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