target-ppc/translate_init.c

   1 /*
   2  *  PowerPC CPU initialization for qemu.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* A lot of PowerPC definition have been included here.
  22  * Most of them are not usable for now but have been kept
  23  * inside "#if defined(TODO) ... #endif" statements to make tests easier.
  24  */
  25
  26 //#define PPC_DUMP_CPU
  27 //#define PPC_DEBUG_SPR
  28 //#define PPC_DEBUG_IRQ
  29
  30 struct ppc_def_t {
  31     const unsigned char *name;
  32     uint32_t pvr;
  33     uint32_t pvr_mask;
  34     uint64_t insns_flags;
  35     uint32_t flags;
  36     uint64_t msr_mask;
  37 };
  38
  39 /* For user-mode emulation, we don't emulate any IRQ controller */
  40 #if defined(CONFIG_USER_ONLY)
  41 #define PPC_IRQ_INIT_FN(name)                                         \
  42 static inline void glue(glue(ppc, name),_irq_init) (CPUPPCState *env) \
  43 {                                                                     \
  44 }
  45 #else
  46 #define PPC_IRQ_INIT_FN(name)                                         \
  47 void glue(glue(ppc, name),_irq_init) (CPUPPCState *env);
  48 #endif
  49 PPC_IRQ_INIT_FN(405);
  50 PPC_IRQ_INIT_FN(6xx);
  51 PPC_IRQ_INIT_FN(970);
  52
  53 /* Generic callbacks:
  54  * do nothing but store/retrieve spr value
  55  */
  56 static void spr_read_generic (void *opaque, int sprn)
  57 {
  58     gen_op_load_spr(sprn);
  59 }
  60
  61 static void spr_write_generic (void *opaque, int sprn)
  62 {
  63     gen_op_store_spr(sprn);
  64 }
  65
  66 static void spr_read_dump (void *opaque, int sprn)
  67 {
  68     gen_op_load_dump_spr(sprn);
  69 }
  70
  71 static void spr_write_dump (void *opaque, int sprn)
  72 {
  73     gen_op_store_dump_spr(sprn);
  74 }
  75
  76 #if !defined(CONFIG_USER_ONLY)
  77 static void spr_write_clear (void *opaque, int sprn)
  78 {
  79     gen_op_mask_spr(sprn);
  80 }
  81 #endif
  82
  83 /* SPR common to all PowerPC */
  84 /* XER */
  85 static void spr_read_xer (void *opaque, int sprn)
  86 {
  87     gen_op_load_xer();
  88 }
  89
  90 static void spr_write_xer (void *opaque, int sprn)
  91 {
  92     gen_op_store_xer();
  93 }
  94
  95 /* LR */
  96 static void spr_read_lr (void *opaque, int sprn)
  97 {
  98     gen_op_load_lr();
  99 }
 100
 101 static void spr_write_lr (void *opaque, int sprn)
 102 {
 103     gen_op_store_lr();
 104 }
 105
 106 /* CTR */
 107 static void spr_read_ctr (void *opaque, int sprn)
 108 {
 109     gen_op_load_ctr();
 110 }
 111
 112 static void spr_write_ctr (void *opaque, int sprn)
 113 {
 114     gen_op_store_ctr();
 115 }
 116
 117 /* User read access to SPR */
 118 /* USPRx */
 119 /* UMMCRx */
 120 /* UPMCx */
 121 /* USIA */
 122 /* UDECR */
 123 static void spr_read_ureg (void *opaque, int sprn)
 124 {
 125     gen_op_load_spr(sprn + 0x10);
 126 }
 127
 128 /* SPR common to all non-embedded PowerPC */
 129 /* DECR */
 130 #if !defined(CONFIG_USER_ONLY)
 131 static void spr_read_decr (void *opaque, int sprn)
 132 {
 133     gen_op_load_decr();
 134 }
 135
 136 static void spr_write_decr (void *opaque, int sprn)
 137 {
 138     gen_op_store_decr();
 139 }
 140 #endif
 141
 142 /* SPR common to all non-embedded PowerPC, except 601 */
 143 /* Time base */
 144 static void spr_read_tbl (void *opaque, int sprn)
 145 {
 146     gen_op_load_tbl();
 147 }
 148
 149 static void spr_read_tbu (void *opaque, int sprn)
 150 {
 151     gen_op_load_tbu();
 152 }
 153
 154 #if !defined(CONFIG_USER_ONLY)
 155 static void spr_write_tbl (void *opaque, int sprn)
 156 {
 157     gen_op_store_tbl();
 158 }
 159
 160 static void spr_write_tbu (void *opaque, int sprn)
 161 {
 162     gen_op_store_tbu();
 163 }
 164 #endif
 165
 166 #if !defined(CONFIG_USER_ONLY)
 167 /* IBAT0U...IBAT0U */
 168 /* IBAT0L...IBAT7L */
 169 static void spr_read_ibat (void *opaque, int sprn)
 170 {
 171     gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
 172 }
 173
 174 static void spr_read_ibat_h (void *opaque, int sprn)
 175 {
 176     gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT4U) / 2);
 177 }
 178
 179 static void spr_write_ibatu (void *opaque, int sprn)
 180 {
 181     DisasContext *ctx = opaque;
 182
 183     gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);
 184     RET_STOP(ctx);
 185 }
 186
 187 static void spr_write_ibatu_h (void *opaque, int sprn)
 188 {
 189     DisasContext *ctx = opaque;
 190
 191     gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);
 192     RET_STOP(ctx);
 193 }
 194
 195 static void spr_write_ibatl (void *opaque, int sprn)
 196 {
 197     DisasContext *ctx = opaque;
 198
 199     gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);
 200     RET_STOP(ctx);
 201 }
 202
 203 static void spr_write_ibatl_h (void *opaque, int sprn)
 204 {
 205     DisasContext *ctx = opaque;
 206
 207     gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);
 208     RET_STOP(ctx);
 209 }
 210
 211 /* DBAT0U...DBAT7U */
 212 /* DBAT0L...DBAT7L */
 213 static void spr_read_dbat (void *opaque, int sprn)
 214 {
 215     gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT0U) / 2);
 216 }
 217
 218 static void spr_read_dbat_h (void *opaque, int sprn)
 219 {
 220     gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT4U) / 2);
 221 }
 222
 223 static void spr_write_dbatu (void *opaque, int sprn)
 224 {
 225     DisasContext *ctx = opaque;
 226
 227     gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);
 228     RET_STOP(ctx);
 229 }
 230
 231 static void spr_write_dbatu_h (void *opaque, int sprn)
 232 {
 233     DisasContext *ctx = opaque;
 234
 235     gen_op_store_dbatu((sprn - SPR_DBAT4U) / 2);
 236     RET_STOP(ctx);
 237 }
 238
 239 static void spr_write_dbatl (void *opaque, int sprn)
 240 {
 241     DisasContext *ctx = opaque;
 242
 243     gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);
 244     RET_STOP(ctx);
 245 }
 246
 247 static void spr_write_dbatl_h (void *opaque, int sprn)
 248 {
 249     DisasContext *ctx = opaque;
 250
 251     gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);
 252     RET_STOP(ctx);
 253 }
 254
 255 /* SDR1 */
 256 static void spr_read_sdr1 (void *opaque, int sprn)
 257 {
 258     gen_op_load_sdr1();
 259 }
 260
 261 static void spr_write_sdr1 (void *opaque, int sprn)
 262 {
 263     DisasContext *ctx = opaque;
 264
 265     gen_op_store_sdr1();
 266     RET_STOP(ctx);
 267 }
 268
 269 /* 64 bits PowerPC specific SPRs */
 270 /* ASR */
 271 #if defined(TARGET_PPC64)
 272 static void spr_read_asr (void *opaque, int sprn)
 273 {
 274     gen_op_load_asr();
 275 }
 276
 277 static void spr_write_asr (void *opaque, int sprn)
 278 {
 279     DisasContext *ctx = opaque;
 280
 281     gen_op_store_asr();
 282     RET_STOP(ctx);
 283 }
 284 #endif
 285 #endif /* !defined(CONFIG_USER_ONLY) */
 286
 287 /* PowerPC 601 specific registers */
 288 /* RTC */
 289 static void spr_read_601_rtcl (void *opaque, int sprn)
 290 {
 291     gen_op_load_601_rtcl();
 292 }
 293
 294 static void spr_read_601_rtcu (void *opaque, int sprn)
 295 {
 296     gen_op_load_601_rtcu();
 297 }
 298
 299 #if !defined(CONFIG_USER_ONLY)
 300 static void spr_write_601_rtcu (void *opaque, int sprn)
 301 {
 302     gen_op_store_601_rtcu();
 303 }
 304
 305 static void spr_write_601_rtcl (void *opaque, int sprn)
 306 {
 307     gen_op_store_601_rtcl();
 308 }
 309 #endif
 310
 311 /* Unified bats */
 312 #if !defined(CONFIG_USER_ONLY)
 313 static void spr_read_601_ubat (void *opaque, int sprn)
 314 {
 315     gen_op_load_601_bat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
 316 }
 317
 318 static void spr_write_601_ubatu (void *opaque, int sprn)
 319 {
 320     DisasContext *ctx = opaque;
 321
 322     gen_op_store_601_batu((sprn - SPR_IBAT0U) / 2);
 323     RET_STOP(ctx);
 324 }
 325
 326 static void spr_write_601_ubatl (void *opaque, int sprn)
 327 {
 328     DisasContext *ctx = opaque;
 329
 330     gen_op_store_601_batl((sprn - SPR_IBAT0L) / 2);
 331     RET_STOP(ctx);
 332 }
 333 #endif
 334
 335 /* PowerPC 40x specific registers */
 336 #if !defined(CONFIG_USER_ONLY)
 337 static void spr_read_40x_pit (void *opaque, int sprn)
 338 {
 339     gen_op_load_40x_pit();
 340 }
 341
 342 static void spr_write_40x_pit (void *opaque, int sprn)
 343 {
 344     gen_op_store_40x_pit();
 345 }
 346
 347 static void spr_write_40x_dbcr0 (void *opaque, int sprn)
 348 {
 349     DisasContext *ctx = opaque;
 350
 351     gen_op_store_40x_dbcr0();
 352     /* We must stop translation as we may have rebooted */
 353     RET_STOP(ctx);
 354 }
 355
 356 static void spr_write_booke_tcr (void *opaque, int sprn)
 357 {
 358     gen_op_store_booke_tcr();
 359 }
 360
 361 static void spr_write_booke_tsr (void *opaque, int sprn)
 362 {
 363     gen_op_store_booke_tsr();
 364 }
 365 #endif
 366
 367 /* PowerPC 403 specific registers */
 368 /* PBL1 / PBU1 / PBL2 / PBU2 */
 369 #if !defined(CONFIG_USER_ONLY)
 370 static void spr_read_403_pbr (void *opaque, int sprn)
 371 {
 372     gen_op_load_403_pb(sprn - SPR_403_PBL1);
 373 }
 374
 375 static void spr_write_403_pbr (void *opaque, int sprn)
 376 {
 377     DisasContext *ctx = opaque;
 378
 379     gen_op_store_403_pb(sprn - SPR_403_PBL1);
 380     RET_STOP(ctx);
 381 }
 382
 383 static void spr_write_pir (void *opaque, int sprn)
 384 {
 385     gen_op_store_pir();
 386 }
 387 #endif
 388
 389 #if defined(CONFIG_USER_ONLY)
 390 #define spr_register(env, num, name, uea_read, uea_write,                     \
 391                      oea_read, oea_write, initial_value)                      \
 392 do {                                                                          \
 393      _spr_register(env, num, name, uea_read, uea_write, initial_value);       \
 394 } while (0)
 395 static inline void _spr_register (CPUPPCState *env, int num,
 396                                   const unsigned char *name,
 397                                   void (*uea_read)(void *opaque, int sprn),
 398                                   void (*uea_write)(void *opaque, int sprn),
 399                                   target_ulong initial_value)
 400 #else
 401 static inline void spr_register (CPUPPCState *env, int num,
 402                                  const unsigned char *name,
 403                                  void (*uea_read)(void *opaque, int sprn),
 404                                  void (*uea_write)(void *opaque, int sprn),
 405                                  void (*oea_read)(void *opaque, int sprn),
 406                                  void (*oea_write)(void *opaque, int sprn),
 407                                  target_ulong initial_value)
 408 #endif
 409 {
 410     ppc_spr_t *spr;
 411
 412     spr = &env->spr_cb[num];
 413     if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||
 414 #if !defined(CONFIG_USER_ONLY)
 415         spr->oea_read != NULL || spr->oea_write != NULL ||
 416 #endif
 417         spr->uea_read != NULL || spr->uea_write != NULL) {
 418         printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
 419         exit(1);
 420     }
 421 #if defined(PPC_DEBUG_SPR)
 422     printf("*** register spr %d (%03x) %s val " ADDRX "\n", num, num, name,
 423            initial_value);
 424 #endif
 425     spr->name = name;
 426     spr->uea_read = uea_read;
 427     spr->uea_write = uea_write;
 428 #if !defined(CONFIG_USER_ONLY)
 429     spr->oea_read = oea_read;
 430     spr->oea_write = oea_write;
 431 #endif
 432     env->spr[num] = initial_value;
 433 }
 434
 435 /* Generic PowerPC SPRs */
 436 static void gen_spr_generic (CPUPPCState *env)
 437 {
 438     /* Integer processing */
 439     spr_register(env, SPR_XER, "XER",
 440                  &spr_read_xer, &spr_write_xer,
 441                  &spr_read_xer, &spr_write_xer,
 442                  0x00000000);
 443     /* Branch contol */
 444     spr_register(env, SPR_LR, "LR",
 445                  &spr_read_lr, &spr_write_lr,
 446                  &spr_read_lr, &spr_write_lr,
 447                  0x00000000);
 448     spr_register(env, SPR_CTR, "CTR",
 449                  &spr_read_ctr, &spr_write_ctr,
 450                  &spr_read_ctr, &spr_write_ctr,
 451                  0x00000000);
 452     /* Interrupt processing */
 453     spr_register(env, SPR_SRR0, "SRR0",
 454                  SPR_NOACCESS, SPR_NOACCESS,
 455                  &spr_read_generic, &spr_write_generic,
 456                  0x00000000);
 457     spr_register(env, SPR_SRR1, "SRR1",
 458                  SPR_NOACCESS, SPR_NOACCESS,
 459                  &spr_read_generic, &spr_write_generic,
 460                  0x00000000);
 461     /* Processor control */
 462     spr_register(env, SPR_SPRG0, "SPRG0",
 463                  SPR_NOACCESS, SPR_NOACCESS,
 464                  &spr_read_generic, &spr_write_generic,
 465                  0x00000000);
 466     spr_register(env, SPR_SPRG1, "SPRG1",
 467                  SPR_NOACCESS, SPR_NOACCESS,
 468                  &spr_read_generic, &spr_write_generic,
 469                  0x00000000);
 470     spr_register(env, SPR_SPRG2, "SPRG2",
 471                  SPR_NOACCESS, SPR_NOACCESS,
 472                  &spr_read_generic, &spr_write_generic,
 473                  0x00000000);
 474     spr_register(env, SPR_SPRG3, "SPRG3",
 475                  SPR_NOACCESS, SPR_NOACCESS,
 476                  &spr_read_generic, &spr_write_generic,
 477                  0x00000000);
 478 }
 479
 480 /* SPR common to all non-embedded PowerPC, including 601 */
 481 static void gen_spr_ne_601 (CPUPPCState *env)
 482 {
 483     /* Exception processing */
 484     spr_register(env, SPR_DSISR, "DSISR",
 485                  SPR_NOACCESS, SPR_NOACCESS,
 486                  &spr_read_generic, &spr_write_generic,
 487                  0x00000000);
 488     spr_register(env, SPR_DAR, "DAR",
 489                  SPR_NOACCESS, SPR_NOACCESS,
 490                  &spr_read_generic, &spr_write_generic,
 491                  0x00000000);
 492     /* Timer */
 493     spr_register(env, SPR_DECR, "DECR",
 494                  SPR_NOACCESS, SPR_NOACCESS,
 495                  &spr_read_decr, &spr_write_decr,
 496                  0x00000000);
 497     /* Memory management */
 498     spr_register(env, SPR_SDR1, "SDR1",
 499                  SPR_NOACCESS, SPR_NOACCESS,
 500                  &spr_read_sdr1, &spr_write_sdr1,
 501                  0x00000000);
 502 }
 503
 504 /* BATs 0-3 */
 505 static void gen_low_BATs (CPUPPCState *env)
 506 {
 507     spr_register(env, SPR_IBAT0U, "IBAT0U",
 508                  SPR_NOACCESS, SPR_NOACCESS,
 509                  &spr_read_ibat, &spr_write_ibatu,
 510                  0x00000000);
 511     spr_register(env, SPR_IBAT0L, "IBAT0L",
 512                  SPR_NOACCESS, SPR_NOACCESS,
 513                  &spr_read_ibat, &spr_write_ibatl,
 514                  0x00000000);
 515     spr_register(env, SPR_IBAT1U, "IBAT1U",
 516                  SPR_NOACCESS, SPR_NOACCESS,
 517                  &spr_read_ibat, &spr_write_ibatu,
 518                  0x00000000);
 519     spr_register(env, SPR_IBAT1L, "IBAT1L",
 520                  SPR_NOACCESS, SPR_NOACCESS,
 521                  &spr_read_ibat, &spr_write_ibatl,
 522                  0x00000000);
 523     spr_register(env, SPR_IBAT2U, "IBAT2U",
 524                  SPR_NOACCESS, SPR_NOACCESS,
 525                  &spr_read_ibat, &spr_write_ibatu,
 526                  0x00000000);
 527     spr_register(env, SPR_IBAT2L, "IBAT2L",
 528                  SPR_NOACCESS, SPR_NOACCESS,
 529                  &spr_read_ibat, &spr_write_ibatl,
 530                  0x00000000);
 531     spr_register(env, SPR_IBAT3U, "IBAT3U",
 532                  SPR_NOACCESS, SPR_NOACCESS,
 533                  &spr_read_ibat, &spr_write_ibatu,
 534                  0x00000000);
 535     spr_register(env, SPR_IBAT3L, "IBAT3L",
 536                  SPR_NOACCESS, SPR_NOACCESS,
 537                  &spr_read_ibat, &spr_write_ibatl,
 538                  0x00000000);
 539     spr_register(env, SPR_DBAT0U, "DBAT0U",
 540                  SPR_NOACCESS, SPR_NOACCESS,
 541                  &spr_read_dbat, &spr_write_dbatu,
 542                  0x00000000);
 543     spr_register(env, SPR_DBAT0L, "DBAT0L",
 544                  SPR_NOACCESS, SPR_NOACCESS,
 545                  &spr_read_dbat, &spr_write_dbatl,
 546                  0x00000000);
 547     spr_register(env, SPR_DBAT1U, "DBAT1U",
 548                  SPR_NOACCESS, SPR_NOACCESS,
 549                  &spr_read_dbat, &spr_write_dbatu,
 550                  0x00000000);
 551     spr_register(env, SPR_DBAT1L, "DBAT1L",
 552                  SPR_NOACCESS, SPR_NOACCESS,
 553                  &spr_read_dbat, &spr_write_dbatl,
 554                  0x00000000);
 555     spr_register(env, SPR_DBAT2U, "DBAT2U",
 556                  SPR_NOACCESS, SPR_NOACCESS,
 557                  &spr_read_dbat, &spr_write_dbatu,
 558                  0x00000000);
 559     spr_register(env, SPR_DBAT2L, "DBAT2L",
 560                  SPR_NOACCESS, SPR_NOACCESS,
 561                  &spr_read_dbat, &spr_write_dbatl,
 562                  0x00000000);
 563     spr_register(env, SPR_DBAT3U, "DBAT3U",
 564                  SPR_NOACCESS, SPR_NOACCESS,
 565                  &spr_read_dbat, &spr_write_dbatu,
 566                  0x00000000);
 567     spr_register(env, SPR_DBAT3L, "DBAT3L",
 568                  SPR_NOACCESS, SPR_NOACCESS,
 569                  &spr_read_dbat, &spr_write_dbatl,
 570                  0x00000000);
 571     env->nb_BATs = 4;
 572 }
 573
 574 /* BATs 4-7 */
 575 static void gen_high_BATs (CPUPPCState *env)
 576 {
 577     spr_register(env, SPR_IBAT4U, "IBAT4U",
 578                  SPR_NOACCESS, SPR_NOACCESS,
 579                  &spr_read_ibat_h, &spr_write_ibatu_h,
 580                  0x00000000);
 581     spr_register(env, SPR_IBAT4L, "IBAT4L",
 582                  SPR_NOACCESS, SPR_NOACCESS,
 583                  &spr_read_ibat_h, &spr_write_ibatl_h,
 584                  0x00000000);
 585     spr_register(env, SPR_IBAT5U, "IBAT5U",
 586                  SPR_NOACCESS, SPR_NOACCESS,
 587                  &spr_read_ibat_h, &spr_write_ibatu_h,
 588                  0x00000000);
 589     spr_register(env, SPR_IBAT5L, "IBAT5L",
 590                  SPR_NOACCESS, SPR_NOACCESS,
 591                  &spr_read_ibat_h, &spr_write_ibatl_h,
 592                  0x00000000);
 593     spr_register(env, SPR_IBAT6U, "IBAT6U",
 594                  SPR_NOACCESS, SPR_NOACCESS,
 595                  &spr_read_ibat_h, &spr_write_ibatu_h,
 596                  0x00000000);
 597     spr_register(env, SPR_IBAT6L, "IBAT6L",
 598                  SPR_NOACCESS, SPR_NOACCESS,
 599                  &spr_read_ibat_h, &spr_write_ibatl_h,
 600                  0x00000000);
 601     spr_register(env, SPR_IBAT7U, "IBAT7U",
 602                  SPR_NOACCESS, SPR_NOACCESS,
 603                  &spr_read_ibat_h, &spr_write_ibatu_h,
 604                  0x00000000);
 605     spr_register(env, SPR_IBAT7L, "IBAT7L",
 606                  SPR_NOACCESS, SPR_NOACCESS,
 607                  &spr_read_ibat_h, &spr_write_ibatl_h,
 608                  0x00000000);
 609     spr_register(env, SPR_DBAT4U, "DBAT4U",
 610                  SPR_NOACCESS, SPR_NOACCESS,
 611                  &spr_read_dbat_h, &spr_write_dbatu_h,
 612                  0x00000000);
 613     spr_register(env, SPR_DBAT4L, "DBAT4L",
 614                  SPR_NOACCESS, SPR_NOACCESS,
 615                  &spr_read_dbat_h, &spr_write_dbatl_h,
 616                  0x00000000);
 617     spr_register(env, SPR_DBAT5U, "DBAT5U",
 618                  SPR_NOACCESS, SPR_NOACCESS,
 619                  &spr_read_dbat_h, &spr_write_dbatu_h,
 620                  0x00000000);
 621     spr_register(env, SPR_DBAT5L, "DBAT5L",
 622                  SPR_NOACCESS, SPR_NOACCESS,
 623                  &spr_read_dbat_h, &spr_write_dbatl_h,
 624                  0x00000000);
 625     spr_register(env, SPR_DBAT6U, "DBAT6U",
 626                  SPR_NOACCESS, SPR_NOACCESS,
 627                  &spr_read_dbat_h, &spr_write_dbatu_h,
 628                  0x00000000);
 629     spr_register(env, SPR_DBAT6L, "DBAT6L",
 630                  SPR_NOACCESS, SPR_NOACCESS,
 631                  &spr_read_dbat_h, &spr_write_dbatl_h,
 632                  0x00000000);
 633     spr_register(env, SPR_DBAT7U, "DBAT7U",
 634                  SPR_NOACCESS, SPR_NOACCESS,
 635                  &spr_read_dbat_h, &spr_write_dbatu_h,
 636                  0x00000000);
 637     spr_register(env, SPR_DBAT7L, "DBAT7L",
 638                  SPR_NOACCESS, SPR_NOACCESS,
 639                  &spr_read_dbat_h, &spr_write_dbatl_h,
 640                  0x00000000);
 641     env->nb_BATs = 8;
 642 }
 643
 644 /* Generic PowerPC time base */
 645 static void gen_tbl (CPUPPCState *env)
 646 {
 647     spr_register(env, SPR_VTBL,  "TBL",
 648                  &spr_read_tbl, SPR_NOACCESS,
 649                  &spr_read_tbl, SPR_NOACCESS,
 650                  0x00000000);
 651     spr_register(env, SPR_TBL,   "TBL",
 652                  SPR_NOACCESS, SPR_NOACCESS,
 653                  SPR_NOACCESS, &spr_write_tbl,
 654                  0x00000000);
 655     spr_register(env, SPR_VTBU,  "TBU",
 656                  &spr_read_tbu, SPR_NOACCESS,
 657                  &spr_read_tbu, SPR_NOACCESS,
 658                  0x00000000);
 659     spr_register(env, SPR_TBU,   "TBU",
 660                  SPR_NOACCESS, SPR_NOACCESS,
 661                  SPR_NOACCESS, &spr_write_tbu,
 662                  0x00000000);
 663 }
 664
 665 /* Softare table search registers */
 666 static void gen_6xx_7xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
 667 {
 668     env->nb_tlb = nb_tlbs;
 669     env->nb_ways = nb_ways;
 670     env->id_tlbs = 1;
 671     spr_register(env, SPR_DMISS, "DMISS",
 672                  SPR_NOACCESS, SPR_NOACCESS,
 673                  &spr_read_generic, SPR_NOACCESS,
 674                  0x00000000);
 675     spr_register(env, SPR_DCMP, "DCMP",
 676                  SPR_NOACCESS, SPR_NOACCESS,
 677                  &spr_read_generic, SPR_NOACCESS,
 678                  0x00000000);
 679     spr_register(env, SPR_HASH1, "HASH1",
 680                  SPR_NOACCESS, SPR_NOACCESS,
 681                  &spr_read_generic, SPR_NOACCESS,
 682                  0x00000000);
 683     spr_register(env, SPR_HASH2, "HASH2",
 684                  SPR_NOACCESS, SPR_NOACCESS,
 685                  &spr_read_generic, SPR_NOACCESS,
 686                  0x00000000);
 687     spr_register(env, SPR_IMISS, "IMISS",
 688                  SPR_NOACCESS, SPR_NOACCESS,
 689                  &spr_read_generic, SPR_NOACCESS,
 690                  0x00000000);
 691     spr_register(env, SPR_ICMP, "ICMP",
 692                  SPR_NOACCESS, SPR_NOACCESS,
 693                  &spr_read_generic, SPR_NOACCESS,
 694                  0x00000000);
 695     spr_register(env, SPR_RPA, "RPA",
 696                  SPR_NOACCESS, SPR_NOACCESS,
 697                  &spr_read_generic, &spr_write_generic,
 698                  0x00000000);
 699 }
 700
 701 /* SPR common to MPC755 and G2 */
 702 static void gen_spr_G2_755 (CPUPPCState *env)
 703 {
 704     /* SGPRs */
 705     spr_register(env, SPR_SPRG4, "SPRG4",
 706                  SPR_NOACCESS, SPR_NOACCESS,
 707                  &spr_read_generic, &spr_write_generic,
 708                  0x00000000);
 709     spr_register(env, SPR_SPRG5, "SPRG5",
 710                  SPR_NOACCESS, SPR_NOACCESS,
 711                  &spr_read_generic, &spr_write_generic,
 712                  0x00000000);
 713     spr_register(env, SPR_SPRG6, "SPRG6",
 714                  SPR_NOACCESS, SPR_NOACCESS,
 715                  &spr_read_generic, &spr_write_generic,
 716                  0x00000000);
 717     spr_register(env, SPR_SPRG7, "SPRG7",
 718                  SPR_NOACCESS, SPR_NOACCESS,
 719                  &spr_read_generic, &spr_write_generic,
 720                  0x00000000);
 721     /* External access control */
 722     /* XXX : not implemented */
 723     spr_register(env, SPR_EAR, "EAR",
 724                  SPR_NOACCESS, SPR_NOACCESS,
 725                  &spr_read_generic, &spr_write_generic,
 726                  0x00000000);
 727 }
 728
 729 /* SPR common to all 7xx PowerPC implementations */
 730 static void gen_spr_7xx (CPUPPCState *env)
 731 {
 732     /* Breakpoints */
 733     /* XXX : not implemented */
 734     spr_register(env, SPR_DABR, "DABR",
 735                  SPR_NOACCESS, SPR_NOACCESS,
 736                  &spr_read_generic, &spr_write_generic,
 737                  0x00000000);
 738     /* XXX : not implemented */
 739     spr_register(env, SPR_IABR, "IABR",
 740                  SPR_NOACCESS, SPR_NOACCESS,
 741                  &spr_read_generic, &spr_write_generic,
 742                  0x00000000);
 743     /* Cache management */
 744     /* XXX : not implemented */
 745     spr_register(env, SPR_ICTC, "ICTC",
 746                  SPR_NOACCESS, SPR_NOACCESS,
 747                  &spr_read_generic, &spr_write_generic,
 748                  0x00000000);
 749     /* XXX : not implemented */
 750     spr_register(env, SPR_L2CR, "L2CR",
 751                  SPR_NOACCESS, SPR_NOACCESS,
 752                  &spr_read_generic, &spr_write_generic,
 753                  0x00000000);
 754     /* Performance monitors */
 755     /* XXX : not implemented */
 756     spr_register(env, SPR_MMCR0, "MMCR0",
 757                  SPR_NOACCESS, SPR_NOACCESS,
 758                  &spr_read_generic, &spr_write_generic,
 759                  0x00000000);
 760     /* XXX : not implemented */
 761     spr_register(env, SPR_MMCR1, "MMCR1",
 762                  SPR_NOACCESS, SPR_NOACCESS,
 763                  &spr_read_generic, &spr_write_generic,
 764                  0x00000000);
 765     /* XXX : not implemented */
 766     spr_register(env, SPR_PMC1, "PMC1",
 767                  SPR_NOACCESS, SPR_NOACCESS,
 768                  &spr_read_generic, &spr_write_generic,
 769                  0x00000000);
 770     /* XXX : not implemented */
 771     spr_register(env, SPR_PMC2, "PMC2",
 772                  SPR_NOACCESS, SPR_NOACCESS,
 773                  &spr_read_generic, &spr_write_generic,
 774                  0x00000000);
 775     /* XXX : not implemented */
 776     spr_register(env, SPR_PMC3, "PMC3",
 777                  SPR_NOACCESS, SPR_NOACCESS,
 778                  &spr_read_generic, &spr_write_generic,
 779                  0x00000000);
 780     /* XXX : not implemented */
 781     spr_register(env, SPR_PMC4, "PMC4",
 782                  SPR_NOACCESS, SPR_NOACCESS,
 783                  &spr_read_generic, &spr_write_generic,
 784                  0x00000000);
 785     /* XXX : not implemented */
 786     spr_register(env, SPR_SIA, "SIA",
 787                  SPR_NOACCESS, SPR_NOACCESS,
 788                  &spr_read_generic, SPR_NOACCESS,
 789                  0x00000000);
 790     spr_register(env, SPR_UMMCR0, "UMMCR0",
 791                  &spr_read_ureg, SPR_NOACCESS,
 792                  &spr_read_ureg, SPR_NOACCESS,
 793                  0x00000000);
 794     spr_register(env, SPR_UMMCR1, "UMMCR1",
 795                  &spr_read_ureg, SPR_NOACCESS,
 796                  &spr_read_ureg, SPR_NOACCESS,
 797                  0x00000000);
 798     spr_register(env, SPR_UPMC1, "UPMC1",
 799                  &spr_read_ureg, SPR_NOACCESS,
 800                  &spr_read_ureg, SPR_NOACCESS,
 801                  0x00000000);
 802     spr_register(env, SPR_UPMC2, "UPMC2",
 803                  &spr_read_ureg, SPR_NOACCESS,
 804                  &spr_read_ureg, SPR_NOACCESS,
 805                  0x00000000);
 806     spr_register(env, SPR_UPMC3, "UPMC3",
 807                  &spr_read_ureg, SPR_NOACCESS,
 808                  &spr_read_ureg, SPR_NOACCESS,
 809                  0x00000000);
 810     spr_register(env, SPR_UPMC4, "UPMC4",
 811                  &spr_read_ureg, SPR_NOACCESS,
 812                  &spr_read_ureg, SPR_NOACCESS,
 813                  0x00000000);
 814     spr_register(env, SPR_USIA, "USIA",
 815                  &spr_read_ureg, SPR_NOACCESS,
 816                  &spr_read_ureg, SPR_NOACCESS,
 817                  0x00000000);
 818     /* Thermal management */
 819     /* XXX : not implemented */
 820     spr_register(env, SPR_THRM1, "THRM1",
 821                  SPR_NOACCESS, SPR_NOACCESS,
 822                  &spr_read_generic, &spr_write_generic,
 823                  0x00000000);
 824     /* XXX : not implemented */
 825     spr_register(env, SPR_THRM2, "THRM2",
 826                  SPR_NOACCESS, SPR_NOACCESS,
 827                  &spr_read_generic, &spr_write_generic,
 828                  0x00000000);
 829     /* XXX : not implemented */
 830     spr_register(env, SPR_THRM3, "THRM3",
 831                  SPR_NOACCESS, SPR_NOACCESS,
 832                  &spr_read_generic, &spr_write_generic,
 833                  0x00000000);
 834     /* External access control */
 835     /* XXX : not implemented */
 836     spr_register(env, SPR_EAR, "EAR",
 837                  SPR_NOACCESS, SPR_NOACCESS,
 838                  &spr_read_generic, &spr_write_generic,
 839                  0x00000000);
 840 }
 841
 842 /* SPR specific to PowerPC 604 implementation */
 843 static void gen_spr_604 (CPUPPCState *env)
 844 {
 845     /* Processor identification */
 846     spr_register(env, SPR_PIR, "PIR",
 847                  SPR_NOACCESS, SPR_NOACCESS,
 848                  &spr_read_generic, &spr_write_pir,
 849                  0x00000000);
 850     /* Breakpoints */
 851     /* XXX : not implemented */
 852     spr_register(env, SPR_IABR, "IABR",
 853                  SPR_NOACCESS, SPR_NOACCESS,
 854                  &spr_read_generic, &spr_write_generic,
 855                  0x00000000);
 856     /* XXX : not implemented */
 857     spr_register(env, SPR_DABR, "DABR",
 858                  SPR_NOACCESS, SPR_NOACCESS,
 859                  &spr_read_generic, &spr_write_generic,
 860                  0x00000000);
 861     /* Performance counters */
 862     /* XXX : not implemented */
 863     spr_register(env, SPR_MMCR0, "MMCR0",
 864                  SPR_NOACCESS, SPR_NOACCESS,
 865                  &spr_read_generic, &spr_write_generic,
 866                  0x00000000);
 867     /* XXX : not implemented */
 868     spr_register(env, SPR_MMCR1, "MMCR1",
 869                  SPR_NOACCESS, SPR_NOACCESS,
 870                  &spr_read_generic, &spr_write_generic,
 871                  0x00000000);
 872     /* XXX : not implemented */
 873     spr_register(env, SPR_PMC1, "PMC1",
 874                  SPR_NOACCESS, SPR_NOACCESS,
 875                  &spr_read_generic, &spr_write_generic,
 876                  0x00000000);
 877     /* XXX : not implemented */
 878     spr_register(env, SPR_PMC2, "PMC2",
 879                  SPR_NOACCESS, SPR_NOACCESS,
 880                  &spr_read_generic, &spr_write_generic,
 881                  0x00000000);
 882     /* XXX : not implemented */
 883     spr_register(env, SPR_PMC3, "PMC3",
 884                  SPR_NOACCESS, SPR_NOACCESS,
 885                  &spr_read_generic, &spr_write_generic,
 886                  0x00000000);
 887     /* XXX : not implemented */
 888     spr_register(env, SPR_PMC4, "PMC4",
 889                  SPR_NOACCESS, SPR_NOACCESS,
 890                  &spr_read_generic, &spr_write_generic,
 891                  0x00000000);
 892     /* XXX : not implemented */
 893     spr_register(env, SPR_SIA, "SIA",
 894                  SPR_NOACCESS, SPR_NOACCESS,
 895                  &spr_read_generic, SPR_NOACCESS,
 896                  0x00000000);
 897     /* XXX : not implemented */
 898     spr_register(env, SPR_SDA, "SDA",
 899                  SPR_NOACCESS, SPR_NOACCESS,
 900                  &spr_read_generic, SPR_NOACCESS,
 901                  0x00000000);
 902     /* External access control */
 903     /* XXX : not implemented */
 904     spr_register(env, SPR_EAR, "EAR",
 905                  SPR_NOACCESS, SPR_NOACCESS,
 906                  &spr_read_generic, &spr_write_generic,
 907                  0x00000000);
 908 }
 909
 910 /* SPR specific to PowerPC 603 implementation */
 911 static void gen_spr_603 (CPUPPCState *env)
 912 {
 913     /* External access control */
 914     /* XXX : not implemented */
 915     spr_register(env, SPR_EAR, "EAR",
 916                  SPR_NOACCESS, SPR_NOACCESS,
 917                  &spr_read_generic, &spr_write_generic,
 918                  0x00000000);
 919 }
 920
 921 /* SPR specific to PowerPC G2 implementation */
 922 static void gen_spr_G2 (CPUPPCState *env)
 923 {
 924     /* Memory base address */
 925     /* MBAR */
 926     spr_register(env, SPR_MBAR, "MBAR",
 927                  SPR_NOACCESS, SPR_NOACCESS,
 928                  &spr_read_generic, &spr_write_generic,
 929                  0x00000000);
 930     /* System version register */
 931     /* SVR */
 932     spr_register(env, SPR_SVR, "SVR",
 933                  SPR_NOACCESS, SPR_NOACCESS,
 934                  &spr_read_generic, SPR_NOACCESS,
 935                  0x00000000);
 936     /* Exception processing */
 937     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
 938                  SPR_NOACCESS, SPR_NOACCESS,
 939                  &spr_read_generic, &spr_write_generic,
 940                  0x00000000);
 941     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
 942                  SPR_NOACCESS, SPR_NOACCESS,
 943                  &spr_read_generic, &spr_write_generic,
 944                  0x00000000);
 945     /* Breakpoints */
 946     /* XXX : not implemented */
 947     spr_register(env, SPR_DABR, "DABR",
 948                  SPR_NOACCESS, SPR_NOACCESS,
 949                  &spr_read_generic, &spr_write_generic,
 950                  0x00000000);
 951     /* XXX : not implemented */
 952     spr_register(env, SPR_DABR2, "DABR2",
 953                  SPR_NOACCESS, SPR_NOACCESS,
 954                  &spr_read_generic, &spr_write_generic,
 955                  0x00000000);
 956     /* XXX : not implemented */
 957     spr_register(env, SPR_IABR, "IABR",
 958                  SPR_NOACCESS, SPR_NOACCESS,
 959                  &spr_read_generic, &spr_write_generic,
 960                  0x00000000);
 961     /* XXX : not implemented */
 962     spr_register(env, SPR_IABR2, "IABR2",
 963                  SPR_NOACCESS, SPR_NOACCESS,
 964                  &spr_read_generic, &spr_write_generic,
 965                  0x00000000);
 966     /* XXX : not implemented */
 967     spr_register(env, SPR_IBCR, "IBCR",
 968                  SPR_NOACCESS, SPR_NOACCESS,
 969                  &spr_read_generic, &spr_write_generic,
 970                  0x00000000);
 971     /* XXX : not implemented */
 972     spr_register(env, SPR_DBCR, "DBCR",
 973                  SPR_NOACCESS, SPR_NOACCESS,
 974                  &spr_read_generic, &spr_write_generic,
 975                  0x00000000);
 976 }
 977
 978 /* SPR specific to PowerPC 602 implementation */
 979 static void gen_spr_602 (CPUPPCState *env)
 980 {
 981     /* ESA registers */
 982     /* XXX : not implemented */
 983     spr_register(env, SPR_SER, "SER",
 984                  SPR_NOACCESS, SPR_NOACCESS,
 985                  &spr_read_generic, &spr_write_generic,
 986                  0x00000000);
 987     /* XXX : not implemented */
 988     spr_register(env, SPR_SEBR, "SEBR",
 989                  SPR_NOACCESS, SPR_NOACCESS,
 990                  &spr_read_generic, &spr_write_generic,
 991                  0x00000000);
 992     /* XXX : not implemented */
 993     spr_register(env, SPR_ESASR, "ESASR",
 994                  SPR_NOACCESS, SPR_NOACCESS,
 995                  &spr_read_generic, &spr_write_generic,
 996                  0x00000000);
 997     /* Floating point status */
 998     /* XXX : not implemented */
 999     spr_register(env, SPR_SP, "SP",
1000                  SPR_NOACCESS, SPR_NOACCESS,
1001                  &spr_read_generic, &spr_write_generic,
1002                  0x00000000);
1003     /* XXX : not implemented */
1004     spr_register(env, SPR_LT, "LT",
1005                  SPR_NOACCESS, SPR_NOACCESS,
1006                  &spr_read_generic, &spr_write_generic,
1007                  0x00000000);
1008     /* Watchdog timer */
1009     /* XXX : not implemented */
1010     spr_register(env, SPR_TCR, "TCR",
1011                  SPR_NOACCESS, SPR_NOACCESS,
1012                  &spr_read_generic, &spr_write_generic,
1013                  0x00000000);
1014     /* Interrupt base */
1015     spr_register(env, SPR_IBR, "IBR",
1016                  SPR_NOACCESS, SPR_NOACCESS,
1017                  &spr_read_generic, &spr_write_generic,
1018                  0x00000000);
1019 }
1020
1021 /* SPR specific to PowerPC 601 implementation */
1022 static void gen_spr_601 (CPUPPCState *env)
1023 {
1024     /* Multiplication/division register */
1025     /* MQ */
1026     spr_register(env, SPR_MQ, "MQ",
1027                  &spr_read_generic, &spr_write_generic,
1028                  &spr_read_generic, &spr_write_generic,
1029                  0x00000000);
1030     /* RTC registers */
1031     spr_register(env, SPR_601_RTCU, "RTCU",
1032                  SPR_NOACCESS, SPR_NOACCESS,
1033                  SPR_NOACCESS, &spr_write_601_rtcu,
1034                  0x00000000);
1035     spr_register(env, SPR_601_VRTCU, "RTCU",
1036                  &spr_read_601_rtcu, SPR_NOACCESS,
1037                  &spr_read_601_rtcu, SPR_NOACCESS,
1038                  0x00000000);
1039     spr_register(env, SPR_601_RTCL, "RTCL",
1040                  SPR_NOACCESS, SPR_NOACCESS,
1041                  SPR_NOACCESS, &spr_write_601_rtcl,
1042                  0x00000000);
1043     spr_register(env, SPR_601_VRTCL, "RTCL",
1044                  &spr_read_601_rtcl, SPR_NOACCESS,
1045                  &spr_read_601_rtcl, SPR_NOACCESS,
1046                  0x00000000);
1047     /* Timer */
1048 #if 0 /* ? */
1049     spr_register(env, SPR_601_UDECR, "UDECR",
1050                  &spr_read_decr, SPR_NOACCESS,
1051                  &spr_read_decr, SPR_NOACCESS,
1052                  0x00000000);
1053 #endif
1054     /* External access control */
1055     /* XXX : not implemented */
1056     spr_register(env, SPR_EAR, "EAR",
1057                  SPR_NOACCESS, SPR_NOACCESS,
1058                  &spr_read_generic, &spr_write_generic,
1059                  0x00000000);
1060     /* Memory management */
1061     spr_register(env, SPR_IBAT0U, "IBAT0U",
1062                  SPR_NOACCESS, SPR_NOACCESS,
1063                  &spr_read_601_ubat, &spr_write_601_ubatu,
1064                  0x00000000);
1065     spr_register(env, SPR_IBAT0L, "IBAT0L",
1066                  SPR_NOACCESS, SPR_NOACCESS,
1067                  &spr_read_601_ubat, &spr_write_601_ubatl,
1068                  0x00000000);
1069     spr_register(env, SPR_IBAT1U, "IBAT1U",
1070                  SPR_NOACCESS, SPR_NOACCESS,
1071                  &spr_read_601_ubat, &spr_write_601_ubatu,
1072                  0x00000000);
1073     spr_register(env, SPR_IBAT1L, "IBAT1L",
1074                  SPR_NOACCESS, SPR_NOACCESS,
1075                  &spr_read_601_ubat, &spr_write_601_ubatl,
1076                  0x00000000);
1077     spr_register(env, SPR_IBAT2U, "IBAT2U",
1078                  SPR_NOACCESS, SPR_NOACCESS,
1079                  &spr_read_601_ubat, &spr_write_601_ubatu,
1080                  0x00000000);
1081     spr_register(env, SPR_IBAT2L, "IBAT2L",
1082                  SPR_NOACCESS, SPR_NOACCESS,
1083                  &spr_read_601_ubat, &spr_write_601_ubatl,
1084                  0x00000000);
1085     spr_register(env, SPR_IBAT3U, "IBAT3U",
1086                  SPR_NOACCESS, SPR_NOACCESS,
1087                  &spr_read_601_ubat, &spr_write_601_ubatu,
1088                  0x00000000);
1089     spr_register(env, SPR_IBAT3L, "IBAT3L",
1090                  SPR_NOACCESS, SPR_NOACCESS,
1091                  &spr_read_601_ubat, &spr_write_601_ubatl,
1092                  0x00000000);
1093 }
1094
1095 /* PowerPC BookE SPR */
1096 static void gen_spr_BookE (CPUPPCState *env)
1097 {
1098     /* Processor identification */
1099     spr_register(env, SPR_BOOKE_PIR, "PIR",
1100                  SPR_NOACCESS, SPR_NOACCESS,
1101                  &spr_read_generic, &spr_write_pir,
1102                  0x00000000);
1103     /* Interrupt processing */
1104     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1105                  SPR_NOACCESS, SPR_NOACCESS,
1106                  &spr_read_generic, &spr_write_generic,
1107                  0x00000000);
1108     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1109                  SPR_NOACCESS, SPR_NOACCESS,
1110                  &spr_read_generic, &spr_write_generic,
1111                  0x00000000);
1112     spr_register(env, SPR_BOOKE_DSRR0, "DSRR0",
1113                  SPR_NOACCESS, SPR_NOACCESS,
1114                  &spr_read_generic, &spr_write_generic,
1115                  0x00000000);
1116     spr_register(env, SPR_BOOKE_DSRR1, "DSRR1",
1117                  SPR_NOACCESS, SPR_NOACCESS,
1118                  &spr_read_generic, &spr_write_generic,
1119                  0x00000000);
1120     spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
1121                  SPR_NOACCESS, SPR_NOACCESS,
1122                  &spr_read_generic, &spr_write_generic,
1123                  0x00000000);
1124     spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
1125                  SPR_NOACCESS, SPR_NOACCESS,
1126                  &spr_read_generic, &spr_write_generic,
1127                  0x00000000);
1128     /* Debug */
1129     /* XXX : not implemented */
1130     spr_register(env, SPR_BOOKE_IAC1, "IAC1",
1131                  SPR_NOACCESS, SPR_NOACCESS,
1132                  &spr_read_generic, &spr_write_generic,
1133                  0x00000000);
1134     /* XXX : not implemented */
1135     spr_register(env, SPR_BOOKE_IAC2, "IAC2",
1136                  SPR_NOACCESS, SPR_NOACCESS,
1137                  &spr_read_generic, &spr_write_generic,
1138                  0x00000000);
1139     /* XXX : not implemented */
1140     spr_register(env, SPR_BOOKE_IAC3, "IAC3",
1141                  SPR_NOACCESS, SPR_NOACCESS,
1142                  &spr_read_generic, &spr_write_generic,
1143                  0x00000000);
1144     /* XXX : not implemented */
1145     spr_register(env, SPR_BOOKE_IAC4, "IAC4",
1146                  SPR_NOACCESS, SPR_NOACCESS,
1147                  &spr_read_generic, &spr_write_generic,
1148                  0x00000000);
1149     /* XXX : not implemented */
1150     spr_register(env, SPR_BOOKE_DAC1, "DAC1",
1151                  SPR_NOACCESS, SPR_NOACCESS,
1152                  &spr_read_generic, &spr_write_generic,
1153                  0x00000000);
1154     /* XXX : not implemented */
1155     spr_register(env, SPR_BOOKE_DAC2, "DAC2",
1156                  SPR_NOACCESS, SPR_NOACCESS,
1157                  &spr_read_generic, &spr_write_generic,
1158                  0x00000000);
1159     /* XXX : not implemented */
1160     spr_register(env, SPR_BOOKE_DVC1, "DVC1",
1161                  SPR_NOACCESS, SPR_NOACCESS,
1162                  &spr_read_generic, &spr_write_generic,
1163                  0x00000000);
1164     /* XXX : not implemented */
1165     spr_register(env, SPR_BOOKE_DVC2, "DVC2",
1166                  SPR_NOACCESS, SPR_NOACCESS,
1167                  &spr_read_generic, &spr_write_generic,
1168                  0x00000000);
1169     /* XXX : not implemented */
1170     spr_register(env, SPR_BOOKE_DBCR0, "DBCR0",
1171                  SPR_NOACCESS, SPR_NOACCESS,
1172                  &spr_read_generic, &spr_write_generic,
1173                  0x00000000);
1174     /* XXX : not implemented */
1175     spr_register(env, SPR_BOOKE_DBCR1, "DBCR1",
1176                  SPR_NOACCESS, SPR_NOACCESS,
1177                  &spr_read_generic, &spr_write_generic,
1178                  0x00000000);
1179     /* XXX : not implemented */
1180     spr_register(env, SPR_BOOKE_DBCR2, "DBCR2",
1181                  SPR_NOACCESS, SPR_NOACCESS,
1182                  &spr_read_generic, &spr_write_generic,
1183                  0x00000000);
1184     /* XXX : not implemented */
1185     spr_register(env, SPR_BOOKE_DBSR, "DBSR",
1186                  SPR_NOACCESS, SPR_NOACCESS,
1187                  &spr_read_generic, &spr_write_clear,
1188                  0x00000000);
1189     spr_register(env, SPR_BOOKE_DEAR, "DEAR",
1190                  SPR_NOACCESS, SPR_NOACCESS,
1191                  &spr_read_generic, &spr_write_generic,
1192                  0x00000000);
1193     spr_register(env, SPR_BOOKE_ESR, "ESR",
1194                  SPR_NOACCESS, SPR_NOACCESS,
1195                  &spr_read_generic, &spr_write_generic,
1196                  0x00000000);
1197     spr_register(env, SPR_BOOKE_IVPR, "IVPR",
1198                  SPR_NOACCESS, SPR_NOACCESS,
1199                  &spr_read_generic, &spr_write_generic,
1200                  0x00000000);
1201     /* Exception vectors */
1202     spr_register(env, SPR_BOOKE_IVPR, "IVPR",
1203                  SPR_NOACCESS, SPR_NOACCESS,
1204                  &spr_read_generic, &spr_write_generic,
1205                  0x00000000);
1206     spr_register(env, SPR_BOOKE_IVOR0, "IVOR0",
1207                  SPR_NOACCESS, SPR_NOACCESS,
1208                  &spr_read_generic, &spr_write_generic,
1209                  0x00000000);
1210     spr_register(env, SPR_BOOKE_IVOR1, "IVOR1",
1211                  SPR_NOACCESS, SPR_NOACCESS,
1212                  &spr_read_generic, &spr_write_generic,
1213                  0x00000000);
1214     spr_register(env, SPR_BOOKE_IVOR2, "IVOR2",
1215                  SPR_NOACCESS, SPR_NOACCESS,
1216                  &spr_read_generic, &spr_write_generic,
1217                  0x00000000);
1218     spr_register(env, SPR_BOOKE_IVOR3, "IVOR3",
1219                  SPR_NOACCESS, SPR_NOACCESS,
1220                  &spr_read_generic, &spr_write_generic,
1221                  0x00000000);
1222     spr_register(env, SPR_BOOKE_IVOR4, "IVOR4",
1223                  SPR_NOACCESS, SPR_NOACCESS,
1224                  &spr_read_generic, &spr_write_generic,
1225                  0x00000000);
1226     spr_register(env, SPR_BOOKE_IVOR5, "IVOR5",
1227                  SPR_NOACCESS, SPR_NOACCESS,
1228                  &spr_read_generic, &spr_write_generic,
1229                  0x00000000);
1230     spr_register(env, SPR_BOOKE_IVOR6, "IVOR6",
1231                  SPR_NOACCESS, SPR_NOACCESS,
1232                  &spr_read_generic, &spr_write_generic,
1233                  0x00000000);
1234     spr_register(env, SPR_BOOKE_IVOR7, "IVOR7",
1235                  SPR_NOACCESS, SPR_NOACCESS,
1236                  &spr_read_generic, &spr_write_generic,
1237                  0x00000000);
1238     spr_register(env, SPR_BOOKE_IVOR8, "IVOR8",
1239                  SPR_NOACCESS, SPR_NOACCESS,
1240                  &spr_read_generic, &spr_write_generic,
1241                  0x00000000);
1242     spr_register(env, SPR_BOOKE_IVOR9, "IVOR9",
1243                  SPR_NOACCESS, SPR_NOACCESS,
1244                  &spr_read_generic, &spr_write_generic,
1245                  0x00000000);
1246     spr_register(env, SPR_BOOKE_IVOR10, "IVOR10",
1247                  SPR_NOACCESS, SPR_NOACCESS,
1248                  &spr_read_generic, &spr_write_generic,
1249                  0x00000000);
1250     spr_register(env, SPR_BOOKE_IVOR11, "IVOR11",
1251                  SPR_NOACCESS, SPR_NOACCESS,
1252                  &spr_read_generic, &spr_write_generic,
1253                  0x00000000);
1254     spr_register(env, SPR_BOOKE_IVOR12, "IVOR12",
1255                  SPR_NOACCESS, SPR_NOACCESS,
1256                  &spr_read_generic, &spr_write_generic,
1257                  0x00000000);
1258     spr_register(env, SPR_BOOKE_IVOR13, "IVOR13",
1259                  SPR_NOACCESS, SPR_NOACCESS,
1260                  &spr_read_generic, &spr_write_generic,
1261                  0x00000000);
1262     spr_register(env, SPR_BOOKE_IVOR14, "IVOR14",
1263                  SPR_NOACCESS, SPR_NOACCESS,
1264                  &spr_read_generic, &spr_write_generic,
1265                  0x00000000);
1266     spr_register(env, SPR_BOOKE_IVOR15, "IVOR15",
1267                  SPR_NOACCESS, SPR_NOACCESS,
1268                  &spr_read_generic, &spr_write_generic,
1269                  0x00000000);
1270     spr_register(env, SPR_BOOKE_IVOR32, "IVOR32",
1271                  SPR_NOACCESS, SPR_NOACCESS,
1272                  &spr_read_generic, &spr_write_generic,
1273                  0x00000000);
1274     spr_register(env, SPR_BOOKE_IVOR33, "IVOR33",
1275                  SPR_NOACCESS, SPR_NOACCESS,
1276                  &spr_read_generic, &spr_write_generic,
1277                  0x00000000);
1278     spr_register(env, SPR_BOOKE_IVOR34, "IVOR34",
1279                  SPR_NOACCESS, SPR_NOACCESS,
1280                  &spr_read_generic, &spr_write_generic,
1281                  0x00000000);
1282     spr_register(env, SPR_BOOKE_IVOR35, "IVOR35",
1283                  SPR_NOACCESS, SPR_NOACCESS,
1284                  &spr_read_generic, &spr_write_generic,
1285                  0x00000000);
1286     spr_register(env, SPR_BOOKE_IVOR36, "IVOR36",
1287                  SPR_NOACCESS, SPR_NOACCESS,
1288                  &spr_read_generic, &spr_write_generic,
1289                  0x00000000);
1290     spr_register(env, SPR_BOOKE_IVOR37, "IVOR37",
1291                  SPR_NOACCESS, SPR_NOACCESS,
1292                  &spr_read_generic, &spr_write_generic,
1293                  0x00000000);
1294     spr_register(env, SPR_BOOKE_PID, "PID",
1295                  SPR_NOACCESS, SPR_NOACCESS,
1296                  &spr_read_generic, &spr_write_generic,
1297                  0x00000000);
1298     spr_register(env, SPR_BOOKE_TCR, "TCR",
1299                  SPR_NOACCESS, SPR_NOACCESS,
1300                  &spr_read_generic, &spr_write_booke_tcr,
1301                  0x00000000);
1302     spr_register(env, SPR_BOOKE_TSR, "TSR",
1303                  SPR_NOACCESS, SPR_NOACCESS,
1304                  &spr_read_generic, &spr_write_booke_tsr,
1305                  0x00000000);
1306     /* Timer */
1307     spr_register(env, SPR_DECR, "DECR",
1308                  SPR_NOACCESS, SPR_NOACCESS,
1309                  &spr_read_decr, &spr_write_decr,
1310                  0x00000000);
1311     spr_register(env, SPR_BOOKE_DECAR, "DECAR",
1312                  SPR_NOACCESS, SPR_NOACCESS,
1313                  SPR_NOACCESS, &spr_write_generic,
1314                  0x00000000);
1315     /* SPRGs */
1316     spr_register(env, SPR_USPRG0, "USPRG0",
1317                  &spr_read_generic, &spr_write_generic,
1318                  &spr_read_generic, &spr_write_generic,
1319                  0x00000000);
1320     spr_register(env, SPR_SPRG4, "SPRG4",
1321                  SPR_NOACCESS, SPR_NOACCESS,
1322                  &spr_read_generic, &spr_write_generic,
1323                  0x00000000);
1324     spr_register(env, SPR_USPRG4, "USPRG4",
1325                  &spr_read_ureg, SPR_NOACCESS,
1326                  &spr_read_ureg, SPR_NOACCESS,
1327                  0x00000000);
1328     spr_register(env, SPR_SPRG5, "SPRG5",
1329                  SPR_NOACCESS, SPR_NOACCESS,
1330                  &spr_read_generic, &spr_write_generic,
1331                  0x00000000);
1332     spr_register(env, SPR_USPRG5, "USPRG5",
1333                  &spr_read_ureg, SPR_NOACCESS,
1334                  &spr_read_ureg, SPR_NOACCESS,
1335                  0x00000000);
1336     spr_register(env, SPR_SPRG6, "SPRG6",
1337                  SPR_NOACCESS, SPR_NOACCESS,
1338                  &spr_read_generic, &spr_write_generic,
1339                  0x00000000);
1340     spr_register(env, SPR_USPRG6, "USPRG6",
1341                  &spr_read_ureg, SPR_NOACCESS,
1342                  &spr_read_ureg, SPR_NOACCESS,
1343                  0x00000000);
1344     spr_register(env, SPR_SPRG7, "SPRG7",
1345                  SPR_NOACCESS, SPR_NOACCESS,
1346                  &spr_read_generic, &spr_write_generic,
1347                  0x00000000);
1348     spr_register(env, SPR_USPRG7, "USPRG7",
1349                  &spr_read_ureg, SPR_NOACCESS,
1350                  &spr_read_ureg, SPR_NOACCESS,
1351                  0x00000000);
1352 }
1353
1354 /* FSL storage control registers */
1355 static void gen_spr_BookE_FSL (CPUPPCState *env)
1356 {
1357     /* TLB assist registers */
1358     spr_register(env, SPR_BOOKE_MAS0, "MAS0",
1359                  SPR_NOACCESS, SPR_NOACCESS,
1360                  &spr_read_generic, &spr_write_generic,
1361                  0x00000000);
1362     spr_register(env, SPR_BOOKE_MAS1, "MAS2",
1363                  SPR_NOACCESS, SPR_NOACCESS,
1364                  &spr_read_generic, &spr_write_generic,
1365                  0x00000000);
1366     spr_register(env, SPR_BOOKE_MAS2, "MAS3",
1367                  SPR_NOACCESS, SPR_NOACCESS,
1368                  &spr_read_generic, &spr_write_generic,
1369                  0x00000000);
1370     spr_register(env, SPR_BOOKE_MAS3, "MAS4",
1371                  SPR_NOACCESS, SPR_NOACCESS,
1372                  &spr_read_generic, &spr_write_generic,
1373                  0x00000000);
1374     spr_register(env, SPR_BOOKE_MAS4, "MAS5",
1375                  SPR_NOACCESS, SPR_NOACCESS,
1376                  &spr_read_generic, &spr_write_generic,
1377                  0x00000000);
1378     spr_register(env, SPR_BOOKE_MAS6, "MAS6",
1379                  SPR_NOACCESS, SPR_NOACCESS,
1380                  &spr_read_generic, &spr_write_generic,
1381                  0x00000000);
1382     spr_register(env, SPR_BOOKE_MAS7, "MAS7",
1383                  SPR_NOACCESS, SPR_NOACCESS,
1384                  &spr_read_generic, &spr_write_generic,
1385                  0x00000000);
1386     if (env->nb_pids > 1) {
1387         spr_register(env, SPR_BOOKE_PID1, "PID1",
1388                      SPR_NOACCESS, SPR_NOACCESS,
1389                      &spr_read_generic, &spr_write_generic,
1390                      0x00000000);
1391     }
1392     if (env->nb_pids > 2) {
1393         spr_register(env, SPR_BOOKE_PID2, "PID2",
1394                      SPR_NOACCESS, SPR_NOACCESS,
1395                      &spr_read_generic, &spr_write_generic,
1396                      0x00000000);
1397     }
1398     spr_register(env, SPR_BOOKE_MMUCFG, "MMUCFG",
1399                  SPR_NOACCESS, SPR_NOACCESS,
1400                  &spr_read_generic, SPR_NOACCESS,
1401                  0x00000000); /* TOFIX */
1402     spr_register(env, SPR_BOOKE_MMUCSR0, "MMUCSR0",
1403                  SPR_NOACCESS, SPR_NOACCESS,
1404                  &spr_read_generic, &spr_write_generic,
1405                  0x00000000); /* TOFIX */
1406     switch (env->nb_ways) {
1407     case 4:
1408         spr_register(env, SPR_BOOKE_TLB3CFG, "TLB3CFG",
1409                      SPR_NOACCESS, SPR_NOACCESS,
1410                      &spr_read_generic, SPR_NOACCESS,
1411                      0x00000000); /* TOFIX */
1412         /* Fallthru */
1413     case 3:
1414         spr_register(env, SPR_BOOKE_TLB2CFG, "TLB2CFG",
1415                      SPR_NOACCESS, SPR_NOACCESS,
1416                      &spr_read_generic, SPR_NOACCESS,
1417                      0x00000000); /* TOFIX */
1418         /* Fallthru */
1419     case 2:
1420         spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
1421                      SPR_NOACCESS, SPR_NOACCESS,
1422                      &spr_read_generic, SPR_NOACCESS,
1423                      0x00000000); /* TOFIX */
1424         /* Fallthru */
1425     case 1:
1426         spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
1427                      SPR_NOACCESS, SPR_NOACCESS,
1428                      &spr_read_generic, SPR_NOACCESS,
1429                      0x00000000); /* TOFIX */
1430         /* Fallthru */
1431     case 0:
1432     default:
1433         break;
1434     }
1435 }
1436
1437 /* SPR specific to PowerPC 440 implementation */
1438 static void gen_spr_440 (CPUPPCState *env)
1439 {
1440     /* Cache control */
1441     /* XXX : not implemented */
1442     spr_register(env, SPR_440_DNV0, "DNV0",
1443                  SPR_NOACCESS, SPR_NOACCESS,
1444                  &spr_read_generic, &spr_write_generic,
1445                  0x00000000);
1446     /* XXX : not implemented */
1447     spr_register(env, SPR_440_DNV1, "DNV1",
1448                  SPR_NOACCESS, SPR_NOACCESS,
1449                  &spr_read_generic, &spr_write_generic,
1450                  0x00000000);
1451     /* XXX : not implemented */
1452     spr_register(env, SPR_440_DNV2, "DNV2",
1453                  SPR_NOACCESS, SPR_NOACCESS,
1454                  &spr_read_generic, &spr_write_generic,
1455                  0x00000000);
1456     /* XXX : not implemented */
1457     spr_register(env, SPR_440_DNV3, "DNV3",
1458                  SPR_NOACCESS, SPR_NOACCESS,
1459                  &spr_read_generic, &spr_write_generic,
1460                  0x00000000);
1461     /* XXX : not implemented */
1462     spr_register(env, SPR_440_DVT0, "DVT0",
1463                  SPR_NOACCESS, SPR_NOACCESS,
1464                  &spr_read_generic, &spr_write_generic,
1465                  0x00000000);
1466     /* XXX : not implemented */
1467     spr_register(env, SPR_440_DVT1, "DVT1",
1468                  SPR_NOACCESS, SPR_NOACCESS,
1469                  &spr_read_generic, &spr_write_generic,
1470                  0x00000000);
1471     /* XXX : not implemented */
1472     spr_register(env, SPR_440_DVT2, "DVT2",
1473                  SPR_NOACCESS, SPR_NOACCESS,
1474                  &spr_read_generic, &spr_write_generic,
1475                  0x00000000);
1476     /* XXX : not implemented */
1477     spr_register(env, SPR_440_DVT3, "DVT3",
1478                  SPR_NOACCESS, SPR_NOACCESS,
1479                  &spr_read_generic, &spr_write_generic,
1480                  0x00000000);
1481     /* XXX : not implemented */
1482     spr_register(env, SPR_440_DVLIM, "DVLIM",
1483                  SPR_NOACCESS, SPR_NOACCESS,
1484                  &spr_read_generic, &spr_write_generic,
1485                  0x00000000);
1486     /* XXX : not implemented */
1487     spr_register(env, SPR_440_INV0, "INV0",
1488                  SPR_NOACCESS, SPR_NOACCESS,
1489                  &spr_read_generic, &spr_write_generic,
1490                  0x00000000);
1491     /* XXX : not implemented */
1492     spr_register(env, SPR_440_INV1, "INV1",
1493                  SPR_NOACCESS, SPR_NOACCESS,
1494                  &spr_read_generic, &spr_write_generic,
1495                  0x00000000);
1496     /* XXX : not implemented */
1497     spr_register(env, SPR_440_INV2, "INV2",
1498                  SPR_NOACCESS, SPR_NOACCESS,
1499                  &spr_read_generic, &spr_write_generic,
1500                  0x00000000);
1501     /* XXX : not implemented */
1502     spr_register(env, SPR_440_INV3, "INV3",
1503                  SPR_NOACCESS, SPR_NOACCESS,
1504                  &spr_read_generic, &spr_write_generic,
1505                  0x00000000);
1506     /* XXX : not implemented */
1507     spr_register(env, SPR_440_IVT0, "IVT0",
1508                  SPR_NOACCESS, SPR_NOACCESS,
1509                  &spr_read_generic, &spr_write_generic,
1510                  0x00000000);
1511     /* XXX : not implemented */
1512     spr_register(env, SPR_440_IVT1, "IVT1",
1513                  SPR_NOACCESS, SPR_NOACCESS,
1514                  &spr_read_generic, &spr_write_generic,
1515                  0x00000000);
1516     /* XXX : not implemented */
1517     spr_register(env, SPR_440_IVT2, "IVT2",
1518                  SPR_NOACCESS, SPR_NOACCESS,
1519                  &spr_read_generic, &spr_write_generic,
1520                  0x00000000);
1521     /* XXX : not implemented */
1522     spr_register(env, SPR_440_IVT3, "IVT3",
1523                  SPR_NOACCESS, SPR_NOACCESS,
1524                  &spr_read_generic, &spr_write_generic,
1525                  0x00000000);
1526     /* XXX : not implemented */
1527     spr_register(env, SPR_440_IVLIM, "IVLIM",
1528                  SPR_NOACCESS, SPR_NOACCESS,
1529                  &spr_read_generic, &spr_write_generic,
1530                  0x00000000);
1531     /* Cache debug */
1532     /* XXX : not implemented */
1533     spr_register(env, SPR_BOOKE_DCBTRH, "DCBTRH",
1534                  SPR_NOACCESS, SPR_NOACCESS,
1535                  &spr_read_generic, SPR_NOACCESS,
1536                  0x00000000);
1537     /* XXX : not implemented */
1538     spr_register(env, SPR_BOOKE_DCBTRL, "DCBTRL",
1539                  SPR_NOACCESS, SPR_NOACCESS,
1540                  &spr_read_generic, SPR_NOACCESS,
1541                  0x00000000);
1542     /* XXX : not implemented */
1543     spr_register(env, SPR_BOOKE_ICBDR, "ICBDR",
1544                  SPR_NOACCESS, SPR_NOACCESS,
1545                  &spr_read_generic, SPR_NOACCESS,
1546                  0x00000000);
1547     /* XXX : not implemented */
1548     spr_register(env, SPR_BOOKE_ICBTRH, "ICBTRH",
1549                  SPR_NOACCESS, SPR_NOACCESS,
1550                  &spr_read_generic, SPR_NOACCESS,
1551                  0x00000000);
1552     /* XXX : not implemented */
1553     spr_register(env, SPR_BOOKE_ICBTRL, "ICBTRL",
1554                  SPR_NOACCESS, SPR_NOACCESS,
1555                  &spr_read_generic, SPR_NOACCESS,
1556                  0x00000000);
1557     /* XXX : not implemented */
1558     spr_register(env, SPR_440_DBDR, "DBDR",
1559                  SPR_NOACCESS, SPR_NOACCESS,
1560                  &spr_read_generic, &spr_write_generic,
1561                  0x00000000);
1562     /* Processor control */
1563     spr_register(env, SPR_4xx_CCR0, "CCR0",
1564                  SPR_NOACCESS, SPR_NOACCESS,
1565                  &spr_read_generic, &spr_write_generic,
1566                  0x00000000);
1567     spr_register(env, SPR_440_RSTCFG, "RSTCFG",
1568                  SPR_NOACCESS, SPR_NOACCESS,
1569                  &spr_read_generic, SPR_NOACCESS,
1570                  0x00000000);
1571     /* Storage control */
1572     spr_register(env, SPR_440_MMUCR, "MMUCR",
1573                  SPR_NOACCESS, SPR_NOACCESS,
1574                  &spr_read_generic, &spr_write_generic,
1575                  0x00000000);
1576 }
1577
1578 /* SPR shared between PowerPC 40x implementations */
1579 static void gen_spr_40x (CPUPPCState *env)
1580 {
1581     /* Cache */
1582     /* XXX : not implemented */
1583     spr_register(env, SPR_40x_DCCR, "DCCR",
1584                  SPR_NOACCESS, SPR_NOACCESS,
1585                  &spr_read_generic, &spr_write_generic,
1586                  0x00000000);
1587     /* XXX : not implemented */
1588     spr_register(env, SPR_40x_DCWR, "DCWR",
1589                  SPR_NOACCESS, SPR_NOACCESS,
1590                  &spr_read_generic, &spr_write_generic,
1591                  0x00000000);
1592     /* XXX : not implemented */
1593     spr_register(env, SPR_40x_ICCR, "ICCR",
1594                  SPR_NOACCESS, SPR_NOACCESS,
1595                  &spr_read_generic, &spr_write_generic,
1596                  0x00000000);
1597     /* XXX : not implemented */
1598     spr_register(env, SPR_BOOKE_ICBDR, "ICBDR",
1599                  SPR_NOACCESS, SPR_NOACCESS,
1600                  &spr_read_generic, SPR_NOACCESS,
1601                  0x00000000);
1602     /* Bus access control */
1603     spr_register(env, SPR_40x_SGR, "SGR",
1604                  SPR_NOACCESS, SPR_NOACCESS,
1605                  &spr_read_generic, &spr_write_generic,
1606                  0xFFFFFFFF);
1607     spr_register(env, SPR_40x_ZPR, "ZPR",
1608                  SPR_NOACCESS, SPR_NOACCESS,
1609                  &spr_read_generic, &spr_write_generic,
1610                  0x00000000);
1611     /* MMU */
1612     spr_register(env, SPR_40x_PID, "PID",
1613                  SPR_NOACCESS, SPR_NOACCESS,
1614                  &spr_read_generic, &spr_write_generic,
1615                  0x00000000);
1616     /* Exception */
1617     spr_register(env, SPR_40x_DEAR, "DEAR",
1618                  SPR_NOACCESS, SPR_NOACCESS,
1619                  &spr_read_generic, &spr_write_generic,
1620                  0x00000000);
1621     spr_register(env, SPR_40x_ESR, "ESR",
1622                  SPR_NOACCESS, SPR_NOACCESS,
1623                  &spr_read_generic, &spr_write_generic,
1624                  0x00000000);
1625     spr_register(env, SPR_40x_EVPR, "EVPR",
1626                  SPR_NOACCESS, SPR_NOACCESS,
1627                  &spr_read_generic, &spr_write_generic,
1628                  0x00000000);
1629     spr_register(env, SPR_40x_SRR2, "SRR2",
1630                  &spr_read_generic, &spr_write_generic,
1631                  &spr_read_generic, &spr_write_generic,
1632                  0x00000000);
1633     spr_register(env, SPR_40x_SRR3, "SRR3",
1634                  &spr_read_generic, &spr_write_generic,
1635                  &spr_read_generic, &spr_write_generic,
1636                  0x00000000);
1637     /* Timers */
1638     spr_register(env, SPR_40x_PIT, "PIT",
1639                  SPR_NOACCESS, SPR_NOACCESS,
1640                  &spr_read_40x_pit, &spr_write_40x_pit,
1641                  0x00000000);
1642     spr_register(env, SPR_40x_TCR, "TCR",
1643                  SPR_NOACCESS, SPR_NOACCESS,
1644                  &spr_read_generic, &spr_write_booke_tcr,
1645                  0x00000000);
1646     spr_register(env, SPR_40x_TSR, "TSR",
1647                  SPR_NOACCESS, SPR_NOACCESS,
1648                  &spr_read_generic, &spr_write_booke_tsr,
1649                  0x00000000);
1650     /* Debug interface */
1651     /* XXX : not implemented */
1652     spr_register(env, SPR_40x_DAC1, "DAC1",
1653                  SPR_NOACCESS, SPR_NOACCESS,
1654                  &spr_read_generic, &spr_write_generic,
1655                  0x00000000);
1656     spr_register(env, SPR_40x_DAC2, "DAC2",
1657                  SPR_NOACCESS, SPR_NOACCESS,
1658                  &spr_read_generic, &spr_write_generic,
1659                  0x00000000);
1660     /* XXX : not implemented */
1661     spr_register(env, SPR_40x_DBCR0, "DBCR0",
1662                  SPR_NOACCESS, SPR_NOACCESS,
1663                  &spr_read_generic, &spr_write_40x_dbcr0,
1664                  0x00000000);
1665     /* XXX : not implemented */
1666     spr_register(env, SPR_40x_DBSR, "DBSR",
1667                  SPR_NOACCESS, SPR_NOACCESS,
1668                  &spr_read_generic, &spr_write_clear,
1669                  /* Last reset was system reset */
1670                  0x00000300);
1671     /* XXX : not implemented */
1672     spr_register(env, SPR_40x_IAC1, "IAC1",
1673                  SPR_NOACCESS, SPR_NOACCESS,
1674                  &spr_read_generic, &spr_write_generic,
1675                  0x00000000);
1676     spr_register(env, SPR_40x_IAC2, "IAC2",
1677                  SPR_NOACCESS, SPR_NOACCESS,
1678                  &spr_read_generic, &spr_write_generic,
1679                  0x00000000);
1680 }
1681
1682 /* SPR specific to PowerPC 405 implementation */
1683 static void gen_spr_405 (CPUPPCState *env)
1684 {
1685     spr_register(env, SPR_4xx_CCR0, "CCR0",
1686                  SPR_NOACCESS, SPR_NOACCESS,
1687                  &spr_read_generic, &spr_write_generic,
1688                  0x00700000);
1689     /* Debug */
1690     /* XXX : not implemented */
1691     spr_register(env, SPR_405_DBCR1, "DBCR1",
1692                  SPR_NOACCESS, SPR_NOACCESS,
1693                  &spr_read_generic, &spr_write_generic,
1694                  0x00000000);
1695     /* XXX : not implemented */
1696     spr_register(env, SPR_405_DVC1, "DVC1",
1697                  SPR_NOACCESS, SPR_NOACCESS,
1698                  &spr_read_generic, &spr_write_generic,
1699                  0x00000000);
1700     /* XXX : not implemented */
1701     spr_register(env, SPR_405_DVC2, "DVC2",
1702                  SPR_NOACCESS, SPR_NOACCESS,
1703                  &spr_read_generic, &spr_write_generic,
1704                  0x00000000);
1705     /* XXX : not implemented */
1706     spr_register(env, SPR_405_IAC3, "IAC3",
1707                  SPR_NOACCESS, SPR_NOACCESS,
1708                  &spr_read_generic, &spr_write_generic,
1709                  0x00000000);
1710     /* XXX : not implemented */
1711     spr_register(env, SPR_405_IAC4, "IAC4",
1712                  SPR_NOACCESS, SPR_NOACCESS,
1713                  &spr_read_generic, &spr_write_generic,
1714                  0x00000000);
1715     /* Storage control */
1716     /* XXX : not implemented */
1717     spr_register(env, SPR_405_SLER, "SLER",
1718                  SPR_NOACCESS, SPR_NOACCESS,
1719                  &spr_read_generic, &spr_write_generic,
1720                  0x00000000);
1721     /* XXX : not implemented */
1722     spr_register(env, SPR_405_SU0R, "SU0R",
1723                  SPR_NOACCESS, SPR_NOACCESS,
1724                  &spr_read_generic, &spr_write_generic,
1725                  0x00000000);
1726     /* SPRG */
1727     spr_register(env, SPR_USPRG0, "USPRG0",
1728                  &spr_read_ureg, SPR_NOACCESS,
1729                  &spr_read_ureg, SPR_NOACCESS,
1730                  0x00000000);
1731     spr_register(env, SPR_SPRG4, "SPRG4",
1732                  SPR_NOACCESS, SPR_NOACCESS,
1733                  SPR_NOACCESS, &spr_write_generic,
1734                  0x00000000);
1735     spr_register(env, SPR_USPRG4, "USPRG4",
1736                  &spr_read_ureg, SPR_NOACCESS,
1737                  &spr_read_ureg, SPR_NOACCESS,
1738                  0x00000000);
1739     spr_register(env, SPR_SPRG5, "SPRG5",
1740                  SPR_NOACCESS, SPR_NOACCESS,
1741                  SPR_NOACCESS, &spr_write_generic,
1742                  0x00000000);
1743     spr_register(env, SPR_USPRG5, "USPRG5",
1744                  &spr_read_ureg, SPR_NOACCESS,
1745                  &spr_read_ureg, SPR_NOACCESS,
1746                  0x00000000);
1747     spr_register(env, SPR_SPRG6, "SPRG6",
1748                  SPR_NOACCESS, SPR_NOACCESS,
1749                  SPR_NOACCESS, &spr_write_generic,
1750                  0x00000000);
1751     spr_register(env, SPR_USPRG6, "USPRG6",
1752                  &spr_read_ureg, SPR_NOACCESS,
1753                  &spr_read_ureg, SPR_NOACCESS,
1754                  0x00000000);
1755     spr_register(env, SPR_SPRG7, "SPRG7",
1756                  SPR_NOACCESS, SPR_NOACCESS,
1757                  SPR_NOACCESS, &spr_write_generic,
1758                  0x00000000);
1759     spr_register(env, SPR_USPRG7, "USPRG7",
1760                  &spr_read_ureg, SPR_NOACCESS,
1761                  &spr_read_ureg, SPR_NOACCESS,
1762                  0x00000000);
1763 }
1764
1765 /* SPR shared between PowerPC 401 & 403 implementations */
1766 static void gen_spr_401_403 (CPUPPCState *env)
1767 {
1768     /* Time base */
1769     spr_register(env, SPR_403_VTBL,  "TBL",
1770                  &spr_read_tbl, SPR_NOACCESS,
1771                  &spr_read_tbl, SPR_NOACCESS,
1772                  0x00000000);
1773     spr_register(env, SPR_403_TBL,   "TBL",
1774                  SPR_NOACCESS, SPR_NOACCESS,
1775                  SPR_NOACCESS, &spr_write_tbl,
1776                  0x00000000);
1777     spr_register(env, SPR_403_VTBU,  "TBU",
1778                  &spr_read_tbu, SPR_NOACCESS,
1779                  &spr_read_tbu, SPR_NOACCESS,
1780                  0x00000000);
1781     spr_register(env, SPR_403_TBU,   "TBU",
1782                  SPR_NOACCESS, SPR_NOACCESS,
1783                  SPR_NOACCESS, &spr_write_tbu,
1784                  0x00000000);
1785     /* Debug */
1786     /* XXX: not implemented */
1787     spr_register(env, SPR_403_CDBCR, "CDBCR",
1788                  SPR_NOACCESS, SPR_NOACCESS,
1789                  &spr_read_generic, &spr_write_generic,
1790                  0x00000000);
1791 }
1792
1793 /* SPR specific to PowerPC 403 implementation */
1794 static void gen_spr_403 (CPUPPCState *env)
1795 {
1796     /* MMU */
1797     spr_register(env, SPR_403_PBL1,  "PBL1",
1798                  SPR_NOACCESS, SPR_NOACCESS,
1799                  &spr_read_403_pbr, &spr_write_403_pbr,
1800                  0x00000000);
1801     spr_register(env, SPR_403_PBU1,  "PBU1",
1802                  SPR_NOACCESS, SPR_NOACCESS,
1803                  &spr_read_403_pbr, &spr_write_403_pbr,
1804                  0x00000000);
1805     spr_register(env, SPR_403_PBL2,  "PBL2",
1806                  SPR_NOACCESS, SPR_NOACCESS,
1807                  &spr_read_403_pbr, &spr_write_403_pbr,
1808                  0x00000000);
1809     spr_register(env, SPR_403_PBU2,  "PBU2",
1810                  SPR_NOACCESS, SPR_NOACCESS,
1811                  &spr_read_403_pbr, &spr_write_403_pbr,
1812                  0x00000000);
1813     /* Debug */
1814     /* XXX : not implemented */
1815     spr_register(env, SPR_40x_DAC2, "DAC2",
1816                  SPR_NOACCESS, SPR_NOACCESS,
1817                  &spr_read_generic, &spr_write_generic,
1818                  0x00000000);
1819     /* XXX : not implemented */
1820     spr_register(env, SPR_40x_IAC2, "IAC2",
1821                  SPR_NOACCESS, SPR_NOACCESS,
1822                  &spr_read_generic, &spr_write_generic,
1823                  0x00000000);
1824 }
1825
1826 /* SPR specific to PowerPC compression coprocessor extension */
1827 #if defined (TODO)
1828 static void gen_spr_compress (CPUPPCState *env)
1829 {
1830     spr_register(env, SPR_401_SKR, "SKR",
1831                  SPR_NOACCESS, SPR_NOACCESS,
1832                  &spr_read_generic, &spr_write_generic,
1833                  0x00000000);
1834 }
1835 #endif
1836
1837 // XXX: TODO (64 bits PowerPC SPRs)
1838 /*
1839  * ASR => SPR 280 (64 bits)
1840  * FPECR => SPR 1022 (?)
1841  * VRSAVE => SPR 256 (Altivec)
1842  * SCOMC => SPR 276 (64 bits ?)
1843  * SCOMD => SPR 277 (64 bits ?)
1844  * HSPRG0 => SPR 304 (hypervisor)
1845  * HSPRG1 => SPR 305 (hypervisor)
1846  * HDEC => SPR 310 (hypervisor)
1847  * HIOR => SPR 311 (hypervisor)
1848  * RMOR => SPR 312 (970)
1849  * HRMOR => SPR 313 (hypervisor)
1850  * HSRR0 => SPR 314 (hypervisor)
1851  * HSRR1 => SPR 315 (hypervisor)
1852  * LPCR => SPR 316 (970)
1853  * LPIDR => SPR 317 (970)
1854  * ... and more (thermal management, performance counters, ...)
1855  */
1856
1857 static void init_ppc_proc (CPUPPCState *env, ppc_def_t *def)
1858 {
1859     env->reserve = -1;
1860     /* Default MMU definitions */
1861     env->nb_BATs = -1;
1862     env->nb_tlb = 0;
1863     env->nb_ways = 0;
1864     /* XXX: missing:
1865      * 32 bits PowerPC:
1866      * - MPC5xx(x)
1867      * - MPC8xx(x)
1868      * - RCPU (same as MPC5xx ?)
1869      */
1870     spr_register(env, SPR_PVR, "PVR",
1871                  SPR_NOACCESS, SPR_NOACCESS,
1872                  &spr_read_generic, SPR_NOACCESS,
1873                  def->pvr);
1874     printf("%s: PVR %08x mask %08x => %08x\n", __func__,
1875            def->pvr, def->pvr_mask, def->pvr & def->pvr_mask);
1876     switch (def->pvr) {
1877     /* Embedded PowerPC from IBM                           */
1878     case CPU_PPC_401A1:   /* 401 A1 family                 */
1879     case CPU_PPC_401B2:   /* 401 B2 family                 */
1880     case CPU_PPC_401C2:   /* 401 C2 family                 */
1881     case CPU_PPC_401D2:   /* 401 D2 family                 */
1882     case CPU_PPC_401E2:   /* 401 E2 family                 */
1883     case CPU_PPC_401F2:   /* 401 F2 family                 */
1884     case CPU_PPC_401G2:   /* 401 G2 family                 */
1885     case CPU_PPC_IOP480:  /* IOP 480 family                */
1886     case CPU_PPC_COBRA:   /* IBM Processor for Network Resources */
1887         gen_spr_generic(env);
1888         gen_spr_40x(env);
1889         gen_spr_401_403(env);
1890 #if defined (TODO)
1891         /* XXX: optional ? */
1892         gen_spr_compress(env);
1893 #endif
1894         env->nb_BATs = 0;
1895         env->nb_tlb = 64;
1896         env->nb_ways = 1;
1897         env->id_tlbs = 0;
1898         /* XXX: TODO: allocate internal IRQ controller */
1899         break;
1900
1901     case CPU_PPC_403GA:   /* 403 GA family                 */
1902     case CPU_PPC_403GB:   /* 403 GB family                 */
1903     case CPU_PPC_403GC:   /* 403 GC family                 */
1904     case CPU_PPC_403GCX:  /* 403 GCX family                */
1905         gen_spr_generic(env);
1906         gen_spr_40x(env);
1907         gen_spr_401_403(env);
1908         gen_spr_403(env);
1909         env->nb_BATs = 0;
1910         env->nb_tlb = 64;
1911         env->nb_ways = 1;
1912         env->id_tlbs = 0;
1913         /* XXX: TODO: allocate internal IRQ controller */
1914         break;
1915
1916     case CPU_PPC_405CR:   /* 405 GP/CR family              */
1917     case CPU_PPC_405EP:   /* 405 EP family                 */
1918     case CPU_PPC_405GPR:  /* 405 GPR family                */
1919     case CPU_PPC_405D2:   /* 405 D2 family                 */
1920     case CPU_PPC_405D4:   /* 405 D4 family                 */
1921         gen_spr_generic(env);
1922         /* Time base */
1923         gen_tbl(env);
1924         gen_spr_40x(env);
1925         gen_spr_405(env);
1926         env->nb_BATs = 0;
1927         env->nb_tlb = 64;
1928         env->nb_ways = 1;
1929         env->id_tlbs = 0;
1930         /* Allocate hardware IRQ controller */
1931         ppc405_irq_init(env);
1932         break;
1933
1934     case CPU_PPC_NPE405H: /* NPe405 H family               */
1935     case CPU_PPC_NPE405H2:
1936     case CPU_PPC_NPE405L: /* Npe405 L family               */
1937         gen_spr_generic(env);
1938         /* Time base */
1939         gen_tbl(env);
1940         gen_spr_40x(env);
1941         gen_spr_405(env);
1942         env->nb_BATs = 0;
1943         env->nb_tlb = 64;
1944         env->nb_ways = 1;
1945         env->id_tlbs = 0;
1946         /* Allocate hardware IRQ controller */
1947         ppc405_irq_init(env);
1948         break;
1949
1950 #if defined (TODO)
1951     case CPU_PPC_STB01000:
1952 #endif
1953 #if defined (TODO)
1954     case CPU_PPC_STB01010:
1955 #endif
1956 #if defined (TODO)
1957     case CPU_PPC_STB0210:
1958 #endif
1959     case CPU_PPC_STB03:   /* STB03 family                  */
1960 #if defined (TODO)
1961     case CPU_PPC_STB043:  /* STB043 family                  */
1962 #endif
1963 #if defined (TODO)
1964     case CPU_PPC_STB045:  /* STB045 family                  */
1965 #endif
1966     case CPU_PPC_STB25:   /* STB25 family                  */
1967 #if defined (TODO)
1968     case CPU_PPC_STB130:  /* STB130 family                 */
1969 #endif
1970         gen_spr_generic(env);
1971         /* Time base */
1972         gen_tbl(env);
1973         gen_spr_40x(env);
1974         gen_spr_405(env);
1975         env->nb_BATs = 0;
1976         env->nb_tlb = 64;
1977         env->nb_ways = 1;
1978         env->id_tlbs = 0;
1979         /* Allocate hardware IRQ controller */
1980         ppc405_irq_init(env);
1981         break;
1982
1983     case CPU_PPC_440EP:   /* 440 EP family                 */
1984     case CPU_PPC_440GP:   /* 440 GP family                 */
1985     case CPU_PPC_440GX:   /* 440 GX family                 */
1986     case CPU_PPC_440GXc:  /* 440 GXc family                */
1987     case CPU_PPC_440GXf:  /* 440 GXf family                */
1988     case CPU_PPC_440SP:   /* 440 SP family                 */
1989     case CPU_PPC_440SP2:
1990     case CPU_PPC_440SPE:  /* 440 SPE family                */
1991         gen_spr_generic(env);
1992         /* Time base */
1993         gen_tbl(env);
1994         gen_spr_BookE(env);
1995         gen_spr_440(env);
1996         env->nb_BATs = 0;
1997         env->nb_tlb = 64;
1998         env->nb_ways = 1;
1999         env->id_tlbs = 0;
2000         /* XXX: TODO: allocate internal IRQ controller */
2001         break;
2002
2003     /* Embedded PowerPC from Freescale                     */
2004 #if defined (TODO)
2005     case CPU_PPC_5xx:
2006         break;
2007 #endif
2008 #if defined (TODO)
2009     case CPU_PPC_8xx:     /* MPC821 / 823 / 850 / 860      */
2010         break;
2011 #endif
2012 #if defined (TODO)
2013     case CPU_PPC_82xx_HIP3:    /* MPC8240 / 8260                */
2014     case CPU_PPC_82xx_HIP4:    /* MPC8240 / 8260                */
2015         break;
2016 #endif
2017 #if defined (TODO)
2018     case CPU_PPC_827x:    /* MPC 827x / 828x               */
2019         break;
2020 #endif
2021
2022     /* XXX: Use MPC8540 PVR to implement a test PowerPC BookE target */
2023     case CPU_PPC_e500v110:
2024     case CPU_PPC_e500v120:
2025     case CPU_PPC_e500v210:
2026     case CPU_PPC_e500v220:
2027         gen_spr_generic(env);
2028         /* Time base */
2029         gen_tbl(env);
2030         gen_spr_BookE(env);
2031         gen_spr_BookE_FSL(env);
2032         env->nb_BATs = 0;
2033         env->nb_tlb = 64;
2034         env->nb_ways = 1;
2035         env->id_tlbs = 0;
2036         /* XXX: TODO: allocate internal IRQ controller */
2037         break;
2038
2039 #if defined (TODO)
2040     case CPU_PPC_e600:
2041         break;
2042 #endif
2043
2044     /* 32 bits PowerPC                                     */
2045     case CPU_PPC_601:     /* PowerPC 601                   */
2046         gen_spr_generic(env);
2047         gen_spr_ne_601(env);
2048         gen_spr_601(env);
2049         /* Hardware implementation registers */
2050         /* XXX : not implemented */
2051         spr_register(env, SPR_HID0, "HID0",
2052                      SPR_NOACCESS, SPR_NOACCESS,
2053                      &spr_read_generic, &spr_write_generic,
2054                      0x00000000);
2055         /* XXX : not implemented */
2056         spr_register(env, SPR_HID1, "HID1",
2057                      SPR_NOACCESS, SPR_NOACCESS,
2058                      &spr_read_generic, &spr_write_generic,
2059                      0x00000000);
2060         /* XXX : not implemented */
2061         spr_register(env, SPR_601_HID2, "HID2",
2062                      SPR_NOACCESS, SPR_NOACCESS,
2063                      &spr_read_generic, &spr_write_generic,
2064                      0x00000000);
2065         /* XXX : not implemented */
2066         spr_register(env, SPR_601_HID5, "HID5",
2067                      SPR_NOACCESS, SPR_NOACCESS,
2068                      &spr_read_generic, &spr_write_generic,
2069                      0x00000000);
2070         /* XXX : not implemented */
2071 #if 0 /* ? */
2072         spr_register(env, SPR_601_HID15, "HID15",
2073                      SPR_NOACCESS, SPR_NOACCESS,
2074                      &spr_read_generic, &spr_write_generic,
2075                      0x00000000);
2076 #endif
2077         env->nb_tlb = 64;
2078         env->nb_ways = 2;
2079         env->id_tlbs = 0;
2080         env->id_tlbs = 0;
2081         /* XXX: TODO: allocate internal IRQ controller */
2082         break;
2083
2084     case CPU_PPC_602:     /* PowerPC 602                   */
2085         gen_spr_generic(env);
2086         gen_spr_ne_601(env);
2087         /* Memory management */
2088         gen_low_BATs(env);
2089         /* Time base */
2090         gen_tbl(env);
2091         gen_6xx_7xx_soft_tlb(env, 64, 2);
2092         gen_spr_602(env);
2093         /* hardware implementation registers */
2094         /* XXX : not implemented */
2095         spr_register(env, SPR_HID0, "HID0",
2096                      SPR_NOACCESS, SPR_NOACCESS,
2097                      &spr_read_generic, &spr_write_generic,
2098                      0x00000000);
2099         /* XXX : not implemented */
2100         spr_register(env, SPR_HID1, "HID1",
2101                      SPR_NOACCESS, SPR_NOACCESS,
2102                      &spr_read_generic, &spr_write_generic,
2103                      0x00000000);
2104         /* Allocate hardware IRQ controller */
2105         ppc6xx_irq_init(env);
2106         break;
2107
2108     case CPU_PPC_603:     /* PowerPC 603                   */
2109     case CPU_PPC_603E:    /* PowerPC 603e                  */
2110     case CPU_PPC_603E7v:
2111     case CPU_PPC_603E7v2:
2112     case CPU_PPC_603P:    /* PowerPC 603p                  */
2113     case CPU_PPC_603R:    /* PowerPC 603r                  */
2114         gen_spr_generic(env);
2115         gen_spr_ne_601(env);
2116         /* Memory management */
2117         gen_low_BATs(env);
2118         /* Time base */
2119         gen_tbl(env);
2120         gen_6xx_7xx_soft_tlb(env, 64, 2);
2121         gen_spr_603(env);
2122         /* hardware implementation registers */
2123         /* XXX : not implemented */
2124         spr_register(env, SPR_HID0, "HID0",
2125                      SPR_NOACCESS, SPR_NOACCESS,
2126                      &spr_read_generic, &spr_write_generic,
2127                      0x00000000);
2128         /* XXX : not implemented */
2129         spr_register(env, SPR_HID1, "HID1",
2130                      SPR_NOACCESS, SPR_NOACCESS,
2131                      &spr_read_generic, &spr_write_generic,
2132                      0x00000000);
2133         /* Allocate hardware IRQ controller */
2134         ppc6xx_irq_init(env);
2135         break;
2136
2137     case CPU_PPC_G2:      /* PowerPC G2 family             */
2138     case CPU_PPC_G2H4:
2139     case CPU_PPC_G2gp:
2140     case CPU_PPC_G2ls:
2141     case CPU_PPC_G2LE:    /* PowerPC G2LE family           */
2142     case CPU_PPC_G2LEgp:
2143     case CPU_PPC_G2LEls:
2144         gen_spr_generic(env);
2145         gen_spr_ne_601(env);
2146         /* Memory management */
2147         gen_low_BATs(env);
2148         /* Time base */
2149         gen_tbl(env);
2150         /* Memory management */
2151         gen_high_BATs(env);
2152         gen_6xx_7xx_soft_tlb(env, 64, 2);
2153         gen_spr_G2_755(env);
2154         gen_spr_G2(env);
2155         /* Hardware implementation register */
2156         /* XXX : not implemented */
2157         spr_register(env, SPR_HID0, "HID0",
2158                      SPR_NOACCESS, SPR_NOACCESS,
2159                      &spr_read_generic, &spr_write_generic,
2160                      0x00000000);
2161         /* XXX : not implemented */
2162         spr_register(env, SPR_HID1, "HID1",
2163                      SPR_NOACCESS, SPR_NOACCESS,
2164                      &spr_read_generic, &spr_write_generic,
2165                      0x00000000);
2166         /* XXX : not implemented */
2167         spr_register(env, SPR_HID2, "HID2",
2168                      SPR_NOACCESS, SPR_NOACCESS,
2169                      &spr_read_generic, &spr_write_generic,
2170                      0x00000000);
2171         /* Allocate hardware IRQ controller */
2172         ppc6xx_irq_init(env);
2173         break;
2174
2175     case CPU_PPC_604:     /* PowerPC 604                   */
2176     case CPU_PPC_604E:    /* PowerPC 604e                  */
2177     case CPU_PPC_604R:    /* PowerPC 604r                  */
2178         gen_spr_generic(env);
2179         gen_spr_ne_601(env);
2180         /* Memory management */
2181         gen_low_BATs(env);
2182         /* Time base */
2183         gen_tbl(env);
2184         gen_spr_604(env);
2185         /* Hardware implementation registers */
2186         /* XXX : not implemented */
2187         spr_register(env, SPR_HID0, "HID0",
2188                      SPR_NOACCESS, SPR_NOACCESS,
2189                      &spr_read_generic, &spr_write_generic,
2190                      0x00000000);
2191         /* XXX : not implemented */
2192         spr_register(env, SPR_HID1, "HID1",
2193                      SPR_NOACCESS, SPR_NOACCESS,
2194                      &spr_read_generic, &spr_write_generic,
2195                      0x00000000);
2196         /* Allocate hardware IRQ controller */
2197         ppc6xx_irq_init(env);
2198         break;
2199
2200     case CPU_PPC_74x:     /* PowerPC 740 / 750             */
2201     case CPU_PPC_740E:
2202     case CPU_PPC_750E:
2203     case CPU_PPC_74xP:    /* PowerPC 740P / 750P           */
2204     case CPU_PPC_750CXE21: /* IBM PowerPC 750cxe            */
2205     case CPU_PPC_750CXE22:
2206     case CPU_PPC_750CXE23:
2207     case CPU_PPC_750CXE24:
2208     case CPU_PPC_750CXE24b:
2209     case CPU_PPC_750CXE31:
2210     case CPU_PPC_750CXE31b:
2211     case CPU_PPC_750CXR:
2212         gen_spr_generic(env);
2213         gen_spr_ne_601(env);
2214         /* Memory management */
2215         gen_low_BATs(env);
2216         /* Time base */
2217         gen_tbl(env);
2218         gen_spr_7xx(env);
2219         /* Hardware implementation registers */
2220         /* XXX : not implemented */
2221         spr_register(env, SPR_HID0, "HID0",
2222                      SPR_NOACCESS, SPR_NOACCESS,
2223                      &spr_read_generic, &spr_write_generic,
2224                      0x00000000);
2225         /* XXX : not implemented */
2226         spr_register(env, SPR_HID1, "HID1",
2227                      SPR_NOACCESS, SPR_NOACCESS,
2228                      &spr_read_generic, &spr_write_generic,
2229                      0x00000000);
2230         /* Allocate hardware IRQ controller */
2231         ppc6xx_irq_init(env);
2232         break;
2233
2234     case CPU_PPC_750FX10: /* IBM PowerPC 750 FX            */
2235     case CPU_PPC_750FX20:
2236     case CPU_PPC_750FX21:
2237     case CPU_PPC_750FX22:
2238     case CPU_PPC_750FX23:
2239     case CPU_PPC_750GX10: /* IBM PowerPC 750 GX            */
2240     case CPU_PPC_750GX11:
2241     case CPU_PPC_750GX12:
2242         gen_spr_generic(env);
2243         gen_spr_ne_601(env);
2244         /* Memory management */
2245         gen_low_BATs(env);
2246         /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
2247         gen_high_BATs(env);
2248         /* Time base */
2249         gen_tbl(env);
2250         gen_spr_7xx(env);
2251         /* Hardware implementation registers */
2252         /* XXX : not implemented */
2253         spr_register(env, SPR_HID0, "HID0",
2254                      SPR_NOACCESS, SPR_NOACCESS,
2255                      &spr_read_generic, &spr_write_generic,
2256                      0x00000000);
2257         /* XXX : not implemented */
2258         spr_register(env, SPR_HID1, "HID1",
2259                      SPR_NOACCESS, SPR_NOACCESS,
2260                      &spr_read_generic, &spr_write_generic,
2261                      0x00000000);
2262         /* XXX : not implemented */
2263         spr_register(env, SPR_750_HID2, "HID2",
2264                      SPR_NOACCESS, SPR_NOACCESS,
2265                      &spr_read_generic, &spr_write_generic,
2266                      0x00000000);
2267         /* Allocate hardware IRQ controller */
2268         ppc6xx_irq_init(env);
2269         break;
2270
2271     case CPU_PPC_755_10:  /* PowerPC 755                   */
2272     case CPU_PPC_755_11:
2273     case CPU_PPC_755_20:
2274     case CPU_PPC_755D:
2275     case CPU_PPC_755E:
2276         gen_spr_generic(env);
2277         gen_spr_ne_601(env);
2278         /* Memory management */
2279         gen_low_BATs(env);
2280         /* Time base */
2281         gen_tbl(env);
2282         /* Memory management */
2283         gen_high_BATs(env);
2284         gen_6xx_7xx_soft_tlb(env, 64, 2);
2285         gen_spr_G2_755(env);
2286         /* L2 cache control */
2287         /* XXX : not implemented */
2288         spr_register(env, SPR_ICTC, "ICTC",
2289                      SPR_NOACCESS, SPR_NOACCESS,
2290                      &spr_read_generic, &spr_write_generic,
2291                      0x00000000);
2292         /* XXX : not implemented */
2293         spr_register(env, SPR_L2PM, "L2PM",
2294                      SPR_NOACCESS, SPR_NOACCESS,
2295                      &spr_read_generic, &spr_write_generic,
2296                      0x00000000);
2297         /* Hardware implementation registers */
2298         /* XXX : not implemented */
2299         spr_register(env, SPR_HID0, "HID0",
2300                      SPR_NOACCESS, SPR_NOACCESS,
2301                      &spr_read_generic, &spr_write_generic,
2302                      0x00000000);
2303         /* XXX : not implemented */
2304         spr_register(env, SPR_HID1, "HID1",
2305                      SPR_NOACCESS, SPR_NOACCESS,
2306                      &spr_read_generic, &spr_write_generic,
2307                      0x00000000);
2308         /* XXX : not implemented */
2309         spr_register(env, SPR_HID2, "HID2",
2310                      SPR_NOACCESS, SPR_NOACCESS,
2311                      &spr_read_generic, &spr_write_generic,
2312                      0x00000000);
2313         /* Allocate hardware IRQ controller */
2314         ppc6xx_irq_init(env);
2315         break;
2316
2317 #if defined (TODO)
2318     /* G4 family */
2319     case CPU_PPC_7400:    /* PowerPC 7400                  */
2320     case CPU_PPC_7410C:   /* PowerPC 7410                  */
2321     case CPU_PPC_7410D:
2322     case CPU_PPC_7410E:
2323     case CPU_PPC_7441:    /* PowerPC 7441                  */
2324     case CPU_PPC_7445:    /* PowerPC 7445                  */
2325     case CPU_PPC_7447:    /* PowerPC 7447                  */
2326     case CPU_PPC_7447A:   /* PowerPC 7447A                 */
2327     case CPU_PPC_7448:    /* PowerPC 7448                  */
2328     case CPU_PPC_7450:    /* PowerPC 7450                  */
2329     case CPU_PPC_7450b:
2330     case CPU_PPC_7451:    /* PowerPC 7451                  */
2331     case CPU_PPC_7451G:
2332     case CPU_PPC_7455:    /* PowerPC 7455                  */
2333     case CPU_PPC_7455F:
2334     case CPU_PPC_7455G:
2335     case CPU_PPC_7457:    /* PowerPC 7457                  */
2336     case CPU_PPC_7457C:
2337     case CPU_PPC_7457A:   /* PowerPC 7457A                 */
2338         break;
2339 #endif
2340
2341     /* 64 bits PowerPC                                     */
2342 #if defined (TARGET_PPC64)
2343 #if defined (TODO)
2344     case CPU_PPC_620:     /* PowerPC 620                   */
2345     case CPU_PPC_630:     /* PowerPC 630 (Power 3)         */
2346     case CPU_PPC_631:     /* PowerPC 631 (Power 3+)        */
2347     case CPU_PPC_POWER4:  /* Power 4                       */
2348     case CPU_PPC_POWER4P: /* Power 4+                      */
2349     case CPU_PPC_POWER5:  /* Power 5                       */
2350     case CPU_PPC_POWER5P: /* Power 5+                      */
2351 #endif
2352         break;
2353
2354     case CPU_PPC_970:     /* PowerPC 970                   */
2355     case CPU_PPC_970FX10: /* PowerPC 970 FX                */
2356     case CPU_PPC_970FX20:
2357     case CPU_PPC_970FX21:
2358     case CPU_PPC_970FX30:
2359     case CPU_PPC_970FX31:
2360     case CPU_PPC_970MP10: /* PowerPC 970 MP                */
2361     case CPU_PPC_970MP11:
2362         gen_spr_generic(env);
2363         gen_spr_ne_601(env);
2364         /* XXX: not correct */
2365         gen_low_BATs(env);
2366         /* Time base */
2367         gen_tbl(env);
2368         gen_spr_7xx(env);
2369         /* Hardware implementation registers */
2370         /* XXX : not implemented */
2371         spr_register(env, SPR_HID0, "HID0",
2372                      SPR_NOACCESS, SPR_NOACCESS,
2373                      &spr_read_generic, &spr_write_generic,
2374                      0x00000000);
2375         /* XXX : not implemented */
2376         spr_register(env, SPR_HID1, "HID1",
2377                      SPR_NOACCESS, SPR_NOACCESS,
2378                      &spr_read_generic, &spr_write_generic,
2379                      0x00000000);
2380         /* XXX : not implemented */
2381         spr_register(env, SPR_750_HID2, "HID2",
2382                      SPR_NOACCESS, SPR_NOACCESS,
2383                      &spr_read_generic, &spr_write_generic,
2384                      0x00000000);
2385         /* Allocate hardware IRQ controller */
2386         ppc970_irq_init(env);
2387         break;
2388
2389 #if defined (TODO)
2390     case CPU_PPC_CELL10:  /* Cell family                   */
2391     case CPU_PPC_CELL20:
2392     case CPU_PPC_CELL30:
2393     case CPU_PPC_CELL31:
2394 #endif
2395         break;
2396
2397 #if defined (TODO)
2398     case CPU_PPC_RS64:    /* Apache (RS64/A35)             */
2399     case CPU_PPC_RS64II:  /* NorthStar (RS64-II/A50)       */
2400     case CPU_PPC_RS64III: /* Pulsar (RS64-III)             */
2401     case CPU_PPC_RS64IV:  /* IceStar/IStar/SStar (RS64-IV) */
2402 #endif
2403         break;
2404 #endif /* defined (TARGET_PPC64) */
2405
2406 #if defined (TODO)
2407         /* POWER                                               */
2408     case CPU_POWER:       /* POWER                         */
2409     case CPU_POWER2:      /* POWER2                        */
2410         break;
2411 #endif
2412
2413     default:
2414         gen_spr_generic(env);
2415         /* XXX: TODO: allocate internal IRQ controller */
2416         break;
2417     }
2418     if (env->nb_BATs == -1)
2419         env->nb_BATs = 4;
2420     /* Allocate TLBs buffer when needed */
2421     if (env->nb_tlb != 0) {
2422         int nb_tlb = env->nb_tlb;
2423         if (env->id_tlbs != 0)
2424             nb_tlb *= 2;
2425         env->tlb = qemu_mallocz(nb_tlb * sizeof(ppc_tlb_t));
2426         /* Pre-compute some useful values */
2427         env->tlb_per_way = env->nb_tlb / env->nb_ways;
2428     }
2429 }
2430
2431 #if defined(PPC_DUMP_CPU)
2432 static void dump_sprs (CPUPPCState *env)
2433 {
2434     ppc_spr_t *spr;
2435     uint32_t pvr = env->spr[SPR_PVR];
2436     uint32_t sr, sw, ur, uw;
2437     int i, j, n;
2438
2439     printf("* SPRs for PVR=%08x\n", pvr);
2440     for (i = 0; i < 32; i++) {
2441         for (j = 0; j < 32; j++) {
2442             n = (i << 5) | j;
2443             spr = &env->spr_cb[n];
2444 #if !defined(CONFIG_USER_ONLY)
2445             sw = spr->oea_write != NULL && spr->oea_write != SPR_NOACCESS;
2446             sr = spr->oea_read != NULL && spr->oea_read != SPR_NOACCESS;
2447 #else
2448             sw = 0;
2449             sr = 0;
2450 #endif
2451             uw = spr->uea_write != NULL && spr->uea_write != SPR_NOACCESS;
2452             ur = spr->uea_read != NULL && spr->uea_read != SPR_NOACCESS;
2453             if (sw || sr || uw || ur) {
2454                 printf("%4d (%03x) %8s s%c%c u%c%c\n",
2455                        (i << 5) | j, (i << 5) | j, spr->name,
2456                        sw ? 'w' : '-', sr ? 'r' : '-',
2457                        uw ? 'w' : '-', ur ? 'r' : '-');
2458             }
2459         }
2460     }
2461     fflush(stdout);
2462     fflush(stderr);
2463 }
2464 #endif
2465
2466 /*****************************************************************************/
2467 #include <stdlib.h>
2468 #include <string.h>
2469
2470 int fflush (FILE *stream);
2471
2472 /* Opcode types */
2473 enum {
2474     PPC_DIRECT   = 0, /* Opcode routine        */
2475     PPC_INDIRECT = 1, /* Indirect opcode table */
2476 };
2477
2478 static inline int is_indirect_opcode (void *handler)
2479 {
2480     return ((unsigned long)handler & 0x03) == PPC_INDIRECT;
2481 }
2482
2483 static inline opc_handler_t **ind_table(void *handler)
2484 {
2485     return (opc_handler_t **)((unsigned long)handler & ~3);
2486 }
2487
2488 /* Instruction table creation */
2489 /* Opcodes tables creation */
2490 static void fill_new_table (opc_handler_t **table, int len)
2491 {
2492     int i;
2493
2494     for (i = 0; i < len; i++)
2495         table[i] = &invalid_handler;
2496 }
2497
2498 static int create_new_table (opc_handler_t **table, unsigned char idx)
2499 {
2500     opc_handler_t **tmp;
2501
2502     tmp = malloc(0x20 * sizeof(opc_handler_t));
2503     if (tmp == NULL)
2504         return -1;
2505     fill_new_table(tmp, 0x20);
2506     table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);
2507
2508     return 0;
2509 }
2510
2511 static int insert_in_table (opc_handler_t **table, unsigned char idx,
2512                             opc_handler_t *handler)
2513 {
2514     if (table[idx] != &invalid_handler)
2515         return -1;
2516     table[idx] = handler;
2517
2518     return 0;
2519 }
2520
2521 static int register_direct_insn (opc_handler_t **ppc_opcodes,
2522                                  unsigned char idx, opc_handler_t *handler)
2523 {
2524     if (insert_in_table(ppc_opcodes, idx, handler) < 0) {
2525         printf("*** ERROR: opcode %02x already assigned in main "
2526                "opcode table\n", idx);
2527         return -1;
2528     }
2529
2530     return 0;
2531 }
2532
2533 static int register_ind_in_table (opc_handler_t **table,
2534                                   unsigned char idx1, unsigned char idx2,
2535                                   opc_handler_t *handler)
2536 {
2537     if (table[idx1] == &invalid_handler) {
2538         if (create_new_table(table, idx1) < 0) {
2539             printf("*** ERROR: unable to create indirect table "
2540                    "idx=%02x\n", idx1);
2541             return -1;
2542         }
2543     } else {
2544         if (!is_indirect_opcode(table[idx1])) {
2545             printf("*** ERROR: idx %02x already assigned to a direct "
2546                    "opcode\n", idx1);
2547             return -1;
2548         }
2549     }
2550     if (handler != NULL &&
2551         insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {
2552         printf("*** ERROR: opcode %02x already assigned in "
2553                "opcode table %02x\n", idx2, idx1);
2554         return -1;
2555     }
2556
2557     return 0;
2558 }
2559
2560 static int register_ind_insn (opc_handler_t **ppc_opcodes,
2561                               unsigned char idx1, unsigned char idx2,
2562                               opc_handler_t *handler)
2563 {
2564     int ret;
2565
2566     ret = register_ind_in_table(ppc_opcodes, idx1, idx2, handler);
2567
2568     return ret;
2569 }
2570
2571 static int register_dblind_insn (opc_handler_t **ppc_opcodes,
2572                                  unsigned char idx1, unsigned char idx2,
2573                                  unsigned char idx3, opc_handler_t *handler)
2574 {
2575     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
2576         printf("*** ERROR: unable to join indirect table idx "
2577                "[%02x-%02x]\n", idx1, idx2);
2578         return -1;
2579     }
2580     if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,
2581                               handler) < 0) {
2582         printf("*** ERROR: unable to insert opcode "
2583                "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
2584         return -1;
2585     }
2586
2587     return 0;
2588 }
2589
2590 static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)
2591 {
2592     if (insn->opc2 != 0xFF) {
2593         if (insn->opc3 != 0xFF) {
2594             if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
2595                                      insn->opc3, &insn->handler) < 0)
2596                 return -1;
2597         } else {
2598             if (register_ind_insn(ppc_opcodes, insn->opc1,
2599                                   insn->opc2, &insn->handler) < 0)
2600                 return -1;
2601         }
2602     } else {
2603         if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0)
2604             return -1;
2605     }
2606
2607     return 0;
2608 }
2609
2610 static int test_opcode_table (opc_handler_t **table, int len)
2611 {
2612     int i, count, tmp;
2613
2614     for (i = 0, count = 0; i < len; i++) {
2615         /* Consistency fixup */
2616         if (table[i] == NULL)
2617             table[i] = &invalid_handler;
2618         if (table[i] != &invalid_handler) {
2619             if (is_indirect_opcode(table[i])) {
2620                 tmp = test_opcode_table(ind_table(table[i]), 0x20);
2621                 if (tmp == 0) {
2622                     free(table[i]);
2623                     table[i] = &invalid_handler;
2624                 } else {
2625                     count++;
2626                 }
2627             } else {
2628                 count++;
2629             }
2630         }
2631     }
2632
2633     return count;
2634 }
2635
2636 static void fix_opcode_tables (opc_handler_t **ppc_opcodes)
2637 {
2638     if (test_opcode_table(ppc_opcodes, 0x40) == 0)
2639         printf("*** WARNING: no opcode defined !\n");
2640 }
2641
2642 /*****************************************************************************/
2643 static int create_ppc_opcodes (CPUPPCState *env, ppc_def_t *def)
2644 {
2645     opcode_t *opc, *start, *end;
2646
2647     fill_new_table(env->opcodes, 0x40);
2648 #if defined(PPC_DUMP_CPU)
2649     printf("* PowerPC instructions for PVR %08x: %s flags %016" PRIx64
2650            " %08x\n",
2651            def->pvr, def->name, def->insns_flags, def->flags);
2652 #endif
2653     if (&opc_start < &opc_end) {
2654         start = &opc_start;
2655         end = &opc_end;
2656     } else {
2657         start = &opc_end;
2658         end = &opc_start;
2659     }
2660     for (opc = start + 1; opc != end; opc++) {
2661         if ((opc->handler.type & def->insns_flags) != 0) {
2662             if (register_insn(env->opcodes, opc) < 0) {
2663                 printf("*** ERROR initializing PowerPC instruction "
2664                        "0x%02x 0x%02x 0x%02x\n", opc->opc1, opc->opc2,
2665                        opc->opc3);
2666                 return -1;
2667             }
2668 #if defined(PPC_DUMP_CPU)
2669             if (opc1 != 0x00) {
2670                 if (opc->opc3 == 0xFF) {
2671                     if (opc->opc2 == 0xFF) {
2672                         printf(" %02x -- -- (%2d ----) : %s\n",
2673                                opc->opc1, opc->opc1, opc->oname);
2674                     } else {
2675                         printf(" %02x %02x -- (%2d %4d) : %s\n",
2676                                opc->opc1, opc->opc2, opc->opc1, opc->opc2,
2677                                opc->oname);
2678                     }
2679                 } else {
2680                     printf(" %02x %02x %02x (%2d %4d) : %s\n",
2681                            opc->opc1, opc->opc2, opc->opc3,
2682                            opc->opc1, (opc->opc3 << 5) | opc->opc2,
2683                            opc->oname);
2684                 }
2685             }
2686 #endif
2687         }
2688     }
2689     fix_opcode_tables(env->opcodes);
2690     fflush(stdout);
2691     fflush(stderr);
2692
2693     return 0;
2694 }
2695
2696 int cpu_ppc_register (CPUPPCState *env, ppc_def_t *def)
2697 {
2698     env->msr_mask = def->msr_mask;
2699     env->flags = def->flags;
2700     if (create_ppc_opcodes(env, def) < 0)
2701         return -1;
2702     init_ppc_proc(env, def);
2703 #if defined(PPC_DUMP_CPU)
2704     dump_sprs(env);
2705     if (env->tlb != NULL) {
2706         printf("%d %s TLB in %d ways\n", env->nb_tlb,
2707                env->id_tlbs ? "splitted" : "merged", env->nb_ways);
2708     }
2709 #endif
2710
2711     return 0;
2712 }
2713
2714 /*****************************************************************************/
2715 /* PowerPC CPU definitions */
2716 static ppc_def_t ppc_defs[] = {
2717     /* Embedded PowerPC */
2718 #if defined (TODO)
2719     /* PowerPC 401 */
2720     {
2721         .name        = "401",
2722         .pvr         = CPU_PPC_401,
2723         .pvr_mask    = 0xFFFF0000,
2724         .insns_flags = PPC_INSNS_401,
2725         .flags       = PPC_FLAGS_401,
2726         .msr_mask    = xxx,
2727     },
2728 #endif
2729 #if defined (TODO)
2730     /* IOP480 (401 microcontroler) */
2731     {
2732         .name        = "iop480",
2733         .pvr         = CPU_PPC_IOP480,
2734         .pvr_mask    = 0xFFFF0000,
2735         .insns_flags = PPC_INSNS_401,
2736         .flags       = PPC_FLAGS_401,
2737         .msr_mask    = xxx,
2738     },
2739 #endif
2740 #if defined (TODO)
2741     /* IBM Processor for Network Resources */
2742     {
2743         .name        = "Cobra",
2744         .pvr         = CPU_PPC_COBRA,
2745         .pvr_mask    = 0xFFFF0000,
2746         .insns_flags = PPC_INSNS_401,
2747         .flags       = PPC_FLAGS_401,
2748         .msr_mask    = xxx,
2749     },
2750 #endif
2751 #if defined (TODO)
2752     /* Generic PowerPC 403 */
2753     {
2754         .name        = "403",
2755         .pvr         = CPU_PPC_403,
2756         .pvr_mask    = 0xFFFFFF00,
2757         .insns_flags = PPC_INSNS_403,
2758         .flags       = PPC_FLAGS_403,
2759         .msr_mask    = 0x000000000007D23D,
2760     },
2761 #endif
2762 #if defined (TODO)
2763     /* PowerPC 403 GA */
2764     {
2765         .name        = "403ga",
2766         .pvr         = CPU_PPC_403GA,
2767         .pvr_mask    = 0xFFFFFF00,
2768         .insns_flags = PPC_INSNS_403,
2769         .flags       = PPC_FLAGS_403,
2770         .msr_mask    = 0x000000000007D23D,
2771     },
2772 #endif
2773 #if defined (TODO)
2774     /* PowerPC 403 GB */
2775     {
2776         .name        = "403gb",
2777         .pvr         = CPU_PPC_403GB,
2778         .pvr_mask    = 0xFFFFFF00,
2779         .insns_flags = PPC_INSNS_403,
2780         .flags       = PPC_FLAGS_403,
2781         .msr_mask    = 0x000000000007D23D,
2782     },
2783 #endif
2784 #if defined (TODO)
2785     /* PowerPC 403 GC */
2786     {
2787         .name        = "403gc",
2788         .pvr         = CPU_PPC_403GC,
2789         .pvr_mask    = 0xFFFFFF00,
2790         .insns_flags = PPC_INSNS_403,
2791         .flags       = PPC_FLAGS_403,
2792         .msr_mask    = 0x000000000007D23D,
2793     },
2794 #endif
2795 #if defined (TODO)
2796     /* PowerPC 403 GCX */
2797     {
2798         .name        = "403gcx",
2799         .pvr         = CPU_PPC_403GCX,
2800         .pvr_mask    = 0xFFFFFF00,
2801         .insns_flags = PPC_INSNS_403,
2802         .flags       = PPC_FLAGS_403,
2803         .msr_mask    = 0x000000000007D23D,
2804     },
2805 #endif
2806     /* Generic PowerPC 405 */
2807     {
2808         .name        = "405",
2809         .pvr         = CPU_PPC_405,
2810         .pvr_mask    = 0xFFFF0000,
2811         .insns_flags = PPC_INSNS_405,
2812         .flags       = PPC_FLAGS_405,
2813         .msr_mask    = 0x00000000020EFF30,
2814     },
2815     /* PowerPC 405 CR */
2816     {
2817         .name        = "405cr",
2818         .pvr         = CPU_PPC_405,
2819         .pvr_mask    = 0xFFFFFFFF,
2820         .insns_flags = PPC_INSNS_405,
2821         .flags       = PPC_FLAGS_405,
2822         .msr_mask    = 0x00000000020EFF30,
2823     },
2824 #if defined (TODO)
2825     /* PowerPC 405 GP */
2826     {
2827         .name        = "405gp",
2828         .pvr         = CPU_PPC_405,
2829         .pvr_mask    = 0xFFFFFFFF,
2830         .insns_flags = PPC_INSNS_405,
2831         .flags       = PPC_FLAGS_405,
2832         .msr_mask    = 0x00000000020EFF30,
2833     },
2834 #endif
2835     /* PowerPC 405 EP */
2836     {
2837         .name        = "405ep",
2838         .pvr         = CPU_PPC_405EP,
2839         .pvr_mask    = 0xFFFFFFFF,
2840         .insns_flags = PPC_INSNS_405,
2841         .flags       = PPC_FLAGS_405,
2842         .msr_mask    = 0x00000000020EFF30,
2843     },
2844 #if defined (TODO)
2845     /* PowerPC 405 EZ */
2846     {
2847         .name        = "405ez",
2848         .pvr         = CPU_PPC_405EZ,
2849         .pvr_mask    = 0xFFFFFFFF,
2850         .insns_flags = PPC_INSNS_405,
2851         .flags       = PPC_FLAGS_405,
2852         .msr_mask    = 0x00000000020EFF30,
2853     },
2854 #endif
2855 #if defined (TODO)
2856     /* PowerPC 405 GPR */
2857     {
2858         .name        = "405gpr",
2859         .pvr         = CPU_PPC_405GPR,
2860         .pvr_mask    = 0xFFFFFFFF,
2861         .insns_flags = PPC_INSNS_405,
2862         .flags       = PPC_FLAGS_405,
2863         .msr_mask    = 0x00000000020EFF30,
2864     },
2865 #endif
2866 #if defined (TODO)
2867     /* PowerPC 405 D2 */
2868     {
2869         .name        = "405d2",
2870         .pvr         = CPU_PPC_405D2,
2871         .pvr_mask    = 0xFFFFFFFF,
2872         .insns_flags = PPC_INSNS_405,
2873         .flags       = PPC_FLAGS_405,
2874         .msr_mask    = 0x00000000020EFF30,
2875     },
2876 #endif
2877 #if defined (TODO)
2878     /* PowerPC 405 D4 */
2879     {
2880         .name        = "405d4",
2881         .pvr         = CPU_PPC_405D4,
2882         .pvr_mask    = 0xFFFFFFFF,
2883         .insns_flags = PPC_INSNS_405,
2884         .flags       = PPC_FLAGS_405,
2885         .msr_mask    = 0x00000000020EFF30,
2886     },
2887 #endif
2888 #if defined (TODO)
2889     /* Npe405 H */
2890     {
2891         .name        = "Npe405H",
2892         .pvr         = CPU_PPC_NPE405H,
2893         .pvr_mask    = 0xFFFFFFFF,
2894             .insns_flags = PPC_INSNS_405,
2895         .flags       = PPC_FLAGS_405,
2896         .msr_mask    = 0x00000000020EFF30,
2897     },
2898 #endif
2899 #if defined (TODO)
2900     /* Npe405 L */
2901     {
2902         .name        = "Npe405L",
2903         .pvr         = CPU_PPC_NPE405L,
2904         .pvr_mask    = 0xFFFFFFFF,
2905         .insns_flags = PPC_INSNS_405,
2906         .flags       = PPC_FLAGS_405,
2907         .msr_mask    = 0x00000000020EFF30,
2908     },
2909 #endif
2910 #if defined (TODO)
2911     /* STB010000 */
2912     {
2913         .name        = "STB01000",
2914         .pvr         = CPU_PPC_STB01000,
2915         .pvr_mask    = 0xFFFFFFFF,
2916         .insns_flags = PPC_INSNS_405,
2917         .flags       = PPC_FLAGS_405,
2918         .msr_mask    = 0x00000000020EFF30,
2919     },
2920 #endif
2921 #if defined (TODO)
2922     /* STB01010 */
2923     {
2924         .name        = "STB01010",
2925         .pvr         = CPU_PPC_STB01010,
2926         .pvr_mask    = 0xFFFFFFFF,
2927         .insns_flags = PPC_INSNS_405,
2928         .flags       = PPC_FLAGS_405,
2929         .msr_mask    = 0x00000000020EFF30,
2930     },
2931 #endif
2932 #if defined (TODO)
2933     /* STB0210 */
2934     {
2935         .name        = "STB0210",
2936         .pvr         = CPU_PPC_STB0210,
2937         .pvr_mask    = 0xFFFFFFFF,
2938         .insns_flags = PPC_INSNS_405,
2939         .flags       = PPC_FLAGS_405,
2940         .msr_mask    = 0x00000000020EFF30,
2941     },
2942 #endif
2943 #if defined (TODO) || 1
2944     /* STB03xx */
2945     {
2946         .name        = "STB03",
2947         .pvr         = CPU_PPC_STB03,
2948         .pvr_mask    = 0xFFFFFFFF,
2949         .insns_flags = PPC_INSNS_405,
2950         .flags       = PPC_FLAGS_405,
2951         .msr_mask    = 0x00000000020EFF30,
2952     },
2953 #endif
2954 #if defined (TODO)
2955     /* STB043x */
2956     {
2957         .name        = "STB043",
2958         .pvr         = CPU_PPC_STB043,
2959         .pvr_mask    = 0xFFFFFFFF,
2960         .insns_flags = PPC_INSNS_405,
2961         .flags       = PPC_FLAGS_405,
2962         .msr_mask    = 0x00000000020EFF30,
2963     },
2964 #endif
2965 #if defined (TODO)
2966     /* STB045x */
2967     {
2968         .name        = "STB045",
2969         .pvr         = CPU_PPC_STB045,
2970         .pvr_mask    = 0xFFFFFFFF,
2971         .insns_flags = PPC_INSNS_405,
2972         .flags       = PPC_FLAGS_405,
2973         .msr_mask    = 0x00000000020EFF30,
2974     },
2975 #endif
2976 #if defined (TODO) || 1
2977     /* STB25xx */
2978     {
2979         .name        = "STB25",
2980         .pvr         = CPU_PPC_STB25,
2981         .pvr_mask    = 0xFFFFFFFF,
2982         .insns_flags = PPC_INSNS_405,
2983         .flags       = PPC_FLAGS_405,
2984         .msr_mask    = 0x00000000020EFF30,
2985     },
2986 #endif
2987 #if defined (TODO)
2988     /* STB130 */
2989     {
2990         .name        = "STB130",
2991         .pvr         = CPU_PPC_STB130,
2992         .pvr_mask    = 0xFFFFFFFF,
2993         .insns_flags = PPC_INSNS_405,
2994         .flags       = PPC_FLAGS_405,
2995         .msr_mask    = 0x00000000020EFF30,
2996     },
2997 #endif
2998         /* Xilinx PowerPC 405 cores */
2999 #if defined (TODO)
3000     {
3001         .name        = "x2vp4",
3002         .pvr         = CPU_PPC_X2VP4,
3003         .pvr_mask    = 0xFFFFFFFF,
3004         .insns_flags = PPC_INSNS_405,
3005         .flags       = PPC_FLAGS_405,
3006         .msr_mask    = 0x00000000020EFF30,
3007     },
3008     {
3009         .name        = "x2vp7",
3010         .pvr         = CPU_PPC_X2VP7,
3011         .pvr_mask    = 0xFFFFFFFF,
3012         .insns_flags = PPC_INSNS_405,
3013         .flags       = PPC_FLAGS_405,
3014         .msr_mask    = 0x00000000020EFF30,
3015     },
3016     {
3017         .name        = "x2vp20",
3018         .pvr         = CPU_PPC_X2VP20,
3019         .pvr_mask    = 0xFFFFFFFF,
3020         .insns_flags = PPC_INSNS_405,
3021         .flags       = PPC_FLAGS_405,
3022         .msr_mask    = 0x00000000020EFF30,
3023     },
3024     {
3025         .name        = "x2vp50",
3026         .pvr         = CPU_PPC_X2VP50,
3027         .pvr_mask    = 0xFFFFFFFF,
3028         .insns_flags = PPC_INSNS_405,
3029         .flags       = PPC_FLAGS_405,
3030         .msr_mask    = 0x00000000020EFF30,
3031     },
3032 #endif
3033 #if defined (TODO)
3034     /* PowerPC 440 EP */
3035     {
3036         .name        = "440ep",
3037         .pvr         = CPU_PPC_440EP,
3038         .pvr_mask    = 0xFFFF0000,
3039         .insns_flags = PPC_INSNS_440,
3040         .flags       = PPC_FLAGS_440,
3041         .msr_mask    = 0x000000000006D630,
3042     },
3043 #endif
3044 #if defined (TODO)
3045     /* PowerPC 440 GR */
3046     {
3047         .name        = "440gr",
3048         .pvr         = CPU_PPC_440GR,
3049         .pvr_mask    = 0xFFFF0000,
3050         .insns_flags = PPC_INSNS_440,
3051         .flags       = PPC_FLAGS_440,
3052         .msr_mask    = 0x000000000006D630,
3053     },
3054 #endif
3055 #if defined (TODO)
3056     /* PowerPC 440 GP */
3057     {
3058         .name        = "440gp",
3059         .pvr         = CPU_PPC_440GP,
3060         .pvr_mask    = 0xFFFFFF00,
3061         .insns_flags = PPC_INSNS_440,
3062         .flags       = PPC_FLAGS_440,
3063         .msr_mask    = 0x000000000006D630,
3064     },
3065 #endif
3066 #if defined (TODO)
3067     /* PowerPC 440 GX */
3068     {
3069         .name        = "440gx",
3070         .pvr         = CPU_PPC_440GX,
3071         .pvr_mask    = 0xFFFF0000,
3072         .insns_flags = PPC_INSNS_405,
3073         .flags       = PPC_FLAGS_440,
3074         .msr_mask    = 0x000000000006D630,
3075     },
3076 #endif
3077 #if defined (TODO)
3078     /* PowerPC 440 GXc */
3079     {
3080         .name        = "440gxc",
3081         .pvr         = CPU_PPC_440GXC,
3082         .pvr_mask    = 0xFFFF0000,
3083         .insns_flags = PPC_INSNS_405,
3084         .flags       = PPC_FLAGS_440,
3085         .msr_mask    = 0x000000000006D630,
3086     },
3087 #endif
3088 #if defined (TODO)
3089     /* PowerPC 440 GXf */
3090     {
3091         .name        = "440gxf",
3092         .pvr         = CPU_PPC_440GXF,
3093         .pvr_mask    = 0xFFFF0000,
3094         .insns_flags = PPC_INSNS_405,
3095         .flags       = PPC_FLAGS_440,
3096         .msr_mask    = 0x000000000006D630,
3097     },
3098 #endif
3099 #if defined (TODO)
3100     /* PowerPC 440 SP */
3101     {
3102         .name        = "440sp",
3103         .pvr         = CPU_PPC_440SP,
3104         .pvr_mask    = 0xFFFF0000,
3105         .insns_flags = PPC_INSNS_405,
3106         .flags       = PPC_FLAGS_440,
3107         .msr_mask    = 0x000000000006D630,
3108     },
3109 #endif
3110 #if defined (TODO)
3111     /* PowerPC 440 SP2 */
3112     {
3113         .name        = "440sp2",
3114         .pvr         = CPU_PPC_440SP2,
3115         .pvr_mask    = 0xFFFF0000,
3116         .insns_flags = PPC_INSNS_405,
3117         .flags       = PPC_FLAGS_440,
3118         .msr_mask    = 0x000000000006D630,
3119     },
3120 #endif
3121 #if defined (TODO)
3122     /* PowerPC 440 SPE */
3123     {
3124         .name        = "440spe",
3125         .pvr         = CPU_PPC_440SPE,
3126         .pvr_mask    = 0xFFFF0000,
3127         .insns_flags = PPC_INSNS_405,
3128         .flags       = PPC_FLAGS_440,
3129         .msr_mask    = 0x000000000006D630,
3130     },
3131 #endif
3132     /* Fake generic BookE PowerPC */
3133     {
3134         .name        = "BookE",
3135         .pvr         = CPU_PPC_e500,
3136         .pvr_mask    = 0xFFFFFFFF,
3137         .insns_flags = PPC_INSNS_BOOKE,
3138         .flags       = PPC_FLAGS_BOOKE,
3139         .msr_mask    = 0x000000000006D630,
3140     },
3141     /* PowerPC 460 cores - TODO */
3142     /* PowerPC MPC 5xx cores - TODO */
3143     /* PowerPC MPC 8xx cores - TODO */
3144     /* PowerPC MPC 8xxx cores - TODO */
3145     /* e200 cores - TODO */
3146     /* e500 cores - TODO */
3147     /* e600 cores - TODO */
3148
3149     /* 32 bits "classic" PowerPC */
3150 #if defined (TODO)
3151     /* PowerPC 601 */
3152     {
3153         .name        = "601",
3154         .pvr         = CPU_PPC_601,
3155         .pvr_mask    = 0xFFFF0000,
3156         .insns_flags = PPC_INSNS_601,
3157         .flags       = PPC_FLAGS_601,
3158         .msr_mask    = 0x000000000000FD70,
3159     },
3160 #endif
3161 #if defined (TODO)
3162     /* PowerPC 602 */
3163     {
3164         .name        = "602",
3165         .pvr         = CPU_PPC_602,
3166         .pvr_mask    = 0xFFFF0000,
3167         .insns_flags = PPC_INSNS_602,
3168         .flags       = PPC_FLAGS_602,
3169         .msr_mask    = 0x0000000000C7FF73,
3170     },
3171 #endif
3172     /* PowerPC 603 */
3173     {
3174         .name        = "603",
3175         .pvr         = CPU_PPC_603,
3176         .pvr_mask    = 0xFFFFFFFF,
3177         .insns_flags = PPC_INSNS_603,
3178         .flags       = PPC_FLAGS_603,
3179         .msr_mask    = 0x000000000007FF73,
3180     },
3181     /* PowerPC 603e */
3182     {
3183         .name        = "603e",
3184         .pvr         = CPU_PPC_603E,
3185         .pvr_mask    = 0xFFFFFFFF,
3186         .insns_flags = PPC_INSNS_603,
3187         .flags       = PPC_FLAGS_603,
3188         .msr_mask    = 0x000000000007FF73,
3189     },
3190     {
3191         .name        = "Stretch",
3192         .pvr         = CPU_PPC_603E,
3193         .pvr_mask    = 0xFFFFFFFF,
3194         .insns_flags = PPC_INSNS_603,
3195         .flags       = PPC_FLAGS_603,
3196         .msr_mask    = 0x000000000007FF73,
3197     },
3198     /* PowerPC 603p */
3199     {
3200         .name        = "603p",
3201         .pvr         = CPU_PPC_603P,
3202         .pvr_mask    = 0xFFFFFFFF,
3203         .insns_flags = PPC_INSNS_603,
3204         .flags       = PPC_FLAGS_603,
3205         .msr_mask    = 0x000000000007FF73,
3206     },
3207     /* PowerPC 603e7 */
3208     {
3209         .name        = "603e7",
3210         .pvr         = CPU_PPC_603E7,
3211         .pvr_mask    = 0xFFFFFFFF,
3212         .insns_flags = PPC_INSNS_603,
3213         .flags       = PPC_FLAGS_603,
3214         .msr_mask    = 0x000000000007FF73,
3215     },
3216     /* PowerPC 603e7v */
3217     {
3218         .name        = "603e7v",
3219         .pvr         = CPU_PPC_603E7v,
3220         .pvr_mask    = 0xFFFFFFFF,
3221         .insns_flags = PPC_INSNS_603,
3222         .flags       = PPC_FLAGS_603,
3223         .msr_mask    = 0x000000000007FF73,
3224     },
3225     /* PowerPC 603e7v2 */
3226     {
3227         .name        = "603e7v2",
3228         .pvr         = CPU_PPC_603E7v2,
3229         .pvr_mask    = 0xFFFFFFFF,
3230         .insns_flags = PPC_INSNS_603,
3231         .flags       = PPC_FLAGS_603,
3232         .msr_mask    = 0x000000000007FF73,
3233     },
3234     /* PowerPC 603r */
3235     {
3236         .name        = "603r",
3237         .pvr         = CPU_PPC_603R,
3238         .pvr_mask    = 0xFFFFFFFF,
3239         .insns_flags = PPC_INSNS_603,
3240         .flags       = PPC_FLAGS_603,
3241         .msr_mask    = 0x000000000007FF73,
3242     },
3243     {
3244         .name        = "Goldeneye",
3245         .pvr         = CPU_PPC_603R,
3246         .pvr_mask    = 0xFFFFFFFF,
3247         .insns_flags = PPC_INSNS_603,
3248         .flags       = PPC_FLAGS_603,
3249         .msr_mask    = 0x000000000007FF73,
3250     },
3251 #if defined (TODO)
3252     /* XXX: TODO: according to Motorola UM, this is a derivative to 603e */
3253     {
3254         .name        = "G2",
3255         .pvr         = CPU_PPC_G2,
3256         .pvr_mask    = 0xFFFF0000,
3257         .insns_flags = PPC_INSNS_G2,
3258         .flags       = PPC_FLAGS_G2,
3259         .msr_mask    = 0x000000000006FFF2,
3260     },
3261     {
3262         .name        = "G2h4",
3263         .pvr         = CPU_PPC_G2H4,
3264         .pvr_mask    = 0xFFFF0000,
3265         .insns_flags = PPC_INSNS_G2,
3266         .flags       = PPC_FLAGS_G2,
3267         .msr_mask    = 0x000000000006FFF2,
3268     },
3269     {
3270         .name        = "G2gp",
3271         .pvr         = CPU_PPC_G2gp,
3272         .pvr_mask    = 0xFFFF0000,
3273         .insns_flags = PPC_INSNS_G2,
3274         .flags       = PPC_FLAGS_G2,
3275         .msr_mask    = 0x000000000006FFF2,
3276     },
3277     {
3278         .name        = "G2ls",
3279         .pvr         = CPU_PPC_G2ls,
3280         .pvr_mask    = 0xFFFF0000,
3281         .insns_flags = PPC_INSNS_G2,
3282         .flags       = PPC_FLAGS_G2,
3283         .msr_mask    = 0x000000000006FFF2,
3284     },
3285     { /* Same as G2, with LE mode support */
3286         .name        = "G2le",
3287         .pvr         = CPU_PPC_G2LE,
3288         .pvr_mask    = 0xFFFF0000,
3289         .insns_flags = PPC_INSNS_G2,
3290         .flags       = PPC_FLAGS_G2,
3291         .msr_mask    = 0x000000000007FFF3,
3292     },
3293     {
3294         .name        = "G2legp",
3295         .pvr         = CPU_PPC_G2LEgp,
3296         .pvr_mask    = 0xFFFF0000,
3297         .insns_flags = PPC_INSNS_G2,
3298         .flags       = PPC_FLAGS_G2,
3299         .msr_mask    = 0x000000000007FFF3,
3300     },
3301     {
3302         .name        = "G2lels",
3303         .pvr         = CPU_PPC_G2LEls,
3304         .pvr_mask    = 0xFFFF0000,
3305         .insns_flags = PPC_INSNS_G2,
3306         .flags       = PPC_FLAGS_G2,
3307         .msr_mask    = 0x000000000007FFF3,
3308     },
3309 #endif
3310     /* PowerPC 604 */
3311     {
3312         .name        = "604",
3313         .pvr         = CPU_PPC_604,
3314         .pvr_mask    = 0xFFFFFFFF,
3315         .insns_flags = PPC_INSNS_604,
3316         .flags       = PPC_FLAGS_604,
3317         .msr_mask    = 0x000000000005FF77,
3318     },
3319     /* PowerPC 604e */
3320     {
3321         .name        = "604e",
3322         .pvr         = CPU_PPC_604E,
3323         .pvr_mask    = 0xFFFFFFFF,
3324         .insns_flags = PPC_INSNS_604,
3325         .flags       = PPC_FLAGS_604,
3326         .msr_mask    = 0x000000000005FF77,
3327     },
3328     /* PowerPC 604r */
3329     {
3330         .name        = "604r",
3331         .pvr         = CPU_PPC_604R,
3332         .pvr_mask    = 0xFFFFFFFF,
3333         .insns_flags = PPC_INSNS_604,
3334         .flags       = PPC_FLAGS_604,
3335         .msr_mask    = 0x000000000005FF77,
3336     },
3337     /* generic G3 */
3338     {
3339         .name        = "G3",
3340         .pvr         = CPU_PPC_74x,
3341         .pvr_mask    = 0xFFFFFFFF,
3342         .insns_flags = PPC_INSNS_7x0,
3343         .flags       = PPC_FLAGS_7x0,
3344         .msr_mask    = 0x000000000007FF77,
3345     },
3346     /* MPC740 (G3) */
3347     {
3348         .name        = "740",
3349         .pvr         = CPU_PPC_74x,
3350         .pvr_mask    = 0xFFFFFFFF,
3351         .insns_flags = PPC_INSNS_7x0,
3352         .flags       = PPC_FLAGS_7x0,
3353         .msr_mask    = 0x000000000007FF77,
3354     },
3355     {
3356         .name        = "Arthur",
3357         .pvr         = CPU_PPC_74x,
3358         .pvr_mask    = 0xFFFFFFFF,
3359         .insns_flags = PPC_INSNS_7x0,
3360         .flags       = PPC_FLAGS_7x0,
3361         .msr_mask    = 0x000000000007FF77,
3362     },
3363 #if defined (TODO)
3364     /* MPC745 (G3) */
3365     {
3366         .name        = "745",
3367         .pvr         = CPU_PPC_74x,
3368         .pvr_mask    = 0xFFFFF000,
3369         .insns_flags = PPC_INSNS_7x5,
3370         .flags       = PPC_FLAGS_7x5,
3371         .msr_mask    = 0x000000000007FF77,
3372     },
3373     {
3374         .name        = "Goldfinger",
3375         .pvr         = CPU_PPC_74x,
3376         .pvr_mask    = 0xFFFFF000,
3377         .insns_flags = PPC_INSNS_7x5,
3378         .flags       = PPC_FLAGS_7x5,
3379         .msr_mask    = 0x000000000007FF77,
3380     },
3381 #endif
3382     /* MPC750 (G3) */
3383     {
3384         .name        = "750",
3385         .pvr         = CPU_PPC_74x,
3386         .pvr_mask    = 0xFFFFFFFF,
3387         .insns_flags = PPC_INSNS_7x0,
3388         .flags       = PPC_FLAGS_7x0,
3389         .msr_mask    = 0x000000000007FF77,
3390     },
3391 #if defined (TODO)
3392     /* MPC755 (G3) */
3393     {
3394         .name        = "755",
3395         .pvr         = CPU_PPC_755,
3396         .pvr_mask    = 0xFFFFF000,
3397         .insns_flags = PPC_INSNS_7x5,
3398         .flags       = PPC_FLAGS_7x5,
3399         .msr_mask    = 0x000000000007FF77,
3400     },
3401 #endif
3402     /* MPC740P (G3) */
3403     {
3404         .name        = "740p",
3405         .pvr         = CPU_PPC_74xP,
3406         .pvr_mask    = 0xFFFFFFFF,
3407         .insns_flags = PPC_INSNS_7x0,
3408         .flags       = PPC_FLAGS_7x0,
3409         .msr_mask    = 0x000000000007FF77,
3410     },
3411     {
3412         .name        = "Conan/Doyle",
3413         .pvr         = CPU_PPC_74xP,
3414         .pvr_mask    = 0xFFFFFFFF,
3415         .insns_flags = PPC_INSNS_7x0,
3416         .flags       = PPC_FLAGS_7x0,
3417         .msr_mask    = 0x000000000007FF77,
3418     },
3419 #if defined (TODO)
3420     /* MPC745P (G3) */
3421     {
3422         .name        = "745p",
3423         .pvr         = CPU_PPC_74xP,
3424         .pvr_mask    = 0xFFFFF000,
3425         .insns_flags = PPC_INSNS_7x5,
3426         .flags       = PPC_FLAGS_7x5,
3427         .msr_mask    = 0x000000000007FF77,
3428     },
3429 #endif
3430     /* MPC750P (G3) */
3431     {
3432         .name        = "750p",
3433         .pvr         = CPU_PPC_74xP,
3434         .pvr_mask    = 0xFFFFFFFF,
3435         .insns_flags = PPC_INSNS_7x0,
3436         .flags       = PPC_FLAGS_7x0,
3437         .msr_mask    = 0x000000000007FF77,
3438     },
3439 #if defined (TODO)
3440     /* MPC755P (G3) */
3441     {
3442         .name        = "755p",
3443         .pvr         = CPU_PPC_74xP,
3444         .pvr_mask    = 0xFFFFF000,
3445         .insns_flags = PPC_INSNS_7x5,
3446         .flags       = PPC_FLAGS_7x5,
3447         .msr_mask    = 0x000000000007FF77,
3448     },
3449 #endif
3450     /* IBM 750CXe (G3 embedded) */
3451     {
3452         .name        = "750cxe",
3453         .pvr         = CPU_PPC_750CXE,
3454         .pvr_mask    = 0xFFFFFFFF,
3455         .insns_flags = PPC_INSNS_7x0,
3456         .flags       = PPC_FLAGS_7x0,
3457         .msr_mask    = 0x000000000007FF77,
3458     },
3459     /* IBM 750FX (G3 embedded) */
3460     {
3461         .name        = "750fx",
3462         .pvr         = CPU_PPC_750FX,
3463         .pvr_mask    = 0xFFFFFFFF,
3464         .insns_flags = PPC_INSNS_7x0,
3465         .flags       = PPC_FLAGS_7x0,
3466         .msr_mask    = 0x000000000007FF77,
3467     },
3468     /* IBM 750GX (G3 embedded) */
3469     {
3470         .name        = "750gx",
3471         .pvr         = CPU_PPC_750GX,
3472         .pvr_mask    = 0xFFFFFFFF,
3473         .insns_flags = PPC_INSNS_7x0,
3474         .flags       = PPC_FLAGS_7x0,
3475         .msr_mask    = 0x000000000007FF77,
3476     },
3477 #if defined (TODO)
3478     /* generic G4 */
3479     {
3480         .name        = "G4",
3481         .pvr         = CPU_PPC_7400,
3482         .pvr_mask    = 0xFFFF0000,
3483         .insns_flags = PPC_INSNS_74xx,
3484         .flags       = PPC_FLAGS_74xx,
3485         .msr_mask    = 0x000000000205FF77,
3486     },
3487 #endif
3488 #if defined (TODO)
3489     /* PowerPC 7400 (G4) */
3490     {
3491         .name        = "7400",
3492         .pvr         = CPU_PPC_7400,
3493         .pvr_mask    = 0xFFFF0000,
3494         .insns_flags = PPC_INSNS_74xx,
3495         .flags       = PPC_FLAGS_74xx,
3496         .msr_mask    = 0x000000000205FF77,
3497     },
3498     {
3499         .name        = "Max",
3500         .pvr         = CPU_PPC_7400,
3501         .pvr_mask    = 0xFFFF0000,
3502         .insns_flags = PPC_INSNS_74xx,
3503         .flags       = PPC_FLAGS_74xx,
3504         .msr_mask    = 0x000000000205FF77,
3505     },
3506 #endif
3507 #if defined (TODO)
3508     /* PowerPC 7410 (G4) */
3509     {
3510         .name        = "7410",
3511         .pvr         = CPU_PPC_7410,
3512         .pvr_mask    = 0xFFFF0000,
3513         .insns_flags = PPC_INSNS_74xx,
3514         .flags       = PPC_FLAGS_74xx,
3515         .msr_mask    = 0x000000000205FF77,
3516     },
3517     {
3518         .name        = "Nitro",
3519         .pvr         = CPU_PPC_7410,
3520         .pvr_mask    = 0xFFFF0000,
3521         .insns_flags = PPC_INSNS_74xx,
3522         .flags       = PPC_FLAGS_74xx,
3523         .msr_mask    = 0x000000000205FF77,
3524     },
3525 #endif
3526     /* XXX: 7441 */
3527     /* XXX: 7445 */
3528     /* XXX: 7447 */
3529     /* XXX: 7447A */
3530 #if defined (TODO)
3531     /* PowerPC 7450 (G4) */
3532     {
3533         .name        = "7450",
3534         .pvr         = CPU_PPC_7450,
3535         .pvr_mask    = 0xFFFF0000,
3536         .insns_flags = PPC_INSNS_74xx,
3537         .flags       = PPC_FLAGS_74xx,
3538         .msr_mask    = 0x000000000205FF77,
3539     },
3540     {
3541         .name        = "Vger",
3542         .pvr         = CPU_PPC_7450,
3543         .pvr_mask    = 0xFFFF0000,
3544         .insns_flags = PPC_INSNS_74xx,
3545         .flags       = PPC_FLAGS_74xx,
3546         .msr_mask    = 0x000000000205FF77,
3547     },
3548 #endif
3549     /* XXX: 7451 */
3550 #if defined (TODO)
3551     /* PowerPC 7455 (G4) */
3552     {
3553         .name        = "7455",
3554         .pvr         = CPU_PPC_7455,
3555         .pvr_mask    = 0xFFFF0000,
3556         .insns_flags = PPC_INSNS_74xx,
3557         .flags       = PPC_FLAGS_74xx,
3558         .msr_mask    = 0x000000000205FF77,
3559     },
3560     {
3561         .name        = "Apollo 6",
3562         .pvr         = CPU_PPC_7455,
3563         .pvr_mask    = 0xFFFF0000,
3564         .insns_flags = PPC_INSNS_74xx,
3565         .flags       = PPC_FLAGS_74xx,
3566         .msr_mask    = 0x000000000205FF77,
3567     },
3568 #endif
3569 #if defined (TODO)
3570     /* PowerPC 7457 (G4) */
3571     {
3572         .name        = "7457",
3573         .pvr         = CPU_PPC_7457,
3574         .pvr_mask    = 0xFFFF0000,
3575         .insns_flags = PPC_INSNS_74xx,
3576         .flags       = PPC_FLAGS_74xx,
3577         .msr_mask    = 0x000000000205FF77,
3578     },
3579     {
3580         .name        = "Apollo 7",
3581         .pvr         = CPU_PPC_7457,
3582         .pvr_mask    = 0xFFFF0000,
3583         .insns_flags = PPC_INSNS_74xx,
3584         .flags       = PPC_FLAGS_74xx,
3585         .msr_mask    = 0x000000000205FF77,
3586     },
3587 #endif
3588 #if defined (TODO)
3589     /* PowerPC 7457A (G4) */
3590     {
3591         .name        = "7457A",
3592         .pvr         = CPU_PPC_7457A,
3593         .pvr_mask    = 0xFFFF0000,
3594         .insns_flags = PPC_INSNS_74xx,
3595         .flags       = PPC_FLAGS_74xx,
3596         .msr_mask    = 0x000000000205FF77,
3597     },
3598     {
3599         .name        = "Apollo 7 PM",
3600         .pvr         = CPU_PPC_7457A,
3601         .pvr_mask    = 0xFFFF0000,
3602         .insns_flags = PPC_INSNS_74xx,
3603         .flags       = PPC_FLAGS_74xx,
3604         .msr_mask    = 0x000000000205FF77,
3605     },
3606 #endif
3607     /* 64 bits PowerPC */
3608 #if defined (TARGET_PPC64)
3609 #if defined (TODO)
3610     /* PowerPC 620 */
3611     {
3612         .name        = "620",
3613         .pvr         = CPU_PPC_620,
3614         .pvr_mask    = 0xFFFF0000,
3615         .insns_flags = PPC_INSNS_620,
3616         .flags       = PPC_FLAGS_620,
3617         .msr_mask    = 0x800000000005FF73,
3618     },
3619 #endif
3620 #if defined (TODO)
3621     /* PowerPC 630 (POWER3) */
3622     {
3623         .name        = "630",
3624         .pvr         = CPU_PPC_630,
3625         .pvr_mask    = 0xFFFF0000,
3626         .insns_flags = PPC_INSNS_630,
3627         .flags       = PPC_FLAGS_630,
3628         .msr_mask    = xxx,
3629     }
3630     {
3631         .name        = "POWER3",
3632         .pvr         = CPU_PPC_630,
3633         .pvr_mask    = 0xFFFF0000,
3634         .insns_flags = PPC_INSNS_630,
3635         .flags       = PPC_FLAGS_630,
3636         .msr_mask    = xxx,
3637     }
3638 #endif
3639 #if defined (TODO)
3640     /* PowerPC 631 (Power 3+)*/
3641     {
3642         .name        = "631",
3643         .pvr         = CPU_PPC_631,
3644         .pvr_mask    = 0xFFFF0000,
3645         .insns_flags = PPC_INSNS_631,
3646         .flags       = PPC_FLAGS_631,
3647         .msr_mask    = xxx,
3648     },
3649     {
3650         .name        = "POWER3+",
3651         .pvr         = CPU_PPC_631,
3652         .pvr_mask    = 0xFFFF0000,
3653         .insns_flags = PPC_INSNS_631,
3654         .flags       = PPC_FLAGS_631,
3655         .msr_mask    = xxx,
3656     },
3657 #endif
3658 #if defined (TODO)
3659     /* POWER4 */
3660     {
3661         .name        = "POWER4",
3662         .pvr         = CPU_PPC_POWER4,
3663         .pvr_mask    = 0xFFFF0000,
3664         .insns_flags = PPC_INSNS_POWER4,
3665         .flags       = PPC_FLAGS_POWER4,
3666         .msr_mask    = xxx,
3667     },
3668 #endif
3669 #if defined (TODO)
3670     /* POWER4p */
3671     {
3672         .name        = "POWER4+",
3673         .pvr         = CPU_PPC_POWER4P,
3674         .pvr_mask    = 0xFFFF0000,
3675         .insns_flags = PPC_INSNS_POWER4,
3676         .flags       = PPC_FLAGS_POWER4,
3677         .msr_mask    = xxx,
3678     },
3679 #endif
3680 #if defined (TODO)
3681     /* POWER5 */
3682     {
3683         .name        = "POWER5",
3684         .pvr         = CPU_PPC_POWER5,
3685         .pvr_mask    = 0xFFFF0000,
3686         .insns_flags = PPC_INSNS_POWER5,
3687         .flags       = PPC_FLAGS_POWER5,
3688         .msr_mask    = xxx,
3689     },
3690 #endif
3691 #if defined (TODO)
3692     /* POWER5+ */
3693     {
3694         .name        = "POWER5+",
3695         .pvr         = CPU_PPC_POWER5P,
3696         .pvr_mask    = 0xFFFF0000,
3697         .insns_flags = PPC_INSNS_POWER5,
3698         .flags       = PPC_FLAGS_POWER5,
3699         .msr_mask    = xxx,
3700     },
3701 #endif
3702 #if defined (TODO) || 1
3703     /* PowerPC 970 */
3704     {
3705         .name        = "970",
3706         .pvr         = CPU_PPC_970,
3707         .pvr_mask    = 0xFFFF0000,
3708         .insns_flags = PPC_INSNS_970,
3709         .flags       = PPC_FLAGS_970,
3710         .msr_mask    = 0x900000000204FF36,
3711     },
3712 #endif
3713 #if defined (TODO)
3714     /* PowerPC 970FX (G5) */
3715     {
3716         .name        = "970fx",
3717         .pvr         = CPU_PPC_970FX,
3718         .pvr_mask    = 0xFFFF0000,
3719         .insns_flags = PPC_INSNS_970FX,
3720         .flags       = PPC_FLAGS_970FX,
3721         .msr_mask    = 0x800000000204FF36,
3722     },
3723 #endif
3724 #if defined (TODO)
3725     /* RS64 (Apache/A35) */
3726     /* This one seems to support the whole POWER2 instruction set
3727      * and the PowerPC 64 one.
3728      */
3729     {
3730         .name        = "RS64",
3731         .pvr         = CPU_PPC_RS64,
3732         .pvr_mask    = 0xFFFF0000,
3733         .insns_flags = PPC_INSNS_RS64,
3734         .flags       = PPC_FLAGS_RS64,
3735         .msr_mask    = xxx,
3736     },
3737     {
3738         .name        = "Apache",
3739         .pvr         = CPU_PPC_RS64,
3740         .pvr_mask    = 0xFFFF0000,
3741         .insns_flags = PPC_INSNS_RS64,
3742         .flags       = PPC_FLAGS_RS64,
3743         .msr_mask    = xxx,
3744     },
3745     {
3746         .name        = "A35",
3747         .pvr         = CPU_PPC_RS64,
3748         .pvr_mask    = 0xFFFF0000,
3749         .insns_flags = PPC_INSNS_RS64,
3750         .flags       = PPC_FLAGS_RS64,
3751         .msr_mask    = xxx,
3752     },
3753 #endif
3754 #if defined (TODO)
3755     /* RS64-II (NorthStar/A50) */
3756     {
3757         .name        = "RS64-II",
3758         .pvr         = CPU_PPC_RS64II,
3759         .pvr_mask    = 0xFFFF0000,
3760         .insns_flags = PPC_INSNS_RS64,
3761         .flags       = PPC_FLAGS_RS64,
3762         .msr_mask    = xxx,
3763     },
3764     {
3765         .name        = "NortStar",
3766         .pvr         = CPU_PPC_RS64II,
3767         .pvr_mask    = 0xFFFF0000,
3768         .insns_flags = PPC_INSNS_RS64,
3769         .flags       = PPC_FLAGS_RS64,
3770         .msr_mask    = xxx,
3771     },
3772     {
3773         .name        = "A50",
3774         .pvr         = CPU_PPC_RS64II,
3775         .pvr_mask    = 0xFFFF0000,
3776         .insns_flags = PPC_INSNS_RS64,
3777         .flags       = PPC_FLAGS_RS64,
3778         .msr_mask    = xxx,
3779     },
3780 #endif
3781 #if defined (TODO)
3782     /* RS64-III (Pulsar) */
3783     {
3784         .name        = "RS64-III",
3785         .pvr         = CPU_PPC_RS64III,
3786         .pvr_mask    = 0xFFFF0000,
3787         .insns_flags = PPC_INSNS_RS64,
3788         .flags       = PPC_FLAGS_RS64,
3789         .msr_mask    = xxx,
3790     },
3791     {
3792         .name        = "Pulsar",
3793         .pvr         = CPU_PPC_RS64III,
3794         .pvr_mask    = 0xFFFF0000,
3795         .insns_flags = PPC_INSNS_RS64,
3796         .flags       = PPC_FLAGS_RS64,
3797         .msr_mask    = xxx,
3798     },
3799 #endif
3800 #if defined (TODO)
3801     /* RS64-IV (IceStar/IStar/SStar) */
3802     {
3803         .name        = "RS64-IV",
3804         .pvr         = CPU_PPC_RS64IV,
3805         .pvr_mask    = 0xFFFF0000,
3806         .insns_flags = PPC_INSNS_RS64,
3807         .flags       = PPC_FLAGS_RS64,
3808         .msr_mask    = xxx,
3809     },
3810     {
3811         .name        = "IceStar",
3812         .pvr         = CPU_PPC_RS64IV,
3813         .pvr_mask    = 0xFFFF0000,
3814         .insns_flags = PPC_INSNS_RS64,
3815         .flags       = PPC_FLAGS_RS64,
3816         .msr_mask    = xxx,
3817     },
3818     {
3819         .name        = "IStar",
3820         .pvr         = CPU_PPC_RS64IV,
3821         .pvr_mask    = 0xFFFF0000,
3822         .insns_flags = PPC_INSNS_RS64,
3823         .flags       = PPC_FLAGS_RS64,
3824         .msr_mask    = xxx,
3825     },
3826     {
3827         .name        = "SStar",
3828         .pvr         = CPU_PPC_RS64IV,
3829         .pvr_mask    = 0xFFFF0000,
3830         .insns_flags = PPC_INSNS_RS64,
3831         .flags       = PPC_FLAGS_RS64,
3832         .msr_mask    = xxx,
3833     },
3834 #endif
3835     /* POWER */
3836 #if defined (TODO)
3837     /* Original POWER */
3838     {
3839         .name        = "POWER",
3840         .pvr         = CPU_POWER,
3841         .pvr_mask    = 0xFFFF0000,
3842         .insns_flags = PPC_INSNS_POWER,
3843         .flags       = PPC_FLAGS_POWER,
3844         .msr_mask    = xxx,
3845     },
3846 #endif
3847 #endif /* defined (TARGET_PPC64) */
3848 #if defined (TODO)
3849     /* POWER2 */
3850     {
3851         .name        = "POWER2",
3852         .pvr         = CPU_POWER2,
3853         .pvr_mask    = 0xFFFF0000,
3854         .insns_flags = PPC_INSNS_POWER,
3855         .flags       = PPC_FLAGS_POWER,
3856         .msr_mask    = xxx,
3857     },
3858 #endif
3859     /* Generic PowerPCs */
3860 #if defined (TODO) || 1
3861     {
3862         .name        = "ppc64",
3863         .pvr         = CPU_PPC_970,
3864         .pvr_mask    = 0xFFFF0000,
3865         .insns_flags = PPC_INSNS_PPC64,
3866         .flags       = PPC_FLAGS_PPC64,
3867         .msr_mask    = 0xA00000000204FF36,
3868     },
3869 #endif
3870     {
3871         .name        = "ppc32",
3872         .pvr         = CPU_PPC_604,
3873         .pvr_mask    = 0xFFFFFFFF,
3874         .insns_flags = PPC_INSNS_PPC32,
3875         .flags       = PPC_FLAGS_PPC32,
3876         .msr_mask    = 0x000000000005FF77,
3877     },
3878     /* Fallback */
3879     {
3880         .name        = "ppc",
3881         .pvr         = CPU_PPC_604,
3882         .pvr_mask    = 0xFFFFFFFF,
3883         .insns_flags = PPC_INSNS_PPC32,
3884         .flags       = PPC_FLAGS_PPC32,
3885         .msr_mask    = 0x000000000005FF77,
3886     },
3887 };
3888
3889 int ppc_find_by_name (const unsigned char *name, ppc_def_t **def)
3890 {
3891     int i, ret;
3892
3893     ret = -1;
3894     *def = NULL;
3895     for (i = 0; strcmp(ppc_defs[i].name, "ppc") != 0; i++) {
3896         if (strcasecmp(name, ppc_defs[i].name) == 0) {
3897             *def = &ppc_defs[i];
3898             ret = 0;
3899             break;
3900         }
3901     }
3902
3903     return ret;
3904 }
3905
3906 int ppc_find_by_pvr (uint32_t pvr, ppc_def_t **def)
3907 {
3908     int i, ret;
3909
3910     ret = -1;
3911     *def = NULL;
3912     for (i = 0; ppc_defs[i].name != NULL; i++) {
3913         if ((pvr & ppc_defs[i].pvr_mask) ==
3914             (ppc_defs[i].pvr & ppc_defs[i].pvr_mask)) {
3915             *def = &ppc_defs[i];
3916             ret = 0;
3917             break;
3918         }
3919     }
3920
3921     return ret;
3922 }
3923
3924 void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
3925 {
3926     int i;
3927
3928     for (i = 0; ; i++) {
3929         (*cpu_fprintf)(f, "PowerPC %16s PVR %08x mask %08x\n",
3930                        ppc_defs[i].name,
3931                        ppc_defs[i].pvr, ppc_defs[i].pvr_mask);
3932         if (strcmp(ppc_defs[i].name, "ppc") == 0)
3933             break;
3934     }
3935 }