target-ppc/translate_init.c

   1 /*
   2  *  PowerPC CPU initialization for qemu.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *  Copyright 2011 Freescale Semiconductor, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "disas/bfd.h"
  23 #include "exec/gdbstub.h"
  24 #include "sysemu/kvm.h"
  25 #include "kvm_ppc.h"
  26 #include "sysemu/arch_init.h"
  27 #include "sysemu/cpus.h"
  28 #include "cpu-models.h"
  29 #include "mmu-hash32.h"
  30 #include "mmu-hash64.h"
  31 #include "qemu/error-report.h"
  32 #include "qapi/visitor.h"
  33 #include "hw/qdev-properties.h"
  34 #include "hw/ppc/ppc.h"
  35
  36 //#define PPC_DUMP_CPU
  37 //#define PPC_DEBUG_SPR
  38 //#define PPC_DUMP_SPR_ACCESSES
  39 /* #define USE_APPLE_GDB */
  40
  41 /* Generic callbacks:
  42  * do nothing but store/retrieve spr value
  43  */
  44 static void spr_load_dump_spr(int sprn)
  45 {
  46 #ifdef PPC_DUMP_SPR_ACCESSES
  47     TCGv_i32 t0 = tcg_const_i32(sprn);
  48     gen_helper_load_dump_spr(cpu_env, t0);
  49     tcg_temp_free_i32(t0);
  50 #endif
  51 }
  52
  53 static void spr_read_generic (DisasContext *ctx, int gprn, int sprn)
  54 {
  55     gen_load_spr(cpu_gpr[gprn], sprn);
  56     spr_load_dump_spr(sprn);
  57 }
  58
  59 static void spr_store_dump_spr(int sprn)
  60 {
  61 #ifdef PPC_DUMP_SPR_ACCESSES
  62     TCGv_i32 t0 = tcg_const_i32(sprn);
  63     gen_helper_store_dump_spr(cpu_env, t0);
  64     tcg_temp_free_i32(t0);
  65 #endif
  66 }
  67
  68 static void spr_write_generic (DisasContext *ctx, int sprn, int gprn)
  69 {
  70     gen_store_spr(sprn, cpu_gpr[gprn]);
  71     spr_store_dump_spr(sprn);
  72 }
  73
  74 #if !defined(CONFIG_USER_ONLY)
  75 static void spr_write_generic32(DisasContext *ctx, int sprn, int gprn)
  76 {
  77 #ifdef TARGET_PPC64
  78     TCGv t0 = tcg_temp_new();
  79     tcg_gen_ext32u_tl(t0, cpu_gpr[gprn]);
  80     gen_store_spr(sprn, t0);
  81     tcg_temp_free(t0);
  82     spr_store_dump_spr(sprn);
  83 #else
  84     spr_write_generic(ctx, sprn, gprn);
  85 #endif
  86 }
  87
  88 static void spr_write_clear (DisasContext *ctx, int sprn, int gprn)
  89 {
  90     TCGv t0 = tcg_temp_new();
  91     TCGv t1 = tcg_temp_new();
  92     gen_load_spr(t0, sprn);
  93     tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
  94     tcg_gen_and_tl(t0, t0, t1);
  95     gen_store_spr(sprn, t0);
  96     tcg_temp_free(t0);
  97     tcg_temp_free(t1);
  98 }
  99
 100 static void spr_access_nop(DisasContext *ctx, int sprn, int gprn)
 101 {
 102 }
 103
 104 #endif
 105
 106 /* SPR common to all PowerPC */
 107 /* XER */
 108 static void spr_read_xer (DisasContext *ctx, int gprn, int sprn)
 109 {
 110     gen_read_xer(cpu_gpr[gprn]);
 111 }
 112
 113 static void spr_write_xer (DisasContext *ctx, int sprn, int gprn)
 114 {
 115     gen_write_xer(cpu_gpr[gprn]);
 116 }
 117
 118 /* LR */
 119 static void spr_read_lr (DisasContext *ctx, int gprn, int sprn)
 120 {
 121     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
 122 }
 123
 124 static void spr_write_lr (DisasContext *ctx, int sprn, int gprn)
 125 {
 126     tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
 127 }
 128
 129 /* CFAR */
 130 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
 131 static void spr_read_cfar (DisasContext *ctx, int gprn, int sprn)
 132 {
 133     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_cfar);
 134 }
 135
 136 static void spr_write_cfar (DisasContext *ctx, int sprn, int gprn)
 137 {
 138     tcg_gen_mov_tl(cpu_cfar, cpu_gpr[gprn]);
 139 }
 140 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */
 141
 142 /* CTR */
 143 static void spr_read_ctr (DisasContext *ctx, int gprn, int sprn)
 144 {
 145     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
 146 }
 147
 148 static void spr_write_ctr (DisasContext *ctx, int sprn, int gprn)
 149 {
 150     tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
 151 }
 152
 153 /* User read access to SPR */
 154 /* USPRx */
 155 /* UMMCRx */
 156 /* UPMCx */
 157 /* USIA */
 158 /* UDECR */
 159 static void spr_read_ureg (DisasContext *ctx, int gprn, int sprn)
 160 {
 161     gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
 162 }
 163
 164 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
 165 static void spr_write_ureg(DisasContext *ctx, int sprn, int gprn)
 166 {
 167     gen_store_spr(sprn + 0x10, cpu_gpr[gprn]);
 168 }
 169 #endif
 170
 171 /* SPR common to all non-embedded PowerPC */
 172 /* DECR */
 173 #if !defined(CONFIG_USER_ONLY)
 174 static void spr_read_decr (DisasContext *ctx, int gprn, int sprn)
 175 {
 176     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 177         gen_io_start();
 178     }
 179     gen_helper_load_decr(cpu_gpr[gprn], cpu_env);
 180     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 181         gen_io_end();
 182         gen_stop_exception(ctx);
 183     }
 184 }
 185
 186 static void spr_write_decr (DisasContext *ctx, int sprn, int gprn)
 187 {
 188     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 189         gen_io_start();
 190     }
 191     gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
 192     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 193         gen_io_end();
 194         gen_stop_exception(ctx);
 195     }
 196 }
 197 #endif
 198
 199 /* SPR common to all non-embedded PowerPC, except 601 */
 200 /* Time base */
 201 static void spr_read_tbl (DisasContext *ctx, int gprn, int sprn)
 202 {
 203     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 204         gen_io_start();
 205     }
 206     gen_helper_load_tbl(cpu_gpr[gprn], cpu_env);
 207     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 208         gen_io_end();
 209         gen_stop_exception(ctx);
 210     }
 211 }
 212
 213 static void spr_read_tbu (DisasContext *ctx, int gprn, int sprn)
 214 {
 215     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 216         gen_io_start();
 217     }
 218     gen_helper_load_tbu(cpu_gpr[gprn], cpu_env);
 219     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 220         gen_io_end();
 221         gen_stop_exception(ctx);
 222     }
 223 }
 224
 225 __attribute__ (( unused ))
 226 static void spr_read_atbl (DisasContext *ctx, int gprn, int sprn)
 227 {
 228     gen_helper_load_atbl(cpu_gpr[gprn], cpu_env);
 229 }
 230
 231 __attribute__ (( unused ))
 232 static void spr_read_atbu (DisasContext *ctx, int gprn, int sprn)
 233 {
 234     gen_helper_load_atbu(cpu_gpr[gprn], cpu_env);
 235 }
 236
 237 #if !defined(CONFIG_USER_ONLY)
 238 static void spr_write_tbl (DisasContext *ctx, int sprn, int gprn)
 239 {
 240     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 241         gen_io_start();
 242     }
 243     gen_helper_store_tbl(cpu_env, cpu_gpr[gprn]);
 244     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 245         gen_io_end();
 246         gen_stop_exception(ctx);
 247     }
 248 }
 249
 250 static void spr_write_tbu (DisasContext *ctx, int sprn, int gprn)
 251 {
 252     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 253         gen_io_start();
 254     }
 255     gen_helper_store_tbu(cpu_env, cpu_gpr[gprn]);
 256     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 257         gen_io_end();
 258         gen_stop_exception(ctx);
 259     }
 260 }
 261
 262 __attribute__ (( unused ))
 263 static void spr_write_atbl (DisasContext *ctx, int sprn, int gprn)
 264 {
 265     gen_helper_store_atbl(cpu_env, cpu_gpr[gprn]);
 266 }
 267
 268 __attribute__ (( unused ))
 269 static void spr_write_atbu (DisasContext *ctx, int sprn, int gprn)
 270 {
 271     gen_helper_store_atbu(cpu_env, cpu_gpr[gprn]);
 272 }
 273
 274 #if defined(TARGET_PPC64)
 275 __attribute__ (( unused ))
 276 static void spr_read_purr (DisasContext *ctx, int gprn, int sprn)
 277 {
 278     gen_helper_load_purr(cpu_gpr[gprn], cpu_env);
 279 }
 280
 281 /* HDECR */
 282 static void spr_read_hdecr(DisasContext *ctx, int gprn, int sprn)
 283 {
 284     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 285         gen_io_start();
 286     }
 287     gen_helper_load_hdecr(cpu_gpr[gprn], cpu_env);
 288     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 289         gen_io_end();
 290         gen_stop_exception(ctx);
 291     }
 292 }
 293
 294 static void spr_write_hdecr(DisasContext *ctx, int sprn, int gprn)
 295 {
 296     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 297         gen_io_start();
 298     }
 299     gen_helper_store_hdecr(cpu_env, cpu_gpr[gprn]);
 300     if (ctx->tb->cflags & CF_USE_ICOUNT) {
 301         gen_io_end();
 302         gen_stop_exception(ctx);
 303     }
 304 }
 305
 306 #endif
 307 #endif
 308
 309 #if !defined(CONFIG_USER_ONLY)
 310 /* IBAT0U...IBAT0U */
 311 /* IBAT0L...IBAT7L */
 312 static void spr_read_ibat (DisasContext *ctx, int gprn, int sprn)
 313 {
 314     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 315 }
 316
 317 static void spr_read_ibat_h (DisasContext *ctx, int gprn, int sprn)
 318 {
 319     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][((sprn - SPR_IBAT4U) / 2) + 4]));
 320 }
 321
 322 static void spr_write_ibatu (DisasContext *ctx, int sprn, int gprn)
 323 {
 324     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 325     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
 326     tcg_temp_free_i32(t0);
 327 }
 328
 329 static void spr_write_ibatu_h (DisasContext *ctx, int sprn, int gprn)
 330 {
 331     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4U) / 2) + 4);
 332     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
 333     tcg_temp_free_i32(t0);
 334 }
 335
 336 static void spr_write_ibatl (DisasContext *ctx, int sprn, int gprn)
 337 {
 338     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0L) / 2);
 339     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
 340     tcg_temp_free_i32(t0);
 341 }
 342
 343 static void spr_write_ibatl_h (DisasContext *ctx, int sprn, int gprn)
 344 {
 345     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4L) / 2) + 4);
 346     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
 347     tcg_temp_free_i32(t0);
 348 }
 349
 350 /* DBAT0U...DBAT7U */
 351 /* DBAT0L...DBAT7L */
 352 static void spr_read_dbat (DisasContext *ctx, int gprn, int sprn)
 353 {
 354     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
 355 }
 356
 357 static void spr_read_dbat_h (DisasContext *ctx, int gprn, int sprn)
 358 {
 359     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
 360 }
 361
 362 static void spr_write_dbatu (DisasContext *ctx, int sprn, int gprn)
 363 {
 364     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0U) / 2);
 365     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
 366     tcg_temp_free_i32(t0);
 367 }
 368
 369 static void spr_write_dbatu_h (DisasContext *ctx, int sprn, int gprn)
 370 {
 371     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4U) / 2) + 4);
 372     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
 373     tcg_temp_free_i32(t0);
 374 }
 375
 376 static void spr_write_dbatl (DisasContext *ctx, int sprn, int gprn)
 377 {
 378     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0L) / 2);
 379     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
 380     tcg_temp_free_i32(t0);
 381 }
 382
 383 static void spr_write_dbatl_h (DisasContext *ctx, int sprn, int gprn)
 384 {
 385     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4L) / 2) + 4);
 386     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
 387     tcg_temp_free_i32(t0);
 388 }
 389
 390 /* SDR1 */
 391 static void spr_write_sdr1 (DisasContext *ctx, int sprn, int gprn)
 392 {
 393     gen_helper_store_sdr1(cpu_env, cpu_gpr[gprn]);
 394 }
 395
 396 /* 64 bits PowerPC specific SPRs */
 397 #if defined(TARGET_PPC64)
 398 static void spr_read_hior (DisasContext *ctx, int gprn, int sprn)
 399 {
 400     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, excp_prefix));
 401 }
 402
 403 static void spr_write_hior (DisasContext *ctx, int sprn, int gprn)
 404 {
 405     TCGv t0 = tcg_temp_new();
 406     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
 407     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
 408     tcg_temp_free(t0);
 409 }
 410 #endif
 411 #endif
 412
 413 /* PowerPC 601 specific registers */
 414 /* RTC */
 415 static void spr_read_601_rtcl (DisasContext *ctx, int gprn, int sprn)
 416 {
 417     gen_helper_load_601_rtcl(cpu_gpr[gprn], cpu_env);
 418 }
 419
 420 static void spr_read_601_rtcu (DisasContext *ctx, int gprn, int sprn)
 421 {
 422     gen_helper_load_601_rtcu(cpu_gpr[gprn], cpu_env);
 423 }
 424
 425 #if !defined(CONFIG_USER_ONLY)
 426 static void spr_write_601_rtcu (DisasContext *ctx, int sprn, int gprn)
 427 {
 428     gen_helper_store_601_rtcu(cpu_env, cpu_gpr[gprn]);
 429 }
 430
 431 static void spr_write_601_rtcl (DisasContext *ctx, int sprn, int gprn)
 432 {
 433     gen_helper_store_601_rtcl(cpu_env, cpu_gpr[gprn]);
 434 }
 435
 436 static void spr_write_hid0_601 (DisasContext *ctx, int sprn, int gprn)
 437 {
 438     gen_helper_store_hid0_601(cpu_env, cpu_gpr[gprn]);
 439     /* Must stop the translation as endianness may have changed */
 440     gen_stop_exception(ctx);
 441 }
 442 #endif
 443
 444 /* Unified bats */
 445 #if !defined(CONFIG_USER_ONLY)
 446 static void spr_read_601_ubat (DisasContext *ctx, int gprn, int sprn)
 447 {
 448     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 449 }
 450
 451 static void spr_write_601_ubatu (DisasContext *ctx, int sprn, int gprn)
 452 {
 453     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 454     gen_helper_store_601_batl(cpu_env, t0, cpu_gpr[gprn]);
 455     tcg_temp_free_i32(t0);
 456 }
 457
 458 static void spr_write_601_ubatl (DisasContext *ctx, int sprn, int gprn)
 459 {
 460     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 461     gen_helper_store_601_batu(cpu_env, t0, cpu_gpr[gprn]);
 462     tcg_temp_free_i32(t0);
 463 }
 464 #endif
 465
 466 /* PowerPC 40x specific registers */
 467 #if !defined(CONFIG_USER_ONLY)
 468 static void spr_read_40x_pit (DisasContext *ctx, int gprn, int sprn)
 469 {
 470     gen_helper_load_40x_pit(cpu_gpr[gprn], cpu_env);
 471 }
 472
 473 static void spr_write_40x_pit (DisasContext *ctx, int sprn, int gprn)
 474 {
 475     gen_helper_store_40x_pit(cpu_env, cpu_gpr[gprn]);
 476 }
 477
 478 static void spr_write_40x_dbcr0 (DisasContext *ctx, int sprn, int gprn)
 479 {
 480     gen_helper_store_40x_dbcr0(cpu_env, cpu_gpr[gprn]);
 481     /* We must stop translation as we may have rebooted */
 482     gen_stop_exception(ctx);
 483 }
 484
 485 static void spr_write_40x_sler (DisasContext *ctx, int sprn, int gprn)
 486 {
 487     gen_helper_store_40x_sler(cpu_env, cpu_gpr[gprn]);
 488 }
 489
 490 static void spr_write_booke_tcr (DisasContext *ctx, int sprn, int gprn)
 491 {
 492     gen_helper_store_booke_tcr(cpu_env, cpu_gpr[gprn]);
 493 }
 494
 495 static void spr_write_booke_tsr (DisasContext *ctx, int sprn, int gprn)
 496 {
 497     gen_helper_store_booke_tsr(cpu_env, cpu_gpr[gprn]);
 498 }
 499 #endif
 500
 501 /* PowerPC 403 specific registers */
 502 /* PBL1 / PBU1 / PBL2 / PBU2 */
 503 #if !defined(CONFIG_USER_ONLY)
 504 static void spr_read_403_pbr (DisasContext *ctx, int gprn, int sprn)
 505 {
 506     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, pb[sprn - SPR_403_PBL1]));
 507 }
 508
 509 static void spr_write_403_pbr (DisasContext *ctx, int sprn, int gprn)
 510 {
 511     TCGv_i32 t0 = tcg_const_i32(sprn - SPR_403_PBL1);
 512     gen_helper_store_403_pbr(cpu_env, t0, cpu_gpr[gprn]);
 513     tcg_temp_free_i32(t0);
 514 }
 515
 516 static void spr_write_pir (DisasContext *ctx, int sprn, int gprn)
 517 {
 518     TCGv t0 = tcg_temp_new();
 519     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
 520     gen_store_spr(SPR_PIR, t0);
 521     tcg_temp_free(t0);
 522 }
 523 #endif
 524
 525 /* SPE specific registers */
 526 static void spr_read_spefscr (DisasContext *ctx, int gprn, int sprn)
 527 {
 528     TCGv_i32 t0 = tcg_temp_new_i32();
 529     tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
 530     tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);
 531     tcg_temp_free_i32(t0);
 532 }
 533
 534 static void spr_write_spefscr (DisasContext *ctx, int sprn, int gprn)
 535 {
 536     TCGv_i32 t0 = tcg_temp_new_i32();
 537     tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);
 538     tcg_gen_st_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
 539     tcg_temp_free_i32(t0);
 540 }
 541
 542 #if !defined(CONFIG_USER_ONLY)
 543 /* Callback used to write the exception vector base */
 544 static void spr_write_excp_prefix (DisasContext *ctx, int sprn, int gprn)
 545 {
 546     TCGv t0 = tcg_temp_new();
 547     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivpr_mask));
 548     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 549     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
 550     gen_store_spr(sprn, t0);
 551     tcg_temp_free(t0);
 552 }
 553
 554 static void spr_write_excp_vector (DisasContext *ctx, int sprn, int gprn)
 555 {
 556     int sprn_offs;
 557
 558     if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
 559         sprn_offs = sprn - SPR_BOOKE_IVOR0;
 560     } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
 561         sprn_offs = sprn - SPR_BOOKE_IVOR32 + 32;
 562     } else if (sprn >= SPR_BOOKE_IVOR38 && sprn <= SPR_BOOKE_IVOR42) {
 563         sprn_offs = sprn - SPR_BOOKE_IVOR38 + 38;
 564     } else {
 565         printf("Trying to write an unknown exception vector %d %03x\n",
 566                sprn, sprn);
 567         gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
 568         return;
 569     }
 570
 571     TCGv t0 = tcg_temp_new();
 572     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivor_mask));
 573     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 574     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_vectors[sprn_offs]));
 575     gen_store_spr(sprn, t0);
 576     tcg_temp_free(t0);
 577 }
 578 #endif
 579
 580 static inline void vscr_init (CPUPPCState *env, uint32_t val)
 581 {
 582     env->vscr = val;
 583     /* Altivec always uses round-to-nearest */
 584     set_float_rounding_mode(float_round_nearest_even, &env->vec_status);
 585     set_flush_to_zero(vscr_nj, &env->vec_status);
 586 }
 587
 588 #ifdef CONFIG_USER_ONLY
 589 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
 590                          oea_read, oea_write, one_reg_id, initial_value)       \
 591     _spr_register(env, num, name, uea_read, uea_write, initial_value)
 592 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
 593                             oea_read, oea_write, hea_read, hea_write,          \
 594                             one_reg_id, initial_value)                         \
 595     _spr_register(env, num, name, uea_read, uea_write, initial_value)
 596 #else
 597 #if !defined(CONFIG_KVM)
 598 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
 599                          oea_read, oea_write, one_reg_id, initial_value)       \
 600     _spr_register(env, num, name, uea_read, uea_write,                         \
 601                   oea_read, oea_write, oea_read, oea_write, initial_value)
 602 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
 603                             oea_read, oea_write, hea_read, hea_write,          \
 604                             one_reg_id, initial_value)                         \
 605     _spr_register(env, num, name, uea_read, uea_write,                         \
 606                   oea_read, oea_write, hea_read, hea_write, initial_value)
 607 #else
 608 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
 609                          oea_read, oea_write, one_reg_id, initial_value)       \
 610     _spr_register(env, num, name, uea_read, uea_write,                         \
 611                   oea_read, oea_write, oea_read, oea_write,                    \
 612                   one_reg_id, initial_value)
 613 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
 614                             oea_read, oea_write, hea_read, hea_write,          \
 615                             one_reg_id, initial_value)                         \
 616     _spr_register(env, num, name, uea_read, uea_write,                         \
 617                   oea_read, oea_write, hea_read, hea_write,                    \
 618                   one_reg_id, initial_value)
 619 #endif
 620 #endif
 621
 622 #define spr_register(env, num, name, uea_read, uea_write,                      \
 623                      oea_read, oea_write, initial_value)                       \
 624     spr_register_kvm(env, num, name, uea_read, uea_write,                      \
 625                      oea_read, oea_write, 0, initial_value)
 626
 627 #define spr_register_hv(env, num, name, uea_read, uea_write,                   \
 628                         oea_read, oea_write, hea_read, hea_write,              \
 629                         initial_value)                                         \
 630     spr_register_kvm_hv(env, num, name, uea_read, uea_write,                   \
 631                         oea_read, oea_write, hea_read, hea_write,              \
 632                         0, initial_value)
 633
 634 static inline void _spr_register(CPUPPCState *env, int num,
 635                                  const char *name,
 636                                  void (*uea_read)(DisasContext *ctx, int gprn, int sprn),
 637                                  void (*uea_write)(DisasContext *ctx, int sprn, int gprn),
 638 #if !defined(CONFIG_USER_ONLY)
 639
 640                                  void (*oea_read)(DisasContext *ctx, int gprn, int sprn),
 641                                  void (*oea_write)(DisasContext *ctx, int sprn, int gprn),
 642                                  void (*hea_read)(DisasContext *opaque, int gprn, int sprn),
 643                                  void (*hea_write)(DisasContext *opaque, int sprn, int gprn),
 644 #endif
 645 #if defined(CONFIG_KVM)
 646                                  uint64_t one_reg_id,
 647 #endif
 648                                  target_ulong initial_value)
 649 {
 650     ppc_spr_t *spr;
 651
 652     spr = &env->spr_cb[num];
 653     if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||
 654 #if !defined(CONFIG_USER_ONLY)
 655         spr->oea_read != NULL || spr->oea_write != NULL ||
 656 #endif
 657         spr->uea_read != NULL || spr->uea_write != NULL) {
 658         printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
 659         exit(1);
 660     }
 661 #if defined(PPC_DEBUG_SPR)
 662     printf("*** register spr %d (%03x) %s val " TARGET_FMT_lx "\n", num, num,
 663            name, initial_value);
 664 #endif
 665     spr->name = name;
 666     spr->uea_read = uea_read;
 667     spr->uea_write = uea_write;
 668 #if !defined(CONFIG_USER_ONLY)
 669     spr->oea_read = oea_read;
 670     spr->oea_write = oea_write;
 671     spr->hea_read = hea_read;
 672     spr->hea_write = hea_write;
 673 #endif
 674 #if defined(CONFIG_KVM)
 675     spr->one_reg_id = one_reg_id,
 676 #endif
 677     env->spr[num] = spr->default_value = initial_value;
 678 }
 679
 680 /* Generic PowerPC SPRs */
 681 static void gen_spr_generic (CPUPPCState *env)
 682 {
 683     /* Integer processing */
 684     spr_register(env, SPR_XER, "XER",
 685                  &spr_read_xer, &spr_write_xer,
 686                  &spr_read_xer, &spr_write_xer,
 687                  0x00000000);
 688     /* Branch contol */
 689     spr_register(env, SPR_LR, "LR",
 690                  &spr_read_lr, &spr_write_lr,
 691                  &spr_read_lr, &spr_write_lr,
 692                  0x00000000);
 693     spr_register(env, SPR_CTR, "CTR",
 694                  &spr_read_ctr, &spr_write_ctr,
 695                  &spr_read_ctr, &spr_write_ctr,
 696                  0x00000000);
 697     /* Interrupt processing */
 698     spr_register(env, SPR_SRR0, "SRR0",
 699                  SPR_NOACCESS, SPR_NOACCESS,
 700                  &spr_read_generic, &spr_write_generic,
 701                  0x00000000);
 702     spr_register(env, SPR_SRR1, "SRR1",
 703                  SPR_NOACCESS, SPR_NOACCESS,
 704                  &spr_read_generic, &spr_write_generic,
 705                  0x00000000);
 706     /* Processor control */
 707     spr_register(env, SPR_SPRG0, "SPRG0",
 708                  SPR_NOACCESS, SPR_NOACCESS,
 709                  &spr_read_generic, &spr_write_generic,
 710                  0x00000000);
 711     spr_register(env, SPR_SPRG1, "SPRG1",
 712                  SPR_NOACCESS, SPR_NOACCESS,
 713                  &spr_read_generic, &spr_write_generic,
 714                  0x00000000);
 715     spr_register(env, SPR_SPRG2, "SPRG2",
 716                  SPR_NOACCESS, SPR_NOACCESS,
 717                  &spr_read_generic, &spr_write_generic,
 718                  0x00000000);
 719     spr_register(env, SPR_SPRG3, "SPRG3",
 720                  SPR_NOACCESS, SPR_NOACCESS,
 721                  &spr_read_generic, &spr_write_generic,
 722                  0x00000000);
 723 }
 724
 725 /* SPR common to all non-embedded PowerPC, including 601 */
 726 static void gen_spr_ne_601 (CPUPPCState *env)
 727 {
 728     /* Exception processing */
 729     spr_register_kvm(env, SPR_DSISR, "DSISR",
 730                      SPR_NOACCESS, SPR_NOACCESS,
 731                      &spr_read_generic, &spr_write_generic,
 732                      KVM_REG_PPC_DSISR, 0x00000000);
 733     spr_register_kvm(env, SPR_DAR, "DAR",
 734                      SPR_NOACCESS, SPR_NOACCESS,
 735                      &spr_read_generic, &spr_write_generic,
 736                      KVM_REG_PPC_DAR, 0x00000000);
 737     /* Timer */
 738     spr_register(env, SPR_DECR, "DECR",
 739                  SPR_NOACCESS, SPR_NOACCESS,
 740                  &spr_read_decr, &spr_write_decr,
 741                  0x00000000);
 742     /* Memory management */
 743     spr_register(env, SPR_SDR1, "SDR1",
 744                  SPR_NOACCESS, SPR_NOACCESS,
 745                  &spr_read_generic, &spr_write_sdr1,
 746                  0x00000000);
 747 }
 748
 749 /* BATs 0-3 */
 750 static void gen_low_BATs (CPUPPCState *env)
 751 {
 752 #if !defined(CONFIG_USER_ONLY)
 753     spr_register(env, SPR_IBAT0U, "IBAT0U",
 754                  SPR_NOACCESS, SPR_NOACCESS,
 755                  &spr_read_ibat, &spr_write_ibatu,
 756                  0x00000000);
 757     spr_register(env, SPR_IBAT0L, "IBAT0L",
 758                  SPR_NOACCESS, SPR_NOACCESS,
 759                  &spr_read_ibat, &spr_write_ibatl,
 760                  0x00000000);
 761     spr_register(env, SPR_IBAT1U, "IBAT1U",
 762                  SPR_NOACCESS, SPR_NOACCESS,
 763                  &spr_read_ibat, &spr_write_ibatu,
 764                  0x00000000);
 765     spr_register(env, SPR_IBAT1L, "IBAT1L",
 766                  SPR_NOACCESS, SPR_NOACCESS,
 767                  &spr_read_ibat, &spr_write_ibatl,
 768                  0x00000000);
 769     spr_register(env, SPR_IBAT2U, "IBAT2U",
 770                  SPR_NOACCESS, SPR_NOACCESS,
 771                  &spr_read_ibat, &spr_write_ibatu,
 772                  0x00000000);
 773     spr_register(env, SPR_IBAT2L, "IBAT2L",
 774                  SPR_NOACCESS, SPR_NOACCESS,
 775                  &spr_read_ibat, &spr_write_ibatl,
 776                  0x00000000);
 777     spr_register(env, SPR_IBAT3U, "IBAT3U",
 778                  SPR_NOACCESS, SPR_NOACCESS,
 779                  &spr_read_ibat, &spr_write_ibatu,
 780                  0x00000000);
 781     spr_register(env, SPR_IBAT3L, "IBAT3L",
 782                  SPR_NOACCESS, SPR_NOACCESS,
 783                  &spr_read_ibat, &spr_write_ibatl,
 784                  0x00000000);
 785     spr_register(env, SPR_DBAT0U, "DBAT0U",
 786                  SPR_NOACCESS, SPR_NOACCESS,
 787                  &spr_read_dbat, &spr_write_dbatu,
 788                  0x00000000);
 789     spr_register(env, SPR_DBAT0L, "DBAT0L",
 790                  SPR_NOACCESS, SPR_NOACCESS,
 791                  &spr_read_dbat, &spr_write_dbatl,
 792                  0x00000000);
 793     spr_register(env, SPR_DBAT1U, "DBAT1U",
 794                  SPR_NOACCESS, SPR_NOACCESS,
 795                  &spr_read_dbat, &spr_write_dbatu,
 796                  0x00000000);
 797     spr_register(env, SPR_DBAT1L, "DBAT1L",
 798                  SPR_NOACCESS, SPR_NOACCESS,
 799                  &spr_read_dbat, &spr_write_dbatl,
 800                  0x00000000);
 801     spr_register(env, SPR_DBAT2U, "DBAT2U",
 802                  SPR_NOACCESS, SPR_NOACCESS,
 803                  &spr_read_dbat, &spr_write_dbatu,
 804                  0x00000000);
 805     spr_register(env, SPR_DBAT2L, "DBAT2L",
 806                  SPR_NOACCESS, SPR_NOACCESS,
 807                  &spr_read_dbat, &spr_write_dbatl,
 808                  0x00000000);
 809     spr_register(env, SPR_DBAT3U, "DBAT3U",
 810                  SPR_NOACCESS, SPR_NOACCESS,
 811                  &spr_read_dbat, &spr_write_dbatu,
 812                  0x00000000);
 813     spr_register(env, SPR_DBAT3L, "DBAT3L",
 814                  SPR_NOACCESS, SPR_NOACCESS,
 815                  &spr_read_dbat, &spr_write_dbatl,
 816                  0x00000000);
 817     env->nb_BATs += 4;
 818 #endif
 819 }
 820
 821 /* BATs 4-7 */
 822 static void gen_high_BATs (CPUPPCState *env)
 823 {
 824 #if !defined(CONFIG_USER_ONLY)
 825     spr_register(env, SPR_IBAT4U, "IBAT4U",
 826                  SPR_NOACCESS, SPR_NOACCESS,
 827                  &spr_read_ibat_h, &spr_write_ibatu_h,
 828                  0x00000000);
 829     spr_register(env, SPR_IBAT4L, "IBAT4L",
 830                  SPR_NOACCESS, SPR_NOACCESS,
 831                  &spr_read_ibat_h, &spr_write_ibatl_h,
 832                  0x00000000);
 833     spr_register(env, SPR_IBAT5U, "IBAT5U",
 834                  SPR_NOACCESS, SPR_NOACCESS,
 835                  &spr_read_ibat_h, &spr_write_ibatu_h,
 836                  0x00000000);
 837     spr_register(env, SPR_IBAT5L, "IBAT5L",
 838                  SPR_NOACCESS, SPR_NOACCESS,
 839                  &spr_read_ibat_h, &spr_write_ibatl_h,
 840                  0x00000000);
 841     spr_register(env, SPR_IBAT6U, "IBAT6U",
 842                  SPR_NOACCESS, SPR_NOACCESS,
 843                  &spr_read_ibat_h, &spr_write_ibatu_h,
 844                  0x00000000);
 845     spr_register(env, SPR_IBAT6L, "IBAT6L",
 846                  SPR_NOACCESS, SPR_NOACCESS,
 847                  &spr_read_ibat_h, &spr_write_ibatl_h,
 848                  0x00000000);
 849     spr_register(env, SPR_IBAT7U, "IBAT7U",
 850                  SPR_NOACCESS, SPR_NOACCESS,
 851                  &spr_read_ibat_h, &spr_write_ibatu_h,
 852                  0x00000000);
 853     spr_register(env, SPR_IBAT7L, "IBAT7L",
 854                  SPR_NOACCESS, SPR_NOACCESS,
 855                  &spr_read_ibat_h, &spr_write_ibatl_h,
 856                  0x00000000);
 857     spr_register(env, SPR_DBAT4U, "DBAT4U",
 858                  SPR_NOACCESS, SPR_NOACCESS,
 859                  &spr_read_dbat_h, &spr_write_dbatu_h,
 860                  0x00000000);
 861     spr_register(env, SPR_DBAT4L, "DBAT4L",
 862                  SPR_NOACCESS, SPR_NOACCESS,
 863                  &spr_read_dbat_h, &spr_write_dbatl_h,
 864                  0x00000000);
 865     spr_register(env, SPR_DBAT5U, "DBAT5U",
 866                  SPR_NOACCESS, SPR_NOACCESS,
 867                  &spr_read_dbat_h, &spr_write_dbatu_h,
 868                  0x00000000);
 869     spr_register(env, SPR_DBAT5L, "DBAT5L",
 870                  SPR_NOACCESS, SPR_NOACCESS,
 871                  &spr_read_dbat_h, &spr_write_dbatl_h,
 872                  0x00000000);
 873     spr_register(env, SPR_DBAT6U, "DBAT6U",
 874                  SPR_NOACCESS, SPR_NOACCESS,
 875                  &spr_read_dbat_h, &spr_write_dbatu_h,
 876                  0x00000000);
 877     spr_register(env, SPR_DBAT6L, "DBAT6L",
 878                  SPR_NOACCESS, SPR_NOACCESS,
 879                  &spr_read_dbat_h, &spr_write_dbatl_h,
 880                  0x00000000);
 881     spr_register(env, SPR_DBAT7U, "DBAT7U",
 882                  SPR_NOACCESS, SPR_NOACCESS,
 883                  &spr_read_dbat_h, &spr_write_dbatu_h,
 884                  0x00000000);
 885     spr_register(env, SPR_DBAT7L, "DBAT7L",
 886                  SPR_NOACCESS, SPR_NOACCESS,
 887                  &spr_read_dbat_h, &spr_write_dbatl_h,
 888                  0x00000000);
 889     env->nb_BATs += 4;
 890 #endif
 891 }
 892
 893 /* Generic PowerPC time base */
 894 static void gen_tbl (CPUPPCState *env)
 895 {
 896     spr_register(env, SPR_VTBL,  "TBL",
 897                  &spr_read_tbl, SPR_NOACCESS,
 898                  &spr_read_tbl, SPR_NOACCESS,
 899                  0x00000000);
 900     spr_register(env, SPR_TBL,   "TBL",
 901                  &spr_read_tbl, SPR_NOACCESS,
 902                  &spr_read_tbl, &spr_write_tbl,
 903                  0x00000000);
 904     spr_register(env, SPR_VTBU,  "TBU",
 905                  &spr_read_tbu, SPR_NOACCESS,
 906                  &spr_read_tbu, SPR_NOACCESS,
 907                  0x00000000);
 908     spr_register(env, SPR_TBU,   "TBU",
 909                  &spr_read_tbu, SPR_NOACCESS,
 910                  &spr_read_tbu, &spr_write_tbu,
 911                  0x00000000);
 912 }
 913
 914 /* Softare table search registers */
 915 static void gen_6xx_7xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
 916 {
 917 #if !defined(CONFIG_USER_ONLY)
 918     env->nb_tlb = nb_tlbs;
 919     env->nb_ways = nb_ways;
 920     env->id_tlbs = 1;
 921     env->tlb_type = TLB_6XX;
 922     spr_register(env, SPR_DMISS, "DMISS",
 923                  SPR_NOACCESS, SPR_NOACCESS,
 924                  &spr_read_generic, SPR_NOACCESS,
 925                  0x00000000);
 926     spr_register(env, SPR_DCMP, "DCMP",
 927                  SPR_NOACCESS, SPR_NOACCESS,
 928                  &spr_read_generic, SPR_NOACCESS,
 929                  0x00000000);
 930     spr_register(env, SPR_HASH1, "HASH1",
 931                  SPR_NOACCESS, SPR_NOACCESS,
 932                  &spr_read_generic, SPR_NOACCESS,
 933                  0x00000000);
 934     spr_register(env, SPR_HASH2, "HASH2",
 935                  SPR_NOACCESS, SPR_NOACCESS,
 936                  &spr_read_generic, SPR_NOACCESS,
 937                  0x00000000);
 938     spr_register(env, SPR_IMISS, "IMISS",
 939                  SPR_NOACCESS, SPR_NOACCESS,
 940                  &spr_read_generic, SPR_NOACCESS,
 941                  0x00000000);
 942     spr_register(env, SPR_ICMP, "ICMP",
 943                  SPR_NOACCESS, SPR_NOACCESS,
 944                  &spr_read_generic, SPR_NOACCESS,
 945                  0x00000000);
 946     spr_register(env, SPR_RPA, "RPA",
 947                  SPR_NOACCESS, SPR_NOACCESS,
 948                  &spr_read_generic, &spr_write_generic,
 949                  0x00000000);
 950 #endif
 951 }
 952
 953 /* SPR common to MPC755 and G2 */
 954 static void gen_spr_G2_755 (CPUPPCState *env)
 955 {
 956     /* SGPRs */
 957     spr_register(env, SPR_SPRG4, "SPRG4",
 958                  SPR_NOACCESS, SPR_NOACCESS,
 959                  &spr_read_generic, &spr_write_generic,
 960                  0x00000000);
 961     spr_register(env, SPR_SPRG5, "SPRG5",
 962                  SPR_NOACCESS, SPR_NOACCESS,
 963                  &spr_read_generic, &spr_write_generic,
 964                  0x00000000);
 965     spr_register(env, SPR_SPRG6, "SPRG6",
 966                  SPR_NOACCESS, SPR_NOACCESS,
 967                  &spr_read_generic, &spr_write_generic,
 968                  0x00000000);
 969     spr_register(env, SPR_SPRG7, "SPRG7",
 970                  SPR_NOACCESS, SPR_NOACCESS,
 971                  &spr_read_generic, &spr_write_generic,
 972                  0x00000000);
 973 }
 974
 975 /* SPR common to all 7xx PowerPC implementations */
 976 static void gen_spr_7xx (CPUPPCState *env)
 977 {
 978     /* Breakpoints */
 979     /* XXX : not implemented */
 980     spr_register_kvm(env, SPR_DABR, "DABR",
 981                      SPR_NOACCESS, SPR_NOACCESS,
 982                      &spr_read_generic, &spr_write_generic,
 983                      KVM_REG_PPC_DABR, 0x00000000);
 984     /* XXX : not implemented */
 985     spr_register(env, SPR_IABR, "IABR",
 986                  SPR_NOACCESS, SPR_NOACCESS,
 987                  &spr_read_generic, &spr_write_generic,
 988                  0x00000000);
 989     /* Cache management */
 990     /* XXX : not implemented */
 991     spr_register(env, SPR_ICTC, "ICTC",
 992                  SPR_NOACCESS, SPR_NOACCESS,
 993                  &spr_read_generic, &spr_write_generic,
 994                  0x00000000);
 995     /* Performance monitors */
 996     /* XXX : not implemented */
 997     spr_register(env, SPR_7XX_MMCR0, "MMCR0",
 998                  SPR_NOACCESS, SPR_NOACCESS,
 999                  &spr_read_generic, &spr_write_generic,
1000                  0x00000000);
1001     /* XXX : not implemented */
1002     spr_register(env, SPR_7XX_MMCR1, "MMCR1",
1003                  SPR_NOACCESS, SPR_NOACCESS,
1004                  &spr_read_generic, &spr_write_generic,
1005                  0x00000000);
1006     /* XXX : not implemented */
1007     spr_register(env, SPR_7XX_PMC1, "PMC1",
1008                  SPR_NOACCESS, SPR_NOACCESS,
1009                  &spr_read_generic, &spr_write_generic,
1010                  0x00000000);
1011     /* XXX : not implemented */
1012     spr_register(env, SPR_7XX_PMC2, "PMC2",
1013                  SPR_NOACCESS, SPR_NOACCESS,
1014                  &spr_read_generic, &spr_write_generic,
1015                  0x00000000);
1016     /* XXX : not implemented */
1017     spr_register(env, SPR_7XX_PMC3, "PMC3",
1018                  SPR_NOACCESS, SPR_NOACCESS,
1019                  &spr_read_generic, &spr_write_generic,
1020                  0x00000000);
1021     /* XXX : not implemented */
1022     spr_register(env, SPR_7XX_PMC4, "PMC4",
1023                  SPR_NOACCESS, SPR_NOACCESS,
1024                  &spr_read_generic, &spr_write_generic,
1025                  0x00000000);
1026     /* XXX : not implemented */
1027     spr_register(env, SPR_7XX_SIAR, "SIAR",
1028                  SPR_NOACCESS, SPR_NOACCESS,
1029                  &spr_read_generic, SPR_NOACCESS,
1030                  0x00000000);
1031     /* XXX : not implemented */
1032     spr_register(env, SPR_7XX_UMMCR0, "UMMCR0",
1033                  &spr_read_ureg, SPR_NOACCESS,
1034                  &spr_read_ureg, SPR_NOACCESS,
1035                  0x00000000);
1036     /* XXX : not implemented */
1037     spr_register(env, SPR_7XX_UMMCR1, "UMMCR1",
1038                  &spr_read_ureg, SPR_NOACCESS,
1039                  &spr_read_ureg, SPR_NOACCESS,
1040                  0x00000000);
1041     /* XXX : not implemented */
1042     spr_register(env, SPR_7XX_UPMC1, "UPMC1",
1043                  &spr_read_ureg, SPR_NOACCESS,
1044                  &spr_read_ureg, SPR_NOACCESS,
1045                  0x00000000);
1046     /* XXX : not implemented */
1047     spr_register(env, SPR_7XX_UPMC2, "UPMC2",
1048                  &spr_read_ureg, SPR_NOACCESS,
1049                  &spr_read_ureg, SPR_NOACCESS,
1050                  0x00000000);
1051     /* XXX : not implemented */
1052     spr_register(env, SPR_7XX_UPMC3, "UPMC3",
1053                  &spr_read_ureg, SPR_NOACCESS,
1054                  &spr_read_ureg, SPR_NOACCESS,
1055                  0x00000000);
1056     /* XXX : not implemented */
1057     spr_register(env, SPR_7XX_UPMC4, "UPMC4",
1058                  &spr_read_ureg, SPR_NOACCESS,
1059                  &spr_read_ureg, SPR_NOACCESS,
1060                  0x00000000);
1061     /* XXX : not implemented */
1062     spr_register(env, SPR_7XX_USIAR, "USIAR",
1063                  &spr_read_ureg, SPR_NOACCESS,
1064                  &spr_read_ureg, SPR_NOACCESS,
1065                  0x00000000);
1066     /* External access control */
1067     /* XXX : not implemented */
1068     spr_register(env, SPR_EAR, "EAR",
1069                  SPR_NOACCESS, SPR_NOACCESS,
1070                  &spr_read_generic, &spr_write_generic,
1071                  0x00000000);
1072 }
1073
1074 #ifdef TARGET_PPC64
1075 #ifndef CONFIG_USER_ONLY
1076 static void spr_write_amr(DisasContext *ctx, int sprn, int gprn)
1077 {
1078     TCGv t0 = tcg_temp_new();
1079     TCGv t1 = tcg_temp_new();
1080     TCGv t2 = tcg_temp_new();
1081
1082     /* Note, the HV=1 PR=0 case is handled earlier by simply using
1083      * spr_write_generic for HV mode in the SPR table
1084      */
1085
1086     /* Build insertion mask into t1 based on context */
1087     if (ctx->pr) {
1088         gen_load_spr(t1, SPR_UAMOR);
1089     } else {
1090         gen_load_spr(t1, SPR_AMOR);
1091     }
1092
1093     /* Mask new bits into t2 */
1094     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1095
1096     /* Load AMR and clear new bits in t0 */
1097     gen_load_spr(t0, SPR_AMR);
1098     tcg_gen_andc_tl(t0, t0, t1);
1099
1100     /* Or'in new bits and write it out */
1101     tcg_gen_or_tl(t0, t0, t2);
1102     gen_store_spr(SPR_AMR, t0);
1103     spr_store_dump_spr(SPR_AMR);
1104
1105     tcg_temp_free(t0);
1106     tcg_temp_free(t1);
1107     tcg_temp_free(t2);
1108 }
1109
1110 static void spr_write_uamor(DisasContext *ctx, int sprn, int gprn)
1111 {
1112     TCGv t0 = tcg_temp_new();
1113     TCGv t1 = tcg_temp_new();
1114     TCGv t2 = tcg_temp_new();
1115
1116     /* Note, the HV=1 case is handled earlier by simply using
1117      * spr_write_generic for HV mode in the SPR table
1118      */
1119
1120     /* Build insertion mask into t1 based on context */
1121     gen_load_spr(t1, SPR_AMOR);
1122
1123     /* Mask new bits into t2 */
1124     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1125
1126     /* Load AMR and clear new bits in t0 */
1127     gen_load_spr(t0, SPR_UAMOR);
1128     tcg_gen_andc_tl(t0, t0, t1);
1129
1130     /* Or'in new bits and write it out */
1131     tcg_gen_or_tl(t0, t0, t2);
1132     gen_store_spr(SPR_UAMOR, t0);
1133     spr_store_dump_spr(SPR_UAMOR);
1134
1135     tcg_temp_free(t0);
1136     tcg_temp_free(t1);
1137     tcg_temp_free(t2);
1138 }
1139
1140 static void spr_write_iamr(DisasContext *ctx, int sprn, int gprn)
1141 {
1142     TCGv t0 = tcg_temp_new();
1143     TCGv t1 = tcg_temp_new();
1144     TCGv t2 = tcg_temp_new();
1145
1146     /* Note, the HV=1 case is handled earlier by simply using
1147      * spr_write_generic for HV mode in the SPR table
1148      */
1149
1150     /* Build insertion mask into t1 based on context */
1151     gen_load_spr(t1, SPR_AMOR);
1152
1153     /* Mask new bits into t2 */
1154     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1155
1156     /* Load AMR and clear new bits in t0 */
1157     gen_load_spr(t0, SPR_IAMR);
1158     tcg_gen_andc_tl(t0, t0, t1);
1159
1160     /* Or'in new bits and write it out */
1161     tcg_gen_or_tl(t0, t0, t2);
1162     gen_store_spr(SPR_IAMR, t0);
1163     spr_store_dump_spr(SPR_IAMR);
1164
1165     tcg_temp_free(t0);
1166     tcg_temp_free(t1);
1167     tcg_temp_free(t2);
1168 }
1169 #endif /* CONFIG_USER_ONLY */
1170
1171 static void gen_spr_amr(CPUPPCState *env, bool has_iamr)
1172 {
1173 #ifndef CONFIG_USER_ONLY
1174     /* Virtual Page Class Key protection */
1175     /* The AMR is accessible either via SPR 13 or SPR 29.  13 is
1176      * userspace accessible, 29 is privileged.  So we only need to set
1177      * the kvm ONE_REG id on one of them, we use 29 */
1178     spr_register(env, SPR_UAMR, "UAMR",
1179                  &spr_read_generic, &spr_write_amr,
1180                  &spr_read_generic, &spr_write_amr,
1181                  0);
1182     spr_register_kvm_hv(env, SPR_AMR, "AMR",
1183                      SPR_NOACCESS, SPR_NOACCESS,
1184                      &spr_read_generic, &spr_write_amr,
1185                      &spr_read_generic, &spr_write_generic,
1186                      KVM_REG_PPC_AMR, 0);
1187     spr_register_kvm_hv(env, SPR_UAMOR, "UAMOR",
1188                      SPR_NOACCESS, SPR_NOACCESS,
1189                      &spr_read_generic, &spr_write_uamor,
1190                      &spr_read_generic, &spr_write_generic,
1191                      KVM_REG_PPC_UAMOR, 0);
1192     spr_register_hv(env, SPR_AMOR, "AMOR",
1193                     SPR_NOACCESS, SPR_NOACCESS,
1194                     SPR_NOACCESS, SPR_NOACCESS,
1195                     &spr_read_generic, &spr_write_generic,
1196                     0);
1197     if (has_iamr) {
1198         spr_register_kvm_hv(env, SPR_IAMR, "IAMR",
1199                             SPR_NOACCESS, SPR_NOACCESS,
1200                             &spr_read_generic, &spr_write_iamr,
1201                             &spr_read_generic, &spr_write_generic,
1202                             KVM_REG_PPC_IAMR, 0);
1203     }
1204 #endif /* !CONFIG_USER_ONLY */
1205 }
1206 #endif /* TARGET_PPC64 */
1207
1208 #ifndef CONFIG_USER_ONLY
1209 static void spr_read_thrm(DisasContext *ctx, int gprn, int sprn)
1210 {
1211     gen_helper_fixup_thrm(cpu_env);
1212     gen_load_spr(cpu_gpr[gprn], sprn);
1213     spr_load_dump_spr(sprn);
1214 }
1215 #endif /* !CONFIG_USER_ONLY */
1216
1217 static void gen_spr_thrm (CPUPPCState *env)
1218 {
1219     /* Thermal management */
1220     /* XXX : not implemented */
1221     spr_register(env, SPR_THRM1, "THRM1",
1222                  SPR_NOACCESS, SPR_NOACCESS,
1223                  &spr_read_thrm, &spr_write_generic,
1224                  0x00000000);
1225     /* XXX : not implemented */
1226     spr_register(env, SPR_THRM2, "THRM2",
1227                  SPR_NOACCESS, SPR_NOACCESS,
1228                  &spr_read_thrm, &spr_write_generic,
1229                  0x00000000);
1230     /* XXX : not implemented */
1231     spr_register(env, SPR_THRM3, "THRM3",
1232                  SPR_NOACCESS, SPR_NOACCESS,
1233                  &spr_read_thrm, &spr_write_generic,
1234                  0x00000000);
1235 }
1236
1237 /* SPR specific to PowerPC 604 implementation */
1238 static void gen_spr_604 (CPUPPCState *env)
1239 {
1240     /* Processor identification */
1241     spr_register(env, SPR_PIR, "PIR",
1242                  SPR_NOACCESS, SPR_NOACCESS,
1243                  &spr_read_generic, &spr_write_pir,
1244                  0x00000000);
1245     /* Breakpoints */
1246     /* XXX : not implemented */
1247     spr_register(env, SPR_IABR, "IABR",
1248                  SPR_NOACCESS, SPR_NOACCESS,
1249                  &spr_read_generic, &spr_write_generic,
1250                  0x00000000);
1251     /* XXX : not implemented */
1252     spr_register_kvm(env, SPR_DABR, "DABR",
1253                      SPR_NOACCESS, SPR_NOACCESS,
1254                      &spr_read_generic, &spr_write_generic,
1255                      KVM_REG_PPC_DABR, 0x00000000);
1256     /* Performance counters */
1257     /* XXX : not implemented */
1258     spr_register(env, SPR_7XX_MMCR0, "MMCR0",
1259                  SPR_NOACCESS, SPR_NOACCESS,
1260                  &spr_read_generic, &spr_write_generic,
1261                  0x00000000);
1262     /* XXX : not implemented */
1263     spr_register(env, SPR_7XX_PMC1, "PMC1",
1264                  SPR_NOACCESS, SPR_NOACCESS,
1265                  &spr_read_generic, &spr_write_generic,
1266                  0x00000000);
1267     /* XXX : not implemented */
1268     spr_register(env, SPR_7XX_PMC2, "PMC2",
1269                  SPR_NOACCESS, SPR_NOACCESS,
1270                  &spr_read_generic, &spr_write_generic,
1271                  0x00000000);
1272     /* XXX : not implemented */
1273     spr_register(env, SPR_7XX_SIAR, "SIAR",
1274                  SPR_NOACCESS, SPR_NOACCESS,
1275                  &spr_read_generic, SPR_NOACCESS,
1276                  0x00000000);
1277     /* XXX : not implemented */
1278     spr_register(env, SPR_SDA, "SDA",
1279                  SPR_NOACCESS, SPR_NOACCESS,
1280                  &spr_read_generic, SPR_NOACCESS,
1281                  0x00000000);
1282     /* External access control */
1283     /* XXX : not implemented */
1284     spr_register(env, SPR_EAR, "EAR",
1285                  SPR_NOACCESS, SPR_NOACCESS,
1286                  &spr_read_generic, &spr_write_generic,
1287                  0x00000000);
1288 }
1289
1290 /* SPR specific to PowerPC 603 implementation */
1291 static void gen_spr_603 (CPUPPCState *env)
1292 {
1293     /* External access control */
1294     /* XXX : not implemented */
1295     spr_register(env, SPR_EAR, "EAR",
1296                  SPR_NOACCESS, SPR_NOACCESS,
1297                  &spr_read_generic, &spr_write_generic,
1298                  0x00000000);
1299     /* Breakpoints */
1300     /* XXX : not implemented */
1301     spr_register(env, SPR_IABR, "IABR",
1302                  SPR_NOACCESS, SPR_NOACCESS,
1303                  &spr_read_generic, &spr_write_generic,
1304                  0x00000000);
1305
1306 }
1307
1308 /* SPR specific to PowerPC G2 implementation */
1309 static void gen_spr_G2 (CPUPPCState *env)
1310 {
1311     /* Memory base address */
1312     /* MBAR */
1313     /* XXX : not implemented */
1314     spr_register(env, SPR_MBAR, "MBAR",
1315                  SPR_NOACCESS, SPR_NOACCESS,
1316                  &spr_read_generic, &spr_write_generic,
1317                  0x00000000);
1318     /* Exception processing */
1319     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1320                  SPR_NOACCESS, SPR_NOACCESS,
1321                  &spr_read_generic, &spr_write_generic,
1322                  0x00000000);
1323     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1324                  SPR_NOACCESS, SPR_NOACCESS,
1325                  &spr_read_generic, &spr_write_generic,
1326                  0x00000000);
1327     /* Breakpoints */
1328     /* XXX : not implemented */
1329     spr_register(env, SPR_DABR, "DABR",
1330                  SPR_NOACCESS, SPR_NOACCESS,
1331                  &spr_read_generic, &spr_write_generic,
1332                  0x00000000);
1333     /* XXX : not implemented */
1334     spr_register(env, SPR_DABR2, "DABR2",
1335                  SPR_NOACCESS, SPR_NOACCESS,
1336                  &spr_read_generic, &spr_write_generic,
1337                  0x00000000);
1338     /* XXX : not implemented */
1339     spr_register(env, SPR_IABR, "IABR",
1340                  SPR_NOACCESS, SPR_NOACCESS,
1341                  &spr_read_generic, &spr_write_generic,
1342                  0x00000000);
1343     /* XXX : not implemented */
1344     spr_register(env, SPR_IABR2, "IABR2",
1345                  SPR_NOACCESS, SPR_NOACCESS,
1346                  &spr_read_generic, &spr_write_generic,
1347                  0x00000000);
1348     /* XXX : not implemented */
1349     spr_register(env, SPR_IBCR, "IBCR",
1350                  SPR_NOACCESS, SPR_NOACCESS,
1351                  &spr_read_generic, &spr_write_generic,
1352                  0x00000000);
1353     /* XXX : not implemented */
1354     spr_register(env, SPR_DBCR, "DBCR",
1355                  SPR_NOACCESS, SPR_NOACCESS,
1356                  &spr_read_generic, &spr_write_generic,
1357                  0x00000000);
1358 }
1359
1360 /* SPR specific to PowerPC 602 implementation */
1361 static void gen_spr_602 (CPUPPCState *env)
1362 {
1363     /* ESA registers */
1364     /* XXX : not implemented */
1365     spr_register(env, SPR_SER, "SER",
1366                  SPR_NOACCESS, SPR_NOACCESS,
1367                  &spr_read_generic, &spr_write_generic,
1368                  0x00000000);
1369     /* XXX : not implemented */
1370     spr_register(env, SPR_SEBR, "SEBR",
1371                  SPR_NOACCESS, SPR_NOACCESS,
1372                  &spr_read_generic, &spr_write_generic,
1373                  0x00000000);
1374     /* XXX : not implemented */
1375     spr_register(env, SPR_ESASRR, "ESASRR",
1376                  SPR_NOACCESS, SPR_NOACCESS,
1377                  &spr_read_generic, &spr_write_generic,
1378                  0x00000000);
1379     /* Floating point status */
1380     /* XXX : not implemented */
1381     spr_register(env, SPR_SP, "SP",
1382                  SPR_NOACCESS, SPR_NOACCESS,
1383                  &spr_read_generic, &spr_write_generic,
1384                  0x00000000);
1385     /* XXX : not implemented */
1386     spr_register(env, SPR_LT, "LT",
1387                  SPR_NOACCESS, SPR_NOACCESS,
1388                  &spr_read_generic, &spr_write_generic,
1389                  0x00000000);
1390     /* Watchdog timer */
1391     /* XXX : not implemented */
1392     spr_register(env, SPR_TCR, "TCR",
1393                  SPR_NOACCESS, SPR_NOACCESS,
1394                  &spr_read_generic, &spr_write_generic,
1395                  0x00000000);
1396     /* Interrupt base */
1397     spr_register(env, SPR_IBR, "IBR",
1398                  SPR_NOACCESS, SPR_NOACCESS,
1399                  &spr_read_generic, &spr_write_generic,
1400                  0x00000000);
1401     /* XXX : not implemented */
1402     spr_register(env, SPR_IABR, "IABR",
1403                  SPR_NOACCESS, SPR_NOACCESS,
1404                  &spr_read_generic, &spr_write_generic,
1405                  0x00000000);
1406 }
1407
1408 /* SPR specific to PowerPC 601 implementation */
1409 static void gen_spr_601 (CPUPPCState *env)
1410 {
1411     /* Multiplication/division register */
1412     /* MQ */
1413     spr_register(env, SPR_MQ, "MQ",
1414                  &spr_read_generic, &spr_write_generic,
1415                  &spr_read_generic, &spr_write_generic,
1416                  0x00000000);
1417     /* RTC registers */
1418     spr_register(env, SPR_601_RTCU, "RTCU",
1419                  SPR_NOACCESS, SPR_NOACCESS,
1420                  SPR_NOACCESS, &spr_write_601_rtcu,
1421                  0x00000000);
1422     spr_register(env, SPR_601_VRTCU, "RTCU",
1423                  &spr_read_601_rtcu, SPR_NOACCESS,
1424                  &spr_read_601_rtcu, SPR_NOACCESS,
1425                  0x00000000);
1426     spr_register(env, SPR_601_RTCL, "RTCL",
1427                  SPR_NOACCESS, SPR_NOACCESS,
1428                  SPR_NOACCESS, &spr_write_601_rtcl,
1429                  0x00000000);
1430     spr_register(env, SPR_601_VRTCL, "RTCL",
1431                  &spr_read_601_rtcl, SPR_NOACCESS,
1432                  &spr_read_601_rtcl, SPR_NOACCESS,
1433                  0x00000000);
1434     /* Timer */
1435 #if 0 /* ? */
1436     spr_register(env, SPR_601_UDECR, "UDECR",
1437                  &spr_read_decr, SPR_NOACCESS,
1438                  &spr_read_decr, SPR_NOACCESS,
1439                  0x00000000);
1440 #endif
1441     /* External access control */
1442     /* XXX : not implemented */
1443     spr_register(env, SPR_EAR, "EAR",
1444                  SPR_NOACCESS, SPR_NOACCESS,
1445                  &spr_read_generic, &spr_write_generic,
1446                  0x00000000);
1447     /* Memory management */
1448 #if !defined(CONFIG_USER_ONLY)
1449     spr_register(env, SPR_IBAT0U, "IBAT0U",
1450                  SPR_NOACCESS, SPR_NOACCESS,
1451                  &spr_read_601_ubat, &spr_write_601_ubatu,
1452                  0x00000000);
1453     spr_register(env, SPR_IBAT0L, "IBAT0L",
1454                  SPR_NOACCESS, SPR_NOACCESS,
1455                  &spr_read_601_ubat, &spr_write_601_ubatl,
1456                  0x00000000);
1457     spr_register(env, SPR_IBAT1U, "IBAT1U",
1458                  SPR_NOACCESS, SPR_NOACCESS,
1459                  &spr_read_601_ubat, &spr_write_601_ubatu,
1460                  0x00000000);
1461     spr_register(env, SPR_IBAT1L, "IBAT1L",
1462                  SPR_NOACCESS, SPR_NOACCESS,
1463                  &spr_read_601_ubat, &spr_write_601_ubatl,
1464                  0x00000000);
1465     spr_register(env, SPR_IBAT2U, "IBAT2U",
1466                  SPR_NOACCESS, SPR_NOACCESS,
1467                  &spr_read_601_ubat, &spr_write_601_ubatu,
1468                  0x00000000);
1469     spr_register(env, SPR_IBAT2L, "IBAT2L",
1470                  SPR_NOACCESS, SPR_NOACCESS,
1471                  &spr_read_601_ubat, &spr_write_601_ubatl,
1472                  0x00000000);
1473     spr_register(env, SPR_IBAT3U, "IBAT3U",
1474                  SPR_NOACCESS, SPR_NOACCESS,
1475                  &spr_read_601_ubat, &spr_write_601_ubatu,
1476                  0x00000000);
1477     spr_register(env, SPR_IBAT3L, "IBAT3L",
1478                  SPR_NOACCESS, SPR_NOACCESS,
1479                  &spr_read_601_ubat, &spr_write_601_ubatl,
1480                  0x00000000);
1481     env->nb_BATs = 4;
1482 #endif
1483 }
1484
1485 static void gen_spr_74xx (CPUPPCState *env)
1486 {
1487     /* Processor identification */
1488     spr_register(env, SPR_PIR, "PIR",
1489                  SPR_NOACCESS, SPR_NOACCESS,
1490                  &spr_read_generic, &spr_write_pir,
1491                  0x00000000);
1492     /* XXX : not implemented */
1493     spr_register(env, SPR_74XX_MMCR2, "MMCR2",
1494                  SPR_NOACCESS, SPR_NOACCESS,
1495                  &spr_read_generic, &spr_write_generic,
1496                  0x00000000);
1497     /* XXX : not implemented */
1498     spr_register(env, SPR_74XX_UMMCR2, "UMMCR2",
1499                  &spr_read_ureg, SPR_NOACCESS,
1500                  &spr_read_ureg, SPR_NOACCESS,
1501                  0x00000000);
1502     /* XXX: not implemented */
1503     spr_register(env, SPR_BAMR, "BAMR",
1504                  SPR_NOACCESS, SPR_NOACCESS,
1505                  &spr_read_generic, &spr_write_generic,
1506                  0x00000000);
1507     /* XXX : not implemented */
1508     spr_register(env, SPR_MSSCR0, "MSSCR0",
1509                  SPR_NOACCESS, SPR_NOACCESS,
1510                  &spr_read_generic, &spr_write_generic,
1511                  0x00000000);
1512     /* Hardware implementation registers */
1513     /* XXX : not implemented */
1514     spr_register(env, SPR_HID0, "HID0",
1515                  SPR_NOACCESS, SPR_NOACCESS,
1516                  &spr_read_generic, &spr_write_generic,
1517                  0x00000000);
1518     /* XXX : not implemented */
1519     spr_register(env, SPR_HID1, "HID1",
1520                  SPR_NOACCESS, SPR_NOACCESS,
1521                  &spr_read_generic, &spr_write_generic,
1522                  0x00000000);
1523     /* Altivec */
1524     spr_register(env, SPR_VRSAVE, "VRSAVE",
1525                  &spr_read_generic, &spr_write_generic,
1526                  &spr_read_generic, &spr_write_generic,
1527                  0x00000000);
1528     /* XXX : not implemented */
1529     spr_register(env, SPR_L2CR, "L2CR",
1530                  SPR_NOACCESS, SPR_NOACCESS,
1531                  &spr_read_generic, spr_access_nop,
1532                  0x00000000);
1533     /* Not strictly an SPR */
1534     vscr_init(env, 0x00010000);
1535 }
1536
1537 static void gen_l3_ctrl (CPUPPCState *env)
1538 {
1539     /* L3CR */
1540     /* XXX : not implemented */
1541     spr_register(env, SPR_L3CR, "L3CR",
1542                  SPR_NOACCESS, SPR_NOACCESS,
1543                  &spr_read_generic, &spr_write_generic,
1544                  0x00000000);
1545     /* L3ITCR0 */
1546     /* XXX : not implemented */
1547     spr_register(env, SPR_L3ITCR0, "L3ITCR0",
1548                  SPR_NOACCESS, SPR_NOACCESS,
1549                  &spr_read_generic, &spr_write_generic,
1550                  0x00000000);
1551     /* L3PM */
1552     /* XXX : not implemented */
1553     spr_register(env, SPR_L3PM, "L3PM",
1554                  SPR_NOACCESS, SPR_NOACCESS,
1555                  &spr_read_generic, &spr_write_generic,
1556                  0x00000000);
1557 }
1558
1559 static void gen_74xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
1560 {
1561 #if !defined(CONFIG_USER_ONLY)
1562     env->nb_tlb = nb_tlbs;
1563     env->nb_ways = nb_ways;
1564     env->id_tlbs = 1;
1565     env->tlb_type = TLB_6XX;
1566     /* XXX : not implemented */
1567     spr_register(env, SPR_PTEHI, "PTEHI",
1568                  SPR_NOACCESS, SPR_NOACCESS,
1569                  &spr_read_generic, &spr_write_generic,
1570                  0x00000000);
1571     /* XXX : not implemented */
1572     spr_register(env, SPR_PTELO, "PTELO",
1573                  SPR_NOACCESS, SPR_NOACCESS,
1574                  &spr_read_generic, &spr_write_generic,
1575                  0x00000000);
1576     /* XXX : not implemented */
1577     spr_register(env, SPR_TLBMISS, "TLBMISS",
1578                  SPR_NOACCESS, SPR_NOACCESS,
1579                  &spr_read_generic, &spr_write_generic,
1580                  0x00000000);
1581 #endif
1582 }
1583
1584 #if !defined(CONFIG_USER_ONLY)
1585 static void spr_write_e500_l1csr0 (DisasContext *ctx, int sprn, int gprn)
1586 {
1587     TCGv t0 = tcg_temp_new();
1588
1589     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR0_DCE | L1CSR0_CPE);
1590     gen_store_spr(sprn, t0);
1591     tcg_temp_free(t0);
1592 }
1593
1594 static void spr_write_e500_l1csr1(DisasContext *ctx, int sprn, int gprn)
1595 {
1596     TCGv t0 = tcg_temp_new();
1597
1598     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR1_ICE | L1CSR1_CPE);
1599     gen_store_spr(sprn, t0);
1600     tcg_temp_free(t0);
1601 }
1602
1603 static void spr_write_booke206_mmucsr0 (DisasContext *ctx, int sprn, int gprn)
1604 {
1605     gen_helper_booke206_tlbflush(cpu_env, cpu_gpr[gprn]);
1606 }
1607
1608 static void spr_write_booke_pid (DisasContext *ctx, int sprn, int gprn)
1609 {
1610     TCGv_i32 t0 = tcg_const_i32(sprn);
1611     gen_helper_booke_setpid(cpu_env, t0, cpu_gpr[gprn]);
1612     tcg_temp_free_i32(t0);
1613 }
1614 #endif
1615
1616 static void gen_spr_usprgh (CPUPPCState *env)
1617 {
1618     spr_register(env, SPR_USPRG4, "USPRG4",
1619                  &spr_read_ureg, SPR_NOACCESS,
1620                  &spr_read_ureg, SPR_NOACCESS,
1621                  0x00000000);
1622     spr_register(env, SPR_USPRG5, "USPRG5",
1623                  &spr_read_ureg, SPR_NOACCESS,
1624                  &spr_read_ureg, SPR_NOACCESS,
1625                  0x00000000);
1626     spr_register(env, SPR_USPRG6, "USPRG6",
1627                  &spr_read_ureg, SPR_NOACCESS,
1628                  &spr_read_ureg, SPR_NOACCESS,
1629                  0x00000000);
1630     spr_register(env, SPR_USPRG7, "USPRG7",
1631                  &spr_read_ureg, SPR_NOACCESS,
1632                  &spr_read_ureg, SPR_NOACCESS,
1633                  0x00000000);
1634 }
1635
1636 /* PowerPC BookE SPR */
1637 static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)
1638 {
1639     const char *ivor_names[64] = {
1640         "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",
1641         "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",
1642         "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",
1643         "IVOR12", "IVOR13", "IVOR14", "IVOR15",
1644         "IVOR16", "IVOR17", "IVOR18", "IVOR19",
1645         "IVOR20", "IVOR21", "IVOR22", "IVOR23",
1646         "IVOR24", "IVOR25", "IVOR26", "IVOR27",
1647         "IVOR28", "IVOR29", "IVOR30", "IVOR31",
1648         "IVOR32", "IVOR33", "IVOR34", "IVOR35",
1649         "IVOR36", "IVOR37", "IVOR38", "IVOR39",
1650         "IVOR40", "IVOR41", "IVOR42", "IVOR43",
1651         "IVOR44", "IVOR45", "IVOR46", "IVOR47",
1652         "IVOR48", "IVOR49", "IVOR50", "IVOR51",
1653         "IVOR52", "IVOR53", "IVOR54", "IVOR55",
1654         "IVOR56", "IVOR57", "IVOR58", "IVOR59",
1655         "IVOR60", "IVOR61", "IVOR62", "IVOR63",
1656     };
1657 #define SPR_BOOKE_IVORxx (-1)
1658     int ivor_sprn[64] = {
1659         SPR_BOOKE_IVOR0,  SPR_BOOKE_IVOR1,  SPR_BOOKE_IVOR2,  SPR_BOOKE_IVOR3,
1660         SPR_BOOKE_IVOR4,  SPR_BOOKE_IVOR5,  SPR_BOOKE_IVOR6,  SPR_BOOKE_IVOR7,
1661         SPR_BOOKE_IVOR8,  SPR_BOOKE_IVOR9,  SPR_BOOKE_IVOR10, SPR_BOOKE_IVOR11,
1662         SPR_BOOKE_IVOR12, SPR_BOOKE_IVOR13, SPR_BOOKE_IVOR14, SPR_BOOKE_IVOR15,
1663         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1664         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1665         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1666         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1667         SPR_BOOKE_IVOR32, SPR_BOOKE_IVOR33, SPR_BOOKE_IVOR34, SPR_BOOKE_IVOR35,
1668         SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVOR38, SPR_BOOKE_IVOR39,
1669         SPR_BOOKE_IVOR40, SPR_BOOKE_IVOR41, SPR_BOOKE_IVOR42, SPR_BOOKE_IVORxx,
1670         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1671         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1672         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1673         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1674         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1675     };
1676     int i;
1677
1678     /* Interrupt processing */
1679     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1680                  SPR_NOACCESS, SPR_NOACCESS,
1681                  &spr_read_generic, &spr_write_generic,
1682                  0x00000000);
1683     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1684                  SPR_NOACCESS, SPR_NOACCESS,
1685                  &spr_read_generic, &spr_write_generic,
1686                  0x00000000);
1687     /* Debug */
1688     /* XXX : not implemented */
1689     spr_register(env, SPR_BOOKE_IAC1, "IAC1",
1690                  SPR_NOACCESS, SPR_NOACCESS,
1691                  &spr_read_generic, &spr_write_generic,
1692                  0x00000000);
1693     /* XXX : not implemented */
1694     spr_register(env, SPR_BOOKE_IAC2, "IAC2",
1695                  SPR_NOACCESS, SPR_NOACCESS,
1696                  &spr_read_generic, &spr_write_generic,
1697                  0x00000000);
1698     /* XXX : not implemented */
1699     spr_register(env, SPR_BOOKE_DAC1, "DAC1",
1700                  SPR_NOACCESS, SPR_NOACCESS,
1701                  &spr_read_generic, &spr_write_generic,
1702                  0x00000000);
1703     /* XXX : not implemented */
1704     spr_register(env, SPR_BOOKE_DAC2, "DAC2",
1705                  SPR_NOACCESS, SPR_NOACCESS,
1706                  &spr_read_generic, &spr_write_generic,
1707                  0x00000000);
1708     /* XXX : not implemented */
1709     spr_register(env, SPR_BOOKE_DBCR0, "DBCR0",
1710                  SPR_NOACCESS, SPR_NOACCESS,
1711                  &spr_read_generic, &spr_write_40x_dbcr0,
1712                  0x00000000);
1713     /* XXX : not implemented */
1714     spr_register(env, SPR_BOOKE_DBCR1, "DBCR1",
1715                  SPR_NOACCESS, SPR_NOACCESS,
1716                  &spr_read_generic, &spr_write_generic,
1717                  0x00000000);
1718     /* XXX : not implemented */
1719     spr_register(env, SPR_BOOKE_DBCR2, "DBCR2",
1720                  SPR_NOACCESS, SPR_NOACCESS,
1721                  &spr_read_generic, &spr_write_generic,
1722                  0x00000000);
1723     /* XXX : not implemented */
1724     spr_register(env, SPR_BOOKE_DBSR, "DBSR",
1725                  SPR_NOACCESS, SPR_NOACCESS,
1726                  &spr_read_generic, &spr_write_clear,
1727                  0x00000000);
1728     spr_register(env, SPR_BOOKE_DEAR, "DEAR",
1729                  SPR_NOACCESS, SPR_NOACCESS,
1730                  &spr_read_generic, &spr_write_generic,
1731                  0x00000000);
1732     spr_register(env, SPR_BOOKE_ESR, "ESR",
1733                  SPR_NOACCESS, SPR_NOACCESS,
1734                  &spr_read_generic, &spr_write_generic,
1735                  0x00000000);
1736     spr_register(env, SPR_BOOKE_IVPR, "IVPR",
1737                  SPR_NOACCESS, SPR_NOACCESS,
1738                  &spr_read_generic, &spr_write_excp_prefix,
1739                  0x00000000);
1740     /* Exception vectors */
1741     for (i = 0; i < 64; i++) {
1742         if (ivor_mask & (1ULL << i)) {
1743             if (ivor_sprn[i] == SPR_BOOKE_IVORxx) {
1744                 fprintf(stderr, "ERROR: IVOR %d SPR is not defined\n", i);
1745                 exit(1);
1746             }
1747             spr_register(env, ivor_sprn[i], ivor_names[i],
1748                          SPR_NOACCESS, SPR_NOACCESS,
1749                          &spr_read_generic, &spr_write_excp_vector,
1750                          0x00000000);
1751         }
1752     }
1753     spr_register(env, SPR_BOOKE_PID, "PID",
1754                  SPR_NOACCESS, SPR_NOACCESS,
1755                  &spr_read_generic, &spr_write_booke_pid,
1756                  0x00000000);
1757     spr_register(env, SPR_BOOKE_TCR, "TCR",
1758                  SPR_NOACCESS, SPR_NOACCESS,
1759                  &spr_read_generic, &spr_write_booke_tcr,
1760                  0x00000000);
1761     spr_register(env, SPR_BOOKE_TSR, "TSR",
1762                  SPR_NOACCESS, SPR_NOACCESS,
1763                  &spr_read_generic, &spr_write_booke_tsr,
1764                  0x00000000);
1765     /* Timer */
1766     spr_register(env, SPR_DECR, "DECR",
1767                  SPR_NOACCESS, SPR_NOACCESS,
1768                  &spr_read_decr, &spr_write_decr,
1769                  0x00000000);
1770     spr_register(env, SPR_BOOKE_DECAR, "DECAR",
1771                  SPR_NOACCESS, SPR_NOACCESS,
1772                  SPR_NOACCESS, &spr_write_generic,
1773                  0x00000000);
1774     /* SPRGs */
1775     spr_register(env, SPR_USPRG0, "USPRG0",
1776                  &spr_read_generic, &spr_write_generic,
1777                  &spr_read_generic, &spr_write_generic,
1778                  0x00000000);
1779     spr_register(env, SPR_SPRG4, "SPRG4",
1780                  SPR_NOACCESS, SPR_NOACCESS,
1781                  &spr_read_generic, &spr_write_generic,
1782                  0x00000000);
1783     spr_register(env, SPR_SPRG5, "SPRG5",
1784                  SPR_NOACCESS, SPR_NOACCESS,
1785                  &spr_read_generic, &spr_write_generic,
1786                  0x00000000);
1787     spr_register(env, SPR_SPRG6, "SPRG6",
1788                  SPR_NOACCESS, SPR_NOACCESS,
1789                  &spr_read_generic, &spr_write_generic,
1790                  0x00000000);
1791     spr_register(env, SPR_SPRG7, "SPRG7",
1792                  SPR_NOACCESS, SPR_NOACCESS,
1793                  &spr_read_generic, &spr_write_generic,
1794                  0x00000000);
1795 }
1796
1797 static inline uint32_t gen_tlbncfg(uint32_t assoc, uint32_t minsize,
1798                                    uint32_t maxsize, uint32_t flags,
1799                                    uint32_t nentries)
1800 {
1801     return (assoc << TLBnCFG_ASSOC_SHIFT) |
1802            (minsize << TLBnCFG_MINSIZE_SHIFT) |
1803            (maxsize << TLBnCFG_MAXSIZE_SHIFT) |
1804            flags | nentries;
1805 }
1806
1807 /* BookE 2.06 storage control registers */
1808 static void gen_spr_BookE206(CPUPPCState *env, uint32_t mas_mask,
1809                               uint32_t *tlbncfg)
1810 {
1811 #if !defined(CONFIG_USER_ONLY)
1812     const char *mas_names[8] = {
1813         "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
1814     };
1815     int mas_sprn[8] = {
1816         SPR_BOOKE_MAS0, SPR_BOOKE_MAS1, SPR_BOOKE_MAS2, SPR_BOOKE_MAS3,
1817         SPR_BOOKE_MAS4, SPR_BOOKE_MAS5, SPR_BOOKE_MAS6, SPR_BOOKE_MAS7,
1818     };
1819     int i;
1820
1821     /* TLB assist registers */
1822     /* XXX : not implemented */
1823     for (i = 0; i < 8; i++) {
1824         void (*uea_write)(DisasContext *ctx, int sprn, int gprn) = &spr_write_generic32;
1825         if (i == 2 && (mas_mask & (1 << i)) && (env->insns_flags & PPC_64B)) {
1826             uea_write = &spr_write_generic;
1827         }
1828         if (mas_mask & (1 << i)) {
1829             spr_register(env, mas_sprn[i], mas_names[i],
1830                          SPR_NOACCESS, SPR_NOACCESS,
1831                          &spr_read_generic, uea_write,
1832                          0x00000000);
1833         }
1834     }
1835     if (env->nb_pids > 1) {
1836         /* XXX : not implemented */
1837         spr_register(env, SPR_BOOKE_PID1, "PID1",
1838                      SPR_NOACCESS, SPR_NOACCESS,
1839                      &spr_read_generic, &spr_write_booke_pid,
1840                      0x00000000);
1841     }
1842     if (env->nb_pids > 2) {
1843         /* XXX : not implemented */
1844         spr_register(env, SPR_BOOKE_PID2, "PID2",
1845                      SPR_NOACCESS, SPR_NOACCESS,
1846                      &spr_read_generic, &spr_write_booke_pid,
1847                      0x00000000);
1848     }
1849     /* XXX : not implemented */
1850     spr_register(env, SPR_MMUCFG, "MMUCFG",
1851                  SPR_NOACCESS, SPR_NOACCESS,
1852                  &spr_read_generic, SPR_NOACCESS,
1853                  0x00000000); /* TOFIX */
1854     switch (env->nb_ways) {
1855     case 4:
1856         spr_register(env, SPR_BOOKE_TLB3CFG, "TLB3CFG",
1857                      SPR_NOACCESS, SPR_NOACCESS,
1858                      &spr_read_generic, SPR_NOACCESS,
1859                      tlbncfg[3]);
1860         /* Fallthru */
1861     case 3:
1862         spr_register(env, SPR_BOOKE_TLB2CFG, "TLB2CFG",
1863                      SPR_NOACCESS, SPR_NOACCESS,
1864                      &spr_read_generic, SPR_NOACCESS,
1865                      tlbncfg[2]);
1866         /* Fallthru */
1867     case 2:
1868         spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
1869                      SPR_NOACCESS, SPR_NOACCESS,
1870                      &spr_read_generic, SPR_NOACCESS,
1871                      tlbncfg[1]);
1872         /* Fallthru */
1873     case 1:
1874         spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
1875                      SPR_NOACCESS, SPR_NOACCESS,
1876                      &spr_read_generic, SPR_NOACCESS,
1877                      tlbncfg[0]);
1878         /* Fallthru */
1879     case 0:
1880     default:
1881         break;
1882     }
1883 #endif
1884
1885     gen_spr_usprgh(env);
1886 }
1887
1888 /* SPR specific to PowerPC 440 implementation */
1889 static void gen_spr_440 (CPUPPCState *env)
1890 {
1891     /* Cache control */
1892     /* XXX : not implemented */
1893     spr_register(env, SPR_440_DNV0, "DNV0",
1894                  SPR_NOACCESS, SPR_NOACCESS,
1895                  &spr_read_generic, &spr_write_generic,
1896                  0x00000000);
1897     /* XXX : not implemented */
1898     spr_register(env, SPR_440_DNV1, "DNV1",
1899                  SPR_NOACCESS, SPR_NOACCESS,
1900                  &spr_read_generic, &spr_write_generic,
1901                  0x00000000);
1902     /* XXX : not implemented */
1903     spr_register(env, SPR_440_DNV2, "DNV2",
1904                  SPR_NOACCESS, SPR_NOACCESS,
1905                  &spr_read_generic, &spr_write_generic,
1906                  0x00000000);
1907     /* XXX : not implemented */
1908     spr_register(env, SPR_440_DNV3, "DNV3",
1909                  SPR_NOACCESS, SPR_NOACCESS,
1910                  &spr_read_generic, &spr_write_generic,
1911                  0x00000000);
1912     /* XXX : not implemented */
1913     spr_register(env, SPR_440_DTV0, "DTV0",
1914                  SPR_NOACCESS, SPR_NOACCESS,
1915                  &spr_read_generic, &spr_write_generic,
1916                  0x00000000);
1917     /* XXX : not implemented */
1918     spr_register(env, SPR_440_DTV1, "DTV1",
1919                  SPR_NOACCESS, SPR_NOACCESS,
1920                  &spr_read_generic, &spr_write_generic,
1921                  0x00000000);
1922     /* XXX : not implemented */
1923     spr_register(env, SPR_440_DTV2, "DTV2",
1924                  SPR_NOACCESS, SPR_NOACCESS,
1925                  &spr_read_generic, &spr_write_generic,
1926                  0x00000000);
1927     /* XXX : not implemented */
1928     spr_register(env, SPR_440_DTV3, "DTV3",
1929                  SPR_NOACCESS, SPR_NOACCESS,
1930                  &spr_read_generic, &spr_write_generic,
1931                  0x00000000);
1932     /* XXX : not implemented */
1933     spr_register(env, SPR_440_DVLIM, "DVLIM",
1934                  SPR_NOACCESS, SPR_NOACCESS,
1935                  &spr_read_generic, &spr_write_generic,
1936                  0x00000000);
1937     /* XXX : not implemented */
1938     spr_register(env, SPR_440_INV0, "INV0",
1939                  SPR_NOACCESS, SPR_NOACCESS,
1940                  &spr_read_generic, &spr_write_generic,
1941                  0x00000000);
1942     /* XXX : not implemented */
1943     spr_register(env, SPR_440_INV1, "INV1",
1944                  SPR_NOACCESS, SPR_NOACCESS,
1945                  &spr_read_generic, &spr_write_generic,
1946                  0x00000000);
1947     /* XXX : not implemented */
1948     spr_register(env, SPR_440_INV2, "INV2",
1949                  SPR_NOACCESS, SPR_NOACCESS,
1950                  &spr_read_generic, &spr_write_generic,
1951                  0x00000000);
1952     /* XXX : not implemented */
1953     spr_register(env, SPR_440_INV3, "INV3",
1954                  SPR_NOACCESS, SPR_NOACCESS,
1955                  &spr_read_generic, &spr_write_generic,
1956                  0x00000000);
1957     /* XXX : not implemented */
1958     spr_register(env, SPR_440_ITV0, "ITV0",
1959                  SPR_NOACCESS, SPR_NOACCESS,
1960                  &spr_read_generic, &spr_write_generic,
1961                  0x00000000);
1962     /* XXX : not implemented */
1963     spr_register(env, SPR_440_ITV1, "ITV1",
1964                  SPR_NOACCESS, SPR_NOACCESS,
1965                  &spr_read_generic, &spr_write_generic,
1966                  0x00000000);
1967     /* XXX : not implemented */
1968     spr_register(env, SPR_440_ITV2, "ITV2",
1969                  SPR_NOACCESS, SPR_NOACCESS,
1970                  &spr_read_generic, &spr_write_generic,
1971                  0x00000000);
1972     /* XXX : not implemented */
1973     spr_register(env, SPR_440_ITV3, "ITV3",
1974                  SPR_NOACCESS, SPR_NOACCESS,
1975                  &spr_read_generic, &spr_write_generic,
1976                  0x00000000);
1977     /* XXX : not implemented */
1978     spr_register(env, SPR_440_IVLIM, "IVLIM",
1979                  SPR_NOACCESS, SPR_NOACCESS,
1980                  &spr_read_generic, &spr_write_generic,
1981                  0x00000000);
1982     /* Cache debug */
1983     /* XXX : not implemented */
1984     spr_register(env, SPR_BOOKE_DCDBTRH, "DCDBTRH",
1985                  SPR_NOACCESS, SPR_NOACCESS,
1986                  &spr_read_generic, SPR_NOACCESS,
1987                  0x00000000);
1988     /* XXX : not implemented */
1989     spr_register(env, SPR_BOOKE_DCDBTRL, "DCDBTRL",
1990                  SPR_NOACCESS, SPR_NOACCESS,
1991                  &spr_read_generic, SPR_NOACCESS,
1992                  0x00000000);
1993     /* XXX : not implemented */
1994     spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
1995                  SPR_NOACCESS, SPR_NOACCESS,
1996                  &spr_read_generic, SPR_NOACCESS,
1997                  0x00000000);
1998     /* XXX : not implemented */
1999     spr_register(env, SPR_BOOKE_ICDBTRH, "ICDBTRH",
2000                  SPR_NOACCESS, SPR_NOACCESS,
2001                  &spr_read_generic, SPR_NOACCESS,
2002                  0x00000000);
2003     /* XXX : not implemented */
2004     spr_register(env, SPR_BOOKE_ICDBTRL, "ICDBTRL",
2005                  SPR_NOACCESS, SPR_NOACCESS,
2006                  &spr_read_generic, SPR_NOACCESS,
2007                  0x00000000);
2008     /* XXX : not implemented */
2009     spr_register(env, SPR_440_DBDR, "DBDR",
2010                  SPR_NOACCESS, SPR_NOACCESS,
2011                  &spr_read_generic, &spr_write_generic,
2012                  0x00000000);
2013     /* Processor control */
2014     spr_register(env, SPR_4xx_CCR0, "CCR0",
2015                  SPR_NOACCESS, SPR_NOACCESS,
2016                  &spr_read_generic, &spr_write_generic,
2017                  0x00000000);
2018     spr_register(env, SPR_440_RSTCFG, "RSTCFG",
2019                  SPR_NOACCESS, SPR_NOACCESS,
2020                  &spr_read_generic, SPR_NOACCESS,
2021                  0x00000000);
2022     /* Storage control */
2023     spr_register(env, SPR_440_MMUCR, "MMUCR",
2024                  SPR_NOACCESS, SPR_NOACCESS,
2025                  &spr_read_generic, &spr_write_generic,
2026                  0x00000000);
2027 }
2028
2029 /* SPR shared between PowerPC 40x implementations */
2030 static void gen_spr_40x (CPUPPCState *env)
2031 {
2032     /* Cache */
2033     /* not emulated, as QEMU do not emulate caches */
2034     spr_register(env, SPR_40x_DCCR, "DCCR",
2035                  SPR_NOACCESS, SPR_NOACCESS,
2036                  &spr_read_generic, &spr_write_generic,
2037                  0x00000000);
2038     /* not emulated, as QEMU do not emulate caches */
2039     spr_register(env, SPR_40x_ICCR, "ICCR",
2040                  SPR_NOACCESS, SPR_NOACCESS,
2041                  &spr_read_generic, &spr_write_generic,
2042                  0x00000000);
2043     /* not emulated, as QEMU do not emulate caches */
2044     spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
2045                  SPR_NOACCESS, SPR_NOACCESS,
2046                  &spr_read_generic, SPR_NOACCESS,
2047                  0x00000000);
2048     /* Exception */
2049     spr_register(env, SPR_40x_DEAR, "DEAR",
2050                  SPR_NOACCESS, SPR_NOACCESS,
2051                  &spr_read_generic, &spr_write_generic,
2052                  0x00000000);
2053     spr_register(env, SPR_40x_ESR, "ESR",
2054                  SPR_NOACCESS, SPR_NOACCESS,
2055                  &spr_read_generic, &spr_write_generic,
2056                  0x00000000);
2057     spr_register(env, SPR_40x_EVPR, "EVPR",
2058                  SPR_NOACCESS, SPR_NOACCESS,
2059                  &spr_read_generic, &spr_write_excp_prefix,
2060                  0x00000000);
2061     spr_register(env, SPR_40x_SRR2, "SRR2",
2062                  &spr_read_generic, &spr_write_generic,
2063                  &spr_read_generic, &spr_write_generic,
2064                  0x00000000);
2065     spr_register(env, SPR_40x_SRR3, "SRR3",
2066                  &spr_read_generic, &spr_write_generic,
2067                  &spr_read_generic, &spr_write_generic,
2068                  0x00000000);
2069     /* Timers */
2070     spr_register(env, SPR_40x_PIT, "PIT",
2071                  SPR_NOACCESS, SPR_NOACCESS,
2072                  &spr_read_40x_pit, &spr_write_40x_pit,
2073                  0x00000000);
2074     spr_register(env, SPR_40x_TCR, "TCR",
2075                  SPR_NOACCESS, SPR_NOACCESS,
2076                  &spr_read_generic, &spr_write_booke_tcr,
2077                  0x00000000);
2078     spr_register(env, SPR_40x_TSR, "TSR",
2079                  SPR_NOACCESS, SPR_NOACCESS,
2080                  &spr_read_generic, &spr_write_booke_tsr,
2081                  0x00000000);
2082 }
2083
2084 /* SPR specific to PowerPC 405 implementation */
2085 static void gen_spr_405 (CPUPPCState *env)
2086 {
2087     /* MMU */
2088     spr_register(env, SPR_40x_PID, "PID",
2089                  SPR_NOACCESS, SPR_NOACCESS,
2090                  &spr_read_generic, &spr_write_generic,
2091                  0x00000000);
2092     spr_register(env, SPR_4xx_CCR0, "CCR0",
2093                  SPR_NOACCESS, SPR_NOACCESS,
2094                  &spr_read_generic, &spr_write_generic,
2095                  0x00700000);
2096     /* Debug interface */
2097     /* XXX : not implemented */
2098     spr_register(env, SPR_40x_DBCR0, "DBCR0",
2099                  SPR_NOACCESS, SPR_NOACCESS,
2100                  &spr_read_generic, &spr_write_40x_dbcr0,
2101                  0x00000000);
2102     /* XXX : not implemented */
2103     spr_register(env, SPR_405_DBCR1, "DBCR1",
2104                  SPR_NOACCESS, SPR_NOACCESS,
2105                  &spr_read_generic, &spr_write_generic,
2106                  0x00000000);
2107     /* XXX : not implemented */
2108     spr_register(env, SPR_40x_DBSR, "DBSR",
2109                  SPR_NOACCESS, SPR_NOACCESS,
2110                  &spr_read_generic, &spr_write_clear,
2111                  /* Last reset was system reset */
2112                  0x00000300);
2113     /* XXX : not implemented */
2114     spr_register(env, SPR_40x_DAC1, "DAC1",
2115                  SPR_NOACCESS, SPR_NOACCESS,
2116                  &spr_read_generic, &spr_write_generic,
2117                  0x00000000);
2118     spr_register(env, SPR_40x_DAC2, "DAC2",
2119                  SPR_NOACCESS, SPR_NOACCESS,
2120                  &spr_read_generic, &spr_write_generic,
2121                  0x00000000);
2122     /* XXX : not implemented */
2123     spr_register(env, SPR_405_DVC1, "DVC1",
2124                  SPR_NOACCESS, SPR_NOACCESS,
2125                  &spr_read_generic, &spr_write_generic,
2126                  0x00000000);
2127     /* XXX : not implemented */
2128     spr_register(env, SPR_405_DVC2, "DVC2",
2129                  SPR_NOACCESS, SPR_NOACCESS,
2130                  &spr_read_generic, &spr_write_generic,
2131                  0x00000000);
2132     /* XXX : not implemented */
2133     spr_register(env, SPR_40x_IAC1, "IAC1",
2134                  SPR_NOACCESS, SPR_NOACCESS,
2135                  &spr_read_generic, &spr_write_generic,
2136                  0x00000000);
2137     spr_register(env, SPR_40x_IAC2, "IAC2",
2138                  SPR_NOACCESS, SPR_NOACCESS,
2139                  &spr_read_generic, &spr_write_generic,
2140                  0x00000000);
2141     /* XXX : not implemented */
2142     spr_register(env, SPR_405_IAC3, "IAC3",
2143                  SPR_NOACCESS, SPR_NOACCESS,
2144                  &spr_read_generic, &spr_write_generic,
2145                  0x00000000);
2146     /* XXX : not implemented */
2147     spr_register(env, SPR_405_IAC4, "IAC4",
2148                  SPR_NOACCESS, SPR_NOACCESS,
2149                  &spr_read_generic, &spr_write_generic,
2150                  0x00000000);
2151     /* Storage control */
2152     /* XXX: TODO: not implemented */
2153     spr_register(env, SPR_405_SLER, "SLER",
2154                  SPR_NOACCESS, SPR_NOACCESS,
2155                  &spr_read_generic, &spr_write_40x_sler,
2156                  0x00000000);
2157     spr_register(env, SPR_40x_ZPR, "ZPR",
2158                  SPR_NOACCESS, SPR_NOACCESS,
2159                  &spr_read_generic, &spr_write_generic,
2160                  0x00000000);
2161     /* XXX : not implemented */
2162     spr_register(env, SPR_405_SU0R, "SU0R",
2163                  SPR_NOACCESS, SPR_NOACCESS,
2164                  &spr_read_generic, &spr_write_generic,
2165                  0x00000000);
2166     /* SPRG */
2167     spr_register(env, SPR_USPRG0, "USPRG0",
2168                  &spr_read_ureg, SPR_NOACCESS,
2169                  &spr_read_ureg, SPR_NOACCESS,
2170                  0x00000000);
2171     spr_register(env, SPR_SPRG4, "SPRG4",
2172                  SPR_NOACCESS, SPR_NOACCESS,
2173                  &spr_read_generic, &spr_write_generic,
2174                  0x00000000);
2175     spr_register(env, SPR_SPRG5, "SPRG5",
2176                  SPR_NOACCESS, SPR_NOACCESS,
2177                  spr_read_generic, &spr_write_generic,
2178                  0x00000000);
2179     spr_register(env, SPR_SPRG6, "SPRG6",
2180                  SPR_NOACCESS, SPR_NOACCESS,
2181                  spr_read_generic, &spr_write_generic,
2182                  0x00000000);
2183     spr_register(env, SPR_SPRG7, "SPRG7",
2184                  SPR_NOACCESS, SPR_NOACCESS,
2185                  spr_read_generic, &spr_write_generic,
2186                  0x00000000);
2187     gen_spr_usprgh(env);
2188 }
2189
2190 /* SPR shared between PowerPC 401 & 403 implementations */
2191 static void gen_spr_401_403 (CPUPPCState *env)
2192 {
2193     /* Time base */
2194     spr_register(env, SPR_403_VTBL,  "TBL",
2195                  &spr_read_tbl, SPR_NOACCESS,
2196                  &spr_read_tbl, SPR_NOACCESS,
2197                  0x00000000);
2198     spr_register(env, SPR_403_TBL,   "TBL",
2199                  SPR_NOACCESS, SPR_NOACCESS,
2200                  SPR_NOACCESS, &spr_write_tbl,
2201                  0x00000000);
2202     spr_register(env, SPR_403_VTBU,  "TBU",
2203                  &spr_read_tbu, SPR_NOACCESS,
2204                  &spr_read_tbu, SPR_NOACCESS,
2205                  0x00000000);
2206     spr_register(env, SPR_403_TBU,   "TBU",
2207                  SPR_NOACCESS, SPR_NOACCESS,
2208                  SPR_NOACCESS, &spr_write_tbu,
2209                  0x00000000);
2210     /* Debug */
2211     /* not emulated, as QEMU do not emulate caches */
2212     spr_register(env, SPR_403_CDBCR, "CDBCR",
2213                  SPR_NOACCESS, SPR_NOACCESS,
2214                  &spr_read_generic, &spr_write_generic,
2215                  0x00000000);
2216 }
2217
2218 /* SPR specific to PowerPC 401 implementation */
2219 static void gen_spr_401 (CPUPPCState *env)
2220 {
2221     /* Debug interface */
2222     /* XXX : not implemented */
2223     spr_register(env, SPR_40x_DBCR0, "DBCR",
2224                  SPR_NOACCESS, SPR_NOACCESS,
2225                  &spr_read_generic, &spr_write_40x_dbcr0,
2226                  0x00000000);
2227     /* XXX : not implemented */
2228     spr_register(env, SPR_40x_DBSR, "DBSR",
2229                  SPR_NOACCESS, SPR_NOACCESS,
2230                  &spr_read_generic, &spr_write_clear,
2231                  /* Last reset was system reset */
2232                  0x00000300);
2233     /* XXX : not implemented */
2234     spr_register(env, SPR_40x_DAC1, "DAC",
2235                  SPR_NOACCESS, SPR_NOACCESS,
2236                  &spr_read_generic, &spr_write_generic,
2237                  0x00000000);
2238     /* XXX : not implemented */
2239     spr_register(env, SPR_40x_IAC1, "IAC",
2240                  SPR_NOACCESS, SPR_NOACCESS,
2241                  &spr_read_generic, &spr_write_generic,
2242                  0x00000000);
2243     /* Storage control */
2244     /* XXX: TODO: not implemented */
2245     spr_register(env, SPR_405_SLER, "SLER",
2246                  SPR_NOACCESS, SPR_NOACCESS,
2247                  &spr_read_generic, &spr_write_40x_sler,
2248                  0x00000000);
2249     /* not emulated, as QEMU never does speculative access */
2250     spr_register(env, SPR_40x_SGR, "SGR",
2251                  SPR_NOACCESS, SPR_NOACCESS,
2252                  &spr_read_generic, &spr_write_generic,
2253                  0xFFFFFFFF);
2254     /* not emulated, as QEMU do not emulate caches */
2255     spr_register(env, SPR_40x_DCWR, "DCWR",
2256                  SPR_NOACCESS, SPR_NOACCESS,
2257                  &spr_read_generic, &spr_write_generic,
2258                  0x00000000);
2259 }
2260
2261 static void gen_spr_401x2 (CPUPPCState *env)
2262 {
2263     gen_spr_401(env);
2264     spr_register(env, SPR_40x_PID, "PID",
2265                  SPR_NOACCESS, SPR_NOACCESS,
2266                  &spr_read_generic, &spr_write_generic,
2267                  0x00000000);
2268     spr_register(env, SPR_40x_ZPR, "ZPR",
2269                  SPR_NOACCESS, SPR_NOACCESS,
2270                  &spr_read_generic, &spr_write_generic,
2271                  0x00000000);
2272 }
2273
2274 /* SPR specific to PowerPC 403 implementation */
2275 static void gen_spr_403 (CPUPPCState *env)
2276 {
2277     /* Debug interface */
2278     /* XXX : not implemented */
2279     spr_register(env, SPR_40x_DBCR0, "DBCR0",
2280                  SPR_NOACCESS, SPR_NOACCESS,
2281                  &spr_read_generic, &spr_write_40x_dbcr0,
2282                  0x00000000);
2283     /* XXX : not implemented */
2284     spr_register(env, SPR_40x_DBSR, "DBSR",
2285                  SPR_NOACCESS, SPR_NOACCESS,
2286                  &spr_read_generic, &spr_write_clear,
2287                  /* Last reset was system reset */
2288                  0x00000300);
2289     /* XXX : not implemented */
2290     spr_register(env, SPR_40x_DAC1, "DAC1",
2291                  SPR_NOACCESS, SPR_NOACCESS,
2292                  &spr_read_generic, &spr_write_generic,
2293                  0x00000000);
2294     /* XXX : not implemented */
2295     spr_register(env, SPR_40x_DAC2, "DAC2",
2296                  SPR_NOACCESS, SPR_NOACCESS,
2297                  &spr_read_generic, &spr_write_generic,
2298                  0x00000000);
2299     /* XXX : not implemented */
2300     spr_register(env, SPR_40x_IAC1, "IAC1",
2301                  SPR_NOACCESS, SPR_NOACCESS,
2302                  &spr_read_generic, &spr_write_generic,
2303                  0x00000000);
2304     /* XXX : not implemented */
2305     spr_register(env, SPR_40x_IAC2, "IAC2",
2306                  SPR_NOACCESS, SPR_NOACCESS,
2307                  &spr_read_generic, &spr_write_generic,
2308                  0x00000000);
2309 }
2310
2311 static void gen_spr_403_real (CPUPPCState *env)
2312 {
2313     spr_register(env, SPR_403_PBL1,  "PBL1",
2314                  SPR_NOACCESS, SPR_NOACCESS,
2315                  &spr_read_403_pbr, &spr_write_403_pbr,
2316                  0x00000000);
2317     spr_register(env, SPR_403_PBU1,  "PBU1",
2318                  SPR_NOACCESS, SPR_NOACCESS,
2319                  &spr_read_403_pbr, &spr_write_403_pbr,
2320                  0x00000000);
2321     spr_register(env, SPR_403_PBL2,  "PBL2",
2322                  SPR_NOACCESS, SPR_NOACCESS,
2323                  &spr_read_403_pbr, &spr_write_403_pbr,
2324                  0x00000000);
2325     spr_register(env, SPR_403_PBU2,  "PBU2",
2326                  SPR_NOACCESS, SPR_NOACCESS,
2327                  &spr_read_403_pbr, &spr_write_403_pbr,
2328                  0x00000000);
2329 }
2330
2331 static void gen_spr_403_mmu (CPUPPCState *env)
2332 {
2333     /* MMU */
2334     spr_register(env, SPR_40x_PID, "PID",
2335                  SPR_NOACCESS, SPR_NOACCESS,
2336                  &spr_read_generic, &spr_write_generic,
2337                  0x00000000);
2338     spr_register(env, SPR_40x_ZPR, "ZPR",
2339                  SPR_NOACCESS, SPR_NOACCESS,
2340                  &spr_read_generic, &spr_write_generic,
2341                  0x00000000);
2342 }
2343
2344 /* SPR specific to PowerPC compression coprocessor extension */
2345 static void gen_spr_compress (CPUPPCState *env)
2346 {
2347     /* XXX : not implemented */
2348     spr_register(env, SPR_401_SKR, "SKR",
2349                  SPR_NOACCESS, SPR_NOACCESS,
2350                  &spr_read_generic, &spr_write_generic,
2351                  0x00000000);
2352 }
2353
2354 static void gen_spr_5xx_8xx (CPUPPCState *env)
2355 {
2356     /* Exception processing */
2357     spr_register_kvm(env, SPR_DSISR, "DSISR",
2358                      SPR_NOACCESS, SPR_NOACCESS,
2359                      &spr_read_generic, &spr_write_generic,
2360                      KVM_REG_PPC_DSISR, 0x00000000);
2361     spr_register_kvm(env, SPR_DAR, "DAR",
2362                      SPR_NOACCESS, SPR_NOACCESS,
2363                      &spr_read_generic, &spr_write_generic,
2364                      KVM_REG_PPC_DAR, 0x00000000);
2365     /* Timer */
2366     spr_register(env, SPR_DECR, "DECR",
2367                  SPR_NOACCESS, SPR_NOACCESS,
2368                  &spr_read_decr, &spr_write_decr,
2369                  0x00000000);
2370     /* XXX : not implemented */
2371     spr_register(env, SPR_MPC_EIE, "EIE",
2372                  SPR_NOACCESS, SPR_NOACCESS,
2373                  &spr_read_generic, &spr_write_generic,
2374                  0x00000000);
2375     /* XXX : not implemented */
2376     spr_register(env, SPR_MPC_EID, "EID",
2377                  SPR_NOACCESS, SPR_NOACCESS,
2378                  &spr_read_generic, &spr_write_generic,
2379                  0x00000000);
2380     /* XXX : not implemented */
2381     spr_register(env, SPR_MPC_NRI, "NRI",
2382                  SPR_NOACCESS, SPR_NOACCESS,
2383                  &spr_read_generic, &spr_write_generic,
2384                  0x00000000);
2385     /* XXX : not implemented */
2386     spr_register(env, SPR_MPC_CMPA, "CMPA",
2387                  SPR_NOACCESS, SPR_NOACCESS,
2388                  &spr_read_generic, &spr_write_generic,
2389                  0x00000000);
2390     /* XXX : not implemented */
2391     spr_register(env, SPR_MPC_CMPB, "CMPB",
2392                  SPR_NOACCESS, SPR_NOACCESS,
2393                  &spr_read_generic, &spr_write_generic,
2394                  0x00000000);
2395     /* XXX : not implemented */
2396     spr_register(env, SPR_MPC_CMPC, "CMPC",
2397                  SPR_NOACCESS, SPR_NOACCESS,
2398                  &spr_read_generic, &spr_write_generic,
2399                  0x00000000);
2400     /* XXX : not implemented */
2401     spr_register(env, SPR_MPC_CMPD, "CMPD",
2402                  SPR_NOACCESS, SPR_NOACCESS,
2403                  &spr_read_generic, &spr_write_generic,
2404                  0x00000000);
2405     /* XXX : not implemented */
2406     spr_register(env, SPR_MPC_ECR, "ECR",
2407                  SPR_NOACCESS, SPR_NOACCESS,
2408                  &spr_read_generic, &spr_write_generic,
2409                  0x00000000);
2410     /* XXX : not implemented */
2411     spr_register(env, SPR_MPC_DER, "DER",
2412                  SPR_NOACCESS, SPR_NOACCESS,
2413                  &spr_read_generic, &spr_write_generic,
2414                  0x00000000);
2415     /* XXX : not implemented */
2416     spr_register(env, SPR_MPC_COUNTA, "COUNTA",
2417                  SPR_NOACCESS, SPR_NOACCESS,
2418                  &spr_read_generic, &spr_write_generic,
2419                  0x00000000);
2420     /* XXX : not implemented */
2421     spr_register(env, SPR_MPC_COUNTB, "COUNTB",
2422                  SPR_NOACCESS, SPR_NOACCESS,
2423                  &spr_read_generic, &spr_write_generic,
2424                  0x00000000);
2425     /* XXX : not implemented */
2426     spr_register(env, SPR_MPC_CMPE, "CMPE",
2427                  SPR_NOACCESS, SPR_NOACCESS,
2428                  &spr_read_generic, &spr_write_generic,
2429                  0x00000000);
2430     /* XXX : not implemented */
2431     spr_register(env, SPR_MPC_CMPF, "CMPF",
2432                  SPR_NOACCESS, SPR_NOACCESS,
2433                  &spr_read_generic, &spr_write_generic,
2434                  0x00000000);
2435     /* XXX : not implemented */
2436     spr_register(env, SPR_MPC_CMPG, "CMPG",
2437                  SPR_NOACCESS, SPR_NOACCESS,
2438                  &spr_read_generic, &spr_write_generic,
2439                  0x00000000);
2440     /* XXX : not implemented */
2441     spr_register(env, SPR_MPC_CMPH, "CMPH",
2442                  SPR_NOACCESS, SPR_NOACCESS,
2443                  &spr_read_generic, &spr_write_generic,
2444                  0x00000000);
2445     /* XXX : not implemented */
2446     spr_register(env, SPR_MPC_LCTRL1, "LCTRL1",
2447                  SPR_NOACCESS, SPR_NOACCESS,
2448                  &spr_read_generic, &spr_write_generic,
2449                  0x00000000);
2450     /* XXX : not implemented */
2451     spr_register(env, SPR_MPC_LCTRL2, "LCTRL2",
2452                  SPR_NOACCESS, SPR_NOACCESS,
2453                  &spr_read_generic, &spr_write_generic,
2454                  0x00000000);
2455     /* XXX : not implemented */
2456     spr_register(env, SPR_MPC_BAR, "BAR",
2457                  SPR_NOACCESS, SPR_NOACCESS,
2458                  &spr_read_generic, &spr_write_generic,
2459                  0x00000000);
2460     /* XXX : not implemented */
2461     spr_register(env, SPR_MPC_DPDR, "DPDR",
2462                  SPR_NOACCESS, SPR_NOACCESS,
2463                  &spr_read_generic, &spr_write_generic,
2464                  0x00000000);
2465     /* XXX : not implemented */
2466     spr_register(env, SPR_MPC_IMMR, "IMMR",
2467                  SPR_NOACCESS, SPR_NOACCESS,
2468                  &spr_read_generic, &spr_write_generic,
2469                  0x00000000);
2470 }
2471
2472 static void gen_spr_5xx (CPUPPCState *env)
2473 {
2474     /* XXX : not implemented */
2475     spr_register(env, SPR_RCPU_MI_GRA, "MI_GRA",
2476                  SPR_NOACCESS, SPR_NOACCESS,
2477                  &spr_read_generic, &spr_write_generic,
2478                  0x00000000);
2479     /* XXX : not implemented */
2480     spr_register(env, SPR_RCPU_L2U_GRA, "L2U_GRA",
2481                  SPR_NOACCESS, SPR_NOACCESS,
2482                  &spr_read_generic, &spr_write_generic,
2483                  0x00000000);
2484     /* XXX : not implemented */
2485     spr_register(env, SPR_RPCU_BBCMCR, "L2U_BBCMCR",
2486                  SPR_NOACCESS, SPR_NOACCESS,
2487                  &spr_read_generic, &spr_write_generic,
2488                  0x00000000);
2489     /* XXX : not implemented */
2490     spr_register(env, SPR_RCPU_L2U_MCR, "L2U_MCR",
2491                  SPR_NOACCESS, SPR_NOACCESS,
2492                  &spr_read_generic, &spr_write_generic,
2493                  0x00000000);
2494     /* XXX : not implemented */
2495     spr_register(env, SPR_RCPU_MI_RBA0, "MI_RBA0",
2496                  SPR_NOACCESS, SPR_NOACCESS,
2497                  &spr_read_generic, &spr_write_generic,
2498                  0x00000000);
2499     /* XXX : not implemented */
2500     spr_register(env, SPR_RCPU_MI_RBA1, "MI_RBA1",
2501                  SPR_NOACCESS, SPR_NOACCESS,
2502                  &spr_read_generic, &spr_write_generic,
2503                  0x00000000);
2504     /* XXX : not implemented */
2505     spr_register(env, SPR_RCPU_MI_RBA2, "MI_RBA2",
2506                  SPR_NOACCESS, SPR_NOACCESS,
2507                  &spr_read_generic, &spr_write_generic,
2508                  0x00000000);
2509     /* XXX : not implemented */
2510     spr_register(env, SPR_RCPU_MI_RBA3, "MI_RBA3",
2511                  SPR_NOACCESS, SPR_NOACCESS,
2512                  &spr_read_generic, &spr_write_generic,
2513                  0x00000000);
2514     /* XXX : not implemented */
2515     spr_register(env, SPR_RCPU_L2U_RBA0, "L2U_RBA0",
2516                  SPR_NOACCESS, SPR_NOACCESS,
2517                  &spr_read_generic, &spr_write_generic,
2518                  0x00000000);
2519     /* XXX : not implemented */
2520     spr_register(env, SPR_RCPU_L2U_RBA1, "L2U_RBA1",
2521                  SPR_NOACCESS, SPR_NOACCESS,
2522                  &spr_read_generic, &spr_write_generic,
2523                  0x00000000);
2524     /* XXX : not implemented */
2525     spr_register(env, SPR_RCPU_L2U_RBA2, "L2U_RBA2",
2526                  SPR_NOACCESS, SPR_NOACCESS,
2527                  &spr_read_generic, &spr_write_generic,
2528                  0x00000000);
2529     /* XXX : not implemented */
2530     spr_register(env, SPR_RCPU_L2U_RBA3, "L2U_RBA3",
2531                  SPR_NOACCESS, SPR_NOACCESS,
2532                  &spr_read_generic, &spr_write_generic,
2533                  0x00000000);
2534     /* XXX : not implemented */
2535     spr_register(env, SPR_RCPU_MI_RA0, "MI_RA0",
2536                  SPR_NOACCESS, SPR_NOACCESS,
2537                  &spr_read_generic, &spr_write_generic,
2538                  0x00000000);
2539     /* XXX : not implemented */
2540     spr_register(env, SPR_RCPU_MI_RA1, "MI_RA1",
2541                  SPR_NOACCESS, SPR_NOACCESS,
2542                  &spr_read_generic, &spr_write_generic,
2543                  0x00000000);
2544     /* XXX : not implemented */
2545     spr_register(env, SPR_RCPU_MI_RA2, "MI_RA2",
2546                  SPR_NOACCESS, SPR_NOACCESS,
2547                  &spr_read_generic, &spr_write_generic,
2548                  0x00000000);
2549     /* XXX : not implemented */
2550     spr_register(env, SPR_RCPU_MI_RA3, "MI_RA3",
2551                  SPR_NOACCESS, SPR_NOACCESS,
2552                  &spr_read_generic, &spr_write_generic,
2553                  0x00000000);
2554     /* XXX : not implemented */
2555     spr_register(env, SPR_RCPU_L2U_RA0, "L2U_RA0",
2556                  SPR_NOACCESS, SPR_NOACCESS,
2557                  &spr_read_generic, &spr_write_generic,
2558                  0x00000000);
2559     /* XXX : not implemented */
2560     spr_register(env, SPR_RCPU_L2U_RA1, "L2U_RA1",
2561                  SPR_NOACCESS, SPR_NOACCESS,
2562                  &spr_read_generic, &spr_write_generic,
2563                  0x00000000);
2564     /* XXX : not implemented */
2565     spr_register(env, SPR_RCPU_L2U_RA2, "L2U_RA2",
2566                  SPR_NOACCESS, SPR_NOACCESS,
2567                  &spr_read_generic, &spr_write_generic,
2568                  0x00000000);
2569     /* XXX : not implemented */
2570     spr_register(env, SPR_RCPU_L2U_RA3, "L2U_RA3",
2571                  SPR_NOACCESS, SPR_NOACCESS,
2572                  &spr_read_generic, &spr_write_generic,
2573                  0x00000000);
2574     /* XXX : not implemented */
2575     spr_register(env, SPR_RCPU_FPECR, "FPECR",
2576                  SPR_NOACCESS, SPR_NOACCESS,
2577                  &spr_read_generic, &spr_write_generic,
2578                  0x00000000);
2579 }
2580
2581 static void gen_spr_8xx (CPUPPCState *env)
2582 {
2583     /* XXX : not implemented */
2584     spr_register(env, SPR_MPC_IC_CST, "IC_CST",
2585                  SPR_NOACCESS, SPR_NOACCESS,
2586                  &spr_read_generic, &spr_write_generic,
2587                  0x00000000);
2588     /* XXX : not implemented */
2589     spr_register(env, SPR_MPC_IC_ADR, "IC_ADR",
2590                  SPR_NOACCESS, SPR_NOACCESS,
2591                  &spr_read_generic, &spr_write_generic,
2592                  0x00000000);
2593     /* XXX : not implemented */
2594     spr_register(env, SPR_MPC_IC_DAT, "IC_DAT",
2595                  SPR_NOACCESS, SPR_NOACCESS,
2596                  &spr_read_generic, &spr_write_generic,
2597                  0x00000000);
2598     /* XXX : not implemented */
2599     spr_register(env, SPR_MPC_DC_CST, "DC_CST",
2600                  SPR_NOACCESS, SPR_NOACCESS,
2601                  &spr_read_generic, &spr_write_generic,
2602                  0x00000000);
2603     /* XXX : not implemented */
2604     spr_register(env, SPR_MPC_DC_ADR, "DC_ADR",
2605                  SPR_NOACCESS, SPR_NOACCESS,
2606                  &spr_read_generic, &spr_write_generic,
2607                  0x00000000);
2608     /* XXX : not implemented */
2609     spr_register(env, SPR_MPC_DC_DAT, "DC_DAT",
2610                  SPR_NOACCESS, SPR_NOACCESS,
2611                  &spr_read_generic, &spr_write_generic,
2612                  0x00000000);
2613     /* XXX : not implemented */
2614     spr_register(env, SPR_MPC_MI_CTR, "MI_CTR",
2615                  SPR_NOACCESS, SPR_NOACCESS,
2616                  &spr_read_generic, &spr_write_generic,
2617                  0x00000000);
2618     /* XXX : not implemented */
2619     spr_register(env, SPR_MPC_MI_AP, "MI_AP",
2620                  SPR_NOACCESS, SPR_NOACCESS,
2621                  &spr_read_generic, &spr_write_generic,
2622                  0x00000000);
2623     /* XXX : not implemented */
2624     spr_register(env, SPR_MPC_MI_EPN, "MI_EPN",
2625                  SPR_NOACCESS, SPR_NOACCESS,
2626                  &spr_read_generic, &spr_write_generic,
2627                  0x00000000);
2628     /* XXX : not implemented */
2629     spr_register(env, SPR_MPC_MI_TWC, "MI_TWC",
2630                  SPR_NOACCESS, SPR_NOACCESS,
2631                  &spr_read_generic, &spr_write_generic,
2632                  0x00000000);
2633     /* XXX : not implemented */
2634     spr_register(env, SPR_MPC_MI_RPN, "MI_RPN",
2635                  SPR_NOACCESS, SPR_NOACCESS,
2636                  &spr_read_generic, &spr_write_generic,
2637                  0x00000000);
2638     /* XXX : not implemented */
2639     spr_register(env, SPR_MPC_MI_DBCAM, "MI_DBCAM",
2640                  SPR_NOACCESS, SPR_NOACCESS,
2641                  &spr_read_generic, &spr_write_generic,
2642                  0x00000000);
2643     /* XXX : not implemented */
2644     spr_register(env, SPR_MPC_MI_DBRAM0, "MI_DBRAM0",
2645                  SPR_NOACCESS, SPR_NOACCESS,
2646                  &spr_read_generic, &spr_write_generic,
2647                  0x00000000);
2648     /* XXX : not implemented */
2649     spr_register(env, SPR_MPC_MI_DBRAM1, "MI_DBRAM1",
2650                  SPR_NOACCESS, SPR_NOACCESS,
2651                  &spr_read_generic, &spr_write_generic,
2652                  0x00000000);
2653     /* XXX : not implemented */
2654     spr_register(env, SPR_MPC_MD_CTR, "MD_CTR",
2655                  SPR_NOACCESS, SPR_NOACCESS,
2656                  &spr_read_generic, &spr_write_generic,
2657                  0x00000000);
2658     /* XXX : not implemented */
2659     spr_register(env, SPR_MPC_MD_CASID, "MD_CASID",
2660                  SPR_NOACCESS, SPR_NOACCESS,
2661                  &spr_read_generic, &spr_write_generic,
2662                  0x00000000);
2663     /* XXX : not implemented */
2664     spr_register(env, SPR_MPC_MD_AP, "MD_AP",
2665                  SPR_NOACCESS, SPR_NOACCESS,
2666                  &spr_read_generic, &spr_write_generic,
2667                  0x00000000);
2668     /* XXX : not implemented */
2669     spr_register(env, SPR_MPC_MD_EPN, "MD_EPN",
2670                  SPR_NOACCESS, SPR_NOACCESS,
2671                  &spr_read_generic, &spr_write_generic,
2672                  0x00000000);
2673     /* XXX : not implemented */
2674     spr_register(env, SPR_MPC_MD_TWB, "MD_TWB",
2675                  SPR_NOACCESS, SPR_NOACCESS,
2676                  &spr_read_generic, &spr_write_generic,
2677                  0x00000000);
2678     /* XXX : not implemented */
2679     spr_register(env, SPR_MPC_MD_TWC, "MD_TWC",
2680                  SPR_NOACCESS, SPR_NOACCESS,
2681                  &spr_read_generic, &spr_write_generic,
2682                  0x00000000);
2683     /* XXX : not implemented */
2684     spr_register(env, SPR_MPC_MD_RPN, "MD_RPN",
2685                  SPR_NOACCESS, SPR_NOACCESS,
2686                  &spr_read_generic, &spr_write_generic,
2687                  0x00000000);
2688     /* XXX : not implemented */
2689     spr_register(env, SPR_MPC_MD_TW, "MD_TW",
2690                  SPR_NOACCESS, SPR_NOACCESS,
2691                  &spr_read_generic, &spr_write_generic,
2692                  0x00000000);
2693     /* XXX : not implemented */
2694     spr_register(env, SPR_MPC_MD_DBCAM, "MD_DBCAM",
2695                  SPR_NOACCESS, SPR_NOACCESS,
2696                  &spr_read_generic, &spr_write_generic,
2697                  0x00000000);
2698     /* XXX : not implemented */
2699     spr_register(env, SPR_MPC_MD_DBRAM0, "MD_DBRAM0",
2700                  SPR_NOACCESS, SPR_NOACCESS,
2701                  &spr_read_generic, &spr_write_generic,
2702                  0x00000000);
2703     /* XXX : not implemented */
2704     spr_register(env, SPR_MPC_MD_DBRAM1, "MD_DBRAM1",
2705                  SPR_NOACCESS, SPR_NOACCESS,
2706                  &spr_read_generic, &spr_write_generic,
2707                  0x00000000);
2708 }
2709
2710 // XXX: TODO
2711 /*
2712  * AMR     => SPR 29 (Power 2.04)
2713  * CTRL    => SPR 136 (Power 2.04)
2714  * CTRL    => SPR 152 (Power 2.04)
2715  * SCOMC   => SPR 276 (64 bits ?)
2716  * SCOMD   => SPR 277 (64 bits ?)
2717  * TBU40   => SPR 286 (Power 2.04 hypv)
2718  * HSPRG0  => SPR 304 (Power 2.04 hypv)
2719  * HSPRG1  => SPR 305 (Power 2.04 hypv)
2720  * HDSISR  => SPR 306 (Power 2.04 hypv)
2721  * HDAR    => SPR 307 (Power 2.04 hypv)
2722  * PURR    => SPR 309 (Power 2.04 hypv)
2723  * HDEC    => SPR 310 (Power 2.04 hypv)
2724  * HIOR    => SPR 311 (hypv)
2725  * RMOR    => SPR 312 (970)
2726  * HRMOR   => SPR 313 (Power 2.04 hypv)
2727  * HSRR0   => SPR 314 (Power 2.04 hypv)
2728  * HSRR1   => SPR 315 (Power 2.04 hypv)
2729  * LPIDR   => SPR 317 (970)
2730  * EPR     => SPR 702 (Power 2.04 emb)
2731  * perf    => 768-783 (Power 2.04)
2732  * perf    => 784-799 (Power 2.04)
2733  * PPR     => SPR 896 (Power 2.04)
2734  * EPLC    => SPR 947 (Power 2.04 emb)
2735  * EPSC    => SPR 948 (Power 2.04 emb)
2736  * DABRX   => 1015    (Power 2.04 hypv)
2737  * FPECR   => SPR 1022 (?)
2738  * ... and more (thermal management, performance counters, ...)
2739  */
2740
2741 /*****************************************************************************/
2742 /* Exception vectors models                                                  */
2743 static void init_excp_4xx_real (CPUPPCState *env)
2744 {
2745 #if !defined(CONFIG_USER_ONLY)
2746     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
2747     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2748     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2749     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2750     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2751     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2752     env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
2753     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
2754     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
2755     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
2756     env->ivor_mask = 0x0000FFF0UL;
2757     env->ivpr_mask = 0xFFFF0000UL;
2758     /* Hardware reset vector */
2759     env->hreset_vector = 0xFFFFFFFCUL;
2760 #endif
2761 }
2762
2763 static void init_excp_4xx_softmmu (CPUPPCState *env)
2764 {
2765 #if !defined(CONFIG_USER_ONLY)
2766     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
2767     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2768     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2769     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2770     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2771     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2772     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2773     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2774     env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
2775     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
2776     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
2777     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001100;
2778     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001200;
2779     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
2780     env->ivor_mask = 0x0000FFF0UL;
2781     env->ivpr_mask = 0xFFFF0000UL;
2782     /* Hardware reset vector */
2783     env->hreset_vector = 0xFFFFFFFCUL;
2784 #endif
2785 }
2786
2787 static void init_excp_MPC5xx (CPUPPCState *env)
2788 {
2789 #if !defined(CONFIG_USER_ONLY)
2790     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2791     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2792     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2793     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2794     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2795     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
2796     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2797     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2798     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2799     env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
2800     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
2801     env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
2802     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
2803     env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
2804     env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
2805     env->ivor_mask = 0x0000FFF0UL;
2806     env->ivpr_mask = 0xFFFF0000UL;
2807     /* Hardware reset vector */
2808     env->hreset_vector = 0x00000100UL;
2809 #endif
2810 }
2811
2812 static void init_excp_MPC8xx (CPUPPCState *env)
2813 {
2814 #if !defined(CONFIG_USER_ONLY)
2815     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2816     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2817     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2818     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2819     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2820     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2821     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2822     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
2823     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2824     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2825     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2826     env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
2827     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
2828     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001100;
2829     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001200;
2830     env->excp_vectors[POWERPC_EXCP_ITLBE]    = 0x00001300;
2831     env->excp_vectors[POWERPC_EXCP_DTLBE]    = 0x00001400;
2832     env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
2833     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
2834     env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
2835     env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
2836     env->ivor_mask = 0x0000FFF0UL;
2837     env->ivpr_mask = 0xFFFF0000UL;
2838     /* Hardware reset vector */
2839     env->hreset_vector = 0x00000100UL;
2840 #endif
2841 }
2842
2843 static void init_excp_G2 (CPUPPCState *env)
2844 {
2845 #if !defined(CONFIG_USER_ONLY)
2846     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2847     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2848     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2849     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2850     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2851     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2852     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2853     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
2854     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2855     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000A00;
2856     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2857     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2858     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
2859     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
2860     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
2861     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
2862     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
2863     /* Hardware reset vector */
2864     env->hreset_vector = 0x00000100UL;
2865 #endif
2866 }
2867
2868 static void init_excp_e200(CPUPPCState *env, target_ulong ivpr_mask)
2869 {
2870 #if !defined(CONFIG_USER_ONLY)
2871     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000FFC;
2872     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
2873     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
2874     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
2875     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
2876     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
2877     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
2878     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
2879     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
2880     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
2881     env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
2882     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
2883     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
2884     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
2885     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
2886     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
2887     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
2888     env->excp_vectors[POWERPC_EXCP_SPEU]     = 0x00000000;
2889     env->excp_vectors[POWERPC_EXCP_EFPDI]    = 0x00000000;
2890     env->excp_vectors[POWERPC_EXCP_EFPRI]    = 0x00000000;
2891     env->ivor_mask = 0x0000FFF7UL;
2892     env->ivpr_mask = ivpr_mask;
2893     /* Hardware reset vector */
2894     env->hreset_vector = 0xFFFFFFFCUL;
2895 #endif
2896 }
2897
2898 static void init_excp_BookE (CPUPPCState *env)
2899 {
2900 #if !defined(CONFIG_USER_ONLY)
2901     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
2902     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
2903     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
2904     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
2905     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
2906     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
2907     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
2908     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
2909     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
2910     env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
2911     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
2912     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
2913     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
2914     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
2915     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
2916     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
2917     env->ivor_mask = 0x0000FFF0UL;
2918     env->ivpr_mask = 0xFFFF0000UL;
2919     /* Hardware reset vector */
2920     env->hreset_vector = 0xFFFFFFFCUL;
2921 #endif
2922 }
2923
2924 static void init_excp_601 (CPUPPCState *env)
2925 {
2926 #if !defined(CONFIG_USER_ONLY)
2927     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2928     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2929     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2930     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2931     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2932     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2933     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2934     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
2935     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2936     env->excp_vectors[POWERPC_EXCP_IO]       = 0x00000A00;
2937     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2938     env->excp_vectors[POWERPC_EXCP_RUNM]     = 0x00002000;
2939     /* Hardware reset vector */
2940     env->hreset_vector = 0x00000100UL;
2941 #endif
2942 }
2943
2944 static void init_excp_602 (CPUPPCState *env)
2945 {
2946 #if !defined(CONFIG_USER_ONLY)
2947     /* XXX: exception prefix has a special behavior on 602 */
2948     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2949     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2950     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2951     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2952     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2953     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2954     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2955     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
2956     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2957     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2958     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2959     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
2960     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
2961     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
2962     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
2963     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
2964     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001500;
2965     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001600;
2966     /* Hardware reset vector */
2967     env->hreset_vector = 0x00000100UL;
2968 #endif
2969 }
2970
2971 static void init_excp_603 (CPUPPCState *env)
2972 {
2973 #if !defined(CONFIG_USER_ONLY)
2974     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2975     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2976     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2977     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2978     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2979     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2980     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2981     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
2982     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2983     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2984     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2985     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
2986     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
2987     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
2988     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
2989     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
2990     /* Hardware reset vector */
2991     env->hreset_vector = 0x00000100UL;
2992 #endif
2993 }
2994
2995 static void init_excp_604 (CPUPPCState *env)
2996 {
2997 #if !defined(CONFIG_USER_ONLY)
2998     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2999     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3000     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3001     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3002     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3003     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3004     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3005     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3006     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3007     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3008     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3009     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3010     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3011     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3012     /* Hardware reset vector */
3013     env->hreset_vector = 0x00000100UL;
3014 #endif
3015 }
3016
3017 static void init_excp_7x0 (CPUPPCState *env)
3018 {
3019 #if !defined(CONFIG_USER_ONLY)
3020     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3021     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3022     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3023     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3024     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3025     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3026     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3027     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3028     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3029     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3030     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3031     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3032     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3033     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3034     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3035     /* Hardware reset vector */
3036     env->hreset_vector = 0x00000100UL;
3037 #endif
3038 }
3039
3040 static void init_excp_750cl (CPUPPCState *env)
3041 {
3042 #if !defined(CONFIG_USER_ONLY)
3043     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3044     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3045     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3046     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3047     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3048     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3049     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3050     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3051     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3052     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3053     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3054     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3055     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3056     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3057     /* Hardware reset vector */
3058     env->hreset_vector = 0x00000100UL;
3059 #endif
3060 }
3061
3062 static void init_excp_750cx (CPUPPCState *env)
3063 {
3064 #if !defined(CONFIG_USER_ONLY)
3065     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3066     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3067     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3068     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3069     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3070     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3071     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3072     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3073     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3074     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3075     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3076     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3077     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3078     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3079     /* Hardware reset vector */
3080     env->hreset_vector = 0x00000100UL;
3081 #endif
3082 }
3083
3084 /* XXX: Check if this is correct */
3085 static void init_excp_7x5 (CPUPPCState *env)
3086 {
3087 #if !defined(CONFIG_USER_ONLY)
3088     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3089     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3090     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3091     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3092     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3093     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3094     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3095     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3096     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3097     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3098     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3099     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3100     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3101     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3102     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3103     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3104     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3105     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3106     /* Hardware reset vector */
3107     env->hreset_vector = 0x00000100UL;
3108 #endif
3109 }
3110
3111 static void init_excp_7400 (CPUPPCState *env)
3112 {
3113 #if !defined(CONFIG_USER_ONLY)
3114     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3115     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3116     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3117     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3118     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3119     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3120     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3121     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3122     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3123     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3124     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3125     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3126     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3127     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3128     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3129     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
3130     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3131     /* Hardware reset vector */
3132     env->hreset_vector = 0x00000100UL;
3133 #endif
3134 }
3135
3136 static void init_excp_7450 (CPUPPCState *env)
3137 {
3138 #if !defined(CONFIG_USER_ONLY)
3139     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3140     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3141     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3142     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3143     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3144     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3145     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3146     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3147     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3148     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3149     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3150     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3151     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3152     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3153     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3154     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3155     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3156     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3157     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
3158     /* Hardware reset vector */
3159     env->hreset_vector = 0x00000100UL;
3160 #endif
3161 }
3162
3163 #if defined (TARGET_PPC64)
3164 static void init_excp_970 (CPUPPCState *env)
3165 {
3166 #if !defined(CONFIG_USER_ONLY)
3167     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3168     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3169     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3170     env->excp_vectors[POWERPC_EXCP_DSEG]     = 0x00000380;
3171     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3172     env->excp_vectors[POWERPC_EXCP_ISEG]     = 0x00000480;
3173     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3174     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3175     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3176     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3177     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3178     env->excp_vectors[POWERPC_EXCP_HDECR]    = 0x00000980;
3179     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3180     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3181     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3182     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3183     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3184     env->excp_vectors[POWERPC_EXCP_MAINT]    = 0x00001600;
3185     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001700;
3186     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001800;
3187     /* Hardware reset vector */
3188     env->hreset_vector = 0x0000000000000100ULL;
3189 #endif
3190 }
3191
3192 static void init_excp_POWER7 (CPUPPCState *env)
3193 {
3194 #if !defined(CONFIG_USER_ONLY)
3195     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3196     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3197     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3198     env->excp_vectors[POWERPC_EXCP_DSEG]     = 0x00000380;
3199     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3200     env->excp_vectors[POWERPC_EXCP_ISEG]     = 0x00000480;
3201     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3202     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3203     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3204     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3205     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3206     env->excp_vectors[POWERPC_EXCP_HDECR]    = 0x00000980;
3207     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3208     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3209     env->excp_vectors[POWERPC_EXCP_HDSI]     = 0x00000E00;
3210     env->excp_vectors[POWERPC_EXCP_HISI]     = 0x00000E20;
3211     env->excp_vectors[POWERPC_EXCP_HV_EMU]   = 0x00000E40;
3212     env->excp_vectors[POWERPC_EXCP_HV_MAINT] = 0x00000E60;
3213     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3214     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3215     env->excp_vectors[POWERPC_EXCP_VSXU]     = 0x00000F40;
3216     /* Hardware reset vector */
3217     env->hreset_vector = 0x0000000000000100ULL;
3218 #endif
3219 }
3220
3221 static void init_excp_POWER8(CPUPPCState *env)
3222 {
3223     init_excp_POWER7(env);
3224
3225 #if !defined(CONFIG_USER_ONLY)
3226     env->excp_vectors[POWERPC_EXCP_SDOOR]    = 0x00000A00;
3227     env->excp_vectors[POWERPC_EXCP_FU]       = 0x00000F60;
3228     env->excp_vectors[POWERPC_EXCP_HV_FU]    = 0x00000F80;
3229     env->excp_vectors[POWERPC_EXCP_SDOOR_HV] = 0x00000E80;
3230 #endif
3231 }
3232
3233 #endif
3234
3235 /*****************************************************************************/
3236 /* Power management enable checks                                            */
3237 static int check_pow_none (CPUPPCState *env)
3238 {
3239     return 0;
3240 }
3241
3242 static int check_pow_nocheck (CPUPPCState *env)
3243 {
3244     return 1;
3245 }
3246
3247 static int check_pow_hid0 (CPUPPCState *env)
3248 {
3249     if (env->spr[SPR_HID0] & 0x00E00000)
3250         return 1;
3251
3252     return 0;
3253 }
3254
3255 static int check_pow_hid0_74xx (CPUPPCState *env)
3256 {
3257     if (env->spr[SPR_HID0] & 0x00600000)
3258         return 1;
3259
3260     return 0;
3261 }
3262
3263 static bool ppc_cpu_interrupts_big_endian_always(PowerPCCPU *cpu)
3264 {
3265     return true;
3266 }
3267
3268 #ifdef TARGET_PPC64
3269 static bool ppc_cpu_interrupts_big_endian_lpcr(PowerPCCPU *cpu)
3270 {
3271     return !(cpu->env.spr[SPR_LPCR] & LPCR_ILE);
3272 }
3273 #endif
3274
3275 /*****************************************************************************/
3276 /* PowerPC implementations definitions                                       */
3277
3278 #define POWERPC_FAMILY(_name)                                               \
3279     static void                                                             \
3280     glue(glue(ppc_, _name), _cpu_family_class_init)(ObjectClass *, void *); \
3281                                                                             \
3282     static const TypeInfo                                                   \
3283     glue(glue(ppc_, _name), _cpu_family_type_info) = {                      \
3284         .name = stringify(_name) "-family-" TYPE_POWERPC_CPU,               \
3285         .parent = TYPE_POWERPC_CPU,                                         \
3286         .abstract = true,                                                   \
3287         .class_init = glue(glue(ppc_, _name), _cpu_family_class_init),      \
3288     };                                                                      \
3289                                                                             \
3290     static void glue(glue(ppc_, _name), _cpu_family_register_types)(void)   \
3291     {                                                                       \
3292         type_register_static(                                               \
3293             &glue(glue(ppc_, _name), _cpu_family_type_info));               \
3294     }                                                                       \
3295                                                                             \
3296     type_init(glue(glue(ppc_, _name), _cpu_family_register_types))          \
3297                                                                             \
3298     static void glue(glue(ppc_, _name), _cpu_family_class_init)
3299
3300 static void init_proc_401 (CPUPPCState *env)
3301 {
3302     gen_spr_40x(env);
3303     gen_spr_401_403(env);
3304     gen_spr_401(env);
3305     init_excp_4xx_real(env);
3306     env->dcache_line_size = 32;
3307     env->icache_line_size = 32;
3308     /* Allocate hardware IRQ controller */
3309     ppc40x_irq_init(ppc_env_get_cpu(env));
3310
3311     SET_FIT_PERIOD(12, 16, 20, 24);
3312     SET_WDT_PERIOD(16, 20, 24, 28);
3313 }
3314
3315 POWERPC_FAMILY(401)(ObjectClass *oc, void *data)
3316 {
3317     DeviceClass *dc = DEVICE_CLASS(oc);
3318     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3319
3320     dc->desc = "PowerPC 401";
3321     pcc->init_proc = init_proc_401;
3322     pcc->check_pow = check_pow_nocheck;
3323     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3324                        PPC_WRTEE | PPC_DCR |
3325                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3326                        PPC_CACHE_DCBZ |
3327                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3328                        PPC_4xx_COMMON | PPC_40x_EXCP;
3329     pcc->msr_mask = (1ull << MSR_KEY) |
3330                     (1ull << MSR_POW) |
3331                     (1ull << MSR_CE) |
3332                     (1ull << MSR_ILE) |
3333                     (1ull << MSR_EE) |
3334                     (1ull << MSR_PR) |
3335                     (1ull << MSR_ME) |
3336                     (1ull << MSR_DE) |
3337                     (1ull << MSR_LE);
3338     pcc->mmu_model = POWERPC_MMU_REAL;
3339     pcc->excp_model = POWERPC_EXCP_40x;
3340     pcc->bus_model = PPC_FLAGS_INPUT_401;
3341     pcc->bfd_mach = bfd_mach_ppc_403;
3342     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3343                  POWERPC_FLAG_BUS_CLK;
3344 }
3345
3346 static void init_proc_401x2 (CPUPPCState *env)
3347 {
3348     gen_spr_40x(env);
3349     gen_spr_401_403(env);
3350     gen_spr_401x2(env);
3351     gen_spr_compress(env);
3352     /* Memory management */
3353 #if !defined(CONFIG_USER_ONLY)
3354     env->nb_tlb = 64;
3355     env->nb_ways = 1;
3356     env->id_tlbs = 0;
3357     env->tlb_type = TLB_EMB;
3358 #endif
3359     init_excp_4xx_softmmu(env);
3360     env->dcache_line_size = 32;
3361     env->icache_line_size = 32;
3362     /* Allocate hardware IRQ controller */
3363     ppc40x_irq_init(ppc_env_get_cpu(env));
3364
3365     SET_FIT_PERIOD(12, 16, 20, 24);
3366     SET_WDT_PERIOD(16, 20, 24, 28);
3367 }
3368
3369 POWERPC_FAMILY(401x2)(ObjectClass *oc, void *data)
3370 {
3371     DeviceClass *dc = DEVICE_CLASS(oc);
3372     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3373
3374     dc->desc = "PowerPC 401x2";
3375     pcc->init_proc = init_proc_401x2;
3376     pcc->check_pow = check_pow_nocheck;
3377     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3378                        PPC_DCR | PPC_WRTEE |
3379                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3380                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3381                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3382                        PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3383                        PPC_4xx_COMMON | PPC_40x_EXCP;
3384     pcc->msr_mask = (1ull << 20) |
3385                     (1ull << MSR_KEY) |
3386                     (1ull << MSR_POW) |
3387                     (1ull << MSR_CE) |
3388                     (1ull << MSR_ILE) |
3389                     (1ull << MSR_EE) |
3390                     (1ull << MSR_PR) |
3391                     (1ull << MSR_ME) |
3392                     (1ull << MSR_DE) |
3393                     (1ull << MSR_IR) |
3394                     (1ull << MSR_DR) |
3395                     (1ull << MSR_LE);
3396     pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3397     pcc->excp_model = POWERPC_EXCP_40x;
3398     pcc->bus_model = PPC_FLAGS_INPUT_401;
3399     pcc->bfd_mach = bfd_mach_ppc_403;
3400     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3401                  POWERPC_FLAG_BUS_CLK;
3402 }
3403
3404 static void init_proc_401x3 (CPUPPCState *env)
3405 {
3406     gen_spr_40x(env);
3407     gen_spr_401_403(env);
3408     gen_spr_401(env);
3409     gen_spr_401x2(env);
3410     gen_spr_compress(env);
3411     init_excp_4xx_softmmu(env);
3412     env->dcache_line_size = 32;
3413     env->icache_line_size = 32;
3414     /* Allocate hardware IRQ controller */
3415     ppc40x_irq_init(ppc_env_get_cpu(env));
3416
3417     SET_FIT_PERIOD(12, 16, 20, 24);
3418     SET_WDT_PERIOD(16, 20, 24, 28);
3419 }
3420
3421 POWERPC_FAMILY(401x3)(ObjectClass *oc, void *data)
3422 {
3423     DeviceClass *dc = DEVICE_CLASS(oc);
3424     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3425
3426     dc->desc = "PowerPC 401x3";
3427     pcc->init_proc = init_proc_401x3;
3428     pcc->check_pow = check_pow_nocheck;
3429     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3430                        PPC_DCR | PPC_WRTEE |
3431                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3432                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3433                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3434                        PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3435                        PPC_4xx_COMMON | PPC_40x_EXCP;
3436     pcc->msr_mask = (1ull << 20) |
3437                     (1ull << MSR_KEY) |
3438                     (1ull << MSR_POW) |
3439                     (1ull << MSR_CE) |
3440                     (1ull << MSR_ILE) |
3441                     (1ull << MSR_EE) |
3442                     (1ull << MSR_PR) |
3443                     (1ull << MSR_ME) |
3444                     (1ull << MSR_DWE) |
3445                     (1ull << MSR_DE) |
3446                     (1ull << MSR_IR) |
3447                     (1ull << MSR_DR) |
3448                     (1ull << MSR_LE);
3449     pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3450     pcc->excp_model = POWERPC_EXCP_40x;
3451     pcc->bus_model = PPC_FLAGS_INPUT_401;
3452     pcc->bfd_mach = bfd_mach_ppc_403;
3453     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3454                  POWERPC_FLAG_BUS_CLK;
3455 }
3456
3457 static void init_proc_IOP480 (CPUPPCState *env)
3458 {
3459     gen_spr_40x(env);
3460     gen_spr_401_403(env);
3461     gen_spr_401x2(env);
3462     gen_spr_compress(env);
3463     /* Memory management */
3464 #if !defined(CONFIG_USER_ONLY)
3465     env->nb_tlb = 64;
3466     env->nb_ways = 1;
3467     env->id_tlbs = 0;
3468     env->tlb_type = TLB_EMB;
3469 #endif
3470     init_excp_4xx_softmmu(env);
3471     env->dcache_line_size = 32;
3472     env->icache_line_size = 32;
3473     /* Allocate hardware IRQ controller */
3474     ppc40x_irq_init(ppc_env_get_cpu(env));
3475
3476     SET_FIT_PERIOD(8, 12, 16, 20);
3477     SET_WDT_PERIOD(16, 20, 24, 28);
3478 }
3479
3480 POWERPC_FAMILY(IOP480)(ObjectClass *oc, void *data)
3481 {
3482     DeviceClass *dc = DEVICE_CLASS(oc);
3483     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3484
3485     dc->desc = "IOP480";
3486     pcc->init_proc = init_proc_IOP480;
3487     pcc->check_pow = check_pow_nocheck;
3488     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3489                        PPC_DCR | PPC_WRTEE |
3490                        PPC_CACHE | PPC_CACHE_ICBI |  PPC_40x_ICBT |
3491                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3492                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3493                        PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3494                        PPC_4xx_COMMON | PPC_40x_EXCP;
3495     pcc->msr_mask = (1ull << 20) |
3496                     (1ull << MSR_KEY) |
3497                     (1ull << MSR_POW) |
3498                     (1ull << MSR_CE) |
3499                     (1ull << MSR_ILE) |
3500                     (1ull << MSR_EE) |
3501                     (1ull << MSR_PR) |
3502                     (1ull << MSR_ME) |
3503                     (1ull << MSR_DE) |
3504                     (1ull << MSR_IR) |
3505                     (1ull << MSR_DR) |
3506                     (1ull << MSR_LE);
3507     pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3508     pcc->excp_model = POWERPC_EXCP_40x;
3509     pcc->bus_model = PPC_FLAGS_INPUT_401;
3510     pcc->bfd_mach = bfd_mach_ppc_403;
3511     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3512                  POWERPC_FLAG_BUS_CLK;
3513 }
3514
3515 static void init_proc_403 (CPUPPCState *env)
3516 {
3517     gen_spr_40x(env);
3518     gen_spr_401_403(env);
3519     gen_spr_403(env);
3520     gen_spr_403_real(env);
3521     init_excp_4xx_real(env);
3522     env->dcache_line_size = 32;
3523     env->icache_line_size = 32;
3524     /* Allocate hardware IRQ controller */
3525     ppc40x_irq_init(ppc_env_get_cpu(env));
3526
3527     SET_FIT_PERIOD(8, 12, 16, 20);
3528     SET_WDT_PERIOD(16, 20, 24, 28);
3529 }
3530
3531 POWERPC_FAMILY(403)(ObjectClass *oc, void *data)
3532 {
3533     DeviceClass *dc = DEVICE_CLASS(oc);
3534     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3535
3536     dc->desc = "PowerPC 403";
3537     pcc->init_proc = init_proc_403;
3538     pcc->check_pow = check_pow_nocheck;
3539     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3540                        PPC_DCR | PPC_WRTEE |
3541                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3542                        PPC_CACHE_DCBZ |
3543                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3544                        PPC_4xx_COMMON | PPC_40x_EXCP;
3545     pcc->msr_mask = (1ull << MSR_POW) |
3546                     (1ull << MSR_CE) |
3547                     (1ull << MSR_ILE) |
3548                     (1ull << MSR_EE) |
3549                     (1ull << MSR_PR) |
3550                     (1ull << MSR_ME) |
3551                     (1ull << MSR_PE) |
3552                     (1ull << MSR_PX) |
3553                     (1ull << MSR_LE);
3554     pcc->mmu_model = POWERPC_MMU_REAL;
3555     pcc->excp_model = POWERPC_EXCP_40x;
3556     pcc->bus_model = PPC_FLAGS_INPUT_401;
3557     pcc->bfd_mach = bfd_mach_ppc_403;
3558     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_PX |
3559                  POWERPC_FLAG_BUS_CLK;
3560 }
3561
3562 static void init_proc_403GCX (CPUPPCState *env)
3563 {
3564     gen_spr_40x(env);
3565     gen_spr_401_403(env);
3566     gen_spr_403(env);
3567     gen_spr_403_real(env);
3568     gen_spr_403_mmu(env);
3569     /* Bus access control */
3570     /* not emulated, as QEMU never does speculative access */
3571     spr_register(env, SPR_40x_SGR, "SGR",
3572                  SPR_NOACCESS, SPR_NOACCESS,
3573                  &spr_read_generic, &spr_write_generic,
3574                  0xFFFFFFFF);
3575     /* not emulated, as QEMU do not emulate caches */
3576     spr_register(env, SPR_40x_DCWR, "DCWR",
3577                  SPR_NOACCESS, SPR_NOACCESS,
3578                  &spr_read_generic, &spr_write_generic,
3579                  0x00000000);
3580     /* Memory management */
3581 #if !defined(CONFIG_USER_ONLY)
3582     env->nb_tlb = 64;
3583     env->nb_ways = 1;
3584     env->id_tlbs = 0;
3585     env->tlb_type = TLB_EMB;
3586 #endif
3587     init_excp_4xx_softmmu(env);
3588     env->dcache_line_size = 32;
3589     env->icache_line_size = 32;
3590     /* Allocate hardware IRQ controller */
3591     ppc40x_irq_init(ppc_env_get_cpu(env));
3592
3593     SET_FIT_PERIOD(8, 12, 16, 20);
3594     SET_WDT_PERIOD(16, 20, 24, 28);
3595 }
3596
3597 POWERPC_FAMILY(403GCX)(ObjectClass *oc, void *data)
3598 {
3599     DeviceClass *dc = DEVICE_CLASS(oc);
3600     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3601
3602     dc->desc = "PowerPC 403 GCX";
3603     pcc->init_proc = init_proc_403GCX;
3604     pcc->check_pow = check_pow_nocheck;
3605     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3606                        PPC_DCR | PPC_WRTEE |
3607                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3608                        PPC_CACHE_DCBZ |
3609                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3610                        PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3611                        PPC_4xx_COMMON | PPC_40x_EXCP;
3612     pcc->msr_mask = (1ull << MSR_POW) |
3613                     (1ull << MSR_CE) |
3614                     (1ull << MSR_ILE) |
3615                     (1ull << MSR_EE) |
3616                     (1ull << MSR_PR) |
3617                     (1ull << MSR_ME) |
3618                     (1ull << MSR_PE) |
3619                     (1ull << MSR_PX) |
3620                     (1ull << MSR_LE);
3621     pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3622     pcc->excp_model = POWERPC_EXCP_40x;
3623     pcc->bus_model = PPC_FLAGS_INPUT_401;
3624     pcc->bfd_mach = bfd_mach_ppc_403;
3625     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_PX |
3626                  POWERPC_FLAG_BUS_CLK;
3627 }
3628
3629 static void init_proc_405 (CPUPPCState *env)
3630 {
3631     /* Time base */
3632     gen_tbl(env);
3633     gen_spr_40x(env);
3634     gen_spr_405(env);
3635     /* Bus access control */
3636     /* not emulated, as QEMU never does speculative access */
3637     spr_register(env, SPR_40x_SGR, "SGR",
3638                  SPR_NOACCESS, SPR_NOACCESS,
3639                  &spr_read_generic, &spr_write_generic,
3640                  0xFFFFFFFF);
3641     /* not emulated, as QEMU do not emulate caches */
3642     spr_register(env, SPR_40x_DCWR, "DCWR",
3643                  SPR_NOACCESS, SPR_NOACCESS,
3644                  &spr_read_generic, &spr_write_generic,
3645                  0x00000000);
3646     /* Memory management */
3647 #if !defined(CONFIG_USER_ONLY)
3648     env->nb_tlb = 64;
3649     env->nb_ways = 1;
3650     env->id_tlbs = 0;
3651     env->tlb_type = TLB_EMB;
3652 #endif
3653     init_excp_4xx_softmmu(env);
3654     env->dcache_line_size = 32;
3655     env->icache_line_size = 32;
3656     /* Allocate hardware IRQ controller */
3657     ppc40x_irq_init(ppc_env_get_cpu(env));
3658
3659     SET_FIT_PERIOD(8, 12, 16, 20);
3660     SET_WDT_PERIOD(16, 20, 24, 28);
3661 }
3662
3663 POWERPC_FAMILY(405)(ObjectClass *oc, void *data)
3664 {
3665     DeviceClass *dc = DEVICE_CLASS(oc);
3666     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3667
3668     dc->desc = "PowerPC 405";
3669     pcc->init_proc = init_proc_405;
3670     pcc->check_pow = check_pow_nocheck;
3671     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3672                        PPC_DCR | PPC_WRTEE |
3673                        PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3674                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3675                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
3676                        PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3677                        PPC_4xx_COMMON | PPC_405_MAC | PPC_40x_EXCP;
3678     pcc->msr_mask = (1ull << MSR_POW) |
3679                     (1ull << MSR_CE) |
3680                     (1ull << MSR_EE) |
3681                     (1ull << MSR_PR) |
3682                     (1ull << MSR_FP) |
3683                     (1ull << MSR_DWE) |
3684                     (1ull << MSR_DE) |
3685                     (1ull << MSR_IR) |
3686                     (1ull << MSR_DR);
3687     pcc->mmu_model = POWERPC_MMU_SOFT_4xx;
3688     pcc->excp_model = POWERPC_EXCP_40x;
3689     pcc->bus_model = PPC_FLAGS_INPUT_405;
3690     pcc->bfd_mach = bfd_mach_ppc_403;
3691     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3692                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3693 }
3694
3695 static void init_proc_440EP (CPUPPCState *env)
3696 {
3697     /* Time base */
3698     gen_tbl(env);
3699     gen_spr_BookE(env, 0x000000000000FFFFULL);
3700     gen_spr_440(env);
3701     gen_spr_usprgh(env);
3702     /* Processor identification */
3703     spr_register(env, SPR_BOOKE_PIR, "PIR",
3704                  SPR_NOACCESS, SPR_NOACCESS,
3705                  &spr_read_generic, &spr_write_pir,
3706                  0x00000000);
3707     /* XXX : not implemented */
3708     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3709                  SPR_NOACCESS, SPR_NOACCESS,
3710                  &spr_read_generic, &spr_write_generic,
3711                  0x00000000);
3712     /* XXX : not implemented */
3713     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3714                  SPR_NOACCESS, SPR_NOACCESS,
3715                  &spr_read_generic, &spr_write_generic,
3716                  0x00000000);
3717     /* XXX : not implemented */
3718     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3719                  SPR_NOACCESS, SPR_NOACCESS,
3720                  &spr_read_generic, &spr_write_generic,
3721                  0x00000000);
3722     /* XXX : not implemented */
3723     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3724                  SPR_NOACCESS, SPR_NOACCESS,
3725                  &spr_read_generic, &spr_write_generic,
3726                  0x00000000);
3727     /* XXX : not implemented */
3728     spr_register(env, SPR_BOOKE_MCSR, "MCSR",
3729                  SPR_NOACCESS, SPR_NOACCESS,
3730                  &spr_read_generic, &spr_write_generic,
3731                  0x00000000);
3732     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
3733                  SPR_NOACCESS, SPR_NOACCESS,
3734                  &spr_read_generic, &spr_write_generic,
3735                  0x00000000);
3736     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
3737                  SPR_NOACCESS, SPR_NOACCESS,
3738                  &spr_read_generic, &spr_write_generic,
3739                  0x00000000);
3740     /* XXX : not implemented */
3741     spr_register(env, SPR_440_CCR1, "CCR1",
3742                  SPR_NOACCESS, SPR_NOACCESS,
3743                  &spr_read_generic, &spr_write_generic,
3744                  0x00000000);
3745     /* Memory management */
3746 #if !defined(CONFIG_USER_ONLY)
3747     env->nb_tlb = 64;
3748     env->nb_ways = 1;
3749     env->id_tlbs = 0;
3750     env->tlb_type = TLB_EMB;
3751 #endif
3752     init_excp_BookE(env);
3753     env->dcache_line_size = 32;
3754     env->icache_line_size = 32;
3755     ppc40x_irq_init(ppc_env_get_cpu(env));
3756
3757     SET_FIT_PERIOD(12, 16, 20, 24);
3758     SET_WDT_PERIOD(20, 24, 28, 32);
3759 }
3760
3761 POWERPC_FAMILY(440EP)(ObjectClass *oc, void *data)
3762 {
3763     DeviceClass *dc = DEVICE_CLASS(oc);
3764     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3765
3766     dc->desc = "PowerPC 440 EP";
3767     pcc->init_proc = init_proc_440EP;
3768     pcc->check_pow = check_pow_nocheck;
3769     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3770                        PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL |
3771                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
3772                        PPC_FLOAT_STFIWX |
3773                        PPC_DCR | PPC_WRTEE | PPC_RFMCI |
3774                        PPC_CACHE | PPC_CACHE_ICBI |
3775                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3776                        PPC_MEM_TLBSYNC | PPC_MFTB |
3777                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3778                        PPC_440_SPEC;
3779     pcc->msr_mask = (1ull << MSR_POW) |
3780                     (1ull << MSR_CE) |
3781                     (1ull << MSR_EE) |
3782                     (1ull << MSR_PR) |
3783                     (1ull << MSR_FP) |
3784                     (1ull << MSR_ME) |
3785                     (1ull << MSR_FE0) |
3786                     (1ull << MSR_DWE) |
3787                     (1ull << MSR_DE) |
3788                     (1ull << MSR_FE1) |
3789                     (1ull << MSR_IR) |
3790                     (1ull << MSR_DR);
3791     pcc->mmu_model = POWERPC_MMU_BOOKE;
3792     pcc->excp_model = POWERPC_EXCP_BOOKE;
3793     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3794     pcc->bfd_mach = bfd_mach_ppc_403;
3795     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3796                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3797 }
3798
3799 static void init_proc_440GP (CPUPPCState *env)
3800 {
3801     /* Time base */
3802     gen_tbl(env);
3803     gen_spr_BookE(env, 0x000000000000FFFFULL);
3804     gen_spr_440(env);
3805     gen_spr_usprgh(env);
3806     /* Processor identification */
3807     spr_register(env, SPR_BOOKE_PIR, "PIR",
3808                  SPR_NOACCESS, SPR_NOACCESS,
3809                  &spr_read_generic, &spr_write_pir,
3810                  0x00000000);
3811     /* XXX : not implemented */
3812     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3813                  SPR_NOACCESS, SPR_NOACCESS,
3814                  &spr_read_generic, &spr_write_generic,
3815                  0x00000000);
3816     /* XXX : not implemented */
3817     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3818                  SPR_NOACCESS, SPR_NOACCESS,
3819                  &spr_read_generic, &spr_write_generic,
3820                  0x00000000);
3821     /* XXX : not implemented */
3822     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3823                  SPR_NOACCESS, SPR_NOACCESS,
3824                  &spr_read_generic, &spr_write_generic,
3825                  0x00000000);
3826     /* XXX : not implemented */
3827     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3828                  SPR_NOACCESS, SPR_NOACCESS,
3829                  &spr_read_generic, &spr_write_generic,
3830                  0x00000000);
3831     /* Memory management */
3832 #if !defined(CONFIG_USER_ONLY)
3833     env->nb_tlb = 64;
3834     env->nb_ways = 1;
3835     env->id_tlbs = 0;
3836     env->tlb_type = TLB_EMB;
3837 #endif
3838     init_excp_BookE(env);
3839     env->dcache_line_size = 32;
3840     env->icache_line_size = 32;
3841     /* XXX: TODO: allocate internal IRQ controller */
3842
3843     SET_FIT_PERIOD(12, 16, 20, 24);
3844     SET_WDT_PERIOD(20, 24, 28, 32);
3845 }
3846
3847 POWERPC_FAMILY(440GP)(ObjectClass *oc, void *data)
3848 {
3849     DeviceClass *dc = DEVICE_CLASS(oc);
3850     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3851
3852     dc->desc = "PowerPC 440 GP";
3853     pcc->init_proc = init_proc_440GP;
3854     pcc->check_pow = check_pow_nocheck;
3855     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3856                        PPC_DCR | PPC_DCRX | PPC_WRTEE | PPC_MFAPIDI |
3857                        PPC_CACHE | PPC_CACHE_ICBI |
3858                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3859                        PPC_MEM_TLBSYNC | PPC_TLBIVA | PPC_MFTB |
3860                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3861                        PPC_440_SPEC;
3862     pcc->msr_mask = (1ull << MSR_POW) |
3863                     (1ull << MSR_CE) |
3864                     (1ull << MSR_EE) |
3865                     (1ull << MSR_PR) |
3866                     (1ull << MSR_FP) |
3867                     (1ull << MSR_ME) |
3868                     (1ull << MSR_FE0) |
3869                     (1ull << MSR_DWE) |
3870                     (1ull << MSR_DE) |
3871                     (1ull << MSR_FE1) |
3872                     (1ull << MSR_IR) |
3873                     (1ull << MSR_DR);
3874     pcc->mmu_model = POWERPC_MMU_BOOKE;
3875     pcc->excp_model = POWERPC_EXCP_BOOKE;
3876     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3877     pcc->bfd_mach = bfd_mach_ppc_403;
3878     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3879                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3880 }
3881
3882 static void init_proc_440x4 (CPUPPCState *env)
3883 {
3884     /* Time base */
3885     gen_tbl(env);
3886     gen_spr_BookE(env, 0x000000000000FFFFULL);
3887     gen_spr_440(env);
3888     gen_spr_usprgh(env);
3889     /* Processor identification */
3890     spr_register(env, SPR_BOOKE_PIR, "PIR",
3891                  SPR_NOACCESS, SPR_NOACCESS,
3892                  &spr_read_generic, &spr_write_pir,
3893                  0x00000000);
3894     /* XXX : not implemented */
3895     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3896                  SPR_NOACCESS, SPR_NOACCESS,
3897                  &spr_read_generic, &spr_write_generic,
3898                  0x00000000);
3899     /* XXX : not implemented */
3900     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3901                  SPR_NOACCESS, SPR_NOACCESS,
3902                  &spr_read_generic, &spr_write_generic,
3903                  0x00000000);
3904     /* XXX : not implemented */
3905     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3906                  SPR_NOACCESS, SPR_NOACCESS,
3907                  &spr_read_generic, &spr_write_generic,
3908                  0x00000000);
3909     /* XXX : not implemented */
3910     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3911                  SPR_NOACCESS, SPR_NOACCESS,
3912                  &spr_read_generic, &spr_write_generic,
3913                  0x00000000);
3914     /* Memory management */
3915 #if !defined(CONFIG_USER_ONLY)
3916     env->nb_tlb = 64;
3917     env->nb_ways = 1;
3918     env->id_tlbs = 0;
3919     env->tlb_type = TLB_EMB;
3920 #endif
3921     init_excp_BookE(env);
3922     env->dcache_line_size = 32;
3923     env->icache_line_size = 32;
3924     /* XXX: TODO: allocate internal IRQ controller */
3925
3926     SET_FIT_PERIOD(12, 16, 20, 24);
3927     SET_WDT_PERIOD(20, 24, 28, 32);
3928 }
3929
3930 POWERPC_FAMILY(440x4)(ObjectClass *oc, void *data)
3931 {
3932     DeviceClass *dc = DEVICE_CLASS(oc);
3933     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3934
3935     dc->desc = "PowerPC 440x4";
3936     pcc->init_proc = init_proc_440x4;
3937     pcc->check_pow = check_pow_nocheck;
3938     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3939                        PPC_DCR | PPC_WRTEE |
3940                        PPC_CACHE | PPC_CACHE_ICBI |
3941                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3942                        PPC_MEM_TLBSYNC | PPC_MFTB |
3943                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3944                        PPC_440_SPEC;
3945     pcc->msr_mask = (1ull << MSR_POW) |
3946                     (1ull << MSR_CE) |
3947                     (1ull << MSR_EE) |
3948                     (1ull << MSR_PR) |
3949                     (1ull << MSR_FP) |
3950                     (1ull << MSR_ME) |
3951                     (1ull << MSR_FE0) |
3952                     (1ull << MSR_DWE) |
3953                     (1ull << MSR_DE) |
3954                     (1ull << MSR_FE1) |
3955                     (1ull << MSR_IR) |
3956                     (1ull << MSR_DR);
3957     pcc->mmu_model = POWERPC_MMU_BOOKE;
3958     pcc->excp_model = POWERPC_EXCP_BOOKE;
3959     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3960     pcc->bfd_mach = bfd_mach_ppc_403;
3961     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3962                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3963 }
3964
3965 static void init_proc_440x5 (CPUPPCState *env)
3966 {
3967     /* Time base */
3968     gen_tbl(env);
3969     gen_spr_BookE(env, 0x000000000000FFFFULL);
3970     gen_spr_440(env);
3971     gen_spr_usprgh(env);
3972     /* Processor identification */
3973     spr_register(env, SPR_BOOKE_PIR, "PIR",
3974                  SPR_NOACCESS, SPR_NOACCESS,
3975                  &spr_read_generic, &spr_write_pir,
3976                  0x00000000);
3977     /* XXX : not implemented */
3978     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3979                  SPR_NOACCESS, SPR_NOACCESS,
3980                  &spr_read_generic, &spr_write_generic,
3981                  0x00000000);
3982     /* XXX : not implemented */
3983     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3984                  SPR_NOACCESS, SPR_NOACCESS,
3985                  &spr_read_generic, &spr_write_generic,
3986                  0x00000000);
3987     /* XXX : not implemented */
3988     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3989                  SPR_NOACCESS, SPR_NOACCESS,
3990                  &spr_read_generic, &spr_write_generic,
3991                  0x00000000);
3992     /* XXX : not implemented */
3993     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3994                  SPR_NOACCESS, SPR_NOACCESS,
3995                  &spr_read_generic, &spr_write_generic,
3996                  0x00000000);
3997     /* XXX : not implemented */
3998     spr_register(env, SPR_BOOKE_MCSR, "MCSR",
3999                  SPR_NOACCESS, SPR_NOACCESS,
4000                  &spr_read_generic, &spr_write_generic,
4001                  0x00000000);
4002     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4003                  SPR_NOACCESS, SPR_NOACCESS,
4004                  &spr_read_generic, &spr_write_generic,
4005                  0x00000000);
4006     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
4007                  SPR_NOACCESS, SPR_NOACCESS,
4008                  &spr_read_generic, &spr_write_generic,
4009                  0x00000000);
4010     /* XXX : not implemented */
4011     spr_register(env, SPR_440_CCR1, "CCR1",
4012                  SPR_NOACCESS, SPR_NOACCESS,
4013                  &spr_read_generic, &spr_write_generic,
4014                  0x00000000);
4015     /* Memory management */
4016 #if !defined(CONFIG_USER_ONLY)
4017     env->nb_tlb = 64;
4018     env->nb_ways = 1;
4019     env->id_tlbs = 0;
4020     env->tlb_type = TLB_EMB;
4021 #endif
4022     init_excp_BookE(env);
4023     env->dcache_line_size = 32;
4024     env->icache_line_size = 32;
4025     ppc40x_irq_init(ppc_env_get_cpu(env));
4026
4027     SET_FIT_PERIOD(12, 16, 20, 24);
4028     SET_WDT_PERIOD(20, 24, 28, 32);
4029 }
4030
4031 POWERPC_FAMILY(440x5)(ObjectClass *oc, void *data)
4032 {
4033     DeviceClass *dc = DEVICE_CLASS(oc);
4034     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4035
4036     dc->desc = "PowerPC 440x5";
4037     pcc->init_proc = init_proc_440x5;
4038     pcc->check_pow = check_pow_nocheck;
4039     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4040                        PPC_DCR | PPC_WRTEE | PPC_RFMCI |
4041                        PPC_CACHE | PPC_CACHE_ICBI |
4042                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4043                        PPC_MEM_TLBSYNC | PPC_MFTB |
4044                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4045                        PPC_440_SPEC;
4046     pcc->msr_mask = (1ull << MSR_POW) |
4047                     (1ull << MSR_CE) |
4048                     (1ull << MSR_EE) |
4049                     (1ull << MSR_PR) |
4050                     (1ull << MSR_FP) |
4051                     (1ull << MSR_ME) |
4052                     (1ull << MSR_FE0) |
4053                     (1ull << MSR_DWE) |
4054                     (1ull << MSR_DE) |
4055                     (1ull << MSR_FE1) |
4056                     (1ull << MSR_IR) |
4057                     (1ull << MSR_DR);
4058     pcc->mmu_model = POWERPC_MMU_BOOKE;
4059     pcc->excp_model = POWERPC_EXCP_BOOKE;
4060     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4061     pcc->bfd_mach = bfd_mach_ppc_403;
4062     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4063                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4064 }
4065
4066 POWERPC_FAMILY(440x5wDFPU)(ObjectClass *oc, void *data)
4067 {
4068     DeviceClass *dc = DEVICE_CLASS(oc);
4069     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4070
4071     dc->desc = "PowerPC 440x5 with double precision FPU";
4072     pcc->init_proc = init_proc_440x5;
4073     pcc->check_pow = check_pow_nocheck;
4074     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4075                        PPC_FLOAT | PPC_FLOAT_FSQRT |
4076                        PPC_FLOAT_STFIWX |
4077                        PPC_DCR | PPC_WRTEE | PPC_RFMCI |
4078                        PPC_CACHE | PPC_CACHE_ICBI |
4079                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4080                        PPC_MEM_TLBSYNC | PPC_MFTB |
4081                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4082                        PPC_440_SPEC;
4083     pcc->insns_flags2 = PPC2_FP_CVT_S64;
4084     pcc->msr_mask = (1ull << MSR_POW) |
4085                     (1ull << MSR_CE) |
4086                     (1ull << MSR_EE) |
4087                     (1ull << MSR_PR) |
4088                     (1ull << MSR_FP) |
4089                     (1ull << MSR_ME) |
4090                     (1ull << MSR_FE0) |
4091                     (1ull << MSR_DWE) |
4092                     (1ull << MSR_DE) |
4093                     (1ull << MSR_FE1) |
4094                     (1ull << MSR_IR) |
4095                     (1ull << MSR_DR);
4096     pcc->mmu_model = POWERPC_MMU_BOOKE;
4097     pcc->excp_model = POWERPC_EXCP_BOOKE;
4098     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4099     pcc->bfd_mach = bfd_mach_ppc_403;
4100     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4101                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4102 }
4103
4104 static void init_proc_460 (CPUPPCState *env)
4105 {
4106     /* Time base */
4107     gen_tbl(env);
4108     gen_spr_BookE(env, 0x000000000000FFFFULL);
4109     gen_spr_440(env);
4110     gen_spr_usprgh(env);
4111     /* Processor identification */
4112     spr_register(env, SPR_BOOKE_PIR, "PIR",
4113                  SPR_NOACCESS, SPR_NOACCESS,
4114                  &spr_read_generic, &spr_write_pir,
4115                  0x00000000);
4116     /* XXX : not implemented */
4117     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
4118                  SPR_NOACCESS, SPR_NOACCESS,
4119                  &spr_read_generic, &spr_write_generic,
4120                  0x00000000);
4121     /* XXX : not implemented */
4122     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
4123                  SPR_NOACCESS, SPR_NOACCESS,
4124                  &spr_read_generic, &spr_write_generic,
4125                  0x00000000);
4126     /* XXX : not implemented */
4127     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
4128                  SPR_NOACCESS, SPR_NOACCESS,
4129                  &spr_read_generic, &spr_write_generic,
4130                  0x00000000);
4131     /* XXX : not implemented */
4132     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
4133                  SPR_NOACCESS, SPR_NOACCESS,
4134                  &spr_read_generic, &spr_write_generic,
4135                  0x00000000);
4136     /* XXX : not implemented */
4137     spr_register(env, SPR_BOOKE_MCSR, "MCSR",
4138                  SPR_NOACCESS, SPR_NOACCESS,
4139                  &spr_read_generic, &spr_write_generic,
4140                  0x00000000);
4141     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4142                  SPR_NOACCESS, SPR_NOACCESS,
4143                  &spr_read_generic, &spr_write_generic,
4144                  0x00000000);
4145     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
4146                  SPR_NOACCESS, SPR_NOACCESS,
4147                  &spr_read_generic, &spr_write_generic,
4148                  0x00000000);
4149     /* XXX : not implemented */
4150     spr_register(env, SPR_440_CCR1, "CCR1",
4151                  SPR_NOACCESS, SPR_NOACCESS,
4152                  &spr_read_generic, &spr_write_generic,
4153                  0x00000000);
4154     /* XXX : not implemented */
4155     spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
4156                  &spr_read_generic, &spr_write_generic,
4157                  &spr_read_generic, &spr_write_generic,
4158                  0x00000000);
4159     /* Memory management */
4160 #if !defined(CONFIG_USER_ONLY)
4161     env->nb_tlb = 64;
4162     env->nb_ways = 1;
4163     env->id_tlbs = 0;
4164     env->tlb_type = TLB_EMB;
4165 #endif
4166     init_excp_BookE(env);
4167     env->dcache_line_size = 32;
4168     env->icache_line_size = 32;
4169     /* XXX: TODO: allocate internal IRQ controller */
4170
4171     SET_FIT_PERIOD(12, 16, 20, 24);
4172     SET_WDT_PERIOD(20, 24, 28, 32);
4173 }
4174
4175 POWERPC_FAMILY(460)(ObjectClass *oc, void *data)
4176 {
4177     DeviceClass *dc = DEVICE_CLASS(oc);
4178     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4179
4180     dc->desc = "PowerPC 460 (guessed)";
4181     pcc->init_proc = init_proc_460;
4182     pcc->check_pow = check_pow_nocheck;
4183     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4184                        PPC_DCR | PPC_DCRX  | PPC_DCRUX |
4185                        PPC_WRTEE | PPC_MFAPIDI | PPC_MFTB |
4186                        PPC_CACHE | PPC_CACHE_ICBI |
4187                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4188                        PPC_MEM_TLBSYNC | PPC_TLBIVA |
4189                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4190                        PPC_440_SPEC;
4191     pcc->msr_mask = (1ull << MSR_POW) |
4192                     (1ull << MSR_CE) |
4193                     (1ull << MSR_EE) |
4194                     (1ull << MSR_PR) |
4195                     (1ull << MSR_FP) |
4196                     (1ull << MSR_ME) |
4197                     (1ull << MSR_FE0) |
4198                     (1ull << MSR_DWE) |
4199                     (1ull << MSR_DE) |
4200                     (1ull << MSR_FE1) |
4201                     (1ull << MSR_IR) |
4202                     (1ull << MSR_DR);
4203     pcc->mmu_model = POWERPC_MMU_BOOKE;
4204     pcc->excp_model = POWERPC_EXCP_BOOKE;
4205     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4206     pcc->bfd_mach = bfd_mach_ppc_403;
4207     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4208                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4209 }
4210
4211 static void init_proc_460F (CPUPPCState *env)
4212 {
4213     /* Time base */
4214     gen_tbl(env);
4215     gen_spr_BookE(env, 0x000000000000FFFFULL);
4216     gen_spr_440(env);
4217     gen_spr_usprgh(env);
4218     /* Processor identification */
4219     spr_register(env, SPR_BOOKE_PIR, "PIR",
4220                  SPR_NOACCESS, SPR_NOACCESS,
4221                  &spr_read_generic, &spr_write_pir,
4222                  0x00000000);
4223     /* XXX : not implemented */
4224     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
4225                  SPR_NOACCESS, SPR_NOACCESS,
4226                  &spr_read_generic, &spr_write_generic,
4227                  0x00000000);
4228     /* XXX : not implemented */
4229     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
4230                  SPR_NOACCESS, SPR_NOACCESS,
4231                  &spr_read_generic, &spr_write_generic,
4232                  0x00000000);
4233     /* XXX : not implemented */
4234     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
4235                  SPR_NOACCESS, SPR_NOACCESS,
4236                  &spr_read_generic, &spr_write_generic,
4237                  0x00000000);
4238     /* XXX : not implemented */
4239     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
4240                  SPR_NOACCESS, SPR_NOACCESS,
4241                  &spr_read_generic, &spr_write_generic,
4242                  0x00000000);
4243     /* XXX : not implemented */
4244     spr_register(env, SPR_BOOKE_MCSR, "MCSR",
4245                  SPR_NOACCESS, SPR_NOACCESS,
4246                  &spr_read_generic, &spr_write_generic,
4247                  0x00000000);
4248     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4249                  SPR_NOACCESS, SPR_NOACCESS,
4250                  &spr_read_generic, &spr_write_generic,
4251                  0x00000000);
4252     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
4253                  SPR_NOACCESS, SPR_NOACCESS,
4254                  &spr_read_generic, &spr_write_generic,
4255                  0x00000000);
4256     /* XXX : not implemented */
4257     spr_register(env, SPR_440_CCR1, "CCR1",
4258                  SPR_NOACCESS, SPR_NOACCESS,
4259                  &spr_read_generic, &spr_write_generic,
4260                  0x00000000);
4261     /* XXX : not implemented */
4262     spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
4263                  &spr_read_generic, &spr_write_generic,
4264                  &spr_read_generic, &spr_write_generic,
4265                  0x00000000);
4266     /* Memory management */
4267 #if !defined(CONFIG_USER_ONLY)
4268     env->nb_tlb = 64;
4269     env->nb_ways = 1;
4270     env->id_tlbs = 0;
4271     env->tlb_type = TLB_EMB;
4272 #endif
4273     init_excp_BookE(env);
4274     env->dcache_line_size = 32;
4275     env->icache_line_size = 32;
4276     /* XXX: TODO: allocate internal IRQ controller */
4277
4278     SET_FIT_PERIOD(12, 16, 20, 24);
4279     SET_WDT_PERIOD(20, 24, 28, 32);
4280 }
4281
4282 POWERPC_FAMILY(460F)(ObjectClass *oc, void *data)
4283 {
4284     DeviceClass *dc = DEVICE_CLASS(oc);
4285     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4286
4287     dc->desc = "PowerPC 460F (guessed)";
4288     pcc->init_proc = init_proc_460F;
4289     pcc->check_pow = check_pow_nocheck;
4290     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4291                        PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL |
4292                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
4293                        PPC_FLOAT_STFIWX | PPC_MFTB |
4294                        PPC_DCR | PPC_DCRX | PPC_DCRUX |
4295                        PPC_WRTEE | PPC_MFAPIDI |
4296                        PPC_CACHE | PPC_CACHE_ICBI |
4297                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4298                        PPC_MEM_TLBSYNC | PPC_TLBIVA |
4299                        PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4300                        PPC_440_SPEC;
4301     pcc->msr_mask = (1ull << MSR_POW) |
4302                     (1ull << MSR_CE) |
4303                     (1ull << MSR_EE) |
4304                     (1ull << MSR_PR) |
4305                     (1ull << MSR_FP) |
4306                     (1ull << MSR_ME) |
4307                     (1ull << MSR_FE0) |
4308                     (1ull << MSR_DWE) |
4309                     (1ull << MSR_DE) |
4310                     (1ull << MSR_FE1) |
4311                     (1ull << MSR_IR) |
4312                     (1ull << MSR_DR);
4313     pcc->mmu_model = POWERPC_MMU_BOOKE;
4314     pcc->excp_model = POWERPC_EXCP_BOOKE;
4315     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4316     pcc->bfd_mach = bfd_mach_ppc_403;
4317     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4318                  POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4319 }
4320
4321 static void init_proc_MPC5xx (CPUPPCState *env)
4322 {
4323     /* Time base */
4324     gen_tbl(env);
4325     gen_spr_5xx_8xx(env);
4326     gen_spr_5xx(env);
4327     init_excp_MPC5xx(env);
4328     env->dcache_line_size = 32;
4329     env->icache_line_size = 32;
4330     /* XXX: TODO: allocate internal IRQ controller */
4331 }
4332
4333 POWERPC_FAMILY(MPC5xx)(ObjectClass *oc, void *data)
4334 {
4335     DeviceClass *dc = DEVICE_CLASS(oc);
4336     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4337
4338     dc->desc = "Freescale 5xx cores (aka RCPU)";
4339     pcc->init_proc = init_proc_MPC5xx;
4340     pcc->check_pow = check_pow_none;
4341     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4342                        PPC_MEM_EIEIO | PPC_MEM_SYNC |
4343                        PPC_CACHE_ICBI | PPC_FLOAT | PPC_FLOAT_STFIWX |
4344                        PPC_MFTB;
4345     pcc->msr_mask = (1ull << MSR_ILE) |
4346                     (1ull << MSR_EE) |
4347                     (1ull << MSR_PR) |
4348                     (1ull << MSR_FP) |
4349                     (1ull << MSR_ME) |
4350                     (1ull << MSR_FE0) |
4351                     (1ull << MSR_SE) |
4352                     (1ull << MSR_DE) |
4353                     (1ull << MSR_FE1) |
4354                     (1ull << MSR_EP) |
4355                     (1ull << MSR_RI) |
4356                     (1ull << MSR_LE);
4357     pcc->mmu_model = POWERPC_MMU_REAL;
4358     pcc->excp_model = POWERPC_EXCP_603;
4359     pcc->bus_model = PPC_FLAGS_INPUT_RCPU;
4360     pcc->bfd_mach = bfd_mach_ppc_505;
4361     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
4362                  POWERPC_FLAG_BUS_CLK;
4363 }
4364
4365 static void init_proc_MPC8xx (CPUPPCState *env)
4366 {
4367     /* Time base */
4368     gen_tbl(env);
4369     gen_spr_5xx_8xx(env);
4370     gen_spr_8xx(env);
4371     init_excp_MPC8xx(env);
4372     env->dcache_line_size = 32;
4373     env->icache_line_size = 32;
4374     /* XXX: TODO: allocate internal IRQ controller */
4375 }
4376
4377 POWERPC_FAMILY(MPC8xx)(ObjectClass *oc, void *data)
4378 {
4379     DeviceClass *dc = DEVICE_CLASS(oc);
4380     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4381
4382     dc->desc = "Freescale 8xx cores (aka PowerQUICC)";
4383     pcc->init_proc = init_proc_MPC8xx;
4384     pcc->check_pow = check_pow_none;
4385     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING  |
4386                        PPC_MEM_EIEIO | PPC_MEM_SYNC |
4387                        PPC_CACHE_ICBI | PPC_MFTB;
4388     pcc->msr_mask = (1ull << MSR_ILE) |
4389                     (1ull << MSR_EE) |
4390                     (1ull << MSR_PR) |
4391                     (1ull << MSR_FP) |
4392                     (1ull << MSR_ME) |
4393                     (1ull << MSR_SE) |
4394                     (1ull << MSR_DE) |
4395                     (1ull << MSR_EP) |
4396                     (1ull << MSR_IR) |
4397                     (1ull << MSR_DR) |
4398                     (1ull << MSR_RI) |
4399                     (1ull << MSR_LE);
4400     pcc->mmu_model = POWERPC_MMU_MPC8xx;
4401     pcc->excp_model = POWERPC_EXCP_603;
4402     pcc->bus_model = PPC_FLAGS_INPUT_RCPU;
4403     pcc->bfd_mach = bfd_mach_ppc_860;
4404     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
4405                  POWERPC_FLAG_BUS_CLK;
4406 }
4407
4408 /* Freescale 82xx cores (aka PowerQUICC-II)                                  */
4409
4410 static void init_proc_G2 (CPUPPCState *env)
4411 {
4412     gen_spr_ne_601(env);
4413     gen_spr_G2_755(env);
4414     gen_spr_G2(env);
4415     /* Time base */
4416     gen_tbl(env);
4417     /* External access control */
4418     /* XXX : not implemented */
4419     spr_register(env, SPR_EAR, "EAR",
4420                  SPR_NOACCESS, SPR_NOACCESS,
4421                  &spr_read_generic, &spr_write_generic,
4422                  0x00000000);
4423     /* Hardware implementation register */
4424     /* XXX : not implemented */
4425     spr_register(env, SPR_HID0, "HID0",
4426                  SPR_NOACCESS, SPR_NOACCESS,
4427                  &spr_read_generic, &spr_write_generic,
4428                  0x00000000);
4429     /* XXX : not implemented */
4430     spr_register(env, SPR_HID1, "HID1",
4431                  SPR_NOACCESS, SPR_NOACCESS,
4432                  &spr_read_generic, &spr_write_generic,
4433                  0x00000000);
4434     /* XXX : not implemented */
4435     spr_register(env, SPR_HID2, "HID2",
4436                  SPR_NOACCESS, SPR_NOACCESS,
4437                  &spr_read_generic, &spr_write_generic,
4438                  0x00000000);
4439     /* Memory management */
4440     gen_low_BATs(env);
4441     gen_high_BATs(env);
4442     gen_6xx_7xx_soft_tlb(env, 64, 2);
4443     init_excp_G2(env);
4444     env->dcache_line_size = 32;
4445     env->icache_line_size = 32;
4446     /* Allocate hardware IRQ controller */
4447     ppc6xx_irq_init(ppc_env_get_cpu(env));
4448 }
4449
4450 POWERPC_FAMILY(G2)(ObjectClass *oc, void *data)
4451 {
4452     DeviceClass *dc = DEVICE_CLASS(oc);
4453     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4454
4455     dc->desc = "PowerPC G2";
4456     pcc->init_proc = init_proc_G2;
4457     pcc->check_pow = check_pow_hid0;
4458     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4459                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4460                        PPC_FLOAT_STFIWX |
4461                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4462                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
4463                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4464                        PPC_SEGMENT | PPC_EXTERN;
4465     pcc->msr_mask = (1ull << MSR_POW) |
4466                     (1ull << MSR_TGPR) |
4467                     (1ull << MSR_EE) |
4468                     (1ull << MSR_PR) |
4469                     (1ull << MSR_FP) |
4470                     (1ull << MSR_ME) |
4471                     (1ull << MSR_FE0) |
4472                     (1ull << MSR_SE) |
4473                     (1ull << MSR_DE) |
4474                     (1ull << MSR_FE1) |
4475                     (1ull << MSR_AL) |
4476                     (1ull << MSR_EP) |
4477                     (1ull << MSR_IR) |
4478                     (1ull << MSR_DR) |
4479                     (1ull << MSR_RI);
4480     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4481     pcc->excp_model = POWERPC_EXCP_G2;
4482     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4483     pcc->bfd_mach = bfd_mach_ppc_ec603e;
4484     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4485                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4486 }
4487
4488 static void init_proc_G2LE (CPUPPCState *env)
4489 {
4490     gen_spr_ne_601(env);
4491     gen_spr_G2_755(env);
4492     gen_spr_G2(env);
4493     /* Time base */
4494     gen_tbl(env);
4495     /* External access control */
4496     /* XXX : not implemented */
4497     spr_register(env, SPR_EAR, "EAR",
4498                  SPR_NOACCESS, SPR_NOACCESS,
4499                  &spr_read_generic, &spr_write_generic,
4500                  0x00000000);
4501     /* Hardware implementation register */
4502     /* XXX : not implemented */
4503     spr_register(env, SPR_HID0, "HID0",
4504                  SPR_NOACCESS, SPR_NOACCESS,
4505                  &spr_read_generic, &spr_write_generic,
4506                  0x00000000);
4507     /* XXX : not implemented */
4508     spr_register(env, SPR_HID1, "HID1",
4509                  SPR_NOACCESS, SPR_NOACCESS,
4510                  &spr_read_generic, &spr_write_generic,
4511                  0x00000000);
4512     /* XXX : not implemented */
4513     spr_register(env, SPR_HID2, "HID2",
4514                  SPR_NOACCESS, SPR_NOACCESS,
4515                  &spr_read_generic, &spr_write_generic,
4516                  0x00000000);
4517
4518     /* Memory management */
4519     gen_low_BATs(env);
4520     gen_high_BATs(env);
4521     gen_6xx_7xx_soft_tlb(env, 64, 2);
4522     init_excp_G2(env);
4523     env->dcache_line_size = 32;
4524     env->icache_line_size = 32;
4525     /* Allocate hardware IRQ controller */
4526     ppc6xx_irq_init(ppc_env_get_cpu(env));
4527 }
4528
4529 POWERPC_FAMILY(G2LE)(ObjectClass *oc, void *data)
4530 {
4531     DeviceClass *dc = DEVICE_CLASS(oc);
4532     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4533
4534     dc->desc = "PowerPC G2LE";
4535     pcc->init_proc = init_proc_G2LE;
4536     pcc->check_pow = check_pow_hid0;
4537     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4538                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4539                        PPC_FLOAT_STFIWX |
4540                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4541                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
4542                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4543                        PPC_SEGMENT | PPC_EXTERN;
4544     pcc->msr_mask = (1ull << MSR_POW) |
4545                     (1ull << MSR_TGPR) |
4546                     (1ull << MSR_ILE) |
4547                     (1ull << MSR_EE) |
4548                     (1ull << MSR_PR) |
4549                     (1ull << MSR_FP) |
4550                     (1ull << MSR_ME) |
4551                     (1ull << MSR_FE0) |
4552                     (1ull << MSR_SE) |
4553                     (1ull << MSR_DE) |
4554                     (1ull << MSR_FE1) |
4555                     (1ull << MSR_AL) |
4556                     (1ull << MSR_EP) |
4557                     (1ull << MSR_IR) |
4558                     (1ull << MSR_DR) |
4559                     (1ull << MSR_RI) |
4560                     (1ull << MSR_LE);
4561     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4562     pcc->excp_model = POWERPC_EXCP_G2;
4563     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4564     pcc->bfd_mach = bfd_mach_ppc_ec603e;
4565     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4566                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4567 }
4568
4569 static void init_proc_e200 (CPUPPCState *env)
4570 {
4571     /* Time base */
4572     gen_tbl(env);
4573     gen_spr_BookE(env, 0x000000070000FFFFULL);
4574     /* XXX : not implemented */
4575     spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
4576                  &spr_read_spefscr, &spr_write_spefscr,
4577                  &spr_read_spefscr, &spr_write_spefscr,
4578                  0x00000000);
4579     /* Memory management */
4580     gen_spr_BookE206(env, 0x0000005D, NULL);
4581     /* XXX : not implemented */
4582     spr_register(env, SPR_HID0, "HID0",
4583                  SPR_NOACCESS, SPR_NOACCESS,
4584                  &spr_read_generic, &spr_write_generic,
4585                  0x00000000);
4586     /* XXX : not implemented */
4587     spr_register(env, SPR_HID1, "HID1",
4588                  SPR_NOACCESS, SPR_NOACCESS,
4589                  &spr_read_generic, &spr_write_generic,
4590                  0x00000000);
4591     /* XXX : not implemented */
4592     spr_register(env, SPR_Exxx_ALTCTXCR, "ALTCTXCR",
4593                  SPR_NOACCESS, SPR_NOACCESS,
4594                  &spr_read_generic, &spr_write_generic,
4595                  0x00000000);
4596     /* XXX : not implemented */
4597     spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
4598                  SPR_NOACCESS, SPR_NOACCESS,
4599                  &spr_read_generic, &spr_write_generic,
4600                  0x00000000);
4601     /* XXX : not implemented */
4602     spr_register(env, SPR_Exxx_CTXCR, "CTXCR",
4603                  SPR_NOACCESS, SPR_NOACCESS,
4604                  &spr_read_generic, &spr_write_generic,
4605                  0x00000000);
4606     /* XXX : not implemented */
4607     spr_register(env, SPR_Exxx_DBCNT, "DBCNT",
4608                  SPR_NOACCESS, SPR_NOACCESS,
4609                  &spr_read_generic, &spr_write_generic,
4610                  0x00000000);
4611     /* XXX : not implemented */
4612     spr_register(env, SPR_Exxx_DBCR3, "DBCR3",
4613                  SPR_NOACCESS, SPR_NOACCESS,
4614                  &spr_read_generic, &spr_write_generic,
4615                  0x00000000);
4616     /* XXX : not implemented */
4617     spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
4618                  &spr_read_generic, SPR_NOACCESS,
4619                  &spr_read_generic, SPR_NOACCESS,
4620                  0x00000000);
4621     /* XXX : not implemented */
4622     spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
4623                  SPR_NOACCESS, SPR_NOACCESS,
4624                  &spr_read_generic, &spr_write_generic,
4625                  0x00000000);
4626     /* XXX : not implemented */
4627     spr_register(env, SPR_Exxx_L1FINV0, "L1FINV0",
4628                  SPR_NOACCESS, SPR_NOACCESS,
4629                  &spr_read_generic, &spr_write_generic,
4630                  0x00000000);
4631     /* XXX : not implemented */
4632     spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
4633                  SPR_NOACCESS, SPR_NOACCESS,
4634                  &spr_read_generic, &spr_write_generic,
4635                  0x00000000);
4636     /* XXX : not implemented */
4637     spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
4638                  SPR_NOACCESS, SPR_NOACCESS,
4639                  &spr_read_generic, &spr_write_generic,
4640                  0x00000000);
4641     /* XXX : not implemented */
4642     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
4643                  SPR_NOACCESS, SPR_NOACCESS,
4644                  &spr_read_generic, &spr_write_generic,
4645                  0x00000000);
4646     /* XXX : not implemented */
4647     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
4648                  SPR_NOACCESS, SPR_NOACCESS,
4649                  &spr_read_generic, &spr_write_generic,
4650                  0x00000000);
4651     /* XXX : not implemented */
4652     spr_register(env, SPR_MMUCSR0, "MMUCSR0",
4653                  SPR_NOACCESS, SPR_NOACCESS,
4654                  &spr_read_generic, &spr_write_generic,
4655                  0x00000000); /* TOFIX */
4656     spr_register(env, SPR_BOOKE_DSRR0, "DSRR0",
4657                  SPR_NOACCESS, SPR_NOACCESS,
4658                  &spr_read_generic, &spr_write_generic,
4659                  0x00000000);
4660     spr_register(env, SPR_BOOKE_DSRR1, "DSRR1",
4661                  SPR_NOACCESS, SPR_NOACCESS,
4662                  &spr_read_generic, &spr_write_generic,
4663                  0x00000000);
4664 #if !defined(CONFIG_USER_ONLY)
4665     env->nb_tlb = 64;
4666     env->nb_ways = 1;
4667     env->id_tlbs = 0;
4668     env->tlb_type = TLB_EMB;
4669 #endif
4670     init_excp_e200(env, 0xFFFF0000UL);
4671     env->dcache_line_size = 32;
4672     env->icache_line_size = 32;
4673     /* XXX: TODO: allocate internal IRQ controller */
4674 }
4675
4676 POWERPC_FAMILY(e200)(ObjectClass *oc, void *data)
4677 {
4678     DeviceClass *dc = DEVICE_CLASS(oc);
4679     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4680
4681     dc->desc = "e200 core";
4682     pcc->init_proc = init_proc_e200;
4683     pcc->check_pow = check_pow_hid0;
4684     /* XXX: unimplemented instructions:
4685      * dcblc
4686      * dcbtlst
4687      * dcbtstls
4688      * icblc
4689      * icbtls
4690      * tlbivax
4691      * all SPE multiply-accumulate instructions
4692      */
4693     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4694                        PPC_SPE | PPC_SPE_SINGLE |
4695                        PPC_WRTEE | PPC_RFDI |
4696                        PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4697                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4698                        PPC_MEM_TLBSYNC | PPC_TLBIVAX |
4699                        PPC_BOOKE;
4700     pcc->msr_mask = (1ull << MSR_UCLE) |
4701                     (1ull << MSR_SPE) |
4702                     (1ull << MSR_POW) |
4703                     (1ull << MSR_CE) |
4704                     (1ull << MSR_EE) |
4705                     (1ull << MSR_PR) |
4706                     (1ull << MSR_FP) |
4707                     (1ull << MSR_ME) |
4708                     (1ull << MSR_FE0) |
4709                     (1ull << MSR_DWE) |
4710                     (1ull << MSR_DE) |
4711                     (1ull << MSR_FE1) |
4712                     (1ull << MSR_IR) |
4713                     (1ull << MSR_DR);
4714     pcc->mmu_model = POWERPC_MMU_BOOKE206;
4715     pcc->excp_model = POWERPC_EXCP_BOOKE;
4716     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4717     pcc->bfd_mach = bfd_mach_ppc_860;
4718     pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
4719                  POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
4720                  POWERPC_FLAG_BUS_CLK;
4721 }
4722
4723 static void init_proc_e300 (CPUPPCState *env)
4724 {
4725     gen_spr_ne_601(env);
4726     gen_spr_603(env);
4727     /* Time base */
4728     gen_tbl(env);
4729     /* hardware implementation registers */
4730     /* XXX : not implemented */
4731     spr_register(env, SPR_HID0, "HID0",
4732                  SPR_NOACCESS, SPR_NOACCESS,
4733                  &spr_read_generic, &spr_write_generic,
4734                  0x00000000);
4735     /* XXX : not implemented */
4736     spr_register(env, SPR_HID1, "HID1",
4737                  SPR_NOACCESS, SPR_NOACCESS,
4738                  &spr_read_generic, &spr_write_generic,
4739                  0x00000000);
4740     /* XXX : not implemented */
4741     spr_register(env, SPR_HID2, "HID2",
4742                  SPR_NOACCESS, SPR_NOACCESS,
4743                  &spr_read_generic, &spr_write_generic,
4744                  0x00000000);
4745     /* Breakpoints */
4746     /* XXX : not implemented */
4747     spr_register(env, SPR_DABR, "DABR",
4748                  SPR_NOACCESS, SPR_NOACCESS,
4749                  &spr_read_generic, &spr_write_generic,
4750                  0x00000000);
4751     /* XXX : not implemented */
4752     spr_register(env, SPR_DABR2, "DABR2",
4753                  SPR_NOACCESS, SPR_NOACCESS,
4754                  &spr_read_generic, &spr_write_generic,
4755                  0x00000000);
4756     /* XXX : not implemented */
4757     spr_register(env, SPR_IABR2, "IABR2",
4758                  SPR_NOACCESS, SPR_NOACCESS,
4759                  &spr_read_generic, &spr_write_generic,
4760                  0x00000000);
4761     /* XXX : not implemented */
4762     spr_register(env, SPR_IBCR, "IBCR",
4763                  SPR_NOACCESS, SPR_NOACCESS,
4764                  &spr_read_generic, &spr_write_generic,
4765                  0x00000000);
4766     /* XXX : not implemented */
4767     spr_register(env, SPR_DBCR, "DBCR",
4768                  SPR_NOACCESS, SPR_NOACCESS,
4769                  &spr_read_generic, &spr_write_generic,
4770                  0x00000000);
4771     /* Memory management */
4772     gen_low_BATs(env);
4773     gen_high_BATs(env);
4774     gen_6xx_7xx_soft_tlb(env, 64, 2);
4775     init_excp_603(env);
4776     env->dcache_line_size = 32;
4777     env->icache_line_size = 32;
4778     /* Allocate hardware IRQ controller */
4779     ppc6xx_irq_init(ppc_env_get_cpu(env));
4780 }
4781
4782 POWERPC_FAMILY(e300)(ObjectClass *oc, void *data)
4783 {
4784     DeviceClass *dc = DEVICE_CLASS(oc);
4785     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4786
4787     dc->desc = "e300 core";
4788     pcc->init_proc = init_proc_e300;
4789     pcc->check_pow = check_pow_hid0;
4790     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4791                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4792                        PPC_FLOAT_STFIWX |
4793                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4794                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
4795                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4796                        PPC_SEGMENT | PPC_EXTERN;
4797     pcc->msr_mask = (1ull << MSR_POW) |
4798                     (1ull << MSR_TGPR) |
4799                     (1ull << MSR_ILE) |
4800                     (1ull << MSR_EE) |
4801                     (1ull << MSR_PR) |
4802                     (1ull << MSR_FP) |
4803                     (1ull << MSR_ME) |
4804                     (1ull << MSR_FE0) |
4805                     (1ull << MSR_SE) |
4806                     (1ull << MSR_DE) |
4807                     (1ull << MSR_FE1) |
4808                     (1ull << MSR_AL) |
4809                     (1ull << MSR_EP) |
4810                     (1ull << MSR_IR) |
4811                     (1ull << MSR_DR) |
4812                     (1ull << MSR_RI) |
4813                     (1ull << MSR_LE);
4814     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4815     pcc->excp_model = POWERPC_EXCP_603;
4816     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4817     pcc->bfd_mach = bfd_mach_ppc_603;
4818     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4819                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4820 }
4821
4822 #if !defined(CONFIG_USER_ONLY)
4823 static void spr_write_mas73(DisasContext *ctx, int sprn, int gprn)
4824 {
4825     TCGv val = tcg_temp_new();
4826     tcg_gen_ext32u_tl(val, cpu_gpr[gprn]);
4827     gen_store_spr(SPR_BOOKE_MAS3, val);
4828     tcg_gen_shri_tl(val, cpu_gpr[gprn], 32);
4829     gen_store_spr(SPR_BOOKE_MAS7, val);
4830     tcg_temp_free(val);
4831 }
4832
4833 static void spr_read_mas73(DisasContext *ctx, int gprn, int sprn)
4834 {
4835     TCGv mas7 = tcg_temp_new();
4836     TCGv mas3 = tcg_temp_new();
4837     gen_load_spr(mas7, SPR_BOOKE_MAS7);
4838     tcg_gen_shli_tl(mas7, mas7, 32);
4839     gen_load_spr(mas3, SPR_BOOKE_MAS3);
4840     tcg_gen_or_tl(cpu_gpr[gprn], mas3, mas7);
4841     tcg_temp_free(mas3);
4842     tcg_temp_free(mas7);
4843 }
4844
4845 #endif
4846
4847 enum fsl_e500_version {
4848     fsl_e500v1,
4849     fsl_e500v2,
4850     fsl_e500mc,
4851     fsl_e5500,
4852 };
4853
4854 static void init_proc_e500 (CPUPPCState *env, int version)
4855 {
4856     PowerPCCPU *cpu = ppc_env_get_cpu(env);
4857     uint32_t tlbncfg[2];
4858     uint64_t ivor_mask;
4859     uint64_t ivpr_mask = 0xFFFF0000ULL;
4860     uint32_t l1cfg0 = 0x3800  /* 8 ways */
4861                     | 0x0020; /* 32 kb */
4862     uint32_t l1cfg1 = 0x3800  /* 8 ways */
4863                     | 0x0020; /* 32 kb */
4864 #if !defined(CONFIG_USER_ONLY)
4865     int i;
4866 #endif
4867
4868     /* Time base */
4869     gen_tbl(env);
4870     /*
4871      * XXX The e500 doesn't implement IVOR7 and IVOR9, but doesn't
4872      *     complain when accessing them.
4873      * gen_spr_BookE(env, 0x0000000F0000FD7FULL);
4874      */
4875     switch (version) {
4876         case fsl_e500v1:
4877         case fsl_e500v2:
4878         default:
4879             ivor_mask = 0x0000000F0000FFFFULL;
4880             break;
4881         case fsl_e500mc:
4882         case fsl_e5500:
4883             ivor_mask = 0x000003FE0000FFFFULL;
4884             break;
4885     }
4886     gen_spr_BookE(env, ivor_mask);
4887     /* Processor identification */
4888     spr_register(env, SPR_BOOKE_PIR, "PIR",
4889                  SPR_NOACCESS, SPR_NOACCESS,
4890                  &spr_read_generic, &spr_write_pir,
4891                  0x00000000);
4892     /* XXX : not implemented */
4893     spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
4894                  &spr_read_spefscr, &spr_write_spefscr,
4895                  &spr_read_spefscr, &spr_write_spefscr,
4896                  0x00000000);
4897 #if !defined(CONFIG_USER_ONLY)
4898     /* Memory management */
4899     env->nb_pids = 3;
4900     env->nb_ways = 2;
4901     env->id_tlbs = 0;
4902     switch (version) {
4903     case fsl_e500v1:
4904         tlbncfg[0] = gen_tlbncfg(2, 1, 1, 0, 256);
4905         tlbncfg[1] = gen_tlbncfg(16, 1, 9, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
4906         break;
4907     case fsl_e500v2:
4908         tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4909         tlbncfg[1] = gen_tlbncfg(16, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
4910         break;
4911     case fsl_e500mc:
4912     case fsl_e5500:
4913         tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4914         tlbncfg[1] = gen_tlbncfg(64, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 64);
4915         break;
4916     default:
4917         cpu_abort(CPU(cpu), "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
4918     }
4919 #endif
4920     /* Cache sizes */
4921     switch (version) {
4922     case fsl_e500v1:
4923     case fsl_e500v2:
4924         env->dcache_line_size = 32;
4925         env->icache_line_size = 32;
4926         break;
4927     case fsl_e500mc:
4928     case fsl_e5500:
4929         env->dcache_line_size = 64;
4930         env->icache_line_size = 64;
4931         l1cfg0 |= 0x1000000; /* 64 byte cache block size */
4932         l1cfg1 |= 0x1000000; /* 64 byte cache block size */
4933         break;
4934     default:
4935         cpu_abort(CPU(cpu), "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
4936     }
4937     gen_spr_BookE206(env, 0x000000DF, tlbncfg);
4938     /* XXX : not implemented */
4939     spr_register(env, SPR_HID0, "HID0",
4940                  SPR_NOACCESS, SPR_NOACCESS,
4941                  &spr_read_generic, &spr_write_generic,
4942                  0x00000000);
4943     /* XXX : not implemented */
4944     spr_register(env, SPR_HID1, "HID1",
4945                  SPR_NOACCESS, SPR_NOACCESS,
4946                  &spr_read_generic, &spr_write_generic,
4947                  0x00000000);
4948     /* XXX : not implemented */
4949     spr_register(env, SPR_Exxx_BBEAR, "BBEAR",
4950                  SPR_NOACCESS, SPR_NOACCESS,
4951                  &spr_read_generic, &spr_write_generic,
4952                  0x00000000);
4953     /* XXX : not implemented */
4954     spr_register(env, SPR_Exxx_BBTAR, "BBTAR",
4955                  SPR_NOACCESS, SPR_NOACCESS,
4956                  &spr_read_generic, &spr_write_generic,
4957                  0x00000000);
4958     /* XXX : not implemented */
4959     spr_register(env, SPR_Exxx_MCAR, "MCAR",
4960                  SPR_NOACCESS, SPR_NOACCESS,
4961                  &spr_read_generic, &spr_write_generic,
4962                  0x00000000);
4963     /* XXX : not implemented */
4964     spr_register(env, SPR_BOOKE_MCSR, "MCSR",
4965                  SPR_NOACCESS, SPR_NOACCESS,
4966                  &spr_read_generic, &spr_write_generic,
4967                  0x00000000);
4968     /* XXX : not implemented */
4969     spr_register(env, SPR_Exxx_NPIDR, "NPIDR",
4970                  SPR_NOACCESS, SPR_NOACCESS,
4971                  &spr_read_generic, &spr_write_generic,
4972                  0x00000000);
4973     /* XXX : not implemented */
4974     spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
4975                  SPR_NOACCESS, SPR_NOACCESS,
4976                  &spr_read_generic, &spr_write_generic,
4977                  0x00000000);
4978     /* XXX : not implemented */
4979     spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
4980                  &spr_read_generic, SPR_NOACCESS,
4981                  &spr_read_generic, SPR_NOACCESS,
4982                  l1cfg0);
4983     spr_register(env, SPR_Exxx_L1CFG1, "L1CFG1",
4984                  &spr_read_generic, SPR_NOACCESS,
4985                  &spr_read_generic, SPR_NOACCESS,
4986                  l1cfg1);
4987     spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
4988                  SPR_NOACCESS, SPR_NOACCESS,
4989                  &spr_read_generic, &spr_write_e500_l1csr0,
4990                  0x00000000);
4991     spr_register(env, SPR_Exxx_L1CSR1, "L1CSR1",
4992                  SPR_NOACCESS, SPR_NOACCESS,
4993                  &spr_read_generic, &spr_write_e500_l1csr1,
4994                  0x00000000);
4995     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4996                  SPR_NOACCESS, SPR_NOACCESS,
4997                  &spr_read_generic, &spr_write_generic,
4998                  0x00000000);
4999     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
5000                  SPR_NOACCESS, SPR_NOACCESS,
5001                  &spr_read_generic, &spr_write_generic,
5002                  0x00000000);
5003     spr_register(env, SPR_MMUCSR0, "MMUCSR0",
5004                  SPR_NOACCESS, SPR_NOACCESS,
5005                  &spr_read_generic, &spr_write_booke206_mmucsr0,
5006                  0x00000000);
5007     spr_register(env, SPR_BOOKE_EPR, "EPR",
5008                  SPR_NOACCESS, SPR_NOACCESS,
5009                  &spr_read_generic, SPR_NOACCESS,
5010                  0x00000000);
5011     /* XXX better abstract into Emb.xxx features */
5012     if (version == fsl_e5500) {
5013         spr_register(env, SPR_BOOKE_EPCR, "EPCR",
5014                      SPR_NOACCESS, SPR_NOACCESS,
5015                      &spr_read_generic, &spr_write_generic,
5016                      0x00000000);
5017         spr_register(env, SPR_BOOKE_MAS7_MAS3, "MAS7_MAS3",
5018                      SPR_NOACCESS, SPR_NOACCESS,
5019                      &spr_read_mas73, &spr_write_mas73,
5020                      0x00000000);
5021         ivpr_mask = (target_ulong)~0xFFFFULL;
5022     }
5023
5024 #if !defined(CONFIG_USER_ONLY)
5025     env->nb_tlb = 0;
5026     env->tlb_type = TLB_MAS;
5027     for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
5028         env->nb_tlb += booke206_tlb_size(env, i);
5029     }
5030 #endif
5031
5032     init_excp_e200(env, ivpr_mask);
5033     /* Allocate hardware IRQ controller */
5034     ppce500_irq_init(ppc_env_get_cpu(env));
5035 }
5036
5037 static void init_proc_e500v1(CPUPPCState *env)
5038 {
5039     init_proc_e500(env, fsl_e500v1);
5040 }
5041
5042 POWERPC_FAMILY(e500v1)(ObjectClass *oc, void *data)
5043 {
5044     DeviceClass *dc = DEVICE_CLASS(oc);
5045     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5046
5047     dc->desc = "e500v1 core";
5048     pcc->init_proc = init_proc_e500v1;
5049     pcc->check_pow = check_pow_hid0;
5050     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
5051                        PPC_SPE | PPC_SPE_SINGLE |
5052                        PPC_WRTEE | PPC_RFDI |
5053                        PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
5054                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
5055                        PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
5056     pcc->insns_flags2 = PPC2_BOOKE206;
5057     pcc->msr_mask = (1ull << MSR_UCLE) |
5058                     (1ull << MSR_SPE) |
5059                     (1ull << MSR_POW) |
5060                     (1ull << MSR_CE) |
5061                     (1ull << MSR_EE) |
5062                     (1ull << MSR_PR) |
5063                     (1ull << MSR_FP) |
5064                     (1ull << MSR_ME) |
5065                     (1ull << MSR_FE0) |
5066                     (1ull << MSR_DWE) |
5067                     (1ull << MSR_DE) |
5068                     (1ull << MSR_FE1) |
5069                     (1ull << MSR_IR) |
5070                     (1ull << MSR_DR);
5071     pcc->mmu_model = POWERPC_MMU_BOOKE206;
5072     pcc->excp_model = POWERPC_EXCP_BOOKE;
5073     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
5074     pcc->bfd_mach = bfd_mach_ppc_860;
5075     pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
5076                  POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
5077                  POWERPC_FLAG_BUS_CLK;
5078 }
5079
5080 static void init_proc_e500v2(CPUPPCState *env)
5081 {
5082     init_proc_e500(env, fsl_e500v2);
5083 }
5084
5085 POWERPC_FAMILY(e500v2)(ObjectClass *oc, void *data)
5086 {
5087     DeviceClass *dc = DEVICE_CLASS(oc);
5088     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5089
5090     dc->desc = "e500v2 core";
5091     pcc->init_proc = init_proc_e500v2;
5092     pcc->check_pow = check_pow_hid0;
5093     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
5094                        PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE |
5095                        PPC_WRTEE | PPC_RFDI |
5096                        PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
5097                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
5098                        PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
5099     pcc->insns_flags2 = PPC2_BOOKE206;
5100     pcc->msr_mask = (1ull << MSR_UCLE) |
5101                     (1ull << MSR_SPE) |
5102                     (1ull << MSR_POW) |
5103                     (1ull << MSR_CE) |
5104                     (1ull << MSR_EE) |
5105                     (1ull << MSR_PR) |
5106                     (1ull << MSR_FP) |
5107                     (1ull << MSR_ME) |
5108                     (1ull << MSR_FE0) |
5109                     (1ull << MSR_DWE) |
5110                     (1ull << MSR_DE) |
5111                     (1ull << MSR_FE1) |
5112                     (1ull << MSR_IR) |
5113                     (1ull << MSR_DR);
5114     pcc->mmu_model = POWERPC_MMU_BOOKE206;
5115     pcc->excp_model = POWERPC_EXCP_BOOKE;
5116     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
5117     pcc->bfd_mach = bfd_mach_ppc_860;
5118     pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
5119                  POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
5120                  POWERPC_FLAG_BUS_CLK;
5121 }
5122
5123 static void init_proc_e500mc(CPUPPCState *env)
5124 {
5125     init_proc_e500(env, fsl_e500mc);
5126 }
5127
5128 POWERPC_FAMILY(e500mc)(ObjectClass *oc, void *data)
5129 {
5130     DeviceClass *dc = DEVICE_CLASS(oc);
5131     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5132
5133     dc->desc = "e500mc core";
5134     pcc->init_proc = init_proc_e500mc;
5135     pcc->check_pow = check_pow_none;
5136     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_MFTB |
5137                        PPC_WRTEE | PPC_RFDI | PPC_RFMCI |
5138                        PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
5139                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
5140                        PPC_FLOAT | PPC_FLOAT_FRES |
5141                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |
5142                        PPC_FLOAT_STFIWX | PPC_WAIT |
5143                        PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
5144     pcc->insns_flags2 = PPC2_BOOKE206 | PPC2_PRCNTL;
5145     pcc->msr_mask = (1ull << MSR_GS) |
5146                     (1ull << MSR_UCLE) |
5147                     (1ull << MSR_CE) |
5148                     (1ull << MSR_EE) |
5149                     (1ull << MSR_PR) |
5150                     (1ull << MSR_FP) |
5151                     (1ull << MSR_ME) |
5152                     (1ull << MSR_FE0) |
5153                     (1ull << MSR_DE) |
5154                     (1ull << MSR_FE1) |
5155                     (1ull << MSR_IR) |
5156                     (1ull << MSR_DR) |
5157                     (1ull << MSR_PX) |
5158                     (1ull << MSR_RI);
5159     pcc->mmu_model = POWERPC_MMU_BOOKE206;
5160     pcc->excp_model = POWERPC_EXCP_BOOKE;
5161     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
5162     /* FIXME: figure out the correct flag for e500mc */
5163     pcc->bfd_mach = bfd_mach_ppc_e500;
5164     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
5165                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5166 }
5167
5168 #ifdef TARGET_PPC64
5169 static void init_proc_e5500(CPUPPCState *env)
5170 {
5171     init_proc_e500(env, fsl_e5500);
5172 }
5173
5174 POWERPC_FAMILY(e5500)(ObjectClass *oc, void *data)
5175 {
5176     DeviceClass *dc = DEVICE_CLASS(oc);
5177     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5178
5179     dc->desc = "e5500 core";
5180     pcc->init_proc = init_proc_e5500;
5181     pcc->check_pow = check_pow_none;
5182     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_MFTB |
5183                        PPC_WRTEE | PPC_RFDI | PPC_RFMCI |
5184                        PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
5185                        PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
5186                        PPC_FLOAT | PPC_FLOAT_FRES |
5187                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |
5188                        PPC_FLOAT_STFIWX | PPC_WAIT |
5189                        PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC |
5190                        PPC_64B | PPC_POPCNTB | PPC_POPCNTWD;
5191     pcc->insns_flags2 = PPC2_BOOKE206 | PPC2_PRCNTL | PPC2_PERM_ISA206 | \
5192                         PPC2_FP_CVT_S64;
5193     pcc->msr_mask = (1ull << MSR_CM) |
5194                     (1ull << MSR_GS) |
5195                     (1ull << MSR_UCLE) |
5196                     (1ull << MSR_CE) |
5197                     (1ull << MSR_EE) |
5198                     (1ull << MSR_PR) |
5199                     (1ull << MSR_FP) |
5200                     (1ull << MSR_ME) |
5201                     (1ull << MSR_FE0) |
5202                     (1ull << MSR_DE) |
5203                     (1ull << MSR_FE1) |
5204                     (1ull << MSR_IR) |
5205                     (1ull << MSR_DR) |
5206                     (1ull << MSR_PX) |
5207                     (1ull << MSR_RI);
5208     pcc->mmu_model = POWERPC_MMU_BOOKE206;
5209     pcc->excp_model = POWERPC_EXCP_BOOKE;
5210     pcc->bus_model = PPC_FLAGS_INPUT_BookE;
5211     /* FIXME: figure out the correct flag for e5500 */
5212     pcc->bfd_mach = bfd_mach_ppc_e500;
5213     pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
5214                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5215 }
5216 #endif
5217
5218 /* Non-embedded PowerPC                                                      */
5219
5220 /* POWER : same as 601, without mfmsr, mfsr                                  */
5221 POWERPC_FAMILY(POWER)(ObjectClass *oc, void *data)
5222 {
5223     DeviceClass *dc = DEVICE_CLASS(oc);
5224     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5225
5226     dc->desc = "POWER";
5227     /* pcc->insns_flags = XXX_TODO; */
5228     /* POWER RSC (from RAD6000) */
5229     pcc->msr_mask = (1ull << MSR_EE) |
5230                     (1ull << MSR_PR) |
5231                     (1ull << MSR_FP) |
5232                     (1ull << MSR_ME) |
5233                     (1ull << MSR_FE0) |
5234                     (1ull << MSR_SE) |
5235                     (1ull << MSR_DE) |
5236                     (1ull << MSR_AL) |
5237                     (1ull << MSR_EP) |
5238                     (1ull << MSR_IR) |
5239                     (1ull << MSR_DR);
5240 }
5241
5242 #define POWERPC_MSRR_601     (0x0000000000001040ULL)
5243
5244 static void init_proc_601 (CPUPPCState *env)
5245 {
5246     gen_spr_ne_601(env);
5247     gen_spr_601(env);
5248     /* Hardware implementation registers */
5249     /* XXX : not implemented */
5250     spr_register(env, SPR_HID0, "HID0",
5251                  SPR_NOACCESS, SPR_NOACCESS,
5252                  &spr_read_generic, &spr_write_hid0_601,
5253                  0x80010080);
5254     /* XXX : not implemented */
5255     spr_register(env, SPR_HID1, "HID1",
5256                  SPR_NOACCESS, SPR_NOACCESS,
5257                  &spr_read_generic, &spr_write_generic,
5258                  0x00000000);
5259     /* XXX : not implemented */
5260     spr_register(env, SPR_601_HID2, "HID2",
5261                  SPR_NOACCESS, SPR_NOACCESS,
5262                  &spr_read_generic, &spr_write_generic,
5263                  0x00000000);
5264     /* XXX : not implemented */
5265     spr_register(env, SPR_601_HID5, "HID5",
5266                  SPR_NOACCESS, SPR_NOACCESS,
5267                  &spr_read_generic, &spr_write_generic,
5268                  0x00000000);
5269     /* Memory management */
5270     init_excp_601(env);
5271     /* XXX: beware that dcache line size is 64
5272      *      but dcbz uses 32 bytes "sectors"
5273      * XXX: this breaks clcs instruction !
5274      */
5275     env->dcache_line_size = 32;
5276     env->icache_line_size = 64;
5277     /* Allocate hardware IRQ controller */
5278     ppc6xx_irq_init(ppc_env_get_cpu(env));
5279 }
5280
5281 POWERPC_FAMILY(601)(ObjectClass *oc, void *data)
5282 {
5283     DeviceClass *dc = DEVICE_CLASS(oc);
5284     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5285
5286     dc->desc = "PowerPC 601";
5287     pcc->init_proc = init_proc_601;
5288     pcc->check_pow = check_pow_none;
5289     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |
5290                        PPC_FLOAT |
5291                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5292                        PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
5293                        PPC_SEGMENT | PPC_EXTERN;
5294     pcc->msr_mask = (1ull << MSR_EE) |
5295                     (1ull << MSR_PR) |
5296                     (1ull << MSR_FP) |
5297                     (1ull << MSR_ME) |
5298                     (1ull << MSR_FE0) |
5299                     (1ull << MSR_SE) |
5300                     (1ull << MSR_FE1) |
5301                     (1ull << MSR_EP) |
5302                     (1ull << MSR_IR) |
5303                     (1ull << MSR_DR);
5304     pcc->mmu_model = POWERPC_MMU_601;
5305 #if defined(CONFIG_SOFTMMU)
5306     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5307 #endif
5308     pcc->excp_model = POWERPC_EXCP_601;
5309     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5310     pcc->bfd_mach = bfd_mach_ppc_601;
5311     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK;
5312 }
5313
5314 #define POWERPC_MSRR_601v    (0x0000000000001040ULL)
5315
5316 static void init_proc_601v (CPUPPCState *env)
5317 {
5318     init_proc_601(env);
5319     /* XXX : not implemented */
5320     spr_register(env, SPR_601_HID15, "HID15",
5321                  SPR_NOACCESS, SPR_NOACCESS,
5322                  &spr_read_generic, &spr_write_generic,
5323                  0x00000000);
5324 }
5325
5326 POWERPC_FAMILY(601v)(ObjectClass *oc, void *data)
5327 {
5328     DeviceClass *dc = DEVICE_CLASS(oc);
5329     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5330
5331     dc->desc = "PowerPC 601v";
5332     pcc->init_proc = init_proc_601v;
5333     pcc->check_pow = check_pow_none;
5334     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |
5335                        PPC_FLOAT |
5336                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5337                        PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
5338                        PPC_SEGMENT | PPC_EXTERN;
5339     pcc->msr_mask = (1ull << MSR_EE) |
5340                     (1ull << MSR_PR) |
5341                     (1ull << MSR_FP) |
5342                     (1ull << MSR_ME) |
5343                     (1ull << MSR_FE0) |
5344                     (1ull << MSR_SE) |
5345                     (1ull << MSR_FE1) |
5346                     (1ull << MSR_EP) |
5347                     (1ull << MSR_IR) |
5348                     (1ull << MSR_DR);
5349     pcc->mmu_model = POWERPC_MMU_601;
5350 #if defined(CONFIG_SOFTMMU)
5351     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5352 #endif
5353     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5354     pcc->bfd_mach = bfd_mach_ppc_601;
5355     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK;
5356 }
5357
5358 static void init_proc_602 (CPUPPCState *env)
5359 {
5360     gen_spr_ne_601(env);
5361     gen_spr_602(env);
5362     /* Time base */
5363     gen_tbl(env);
5364     /* hardware implementation registers */
5365     /* XXX : not implemented */
5366     spr_register(env, SPR_HID0, "HID0",
5367                  SPR_NOACCESS, SPR_NOACCESS,
5368                  &spr_read_generic, &spr_write_generic,
5369                  0x00000000);
5370     /* XXX : not implemented */
5371     spr_register(env, SPR_HID1, "HID1",
5372                  SPR_NOACCESS, SPR_NOACCESS,
5373                  &spr_read_generic, &spr_write_generic,
5374                  0x00000000);
5375     /* Memory management */
5376     gen_low_BATs(env);
5377     gen_6xx_7xx_soft_tlb(env, 64, 2);
5378     init_excp_602(env);
5379     env->dcache_line_size = 32;
5380     env->icache_line_size = 32;
5381     /* Allocate hardware IRQ controller */
5382     ppc6xx_irq_init(ppc_env_get_cpu(env));
5383 }
5384
5385 POWERPC_FAMILY(602)(ObjectClass *oc, void *data)
5386 {
5387     DeviceClass *dc = DEVICE_CLASS(oc);
5388     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5389
5390     dc->desc = "PowerPC 602";
5391     pcc->init_proc = init_proc_602;
5392     pcc->check_pow = check_pow_hid0;
5393     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5394                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5395                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5396                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5397                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5398                        PPC_MEM_TLBIE | PPC_6xx_TLB | PPC_MEM_TLBSYNC |
5399                        PPC_SEGMENT | PPC_602_SPEC;
5400     pcc->msr_mask = (1ull << MSR_VSX) |
5401                     (1ull << MSR_SA) |
5402                     (1ull << MSR_POW) |
5403                     (1ull << MSR_TGPR) |
5404                     (1ull << MSR_ILE) |
5405                     (1ull << MSR_EE) |
5406                     (1ull << MSR_PR) |
5407                     (1ull << MSR_FP) |
5408                     (1ull << MSR_ME) |
5409                     (1ull << MSR_FE0) |
5410                     (1ull << MSR_SE) |
5411                     (1ull << MSR_DE) |
5412                     (1ull << MSR_FE1) |
5413                     (1ull << MSR_EP) |
5414                     (1ull << MSR_IR) |
5415                     (1ull << MSR_DR) |
5416                     (1ull << MSR_RI) |
5417                     (1ull << MSR_LE);
5418     /* XXX: 602 MMU is quite specific. Should add a special case */
5419     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5420     pcc->excp_model = POWERPC_EXCP_602;
5421     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5422     pcc->bfd_mach = bfd_mach_ppc_602;
5423     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5424                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5425 }
5426
5427 static void init_proc_603 (CPUPPCState *env)
5428 {
5429     gen_spr_ne_601(env);
5430     gen_spr_603(env);
5431     /* Time base */
5432     gen_tbl(env);
5433     /* hardware implementation registers */
5434     /* XXX : not implemented */
5435     spr_register(env, SPR_HID0, "HID0",
5436                  SPR_NOACCESS, SPR_NOACCESS,
5437                  &spr_read_generic, &spr_write_generic,
5438                  0x00000000);
5439     /* XXX : not implemented */
5440     spr_register(env, SPR_HID1, "HID1",
5441                  SPR_NOACCESS, SPR_NOACCESS,
5442                  &spr_read_generic, &spr_write_generic,
5443                  0x00000000);
5444     /* Memory management */
5445     gen_low_BATs(env);
5446     gen_6xx_7xx_soft_tlb(env, 64, 2);
5447     init_excp_603(env);
5448     env->dcache_line_size = 32;
5449     env->icache_line_size = 32;
5450     /* Allocate hardware IRQ controller */
5451     ppc6xx_irq_init(ppc_env_get_cpu(env));
5452 }
5453
5454 POWERPC_FAMILY(603)(ObjectClass *oc, void *data)
5455 {
5456     DeviceClass *dc = DEVICE_CLASS(oc);
5457     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5458
5459     dc->desc = "PowerPC 603";
5460     pcc->init_proc = init_proc_603;
5461     pcc->check_pow = check_pow_hid0;
5462     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5463                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5464                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5465                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5466                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5467                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5468                        PPC_SEGMENT | PPC_EXTERN;
5469     pcc->msr_mask = (1ull << MSR_POW) |
5470                     (1ull << MSR_TGPR) |
5471                     (1ull << MSR_ILE) |
5472                     (1ull << MSR_EE) |
5473                     (1ull << MSR_PR) |
5474                     (1ull << MSR_FP) |
5475                     (1ull << MSR_ME) |
5476                     (1ull << MSR_FE0) |
5477                     (1ull << MSR_SE) |
5478                     (1ull << MSR_DE) |
5479                     (1ull << MSR_FE1) |
5480                     (1ull << MSR_EP) |
5481                     (1ull << MSR_IR) |
5482                     (1ull << MSR_DR) |
5483                     (1ull << MSR_RI) |
5484                     (1ull << MSR_LE);
5485     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5486     pcc->excp_model = POWERPC_EXCP_603;
5487     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5488     pcc->bfd_mach = bfd_mach_ppc_603;
5489     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5490                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5491 }
5492
5493 static void init_proc_603E (CPUPPCState *env)
5494 {
5495     gen_spr_ne_601(env);
5496     gen_spr_603(env);
5497     /* Time base */
5498     gen_tbl(env);
5499     /* hardware implementation registers */
5500     /* XXX : not implemented */
5501     spr_register(env, SPR_HID0, "HID0",
5502                  SPR_NOACCESS, SPR_NOACCESS,
5503                  &spr_read_generic, &spr_write_generic,
5504                  0x00000000);
5505     /* XXX : not implemented */
5506     spr_register(env, SPR_HID1, "HID1",
5507                  SPR_NOACCESS, SPR_NOACCESS,
5508                  &spr_read_generic, &spr_write_generic,
5509                  0x00000000);
5510     /* Memory management */
5511     gen_low_BATs(env);
5512     gen_6xx_7xx_soft_tlb(env, 64, 2);
5513     init_excp_603(env);
5514     env->dcache_line_size = 32;
5515     env->icache_line_size = 32;
5516     /* Allocate hardware IRQ controller */
5517     ppc6xx_irq_init(ppc_env_get_cpu(env));
5518 }
5519
5520 POWERPC_FAMILY(603E)(ObjectClass *oc, void *data)
5521 {
5522     DeviceClass *dc = DEVICE_CLASS(oc);
5523     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5524
5525     dc->desc = "PowerPC 603e";
5526     pcc->init_proc = init_proc_603E;
5527     pcc->check_pow = check_pow_hid0;
5528     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5529                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5530                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5531                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5532                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5533                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5534                        PPC_SEGMENT | PPC_EXTERN;
5535     pcc->msr_mask = (1ull << MSR_POW) |
5536                     (1ull << MSR_TGPR) |
5537                     (1ull << MSR_ILE) |
5538                     (1ull << MSR_EE) |
5539                     (1ull << MSR_PR) |
5540                     (1ull << MSR_FP) |
5541                     (1ull << MSR_ME) |
5542                     (1ull << MSR_FE0) |
5543                     (1ull << MSR_SE) |
5544                     (1ull << MSR_DE) |
5545                     (1ull << MSR_FE1) |
5546                     (1ull << MSR_EP) |
5547                     (1ull << MSR_IR) |
5548                     (1ull << MSR_DR) |
5549                     (1ull << MSR_RI) |
5550                     (1ull << MSR_LE);
5551     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5552     pcc->excp_model = POWERPC_EXCP_603E;
5553     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5554     pcc->bfd_mach = bfd_mach_ppc_ec603e;
5555     pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5556                  POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5557 }
5558
5559 static void init_proc_604 (CPUPPCState *env)
5560 {
5561     gen_spr_ne_601(env);
5562     gen_spr_604(env);
5563     /* Time base */
5564     gen_tbl(env);
5565     /* Hardware implementation registers */
5566     /* XXX : not implemented */
5567     spr_register(env, SPR_HID0, "HID0",
5568                  SPR_NOACCESS, SPR_NOACCESS,
5569                  &spr_read_generic, &spr_write_generic,
5570                  0x00000000);
5571     /* Memory management */
5572     gen_low_BATs(env);
5573     init_excp_604(env);
5574     env->dcache_line_size = 32;
5575     env->icache_line_size = 32;
5576     /* Allocate hardware IRQ controller */
5577     ppc6xx_irq_init(ppc_env_get_cpu(env));
5578 }
5579
5580 POWERPC_FAMILY(604)(ObjectClass *oc, void *data)
5581 {
5582     DeviceClass *dc = DEVICE_CLASS(oc);
5583     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5584
5585     dc->desc = "PowerPC 604";
5586     pcc->init_proc = init_proc_604;
5587     pcc->check_pow = check_pow_nocheck;
5588     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5589                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5590                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5591                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5592                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5593                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5594                        PPC_SEGMENT | PPC_EXTERN;
5595     pcc->msr_mask = (1ull << MSR_POW) |
5596                     (1ull << MSR_ILE) |
5597                     (1ull << MSR_EE) |
5598                     (1ull << MSR_PR) |
5599                     (1ull << MSR_FP) |
5600                     (1ull << MSR_ME) |
5601                     (1ull << MSR_FE0) |
5602                     (1ull << MSR_SE) |
5603                     (1ull << MSR_DE) |
5604                     (1ull << MSR_FE1) |
5605                     (1ull << MSR_EP) |
5606                     (1ull << MSR_IR) |
5607                     (1ull << MSR_DR) |
5608                     (1ull << MSR_PMM) |
5609                     (1ull << MSR_RI) |
5610                     (1ull << MSR_LE);
5611     pcc->mmu_model = POWERPC_MMU_32B;
5612 #if defined(CONFIG_SOFTMMU)
5613     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5614 #endif
5615     pcc->excp_model = POWERPC_EXCP_604;
5616     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5617     pcc->bfd_mach = bfd_mach_ppc_604;
5618     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5619                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5620 }
5621
5622 static void init_proc_604E (CPUPPCState *env)
5623 {
5624     gen_spr_ne_601(env);
5625     gen_spr_604(env);
5626     /* XXX : not implemented */
5627     spr_register(env, SPR_7XX_MMCR1, "MMCR1",
5628                  SPR_NOACCESS, SPR_NOACCESS,
5629                  &spr_read_generic, &spr_write_generic,
5630                  0x00000000);
5631     /* XXX : not implemented */
5632     spr_register(env, SPR_7XX_PMC3, "PMC3",
5633                  SPR_NOACCESS, SPR_NOACCESS,
5634                  &spr_read_generic, &spr_write_generic,
5635                  0x00000000);
5636     /* XXX : not implemented */
5637     spr_register(env, SPR_7XX_PMC4, "PMC4",
5638                  SPR_NOACCESS, SPR_NOACCESS,
5639                  &spr_read_generic, &spr_write_generic,
5640                  0x00000000);
5641     /* Time base */
5642     gen_tbl(env);
5643     /* Hardware implementation registers */
5644     /* XXX : not implemented */
5645     spr_register(env, SPR_HID0, "HID0",
5646                  SPR_NOACCESS, SPR_NOACCESS,
5647                  &spr_read_generic, &spr_write_generic,
5648                  0x00000000);
5649     /* XXX : not implemented */
5650     spr_register(env, SPR_HID1, "HID1",
5651                  SPR_NOACCESS, SPR_NOACCESS,
5652                  &spr_read_generic, &spr_write_generic,
5653                  0x00000000);
5654     /* Memory management */
5655     gen_low_BATs(env);
5656     init_excp_604(env);
5657     env->dcache_line_size = 32;
5658     env->icache_line_size = 32;
5659     /* Allocate hardware IRQ controller */
5660     ppc6xx_irq_init(ppc_env_get_cpu(env));
5661 }
5662
5663 POWERPC_FAMILY(604E)(ObjectClass *oc, void *data)
5664 {
5665     DeviceClass *dc = DEVICE_CLASS(oc);
5666     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5667
5668     dc->desc = "PowerPC 604E";
5669     pcc->init_proc = init_proc_604E;
5670     pcc->check_pow = check_pow_nocheck;
5671     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5672                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5673                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5674                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5675                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5676                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5677                        PPC_SEGMENT | PPC_EXTERN;
5678     pcc->msr_mask = (1ull << MSR_POW) |
5679                     (1ull << MSR_ILE) |
5680                     (1ull << MSR_EE) |
5681                     (1ull << MSR_PR) |
5682                     (1ull << MSR_FP) |
5683                     (1ull << MSR_ME) |
5684                     (1ull << MSR_FE0) |
5685                     (1ull << MSR_SE) |
5686                     (1ull << MSR_DE) |
5687                     (1ull << MSR_FE1) |
5688                     (1ull << MSR_EP) |
5689                     (1ull << MSR_IR) |
5690                     (1ull << MSR_DR) |
5691                     (1ull << MSR_PMM) |
5692                     (1ull << MSR_RI) |
5693                     (1ull << MSR_LE);
5694     pcc->mmu_model = POWERPC_MMU_32B;
5695 #if defined(CONFIG_SOFTMMU)
5696     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5697 #endif
5698     pcc->excp_model = POWERPC_EXCP_604;
5699     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5700     pcc->bfd_mach = bfd_mach_ppc_604;
5701     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5702                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5703 }
5704
5705 static void init_proc_740 (CPUPPCState *env)
5706 {
5707     gen_spr_ne_601(env);
5708     gen_spr_7xx(env);
5709     /* Time base */
5710     gen_tbl(env);
5711     /* Thermal management */
5712     gen_spr_thrm(env);
5713     /* Hardware implementation registers */
5714     /* XXX : not implemented */
5715     spr_register(env, SPR_HID0, "HID0",
5716                  SPR_NOACCESS, SPR_NOACCESS,
5717                  &spr_read_generic, &spr_write_generic,
5718                  0x00000000);
5719     /* XXX : not implemented */
5720     spr_register(env, SPR_HID1, "HID1",
5721                  SPR_NOACCESS, SPR_NOACCESS,
5722                  &spr_read_generic, &spr_write_generic,
5723                  0x00000000);
5724     /* Memory management */
5725     gen_low_BATs(env);
5726     init_excp_7x0(env);
5727     env->dcache_line_size = 32;
5728     env->icache_line_size = 32;
5729     /* Allocate hardware IRQ controller */
5730     ppc6xx_irq_init(ppc_env_get_cpu(env));
5731 }
5732
5733 POWERPC_FAMILY(740)(ObjectClass *oc, void *data)
5734 {
5735     DeviceClass *dc = DEVICE_CLASS(oc);
5736     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5737
5738     dc->desc = "PowerPC 740";
5739     pcc->init_proc = init_proc_740;
5740     pcc->check_pow = check_pow_hid0;
5741     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5742                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5743                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5744                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5745                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5746                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5747                        PPC_SEGMENT | PPC_EXTERN;
5748     pcc->msr_mask = (1ull << MSR_POW) |
5749                     (1ull << MSR_ILE) |
5750                     (1ull << MSR_EE) |
5751                     (1ull << MSR_PR) |
5752                     (1ull << MSR_FP) |
5753                     (1ull << MSR_ME) |
5754                     (1ull << MSR_FE0) |
5755                     (1ull << MSR_SE) |
5756                     (1ull << MSR_DE) |
5757                     (1ull << MSR_FE1) |
5758                     (1ull << MSR_EP) |
5759                     (1ull << MSR_IR) |
5760                     (1ull << MSR_DR) |
5761                     (1ull << MSR_PMM) |
5762                     (1ull << MSR_RI) |
5763                     (1ull << MSR_LE);
5764     pcc->mmu_model = POWERPC_MMU_32B;
5765 #if defined(CONFIG_SOFTMMU)
5766     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5767 #endif
5768     pcc->excp_model = POWERPC_EXCP_7x0;
5769     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5770     pcc->bfd_mach = bfd_mach_ppc_750;
5771     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5772                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5773 }
5774
5775 static void init_proc_750 (CPUPPCState *env)
5776 {
5777     gen_spr_ne_601(env);
5778     gen_spr_7xx(env);
5779     /* XXX : not implemented */
5780     spr_register(env, SPR_L2CR, "L2CR",
5781                  SPR_NOACCESS, SPR_NOACCESS,
5782                  &spr_read_generic, spr_access_nop,
5783                  0x00000000);
5784     /* Time base */
5785     gen_tbl(env);
5786     /* Thermal management */
5787     gen_spr_thrm(env);
5788     /* Hardware implementation registers */
5789     /* XXX : not implemented */
5790     spr_register(env, SPR_HID0, "HID0",
5791                  SPR_NOACCESS, SPR_NOACCESS,
5792                  &spr_read_generic, &spr_write_generic,
5793                  0x00000000);
5794     /* XXX : not implemented */
5795     spr_register(env, SPR_HID1, "HID1",
5796                  SPR_NOACCESS, SPR_NOACCESS,
5797                  &spr_read_generic, &spr_write_generic,
5798                  0x00000000);
5799     /* Memory management */
5800     gen_low_BATs(env);
5801     /* XXX: high BATs are also present but are known to be bugged on
5802      *      die version 1.x
5803      */
5804     init_excp_7x0(env);
5805     env->dcache_line_size = 32;
5806     env->icache_line_size = 32;
5807     /* Allocate hardware IRQ controller */
5808     ppc6xx_irq_init(ppc_env_get_cpu(env));
5809 }
5810
5811 POWERPC_FAMILY(750)(ObjectClass *oc, void *data)
5812 {
5813     DeviceClass *dc = DEVICE_CLASS(oc);
5814     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5815
5816     dc->desc = "PowerPC 750";
5817     pcc->init_proc = init_proc_750;
5818     pcc->check_pow = check_pow_hid0;
5819     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5820                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5821                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5822                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5823                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
5824                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5825                        PPC_SEGMENT | PPC_EXTERN;
5826     pcc->msr_mask = (1ull << MSR_POW) |
5827                     (1ull << MSR_ILE) |
5828                     (1ull << MSR_EE) |
5829                     (1ull << MSR_PR) |
5830                     (1ull << MSR_FP) |
5831                     (1ull << MSR_ME) |
5832                     (1ull << MSR_FE0) |
5833                     (1ull << MSR_SE) |
5834                     (1ull << MSR_DE) |
5835                     (1ull << MSR_FE1) |
5836                     (1ull << MSR_EP) |
5837                     (1ull << MSR_IR) |
5838                     (1ull << MSR_DR) |
5839                     (1ull << MSR_PMM) |
5840                     (1ull << MSR_RI) |
5841                     (1ull << MSR_LE);
5842     pcc->mmu_model = POWERPC_MMU_32B;
5843 #if defined(CONFIG_SOFTMMU)
5844     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
5845 #endif
5846     pcc->excp_model = POWERPC_EXCP_7x0;
5847     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5848     pcc->bfd_mach = bfd_mach_ppc_750;
5849     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5850                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5851 }
5852
5853 static void init_proc_750cl (CPUPPCState *env)
5854 {
5855     gen_spr_ne_601(env);
5856     gen_spr_7xx(env);
5857     /* XXX : not implemented */
5858     spr_register(env, SPR_L2CR, "L2CR",
5859                  SPR_NOACCESS, SPR_NOACCESS,
5860                  &spr_read_generic, spr_access_nop,
5861                  0x00000000);
5862     /* Time base */
5863     gen_tbl(env);
5864     /* Thermal management */
5865     /* Those registers are fake on 750CL */
5866     spr_register(env, SPR_THRM1, "THRM1",
5867                  SPR_NOACCESS, SPR_NOACCESS,
5868                  &spr_read_generic, &spr_write_generic,
5869                  0x00000000);
5870     spr_register(env, SPR_THRM2, "THRM2",
5871                  SPR_NOACCESS, SPR_NOACCESS,
5872                  &spr_read_generic, &spr_write_generic,
5873                  0x00000000);
5874     spr_register(env, SPR_THRM3, "THRM3",
5875                  SPR_NOACCESS, SPR_NOACCESS,
5876                  &spr_read_generic, &spr_write_generic,
5877                  0x00000000);
5878     /* XXX: not implemented */
5879     spr_register(env, SPR_750_TDCL, "TDCL",
5880                  SPR_NOACCESS, SPR_NOACCESS,
5881                  &spr_read_generic, &spr_write_generic,
5882                  0x00000000);
5883     spr_register(env, SPR_750_TDCH, "TDCH",
5884                  SPR_NOACCESS, SPR_NOACCESS,
5885                  &spr_read_generic, &spr_write_generic,
5886                  0x00000000);
5887     /* DMA */
5888     /* XXX : not implemented */
5889     spr_register(env, SPR_750_WPAR, "WPAR",
5890                  SPR_NOACCESS, SPR_NOACCESS,
5891                  &spr_read_generic, &spr_write_generic,
5892                  0x00000000);
5893     spr_register(env, SPR_750_DMAL, "DMAL",
5894                  SPR_NOACCESS, SPR_NOACCESS,
5895                  &spr_read_generic, &spr_write_generic,
5896                  0x00000000);
5897     spr_register(env, SPR_750_DMAU, "DMAU",
5898                  SPR_NOACCESS, SPR_NOACCESS,
5899                  &spr_read_generic, &spr_write_generic,
5900                  0x00000000);
5901     /* Hardware implementation registers */
5902     /* XXX : not implemented */
5903     spr_register(env, SPR_HID0, "HID0",
5904                  SPR_NOACCESS, SPR_NOACCESS,
5905                  &spr_read_generic, &spr_write_generic,
5906                  0x00000000);
5907     /* XXX : not implemented */
5908     spr_register(env, SPR_HID1, "HID1",
5909                  SPR_NOACCESS, SPR_NOACCESS,
5910                  &spr_read_generic, &spr_write_generic,
5911                  0x00000000);
5912     /* XXX : not implemented */
5913     spr_register(env, SPR_750CL_HID2, "HID2",
5914                  SPR_NOACCESS, SPR_NOACCESS,
5915                  &spr_read_generic, &spr_write_generic,
5916                  0x00000000);
5917     /* XXX : not implemented */
5918     spr_register(env, SPR_750CL_HID4, "HID4",
5919                  SPR_NOACCESS, SPR_NOACCESS,
5920                  &spr_read_generic, &spr_write_generic,
5921                  0x00000000);
5922     /* Quantization registers */
5923     /* XXX : not implemented */
5924     spr_register(env, SPR_750_GQR0, "GQR0",
5925                  SPR_NOACCESS, SPR_NOACCESS,
5926                  &spr_read_generic, &spr_write_generic,
5927                  0x00000000);
5928     /* XXX : not implemented */
5929     spr_register(env, SPR_750_GQR1, "GQR1",
5930                  SPR_NOACCESS, SPR_NOACCESS,
5931                  &spr_read_generic, &spr_write_generic,
5932                  0x00000000);
5933     /* XXX : not implemented */
5934     spr_register(env, SPR_750_GQR2, "GQR2",
5935                  SPR_NOACCESS, SPR_NOACCESS,
5936                  &spr_read_generic, &spr_write_generic,
5937                  0x00000000);
5938     /* XXX : not implemented */
5939     spr_register(env, SPR_750_GQR3, "GQR3",
5940                  SPR_NOACCESS, SPR_NOACCESS,
5941                  &spr_read_generic, &spr_write_generic,
5942                  0x00000000);
5943     /* XXX : not implemented */
5944     spr_register(env, SPR_750_GQR4, "GQR4",
5945                  SPR_NOACCESS, SPR_NOACCESS,
5946                  &spr_read_generic, &spr_write_generic,
5947                  0x00000000);
5948     /* XXX : not implemented */
5949     spr_register(env, SPR_750_GQR5, "GQR5",
5950                  SPR_NOACCESS, SPR_NOACCESS,
5951                  &spr_read_generic, &spr_write_generic,
5952                  0x00000000);
5953     /* XXX : not implemented */
5954     spr_register(env, SPR_750_GQR6, "GQR6",
5955                  SPR_NOACCESS, SPR_NOACCESS,
5956                  &spr_read_generic, &spr_write_generic,
5957                  0x00000000);
5958     /* XXX : not implemented */
5959     spr_register(env, SPR_750_GQR7, "GQR7",
5960                  SPR_NOACCESS, SPR_NOACCESS,
5961                  &spr_read_generic, &spr_write_generic,
5962                  0x00000000);
5963     /* Memory management */
5964     gen_low_BATs(env);
5965     /* PowerPC 750cl has 8 DBATs and 8 IBATs */
5966     gen_high_BATs(env);
5967     init_excp_750cl(env);
5968     env->dcache_line_size = 32;
5969     env->icache_line_size = 32;
5970     /* Allocate hardware IRQ controller */
5971     ppc6xx_irq_init(ppc_env_get_cpu(env));
5972 }
5973
5974 POWERPC_FAMILY(750cl)(ObjectClass *oc, void *data)
5975 {
5976     DeviceClass *dc = DEVICE_CLASS(oc);
5977     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5978
5979     dc->desc = "PowerPC 750 CL";
5980     pcc->init_proc = init_proc_750cl;
5981     pcc->check_pow = check_pow_hid0;
5982     /* XXX: not implemented:
5983      * cache lock instructions:
5984      * dcbz_l
5985      * floating point paired instructions
5986      * psq_lux
5987      * psq_lx
5988      * psq_stux
5989      * psq_stx
5990      * ps_abs
5991      * ps_add
5992      * ps_cmpo0
5993      * ps_cmpo1
5994      * ps_cmpu0
5995      * ps_cmpu1
5996      * ps_div
5997      * ps_madd
5998      * ps_madds0
5999      * ps_madds1
6000      * ps_merge00
6001      * ps_merge01
6002      * ps_merge10
6003      * ps_merge11
6004      * ps_mr
6005      * ps_msub
6006      * ps_mul
6007      * ps_muls0
6008      * ps_muls1
6009      * ps_nabs
6010      * ps_neg
6011      * ps_nmadd
6012      * ps_nmsub
6013      * ps_res
6014      * ps_rsqrte
6015      * ps_sel
6016      * ps_sub
6017      * ps_sum0
6018      * ps_sum1
6019      */
6020     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6021                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6022                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6023                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6024                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6025                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6026                        PPC_SEGMENT | PPC_EXTERN;
6027     pcc->msr_mask = (1ull << MSR_POW) |
6028                     (1ull << MSR_ILE) |
6029                     (1ull << MSR_EE) |
6030                     (1ull << MSR_PR) |
6031                     (1ull << MSR_FP) |
6032                     (1ull << MSR_ME) |
6033                     (1ull << MSR_FE0) |
6034                     (1ull << MSR_SE) |
6035                     (1ull << MSR_DE) |
6036                     (1ull << MSR_FE1) |
6037                     (1ull << MSR_EP) |
6038                     (1ull << MSR_IR) |
6039                     (1ull << MSR_DR) |
6040                     (1ull << MSR_PMM) |
6041                     (1ull << MSR_RI) |
6042                     (1ull << MSR_LE);
6043     pcc->mmu_model = POWERPC_MMU_32B;
6044 #if defined(CONFIG_SOFTMMU)
6045     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6046 #endif
6047     pcc->excp_model = POWERPC_EXCP_7x0;
6048     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6049     pcc->bfd_mach = bfd_mach_ppc_750;
6050     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6051                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6052 }
6053
6054 static void init_proc_750cx (CPUPPCState *env)
6055 {
6056     gen_spr_ne_601(env);
6057     gen_spr_7xx(env);
6058     /* XXX : not implemented */
6059     spr_register(env, SPR_L2CR, "L2CR",
6060                  SPR_NOACCESS, SPR_NOACCESS,
6061                  &spr_read_generic, spr_access_nop,
6062                  0x00000000);
6063     /* Time base */
6064     gen_tbl(env);
6065     /* Thermal management */
6066     gen_spr_thrm(env);
6067     /* This register is not implemented but is present for compatibility */
6068     spr_register(env, SPR_SDA, "SDA",
6069                  SPR_NOACCESS, SPR_NOACCESS,
6070                  &spr_read_generic, &spr_write_generic,
6071                  0x00000000);
6072     /* Hardware implementation registers */
6073     /* XXX : not implemented */
6074     spr_register(env, SPR_HID0, "HID0",
6075                  SPR_NOACCESS, SPR_NOACCESS,
6076                  &spr_read_generic, &spr_write_generic,
6077                  0x00000000);
6078     /* XXX : not implemented */
6079     spr_register(env, SPR_HID1, "HID1",
6080                  SPR_NOACCESS, SPR_NOACCESS,
6081                  &spr_read_generic, &spr_write_generic,
6082                  0x00000000);
6083     /* Memory management */
6084     gen_low_BATs(env);
6085     /* PowerPC 750cx has 8 DBATs and 8 IBATs */
6086     gen_high_BATs(env);
6087     init_excp_750cx(env);
6088     env->dcache_line_size = 32;
6089     env->icache_line_size = 32;
6090     /* Allocate hardware IRQ controller */
6091     ppc6xx_irq_init(ppc_env_get_cpu(env));
6092 }
6093
6094 POWERPC_FAMILY(750cx)(ObjectClass *oc, void *data)
6095 {
6096     DeviceClass *dc = DEVICE_CLASS(oc);
6097     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6098
6099     dc->desc = "PowerPC 750CX";
6100     pcc->init_proc = init_proc_750cx;
6101     pcc->check_pow = check_pow_hid0;
6102     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6103                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6104                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6105                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6106                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6107                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6108                        PPC_SEGMENT | PPC_EXTERN;
6109     pcc->msr_mask = (1ull << MSR_POW) |
6110                     (1ull << MSR_ILE) |
6111                     (1ull << MSR_EE) |
6112                     (1ull << MSR_PR) |
6113                     (1ull << MSR_FP) |
6114                     (1ull << MSR_ME) |
6115                     (1ull << MSR_FE0) |
6116                     (1ull << MSR_SE) |
6117                     (1ull << MSR_DE) |
6118                     (1ull << MSR_FE1) |
6119                     (1ull << MSR_EP) |
6120                     (1ull << MSR_IR) |
6121                     (1ull << MSR_DR) |
6122                     (1ull << MSR_PMM) |
6123                     (1ull << MSR_RI) |
6124                     (1ull << MSR_LE);
6125     pcc->mmu_model = POWERPC_MMU_32B;
6126 #if defined(CONFIG_SOFTMMU)
6127     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6128 #endif
6129     pcc->excp_model = POWERPC_EXCP_7x0;
6130     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6131     pcc->bfd_mach = bfd_mach_ppc_750;
6132     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6133                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6134 }
6135
6136 static void init_proc_750fx (CPUPPCState *env)
6137 {
6138     gen_spr_ne_601(env);
6139     gen_spr_7xx(env);
6140     /* XXX : not implemented */
6141     spr_register(env, SPR_L2CR, "L2CR",
6142                  SPR_NOACCESS, SPR_NOACCESS,
6143                  &spr_read_generic, spr_access_nop,
6144                  0x00000000);
6145     /* Time base */
6146     gen_tbl(env);
6147     /* Thermal management */
6148     gen_spr_thrm(env);
6149     /* XXX : not implemented */
6150     spr_register(env, SPR_750_THRM4, "THRM4",
6151                  SPR_NOACCESS, SPR_NOACCESS,
6152                  &spr_read_generic, &spr_write_generic,
6153                  0x00000000);
6154     /* Hardware implementation registers */
6155     /* XXX : not implemented */
6156     spr_register(env, SPR_HID0, "HID0",
6157                  SPR_NOACCESS, SPR_NOACCESS,
6158                  &spr_read_generic, &spr_write_generic,
6159                  0x00000000);
6160     /* XXX : not implemented */
6161     spr_register(env, SPR_HID1, "HID1",
6162                  SPR_NOACCESS, SPR_NOACCESS,
6163                  &spr_read_generic, &spr_write_generic,
6164                  0x00000000);
6165     /* XXX : not implemented */
6166     spr_register(env, SPR_750FX_HID2, "HID2",
6167                  SPR_NOACCESS, SPR_NOACCESS,
6168                  &spr_read_generic, &spr_write_generic,
6169                  0x00000000);
6170     /* Memory management */
6171     gen_low_BATs(env);
6172     /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
6173     gen_high_BATs(env);
6174     init_excp_7x0(env);
6175     env->dcache_line_size = 32;
6176     env->icache_line_size = 32;
6177     /* Allocate hardware IRQ controller */
6178     ppc6xx_irq_init(ppc_env_get_cpu(env));
6179 }
6180
6181 POWERPC_FAMILY(750fx)(ObjectClass *oc, void *data)
6182 {
6183     DeviceClass *dc = DEVICE_CLASS(oc);
6184     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6185
6186     dc->desc = "PowerPC 750FX";
6187     pcc->init_proc = init_proc_750fx;
6188     pcc->check_pow = check_pow_hid0;
6189     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6190                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6191                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6192                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6193                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6194                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6195                        PPC_SEGMENT | PPC_EXTERN;
6196     pcc->msr_mask = (1ull << MSR_POW) |
6197                     (1ull << MSR_ILE) |
6198                     (1ull << MSR_EE) |
6199                     (1ull << MSR_PR) |
6200                     (1ull << MSR_FP) |
6201                     (1ull << MSR_ME) |
6202                     (1ull << MSR_FE0) |
6203                     (1ull << MSR_SE) |
6204                     (1ull << MSR_DE) |
6205                     (1ull << MSR_FE1) |
6206                     (1ull << MSR_EP) |
6207                     (1ull << MSR_IR) |
6208                     (1ull << MSR_DR) |
6209                     (1ull << MSR_PMM) |
6210                     (1ull << MSR_RI) |
6211                     (1ull << MSR_LE);
6212     pcc->mmu_model = POWERPC_MMU_32B;
6213 #if defined(CONFIG_SOFTMMU)
6214     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6215 #endif
6216     pcc->excp_model = POWERPC_EXCP_7x0;
6217     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6218     pcc->bfd_mach = bfd_mach_ppc_750;
6219     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6220                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6221 }
6222
6223 static void init_proc_750gx (CPUPPCState *env)
6224 {
6225     gen_spr_ne_601(env);
6226     gen_spr_7xx(env);
6227     /* XXX : not implemented (XXX: different from 750fx) */
6228     spr_register(env, SPR_L2CR, "L2CR",
6229                  SPR_NOACCESS, SPR_NOACCESS,
6230                  &spr_read_generic, spr_access_nop,
6231                  0x00000000);
6232     /* Time base */
6233     gen_tbl(env);
6234     /* Thermal management */
6235     gen_spr_thrm(env);
6236     /* XXX : not implemented */
6237     spr_register(env, SPR_750_THRM4, "THRM4",
6238                  SPR_NOACCESS, SPR_NOACCESS,
6239                  &spr_read_generic, &spr_write_generic,
6240                  0x00000000);
6241     /* Hardware implementation registers */
6242     /* XXX : not implemented (XXX: different from 750fx) */
6243     spr_register(env, SPR_HID0, "HID0",
6244                  SPR_NOACCESS, SPR_NOACCESS,
6245                  &spr_read_generic, &spr_write_generic,
6246                  0x00000000);
6247     /* XXX : not implemented */
6248     spr_register(env, SPR_HID1, "HID1",
6249                  SPR_NOACCESS, SPR_NOACCESS,
6250                  &spr_read_generic, &spr_write_generic,
6251                  0x00000000);
6252     /* XXX : not implemented (XXX: different from 750fx) */
6253     spr_register(env, SPR_750FX_HID2, "HID2",
6254                  SPR_NOACCESS, SPR_NOACCESS,
6255                  &spr_read_generic, &spr_write_generic,
6256                  0x00000000);
6257     /* Memory management */
6258     gen_low_BATs(env);
6259     /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
6260     gen_high_BATs(env);
6261     init_excp_7x0(env);
6262     env->dcache_line_size = 32;
6263     env->icache_line_size = 32;
6264     /* Allocate hardware IRQ controller */
6265     ppc6xx_irq_init(ppc_env_get_cpu(env));
6266 }
6267
6268 POWERPC_FAMILY(750gx)(ObjectClass *oc, void *data)
6269 {
6270     DeviceClass *dc = DEVICE_CLASS(oc);
6271     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6272
6273     dc->desc = "PowerPC 750GX";
6274     pcc->init_proc = init_proc_750gx;
6275     pcc->check_pow = check_pow_hid0;
6276     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6277                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6278                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6279                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6280                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6281                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6282                        PPC_SEGMENT | PPC_EXTERN;
6283     pcc->msr_mask = (1ull << MSR_POW) |
6284                     (1ull << MSR_ILE) |
6285                     (1ull << MSR_EE) |
6286                     (1ull << MSR_PR) |
6287                     (1ull << MSR_FP) |
6288                     (1ull << MSR_ME) |
6289                     (1ull << MSR_FE0) |
6290                     (1ull << MSR_SE) |
6291                     (1ull << MSR_DE) |
6292                     (1ull << MSR_FE1) |
6293                     (1ull << MSR_EP) |
6294                     (1ull << MSR_IR) |
6295                     (1ull << MSR_DR) |
6296                     (1ull << MSR_PMM) |
6297                     (1ull << MSR_RI) |
6298                     (1ull << MSR_LE);
6299     pcc->mmu_model = POWERPC_MMU_32B;
6300 #if defined(CONFIG_SOFTMMU)
6301     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6302 #endif
6303     pcc->excp_model = POWERPC_EXCP_7x0;
6304     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6305     pcc->bfd_mach = bfd_mach_ppc_750;
6306     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6307                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6308 }
6309
6310 static void init_proc_745 (CPUPPCState *env)
6311 {
6312     gen_spr_ne_601(env);
6313     gen_spr_7xx(env);
6314     gen_spr_G2_755(env);
6315     /* Time base */
6316     gen_tbl(env);
6317     /* Thermal management */
6318     gen_spr_thrm(env);
6319     /* Hardware implementation registers */
6320     /* XXX : not implemented */
6321     spr_register(env, SPR_HID0, "HID0",
6322                  SPR_NOACCESS, SPR_NOACCESS,
6323                  &spr_read_generic, &spr_write_generic,
6324                  0x00000000);
6325     /* XXX : not implemented */
6326     spr_register(env, SPR_HID1, "HID1",
6327                  SPR_NOACCESS, SPR_NOACCESS,
6328                  &spr_read_generic, &spr_write_generic,
6329                  0x00000000);
6330     /* XXX : not implemented */
6331     spr_register(env, SPR_HID2, "HID2",
6332                  SPR_NOACCESS, SPR_NOACCESS,
6333                  &spr_read_generic, &spr_write_generic,
6334                  0x00000000);
6335     /* Memory management */
6336     gen_low_BATs(env);
6337     gen_high_BATs(env);
6338     gen_6xx_7xx_soft_tlb(env, 64, 2);
6339     init_excp_7x5(env);
6340     env->dcache_line_size = 32;
6341     env->icache_line_size = 32;
6342     /* Allocate hardware IRQ controller */
6343     ppc6xx_irq_init(ppc_env_get_cpu(env));
6344 }
6345
6346 POWERPC_FAMILY(745)(ObjectClass *oc, void *data)
6347 {
6348     DeviceClass *dc = DEVICE_CLASS(oc);
6349     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6350
6351     dc->desc = "PowerPC 745";
6352     pcc->init_proc = init_proc_745;
6353     pcc->check_pow = check_pow_hid0;
6354     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6355                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6356                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6357                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6358                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6359                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
6360                        PPC_SEGMENT | PPC_EXTERN;
6361     pcc->msr_mask = (1ull << MSR_POW) |
6362                     (1ull << MSR_ILE) |
6363                     (1ull << MSR_EE) |
6364                     (1ull << MSR_PR) |
6365                     (1ull << MSR_FP) |
6366                     (1ull << MSR_ME) |
6367                     (1ull << MSR_FE0) |
6368                     (1ull << MSR_SE) |
6369                     (1ull << MSR_DE) |
6370                     (1ull << MSR_FE1) |
6371                     (1ull << MSR_EP) |
6372                     (1ull << MSR_IR) |
6373                     (1ull << MSR_DR) |
6374                     (1ull << MSR_PMM) |
6375                     (1ull << MSR_RI) |
6376                     (1ull << MSR_LE);
6377     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
6378     pcc->excp_model = POWERPC_EXCP_7x5;
6379     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6380     pcc->bfd_mach = bfd_mach_ppc_750;
6381     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6382                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6383 }
6384
6385 static void init_proc_755 (CPUPPCState *env)
6386 {
6387     gen_spr_ne_601(env);
6388     gen_spr_7xx(env);
6389     gen_spr_G2_755(env);
6390     /* Time base */
6391     gen_tbl(env);
6392     /* L2 cache control */
6393     /* XXX : not implemented */
6394     spr_register(env, SPR_L2CR, "L2CR",
6395                  SPR_NOACCESS, SPR_NOACCESS,
6396                  &spr_read_generic, spr_access_nop,
6397                  0x00000000);
6398     /* XXX : not implemented */
6399     spr_register(env, SPR_L2PMCR, "L2PMCR",
6400                  SPR_NOACCESS, SPR_NOACCESS,
6401                  &spr_read_generic, &spr_write_generic,
6402                  0x00000000);
6403     /* Thermal management */
6404     gen_spr_thrm(env);
6405     /* Hardware implementation registers */
6406     /* XXX : not implemented */
6407     spr_register(env, SPR_HID0, "HID0",
6408                  SPR_NOACCESS, SPR_NOACCESS,
6409                  &spr_read_generic, &spr_write_generic,
6410                  0x00000000);
6411     /* XXX : not implemented */
6412     spr_register(env, SPR_HID1, "HID1",
6413                  SPR_NOACCESS, SPR_NOACCESS,
6414                  &spr_read_generic, &spr_write_generic,
6415                  0x00000000);
6416     /* XXX : not implemented */
6417     spr_register(env, SPR_HID2, "HID2",
6418                  SPR_NOACCESS, SPR_NOACCESS,
6419                  &spr_read_generic, &spr_write_generic,
6420                  0x00000000);
6421     /* Memory management */
6422     gen_low_BATs(env);
6423     gen_high_BATs(env);
6424     gen_6xx_7xx_soft_tlb(env, 64, 2);
6425     init_excp_7x5(env);
6426     env->dcache_line_size = 32;
6427     env->icache_line_size = 32;
6428     /* Allocate hardware IRQ controller */
6429     ppc6xx_irq_init(ppc_env_get_cpu(env));
6430 }
6431
6432 POWERPC_FAMILY(755)(ObjectClass *oc, void *data)
6433 {
6434     DeviceClass *dc = DEVICE_CLASS(oc);
6435     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6436
6437     dc->desc = "PowerPC 755";
6438     pcc->init_proc = init_proc_755;
6439     pcc->check_pow = check_pow_hid0;
6440     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6441                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6442                        PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
6443                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6444                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6445                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
6446                        PPC_SEGMENT | PPC_EXTERN;
6447     pcc->msr_mask = (1ull << MSR_POW) |
6448                     (1ull << MSR_ILE) |
6449                     (1ull << MSR_EE) |
6450                     (1ull << MSR_PR) |
6451                     (1ull << MSR_FP) |
6452                     (1ull << MSR_ME) |
6453                     (1ull << MSR_FE0) |
6454                     (1ull << MSR_SE) |
6455                     (1ull << MSR_DE) |
6456                     (1ull << MSR_FE1) |
6457                     (1ull << MSR_EP) |
6458                     (1ull << MSR_IR) |
6459                     (1ull << MSR_DR) |
6460                     (1ull << MSR_PMM) |
6461                     (1ull << MSR_RI) |
6462                     (1ull << MSR_LE);
6463     pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
6464     pcc->excp_model = POWERPC_EXCP_7x5;
6465     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6466     pcc->bfd_mach = bfd_mach_ppc_750;
6467     pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
6468                  POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
6469 }
6470
6471 static void init_proc_7400 (CPUPPCState *env)
6472 {
6473     gen_spr_ne_601(env);
6474     gen_spr_7xx(env);
6475     /* Time base */
6476     gen_tbl(env);
6477     /* 74xx specific SPR */
6478     gen_spr_74xx(env);
6479     /* XXX : not implemented */
6480     spr_register(env, SPR_UBAMR, "UBAMR",
6481                  &spr_read_ureg, SPR_NOACCESS,
6482                  &spr_read_ureg, SPR_NOACCESS,
6483                  0x00000000);
6484     /* XXX: this seems not implemented on all revisions. */
6485     /* XXX : not implemented */
6486     spr_register(env, SPR_MSSCR1, "MSSCR1",
6487                  SPR_NOACCESS, SPR_NOACCESS,
6488                  &spr_read_generic, &spr_write_generic,
6489                  0x00000000);
6490     /* Thermal management */
6491     gen_spr_thrm(env);
6492     /* Memory management */
6493     gen_low_BATs(env);
6494     init_excp_7400(env);
6495     env->dcache_line_size = 32;
6496     env->icache_line_size = 32;
6497     /* Allocate hardware IRQ controller */
6498     ppc6xx_irq_init(ppc_env_get_cpu(env));
6499 }
6500
6501 POWERPC_FAMILY(7400)(ObjectClass *oc, void *data)
6502 {
6503     DeviceClass *dc = DEVICE_CLASS(oc);
6504     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6505
6506     dc->desc = "PowerPC 7400 (aka G4)";
6507     pcc->init_proc = init_proc_7400;
6508     pcc->check_pow = check_pow_hid0;
6509     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6510                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6511                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6512                        PPC_FLOAT_STFIWX |
6513                        PPC_CACHE | PPC_CACHE_ICBI |
6514                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6515                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6516                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6517                        PPC_MEM_TLBIA |
6518                        PPC_SEGMENT | PPC_EXTERN |
6519                        PPC_ALTIVEC;
6520     pcc->msr_mask = (1ull << MSR_VR) |
6521                     (1ull << MSR_POW) |
6522                     (1ull << MSR_ILE) |
6523                     (1ull << MSR_EE) |
6524                     (1ull << MSR_PR) |
6525                     (1ull << MSR_FP) |
6526                     (1ull << MSR_ME) |
6527                     (1ull << MSR_FE0) |
6528                     (1ull << MSR_SE) |
6529                     (1ull << MSR_DE) |
6530                     (1ull << MSR_FE1) |
6531                     (1ull << MSR_EP) |
6532                     (1ull << MSR_IR) |
6533                     (1ull << MSR_DR) |
6534                     (1ull << MSR_PMM) |
6535                     (1ull << MSR_RI) |
6536                     (1ull << MSR_LE);
6537     pcc->mmu_model = POWERPC_MMU_32B;
6538 #if defined(CONFIG_SOFTMMU)
6539     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6540 #endif
6541     pcc->excp_model = POWERPC_EXCP_74xx;
6542     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6543     pcc->bfd_mach = bfd_mach_ppc_7400;
6544     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6545                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6546                  POWERPC_FLAG_BUS_CLK;
6547 }
6548
6549 static void init_proc_7410 (CPUPPCState *env)
6550 {
6551     gen_spr_ne_601(env);
6552     gen_spr_7xx(env);
6553     /* Time base */
6554     gen_tbl(env);
6555     /* 74xx specific SPR */
6556     gen_spr_74xx(env);
6557     /* XXX : not implemented */
6558     spr_register(env, SPR_UBAMR, "UBAMR",
6559                  &spr_read_ureg, SPR_NOACCESS,
6560                  &spr_read_ureg, SPR_NOACCESS,
6561                  0x00000000);
6562     /* Thermal management */
6563     gen_spr_thrm(env);
6564     /* L2PMCR */
6565     /* XXX : not implemented */
6566     spr_register(env, SPR_L2PMCR, "L2PMCR",
6567                  SPR_NOACCESS, SPR_NOACCESS,
6568                  &spr_read_generic, &spr_write_generic,
6569                  0x00000000);
6570     /* LDSTDB */
6571     /* XXX : not implemented */
6572     spr_register(env, SPR_LDSTDB, "LDSTDB",
6573                  SPR_NOACCESS, SPR_NOACCESS,
6574                  &spr_read_generic, &spr_write_generic,
6575                  0x00000000);
6576     /* Memory management */
6577     gen_low_BATs(env);
6578     init_excp_7400(env);
6579     env->dcache_line_size = 32;
6580     env->icache_line_size = 32;
6581     /* Allocate hardware IRQ controller */
6582     ppc6xx_irq_init(ppc_env_get_cpu(env));
6583 }
6584
6585 POWERPC_FAMILY(7410)(ObjectClass *oc, void *data)
6586 {
6587     DeviceClass *dc = DEVICE_CLASS(oc);
6588     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6589
6590     dc->desc = "PowerPC 7410 (aka G4)";
6591     pcc->init_proc = init_proc_7410;
6592     pcc->check_pow = check_pow_hid0;
6593     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6594                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6595                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6596                        PPC_FLOAT_STFIWX |
6597                        PPC_CACHE | PPC_CACHE_ICBI |
6598                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6599                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6600                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6601                        PPC_MEM_TLBIA |
6602                        PPC_SEGMENT | PPC_EXTERN |
6603                        PPC_ALTIVEC;
6604     pcc->msr_mask = (1ull << MSR_VR) |
6605                     (1ull << MSR_POW) |
6606                     (1ull << MSR_ILE) |
6607                     (1ull << MSR_EE) |
6608                     (1ull << MSR_PR) |
6609                     (1ull << MSR_FP) |
6610                     (1ull << MSR_ME) |
6611                     (1ull << MSR_FE0) |
6612                     (1ull << MSR_SE) |
6613                     (1ull << MSR_DE) |
6614                     (1ull << MSR_FE1) |
6615                     (1ull << MSR_EP) |
6616                     (1ull << MSR_IR) |
6617                     (1ull << MSR_DR) |
6618                     (1ull << MSR_PMM) |
6619                     (1ull << MSR_RI) |
6620                     (1ull << MSR_LE);
6621     pcc->mmu_model = POWERPC_MMU_32B;
6622 #if defined(CONFIG_SOFTMMU)
6623     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
6624 #endif
6625     pcc->excp_model = POWERPC_EXCP_74xx;
6626     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6627     pcc->bfd_mach = bfd_mach_ppc_7400;
6628     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6629                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6630                  POWERPC_FLAG_BUS_CLK;
6631 }
6632
6633 static void init_proc_7440 (CPUPPCState *env)
6634 {
6635     gen_spr_ne_601(env);
6636     gen_spr_7xx(env);
6637     /* Time base */
6638     gen_tbl(env);
6639     /* 74xx specific SPR */
6640     gen_spr_74xx(env);
6641     /* XXX : not implemented */
6642     spr_register(env, SPR_UBAMR, "UBAMR",
6643                  &spr_read_ureg, SPR_NOACCESS,
6644                  &spr_read_ureg, SPR_NOACCESS,
6645                  0x00000000);
6646     /* LDSTCR */
6647     /* XXX : not implemented */
6648     spr_register(env, SPR_LDSTCR, "LDSTCR",
6649                  SPR_NOACCESS, SPR_NOACCESS,
6650                  &spr_read_generic, &spr_write_generic,
6651                  0x00000000);
6652     /* ICTRL */
6653     /* XXX : not implemented */
6654     spr_register(env, SPR_ICTRL, "ICTRL",
6655                  SPR_NOACCESS, SPR_NOACCESS,
6656                  &spr_read_generic, &spr_write_generic,
6657                  0x00000000);
6658     /* MSSSR0 */
6659     /* XXX : not implemented */
6660     spr_register(env, SPR_MSSSR0, "MSSSR0",
6661                  SPR_NOACCESS, SPR_NOACCESS,
6662                  &spr_read_generic, &spr_write_generic,
6663                  0x00000000);
6664     /* PMC */
6665     /* XXX : not implemented */
6666     spr_register(env, SPR_7XX_PMC5, "PMC5",
6667                  SPR_NOACCESS, SPR_NOACCESS,
6668                  &spr_read_generic, &spr_write_generic,
6669                  0x00000000);
6670     /* XXX : not implemented */
6671     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
6672                  &spr_read_ureg, SPR_NOACCESS,
6673                  &spr_read_ureg, SPR_NOACCESS,
6674                  0x00000000);
6675     /* XXX : not implemented */
6676     spr_register(env, SPR_7XX_PMC6, "PMC6",
6677                  SPR_NOACCESS, SPR_NOACCESS,
6678                  &spr_read_generic, &spr_write_generic,
6679                  0x00000000);
6680     /* XXX : not implemented */
6681     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
6682                  &spr_read_ureg, SPR_NOACCESS,
6683                  &spr_read_ureg, SPR_NOACCESS,
6684                  0x00000000);
6685     /* Memory management */
6686     gen_low_BATs(env);
6687     gen_74xx_soft_tlb(env, 128, 2);
6688     init_excp_7450(env);
6689     env->dcache_line_size = 32;
6690     env->icache_line_size = 32;
6691     /* Allocate hardware IRQ controller */
6692     ppc6xx_irq_init(ppc_env_get_cpu(env));
6693 }
6694
6695 POWERPC_FAMILY(7440)(ObjectClass *oc, void *data)
6696 {
6697     DeviceClass *dc = DEVICE_CLASS(oc);
6698     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6699
6700     dc->desc = "PowerPC 7440 (aka G4)";
6701     pcc->init_proc = init_proc_7440;
6702     pcc->check_pow = check_pow_hid0_74xx;
6703     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6704                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6705                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6706                        PPC_FLOAT_STFIWX |
6707                        PPC_CACHE | PPC_CACHE_ICBI |
6708                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6709                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6710                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6711                        PPC_MEM_TLBIA | PPC_74xx_TLB |
6712                        PPC_SEGMENT | PPC_EXTERN |
6713                        PPC_ALTIVEC;
6714     pcc->msr_mask = (1ull << MSR_VR) |
6715                     (1ull << MSR_POW) |
6716                     (1ull << MSR_ILE) |
6717                     (1ull << MSR_EE) |
6718                     (1ull << MSR_PR) |
6719                     (1ull << MSR_FP) |
6720                     (1ull << MSR_ME) |
6721                     (1ull << MSR_FE0) |
6722                     (1ull << MSR_SE) |
6723                     (1ull << MSR_DE) |
6724                     (1ull << MSR_FE1) |
6725                     (1ull << MSR_EP) |
6726                     (1ull << MSR_IR) |
6727                     (1ull << MSR_DR) |
6728                     (1ull << MSR_PMM) |
6729                     (1ull << MSR_RI) |
6730                     (1ull << MSR_LE);
6731     pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6732     pcc->excp_model = POWERPC_EXCP_74xx;
6733     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6734     pcc->bfd_mach = bfd_mach_ppc_7400;
6735     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6736                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6737                  POWERPC_FLAG_BUS_CLK;
6738 }
6739
6740 static void init_proc_7450 (CPUPPCState *env)
6741 {
6742     gen_spr_ne_601(env);
6743     gen_spr_7xx(env);
6744     /* Time base */
6745     gen_tbl(env);
6746     /* 74xx specific SPR */
6747     gen_spr_74xx(env);
6748     /* Level 3 cache control */
6749     gen_l3_ctrl(env);
6750     /* L3ITCR1 */
6751     /* XXX : not implemented */
6752     spr_register(env, SPR_L3ITCR1, "L3ITCR1",
6753                  SPR_NOACCESS, SPR_NOACCESS,
6754                  &spr_read_generic, &spr_write_generic,
6755                  0x00000000);
6756     /* L3ITCR2 */
6757     /* XXX : not implemented */
6758     spr_register(env, SPR_L3ITCR2, "L3ITCR2",
6759                  SPR_NOACCESS, SPR_NOACCESS,
6760                  &spr_read_generic, &spr_write_generic,
6761                  0x00000000);
6762     /* L3ITCR3 */
6763     /* XXX : not implemented */
6764     spr_register(env, SPR_L3ITCR3, "L3ITCR3",
6765                  SPR_NOACCESS, SPR_NOACCESS,
6766                  &spr_read_generic, &spr_write_generic,
6767                  0x00000000);
6768     /* L3OHCR */
6769     /* XXX : not implemented */
6770     spr_register(env, SPR_L3OHCR, "L3OHCR",
6771                  SPR_NOACCESS, SPR_NOACCESS,
6772                  &spr_read_generic, &spr_write_generic,
6773                  0x00000000);
6774     /* XXX : not implemented */
6775     spr_register(env, SPR_UBAMR, "UBAMR",
6776                  &spr_read_ureg, SPR_NOACCESS,
6777                  &spr_read_ureg, SPR_NOACCESS,
6778                  0x00000000);
6779     /* LDSTCR */
6780     /* XXX : not implemented */
6781     spr_register(env, SPR_LDSTCR, "LDSTCR",
6782                  SPR_NOACCESS, SPR_NOACCESS,
6783                  &spr_read_generic, &spr_write_generic,
6784                  0x00000000);
6785     /* ICTRL */
6786     /* XXX : not implemented */
6787     spr_register(env, SPR_ICTRL, "ICTRL",
6788                  SPR_NOACCESS, SPR_NOACCESS,
6789                  &spr_read_generic, &spr_write_generic,
6790                  0x00000000);
6791     /* MSSSR0 */
6792     /* XXX : not implemented */
6793     spr_register(env, SPR_MSSSR0, "MSSSR0",
6794                  SPR_NOACCESS, SPR_NOACCESS,
6795                  &spr_read_generic, &spr_write_generic,
6796                  0x00000000);
6797     /* PMC */
6798     /* XXX : not implemented */
6799     spr_register(env, SPR_7XX_PMC5, "PMC5",
6800                  SPR_NOACCESS, SPR_NOACCESS,
6801                  &spr_read_generic, &spr_write_generic,
6802                  0x00000000);
6803     /* XXX : not implemented */
6804     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
6805                  &spr_read_ureg, SPR_NOACCESS,
6806                  &spr_read_ureg, SPR_NOACCESS,
6807                  0x00000000);
6808     /* XXX : not implemented */
6809     spr_register(env, SPR_7XX_PMC6, "PMC6",
6810                  SPR_NOACCESS, SPR_NOACCESS,
6811                  &spr_read_generic, &spr_write_generic,
6812                  0x00000000);
6813     /* XXX : not implemented */
6814     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
6815                  &spr_read_ureg, SPR_NOACCESS,
6816                  &spr_read_ureg, SPR_NOACCESS,
6817                  0x00000000);
6818     /* Memory management */
6819     gen_low_BATs(env);
6820     gen_74xx_soft_tlb(env, 128, 2);
6821     init_excp_7450(env);
6822     env->dcache_line_size = 32;
6823     env->icache_line_size = 32;
6824     /* Allocate hardware IRQ controller */
6825     ppc6xx_irq_init(ppc_env_get_cpu(env));
6826 }
6827
6828 POWERPC_FAMILY(7450)(ObjectClass *oc, void *data)
6829 {
6830     DeviceClass *dc = DEVICE_CLASS(oc);
6831     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6832
6833     dc->desc = "PowerPC 7450 (aka G4)";
6834     pcc->init_proc = init_proc_7450;
6835     pcc->check_pow = check_pow_hid0_74xx;
6836     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6837                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6838                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6839                        PPC_FLOAT_STFIWX |
6840                        PPC_CACHE | PPC_CACHE_ICBI |
6841                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6842                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6843                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6844                        PPC_MEM_TLBIA | PPC_74xx_TLB |
6845                        PPC_SEGMENT | PPC_EXTERN |
6846                        PPC_ALTIVEC;
6847     pcc->msr_mask = (1ull << MSR_VR) |
6848                     (1ull << MSR_POW) |
6849                     (1ull << MSR_ILE) |
6850                     (1ull << MSR_EE) |
6851                     (1ull << MSR_PR) |
6852                     (1ull << MSR_FP) |
6853                     (1ull << MSR_ME) |
6854                     (1ull << MSR_FE0) |
6855                     (1ull << MSR_SE) |
6856                     (1ull << MSR_DE) |
6857                     (1ull << MSR_FE1) |
6858                     (1ull << MSR_EP) |
6859                     (1ull << MSR_IR) |
6860                     (1ull << MSR_DR) |
6861                     (1ull << MSR_PMM) |
6862                     (1ull << MSR_RI) |
6863                     (1ull << MSR_LE);
6864     pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6865     pcc->excp_model = POWERPC_EXCP_74xx;
6866     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6867     pcc->bfd_mach = bfd_mach_ppc_7400;
6868     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6869                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6870                  POWERPC_FLAG_BUS_CLK;
6871 }
6872
6873 static void init_proc_7445 (CPUPPCState *env)
6874 {
6875     gen_spr_ne_601(env);
6876     gen_spr_7xx(env);
6877     /* Time base */
6878     gen_tbl(env);
6879     /* 74xx specific SPR */
6880     gen_spr_74xx(env);
6881     /* LDSTCR */
6882     /* XXX : not implemented */
6883     spr_register(env, SPR_LDSTCR, "LDSTCR",
6884                  SPR_NOACCESS, SPR_NOACCESS,
6885                  &spr_read_generic, &spr_write_generic,
6886                  0x00000000);
6887     /* ICTRL */
6888     /* XXX : not implemented */
6889     spr_register(env, SPR_ICTRL, "ICTRL",
6890                  SPR_NOACCESS, SPR_NOACCESS,
6891                  &spr_read_generic, &spr_write_generic,
6892                  0x00000000);
6893     /* MSSSR0 */
6894     /* XXX : not implemented */
6895     spr_register(env, SPR_MSSSR0, "MSSSR0",
6896                  SPR_NOACCESS, SPR_NOACCESS,
6897                  &spr_read_generic, &spr_write_generic,
6898                  0x00000000);
6899     /* PMC */
6900     /* XXX : not implemented */
6901     spr_register(env, SPR_7XX_PMC5, "PMC5",
6902                  SPR_NOACCESS, SPR_NOACCESS,
6903                  &spr_read_generic, &spr_write_generic,
6904                  0x00000000);
6905     /* XXX : not implemented */
6906     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
6907                  &spr_read_ureg, SPR_NOACCESS,
6908                  &spr_read_ureg, SPR_NOACCESS,
6909                  0x00000000);
6910     /* XXX : not implemented */
6911     spr_register(env, SPR_7XX_PMC6, "PMC6",
6912                  SPR_NOACCESS, SPR_NOACCESS,
6913                  &spr_read_generic, &spr_write_generic,
6914                  0x00000000);
6915     /* XXX : not implemented */
6916     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
6917                  &spr_read_ureg, SPR_NOACCESS,
6918                  &spr_read_ureg, SPR_NOACCESS,
6919                  0x00000000);
6920     /* SPRGs */
6921     spr_register(env, SPR_SPRG4, "SPRG4",
6922                  SPR_NOACCESS, SPR_NOACCESS,
6923                  &spr_read_generic, &spr_write_generic,
6924                  0x00000000);
6925     spr_register(env, SPR_USPRG4, "USPRG4",
6926                  &spr_read_ureg, SPR_NOACCESS,
6927                  &spr_read_ureg, SPR_NOACCESS,
6928                  0x00000000);
6929     spr_register(env, SPR_SPRG5, "SPRG5",
6930                  SPR_NOACCESS, SPR_NOACCESS,
6931                  &spr_read_generic, &spr_write_generic,
6932                  0x00000000);
6933     spr_register(env, SPR_USPRG5, "USPRG5",
6934                  &spr_read_ureg, SPR_NOACCESS,
6935                  &spr_read_ureg, SPR_NOACCESS,
6936                  0x00000000);
6937     spr_register(env, SPR_SPRG6, "SPRG6",
6938                  SPR_NOACCESS, SPR_NOACCESS,
6939                  &spr_read_generic, &spr_write_generic,
6940                  0x00000000);
6941     spr_register(env, SPR_USPRG6, "USPRG6",
6942                  &spr_read_ureg, SPR_NOACCESS,
6943                  &spr_read_ureg, SPR_NOACCESS,
6944                  0x00000000);
6945     spr_register(env, SPR_SPRG7, "SPRG7",
6946                  SPR_NOACCESS, SPR_NOACCESS,
6947                  &spr_read_generic, &spr_write_generic,
6948                  0x00000000);
6949     spr_register(env, SPR_USPRG7, "USPRG7",
6950                  &spr_read_ureg, SPR_NOACCESS,
6951                  &spr_read_ureg, SPR_NOACCESS,
6952                  0x00000000);
6953     /* Memory management */
6954     gen_low_BATs(env);
6955     gen_high_BATs(env);
6956     gen_74xx_soft_tlb(env, 128, 2);
6957     init_excp_7450(env);
6958     env->dcache_line_size = 32;
6959     env->icache_line_size = 32;
6960     /* Allocate hardware IRQ controller */
6961     ppc6xx_irq_init(ppc_env_get_cpu(env));
6962 }
6963
6964 POWERPC_FAMILY(7445)(ObjectClass *oc, void *data)
6965 {
6966     DeviceClass *dc = DEVICE_CLASS(oc);
6967     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6968
6969     dc->desc = "PowerPC 7445 (aka G4)";
6970     pcc->init_proc = init_proc_7445;
6971     pcc->check_pow = check_pow_hid0_74xx;
6972     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6973                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6974                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6975                        PPC_FLOAT_STFIWX |
6976                        PPC_CACHE | PPC_CACHE_ICBI |
6977                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6978                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
6979                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6980                        PPC_MEM_TLBIA | PPC_74xx_TLB |
6981                        PPC_SEGMENT | PPC_EXTERN |
6982                        PPC_ALTIVEC;
6983     pcc->msr_mask = (1ull << MSR_VR) |
6984                     (1ull << MSR_POW) |
6985                     (1ull << MSR_ILE) |
6986                     (1ull << MSR_EE) |
6987                     (1ull << MSR_PR) |
6988                     (1ull << MSR_FP) |
6989                     (1ull << MSR_ME) |
6990                     (1ull << MSR_FE0) |
6991                     (1ull << MSR_SE) |
6992                     (1ull << MSR_DE) |
6993                     (1ull << MSR_FE1) |
6994                     (1ull << MSR_EP) |
6995                     (1ull << MSR_IR) |
6996                     (1ull << MSR_DR) |
6997                     (1ull << MSR_PMM) |
6998                     (1ull << MSR_RI) |
6999                     (1ull << MSR_LE);
7000     pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
7001     pcc->excp_model = POWERPC_EXCP_74xx;
7002     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
7003     pcc->bfd_mach = bfd_mach_ppc_7400;
7004     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7005                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7006                  POWERPC_FLAG_BUS_CLK;
7007 }
7008
7009 static void init_proc_7455 (CPUPPCState *env)
7010 {
7011     gen_spr_ne_601(env);
7012     gen_spr_7xx(env);
7013     /* Time base */
7014     gen_tbl(env);
7015     /* 74xx specific SPR */
7016     gen_spr_74xx(env);
7017     /* Level 3 cache control */
7018     gen_l3_ctrl(env);
7019     /* LDSTCR */
7020     /* XXX : not implemented */
7021     spr_register(env, SPR_LDSTCR, "LDSTCR",
7022                  SPR_NOACCESS, SPR_NOACCESS,
7023                  &spr_read_generic, &spr_write_generic,
7024                  0x00000000);
7025     /* ICTRL */
7026     /* XXX : not implemented */
7027     spr_register(env, SPR_ICTRL, "ICTRL",
7028                  SPR_NOACCESS, SPR_NOACCESS,
7029                  &spr_read_generic, &spr_write_generic,
7030                  0x00000000);
7031     /* MSSSR0 */
7032     /* XXX : not implemented */
7033     spr_register(env, SPR_MSSSR0, "MSSSR0",
7034                  SPR_NOACCESS, SPR_NOACCESS,
7035                  &spr_read_generic, &spr_write_generic,
7036                  0x00000000);
7037     /* PMC */
7038     /* XXX : not implemented */
7039     spr_register(env, SPR_7XX_PMC5, "PMC5",
7040                  SPR_NOACCESS, SPR_NOACCESS,
7041                  &spr_read_generic, &spr_write_generic,
7042                  0x00000000);
7043     /* XXX : not implemented */
7044     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
7045                  &spr_read_ureg, SPR_NOACCESS,
7046                  &spr_read_ureg, SPR_NOACCESS,
7047                  0x00000000);
7048     /* XXX : not implemented */
7049     spr_register(env, SPR_7XX_PMC6, "PMC6",
7050                  SPR_NOACCESS, SPR_NOACCESS,
7051                  &spr_read_generic, &spr_write_generic,
7052                  0x00000000);
7053     /* XXX : not implemented */
7054     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
7055                  &spr_read_ureg, SPR_NOACCESS,
7056                  &spr_read_ureg, SPR_NOACCESS,
7057                  0x00000000);
7058     /* SPRGs */
7059     spr_register(env, SPR_SPRG4, "SPRG4",
7060                  SPR_NOACCESS, SPR_NOACCESS,
7061                  &spr_read_generic, &spr_write_generic,
7062                  0x00000000);
7063     spr_register(env, SPR_USPRG4, "USPRG4",
7064                  &spr_read_ureg, SPR_NOACCESS,
7065                  &spr_read_ureg, SPR_NOACCESS,
7066                  0x00000000);
7067     spr_register(env, SPR_SPRG5, "SPRG5",
7068                  SPR_NOACCESS, SPR_NOACCESS,
7069                  &spr_read_generic, &spr_write_generic,
7070                  0x00000000);
7071     spr_register(env, SPR_USPRG5, "USPRG5",
7072                  &spr_read_ureg, SPR_NOACCESS,
7073                  &spr_read_ureg, SPR_NOACCESS,
7074                  0x00000000);
7075     spr_register(env, SPR_SPRG6, "SPRG6",
7076                  SPR_NOACCESS, SPR_NOACCESS,
7077                  &spr_read_generic, &spr_write_generic,
7078                  0x00000000);
7079     spr_register(env, SPR_USPRG6, "USPRG6",
7080                  &spr_read_ureg, SPR_NOACCESS,
7081                  &spr_read_ureg, SPR_NOACCESS,
7082                  0x00000000);
7083     spr_register(env, SPR_SPRG7, "SPRG7",
7084                  SPR_NOACCESS, SPR_NOACCESS,
7085                  &spr_read_generic, &spr_write_generic,
7086                  0x00000000);
7087     spr_register(env, SPR_USPRG7, "USPRG7",
7088                  &spr_read_ureg, SPR_NOACCESS,
7089                  &spr_read_ureg, SPR_NOACCESS,
7090                  0x00000000);
7091     /* Memory management */
7092     gen_low_BATs(env);
7093     gen_high_BATs(env);
7094     gen_74xx_soft_tlb(env, 128, 2);
7095     init_excp_7450(env);
7096     env->dcache_line_size = 32;
7097     env->icache_line_size = 32;
7098     /* Allocate hardware IRQ controller */
7099     ppc6xx_irq_init(ppc_env_get_cpu(env));
7100 }
7101
7102 POWERPC_FAMILY(7455)(ObjectClass *oc, void *data)
7103 {
7104     DeviceClass *dc = DEVICE_CLASS(oc);
7105     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7106
7107     dc->desc = "PowerPC 7455 (aka G4)";
7108     pcc->init_proc = init_proc_7455;
7109     pcc->check_pow = check_pow_hid0_74xx;
7110     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7111                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7112                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7113                        PPC_FLOAT_STFIWX |
7114                        PPC_CACHE | PPC_CACHE_ICBI |
7115                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
7116                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
7117                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7118                        PPC_MEM_TLBIA | PPC_74xx_TLB |
7119                        PPC_SEGMENT | PPC_EXTERN |
7120                        PPC_ALTIVEC;
7121     pcc->msr_mask = (1ull << MSR_VR) |
7122                     (1ull << MSR_POW) |
7123                     (1ull << MSR_ILE) |
7124                     (1ull << MSR_EE) |
7125                     (1ull << MSR_PR) |
7126                     (1ull << MSR_FP) |
7127                     (1ull << MSR_ME) |
7128                     (1ull << MSR_FE0) |
7129                     (1ull << MSR_SE) |
7130                     (1ull << MSR_DE) |
7131                     (1ull << MSR_FE1) |
7132                     (1ull << MSR_EP) |
7133                     (1ull << MSR_IR) |
7134                     (1ull << MSR_DR) |
7135                     (1ull << MSR_PMM) |
7136                     (1ull << MSR_RI) |
7137                     (1ull << MSR_LE);
7138     pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
7139     pcc->excp_model = POWERPC_EXCP_74xx;
7140     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
7141     pcc->bfd_mach = bfd_mach_ppc_7400;
7142     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7143                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7144                  POWERPC_FLAG_BUS_CLK;
7145 }
7146
7147 static void init_proc_7457 (CPUPPCState *env)
7148 {
7149     gen_spr_ne_601(env);
7150     gen_spr_7xx(env);
7151     /* Time base */
7152     gen_tbl(env);
7153     /* 74xx specific SPR */
7154     gen_spr_74xx(env);
7155     /* Level 3 cache control */
7156     gen_l3_ctrl(env);
7157     /* L3ITCR1 */
7158     /* XXX : not implemented */
7159     spr_register(env, SPR_L3ITCR1, "L3ITCR1",
7160                  SPR_NOACCESS, SPR_NOACCESS,
7161                  &spr_read_generic, &spr_write_generic,
7162                  0x00000000);
7163     /* L3ITCR2 */
7164     /* XXX : not implemented */
7165     spr_register(env, SPR_L3ITCR2, "L3ITCR2",
7166                  SPR_NOACCESS, SPR_NOACCESS,
7167                  &spr_read_generic, &spr_write_generic,
7168                  0x00000000);
7169     /* L3ITCR3 */
7170     /* XXX : not implemented */
7171     spr_register(env, SPR_L3ITCR3, "L3ITCR3",
7172                  SPR_NOACCESS, SPR_NOACCESS,
7173                  &spr_read_generic, &spr_write_generic,
7174                  0x00000000);
7175     /* L3OHCR */
7176     /* XXX : not implemented */
7177     spr_register(env, SPR_L3OHCR, "L3OHCR",
7178                  SPR_NOACCESS, SPR_NOACCESS,
7179                  &spr_read_generic, &spr_write_generic,
7180                  0x00000000);
7181     /* LDSTCR */
7182     /* XXX : not implemented */
7183     spr_register(env, SPR_LDSTCR, "LDSTCR",
7184                  SPR_NOACCESS, SPR_NOACCESS,
7185                  &spr_read_generic, &spr_write_generic,
7186                  0x00000000);
7187     /* ICTRL */
7188     /* XXX : not implemented */
7189     spr_register(env, SPR_ICTRL, "ICTRL",
7190                  SPR_NOACCESS, SPR_NOACCESS,
7191                  &spr_read_generic, &spr_write_generic,
7192                  0x00000000);
7193     /* MSSSR0 */
7194     /* XXX : not implemented */
7195     spr_register(env, SPR_MSSSR0, "MSSSR0",
7196                  SPR_NOACCESS, SPR_NOACCESS,
7197                  &spr_read_generic, &spr_write_generic,
7198                  0x00000000);
7199     /* PMC */
7200     /* XXX : not implemented */
7201     spr_register(env, SPR_7XX_PMC5, "PMC5",
7202                  SPR_NOACCESS, SPR_NOACCESS,
7203                  &spr_read_generic, &spr_write_generic,
7204                  0x00000000);
7205     /* XXX : not implemented */
7206     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
7207                  &spr_read_ureg, SPR_NOACCESS,
7208                  &spr_read_ureg, SPR_NOACCESS,
7209                  0x00000000);
7210     /* XXX : not implemented */
7211     spr_register(env, SPR_7XX_PMC6, "PMC6",
7212                  SPR_NOACCESS, SPR_NOACCESS,
7213                  &spr_read_generic, &spr_write_generic,
7214                  0x00000000);
7215     /* XXX : not implemented */
7216     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
7217                  &spr_read_ureg, SPR_NOACCESS,
7218                  &spr_read_ureg, SPR_NOACCESS,
7219                  0x00000000);
7220     /* SPRGs */
7221     spr_register(env, SPR_SPRG4, "SPRG4",
7222                  SPR_NOACCESS, SPR_NOACCESS,
7223                  &spr_read_generic, &spr_write_generic,
7224                  0x00000000);
7225     spr_register(env, SPR_USPRG4, "USPRG4",
7226                  &spr_read_ureg, SPR_NOACCESS,
7227                  &spr_read_ureg, SPR_NOACCESS,
7228                  0x00000000);
7229     spr_register(env, SPR_SPRG5, "SPRG5",
7230                  SPR_NOACCESS, SPR_NOACCESS,
7231                  &spr_read_generic, &spr_write_generic,
7232                  0x00000000);
7233     spr_register(env, SPR_USPRG5, "USPRG5",
7234                  &spr_read_ureg, SPR_NOACCESS,
7235                  &spr_read_ureg, SPR_NOACCESS,
7236                  0x00000000);
7237     spr_register(env, SPR_SPRG6, "SPRG6",
7238                  SPR_NOACCESS, SPR_NOACCESS,
7239                  &spr_read_generic, &spr_write_generic,
7240                  0x00000000);
7241     spr_register(env, SPR_USPRG6, "USPRG6",
7242                  &spr_read_ureg, SPR_NOACCESS,
7243                  &spr_read_ureg, SPR_NOACCESS,
7244                  0x00000000);
7245     spr_register(env, SPR_SPRG7, "SPRG7",
7246                  SPR_NOACCESS, SPR_NOACCESS,
7247                  &spr_read_generic, &spr_write_generic,
7248                  0x00000000);
7249     spr_register(env, SPR_USPRG7, "USPRG7",
7250                  &spr_read_ureg, SPR_NOACCESS,
7251                  &spr_read_ureg, SPR_NOACCESS,
7252                  0x00000000);
7253     /* Memory management */
7254     gen_low_BATs(env);
7255     gen_high_BATs(env);
7256     gen_74xx_soft_tlb(env, 128, 2);
7257     init_excp_7450(env);
7258     env->dcache_line_size = 32;
7259     env->icache_line_size = 32;
7260     /* Allocate hardware IRQ controller */
7261     ppc6xx_irq_init(ppc_env_get_cpu(env));
7262 }
7263
7264 POWERPC_FAMILY(7457)(ObjectClass *oc, void *data)
7265 {
7266     DeviceClass *dc = DEVICE_CLASS(oc);
7267     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7268
7269     dc->desc = "PowerPC 7457 (aka G4)";
7270     pcc->init_proc = init_proc_7457;
7271     pcc->check_pow = check_pow_hid0_74xx;
7272     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7273                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7274                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7275                        PPC_FLOAT_STFIWX |
7276                        PPC_CACHE | PPC_CACHE_ICBI |
7277                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
7278                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
7279                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7280                        PPC_MEM_TLBIA | PPC_74xx_TLB |
7281                        PPC_SEGMENT | PPC_EXTERN |
7282                        PPC_ALTIVEC;
7283     pcc->msr_mask = (1ull << MSR_VR) |
7284                     (1ull << MSR_POW) |
7285                     (1ull << MSR_ILE) |
7286                     (1ull << MSR_EE) |
7287                     (1ull << MSR_PR) |
7288                     (1ull << MSR_FP) |
7289                     (1ull << MSR_ME) |
7290                     (1ull << MSR_FE0) |
7291                     (1ull << MSR_SE) |
7292                     (1ull << MSR_DE) |
7293                     (1ull << MSR_FE1) |
7294                     (1ull << MSR_EP) |
7295                     (1ull << MSR_IR) |
7296                     (1ull << MSR_DR) |
7297                     (1ull << MSR_PMM) |
7298                     (1ull << MSR_RI) |
7299                     (1ull << MSR_LE);
7300     pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
7301     pcc->excp_model = POWERPC_EXCP_74xx;
7302     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
7303     pcc->bfd_mach = bfd_mach_ppc_7400;
7304     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7305                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7306                  POWERPC_FLAG_BUS_CLK;
7307 }
7308
7309 static void init_proc_e600 (CPUPPCState *env)
7310 {
7311     gen_spr_ne_601(env);
7312     gen_spr_7xx(env);
7313     /* Time base */
7314     gen_tbl(env);
7315     /* 74xx specific SPR */
7316     gen_spr_74xx(env);
7317     /* XXX : not implemented */
7318     spr_register(env, SPR_UBAMR, "UBAMR",
7319                  &spr_read_ureg, SPR_NOACCESS,
7320                  &spr_read_ureg, SPR_NOACCESS,
7321                  0x00000000);
7322     /* XXX : not implemented */
7323     spr_register(env, SPR_LDSTCR, "LDSTCR",
7324                  SPR_NOACCESS, SPR_NOACCESS,
7325                  &spr_read_generic, &spr_write_generic,
7326                  0x00000000);
7327     /* XXX : not implemented */
7328     spr_register(env, SPR_ICTRL, "ICTRL",
7329                  SPR_NOACCESS, SPR_NOACCESS,
7330                  &spr_read_generic, &spr_write_generic,
7331                  0x00000000);
7332     /* XXX : not implemented */
7333     spr_register(env, SPR_MSSSR0, "MSSSR0",
7334                  SPR_NOACCESS, SPR_NOACCESS,
7335                  &spr_read_generic, &spr_write_generic,
7336                  0x00000000);
7337     /* XXX : not implemented */
7338     spr_register(env, SPR_7XX_PMC5, "PMC5",
7339                  SPR_NOACCESS, SPR_NOACCESS,
7340                  &spr_read_generic, &spr_write_generic,
7341                  0x00000000);
7342     /* XXX : not implemented */
7343     spr_register(env, SPR_7XX_UPMC5, "UPMC5",
7344                  &spr_read_ureg, SPR_NOACCESS,
7345                  &spr_read_ureg, SPR_NOACCESS,
7346                  0x00000000);
7347     /* XXX : not implemented */
7348     spr_register(env, SPR_7XX_PMC6, "PMC6",
7349                  SPR_NOACCESS, SPR_NOACCESS,
7350                  &spr_read_generic, &spr_write_generic,
7351                  0x00000000);
7352     /* XXX : not implemented */
7353     spr_register(env, SPR_7XX_UPMC6, "UPMC6",
7354                  &spr_read_ureg, SPR_NOACCESS,
7355                  &spr_read_ureg, SPR_NOACCESS,
7356                  0x00000000);
7357     /* SPRGs */
7358     spr_register(env, SPR_SPRG4, "SPRG4",
7359                  SPR_NOACCESS, SPR_NOACCESS,
7360                  &spr_read_generic, &spr_write_generic,
7361                  0x00000000);
7362     spr_register(env, SPR_USPRG4, "USPRG4",
7363                  &spr_read_ureg, SPR_NOACCESS,
7364                  &spr_read_ureg, SPR_NOACCESS,
7365                  0x00000000);
7366     spr_register(env, SPR_SPRG5, "SPRG5",
7367                  SPR_NOACCESS, SPR_NOACCESS,
7368                  &spr_read_generic, &spr_write_generic,
7369                  0x00000000);
7370     spr_register(env, SPR_USPRG5, "USPRG5",
7371                  &spr_read_ureg, SPR_NOACCESS,
7372                  &spr_read_ureg, SPR_NOACCESS,
7373                  0x00000000);
7374     spr_register(env, SPR_SPRG6, "SPRG6",
7375                  SPR_NOACCESS, SPR_NOACCESS,
7376                  &spr_read_generic, &spr_write_generic,
7377                  0x00000000);
7378     spr_register(env, SPR_USPRG6, "USPRG6",
7379                  &spr_read_ureg, SPR_NOACCESS,
7380                  &spr_read_ureg, SPR_NOACCESS,
7381                  0x00000000);
7382     spr_register(env, SPR_SPRG7, "SPRG7",
7383                  SPR_NOACCESS, SPR_NOACCESS,
7384                  &spr_read_generic, &spr_write_generic,
7385                  0x00000000);
7386     spr_register(env, SPR_USPRG7, "USPRG7",
7387                  &spr_read_ureg, SPR_NOACCESS,
7388                  &spr_read_ureg, SPR_NOACCESS,
7389                  0x00000000);
7390     /* Memory management */
7391     gen_low_BATs(env);
7392     gen_high_BATs(env);
7393     gen_74xx_soft_tlb(env, 128, 2);
7394     init_excp_7450(env);
7395     env->dcache_line_size = 32;
7396     env->icache_line_size = 32;
7397     /* Allocate hardware IRQ controller */
7398     ppc6xx_irq_init(ppc_env_get_cpu(env));
7399 }
7400
7401 POWERPC_FAMILY(e600)(ObjectClass *oc, void *data)
7402 {
7403     DeviceClass *dc = DEVICE_CLASS(oc);
7404     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7405
7406     dc->desc = "PowerPC e600";
7407     pcc->init_proc = init_proc_e600;
7408     pcc->check_pow = check_pow_hid0_74xx;
7409     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7410                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7411                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7412                        PPC_FLOAT_STFIWX |
7413                        PPC_CACHE | PPC_CACHE_ICBI |
7414                        PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
7415                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
7416                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7417                        PPC_MEM_TLBIA | PPC_74xx_TLB |
7418                        PPC_SEGMENT | PPC_EXTERN |
7419                        PPC_ALTIVEC;
7420     pcc->insns_flags2 = PPC_NONE;
7421     pcc->msr_mask = (1ull << MSR_VR) |
7422                     (1ull << MSR_POW) |
7423                     (1ull << MSR_ILE) |
7424                     (1ull << MSR_EE) |
7425                     (1ull << MSR_PR) |
7426                     (1ull << MSR_FP) |
7427                     (1ull << MSR_ME) |
7428                     (1ull << MSR_FE0) |
7429                     (1ull << MSR_SE) |
7430                     (1ull << MSR_DE) |
7431                     (1ull << MSR_FE1) |
7432                     (1ull << MSR_EP) |
7433                     (1ull << MSR_IR) |
7434                     (1ull << MSR_DR) |
7435                     (1ull << MSR_PMM) |
7436                     (1ull << MSR_RI) |
7437                     (1ull << MSR_LE);
7438     pcc->mmu_model = POWERPC_MMU_32B;
7439 #if defined(CONFIG_SOFTMMU)
7440     pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
7441 #endif
7442     pcc->excp_model = POWERPC_EXCP_74xx;
7443     pcc->bus_model = PPC_FLAGS_INPUT_6xx;
7444     pcc->bfd_mach = bfd_mach_ppc_7400;
7445     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7446                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7447                  POWERPC_FLAG_BUS_CLK;
7448 }
7449
7450 #if defined (TARGET_PPC64)
7451 #if defined(CONFIG_USER_ONLY)
7452 #define POWERPC970_HID5_INIT 0x00000080
7453 #else
7454 #define POWERPC970_HID5_INIT 0x00000000
7455 #endif
7456
7457 enum BOOK3S_CPU_TYPE {
7458     BOOK3S_CPU_970,
7459     BOOK3S_CPU_POWER5PLUS,
7460     BOOK3S_CPU_POWER6,
7461     BOOK3S_CPU_POWER7,
7462     BOOK3S_CPU_POWER8,
7463     BOOK3S_CPU_POWER9
7464 };
7465
7466 static void gen_fscr_facility_check(DisasContext *ctx, int facility_sprn,
7467                                     int bit, int sprn, int cause)
7468 {
7469     TCGv_i32 t1 = tcg_const_i32(bit);
7470     TCGv_i32 t2 = tcg_const_i32(sprn);
7471     TCGv_i32 t3 = tcg_const_i32(cause);
7472
7473     gen_helper_fscr_facility_check(cpu_env, t1, t2, t3);
7474
7475     tcg_temp_free_i32(t3);
7476     tcg_temp_free_i32(t2);
7477     tcg_temp_free_i32(t1);
7478 }
7479
7480 static void gen_msr_facility_check(DisasContext *ctx, int facility_sprn,
7481                                    int bit, int sprn, int cause)
7482 {
7483     TCGv_i32 t1 = tcg_const_i32(bit);
7484     TCGv_i32 t2 = tcg_const_i32(sprn);
7485     TCGv_i32 t3 = tcg_const_i32(cause);
7486
7487     gen_helper_msr_facility_check(cpu_env, t1, t2, t3);
7488
7489     tcg_temp_free_i32(t3);
7490     tcg_temp_free_i32(t2);
7491     tcg_temp_free_i32(t1);
7492 }
7493
7494 static void spr_read_prev_upper32(DisasContext *ctx, int gprn, int sprn)
7495 {
7496     TCGv spr_up = tcg_temp_new();
7497     TCGv spr = tcg_temp_new();
7498
7499     gen_load_spr(spr, sprn - 1);
7500     tcg_gen_shri_tl(spr_up, spr, 32);
7501     tcg_gen_ext32u_tl(cpu_gpr[gprn], spr_up);
7502
7503     tcg_temp_free(spr);
7504     tcg_temp_free(spr_up);
7505 }
7506
7507 static void spr_write_prev_upper32(DisasContext *ctx, int sprn, int gprn)
7508 {
7509     TCGv spr = tcg_temp_new();
7510
7511     gen_load_spr(spr, sprn - 1);
7512     tcg_gen_deposit_tl(spr, spr, cpu_gpr[gprn], 32, 32);
7513     gen_store_spr(sprn - 1, spr);
7514
7515     tcg_temp_free(spr);
7516 }
7517
7518 static int check_pow_970 (CPUPPCState *env)
7519 {
7520     if (env->spr[SPR_HID0] & (HID0_DEEPNAP | HID0_DOZE | HID0_NAP)) {
7521         return 1;
7522     }
7523
7524     return 0;
7525 }
7526
7527 static void gen_spr_970_hid(CPUPPCState *env)
7528 {
7529     /* Hardware implementation registers */
7530     /* XXX : not implemented */
7531     spr_register(env, SPR_HID0, "HID0",
7532                  SPR_NOACCESS, SPR_NOACCESS,
7533                  &spr_read_generic, &spr_write_clear,
7534                  0x60000000);
7535     spr_register(env, SPR_HID1, "HID1",
7536                  SPR_NOACCESS, SPR_NOACCESS,
7537                  &spr_read_generic, &spr_write_generic,
7538                  0x00000000);
7539     spr_register(env, SPR_970_HID5, "HID5",
7540                  SPR_NOACCESS, SPR_NOACCESS,
7541                  &spr_read_generic, &spr_write_generic,
7542                  POWERPC970_HID5_INIT);
7543 }
7544
7545 static void gen_spr_970_hior(CPUPPCState *env)
7546 {
7547     spr_register(env, SPR_HIOR, "SPR_HIOR",
7548                  SPR_NOACCESS, SPR_NOACCESS,
7549                  &spr_read_hior, &spr_write_hior,
7550                  0x00000000);
7551 }
7552
7553 static void gen_spr_book3s_common(CPUPPCState *env)
7554 {
7555     spr_register(env, SPR_CTRL, "SPR_CTRL",
7556                  SPR_NOACCESS, SPR_NOACCESS,
7557                  SPR_NOACCESS, &spr_write_generic,
7558                  0x00000000);
7559     spr_register(env, SPR_UCTRL, "SPR_UCTRL",
7560                  &spr_read_ureg, SPR_NOACCESS,
7561                  &spr_read_ureg, SPR_NOACCESS,
7562                  0x00000000);
7563 }
7564
7565 static void gen_spr_book3s_altivec(CPUPPCState *env)
7566 {
7567     if (!(env->insns_flags & PPC_ALTIVEC)) {
7568         return;
7569     }
7570
7571     spr_register_kvm(env, SPR_VRSAVE, "VRSAVE",
7572                      &spr_read_generic, &spr_write_generic,
7573                      &spr_read_generic, &spr_write_generic,
7574                      KVM_REG_PPC_VRSAVE, 0x00000000);
7575
7576     /* Can't find information on what this should be on reset.  This
7577      * value is the one used by 74xx processors. */
7578     vscr_init(env, 0x00010000);
7579 }
7580
7581 static void gen_spr_book3s_dbg(CPUPPCState *env)
7582 {
7583     /*
7584      * TODO: different specs define different scopes for these,
7585      * will have to address this:
7586      * 970: super/write and super/read
7587      * powerisa 2.03..2.04: hypv/write and super/read.
7588      * powerisa 2.05 and newer: hypv/write and hypv/read.
7589      */
7590     spr_register_kvm(env, SPR_DABR, "DABR",
7591                      SPR_NOACCESS, SPR_NOACCESS,
7592                      &spr_read_generic, &spr_write_generic,
7593                      KVM_REG_PPC_DABR, 0x00000000);
7594     spr_register_kvm(env, SPR_DABRX, "DABRX",
7595                      SPR_NOACCESS, SPR_NOACCESS,
7596                      &spr_read_generic, &spr_write_generic,
7597                      KVM_REG_PPC_DABRX, 0x00000000);
7598 }
7599
7600 static void gen_spr_book3s_207_dbg(CPUPPCState *env)
7601 {
7602     spr_register_kvm_hv(env, SPR_DAWR, "DAWR",
7603                         SPR_NOACCESS, SPR_NOACCESS,
7604                         SPR_NOACCESS, SPR_NOACCESS,
7605                         &spr_read_generic, &spr_write_generic,
7606                         KVM_REG_PPC_DAWR, 0x00000000);
7607     spr_register_kvm_hv(env, SPR_DAWRX, "DAWRX",
7608                         SPR_NOACCESS, SPR_NOACCESS,
7609                         SPR_NOACCESS, SPR_NOACCESS,
7610                         &spr_read_generic, &spr_write_generic,
7611                         KVM_REG_PPC_DAWRX, 0x00000000);
7612     spr_register_kvm_hv(env, SPR_CIABR, "CIABR",
7613                         SPR_NOACCESS, SPR_NOACCESS,
7614                         SPR_NOACCESS, SPR_NOACCESS,
7615                         &spr_read_generic, &spr_write_generic,
7616                         KVM_REG_PPC_CIABR, 0x00000000);
7617 }
7618
7619 static void gen_spr_970_dbg(CPUPPCState *env)
7620 {
7621     /* Breakpoints */
7622     spr_register(env, SPR_IABR, "IABR",
7623                  SPR_NOACCESS, SPR_NOACCESS,
7624                  &spr_read_generic, &spr_write_generic,
7625                  0x00000000);
7626 }
7627
7628 static void gen_spr_book3s_pmu_sup(CPUPPCState *env)
7629 {
7630     spr_register_kvm(env, SPR_POWER_MMCR0, "MMCR0",
7631                      SPR_NOACCESS, SPR_NOACCESS,
7632                      &spr_read_generic, &spr_write_generic,
7633                      KVM_REG_PPC_MMCR0, 0x00000000);
7634     spr_register_kvm(env, SPR_POWER_MMCR1, "MMCR1",
7635                      SPR_NOACCESS, SPR_NOACCESS,
7636                      &spr_read_generic, &spr_write_generic,
7637                      KVM_REG_PPC_MMCR1, 0x00000000);
7638     spr_register_kvm(env, SPR_POWER_MMCRA, "MMCRA",
7639                      SPR_NOACCESS, SPR_NOACCESS,
7640                      &spr_read_generic, &spr_write_generic,
7641                      KVM_REG_PPC_MMCRA, 0x00000000);
7642     spr_register_kvm(env, SPR_POWER_PMC1, "PMC1",
7643                      SPR_NOACCESS, SPR_NOACCESS,
7644                      &spr_read_generic, &spr_write_generic,
7645                      KVM_REG_PPC_PMC1, 0x00000000);
7646     spr_register_kvm(env, SPR_POWER_PMC2, "PMC2",
7647                      SPR_NOACCESS, SPR_NOACCESS,
7648                      &spr_read_generic, &spr_write_generic,
7649                      KVM_REG_PPC_PMC2, 0x00000000);
7650     spr_register_kvm(env, SPR_POWER_PMC3, "PMC3",
7651                      SPR_NOACCESS, SPR_NOACCESS,
7652                      &spr_read_generic, &spr_write_generic,
7653                      KVM_REG_PPC_PMC3, 0x00000000);
7654     spr_register_kvm(env, SPR_POWER_PMC4, "PMC4",
7655                      SPR_NOACCESS, SPR_NOACCESS,
7656                      &spr_read_generic, &spr_write_generic,
7657                      KVM_REG_PPC_PMC4, 0x00000000);
7658     spr_register_kvm(env, SPR_POWER_PMC5, "PMC5",
7659                      SPR_NOACCESS, SPR_NOACCESS,
7660                      &spr_read_generic, &spr_write_generic,
7661                      KVM_REG_PPC_PMC5, 0x00000000);
7662     spr_register_kvm(env, SPR_POWER_PMC6, "PMC6",
7663                      SPR_NOACCESS, SPR_NOACCESS,
7664                      &spr_read_generic, &spr_write_generic,
7665                      KVM_REG_PPC_PMC6, 0x00000000);
7666     spr_register_kvm(env, SPR_POWER_SIAR, "SIAR",
7667                      SPR_NOACCESS, SPR_NOACCESS,
7668                      &spr_read_generic, &spr_write_generic,
7669                      KVM_REG_PPC_SIAR, 0x00000000);
7670     spr_register_kvm(env, SPR_POWER_SDAR, "SDAR",
7671                      SPR_NOACCESS, SPR_NOACCESS,
7672                      &spr_read_generic, &spr_write_generic,
7673                      KVM_REG_PPC_SDAR, 0x00000000);
7674 }
7675
7676 static void gen_spr_book3s_pmu_user(CPUPPCState *env)
7677 {
7678     spr_register(env, SPR_POWER_UMMCR0, "UMMCR0",
7679                  &spr_read_ureg, SPR_NOACCESS,
7680                  &spr_read_ureg, &spr_write_ureg,
7681                  0x00000000);
7682     spr_register(env, SPR_POWER_UMMCR1, "UMMCR1",
7683                  &spr_read_ureg, SPR_NOACCESS,
7684                  &spr_read_ureg, &spr_write_ureg,
7685                  0x00000000);
7686     spr_register(env, SPR_POWER_UMMCRA, "UMMCRA",
7687                  &spr_read_ureg, SPR_NOACCESS,
7688                  &spr_read_ureg, &spr_write_ureg,
7689                  0x00000000);
7690     spr_register(env, SPR_POWER_UPMC1, "UPMC1",
7691                  &spr_read_ureg, SPR_NOACCESS,
7692                  &spr_read_ureg, &spr_write_ureg,
7693                  0x00000000);
7694     spr_register(env, SPR_POWER_UPMC2, "UPMC2",
7695                  &spr_read_ureg, SPR_NOACCESS,
7696                  &spr_read_ureg, &spr_write_ureg,
7697                  0x00000000);
7698     spr_register(env, SPR_POWER_UPMC3, "UPMC3",
7699                  &spr_read_ureg, SPR_NOACCESS,
7700                  &spr_read_ureg, &spr_write_ureg,
7701                  0x00000000);
7702     spr_register(env, SPR_POWER_UPMC4, "UPMC4",
7703                  &spr_read_ureg, SPR_NOACCESS,
7704                  &spr_read_ureg, &spr_write_ureg,
7705                  0x00000000);
7706     spr_register(env, SPR_POWER_UPMC5, "UPMC5",
7707                  &spr_read_ureg, SPR_NOACCESS,
7708                  &spr_read_ureg, &spr_write_ureg,
7709                  0x00000000);
7710     spr_register(env, SPR_POWER_UPMC6, "UPMC6",
7711                  &spr_read_ureg, SPR_NOACCESS,
7712                  &spr_read_ureg, &spr_write_ureg,
7713                  0x00000000);
7714     spr_register(env, SPR_POWER_USIAR, "USIAR",
7715                  &spr_read_ureg, SPR_NOACCESS,
7716                  &spr_read_ureg, &spr_write_ureg,
7717                  0x00000000);
7718     spr_register(env, SPR_POWER_USDAR, "USDAR",
7719                  &spr_read_ureg, SPR_NOACCESS,
7720                  &spr_read_ureg, &spr_write_ureg,
7721                  0x00000000);
7722 }
7723
7724 static void gen_spr_970_pmu_sup(CPUPPCState *env)
7725 {
7726     spr_register_kvm(env, SPR_970_PMC7, "PMC7",
7727                      SPR_NOACCESS, SPR_NOACCESS,
7728                      &spr_read_generic, &spr_write_generic,
7729                      KVM_REG_PPC_PMC7, 0x00000000);
7730     spr_register_kvm(env, SPR_970_PMC8, "PMC8",
7731                      SPR_NOACCESS, SPR_NOACCESS,
7732                      &spr_read_generic, &spr_write_generic,
7733                      KVM_REG_PPC_PMC8, 0x00000000);
7734 }
7735
7736 static void gen_spr_970_pmu_user(CPUPPCState *env)
7737 {
7738     spr_register(env, SPR_970_UPMC7, "UPMC7",
7739                  &spr_read_ureg, SPR_NOACCESS,
7740                  &spr_read_ureg, &spr_write_ureg,
7741                  0x00000000);
7742     spr_register(env, SPR_970_UPMC8, "UPMC8",
7743                  &spr_read_ureg, SPR_NOACCESS,
7744                  &spr_read_ureg, &spr_write_ureg,
7745                  0x00000000);
7746 }
7747
7748 static void gen_spr_power8_pmu_sup(CPUPPCState *env)
7749 {
7750     spr_register_kvm(env, SPR_POWER_MMCR2, "MMCR2",
7751                      SPR_NOACCESS, SPR_NOACCESS,
7752                      &spr_read_generic, &spr_write_generic,
7753                      KVM_REG_PPC_MMCR2, 0x00000000);
7754     spr_register_kvm(env, SPR_POWER_MMCRS, "MMCRS",
7755                      SPR_NOACCESS, SPR_NOACCESS,
7756                      &spr_read_generic, &spr_write_generic,
7757                      KVM_REG_PPC_MMCRS, 0x00000000);
7758     spr_register_kvm(env, SPR_POWER_SIER, "SIER",
7759                      SPR_NOACCESS, SPR_NOACCESS,
7760                      &spr_read_generic, &spr_write_generic,
7761                      KVM_REG_PPC_SIER, 0x00000000);
7762     spr_register_kvm(env, SPR_POWER_SPMC1, "SPMC1",
7763                      SPR_NOACCESS, SPR_NOACCESS,
7764                      &spr_read_generic, &spr_write_generic,
7765                      KVM_REG_PPC_SPMC1, 0x00000000);
7766     spr_register_kvm(env, SPR_POWER_SPMC2, "SPMC2",
7767                      SPR_NOACCESS, SPR_NOACCESS,
7768                      &spr_read_generic, &spr_write_generic,
7769                      KVM_REG_PPC_SPMC2, 0x00000000);
7770     spr_register_kvm(env, SPR_TACR, "TACR",
7771                      SPR_NOACCESS, SPR_NOACCESS,
7772                      &spr_read_generic, &spr_write_generic,
7773                      KVM_REG_PPC_TACR, 0x00000000);
7774     spr_register_kvm(env, SPR_TCSCR, "TCSCR",
7775                      SPR_NOACCESS, SPR_NOACCESS,
7776                      &spr_read_generic, &spr_write_generic,
7777                      KVM_REG_PPC_TCSCR, 0x00000000);
7778     spr_register_kvm(env, SPR_CSIGR, "CSIGR",
7779                      SPR_NOACCESS, SPR_NOACCESS,
7780                      &spr_read_generic, &spr_write_generic,
7781                      KVM_REG_PPC_CSIGR, 0x00000000);
7782 }
7783
7784 static void gen_spr_power8_pmu_user(CPUPPCState *env)
7785 {
7786     spr_register(env, SPR_POWER_UMMCR2, "UMMCR2",
7787                  &spr_read_ureg, SPR_NOACCESS,
7788                  &spr_read_ureg, &spr_write_ureg,
7789                  0x00000000);
7790     spr_register(env, SPR_POWER_USIER, "USIER",
7791                  &spr_read_generic, SPR_NOACCESS,
7792                  &spr_read_generic, &spr_write_generic,
7793                  0x00000000);
7794 }
7795
7796 static void gen_spr_power5p_ear(CPUPPCState *env)
7797 {
7798     /* External access control */
7799     spr_register(env, SPR_EAR, "EAR",
7800                  SPR_NOACCESS, SPR_NOACCESS,
7801                  &spr_read_generic, &spr_write_generic,
7802                  0x00000000);
7803 }
7804
7805 #if !defined(CONFIG_USER_ONLY)
7806 static void spr_write_hmer(DisasContext *ctx, int sprn, int gprn)
7807 {
7808     TCGv hmer = tcg_temp_new();
7809
7810     gen_load_spr(hmer, sprn);
7811     tcg_gen_and_tl(hmer, cpu_gpr[gprn], hmer);
7812     gen_store_spr(sprn, hmer);
7813     spr_store_dump_spr(sprn);
7814     tcg_temp_free(hmer);
7815 }
7816
7817 static void spr_write_lpcr(DisasContext *ctx, int sprn, int gprn)
7818 {
7819     gen_helper_store_lpcr(cpu_env, cpu_gpr[gprn]);
7820 }
7821
7822 static void spr_write_970_hid4(DisasContext *ctx, int sprn, int gprn)
7823 {
7824 #if defined(TARGET_PPC64)
7825     spr_write_generic(ctx, sprn, gprn);
7826     gen_helper_store_lpcr(cpu_env, cpu_gpr[gprn]);
7827 #endif
7828 }
7829
7830 #endif /* !defined(CONFIG_USER_ONLY) */
7831
7832 static void gen_spr_970_lpar(CPUPPCState *env)
7833 {
7834 #if !defined(CONFIG_USER_ONLY)
7835     /* Logical partitionning */
7836     /* PPC970: HID4 is effectively the LPCR */
7837     spr_register(env, SPR_970_HID4, "HID4",
7838                  SPR_NOACCESS, SPR_NOACCESS,
7839                  &spr_read_generic, &spr_write_970_hid4,
7840                  0x00000000);
7841 #endif
7842 }
7843
7844 static void gen_spr_power5p_lpar(CPUPPCState *env)
7845 {
7846 #if !defined(CONFIG_USER_ONLY)
7847     /* Logical partitionning */
7848     spr_register_kvm_hv(env, SPR_LPCR, "LPCR",
7849                         SPR_NOACCESS, SPR_NOACCESS,
7850                         SPR_NOACCESS, SPR_NOACCESS,
7851                         &spr_read_generic, &spr_write_lpcr,
7852                         KVM_REG_PPC_LPCR, LPCR_LPES0 | LPCR_LPES1);
7853     spr_register_hv(env, SPR_HDEC, "HDEC",
7854                     SPR_NOACCESS, SPR_NOACCESS,
7855                     SPR_NOACCESS, SPR_NOACCESS,
7856                     &spr_read_hdecr, &spr_write_hdecr, 0);
7857 #endif
7858 }
7859
7860 static void gen_spr_book3s_ids(CPUPPCState *env)
7861 {
7862     /* FIXME: Will need to deal with thread vs core only SPRs */
7863
7864     /* Processor identification */
7865     spr_register_hv(env, SPR_PIR, "PIR",
7866                  SPR_NOACCESS, SPR_NOACCESS,
7867                  SPR_NOACCESS, SPR_NOACCESS,
7868                  &spr_read_generic, NULL,
7869                  0x00000000);
7870     spr_register_hv(env, SPR_HID0, "HID0",
7871                  SPR_NOACCESS, SPR_NOACCESS,
7872                  SPR_NOACCESS, SPR_NOACCESS,
7873                  &spr_read_generic, &spr_write_generic,
7874                  0x00000000);
7875     spr_register_hv(env, SPR_TSCR, "TSCR",
7876                  SPR_NOACCESS, SPR_NOACCESS,
7877                  SPR_NOACCESS, SPR_NOACCESS,
7878                  &spr_read_generic, &spr_write_generic,
7879                  0x00000000);
7880     spr_register_hv(env, SPR_HMER, "HMER",
7881                  SPR_NOACCESS, SPR_NOACCESS,
7882                  SPR_NOACCESS, SPR_NOACCESS,
7883                  &spr_read_generic, &spr_write_hmer,
7884                  0x00000000);
7885     spr_register_hv(env, SPR_HMEER, "HMEER",
7886                  SPR_NOACCESS, SPR_NOACCESS,
7887                  SPR_NOACCESS, SPR_NOACCESS,
7888                  &spr_read_generic, &spr_write_generic,
7889                  0x00000000);
7890     spr_register_hv(env, SPR_TFMR, "TFMR",
7891                  SPR_NOACCESS, SPR_NOACCESS,
7892                  SPR_NOACCESS, SPR_NOACCESS,
7893                  &spr_read_generic, &spr_write_generic,
7894                  0x00000000);
7895     spr_register_hv(env, SPR_LPIDR, "LPIDR",
7896                  SPR_NOACCESS, SPR_NOACCESS,
7897                  SPR_NOACCESS, SPR_NOACCESS,
7898                  &spr_read_generic, &spr_write_generic,
7899                  0x00000000);
7900     spr_register_hv(env, SPR_HFSCR, "HFSCR",
7901                  SPR_NOACCESS, SPR_NOACCESS,
7902                  SPR_NOACCESS, SPR_NOACCESS,
7903                  &spr_read_generic, &spr_write_generic,
7904                  0x00000000);
7905     spr_register_hv(env, SPR_MMCRC, "MMCRC",
7906                  SPR_NOACCESS, SPR_NOACCESS,
7907                  SPR_NOACCESS, SPR_NOACCESS,
7908                  &spr_read_generic, &spr_write_generic,
7909                  0x00000000);
7910     spr_register_hv(env, SPR_MMCRH, "MMCRH",
7911                  SPR_NOACCESS, SPR_NOACCESS,
7912                  SPR_NOACCESS, SPR_NOACCESS,
7913                  &spr_read_generic, &spr_write_generic,
7914                  0x00000000);
7915     spr_register_hv(env, SPR_HSPRG0, "HSPRG0",
7916                  SPR_NOACCESS, SPR_NOACCESS,
7917                  SPR_NOACCESS, SPR_NOACCESS,
7918                  &spr_read_generic, &spr_write_generic,
7919                  0x00000000);
7920     spr_register_hv(env, SPR_HSPRG1, "HSPRG1",
7921                  SPR_NOACCESS, SPR_NOACCESS,
7922                  SPR_NOACCESS, SPR_NOACCESS,
7923                  &spr_read_generic, &spr_write_generic,
7924                  0x00000000);
7925     spr_register_hv(env, SPR_HSRR0, "HSRR0",
7926                  SPR_NOACCESS, SPR_NOACCESS,
7927                  SPR_NOACCESS, SPR_NOACCESS,
7928                  &spr_read_generic, &spr_write_generic,
7929                  0x00000000);
7930     spr_register_hv(env, SPR_HSRR1, "HSRR1",
7931                  SPR_NOACCESS, SPR_NOACCESS,
7932                  SPR_NOACCESS, SPR_NOACCESS,
7933                  &spr_read_generic, &spr_write_generic,
7934                  0x00000000);
7935     spr_register_hv(env, SPR_HDAR, "HDAR",
7936                  SPR_NOACCESS, SPR_NOACCESS,
7937                  SPR_NOACCESS, SPR_NOACCESS,
7938                  &spr_read_generic, &spr_write_generic,
7939                  0x00000000);
7940     spr_register_hv(env, SPR_HDSISR, "HDSISR",
7941                  SPR_NOACCESS, SPR_NOACCESS,
7942                  SPR_NOACCESS, SPR_NOACCESS,
7943                  &spr_read_generic, &spr_write_generic,
7944                  0x00000000);
7945     spr_register_hv(env, SPR_RMOR, "RMOR",
7946                  SPR_NOACCESS, SPR_NOACCESS,
7947                  SPR_NOACCESS, SPR_NOACCESS,
7948                  &spr_read_generic, &spr_write_generic,
7949                  0x00000000);
7950     spr_register_hv(env, SPR_HRMOR, "HRMOR",
7951                  SPR_NOACCESS, SPR_NOACCESS,
7952                  SPR_NOACCESS, SPR_NOACCESS,
7953                  &spr_read_generic, &spr_write_generic,
7954                  0x00000000);
7955 }
7956
7957 static void gen_spr_power8_ids(CPUPPCState *env)
7958 {
7959     /* Thread identification */
7960     spr_register(env, SPR_TIR, "TIR",
7961                  SPR_NOACCESS, SPR_NOACCESS,
7962                  &spr_read_generic, SPR_NOACCESS,
7963                  0x00000000);
7964 }
7965
7966 static void gen_spr_book3s_purr(CPUPPCState *env)
7967 {
7968 #if !defined(CONFIG_USER_ONLY)
7969     /* PURR & SPURR: Hack - treat these as aliases for the TB for now */
7970     spr_register_kvm(env, SPR_PURR,   "PURR",
7971                      &spr_read_purr, SPR_NOACCESS,
7972                      &spr_read_purr, SPR_NOACCESS,
7973                      KVM_REG_PPC_PURR, 0x00000000);
7974     spr_register_kvm(env, SPR_SPURR,   "SPURR",
7975                      &spr_read_purr, SPR_NOACCESS,
7976                      &spr_read_purr, SPR_NOACCESS,
7977                      KVM_REG_PPC_SPURR, 0x00000000);
7978 #endif
7979 }
7980
7981 static void gen_spr_power6_dbg(CPUPPCState *env)
7982 {
7983 #if !defined(CONFIG_USER_ONLY)
7984     spr_register(env, SPR_CFAR, "SPR_CFAR",
7985                  SPR_NOACCESS, SPR_NOACCESS,
7986                  &spr_read_cfar, &spr_write_cfar,
7987                  0x00000000);
7988 #endif
7989 }
7990
7991 static void gen_spr_power5p_common(CPUPPCState *env)
7992 {
7993     spr_register_kvm(env, SPR_PPR, "PPR",
7994                      &spr_read_generic, &spr_write_generic,
7995                      &spr_read_generic, &spr_write_generic,
7996                      KVM_REG_PPC_PPR, 0x00000000);
7997 }
7998
7999 static void gen_spr_power6_common(CPUPPCState *env)
8000 {
8001 #if !defined(CONFIG_USER_ONLY)
8002     spr_register_kvm(env, SPR_DSCR, "SPR_DSCR",
8003                      SPR_NOACCESS, SPR_NOACCESS,
8004                      &spr_read_generic, &spr_write_generic,
8005                      KVM_REG_PPC_DSCR, 0x00000000);
8006 #endif
8007     /*
8008      * Register PCR to report POWERPC_EXCP_PRIV_REG instead of
8009      * POWERPC_EXCP_INVAL_SPR.
8010      */
8011     spr_register(env, SPR_PCR, "PCR",
8012                  SPR_NOACCESS, SPR_NOACCESS,
8013                  SPR_NOACCESS, SPR_NOACCESS,
8014                  0x00000000);
8015 }
8016
8017 static void spr_read_tar(DisasContext *ctx, int gprn, int sprn)
8018 {
8019     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_TAR, sprn, FSCR_IC_TAR);
8020     spr_read_generic(ctx, gprn, sprn);
8021 }
8022
8023 static void spr_write_tar(DisasContext *ctx, int sprn, int gprn)
8024 {
8025     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_TAR, sprn, FSCR_IC_TAR);
8026     spr_write_generic(ctx, sprn, gprn);
8027 }
8028
8029 static void gen_spr_power8_tce_address_control(CPUPPCState *env)
8030 {
8031     spr_register_kvm(env, SPR_TAR, "TAR",
8032                      &spr_read_tar, &spr_write_tar,
8033                      &spr_read_generic, &spr_write_generic,
8034                      KVM_REG_PPC_TAR, 0x00000000);
8035 }
8036
8037 static void spr_read_tm(DisasContext *ctx, int gprn, int sprn)
8038 {
8039     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
8040     spr_read_generic(ctx, gprn, sprn);
8041 }
8042
8043 static void spr_write_tm(DisasContext *ctx, int sprn, int gprn)
8044 {
8045     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
8046     spr_write_generic(ctx, sprn, gprn);
8047 }
8048
8049 static void spr_read_tm_upper32(DisasContext *ctx, int gprn, int sprn)
8050 {
8051     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
8052     spr_read_prev_upper32(ctx, gprn, sprn);
8053 }
8054
8055 static void spr_write_tm_upper32(DisasContext *ctx, int sprn, int gprn)
8056 {
8057     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
8058     spr_write_prev_upper32(ctx, sprn, gprn);
8059 }
8060
8061 static void gen_spr_power8_tm(CPUPPCState *env)
8062 {
8063     spr_register_kvm(env, SPR_TFHAR, "TFHAR",
8064                      &spr_read_tm, &spr_write_tm,
8065                      &spr_read_tm, &spr_write_tm,
8066                      KVM_REG_PPC_TFHAR, 0x00000000);
8067     spr_register_kvm(env, SPR_TFIAR, "TFIAR",
8068                      &spr_read_tm, &spr_write_tm,
8069                      &spr_read_tm, &spr_write_tm,
8070                      KVM_REG_PPC_TFIAR, 0x00000000);
8071     spr_register_kvm(env, SPR_TEXASR, "TEXASR",
8072                      &spr_read_tm, &spr_write_tm,
8073                      &spr_read_tm, &spr_write_tm,
8074                      KVM_REG_PPC_TEXASR, 0x00000000);
8075     spr_register(env, SPR_TEXASRU, "TEXASRU",
8076                  &spr_read_tm_upper32, &spr_write_tm_upper32,
8077                  &spr_read_tm_upper32, &spr_write_tm_upper32,
8078                  0x00000000);
8079 }
8080
8081 static void spr_read_ebb(DisasContext *ctx, int gprn, int sprn)
8082 {
8083     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
8084     spr_read_generic(ctx, gprn, sprn);
8085 }
8086
8087 static void spr_write_ebb(DisasContext *ctx, int sprn, int gprn)
8088 {
8089     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
8090     spr_write_generic(ctx, sprn, gprn);
8091 }
8092
8093 static void spr_read_ebb_upper32(DisasContext *ctx, int gprn, int sprn)
8094 {
8095     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
8096     spr_read_prev_upper32(ctx, gprn, sprn);
8097 }
8098
8099 static void spr_write_ebb_upper32(DisasContext *ctx, int sprn, int gprn)
8100 {
8101     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
8102     spr_write_prev_upper32(ctx, sprn, gprn);
8103 }
8104
8105 static void gen_spr_power8_ebb(CPUPPCState *env)
8106 {
8107     spr_register(env, SPR_BESCRS, "BESCRS",
8108                  &spr_read_ebb, &spr_write_ebb,
8109                  &spr_read_generic, &spr_write_generic,
8110                  0x00000000);
8111     spr_register(env, SPR_BESCRSU, "BESCRSU",
8112                  &spr_read_ebb_upper32, &spr_write_ebb_upper32,
8113                  &spr_read_prev_upper32, &spr_write_prev_upper32,
8114                  0x00000000);
8115     spr_register(env, SPR_BESCRR, "BESCRR",
8116                  &spr_read_ebb, &spr_write_ebb,
8117                  &spr_read_generic, &spr_write_generic,
8118                  0x00000000);
8119     spr_register(env, SPR_BESCRRU, "BESCRRU",
8120                  &spr_read_ebb_upper32, &spr_write_ebb_upper32,
8121                  &spr_read_prev_upper32, &spr_write_prev_upper32,
8122                  0x00000000);
8123     spr_register_kvm(env, SPR_EBBHR, "EBBHR",
8124                      &spr_read_ebb, &spr_write_ebb,
8125                      &spr_read_generic, &spr_write_generic,
8126                      KVM_REG_PPC_EBBHR, 0x00000000);
8127     spr_register_kvm(env, SPR_EBBRR, "EBBRR",
8128                      &spr_read_ebb, &spr_write_ebb,
8129                      &spr_read_generic, &spr_write_generic,
8130                      KVM_REG_PPC_EBBRR, 0x00000000);
8131     spr_register_kvm(env, SPR_BESCR, "BESCR",
8132                      &spr_read_ebb, &spr_write_ebb,
8133                      &spr_read_generic, &spr_write_generic,
8134                      KVM_REG_PPC_BESCR, 0x00000000);
8135 }
8136
8137 /* Virtual Time Base */
8138 static void gen_spr_vtb(CPUPPCState *env)
8139 {
8140     spr_register(env, SPR_VTB, "VTB",
8141                  SPR_NOACCESS, SPR_NOACCESS,
8142                  &spr_read_tbl, SPR_NOACCESS,
8143                  0x00000000);
8144 }
8145
8146 static void gen_spr_power8_fscr(CPUPPCState *env)
8147 {
8148 #if defined(CONFIG_USER_ONLY)
8149     target_ulong initval = 1ULL << FSCR_TAR;
8150 #else
8151     target_ulong initval = 0;
8152 #endif
8153     spr_register_kvm(env, SPR_FSCR, "FSCR",
8154                      SPR_NOACCESS, SPR_NOACCESS,
8155                      &spr_read_generic, &spr_write_generic,
8156                      KVM_REG_PPC_FSCR, initval);
8157 }
8158
8159 static void gen_spr_power8_pspb(CPUPPCState *env)
8160 {
8161     spr_register_kvm(env, SPR_PSPB, "PSPB",
8162                      SPR_NOACCESS, SPR_NOACCESS,
8163                      &spr_read_generic, &spr_write_generic32,
8164                      KVM_REG_PPC_PSPB, 0);
8165 }
8166
8167 static void gen_spr_power8_ic(CPUPPCState *env)
8168 {
8169 #if !defined(CONFIG_USER_ONLY)
8170     spr_register_hv(env, SPR_IC, "IC",
8171                     SPR_NOACCESS, SPR_NOACCESS,
8172                     &spr_read_generic, SPR_NOACCESS,
8173                     &spr_read_generic, &spr_write_generic,
8174                     0);
8175 #endif
8176 }
8177
8178 static void gen_spr_power8_book4(CPUPPCState *env)
8179 {
8180     /* Add a number of P8 book4 registers */
8181 #if !defined(CONFIG_USER_ONLY)
8182     spr_register_kvm(env, SPR_ACOP, "ACOP",
8183                      SPR_NOACCESS, SPR_NOACCESS,
8184                      &spr_read_generic, &spr_write_generic,
8185                      KVM_REG_PPC_ACOP, 0);
8186     spr_register_kvm(env, SPR_BOOKS_PID, "PID",
8187                      SPR_NOACCESS, SPR_NOACCESS,
8188                      &spr_read_generic, &spr_write_generic,
8189                      KVM_REG_PPC_PID, 0);
8190     spr_register_kvm(env, SPR_WORT, "WORT",
8191                      SPR_NOACCESS, SPR_NOACCESS,
8192                      &spr_read_generic, &spr_write_generic,
8193                      KVM_REG_PPC_WORT, 0);
8194 #endif
8195 }
8196
8197 static void gen_spr_power7_book4(CPUPPCState *env)
8198 {
8199     /* Add a number of P7 book4 registers */
8200 #if !defined(CONFIG_USER_ONLY)
8201     spr_register_kvm(env, SPR_ACOP, "ACOP",
8202                      SPR_NOACCESS, SPR_NOACCESS,
8203                      &spr_read_generic, &spr_write_generic,
8204                      KVM_REG_PPC_ACOP, 0);
8205     spr_register_kvm(env, SPR_BOOKS_PID, "PID",
8206                      SPR_NOACCESS, SPR_NOACCESS,
8207                      &spr_read_generic, &spr_write_generic,
8208                      KVM_REG_PPC_PID, 0);
8209 #endif
8210 }
8211
8212 static void gen_spr_power8_rpr(CPUPPCState *env)
8213 {
8214 #if !defined(CONFIG_USER_ONLY)
8215     spr_register_hv(env, SPR_RPR, "RPR",
8216                     SPR_NOACCESS, SPR_NOACCESS,
8217                     SPR_NOACCESS, SPR_NOACCESS,
8218                     &spr_read_generic, &spr_write_generic,
8219                     0x00000103070F1F3F);
8220 #endif
8221 }
8222
8223 static void init_proc_book3s_64(CPUPPCState *env, int version)
8224 {
8225     gen_spr_ne_601(env);
8226     gen_tbl(env);
8227     gen_spr_book3s_altivec(env);
8228     gen_spr_book3s_pmu_sup(env);
8229     gen_spr_book3s_pmu_user(env);
8230     gen_spr_book3s_common(env);
8231
8232     switch (version) {
8233     case BOOK3S_CPU_970:
8234     case BOOK3S_CPU_POWER5PLUS:
8235         gen_spr_970_hid(env);
8236         gen_spr_970_hior(env);
8237         gen_low_BATs(env);
8238         gen_spr_970_pmu_sup(env);
8239         gen_spr_970_pmu_user(env);
8240         break;
8241     case BOOK3S_CPU_POWER7:
8242     case BOOK3S_CPU_POWER8:
8243     case BOOK3S_CPU_POWER9:
8244         gen_spr_book3s_ids(env);
8245         gen_spr_amr(env, version >= BOOK3S_CPU_POWER8);
8246         gen_spr_book3s_purr(env);
8247         env->ci_large_pages = true;
8248         break;
8249     default:
8250         g_assert_not_reached();
8251     }
8252     if (version >= BOOK3S_CPU_POWER5PLUS) {
8253         gen_spr_power5p_common(env);
8254         gen_spr_power5p_lpar(env);
8255         gen_spr_power5p_ear(env);
8256     } else {
8257         gen_spr_970_lpar(env);
8258     }
8259     if (version == BOOK3S_CPU_970) {
8260         gen_spr_970_dbg(env);
8261     }
8262     if (version >= BOOK3S_CPU_POWER6) {
8263         gen_spr_power6_common(env);
8264         gen_spr_power6_dbg(env);
8265     }
8266     if (version == BOOK3S_CPU_POWER7) {
8267         gen_spr_power7_book4(env);
8268     }
8269     if (version >= BOOK3S_CPU_POWER8) {
8270         gen_spr_power8_tce_address_control(env);
8271         gen_spr_power8_ids(env);
8272         gen_spr_power8_ebb(env);
8273         gen_spr_power8_fscr(env);
8274         gen_spr_power8_pmu_sup(env);
8275         gen_spr_power8_pmu_user(env);
8276         gen_spr_power8_tm(env);
8277         gen_spr_power8_pspb(env);
8278         gen_spr_vtb(env);
8279         gen_spr_power8_ic(env);
8280         gen_spr_power8_book4(env);
8281         gen_spr_power8_rpr(env);
8282     }
8283     if (version < BOOK3S_CPU_POWER8) {
8284         gen_spr_book3s_dbg(env);
8285     } else {
8286         gen_spr_book3s_207_dbg(env);
8287     }
8288 #if !defined(CONFIG_USER_ONLY)
8289     switch (version) {
8290     case BOOK3S_CPU_970:
8291     case BOOK3S_CPU_POWER5PLUS:
8292         env->slb_nr = 64;
8293         break;
8294     case BOOK3S_CPU_POWER7:
8295     case BOOK3S_CPU_POWER8:
8296     case BOOK3S_CPU_POWER9:
8297     default:
8298         env->slb_nr = 32;
8299         break;
8300     }
8301 #endif
8302     /* Allocate hardware IRQ controller */
8303     switch (version) {
8304     case BOOK3S_CPU_970:
8305     case BOOK3S_CPU_POWER5PLUS:
8306         init_excp_970(env);
8307         ppc970_irq_init(ppc_env_get_cpu(env));
8308         break;
8309     case BOOK3S_CPU_POWER7:
8310         init_excp_POWER7(env);
8311         ppcPOWER7_irq_init(ppc_env_get_cpu(env));
8312         break;
8313     case BOOK3S_CPU_POWER8:
8314     case BOOK3S_CPU_POWER9:
8315         init_excp_POWER8(env);
8316         ppcPOWER7_irq_init(ppc_env_get_cpu(env));
8317         break;
8318     default:
8319         g_assert_not_reached();
8320     }
8321
8322     env->dcache_line_size = 128;
8323     env->icache_line_size = 128;
8324 }
8325
8326 static void init_proc_970(CPUPPCState *env)
8327 {
8328     init_proc_book3s_64(env, BOOK3S_CPU_970);
8329 }
8330
8331 POWERPC_FAMILY(970)(ObjectClass *oc, void *data)
8332 {
8333     DeviceClass *dc = DEVICE_CLASS(oc);
8334     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8335
8336     dc->desc = "PowerPC 970";
8337     pcc->init_proc = init_proc_970;
8338     pcc->check_pow = check_pow_970;
8339     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
8340                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
8341                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
8342                        PPC_FLOAT_STFIWX |
8343                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
8344                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
8345                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
8346                        PPC_64B | PPC_ALTIVEC |
8347                        PPC_SEGMENT_64B | PPC_SLBI;
8348     pcc->insns_flags2 = PPC2_FP_CVT_S64;
8349     pcc->msr_mask = (1ull << MSR_SF) |
8350                     (1ull << MSR_VR) |
8351                     (1ull << MSR_POW) |
8352                     (1ull << MSR_EE) |
8353                     (1ull << MSR_PR) |
8354                     (1ull << MSR_FP) |
8355                     (1ull << MSR_ME) |
8356                     (1ull << MSR_FE0) |
8357                     (1ull << MSR_SE) |
8358                     (1ull << MSR_DE) |
8359                     (1ull << MSR_FE1) |
8360                     (1ull << MSR_IR) |
8361                     (1ull << MSR_DR) |
8362                     (1ull << MSR_PMM) |
8363                     (1ull << MSR_RI);
8364     pcc->mmu_model = POWERPC_MMU_64B;
8365 #if defined(CONFIG_SOFTMMU)
8366     pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
8367 #endif
8368     pcc->excp_model = POWERPC_EXCP_970;
8369     pcc->bus_model = PPC_FLAGS_INPUT_970;
8370     pcc->bfd_mach = bfd_mach_ppc64;
8371     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
8372                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
8373                  POWERPC_FLAG_BUS_CLK;
8374     pcc->l1_dcache_size = 0x8000;
8375     pcc->l1_icache_size = 0x10000;
8376 }
8377
8378 static void init_proc_power5plus(CPUPPCState *env)
8379 {
8380     init_proc_book3s_64(env, BOOK3S_CPU_POWER5PLUS);
8381 }
8382
8383 POWERPC_FAMILY(POWER5P)(ObjectClass *oc, void *data)
8384 {
8385     DeviceClass *dc = DEVICE_CLASS(oc);
8386     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8387
8388     dc->fw_name = "PowerPC,POWER5";
8389     dc->desc = "POWER5+";
8390     pcc->init_proc = init_proc_power5plus;
8391     pcc->check_pow = check_pow_970;
8392     pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
8393                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
8394                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
8395                        PPC_FLOAT_STFIWX |
8396                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
8397                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
8398                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
8399                        PPC_64B |
8400                        PPC_SEGMENT_64B | PPC_SLBI;
8401     pcc->insns_flags2 = PPC2_FP_CVT_S64;
8402     pcc->msr_mask = (1ull << MSR_SF) |
8403                     (1ull << MSR_VR) |
8404                     (1ull << MSR_POW) |
8405                     (1ull << MSR_EE) |
8406                     (1ull << MSR_PR) |
8407                     (1ull << MSR_FP) |
8408                     (1ull << MSR_ME) |
8409                     (1ull << MSR_FE0) |
8410                     (1ull << MSR_SE) |
8411                     (1ull << MSR_DE) |
8412                     (1ull << MSR_FE1) |
8413                     (1ull << MSR_IR) |
8414                     (1ull << MSR_DR) |
8415                     (1ull << MSR_PMM) |
8416                     (1ull << MSR_RI);
8417     pcc->mmu_model = POWERPC_MMU_2_03;
8418 #if defined(CONFIG_SOFTMMU)
8419     pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
8420 #endif
8421     pcc->excp_model = POWERPC_EXCP_970;
8422     pcc->bus_model = PPC_FLAGS_INPUT_970;
8423     pcc->bfd_mach = bfd_mach_ppc64;
8424     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
8425                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
8426                  POWERPC_FLAG_BUS_CLK;
8427     pcc->l1_dcache_size = 0x8000;
8428     pcc->l1_icache_size = 0x10000;
8429 }
8430
8431 static void powerpc_get_compat(Object *obj, Visitor *v, const char *name,
8432                                void *opaque, Error **errp)
8433 {
8434     char *value = (char *)"";
8435     Property *prop = opaque;
8436     uint32_t *max_compat = qdev_get_prop_ptr(DEVICE(obj), prop);
8437
8438     switch (*max_compat) {
8439     case CPU_POWERPC_LOGICAL_2_05:
8440         value = (char *)"power6";
8441         break;
8442     case CPU_POWERPC_LOGICAL_2_06:
8443         value = (char *)"power7";
8444         break;
8445     case CPU_POWERPC_LOGICAL_2_07:
8446         value = (char *)"power8";
8447         break;
8448     case 0:
8449         break;
8450     default:
8451         error_report("Internal error: compat is set to %x", *max_compat);
8452         abort();
8453         break;
8454     }
8455
8456     visit_type_str(v, name, &value, errp);
8457 }
8458
8459 static void powerpc_set_compat(Object *obj, Visitor *v, const char *name,
8460                                void *opaque, Error **errp)
8461 {
8462     Error *error = NULL;
8463     char *value = NULL;
8464     Property *prop = opaque;
8465     uint32_t *max_compat = qdev_get_prop_ptr(DEVICE(obj), prop);
8466
8467     visit_type_str(v, name, &value, &error);
8468     if (error) {
8469         error_propagate(errp, error);
8470         return;
8471     }
8472
8473     if (strcmp(value, "power6") == 0) {
8474         *max_compat = CPU_POWERPC_LOGICAL_2_05;
8475     } else if (strcmp(value, "power7") == 0) {
8476         *max_compat = CPU_POWERPC_LOGICAL_2_06;
8477     } else if (strcmp(value, "power8") == 0) {
8478         *max_compat = CPU_POWERPC_LOGICAL_2_07;
8479     } else {
8480         error_setg(errp, "Invalid compatibility mode \"%s\"", value);
8481     }
8482
8483     g_free(value);
8484 }
8485
8486 static PropertyInfo powerpc_compat_propinfo = {
8487     .name = "str",
8488     .description = "compatibility mode, power6/power7/power8",
8489     .get = powerpc_get_compat,
8490     .set = powerpc_set_compat,
8491 };
8492
8493 #define DEFINE_PROP_POWERPC_COMPAT(_n, _s, _f) \
8494     DEFINE_PROP(_n, _s, _f, powerpc_compat_propinfo, uint32_t)
8495
8496 static Property powerpc_servercpu_properties[] = {
8497     DEFINE_PROP_POWERPC_COMPAT("compat", PowerPCCPU, max_compat),
8498     DEFINE_PROP_END_OF_LIST(),
8499 };
8500
8501 #ifdef CONFIG_SOFTMMU
8502 static const struct ppc_segment_page_sizes POWER7_POWER8_sps = {
8503     .sps = {
8504         {
8505             .page_shift = 12, /* 4K */
8506             .slb_enc = 0,
8507             .enc = { { .page_shift = 12, .pte_enc = 0 },
8508                      { .page_shift = 16, .pte_enc = 0x7 },
8509                      { .page_shift = 24, .pte_enc = 0x38 }, },
8510         },
8511         {
8512             .page_shift = 16, /* 64K */
8513             .slb_enc = SLB_VSID_64K,
8514             .enc = { { .page_shift = 16, .pte_enc = 0x1 },
8515                      { .page_shift = 24, .pte_enc = 0x8 }, },
8516         },
8517         {
8518             .page_shift = 24, /* 16M */
8519             .slb_enc = SLB_VSID_16M,
8520             .enc = { { .page_shift = 24, .pte_enc = 0 }, },
8521         },
8522         {
8523             .page_shift = 34, /* 16G */
8524             .slb_enc = SLB_VSID_16G,
8525             .enc = { { .page_shift = 34, .pte_enc = 0x3 }, },
8526         },
8527     }
8528 };
8529 #endif /* CONFIG_SOFTMMU */
8530
8531 static void init_proc_POWER7 (CPUPPCState *env)
8532 {
8533     init_proc_book3s_64(env, BOOK3S_CPU_POWER7);
8534 }
8535
8536 static bool ppc_pvr_match_power7(PowerPCCPUClass *pcc, uint32_t pvr)
8537 {
8538     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER7P_BASE) {
8539         return true;
8540     }
8541     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER7_BASE) {
8542         return true;
8543     }
8544     return false;
8545 }
8546
8547 static bool cpu_has_work_POWER7(CPUState *cs)
8548 {
8549     PowerPCCPU *cpu = POWERPC_CPU(cs);
8550     CPUPPCState *env = &cpu->env;
8551
8552     if (cs->halted) {
8553         if (!(cs->interrupt_request & CPU_INTERRUPT_HARD)) {
8554             return false;
8555         }
8556         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_EXT)) &&
8557             (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
8558             return true;
8559         }
8560         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_DECR)) &&
8561             (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
8562             return true;
8563         }
8564         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_MCK)) &&
8565             (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
8566             return true;
8567         }
8568         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_HMI)) &&
8569             (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
8570             return true;
8571         }
8572         if (env->pending_interrupts & (1u << PPC_INTERRUPT_RESET)) {
8573             return true;
8574         }
8575         return false;
8576     } else {
8577         return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD);
8578     }
8579 }
8580
8581 POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data)
8582 {
8583     DeviceClass *dc = DEVICE_CLASS(oc);
8584     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8585     CPUClass *cc = CPU_CLASS(oc);
8586
8587     dc->fw_name = "PowerPC,POWER7";
8588     dc->desc = "POWER7";
8589     dc->props = powerpc_servercpu_properties;
8590     pcc->pvr_match = ppc_pvr_match_power7;
8591     pcc->pcr_mask = PCR_VEC_DIS | PCR_VSX_DIS | PCR_COMPAT_2_05;
8592     pcc->pcr_supported = PCR_COMPAT_2_06 | PCR_COMPAT_2_05;
8593     pcc->init_proc = init_proc_POWER7;
8594     pcc->check_pow = check_pow_nocheck;
8595     cc->has_work = cpu_has_work_POWER7;
8596     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_STRING | PPC_MFTB |
8597                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
8598                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
8599                        PPC_FLOAT_FRSQRTES |
8600                        PPC_FLOAT_STFIWX |
8601                        PPC_FLOAT_EXT |
8602                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
8603                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
8604                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
8605                        PPC_64B | PPC_64H | PPC_64BX | PPC_ALTIVEC |
8606                        PPC_SEGMENT_64B | PPC_SLBI |
8607                        PPC_POPCNTB | PPC_POPCNTWD |
8608                        PPC_CILDST;
8609     pcc->insns_flags2 = PPC2_VSX | PPC2_DFP | PPC2_DBRX | PPC2_ISA205 |
8610                         PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 |
8611                         PPC2_ATOMIC_ISA206 | PPC2_FP_CVT_ISA206 |
8612                         PPC2_FP_TST_ISA206 | PPC2_FP_CVT_S64 |
8613                         PPC2_PM_ISA206;
8614     pcc->msr_mask = (1ull << MSR_SF) |
8615                     (1ull << MSR_VR) |
8616                     (1ull << MSR_VSX) |
8617                     (1ull << MSR_EE) |
8618                     (1ull << MSR_PR) |
8619                     (1ull << MSR_FP) |
8620                     (1ull << MSR_ME) |
8621                     (1ull << MSR_FE0) |
8622                     (1ull << MSR_SE) |
8623                     (1ull << MSR_DE) |
8624                     (1ull << MSR_FE1) |
8625                     (1ull << MSR_IR) |
8626                     (1ull << MSR_DR) |
8627                     (1ull << MSR_PMM) |
8628                     (1ull << MSR_RI) |
8629                     (1ull << MSR_LE);
8630     pcc->mmu_model = POWERPC_MMU_2_06;
8631 #if defined(CONFIG_SOFTMMU)
8632     pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
8633     pcc->sps = &POWER7_POWER8_sps;
8634 #endif
8635     pcc->excp_model = POWERPC_EXCP_POWER7;
8636     pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
8637     pcc->bfd_mach = bfd_mach_ppc64;
8638     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
8639                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
8640                  POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR |
8641                  POWERPC_FLAG_VSX;
8642     pcc->l1_dcache_size = 0x8000;
8643     pcc->l1_icache_size = 0x8000;
8644     pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_lpcr;
8645 }
8646
8647 static void init_proc_POWER8(CPUPPCState *env)
8648 {
8649     init_proc_book3s_64(env, BOOK3S_CPU_POWER8);
8650 }
8651
8652 static bool ppc_pvr_match_power8(PowerPCCPUClass *pcc, uint32_t pvr)
8653 {
8654     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER8NVL_BASE) {
8655         return true;
8656     }
8657     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER8E_BASE) {
8658         return true;
8659     }
8660     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER8_BASE) {
8661         return true;
8662     }
8663     return false;
8664 }
8665
8666 static bool cpu_has_work_POWER8(CPUState *cs)
8667 {
8668     PowerPCCPU *cpu = POWERPC_CPU(cs);
8669     CPUPPCState *env = &cpu->env;
8670
8671     if (cs->halted) {
8672         if (!(cs->interrupt_request & CPU_INTERRUPT_HARD)) {
8673             return false;
8674         }
8675         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_EXT)) &&
8676             (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
8677             return true;
8678         }
8679         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_DECR)) &&
8680             (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
8681             return true;
8682         }
8683         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_MCK)) &&
8684             (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
8685             return true;
8686         }
8687         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_HMI)) &&
8688             (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
8689             return true;
8690         }
8691         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_DOORBELL)) &&
8692             (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
8693             return true;
8694         }
8695         if ((env->pending_interrupts & (1u << PPC_INTERRUPT_HDOORBELL)) &&
8696             (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
8697             return true;
8698         }
8699         if (env->pending_interrupts & (1u << PPC_INTERRUPT_RESET)) {
8700             return true;
8701         }
8702         return false;
8703     } else {
8704         return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD);
8705     }
8706 }
8707
8708 POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)
8709 {
8710     DeviceClass *dc = DEVICE_CLASS(oc);
8711     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8712     CPUClass *cc = CPU_CLASS(oc);
8713
8714     dc->fw_name = "PowerPC,POWER8";
8715     dc->desc = "POWER8";
8716     dc->props = powerpc_servercpu_properties;
8717     pcc->pvr_match = ppc_pvr_match_power8;
8718     pcc->pcr_mask = PCR_TM_DIS | PCR_COMPAT_2_06 | PCR_COMPAT_2_05;
8719     pcc->pcr_supported = PCR_COMPAT_2_07 | PCR_COMPAT_2_06 | PCR_COMPAT_2_05;
8720     pcc->init_proc = init_proc_POWER8;
8721     pcc->check_pow = check_pow_nocheck;
8722     cc->has_work = cpu_has_work_POWER8;
8723     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_STRING | PPC_MFTB |
8724                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
8725                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
8726                        PPC_FLOAT_FRSQRTES |
8727                        PPC_FLOAT_STFIWX |
8728                        PPC_FLOAT_EXT |
8729                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
8730                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
8731                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
8732                        PPC_64B | PPC_64H | PPC_64BX | PPC_ALTIVEC |
8733                        PPC_SEGMENT_64B | PPC_SLBI |
8734                        PPC_POPCNTB | PPC_POPCNTWD |
8735                        PPC_CILDST;
8736     pcc->insns_flags2 = PPC2_VSX | PPC2_VSX207 | PPC2_DFP | PPC2_DBRX |
8737                         PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 |
8738                         PPC2_ATOMIC_ISA206 | PPC2_FP_CVT_ISA206 |
8739                         PPC2_FP_TST_ISA206 | PPC2_BCTAR_ISA207 |
8740                         PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
8741                         PPC2_ISA205 | PPC2_ISA207S | PPC2_FP_CVT_S64 |
8742                         PPC2_TM | PPC2_PM_ISA206;
8743     pcc->msr_mask = (1ull << MSR_SF) |
8744                     (1ull << MSR_SHV) |
8745                     (1ull << MSR_TM) |
8746                     (1ull << MSR_VR) |
8747                     (1ull << MSR_VSX) |
8748                     (1ull << MSR_EE) |
8749                     (1ull << MSR_PR) |
8750                     (1ull << MSR_FP) |
8751                     (1ull << MSR_ME) |
8752                     (1ull << MSR_FE0) |
8753                     (1ull << MSR_SE) |
8754                     (1ull << MSR_DE) |
8755                     (1ull << MSR_FE1) |
8756                     (1ull << MSR_IR) |
8757                     (1ull << MSR_DR) |
8758                     (1ull << MSR_PMM) |
8759                     (1ull << MSR_RI) |
8760                     (1ull << MSR_LE);
8761     pcc->mmu_model = POWERPC_MMU_2_07;
8762 #if defined(CONFIG_SOFTMMU)
8763     pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
8764     pcc->sps = &POWER7_POWER8_sps;
8765 #endif
8766     pcc->excp_model = POWERPC_EXCP_POWER8;
8767     pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
8768     pcc->bfd_mach = bfd_mach_ppc64;
8769     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
8770                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
8771                  POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR |
8772                  POWERPC_FLAG_VSX | POWERPC_FLAG_TM;
8773     pcc->l1_dcache_size = 0x8000;
8774     pcc->l1_icache_size = 0x8000;
8775     pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_lpcr;
8776 }
8777 static void init_proc_POWER9(CPUPPCState *env)
8778 {
8779     init_proc_book3s_64(env, BOOK3S_CPU_POWER9);
8780 }
8781
8782 static bool ppc_pvr_match_power9(PowerPCCPUClass *pcc, uint32_t pvr)
8783 {
8784     if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER9_BASE) {
8785         return true;
8786     }
8787     return false;
8788 }
8789
8790 POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)
8791 {
8792     DeviceClass *dc = DEVICE_CLASS(oc);
8793     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8794
8795     dc->fw_name = "PowerPC,POWER9";
8796     dc->desc = "POWER9";
8797     dc->props = powerpc_servercpu_properties;
8798     pcc->pvr_match = ppc_pvr_match_power9;
8799     pcc->pcr_mask = PCR_COMPAT_2_05 | PCR_COMPAT_2_06 | PCR_COMPAT_2_07;
8800     pcc->init_proc = init_proc_POWER9;
8801     pcc->check_pow = check_pow_nocheck;
8802     pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_STRING | PPC_MFTB |
8803                        PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
8804                        PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
8805                        PPC_FLOAT_FRSQRTES |
8806                        PPC_FLOAT_STFIWX |
8807                        PPC_FLOAT_EXT |
8808                        PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
8809                        PPC_MEM_SYNC | PPC_MEM_EIEIO |
8810                        PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
8811                        PPC_64B | PPC_64BX | PPC_ALTIVEC |
8812                        PPC_SEGMENT_64B | PPC_SLBI |
8813                        PPC_POPCNTB | PPC_POPCNTWD |
8814                        PPC_CILDST;
8815     pcc->insns_flags2 = PPC2_VSX | PPC2_VSX207 | PPC2_DFP | PPC2_DBRX |
8816                         PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 |
8817                         PPC2_ATOMIC_ISA206 | PPC2_FP_CVT_ISA206 |
8818                         PPC2_FP_TST_ISA206 | PPC2_BCTAR_ISA207 |
8819                         PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
8820                         PPC2_ISA205 | PPC2_ISA207S | PPC2_FP_CVT_S64 |
8821                         PPC2_TM | PPC2_PM_ISA206 | PPC2_ISA300;
8822     pcc->msr_mask = (1ull << MSR_SF) |
8823                     (1ull << MSR_TM) |
8824                     (1ull << MSR_VR) |
8825                     (1ull << MSR_VSX) |
8826                     (1ull << MSR_EE) |
8827                     (1ull << MSR_PR) |
8828                     (1ull << MSR_FP) |
8829                     (1ull << MSR_ME) |
8830                     (1ull << MSR_FE0) |
8831                     (1ull << MSR_SE) |
8832                     (1ull << MSR_DE) |
8833                     (1ull << MSR_FE1) |
8834                     (1ull << MSR_IR) |
8835                     (1ull << MSR_DR) |
8836                     (1ull << MSR_PMM) |
8837                     (1ull << MSR_RI) |
8838                     (1ull << MSR_LE);
8839     /* Using 2.07 defines until new radix model is added. */
8840     pcc->mmu_model = POWERPC_MMU_2_07;
8841 #if defined(CONFIG_SOFTMMU)
8842     pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
8843     /* segment page size remain the same */
8844     pcc->sps = &POWER7_POWER8_sps;
8845 #endif
8846     pcc->excp_model = POWERPC_EXCP_POWER8;
8847     pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
8848     pcc->bfd_mach = bfd_mach_ppc64;
8849     pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
8850                  POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
8851                  POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR |
8852                  POWERPC_FLAG_VSX | POWERPC_FLAG_TM;
8853     pcc->l1_dcache_size = 0x8000;
8854     pcc->l1_icache_size = 0x8000;
8855     pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_lpcr;
8856 }
8857
8858 #if !defined(CONFIG_USER_ONLY)
8859
8860 void cpu_ppc_set_papr(PowerPCCPU *cpu)
8861 {
8862     CPUPPCState *env = &cpu->env;
8863     ppc_spr_t *lpcr = &env->spr_cb[SPR_LPCR];
8864     ppc_spr_t *amor = &env->spr_cb[SPR_AMOR];
8865
8866     /* PAPR always has exception vectors in RAM not ROM. To ensure this,
8867      * MSR[IP] should never be set.
8868      *
8869      * We also disallow setting of MSR_HV
8870      */
8871     env->msr_mask &= ~((1ull << MSR_EP) | MSR_HVB);
8872
8873     /* Set emulated LPCR to not send interrupts to hypervisor. Note that
8874      * under KVM, the actual HW LPCR will be set differently by KVM itself,
8875      * the settings below ensure proper operations with TCG in absence of
8876      * a real hypervisor.
8877      *
8878      * Clearing VPM0 will also cause us to use RMOR in mmu-hash64.c for
8879      * real mode accesses, which thankfully defaults to 0 and isn't
8880      * accessible in guest mode.
8881      */
8882     lpcr->default_value &= ~(LPCR_VPM0 | LPCR_VPM1 | LPCR_ISL | LPCR_KBV);
8883     lpcr->default_value |= LPCR_LPES0 | LPCR_LPES1;
8884
8885     /* Set RMLS to the max (ie, 16G) */
8886     lpcr->default_value &= ~LPCR_RMLS;
8887     lpcr->default_value |= 1ull << LPCR_RMLS_SHIFT;
8888
8889     /* P7 and P8 has slightly different PECE bits, mostly because P8 adds
8890      * bit 47 and 48 which are reserved on P7. Here we set them all, which
8891      * will work as expected for both implementations
8892      */
8893     lpcr->default_value |= LPCR_P8_PECE0 | LPCR_P8_PECE1 | LPCR_P8_PECE2 |
8894                            LPCR_P8_PECE3 | LPCR_P8_PECE4;
8895
8896     /* We should be followed by a CPU reset but update the active value
8897      * just in case...
8898      */
8899     env->spr[SPR_LPCR] = lpcr->default_value;
8900
8901     /* Set a full AMOR so guest can use the AMR as it sees fit */
8902     env->spr[SPR_AMOR] = amor->default_value = 0xffffffffffffffffull;
8903
8904     /* Update some env bits based on new LPCR value */
8905     ppc_hash64_update_rmls(env);
8906     ppc_hash64_update_vrma(env);
8907
8908     /* Tell KVM that we're in PAPR mode */
8909     if (kvm_enabled()) {
8910         kvmppc_set_papr(cpu);
8911     }
8912 }
8913
8914 #endif /* !defined(CONFIG_USER_ONLY) */
8915
8916 #endif /* defined (TARGET_PPC64) */
8917
8918 /*****************************************************************************/
8919 /* Generic CPU instantiation routine                                         */
8920 static void init_ppc_proc(PowerPCCPU *cpu)
8921 {
8922     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
8923     CPUPPCState *env = &cpu->env;
8924 #if !defined(CONFIG_USER_ONLY)
8925     int i;
8926
8927     env->irq_inputs = NULL;
8928     /* Set all exception vectors to an invalid address */
8929     for (i = 0; i < POWERPC_EXCP_NB; i++)
8930         env->excp_vectors[i] = (target_ulong)(-1ULL);
8931     env->ivor_mask = 0x00000000;
8932     env->ivpr_mask = 0x00000000;
8933     /* Default MMU definitions */
8934     env->nb_BATs = 0;
8935     env->nb_tlb = 0;
8936     env->nb_ways = 0;
8937     env->tlb_type = TLB_NONE;
8938 #endif
8939     /* Register SPR common to all PowerPC implementations */
8940     gen_spr_generic(env);
8941     spr_register(env, SPR_PVR, "PVR",
8942                  /* Linux permits userspace to read PVR */
8943 #if defined(CONFIG_LINUX_USER)
8944                  &spr_read_generic,
8945 #else
8946                  SPR_NOACCESS,
8947 #endif
8948                  SPR_NOACCESS,
8949                  &spr_read_generic, SPR_NOACCESS,
8950                  pcc->pvr);
8951     /* Register SVR if it's defined to anything else than POWERPC_SVR_NONE */
8952     if (pcc->svr != POWERPC_SVR_NONE) {
8953         if (pcc->svr & POWERPC_SVR_E500) {
8954             spr_register(env, SPR_E500_SVR, "SVR",
8955                          SPR_NOACCESS, SPR_NOACCESS,
8956                          &spr_read_generic, SPR_NOACCESS,
8957                          pcc->svr & ~POWERPC_SVR_E500);
8958         } else {
8959             spr_register(env, SPR_SVR, "SVR",
8960                          SPR_NOACCESS, SPR_NOACCESS,
8961                          &spr_read_generic, SPR_NOACCESS,
8962                          pcc->svr);
8963         }
8964     }
8965     /* PowerPC implementation specific initialisations (SPRs, timers, ...) */
8966     (*pcc->init_proc)(env);
8967
8968     /* MSR bits & flags consistency checks */
8969     if (env->msr_mask & (1 << 25)) {
8970         switch (env->flags & (POWERPC_FLAG_SPE | POWERPC_FLAG_VRE)) {
8971         case POWERPC_FLAG_SPE:
8972         case POWERPC_FLAG_VRE:
8973             break;
8974         default:
8975             fprintf(stderr, "PowerPC MSR definition inconsistency\n"
8976                     "Should define POWERPC_FLAG_SPE or POWERPC_FLAG_VRE\n");
8977             exit(1);
8978         }
8979     } else if (env->flags & (POWERPC_FLAG_SPE | POWERPC_FLAG_VRE)) {
8980         fprintf(stderr, "PowerPC MSR definition inconsistency\n"
8981                 "Should not define POWERPC_FLAG_SPE nor POWERPC_FLAG_VRE\n");
8982         exit(1);
8983     }
8984     if (env->msr_mask & (1 << 17)) {
8985         switch (env->flags & (POWERPC_FLAG_TGPR | POWERPC_FLAG_CE)) {
8986         case POWERPC_FLAG_TGPR:
8987         case POWERPC_FLAG_CE:
8988             break;
8989         default:
8990             fprintf(stderr, "PowerPC MSR definition inconsistency\n"
8991                     "Should define POWERPC_FLAG_TGPR or POWERPC_FLAG_CE\n");
8992             exit(1);
8993         }
8994     } else if (env->flags & (POWERPC_FLAG_TGPR | POWERPC_FLAG_CE)) {
8995         fprintf(stderr, "PowerPC MSR definition inconsistency\n"
8996                 "Should not define POWERPC_FLAG_TGPR nor POWERPC_FLAG_CE\n");
8997         exit(1);
8998     }
8999     if (env->msr_mask & (1 << 10)) {
9000         switch (env->flags & (POWERPC_FLAG_SE | POWERPC_FLAG_DWE |
9001                               POWERPC_FLAG_UBLE)) {
9002         case POWERPC_FLAG_SE:
9003         case POWERPC_FLAG_DWE:
9004         case POWERPC_FLAG_UBLE:
9005             break;
9006         default:
9007             fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9008                     "Should define POWERPC_FLAG_SE or POWERPC_FLAG_DWE or "
9009                     "POWERPC_FLAG_UBLE\n");
9010             exit(1);
9011         }
9012     } else if (env->flags & (POWERPC_FLAG_SE | POWERPC_FLAG_DWE |
9013                              POWERPC_FLAG_UBLE)) {
9014         fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9015                 "Should not define POWERPC_FLAG_SE nor POWERPC_FLAG_DWE nor "
9016                 "POWERPC_FLAG_UBLE\n");
9017             exit(1);
9018     }
9019     if (env->msr_mask & (1 << 9)) {
9020         switch (env->flags & (POWERPC_FLAG_BE | POWERPC_FLAG_DE)) {
9021         case POWERPC_FLAG_BE:
9022         case POWERPC_FLAG_DE:
9023             break;
9024         default:
9025             fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9026                     "Should define POWERPC_FLAG_BE or POWERPC_FLAG_DE\n");
9027             exit(1);
9028         }
9029     } else if (env->flags & (POWERPC_FLAG_BE | POWERPC_FLAG_DE)) {
9030         fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9031                 "Should not define POWERPC_FLAG_BE nor POWERPC_FLAG_DE\n");
9032         exit(1);
9033     }
9034     if (env->msr_mask & (1 << 2)) {
9035         switch (env->flags & (POWERPC_FLAG_PX | POWERPC_FLAG_PMM)) {
9036         case POWERPC_FLAG_PX:
9037         case POWERPC_FLAG_PMM:
9038             break;
9039         default:
9040             fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9041                     "Should define POWERPC_FLAG_PX or POWERPC_FLAG_PMM\n");
9042             exit(1);
9043         }
9044     } else if (env->flags & (POWERPC_FLAG_PX | POWERPC_FLAG_PMM)) {
9045         fprintf(stderr, "PowerPC MSR definition inconsistency\n"
9046                 "Should not define POWERPC_FLAG_PX nor POWERPC_FLAG_PMM\n");
9047         exit(1);
9048     }
9049     if ((env->flags & (POWERPC_FLAG_RTC_CLK | POWERPC_FLAG_BUS_CLK)) == 0) {
9050         fprintf(stderr, "PowerPC flags inconsistency\n"
9051                 "Should define the time-base and decrementer clock source\n");
9052         exit(1);
9053     }
9054     /* Allocate TLBs buffer when needed */
9055 #if !defined(CONFIG_USER_ONLY)
9056     if (env->nb_tlb != 0) {
9057         int nb_tlb = env->nb_tlb;
9058         if (env->id_tlbs != 0)
9059             nb_tlb *= 2;
9060         switch (env->tlb_type) {
9061         case TLB_6XX:
9062             env->tlb.tlb6 = g_malloc0(nb_tlb * sizeof(ppc6xx_tlb_t));
9063             break;
9064         case TLB_EMB:
9065             env->tlb.tlbe = g_malloc0(nb_tlb * sizeof(ppcemb_tlb_t));
9066             break;
9067         case TLB_MAS:
9068             env->tlb.tlbm = g_malloc0(nb_tlb * sizeof(ppcmas_tlb_t));
9069             break;
9070         }
9071         /* Pre-compute some useful values */
9072         env->tlb_per_way = env->nb_tlb / env->nb_ways;
9073     }
9074     if (env->irq_inputs == NULL) {
9075         fprintf(stderr, "WARNING: no internal IRQ controller registered.\n"
9076                 " Attempt QEMU to crash very soon !\n");
9077     }
9078 #endif
9079     if (env->check_pow == NULL) {
9080         fprintf(stderr, "WARNING: no power management check handler "
9081                 "registered.\n"
9082                 " Attempt QEMU to crash very soon !\n");
9083     }
9084 }
9085
9086 #if defined(PPC_DUMP_CPU)
9087 static void dump_ppc_sprs (CPUPPCState *env)
9088 {
9089     ppc_spr_t *spr;
9090 #if !defined(CONFIG_USER_ONLY)
9091     uint32_t sr, sw;
9092 #endif
9093     uint32_t ur, uw;
9094     int i, j, n;
9095
9096     printf("Special purpose registers:\n");
9097     for (i = 0; i < 32; i++) {
9098         for (j = 0; j < 32; j++) {
9099             n = (i << 5) | j;
9100             spr = &env->spr_cb[n];
9101             uw = spr->uea_write != NULL && spr->uea_write != SPR_NOACCESS;
9102             ur = spr->uea_read != NULL && spr->uea_read != SPR_NOACCESS;
9103 #if !defined(CONFIG_USER_ONLY)
9104             sw = spr->oea_write != NULL && spr->oea_write != SPR_NOACCESS;
9105             sr = spr->oea_read != NULL && spr->oea_read != SPR_NOACCESS;
9106             if (sw || sr || uw || ur) {
9107                 printf("SPR: %4d (%03x) %-8s s%c%c u%c%c\n",
9108                        (i << 5) | j, (i << 5) | j, spr->name,
9109                        sw ? 'w' : '-', sr ? 'r' : '-',
9110                        uw ? 'w' : '-', ur ? 'r' : '-');
9111             }
9112 #else
9113             if (uw || ur) {
9114                 printf("SPR: %4d (%03x) %-8s u%c%c\n",
9115                        (i << 5) | j, (i << 5) | j, spr->name,
9116                        uw ? 'w' : '-', ur ? 'r' : '-');
9117             }
9118 #endif
9119         }
9120     }
9121     fflush(stdout);
9122     fflush(stderr);
9123 }
9124 #endif
9125
9126 /*****************************************************************************/
9127
9128 /* Opcode types */
9129 enum {
9130     PPC_DIRECT   = 0, /* Opcode routine        */
9131     PPC_INDIRECT = 1, /* Indirect opcode table */
9132 };
9133
9134 #define PPC_OPCODE_MASK 0x3
9135
9136 static inline int is_indirect_opcode (void *handler)
9137 {
9138     return ((uintptr_t)handler & PPC_OPCODE_MASK) == PPC_INDIRECT;
9139 }
9140
9141 static inline opc_handler_t **ind_table(void *handler)
9142 {
9143     return (opc_handler_t **)((uintptr_t)handler & ~PPC_OPCODE_MASK);
9144 }
9145
9146 /* Instruction table creation */
9147 /* Opcodes tables creation */
9148 static void fill_new_table (opc_handler_t **table, int len)
9149 {
9150     int i;
9151
9152     for (i = 0; i < len; i++)
9153         table[i] = &invalid_handler;
9154 }
9155
9156 static int create_new_table (opc_handler_t **table, unsigned char idx)
9157 {
9158     opc_handler_t **tmp;
9159
9160     tmp = g_new(opc_handler_t *, PPC_CPU_INDIRECT_OPCODES_LEN);
9161     fill_new_table(tmp, PPC_CPU_INDIRECT_OPCODES_LEN);
9162     table[idx] = (opc_handler_t *)((uintptr_t)tmp | PPC_INDIRECT);
9163
9164     return 0;
9165 }
9166
9167 static int insert_in_table (opc_handler_t **table, unsigned char idx,
9168                             opc_handler_t *handler)
9169 {
9170     if (table[idx] != &invalid_handler)
9171         return -1;
9172     table[idx] = handler;
9173
9174     return 0;
9175 }
9176
9177 static int register_direct_insn (opc_handler_t **ppc_opcodes,
9178                                  unsigned char idx, opc_handler_t *handler)
9179 {
9180     if (insert_in_table(ppc_opcodes, idx, handler) < 0) {
9181         printf("*** ERROR: opcode %02x already assigned in main "
9182                "opcode table\n", idx);
9183 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9184         printf("           Registered handler '%s' - new handler '%s'\n",
9185                ppc_opcodes[idx]->oname, handler->oname);
9186 #endif
9187         return -1;
9188     }
9189
9190     return 0;
9191 }
9192
9193 static int register_ind_in_table (opc_handler_t **table,
9194                                   unsigned char idx1, unsigned char idx2,
9195                                   opc_handler_t *handler)
9196 {
9197     if (table[idx1] == &invalid_handler) {
9198         if (create_new_table(table, idx1) < 0) {
9199             printf("*** ERROR: unable to create indirect table "
9200                    "idx=%02x\n", idx1);
9201             return -1;
9202         }
9203     } else {
9204         if (!is_indirect_opcode(table[idx1])) {
9205             printf("*** ERROR: idx %02x already assigned to a direct "
9206                    "opcode\n", idx1);
9207 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9208             printf("           Registered handler '%s' - new handler '%s'\n",
9209                    ind_table(table[idx1])[idx2]->oname, handler->oname);
9210 #endif
9211             return -1;
9212         }
9213     }
9214     if (handler != NULL &&
9215         insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {
9216         printf("*** ERROR: opcode %02x already assigned in "
9217                "opcode table %02x\n", idx2, idx1);
9218 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9219         printf("           Registered handler '%s' - new handler '%s'\n",
9220                ind_table(table[idx1])[idx2]->oname, handler->oname);
9221 #endif
9222         return -1;
9223     }
9224
9225     return 0;
9226 }
9227
9228 static int register_ind_insn (opc_handler_t **ppc_opcodes,
9229                               unsigned char idx1, unsigned char idx2,
9230                               opc_handler_t *handler)
9231 {
9232     return register_ind_in_table(ppc_opcodes, idx1, idx2, handler);
9233 }
9234
9235 static int register_dblind_insn (opc_handler_t **ppc_opcodes,
9236                                  unsigned char idx1, unsigned char idx2,
9237                                  unsigned char idx3, opc_handler_t *handler)
9238 {
9239     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
9240         printf("*** ERROR: unable to join indirect table idx "
9241                "[%02x-%02x]\n", idx1, idx2);
9242         return -1;
9243     }
9244     if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,
9245                               handler) < 0) {
9246         printf("*** ERROR: unable to insert opcode "
9247                "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
9248         return -1;
9249     }
9250
9251     return 0;
9252 }
9253
9254 static int register_trplind_insn(opc_handler_t **ppc_opcodes,
9255                                  unsigned char idx1, unsigned char idx2,
9256                                  unsigned char idx3, unsigned char idx4,
9257                                  opc_handler_t *handler)
9258 {
9259     opc_handler_t **table;
9260
9261     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
9262         printf("*** ERROR: unable to join indirect table idx "
9263                "[%02x-%02x]\n", idx1, idx2);
9264         return -1;
9265     }
9266     table = ind_table(ppc_opcodes[idx1]);
9267     if (register_ind_in_table(table, idx2, idx3, NULL) < 0) {
9268         printf("*** ERROR: unable to join 2nd-level indirect table idx "
9269                "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
9270         return -1;
9271     }
9272     table = ind_table(table[idx2]);
9273     if (register_ind_in_table(table, idx3, idx4, handler) < 0) {
9274         printf("*** ERROR: unable to insert opcode "
9275                "[%02x-%02x-%02x-%02x]\n", idx1, idx2, idx3, idx4);
9276         return -1;
9277     }
9278     return 0;
9279 }
9280 static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)
9281 {
9282     if (insn->opc2 != 0xFF) {
9283         if (insn->opc3 != 0xFF) {
9284             if (insn->opc4 != 0xFF) {
9285                 if (register_trplind_insn(ppc_opcodes, insn->opc1, insn->opc2,
9286                                           insn->opc3, insn->opc4,
9287                                           &insn->handler) < 0) {
9288                     return -1;
9289                 }
9290             } else {
9291                 if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
9292                                          insn->opc3, &insn->handler) < 0)
9293                     return -1;
9294             }
9295         } else {
9296             if (register_ind_insn(ppc_opcodes, insn->opc1,
9297                                   insn->opc2, &insn->handler) < 0)
9298                 return -1;
9299         }
9300     } else {
9301         if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0)
9302             return -1;
9303     }
9304
9305     return 0;
9306 }
9307
9308 static int test_opcode_table (opc_handler_t **table, int len)
9309 {
9310     int i, count, tmp;
9311
9312     for (i = 0, count = 0; i < len; i++) {
9313         /* Consistency fixup */
9314         if (table[i] == NULL)
9315             table[i] = &invalid_handler;
9316         if (table[i] != &invalid_handler) {
9317             if (is_indirect_opcode(table[i])) {
9318                 tmp = test_opcode_table(ind_table(table[i]),
9319                     PPC_CPU_INDIRECT_OPCODES_LEN);
9320                 if (tmp == 0) {
9321                     free(table[i]);
9322                     table[i] = &invalid_handler;
9323                 } else {
9324                     count++;
9325                 }
9326             } else {
9327                 count++;
9328             }
9329         }
9330     }
9331
9332     return count;
9333 }
9334
9335 static void fix_opcode_tables (opc_handler_t **ppc_opcodes)
9336 {
9337     if (test_opcode_table(ppc_opcodes, PPC_CPU_OPCODES_LEN) == 0)
9338         printf("*** WARNING: no opcode defined !\n");
9339 }
9340
9341 /*****************************************************************************/
9342 static void create_ppc_opcodes(PowerPCCPU *cpu, Error **errp)
9343 {
9344     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
9345     CPUPPCState *env = &cpu->env;
9346     opcode_t *opc;
9347
9348     fill_new_table(env->opcodes, PPC_CPU_OPCODES_LEN);
9349     for (opc = opcodes; opc < &opcodes[ARRAY_SIZE(opcodes)]; opc++) {
9350         if (((opc->handler.type & pcc->insns_flags) != 0) ||
9351             ((opc->handler.type2 & pcc->insns_flags2) != 0)) {
9352             if (register_insn(env->opcodes, opc) < 0) {
9353                 error_setg(errp, "ERROR initializing PowerPC instruction "
9354                            "0x%02x 0x%02x 0x%02x", opc->opc1, opc->opc2,
9355                            opc->opc3);
9356                 return;
9357             }
9358         }
9359     }
9360     fix_opcode_tables(env->opcodes);
9361     fflush(stdout);
9362     fflush(stderr);
9363 }
9364
9365 #if defined(PPC_DUMP_CPU)
9366 static void dump_ppc_insns (CPUPPCState *env)
9367 {
9368     opc_handler_t **table, *handler;
9369     const char *p, *q;
9370     uint8_t opc1, opc2, opc3, opc4;
9371
9372     printf("Instructions set:\n");
9373     /* opc1 is 6 bits long */
9374     for (opc1 = 0x00; opc1 < PPC_CPU_OPCODES_LEN; opc1++) {
9375         table = env->opcodes;
9376         handler = table[opc1];
9377         if (is_indirect_opcode(handler)) {
9378             /* opc2 is 5 bits long */
9379             for (opc2 = 0; opc2 < PPC_CPU_INDIRECT_OPCODES_LEN; opc2++) {
9380                 table = env->opcodes;
9381                 handler = env->opcodes[opc1];
9382                 table = ind_table(handler);
9383                 handler = table[opc2];
9384                 if (is_indirect_opcode(handler)) {
9385                     table = ind_table(handler);
9386                     /* opc3 is 5 bits long */
9387                     for (opc3 = 0; opc3 < PPC_CPU_INDIRECT_OPCODES_LEN;
9388                             opc3++) {
9389                         handler = table[opc3];
9390                         if (is_indirect_opcode(handler)) {
9391                             table = ind_table(handler);
9392                             /* opc4 is 5 bits long */
9393                             for (opc4 = 0; opc4 < PPC_CPU_INDIRECT_OPCODES_LEN;
9394                                  opc4++) {
9395                                 handler = table[opc4];
9396                                 if (handler->handler != &gen_invalid) {
9397                                     printf("INSN: %02x %02x %02x %02x -- "
9398                                            "(%02d %04d %02d) : %s\n",
9399                                            opc1, opc2, opc3, opc4,
9400                                            opc1, (opc3 << 5) | opc2, opc4,
9401                                            handler->oname);
9402                                 }
9403                             }
9404                         } else {
9405                             if (handler->handler != &gen_invalid) {
9406                                 /* Special hack to properly dump SPE insns */
9407                                 p = strchr(handler->oname, '_');
9408                                 if (p == NULL) {
9409                                     printf("INSN: %02x %02x %02x (%02d %04d) : "
9410                                            "%s\n",
9411                                            opc1, opc2, opc3, opc1,
9412                                            (opc3 << 5) | opc2,
9413                                            handler->oname);
9414                                 } else {
9415                                     q = "speundef";
9416                                     if ((p - handler->oname) != strlen(q)
9417                                         || (memcmp(handler->oname, q, strlen(q))
9418                                             != 0)) {
9419                                         /* First instruction */
9420                                         printf("INSN: %02x %02x %02x"
9421                                                "(%02d %04d) : %.*s\n",
9422                                                opc1, opc2 << 1, opc3, opc1,
9423                                                (opc3 << 6) | (opc2 << 1),
9424                                                (int)(p - handler->oname),
9425                                                handler->oname);
9426                                     }
9427                                     if (strcmp(p + 1, q) != 0) {
9428                                         /* Second instruction */
9429                                         printf("INSN: %02x %02x %02x "
9430                                                "(%02d %04d) : %s\n", opc1,
9431                                                (opc2 << 1) | 1, opc3, opc1,
9432                                                (opc3 << 6) | (opc2 << 1) | 1,
9433                                                p + 1);
9434                                     }
9435                                 }
9436                             }
9437                         }
9438                     }
9439                 } else {
9440                     if (handler->handler != &gen_invalid) {
9441                         printf("INSN: %02x %02x -- (%02d %04d) : %s\n",
9442                                opc1, opc2, opc1, opc2, handler->oname);
9443                     }
9444                 }
9445             }
9446         } else {
9447             if (handler->handler != &gen_invalid) {
9448                 printf("INSN: %02x -- -- (%02d ----) : %s\n",
9449                        opc1, opc1, handler->oname);
9450             }
9451         }
9452     }
9453 }
9454 #endif
9455
9456 static bool avr_need_swap(CPUPPCState *env)
9457 {
9458 #ifdef HOST_WORDS_BIGENDIAN
9459     return msr_le;
9460 #else
9461     return !msr_le;
9462 #endif
9463 }
9464
9465 static int gdb_get_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9466 {
9467     if (n < 32) {
9468         stfq_p(mem_buf, env->fpr[n]);
9469         ppc_maybe_bswap_register(env, mem_buf, 8);
9470         return 8;
9471     }
9472     if (n == 32) {
9473         stl_p(mem_buf, env->fpscr);
9474         ppc_maybe_bswap_register(env, mem_buf, 4);
9475         return 4;
9476     }
9477     return 0;
9478 }
9479
9480 static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9481 {
9482     if (n < 32) {
9483         ppc_maybe_bswap_register(env, mem_buf, 8);
9484         env->fpr[n] = ldfq_p(mem_buf);
9485         return 8;
9486     }
9487     if (n == 32) {
9488         ppc_maybe_bswap_register(env, mem_buf, 4);
9489         helper_store_fpscr(env, ldl_p(mem_buf), 0xffffffff);
9490         return 4;
9491     }
9492     return 0;
9493 }
9494
9495 static int gdb_get_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9496 {
9497     if (n < 32) {
9498         if (!avr_need_swap(env)) {
9499             stq_p(mem_buf, env->avr[n].u64[0]);
9500             stq_p(mem_buf+8, env->avr[n].u64[1]);
9501         } else {
9502             stq_p(mem_buf, env->avr[n].u64[1]);
9503             stq_p(mem_buf+8, env->avr[n].u64[0]);
9504         }
9505         ppc_maybe_bswap_register(env, mem_buf, 8);
9506         ppc_maybe_bswap_register(env, mem_buf + 8, 8);
9507         return 16;
9508     }
9509     if (n == 32) {
9510         stl_p(mem_buf, env->vscr);
9511         ppc_maybe_bswap_register(env, mem_buf, 4);
9512         return 4;
9513     }
9514     if (n == 33) {
9515         stl_p(mem_buf, (uint32_t)env->spr[SPR_VRSAVE]);
9516         ppc_maybe_bswap_register(env, mem_buf, 4);
9517         return 4;
9518     }
9519     return 0;
9520 }
9521
9522 static int gdb_set_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9523 {
9524     if (n < 32) {
9525         ppc_maybe_bswap_register(env, mem_buf, 8);
9526         ppc_maybe_bswap_register(env, mem_buf + 8, 8);
9527         if (!avr_need_swap(env)) {
9528             env->avr[n].u64[0] = ldq_p(mem_buf);
9529             env->avr[n].u64[1] = ldq_p(mem_buf+8);
9530         } else {
9531             env->avr[n].u64[1] = ldq_p(mem_buf);
9532             env->avr[n].u64[0] = ldq_p(mem_buf+8);
9533         }
9534         return 16;
9535     }
9536     if (n == 32) {
9537         ppc_maybe_bswap_register(env, mem_buf, 4);
9538         env->vscr = ldl_p(mem_buf);
9539         return 4;
9540     }
9541     if (n == 33) {
9542         ppc_maybe_bswap_register(env, mem_buf, 4);
9543         env->spr[SPR_VRSAVE] = (target_ulong)ldl_p(mem_buf);
9544         return 4;
9545     }
9546     return 0;
9547 }
9548
9549 static int gdb_get_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9550 {
9551     if (n < 32) {
9552 #if defined(TARGET_PPC64)
9553         stl_p(mem_buf, env->gpr[n] >> 32);
9554         ppc_maybe_bswap_register(env, mem_buf, 4);
9555 #else
9556         stl_p(mem_buf, env->gprh[n]);
9557 #endif
9558         return 4;
9559     }
9560     if (n == 32) {
9561         stq_p(mem_buf, env->spe_acc);
9562         ppc_maybe_bswap_register(env, mem_buf, 8);
9563         return 8;
9564     }
9565     if (n == 33) {
9566         stl_p(mem_buf, env->spe_fscr);
9567         ppc_maybe_bswap_register(env, mem_buf, 4);
9568         return 4;
9569     }
9570     return 0;
9571 }
9572
9573 static int gdb_set_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9574 {
9575     if (n < 32) {
9576 #if defined(TARGET_PPC64)
9577         target_ulong lo = (uint32_t)env->gpr[n];
9578         target_ulong hi;
9579
9580         ppc_maybe_bswap_register(env, mem_buf, 4);
9581
9582         hi = (target_ulong)ldl_p(mem_buf) << 32;
9583         env->gpr[n] = lo | hi;
9584 #else
9585         env->gprh[n] = ldl_p(mem_buf);
9586 #endif
9587         return 4;
9588     }
9589     if (n == 32) {
9590         ppc_maybe_bswap_register(env, mem_buf, 8);
9591         env->spe_acc = ldq_p(mem_buf);
9592         return 8;
9593     }
9594     if (n == 33) {
9595         ppc_maybe_bswap_register(env, mem_buf, 4);
9596         env->spe_fscr = ldl_p(mem_buf);
9597         return 4;
9598     }
9599     return 0;
9600 }
9601
9602 static int gdb_get_vsx_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9603 {
9604     if (n < 32) {
9605         stq_p(mem_buf, env->vsr[n]);
9606         ppc_maybe_bswap_register(env, mem_buf, 8);
9607         return 8;
9608     }
9609     return 0;
9610 }
9611
9612 static int gdb_set_vsx_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
9613 {
9614     if (n < 32) {
9615         ppc_maybe_bswap_register(env, mem_buf, 8);
9616         env->vsr[n] = ldq_p(mem_buf);
9617         return 8;
9618     }
9619     return 0;
9620 }
9621
9622 static int ppc_fixup_cpu(PowerPCCPU *cpu)
9623 {
9624     CPUPPCState *env = &cpu->env;
9625
9626     /* TCG doesn't (yet) emulate some groups of instructions that
9627      * are implemented on some otherwise supported CPUs (e.g. VSX
9628      * and decimal floating point instructions on POWER7).  We
9629      * remove unsupported instruction groups from the cpu state's
9630      * instruction masks and hope the guest can cope.  For at
9631      * least the pseries machine, the unavailability of these
9632      * instructions can be advertised to the guest via the device
9633      * tree. */
9634     if ((env->insns_flags & ~PPC_TCG_INSNS)
9635         || (env->insns_flags2 & ~PPC_TCG_INSNS2)) {
9636         fprintf(stderr, "Warning: Disabling some instructions which are not "
9637                 "emulated by TCG (0x%" PRIx64 ", 0x%" PRIx64 ")\n",
9638                 env->insns_flags & ~PPC_TCG_INSNS,
9639                 env->insns_flags2 & ~PPC_TCG_INSNS2);
9640     }
9641     env->insns_flags &= PPC_TCG_INSNS;
9642     env->insns_flags2 &= PPC_TCG_INSNS2;
9643     return 0;
9644 }
9645
9646 static inline bool ppc_cpu_is_valid(PowerPCCPUClass *pcc)
9647 {
9648 #ifdef TARGET_PPCEMB
9649     return pcc->mmu_model == POWERPC_MMU_BOOKE ||
9650            pcc->mmu_model == POWERPC_MMU_SOFT_4xx ||
9651            pcc->mmu_model == POWERPC_MMU_SOFT_4xx_Z;
9652 #else
9653     return true;
9654 #endif
9655 }
9656
9657 static void ppc_cpu_realizefn(DeviceState *dev, Error **errp)
9658 {
9659     CPUState *cs = CPU(dev);
9660     PowerPCCPU *cpu = POWERPC_CPU(dev);
9661     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
9662     Error *local_err = NULL;
9663 #if !defined(CONFIG_USER_ONLY)
9664     int max_smt = kvmppc_smt_threads();
9665 #endif
9666
9667 #if !defined(CONFIG_USER_ONLY)
9668     if (smp_threads > max_smt) {
9669         error_setg(errp, "Cannot support more than %d threads on PPC with %s",
9670                    max_smt, kvm_enabled() ? "KVM" : "TCG");
9671         return;
9672     }
9673     if (!is_power_of_2(smp_threads)) {
9674         error_setg(errp, "Cannot support %d threads on PPC with %s, "
9675                    "threads count must be a power of 2.",
9676                    smp_threads, kvm_enabled() ? "KVM" : "TCG");
9677         return;
9678     }
9679 #endif
9680
9681     cpu_exec_realizefn(cs, &local_err);
9682     if (local_err != NULL) {
9683         error_propagate(errp, local_err);
9684         return;
9685     }
9686
9687 #if !defined(CONFIG_USER_ONLY)
9688     cpu->cpu_dt_id = (cs->cpu_index / smp_threads) * max_smt
9689         + (cs->cpu_index % smp_threads);
9690
9691     if (kvm_enabled() && !kvm_vcpu_id_is_valid(cpu->cpu_dt_id)) {
9692         error_setg(errp, "Can't create CPU with id %d in KVM", cpu->cpu_dt_id);
9693         error_append_hint(errp, "Adjust the number of cpus to %d "
9694                           "or try to raise the number of threads per core\n",
9695                           cpu->cpu_dt_id * smp_threads / max_smt);
9696         return;
9697     }
9698 #endif
9699
9700     if (tcg_enabled()) {
9701         if (ppc_fixup_cpu(cpu) != 0) {
9702             error_setg(errp, "Unable to emulate selected CPU with TCG");
9703             return;
9704         }
9705     }
9706
9707 #if defined(TARGET_PPCEMB)
9708     if (!ppc_cpu_is_valid(pcc)) {
9709         error_setg(errp, "CPU does not possess a BookE or 4xx MMU. "
9710                    "Please use qemu-system-ppc or qemu-system-ppc64 instead "
9711                    "or choose another CPU model.");
9712         return;
9713     }
9714 #endif
9715
9716     create_ppc_opcodes(cpu, &local_err);
9717     if (local_err != NULL) {
9718         error_propagate(errp, local_err);
9719         return;
9720     }
9721     init_ppc_proc(cpu);
9722
9723     if (pcc->insns_flags & PPC_FLOAT) {
9724         gdb_register_coprocessor(cs, gdb_get_float_reg, gdb_set_float_reg,
9725                                  33, "power-fpu.xml", 0);
9726     }
9727     if (pcc->insns_flags & PPC_ALTIVEC) {
9728         gdb_register_coprocessor(cs, gdb_get_avr_reg, gdb_set_avr_reg,
9729                                  34, "power-altivec.xml", 0);
9730     }
9731     if (pcc->insns_flags & PPC_SPE) {
9732         gdb_register_coprocessor(cs, gdb_get_spe_reg, gdb_set_spe_reg,
9733                                  34, "power-spe.xml", 0);
9734     }
9735     if (pcc->insns_flags2 & PPC2_VSX) {
9736         gdb_register_coprocessor(cs, gdb_get_vsx_reg, gdb_set_vsx_reg,
9737                                  32, "power-vsx.xml", 0);
9738     }
9739
9740     qemu_init_vcpu(cs);
9741
9742     pcc->parent_realize(dev, errp);
9743
9744 #if defined(PPC_DUMP_CPU)
9745     {
9746         CPUPPCState *env = &cpu->env;
9747         const char *mmu_model, *excp_model, *bus_model;
9748         switch (env->mmu_model) {
9749         case POWERPC_MMU_32B:
9750             mmu_model = "PowerPC 32";
9751             break;
9752         case POWERPC_MMU_SOFT_6xx:
9753             mmu_model = "PowerPC 6xx/7xx with software driven TLBs";
9754             break;
9755         case POWERPC_MMU_SOFT_74xx:
9756             mmu_model = "PowerPC 74xx with software driven TLBs";
9757             break;
9758         case POWERPC_MMU_SOFT_4xx:
9759             mmu_model = "PowerPC 4xx with software driven TLBs";
9760             break;
9761         case POWERPC_MMU_SOFT_4xx_Z:
9762             mmu_model = "PowerPC 4xx with software driven TLBs "
9763                 "and zones protections";
9764             break;
9765         case POWERPC_MMU_REAL:
9766             mmu_model = "PowerPC real mode only";
9767             break;
9768         case POWERPC_MMU_MPC8xx:
9769             mmu_model = "PowerPC MPC8xx";
9770             break;
9771         case POWERPC_MMU_BOOKE:
9772             mmu_model = "PowerPC BookE";
9773             break;
9774         case POWERPC_MMU_BOOKE206:
9775             mmu_model = "PowerPC BookE 2.06";
9776             break;
9777         case POWERPC_MMU_601:
9778             mmu_model = "PowerPC 601";
9779             break;
9780 #if defined (TARGET_PPC64)
9781         case POWERPC_MMU_64B:
9782             mmu_model = "PowerPC 64";
9783             break;
9784 #endif
9785         default:
9786             mmu_model = "Unknown or invalid";
9787             break;
9788         }
9789         switch (env->excp_model) {
9790         case POWERPC_EXCP_STD:
9791             excp_model = "PowerPC";
9792             break;
9793         case POWERPC_EXCP_40x:
9794             excp_model = "PowerPC 40x";
9795             break;
9796         case POWERPC_EXCP_601:
9797             excp_model = "PowerPC 601";
9798             break;
9799         case POWERPC_EXCP_602:
9800             excp_model = "PowerPC 602";
9801             break;
9802         case POWERPC_EXCP_603:
9803             excp_model = "PowerPC 603";
9804             break;
9805         case POWERPC_EXCP_603E:
9806             excp_model = "PowerPC 603e";
9807             break;
9808         case POWERPC_EXCP_604:
9809             excp_model = "PowerPC 604";
9810             break;
9811         case POWERPC_EXCP_7x0:
9812             excp_model = "PowerPC 740/750";
9813             break;
9814         case POWERPC_EXCP_7x5:
9815             excp_model = "PowerPC 745/755";
9816             break;
9817         case POWERPC_EXCP_74xx:
9818             excp_model = "PowerPC 74xx";
9819             break;
9820         case POWERPC_EXCP_BOOKE:
9821             excp_model = "PowerPC BookE";
9822             break;
9823 #if defined (TARGET_PPC64)
9824         case POWERPC_EXCP_970:
9825             excp_model = "PowerPC 970";
9826             break;
9827 #endif
9828         default:
9829             excp_model = "Unknown or invalid";
9830             break;
9831         }
9832         switch (env->bus_model) {
9833         case PPC_FLAGS_INPUT_6xx:
9834             bus_model = "PowerPC 6xx";
9835             break;
9836         case PPC_FLAGS_INPUT_BookE:
9837             bus_model = "PowerPC BookE";
9838             break;
9839         case PPC_FLAGS_INPUT_405:
9840             bus_model = "PowerPC 405";
9841             break;
9842         case PPC_FLAGS_INPUT_401:
9843             bus_model = "PowerPC 401/403";
9844             break;
9845         case PPC_FLAGS_INPUT_RCPU:
9846             bus_model = "RCPU / MPC8xx";
9847             break;
9848 #if defined (TARGET_PPC64)
9849         case PPC_FLAGS_INPUT_970:
9850             bus_model = "PowerPC 970";
9851             break;
9852 #endif
9853         default:
9854             bus_model = "Unknown or invalid";
9855             break;
9856         }
9857         printf("PowerPC %-12s : PVR %08x MSR %016" PRIx64 "\n"
9858                "    MMU model        : %s\n",
9859                object_class_get_name(OBJECT_CLASS(pcc)),
9860                pcc->pvr, pcc->msr_mask, mmu_model);
9861 #if !defined(CONFIG_USER_ONLY)
9862         if (env->tlb.tlb6) {
9863             printf("                       %d %s TLB in %d ways\n",
9864                    env->nb_tlb, env->id_tlbs ? "splitted" : "merged",
9865                    env->nb_ways);
9866         }
9867 #endif
9868         printf("    Exceptions model : %s\n"
9869                "    Bus model        : %s\n",
9870                excp_model, bus_model);
9871         printf("    MSR features     :\n");
9872         if (env->flags & POWERPC_FLAG_SPE)
9873             printf("                        signal processing engine enable"
9874                    "\n");
9875         else if (env->flags & POWERPC_FLAG_VRE)
9876             printf("                        vector processor enable\n");
9877         if (env->flags & POWERPC_FLAG_TGPR)
9878             printf("                        temporary GPRs\n");
9879         else if (env->flags & POWERPC_FLAG_CE)
9880             printf("                        critical input enable\n");
9881         if (env->flags & POWERPC_FLAG_SE)
9882             printf("                        single-step trace mode\n");
9883         else if (env->flags & POWERPC_FLAG_DWE)
9884             printf("                        debug wait enable\n");
9885         else if (env->flags & POWERPC_FLAG_UBLE)
9886             printf("                        user BTB lock enable\n");
9887         if (env->flags & POWERPC_FLAG_BE)
9888             printf("                        branch-step trace mode\n");
9889         else if (env->flags & POWERPC_FLAG_DE)
9890             printf("                        debug interrupt enable\n");
9891         if (env->flags & POWERPC_FLAG_PX)
9892             printf("                        inclusive protection\n");
9893         else if (env->flags & POWERPC_FLAG_PMM)
9894             printf("                        performance monitor mark\n");
9895         if (env->flags == POWERPC_FLAG_NONE)
9896             printf("                        none\n");
9897         printf("    Time-base/decrementer clock source: %s\n",
9898                env->flags & POWERPC_FLAG_RTC_CLK ? "RTC clock" : "bus clock");
9899         dump_ppc_insns(env);
9900         dump_ppc_sprs(env);
9901         fflush(stdout);
9902     }
9903 #endif
9904 }
9905
9906 static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
9907 {
9908     PowerPCCPU *cpu = POWERPC_CPU(dev);
9909     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
9910     CPUPPCState *env = &cpu->env;
9911     Error *local_err = NULL;
9912     opc_handler_t **table, **table_2;
9913     int i, j, k;
9914
9915     pcc->parent_unrealize(dev, &local_err);
9916     if (local_err != NULL) {
9917         error_propagate(errp, local_err);
9918         return;
9919     }
9920
9921     for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
9922         if (env->opcodes[i] == &invalid_handler) {
9923             continue;
9924         }
9925         if (is_indirect_opcode(env->opcodes[i])) {
9926             table = ind_table(env->opcodes[i]);
9927             for (j = 0; j < PPC_CPU_INDIRECT_OPCODES_LEN; j++) {
9928                 if (table[j] == &invalid_handler) {
9929                     continue;
9930                 }
9931                 if (is_indirect_opcode(table[j])) {
9932                     table_2 = ind_table(table[j]);
9933                     for (k = 0; k < PPC_CPU_INDIRECT_OPCODES_LEN; k++) {
9934                         if (table_2[k] != &invalid_handler &&
9935                             is_indirect_opcode(table_2[k])) {
9936                             g_free((opc_handler_t *)((uintptr_t)table_2[k] &
9937                                                      ~PPC_INDIRECT));
9938                         }
9939                     }
9940                     g_free((opc_handler_t *)((uintptr_t)table[j] &
9941                                              ~PPC_INDIRECT));
9942                 }
9943             }
9944             g_free((opc_handler_t *)((uintptr_t)env->opcodes[i] &
9945                 ~PPC_INDIRECT));
9946         }
9947     }
9948 }
9949
9950 int ppc_get_compat_smt_threads(PowerPCCPU *cpu)
9951 {
9952     CPUState *cs = CPU(cpu);
9953     int ret = MIN(cs->nr_threads, kvmppc_smt_threads());
9954
9955     switch (cpu->cpu_version) {
9956     case CPU_POWERPC_LOGICAL_2_05:
9957         ret = MIN(ret, 2);
9958         break;
9959     case CPU_POWERPC_LOGICAL_2_06:
9960         ret = MIN(ret, 4);
9961         break;
9962     case CPU_POWERPC_LOGICAL_2_07:
9963         ret = MIN(ret, 8);
9964         break;
9965     }
9966
9967     return ret;
9968 }
9969
9970 #ifdef TARGET_PPC64
9971 void ppc_set_compat(PowerPCCPU *cpu, uint32_t cpu_version, Error **errp)
9972 {
9973     int ret = 0;
9974     CPUPPCState *env = &cpu->env;
9975     PowerPCCPUClass *host_pcc;
9976
9977     cpu->cpu_version = cpu_version;
9978
9979     switch (cpu_version) {
9980     case CPU_POWERPC_LOGICAL_2_05:
9981         env->spr[SPR_PCR] = PCR_TM_DIS | PCR_VSX_DIS | PCR_COMPAT_2_07 |
9982                             PCR_COMPAT_2_06 | PCR_COMPAT_2_05;
9983         break;
9984     case CPU_POWERPC_LOGICAL_2_06:
9985     case CPU_POWERPC_LOGICAL_2_06_PLUS:
9986         env->spr[SPR_PCR] = PCR_TM_DIS | PCR_COMPAT_2_07 | PCR_COMPAT_2_06;
9987         break;
9988     case CPU_POWERPC_LOGICAL_2_07:
9989         env->spr[SPR_PCR] = PCR_COMPAT_2_07;
9990         break;
9991     default:
9992         env->spr[SPR_PCR] = 0;
9993         break;
9994     }
9995
9996     host_pcc = kvm_ppc_get_host_cpu_class();
9997     if (host_pcc) {
9998         env->spr[SPR_PCR] &= host_pcc->pcr_mask;
9999     }
10000
10001     if (kvm_enabled()) {
10002         ret = kvmppc_set_compat(cpu, cpu->cpu_version);
10003         if (ret < 0) {
10004             error_setg_errno(errp, -ret,
10005                              "Unable to set CPU compatibility mode in KVM");
10006         }
10007     }
10008 }
10009 #endif
10010
10011 static gint ppc_cpu_compare_class_pvr(gconstpointer a, gconstpointer b)
10012 {
10013     ObjectClass *oc = (ObjectClass *)a;
10014     uint32_t pvr = *(uint32_t *)b;
10015     PowerPCCPUClass *pcc = (PowerPCCPUClass *)a;
10016
10017     /* -cpu host does a PVR lookup during construction */
10018     if (unlikely(strcmp(object_class_get_name(oc),
10019                         TYPE_HOST_POWERPC_CPU) == 0)) {
10020         return -1;
10021     }
10022
10023     if (!ppc_cpu_is_valid(pcc)) {
10024         return -1;
10025     }
10026
10027     return pcc->pvr == pvr ? 0 : -1;
10028 }
10029
10030 PowerPCCPUClass *ppc_cpu_class_by_pvr(uint32_t pvr)
10031 {
10032     GSList *list, *item;
10033     PowerPCCPUClass *pcc = NULL;
10034
10035     list = object_class_get_list(TYPE_POWERPC_CPU, false);
10036     item = g_slist_find_custom(list, &pvr, ppc_cpu_compare_class_pvr);
10037     if (item != NULL) {
10038         pcc = POWERPC_CPU_CLASS(item->data);
10039     }
10040     g_slist_free(list);
10041
10042     return pcc;
10043 }
10044
10045 static gint ppc_cpu_compare_class_pvr_mask(gconstpointer a, gconstpointer b)
10046 {
10047     ObjectClass *oc = (ObjectClass *)a;
10048     uint32_t pvr = *(uint32_t *)b;
10049     PowerPCCPUClass *pcc = (PowerPCCPUClass *)a;
10050
10051     /* -cpu host does a PVR lookup during construction */
10052     if (unlikely(strcmp(object_class_get_name(oc),
10053                         TYPE_HOST_POWERPC_CPU) == 0)) {
10054         return -1;
10055     }
10056
10057     if (!ppc_cpu_is_valid(pcc)) {
10058         return -1;
10059     }
10060
10061     if (pcc->pvr_match(pcc, pvr)) {
10062         return 0;
10063     }
10064
10065     return -1;
10066 }
10067
10068 PowerPCCPUClass *ppc_cpu_class_by_pvr_mask(uint32_t pvr)
10069 {
10070     GSList *list, *item;
10071     PowerPCCPUClass *pcc = NULL;
10072
10073     list = object_class_get_list(TYPE_POWERPC_CPU, true);
10074     item = g_slist_find_custom(list, &pvr, ppc_cpu_compare_class_pvr_mask);
10075     if (item != NULL) {
10076         pcc = POWERPC_CPU_CLASS(item->data);
10077     }
10078     g_slist_free(list);
10079
10080     return pcc;
10081 }
10082
10083 static gint ppc_cpu_compare_class_name(gconstpointer a, gconstpointer b)
10084 {
10085     ObjectClass *oc = (ObjectClass *)a;
10086     const char *name = b;
10087     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
10088
10089     if (strncasecmp(name, object_class_get_name(oc), strlen(name)) == 0 &&
10090         ppc_cpu_is_valid(pcc) &&
10091         strcmp(object_class_get_name(oc) + strlen(name),
10092                "-" TYPE_POWERPC_CPU) == 0) {
10093         return 0;
10094     }
10095     return -1;
10096 }
10097
10098
10099 static ObjectClass *ppc_cpu_class_by_name(const char *name);
10100
10101 static ObjectClass *ppc_cpu_class_by_alias(PowerPCCPUAlias *alias)
10102 {
10103     ObjectClass *invalid_class = (void*)ppc_cpu_class_by_alias;
10104
10105     /* Cache target class lookups in the alias table */
10106     if (!alias->oc) {
10107         alias->oc = ppc_cpu_class_by_name(alias->model);
10108         if (!alias->oc) {
10109             /* Fast check for non-existing aliases */
10110             alias->oc = invalid_class;
10111         }
10112     }
10113
10114     if (alias->oc == invalid_class) {
10115         return NULL;
10116     } else {
10117         return alias->oc;
10118     }
10119 }
10120
10121 static ObjectClass *ppc_cpu_class_by_name(const char *name)
10122 {
10123     GSList *list, *item;
10124     ObjectClass *ret = NULL;
10125     const char *p;
10126     int i, len;
10127
10128     /* Check if the given name is a PVR */
10129     len = strlen(name);
10130     if (len == 10 && name[0] == '0' && name[1] == 'x') {
10131         p = name + 2;
10132         goto check_pvr;
10133     } else if (len == 8) {
10134         p = name;
10135     check_pvr:
10136         for (i = 0; i < 8; i++) {
10137             if (!qemu_isxdigit(*p++))
10138                 break;
10139         }
10140         if (i == 8) {
10141             return OBJECT_CLASS(ppc_cpu_class_by_pvr(strtoul(name, NULL, 16)));
10142         }
10143     }
10144
10145     list = object_class_get_list(TYPE_POWERPC_CPU, false);
10146     item = g_slist_find_custom(list, name, ppc_cpu_compare_class_name);
10147     if (item != NULL) {
10148         ret = OBJECT_CLASS(item->data);
10149     }
10150     g_slist_free(list);
10151
10152     if (ret) {
10153         return ret;
10154     }
10155
10156     for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
10157         if (strcmp(ppc_cpu_aliases[i].alias, name) == 0) {
10158             return ppc_cpu_class_by_alias(&ppc_cpu_aliases[i]);
10159         }
10160     }
10161
10162     return NULL;
10163 }
10164
10165 const char *ppc_cpu_lookup_alias(const char *alias)
10166 {
10167     int ai;
10168
10169     for (ai = 0; ppc_cpu_aliases[ai].alias != NULL; ai++) {
10170         if (strcmp(ppc_cpu_aliases[ai].alias, alias) == 0) {
10171             return ppc_cpu_aliases[ai].model;
10172         }
10173     }
10174
10175     return NULL;
10176 }
10177
10178 PowerPCCPU *cpu_ppc_init(const char *cpu_model)
10179 {
10180     return POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU, cpu_model));
10181 }
10182
10183 /* Sort by PVR, ordering special case "host" last. */
10184 static gint ppc_cpu_list_compare(gconstpointer a, gconstpointer b)
10185 {
10186     ObjectClass *oc_a = (ObjectClass *)a;
10187     ObjectClass *oc_b = (ObjectClass *)b;
10188     PowerPCCPUClass *pcc_a = POWERPC_CPU_CLASS(oc_a);
10189     PowerPCCPUClass *pcc_b = POWERPC_CPU_CLASS(oc_b);
10190     const char *name_a = object_class_get_name(oc_a);
10191     const char *name_b = object_class_get_name(oc_b);
10192
10193     if (strcmp(name_a, TYPE_HOST_POWERPC_CPU) == 0) {
10194         return 1;
10195     } else if (strcmp(name_b, TYPE_HOST_POWERPC_CPU) == 0) {
10196         return -1;
10197     } else {
10198         /* Avoid an integer overflow during subtraction */
10199         if (pcc_a->pvr < pcc_b->pvr) {
10200             return -1;
10201         } else if (pcc_a->pvr > pcc_b->pvr) {
10202             return 1;
10203         } else {
10204             return 0;
10205         }
10206     }
10207 }
10208
10209 static void ppc_cpu_list_entry(gpointer data, gpointer user_data)
10210 {
10211     ObjectClass *oc = data;
10212     CPUListState *s = user_data;
10213     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
10214     const char *typename = object_class_get_name(oc);
10215     char *name;
10216     int i;
10217
10218     if (!ppc_cpu_is_valid(pcc)) {
10219         return;
10220     }
10221     if (unlikely(strcmp(typename, TYPE_HOST_POWERPC_CPU) == 0)) {
10222         return;
10223     }
10224
10225     name = g_strndup(typename,
10226                      strlen(typename) - strlen("-" TYPE_POWERPC_CPU));
10227     (*s->cpu_fprintf)(s->file, "PowerPC %-16s PVR %08x\n",
10228                       name, pcc->pvr);
10229     for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
10230         PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
10231         ObjectClass *alias_oc = ppc_cpu_class_by_alias(alias);
10232
10233         if (alias_oc != oc) {
10234             continue;
10235         }
10236         (*s->cpu_fprintf)(s->file, "PowerPC %-16s (alias for %s)\n",
10237                           alias->alias, name);
10238     }
10239     g_free(name);
10240 }
10241
10242 void ppc_cpu_list(FILE *f, fprintf_function cpu_fprintf)
10243 {
10244     CPUListState s = {
10245         .file = f,
10246         .cpu_fprintf = cpu_fprintf,
10247     };
10248     GSList *list;
10249
10250     list = object_class_get_list(TYPE_POWERPC_CPU, false);
10251     list = g_slist_sort(list, ppc_cpu_list_compare);
10252     g_slist_foreach(list, ppc_cpu_list_entry, &s);
10253     g_slist_free(list);
10254
10255 #ifdef CONFIG_KVM
10256     cpu_fprintf(f, "\n");
10257     cpu_fprintf(f, "PowerPC %-16s\n", "host");
10258 #endif
10259 }
10260
10261 static void ppc_cpu_defs_entry(gpointer data, gpointer user_data)
10262 {
10263     ObjectClass *oc = data;
10264     CpuDefinitionInfoList **first = user_data;
10265     const char *typename;
10266     CpuDefinitionInfoList *entry;
10267     CpuDefinitionInfo *info;
10268     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
10269
10270     if (!ppc_cpu_is_valid(pcc)) {
10271         return;
10272     }
10273
10274     typename = object_class_get_name(oc);
10275     info = g_malloc0(sizeof(*info));
10276     info->name = g_strndup(typename,
10277                            strlen(typename) - strlen("-" TYPE_POWERPC_CPU));
10278
10279     entry = g_malloc0(sizeof(*entry));
10280     entry->value = info;
10281     entry->next = *first;
10282     *first = entry;
10283 }
10284
10285 CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp)
10286 {
10287     CpuDefinitionInfoList *cpu_list = NULL;
10288     GSList *list;
10289     int i;
10290
10291     list = object_class_get_list(TYPE_POWERPC_CPU, false);
10292     g_slist_foreach(list, ppc_cpu_defs_entry, &cpu_list);
10293     g_slist_free(list);
10294
10295     for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
10296         PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
10297         ObjectClass *oc;
10298         CpuDefinitionInfoList *entry;
10299         CpuDefinitionInfo *info;
10300
10301         oc = ppc_cpu_class_by_alias(alias);
10302         if (oc == NULL) {
10303             continue;
10304         }
10305
10306         info = g_malloc0(sizeof(*info));
10307         info->name = g_strdup(alias->alias);
10308
10309         entry = g_malloc0(sizeof(*entry));
10310         entry->value = info;
10311         entry->next = cpu_list;
10312         cpu_list = entry;
10313     }
10314
10315     return cpu_list;
10316 }
10317
10318 static void ppc_cpu_set_pc(CPUState *cs, vaddr value)
10319 {
10320     PowerPCCPU *cpu = POWERPC_CPU(cs);
10321
10322     cpu->env.nip = value;
10323 }
10324
10325 static bool ppc_cpu_has_work(CPUState *cs)
10326 {
10327     PowerPCCPU *cpu = POWERPC_CPU(cs);
10328     CPUPPCState *env = &cpu->env;
10329
10330     return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD);
10331 }
10332
10333 static void ppc_cpu_exec_enter(CPUState *cs)
10334 {
10335     PowerPCCPU *cpu = POWERPC_CPU(cs);
10336     CPUPPCState *env = &cpu->env;
10337
10338     env->reserve_addr = -1;
10339 }
10340
10341 /* CPUClass::reset() */
10342 static void ppc_cpu_reset(CPUState *s)
10343 {
10344     PowerPCCPU *cpu = POWERPC_CPU(s);
10345     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
10346     CPUPPCState *env = &cpu->env;
10347     target_ulong msr;
10348     int i;
10349
10350     pcc->parent_reset(s);
10351
10352     msr = (target_ulong)0;
10353     msr |= (target_ulong)MSR_HVB;
10354     msr |= (target_ulong)0 << MSR_AP; /* TO BE CHECKED */
10355     msr |= (target_ulong)0 << MSR_SA; /* TO BE CHECKED */
10356     msr |= (target_ulong)1 << MSR_EP;
10357 #if defined(DO_SINGLE_STEP) && 0
10358     /* Single step trace mode */
10359     msr |= (target_ulong)1 << MSR_SE;
10360     msr |= (target_ulong)1 << MSR_BE;
10361 #endif
10362 #if defined(CONFIG_USER_ONLY)
10363     msr |= (target_ulong)1 << MSR_FP; /* Allow floating point usage */
10364     msr |= (target_ulong)1 << MSR_VR; /* Allow altivec usage */
10365     msr |= (target_ulong)1 << MSR_VSX; /* Allow VSX usage */
10366     msr |= (target_ulong)1 << MSR_SPE; /* Allow SPE usage */
10367     msr |= (target_ulong)1 << MSR_PR;
10368 #if defined(TARGET_PPC64)
10369     msr |= (target_ulong)1 << MSR_TM; /* Transactional memory */
10370 #endif
10371 #if !defined(TARGET_WORDS_BIGENDIAN)
10372     msr |= (target_ulong)1 << MSR_LE; /* Little-endian user mode */
10373     if (!((env->msr_mask >> MSR_LE) & 1)) {
10374         fprintf(stderr, "Selected CPU does not support little-endian.\n");
10375         exit(1);
10376     }
10377 #endif
10378 #endif
10379
10380 #if defined(TARGET_PPC64)
10381     if (env->mmu_model & POWERPC_MMU_64) {
10382         msr |= (1ULL << MSR_SF);
10383     }
10384 #endif
10385
10386     hreg_store_msr(env, msr, 1);
10387
10388 #if !defined(CONFIG_USER_ONLY)
10389     env->nip = env->hreset_vector | env->excp_prefix;
10390     if (env->mmu_model != POWERPC_MMU_REAL) {
10391         ppc_tlb_invalidate_all(env);
10392     }
10393 #endif
10394
10395     hreg_compute_hflags(env);
10396     env->reserve_addr = (target_ulong)-1ULL;
10397     /* Be sure no exception or interrupt is pending */
10398     env->pending_interrupts = 0;
10399     s->exception_index = POWERPC_EXCP_NONE;
10400     env->error_code = 0;
10401
10402 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
10403     env->vpa_addr = 0;
10404     env->slb_shadow_addr = 0;
10405     env->slb_shadow_size = 0;
10406     env->dtl_addr = 0;
10407     env->dtl_size = 0;
10408 #endif /* TARGET_PPC64 */
10409
10410     for (i = 0; i < ARRAY_SIZE(env->spr_cb); i++) {
10411         ppc_spr_t *spr = &env->spr_cb[i];
10412
10413         if (!spr->name) {
10414             continue;
10415         }
10416         env->spr[i] = spr->default_value;
10417     }
10418
10419     /* Flush all TLBs */
10420     tlb_flush(s, 1);
10421 }
10422
10423 #ifndef CONFIG_USER_ONLY
10424 static bool ppc_cpu_is_big_endian(CPUState *cs)
10425 {
10426     PowerPCCPU *cpu = POWERPC_CPU(cs);
10427     CPUPPCState *env = &cpu->env;
10428
10429     cpu_synchronize_state(cs);
10430
10431     return !msr_le;
10432 }
10433 #endif
10434
10435 static void ppc_cpu_initfn(Object *obj)
10436 {
10437     CPUState *cs = CPU(obj);
10438     PowerPCCPU *cpu = POWERPC_CPU(obj);
10439     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
10440     CPUPPCState *env = &cpu->env;
10441
10442     cs->env_ptr = env;
10443
10444     env->msr_mask = pcc->msr_mask;
10445     env->mmu_model = pcc->mmu_model;
10446     env->excp_model = pcc->excp_model;
10447     env->bus_model = pcc->bus_model;
10448     env->insns_flags = pcc->insns_flags;
10449     env->insns_flags2 = pcc->insns_flags2;
10450     env->flags = pcc->flags;
10451     env->bfd_mach = pcc->bfd_mach;
10452     env->check_pow = pcc->check_pow;
10453
10454     /* Mark HV mode as supported if the CPU has an MSR_HV bit
10455      * in the msr_mask. The mask can later be cleared by PAPR
10456      * mode but the hv mode support will remain, thus enforcing
10457      * that we cannot use priv. instructions in guest in PAPR
10458      * mode. For 970 we currently simply don't set HV in msr_mask
10459      * thus simulating an "Apple mode" 970. If we ever want to
10460      * support 970 HV mode, we'll have to add a processor attribute
10461      * of some sort.
10462      */
10463 #if !defined(CONFIG_USER_ONLY)
10464     env->has_hv_mode = !!(env->msr_mask & MSR_HVB);
10465 #endif
10466
10467 #if defined(TARGET_PPC64)
10468     if (pcc->sps) {
10469         env->sps = *pcc->sps;
10470     } else if (env->mmu_model & POWERPC_MMU_64) {
10471         /* Use default sets of page sizes. We don't support MPSS */
10472         static const struct ppc_segment_page_sizes defsps_4k = {
10473             .sps = {
10474                 { .page_shift = 12, /* 4K */
10475                   .slb_enc = 0,
10476                   .enc = { { .page_shift = 12, .pte_enc = 0 } }
10477                 },
10478                 { .page_shift = 24, /* 16M */
10479                   .slb_enc = 0x100,
10480                   .enc = { { .page_shift = 24, .pte_enc = 0 } }
10481                 },
10482             },
10483         };
10484         static const struct ppc_segment_page_sizes defsps_64k = {
10485             .sps = {
10486                 { .page_shift = 12, /* 4K */
10487                   .slb_enc = 0,
10488                   .enc = { { .page_shift = 12, .pte_enc = 0 } }
10489                 },
10490                 { .page_shift = 16, /* 64K */
10491                   .slb_enc = 0x110,
10492                   .enc = { { .page_shift = 16, .pte_enc = 1 } }
10493                 },
10494                 { .page_shift = 24, /* 16M */
10495                   .slb_enc = 0x100,
10496                   .enc = { { .page_shift = 24, .pte_enc = 0 } }
10497                 },
10498             },
10499         };
10500         env->sps = (env->mmu_model & POWERPC_MMU_64K) ? defsps_64k : defsps_4k;
10501     }
10502 #endif /* defined(TARGET_PPC64) */
10503
10504     if (tcg_enabled()) {
10505         ppc_translate_init();
10506     }
10507 }
10508
10509 static bool ppc_pvr_match_default(PowerPCCPUClass *pcc, uint32_t pvr)
10510 {
10511     return pcc->pvr == pvr;
10512 }
10513
10514 static gchar *ppc_gdb_arch_name(CPUState *cs)
10515 {
10516 #if defined(TARGET_PPC64)
10517     return g_strdup("powerpc:common64");
10518 #else
10519     return g_strdup("powerpc:common");
10520 #endif
10521 }
10522
10523 static void ppc_cpu_class_init(ObjectClass *oc, void *data)
10524 {
10525     PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
10526     CPUClass *cc = CPU_CLASS(oc);
10527     DeviceClass *dc = DEVICE_CLASS(oc);
10528
10529     pcc->parent_realize = dc->realize;
10530     pcc->parent_unrealize = dc->unrealize;
10531     pcc->pvr_match = ppc_pvr_match_default;
10532     pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_always;
10533     dc->realize = ppc_cpu_realizefn;
10534     dc->unrealize = ppc_cpu_unrealizefn;
10535
10536     pcc->parent_reset = cc->reset;
10537     cc->reset = ppc_cpu_reset;
10538
10539     cc->class_by_name = ppc_cpu_class_by_name;
10540     cc->has_work = ppc_cpu_has_work;
10541     cc->do_interrupt = ppc_cpu_do_interrupt;
10542     cc->cpu_exec_interrupt = ppc_cpu_exec_interrupt;
10543     cc->dump_state = ppc_cpu_dump_state;
10544     cc->dump_statistics = ppc_cpu_dump_statistics;
10545     cc->set_pc = ppc_cpu_set_pc;
10546     cc->gdb_read_register = ppc_cpu_gdb_read_register;
10547     cc->gdb_write_register = ppc_cpu_gdb_write_register;
10548 #ifdef CONFIG_USER_ONLY
10549     cc->handle_mmu_fault = ppc_cpu_handle_mmu_fault;
10550 #else
10551     cc->get_phys_page_debug = ppc_cpu_get_phys_page_debug;
10552     cc->vmsd = &vmstate_ppc_cpu;
10553 #if defined(TARGET_PPC64)
10554     cc->write_elf64_note = ppc64_cpu_write_elf64_note;
10555 #endif
10556 #endif
10557     cc->cpu_exec_enter = ppc_cpu_exec_enter;
10558
10559     cc->gdb_num_core_regs = 71;
10560
10561 #ifdef USE_APPLE_GDB
10562     cc->gdb_read_register = ppc_cpu_gdb_read_register_apple;
10563     cc->gdb_write_register = ppc_cpu_gdb_write_register_apple;
10564     cc->gdb_num_core_regs = 71 + 32;
10565 #endif
10566
10567     cc->gdb_arch_name = ppc_gdb_arch_name;
10568 #if defined(TARGET_PPC64)
10569     cc->gdb_core_xml_file = "power64-core.xml";
10570 #else
10571     cc->gdb_core_xml_file = "power-core.xml";
10572 #endif
10573 #ifndef CONFIG_USER_ONLY
10574     cc->virtio_is_big_endian = ppc_cpu_is_big_endian;
10575 #endif
10576
10577     dc->fw_name = "PowerPC,UNKNOWN";
10578 }
10579
10580 static const TypeInfo ppc_cpu_type_info = {
10581     .name = TYPE_POWERPC_CPU,
10582     .parent = TYPE_CPU,
10583     .instance_size = sizeof(PowerPCCPU),
10584     .instance_init = ppc_cpu_initfn,
10585     .abstract = true,
10586     .class_size = sizeof(PowerPCCPUClass),
10587     .class_init = ppc_cpu_class_init,
10588 };
10589
10590 static void ppc_cpu_register_types(void)
10591 {
10592     type_register_static(&ppc_cpu_type_info);
10593 }
10594
10595 type_init(ppc_cpu_register_types)