vcs.maemo.org Git - qemu/blob - hw/sun4m.c

   1 /*
   2  * QEMU Sun4m 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 "vl.h"
  25
  26 /*
  27  * Sun4m architecture was used in the following machines:
  28  *
  29  * SPARCserver 6xxMP/xx
  30  * SPARCclassic (SPARCclassic Server)(SPARCstation LC) (4/15), SPARCclassic X (4/10)
  31  * SPARCstation LX/ZX (4/30)
  32  * SPARCstation Voyager
  33  * SPARCstation 10/xx, SPARCserver 10/xx
  34  * SPARCstation 5, SPARCserver 5
  35  * SPARCstation 20/xx, SPARCserver 20
  36  * SPARCstation 4
  37  *
  38  * See for example: http://www.sunhelp.org/faq/sunref1.html
  39  */
  40
  41 #define KERNEL_LOAD_ADDR     0x00004000
  42 #define CMDLINE_ADDR         0x007ff000
  43 #define INITRD_LOAD_ADDR     0x00800000
  44 #define PROM_SIZE_MAX        (256 * 1024)
  45 #define PROM_ADDR            0xffd00000
  46 #define PROM_FILENAME        "openbios-sparc32"
  47
  48 #define MAX_CPUS 16
  49
  50 struct hwdef {
  51     target_ulong iommu_base, slavio_base;
  52     target_ulong intctl_base, counter_base, nvram_base, ms_kb_base, serial_base;
  53     target_ulong fd_base;
  54     target_ulong dma_base, esp_base, le_base;
  55     target_ulong tcx_base, cs_base;
  56     long vram_size, nvram_size;
  57     // IRQ numbers are not PIL ones, but master interrupt controller register
  58     // bit numbers
  59     int intctl_g_intr, esp_irq, le_irq, cpu_irq, clock_irq, clock1_irq;
  60     int ser_irq, ms_kb_irq, fd_irq, me_irq, cs_irq;
  61     int machine_id; // For NVRAM
  62     uint32_t intbit_to_level[32];
  63 };
  64
  65 /* TSC handling */
  66
  67 uint64_t cpu_get_tsc()
  68 {
  69     return qemu_get_clock(vm_clock);
  70 }
  71
  72 int DMA_get_channel_mode (int nchan)
  73 {
  74     return 0;
  75 }
  76 int DMA_read_memory (int nchan, void *buf, int pos, int size)
  77 {
  78     return 0;
  79 }
  80 int DMA_write_memory (int nchan, void *buf, int pos, int size)
  81 {
  82     return 0;
  83 }
  84 void DMA_hold_DREQ (int nchan) {}
  85 void DMA_release_DREQ (int nchan) {}
  86 void DMA_schedule(int nchan) {}
  87 void DMA_run (void) {}
  88 void DMA_init (int high_page_enable) {}
  89 void DMA_register_channel (int nchan,
  90                            DMA_transfer_handler transfer_handler,
  91                            void *opaque)
  92 {
  93 }
  94
  95 static void nvram_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value)
  96 {
  97     m48t59_write(nvram, addr++, (value >> 8) & 0xff);
  98     m48t59_write(nvram, addr++, value & 0xff);
  99 }
 100
 101 static void nvram_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value)
 102 {
 103     m48t59_write(nvram, addr++, value >> 24);
 104     m48t59_write(nvram, addr++, (value >> 16) & 0xff);
 105     m48t59_write(nvram, addr++, (value >> 8) & 0xff);
 106     m48t59_write(nvram, addr++, value & 0xff);
 107 }
 108
 109 static void nvram_set_string (m48t59_t *nvram, uint32_t addr,
 110                        const unsigned char *str, uint32_t max)
 111 {
 112     unsigned int i;
 113
 114     for (i = 0; i < max && str[i] != '\0'; i++) {
 115         m48t59_write(nvram, addr + i, str[i]);
 116     }
 117     m48t59_write(nvram, addr + max - 1, '\0');
 118 }
 119
 120 static m48t59_t *nvram;
 121
 122 extern int nographic;
 123
 124 static void nvram_init(m48t59_t *nvram, uint8_t *macaddr, const char *cmdline,
 125                        int boot_device, uint32_t RAM_size,
 126                        uint32_t kernel_size,
 127                        int width, int height, int depth,
 128                        int machine_id)
 129 {
 130     unsigned char tmp = 0;
 131     int i, j;
 132
 133     // Try to match PPC NVRAM
 134     nvram_set_string(nvram, 0x00, "QEMU_BIOS", 16);
 135     nvram_set_lword(nvram,  0x10, 0x00000001); /* structure v1 */
 136     // NVRAM_size, arch not applicable
 137     m48t59_write(nvram, 0x2D, smp_cpus & 0xff);
 138     m48t59_write(nvram, 0x2E, 0);
 139     m48t59_write(nvram, 0x2F, nographic & 0xff);
 140     nvram_set_lword(nvram,  0x30, RAM_size);
 141     m48t59_write(nvram, 0x34, boot_device & 0xff);
 142     nvram_set_lword(nvram,  0x38, KERNEL_LOAD_ADDR);
 143     nvram_set_lword(nvram,  0x3C, kernel_size);
 144     if (cmdline) {
 145         strcpy(phys_ram_base + CMDLINE_ADDR, cmdline);
 146         nvram_set_lword(nvram,  0x40, CMDLINE_ADDR);
 147         nvram_set_lword(nvram,  0x44, strlen(cmdline));
 148     }
 149     // initrd_image, initrd_size passed differently
 150     nvram_set_word(nvram,   0x54, width);
 151     nvram_set_word(nvram,   0x56, height);
 152     nvram_set_word(nvram,   0x58, depth);
 153
 154     // Sun4m specific use
 155     i = 0x1fd8;
 156     m48t59_write(nvram, i++, 0x01);
 157     m48t59_write(nvram, i++, machine_id);
 158     j = 0;
 159     m48t59_write(nvram, i++, macaddr[j++]);
 160     m48t59_write(nvram, i++, macaddr[j++]);
 161     m48t59_write(nvram, i++, macaddr[j++]);
 162     m48t59_write(nvram, i++, macaddr[j++]);
 163     m48t59_write(nvram, i++, macaddr[j++]);
 164     m48t59_write(nvram, i, macaddr[j]);
 165
 166     /* Calculate checksum */
 167     for (i = 0x1fd8; i < 0x1fe7; i++) {
 168         tmp ^= m48t59_read(nvram, i);
 169     }
 170     m48t59_write(nvram, 0x1fe7, tmp);
 171 }
 172
 173 static void *slavio_intctl;
 174
 175 void pic_info()
 176 {
 177     slavio_pic_info(slavio_intctl);
 178 }
 179
 180 void irq_info()
 181 {
 182     slavio_irq_info(slavio_intctl);
 183 }
 184
 185 static void *slavio_misc;
 186
 187 void qemu_system_powerdown(void)
 188 {
 189     slavio_set_power_fail(slavio_misc, 1);
 190 }
 191
 192 static void main_cpu_reset(void *opaque)
 193 {
 194     CPUState *env = opaque;
 195     cpu_reset(env);
 196 }
 197
 198 static void sun4m_hw_init(const struct hwdef *hwdef, int ram_size,
 199                           DisplayState *ds, const char *cpu_model)
 200
 201 {
 202     CPUState *env, *envs[MAX_CPUS];
 203     unsigned int i;
 204     void *iommu, *dma, *main_esp, *main_lance = NULL;
 205     const sparc_def_t *def;
 206     qemu_irq *slavio_irq;
 207
 208     /* init CPUs */
 209     sparc_find_by_name(cpu_model, &def);
 210     if (def == NULL) {
 211         fprintf(stderr, "Unable to find Sparc CPU definition\n");
 212         exit(1);
 213     }
 214     for(i = 0; i < smp_cpus; i++) {
 215         env = cpu_init();
 216         cpu_sparc_register(env, def);
 217         envs[i] = env;
 218         if (i != 0)
 219             env->halted = 1;
 220         register_savevm("cpu", i, 3, cpu_save, cpu_load, env);
 221         qemu_register_reset(main_cpu_reset, env);
 222     }
 223     /* allocate RAM */
 224     cpu_register_physical_memory(0, ram_size, 0);
 225
 226     iommu = iommu_init(hwdef->iommu_base);
 227     slavio_intctl = slavio_intctl_init(hwdef->intctl_base,
 228                                        hwdef->intctl_base + 0x10000,
 229                                        &hwdef->intbit_to_level[0],
 230                                        &slavio_irq);
 231     for(i = 0; i < smp_cpus; i++) {
 232         slavio_intctl_set_cpu(slavio_intctl, i, envs[i]);
 233     }
 234     dma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq],
 235                            slavio_irq[hwdef->le_irq], iommu);
 236
 237     if (graphic_depth != 8 && graphic_depth != 24) {
 238         fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth);
 239         exit (1);
 240     }
 241     tcx_init(ds, hwdef->tcx_base, phys_ram_base + ram_size, ram_size,
 242              hwdef->vram_size, graphic_width, graphic_height, graphic_depth);
 243     if (nd_table[0].vlan) {
 244         if (nd_table[0].model == NULL
 245             || strcmp(nd_table[0].model, "lance") == 0) {
 246             main_lance = lance_init(&nd_table[0], hwdef->le_base, dma,
 247                                     slavio_irq[hwdef->le_irq]);
 248         } else {
 249             fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
 250             exit (1);
 251         }
 252     }
 253     nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0,
 254                         hwdef->nvram_size, 8);
 255     for (i = 0; i < MAX_CPUS; i++) {
 256         slavio_timer_init(hwdef->counter_base + i * TARGET_PAGE_SIZE,
 257                           hwdef->clock_irq, 0, i, slavio_intctl);
 258     }
 259     slavio_timer_init(hwdef->counter_base + 0x10000, hwdef->clock1_irq, 2,
 260                       (unsigned int)-1, slavio_intctl);
 261     slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq]);
 262     // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device
 263     // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device
 264     slavio_serial_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq],
 265                        serial_hds[1], serial_hds[0]);
 266     fdctrl_init(slavio_irq[hwdef->fd_irq], 0, 1, hwdef->fd_base, fd_table);
 267     main_esp = esp_init(bs_table, hwdef->esp_base, dma);
 268
 269     for (i = 0; i < MAX_DISKS; i++) {
 270         if (bs_table[i]) {
 271             esp_scsi_attach(main_esp, bs_table[i], i);
 272         }
 273     }
 274
 275     slavio_misc = slavio_misc_init(hwdef->slavio_base,
 276                                    slavio_irq[hwdef->me_irq]);
 277     if (hwdef->cs_base != (target_ulong)-1)
 278         cs_init(hwdef->cs_base, hwdef->cs_irq, slavio_intctl);
 279     sparc32_dma_set_reset_data(dma, main_esp, main_lance);
 280 }
 281
 282 static void sun4m_load_kernel(long vram_size, int ram_size, int boot_device,
 283                               const char *kernel_filename,
 284                               const char *kernel_cmdline,
 285                               const char *initrd_filename,
 286                               int machine_id)
 287 {
 288     int ret, linux_boot;
 289     char buf[1024];
 290     unsigned int i;
 291     long prom_offset, initrd_size, kernel_size;
 292
 293     linux_boot = (kernel_filename != NULL);
 294
 295     prom_offset = ram_size + vram_size;
 296     cpu_register_physical_memory(PROM_ADDR,
 297                                  (PROM_SIZE_MAX + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK,
 298                                  prom_offset | IO_MEM_ROM);
 299
 300     snprintf(buf, sizeof(buf), "%s/%s", bios_dir, PROM_FILENAME);
 301     ret = load_elf(buf, 0, NULL, NULL, NULL);
 302     if (ret < 0) {
 303         fprintf(stderr, "qemu: could not load prom '%s'\n",
 304                 buf);
 305         exit(1);
 306     }
 307
 308     kernel_size = 0;
 309     if (linux_boot) {
 310         kernel_size = load_elf(kernel_filename, -0xf0000000, NULL, NULL, NULL);
 311         if (kernel_size < 0)
 312             kernel_size = load_aout(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 313         if (kernel_size < 0)
 314             kernel_size = load_image(kernel_filename, phys_ram_base + KERNEL_LOAD_ADDR);
 315         if (kernel_size < 0) {
 316             fprintf(stderr, "qemu: could not load kernel '%s'\n",
 317                     kernel_filename);
 318             exit(1);
 319         }
 320
 321         /* load initrd */
 322         initrd_size = 0;
 323         if (initrd_filename) {
 324             initrd_size = load_image(initrd_filename, phys_ram_base + INITRD_LOAD_ADDR);
 325             if (initrd_size < 0) {
 326                 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
 327                         initrd_filename);
 328                 exit(1);
 329             }
 330         }
 331         if (initrd_size > 0) {
 332             for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) {
 333                 if (ldl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i)
 334                     == 0x48647253) { // HdrS
 335                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 16, INITRD_LOAD_ADDR);
 336                     stl_raw(phys_ram_base + KERNEL_LOAD_ADDR + i + 20, initrd_size);
 337                     break;
 338                 }
 339             }
 340         }
 341     }
 342     nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline,
 343                boot_device, ram_size, kernel_size, graphic_width,
 344                graphic_height, graphic_depth, machine_id);
 345 }
 346
 347 static const struct hwdef hwdefs[] = {
 348     /* SS-5 */
 349     {
 350         .iommu_base   = 0x10000000,
 351         .tcx_base     = 0x50000000,
 352         .cs_base      = 0x6c000000,
 353         .slavio_base  = 0x71000000,
 354         .ms_kb_base   = 0x71000000,
 355         .serial_base  = 0x71100000,
 356         .nvram_base   = 0x71200000,
 357         .fd_base      = 0x71400000,
 358         .counter_base = 0x71d00000,
 359         .intctl_base  = 0x71e00000,
 360         .dma_base     = 0x78400000,
 361         .esp_base     = 0x78800000,
 362         .le_base      = 0x78c00000,
 363         .vram_size    = 0x00100000,
 364         .nvram_size   = 0x2000,
 365         .esp_irq = 18,
 366         .le_irq = 16,
 367         .clock_irq = 7,
 368         .clock1_irq = 19,
 369         .ms_kb_irq = 14,
 370         .ser_irq = 15,
 371         .fd_irq = 22,
 372         .me_irq = 30,
 373         .cs_irq = 5,
 374         .machine_id = 0x80,
 375         .intbit_to_level = {
 376             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 377             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 378         },
 379     },
 380     /* SS-10 */
 381     {
 382         .iommu_base   = 0xe0000000, // XXX Actually at 0xfe0000000ULL (36 bits)
 383         .tcx_base     = 0x20000000, // 0xe20000000ULL,
 384         .cs_base      = -1,
 385         .slavio_base  = 0xf1000000, // 0xff1000000ULL,
 386         .ms_kb_base   = 0xf1000000, // 0xff1000000ULL,
 387         .serial_base  = 0xf1100000, // 0xff1100000ULL,
 388         .nvram_base   = 0xf1200000, // 0xff1200000ULL,
 389         .fd_base      = 0xf1700000, // 0xff1700000ULL,
 390         .counter_base = 0xf1300000, // 0xff1300000ULL,
 391         .intctl_base  = 0xf1400000, // 0xff1400000ULL,
 392         .dma_base     = 0xf0400000, // 0xef0400000ULL,
 393         .esp_base     = 0xf0800000, // 0xef0800000ULL,
 394         .le_base      = 0xf0c00000, // 0xef0c00000ULL,
 395         .vram_size    = 0x00100000,
 396         .nvram_size   = 0x2000,
 397         .esp_irq = 18,
 398         .le_irq = 16,
 399         .clock_irq = 7,
 400         .clock1_irq = 19,
 401         .ms_kb_irq = 14,
 402         .ser_irq = 15,
 403         .fd_irq = 22,
 404         .me_irq = 30,
 405         .cs_irq = -1,
 406         .machine_id = 0x72,
 407         .intbit_to_level = {
 408             2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 409             6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 410         },
 411     },
 412 };
 413
 414 static void sun4m_common_init(int ram_size, int boot_device, DisplayState *ds,
 415                               const char *kernel_filename, const char *kernel_cmdline,
 416                               const char *initrd_filename, const char *cpu_model,
 417                               unsigned int machine)
 418 {
 419     sun4m_hw_init(&hwdefs[machine], ram_size, ds, cpu_model);
 420
 421     sun4m_load_kernel(hwdefs[machine].vram_size, ram_size, boot_device,
 422                       kernel_filename, kernel_cmdline, initrd_filename,
 423                       hwdefs[machine].machine_id);
 424 }
 425
 426 /* SPARCstation 5 hardware initialisation */
 427 static void ss5_init(int ram_size, int vga_ram_size, int boot_device,
 428                        DisplayState *ds, const char **fd_filename, int snapshot,
 429                        const char *kernel_filename, const char *kernel_cmdline,
 430                        const char *initrd_filename, const char *cpu_model)
 431 {
 432     if (cpu_model == NULL)
 433         cpu_model = "Fujitsu MB86904";
 434     sun4m_common_init(ram_size, boot_device, ds, kernel_filename,
 435                       kernel_cmdline, initrd_filename, cpu_model,
 436                       0);
 437 }
 438
 439 /* SPARCstation 10 hardware initialisation */
 440 static void ss10_init(int ram_size, int vga_ram_size, int boot_device,
 441                             DisplayState *ds, const char **fd_filename, int snapshot,
 442                             const char *kernel_filename, const char *kernel_cmdline,
 443                             const char *initrd_filename, const char *cpu_model)
 444 {
 445     if (cpu_model == NULL)
 446         cpu_model = "TI SuperSparc II";
 447     sun4m_common_init(ram_size, boot_device, ds, kernel_filename,
 448                       kernel_cmdline, initrd_filename, cpu_model,
 449                       1);
 450 }
 451
 452 QEMUMachine ss5_machine = {
 453     "SS-5",
 454     "Sun4m platform, SPARCstation 5",
 455     ss5_init,
 456 };
 457
 458 QEMUMachine ss10_machine = {
 459     "SS-10",
 460     "Sun4m platform, SPARCstation 10",
 461     ss10_init,
 462 };