src/mess/drivers/pv1000.c
| r12808 | r12809 | |
| 3 | 3 | Driver for Casio PV-1000 |
| 4 | 4 | |
| 5 | 5 | ***************************************************************************/ |
| 6 | #define ADDRESS_MAP_MODERN |
| 6 | 7 | |
| 7 | 8 | #include "emu.h" |
| 8 | 9 | #include "cpu/z80/z80.h" |
| r12808 | r12809 | |
| 13 | 14 | DEFINE_LEGACY_SOUND_DEVICE(PV1000,pv1000_sound); |
| 14 | 15 | |
| 15 | 16 | |
| 16 | | class d65010_state : public driver_device |
| 17 | class pv1000_state : public driver_device |
| 17 | 18 | { |
| 18 | 19 | public: |
| 19 | | d65010_state(const machine_config &mconfig, device_type type, const char *tag) |
| 20 | pv1000_state(const machine_config &mconfig, device_type type, const char *tag) |
| 20 | 21 | : driver_device(mconfig, type, tag) { } |
| 21 | 22 | |
| 23 | DECLARE_WRITE8_MEMBER(pv1000_io_w); |
| 24 | DECLARE_READ8_MEMBER(pv1000_io_r); |
| 25 | DECLARE_WRITE8_MEMBER(pv1000_gfxram_w); |
| 22 | 26 | UINT8 m_io_regs[8]; |
| 23 | 27 | UINT8 m_fd_data; |
| 24 | 28 | struct |
| r12808 | r12809 | |
| 34 | 38 | |
| 35 | 39 | device_t *m_maincpu; |
| 36 | 40 | screen_device *m_screen; |
| 37 | | UINT8 *m_ram; |
| 41 | UINT8 *m_p_videoram; |
| 38 | 42 | }; |
| 39 | 43 | |
| 40 | 44 | |
| 41 | | static WRITE8_HANDLER( pv1000_io_w ); |
| 42 | | static READ8_HANDLER( pv1000_io_r ); |
| 43 | | static WRITE8_HANDLER( pv1000_gfxram_w ); |
| 44 | | |
| 45 | | |
| 46 | | static ADDRESS_MAP_START( pv1000, AS_PROGRAM, 8 ) |
| 45 | static ADDRESS_MAP_START( pv1000, AS_PROGRAM, 8, pv1000_state ) |
| 47 | 46 | AM_RANGE( 0x0000, 0x3fff ) AM_MIRROR( 0x4000 ) AM_ROM AM_REGION( "cart", 0 ) |
| 48 | | AM_RANGE( 0xb800, 0xbbff ) AM_RAM AM_BASE_MEMBER( d65010_state, m_ram ) |
| 47 | AM_RANGE( 0xb800, 0xbbff ) AM_RAM AM_BASE( m_p_videoram ) |
| 49 | 48 | AM_RANGE( 0xbc00, 0xbfff ) AM_RAM_WRITE( pv1000_gfxram_w ) AM_REGION( "gfxram", 0 ) |
| 50 | 49 | ADDRESS_MAP_END |
| 51 | 50 | |
| 52 | 51 | |
| 53 | | static ADDRESS_MAP_START( pv1000_io, AS_IO, 8 ) |
| 52 | static ADDRESS_MAP_START( pv1000_io, AS_IO, 8, pv1000_state ) |
| 54 | 53 | ADDRESS_MAP_GLOBAL_MASK( 0xff ) |
| 55 | 54 | AM_RANGE( 0xf8, 0xff ) AM_READWRITE( pv1000_io_r, pv1000_io_w ) |
| 56 | 55 | ADDRESS_MAP_END |
| 57 | 56 | |
| 58 | 57 | |
| 59 | | static WRITE8_HANDLER( pv1000_gfxram_w ) |
| 58 | WRITE8_MEMBER( pv1000_state::pv1000_gfxram_w ) |
| 60 | 59 | { |
| 61 | | UINT8 *gfxram = space->machine().region( "gfxram" )->base(); |
| 60 | UINT8 *gfxram = machine().region( "gfxram" )->base(); |
| 62 | 61 | |
| 63 | 62 | gfxram[ offset ] = data; |
| 64 | | gfx_element_mark_dirty(space->machine().gfx[1], offset/32); |
| 63 | gfx_element_mark_dirty(machine().gfx[1], offset/32); |
| 65 | 64 | } |
| 66 | 65 | |
| 67 | 66 | |
| 68 | | static WRITE8_HANDLER( pv1000_io_w ) |
| 67 | WRITE8_MEMBER( pv1000_state::pv1000_io_w ) |
| 69 | 68 | { |
| 70 | | d65010_state *state = space->machine().driver_data<d65010_state>(); |
| 71 | | |
| 72 | 69 | switch ( offset ) |
| 73 | 70 | { |
| 74 | 71 | case 0x00: |
| 75 | 72 | case 0x01: |
| 76 | 73 | case 0x02: |
| 77 | 74 | //logerror("pv1000_io_w offset=%02x, data=%02x (%03d)\n", offset, data , data); |
| 78 | | state->m_voice[offset].period = data; |
| 75 | m_voice[offset].period = data; |
| 79 | 76 | break; |
| 80 | 77 | |
| 81 | 78 | case 0x03: |
| r12808 | r12809 | |
| 83 | 80 | break; |
| 84 | 81 | |
| 85 | 82 | case 0x05: |
| 86 | | state->m_fd_data = 1; |
| 83 | m_fd_data = 1; |
| 87 | 84 | break; |
| 88 | 85 | } |
| 89 | 86 | |
| 90 | | state->m_io_regs[offset] = data; |
| 87 | m_io_regs[offset] = data; |
| 91 | 88 | } |
| 92 | 89 | |
| 93 | 90 | |
| 94 | | static READ8_HANDLER( pv1000_io_r ) |
| 91 | READ8_MEMBER( pv1000_state::pv1000_io_r ) |
| 95 | 92 | { |
| 96 | | d65010_state *state = space->machine().driver_data<d65010_state>(); |
| 97 | | UINT8 data = state->m_io_regs[offset]; |
| 93 | UINT8 data = m_io_regs[offset]; |
| 98 | 94 | |
| 99 | 95 | // logerror("pv1000_io_r offset=%02x\n", offset ); |
| 100 | 96 | |
| r12808 | r12809 | |
| 103 | 99 | case 0x04: |
| 104 | 100 | /* Bit 1 = 1 => Data is available in port FD */ |
| 105 | 101 | /* Bit 0 = 1 => Buffer at port FD is empty */ |
| 106 | | data = ( state->m_screen->vpos() >= 212 && state->m_screen->vpos() <= 220 ) ? 0x01 : 0x00; |
| 107 | | data |= state->m_fd_data ? 0x02 : 0x00; |
| 102 | data = ( m_screen->vpos() >= 212 && m_screen->vpos() <= 220 ) ? 1 : 0; |
| 103 | data |= m_fd_data ? 2 : 0; |
| 108 | 104 | break; |
| 109 | 105 | case 0x05: |
| 110 | 106 | data = 0; |
| 111 | | if ( state->m_io_regs[5] & 0x08 ) |
| 107 | if ( m_io_regs[5] & 0x08 ) |
| 112 | 108 | { |
| 113 | | data = input_port_read( space->machine(), "IN3" ); |
| 109 | data = input_port_read( machine(), "IN3" ); |
| 114 | 110 | } |
| 115 | | if ( state->m_io_regs[5] & 0x04 ) |
| 111 | if ( m_io_regs[5] & 0x04 ) |
| 116 | 112 | { |
| 117 | | data = input_port_read( space->machine(), "IN2" ); |
| 113 | data = input_port_read( machine(), "IN2" ); |
| 118 | 114 | } |
| 119 | | if ( state->m_io_regs[5] & 0x02 ) |
| 115 | if ( m_io_regs[5] & 0x02 ) |
| 120 | 116 | { |
| 121 | | data = input_port_read( space->machine(), "IN1" ); |
| 117 | data = input_port_read( machine(), "IN1" ); |
| 122 | 118 | } |
| 123 | | if ( state->m_io_regs[5] & 0x01 ) |
| 119 | if ( m_io_regs[5] & 0x01 ) |
| 124 | 120 | { |
| 125 | | data = input_port_read( space->machine(), "IN0" ); |
| 121 | data = input_port_read( machine(), "IN0" ); |
| 126 | 122 | } |
| 127 | | state->m_fd_data = 0; |
| 123 | m_fd_data = 0; |
| 128 | 124 | break; |
| 129 | 125 | } |
| 130 | 126 | |
| r12808 | r12809 | |
| 211 | 207 | |
| 212 | 208 | static SCREEN_UPDATE( pv1000 ) |
| 213 | 209 | { |
| 214 | | d65010_state *state = screen->machine().driver_data<d65010_state>(); |
| 210 | pv1000_state *state = screen->machine().driver_data<pv1000_state>(); |
| 215 | 211 | int x, y; |
| 216 | 212 | |
| 217 | 213 | for ( y = 0; y < 24; y++ ) |
| 218 | 214 | { |
| 219 | 215 | for ( x = 0; x < 32; x++ ) |
| 220 | 216 | { |
| 221 | | UINT16 tile = state->m_ram[ y * 32 + x ]; |
| 217 | UINT16 tile = state->m_p_videoram[ y * 32 + x ]; |
| 222 | 218 | |
| 223 | 219 | if ( tile < 0xe0 ) |
| 224 | 220 | { |
| r12808 | r12809 | |
| 249 | 245 | |
| 250 | 246 | static STREAM_UPDATE( pv1000_sound_update ) |
| 251 | 247 | { |
| 252 | | d65010_state *state = device->machine().driver_data<d65010_state>(); |
| 248 | pv1000_state *state = device->machine().driver_data<pv1000_state>(); |
| 253 | 249 | stream_sample_t *buffer = outputs[0]; |
| 254 | 250 | |
| 255 | 251 | while ( samples > 0 ) |
| r12808 | r12809 | |
| 282 | 278 | |
| 283 | 279 | static DEVICE_START( pv1000_sound ) |
| 284 | 280 | { |
| 285 | | d65010_state *state = device->machine().driver_data<d65010_state>(); |
| 281 | pv1000_state *state = device->machine().driver_data<pv1000_state>(); |
| 286 | 282 | state->m_sh_channel = device->machine().sound().stream_alloc(*device, 0, 1, device->clock()/1024, 0, pv1000_sound_update ); |
| 287 | 283 | } |
| 288 | 284 | |
| r12808 | r12809 | |
| 305 | 301 | /* we have chosen to trigger on scanlines 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255 */ |
| 306 | 302 | static TIMER_CALLBACK( d65010_irq_on_cb ) |
| 307 | 303 | { |
| 308 | | d65010_state *state = machine.driver_data<d65010_state>(); |
| 304 | pv1000_state *state = machine.driver_data<pv1000_state>(); |
| 309 | 305 | int vpos = state->m_screen->vpos(); |
| 310 | 306 | int next_vpos = vpos + 12; |
| 311 | 307 | |
| r12808 | r12809 | |
| 324 | 320 | |
| 325 | 321 | static TIMER_CALLBACK( d65010_irq_off_cb ) |
| 326 | 322 | { |
| 327 | | d65010_state *state = machine.driver_data<d65010_state>(); |
| 323 | pv1000_state *state = machine.driver_data<pv1000_state>(); |
| 328 | 324 | |
| 329 | 325 | device_set_input_line( state->m_maincpu, 0, CLEAR_LINE ); |
| 330 | 326 | } |
| r12808 | r12809 | |
| 332 | 328 | |
| 333 | 329 | static MACHINE_START( pv1000 ) |
| 334 | 330 | { |
| 335 | | d65010_state *state = machine.driver_data<d65010_state>(); |
| 331 | pv1000_state *state = machine.driver_data<pv1000_state>(); |
| 336 | 332 | |
| 337 | 333 | state->m_irq_on_timer = machine.scheduler().timer_alloc(FUNC(d65010_irq_on_cb)); |
| 338 | 334 | state->m_irq_off_timer = machine.scheduler().timer_alloc(FUNC(d65010_irq_off_cb)); |
| r12808 | r12809 | |
| 343 | 339 | |
| 344 | 340 | static MACHINE_RESET( pv1000 ) |
| 345 | 341 | { |
| 346 | | d65010_state *state = machine.driver_data<d65010_state>(); |
| 342 | pv1000_state *state = machine.driver_data<pv1000_state>(); |
| 347 | 343 | |
| 348 | 344 | state->m_io_regs[5] = 0; |
| 349 | 345 | state->m_fd_data = 0; |
| r12808 | r12809 | |
| 370 | 366 | GFXDECODE_END |
| 371 | 367 | |
| 372 | 368 | |
| 373 | | static MACHINE_CONFIG_START( pv1000, d65010_state ) |
| 369 | static MACHINE_CONFIG_START( pv1000, pv1000_state ) |
| 374 | 370 | |
| 375 | 371 | MCFG_CPU_ADD( "maincpu", Z80, 17897725/5 ) |
| 376 | 372 | MCFG_CPU_PROGRAM_MAP( pv1000 ) |
| r12808 | r12809 | |
| 413 | 409 | |
| 414 | 410 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 415 | 411 | CONS( 1983, pv1000, 0, 0, pv1000, pv1000, 0, "Casio", "PV-1000", GAME_NOT_WORKING ) |
| 416 | | |