1 /* 2 * NeXT Cube System Driver 3 * 4 * Copyright (c) 2011 Bryce Lanham 5 * 6 * This code is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published 8 * by the Free Software Foundation; either version 2 of the License, 9 * or (at your option) any later version. 10 */ 11 12 #include "qemu/osdep.h" 13 #include "exec/hwaddr.h" 14 #include "system/system.h" 15 #include "system/qtest.h" 16 #include "hw/irq.h" 17 #include "hw/m68k/next-cube.h" 18 #include "hw/boards.h" 19 #include "hw/loader.h" 20 #include "hw/scsi/esp.h" 21 #include "hw/sysbus.h" 22 #include "qom/object.h" 23 #include "hw/char/escc.h" /* ZILOG 8530 Serial Emulation */ 24 #include "hw/block/fdc.h" 25 #include "hw/misc/empty_slot.h" 26 #include "hw/qdev-properties.h" 27 #include "qapi/error.h" 28 #include "qemu/error-report.h" 29 #include "ui/console.h" 30 #include "target/m68k/cpu.h" 31 #include "migration/vmstate.h" 32 33 /* #define DEBUG_NEXT */ 34 #ifdef DEBUG_NEXT 35 #define DPRINTF(fmt, ...) \ 36 do { printf("NeXT: " fmt , ## __VA_ARGS__); } while (0) 37 #else 38 #define DPRINTF(fmt, ...) do { } while (0) 39 #endif 40 41 #define ENTRY 0x0100001e 42 #define RAM_SIZE 0x4000000 43 #define ROM_FILE "Rev_2.5_v66.bin" 44 45 46 #define TYPE_NEXT_RTC "next-rtc" 47 OBJECT_DECLARE_SIMPLE_TYPE(NeXTRTC, NEXT_RTC) 48 49 struct NeXTRTC { 50 SysBusDevice parent_obj; 51 52 int8_t phase; 53 uint8_t ram[32]; 54 uint8_t command; 55 uint8_t value; 56 uint8_t status; 57 uint8_t control; 58 uint8_t retval; 59 60 qemu_irq data_out_irq; 61 qemu_irq power_irq; 62 }; 63 64 #define TYPE_NEXT_SCSI "next-scsi" 65 OBJECT_DECLARE_SIMPLE_TYPE(NeXTSCSI, NEXT_SCSI) 66 67 /* NeXT SCSI Controller */ 68 struct NeXTSCSI { 69 SysBusDevice parent_obj; 70 71 MemoryRegion scsi_mem; 72 73 SysBusESPState sysbus_esp; 74 75 MemoryRegion scsi_csr_mem; 76 uint8_t scsi_csr_1; 77 uint8_t scsi_csr_2; 78 }; 79 80 #define TYPE_NEXT_PC "next-pc" 81 OBJECT_DECLARE_SIMPLE_TYPE(NeXTPC, NEXT_PC) 82 83 /* NeXT Peripheral Controller */ 84 struct NeXTPC { 85 SysBusDevice parent_obj; 86 87 M68kCPU *cpu; 88 89 MemoryRegion floppy_mem; 90 MemoryRegion timer_mem; 91 MemoryRegion dummyen_mem; 92 MemoryRegion mmiomem; 93 MemoryRegion scrmem; 94 95 uint32_t scr1; 96 uint32_t scr2; 97 uint32_t old_scr2; 98 uint32_t int_mask; 99 uint32_t int_status; 100 uint32_t led; 101 102 NeXTSCSI next_scsi; 103 104 qemu_irq scsi_reset; 105 qemu_irq scsi_dma; 106 107 ESCCState escc; 108 109 NeXTRTC rtc; 110 qemu_irq rtc_data_irq; 111 qemu_irq rtc_cmd_reset_irq; 112 }; 113 114 typedef struct next_dma { 115 uint32_t csr; 116 117 uint32_t saved_next; 118 uint32_t saved_limit; 119 uint32_t saved_start; 120 uint32_t saved_stop; 121 122 uint32_t next; 123 uint32_t limit; 124 uint32_t start; 125 uint32_t stop; 126 127 uint32_t next_initbuf; 128 uint32_t size; 129 } next_dma; 130 131 #define TYPE_NEXT_MACHINE MACHINE_TYPE_NAME("next-cube") 132 OBJECT_DECLARE_SIMPLE_TYPE(NeXTState, NEXT_MACHINE) 133 134 struct NeXTState { 135 MachineState parent; 136 137 MemoryRegion rom; 138 MemoryRegion rom2; 139 MemoryRegion dmamem; 140 MemoryRegion bmapm1; 141 MemoryRegion bmapm2; 142 143 next_dma dma[10]; 144 }; 145 146 /* Thanks to NeXT forums for this */ 147 /* 148 static const uint8_t rtc_ram3[32] = { 149 0x94, 0x0f, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 150 0x00, 0x00, 0xfb, 0x6d, 0x00, 0x00, 0x7B, 0x00, 151 0x00, 0x00, 0x65, 0x6e, 0x00, 0x00, 0x00, 0x00, 152 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x13 153 }; 154 */ 155 static const uint8_t rtc_ram2[32] = { 156 0x94, 0x0f, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 157 0x00, 0x00, 0xfb, 0x6d, 0x00, 0x00, 0x4b, 0x00, 158 0x41, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 159 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x7e, 160 }; 161 162 #define SCR2_RTCLK 0x2 163 #define SCR2_RTDATA 0x4 164 #define SCR2_TOBCD(x) (((x / 10) << 4) + (x % 10)) 165 166 static void next_scr2_led_update(NeXTPC *s) 167 { 168 if (s->scr2 & 0x1) { 169 DPRINTF("fault!\n"); 170 s->led++; 171 if (s->led == 10) { 172 DPRINTF("LED flashing, possible fault!\n"); 173 s->led = 0; 174 } 175 } 176 } 177 178 static bool next_rtc_cmd_is_write(uint8_t cmd) 179 { 180 return (cmd >= 0x80 && cmd <= 0x9f) || 181 (cmd == 0xb1); 182 } 183 184 static void next_rtc_data_in_irq(void *opaque, int n, int level) 185 { 186 NeXTRTC *rtc = NEXT_RTC(opaque); 187 188 if (rtc->phase < 8) { 189 rtc->command = (rtc->command << 1) | level; 190 191 if (rtc->phase == 7 && !next_rtc_cmd_is_write(rtc->command)) { 192 if (rtc->command <= 0x1f) { 193 /* RAM registers */ 194 rtc->retval = rtc->ram[rtc->command]; 195 } 196 if ((rtc->command >= 0x20) && (rtc->command <= 0x2f)) { 197 /* RTC */ 198 time_t time_h = time(NULL); 199 struct tm *info = localtime(&time_h); 200 rtc->retval = 0; 201 202 switch (rtc->command) { 203 case 0x20: 204 rtc->retval = SCR2_TOBCD(info->tm_sec); 205 break; 206 case 0x21: 207 rtc->retval = SCR2_TOBCD(info->tm_min); 208 break; 209 case 0x22: 210 rtc->retval = SCR2_TOBCD(info->tm_hour); 211 break; 212 case 0x24: 213 rtc->retval = SCR2_TOBCD(info->tm_mday); 214 break; 215 case 0x25: 216 rtc->retval = SCR2_TOBCD((info->tm_mon + 1)); 217 break; 218 case 0x26: 219 rtc->retval = SCR2_TOBCD((info->tm_year - 100)); 220 break; 221 } 222 } 223 if (rtc->command == 0x30) { 224 /* read the status 0x30 */ 225 rtc->retval = rtc->status; 226 } 227 if (rtc->command == 0x31) { 228 /* read the control 0x31 */ 229 rtc->retval = rtc->control; 230 } 231 } 232 } 233 if (rtc->phase >= 8 && rtc->phase < 16) { 234 if (next_rtc_cmd_is_write(rtc->command)) { 235 /* Shift in value to write */ 236 rtc->value = (rtc->value << 1) | level; 237 } else { 238 /* Shift out value to read */ 239 if (rtc->retval & (0x80 >> (rtc->phase - 8))) { 240 qemu_irq_raise(rtc->data_out_irq); 241 } else { 242 qemu_irq_lower(rtc->data_out_irq); 243 } 244 } 245 } 246 247 rtc->phase++; 248 if (rtc->phase == 16 && next_rtc_cmd_is_write(rtc->command)) { 249 if (rtc->command >= 0x80 && rtc->command <= 0x9f) { 250 /* RAM registers */ 251 rtc->ram[rtc->command - 0x80] = rtc->value; 252 } 253 if (rtc->command == 0xb1) { 254 /* write to 0x30 register */ 255 if (rtc->value & 0x04) { 256 /* clear FTU */ 257 rtc->status = rtc->status & (~0x18); 258 qemu_irq_lower(rtc->power_irq); 259 } 260 } 261 } 262 } 263 264 static void next_scr2_rtc_update(NeXTPC *s) 265 { 266 uint8_t old_scr2, scr2_2; 267 268 old_scr2 = extract32(s->old_scr2, 8, 8); 269 scr2_2 = extract32(s->scr2, 8, 8); 270 271 if (scr2_2 & 0x1) { 272 /* DPRINTF("RTC %x phase %i\n", scr2_2, rtc->phase); */ 273 /* If we are in going down clock... do something */ 274 if (((old_scr2 & SCR2_RTCLK) != (scr2_2 & SCR2_RTCLK)) && 275 ((scr2_2 & SCR2_RTCLK) == 0)) { 276 if (scr2_2 & SCR2_RTDATA) { 277 qemu_irq_raise(s->rtc_data_irq); 278 } else { 279 qemu_irq_lower(s->rtc_data_irq); 280 } 281 } 282 } else { 283 /* else end or abort */ 284 qemu_irq_raise(s->rtc_cmd_reset_irq); 285 } 286 } 287 288 static uint64_t next_mmio_read(void *opaque, hwaddr addr, unsigned size) 289 { 290 NeXTPC *s = NEXT_PC(opaque); 291 uint64_t val; 292 293 switch (addr) { 294 case 0x2000: /* 0x2007000 */ 295 /* DPRINTF("Read INT status: %x\n", s->int_status); */ 296 val = s->int_status; 297 break; 298 299 case 0x2800: /* 0x2007800 */ 300 DPRINTF("MMIO Read INT mask: %x\n", s->int_mask); 301 val = s->int_mask; 302 break; 303 304 case 0x7000 ... 0x7003: /* 0x200c000 */ 305 val = extract32(s->scr1, (4 - (addr - 0x7000) - size) << 3, 306 size << 3); 307 break; 308 309 case 0x8000 ... 0x8003: /* 0x200d000 */ 310 val = extract32(s->scr2, (4 - (addr - 0x8000) - size) << 3, 311 size << 3); 312 break; 313 314 default: 315 val = 0; 316 DPRINTF("MMIO Read @ 0x%"HWADDR_PRIx" size %d\n", addr, size); 317 break; 318 } 319 320 return val; 321 } 322 323 static void next_mmio_write(void *opaque, hwaddr addr, uint64_t val, 324 unsigned size) 325 { 326 NeXTPC *s = NEXT_PC(opaque); 327 328 switch (addr) { 329 case 0x2000: /* 0x2007000 */ 330 DPRINTF("INT Status old: %x new: %x\n", s->int_status, 331 (unsigned int)val); 332 s->int_status = val; 333 break; 334 335 case 0x2800: /* 0x2007800 */ 336 DPRINTF("INT Mask old: %x new: %x\n", s->int_mask, (unsigned int)val); 337 s->int_mask = val; 338 break; 339 340 case 0x7000 ... 0x7003: /* 0x200c000 */ 341 DPRINTF("SCR1 Write: %x\n", (unsigned int)val); 342 s->scr1 = deposit32(s->scr1, (4 - (addr - 0x7000) - size) << 3, 343 size << 3, val); 344 break; 345 346 case 0x8000 ... 0x8003: /* 0x200d000 */ 347 s->scr2 = deposit32(s->scr2, (4 - (addr - 0x8000) - size) << 3, 348 size << 3, val); 349 next_scr2_led_update(s); 350 next_scr2_rtc_update(s); 351 s->old_scr2 = s->scr2; 352 break; 353 354 default: 355 DPRINTF("MMIO Write @ 0x%"HWADDR_PRIx " with 0x%x size %u\n", addr, 356 (unsigned int)val, size); 357 } 358 } 359 360 static const MemoryRegionOps next_mmio_ops = { 361 .read = next_mmio_read, 362 .write = next_mmio_write, 363 .valid.min_access_size = 1, 364 .valid.max_access_size = 4, 365 .endianness = DEVICE_BIG_ENDIAN, 366 }; 367 368 #define SCSICSR_ENABLE 0x01 369 #define SCSICSR_RESET 0x02 /* reset scsi dma */ 370 #define SCSICSR_FIFOFL 0x04 371 #define SCSICSR_DMADIR 0x08 /* if set, scsi to mem */ 372 #define SCSICSR_CPUDMA 0x10 /* if set, dma enabled */ 373 #define SCSICSR_INTMASK 0x20 /* if set, interrupt enabled */ 374 375 #define NEXTDMA_SCSI(x) (0x10 + x) 376 #define NEXTDMA_FD(x) (0x10 + x) 377 #define NEXTDMA_ENTX(x) (0x110 + x) 378 #define NEXTDMA_ENRX(x) (0x150 + x) 379 #define NEXTDMA_CSR 0x0 380 #define NEXTDMA_NEXT 0x4000 381 #define NEXTDMA_LIMIT 0x4004 382 #define NEXTDMA_START 0x4008 383 #define NEXTDMA_STOP 0x400c 384 #define NEXTDMA_NEXT_INIT 0x4200 385 #define NEXTDMA_SIZE 0x4204 386 387 static void next_dma_write(void *opaque, hwaddr addr, uint64_t val, 388 unsigned int size) 389 { 390 NeXTState *next_state = NEXT_MACHINE(opaque); 391 392 switch (addr) { 393 case NEXTDMA_ENRX(NEXTDMA_CSR): 394 if (val & DMA_DEV2M) { 395 next_state->dma[NEXTDMA_ENRX].csr |= DMA_DEV2M; 396 } 397 398 if (val & DMA_SETENABLE) { 399 /* DPRINTF("SCSI DMA ENABLE\n"); */ 400 next_state->dma[NEXTDMA_ENRX].csr |= DMA_ENABLE; 401 } 402 if (val & DMA_SETSUPDATE) { 403 next_state->dma[NEXTDMA_ENRX].csr |= DMA_SUPDATE; 404 } 405 if (val & DMA_CLRCOMPLETE) { 406 next_state->dma[NEXTDMA_ENRX].csr &= ~DMA_COMPLETE; 407 } 408 409 if (val & DMA_RESET) { 410 next_state->dma[NEXTDMA_ENRX].csr &= ~(DMA_COMPLETE | DMA_SUPDATE | 411 DMA_ENABLE | DMA_DEV2M); 412 } 413 /* DPRINTF("RXCSR \tWrite: %x\n",value); */ 414 break; 415 416 case NEXTDMA_ENRX(NEXTDMA_NEXT_INIT): 417 next_state->dma[NEXTDMA_ENRX].next_initbuf = val; 418 break; 419 420 case NEXTDMA_ENRX(NEXTDMA_NEXT): 421 next_state->dma[NEXTDMA_ENRX].next = val; 422 break; 423 424 case NEXTDMA_ENRX(NEXTDMA_LIMIT): 425 next_state->dma[NEXTDMA_ENRX].limit = val; 426 break; 427 428 case NEXTDMA_SCSI(NEXTDMA_CSR): 429 if (val & DMA_DEV2M) { 430 next_state->dma[NEXTDMA_SCSI].csr |= DMA_DEV2M; 431 } 432 if (val & DMA_SETENABLE) { 433 /* DPRINTF("SCSI DMA ENABLE\n"); */ 434 next_state->dma[NEXTDMA_SCSI].csr |= DMA_ENABLE; 435 } 436 if (val & DMA_SETSUPDATE) { 437 next_state->dma[NEXTDMA_SCSI].csr |= DMA_SUPDATE; 438 } 439 if (val & DMA_CLRCOMPLETE) { 440 next_state->dma[NEXTDMA_SCSI].csr &= ~DMA_COMPLETE; 441 } 442 443 if (val & DMA_RESET) { 444 next_state->dma[NEXTDMA_SCSI].csr &= ~(DMA_COMPLETE | DMA_SUPDATE | 445 DMA_ENABLE | DMA_DEV2M); 446 /* DPRINTF("SCSI DMA RESET\n"); */ 447 } 448 /* DPRINTF("RXCSR \tWrite: %x\n",value); */ 449 break; 450 451 case NEXTDMA_SCSI(NEXTDMA_NEXT): 452 next_state->dma[NEXTDMA_SCSI].next = val; 453 break; 454 455 case NEXTDMA_SCSI(NEXTDMA_LIMIT): 456 next_state->dma[NEXTDMA_SCSI].limit = val; 457 break; 458 459 case NEXTDMA_SCSI(NEXTDMA_START): 460 next_state->dma[NEXTDMA_SCSI].start = val; 461 break; 462 463 case NEXTDMA_SCSI(NEXTDMA_STOP): 464 next_state->dma[NEXTDMA_SCSI].stop = val; 465 break; 466 467 case NEXTDMA_SCSI(NEXTDMA_NEXT_INIT): 468 next_state->dma[NEXTDMA_SCSI].next_initbuf = val; 469 break; 470 471 default: 472 DPRINTF("DMA write @ %x w/ %x\n", (unsigned)addr, (unsigned)val); 473 } 474 } 475 476 static uint64_t next_dma_read(void *opaque, hwaddr addr, unsigned int size) 477 { 478 NeXTState *next_state = NEXT_MACHINE(opaque); 479 uint64_t val; 480 481 switch (addr) { 482 case NEXTDMA_SCSI(NEXTDMA_CSR): 483 DPRINTF("SCSI DMA CSR READ\n"); 484 val = next_state->dma[NEXTDMA_SCSI].csr; 485 break; 486 487 case NEXTDMA_ENRX(NEXTDMA_CSR): 488 val = next_state->dma[NEXTDMA_ENRX].csr; 489 break; 490 491 case NEXTDMA_ENRX(NEXTDMA_NEXT_INIT): 492 val = next_state->dma[NEXTDMA_ENRX].next_initbuf; 493 break; 494 495 case NEXTDMA_ENRX(NEXTDMA_NEXT): 496 val = next_state->dma[NEXTDMA_ENRX].next; 497 break; 498 499 case NEXTDMA_ENRX(NEXTDMA_LIMIT): 500 val = next_state->dma[NEXTDMA_ENRX].limit; 501 break; 502 503 case NEXTDMA_SCSI(NEXTDMA_NEXT): 504 val = next_state->dma[NEXTDMA_SCSI].next; 505 break; 506 507 case NEXTDMA_SCSI(NEXTDMA_NEXT_INIT): 508 val = next_state->dma[NEXTDMA_SCSI].next_initbuf; 509 break; 510 511 case NEXTDMA_SCSI(NEXTDMA_LIMIT): 512 val = next_state->dma[NEXTDMA_SCSI].limit; 513 break; 514 515 case NEXTDMA_SCSI(NEXTDMA_START): 516 val = next_state->dma[NEXTDMA_SCSI].start; 517 break; 518 519 case NEXTDMA_SCSI(NEXTDMA_STOP): 520 val = next_state->dma[NEXTDMA_SCSI].stop; 521 break; 522 523 default: 524 DPRINTF("DMA read @ %x\n", (unsigned int)addr); 525 val = 0; 526 } 527 528 /* 529 * once the csr's are done, subtract 0x3FEC from the addr, and that will 530 * normalize the upper registers 531 */ 532 533 return val; 534 } 535 536 static const MemoryRegionOps next_dma_ops = { 537 .read = next_dma_read, 538 .write = next_dma_write, 539 .impl.min_access_size = 4, 540 .valid.min_access_size = 4, 541 .valid.max_access_size = 4, 542 .endianness = DEVICE_BIG_ENDIAN, 543 }; 544 545 static void next_irq(void *opaque, int number, int level) 546 { 547 NeXTPC *s = NEXT_PC(opaque); 548 M68kCPU *cpu = s->cpu; 549 int shift = 0; 550 551 /* first switch sets interrupt status */ 552 /* DPRINTF("IRQ %i\n",number); */ 553 switch (number) { 554 /* level 3 - floppy, kbd/mouse, power, ether rx/tx, scsi, clock */ 555 case NEXT_FD_I: 556 shift = 7; 557 break; 558 case NEXT_KBD_I: 559 shift = 3; 560 break; 561 case NEXT_PWR_I: 562 shift = 2; 563 break; 564 case NEXT_ENRX_I: 565 shift = 9; 566 break; 567 case NEXT_ENTX_I: 568 shift = 10; 569 break; 570 case NEXT_SCSI_I: 571 shift = 12; 572 break; 573 case NEXT_CLK_I: 574 shift = 5; 575 break; 576 577 /* level 5 - scc (serial) */ 578 case NEXT_SCC_I: 579 shift = 17; 580 break; 581 582 /* level 6 - audio etherrx/tx dma */ 583 case NEXT_ENTX_DMA_I: 584 shift = 28; 585 break; 586 case NEXT_ENRX_DMA_I: 587 shift = 27; 588 break; 589 case NEXT_SCSI_DMA_I: 590 shift = 26; 591 break; 592 case NEXT_SND_I: 593 shift = 23; 594 break; 595 case NEXT_SCC_DMA_I: 596 shift = 21; 597 break; 598 599 } 600 /* 601 * this HAS to be wrong, the interrupt handlers in mach and together 602 * int_status and int_mask and return if there is a hit 603 */ 604 if (s->int_mask & (1 << shift)) { 605 DPRINTF("%x interrupt masked @ %x\n", 1 << shift, cpu->env.pc); 606 /* return; */ 607 } 608 609 /* second switch triggers the correct interrupt */ 610 if (level) { 611 s->int_status |= 1 << shift; 612 613 switch (number) { 614 /* level 3 - floppy, kbd/mouse, power, ether rx/tx, scsi, clock */ 615 case NEXT_FD_I: 616 case NEXT_KBD_I: 617 case NEXT_PWR_I: 618 case NEXT_ENRX_I: 619 case NEXT_ENTX_I: 620 case NEXT_SCSI_I: 621 case NEXT_CLK_I: 622 m68k_set_irq_level(cpu, 3, 27); 623 break; 624 625 /* level 5 - scc (serial) */ 626 case NEXT_SCC_I: 627 m68k_set_irq_level(cpu, 5, 29); 628 break; 629 630 /* level 6 - audio etherrx/tx dma */ 631 case NEXT_ENTX_DMA_I: 632 case NEXT_ENRX_DMA_I: 633 case NEXT_SCSI_DMA_I: 634 case NEXT_SND_I: 635 case NEXT_SCC_DMA_I: 636 m68k_set_irq_level(cpu, 6, 30); 637 break; 638 } 639 } else { 640 s->int_status &= ~(1 << shift); 641 cpu_reset_interrupt(CPU(cpu), CPU_INTERRUPT_HARD); 642 } 643 } 644 645 static void nextdma_write(void *opaque, uint8_t *buf, int size, int type) 646 { 647 uint32_t base_addr; 648 int irq = 0; 649 uint8_t align = 16; 650 NeXTState *next_state = NEXT_MACHINE(qdev_get_machine()); 651 652 if (type == NEXTDMA_ENRX || type == NEXTDMA_ENTX) { 653 align = 32; 654 } 655 /* Most DMA is supposedly 16 byte aligned */ 656 if ((size % align) != 0) { 657 size -= size % align; 658 size += align; 659 } 660 661 /* 662 * prom sets the dma start using initbuf while the bootloader uses next 663 * so we check to see if initbuf is 0 664 */ 665 if (next_state->dma[type].next_initbuf == 0) { 666 base_addr = next_state->dma[type].next; 667 } else { 668 base_addr = next_state->dma[type].next_initbuf; 669 } 670 671 cpu_physical_memory_write(base_addr, buf, size); 672 673 next_state->dma[type].next_initbuf = 0; 674 675 /* saved limit is checked to calculate packet size by both, rom and netbsd */ 676 next_state->dma[type].saved_limit = (next_state->dma[type].next + size); 677 next_state->dma[type].saved_next = (next_state->dma[type].next); 678 679 /* 680 * 32 bytes under savedbase seems to be some kind of register 681 * of which the purpose is unknown as of yet 682 */ 683 /* stl_phys(s->rx_dma.base-32,0xFFFFFFFF); */ 684 685 if (!(next_state->dma[type].csr & DMA_SUPDATE)) { 686 next_state->dma[type].next = next_state->dma[type].start; 687 next_state->dma[type].limit = next_state->dma[type].stop; 688 } 689 690 /* Set dma registers and raise an irq */ 691 next_state->dma[type].csr |= DMA_COMPLETE; /* DON'T CHANGE THIS! */ 692 693 switch (type) { 694 case NEXTDMA_SCSI: 695 irq = NEXT_SCSI_DMA_I; 696 break; 697 } 698 699 next_irq(opaque, irq, 1); 700 next_irq(opaque, irq, 0); 701 } 702 703 static void nextscsi_read(void *opaque, uint8_t *buf, int len) 704 { 705 DPRINTF("SCSI READ: %x\n", len); 706 abort(); 707 } 708 709 static void nextscsi_write(void *opaque, uint8_t *buf, int size) 710 { 711 DPRINTF("SCSI WRITE: %i\n", size); 712 nextdma_write(opaque, buf, size, NEXTDMA_SCSI); 713 } 714 715 static void next_scsi_csr_write(void *opaque, hwaddr addr, uint64_t val, 716 unsigned size) 717 { 718 NeXTSCSI *s = NEXT_SCSI(opaque); 719 NeXTPC *pc = NEXT_PC(container_of(s, NeXTPC, next_scsi)); 720 721 switch (addr) { 722 case 0: 723 if (val & SCSICSR_FIFOFL) { 724 DPRINTF("SCSICSR FIFO Flush\n"); 725 /* will have to add another irq to the esp if this is needed */ 726 /* esp_puflush_fifo(esp_g); */ 727 } 728 729 if (val & SCSICSR_ENABLE) { 730 DPRINTF("SCSICSR Enable\n"); 731 /* 732 * qemu_irq_raise(s->scsi_dma); 733 * s->scsi_csr_1 = 0xc0; 734 * s->scsi_csr_1 |= 0x1; 735 * qemu_irq_pulse(s->scsi_dma); 736 */ 737 } 738 /* 739 * else 740 * s->scsi_csr_1 &= ~SCSICSR_ENABLE; 741 */ 742 743 if (val & SCSICSR_RESET) { 744 DPRINTF("SCSICSR Reset\n"); 745 /* I think this should set DMADIR. CPUDMA and INTMASK to 0 */ 746 qemu_irq_raise(pc->scsi_reset); 747 s->scsi_csr_1 &= ~(SCSICSR_INTMASK | 0x80 | 0x1); 748 qemu_irq_lower(pc->scsi_reset); 749 } 750 if (val & SCSICSR_DMADIR) { 751 DPRINTF("SCSICSR DMAdir\n"); 752 } 753 if (val & SCSICSR_CPUDMA) { 754 DPRINTF("SCSICSR CPUDMA\n"); 755 /* qemu_irq_raise(s->scsi_dma); */ 756 pc->int_status |= 0x4000000; 757 } else { 758 /* fprintf(stderr,"SCSICSR CPUDMA disabled\n"); */ 759 pc->int_status &= ~(0x4000000); 760 /* qemu_irq_lower(s->scsi_dma); */ 761 } 762 if (val & SCSICSR_INTMASK) { 763 DPRINTF("SCSICSR INTMASK\n"); 764 /* 765 * int_mask &= ~0x1000; 766 * s->scsi_csr_1 |= val; 767 * s->scsi_csr_1 &= ~SCSICSR_INTMASK; 768 * if (s->scsi_queued) { 769 * s->scsi_queued = 0; 770 * next_irq(s, NEXT_SCSI_I, level); 771 * } 772 */ 773 } else { 774 /* int_mask |= 0x1000; */ 775 } 776 if (val & 0x80) { 777 /* int_mask |= 0x1000; */ 778 /* s->scsi_csr_1 |= 0x80; */ 779 } 780 DPRINTF("SCSICSR1 Write: %"PRIx64 "\n", val); 781 s->scsi_csr_1 = val; 782 break; 783 784 case 1: 785 DPRINTF("SCSICSR2 Write: %"PRIx64 "\n", val); 786 s->scsi_csr_2 = val; 787 break; 788 789 default: 790 g_assert_not_reached(); 791 } 792 } 793 794 static uint64_t next_scsi_csr_read(void *opaque, hwaddr addr, unsigned size) 795 { 796 NeXTSCSI *s = NEXT_SCSI(opaque); 797 uint64_t val; 798 799 switch (addr) { 800 case 0: 801 DPRINTF("SCSI 4020 STATUS READ %X\n", s->scsi_csr_1); 802 val = s->scsi_csr_1; 803 break; 804 805 case 1: 806 DPRINTF("SCSI 4021 STATUS READ %X\n", s->scsi_csr_2); 807 val = s->scsi_csr_2; 808 break; 809 810 default: 811 g_assert_not_reached(); 812 } 813 814 return val; 815 } 816 817 static const MemoryRegionOps next_scsi_csr_ops = { 818 .read = next_scsi_csr_read, 819 .write = next_scsi_csr_write, 820 .valid.min_access_size = 1, 821 .valid.max_access_size = 1, 822 .endianness = DEVICE_BIG_ENDIAN, 823 }; 824 825 static void next_scsi_init(Object *obj) 826 { 827 NeXTSCSI *s = NEXT_SCSI(obj); 828 SysBusDevice *sbd = SYS_BUS_DEVICE(obj); 829 830 object_initialize_child(obj, "esp", &s->sysbus_esp, TYPE_SYSBUS_ESP); 831 832 memory_region_init_io(&s->scsi_csr_mem, obj, &next_scsi_csr_ops, 833 s, "csrs", 2); 834 835 memory_region_init(&s->scsi_mem, obj, "next.scsi", 0x40); 836 sysbus_init_mmio(sbd, &s->scsi_mem); 837 } 838 839 static void next_scsi_realize(DeviceState *dev, Error **errp) 840 { 841 NeXTSCSI *s = NEXT_SCSI(dev); 842 SysBusESPState *sysbus_esp; 843 SysBusDevice *sbd; 844 ESPState *esp; 845 NeXTPC *pcdev; 846 847 pcdev = NEXT_PC(container_of(s, NeXTPC, next_scsi)); 848 849 /* ESP */ 850 sysbus_esp = SYSBUS_ESP(&s->sysbus_esp); 851 esp = &sysbus_esp->esp; 852 esp->dma_memory_read = nextscsi_read; 853 esp->dma_memory_write = nextscsi_write; 854 esp->dma_opaque = pcdev; 855 sysbus_esp->it_shift = 0; 856 esp->dma_enabled = 1; 857 sbd = SYS_BUS_DEVICE(sysbus_esp); 858 if (!sysbus_realize(sbd, errp)) { 859 return; 860 } 861 memory_region_add_subregion(&s->scsi_mem, 0x0, 862 sysbus_mmio_get_region(sbd, 0)); 863 864 /* SCSI CSRs */ 865 memory_region_add_subregion(&s->scsi_mem, 0x20, &s->scsi_csr_mem); 866 867 scsi_bus_legacy_handle_cmdline(&s->sysbus_esp.esp.bus); 868 } 869 870 static const VMStateDescription next_scsi_vmstate = { 871 .name = "next-scsi", 872 .version_id = 0, 873 .minimum_version_id = 0, 874 .fields = (const VMStateField[]) { 875 VMSTATE_UINT8(scsi_csr_1, NeXTSCSI), 876 VMSTATE_UINT8(scsi_csr_2, NeXTSCSI), 877 VMSTATE_END_OF_LIST() 878 }, 879 }; 880 881 static void next_scsi_class_init(ObjectClass *klass, void *data) 882 { 883 DeviceClass *dc = DEVICE_CLASS(klass); 884 885 dc->desc = "NeXT SCSI Controller"; 886 dc->realize = next_scsi_realize; 887 dc->vmsd = &next_scsi_vmstate; 888 } 889 890 static const TypeInfo next_scsi_info = { 891 .name = TYPE_NEXT_SCSI, 892 .parent = TYPE_SYS_BUS_DEVICE, 893 .instance_init = next_scsi_init, 894 .instance_size = sizeof(NeXTSCSI), 895 .class_init = next_scsi_class_init, 896 }; 897 898 static void next_floppy_write(void *opaque, hwaddr addr, uint64_t val, 899 unsigned size) 900 { 901 switch (addr) { 902 case 0: 903 DPRINTF("FDCSR Write: %"PRIx64 "\n", val); 904 if (val == 0x0) { 905 /* qemu_irq_raise(s->fd_irq[0]); */ 906 } 907 break; 908 909 default: 910 g_assert_not_reached(); 911 } 912 } 913 914 static uint64_t next_floppy_read(void *opaque, hwaddr addr, unsigned size) 915 { 916 uint64_t val; 917 918 switch (addr) { 919 case 0: 920 DPRINTF("FD read @ %x\n", (unsigned int)addr); 921 val = 0x40 | 0x04 | 0x2 | 0x1; 922 break; 923 924 default: 925 g_assert_not_reached(); 926 } 927 928 return val; 929 } 930 931 static const MemoryRegionOps next_floppy_ops = { 932 .read = next_floppy_read, 933 .write = next_floppy_write, 934 .valid.min_access_size = 1, 935 .valid.max_access_size = 4, 936 .endianness = DEVICE_BIG_ENDIAN, 937 }; 938 939 static void next_timer_write(void *opaque, hwaddr addr, uint64_t val, 940 unsigned size) 941 { 942 switch (addr) { 943 case 0 ... 3: 944 /* Hardware timer latch - not implemented yet */ 945 break; 946 947 default: 948 g_assert_not_reached(); 949 } 950 } 951 952 static uint64_t next_timer_read(void *opaque, hwaddr addr, unsigned size) 953 { 954 uint64_t val; 955 956 switch (addr) { 957 case 0 ... 3: 958 /* 959 * These 4 registers are the hardware timer, not sure which register 960 * is the latch instead of data, but no problems so far. 961 * 962 * Hack: We need to have the LSB change consistently to make it work 963 */ 964 val = extract32(clock(), (4 - addr - size) << 3, 965 size << 3); 966 break; 967 968 default: 969 g_assert_not_reached(); 970 } 971 972 return val; 973 } 974 975 static const MemoryRegionOps next_timer_ops = { 976 .read = next_timer_read, 977 .write = next_timer_write, 978 .valid.min_access_size = 1, 979 .valid.max_access_size = 4, 980 .endianness = DEVICE_BIG_ENDIAN, 981 }; 982 983 static void next_dummy_en_write(void *opaque, hwaddr addr, uint64_t val, 984 unsigned size) 985 { 986 /* Do nothing */ 987 return; 988 } 989 990 static uint64_t next_dummy_en_read(void *opaque, hwaddr addr, unsigned size) 991 { 992 uint64_t val; 993 994 switch (addr) { 995 case 0: 996 /* For now return dummy byte to allow the Ethernet test to timeout */ 997 val = 0xff; 998 break; 999 1000 default: 1001 val = 0; 1002 } 1003 1004 return val; 1005 } 1006 1007 static const MemoryRegionOps next_dummy_en_ops = { 1008 .read = next_dummy_en_read, 1009 .write = next_dummy_en_write, 1010 .valid.min_access_size = 1, 1011 .valid.max_access_size = 4, 1012 .endianness = DEVICE_BIG_ENDIAN, 1013 }; 1014 1015 static void next_rtc_cmd_reset_irq(void *opaque, int n, int level) 1016 { 1017 NeXTRTC *rtc = NEXT_RTC(opaque); 1018 1019 if (level) { 1020 rtc->phase = 0; 1021 rtc->command = 0; 1022 rtc->value = 0; 1023 } 1024 } 1025 1026 static void next_rtc_reset_hold(Object *obj, ResetType type) 1027 { 1028 NeXTRTC *rtc = NEXT_RTC(obj); 1029 1030 rtc->status = 0x90; 1031 1032 /* Load RTC RAM - TODO: provide possibility to load contents from file */ 1033 memcpy(rtc->ram, rtc_ram2, 32); 1034 } 1035 1036 static void next_rtc_init(Object *obj) 1037 { 1038 NeXTRTC *rtc = NEXT_RTC(obj); 1039 1040 qdev_init_gpio_in_named(DEVICE(obj), next_rtc_data_in_irq, 1041 "rtc-data-in", 1); 1042 qdev_init_gpio_out_named(DEVICE(obj), &rtc->data_out_irq, 1043 "rtc-data-out", 1); 1044 qdev_init_gpio_in_named(DEVICE(obj), next_rtc_cmd_reset_irq, 1045 "rtc-cmd-reset", 1); 1046 qdev_init_gpio_out_named(DEVICE(obj), &rtc->power_irq, 1047 "rtc-power-out", 1); 1048 } 1049 1050 static const VMStateDescription next_rtc_vmstate = { 1051 .name = "next-rtc", 1052 .version_id = 3, 1053 .minimum_version_id = 3, 1054 .fields = (const VMStateField[]) { 1055 VMSTATE_INT8(phase, NeXTRTC), 1056 VMSTATE_UINT8_ARRAY(ram, NeXTRTC, 32), 1057 VMSTATE_UINT8(command, NeXTRTC), 1058 VMSTATE_UINT8(value, NeXTRTC), 1059 VMSTATE_UINT8(status, NeXTRTC), 1060 VMSTATE_UINT8(control, NeXTRTC), 1061 VMSTATE_UINT8(retval, NeXTRTC), 1062 VMSTATE_END_OF_LIST() 1063 }, 1064 }; 1065 1066 static void next_rtc_class_init(ObjectClass *klass, void *data) 1067 { 1068 DeviceClass *dc = DEVICE_CLASS(klass); 1069 ResettableClass *rc = RESETTABLE_CLASS(klass); 1070 1071 dc->desc = "NeXT RTC"; 1072 dc->vmsd = &next_rtc_vmstate; 1073 rc->phases.hold = next_rtc_reset_hold; 1074 } 1075 1076 static const TypeInfo next_rtc_info = { 1077 .name = TYPE_NEXT_RTC, 1078 .parent = TYPE_SYS_BUS_DEVICE, 1079 .instance_init = next_rtc_init, 1080 .instance_size = sizeof(NeXTRTC), 1081 .class_init = next_rtc_class_init, 1082 }; 1083 1084 static void next_pc_rtc_data_in_irq(void *opaque, int n, int level) 1085 { 1086 NeXTPC *s = NEXT_PC(opaque); 1087 uint8_t scr2_2 = extract32(s->scr2, 8, 8); 1088 1089 if (level) { 1090 scr2_2 |= SCR2_RTDATA; 1091 } else { 1092 scr2_2 &= ~SCR2_RTDATA; 1093 } 1094 1095 s->scr2 = deposit32(s->scr2, 8, 8, scr2_2); 1096 } 1097 1098 static void next_pc_reset_hold(Object *obj, ResetType type) 1099 { 1100 NeXTPC *s = NEXT_PC(obj); 1101 1102 /* Set internal registers to initial values */ 1103 /* 0x0000XX00 << vital bits */ 1104 s->scr1 = 0x00011102; 1105 s->scr2 = 0x00ff0c80; 1106 s->old_scr2 = s->scr2; 1107 } 1108 1109 static void next_pc_realize(DeviceState *dev, Error **errp) 1110 { 1111 NeXTPC *s = NEXT_PC(dev); 1112 SysBusDevice *sbd; 1113 DeviceState *d; 1114 1115 /* SCSI */ 1116 sbd = SYS_BUS_DEVICE(&s->next_scsi); 1117 if (!sysbus_realize(sbd, errp)) { 1118 return; 1119 } 1120 1121 d = DEVICE(object_resolve_path_component(OBJECT(&s->next_scsi), "esp")); 1122 sysbus_connect_irq(SYS_BUS_DEVICE(d), 0, 1123 qdev_get_gpio_in(DEVICE(s), NEXT_SCSI_I)); 1124 1125 s->scsi_reset = qdev_get_gpio_in(d, 0); 1126 s->scsi_dma = qdev_get_gpio_in(d, 1); 1127 1128 /* ESCC */ 1129 d = DEVICE(&s->escc); 1130 qdev_prop_set_uint32(d, "disabled", 0); 1131 qdev_prop_set_uint32(d, "frequency", 9600 * 384); 1132 qdev_prop_set_uint32(d, "it_shift", 0); 1133 qdev_prop_set_bit(d, "bit_swap", true); 1134 qdev_prop_set_chr(d, "chrB", serial_hd(1)); 1135 qdev_prop_set_chr(d, "chrA", serial_hd(0)); 1136 qdev_prop_set_uint32(d, "chnBtype", escc_serial); 1137 qdev_prop_set_uint32(d, "chnAtype", escc_serial); 1138 1139 sbd = SYS_BUS_DEVICE(d); 1140 if (!sysbus_realize(sbd, errp)) { 1141 return; 1142 } 1143 sysbus_connect_irq(sbd, 0, qdev_get_gpio_in(dev, NEXT_SCC_I)); 1144 sysbus_connect_irq(sbd, 1, qdev_get_gpio_in(dev, NEXT_SCC_DMA_I)); 1145 1146 /* RTC */ 1147 d = DEVICE(&s->rtc); 1148 if (!sysbus_realize(SYS_BUS_DEVICE(d), errp)) { 1149 return; 1150 } 1151 /* Data from NeXTPC to RTC */ 1152 qdev_connect_gpio_out_named(dev, "rtc-data-out", 0, 1153 qdev_get_gpio_in_named(d, "rtc-data-in", 0)); 1154 /* Data from RTC to NeXTPC */ 1155 qdev_connect_gpio_out_named(d, "rtc-data-out", 0, 1156 qdev_get_gpio_in_named(dev, 1157 "rtc-data-in", 0)); 1158 qdev_connect_gpio_out_named(dev, "rtc-cmd-reset", 0, 1159 qdev_get_gpio_in_named(d, "rtc-cmd-reset", 0)); 1160 qdev_connect_gpio_out_named(d, "rtc-power-out", 0, 1161 qdev_get_gpio_in(dev, NEXT_PWR_I)); 1162 } 1163 1164 static void next_pc_init(Object *obj) 1165 { 1166 NeXTPC *s = NEXT_PC(obj); 1167 SysBusDevice *sbd = SYS_BUS_DEVICE(obj); 1168 1169 qdev_init_gpio_in(DEVICE(obj), next_irq, NEXT_NUM_IRQS); 1170 1171 memory_region_init_io(&s->mmiomem, OBJECT(s), &next_mmio_ops, s, 1172 "next.mmio", 0x9000); 1173 sysbus_init_mmio(sbd, &s->mmiomem); 1174 1175 memory_region_init_io(&s->dummyen_mem, OBJECT(s), &next_dummy_en_ops, s, 1176 "next.en", 0x20); 1177 sysbus_init_mmio(sbd, &s->dummyen_mem); 1178 1179 object_initialize_child(obj, "next-scsi", &s->next_scsi, TYPE_NEXT_SCSI); 1180 sysbus_init_mmio(sbd, 1181 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->next_scsi), 0)); 1182 1183 memory_region_init_io(&s->floppy_mem, OBJECT(s), &next_floppy_ops, s, 1184 "next.floppy", 4); 1185 sysbus_init_mmio(sbd, &s->floppy_mem); 1186 1187 object_initialize_child(obj, "escc", &s->escc, TYPE_ESCC); 1188 sysbus_init_mmio(sbd, 1189 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->escc), 0)); 1190 1191 memory_region_init_io(&s->timer_mem, OBJECT(s), &next_timer_ops, s, 1192 "next.timer", 4); 1193 sysbus_init_mmio(sbd, &s->timer_mem); 1194 1195 object_initialize_child(obj, "rtc", &s->rtc, TYPE_NEXT_RTC); 1196 1197 qdev_init_gpio_in_named(DEVICE(obj), next_pc_rtc_data_in_irq, 1198 "rtc-data-in", 1); 1199 qdev_init_gpio_out_named(DEVICE(obj), &s->rtc_data_irq, 1200 "rtc-data-out", 1); 1201 qdev_init_gpio_out_named(DEVICE(obj), &s->rtc_cmd_reset_irq, 1202 "rtc-cmd-reset", 1); 1203 } 1204 1205 /* 1206 * If the m68k CPU implemented its inbound irq lines as GPIO lines 1207 * rather than via the m68k_set_irq_level() function we would not need 1208 * this cpu link property and could instead provide outbound IRQ lines 1209 * that the board could wire up to the CPU. 1210 */ 1211 static const Property next_pc_properties[] = { 1212 DEFINE_PROP_LINK("cpu", NeXTPC, cpu, TYPE_M68K_CPU, M68kCPU *), 1213 }; 1214 1215 static const VMStateDescription next_pc_vmstate = { 1216 .name = "next-pc", 1217 .version_id = 4, 1218 .minimum_version_id = 4, 1219 .fields = (const VMStateField[]) { 1220 VMSTATE_UINT32(scr1, NeXTPC), 1221 VMSTATE_UINT32(scr2, NeXTPC), 1222 VMSTATE_UINT32(old_scr2, NeXTPC), 1223 VMSTATE_UINT32(int_mask, NeXTPC), 1224 VMSTATE_UINT32(int_status, NeXTPC), 1225 VMSTATE_UINT32(led, NeXTPC), 1226 VMSTATE_END_OF_LIST() 1227 }, 1228 }; 1229 1230 static void next_pc_class_init(ObjectClass *klass, void *data) 1231 { 1232 DeviceClass *dc = DEVICE_CLASS(klass); 1233 ResettableClass *rc = RESETTABLE_CLASS(klass); 1234 1235 dc->desc = "NeXT Peripheral Controller"; 1236 dc->realize = next_pc_realize; 1237 device_class_set_props(dc, next_pc_properties); 1238 dc->vmsd = &next_pc_vmstate; 1239 rc->phases.hold = next_pc_reset_hold; 1240 } 1241 1242 static const TypeInfo next_pc_info = { 1243 .name = TYPE_NEXT_PC, 1244 .parent = TYPE_SYS_BUS_DEVICE, 1245 .instance_init = next_pc_init, 1246 .instance_size = sizeof(NeXTPC), 1247 .class_init = next_pc_class_init, 1248 }; 1249 1250 static void next_cube_init(MachineState *machine) 1251 { 1252 NeXTState *m = NEXT_MACHINE(machine); 1253 M68kCPU *cpu; 1254 CPUM68KState *env; 1255 MemoryRegion *sysmem = get_system_memory(); 1256 const char *bios_name = machine->firmware ?: ROM_FILE; 1257 DeviceState *pcdev; 1258 1259 /* Initialize the cpu core */ 1260 cpu = M68K_CPU(cpu_create(machine->cpu_type)); 1261 if (!cpu) { 1262 error_report("Unable to find m68k CPU definition"); 1263 exit(1); 1264 } 1265 env = &cpu->env; 1266 1267 /* Initialize CPU registers. */ 1268 env->vbr = 0; 1269 env->sr = 0x2700; 1270 1271 /* Peripheral Controller */ 1272 pcdev = qdev_new(TYPE_NEXT_PC); 1273 object_property_set_link(OBJECT(pcdev), "cpu", OBJECT(cpu), &error_abort); 1274 sysbus_realize_and_unref(SYS_BUS_DEVICE(pcdev), &error_fatal); 1275 1276 /* 64MB RAM starting at 0x04000000 */ 1277 memory_region_add_subregion(sysmem, 0x04000000, machine->ram); 1278 1279 /* Framebuffer */ 1280 sysbus_create_simple(TYPE_NEXTFB, 0x0B000000, NULL); 1281 1282 /* MMIO */ 1283 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 0, 0x02005000); 1284 1285 /* BMAP IO - acts as a catch-all for now */ 1286 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 1, 0x02100000); 1287 1288 /* en network (dummy) */ 1289 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 1, 0x02106000); 1290 1291 /* unknown: Brightness control register? */ 1292 empty_slot_init("next.unknown.0", 0x02110000, 0x10); 1293 /* unknown: Magneto-Optical drive controller? */ 1294 empty_slot_init("next.unknown.1", 0x02112000, 0x10); 1295 1296 /* SCSI */ 1297 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 2, 0x02114000); 1298 /* Floppy */ 1299 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 3, 0x02114108); 1300 /* ESCC */ 1301 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 4, 0x02118000); 1302 1303 /* unknown: Serial clock configuration register? */ 1304 empty_slot_init("next.unknown.2", 0x02118004, 0x10); 1305 1306 /* Timer */ 1307 sysbus_mmio_map(SYS_BUS_DEVICE(pcdev), 5, 0x0211a000); 1308 1309 /* BMAP memory */ 1310 memory_region_init_ram_flags_nomigrate(&m->bmapm1, NULL, "next.bmapmem", 1311 64, RAM_SHARED, &error_fatal); 1312 memory_region_add_subregion(sysmem, 0x020c0000, &m->bmapm1); 1313 /* The Rev_2.5_v66.bin firmware accesses it at 0x820c0020, too */ 1314 memory_region_init_alias(&m->bmapm2, NULL, "next.bmapmem2", &m->bmapm1, 1315 0x0, 64); 1316 memory_region_add_subregion(sysmem, 0x820c0000, &m->bmapm2); 1317 1318 /* KBD */ 1319 sysbus_create_simple(TYPE_NEXTKBD, 0x0200e000, NULL); 1320 1321 /* Load ROM here */ 1322 memory_region_init_rom(&m->rom, NULL, "next.rom", 0x20000, &error_fatal); 1323 memory_region_add_subregion(sysmem, 0x01000000, &m->rom); 1324 memory_region_init_alias(&m->rom2, NULL, "next.rom2", &m->rom, 0x0, 1325 0x20000); 1326 memory_region_add_subregion(sysmem, 0x0, &m->rom2); 1327 if (load_image_targphys(bios_name, 0x01000000, 0x20000) < 8) { 1328 if (!qtest_enabled()) { 1329 error_report("Failed to load firmware '%s'.", bios_name); 1330 } 1331 } else { 1332 uint8_t *ptr; 1333 /* Initial PC is always at offset 4 in firmware binaries */ 1334 ptr = rom_ptr(0x01000004, 4); 1335 g_assert(ptr != NULL); 1336 env->pc = ldl_be_p(ptr); 1337 if (env->pc >= 0x01020000) { 1338 error_report("'%s' does not seem to be a valid firmware image.", 1339 bios_name); 1340 exit(1); 1341 } 1342 } 1343 1344 /* DMA */ 1345 memory_region_init_io(&m->dmamem, NULL, &next_dma_ops, machine, 1346 "next.dma", 0x5000); 1347 memory_region_add_subregion(sysmem, 0x02000000, &m->dmamem); 1348 } 1349 1350 static void next_machine_class_init(ObjectClass *oc, void *data) 1351 { 1352 MachineClass *mc = MACHINE_CLASS(oc); 1353 1354 mc->desc = "NeXT Cube"; 1355 mc->init = next_cube_init; 1356 mc->block_default_type = IF_SCSI; 1357 mc->default_ram_size = RAM_SIZE; 1358 mc->default_ram_id = "next.ram"; 1359 mc->default_cpu_type = M68K_CPU_TYPE_NAME("m68040"); 1360 mc->no_cdrom = true; 1361 } 1362 1363 static const TypeInfo next_typeinfo = { 1364 .name = TYPE_NEXT_MACHINE, 1365 .parent = TYPE_MACHINE, 1366 .class_init = next_machine_class_init, 1367 .instance_size = sizeof(NeXTState), 1368 }; 1369 1370 static void next_register_type(void) 1371 { 1372 type_register_static(&next_typeinfo); 1373 type_register_static(&next_pc_info); 1374 type_register_static(&next_scsi_info); 1375 type_register_static(&next_rtc_info); 1376 } 1377 1378 type_init(next_register_type) 1379