13475187dSbellard /* 2c7ba218dSblueswir1 * QEMU Sun4u/Sun4v System Emulator 33475187dSbellard * 43475187dSbellard * Copyright (c) 2005 Fabrice Bellard 53475187dSbellard * 63475187dSbellard * Permission is hereby granted, free of charge, to any person obtaining a copy 73475187dSbellard * of this software and associated documentation files (the "Software"), to deal 83475187dSbellard * in the Software without restriction, including without limitation the rights 93475187dSbellard * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 103475187dSbellard * copies of the Software, and to permit persons to whom the Software is 113475187dSbellard * furnished to do so, subject to the following conditions: 123475187dSbellard * 133475187dSbellard * The above copyright notice and this permission notice shall be included in 143475187dSbellard * all copies or substantial portions of the Software. 153475187dSbellard * 163475187dSbellard * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 173475187dSbellard * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 183475187dSbellard * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 193475187dSbellard * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 203475187dSbellard * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 213475187dSbellard * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 223475187dSbellard * THE SOFTWARE. 233475187dSbellard */ 24db5ebe5fSPeter Maydell #include "qemu/osdep.h" 25da34e65cSMarkus Armbruster #include "qapi/error.h" 264771d756SPaolo Bonzini #include "qemu-common.h" 274771d756SPaolo Bonzini #include "cpu.h" 2883c9f4caSPaolo Bonzini #include "hw/hw.h" 2983c9f4caSPaolo Bonzini #include "hw/pci/pci.h" 306864fa38SMark Cave-Ayland #include "hw/pci/pci_bus.h" 310d09e41aSPaolo Bonzini #include "hw/pci-host/apb.h" 320d09e41aSPaolo Bonzini #include "hw/i386/pc.h" 330d09e41aSPaolo Bonzini #include "hw/char/serial.h" 340d09e41aSPaolo Bonzini #include "hw/timer/m48t59.h" 350d09e41aSPaolo Bonzini #include "hw/block/fdc.h" 361422e32dSPaolo Bonzini #include "net/net.h" 371de7afc9SPaolo Bonzini #include "qemu/timer.h" 389c17d615SPaolo Bonzini #include "sysemu/sysemu.h" 3983c9f4caSPaolo Bonzini #include "hw/boards.h" 40c6363baeSThomas Huth #include "hw/nvram/sun_nvram.h" 412024c014SThomas Huth #include "hw/nvram/chrp_nvram.h" 42fff54d22SArtyom Tarasenko #include "hw/sparc/sparc64.h" 430d09e41aSPaolo Bonzini #include "hw/nvram/fw_cfg.h" 4483c9f4caSPaolo Bonzini #include "hw/sysbus.h" 4583c9f4caSPaolo Bonzini #include "hw/ide.h" 466864fa38SMark Cave-Ayland #include "hw/ide/pci.h" 4783c9f4caSPaolo Bonzini #include "hw/loader.h" 48ca20cf32SBlue Swirl #include "elf.h" 49f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 503475187dSbellard 51b430a225SBlue Swirl //#define DEBUG_EBUS 52b430a225SBlue Swirl 53b430a225SBlue Swirl #ifdef DEBUG_EBUS 54b430a225SBlue Swirl #define EBUS_DPRINTF(fmt, ...) \ 55b430a225SBlue Swirl do { printf("EBUS: " fmt , ## __VA_ARGS__); } while (0) 56b430a225SBlue Swirl #else 57b430a225SBlue Swirl #define EBUS_DPRINTF(fmt, ...) 589d926598Sblueswir1 #endif 599d926598Sblueswir1 6083469015Sbellard #define KERNEL_LOAD_ADDR 0x00404000 6183469015Sbellard #define CMDLINE_ADDR 0x003ff000 62ac2e9d66Sblueswir1 #define PROM_SIZE_MAX (4 * 1024 * 1024) 63f19e918dSblueswir1 #define PROM_VADDR 0x000ffd00000ULL 6483469015Sbellard #define APB_SPECIAL_BASE 0x1fe00000000ULL 6583469015Sbellard #define APB_MEM_BASE 0x1ff00000000ULL 66d63baf92SIgor V. Kovalenko #define APB_PCI_IO_BASE (APB_SPECIAL_BASE + 0x02000000ULL) 670986ac3bSbellard #define PROM_FILENAME "openbios-sparc64" 6883469015Sbellard #define NVRAM_SIZE 0x2000 69e4bcb14cSths #define MAX_IDE_BUS 2 703cce6243Sblueswir1 #define BIOS_CFG_IOPORT 0x510 717589690cSBlue Swirl #define FW_CFG_SPARC64_WIDTH (FW_CFG_ARCH_LOCAL + 0x00) 727589690cSBlue Swirl #define FW_CFG_SPARC64_HEIGHT (FW_CFG_ARCH_LOCAL + 0x01) 737589690cSBlue Swirl #define FW_CFG_SPARC64_DEPTH (FW_CFG_ARCH_LOCAL + 0x02) 743475187dSbellard 75852e82f3SArtyom Tarasenko #define IVEC_MAX 0x40 769d926598Sblueswir1 77c7ba218dSblueswir1 struct hwdef { 78905fdcb5Sblueswir1 uint16_t machine_id; 79e87231d4Sblueswir1 uint64_t prom_addr; 80e87231d4Sblueswir1 uint64_t console_serial_base; 81c7ba218dSblueswir1 }; 82c7ba218dSblueswir1 83c5e6fb7eSAvi Kivity typedef struct EbusState { 84ad6856e8SMark Cave-Ayland /*< private >*/ 85ad6856e8SMark Cave-Ayland PCIDevice parent_obj; 86ad6856e8SMark Cave-Ayland 878c40b8d9SMark Cave-Ayland ISABus *isa_bus; 880fe22ffbSMark Cave-Ayland uint64_t console_serial_base; 89c5e6fb7eSAvi Kivity MemoryRegion bar0; 90c5e6fb7eSAvi Kivity MemoryRegion bar1; 91c5e6fb7eSAvi Kivity } EbusState; 92c5e6fb7eSAvi Kivity 93ad6856e8SMark Cave-Ayland #define TYPE_EBUS "ebus" 94ad6856e8SMark Cave-Ayland #define EBUS(obj) OBJECT_CHECK(EbusState, (obj), TYPE_EBUS) 95ad6856e8SMark Cave-Ayland 9657146941SHervé Poussineau void DMA_init(ISABus *bus, int high_page_enable) 974556bd8bSBlue Swirl { 984556bd8bSBlue Swirl } 994556bd8bSBlue Swirl 100ddcd5531SGonglei static void fw_cfg_boot_set(void *opaque, const char *boot_device, 101ddcd5531SGonglei Error **errp) 10281864572Sblueswir1 { 10348779e50SGabriel L. Somlo fw_cfg_modify_i16(opaque, FW_CFG_BOOT_DEVICE, boot_device[0]); 10481864572Sblueswir1 } 10581864572Sblueswir1 10631688246SHervé Poussineau static int sun4u_NVRAM_set_params(Nvram *nvram, uint16_t NVRAM_size, 10743a34704SBlue Swirl const char *arch, ram_addr_t RAM_size, 10877f193daSblueswir1 const char *boot_devices, 10983469015Sbellard uint32_t kernel_image, uint32_t kernel_size, 11083469015Sbellard const char *cmdline, 11183469015Sbellard uint32_t initrd_image, uint32_t initrd_size, 11283469015Sbellard uint32_t NVRAM_image, 1130d31cb99Sblueswir1 int width, int height, int depth, 1140d31cb99Sblueswir1 const uint8_t *macaddr) 1153475187dSbellard { 11666508601Sblueswir1 unsigned int i; 1172024c014SThomas Huth int sysp_end; 118d2c63fc1Sblueswir1 uint8_t image[0x1ff0]; 11931688246SHervé Poussineau NvramClass *k = NVRAM_GET_CLASS(nvram); 1203475187dSbellard 121d2c63fc1Sblueswir1 memset(image, '\0', sizeof(image)); 122d2c63fc1Sblueswir1 1232024c014SThomas Huth /* OpenBIOS nvram variables partition */ 1242024c014SThomas Huth sysp_end = chrp_nvram_create_system_partition(image, 0); 1253475187dSbellard 1262024c014SThomas Huth /* Free space partition */ 1272024c014SThomas Huth chrp_nvram_create_free_partition(&image[sysp_end], 0x1fd0 - sysp_end); 128d2c63fc1Sblueswir1 1290d31cb99Sblueswir1 Sun_init_header((struct Sun_nvram *)&image[0x1fd8], macaddr, 0x80); 1300d31cb99Sblueswir1 13131688246SHervé Poussineau for (i = 0; i < sizeof(image); i++) { 13231688246SHervé Poussineau (k->write)(nvram, i, image[i]); 13331688246SHervé Poussineau } 13466508601Sblueswir1 13583469015Sbellard return 0; 1363475187dSbellard } 1375f2bf0feSBlue Swirl 1385f2bf0feSBlue Swirl static uint64_t sun4u_load_kernel(const char *kernel_filename, 139636aa70aSBlue Swirl const char *initrd_filename, 1405f2bf0feSBlue Swirl ram_addr_t RAM_size, uint64_t *initrd_size, 1415f2bf0feSBlue Swirl uint64_t *initrd_addr, uint64_t *kernel_addr, 1425f2bf0feSBlue Swirl uint64_t *kernel_entry) 143636aa70aSBlue Swirl { 144636aa70aSBlue Swirl int linux_boot; 145636aa70aSBlue Swirl unsigned int i; 146636aa70aSBlue Swirl long kernel_size; 1476908d9ceSBlue Swirl uint8_t *ptr; 1485f2bf0feSBlue Swirl uint64_t kernel_top; 149636aa70aSBlue Swirl 150636aa70aSBlue Swirl linux_boot = (kernel_filename != NULL); 151636aa70aSBlue Swirl 152636aa70aSBlue Swirl kernel_size = 0; 153636aa70aSBlue Swirl if (linux_boot) { 154ca20cf32SBlue Swirl int bswap_needed; 155ca20cf32SBlue Swirl 156ca20cf32SBlue Swirl #ifdef BSWAP_NEEDED 157ca20cf32SBlue Swirl bswap_needed = 1; 158ca20cf32SBlue Swirl #else 159ca20cf32SBlue Swirl bswap_needed = 0; 160ca20cf32SBlue Swirl #endif 1615f2bf0feSBlue Swirl kernel_size = load_elf(kernel_filename, NULL, NULL, kernel_entry, 1627ef295eaSPeter Crosthwaite kernel_addr, &kernel_top, 1, EM_SPARCV9, 0, 0); 1635f2bf0feSBlue Swirl if (kernel_size < 0) { 1645f2bf0feSBlue Swirl *kernel_addr = KERNEL_LOAD_ADDR; 1655f2bf0feSBlue Swirl *kernel_entry = KERNEL_LOAD_ADDR; 166636aa70aSBlue Swirl kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR, 167ca20cf32SBlue Swirl RAM_size - KERNEL_LOAD_ADDR, bswap_needed, 168ca20cf32SBlue Swirl TARGET_PAGE_SIZE); 1695f2bf0feSBlue Swirl } 1705f2bf0feSBlue Swirl if (kernel_size < 0) { 171636aa70aSBlue Swirl kernel_size = load_image_targphys(kernel_filename, 172636aa70aSBlue Swirl KERNEL_LOAD_ADDR, 173636aa70aSBlue Swirl RAM_size - KERNEL_LOAD_ADDR); 1745f2bf0feSBlue Swirl } 175636aa70aSBlue Swirl if (kernel_size < 0) { 176636aa70aSBlue Swirl fprintf(stderr, "qemu: could not load kernel '%s'\n", 177636aa70aSBlue Swirl kernel_filename); 178636aa70aSBlue Swirl exit(1); 179636aa70aSBlue Swirl } 1805f2bf0feSBlue Swirl /* load initrd above kernel */ 181636aa70aSBlue Swirl *initrd_size = 0; 182636aa70aSBlue Swirl if (initrd_filename) { 1835f2bf0feSBlue Swirl *initrd_addr = TARGET_PAGE_ALIGN(kernel_top); 1845f2bf0feSBlue Swirl 185636aa70aSBlue Swirl *initrd_size = load_image_targphys(initrd_filename, 1865f2bf0feSBlue Swirl *initrd_addr, 1875f2bf0feSBlue Swirl RAM_size - *initrd_addr); 1885f2bf0feSBlue Swirl if ((int)*initrd_size < 0) { 189636aa70aSBlue Swirl fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", 190636aa70aSBlue Swirl initrd_filename); 191636aa70aSBlue Swirl exit(1); 192636aa70aSBlue Swirl } 193636aa70aSBlue Swirl } 194636aa70aSBlue Swirl if (*initrd_size > 0) { 195636aa70aSBlue Swirl for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) { 1965f2bf0feSBlue Swirl ptr = rom_ptr(*kernel_addr + i); 1976908d9ceSBlue Swirl if (ldl_p(ptr + 8) == 0x48647253) { /* HdrS */ 1985f2bf0feSBlue Swirl stl_p(ptr + 24, *initrd_addr + *kernel_addr); 1996908d9ceSBlue Swirl stl_p(ptr + 28, *initrd_size); 200636aa70aSBlue Swirl break; 201636aa70aSBlue Swirl } 202636aa70aSBlue Swirl } 203636aa70aSBlue Swirl } 204636aa70aSBlue Swirl } 205636aa70aSBlue Swirl return kernel_size; 206636aa70aSBlue Swirl } 2073475187dSbellard 208e87231d4Sblueswir1 typedef struct ResetData { 209403d7a2dSAndreas Färber SPARCCPU *cpu; 21044a99354SBlue Swirl uint64_t prom_addr; 211e87231d4Sblueswir1 } ResetData; 212e87231d4Sblueswir1 213361dea40SBlue Swirl static void isa_irq_handler(void *opaque, int n, int level) 2141387fe4aSBlue Swirl { 215361dea40SBlue Swirl static const int isa_irq_to_ivec[16] = { 216361dea40SBlue Swirl [1] = 0x29, /* keyboard */ 217361dea40SBlue Swirl [4] = 0x2b, /* serial */ 218361dea40SBlue Swirl [6] = 0x27, /* floppy */ 219361dea40SBlue Swirl [7] = 0x22, /* parallel */ 220361dea40SBlue Swirl [12] = 0x2a, /* mouse */ 221361dea40SBlue Swirl }; 222361dea40SBlue Swirl qemu_irq *irqs = opaque; 223361dea40SBlue Swirl int ivec; 224361dea40SBlue Swirl 2251f6fb58dSPhilippe Mathieu-Daudé assert(n < ARRAY_SIZE(isa_irq_to_ivec)); 226361dea40SBlue Swirl ivec = isa_irq_to_ivec[n]; 227361dea40SBlue Swirl EBUS_DPRINTF("Set ISA IRQ %d level %d -> ivec 0x%x\n", n, level, ivec); 228361dea40SBlue Swirl if (ivec) { 229361dea40SBlue Swirl qemu_set_irq(irqs[ivec], level); 230361dea40SBlue Swirl } 2311387fe4aSBlue Swirl } 2321387fe4aSBlue Swirl 233c190ea07Sblueswir1 /* EBUS (Eight bit bus) bridge */ 234ad6856e8SMark Cave-Ayland static void ebus_realize(PCIDevice *pci_dev, Error **errp) 23553e3c4f9SBlue Swirl { 236ad6856e8SMark Cave-Ayland EbusState *s = EBUS(pci_dev); 237c796eddaSMark Cave-Ayland APBState *apb; 2380fe22ffbSMark Cave-Ayland DeviceState *dev; 239c796eddaSMark Cave-Ayland qemu_irq *isa_irq; 2400fe22ffbSMark Cave-Ayland DriveInfo *fd[MAX_FD]; 2410fe22ffbSMark Cave-Ayland int i; 2420c5b8d83SBlue Swirl 2438c40b8d9SMark Cave-Ayland s->isa_bus = isa_bus_new(DEVICE(pci_dev), get_system_memory(), 2448c40b8d9SMark Cave-Ayland pci_address_space_io(pci_dev), errp); 2458c40b8d9SMark Cave-Ayland if (!s->isa_bus) { 2468c40b8d9SMark Cave-Ayland error_setg(errp, "unable to instantiate EBUS ISA bus"); 247d10e5432SMarkus Armbruster return; 248d10e5432SMarkus Armbruster } 249c190ea07Sblueswir1 250c796eddaSMark Cave-Ayland apb = APB_DEVICE(object_resolve_path_type("", TYPE_APB, NULL)); 251c796eddaSMark Cave-Ayland if (!apb) { 252c796eddaSMark Cave-Ayland error_setg(errp, "unable to locate APB PCI host bridge"); 253c796eddaSMark Cave-Ayland return; 254c796eddaSMark Cave-Ayland } 255c796eddaSMark Cave-Ayland 256c796eddaSMark Cave-Ayland isa_irq = qemu_allocate_irqs(isa_irq_handler, apb->pbm_irqs, 16); 257c796eddaSMark Cave-Ayland isa_bus_irqs(s->isa_bus, isa_irq); 258c796eddaSMark Cave-Ayland 2590fe22ffbSMark Cave-Ayland /* Serial ports */ 2600fe22ffbSMark Cave-Ayland i = 0; 2610fe22ffbSMark Cave-Ayland if (s->console_serial_base) { 2620fe22ffbSMark Cave-Ayland serial_mm_init(pci_address_space(pci_dev), s->console_serial_base, 2630fe22ffbSMark Cave-Ayland 0, NULL, 115200, serial_hds[i], DEVICE_BIG_ENDIAN); 2640fe22ffbSMark Cave-Ayland i++; 2650fe22ffbSMark Cave-Ayland } 2660fe22ffbSMark Cave-Ayland serial_hds_isa_init(s->isa_bus, i, MAX_SERIAL_PORTS); 2670fe22ffbSMark Cave-Ayland 2680fe22ffbSMark Cave-Ayland /* Parallel ports */ 2690fe22ffbSMark Cave-Ayland parallel_hds_isa_init(s->isa_bus, MAX_PARALLEL_PORTS); 2700fe22ffbSMark Cave-Ayland 2710fe22ffbSMark Cave-Ayland /* Keyboard */ 2720fe22ffbSMark Cave-Ayland isa_create_simple(s->isa_bus, "i8042"); 2730fe22ffbSMark Cave-Ayland 2740fe22ffbSMark Cave-Ayland /* Floppy */ 2750fe22ffbSMark Cave-Ayland for (i = 0; i < MAX_FD; i++) { 2760fe22ffbSMark Cave-Ayland fd[i] = drive_get(IF_FLOPPY, 0, i); 2770fe22ffbSMark Cave-Ayland } 2780fe22ffbSMark Cave-Ayland dev = DEVICE(isa_create(s->isa_bus, TYPE_ISA_FDC)); 2790fe22ffbSMark Cave-Ayland if (fd[0]) { 2800fe22ffbSMark Cave-Ayland qdev_prop_set_drive(dev, "driveA", blk_by_legacy_dinfo(fd[0]), 2810fe22ffbSMark Cave-Ayland &error_abort); 2820fe22ffbSMark Cave-Ayland } 2830fe22ffbSMark Cave-Ayland if (fd[1]) { 2840fe22ffbSMark Cave-Ayland qdev_prop_set_drive(dev, "driveB", blk_by_legacy_dinfo(fd[1]), 2850fe22ffbSMark Cave-Ayland &error_abort); 2860fe22ffbSMark Cave-Ayland } 2870fe22ffbSMark Cave-Ayland qdev_prop_set_uint32(dev, "dma", -1); 2880fe22ffbSMark Cave-Ayland qdev_init_nofail(dev); 2890fe22ffbSMark Cave-Ayland 2900fe22ffbSMark Cave-Ayland /* PCI */ 291c5e6fb7eSAvi Kivity pci_dev->config[0x04] = 0x06; // command = bus master, pci mem 292c5e6fb7eSAvi Kivity pci_dev->config[0x05] = 0x00; 293c5e6fb7eSAvi Kivity pci_dev->config[0x06] = 0xa0; // status = fast back-to-back, 66MHz, no error 294c5e6fb7eSAvi Kivity pci_dev->config[0x07] = 0x03; // status = medium devsel 295c5e6fb7eSAvi Kivity pci_dev->config[0x09] = 0x00; // programming i/f 296c5e6fb7eSAvi Kivity pci_dev->config[0x0D] = 0x0a; // latency_timer 297c5e6fb7eSAvi Kivity 2980a70e094SPaolo Bonzini memory_region_init_alias(&s->bar0, OBJECT(s), "bar0", get_system_io(), 2990a70e094SPaolo Bonzini 0, 0x1000000); 300e824b2ccSAvi Kivity pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->bar0); 3010a70e094SPaolo Bonzini memory_region_init_alias(&s->bar1, OBJECT(s), "bar1", get_system_io(), 302f3b18f35SMark Cave-Ayland 0, 0x4000); 303a1cf8be5SMark Cave-Ayland pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &s->bar1); 304c190ea07Sblueswir1 } 305c190ea07Sblueswir1 3060fe22ffbSMark Cave-Ayland static Property ebus_properties[] = { 3070fe22ffbSMark Cave-Ayland DEFINE_PROP_UINT64("console-serial-base", EbusState, 3080fe22ffbSMark Cave-Ayland console_serial_base, 0), 3090fe22ffbSMark Cave-Ayland DEFINE_PROP_END_OF_LIST(), 3100fe22ffbSMark Cave-Ayland }; 3110fe22ffbSMark Cave-Ayland 31240021f08SAnthony Liguori static void ebus_class_init(ObjectClass *klass, void *data) 31340021f08SAnthony Liguori { 31440021f08SAnthony Liguori PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); 3150fe22ffbSMark Cave-Ayland DeviceClass *dc = DEVICE_CLASS(klass); 31640021f08SAnthony Liguori 317ad6856e8SMark Cave-Ayland k->realize = ebus_realize; 31840021f08SAnthony Liguori k->vendor_id = PCI_VENDOR_ID_SUN; 31940021f08SAnthony Liguori k->device_id = PCI_DEVICE_ID_SUN_EBUS; 32040021f08SAnthony Liguori k->revision = 0x01; 32140021f08SAnthony Liguori k->class_id = PCI_CLASS_BRIDGE_OTHER; 3220fe22ffbSMark Cave-Ayland dc->props = ebus_properties; 32340021f08SAnthony Liguori } 32440021f08SAnthony Liguori 3258c43a6f0SAndreas Färber static const TypeInfo ebus_info = { 326ad6856e8SMark Cave-Ayland .name = TYPE_EBUS, 32739bffca2SAnthony Liguori .parent = TYPE_PCI_DEVICE, 32840021f08SAnthony Liguori .class_init = ebus_class_init, 329ad6856e8SMark Cave-Ayland .instance_size = sizeof(EbusState), 330fd3b02c8SEduardo Habkost .interfaces = (InterfaceInfo[]) { 331fd3b02c8SEduardo Habkost { INTERFACE_CONVENTIONAL_PCI_DEVICE }, 332fd3b02c8SEduardo Habkost { }, 333fd3b02c8SEduardo Habkost }, 33453e3c4f9SBlue Swirl }; 33553e3c4f9SBlue Swirl 33613575cf6SAndreas Färber #define TYPE_OPENPROM "openprom" 33713575cf6SAndreas Färber #define OPENPROM(obj) OBJECT_CHECK(PROMState, (obj), TYPE_OPENPROM) 33813575cf6SAndreas Färber 339d4edce38SAvi Kivity typedef struct PROMState { 34013575cf6SAndreas Färber SysBusDevice parent_obj; 34113575cf6SAndreas Färber 342d4edce38SAvi Kivity MemoryRegion prom; 343d4edce38SAvi Kivity } PROMState; 344d4edce38SAvi Kivity 345409dbce5SAurelien Jarno static uint64_t translate_prom_address(void *opaque, uint64_t addr) 346409dbce5SAurelien Jarno { 347a8170e5eSAvi Kivity hwaddr *base_addr = (hwaddr *)opaque; 348409dbce5SAurelien Jarno return addr + *base_addr - PROM_VADDR; 349409dbce5SAurelien Jarno } 350409dbce5SAurelien Jarno 3511baffa46SBlue Swirl /* Boot PROM (OpenBIOS) */ 352a8170e5eSAvi Kivity static void prom_init(hwaddr addr, const char *bios_name) 3531baffa46SBlue Swirl { 3541baffa46SBlue Swirl DeviceState *dev; 3551baffa46SBlue Swirl SysBusDevice *s; 3561baffa46SBlue Swirl char *filename; 3571baffa46SBlue Swirl int ret; 3581baffa46SBlue Swirl 35913575cf6SAndreas Färber dev = qdev_create(NULL, TYPE_OPENPROM); 360e23a1b33SMarkus Armbruster qdev_init_nofail(dev); 3611356b98dSAndreas Färber s = SYS_BUS_DEVICE(dev); 3621baffa46SBlue Swirl 3631baffa46SBlue Swirl sysbus_mmio_map(s, 0, addr); 3641baffa46SBlue Swirl 3651baffa46SBlue Swirl /* load boot prom */ 3661baffa46SBlue Swirl if (bios_name == NULL) { 3671baffa46SBlue Swirl bios_name = PROM_FILENAME; 3681baffa46SBlue Swirl } 3691baffa46SBlue Swirl filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 3701baffa46SBlue Swirl if (filename) { 371409dbce5SAurelien Jarno ret = load_elf(filename, translate_prom_address, &addr, 3727ef295eaSPeter Crosthwaite NULL, NULL, NULL, 1, EM_SPARCV9, 0, 0); 3731baffa46SBlue Swirl if (ret < 0 || ret > PROM_SIZE_MAX) { 3741baffa46SBlue Swirl ret = load_image_targphys(filename, addr, PROM_SIZE_MAX); 3751baffa46SBlue Swirl } 3767267c094SAnthony Liguori g_free(filename); 3771baffa46SBlue Swirl } else { 3781baffa46SBlue Swirl ret = -1; 3791baffa46SBlue Swirl } 3801baffa46SBlue Swirl if (ret < 0 || ret > PROM_SIZE_MAX) { 3811baffa46SBlue Swirl fprintf(stderr, "qemu: could not load prom '%s'\n", bios_name); 3821baffa46SBlue Swirl exit(1); 3831baffa46SBlue Swirl } 3841baffa46SBlue Swirl } 3851baffa46SBlue Swirl 38678fb261dSxiaoqiang zhao static void prom_init1(Object *obj) 3871baffa46SBlue Swirl { 38878fb261dSxiaoqiang zhao PROMState *s = OPENPROM(obj); 38978fb261dSxiaoqiang zhao SysBusDevice *dev = SYS_BUS_DEVICE(obj); 3901baffa46SBlue Swirl 3911cfe48c1SPeter Maydell memory_region_init_ram_nomigrate(&s->prom, obj, "sun4u.prom", PROM_SIZE_MAX, 392f8ed85acSMarkus Armbruster &error_fatal); 393c5705a77SAvi Kivity vmstate_register_ram_global(&s->prom); 394d4edce38SAvi Kivity memory_region_set_readonly(&s->prom, true); 395750ecd44SAvi Kivity sysbus_init_mmio(dev, &s->prom); 3961baffa46SBlue Swirl } 3971baffa46SBlue Swirl 398999e12bbSAnthony Liguori static Property prom_properties[] = { 399999e12bbSAnthony Liguori {/* end of property list */}, 400999e12bbSAnthony Liguori }; 401999e12bbSAnthony Liguori 402999e12bbSAnthony Liguori static void prom_class_init(ObjectClass *klass, void *data) 403999e12bbSAnthony Liguori { 40439bffca2SAnthony Liguori DeviceClass *dc = DEVICE_CLASS(klass); 405999e12bbSAnthony Liguori 40639bffca2SAnthony Liguori dc->props = prom_properties; 4071baffa46SBlue Swirl } 408999e12bbSAnthony Liguori 4098c43a6f0SAndreas Färber static const TypeInfo prom_info = { 41013575cf6SAndreas Färber .name = TYPE_OPENPROM, 41139bffca2SAnthony Liguori .parent = TYPE_SYS_BUS_DEVICE, 41239bffca2SAnthony Liguori .instance_size = sizeof(PROMState), 413999e12bbSAnthony Liguori .class_init = prom_class_init, 41478fb261dSxiaoqiang zhao .instance_init = prom_init1, 4151baffa46SBlue Swirl }; 4161baffa46SBlue Swirl 417bda42033SBlue Swirl 41888c034d5SAndreas Färber #define TYPE_SUN4U_MEMORY "memory" 41988c034d5SAndreas Färber #define SUN4U_RAM(obj) OBJECT_CHECK(RamDevice, (obj), TYPE_SUN4U_MEMORY) 42088c034d5SAndreas Färber 42188c034d5SAndreas Färber typedef struct RamDevice { 42288c034d5SAndreas Färber SysBusDevice parent_obj; 42388c034d5SAndreas Färber 424d4edce38SAvi Kivity MemoryRegion ram; 42504843626SBlue Swirl uint64_t size; 426bda42033SBlue Swirl } RamDevice; 427bda42033SBlue Swirl 428bda42033SBlue Swirl /* System RAM */ 42978fb261dSxiaoqiang zhao static void ram_realize(DeviceState *dev, Error **errp) 430bda42033SBlue Swirl { 43188c034d5SAndreas Färber RamDevice *d = SUN4U_RAM(dev); 43278fb261dSxiaoqiang zhao SysBusDevice *sbd = SYS_BUS_DEVICE(dev); 433bda42033SBlue Swirl 4341cfe48c1SPeter Maydell memory_region_init_ram_nomigrate(&d->ram, OBJECT(d), "sun4u.ram", d->size, 435f8ed85acSMarkus Armbruster &error_fatal); 436c5705a77SAvi Kivity vmstate_register_ram_global(&d->ram); 43778fb261dSxiaoqiang zhao sysbus_init_mmio(sbd, &d->ram); 438bda42033SBlue Swirl } 439bda42033SBlue Swirl 440a8170e5eSAvi Kivity static void ram_init(hwaddr addr, ram_addr_t RAM_size) 441bda42033SBlue Swirl { 442bda42033SBlue Swirl DeviceState *dev; 443bda42033SBlue Swirl SysBusDevice *s; 444bda42033SBlue Swirl RamDevice *d; 445bda42033SBlue Swirl 446bda42033SBlue Swirl /* allocate RAM */ 44788c034d5SAndreas Färber dev = qdev_create(NULL, TYPE_SUN4U_MEMORY); 4481356b98dSAndreas Färber s = SYS_BUS_DEVICE(dev); 449bda42033SBlue Swirl 45088c034d5SAndreas Färber d = SUN4U_RAM(dev); 451bda42033SBlue Swirl d->size = RAM_size; 452e23a1b33SMarkus Armbruster qdev_init_nofail(dev); 453bda42033SBlue Swirl 454bda42033SBlue Swirl sysbus_mmio_map(s, 0, addr); 455bda42033SBlue Swirl } 456bda42033SBlue Swirl 457999e12bbSAnthony Liguori static Property ram_properties[] = { 45832a7ee98SGerd Hoffmann DEFINE_PROP_UINT64("size", RamDevice, size, 0), 45932a7ee98SGerd Hoffmann DEFINE_PROP_END_OF_LIST(), 460999e12bbSAnthony Liguori }; 461999e12bbSAnthony Liguori 462999e12bbSAnthony Liguori static void ram_class_init(ObjectClass *klass, void *data) 463999e12bbSAnthony Liguori { 46439bffca2SAnthony Liguori DeviceClass *dc = DEVICE_CLASS(klass); 465999e12bbSAnthony Liguori 46678fb261dSxiaoqiang zhao dc->realize = ram_realize; 46739bffca2SAnthony Liguori dc->props = ram_properties; 468bda42033SBlue Swirl } 469999e12bbSAnthony Liguori 4708c43a6f0SAndreas Färber static const TypeInfo ram_info = { 47188c034d5SAndreas Färber .name = TYPE_SUN4U_MEMORY, 47239bffca2SAnthony Liguori .parent = TYPE_SYS_BUS_DEVICE, 47339bffca2SAnthony Liguori .instance_size = sizeof(RamDevice), 474999e12bbSAnthony Liguori .class_init = ram_class_init, 475bda42033SBlue Swirl }; 476bda42033SBlue Swirl 47738bc50f7SRichard Henderson static void sun4uv_init(MemoryRegion *address_space_mem, 4783ef96221SMarcel Apfelbaum MachineState *machine, 4797b833f5bSBlue Swirl const struct hwdef *hwdef) 4807b833f5bSBlue Swirl { 481f9d1465fSAndreas Färber SPARCCPU *cpu; 48231688246SHervé Poussineau Nvram *nvram; 4837b833f5bSBlue Swirl unsigned int i; 4845f2bf0feSBlue Swirl uint64_t initrd_addr, initrd_size, kernel_addr, kernel_size, kernel_entry; 485*588978c0SMark Cave-Ayland APBState *apb; 486311f2b7aSMark Cave-Ayland PCIBus *pci_bus, *pci_busA, *pci_busB; 4878d932971SMark Cave-Ayland PCIDevice *ebus, *pci_dev; 488f3b18f35SMark Cave-Ayland SysBusDevice *s; 489c796eddaSMark Cave-Ayland qemu_irq *ivec_irqs; 490f455e98cSGerd Hoffmann DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS]; 491c3ae40e1SHervé Poussineau DeviceState *dev; 492a88b362cSLaszlo Ersek FWCfgState *fw_cfg; 4938d932971SMark Cave-Ayland NICInfo *nd; 4946864fa38SMark Cave-Ayland MACAddr macaddr; 4956864fa38SMark Cave-Ayland bool onboard_nic; 4967b833f5bSBlue Swirl 4977b833f5bSBlue Swirl /* init CPUs */ 49858530461SIgor Mammedov cpu = sparc64_cpu_devinit(machine->cpu_type, hwdef->prom_addr); 4997b833f5bSBlue Swirl 500bda42033SBlue Swirl /* set up devices */ 5013ef96221SMarcel Apfelbaum ram_init(0, machine->ram_size); 5023475187dSbellard 5031baffa46SBlue Swirl prom_init(hwdef->prom_addr, bios_name); 5043475187dSbellard 505fff54d22SArtyom Tarasenko ivec_irqs = qemu_allocate_irqs(sparc64_cpu_set_ivec_irq, cpu, IVEC_MAX); 506*588978c0SMark Cave-Ayland apb = pci_apb_init(APB_SPECIAL_BASE, APB_MEM_BASE, ivec_irqs, &pci_busA, 507c796eddaSMark Cave-Ayland &pci_busB); 508*588978c0SMark Cave-Ayland pci_bus = PCI_HOST_BRIDGE(apb)->bus; 50983469015Sbellard 5106864fa38SMark Cave-Ayland /* Only in-built Simba PBMs can exist on the root bus, slot 0 on busA is 5116864fa38SMark Cave-Ayland reserved (leaving no slots free after on-board devices) however slots 5126864fa38SMark Cave-Ayland 0-3 are free on busB */ 5136864fa38SMark Cave-Ayland pci_bus->slot_reserved_mask = 0xfffffffc; 5146864fa38SMark Cave-Ayland pci_busA->slot_reserved_mask = 0xfffffff1; 5156864fa38SMark Cave-Ayland pci_busB->slot_reserved_mask = 0xfffffff0; 5166864fa38SMark Cave-Ayland 517ad6856e8SMark Cave-Ayland ebus = pci_create_multifunction(pci_busA, PCI_DEVFN(1, 0), true, TYPE_EBUS); 5180fe22ffbSMark Cave-Ayland qdev_prop_set_uint64(DEVICE(ebus), "console-serial-base", 5190fe22ffbSMark Cave-Ayland hwdef->console_serial_base); 5206864fa38SMark Cave-Ayland qdev_init_nofail(DEVICE(ebus)); 5216864fa38SMark Cave-Ayland 5226864fa38SMark Cave-Ayland pci_dev = pci_create_simple(pci_busA, PCI_DEVFN(2, 0), "VGA"); 5236864fa38SMark Cave-Ayland 5246864fa38SMark Cave-Ayland memset(&macaddr, 0, sizeof(MACAddr)); 5256864fa38SMark Cave-Ayland onboard_nic = false; 5268d932971SMark Cave-Ayland for (i = 0; i < nb_nics; i++) { 5278d932971SMark Cave-Ayland nd = &nd_table[i]; 5288d932971SMark Cave-Ayland 5296864fa38SMark Cave-Ayland if (!nd->model || strcmp(nd->model, "sunhme") == 0) { 5306864fa38SMark Cave-Ayland if (!onboard_nic) { 5316864fa38SMark Cave-Ayland pci_dev = pci_create_multifunction(pci_busA, PCI_DEVFN(1, 1), 5326864fa38SMark Cave-Ayland true, "sunhme"); 5336864fa38SMark Cave-Ayland memcpy(&macaddr, &nd->macaddr.a, sizeof(MACAddr)); 5346864fa38SMark Cave-Ayland onboard_nic = true; 5356864fa38SMark Cave-Ayland } else { 536bcf9e2c2SMark Cave-Ayland pci_dev = pci_create(pci_busB, -1, "sunhme"); 5376864fa38SMark Cave-Ayland } 5386864fa38SMark Cave-Ayland } else { 539bcf9e2c2SMark Cave-Ayland pci_dev = pci_create(pci_busB, -1, nd->model); 5406864fa38SMark Cave-Ayland } 5416864fa38SMark Cave-Ayland 5428d932971SMark Cave-Ayland dev = &pci_dev->qdev; 5438d932971SMark Cave-Ayland qdev_set_nic_properties(dev, nd); 5448d932971SMark Cave-Ayland qdev_init_nofail(dev); 5456864fa38SMark Cave-Ayland } 5468d932971SMark Cave-Ayland 5476864fa38SMark Cave-Ayland /* If we don't have an onboard NIC, grab a default MAC address so that 5486864fa38SMark Cave-Ayland * we have a valid machine id */ 5496864fa38SMark Cave-Ayland if (!onboard_nic) { 5506864fa38SMark Cave-Ayland qemu_macaddr_default_if_unset(&macaddr); 5518d932971SMark Cave-Ayland } 55283469015Sbellard 553d8f94e1bSJohn Snow ide_drive_get(hd, ARRAY_SIZE(hd)); 554e4bcb14cSths 5556864fa38SMark Cave-Ayland pci_dev = pci_create(pci_busA, PCI_DEVFN(3, 0), "cmd646-ide"); 5566864fa38SMark Cave-Ayland qdev_prop_set_uint32(&pci_dev->qdev, "secondary", 1); 5576864fa38SMark Cave-Ayland qdev_init_nofail(&pci_dev->qdev); 5586864fa38SMark Cave-Ayland pci_ide_create_devs(pci_dev, hd); 5593b898ddaSblueswir1 560f3b18f35SMark Cave-Ayland /* Map NVRAM into I/O (ebus) space */ 561f3b18f35SMark Cave-Ayland nvram = m48t59_init(NULL, 0, 0, NVRAM_SIZE, 1968, 59); 562f3b18f35SMark Cave-Ayland s = SYS_BUS_DEVICE(nvram); 56307c84741SMark Cave-Ayland memory_region_add_subregion(pci_address_space_io(ebus), 0x2000, 564f3b18f35SMark Cave-Ayland sysbus_mmio_get_region(s, 0)); 565636aa70aSBlue Swirl 566636aa70aSBlue Swirl initrd_size = 0; 5675f2bf0feSBlue Swirl initrd_addr = 0; 5683ef96221SMarcel Apfelbaum kernel_size = sun4u_load_kernel(machine->kernel_filename, 5693ef96221SMarcel Apfelbaum machine->initrd_filename, 5705f2bf0feSBlue Swirl ram_size, &initrd_size, &initrd_addr, 5715f2bf0feSBlue Swirl &kernel_addr, &kernel_entry); 572636aa70aSBlue Swirl 5733ef96221SMarcel Apfelbaum sun4u_NVRAM_set_params(nvram, NVRAM_SIZE, "Sun4u", machine->ram_size, 5743ef96221SMarcel Apfelbaum machine->boot_order, 5755f2bf0feSBlue Swirl kernel_addr, kernel_size, 5763ef96221SMarcel Apfelbaum machine->kernel_cmdline, 5775f2bf0feSBlue Swirl initrd_addr, initrd_size, 57883469015Sbellard /* XXX: need an option to load a NVRAM image */ 57983469015Sbellard 0, 5800d31cb99Sblueswir1 graphic_width, graphic_height, graphic_depth, 5816864fa38SMark Cave-Ayland (uint8_t *)&macaddr); 58283469015Sbellard 583d6acc8a5SMark Cave-Ayland dev = qdev_create(NULL, TYPE_FW_CFG_IO); 584d6acc8a5SMark Cave-Ayland qdev_prop_set_bit(dev, "dma_enabled", false); 58507c84741SMark Cave-Ayland object_property_add_child(OBJECT(ebus), TYPE_FW_CFG, OBJECT(dev), NULL); 586d6acc8a5SMark Cave-Ayland qdev_init_nofail(dev); 58707c84741SMark Cave-Ayland memory_region_add_subregion(pci_address_space_io(ebus), BIOS_CFG_IOPORT, 588d6acc8a5SMark Cave-Ayland &FW_CFG_IO(dev)->comb_iomem); 589d6acc8a5SMark Cave-Ayland 590d6acc8a5SMark Cave-Ayland fw_cfg = FW_CFG(dev); 5915836d168SIgor Mammedov fw_cfg_add_i16(fw_cfg, FW_CFG_NB_CPUS, (uint16_t)smp_cpus); 59270db9222SEduardo Habkost fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus); 593905fdcb5Sblueswir1 fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size); 594905fdcb5Sblueswir1 fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id); 5955f2bf0feSBlue Swirl fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_entry); 5965f2bf0feSBlue Swirl fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); 5973ef96221SMarcel Apfelbaum if (machine->kernel_cmdline) { 5989c9b0512SBlue Swirl fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 5993ef96221SMarcel Apfelbaum strlen(machine->kernel_cmdline) + 1); 6003ef96221SMarcel Apfelbaum fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, machine->kernel_cmdline); 601513f789fSblueswir1 } else { 6029c9b0512SBlue Swirl fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 0); 603513f789fSblueswir1 } 6045f2bf0feSBlue Swirl fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr); 6055f2bf0feSBlue Swirl fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); 6063ef96221SMarcel Apfelbaum fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, machine->boot_order[0]); 6077589690cSBlue Swirl 6087589690cSBlue Swirl fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_WIDTH, graphic_width); 6097589690cSBlue Swirl fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_HEIGHT, graphic_height); 6107589690cSBlue Swirl fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_DEPTH, graphic_depth); 6117589690cSBlue Swirl 612513f789fSblueswir1 qemu_register_boot_set(fw_cfg_boot_set, fw_cfg); 6133475187dSbellard } 6143475187dSbellard 615905fdcb5Sblueswir1 enum { 616905fdcb5Sblueswir1 sun4u_id = 0, 617905fdcb5Sblueswir1 sun4v_id = 64, 618905fdcb5Sblueswir1 }; 619905fdcb5Sblueswir1 620c7ba218dSblueswir1 static const struct hwdef hwdefs[] = { 621c7ba218dSblueswir1 /* Sun4u generic PC-like machine */ 622c7ba218dSblueswir1 { 623905fdcb5Sblueswir1 .machine_id = sun4u_id, 624e87231d4Sblueswir1 .prom_addr = 0x1fff0000000ULL, 625e87231d4Sblueswir1 .console_serial_base = 0, 626c7ba218dSblueswir1 }, 627c7ba218dSblueswir1 /* Sun4v generic PC-like machine */ 628c7ba218dSblueswir1 { 629905fdcb5Sblueswir1 .machine_id = sun4v_id, 630e87231d4Sblueswir1 .prom_addr = 0x1fff0000000ULL, 631e87231d4Sblueswir1 .console_serial_base = 0, 632e87231d4Sblueswir1 }, 633c7ba218dSblueswir1 }; 634c7ba218dSblueswir1 635c7ba218dSblueswir1 /* Sun4u hardware initialisation */ 6363ef96221SMarcel Apfelbaum static void sun4u_init(MachineState *machine) 637c7ba218dSblueswir1 { 6383ef96221SMarcel Apfelbaum sun4uv_init(get_system_memory(), machine, &hwdefs[0]); 639c7ba218dSblueswir1 } 640c7ba218dSblueswir1 641c7ba218dSblueswir1 /* Sun4v hardware initialisation */ 6423ef96221SMarcel Apfelbaum static void sun4v_init(MachineState *machine) 643c7ba218dSblueswir1 { 6443ef96221SMarcel Apfelbaum sun4uv_init(get_system_memory(), machine, &hwdefs[1]); 645c7ba218dSblueswir1 } 646c7ba218dSblueswir1 6478a661aeaSAndreas Färber static void sun4u_class_init(ObjectClass *oc, void *data) 648e264d29dSEduardo Habkost { 6498a661aeaSAndreas Färber MachineClass *mc = MACHINE_CLASS(oc); 6508a661aeaSAndreas Färber 651e264d29dSEduardo Habkost mc->desc = "Sun4u platform"; 652e264d29dSEduardo Habkost mc->init = sun4u_init; 6532059839bSMarkus Armbruster mc->block_default_type = IF_IDE; 654e264d29dSEduardo Habkost mc->max_cpus = 1; /* XXX for now */ 655e264d29dSEduardo Habkost mc->is_default = 1; 656e264d29dSEduardo Habkost mc->default_boot_order = "c"; 65758530461SIgor Mammedov mc->default_cpu_type = SPARC_CPU_TYPE_NAME("TI-UltraSparc-IIi"); 658e264d29dSEduardo Habkost } 659c7ba218dSblueswir1 6608a661aeaSAndreas Färber static const TypeInfo sun4u_type = { 6618a661aeaSAndreas Färber .name = MACHINE_TYPE_NAME("sun4u"), 6628a661aeaSAndreas Färber .parent = TYPE_MACHINE, 6638a661aeaSAndreas Färber .class_init = sun4u_class_init, 6648a661aeaSAndreas Färber }; 665e87231d4Sblueswir1 6668a661aeaSAndreas Färber static void sun4v_class_init(ObjectClass *oc, void *data) 667e264d29dSEduardo Habkost { 6688a661aeaSAndreas Färber MachineClass *mc = MACHINE_CLASS(oc); 6698a661aeaSAndreas Färber 670e264d29dSEduardo Habkost mc->desc = "Sun4v platform"; 671e264d29dSEduardo Habkost mc->init = sun4v_init; 6722059839bSMarkus Armbruster mc->block_default_type = IF_IDE; 673e264d29dSEduardo Habkost mc->max_cpus = 1; /* XXX for now */ 674e264d29dSEduardo Habkost mc->default_boot_order = "c"; 67558530461SIgor Mammedov mc->default_cpu_type = SPARC_CPU_TYPE_NAME("Sun-UltraSparc-T1"); 676e264d29dSEduardo Habkost } 677e264d29dSEduardo Habkost 6788a661aeaSAndreas Färber static const TypeInfo sun4v_type = { 6798a661aeaSAndreas Färber .name = MACHINE_TYPE_NAME("sun4v"), 6808a661aeaSAndreas Färber .parent = TYPE_MACHINE, 6818a661aeaSAndreas Färber .class_init = sun4v_class_init, 6828a661aeaSAndreas Färber }; 683e264d29dSEduardo Habkost 68483f7d43aSAndreas Färber static void sun4u_register_types(void) 68583f7d43aSAndreas Färber { 68683f7d43aSAndreas Färber type_register_static(&ebus_info); 68783f7d43aSAndreas Färber type_register_static(&prom_info); 68883f7d43aSAndreas Färber type_register_static(&ram_info); 68983f7d43aSAndreas Färber 6908a661aeaSAndreas Färber type_register_static(&sun4u_type); 6918a661aeaSAndreas Färber type_register_static(&sun4v_type); 6928a661aeaSAndreas Färber } 6938a661aeaSAndreas Färber 69483f7d43aSAndreas Färber type_init(sun4u_register_types) 695