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 "cpu.h"
  11 #include "elf.h"
  12 #include "hw/loader.h"
  13 #include "alpha_sys.h"
  14 #include "qemu/error-report.h"
  15 #include "hw/rtc/mc146818rtc.h"
  16 #include "hw/ide/pci.h"
  17 #include "hw/isa/superio.h"
  18 #include "net/net.h"
  19 #include "qemu/cutils.h"
  20 #include "qemu/datadir.h"
  21 #include "net/net.h"
  22
  23 #define MAX_IDE_BUS 2
  24
  25 static uint64_t cpu_alpha_superpage_to_phys(void *opaque, uint64_t addr)
  26 {
  27     if (((addr >> 41) & 3) == 2) {
  28         addr &= 0xffffffffffull;
  29     }
  30     return addr;
  31 }
  32
  33 /* Note that there are at least 3 viewpoints of IRQ numbers on Alpha systems.
  34     (0) The dev_irq_n lines into the cpu, which we totally ignore,
  35     (1) The DRIR lines in the typhoon chipset,
  36     (2) The "vector" aka mangled interrupt number reported by SRM PALcode,
  37     (3) The interrupt number assigned by the kernel.
  38    The following function is concerned with (1) only.  */
  39
  40 static int clipper_pci_map_irq(PCIDevice *d, int irq_num)
  41 {
  42     int slot = d->devfn >> 3;
  43
  44     assert(irq_num >= 0 && irq_num <= 3);
  45
  46     return (slot + 1) * 4 + irq_num;
  47 }
  48
  49 static void clipper_init(MachineState *machine)
  50 {
  51     ram_addr_t ram_size = machine->ram_size;
  52     const char *kernel_filename = machine->kernel_filename;
  53     const char *kernel_cmdline = machine->kernel_cmdline;
  54     const char *initrd_filename = machine->initrd_filename;
  55     AlphaCPU *cpus[4];
  56     PCIBus *pci_bus;
  57     PCIDevice *pci_dev;
  58     DeviceState *i82378_dev;
  59     ISABus *isa_bus;
  60     qemu_irq rtc_irq;
  61     qemu_irq isa_irq;
  62     long size, i;
  63     char *palcode_filename;
  64     uint64_t palcode_entry;
  65     uint64_t kernel_entry, kernel_low;
  66     unsigned int smp_cpus = machine->smp.cpus;
  67
  68     /* Create up to 4 cpus.  */
  69     memset(cpus, 0, sizeof(cpus));
  70     for (i = 0; i < smp_cpus; ++i) {
  71         cpus[i] = ALPHA_CPU(cpu_create(machine->cpu_type));
  72     }
  73
  74     /*
  75      * arg0 -> memory size
  76      * arg1 -> kernel entry point
  77      * arg2 -> config word
  78      *
  79      * Config word: bits 0-5 -> ncpus
  80      *              bit  6   -> nographics option (for HWRPB CTB)
  81      *
  82      * See init_hwrpb() in the PALcode.
  83      */
  84     cpus[0]->env.trap_arg0 = ram_size;
  85     cpus[0]->env.trap_arg1 = 0;
  86     cpus[0]->env.trap_arg2 = smp_cpus | (!machine->enable_graphics << 6);
  87
  88     /*
  89      * Init the chipset.  Because we're using CLIPPER IRQ mappings,
  90      * the minimum PCI device IdSel is 1.
  91      */
  92     pci_bus = typhoon_init(machine->ram, &isa_irq, &rtc_irq, cpus,
  93                            clipper_pci_map_irq, PCI_DEVFN(1, 0));
  94
  95     /*
  96      * Init the PCI -> ISA bridge.
  97      *
  98      * Technically, PCI-based Alphas shipped with one of three different
  99      * PCI-ISA bridges:
 100      *
 101      * - Intel i82378 SIO
 102      * - Cypress CY82c693UB
 103      * - ALI M1533
 104      *
 105      * (An Intel i82375 PCI-EISA bridge was also used on some models.)
 106      *
 107      * For simplicity, we model an i82378 here, even though it wouldn't
 108      * have been on any Tsunami/Typhoon systems; it's close enough, and
 109      * we don't want to deal with modelling the CY82c693UB (which has
 110      * incompatible edge/level control registers, plus other peripherals
 111      * like IDE and USB) or the M1533 (which also has IDE and USB).
 112      *
 113      * Importantly, we need to provide a PCI device node for it, otherwise
 114      * some operating systems won't notice there's an ISA bus to configure.
 115      */
 116     i82378_dev = DEVICE(pci_create_simple(pci_bus, PCI_DEVFN(7, 0), "i82378"));
 117     isa_bus = ISA_BUS(qdev_get_child_bus(i82378_dev, "isa.0"));
 118
 119     /* Connect the ISA PIC to the Typhoon IRQ used for ISA interrupts. */
 120     qdev_connect_gpio_out(i82378_dev, 0, isa_irq);
 121
 122     /* Since we have an SRM-compatible PALcode, use the SRM epoch.  */
 123     mc146818_rtc_init(isa_bus, 1900, rtc_irq);
 124
 125     /* VGA setup.  Don't bother loading the bios.  */
 126     pci_vga_init(pci_bus);
 127
 128     /* Network setup.  e1000 is good enough, failing Tulip support.  */
 129     for (i = 0; i < nb_nics; i++) {
 130         pci_nic_init_nofail(&nd_table[i], pci_bus, "e1000", NULL);
 131     }
 132
 133     /* Super I/O */
 134     isa_create_simple(isa_bus, TYPE_SMC37C669_SUPERIO);
 135
 136     /* IDE disk setup.  */
 137     pci_dev = pci_create_simple(pci_bus, -1, "cmd646-ide");
 138     pci_ide_create_devs(pci_dev);
 139
 140     /* Load PALcode.  Given that this is not "real" cpu palcode,
 141        but one explicitly written for the emulation, we might as
 142        well load it directly from and ELF image.  */
 143     palcode_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS,
 144                                       machine->firmware ?: "palcode-clipper");
 145     if (palcode_filename == NULL) {
 146         error_report("no palcode provided");
 147         exit(1);
 148     }
 149     size = load_elf(palcode_filename, NULL, cpu_alpha_superpage_to_phys,
 150                     NULL, &palcode_entry, NULL, NULL, NULL,
 151                     0, EM_ALPHA, 0, 0);
 152     if (size < 0) {
 153         error_report("could not load palcode '%s'", palcode_filename);
 154         exit(1);
 155     }
 156     g_free(palcode_filename);
 157
 158     /* Start all cpus at the PALcode RESET entry point.  */
 159     for (i = 0; i < smp_cpus; ++i) {
 160         cpus[i]->env.pc = palcode_entry;
 161         cpus[i]->env.palbr = palcode_entry;
 162     }
 163
 164     /* Load a kernel.  */
 165     if (kernel_filename) {
 166         uint64_t param_offset;
 167
 168         size = load_elf(kernel_filename, NULL, cpu_alpha_superpage_to_phys,
 169                         NULL, &kernel_entry, &kernel_low, NULL, NULL,
 170                         0, EM_ALPHA, 0, 0);
 171         if (size < 0) {
 172             error_report("could not load kernel '%s'", kernel_filename);
 173             exit(1);
 174         }
 175
 176         cpus[0]->env.trap_arg1 = kernel_entry;
 177
 178         param_offset = kernel_low - 0x6000;
 179
 180         if (kernel_cmdline) {
 181             pstrcpy_targphys("cmdline", param_offset, 0x100, kernel_cmdline);
 182         }
 183
 184         if (initrd_filename) {
 185             long initrd_base;
 186             int64_t initrd_size;
 187
 188             initrd_size = get_image_size(initrd_filename);
 189             if (initrd_size < 0) {
 190                 error_report("could not load initial ram disk '%s'",
 191                              initrd_filename);
 192                 exit(1);
 193             }
 194
 195             /* Put the initrd image as high in memory as possible.  */
 196             initrd_base = (ram_size - initrd_size) & TARGET_PAGE_MASK;
 197             load_image_targphys(initrd_filename, initrd_base,
 198                                 ram_size - initrd_base);
 199
 200             address_space_stq(&address_space_memory, param_offset + 0x100,
 201                               initrd_base + 0xfffffc0000000000ULL,
 202                               MEMTXATTRS_UNSPECIFIED,
 203                               NULL);
 204             address_space_stq(&address_space_memory, param_offset + 0x108,
 205                               initrd_size, MEMTXATTRS_UNSPECIFIED, NULL);
 206         }
 207     }
 208 }
 209
 210 static void clipper_machine_init(MachineClass *mc)
 211 {
 212     mc->desc = "Alpha DP264/CLIPPER";
 213     mc->init = clipper_init;
 214     mc->block_default_type = IF_IDE;
 215     mc->max_cpus = 4;
 216     mc->is_default = true;
 217     mc->default_cpu_type = ALPHA_CPU_TYPE_NAME("ev67");
 218     mc->default_ram_id = "ram";
 219 }
 220
 221 DEFINE_MACHINE("clipper", clipper_machine_init)