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