| Previous | 199869 Revisions | Next |
| r17965 Monday 17th September, 2012 at 09:16:44 UTC by Aaron Giles |
|---|
| Memory handler cleanup 3. Add mem_mask parameter to 8-bit handlers to match the others. To ease pain, added DECLARE_READ/WRITE_HANDLER macros that set up a default parameter. Also updated devcb so that the handlers can be called with or without the mem_mask. [Aaron Giles] |
| [src/emu] | devcb.c devcb.h memconv.h memory.c memory.h |
| [src/emu/cpu/dsp56k] | dsp56mem.h |
| [src/emu/cpu/g65816] | g65816op.h |
| [src/emu/cpu/h6280] | h6280.h |
| [src/emu/cpu/m6800] | m6800.h |
| [src/emu/cpu/m68000] | 68307bus.h 68307ser.h 68307sim.h 68307tmu.h 68340dma.h 68340ser.h 68340sim.h 68340tmu.h |
| [src/emu/cpu/psx] | sio.h |
| [src/emu/cpu/sh2] | sh2.h |
| [src/emu/cpu/sh4] | sh4.h sh4comn.h |
| [src/emu/cpu/tms34010] | tms34010.h |
| [src/emu/cpu/tms7000] | tms7000.c |
| [src/emu/cpu/tms9900] | tms9900l.h |
| [src/emu/machine] | 8042kbdc.h latch8.c pc16552d.h s3c2400.c s3c2410.c tmp68301.h |
| [src/emu/sound] | pokey.h spu.h |
| [src/emu/video] | pc_cga.c pc_cga.h pc_vga.c pc_vga.h tms34061.h |
| [src/mame/audio] | atarijsa.c cage.c cclimber.h dcs.c dcs.h irem.h seibu.h t5182.h timeplt.h trackfld.h |
| [src/mame/drivers] | bfm_sc4h.c decocass.c dkong.c mario.c mpu4vid.c |
| [src/mame/includes] | actfancr.h amiga.h archimds.h astrocde.h asuka.h atari.h atarig42.h atarigx2.h atarisy1.h atarisy2.h avalnche.h badlands.h cchip.h copsnrob.h cyberbal.h dc.h dec0.h dec8.h deco32.h decoprot.h fastfred.h galaga.h galivan.h galpani2.h galpanic.h gauntlet.h harddriv.h itech8.h klax.h ladybug.h matmania.h megadriv.h midzeus.h namcoic.h namcos1.h namcos2.h nb1413m3.h pacman.h pk8000.h psx.h scramble.h segamsys.h sei_crtc.h skullxbo.h snes.h snk6502.h stv.h targ.h toobin.h vicdual.h vindictr.h |
| [src/mame/machine] | asic65.h atarigen.h cdi070.h decocass.c decocass.h konppc.h m68kfmly.h megacd.c megadriv.c midwayic.h namcos1.c nmk004.h pcecommn.h seicop.h smpc.h snes.c stvcd.h tait8741.c tait8741.h |
| [src/mame/video] | atarimo.h avgdvg.h gtia.h gticlub.h konamiic.c konamiic.h konicdev.h mcd212.h segaic16.h vdc.h ygv608.h |
| [src/mess/drivers] | b16.c bigbord2.c bullet.c dc.c dmv.c mikromik.c p8k.c qx10.c super6.c trs80m2.c vidbrain.c x1.c |
| [src/mess/includes] | amstr_pc.h apple2.h bebox.h c16.h c64_legacy.h cgenie.h corvushd.h dgn_beta.h enterp.h europc.h fmtowns.h hec2hrp.h mbc55x.h pc1251.h pc1350.h pc1401.h pc1403.h pet.h ps2.h tandy1t.h thomson.h x68k.h |
| [src/mess/machine] | 990_dk.h 990_hd.h apple2gs.c c65.c concept.c dgn_beta.c lux21046.c lynx.c mboard.h nes_mmc.c nes_mmc.h nes_pcb.c partner.c pc_fdc.c pc_fdc.h pc_joy.h radio86.c sgi.h sst39vfx.h thomflop.c thomflop.h ti990.h |
| [src/mess/video] | gf4500.h newport.c newport.h pc_aga.c pc_aga.h |
| r17964 | r17965 | |
|---|---|---|
| 73 | 73 | |
| 74 | 74 | static void update_all_volumes(running_machine &machine); |
| 75 | 75 | |
| 76 | static READ8_HANDLER( jsa1_io_r ); | |
| 77 | static WRITE8_HANDLER( jsa1_io_w ); | |
| 78 | static READ8_HANDLER( jsa2_io_r ); | |
| 79 | static WRITE8_HANDLER( jsa2_io_w ); | |
| 80 | static READ8_HANDLER( jsa3_io_r ); | |
| 81 | static WRITE8_HANDLER( jsa3_io_w ); | |
| 76 | static DECLARE_READ8_HANDLER( jsa1_io_r ); | |
| 77 | static DECLARE_WRITE8_HANDLER( jsa1_io_w ); | |
| 78 | static DECLARE_READ8_HANDLER( jsa2_io_r ); | |
| 79 | static DECLARE_WRITE8_HANDLER( jsa2_io_w ); | |
| 80 | static DECLARE_READ8_HANDLER( jsa3_io_r ); | |
| 81 | static DECLARE_WRITE8_HANDLER( jsa3_io_w ); | |
| 82 | 82 | |
| 83 | 83 | |
| 84 | 84 | /************************************* |
| r17964 | r17965 | |
|---|---|---|
| 147 | 147 | static TIMER_DEVICE_CALLBACK( dma_timer_callback ); |
| 148 | 148 | static TIMER_DEVICE_CALLBACK( cage_timer_callback ); |
| 149 | 149 | static void update_timer(int which); |
| 150 | static WRITE32_HANDLER( speedup_w ); | |
| 150 | static DECLARE_WRITE32_HANDLER( speedup_w ); | |
| 151 | 151 | |
| 152 | 152 | |
| 153 | 153 |
| r17964 | r17965 | |
|---|---|---|
| 38 | 38 | ADDRESS_MAP_EXTERN(seibu3_sound_map, 8); |
| 39 | 39 | ADDRESS_MAP_EXTERN(seibu3_adpcm_sound_map, 8); |
| 40 | 40 | |
| 41 | READ16_HANDLER( seibu_main_word_r ); | |
| 42 | READ8_HANDLER( seibu_main_v30_r ); | |
| 43 | WRITE16_HANDLER( seibu_main_word_w ); | |
| 44 | WRITE8_HANDLER( seibu_main_v30_w ); | |
| 41 | DECLARE_READ16_HANDLER( seibu_main_word_r ); | |
| 42 | DECLARE_READ8_HANDLER( seibu_main_v30_r ); | |
| 43 | DECLARE_WRITE16_HANDLER( seibu_main_word_w ); | |
| 44 | DECLARE_WRITE8_HANDLER( seibu_main_v30_w ); | |
| 45 | 45 | |
| 46 | WRITE16_HANDLER( seibu_main_mustb_w ); | |
| 46 | DECLARE_WRITE16_HANDLER( seibu_main_mustb_w ); | |
| 47 | 47 | |
| 48 | WRITE8_HANDLER( seibu_irq_clear_w ); | |
| 49 | WRITE8_HANDLER( seibu_rst10_ack_w ); | |
| 50 | WRITE8_HANDLER( seibu_rst18_ack_w ); | |
| 51 | WRITE8_HANDLER( seibu_bank_w ); | |
| 52 | WRITE8_HANDLER( seibu_coin_w ); | |
| 48 | DECLARE_WRITE8_HANDLER( seibu_irq_clear_w ); | |
| 49 | DECLARE_WRITE8_HANDLER( seibu_rst10_ack_w ); | |
| 50 | DECLARE_WRITE8_HANDLER( seibu_rst18_ack_w ); | |
| 51 | DECLARE_WRITE8_HANDLER( seibu_bank_w ); | |
| 52 | DECLARE_WRITE8_HANDLER( seibu_coin_w ); | |
| 53 | 53 | void seibu_ym3812_irqhandler(device_t *device, int linestate); |
| 54 | 54 | void seibu_ym2151_irqhandler(device_t *device, int linestate); |
| 55 | 55 | void seibu_ym2203_irqhandler(device_t *device, int linestate); |
| 56 | READ8_HANDLER( seibu_soundlatch_r ); | |
| 57 | READ8_HANDLER( seibu_main_data_pending_r ); | |
| 58 | WRITE8_HANDLER( seibu_main_data_w ); | |
| 56 | DECLARE_READ8_HANDLER( seibu_soundlatch_r ); | |
| 57 | DECLARE_READ8_HANDLER( seibu_main_data_pending_r ); | |
| 58 | DECLARE_WRITE8_HANDLER( seibu_main_data_w ); | |
| 59 | 59 | MACHINE_RESET( seibu_sound ); |
| 60 | 60 | void seibu_sound_decrypt(running_machine &machine,const char *cpu,int length); |
| 61 | 61 |
| r17964 | r17965 | |
|---|---|---|
| 376 | 376 | * |
| 377 | 377 | *************************************/ |
| 378 | 378 | |
| 379 | static READ16_HANDLER( dcs_dataram_r ); | |
| 380 | static WRITE16_HANDLER( dcs_dataram_w ); | |
| 381 | static WRITE16_HANDLER( dcs_data_bank_select_w ); | |
| 379 | static DECLARE_READ16_HANDLER( dcs_dataram_r ); | |
| 380 | static DECLARE_WRITE16_HANDLER( dcs_dataram_w ); | |
| 381 | static DECLARE_WRITE16_HANDLER( dcs_data_bank_select_w ); | |
| 382 | 382 | |
| 383 | 383 | static void sdrc_reset(running_machine &machine); |
| 384 | static READ16_HANDLER( sdrc_r ); | |
| 385 | static WRITE16_HANDLER( sdrc_w ); | |
| 384 | static DECLARE_READ16_HANDLER( sdrc_r ); | |
| 385 | static DECLARE_WRITE16_HANDLER( sdrc_w ); | |
| 386 | 386 | |
| 387 | 387 | static void dsio_reset(running_machine &machine); |
| 388 | static READ16_HANDLER( dsio_r ); | |
| 389 | static WRITE16_HANDLER( dsio_w ); | |
| 388 | static DECLARE_READ16_HANDLER( dsio_r ); | |
| 389 | static DECLARE_WRITE16_HANDLER( dsio_w ); | |
| 390 | 390 | |
| 391 | 391 | static void denver_reset(running_machine &machine); |
| 392 | static READ16_HANDLER( denver_r ); | |
| 393 | static WRITE16_HANDLER( denver_w ); | |
| 392 | static DECLARE_READ16_HANDLER( denver_r ); | |
| 393 | static DECLARE_WRITE16_HANDLER( denver_w ); | |
| 394 | 394 | |
| 395 | static READ16_HANDLER( adsp_control_r ); | |
| 396 | static WRITE16_HANDLER( adsp_control_w ); | |
| 395 | static DECLARE_READ16_HANDLER( adsp_control_r ); | |
| 396 | static DECLARE_WRITE16_HANDLER( adsp_control_w ); | |
| 397 | 397 | |
| 398 | static READ16_HANDLER( latch_status_r ); | |
| 399 | static READ16_HANDLER( fifo_input_r ); | |
| 400 | static READ16_HANDLER( input_latch_r ); | |
| 401 | static WRITE16_HANDLER( input_latch_ack_w ); | |
| 402 | static WRITE16_HANDLER( output_latch_w ); | |
| 403 | static READ16_HANDLER( output_control_r ); | |
| 404 | static WRITE16_HANDLER( output_control_w ); | |
| 398 | static DECLARE_READ16_HANDLER( latch_status_r ); | |
| 399 | static DECLARE_READ16_HANDLER( fifo_input_r ); | |
| 400 | static DECLARE_READ16_HANDLER( input_latch_r ); | |
| 401 | static DECLARE_WRITE16_HANDLER( input_latch_ack_w ); | |
| 402 | static DECLARE_WRITE16_HANDLER( output_latch_w ); | |
| 403 | static DECLARE_READ16_HANDLER( output_control_r ); | |
| 404 | static DECLARE_WRITE16_HANDLER( output_control_w ); | |
| 405 | 405 | |
| 406 | 406 | static void timer_enable_callback(adsp21xx_device &device, int enable); |
| 407 | 407 | static TIMER_DEVICE_CALLBACK( internal_timer_callback ); |
| r17964 | r17965 | |
| 410 | 410 | static void recompute_sample_rate(running_machine &machine); |
| 411 | 411 | static void sound_tx_callback(adsp21xx_device &device, int port, INT32 data); |
| 412 | 412 | |
| 413 | static READ16_HANDLER( dcs_polling_r ); | |
| 414 | static WRITE16_HANDLER( dcs_polling_w ); | |
| 413 | static DECLARE_READ16_HANDLER( dcs_polling_r ); | |
| 414 | static DECLARE_WRITE16_HANDLER( dcs_polling_w ); | |
| 415 | 415 | |
| 416 | 416 | static TIMER_DEVICE_CALLBACK( transfer_watchdog_callback ); |
| 417 | 417 | static int preprocess_write(running_machine &machine, UINT16 data); |
| r17964 | r17965 | |
|---|---|---|
| 4 | 4 | |
| 5 | 5 | ****************************************************************************/ |
| 6 | 6 | |
| 7 | #ifndef __DCS_H__ | |
| 8 | #define __DCS_H__ | |
| 9 | ||
| 7 | 10 | MACHINE_CONFIG_EXTERN( dcs_audio_2k ); |
| 8 | 11 | MACHINE_CONFIG_EXTERN( dcs_audio_2k_uart ); |
| 9 | 12 | MACHINE_CONFIG_EXTERN( dcs_audio_8k ); |
| r17964 | r17965 | |
| 29 | 32 | |
| 30 | 33 | void dcs_fifo_notify(running_machine &machine, int count, int max); |
| 31 | 34 | |
| 32 | WRITE32_HANDLER( dsio_idma_addr_w ); | |
| 33 | WRITE32_HANDLER( dsio_idma_data_w ); | |
| 34 | READ32_HANDLER( dsio_idma_data_r ); | |
| 35 | DECLARE_WRITE32_HANDLER( dsio_idma_addr_w ); | |
| 36 | DECLARE_WRITE32_HANDLER( dsio_idma_data_w ); | |
| 37 | DECLARE_READ32_HANDLER( dsio_idma_data_r ); | |
| 38 | ||
| 39 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 1 | WRITE8_HANDLER( timeplt_sh_irqtrigger_w ); | |
| 1 | DECLARE_WRITE8_HANDLER( timeplt_sh_irqtrigger_w ); | |
| 2 | 2 | |
| 3 | 3 | MACHINE_CONFIG_EXTERN( timeplt_sound ); |
| 4 | 4 | MACHINE_CONFIG_EXTERN( locomotn_sound ); |
| r17964 | r17965 | |
|---|---|---|
| 1 | WRITE8_HANDLER( konami_sh_irqtrigger_w ); | |
| 2 | READ8_HANDLER( trackfld_sh_timer_r ); | |
| 1 | DECLARE_WRITE8_HANDLER( konami_sh_irqtrigger_w ); | |
| 2 | DECLARE_READ8_HANDLER( trackfld_sh_timer_r ); | |
| 3 | 3 | DECLARE_READ8_DEVICE_HANDLER( trackfld_speech_r ); |
| 4 | 4 | DECLARE_WRITE8_DEVICE_HANDLER( trackfld_sound_w ); |
| 5 | READ8_HANDLER( hyperspt_sh_timer_r ); | |
| 5 | DECLARE_READ8_HANDLER( hyperspt_sh_timer_r ); | |
| 6 | 6 | DECLARE_WRITE8_DEVICE_HANDLER( hyperspt_sound_w ); |
| 7 | WRITE8_HANDLER( konami_SN76496_latch_w ); | |
| 7 | DECLARE_WRITE8_HANDLER( konami_SN76496_latch_w ); | |
| 8 | 8 | DECLARE_WRITE8_DEVICE_HANDLER( konami_SN76496_w ); |
| 9 | 9 | |
| 10 | 10 | class trackfld_audio_device : public device_t, |
| r17964 | r17965 | |
|---|---|---|
| 3 | 3 | |
| 4 | 4 | extern const ay8910_interface cclimber_ay8910_interface; |
| 5 | 5 | extern const samples_interface cclimber_samples_interface; |
| 6 | WRITE8_HANDLER( cclimber_sample_trigger_w ); | |
| 7 | WRITE8_HANDLER( cclimber_sample_rate_w ); | |
| 8 | WRITE8_HANDLER( cclimber_sample_volume_w ); | |
| 6 | DECLARE_WRITE8_HANDLER( cclimber_sample_trigger_w ); | |
| 7 | DECLARE_WRITE8_HANDLER( cclimber_sample_rate_w ); | |
| 8 | DECLARE_WRITE8_HANDLER( cclimber_sample_volume_w ); |
| r17964 | r17965 | |
|---|---|---|
| 10 | 10 | ADDRESS_MAP_EXTERN( t5182_map, 8 ); |
| 11 | 11 | ADDRESS_MAP_EXTERN( t5182_io, 8 ); |
| 12 | 12 | |
| 13 | WRITE8_HANDLER( t5182_sound_irq_w ); | |
| 14 | READ8_HANDLER(t5182_sharedram_semaphore_snd_r); | |
| 15 | WRITE8_HANDLER(t5182_sharedram_semaphore_main_acquire_w); | |
| 16 | WRITE8_HANDLER(t5182_sharedram_semaphore_main_release_w); | |
| 13 | DECLARE_WRITE8_HANDLER( t5182_sound_irq_w ); | |
| 14 | DECLARE_READ8_HANDLER(t5182_sharedram_semaphore_snd_r); | |
| 15 | DECLARE_WRITE8_HANDLER(t5182_sharedram_semaphore_main_acquire_w); | |
| 16 | DECLARE_WRITE8_HANDLER(t5182_sharedram_semaphore_main_release_w); | |
| 17 | 17 | |
| 18 | READ8_HANDLER( t5182_sharedram_r ); | |
| 19 | WRITE8_HANDLER( t5182_sharedram_w ); | |
| 18 | DECLARE_READ8_HANDLER( t5182_sharedram_r ); | |
| 19 | DECLARE_WRITE8_HANDLER( t5182_sharedram_w ); | |
| 20 | 20 | |
| 21 | 21 | extern const ym2151_interface t5182_ym2151_interface; |
| r17964 | r17965 | |
|---|---|---|
| 1 | WRITE8_HANDLER( irem_sound_cmd_w ); | |
| 1 | DECLARE_WRITE8_HANDLER( irem_sound_cmd_w ); | |
| 2 | 2 | |
| 3 | 3 | MACHINE_CONFIG_EXTERN( m52_sound_c_audio ); |
| 4 | 4 | MACHINE_CONFIG_EXTERN( m52_large_audio ); |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | void NMK004_init(running_machine &machine); |
| 2 | 2 | void NMK004_irq(device_t *device, int irq); |
| 3 | READ16_HANDLER( NMK004_r ); | |
| 4 | WRITE16_HANDLER( NMK004_w ); | |
| 3 | DECLARE_READ16_HANDLER( NMK004_r ); | |
| 4 | DECLARE_WRITE16_HANDLER( NMK004_w ); |
| r17964 | r17965 | |
|---|---|---|
| 11 | 11 | |
| 12 | 12 | void asic65_config(running_machine &machine, int asictype); |
| 13 | 13 | void asic65_reset(running_machine &machine, int state); |
| 14 | WRITE16_HANDLER( asic65_data_w ); | |
| 15 | READ16_HANDLER( asic65_r ); | |
| 16 | READ16_HANDLER( asic65_io_r ); | |
| 14 | DECLARE_WRITE16_HANDLER( asic65_data_w ); | |
| 15 | DECLARE_READ16_HANDLER( asic65_r ); | |
| 16 | DECLARE_READ16_HANDLER( asic65_io_r ); | |
| 17 | 17 | |
| 18 | 18 | MACHINE_CONFIG_EXTERN( asic65 ); |
| r17964 | r17965 | |
|---|---|---|
| 6 | 6 | |
| 7 | 7 | ******************************************************************************/ |
| 8 | 8 | |
| 9 | READ16_HANDLER( tmp68301_address_decoder_r ); | |
| 10 | WRITE16_HANDLER( tmp68301_address_decoder_w ); | |
| 11 | READ16_HANDLER( tmp68301_interrupt_controller_r ); | |
| 12 | WRITE16_HANDLER( tmp68301_interrupt_controller_w ); | |
| 13 | READ16_HANDLER( tmp68301_parallel_interface_r ); | |
| 14 | WRITE16_HANDLER( tmp68301_parallel_interface_w ); | |
| 15 | READ16_HANDLER( tmp68301_serial_interface_r ); | |
| 16 | WRITE16_HANDLER( tmp68301_serial_interface_w ); | |
| 17 | READ16_HANDLER( tmp68301_timer_r ); | |
| 18 | WRITE16_HANDLER( tmp68301_timer_w ); | |
| 9 | DECLARE_READ16_HANDLER( tmp68301_address_decoder_r ); | |
| 10 | DECLARE_WRITE16_HANDLER( tmp68301_address_decoder_w ); | |
| 11 | DECLARE_READ16_HANDLER( tmp68301_interrupt_controller_r ); | |
| 12 | DECLARE_WRITE16_HANDLER( tmp68301_interrupt_controller_w ); | |
| 13 | DECLARE_READ16_HANDLER( tmp68301_parallel_interface_r ); | |
| 14 | DECLARE_WRITE16_HANDLER( tmp68301_parallel_interface_w ); | |
| 15 | DECLARE_READ16_HANDLER( tmp68301_serial_interface_r ); | |
| 16 | DECLARE_WRITE16_HANDLER( tmp68301_serial_interface_w ); | |
| 17 | DECLARE_READ16_HANDLER( tmp68301_timer_r ); | |
| 18 | DECLARE_WRITE16_HANDLER( tmp68301_timer_w ); |
| r17964 | r17965 | |
|---|---|---|
| 15 | 15 | TIMER_DEVICE_CALLBACK( stv_sector_cb ); |
| 16 | 16 | TIMER_DEVICE_CALLBACK( stv_sh1_sim ); |
| 17 | 17 | |
| 18 | READ32_HANDLER( stvcd_r ); | |
| 19 | WRITE32_HANDLER( stvcd_w ); | |
| 18 | DECLARE_READ32_HANDLER( stvcd_r ); | |
| 19 | DECLARE_WRITE32_HANDLER( stvcd_w ); | |
| 20 | 20 | |
| 21 | 21 | void stvcd_set_tray_open(running_machine &machine); |
| 22 | 22 | void stvcd_set_tray_close(running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 15 | 15 | INLINE UINT8 bank_r(address_space &space, offs_t offset, int bank) |
| 16 | 16 | { |
| 17 | 17 | namcos1_state *state = space.machine().driver_data<namcos1_state>(); |
| 18 | return (*state->m_active_bank[bank].bank_handler_r )(space, offset + state->m_active_bank[bank].bank_offset); | |
| 18 | return (*state->m_active_bank[bank].bank_handler_r )(space, offset + state->m_active_bank[bank].bank_offset, 0xff); | |
| 19 | 19 | } |
| 20 | 20 | |
| 21 | 21 | static READ8_HANDLER( bank1_r ) { return bank_r(space, offset, 0); } |
| r17964 | r17965 | |
| 38 | 38 | INLINE void bank_w(address_space &space, offs_t offset, UINT8 data, int bank) |
| 39 | 39 | { |
| 40 | 40 | namcos1_state *state = space.machine().driver_data<namcos1_state>(); |
| 41 | (*state->m_active_bank[bank].bank_handler_w )(space, offset + state->m_active_bank[bank].bank_offset, data); | |
| 41 | (*state->m_active_bank[bank].bank_handler_w )(space, offset + state->m_active_bank[bank].bank_offset, data, 0xff); | |
| 42 | 42 | } |
| 43 | 43 | |
| 44 | 44 | static WRITE8_HANDLER( bank1_w ) { bank_w(space, offset, data, 0); } |
| r17964 | r17965 | |
| 84 | 84 | |
| 85 | 85 | |
| 86 | 86 | // used by faceoff and tankforce 4 player (input multiplex) |
| 87 | static READ8_HANDLER( faceoff_inputs_r ); | |
| 87 | static DECLARE_READ8_HANDLER( faceoff_inputs_r ); | |
| 88 | 88 | |
| 89 | 89 | static READ8_HANDLER( no_key_r ) |
| 90 | 90 | { |
| r17964 | r17965 | |
|---|---|---|
| 95 | 95 | } |
| 96 | 96 | |
| 97 | 97 | |
| 98 | static READ16_HANDLER( megadriv_68k_check_z80_bus ); | |
| 99 | static WRITE16_HANDLER(megadriv_68k_req_z80_bus); | |
| 98 | static DECLARE_READ16_HANDLER( megadriv_68k_check_z80_bus ); | |
| 99 | static DECLARE_WRITE16_HANDLER(megadriv_68k_req_z80_bus); | |
| 100 | 100 | |
| 101 | static READ16_HANDLER( megadriv_68k_read_z80_ram ); | |
| 102 | static WRITE16_HANDLER( megadriv_68k_write_z80_ram ); | |
| 101 | static DECLARE_READ16_HANDLER( megadriv_68k_read_z80_ram ); | |
| 102 | static DECLARE_WRITE16_HANDLER( megadriv_68k_write_z80_ram ); | |
| 103 | 103 | |
| 104 | static WRITE16_HANDLER( megadriv_68k_req_z80_reset ); | |
| 104 | static DECLARE_WRITE16_HANDLER( megadriv_68k_req_z80_reset ); | |
| 105 | 105 | |
| 106 | 106 | |
| 107 | 107 |
| r17964 | r17965 | |
|---|---|---|
| 1372 | 1372 | if (SEGACD_FORCE_SYNCS) space.machine().scheduler().synchronize(); |
| 1373 | 1373 | |
| 1374 | 1374 | if (ACCESSING_BITS_8_15) |
| 1375 | scd_a12002_memory_mode_w_8_15(space, 0, data>>8); | |
| 1375 | scd_a12002_memory_mode_w_8_15(space, 0, data>>8, mem_mask>>8); | |
| 1376 | 1376 | |
| 1377 | 1377 | if (ACCESSING_BITS_0_7) |
| 1378 | scd_a12002_memory_mode_w_0_7(space, 0, data&0xff); | |
| 1378 | scd_a12002_memory_mode_w_0_7(space, 0, data&0xff, mem_mask&0xff); | |
| 1379 | 1379 | } |
| 1380 | 1380 | |
| 1381 | 1381 | |
| r17964 | r17965 | |
| 1468 | 1468 | if (SEGACD_FORCE_SYNCS) space.machine().scheduler().synchronize(); |
| 1469 | 1469 | |
| 1470 | 1470 | if (ACCESSING_BITS_8_15) |
| 1471 | segacd_sub_memory_mode_w_8_15(space, 0, data>>8); | |
| 1471 | segacd_sub_memory_mode_w_8_15(space, 0, data>>8, mem_mask>>8); | |
| 1472 | 1472 | |
| 1473 | 1473 | if (ACCESSING_BITS_0_7) |
| 1474 | segacd_sub_memory_mode_w_0_7(space, 0, data&0xff); | |
| 1474 | segacd_sub_memory_mode_w_0_7(space, 0, data&0xff, mem_mask&0xff); | |
| 1475 | 1475 | } |
| 1476 | 1476 | |
| 1477 | 1477 | |
| r17964 | r17965 | |
| 2305 | 2305 | void segacd_init_main_cpu( running_machine& machine ) |
| 2306 | 2306 | { |
| 2307 | 2307 | address_space& space = *machine.device("maincpu")->memory().space(AS_PROGRAM); |
| 2308 | ||
| 2308 | ||
| 2309 | 2309 | segacd_font_bits = reinterpret_cast<UINT16 *>(machine.root_device().memshare(":segacd:segacd_font")->ptr()); |
| 2310 | 2310 | segacd_backupram = reinterpret_cast<UINT16 *>(machine.root_device().memshare(":segacd:backupram")->ptr()); |
| 2311 | 2311 | segacd_dataram = reinterpret_cast<UINT16 *>(machine.root_device().memshare(":segacd:dataram")->ptr()); |
| 2312 | 2312 | segacd_dataram2 = reinterpret_cast<UINT16 *>(machine.root_device().memshare(":segacd:dataram2")->ptr()); |
| 2313 | 2313 | segacd_4meg_prgram = reinterpret_cast<UINT16 *>(machine.root_device().memshare(":segacd:segacd_program")->ptr()); |
| 2314 | ||
| 2314 | ||
| 2315 | 2315 | segacd_4meg_prgbank = 0; |
| 2316 | 2316 | |
| 2317 | 2317 |
| r17964 | r17965 | |
|---|---|---|
| 1 | WRITE8_HANDLER( stv_SMPC_w ); | |
| 2 | READ8_HANDLER( stv_SMPC_r ); | |
| 3 | WRITE8_HANDLER( saturn_SMPC_w ); | |
| 4 | READ8_HANDLER( saturn_SMPC_r ); | |
| 1 | DECLARE_WRITE8_HANDLER( stv_SMPC_w ); | |
| 2 | DECLARE_READ8_HANDLER( stv_SMPC_r ); | |
| 3 | DECLARE_WRITE8_HANDLER( saturn_SMPC_w ); | |
| 4 | DECLARE_READ8_HANDLER( saturn_SMPC_r ); |
| r17964 | r17965 | |
|---|---|---|
| 1242 | 1242 | else |
| 1243 | 1243 | { |
| 1244 | 1244 | if (state->m_dongle_r) |
| 1245 | data = (*state->m_dongle_r)(space, offset); | |
| 1245 | data = (*state->m_dongle_r)(space, offset, mem_mask); | |
| 1246 | 1246 | else |
| 1247 | 1247 | data = 0xff; |
| 1248 | 1248 | } |
| r17964 | r17965 | |
| 1254 | 1254 | decocass_state *state = space.machine().driver_data<decocass_state>(); |
| 1255 | 1255 | if (state->m_dongle_w) |
| 1256 | 1256 | { |
| 1257 | (*state->m_dongle_w)(space, offset, data); | |
| 1257 | (*state->m_dongle_w)(space, offset, data, mem_mask); | |
| 1258 | 1258 | return; |
| 1259 | 1259 | } |
| 1260 | 1260 |
| r17964 | r17965 | |
|---|---|---|
| 184 | 184 | |
| 185 | 185 | |
| 186 | 186 | |
| 187 | WRITE8_HANDLER( decocass_coin_counter_w ); | |
| 188 | WRITE8_HANDLER( decocass_sound_command_w ); | |
| 189 | READ8_HANDLER( decocass_sound_data_r ); | |
| 190 | READ8_HANDLER( decocass_sound_ack_r ); | |
| 191 | WRITE8_HANDLER( decocass_sound_data_w ); | |
| 192 | READ8_HANDLER( decocass_sound_command_r ); | |
| 187 | DECLARE_WRITE8_HANDLER( decocass_coin_counter_w ); | |
| 188 | DECLARE_WRITE8_HANDLER( decocass_sound_command_w ); | |
| 189 | DECLARE_READ8_HANDLER( decocass_sound_data_r ); | |
| 190 | DECLARE_READ8_HANDLER( decocass_sound_ack_r ); | |
| 191 | DECLARE_WRITE8_HANDLER( decocass_sound_data_w ); | |
| 192 | DECLARE_READ8_HANDLER( decocass_sound_command_r ); | |
| 193 | 193 | TIMER_DEVICE_CALLBACK( decocass_audio_nmi_gen ); |
| 194 | WRITE8_HANDLER( decocass_sound_nmi_enable_w ); | |
| 195 | READ8_HANDLER( decocass_sound_nmi_enable_r ); | |
| 196 | READ8_HANDLER( decocass_sound_data_ack_reset_r ); | |
| 197 | WRITE8_HANDLER( decocass_sound_data_ack_reset_w ); | |
| 198 | WRITE8_HANDLER( decocass_nmi_reset_w ); | |
| 199 | WRITE8_HANDLER( decocass_quadrature_decoder_reset_w ); | |
| 200 | WRITE8_HANDLER( decocass_adc_w ); | |
| 201 | READ8_HANDLER( decocass_input_r ); | |
| 194 | DECLARE_WRITE8_HANDLER( decocass_sound_nmi_enable_w ); | |
| 195 | DECLARE_READ8_HANDLER( decocass_sound_nmi_enable_r ); | |
| 196 | DECLARE_READ8_HANDLER( decocass_sound_data_ack_reset_r ); | |
| 197 | DECLARE_WRITE8_HANDLER( decocass_sound_data_ack_reset_w ); | |
| 198 | DECLARE_WRITE8_HANDLER( decocass_nmi_reset_w ); | |
| 199 | DECLARE_WRITE8_HANDLER( decocass_quadrature_decoder_reset_w ); | |
| 200 | DECLARE_WRITE8_HANDLER( decocass_adc_w ); | |
| 201 | DECLARE_READ8_HANDLER( decocass_input_r ); | |
| 202 | 202 | |
| 203 | WRITE8_HANDLER( decocass_reset_w ); | |
| 203 | DECLARE_WRITE8_HANDLER( decocass_reset_w ); | |
| 204 | 204 | |
| 205 | READ8_HANDLER( decocass_e5xx_r ); | |
| 206 | WRITE8_HANDLER( decocass_e5xx_w ); | |
| 207 | WRITE8_HANDLER( decocass_de0091_w ); | |
| 208 | WRITE8_HANDLER( decocass_e900_w ); | |
| 205 | DECLARE_READ8_HANDLER( decocass_e5xx_r ); | |
| 206 | DECLARE_WRITE8_HANDLER( decocass_e5xx_w ); | |
| 207 | DECLARE_WRITE8_HANDLER( decocass_de0091_w ); | |
| 208 | DECLARE_WRITE8_HANDLER( decocass_e900_w ); | |
| 209 | 209 | |
| 210 | 210 | |
| 211 | 211 | |
| r17964 | r17965 | |
| 243 | 243 | |
| 244 | 244 | |
| 245 | 245 | |
| 246 | WRITE8_HANDLER( i8041_p1_w ); | |
| 247 | READ8_HANDLER( i8041_p1_r ); | |
| 248 | WRITE8_HANDLER( i8041_p2_w ); | |
| 249 | READ8_HANDLER( i8041_p2_r ); | |
| 246 | DECLARE_WRITE8_HANDLER( i8041_p1_w ); | |
| 247 | DECLARE_READ8_HANDLER( i8041_p1_r ); | |
| 248 | DECLARE_WRITE8_HANDLER( i8041_p2_w ); | |
| 249 | DECLARE_READ8_HANDLER( i8041_p2_r ); | |
| 250 | 250 | |
| 251 | 251 | void decocass_machine_state_save_init(running_machine &machine); |
| 252 | 252 | |
| 253 | 253 | |
| 254 | 254 | /*----------- defined in video/decocass.c -----------*/ |
| 255 | 255 | |
| 256 | WRITE8_HANDLER( decocass_paletteram_w ); | |
| 257 | WRITE8_HANDLER( decocass_charram_w ); | |
| 258 | WRITE8_HANDLER( decocass_fgvideoram_w ); | |
| 259 | WRITE8_HANDLER( decocass_colorram_w ); | |
| 260 | WRITE8_HANDLER( decocass_bgvideoram_w ); | |
| 261 | WRITE8_HANDLER( decocass_tileram_w ); | |
| 262 | WRITE8_HANDLER( decocass_objectram_w ); | |
| 256 | DECLARE_WRITE8_HANDLER( decocass_paletteram_w ); | |
| 257 | DECLARE_WRITE8_HANDLER( decocass_charram_w ); | |
| 258 | DECLARE_WRITE8_HANDLER( decocass_fgvideoram_w ); | |
| 259 | DECLARE_WRITE8_HANDLER( decocass_colorram_w ); | |
| 260 | DECLARE_WRITE8_HANDLER( decocass_bgvideoram_w ); | |
| 261 | DECLARE_WRITE8_HANDLER( decocass_tileram_w ); | |
| 262 | DECLARE_WRITE8_HANDLER( decocass_objectram_w ); | |
| 263 | 263 | |
| 264 | WRITE8_HANDLER( decocass_watchdog_count_w ); | |
| 265 | WRITE8_HANDLER( decocass_watchdog_flip_w ); | |
| 266 | WRITE8_HANDLER( decocass_color_missiles_w ); | |
| 267 | WRITE8_HANDLER( decocass_mode_set_w ); | |
| 268 | WRITE8_HANDLER( decocass_color_center_bot_w ); | |
| 269 | WRITE8_HANDLER( decocass_back_h_shift_w ); | |
| 270 | WRITE8_HANDLER( decocass_back_vl_shift_w ); | |
| 271 | WRITE8_HANDLER( decocass_back_vr_shift_w ); | |
| 272 | WRITE8_HANDLER( decocass_part_h_shift_w ); | |
| 273 | WRITE8_HANDLER( decocass_part_v_shift_w ); | |
| 274 | WRITE8_HANDLER( decocass_center_h_shift_space_w ); | |
| 275 | WRITE8_HANDLER( decocass_center_v_shift_w ); | |
| 264 | DECLARE_WRITE8_HANDLER( decocass_watchdog_count_w ); | |
| 265 | DECLARE_WRITE8_HANDLER( decocass_watchdog_flip_w ); | |
| 266 | DECLARE_WRITE8_HANDLER( decocass_color_missiles_w ); | |
| 267 | DECLARE_WRITE8_HANDLER( decocass_mode_set_w ); | |
| 268 | DECLARE_WRITE8_HANDLER( decocass_color_center_bot_w ); | |
| 269 | DECLARE_WRITE8_HANDLER( decocass_back_h_shift_w ); | |
| 270 | DECLARE_WRITE8_HANDLER( decocass_back_vl_shift_w ); | |
| 271 | DECLARE_WRITE8_HANDLER( decocass_back_vr_shift_w ); | |
| 272 | DECLARE_WRITE8_HANDLER( decocass_part_h_shift_w ); | |
| 273 | DECLARE_WRITE8_HANDLER( decocass_part_v_shift_w ); | |
| 274 | DECLARE_WRITE8_HANDLER( decocass_center_h_shift_space_w ); | |
| 275 | DECLARE_WRITE8_HANDLER( decocass_center_v_shift_w ); | |
| 276 | 276 | |
| 277 | 277 | |
| 278 | 278 | SCREEN_UPDATE_IND16( decocass ); |
| r17964 | r17965 | |
|---|---|---|
| 12 | 12 | int get_cgboard_id(void); |
| 13 | 13 | void set_cgboard_texture_bank(running_machine &machine, int board, const char *bank, UINT8 *rom); |
| 14 | 14 | |
| 15 | READ32_HANDLER( cgboard_dsp_comm_r_ppc ); | |
| 16 | WRITE32_HANDLER( cgboard_dsp_comm_w_ppc ); | |
| 17 | READ32_HANDLER( cgboard_dsp_shared_r_ppc ); | |
| 18 | WRITE32_HANDLER( cgboard_dsp_shared_w_ppc ); | |
| 15 | DECLARE_READ32_HANDLER( cgboard_dsp_comm_r_ppc ); | |
| 16 | DECLARE_WRITE32_HANDLER( cgboard_dsp_comm_w_ppc ); | |
| 17 | DECLARE_READ32_HANDLER( cgboard_dsp_shared_r_ppc ); | |
| 18 | DECLARE_WRITE32_HANDLER( cgboard_dsp_shared_w_ppc ); | |
| 19 | 19 | |
| 20 | READ32_HANDLER( cgboard_0_comm_sharc_r ); | |
| 21 | WRITE32_HANDLER( cgboard_0_comm_sharc_w ); | |
| 22 | READ32_HANDLER( cgboard_0_shared_sharc_r ); | |
| 23 | WRITE32_HANDLER( cgboard_0_shared_sharc_w ); | |
| 24 | READ32_HANDLER( cgboard_1_comm_sharc_r ); | |
| 25 | WRITE32_HANDLER( cgboard_1_comm_sharc_w ); | |
| 26 | READ32_HANDLER( cgboard_1_shared_sharc_r ); | |
| 27 | WRITE32_HANDLER( cgboard_1_shared_sharc_w ); | |
| 20 | DECLARE_READ32_HANDLER( cgboard_0_comm_sharc_r ); | |
| 21 | DECLARE_WRITE32_HANDLER( cgboard_0_comm_sharc_w ); | |
| 22 | DECLARE_READ32_HANDLER( cgboard_0_shared_sharc_r ); | |
| 23 | DECLARE_WRITE32_HANDLER( cgboard_0_shared_sharc_w ); | |
| 24 | DECLARE_READ32_HANDLER( cgboard_1_comm_sharc_r ); | |
| 25 | DECLARE_WRITE32_HANDLER( cgboard_1_comm_sharc_w ); | |
| 26 | DECLARE_READ32_HANDLER( cgboard_1_shared_sharc_r ); | |
| 27 | DECLARE_WRITE32_HANDLER( cgboard_1_shared_sharc_w ); | |
| 28 | 28 | |
| 29 | READ32_HANDLER(K033906_0_r); | |
| 30 | WRITE32_HANDLER(K033906_0_w); | |
| 31 | READ32_HANDLER(K033906_1_r); | |
| 32 | WRITE32_HANDLER(K033906_1_w); | |
| 29 | DECLARE_READ32_HANDLER(K033906_0_r); | |
| 30 | DECLARE_WRITE32_HANDLER(K033906_0_w); | |
| 31 | DECLARE_READ32_HANDLER(K033906_1_r); | |
| 32 | DECLARE_WRITE32_HANDLER(K033906_1_w); | |
| 33 | 33 | |
| 34 | 34 | DECLARE_WRITE32_DEVICE_HANDLER(nwk_fifo_0_w); |
| 35 | 35 | DECLARE_WRITE32_DEVICE_HANDLER(nwk_fifo_1_w); |
| r17964 | r17965 | |
|---|---|---|
| 30 | 30 | void midway_ioasic_fifo_w(running_machine &machine, UINT16 data); |
| 31 | 31 | void midway_ioasic_fifo_reset_w(running_machine &machine, int state); |
| 32 | 32 | void midway_ioasic_fifo_full_w(running_machine &machine, UINT16 data); |
| 33 | READ32_HANDLER( midway_ioasic_r ); | |
| 34 | WRITE32_HANDLER( midway_ioasic_w ); | |
| 35 | READ32_HANDLER( midway_ioasic_packed_r ); | |
| 36 | WRITE32_HANDLER( midway_ioasic_packed_w ); | |
| 33 | DECLARE_READ32_HANDLER( midway_ioasic_r ); | |
| 34 | DECLARE_WRITE32_HANDLER( midway_ioasic_w ); | |
| 35 | DECLARE_READ32_HANDLER( midway_ioasic_packed_r ); | |
| 36 | DECLARE_WRITE32_HANDLER( midway_ioasic_packed_w ); | |
| 37 | 37 | |
| 38 | 38 | enum |
| 39 | 39 | { |
| r17964 | r17965 | |
|---|---|---|
| 177 | 177 | else |
| 178 | 178 | { /* port select */ |
| 179 | 179 | st->parallelselect = data & 0x07; |
| 180 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space,st->parallelselect) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0); | |
| 180 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space,st->parallelselect,0xff) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0); | |
| 181 | 181 | } |
| 182 | 182 | } |
| 183 | 183 | } |
| r17964 | r17965 | |
| 188 | 188 | case -1: /* no command data */ |
| 189 | 189 | break; |
| 190 | 190 | case 0x00: /* read from parallel port */ |
| 191 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space,0) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0 ); | |
| 191 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space,0,0xff) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0 ); | |
| 192 | 192 | break; |
| 193 | 193 | case 0x01: /* read receive buffer 0 */ |
| 194 | 194 | case 0x02: /* read receive buffer 1 */ |
| r17964 | r17965 | |
| 201 | 201 | taito8741_hostdata_w(st,st->rxd[data-1]); |
| 202 | 202 | break; |
| 203 | 203 | case 0x08: /* latch received serial data */ |
| 204 | st->txd[0] = st->portHandler ? st->portHandler(space,0) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0; | |
| 204 | st->txd[0] = st->portHandler ? st->portHandler(space,0,0xff) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0; | |
| 205 | 205 | if( sst ) |
| 206 | 206 | { |
| 207 | 207 | space.machine().scheduler().synchronize(FUNC(taito8741_serial_tx), num); |
| r17964 | r17965 | |
| 295 | 295 | switch( st->mode ) |
| 296 | 296 | { |
| 297 | 297 | case TAITO8741_PORT: /* parallel data */ |
| 298 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space, st->parallelselect) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0); | |
| 298 | taito8741_hostdata_w(st,st->portHandler ? st->portHandler(space, st->parallelselect, 0xff) : st->portName ? space.machine().root_device().ioport(st->portName)->read() : 0); | |
| 299 | 299 | break; |
| 300 | 300 | } |
| 301 | 301 | return ret; |
| r17964 | r17965 | |
|---|---|---|
| 28 | 28 | void TAITO8741_reset(int num); |
| 29 | 29 | |
| 30 | 30 | /* write handler */ |
| 31 | WRITE8_HANDLER( TAITO8741_0_w ); | |
| 32 | WRITE8_HANDLER( TAITO8741_1_w ); | |
| 33 | WRITE8_HANDLER( TAITO8741_2_w ); | |
| 34 | WRITE8_HANDLER( TAITO8741_3_w ); | |
| 31 | DECLARE_WRITE8_HANDLER( TAITO8741_0_w ); | |
| 32 | DECLARE_WRITE8_HANDLER( TAITO8741_1_w ); | |
| 33 | DECLARE_WRITE8_HANDLER( TAITO8741_2_w ); | |
| 34 | DECLARE_WRITE8_HANDLER( TAITO8741_3_w ); | |
| 35 | 35 | /* read handler */ |
| 36 | READ8_HANDLER( TAITO8741_0_r ); | |
| 37 | READ8_HANDLER( TAITO8741_1_r ); | |
| 38 | READ8_HANDLER( TAITO8741_2_r ); | |
| 39 | READ8_HANDLER( TAITO8741_3_r ); | |
| 36 | DECLARE_READ8_HANDLER( TAITO8741_0_r ); | |
| 37 | DECLARE_READ8_HANDLER( TAITO8741_1_r ); | |
| 38 | DECLARE_READ8_HANDLER( TAITO8741_2_r ); | |
| 39 | DECLARE_READ8_HANDLER( TAITO8741_3_r ); | |
| 40 | 40 | |
| 41 | 41 | /**************************************************************************** |
| 42 | 42 | joshi Volleyball set. |
| 43 | 43 | ****************************************************************************/ |
| 44 | 44 | |
| 45 | 45 | void josvolly_8741_reset(void); |
| 46 | WRITE8_HANDLER( josvolly_8741_0_w ); | |
| 47 | WRITE8_HANDLER( josvolly_8741_1_w ); | |
| 48 | READ8_HANDLER( josvolly_8741_0_r ); | |
| 49 | READ8_HANDLER( josvolly_8741_1_r ); | |
| 50 | WRITE8_HANDLER( josvolly_nmi_enable_w ); | |
| 46 | DECLARE_WRITE8_HANDLER( josvolly_8741_0_w ); | |
| 47 | DECLARE_WRITE8_HANDLER( josvolly_8741_1_w ); | |
| 48 | DECLARE_READ8_HANDLER( josvolly_8741_0_r ); | |
| 49 | DECLARE_READ8_HANDLER( josvolly_8741_1_r ); | |
| 50 | DECLARE_WRITE8_HANDLER( josvolly_nmi_enable_w ); | |
| 51 | 51 | |
| 52 | 52 | #endif |
| 53 | 53 |
| r17964 | r17965 | |
|---|---|---|
| 11 | 11 | |
| 12 | 12 | #define PCE_MAIN_CLOCK 21477270 |
| 13 | 13 | |
| 14 | WRITE8_HANDLER ( pce_joystick_w ); | |
| 15 | READ8_HANDLER ( pce_joystick_r ); | |
| 14 | DECLARE_WRITE8_HANDLER ( pce_joystick_w ); | |
| 15 | DECLARE_READ8_HANDLER ( pce_joystick_r ); | |
| 16 | 16 | |
| 17 | 17 | #define TG_16_JOY_SIG 0x00 |
| 18 | 18 | #define PCE_JOY_SIG 0x40 |
| r17964 | r17965 | |
|---|---|---|
| 35 | 35 | static void snes_hdma_init(address_space &space); |
| 36 | 36 | static void snes_hdma(address_space &space); |
| 37 | 37 | |
| 38 | static READ8_HANDLER(snes_io_dma_r); | |
| 39 | static WRITE8_HANDLER(snes_io_dma_w); | |
| 38 | static DECLARE_READ8_HANDLER(snes_io_dma_r); | |
| 39 | static DECLARE_WRITE8_HANDLER(snes_io_dma_w); | |
| 40 | 40 | |
| 41 | 41 | struct snes_cart_info snes_cart; |
| 42 | 42 | |
| r17964 | r17965 | |
| 604 | 604 | // APU is mirrored from 2140 to 217f |
| 605 | 605 | if (offset >= APU00 && offset < WMDATA) |
| 606 | 606 | { |
| 607 | // printf("816: %02x to APU @ %d (PC=%06x)\n", data, offset & 3,space | |
| 607 | // printf("816: %02x to APU @ %d (PC=%06x)\n", data, offset & 3,space. | |
| 608 | 608 | spc_port_in(state->m_spc700, space, offset & 0x3, data); |
| 609 | 609 | space.machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(20)); |
| 610 | 610 | return; |
| r17964 | r17965 | |
| 849 | 849 | else if (address < 0x6000) /* I/O */ |
| 850 | 850 | { |
| 851 | 851 | if (state->m_cart[0].mode == SNES_MODE_BSX && address >= 0x5000) |
| 852 | value = bsx_read(space, offset); | |
| 852 | value = bsx_read(space, offset, mem_mask); | |
| 853 | 853 | else |
| 854 | 854 | value = snes_r_io(space, address); |
| 855 | 855 | } |
| r17964 | r17965 | |
| 863 | 863 | value = snes_open_bus_r(space, 0); |
| 864 | 864 | } |
| 865 | 865 | else if (state->m_has_addon_chip == HAS_OBC1) |
| 866 | value = obc1_read(space, offset); | |
| 866 | value = obc1_read(space, offset, mem_mask); | |
| 867 | 867 | else if ((state->m_cart[0].mode == SNES_MODE_21) && (state->m_has_addon_chip == HAS_DSP1) && (offset < 0x100000)) |
| 868 | 868 | value = (address < 0x7000) ? dsp_get_dr() : dsp_get_sr(); |
| 869 | 869 | else if (state->m_has_addon_chip == HAS_CX4) |
| r17964 | r17965 | |
| 903 | 903 | else if (address < 0x6000) /* I/O */ |
| 904 | 904 | { |
| 905 | 905 | if (state->m_cart[0].mode == SNES_MODE_BSX && address >= 0x5000) |
| 906 | value = bsx_read(space, 0x300000 + offset); | |
| 906 | value = bsx_read(space, 0x300000 + offset, mem_mask); | |
| 907 | 907 | else |
| 908 | 908 | value = snes_r_io(space, address); |
| 909 | 909 | } |
| r17964 | r17965 | |
| 917 | 917 | value = snes_open_bus_r(space, 0); |
| 918 | 918 | } |
| 919 | 919 | else if (state->m_has_addon_chip == HAS_OBC1) |
| 920 | value = obc1_read (space, offset); | |
| 920 | value = obc1_read (space, offset, mem_mask); | |
| 921 | 921 | else if (state->m_has_addon_chip == HAS_CX4) |
| 922 | 922 | value = CX4_read(address - 0x6000); |
| 923 | 923 | else if (state->m_has_addon_chip == HAS_SPC7110 || state->m_has_addon_chip == HAS_SPC7110_RTC) |
| r17964 | r17965 | |
| 1184 | 1184 | else if (address < 0x6000) /* I/O */ |
| 1185 | 1185 | { |
| 1186 | 1186 | if (state->m_cart[0].mode == SNES_MODE_BSX && address >= 0x5000) |
| 1187 | bsx_write(space, offset, data); | |
| 1187 | bsx_write(space, offset, data, mem_mask); | |
| 1188 | 1188 | else |
| 1189 | 1189 | snes_w_io(space, address, data); |
| 1190 | 1190 | } |
| r17964 | r17965 | |
| 1193 | 1193 | if (state->m_has_addon_chip == HAS_SUPERFX) |
| 1194 | 1194 | snes_ram[0xf00000 + (offset & 0x1fff)] = data; // here it should be 0xe00000 but there are mirroring issues |
| 1195 | 1195 | else if (state->m_has_addon_chip == HAS_OBC1) |
| 1196 | obc1_write(space, offset, data); | |
| 1196 | obc1_write(space, offset, data, mem_mask); | |
| 1197 | 1197 | else if ((state->m_cart[0].mode == SNES_MODE_21) && (state->m_has_addon_chip == HAS_DSP1) && (offset < 0x100000)) |
| 1198 | 1198 | dsp_set_dr(data); |
| 1199 | 1199 | else if (state->m_has_addon_chip == HAS_CX4) |
| r17964 | r17965 | |
| 1235 | 1235 | else if (address < 0x6000) /* I/O */ |
| 1236 | 1236 | { |
| 1237 | 1237 | if (state->m_cart[0].mode == SNES_MODE_BSX && address >= 0x5000) |
| 1238 | bsx_write(space, 0x300000 + offset, data); | |
| 1238 | bsx_write(space, 0x300000 + offset, data, mem_mask); | |
| 1239 | 1239 | else |
| 1240 | 1240 | snes_w_io(space, address, data); |
| 1241 | 1241 | } |
| r17964 | r17965 | |
| 1244 | 1244 | if (state->m_has_addon_chip == HAS_SUPERFX) |
| 1245 | 1245 | snes_ram[0xf00000 + (offset & 0x1fff)] = data; // here it should be 0xe00000 but there are mirroring issues |
| 1246 | 1246 | else if (state->m_has_addon_chip == HAS_OBC1) |
| 1247 | obc1_write(space, offset, data); | |
| 1247 | obc1_write(space, offset, data, mem_mask); | |
| 1248 | 1248 | else if (state->m_has_addon_chip == HAS_CX4) |
| 1249 | 1249 | CX4_write(space.machine(), address - 0x6000, data); |
| 1250 | 1250 | else if (state->m_has_addon_chip == HAS_SPC7110 || state->m_has_addon_chip == HAS_SPC7110_RTC) |
| r17964 | r17965 | |
|---|---|---|
| 213 | 213 | |
| 214 | 214 | void atarigen_scanline_int_set(screen_device &screen, int scanline); |
| 215 | 215 | INTERRUPT_GEN( atarigen_scanline_int_gen ); |
| 216 | WRITE16_HANDLER( atarigen_scanline_int_ack_w ); | |
| 217 | WRITE32_HANDLER( atarigen_scanline_int_ack32_w ); | |
| 216 | DECLARE_WRITE16_HANDLER( atarigen_scanline_int_ack_w ); | |
| 217 | DECLARE_WRITE32_HANDLER( atarigen_scanline_int_ack32_w ); | |
| 218 | 218 | |
| 219 | 219 | INTERRUPT_GEN( atarigen_sound_int_gen ); |
| 220 | WRITE16_HANDLER( atarigen_sound_int_ack_w ); | |
| 221 | WRITE32_HANDLER( atarigen_sound_int_ack32_w ); | |
| 220 | DECLARE_WRITE16_HANDLER( atarigen_sound_int_ack_w ); | |
| 221 | DECLARE_WRITE32_HANDLER( atarigen_sound_int_ack32_w ); | |
| 222 | 222 | |
| 223 | 223 | INTERRUPT_GEN( atarigen_video_int_gen ); |
| 224 | WRITE16_HANDLER( atarigen_video_int_ack_w ); | |
| 225 | WRITE32_HANDLER( atarigen_video_int_ack32_w ); | |
| 224 | DECLARE_WRITE16_HANDLER( atarigen_video_int_ack_w ); | |
| 225 | DECLARE_WRITE32_HANDLER( atarigen_video_int_ack32_w ); | |
| 226 | 226 | |
| 227 | 227 | |
| 228 | 228 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
| 231 | 231 | |
| 232 | 232 | void atarigen_eeprom_reset(atarigen_state *state); |
| 233 | 233 | |
| 234 | WRITE16_HANDLER( atarigen_eeprom_enable_w ); | |
| 235 | WRITE16_HANDLER( atarigen_eeprom_w ); | |
| 236 | READ16_HANDLER( atarigen_eeprom_r ); | |
| 237 | READ16_HANDLER( atarigen_eeprom_upper_r ); | |
| 234 | DECLARE_WRITE16_HANDLER( atarigen_eeprom_enable_w ); | |
| 235 | DECLARE_WRITE16_HANDLER( atarigen_eeprom_w ); | |
| 236 | DECLARE_READ16_HANDLER( atarigen_eeprom_r ); | |
| 237 | DECLARE_READ16_HANDLER( atarigen_eeprom_upper_r ); | |
| 238 | 238 | |
| 239 | WRITE32_HANDLER( atarigen_eeprom_enable32_w ); | |
| 240 | WRITE32_HANDLER( atarigen_eeprom32_w ); | |
| 241 | READ32_HANDLER( atarigen_eeprom_upper32_r ); | |
| 239 | DECLARE_WRITE32_HANDLER( atarigen_eeprom_enable32_w ); | |
| 240 | DECLARE_WRITE32_HANDLER( atarigen_eeprom32_w ); | |
| 241 | DECLARE_READ32_HANDLER( atarigen_eeprom_upper32_r ); | |
| 242 | 242 | |
| 243 | 243 | |
| 244 | 244 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
| 248 | 248 | void atarigen_slapstic_init(device_t *device, offs_t base, offs_t mirror, int chipnum); |
| 249 | 249 | void atarigen_slapstic_reset(atarigen_state *state); |
| 250 | 250 | |
| 251 | WRITE16_HANDLER( atarigen_slapstic_w ); | |
| 252 | READ16_HANDLER( atarigen_slapstic_r ); | |
| 251 | DECLARE_WRITE16_HANDLER( atarigen_slapstic_w ); | |
| 252 | DECLARE_READ16_HANDLER( atarigen_slapstic_r ); | |
| 253 | 253 | |
| 254 | 254 | |
| 255 | 255 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
| 259 | 259 | void atarigen_sound_io_reset(device_t *device); |
| 260 | 260 | |
| 261 | 261 | INTERRUPT_GEN( atarigen_6502_irq_gen ); |
| 262 | READ8_HANDLER( atarigen_6502_irq_ack_r ); | |
| 263 | WRITE8_HANDLER( atarigen_6502_irq_ack_w ); | |
| 262 | DECLARE_READ8_HANDLER( atarigen_6502_irq_ack_r ); | |
| 263 | DECLARE_WRITE8_HANDLER( atarigen_6502_irq_ack_w ); | |
| 264 | 264 | |
| 265 | 265 | void atarigen_ym2151_irq_gen(device_t *device, int irq); |
| 266 | 266 | |
| 267 | WRITE16_HANDLER( atarigen_sound_w ); | |
| 268 | READ16_HANDLER( atarigen_sound_r ); | |
| 269 | WRITE16_HANDLER( atarigen_sound_upper_w ); | |
| 270 | READ16_HANDLER( atarigen_sound_upper_r ); | |
| 267 | DECLARE_WRITE16_HANDLER( atarigen_sound_w ); | |
| 268 | DECLARE_READ16_HANDLER( atarigen_sound_r ); | |
| 269 | DECLARE_WRITE16_HANDLER( atarigen_sound_upper_w ); | |
| 270 | DECLARE_READ16_HANDLER( atarigen_sound_upper_r ); | |
| 271 | 271 | |
| 272 | WRITE32_HANDLER( atarigen_sound_upper32_w ); | |
| 273 | READ32_HANDLER( atarigen_sound_upper32_r ); | |
| 272 | DECLARE_WRITE32_HANDLER( atarigen_sound_upper32_w ); | |
| 273 | DECLARE_READ32_HANDLER( atarigen_sound_upper32_r ); | |
| 274 | 274 | |
| 275 | 275 | void atarigen_sound_reset(running_machine &machine); |
| 276 | WRITE16_HANDLER( atarigen_sound_reset_w ); | |
| 277 | WRITE8_HANDLER( atarigen_6502_sound_w ); | |
| 278 | READ8_HANDLER( atarigen_6502_sound_r ); | |
| 276 | DECLARE_WRITE16_HANDLER( atarigen_sound_reset_w ); | |
| 277 | DECLARE_WRITE8_HANDLER( atarigen_6502_sound_w ); | |
| 278 | DECLARE_READ8_HANDLER( atarigen_6502_sound_r ); | |
| 279 | 279 | |
| 280 | 280 | |
| 281 | 281 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
| 309 | 309 | PLAYFIELD/ALPHA MAP HELPERS |
| 310 | 310 | ---------------------------------------------------------------*/ |
| 311 | 311 | |
| 312 | WRITE16_HANDLER( atarigen_alpha_w ); | |
| 313 | WRITE32_HANDLER( atarigen_alpha32_w ); | |
| 314 | WRITE16_HANDLER( atarigen_alpha2_w ); | |
| 312 | DECLARE_WRITE16_HANDLER( atarigen_alpha_w ); | |
| 313 | DECLARE_WRITE32_HANDLER( atarigen_alpha32_w ); | |
| 314 | DECLARE_WRITE16_HANDLER( atarigen_alpha2_w ); | |
| 315 | 315 | void atarigen_set_playfield_latch(atarigen_state *state, int data); |
| 316 | 316 | void atarigen_set_playfield2_latch(atarigen_state *state, int data); |
| 317 | WRITE16_HANDLER( atarigen_playfield_w ); | |
| 318 | WRITE32_HANDLER( atarigen_playfield32_w ); | |
| 319 | WRITE16_HANDLER( atarigen_playfield_large_w ); | |
| 320 | WRITE16_HANDLER( atarigen_playfield_upper_w ); | |
| 321 | WRITE16_HANDLER( atarigen_playfield_dual_upper_w ); | |
| 322 | WRITE16_HANDLER( atarigen_playfield_latched_lsb_w ); | |
| 323 | WRITE16_HANDLER( atarigen_playfield_latched_msb_w ); | |
| 324 | WRITE16_HANDLER( atarigen_playfield2_w ); | |
| 325 | WRITE16_HANDLER( atarigen_playfield2_latched_msb_w ); | |
| 317 | DECLARE_WRITE16_HANDLER( atarigen_playfield_w ); | |
| 318 | DECLARE_WRITE32_HANDLER( atarigen_playfield32_w ); | |
| 319 | DECLARE_WRITE16_HANDLER( atarigen_playfield_large_w ); | |
| 320 | DECLARE_WRITE16_HANDLER( atarigen_playfield_upper_w ); | |
| 321 | DECLARE_WRITE16_HANDLER( atarigen_playfield_dual_upper_w ); | |
| 322 | DECLARE_WRITE16_HANDLER( atarigen_playfield_latched_lsb_w ); | |
| 323 | DECLARE_WRITE16_HANDLER( atarigen_playfield_latched_msb_w ); | |
| 324 | DECLARE_WRITE16_HANDLER( atarigen_playfield2_w ); | |
| 325 | DECLARE_WRITE16_HANDLER( atarigen_playfield2_latched_msb_w ); | |
| 326 | 326 | |
| 327 | 327 | |
| 328 | 328 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
| 332 | 332 | void atarigen_scanline_timer_reset(screen_device &screen, atarigen_scanline_func update_graphics, int frequency); |
| 333 | 333 | int atarigen_get_hblank(screen_device &screen); |
| 334 | 334 | void atarigen_halt_until_hblank_0(screen_device &screen); |
| 335 | WRITE16_HANDLER( atarigen_666_paletteram_w ); | |
| 336 | WRITE16_HANDLER( atarigen_expanded_666_paletteram_w ); | |
| 337 | WRITE32_HANDLER( atarigen_666_paletteram32_w ); | |
| 335 | DECLARE_WRITE16_HANDLER( atarigen_666_paletteram_w ); | |
| 336 | DECLARE_WRITE16_HANDLER( atarigen_expanded_666_paletteram_w ); | |
| 337 | DECLARE_WRITE32_HANDLER( atarigen_666_paletteram32_w ); | |
| 338 | 338 | |
| 339 | 339 | |
| 340 | 340 | /*--------------------------------------------------------------- |
| r17964 | r17965 | |
|---|---|---|
| 1 | READ16_HANDLER( copdxbl_0_r ); | |
| 2 | WRITE16_HANDLER( copdxbl_0_w ); | |
| 1 | DECLARE_READ16_HANDLER( copdxbl_0_r ); | |
| 2 | DECLARE_WRITE16_HANDLER( copdxbl_0_w ); | |
| 3 | 3 | |
| 4 | READ16_HANDLER( heatbrl_mcu_r ); | |
| 5 | WRITE16_HANDLER( heatbrl_mcu_w ); | |
| 6 | READ16_HANDLER( cupsoc_mcu_r ); | |
| 7 | WRITE16_HANDLER( cupsoc_mcu_w ); | |
| 8 | READ16_HANDLER( cupsocs_mcu_r ); | |
| 9 | WRITE16_HANDLER( cupsocs_mcu_w ); | |
| 10 | READ16_HANDLER( godzilla_mcu_r ); | |
| 11 | WRITE16_HANDLER( godzilla_mcu_w ); | |
| 12 | READ16_HANDLER( denjinmk_mcu_r ); | |
| 13 | WRITE16_HANDLER( denjinmk_mcu_w ); | |
| 14 | READ16_HANDLER( grainbow_mcu_r ); | |
| 15 | WRITE16_HANDLER( grainbow_mcu_w ); | |
| 16 | READ16_HANDLER( legionna_mcu_r ); | |
| 17 | WRITE16_HANDLER( legionna_mcu_w ); | |
| 4 | DECLARE_READ16_HANDLER( heatbrl_mcu_r ); | |
| 5 | DECLARE_WRITE16_HANDLER( heatbrl_mcu_w ); | |
| 6 | DECLARE_READ16_HANDLER( cupsoc_mcu_r ); | |
| 7 | DECLARE_WRITE16_HANDLER( cupsoc_mcu_w ); | |
| 8 | DECLARE_READ16_HANDLER( cupsocs_mcu_r ); | |
| 9 | DECLARE_WRITE16_HANDLER( cupsocs_mcu_w ); | |
| 10 | DECLARE_READ16_HANDLER( godzilla_mcu_r ); | |
| 11 | DECLARE_WRITE16_HANDLER( godzilla_mcu_w ); | |
| 12 | DECLARE_READ16_HANDLER( denjinmk_mcu_r ); | |
| 13 | DECLARE_WRITE16_HANDLER( denjinmk_mcu_w ); | |
| 14 | DECLARE_READ16_HANDLER( grainbow_mcu_r ); | |
| 15 | DECLARE_WRITE16_HANDLER( grainbow_mcu_w ); | |
| 16 | DECLARE_READ16_HANDLER( legionna_mcu_r ); | |
| 17 | DECLARE_WRITE16_HANDLER( legionna_mcu_w ); | |
| 18 | 18 | |
| 19 | READ16_HANDLER( raiden2_mcu_r ); | |
| 20 | WRITE16_HANDLER( raiden2_mcu_w ); | |
| 19 | DECLARE_READ16_HANDLER( raiden2_mcu_r ); | |
| 20 | DECLARE_WRITE16_HANDLER( raiden2_mcu_w ); |
| r17964 | r17965 | |
|---|---|---|
| 234 | 234 | TIMER_CALLBACK( scc68070_timer0_callback ); |
| 235 | 235 | TIMER_CALLBACK( scc68070_rx_callback ); |
| 236 | 236 | TIMER_CALLBACK( scc68070_tx_callback ); |
| 237 | READ16_HANDLER( scc68070_periphs_r ); | |
| 238 | WRITE16_HANDLER( scc68070_periphs_w ); | |
| 239 | //READ16_HANDLER( uart_loopback_enable ); | |
| 237 | DECLARE_READ16_HANDLER( scc68070_periphs_r ); | |
| 238 | DECLARE_WRITE16_HANDLER( scc68070_periphs_w ); | |
| 239 | //DECLARE_READ16_HANDLER( uart_loopback_enable ); | |
| 240 | 240 | |
| 241 | 241 | void scc68070_init(running_machine &machine, scc68070_regs_t *scc68070); |
| 242 | 242 | void scc68070_uart_rx(running_machine &machine, scc68070_regs_t *scc68070, UINT8 data); |
| r17964 | r17965 | |
|---|---|---|
| 185 | 185 | }; |
| 186 | 186 | |
| 187 | 187 | // Member functions |
| 188 | READ16_HANDLER( mcd212_r ); | |
| 189 | WRITE16_HANDLER( mcd212_w ); | |
| 188 | DECLARE_READ16_HANDLER( mcd212_r ); | |
| 189 | DECLARE_WRITE16_HANDLER( mcd212_w ); | |
| 190 | 190 | TIMER_CALLBACK( mcd212_perform_scan ); |
| 191 | 191 | VIDEO_START( cdimono1 ); |
| 192 | 192 | SCREEN_UPDATE_RGB32( cdimono1 ); |
| r17964 | r17965 | |
|---|---|---|
| 335 | 335 | VIDEO_START( ygv608 ); |
| 336 | 336 | SCREEN_UPDATE_IND16( ygv608 ); |
| 337 | 337 | |
| 338 | READ16_HANDLER( ygv608_r ); | |
| 339 | WRITE16_HANDLER( ygv608_w ); | |
| 338 | DECLARE_READ16_HANDLER( ygv608_r ); | |
| 339 | DECLARE_WRITE16_HANDLER( ygv608_w ); | |
| 340 | 340 | |
| 341 | 341 | // to be removed |
| 342 | READ16_HANDLER( ygv608_debug_trigger ); | |
| 342 | DECLARE_READ16_HANDLER( ygv608_debug_trigger ); | |
| 343 | 343 | |
| 344 | 344 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 5 | 5 | void K001005_init(running_machine &machine); |
| 6 | 6 | void K001005_preprocess_texture_data(UINT8 *rom, int length, int gticlub); |
| 7 | 7 | |
| 8 | READ32_HANDLER(K001005_r); | |
| 9 | WRITE32_HANDLER(K001005_w); | |
| 8 | DECLARE_READ32_HANDLER(K001005_r); | |
| 9 | DECLARE_WRITE32_HANDLER(K001005_w); | |
| 10 | 10 | |
| 11 | 11 | void K001006_init(running_machine &machine); |
| 12 | READ32_HANDLER(K001006_0_r); | |
| 13 | WRITE32_HANDLER(K001006_0_w); | |
| 14 | READ32_HANDLER(K001006_1_r); | |
| 15 | WRITE32_HANDLER(K001006_1_w); | |
| 12 | DECLARE_READ32_HANDLER(K001006_0_r); | |
| 13 | DECLARE_WRITE32_HANDLER(K001006_0_w); | |
| 14 | DECLARE_READ32_HANDLER(K001006_1_r); | |
| 15 | DECLARE_WRITE32_HANDLER(K001006_1_w); | |
| 16 | 16 | |
| 17 | 17 | VIDEO_START( gticlub ); |
| 18 | 18 | SCREEN_UPDATE_RGB32( gticlub ); |
| r17964 | r17965 | |
|---|---|---|
| 3 | 3 | |
| 4 | 4 | VIDEO_START( pce ); |
| 5 | 5 | SCREEN_UPDATE_IND16( pce ); |
| 6 | WRITE8_HANDLER ( vdc_0_w ); | |
| 7 | WRITE8_HANDLER ( vdc_1_w ); | |
| 8 | READ8_HANDLER ( vdc_0_r ); | |
| 9 | READ8_HANDLER ( vdc_1_r ); | |
| 6 | DECLARE_WRITE8_HANDLER ( vdc_0_w ); | |
| 7 | DECLARE_WRITE8_HANDLER ( vdc_1_w ); | |
| 8 | DECLARE_READ8_HANDLER ( vdc_0_r ); | |
| 9 | DECLARE_READ8_HANDLER ( vdc_1_r ); | |
| 10 | 10 | PALETTE_INIT( vce ); |
| 11 | READ8_HANDLER ( vce_r ); | |
| 12 | WRITE8_HANDLER ( vce_w ); | |
| 13 | WRITE8_HANDLER( vpc_w ); | |
| 14 | READ8_HANDLER( vpc_r ); | |
| 15 | WRITE8_HANDLER( sgx_vdc_w ); | |
| 16 | READ8_HANDLER( sgx_vdc_r ); | |
| 11 | DECLARE_READ8_HANDLER ( vce_r ); | |
| 12 | DECLARE_WRITE8_HANDLER ( vce_w ); | |
| 13 | DECLARE_WRITE8_HANDLER( vpc_w ); | |
| 14 | DECLARE_READ8_HANDLER( vpc_r ); | |
| 15 | DECLARE_WRITE8_HANDLER( sgx_vdc_w ); | |
| 16 | DECLARE_READ8_HANDLER( sgx_vdc_r ); | |
| 17 | 17 | TIMER_DEVICE_CALLBACK( pce_interrupt ); |
| 18 | 18 | TIMER_DEVICE_CALLBACK( sgx_interrupt ); |
| 19 | 19 |
| r17964 | r17965 | |
|---|---|---|
| 111 | 111 | int atarimo_get_yscroll(int map); |
| 112 | 112 | |
| 113 | 113 | /* read/write handlers */ |
| 114 | READ16_HANDLER( atarimo_0_spriteram_r ); | |
| 115 | READ16_HANDLER( atarimo_0_slipram_r ); | |
| 114 | DECLARE_READ16_HANDLER( atarimo_0_spriteram_r ); | |
| 115 | DECLARE_READ16_HANDLER( atarimo_0_slipram_r ); | |
| 116 | 116 | |
| 117 | READ16_HANDLER( atarimo_1_spriteram_r ); | |
| 118 | READ16_HANDLER( atarimo_1_slipram_r ); | |
| 117 | DECLARE_READ16_HANDLER( atarimo_1_spriteram_r ); | |
| 118 | DECLARE_READ16_HANDLER( atarimo_1_slipram_r ); | |
| 119 | 119 | |
| 120 | WRITE16_HANDLER( atarimo_0_spriteram_w ); | |
| 121 | WRITE16_HANDLER( atarimo_0_spriteram_expanded_w ); | |
| 122 | WRITE16_HANDLER( atarimo_0_slipram_w ); | |
| 120 | DECLARE_WRITE16_HANDLER( atarimo_0_spriteram_w ); | |
| 121 | DECLARE_WRITE16_HANDLER( atarimo_0_spriteram_expanded_w ); | |
| 122 | DECLARE_WRITE16_HANDLER( atarimo_0_slipram_w ); | |
| 123 | 123 | |
| 124 | WRITE16_HANDLER( atarimo_1_spriteram_w ); | |
| 125 | WRITE16_HANDLER( atarimo_1_slipram_w ); | |
| 124 | DECLARE_WRITE16_HANDLER( atarimo_1_spriteram_w ); | |
| 125 | DECLARE_WRITE16_HANDLER( atarimo_1_slipram_w ); | |
| 126 | 126 | |
| 127 | 127 | void atarimo_mark_high_palette(bitmap_ind16 &bitmap, UINT16 *pf, UINT16 *mo, int x, int y); |
| 128 | 128 |
| r17964 | r17965 | |
|---|---|---|
| 36 | 36 | void segaic16_tilemap_set_rowscroll(running_machine &machine, int which, int enable); |
| 37 | 37 | void segaic16_tilemap_set_colscroll(running_machine &machine, int which, int enable); |
| 38 | 38 | |
| 39 | WRITE16_HANDLER( segaic16_tileram_0_w ); | |
| 40 | WRITE16_HANDLER( segaic16_textram_0_w ); | |
| 39 | DECLARE_WRITE16_HANDLER( segaic16_tileram_0_w ); | |
| 40 | DECLARE_WRITE16_HANDLER( segaic16_textram_0_w ); | |
| 41 | 41 | |
| 42 | 42 | /* road systems */ |
| 43 | 43 | #define SEGAIC16_MAX_ROADS 1 |
| r17964 | r17965 | |
| 52 | 52 | |
| 53 | 53 | void segaic16_road_init(running_machine &machine, int which, int type, int colorbase1, int colorbase2, int colorbase3, int xoffs); |
| 54 | 54 | void segaic16_road_draw(int which, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority); |
| 55 | READ16_HANDLER( segaic16_road_control_0_r ); | |
| 56 | WRITE16_HANDLER( segaic16_road_control_0_w ); | |
| 55 | DECLARE_READ16_HANDLER( segaic16_road_control_0_r ); | |
| 56 | DECLARE_WRITE16_HANDLER( segaic16_road_control_0_w ); | |
| 57 | 57 | |
| 58 | 58 | /* rotation systems */ |
| 59 | 59 | #define SEGAIC16_MAX_ROTATE 1 |
| r17964 | r17965 | |
| 62 | 62 | |
| 63 | 63 | void segaic16_rotate_init(running_machine &machine, int which, int type, int colorbase); |
| 64 | 64 | void segaic16_rotate_draw(running_machine &machine, int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind16 &srcbitmap); |
| 65 | READ16_HANDLER( segaic16_rotate_control_0_r ); | |
| 65 | DECLARE_READ16_HANDLER( segaic16_rotate_control_0_r ); | |
| 66 | 66 | |
| 67 | 67 | /************************************* |
| 68 | 68 | * |
| r17964 | r17965 | |
|---|---|---|
| 134 | 134 | extern gtia_struct gtia; |
| 135 | 135 | |
| 136 | 136 | void gtia_init(running_machine &machine, const gtia_interface *intf); |
| 137 | READ8_HANDLER( atari_gtia_r ); | |
| 138 | WRITE8_HANDLER( atari_gtia_w ); | |
| 137 | DECLARE_READ8_HANDLER( atari_gtia_r ); | |
| 138 | DECLARE_WRITE8_HANDLER( atari_gtia_w ); | |
| 139 | 139 | |
| 140 | 140 | ANTIC_RENDERER( gtia_mode_1_32 ); |
| 141 | 141 | ANTIC_RENDERER( gtia_mode_1_40 ); |
| r17964 | r17965 | |
|---|---|---|
| 2 | 2 | #define __AVGDVG__ |
| 3 | 3 | |
| 4 | 4 | CUSTOM_INPUT( avgdvg_done_r ); |
| 5 | WRITE8_HANDLER( avgdvg_go_w ); | |
| 6 | WRITE8_HANDLER( avgdvg_reset_w ); | |
| 7 | WRITE16_HANDLER( avgdvg_go_word_w ); | |
| 8 | WRITE16_HANDLER( avgdvg_reset_word_w ); | |
| 5 | DECLARE_WRITE8_HANDLER( avgdvg_go_w ); | |
| 6 | DECLARE_WRITE8_HANDLER( avgdvg_reset_w ); | |
| 7 | DECLARE_WRITE16_HANDLER( avgdvg_go_word_w ); | |
| 8 | DECLARE_WRITE16_HANDLER( avgdvg_reset_word_w ); | |
| 9 | 9 | |
| 10 | 10 | /* Tempest and Quantum use this capability */ |
| 11 | 11 | void avg_set_flip_x(int flip); |
| r17964 | r17965 | |
|---|---|---|
| 1479 | 1479 | WRITE16_HANDLER( K053246_word_w ) |
| 1480 | 1480 | { |
| 1481 | 1481 | if (ACCESSING_BITS_8_15) |
| 1482 | K053246_w(space, offset<<1,(data >> 8) & 0xff); | |
| 1482 | K053246_w(space, offset<<1,(data >> 8) & 0xff, (mem_mask >> 8) & 0xff); | |
| 1483 | 1483 | if (ACCESSING_BITS_0_7) |
| 1484 | K053246_w(space, (offset<<1) + 1,data & 0xff); | |
| 1484 | K053246_w(space, (offset<<1) + 1,data & 0xff, mem_mask & 0xff); | |
| 1485 | 1485 | } |
| 1486 | 1486 | |
| 1487 | 1487 | WRITE32_HANDLER( K053246_long_w ) |
| r17964 | r17965 | |
| 1710 | 1710 | |
| 1711 | 1711 | READ16_HANDLER( K054000_lsb_r ) |
| 1712 | 1712 | { |
| 1713 | return K054000_r(space, offset); | |
| 1713 | return K054000_r(space, offset, mem_mask & 0xff); | |
| 1714 | 1714 | } |
| 1715 | 1715 | |
| 1716 | 1716 | WRITE16_HANDLER( K054000_lsb_w ) |
| 1717 | 1717 | { |
| 1718 | 1718 | if (ACCESSING_BITS_0_7) |
| 1719 | K054000_w(space, offset, data & 0xff); | |
| 1719 | K054000_w(space, offset, data & 0xff, mem_mask & 0xff); | |
| 1720 | 1720 | } |
| 1721 | 1721 | |
| 1722 | 1722 |
| r17964 | r17965 | |
|---|---|---|
| 5 | 5 | |
| 6 | 6 | void K055673_vh_start(running_machine &machine, const char *gfx_memory_region, int alt_layout, int dx, int dy, |
| 7 | 7 | void (*callback)(running_machine &machine, int *code,int *color,int *priority)); |
| 8 | READ16_HANDLER( K055673_rom_word_r ); | |
| 9 | READ16_HANDLER( K055673_GX6bpp_rom_word_r ); | |
| 8 | DECLARE_READ16_HANDLER( K055673_rom_word_r ); | |
| 9 | DECLARE_READ16_HANDLER( K055673_GX6bpp_rom_word_r ); | |
| 10 | 10 | |
| 11 | 11 | /* |
| 12 | 12 | Callback procedures for non-standard shadows: |
| r17964 | r17965 | |
| 18 | 18 | #define K053247_CUSTOMSHADOW 0x20000000 |
| 19 | 19 | #define K053247_SHDSHIFT 20 |
| 20 | 20 | |
| 21 | READ16_HANDLER( K053247_word_r ); | |
| 22 | WRITE16_HANDLER( K053247_word_w ); | |
| 23 | READ32_HANDLER( K053247_long_r ); | |
| 24 | WRITE32_HANDLER( K053247_long_w ); | |
| 25 | WRITE16_HANDLER( K053247_reg_word_w ); // "OBJSET2" registers | |
| 26 | WRITE32_HANDLER( K053247_reg_long_w ); | |
| 21 | DECLARE_READ16_HANDLER( K053247_word_r ); | |
| 22 | DECLARE_WRITE16_HANDLER( K053247_word_w ); | |
| 23 | DECLARE_READ32_HANDLER( K053247_long_r ); | |
| 24 | DECLARE_WRITE32_HANDLER( K053247_long_w ); | |
| 25 | DECLARE_WRITE16_HANDLER( K053247_reg_word_w ); // "OBJSET2" registers | |
| 26 | DECLARE_WRITE32_HANDLER( K053247_reg_long_w ); | |
| 27 | 27 | |
| 28 | 28 | int K053247_read_register(int regnum); |
| 29 | 29 | void K053247_set_SpriteOffset(int offsx, int offsy); |
| 30 | 30 | void K053247_export_config(UINT16 **ram, gfx_element **gfx, void (**callback)(running_machine &, int *, int *, int *), int *dx, int *dy); |
| 31 | 31 | |
| 32 | WRITE16_HANDLER( K053246_word_w ); | |
| 33 | WRITE32_HANDLER( K053246_long_w ); | |
| 32 | DECLARE_WRITE16_HANDLER( K053246_word_w ); | |
| 33 | DECLARE_WRITE32_HANDLER( K053246_long_w ); | |
| 34 | 34 | void K053246_set_OBJCHA_line(int state); |
| 35 | 35 | int K053246_is_IRQ_enabled(void); |
| 36 | 36 | int K053246_read_register(int regnum); |
| r17964 | r17965 | |
| 47 | 47 | when some palette index changes. If ALL_TILEMAPS is too expensive, use |
| 48 | 48 | K053251_set_tilemaps() to indicate which tilemap is associated with each index. |
| 49 | 49 | */ |
| 50 | WRITE8_HANDLER( K053251_w ); | |
| 51 | WRITE16_HANDLER( K053251_lsb_w ); | |
| 52 | WRITE16_HANDLER( K053251_msb_w ); | |
| 50 | DECLARE_WRITE8_HANDLER( K053251_w ); | |
| 51 | DECLARE_WRITE16_HANDLER( K053251_lsb_w ); | |
| 52 | DECLARE_WRITE16_HANDLER( K053251_msb_w ); | |
| 53 | 53 | enum { K053251_CI0=0,K053251_CI1,K053251_CI2,K053251_CI3,K053251_CI4 }; |
| 54 | 54 | int K053251_get_priority(int ci); |
| 55 | 55 | int K053251_get_palette_index(int ci); |
| r17964 | r17965 | |
| 57 | 57 | void K053251_vh_start(running_machine &machine); |
| 58 | 58 | |
| 59 | 59 | |
| 60 | WRITE16_HANDLER( K054000_lsb_w ); | |
| 61 | READ16_HANDLER( K054000_lsb_r ); | |
| 60 | DECLARE_WRITE16_HANDLER( K054000_lsb_w ); | |
| 61 | DECLARE_READ16_HANDLER( K054000_lsb_r ); | |
| 62 | 62 | |
| 63 | 63 | |
| 64 | 64 | #define K056382_DRAW_FLAG_FORCE_XYSCROLL 0x00800000 |
| r17964 | r17965 | |
| 67 | 67 | int (*scrolld)[4][2], |
| 68 | 68 | void (*callback)(running_machine &machine, int layer, int *code, int *color, int *flags), |
| 69 | 69 | int djmain_hack); |
| 70 | READ16_HANDLER( K056832_ram_word_r ); | |
| 71 | WRITE16_HANDLER( K056832_ram_word_w ); | |
| 72 | READ32_HANDLER( K056832_5bpp_rom_long_r ); | |
| 73 | READ32_HANDLER( K056832_6bpp_rom_long_r ); | |
| 74 | READ16_HANDLER( K056832_mw_rom_word_r ); | |
| 75 | WRITE16_HANDLER( K056832_word_w ); // "VRAM" registers | |
| 76 | WRITE16_HANDLER( K056832_b_word_w ); | |
| 70 | DECLARE_READ16_HANDLER( K056832_ram_word_r ); | |
| 71 | DECLARE_WRITE16_HANDLER( K056832_ram_word_w ); | |
| 72 | DECLARE_READ32_HANDLER( K056832_5bpp_rom_long_r ); | |
| 73 | DECLARE_READ32_HANDLER( K056832_6bpp_rom_long_r ); | |
| 74 | DECLARE_READ16_HANDLER( K056832_mw_rom_word_r ); | |
| 75 | DECLARE_WRITE16_HANDLER( K056832_word_w ); // "VRAM" registers | |
| 76 | DECLARE_WRITE16_HANDLER( K056832_b_word_w ); | |
| 77 | 77 | void K056832_mark_plane_dirty(int num); |
| 78 | 78 | void K056832_MarkAllTilemapsDirty(void); |
| 79 | 79 | void K056832_tilemap_draw(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, int num, UINT32 flags, UINT32 priority); |
| r17964 | r17965 | |
| 81 | 81 | void K056832_set_LayerOffset(int layer, int offsx, int offsy); |
| 82 | 82 | void K056832_set_UpdateMode(int mode); |
| 83 | 83 | |
| 84 | READ32_HANDLER( K056832_ram_long_r ); | |
| 85 | WRITE32_HANDLER( K056832_ram_long_w ); | |
| 86 | WRITE32_HANDLER( K056832_long_w ); | |
| 87 | WRITE32_HANDLER( K056832_b_long_w ); | |
| 84 | DECLARE_READ32_HANDLER( K056832_ram_long_r ); | |
| 85 | DECLARE_WRITE32_HANDLER( K056832_ram_long_w ); | |
| 86 | DECLARE_WRITE32_HANDLER( K056832_long_w ); | |
| 87 | DECLARE_WRITE32_HANDLER( K056832_b_long_w ); | |
| 88 | 88 | |
| 89 | 89 | /* bit depths for the 56832 */ |
| 90 | 90 | #define K056832_BPP_4 0 |
| r17964 | r17965 | |
| 97 | 97 | |
| 98 | 98 | void K055555_vh_start(running_machine &machine); // "PCU2" |
| 99 | 99 | void K055555_write_reg(UINT8 regnum, UINT8 regdat); |
| 100 | WRITE16_HANDLER( K055555_word_w ); | |
| 101 | WRITE32_HANDLER( K055555_long_w ); | |
| 100 | DECLARE_WRITE16_HANDLER( K055555_word_w ); | |
| 101 | DECLARE_WRITE32_HANDLER( K055555_long_w ); | |
| 102 | 102 | int K055555_read_register(int regnum); |
| 103 | 103 | int K055555_get_palette_index(int idx); |
| 104 | 104 | |
| r17964 | r17965 | |
| 169 | 169 | |
| 170 | 170 | /* K054338 mixer/alpha blender */ |
| 171 | 171 | void K054338_vh_start(running_machine &machine); |
| 172 | WRITE16_HANDLER( K054338_word_w ); // "CLCT" registers | |
| 173 | WRITE32_HANDLER( K054338_long_w ); | |
| 172 | DECLARE_WRITE16_HANDLER( K054338_word_w ); // "CLCT" registers | |
| 173 | DECLARE_WRITE32_HANDLER( K054338_long_w ); | |
| 174 | 174 | int K054338_read_register(int reg); |
| 175 | 175 | void K054338_update_all_shadows(running_machine &machine, int rushingheroes_hack); // called at the beginning of SCREEN_UPDATE() |
| 176 | 176 | void K054338_fill_solid_bg(bitmap_ind16 &bitmap); // solid backcolor fill |
| r17964 | r17965 | |
| 194 | 194 | #define K338_CTL_CLIPSL 0x20 |
| 195 | 195 | |
| 196 | 196 | // K053252 CRT and interrupt control unit |
| 197 | WRITE16_HANDLER( K053252_word_w ); | |
| 197 | DECLARE_WRITE16_HANDLER( K053252_word_w ); | |
| 198 | 198 |
| r17964 | r17965 | |
|---|---|---|
| 820 | 820 | |
| 821 | 821 | #if 0 // to be moved in the specific drivers! |
| 822 | 822 | /* special handling for the chips sharing address space */ |
| 823 | READ8_HANDLER( k052109_051960_r ); | |
| 824 | WRITE8_HANDLER( k052109_051960_w ); | |
| 823 | DECLARE_READ8_HANDLER( k052109_051960_r ); | |
| 824 | DECLARE_WRITE8_HANDLER( k052109_051960_w ); | |
| 825 | 825 | #endif |
| 826 | 826 | |
| 827 | 827 |
| r17964 | r17965 | |
|---|---|---|
| 41 | 41 | |
| 42 | 42 | /*----------- defined in machine/copsnrob.c -----------*/ |
| 43 | 43 | |
| 44 | READ8_HANDLER( copsnrob_gun_position_r ); | |
| 44 | DECLARE_READ8_HANDLER( copsnrob_gun_position_r ); | |
| 45 | 45 | |
| 46 | 46 | |
| 47 | 47 | /*----------- defined in video/copsnrob.c -----------*/ |
| r17964 | r17965 | |
|---|---|---|
| 59 | 59 | |
| 60 | 60 | SCREEN_UPDATE_IND16( galpani2 ); |
| 61 | 61 | |
| 62 | WRITE16_HANDLER( galpani2_palette_0_w ); | |
| 63 | WRITE16_HANDLER( galpani2_palette_1_w ); | |
| 62 | DECLARE_WRITE16_HANDLER( galpani2_palette_0_w ); | |
| 63 | DECLARE_WRITE16_HANDLER( galpani2_palette_1_w ); | |
| 64 | 64 | |
| 65 | WRITE16_HANDLER( galpani2_bg8_0_w ); | |
| 66 | WRITE16_HANDLER( galpani2_bg8_1_w ); | |
| 65 | DECLARE_WRITE16_HANDLER( galpani2_bg8_0_w ); | |
| 66 | DECLARE_WRITE16_HANDLER( galpani2_bg8_1_w ); | |
| 67 | 67 | |
| 68 | WRITE16_HANDLER( galpani2_bg15_w ); | |
| 68 | DECLARE_WRITE16_HANDLER( galpani2_bg15_w ); |
| r17964 | r17965 | |
|---|---|---|
| 69 | 69 | |
| 70 | 70 | |
| 71 | 71 | /* These handlers are needed by megaplay.c */ |
| 72 | extern READ16_HANDLER( megadriv_68k_io_read ); | |
| 73 | extern WRITE16_HANDLER( megadriv_68k_io_write ); | |
| 72 | extern DECLARE_READ16_HANDLER( megadriv_68k_io_read ); | |
| 73 | extern DECLARE_WRITE16_HANDLER( megadriv_68k_io_write ); | |
| 74 | 74 | |
| 75 | 75 | /* These handlers are needed by puckpkmn.c for his memory map */ |
| 76 | 76 | extern DECLARE_READ8_DEVICE_HANDLER( megadriv_68k_YM2612_read); |
| r17964 | r17965 | |
| 472 | 472 | /*----------- defined in drivers/megadriv.c -----------*/ |
| 473 | 473 | |
| 474 | 474 | /* These are needed to handle J-Cart inputs */ |
| 475 | extern WRITE16_HANDLER( jcart_ctrl_w ); | |
| 476 | extern READ16_HANDLER( jcart_ctrl_r ); | |
| 475 | extern DECLARE_WRITE16_HANDLER( jcart_ctrl_w ); | |
| 476 | extern DECLARE_READ16_HANDLER( jcart_ctrl_r ); | |
| 477 | 477 | |
| 478 | 478 | /* machine/megavdp.c */ |
| 479 | 479 | extern UINT16 (*vdp_get_word_from_68k_mem)(running_machine &machine, UINT32 source, address_space* space); |
| r17964 | r17965 | |
|---|---|---|
| 447 | 447 | |
| 448 | 448 | |
| 449 | 449 | |
| 450 | READ16_HANDLER( amiga_cia_r ); | |
| 451 | WRITE16_HANDLER( amiga_cia_w ); | |
| 450 | DECLARE_READ16_HANDLER( amiga_cia_r ); | |
| 451 | DECLARE_WRITE16_HANDLER( amiga_cia_w ); | |
| 452 | 452 | |
| 453 | READ16_HANDLER( amiga_custom_r ); | |
| 454 | WRITE16_HANDLER( amiga_custom_w ); | |
| 453 | DECLARE_READ16_HANDLER( amiga_custom_r ); | |
| 454 | DECLARE_WRITE16_HANDLER( amiga_custom_w ); | |
| 455 | 455 | |
| 456 | 456 | void amiga_serial_in_w(running_machine &machine, UINT16 data); |
| 457 | 457 | attotime amiga_get_serial_char_period(running_machine &machine); |
| 458 | 458 | |
| 459 | 459 | void amiga_add_autoconfig(running_machine &machine, const amiga_autoconfig_device *device); |
| 460 | READ16_HANDLER( amiga_autoconfig_r ); | |
| 461 | WRITE16_HANDLER( amiga_autoconfig_w ); | |
| 460 | DECLARE_READ16_HANDLER( amiga_autoconfig_r ); | |
| 461 | DECLARE_WRITE16_HANDLER( amiga_autoconfig_w ); | |
| 462 | 462 | |
| 463 | 463 | void amiga_cia_0_irq(device_t *device, int state); |
| 464 | 464 | void amiga_cia_1_irq(device_t *device, int state); |
| r17964 | r17965 | |
|---|---|---|
| 152 | 152 | SCREEN_UPDATE_RGB32( nslasher ); |
| 153 | 153 | |
| 154 | 154 | |
| 155 | WRITE32_HANDLER( deco32_pf1_data_w ); | |
| 156 | WRITE32_HANDLER( deco32_pf2_data_w ); | |
| 157 | WRITE32_HANDLER( deco32_pf3_data_w ); | |
| 158 | WRITE32_HANDLER( deco32_pf4_data_w ); | |
| 155 | DECLARE_WRITE32_HANDLER( deco32_pf1_data_w ); | |
| 156 | DECLARE_WRITE32_HANDLER( deco32_pf2_data_w ); | |
| 157 | DECLARE_WRITE32_HANDLER( deco32_pf3_data_w ); | |
| 158 | DECLARE_WRITE32_HANDLER( deco32_pf4_data_w ); | |
| 159 | 159 | |
| 160 | 160 |
| r17964 | r17965 | |
|---|---|---|
| 70 | 70 | |
| 71 | 71 | SCREEN_UPDATE_RGB32( midzeus2 ); |
| 72 | 72 | |
| 73 | READ32_HANDLER( zeus2_r ); | |
| 74 | WRITE32_HANDLER( zeus2_w ); | |
| 73 | DECLARE_READ32_HANDLER( zeus2_r ); | |
| 74 | DECLARE_WRITE32_HANDLER( zeus2_w ); | |
| 75 | 75 |
| r17964 | r17965 | |
|---|---|---|
| 68 | 68 | |
| 69 | 69 | |
| 70 | 70 | |
| 71 | WRITE8_HANDLER( fastfred_videoram_w ); | |
| 72 | WRITE8_HANDLER( fastfred_attributes_w ); | |
| 73 | WRITE8_HANDLER( fastfred_charbank1_w ); | |
| 74 | WRITE8_HANDLER( fastfred_charbank2_w ); | |
| 75 | WRITE8_HANDLER( fastfred_colorbank1_w ); | |
| 76 | WRITE8_HANDLER( fastfred_colorbank2_w ); | |
| 77 | WRITE8_HANDLER( fastfred_flip_screen_x_w ); | |
| 78 | WRITE8_HANDLER( fastfred_flip_screen_y_w ); | |
| 71 | DECLARE_WRITE8_HANDLER( fastfred_videoram_w ); | |
| 72 | DECLARE_WRITE8_HANDLER( fastfred_attributes_w ); | |
| 73 | DECLARE_WRITE8_HANDLER( fastfred_charbank1_w ); | |
| 74 | DECLARE_WRITE8_HANDLER( fastfred_charbank2_w ); | |
| 75 | DECLARE_WRITE8_HANDLER( fastfred_colorbank1_w ); | |
| 76 | DECLARE_WRITE8_HANDLER( fastfred_colorbank2_w ); | |
| 77 | DECLARE_WRITE8_HANDLER( fastfred_flip_screen_x_w ); | |
| 78 | DECLARE_WRITE8_HANDLER( fastfred_flip_screen_y_w ); | |
| 79 | 79 | SCREEN_UPDATE_IND16( fastfred ); |
| 80 | 80 | |
| 81 | 81 | |
| 82 | 82 | SCREEN_UPDATE_IND16( imago ); |
| 83 | WRITE8_HANDLER( imago_fg_videoram_w ); | |
| 84 | WRITE8_HANDLER( imago_charbank_w ); | |
| 83 | DECLARE_WRITE8_HANDLER( imago_fg_videoram_w ); | |
| 84 | DECLARE_WRITE8_HANDLER( imago_charbank_w ); |
| r17964 | r17965 | |
|---|---|---|
| 30 | 30 | /*----------- defined in video/galpanic.c -----------*/ |
| 31 | 31 | |
| 32 | 32 | |
| 33 | WRITE16_HANDLER( galpanic_bgvideoram_w ); | |
| 34 | WRITE16_HANDLER( galpanic_paletteram_w ); | |
| 33 | DECLARE_WRITE16_HANDLER( galpanic_bgvideoram_w ); | |
| 34 | DECLARE_WRITE16_HANDLER( galpanic_paletteram_w ); | |
| 35 | 35 | |
| 36 | 36 | SCREEN_UPDATE_IND16( galpanic ); |
| 37 | 37 | SCREEN_UPDATE_IND16( comad ); |
| r17964 | r17965 | |
|---|---|---|
| 25 | 25 | |
| 26 | 26 | // mame/machine/psx.c |
| 27 | 27 | extern void psx_driver_init( running_machine &machine ); |
| 28 | WRITE32_HANDLER( psx_com_delay_w ); | |
| 29 | READ32_HANDLER( psx_com_delay_r ); | |
| 28 | DECLARE_WRITE32_HANDLER( psx_com_delay_w ); | |
| 29 | DECLARE_READ32_HANDLER( psx_com_delay_r ); | |
| 30 | 30 | extern void psx_irq_set( running_machine &, UINT32 ); |
| 31 | 31 | extern void psx_sio_install_handler( running_machine &, int, psx_sio_handler ); |
| 32 | 32 | extern void psx_sio_input( running_machine &, int, int, int ); |
| 33 | 33 | |
| 34 | READ32_HANDLER( psx_gpu_r ); | |
| 35 | WRITE32_HANDLER( psx_gpu_w ); | |
| 34 | DECLARE_READ32_HANDLER( psx_gpu_r ); | |
| 35 | DECLARE_WRITE32_HANDLER( psx_gpu_w ); | |
| 36 | 36 | extern void psx_lightgun_set( running_machine &, int, int ); |
| 37 | 37 | |
| 38 | 38 | // emu/video/psx.c |
| r17964 | r17965 | |
|---|---|---|
| 35 | 35 | |
| 36 | 36 | /*----------- defined in video/gauntlet.c -----------*/ |
| 37 | 37 | |
| 38 | WRITE16_HANDLER( gauntlet_xscroll_w ); | |
| 39 | WRITE16_HANDLER( gauntlet_yscroll_w ); | |
| 38 | DECLARE_WRITE16_HANDLER( gauntlet_xscroll_w ); | |
| 39 | DECLARE_WRITE16_HANDLER( gauntlet_yscroll_w ); | |
| 40 | 40 | |
| 41 | 41 | |
| 42 | 42 | SCREEN_UPDATE_IND16( gauntlet ); |
| r17964 | r17965 | |
|---|---|---|
| 38 | 38 | |
| 39 | 39 | /*----------- defined in video/actfancr.c -----------*/ |
| 40 | 40 | |
| 41 | WRITE8_HANDLER( actfancr_pf1_data_w ); | |
| 42 | READ8_HANDLER( actfancr_pf1_data_r ); | |
| 43 | WRITE8_HANDLER( actfancr_pf1_control_w ); | |
| 44 | WRITE8_HANDLER( actfancr_pf2_data_w ); | |
| 45 | READ8_HANDLER( actfancr_pf2_data_r ); | |
| 46 | WRITE8_HANDLER( actfancr_pf2_control_w ); | |
| 41 | DECLARE_WRITE8_HANDLER( actfancr_pf1_data_w ); | |
| 42 | DECLARE_READ8_HANDLER( actfancr_pf1_data_r ); | |
| 43 | DECLARE_WRITE8_HANDLER( actfancr_pf1_control_w ); | |
| 44 | DECLARE_WRITE8_HANDLER( actfancr_pf2_data_w ); | |
| 45 | DECLARE_READ8_HANDLER( actfancr_pf2_data_r ); | |
| 46 | DECLARE_WRITE8_HANDLER( actfancr_pf2_control_w ); | |
| 47 | 47 | |
| 48 | 48 | |
| 49 | 49 | SCREEN_UPDATE_IND16( actfancr ); |
| r17964 | r17965 | |
|---|---|---|
| 34 | 34 | DECLARE_WRITE8_DEVICE_HANDLER( avalnche_attract_enable_w ); |
| 35 | 35 | DECLARE_WRITE8_DEVICE_HANDLER( avalnche_audio_w ); |
| 36 | 36 | |
| 37 | WRITE8_HANDLER( catch_audio_w ); | |
| 37 | DECLARE_WRITE8_HANDLER( catch_audio_w ); |
| r17964 | r17965 | |
|---|---|---|
| 99 | 99 | |
| 100 | 100 | /*----------- defined in machine/slikshot.c -----------*/ |
| 101 | 101 | |
| 102 | READ8_HANDLER( slikz80_port_r ); | |
| 103 | WRITE8_HANDLER( slikz80_port_w ); | |
| 102 | DECLARE_READ8_HANDLER( slikz80_port_r ); | |
| 103 | DECLARE_WRITE8_HANDLER( slikz80_port_w ); | |
| 104 | 104 | |
| 105 | READ8_HANDLER( slikshot_z80_r ); | |
| 106 | READ8_HANDLER( slikshot_z80_control_r ); | |
| 107 | WRITE8_HANDLER( slikshot_z80_control_w ); | |
| 105 | DECLARE_READ8_HANDLER( slikshot_z80_r ); | |
| 106 | DECLARE_READ8_HANDLER( slikshot_z80_control_r ); | |
| 107 | DECLARE_WRITE8_HANDLER( slikshot_z80_control_w ); | |
| 108 | 108 | |
| 109 | 109 | |
| 110 | 110 | SCREEN_UPDATE_RGB32( slikshot ); |
| r17964 | r17965 | |
|---|---|---|
| 100 | 100 | |
| 101 | 101 | /*----------- defined in machine/dc.c -----------*/ |
| 102 | 102 | |
| 103 | READ64_HANDLER( pvr_ctrl_r ); | |
| 104 | WRITE64_HANDLER( pvr_ctrl_w ); | |
| 103 | DECLARE_READ64_HANDLER( pvr_ctrl_r ); | |
| 104 | DECLARE_WRITE64_HANDLER( pvr_ctrl_w ); | |
| 105 | 105 | |
| 106 | READ64_HANDLER( dc_sysctrl_r ); | |
| 107 | WRITE64_HANDLER( dc_sysctrl_w ); | |
| 108 | READ64_HANDLER( dc_gdrom_r ); | |
| 109 | WRITE64_HANDLER( dc_gdrom_w ); | |
| 110 | READ64_HANDLER( dc_g1_ctrl_r ); | |
| 111 | WRITE64_HANDLER( dc_g1_ctrl_w ); | |
| 112 | READ64_HANDLER( dc_g2_ctrl_r ); | |
| 113 | WRITE64_HANDLER( dc_g2_ctrl_w ); | |
| 114 | READ64_HANDLER( dc_modem_r ); | |
| 115 | WRITE64_HANDLER( dc_modem_w ); | |
| 116 | READ64_HANDLER( dc_rtc_r ); | |
| 117 | WRITE64_HANDLER( dc_rtc_w ); | |
| 106 | DECLARE_READ64_HANDLER( dc_sysctrl_r ); | |
| 107 | DECLARE_WRITE64_HANDLER( dc_sysctrl_w ); | |
| 108 | DECLARE_READ64_HANDLER( dc_gdrom_r ); | |
| 109 | DECLARE_WRITE64_HANDLER( dc_gdrom_w ); | |
| 110 | DECLARE_READ64_HANDLER( dc_g1_ctrl_r ); | |
| 111 | DECLARE_WRITE64_HANDLER( dc_g1_ctrl_w ); | |
| 112 | DECLARE_READ64_HANDLER( dc_g2_ctrl_r ); | |
| 113 | DECLARE_WRITE64_HANDLER( dc_g2_ctrl_w ); | |
| 114 | DECLARE_READ64_HANDLER( dc_modem_r ); | |
| 115 | DECLARE_WRITE64_HANDLER( dc_modem_w ); | |
| 116 | DECLARE_READ64_HANDLER( dc_rtc_r ); | |
| 117 | DECLARE_WRITE64_HANDLER( dc_rtc_w ); | |
| 118 | 118 | DECLARE_READ64_DEVICE_HANDLER( dc_aica_reg_r ); |
| 119 | 119 | DECLARE_WRITE64_DEVICE_HANDLER( dc_aica_reg_w ); |
| 120 | 120 | |
| r17964 | r17965 | |
| 296 | 296 | extern UINT64 *pvr2_framebuffer_ram; |
| 297 | 297 | extern UINT64 *elan_ram; |
| 298 | 298 | |
| 299 | READ64_HANDLER( pvr_ta_r ); | |
| 300 | WRITE64_HANDLER( pvr_ta_w ); | |
| 301 | READ64_HANDLER( pvr2_ta_r ); | |
| 302 | WRITE64_HANDLER( pvr2_ta_w ); | |
| 303 | READ64_HANDLER( pvrs_ta_r ); | |
| 304 | WRITE64_HANDLER( pvrs_ta_w ); | |
| 305 | READ32_HANDLER( elan_regs_r ); | |
| 306 | WRITE32_HANDLER( elan_regs_w ); | |
| 307 | WRITE64_HANDLER( ta_fifo_poly_w ); | |
| 308 | WRITE64_HANDLER( ta_fifo_yuv_w ); | |
| 299 | DECLARE_READ64_HANDLER( pvr_ta_r ); | |
| 300 | DECLARE_WRITE64_HANDLER( pvr_ta_w ); | |
| 301 | DECLARE_READ64_HANDLER( pvr2_ta_r ); | |
| 302 | DECLARE_WRITE64_HANDLER( pvr2_ta_w ); | |
| 303 | DECLARE_READ64_HANDLER( pvrs_ta_r ); | |
| 304 | DECLARE_WRITE64_HANDLER( pvrs_ta_w ); | |
| 305 | DECLARE_READ32_HANDLER( elan_regs_r ); | |
| 306 | DECLARE_WRITE32_HANDLER( elan_regs_w ); | |
| 307 | DECLARE_WRITE64_HANDLER( ta_fifo_poly_w ); | |
| 308 | DECLARE_WRITE64_HANDLER( ta_fifo_yuv_w ); | |
| 309 | 309 | |
| 310 | 310 | SCREEN_UPDATE_RGB32(dc); |
| 311 | 311 |
| r17964 | r17965 | |
|---|---|---|
| 66 | 66 | |
| 67 | 67 | |
| 68 | 68 | |
| 69 | READ8_HANDLER( triplep_pip_r ); | |
| 70 | READ8_HANDLER( triplep_pap_r ); | |
| 69 | DECLARE_READ8_HANDLER( triplep_pip_r ); | |
| 70 | DECLARE_READ8_HANDLER( triplep_pap_r ); | |
| 71 | 71 | |
| 72 | READ8_HANDLER( hunchbks_mirror_r ); | |
| 73 | WRITE8_HANDLER( hunchbks_mirror_w ); | |
| 72 | DECLARE_READ8_HANDLER( hunchbks_mirror_r ); | |
| 73 | DECLARE_WRITE8_HANDLER( hunchbks_mirror_w ); | |
| 74 | 74 | |
| 75 | 75 | DECLARE_READ8_DEVICE_HANDLER( scramble_protection_r ); |
| 76 | 76 | DECLARE_WRITE8_DEVICE_HANDLER( scramble_protection_w ); |
| r17964 | r17965 | |
|---|---|---|
| 7 | 7 | |
| 8 | 8 | /*----------- defined in audio/targ.c -----------*/ |
| 9 | 9 | |
| 10 | WRITE8_HANDLER( targ_audio_1_w ); | |
| 11 | WRITE8_HANDLER( targ_audio_2_w ); | |
| 12 | WRITE8_HANDLER( spectar_audio_2_w ); | |
| 10 | DECLARE_WRITE8_HANDLER( targ_audio_1_w ); | |
| 11 | DECLARE_WRITE8_HANDLER( targ_audio_2_w ); | |
| 12 | DECLARE_WRITE8_HANDLER( spectar_audio_2_w ); | |
| 13 | 13 | |
| 14 | 14 | MACHINE_CONFIG_EXTERN( spectar_audio ); |
| 15 | 15 | MACHINE_CONFIG_EXTERN( targ_audio ); |
| r17964 | r17965 | |
|---|---|---|
| 25 | 25 | |
| 26 | 26 | /*----------- defined in video/skullxbo.c -----------*/ |
| 27 | 27 | |
| 28 | WRITE16_HANDLER( skullxbo_playfieldlatch_w ); | |
| 29 | WRITE16_HANDLER( skullxbo_xscroll_w ); | |
| 30 | WRITE16_HANDLER( skullxbo_yscroll_w ); | |
| 31 | WRITE16_HANDLER( skullxbo_mobmsb_w ); | |
| 28 | DECLARE_WRITE16_HANDLER( skullxbo_playfieldlatch_w ); | |
| 29 | DECLARE_WRITE16_HANDLER( skullxbo_xscroll_w ); | |
| 30 | DECLARE_WRITE16_HANDLER( skullxbo_yscroll_w ); | |
| 31 | DECLARE_WRITE16_HANDLER( skullxbo_mobmsb_w ); | |
| 32 | 32 | |
| 33 | 33 | |
| 34 | 34 | SCREEN_UPDATE_IND16( skullxbo ); |
| r17964 | r17965 | |
|---|---|---|
| 595 | 595 | extern MACHINE_START( snes ); |
| 596 | 596 | extern MACHINE_RESET( snes ); |
| 597 | 597 | |
| 598 | READ8_HANDLER( snes_open_bus_r ); | |
| 598 | DECLARE_READ8_HANDLER( snes_open_bus_r ); | |
| 599 | 599 | |
| 600 | extern READ8_HANDLER( snes_r_io ); | |
| 601 | extern WRITE8_HANDLER( snes_w_io ); | |
| 600 | extern DECLARE_READ8_HANDLER( snes_r_io ); | |
| 601 | extern DECLARE_WRITE8_HANDLER( snes_w_io ); | |
| 602 | 602 | |
| 603 | extern READ8_HANDLER( snes_r_bank1 ); | |
| 604 | extern READ8_HANDLER( snes_r_bank2 ); | |
| 605 | extern READ8_HANDLER( snes_r_bank3 ); | |
| 606 | extern READ8_HANDLER( snes_r_bank4 ); | |
| 607 | extern READ8_HANDLER( snes_r_bank5 ); | |
| 608 | extern READ8_HANDLER( snes_r_bank6 ); | |
| 609 | extern READ8_HANDLER( snes_r_bank7 ); | |
| 610 | extern WRITE8_HANDLER( snes_w_bank1 ); | |
| 611 | extern WRITE8_HANDLER( snes_w_bank2 ); | |
| 612 | extern WRITE8_HANDLER( snes_w_bank4 ); | |
| 613 | extern WRITE8_HANDLER( snes_w_bank5 ); | |
| 614 | extern WRITE8_HANDLER( snes_w_bank6 ); | |
| 615 | extern WRITE8_HANDLER( snes_w_bank7 ); | |
| 603 | extern DECLARE_READ8_HANDLER( snes_r_bank1 ); | |
| 604 | extern DECLARE_READ8_HANDLER( snes_r_bank2 ); | |
| 605 | extern DECLARE_READ8_HANDLER( snes_r_bank3 ); | |
| 606 | extern DECLARE_READ8_HANDLER( snes_r_bank4 ); | |
| 607 | extern DECLARE_READ8_HANDLER( snes_r_bank5 ); | |
| 608 | extern DECLARE_READ8_HANDLER( snes_r_bank6 ); | |
| 609 | extern DECLARE_READ8_HANDLER( snes_r_bank7 ); | |
| 610 | extern DECLARE_WRITE8_HANDLER( snes_w_bank1 ); | |
| 611 | extern DECLARE_WRITE8_HANDLER( snes_w_bank2 ); | |
| 612 | extern DECLARE_WRITE8_HANDLER( snes_w_bank4 ); | |
| 613 | extern DECLARE_WRITE8_HANDLER( snes_w_bank5 ); | |
| 614 | extern DECLARE_WRITE8_HANDLER( snes_w_bank6 ); | |
| 615 | extern DECLARE_WRITE8_HANDLER( snes_w_bank7 ); | |
| 616 | 616 | |
| 617 | extern READ8_HANDLER( superfx_r_bank1 ); | |
| 618 | extern READ8_HANDLER( superfx_r_bank2 ); | |
| 619 | extern READ8_HANDLER( superfx_r_bank3 ); | |
| 620 | extern WRITE8_HANDLER( superfx_w_bank1 ); | |
| 621 | extern WRITE8_HANDLER( superfx_w_bank2 ); | |
| 622 | extern WRITE8_HANDLER( superfx_w_bank3 ); | |
| 617 | extern DECLARE_READ8_HANDLER( superfx_r_bank1 ); | |
| 618 | extern DECLARE_READ8_HANDLER( superfx_r_bank2 ); | |
| 619 | extern DECLARE_READ8_HANDLER( superfx_r_bank3 ); | |
| 620 | extern DECLARE_WRITE8_HANDLER( superfx_w_bank1 ); | |
| 621 | extern DECLARE_WRITE8_HANDLER( superfx_w_bank2 ); | |
| 622 | extern DECLARE_WRITE8_HANDLER( superfx_w_bank3 ); | |
| 623 | 623 | |
| 624 | 624 | WRITE_LINE_DEVICE_HANDLER( snes_extern_irq_w ); |
| 625 | 625 | |
| r17964 | r17965 | |
| 745 | 745 | extern VIDEO_START( snes ); |
| 746 | 746 | extern SCREEN_UPDATE_RGB32( snes ); |
| 747 | 747 | |
| 748 | extern READ8_HANDLER( snes_ppu_read ); | |
| 749 | extern WRITE8_HANDLER( snes_ppu_write ); | |
| 748 | extern DECLARE_READ8_HANDLER( snes_ppu_read ); | |
| 749 | extern DECLARE_WRITE8_HANDLER( snes_ppu_write ); | |
| 750 | 750 | |
| 751 | 751 | #endif /* _SNES_H_ */ |
| r17964 | r17965 | |
|---|---|---|
| 96 | 96 | |
| 97 | 97 | MACHINE_CONFIG_EXTERN( frogs_audio ); |
| 98 | 98 | MACHINE_CONFIG_EXTERN( headon_audio ); |
| 99 | WRITE8_HANDLER( frogs_audio_w ); | |
| 100 | WRITE8_HANDLER( headon_audio_w ); | |
| 101 | WRITE8_HANDLER( invho2_audio_w ); | |
| 99 | DECLARE_WRITE8_HANDLER( frogs_audio_w ); | |
| 100 | DECLARE_WRITE8_HANDLER( headon_audio_w ); | |
| 101 | DECLARE_WRITE8_HANDLER( invho2_audio_w ); | |
| 102 | 102 | |
| 103 | 103 | |
| 104 | 104 | /*----------- defined in audio/depthch.c -----------*/ |
| 105 | 105 | |
| 106 | 106 | MACHINE_CONFIG_EXTERN( depthch_audio ); |
| 107 | WRITE8_HANDLER( depthch_audio_w ); | |
| 107 | DECLARE_WRITE8_HANDLER( depthch_audio_w ); | |
| 108 | 108 | |
| 109 | 109 | |
| 110 | 110 | /*----------- defined in audio/carnival.c -----------*/ |
| 111 | 111 | |
| 112 | 112 | MACHINE_CONFIG_EXTERN( carnival_audio ); |
| 113 | WRITE8_HANDLER( carnival_audio_1_w ); | |
| 114 | WRITE8_HANDLER( carnival_audio_2_w ); | |
| 113 | DECLARE_WRITE8_HANDLER( carnival_audio_1_w ); | |
| 114 | DECLARE_WRITE8_HANDLER( carnival_audio_2_w ); | |
| 115 | 115 | |
| 116 | 116 | |
| 117 | 117 | /*----------- defined in audio/invinco.c -----------*/ |
| 118 | 118 | |
| 119 | 119 | MACHINE_CONFIG_EXTERN( invinco_audio ); |
| 120 | WRITE8_HANDLER( invinco_audio_w ); | |
| 120 | DECLARE_WRITE8_HANDLER( invinco_audio_w ); | |
| 121 | 121 | |
| 122 | 122 | |
| 123 | 123 | /*----------- defined in audio/pulsar.c -----------*/ |
| 124 | 124 | |
| 125 | 125 | MACHINE_CONFIG_EXTERN( pulsar_audio ); |
| 126 | WRITE8_HANDLER( pulsar_audio_1_w ); | |
| 127 | WRITE8_HANDLER( pulsar_audio_2_w ); | |
| 126 | DECLARE_WRITE8_HANDLER( pulsar_audio_1_w ); | |
| 127 | DECLARE_WRITE8_HANDLER( pulsar_audio_2_w ); |
| r17964 | r17965 | |
|---|---|---|
| 73 | 73 | TIMER_DEVICE_CALLBACK( atarisy1_int3off_callback ); |
| 74 | 74 | TIMER_DEVICE_CALLBACK( atarisy1_reset_yscroll_callback ); |
| 75 | 75 | |
| 76 | READ16_HANDLER( atarisy1_int3state_r ); | |
| 76 | DECLARE_READ16_HANDLER( atarisy1_int3state_r ); | |
| 77 | 77 | |
| 78 | WRITE16_HANDLER( atarisy1_spriteram_w ); | |
| 79 | WRITE16_HANDLER( atarisy1_bankselect_w ); | |
| 80 | WRITE16_HANDLER( atarisy1_xscroll_w ); | |
| 81 | WRITE16_HANDLER( atarisy1_yscroll_w ); | |
| 82 | WRITE16_HANDLER( atarisy1_priority_w ); | |
| 78 | DECLARE_WRITE16_HANDLER( atarisy1_spriteram_w ); | |
| 79 | DECLARE_WRITE16_HANDLER( atarisy1_bankselect_w ); | |
| 80 | DECLARE_WRITE16_HANDLER( atarisy1_xscroll_w ); | |
| 81 | DECLARE_WRITE16_HANDLER( atarisy1_yscroll_w ); | |
| 82 | DECLARE_WRITE16_HANDLER( atarisy1_priority_w ); | |
| 83 | 83 | |
| 84 | 84 | |
| 85 | 85 | SCREEN_UPDATE_IND16( atarisy1 ); |
| r17964 | r17965 | |
|---|---|---|
| 119 | 119 | |
| 120 | 120 | /*----------- defined in machine/dec0.c -----------*/ |
| 121 | 121 | |
| 122 | READ16_HANDLER( slyspy_controls_r ); | |
| 122 | DECLARE_READ16_HANDLER( slyspy_controls_r ); | |
| 123 | 123 | |
| 124 | 124 | |
| 125 | 125 | extern void dec0_i8751_write(running_machine &machine, int data); |
| r17964 | r17965 | |
|---|---|---|
| 61 | 61 | SCREEN_VBLANK( atarig42 ); |
| 62 | 62 | SCREEN_UPDATE_IND16( atarig42 ); |
| 63 | 63 | |
| 64 | WRITE16_HANDLER( atarig42_mo_control_w ); | |
| 64 | DECLARE_WRITE16_HANDLER( atarig42_mo_control_w ); | |
| 65 | 65 | |
| 66 | 66 | void atarig42_scanline_update(screen_device &screen, int scanline); |
| 67 | 67 |
| r17964 | r17965 | |
|---|---|---|
| 27 | 27 | |
| 28 | 28 | /*----------- defined in video/vindictr.c -----------*/ |
| 29 | 29 | |
| 30 | WRITE16_HANDLER( vindictr_paletteram_w ); | |
| 30 | DECLARE_WRITE16_HANDLER( vindictr_paletteram_w ); | |
| 31 | 31 | |
| 32 | 32 | |
| 33 | 33 | SCREEN_UPDATE_IND16( vindictr ); |
| r17964 | r17965 | |
|---|---|---|
| 122 | 122 | /*----------- defined in machine/nb1413m3.c -----------*/ |
| 123 | 123 | |
| 124 | 124 | MACHINE_RESET( nb1413m3 ); |
| 125 | WRITE8_HANDLER( nb1413m3_nmi_clock_w ); | |
| 125 | DECLARE_WRITE8_HANDLER( nb1413m3_nmi_clock_w ); | |
| 126 | 126 | INTERRUPT_GEN( nb1413m3_interrupt ); |
| 127 | READ8_HANDLER( nb1413m3_sndrom_r ); | |
| 128 | WRITE8_HANDLER( nb1413m3_sndrombank1_w ); | |
| 129 | WRITE8_HANDLER( nb1413m3_sndrombank2_w ); | |
| 130 | READ8_HANDLER( nb1413m3_gfxrom_r ); | |
| 131 | WRITE8_HANDLER( nb1413m3_gfxrombank_w ); | |
| 132 | WRITE8_HANDLER( nb1413m3_gfxradr_l_w ); | |
| 133 | WRITE8_HANDLER( nb1413m3_gfxradr_h_w ); | |
| 134 | WRITE8_HANDLER( nb1413m3_inputportsel_w ); | |
| 135 | READ8_HANDLER( nb1413m3_inputport0_r ); | |
| 136 | READ8_HANDLER( nb1413m3_inputport1_r ); | |
| 137 | READ8_HANDLER( nb1413m3_inputport2_r ); | |
| 138 | READ8_HANDLER( nb1413m3_inputport3_r ); | |
| 139 | READ8_HANDLER( nb1413m3_dipsw1_r ); | |
| 140 | READ8_HANDLER( nb1413m3_dipsw2_r ); | |
| 141 | READ8_HANDLER( nb1413m3_dipsw3_l_r ); | |
| 142 | READ8_HANDLER( nb1413m3_dipsw3_h_r ); | |
| 143 | WRITE8_HANDLER( nb1413m3_outcoin_w ); | |
| 144 | WRITE8_HANDLER( nb1413m3_vcrctrl_w ); | |
| 127 | DECLARE_READ8_HANDLER( nb1413m3_sndrom_r ); | |
| 128 | DECLARE_WRITE8_HANDLER( nb1413m3_sndrombank1_w ); | |
| 129 | DECLARE_WRITE8_HANDLER( nb1413m3_sndrombank2_w ); | |
| 130 | DECLARE_READ8_HANDLER( nb1413m3_gfxrom_r ); | |
| 131 | DECLARE_WRITE8_HANDLER( nb1413m3_gfxrombank_w ); | |
| 132 | DECLARE_WRITE8_HANDLER( nb1413m3_gfxradr_l_w ); | |
| 133 | DECLARE_WRITE8_HANDLER( nb1413m3_gfxradr_h_w ); | |
| 134 | DECLARE_WRITE8_HANDLER( nb1413m3_inputportsel_w ); | |
| 135 | DECLARE_READ8_HANDLER( nb1413m3_inputport0_r ); | |
| 136 | DECLARE_READ8_HANDLER( nb1413m3_inputport1_r ); | |
| 137 | DECLARE_READ8_HANDLER( nb1413m3_inputport2_r ); | |
| 138 | DECLARE_READ8_HANDLER( nb1413m3_inputport3_r ); | |
| 139 | DECLARE_READ8_HANDLER( nb1413m3_dipsw1_r ); | |
| 140 | DECLARE_READ8_HANDLER( nb1413m3_dipsw2_r ); | |
| 141 | DECLARE_READ8_HANDLER( nb1413m3_dipsw3_l_r ); | |
| 142 | DECLARE_READ8_HANDLER( nb1413m3_dipsw3_h_r ); | |
| 143 | DECLARE_WRITE8_HANDLER( nb1413m3_outcoin_w ); | |
| 144 | DECLARE_WRITE8_HANDLER( nb1413m3_vcrctrl_w ); | |
| 145 | 145 | CUSTOM_INPUT( nb1413m3_busyflag_r ); |
| 146 | 146 | CUSTOM_INPUT( nb1413m3_outcoin_flag_r ); |
| 147 | 147 |
| r17964 | r17965 | |
|---|---|---|
| 83 | 83 | |
| 84 | 84 | /*----------- defined in video/atarisy2.c -----------*/ |
| 85 | 85 | |
| 86 | READ16_HANDLER( atarisy2_slapstic_r ); | |
| 87 | READ16_HANDLER( atarisy2_videoram_r ); | |
| 86 | DECLARE_READ16_HANDLER( atarisy2_slapstic_r ); | |
| 87 | DECLARE_READ16_HANDLER( atarisy2_videoram_r ); | |
| 88 | 88 | |
| 89 | WRITE16_HANDLER( atarisy2_slapstic_w ); | |
| 90 | WRITE16_HANDLER( atarisy2_yscroll_w ); | |
| 91 | WRITE16_HANDLER( atarisy2_xscroll_w ); | |
| 92 | WRITE16_HANDLER( atarisy2_videoram_w ); | |
| 93 | WRITE16_HANDLER( atarisy2_paletteram_w ); | |
| 89 | DECLARE_WRITE16_HANDLER( atarisy2_slapstic_w ); | |
| 90 | DECLARE_WRITE16_HANDLER( atarisy2_yscroll_w ); | |
| 91 | DECLARE_WRITE16_HANDLER( atarisy2_xscroll_w ); | |
| 92 | DECLARE_WRITE16_HANDLER( atarisy2_videoram_w ); | |
| 93 | DECLARE_WRITE16_HANDLER( atarisy2_paletteram_w ); | |
| 94 | 94 | |
| 95 | 95 | |
| 96 | 96 | SCREEN_UPDATE_IND16( atarisy2 ); |
| r17964 | r17965 | |
|---|---|---|
| 243 | 243 | void video_update_vdp1(running_machine &machine); |
| 244 | 244 | void stv_vdp2_dynamic_res_change(running_machine &machine); |
| 245 | 245 | |
| 246 | READ16_HANDLER ( saturn_vdp1_regs_r ); | |
| 247 | READ32_HANDLER ( saturn_vdp1_vram_r ); | |
| 248 | READ32_HANDLER ( saturn_vdp1_framebuffer0_r ); | |
| 246 | DECLARE_READ16_HANDLER ( saturn_vdp1_regs_r ); | |
| 247 | DECLARE_READ32_HANDLER ( saturn_vdp1_vram_r ); | |
| 248 | DECLARE_READ32_HANDLER ( saturn_vdp1_framebuffer0_r ); | |
| 249 | 249 | |
| 250 | WRITE16_HANDLER ( saturn_vdp1_regs_w ); | |
| 251 | WRITE32_HANDLER ( saturn_vdp1_vram_w ); | |
| 252 | WRITE32_HANDLER ( saturn_vdp1_framebuffer0_w ); | |
| 250 | DECLARE_WRITE16_HANDLER ( saturn_vdp1_regs_w ); | |
| 251 | DECLARE_WRITE32_HANDLER ( saturn_vdp1_vram_w ); | |
| 252 | DECLARE_WRITE32_HANDLER ( saturn_vdp1_framebuffer0_w ); | |
| 253 | 253 | |
| 254 | 254 | /*----------- defined in video/stvvdp2.c -----------*/ |
| 255 | 255 | |
| 256 | READ32_HANDLER ( saturn_vdp2_vram_r ); | |
| 257 | READ32_HANDLER ( saturn_vdp2_cram_r ); | |
| 258 | READ16_HANDLER ( saturn_vdp2_regs_r ); | |
| 256 | DECLARE_READ32_HANDLER ( saturn_vdp2_vram_r ); | |
| 257 | DECLARE_READ32_HANDLER ( saturn_vdp2_cram_r ); | |
| 258 | DECLARE_READ16_HANDLER ( saturn_vdp2_regs_r ); | |
| 259 | 259 | |
| 260 | WRITE32_HANDLER ( saturn_vdp2_vram_w ); | |
| 261 | WRITE32_HANDLER ( saturn_vdp2_cram_w ); | |
| 262 | WRITE16_HANDLER ( saturn_vdp2_regs_w ); | |
| 260 | DECLARE_WRITE32_HANDLER ( saturn_vdp2_vram_w ); | |
| 261 | DECLARE_WRITE32_HANDLER ( saturn_vdp2_cram_w ); | |
| 262 | DECLARE_WRITE16_HANDLER ( saturn_vdp2_regs_w ); | |
| 263 | 263 | |
| 264 | 264 | |
| 265 | 265 | SCREEN_UPDATE_RGB32( stv_vdp2 ); |
| r17964 | r17965 | |
|---|---|---|
| 2 | 2 | |
| 3 | 3 | extern UINT16 seibucrtc_sc0bank; |
| 4 | 4 | |
| 5 | WRITE16_HANDLER( seibucrtc_sc0vram_w ); | |
| 6 | WRITE16_HANDLER( seibucrtc_sc1vram_w ); | |
| 7 | WRITE16_HANDLER( seibucrtc_sc2vram_w ); | |
| 8 | WRITE16_HANDLER( seibucrtc_sc3vram_w ); | |
| 9 | WRITE16_HANDLER( seibucrtc_vregs_w ); | |
| 5 | DECLARE_WRITE16_HANDLER( seibucrtc_sc0vram_w ); | |
| 6 | DECLARE_WRITE16_HANDLER( seibucrtc_sc1vram_w ); | |
| 7 | DECLARE_WRITE16_HANDLER( seibucrtc_sc2vram_w ); | |
| 8 | DECLARE_WRITE16_HANDLER( seibucrtc_sc3vram_w ); | |
| 9 | DECLARE_WRITE16_HANDLER( seibucrtc_vregs_w ); | |
| 10 | 10 | void seibucrtc_sc0bank_w(UINT16 data); |
| 11 | 11 | VIDEO_START( seibu_crtc ); |
| 12 | 12 | SCREEN_UPDATE_IND16( seibu_crtc ); |
| r17964 | r17965 | |
|---|---|---|
| 111 | 111 | |
| 112 | 112 | /*----------- defined in video/namcos1.c -----------*/ |
| 113 | 113 | |
| 114 | READ8_HANDLER( namcos1_videoram_r ); | |
| 115 | WRITE8_HANDLER( namcos1_videoram_w ); | |
| 116 | WRITE8_HANDLER( namcos1_paletteram_w ); | |
| 117 | READ8_HANDLER( namcos1_spriteram_r ); | |
| 118 | WRITE8_HANDLER( namcos1_spriteram_w ); | |
| 114 | DECLARE_READ8_HANDLER( namcos1_videoram_r ); | |
| 115 | DECLARE_WRITE8_HANDLER( namcos1_videoram_w ); | |
| 116 | DECLARE_WRITE8_HANDLER( namcos1_paletteram_w ); | |
| 117 | DECLARE_READ8_HANDLER( namcos1_spriteram_r ); | |
| 118 | DECLARE_WRITE8_HANDLER( namcos1_spriteram_w ); | |
| 119 | 119 | |
| 120 | 120 | |
| 121 | 121 | SCREEN_UPDATE_IND16( namcos1 ); |
| r17964 | r17965 | |
|---|---|---|
| 141 | 141 | |
| 142 | 142 | extern const char *const wow_sample_names[]; |
| 143 | 143 | |
| 144 | READ8_HANDLER( wow_speech_r ); | |
| 144 | DECLARE_READ8_HANDLER( wow_speech_r ); | |
| 145 | 145 | CUSTOM_INPUT( wow_speech_status_r ); |
| 146 | 146 | |
| 147 | 147 | |
| r17964 | r17965 | |
| 149 | 149 | |
| 150 | 150 | extern const char *const gorf_sample_names[]; |
| 151 | 151 | |
| 152 | READ8_HANDLER( gorf_speech_r ); | |
| 152 | DECLARE_READ8_HANDLER( gorf_speech_r ); | |
| 153 | 153 | CUSTOM_INPUT( gorf_speech_status_r ); |
| r17964 | r17965 | |
|---|---|---|
| 150 | 150 | |
| 151 | 151 | /*----------- defined in video/bosco.c -----------*/ |
| 152 | 152 | |
| 153 | WRITE8_HANDLER( bosco_videoram_w ); | |
| 154 | WRITE8_HANDLER( bosco_scrollx_w ); | |
| 155 | WRITE8_HANDLER( bosco_scrolly_w ); | |
| 156 | WRITE8_HANDLER( bosco_starclr_w ); | |
| 153 | DECLARE_WRITE8_HANDLER( bosco_videoram_w ); | |
| 154 | DECLARE_WRITE8_HANDLER( bosco_scrollx_w ); | |
| 155 | DECLARE_WRITE8_HANDLER( bosco_scrolly_w ); | |
| 156 | DECLARE_WRITE8_HANDLER( bosco_starclr_w ); | |
| 157 | 157 | |
| 158 | 158 | SCREEN_UPDATE_IND16( bosco ); |
| 159 | 159 | |
| r17964 | r17965 | |
| 182 | 182 | |
| 183 | 183 | /*----------- defined in video/xevious.c -----------*/ |
| 184 | 184 | |
| 185 | WRITE8_HANDLER( xevious_fg_videoram_w ); | |
| 186 | WRITE8_HANDLER( xevious_fg_colorram_w ); | |
| 187 | WRITE8_HANDLER( xevious_bg_videoram_w ); | |
| 188 | WRITE8_HANDLER( xevious_bg_colorram_w ); | |
| 189 | WRITE8_HANDLER( xevious_vh_latch_w ); | |
| 190 | WRITE8_HANDLER( xevious_bs_w ); | |
| 191 | READ8_HANDLER( xevious_bb_r ); | |
| 185 | DECLARE_WRITE8_HANDLER( xevious_fg_videoram_w ); | |
| 186 | DECLARE_WRITE8_HANDLER( xevious_fg_colorram_w ); | |
| 187 | DECLARE_WRITE8_HANDLER( xevious_bg_videoram_w ); | |
| 188 | DECLARE_WRITE8_HANDLER( xevious_bg_colorram_w ); | |
| 189 | DECLARE_WRITE8_HANDLER( xevious_vh_latch_w ); | |
| 190 | DECLARE_WRITE8_HANDLER( xevious_bs_w ); | |
| 191 | DECLARE_READ8_HANDLER( xevious_bb_r ); | |
| 192 | 192 | |
| 193 | 193 | |
| 194 | 194 | SCREEN_UPDATE_IND16( xevious ); |
| r17964 | r17965 | |
| 200 | 200 | void battles_customio_init(running_machine &machine); |
| 201 | 201 | TIMER_DEVICE_CALLBACK( battles_nmi_generate ); |
| 202 | 202 | |
| 203 | READ8_HANDLER( battles_customio0_r ); | |
| 204 | READ8_HANDLER( battles_customio_data0_r ); | |
| 205 | READ8_HANDLER( battles_customio3_r ); | |
| 206 | READ8_HANDLER( battles_customio_data3_r ); | |
| 207 | READ8_HANDLER( battles_input_port_r ); | |
| 203 | DECLARE_READ8_HANDLER( battles_customio0_r ); | |
| 204 | DECLARE_READ8_HANDLER( battles_customio_data0_r ); | |
| 205 | DECLARE_READ8_HANDLER( battles_customio3_r ); | |
| 206 | DECLARE_READ8_HANDLER( battles_customio_data3_r ); | |
| 207 | DECLARE_READ8_HANDLER( battles_input_port_r ); | |
| 208 | 208 | |
| 209 | WRITE8_HANDLER( battles_customio0_w ); | |
| 210 | WRITE8_HANDLER( battles_customio_data0_w ); | |
| 211 | WRITE8_HANDLER( battles_customio3_w ); | |
| 212 | WRITE8_HANDLER( battles_customio_data3_w ); | |
| 213 | WRITE8_HANDLER( battles_CPU4_coin_w ); | |
| 214 | WRITE8_HANDLER( battles_noise_sound_w ); | |
| 209 | DECLARE_WRITE8_HANDLER( battles_customio0_w ); | |
| 210 | DECLARE_WRITE8_HANDLER( battles_customio_data0_w ); | |
| 211 | DECLARE_WRITE8_HANDLER( battles_customio3_w ); | |
| 212 | DECLARE_WRITE8_HANDLER( battles_customio_data3_w ); | |
| 213 | DECLARE_WRITE8_HANDLER( battles_CPU4_coin_w ); | |
| 214 | DECLARE_WRITE8_HANDLER( battles_noise_sound_w ); | |
| 215 | 215 | |
| 216 | 216 | INTERRUPT_GEN( battles_interrupt_4 ); |
| 217 | 217 | |
| 218 | 218 | /*----------- defined in video/digdug.c -----------*/ |
| 219 | 219 | |
| 220 | WRITE8_HANDLER( digdug_videoram_w ); | |
| 221 | WRITE8_HANDLER( digdug_PORT_w ); | |
| 220 | DECLARE_WRITE8_HANDLER( digdug_videoram_w ); | |
| 221 | DECLARE_WRITE8_HANDLER( digdug_PORT_w ); | |
| 222 | 222 | |
| 223 | 223 | SCREEN_UPDATE_IND16( digdug ); |
| 224 | 224 |
| r17964 | r17965 | |
|---|---|---|
| 62 | 62 | |
| 63 | 63 | /*----------- defined in video/galivan.c -----------*/ |
| 64 | 64 | |
| 65 | WRITE8_HANDLER( ninjemak_scrollx_w ); | |
| 66 | WRITE8_HANDLER( ninjemak_scrolly_w ); | |
| 65 | DECLARE_WRITE8_HANDLER( ninjemak_scrollx_w ); | |
| 66 | DECLARE_WRITE8_HANDLER( ninjemak_scrolly_w ); | |
| 67 | 67 | |
| 68 | 68 | |
| 69 | 69 |
| r17964 | r17965 | |
|---|---|---|
| 297 | 297 | |
| 298 | 298 | extern void (*namcos2_kickstart)(running_machine &machine, int internal); |
| 299 | 299 | |
| 300 | READ16_HANDLER( namcos2_flap_prot_r ); | |
| 300 | DECLARE_READ16_HANDLER( namcos2_flap_prot_r ); | |
| 301 | 301 | |
| 302 | 302 | /**************************************************************/ |
| 303 | 303 | /* EEPROM memory function handlers */ |
| 304 | 304 | /**************************************************************/ |
| 305 | 305 | #define NAMCOS2_68K_eeprom_W namcos2_68k_eeprom_w |
| 306 | 306 | #define NAMCOS2_68K_eeprom_R namcos2_68k_eeprom_r |
| 307 | WRITE16_HANDLER( namcos2_68k_eeprom_w ); | |
| 308 | READ16_HANDLER( namcos2_68k_eeprom_r ); | |
| 307 | DECLARE_WRITE16_HANDLER( namcos2_68k_eeprom_w ); | |
| 308 | DECLARE_READ16_HANDLER( namcos2_68k_eeprom_r ); | |
| 309 | 309 | |
| 310 | 310 | /**************************************************************/ |
| 311 | 311 | /* Shared data ROM memory handlerhandlers */ |
| 312 | 312 | /**************************************************************/ |
| 313 | READ16_HANDLER( namcos2_68k_data_rom_r ); | |
| 313 | DECLARE_READ16_HANDLER( namcos2_68k_data_rom_r ); | |
| 314 | 314 | |
| 315 | 315 | /**************************************************************/ |
| 316 | 316 | /* Shared protection/random number generator */ |
| 317 | 317 | /**************************************************************/ |
| 318 | READ16_HANDLER( namcos2_68k_key_r ); | |
| 319 | WRITE16_HANDLER( namcos2_68k_key_w ); | |
| 318 | DECLARE_READ16_HANDLER( namcos2_68k_key_r ); | |
| 319 | DECLARE_WRITE16_HANDLER( namcos2_68k_key_w ); | |
| 320 | 320 | |
| 321 | 321 | /**************************************************************/ |
| 322 | 322 | /* Non-shared memory custom IO device - IRQ/Inputs/Outputs */ |
| r17964 | r17965 | |
| 331 | 331 | #define NAMCOS2_C148_SERIRQ 6 /* 0x1cc000 */ |
| 332 | 332 | #define NAMCOS2_C148_VBLANKIRQ 7 /* 0x1ce000 */ |
| 333 | 333 | |
| 334 | WRITE16_HANDLER( namcos2_68k_master_C148_w ); | |
| 335 | READ16_HANDLER( namcos2_68k_master_C148_r ); | |
| 334 | DECLARE_WRITE16_HANDLER( namcos2_68k_master_C148_w ); | |
| 335 | DECLARE_READ16_HANDLER( namcos2_68k_master_C148_r ); | |
| 336 | 336 | INTERRUPT_GEN( namcos2_68k_master_vblank ); |
| 337 | 337 | |
| 338 | WRITE16_HANDLER( namcos2_68k_slave_C148_w ); | |
| 339 | READ16_HANDLER( namcos2_68k_slave_C148_r ); | |
| 338 | DECLARE_WRITE16_HANDLER( namcos2_68k_slave_C148_w ); | |
| 339 | DECLARE_READ16_HANDLER( namcos2_68k_slave_C148_r ); | |
| 340 | 340 | INTERRUPT_GEN( namcos2_68k_slave_vblank ); |
| 341 | 341 | |
| 342 | WRITE16_HANDLER( namcos2_68k_gpu_C148_w ); | |
| 343 | READ16_HANDLER( namcos2_68k_gpu_C148_r ); | |
| 342 | DECLARE_WRITE16_HANDLER( namcos2_68k_gpu_C148_w ); | |
| 343 | DECLARE_READ16_HANDLER( namcos2_68k_gpu_C148_r ); | |
| 344 | 344 | INTERRUPT_GEN( namcos2_68k_gpu_vblank ); |
| 345 | 345 | |
| 346 | 346 | void namcos2_adjust_posirq_timer( running_machine &machine, int scanline ); |
| r17964 | r17965 | |
| 366 | 366 | /* Sound CPU support handlers - 6809 */ |
| 367 | 367 | /**************************************************************/ |
| 368 | 368 | |
| 369 | WRITE8_HANDLER( namcos2_sound_bankselect_w ); | |
| 369 | DECLARE_WRITE8_HANDLER( namcos2_sound_bankselect_w ); | |
| 370 | 370 | |
| 371 | 371 | /**************************************************************/ |
| 372 | 372 | /* MCU Specific support handlers - HD63705 */ |
| 373 | 373 | /**************************************************************/ |
| 374 | 374 | |
| 375 | WRITE8_HANDLER( namcos2_mcu_analog_ctrl_w ); | |
| 376 | READ8_HANDLER( namcos2_mcu_analog_ctrl_r ); | |
| 375 | DECLARE_WRITE8_HANDLER( namcos2_mcu_analog_ctrl_w ); | |
| 376 | DECLARE_READ8_HANDLER( namcos2_mcu_analog_ctrl_r ); | |
| 377 | 377 | |
| 378 | WRITE8_HANDLER( namcos2_mcu_analog_port_w ); | |
| 379 | READ8_HANDLER( namcos2_mcu_analog_port_r ); | |
| 378 | DECLARE_WRITE8_HANDLER( namcos2_mcu_analog_port_w ); | |
| 379 | DECLARE_READ8_HANDLER( namcos2_mcu_analog_port_r ); | |
| 380 | 380 | |
| 381 | WRITE8_HANDLER( namcos2_mcu_port_d_w ); | |
| 382 | READ8_HANDLER( namcos2_mcu_port_d_r ); | |
| 381 | DECLARE_WRITE8_HANDLER( namcos2_mcu_port_d_w ); | |
| 382 | DECLARE_READ8_HANDLER( namcos2_mcu_port_d_r ); | |
| 383 | 383 | |
| 384 | READ8_HANDLER( namcos2_input_port_0_r ); | |
| 385 | READ8_HANDLER( namcos2_input_port_10_r ); | |
| 386 | READ8_HANDLER( namcos2_input_port_12_r ); | |
| 384 | DECLARE_READ8_HANDLER( namcos2_input_port_0_r ); | |
| 385 | DECLARE_READ8_HANDLER( namcos2_input_port_10_r ); | |
| 386 | DECLARE_READ8_HANDLER( namcos2_input_port_12_r ); | |
| 387 | 387 |
| r17964 | r17965 | |
|---|---|---|
| 76 | 76 | extern const sn76477_interface vanguard_sn76477_intf_2; |
| 77 | 77 | extern const sn76477_interface fantasy_sn76477_intf; |
| 78 | 78 | |
| 79 | extern WRITE8_HANDLER( sasuke_sound_w ); | |
| 80 | extern WRITE8_HANDLER( satansat_sound_w ); | |
| 81 | extern WRITE8_HANDLER( vanguard_sound_w ); | |
| 82 | extern WRITE8_HANDLER( vanguard_speech_w ); | |
| 83 | extern WRITE8_HANDLER( fantasy_sound_w ); | |
| 84 | extern WRITE8_HANDLER( fantasy_speech_w ); | |
| 79 | extern DECLARE_WRITE8_HANDLER( sasuke_sound_w ); | |
| 80 | extern DECLARE_WRITE8_HANDLER( satansat_sound_w ); | |
| 81 | extern DECLARE_WRITE8_HANDLER( vanguard_sound_w ); | |
| 82 | extern DECLARE_WRITE8_HANDLER( vanguard_speech_w ); | |
| 83 | extern DECLARE_WRITE8_HANDLER( fantasy_sound_w ); | |
| 84 | extern DECLARE_WRITE8_HANDLER( fantasy_speech_w ); | |
| 85 | 85 | |
| 86 | 86 | class snk6502_sound_device : public device_t, |
| 87 | 87 | public device_sound_interface |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | /*----------- defined in machine/decoprot.c -----------*/ |
| 2 | 2 | |
| 3 | READ16_HANDLER( deco16_60_prot_r ); | |
| 4 | READ16_HANDLER( deco16_66_prot_r ); | |
| 5 | READ16_HANDLER( deco16_104_prot_r ); | |
| 6 | READ16_HANDLER( deco16_104_cninja_prot_r ); | |
| 7 | READ16_HANDLER( deco16_104_rohga_prot_r ); | |
| 8 | READ16_HANDLER( deco16_146_funkyjet_prot_r ); | |
| 9 | READ16_HANDLER( deco16_146_nitroball_prot_r ); | |
| 10 | READ16_HANDLER( deco16_104_pktgaldx_prot_r ); | |
| 11 | READ32_HANDLER( deco16_146_fghthist_prot_r ); | |
| 3 | DECLARE_READ16_HANDLER( deco16_60_prot_r ); | |
| 4 | DECLARE_READ16_HANDLER( deco16_66_prot_r ); | |
| 5 | DECLARE_READ16_HANDLER( deco16_104_prot_r ); | |
| 6 | DECLARE_READ16_HANDLER( deco16_104_cninja_prot_r ); | |
| 7 | DECLARE_READ16_HANDLER( deco16_104_rohga_prot_r ); | |
| 8 | DECLARE_READ16_HANDLER( deco16_146_funkyjet_prot_r ); | |
| 9 | DECLARE_READ16_HANDLER( deco16_146_nitroball_prot_r ); | |
| 10 | DECLARE_READ16_HANDLER( deco16_104_pktgaldx_prot_r ); | |
| 11 | DECLARE_READ32_HANDLER( deco16_146_fghthist_prot_r ); | |
| 12 | 12 | |
| 13 | WRITE16_HANDLER( deco16_60_prot_w ); | |
| 14 | WRITE16_HANDLER( deco16_66_prot_w ); | |
| 15 | WRITE16_HANDLER( deco16_104_prot_w ); | |
| 16 | WRITE16_HANDLER( deco16_104_cninja_prot_w ); | |
| 17 | WRITE16_HANDLER( deco16_104_rohga_prot_w ); | |
| 18 | WRITE16_HANDLER( deco16_146_funkyjet_prot_w ); | |
| 19 | WRITE16_HANDLER( deco16_146_nitroball_prot_w ); | |
| 20 | WRITE16_HANDLER( deco16_104_pktgaldx_prot_w ); | |
| 21 | WRITE32_HANDLER( deco16_146_fghthist_prot_w ); | |
| 13 | DECLARE_WRITE16_HANDLER( deco16_60_prot_w ); | |
| 14 | DECLARE_WRITE16_HANDLER( deco16_66_prot_w ); | |
| 15 | DECLARE_WRITE16_HANDLER( deco16_104_prot_w ); | |
| 16 | DECLARE_WRITE16_HANDLER( deco16_104_cninja_prot_w ); | |
| 17 | DECLARE_WRITE16_HANDLER( deco16_104_rohga_prot_w ); | |
| 18 | DECLARE_WRITE16_HANDLER( deco16_146_funkyjet_prot_w ); | |
| 19 | DECLARE_WRITE16_HANDLER( deco16_146_nitroball_prot_w ); | |
| 20 | DECLARE_WRITE16_HANDLER( deco16_104_pktgaldx_prot_w ); | |
| 21 | DECLARE_WRITE32_HANDLER( deco16_146_fghthist_prot_w ); | |
| 22 | 22 | |
| 23 | 23 | void decoprot_reset(running_machine &machine); |
| 24 | 24 | |
| 25 | READ16_HANDLER( dietgo_104_prot_r ); | |
| 26 | WRITE16_HANDLER( dietgo_104_prot_w ); | |
| 25 | DECLARE_READ16_HANDLER( dietgo_104_prot_r ); | |
| 26 | DECLARE_WRITE16_HANDLER( dietgo_104_prot_w ); |
| r17964 | r17965 | |
|---|---|---|
| 18 | 18 | extern SCREEN_VBLANK(megatech_bios); |
| 19 | 19 | extern SCREEN_VBLANK(megatech_md_sms); |
| 20 | 20 | |
| 21 | extern READ8_HANDLER( sms_vcounter_r ); | |
| 22 | extern READ8_HANDLER( sms_vdp_data_r ); | |
| 23 | extern WRITE8_HANDLER( sms_vdp_data_w ); | |
| 24 | extern READ8_HANDLER( sms_vdp_ctrl_r ); | |
| 25 | extern WRITE8_HANDLER( sms_vdp_ctrl_w ); | |
| 21 | extern DECLARE_READ8_HANDLER( sms_vcounter_r ); | |
| 22 | extern DECLARE_READ8_HANDLER( sms_vdp_data_r ); | |
| 23 | extern DECLARE_WRITE8_HANDLER( sms_vdp_data_w ); | |
| 24 | extern DECLARE_READ8_HANDLER( sms_vdp_ctrl_r ); | |
| 25 | extern DECLARE_WRITE8_HANDLER( sms_vdp_ctrl_w ); | |
| 26 | 26 | |
| 27 | 27 | extern void init_for_megadrive(running_machine &machine); |
| 28 | 28 | extern void segae_md_sms_stop_scanline_timer(void); |
| 29 | 29 | |
| 30 | 30 | |
| 31 | extern READ8_HANDLER( md_sms_vdp_vcounter_r ); | |
| 32 | extern READ8_HANDLER( md_sms_vdp_data_r ); | |
| 33 | extern WRITE8_HANDLER( md_sms_vdp_data_w ); | |
| 34 | extern READ8_HANDLER( md_sms_vdp_ctrl_r ); | |
| 35 | extern WRITE8_HANDLER( md_sms_vdp_ctrl_w ); | |
| 31 | extern DECLARE_READ8_HANDLER( md_sms_vdp_vcounter_r ); | |
| 32 | extern DECLARE_READ8_HANDLER( md_sms_vdp_data_r ); | |
| 33 | extern DECLARE_WRITE8_HANDLER( md_sms_vdp_data_w ); | |
| 34 | extern DECLARE_READ8_HANDLER( md_sms_vdp_ctrl_r ); | |
| 35 | extern DECLARE_WRITE8_HANDLER( md_sms_vdp_ctrl_w ); | |
| 36 | 36 | |
| 37 | 37 | extern VIDEO_START(sms); |
| 38 | 38 | extern SCREEN_VBLANK(sms); |
| 39 | extern READ8_HANDLER( sms_vdp_2_data_r ); | |
| 40 | extern WRITE8_HANDLER( sms_vdp_2_data_w ); | |
| 41 | extern READ8_HANDLER( sms_vdp_2_ctrl_r ); | |
| 42 | extern WRITE8_HANDLER( sms_vdp_2_ctrl_w ); | |
| 39 | extern DECLARE_READ8_HANDLER( sms_vdp_2_data_r ); | |
| 40 | extern DECLARE_WRITE8_HANDLER( sms_vdp_2_data_w ); | |
| 41 | extern DECLARE_READ8_HANDLER( sms_vdp_2_ctrl_r ); | |
| 42 | extern DECLARE_WRITE8_HANDLER( sms_vdp_2_ctrl_w ); | |
| 43 | 43 | extern SCREEN_VBLANK(systeme); |
| 44 | 44 | extern SCREEN_UPDATE_RGB32(systeme); |
| 45 | 45 | extern MACHINE_RESET(systeme); |
| r17964 | r17965 | |
| 49 | 49 | extern UINT8* vdp1_vram_bank0; |
| 50 | 50 | extern UINT8* vdp1_vram_bank1; |
| 51 | 51 | extern void segae_set_vram_banks(UINT8 data); |
| 52 | READ8_HANDLER( sms_ioport_gg00_r ); | |
| 52 | DECLARE_READ8_HANDLER( sms_ioport_gg00_r ); | |
| 53 | 53 | void init_extra_gg_ports(running_machine* machine, const char* tag); |
| 54 | READ8_HANDLER (megatech_sms_ioport_dc_r); | |
| 55 | READ8_HANDLER (megatech_sms_ioport_dd_r); | |
| 56 | READ8_HANDLER( smsgg_backupram_r ); | |
| 57 | WRITE8_HANDLER( smsgg_backupram_w ); | |
| 54 | DECLARE_READ8_HANDLER (megatech_sms_ioport_dc_r); | |
| 55 | DECLARE_READ8_HANDLER (megatech_sms_ioport_dd_r); | |
| 56 | DECLARE_READ8_HANDLER( smsgg_backupram_r ); | |
| 57 | DECLARE_WRITE8_HANDLER( smsgg_backupram_w ); | |
| 58 | 58 | extern void megatech_set_genz80_as_sms_standard_map(running_machine &machine, const char* tag, int mapper); |
| 59 | 59 | MACHINE_CONFIG_EXTERN(sms); |
| 60 | 60 | extern void init_sms(running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 227 | 227 | |
| 228 | 228 | |
| 229 | 229 | INTERRUPT_GEN( hd68k_irq_gen ); |
| 230 | WRITE16_HANDLER( hd68k_irq_ack_w ); | |
| 230 | DECLARE_WRITE16_HANDLER( hd68k_irq_ack_w ); | |
| 231 | 231 | void hdgsp_irq_gen(device_t *device, int state); |
| 232 | 232 | void hdmsp_irq_gen(device_t *device, int state); |
| 233 | 233 | |
| 234 | READ16_HANDLER( hd68k_gsp_io_r ); | |
| 235 | WRITE16_HANDLER( hd68k_gsp_io_w ); | |
| 234 | DECLARE_READ16_HANDLER( hd68k_gsp_io_r ); | |
| 235 | DECLARE_WRITE16_HANDLER( hd68k_gsp_io_w ); | |
| 236 | 236 | |
| 237 | READ16_HANDLER( hd68k_msp_io_r ); | |
| 238 | WRITE16_HANDLER( hd68k_msp_io_w ); | |
| 237 | DECLARE_READ16_HANDLER( hd68k_msp_io_r ); | |
| 238 | DECLARE_WRITE16_HANDLER( hd68k_msp_io_w ); | |
| 239 | 239 | |
| 240 | READ16_HANDLER( hd68k_port0_r ); | |
| 241 | READ16_HANDLER( hd68k_adc8_r ); | |
| 242 | READ16_HANDLER( hd68k_adc12_r ); | |
| 243 | READ16_HANDLER( hdc68k_port1_r ); | |
| 244 | READ16_HANDLER( hda68k_port1_r ); | |
| 245 | READ16_HANDLER( hdc68k_wheel_r ); | |
| 246 | READ16_HANDLER( hd68k_sound_reset_r ); | |
| 240 | DECLARE_READ16_HANDLER( hd68k_port0_r ); | |
| 241 | DECLARE_READ16_HANDLER( hd68k_adc8_r ); | |
| 242 | DECLARE_READ16_HANDLER( hd68k_adc12_r ); | |
| 243 | DECLARE_READ16_HANDLER( hdc68k_port1_r ); | |
| 244 | DECLARE_READ16_HANDLER( hda68k_port1_r ); | |
| 245 | DECLARE_READ16_HANDLER( hdc68k_wheel_r ); | |
| 246 | DECLARE_READ16_HANDLER( hd68k_sound_reset_r ); | |
| 247 | 247 | |
| 248 | WRITE16_HANDLER( hd68k_adc_control_w ); | |
| 249 | WRITE16_HANDLER( hd68k_wr0_write ); | |
| 250 | WRITE16_HANDLER( hd68k_wr1_write ); | |
| 251 | WRITE16_HANDLER( hd68k_wr2_write ); | |
| 252 | WRITE16_HANDLER( hd68k_nwr_w ); | |
| 253 | WRITE16_HANDLER( hdc68k_wheel_edge_reset_w ); | |
| 248 | DECLARE_WRITE16_HANDLER( hd68k_adc_control_w ); | |
| 249 | DECLARE_WRITE16_HANDLER( hd68k_wr0_write ); | |
| 250 | DECLARE_WRITE16_HANDLER( hd68k_wr1_write ); | |
| 251 | DECLARE_WRITE16_HANDLER( hd68k_wr2_write ); | |
| 252 | DECLARE_WRITE16_HANDLER( hd68k_nwr_w ); | |
| 253 | DECLARE_WRITE16_HANDLER( hdc68k_wheel_edge_reset_w ); | |
| 254 | 254 | |
| 255 | READ16_HANDLER( hd68k_zram_r ); | |
| 256 | WRITE16_HANDLER( hd68k_zram_w ); | |
| 255 | DECLARE_READ16_HANDLER( hd68k_zram_r ); | |
| 256 | DECLARE_WRITE16_HANDLER( hd68k_zram_w ); | |
| 257 | 257 | |
| 258 | 258 | void harddriv_duart_irq_handler(device_t *device, int state, UINT8 vector); |
| 259 | 259 | |
| 260 | WRITE16_HANDLER( hdgsp_io_w ); | |
| 260 | DECLARE_WRITE16_HANDLER( hdgsp_io_w ); | |
| 261 | 261 | |
| 262 | WRITE16_HANDLER( hdgsp_protection_w ); | |
| 262 | DECLARE_WRITE16_HANDLER( hdgsp_protection_w ); | |
| 263 | 263 | |
| 264 | 264 | |
| 265 | 265 | /* ADSP board */ |
| 266 | READ16_HANDLER( hd68k_adsp_program_r ); | |
| 267 | WRITE16_HANDLER( hd68k_adsp_program_w ); | |
| 266 | DECLARE_READ16_HANDLER( hd68k_adsp_program_r ); | |
| 267 | DECLARE_WRITE16_HANDLER( hd68k_adsp_program_w ); | |
| 268 | 268 | |
| 269 | READ16_HANDLER( hd68k_adsp_data_r ); | |
| 270 | WRITE16_HANDLER( hd68k_adsp_data_w ); | |
| 269 | DECLARE_READ16_HANDLER( hd68k_adsp_data_r ); | |
| 270 | DECLARE_WRITE16_HANDLER( hd68k_adsp_data_w ); | |
| 271 | 271 | |
| 272 | READ16_HANDLER( hd68k_adsp_buffer_r ); | |
| 273 | WRITE16_HANDLER( hd68k_adsp_buffer_w ); | |
| 272 | DECLARE_READ16_HANDLER( hd68k_adsp_buffer_r ); | |
| 273 | DECLARE_WRITE16_HANDLER( hd68k_adsp_buffer_w ); | |
| 274 | 274 | |
| 275 | WRITE16_HANDLER( hd68k_adsp_control_w ); | |
| 276 | WRITE16_HANDLER( hd68k_adsp_irq_clear_w ); | |
| 277 | READ16_HANDLER( hd68k_adsp_irq_state_r ); | |
| 275 | DECLARE_WRITE16_HANDLER( hd68k_adsp_control_w ); | |
| 276 | DECLARE_WRITE16_HANDLER( hd68k_adsp_irq_clear_w ); | |
| 277 | DECLARE_READ16_HANDLER( hd68k_adsp_irq_state_r ); | |
| 278 | 278 | |
| 279 | READ16_HANDLER( hdadsp_special_r ); | |
| 280 | WRITE16_HANDLER( hdadsp_special_w ); | |
| 279 | DECLARE_READ16_HANDLER( hdadsp_special_r ); | |
| 280 | DECLARE_WRITE16_HANDLER( hdadsp_special_w ); | |
| 281 | 281 | |
| 282 | 282 | /* DS III board */ |
| 283 | WRITE16_HANDLER( hd68k_ds3_control_w ); | |
| 284 | READ16_HANDLER( hd68k_ds3_girq_state_r ); | |
| 285 | READ16_HANDLER( hd68k_ds3_sirq_state_r ); | |
| 286 | READ16_HANDLER( hd68k_ds3_gdata_r ); | |
| 287 | WRITE16_HANDLER( hd68k_ds3_gdata_w ); | |
| 288 | READ16_HANDLER( hd68k_ds3_sdata_r ); | |
| 289 | WRITE16_HANDLER( hd68k_ds3_sdata_w ); | |
| 283 | DECLARE_WRITE16_HANDLER( hd68k_ds3_control_w ); | |
| 284 | DECLARE_READ16_HANDLER( hd68k_ds3_girq_state_r ); | |
| 285 | DECLARE_READ16_HANDLER( hd68k_ds3_sirq_state_r ); | |
| 286 | DECLARE_READ16_HANDLER( hd68k_ds3_gdata_r ); | |
| 287 | DECLARE_WRITE16_HANDLER( hd68k_ds3_gdata_w ); | |
| 288 | DECLARE_READ16_HANDLER( hd68k_ds3_sdata_r ); | |
| 289 | DECLARE_WRITE16_HANDLER( hd68k_ds3_sdata_w ); | |
| 290 | 290 | |
| 291 | READ16_HANDLER( hdds3_special_r ); | |
| 292 | WRITE16_HANDLER( hdds3_special_w ); | |
| 293 | READ16_HANDLER( hdds3_control_r ); | |
| 294 | WRITE16_HANDLER( hdds3_control_w ); | |
| 291 | DECLARE_READ16_HANDLER( hdds3_special_r ); | |
| 292 | DECLARE_WRITE16_HANDLER( hdds3_special_w ); | |
| 293 | DECLARE_READ16_HANDLER( hdds3_control_r ); | |
| 294 | DECLARE_WRITE16_HANDLER( hdds3_control_w ); | |
| 295 | 295 | |
| 296 | READ16_HANDLER( hd68k_ds3_program_r ); | |
| 297 | WRITE16_HANDLER( hd68k_ds3_program_w ); | |
| 296 | DECLARE_READ16_HANDLER( hd68k_ds3_program_r ); | |
| 297 | DECLARE_WRITE16_HANDLER( hd68k_ds3_program_w ); | |
| 298 | 298 | |
| 299 | 299 | /* DSK board */ |
| 300 | 300 | void hddsk_update_pif(dsp32c_device &device, UINT32 pins); |
| 301 | WRITE16_HANDLER( hd68k_dsk_control_w ); | |
| 302 | READ16_HANDLER( hd68k_dsk_ram_r ); | |
| 303 | WRITE16_HANDLER( hd68k_dsk_ram_w ); | |
| 304 | READ16_HANDLER( hd68k_dsk_zram_r ); | |
| 305 | WRITE16_HANDLER( hd68k_dsk_zram_w ); | |
| 306 | READ16_HANDLER( hd68k_dsk_small_rom_r ); | |
| 307 | READ16_HANDLER( hd68k_dsk_rom_r ); | |
| 308 | WRITE16_HANDLER( hd68k_dsk_dsp32_w ); | |
| 309 | READ16_HANDLER( hd68k_dsk_dsp32_r ); | |
| 310 | WRITE32_HANDLER( rddsp32_sync0_w ); | |
| 311 | WRITE32_HANDLER( rddsp32_sync1_w ); | |
| 301 | DECLARE_WRITE16_HANDLER( hd68k_dsk_control_w ); | |
| 302 | DECLARE_READ16_HANDLER( hd68k_dsk_ram_r ); | |
| 303 | DECLARE_WRITE16_HANDLER( hd68k_dsk_ram_w ); | |
| 304 | DECLARE_READ16_HANDLER( hd68k_dsk_zram_r ); | |
| 305 | DECLARE_WRITE16_HANDLER( hd68k_dsk_zram_w ); | |
| 306 | DECLARE_READ16_HANDLER( hd68k_dsk_small_rom_r ); | |
| 307 | DECLARE_READ16_HANDLER( hd68k_dsk_rom_r ); | |
| 308 | DECLARE_WRITE16_HANDLER( hd68k_dsk_dsp32_w ); | |
| 309 | DECLARE_READ16_HANDLER( hd68k_dsk_dsp32_r ); | |
| 310 | DECLARE_WRITE32_HANDLER( rddsp32_sync0_w ); | |
| 311 | DECLARE_WRITE32_HANDLER( rddsp32_sync1_w ); | |
| 312 | 312 | |
| 313 | 313 | /* DSPCOM board */ |
| 314 | WRITE16_HANDLER( hddspcom_control_w ); | |
| 314 | DECLARE_WRITE16_HANDLER( hddspcom_control_w ); | |
| 315 | 315 | |
| 316 | WRITE16_HANDLER( rd68k_slapstic_w ); | |
| 317 | READ16_HANDLER( rd68k_slapstic_r ); | |
| 316 | DECLARE_WRITE16_HANDLER( rd68k_slapstic_w ); | |
| 317 | DECLARE_READ16_HANDLER( rd68k_slapstic_r ); | |
| 318 | 318 | |
| 319 | 319 | /* Game-specific protection */ |
| 320 | WRITE16_HANDLER( st68k_sloop_w ); | |
| 321 | READ16_HANDLER( st68k_sloop_r ); | |
| 322 | READ16_HANDLER( st68k_sloop_alt_r ); | |
| 323 | WRITE16_HANDLER( st68k_protosloop_w ); | |
| 324 | READ16_HANDLER( st68k_protosloop_r ); | |
| 320 | DECLARE_WRITE16_HANDLER( st68k_sloop_w ); | |
| 321 | DECLARE_READ16_HANDLER( st68k_sloop_r ); | |
| 322 | DECLARE_READ16_HANDLER( st68k_sloop_alt_r ); | |
| 323 | DECLARE_WRITE16_HANDLER( st68k_protosloop_w ); | |
| 324 | DECLARE_READ16_HANDLER( st68k_protosloop_r ); | |
| 325 | 325 | |
| 326 | 326 | /* GSP optimizations */ |
| 327 | READ16_HANDLER( hdgsp_speedup_r ); | |
| 328 | WRITE16_HANDLER( hdgsp_speedup1_w ); | |
| 329 | WRITE16_HANDLER( hdgsp_speedup2_w ); | |
| 330 | READ16_HANDLER( rdgsp_speedup1_r ); | |
| 331 | WRITE16_HANDLER( rdgsp_speedup1_w ); | |
| 327 | DECLARE_READ16_HANDLER( hdgsp_speedup_r ); | |
| 328 | DECLARE_WRITE16_HANDLER( hdgsp_speedup1_w ); | |
| 329 | DECLARE_WRITE16_HANDLER( hdgsp_speedup2_w ); | |
| 330 | DECLARE_READ16_HANDLER( rdgsp_speedup1_r ); | |
| 331 | DECLARE_WRITE16_HANDLER( rdgsp_speedup1_w ); | |
| 332 | 332 | |
| 333 | 333 | /* MSP optimizations */ |
| 334 | READ16_HANDLER( hdmsp_speedup_r ); | |
| 335 | WRITE16_HANDLER( hdmsp_speedup_w ); | |
| 334 | DECLARE_READ16_HANDLER( hdmsp_speedup_r ); | |
| 335 | DECLARE_WRITE16_HANDLER( hdmsp_speedup_w ); | |
| 336 | 336 | |
| 337 | 337 | /* ADSP optimizations */ |
| 338 | READ16_HANDLER( hdadsp_speedup_r ); | |
| 339 | READ16_HANDLER( hdds3_speedup_r ); | |
| 338 | DECLARE_READ16_HANDLER( hdadsp_speedup_r ); | |
| 339 | DECLARE_READ16_HANDLER( hdds3_speedup_r ); | |
| 340 | 340 | |
| 341 | 341 | |
| 342 | 342 | /*----------- defined in audio/harddriv.c -----------*/ |
| r17964 | r17965 | |
| 359 | 359 | void hdgsp_write_to_shiftreg(address_space &space, UINT32 address, UINT16 *shiftreg); |
| 360 | 360 | void hdgsp_read_from_shiftreg(address_space &space, UINT32 address, UINT16 *shiftreg); |
| 361 | 361 | |
| 362 | READ16_HANDLER( hdgsp_control_lo_r ); | |
| 363 | WRITE16_HANDLER( hdgsp_control_lo_w ); | |
| 364 | READ16_HANDLER( hdgsp_control_hi_r ); | |
| 365 | WRITE16_HANDLER( hdgsp_control_hi_w ); | |
| 362 | DECLARE_READ16_HANDLER( hdgsp_control_lo_r ); | |
| 363 | DECLARE_WRITE16_HANDLER( hdgsp_control_lo_w ); | |
| 364 | DECLARE_READ16_HANDLER( hdgsp_control_hi_r ); | |
| 365 | DECLARE_WRITE16_HANDLER( hdgsp_control_hi_w ); | |
| 366 | 366 | |
| 367 | READ16_HANDLER( hdgsp_vram_2bpp_r ); | |
| 368 | WRITE16_HANDLER( hdgsp_vram_1bpp_w ); | |
| 369 | WRITE16_HANDLER( hdgsp_vram_2bpp_w ); | |
| 367 | DECLARE_READ16_HANDLER( hdgsp_vram_2bpp_r ); | |
| 368 | DECLARE_WRITE16_HANDLER( hdgsp_vram_1bpp_w ); | |
| 369 | DECLARE_WRITE16_HANDLER( hdgsp_vram_2bpp_w ); | |
| 370 | 370 | |
| 371 | READ16_HANDLER( hdgsp_paletteram_lo_r ); | |
| 372 | WRITE16_HANDLER( hdgsp_paletteram_lo_w ); | |
| 373 | READ16_HANDLER( hdgsp_paletteram_hi_r ); | |
| 374 | WRITE16_HANDLER( hdgsp_paletteram_hi_w ); | |
| 371 | DECLARE_READ16_HANDLER( hdgsp_paletteram_lo_r ); | |
| 372 | DECLARE_WRITE16_HANDLER( hdgsp_paletteram_lo_w ); | |
| 373 | DECLARE_READ16_HANDLER( hdgsp_paletteram_hi_r ); | |
| 374 | DECLARE_WRITE16_HANDLER( hdgsp_paletteram_hi_w ); | |
| 375 | 375 | |
| 376 | 376 | void harddriv_scanline_driver(screen_device &screen, bitmap_ind16 &bitmap, int scanline, const tms34010_display_params *params); |
| 377 | 377 | void harddriv_scanline_multisync(screen_device &screen, bitmap_ind16 &bitmap, int scanline, const tms34010_display_params *params); |
| r17964 | r17965 | |
|---|---|---|
| 30 | 30 | |
| 31 | 31 | /*----------- defined in video/toobin.c -----------*/ |
| 32 | 32 | |
| 33 | WRITE16_HANDLER( toobin_paletteram_w ); | |
| 34 | WRITE16_HANDLER( toobin_intensity_w ); | |
| 35 | WRITE16_HANDLER( toobin_xscroll_w ); | |
| 36 | WRITE16_HANDLER( toobin_yscroll_w ); | |
| 37 | WRITE16_HANDLER( toobin_slip_w ); | |
| 33 | DECLARE_WRITE16_HANDLER( toobin_paletteram_w ); | |
| 34 | DECLARE_WRITE16_HANDLER( toobin_intensity_w ); | |
| 35 | DECLARE_WRITE16_HANDLER( toobin_xscroll_w ); | |
| 36 | DECLARE_WRITE16_HANDLER( toobin_yscroll_w ); | |
| 37 | DECLARE_WRITE16_HANDLER( toobin_slip_w ); | |
| 38 | 38 | |
| 39 | 39 | |
| 40 | 40 | SCREEN_UPDATE_RGB32( toobin ); |
| r17964 | r17965 | |
|---|---|---|
| 68 | 68 | |
| 69 | 69 | /*----------- defined in video/cyberbal.c -----------*/ |
| 70 | 70 | |
| 71 | READ16_HANDLER( cyberbal_paletteram_0_r ); | |
| 72 | READ16_HANDLER( cyberbal_paletteram_1_r ); | |
| 73 | WRITE16_HANDLER( cyberbal_paletteram_0_w ); | |
| 74 | WRITE16_HANDLER( cyberbal_paletteram_1_w ); | |
| 71 | DECLARE_READ16_HANDLER( cyberbal_paletteram_0_r ); | |
| 72 | DECLARE_READ16_HANDLER( cyberbal_paletteram_1_r ); | |
| 73 | DECLARE_WRITE16_HANDLER( cyberbal_paletteram_0_w ); | |
| 74 | DECLARE_WRITE16_HANDLER( cyberbal_paletteram_1_w ); | |
| 75 | 75 | |
| 76 | 76 | |
| 77 | 77 |
| r17964 | r17965 | |
|---|---|---|
| 535 | 535 | |
| 536 | 536 | void antic_reset(void); |
| 537 | 537 | |
| 538 | READ8_HANDLER ( atari_antic_r ); | |
| 539 | WRITE8_HANDLER ( atari_antic_w ); | |
| 538 | DECLARE_READ8_HANDLER ( atari_antic_r ); | |
| 539 | DECLARE_WRITE8_HANDLER ( atari_antic_w ); | |
| 540 | 540 | |
| 541 | 541 | #define ANTIC_RENDERER(name) void name(address_space &space, VIDEO *video) |
| 542 | 542 |
| r17964 | r17965 | |
|---|---|---|
| 35 | 35 | |
| 36 | 36 | /*----------- defined in video/badlands.c -----------*/ |
| 37 | 37 | |
| 38 | WRITE16_HANDLER( badlands_pf_bank_w ); | |
| 38 | DECLARE_WRITE16_HANDLER( badlands_pf_bank_w ); | |
| 39 | 39 | |
| 40 | 40 | |
| 41 | 41 | SCREEN_UPDATE_IND16( badlands ); |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | /*----------- defined in video/pk8000.c -----------*/ |
| 2 | 2 | |
| 3 | READ8_HANDLER(pk8000_video_color_r); | |
| 4 | WRITE8_HANDLER(pk8000_video_color_w); | |
| 5 | READ8_HANDLER(pk8000_text_start_r); | |
| 6 | WRITE8_HANDLER(pk8000_text_start_w); | |
| 7 | READ8_HANDLER(pk8000_chargen_start_r); | |
| 8 | WRITE8_HANDLER(pk8000_chargen_start_w); | |
| 9 | READ8_HANDLER(pk8000_video_start_r); | |
| 10 | WRITE8_HANDLER(pk8000_video_start_w); | |
| 11 | READ8_HANDLER(pk8000_color_start_r); | |
| 12 | WRITE8_HANDLER(pk8000_color_start_w); | |
| 13 | READ8_HANDLER(pk8000_color_r); | |
| 14 | WRITE8_HANDLER(pk8000_color_w); | |
| 3 | DECLARE_READ8_HANDLER(pk8000_video_color_r); | |
| 4 | DECLARE_WRITE8_HANDLER(pk8000_video_color_w); | |
| 5 | DECLARE_READ8_HANDLER(pk8000_text_start_r); | |
| 6 | DECLARE_WRITE8_HANDLER(pk8000_text_start_w); | |
| 7 | DECLARE_READ8_HANDLER(pk8000_chargen_start_r); | |
| 8 | DECLARE_WRITE8_HANDLER(pk8000_chargen_start_w); | |
| 9 | DECLARE_READ8_HANDLER(pk8000_video_start_r); | |
| 10 | DECLARE_WRITE8_HANDLER(pk8000_video_start_w); | |
| 11 | DECLARE_READ8_HANDLER(pk8000_color_start_r); | |
| 12 | DECLARE_WRITE8_HANDLER(pk8000_color_start_w); | |
| 13 | DECLARE_READ8_HANDLER(pk8000_color_r); | |
| 14 | DECLARE_WRITE8_HANDLER(pk8000_color_w); | |
| 15 | 15 | |
| 16 | 16 | extern UINT8 pk8000_video_mode; |
| 17 | 17 | extern UINT8 pk8000_video_enable; |
| r17964 | r17965 | |
|---|---|---|
| 21 | 21 | |
| 22 | 22 | /*----------- defined in video/klax.c -----------*/ |
| 23 | 23 | |
| 24 | WRITE16_HANDLER( klax_latch_w ); | |
| 24 | DECLARE_WRITE16_HANDLER( klax_latch_w ); | |
| 25 | 25 | |
| 26 | 26 | |
| 27 | 27 | SCREEN_UPDATE_IND16( klax ); |
| r17964 | r17965 | |
|---|---|---|
| 160 | 160 | |
| 161 | 161 | void namco_tilemap_draw( bitmap_ind16 &bitmap, const rectangle &cliprect, int pri ); |
| 162 | 162 | void namco_tilemap_invalidate( void ); |
| 163 | WRITE16_HANDLER( namco_tilemapvideoram16_w ); | |
| 164 | READ16_HANDLER( namco_tilemapvideoram16_r ); | |
| 165 | WRITE16_HANDLER( namco_tilemapcontrol16_w ); | |
| 166 | READ16_HANDLER( namco_tilemapcontrol16_r ); | |
| 163 | DECLARE_WRITE16_HANDLER( namco_tilemapvideoram16_w ); | |
| 164 | DECLARE_READ16_HANDLER( namco_tilemapvideoram16_r ); | |
| 165 | DECLARE_WRITE16_HANDLER( namco_tilemapcontrol16_w ); | |
| 166 | DECLARE_READ16_HANDLER( namco_tilemapcontrol16_r ); | |
| 167 | 167 | |
| 168 | READ32_HANDLER( namco_tilemapvideoram32_r ); | |
| 169 | WRITE32_HANDLER( namco_tilemapvideoram32_w ); | |
| 170 | READ32_HANDLER( namco_tilemapcontrol32_r ); | |
| 171 | WRITE32_HANDLER( namco_tilemapcontrol32_w ); | |
| 168 | DECLARE_READ32_HANDLER( namco_tilemapvideoram32_r ); | |
| 169 | DECLARE_WRITE32_HANDLER( namco_tilemapvideoram32_w ); | |
| 170 | DECLARE_READ32_HANDLER( namco_tilemapcontrol32_r ); | |
| 171 | DECLARE_WRITE32_HANDLER( namco_tilemapcontrol32_w ); | |
| 172 | 172 | |
| 173 | READ32_HANDLER( namco_tilemapvideoram32_le_r ); | |
| 174 | WRITE32_HANDLER( namco_tilemapvideoram32_le_w ); | |
| 175 | READ32_HANDLER( namco_tilemapcontrol32_le_r ); | |
| 176 | WRITE32_HANDLER( namco_tilemapcontrol32_le_w ); | |
| 173 | DECLARE_READ32_HANDLER( namco_tilemapvideoram32_le_r ); | |
| 174 | DECLARE_WRITE32_HANDLER( namco_tilemapvideoram32_le_w ); | |
| 175 | DECLARE_READ32_HANDLER( namco_tilemapcontrol32_le_r ); | |
| 176 | DECLARE_WRITE32_HANDLER( namco_tilemapcontrol32_le_w ); | |
| 177 | 177 | |
| 178 | 178 | /***********************************************************************************/ |
| 179 | 179 |
| r17964 | r17965 | |
|---|---|---|
| 93 | 93 | |
| 94 | 94 | /*----------- defined in video/redclash.c -----------*/ |
| 95 | 95 | |
| 96 | WRITE8_HANDLER( redclash_videoram_w ); | |
| 97 | WRITE8_HANDLER( redclash_gfxbank_w ); | |
| 98 | WRITE8_HANDLER( redclash_flipscreen_w ); | |
| 96 | DECLARE_WRITE8_HANDLER( redclash_videoram_w ); | |
| 97 | DECLARE_WRITE8_HANDLER( redclash_gfxbank_w ); | |
| 98 | DECLARE_WRITE8_HANDLER( redclash_flipscreen_w ); | |
| 99 | 99 | |
| 100 | WRITE8_HANDLER( redclash_star0_w ); | |
| 101 | WRITE8_HANDLER( redclash_star1_w ); | |
| 102 | WRITE8_HANDLER( redclash_star2_w ); | |
| 103 | WRITE8_HANDLER( redclash_star_reset_w ); | |
| 100 | DECLARE_WRITE8_HANDLER( redclash_star0_w ); | |
| 101 | DECLARE_WRITE8_HANDLER( redclash_star1_w ); | |
| 102 | DECLARE_WRITE8_HANDLER( redclash_star2_w ); | |
| 103 | DECLARE_WRITE8_HANDLER( redclash_star_reset_w ); | |
| 104 | 104 | |
| 105 | 105 | |
| 106 | 106 |
| r17964 | r17965 | |
|---|---|---|
| 55 | 55 | SCREEN_VBLANK( atarigx2 ); |
| 56 | 56 | SCREEN_UPDATE_IND16( atarigx2 ); |
| 57 | 57 | |
| 58 | WRITE16_HANDLER( atarigx2_mo_control_w ); | |
| 58 | DECLARE_WRITE16_HANDLER( atarigx2_mo_control_w ); | |
| 59 | 59 | |
| 60 | 60 | void atarigx2_scanline_update(screen_device &screen, int scanline); |
| r17964 | r17965 | |
|---|---|---|
| 63 | 63 | |
| 64 | 64 | /*----------- defined in machine/maniach.c -----------*/ |
| 65 | 65 | |
| 66 | READ8_HANDLER( maniach_68705_port_a_r ); | |
| 67 | WRITE8_HANDLER( maniach_68705_port_a_w ); | |
| 68 | READ8_HANDLER( maniach_68705_port_b_r ); | |
| 69 | WRITE8_HANDLER( maniach_68705_port_b_w ); | |
| 70 | READ8_HANDLER( maniach_68705_port_c_r ); | |
| 71 | WRITE8_HANDLER( maniach_68705_port_c_w ); | |
| 72 | WRITE8_HANDLER( maniach_68705_ddr_a_w ); | |
| 73 | WRITE8_HANDLER( maniach_68705_ddr_b_w ); | |
| 74 | WRITE8_HANDLER( maniach_68705_ddr_c_w ); | |
| 75 | WRITE8_HANDLER( maniach_mcu_w ); | |
| 76 | READ8_HANDLER( maniach_mcu_r ); | |
| 77 | READ8_HANDLER( maniach_mcu_status_r ); | |
| 66 | DECLARE_READ8_HANDLER( maniach_68705_port_a_r ); | |
| 67 | DECLARE_WRITE8_HANDLER( maniach_68705_port_a_w ); | |
| 68 | DECLARE_READ8_HANDLER( maniach_68705_port_b_r ); | |
| 69 | DECLARE_WRITE8_HANDLER( maniach_68705_port_b_w ); | |
| 70 | DECLARE_READ8_HANDLER( maniach_68705_port_c_r ); | |
| 71 | DECLARE_WRITE8_HANDLER( maniach_68705_port_c_w ); | |
| 72 | DECLARE_WRITE8_HANDLER( maniach_68705_ddr_a_w ); | |
| 73 | DECLARE_WRITE8_HANDLER( maniach_68705_ddr_b_w ); | |
| 74 | DECLARE_WRITE8_HANDLER( maniach_68705_ddr_c_w ); | |
| 75 | DECLARE_WRITE8_HANDLER( maniach_mcu_w ); | |
| 76 | DECLARE_READ8_HANDLER( maniach_mcu_r ); | |
| 77 | DECLARE_READ8_HANDLER( maniach_mcu_status_r ); | |
| 78 | 78 | |
| 79 | 79 | |
| 80 | 80 | /*----------- defined in video/matmania.c -----------*/ |
| r17964 | r17965 | |
|---|---|---|
| 47 | 47 | void archimedes_clear_irq_b(running_machine &machine, int mask); |
| 48 | 48 | void archimedes_clear_fiq(running_machine &machine, int mask); |
| 49 | 49 | |
| 50 | extern READ32_HANDLER(aristmk5_drame_memc_logical_r); | |
| 51 | extern READ32_HANDLER(archimedes_memc_logical_r); | |
| 52 | extern WRITE32_HANDLER(archimedes_memc_logical_w); | |
| 53 | extern READ32_HANDLER(archimedes_memc_r); | |
| 54 | extern WRITE32_HANDLER(archimedes_memc_w); | |
| 55 | extern WRITE32_HANDLER(archimedes_memc_page_w); | |
| 56 | extern READ32_HANDLER(archimedes_ioc_r); | |
| 57 | extern WRITE32_HANDLER(archimedes_ioc_w); | |
| 58 | extern READ32_HANDLER(archimedes_vidc_r); | |
| 59 | extern WRITE32_HANDLER(archimedes_vidc_w); | |
| 50 | extern DECLARE_READ32_HANDLER(aristmk5_drame_memc_logical_r); | |
| 51 | extern DECLARE_READ32_HANDLER(archimedes_memc_logical_r); | |
| 52 | extern DECLARE_WRITE32_HANDLER(archimedes_memc_logical_w); | |
| 53 | extern DECLARE_READ32_HANDLER(archimedes_memc_r); | |
| 54 | extern DECLARE_WRITE32_HANDLER(archimedes_memc_w); | |
| 55 | extern DECLARE_WRITE32_HANDLER(archimedes_memc_page_w); | |
| 56 | extern DECLARE_READ32_HANDLER(archimedes_ioc_r); | |
| 57 | extern DECLARE_WRITE32_HANDLER(archimedes_ioc_w); | |
| 58 | extern DECLARE_READ32_HANDLER(archimedes_vidc_r); | |
| 59 | extern DECLARE_WRITE32_HANDLER(archimedes_vidc_w); | |
| 60 | 60 | |
| 61 | 61 | extern UINT8 i2c_clk; |
| 62 | 62 | extern INT16 memc_pages[0x2000]; // the logical RAM area is 32 megs, and the smallest page size is 4k |
| r17964 | r17965 | |
|---|---|---|
| 167 | 167 | |
| 168 | 168 | |
| 169 | 169 | |
| 170 | READ8_HANDLER( theglobp_decrypt_rom ); | |
| 170 | DECLARE_READ8_HANDLER( theglobp_decrypt_rom ); | |
| 171 | 171 | |
| 172 | 172 | |
| 173 | 173 | /*----------- defined in machine/acitya.c -------------*/ |
| 174 | 174 | |
| 175 | 175 | |
| 176 | 176 | |
| 177 | READ8_HANDLER( acitya_decrypt_rom ); | |
| 177 | DECLARE_READ8_HANDLER( acitya_decrypt_rom ); |
| r17964 | r17965 | |
|---|---|---|
| 144 | 144 | |
| 145 | 145 | |
| 146 | 146 | |
| 147 | WRITE8_HANDLER( dec8_bac06_0_w ); | |
| 148 | WRITE8_HANDLER( dec8_bac06_1_w ); | |
| 149 | WRITE8_HANDLER( dec8_pf1_data_w ); | |
| 150 | READ8_HANDLER( dec8_pf1_data_r ); | |
| 147 | DECLARE_WRITE8_HANDLER( dec8_bac06_0_w ); | |
| 148 | DECLARE_WRITE8_HANDLER( dec8_bac06_1_w ); | |
| 149 | DECLARE_WRITE8_HANDLER( dec8_pf1_data_w ); | |
| 150 | DECLARE_READ8_HANDLER( dec8_pf1_data_r ); |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | /*----------- defined in machine/cchip.c -----------*/ |
| 2 | 2 | |
| 3 | 3 | MACHINE_RESET( cchip1 ); |
| 4 | READ16_HANDLER( cchip1_ctrl_r ); | |
| 5 | READ16_HANDLER( cchip1_ram_r ); | |
| 6 | WRITE16_HANDLER( cchip1_ctrl_w ); | |
| 7 | WRITE16_HANDLER( cchip1_bank_w ); | |
| 8 | WRITE16_HANDLER( cchip1_ram_w ); | |
| 4 | DECLARE_READ16_HANDLER( cchip1_ctrl_r ); | |
| 5 | DECLARE_READ16_HANDLER( cchip1_ram_r ); | |
| 6 | DECLARE_WRITE16_HANDLER( cchip1_ctrl_w ); | |
| 7 | DECLARE_WRITE16_HANDLER( cchip1_bank_w ); | |
| 8 | DECLARE_WRITE16_HANDLER( cchip1_ram_w ); | |
| 9 | 9 |
| r17964 | r17965 | |
|---|---|---|
| 53 | 53 | |
| 54 | 54 | /*----------- defined in machine/bonzeadv.c -----------*/ |
| 55 | 55 | |
| 56 | READ16_HANDLER( bonzeadv_cchip_ctrl_r ); | |
| 57 | READ16_HANDLER( bonzeadv_cchip_ram_r ); | |
| 58 | WRITE16_HANDLER( bonzeadv_cchip_ctrl_w ); | |
| 59 | WRITE16_HANDLER( bonzeadv_cchip_bank_w ); | |
| 60 | WRITE16_HANDLER( bonzeadv_cchip_ram_w ); | |
| 56 | DECLARE_READ16_HANDLER( bonzeadv_cchip_ctrl_r ); | |
| 57 | DECLARE_READ16_HANDLER( bonzeadv_cchip_ram_r ); | |
| 58 | DECLARE_WRITE16_HANDLER( bonzeadv_cchip_ctrl_w ); | |
| 59 | DECLARE_WRITE16_HANDLER( bonzeadv_cchip_bank_w ); | |
| 60 | DECLARE_WRITE16_HANDLER( bonzeadv_cchip_ram_w ); | |
| 61 | 61 | |
| 62 | 62 | |
| 63 | 63 | /*----------- defined in video/asuka.c -----------*/ |
| r17964 | r17965 | |
|---|---|---|
| 235 | 235 | return 0x0000; |
| 236 | 236 | } |
| 237 | 237 | |
| 238 | static WRITE8_HANDLER( bfm_sc4_reel4_w ); | |
| 238 | static DECLARE_WRITE8_HANDLER( bfm_sc4_reel4_w ); | |
| 239 | 239 | |
| 240 | 240 | WRITE8_MEMBER(sc4_state::mux_output_w) |
| 241 | 241 | { |
| r17964 | r17965 | |
| 561 | 561 | |
| 562 | 562 | bfm_sc4_write_serial_vfd(space.machine(), (data & 0x4000)?1:0, (data & 0x1000)?1:0, !(data & 0x2000)?1:0); |
| 563 | 563 | |
| 564 | bfm_sc4_reel3_w(space, 0, (data&0x0f00)>>8); | |
| 564 | bfm_sc4_reel3_w(space, 0, (data&0x0f00)>>8, 0xff); | |
| 565 | 565 | } |
| 566 | 566 | |
| 567 | 567 | } |
| r17964 | r17965 | |
|---|---|---|
| 273 | 273 | |
| 274 | 274 | |
| 275 | 275 | |
| 276 | static READ16_HANDLER( characteriser16_r ); | |
| 277 | static WRITE16_HANDLER( characteriser16_w ); | |
| 276 | static DECLARE_READ16_HANDLER( characteriser16_r ); | |
| 277 | static DECLARE_WRITE16_HANDLER( characteriser16_w ); | |
| 278 | 278 | |
| 279 | static READ16_HANDLER( bwb_characteriser16_r ); | |
| 280 | static WRITE16_HANDLER( bwb_characteriser16_w ); | |
| 279 | static DECLARE_READ16_HANDLER( bwb_characteriser16_r ); | |
| 280 | static DECLARE_WRITE16_HANDLER( bwb_characteriser16_w ); | |
| 281 | 281 | |
| 282 | 282 | /************************************* |
| 283 | 283 | * |
| r17964 | r17965 | |
|---|---|---|
| 347 | 347 | * |
| 348 | 348 | *************************************/ |
| 349 | 349 | |
| 350 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 351 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 350 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 351 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 352 | 352 | |
| 353 | 353 | static Z80DMA_INTERFACE( dk3_dma ) |
| 354 | 354 | { |
| r17964 | r17965 | |
|---|---|---|
| 101 | 101 | * |
| 102 | 102 | *************************************/ |
| 103 | 103 | |
| 104 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 105 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 104 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 105 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 106 | 106 | |
| 107 | 107 | static Z80DMA_INTERFACE( mario_dma ) |
| 108 | 108 | { |
| r17964 | r17965 | |
|---|---|---|
| 97 | 97 | decocass_objectram_w(space, offset, data); |
| 98 | 98 | } |
| 99 | 99 | |
| 100 | static WRITE8_HANDLER( mirrorvideoram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data); } | |
| 101 | static WRITE8_HANDLER( mirrorcolorram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data); } | |
| 100 | static WRITE8_HANDLER( mirrorvideoram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data, mem_mask); } | |
| 101 | static WRITE8_HANDLER( mirrorcolorram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data, mem_mask); } | |
| 102 | 102 | |
| 103 | 103 | static READ8_HANDLER( mirrorvideoram_r ) |
| 104 | 104 | { |
| r17964 | r17965 | |
|---|---|---|
| 41 | 41 | |
| 42 | 42 | |
| 43 | 43 | |
| 44 | READ16_HANDLER( m68340_internal_sim_r ); | |
| 45 | WRITE16_HANDLER( m68340_internal_sim_w ); | |
| 46 | READ32_HANDLER( m68340_internal_sim_cs_r ); | |
| 47 | WRITE32_HANDLER( m68340_internal_sim_cs_w ); | |
| 48 | READ8_HANDLER( m68340_internal_sim_ports_r ); | |
| 49 | WRITE8_HANDLER( m68340_internal_sim_ports_w ); | |
| 44 | DECLARE_READ16_HANDLER( m68340_internal_sim_r ); | |
| 45 | DECLARE_WRITE16_HANDLER( m68340_internal_sim_w ); | |
| 46 | DECLARE_READ32_HANDLER( m68340_internal_sim_cs_r ); | |
| 47 | DECLARE_WRITE32_HANDLER( m68340_internal_sim_cs_w ); | |
| 48 | DECLARE_READ8_HANDLER( m68340_internal_sim_ports_r ); | |
| 49 | DECLARE_WRITE8_HANDLER( m68340_internal_sim_ports_w ); | |
| 50 | 50 | |
| 51 | 51 | |
| 52 | 52 |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | |
| 2 | READ32_HANDLER( m68340_internal_serial_r ); | |
| 3 | WRITE32_HANDLER( m68340_internal_serial_w ); | |
| 2 | DECLARE_READ32_HANDLER( m68340_internal_serial_r ); | |
| 3 | DECLARE_WRITE32_HANDLER( m68340_internal_serial_w ); | |
| 4 | 4 | |
| 5 | 5 | class m68340_serial |
| 6 | 6 | { |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | /* 68307 SIM module */ |
| 2 | 2 | |
| 3 | READ16_HANDLER( m68307_internal_sim_r ); | |
| 4 | WRITE16_HANDLER( m68307_internal_sim_w ); | |
| 3 | DECLARE_READ16_HANDLER( m68307_internal_sim_r ); | |
| 4 | DECLARE_WRITE16_HANDLER( m68307_internal_sim_w ); | |
| 5 | 5 | |
| 6 | 6 | /* ports */ |
| 7 | 7 | #define m68307SIM_PACNT (0x10) |
| r17964 | r17965 | |
|---|---|---|
| 4 | 4 | #define m68307BUS_MBSR (0x07) |
| 5 | 5 | #define m68307BUS_MBDR (0x09) |
| 6 | 6 | |
| 7 | READ8_HANDLER( m68307_internal_mbus_r ); | |
| 8 | WRITE8_HANDLER( m68307_internal_mbus_w ); | |
| 7 | DECLARE_READ8_HANDLER( m68307_internal_mbus_r ); | |
| 8 | DECLARE_WRITE8_HANDLER( m68307_internal_mbus_w ); | |
| 9 | 9 | |
| 10 | 10 | class m68307_mbus |
| 11 | 11 | { |
| r17964 | r17965 | |
|---|---|---|
| 18 | 18 | #define m68307SER_UOP0 (0x1f) |
| 19 | 19 | |
| 20 | 20 | |
| 21 | READ8_HANDLER( m68307_internal_serial_r ); | |
| 22 | WRITE8_HANDLER( m68307_internal_serial_w ); | |
| 21 | DECLARE_READ8_HANDLER( m68307_internal_serial_r ); | |
| 22 | DECLARE_WRITE8_HANDLER( m68307_internal_serial_w ); | |
| 23 | 23 | |
| 24 | 24 | class m68307_serial |
| 25 | 25 | { |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | |
| 2 | READ32_HANDLER( m68340_internal_dma_r ); | |
| 3 | WRITE32_HANDLER( m68340_internal_dma_w ); | |
| 2 | DECLARE_READ32_HANDLER( m68340_internal_dma_r ); | |
| 3 | DECLARE_WRITE32_HANDLER( m68340_internal_dma_w ); | |
| 4 | 4 | |
| 5 | 5 | class m68340_dma |
| 6 | 6 | { |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | |
| 2 | READ32_HANDLER( m68340_internal_timer_r ); | |
| 3 | WRITE32_HANDLER( m68340_internal_timer_w ); | |
| 2 | DECLARE_READ32_HANDLER( m68340_internal_timer_r ); | |
| 3 | DECLARE_WRITE32_HANDLER( m68340_internal_timer_w ); | |
| 4 | 4 | |
| 5 | 5 | class m68340_timer |
| 6 | 6 | { |
| r17964 | r17965 | |
|---|---|---|
| 1 | 1 | |
| 2 | READ16_HANDLER( m68307_internal_timer_r ); | |
| 3 | WRITE16_HANDLER( m68307_internal_timer_w ); | |
| 2 | DECLARE_READ16_HANDLER( m68307_internal_timer_r ); | |
| 3 | DECLARE_WRITE16_HANDLER( m68307_internal_timer_w ); | |
| 4 | 4 | |
| 5 | 5 | #define m68307TIMER_TMR (0x0) |
| 6 | 6 | #define m68307TIMER_TRR (0x1) |
| r17964 | r17965 | |
|---|---|---|
| 222 | 222 | |
| 223 | 223 | |
| 224 | 224 | /* Reads & writes to the 34010 I/O registers; place at 0xc0000000 */ |
| 225 | WRITE16_HANDLER( tms34010_io_register_w ); | |
| 226 | READ16_HANDLER( tms34010_io_register_r ); | |
| 225 | DECLARE_WRITE16_HANDLER( tms34010_io_register_w ); | |
| 226 | DECLARE_READ16_HANDLER( tms34010_io_register_r ); | |
| 227 | 227 | |
| 228 | 228 | /* Reads & writes to the 34020 I/O registers; place at 0xc0000000 */ |
| 229 | WRITE16_HANDLER( tms34020_io_register_w ); | |
| 230 | READ16_HANDLER( tms34020_io_register_r ); | |
| 229 | DECLARE_WRITE16_HANDLER( tms34020_io_register_w ); | |
| 230 | DECLARE_READ16_HANDLER( tms34020_io_register_r ); | |
| 231 | 231 | |
| 232 | 232 | |
| 233 | 233 | /* Use this macro in the memory definitions to specify bit-based addresses */ |
| r17964 | r17965 | |
|---|---|---|
| 235 | 235 | /* Port C Dtaa Register (PCD) */ |
| 236 | 236 | void PCD_set(dsp56k_core* cpustate, UINT16 value); |
| 237 | 237 | |
| 238 | READ16_HANDLER( peripheral_register_r ); | |
| 239 | WRITE16_HANDLER( peripheral_register_w ); | |
| 240 | READ16_HANDLER( program_r ); | |
| 241 | WRITE16_HANDLER( program_w ); | |
| 238 | DECLARE_READ16_HANDLER( peripheral_register_r ); | |
| 239 | DECLARE_WRITE16_HANDLER( peripheral_register_w ); | |
| 240 | DECLARE_READ16_HANDLER( program_r ); | |
| 241 | DECLARE_WRITE16_HANDLER( program_w ); | |
| 242 | 242 | |
| 243 | 243 | } // namespace DSP56K |
| 244 | 244 |
| r17964 | r17965 | |
|---|---|---|
| 87 | 87 | psx_sio port[2]; |
| 88 | 88 | }; |
| 89 | 89 | |
| 90 | WRITE32_HANDLER( psx_sio_w ); | |
| 91 | READ32_HANDLER( psx_sio_r ); | |
| 90 | DECLARE_WRITE32_HANDLER( psx_sio_w ); | |
| 91 | DECLARE_READ32_HANDLER( psx_sio_r ); | |
| 92 | 92 | |
| 93 | 93 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 67 | 67 | DECLARE_LEGACY_CPU_DEVICE(SH1, sh1); |
| 68 | 68 | DECLARE_LEGACY_CPU_DEVICE(SH2, sh2); |
| 69 | 69 | |
| 70 | WRITE32_HANDLER( sh2_internal_w ); | |
| 71 | READ32_HANDLER( sh2_internal_r ); | |
| 70 | DECLARE_WRITE32_HANDLER( sh2_internal_w ); | |
| 71 | DECLARE_READ32_HANDLER( sh2_internal_r ); | |
| 72 | 72 | |
| 73 | 73 | void sh2_set_ftcsr_read_callback(device_t *device, void (*callback)(UINT32)); |
| 74 | 74 | void sh2_set_frt_input(device_t *device, int state); |
| r17964 | r17965 | |
|---|---|---|
| 320 | 320 | UINT32 sh4_getsqremap(sh4_state *sh4, UINT32 address); |
| 321 | 321 | void sh4_handler_ipra_w(sh4_state *sh4, UINT32 data, UINT32 mem_mask); |
| 322 | 322 | |
| 323 | READ64_HANDLER( sh4_tlb_r ); | |
| 324 | WRITE64_HANDLER( sh4_tlb_w ); | |
| 323 | DECLARE_READ64_HANDLER( sh4_tlb_r ); | |
| 324 | DECLARE_WRITE64_HANDLER( sh4_tlb_w ); | |
| 325 | 325 | |
| 326 | 326 | |
| 327 | 327 | INLINE void sh4_check_pending_irq(sh4_state *sh4, const char *message) // look for highest priority active exception and handle it |
| r17964 | r17965 | |
|---|---|---|
| 152 | 152 | DECLARE_LEGACY_CPU_DEVICE(SH4LE, sh4); |
| 153 | 153 | DECLARE_LEGACY_CPU_DEVICE(SH4BE, sh4be); |
| 154 | 154 | |
| 155 | WRITE32_HANDLER( sh4_internal_w ); | |
| 156 | READ32_HANDLER( sh4_internal_r ); | |
| 155 | DECLARE_WRITE32_HANDLER( sh4_internal_w ); | |
| 156 | DECLARE_READ32_HANDLER( sh4_internal_r ); | |
| 157 | 157 | |
| 158 | WRITE32_HANDLER( sh3_internal_w ); | |
| 159 | READ32_HANDLER( sh3_internal_r ); | |
| 158 | DECLARE_WRITE32_HANDLER( sh3_internal_w ); | |
| 159 | DECLARE_READ32_HANDLER( sh3_internal_r ); | |
| 160 | 160 | |
| 161 | WRITE32_HANDLER( sh3_internal_high_w ); | |
| 162 | READ32_HANDLER( sh3_internal_high_r ); | |
| 161 | DECLARE_WRITE32_HANDLER( sh3_internal_high_w ); | |
| 162 | DECLARE_READ32_HANDLER( sh3_internal_high_r ); | |
| 163 | 163 | |
| 164 | 164 | |
| 165 | 165 | void sh4_set_frt_input(device_t *device, int state); |
| r17964 | r17965 | |
|---|---|---|
| 85 | 85 | INLINE uint g65816i_read_8_vector(g65816i_cpu_struct *cpustate, uint address) |
| 86 | 86 | { |
| 87 | 87 | if (READ_VECTOR) |
| 88 | return READ_VECTOR(*cpustate->program, address); | |
| 88 | return READ_VECTOR(*cpustate->program, address, 0xff); | |
| 89 | 89 | else |
| 90 | 90 | return g65816i_read_8_normal(cpustate, address); |
| 91 | 91 | } |
| r17964 | r17965 | |
|---|---|---|
| 126 | 126 | #define SETZ pSR |= SR_Z |
| 127 | 127 | #define SETN pSR |= SR_N |
| 128 | 128 | |
| 129 | static READ8_HANDLER( tms7000_internal_r ); | |
| 130 | static WRITE8_HANDLER( tms7000_internal_w ); | |
| 131 | static READ8_HANDLER( tms70x0_pf_r ); | |
| 132 | static WRITE8_HANDLER( tms70x0_pf_w ); | |
| 129 | static DECLARE_READ8_HANDLER( tms7000_internal_r ); | |
| 130 | static DECLARE_WRITE8_HANDLER( tms7000_internal_w ); | |
| 131 | static DECLARE_READ8_HANDLER( tms70x0_pf_r ); | |
| 132 | static DECLARE_WRITE8_HANDLER( tms70x0_pf_w ); | |
| 133 | 133 | |
| 134 | 134 | static ADDRESS_MAP_START(tms7000_mem, AS_PROGRAM, 8, legacy_cpu_device ) |
| 135 | 135 | AM_RANGE(0x0000, 0x007f) AM_READWRITE_LEGACY(tms7000_internal_r, tms7000_internal_w) /* tms7000 internal RAM */ |
| r17964 | r17965 | |
|---|---|---|
| 71 | 71 | }; |
| 72 | 72 | |
| 73 | 73 | /* accessor for the internal ROM */ |
| 74 | extern READ16_HANDLER(ti990_10_internal_r); | |
| 74 | extern DECLARE_READ16_HANDLER(ti990_10_internal_r); | |
| 75 | 75 | |
| 76 | 76 | /* CRU accessor for the mapper registers (R12 base 0x1fa0) */ |
| 77 | extern READ8_HANDLER(ti990_10_mapper_cru_r); | |
| 78 | extern WRITE8_HANDLER(ti990_10_mapper_cru_w); | |
| 77 | extern DECLARE_READ8_HANDLER(ti990_10_mapper_cru_r); | |
| 78 | extern DECLARE_WRITE8_HANDLER(ti990_10_mapper_cru_w); | |
| 79 | 79 | /* CRU accessor for the error interrupt register (R12 base 0x1fc0) */ |
| 80 | extern READ8_HANDLER(ti990_10_eir_cru_r); | |
| 81 | extern WRITE8_HANDLER(ti990_10_eir_cru_w); | |
| 80 | extern DECLARE_READ8_HANDLER(ti990_10_eir_cru_r); | |
| 81 | extern DECLARE_WRITE8_HANDLER(ti990_10_eir_cru_w); | |
| 82 | 82 | |
| 83 | 83 | |
| 84 | 84 | |
| r17964 | r17965 | |
| 162 | 162 | }; |
| 163 | 163 | |
| 164 | 164 | /* accessor for the first 252 bytes of internal RAM */ |
| 165 | extern READ8_HANDLER(tms9995_internal1_r); | |
| 166 | extern WRITE8_HANDLER(tms9995_internal1_w); | |
| 165 | extern DECLARE_READ8_HANDLER(tms9995_internal1_r); | |
| 166 | extern DECLARE_WRITE8_HANDLER(tms9995_internal1_w); | |
| 167 | 167 | /* accessors for the last 4 bytes of internal RAM */ |
| 168 | extern READ8_HANDLER(tms9995_internal2_r); | |
| 169 | extern WRITE8_HANDLER(tms9995_internal2_w); | |
| 168 | extern DECLARE_READ8_HANDLER(tms9995_internal2_r); | |
| 169 | extern DECLARE_WRITE8_HANDLER(tms9995_internal2_w); | |
| 170 | 170 | |
| 171 | 171 | |
| 172 | 172 |
| r17964 | r17965 | |
|---|---|---|
| 75 | 75 | |
| 76 | 76 | DECLARE_LEGACY_CPU_DEVICE(H6280, h6280); |
| 77 | 77 | |
| 78 | READ8_HANDLER( h6280_irq_status_r ); | |
| 79 | WRITE8_HANDLER( h6280_irq_status_w ); | |
| 78 | DECLARE_READ8_HANDLER( h6280_irq_status_r ); | |
| 79 | DECLARE_WRITE8_HANDLER( h6280_irq_status_w ); | |
| 80 | 80 | |
| 81 | READ8_HANDLER( h6280_timer_r ); | |
| 82 | WRITE8_HANDLER( h6280_timer_w ); | |
| 81 | DECLARE_READ8_HANDLER( h6280_timer_r ); | |
| 82 | DECLARE_WRITE8_HANDLER( h6280_timer_w ); | |
| 83 | 83 | |
| 84 | 84 | /* functions for use by the PSG and joypad port only! */ |
| 85 | 85 | UINT8 h6280io_get_buffer(device_t*); |
| r17964 | r17965 | |
|---|---|---|
| 63 | 63 | DECLARE_LEGACY_CPU_DEVICE(HD6303Y, hd6303y); |
| 64 | 64 | |
| 65 | 65 | |
| 66 | READ8_HANDLER( m6801_io_r ); | |
| 67 | WRITE8_HANDLER( m6801_io_w ); | |
| 66 | DECLARE_READ8_HANDLER( m6801_io_r ); | |
| 67 | DECLARE_WRITE8_HANDLER( m6801_io_w ); | |
| 68 | 68 | |
| 69 | 69 | CPU_DISASSEMBLE( m6800 ); |
| 70 | 70 | CPU_DISASSEMBLE( m6801 ); |
| r17964 | r17965 | |
|---|---|---|
| 393 | 393 | if (desc.readdevice != NULL) |
| 394 | 394 | { |
| 395 | 395 | m_helper.read8_device = desc.readdevice; |
| 396 | *static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_read8, desc.name, this); | |
| 396 | *static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_read8device, desc.name, this); | |
| 397 | 397 | } |
| 398 | 398 | else |
| 399 | 399 | { |
| r17964 | r17965 | |
| 404 | 404 | |
| 405 | 405 | case DEVCB_TYPE_LEGACY_SPACE: |
| 406 | 406 | m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device); |
| 407 | *static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(desc.readspace, desc.name, m_object.space); | |
| 407 | m_helper.read8_space = desc.readspace; | |
| 408 | *static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_read8space, desc.name, this); | |
| 408 | 409 | break; |
| 409 | 410 | |
| 410 | 411 | case DEVCB_TYPE_CONSTANT: |
| r17964 | r17965 | |
| 420 | 421 | // value to an 8-bit value |
| 421 | 422 | //------------------------------------------------- |
| 422 | 423 | |
| 423 | UINT8 devcb_resolved_read8::from_port(offs_t offset) | |
| 424 | UINT8 devcb_resolved_read8::from_port(offs_t offset, UINT8 mem_mask) | |
| 424 | 425 | { |
| 425 | 426 | return m_object.port->read(); |
| 426 | 427 | } |
| 427 | 428 | |
| 428 | 429 | |
| 429 | 430 | //------------------------------------------------- |
| 430 | // from_read8 - helper to convert from a device | |
| 431 | // from_read8space - helper to convert from a device | |
| 431 | 432 | // line read value to an 8-bit value |
| 432 | 433 | //------------------------------------------------- |
| 433 | 434 | |
| 434 | UINT8 devcb_resolved_read8::from_read8(offs_t offset) | |
| 435 | UINT8 devcb_resolved_read8::from_read8space(offs_t offset, UINT8 mem_mask) | |
| 435 | 436 | { |
| 436 | 437 | return (*m_helper.read8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, 0xff); |
| 437 | 438 | } |
| 438 | 439 | |
| 439 | 440 | |
| 440 | 441 | //------------------------------------------------- |
| 442 | // from_read8device - helper to convert from a device | |
| 443 | // line read value to an 8-bit value | |
| 444 | //------------------------------------------------- | |
| 445 | ||
| 446 | UINT8 devcb_resolved_read8::from_read8device(offs_t offset, UINT8 mem_mask) | |
| 447 | { | |
| 448 | return (*m_helper.read8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, mem_mask); | |
| 449 | } | |
| 450 | ||
| 451 | ||
| 452 | //------------------------------------------------- | |
| 441 | 453 | // from_readline - helper to convert from a device |
| 442 | 454 | // line read value to an 8-bit value |
| 443 | 455 | //------------------------------------------------- |
| 444 | 456 | |
| 445 | UINT8 devcb_resolved_read8::from_readline(offs_t offset) | |
| 457 | UINT8 devcb_resolved_read8::from_readline(offs_t offset, UINT8 mem_mask) | |
| 446 | 458 | { |
| 447 | 459 | return (*m_helper.read_line)(m_object.device); |
| 448 | 460 | } |
| r17964 | r17965 | |
| 453 | 465 | // constant value to an 8-bit value |
| 454 | 466 | //------------------------------------------------- |
| 455 | 467 | |
| 456 | UINT8 devcb_resolved_read8::from_constant(offs_t offset) | |
| 468 | UINT8 devcb_resolved_read8::from_constant(offs_t offset, UINT8 mem_mask) | |
| 457 | 469 | { |
| 458 | 470 | return m_object.constant; |
| 459 | 471 | } |
| r17964 | r17965 | |
| 500 | 512 | if (desc.writedevice != NULL) |
| 501 | 513 | { |
| 502 | 514 | m_helper.write8_device = desc.writedevice; |
| 503 | *static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(&devcb_resolved_write8::to_write8, desc.name, this); | |
| 515 | *static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(&devcb_resolved_write8::to_write8device, desc.name, this); | |
| 504 | 516 | } |
| 505 | 517 | else |
| 506 | 518 | { |
| r17964 | r17965 | |
| 511 | 523 | |
| 512 | 524 | case DEVCB_TYPE_LEGACY_SPACE: |
| 513 | 525 | m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device); |
| 514 | *static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(desc.writespace, desc.name, m_object.space); | |
| 526 | m_helper.write8_space = desc.writespace; | |
| 527 | *static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(&devcb_resolved_write8::to_write8space, desc.name, this); | |
| 515 | 528 | break; |
| 516 | 529 | |
| 517 | 530 | case DEVCB_TYPE_INPUT_LINE: |
| r17964 | r17965 | |
| 527 | 540 | // to_null - helper to handle a NULL write |
| 528 | 541 | //------------------------------------------------- |
| 529 | 542 | |
| 530 | void devcb_resolved_write8::to_null(offs_t offset, UINT8 data) | |
| 543 | void devcb_resolved_write8::to_null(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 531 | 544 | { |
| 532 | 545 | } |
| 533 | 546 | |
| r17964 | r17965 | |
| 537 | 550 | // value from a line value |
| 538 | 551 | //------------------------------------------------- |
| 539 | 552 | |
| 540 | void devcb_resolved_write8::to_port(offs_t offset, UINT8 data) | |
| 553 | void devcb_resolved_write8::to_port(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 541 | 554 | { |
| 542 | m_object.port->write(data, | |
| 555 | m_object.port->write(data, mem_mask); | |
| 543 | 556 | } |
| 544 | 557 | |
| 545 | 558 | |
| 546 | 559 | //------------------------------------------------- |
| 547 | // to_write8 - helper to convert to an 8-bit | |
| 560 | // to_write8space - helper to convert to an 8-bit | |
| 548 | 561 | // memory read value from a line value |
| 549 | 562 | //------------------------------------------------- |
| 550 | 563 | |
| 551 | void devcb_resolved_write8::to_write8(offs_t offset, UINT8 data) | |
| 564 | void devcb_resolved_write8::to_write8space(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 552 | 565 | { |
| 553 | (*m_helper.write8_ | |
| 566 | (*m_helper.write8_spa | |
| 554 | 567 | } |
| 555 | 568 | |
| 556 | 569 | |
| 557 | 570 | //------------------------------------------------- |
| 571 | // to_write8device - helper to convert to an 8-bit | |
| 572 | // memory read value from a line value | |
| 573 | //------------------------------------------------- | |
| 574 | ||
| 575 | void devcb_resolved_write8::to_write8device(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 576 | { | |
| 577 | (*m_helper.write8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, data, mem_mask); | |
| 578 | } | |
| 579 | ||
| 580 | ||
| 581 | //------------------------------------------------- | |
| 558 | 582 | // to_write8 - helper to convert to an 8-bit |
| 559 | 583 | // memory read value from a line value |
| 560 | 584 | //------------------------------------------------- |
| 561 | 585 | |
| 562 | void devcb_resolved_write8::to_writeline(offs_t offset, UINT8 data) | |
| 586 | void devcb_resolved_write8::to_writeline(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 563 | 587 | { |
| 564 | 588 | (*m_helper.write_line)(m_object.device, (data & 1) ? ASSERT_LINE : CLEAR_LINE); |
| 565 | 589 | } |
| r17964 | r17965 | |
| 570 | 594 | // value from a line value |
| 571 | 595 | //------------------------------------------------- |
| 572 | 596 | |
| 573 | void devcb_resolved_write8::to_input(offs_t offset, UINT8 data) | |
| 597 | void devcb_resolved_write8::to_input(offs_t offset, UINT8 data, UINT8 mem_mask) | |
| 574 | 598 | { |
| 575 | 599 | m_object.execute->set_input_line(m_helper.input_line, (data & 1) ? ASSERT_LINE : CLEAR_LINE); |
| 576 | 600 | } |
| r17964 | r17965 | |
|---|---|---|
| 66 | 66 | void tms34061_w(address_space &space, int col, int row, int func, UINT8 data); |
| 67 | 67 | |
| 68 | 68 | /* latch settings */ |
| 69 | READ8_HANDLER( tms34061_latch_r ); | |
| 70 | WRITE8_HANDLER( tms34061_latch_w ); | |
| 69 | DECLARE_READ8_HANDLER( tms34061_latch_r ); | |
| 70 | DECLARE_WRITE8_HANDLER( tms34061_latch_w ); | |
| 71 | 71 | |
| 72 | 72 | /* video update handling */ |
| 73 | 73 | void tms34061_get_display_state(struct tms34061_display *state); |
| r17964 | r17965 | |
|---|---|---|
| 168 | 168 | #define CGA_CHIPSET_PARADISE 0x80 /* Paradise (used in PC1640) */ |
| 169 | 169 | |
| 170 | 170 | |
| 171 | static READ8_HANDLER( pc_cga8_r ); | |
| 172 | static WRITE8_HANDLER( pc_cga8_w ); | |
| 171 | static DECLARE_READ8_HANDLER( pc_cga8_r ); | |
| 172 | static DECLARE_WRITE8_HANDLER( pc_cga8_w ); | |
| 173 | 173 | static MC6845_UPDATE_ROW( cga_update_row ); |
| 174 | 174 | static WRITE_LINE_DEVICE_HANDLER( cga_hsync_changed ); |
| 175 | 175 | static WRITE_LINE_DEVICE_HANDLER( cga_vsync_changed ); |
| r17964 | r17965 | |
|---|---|---|
| 20 | 20 | |
| 21 | 21 | |
| 22 | 22 | /* Used in machine/pc.c */ |
| 23 | READ16_HANDLER( pc1512_16le_r ); | |
| 24 | WRITE16_HANDLER( pc1512_16le_w ); | |
| 25 | WRITE16_HANDLER( pc1512_videoram16le_w ); | |
| 23 | DECLARE_READ16_HANDLER( pc1512_16le_r ); | |
| 24 | DECLARE_WRITE16_HANDLER( pc1512_16le_w ); | |
| 25 | DECLARE_WRITE16_HANDLER( pc1512_videoram16le_w ); | |
| 26 | 26 | |
| 27 | 27 | MACHINE_CONFIG_EXTERN( pcvideo_poisk2 ); |
| 28 | 28 |
| r17964 | r17965 | |
|---|---|---|
| 1533 | 1533 | { |
| 1534 | 1534 | UINT8 data = 0xff; |
| 1535 | 1535 | if (CRTC_PORT_ADDR==0x3b0) |
| 1536 | data=vga_crtc_r(space, offset); | |
| 1536 | data=vga_crtc_r(space, offset, mem_mask); | |
| 1537 | 1537 | return data; |
| 1538 | 1538 | } |
| 1539 | 1539 | |
| r17964 | r17965 | |
| 1607 | 1607 | switch ((vga.miscellaneous_output>>2)&3) |
| 1608 | 1608 | { |
| 1609 | 1609 | case 3: |
| 1610 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0) & 0x01) | |
| 1610 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0, mem_mask) & 0x01) | |
| 1611 | 1611 | data |= 0x10; |
| 1612 | 1612 | break; |
| 1613 | 1613 | case 2: |
| 1614 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0) & 0x02) | |
| 1614 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0, mem_mask) & 0x02) | |
| 1615 | 1615 | data |= 0x10; |
| 1616 | 1616 | break; |
| 1617 | 1617 | case 1: |
| 1618 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0) & 0x04) | |
| 1618 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0, mem_mask) & 0x04) | |
| 1619 | 1619 | data |= 0x10; |
| 1620 | 1620 | break; |
| 1621 | 1621 | case 0: |
| 1622 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0) & 0x08) | |
| 1622 | if (vga.read_dipswitch && vga.read_dipswitch(space, 0, mem_mask) & 0x08) | |
| 1623 | 1623 | data |= 0x10; |
| 1624 | 1624 | break; |
| 1625 | 1625 | } |
| r17964 | r17965 | |
| 1697 | 1697 | { |
| 1698 | 1698 | UINT8 data = 0xff; |
| 1699 | 1699 | if (CRTC_PORT_ADDR == 0x3d0) |
| 1700 | data = vga_crtc_r(space, offset); | |
| 1700 | data = vga_crtc_r(space, offset, mem_mask); | |
| 1701 | 1701 | if(offset == 8) |
| 1702 | 1702 | { |
| 1703 | 1703 | logerror("VGA: 0x3d8 read at %08x\n",space.device().safe_pc()); |
| r17964 | r17965 | |
| 1713 | 1713 | logerror("vga_port_03b0_w(): port=0x%04x data=0x%02x\n", offset + 0x3b0, data); |
| 1714 | 1714 | |
| 1715 | 1715 | if (CRTC_PORT_ADDR == 0x3b0) |
| 1716 | vga_crtc_w(space, offset, data); | |
| 1716 | vga_crtc_w(space, offset, data, mem_mask); | |
| 1717 | 1717 | } |
| 1718 | 1718 | |
| 1719 | 1719 | static void attribute_reg_write(UINT8 index, UINT8 data) |
| r17964 | r17965 | |
| 1876 | 1876 | logerror("vga_port_03d0_w(): port=0x%04x data=0x%02x\n", offset + 0x3d0, data); |
| 1877 | 1877 | |
| 1878 | 1878 | if (CRTC_PORT_ADDR == 0x3d0) |
| 1879 | vga_crtc_w(space, offset, data); | |
| 1879 | vga_crtc_w(space, offset, data, mem_mask); | |
| 1880 | 1880 | } |
| 1881 | 1881 | |
| 1882 | 1882 | void pc_vga_reset(running_machine &machine) |
| r17964 | r17965 | |
|---|---|---|
| 35 | 35 | void pc_video_start(running_machine &machine); |
| 36 | 36 | void s3_video_start(running_machine &machine); |
| 37 | 37 | |
| 38 | READ8_HANDLER(vga_port_03b0_r); | |
| 39 | READ8_HANDLER(vga_port_03c0_r); | |
| 40 | READ8_HANDLER(vga_port_03d0_r); | |
| 41 | READ8_HANDLER(vga_mem_r); | |
| 42 | WRITE8_HANDLER(vga_port_03b0_w); | |
| 43 | WRITE8_HANDLER(vga_port_03c0_w); | |
| 44 | WRITE8_HANDLER(vga_port_03d0_w); | |
| 45 | WRITE8_HANDLER(vga_mem_w); | |
| 38 | DECLARE_READ8_HANDLER(vga_port_03b0_r); | |
| 39 | DECLARE_READ8_HANDLER(vga_port_03c0_r); | |
| 40 | DECLARE_READ8_HANDLER(vga_port_03d0_r); | |
| 41 | DECLARE_READ8_HANDLER(vga_mem_r); | |
| 42 | DECLARE_WRITE8_HANDLER(vga_port_03b0_w); | |
| 43 | DECLARE_WRITE8_HANDLER(vga_port_03c0_w); | |
| 44 | DECLARE_WRITE8_HANDLER(vga_port_03d0_w); | |
| 45 | DECLARE_WRITE8_HANDLER(vga_mem_w); | |
| 46 | 46 | |
| 47 | 47 | /* per-device implementations */ |
| 48 | READ8_HANDLER(tseng_et4k_03b0_r); | |
| 49 | WRITE8_HANDLER(tseng_et4k_03b0_w); | |
| 50 | READ8_HANDLER(tseng_et4k_03c0_r); | |
| 51 | WRITE8_HANDLER(tseng_et4k_03c0_w); | |
| 52 | READ8_HANDLER(tseng_et4k_03d0_r); | |
| 53 | WRITE8_HANDLER(tseng_et4k_03d0_w); | |
| 54 | READ8_HANDLER(tseng_mem_r); | |
| 55 | WRITE8_HANDLER(tseng_mem_w); | |
| 48 | DECLARE_READ8_HANDLER(tseng_et4k_03b0_r); | |
| 49 | DECLARE_WRITE8_HANDLER(tseng_et4k_03b0_w); | |
| 50 | DECLARE_READ8_HANDLER(tseng_et4k_03c0_r); | |
| 51 | DECLARE_WRITE8_HANDLER(tseng_et4k_03c0_w); | |
| 52 | DECLARE_READ8_HANDLER(tseng_et4k_03d0_r); | |
| 53 | DECLARE_WRITE8_HANDLER(tseng_et4k_03d0_w); | |
| 54 | DECLARE_READ8_HANDLER(tseng_mem_r); | |
| 55 | DECLARE_WRITE8_HANDLER(tseng_mem_w); | |
| 56 | 56 | |
| 57 | READ8_HANDLER(trident_03c0_r); | |
| 58 | WRITE8_HANDLER(trident_03c0_w); | |
| 59 | READ8_HANDLER(trident_03d0_r); | |
| 60 | WRITE8_HANDLER(trident_03d0_w); | |
| 61 | READ8_HANDLER(trident_mem_r); | |
| 62 | WRITE8_HANDLER(trident_mem_w); | |
| 57 | DECLARE_READ8_HANDLER(trident_03c0_r); | |
| 58 | DECLARE_WRITE8_HANDLER(trident_03c0_w); | |
| 59 | DECLARE_READ8_HANDLER(trident_03d0_r); | |
| 60 | DECLARE_WRITE8_HANDLER(trident_03d0_w); | |
| 61 | DECLARE_READ8_HANDLER(trident_mem_r); | |
| 62 | DECLARE_WRITE8_HANDLER(trident_mem_w); | |
| 63 | 63 | |
| 64 | READ8_HANDLER(s3_port_03b0_r); | |
| 65 | WRITE8_HANDLER(s3_port_03b0_w); | |
| 66 | READ8_HANDLER(s3_port_03c0_r); | |
| 67 | WRITE8_HANDLER(s3_port_03c0_w); | |
| 68 | READ8_HANDLER(s3_port_03d0_r); | |
| 69 | WRITE8_HANDLER(s3_port_03d0_w); | |
| 70 | READ16_HANDLER(s3_gpstatus_r); | |
| 71 | WRITE16_HANDLER(s3_cmd_w); | |
| 72 | READ16_HANDLER(ibm8514_ssv_r); | |
| 73 | WRITE16_HANDLER(ibm8514_ssv_w); | |
| 74 | READ16_HANDLER(s3_8ae8_r); | |
| 75 | WRITE16_HANDLER(s3_8ae8_w); | |
| 76 | READ16_HANDLER(s3_8ee8_r); | |
| 77 | WRITE16_HANDLER(s3_8ee8_w); | |
| 78 | READ16_HANDLER(s3_currentx_r); | |
| 79 | WRITE16_HANDLER(s3_currentx_w); | |
| 80 | READ16_HANDLER(s3_currenty_r); | |
| 81 | WRITE16_HANDLER(s3_currenty_w); | |
| 82 | READ16_HANDLER(s3_line_error_r); | |
| 83 | WRITE16_HANDLER(s3_line_error_w); | |
| 84 | READ16_HANDLER(s3_width_r); | |
| 85 | WRITE16_HANDLER(s3_width_w); | |
| 86 | READ16_HANDLER(s3_multifunc_r); | |
| 87 | WRITE16_HANDLER(s3_multifunc_w); | |
| 88 | READ16_HANDLER(s3_fgcolour_r); | |
| 89 | WRITE16_HANDLER(s3_fgcolour_w); | |
| 90 | READ16_HANDLER(s3_bgcolour_r); | |
| 91 | WRITE16_HANDLER(s3_bgcolour_w); | |
| 92 | READ16_HANDLER(s3_backmix_r); | |
| 93 | WRITE16_HANDLER(s3_backmix_w); | |
| 94 | READ16_HANDLER(s3_foremix_r); | |
| 95 | WRITE16_HANDLER(s3_foremix_w); | |
| 96 | READ16_HANDLER(s3_pixel_xfer_r); | |
| 97 | WRITE16_HANDLER(s3_pixel_xfer_w); | |
| 98 | READ8_HANDLER(s3_mem_r); | |
| 99 | WRITE8_HANDLER(s3_mem_w); | |
| 64 | DECLARE_READ8_HANDLER(s3_port_03b0_r); | |
| 65 | DECLARE_WRITE8_HANDLER(s3_port_03b0_w); | |
| 66 | DECLARE_READ8_HANDLER(s3_port_03c0_r); | |
| 67 | DECLARE_WRITE8_HANDLER(s3_port_03c0_w); | |
| 68 | DECLARE_READ8_HANDLER(s3_port_03d0_r); | |
| 69 | DECLARE_WRITE8_HANDLER(s3_port_03d0_w); | |
| 70 | DECLARE_READ16_HANDLER(s3_gpstatus_r); | |
| 71 | DECLARE_WRITE16_HANDLER(s3_cmd_w); | |
| 72 | DECLARE_READ16_HANDLER(ibm8514_ssv_r); | |
| 73 | DECLARE_WRITE16_HANDLER(ibm8514_ssv_w); | |
| 74 | DECLARE_READ16_HANDLER(s3_8ae8_r); | |
| 75 | DECLARE_WRITE16_HANDLER(s3_8ae8_w); | |
| 76 | DECLARE_READ16_HANDLER(s3_8ee8_r); | |
| 77 | DECLARE_WRITE16_HANDLER(s3_8ee8_w); | |
| 78 | DECLARE_READ16_HANDLER(s3_currentx_r); | |
| 79 | DECLARE_WRITE16_HANDLER(s3_currentx_w); | |
| 80 | DECLARE_READ16_HANDLER(s3_currenty_r); | |
| 81 | DECLARE_WRITE16_HANDLER(s3_currenty_w); | |
| 82 | DECLARE_READ16_HANDLER(s3_line_error_r); | |
| 83 | DECLARE_WRITE16_HANDLER(s3_line_error_w); | |
| 84 | DECLARE_READ16_HANDLER(s3_width_r); | |
| 85 | DECLARE_WRITE16_HANDLER(s3_width_w); | |
| 86 | DECLARE_READ16_HANDLER(s3_multifunc_r); | |
| 87 | DECLARE_WRITE16_HANDLER(s3_multifunc_w); | |
| 88 | DECLARE_READ16_HANDLER(s3_fgcolour_r); | |
| 89 | DECLARE_WRITE16_HANDLER(s3_fgcolour_w); | |
| 90 | DECLARE_READ16_HANDLER(s3_bgcolour_r); | |
| 91 | DECLARE_WRITE16_HANDLER(s3_bgcolour_w); | |
| 92 | DECLARE_READ16_HANDLER(s3_backmix_r); | |
| 93 | DECLARE_WRITE16_HANDLER(s3_backmix_w); | |
| 94 | DECLARE_READ16_HANDLER(s3_foremix_r); | |
| 95 | DECLARE_WRITE16_HANDLER(s3_foremix_w); | |
| 96 | DECLARE_READ16_HANDLER(s3_pixel_xfer_r); | |
| 97 | DECLARE_WRITE16_HANDLER(s3_pixel_xfer_w); | |
| 98 | DECLARE_READ8_HANDLER(s3_mem_r); | |
| 99 | DECLARE_WRITE8_HANDLER(s3_mem_w); | |
| 100 | 100 | |
| 101 | READ8_HANDLER( ati_port_03c0_r ); | |
| 101 | DECLARE_READ8_HANDLER( ati_port_03c0_r ); | |
| 102 | 102 | DECLARE_READ8_DEVICE_HANDLER(ati_port_ext_r); |
| 103 | 103 | DECLARE_WRITE8_DEVICE_HANDLER(ati_port_ext_w); |
| 104 | READ16_HANDLER(ibm8514_gpstatus_r); | |
| 105 | WRITE16_HANDLER(ibm8514_cmd_w); | |
| 106 | READ16_HANDLER(mach8_ext_fifo_r); | |
| 107 | WRITE16_HANDLER(mach8_linedraw_index_w); | |
| 108 | READ16_HANDLER(mach8_bresenham_count_r); | |
| 109 | WRITE16_HANDLER(mach8_bresenham_count_w); | |
| 110 | READ16_HANDLER(mach8_scratch0_r); | |
| 111 | WRITE16_HANDLER(mach8_scratch0_w); | |
| 112 | READ16_HANDLER(mach8_scratch1_r); | |
| 113 | WRITE16_HANDLER(mach8_scratch1_w); | |
| 114 | READ16_HANDLER(mach8_config1_r); | |
| 115 | READ16_HANDLER(mach8_config2_r); | |
| 116 | READ16_HANDLER(mach8_status_r); | |
| 117 | READ16_HANDLER(mach8_substatus_r); | |
| 118 | WRITE16_HANDLER(mach8_subcontrol_w); | |
| 119 | READ16_HANDLER(mach8_subcontrol_r); | |
| 120 | READ16_HANDLER(mach8_htotal_r); | |
| 121 | WRITE16_HANDLER(mach8_htotal_w); | |
| 122 | READ16_HANDLER(mach8_vtotal_r); | |
| 123 | WRITE16_HANDLER(mach8_vtotal_w); | |
| 124 | READ16_HANDLER(mach8_vdisp_r); | |
| 125 | WRITE16_HANDLER(mach8_vdisp_w); | |
| 126 | READ16_HANDLER(mach8_vsync_r); | |
| 127 | WRITE16_HANDLER(mach8_vsync_w); | |
| 128 | WRITE16_HANDLER(mach8_linedraw_w); | |
| 129 | READ16_HANDLER(mach8_ec0_r); | |
| 130 | WRITE16_HANDLER(mach8_ec0_w); | |
| 131 | READ16_HANDLER(mach8_ec1_r); | |
| 132 | WRITE16_HANDLER(mach8_ec1_w); | |
| 133 | READ16_HANDLER(mach8_ec2_r); | |
| 134 | WRITE16_HANDLER(mach8_ec2_w); | |
| 135 | READ16_HANDLER(mach8_ec3_r); | |
| 136 | WRITE16_HANDLER(mach8_ec3_w); | |
| 137 | READ8_HANDLER(ati_mem_r); | |
| 138 | WRITE8_HANDLER(ati_mem_w); | |
| 104 | DECLARE_READ16_HANDLER(ibm8514_gpstatus_r); | |
| 105 | DECLARE_WRITE16_HANDLER(ibm8514_cmd_w); | |
| 106 | DECLARE_READ16_HANDLER(mach8_ext_fifo_r); | |
| 107 | DECLARE_WRITE16_HANDLER(mach8_linedraw_index_w); | |
| 108 | DECLARE_READ16_HANDLER(mach8_bresenham_count_r); | |
| 109 | DECLARE_WRITE16_HANDLER(mach8_bresenham_count_w); | |
| 110 | DECLARE_READ16_HANDLER(mach8_scratch0_r); | |
| 111 | DECLARE_WRITE16_HANDLER(mach8_scratch0_w); | |
| 112 | DECLARE_READ16_HANDLER(mach8_scratch1_r); | |
| 113 | DECLARE_WRITE16_HANDLER(mach8_scratch1_w); | |
| 114 | DECLARE_READ16_HANDLER(mach8_config1_r); | |
| 115 | DECLARE_READ16_HANDLER(mach8_config2_r); | |
| 116 | DECLARE_READ16_HANDLER(mach8_status_r); | |
| 117 | DECLARE_READ16_HANDLER(mach8_substatus_r); | |
| 118 | DECLARE_WRITE16_HANDLER(mach8_subcontrol_w); | |
| 119 | DECLARE_READ16_HANDLER(mach8_subcontrol_r); | |
| 120 | DECLARE_READ16_HANDLER(mach8_htotal_r); | |
| 121 | DECLARE_WRITE16_HANDLER(mach8_htotal_w); | |
| 122 | DECLARE_READ16_HANDLER(mach8_vtotal_r); | |
| 123 | DECLARE_WRITE16_HANDLER(mach8_vtotal_w); | |
| 124 | DECLARE_READ16_HANDLER(mach8_vdisp_r); | |
| 125 | DECLARE_WRITE16_HANDLER(mach8_vdisp_w); | |
| 126 | DECLARE_READ16_HANDLER(mach8_vsync_r); | |
| 127 | DECLARE_WRITE16_HANDLER(mach8_vsync_w); | |
| 128 | DECLARE_WRITE16_HANDLER(mach8_linedraw_w); | |
| 129 | DECLARE_READ16_HANDLER(mach8_ec0_r); | |
| 130 | DECLARE_WRITE16_HANDLER(mach8_ec0_w); | |
| 131 | DECLARE_READ16_HANDLER(mach8_ec1_r); | |
| 132 | DECLARE_WRITE16_HANDLER(mach8_ec1_w); | |
| 133 | DECLARE_READ16_HANDLER(mach8_ec2_r); | |
| 134 | DECLARE_WRITE16_HANDLER(mach8_ec2_w); | |
| 135 | DECLARE_READ16_HANDLER(mach8_ec3_r); | |
| 136 | DECLARE_WRITE16_HANDLER(mach8_ec3_w); | |
| 137 | DECLARE_READ8_HANDLER(ati_mem_r); | |
| 138 | DECLARE_WRITE8_HANDLER(ati_mem_w); | |
| 139 | 139 | |
| 140 | 140 | |
| 141 | 141 | /* |
| r17964 | r17965 | |
|---|---|---|
| 353 | 353 | // ======================> devcb_resolved_read8 |
| 354 | 354 | |
| 355 | 355 | // base delegate type for a read8 |
| 356 | typedef delegate<UINT8 (offs_t)> devcb_read8_delegate; | |
| 356 | typedef delegate<UINT8 (offs_t, UINT8)> devcb_read8_delegate; | |
| 357 | 357 | |
| 358 | 358 | // class which wraps resolving a devcb_read8 into a delegate |
| 359 | 359 | class devcb_resolved_read8 : public devcb_read8_delegate |
| r17964 | r17965 | |
| 371 | 371 | // override parent class' notion of NULL |
| 372 | 372 | bool isnull() const { return m_helper.null_indicator == &s_null; } |
| 373 | 373 | |
| 374 | // provide default for mem_mask | |
| 375 | UINT8 operator()(offs_t offset, UINT8 mem_mask = 0xff) const { return devcb_read8_delegate::operator()(offset, mem_mask); } | |
| 376 | ||
| 374 | 377 | private: |
| 375 | 378 | // internal helpers |
| 376 | UINT8 from_port(offs_t offset); | |
| 377 | UINT8 from_read8(offs_t offset); | |
| 378 | UINT8 from_readline(offs_t offset); | |
| 379 | UINT8 from_constant(offs_t offset); | |
| 379 | UINT8 from_port(offs_t offset, UINT8 mem_mask); | |
| 380 | UINT8 from_read8space(offs_t offset, UINT8 mem_mask); | |
| 381 | UINT8 from_read8device(offs_t offset, UINT8 mem_mask); | |
| 382 | UINT8 from_readline(offs_t offset, UINT8 mem_mask); | |
| 383 | UINT8 from_constant(offs_t offset, UINT8 mem_mask); | |
| 380 | 384 | |
| 381 | 385 | // internal state |
| 382 | 386 | devcb_resolved_objects m_object; |
| r17964 | r17965 | |
| 403 | 407 | // ======================> devcb_resolved_write8 |
| 404 | 408 | |
| 405 | 409 | // base delegate type for a write8 |
| 406 | typedef delegate<void (offs_t, UINT8)> devcb_write8_delegate; | |
| 410 | typedef delegate<void (offs_t, UINT8, UINT8)> devcb_write8_delegate; | |
| 407 | 411 | |
| 408 | 412 | // class which wraps resolving a devcb_write8 into a delegate |
| 409 | 413 | class devcb_resolved_write8 : public devcb_write8_delegate |
| r17964 | r17965 | |
| 421 | 425 | // override parent class' notion of NULL |
| 422 | 426 | bool isnull() const { return m_helper.null_indicator == &s_null; } |
| 423 | 427 | |
| 428 | // provide default for mem_mask | |
| 429 | void operator()(offs_t offset, UINT8 data, UINT8 mem_mask = 0xff) const { devcb_write8_delegate::operator()(offset, data, mem_mask); } | |
| 430 | ||
| 424 | 431 | private: |
| 425 | 432 | // internal helpers |
| 426 | void to_null(offs_t offset, UINT8 data); | |
| 427 | void to_port(offs_t offset, UINT8 data); | |
| 428 | void to_write8(offs_t offset, UINT8 data); | |
| 429 | void to_writeline(offs_t offset, UINT8 data); | |
| 430 | void to_input(offs_t offset, UINT8 data); | |
| 433 | void to_null(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 434 | void to_port(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 435 | void to_write8space(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 436 | void to_write8device(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 437 | void to_writeline(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 438 | void to_input(offs_t offset, UINT8 data, UINT8 mem_mask); | |
| 431 | 439 | |
| 432 | 440 | // internal state |
| 433 | 441 | devcb_resolved_objects m_object; |
| r17964 | r17965 | |
| 472 | 480 | // override parent class' notion of NULL |
| 473 | 481 | bool isnull() const { return m_helper.null_indicator == &s_null; } |
| 474 | 482 | |
| 483 | // provide default for mem_mask | |
| 484 | UINT16 operator()(offs_t offset, UINT16 mem_mask = 0xffff) const { return devcb_read16_delegate::operator()(offset, mem_mask); } | |
| 485 | ||
| 475 | 486 | private: |
| 476 | 487 | // internal helpers |
| 477 | 488 | UINT16 from_port(offs_t offset, UINT16 mask); |
| r17964 | r17965 | |
| 522 | 533 | // override parent class' notion of NULL |
| 523 | 534 | bool isnull() const { return m_helper.null_indicator == &s_null; } |
| 524 | 535 | |
| 536 | // provide default for mem_mask | |
| 537 | void operator()(offs_t offset, UINT16 data, UINT16 mem_mask = 0xffff) const { devcb_write16_delegate::operator()(offset, data, mem_mask); } | |
| 538 | ||
| 525 | 539 | private: |
| 526 | 540 | // internal helpers |
| 527 | 541 | void to_null(offs_t offset, UINT16 data, UINT16 mask); |
| r17964 | r17965 | |
|---|---|---|
| 248 | 248 | extern const device_type SPU; |
| 249 | 249 | |
| 250 | 250 | // MAME old-style interface |
| 251 | READ16_HANDLER( spu_r ); | |
| 252 | WRITE16_HANDLER( spu_w ); | |
| 251 | DECLARE_READ16_HANDLER( spu_r ); | |
| 252 | DECLARE_WRITE16_HANDLER( spu_w ); | |
| 253 | 253 | |
| 254 | 254 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 347 | 347 | |
| 348 | 348 | |
| 349 | 349 | /* fix me: eventually this should be a single device with pokey subdevices */ |
| 350 | READ8_HANDLER( quad_pokeyn_r ); | |
| 351 | WRITE8_HANDLER( quad_pokeyn_w ); | |
| 350 | DECLARE_READ8_HANDLER( quad_pokeyn_r ); | |
| 351 | DECLARE_WRITE8_HANDLER( quad_pokeyn_w ); | |
| 352 | 352 | |
| 353 | 353 | |
| 354 | 354 | #endif /* __POKEY_H__ */ |
| r17964 | r17965 | |
|---|---|---|
| 89 | 89 | { |
| 90 | 90 | UINT16 result = 0; |
| 91 | 91 | if (ACCESSING_BITS_8_15) |
| 92 | result |= ((UINT16)(*handler)(space, offset * 2 + 0)) << 8; | |
| 92 | result |= ((UINT16)(*handler)(space, offset * 2 + 0, mem_mask >> 8)) << 8; | |
| 93 | 93 | if (ACCESSING_BITS_0_7) |
| 94 | result |= ((UINT16)(*handler)(space, offset * 2 + 1)) << 0; | |
| 94 | result |= ((UINT16)(*handler)(space, offset * 2 + 1, mem_mask >> 0)) << 0; | |
| 95 | 95 | return result; |
| 96 | 96 | } |
| 97 | 97 | |
| r17964 | r17965 | |
| 99 | 99 | INLINE void write16be_with_write8_handler(write8_space_func handler, address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask) |
| 100 | 100 | { |
| 101 | 101 | if (ACCESSING_BITS_8_15) |
| 102 | (*handler)(space, offset * 2 + 0, data >> 8); | |
| 102 | (*handler)(space, offset * 2 + 0, data >> 8, mem_mask >> 8); | |
| 103 | 103 | if (ACCESSING_BITS_0_7) |
| 104 | (*handler)(space, offset * 2 + 1, data >> 0); | |
| 104 | (*handler)(space, offset * 2 + 1, data >> 0, mem_mask >> 0); | |
| 105 | 105 | } |
| 106 | 106 | |
| 107 | 107 | |
| r17964 | r17965 | |
| 115 | 115 | { |
| 116 | 116 | UINT16 result = 0; |
| 117 | 117 | if (ACCESSING_BITS_0_7) |
| 118 | result |= ((UINT16) (*handler)(space, offset * 2 + 0)) << 0; | |
| 118 | result |= ((UINT16) (*handler)(space, offset * 2 + 0, mem_mask >> 0)) << 0; | |
| 119 | 119 | if (ACCESSING_BITS_8_15) |
| 120 | result |= ((UINT16) (*handler)(space, offset * 2 + 1)) << 8; | |
| 120 | result |= ((UINT16) (*handler)(space, offset * 2 + 1, mem_mask >> 8)) << 8; | |
| 121 | 121 | return result; |
| 122 | 122 | } |
| 123 | 123 | |
| r17964 | r17965 | |
| 125 | 125 | INLINE void write16le_with_write8_handler(write8_space_func handler, address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask) |
| 126 | 126 | { |
| 127 | 127 | if (ACCESSING_BITS_0_7) |
| 128 | (*handler)(space, offset * 2 + 0, data >> 0); | |
| 128 | (*handler)(space, offset * 2 + 0, data >> 0, mem_mask >> 0); | |
| 129 | 129 | if (ACCESSING_BITS_8_15) |
| 130 | (*handler)(space, offset * 2 + 1, data >> 8); | |
| 130 | (*handler)(space, offset * 2 + 1, data >> 8, mem_mask >> 8); | |
| 131 | 131 | } |
| 132 | 132 | |
| 133 | 133 |
| r17964 | r17965 | |
|---|---|---|
| 4984 | 4984 | offs_t aoffset = offset * si.m_multiplier + si.m_offset; |
| 4985 | 4985 | UINT8 val; |
| 4986 | 4986 | if (m_sub_is_legacy[index]) |
| 4987 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset); | |
| 4987 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, submask); | |
| 4988 | 4988 | else |
| 4989 | 4989 | val = m_subread[index].r8(space, aoffset, submask); |
| 4990 | 4990 | result |= val << si.m_shift; |
| r17964 | r17965 | |
| 5015 | 5015 | switch (si.m_size) |
| 5016 | 5016 | { |
| 5017 | 5017 | case 8: |
| 5018 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset); | |
| 5018 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, submask); | |
| 5019 | 5019 | break; |
| 5020 | 5020 | case 16: |
| 5021 | 5021 | val = m_sublegacy_info[index].handler.space16(*m_sublegacy_info[index].object.space, aoffset, submask); |
| r17964 | r17965 | |
| 5062 | 5062 | switch (si.m_size) |
| 5063 | 5063 | { |
| 5064 | 5064 | case 8: |
| 5065 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset); | |
| 5065 | val = m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, submask); | |
| 5066 | 5066 | break; |
| 5067 | 5067 | case 16: |
| 5068 | 5068 | val = m_sublegacy_info[index].handler.space16(*m_sublegacy_info[index].object.space, aoffset, submask); |
| r17964 | r17965 | |
| 5101 | 5101 | |
| 5102 | 5102 | UINT8 handler_entry_read::read_stub_legacy(address_space &space, offs_t offset, UINT8 mask) |
| 5103 | 5103 | { |
| 5104 | return m_legacy_info.handler.space8(*m_legacy_info.object.space, offset); | |
| 5104 | return m_legacy_info.handler.space8(*m_legacy_info.object.space, offset, mask); | |
| 5105 | 5105 | } |
| 5106 | 5106 | |
| 5107 | 5107 | UINT16 handler_entry_read::read_stub_legacy(address_space &space, offs_t offset, UINT16 mask) |
| r17964 | r17965 | |
| 5438 | 5438 | offs_t aoffset = offset * si.m_multiplier + si.m_offset; |
| 5439 | 5439 | UINT8 adata = data >> si.m_shift; |
| 5440 | 5440 | if (m_sub_is_legacy[index]) |
| 5441 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata); | |
| 5441 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata, submask); | |
| 5442 | 5442 | else |
| 5443 | 5443 | m_subwrite[index].w8(space, aoffset, adata, submask); |
| 5444 | 5444 | } |
| r17964 | r17965 | |
| 5466 | 5466 | switch (si.m_size) |
| 5467 | 5467 | { |
| 5468 | 5468 | case 8: |
| 5469 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata); | |
| 5469 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata, submask); | |
| 5470 | 5470 | break; |
| 5471 | 5471 | case 16: |
| 5472 | 5472 | m_sublegacy_info[index].handler.space16(*m_sublegacy_info[index].object.space, aoffset, adata, submask); |
| r17964 | r17965 | |
| 5510 | 5510 | switch (si.m_size) |
| 5511 | 5511 | { |
| 5512 | 5512 | case 8: |
| 5513 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata); | |
| 5513 | m_sublegacy_info[index].handler.space8(*m_sublegacy_info[index].object.space, aoffset, adata, submask); | |
| 5514 | 5514 | break; |
| 5515 | 5515 | case 16: |
| 5516 | 5516 | m_sublegacy_info[index].handler.space16(*m_sublegacy_info[index].object.space, aoffset, adata, submask); |
| r17964 | r17965 | |
| 5547 | 5547 | |
| 5548 | 5548 | void handler_entry_write::write_stub_legacy(address_space &space, offs_t offset, UINT8 data, UINT8 mask) |
| 5549 | 5549 | { |
| 5550 | m_legacy_info.handler.space8(*m_legacy_info.object.space, offset, data); | |
| 5550 | m_legacy_info.handler.space8(*m_legacy_info.object.space, offset, data, mask); | |
| 5551 | 5551 | } |
| 5552 | 5552 | |
| 5553 | 5553 | void handler_entry_write::write_stub_legacy(address_space &space, offs_t offset, UINT16 data, UINT16 mask) |
| r17964 | r17965 | |
|---|---|---|
| 112 | 112 | |
| 113 | 113 | |
| 114 | 114 | // legacy space read/write handlers |
| 115 | typedef UINT8 (*read8_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset); | |
| 116 | typedef void (*write8_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data); | |
| 115 | typedef UINT8 (*read8_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask); | |
| 116 | typedef void (*write8_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask); | |
| 117 | 117 | typedef UINT16 (*read16_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask); |
| 118 | 118 | typedef void (*write16_space_func)(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask); |
| 119 | 119 | typedef UINT32 (*read32_space_func) (ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask); |
| r17964 | r17965 | |
| 876 | 876 | |
| 877 | 877 | |
| 878 | 878 | // space read/write handler function macros |
| 879 | #define READ8_HANDLER(name) UINT8 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset) | |
| 880 | #define WRITE8_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data) | |
| 879 | #define READ8_HANDLER(name) UINT8 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask) | |
| 880 | #define WRITE8_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask) | |
| 881 | 881 | #define READ16_HANDLER(name) UINT16 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask) |
| 882 | 882 | #define WRITE16_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask) |
| 883 | 883 | #define READ32_HANDLER(name) UINT32 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask) |
| r17964 | r17965 | |
| 885 | 885 | #define READ64_HANDLER(name) UINT64 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask) |
| 886 | 886 | #define WRITE64_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask) |
| 887 | 887 | |
| 888 | #define DECLARE_READ8_HANDLER(name) UINT8 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask = 0xff) | |
| 889 | #define DECLARE_WRITE8_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask = 0xff) | |
| 890 | #define DECLARE_READ16_HANDLER(name) UINT16 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask = 0xffff) | |
| 891 | #define DECLARE_WRITE16_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask = 0xffff) | |
| 892 | #define DECLARE_READ32_HANDLER(name) UINT32 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask = 0xffffffff) | |
| 893 | #define DECLARE_WRITE32_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask = 0xffffffff) | |
| 894 | #define DECLARE_READ64_HANDLER(name) UINT64 name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask = U64(0xffffffffffffffff)) | |
| 895 | #define DECLARE_WRITE64_HANDLER(name) void name(ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask = U64(0xffffffffffffffff)) | |
| 888 | 896 | |
| 897 | ||
| 889 | 898 | // device read/write handler function macros |
| 890 | 899 | #define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask) |
| 891 | 900 | #define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask) |
| r17964 | r17965 | |
|---|---|---|
| 4 | 4 | void pc16552d_init(running_machine &machine, int chip, int frequency, void (* irq_handler)(running_machine &machine, int channel, int value), void (* tx_callback)(running_machine &machine, int channel, int count, UINT8* data)); |
| 5 | 5 | void pc16552d_rx_data(running_machine &machine, int chip, int channel, UINT8 data); |
| 6 | 6 | |
| 7 | READ8_HANDLER(pc16552d_0_r); | |
| 8 | WRITE8_HANDLER(pc16552d_0_w); | |
| 9 | READ8_HANDLER(pc16552d_1_r); | |
| 10 | WRITE8_HANDLER(pc16552d_1_w); | |
| 7 | DECLARE_READ8_HANDLER(pc16552d_0_r); | |
| 8 | DECLARE_WRITE8_HANDLER(pc16552d_0_w); | |
| 9 | DECLARE_READ8_HANDLER(pc16552d_1_r); | |
| 10 | DECLARE_WRITE8_HANDLER(pc16552d_1_w); | |
| 11 | 11 | |
| 12 | 12 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 88 | 88 | if (latch8->intf->devread[i].read_handler != NULL) |
| 89 | 89 | { |
| 90 | 90 | res &= ~( 1 << i); |
| 91 | res |= ((latch8->intf->devread[i].read_handler(space, 0) >> latch8->intf->devread[i].from_bit) & 0x01) << i; | |
| 91 | res |= ((latch8->intf->devread[i].read_handler(space, 0, 0xff) >> latch8->intf->devread[i].from_bit) & 0x01) << i; | |
| 92 | 92 | } |
| 93 | 93 | } |
| 94 | 94 | } |
| r17964 | r17965 | |
|---|---|---|
| 34 | 34 | |
| 35 | 35 | void kbdc8042_init(running_machine &machine, const struct kbdc8042_interface *intf); |
| 36 | 36 | |
| 37 | READ8_HANDLER(kbdc8042_8_r); | |
| 38 | WRITE8_HANDLER(kbdc8042_8_w); | |
| 39 | READ64_HANDLER(kbdc8042_64be_r); | |
| 40 | WRITE64_HANDLER(kbdc8042_64be_w); | |
| 37 | DECLARE_READ8_HANDLER(kbdc8042_8_r); | |
| 38 | DECLARE_WRITE8_HANDLER(kbdc8042_8_w); | |
| 39 | DECLARE_READ64_HANDLER(kbdc8042_64be_r); | |
| 40 | DECLARE_WRITE64_HANDLER(kbdc8042_64be_w); | |
| 41 | 41 | |
| 42 | 42 | #endif /* KBDC8042_H */ |
| 43 | 43 |
| r17964 | r17965 | |
|---|---|---|
| 62 | 62 | space.install_legacy_readwrite_handler( *device, 0x15800000, 0x15800007, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w)); |
| 63 | 63 | space.install_legacy_readwrite_handler( *device, 0x15900000, 0x15900017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w)); |
| 64 | 64 | space.install_legacy_readwrite_handler( *device, 0x15a00000, 0x15a0003f, FUNC(s3c24xx_mmc_r), FUNC(s3c24xx_mmc_w)); |
| 65 | ||
| 65 | ||
| 66 | 66 | s3c24xx_video_start( device, device->machine()); |
| 67 | 67 | } |
| 68 | 68 |
| r17964 | r17965 | |
|---|---|---|
| 6 | 6 | MACHINE_RESET( tmp68301 ); |
| 7 | 7 | |
| 8 | 8 | // Hardware Registers |
| 9 | READ16_HANDLER( tmp68301_regs_r ); | |
| 10 | WRITE16_HANDLER( tmp68301_regs_w ); | |
| 9 | DECLARE_READ16_HANDLER( tmp68301_regs_r ); | |
| 10 | DECLARE_WRITE16_HANDLER( tmp68301_regs_w ); | |
| 11 | 11 | |
| 12 | 12 | // Interrupts |
| 13 | 13 | void tmp68301_external_interrupt_0(running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 65 | 65 | space.install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w)); |
| 66 | 66 | space.install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w)); |
| 67 | 67 | space.install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w)); |
| 68 | ||
| 68 | ||
| 69 | 69 | s3c24xx_video_start( device, device->machine()); |
| 70 | 70 | } |
| 71 | 71 |
| r17964 | r17965 | |
|---|---|---|
| 73 | 73 | |
| 74 | 74 | |
| 75 | 75 | // Ram banking handlers. |
| 76 | static WRITE8_HANDLER( dgnbeta_ram_b0_w ); | |
| 77 | static WRITE8_HANDLER( dgnbeta_ram_b1_w ); | |
| 78 | static WRITE8_HANDLER( dgnbeta_ram_b2_w ); | |
| 79 | static WRITE8_HANDLER( dgnbeta_ram_b3_w ); | |
| 80 | static WRITE8_HANDLER( dgnbeta_ram_b4_w ); | |
| 81 | static WRITE8_HANDLER( dgnbeta_ram_b5_w ); | |
| 82 | static WRITE8_HANDLER( dgnbeta_ram_b6_w ); | |
| 83 | static WRITE8_HANDLER( dgnbeta_ram_b7_w ); | |
| 84 | static WRITE8_HANDLER( dgnbeta_ram_b8_w ); | |
| 85 | static WRITE8_HANDLER( dgnbeta_ram_b9_w ); | |
| 86 | static WRITE8_HANDLER( dgnbeta_ram_bA_w ); | |
| 87 | static WRITE8_HANDLER( dgnbeta_ram_bB_w ); | |
| 88 | static WRITE8_HANDLER( dgnbeta_ram_bC_w ); | |
| 89 | static WRITE8_HANDLER( dgnbeta_ram_bD_w ); | |
| 90 | static WRITE8_HANDLER( dgnbeta_ram_bE_w ); | |
| 91 | static WRITE8_HANDLER( dgnbeta_ram_bF_w ); | |
| 92 | static WRITE8_HANDLER( dgnbeta_ram_bG_w ); | |
| 76 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b0_w ); | |
| 77 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b1_w ); | |
| 78 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b2_w ); | |
| 79 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b3_w ); | |
| 80 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b4_w ); | |
| 81 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b5_w ); | |
| 82 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b6_w ); | |
| 83 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b7_w ); | |
| 84 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b8_w ); | |
| 85 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_b9_w ); | |
| 86 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bA_w ); | |
| 87 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bB_w ); | |
| 88 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bC_w ); | |
| 89 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bD_w ); | |
| 90 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bE_w ); | |
| 91 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bF_w ); | |
| 92 | static DECLARE_WRITE8_HANDLER( dgnbeta_ram_bG_w ); | |
| 93 | 93 | |
| 94 | 94 | |
| 95 | 95 | #define VERBOSE 0 |
| r17964 | r17965 | |
|---|---|---|
| 84 | 84 | |
| 85 | 85 | // read/write handler |
| 86 | 86 | #if 0 |
| 87 | READ8_HANDLER( sst39vfx_r ); | |
| 88 | WRITE8_HANDLER( sst39vfx_w ); | |
| 87 | DECLARE_READ8_HANDLER( sst39vfx_r ); | |
| 88 | DECLARE_WRITE8_HANDLER( sst39vfx_w ); | |
| 89 | 89 | #endif |
| 90 | 90 | |
| 91 | 91 | // load/save |
| r17964 | r17965 | |
|---|---|---|
| 1013 | 1013 | case 0x3D: /* C03D - SOUNDDATA */ |
| 1014 | 1014 | case 0x3E: /* C03E - SOUNDADRL */ |
| 1015 | 1015 | case 0x3F: /* C03F - SOUNDADRH */ |
| 1016 | result = gssnd_r(space, offset & 0x03); | |
| 1016 | result = gssnd_r(space, offset & 0x03, mem_mask); | |
| 1017 | 1017 | break; |
| 1018 | 1018 | |
| 1019 | 1019 | case 0x41: /* C041 - INTEN */ |
| r17964 | r17965 | |
| 1174 | 1174 | case 0x3D: /* C03D - SOUNDDATA */ |
| 1175 | 1175 | case 0x3E: /* C03E - SOUNDADRL */ |
| 1176 | 1176 | case 0x3F: /* C03F - SOUNDADRH */ |
| 1177 | gssnd_w(space, offset & 0x03, data); | |
| 1177 | gssnd_w(space, offset & 0x03, data, mem_mask); | |
| 1178 | 1178 | break; |
| 1179 | 1179 | |
| 1180 | 1180 | case 0x41: /* C041 - INTEN */ |
| r17964 | r17965 | |
| 1763 | 1763 | state->m_slowmem[offset] = data; |
| 1764 | 1764 | } |
| 1765 | 1765 | |
| 1766 | static WRITE8_HANDLER( apple2gs_E004xx_w ) { apple2gs_Exxxxx_w(space, offset + 0x00400, data); } | |
| 1767 | static WRITE8_HANDLER( apple2gs_E02xxx_w ) { apple2gs_Exxxxx_w(space, offset + 0x02000, data); } | |
| 1768 | static WRITE8_HANDLER( apple2gs_E104xx_w ) { apple2gs_Exxxxx_w(space, offset + 0x10400, data); } | |
| 1769 | static WRITE8_HANDLER( apple2gs_E12xxx_w ) { apple2gs_Exxxxx_w(space, offset + 0x12000, data); } | |
| 1766 | static WRITE8_HANDLER( apple2gs_E004xx_w ) { apple2gs_Exxxxx_w(space, offset + 0x00400, data, mem_mask); } | |
| 1767 | static WRITE8_HANDLER( apple2gs_E02xxx_w ) { apple2gs_Exxxxx_w(space, offset + 0x02000, data, mem_mask); } | |
| 1768 | static WRITE8_HANDLER( apple2gs_E104xx_w ) { apple2gs_Exxxxx_w(space, offset + 0x10400, data, mem_mask); } | |
| 1769 | static WRITE8_HANDLER( apple2gs_E12xxx_w ) { apple2gs_Exxxxx_w(space, offset + 0x12000, data, mem_mask); } | |
| 1770 | 1770 | |
| 1771 | 1771 | static WRITE8_HANDLER( apple2gs_slowmem_w ) |
| 1772 | 1772 | { |
| r17964 | r17965 | |
|---|---|---|
| 223 | 223 | m_maincpu->set_input_line(INPUT_LINE_IRQ0, m_fdc_irq | m_dma_irq); |
| 224 | 224 | } |
| 225 | 225 | |
| 226 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 227 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 226 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 227 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 228 | 228 | |
| 229 | 229 | static Z80DMA_INTERFACE( dma_intf ) |
| 230 | 230 | { |
| r17964 | r17965 | |
|---|---|---|
| 137 | 137 | #define LOG_FDS(x) do { if (VERBOSE) logerror x; } while (0) |
| 138 | 138 | |
| 139 | 139 | static void ffe_irq( device_t *device, int scanline, int vblank, int blanked ); |
| 140 | static WRITE8_HANDLER( mapper6_l_w ); | |
| 141 | static WRITE8_HANDLER( mapper6_w ); | |
| 142 | static WRITE8_HANDLER( mapper8_w ); | |
| 143 | static WRITE8_HANDLER( mapper17_l_w ); | |
| 140 | static DECLARE_WRITE8_HANDLER( mapper6_l_w ); | |
| 141 | static DECLARE_WRITE8_HANDLER( mapper6_w ); | |
| 142 | static DECLARE_WRITE8_HANDLER( mapper8_w ); | |
| 143 | static DECLARE_WRITE8_HANDLER( mapper17_l_w ); | |
| 144 | 144 | |
| 145 | 145 | /************************************************************* |
| 146 | 146 | |
| r17964 | r17965 | |
| 222 | 222 | nes_state *state = space.machine().driver_data<nes_state>(); |
| 223 | 223 | |
| 224 | 224 | if (state->m_mmc_write_low) |
| 225 | (*state->m_mmc_write_low)(space, offset, data); | |
| 225 | (*state->m_mmc_write_low)(space, offset, data, mem_mask); | |
| 226 | 226 | else |
| 227 | 227 | logerror("Unimplemented LOW mapper write, offset: %04x, data: %02x\n", offset + 0x4100, data); |
| 228 | 228 | } |
| r17964 | r17965 | |
| 232 | 232 | nes_state *state = space.machine().driver_data<nes_state>(); |
| 233 | 233 | |
| 234 | 234 | if (state->m_mmc_read_low) |
| 235 | return (*state->m_mmc_read_low)(space, offset); | |
| 235 | return (*state->m_mmc_read_low)(space, offset, mem_mask); | |
| 236 | 236 | else |
| 237 | 237 | logerror("Unimplemented LOW mapper read, offset: %04x\n", offset + 0x4100); |
| 238 | 238 |
| r17964 | r17965 | |
|---|---|---|
| 117 | 117 | int nes_pcb_reset(running_machine &machine); |
| 118 | 118 | |
| 119 | 119 | |
| 120 | WRITE8_HANDLER( nes_low_mapper_w ); | |
| 121 | READ8_HANDLER( nes_low_mapper_r ); | |
| 122 | WRITE8_HANDLER( nes_chr_w ); | |
| 123 | READ8_HANDLER( nes_chr_r ); | |
| 124 | WRITE8_HANDLER( nes_nt_w ); | |
| 125 | READ8_HANDLER( nes_nt_r ); | |
| 120 | DECLARE_WRITE8_HANDLER( nes_low_mapper_w ); | |
| 121 | DECLARE_READ8_HANDLER( nes_low_mapper_r ); | |
| 122 | DECLARE_WRITE8_HANDLER( nes_chr_w ); | |
| 123 | DECLARE_READ8_HANDLER( nes_chr_r ); | |
| 124 | DECLARE_WRITE8_HANDLER( nes_nt_w ); | |
| 125 | DECLARE_READ8_HANDLER( nes_nt_r ); | |
| 126 | 126 | |
| 127 | WRITE8_HANDLER( smb2jb_extra_w ); | |
| 128 | WRITE8_HANDLER( ks7017_extra_w ); | |
| 129 | READ8_HANDLER( ks7017_extra_r ); | |
| 130 | WRITE8_HANDLER( unl_6035052_extra_w ); | |
| 131 | READ8_HANDLER( unl_6035052_extra_r ); | |
| 132 | READ8_HANDLER( waixing_sh2_chr_r ); | |
| 127 | DECLARE_WRITE8_HANDLER( smb2jb_extra_w ); | |
| 128 | DECLARE_WRITE8_HANDLER( ks7017_extra_w ); | |
| 129 | DECLARE_READ8_HANDLER( ks7017_extra_r ); | |
| 130 | DECLARE_WRITE8_HANDLER( unl_6035052_extra_w ); | |
| 131 | DECLARE_READ8_HANDLER( unl_6035052_extra_r ); | |
| 132 | DECLARE_READ8_HANDLER( waixing_sh2_chr_r ); | |
| 133 | 133 | |
| 134 | 134 | //TEMPORARY PPU STUFF |
| 135 | 135 |
| r17964 | r17965 | |
|---|---|---|
| 11 | 11 | |
| 12 | 12 | #include "emu.h" |
| 13 | 13 | |
| 14 | READ8_HANDLER ( pc_JOY_r ); | |
| 15 | WRITE8_HANDLER ( pc_JOY_w ); | |
| 14 | DECLARE_READ8_HANDLER ( pc_JOY_r ); | |
| 15 | DECLARE_WRITE8_HANDLER ( pc_JOY_w ); | |
| 16 | 16 | |
| 17 | 17 | INPUT_PORTS_EXTERN( pc_joystick_none ); |
| 18 | 18 | INPUT_PORTS_EXTERN( pc_joystick ); |
| r17964 | r17965 | |
|---|---|---|
| 366 | 366 | i8257_hlda_w(device, state); |
| 367 | 367 | } |
| 368 | 368 | |
| 369 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 370 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 369 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 370 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 371 | 371 | |
| 372 | 372 | I8257_INTERFACE( partner_dma ) |
| 373 | 373 | { |
| r17964 | r17965 | |
|---|---|---|
| 531 | 531 | case 1: /* n/a */ |
| 532 | 532 | break; |
| 533 | 533 | case 2: |
| 534 | pc_fdc_dor_w(space, 0, data); | |
| 534 | pc_fdc_dor_w(space, 0, data, mem_mask); | |
| 535 | 535 | break; |
| 536 | 536 | case 3: |
| 537 | 537 | /* tape drive select? */ |
| r17964 | r17965 | |
| 568 | 568 | switch(offset) |
| 569 | 569 | { |
| 570 | 570 | case 2: |
| 571 | pcjr_fdc_dor_w( space, 0, data ); | |
| 571 | pcjr_fdc_dor_w( space, 0, data, mem_mask ); | |
| 572 | 572 | break; |
| 573 | 573 | case 4: |
| 574 | 574 | case 7: |
| r17964 | r17965 | |
|---|---|---|
| 43 | 43 | int pc_fdc_dack_r(running_machine &machine, address_space &space); |
| 44 | 44 | void pc_fdc_dack_w(running_machine &machine, address_space &space, int data); |
| 45 | 45 | |
| 46 | READ8_HANDLER(pc_fdc_r); | |
| 47 | WRITE8_HANDLER(pc_fdc_w); | |
| 48 | WRITE8_HANDLER ( pcjr_fdc_w ); | |
| 46 | DECLARE_READ8_HANDLER(pc_fdc_r); | |
| 47 | DECLARE_WRITE8_HANDLER(pc_fdc_w); | |
| 48 | DECLARE_WRITE8_HANDLER ( pcjr_fdc_w ); | |
| 49 | 49 | |
| 50 | 50 | #endif /* PC_FDC_H */ |
| 51 | 51 |
| r17964 | r17965 | |
|---|---|---|
| 11 | 11 | |
| 12 | 12 | void sgi_mc_init(running_machine &machine); |
| 13 | 13 | |
| 14 | READ32_HANDLER(sgi_mc_r); | |
| 15 | WRITE32_HANDLER(sgi_mc_w); | |
| 14 | DECLARE_READ32_HANDLER(sgi_mc_r); | |
| 15 | DECLARE_WRITE32_HANDLER(sgi_mc_w); | |
| 16 | 16 | |
| 17 | 17 | |
| 18 | 18 | #endif /* _SGIMC_H */ |
| r17964 | r17965 | |
|---|---|---|
| 217 | 217 | /* processor has only 1 mega address space !? */ |
| 218 | 218 | /* and system 8 megabyte */ |
| 219 | 219 | /* dma controller and bankswitch hardware ?*/ |
| 220 | static DECLARE_READ8_HANDLER( c65_read_mem ); | |
| 220 | 221 | static READ8_HANDLER( c65_read_mem ) |
| 221 | 222 | { |
| 222 | 223 | c65_state *state = space.machine().driver_data<c65_state>(); |
| r17964 | r17965 | |
| 228 | 229 | return result; |
| 229 | 230 | } |
| 230 | 231 | |
| 232 | static DECLARE_WRITE8_HANDLER( c65_write_mem ); | |
| 231 | 233 | static WRITE8_HANDLER( c65_write_mem ) |
| 232 | 234 | { |
| 233 | 235 | c65_state *state = space.machine().driver_data<c65_state>(); |
| r17964 | r17965 | |
| 659 | 661 | c65_fdc_w(space.machine(), offset&0x1f,data); |
| 660 | 662 | else |
| 661 | 663 | { |
| 662 | c65_ram_expansion_w(space, offset&0x1f, data); | |
| 664 | c65_ram_expansion_w(space, offset&0x1f, data, mem_mask); | |
| 663 | 665 | /*ram expansion crtl optional */ |
| 664 | 666 | } |
| 665 | 667 | break; |
| r17964 | r17965 | |
| 723 | 725 | return c65_fdc_r(space.machine(), offset&0x1f); |
| 724 | 726 | else |
| 725 | 727 | { |
| 726 | return c65_ram_expansion_r(space, offset&0x1f); | |
| 728 | return c65_ram_expansion_r(space, offset&0x1f, mem_mask); | |
| 727 | 729 | /*return; ram expansion crtl optional */ |
| 728 | 730 | } |
| 729 | 731 | break; |
| r17964 | r17965 | |
|---|---|---|
| 10 | 10 | |
| 11 | 11 | void ti990_hdc_init(running_machine &machine, void (*interrupt_callback)(running_machine &machine, int state)); |
| 12 | 12 | |
| 13 | READ16_HANDLER(ti990_hdc_r); | |
| 14 | WRITE16_HANDLER(ti990_hdc_w); | |
| 13 | DECLARE_READ16_HANDLER(ti990_hdc_r); | |
| 14 | DECLARE_WRITE16_HANDLER(ti990_hdc_w); | |
| 15 | 15 | |
| 16 | 16 | MACHINE_CONFIG_EXTERN( ti990_hdc ); |
| 17 | 17 |
| r17964 | r17965 | |
|---|---|---|
| 140 | 140 | i8257_hlda_w(device, state); |
| 141 | 141 | } |
| 142 | 142 | |
| 143 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 144 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 143 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 144 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 145 | 145 | |
| 146 | 146 | I8257_INTERFACE( radio86_dma ) |
| 147 | 147 | { |
| r17964 | r17965 | |
|---|---|---|
| 14 | 14 | |
| 15 | 15 | void ti990_hold_load(running_machine &machine); |
| 16 | 16 | |
| 17 | READ8_HANDLER ( ti990_panel_read ); | |
| 18 | WRITE8_HANDLER ( ti990_panel_write ); | |
| 17 | DECLARE_READ8_HANDLER ( ti990_panel_read ); | |
| 18 | DECLARE_WRITE8_HANDLER ( ti990_panel_write ); | |
| 19 | 19 | |
| 20 | 20 | void ti990_line_interrupt(running_machine &machine); |
| 21 | 21 | void ti990_ckon_ckof_callback(device_t *device, int state); |
| r17964 | r17965 | |
|---|---|---|
| 1824 | 1824 | { |
| 1825 | 1825 | |
| 1826 | 1826 | case 1: |
| 1827 | return to7_5p14sd_r( space, offset ); | |
| 1827 | return to7_5p14sd_r( space, offset, mem_mask ); | |
| 1828 | 1828 | |
| 1829 | 1829 | case 2: |
| 1830 | return to7_5p14_r( space, offset ); | |
| 1830 | return to7_5p14_r( space, offset, mem_mask ); | |
| 1831 | 1831 | |
| 1832 | 1832 | case 3: |
| 1833 | 1833 | return thmfc_floppy_r( space, offset ); |
| 1834 | 1834 | |
| 1835 | 1835 | case 4: |
| 1836 | return to7_qdd_r( space, offset ); | |
| 1836 | return to7_qdd_r( space, offset, mem_mask ); | |
| 1837 | 1837 | |
| 1838 | 1838 | case 5: |
| 1839 | return to7_network_r( space, offset ); | |
| 1839 | return to7_network_r( space, offset, mem_mask ); | |
| 1840 | 1840 | } |
| 1841 | 1841 | |
| 1842 | 1842 | return 0; |
| r17964 | r17965 | |
| 1850 | 1850 | { |
| 1851 | 1851 | |
| 1852 | 1852 | case 1: |
| 1853 | to7_5p14sd_w( space, offset, data ); | |
| 1853 | to7_5p14sd_w( space, offset, data, mem_mask ); | |
| 1854 | 1854 | return; |
| 1855 | 1855 | |
| 1856 | 1856 | case 2: |
| 1857 | to7_5p14_w( space, offset, data ); | |
| 1857 | to7_5p14_w( space, offset, data, mem_mask ); | |
| 1858 | 1858 | break; |
| 1859 | 1859 | |
| 1860 | 1860 | case 3: |
| r17964 | r17965 | |
| 1869 | 1869 | break; |
| 1870 | 1870 | |
| 1871 | 1871 | case 4: |
| 1872 | to7_qdd_w( space, offset, data ); | |
| 1872 | to7_qdd_w( space, offset, data, mem_mask ); | |
| 1873 | 1873 | break; |
| 1874 | 1874 | |
| 1875 | 1875 | case 5: |
| 1876 | to7_network_w( space, offset, data ); | |
| 1876 | to7_network_w( space, offset, data, mem_mask ); | |
| 1877 | 1877 | break; |
| 1878 | 1878 | } |
| 1879 | 1879 | } |
| r17964 | r17965 | |
| 1918 | 1918 | if ( THOM_FLOPPY_EXT ) |
| 1919 | 1919 | return to7_floppy_r( space, offset ); |
| 1920 | 1920 | else |
| 1921 | return to7_5p14_r( space, offset ); | |
| 1921 | return to7_5p14_r( space, offset, mem_mask ); | |
| 1922 | 1922 | } |
| 1923 | 1923 | |
| 1924 | 1924 | WRITE8_HANDLER ( to9_floppy_w ) |
| r17964 | r17965 | |
| 1926 | 1926 | if ( THOM_FLOPPY_EXT ) |
| 1927 | 1927 | to7_floppy_w( space, offset, data ); |
| 1928 | 1928 | else |
| 1929 | to7_5p14_w( space, offset, data ); | |
| 1929 | to7_5p14_w( space, offset, data, mem_mask ); | |
| 1930 | 1930 | } |
| 1931 | 1931 | |
| 1932 | 1932 | WRITE_LINE_DEVICE_HANDLER(thomson_index_callback) |
| r17964 | r17965 | |
|---|---|---|
| 33 | 33 | /* external controllers */ |
| 34 | 34 | extern void to7_floppy_init ( running_machine &machine, void* base ); |
| 35 | 35 | extern void to7_floppy_reset ( running_machine &machine ); |
| 36 | extern READ8_HANDLER ( to7_floppy_r ); | |
| 37 | extern WRITE8_HANDLER ( to7_floppy_w ); | |
| 36 | extern DECLARE_READ8_HANDLER ( to7_floppy_r ); | |
| 37 | extern DECLARE_WRITE8_HANDLER ( to7_floppy_w ); | |
| 38 | 38 | |
| 39 | 39 | /* TO9 internal (WD2793) & external controllers */ |
| 40 | 40 | extern void to9_floppy_init ( running_machine &machine, void* int_base, void* ext_base ); |
| 41 | 41 | extern void to9_floppy_reset ( running_machine &machine ); |
| 42 | extern READ8_HANDLER ( to9_floppy_r ); | |
| 43 | extern WRITE8_HANDLER ( to9_floppy_w ); | |
| 42 | extern DECLARE_READ8_HANDLER ( to9_floppy_r ); | |
| 43 | extern DECLARE_WRITE8_HANDLER ( to9_floppy_w ); | |
| 44 | 44 | |
| 45 | 45 | /* TO8 internal (THMFC1) controller */ |
| 46 | 46 | extern void thmfc_floppy_init ( running_machine &machine ); |
| 47 | 47 | extern void thmfc_floppy_reset ( running_machine &machine ); |
| 48 | extern READ8_HANDLER ( thmfc_floppy_r ); | |
| 49 | extern WRITE8_HANDLER ( thmfc_floppy_w ); | |
| 48 | extern DECLARE_READ8_HANDLER ( thmfc_floppy_r ); | |
| 49 | extern DECLARE_WRITE8_HANDLER ( thmfc_floppy_w ); | |
| 50 | 50 | |
| 51 | 51 | extern WRITE_LINE_DEVICE_HANDLER(thomson_index_callback); |
| 52 | 52 |
| r17964 | r17965 | |
|---|---|---|
| 5 | 5 | |
| 6 | 6 | void fd800_machine_init(running_machine &machine, void (*interrupt_callback)(running_machine &machine, int state)); |
| 7 | 7 | |
| 8 | extern READ8_HANDLER(fd800_cru_r); | |
| 9 | extern WRITE8_HANDLER(fd800_cru_w); | |
| 8 | extern DECLARE_READ8_HANDLER(fd800_cru_r); | |
| 9 | extern DECLARE_WRITE8_HANDLER(fd800_cru_w); | |
| 10 | 10 |
| r17964 | r17965 | |
|---|---|---|
| 1209 | 1209 | prg16_89ab(space.machine(), data); |
| 1210 | 1210 | break; |
| 1211 | 1211 | default: |
| 1212 | pxrom_w(space, offset, data); | |
| 1212 | pxrom_w(space, offset, data, mem_mask); | |
| 1213 | 1213 | break; |
| 1214 | 1214 | } |
| 1215 | 1215 | } |
| r17964 | r17965 | |
| 1451 | 1451 | break; |
| 1452 | 1452 | |
| 1453 | 1453 | default: |
| 1454 | txrom_w(space, offset, data); | |
| 1454 | txrom_w(space, offset, data, mem_mask); | |
| 1455 | 1455 | break; |
| 1456 | 1456 | } |
| 1457 | 1457 | } |
| r17964 | r17965 | |
| 1504 | 1504 | break; |
| 1505 | 1505 | |
| 1506 | 1506 | default: |
| 1507 | txrom_w(space, offset, data); | |
| 1507 | txrom_w(space, offset, data, mem_mask); | |
| 1508 | 1508 | break; |
| 1509 | 1509 | } |
| 1510 | 1510 | } |
| r17964 | r17965 | |
| 1582 | 1582 | break; |
| 1583 | 1583 | |
| 1584 | 1584 | default: |
| 1585 | txrom_w(space, offset, data); | |
| 1585 | txrom_w(space, offset, data, mem_mask); | |
| 1586 | 1586 | break; |
| 1587 | 1587 | } |
| 1588 | 1588 | } |
| r17964 | r17965 | |
| 2618 | 2618 | if (!(offset & 1)) |
| 2619 | 2619 | set_nt_mirroring(space.machine(), BIT(data, 6) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW); |
| 2620 | 2620 | |
| 2621 | dxrom_w(space, offset, data); | |
| 2621 | dxrom_w(space, offset, data, mem_mask); | |
| 2622 | 2622 | } |
| 2623 | 2623 | |
| 2624 | 2624 | /************************************************************* |
| r17964 | r17965 | |
| 2884 | 2884 | LOG_MMC(("lz93d50_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 2885 | 2885 | |
| 2886 | 2886 | if (!state->m_battery && !state->m_wram) |
| 2887 | lz93d50_w(space, offset & 0x0f, data); | |
| 2887 | lz93d50_w(space, offset & 0x0f, data, mem_mask); | |
| 2888 | 2888 | else if (state->m_battery) |
| 2889 | 2889 | state->m_battery_ram[offset] = data; |
| 2890 | 2890 | else |
| r17964 | r17965 | |
| 2921 | 2921 | fjump2_set_prg(space.machine()); |
| 2922 | 2922 | break; |
| 2923 | 2923 | default: |
| 2924 | lz93d50_m_w(space, offset & 0x0f, data); | |
| 2924 | lz93d50_m_w(space, offset & 0x0f, data, mem_mask); | |
| 2925 | 2925 | break; |
| 2926 | 2926 | } |
| 2927 | 2927 | } |
| r17964 | r17965 | |
| 4167 | 4167 | case 0x2001: |
| 4168 | 4168 | case 0x2002: |
| 4169 | 4169 | case 0x2003: |
| 4170 | tc0190fmc_w(space, offset, data); | |
| 4170 | tc0190fmc_w(space, offset, data, mem_mask); | |
| 4171 | 4171 | break; |
| 4172 | 4172 | case 0x4000: |
| 4173 | 4173 | state->m_IRQ_count_latch = (0x100 - data) & 0xff; |
| r17964 | r17965 | |
| 4290 | 4290 | break; |
| 4291 | 4291 | } |
| 4292 | 4292 | |
| 4293 | x1005_m_w(space, offset, data); | |
| 4293 | x1005_m_w(space, offset, data, mem_mask); | |
| 4294 | 4294 | } |
| 4295 | 4295 | |
| 4296 | 4296 | /************************************************************* |
| r17964 | r17965 | |
| 5769 | 5769 | switch (offset & 0x6003) |
| 5770 | 5770 | { |
| 5771 | 5771 | case 0x0000: |
| 5772 | txrom_w(space, offset, data); | |
| 5772 | txrom_w(space, offset, data, mem_mask); | |
| 5773 | 5773 | mmc3_set_prg(space.machine(), state->m_mmc_prg_base, state->m_mmc_prg_mask); |
| 5774 | 5774 | break; |
| 5775 | 5775 | |
| r17964 | r17965 | |
| 5778 | 5778 | | (BIT(data, 3) << 2) | (BIT(data, 4) << 1) | BIT(data, 5); |
| 5779 | 5779 | if (!state->m_mmc_reg[7]) |
| 5780 | 5780 | kay_pp_update_regs(space.machine()); |
| 5781 | txrom_w(space, offset, data); | |
| 5781 | txrom_w(space, offset, data, mem_mask); | |
| 5782 | 5782 | mmc3_set_prg(space.machine(), state->m_mmc_prg_base, state->m_mmc_prg_mask); |
| 5783 | 5783 | break; |
| 5784 | 5784 | |
| 5785 | 5785 | case 0x0003: |
| 5786 | 5786 | state->m_mmc_reg[5] = data; |
| 5787 | 5787 | kay_pp_update_regs(space.machine()); |
| 5788 | txrom_w(space, 0x0000, data); | |
| 5788 | txrom_w(space, 0x0000, data, mem_mask); | |
| 5789 | 5789 | mmc3_set_prg(space.machine(), state->m_mmc_prg_base, state->m_mmc_prg_mask); |
| 5790 | 5790 | break; |
| 5791 | 5791 | |
| 5792 | 5792 | default: |
| 5793 | txrom_w(space, offset, data); | |
| 5793 | txrom_w(space, offset, data, mem_mask); | |
| 5794 | 5794 | break; |
| 5795 | 5795 | } |
| 5796 | 5796 | } |
| r17964 | r17965 | |
| 5985 | 5985 | { |
| 5986 | 5986 | LOG_MMC(("nitra_w, offset: %04x, data: %02x\n", offset, data)); |
| 5987 | 5987 | |
| 5988 | txrom_w(space, (offset & 0x6000) | ((offset & 0x400) >> 10), offset & 0xff); | |
| 5988 | txrom_w(space, (offset & 0x6000) | ((offset & 0x400) >> 10), offset & 0xff, mem_mask); | |
| 5989 | 5989 | } |
| 5990 | 5990 | |
| 5991 | 5991 | /************************************************************* |
| r17964 | r17965 | |
| 6387 | 6387 | break; |
| 6388 | 6388 | |
| 6389 | 6389 | default: |
| 6390 | txrom_w(space, offset, data); | |
| 6390 | txrom_w(space, offset, data, mem_mask); | |
| 6391 | 6391 | break; |
| 6392 | 6392 | } |
| 6393 | 6393 | } |
| r17964 | r17965 | |
| 6811 | 6811 | { |
| 6812 | 6812 | LOG_MMC(("tcu01_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 6813 | 6813 | |
| 6814 | tcu01_l_w(space, (offset + 0x100) & 0xfff, data); | |
| 6814 | tcu01_l_w(space, (offset + 0x100) & 0xfff, data, mem_mask); | |
| 6815 | 6815 | } |
| 6816 | 6816 | |
| 6817 | 6817 | static WRITE8_HANDLER( tcu01_w ) |
| 6818 | 6818 | { |
| 6819 | 6819 | LOG_MMC(("tcu01_w, offset: %04x, data: %02x\n", offset, data)); |
| 6820 | 6820 | |
| 6821 | tcu01_l_w(space, (offset + 0x100) & 0xfff, data); | |
| 6821 | tcu01_l_w(space, (offset + 0x100) & 0xfff, data, mem_mask); | |
| 6822 | 6822 | } |
| 6823 | 6823 | |
| 6824 | 6824 | /************************************************************* |
| r17964 | r17965 | |
| 7047 | 7047 | { |
| 7048 | 7048 | case 0x0000: |
| 7049 | 7049 | if (!state->m_mmc_reg[2]) |
| 7050 | txrom_w(space, 0x0000, data); | |
| 7050 | txrom_w(space, 0x0000, data, mem_mask); | |
| 7051 | 7051 | break; |
| 7052 | 7052 | |
| 7053 | 7053 | case 0x0001: |
| 7054 | 7054 | if (!state->m_mmc_reg[2]) |
| 7055 | txrom_w(space, 0x0001, data); | |
| 7055 | txrom_w(space, 0x0001, data, mem_mask); | |
| 7056 | 7056 | else if (state->m_mmc_reg[3] && ((state->m_mmc_reg[0] & 0x80) == 0 || (state->m_mmc_latch1 & 0x07) < 6)) // if we use the prg16 banks and cmd=6,7 DON'T enter! |
| 7057 | 7057 | { |
| 7058 | 7058 | state->m_mmc_reg[3] = 0; |
| 7059 | txrom_w(space, 0x0001, data); | |
| 7059 | txrom_w(space, 0x0001, data, mem_mask); | |
| 7060 | 7060 | } |
| 7061 | 7061 | break; |
| 7062 | 7062 | |
| 7063 | 7063 | case 0x2000: |
| 7064 | 7064 | if (!state->m_mmc_reg[2]) |
| 7065 | txrom_w(space, 0x2000, data); | |
| 7065 | txrom_w(space, 0x2000, data, mem_mask); | |
| 7066 | 7066 | else |
| 7067 | 7067 | { |
| 7068 | 7068 | data = (data & 0xc0) | conv_table[data & 0x07]; |
| 7069 | 7069 | state->m_mmc_reg[3] = 1; |
| 7070 | txrom_w(space, 0x0000, data); | |
| 7070 | txrom_w(space, 0x0000, data, mem_mask); | |
| 7071 | 7071 | break; |
| 7072 | 7072 | } |
| 7073 | 7073 | break; |
| 7074 | 7074 | |
| 7075 | 7075 | case 0x4000: |
| 7076 | 7076 | if (!state->m_mmc_reg[2]) |
| 7077 | txrom_w(space, 0x4000, data); | |
| 7077 | txrom_w(space, 0x4000, data, mem_mask); | |
| 7078 | 7078 | else |
| 7079 | 7079 | set_nt_mirroring(space.machine(), ((data >> 7) | data) & 0x01 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT); |
| 7080 | 7080 | break; |
| 7081 | 7081 | |
| 7082 | 7082 | case 0x4001: |
| 7083 | 7083 | if (!state->m_mmc_reg[2]) |
| 7084 | txrom_w(space, 0x4001, data); | |
| 7084 | txrom_w(space, 0x4001, data, mem_mask); | |
| 7085 | 7085 | else |
| 7086 | txrom_w(space, 0x6001, data); | |
| 7086 | txrom_w(space, 0x6001, data, mem_mask); | |
| 7087 | 7087 | break; |
| 7088 | 7088 | |
| 7089 | 7089 | case 0x6001: |
| 7090 | 7090 | if (!state->m_mmc_reg[2]) |
| 7091 | txrom_w(space, 0x6001, data); | |
| 7091 | txrom_w(space, 0x6001, data, mem_mask); | |
| 7092 | 7092 | else |
| 7093 | 7093 | { |
| 7094 | txrom_w(space, 0x4000, data); | |
| 7095 | txrom_w(space, 0x4001, data); | |
| 7094 | txrom_w(space, 0x4000, data, mem_mask); | |
| 7095 | txrom_w(space, 0x4001, data, mem_mask); | |
| 7096 | 7096 | } |
| 7097 | 7097 | break; |
| 7098 | 7098 | |
| 7099 | 7099 | default: |
| 7100 | txrom_w(space, offset, data); | |
| 7100 | txrom_w(space, offset, data, mem_mask); | |
| 7101 | 7101 | break; |
| 7102 | 7102 | } |
| 7103 | 7103 | } |
| r17964 | r17965 | |
| 7149 | 7149 | case 0x2000: |
| 7150 | 7150 | state->m_map114_reg_enabled = 1; |
| 7151 | 7151 | data = (data & 0xc0) | conv_table[data & 0x07]; |
| 7152 | txrom_w(space, 0x0000, data); | |
| 7152 | txrom_w(space, 0x0000, data, mem_mask); | |
| 7153 | 7153 | break; |
| 7154 | 7154 | case 0x4000: |
| 7155 | 7155 | if (state->m_map114_reg_enabled && (state->m_map114_reg & 0x80) == 0) |
| 7156 | 7156 | { |
| 7157 | 7157 | state->m_map114_reg_enabled = 0; |
| 7158 | txrom_w(space, 0x0001, data); | |
| 7158 | txrom_w(space, 0x0001, data, mem_mask); | |
| 7159 | 7159 | } |
| 7160 | 7160 | break; |
| 7161 | 7161 | } |
| r17964 | r17965 | |
| 7165 | 7165 | switch (offset & 0x03) |
| 7166 | 7166 | { |
| 7167 | 7167 | case 0x02: |
| 7168 | txrom_w(space, 0x6000, data); | |
| 7168 | txrom_w(space, 0x6000, data, mem_mask); | |
| 7169 | 7169 | break; |
| 7170 | 7170 | case 0x03: |
| 7171 | txrom_w(space, 0x6001, data); | |
| 7172 | txrom_w(space, 0x4000, data); | |
| 7173 | txrom_w(space, 0x4001, data); | |
| 7171 | txrom_w(space, 0x6001, data, mem_mask); | |
| 7172 | txrom_w(space, 0x4000, data, mem_mask); | |
| 7173 | txrom_w(space, 0x4001, data, mem_mask); | |
| 7174 | 7174 | break; |
| 7175 | 7175 | } |
| 7176 | 7176 | } |
| r17964 | r17965 | |
| 7452 | 7452 | break; |
| 7453 | 7453 | |
| 7454 | 7454 | default: |
| 7455 | tengen_800032_w(space, offset, data); | |
| 7455 | tengen_800032_w(space, offset, data, mem_mask); | |
| 7456 | 7456 | break; |
| 7457 | 7457 | } |
| 7458 | 7458 | } |
| r17964 | r17965 | |
| 7577 | 7577 | { |
| 7578 | 7578 | LOG_MMC(("txctw_m_w, offset: %04x, data: %04x\n", offset, data)); |
| 7579 | 7579 | |
| 7580 | txc_tw_l_w(space, offset & 0xff, data); // offset does not really count for this mapper | |
| 7580 | txc_tw_l_w(space, offset & 0xff, data, mem_mask); // offset does not really count for this mapper | |
| 7581 | 7581 | } |
| 7582 | 7582 | |
| 7583 | 7583 | /* writes to 0x8000-0xffff are like MMC3 but no PRG bankswitch (beacuse it is handled by low writes) */ |
| r17964 | r17965 | |
| 7705 | 7705 | break; |
| 7706 | 7706 | |
| 7707 | 7707 | default: |
| 7708 | txrom_w(space, offset, data); | |
| 7708 | txrom_w(space, offset, data, mem_mask); | |
| 7709 | 7709 | break; |
| 7710 | 7710 | } |
| 7711 | 7711 | } |
| r17964 | r17965 | |
| 7829 | 7829 | mmc3_set_prg(space.machine(), state->m_mmc_prg_base, state->m_mmc_prg_mask); |
| 7830 | 7830 | } |
| 7831 | 7831 | else |
| 7832 | waixing_a_w(space, offset, data); | |
| 7832 | waixing_a_w(space, offset, data, mem_mask); | |
| 7833 | 7833 | break; |
| 7834 | 7834 | |
| 7835 | 7835 | default: |
| 7836 | waixing_a_w(space, offset, data); | |
| 7836 | waixing_a_w(space, offset, data, mem_mask); | |
| 7837 | 7837 | break; |
| 7838 | 7838 | } |
| 7839 | 7839 | } |
| r17964 | r17965 | |
| 7919 | 7919 | break; |
| 7920 | 7920 | |
| 7921 | 7921 | default: |
| 7922 | waixing_a_w(space, offset, data); | |
| 7922 | waixing_a_w(space, offset, data, mem_mask); | |
| 7923 | 7923 | break; |
| 7924 | 7924 | } |
| 7925 | 7925 | } |
| r17964 | r17965 | |
| 7961 | 7961 | state->m_mmc_prg_base = (data << 5) & 0x40; |
| 7962 | 7962 | state->m_mmc_prg_mask = 0x3f; |
| 7963 | 7963 | mmc3_set_prg(space.machine(), state->m_mmc_prg_base, state->m_mmc_prg_mask); |
| 7964 | txrom_w(space, offset, data); | |
| 7964 | txrom_w(space, offset, data, mem_mask); | |
| 7965 | 7965 | default: |
| 7966 | txrom_w(space, offset, data); | |
| 7966 | txrom_w(space, offset, data, mem_mask); | |
| 7967 | 7967 | break; |
| 7968 | 7968 | } |
| 7969 | 7969 | break; |
| r17964 | r17965 | |
| 7972 | 7972 | break; |
| 7973 | 7973 | |
| 7974 | 7974 | default: |
| 7975 | txrom_w(space, offset, data); | |
| 7975 | txrom_w(space, offset, data, mem_mask); | |
| 7976 | 7976 | break; |
| 7977 | 7977 | } |
| 7978 | 7978 | } |
| r17964 | r17965 | |
| 8399 | 8399 | case 0x3000: |
| 8400 | 8400 | state->m_mmc_reg[2] = 1; |
| 8401 | 8401 | data = (data & 0xc0) | conv_table[data & 0x07]; |
| 8402 | txrom_w(space, 0x0000, data); | |
| 8402 | txrom_w(space, 0x0000, data, mem_mask); | |
| 8403 | 8403 | break; |
| 8404 | 8404 | |
| 8405 | 8405 | case 0x4000: |
| r17964 | r17965 | |
| 8407 | 8407 | if (state->m_mmc_reg[2]) |
| 8408 | 8408 | { |
| 8409 | 8409 | state->m_mmc_reg[2] = 0; |
| 8410 | txrom_w(space, 0x0001, data); | |
| 8410 | txrom_w(space, 0x0001, data, mem_mask); | |
| 8411 | 8411 | } |
| 8412 | 8412 | break; |
| 8413 | 8413 | |
| r17964 | r17965 | |
| 8415 | 8415 | break; |
| 8416 | 8416 | |
| 8417 | 8417 | case 0x7000: |
| 8418 | txrom_w(space, 0x6001, data); | |
| 8419 | txrom_w(space, 0x4000, data); | |
| 8420 | txrom_w(space, 0x4001, data); | |
| 8418 | txrom_w(space, 0x6001, data, mem_mask); | |
| 8419 | txrom_w(space, 0x4000, data, mem_mask); | |
| 8420 | txrom_w(space, 0x4001, data, mem_mask); | |
| 8421 | 8421 | break; |
| 8422 | 8422 | } |
| 8423 | 8423 | } |
| r17964 | r17965 | |
| 8538 | 8538 | if (offset == 0x1000) |
| 8539 | 8539 | { |
| 8540 | 8540 | data = unl_kof97_unscramble(data); |
| 8541 | txrom_w(space, 0x0001, data); | |
| 8541 | txrom_w(space, 0x0001, data, mem_mask); | |
| 8542 | 8542 | } |
| 8543 | 8543 | else if (offset == 0x2000) |
| 8544 | 8544 | { |
| 8545 | 8545 | data = unl_kof97_unscramble(data); |
| 8546 | txrom_w(space, 0x0000, data); | |
| 8546 | txrom_w(space, 0x0000, data, mem_mask); | |
| 8547 | 8547 | } |
| 8548 | 8548 | else if (offset == 0x5000) |
| 8549 | 8549 | { |
| 8550 | 8550 | data = unl_kof97_unscramble(data); |
| 8551 | txrom_w(space, 0x4001, data); | |
| 8551 | txrom_w(space, 0x4001, data, mem_mask); | |
| 8552 | 8552 | } |
| 8553 | 8553 | else if (offset == 0x7000) |
| 8554 | 8554 | { |
| 8555 | 8555 | data = unl_kof97_unscramble(data); |
| 8556 | txrom_w(space, 0x6001, data); | |
| 8556 | txrom_w(space, 0x6001, data, mem_mask); | |
| 8557 | 8557 | } |
| 8558 | 8558 | else /* Other addresses behaves like MMC3, up to unscrambling data */ |
| 8559 | 8559 | { |
| r17964 | r17965 | |
| 8568 | 8568 | case 0x2000: /* are these ever called?!? */ |
| 8569 | 8569 | case 0x2001: |
| 8570 | 8570 | data = unl_kof97_unscramble(data); |
| 8571 | txrom_w(space, offset, data); | |
| 8571 | txrom_w(space, offset, data, mem_mask); | |
| 8572 | 8572 | break; |
| 8573 | 8573 | } |
| 8574 | 8574 | } |
| r17964 | r17965 | |
| 8590 | 8590 | { |
| 8591 | 8591 | LOG_MMC(("ks7057_w, offset: %04x, data: %02x\n", offset, data)); |
| 8592 | 8592 | offset = (BIT(offset, 0) << 1) | BIT(offset, 1) | (offset & ~0x03); |
| 8593 | txrom_w(space, offset, data); | |
| 8593 | txrom_w(space, offset, data, mem_mask); | |
| 8594 | 8594 | } |
| 8595 | 8595 | |
| 8596 | 8596 | /************************************************************* |
| r17964 | r17965 | |
| 8785 | 8785 | { |
| 8786 | 8786 | case 0x0000: |
| 8787 | 8787 | state->m_mmc_reg[2] = 1; |
| 8788 | txrom_w(space, 0x0000, data); | |
| 8788 | txrom_w(space, 0x0000, data, mem_mask); | |
| 8789 | 8789 | break; |
| 8790 | 8790 | |
| 8791 | 8791 | case 0x0001: |
| 8792 | 8792 | if (state->m_mmc_reg[2]) |
| 8793 | txrom_w(space, 0x0001, data); | |
| 8793 | txrom_w(space, 0x0001, data, mem_mask); | |
| 8794 | 8794 | break; |
| 8795 | 8795 | |
| 8796 | 8796 | case 0x0002: |
| r17964 | r17965 | |
| 8806 | 8806 | break; |
| 8807 | 8807 | |
| 8808 | 8808 | default: |
| 8809 | txrom_w(space, offset, data); | |
| 8809 | txrom_w(space, offset, data, mem_mask); | |
| 8810 | 8810 | break; |
| 8811 | 8811 | } |
| 8812 | 8812 | } |
| r17964 | r17965 | |
| 9172 | 9172 | break; |
| 9173 | 9173 | |
| 9174 | 9174 | default: |
| 9175 | txrom_w(space, offset, data); | |
| 9175 | txrom_w(space, offset, data, mem_mask); | |
| 9176 | 9176 | break; |
| 9177 | 9177 | } |
| 9178 | 9178 | } |
| r17964 | r17965 | |
| 9290 | 9290 | { |
| 9291 | 9291 | LOG_MMC(("btl_smb11_w, offset: %04x, data: %02x\n", offset, data)); |
| 9292 | 9292 | |
| 9293 | txrom_w(space, (offset & 0x6000) | ((offset & 0x04) >> 2), data); | |
| 9293 | txrom_w(space, (offset & 0x6000) | ((offset & 0x04) >> 2), data, mem_mask); | |
| 9294 | 9294 | } |
| 9295 | 9295 | |
| 9296 | 9296 | /************************************************************* |
| r17964 | r17965 | |
| 9589 | 9589 | case 0x2000: |
| 9590 | 9590 | state->m_mmc_reg[0] = 0; |
| 9591 | 9591 | default: |
| 9592 | txrom_w(space, offset, data); | |
| 9592 | txrom_w(space, offset, data, mem_mask); | |
| 9593 | 9593 | break; |
| 9594 | 9594 | } |
| 9595 | 9595 | } |
| r17964 | r17965 | |
| 9759 | 9759 | fk23c_set_chr(space.machine()); |
| 9760 | 9760 | } |
| 9761 | 9761 | else |
| 9762 | txrom_w(space, offset, data); | |
| 9762 | txrom_w(space, offset, data, mem_mask); | |
| 9763 | 9763 | break; |
| 9764 | 9764 | |
| 9765 | 9765 | case 0x2000: |
| r17964 | r17965 | |
| 9767 | 9767 | break; |
| 9768 | 9768 | |
| 9769 | 9769 | default: |
| 9770 | txrom_w(space, offset, data); | |
| 9770 | txrom_w(space, offset, data, mem_mask); | |
| 9771 | 9771 | break; |
| 9772 | 9772 | } |
| 9773 | 9773 | } |
| r17964 | r17965 | |
| 10684 | 10684 | break; |
| 10685 | 10685 | |
| 10686 | 10686 | default: |
| 10687 | txrom_w(space, offset, data); | |
| 10687 | txrom_w(space, offset, data, mem_mask); | |
| 10688 | 10688 | break; |
| 10689 | 10689 | } |
| 10690 | 10690 | } |
| r17964 | r17965 | |
| 11033 | 11033 | break; |
| 11034 | 11034 | |
| 11035 | 11035 | default: |
| 11036 | txrom_w(space, offset, data); | |
| 11036 | txrom_w(space, offset, data, mem_mask); | |
| 11037 | 11037 | break; |
| 11038 | 11038 | } |
| 11039 | 11039 | } |
| r17964 | r17965 | |
| 11042 | 11042 | switch (offset & 0x6001) |
| 11043 | 11043 | { |
| 11044 | 11044 | case 0x0000: |
| 11045 | txrom_w(space, 0x4000, data); | |
| 11045 | txrom_w(space, 0x4000, data, mem_mask); | |
| 11046 | 11046 | break; |
| 11047 | 11047 | |
| 11048 | 11048 | case 0x0001: |
| r17964 | r17965 | |
| 11088 | 11088 | break; |
| 11089 | 11089 | |
| 11090 | 11090 | default: |
| 11091 | txrom_w(space, offset, data); | |
| 11091 | txrom_w(space, offset, data, mem_mask); | |
| 11092 | 11092 | break; |
| 11093 | 11093 | } |
| 11094 | 11094 | } |
| r17964 | r17965 | |
| 11382 | 11382 | switch (offset & 0x6001) |
| 11383 | 11383 | { |
| 11384 | 11384 | case 0x0000: |
| 11385 | txrom_w(space, 0x0000, (data & 0xc0) | conv_table[data & 0x07]); | |
| 11385 | txrom_w(space, 0x0000, (data & 0xc0) | conv_table[data & 0x07], mem_mask); | |
| 11386 | 11386 | break; |
| 11387 | 11387 | |
| 11388 | 11388 | default: |
| 11389 | txrom_w(space, offset, data); | |
| 11389 | txrom_w(space, offset, data, mem_mask); | |
| 11390 | 11390 | break; |
| 11391 | 11391 | } |
| 11392 | 11392 | } |
| r17964 | r17965 | |
| 11802 | 11802 | |
| 11803 | 11803 | switch (state->m_mmc_cmd1) |
| 11804 | 11804 | { |
| 11805 | case 0x00: someri_vrc2_w(space, offset, data); break; | |
| 11806 | case 0x01: someri_mmc3_w(space, offset, data); break; | |
| 11807 | case 0x02: someri_mmc1_w(space, offset, data); break; | |
| 11805 | case 0x00: someri_vrc2_w(space, offset, data, mem_mask); break; | |
| 11806 | case 0x01: someri_mmc3_w(space, offset, data, mem_mask); break; | |
| 11807 | case 0x02: someri_mmc1_w(space, offset, data, mem_mask); break; | |
| 11808 | 11808 | } |
| 11809 | 11809 | } |
| 11810 | 11810 |
| r17964 | r17965 | |
|---|---|---|
| 276 | 276 | { |
| 277 | 277 | int slot = ((offset >> 4) & 7) - 1; |
| 278 | 278 | if (m_expansion_slots[slot].reg_read) |
| 279 | return m_expansion_slots[slot].reg_read(space, offset & 0xf); | |
| 279 | return m_expansion_slots[slot].reg_read(space, offset & 0xf, mem_mask); | |
| 280 | 280 | } |
| 281 | 281 | break; |
| 282 | 282 | |
| r17964 | r17965 | |
| 299 | 299 | int slot = ((offset >> 8) & 7) - 1; |
| 300 | 300 | LOG(("concept_io_r: Slot ROM memory accessed for slot %d at address 0x03%4.4x\n", slot, offset << 1)); |
| 301 | 301 | if (m_expansion_slots[slot].rom_read) |
| 302 | return m_expansion_slots[slot].rom_read(space, offset & 0xff); | |
| 302 | return m_expansion_slots[slot].rom_read(space, offset & 0xff, mem_mask); | |
| 303 | 303 | } |
| 304 | 304 | break; |
| 305 | 305 | |
| r17964 | r17965 | |
| 418 | 418 | LOG(("concept_io_w: Slot I/O register written for slot %d at address 0x03%4.4x, data: 0x%4.4x\n", |
| 419 | 419 | slot, offset << 1, data)); |
| 420 | 420 | if (m_expansion_slots[slot].reg_write) |
| 421 | m_expansion_slots[slot].reg_write(space, offset & 0xf, data); | |
| 421 | m_expansion_slots[slot].reg_write(space, offset & 0xf, data, mem_mask); | |
| 422 | 422 | } |
| 423 | 423 | break; |
| 424 | 424 | |
| r17964 | r17965 | |
| 441 | 441 | int slot = ((offset >> 8) & 7) - 1; |
| 442 | 442 | LOG(("concept_io_w: Slot ROM memory written to for slot %d at address 0x03%4.4x, data: 0x%4.4x\n", slot, offset << 1, data)); |
| 443 | 443 | if (m_expansion_slots[slot].rom_write) |
| 444 | m_expansion_slots[slot].rom_write(space, offset & 0xff, data); | |
| 444 | m_expansion_slots[slot].rom_write(space, offset & 0xff, data, mem_mask); | |
| 445 | 445 | } |
| 446 | 446 | break; |
| 447 | 447 | |
| r17964 | r17965 | |
| 548 | 548 | }; |
| 549 | 549 | |
| 550 | 550 | |
| 551 | static READ8_HANDLER(concept_fdc_reg_r); | |
| 552 | static WRITE8_HANDLER(concept_fdc_reg_w); | |
| 553 | static READ8_HANDLER(concept_fdc_rom_r); | |
| 551 | static DECLARE_READ8_HANDLER(concept_fdc_reg_r); | |
| 552 | static DECLARE_WRITE8_HANDLER(concept_fdc_reg_w); | |
| 553 | static DECLARE_READ8_HANDLER(concept_fdc_rom_r); | |
| 554 | 554 | |
| 555 | 555 | static void concept_fdc_init(running_machine &machine, int slot) |
| 556 | 556 | { |
| r17964 | r17965 | |
| 670 | 670 | * Concept Hard Disk Controller (hdc) |
| 671 | 671 | */ |
| 672 | 672 | |
| 673 | static READ8_HANDLER(concept_hdc_reg_r); | |
| 674 | static WRITE8_HANDLER(concept_hdc_reg_w); | |
| 675 | static READ8_HANDLER(concept_hdc_rom_r); | |
| 673 | static DECLARE_READ8_HANDLER(concept_hdc_reg_r); | |
| 674 | static DECLARE_WRITE8_HANDLER(concept_hdc_reg_w); | |
| 675 | static DECLARE_READ8_HANDLER(concept_hdc_rom_r); | |
| 676 | 676 | |
| 677 | 677 | /* |
| 678 | 678 | * Hook up the Register and ROM R/W routines into the Slot I/O Space |
| r17964 | r17965 | |
|---|---|---|
| 52 | 52 | FUNCTION PROTOTYPES |
| 53 | 53 | ***************************************************************************/ |
| 54 | 54 | |
| 55 | READ8_HANDLER( mboard_read_board_8 ); | |
| 56 | WRITE8_HANDLER( mboard_write_board_8 ); | |
| 57 | WRITE8_HANDLER( mboard_write_LED_8 ); | |
| 55 | DECLARE_READ8_HANDLER( mboard_read_board_8 ); | |
| 56 | DECLARE_WRITE8_HANDLER( mboard_write_board_8 ); | |
| 57 | DECLARE_WRITE8_HANDLER( mboard_write_LED_8 ); | |
| 58 | 58 | |
| 59 | READ16_HANDLER( mboard_read_board_16 ); | |
| 60 | WRITE16_HANDLER( mboard_write_board_16 ); | |
| 61 | WRITE16_HANDLER( mboard_write_LED_16 ); | |
| 59 | DECLARE_READ16_HANDLER( mboard_read_board_16 ); | |
| 60 | DECLARE_WRITE16_HANDLER( mboard_write_board_16 ); | |
| 61 | DECLARE_WRITE16_HANDLER( mboard_write_LED_16 ); | |
| 62 | 62 | |
| 63 | READ32_HANDLER( mboard_read_board_32 ); | |
| 64 | WRITE32_HANDLER( mboard_write_board_32 ); | |
| 65 | WRITE32_HANDLER( mboard_write_LED_32 ); | |
| 63 | DECLARE_READ32_HANDLER( mboard_read_board_32 ); | |
| 64 | DECLARE_WRITE32_HANDLER( mboard_write_board_32 ); | |
| 65 | DECLARE_WRITE32_HANDLER( mboard_write_LED_32 ); | |
| 66 | 66 | |
| 67 | 67 | TIMER_DEVICE_CALLBACK( mboard_update_artwork ); |
| 68 | 68 |
| r17964 | r17965 | |
|---|---|---|
| 1769 | 1769 | |
| 1770 | 1770 | case 0x8c: |
| 1771 | 1771 | case 0x8d: |
| 1772 | value = lynx_uart_r(space, offset); | |
| 1772 | value = lynx_uart_r(space, offset, mem_mask); | |
| 1773 | 1773 | break; |
| 1774 | 1774 | |
| 1775 | 1775 | default: |
| r17964 | r17965 | |
|---|---|---|
| 174 | 174 | // Prototypes |
| 175 | 175 | // |
| 176 | 176 | UINT8 corvus_hdc_init( running_machine &machine ); |
| 177 | READ8_HANDLER ( corvus_hdc_status_r ); | |
| 178 | READ8_HANDLER ( corvus_hdc_data_r ); | |
| 179 | WRITE8_HANDLER ( corvus_hdc_data_w ); | |
| 177 | DECLARE_READ8_HANDLER ( corvus_hdc_status_r ); | |
| 178 | DECLARE_READ8_HANDLER ( corvus_hdc_data_r ); | |
| 179 | DECLARE_WRITE8_HANDLER ( corvus_hdc_data_w ); | |
| 180 | 180 | |
| 181 | 181 | |
| 182 | 182 | #endif /* CORVUSHD_H_ */ |
| r17964 | r17965 | |
|---|---|---|
| 156 | 156 | |
| 157 | 157 | |
| 158 | 158 | // Page IO at FE00 |
| 159 | READ8_HANDLER( dgn_beta_page_r ); | |
| 160 | WRITE8_HANDLER( dgn_beta_page_w ); | |
| 159 | DECLARE_READ8_HANDLER( dgn_beta_page_r ); | |
| 160 | DECLARE_WRITE8_HANDLER( dgn_beta_page_w ); | |
| 161 | 161 | |
| 162 | 162 | /* WD2797 FDC */ |
| 163 | READ8_HANDLER(dgnbeta_wd2797_r); | |
| 164 | WRITE8_HANDLER(dgnbeta_wd2797_w); | |
| 163 | DECLARE_READ8_HANDLER(dgnbeta_wd2797_r); | |
| 164 | DECLARE_WRITE8_HANDLER(dgnbeta_wd2797_w); | |
| 165 | 165 | |
| 166 | 166 | void dgn_beta_frame_interrupt (running_machine &machine, int data); |
| 167 | 167 | |
| r17964 | r17965 | |
| 172 | 172 | void dgnbeta_vid_set_gctrl(running_machine &machine, int data); |
| 173 | 173 | |
| 174 | 174 | /* 74HC670 4x4bit colour ram */ |
| 175 | WRITE8_HANDLER(dgnbeta_colour_ram_w); | |
| 175 | DECLARE_WRITE8_HANDLER(dgnbeta_colour_ram_w); | |
| 176 | 176 | |
| 177 | 177 | extern const mc6845_interface dgnbeta_crtc6845_interface; |
| 178 | 178 |
| r17964 | r17965 | |
|---|---|---|
| 10 | 10 | |
| 11 | 11 | /*----------- defined in machine/ps2.c -----------*/ |
| 12 | 12 | |
| 13 | READ8_HANDLER(ps2_pos_r); | |
| 14 | WRITE8_HANDLER(ps2_pos_w); | |
| 13 | DECLARE_READ8_HANDLER(ps2_pos_r); | |
| 14 | DECLARE_WRITE8_HANDLER(ps2_pos_w); | |
| 15 | 15 | |
| 16 | 16 | |
| 17 | 17 | #endif /* PS2_H_ */ |
| r17964 | r17965 | |
|---|---|---|
| 44 | 44 | |
| 45 | 45 | /*----------- defined in video/pc1401.c -----------*/ |
| 46 | 46 | |
| 47 | READ8_HANDLER(pc1401_lcd_read); | |
| 48 | WRITE8_HANDLER(pc1401_lcd_write); | |
| 47 | DECLARE_READ8_HANDLER(pc1401_lcd_read); | |
| 48 | DECLARE_WRITE8_HANDLER(pc1401_lcd_write); | |
| 49 | 49 | SCREEN_UPDATE_IND16( pc1401 ); |
| 50 | 50 | |
| 51 | 51 |
| r17964 | r17965 | |
|---|---|---|
| 42 | 42 | |
| 43 | 43 | /*----------- defined in video/pc1350.c -----------*/ |
| 44 | 44 | |
| 45 | READ8_HANDLER(pc1350_lcd_read); | |
| 46 | WRITE8_HANDLER(pc1350_lcd_write); | |
| 45 | DECLARE_READ8_HANDLER(pc1350_lcd_read); | |
| 46 | DECLARE_WRITE8_HANDLER(pc1350_lcd_write); | |
| 47 | 47 | SCREEN_UPDATE_IND16( pc1350 ); |
| 48 | 48 | |
| 49 | 49 | int pc1350_keyboard_line_r(running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 67 | 67 | |
| 68 | 68 | /* cartridge bank-switching */ |
| 69 | 69 | extern DEVICE_IMAGE_LOAD( to7_cartridge ); |
| 70 | extern WRITE8_HANDLER ( to7_cartridge_w ); | |
| 71 | extern READ8_HANDLER ( to7_cartridge_r ); | |
| 70 | extern DECLARE_WRITE8_HANDLER ( to7_cartridge_w ); | |
| 71 | extern DECLARE_READ8_HANDLER ( to7_cartridge_r ); | |
| 72 | 72 | |
| 73 | 73 | /* dispatch MODEM or speech synthesis extension */ |
| 74 | extern READ8_HANDLER ( to7_modem_mea8000_r ); | |
| 75 | extern WRITE8_HANDLER ( to7_modem_mea8000_w ); | |
| 74 | extern DECLARE_READ8_HANDLER ( to7_modem_mea8000_r ); | |
| 75 | extern DECLARE_WRITE8_HANDLER ( to7_modem_mea8000_w ); | |
| 76 | 76 | |
| 77 | 77 | /* MIDI extension (actually an 6850 ACIA) */ |
| 78 | extern READ8_HANDLER ( to7_midi_r ); | |
| 79 | extern WRITE8_HANDLER ( to7_midi_w ); | |
| 78 | extern DECLARE_READ8_HANDLER ( to7_midi_r ); | |
| 79 | extern DECLARE_WRITE8_HANDLER ( to7_midi_w ); | |
| 80 | 80 | |
| 81 | 81 | extern MACHINE_START ( to7 ); |
| 82 | 82 | extern MACHINE_RESET ( to7 ); |
| r17964 | r17965 | |
| 98 | 98 | /***************************** TO7/70 ******************************/ |
| 99 | 99 | |
| 100 | 100 | /* gate-array */ |
| 101 | extern READ8_HANDLER ( to770_gatearray_r ); | |
| 102 | extern WRITE8_HANDLER ( to770_gatearray_w ); | |
| 101 | extern DECLARE_READ8_HANDLER ( to770_gatearray_r ); | |
| 102 | extern DECLARE_WRITE8_HANDLER ( to770_gatearray_w ); | |
| 103 | 103 | |
| 104 | 104 | extern MACHINE_START ( to770 ); |
| 105 | 105 | extern MACHINE_RESET ( to770 ); |
| r17964 | r17965 | |
| 109 | 109 | /***************************** MO5 ******************************/ |
| 110 | 110 | |
| 111 | 111 | /* gate-array */ |
| 112 | extern READ8_HANDLER ( mo5_gatearray_r ); | |
| 113 | extern WRITE8_HANDLER ( mo5_gatearray_w ); | |
| 112 | extern DECLARE_READ8_HANDLER ( mo5_gatearray_r ); | |
| 113 | extern DECLARE_WRITE8_HANDLER ( mo5_gatearray_w ); | |
| 114 | 114 | |
| 115 | 115 | /* cartridge / extended RAM bank-switching */ |
| 116 | 116 | extern DEVICE_IMAGE_LOAD( mo5_cartridge ); |
| 117 | extern WRITE8_HANDLER ( mo5_ext_w ); | |
| 118 | extern WRITE8_HANDLER ( mo5_cartridge_w ); | |
| 119 | extern READ8_HANDLER ( mo5_cartridge_r ); | |
| 117 | extern DECLARE_WRITE8_HANDLER ( mo5_ext_w ); | |
| 118 | extern DECLARE_WRITE8_HANDLER ( mo5_cartridge_w ); | |
| 119 | extern DECLARE_READ8_HANDLER ( mo5_cartridge_r ); | |
| 120 | 120 | |
| 121 | 121 | extern MACHINE_START ( mo5 ); |
| 122 | 122 | extern MACHINE_RESET ( mo5 ); |
| r17964 | r17965 | |
| 125 | 125 | /***************************** TO9 ******************************/ |
| 126 | 126 | |
| 127 | 127 | /* IEEE extension */ |
| 128 | extern WRITE8_HANDLER ( to9_ieee_w ); | |
| 129 | extern READ8_HANDLER ( to9_ieee_r ); | |
| 128 | extern DECLARE_WRITE8_HANDLER ( to9_ieee_w ); | |
| 129 | extern DECLARE_READ8_HANDLER ( to9_ieee_r ); | |
| 130 | 130 | |
| 131 | 131 | /* ROM bank-switching */ |
| 132 | extern WRITE8_HANDLER ( to9_cartridge_w ); | |
| 133 | extern READ8_HANDLER ( to9_cartridge_r ); | |
| 132 | extern DECLARE_WRITE8_HANDLER ( to9_cartridge_w ); | |
| 133 | extern DECLARE_READ8_HANDLER ( to9_cartridge_r ); | |
| 134 | 134 | |
| 135 | 135 | /* system gate-array */ |
| 136 | extern READ8_HANDLER ( to9_gatearray_r ); | |
| 137 | extern WRITE8_HANDLER ( to9_gatearray_w ); | |
| 136 | extern DECLARE_READ8_HANDLER ( to9_gatearray_r ); | |
| 137 | extern DECLARE_WRITE8_HANDLER ( to9_gatearray_w ); | |
| 138 | 138 | |
| 139 | 139 | /* video gate-array */ |
| 140 | extern READ8_HANDLER ( to9_vreg_r ); | |
| 141 | extern WRITE8_HANDLER ( to9_vreg_w ); | |
| 140 | extern DECLARE_READ8_HANDLER ( to9_vreg_r ); | |
| 141 | extern DECLARE_WRITE8_HANDLER ( to9_vreg_w ); | |
| 142 | 142 | |
| 143 | 143 | /* keyboard */ |
| 144 | extern READ8_HANDLER ( to9_kbd_r ); | |
| 145 | extern WRITE8_HANDLER ( to9_kbd_w ); | |
| 144 | extern DECLARE_READ8_HANDLER ( to9_kbd_r ); | |
| 145 | extern DECLARE_WRITE8_HANDLER ( to9_kbd_w ); | |
| 146 | 146 | |
| 147 | 147 | extern MACHINE_START ( to9 ); |
| 148 | 148 | extern MACHINE_RESET ( to9 ); |
| r17964 | r17965 | |
| 162 | 162 | extern UINT8 to8_data_vpage; |
| 163 | 163 | extern UINT8 to8_cart_vpage; |
| 164 | 164 | |
| 165 | extern WRITE8_HANDLER ( to8_cartridge_w ); | |
| 166 | extern READ8_HANDLER ( to8_cartridge_r ); | |
| 165 | extern DECLARE_WRITE8_HANDLER ( to8_cartridge_w ); | |
| 166 | extern DECLARE_READ8_HANDLER ( to8_cartridge_r ); | |
| 167 | 167 | |
| 168 | 168 | /* system gate-array */ |
| 169 | extern READ8_HANDLER ( to8_gatearray_r ); | |
| 170 | extern WRITE8_HANDLER ( to8_gatearray_w ); | |
| 169 | extern DECLARE_READ8_HANDLER ( to8_gatearray_r ); | |
| 170 | extern DECLARE_WRITE8_HANDLER ( to8_gatearray_w ); | |
| 171 | 171 | |
| 172 | 172 | /* video gate-array */ |
| 173 | extern READ8_HANDLER ( to8_vreg_r ); | |
| 174 | extern WRITE8_HANDLER ( to8_vreg_w ); | |
| 173 | extern DECLARE_READ8_HANDLER ( to8_vreg_r ); | |
| 174 | extern DECLARE_WRITE8_HANDLER ( to8_vreg_w ); | |
| 175 | 175 | |
| 176 | 176 | /* floppy */ |
| 177 | extern READ8_HANDLER ( to8_floppy_r ); | |
| 178 | extern WRITE8_HANDLER ( to8_floppy_w ); | |
| 177 | extern DECLARE_READ8_HANDLER ( to8_floppy_r ); | |
| 178 | extern DECLARE_WRITE8_HANDLER ( to8_floppy_w ); | |
| 179 | 179 | |
| 180 | 180 | extern MACHINE_START ( to8 ); |
| 181 | 181 | extern MACHINE_RESET ( to8 ); |
| r17964 | r17965 | |
| 193 | 193 | |
| 194 | 194 | /***************************** MO6 ******************************/ |
| 195 | 195 | |
| 196 | extern READ8_HANDLER ( mo6_cartridge_r ); | |
| 197 | extern WRITE8_HANDLER ( mo6_cartridge_w ); | |
| 198 | extern WRITE8_HANDLER ( mo6_ext_w ); | |
| 196 | extern DECLARE_READ8_HANDLER ( mo6_cartridge_r ); | |
| 197 | extern DECLARE_WRITE8_HANDLER ( mo6_cartridge_w ); | |
| 198 | extern DECLARE_WRITE8_HANDLER ( mo6_ext_w ); | |
| 199 | 199 | |
| 200 | 200 | /* system gate-array */ |
| 201 | extern READ8_HANDLER ( mo6_gatearray_r ); | |
| 202 | extern WRITE8_HANDLER ( mo6_gatearray_w ); | |
| 201 | extern DECLARE_READ8_HANDLER ( mo6_gatearray_r ); | |
| 202 | extern DECLARE_WRITE8_HANDLER ( mo6_gatearray_w ); | |
| 203 | 203 | |
| 204 | 204 | /* video gate-array */ |
| 205 | extern READ8_HANDLER ( mo6_vreg_r ); | |
| 206 | extern WRITE8_HANDLER ( mo6_vreg_w ); | |
| 205 | extern DECLARE_READ8_HANDLER ( mo6_vreg_r ); | |
| 206 | extern DECLARE_WRITE8_HANDLER ( mo6_vreg_w ); | |
| 207 | 207 | |
| 208 | 208 | extern MACHINE_START ( mo6 ); |
| 209 | 209 | extern MACHINE_RESET ( mo6 ); |
| r17964 | r17965 | |
| 212 | 212 | /***************************** MO5 NR ******************************/ |
| 213 | 213 | |
| 214 | 214 | /* network */ |
| 215 | extern READ8_HANDLER ( mo5nr_net_r ); | |
| 216 | extern WRITE8_HANDLER ( mo5nr_net_w ); | |
| 215 | extern DECLARE_READ8_HANDLER ( mo5nr_net_r ); | |
| 216 | extern DECLARE_WRITE8_HANDLER ( mo5nr_net_w ); | |
| 217 | 217 | |
| 218 | 218 | /* printer */ |
| 219 | extern READ8_HANDLER ( mo5nr_prn_r ); | |
| 220 | extern WRITE8_HANDLER ( mo5nr_prn_w ); | |
| 219 | extern DECLARE_READ8_HANDLER ( mo5nr_prn_r ); | |
| 220 | extern DECLARE_WRITE8_HANDLER ( mo5nr_prn_w ); | |
| 221 | 221 | |
| 222 | 222 | extern MACHINE_START ( mo5nr ); |
| 223 | 223 | extern MACHINE_RESET ( mo5nr ); |
| r17964 | r17965 | |
| 343 | 343 | |
| 344 | 344 | /***************************** TO7 / T9000 *************************/ |
| 345 | 345 | |
| 346 | extern WRITE8_HANDLER ( to7_vram_w ); | |
| 346 | extern DECLARE_WRITE8_HANDLER ( to7_vram_w ); | |
| 347 | 347 | |
| 348 | 348 | |
| 349 | 349 | /***************************** TO7/70 ******************************/ |
| 350 | 350 | |
| 351 | extern WRITE8_HANDLER ( to770_vram_w ); | |
| 351 | extern DECLARE_WRITE8_HANDLER ( to770_vram_w ); | |
| 352 | 352 | |
| 353 | 353 | |
| 354 | 354 | /***************************** TO8 ******************************/ |
| 355 | 355 | |
| 356 | 356 | /* write to video memory through system space (always page 1) */ |
| 357 | WRITE8_HANDLER ( to8_sys_lo_w ); | |
| 358 | WRITE8_HANDLER ( to8_sys_hi_w ); | |
| 357 | DECLARE_WRITE8_HANDLER ( to8_sys_lo_w ); | |
| 358 | DECLARE_WRITE8_HANDLER ( to8_sys_hi_w ); | |
| 359 | 359 | |
| 360 | 360 | /* write to video memory through data space */ |
| 361 | WRITE8_HANDLER ( to8_data_lo_w ); | |
| 362 | WRITE8_HANDLER ( to8_data_hi_w ); | |
| 361 | DECLARE_WRITE8_HANDLER ( to8_data_lo_w ); | |
| 362 | DECLARE_WRITE8_HANDLER ( to8_data_hi_w ); | |
| 363 | 363 | |
| 364 | 364 | /* write to video memory page through cartridge addresses space */ |
| 365 | WRITE8_HANDLER ( to8_vcart_w ); | |
| 365 | DECLARE_WRITE8_HANDLER ( to8_vcart_w ); | |
| 366 | 366 | |
| 367 | 367 | |
| 368 | 368 |
| r17964 | r17965 | |
|---|---|---|
| 81 | 81 | extern const wd17xx_interface cgenie_wd17xx_interface; |
| 82 | 82 | |
| 83 | 83 | |
| 84 | READ8_HANDLER ( cgenie_psg_port_a_r ); | |
| 85 | READ8_HANDLER ( cgenie_psg_port_b_r ); | |
| 86 | WRITE8_HANDLER ( cgenie_psg_port_a_w ); | |
| 87 | WRITE8_HANDLER ( cgenie_psg_port_b_w ); | |
| 84 | DECLARE_READ8_HANDLER ( cgenie_psg_port_a_r ); | |
| 85 | DECLARE_READ8_HANDLER ( cgenie_psg_port_b_r ); | |
| 86 | DECLARE_WRITE8_HANDLER ( cgenie_psg_port_a_w ); | |
| 87 | DECLARE_WRITE8_HANDLER ( cgenie_psg_port_b_w ); | |
| 88 | 88 | |
| 89 | 89 | |
| 90 | 90 | |
| 91 | 91 | |
| 92 | READ8_HANDLER ( cgenie_colorram_r ); | |
| 93 | READ8_HANDLER ( cgenie_fontram_r ); | |
| 92 | DECLARE_READ8_HANDLER ( cgenie_colorram_r ); | |
| 93 | DECLARE_READ8_HANDLER ( cgenie_fontram_r ); | |
| 94 | 94 | |
| 95 | WRITE8_HANDLER ( cgenie_colorram_w ); | |
| 96 | WRITE8_HANDLER ( cgenie_fontram_w ); | |
| 95 | DECLARE_WRITE8_HANDLER ( cgenie_colorram_w ); | |
| 96 | DECLARE_WRITE8_HANDLER ( cgenie_fontram_w ); | |
| 97 | 97 | |
| 98 | WRITE8_HANDLER ( cgenie_port_ff_w ); | |
| 99 | READ8_HANDLER ( cgenie_port_ff_r ); | |
| 98 | DECLARE_WRITE8_HANDLER ( cgenie_port_ff_w ); | |
| 99 | DECLARE_READ8_HANDLER ( cgenie_port_ff_r ); | |
| 100 | 100 | int cgenie_port_xx_r(int offset); |
| 101 | 101 | |
| 102 | 102 | INTERRUPT_GEN( cgenie_timer_interrupt ); |
| 103 | 103 | INTERRUPT_GEN( cgenie_frame_interrupt ); |
| 104 | 104 | |
| 105 | READ8_HANDLER ( cgenie_status_r ); | |
| 106 | READ8_HANDLER ( cgenie_track_r ); | |
| 107 | READ8_HANDLER ( cgenie_sector_r ); | |
| 108 | READ8_HANDLER ( cgenie_data_r ); | |
| 105 | DECLARE_READ8_HANDLER ( cgenie_status_r ); | |
| 106 | DECLARE_READ8_HANDLER ( cgenie_track_r ); | |
| 107 | DECLARE_READ8_HANDLER ( cgenie_sector_r ); | |
| 108 | DECLARE_READ8_HANDLER ( cgenie_data_r ); | |
| 109 | 109 | |
| 110 | WRITE8_HANDLER ( cgenie_command_w ); | |
| 111 | WRITE8_HANDLER ( cgenie_track_w ); | |
| 112 | WRITE8_HANDLER ( cgenie_sector_w ); | |
| 113 | WRITE8_HANDLER ( cgenie_data_w ); | |
| 110 | DECLARE_WRITE8_HANDLER ( cgenie_command_w ); | |
| 111 | DECLARE_WRITE8_HANDLER ( cgenie_track_w ); | |
| 112 | DECLARE_WRITE8_HANDLER ( cgenie_sector_w ); | |
| 113 | DECLARE_WRITE8_HANDLER ( cgenie_data_w ); | |
| 114 | 114 | |
| 115 | READ8_HANDLER ( cgenie_irq_status_r ); | |
| 115 | DECLARE_READ8_HANDLER ( cgenie_irq_status_r ); | |
| 116 | 116 | |
| 117 | WRITE8_HANDLER ( cgenie_motor_w ); | |
| 117 | DECLARE_WRITE8_HANDLER ( cgenie_motor_w ); | |
| 118 | 118 | |
| 119 | READ8_HANDLER ( cgenie_keyboard_r ); | |
| 119 | DECLARE_READ8_HANDLER ( cgenie_keyboard_r ); | |
| 120 | 120 | int cgenie_videoram_r(running_machine &machine,int offset); |
| 121 | WRITE8_HANDLER ( cgenie_videoram_w ); | |
| 121 | DECLARE_WRITE8_HANDLER ( cgenie_videoram_w ); | |
| 122 | 122 | |
| 123 | 123 | |
| 124 | 124 | /*----------- defined in video/cgenie.c -----------*/ |
| r17964 | r17965 | |
| 126 | 126 | |
| 127 | 127 | SCREEN_UPDATE_IND16( cgenie ); |
| 128 | 128 | |
| 129 | READ8_HANDLER ( cgenie_index_r ); | |
| 130 | READ8_HANDLER ( cgenie_register_r ); | |
| 129 | DECLARE_READ8_HANDLER ( cgenie_index_r ); | |
| 130 | DECLARE_READ8_HANDLER ( cgenie_register_r ); | |
| 131 | 131 | |
| 132 | WRITE8_HANDLER ( cgenie_index_w ); | |
| 133 | WRITE8_HANDLER ( cgenie_register_w ); | |
| 132 | DECLARE_WRITE8_HANDLER ( cgenie_index_w ); | |
| 133 | DECLARE_WRITE8_HANDLER ( cgenie_register_w ); | |
| 134 | 134 | |
| 135 | 135 | int cgenie_get_register(running_machine &machine, int indx); |
| 136 | 136 | void cgenie_mode_select(running_machine &machine, int graphics); |
| r17964 | r17965 | |
|---|---|---|
| 286 | 286 | TIMER_CALLBACK(x68k_hsync); |
| 287 | 287 | |
| 288 | 288 | |
| 289 | READ16_HANDLER( x68k_spritereg_r ); | |
| 290 | WRITE16_HANDLER( x68k_spritereg_w ); | |
| 291 | READ16_HANDLER( x68k_spriteram_r ); | |
| 292 | WRITE16_HANDLER( x68k_spriteram_w ); | |
| 293 | WRITE16_HANDLER( x68k_crtc_w ); | |
| 294 | READ16_HANDLER( x68k_crtc_r ); | |
| 295 | WRITE16_HANDLER( x68k_gvram_w ); | |
| 296 | READ16_HANDLER( x68k_gvram_r ); | |
| 297 | WRITE16_HANDLER( x68k_tvram_w ); | |
| 298 | READ16_HANDLER( x68k_tvram_r ); | |
| 299 | WRITE32_HANDLER( x68k_gvram32_w ); | |
| 300 | READ32_HANDLER( x68k_gvram32_r ); | |
| 301 | WRITE32_HANDLER( x68k_tvram32_w ); | |
| 302 | READ32_HANDLER( x68k_tvram32_r ); | |
| 289 | DECLARE_READ16_HANDLER( x68k_spritereg_r ); | |
| 290 | DECLARE_WRITE16_HANDLER( x68k_spritereg_w ); | |
| 291 | DECLARE_READ16_HANDLER( x68k_spriteram_r ); | |
| 292 | DECLARE_WRITE16_HANDLER( x68k_spriteram_w ); | |
| 293 | DECLARE_WRITE16_HANDLER( x68k_crtc_w ); | |
| 294 | DECLARE_READ16_HANDLER( x68k_crtc_r ); | |
| 295 | DECLARE_WRITE16_HANDLER( x68k_gvram_w ); | |
| 296 | DECLARE_READ16_HANDLER( x68k_gvram_r ); | |
| 297 | DECLARE_WRITE16_HANDLER( x68k_tvram_w ); | |
| 298 | DECLARE_READ16_HANDLER( x68k_tvram_r ); | |
| 299 | DECLARE_WRITE32_HANDLER( x68k_gvram32_w ); | |
| 300 | DECLARE_READ32_HANDLER( x68k_gvram32_r ); | |
| 301 | DECLARE_WRITE32_HANDLER( x68k_tvram32_w ); | |
| 302 | DECLARE_READ32_HANDLER( x68k_tvram32_r ); | |
| 303 | 303 | SCREEN_UPDATE_IND16( x68000 ); |
| 304 | 304 | |
| 305 | 305 |
| r17964 | r17965 | |
|---|---|---|
| 77 | 77 | extern const pia6821_interface pet_pia1; |
| 78 | 78 | |
| 79 | 79 | |
| 80 | WRITE8_HANDLER(cbm8096_w); | |
| 81 | extern READ8_HANDLER(superpet_r); | |
| 82 | extern WRITE8_HANDLER(superpet_w); | |
| 80 | DECLARE_WRITE8_HANDLER(cbm8096_w); | |
| 81 | extern DECLARE_READ8_HANDLER(superpet_r); | |
| 82 | extern DECLARE_WRITE8_HANDLER(superpet_w); | |
| 83 | 83 | |
| 84 | 84 | |
| 85 | 85 | INTERRUPT_GEN( pet_frame_interrupt ); |
| r17964 | r17965 | |
|---|---|---|
| 55 | 55 | extern DECLARE_READ8_DEVICE_HANDLER(c16_m7501_port_read); |
| 56 | 56 | extern DECLARE_WRITE8_DEVICE_HANDLER(c16_m7501_port_write); |
| 57 | 57 | |
| 58 | extern WRITE8_HANDLER(c16_6551_port_w); | |
| 59 | extern READ8_HANDLER(c16_6551_port_r); | |
| 58 | extern DECLARE_WRITE8_HANDLER(c16_6551_port_w); | |
| 59 | extern DECLARE_READ8_HANDLER(c16_6551_port_r); | |
| 60 | 60 | |
| 61 | extern READ8_HANDLER(c16_fd1x_r); | |
| 62 | extern WRITE8_HANDLER(plus4_6529_port_w); | |
| 63 | extern READ8_HANDLER(plus4_6529_port_r); | |
| 61 | extern DECLARE_READ8_HANDLER(c16_fd1x_r); | |
| 62 | extern DECLARE_WRITE8_HANDLER(plus4_6529_port_w); | |
| 63 | extern DECLARE_READ8_HANDLER(plus4_6529_port_r); | |
| 64 | 64 | |
| 65 | extern WRITE8_HANDLER(c16_6529_port_w); | |
| 66 | extern READ8_HANDLER(c16_6529_port_r); | |
| 65 | extern DECLARE_WRITE8_HANDLER(c16_6529_port_w); | |
| 66 | extern DECLARE_READ8_HANDLER(c16_6529_port_r); | |
| 67 | 67 | |
| 68 | extern WRITE8_HANDLER(c16_select_roms); | |
| 69 | extern WRITE8_HANDLER(c16_switch_to_rom); | |
| 70 | extern WRITE8_HANDLER(c16_switch_to_ram); | |
| 68 | extern DECLARE_WRITE8_HANDLER(c16_select_roms); | |
| 69 | extern DECLARE_WRITE8_HANDLER(c16_switch_to_rom); | |
| 70 | extern DECLARE_WRITE8_HANDLER(c16_switch_to_ram); | |
| 71 | 71 | |
| 72 | 72 | /* ted reads (passed to the device interface) */ |
| 73 | 73 | extern UINT8 c16_read_keyboard(running_machine &machine, int databus); |
| r17964 | r17965 | |
|---|---|---|
| 134 | 134 | |
| 135 | 135 | /*----------- defined in machine/europc.c -----------*/ |
| 136 | 136 | |
| 137 | WRITE8_HANDLER( europc_pio_w ); | |
| 138 | READ8_HANDLER( europc_pio_r ); | |
| 137 | DECLARE_WRITE8_HANDLER( europc_pio_w ); | |
| 138 | DECLARE_READ8_HANDLER( europc_pio_r ); | |
| 139 | 139 | |
| 140 | extern WRITE8_HANDLER ( europc_jim_w ); | |
| 141 | extern READ8_HANDLER ( europc_jim_r ); | |
| 142 | extern READ8_HANDLER ( europc_jim2_r ); | |
| 140 | extern DECLARE_WRITE8_HANDLER ( europc_jim_w ); | |
| 141 | extern DECLARE_READ8_HANDLER ( europc_jim_r ); | |
| 142 | extern DECLARE_READ8_HANDLER ( europc_jim2_r ); | |
| 143 | 143 | |
| 144 | extern READ8_HANDLER( europc_rtc_r ); | |
| 145 | extern WRITE8_HANDLER( europc_rtc_w ); | |
| 144 | extern DECLARE_READ8_HANDLER( europc_rtc_r ); | |
| 145 | extern DECLARE_WRITE8_HANDLER( europc_rtc_w ); | |
| 146 | 146 | extern NVRAM_HANDLER( europc_rtc ); |
| 147 | 147 | |
| 148 | 148 | void europc_rtc_set_time(running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 40 | 40 | |
| 41 | 41 | SCREEN_UPDATE_IND16( epnick ); |
| 42 | 42 | |
| 43 | WRITE8_HANDLER( epnick_reg_w ); | |
| 43 | DECLARE_WRITE8_HANDLER( epnick_reg_w ); | |
| 44 | 44 | |
| 45 | 45 | |
| 46 | 46 | #endif /* __ENTERP_H__ */ |
| r17964 | r17965 | |
|---|---|---|
| 203 | 203 | #define RAM_BANK_COUNT 15 |
| 204 | 204 | |
| 205 | 205 | |
| 206 | READ8_HANDLER(ppi8255_r); | |
| 207 | WRITE8_HANDLER(ppi8255_w); | |
| 206 | DECLARE_READ8_HANDLER(ppi8255_r); | |
| 207 | DECLARE_WRITE8_HANDLER(ppi8255_w); | |
| 208 | 208 | |
| 209 | 209 | /* Floppy drive interface */ |
| 210 | 210 | |
| r17964 | r17965 | |
| 217 | 217 | |
| 218 | 218 | extern const mc6845_interface mb55x_mc6845_intf; |
| 219 | 219 | |
| 220 | READ16_HANDLER (mbc55x_video_io_r); | |
| 221 | WRITE16_HANDLER (mbc55x_video_io_w); | |
| 220 | DECLARE_READ16_HANDLER (mbc55x_video_io_r); | |
| 221 | DECLARE_WRITE16_HANDLER (mbc55x_video_io_w); | |
| 222 | 222 | |
| 223 | 223 | |
| 224 | 224 | SCREEN_VBLANK( mbc55x ); |
| r17964 | r17965 | |
|---|---|---|
| 44 | 44 | |
| 45 | 45 | MACHINE_START( pc1403 ); |
| 46 | 46 | |
| 47 | READ8_HANDLER(pc1403_asic_read); | |
| 48 | WRITE8_HANDLER(pc1403_asic_write); | |
| 47 | DECLARE_READ8_HANDLER(pc1403_asic_read); | |
| 48 | DECLARE_WRITE8_HANDLER(pc1403_asic_write); | |
| 49 | 49 | |
| 50 | 50 | |
| 51 | 51 | /*----------- defined in video/pc1403.c -----------*/ |
| r17964 | r17965 | |
| 53 | 53 | VIDEO_START( pc1403 ); |
| 54 | 54 | SCREEN_UPDATE_IND16( pc1403 ); |
| 55 | 55 | |
| 56 | READ8_HANDLER(pc1403_lcd_read); | |
| 57 | WRITE8_HANDLER(pc1403_lcd_write); | |
| 56 | DECLARE_READ8_HANDLER(pc1403_lcd_read); | |
| 57 | DECLARE_WRITE8_HANDLER(pc1403_lcd_write); | |
| 58 | 58 | |
| 59 | 59 | |
| 60 | 60 | #endif /* PC1403_H_ */ |
| r17964 | r17965 | |
|---|---|---|
| 100 | 100 | extern DECLARE_READ8_DEVICE_HANDLER(c64_m6510_port_read); |
| 101 | 101 | extern DECLARE_WRITE8_DEVICE_HANDLER(c64_m6510_port_write); |
| 102 | 102 | |
| 103 | READ8_HANDLER ( c64_colorram_read ); | |
| 104 | WRITE8_HANDLER ( c64_colorram_write ); | |
| 103 | DECLARE_READ8_HANDLER ( c64_colorram_read ); | |
| 104 | DECLARE_WRITE8_HANDLER ( c64_colorram_write ); | |
| 105 | 105 | |
| 106 | 106 | MACHINE_START( c64 ); |
| 107 | 107 | MACHINE_RESET( c64 ); |
| r17964 | r17965 | |
| 109 | 109 | TIMER_CALLBACK( c64_tape_timer ); |
| 110 | 110 | |
| 111 | 111 | /* private area */ |
| 112 | WRITE8_HANDLER(c64_roml_w); | |
| 112 | DECLARE_WRITE8_HANDLER(c64_roml_w); | |
| 113 | 113 | |
| 114 | READ8_HANDLER(c64_ioarea_r); | |
| 115 | WRITE8_HANDLER(c64_ioarea_w); | |
| 114 | DECLARE_READ8_HANDLER(c64_ioarea_r); | |
| 115 | DECLARE_WRITE8_HANDLER(c64_ioarea_w); | |
| 116 | 116 | |
| 117 | WRITE8_HANDLER ( c64_write_io ); | |
| 118 | READ8_HANDLER ( c64_read_io ); | |
| 117 | DECLARE_WRITE8_HANDLER ( c64_write_io ); | |
| 118 | DECLARE_READ8_HANDLER ( c64_read_io ); | |
| 119 | 119 | int c64_paddle_read (device_t *device, address_space &space, int which); |
| 120 | 120 | |
| 121 | 121 | extern const mos6526_interface c64_ntsc_cia0, c64_pal_cia0; |
| r17964 | r17965 | |
|---|---|---|
| 141 | 141 | /*----------- defined in machine/hec2hrp.c -----------*/ |
| 142 | 142 | |
| 143 | 143 | /* Protoype of memory Handler*/ |
| 144 | WRITE8_HANDLER( hector_switch_bank_rom_w ); | |
| 144 | DECLARE_WRITE8_HANDLER( hector_switch_bank_rom_w ); | |
| 145 | 145 | |
| 146 | 146 | void hector_init( running_machine &machine); |
| 147 | 147 | void hector_reset(running_machine &machine, int hr, int with_D2); |
| 148 | 148 | void hector_disc2_reset( running_machine &machine); |
| 149 | 149 | |
| 150 | 150 | /* Prototype of I/O Handler*/ |
| 151 | READ8_HANDLER( hector_mx_io_port_r ); | |
| 151 | DECLARE_READ8_HANDLER( hector_mx_io_port_r ); | |
| 152 | 152 | /*----------- defined in video/hec2video.c -----------*/ |
| 153 | 153 | |
| 154 | 154 | void hector_80c(running_machine &machine, bitmap_ind16 &bitmap, UINT8 *page, int ymax, int yram) ; |
| r17964 | r17965 | |
| 163 | 163 | |
| 164 | 164 | // disc2 handling |
| 165 | 165 | WRITE_LINE_DEVICE_HANDLER( hector_disk2_fdc_interrupt ); |
| 166 | READ8_HANDLER( hector_disc2_io00_port_r); | |
| 167 | WRITE8_HANDLER( hector_disc2_io00_port_w); | |
| 168 | READ8_HANDLER( hector_disc2_io20_port_r); | |
| 169 | WRITE8_HANDLER( hector_disc2_io20_port_w); | |
| 170 | READ8_HANDLER( hector_disc2_io30_port_r); | |
| 171 | WRITE8_HANDLER( hector_disc2_io30_port_w); | |
| 172 | READ8_HANDLER( hector_disc2_io40_port_r); | |
| 173 | WRITE8_HANDLER( hector_disc2_io40_port_w); | |
| 174 | READ8_HANDLER( hector_disc2_io50_port_r); | |
| 175 | WRITE8_HANDLER( hector_disc2_io50_port_w); | |
| 176 | READ8_HANDLER( hector_disc2_io61_port_r); | |
| 177 | WRITE8_HANDLER( hector_disc2_io61_port_w); | |
| 178 | READ8_HANDLER( hector_disc2_io70_port_r); | |
| 179 | WRITE8_HANDLER( hector_disc2_io70_port_w); | |
| 166 | DECLARE_READ8_HANDLER( hector_disc2_io00_port_r); | |
| 167 | DECLARE_WRITE8_HANDLER( hector_disc2_io00_port_w); | |
| 168 | DECLARE_READ8_HANDLER( hector_disc2_io20_port_r); | |
| 169 | DECLARE_WRITE8_HANDLER( hector_disc2_io20_port_w); | |
| 170 | DECLARE_READ8_HANDLER( hector_disc2_io30_port_r); | |
| 171 | DECLARE_WRITE8_HANDLER( hector_disc2_io30_port_w); | |
| 172 | DECLARE_READ8_HANDLER( hector_disc2_io40_port_r); | |
| 173 | DECLARE_WRITE8_HANDLER( hector_disc2_io40_port_w); | |
| 174 | DECLARE_READ8_HANDLER( hector_disc2_io50_port_r); | |
| 175 | DECLARE_WRITE8_HANDLER( hector_disc2_io50_port_w); | |
| 176 | DECLARE_READ8_HANDLER( hector_disc2_io61_port_r); | |
| 177 | DECLARE_WRITE8_HANDLER( hector_disc2_io61_port_w); | |
| 178 | DECLARE_READ8_HANDLER( hector_disc2_io70_port_r); | |
| 179 | DECLARE_WRITE8_HANDLER( hector_disc2_io70_port_w); | |
| 180 | 180 | |
| 181 | 181 | void hector_disc2_init( running_machine &machine); |
| 182 | 182 | void hector_minidisc_init( running_machine &machine); |
| r17964 | r17965 | |
|---|---|---|
| 21 | 21 | |
| 22 | 22 | #define IRQ_LOG 0 // set to 1 to log IRQ line activity |
| 23 | 23 | |
| 24 | READ8_HANDLER( towns_gfx_high_r ); | |
| 25 | WRITE8_HANDLER( towns_gfx_high_w ); | |
| 26 | READ8_HANDLER( towns_gfx_r ); | |
| 27 | WRITE8_HANDLER( towns_gfx_w ); | |
| 28 | READ8_HANDLER( towns_video_cff80_r ); | |
| 29 | WRITE8_HANDLER( towns_video_cff80_w ); | |
| 30 | READ8_HANDLER( towns_video_cff80_mem_r ); | |
| 31 | WRITE8_HANDLER( towns_video_cff80_mem_w ); | |
| 32 | READ8_HANDLER(towns_video_440_r); | |
| 33 | WRITE8_HANDLER(towns_video_440_w); | |
| 34 | READ8_HANDLER(towns_video_5c8_r); | |
| 35 | WRITE8_HANDLER(towns_video_5c8_w); | |
| 36 | READ8_HANDLER(towns_video_fd90_r); | |
| 37 | WRITE8_HANDLER(towns_video_fd90_w); | |
| 38 | READ8_HANDLER(towns_video_ff81_r); | |
| 39 | WRITE8_HANDLER(towns_video_ff81_w); | |
| 40 | READ32_HANDLER(towns_video_unknown_r); | |
| 41 | READ8_HANDLER(towns_spriteram_low_r); | |
| 42 | WRITE8_HANDLER(towns_spriteram_low_w); | |
| 43 | READ8_HANDLER(towns_spriteram_r); | |
| 44 | WRITE8_HANDLER(towns_spriteram_w); | |
| 24 | DECLARE_READ8_HANDLER( towns_gfx_high_r ); | |
| 25 | DECLARE_WRITE8_HANDLER( towns_gfx_high_w ); | |
| 26 | DECLARE_READ8_HANDLER( towns_gfx_r ); | |
| 27 | DECLARE_WRITE8_HANDLER( towns_gfx_w ); | |
| 28 | DECLARE_READ8_HANDLER( towns_video_cff80_r ); | |
| 29 | DECLARE_WRITE8_HANDLER( towns_video_cff80_w ); | |
| 30 | DECLARE_READ8_HANDLER( towns_video_cff80_mem_r ); | |
| 31 | DECLARE_WRITE8_HANDLER( towns_video_cff80_mem_w ); | |
| 32 | DECLARE_READ8_HANDLER(towns_video_440_r); | |
| 33 | DECLARE_WRITE8_HANDLER(towns_video_440_w); | |
| 34 | DECLARE_READ8_HANDLER(towns_video_5c8_r); | |
| 35 | DECLARE_WRITE8_HANDLER(towns_video_5c8_w); | |
| 36 | DECLARE_READ8_HANDLER(towns_video_fd90_r); | |
| 37 | DECLARE_WRITE8_HANDLER(towns_video_fd90_w); | |
| 38 | DECLARE_READ8_HANDLER(towns_video_ff81_r); | |
| 39 | DECLARE_WRITE8_HANDLER(towns_video_ff81_w); | |
| 40 | DECLARE_READ32_HANDLER(towns_video_unknown_r); | |
| 41 | DECLARE_READ8_HANDLER(towns_spriteram_low_r); | |
| 42 | DECLARE_WRITE8_HANDLER(towns_spriteram_low_w); | |
| 43 | DECLARE_READ8_HANDLER(towns_spriteram_r); | |
| 44 | DECLARE_WRITE8_HANDLER(towns_spriteram_w); | |
| 45 | 45 | |
| 46 | 46 | struct towns_cdrom_controller |
| 47 | 47 | { |
| r17964 | r17965 | |
|---|---|---|
| 59 | 59 | |
| 60 | 60 | |
| 61 | 61 | |
| 62 | READ64_HANDLER( bebox_cpu0_imask_r ); | |
| 63 | READ64_HANDLER( bebox_cpu1_imask_r ); | |
| 64 | READ64_HANDLER( bebox_interrupt_sources_r ); | |
| 65 | READ64_HANDLER( bebox_crossproc_interrupts_r ); | |
| 66 | READ8_HANDLER( bebox_800001F0_r ); | |
| 67 | READ64_HANDLER( bebox_800003F0_r ); | |
| 68 | READ64_HANDLER( bebox_interrupt_ack_r ); | |
| 69 | READ8_HANDLER( bebox_page_r ); | |
| 70 | READ8_HANDLER( bebox_80000480_r ); | |
| 71 | READ8_HANDLER( bebox_flash_r ); | |
| 62 | DECLARE_READ64_HANDLER( bebox_cpu0_imask_r ); | |
| 63 | DECLARE_READ64_HANDLER( bebox_cpu1_imask_r ); | |
| 64 | DECLARE_READ64_HANDLER( bebox_interrupt_sources_r ); | |
| 65 | DECLARE_READ64_HANDLER( bebox_crossproc_interrupts_r ); | |
| 66 | DECLARE_READ8_HANDLER( bebox_800001F0_r ); | |
| 67 | DECLARE_READ64_HANDLER( bebox_800003F0_r ); | |
| 68 | DECLARE_READ64_HANDLER( bebox_interrupt_ack_r ); | |
| 69 | DECLARE_READ8_HANDLER( bebox_page_r ); | |
| 70 | DECLARE_READ8_HANDLER( bebox_80000480_r ); | |
| 71 | DECLARE_READ8_HANDLER( bebox_flash_r ); | |
| 72 | 72 | |
| 73 | WRITE64_HANDLER( bebox_cpu0_imask_w ); | |
| 74 | WRITE64_HANDLER( bebox_cpu1_imask_w ); | |
| 75 | WRITE64_HANDLER( bebox_crossproc_interrupts_w ); | |
| 76 | WRITE64_HANDLER( bebox_processor_resets_w ); | |
| 77 | WRITE8_HANDLER( bebox_800001F0_w ); | |
| 78 | WRITE64_HANDLER( bebox_800003F0_w ); | |
| 79 | WRITE8_HANDLER( bebox_page_w ); | |
| 80 | WRITE8_HANDLER( bebox_80000480_w ); | |
| 81 | WRITE8_HANDLER( bebox_flash_w ); | |
| 73 | DECLARE_WRITE64_HANDLER( bebox_cpu0_imask_w ); | |
| 74 | DECLARE_WRITE64_HANDLER( bebox_cpu1_imask_w ); | |
| 75 | DECLARE_WRITE64_HANDLER( bebox_crossproc_interrupts_w ); | |
| 76 | DECLARE_WRITE64_HANDLER( bebox_processor_resets_w ); | |
| 77 | DECLARE_WRITE8_HANDLER( bebox_800001F0_w ); | |
| 78 | DECLARE_WRITE64_HANDLER( bebox_800003F0_w ); | |
| 79 | DECLARE_WRITE8_HANDLER( bebox_page_w ); | |
| 80 | DECLARE_WRITE8_HANDLER( bebox_80000480_w ); | |
| 81 | DECLARE_WRITE8_HANDLER( bebox_flash_w ); | |
| 82 | 82 | |
| 83 | 83 | void bebox_ide_interrupt(device_t *device, int state); |
| 84 | 84 | void bebox_set_irq_bit(running_machine &machine, unsigned int interrupt_bit, int val); |
| r17964 | r17965 | |
|---|---|---|
| 264 | 264 | |
| 265 | 265 | |
| 266 | 266 | UINT8 apple2_getfloatingbusvalue(running_machine &machine); |
| 267 | READ8_HANDLER( apple2_c0xx_r ); | |
| 268 | WRITE8_HANDLER( apple2_c0xx_w ); | |
| 269 | READ8_HANDLER( apple2_c080_r ); | |
| 270 | WRITE8_HANDLER( apple2_c080_w ); | |
| 267 | DECLARE_READ8_HANDLER( apple2_c0xx_r ); | |
| 268 | DECLARE_WRITE8_HANDLER( apple2_c0xx_w ); | |
| 269 | DECLARE_READ8_HANDLER( apple2_c080_r ); | |
| 270 | DECLARE_WRITE8_HANDLER( apple2_c080_w ); | |
| 271 | 271 | |
| 272 | 272 | TIMER_DEVICE_CALLBACK( apple2_interrupt ); |
| 273 | 273 |
| r17964 | r17965 | |
|---|---|---|
| 10 | 10 | |
| 11 | 11 | /*----------- defined in machine/tandy1t.c -----------*/ |
| 12 | 12 | |
| 13 | extern WRITE8_HANDLER ( pc_t1t_p37x_w ); | |
| 14 | extern READ8_HANDLER ( pc_t1t_p37x_r ); | |
| 13 | extern DECLARE_WRITE8_HANDLER ( pc_t1t_p37x_w ); | |
| 14 | extern DECLARE_READ8_HANDLER ( pc_t1t_p37x_r ); | |
| 15 | 15 | |
| 16 | extern WRITE8_HANDLER ( tandy1000_pio_w ); | |
| 17 | extern READ8_HANDLER(tandy1000_pio_r); | |
| 16 | extern DECLARE_WRITE8_HANDLER ( tandy1000_pio_w ); | |
| 17 | extern DECLARE_READ8_HANDLER(tandy1000_pio_r); | |
| 18 | 18 | |
| 19 | 19 | extern NVRAM_HANDLER( tandy1000 ); |
| 20 | 20 | |
| 21 | READ8_HANDLER( tandy1000_bank_r ); | |
| 22 | WRITE8_HANDLER( tandy1000_bank_w ); | |
| 21 | DECLARE_READ8_HANDLER( tandy1000_bank_r ); | |
| 22 | DECLARE_WRITE8_HANDLER( tandy1000_bank_w ); | |
| 23 | 23 | |
| 24 | 24 | INPUT_PORTS_EXTERN( t1000_keyboard ); |
| 25 | 25 |
| r17964 | r17965 | |
|---|---|---|
| 14 | 14 | |
| 15 | 15 | /*----------- defined in machine/amstr_pc.c -----------*/ |
| 16 | 16 | |
| 17 | READ8_HANDLER( pc1640_port60_r ); | |
| 18 | WRITE8_HANDLER( pc1640_port60_w ); | |
| 17 | DECLARE_READ8_HANDLER( pc1640_port60_r ); | |
| 18 | DECLARE_WRITE8_HANDLER( pc1640_port60_w ); | |
| 19 | 19 | |
| 20 | READ8_HANDLER( pc1640_mouse_x_r ); | |
| 21 | READ8_HANDLER( pc1640_mouse_y_r ); | |
| 22 | WRITE8_HANDLER( pc1640_mouse_x_w ); | |
| 23 | WRITE8_HANDLER( pc1640_mouse_y_w ); | |
| 20 | DECLARE_READ8_HANDLER( pc1640_mouse_x_r ); | |
| 21 | DECLARE_READ8_HANDLER( pc1640_mouse_y_r ); | |
| 22 | DECLARE_WRITE8_HANDLER( pc1640_mouse_x_w ); | |
| 23 | DECLARE_WRITE8_HANDLER( pc1640_mouse_y_w ); | |
| 24 | 24 | |
| 25 | READ8_HANDLER( pc200_port378_r ); | |
| 26 | READ8_HANDLER( pc200_port278_r ); | |
| 27 | READ8_HANDLER( pc1640_port378_r ); | |
| 28 | READ8_HANDLER( pc1640_port3d0_r ); | |
| 29 | READ8_HANDLER( pc1640_port4278_r ); | |
| 30 | READ8_HANDLER( pc1640_port278_r ); | |
| 25 | DECLARE_READ8_HANDLER( pc200_port378_r ); | |
| 26 | DECLARE_READ8_HANDLER( pc200_port278_r ); | |
| 27 | DECLARE_READ8_HANDLER( pc1640_port378_r ); | |
| 28 | DECLARE_READ8_HANDLER( pc1640_port3d0_r ); | |
| 29 | DECLARE_READ8_HANDLER( pc1640_port4278_r ); | |
| 30 | DECLARE_READ8_HANDLER( pc1640_port278_r ); | |
| 31 | 31 | |
| 32 | 32 | INPUT_PORTS_EXTERN( amstrad_keyboard ); |
| 33 | 33 |
| r17964 | r17965 | |
|---|---|---|
| 45 | 45 | |
| 46 | 46 | /*----------- defined in video/pc1251.c -----------*/ |
| 47 | 47 | |
| 48 | READ8_HANDLER(pc1251_lcd_read); | |
| 49 | WRITE8_HANDLER(pc1251_lcd_write); | |
| 48 | DECLARE_READ8_HANDLER(pc1251_lcd_read); | |
| 49 | DECLARE_WRITE8_HANDLER(pc1251_lcd_write); | |
| 50 | 50 | SCREEN_UPDATE_IND16( pc1251 ); |
| 51 | 51 | |
| 52 | 52 |
| r17964 | r17965 | |
|---|---|---|
| 42 | 42 | } |
| 43 | 43 | } |
| 44 | 44 | |
| 45 | static READ32_HANDLER( newport_cmap0_r ); | |
| 46 | static WRITE32_HANDLER( newport_cmap0_w ); | |
| 47 | static READ32_HANDLER( newport_cmap1_r ); | |
| 48 | static READ32_HANDLER( newport_xmap0_r ); | |
| 49 | static WRITE32_HANDLER( newport_xmap0_w ); | |
| 50 | static READ32_HANDLER( newport_xmap1_r ); | |
| 51 | static WRITE32_HANDLER( newport_xmap1_w ); | |
| 52 | static READ32_HANDLER( newport_vc2_r ); | |
| 53 | static WRITE32_HANDLER( newport_vc2_w ); | |
| 45 | static DECLARE_READ32_HANDLER( newport_cmap0_r ); | |
| 46 | static DECLARE_WRITE32_HANDLER( newport_cmap0_w ); | |
| 47 | static DECLARE_READ32_HANDLER( newport_cmap1_r ); | |
| 48 | static DECLARE_READ32_HANDLER( newport_xmap0_r ); | |
| 49 | static DECLARE_WRITE32_HANDLER( newport_xmap0_w ); | |
| 50 | static DECLARE_READ32_HANDLER( newport_xmap1_r ); | |
| 51 | static DECLARE_WRITE32_HANDLER( newport_xmap1_w ); | |
| 52 | static DECLARE_READ32_HANDLER( newport_vc2_r ); | |
| 53 | static DECLARE_WRITE32_HANDLER( newport_vc2_w ); | |
| 54 | 54 | |
| 55 | 55 | struct VC2_t |
| 56 | 56 | { |
| r17964 | r17965 | |
|---|---|---|
| 9 | 9 | extern VIDEO_START( newport ); |
| 10 | 10 | extern SCREEN_UPDATE_RGB32( newport ); |
| 11 | 11 | |
| 12 | READ32_HANDLER( newport_rex3_r ); | |
| 13 | WRITE32_HANDLER( newport_rex3_w ); | |
| 12 | DECLARE_READ32_HANDLER( newport_rex3_r ); | |
| 13 | DECLARE_WRITE32_HANDLER( newport_rex3_w ); | |
| 14 | 14 | |
| 15 | 15 | #endif |
| r17964 | r17965 | |
|---|---|---|
| 9 | 9 | #ifndef __GF4500_H__ |
| 10 | 10 | #define __GF4500_H__ |
| 11 | 11 | |
| 12 | READ32_HANDLER( gf4500_r ); | |
| 13 | WRITE32_HANDLER( gf4500_w ); | |
| 12 | DECLARE_READ32_HANDLER( gf4500_r ); | |
| 13 | DECLARE_WRITE32_HANDLER( gf4500_w ); | |
| 14 | 14 | |
| 15 | 15 | VIDEO_START( gf4500 ); |
| 16 | 16 | SCREEN_UPDATE_RGB32( gf4500 ); |
| r17964 | r17965 | |
|---|---|---|
| 814 | 814 | // but now cga and mda are splitted in mess |
| 815 | 815 | WRITE8_HANDLER( pc200_cga_w ) |
| 816 | 816 | { |
| 817 | pc_aga_cga_w(space, offset,data); | |
| 817 | pc_aga_cga_w(space, offset,data,mem_mask); | |
| 818 | 818 | switch(offset) { |
| 819 | 819 | case 4: |
| 820 | 820 | pc200.portd |= 0x20; |
| r17964 | r17965 | |
| 872 | 872 | break; |
| 873 | 873 | |
| 874 | 874 | default: |
| 875 | result = pc_aga_cga_r(space, offset); | |
| 875 | result = pc_aga_cga_r(space, offset, mem_mask); | |
| 876 | 876 | break; |
| 877 | 877 | } |
| 878 | 878 | return result; |
| r17964 | r17965 | |
|---|---|---|
| 28 | 28 | enum AGA_MODE { AGA_OFF, AGA_COLOR, AGA_MONO }; |
| 29 | 29 | void pc_aga_set_mode(running_machine &machine, AGA_MODE mode); |
| 30 | 30 | |
| 31 | READ8_HANDLER( pc_aga_videoram_r ); | |
| 32 | WRITE8_HANDLER( pc_aga_videoram_w ); | |
| 31 | DECLARE_READ8_HANDLER( pc_aga_videoram_r ); | |
| 32 | DECLARE_WRITE8_HANDLER( pc_aga_videoram_w ); | |
| 33 | 33 | |
| 34 | READ8_HANDLER( pc200_videoram_r ); | |
| 35 | WRITE8_HANDLER( pc200_videoram_w ); | |
| 36 | READ16_HANDLER( pc200_videoram16le_r ); | |
| 37 | WRITE16_HANDLER( pc200_videoram16le_w ); | |
| 34 | DECLARE_READ8_HANDLER( pc200_videoram_r ); | |
| 35 | DECLARE_WRITE8_HANDLER( pc200_videoram_w ); | |
| 36 | DECLARE_READ16_HANDLER( pc200_videoram16le_r ); | |
| 37 | DECLARE_WRITE16_HANDLER( pc200_videoram16le_w ); | |
| 38 | 38 | |
| 39 | READ8_HANDLER( pc200_cga_r ); | |
| 40 | WRITE8_HANDLER( pc200_cga_w ); | |
| 41 | READ16_HANDLER( pc200_cga16le_r ); | |
| 42 | WRITE16_HANDLER( pc200_cga16le_w ); | |
| 39 | DECLARE_READ8_HANDLER( pc200_cga_r ); | |
| 40 | DECLARE_WRITE8_HANDLER( pc200_cga_w ); | |
| 41 | DECLARE_READ16_HANDLER( pc200_cga16le_r ); | |
| 42 | DECLARE_WRITE16_HANDLER( pc200_cga16le_w ); | |
| 43 | 43 |
| r17964 | r17965 | |
|---|---|---|
| 1916 | 1916 | NULL /* update address callback */ |
| 1917 | 1917 | }; |
| 1918 | 1918 | |
| 1919 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 1920 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 1919 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 1920 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 1921 | 1921 | |
| 1922 | 1922 | static Z80DMA_INTERFACE( x1_dma ) |
| 1923 | 1923 | { |
| r17964 | r17965 | |
|---|---|---|
| 537 | 537 | } |
| 538 | 538 | } |
| 539 | 539 | |
| 540 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 541 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 540 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 541 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 542 | 542 | |
| 543 | 543 | static I8237_INTERFACE( dmac_intf ) |
| 544 | 544 | { |
| r17964 | r17965 | |
|---|---|---|
| 377 | 377 | Channel 2: GDC |
| 378 | 378 | Channel 3: Option slots |
| 379 | 379 | */ |
| 380 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 381 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 380 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 381 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 382 | 382 | |
| 383 | 383 | static I8237_INTERFACE( qx10_dma8237_1_interface ) |
| 384 | 384 | { |
| r17964 | r17965 | |
|---|---|---|
| 207 | 207 | /* Z80 DMA */ |
| 208 | 208 | |
| 209 | 209 | |
| 210 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 211 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 210 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 211 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 212 | 212 | |
| 213 | 213 | static Z80DMA_INTERFACE( dma_intf ) |
| 214 | 214 | { |
| r17964 | r17965 | |
|---|---|---|
| 798 | 798 | } |
| 799 | 799 | } |
| 800 | 800 | |
| 801 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 802 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 801 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 802 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 803 | 803 | |
| 804 | 804 | static Z80DMA_INTERFACE( dma_intf ) |
| 805 | 805 | { |
| r17964 | r17965 | |
|---|---|---|
| 449 | 449 | } |
| 450 | 450 | } |
| 451 | 451 | |
| 452 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 452 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 453 | 453 | |
| 454 | 454 | static UV201_INTERFACE( uv_intf ) |
| 455 | 455 | { |
| r17964 | r17965 | |
|---|---|---|
| 694 | 694 | // Z80DMA_INTERFACE( dma_intf ) |
| 695 | 695 | //------------------------------------------------- |
| 696 | 696 | |
| 697 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 698 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 697 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 698 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 699 | 699 | |
| 700 | 700 | static Z80DMA_INTERFACE( dma_intf ) |
| 701 | 701 | { |
| r17964 | r17965 | |
|---|---|---|
| 219 | 219 | p8k_daisy_interrupt(device, state); |
| 220 | 220 | } |
| 221 | 221 | |
| 222 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 223 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 222 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 223 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 224 | 224 | |
| 225 | 225 | static Z80DMA_INTERFACE( p8k_dma_intf ) |
| 226 | 226 | { |
| r17964 | r17965 | |
|---|---|---|
| 35 | 35 | // things from mess/machine/dc.c |
| 36 | 36 | void dreamcast_atapi_init(running_machine &machine); |
| 37 | 37 | void dreamcast_atapi_reset(running_machine &machine); |
| 38 | extern READ64_HANDLER( dc_mess_gdrom_r ); | |
| 39 | extern WRITE64_HANDLER( dc_mess_gdrom_w ); | |
| 40 | extern READ64_HANDLER( dc_mess_g1_ctrl_r ); | |
| 41 | extern WRITE64_HANDLER( dc_mess_g1_ctrl_w ); | |
| 38 | extern DECLARE_READ64_HANDLER( dc_mess_gdrom_r ); | |
| 39 | extern DECLARE_WRITE64_HANDLER( dc_mess_gdrom_w ); | |
| 40 | extern DECLARE_READ64_HANDLER( dc_mess_g1_ctrl_r ); | |
| 41 | extern DECLARE_WRITE64_HANDLER( dc_mess_g1_ctrl_w ); | |
| 42 | 42 | |
| 43 | 43 | static READ64_HANDLER( dcus_idle_skip_r ) |
| 44 | 44 | { |
| r17964 | r17965 | |
|---|---|---|
| 396 | 396 | // Z80DMA_INTERFACE( dma_intf ) |
| 397 | 397 | //------------------------------------------------- |
| 398 | 398 | |
| 399 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 400 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 399 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 400 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 401 | 401 | |
| 402 | 402 | static Z80DMA_INTERFACE( dma_intf ) |
| 403 | 403 | { |
| r17964 | r17965 | |
|---|---|---|
| 277 | 277 | i8237_hlda_w(m_dmac, state); |
| 278 | 278 | } |
| 279 | 279 | |
| 280 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 281 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 280 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 281 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 282 | 282 | |
| 283 | 283 | static I8237_INTERFACE( dmv_dma8237_config ) |
| 284 | 284 | { |
| r17964 | r17965 | |
|---|---|---|
| 262 | 262 | NULL /* update address callback */ |
| 263 | 263 | }; |
| 264 | 264 | |
| 265 | static UINT8 memory_read_byte(address_space &space, offs_t address) { return space.read_byte(address); } | |
| 266 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data) { space.write_byte(address, data); } | |
| 265 | static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); } | |
| 266 | static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); } | |
| 267 | 267 | |
| 268 | 268 | static I8237_INTERFACE( b16_dma8237_interface ) |
| 269 | 269 | { |
| Previous | 199869 Revisions | Next |