vcs.maemo.org Git - qemu/blob - hw/ppc405_uc.c

   1 /*
   2  * QEMU PowerPC 405 embedded processors emulation
   3  *
   4  * Copyright (c) 2007 Jocelyn Mayer
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25 #include "ppc405.h"
  26
  27 extern int loglevel;
  28 extern FILE *logfile;
  29
  30 #define DEBUG_MMIO
  31 #define DEBUG_OPBA
  32 #define DEBUG_SDRAM
  33 #define DEBUG_GPIO
  34 #define DEBUG_SERIAL
  35 #define DEBUG_OCM
  36 #define DEBUG_I2C
  37 #define DEBUG_UIC
  38 #define DEBUG_CLOCKS
  39 #define DEBUG_UNASSIGNED
  40
  41 /*****************************************************************************/
  42 /* Generic PowerPC 405 processor instanciation */
  43 CPUState *ppc405_init (const unsigned char *cpu_model,
  44                        clk_setup_t *cpu_clk, clk_setup_t *tb_clk,
  45                        uint32_t sysclk)
  46 {
  47     CPUState *env;
  48     ppc_def_t *def;
  49
  50     /* init CPUs */
  51     env = cpu_init();
  52     qemu_register_reset(&cpu_ppc_reset, env);
  53     register_savevm("cpu", 0, 3, cpu_save, cpu_load, env);
  54     ppc_find_by_name(cpu_model, &def);
  55     if (def == NULL) {
  56         cpu_abort(env, "Unable to find PowerPC %s CPU definition\n",
  57                   cpu_model);
  58     }
  59     cpu_ppc_register(env, def);
  60     cpu_clk->cb = NULL; /* We don't care about CPU clock frequency changes */
  61     cpu_clk->opaque = env;
  62     /* Set time-base frequency to sysclk */
  63     tb_clk->cb = ppc_emb_timers_init(env, sysclk);
  64     tb_clk->opaque = env;
  65     ppc_dcr_init(env, NULL, NULL);
  66
  67     return env;
  68 }
  69
  70 ram_addr_t ppc405_set_bootinfo (CPUState *env, ppc4xx_bd_info_t *bd)
  71 {
  72     ram_addr_t bdloc;
  73     int i, n;
  74
  75     /* We put the bd structure at the top of memory */
  76     bdloc = bd->bi_memsize - sizeof(struct ppc4xx_bd_info_t);
  77     stl_raw(phys_ram_base + bdloc + 0x00, bd->bi_memstart);
  78     stl_raw(phys_ram_base + bdloc + 0x04, bd->bi_memsize);
  79     stl_raw(phys_ram_base + bdloc + 0x08, bd->bi_flashstart);
  80     stl_raw(phys_ram_base + bdloc + 0x0C, bd->bi_flashsize);
  81     stl_raw(phys_ram_base + bdloc + 0x10, bd->bi_flashoffset);
  82     stl_raw(phys_ram_base + bdloc + 0x14, bd->bi_sramstart);
  83     stl_raw(phys_ram_base + bdloc + 0x18, bd->bi_sramsize);
  84     stl_raw(phys_ram_base + bdloc + 0x1C, bd->bi_bootflags);
  85     stl_raw(phys_ram_base + bdloc + 0x20, bd->bi_ipaddr);
  86     for (i = 0; i < 6; i++)
  87         stb_raw(phys_ram_base + bdloc + 0x24 + i, bd->bi_enetaddr[i]);
  88     stw_raw(phys_ram_base + bdloc + 0x2A, bd->bi_ethspeed);
  89     stl_raw(phys_ram_base + bdloc + 0x2C, bd->bi_intfreq);
  90     stl_raw(phys_ram_base + bdloc + 0x30, bd->bi_busfreq);
  91     stl_raw(phys_ram_base + bdloc + 0x34, bd->bi_baudrate);
  92     for (i = 0; i < 4; i++)
  93         stb_raw(phys_ram_base + bdloc + 0x38 + i, bd->bi_s_version[i]);
  94     for (i = 0; i < 32; i++)
  95         stb_raw(phys_ram_base + bdloc + 0x3C + i, bd->bi_s_version[i]);
  96     stl_raw(phys_ram_base + bdloc + 0x5C, bd->bi_plb_busfreq);
  97     stl_raw(phys_ram_base + bdloc + 0x60, bd->bi_pci_busfreq);
  98     for (i = 0; i < 6; i++)
  99         stb_raw(phys_ram_base + bdloc + 0x64 + i, bd->bi_pci_enetaddr[i]);
 100     n = 0x6A;
 101     if (env->spr[SPR_PVR] == CPU_PPC_405EP) {
 102         for (i = 0; i < 6; i++)
 103             stb_raw(phys_ram_base + bdloc + n++, bd->bi_pci_enetaddr2[i]);
 104     }
 105     stl_raw(phys_ram_base + bdloc + n, bd->bi_opbfreq);
 106     n += 4;
 107     for (i = 0; i < 2; i++) {
 108         stl_raw(phys_ram_base + bdloc + n, bd->bi_iic_fast[i]);
 109         n += 4;
 110     }
 111
 112     return bdloc;
 113 }
 114
 115 /*****************************************************************************/
 116 /* Shared peripherals */
 117
 118 /*****************************************************************************/
 119 /* Fake device used to map multiple devices in a single memory page */
 120 #define MMIO_AREA_BITS 8
 121 #define MMIO_AREA_LEN (1 << MMIO_AREA_BITS)
 122 #define MMIO_AREA_NB (1 << (TARGET_PAGE_BITS - MMIO_AREA_BITS))
 123 #define MMIO_IDX(addr) (((addr) >> MMIO_AREA_BITS) & (MMIO_AREA_NB - 1))
 124 struct ppc4xx_mmio_t {
 125     uint32_t base;
 126     CPUReadMemoryFunc **mem_read[MMIO_AREA_NB];
 127     CPUWriteMemoryFunc **mem_write[MMIO_AREA_NB];
 128     void *opaque[MMIO_AREA_NB];
 129 };
 130
 131 static uint32_t unassigned_mem_readb (void *opaque, target_phys_addr_t addr)
 132 {
 133 #ifdef DEBUG_UNASSIGNED
 134     printf("Unassigned mem read 0x" PADDRX "\n", addr);
 135 #endif
 136
 137     return 0;
 138 }
 139
 140 static void unassigned_mem_writeb (void *opaque,
 141                                    target_phys_addr_t addr, uint32_t val)
 142 {
 143 #ifdef DEBUG_UNASSIGNED
 144     printf("Unassigned mem write 0x" PADDRX " = 0x%x\n", addr, val);
 145 #endif
 146 }
 147
 148 static CPUReadMemoryFunc *unassigned_mem_read[3] = {
 149     unassigned_mem_readb,
 150     unassigned_mem_readb,
 151     unassigned_mem_readb,
 152 };
 153
 154 static CPUWriteMemoryFunc *unassigned_mem_write[3] = {
 155     unassigned_mem_writeb,
 156     unassigned_mem_writeb,
 157     unassigned_mem_writeb,
 158 };
 159
 160 static uint32_t mmio_readlen (ppc4xx_mmio_t *mmio,
 161                               target_phys_addr_t addr, int len)
 162 {
 163     CPUReadMemoryFunc **mem_read;
 164     uint32_t ret;
 165     int idx;
 166
 167     idx = MMIO_IDX(addr - mmio->base);
 168 #if defined(DEBUG_MMIO)
 169     printf("%s: mmio %p len %d addr " PADDRX " idx %d\n", __func__,
 170            mmio, len, addr, idx);
 171 #endif
 172     mem_read = mmio->mem_read[idx];
 173     ret = (*mem_read[len])(mmio->opaque[idx], addr);
 174
 175     return ret;
 176 }
 177
 178 static void mmio_writelen (ppc4xx_mmio_t *mmio,
 179                            target_phys_addr_t addr, uint32_t value, int len)
 180 {
 181     CPUWriteMemoryFunc **mem_write;
 182     int idx;
 183
 184     idx = MMIO_IDX(addr - mmio->base);
 185 #if defined(DEBUG_MMIO)
 186     printf("%s: mmio %p len %d addr " PADDRX " idx %d value %08x\n", __func__,
 187            mmio, len, addr, idx, value);
 188 #endif
 189     mem_write = mmio->mem_write[idx];
 190     (*mem_write[len])(mmio->opaque[idx], addr, value);
 191 }
 192
 193 static uint32_t mmio_readb (void *opaque, target_phys_addr_t addr)
 194 {
 195 #if defined(DEBUG_MMIO)
 196     printf("%s: addr " PADDRX "\n", __func__, addr);
 197 #endif
 198
 199     return mmio_readlen(opaque, addr, 0);
 200 }
 201
 202 static void mmio_writeb (void *opaque,
 203                          target_phys_addr_t addr, uint32_t value)
 204 {
 205 #if defined(DEBUG_MMIO)
 206     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 207 #endif
 208     mmio_writelen(opaque, addr, value, 0);
 209 }
 210
 211 static uint32_t mmio_readw (void *opaque, target_phys_addr_t addr)
 212 {
 213 #if defined(DEBUG_MMIO)
 214     printf("%s: addr " PADDRX "\n", __func__, addr);
 215 #endif
 216
 217     return mmio_readlen(opaque, addr, 1);
 218 }
 219
 220 static void mmio_writew (void *opaque,
 221                          target_phys_addr_t addr, uint32_t value)
 222 {
 223 #if defined(DEBUG_MMIO)
 224     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 225 #endif
 226     mmio_writelen(opaque, addr, value, 1);
 227 }
 228
 229 static uint32_t mmio_readl (void *opaque, target_phys_addr_t addr)
 230 {
 231 #if defined(DEBUG_MMIO)
 232     printf("%s: addr " PADDRX "\n", __func__, addr);
 233 #endif
 234
 235     return mmio_readlen(opaque, addr, 2);
 236 }
 237
 238 static void mmio_writel (void *opaque,
 239                          target_phys_addr_t addr, uint32_t value)
 240 {
 241 #if defined(DEBUG_MMIO)
 242     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 243 #endif
 244     mmio_writelen(opaque, addr, value, 2);
 245 }
 246
 247 static CPUReadMemoryFunc *mmio_read[] = {
 248     &mmio_readb,
 249     &mmio_readw,
 250     &mmio_readl,
 251 };
 252
 253 static CPUWriteMemoryFunc *mmio_write[] = {
 254     &mmio_writeb,
 255     &mmio_writew,
 256     &mmio_writel,
 257 };
 258
 259 int ppc4xx_mmio_register (CPUState *env, ppc4xx_mmio_t *mmio,
 260                           uint32_t offset, uint32_t len,
 261                           CPUReadMemoryFunc **mem_read,
 262                           CPUWriteMemoryFunc **mem_write, void *opaque)
 263 {
 264     uint32_t end;
 265     int idx, eidx;
 266
 267     if ((offset + len) > TARGET_PAGE_SIZE)
 268         return -1;
 269     idx = MMIO_IDX(offset);
 270     end = offset + len - 1;
 271     eidx = MMIO_IDX(end);
 272 #if defined(DEBUG_MMIO)
 273     printf("%s: offset %08x len %08x %08x %d %d\n", __func__, offset, len,
 274            end, idx, eidx);
 275 #endif
 276     for (; idx <= eidx; idx++) {
 277         mmio->mem_read[idx] = mem_read;
 278         mmio->mem_write[idx] = mem_write;
 279         mmio->opaque[idx] = opaque;
 280     }
 281
 282     return 0;
 283 }
 284
 285 ppc4xx_mmio_t *ppc4xx_mmio_init (CPUState *env, uint32_t base)
 286 {
 287     ppc4xx_mmio_t *mmio;
 288     int mmio_memory;
 289
 290     mmio = qemu_mallocz(sizeof(ppc4xx_mmio_t));
 291     if (mmio != NULL) {
 292         mmio->base = base;
 293         mmio_memory = cpu_register_io_memory(0, mmio_read, mmio_write, mmio);
 294 #if defined(DEBUG_MMIO)
 295         printf("%s: %p base %08x len %08x %d\n", __func__,
 296                mmio, base, TARGET_PAGE_SIZE, mmio_memory);
 297 #endif
 298         cpu_register_physical_memory(base, TARGET_PAGE_SIZE, mmio_memory);
 299         ppc4xx_mmio_register(env, mmio, 0, TARGET_PAGE_SIZE,
 300                              unassigned_mem_read, unassigned_mem_write, NULL);
 301     }
 302
 303     return mmio;
 304 }
 305
 306 /*****************************************************************************/
 307 /* Peripheral local bus arbitrer */
 308 enum {
 309     PLB0_BESR = 0x084,
 310     PLB0_BEAR = 0x086,
 311     PLB0_ACR  = 0x087,
 312 };
 313
 314 typedef struct ppc4xx_plb_t ppc4xx_plb_t;
 315 struct ppc4xx_plb_t {
 316     uint32_t acr;
 317     uint32_t bear;
 318     uint32_t besr;
 319 };
 320
 321 static target_ulong dcr_read_plb (void *opaque, int dcrn)
 322 {
 323     ppc4xx_plb_t *plb;
 324     target_ulong ret;
 325
 326     plb = opaque;
 327     switch (dcrn) {
 328     case PLB0_ACR:
 329         ret = plb->acr;
 330         break;
 331     case PLB0_BEAR:
 332         ret = plb->bear;
 333         break;
 334     case PLB0_BESR:
 335         ret = plb->besr;
 336         break;
 337     default:
 338         /* Avoid gcc warning */
 339         ret = 0;
 340         break;
 341     }
 342
 343     return ret;
 344 }
 345
 346 static void dcr_write_plb (void *opaque, int dcrn, target_ulong val)
 347 {
 348     ppc4xx_plb_t *plb;
 349
 350     plb = opaque;
 351     switch (dcrn) {
 352     case PLB0_ACR:
 353         plb->acr = val & 0xFC000000;
 354         break;
 355     case PLB0_BEAR:
 356         /* Read only */
 357         break;
 358     case PLB0_BESR:
 359         /* Write-clear */
 360         plb->besr &= ~val;
 361         break;
 362     }
 363 }
 364
 365 static void ppc4xx_plb_reset (void *opaque)
 366 {
 367     ppc4xx_plb_t *plb;
 368
 369     plb = opaque;
 370     plb->acr = 0x00000000;
 371     plb->bear = 0x00000000;
 372     plb->besr = 0x00000000;
 373 }
 374
 375 void ppc4xx_plb_init (CPUState *env)
 376 {
 377     ppc4xx_plb_t *plb;
 378
 379     plb = qemu_mallocz(sizeof(ppc4xx_plb_t));
 380     if (plb != NULL) {
 381         ppc_dcr_register(env, PLB0_ACR, plb, &dcr_read_plb, &dcr_write_plb);
 382         ppc_dcr_register(env, PLB0_BEAR, plb, &dcr_read_plb, &dcr_write_plb);
 383         ppc_dcr_register(env, PLB0_BESR, plb, &dcr_read_plb, &dcr_write_plb);
 384         ppc4xx_plb_reset(plb);
 385         qemu_register_reset(ppc4xx_plb_reset, plb);
 386     }
 387 }
 388
 389 /*****************************************************************************/
 390 /* PLB to OPB bridge */
 391 enum {
 392     POB0_BESR0 = 0x0A0,
 393     POB0_BESR1 = 0x0A2,
 394     POB0_BEAR  = 0x0A4,
 395 };
 396
 397 typedef struct ppc4xx_pob_t ppc4xx_pob_t;
 398 struct ppc4xx_pob_t {
 399     uint32_t bear;
 400     uint32_t besr[2];
 401 };
 402
 403 static target_ulong dcr_read_pob (void *opaque, int dcrn)
 404 {
 405     ppc4xx_pob_t *pob;
 406     target_ulong ret;
 407
 408     pob = opaque;
 409     switch (dcrn) {
 410     case POB0_BEAR:
 411         ret = pob->bear;
 412         break;
 413     case POB0_BESR0:
 414     case POB0_BESR1:
 415         ret = pob->besr[dcrn - POB0_BESR0];
 416         break;
 417     default:
 418         /* Avoid gcc warning */
 419         ret = 0;
 420         break;
 421     }
 422
 423     return ret;
 424 }
 425
 426 static void dcr_write_pob (void *opaque, int dcrn, target_ulong val)
 427 {
 428     ppc4xx_pob_t *pob;
 429
 430     pob = opaque;
 431     switch (dcrn) {
 432     case POB0_BEAR:
 433         /* Read only */
 434         break;
 435     case POB0_BESR0:
 436     case POB0_BESR1:
 437         /* Write-clear */
 438         pob->besr[dcrn - POB0_BESR0] &= ~val;
 439         break;
 440     }
 441 }
 442
 443 static void ppc4xx_pob_reset (void *opaque)
 444 {
 445     ppc4xx_pob_t *pob;
 446
 447     pob = opaque;
 448     /* No error */
 449     pob->bear = 0x00000000;
 450     pob->besr[0] = 0x0000000;
 451     pob->besr[1] = 0x0000000;
 452 }
 453
 454 void ppc4xx_pob_init (CPUState *env)
 455 {
 456     ppc4xx_pob_t *pob;
 457
 458     pob = qemu_mallocz(sizeof(ppc4xx_pob_t));
 459     if (pob != NULL) {
 460         ppc_dcr_register(env, POB0_BEAR, pob, &dcr_read_pob, &dcr_write_pob);
 461         ppc_dcr_register(env, POB0_BESR0, pob, &dcr_read_pob, &dcr_write_pob);
 462         ppc_dcr_register(env, POB0_BESR1, pob, &dcr_read_pob, &dcr_write_pob);
 463         qemu_register_reset(ppc4xx_pob_reset, pob);
 464         ppc4xx_pob_reset(env);
 465     }
 466 }
 467
 468 /*****************************************************************************/
 469 /* OPB arbitrer */
 470 typedef struct ppc4xx_opba_t ppc4xx_opba_t;
 471 struct ppc4xx_opba_t {
 472     target_ulong base;
 473     uint8_t cr;
 474     uint8_t pr;
 475 };
 476
 477 static uint32_t opba_readb (void *opaque, target_phys_addr_t addr)
 478 {
 479     ppc4xx_opba_t *opba;
 480     uint32_t ret;
 481
 482 #ifdef DEBUG_OPBA
 483     printf("%s: addr " PADDRX "\n", __func__, addr);
 484 #endif
 485     opba = opaque;
 486     switch (addr - opba->base) {
 487     case 0x00:
 488         ret = opba->cr;
 489         break;
 490     case 0x01:
 491         ret = opba->pr;
 492         break;
 493     default:
 494         ret = 0x00;
 495         break;
 496     }
 497
 498     return ret;
 499 }
 500
 501 static void opba_writeb (void *opaque,
 502                          target_phys_addr_t addr, uint32_t value)
 503 {
 504     ppc4xx_opba_t *opba;
 505
 506 #ifdef DEBUG_OPBA
 507     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 508 #endif
 509     opba = opaque;
 510     switch (addr - opba->base) {
 511     case 0x00:
 512         opba->cr = value & 0xF8;
 513         break;
 514     case 0x01:
 515         opba->pr = value & 0xFF;
 516         break;
 517     default:
 518         break;
 519     }
 520 }
 521
 522 static uint32_t opba_readw (void *opaque, target_phys_addr_t addr)
 523 {
 524     uint32_t ret;
 525
 526 #ifdef DEBUG_OPBA
 527     printf("%s: addr " PADDRX "\n", __func__, addr);
 528 #endif
 529     ret = opba_readb(opaque, addr) << 8;
 530     ret |= opba_readb(opaque, addr + 1);
 531
 532     return ret;
 533 }
 534
 535 static void opba_writew (void *opaque,
 536                          target_phys_addr_t addr, uint32_t value)
 537 {
 538 #ifdef DEBUG_OPBA
 539     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 540 #endif
 541     opba_writeb(opaque, addr, value >> 8);
 542     opba_writeb(opaque, addr + 1, value);
 543 }
 544
 545 static uint32_t opba_readl (void *opaque, target_phys_addr_t addr)
 546 {
 547     uint32_t ret;
 548
 549 #ifdef DEBUG_OPBA
 550     printf("%s: addr " PADDRX "\n", __func__, addr);
 551 #endif
 552     ret = opba_readb(opaque, addr) << 24;
 553     ret |= opba_readb(opaque, addr + 1) << 16;
 554
 555     return ret;
 556 }
 557
 558 static void opba_writel (void *opaque,
 559                          target_phys_addr_t addr, uint32_t value)
 560 {
 561 #ifdef DEBUG_OPBA
 562     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
 563 #endif
 564     opba_writeb(opaque, addr, value >> 24);
 565     opba_writeb(opaque, addr + 1, value >> 16);
 566 }
 567
 568 static CPUReadMemoryFunc *opba_read[] = {
 569     &opba_readb,
 570     &opba_readw,
 571     &opba_readl,
 572 };
 573
 574 static CPUWriteMemoryFunc *opba_write[] = {
 575     &opba_writeb,
 576     &opba_writew,
 577     &opba_writel,
 578 };
 579
 580 static void ppc4xx_opba_reset (void *opaque)
 581 {
 582     ppc4xx_opba_t *opba;
 583
 584     opba = opaque;
 585     opba->cr = 0x00; /* No dynamic priorities - park disabled */
 586     opba->pr = 0x11;
 587 }
 588
 589 void ppc4xx_opba_init (CPUState *env, ppc4xx_mmio_t *mmio, uint32_t offset)
 590 {
 591     ppc4xx_opba_t *opba;
 592
 593     opba = qemu_mallocz(sizeof(ppc4xx_opba_t));
 594     if (opba != NULL) {
 595         opba->base = mmio->base + offset;
 596 #ifdef DEBUG_OPBA
 597         printf("%s: offset=%08x\n", __func__, offset);
 598 #endif
 599         ppc4xx_mmio_register(env, mmio, offset, 0x002,
 600                              opba_read, opba_write, opba);
 601         qemu_register_reset(ppc4xx_opba_reset, opba);
 602         ppc4xx_opba_reset(opba);
 603     }
 604 }
 605
 606 /*****************************************************************************/
 607 /* "Universal" Interrupt controller */
 608 enum {
 609     DCR_UICSR  = 0x000,
 610     DCR_UICSRS = 0x001,
 611     DCR_UICER  = 0x002,
 612     DCR_UICCR  = 0x003,
 613     DCR_UICPR  = 0x004,
 614     DCR_UICTR  = 0x005,
 615     DCR_UICMSR = 0x006,
 616     DCR_UICVR  = 0x007,
 617     DCR_UICVCR = 0x008,
 618     DCR_UICMAX = 0x009,
 619 };
 620
 621 #define UIC_MAX_IRQ 32
 622 typedef struct ppcuic_t ppcuic_t;
 623 struct ppcuic_t {
 624     uint32_t dcr_base;
 625     int use_vectors;
 626     uint32_t uicsr;  /* Status register */
 627     uint32_t uicer;  /* Enable register */
 628     uint32_t uiccr;  /* Critical register */
 629     uint32_t uicpr;  /* Polarity register */
 630     uint32_t uictr;  /* Triggering register */
 631     uint32_t uicvcr; /* Vector configuration register */
 632     uint32_t uicvr;
 633     qemu_irq *irqs;
 634 };
 635
 636 static void ppcuic_trigger_irq (ppcuic_t *uic)
 637 {
 638     uint32_t ir, cr;
 639     int start, end, inc, i;
 640
 641     /* Trigger interrupt if any is pending */
 642     ir = uic->uicsr & uic->uicer & (~uic->uiccr);
 643     cr = uic->uicsr & uic->uicer & uic->uiccr;
 644 #ifdef DEBUG_UIC
 645     if (loglevel & CPU_LOG_INT) {
 646         fprintf(logfile, "%s: uicsr %08x uicer %08x uiccr %08x\n"
 647                 "   %08x ir %08x cr %08x\n", __func__,
 648                 uic->uicsr, uic->uicer, uic->uiccr,
 649                 uic->uicsr & uic->uicer, ir, cr);
 650     }
 651 #endif
 652     if (ir != 0x0000000) {
 653 #ifdef DEBUG_UIC
 654         if (loglevel & CPU_LOG_INT) {
 655             fprintf(logfile, "Raise UIC interrupt\n");
 656         }
 657 #endif
 658         qemu_irq_raise(uic->irqs[PPCUIC_OUTPUT_INT]);
 659     } else {
 660 #ifdef DEBUG_UIC
 661         if (loglevel & CPU_LOG_INT) {
 662             fprintf(logfile, "Lower UIC interrupt\n");
 663         }
 664 #endif
 665         qemu_irq_lower(uic->irqs[PPCUIC_OUTPUT_INT]);
 666     }
 667     /* Trigger critical interrupt if any is pending and update vector */
 668     if (cr != 0x0000000) {
 669         qemu_irq_raise(uic->irqs[PPCUIC_OUTPUT_CINT]);
 670         if (uic->use_vectors) {
 671             /* Compute critical IRQ vector */
 672             if (uic->uicvcr & 1) {
 673                 start = 31;
 674                 end = 0;
 675                 inc = -1;
 676             } else {
 677                 start = 0;
 678                 end = 31;
 679                 inc = 1;
 680             }
 681             uic->uicvr = uic->uicvcr & 0xFFFFFFFC;
 682             for (i = start; i <= end; i += inc) {
 683                 if (cr & (1 << i)) {
 684                     uic->uicvr += (i - start) * 512 * inc;
 685                     break;
 686                 }
 687             }
 688         }
 689 #ifdef DEBUG_UIC
 690         if (loglevel & CPU_LOG_INT) {
 691             fprintf(logfile, "Raise UIC critical interrupt - vector %08x\n",
 692                     uic->uicvr);
 693         }
 694 #endif
 695     } else {
 696 #ifdef DEBUG_UIC
 697         if (loglevel & CPU_LOG_INT) {
 698             fprintf(logfile, "Lower UIC critical interrupt\n");
 699         }
 700 #endif
 701         qemu_irq_lower(uic->irqs[PPCUIC_OUTPUT_CINT]);
 702         uic->uicvr = 0x00000000;
 703     }
 704 }
 705
 706 static void ppcuic_set_irq (void *opaque, int irq_num, int level)
 707 {
 708     ppcuic_t *uic;
 709     uint32_t mask, sr;
 710
 711     uic = opaque;
 712     mask = 1 << irq_num;
 713 #ifdef DEBUG_UIC
 714     if (loglevel & CPU_LOG_INT) {
 715         fprintf(logfile, "%s: irq %d level %d uicsr %08x mask %08x => %08x "
 716                 "%08x\n", __func__, irq_num, level,
 717                 uic->uicsr, mask, uic->uicsr & mask, level << irq_num);
 718     }
 719 #endif
 720     if (irq_num < 0 || irq_num > 31)
 721         return;
 722     sr = uic->uicsr;
 723     if (!(uic->uicpr & mask)) {
 724         /* Negatively asserted IRQ */
 725         level = level == 0 ? 1 : 0;
 726     }
 727     /* Update status register */
 728     if (uic->uictr & mask) {
 729         /* Edge sensitive interrupt */
 730         if (level == 1)
 731             uic->uicsr |= mask;
 732     } else {
 733         /* Level sensitive interrupt */
 734         if (level == 1)
 735             uic->uicsr |= mask;
 736         else
 737             uic->uicsr &= ~mask;
 738     }
 739 #ifdef DEBUG_UIC
 740     if (loglevel & CPU_LOG_INT) {
 741         fprintf(logfile, "%s: irq %d level %d sr %08x => %08x\n", __func__,
 742                 irq_num, level, uic->uicsr, sr);
 743     }
 744 #endif
 745     if (sr != uic->uicsr)
 746         ppcuic_trigger_irq(uic);
 747 }
 748
 749 static target_ulong dcr_read_uic (void *opaque, int dcrn)
 750 {
 751     ppcuic_t *uic;
 752     target_ulong ret;
 753
 754     uic = opaque;
 755     dcrn -= uic->dcr_base;
 756     switch (dcrn) {
 757     case DCR_UICSR:
 758     case DCR_UICSRS:
 759         ret = uic->uicsr;
 760         break;
 761     case DCR_UICER:
 762         ret = uic->uicer;
 763         break;
 764     case DCR_UICCR:
 765         ret = uic->uiccr;
 766         break;
 767     case DCR_UICPR:
 768         ret = uic->uicpr;
 769         break;
 770     case DCR_UICTR:
 771         ret = uic->uictr;
 772         break;
 773     case DCR_UICMSR:
 774         ret = uic->uicsr & uic->uicer;
 775         break;
 776     case DCR_UICVR:
 777         if (!uic->use_vectors)
 778             goto no_read;
 779         ret = uic->uicvr;
 780         break;
 781     case DCR_UICVCR:
 782         if (!uic->use_vectors)
 783             goto no_read;
 784         ret = uic->uicvcr;
 785         break;
 786     default:
 787     no_read:
 788         ret = 0x00000000;
 789         break;
 790     }
 791
 792     return ret;
 793 }
 794
 795 static void dcr_write_uic (void *opaque, int dcrn, target_ulong val)
 796 {
 797     ppcuic_t *uic;
 798
 799     uic = opaque;
 800     dcrn -= uic->dcr_base;
 801 #ifdef DEBUG_UIC
 802     if (loglevel & CPU_LOG_INT) {
 803         fprintf(logfile, "%s: dcr %d val " ADDRX "\n", __func__, dcrn, val);
 804     }
 805 #endif
 806     switch (dcrn) {
 807     case DCR_UICSR:
 808         uic->uicsr &= ~val;
 809         ppcuic_trigger_irq(uic);
 810         break;
 811     case DCR_UICSRS:
 812         uic->uicsr |= val;
 813         ppcuic_trigger_irq(uic);
 814         break;
 815     case DCR_UICER:
 816         uic->uicer = val;
 817         ppcuic_trigger_irq(uic);
 818         break;
 819     case DCR_UICCR:
 820         uic->uiccr = val;
 821         ppcuic_trigger_irq(uic);
 822         break;
 823     case DCR_UICPR:
 824         uic->uicpr = val;
 825         ppcuic_trigger_irq(uic);
 826         break;
 827     case DCR_UICTR:
 828         uic->uictr = val;
 829         ppcuic_trigger_irq(uic);
 830         break;
 831     case DCR_UICMSR:
 832         break;
 833     case DCR_UICVR:
 834         break;
 835     case DCR_UICVCR:
 836         uic->uicvcr = val & 0xFFFFFFFD;
 837         ppcuic_trigger_irq(uic);
 838         break;
 839     }
 840 }
 841
 842 static void ppcuic_reset (void *opaque)
 843 {
 844     ppcuic_t *uic;
 845
 846     uic = opaque;
 847     uic->uiccr = 0x00000000;
 848     uic->uicer = 0x00000000;
 849     uic->uicpr = 0x00000000;
 850     uic->uicsr = 0x00000000;
 851     uic->uictr = 0x00000000;
 852     if (uic->use_vectors) {
 853         uic->uicvcr = 0x00000000;
 854         uic->uicvr = 0x0000000;
 855     }
 856 }
 857
 858 qemu_irq *ppcuic_init (CPUState *env, qemu_irq *irqs,
 859                        uint32_t dcr_base, int has_ssr, int has_vr)
 860 {
 861     ppcuic_t *uic;
 862     int i;
 863
 864     uic = qemu_mallocz(sizeof(ppcuic_t));
 865     if (uic != NULL) {
 866         uic->dcr_base = dcr_base;
 867         uic->irqs = irqs;
 868         if (has_vr)
 869             uic->use_vectors = 1;
 870         for (i = 0; i < DCR_UICMAX; i++) {
 871             ppc_dcr_register(env, dcr_base + i, uic,
 872                              &dcr_read_uic, &dcr_write_uic);
 873         }
 874         qemu_register_reset(ppcuic_reset, uic);
 875         ppcuic_reset(uic);
 876     }
 877
 878     return qemu_allocate_irqs(&ppcuic_set_irq, uic, UIC_MAX_IRQ);
 879 }
 880
 881 /*****************************************************************************/
 882 /* Code decompression controller */
 883 /* XXX: TODO */
 884
 885 /*****************************************************************************/
 886 /* SDRAM controller */
 887 typedef struct ppc4xx_sdram_t ppc4xx_sdram_t;
 888 struct ppc4xx_sdram_t {
 889     uint32_t addr;
 890     int nbanks;
 891     target_ulong ram_bases[4];
 892     target_ulong ram_sizes[4];
 893     uint32_t besr0;
 894     uint32_t besr1;
 895     uint32_t bear;
 896     uint32_t cfg;
 897     uint32_t status;
 898     uint32_t rtr;
 899     uint32_t pmit;
 900     uint32_t bcr[4];
 901     uint32_t tr;
 902     uint32_t ecccfg;
 903     uint32_t eccesr;
 904     qemu_irq irq;
 905 };
 906
 907 enum {
 908     SDRAM0_CFGADDR = 0x010,
 909     SDRAM0_CFGDATA = 0x011,
 910 };
 911
 912 static uint32_t sdram_bcr (target_ulong ram_base, target_ulong ram_size)
 913 {
 914     uint32_t bcr;
 915
 916     switch (ram_size) {
 917     case (4 * 1024 * 1024):
 918         bcr = 0x00000000;
 919         break;
 920     case (8 * 1024 * 1024):
 921         bcr = 0x00020000;
 922         break;
 923     case (16 * 1024 * 1024):
 924         bcr = 0x00040000;
 925         break;
 926     case (32 * 1024 * 1024):
 927         bcr = 0x00060000;
 928         break;
 929     case (64 * 1024 * 1024):
 930         bcr = 0x00080000;
 931         break;
 932     case (128 * 1024 * 1024):
 933         bcr = 0x000A0000;
 934         break;
 935     case (256 * 1024 * 1024):
 936         bcr = 0x000C0000;
 937         break;
 938     default:
 939         printf("%s: invalid RAM size " TARGET_FMT_ld "\n", __func__, ram_size);
 940         return 0x00000000;
 941     }
 942     bcr |= ram_base & 0xFF800000;
 943     bcr |= 1;
 944
 945     return bcr;
 946 }
 947
 948 static inline target_ulong sdram_base (uint32_t bcr)
 949 {
 950     return bcr & 0xFF800000;
 951 }
 952
 953 static target_ulong sdram_size (uint32_t bcr)
 954 {
 955     target_ulong size;
 956     int sh;
 957
 958     sh = (bcr >> 17) & 0x7;
 959     if (sh == 7)
 960         size = -1;
 961     else
 962         size = (4 * 1024 * 1024) << sh;
 963
 964     return size;
 965 }
 966
 967 static void sdram_set_bcr (uint32_t *bcrp, uint32_t bcr, int enabled)
 968 {
 969     if (*bcrp & 0x00000001) {
 970         /* Unmap RAM */
 971 #ifdef DEBUG_SDRAM
 972         printf("%s: unmap RAM area " ADDRX " " ADDRX "\n", __func__,
 973                sdram_base(*bcrp), sdram_size(*bcrp));
 974 #endif
 975         cpu_register_physical_memory(sdram_base(*bcrp), sdram_size(*bcrp),
 976                                      IO_MEM_UNASSIGNED);
 977     }
 978     *bcrp = bcr & 0xFFDEE001;
 979     if (enabled && (bcr & 0x00000001)) {
 980 #ifdef DEBUG_SDRAM
 981         printf("%s: Map RAM area " ADDRX " " ADDRX "\n", __func__,
 982                sdram_base(bcr), sdram_size(bcr));
 983 #endif
 984         cpu_register_physical_memory(sdram_base(bcr), sdram_size(bcr),
 985                                      sdram_base(bcr) | IO_MEM_RAM);
 986     }
 987 }
 988
 989 static void sdram_map_bcr (ppc4xx_sdram_t *sdram)
 990 {
 991     int i;
 992
 993     for (i = 0; i < sdram->nbanks; i++) {
 994         if (sdram->ram_sizes[i] != 0) {
 995             sdram_set_bcr(&sdram->bcr[i],
 996                           sdram_bcr(sdram->ram_bases[i], sdram->ram_sizes[i]),
 997                           1);
 998         } else {
 999             sdram_set_bcr(&sdram->bcr[i], 0x00000000, 0);
1000         }
1001     }
1002 }
1003
1004 static void sdram_unmap_bcr (ppc4xx_sdram_t *sdram)
1005 {
1006     int i;
1007
1008     for (i = 0; i < sdram->nbanks; i++) {
1009 #ifdef DEBUG_SDRAM
1010         printf("%s: Unmap RAM area " ADDRX " " ADDRX "\n", __func__,
1011                sdram_base(sdram->bcr[i]), sdram_size(sdram->bcr[i]));
1012 #endif
1013         cpu_register_physical_memory(sdram_base(sdram->bcr[i]),
1014                                      sdram_size(sdram->bcr[i]),
1015                                      IO_MEM_UNASSIGNED);
1016     }
1017 }
1018
1019 static target_ulong dcr_read_sdram (void *opaque, int dcrn)
1020 {
1021     ppc4xx_sdram_t *sdram;
1022     target_ulong ret;
1023
1024     sdram = opaque;
1025     switch (dcrn) {
1026     case SDRAM0_CFGADDR:
1027         ret = sdram->addr;
1028         break;
1029     case SDRAM0_CFGDATA:
1030         switch (sdram->addr) {
1031         case 0x00: /* SDRAM_BESR0 */
1032             ret = sdram->besr0;
1033             break;
1034         case 0x08: /* SDRAM_BESR1 */
1035             ret = sdram->besr1;
1036             break;
1037         case 0x10: /* SDRAM_BEAR */
1038             ret = sdram->bear;
1039             break;
1040         case 0x20: /* SDRAM_CFG */
1041             ret = sdram->cfg;
1042             break;
1043         case 0x24: /* SDRAM_STATUS */
1044             ret = sdram->status;
1045             break;
1046         case 0x30: /* SDRAM_RTR */
1047             ret = sdram->rtr;
1048             break;
1049         case 0x34: /* SDRAM_PMIT */
1050             ret = sdram->pmit;
1051             break;
1052         case 0x40: /* SDRAM_B0CR */
1053             ret = sdram->bcr[0];
1054             break;
1055         case 0x44: /* SDRAM_B1CR */
1056             ret = sdram->bcr[1];
1057             break;
1058         case 0x48: /* SDRAM_B2CR */
1059             ret = sdram->bcr[2];
1060             break;
1061         case 0x4C: /* SDRAM_B3CR */
1062             ret = sdram->bcr[3];
1063             break;
1064         case 0x80: /* SDRAM_TR */
1065             ret = -1; /* ? */
1066             break;
1067         case 0x94: /* SDRAM_ECCCFG */
1068             ret = sdram->ecccfg;
1069             break;
1070         case 0x98: /* SDRAM_ECCESR */
1071             ret = sdram->eccesr;
1072             break;
1073         default: /* Error */
1074             ret = -1;
1075             break;
1076         }
1077         break;
1078     default:
1079         /* Avoid gcc warning */
1080         ret = 0x00000000;
1081         break;
1082     }
1083
1084     return ret;
1085 }
1086
1087 static void dcr_write_sdram (void *opaque, int dcrn, target_ulong val)
1088 {
1089     ppc4xx_sdram_t *sdram;
1090
1091     sdram = opaque;
1092     switch (dcrn) {
1093     case SDRAM0_CFGADDR:
1094         sdram->addr = val;
1095         break;
1096     case SDRAM0_CFGDATA:
1097         switch (sdram->addr) {
1098         case 0x00: /* SDRAM_BESR0 */
1099             sdram->besr0 &= ~val;
1100             break;
1101         case 0x08: /* SDRAM_BESR1 */
1102             sdram->besr1 &= ~val;
1103             break;
1104         case 0x10: /* SDRAM_BEAR */
1105             sdram->bear = val;
1106             break;
1107         case 0x20: /* SDRAM_CFG */
1108             val &= 0xFFE00000;
1109             if (!(sdram->cfg & 0x80000000) && (val & 0x80000000)) {
1110 #ifdef DEBUG_SDRAM
1111                 printf("%s: enable SDRAM controller\n", __func__);
1112 #endif
1113                 /* validate all RAM mappings */
1114                 sdram_map_bcr(sdram);
1115                 sdram->status &= ~0x80000000;
1116             } else if ((sdram->cfg & 0x80000000) && !(val & 0x80000000)) {
1117 #ifdef DEBUG_SDRAM
1118                 printf("%s: disable SDRAM controller\n", __func__);
1119 #endif
1120                 /* invalidate all RAM mappings */
1121                 sdram_unmap_bcr(sdram);
1122                 sdram->status |= 0x80000000;
1123             }
1124             if (!(sdram->cfg & 0x40000000) && (val & 0x40000000))
1125                 sdram->status |= 0x40000000;
1126             else if ((sdram->cfg & 0x40000000) && !(val & 0x40000000))
1127                 sdram->status &= ~0x40000000;
1128             sdram->cfg = val;
1129             break;
1130         case 0x24: /* SDRAM_STATUS */
1131             /* Read-only register */
1132             break;
1133         case 0x30: /* SDRAM_RTR */
1134             sdram->rtr = val & 0x3FF80000;
1135             break;
1136         case 0x34: /* SDRAM_PMIT */
1137             sdram->pmit = (val & 0xF8000000) | 0x07C00000;
1138             break;
1139         case 0x40: /* SDRAM_B0CR */
1140             sdram_set_bcr(&sdram->bcr[0], val, sdram->cfg & 0x80000000);
1141             break;
1142         case 0x44: /* SDRAM_B1CR */
1143             sdram_set_bcr(&sdram->bcr[1], val, sdram->cfg & 0x80000000);
1144             break;
1145         case 0x48: /* SDRAM_B2CR */
1146             sdram_set_bcr(&sdram->bcr[2], val, sdram->cfg & 0x80000000);
1147             break;
1148         case 0x4C: /* SDRAM_B3CR */
1149             sdram_set_bcr(&sdram->bcr[3], val, sdram->cfg & 0x80000000);
1150             break;
1151         case 0x80: /* SDRAM_TR */
1152             sdram->tr = val & 0x018FC01F;
1153             break;
1154         case 0x94: /* SDRAM_ECCCFG */
1155             sdram->ecccfg = val & 0x00F00000;
1156             break;
1157         case 0x98: /* SDRAM_ECCESR */
1158             val &= 0xFFF0F000;
1159             if (sdram->eccesr == 0 && val != 0)
1160                 qemu_irq_raise(sdram->irq);
1161             else if (sdram->eccesr != 0 && val == 0)
1162                 qemu_irq_lower(sdram->irq);
1163             sdram->eccesr = val;
1164             break;
1165         default: /* Error */
1166             break;
1167         }
1168         break;
1169     }
1170 }
1171
1172 static void sdram_reset (void *opaque)
1173 {
1174     ppc4xx_sdram_t *sdram;
1175
1176     sdram = opaque;
1177     sdram->addr = 0x00000000;
1178     sdram->bear = 0x00000000;
1179     sdram->besr0 = 0x00000000; /* No error */
1180     sdram->besr1 = 0x00000000; /* No error */
1181     sdram->cfg = 0x00000000;
1182     sdram->ecccfg = 0x00000000; /* No ECC */
1183     sdram->eccesr = 0x00000000; /* No error */
1184     sdram->pmit = 0x07C00000;
1185     sdram->rtr = 0x05F00000;
1186     sdram->tr = 0x00854009;
1187     /* We pre-initialize RAM banks */
1188     sdram->status = 0x00000000;
1189     sdram->cfg = 0x00800000;
1190     sdram_unmap_bcr(sdram);
1191 }
1192
1193 void ppc405_sdram_init (CPUState *env, qemu_irq irq, int nbanks,
1194                         target_ulong *ram_bases, target_ulong *ram_sizes,
1195                         int do_init)
1196 {
1197     ppc4xx_sdram_t *sdram;
1198
1199     sdram = qemu_mallocz(sizeof(ppc4xx_sdram_t));
1200     if (sdram != NULL) {
1201         sdram->irq = irq;
1202         sdram->nbanks = nbanks;
1203         memset(sdram->ram_bases, 0, 4 * sizeof(target_ulong));
1204         memcpy(sdram->ram_bases, ram_bases, nbanks * sizeof(target_ulong));
1205         memset(sdram->ram_sizes, 0, 4 * sizeof(target_ulong));
1206         memcpy(sdram->ram_sizes, ram_sizes, nbanks * sizeof(target_ulong));
1207         sdram_reset(sdram);
1208         qemu_register_reset(&sdram_reset, sdram);
1209         ppc_dcr_register(env, SDRAM0_CFGADDR,
1210                          sdram, &dcr_read_sdram, &dcr_write_sdram);
1211         ppc_dcr_register(env, SDRAM0_CFGDATA,
1212                          sdram, &dcr_read_sdram, &dcr_write_sdram);
1213         if (do_init)
1214             sdram_map_bcr(sdram);
1215     }
1216 }
1217
1218 /*****************************************************************************/
1219 /* Peripheral controller */
1220 typedef struct ppc4xx_ebc_t ppc4xx_ebc_t;
1221 struct ppc4xx_ebc_t {
1222     uint32_t addr;
1223     uint32_t bcr[8];
1224     uint32_t bap[8];
1225     uint32_t bear;
1226     uint32_t besr0;
1227     uint32_t besr1;
1228     uint32_t cfg;
1229 };
1230
1231 enum {
1232     EBC0_CFGADDR = 0x012,
1233     EBC0_CFGDATA = 0x013,
1234 };
1235
1236 static target_ulong dcr_read_ebc (void *opaque, int dcrn)
1237 {
1238     ppc4xx_ebc_t *ebc;
1239     target_ulong ret;
1240
1241     ebc = opaque;
1242     switch (dcrn) {
1243     case EBC0_CFGADDR:
1244         ret = ebc->addr;
1245         break;
1246     case EBC0_CFGDATA:
1247         switch (ebc->addr) {
1248         case 0x00: /* B0CR */
1249             ret = ebc->bcr[0];
1250             break;
1251         case 0x01: /* B1CR */
1252             ret = ebc->bcr[1];
1253             break;
1254         case 0x02: /* B2CR */
1255             ret = ebc->bcr[2];
1256             break;
1257         case 0x03: /* B3CR */
1258             ret = ebc->bcr[3];
1259             break;
1260         case 0x04: /* B4CR */
1261             ret = ebc->bcr[4];
1262             break;
1263         case 0x05: /* B5CR */
1264             ret = ebc->bcr[5];
1265             break;
1266         case 0x06: /* B6CR */
1267             ret = ebc->bcr[6];
1268             break;
1269         case 0x07: /* B7CR */
1270             ret = ebc->bcr[7];
1271             break;
1272         case 0x10: /* B0AP */
1273             ret = ebc->bap[0];
1274             break;
1275         case 0x11: /* B1AP */
1276             ret = ebc->bap[1];
1277             break;
1278         case 0x12: /* B2AP */
1279             ret = ebc->bap[2];
1280             break;
1281         case 0x13: /* B3AP */
1282             ret = ebc->bap[3];
1283             break;
1284         case 0x14: /* B4AP */
1285             ret = ebc->bap[4];
1286             break;
1287         case 0x15: /* B5AP */
1288             ret = ebc->bap[5];
1289             break;
1290         case 0x16: /* B6AP */
1291             ret = ebc->bap[6];
1292             break;
1293         case 0x17: /* B7AP */
1294             ret = ebc->bap[7];
1295             break;
1296         case 0x20: /* BEAR */
1297             ret = ebc->bear;
1298             break;
1299         case 0x21: /* BESR0 */
1300             ret = ebc->besr0;
1301             break;
1302         case 0x22: /* BESR1 */
1303             ret = ebc->besr1;
1304             break;
1305         case 0x23: /* CFG */
1306             ret = ebc->cfg;
1307             break;
1308         default:
1309             ret = 0x00000000;
1310             break;
1311         }
1312     default:
1313         ret = 0x00000000;
1314         break;
1315     }
1316
1317     return ret;
1318 }
1319
1320 static void dcr_write_ebc (void *opaque, int dcrn, target_ulong val)
1321 {
1322     ppc4xx_ebc_t *ebc;
1323
1324     ebc = opaque;
1325     switch (dcrn) {
1326     case EBC0_CFGADDR:
1327         ebc->addr = val;
1328         break;
1329     case EBC0_CFGDATA:
1330         switch (ebc->addr) {
1331         case 0x00: /* B0CR */
1332             break;
1333         case 0x01: /* B1CR */
1334             break;
1335         case 0x02: /* B2CR */
1336             break;
1337         case 0x03: /* B3CR */
1338             break;
1339         case 0x04: /* B4CR */
1340             break;
1341         case 0x05: /* B5CR */
1342             break;
1343         case 0x06: /* B6CR */
1344             break;
1345         case 0x07: /* B7CR */
1346             break;
1347         case 0x10: /* B0AP */
1348             break;
1349         case 0x11: /* B1AP */
1350             break;
1351         case 0x12: /* B2AP */
1352             break;
1353         case 0x13: /* B3AP */
1354             break;
1355         case 0x14: /* B4AP */
1356             break;
1357         case 0x15: /* B5AP */
1358             break;
1359         case 0x16: /* B6AP */
1360             break;
1361         case 0x17: /* B7AP */
1362             break;
1363         case 0x20: /* BEAR */
1364             break;
1365         case 0x21: /* BESR0 */
1366             break;
1367         case 0x22: /* BESR1 */
1368             break;
1369         case 0x23: /* CFG */
1370             break;
1371         default:
1372             break;
1373         }
1374         break;
1375     default:
1376         break;
1377     }
1378 }
1379
1380 static void ebc_reset (void *opaque)
1381 {
1382     ppc4xx_ebc_t *ebc;
1383     int i;
1384
1385     ebc = opaque;
1386     ebc->addr = 0x00000000;
1387     ebc->bap[0] = 0x7F8FFE80;
1388     ebc->bcr[0] = 0xFFE28000;
1389     for (i = 0; i < 8; i++) {
1390         ebc->bap[i] = 0x00000000;
1391         ebc->bcr[i] = 0x00000000;
1392     }
1393     ebc->besr0 = 0x00000000;
1394     ebc->besr1 = 0x00000000;
1395     ebc->cfg = 0x07C00000;
1396 }
1397
1398 void ppc405_ebc_init (CPUState *env)
1399 {
1400     ppc4xx_ebc_t *ebc;
1401
1402     ebc = qemu_mallocz(sizeof(ppc4xx_ebc_t));
1403     if (ebc != NULL) {
1404         ebc_reset(ebc);
1405         qemu_register_reset(&ebc_reset, ebc);
1406         ppc_dcr_register(env, EBC0_CFGADDR,
1407                          ebc, &dcr_read_ebc, &dcr_write_ebc);
1408         ppc_dcr_register(env, EBC0_CFGDATA,
1409                          ebc, &dcr_read_ebc, &dcr_write_ebc);
1410     }
1411 }
1412
1413 /*****************************************************************************/
1414 /* DMA controller */
1415 enum {
1416     DMA0_CR0 = 0x100,
1417     DMA0_CT0 = 0x101,
1418     DMA0_DA0 = 0x102,
1419     DMA0_SA0 = 0x103,
1420     DMA0_SG0 = 0x104,
1421     DMA0_CR1 = 0x108,
1422     DMA0_CT1 = 0x109,
1423     DMA0_DA1 = 0x10A,
1424     DMA0_SA1 = 0x10B,
1425     DMA0_SG1 = 0x10C,
1426     DMA0_CR2 = 0x110,
1427     DMA0_CT2 = 0x111,
1428     DMA0_DA2 = 0x112,
1429     DMA0_SA2 = 0x113,
1430     DMA0_SG2 = 0x114,
1431     DMA0_CR3 = 0x118,
1432     DMA0_CT3 = 0x119,
1433     DMA0_DA3 = 0x11A,
1434     DMA0_SA3 = 0x11B,
1435     DMA0_SG3 = 0x11C,
1436     DMA0_SR  = 0x120,
1437     DMA0_SGC = 0x123,
1438     DMA0_SLP = 0x125,
1439     DMA0_POL = 0x126,
1440 };
1441
1442 typedef struct ppc405_dma_t ppc405_dma_t;
1443 struct ppc405_dma_t {
1444     qemu_irq irqs[4];
1445     uint32_t cr[4];
1446     uint32_t ct[4];
1447     uint32_t da[4];
1448     uint32_t sa[4];
1449     uint32_t sg[4];
1450     uint32_t sr;
1451     uint32_t sgc;
1452     uint32_t slp;
1453     uint32_t pol;
1454 };
1455
1456 static target_ulong dcr_read_dma (void *opaque, int dcrn)
1457 {
1458     ppc405_dma_t *dma;
1459
1460     dma = opaque;
1461
1462     return 0;
1463 }
1464
1465 static void dcr_write_dma (void *opaque, int dcrn, target_ulong val)
1466 {
1467     ppc405_dma_t *dma;
1468
1469     dma = opaque;
1470 }
1471
1472 static void ppc405_dma_reset (void *opaque)
1473 {
1474     ppc405_dma_t *dma;
1475     int i;
1476
1477     dma = opaque;
1478     for (i = 0; i < 4; i++) {
1479         dma->cr[i] = 0x00000000;
1480         dma->ct[i] = 0x00000000;
1481         dma->da[i] = 0x00000000;
1482         dma->sa[i] = 0x00000000;
1483         dma->sg[i] = 0x00000000;
1484     }
1485     dma->sr = 0x00000000;
1486     dma->sgc = 0x00000000;
1487     dma->slp = 0x7C000000;
1488     dma->pol = 0x00000000;
1489 }
1490
1491 void ppc405_dma_init (CPUState *env, qemu_irq irqs[4])
1492 {
1493     ppc405_dma_t *dma;
1494
1495     dma = qemu_mallocz(sizeof(ppc405_dma_t));
1496     if (dma != NULL) {
1497         memcpy(dma->irqs, irqs, 4 * sizeof(qemu_irq));
1498         ppc405_dma_reset(dma);
1499         qemu_register_reset(&ppc405_dma_reset, dma);
1500         ppc_dcr_register(env, DMA0_CR0,
1501                          dma, &dcr_read_dma, &dcr_write_dma);
1502         ppc_dcr_register(env, DMA0_CT0,
1503                          dma, &dcr_read_dma, &dcr_write_dma);
1504         ppc_dcr_register(env, DMA0_DA0,
1505                          dma, &dcr_read_dma, &dcr_write_dma);
1506         ppc_dcr_register(env, DMA0_SA0,
1507                          dma, &dcr_read_dma, &dcr_write_dma);
1508         ppc_dcr_register(env, DMA0_SG0,
1509                          dma, &dcr_read_dma, &dcr_write_dma);
1510         ppc_dcr_register(env, DMA0_CR1,
1511                          dma, &dcr_read_dma, &dcr_write_dma);
1512         ppc_dcr_register(env, DMA0_CT1,
1513                          dma, &dcr_read_dma, &dcr_write_dma);
1514         ppc_dcr_register(env, DMA0_DA1,
1515                          dma, &dcr_read_dma, &dcr_write_dma);
1516         ppc_dcr_register(env, DMA0_SA1,
1517                          dma, &dcr_read_dma, &dcr_write_dma);
1518         ppc_dcr_register(env, DMA0_SG1,
1519                          dma, &dcr_read_dma, &dcr_write_dma);
1520         ppc_dcr_register(env, DMA0_CR2,
1521                          dma, &dcr_read_dma, &dcr_write_dma);
1522         ppc_dcr_register(env, DMA0_CT2,
1523                          dma, &dcr_read_dma, &dcr_write_dma);
1524         ppc_dcr_register(env, DMA0_DA2,
1525                          dma, &dcr_read_dma, &dcr_write_dma);
1526         ppc_dcr_register(env, DMA0_SA2,
1527                          dma, &dcr_read_dma, &dcr_write_dma);
1528         ppc_dcr_register(env, DMA0_SG2,
1529                          dma, &dcr_read_dma, &dcr_write_dma);
1530         ppc_dcr_register(env, DMA0_CR3,
1531                          dma, &dcr_read_dma, &dcr_write_dma);
1532         ppc_dcr_register(env, DMA0_CT3,
1533                          dma, &dcr_read_dma, &dcr_write_dma);
1534         ppc_dcr_register(env, DMA0_DA3,
1535                          dma, &dcr_read_dma, &dcr_write_dma);
1536         ppc_dcr_register(env, DMA0_SA3,
1537                          dma, &dcr_read_dma, &dcr_write_dma);
1538         ppc_dcr_register(env, DMA0_SG3,
1539                          dma, &dcr_read_dma, &dcr_write_dma);
1540         ppc_dcr_register(env, DMA0_SR,
1541                          dma, &dcr_read_dma, &dcr_write_dma);
1542         ppc_dcr_register(env, DMA0_SGC,
1543                          dma, &dcr_read_dma, &dcr_write_dma);
1544         ppc_dcr_register(env, DMA0_SLP,
1545                          dma, &dcr_read_dma, &dcr_write_dma);
1546         ppc_dcr_register(env, DMA0_POL,
1547                          dma, &dcr_read_dma, &dcr_write_dma);
1548     }
1549 }
1550
1551 /*****************************************************************************/
1552 /* GPIO */
1553 typedef struct ppc405_gpio_t ppc405_gpio_t;
1554 struct ppc405_gpio_t {
1555     uint32_t base;
1556     uint32_t or;
1557     uint32_t tcr;
1558     uint32_t osrh;
1559     uint32_t osrl;
1560     uint32_t tsrh;
1561     uint32_t tsrl;
1562     uint32_t odr;
1563     uint32_t ir;
1564     uint32_t rr1;
1565     uint32_t isr1h;
1566     uint32_t isr1l;
1567 };
1568
1569 static uint32_t ppc405_gpio_readb (void *opaque, target_phys_addr_t addr)
1570 {
1571     ppc405_gpio_t *gpio;
1572
1573     gpio = opaque;
1574 #ifdef DEBUG_GPIO
1575     printf("%s: addr " PADDRX "\n", __func__, addr);
1576 #endif
1577
1578     return 0;
1579 }
1580
1581 static void ppc405_gpio_writeb (void *opaque,
1582                                 target_phys_addr_t addr, uint32_t value)
1583 {
1584     ppc405_gpio_t *gpio;
1585
1586     gpio = opaque;
1587 #ifdef DEBUG_GPIO
1588     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
1589 #endif
1590 }
1591
1592 static uint32_t ppc405_gpio_readw (void *opaque, target_phys_addr_t addr)
1593 {
1594     ppc405_gpio_t *gpio;
1595
1596     gpio = opaque;
1597 #ifdef DEBUG_GPIO
1598     printf("%s: addr " PADDRX "\n", __func__, addr);
1599 #endif
1600
1601     return 0;
1602 }
1603
1604 static void ppc405_gpio_writew (void *opaque,
1605                                 target_phys_addr_t addr, uint32_t value)
1606 {
1607     ppc405_gpio_t *gpio;
1608
1609     gpio = opaque;
1610 #ifdef DEBUG_GPIO
1611     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
1612 #endif
1613 }
1614
1615 static uint32_t ppc405_gpio_readl (void *opaque, target_phys_addr_t addr)
1616 {
1617     ppc405_gpio_t *gpio;
1618
1619     gpio = opaque;
1620 #ifdef DEBUG_GPIO
1621     printf("%s: addr " PADDRX "\n", __func__, addr);
1622 #endif
1623
1624     return 0;
1625 }
1626
1627 static void ppc405_gpio_writel (void *opaque,
1628                                 target_phys_addr_t addr, uint32_t value)
1629 {
1630     ppc405_gpio_t *gpio;
1631
1632     gpio = opaque;
1633 #ifdef DEBUG_GPIO
1634     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
1635 #endif
1636 }
1637
1638 static CPUReadMemoryFunc *ppc405_gpio_read[] = {
1639     &ppc405_gpio_readb,
1640     &ppc405_gpio_readw,
1641     &ppc405_gpio_readl,
1642 };
1643
1644 static CPUWriteMemoryFunc *ppc405_gpio_write[] = {
1645     &ppc405_gpio_writeb,
1646     &ppc405_gpio_writew,
1647     &ppc405_gpio_writel,
1648 };
1649
1650 static void ppc405_gpio_reset (void *opaque)
1651 {
1652     ppc405_gpio_t *gpio;
1653
1654     gpio = opaque;
1655 }
1656
1657 void ppc405_gpio_init (CPUState *env, ppc4xx_mmio_t *mmio, uint32_t offset)
1658 {
1659     ppc405_gpio_t *gpio;
1660
1661     gpio = qemu_mallocz(sizeof(ppc405_gpio_t));
1662     if (gpio != NULL) {
1663         gpio->base = mmio->base + offset;
1664         ppc405_gpio_reset(gpio);
1665         qemu_register_reset(&ppc405_gpio_reset, gpio);
1666 #ifdef DEBUG_GPIO
1667         printf("%s: offset=%08x\n", __func__, offset);
1668 #endif
1669         ppc4xx_mmio_register(env, mmio, offset, 0x038,
1670                              ppc405_gpio_read, ppc405_gpio_write, gpio);
1671     }
1672 }
1673
1674 /*****************************************************************************/
1675 /* Serial ports */
1676 static CPUReadMemoryFunc *serial_mm_read[] = {
1677     &serial_mm_readb,
1678     &serial_mm_readw,
1679     &serial_mm_readl,
1680 };
1681
1682 static CPUWriteMemoryFunc *serial_mm_write[] = {
1683     &serial_mm_writeb,
1684     &serial_mm_writew,
1685     &serial_mm_writel,
1686 };
1687
1688 void ppc405_serial_init (CPUState *env, ppc4xx_mmio_t *mmio,
1689                          uint32_t offset, qemu_irq irq,
1690                          CharDriverState *chr)
1691 {
1692     void *serial;
1693
1694 #ifdef DEBUG_SERIAL
1695     printf("%s: offset=%08x\n", __func__, offset);
1696 #endif
1697     serial = serial_mm_init(mmio->base + offset, 0, irq, chr, 0);
1698     ppc4xx_mmio_register(env, mmio, offset, 0x008,
1699                          serial_mm_read, serial_mm_write, serial);
1700 }
1701
1702 /*****************************************************************************/
1703 /* On Chip Memory */
1704 enum {
1705     OCM0_ISARC   = 0x018,
1706     OCM0_ISACNTL = 0x019,
1707     OCM0_DSARC   = 0x01A,
1708     OCM0_DSACNTL = 0x01B,
1709 };
1710
1711 typedef struct ppc405_ocm_t ppc405_ocm_t;
1712 struct ppc405_ocm_t {
1713     target_ulong offset;
1714     uint32_t isarc;
1715     uint32_t isacntl;
1716     uint32_t dsarc;
1717     uint32_t dsacntl;
1718 };
1719
1720 static void ocm_update_mappings (ppc405_ocm_t *ocm,
1721                                  uint32_t isarc, uint32_t isacntl,
1722                                  uint32_t dsarc, uint32_t dsacntl)
1723 {
1724 #ifdef DEBUG_OCM
1725     printf("OCM update ISA %08x %08x (%08x %08x) DSA %08x %08x (%08x %08x)\n",
1726            isarc, isacntl, dsarc, dsacntl,
1727            ocm->isarc, ocm->isacntl, ocm->dsarc, ocm->dsacntl);
1728 #endif
1729     if (ocm->isarc != isarc ||
1730         (ocm->isacntl & 0x80000000) != (isacntl & 0x80000000)) {
1731         if (ocm->isacntl & 0x80000000) {
1732             /* Unmap previously assigned memory region */
1733             printf("OCM unmap ISA %08x\n", ocm->isarc);
1734             cpu_register_physical_memory(ocm->isarc, 0x04000000,
1735                                          IO_MEM_UNASSIGNED);
1736         }
1737         if (isacntl & 0x80000000) {
1738             /* Map new instruction memory region */
1739 #ifdef DEBUG_OCM
1740             printf("OCM map ISA %08x\n", isarc);
1741 #endif
1742             cpu_register_physical_memory(isarc, 0x04000000,
1743                                          ocm->offset | IO_MEM_RAM);
1744         }
1745     }
1746     if (ocm->dsarc != dsarc ||
1747         (ocm->dsacntl & 0x80000000) != (dsacntl & 0x80000000)) {
1748         if (ocm->dsacntl & 0x80000000) {
1749             /* Beware not to unmap the region we just mapped */
1750             if (!(isacntl & 0x80000000) || ocm->dsarc != isarc) {
1751                 /* Unmap previously assigned memory region */
1752 #ifdef DEBUG_OCM
1753                 printf("OCM unmap DSA %08x\n", ocm->dsarc);
1754 #endif
1755                 cpu_register_physical_memory(ocm->dsarc, 0x04000000,
1756                                              IO_MEM_UNASSIGNED);
1757             }
1758         }
1759         if (dsacntl & 0x80000000) {
1760             /* Beware not to remap the region we just mapped */
1761             if (!(isacntl & 0x80000000) || dsarc != isarc) {
1762                 /* Map new data memory region */
1763 #ifdef DEBUG_OCM
1764                 printf("OCM map DSA %08x\n", dsarc);
1765 #endif
1766                 cpu_register_physical_memory(dsarc, 0x04000000,
1767                                              ocm->offset | IO_MEM_RAM);
1768             }
1769         }
1770     }
1771 }
1772
1773 static target_ulong dcr_read_ocm (void *opaque, int dcrn)
1774 {
1775     ppc405_ocm_t *ocm;
1776     target_ulong ret;
1777
1778     ocm = opaque;
1779     switch (dcrn) {
1780     case OCM0_ISARC:
1781         ret = ocm->isarc;
1782         break;
1783     case OCM0_ISACNTL:
1784         ret = ocm->isacntl;
1785         break;
1786     case OCM0_DSARC:
1787         ret = ocm->dsarc;
1788         break;
1789     case OCM0_DSACNTL:
1790         ret = ocm->dsacntl;
1791         break;
1792     default:
1793         ret = 0;
1794         break;
1795     }
1796
1797     return ret;
1798 }
1799
1800 static void dcr_write_ocm (void *opaque, int dcrn, target_ulong val)
1801 {
1802     ppc405_ocm_t *ocm;
1803     uint32_t isarc, dsarc, isacntl, dsacntl;
1804
1805     ocm = opaque;
1806     isarc = ocm->isarc;
1807     dsarc = ocm->dsarc;
1808     isacntl = ocm->isacntl;
1809     dsacntl = ocm->dsacntl;
1810     switch (dcrn) {
1811     case OCM0_ISARC:
1812         isarc = val & 0xFC000000;
1813         break;
1814     case OCM0_ISACNTL:
1815         isacntl = val & 0xC0000000;
1816         break;
1817     case OCM0_DSARC:
1818         isarc = val & 0xFC000000;
1819         break;
1820     case OCM0_DSACNTL:
1821         isacntl = val & 0xC0000000;
1822         break;
1823     }
1824     ocm_update_mappings(ocm, isarc, isacntl, dsarc, dsacntl);
1825     ocm->isarc = isarc;
1826     ocm->dsarc = dsarc;
1827     ocm->isacntl = isacntl;
1828     ocm->dsacntl = dsacntl;
1829 }
1830
1831 static void ocm_reset (void *opaque)
1832 {
1833     ppc405_ocm_t *ocm;
1834     uint32_t isarc, dsarc, isacntl, dsacntl;
1835
1836     ocm = opaque;
1837     isarc = 0x00000000;
1838     isacntl = 0x00000000;
1839     dsarc = 0x00000000;
1840     dsacntl = 0x00000000;
1841     ocm_update_mappings(ocm, isarc, isacntl, dsarc, dsacntl);
1842     ocm->isarc = isarc;
1843     ocm->dsarc = dsarc;
1844     ocm->isacntl = isacntl;
1845     ocm->dsacntl = dsacntl;
1846 }
1847
1848 void ppc405_ocm_init (CPUState *env, unsigned long offset)
1849 {
1850     ppc405_ocm_t *ocm;
1851
1852     ocm = qemu_mallocz(sizeof(ppc405_ocm_t));
1853     if (ocm != NULL) {
1854         ocm->offset = offset;
1855         ocm_reset(ocm);
1856         qemu_register_reset(&ocm_reset, ocm);
1857         ppc_dcr_register(env, OCM0_ISARC,
1858                          ocm, &dcr_read_ocm, &dcr_write_ocm);
1859         ppc_dcr_register(env, OCM0_ISACNTL,
1860                          ocm, &dcr_read_ocm, &dcr_write_ocm);
1861         ppc_dcr_register(env, OCM0_DSARC,
1862                          ocm, &dcr_read_ocm, &dcr_write_ocm);
1863         ppc_dcr_register(env, OCM0_DSACNTL,
1864                          ocm, &dcr_read_ocm, &dcr_write_ocm);
1865     }
1866 }
1867
1868 /*****************************************************************************/
1869 /* I2C controller */
1870 typedef struct ppc4xx_i2c_t ppc4xx_i2c_t;
1871 struct ppc4xx_i2c_t {
1872     uint32_t base;
1873     uint8_t mdata;
1874     uint8_t lmadr;
1875     uint8_t hmadr;
1876     uint8_t cntl;
1877     uint8_t mdcntl;
1878     uint8_t sts;
1879     uint8_t extsts;
1880     uint8_t sdata;
1881     uint8_t lsadr;
1882     uint8_t hsadr;
1883     uint8_t clkdiv;
1884     uint8_t intrmsk;
1885     uint8_t xfrcnt;
1886     uint8_t xtcntlss;
1887     uint8_t directcntl;
1888 };
1889
1890 static uint32_t ppc4xx_i2c_readb (void *opaque, target_phys_addr_t addr)
1891 {
1892     ppc4xx_i2c_t *i2c;
1893     uint32_t ret;
1894
1895 #ifdef DEBUG_I2C
1896     printf("%s: addr " PADDRX "\n", __func__, addr);
1897 #endif
1898     i2c = opaque;
1899     switch (addr - i2c->base) {
1900     case 0x00:
1901         //        i2c_readbyte(&i2c->mdata);
1902         ret = i2c->mdata;
1903         break;
1904     case 0x02:
1905         ret = i2c->sdata;
1906         break;
1907     case 0x04:
1908         ret = i2c->lmadr;
1909         break;
1910     case 0x05:
1911         ret = i2c->hmadr;
1912         break;
1913     case 0x06:
1914         ret = i2c->cntl;
1915         break;
1916     case 0x07:
1917         ret = i2c->mdcntl;
1918         break;
1919     case 0x08:
1920         ret = i2c->sts;
1921         break;
1922     case 0x09:
1923         ret = i2c->extsts;
1924         break;
1925     case 0x0A:
1926         ret = i2c->lsadr;
1927         break;
1928     case 0x0B:
1929         ret = i2c->hsadr;
1930         break;
1931     case 0x0C:
1932         ret = i2c->clkdiv;
1933         break;
1934     case 0x0D:
1935         ret = i2c->intrmsk;
1936         break;
1937     case 0x0E:
1938         ret = i2c->xfrcnt;
1939         break;
1940     case 0x0F:
1941         ret = i2c->xtcntlss;
1942         break;
1943     case 0x10:
1944         ret = i2c->directcntl;
1945         break;
1946     default:
1947         ret = 0x00;
1948         break;
1949     }
1950 #ifdef DEBUG_I2C
1951     printf("%s: addr " PADDRX " %02x\n", __func__, addr, ret);
1952 #endif
1953
1954     return ret;
1955 }
1956
1957 static void ppc4xx_i2c_writeb (void *opaque,
1958                                target_phys_addr_t addr, uint32_t value)
1959 {
1960     ppc4xx_i2c_t *i2c;
1961
1962 #ifdef DEBUG_I2C
1963     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
1964 #endif
1965     i2c = opaque;
1966     switch (addr - i2c->base) {
1967     case 0x00:
1968         i2c->mdata = value;
1969         //        i2c_sendbyte(&i2c->mdata);
1970         break;
1971     case 0x02:
1972         i2c->sdata = value;
1973         break;
1974     case 0x04:
1975         i2c->lmadr = value;
1976         break;
1977     case 0x05:
1978         i2c->hmadr = value;
1979         break;
1980     case 0x06:
1981         i2c->cntl = value;
1982         break;
1983     case 0x07:
1984         i2c->mdcntl = value & 0xDF;
1985         break;
1986     case 0x08:
1987         i2c->sts &= ~(value & 0x0A);
1988         break;
1989     case 0x09:
1990         i2c->extsts &= ~(value & 0x8F);
1991         break;
1992     case 0x0A:
1993         i2c->lsadr = value;
1994         break;
1995     case 0x0B:
1996         i2c->hsadr = value;
1997         break;
1998     case 0x0C:
1999         i2c->clkdiv = value;
2000         break;
2001     case 0x0D:
2002         i2c->intrmsk = value;
2003         break;
2004     case 0x0E:
2005         i2c->xfrcnt = value & 0x77;
2006         break;
2007     case 0x0F:
2008         i2c->xtcntlss = value;
2009         break;
2010     case 0x10:
2011         i2c->directcntl = value & 0x7;
2012         break;
2013     }
2014 }
2015
2016 static uint32_t ppc4xx_i2c_readw (void *opaque, target_phys_addr_t addr)
2017 {
2018     uint32_t ret;
2019
2020 #ifdef DEBUG_I2C
2021     printf("%s: addr " PADDRX "\n", __func__, addr);
2022 #endif
2023     ret = ppc4xx_i2c_readb(opaque, addr) << 8;
2024     ret |= ppc4xx_i2c_readb(opaque, addr + 1);
2025
2026     return ret;
2027 }
2028
2029 static void ppc4xx_i2c_writew (void *opaque,
2030                                target_phys_addr_t addr, uint32_t value)
2031 {
2032 #ifdef DEBUG_I2C
2033     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
2034 #endif
2035     ppc4xx_i2c_writeb(opaque, addr, value >> 8);
2036     ppc4xx_i2c_writeb(opaque, addr + 1, value);
2037 }
2038
2039 static uint32_t ppc4xx_i2c_readl (void *opaque, target_phys_addr_t addr)
2040 {
2041     uint32_t ret;
2042
2043 #ifdef DEBUG_I2C
2044     printf("%s: addr " PADDRX "\n", __func__, addr);
2045 #endif
2046     ret = ppc4xx_i2c_readb(opaque, addr) << 24;
2047     ret |= ppc4xx_i2c_readb(opaque, addr + 1) << 16;
2048     ret |= ppc4xx_i2c_readb(opaque, addr + 2) << 8;
2049     ret |= ppc4xx_i2c_readb(opaque, addr + 3);
2050
2051     return ret;
2052 }
2053
2054 static void ppc4xx_i2c_writel (void *opaque,
2055                                target_phys_addr_t addr, uint32_t value)
2056 {
2057 #ifdef DEBUG_I2C
2058     printf("%s: addr " PADDRX " val %08x\n", __func__, addr, value);
2059 #endif
2060     ppc4xx_i2c_writeb(opaque, addr, value >> 24);
2061     ppc4xx_i2c_writeb(opaque, addr + 1, value >> 16);
2062     ppc4xx_i2c_writeb(opaque, addr + 2, value >> 8);
2063     ppc4xx_i2c_writeb(opaque, addr + 3, value);
2064 }
2065
2066 static CPUReadMemoryFunc *i2c_read[] = {
2067     &ppc4xx_i2c_readb,
2068     &ppc4xx_i2c_readw,
2069     &ppc4xx_i2c_readl,
2070 };
2071
2072 static CPUWriteMemoryFunc *i2c_write[] = {
2073     &ppc4xx_i2c_writeb,
2074     &ppc4xx_i2c_writew,
2075     &ppc4xx_i2c_writel,
2076 };
2077
2078 static void ppc4xx_i2c_reset (void *opaque)
2079 {
2080     ppc4xx_i2c_t *i2c;
2081
2082     i2c = opaque;
2083     i2c->mdata = 0x00;
2084     i2c->sdata = 0x00;
2085     i2c->cntl = 0x00;
2086     i2c->mdcntl = 0x00;
2087     i2c->sts = 0x00;
2088     i2c->extsts = 0x00;
2089     i2c->clkdiv = 0x00;
2090     i2c->xfrcnt = 0x00;
2091     i2c->directcntl = 0x0F;
2092 }
2093
2094 void ppc405_i2c_init (CPUState *env, ppc4xx_mmio_t *mmio, uint32_t offset)
2095 {
2096     ppc4xx_i2c_t *i2c;
2097
2098     i2c = qemu_mallocz(sizeof(ppc4xx_i2c_t));
2099     if (i2c != NULL) {
2100         i2c->base = mmio->base + offset;
2101         ppc4xx_i2c_reset(i2c);
2102 #ifdef DEBUG_I2C
2103         printf("%s: offset=%08x\n", __func__, offset);
2104 #endif
2105         ppc4xx_mmio_register(env, mmio, offset, 0x011,
2106                              i2c_read, i2c_write, i2c);
2107         qemu_register_reset(ppc4xx_i2c_reset, i2c);
2108     }
2109 }
2110
2111 /*****************************************************************************/
2112 /* SPR */
2113 void ppc40x_core_reset (CPUState *env)
2114 {
2115     target_ulong dbsr;
2116
2117     printf("Reset PowerPC core\n");
2118     cpu_ppc_reset(env);
2119     dbsr = env->spr[SPR_40x_DBSR];
2120     dbsr &= ~0x00000300;
2121     dbsr |= 0x00000100;
2122     env->spr[SPR_40x_DBSR] = dbsr;
2123     cpu_loop_exit();
2124 }
2125
2126 void ppc40x_chip_reset (CPUState *env)
2127 {
2128     target_ulong dbsr;
2129
2130     printf("Reset PowerPC chip\n");
2131     cpu_ppc_reset(env);
2132     /* XXX: TODO reset all internal peripherals */
2133     dbsr = env->spr[SPR_40x_DBSR];
2134     dbsr &= ~0x00000300;
2135     dbsr |= 0x00000200;
2136     env->spr[SPR_40x_DBSR] = dbsr;
2137     cpu_loop_exit();
2138 }
2139
2140 void ppc40x_system_reset (CPUState *env)
2141 {
2142     printf("Reset PowerPC system\n");
2143     qemu_system_reset_request();
2144 }
2145
2146 void store_40x_dbcr0 (CPUState *env, uint32_t val)
2147 {
2148     switch ((val >> 28) & 0x3) {
2149     case 0x0:
2150         /* No action */
2151         break;
2152     case 0x1:
2153         /* Core reset */
2154         ppc40x_core_reset(env);
2155         break;
2156     case 0x2:
2157         /* Chip reset */
2158         ppc40x_chip_reset(env);
2159         break;
2160     case 0x3:
2161         /* System reset */
2162         ppc40x_system_reset(env);
2163         break;
2164     }
2165 }
2166
2167 /*****************************************************************************/
2168 /* PowerPC 405CR */
2169 enum {
2170     PPC405CR_CPC0_PLLMR  = 0x0B0,
2171     PPC405CR_CPC0_CR0    = 0x0B1,
2172     PPC405CR_CPC0_CR1    = 0x0B2,
2173     PPC405CR_CPC0_PSR    = 0x0B4,
2174     PPC405CR_CPC0_JTAGID = 0x0B5,
2175     PPC405CR_CPC0_ER     = 0x0B9,
2176     PPC405CR_CPC0_FR     = 0x0BA,
2177     PPC405CR_CPC0_SR     = 0x0BB,
2178 };
2179
2180 enum {
2181     PPC405CR_CPU_CLK   = 0,
2182     PPC405CR_TMR_CLK   = 1,
2183     PPC405CR_PLB_CLK   = 2,
2184     PPC405CR_SDRAM_CLK = 3,
2185     PPC405CR_OPB_CLK   = 4,
2186     PPC405CR_EXT_CLK   = 5,
2187     PPC405CR_UART_CLK  = 6,
2188     PPC405CR_CLK_NB    = 7,
2189 };
2190
2191 typedef struct ppc405cr_cpc_t ppc405cr_cpc_t;
2192 struct ppc405cr_cpc_t {
2193     clk_setup_t clk_setup[PPC405CR_CLK_NB];
2194     uint32_t sysclk;
2195     uint32_t psr;
2196     uint32_t cr0;
2197     uint32_t cr1;
2198     uint32_t jtagid;
2199     uint32_t pllmr;
2200     uint32_t er;
2201     uint32_t fr;
2202 };
2203
2204 static void ppc405cr_clk_setup (ppc405cr_cpc_t *cpc)
2205 {
2206     uint64_t VCO_out, PLL_out;
2207     uint32_t CPU_clk, TMR_clk, SDRAM_clk, PLB_clk, OPB_clk, EXT_clk, UART_clk;
2208     int M, D0, D1, D2;
2209
2210     D0 = ((cpc->pllmr >> 26) & 0x3) + 1; /* CBDV */
2211     if (cpc->pllmr & 0x80000000) {
2212         D1 = (((cpc->pllmr >> 20) - 1) & 0xF) + 1; /* FBDV */
2213         D2 = 8 - ((cpc->pllmr >> 16) & 0x7); /* FWDVA */
2214         M = D0 * D1 * D2;
2215         VCO_out = cpc->sysclk * M;
2216         if (VCO_out < 400000000 || VCO_out > 800000000) {
2217             /* PLL cannot lock */
2218             cpc->pllmr &= ~0x80000000;
2219             goto bypass_pll;
2220         }
2221         PLL_out = VCO_out / D2;
2222     } else {
2223         /* Bypass PLL */
2224     bypass_pll:
2225         M = D0;
2226         PLL_out = cpc->sysclk * M;
2227     }
2228     CPU_clk = PLL_out;
2229     if (cpc->cr1 & 0x00800000)
2230         TMR_clk = cpc->sysclk; /* Should have a separate clock */
2231     else
2232         TMR_clk = CPU_clk;
2233     PLB_clk = CPU_clk / D0;
2234     SDRAM_clk = PLB_clk;
2235     D0 = ((cpc->pllmr >> 10) & 0x3) + 1;
2236     OPB_clk = PLB_clk / D0;
2237     D0 = ((cpc->pllmr >> 24) & 0x3) + 2;
2238     EXT_clk = PLB_clk / D0;
2239     D0 = ((cpc->cr0 >> 1) & 0x1F) + 1;
2240     UART_clk = CPU_clk / D0;
2241     /* Setup CPU clocks */
2242     clk_setup(&cpc->clk_setup[PPC405CR_CPU_CLK], CPU_clk);
2243     /* Setup time-base clock */
2244     clk_setup(&cpc->clk_setup[PPC405CR_TMR_CLK], TMR_clk);
2245     /* Setup PLB clock */
2246     clk_setup(&cpc->clk_setup[PPC405CR_PLB_CLK], PLB_clk);
2247     /* Setup SDRAM clock */
2248     clk_setup(&cpc->clk_setup[PPC405CR_SDRAM_CLK], SDRAM_clk);
2249     /* Setup OPB clock */
2250     clk_setup(&cpc->clk_setup[PPC405CR_OPB_CLK], OPB_clk);
2251     /* Setup external clock */
2252     clk_setup(&cpc->clk_setup[PPC405CR_EXT_CLK], EXT_clk);
2253     /* Setup UART clock */
2254     clk_setup(&cpc->clk_setup[PPC405CR_UART_CLK], UART_clk);
2255 }
2256
2257 static target_ulong dcr_read_crcpc (void *opaque, int dcrn)
2258 {
2259     ppc405cr_cpc_t *cpc;
2260     target_ulong ret;
2261
2262     cpc = opaque;
2263     switch (dcrn) {
2264     case PPC405CR_CPC0_PLLMR:
2265         ret = cpc->pllmr;
2266         break;
2267     case PPC405CR_CPC0_CR0:
2268         ret = cpc->cr0;
2269         break;
2270     case PPC405CR_CPC0_CR1:
2271         ret = cpc->cr1;
2272         break;
2273     case PPC405CR_CPC0_PSR:
2274         ret = cpc->psr;
2275         break;
2276     case PPC405CR_CPC0_JTAGID:
2277         ret = cpc->jtagid;
2278         break;
2279     case PPC405CR_CPC0_ER:
2280         ret = cpc->er;
2281         break;
2282     case PPC405CR_CPC0_FR:
2283         ret = cpc->fr;
2284         break;
2285     case PPC405CR_CPC0_SR:
2286         ret = ~(cpc->er | cpc->fr) & 0xFFFF0000;
2287         break;
2288     default:
2289         /* Avoid gcc warning */
2290         ret = 0;
2291         break;
2292     }
2293
2294     return ret;
2295 }
2296
2297 static void dcr_write_crcpc (void *opaque, int dcrn, target_ulong val)
2298 {
2299     ppc405cr_cpc_t *cpc;
2300
2301     cpc = opaque;
2302     switch (dcrn) {
2303     case PPC405CR_CPC0_PLLMR:
2304         cpc->pllmr = val & 0xFFF77C3F;
2305         break;
2306     case PPC405CR_CPC0_CR0:
2307         cpc->cr0 = val & 0x0FFFFFFE;
2308         break;
2309     case PPC405CR_CPC0_CR1:
2310         cpc->cr1 = val & 0x00800000;
2311         break;
2312     case PPC405CR_CPC0_PSR:
2313         /* Read-only */
2314         break;
2315     case PPC405CR_CPC0_JTAGID:
2316         /* Read-only */
2317         break;
2318     case PPC405CR_CPC0_ER:
2319         cpc->er = val & 0xBFFC0000;
2320         break;
2321     case PPC405CR_CPC0_FR:
2322         cpc->fr = val & 0xBFFC0000;
2323         break;
2324     case PPC405CR_CPC0_SR:
2325         /* Read-only */
2326         break;
2327     }
2328 }
2329
2330 static void ppc405cr_cpc_reset (void *opaque)
2331 {
2332     ppc405cr_cpc_t *cpc;
2333     int D;
2334
2335     cpc = opaque;
2336     /* Compute PLLMR value from PSR settings */
2337     cpc->pllmr = 0x80000000;
2338     /* PFWD */
2339     switch ((cpc->psr >> 30) & 3) {
2340     case 0:
2341         /* Bypass */
2342         cpc->pllmr &= ~0x80000000;
2343         break;
2344     case 1:
2345         /* Divide by 3 */
2346         cpc->pllmr |= 5 << 16;
2347         break;
2348     case 2:
2349         /* Divide by 4 */
2350         cpc->pllmr |= 4 << 16;
2351         break;
2352     case 3:
2353         /* Divide by 6 */
2354         cpc->pllmr |= 2 << 16;
2355         break;
2356     }
2357     /* PFBD */
2358     D = (cpc->psr >> 28) & 3;
2359     cpc->pllmr |= (D + 1) << 20;
2360     /* PT   */
2361     D = (cpc->psr >> 25) & 7;
2362     switch (D) {
2363     case 0x2:
2364         cpc->pllmr |= 0x13;
2365         break;
2366     case 0x4:
2367         cpc->pllmr |= 0x15;
2368         break;
2369     case 0x5:
2370         cpc->pllmr |= 0x16;
2371         break;
2372     default:
2373         break;
2374     }
2375     /* PDC  */
2376     D = (cpc->psr >> 23) & 3;
2377     cpc->pllmr |= D << 26;
2378     /* ODP  */
2379     D = (cpc->psr >> 21) & 3;
2380     cpc->pllmr |= D << 10;
2381     /* EBPD */
2382     D = (cpc->psr >> 17) & 3;
2383     cpc->pllmr |= D << 24;
2384     cpc->cr0 = 0x0000003C;
2385     cpc->cr1 = 0x2B0D8800;
2386     cpc->er = 0x00000000;
2387     cpc->fr = 0x00000000;
2388     ppc405cr_clk_setup(cpc);
2389 }
2390
2391 static void ppc405cr_clk_init (ppc405cr_cpc_t *cpc)
2392 {
2393     int D;
2394
2395     /* XXX: this should be read from IO pins */
2396     cpc->psr = 0x00000000; /* 8 bits ROM */
2397     /* PFWD */
2398     D = 0x2; /* Divide by 4 */
2399     cpc->psr |= D << 30;
2400     /* PFBD */
2401     D = 0x1; /* Divide by 2 */
2402     cpc->psr |= D << 28;
2403     /* PDC */
2404     D = 0x1; /* Divide by 2 */
2405     cpc->psr |= D << 23;
2406     /* PT */
2407     D = 0x5; /* M = 16 */
2408     cpc->psr |= D << 25;
2409     /* ODP */
2410     D = 0x1; /* Divide by 2 */
2411     cpc->psr |= D << 21;
2412     /* EBDP */
2413     D = 0x2; /* Divide by 4 */
2414     cpc->psr |= D << 17;
2415 }
2416
2417 static void ppc405cr_cpc_init (CPUState *env, clk_setup_t clk_setup[7],
2418                                uint32_t sysclk)
2419 {
2420     ppc405cr_cpc_t *cpc;
2421
2422     cpc = qemu_mallocz(sizeof(ppc405cr_cpc_t));
2423     if (cpc != NULL) {
2424         memcpy(cpc->clk_setup, clk_setup,
2425                PPC405CR_CLK_NB * sizeof(clk_setup_t));
2426         cpc->sysclk = sysclk;
2427         cpc->jtagid = 0x42051049;
2428         ppc_dcr_register(env, PPC405CR_CPC0_PSR, cpc,
2429                          &dcr_read_crcpc, &dcr_write_crcpc);
2430         ppc_dcr_register(env, PPC405CR_CPC0_CR0, cpc,
2431                          &dcr_read_crcpc, &dcr_write_crcpc);
2432         ppc_dcr_register(env, PPC405CR_CPC0_CR1, cpc,
2433                          &dcr_read_crcpc, &dcr_write_crcpc);
2434         ppc_dcr_register(env, PPC405CR_CPC0_JTAGID, cpc,
2435                          &dcr_read_crcpc, &dcr_write_crcpc);
2436         ppc_dcr_register(env, PPC405CR_CPC0_PLLMR, cpc,
2437                          &dcr_read_crcpc, &dcr_write_crcpc);
2438         ppc_dcr_register(env, PPC405CR_CPC0_ER, cpc,
2439                          &dcr_read_crcpc, &dcr_write_crcpc);
2440         ppc_dcr_register(env, PPC405CR_CPC0_FR, cpc,
2441                          &dcr_read_crcpc, &dcr_write_crcpc);
2442         ppc_dcr_register(env, PPC405CR_CPC0_SR, cpc,
2443                          &dcr_read_crcpc, &dcr_write_crcpc);
2444         ppc405cr_clk_init(cpc);
2445         qemu_register_reset(ppc405cr_cpc_reset, cpc);
2446         ppc405cr_cpc_reset(cpc);
2447     }
2448 }
2449
2450 CPUState *ppc405cr_init (target_ulong ram_bases[4], target_ulong ram_sizes[4],
2451                          uint32_t sysclk, qemu_irq **picp,
2452                          ram_addr_t *offsetp, int do_init)
2453 {
2454     clk_setup_t clk_setup[PPC405CR_CLK_NB];
2455     qemu_irq dma_irqs[4];
2456     CPUState *env;
2457     ppc4xx_mmio_t *mmio;
2458     qemu_irq *pic, *irqs;
2459     ram_addr_t offset;
2460     int i;
2461
2462     memset(clk_setup, 0, sizeof(clk_setup));
2463     env = ppc405_init("405cr", &clk_setup[PPC405CR_CPU_CLK],
2464                       &clk_setup[PPC405CR_TMR_CLK], sysclk);
2465     /* Memory mapped devices registers */
2466     mmio = ppc4xx_mmio_init(env, 0xEF600000);
2467     /* PLB arbitrer */
2468     ppc4xx_plb_init(env);
2469     /* PLB to OPB bridge */
2470     ppc4xx_pob_init(env);
2471     /* OBP arbitrer */
2472     ppc4xx_opba_init(env, mmio, 0x600);
2473     /* Universal interrupt controller */
2474     irqs = qemu_mallocz(sizeof(qemu_irq) * PPCUIC_OUTPUT_NB);
2475     irqs[PPCUIC_OUTPUT_INT] =
2476         ((qemu_irq *)env->irq_inputs)[PPC405_INPUT_INT];
2477     irqs[PPCUIC_OUTPUT_CINT] =
2478         ((qemu_irq *)env->irq_inputs)[PPC405_INPUT_CINT];
2479     pic = ppcuic_init(env, irqs, 0x0C0, 0, 1);
2480     *picp = pic;
2481     /* SDRAM controller */
2482     ppc405_sdram_init(env, pic[14], 1, ram_bases, ram_sizes, do_init);
2483     offset = 0;
2484     for (i = 0; i < 4; i++)
2485         offset += ram_sizes[i];
2486     /* External bus controller */
2487     ppc405_ebc_init(env);
2488     /* DMA controller */
2489     dma_irqs[0] = pic[26];
2490     dma_irqs[1] = pic[25];
2491     dma_irqs[2] = pic[24];
2492     dma_irqs[3] = pic[23];
2493     ppc405_dma_init(env, dma_irqs);
2494     /* Serial ports */
2495     if (serial_hds[0] != NULL) {
2496         ppc405_serial_init(env, mmio, 0x300, pic[31], serial_hds[0]);
2497     }
2498     if (serial_hds[1] != NULL) {
2499         ppc405_serial_init(env, mmio, 0x400, pic[30], serial_hds[1]);
2500     }
2501     /* IIC controller */
2502     ppc405_i2c_init(env, mmio, 0x500);
2503     /* GPIO */
2504     ppc405_gpio_init(env, mmio, 0x700);
2505     /* CPU control */
2506     ppc405cr_cpc_init(env, clk_setup, sysclk);
2507     *offsetp = offset;
2508
2509     return env;
2510 }
2511
2512 /*****************************************************************************/
2513 /* PowerPC 405EP */
2514 /* CPU control */
2515 enum {
2516     PPC405EP_CPC0_PLLMR0 = 0x0F0,
2517     PPC405EP_CPC0_BOOT   = 0x0F1,
2518     PPC405EP_CPC0_EPCTL  = 0x0F3,
2519     PPC405EP_CPC0_PLLMR1 = 0x0F4,
2520     PPC405EP_CPC0_UCR    = 0x0F5,
2521     PPC405EP_CPC0_SRR    = 0x0F6,
2522     PPC405EP_CPC0_JTAGID = 0x0F7,
2523     PPC405EP_CPC0_PCI    = 0x0F9,
2524 };
2525
2526 enum {
2527     PPC405EP_CPU_CLK   = 0,
2528     PPC405EP_PLB_CLK   = 1,
2529     PPC405EP_OPB_CLK   = 2,
2530     PPC405EP_EBC_CLK   = 3,
2531     PPC405EP_MAL_CLK   = 4,
2532     PPC405EP_PCI_CLK   = 5,
2533     PPC405EP_UART0_CLK = 6,
2534     PPC405EP_UART1_CLK = 7,
2535     PPC405EP_CLK_NB    = 8,
2536 };
2537
2538 typedef struct ppc405ep_cpc_t ppc405ep_cpc_t;
2539 struct ppc405ep_cpc_t {
2540     uint32_t sysclk;
2541     clk_setup_t clk_setup[PPC405EP_CLK_NB];
2542     uint32_t boot;
2543     uint32_t epctl;
2544     uint32_t pllmr[2];
2545     uint32_t ucr;
2546     uint32_t srr;
2547     uint32_t jtagid;
2548     uint32_t pci;
2549 };
2550
2551 static void ppc405ep_compute_clocks (ppc405ep_cpc_t *cpc)
2552 {
2553     uint32_t CPU_clk, PLB_clk, OPB_clk, EBC_clk, MAL_clk, PCI_clk;
2554     uint32_t UART0_clk, UART1_clk;
2555     uint64_t VCO_out, PLL_out;
2556     int M, D;
2557
2558     VCO_out = 0;
2559     if ((cpc->pllmr[1] & 0x80000000) && !(cpc->pllmr[1] & 0x40000000)) {
2560         M = (((cpc->pllmr[1] >> 20) - 1) & 0xF) + 1; /* FBMUL */
2561         //        printf("FBMUL %01x %d\n", (cpc->pllmr[1] >> 20) & 0xF, M);
2562         D = 8 - ((cpc->pllmr[1] >> 16) & 0x7); /* FWDA */
2563         //        printf("FWDA %01x %d\n", (cpc->pllmr[1] >> 16) & 0x7, D);
2564         VCO_out = cpc->sysclk * M * D;
2565         if (VCO_out < 500000000UL || VCO_out > 1000000000UL) {
2566             /* Error - unlock the PLL */
2567             printf("VCO out of range %" PRIu64 "\n", VCO_out);
2568 #if 0
2569             cpc->pllmr[1] &= ~0x80000000;
2570             goto pll_bypass;
2571 #endif
2572         }
2573         PLL_out = VCO_out / D;
2574     } else {
2575 #if 0
2576     pll_bypass:
2577 #endif
2578         PLL_out = cpc->sysclk;
2579     }
2580     /* Now, compute all other clocks */
2581     D = ((cpc->pllmr[0] >> 20) & 0x3) + 1; /* CCDV */
2582 #ifdef DEBUG_CLOCKS
2583     //    printf("CCDV %01x %d\n", (cpc->pllmr[0] >> 20) & 0x3, D);
2584 #endif
2585     CPU_clk = PLL_out / D;
2586     D = ((cpc->pllmr[0] >> 16) & 0x3) + 1; /* CBDV */
2587 #ifdef DEBUG_CLOCKS
2588     //    printf("CBDV %01x %d\n", (cpc->pllmr[0] >> 16) & 0x3, D);
2589 #endif
2590     PLB_clk = CPU_clk / D;
2591     D = ((cpc->pllmr[0] >> 12) & 0x3) + 1; /* OPDV */
2592 #ifdef DEBUG_CLOCKS
2593     //    printf("OPDV %01x %d\n", (cpc->pllmr[0] >> 12) & 0x3, D);
2594 #endif
2595     OPB_clk = PLB_clk / D;
2596     D = ((cpc->pllmr[0] >> 8) & 0x3) + 2; /* EPDV */
2597 #ifdef DEBUG_CLOCKS
2598     //    printf("EPDV %01x %d\n", (cpc->pllmr[0] >> 8) & 0x3, D);
2599 #endif
2600     EBC_clk = PLB_clk / D;
2601     D = ((cpc->pllmr[0] >> 4) & 0x3) + 1; /* MPDV */
2602 #ifdef DEBUG_CLOCKS
2603     //    printf("MPDV %01x %d\n", (cpc->pllmr[0] >> 4) & 0x3, D);
2604 #endif
2605     MAL_clk = PLB_clk / D;
2606     D = (cpc->pllmr[0] & 0x3) + 1; /* PPDV */
2607 #ifdef DEBUG_CLOCKS
2608     //    printf("PPDV %01x %d\n", cpc->pllmr[0] & 0x3, D);
2609 #endif
2610     PCI_clk = PLB_clk / D;
2611     D = ((cpc->ucr - 1) & 0x7F) + 1; /* U0DIV */
2612 #ifdef DEBUG_CLOCKS
2613     //    printf("U0DIV %01x %d\n", cpc->ucr & 0x7F, D);
2614 #endif
2615     UART0_clk = PLL_out / D;
2616     D = (((cpc->ucr >> 8) - 1) & 0x7F) + 1; /* U1DIV */
2617 #ifdef DEBUG_CLOCKS
2618     //    printf("U1DIV %01x %d\n", (cpc->ucr >> 8) & 0x7F, D);
2619 #endif
2620     UART1_clk = PLL_out / D;
2621 #ifdef DEBUG_CLOCKS
2622     printf("Setup PPC405EP clocks - sysclk %d VCO %" PRIu64
2623            " PLL out %" PRIu64 " Hz\n", cpc->sysclk, VCO_out, PLL_out);
2624     printf("CPU %d PLB %d OPB %d EBC %d MAL %d PCI %d UART0 %d UART1 %d\n",
2625            CPU_clk, PLB_clk, OPB_clk, EBC_clk, MAL_clk, PCI_clk,
2626            UART0_clk, UART1_clk);
2627 #endif
2628     /* Setup CPU clocks */
2629     clk_setup(&cpc->clk_setup[PPC405EP_CPU_CLK], CPU_clk);
2630     /* Setup PLB clock */
2631     clk_setup(&cpc->clk_setup[PPC405EP_PLB_CLK], PLB_clk);
2632     /* Setup OPB clock */
2633     clk_setup(&cpc->clk_setup[PPC405EP_OPB_CLK], OPB_clk);
2634     /* Setup external clock */
2635     clk_setup(&cpc->clk_setup[PPC405EP_EBC_CLK], EBC_clk);
2636     /* Setup MAL clock */
2637     clk_setup(&cpc->clk_setup[PPC405EP_MAL_CLK], MAL_clk);
2638     /* Setup PCI clock */
2639     clk_setup(&cpc->clk_setup[PPC405EP_PCI_CLK], PCI_clk);
2640     /* Setup UART0 clock */
2641     clk_setup(&cpc->clk_setup[PPC405EP_UART0_CLK], UART0_clk);
2642     /* Setup UART1 clock */
2643     clk_setup(&cpc->clk_setup[PPC405EP_UART1_CLK], UART1_clk);
2644 }
2645
2646 static target_ulong dcr_read_epcpc (void *opaque, int dcrn)
2647 {
2648     ppc405ep_cpc_t *cpc;
2649     target_ulong ret;
2650
2651     cpc = opaque;
2652     switch (dcrn) {
2653     case PPC405EP_CPC0_BOOT:
2654         ret = cpc->boot;
2655         break;
2656     case PPC405EP_CPC0_EPCTL:
2657         ret = cpc->epctl;
2658         break;
2659     case PPC405EP_CPC0_PLLMR0:
2660         ret = cpc->pllmr[0];
2661         break;
2662     case PPC405EP_CPC0_PLLMR1:
2663         ret = cpc->pllmr[1];
2664         break;
2665     case PPC405EP_CPC0_UCR:
2666         ret = cpc->ucr;
2667         break;
2668     case PPC405EP_CPC0_SRR:
2669         ret = cpc->srr;
2670         break;
2671     case PPC405EP_CPC0_JTAGID:
2672         ret = cpc->jtagid;
2673         break;
2674     case PPC405EP_CPC0_PCI:
2675         ret = cpc->pci;
2676         break;
2677     default:
2678         /* Avoid gcc warning */
2679         ret = 0;
2680         break;
2681     }
2682
2683     return ret;
2684 }
2685
2686 static void dcr_write_epcpc (void *opaque, int dcrn, target_ulong val)
2687 {
2688     ppc405ep_cpc_t *cpc;
2689
2690     cpc = opaque;
2691     switch (dcrn) {
2692     case PPC405EP_CPC0_BOOT:
2693         /* Read-only register */
2694         break;
2695     case PPC405EP_CPC0_EPCTL:
2696         /* Don't care for now */
2697         cpc->epctl = val & 0xC00000F3;
2698         break;
2699     case PPC405EP_CPC0_PLLMR0:
2700         cpc->pllmr[0] = val & 0x00633333;
2701         ppc405ep_compute_clocks(cpc);
2702         break;
2703     case PPC405EP_CPC0_PLLMR1:
2704         cpc->pllmr[1] = val & 0xC0F73FFF;
2705         ppc405ep_compute_clocks(cpc);
2706         break;
2707     case PPC405EP_CPC0_UCR:
2708         /* UART control - don't care for now */
2709         cpc->ucr = val & 0x003F7F7F;
2710         break;
2711     case PPC405EP_CPC0_SRR:
2712         cpc->srr = val;
2713         break;
2714     case PPC405EP_CPC0_JTAGID:
2715         /* Read-only */
2716         break;
2717     case PPC405EP_CPC0_PCI:
2718         cpc->pci = val;
2719         break;
2720     }
2721 }
2722
2723 static void ppc405ep_cpc_reset (void *opaque)
2724 {
2725     ppc405ep_cpc_t *cpc = opaque;
2726
2727     cpc->boot = 0x00000010;     /* Boot from PCI - IIC EEPROM disabled */
2728     cpc->epctl = 0x00000000;
2729     cpc->pllmr[0] = 0x00011010;
2730     cpc->pllmr[1] = 0x40000000;
2731     cpc->ucr = 0x00000000;
2732     cpc->srr = 0x00040000;
2733     cpc->pci = 0x00000000;
2734     ppc405ep_compute_clocks(cpc);
2735 }
2736
2737 /* XXX: sysclk should be between 25 and 100 MHz */
2738 static void ppc405ep_cpc_init (CPUState *env, clk_setup_t clk_setup[8],
2739                                uint32_t sysclk)
2740 {
2741     ppc405ep_cpc_t *cpc;
2742
2743     cpc = qemu_mallocz(sizeof(ppc405ep_cpc_t));
2744     if (cpc != NULL) {
2745         memcpy(cpc->clk_setup, clk_setup,
2746                PPC405EP_CLK_NB * sizeof(clk_setup_t));
2747         cpc->jtagid = 0x20267049;
2748         cpc->sysclk = sysclk;
2749         ppc405ep_cpc_reset(cpc);
2750         qemu_register_reset(&ppc405ep_cpc_reset, cpc);
2751         ppc_dcr_register(env, PPC405EP_CPC0_BOOT, cpc,
2752                          &dcr_read_epcpc, &dcr_write_epcpc);
2753         ppc_dcr_register(env, PPC405EP_CPC0_EPCTL, cpc,
2754                          &dcr_read_epcpc, &dcr_write_epcpc);
2755         ppc_dcr_register(env, PPC405EP_CPC0_PLLMR0, cpc,
2756                          &dcr_read_epcpc, &dcr_write_epcpc);
2757         ppc_dcr_register(env, PPC405EP_CPC0_PLLMR1, cpc,
2758                          &dcr_read_epcpc, &dcr_write_epcpc);
2759         ppc_dcr_register(env, PPC405EP_CPC0_UCR, cpc,
2760                          &dcr_read_epcpc, &dcr_write_epcpc);
2761         ppc_dcr_register(env, PPC405EP_CPC0_SRR, cpc,
2762                          &dcr_read_epcpc, &dcr_write_epcpc);
2763         ppc_dcr_register(env, PPC405EP_CPC0_JTAGID, cpc,
2764                          &dcr_read_epcpc, &dcr_write_epcpc);
2765         ppc_dcr_register(env, PPC405EP_CPC0_PCI, cpc,
2766                          &dcr_read_epcpc, &dcr_write_epcpc);
2767     }
2768 }
2769
2770 CPUState *ppc405ep_init (target_ulong ram_bases[2], target_ulong ram_sizes[2],
2771                          uint32_t sysclk, qemu_irq **picp,
2772                          ram_addr_t *offsetp, int do_init)
2773 {
2774     clk_setup_t clk_setup[PPC405EP_CLK_NB];
2775     qemu_irq dma_irqs[4];
2776     CPUState *env;
2777     ppc4xx_mmio_t *mmio;
2778     qemu_irq *pic, *irqs;
2779     ram_addr_t offset;
2780     int i;
2781
2782     memset(clk_setup, 0, sizeof(clk_setup));
2783     /* init CPUs */
2784     env = ppc405_init("405ep", &clk_setup[PPC405EP_CPU_CLK],
2785                       &clk_setup[PPC405EP_PLB_CLK], sysclk);
2786     /* Internal devices init */
2787     /* Memory mapped devices registers */
2788     mmio = ppc4xx_mmio_init(env, 0xEF600000);
2789     /* PLB arbitrer */
2790     ppc4xx_plb_init(env);
2791     /* PLB to OPB bridge */
2792     ppc4xx_pob_init(env);
2793     /* OBP arbitrer */
2794     ppc4xx_opba_init(env, mmio, 0x600);
2795     /* Universal interrupt controller */
2796     irqs = qemu_mallocz(sizeof(qemu_irq) * PPCUIC_OUTPUT_NB);
2797     irqs[PPCUIC_OUTPUT_INT] =
2798         ((qemu_irq *)env->irq_inputs)[PPC405_INPUT_INT];
2799     irqs[PPCUIC_OUTPUT_CINT] =
2800         ((qemu_irq *)env->irq_inputs)[PPC405_INPUT_CINT];
2801     pic = ppcuic_init(env, irqs, 0x0C0, 0, 1);
2802     *picp = pic;
2803     /* SDRAM controller */
2804     ppc405_sdram_init(env, pic[14], 2, ram_bases, ram_sizes, do_init);
2805     offset = 0;
2806     for (i = 0; i < 2; i++)
2807         offset += ram_sizes[i];
2808     /* External bus controller */
2809     ppc405_ebc_init(env);
2810     /* DMA controller */
2811     dma_irqs[0] = pic[26];
2812     dma_irqs[1] = pic[25];
2813     dma_irqs[2] = pic[24];
2814     dma_irqs[3] = pic[23];
2815     ppc405_dma_init(env, dma_irqs);
2816     /* IIC controller */
2817     ppc405_i2c_init(env, mmio, 0x500);
2818     /* GPIO */
2819     ppc405_gpio_init(env, mmio, 0x700);
2820     /* Serial ports */
2821     if (serial_hds[0] != NULL) {
2822         ppc405_serial_init(env, mmio, 0x300, pic[31], serial_hds[0]);
2823     }
2824     if (serial_hds[1] != NULL) {
2825         ppc405_serial_init(env, mmio, 0x400, pic[30], serial_hds[1]);
2826     }
2827     /* OCM */
2828     ppc405_ocm_init(env, ram_sizes[0] + ram_sizes[1]);
2829     offset += 4096;
2830     /* PCI */
2831     /* CPU control */
2832     ppc405ep_cpc_init(env, clk_setup, sysclk);
2833     *offsetp = offset;
2834
2835     return env;
2836 }