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