| Previous | 15994 Revisions | Next |
| r3487 Friday 24th October, 2008 at 13:22:00 UTC by Wilbert Pol |
|---|
| [NES] Pass the correct memory region to the sound chip. Should fix bug #1672. |
| [ROOT] | makefile |
| [hash] | gamegear.hsi |
| [src/emu] | cpuexec.h cpuintrf.c |
| [src/emu/cpu] | cpu.mak |
| [src/emu/cpu/i8x41] | i8x41.c |
| [src/emu/cpu/m6502] | m6502.c |
| [src/emu/machine] | 8237dma.c 8237dma.h i2cmem.c mc146818.c pic8259.c |
| [src/mame/machine] | pckeybrd.c |
| [src/mame/video] | ppu2c0x.h tia.c |
| [src/mess] | mess.mak messdriv.c |
| [src/mess/devices] | cassette.c |
| [src/mess/drivers] | a2600.c nes.c pc.c pcfx.c |
| [src/mess/machine] | at.c bebox.c c64.c nec765.c nes_mmc.c pc.c pc_fdc.c pc_hdc.c |
| [src/mess/video] | crtc_ega.c crtc_ega.h pc_ega.c pc_video.c |
| [src/osd/sdl] | input.c |
| r3486 | r3487 | |
|---|---|---|
| 370 | 370 | </hash> |
| 371 | 371 | <hash crc32="c888222b" sha1="b6a13d51c72b576738f0d7e8e328db2ffeb0b38c" name="Fantastic Dizzy (U) [S]"> |
| 372 | 372 | <status>GoodGG Verified Image</status> |
| 373 | <extrainfo>GGSMS</extrainfo> | |
| 374 | ||
| 373 | <extrainfo>GGSMS,CODEMASTERS</extrainfo> | |
| 375 | 374 | </hash> |
| 376 | 375 | <hash crc32="d69097e8" sha1="5951d500d6f53b0537f045adb85d94068a838f32" name="Fantasy Zone Gear (JU)"> |
| 377 | 376 | <status>GoodGG Verified Image</status> |
| r3486 | r3487 | |
|---|---|---|
| 26 | 26 | /* AT keyboard documentation comes from www.beyondlogic.org and HelpPC documentation */ |
| 27 | 27 | |
| 28 | 28 | /* to enable logging of keyboard read/writes */ |
| 29 | #define LOG_KEYBOARD | |
| 29 | #define LOG_KEYBOARD 1 | |
| 30 | 30 | |
| 31 | 31 | |
| 32 | 32 | /* |
| r3486 | r3487 | |
| 750 | 750 | |
| 751 | 751 | at_clear_buffer_and_acknowledge(); |
| 752 | 752 | |
| 753 | // /* acknowledge */ | |
| 754 | // at_keyboard_queue_insert(0xfa); | |
| 753 | // /* acknowledge */ | |
| 754 | // at_keyboard_queue_insert(0xfa); | |
| 755 | 755 | /* BAT completion code */ |
| 756 | 756 | at_keyboard_queue_insert(0xaa); |
| 757 | 757 | break; |
| r3486 | r3487 | |
|---|---|---|
| 611 | 611 | } |
| 612 | 612 | else |
| 613 | 613 | { |
| 614 | drawPF(temp, linePF); | |
| 615 | drawBL(temp, lineBL); | |
| 614 | if ( CTRLPF & 2 ) { | |
| 615 | drawBL(temp, lineBL); | |
| 616 | drawPF(temp, linePF); | |
| 617 | } else { | |
| 618 | drawPF(temp, linePF); | |
| 619 | drawBL(temp, lineBL); | |
| 620 | } | |
| 616 | 621 | drawS1(temp, lineP1); |
| 617 | 622 | drawM1(temp, lineM1); |
| 618 | 623 | drawS0(temp, lineP0); |
| r3486 | r3487 | |
| 766 | 771 | } |
| 767 | 772 | else |
| 768 | 773 | { |
| 769 | drawPF(temp, linePF); | |
| 770 | drawBL(temp, lineBL); | |
| 774 | if ( CTRLPF & 2 ) { | |
| 775 | drawBL(temp, lineBL); | |
| 776 | drawPF(temp, linePF); | |
| 777 | } else { | |
| 778 | drawPF(temp, linePF); | |
| 779 | drawBL(temp, lineBL); | |
| 780 | } | |
| 771 | 781 | drawS1(temp, lineP1); |
| 772 | 782 | drawM1(temp, lineM1); |
| 773 | 783 | drawS0(temp, lineP0); |
| r3486 | r3487 | |
|---|---|---|
| 19 | 19 | #define PPU_MIRROR_HIGH 3 |
| 20 | 20 | #define PPU_MIRROR_LOW 4 |
| 21 | 21 | #define PPU_MIRROR_4SCREEN 5 // Same effect as NONE, but signals that we should never mirror |
| 22 | #define PPU_MIRROR_CUSTOM 6 /* Custom mirroring handled by driver */ | |
| 22 | 23 | |
| 23 | 24 | /* registers definition */ |
| 24 | 25 | enum |
| r3486 | r3487 | |
| 83 | 84 | typedef void (*ppu2c0x_hblank_cb)( int num, int scanline, int vblank, int blanked ); |
| 84 | 85 | typedef void (*ppu2c0x_nmi_cb)( int num, int *ppu_regs ); |
| 85 | 86 | typedef int (*ppu2c0x_vidaccess_cb)( int num, int address, int data ); |
| 87 | typedef UINT8* (*ppu2c0x_custpage_cb)( int num, int page, UINT8 *vram_base ); | |
| 86 | 88 | |
| 87 | 89 | typedef struct _ppu2c0x_interface ppu2c0x_interface; |
| 88 | 90 | struct _ppu2c0x_interface |
| r3486 | r3487 | |
| 113 | 115 | void ppu2c0x_set_scanline_callback( int num, ppu2c0x_scanline_cb cb ); |
| 114 | 116 | void ppu2c0x_set_hblank_callback( int num, ppu2c0x_scanline_cb cb ); |
| 115 | 117 | void ppu2c0x_set_vidaccess_callback( int num, ppu2c0x_vidaccess_cb cb ); |
| 118 | void ppu2c0x_set_custpage_callback( int num, ppu2c0x_custpage_cb cb ); | |
| 116 | 119 | void ppu2c0x_set_scanlines_per_frame( int num, int scanlines ); |
| 117 | 120 | |
| 118 | 121 | //27/12/2002 |
| r3486 | r3487 | |
|---|---|---|
| 1217 | 1217 | |
| 1218 | 1218 | if (window != NULL && window->xy_to_render_target(window, event.button.x,event.button.y, &cx, &cy) ) |
| 1219 | 1219 | { |
| 1220 | printf("click. cx = %d, cy = %d\n", cx, cy ); | |
| 1220 | 1221 | ui_input_push_mouse_up_event(machine, window->target, cx, cy); |
| 1221 | 1222 | } |
| 1222 | 1223 | } |
| r3486 | r3487 | |
|---|---|---|
| 738 | 738 | $(I86DEPS) |
| 739 | 739 | |
| 740 | 740 | $(CPUOBJ)/i86/i286.o: $(CPUSRC)/i86/i86.c \ |
| 741 | $(CPUSRC)/i86/instr86.c \ | |
| 741 | 742 | $(CPUSRC)/i86/instr286.c \ |
| 742 | 743 | $(CPUSRC)/i86/i286intf.h \ |
| 743 | 744 | $(I86DEPS) |
| r3486 | r3487 | |
| 1504 | 1505 | |
| 1505 | 1506 | |
| 1506 | 1507 | #------------------------------------------------- |
| 1508 | # Texas Instruments TMS0980 | |
| 1509 | #------------------------------------------------- | |
| 1510 | ||
| 1511 | CPUDEFS += -DHAS_TMS0980=$(if $(filter TMS0980,$(CPUS)),1,0) | |
| 1512 | ||
| 1513 | ifneq ($(filter TMS0980,$(CPUS)),) | |
| 1514 | OBJDIRS += $(CPUOBJ)/tms0980 | |
| 1515 | CPUOBJS += $(CPUOBJ)/tms0980/tms0980.o | |
| 1516 | DBGOBJS += $(CPUOBJ)/tms0980/tms0980d.o | |
| 1517 | endif | |
| 1518 | ||
| 1519 | $(CPUOBJ)/tms0980/tms0980.o: $(CPUSRC)/tms0980/tms0980.c \ | |
| 1520 | $(CPUSRC)/tms0980/tms0980.h | |
| 1521 | ||
| 1522 | $(CPUOBJ)/tms0980/tms0980d.o: $(CPUSRC)/tms0980/tms0980d.c \ | |
| 1523 | $(CPUSRC)/tms0980/tms0980.h | |
| 1524 | ||
| 1525 | ||
| 1526 | ||
| 1527 | #------------------------------------------------- | |
| 1507 | 1528 | # Texas Instruments TMS7000 series |
| 1508 | 1529 | #------------------------------------------------- |
| 1509 | 1530 |
| r3486 | r3487 | |
|---|---|---|
| 219 | 219 | m6502.pending_irq = 0; |
| 220 | 220 | } |
| 221 | 221 | |
| 222 | #define NR_OPS 258 | |
| 223 | #define MAX_OP_LEN 32 | |
| 224 | enum { | |
| 225 | OP_FETCH=1, /* Opcode fetch, increase pc */ | |
| 226 | FETCH, /* Fetch a byte from memory, store byte in tmp */ | |
| 227 | STORE, /* Store a byte in memory writes byte from tmp */ | |
| 228 | /* Basic instructions */ | |
| 229 | /* 1st pass instructions */ | |
| 230 | _BPL, _BMI, _BVC, _BVS, _BCC, _BCS, _BNE, _BEQ, | |
| 231 | _ADC, _ANC, _AND, _ARR, _ASL, _ASR, _AST, _ASX, _AXA, _BIT, _BRK, _CLC, _CLD, _CLI, _CLV, _CMP, _CPX, _CPY, | |
| 232 | _DCP, _DEC, _DEX, _DEY, _EOR, _INC, _INX, _INY, _ISB, _JMP, _JSR, _KIL, | |
| 233 | _LAX, _LDA, _LDX, _LDY, _LSR, _OAL, _NOP, _ORA, _PHA, _PHP, _PLA, _PLP, _RLA, _ROL, _ROR, _RTI, _RRA, _RTS, | |
| 234 | _SAH, _SAX, _SBC, _SEC, _SED, _SEI, _SLO, _SRE, _SSH, _STA, _STX, _STY, _SXH, _SYH, _TAX, _TAY, _TSX, _TXA, _TXS, _TYA, | |
| 235 | /* addressing modes */ | |
| 236 | _EA_ABS, _EA_ABX_NP, _EA_ABX_P, _EA_ABY_NP, _EA_ABY_P, _EA_IND, _EA_IDX, _EA_IDY_NP, _EA_IDY_P, _EA_ZPG, _EA_ZPX, _EA_ZPY, | |
| 237 | _RD_DUM, _RD_IMM, | |
| 238 | _RD_EA, _WR_EA, | |
| 239 | _WB_ACC, _RD_ACC, | |
| 240 | ||
| 241 | /* | |
| 242 | _EA_ZPG: _RD_OP, _WB_ZP, _WB_EA_ZP | |
| 243 | _EA_ZPX: _RD_OP, _WB_ZP, _Z_IDX, _WB_EA_ZP | |
| 244 | _EA_ZPY: _RD_OP, _WB_ZP, _Z_IDY, _WB_EA_ZP | |
| 245 | _EA_ABS: _RD_OP, _WB_EAL, _RD_OP, _WB_EAH | |
| 246 | _EA_ABX_NP: _RD_OP, _WB_EAL, _RD_OP, _WB_EAH, _IDX, _RD_EA, _EA_C, (_RD_EA/_WR_EA) | |
| 247 | _EA_ABX_P: _RD_OP, _WB_EAL, _RD_OP, _WB_EAH, _IDX, _RD_EA, _EA_C, (_RD_EA_C/_WR_EA_C) | |
| 248 | _EA_ABY_NP: _RD_OP, _WB_EAL, _RD_OP, _WB_EAH, _IDX, _RD_EA, _EA_C, (_RD_EA/_WR_EA) | |
| 249 | */ | |
| 250 | }; | |
| 251 | ||
| 252 | static const int m6502_ops[NR_OPS][MAX_OP_LEN] = { | |
| 253 | /* 0x00 - 0x0F */ | |
| 254 | { _BRK, OP_FETCH }, /* 00 - 7 BRK */ | |
| 255 | { _EA_IDX, _RD_EA, _ORA, OP_FETCH }, /* 01 - 6 ORA IDX */ | |
| 256 | { _KIL, OP_FETCH }, /* 02 - 1 KIL */ | |
| 257 | { _EA_IDX, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 03 - 7 SLO IDX */ | |
| 258 | { _EA_ZPG, _RD_EA, _NOP, OP_FETCH }, /* 04 - 3 NOP ZPG */ | |
| 259 | { _EA_ZPG, _RD_EA, _ORA, OP_FETCH }, /* 05 - 3 ORA ZPG */ | |
| 260 | { _EA_ZPG, _RD_EA, _WR_EA, _ASL, _WR_EA, OP_FETCH }, /* 06 - 5 ASL ZPG */ | |
| 261 | { _EA_ZPG, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 07 - 5 SLO ZPG */ | |
| 262 | { _RD_DUM, _PHP, OP_FETCH }, /* 08 - 3 PHP */ | |
| 263 | { _RD_IMM, _ORA, OP_FETCH }, /* 09 - 2 ORA IMM */ | |
| 264 | { _RD_DUM, _RD_ACC, _ASL, _WB_ACC, OP_FETCH }, /* 0a - 2 ASL A */ | |
| 265 | { _RD_IMM, _ANC, OP_FETCH }, /* 0b - 2 ANC IMM */ | |
| 266 | { _EA_ABS, _RD_EA, _NOP, OP_FETCH }, /* 0c - 4 NOP ABS */ | |
| 267 | { _EA_ABS, _RD_EA, _ORA, OP_FETCH }, /* 0d - 4 ORA ABS */ | |
| 268 | { _EA_ABS, _RD_EA, _WR_EA, _ASL, _WR_EA, OP_FETCH }, /* 0e - 6 ASL ABS */ | |
| 269 | { _EA_ABS, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 0f - 6 SLO ABS */ | |
| 270 | /* 0x10 - 0x1F */ | |
| 271 | { _BPL, OP_FETCH }, /* 10 - 2-4 BPL REL */ | |
| 272 | { _EA_IDY_P, _RD_EA, _ORA, OP_FETCH }, /* 11 - 5 ORA IDY page penalty */ | |
| 273 | { _KIL, OP_FETCH }, /* 12 - 1 KIL */ | |
| 274 | { _EA_IDY_NP, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 13 - 7 SLO IDY */ | |
| 275 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* 14 - 4 NOP ZPX */ | |
| 276 | { _EA_ZPX, _RD_EA, _ORA, OP_FETCH }, /* 15 - 4 ORA ZPX */ | |
| 277 | { _EA_ZPX, _RD_EA, _WR_EA, _ASL, _WR_EA, OP_FETCH }, /* 16 - 4 ASL ZPG */ | |
| 278 | { _EA_ZPX, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 17 - 6 SLO ZPX */ | |
| 279 | { _RD_DUM, _CLC, OP_FETCH }, /* 18 - 2 CLC */ | |
| 280 | { _EA_ABY_P, _RD_EA, _ORA, OP_FETCH }, /* 19 - 4 ORA ABY page penalty */ | |
| 281 | { _RD_DUM, _NOP, OP_FETCH }, /* 1a - 2 NOP */ | |
| 282 | { _EA_ABY_NP, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 1b - 7 SLO ABY */ | |
| 283 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* 1c - NOP ABX page penalty */ | |
| 284 | { _EA_ABX_P, _RD_EA, _ORA, OP_FETCH }, /* 1d - ORA ABX page penalty */ | |
| 285 | { _EA_ABX_NP, _RD_EA, _WR_EA, _ASL, _WR_EA, OP_FETCH }, /* 1e - 7 ASL ABX */ | |
| 286 | { _EA_ABX_NP, _RD_EA, _WR_EA, _SLO, _WR_EA, OP_FETCH }, /* 1f - 7 SLA ABX */ | |
| 287 | /* 0x20 - 0x2F */ | |
| 288 | { _JSR, OP_FETCH }, /* 20 - 6 JSR */ | |
| 289 | { _EA_IDX, _RD_EA, _AND, OP_FETCH }, /* 21 - 6 AND IDX */ | |
| 290 | { _KIL, OP_FETCH }, /* 22 - 1 KIL */ | |
| 291 | { _EA_IDX, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 23 - 7 RLA IDX */ | |
| 292 | { _EA_ZPG, _RD_EA, _BIT, OP_FETCH }, /* 24 - 3 BIT ZPG */ | |
| 293 | { _EA_ZPG, _RD_EA, _AND, OP_FETCH }, /* 25 - 3 AND ZPG */ | |
| 294 | { _EA_ZPG, _RD_EA, _WR_EA, _ROL, _WR_EA, OP_FETCH }, /* 26 - 5 ROL ZPG */ | |
| 295 | { _EA_ZPG, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 27 - 5 RLA ZPG */ | |
| 296 | { _RD_DUM, _PLP, OP_FETCH }, /* 28 - 4 PLP */ | |
| 297 | { _RD_IMM, _AND, OP_FETCH }, /* 29 - 2 AND IMM */ | |
| 298 | { _RD_DUM, _RD_ACC, _ROL, _WB_ACC, OP_FETCH }, /* 2a - 2 ROL A */ | |
| 299 | { _RD_IMM, _ANC, OP_FETCH }, /* 2b - 2 ANC IMM */ | |
| 300 | { _EA_ABS, _RD_EA, _BIT, OP_FETCH }, /* 2c - 4 BIT ABS */ | |
| 301 | { _EA_ABS, _RD_EA, _AND, OP_FETCH }, /* 2d - 4 AND ABS */ | |
| 302 | { _EA_ABS, _RD_EA, _WR_EA, _ROL, _WR_EA, OP_FETCH }, /* 2e - 6 ROL ABS */ | |
| 303 | { _EA_ABS, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 2f - 6 RLA ABS */ | |
| 304 | /* 0x30 - 0x3F */ | |
| 305 | { _BMI, OP_FETCH }, /* 30 - 2-4 BMI REL */ | |
| 306 | { _EA_IDY_P, _RD_EA, _AND, OP_FETCH }, /* 31 - 5 AND IDY page penalty */ | |
| 307 | { _KIL, OP_FETCH }, /* 32 - 1 KIL */ | |
| 308 | { _EA_IDY_NP, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 33 - 7 RLA IDY */ | |
| 309 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* 34 - 4 NOP ZPX */ | |
| 310 | { _EA_ZPX, _RD_EA, _AND, OP_FETCH }, /* 35 - 4 AND ZPX */ | |
| 311 | { _EA_ZPX, _RD_EA, _WR_EA, _ROL, _WR_EA, OP_FETCH }, /* 36 - 6 ROL ZPX */ | |
| 312 | { _EA_ZPX, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 37 - 6 RLA ZPX */ | |
| 313 | { _RD_DUM, _SEC, OP_FETCH }, /* 38 - 2 SEC */ | |
| 314 | { _EA_ABY_P, _RD_EA, _AND, OP_FETCH }, /* 39 - 4 AND ABY page penalty */ | |
| 315 | { _RD_DUM, _NOP, OP_FETCH }, /* 3a - 2 NOP */ | |
| 316 | { _EA_ABY_NP, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 3b - 7 RLA ABY */ | |
| 317 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* 3c - 4 NOP ABX page penalty */ | |
| 318 | { _EA_ABX_P, _RD_EA, _AND, OP_FETCH }, /* 3d - 4 AND ABX page penalty */ | |
| 319 | { _EA_ABX_NP, _RD_EA, _WR_EA, _ROL, _WR_EA, OP_FETCH }, /* 3e - 7 ROL ABX */ | |
| 320 | { _EA_ABX_NP, _RD_EA, _WR_EA, _RLA, _WR_EA, OP_FETCH }, /* 3f - 7 RLA ABX */ | |
| 321 | /* 0x40 - 0x4F */ | |
| 322 | { _RTI, OP_FETCH }, /* 40 - 6 RTI */ | |
| 323 | { _EA_IDX, _RD_EA, _EOR, OP_FETCH }, /* 41 - 6 EOR IDX */ | |
| 324 | { _KIL, OP_FETCH }, /* 42 - 1 KIL */ | |
| 325 | { _EA_IDX, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 43 - 7 SRE IDX */ | |
| 326 | { _EA_ZPG, _RD_EA, _NOP, OP_FETCH }, /* 44 - 3 NOP ZPG */ | |
| 327 | { _EA_ZPG, _RD_EA, _EOR, OP_FETCH }, /* 45 - 3 EOR ZPG */ | |
| 328 | { _EA_ZPG, _RD_EA, _WR_EA, _LSR, _WR_EA, OP_FETCH }, /* 46 - 5 LSR ZPG */ | |
| 329 | { _EA_ZPG, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 47 - 5 SRE ZPG */ | |
| 330 | { _RD_DUM, _PHA, OP_FETCH }, /* 48 - 3 PHA */ | |
| 331 | { _RD_IMM, _EOR, OP_FETCH }, /* 49 - 2 EOR IMM */ | |
| 332 | { _RD_DUM, _RD_ACC, _ROL, _WB_ACC, OP_FETCH }, /* 4a - 2 LSR A */ | |
| 333 | { _RD_IMM, _ASR, _WB_ACC, OP_FETCH }, /* 4b - 2 ASR IMM */ | |
| 334 | { _EA_ABS, _JMP, OP_FETCH }, /* 4c - 3 JMP ABS */ | |
| 335 | { _EA_ABS, _RD_EA, _EOR, OP_FETCH }, /* 4d - 4 EOR ABS */ | |
| 336 | { _EA_ABS, _RD_EA, _WR_EA, _LSR, _WR_EA, OP_FETCH }, /* 4e - 6 LSR ABS */ | |
| 337 | { _EA_ABS, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 4f - 6 SRE ABS */ | |
| 338 | /* 0x50 - 0x5F */ | |
| 339 | { _BVC, OP_FETCH }, /* 50 - 2-4 BVC REL */ | |
| 340 | { _EA_IDY_P, _RD_EA, _EOR, OP_FETCH }, /* 51 - EOR IDY page penalty */ | |
| 341 | { _KIL, OP_FETCH }, /* 52 - 1 KIL */ | |
| 342 | { _EA_IDY_NP, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 53 - 7 SRE IDY */ | |
| 343 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* 54 - 4 NOP ZPX */ | |
| 344 | { _EA_ZPX, _RD_EA, _EOR, OP_FETCH }, /* 55 - 4 EOR ZPX */ | |
| 345 | { _EA_ZPX, _RD_EA, _WR_EA, _LSR, _WR_EA, OP_FETCH }, /* 56 - 6 LSR ZPX */ | |
| 346 | { _EA_ZPX, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 57 - 6 SRE ZPX */ | |
| 347 | { _RD_DUM, _CLI, OP_FETCH }, /* 58 - 2 CLI */ | |
| 348 | { _EA_ABY_P, _RD_EA, _EOR, OP_FETCH }, /* 59 - 4 EOR ABY page penalty */ | |
| 349 | { _RD_DUM, _NOP, OP_FETCH }, /* 5a - 2 NOP */ | |
| 350 | { _EA_ABY_NP, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 5b - 7 SRE ABY */ | |
| 351 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* 5c - 4 NOP ABX page penalty */ | |
| 352 | { _EA_ABX_P, _RD_EA, _EOR, OP_FETCH }, /* 5d - 4 EOR ABX page penalty */ | |
| 353 | { _EA_ABX_NP, _RD_EA, _WR_EA, _LSR, _WR_EA, OP_FETCH }, /* 5e - 7 LSR ABX */ | |
| 354 | { _EA_ABX_NP, _RD_EA, _WR_EA, _SRE, _WR_EA, OP_FETCH }, /* 5f - 7 SRE ABX */ | |
| 355 | /* 0x60 - 0x6F */ | |
| 356 | { _RTS, OP_FETCH }, /* 60 - 6 RTS */ | |
| 357 | { _EA_IDX, _RD_EA, _ADC, OP_FETCH }, /* 61 - 6 ADC IDX */ | |
| 358 | { _KIL, OP_FETCH }, /* 62 - 1 KIL */ | |
| 359 | { _EA_IDX, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 63 - 7 RRA IDX */ | |
| 360 | { _EA_ZPG, _RD_EA, _NOP, OP_FETCH }, /* 64 - 3 NOP ZPG */ | |
| 361 | { _EA_ZPG, _RD_EA, _ADC, OP_FETCH }, /* 65 - 3 ADC ZPG */ | |
| 362 | { _EA_ZPG, _RD_EA, _WR_EA, _ROR, _WR_EA, OP_FETCH }, /* 66 - 5 ROR ZPG */ | |
| 363 | { _EA_ZPG, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 67 - 5 RRA ZPG */ | |
| 364 | { _RD_DUM, _PLA, OP_FETCH }, /* 68 - 4 PLA */ | |
| 365 | { _RD_IMM, _ADC, OP_FETCH }, /* 69 - 2 ADC IMM */ | |
| 366 | { _RD_DUM, _RD_ACC, _ROR, _WB_ACC, OP_FETCH }, /* 6a - 2 ROR A */ | |
| 367 | { _RD_IMM, _ARR, _WB_ACC, OP_FETCH }, /* 6b - 2 ARR IMM */ | |
| 368 | { _EA_IND, _JMP, OP_FETCH }, /* 6c - 5 JMP IND */ | |
| 369 | { _EA_ABS, _RD_EA, _ADC, OP_FETCH }, /* 6d - 4 AdC ABS */ | |
| 370 | { _EA_ABS, _RD_EA, _WR_EA, _ROR, _WR_EA, OP_FETCH }, /* 6e - 6 ROR ABS */ | |
| 371 | { _EA_ABS, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 6f - 6 RRA ABS */ | |
| 372 | /* 0x70 - 0x7F */ | |
| 373 | { _BVS, OP_FETCH }, /* 70 - 2-4 BVS REL */ | |
| 374 | { _EA_IDY_P, _RD_EA, _ADC, OP_FETCH }, /* 71 - 5 ADC IDY page penalty */ | |
| 375 | { _KIL, OP_FETCH }, /* 72 - KIL */ | |
| 376 | { _EA_IDY_NP, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 73 - 7 RRA IDY */ | |
| 377 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* 74 - 4 NOP ZPX */ | |
| 378 | { _EA_ZPX, _RD_EA, _ADC, OP_FETCH }, /* 75 - 4 ADC ZPX */ | |
| 379 | { _EA_ZPX, _RD_EA, _WR_EA, _ROR, _WR_EA, OP_FETCH }, /* 76 - 6 ROR ZPX */ | |
| 380 | { _EA_ZPX, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 77 - 6 RRA ZPX */ | |
| 381 | { _RD_DUM, _SEI, OP_FETCH }, /* 78 - 2 SEI */ | |
| 382 | { _EA_ABY_P, _RD_EA, _ADC, OP_FETCH }, /* 79 - 4 ADC ABY page penalty */ | |
| 383 | { _RD_DUM, _NOP, OP_FETCH }, /* 7a - 2 NOP */ | |
| 384 | { _EA_ABY_NP, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 7b - 7 RRA ABY */ | |
| 385 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* 7c - 4 NOP ABX page penalty */ | |
| 386 | { _EA_ABX_P, _RD_EA, _ADC, OP_FETCH }, /* 7d - 4 ADC ABX page penalty */ | |
| 387 | { _EA_ABX_NP, _RD_EA, _WR_EA, _ROR, _WR_EA, OP_FETCH }, /* 7e - 7 ROR ABS */ | |
| 388 | { _EA_ABX_NP, _RD_EA, _WR_EA, _RRA, _WR_EA, OP_FETCH }, /* 7f - 7 RRA ABX */ | |
| 389 | /* 0x80 - 0x8F */ | |
| 390 | { _RD_IMM, _NOP, OP_FETCH }, /* 80 - 2 NOP IMM */ | |
| 391 | { _EA_IDX, _STA, _WR_EA, OP_FETCH }, /* 81 - 6 STA IDX */ | |
| 392 | { _RD_IMM, _NOP, OP_FETCH }, /* 82 - 2 NOP IMM */ | |
| 393 | { _EA_IDX, _SAX, _WR_EA, OP_FETCH }, /* 83 - 6 SAX IDX */ | |
| 394 | { _EA_ZPG, _STY, _WR_EA, OP_FETCH }, /* 84 - 3 STY ZPG */ | |
| 395 | { _EA_ZPG, _STA, _WR_EA, OP_FETCH }, /* 85 - 3 STA ZPG */ | |
| 396 | { _EA_ZPG, _STX, _WR_EA, OP_FETCH }, /* 86 - 3 STX ZPG */ | |
| 397 | { _EA_ZPG, _SAX, _WR_EA, OP_FETCH }, /* 87 - 3 SAX ZPG */ | |
| 398 | { _RD_DUM, _DEY, OP_FETCH }, /* 88 - 2 DEY */ | |
| 399 | { _RD_IMM, _NOP, OP_FETCH }, /* 89 - 2 NOP IMM */ | |
| 400 | { _RD_DUM, _TXA, OP_FETCH }, /* 8a - 2 TXA */ | |
| 401 | { _RD_IMM, _AXA, OP_FETCH }, /* 8b - 2 AXA IMM */ | |
| 402 | { _EA_ABS, _STY, _WR_EA, OP_FETCH }, /* 8c - 4 STY ABS */ | |
| 403 | { _EA_ABS, _STA, _WR_EA, OP_FETCH }, /* 8d - 4 STA ABS */ | |
| 404 | { _EA_ABS, _STX, _WR_EA, OP_FETCH }, /* 8e - 4 STX ABS */ | |
| 405 | { _EA_ABS, _SAX, _WR_EA, OP_FETCH }, /* 8f - 4 SAX ABS */ | |
| 406 | /* 0x90 - 0x9F */ | |
| 407 | { _BCC, OP_FETCH }, /* 90 - 2-4 BCC IMS */ | |
| 408 | { _EA_IDY_NP, _STA, _WR_EA, OP_FETCH }, /* 91 - 6 STA IDY */ | |
| 409 | { _KIL, OP_FETCH }, /* 92 - 1 KIL */ | |
| 410 | { _EA_IDY_NP, _SAH, _WR_EA, OP_FETCH }, /* 93 - SAH IDY */ | |
| 411 | { _EA_ZPX, _STY, _WR_EA, OP_FETCH }, /* 94 - 4 STY ZPX */ | |
| 412 | { _EA_ZPX, _STA, _WR_EA, OP_FETCH }, /* 95 - 4 STA ZPX */ | |
| 413 | { _EA_ZPY, _STX, _WR_EA, OP_FETCH }, /* 96 - 4 STX ZPY */ | |
| 414 | { _EA_ZPY, _SAX, _WR_EA, OP_FETCH }, /* 97 - 4 SAX ZPY */ | |
| 415 | { _RD_DUM, _TYA, OP_FETCH }, /* 98 - 2 TYA */ | |
| 416 | { _EA_ABY_NP, _STA, _WR_EA, OP_FETCH }, /* 99 - 5 STA ABY */ | |
| 417 | { _RD_DUM, _TXS, OP_FETCH }, /* 9a - 2 TXS */ | |
| 418 | { _EA_ABY_NP, _SSH, _WR_EA, OP_FETCH }, /* 9b - 5 SSH ABY */ | |
| 419 | { _EA_ABX_NP, _SYH, _WR_EA, OP_FETCH }, /* 9c - 5 SYH ABX */ | |
| 420 | { _EA_ABX_NP, _STA, _WR_EA, OP_FETCH }, /* 9d - 5 STA ABX */ | |
| 421 | { _EA_ABY_NP, _SXH, _WR_EA, OP_FETCH }, /* 9e - 5 SXH ABY */ | |
| 422 | { _EA_ABY_NP, _SAH, OP_FETCH }, /* 9f - 5 SAH ABY */ | |
| 423 | /* 0xA0 - 0xAF */ | |
| 424 | { _RD_IMM, _LDY, OP_FETCH }, /* a0 - 2 LDY IMM */ | |
| 425 | { _EA_IDX, _RD_EA, _LDA, OP_FETCH }, /* a1 - 6 LDA IDX */ | |
| 426 | { _RD_IMM, _LDX, OP_FETCH }, /* a2 - 2 LDX IMM */ | |
| 427 | { _EA_IDX, _RD_EA, _LAX, OP_FETCH }, /* a3 - 6 LAX IDX */ | |
| 428 | { _EA_ZPG, _RD_EA, _LDY, OP_FETCH }, /* a4 - 3 LDY ZPG */ | |
| 429 | { _EA_ZPG, _RD_EA, _LDA, OP_FETCH }, /* a5 - 3 LDA ZPG */ | |
| 430 | { _EA_ZPG, _RD_EA, _LDX, OP_FETCH }, /* a6 - 3 LDX ZPG */ | |
| 431 | { _EA_ZPG, _RD_EA, _LAX, OP_FETCH }, /* a7 - 3 LAX ZPG */ | |
| 432 | { _RD_DUM, _TAY, OP_FETCH }, /* a8 - 2 TAY */ | |
| 433 | { _RD_IMM, _LDA, OP_FETCH }, /* a9 - 2 LDA IMM */ | |
| 434 | { _RD_DUM, _TAX, OP_FETCH }, /* aa - 2 TAX */ | |
| 435 | { _RD_IMM, _OAL, OP_FETCH }, /* ab - 2 OAL IMM */ | |
| 436 | { _EA_ABS, _RD_EA, _LDY, OP_FETCH }, /* ac - 4 LDY ABS */ | |
| 437 | { _EA_ABS, _RD_EA, _LDA, OP_FETCH }, /* ad - 4 LDA ABS */ | |
| 438 | { _EA_ABS, _RD_EA, _LDX, OP_FETCH }, /* ae - 4 LDX ABS */ | |
| 439 | { _EA_ABS, _RD_EA, _LAX, OP_FETCH }, /* af - 4 LAX ABS */ | |
| 440 | /* 0xB0 - 0xBF */ | |
| 441 | { _BCS, OP_FETCH }, /* b0 - 2-4 BCS REL */ | |
| 442 | { _EA_IDY_P, _RD_EA, _LDA, OP_FETCH }, /* b1 - 5 LDA IDY page penalty */ | |
| 443 | { _KIL, OP_FETCH }, /* b2 - 1 KIL */ | |
| 444 | { _EA_IDY_P, _RD_EA, _LAX, OP_FETCH }, /* b3 - 5 LAX IDY page penalty */ | |
| 445 | { _EA_ZPX, _RD_EA, _LDY, OP_FETCH }, /* b4 - 4 LDY ZPX */ | |
| 446 | { _EA_ZPX, _RD_EA, _LDA, OP_FETCH }, /* b5 - 4 LDA ZPX */ | |
| 447 | { _EA_ZPY, _RD_EA, _LDX, OP_FETCH }, /* b6 - 4 LDX ZPY */ | |
| 448 | { _EA_ZPY, _RD_EA, _LAX, OP_FETCH }, /* b7 - 4 LAX ZPY */ | |
| 449 | { _RD_DUM, _CLV, OP_FETCH }, /* b8 - 2 CLV */ | |
| 450 | { _EA_ABY_P, _RD_EA, _LDA, OP_FETCH }, /* b9 - 4 LDA ABY page penalty */ | |
| 451 | { _RD_DUM, _TSX, OP_FETCH }, /* ba - 2 TSX */ | |
| 452 | { _EA_ABY_P, _RD_EA, _AST, OP_FETCH }, /* bb - 4 AST ABY page penalty */ | |
| 453 | { _EA_ABX_P, _RD_EA, _LDY, OP_FETCH }, /* bc - 4 LDY ABX page penalty */ | |
| 454 | { _EA_ABX_P, _RD_EA, _LDA, OP_FETCH }, /* bd - 4 LDA ABX page penalty */ | |
| 455 | { _EA_ABY_P, _RD_EA, _LDX, OP_FETCH }, /* be - 4 LDX ABY page penalty */ | |
| 456 | { _EA_ABY_P, _RD_EA, _LAX, OP_FETCH }, /* bf - 4 LAX ABY page penalty */ | |
| 457 | /* 0xC0 - 0xCF */ | |
| 458 | { _RD_IMM, _CPY, OP_FETCH }, /* c0 - 2 CPY IMM */ | |
| 459 | { _EA_IDX, _RD_EA, _CMP, OP_FETCH }, /* c1 - 6 CMP IDX */ | |
| 460 | { _RD_IMM, _NOP, OP_FETCH }, /* c2 - 2 NOP IMM */ | |
| 461 | { _EA_IDX, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* c3 - 7 DCP IDX */ | |
| 462 | { _EA_ZPG, _RD_EA, _CPY, OP_FETCH }, /* c4 - 3 CPY ZPG */ | |
| 463 | { _EA_ZPG, _RD_EA, _CMP, OP_FETCH }, /* c5 - 3 CMP ZPG */ | |
| 464 | { _EA_ZPG, _RD_EA, _WR_EA, _DEC, _WR_EA, OP_FETCH }, /* c6 - 5 DEC ZPG */ | |
| 465 | { _EA_ZPG, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* c7 - 5 DCP ZPG */ | |
| 466 | { _RD_DUM, _INY, OP_FETCH }, /* c8 - 2 INY */ | |
| 467 | { _RD_IMM, _CMP, OP_FETCH }, /* c9 - 2 CMP IMM */ | |
| 468 | { _RD_DUM, _DEX, OP_FETCH }, /* ca - 2 DEX */ | |
| 469 | { _RD_IMM, _ASX, OP_FETCH }, /* cb - 2 ASX IMM */ | |
| 470 | { _EA_ABS, _RD_EA, _CPY, OP_FETCH }, /* cc - 4 CPY ABS */ | |
| 471 | { _EA_ABS, _RD_EA, _CMP, OP_FETCH }, /* cd - 4 CMP ABS */ | |
| 472 | { _EA_ABS, _RD_EA, _WR_EA, _DEC, _WR_EA, OP_FETCH }, /* ce - 6 DEC ABS */ | |
| 473 | { _EA_ABS, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* cf - 6 DCP ABS */ | |
| 474 | /* 0xD0 - 0xDF */ | |
| 475 | { _BNE, OP_FETCH }, /* d0 - 2-4 BNE REL */ | |
| 476 | { _EA_IDY_P, _RD_EA, _CMP, OP_FETCH }, /* d1 - 5 CMP IDX page penalty */ | |
| 477 | { _KIL, OP_FETCH }, /* d2 - 1 KIL */ | |
| 478 | { _EA_IDY_NP, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* d3 - 7 DCP, IDY */ | |
| 479 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* d4 - 4 NOP ZPX */ | |
| 480 | { _EA_ZPX, _RD_EA, _CMP, OP_FETCH }, /* d5 - 4 CMP ZPX */ | |
| 481 | { _EA_ZPX, _RD_EA, _WR_EA, _DEC, _WR_EA, OP_FETCH }, /* d6 - 6 DEC ZPX */ | |
| 482 | { _EA_ZPX, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* d7 - 6 DCP ZPX */ | |
| 483 | { _RD_DUM, _CLD, OP_FETCH }, /* d8 - 2 CLD */ | |
| 484 | { _EA_ABY_P, _RD_EA, _CMP, OP_FETCH }, /* d9 - 4 CMP ABY page penalty */ | |
| 485 | { _RD_DUM, _NOP, OP_FETCH }, /* da - 2 NOP */ | |
| 486 | { _EA_ABY_NP, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* db - 7 DCP ABY */ | |
| 487 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* dc - 4 NOP ABX page penalty */ | |
| 488 | { _EA_ABX_P, _RD_EA, _CMP, OP_FETCH }, /* dd - 4 CMP ABX page penalty */ | |
| 489 | { _EA_ABX_NP, _RD_EA, _WR_EA, _DEC, _WR_EA, OP_FETCH }, /* de - 7 DEC ABX */ | |
| 490 | { _EA_ABX_NP, _RD_EA, _WR_EA, _DCP, _WR_EA, OP_FETCH }, /* df - 7 DCP ABX */ | |
| 491 | /* 0xE0 - 0xEF */ | |
| 492 | { _RD_IMM, _CPX, OP_FETCH }, /* e0 - 2 CPX IMM */ | |
| 493 | { _EA_IDX, _RD_EA, _SBC, OP_FETCH }, /* e1 - 6 SBC IDX */ | |
| 494 | { _RD_IMM, _NOP, OP_FETCH }, /* e2 - 2 NOP IMM */ | |
| 495 | { _EA_IDX, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* e3 - 7 ISB IDX */ | |
| 496 | { _EA_ZPG, _RD_EA, _CPX, OP_FETCH }, /* e4 - 3 CPX ZPG */ | |
| 497 | { _EA_ZPG, _RD_EA, _SBC, OP_FETCH }, /* e5 - 3 SBC ZPG */ | |
| 498 | { _EA_ZPG, _RD_EA, _WR_EA, _INC, _WR_EA, OP_FETCH }, /* e6 - 5 INC ZPG */ | |
| 499 | { _EA_ZPG, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* e7 - 5 ISB ZPG */ | |
| 500 | { _RD_DUM, _INX, OP_FETCH }, /* e8 - 2 INX */ | |
| 501 | { _RD_IMM, _SBC, OP_FETCH }, /* e9 - 2 SBC IMM */ | |
| 502 | { _RD_DUM, _NOP, OP_FETCH }, /* ea - 2 NOP */ | |
| 503 | { _RD_IMM, _SBC, OP_FETCH }, /* eb - 2 SBC IMM */ | |
| 504 | { _EA_ABS, _RD_EA, _CPX, OP_FETCH }, /* ec - 4 CPX ABS */ | |
| 505 | { _EA_ABS, _RD_EA, _SBC, OP_FETCH }, /* ed - 4 SBC ABS */ | |
| 506 | { _EA_ABS, _RD_EA, _WR_EA, _INC, _WR_EA, OP_FETCH }, /* ee - 6 INC ABS */ | |
| 507 | { _EA_ABS, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* ef - 6 ISB ABS */ | |
| 508 | /* 0xF0 - 0xFF */ | |
| 509 | { _BEQ, OP_FETCH }, /* f0 - 2-4 BEQ REL */ | |
| 510 | { _EA_IDY_P, _RD_EA, _SBC, OP_FETCH }, /* f1 - 5 SBC page penalty */ | |
| 511 | { _KIL, OP_FETCH }, /* f2 - 1 KIL */ | |
| 512 | { _EA_IDY_NP, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* f3 - 7 ISB IDY */ | |
| 513 | { _EA_ZPX, _RD_EA, _NOP, OP_FETCH }, /* f4 - 4 NOP ZPX */ | |
| 514 | { _EA_ZPX, _RD_EA, _SBC, OP_FETCH }, /* f5 - 4 SBC ZPX */ | |
| 515 | { _EA_ZPX, _RD_EA, _WR_EA, _INC, _WR_EA, OP_FETCH }, /* f6 - 6 INC ZPX */ | |
| 516 | { _EA_ZPX, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* f7 - 6 ISB ZPX */ | |
| 517 | { _RD_DUM, _SED, OP_FETCH }, /* f8 - 2 SED */ | |
| 518 | { _EA_ABY_P, _RD_EA, _SBC, OP_FETCH }, /* f9 - 4 SBC ABY page penalty */ | |
| 519 | { _RD_DUM, _NOP, OP_FETCH }, /* fa - 2 NOP */ | |
| 520 | { _EA_ABY_NP, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* fb - 7 ISB ABY */ | |
| 521 | { _EA_ABX_P, _RD_EA, _NOP, OP_FETCH }, /* fc - 4 NOP ABX page penalty */ | |
| 522 | { _EA_ABX_P, _RD_EA, _SBC, OP_FETCH }, /* fd - 4 SBC ABX page penalty */ | |
| 523 | { _EA_ABX_NP, _RD_EA, _WR_EA, _INC, _WR_EA, OP_FETCH }, /* fe - 7 INC ABX */ | |
| 524 | { _EA_ABX_NP, _RD_EA, _WR_EA, _ISB, _WR_EA, OP_FETCH }, /* ff - 7 ISB ABX */ | |
| 525 | /* special cases */ | |
| 526 | { OP_FETCH }, /* RESET */ | |
| 527 | { OP_FETCH }, /* TAKE_IRQ */ | |
| 528 | }; | |
| 529 | ||
| 530 | static int m6502_execute2(int cycles) { | |
| 531 | m6502_ICount = cycles; | |
| 532 | ||
| 533 | change_pc(PCD); | |
| 534 | ||
| 535 | do { | |
| 536 | debugger_instruction_hook(Machine, PCD); | |
| 537 | m6502_ICount--; | |
| 538 | } while (m6502_ICount > 0); | |
| 539 | ||
| 540 | return cycles - m6502_ICount; | |
| 541 | } | |
| 542 | ||
| 222 | 543 | static int m6502_execute(int cycles) |
| 223 | 544 | { |
| 224 | 545 | m6502_ICount = cycles; |
| r3486 | r3487 | |
|---|---|---|
| 2190 | 2190 | break; |
| 2191 | 2191 | |
| 2192 | 2192 | case CPUINFO_INT_REGISTER + I8X41_STAT: |
| 2193 | logerror("i8x41 #%d:%03x Setting STAT DBBI to %02x\n", cpu_getactivecpu(), PC, (UINT8)info->i); | |
| 2193 | //logerror("i8x41 #%d:%03x Setting STAT DBBI to %02x\n", cpu_getactivecpu(), PC, (UINT8)info->i); | |
| 2194 | 2194 | /* writing status.. hmm, should we issue interrupts here too? */ |
| 2195 | 2195 | STATE = info->i; |
| 2196 | 2196 | break; |
| r3486 | r3487 | |
| 2271 | 2271 | break; |
| 2272 | 2272 | |
| 2273 | 2273 | case CPUINFO_INT_REGISTER + I8X41_STAT: |
| 2274 | logerror("i8x41 #%d:%03x Reading STAT %02x\n", cpu_getactivecpu(), PC, STATE); | |
| 2274 | //logerror("i8x41 #%d:%03x Reading STAT %02x\n", cpu_getactivecpu(), PC, STATE); | |
| 2275 | 2275 | info->i = STATE; |
| 2276 | 2276 | break; |
| 2277 | 2277 |
| r3486 | r3487 | |
|---|---|---|
| 23 | 23 | #include <driver.h> |
| 24 | 24 | #include "machine/i2cmem.h" |
| 25 | 25 | |
| 26 | #define VERBOSE_LEVEL ( | |
| 26 | #define VERBOSE_LEVEL ( 4 ) | |
| 27 | 27 | |
| 28 | 28 | INLINE void ATTR_PRINTF(2,3) verboselog( int n_level, const char *s_fmt, ... ) |
| 29 | 29 | { |
| r3486 | r3487 | |
| 60 | 60 | int shift; |
| 61 | 61 | int devsel; |
| 62 | 62 | int byteaddr; |
| 63 | int byteaddr_width; | |
| 64 | int byteaddr_bits; | |
| 63 | 65 | unsigned char *data; |
| 64 | 66 | int data_size; |
| 65 | 67 | unsigned char *page; |
| r3486 | r3487 | |
| 67 | 69 | int page_size; |
| 68 | 70 | }; |
| 69 | 71 | |
| 70 | #define STATE_IDLE ( 0 ) | |
| 71 | #define STATE_DEVSEL ( 1 ) | |
| 72 | #define STATE_BYTEADDR ( 2 ) | |
| 73 | #define STATE_DATAIN ( 3 ) | |
| 74 | #define STATE_DATAOUT ( 4 ) | |
| 72 | enum { | |
| 73 | STATE_IDLE=0, | |
| 74 | STATE_DEVSEL, | |
| 75 | STATE_BYTEADDR, | |
| 76 | STATE_DATAIN, | |
| 77 | STATE_DATAOUT | |
| 78 | }; | |
| 75 | 79 | |
| 76 | 80 | #define DEVSEL_RW ( 1 ) |
| 77 | 81 | #define DEVSEL_ADDRESS ( 0xfe ) |
| r3486 | r3487 | |
| 117 | 121 | c->shift = 0; |
| 118 | 122 | c->devsel = 0; |
| 119 | 123 | c->byteaddr = 0; |
| 124 | c->byteaddr_width = 16; | |
| 125 | c->byteaddr_bits = 0; | |
| 120 | 126 | c->data = data; |
| 121 | 127 | c->page = page; |
| 122 | 128 | |
| r3486 | r3487 | |
| 132 | 138 | state_save_register_item( "i2cmem", chip, c->shift ); |
| 133 | 139 | state_save_register_item( "i2cmem", chip, c->devsel ); |
| 134 | 140 | state_save_register_item( "i2cmem", chip, c->byteaddr ); |
| 141 | state_save_register_item( "i2cmem", chip, c->byteaddr_width ); | |
| 142 | state_save_register_item( "i2cmem", chip, c->byteaddr_bits ); | |
| 135 | 143 | state_save_register_item_pointer( "i2cmem", chip, c->data, c->data_size ); |
| 136 | 144 | } |
| 137 | 145 | |
| r3486 | r3487 | |
| 150 | 158 | |
| 151 | 159 | static int data_offset( struct i2cmem_chip *c ) |
| 152 | 160 | { |
| 153 | return ( ( ( c->devsel << 7 ) & 0xff00 ) | ( c->byteaddr & 0xff ) ) & ( c->data_size - 1 ); | |
| 161 | switch( c->byteaddr_width ) | |
| 162 | { | |
| 163 | case 16: | |
| 164 | return ( ( ( c->devsel << 15 ) & 0xff0000 ) | ( c->byteaddr & 0xffff ) ) & ( c->data_size - 1 ); | |
| 165 | case 8: | |
| 166 | default: | |
| 167 | return ( ( ( c->devsel << 7 ) & 0xff00 ) | ( c->byteaddr & 0xff ) ) & ( c->data_size - 1 ); | |
| 168 | } | |
| 154 | 169 | } |
| 155 | 170 | |
| 156 | 171 | void i2cmem_write( int chip, int line, int data ) |
| r3486 | r3487 | |
| 256 | 271 | { |
| 257 | 272 | verboselog( 1, "i2cmem(%d) devsel %02x: write\n", chip, c->devsel ); |
| 258 | 273 | c->state = STATE_BYTEADDR; |
| 274 | c->byteaddr_bits = c->byteaddr_width; | |
| 259 | 275 | } |
| 260 | 276 | else |
| 261 | 277 | { |
| r3486 | r3487 | |
| 265 | 281 | break; |
| 266 | 282 | |
| 267 | 283 | case STATE_BYTEADDR: |
| 268 | c->byteaddr = c->shift; | |
| 284 | c->byteaddr_bits -= 8; | |
| 285 | c->byteaddr &= ~ ( 0xff << c->byteaddr_bits ); | |
| 286 | c->byteaddr |= ( c->shift << c->byteaddr_bits ); | |
| 269 | 287 | c->page_offset = 0; |
| 270 | 288 | |
| 271 | 289 | verboselog( 1, "i2cmem(%d) byteaddr %02x\n", chip, c->byteaddr ); |
| 272 | 290 | |
| 273 | c->state = STATE_DATAIN; | |
| 291 | if ( c->byteaddr_bits <= 0 ) | |
| 292 | c->state = STATE_DATAIN; | |
| 274 | 293 | break; |
| 275 | 294 | |
| 276 | 295 | case STATE_DATAIN: |
| r3486 | r3487 | |
| 336 | 355 | c->shift = c->data[ offset ]; |
| 337 | 356 | verboselog( 1, "i2cmem(%d) data[ %04x ] -> %02x\n", chip, offset, c->data[ offset ] ); |
| 338 | 357 | c->byteaddr++; |
| 358 | ||
| 359 | /* Check if there was an acknowledge */ | |
| 360 | if ( ! c->sdaw ) | |
| 361 | c->sdaw = 1; | |
| 339 | 362 | } |
| 340 | 363 | |
| 364 | verboselog( 1, "c->shift = %02x, c->sadw = %d\n", c->shift, c->sdaw ); | |
| 341 | 365 | c->sdar = ( c->shift >> 7 ) & 1; |
| 342 | 366 | |
| 343 | 367 | c->shift = ( c->shift << 1 ) & 0xff; |
| r3486 | r3487 | |
|---|---|---|
| 12 | 12 | **********************************************************************/ |
| 13 | 13 | |
| 14 | 14 | #include "driver.h" |
| 15 | #include "memconv.h" | |
| 16 | 15 | #include "machine/pic8259.h" |
| 17 | 16 | |
| 18 | 17 | #define IRQ_COUNT 8 |
| r3486 | r3487 | |
| 47 | 46 | UINT8 interrupt_mask; |
| 48 | 47 | |
| 49 | 48 | UINT8 input; |
| 50 | UINT | |
| 49 | UINT8 | |
| 51 | 50 | |
| 52 | 51 | /* ICW1 state */ |
| 53 | 52 | UINT32 level_trig_mode : 1; |
| r3486 | r3487 | |
| 103 | 102 | { |
| 104 | 103 | if (LOG_GENERAL) |
| 105 | 104 | logerror("pic8259_timerproc(): PIC triggering IRQ #%d\n", irq); |
| 106 | if (pic8259->intf->set_int_line) | |
| 105 | if ( ! ( pic8259->ocw3 & 0x04 ) && pic8259->intf->set_int_line) | |
| 107 | 106 | pic8259->intf->set_int_line(device, 1); |
| 108 | 107 | return; |
| 109 | 108 | } |
| 110 | 109 | } |
| 111 | if (pic8259->intf->set_int_line) | |
| 110 | if ( ! ( pic8259->ocw3 & 0x04 ) && pic8259->intf->set_int_line) | |
| 112 | 111 | pic8259->intf->set_int_line(device, 0); |
| 113 | 112 | } |
| 114 | 113 | |
| r3486 | r3487 | |
| 122 | 121 | void pic8259_set_irq_line(const device_config *device, int irq, int state) |
| 123 | 122 | { |
| 124 | 123 | pic8259_t *pic8259 = get_safe_token(device); |
| 124 | UINT8 old_irq_lines = pic8259->irq_lines; | |
| 125 | 125 | |
| 126 | 126 | if (state) |
| 127 | 127 | { |
| 128 | 128 | /* setting IRQ line */ |
| 129 | if (!(pic8259->irq_lines & (1 << irq))) | |
| 130 | { | |
| 131 | if (LOG_GENERAL) | |
| 132 | logerror("pic8259_set_irq_line(): PIC set IRQ line #%d\n", irq); | |
| 129 | if (LOG_GENERAL) | |
| 130 | logerror("pic8259_set_irq_line(): PIC set IRQ line #%d\n", irq); | |
| 133 | 131 | |
| 134 | pic8259->irq_lines |= 1 << irq; | |
| 135 | pic8259->pending |= 1 << irq; | |
| 136 | pic8259_set_timer(pic8259); | |
| 137 | } | |
| 132 | pic8259->irq_lines |= 1 << irq; | |
| 138 | 133 | } |
| 139 | 134 | else |
| 140 | 135 | { |
| 141 | 136 | /* clearing IRQ line */ |
| 142 | if (pic8259->irq_lines & (1 << irq)) | |
| 137 | if (LOG_GENERAL) | |
| 138 | logerror("pic8259_set_irq_line(): PIC cleared IRQ line #%d\n", irq); | |
| 139 | ||
| 140 | pic8259->irq_lines &= ~(1 << irq); | |
| 141 | } | |
| 142 | ||
| 143 | if ( pic8259->level_trig_mode ) | |
| 144 | { | |
| 145 | /* Level triggering mode; just copy the IR level */ | |
| 146 | pic8259->pending = ( pic8259->pending & ~ ( 1 << irq ) ) | ( pic8259->irq_lines & ( 1 << irq ) ); | |
| 147 | pic8259_set_timer(pic8259); | |
| 148 | } | |
| 149 | else | |
| 150 | { | |
| 151 | /* Edge triggering mode; check for a 0 -> 1 transition */ | |
| 152 | if ( ! ( old_irq_lines & ( 1 << irq ) ) && state ) | |
| 143 | 153 | { |
| 144 | if (LOG_GENERAL) | |
| 145 | logerror("pic8259_set_irq_line(): PIC cleared IRQ line #%d\n", irq); | |
| 146 | ||
| 147 | pic8259->irq_lines &= ~(1 << irq); | |
| 154 | pic8259->pending |= ( 1 << irq ); | |
| 148 | 155 | pic8259_set_timer(pic8259); |
| 149 | 156 | } |
| 150 | 157 | } |
| r3486 | r3487 | |
| 191 | 198 | /* NPW 18-May-2003 - Changing 0xFF to 0x00 as per Ruslan */ |
| 192 | 199 | UINT8 data = 0x00; |
| 193 | 200 | |
| 201 | //printf("pic8259_r(): pc = %08x, offset = %02x\n", activecpu_get_pc(), offset ); | |
| 194 | 202 | switch(offset) |
| 195 | 203 | { |
| 196 | 204 | case 0: /* PIC acknowledge IRQ */ |
| 197 | if (pic8259-> | |
| 205 | if ( pic8259->o | |
| 198 | 206 | { |
| 199 | pic8259->special = 0; | |
| 200 | data = pic8259->input; | |
| 207 | /* Polling mode */ | |
| 208 | if ( pic8259->in_service & ~pic8259->interrupt_mask ) | |
| 209 | { | |
| 210 | int irq; | |
| 211 | ||
| 212 | pic8259_acknowledge( device ); | |
| 213 | ||
| 214 | for ( irq = 0; irq < IRQ_COUNT; irq++ ) | |
| 215 | { | |
| 216 | if ( ( 1 << irq ) & pic8259->in_service & ~pic8259->interrupt_mask ) | |
| 217 | { | |
| 218 | data = 0x80 | irq; | |
| 219 | break; | |
| 220 | } | |
| 221 | } | |
| 222 | } | |
| 201 | 223 | } |
| 224 | else | |
| 225 | { | |
| 226 | switch ( pic8259->ocw3 & 0x03 ) | |
| 227 | { | |
| 228 | case 2: | |
| 229 | data = pic8259->pending; | |
| 230 | break; | |
| 231 | case 3: | |
| 232 | data = pic8259->in_service & ~pic8259->interrupt_mask; | |
| 233 | break; | |
| 234 | case 1: | |
| 235 | default: | |
| 236 | data = 0x00; | |
| 237 | break; | |
| 238 | } | |
| 239 | } | |
| 202 | 240 | break; |
| 203 | 241 | |
| 204 | 242 | case 1: /* PIC mask register */ |
| r3486 | r3487 | |
| 214 | 252 | { |
| 215 | 253 | pic8259_t *pic8259 = get_safe_token(device); |
| 216 | 254 | |
| 255 | //printf("pic8259_w(): pc = %08x, offset = %02x, data = %02x\n", activecpu_get_pc(), offset, data ); | |
| 217 | 256 | switch(offset) |
| 218 | 257 | { |
| 219 | 258 | case 0: /* PIC acknowledge IRQ */ |
| r3486 | r3487 | |
| 224 | 263 | logerror("pic8259_w(): ICW1; data=0x%02X\n", data); |
| 225 | 264 | |
| 226 | 265 | pic8259->interrupt_mask = 0x00; |
| 266 | pic8259->in_service = 0x00; | |
| 267 | pic8259->pending = 0x00; | |
| 268 | pic8259->irq_lines = 0x00; | |
| 227 | 269 | pic8259->level_trig_mode = (data & 0x08) ? 1 : 0; |
| 228 | 270 | pic8259->vector_size = (data & 0x04) ? 1 : 0; |
| 229 | 271 | pic8259->cascade = (data & 0x02) ? 0 : 1; |
| r3486 | r3487 | |
| 239 | 281 | if (LOG_OCW) |
| 240 | 282 | logerror("pic8259_w(): OCW3; data=0x%02X\n", data); |
| 241 | 283 | |
| 242 | switch (data & 0x03) | |
| 243 | { | |
| 244 | case 0x02: | |
| 245 | pic8259->special = 1; | |
| 246 | pic8259->input = pic8259->pending; | |
| 247 | break; | |
| 248 | case 0x03: | |
| 249 | pic8259->special = 1; | |
| 250 | pic8259->input = pic8259->in_service & ~pic8259->interrupt_mask; | |
| 251 | break; | |
| 252 | } | |
| 284 | pic8259->ocw3 = data; | |
| 253 | 285 | } |
| 254 | 286 | else if ((data & 0x18) == 0x00) |
| 255 | 287 | { |
| r3486 | r3487 | |
| 317 | 349 | switch(pic8259->state) |
| 318 | 350 | { |
| 319 | 351 | case STATE_ICW1: |
| 352 | /* keep compiler happy */ | |
| 320 | 353 | break; |
| 321 | 354 | |
| 322 | 355 | case STATE_ICW2: |
| r3486 | r3487 | |
| 358 | 391 | if (LOG_OCW) |
| 359 | 392 | logerror("pic8259_w(): OCW1; data=0x%02X\n", data); |
| 360 | 393 | |
| 394 | /* Changing a bit in the mask from 1 to 0 with a pending | |
| 395 | interrupt seems to clear the bit in the IRR. | |
| 396 | Observed in Supersoft XT diagnostics and AT + EGA POST | |
| 397 | checks. | |
| 398 | */ | |
| 399 | if ( pic8259->interrupt_mask & ~data ) | |
| 400 | { | |
| 401 | pic8259->pending = pic8259->pending & ~ ( pic8259->interrupt_mask & ~data ); | |
| 402 | } | |
| 361 | 403 | pic8259->interrupt_mask = data; |
| 362 | 404 | break; |
| 363 | 405 | } |
| r3486 | r3487 | |
| 373 | 415 | |
| 374 | 416 | pic8259->intf = device->static_config; |
| 375 | 417 | |
| 418 | pic8259->timer = timer_alloc( pic8259_timerproc, (void *)device ); | |
| 419 | ||
| 376 | 420 | return DEVICE_START_OK; |
| 377 | 421 | } |
| 378 | 422 | |
| r3486 | r3487 | |
| 380 | 424 | static DEVICE_RESET( pic8259 ) { |
| 381 | 425 | pic8259_t *pic8259 = get_safe_token(device); |
| 382 | 426 | |
| 383 | pic8259->timer = timer_alloc( pic8259_timerproc, (void *)device ); | |
| 384 | ||
| 385 | 427 | pic8259->state = STATE_ICW1; /* It is unclear from the original code whether this is correct */ |
| 386 | 428 | pic8259->irq_lines = 0; |
| 387 | 429 | pic8259->in_service = 0; |
| 388 | 430 | pic8259->pending = 0; |
| 389 | 431 | pic8259->prio = 0; |
| 390 | pic8259->interrupt_mask = 0; | |
| 432 | pic8259->interrupt_mask = 0xff; | |
| 391 | 433 | pic8259->input = 0; |
| 392 | pic8259-> | |
| 434 | pic8259->o | |
| 393 | 435 | pic8259->level_trig_mode = 0; |
| 394 | 436 | pic8259->vector_size = 0; |
| 395 | 437 | pic8259->cascade = 0; |
| r3486 | r3487 | |
|---|---|---|
| 23 | 23 | #include "8237dma.h" |
| 24 | 24 | |
| 25 | 25 | |
| 26 | /* States that the dma8237 device can be in */ | |
| 27 | typedef enum { | |
| 28 | DMA8237_SI, /* Idle state */ | |
| 29 | DMA8237_S0, /* HRQ has been triggered, waiting to receive HLDA */ | |
| 30 | // DMA8237_SW, /* Wait state */ | |
| 31 | ||
| 32 | /* Normal transfer states */ | |
| 33 | DMA8237_S1, /* Output A8-A15; only used when A8-A15 really needs to be output */ | |
| 34 | DMA8237_S2, /* Output A0-A7 */ | |
| 35 | DMA8237_S3, /* Initiate read; skipped in compressed timing. On the S2->S3 transition DACK is set. */ | |
| 36 | DMA8237_S4, /* Perform read/write */ | |
| 37 | ||
| 38 | /* Memory to memory transfer states */ | |
| 39 | DMA8237_S11, /* Output A8-A15 */ | |
| 40 | // DMA8237_S12, /* Output A0-A7 */ | |
| 41 | // DMA8237_S13, /* Initiate read */ | |
| 42 | // DMA8237_S14, /* Perform read/write */ | |
| 43 | // DMA8237_S21, /* Output A8-A15 */ | |
| 44 | // DMA8237_S22, /* Output A0-A7 */ | |
| 45 | // DMA8237_S23, /* Initiate read */ | |
| 46 | // DMA8237_S24, /* Perform read/write */ | |
| 47 | } dma8237_state; | |
| 48 | ||
| 49 | ||
| 26 | 50 | typedef struct dma8237 dma8237_t; |
| 27 | 51 | |
| 28 | 52 | struct dma8237 |
| r3486 | r3487 | |
| 33 | 57 | |
| 34 | 58 | struct |
| 35 | 59 | { |
| 60 | UINT16 base_address; | |
| 61 | UINT16 base_count; | |
| 36 | 62 | UINT16 address; |
| 37 | 63 | UINT16 count; |
| 38 | 64 | UINT8 mode; |
| 65 | int high_address_changed; | |
| 39 | 66 | } chan[4]; |
| 40 | 67 | |
| 41 | 68 | UINT32 msb : 1; |
| 42 | 69 | UINT32 eop : 1; |
| 43 | 70 | UINT8 temp; |
| 71 | UINT8 temporary_data; | |
| 44 | 72 | UINT8 command; |
| 45 | 73 | UINT8 drq; |
| 46 | 74 | UINT8 mask; |
| 75 | UINT8 hrq; | |
| 76 | UINT8 hlda; | |
| 47 | 77 | |
| 48 | 78 | /* bits 0- 3 : Terminal count for channels 0-3 |
| 49 | 79 | * bits 4- 7 : Transfer in progress for channels 0-3 */ |
| 50 | 80 | UINT8 status; |
| 81 | ||
| 82 | dma8237_state state; /* State the device is currently in */ | |
| 83 | int service_channel; /* Channel we will be servicing */ | |
| 84 | int last_service_channel; /* Previous channel we serviced; used to determine channel priority. */ | |
| 51 | 85 | }; |
| 52 | 86 | |
| 53 | 87 | |
| 54 | 88 | #define DMA_MODE_CHANNEL(mode) ((mode) & 0x03) |
| 55 | #define DMA_MODE_OPERATION(mode) (((mode) >> 2) & 0x03) | |
| 56 | #define DMA_MODE_DIRECTION(mode) (((mode) & 0x20) ? -1 : +1) | |
| 57 | #define DMA_MODE_TRANSFERMODE(mode) (((mode) >> 6) & 0x03) | |
| 89 | #define DMA_MODE_OPERATION(mode) ((mode) & 0x0c) | |
| 90 | #define DMA_MODE_AUTO_INIT(mode) ((mode) & 0x10) | |
| 91 | #define DMA_MODE_DIRECTION(mode) ((mode) & 0x20) | |
| 92 | #define DMA_MODE_TRANSFERMODE(mode) ((mode) & 0xc0) | |
| 58 | 93 | |
| 94 | #define DMA8237_VERIFY_TRANSFER 0x00 | |
| 95 | #define DMA8237_WRITE_TRANSFER 0x04 | |
| 96 | #define DMA8237_READ_TRANSFER 0x08 | |
| 97 | #define DMA8237_ILLEGAL_TRANSFER 0x0c | |
| 59 | 98 | |
| 99 | #define DMA8237_DEMAND_MODE 0x00 | |
| 100 | #define DMA8237_SINGLE_MODE 0x40 | |
| 101 | #define DMA8237_BLOCK_MODE 0x80 | |
| 102 | #define DMA8237_CASCADE_MODE 0xc0 | |
| 60 | 103 | |
| 61 | static TIMER_CALLBACK( dma8237_timerproc ); | |
| 62 | static TIMER_CALLBACK( dma8237_msbflip_timerproc ); | |
| 63 | static void dma8237_update_status(const device_config *device); | |
| 64 | 104 | |
| 65 | 105 | /* ----------------------------------------------------------------------- */ |
| 66 | 106 | |
| r3486 | r3487 | |
| 75 | 115 | /* ----------------------------------------------------------------------- */ |
| 76 | 116 | |
| 77 | 117 | |
| 78 | ||
| 118 | INLINE void | |
| 79 | 119 | { |
| 80 | dma8237_t *dma8237 = get_safe_token(device); | |
| 81 | int done; | |
| 82 | UINT8 data; | |
| 83 | UINT8 mode; | |
| 120 | dma8237_t *dma8237 = get_safe_token( device ); | |
| 121 | int channel = dma8237->service_channel; | |
| 84 | 122 | |
| 85 | mode = dma8237->chan[channel].mode; | |
| 123 | switch( DMA_MODE_OPERATION( dma8237->chan[ channel ].mode ) ) | |
| 124 | { | |
| 125 | case DMA8237_WRITE_TRANSFER: | |
| 126 | dma8237->temporary_data = dma8237->intf->channel_read_func[ channel ]( device ); | |
| 127 | break; | |
| 128 | case DMA8237_READ_TRANSFER: | |
| 129 | dma8237->temporary_data = dma8237->intf->memory_read_func( device, channel, dma8237->chan[ channel ].address ); | |
| 130 | break; | |
| 131 | case DMA8237_VERIFY_TRANSFER: | |
| 132 | case DMA8237_ILLEGAL_TRANSFER: | |
| 133 | break; | |
| 134 | } | |
| 135 | } | |
| 86 | 136 | |
| 87 | switch(DMA_MODE_OPERATION(mode)) { | |
| 88 | case 1: | |
| 89 | data = dma8237->intf->channel_read_func[channel](device); | |
| 90 | dma8237->intf->memory_write_func(device, channel, dma8237->chan[channel].address, data); | |
| 91 | 137 | |
| 92 | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); | |
| 93 | dma8237->chan[channel].count--; | |
| 94 | done = (dma8237->chan[channel].count == 0xFFFF); | |
| 138 | INLINE void dma8237_do_write( const device_config *device ) | |
| 139 | { | |
| 140 | dma8237_t *dma8237 = get_safe_token( device ); | |
| 141 | int channel = dma8237->service_channel; | |
| 142 | ||
| 143 | switch( DMA_MODE_OPERATION( dma8237->chan[ channel ].mode ) ) | |
| 144 | { | |
| 145 | case DMA8237_WRITE_TRANSFER: | |
| 146 | dma8237->intf->memory_write_func( device, channel, dma8237->chan[ channel ].address, dma8237->temporary_data ); | |
| 95 | 147 | break; |
| 148 | case DMA8237_READ_TRANSFER: | |
| 149 | dma8237->intf->channel_write_func[channel]( device, dma8237->temporary_data ); | |
| 150 | break; | |
| 151 | case DMA8237_VERIFY_TRANSFER: | |
| 152 | case DMA8237_ILLEGAL_TRANSFER: | |
| 153 | break; | |
| 154 | } | |
| 155 | } | |
| 96 | 156 | |
| 97 | case 2: | |
| 98 | data = dma8237->intf->memory_read_func(device, channel, dma8237->chan[channel].address); | |
| 99 | dma8237->intf->channel_write_func[channel](device, data); | |
| 100 | 157 | |
| 101 | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); | |
| 158 | INLINE void dma8237_advance( const device_config *device ) | |
| 159 | { | |
| 160 | dma8237_t *dma8237 = get_safe_token( device ); | |
| 161 | int channel = dma8237->service_channel; | |
| 162 | int mode = dma8237->chan[channel].mode; | |
| 163 | ||
| 164 | switch ( DMA_MODE_OPERATION( mode ) ) | |
| 165 | { | |
| 166 | case DMA8237_VERIFY_TRANSFER: | |
| 167 | case DMA8237_WRITE_TRANSFER: | |
| 168 | case DMA8237_READ_TRANSFER: | |
| 169 | dma8237->chan[channel].high_address_changed = 0; | |
| 170 | ||
| 171 | if ( DMA_MODE_DIRECTION( mode ) ) | |
| 172 | { | |
| 173 | dma8237->chan[channel].address -= 1; | |
| 174 | if ( ( dma8237->chan[channel].address & 0xFF ) == 0xFF ) | |
| 175 | dma8237->chan[channel].high_address_changed = 1; | |
| 176 | } | |
| 177 | else | |
| 178 | { | |
| 179 | dma8237->chan[channel].address += 1; | |
| 180 | if ( ( dma8237->chan[channel].address & 0xFF ) == 0x00 ) | |
| 181 | dma8237->chan[channel].high_address_changed = 1; | |
| 182 | } | |
| 183 | ||
| 102 | 184 | dma8237->chan[channel].count--; |
| 103 | done = (dma8237->chan[channel].count == 0xFFFF); | |
| 104 | break; | |
| 105 | 185 | |
| 106 | default: | |
| 107 | done = TRUE; | |
| 186 | if ( dma8237->chan[channel].count == 0xFFFF ) | |
| 187 | { | |
| 188 | /* Set TC bit for this channel */ | |
| 189 | dma8237->status |= ( 0x01 << channel ); | |
| 190 | ||
| 191 | if ( DMA_MODE_AUTO_INIT( mode ) ) | |
| 192 | { | |
| 193 | dma8237->chan[channel].address = dma8237->chan[channel].base_address; | |
| 194 | dma8237->chan[channel].count = dma8237->chan[channel].base_count; | |
| 195 | dma8237->chan[channel].high_address_changed = 1; | |
| 196 | } | |
| 197 | else | |
| 198 | { | |
| 199 | dma8237->mask |= ( 0x01 << channel ); | |
| 200 | } | |
| 201 | } | |
| 108 | 202 | break; |
| 203 | case DMA8237_ILLEGAL_TRANSFER: | |
| 204 | break; | |
| 109 | 205 | } |
| 110 | ||
| 206 | ||
| 111 | 207 | } |
| 112 | 208 | |
| 113 | 209 | |
| 114 | ||
| 115 | 210 | static TIMER_CALLBACK( dma8237_timerproc ) |
| 116 | 211 | { |
| 117 | 212 | const device_config *device = ptr; |
| 118 | 213 | dma8237_t *dma8237 = get_safe_token(device); |
| 119 | int channel = param % 4; | |
| 120 | int done; | |
| 121 | 214 | |
| 122 | done = dma8237_do_operation(device, channel); | |
| 215 | /* Check if operation is disabled */ | |
| 216 | if ( dma8237->command & 0x04 ) | |
| 217 | return; | |
| 123 | 218 | |
| 124 | if (done) | |
| 125 | { | |
| 126 | dma8237->status &= ~(0x10 << channel); | |
| 127 | dma8237->status |= (0x01 << channel); | |
| 128 | dma8237->drq &= ~(0x01 << channel); | |
| 129 | dma8237_update_status(device); | |
| 130 | } | |
| 131 | } | |
| 219 | switch ( dma8237->state ) { | |
| 132 | 220 | |
| 221 | case DMA8237_SI: | |
| 222 | /* Make sure EOP is high */ | |
| 223 | if ( ! dma8237->eop ) | |
| 224 | { | |
| 225 | dma8237->eop = 1; | |
| 226 | if ( dma8237->intf->out_eop_func ) | |
| 227 | dma8237->intf->out_eop_func( device, 0, dma8237->eop ? ASSERT_LINE : CLEAR_LINE ); | |
| 228 | } | |
| 133 | 229 | |
| 230 | /* Check if a new DMA request has been received. */ | |
| 231 | { | |
| 232 | /* Bit 6 of the command register determines whether the DREQ signals are active | |
| 233 | high or active low. */ | |
| 234 | UINT16 pending_request = ( ( dma8237->command & 0x40 ) ? ~dma8237->drq : dma8237->drq ) & ~dma8237->mask; | |
| 134 | 235 | |
| 135 | static TIMER_CALLBACK( dma8237_msbflip_timerproc ) | |
| 136 | { | |
| 137 | const device_config *device = ptr; | |
| 138 | dma8237_t *dma8237 = get_safe_token(device); | |
| 139 | dma8237->msb ^= 1; | |
| 140 | } | |
| 236 | if ( pending_request & 0x0f ) | |
| 237 | { | |
| 238 | int i, channel, prio_channel; | |
| 141 | 239 | |
| 240 | /* Determine the channel that should be serviced */ | |
| 241 | channel = ( dma8237->command & 0x10 ) ? dma8237->last_service_channel : 3; | |
| 242 | for ( i = 0; i < 4; i++ ) | |
| 243 | { | |
| 244 | if ( pending_request & ( 1 << channel ) ) | |
| 245 | prio_channel = channel; | |
| 246 | channel = ( channel - 1 ) & 0x03; | |
| 247 | } | |
| 142 | 248 | |
| 249 | /* Store the channel we will be servicing and go to the next state */ | |
| 250 | dma8237->service_channel = prio_channel; | |
| 251 | dma8237->last_service_channel = prio_channel; | |
| 252 | dma8237->hrq = 1; | |
| 253 | dma8237->intf->hrq_changed( device, dma8237->hrq ); | |
| 254 | dma8237->state = DMA8237_S0; | |
| 143 | 255 | |
| 144 | static void dma8237_update_status(const device_config *device) | |
| 145 | { | |
| 146 | dma8237_t *dma8237 = get_safe_token(device); | |
| 147 | UINT16 pending_transfer; | |
| 148 | int channel; | |
| 149 | UINT32 new_eop; | |
| 256 | timer_enable( dma8237->timer, 1 ); | |
| 257 | } | |
| 258 | else | |
| 259 | { | |
| 260 | timer_enable( dma8237->timer, 0 ); | |
| 261 | } | |
| 262 | } | |
| 263 | break; | |
| 150 | 264 | |
| 151 | if ((dma8237->status & 0xF0) == 0) | |
| 152 | { | |
| 153 | /* no transfer is active right now; is there a transfer pending right now? */ | |
| 154 | pending_transfer = dma8237->drq & ~dma8237->mask; | |
| 155 | ||
| 156 | if (pending_transfer) | |
| 265 | case DMA8237_S0: | |
| 266 | /* S0 is the first of the DMA service. We have requested a hold but are waiting | |
| 267 | for confirmation. */ | |
| 268 | if ( dma8237->hlda ) | |
| 157 | 269 | { |
| 158 | /* we do have a transfer in progress */ | |
| 159 | for (channel = 3; (pending_transfer & (1 << channel)) == 0; channel--) | |
| 160 | ; | |
| 270 | if ( dma8237->command & 0x01 ) | |
| 271 | { | |
| 272 | /* Memory-to-memory transfers */ | |
| 273 | dma8237->state = DMA8237_S11; | |
| 274 | } | |
| 275 | else | |
| 276 | { | |
| 277 | /* Regular transfers */ | |
| 278 | dma8237->state = DMA8237_S1; | |
| 279 | } | |
| 280 | } | |
| 281 | break; | |
| 161 | 282 | |
| 162 | dma8237->status |= 0x10 << channel; | |
| 163 | dma8237->status &= ~(0x01 << channel); | |
| 283 | case DMA8237_S1: /* Output A8-A15 */ | |
| 284 | dma8237->state = DMA8237_S2; | |
| 285 | break; | |
| 164 | 286 | |
| 165 | timer_adjust_periodic(dma8237->timer, | |
| 166 | attotime_zero, | |
| 167 | channel, | |
| 168 | double_to_attotime(dma8237->intf->bus_speed)); | |
| 169 | } | |
| 287 | case DMA8237_S2: /* Output A7-A0 */ | |
| 288 | /* Check for compressed timing */ | |
| 289 | if ( dma8237->command & 0x08 ) | |
| 290 | dma8237->state = DMA8237_S4; | |
| 170 | 291 | else |
| 292 | dma8237->state = DMA8237_S3; | |
| 293 | break; | |
| 294 | ||
| 295 | case DMA8237_S3: /* Initiate read */ | |
| 296 | dma8237_do_read( device ); | |
| 297 | dma8237->state = DMA8237_S4; | |
| 298 | break; | |
| 299 | ||
| 300 | case DMA8237_S4: /* Perform read/write */ | |
| 301 | /* Perform read when in compressed timing mode */ | |
| 302 | if ( dma8237->command & 0x08 ) | |
| 303 | dma8237_do_read( device ); | |
| 304 | ||
| 305 | /* Perform write */ | |
| 306 | dma8237_do_write( device ); | |
| 307 | ||
| 308 | /* Advance */ | |
| 309 | dma8237_advance( device ); | |
| 310 | ||
| 171 | 311 | { |
| 172 | /* no transfers active right now */ | |
| 173 | timer_reset(dma8237->timer, attotime_never); | |
| 174 | } | |
| 312 | int channel = dma8237->service_channel; | |
| 175 | 313 | |
| 176 | /* set the halt line */ | |
| 177 | if (dma8237->intf && dma8237->intf->cpunum >= 0) | |
| 178 | { | |
| 179 | cpunum_set_input_line(device->machine, dma8237->intf->cpunum, INPUT_LINE_HALT, | |
| 180 | pending_transfer ? ASSERT_LINE : CLEAR_LINE); | |
| 314 | switch( DMA_MODE_TRANSFERMODE( dma8237->chan[channel].mode ) ) | |
| 315 | { | |
| 316 | case DMA8237_DEMAND_MODE: | |
| 317 | /* Check for terminal count or EOP signal or DREQ begin de-asserted */ | |
| 318 | if ( ( dma8237->status & ( 0x01 << channel ) ) || ! dma8237->eop || ! ( dma8237->drq & ( 0x01 << channel ) ) ) | |
| 319 | { | |
| 320 | dma8237->hrq = 0; | |
| 321 | dma8237->hlda = 0; | |
| 322 | dma8237->intf->hrq_changed( device, dma8237->hrq ); | |
| 323 | dma8237->state = DMA8237_SI; | |
| 324 | } | |
| 325 | else | |
| 326 | { | |
| 327 | dma8237->state = dma8237->chan[channel].high_address_changed ? DMA8237_S1 : DMA8237_S2; | |
| 328 | } | |
| 329 | break; | |
| 330 | ||
| 331 | case DMA8237_SINGLE_MODE: | |
| 332 | dma8237->hrq = 0; | |
| 333 | dma8237->hlda = 0; | |
| 334 | dma8237->intf->hrq_changed( device, dma8237->hrq ); | |
| 335 | dma8237->state = DMA8237_SI; | |
| 336 | break; | |
| 337 | ||
| 338 | case DMA8237_BLOCK_MODE: | |
| 339 | /* Check for terminal count or EOP signal */ | |
| 340 | if ( ( dma8237->status & ( 0x01 << channel ) ) || ! dma8237->eop ) | |
| 341 | { | |
| 342 | dma8237->hrq = 0; | |
| 343 | dma8237->hlda = 0; | |
| 344 | dma8237->intf->hrq_changed( device, dma8237->hrq ); | |
| 345 | dma8237->state = DMA8237_SI; | |
| 346 | } | |
| 347 | else | |
| 348 | { | |
| 349 | dma8237->state = dma8237->chan[channel].high_address_changed ? DMA8237_S1 : DMA8237_S2; | |
| 350 | } | |
| 351 | break; | |
| 352 | ||
| 353 | case DMA8237_CASCADE_MODE: | |
| 354 | if ( ! ( dma8237->drq & ( 0x01 << channel ) ) ) | |
| 355 | { | |
| 356 | dma8237->hrq = 0; | |
| 357 | dma8237->hlda = 0; | |
| 358 | dma8237->intf->hrq_changed( device, dma8237->hrq ); | |
| 359 | dma8237->state = DMA8237_SI; | |
| 360 | } | |
| 361 | break; | |
| 362 | } | |
| 363 | ||
| 364 | /* Check if EOP output needs to be asserted */ | |
| 365 | if ( dma8237->status & ( 0x01 << channel ) ) | |
| 366 | { | |
| 367 | dma8237->eop = 0; | |
| 368 | if ( dma8237->intf->out_eop_func ) | |
| 369 | dma8237->intf->out_eop_func( device, channel, dma8237->eop ? ASSERT_LINE : CLEAR_LINE ); | |
| 370 | } | |
| 181 | 371 | } |
| 372 | break; | |
| 182 | 373 | |
| 183 | /* set the eop line, if it has changed */ | |
| 184 | new_eop = (dma8237->status & 0x0F) == 0x0F ? 1 : 0; | |
| 185 | if (dma8237->eop != new_eop) | |
| 186 | { | |
| 187 | dma8237->eop = new_eop; | |
| 188 | if (dma8237->intf->out_eop_func) | |
| 189 | dma8237->intf->out_eop_func(device, new_eop ? ASSERT_LINE : CLEAR_LINE); | |
| 190 | } | |
| 374 | case DMA8237_S11: /* Output A8-A15 */ | |
| 375 | break; | |
| 191 | 376 | } |
| 192 | 377 | } |
| 193 | 378 | |
| 194 | 379 | |
| 380 | static TIMER_CALLBACK( dma8237_msbflip_timerproc ) | |
| 381 | { | |
| 382 | const device_config *device = ptr; | |
| 383 | dma8237_t *dma8237 = get_safe_token(device); | |
| 384 | dma8237->msb ^= 1; | |
| 385 | } | |
| 195 | 386 | |
| 387 | ||
| 388 | ||
| 196 | 389 | /* ----------------------------------------------------------------------- */ |
| 197 | 390 | |
| 198 | 391 | |
| r3486 | r3487 | |
| 209 | 402 | { |
| 210 | 403 | dma8237_t *dma8237 = get_safe_token(device); |
| 211 | 404 | UINT8 data = 0xFF; |
| 212 | UINT8 mode; | |
| 213 | 405 | |
| 214 | 406 | offset &= 0x0F; |
| 215 | 407 | |
| r3486 | r3487 | |
| 221 | 413 | /* DMA address register */ |
| 222 | 414 | data = dma8237->chan[offset / 2].address >> (dma8237->msb ? 8 : 0); |
| 223 | 415 | prepare_msb_flip(device); |
| 224 | ||
| 225 | /* hack simulating refresh activity for 'ibmxt' BIOS; I do not know | |
| 226 | * why this is needed; but in any case, the ibmxt driver does not load | |
| 227 | * if this code is not present */ | |
| 228 | mode = dma8237->chan[0].mode; | |
| 229 | if ((DMA_MODE_OPERATION(mode) == 2) && (offset == 0)) | |
| 230 | { | |
| 231 | dma8237->chan[0].address++; | |
| 232 | dma8237->chan[0].count--; | |
| 233 | } | |
| 234 | 416 | break; |
| 235 | 417 | |
| 236 | 418 | case 1: |
| r3486 | r3487 | |
| 245 | 427 | case 8: |
| 246 | 428 | /* DMA status register */ |
| 247 | 429 | data = (UINT8) dma8237->status; |
| 430 | ||
| 431 | /* TC bits are cleared on a status read */ | |
| 432 | dma8237->status &= 0xF0; | |
| 248 | 433 | break; |
| 249 | 434 | |
| 250 | 435 | case 10: |
| r3486 | r3487 | |
| 265 | 450 | data = 0xFF; |
| 266 | 451 | break; |
| 267 | 452 | } |
| 453 | //printf("dma8237_r() %08x: offset = %02x, data = %02x\n", activecpu_get_pc(), offset, data); | |
| 268 | 454 | return data; |
| 269 | 455 | } |
| 270 | 456 | |
| r3486 | r3487 | |
| 275 | 461 | dma8237_t *dma8237 = get_safe_token(device); |
| 276 | 462 | int channel; |
| 277 | 463 | |
| 464 | //printf("dma8237_w() %08x: offset = %02x, data = %02x\n", activecpu_get_pc(), offset, data); | |
| 278 | 465 | offset &= 0x0F; |
| 279 | 466 | |
| 280 | 467 | switch(offset) { |
| r3486 | r3487 | |
| 283 | 470 | case 4: |
| 284 | 471 | case 6: |
| 285 | 472 | /* DMA address register */ |
| 473 | channel = offset / 2; | |
| 286 | 474 | if (dma8237->msb) |
| 287 | dma8237->chan[offset / 2].address |= ((UINT16) data) << 8; | |
| 475 | { | |
| 476 | dma8237->chan[channel].base_address = ( dma8237->chan[channel].base_address & 0x00FF ) | ( data << 8 ); | |
| 477 | dma8237->chan[channel].address = ( dma8237->chan[channel].address & 0x00FF ) | ( data << 8 ); | |
| 478 | } | |
| 288 | 479 | else |
| 289 | dma8237->chan[offset / 2].address = data; | |
| 480 | { | |
| 481 | dma8237->chan[channel].base_address = ( dma8237->chan[channel].base_address & 0xFF00 ) | data; | |
| 482 | dma8237->chan[channel].address = ( dma8237->chan[channel].address & 0xFF00 ) | data; | |
| 483 | } | |
| 290 | 484 | prepare_msb_flip(device); |
| 291 | 485 | break; |
| 292 | 486 | |
| r3486 | r3487 | |
| 295 | 489 | case 5: |
| 296 | 490 | case 7: |
| 297 | 491 | /* DMA count register */ |
| 492 | channel = offset / 2; | |
| 298 | 493 | if (dma8237->msb) |
| 299 | dma8237->chan[offset / 2].count |= ((UINT16) data) << 8; | |
| 494 | { | |
| 495 | dma8237->chan[channel].base_count = ( dma8237->chan[channel].base_count & 0x00FF ) | ( data << 8 ); | |
| 496 | dma8237->chan[channel].count = ( dma8237->chan[channel].count & 0x00FF ) | ( data << 8 ); | |
| 497 | } | |
| 300 | 498 | else |
| 301 | dma8237->chan[offset / 2].count = data; | |
| 499 | { | |
| 500 | dma8237->chan[channel].base_count = ( dma8237->chan[channel].base_count & 0xFF00 ) | data; | |
| 501 | dma8237->chan[channel].count = ( dma8237->chan[channel].count & 0xFF00 ) | data; | |
| 502 | } | |
| 302 | 503 | prepare_msb_flip(device); |
| 303 | 504 | break; |
| 304 | 505 | |
| 305 | 506 | case 8: |
| 306 | 507 | /* DMA command register */ |
| 307 | 508 | dma8237->command = data; |
| 509 | timer_enable( dma8237->timer, ( dma8237->command & 0x04 ) ? 0 : 1 ); | |
| 308 | 510 | break; |
| 309 | 511 | |
| 512 | case 9: | |
| 513 | /* DMA request register */ | |
| 514 | channel = DMA_MODE_CHANNEL(data); | |
| 515 | if ( data & 0x04 ) | |
| 516 | { | |
| 517 | dma8237->drq |= 0x01 << channel; | |
| 518 | timer_enable( dma8237->timer, ( dma8237->command & 0x04 ) ? 0 : 1 ); | |
| 519 | } | |
| 520 | else | |
| 521 | { | |
| 522 | dma8237->status &= ~ ( 0x10 << channel ); | |
| 523 | dma8237->drq &= ~ ( 0x01 << channel ); | |
| 524 | } | |
| 525 | break; | |
| 526 | ||
| 310 | 527 | case 10: |
| 311 | 528 | /* DMA mask register */ |
| 312 | 529 | channel = DMA_MODE_CHANNEL(data); |
| r3486 | r3487 | |
| 320 | 537 | /* DMA mode register */ |
| 321 | 538 | channel = DMA_MODE_CHANNEL(data); |
| 322 | 539 | dma8237->chan[channel].mode = data; |
| 540 | /* Apparently mode writes also clear the TC bit(?) */ | |
| 541 | dma8237->status &= ~ ( 1 << channel ); | |
| 323 | 542 | break; |
| 324 | 543 | |
| 325 | 544 | case 12: |
| r3486 | r3487 | |
| 331 | 550 | case 13: |
| 332 | 551 | /* DMA master clear */ |
| 333 | 552 | dma8237->msb = 0; |
| 553 | dma8237->mask = 0x0f; | |
| 554 | dma8237->state = DMA8237_SI; | |
| 555 | dma8237->status &= 0xF0; | |
| 334 | 556 | break; |
| 335 | 557 | |
| 336 | 558 | case 14: |
| 337 | 559 | /* DMA clear mask register */ |
| 338 | 560 | dma8237->mask &= ~data; |
| 339 | dma8237 | |
| 561 | dma8237->m | |
| 340 | 562 | break; |
| 341 | 563 | |
| 342 | 564 | case 15: |
| r3486 | r3487 | |
| 347 | 569 | } |
| 348 | 570 | |
| 349 | 571 | |
| 350 | ||
| 351 | static void dma8237_drq_write_callback(const device_config *device, int param) | |
| 572 | void dma8237_drq_write(const device_config *device, int channel, int state) | |
| 352 | 573 | { |
| 353 | dma8237_t *dma8237 = get_safe_token(device); | |
| 354 | int channel = (param >> 1) & 0x03; | |
| 355 | int state = param & 0x01; | |
| 574 | dma8237_t *dma8237 = get_safe_token( device ); | |
| 356 | 575 | |
| 357 | /* normalize state */ | |
| 358 | 576 | if (state) |
| 359 | dma8237->drq |= 0x01 << channel; | |
| 577 | dma8237->drq |= ( 0x01 << channel ); | |
| 360 | 578 | else |
| 361 | dma8237->drq &= ~(0x01 << channel); | |
| 579 | dma8237->drq &= ~( 0x01 << channel ); | |
| 362 | 580 | |
| 363 | dma8237 | |
| 581 | timer_enable( dma8237-> | |
| 364 | 582 | } |
| 365 | 583 | |
| 366 | 584 | |
| 585 | void dma8237_set_hlda(const device_config *device, int state) | |
| 586 | { | |
| 587 | dma8237_t *dma8237 = get_safe_token( device ); | |
| 367 | 588 | |
| 368 | void dma8237_drq_write(const device_config *device, int channel, int state) | |
| 369 | { | |
| 370 | int param = (channel << 1) | (state ? 1 : 0); | |
| 371 | //timer_call_after_resynch(NULL, param, dma8237_drq_write_callback); | |
| 372 | dma8237_drq_write_callback(device, param); | |
| 589 | dma8237->hlda = state; | |
| 373 | 590 | } |
| 374 | 591 | |
| 375 | 592 | |
| r3486 | r3487 | |
| 382 | 599 | |
| 383 | 600 | dma8237->status |= 0x10 << channel; /* reset DMA running flag */ |
| 384 | 601 | |
| 385 | while(!dma8237_do_operation(device, channel)) | |
| 386 | ; | |
| 602 | logerror("dma8237_run_transfer: please do not use me anymore\n"); | |
| 387 | 603 | |
| 388 | 604 | dma8237->status &= ~(0x10 << channel); |
| 389 | 605 | dma8237->status |= (0x01 << channel); |
| r3486 | r3487 | |
| 403 | 619 | static DEVICE_RESET( dma8237 ) { |
| 404 | 620 | dma8237_t *dma8237 = get_safe_token(device); |
| 405 | 621 | |
| 406 | dma8237->status = 0x0F; | |
| 407 | 622 | dma8237->timer = timer_alloc(dma8237_timerproc, (void *)device); |
| 408 | 623 | dma8237->msbflip_timer = timer_alloc(dma8237_msbflip_timerproc, (void *)device); |
| 409 | 624 | dma8237->eop = 1; |
| 625 | dma8237->state = DMA8237_SI; | |
| 626 | dma8237->last_service_channel = 3; | |
| 410 | 627 | |
| 411 | 628 | dma8237->mask = 0x00; |
| 412 | dma8237->status = 0x0F; | |
| 629 | dma8237->status = 0x00; | |
| 630 | dma8237->hrq = 0; | |
| 631 | dma8237->hlda = 0; | |
| 413 | 632 | dma8237->chan[0].mode = 0; |
| 414 | 633 | dma8237->chan[1].mode = 0; |
| 415 | 634 | dma8237->chan[2].mode = 0; |
| 416 | 635 | dma8237->chan[3].mode = 0; |
| 417 | 636 | |
| 418 | dma8237_update_status(device); | |
| 637 | timer_adjust_periodic(dma8237->timer, | |
| 638 | ATTOTIME_IN_HZ(dma8237->intf->bus_speed), | |
| 639 | 0, | |
| 640 | ATTOTIME_IN_HZ(dma8237->intf->bus_speed)); | |
| 419 | 641 | } |
| 420 | 642 | |
| 421 | 643 |
| r3486 | r3487 | |
|---|---|---|
| 9 | 9 | |
| 10 | 10 | #define DMA8237 DEVICE_GET_INFO_NAME(dma8237) |
| 11 | 11 | |
| 12 | typedef void (*dma8237_hrq_func)(const device_config *device, int state); | |
| 12 | 13 | typedef UINT8 (*dma8237_mem_read_func)(const device_config *device, int channel, offs_t offset); |
| 13 | 14 | typedef void (*dma8237_mem_write_func)(const device_config *device, int channel, offs_t offset, UINT8 data); |
| 14 | 15 | typedef int (*dma8237_channel_read_func)(const device_config *device); |
| 15 | 16 | typedef void (*dma8237_channel_write_func)(const device_config *device, int data); |
| 16 | typedef void (*dma8237_out_eop_func)(const device_config *device, int state); | |
| 17 | typedef void (*dma8237_out_eop_func)(const device_config *device, int channel, int state); | |
| 17 | 18 | |
| 19 | #define DMA8237_HRQ_CHANGED(name) void name(const device_config *device, int state) | |
| 18 | 20 | #define DMA8237_MEM_READ(name) UINT8 name(const device_config *device, int channel, offs_t offset) |
| 19 | 21 | #define DMA8237_MEM_WRITE(name) void name(const device_config *device, int channel, offs_t offset, UINT8 data) |
| 20 | 22 | #define DMA8237_CHANNEL_READ(name) int name(const device_config *device) |
| 21 | 23 | #define DMA8237_CHANNEL_WRITE(name) void name(const device_config *device, int data) |
| 22 | #define DMA8237_OUT_EOP(name) void name(const device_config *device, int state) | |
| 24 | #define DMA8237_OUT_EOP(name) void name(const device_config *device, int channel, int state) | |
| 23 | 25 | |
| 26 | ||
| 24 | 27 | struct dma8237_interface |
| 25 | 28 | { |
| 26 | /* CPU to halt when DMA is active */ | |
| 27 | int cpunum; | |
| 28 | ||
| 29 | 29 | /* speed of DMA accesses (per byte) */ |
| 30 | 30 | double bus_speed; |
| 31 | 31 | |
| 32 | /* function that will be called when HRQ may have changed */ | |
| 33 | dma8237_hrq_func hrq_changed; | |
| 34 | ||
| 32 | 35 | /* accessors to main memory */ |
| 33 | 36 | dma8237_mem_read_func memory_read_func; |
| 34 | 37 | dma8237_mem_write_func memory_write_func; |
| r3486 | r3487 | |
| 47 | 50 | READ8_DEVICE_HANDLER( dma8237_r ); |
| 48 | 51 | WRITE8_DEVICE_HANDLER( dma8237_w ); |
| 49 | 52 | void dma8237_drq_write(const device_config *device, int channel, int state); |
| 53 | void dma8237_set_hlda(const device_config *device, int state); | |
| 50 | 54 | |
| 51 | 55 | /* unfortunate hack for the interim for PC HDC */ |
| 52 | 56 | void dma8237_run_transfer(const device_config *device, int channel); |
| r3486 | r3487 | |
|---|---|---|
| 345 | 345 | } |
| 346 | 346 | |
| 347 | 347 | if (LOG_MC146818) |
| 348 | logerror("mc146818_port_r(): index=0x%02x data=0x%02x\n", mc146818->index, data); | |
| 348 | logerror("mc146818_port_r(): offset=0x%02x index=0x%02x data=0x%02x\n", offset, mc146818->index, data); | |
| 349 | 349 | return data; |
| 350 | 350 | } |
| 351 | 351 | |
| r3486 | r3487 | |
| 354 | 354 | WRITE8_HANDLER(mc146818_port_w) |
| 355 | 355 | { |
| 356 | 356 | if (LOG_MC146818) |
| 357 | logerror("mc146818_port_w(): index=0x%02x data=0x%02x\n", mc146818->index, data); | |
| 357 | logerror("mc146818_port_w(): offset=0x%02x index=0x%02x data=0x%02x\n", offset, mc146818->index, data); | |
| 358 | 358 | |
| 359 | 359 | switch (offset) { |
| 360 | 360 | case 0: |
| r3486 | r3487 | |
|---|---|---|
| 225 | 225 | void tx0_64kw_get_info(UINT32 state, cpuinfo *info); |
| 226 | 226 | void tx0_8kw_get_info(UINT32 state, cpuinfo *info); |
| 227 | 227 | void lr35902_get_info(UINT32 state, cpuinfo *info); |
| 228 | void tms0980_get_info(UINT32 state, cpuinfo *indo); | |
| 228 | 229 | void tms7000_get_info(UINT32 state, cpuinfo *info); |
| 229 | 230 | void tms7000_exl_get_info(UINT32 state, cpuinfo *info); |
| 230 | 231 | void sm8500_get_info(UINT32 state, cpuinfo *info); |
| r3486 | r3487 | |
| 877 | 878 | #if (HAS_LR35902) |
| 878 | 879 | { CPU_LR35902, lr35902_get_info }, |
| 879 | 880 | #endif |
| 881 | #if (HAS_TMS0980) | |
| 882 | { CPU_TMS0980, tms0980_get_info }, | |
| 883 | #endif | |
| 880 | 884 | #if (HAS_TMS7000) |
| 881 | 885 | { CPU_TMS7000, tms7000_get_info }, |
| 882 | 886 | #endif |
| r3486 | r3487 | |
|---|---|---|
| 252 | 252 | CPU_TX0_64KW, |
| 253 | 253 | CPU_TX0_8KW, |
| 254 | 254 | CPU_LR35902, |
| 255 | CPU_TMS0980, | |
| 255 | 256 | CPU_TMS7000, |
| 256 | 257 | CPU_TMS7000_EXL, |
| 257 | 258 | CPU_SM8500, |
| r3486 | r3487 | |
|---|---|---|
| 81 | 81 | emu_timer *hsync_off_timer; |
| 82 | 82 | emu_timer *vsync_on_timer; |
| 83 | 83 | emu_timer *vsync_off_timer; |
| 84 | emu_timer *vblank_on_timer; | |
| 85 | emu_timer *vblank_off_timer; | |
| 84 | 86 | emu_timer *light_pen_latch_timer; |
| 85 | 87 | |
| 86 | 88 | /* computed values - do NOT state save these! */ |
| r3486 | r3487 | |
| 104 | 106 | static void update_de_changed_timer(crtc_ega_t *crtc_ega); |
| 105 | 107 | static void update_hsync_changed_timers(crtc_ega_t *crtc_ega); |
| 106 | 108 | static void update_vsync_changed_timers(crtc_ega_t *crtc_ega); |
| 109 | static void update_vblank_changed_timers(crtc_ega_t *crtc_ega); | |
| 107 | 110 | |
| 108 | 111 | |
| 109 | 112 | /* makes sure that the passed in device is the right type */ |
| r3486 | r3487 | |
| 306 | 309 | update_de_changed_timer(crtc_ega); |
| 307 | 310 | update_hsync_changed_timers(crtc_ega); |
| 308 | 311 | update_vsync_changed_timers(crtc_ega); |
| 312 | update_vblank_changed_timers(crtc_ega); | |
| 309 | 313 | } |
| 310 | 314 | } |
| 311 | 315 | } |
| r3486 | r3487 | |
| 401 | 405 | } |
| 402 | 406 | |
| 403 | 407 | |
| 408 | static void update_vblank_changed_timers(crtc_ega_t *crtc_ega) | |
| 409 | { | |
| 410 | if (crtc_ega->has_valid_parameters && (crtc_ega->vblank_on_timer != NULL)) | |
| 411 | { | |
| 412 | timer_adjust_oneshot(crtc_ega->vblank_on_timer, video_screen_get_time_until_pos(crtc_ega->screen, crtc_ega->vert_disp_end, crtc_ega->hsync_on_pos), 0); | |
| 413 | timer_adjust_oneshot(crtc_ega->vblank_off_timer, video_screen_get_time_until_pos(crtc_ega->screen, 0, crtc_ega->hsync_off_pos), 0); | |
| 414 | } | |
| 415 | } | |
| 416 | ||
| 417 | ||
| 404 | 418 | static TIMER_CALLBACK( de_changed_timer_cb ) |
| 405 | 419 | { |
| 406 | 420 | const device_config *device = ptr; |
| r3486 | r3487 | |
| 458 | 472 | |
| 459 | 473 | |
| 460 | 474 | |
| 475 | static TIMER_CALLBACK( vblank_on_timer_cb ) | |
| 476 | { | |
| 477 | const device_config *device = ptr; | |
| 478 | crtc_ega_t *crtc_ega = get_safe_token(device); | |
| 479 | ||
| 480 | /* call the callback function -- we know it exists */ | |
| 481 | crtc_ega->intf->on_vblank_changed(device, TRUE); | |
| 482 | ||
| 483 | update_vblank_changed_timers(crtc_ega); | |
| 484 | } | |
| 485 | ||
| 486 | ||
| 487 | static TIMER_CALLBACK( vblank_off_timer_cb ) | |
| 488 | { | |
| 489 | const device_config *device = ptr; | |
| 490 | crtc_ega_t *crtc_ega = get_safe_token(device); | |
| 491 | ||
| 492 | /* call the callback function -- we know it exists */ | |
| 493 | crtc_ega->intf->on_vblank_changed(device, FALSE); | |
| 494 | ||
| 495 | update_vblank_changed_timers(crtc_ega); | |
| 496 | } | |
| 497 | ||
| 498 | ||
| 461 | 499 | UINT16 crtc_ega_get_ma(const device_config *device) |
| 462 | 500 | { |
| 463 | 501 | UINT16 ret; |
| r3486 | r3487 | |
| 719 | 757 | crtc_ega->vsync_on_timer = timer_alloc(vsync_on_timer_cb, (void *)device); |
| 720 | 758 | crtc_ega->vsync_off_timer = timer_alloc(vsync_off_timer_cb, (void *)device); |
| 721 | 759 | } |
| 760 | ||
| 761 | if (crtc_ega->intf->on_vblank_changed != NULL) | |
| 762 | { | |
| 763 | crtc_ega->vblank_on_timer = timer_alloc(vblank_on_timer_cb, (void *)device); | |
| 764 | crtc_ega->vblank_off_timer = timer_alloc(vblank_off_timer_cb, (void *)device); | |
| 765 | } | |
| 722 | 766 | } |
| 723 | 767 | |
| 724 | 768 | crtc_ega->light_pen_latch_timer = timer_alloc(light_pen_latch_timer_cb, (void *)device); |
| r3486 | r3487 | |
|---|---|---|
| 34 | 34 | typedef void (*crtc_ega_on_vsync_changed_func)(const device_config *device, int vsync); |
| 35 | 35 | #define CRTC_EGA_ON_VSYNC_CHANGED(name) void name(const device_config *device, int vsync) |
| 36 | 36 | |
| 37 | typedef void (*crtc_ega_on_vblank_changed_func)(const device_config *device, int vblank); | |
| 38 | #define CRTC_EGA_ON_VBLANK_CHANGED(name) void name(const device_config *device, int vblank) | |
| 37 | 39 | |
| 40 | ||
| 38 | 41 | /* interface */ |
| 39 | 42 | typedef struct _crtc_ega_interface crtc_ega_interface; |
| 40 | 43 | struct _crtc_ega_interface |
| 41 | 44 | { |
| 42 | 45 | const char *screen_tag; /* screen we are acting on */ |
| 43 | int clock; /* the clock | |
| 46 | int clock; /* the clock | |
| 44 | 47 | int hpixels_per_column; /* number of pixels per video memory address */ |
| 45 | 48 | |
| 46 | 49 | /* if specified, this gets called before any pixel update, |
| r3486 | r3487 | |
| 57 | 60 | /* if specified, this gets called after all row updating is complete */ |
| 58 | 61 | crtc_ega_end_update_func end_update; |
| 59 | 62 | |
| 60 | /* if specified, this gets called for every change of the disply enable | |
| 63 | /* if specified, this gets called for every change of the disply enable signal | |
| 61 | 64 | crtc_ega_on_de_changed_func on_de_changed; |
| 62 | 65 | |
| 63 | /* if specified, this gets called for every change of the HSYNC | |
| 66 | /* if specified, this gets called for every change of the HSYNC signal | |
| 64 | 67 | crtc_ega_on_hsync_changed_func on_hsync_changed; |
| 65 | 68 | |
| 66 | /* if specified, this gets called for every change of the VSYNC | |
| 69 | /* if specified, this gets called for every change of the VSYNC signal | |
| 67 | 70 | crtc_ega_on_vsync_changed_func on_vsync_changed; |
| 71 | ||
| 72 | /* if specificed, this gets called for every change of the VBLAnk signal */ | |
| 73 | crtc_ega_on_vblank_changed_func on_vblank_changed; | |
| 68 | 74 | }; |
| 69 | 75 | |
| 70 | 76 |
| r3486 | r3487 | |
|---|---|---|
| 123 | 123 | |
| 124 | 124 | WRITE8_HANDLER ( pc_video_videoram_w ) |
| 125 | 125 | { |
| 126 | offset %= videoram_size; | |
| 126 | 127 | if (videoram && videoram[offset] != data) |
| 127 | 128 | { |
| 128 | 129 | videoram[offset] = data; |
| r3486 | r3487 | |
|---|---|---|
| 55 | 55 | 1 = video is being displayed |
| 56 | 56 | |
| 57 | 57 | |
| 58 | Configuration switches | |
| 59 | SW1 SW2 SW3 SW4 | |
| 60 | OFF OFF OFF ON - EGA, Color 80x25 (5153) | |
| 61 | - EGA (primary) + MDA, Color 80x25 + Monochrome | |
| 62 | OFF OFF ON OFF - EGA, Monochrome (5151) | |
| 63 | - EGA (primary) + CGA, Monochrome + Color 80x25 | |
| 64 | OFF OFF ON ON - EGA + MDA (primary), 5154 + Enhanced Monochrome | |
| 65 | OFF ON OFF ON - EGA + CGA (primary), Monochrome + Color 80x25 | |
| 66 | OFF ON ON OFF - EGA, Enhanced Color - Enhanced Mode (5154) | |
| 67 | - EGA (primary) + MDA, 5154 monitor + Enhanced Monochrome | |
| 68 | OFF ON ON ON - EGA + MDA (primary), Color 80x25 + Monochrome | |
| 69 | ON OFF OFF ON - EGA, Color 40x25 (5153) | |
| 70 | - EGA (primary) + MDA, Color 40x25 + Monochrome | |
| 71 | ON OFF ON OFF - EGA (primary) + CGA, Monochrome + Color 40x25 | |
| 72 | ON OFF ON ON - EGA + MDA (primary), 5154 + Normal Monochrome | |
| 73 | ON ON OFF ON - EGA + CGA (primary), Monochrome + Color 40x25 | |
| 74 | ON ON ON OFF - EGA, Enhanced Color - Enhanced Mode (5154) | |
| 75 | - EGA (primary) + MDA, 5154 monitor + Normal Monochrome | |
| 76 | ON ON ON ON - EGA + MDA (primary), Color 40x25 + Monochrome | |
| 77 | ||
| 78 | ||
| 58 | 79 | 3XA - 7 6 5 4 3 2 1 0 - Feature Control Register - Write Only |
| 59 | 80 | | | | | | | | | |
| 60 | 81 | | | | | | | | +-- output to FEAT0 of the feature connector |
| r3486 | r3487 | |
| 77 | 98 | | | | | | +------ light pen switch |
| 78 | 99 | | | | | | 0 = switch is closed |
| 79 | 100 | | | | | | 1 = switch is open |
| 80 | | | | | +-------- vertical | |
| 101 | | | | | +-------- vertical bl | |
| 81 | 102 | | | | | 0 = video information is being displayed |
| 82 | | | | | 1 = CRT is in vertical | |
| 103 | | | | | 1 = CRT is in vertical bl | |
| 83 | 104 | | | | +---------- diagnostic usage |
| 84 | 105 | | | +------------ diagnostic usage |
| 85 | 106 | | +-------------- reserved/unused |
| 86 | 107 | +---------------- reserved/unused |
| 87 | 108 | |
| 109 | We think bits 4 and 5 of the status register contain some information about the | |
| 110 | current pixel that is being drawn. Those bits do not seem to be documented. | |
| 88 | 111 | |
| 112 | ||
| 89 | 113 | The EGA graphics card introduces a lot of new indexed registers to handle the |
| 90 | 114 | enhanced graphics. These new indexed registers can be divided into three |
| 91 | 115 | groups: |
| r3486 | r3487 | |
| 416 | 440 | #include "memconv.h" |
| 417 | 441 | |
| 418 | 442 | |
| 419 | #define VERBOSE_EGA | |
| 443 | #define VERBOSE_EGA | |
| 420 | 444 | |
| 421 | 445 | |
| 422 | 446 | static struct |
| r3486 | r3487 | |
| 461 | 485 | |
| 462 | 486 | UINT8 frame_cnt; |
| 463 | 487 | UINT8 vsync; |
| 488 | UINT8 vblank; | |
| 464 | 489 | UINT8 display_enable; |
| 465 | 490 | } ega; |
| 466 | 491 | |
| r3486 | r3487 | |
| 474 | 499 | static CRTC_EGA_UPDATE_ROW( ega_update_row ); |
| 475 | 500 | static CRTC_EGA_ON_DE_CHANGED( ega_de_changed ); |
| 476 | 501 | static CRTC_EGA_ON_VSYNC_CHANGED( ega_vsync_changed ); |
| 502 | static CRTC_EGA_ON_VBLANK_CHANGED( ega_vblank_changed ); | |
| 477 | 503 | static READ8_HANDLER( pc_ega8_3b0_r ); |
| 478 | 504 | static WRITE8_HANDLER( pc_ega8_3b0_w ); |
| 479 | 505 | static READ16_HANDLER( pc_ega16le_3b0_r ); |
| r3486 | r3487 | |
| 507 | 533 | NULL, /* end_update */ |
| 508 | 534 | ega_de_changed, /* on_de_chaged */ |
| 509 | 535 | NULL, /* on_hsync_changed */ |
| 510 | ega_vsync_changed /* on_vsync_changed */ | |
| 536 | ega_vsync_changed, /* on_vsync_changed */ | |
| 537 | ega_vblank_changed /* on_vblank_changed */ | |
| 511 | 538 | }; |
| 512 | 539 | |
| 513 | 540 | |
| r3486 | r3487 | |
| 692 | 719 | } |
| 693 | 720 | |
| 694 | 721 | |
| 722 | static CRTC_EGA_ON_VBLANK_CHANGED( ega_vblank_changed ) | |
| 723 | { | |
| 724 | ega.vblank = vblank ? 8 : 0; | |
| 725 | } | |
| 726 | ||
| 727 | ||
| 695 | 728 | static CRTC_EGA_UPDATE_ROW( pc_ega_graphics ) |
| 696 | 729 | { |
| 697 | 730 | UINT16 *p = BITMAP_ADDR16(bitmap, y, 0); |
| r3486 | r3487 | |
| 812 | 845 | |
| 813 | 846 | /* Input Status Register 1 */ |
| 814 | 847 | case 10: |
| 815 | data = ega.v | |
| 848 | data = ega.vblank | ega.display_enable; | |
| 816 | 849 | |
| 850 | if ( ega.display_enable ) | |
| 851 | { | |
| 852 | /* For the moment i'm putting in some thought up data */ | |
| 853 | static int pixel_data; | |
| 854 | ||
| 855 | pixel_data = ( pixel_data + 1 ) & 0x03; | |
| 856 | data |= ( pixel_data << 4 ); | |
| 857 | } | |
| 817 | 858 | /* Reset the attirubte writing flip flop to let the next write go to the index reigster */ |
| 818 | 859 | ega.attribute.index_write = 1; |
| 819 | 860 | break; |
| r3486 | r3487 | |
| 890 | 931 | |
| 891 | 932 | static READ8_HANDLER( pc_ega8_3c0_r ) |
| 892 | 933 | { |
| 934 | UINT8 dips = 0x01; /* EGA only, 80x25 color */ | |
| 893 | 935 | int data = 0xff; |
| 894 | 936 | |
| 895 | 937 | if ( VERBOSE_EGA ) |
| r3486 | r3487 | |
| 905 | 947 | |
| 906 | 948 | /* Feature Read */ |
| 907 | 949 | case 2: |
| 908 | data = ( data & 0x0 | |
| 950 | data = ( data & 0x0f ); | |
| 909 | 951 | data |= ( ( ega.feature_control & 0x03 ) << 5 ); |
| 910 | 952 | data |= ( ega.vsync ? 0x00 : 0x80 ); |
| 953 | data |= ( ( ( dips >> ( 3 - ( ( ega.misc_output & 0xc0 ) >> 2 ) ) ) & 0x01 ) << 4 ); | |
| 911 | 954 | break; |
| 912 | 955 | |
| 913 | 956 | /* Sequencer */ |
| r3486 | r3487 | |
|---|---|---|
| 1096 | 1096 | DRIVER( dallas32 ) /* Dallas */ |
| 1097 | 1097 | DRIVER( roma ) /* Roma */ |
| 1098 | 1098 | DRIVER( roma32 ) /* Roma */ |
| 1099 | DRIVER( stopthie ) | |
| 1099 | 1100 | |
| 1100 | 1101 | /*********** Misc ***********************************************************/ |
| 1101 | 1102 | DRIVER( ex800 ) |
| r3486 | r3487 | |
|---|---|---|
| 34 | 34 | |
| 35 | 35 | #include "machine/kb_keytro.h" |
| 36 | 36 | |
| 37 | #define LOG_PORT80 | |
| 37 | #define LOG_PORT80 1 | |
| 38 | 38 | #define LOG_KBDC 0 |
| 39 | 39 | |
| 40 | 40 | static struct { |
| 41 | int cpunum_main; | |
| 41 | 42 | const device_config *pic8259_master; |
| 42 | 43 | const device_config *pic8259_slave; |
| 43 | 44 | const device_config *dma8237_1; |
| r3486 | r3487 | |
| 242 | 243 | } |
| 243 | 244 | |
| 244 | 245 | |
| 246 | static DMA8237_HRQ_CHANGED( pc_dma_hrq_changed ) | |
| 247 | { | |
| 248 | cpunum_set_input_line(device->machine, at_devices.cpunum_main, INPUT_LINE_HALT, | |
| 249 | state ? ASSERT_LINE : CLEAR_LINE); | |
| 250 | ||
| 251 | /* Assert HLDA */ | |
| 252 | dma8237_set_hlda( device, state ); | |
| 253 | } | |
| 254 | ||
| 255 | ||
| 245 | 256 | static DMA8237_MEM_READ( pc_dma_read_byte ) |
| 246 | 257 | { |
| 247 | 258 | UINT8 result; |
| r3486 | r3487 | |
| 294 | 305 | |
| 295 | 306 | const struct dma8237_interface at_dma8237_1_config = |
| 296 | 307 | { |
| 297 | 0, | |
| 298 | 1.0e-6, // 1us | |
| 308 | XTAL_14_31818MHz/3, | |
| 299 | 309 | |
| 310 | pc_dma_hrq_changed, | |
| 300 | 311 | pc_dma_read_byte, |
| 301 | 312 | pc_dma_write_byte, |
| 302 | 313 | |
| r3486 | r3487 | |
| 309 | 320 | /* TODO: How is this hooked up in the actual machine? */ |
| 310 | 321 | const struct dma8237_interface at_dma8237_2_config = |
| 311 | 322 | { |
| 312 | 0, | |
| 313 | 1.0e-6, // 1us | |
| 323 | XTAL_14_31818MHz/3, | |
| 314 | 324 | |
| 325 | pc_dma_hrq_changed, | |
| 315 | 326 | pc_dma_read_byte, |
| 316 | 327 | pc_dma_write_byte, |
| 317 | 328 | |
| r3486 | r3487 | |
| 488 | 499 | |
| 489 | 500 | cpunum_set_input_line(machine, 0, INPUT_LINE_RESET, ( data & 0x01 ) ? CLEAR_LINE : ASSERT_LINE ); |
| 490 | 501 | |
| 491 | at_kbdc8042.clock_signal = ( data & 0x40 ) ? 1 : 0; | |
| 502 | at_set_keyb_int( ( data & 0x10 ) ? 1 : 0 ); | |
| 503 | ||
| 504 | at_kbdc8042.clock_signal = ( data & 0x40 ) ? 0 : 1; | |
| 492 | 505 | at_kbdc8042.data_signal = ( data & 0x80 ) ? 1 : 0; |
| 493 | 506 | |
| 494 | 507 | at_kbdc8042.data_callback( machine, 0, at_kbdc8042.data_signal ); |
| r3486 | r3487 | |
| 511 | 524 | static WRITE8_HANDLER( at_kbdc8042_set_clock_signal ) |
| 512 | 525 | { |
| 513 | 526 | at_kbdc8042.clock_signal = data; |
| 527 | at_kbdc8042.clock_callback( machine, 0, at_kbdc8042.clock_signal); | |
| 514 | 528 | } |
| 515 | 529 | |
| 516 | 530 | |
| 517 | 531 | static WRITE8_HANDLER( at_kbdc8042_set_data_signal ) |
| 518 | 532 | { |
| 519 | 533 | at_kbdc8042.data_signal = data; |
| 534 | at_kbdc8042.data_callback( machine, 0, at_kbdc8042.data_signal ); | |
| 520 | 535 | } |
| 521 | 536 | |
| 522 | 537 | |
| r3486 | r3487 | |
| 775 | 790 | |
| 776 | 791 | MACHINE_RESET( at ) |
| 777 | 792 | { |
| 793 | at_devices.cpunum_main = mame_find_cpu_index( machine, "main" ); | |
| 778 | 794 | at_devices.pic8259_master = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_master" ); |
| 779 | 795 | at_devices.pic8259_slave = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_slave" ); |
| 780 | 796 | at_devices.dma8237_1 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" ); |
| r3486 | r3487 | |
|---|---|---|
| 37 | 37 | #include "deprecat.h" |
| 38 | 38 | |
| 39 | 39 | |
| 40 | #define LOG_HDC_STATUS 0 | |
| 41 | #define LOG_HDC_CALL 0 | |
| 40 | #define LOG_HDC_STATUS 1 | |
| 41 | #define LOG_HDC_CALL 1 | |
| 42 | 42 | #define LOG_HDC_DATA 0 |
| 43 | 43 | |
| 44 | 44 | |
| r3486 | r3487 | |
| 415 | 415 | |
| 416 | 416 | if (no_dma()) |
| 417 | 417 | { |
| 418 | printf("pc_hdc: execute_read without DMA\n"); | |
| 418 | 419 | do |
| 419 | 420 | { |
| 420 | 421 | buffer[data_cnt++] = pc_hdc_dack_r(); |
| r3486 | r3487 | |
| 422 | 423 | } |
| 423 | 424 | else |
| 424 | 425 | { |
| 426 | printf("pc_hdc: execute_read through DMA\n"); | |
| 425 | 427 | dma8237_run_transfer(pc_hdc_dma8237, HDC_DMA); |
| 426 | 428 | } |
| 427 | 429 | } |
| r3486 | r3487 | |
| 446 | 448 | |
| 447 | 449 | if (no_dma()) |
| 448 | 450 | { |
| 451 | //printf("pc_hdc: execute_write without DMA\n"); | |
| 449 | 452 | do |
| 450 | 453 | { |
| 451 | 454 | pc_hdc_dack_w(buffer[data_cnt++]); |
| r3486 | r3487 | |
| 454 | 457 | } |
| 455 | 458 | else |
| 456 | 459 | { |
| 460 | printf("pc_hdc: execute_write through DMA\n"); | |
| 457 | 461 | dma8237_run_transfer(pc_hdc_dma8237, HDC_DMA); |
| 458 | 462 | } |
| 459 | 463 | } |
| r3486 | r3487 | |
|---|---|---|
| 35 | 35 | |
| 36 | 36 | /* uncomment the following line for verbose information */ |
| 37 | 37 | #define LOG_VERBOSE 1 |
| 38 | #define LOG_COMMAND | |
| 38 | #define LOG_COMMAND 1 | |
| 39 | 39 | #define LOG_EXTRA 0 |
| 40 | 40 | #define LOG_INTERRUPT 0 |
| 41 | 41 | |
| r3486 | r3487 | |
| 116 | 116 | emu_timer *timer; |
| 117 | 117 | int timer_type; |
| 118 | 118 | |
| 119 | int double_step; | |
| 120 | ||
| 119 | 121 | emu_timer *command_timer; |
| 120 | 122 | } NEC765; |
| 121 | 123 | |
| r3486 | r3487 | |
| 862 | 864 | in the read/write command did not match the C value read from the disc */ |
| 863 | 865 | |
| 864 | 866 | /* no data - checked on Amstrad CPC */ |
| 867 | logerror("ST1_NO_DATA: C = %02x, H = %02x, N = %02x\n", id.C, id.H, id.N); | |
| 865 | 868 | fdc.nec765_status[1] |= NEC765_ST1_NO_DATA; |
| 866 | 869 | /* bad C value */ |
| 867 | 870 | fdc.nec765_status[2] |= NEC765_ST2_WRONG_CYLINDER; |
| r3486 | r3487 | |
| 926 | 929 | fdc.nec765_result_bytes[5] = fdc.nec765_command_bytes[4]; /* R */ |
| 927 | 930 | fdc.nec765_result_bytes[6] = fdc.nec765_command_bytes[5]; /* N */ |
| 928 | 931 | |
| 932 | /* Is the MultiTrack bit set in the original command */ | |
| 933 | if ( fdc.nec765_command_bytes[0] & 0x80 ) | |
| 934 | { | |
| 935 | /* Check if we're at the end of the track */ | |
| 936 | if ( fdc.nec765_command_bytes[4] == fdc.nec765_command_bytes[6] && fdc.nec765_command_bytes[3] ) | |
| 937 | { | |
| 938 | fdc.nec765_result_bytes[3] = fdc.nec765_command_bytes[2] + 1; /* C */ | |
| 939 | fdc.nec765_result_bytes[4] = 0; /* H, inverse of programmed H */ | |
| 940 | fdc.nec765_result_bytes[5] = 1; /* R */ | |
| 941 | } | |
| 942 | else | |
| 943 | { | |
| 944 | fdc.nec765_result_bytes[3] = fdc.nec765_command_bytes[2]; /* C */ | |
| 945 | fdc.nec765_result_bytes[4] = 0; /* H, inverse of programmed H */ | |
| 946 | fdc.nec765_result_bytes[5] = fdc.nec765_command_bytes[4] + 1; /* R */ | |
| 947 | } | |
| 948 | } | |
| 949 | else | |
| 950 | { | |
| 951 | /* Check if we're at the end of the track */ | |
| 952 | if ( fdc.nec765_command_bytes[4] == fdc.nec765_command_bytes[6] ) | |
| 953 | { | |
| 954 | fdc.nec765_result_bytes[3] = fdc.nec765_command_bytes[2] + 1; /* C */ | |
| 955 | fdc.nec765_result_bytes[4] = fdc.nec765_command_bytes[3]; /* H */ | |
| 956 | fdc.nec765_result_bytes[5] = 1; /* R */ | |
| 957 | } | |
| 958 | else | |
| 959 | { | |
| 960 | fdc.nec765_result_bytes[3] = fdc.nec765_command_bytes[2]; /* C */ | |
| 961 | fdc.nec765_result_bytes[4] = fdc.nec765_command_bytes[3]; /* H */ | |
| 962 | fdc.nec765_result_bytes[5] = fdc.nec765_command_bytes[4] + 1; /* R */ | |
| 963 | } | |
| 964 | } | |
| 965 | ||
| 929 | 966 | nec765_setup_result_phase(7); |
| 930 | 967 | } |
| 931 | 968 |
| r3486 | r3487 | |
|---|---|---|
| 77 | 77 | static int MMC3_chr[6]; |
| 78 | 78 | static int MMC3_prg_base, MMC3_prg_mask; |
| 79 | 79 | static int MMC3_chr_base, MMC3_chr_mask; |
| 80 | static int MMC3_exmode; | |
| 80 | 81 | |
| 81 | 82 | static int MMC5_rom_bank_mode; |
| 82 | 83 | static int MMC5_vrom_bank_mode; |
| r3486 | r3487 | |
| 4221 | 4222 | prg32(data>>3); |
| 4222 | 4223 | chr8(data&7); |
| 4223 | 4224 | } |
| 4225 | ||
| 4226 | static READ8_HANDLER( mapper121_l_r ) | |
| 4227 | { | |
| 4228 | return 0x9F; | |
| 4229 | } | |
| 4230 | ||
| 4231 | static WRITE8_HANDLER( mapper121_w ) | |
| 4232 | { | |
| 4233 | LOG_MMC(("mapper121_w, offset: %04x, data: %02x\n", offset, data)); | |
| 4234 | ||
| 4235 | if ( ( offset & 0x7003 ) == 0x0003 && ( data == 0xAB || data == 0xFF ) ) { | |
| 4236 | MMC3_exmode = data; | |
| 4237 | } else { | |
| 4238 | MMC3_exmode = 0; | |
| 4239 | mapper4_w( machine, offset, data ); | |
| 4240 | } | |
| 4241 | } | |
| 4242 | ||
| 4224 | 4243 | static WRITE8_HANDLER( mapper133_l_w ) |
| 4225 | 4244 | { |
| 4226 | 4245 | LOG_MMC(("mapper133_w %04x:%02x\n", offset, data)); |
| r3486 | r3487 | |
| 4925 | 4944 | break; |
| 4926 | 4945 | case 4: |
| 4927 | 4946 | case 118: |
| 4947 | case 121: | |
| 4928 | 4948 | case 206: |
| 4929 | 4949 | /* Can switch 8k prg banks */ |
| 4930 | 4950 | IRQ_enable = 0; |
| r3486 | r3487 | |
| 5373 | 5393 | { 113, "Sachen/Hacker/Nina", mapper113_l_w, NULL, NULL, NULL, NULL, NULL, NULL }, |
| 5374 | 5394 | { 118, "MMC3?", NULL, NULL, NULL, mapper118_w, NULL, NULL, mapper4_irq }, |
| 5375 | 5395 | // 119 - Pinbot |
| 5396 | { 121, "Panda Prince", NULL, mapper121_l_r, NULL, mapper121_w, NULL, NULL, mapper4_irq }, | |
| 5376 | 5397 | { 133, "Sachen", mapper133_l_w, NULL, NULL, NULL, NULL, NULL, NULL }, |
| 5377 | 5398 | { 140, "Jaleco", NULL, NULL, mapper_140_m_w, NULL, NULL, NULL, NULL }, |
| 5378 | 5399 | { 144, "AGCI 50282", NULL, NULL, NULL, mapper144_w, NULL, NULL, NULL }, //Death Race only |
| r3486 | r3487 | |
|---|---|---|
| 24 | 24 | #define PC_FDC_FLAGS_DOR_FDC_ENABLED (1<<2) |
| 25 | 25 | #define PC_FDC_FLAGS_DOR_MOTOR_ON (1<<4) |
| 26 | 26 | |
| 27 | #define LOG_FDC | |
| 27 | #define LOG_FDC 1 | |
| 28 | 28 | |
| 29 | 29 | /* registers etc */ |
| 30 | 30 | struct pc_fdc |
| r3486 | r3487 | |
| 420 | 420 | case 0: /* status register a */ |
| 421 | 421 | case 1: /* status register b */ |
| 422 | 422 | data = 0x00; |
| 423 | break; | |
| 423 | 424 | case 2: |
| 424 | 425 | data = fdc->digital_output_register; |
| 425 | 426 | break; |
| r3486 | r3487 | |
| 439 | 440 | } |
| 440 | 441 | |
| 441 | 442 | if (LOG_FDC) |
| 442 | logerror("pc_fdc_r(): pc=0x%08x offset=%d result=0x%02X\n", (unsigned) activecpu_get_reg(REG_PC), offset, data); | |
| 443 | printf/*logerror*/("pc_fdc_r(): pc=0x%08x offset=%d result=0x%02X\n", (unsigned) activecpu_get_reg(REG_PC), offset, data); | |
| 443 | 444 | return data; |
| 444 | 445 | } |
| 445 | 446 | |
| r3486 | r3487 | |
| 447 | 448 | |
| 448 | 449 | WRITE8_HANDLER ( pc_fdc_w ) |
| 449 | 450 | { |
| 451 | int floppy_count; | |
| 452 | ||
| 450 | 453 | if (LOG_FDC) |
| 451 | logerror("pc_fdc_w(): pc=0x%08x offset=%d data=0x%02X\n", (unsigned) activecpu_get_reg(REG_PC), offset, data); | |
| 454 | printf/*logerror*/("pc_fdc_w(): pc=0x%08x offset=%d data=0x%02X\n", (unsigned) activecpu_get_reg(REG_PC), offset, data); | |
| 452 | 455 | |
| 453 | 456 | switch(offset) |
| 454 | 457 | { |
| r3486 | r3487 | |
| 475 | 478 | * |
| 476 | 479 | * Currently unimplemented; bits 1-0 are supposed to control data |
| 477 | 480 | * flow rates: |
| 478 | * 0 0 500 kbps | |
| 479 | * 0 1 300 kbps | |
| 480 | * 1 0 250 kbps | |
| 481 | * 5 1/4" settings | |
| 482 | * bits datarate drive speed sectors cylinders capacity | |
| 483 | * 0 0 500 kbps 360 RPM 15 80 1.2Mbyte | |
| 484 | * 0 1 300 kbps 360 RPM 9 40 360Kbyte | |
| 485 | * 1 0 250 kbps 300 RPM 9 40 360Kbyte | |
| 481 | 486 | * 1 1 1000 kbps |
| 482 | 487 | */ |
| 488 | ||
| 489 | if ( LOG_FDC ) | |
| 490 | logerror("data rate bits set to %02X\n", data & 0x03 ); | |
| 491 | ||
| 492 | floppy_count = device_count(machine, IO_FLOPPY); | |
| 493 | switch ( data & 0x03 ) | |
| 494 | { | |
| 495 | case 0x00: /* 500kbps */ | |
| 496 | break; | |
| 497 | case 0x01: /* 300kbps */ | |
| 498 | break; | |
| 499 | case 0x02: /* 250kbps */ | |
| 500 | break; | |
| 501 | case 0x03: /* 1000kbps */ | |
| 502 | break; | |
| 503 | } | |
| 483 | 504 | break; |
| 484 | 505 | } |
| 485 | 506 | } |
| 486 | 507 | |
| 508 | ||
| 487 | 509 | WRITE8_HANDLER ( pcjr_fdc_w ) |
| 488 | 510 | { |
| 489 | 511 | if (LOG_FDC) |
| r3486 | r3487 | |
|---|---|---|
| 711 | 711 | } |
| 712 | 712 | |
| 713 | 713 | |
| 714 | static DMA8237_HRQ_CHANGED( bebox_dma_hrq_changed ) | |
| 715 | { | |
| 716 | // cpunum_set_input_line(device->machine, pc_devices.cpunum_main, INPUT_LINE_HALT, | |
| 717 | // state ? ASSERT_LINE : CLEAR_LINE); | |
| 718 | ||
| 719 | /* Assert HLDA */ | |
| 720 | dma8237_set_hlda( device, state ); | |
| 721 | } | |
| 722 | ||
| 723 | ||
| 714 | 724 | static DMA8237_MEM_READ( bebox_dma_read_byte ) |
| 715 | 725 | { |
| 716 | 726 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| r3486 | r3487 | |
| 744 | 754 | |
| 745 | 755 | const struct dma8237_interface bebox_dma8237_1_config = |
| 746 | 756 | { |
| 747 | 0, | |
| 748 | 1.0e-6, /* 1us */ | |
| 757 | XTAL_14_31818MHz/3, /* this needs to be verified */ | |
| 749 | 758 | |
| 759 | bebox_dma_hrq_changed, | |
| 750 | 760 | bebox_dma_read_byte, |
| 751 | 761 | bebox_dma_write_byte, |
| 752 | 762 | |
| r3486 | r3487 | |
| 758 | 768 | |
| 759 | 769 | const struct dma8237_interface bebox_dma8237_2_config = |
| 760 | 770 | { |
| 761 | 0, | |
| 762 | 1.0e-6, /* 1us */ | |
| 771 | XTAL_14_31818MHz/3, /* this needs to be verified */ | |
| 763 | 772 | |
| 764 | 773 | NULL, |
| 765 | 774 | NULL, |
| 775 | NULL, | |
| 766 | 776 | |
| 767 | 777 | { NULL, NULL, NULL, NULL }, |
| 768 | 778 | { NULL, NULL, NULL, NULL }, |
| r3486 | r3487 | |
|---|---|---|
| 1117 | 1117 | |
| 1118 | 1118 | MACHINE_START( c64 ) |
| 1119 | 1119 | { |
| 1120 | int i,j,k; | |
| 1121 | ||
| 1122 | /* Set up RAM contents */ | |
| 1123 | for ( i = 0; i < 64; i++ ) | |
| 1124 | { | |
| 1125 | UINT8 bootup_ram[8] = { 0xFF, 0x01, 0xFF, 0x01, 0x99, 0x66, 0x99, 0x66 }; | |
| 1126 | ||
| 1127 | for ( j = 0; j < 8; j++ ) | |
| 1128 | for ( k = 0; k < 128; k++ ) | |
| 1129 | c64_memory[ i * 0x400 + j * 0x80 + k ] = mame_rand(machine) * 255; | |
| 1130 | } | |
| 1131 | ||
| 1120 | 1132 | c64_port_data = 0x17; |
| 1121 | 1133 | |
| 1122 | 1134 | c64_io_mirror = auto_malloc( 0x1000 ); |
| r3486 | r3487 | |
|---|---|---|
| 57 | 57 | if(VERBOSE_PIO>=N){ if( M )logerror("%11.6f: %-24s",attotime_to_double(timer_get_time()),(char*)M ); logerror A; } |
| 58 | 58 | |
| 59 | 59 | static struct { |
| 60 | int cpunum_main; | |
| 60 | 61 | const device_config *pic8259_master; |
| 61 | 62 | const device_config *pic8259_slave; |
| 62 | 63 | const device_config *dma8237; |
| 63 | 64 | const device_config *pit8253; |
| 65 | /* U73 is an LS74 - dual flip flop */ | |
| 66 | /* Q2 is set by OUT1 from the 8253 and goes to DRQ1 on the 8237 */ | |
| 67 | UINT8 u73_q2; | |
| 64 | 68 | } pc_devices; |
| 65 | 69 | |
| 66 | 70 | /************************************************************************* |
| r3486 | r3487 | |
| 95 | 99 | } |
| 96 | 100 | |
| 97 | 101 | |
| 102 | static DMA8237_HRQ_CHANGED( pc_dma_hrq_changed ) | |
| 103 | { | |
| 104 | /* MAME core currently does not like us halting the main cpu and while the DMA | |
| 105 | controller is running. */ | |
| 106 | cpunum_set_input_line(device->machine, pc_devices.cpunum_main, INPUT_LINE_HALT, | |
| 107 | state ? ASSERT_LINE : CLEAR_LINE); | |
| 108 | ||
| 109 | /* Assert HLDA */ | |
| 110 | dma8237_set_hlda( device, state ); | |
| 111 | } | |
| 112 | ||
| 113 | ||
| 98 | 114 | static DMA8237_MEM_READ( pc_dma_read_byte ) |
| 99 | 115 | { |
| 100 | 116 | UINT8 result; |
| r3486 | r3487 | |
| 144 | 160 | } |
| 145 | 161 | |
| 146 | 162 | |
| 163 | static DMA8237_CHANNEL_WRITE( pc_dma8237_0_dack_w ) | |
| 164 | { | |
| 165 | // printf("pc_dma8237_0_dack_w\n"); | |
| 166 | pc_devices.u73_q2 = 0; | |
| 167 | dma8237_drq_write( pc_devices.dma8237, 0, pc_devices.u73_q2 ); | |
| 168 | } | |
| 169 | ||
| 170 | ||
| 147 | 171 | static DMA8237_OUT_EOP( pc_dma8237_out_eop ) |
| 148 | 172 | { |
| 149 | pc_fdc_set_tc_state( device->machine, state ); | |
| 173 | pc_fdc_set_tc_state( device->machine, state || channel != 2 ? 0 : 1 ); | |
| 150 | 174 | } |
| 151 | 175 | |
| 152 | 176 | |
| 153 | 177 | const struct dma8237_interface ibm5150_dma8237_config = |
| 154 | 178 | { |
| 155 | 0, | |
| 156 | 1.0e-6, // 1us | |
| 179 | XTAL_14_31818MHz/3, | |
| 157 | 180 | |
| 181 | pc_dma_hrq_changed, | |
| 158 | 182 | pc_dma_read_byte, |
| 159 | 183 | pc_dma_write_byte, |
| 160 | 184 | |
| 161 | { 0, 0, pc_dma8237_fdc_dack_r, pc_dma8237_hdc_dack_r }, | |
| 162 | { 0, 0, pc_dma8237_fdc_dack_w, pc_dma8237_hdc_dack_w }, | |
| 185 | { NULL, NULL, pc_dma8237_fdc_dack_r, pc_dma8237_hdc_dack_r }, | |
| 186 | { pc_dma8237_0_dack_w, NULL, pc_dma8237_fdc_dack_w, pc_dma8237_hdc_dack_w }, | |
| 163 | 187 | pc_dma8237_out_eop |
| 164 | 188 | }; |
| 165 | 189 | |
| r3486 | r3487 | |
| 272 | 296 | * |
| 273 | 297 | *************************************************************/ |
| 274 | 298 | |
| 275 | static PIT8253_OUTPUT_CHANGED( ibm5150_ | |
| 299 | static PIT8253_OUTPUT_CHANGED( ibm5150_pit8253_out0_changed ) | |
| 276 | 300 | { |
| 277 | 301 | pic8259_set_irq_line(pc_devices.pic8259_master, 0, state); |
| 278 | 302 | } |
| r3486 | r3487 | |
| 280 | 304 | |
| 281 | 305 | static PIT8253_OUTPUT_CHANGED( ibm5150_pit8253_out1_changed ) |
| 282 | 306 | { |
| 307 | static UINT8 old_state = 0; | |
| 308 | ||
| 283 | 309 | /* Trigger DMA channel #0 */ |
| 310 | if ( old_state == 0 && state == 1 && pc_devices.u73_q2 == 0 ) | |
| 311 | { | |
| 312 | //printf("set q2\n"); | |
| 313 | pc_devices.u73_q2 = 1; | |
| 314 | dma8237_drq_write( pc_devices.dma8237, 0, pc_devices.u73_q2 ); | |
| 315 | } | |
| 316 | old_state = state; | |
| 284 | 317 | } |
| 285 | 318 | |
| 286 | 319 | |
| r3486 | r3487 | |
| 295 | 328 | { |
| 296 | 329 | { |
| 297 | 330 | XTAL_14_31818MHz/12, /* heartbeat IRQ */ |
| 298 | ibm5150_ | |
| 331 | ibm5150_pit8253_out0_changed | |
| 299 | 332 | }, { |
| 300 | 333 | XTAL_14_31818MHz/12, /* dram refresh */ |
| 301 | 334 | ibm5150_pit8253_out1_changed |
| r3486 | r3487 | |
| 318 | 351 | { |
| 319 | 352 | { |
| 320 | 353 | XTAL_14_31818MHz/12, /* heartbeat IRQ */ |
| 321 | ibm5150_ | |
| 354 | ibm5150_pit8253_out0_changed | |
| 322 | 355 | }, { |
| 323 | 356 | XTAL_14_31818MHz/12, /* dram refresh */ |
| 324 | 357 | NULL |
| r3486 | r3487 | |
| 1303 | 1336 | |
| 1304 | 1337 | MACHINE_RESET( pc ) |
| 1305 | 1338 | { |
| 1306 | cpunum_ | |
| 1339 | pc_devices.cpunum_main = mame | |
| 1307 | 1340 | |
| 1341 | cpunum_set_irq_callback(pc_devices.cpunum_main, pc_irq_callback); | |
| 1342 | ||
| 1308 | 1343 | pc_devices.pic8259_master = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_master" ); |
| 1309 | 1344 | pc_devices.pic8259_slave = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_slave" ); |
| 1310 | 1345 | pc_devices.dma8237 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237" ); |
| 1311 | 1346 | pc_devices.pit8253 = device_list_find_by_tag( machine->config->devicelist, PIT8253, "pit8253" ); |
| 1347 | pc_devices.u73_q2 = 0; | |
| 1312 | 1348 | pc_mouse_set_serial_port( device_list_find_by_tag( machine->config->devicelist, INS8250, "ins8250_0" ) ); |
| 1313 | 1349 | pc_hdc_set_dma8237_device( pc_devices.dma8237 ); |
| 1314 | 1350 | speaker_level_w( 0, 0 ); |
| r3486 | r3487 | |
|---|---|---|
| 115 | 115 | CPUS += S2650 |
| 116 | 116 | #CPUS += TMS34010 |
| 117 | 117 | #CPUS += TMS34020 |
| 118 | CPUS += TMS0980 | |
| 118 | 119 | CPUS += TMS9900 |
| 119 | 120 | #CPUS += TMS9940 |
| 120 | 121 | CPUS += TMS9980 |
| r3486 | r3487 | |
| 412 | 413 | $(MESSOBJ)/orion.a \ |
| 413 | 414 | $(MESSOBJ)/osborne.a \ |
| 414 | 415 | $(MESSOBJ)/p2000.a \ |
| 416 | $(MESSOBJ)/parkbros.a \ | |
| 415 | 417 | $(MESSOBJ)/pasogo.a \ |
| 416 | 418 | $(MESSOBJ)/pc.a \ |
| 417 | 419 | $(MESSOBJ)/pcshare.a \ |
| r3486 | r3487 | |
| 1347 | 1349 | $(MESSOBJ)/votrax.a: \ |
| 1348 | 1350 | $(MESS_DRIVERS)/votrpss.o \ |
| 1349 | 1351 | |
| 1352 | $(MESSOBJ)/parkbros.a: \ | |
| 1353 | $(MESS_DRIVERS)/stopthie.o | |
| 1354 | ||
| 1350 | 1355 | #------------------------------------------------- |
| 1351 | 1356 | # layout dependencies |
| 1352 | 1357 | #------------------------------------------------- |
| r3486 | r3487 | |
| 1370 | 1375 | $(MESS_DRIVERS)/mk2.o: $(MESS_LAYOUT)/mk2.lh |
| 1371 | 1376 | $(MESS_DRIVERS)/nc.o: $(MESS_LAYOUT)/nc200.lh |
| 1372 | 1377 | $(MESS_DRIVERS)/pokemini.o: $(MESS_LAYOUT)/pokemini.lh |
| 1378 | $(MESS_DRIVERS)/stopthie.o: $(MESS_LAYOUT)/stopthie.lh | |
| 1373 | 1379 | $(MESS_DRIVERS)/svi318.o: $(MESS_LAYOUT)/sv328806.lh |
| 1374 | 1380 | $(MESS_DRIVERS)/svision.o: $(MESS_LAYOUT)/svision.lh |
| 1375 | 1381 | $(MESS_DRIVERS)/sym1.o: $(MESS_LAYOUT)/sym1.lh |
| r3486 | r3487 | |
|---|---|---|
| 370 | 370 | |
| 371 | 371 | /* draw the cassette */ |
| 372 | 372 | ui_draw_text_box(buf, JUSTIFY_LEFT, x, y, UI_FILLCOLOR); |
| 373 | ||
| 374 | if ( uistate == CASSETTE_PLAY ) { | |
| 375 | /* Check if we are past the end of the tape. If so, stop the motor. */ | |
| 376 | if ( position > length ) { | |
| 377 | cassette_change_state( image, CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); | |
| 378 | } | |
| 379 | } | |
| 380 | ||
| 373 | 381 | } |
| 374 | 382 | |
| 375 | 383 |
| r3486 | r3487 | |
|---|---|---|
| 160 | 160 | }; |
| 161 | 161 | #endif |
| 162 | 162 | |
| 163 | static const nes_interface nes | |
| 163 | static const nes_interface nes_apu_interface = | |
| 164 | 164 | { |
| 165 | | |
| 165 | "main" | |
| 166 | 166 | }; |
| 167 | 167 | |
| 168 | static const nes_interface nespal_interface = | |
| 169 | { | |
| 170 | 0 | |
| 171 | }; | |
| 172 | 168 | |
| 173 | 169 | ROM_START( nes ) |
| 174 | 170 | ROM_REGION( 0x10000, "main",0 ) /* Main RAM + program banks */ |
| r3486 | r3487 | |
| 245 | 241 | /* sound hardware */ |
| 246 | 242 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 247 | 243 | MDRV_SOUND_ADD("nessound", NES, NTSC_CLOCK) |
| 248 | MDRV_SOUND_CONFIG(nes | |
| 244 | MDRV_SOUND_CONFIG(nes_apu_interface) | |
| 249 | 245 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 250 | 246 | MACHINE_DRIVER_END |
| 251 | 247 | |
| r3486 | r3487 | |
| 263 | 259 | |
| 264 | 260 | /* sound hardware */ |
| 265 | 261 | MDRV_SOUND_REPLACE("nessound", NES, PAL_CLOCK) |
| 266 | MDRV_SOUND_CONFIG(nes | |
| 262 | MDRV_SOUND_CONFIG(nes_apu_interface) | |
| 267 | 263 | MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00) |
| 268 | 264 | MACHINE_DRIVER_END |
| 269 | 265 |
| r3486 | r3487 | |
|---|---|---|
| 566 | 566 | case 0x04000: |
| 567 | 567 | case 0x08000: |
| 568 | 568 | case 0x10000: |
| 569 | case 0x78000: | |
| 569 | 570 | case 0x80000: |
| 570 | 571 | break; |
| 571 | 572 | |
| r3486 | r3487 | |
| 606 | 607 | |
| 607 | 608 | static void modeF8_switch(running_machine *machine, UINT16 offset, UINT8 data) |
| 608 | 609 | { |
| 610 | printf("F8 switch offset = %04X\n", offset ); | |
| 609 | 611 | bank_base[1] = CART + 0x1000 * offset; |
| 610 | 612 | memory_set_bankptr(1, bank_base[1]); |
| 611 | 613 | } |
| r3486 | r3487 | |
| 662 | 664 | } |
| 663 | 665 | static void mode3E_RAM_switch(running_machine *machine, UINT16 offset, UINT8 data) |
| 664 | 666 | { |
| 665 | ram_base = extra_RAM + 0x200 * ( data & 0x3F ); | |
| 667 | ram_base = extra_RAM + 0x4200 * ( data & 0x3F ); | |
| 666 | 668 | memory_set_bankptr(1, ram_base ); |
| 667 | 669 | mode3E_ram_enabled = 1; |
| 668 | 670 | } |
| r3486 | r3487 | |
| 1550 | 1552 | case 0x10000: |
| 1551 | 1553 | banking_mode = mode32in1; |
| 1552 | 1554 | break; |
| 1555 | case 0x78000: | |
| 1556 | banking_mode = mode3E; | |
| 1557 | break; | |
| 1553 | 1558 | case 0x80000: |
| 1554 | 1559 | banking_mode = mode3F; |
| 1555 | 1560 | break; |
| r3486 | r3487 | |
| 1634 | 1639 | |
| 1635 | 1640 | case mode3E: |
| 1636 | 1641 | install_banks(machine, 2, cart_size - 0x800); |
| 1637 | number_banks = cart_size / 0x800; | |
| 1642 | if ( cart_size == 0x78000 ) | |
| 1643 | number_banks = 0x80000 / 0x800; | |
| 1644 | else | |
| 1645 | number_banks = cart_size / 0x800; | |
| 1638 | 1646 | mode3E_ram_enabled = 0; |
| 1639 | 1647 | break; |
| 1640 | 1648 | |
| r3486 | r3487 | |
| 1734 | 1742 | case mode3E: |
| 1735 | 1743 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x3e, 0x3e, 0, 0, mode3E_RAM_switch_w); |
| 1736 | 1744 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x3f, 0x3f, 0, 0, mode3E_switch_w); |
| 1737 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x1400, 0x1 | |
| 1745 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x1400, 0x17ff, 0, 0, mode3E_RAM_w); | |
| 1738 | 1746 | break; |
| 1739 | 1747 | |
| 1740 | 1748 | case modeSS: |
| r3486 | r3487 | |
|---|---|---|
| 8 | 8 | |
| 9 | 9 | #include "driver.h" |
| 10 | 10 | #include "video/vdc.h" |
| 11 | #include "deprecat.h" | |
| 11 | 12 | |
| 13 | ||
| 12 | 14 | static ADDRESS_MAP_START( pcfx_mem, ADDRESS_SPACE_PROGRAM, 32 ) |
| 13 | 15 | AM_RANGE( 0x00000000, 0x001FFFFF ) AM_RAM /* RAM */ |
| 14 | 16 | AM_RANGE( 0x80700000, 0x807FFFFF ) AM_NOP /* EXTIO */ |
| r3486 | r3487 | |
| 19 | 21 | ADDRESS_MAP_END |
| 20 | 22 | |
| 21 | 23 | |
| 24 | static READ32_HANDLER( pcfx_vdc_0_r ) | |
| 25 | { | |
| 26 | UINT32 data; | |
| 27 | ||
| 28 | logerror("pcfx_vdc_0_r: read from offset %08x\n", offset ); | |
| 29 | ||
| 30 | if ( offset & 1 ) | |
| 31 | { | |
| 32 | data = vdc_0_r( machine, 2 ); | |
| 33 | data |= ( vdc_0_r( machine, 3 ) << 8 ); | |
| 34 | } | |
| 35 | else | |
| 36 | data = vdc_0_r( machine, 0 ); | |
| 37 | ||
| 38 | return data; | |
| 39 | } | |
| 40 | ||
| 41 | ||
| 42 | static WRITE32_HANDLER( pcfx_vdc_0_w ) | |
| 43 | { | |
| 44 | logerror("pcfx_vdc_0_w: write %08x to offset %08x\n", data, offset ); | |
| 45 | ||
| 46 | if ( offset & 1 ) | |
| 47 | { | |
| 48 | vdc_0_w( machine, 2, data ); | |
| 49 | vdc_0_w( machine, 3, data >> 8 ); | |
| 50 | } | |
| 51 | else | |
| 52 | vdc_0_w( machine, 0, data ); | |
| 53 | } | |
| 54 | ||
| 55 | ||
| 56 | /* | |
| 57 | 100h - channel select | |
| 58 | 102h - Main volume | |
| 59 | 104h - frequency (low) | |
| 60 | 106h - frequency (high) | |
| 61 | 108h - channel volume | |
| 62 | 10Ah - pan | |
| 63 | 10Ch - wave data | |
| 64 | 10Eh - noise | |
| 65 | 110h - LFO freq. | |
| 66 | 112h - LFO control | |
| 67 | 120h - ADPCM control | |
| 68 | 122h - ADPCM vol0 left (0-3Fh) | |
| 69 | 124h - ADPCM vol0 right (0-3Fh) | |
| 70 | 126h - ADPCM vol1 left (0-3Fh) | |
| 71 | 128h - ADPCM vol1 right (0-3Fh) | |
| 72 | 12Ah - | |
| 73 | 12Ch - | |
| 74 | */ | |
| 75 | static READ32_HANDLER( huc6230_r ) | |
| 76 | { | |
| 77 | UINT32 data = 0xFFFFFFFF; | |
| 78 | ||
| 79 | logerror("huc6230_r(): offset = %08x\n", offset ); | |
| 80 | ||
| 81 | return data; | |
| 82 | } | |
| 83 | ||
| 84 | ||
| 85 | static WRITE32_HANDLER( huc6230_w ) | |
| 86 | { | |
| 87 | logerror("huc630_w(): offset = %08x, data = %08x\n", offset, data ); | |
| 88 | } | |
| 89 | ||
| 90 | ||
| 91 | static READ32_HANDLER( huc6271_r ) | |
| 92 | { | |
| 93 | UINT32 data = 0xFFFFFFFF; | |
| 94 | ||
| 95 | logerror("huc6271_r(): offset = %08x\n", offset ); | |
| 96 | ||
| 97 | return data; | |
| 98 | } | |
| 99 | ||
| 100 | ||
| 101 | static WRITE32_HANDLER( huc6271_w ) | |
| 102 | { | |
| 103 | logerror("huc6271_w(): offset = %08x, data = %08x\n", offset, data ); | |
| 104 | } | |
| 105 | ||
| 106 | ||
| 107 | static READ32_HANDLER( huc6261_r ) | |
| 108 | { | |
| 109 | UINT32 data = 0xFFFFFFFF; | |
| 110 | ||
| 111 | logerror("huc6261_r(): offset = %08x\n", offset ); | |
| 112 | ||
| 113 | return data; | |
| 114 | } | |
| 115 | ||
| 116 | ||
| 117 | static WRITE32_HANDLER( huc6261_w ) | |
| 118 | { | |
| 119 | logerror("huc6261_w(): offset = %08x, data = %08x\n", offset, data ); | |
| 120 | } | |
| 121 | ||
| 122 | ||
| 123 | static READ32_HANDLER( pcfx_vdc_1_r ) | |
| 124 | { | |
| 125 | UINT32 data; | |
| 126 | ||
| 127 | logerror("pcfx_vdc_1_r: read from offset %08x\n", offset ); | |
| 128 | ||
| 129 | if ( offset & 1 ) | |
| 130 | { | |
| 131 | data = vdc_1_r( machine, 2 ); | |
| 132 | data |= ( vdc_1_r( machine, 3 ) << 8 ); | |
| 133 | } | |
| 134 | else | |
| 135 | data = vdc_1_r( machine, 0 ); | |
| 136 | ||
| 137 | return data; | |
| 138 | } | |
| 139 | ||
| 140 | ||
| 141 | static WRITE32_HANDLER( pcfx_vdc_1_w ) | |
| 142 | { | |
| 143 | logerror("pcfx_vdc_1_w: write %08x to offset %08x\n", data, offset ); | |
| 144 | ||
| 145 | if ( offset & 1 ) | |
| 146 | { | |
| 147 | vdc_1_w( machine, 2, data ); | |
| 148 | vdc_1_w( machine, 3, data >> 8 ); | |
| 149 | } | |
| 150 | else | |
| 151 | vdc_1_w( machine, 0, data ); | |
| 152 | } | |
| 153 | ||
| 154 | ||
| 155 | static READ32_HANDLER( huc6272_r ) | |
| 156 | { | |
| 157 | UINT32 data = 0xFFFFFFFF; | |
| 158 | ||
| 159 | logerror("huc6272_r(): offset = %08x\n", offset ); | |
| 160 | ||
| 161 | return data; | |
| 162 | } | |
| 163 | ||
| 164 | ||
| 165 | static WRITE32_HANDLER( huc6272_w ) | |
| 166 | { | |
| 167 | logerror("huc6272_w(): offset = %08x, data = %08x\n", offset, data ); | |
| 168 | } | |
| 169 | ||
| 170 | ||
| 22 | 171 | static ADDRESS_MAP_START( pcfx_io, ADDRESS_SPACE_IO, 32 ) |
| 23 | 172 | AM_RANGE( 0x00000000, 0x000000FF ) AM_NOP /* PAD */ |
| 24 | AM_RANGE( 0x00000100, 0x000001FF ) AM_NOP /* HuC6230 */ | |
| 25 | AM_RANGE( 0x00000200, 0x000002FF ) AM_NOP /* HuC6271 */ | |
| 26 | AM_RANGE( 0x00000300, 0x000003FF ) AM_NOP /* HuC6261 */ | |
| 27 | AM_RANGE( 0x00000400, 0x000004FF ) AM_NOP /* HuC6270-A */ | |
| 28 | AM_RANGE( 0x00000500, 0x000005FF ) AM_NOP /* HuC6270-B */ | |
| 29 | AM_RANGE( 0x00000600, 0x000006FF ) AM_NOP /* HuC6272 */ | |
| 173 | AM_RANGE( 0x00000100, 0x000001FF ) AM_READWRITE( huc6230_r, huc6230_w) /* HuC6230 */ | |
| 174 | AM_RANGE( 0x00000200, 0x000002FF ) AM_READWRITE( huc6271_r, huc6271_w) /* HuC6271 */ | |
| 175 | AM_RANGE( 0x00000300, 0x000003FF ) AM_READWRITE( huc6261_r, huc6261_w) /* HuC6261 */ | |
| 176 | AM_RANGE( 0x00000400, 0x000004FF ) AM_READWRITE( pcfx_vdc_0_r, pcfx_vdc_0_w ) /* HuC6270-A */ | |
| 177 | AM_RANGE( 0x00000500, 0x000005FF ) AM_READWRITE( pcfx_vdc_1_r, pcfx_vdc_1_w ) /* HuC6270-B */ | |
| 178 | AM_RANGE( 0x00000600, 0x000006FF ) AM_READWRITE( huc6272_r, huc6272_w) /* HuC6272 */ | |
| 30 | 179 | AM_RANGE( 0x00000C80, 0x00000C83 ) AM_NOP |
| 31 | 180 | AM_RANGE( 0x00000E00, 0x00000EFF ) AM_NOP |
| 32 | 181 | AM_RANGE( 0x00000F00, 0x00000FFF ) AM_NOP |
| r3486 | r3487 | |
| 44 | 193 | MDRV_CPU_ADD( "main", V810, 21477270 ) |
| 45 | 194 | MDRV_CPU_PROGRAM_MAP( pcfx_mem, 0 ) |
| 46 | 195 | MDRV_CPU_IO_MAP( pcfx_io, 0 ) |
| 196 | MDRV_CPU_VBLANK_INT_HACK(sgx_interrupt, VDC_LPF) /* This needs to be updated */ | |
| 47 | 197 | |
| 48 | 198 | MDRV_MACHINE_RESET( pcfx ) |
| 49 | 199 | |
| 50 | 200 | MDRV_SCREEN_ADD( "main", RASTER ) |
| 51 | 201 | MDRV_SCREEN_FORMAT( BITMAP_FORMAT_RGB32 ) |
| 52 | 202 | MDRV_SCREEN_RAW_PARAMS(21477270/2, VDC_WPF, 70, 70 + 512 + 32, VDC_LPF, 14, 14+242) |
| 203 | ||
| 204 | MDRV_VIDEO_START( pce ) /* This needs to be updated */ | |
| 205 | MDRV_VIDEO_UPDATE( pce ) /* This needs to be updated */ | |
| 206 | ||
| 53 | 207 | MACHINE_DRIVER_END |
| 54 | 208 | |
| 55 | 209 |
| r3486 | r3487 | |
|---|---|---|
| 2292 | 2292 | ROMX_LOAD("68x4370.u19", 0xf0000, 0x8000, CRC(758ff036) SHA1(045e27a70407d89b7956ecae4d275bd2f6b0f8e2), ROM_BIOS(4)) |
| 2293 | 2293 | ROMX_LOAD("62x0890.u18", 0xf8000, 0x8000, CRC(4f417635) SHA1(daa61762d3afdd7262e34edf1a3d2df9a05bcebb), ROM_BIOS(4)) |
| 2294 | 2294 | |
| 2295 | // ROM_SYSTEM_BIOS( 4, "xtdiag", "IBM XT 5160 w/Supersoft Diagnostics" ) /* ROMs marked as BAD_DUMP for now. We expect the data to be in a different ROM chip layout */ | |
| 2296 | // ROMX_LOAD("basicc11.f6", 0xf6000, 0x2000, BAD_DUMP CRC(80d3cf5d) SHA1(64769b7a8b60ffeefa04e4afbec778069a2840c9), ROM_BIOS(5) ) | |
| 2297 | // ROMX_LOAD("basicc11.f8", 0xf8000, 0x2000, BAD_DUMP CRC(673a4acc) SHA1(082ae803994048e225150f771794ca305f73d731), ROM_BIOS(5) ) | |
| 2298 | // ROMX_LOAD("basicc11.fa", 0xfa000, 0x2000, BAD_DUMP CRC(aac3fc37) SHA1(c9e0529470edf04da093bb8c8ae2536c688c1a74), ROM_BIOS(5) ) | |
| 2299 | // ROMX_LOAD("basicc11.fc", 0xfc000, 0x2000, BAD_DUMP CRC(3062b3fc) SHA1(5134dd64721cbf093d059ee5d3fd09c7f86604c7), ROM_BIOS(5) ) | |
| 2300 | // ROMX_LOAD("xtdiag.bin", 0xfe000, 0x2000, CRC(4e89a4d8) SHA1(39a28fb2fe9f1aeea24ed2c0255cebca76e37ed7), ROM_BIOS(5) ) | |
| 2295 | ROM_SYSTEM_BIOS( 4, "xtdiag", "IBM XT 5160 w/Supersoft Diagnostics" ) /* ROMs marked as BAD_DUMP for now. We expect the data to be in a different ROM chip layout */ | |
| 2296 | ROMX_LOAD("basicc11.f6", 0xf6000, 0x2000, BAD_DUMP CRC(80d3cf5d) SHA1(64769b7a8b60ffeefa04e4afbec778069a2840c9), ROM_BIOS(5) ) | |
| 2297 | ROMX_LOAD("basicc11.f8", 0xf8000, 0x2000, BAD_DUMP CRC(673a4acc) SHA1(082ae803994048e225150f771794ca305f73d731), ROM_BIOS(5) ) | |
| 2298 | ROMX_LOAD("basicc11.fa", 0xfa000, 0x2000, BAD_DUMP CRC(aac3fc37) SHA1(c9e0529470edf04da093bb8c8ae2536c688c1a74), ROM_BIOS(5) ) | |
| 2299 | ROMX_LOAD("basicc11.fc", 0xfc000, 0x2000, BAD_DUMP CRC(3062b3fc) SHA1(5134dd64721cbf093d059ee5d3fd09c7f86604c7), ROM_BIOS(5) ) | |
| 2300 | ROMX_LOAD("xtdiag.bin", 0xfe000, 0x2000, CRC(4e89a4d8) SHA1(39a28fb2fe9f1aeea24ed2c0255cebca76e37ed7), ROM_BIOS(5) ) | |
| 2301 | 2301 | |
| 2302 | 2302 | /* CGA Character rom */ |
| 2303 | 2303 | ROM_REGION(0x2000,"gfx1", 0) |
| r3486 | r3487 | |
| 2535 | 2535 | |
| 2536 | 2536 | // xt class (pc but 8086) |
| 2537 | 2537 | COMP( 1982, ibm5160, ibm5150, 0, ibm5160, xtcga, pccga, ibm5160, "International Business Machines", "IBM XT 5160" , 0) |
| 2538 | //COMP( 1983, ibm5271, ibm5150, 0, ibm5160, xtcga, pccga, ibm5160, "Internatioanl Business Machines", "IBM 5271 (3270 PC)", GAME_NOT_WORKING ) | |
| 2538 | 2539 | COMP( 1988, pc200, ibm5150, 0, pc200, pc200, pc200, ibm5160, "Sinclair Research", "PC200 Professional Series", GAME_NOT_WORKING) |
| 2539 | 2540 | COMP( 1988, pc20, ibm5150, 0, pc200, pc200, pc200, ibm5160, "Amstrad plc", "Amstrad PC20" , GAME_NOT_WORKING) |
| 2540 | 2541 | COMP( 1987, ppc512, ibm5150, 0, pc200, pc200, pc200, ibm5160, "Amstrad plc", "Amstrad PPC512", GAME_NOT_WORKING) |
| r3486 | r3487 | |
|---|---|---|
| 357 | 357 | |
| 358 | 358 | # LDFLAGS are used generally; LDFLAGSEMULATOR are additional |
| 359 | 359 | # flags only used when linking the core emulator |
| 360 | LDFLAGS = -Wl,--warn-common | |
| 360 | #LDFLAGS = -Wl,--warn-common | |
| 361 | LDFLAGS += -Wl | |
| 361 | 362 | LDFLAGSEMULATOR = |
| 362 | 363 | |
| 363 | 364 | # add profiling information for the linker |
| Previous | 15994 Revisions | Next |