hw/alpha/dp264.c

   1 /*
   2  * QEMU Alpha DP264/CLIPPER hardware system emulator.
   3  *
   4  * Choose CLIPPER IRQ mappings over, say, DP264, MONET, or WEBBRICK
   5  * variants because CLIPPER doesn't have an SMC669 SuperIO controller
   6  * that we need to emulate as well.
   7  */
   8
   9 #include "qemu/osdep.h"
  10 #include "qemu-common.h"
  11 #include "cpu.h"
  12 #include "elf.h"
  13 #include "hw/loader.h"
  14 #include "alpha_sys.h"
  15 #include "qemu/error-report.h"
  16 #include "sysemu/sysemu.h"
  17 #include "hw/rtc/mc146818rtc.h"
  18 #include "hw/ide.h"
  19 #include "hw/ide/pci.h"
  20 #include "hw/timer/i8254.h"
  21 #include "hw/isa/superio.h"
  22 #include "hw/dma/i8257.h"
  23 #include "net/net.h"
  24 #include "qemu/cutils.h"
  25 #include "net/net.h"
  26
  27 #define MAX_IDE_BUS 2
  28
  29 static uint64_t cpu_alpha_superpage_to_phys(void *opaque, uint64_t addr)
  30 {
  31     if (((addr >> 41) & 3) == 2) {
  32         addr &= 0xffffffffffull;
  33     }
  34     return addr;
  35 }
  36
  37 /* Note that there are at least 3 viewpoints of IRQ numbers on Alpha systems.
  38     (0) The dev_irq_n lines into the cpu, which we totally ignore,
  39     (1) The DRIR lines in the typhoon chipset,
  40     (2) The "vector" aka mangled interrupt number reported by SRM PALcode,
  41     (3) The interrupt number assigned by the kernel.
  42    The following function is concerned with (1) only.  */
  43
  44 static int clipper_pci_map_irq(PCIDevice *d, int irq_num)
  45 {
  46     int slot = d->devfn >> 3;
  47
  48     assert(irq_num >= 0 && irq_num <= 3);
  49
  50     return (slot + 1) * 4 + irq_num;
  51 }
  52
  53 static void clipper_init(MachineState *machine)
  54 {
  55     ram_addr_t ram_size = machine->ram_size;
  56     const char *kernel_filename = machine->kernel_filename;
  57     const char *kernel_cmdline = machine->kernel_cmdline;
  58     const char *initrd_filename = machine->initrd_filename;
  59     AlphaCPU *cpus[4];
  60     PCIBus *pci_bus;
  61     ISABus *isa_bus;
  62     qemu_irq rtc_irq;
  63     long size, i;
  64     char *palcode_filename;
  65     uint64_t palcode_entry, palcode_low, palcode_high;
  66     uint64_t kernel_entry, kernel_low, kernel_high;
  67     unsigned int smp_cpus = machine->smp.cpus;
  68
  69     /* Create up to 4 cpus.  */
  70     memset(cpus, 0, sizeof(cpus));
  71     for (i = 0; i < smp_cpus; ++i) {
  72         cpus[i] = ALPHA_CPU(cpu_create(machine->cpu_type));
  73     }
  74
  75     cpus[0]->env.trap_arg0 = ram_size;
  76     cpus[0]->env.trap_arg1 = 0;
  77     cpus[0]->env.trap_arg2 = smp_cpus;
  78
  79     /* Init the chipset.  */
  80     pci_bus = typhoon_init(machine->ram, &isa_bus, &rtc_irq, cpus,
  81                            clipper_pci_map_irq);
  82
  83     /* Since we have an SRM-compatible PALcode, use the SRM epoch.  */
  84     mc146818_rtc_init(isa_bus, 1900, rtc_irq);
  85
  86     i8254_pit_init(isa_bus, 0x40, 0, NULL);
  87
  88     /* VGA setup.  Don't bother loading the bios.  */
  89     pci_vga_init(pci_bus);
  90
  91     /* Network setup.  e1000 is good enough, failing Tulip support.  */
  92     for (i = 0; i < nb_nics; i++) {
  93         pci_nic_init_nofail(&nd_table[i], pci_bus, "e1000", NULL);
  94     }
  95
  96     /* 2 82C37 (dma) */
  97     isa_create_simple(isa_bus, "i82374");
  98
  99     /* Super I/O */
 100     isa_create_simple(isa_bus, TYPE_SMC37C669_SUPERIO);
 101
 102     /* IDE disk setup.  */
 103     {
 104         DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
 105         PCIDevice *pci_dev;
 106
 107         ide_drive_get(hd, ARRAY_SIZE(hd));
 108
 109         pci_dev = pci_create_simple(pci_bus, -1, "cmd646-ide");
 110         pci_ide_create_devs(pci_dev, hd);
 111     }
 112
 113     /* Load PALcode.  Given that this is not "real" cpu palcode,
 114        but one explicitly written for the emulation, we might as
 115        well load it directly from and ELF image.  */
 116     palcode_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS,
 117                                 bios_name ? bios_name : "palcode-clipper");
 118     if (palcode_filename == NULL) {
 119         error_report("no palcode provided");
 120         exit(1);
 121     }
 122     size = load_elf(palcode_filename, NULL, cpu_alpha_superpage_to_phys,
 123                     NULL, &palcode_entry, &palcode_low, &palcode_high, NULL,
 124                     0, EM_ALPHA, 0, 0);
 125     if (size < 0) {
 126         error_report("could not load palcode '%s'", palcode_filename);
 127         exit(1);
 128     }
 129     g_free(palcode_filename);
 130
 131     /* Start all cpus at the PALcode RESET entry point.  */
 132     for (i = 0; i < smp_cpus; ++i) {
 133         cpus[i]->env.pc = palcode_entry;
 134         cpus[i]->env.palbr = palcode_entry;
 135     }
 136
 137     /* Load a kernel.  */
 138     if (kernel_filename) {
 139         uint64_t param_offset;
 140
 141         size = load_elf(kernel_filename, NULL, cpu_alpha_superpage_to_phys,
 142                         NULL, &kernel_entry, &kernel_low, &kernel_high, NULL,
 143                         0, EM_ALPHA, 0, 0);
 144         if (size < 0) {
 145             error_report("could not load kernel '%s'", kernel_filename);
 146             exit(1);
 147         }
 148
 149         cpus[0]->env.trap_arg1 = kernel_entry;
 150
 151         param_offset = kernel_low - 0x6000;
 152
 153         if (kernel_cmdline) {
 154             pstrcpy_targphys("cmdline", param_offset, 0x100, kernel_cmdline);
 155         }
 156
 157         if (initrd_filename) {
 158             long initrd_base;
 159             int64_t initrd_size;
 160
 161             initrd_size = get_image_size(initrd_filename);
 162             if (initrd_size < 0) {
 163                 error_report("could not load initial ram disk '%s'",
 164                              initrd_filename);
 165                 exit(1);
 166             }
 167
 168             /* Put the initrd image as high in memory as possible.  */
 169             initrd_base = (ram_size - initrd_size) & TARGET_PAGE_MASK;
 170             load_image_targphys(initrd_filename, initrd_base,
 171                                 ram_size - initrd_base);
 172
 173             address_space_stq(&address_space_memory, param_offset + 0x100,
 174                               initrd_base + 0xfffffc0000000000ULL,
 175                               MEMTXATTRS_UNSPECIFIED,
 176                               NULL);
 177             address_space_stq(&address_space_memory, param_offset + 0x108,
 178                               initrd_size, MEMTXATTRS_UNSPECIFIED, NULL);
 179         }
 180     }
 181 }
 182
 183 static void clipper_machine_init(MachineClass *mc)
 184 {
 185     mc->desc = "Alpha DP264/CLIPPER";
 186     mc->init = clipper_init;
 187     mc->block_default_type = IF_IDE;
 188     mc->max_cpus = 4;
 189     mc->is_default = true;
 190     mc->default_cpu_type = ALPHA_CPU_TYPE_NAME("ev67");
 191     mc->default_ram_id = "ram";
 192 }
 193
 194 DEFINE_MACHINE("clipper", clipper_machine_init)