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