hw/sun4m.c

   1 /*
   2  * QEMU Sun4m & Sun4d & Sun4c System Emulator
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   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 "sysbus.h"
  25 #include "qemu-timer.h"
  26 #include "sun4m.h"
  27 #include "nvram.h"
  28 #include "sparc32_dma.h"
  29 #include "fdc.h"
  30 #include "sysemu.h"
  31 #include "net.h"
  32 #include "boards.h"
  33 #include "firmware_abi.h"
  34 #include "scsi.h"
  35 #include "pc.h"
  36 #include "isa.h"
  37 #include "fw_cfg.h"
  38 #include "escc.h"
  39
  40 //#define DEBUG_IRQ
  41
  42 /*
  43  * Sun4m architecture was used in the following machines:
  44  *
  45  * SPARCserver 6xxMP/xx
  46  * SPARCclassic (SPARCclassic Server)(SPARCstation LC) (4/15),
  47  * SPARCclassic X (4/10)
  48  * SPARCstation LX/ZX (4/30)
  49  * SPARCstation Voyager
  50  * SPARCstation 10/xx, SPARCserver 10/xx
  51  * SPARCstation 5, SPARCserver 5
  52  * SPARCstation 20/xx, SPARCserver 20
  53  * SPARCstation 4
  54  *
  55  * Sun4d architecture was used in the following machines:
  56  *
  57  * SPARCcenter 2000
  58  * SPARCserver 1000
  59  *
  60  * Sun4c architecture was used in the following machines:
  61  * SPARCstation 1/1+, SPARCserver 1/1+
  62  * SPARCstation SLC
  63  * SPARCstation IPC
  64  * SPARCstation ELC
  65  * SPARCstation IPX
  66  *
  67  * See for example: http://www.sunhelp.org/faq/sunref1.html
  68  */
  69
  70 #ifdef DEBUG_IRQ
  71 #define DPRINTF(fmt, ...)                                       \
  72     do { printf("CPUIRQ: " fmt , ## __VA_ARGS__); } while (0)
  73 #else
  74 #define DPRINTF(fmt, ...)
  75 #endif
  76
  77 #define KERNEL_LOAD_ADDR     0x00004000
  78 #define CMDLINE_ADDR         0x007ff000
  79 #define INITRD_LOAD_ADDR     0x00800000
  80 #define PROM_SIZE_MAX        (1024 * 1024)
  81 #define PROM_VADDR           0xffd00000
  82 #define PROM_FILENAME        "openbios-sparc32"
  83 #define CFG_ADDR             0xd00000510ULL
  84 #define FW_CFG_SUN4M_DEPTH   (FW_CFG_ARCH_LOCAL + 0x00)
  85
  86 #define MAX_CPUS 16
  87 #define MAX_PILS 16
  88
  89 #define ESCC_CLOCK 4915200
  90
  91 struct sun4m_hwdef {
  92     target_phys_addr_t iommu_base, slavio_base;
  93     target_phys_addr_t intctl_base, counter_base, nvram_base, ms_kb_base;
  94     target_phys_addr_t serial_base, fd_base;
  95     target_phys_addr_t idreg_base, dma_base, esp_base, le_base;
  96     target_phys_addr_t tcx_base, cs_base, apc_base, aux1_base, aux2_base;
  97     target_phys_addr_t ecc_base;
  98     uint32_t ecc_version;
  99     long vram_size, nvram_size;
 100     // IRQ numbers are not PIL ones, but master interrupt controller
 101     // register bit numbers
 102     int esp_irq, le_irq, clock_irq, clock1_irq;
 103     int ser_irq, ms_kb_irq, fd_irq, me_irq, cs_irq, ecc_irq;
 104     uint8_t nvram_machine_id;
 105     uint16_t machine_id;
 106     uint32_t iommu_version;
 107     uint32_t intbit_to_level[32];
 108     uint64_t max_mem;
 109     const char * const default_cpu_model;
 110 };
 111
 112 #define MAX_IOUNITS 5
 113
 114 struct sun4d_hwdef {
 115     target_phys_addr_t iounit_bases[MAX_IOUNITS], slavio_base;
 116     target_phys_addr_t counter_base, nvram_base, ms_kb_base;
 117     target_phys_addr_t serial_base;
 118     target_phys_addr_t espdma_base, esp_base;
 119     target_phys_addr_t ledma_base, le_base;
 120     target_phys_addr_t tcx_base;
 121     target_phys_addr_t sbi_base;
 122     unsigned long vram_size, nvram_size;
 123     // IRQ numbers are not PIL ones, but SBI register bit numbers
 124     int esp_irq, le_irq, clock_irq, clock1_irq;
 125     int ser_irq, ms_kb_irq, me_irq;
 126     uint8_t nvram_machine_id;
 127     uint16_t machine_id;
 128     uint32_t iounit_version;
 129     uint64_t max_mem;
 130     const char * const default_cpu_model;
 131 };
 132
 133 struct sun4c_hwdef {
 134     target_phys_addr_t iommu_base, slavio_base;
 135     target_phys_addr_t intctl_base, counter_base, nvram_base, ms_kb_base;
 136     target_phys_addr_t serial_base, fd_base;
 137     target_phys_addr_t idreg_base, dma_base, esp_base, le_base;
 138     target_phys_addr_t tcx_base, aux1_base;
 139     long vram_size, nvram_size;
 140     // IRQ numbers are not PIL ones, but master interrupt controller
 141     // register bit numbers
 142     int esp_irq, le_irq, clock_irq, clock1_irq;
 143     int ser_irq, ms_kb_irq, fd_irq, me_irq;
 144     uint8_t nvram_machine_id;
 145     uint16_t machine_id;
 146     uint32_t iommu_version;
 147     uint32_t intbit_to_level[32];
 148     uint64_t max_mem;
 149     const char * const default_cpu_model;
 150 };
 151
 152 int DMA_get_channel_mode (int nchan)
 153 {
 154     return 0;
 155 }
 156 int DMA_read_memory (int nchan, void *buf, int pos, int size)
 157 {
 158     return 0;
 159 }
 160 int DMA_write_memory (int nchan, void *buf, int pos, int size)
 161 {
 162     return 0;
 163 }
 164 void DMA_hold_DREQ (int nchan) {}
 165 void DMA_release_DREQ (int nchan) {}
 166 void DMA_schedule(int nchan) {}
 167 void DMA_init (int high_page_enable) {}
 168 void DMA_register_channel (int nchan,
 169                            DMA_transfer_handler transfer_handler,
 170                            void *opaque)
 171 {
 172 }
 173
 174 static int fw_cfg_boot_set(void *opaque, const char *boot_device)
 175 {
 176     fw_cfg_add_i16(opaque, FW_CFG_BOOT_DEVICE, boot_device[0]);
 177     return 0;
 178 }
 179
 180 static void nvram_init(m48t59_t *nvram, uint8_t *macaddr, const char *cmdline,
 181                        const char *boot_devices, ram_addr_t RAM_size,
 182                        uint32_t kernel_size,
 183                        int width, int height, int depth,
 184                        int nvram_machine_id, const char *arch)
 185 {
 186     unsigned int i;
 187     uint32_t start, end;
 188     uint8_t image[0x1ff0];
 189     struct OpenBIOS_nvpart_v1 *part_header;
 190
 191     memset(image, '\0', sizeof(image));
 192
 193     start = 0;
 194
 195     // OpenBIOS nvram variables
 196     // Variable partition
 197     part_header = (struct OpenBIOS_nvpart_v1 *)&image[start];
 198     part_header->signature = OPENBIOS_PART_SYSTEM;
 199     pstrcpy(part_header->name, sizeof(part_header->name), "system");
 200
 201     end = start + sizeof(struct OpenBIOS_nvpart_v1);
 202     for (i = 0; i < nb_prom_envs; i++)
 203         end = OpenBIOS_set_var(image, end, prom_envs[i]);
 204
 205     // End marker
 206     image[end++] = '\0';
 207
 208     end = start + ((end - start + 15) & ~15);
 209     OpenBIOS_finish_partition(part_header, end - start);
 210
 211     // free partition
 212     start = end;
 213     part_header = (struct OpenBIOS_nvpart_v1 *)&image[start];
 214     part_header->signature = OPENBIOS_PART_FREE;
 215     pstrcpy(part_header->name, sizeof(part_header->name), "free");
 216
 217     end = 0x1fd0;
 218     OpenBIOS_finish_partition(part_header, end - start);
 219
 220     Sun_init_header((struct Sun_nvram *)&image[0x1fd8], macaddr,
 221                     nvram_machine_id);
 222
 223     for (i = 0; i < sizeof(image); i++)
 224         m48t59_write(nvram, i, image[i]);
 225 }
 226
 227 static void *slavio_intctl;
 228
 229 void pic_info(Monitor *mon)
 230 {
 231     if (slavio_intctl)
 232         slavio_pic_info(mon, slavio_intctl);
 233 }
 234
 235 void irq_info(Monitor *mon)
 236 {
 237     if (slavio_intctl)
 238         slavio_irq_info(mon, slavio_intctl);
 239 }
 240
 241 void cpu_check_irqs(CPUState *env)
 242 {
 243     if (env->pil_in && (env->interrupt_index == 0 ||
 244                         (env->interrupt_index & ~15) == TT_EXTINT)) {
 245         unsigned int i;
 246
 247         for (i = 15; i > 0; i--) {
 248             if (env->pil_in & (1 << i)) {
 249                 int old_interrupt = env->interrupt_index;
 250
 251                 env->interrupt_index = TT_EXTINT | i;
 252                 if (old_interrupt != env->interrupt_index) {
 253                     DPRINTF("Set CPU IRQ %d\n", i);
 254                     cpu_interrupt(env, CPU_INTERRUPT_HARD);
 255                 }
 256                 break;
 257             }
 258         }
 259     } else if (!env->pil_in && (env->interrupt_index & ~15) == TT_EXTINT) {
 260         DPRINTF("Reset CPU IRQ %d\n", env->interrupt_index & 15);
 261         env->interrupt_index = 0;
 262         cpu_reset_interrupt(env, CPU_INTERRUPT_HARD);
 263     }
 264 }
 265
 266 static void cpu_set_irq(void *opaque, int irq, int level)
 267 {
 268     CPUState *env = opaque;
 269
 270     if (level) {
 271         DPRINTF("Raise CPU IRQ %d\n", irq);
 272         env->halted = 0;
 273         env->pil_in |= 1 << irq;
 274         cpu_check_irqs(env);
 275     } else {
 276         DPRINTF("Lower CPU IRQ %d\n", irq);
 277         env->pil_in &= ~(1 << irq);
 278         cpu_check_irqs(env);
 279     }
 280 }
 281
 282 static void dummy_cpu_set_irq(void *opaque, int irq, int level)
 283 {
 284 }
 285
 286 static void *slavio_misc;
 287
 288 void qemu_system_powerdown(void)
 289 {
 290     slavio_set_power_fail(slavio_misc, 1);
 291 }
 292
 293 static void main_cpu_reset(void *opaque)
 294 {
 295     CPUState *env = opaque;
 296
 297     cpu_reset(env);
 298     env->halted = 0;
 299 }
 300
 301 static void secondary_cpu_reset(void *opaque)
 302 {
 303     CPUState *env = opaque;
 304
 305     cpu_reset(env);
 306     env->halted = 1;
 307 }
 308
 309 static void cpu_halt_signal(void *opaque, int irq, int level)
 310 {
 311     if (level && cpu_single_env)
 312         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_HALT);
 313 }
 314
 315 static unsigned long sun4m_load_kernel(const char *kernel_filename,
 316                                        const char *initrd_filename,
 317                                        ram_addr_t RAM_size)
 318 {
 319     int linux_boot;
 320     unsigned int i;
 321     long initrd_size, kernel_size;
 322
 323     linux_boot = (kernel_filename != NULL);
 324
 325     kernel_size = 0;
 326     if (linux_boot) {
 327         kernel_size = load_elf(kernel_filename, -0xf0000000ULL, NULL, NULL,
 328                                NULL);
 329         if (kernel_size < 0)
 330             kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR,
 331                                     RAM_size - KERNEL_LOAD_ADDR);
 332         if (kernel_size < 0)
 333             kernel_size = load_image_targphys(kernel_filename,
 334                                               KERNEL_LOAD_ADDR,
 335                                               RAM_size - KERNEL_LOAD_ADDR);
 336         if (kernel_size < 0) {
 337             fprintf(stderr, "qemu: could not load kernel '%s'\n",
 338                     kernel_filename);
 339             exit(1);
 340         }
 341
 342         /* load initrd */
 343         initrd_size = 0;
 344         if (initrd_filename) {
 345             initrd_size = load_image_targphys(initrd_filename,
 346                                               INITRD_LOAD_ADDR,
 347                                               RAM_size - INITRD_LOAD_ADDR);
 348             if (initrd_size < 0) {
 349                 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
 350                         initrd_filename);
 351                 exit(1);
 352             }
 353         }
 354         if (initrd_size > 0) {
 355             for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
 356                 if (ldl_phys(KERNEL_LOAD_ADDR + i) == 0x48647253) { // HdrS
 357                     stl_phys(KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
 358                     stl_phys(KERNEL_LOAD_ADDR + i + 20, initrd_size);
 359                     break;
 360                 }
 361             }
 362         }
 363     }
 364     return kernel_size;
 365 }
 366
 367 static void lance_init(NICInfo *nd, target_phys_addr_t leaddr,
 368                        void *dma_opaque, qemu_irq irq, qemu_irq *reset)
 369 {
 370     DeviceState *dev;
 371     SysBusDevice *s;
 372
 373     qemu_check_nic_model(&nd_table[0], "lance");
 374
 375     dev = qdev_create(NULL, "lance");
 376     dev->nd = nd;
 377     qdev_prop_set_ptr(dev, "dma", dma_opaque);
 378     qdev_init(dev);
 379     s = sysbus_from_qdev(dev);
 380     sysbus_mmio_map(s, 0, leaddr);
 381     sysbus_connect_irq(s, 0, irq);
 382     *reset = qdev_get_gpio_in(dev, 0);
 383 }
 384
 385 /* NCR89C100/MACIO Internal ID register */
 386 static const uint8_t idreg_data[] = { 0xfe, 0x81, 0x01, 0x03 };
 387
 388 static void idreg_init(target_phys_addr_t addr)
 389 {
 390     DeviceState *dev;
 391     SysBusDevice *s;
 392
 393     dev = qdev_create(NULL, "macio_idreg");
 394     qdev_init(dev);
 395     s = sysbus_from_qdev(dev);
 396
 397     sysbus_mmio_map(s, 0, addr);
 398     cpu_physical_memory_write_rom(addr, idreg_data, sizeof(idreg_data));
 399 }
 400
 401 static void idreg_init1(SysBusDevice *dev)
 402 {
 403     ram_addr_t idreg_offset;
 404
 405     idreg_offset = qemu_ram_alloc(sizeof(idreg_data));
 406     sysbus_init_mmio(dev, sizeof(idreg_data), idreg_offset | IO_MEM_ROM);
 407 }
 408
 409 static SysBusDeviceInfo idreg_info = {
 410     .init = idreg_init1,
 411     .qdev.name  = "macio_idreg",
 412     .qdev.size  = sizeof(SysBusDevice),
 413 };
 414
 415 static void idreg_register_devices(void)
 416 {
 417     sysbus_register_withprop(&idreg_info);
 418 }
 419
 420 device_init(idreg_register_devices);
 421
 422 /* Boot PROM (OpenBIOS) */
 423 static void prom_init(target_phys_addr_t addr, const char *bios_name)
 424 {
 425     DeviceState *dev;
 426     SysBusDevice *s;
 427     char *filename;
 428     int ret;
 429
 430     dev = qdev_create(NULL, "openprom");
 431     qdev_init(dev);
 432     s = sysbus_from_qdev(dev);
 433
 434     sysbus_mmio_map(s, 0, addr);
 435
 436     /* load boot prom */
 437     if (bios_name == NULL) {
 438         bios_name = PROM_FILENAME;
 439     }
 440     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
 441     if (filename) {
 442         ret = load_elf(filename, addr - PROM_VADDR, NULL, NULL, NULL);
 443         if (ret < 0 || ret > PROM_SIZE_MAX) {
 444             ret = load_image_targphys(filename, addr, PROM_SIZE_MAX);
 445         }
 446         qemu_free(filename);
 447     } else {
 448         ret = -1;
 449     }
 450     if (ret < 0 || ret > PROM_SIZE_MAX) {
 451         fprintf(stderr, "qemu: could not load prom '%s'\n", bios_name);
 452         exit(1);
 453     }
 454 }
 455
 456 static void prom_init1(SysBusDevice *dev)
 457 {
 458     ram_addr_t prom_offset;
 459
 460     prom_offset = qemu_ram_alloc(PROM_SIZE_MAX);
 461     sysbus_init_mmio(dev, PROM_SIZE_MAX, prom_offset | IO_MEM_ROM);
 462 }
 463
 464 static SysBusDeviceInfo prom_info = {
 465     .init = prom_init1,
 466     .qdev.name  = "openprom",
 467     .qdev.size  = sizeof(SysBusDevice),
 468     .qdev.props = (Property[]) {
 469         {/* end of property list */}
 470     }
 471 };
 472
 473 static void prom_register_devices(void)
 474 {
 475     sysbus_register_withprop(&prom_info);
 476 }
 477
 478 device_init(prom_register_devices);
 479
 480 typedef struct RamDevice
 481 {
 482     SysBusDevice busdev;
 483     uint64_t size;
 484 } RamDevice;
 485
 486 /* System RAM */
 487 static void ram_init1(SysBusDevice *dev)
 488 {
 489     ram_addr_t RAM_size, ram_offset;
 490     RamDevice *d = FROM_SYSBUS(RamDevice, dev);
 491
 492     RAM_size = d->size;
 493
 494     ram_offset = qemu_ram_alloc(RAM_size);
 495     sysbus_init_mmio(dev, RAM_size, ram_offset);
 496 }
 497
 498 static void ram_init(target_phys_addr_t addr, ram_addr_t RAM_size,
 499                      uint64_t max_mem)
 500 {
 501     DeviceState *dev;
 502     SysBusDevice *s;
 503     RamDevice *d;
 504
 505     /* allocate RAM */
 506     if ((uint64_t)RAM_size > max_mem) {
 507         fprintf(stderr,
 508                 "qemu: Too much memory for this machine: %d, maximum %d\n",
 509                 (unsigned int)(RAM_size / (1024 * 1024)),
 510                 (unsigned int)(max_mem / (1024 * 1024)));
 511         exit(1);
 512     }
 513     dev = qdev_create(NULL, "memory");
 514     s = sysbus_from_qdev(dev);
 515
 516     d = FROM_SYSBUS(RamDevice, s);
 517     d->size = RAM_size;
 518     qdev_init(dev);
 519
 520     sysbus_mmio_map(s, 0, addr);
 521 }
 522
 523 static SysBusDeviceInfo ram_info = {
 524     .init = ram_init1,
 525     .qdev.name  = "memory",
 526     .qdev.size  = sizeof(RamDevice),
 527     .qdev.props = (Property[]) {
 528         {
 529             .name = "size",
 530             .info = &qdev_prop_uint64,
 531             .offset = offsetof(RamDevice, size),
 532         },
 533         {/* end of property list */}
 534     }
 535 };
 536
 537 static void ram_register_devices(void)
 538 {
 539     sysbus_register_withprop(&ram_info);
 540 }
 541
 542 device_init(ram_register_devices);
 543
 544 static CPUState *cpu_devinit(const char *cpu_model, unsigned int id,
 545                              uint64_t prom_addr, qemu_irq **cpu_irqs)
 546 {
 547     CPUState *env;
 548
 549     env = cpu_init(cpu_model);
 550     if (!env) {
 551         fprintf(stderr, "qemu: Unable to find Sparc CPU definition\n");
 552         exit(1);
 553     }
 554
 555     cpu_sparc_set_id(env, id);
 556     if (id == 0) {
 557         qemu_register_reset(main_cpu_reset, env);
 558     } else {
 559         qemu_register_reset(secondary_cpu_reset, env);
 560         env->halted = 1;
 561     }
 562     *cpu_irqs = qemu_allocate_irqs(cpu_set_irq, env, MAX_PILS);
 563     env->prom_addr = prom_addr;
 564
 565     return env;
 566 }
 567
 568 static void sun4m_hw_init(const struct sun4m_hwdef *hwdef, ram_addr_t RAM_size,
 569                           const char *boot_device,
 570                           const char *kernel_filename,
 571                           const char *kernel_cmdline,
 572                           const char *initrd_filename, const char *cpu_model)
 573 {
 574     CPUState *envs[MAX_CPUS];
 575     unsigned int i;
 576     void *iommu, *espdma, *ledma, *nvram;
 577     qemu_irq *cpu_irqs[MAX_CPUS], slavio_irq[32], slavio_cpu_irq[MAX_CPUS],
 578         espdma_irq, ledma_irq;
 579     qemu_irq *esp_reset, *le_reset;
 580     qemu_irq fdc_tc;
 581     qemu_irq *cpu_halt;
 582     unsigned long kernel_size;
 583     BlockDriverState *fd[MAX_FD];
 584     int drive_index;
 585     void *fw_cfg;
 586     DeviceState *dev;
 587
 588     /* init CPUs */
 589     if (!cpu_model)
 590         cpu_model = hwdef->default_cpu_model;
 591
 592     for(i = 0; i < smp_cpus; i++) {
 593         envs[i] = cpu_devinit(cpu_model, i, hwdef->slavio_base, &cpu_irqs[i]);
 594     }
 595
 596     for (i = smp_cpus; i < MAX_CPUS; i++)
 597         cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);
 598
 599
 600     /* set up devices */
 601     ram_init(0, RAM_size, hwdef->max_mem);
 602
 603     prom_init(hwdef->slavio_base, bios_name);
 604
 605     dev = slavio_intctl_init(hwdef->intctl_base,
 606                              hwdef->intctl_base + 0x10000ULL,
 607                              &hwdef->intbit_to_level[0],
 608                              cpu_irqs,
 609                              hwdef->clock_irq);
 610
 611     for (i = 0; i < 32; i++) {
 612         slavio_irq[i] = qdev_get_gpio_in(dev, i);
 613     }
 614     for (i = 0; i < MAX_CPUS; i++) {
 615         slavio_cpu_irq[i] = qdev_get_gpio_in(dev, 32 + i);
 616     }
 617
 618     if (hwdef->idreg_base) {
 619         idreg_init(hwdef->idreg_base);
 620     }
 621
 622     iommu = iommu_init(hwdef->iommu_base, hwdef->iommu_version,
 623                        slavio_irq[hwdef->me_irq]);
 624
 625     espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq],
 626                               iommu, &espdma_irq, &esp_reset);
 627
 628     ledma = sparc32_dma_init(hwdef->dma_base + 16ULL,
 629                              slavio_irq[hwdef->le_irq], iommu, &ledma_irq,
 630                              &le_reset);
 631
 632     if (graphic_depth != 8 && graphic_depth != 24) {
 633         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
 634         exit (1);
 635     }
 636     tcx_init(hwdef->tcx_base, hwdef->vram_size, graphic_width, graphic_height,
 637              graphic_depth);
 638
 639     lance_init(&nd_table[0], hwdef->le_base, ledma, ledma_irq, le_reset);
 640
 641     nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0,
 642                         hwdef->nvram_size, 8);
 643
 644     slavio_timer_init_all(hwdef->counter_base, slavio_irq[hwdef->clock1_irq],
 645                           slavio_cpu_irq, smp_cpus);
 646
 647     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq],
 648                               display_type == DT_NOGRAPHIC, ESCC_CLOCK, 1);
 649     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
 650     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
 651     escc_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq], slavio_irq[hwdef->ser_irq],
 652               serial_hds[0], serial_hds[1], ESCC_CLOCK, 1);
 653
 654     cpu_halt = qemu_allocate_irqs(cpu_halt_signal, NULL, 1);
 655     slavio_misc = slavio_misc_init(hwdef->slavio_base,
 656                                    hwdef->aux1_base, hwdef->aux2_base,
 657                                    slavio_irq[hwdef->me_irq], fdc_tc);
 658     if (hwdef->apc_base) {
 659         apc_init(hwdef->apc_base, cpu_halt[0]);
 660     }
 661
 662     if (hwdef->fd_base) {
 663         /* there is zero or one floppy drive */
 664         memset(fd, 0, sizeof(fd));
 665         drive_index = drive_get_index(IF_FLOPPY, 0, 0);
 666         if (drive_index != -1)
 667             fd[0] = drives_table[drive_index].bdrv;
 668
 669         sun4m_fdctrl_init(slavio_irq[hwdef->fd_irq], hwdef->fd_base, fd,
 670                           &fdc_tc);
 671     }
 672
 673     if (drive_get_max_bus(IF_SCSI) > 0) {
 674         fprintf(stderr, "qemu: too many SCSI bus\n");
 675         exit(1);
 676     }
 677
 678     esp_init(hwdef->esp_base, 2,
 679              espdma_memory_read, espdma_memory_write,
 680              espdma, espdma_irq, esp_reset);
 681
 682     if (hwdef->cs_base) {
 683         sysbus_create_simple("SUNW,CS4231", hwdef->cs_base,
 684                              slavio_irq[hwdef->cs_irq]);
 685     }
 686
 687     kernel_size = sun4m_load_kernel(kernel_filename, initrd_filename,
 688                                     RAM_size);
 689
 690     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
 691                boot_device, RAM_size, kernel_size, graphic_width,
 692                graphic_height, graphic_depth, hwdef->nvram_machine_id,
 693                "Sun4m");
 694
 695     if (hwdef->ecc_base)
 696         ecc_init(hwdef->ecc_base, slavio_irq[hwdef->ecc_irq],
 697                  hwdef->ecc_version);
 698
 699     fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
 700     fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
 701     fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
 702     fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id);
 703     fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_DEPTH, graphic_depth);
 704     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR);
 705     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
 706     if (kernel_cmdline) {
 707         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
 708         pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
 709     } else {
 710         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
 711     }
 712     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR);
 713     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, 0); // not used
 714     fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, boot_device[0]);
 715     qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);
 716 }
 717
 718 enum {
 719     ss2_id = 0,
 720     ss5_id = 32,
 721     vger_id,
 722     lx_id,
 723     ss4_id,
 724     scls_id,
 725     sbook_id,
 726     ss10_id = 64,
 727     ss20_id,
 728     ss600mp_id,
 729     ss1000_id = 96,
 730     ss2000_id,
 731 };
 732
 733 static const struct sun4m_hwdef sun4m_hwdefs[] = {
 734     /* SS-5 */
 735     {
 736         .iommu_base   = 0x10000000,
 737         .tcx_base     = 0x50000000,
 738         .cs_base      = 0x6c000000,
 739         .slavio_base  = 0x70000000,
 740         .ms_kb_base   = 0x71000000,
 741         .serial_base  = 0x71100000,
 742         .nvram_base   = 0x71200000,
 743         .fd_base      = 0x71400000,
 744         .counter_base = 0x71d00000,
 745         .intctl_base  = 0x71e00000,
 746         .idreg_base   = 0x78000000,
 747         .dma_base     = 0x78400000,
 748         .esp_base     = 0x78800000,
 749         .le_base      = 0x78c00000,
 750         .apc_base     = 0x6a000000,
 751         .aux1_base    = 0x71900000,
 752         .aux2_base    = 0x71910000,
 753         .vram_size    = 0x00100000,
 754         .nvram_size   = 0x2000,
 755         .esp_irq = 18,
 756         .le_irq = 16,
 757         .clock_irq = 7,
 758         .clock1_irq = 19,
 759         .ms_kb_irq = 14,
 760         .ser_irq = 15,
 761         .fd_irq = 22,
 762         .me_irq = 30,
 763         .cs_irq = 5,
 764         .nvram_machine_id = 0x80,
 765         .machine_id = ss5_id,
 766         .iommu_version = 0x05000000,
 767         .intbit_to_level = {
 768             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 769             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 770         },
 771         .max_mem = 0x10000000,
 772         .default_cpu_model = "Fujitsu MB86904",
 773     },
 774     /* SS-10 */
 775     {
 776         .iommu_base   = 0xfe0000000ULL,
 777         .tcx_base     = 0xe20000000ULL,
 778         .slavio_base  = 0xff0000000ULL,
 779         .ms_kb_base   = 0xff1000000ULL,
 780         .serial_base  = 0xff1100000ULL,
 781         .nvram_base   = 0xff1200000ULL,
 782         .fd_base      = 0xff1700000ULL,
 783         .counter_base = 0xff1300000ULL,
 784         .intctl_base  = 0xff1400000ULL,
 785         .idreg_base   = 0xef0000000ULL,
 786         .dma_base     = 0xef0400000ULL,
 787         .esp_base     = 0xef0800000ULL,
 788         .le_base      = 0xef0c00000ULL,
 789         .apc_base     = 0xefa000000ULL, // XXX should not exist
 790         .aux1_base    = 0xff1800000ULL,
 791         .aux2_base    = 0xff1a01000ULL,
 792         .ecc_base     = 0xf00000000ULL,
 793         .ecc_version  = 0x10000000, // version 0, implementation 1
 794         .vram_size    = 0x00100000,
 795         .nvram_size   = 0x2000,
 796         .esp_irq = 18,
 797         .le_irq = 16,
 798         .clock_irq = 7,
 799         .clock1_irq = 19,
 800         .ms_kb_irq = 14,
 801         .ser_irq = 15,
 802         .fd_irq = 22,
 803         .me_irq = 30,
 804         .ecc_irq = 28,
 805         .nvram_machine_id = 0x72,
 806         .machine_id = ss10_id,
 807         .iommu_version = 0x03000000,
 808         .intbit_to_level = {
 809             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 810             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 811         },
 812         .max_mem = 0xf00000000ULL,
 813         .default_cpu_model = "TI SuperSparc II",
 814     },
 815     /* SS-600MP */
 816     {
 817         .iommu_base   = 0xfe0000000ULL,
 818         .tcx_base     = 0xe20000000ULL,
 819         .slavio_base  = 0xff0000000ULL,
 820         .ms_kb_base   = 0xff1000000ULL,
 821         .serial_base  = 0xff1100000ULL,
 822         .nvram_base   = 0xff1200000ULL,
 823         .counter_base = 0xff1300000ULL,
 824         .intctl_base  = 0xff1400000ULL,
 825         .dma_base     = 0xef0081000ULL,
 826         .esp_base     = 0xef0080000ULL,
 827         .le_base      = 0xef0060000ULL,
 828         .apc_base     = 0xefa000000ULL, // XXX should not exist
 829         .aux1_base    = 0xff1800000ULL,
 830         .aux2_base    = 0xff1a01000ULL, // XXX should not exist
 831         .ecc_base     = 0xf00000000ULL,
 832         .ecc_version  = 0x00000000, // version 0, implementation 0
 833         .vram_size    = 0x00100000,
 834         .nvram_size   = 0x2000,
 835         .esp_irq = 18,
 836         .le_irq = 16,
 837         .clock_irq = 7,
 838         .clock1_irq = 19,
 839         .ms_kb_irq = 14,
 840         .ser_irq = 15,
 841         .fd_irq = 22,
 842         .me_irq = 30,
 843         .ecc_irq = 28,
 844         .nvram_machine_id = 0x71,
 845         .machine_id = ss600mp_id,
 846         .iommu_version = 0x01000000,
 847         .intbit_to_level = {
 848             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 849             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 850         },
 851         .max_mem = 0xf00000000ULL,
 852         .default_cpu_model = "TI SuperSparc II",
 853     },
 854     /* SS-20 */
 855     {
 856         .iommu_base   = 0xfe0000000ULL,
 857         .tcx_base     = 0xe20000000ULL,
 858         .slavio_base  = 0xff0000000ULL,
 859         .ms_kb_base   = 0xff1000000ULL,
 860         .serial_base  = 0xff1100000ULL,
 861         .nvram_base   = 0xff1200000ULL,
 862         .fd_base      = 0xff1700000ULL,
 863         .counter_base = 0xff1300000ULL,
 864         .intctl_base  = 0xff1400000ULL,
 865         .idreg_base   = 0xef0000000ULL,
 866         .dma_base     = 0xef0400000ULL,
 867         .esp_base     = 0xef0800000ULL,
 868         .le_base      = 0xef0c00000ULL,
 869         .apc_base     = 0xefa000000ULL, // XXX should not exist
 870         .aux1_base    = 0xff1800000ULL,
 871         .aux2_base    = 0xff1a01000ULL,
 872         .ecc_base     = 0xf00000000ULL,
 873         .ecc_version  = 0x20000000, // version 0, implementation 2
 874         .vram_size    = 0x00100000,
 875         .nvram_size   = 0x2000,
 876         .esp_irq = 18,
 877         .le_irq = 16,
 878         .clock_irq = 7,
 879         .clock1_irq = 19,
 880         .ms_kb_irq = 14,
 881         .ser_irq = 15,
 882         .fd_irq = 22,
 883         .me_irq = 30,
 884         .ecc_irq = 28,
 885         .nvram_machine_id = 0x72,
 886         .machine_id = ss20_id,
 887         .iommu_version = 0x13000000,
 888         .intbit_to_level = {
 889             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 890             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 891         },
 892         .max_mem = 0xf00000000ULL,
 893         .default_cpu_model = "TI SuperSparc II",
 894     },
 895     /* Voyager */
 896     {
 897         .iommu_base   = 0x10000000,
 898         .tcx_base     = 0x50000000,
 899         .slavio_base  = 0x70000000,
 900         .ms_kb_base   = 0x71000000,
 901         .serial_base  = 0x71100000,
 902         .nvram_base   = 0x71200000,
 903         .fd_base      = 0x71400000,
 904         .counter_base = 0x71d00000,
 905         .intctl_base  = 0x71e00000,
 906         .idreg_base   = 0x78000000,
 907         .dma_base     = 0x78400000,
 908         .esp_base     = 0x78800000,
 909         .le_base      = 0x78c00000,
 910         .apc_base     = 0x71300000, // pmc
 911         .aux1_base    = 0x71900000,
 912         .aux2_base    = 0x71910000,
 913         .vram_size    = 0x00100000,
 914         .nvram_size   = 0x2000,
 915         .esp_irq = 18,
 916         .le_irq = 16,
 917         .clock_irq = 7,
 918         .clock1_irq = 19,
 919         .ms_kb_irq = 14,
 920         .ser_irq = 15,
 921         .fd_irq = 22,
 922         .me_irq = 30,
 923         .nvram_machine_id = 0x80,
 924         .machine_id = vger_id,
 925         .iommu_version = 0x05000000,
 926         .intbit_to_level = {
 927             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 928             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 929         },
 930         .max_mem = 0x10000000,
 931         .default_cpu_model = "Fujitsu MB86904",
 932     },
 933     /* LX */
 934     {
 935         .iommu_base   = 0x10000000,
 936         .tcx_base     = 0x50000000,
 937         .slavio_base  = 0x70000000,
 938         .ms_kb_base   = 0x71000000,
 939         .serial_base  = 0x71100000,
 940         .nvram_base   = 0x71200000,
 941         .fd_base      = 0x71400000,
 942         .counter_base = 0x71d00000,
 943         .intctl_base  = 0x71e00000,
 944         .idreg_base   = 0x78000000,
 945         .dma_base     = 0x78400000,
 946         .esp_base     = 0x78800000,
 947         .le_base      = 0x78c00000,
 948         .aux1_base    = 0x71900000,
 949         .aux2_base    = 0x71910000,
 950         .vram_size    = 0x00100000,
 951         .nvram_size   = 0x2000,
 952         .esp_irq = 18,
 953         .le_irq = 16,
 954         .clock_irq = 7,
 955         .clock1_irq = 19,
 956         .ms_kb_irq = 14,
 957         .ser_irq = 15,
 958         .fd_irq = 22,
 959         .me_irq = 30,
 960         .nvram_machine_id = 0x80,
 961         .machine_id = lx_id,
 962         .iommu_version = 0x04000000,
 963         .intbit_to_level = {
 964             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 965             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 966         },
 967         .max_mem = 0x10000000,
 968         .default_cpu_model = "TI MicroSparc I",
 969     },
 970     /* SS-4 */
 971     {
 972         .iommu_base   = 0x10000000,
 973         .tcx_base     = 0x50000000,
 974         .cs_base      = 0x6c000000,
 975         .slavio_base  = 0x70000000,
 976         .ms_kb_base   = 0x71000000,
 977         .serial_base  = 0x71100000,
 978         .nvram_base   = 0x71200000,
 979         .fd_base      = 0x71400000,
 980         .counter_base = 0x71d00000,
 981         .intctl_base  = 0x71e00000,
 982         .idreg_base   = 0x78000000,
 983         .dma_base     = 0x78400000,
 984         .esp_base     = 0x78800000,
 985         .le_base      = 0x78c00000,
 986         .apc_base     = 0x6a000000,
 987         .aux1_base    = 0x71900000,
 988         .aux2_base    = 0x71910000,
 989         .vram_size    = 0x00100000,
 990         .nvram_size   = 0x2000,
 991         .esp_irq = 18,
 992         .le_irq = 16,
 993         .clock_irq = 7,
 994         .clock1_irq = 19,
 995         .ms_kb_irq = 14,
 996         .ser_irq = 15,
 997         .fd_irq = 22,
 998         .me_irq = 30,
 999         .cs_irq = 5,
1000         .nvram_machine_id = 0x80,
1001         .machine_id = ss4_id,
1002         .iommu_version = 0x05000000,
1003         .intbit_to_level = {
1004             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
1005             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
1006         },
1007         .max_mem = 0x10000000,
1008         .default_cpu_model = "Fujitsu MB86904",
1009     },
1010     /* SPARCClassic */
1011     {
1012         .iommu_base   = 0x10000000,
1013         .tcx_base     = 0x50000000,
1014         .slavio_base  = 0x70000000,
1015         .ms_kb_base   = 0x71000000,
1016         .serial_base  = 0x71100000,
1017         .nvram_base   = 0x71200000,
1018         .fd_base      = 0x71400000,
1019         .counter_base = 0x71d00000,
1020         .intctl_base  = 0x71e00000,
1021         .idreg_base   = 0x78000000,
1022         .dma_base     = 0x78400000,
1023         .esp_base     = 0x78800000,
1024         .le_base      = 0x78c00000,
1025         .apc_base     = 0x6a000000,
1026         .aux1_base    = 0x71900000,
1027         .aux2_base    = 0x71910000,
1028         .vram_size    = 0x00100000,
1029         .nvram_size   = 0x2000,
1030         .esp_irq = 18,
1031         .le_irq = 16,
1032         .clock_irq = 7,
1033         .clock1_irq = 19,
1034         .ms_kb_irq = 14,
1035         .ser_irq = 15,
1036         .fd_irq = 22,
1037         .me_irq = 30,
1038         .nvram_machine_id = 0x80,
1039         .machine_id = scls_id,
1040         .iommu_version = 0x05000000,
1041         .intbit_to_level = {
1042             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
1043             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
1044         },
1045         .max_mem = 0x10000000,
1046         .default_cpu_model = "TI MicroSparc I",
1047     },
1048     /* SPARCbook */
1049     {
1050         .iommu_base   = 0x10000000,
1051         .tcx_base     = 0x50000000, // XXX
1052         .slavio_base  = 0x70000000,
1053         .ms_kb_base   = 0x71000000,
1054         .serial_base  = 0x71100000,
1055         .nvram_base   = 0x71200000,
1056         .fd_base      = 0x71400000,
1057         .counter_base = 0x71d00000,
1058         .intctl_base  = 0x71e00000,
1059         .idreg_base   = 0x78000000,
1060         .dma_base     = 0x78400000,
1061         .esp_base     = 0x78800000,
1062         .le_base      = 0x78c00000,
1063         .apc_base     = 0x6a000000,
1064         .aux1_base    = 0x71900000,
1065         .aux2_base    = 0x71910000,
1066         .vram_size    = 0x00100000,
1067         .nvram_size   = 0x2000,
1068         .esp_irq = 18,
1069         .le_irq = 16,
1070         .clock_irq = 7,
1071         .clock1_irq = 19,
1072         .ms_kb_irq = 14,
1073         .ser_irq = 15,
1074         .fd_irq = 22,
1075         .me_irq = 30,
1076         .nvram_machine_id = 0x80,
1077         .machine_id = sbook_id,
1078         .iommu_version = 0x05000000,
1079         .intbit_to_level = {
1080             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
1081             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
1082         },
1083         .max_mem = 0x10000000,
1084         .default_cpu_model = "TI MicroSparc I",
1085     },
1086 };
1087
1088 /* SPARCstation 5 hardware initialisation */
1089 static void ss5_init(ram_addr_t RAM_size,
1090                      const char *boot_device,
1091                      const char *kernel_filename, const char *kernel_cmdline,
1092                      const char *initrd_filename, const char *cpu_model)
1093 {
1094     sun4m_hw_init(&sun4m_hwdefs[0], RAM_size, boot_device, kernel_filename,
1095                   kernel_cmdline, initrd_filename, cpu_model);
1096 }
1097
1098 /* SPARCstation 10 hardware initialisation */
1099 static void ss10_init(ram_addr_t RAM_size,
1100                       const char *boot_device,
1101                       const char *kernel_filename, const char *kernel_cmdline,
1102                       const char *initrd_filename, const char *cpu_model)
1103 {
1104     sun4m_hw_init(&sun4m_hwdefs[1], RAM_size, boot_device, kernel_filename,
1105                   kernel_cmdline, initrd_filename, cpu_model);
1106 }
1107
1108 /* SPARCserver 600MP hardware initialisation */
1109 static void ss600mp_init(ram_addr_t RAM_size,
1110                          const char *boot_device,
1111                          const char *kernel_filename,
1112                          const char *kernel_cmdline,
1113                          const char *initrd_filename, const char *cpu_model)
1114 {
1115     sun4m_hw_init(&sun4m_hwdefs[2], RAM_size, boot_device, kernel_filename,
1116                   kernel_cmdline, initrd_filename, cpu_model);
1117 }
1118
1119 /* SPARCstation 20 hardware initialisation */
1120 static void ss20_init(ram_addr_t RAM_size,
1121                       const char *boot_device,
1122                       const char *kernel_filename, const char *kernel_cmdline,
1123                       const char *initrd_filename, const char *cpu_model)
1124 {
1125     sun4m_hw_init(&sun4m_hwdefs[3], RAM_size, boot_device, kernel_filename,
1126                   kernel_cmdline, initrd_filename, cpu_model);
1127 }
1128
1129 /* SPARCstation Voyager hardware initialisation */
1130 static void vger_init(ram_addr_t RAM_size,
1131                       const char *boot_device,
1132                       const char *kernel_filename, const char *kernel_cmdline,
1133                       const char *initrd_filename, const char *cpu_model)
1134 {
1135     sun4m_hw_init(&sun4m_hwdefs[4], RAM_size, boot_device, kernel_filename,
1136                   kernel_cmdline, initrd_filename, cpu_model);
1137 }
1138
1139 /* SPARCstation LX hardware initialisation */
1140 static void ss_lx_init(ram_addr_t RAM_size,
1141                        const char *boot_device,
1142                        const char *kernel_filename, const char *kernel_cmdline,
1143                        const char *initrd_filename, const char *cpu_model)
1144 {
1145     sun4m_hw_init(&sun4m_hwdefs[5], RAM_size, boot_device, kernel_filename,
1146                   kernel_cmdline, initrd_filename, cpu_model);
1147 }
1148
1149 /* SPARCstation 4 hardware initialisation */
1150 static void ss4_init(ram_addr_t RAM_size,
1151                      const char *boot_device,
1152                      const char *kernel_filename, const char *kernel_cmdline,
1153                      const char *initrd_filename, const char *cpu_model)
1154 {
1155     sun4m_hw_init(&sun4m_hwdefs[6], RAM_size, boot_device, kernel_filename,
1156                   kernel_cmdline, initrd_filename, cpu_model);
1157 }
1158
1159 /* SPARCClassic hardware initialisation */
1160 static void scls_init(ram_addr_t RAM_size,
1161                       const char *boot_device,
1162                       const char *kernel_filename, const char *kernel_cmdline,
1163                       const char *initrd_filename, const char *cpu_model)
1164 {
1165     sun4m_hw_init(&sun4m_hwdefs[7], RAM_size, boot_device, kernel_filename,
1166                   kernel_cmdline, initrd_filename, cpu_model);
1167 }
1168
1169 /* SPARCbook hardware initialisation */
1170 static void sbook_init(ram_addr_t RAM_size,
1171                        const char *boot_device,
1172                        const char *kernel_filename, const char *kernel_cmdline,
1173                        const char *initrd_filename, const char *cpu_model)
1174 {
1175     sun4m_hw_init(&sun4m_hwdefs[8], RAM_size, boot_device, kernel_filename,
1176                   kernel_cmdline, initrd_filename, cpu_model);
1177 }
1178
1179 static QEMUMachine ss5_machine = {
1180     .name = "SS-5",
1181     .desc = "Sun4m platform, SPARCstation 5",
1182     .init = ss5_init,
1183     .use_scsi = 1,
1184     .is_default = 1,
1185 };
1186
1187 static QEMUMachine ss10_machine = {
1188     .name = "SS-10",
1189     .desc = "Sun4m platform, SPARCstation 10",
1190     .init = ss10_init,
1191     .use_scsi = 1,
1192     .max_cpus = 4,
1193 };
1194
1195 static QEMUMachine ss600mp_machine = {
1196     .name = "SS-600MP",
1197     .desc = "Sun4m platform, SPARCserver 600MP",
1198     .init = ss600mp_init,
1199     .use_scsi = 1,
1200     .max_cpus = 4,
1201 };
1202
1203 static QEMUMachine ss20_machine = {
1204     .name = "SS-20",
1205     .desc = "Sun4m platform, SPARCstation 20",
1206     .init = ss20_init,
1207     .use_scsi = 1,
1208     .max_cpus = 4,
1209 };
1210
1211 static QEMUMachine voyager_machine = {
1212     .name = "Voyager",
1213     .desc = "Sun4m platform, SPARCstation Voyager",
1214     .init = vger_init,
1215     .use_scsi = 1,
1216 };
1217
1218 static QEMUMachine ss_lx_machine = {
1219     .name = "LX",
1220     .desc = "Sun4m platform, SPARCstation LX",
1221     .init = ss_lx_init,
1222     .use_scsi = 1,
1223 };
1224
1225 static QEMUMachine ss4_machine = {
1226     .name = "SS-4",
1227     .desc = "Sun4m platform, SPARCstation 4",
1228     .init = ss4_init,
1229     .use_scsi = 1,
1230 };
1231
1232 static QEMUMachine scls_machine = {
1233     .name = "SPARCClassic",
1234     .desc = "Sun4m platform, SPARCClassic",
1235     .init = scls_init,
1236     .use_scsi = 1,
1237 };
1238
1239 static QEMUMachine sbook_machine = {
1240     .name = "SPARCbook",
1241     .desc = "Sun4m platform, SPARCbook",
1242     .init = sbook_init,
1243     .use_scsi = 1,
1244 };
1245
1246 static const struct sun4d_hwdef sun4d_hwdefs[] = {
1247     /* SS-1000 */
1248     {
1249         .iounit_bases   = {
1250             0xfe0200000ULL,
1251             0xfe1200000ULL,
1252             0xfe2200000ULL,
1253             0xfe3200000ULL,
1254             -1,
1255         },
1256         .tcx_base     = 0x820000000ULL,
1257         .slavio_base  = 0xf00000000ULL,
1258         .ms_kb_base   = 0xf00240000ULL,
1259         .serial_base  = 0xf00200000ULL,
1260         .nvram_base   = 0xf00280000ULL,
1261         .counter_base = 0xf00300000ULL,
1262         .espdma_base  = 0x800081000ULL,
1263         .esp_base     = 0x800080000ULL,
1264         .ledma_base   = 0x800040000ULL,
1265         .le_base      = 0x800060000ULL,
1266         .sbi_base     = 0xf02800000ULL,
1267         .vram_size    = 0x00100000,
1268         .nvram_size   = 0x2000,
1269         .esp_irq = 3,
1270         .le_irq = 4,
1271         .clock_irq = 14,
1272         .clock1_irq = 10,
1273         .ms_kb_irq = 12,
1274         .ser_irq = 12,
1275         .nvram_machine_id = 0x80,
1276         .machine_id = ss1000_id,
1277         .iounit_version = 0x03000000,
1278         .max_mem = 0xf00000000ULL,
1279         .default_cpu_model = "TI SuperSparc II",
1280     },
1281     /* SS-2000 */
1282     {
1283         .iounit_bases   = {
1284             0xfe0200000ULL,
1285             0xfe1200000ULL,
1286             0xfe2200000ULL,
1287             0xfe3200000ULL,
1288             0xfe4200000ULL,
1289         },
1290         .tcx_base     = 0x820000000ULL,
1291         .slavio_base  = 0xf00000000ULL,
1292         .ms_kb_base   = 0xf00240000ULL,
1293         .serial_base  = 0xf00200000ULL,
1294         .nvram_base   = 0xf00280000ULL,
1295         .counter_base = 0xf00300000ULL,
1296         .espdma_base  = 0x800081000ULL,
1297         .esp_base     = 0x800080000ULL,
1298         .ledma_base   = 0x800040000ULL,
1299         .le_base      = 0x800060000ULL,
1300         .sbi_base     = 0xf02800000ULL,
1301         .vram_size    = 0x00100000,
1302         .nvram_size   = 0x2000,
1303         .esp_irq = 3,
1304         .le_irq = 4,
1305         .clock_irq = 14,
1306         .clock1_irq = 10,
1307         .ms_kb_irq = 12,
1308         .ser_irq = 12,
1309         .nvram_machine_id = 0x80,
1310         .machine_id = ss2000_id,
1311         .iounit_version = 0x03000000,
1312         .max_mem = 0xf00000000ULL,
1313         .default_cpu_model = "TI SuperSparc II",
1314     },
1315 };
1316
1317 static void sun4d_hw_init(const struct sun4d_hwdef *hwdef, ram_addr_t RAM_size,
1318                           const char *boot_device,
1319                           const char *kernel_filename,
1320                           const char *kernel_cmdline,
1321                           const char *initrd_filename, const char *cpu_model)
1322 {
1323     CPUState *envs[MAX_CPUS];
1324     unsigned int i;
1325     void *iounits[MAX_IOUNITS], *espdma, *ledma, *nvram;
1326     qemu_irq *cpu_irqs[MAX_CPUS], sbi_irq[32], sbi_cpu_irq[MAX_CPUS],
1327         espdma_irq, ledma_irq;
1328     qemu_irq *esp_reset, *le_reset;
1329     unsigned long kernel_size;
1330     void *fw_cfg;
1331     DeviceState *dev;
1332
1333     /* init CPUs */
1334     if (!cpu_model)
1335         cpu_model = hwdef->default_cpu_model;
1336
1337     for(i = 0; i < smp_cpus; i++) {
1338         envs[i] = cpu_devinit(cpu_model, i, hwdef->slavio_base, &cpu_irqs[i]);
1339     }
1340
1341     for (i = smp_cpus; i < MAX_CPUS; i++)
1342         cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS);
1343
1344     /* set up devices */
1345     ram_init(0, RAM_size, hwdef->max_mem);
1346
1347     prom_init(hwdef->slavio_base, bios_name);
1348
1349     dev = sbi_init(hwdef->sbi_base, cpu_irqs);
1350
1351     for (i = 0; i < 32; i++) {
1352         sbi_irq[i] = qdev_get_gpio_in(dev, i);
1353     }
1354     for (i = 0; i < MAX_CPUS; i++) {
1355         sbi_cpu_irq[i] = qdev_get_gpio_in(dev, 32 + i);
1356     }
1357
1358     for (i = 0; i < MAX_IOUNITS; i++)
1359         if (hwdef->iounit_bases[i] != (target_phys_addr_t)-1)
1360             iounits[i] = iommu_init(hwdef->iounit_bases[i],
1361                                     hwdef->iounit_version,
1362                                     sbi_irq[hwdef->me_irq]);
1363
1364     espdma = sparc32_dma_init(hwdef->espdma_base, sbi_irq[hwdef->esp_irq],
1365                               iounits[0], &espdma_irq, &esp_reset);
1366
1367     ledma = sparc32_dma_init(hwdef->ledma_base, sbi_irq[hwdef->le_irq],
1368                              iounits[0], &ledma_irq, &le_reset);
1369
1370     if (graphic_depth != 8 && graphic_depth != 24) {
1371         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
1372         exit (1);
1373     }
1374     tcx_init(hwdef->tcx_base, hwdef->vram_size, graphic_width, graphic_height,
1375              graphic_depth);
1376
1377     lance_init(&nd_table[0], hwdef->le_base, ledma, ledma_irq, le_reset);
1378
1379     nvram = m48t59_init(sbi_irq[0], hwdef->nvram_base, 0,
1380                         hwdef->nvram_size, 8);
1381
1382     slavio_timer_init_all(hwdef->counter_base, sbi_irq[hwdef->clock1_irq],
1383                           sbi_cpu_irq, smp_cpus);
1384
1385     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, sbi_irq[hwdef->ms_kb_irq],
1386                               display_type == DT_NOGRAPHIC, ESCC_CLOCK, 1);
1387     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
1388     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
1389     escc_init(hwdef->serial_base, sbi_irq[hwdef->ser_irq], sbi_irq[hwdef->ser_irq],
1390               serial_hds[0], serial_hds[1], ESCC_CLOCK, 1);
1391
1392     if (drive_get_max_bus(IF_SCSI) > 0) {
1393         fprintf(stderr, "qemu: too many SCSI bus\n");
1394         exit(1);
1395     }
1396
1397     esp_init(hwdef->esp_base, 2,
1398              espdma_memory_read, espdma_memory_write,
1399              espdma, espdma_irq, esp_reset);
1400
1401     kernel_size = sun4m_load_kernel(kernel_filename, initrd_filename,
1402                                     RAM_size);
1403
1404     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
1405                boot_device, RAM_size, kernel_size, graphic_width,
1406                graphic_height, graphic_depth, hwdef->nvram_machine_id,
1407                "Sun4d");
1408
1409     fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
1410     fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
1411     fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
1412     fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id);
1413     fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_DEPTH, graphic_depth);
1414     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR);
1415     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
1416     if (kernel_cmdline) {
1417         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
1418         pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1419     } else {
1420         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
1421     }
1422     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR);
1423     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, 0); // not used
1424     fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, boot_device[0]);
1425     qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);
1426 }
1427
1428 /* SPARCserver 1000 hardware initialisation */
1429 static void ss1000_init(ram_addr_t RAM_size,
1430                         const char *boot_device,
1431                         const char *kernel_filename, const char *kernel_cmdline,
1432                         const char *initrd_filename, const char *cpu_model)
1433 {
1434     sun4d_hw_init(&sun4d_hwdefs[0], RAM_size, boot_device, kernel_filename,
1435                   kernel_cmdline, initrd_filename, cpu_model);
1436 }
1437
1438 /* SPARCcenter 2000 hardware initialisation */
1439 static void ss2000_init(ram_addr_t RAM_size,
1440                         const char *boot_device,
1441                         const char *kernel_filename, const char *kernel_cmdline,
1442                         const char *initrd_filename, const char *cpu_model)
1443 {
1444     sun4d_hw_init(&sun4d_hwdefs[1], RAM_size, boot_device, kernel_filename,
1445                   kernel_cmdline, initrd_filename, cpu_model);
1446 }
1447
1448 static QEMUMachine ss1000_machine = {
1449     .name = "SS-1000",
1450     .desc = "Sun4d platform, SPARCserver 1000",
1451     .init = ss1000_init,
1452     .use_scsi = 1,
1453     .max_cpus = 8,
1454 };
1455
1456 static QEMUMachine ss2000_machine = {
1457     .name = "SS-2000",
1458     .desc = "Sun4d platform, SPARCcenter 2000",
1459     .init = ss2000_init,
1460     .use_scsi = 1,
1461     .max_cpus = 20,
1462 };
1463
1464 static const struct sun4c_hwdef sun4c_hwdefs[] = {
1465     /* SS-2 */
1466     {
1467         .iommu_base   = 0xf8000000,
1468         .tcx_base     = 0xfe000000,
1469         .slavio_base  = 0xf6000000,
1470         .intctl_base  = 0xf5000000,
1471         .counter_base = 0xf3000000,
1472         .ms_kb_base   = 0xf0000000,
1473         .serial_base  = 0xf1000000,
1474         .nvram_base   = 0xf2000000,
1475         .fd_base      = 0xf7200000,
1476         .dma_base     = 0xf8400000,
1477         .esp_base     = 0xf8800000,
1478         .le_base      = 0xf8c00000,
1479         .aux1_base    = 0xf7400003,
1480         .vram_size    = 0x00100000,
1481         .nvram_size   = 0x800,
1482         .esp_irq = 2,
1483         .le_irq = 3,
1484         .clock_irq = 5,
1485         .clock1_irq = 7,
1486         .ms_kb_irq = 1,
1487         .ser_irq = 1,
1488         .fd_irq = 1,
1489         .me_irq = 1,
1490         .nvram_machine_id = 0x55,
1491         .machine_id = ss2_id,
1492         .max_mem = 0x10000000,
1493         .default_cpu_model = "Cypress CY7C601",
1494     },
1495 };
1496
1497 static void sun4c_hw_init(const struct sun4c_hwdef *hwdef, ram_addr_t RAM_size,
1498                           const char *boot_device,
1499                           const char *kernel_filename,
1500                           const char *kernel_cmdline,
1501                           const char *initrd_filename, const char *cpu_model)
1502 {
1503     CPUState *env;
1504     void *iommu, *espdma, *ledma, *nvram;
1505     qemu_irq *cpu_irqs, *slavio_irq, espdma_irq, ledma_irq;
1506     qemu_irq *esp_reset, *le_reset;
1507     qemu_irq fdc_tc;
1508     unsigned long kernel_size;
1509     BlockDriverState *fd[MAX_FD];
1510     int drive_index;
1511     void *fw_cfg;
1512
1513     /* init CPU */
1514     if (!cpu_model)
1515         cpu_model = hwdef->default_cpu_model;
1516
1517     env = cpu_devinit(cpu_model, 0, hwdef->slavio_base, &cpu_irqs);
1518
1519     /* set up devices */
1520     ram_init(0, RAM_size, hwdef->max_mem);
1521
1522     prom_init(hwdef->slavio_base, bios_name);
1523
1524     slavio_intctl = sun4c_intctl_init(hwdef->intctl_base,
1525                                       &slavio_irq, cpu_irqs);
1526
1527     iommu = iommu_init(hwdef->iommu_base, hwdef->iommu_version,
1528                        slavio_irq[hwdef->me_irq]);
1529
1530     espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq],
1531                               iommu, &espdma_irq, &esp_reset);
1532
1533     ledma = sparc32_dma_init(hwdef->dma_base + 16ULL,
1534                              slavio_irq[hwdef->le_irq], iommu, &ledma_irq,
1535                              &le_reset);
1536
1537     if (graphic_depth != 8 && graphic_depth != 24) {
1538         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
1539         exit (1);
1540     }
1541     tcx_init(hwdef->tcx_base, hwdef->vram_size, graphic_width, graphic_height,
1542              graphic_depth);
1543
1544     lance_init(&nd_table[0], hwdef->le_base, ledma, ledma_irq, le_reset);
1545
1546     nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0,
1547                         hwdef->nvram_size, 2);
1548
1549     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq],
1550                               display_type == DT_NOGRAPHIC, ESCC_CLOCK, 1);
1551     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
1552     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
1553     escc_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq],
1554               slavio_irq[hwdef->ser_irq], serial_hds[0], serial_hds[1],
1555               ESCC_CLOCK, 1);
1556
1557     slavio_misc = slavio_misc_init(0, hwdef->aux1_base, 0,
1558                                    slavio_irq[hwdef->me_irq], fdc_tc);
1559
1560     if (hwdef->fd_base != (target_phys_addr_t)-1) {
1561         /* there is zero or one floppy drive */
1562         memset(fd, 0, sizeof(fd));
1563         drive_index = drive_get_index(IF_FLOPPY, 0, 0);
1564         if (drive_index != -1)
1565             fd[0] = drives_table[drive_index].bdrv;
1566
1567         sun4m_fdctrl_init(slavio_irq[hwdef->fd_irq], hwdef->fd_base, fd,
1568                           &fdc_tc);
1569     }
1570
1571     if (drive_get_max_bus(IF_SCSI) > 0) {
1572         fprintf(stderr, "qemu: too many SCSI bus\n");
1573         exit(1);
1574     }
1575
1576     esp_init(hwdef->esp_base, 2,
1577              espdma_memory_read, espdma_memory_write,
1578              espdma, espdma_irq, esp_reset);
1579
1580     kernel_size = sun4m_load_kernel(kernel_filename, initrd_filename,
1581                                     RAM_size);
1582
1583     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
1584                boot_device, RAM_size, kernel_size, graphic_width,
1585                graphic_height, graphic_depth, hwdef->nvram_machine_id,
1586                "Sun4c");
1587
1588     fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
1589     fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
1590     fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
1591     fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id);
1592     fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_DEPTH, graphic_depth);
1593     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR);
1594     fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
1595     if (kernel_cmdline) {
1596         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);
1597         pstrcpy_targphys(CMDLINE_ADDR, TARGET_PAGE_SIZE, kernel_cmdline);
1598     } else {
1599         fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
1600     }
1601     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR);
1602     fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, 0); // not used
1603     fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, boot_device[0]);
1604     qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);
1605 }
1606
1607 /* SPARCstation 2 hardware initialisation */
1608 static void ss2_init(ram_addr_t RAM_size,
1609                      const char *boot_device,
1610                      const char *kernel_filename, const char *kernel_cmdline,
1611                      const char *initrd_filename, const char *cpu_model)
1612 {
1613     sun4c_hw_init(&sun4c_hwdefs[0], RAM_size, boot_device, kernel_filename,
1614                   kernel_cmdline, initrd_filename, cpu_model);
1615 }
1616
1617 static QEMUMachine ss2_machine = {
1618     .name = "SS-2",
1619     .desc = "Sun4c platform, SPARCstation 2",
1620     .init = ss2_init,
1621     .use_scsi = 1,
1622 };
1623
1624 static void ss2_machine_init(void)
1625 {
1626     qemu_register_machine(&ss5_machine);
1627     qemu_register_machine(&ss10_machine);
1628     qemu_register_machine(&ss600mp_machine);
1629     qemu_register_machine(&ss20_machine);
1630     qemu_register_machine(&voyager_machine);
1631     qemu_register_machine(&ss_lx_machine);
1632     qemu_register_machine(&ss4_machine);
1633     qemu_register_machine(&scls_machine);
1634     qemu_register_machine(&sbook_machine);
1635     qemu_register_machine(&ss1000_machine);
1636     qemu_register_machine(&ss2000_machine);
1637     qemu_register_machine(&ss2_machine);
1638 }
1639
1640 machine_init(ss2_machine_init);