trunk/src/mame/drivers/taitotz.c
| r18156 | r18157 | |
| 526 | 526 | virtual void video_start(); |
| 527 | 527 | UINT32 screen_update_taitotz(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 528 | 528 | INTERRUPT_GEN_MEMBER(taitotz_vbi); |
| 529 | DECLARE_READ8_MEMBER(tlcs_ide0_r); |
| 530 | DECLARE_WRITE8_MEMBER(tlcs_ide0_w); |
| 531 | DECLARE_READ8_MEMBER(tlcs_ide1_r); |
| 532 | DECLARE_WRITE8_MEMBER(tlcs_ide1_w); |
| 529 | 533 | }; |
| 530 | 534 | |
| 531 | 535 | |
| r18156 | r18157 | |
| 1994 | 1998 | } |
| 1995 | 1999 | } |
| 1996 | 2000 | |
| 1997 | | static READ8_DEVICE_HANDLER(tlcs_ide0_r) |
| 2001 | READ8_MEMBER(taitotz_state::tlcs_ide0_r) |
| 1998 | 2002 | { |
| 2003 | device_t *device = machine().device("ide"); |
| 1999 | 2004 | static UINT16 ide_reg_latch; |
| 2000 | 2005 | int reg = offset >> 1; |
| 2001 | 2006 | |
| r18156 | r18157 | |
| 2024 | 2029 | } |
| 2025 | 2030 | } |
| 2026 | 2031 | |
| 2027 | | static WRITE8_DEVICE_HANDLER(tlcs_ide0_w) |
| 2032 | WRITE8_MEMBER(taitotz_state::tlcs_ide0_w) |
| 2028 | 2033 | { |
| 2034 | device_t *device = machine().device("ide"); |
| 2029 | 2035 | static UINT16 ide_reg_latch; |
| 2030 | 2036 | int reg = offset >> 1; |
| 2031 | 2037 | |
| r18156 | r18157 | |
| 2051 | 2057 | } |
| 2052 | 2058 | } |
| 2053 | 2059 | |
| 2054 | | static READ8_DEVICE_HANDLER(tlcs_ide1_r) |
| 2060 | READ8_MEMBER(taitotz_state::tlcs_ide1_r) |
| 2055 | 2061 | { |
| 2062 | device_t *device = machine().device("ide"); |
| 2056 | 2063 | //static UINT16 ide_reg_latch; |
| 2057 | 2064 | int reg = offset >> 1; |
| 2058 | 2065 | |
| r18156 | r18157 | |
| 2075 | 2082 | } |
| 2076 | 2083 | } |
| 2077 | 2084 | |
| 2078 | | static WRITE8_DEVICE_HANDLER(tlcs_ide1_w) |
| 2085 | WRITE8_MEMBER(taitotz_state::tlcs_ide1_w) |
| 2079 | 2086 | { |
| 2087 | device_t *device = machine().device("ide"); |
| 2080 | 2088 | static UINT16 ide_reg_latch; |
| 2081 | 2089 | int reg = offset >> 1; |
| 2082 | 2090 | |
| r18156 | r18157 | |
| 2178 | 2186 | AM_RANGE(0x044000, 0x04400f) AM_READWRITE(tlcs_rtc_r, tlcs_rtc_w) |
| 2179 | 2187 | AM_RANGE(0x060000, 0x061fff) AM_READWRITE(tlcs_common_r, tlcs_common_w) |
| 2180 | 2188 | AM_RANGE(0x064000, 0x064fff) AM_RAM AM_SHARE("mbox_ram") // MBox |
| 2181 | | AM_RANGE(0x068000, 0x06800f) AM_DEVREADWRITE_LEGACY("ide", tlcs_ide0_r, tlcs_ide0_w) |
| 2182 | | AM_RANGE(0x06c000, 0x06c00f) AM_DEVREADWRITE_LEGACY("ide", tlcs_ide1_r, tlcs_ide1_w) |
| 2189 | AM_RANGE(0x068000, 0x06800f) AM_READWRITE(tlcs_ide0_r, tlcs_ide0_w) |
| 2190 | AM_RANGE(0x06c000, 0x06c00f) AM_READWRITE(tlcs_ide1_r, tlcs_ide1_w) |
| 2183 | 2191 | AM_RANGE(0xfc0000, 0xffffff) AM_ROM AM_REGION("io_cpu", 0) |
| 2184 | 2192 | ADDRESS_MAP_END |
| 2185 | 2193 | |
| r18156 | r18157 | |
| 2189 | 2197 | AM_RANGE(0x404000, 0x40400f) AM_READWRITE(tlcs_rtc_r, tlcs_rtc_w) |
| 2190 | 2198 | AM_RANGE(0x900000, 0x901fff) AM_READWRITE(tlcs_common_r, tlcs_common_w) |
| 2191 | 2199 | AM_RANGE(0x910000, 0x910fff) AM_RAM AM_SHARE("mbox_ram") // MBox |
| 2192 | | AM_RANGE(0x908000, 0x90800f) AM_DEVREADWRITE_LEGACY("ide", tlcs_ide0_r, tlcs_ide0_w) |
| 2193 | | AM_RANGE(0x918000, 0x91800f) AM_DEVREADWRITE_LEGACY("ide", tlcs_ide1_r, tlcs_ide1_w) |
| 2200 | AM_RANGE(0x908000, 0x90800f) AM_READWRITE(tlcs_ide0_r, tlcs_ide0_w) |
| 2201 | AM_RANGE(0x918000, 0x91800f) AM_READWRITE(tlcs_ide1_r, tlcs_ide1_w) |
| 2194 | 2202 | AM_RANGE(0xfc0000, 0xffffff) AM_ROM AM_REGION("io_cpu", 0) |
| 2195 | 2203 | ADDRESS_MAP_END |
| 2196 | 2204 | |
trunk/src/mame/drivers/mpu4vid.c
| r18156 | r18157 | |
| 270 | 270 | DECLARE_VIDEO_START(mpu4_vid); |
| 271 | 271 | UINT32 screen_update_mpu4_vid(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 272 | 272 | TIMER_DEVICE_CALLBACK_MEMBER(scanline_timer_callback); |
| 273 | DECLARE_READ_LINE_MEMBER(m6809_acia_rx_r); |
| 274 | DECLARE_WRITE_LINE_MEMBER(m6809_acia_tx_w); |
| 275 | DECLARE_READ_LINE_MEMBER(m6809_acia_cts_r); |
| 276 | DECLARE_WRITE_LINE_MEMBER(m6809_acia_rts_w); |
| 277 | DECLARE_READ_LINE_MEMBER(m6809_acia_dcd_r); |
| 278 | DECLARE_WRITE_LINE_MEMBER(m6809_acia_irq); |
| 279 | DECLARE_READ_LINE_MEMBER(m68k_acia_rx_r); |
| 280 | DECLARE_WRITE_LINE_MEMBER(m68k_acia_tx_w); |
| 281 | DECLARE_READ_LINE_MEMBER(m68k_acia_cts_r); |
| 282 | DECLARE_WRITE_LINE_MEMBER(m68k_acia_rts_w); |
| 283 | DECLARE_READ_LINE_MEMBER(m68k_acia_dcd_r); |
| 284 | DECLARE_WRITE_LINE_MEMBER(m68k_acia_irq); |
| 285 | DECLARE_WRITE_LINE_MEMBER(cpu1_ptm_irq); |
| 286 | DECLARE_WRITE8_MEMBER(vid_o1_callback); |
| 287 | DECLARE_WRITE8_MEMBER(vid_o2_callback); |
| 288 | DECLARE_WRITE8_MEMBER(vid_o3_callback); |
| 289 | DECLARE_READ8_MEMBER(pia_ic5_porta_track_r); |
| 273 | 290 | }; |
| 274 | 291 | |
| 275 | 292 | |
| r18156 | r18157 | |
| 312 | 329 | |
| 313 | 330 | /* Communications with 6809 board */ |
| 314 | 331 | |
| 315 | | static READ_LINE_DEVICE_HANDLER( m6809_acia_rx_r ) |
| 332 | READ_LINE_MEMBER(mpu4vid_state::m6809_acia_rx_r) |
| 316 | 333 | { |
| 317 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 318 | | return state->m_m68k_m6809_line; |
| 334 | return m_m68k_m6809_line; |
| 319 | 335 | } |
| 320 | 336 | |
| 321 | | static WRITE_LINE_DEVICE_HANDLER( m6809_acia_tx_w ) |
| 337 | WRITE_LINE_MEMBER(mpu4vid_state::m6809_acia_tx_w) |
| 322 | 338 | { |
| 323 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 324 | | drvstate->m_m6809_m68k_line = state; |
| 339 | m_m6809_m68k_line = state; |
| 325 | 340 | } |
| 326 | 341 | |
| 327 | | static READ_LINE_DEVICE_HANDLER( m6809_acia_cts_r ) |
| 342 | READ_LINE_MEMBER(mpu4vid_state::m6809_acia_cts_r) |
| 328 | 343 | { |
| 329 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 330 | | return state->m_m6809_acia_cts; |
| 344 | return m_m6809_acia_cts; |
| 331 | 345 | } |
| 332 | 346 | |
| 333 | | static WRITE_LINE_DEVICE_HANDLER( m6809_acia_rts_w ) |
| 347 | WRITE_LINE_MEMBER(mpu4vid_state::m6809_acia_rts_w) |
| 334 | 348 | { |
| 335 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 336 | | drvstate->m_m6809_acia_rts = state; |
| 349 | m_m6809_acia_rts = state; |
| 337 | 350 | } |
| 338 | 351 | |
| 339 | | static READ_LINE_DEVICE_HANDLER( m6809_acia_dcd_r ) |
| 352 | READ_LINE_MEMBER(mpu4vid_state::m6809_acia_dcd_r) |
| 340 | 353 | { |
| 341 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 342 | | return state->m_m6809_acia_dcd; |
| 354 | return m_m6809_acia_dcd; |
| 343 | 355 | } |
| 344 | 356 | |
| 345 | | static WRITE_LINE_DEVICE_HANDLER( m6809_acia_irq ) |
| 357 | WRITE_LINE_MEMBER(mpu4vid_state::m6809_acia_irq) |
| 346 | 358 | { |
| 347 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 348 | | drvstate->m_m68k_acia_cts = !state; |
| 349 | | device->machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, state ? CLEAR_LINE : ASSERT_LINE); |
| 359 | m_m68k_acia_cts = !state; |
| 360 | machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, state ? CLEAR_LINE : ASSERT_LINE); |
| 350 | 361 | } |
| 351 | 362 | |
| 352 | 363 | static ACIA6850_INTERFACE( m6809_acia_if ) |
| 353 | 364 | { |
| 354 | 365 | 0, |
| 355 | 366 | 0, |
| 356 | | DEVCB_LINE(m6809_acia_rx_r), |
| 357 | | DEVCB_LINE(m6809_acia_tx_w), |
| 358 | | DEVCB_LINE(m6809_acia_cts_r), |
| 359 | | DEVCB_LINE(m6809_acia_rts_w), |
| 360 | | DEVCB_LINE(m6809_acia_dcd_r), |
| 361 | | DEVCB_LINE(m6809_acia_irq) |
| 367 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_rx_r), |
| 368 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_tx_w), |
| 369 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_cts_r), |
| 370 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_rts_w), |
| 371 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_dcd_r), |
| 372 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m6809_acia_irq) |
| 362 | 373 | }; |
| 363 | 374 | |
| 364 | | static READ_LINE_DEVICE_HANDLER( m68k_acia_rx_r ) |
| 375 | READ_LINE_MEMBER(mpu4vid_state::m68k_acia_rx_r) |
| 365 | 376 | { |
| 366 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 367 | | return state->m_m6809_m68k_line; |
| 377 | return m_m6809_m68k_line; |
| 368 | 378 | } |
| 369 | 379 | |
| 370 | | static WRITE_LINE_DEVICE_HANDLER( m68k_acia_tx_w ) |
| 380 | WRITE_LINE_MEMBER(mpu4vid_state::m68k_acia_tx_w) |
| 371 | 381 | { |
| 372 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 373 | | drvstate->m_m68k_m6809_line = state; |
| 382 | m_m68k_m6809_line = state; |
| 374 | 383 | } |
| 375 | 384 | |
| 376 | | static READ_LINE_DEVICE_HANDLER( m68k_acia_cts_r ) |
| 385 | READ_LINE_MEMBER(mpu4vid_state::m68k_acia_cts_r) |
| 377 | 386 | { |
| 378 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 379 | | return state->m_m68k_acia_cts; |
| 387 | return m_m68k_acia_cts; |
| 380 | 388 | } |
| 381 | 389 | |
| 382 | | static WRITE_LINE_DEVICE_HANDLER( m68k_acia_rts_w ) |
| 390 | WRITE_LINE_MEMBER(mpu4vid_state::m68k_acia_rts_w) |
| 383 | 391 | { |
| 384 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 385 | | drvstate->m_m6809_acia_dcd = state; |
| 392 | m_m6809_acia_dcd = state; |
| 386 | 393 | } |
| 387 | 394 | |
| 388 | | static READ_LINE_DEVICE_HANDLER( m68k_acia_dcd_r ) |
| 395 | READ_LINE_MEMBER(mpu4vid_state::m68k_acia_dcd_r) |
| 389 | 396 | { |
| 390 | | mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>(); |
| 391 | | return state->m_m6809_acia_rts; |
| 397 | return m_m6809_acia_rts; |
| 392 | 398 | } |
| 393 | 399 | |
| 394 | | static WRITE_LINE_DEVICE_HANDLER( m68k_acia_irq ) |
| 400 | WRITE_LINE_MEMBER(mpu4vid_state::m68k_acia_irq) |
| 395 | 401 | { |
| 396 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 397 | | drvstate->m_m6809_acia_cts = !state; |
| 398 | | drvstate->m_m6850_irq_state = state; |
| 399 | | update_mpu68_interrupts(device->machine()); |
| 402 | m_m6809_acia_cts = !state; |
| 403 | m_m6850_irq_state = state; |
| 404 | update_mpu68_interrupts(machine()); |
| 400 | 405 | } |
| 401 | 406 | |
| 402 | 407 | static ACIA6850_INTERFACE( m68k_acia_if ) |
| 403 | 408 | { |
| 404 | 409 | 0, |
| 405 | 410 | 0, |
| 406 | | DEVCB_LINE(m68k_acia_rx_r), |
| 407 | | DEVCB_LINE(m68k_acia_tx_w), |
| 408 | | DEVCB_LINE(m68k_acia_cts_r), |
| 409 | | DEVCB_LINE(m68k_acia_rts_w), |
| 410 | | DEVCB_LINE(m68k_acia_dcd_r), |
| 411 | | DEVCB_LINE(m68k_acia_irq) |
| 411 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_rx_r), |
| 412 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_tx_w), |
| 413 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_cts_r), |
| 414 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_rts_w), |
| 415 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_dcd_r), |
| 416 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, m68k_acia_irq) |
| 412 | 417 | }; |
| 413 | 418 | |
| 414 | 419 | |
| 415 | | static WRITE_LINE_DEVICE_HANDLER( cpu1_ptm_irq ) |
| 420 | WRITE_LINE_MEMBER(mpu4vid_state::cpu1_ptm_irq) |
| 416 | 421 | { |
| 417 | | mpu4vid_state *drvstate = device->machine().driver_data<mpu4vid_state>(); |
| 418 | | drvstate->m_m6840_irq_state = state; |
| 419 | | update_mpu68_interrupts(device->machine()); |
| 422 | m_m6840_irq_state = state; |
| 423 | update_mpu68_interrupts(machine()); |
| 420 | 424 | } |
| 421 | 425 | |
| 422 | 426 | |
| 423 | | static WRITE8_DEVICE_HANDLER( vid_o1_callback ) |
| 427 | WRITE8_MEMBER(mpu4vid_state::vid_o1_callback) |
| 424 | 428 | { |
| 425 | | downcast<ptm6840_device *>(device)->set_c2(data); /* this output is the clock for timer2 */ |
| 429 | downcast<ptm6840_device *>(machine().device("6840ptm_68k"))->set_c2(data); /* this output is the clock for timer2 */ |
| 426 | 430 | |
| 427 | 431 | if (data) |
| 428 | 432 | { |
| 429 | | acia6850_device *acia_0 = space.machine().device<acia6850_device>("acia6850_0"); |
| 430 | | acia6850_device *acia_1 = space.machine().device<acia6850_device>("acia6850_1"); |
| 433 | acia6850_device *acia_0 = machine().device<acia6850_device>("acia6850_0"); |
| 434 | acia6850_device *acia_1 = machine().device<acia6850_device>("acia6850_1"); |
| 431 | 435 | acia_0->tx_clock_in(); |
| 432 | 436 | acia_0->rx_clock_in(); |
| 433 | 437 | acia_1->tx_clock_in(); |
| r18156 | r18157 | |
| 436 | 440 | } |
| 437 | 441 | |
| 438 | 442 | |
| 439 | | static WRITE8_DEVICE_HANDLER( vid_o2_callback ) |
| 443 | WRITE8_MEMBER(mpu4vid_state::vid_o2_callback) |
| 440 | 444 | { |
| 441 | | downcast<ptm6840_device *>(device)->set_c3(data); /* this output is the clock for timer3 */ |
| 445 | downcast<ptm6840_device *>(machine().device("6840ptm_68k"))->set_c3(data); /* this output is the clock for timer3 */ |
| 442 | 446 | } |
| 443 | 447 | |
| 444 | 448 | |
| 445 | | static WRITE8_DEVICE_HANDLER( vid_o3_callback ) |
| 449 | WRITE8_MEMBER(mpu4vid_state::vid_o3_callback) |
| 446 | 450 | { |
| 447 | | downcast<ptm6840_device *>(device)->set_c1(data); /* this output is the clock for timer1 */ |
| 451 | downcast<ptm6840_device *>(machine().device("6840ptm_68k"))->set_c1(data); /* this output is the clock for timer1 */ |
| 448 | 452 | } |
| 449 | 453 | |
| 450 | 454 | |
| r18156 | r18157 | |
| 452 | 456 | { |
| 453 | 457 | VIDEO_MASTER_CLOCK / 10, /* 68k E clock */ |
| 454 | 458 | { 0, 0, 0 }, |
| 455 | | { DEVCB_HANDLER(vid_o1_callback), |
| 456 | | DEVCB_HANDLER(vid_o2_callback), |
| 457 | | DEVCB_HANDLER(vid_o3_callback) }, |
| 458 | | DEVCB_LINE(cpu1_ptm_irq) |
| 459 | { DEVCB_DRIVER_MEMBER(mpu4vid_state,vid_o1_callback), |
| 460 | DEVCB_DRIVER_MEMBER(mpu4vid_state,vid_o2_callback), |
| 461 | DEVCB_DRIVER_MEMBER(mpu4vid_state,vid_o3_callback) }, |
| 462 | DEVCB_DRIVER_LINE_MEMBER(mpu4vid_state, cpu1_ptm_irq) |
| 459 | 463 | }; |
| 460 | 464 | |
| 461 | 465 | |
| r18156 | r18157 | |
| 719 | 723 | * |
| 720 | 724 | *************************************/ |
| 721 | 725 | |
| 722 | | static READ8_DEVICE_HANDLER( pia_ic5_porta_track_r ) |
| 726 | READ8_MEMBER(mpu4vid_state::pia_ic5_porta_track_r) |
| 723 | 727 | { |
| 724 | | mpu4vid_state *state = space.machine().driver_data<mpu4vid_state>(); |
| 725 | 728 | /* The SWP trackball interface connects a standard trackball to the AUX1 port on the MPU4 |
| 726 | 729 | mainboard. As per usual, they've taken the cheap route here, reading and processing the |
| 727 | 730 | raw quadrature signal from the encoder wheels for a 4 bit interface, rather than use any |
| r18156 | r18157 | |
| 730 | 733 | We invert the X and Y data at source due to the use of Schmitt triggers in the interface, which |
| 731 | 734 | clean up the pulses and flip the active phase.*/ |
| 732 | 735 | |
| 733 | | LOG(("%s: IC5 PIA Read of Port A (AUX1)\n",space.machine().describe_context())); |
| 736 | LOG(("%s: IC5 PIA Read of Port A (AUX1)\n",machine().describe_context())); |
| 734 | 737 | |
| 735 | 738 | |
| 736 | | UINT8 data = state->ioport("AUX1")->read(); |
| 739 | UINT8 data = ioport("AUX1")->read(); |
| 737 | 740 | |
| 738 | | INT8 dx = state->ioport("TRACKX")->read(); |
| 739 | | INT8 dy = state->ioport("TRACKY")->read(); |
| 741 | INT8 dx = ioport("TRACKX")->read(); |
| 742 | INT8 dy = ioport("TRACKY")->read(); |
| 740 | 743 | |
| 741 | | state->m_cur[0] = dy + dx; |
| 742 | | state->m_cur[1] = dy - dx; |
| 744 | m_cur[0] = dy + dx; |
| 745 | m_cur[1] = dy - dx; |
| 743 | 746 | |
| 744 | 747 | UINT8 xa, xb, ya, yb; |
| 745 | 748 | |
| 746 | 749 | /* generate pulses for the input port (A and B are 1 unit out of phase for direction sensing)*/ |
| 747 | | xa = ((state->m_cur[0] + 1) & 3) <= 1; |
| 748 | | xb = (state->m_cur[0] & 3) <= 1; |
| 749 | | ya = ((state->m_cur[1] + 1) & 3) <= 1; |
| 750 | | yb = (state->m_cur[1] & 3) <= 1; |
| 750 | xa = ((m_cur[0] + 1) & 3) <= 1; |
| 751 | xb = (m_cur[0] & 3) <= 1; |
| 752 | ya = ((m_cur[1] + 1) & 3) <= 1; |
| 753 | yb = (m_cur[1] & 3) <= 1; |
| 751 | 754 | |
| 752 | 755 | data |= (xa << 4); // XA |
| 753 | 756 | data |= (ya << 5); // YA |
| r18156 | r18157 | |
| 759 | 762 | |
| 760 | 763 | static const pia6821_interface pia_ic5t_intf = |
| 761 | 764 | { |
| 762 | | DEVCB_HANDLER(pia_ic5_porta_track_r), /* port A in */ |
| 765 | DEVCB_DRIVER_MEMBER(mpu4vid_state,pia_ic5_porta_track_r), /* port A in */ |
| 763 | 766 | DEVCB_DRIVER_MEMBER(mpu4_state, pia_ic5_portb_r), /* port B in */ |
| 764 | 767 | DEVCB_NULL, /* line CA1 in */ |
| 765 | 768 | DEVCB_NULL, /* line CB1 in */ |
trunk/src/mess/drivers/ami1200.c
| r18156 | r18157 | |
| 38 | 38 | int m_oldstate[2]; |
| 39 | 39 | DECLARE_WRITE32_MEMBER(aga_overlay_w); |
| 40 | 40 | DECLARE_DRIVER_INIT(a1200); |
| 41 | DECLARE_WRITE8_MEMBER(ami1200_cia_0_porta_w); |
| 42 | DECLARE_READ8_MEMBER(ami1200_cia_0_portb_r); |
| 43 | DECLARE_WRITE8_MEMBER(ami1200_cia_0_portb_w); |
| 44 | DECLARE_READ8_MEMBER(a1200_cia_0_portA_r); |
| 41 | 45 | }; |
| 42 | 46 | |
| 43 | 47 | |
| r18156 | r18157 | |
| 83 | 87 | * |
| 84 | 88 | *************************************/ |
| 85 | 89 | |
| 86 | | static WRITE8_DEVICE_HANDLER( ami1200_cia_0_porta_w ) |
| 90 | WRITE8_MEMBER(ami1200_state::ami1200_cia_0_porta_w) |
| 87 | 91 | { |
| 88 | | ami1200_state *state = space.machine().driver_data<ami1200_state>(); |
| 92 | device_t *device = machine().device("cia_0"); |
| 89 | 93 | |
| 90 | 94 | /* bit 2 = Power Led on Amiga */ |
| 91 | | set_led_status(space.machine(), 0, !BIT(data, 1)); |
| 95 | set_led_status(machine(), 0, !BIT(data, 1)); |
| 92 | 96 | |
| 93 | | handle_cd32_joystick_cia(state, data, mos6526_r(device, space, 2)); |
| 97 | handle_cd32_joystick_cia(this, data, mos6526_r(device, space, 2)); |
| 94 | 98 | } |
| 95 | 99 | |
| 96 | 100 | /************************************* |
| r18156 | r18157 | |
| 108 | 112 | * |
| 109 | 113 | *************************************/ |
| 110 | 114 | |
| 111 | | static READ8_DEVICE_HANDLER( ami1200_cia_0_portb_r ) |
| 115 | READ8_MEMBER(ami1200_state::ami1200_cia_0_portb_r) |
| 112 | 116 | { |
| 113 | 117 | /* parallel port */ |
| 114 | | logerror("%s:CIA0_portb_r\n", space.machine().describe_context()); |
| 118 | logerror("%s:CIA0_portb_r\n", machine().describe_context()); |
| 115 | 119 | return 0xff; |
| 116 | 120 | } |
| 117 | 121 | |
| 118 | | static WRITE8_DEVICE_HANDLER( ami1200_cia_0_portb_w ) |
| 122 | WRITE8_MEMBER(ami1200_state::ami1200_cia_0_portb_w) |
| 119 | 123 | { |
| 120 | 124 | /* parallel port */ |
| 121 | | logerror("%s:CIA0_portb_w(%02x)\n", space.machine().describe_context(), data); |
| 125 | logerror("%s:CIA0_portb_w(%02x)\n", machine().describe_context(), data); |
| 122 | 126 | } |
| 123 | 127 | |
| 124 | 128 | static ADDRESS_MAP_START( a1200_map, AS_PROGRAM, 32, ami1200_state ) |
| r18156 | r18157 | |
| 244 | 248 | * |
| 245 | 249 | *************************************/ |
| 246 | 250 | |
| 247 | | static READ8_DEVICE_HANDLER( a1200_cia_0_portA_r ) |
| 251 | READ8_MEMBER(ami1200_state::a1200_cia_0_portA_r) |
| 248 | 252 | { |
| 249 | | UINT8 ret = space.machine().root_device().ioport("CIA0PORTA")->read() & 0xc0; /* Gameport 1 and 0 buttons */ |
| 250 | | ret |= space.machine().device<amiga_fdc>("fdc")->ciaapra_r(); |
| 253 | UINT8 ret = machine().root_device().ioport("CIA0PORTA")->read() & 0xc0; /* Gameport 1 and 0 buttons */ |
| 254 | ret |= machine().device<amiga_fdc>("fdc")->ciaapra_r(); |
| 251 | 255 | return ret; |
| 252 | 256 | } |
| 253 | 257 | |
| r18156 | r18157 | |
| 258 | 262 | DEVCB_NULL, /* pc_func */ |
| 259 | 263 | DEVCB_NULL, |
| 260 | 264 | DEVCB_NULL, |
| 261 | | DEVCB_DEVICE_HANDLER("cia_0", a1200_cia_0_portA_r), |
| 262 | | DEVCB_DEVICE_HANDLER("cia_0", ami1200_cia_0_porta_w), /* port A */ |
| 263 | | DEVCB_DEVICE_HANDLER("cia_0", ami1200_cia_0_portb_r), |
| 264 | | DEVCB_DEVICE_HANDLER("cia_0", ami1200_cia_0_portb_w) /* port B */ |
| 265 | DEVCB_DRIVER_MEMBER(ami1200_state,a1200_cia_0_portA_r), |
| 266 | DEVCB_DRIVER_MEMBER(ami1200_state,ami1200_cia_0_porta_w), /* port A */ |
| 267 | DEVCB_DRIVER_MEMBER(ami1200_state,ami1200_cia_0_portb_r), |
| 268 | DEVCB_DRIVER_MEMBER(ami1200_state,ami1200_cia_0_portb_w) /* port B */ |
| 265 | 269 | }; |
| 266 | 270 | |
| 267 | 271 | static const mos6526_interface a1200_cia_1_intf = |
trunk/src/mess/drivers/nanos.c
| r18156 | r18157 | |
| 58 | 58 | virtual void video_start(); |
| 59 | 59 | UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 60 | 60 | TIMER_DEVICE_CALLBACK_MEMBER(keyboard_callback); |
| 61 | DECLARE_WRITE_LINE_MEMBER(z80daisy_interrupt); |
| 62 | DECLARE_READ8_MEMBER(nanos_port_a_r); |
| 63 | DECLARE_READ8_MEMBER(nanos_port_b_r); |
| 64 | DECLARE_WRITE8_MEMBER(nanos_port_b_w); |
| 61 | 65 | }; |
| 62 | 66 | |
| 63 | 67 | |
| r18156 | r18157 | |
| 121 | 125 | |
| 122 | 126 | /* Z80-SIO Interface */ |
| 123 | 127 | |
| 124 | | static WRITE_LINE_DEVICE_HANDLER( z80daisy_interrupt ) |
| 128 | WRITE_LINE_MEMBER(nanos_state::z80daisy_interrupt) |
| 125 | 129 | { |
| 126 | | device->machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, state); |
| 130 | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, state); |
| 127 | 131 | } |
| 128 | 132 | |
| 129 | 133 | static const z80sio_interface sio_intf = |
| 130 | 134 | { |
| 131 | | DEVCB_LINE(z80daisy_interrupt), /* interrupt handler */ |
| 135 | DEVCB_DRIVER_LINE_MEMBER(nanos_state, z80daisy_interrupt), /* interrupt handler */ |
| 132 | 136 | DEVCB_NULL, /* DTR changed handler */ |
| 133 | 137 | DEVCB_NULL, /* RTS changed handler */ |
| 134 | 138 | DEVCB_NULL, /* BREAK changed handler */ |
| r18156 | r18157 | |
| 307 | 311 | return 0; |
| 308 | 312 | } |
| 309 | 313 | |
| 310 | | static READ8_DEVICE_HANDLER (nanos_port_a_r) |
| 314 | READ8_MEMBER(nanos_state::nanos_port_a_r) |
| 311 | 315 | { |
| 312 | | nanos_state *state = space.machine().driver_data<nanos_state>(); |
| 313 | 316 | UINT8 retVal; |
| 314 | | if (state->m_key_command==0) { |
| 315 | | return state->m_key_pressed; |
| 317 | if (m_key_command==0) { |
| 318 | return m_key_pressed; |
| 316 | 319 | } else { |
| 317 | | retVal = state->m_last_code; |
| 318 | | state->m_last_code = 0; |
| 320 | retVal = m_last_code; |
| 321 | m_last_code = 0; |
| 319 | 322 | return retVal; |
| 320 | 323 | } |
| 321 | 324 | } |
| 322 | 325 | |
| 323 | | static READ8_DEVICE_HANDLER (nanos_port_b_r) |
| 326 | READ8_MEMBER(nanos_state::nanos_port_b_r) |
| 324 | 327 | { |
| 325 | 328 | return 0xff; |
| 326 | 329 | } |
| 327 | 330 | |
| 328 | 331 | |
| 329 | | static WRITE8_DEVICE_HANDLER (nanos_port_b_w) |
| 332 | WRITE8_MEMBER(nanos_state::nanos_port_b_w) |
| 330 | 333 | { |
| 331 | | nanos_state *state = space.machine().driver_data<nanos_state>(); |
| 332 | | state->m_key_command = BIT(data,1); |
| 334 | m_key_command = BIT(data,1); |
| 333 | 335 | if (BIT(data,7)) { |
| 334 | | state->membank("bank1")->set_base(state->memregion("maincpu")->base()); |
| 336 | membank("bank1")->set_base(memregion("maincpu")->base()); |
| 335 | 337 | } else { |
| 336 | | state->membank("bank1")->set_base(space.machine().device<ram_device>(RAM_TAG)->pointer()); |
| 338 | membank("bank1")->set_base(machine().device<ram_device>(RAM_TAG)->pointer()); |
| 337 | 339 | } |
| 338 | 340 | } |
| 339 | 341 | |
| r18156 | r18157 | |
| 455 | 457 | static Z80PIO_INTERFACE( nanos_z80pio_intf ) |
| 456 | 458 | { |
| 457 | 459 | DEVCB_NULL, /* callback when change interrupt status */ |
| 458 | | DEVCB_HANDLER(nanos_port_a_r), |
| 460 | DEVCB_DRIVER_MEMBER(nanos_state,nanos_port_a_r), |
| 459 | 461 | DEVCB_NULL, |
| 460 | 462 | DEVCB_NULL, |
| 461 | | DEVCB_HANDLER(nanos_port_b_r), |
| 462 | | DEVCB_HANDLER(nanos_port_b_w), |
| 463 | DEVCB_DRIVER_MEMBER(nanos_state,nanos_port_b_r), |
| 464 | DEVCB_DRIVER_MEMBER(nanos_state,nanos_port_b_w), |
| 463 | 465 | DEVCB_NULL |
| 464 | 466 | }; |
| 465 | 467 | |
trunk/src/mess/drivers/pc9801.c
| r18156 | r18157 | |
| 418 | 418 | INTERRUPT_GEN_MEMBER(pc9801_vrtc_irq); |
| 419 | 419 | DECLARE_INPUT_CHANGED_MEMBER(key_stroke); |
| 420 | 420 | DECLARE_INPUT_CHANGED_MEMBER(shift_stroke); |
| 421 | DECLARE_WRITE_LINE_MEMBER(pc9801_master_set_int_line); |
| 422 | DECLARE_READ8_MEMBER(get_slave_ack); |
| 423 | DECLARE_WRITE_LINE_MEMBER(pc_dma_hrq_changed); |
| 424 | DECLARE_WRITE_LINE_MEMBER(pc_dack0_w); |
| 425 | DECLARE_WRITE_LINE_MEMBER(pc_dack1_w); |
| 426 | DECLARE_WRITE_LINE_MEMBER(pc_dack2_w); |
| 427 | DECLARE_WRITE_LINE_MEMBER(pc_dack3_w); |
| 428 | DECLARE_READ8_MEMBER(test_r); |
| 429 | DECLARE_WRITE8_MEMBER(test_w); |
| 430 | DECLARE_READ8_MEMBER(ppi_sys_porta_r); |
| 431 | DECLARE_READ8_MEMBER(ppi_sys_portb_r); |
| 432 | DECLARE_READ8_MEMBER(ppi_prn_portb_r); |
| 433 | DECLARE_WRITE8_MEMBER(ppi_sys_portc_w); |
| 434 | DECLARE_READ8_MEMBER(ppi_fdd_porta_r); |
| 435 | DECLARE_READ8_MEMBER(ppi_fdd_portb_r); |
| 436 | DECLARE_READ8_MEMBER(ppi_fdd_portc_r); |
| 437 | DECLARE_WRITE8_MEMBER(ppi_fdd_portc_w); |
| 438 | DECLARE_WRITE_LINE_MEMBER(fdc_2hd_irq); |
| 439 | DECLARE_WRITE_LINE_MEMBER(fdc_2hd_drq); |
| 440 | DECLARE_WRITE_LINE_MEMBER(fdc_2dd_irq); |
| 441 | DECLARE_WRITE_LINE_MEMBER(fdc_2dd_drq); |
| 442 | DECLARE_WRITE_LINE_MEMBER(pc9801rs_fdc_irq); |
| 421 | 443 | }; |
| 422 | 444 | |
| 423 | 445 | |
| r18156 | r18157 | |
| 2198 | 2220 | */ |
| 2199 | 2221 | |
| 2200 | 2222 | |
| 2201 | | static WRITE_LINE_DEVICE_HANDLER( pc9801_master_set_int_line ) |
| 2223 | WRITE_LINE_MEMBER(pc9801_state::pc9801_master_set_int_line) |
| 2202 | 2224 | { |
| 2203 | 2225 | //printf("%02x\n",interrupt); |
| 2204 | | device->machine().device("maincpu")->execute().set_input_line(0, state ? HOLD_LINE : CLEAR_LINE); |
| 2226 | machine().device("maincpu")->execute().set_input_line(0, state ? HOLD_LINE : CLEAR_LINE); |
| 2205 | 2227 | } |
| 2206 | 2228 | |
| 2207 | | static READ8_DEVICE_HANDLER( get_slave_ack ) |
| 2229 | READ8_MEMBER(pc9801_state::get_slave_ack) |
| 2208 | 2230 | { |
| 2209 | 2231 | if (offset==7) { // IRQ = 7 |
| 2210 | | return pic8259_acknowledge( space.machine().device( "pic8259_slave" )); |
| 2232 | return pic8259_acknowledge( machine().device( "pic8259_slave" )); |
| 2211 | 2233 | } |
| 2212 | 2234 | return 0x00; |
| 2213 | 2235 | } |
| 2214 | 2236 | |
| 2215 | 2237 | static const struct pic8259_interface pic8259_master_config = |
| 2216 | 2238 | { |
| 2217 | | DEVCB_LINE(pc9801_master_set_int_line), |
| 2239 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc9801_master_set_int_line), |
| 2218 | 2240 | DEVCB_LINE_VCC, |
| 2219 | | DEVCB_HANDLER(get_slave_ack) |
| 2241 | DEVCB_DRIVER_MEMBER(pc9801_state,get_slave_ack) |
| 2220 | 2242 | }; |
| 2221 | 2243 | |
| 2222 | 2244 | static const struct pic8259_interface pic8259_slave_config = |
| r18156 | r18157 | |
| 2276 | 2298 | * |
| 2277 | 2299 | ****************************************/ |
| 2278 | 2300 | |
| 2279 | | static WRITE_LINE_DEVICE_HANDLER( pc_dma_hrq_changed ) |
| 2301 | WRITE_LINE_MEMBER(pc9801_state::pc_dma_hrq_changed) |
| 2280 | 2302 | { |
| 2281 | | device->machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE); |
| 2303 | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE); |
| 2282 | 2304 | |
| 2283 | 2305 | /* Assert HLDA */ |
| 2284 | | i8237_hlda_w( device, state ); |
| 2306 | i8237_hlda_w( machine().device("dma8237"), state ); |
| 2285 | 2307 | } |
| 2286 | 2308 | |
| 2287 | 2309 | |
| r18156 | r18157 | |
| 2302 | 2324 | space.write_byte(page_offset + offset, data); |
| 2303 | 2325 | } |
| 2304 | 2326 | |
| 2305 | | static void set_dma_channel(device_t *device, int channel, int state) |
| 2327 | static void set_dma_channel(running_machine &machine, int channel, int state) |
| 2306 | 2328 | { |
| 2307 | | pc9801_state *drvstate = device->machine().driver_data<pc9801_state>(); |
| 2329 | pc9801_state *drvstate = machine.driver_data<pc9801_state>(); |
| 2308 | 2330 | if (!state) drvstate->m_dma_channel = channel; |
| 2309 | 2331 | } |
| 2310 | 2332 | |
| 2311 | | static WRITE_LINE_DEVICE_HANDLER( pc_dack0_w ) { /*printf("%02x 0\n",state);*/ set_dma_channel(device, 0, state); } |
| 2312 | | static WRITE_LINE_DEVICE_HANDLER( pc_dack1_w ) { /*printf("%02x 1\n",state);*/ set_dma_channel(device, 1, state); } |
| 2313 | | static WRITE_LINE_DEVICE_HANDLER( pc_dack2_w ) { /*printf("%02x 2\n",state);*/ set_dma_channel(device, 2, state); } |
| 2314 | | static WRITE_LINE_DEVICE_HANDLER( pc_dack3_w ) { /*printf("%02x 3\n",state);*/ set_dma_channel(device, 3, state); } |
| 2333 | WRITE_LINE_MEMBER(pc9801_state::pc_dack0_w){ /*printf("%02x 0\n",state);*/ set_dma_channel(machine(), 0, state); } |
| 2334 | WRITE_LINE_MEMBER(pc9801_state::pc_dack1_w){ /*printf("%02x 1\n",state);*/ set_dma_channel(machine(), 1, state); } |
| 2335 | WRITE_LINE_MEMBER(pc9801_state::pc_dack2_w){ /*printf("%02x 2\n",state);*/ set_dma_channel(machine(), 2, state); } |
| 2336 | WRITE_LINE_MEMBER(pc9801_state::pc_dack3_w){ /*printf("%02x 3\n",state);*/ set_dma_channel(machine(), 3, state); } |
| 2315 | 2337 | |
| 2316 | | static READ8_DEVICE_HANDLER( test_r ) |
| 2338 | READ8_MEMBER(pc9801_state::test_r) |
| 2317 | 2339 | { |
| 2318 | 2340 | printf("2dd DACK R\n"); |
| 2319 | 2341 | |
| 2320 | 2342 | return 0xff; |
| 2321 | 2343 | } |
| 2322 | 2344 | |
| 2323 | | static WRITE8_DEVICE_HANDLER( test_w ) |
| 2345 | WRITE8_MEMBER(pc9801_state::test_w) |
| 2324 | 2346 | { |
| 2325 | 2347 | printf("2dd DACK W\n"); |
| 2326 | 2348 | } |
| 2327 | 2349 | |
| 2328 | 2350 | static I8237_INTERFACE( dma8237_config ) |
| 2329 | 2351 | { |
| 2330 | | DEVCB_LINE(pc_dma_hrq_changed), |
| 2352 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc_dma_hrq_changed), |
| 2331 | 2353 | DEVCB_NULL, |
| 2332 | 2354 | DEVCB_DRIVER_MEMBER(pc9801_state, pc_dma_read_byte), |
| 2333 | 2355 | DEVCB_DRIVER_MEMBER(pc9801_state, pc_dma_write_byte), |
| 2334 | | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_HANDLER(test_r) }, |
| 2335 | | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_HANDLER(test_w) }, |
| 2336 | | { DEVCB_LINE(pc_dack0_w), DEVCB_LINE(pc_dack1_w), DEVCB_LINE(pc_dack2_w), DEVCB_LINE(pc_dack3_w) } |
| 2356 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_DRIVER_MEMBER(pc9801_state,test_r) }, |
| 2357 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_DRIVER_MEMBER(pc9801_state,test_w) }, |
| 2358 | { DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc_dack0_w), DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc_dack1_w), DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc_dack2_w), DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc_dack3_w) } |
| 2337 | 2359 | }; |
| 2338 | 2360 | |
| 2339 | 2361 | /**************************************** |
| r18156 | r18157 | |
| 2342 | 2364 | * |
| 2343 | 2365 | ****************************************/ |
| 2344 | 2366 | |
| 2345 | | static READ8_DEVICE_HANDLER( ppi_sys_porta_r ) { return device->machine().root_device().ioport("DSW2")->read(); } |
| 2346 | | static READ8_DEVICE_HANDLER( ppi_sys_portb_r ) { return device->machine().root_device().ioport("DSW1")->read() & 0xff; } |
| 2347 | | static READ8_DEVICE_HANDLER( ppi_prn_portb_r ) { return device->machine().root_device().ioport("DSW1")->read() >> 8; } |
| 2367 | READ8_MEMBER(pc9801_state::ppi_sys_porta_r){ return machine().root_device().ioport("DSW2")->read(); } |
| 2368 | READ8_MEMBER(pc9801_state::ppi_sys_portb_r){ return machine().root_device().ioport("DSW1")->read() & 0xff; } |
| 2369 | READ8_MEMBER(pc9801_state::ppi_prn_portb_r){ return machine().root_device().ioport("DSW1")->read() >> 8; } |
| 2348 | 2370 | |
| 2349 | | static WRITE8_DEVICE_HANDLER( ppi_sys_portc_w ) |
| 2371 | WRITE8_MEMBER(pc9801_state::ppi_sys_portc_w) |
| 2350 | 2372 | { |
| 2351 | | beep_set_state(space.machine().device(BEEPER_TAG),!(data & 0x08)); |
| 2373 | beep_set_state(machine().device(BEEPER_TAG),!(data & 0x08)); |
| 2352 | 2374 | } |
| 2353 | 2375 | |
| 2354 | 2376 | static I8255A_INTERFACE( ppi_system_intf ) |
| 2355 | 2377 | { |
| 2356 | | DEVCB_HANDLER(ppi_sys_porta_r), /* Port A read */ |
| 2378 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_sys_porta_r), /* Port A read */ |
| 2357 | 2379 | DEVCB_NULL, /* Port A write */ |
| 2358 | | DEVCB_HANDLER(ppi_sys_portb_r), /* Port B read */ |
| 2380 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_sys_portb_r), /* Port B read */ |
| 2359 | 2381 | DEVCB_NULL, /* Port B write */ |
| 2360 | 2382 | DEVCB_NULL, /* Port C read */ |
| 2361 | | DEVCB_HANDLER(ppi_sys_portc_w) /* Port C write */ |
| 2383 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_sys_portc_w) /* Port C write */ |
| 2362 | 2384 | }; |
| 2363 | 2385 | |
| 2364 | 2386 | static I8255A_INTERFACE( ppi_printer_intf ) |
| 2365 | 2387 | { |
| 2366 | 2388 | DEVCB_NULL, /* Port A read */ |
| 2367 | 2389 | DEVCB_NULL, /* Port A write */ |
| 2368 | | DEVCB_HANDLER(ppi_prn_portb_r), /* Port B read */ |
| 2390 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_prn_portb_r), /* Port B read */ |
| 2369 | 2391 | DEVCB_NULL, /* Port B write */ |
| 2370 | 2392 | DEVCB_NULL, /* Port C read */ |
| 2371 | 2393 | DEVCB_NULL /* Port C write */ |
| 2372 | 2394 | }; |
| 2373 | 2395 | |
| 2374 | | static READ8_DEVICE_HANDLER( ppi_fdd_porta_r ) |
| 2396 | READ8_MEMBER(pc9801_state::ppi_fdd_porta_r) |
| 2375 | 2397 | { |
| 2376 | 2398 | return 0xff; |
| 2377 | 2399 | } |
| 2378 | 2400 | |
| 2379 | | static READ8_DEVICE_HANDLER( ppi_fdd_portb_r ) |
| 2401 | READ8_MEMBER(pc9801_state::ppi_fdd_portb_r) |
| 2380 | 2402 | { |
| 2381 | | return 0xff; //upd765_status_r(space.machine().device("upd765_2dd"),space, 0); |
| 2403 | return 0xff; //upd765_status_r(machine().device("upd765_2dd"),space, 0); |
| 2382 | 2404 | } |
| 2383 | 2405 | |
| 2384 | | static READ8_DEVICE_HANDLER( ppi_fdd_portc_r ) |
| 2406 | READ8_MEMBER(pc9801_state::ppi_fdd_portc_r) |
| 2385 | 2407 | { |
| 2386 | | return 0xff; //upd765_data_r(space.machine().device("upd765_2dd"),space, 0); |
| 2408 | return 0xff; //upd765_data_r(machine().device("upd765_2dd"),space, 0); |
| 2387 | 2409 | } |
| 2388 | 2410 | |
| 2389 | | static WRITE8_DEVICE_HANDLER( ppi_fdd_portc_w ) |
| 2411 | WRITE8_MEMBER(pc9801_state::ppi_fdd_portc_w) |
| 2390 | 2412 | { |
| 2391 | | //upd765_data_w(space.machine().device("upd765_2dd"),space, 0,data); |
| 2413 | //upd765_data_w(machine().device("upd765_2dd"),space, 0,data); |
| 2392 | 2414 | } |
| 2393 | 2415 | |
| 2394 | 2416 | static I8255A_INTERFACE( ppi_fdd_intf ) |
| 2395 | 2417 | { |
| 2396 | | DEVCB_HANDLER(ppi_fdd_porta_r), /* Port A read */ |
| 2418 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_fdd_porta_r), /* Port A read */ |
| 2397 | 2419 | DEVCB_NULL, /* Port A write */ |
| 2398 | | DEVCB_HANDLER(ppi_fdd_portb_r), /* Port B read */ |
| 2420 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_fdd_portb_r), /* Port B read */ |
| 2399 | 2421 | DEVCB_NULL, /* Port B write */ |
| 2400 | | DEVCB_HANDLER(ppi_fdd_portc_r), /* Port C read */ |
| 2401 | | DEVCB_HANDLER(ppi_fdd_portc_w) /* Port C write */ |
| 2422 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_fdd_portc_r), /* Port C read */ |
| 2423 | DEVCB_DRIVER_MEMBER(pc9801_state,ppi_fdd_portc_w) /* Port C write */ |
| 2402 | 2424 | }; |
| 2403 | 2425 | |
| 2404 | 2426 | /**************************************** |
| r18156 | r18157 | |
| 2407 | 2429 | * |
| 2408 | 2430 | ****************************************/ |
| 2409 | 2431 | |
| 2410 | | static WRITE_LINE_DEVICE_HANDLER( fdc_2hd_irq ) |
| 2432 | WRITE_LINE_MEMBER(pc9801_state::fdc_2hd_irq) |
| 2411 | 2433 | { |
| 2412 | 2434 | printf("IRQ %d\n",state); |
| 2413 | 2435 | //if(state) |
| 2414 | | // pic8259_ir3_w(device->machine().device("pic8259_slave"), state); |
| 2436 | // pic8259_ir3_w(machine().device("pic8259_slave"), state); |
| 2415 | 2437 | } |
| 2416 | 2438 | |
| 2417 | | static WRITE_LINE_DEVICE_HANDLER( fdc_2hd_drq ) |
| 2439 | WRITE_LINE_MEMBER(pc9801_state::fdc_2hd_drq) |
| 2418 | 2440 | { |
| 2419 | 2441 | printf("%02x DRQ\n",state); |
| 2420 | 2442 | } |
| 2421 | 2443 | |
| 2422 | | static WRITE_LINE_DEVICE_HANDLER( fdc_2dd_irq ) |
| 2444 | WRITE_LINE_MEMBER(pc9801_state::fdc_2dd_irq) |
| 2423 | 2445 | { |
| 2424 | | pc9801_state *drvstate = device->machine().driver_data<pc9801_state>(); |
| 2425 | 2446 | |
| 2426 | 2447 | printf("IRQ %d\n",state); |
| 2427 | 2448 | |
| 2428 | | if(drvstate->m_fdc_2dd_ctrl & 8) |
| 2449 | if(m_fdc_2dd_ctrl & 8) |
| 2429 | 2450 | { |
| 2430 | | pic8259_ir2_w(device->machine().device("pic8259_slave"), state); |
| 2451 | pic8259_ir2_w(machine().device("pic8259_slave"), state); |
| 2431 | 2452 | } |
| 2432 | 2453 | } |
| 2433 | 2454 | |
| 2434 | | static WRITE_LINE_DEVICE_HANDLER( fdc_2dd_drq ) |
| 2455 | WRITE_LINE_MEMBER(pc9801_state::fdc_2dd_drq) |
| 2435 | 2456 | { |
| 2436 | 2457 | printf("%02x DRQ\n",state); |
| 2437 | 2458 | } |
| 2438 | 2459 | |
| 2439 | 2460 | static const struct upd765_interface upd765_2hd_intf = |
| 2440 | 2461 | { |
| 2441 | | DEVCB_LINE(fdc_2hd_irq), |
| 2442 | | DEVCB_LINE(fdc_2hd_drq), //DRQ, TODO |
| 2462 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, fdc_2hd_irq), |
| 2463 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, fdc_2hd_drq), //DRQ, TODO |
| 2443 | 2464 | NULL, |
| 2444 | 2465 | UPD765_RDY_PIN_CONNECTED, |
| 2445 | 2466 | {FLOPPY_0, FLOPPY_1, NULL, NULL} |
| r18156 | r18157 | |
| 2447 | 2468 | |
| 2448 | 2469 | static const struct upd765_interface upd765_2dd_intf = |
| 2449 | 2470 | { |
| 2450 | | DEVCB_LINE(fdc_2dd_irq), |
| 2451 | | DEVCB_LINE(fdc_2dd_drq), //DRQ, TODO |
| 2471 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, fdc_2dd_irq), |
| 2472 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, fdc_2dd_drq), //DRQ, TODO |
| 2452 | 2473 | NULL, |
| 2453 | 2474 | UPD765_RDY_PIN_CONNECTED, |
| 2454 | 2475 | {NULL, NULL, NULL, NULL} |
| 2455 | 2476 | }; |
| 2456 | 2477 | |
| 2457 | | static WRITE_LINE_DEVICE_HANDLER( pc9801rs_fdc_irq ) |
| 2478 | WRITE_LINE_MEMBER(pc9801_state::pc9801rs_fdc_irq) |
| 2458 | 2479 | { |
| 2459 | | pc9801_state *drvstate = device->machine().driver_data<pc9801_state>(); |
| 2460 | 2480 | |
| 2461 | 2481 | /* 0xffaf8 */ |
| 2462 | 2482 | |
| 2463 | | if(drvstate->m_fdc_ctrl & 1) |
| 2464 | | pic8259_ir3_w(device->machine().device("pic8259_slave"), state); |
| 2483 | if(m_fdc_ctrl & 1) |
| 2484 | pic8259_ir3_w(machine().device("pic8259_slave"), state); |
| 2465 | 2485 | else |
| 2466 | | pic8259_ir2_w(device->machine().device("pic8259_slave"), state); |
| 2486 | pic8259_ir2_w(machine().device("pic8259_slave"), state); |
| 2467 | 2487 | } |
| 2468 | 2488 | |
| 2469 | 2489 | static const struct upd765_interface pc9801rs_upd765_intf = |
| 2470 | 2490 | { |
| 2471 | | DEVCB_LINE(pc9801rs_fdc_irq), |
| 2472 | | DEVCB_LINE(fdc_2dd_drq), //DRQ, TODO |
| 2491 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, pc9801rs_fdc_irq), |
| 2492 | DEVCB_DRIVER_LINE_MEMBER(pc9801_state, fdc_2dd_drq), //DRQ, TODO |
| 2473 | 2493 | NULL, |
| 2474 | 2494 | UPD765_RDY_PIN_CONNECTED, |
| 2475 | 2495 | {FLOPPY_0, FLOPPY_1, FLOPPY_2, FLOPPY_3} |
trunk/src/mess/drivers/mz2000.c
| r18156 | r18157 | |
| 79 | 79 | virtual void machine_reset(); |
| 80 | 80 | virtual void video_start(); |
| 81 | 81 | UINT32 screen_update_mz2000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 82 | DECLARE_READ8_MEMBER(mz2000_wd17xx_r); |
| 83 | DECLARE_WRITE8_MEMBER(mz2000_wd17xx_w); |
| 84 | DECLARE_READ8_MEMBER(mz2000_porta_r); |
| 85 | DECLARE_READ8_MEMBER(mz2000_portb_r); |
| 86 | DECLARE_READ8_MEMBER(mz2000_portc_r); |
| 87 | DECLARE_WRITE8_MEMBER(mz2000_porta_w); |
| 88 | DECLARE_WRITE8_MEMBER(mz2000_portb_w); |
| 89 | DECLARE_WRITE8_MEMBER(mz2000_portc_w); |
| 90 | DECLARE_WRITE8_MEMBER(mz2000_pio1_porta_w); |
| 91 | DECLARE_READ8_MEMBER(mz2000_pio1_portb_r); |
| 92 | DECLARE_READ8_MEMBER(mz2000_pio1_porta_r); |
| 82 | 93 | }; |
| 83 | 94 | |
| 84 | 95 | void mz2000_state::video_start() |
| r18156 | r18157 | |
| 288 | 299 | m_gvram_bank = data & 3; |
| 289 | 300 | } |
| 290 | 301 | |
| 291 | | static READ8_DEVICE_HANDLER( mz2000_wd17xx_r ) |
| 302 | READ8_MEMBER(mz2000_state::mz2000_wd17xx_r) |
| 292 | 303 | { |
| 293 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 304 | device_t *device = machine().device("mb8877a"); |
| 294 | 305 | |
| 295 | | if(state->m_has_fdc) |
| 306 | if(m_has_fdc) |
| 296 | 307 | return wd17xx_r(device, space, offset) ^ 0xff; |
| 297 | 308 | |
| 298 | 309 | return 0xff; |
| 299 | 310 | } |
| 300 | 311 | |
| 301 | | static WRITE8_DEVICE_HANDLER( mz2000_wd17xx_w ) |
| 312 | WRITE8_MEMBER(mz2000_state::mz2000_wd17xx_w) |
| 302 | 313 | { |
| 303 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 314 | device_t *device = machine().device("mb8877a"); |
| 304 | 315 | |
| 305 | | if(state->m_has_fdc) |
| 316 | if(m_has_fdc) |
| 306 | 317 | wd17xx_w(device, space, offset, data ^ 0xff); |
| 307 | 318 | } |
| 308 | 319 | |
| r18156 | r18157 | |
| 353 | 364 | static ADDRESS_MAP_START(mz2000_io, AS_IO, 8, mz2000_state ) |
| 354 | 365 | ADDRESS_MAP_UNMAP_HIGH |
| 355 | 366 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 356 | | AM_RANGE(0xd8, 0xdb) AM_DEVREADWRITE_LEGACY("mb8877a", mz2000_wd17xx_r, mz2000_wd17xx_w) |
| 367 | AM_RANGE(0xd8, 0xdb) AM_READWRITE(mz2000_wd17xx_r, mz2000_wd17xx_w) |
| 357 | 368 | AM_RANGE(0xdc, 0xdd) AM_WRITE(mz2000_fdc_w) |
| 358 | 369 | AM_RANGE(0xe0, 0xe3) AM_DEVREADWRITE("i8255_0", i8255_device, read, write) |
| 359 | 370 | AM_RANGE(0xe4, 0xe7) AM_DEVREADWRITE_LEGACY("pit", pit8253_r, pit8253_w) |
| r18156 | r18157 | |
| 565 | 576 | GFXDECODE_ENTRY( "chargen", 0x0800, mz2000_charlayout_16, 0, 1 ) |
| 566 | 577 | GFXDECODE_END |
| 567 | 578 | |
| 568 | | static READ8_DEVICE_HANDLER( mz2000_porta_r ) |
| 579 | READ8_MEMBER(mz2000_state::mz2000_porta_r) |
| 569 | 580 | { |
| 570 | 581 | printf("A R\n"); |
| 571 | 582 | return 0xff; |
| 572 | 583 | } |
| 573 | 584 | |
| 574 | | static READ8_DEVICE_HANDLER( mz2000_portb_r ) |
| 585 | READ8_MEMBER(mz2000_state::mz2000_portb_r) |
| 575 | 586 | { |
| 576 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 577 | 587 | /* |
| 578 | 588 | x--- ---- break key |
| 579 | 589 | -x-- ---- read tape data |
| r18156 | r18157 | |
| 584 | 594 | */ |
| 585 | 595 | UINT8 res = 0x80; |
| 586 | 596 | |
| 587 | | if(state->m_cass->get_image() != NULL) |
| 597 | if(m_cass->get_image() != NULL) |
| 588 | 598 | { |
| 589 | | res |= (state->m_cass->input() > 0.0038) ? 0x40 : 0x00; |
| 590 | | res |= ((state->m_cass->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_PLAY) ? 0x00 : 0x20; |
| 591 | | res |= (state->m_cass->get_position() >= state->m_cass->get_length()) ? 0x08 : 0x00; |
| 599 | res |= (m_cass->input() > 0.0038) ? 0x40 : 0x00; |
| 600 | res |= ((m_cass->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_PLAY) ? 0x00 : 0x20; |
| 601 | res |= (m_cass->get_position() >= m_cass->get_length()) ? 0x08 : 0x00; |
| 592 | 602 | } |
| 593 | 603 | else |
| 594 | 604 | res |= 0x20; |
| 595 | 605 | |
| 596 | | res |= (space.machine().primary_screen->vblank()) ? 0x00 : 0x01; |
| 606 | res |= (machine().primary_screen->vblank()) ? 0x00 : 0x01; |
| 597 | 607 | |
| 598 | 608 | return res; |
| 599 | 609 | } |
| 600 | 610 | |
| 601 | | static READ8_DEVICE_HANDLER( mz2000_portc_r ) |
| 611 | READ8_MEMBER(mz2000_state::mz2000_portc_r) |
| 602 | 612 | { |
| 603 | 613 | printf("C R\n"); |
| 604 | 614 | return 0xff; |
| 605 | 615 | } |
| 606 | 616 | |
| 607 | | static WRITE8_DEVICE_HANDLER( mz2000_porta_w ) |
| 617 | WRITE8_MEMBER(mz2000_state::mz2000_porta_w) |
| 608 | 618 | { |
| 609 | 619 | /* |
| 610 | 620 | These are enabled thru a 0->1 transition |
| r18156 | r18157 | |
| 617 | 627 | ---- --x- tape ff |
| 618 | 628 | ---- ---x tape rewind |
| 619 | 629 | */ |
| 620 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 621 | 630 | |
| 622 | | if((state->m_tape_ctrl & 0x80) == 0 && data & 0x80) |
| 631 | if((m_tape_ctrl & 0x80) == 0 && data & 0x80) |
| 623 | 632 | { |
| 624 | 633 | //printf("Tape APSS control\n"); |
| 625 | 634 | } |
| 626 | 635 | |
| 627 | | if((state->m_tape_ctrl & 0x40) == 0 && data & 0x40) |
| 636 | if((m_tape_ctrl & 0x40) == 0 && data & 0x40) |
| 628 | 637 | { |
| 629 | 638 | //printf("Tape APLAY control\n"); |
| 630 | 639 | } |
| 631 | 640 | |
| 632 | | if((state->m_tape_ctrl & 0x20) == 0 && data & 0x20) |
| 641 | if((m_tape_ctrl & 0x20) == 0 && data & 0x20) |
| 633 | 642 | { |
| 634 | 643 | //printf("Tape AREW control\n"); |
| 635 | 644 | } |
| 636 | 645 | |
| 637 | | if((state->m_tape_ctrl & 0x10) == 0 && data & 0x10) |
| 646 | if((m_tape_ctrl & 0x10) == 0 && data & 0x10) |
| 638 | 647 | { |
| 639 | 648 | //printf("reverse video control\n"); |
| 640 | 649 | } |
| 641 | 650 | |
| 642 | | if((state->m_tape_ctrl & 0x08) == 0 && data & 0x08) // stop |
| 651 | if((m_tape_ctrl & 0x08) == 0 && data & 0x08) // stop |
| 643 | 652 | { |
| 644 | | state->m_cass->change_state(CASSETTE_MOTOR_DISABLED,CASSETTE_MASK_MOTOR); |
| 645 | | state->m_cass->change_state(CASSETTE_STOPPED,CASSETTE_MASK_UISTATE); |
| 653 | m_cass->change_state(CASSETTE_MOTOR_DISABLED,CASSETTE_MASK_MOTOR); |
| 654 | m_cass->change_state(CASSETTE_STOPPED,CASSETTE_MASK_UISTATE); |
| 646 | 655 | } |
| 647 | 656 | |
| 648 | | if((state->m_tape_ctrl & 0x04) == 0 && data & 0x04) // play |
| 657 | if((m_tape_ctrl & 0x04) == 0 && data & 0x04) // play |
| 649 | 658 | { |
| 650 | | state->m_cass->change_state(CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR); |
| 651 | | state->m_cass->change_state(CASSETTE_PLAY,CASSETTE_MASK_UISTATE); |
| 659 | m_cass->change_state(CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR); |
| 660 | m_cass->change_state(CASSETTE_PLAY,CASSETTE_MASK_UISTATE); |
| 652 | 661 | } |
| 653 | 662 | |
| 654 | | if((state->m_tape_ctrl & 0x02) == 0 && data & 0x02) |
| 663 | if((m_tape_ctrl & 0x02) == 0 && data & 0x02) |
| 655 | 664 | { |
| 656 | 665 | //printf("Tape FF control\n"); |
| 657 | 666 | } |
| 658 | 667 | |
| 659 | | if((state->m_tape_ctrl & 0x01) == 0 && data & 0x01) |
| 668 | if((m_tape_ctrl & 0x01) == 0 && data & 0x01) |
| 660 | 669 | { |
| 661 | 670 | //printf("Tape Rewind control\n"); |
| 662 | 671 | } |
| 663 | 672 | |
| 664 | | state->m_tape_ctrl = data; |
| 673 | m_tape_ctrl = data; |
| 665 | 674 | } |
| 666 | 675 | |
| 667 | | static WRITE8_DEVICE_HANDLER( mz2000_portb_w ) |
| 676 | WRITE8_MEMBER(mz2000_state::mz2000_portb_w) |
| 668 | 677 | { |
| 669 | 678 | //printf("B W %02x\n",data); |
| 670 | 679 | |
| 671 | 680 | // ... |
| 672 | 681 | } |
| 673 | 682 | |
| 674 | | static WRITE8_DEVICE_HANDLER( mz2000_portc_w ) |
| 683 | WRITE8_MEMBER(mz2000_state::mz2000_portc_w) |
| 675 | 684 | { |
| 676 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 677 | 685 | /* |
| 678 | 686 | x--- ---- tape data write |
| 679 | 687 | -x-- ---- tape rec |
| r18156 | r18157 | |
| 685 | 693 | */ |
| 686 | 694 | //printf("C W %02x\n",data); |
| 687 | 695 | |
| 688 | | if(((state->m_old_portc & 8) == 0) && data & 8) |
| 689 | | state->m_ipl_enable = 1; |
| 696 | if(((m_old_portc & 8) == 0) && data & 8) |
| 697 | m_ipl_enable = 1; |
| 690 | 698 | |
| 691 | | if(((state->m_old_portc & 2) == 0) && data & 2) |
| 699 | if(((m_old_portc & 2) == 0) && data & 2) |
| 692 | 700 | { |
| 693 | | state->m_ipl_enable = 0; |
| 701 | m_ipl_enable = 0; |
| 694 | 702 | /* correct? */ |
| 695 | | space.machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE); |
| 703 | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE); |
| 696 | 704 | } |
| 697 | 705 | |
| 698 | | beep_set_state(space.machine().device(BEEPER_TAG),data & 0x04); |
| 706 | beep_set_state(machine().device(BEEPER_TAG),data & 0x04); |
| 699 | 707 | |
| 700 | | state->m_old_portc = data; |
| 708 | m_old_portc = data; |
| 701 | 709 | } |
| 702 | 710 | |
| 703 | 711 | static I8255_INTERFACE( ppi8255_intf ) |
| 704 | 712 | { |
| 705 | | DEVCB_HANDLER(mz2000_porta_r), /* Port A read */ |
| 706 | | DEVCB_HANDLER(mz2000_porta_w), /* Port A write */ |
| 707 | | DEVCB_HANDLER(mz2000_portb_r), /* Port B read */ |
| 708 | | DEVCB_HANDLER(mz2000_portb_w), /* Port B write */ |
| 709 | | DEVCB_HANDLER(mz2000_portc_r), /* Port C read */ |
| 710 | | DEVCB_HANDLER(mz2000_portc_w) /* Port C write */ |
| 713 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_porta_r), /* Port A read */ |
| 714 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_porta_w), /* Port A write */ |
| 715 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_portb_r), /* Port B read */ |
| 716 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_portb_w), /* Port B write */ |
| 717 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_portc_r), /* Port C read */ |
| 718 | DEVCB_DRIVER_MEMBER(mz2000_state,mz2000_portc_w) /* Port C write */ |
| 711 | 719 | }; |
| 712 | 720 | |
| 713 | | static WRITE8_DEVICE_HANDLER( mz2000_pio1_porta_w ) |
| 721 | WRITE8_MEMBER(mz2000_state::mz2000_pio1_porta_w) |
| 714 | 722 | { |
| 715 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 716 | | state->m_tvram_enable = ((data & 0xc0) == 0xc0); |
| 717 | | state->m_gvram_enable = ((data & 0xc0) == 0x80); |
| 718 | | state->m_width80 = ((data & 0x20) >> 5); |
| 719 | | state->m_key_mux = data & 0x1f; |
| 723 | m_tvram_enable = ((data & 0xc0) == 0xc0); |
| 724 | m_gvram_enable = ((data & 0xc0) == 0x80); |
| 725 | m_width80 = ((data & 0x20) >> 5); |
| 726 | m_key_mux = data & 0x1f; |
| 720 | 727 | |
| 721 | | state->m_porta_latch = data; |
| 728 | m_porta_latch = data; |
| 722 | 729 | } |
| 723 | 730 | |
| 724 | | static READ8_DEVICE_HANDLER( mz2000_pio1_portb_r ) |
| 731 | READ8_MEMBER(mz2000_state::mz2000_pio1_portb_r) |
| 725 | 732 | { |
| 726 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 727 | 733 | static const char *const keynames[] = { "KEY0", "KEY1", "KEY2", "KEY3", |
| 728 | 734 | "KEY4", "KEY5", "KEY6", "KEY7", |
| 729 | 735 | "KEY8", "KEY9", "KEYA", "KEYB", |
| 730 | 736 | "KEYC", "KEYD", "UNUSED", "UNUSED" }; |
| 731 | 737 | |
| 732 | | if(((state->m_key_mux & 0x10) == 0x00) || ((state->m_key_mux & 0x0f) == 0x0f)) //status read |
| 738 | if(((m_key_mux & 0x10) == 0x00) || ((m_key_mux & 0x0f) == 0x0f)) //status read |
| 733 | 739 | { |
| 734 | 740 | int res,i; |
| 735 | 741 | |
| 736 | 742 | res = 0xff; |
| 737 | 743 | for(i=0;i<0xe;i++) |
| 738 | | res &= space.machine().root_device().ioport(keynames[i])->read(); |
| 744 | res &= machine().root_device().ioport(keynames[i])->read(); |
| 739 | 745 | |
| 740 | 746 | return res; |
| 741 | 747 | } |
| 742 | 748 | |
| 743 | | return space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read(); |
| 749 | return machine().root_device().ioport(keynames[m_key_mux & 0xf])->read(); |
| 744 | 750 | } |
| 745 | 751 | |
| 746 | | static READ8_DEVICE_HANDLER( mz2000_pio1_porta_r ) |
| 752 | READ8_MEMBER(mz2000_state::mz2000_pio1_porta_r) |
| 747 | 753 | { |
| 748 | | mz2000_state *state = space.machine().driver_data<mz2000_state>(); |
| 749 | 754 | |
| 750 | | return state->m_porta_latch; |
| 755 | return m_porta_latch; |
| 751 | 756 | } |
| 752 | 757 | |
| 753 | 758 | static Z80PIO_INTERFACE( mz2000_pio1_intf ) |
| 754 | 759 | { |
| 755 | 760 | DEVCB_NULL, |
| 756 | | DEVCB_HANDLER( mz2000_pio1_porta_r ), |
| 757 | | DEVCB_HANDLER( mz2000_pio1_porta_w ), |
| 761 | DEVCB_DRIVER_MEMBER(mz2000_state, mz2000_pio1_porta_r ), |
| 762 | DEVCB_DRIVER_MEMBER(mz2000_state, mz2000_pio1_porta_w ), |
| 758 | 763 | DEVCB_NULL, |
| 759 | | DEVCB_HANDLER( mz2000_pio1_portb_r ), |
| 764 | DEVCB_DRIVER_MEMBER(mz2000_state, mz2000_pio1_portb_r ), |
| 760 | 765 | DEVCB_NULL, |
| 761 | 766 | DEVCB_NULL |
| 762 | 767 | }; |
trunk/src/mess/drivers/jr100.c
| r18156 | r18157 | |
| 44 | 44 | virtual void video_start(); |
| 45 | 45 | UINT32 screen_update_jr100(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 46 | 46 | TIMER_DEVICE_CALLBACK_MEMBER(sound_tick); |
| 47 | DECLARE_READ8_MEMBER(jr100_via_read_b); |
| 48 | DECLARE_WRITE8_MEMBER(jr100_via_write_a); |
| 49 | DECLARE_WRITE8_MEMBER(jr100_via_write_b); |
| 50 | DECLARE_WRITE_LINE_MEMBER(jr100_via_write_cb2); |
| 47 | 51 | }; |
| 48 | 52 | |
| 49 | 53 | |
| r18156 | r18157 | |
| 228 | 232 | }; |
| 229 | 233 | |
| 230 | 234 | |
| 231 | | static READ8_DEVICE_HANDLER(jr100_via_read_b) |
| 235 | READ8_MEMBER(jr100_state::jr100_via_read_b) |
| 232 | 236 | { |
| 233 | | jr100_state *state = space.machine().driver_data<jr100_state>(); |
| 234 | 237 | UINT8 val = 0x1f; |
| 235 | | if (keynames[state->m_keyboard_line]) { |
| 236 | | val = state->ioport(keynames[state->m_keyboard_line])->read(); |
| 238 | if (keynames[m_keyboard_line]) { |
| 239 | val = ioport(keynames[m_keyboard_line])->read(); |
| 237 | 240 | } |
| 238 | 241 | return val; |
| 239 | 242 | } |
| 240 | 243 | |
| 241 | | static WRITE8_DEVICE_HANDLER(jr100_via_write_a ) |
| 244 | WRITE8_MEMBER(jr100_state::jr100_via_write_a) |
| 242 | 245 | { |
| 243 | | jr100_state *state = space.machine().driver_data<jr100_state>(); |
| 244 | | state->m_keyboard_line = data & 0x0f; |
| 246 | m_keyboard_line = data & 0x0f; |
| 245 | 247 | } |
| 246 | 248 | |
| 247 | | static WRITE8_DEVICE_HANDLER(jr100_via_write_b ) |
| 249 | WRITE8_MEMBER(jr100_state::jr100_via_write_b) |
| 248 | 250 | { |
| 249 | | jr100_state *state = space.machine().driver_data<jr100_state>(); |
| 250 | | state->m_use_pcg = (data & 0x20) ? TRUE : FALSE; |
| 251 | | state->m_speaker = data>>7; |
| 251 | m_use_pcg = (data & 0x20) ? TRUE : FALSE; |
| 252 | m_speaker = data>>7; |
| 252 | 253 | } |
| 253 | 254 | |
| 254 | | static WRITE_LINE_DEVICE_HANDLER(jr100_via_write_cb2) |
| 255 | WRITE_LINE_MEMBER(jr100_state::jr100_via_write_cb2) |
| 255 | 256 | { |
| 256 | | device->machine().device<cassette_image_device>(CASSETTE_TAG)->output(state ? -1.0 : +1.0); |
| 257 | machine().device<cassette_image_device>(CASSETTE_TAG)->output(state ? -1.0 : +1.0); |
| 257 | 258 | } |
| 258 | 259 | static const via6522_interface jr100_via_intf = |
| 259 | 260 | { |
| 260 | 261 | DEVCB_NULL, /* in_a_func */ |
| 261 | | DEVCB_HANDLER(jr100_via_read_b), /* in_b_func */ |
| 262 | DEVCB_DRIVER_MEMBER(jr100_state,jr100_via_read_b), /* in_b_func */ |
| 262 | 263 | DEVCB_NULL, /* in_ca1_func */ |
| 263 | 264 | DEVCB_NULL, /* in_cb1_func */ |
| 264 | 265 | DEVCB_NULL, /* in_ca2_func */ |
| 265 | 266 | DEVCB_NULL, /* in_cb2_func */ |
| 266 | | DEVCB_HANDLER(jr100_via_write_a), /* out_a_func */ |
| 267 | | DEVCB_HANDLER(jr100_via_write_b), /* out_b_func */ |
| 267 | DEVCB_DRIVER_MEMBER(jr100_state,jr100_via_write_a), /* out_a_func */ |
| 268 | DEVCB_DRIVER_MEMBER(jr100_state,jr100_via_write_b), /* out_b_func */ |
| 268 | 269 | DEVCB_NULL, /* out_ca1_func */ |
| 269 | 270 | DEVCB_NULL, /* out_cb1_func */ |
| 270 | 271 | DEVCB_NULL, /* out_ca2_func */ |
| 271 | | DEVCB_LINE(jr100_via_write_cb2), /* out_cb2_func */ |
| 272 | DEVCB_DRIVER_LINE_MEMBER(jr100_state, jr100_via_write_cb2), /* out_cb2_func */ |
| 272 | 273 | DEVCB_NULL /* irq_func */ |
| 273 | 274 | }; |
| 274 | 275 | static const cassette_interface jr100_cassette_interface = |
trunk/src/mess/drivers/pc88va.c
| r18156 | r18157 | |
| 105 | 105 | INTERRUPT_GEN_MEMBER(pc88va_vrtc_irq); |
| 106 | 106 | TIMER_CALLBACK_MEMBER(pc8801fd_upd765_tc_to_zero); |
| 107 | 107 | TIMER_CALLBACK_MEMBER(t3_mouse_callback); |
| 108 | DECLARE_READ8_MEMBER(cpu_8255_c_r); |
| 109 | DECLARE_WRITE8_MEMBER(cpu_8255_c_w); |
| 110 | DECLARE_READ8_MEMBER(fdc_8255_c_r); |
| 111 | DECLARE_WRITE8_MEMBER(fdc_8255_c_w); |
| 112 | DECLARE_READ8_MEMBER(r232_ctrl_porta_r); |
| 113 | DECLARE_READ8_MEMBER(r232_ctrl_portb_r); |
| 114 | DECLARE_READ8_MEMBER(r232_ctrl_portc_r); |
| 115 | DECLARE_WRITE8_MEMBER(r232_ctrl_porta_w); |
| 116 | DECLARE_WRITE8_MEMBER(r232_ctrl_portb_w); |
| 117 | DECLARE_WRITE8_MEMBER(r232_ctrl_portc_w); |
| 118 | DECLARE_WRITE_LINE_MEMBER(pc88va_pic_irq); |
| 119 | DECLARE_READ8_MEMBER(get_slave_ack); |
| 120 | DECLARE_WRITE_LINE_MEMBER(pc88va_pit_out0_changed); |
| 121 | DECLARE_WRITE_LINE_MEMBER(pc88va_upd765_interrupt); |
| 108 | 122 | }; |
| 109 | 123 | |
| 110 | 124 | |
| r18156 | r18157 | |
| 1396 | 1410 | GFXDECODE_ENTRY( "kanji", 0x00000, pc88va_chars_16x16, 0, 1 ) |
| 1397 | 1411 | GFXDECODE_END |
| 1398 | 1412 | |
| 1399 | | static READ8_DEVICE_HANDLER( cpu_8255_c_r ) |
| 1413 | READ8_MEMBER(pc88va_state::cpu_8255_c_r) |
| 1400 | 1414 | { |
| 1401 | | pc88va_state *state = space.machine().driver_data<pc88va_state>(); |
| 1402 | 1415 | |
| 1403 | | return state->m_i8255_1_pc >> 4; |
| 1416 | return m_i8255_1_pc >> 4; |
| 1404 | 1417 | } |
| 1405 | 1418 | |
| 1406 | | static WRITE8_DEVICE_HANDLER( cpu_8255_c_w ) |
| 1419 | WRITE8_MEMBER(pc88va_state::cpu_8255_c_w) |
| 1407 | 1420 | { |
| 1408 | | pc88va_state *state = space.machine().driver_data<pc88va_state>(); |
| 1409 | 1421 | |
| 1410 | | state->m_i8255_0_pc = data; |
| 1422 | m_i8255_0_pc = data; |
| 1411 | 1423 | } |
| 1412 | 1424 | |
| 1413 | 1425 | static I8255A_INTERFACE( master_fdd_intf ) |
| r18156 | r18157 | |
| 1416 | 1428 | DEVCB_NULL, // Port A write |
| 1417 | 1429 | DEVCB_DEVICE_MEMBER("d8255_2s", i8255_device, pa_r), // Port B read |
| 1418 | 1430 | DEVCB_NULL, // Port B write |
| 1419 | | DEVCB_HANDLER(cpu_8255_c_r), // Port C read |
| 1420 | | DEVCB_HANDLER(cpu_8255_c_w) // Port C write |
| 1431 | DEVCB_DRIVER_MEMBER(pc88va_state,cpu_8255_c_r), // Port C read |
| 1432 | DEVCB_DRIVER_MEMBER(pc88va_state,cpu_8255_c_w) // Port C write |
| 1421 | 1433 | }; |
| 1422 | 1434 | |
| 1423 | | static READ8_DEVICE_HANDLER( fdc_8255_c_r ) |
| 1435 | READ8_MEMBER(pc88va_state::fdc_8255_c_r) |
| 1424 | 1436 | { |
| 1425 | | pc88va_state *state = space.machine().driver_data<pc88va_state>(); |
| 1426 | 1437 | |
| 1427 | | return state->m_i8255_0_pc >> 4; |
| 1438 | return m_i8255_0_pc >> 4; |
| 1428 | 1439 | } |
| 1429 | 1440 | |
| 1430 | | static WRITE8_DEVICE_HANDLER( fdc_8255_c_w ) |
| 1441 | WRITE8_MEMBER(pc88va_state::fdc_8255_c_w) |
| 1431 | 1442 | { |
| 1432 | | pc88va_state *state = space.machine().driver_data<pc88va_state>(); |
| 1433 | 1443 | |
| 1434 | | state->m_i8255_1_pc = data; |
| 1444 | m_i8255_1_pc = data; |
| 1435 | 1445 | } |
| 1436 | 1446 | |
| 1437 | 1447 | static I8255A_INTERFACE( slave_fdd_intf ) |
| r18156 | r18157 | |
| 1440 | 1450 | DEVCB_NULL, // Port A write |
| 1441 | 1451 | DEVCB_DEVICE_MEMBER("d8255_2", i8255_device, pa_r), // Port B read |
| 1442 | 1452 | DEVCB_NULL, // Port B write |
| 1443 | | DEVCB_HANDLER(fdc_8255_c_r), // Port C read |
| 1444 | | DEVCB_HANDLER(fdc_8255_c_w) // Port C write |
| 1453 | DEVCB_DRIVER_MEMBER(pc88va_state,fdc_8255_c_r), // Port C read |
| 1454 | DEVCB_DRIVER_MEMBER(pc88va_state,fdc_8255_c_w) // Port C write |
| 1445 | 1455 | }; |
| 1446 | 1456 | |
| 1447 | | static READ8_DEVICE_HANDLER( r232_ctrl_porta_r ) |
| 1457 | READ8_MEMBER(pc88va_state::r232_ctrl_porta_r) |
| 1448 | 1458 | { |
| 1449 | 1459 | UINT8 sw5, sw4, sw3, sw2,speed_sw; |
| 1450 | 1460 | |
| 1451 | | speed_sw = (space.machine().root_device().ioport("SPEED_SW")->read() & 1) ? 0x20 : 0x00; |
| 1452 | | sw5 = (space.machine().root_device().ioport("DSW")->read() & 0x10); |
| 1453 | | sw4 = (space.machine().root_device().ioport("DSW")->read() & 0x08); |
| 1454 | | sw3 = (space.machine().root_device().ioport("DSW")->read() & 0x04); |
| 1455 | | sw2 = (space.machine().root_device().ioport("DSW")->read() & 0x02); |
| 1461 | speed_sw = (machine().root_device().ioport("SPEED_SW")->read() & 1) ? 0x20 : 0x00; |
| 1462 | sw5 = (machine().root_device().ioport("DSW")->read() & 0x10); |
| 1463 | sw4 = (machine().root_device().ioport("DSW")->read() & 0x08); |
| 1464 | sw3 = (machine().root_device().ioport("DSW")->read() & 0x04); |
| 1465 | sw2 = (machine().root_device().ioport("DSW")->read() & 0x02); |
| 1456 | 1466 | |
| 1457 | 1467 | return 0xc1 | sw5 | sw4 | sw3 | sw2 | speed_sw; |
| 1458 | 1468 | } |
| 1459 | 1469 | |
| 1460 | | static READ8_DEVICE_HANDLER( r232_ctrl_portb_r ) |
| 1470 | READ8_MEMBER(pc88va_state::r232_ctrl_portb_r) |
| 1461 | 1471 | { |
| 1462 | 1472 | UINT8 xsw1; |
| 1463 | 1473 | |
| 1464 | | xsw1 = (space.machine().root_device().ioport("DSW")->read() & 1) ? 0 : 8; |
| 1474 | xsw1 = (machine().root_device().ioport("DSW")->read() & 1) ? 0 : 8; |
| 1465 | 1475 | |
| 1466 | 1476 | return 0xf7 | xsw1; |
| 1467 | 1477 | } |
| 1468 | 1478 | |
| 1469 | | static READ8_DEVICE_HANDLER( r232_ctrl_portc_r ) |
| 1479 | READ8_MEMBER(pc88va_state::r232_ctrl_portc_r) |
| 1470 | 1480 | { |
| 1471 | 1481 | return 0xff; |
| 1472 | 1482 | } |
| 1473 | 1483 | |
| 1474 | | static WRITE8_DEVICE_HANDLER( r232_ctrl_porta_w ) |
| 1484 | WRITE8_MEMBER(pc88va_state::r232_ctrl_porta_w) |
| 1475 | 1485 | { |
| 1476 | 1486 | // ... |
| 1477 | 1487 | } |
| 1478 | 1488 | |
| 1479 | | static WRITE8_DEVICE_HANDLER( r232_ctrl_portb_w ) |
| 1489 | WRITE8_MEMBER(pc88va_state::r232_ctrl_portb_w) |
| 1480 | 1490 | { |
| 1481 | 1491 | // ... |
| 1482 | 1492 | } |
| 1483 | 1493 | |
| 1484 | | static WRITE8_DEVICE_HANDLER( r232_ctrl_portc_w ) |
| 1494 | WRITE8_MEMBER(pc88va_state::r232_ctrl_portc_w) |
| 1485 | 1495 | { |
| 1486 | 1496 | // ... |
| 1487 | 1497 | } |
| 1488 | 1498 | |
| 1489 | 1499 | static I8255_INTERFACE( r232c_ctrl_intf ) |
| 1490 | 1500 | { |
| 1491 | | DEVCB_HANDLER(r232_ctrl_porta_r), /* Port A read */ |
| 1492 | | DEVCB_HANDLER(r232_ctrl_porta_w), /* Port A write */ |
| 1493 | | DEVCB_HANDLER(r232_ctrl_portb_r), /* Port B read */ |
| 1494 | | DEVCB_HANDLER(r232_ctrl_portb_w), /* Port B write */ |
| 1495 | | DEVCB_HANDLER(r232_ctrl_portc_r), /* Port C read */ |
| 1496 | | DEVCB_HANDLER(r232_ctrl_portc_w) /* Port C write */ |
| 1501 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_porta_r), /* Port A read */ |
| 1502 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_porta_w), /* Port A write */ |
| 1503 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_portb_r), /* Port B read */ |
| 1504 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_portb_w), /* Port B write */ |
| 1505 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_portc_r), /* Port C read */ |
| 1506 | DEVCB_DRIVER_MEMBER(pc88va_state,r232_ctrl_portc_w) /* Port C write */ |
| 1497 | 1507 | }; |
| 1498 | 1508 | |
| 1499 | 1509 | static IRQ_CALLBACK(pc88va_irq_callback) |
| r18156 | r18157 | |
| 1501 | 1511 | return pic8259_acknowledge( device->machine().device( "pic8259_master" ) ); |
| 1502 | 1512 | } |
| 1503 | 1513 | |
| 1504 | | static WRITE_LINE_DEVICE_HANDLER( pc88va_pic_irq ) |
| 1514 | WRITE_LINE_MEMBER(pc88va_state::pc88va_pic_irq) |
| 1505 | 1515 | { |
| 1506 | | device->machine().device("maincpu")->execute().set_input_line(0, state ? HOLD_LINE : CLEAR_LINE); |
| 1516 | machine().device("maincpu")->execute().set_input_line(0, state ? HOLD_LINE : CLEAR_LINE); |
| 1507 | 1517 | // logerror("PIC#1: set IRQ line to %i\n",interrupt); |
| 1508 | 1518 | } |
| 1509 | 1519 | |
| 1510 | | static READ8_DEVICE_HANDLER( get_slave_ack ) |
| 1520 | READ8_MEMBER(pc88va_state::get_slave_ack) |
| 1511 | 1521 | { |
| 1512 | 1522 | if (offset==7) { // IRQ = 7 |
| 1513 | | return pic8259_acknowledge(space.machine().device( "pic8259_slave")); |
| 1523 | return pic8259_acknowledge(machine().device( "pic8259_slave")); |
| 1514 | 1524 | } |
| 1515 | 1525 | return 0x00; |
| 1516 | 1526 | } |
| 1517 | 1527 | |
| 1518 | 1528 | static const struct pic8259_interface pc88va_pic8259_master_config = |
| 1519 | 1529 | { |
| 1520 | | DEVCB_LINE(pc88va_pic_irq), |
| 1530 | DEVCB_DRIVER_LINE_MEMBER(pc88va_state, pc88va_pic_irq), |
| 1521 | 1531 | DEVCB_LINE_VCC, |
| 1522 | | DEVCB_HANDLER(get_slave_ack) |
| 1532 | DEVCB_DRIVER_MEMBER(pc88va_state,get_slave_ack) |
| 1523 | 1533 | }; |
| 1524 | 1534 | |
| 1525 | 1535 | static const struct pic8259_interface pc88va_pic8259_slave_config = |
| r18156 | r18157 | |
| 1592 | 1602 | }; |
| 1593 | 1603 | |
| 1594 | 1604 | |
| 1595 | | static WRITE_LINE_DEVICE_HANDLER( pc88va_pit_out0_changed ) |
| 1605 | WRITE_LINE_MEMBER(pc88va_state::pc88va_pit_out0_changed) |
| 1596 | 1606 | { |
| 1597 | | pic8259_ir0_w(device->machine().device("pic8259_master"), 1); |
| 1607 | pic8259_ir0_w(machine().device("pic8259_master"), 1); |
| 1598 | 1608 | } |
| 1599 | 1609 | |
| 1600 | 1610 | static const struct pit8253_config pc88va_pit8253_config = |
| r18156 | r18157 | |
| 1604 | 1614 | /* general purpose timer 1 */ |
| 1605 | 1615 | 8000000, |
| 1606 | 1616 | DEVCB_NULL, |
| 1607 | | DEVCB_LINE(pc88va_pit_out0_changed) |
| 1617 | DEVCB_DRIVER_LINE_MEMBER(pc88va_state, pc88va_pit_out0_changed) |
| 1608 | 1618 | }, |
| 1609 | 1619 | { |
| 1610 | 1620 | /* BEEP frequency setting */ |
| r18156 | r18157 | |
| 1622 | 1632 | }; |
| 1623 | 1633 | |
| 1624 | 1634 | |
| 1625 | | static WRITE_LINE_DEVICE_HANDLER(pc88va_upd765_interrupt) |
| 1635 | WRITE_LINE_MEMBER(pc88va_state::pc88va_upd765_interrupt) |
| 1626 | 1636 | { |
| 1627 | | pc88va_state *drvstate = device->machine().driver_data<pc88va_state>(); |
| 1628 | | if(drvstate->m_fdc_mode) |
| 1629 | | pic8259_ir3_w(device->machine().device( "pic8259_slave"), state); |
| 1637 | if(m_fdc_mode) |
| 1638 | pic8259_ir3_w(machine().device( "pic8259_slave"), state); |
| 1630 | 1639 | else |
| 1631 | | device->machine().device("fdccpu")->execute().set_input_line(0, HOLD_LINE); |
| 1640 | machine().device("fdccpu")->execute().set_input_line(0, HOLD_LINE); |
| 1632 | 1641 | }; |
| 1633 | 1642 | |
| 1634 | 1643 | static const struct upd765_interface pc88va_upd765_interface = |
| 1635 | 1644 | { |
| 1636 | | DEVCB_LINE(pc88va_upd765_interrupt), |
| 1645 | DEVCB_DRIVER_LINE_MEMBER(pc88va_state, pc88va_upd765_interrupt), |
| 1637 | 1646 | DEVCB_NULL, //DRQ, TODO |
| 1638 | 1647 | NULL, |
| 1639 | 1648 | UPD765_RDY_PIN_CONNECTED, |
trunk/src/mess/drivers/palm.c
| r18156 | r18157 | |
| 45 | 45 | virtual void machine_reset(); |
| 46 | 46 | DECLARE_INPUT_CHANGED_MEMBER(pen_check); |
| 47 | 47 | DECLARE_INPUT_CHANGED_MEMBER(button_check); |
| 48 | DECLARE_WRITE8_MEMBER(palm_port_f_out); |
| 49 | DECLARE_READ8_MEMBER(palm_port_c_in); |
| 50 | DECLARE_READ8_MEMBER(palm_port_f_in); |
| 51 | DECLARE_WRITE16_MEMBER(palm_spim_out); |
| 52 | DECLARE_READ16_MEMBER(palm_spim_in); |
| 53 | DECLARE_WRITE8_MEMBER(palm_dac_transition); |
| 48 | 54 | }; |
| 49 | 55 | |
| 50 | 56 | static offs_t palm_dasm_override(device_t &device, char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, int options); |
| r18156 | r18157 | |
| 71 | 77 | mc68328_set_port_d_lines(m_lsi, button_state, (int)(FPTR)param); |
| 72 | 78 | } |
| 73 | 79 | |
| 74 | | static WRITE8_DEVICE_HANDLER( palm_port_f_out ) |
| 80 | WRITE8_MEMBER(palm_state::palm_port_f_out) |
| 75 | 81 | { |
| 76 | | palm_state *state = space.machine().driver_data<palm_state>(); |
| 77 | | state->m_port_f_latch = data; |
| 82 | m_port_f_latch = data; |
| 78 | 83 | } |
| 79 | 84 | |
| 80 | | static READ8_DEVICE_HANDLER( palm_port_c_in ) |
| 85 | READ8_MEMBER(palm_state::palm_port_c_in) |
| 81 | 86 | { |
| 82 | 87 | return 0x10; |
| 83 | 88 | } |
| 84 | 89 | |
| 85 | | static READ8_DEVICE_HANDLER( palm_port_f_in ) |
| 90 | READ8_MEMBER(palm_state::palm_port_f_in) |
| 86 | 91 | { |
| 87 | | palm_state *state = space.machine().driver_data<palm_state>(); |
| 88 | | return state->m_port_f_latch; |
| 92 | return m_port_f_latch; |
| 89 | 93 | } |
| 90 | 94 | |
| 91 | | static WRITE16_DEVICE_HANDLER( palm_spim_out ) |
| 95 | WRITE16_MEMBER(palm_state::palm_spim_out) |
| 92 | 96 | { |
| 93 | | palm_state *state = space.machine().driver_data<palm_state>(); |
| 94 | | state->m_spim_data = data; |
| 97 | m_spim_data = data; |
| 95 | 98 | } |
| 96 | 99 | |
| 97 | | static READ16_DEVICE_HANDLER( palm_spim_in ) |
| 100 | READ16_MEMBER(palm_state::palm_spim_in) |
| 98 | 101 | { |
| 99 | | palm_state *state = space.machine().driver_data<palm_state>(); |
| 100 | | return state->m_spim_data; |
| 102 | return m_spim_data; |
| 101 | 103 | } |
| 102 | 104 | |
| 103 | 105 | static void palm_spim_exchange( device_t *device ) |
| r18156 | r18157 | |
| 157 | 159 | AUDIO HARDWARE |
| 158 | 160 | ***************************************************************************/ |
| 159 | 161 | |
| 160 | | static WRITE8_DEVICE_HANDLER( palm_dac_transition ) |
| 162 | WRITE8_MEMBER(palm_state::palm_dac_transition) |
| 161 | 163 | { |
| 162 | | palm_state *state = space.machine().driver_data<palm_state>(); |
| 163 | | state->m_dac->write_unsigned8(0x7f * data ); |
| 164 | m_dac->write_unsigned8(0x7f * data ); |
| 164 | 165 | } |
| 165 | 166 | |
| 166 | 167 | |
| r18156 | r18157 | |
| 176 | 177 | DEVCB_NULL, // Port C Output |
| 177 | 178 | DEVCB_NULL, // Port D Output |
| 178 | 179 | DEVCB_NULL, // Port E Output |
| 179 | | DEVCB_HANDLER(palm_port_f_out),// Port F Output |
| 180 | DEVCB_DRIVER_MEMBER(palm_state,palm_port_f_out),// Port F Output |
| 180 | 181 | DEVCB_NULL, // Port G Output |
| 181 | 182 | DEVCB_NULL, // Port J Output |
| 182 | 183 | DEVCB_NULL, // Port K Output |
| r18156 | r18157 | |
| 184 | 185 | |
| 185 | 186 | DEVCB_NULL, // Port A Input |
| 186 | 187 | DEVCB_NULL, // Port B Input |
| 187 | | DEVCB_HANDLER(palm_port_c_in),// Port C Input |
| 188 | DEVCB_DRIVER_MEMBER(palm_state,palm_port_c_in),// Port C Input |
| 188 | 189 | DEVCB_NULL, // Port D Input |
| 189 | 190 | DEVCB_NULL, // Port E Input |
| 190 | | DEVCB_HANDLER(palm_port_f_in),// Port F Input |
| 191 | DEVCB_DRIVER_MEMBER(palm_state,palm_port_f_in),// Port F Input |
| 191 | 192 | DEVCB_NULL, // Port G Input |
| 192 | 193 | DEVCB_NULL, // Port J Input |
| 193 | 194 | DEVCB_NULL, // Port K Input |
| 194 | 195 | DEVCB_NULL, // Port M Input |
| 195 | 196 | |
| 196 | | DEVCB_HANDLER(palm_dac_transition), |
| 197 | DEVCB_DRIVER_MEMBER(palm_state,palm_dac_transition), |
| 197 | 198 | |
| 198 | | DEVCB_HANDLER(palm_spim_out), |
| 199 | | DEVCB_HANDLER(palm_spim_in), |
| 199 | DEVCB_DRIVER_MEMBER16(palm_state,palm_spim_out), |
| 200 | DEVCB_DRIVER_MEMBER16(palm_state,palm_spim_in), |
| 200 | 201 | palm_spim_exchange |
| 201 | 202 | }; |
| 202 | 203 | |
trunk/src/mess/drivers/mirage.c
| r18156 | r18157 | |
| 96 | 96 | DECLARE_DRIVER_INIT(mirage); |
| 97 | 97 | virtual void video_start(); |
| 98 | 98 | UINT32 screen_update_mirage(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); |
| 99 | DECLARE_WRITE8_MEMBER(mirage_via_write_porta); |
| 100 | DECLARE_WRITE8_MEMBER(mirage_via_write_portb); |
| 101 | DECLARE_READ8_MEMBER(mirage_via_read_porta); |
| 102 | DECLARE_READ8_MEMBER(mirage_via_read_portb); |
| 103 | DECLARE_READ8_MEMBER(mirage_via_read_ca1); |
| 104 | DECLARE_READ8_MEMBER(mirage_via_read_cb1); |
| 105 | DECLARE_READ8_MEMBER(mirage_via_read_ca2); |
| 106 | DECLARE_READ8_MEMBER(mirage_via_read_cb2); |
| 99 | 107 | }; |
| 100 | 108 | |
| 101 | 109 | const floppy_format_type mirage_state::floppy_formats[] = { |
| r18156 | r18157 | |
| 149 | 157 | ADDRESS_MAP_END |
| 150 | 158 | |
| 151 | 159 | // port A: front panel |
| 152 | | static WRITE8_DEVICE_HANDLER( mirage_via_write_porta ) |
| 160 | WRITE8_MEMBER(mirage_state::mirage_via_write_porta) |
| 153 | 161 | { |
| 154 | 162 | // printf("PORT A: %02x\n", data); |
| 155 | 163 | } |
| r18156 | r18157 | |
| 162 | 170 | // bit 1: OUT upper/lower bank (64k halves) |
| 163 | 171 | // bit 0: OUT bank 0/bank 1 (32k halves) |
| 164 | 172 | |
| 165 | | static WRITE8_DEVICE_HANDLER( mirage_via_write_portb ) |
| 173 | WRITE8_MEMBER(mirage_state::mirage_via_write_portb) |
| 166 | 174 | { |
| 167 | 175 | int bank = 0; |
| 168 | | mirage_state *state = space.machine().driver_data<mirage_state>(); |
| 169 | 176 | |
| 170 | 177 | // handle sound RAM bank switching |
| 171 | 178 | bank = (data & 2) ? (64*1024) : 0; |
| 172 | 179 | bank += (data & 1) ? (32*1024) : 0; |
| 173 | | if (bank != state->last_sndram_bank) |
| 180 | if (bank != last_sndram_bank) |
| 174 | 181 | { |
| 175 | | state->last_sndram_bank = bank; |
| 176 | | state->membank("sndbank")->set_base(state->memregion("es5503")->base() + bank); |
| 182 | last_sndram_bank = bank; |
| 183 | membank("sndbank")->set_base(memregion("es5503")->base() + bank); |
| 177 | 184 | } |
| 178 | 185 | } |
| 179 | 186 | |
| 180 | 187 | // port A: front panel |
| 181 | | static READ8_DEVICE_HANDLER( mirage_via_read_porta ) |
| 188 | READ8_MEMBER(mirage_state::mirage_via_read_porta) |
| 182 | 189 | { |
| 183 | 190 | return 0; |
| 184 | 191 | } |
| r18156 | r18157 | |
| 186 | 193 | // port B: |
| 187 | 194 | // bit 6: IN FDC disk loaded |
| 188 | 195 | // bit 5: IN 5503 sync (?) |
| 189 | | static READ8_DEVICE_HANDLER( mirage_via_read_portb ) |
| 196 | READ8_MEMBER(mirage_state::mirage_via_read_portb) |
| 190 | 197 | { |
| 191 | 198 | return 0x60; |
| 192 | 199 | } |
| 193 | 200 | |
| 194 | 201 | // external sync pulse |
| 195 | | static READ8_DEVICE_HANDLER( mirage_via_read_ca1 ) |
| 202 | READ8_MEMBER(mirage_state::mirage_via_read_ca1) |
| 196 | 203 | { |
| 197 | 204 | return 0; |
| 198 | 205 | } |
| 199 | 206 | |
| 200 | 207 | // keyscan |
| 201 | | static READ8_DEVICE_HANDLER( mirage_via_read_cb1 ) |
| 208 | READ8_MEMBER(mirage_state::mirage_via_read_cb1) |
| 202 | 209 | { |
| 203 | 210 | return 0; |
| 204 | 211 | } |
| 205 | 212 | |
| 206 | 213 | // keyscan |
| 207 | | static READ8_DEVICE_HANDLER( mirage_via_read_ca2 ) |
| 214 | READ8_MEMBER(mirage_state::mirage_via_read_ca2) |
| 208 | 215 | { |
| 209 | 216 | return 0; |
| 210 | 217 | } |
| 211 | 218 | |
| 212 | 219 | |
| 213 | 220 | // keyscan |
| 214 | | static READ8_DEVICE_HANDLER( mirage_via_read_cb2 ) |
| 221 | READ8_MEMBER(mirage_state::mirage_via_read_cb2) |
| 215 | 222 | { |
| 216 | 223 | return 0; |
| 217 | 224 | } |
| 218 | 225 | |
| 219 | 226 | const via6522_interface mirage_via = |
| 220 | 227 | { |
| 221 | | DEVCB_HANDLER(mirage_via_read_porta), |
| 222 | | DEVCB_HANDLER(mirage_via_read_portb), |
| 223 | | DEVCB_HANDLER(mirage_via_read_ca1), |
| 224 | | DEVCB_HANDLER(mirage_via_read_cb1), |
| 225 | | DEVCB_HANDLER(mirage_via_read_ca2), |
| 226 | | DEVCB_HANDLER(mirage_via_read_cb2), |
| 227 | | DEVCB_HANDLER(mirage_via_write_porta), |
| 228 | | DEVCB_HANDLER(mirage_via_write_portb), |
| 228 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_porta), |
| 229 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_portb), |
| 230 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_ca1), |
| 231 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_cb1), |
| 232 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_ca2), |
| 233 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_read_cb2), |
| 234 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_write_porta), |
| 235 | DEVCB_DRIVER_MEMBER(mirage_state,mirage_via_write_portb), |
| 229 | 236 | DEVCB_NULL, |
| 230 | 237 | DEVCB_NULL, |
| 231 | 238 | DEVCB_NULL, |
trunk/src/mess/drivers/mz2500.c
| r18156 | r18157 | |
| 165 | 165 | virtual void palette_init(); |
| 166 | 166 | UINT32 screen_update_mz2500(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 167 | 167 | INTERRUPT_GEN_MEMBER(mz2500_vbl); |
| 168 | DECLARE_READ8_MEMBER(mz2500_wd17xx_r); |
| 169 | DECLARE_WRITE8_MEMBER(mz2500_wd17xx_w); |
| 170 | DECLARE_READ8_MEMBER(mz2500_porta_r); |
| 171 | DECLARE_READ8_MEMBER(mz2500_portb_r); |
| 172 | DECLARE_READ8_MEMBER(mz2500_portc_r); |
| 173 | DECLARE_WRITE8_MEMBER(mz2500_porta_w); |
| 174 | DECLARE_WRITE8_MEMBER(mz2500_portb_w); |
| 175 | DECLARE_WRITE8_MEMBER(mz2500_portc_w); |
| 176 | DECLARE_WRITE8_MEMBER(mz2500_pio1_porta_w); |
| 177 | DECLARE_READ8_MEMBER(mz2500_pio1_porta_r); |
| 178 | DECLARE_READ8_MEMBER(mz2500_pio1_portb_r); |
| 179 | DECLARE_READ8_MEMBER(opn_porta_r); |
| 180 | DECLARE_WRITE8_MEMBER(opn_porta_w); |
| 181 | DECLARE_WRITE_LINE_MEMBER(pit8253_clk0_irq); |
| 182 | DECLARE_WRITE_LINE_MEMBER(mz2500_rtc_alarm_irq); |
| 168 | 183 | }; |
| 169 | 184 | |
| 170 | 185 | |
| r18156 | r18157 | |
| 1251 | 1266 | palette_set_color_rgb(machine(), pal_entry+0x10, pal4bit(m_pal[pal_entry].r), pal4bit(m_pal[pal_entry].g), pal4bit(m_pal[pal_entry].b)); |
| 1252 | 1267 | } |
| 1253 | 1268 | |
| 1254 | | static READ8_DEVICE_HANDLER( mz2500_wd17xx_r ) |
| 1269 | READ8_MEMBER(mz2500_state::mz2500_wd17xx_r) |
| 1255 | 1270 | { |
| 1256 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1257 | | return wd17xx_r(device, space, offset) ^ state->m_fdc_reverse; |
| 1271 | device_t *device = machine().device("mb8877a"); |
| 1272 | return wd17xx_r(device, space, offset) ^ m_fdc_reverse; |
| 1258 | 1273 | } |
| 1259 | 1274 | |
| 1260 | | static WRITE8_DEVICE_HANDLER( mz2500_wd17xx_w ) |
| 1275 | WRITE8_MEMBER(mz2500_state::mz2500_wd17xx_w) |
| 1261 | 1276 | { |
| 1262 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1263 | | wd17xx_w(device, space, offset, data ^ state->m_fdc_reverse); |
| 1277 | device_t *device = machine().device("mb8877a"); |
| 1278 | wd17xx_w(device, space, offset, data ^ m_fdc_reverse); |
| 1264 | 1279 | } |
| 1265 | 1280 | |
| 1266 | 1281 | READ8_MEMBER(mz2500_state::mz2500_bplane_latch_r) |
| r18156 | r18157 | |
| 1522 | 1537 | AM_RANGE(0xcc, 0xcc) AM_READWRITE(rp5c15_8_r, rp5c15_8_w) |
| 1523 | 1538 | AM_RANGE(0xce, 0xce) AM_WRITE(mz2500_dictionary_bank_w) |
| 1524 | 1539 | AM_RANGE(0xcf, 0xcf) AM_WRITE(mz2500_kanji_bank_w) |
| 1525 | | AM_RANGE(0xd8, 0xdb) AM_DEVREADWRITE_LEGACY("mb8877a", mz2500_wd17xx_r, mz2500_wd17xx_w) |
| 1540 | AM_RANGE(0xd8, 0xdb) AM_READWRITE(mz2500_wd17xx_r, mz2500_wd17xx_w) |
| 1526 | 1541 | AM_RANGE(0xdc, 0xdd) AM_WRITE(mz2500_fdc_w) |
| 1527 | 1542 | AM_RANGE(0xde, 0xde) AM_WRITENOP |
| 1528 | 1543 | AM_RANGE(0xe0, 0xe3) AM_DEVREADWRITE("i8255_0", i8255_device, read, write) |
| r18156 | r18157 | |
| 1830 | 1845 | m_cg_clear_flag = 0; |
| 1831 | 1846 | } |
| 1832 | 1847 | |
| 1833 | | static READ8_DEVICE_HANDLER( mz2500_porta_r ) |
| 1848 | READ8_MEMBER(mz2500_state::mz2500_porta_r) |
| 1834 | 1849 | { |
| 1835 | 1850 | logerror("PPI PORTA R\n"); |
| 1836 | 1851 | |
| 1837 | 1852 | return 0xff; |
| 1838 | 1853 | } |
| 1839 | 1854 | |
| 1840 | | static READ8_DEVICE_HANDLER( mz2500_portb_r ) |
| 1855 | READ8_MEMBER(mz2500_state::mz2500_portb_r) |
| 1841 | 1856 | { |
| 1842 | 1857 | UINT8 vblank_bit; |
| 1843 | 1858 | |
| 1844 | | vblank_bit = space.machine().primary_screen->vblank() ? 0 : 1; //Guess: NOBO wants this bit to be high/low |
| 1859 | vblank_bit = machine().primary_screen->vblank() ? 0 : 1; //Guess: NOBO wants this bit to be high/low |
| 1845 | 1860 | |
| 1846 | 1861 | return 0xfe | vblank_bit; |
| 1847 | 1862 | } |
| 1848 | 1863 | |
| 1849 | | static READ8_DEVICE_HANDLER( mz2500_portc_r ) |
| 1864 | READ8_MEMBER(mz2500_state::mz2500_portc_r) |
| 1850 | 1865 | { |
| 1851 | 1866 | logerror("PPI PORTC R\n"); |
| 1852 | 1867 | |
| 1853 | 1868 | return 0xff; |
| 1854 | 1869 | } |
| 1855 | 1870 | |
| 1856 | | static WRITE8_DEVICE_HANDLER( mz2500_porta_w ) |
| 1871 | WRITE8_MEMBER(mz2500_state::mz2500_porta_w) |
| 1857 | 1872 | { |
| 1858 | 1873 | logerror("PPI PORTA W %02x\n",data); |
| 1859 | 1874 | } |
| 1860 | 1875 | |
| 1861 | | static WRITE8_DEVICE_HANDLER( mz2500_portb_w ) |
| 1876 | WRITE8_MEMBER(mz2500_state::mz2500_portb_w) |
| 1862 | 1877 | { |
| 1863 | 1878 | logerror("PPI PORTB W %02x\n",data); |
| 1864 | 1879 | } |
| 1865 | 1880 | |
| 1866 | | static WRITE8_DEVICE_HANDLER( mz2500_portc_w ) |
| 1881 | WRITE8_MEMBER(mz2500_state::mz2500_portc_w) |
| 1867 | 1882 | { |
| 1868 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1869 | 1883 | /* |
| 1870 | 1884 | ---- x--- 0->1 transition = IPL reset |
| 1871 | 1885 | ---- -x-- beeper state |
| r18156 | r18157 | |
| 1873 | 1887 | */ |
| 1874 | 1888 | |
| 1875 | 1889 | /* work RAM reset */ |
| 1876 | | if((state->m_old_portc & 0x02) == 0x00 && (data & 0x02)) |
| 1890 | if((m_old_portc & 0x02) == 0x00 && (data & 0x02)) |
| 1877 | 1891 | { |
| 1878 | | mz2500_reset(state, WRAM_RESET); |
| 1892 | mz2500_reset(this, WRAM_RESET); |
| 1879 | 1893 | /* correct? */ |
| 1880 | | space.machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE); |
| 1894 | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE); |
| 1881 | 1895 | } |
| 1882 | 1896 | |
| 1883 | 1897 | /* bit 2 is speaker */ |
| 1884 | 1898 | |
| 1885 | 1899 | /* IPL reset */ |
| 1886 | | if((state->m_old_portc & 0x08) == 0x00 && (data & 0x08)) |
| 1887 | | mz2500_reset(state, IPL_RESET); |
| 1900 | if((m_old_portc & 0x08) == 0x00 && (data & 0x08)) |
| 1901 | mz2500_reset(this, IPL_RESET); |
| 1888 | 1902 | |
| 1889 | | state->m_old_portc = data; |
| 1903 | m_old_portc = data; |
| 1890 | 1904 | |
| 1891 | | beep_set_state(space.machine().device(BEEPER_TAG),data & 0x04); |
| 1905 | beep_set_state(machine().device(BEEPER_TAG),data & 0x04); |
| 1892 | 1906 | |
| 1893 | 1907 | if(data & ~0x0e) |
| 1894 | 1908 | logerror("PPI PORTC W %02x\n",data & ~0x0e); |
| r18156 | r18157 | |
| 1896 | 1910 | |
| 1897 | 1911 | static I8255_INTERFACE( ppi8255_intf ) |
| 1898 | 1912 | { |
| 1899 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_porta_r), /* Port A read */ |
| 1900 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_porta_w), /* Port A write */ |
| 1901 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_portb_r), /* Port B read */ |
| 1902 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_portb_w), /* Port B write */ |
| 1903 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_portc_r), /* Port C read */ |
| 1904 | | DEVCB_DEVICE_HANDLER("i8255_0", mz2500_portc_w) /* Port C write */ |
| 1913 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_porta_r), /* Port A read */ |
| 1914 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_porta_w), /* Port A write */ |
| 1915 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_portb_r), /* Port B read */ |
| 1916 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_portb_w), /* Port B write */ |
| 1917 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_portc_r), /* Port C read */ |
| 1918 | DEVCB_DRIVER_MEMBER(mz2500_state,mz2500_portc_w) /* Port C write */ |
| 1905 | 1919 | }; |
| 1906 | 1920 | |
| 1907 | | static WRITE8_DEVICE_HANDLER( mz2500_pio1_porta_w ) |
| 1921 | WRITE8_MEMBER(mz2500_state::mz2500_pio1_porta_w) |
| 1908 | 1922 | { |
| 1909 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1910 | 1923 | // printf("%02x\n",data); |
| 1911 | 1924 | |
| 1912 | | if(state->m_prev_col_val != ((data & 0x20) >> 5)) |
| 1925 | if(m_prev_col_val != ((data & 0x20) >> 5)) |
| 1913 | 1926 | { |
| 1914 | | state->m_text_col_size = ((data & 0x20) >> 5); |
| 1915 | | state->m_prev_col_val = state->m_text_col_size; |
| 1916 | | mz2500_reconfigure_screen(space.machine()); |
| 1927 | m_text_col_size = ((data & 0x20) >> 5); |
| 1928 | m_prev_col_val = m_text_col_size; |
| 1929 | mz2500_reconfigure_screen(machine()); |
| 1917 | 1930 | } |
| 1918 | | state->m_key_mux = data & 0x1f; |
| 1931 | m_key_mux = data & 0x1f; |
| 1919 | 1932 | } |
| 1920 | 1933 | |
| 1921 | 1934 | |
| 1922 | | static READ8_DEVICE_HANDLER( mz2500_pio1_porta_r ) |
| 1935 | READ8_MEMBER(mz2500_state::mz2500_pio1_porta_r) |
| 1923 | 1936 | { |
| 1924 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1925 | 1937 | static const char *const keynames[] = { "KEY0", "KEY1", "KEY2", "KEY3", |
| 1926 | 1938 | "KEY4", "KEY5", "KEY6", "KEY7", |
| 1927 | 1939 | "KEY8", "KEY9", "KEYA", "KEYB", |
| 1928 | 1940 | "KEYC", "KEYD", "UNUSED", "UNUSED" }; |
| 1929 | 1941 | |
| 1930 | | if(((state->m_key_mux & 0x10) == 0x00) || ((state->m_key_mux & 0x0f) == 0x0f)) //status read |
| 1942 | if(((m_key_mux & 0x10) == 0x00) || ((m_key_mux & 0x0f) == 0x0f)) //status read |
| 1931 | 1943 | { |
| 1932 | 1944 | int res,i; |
| 1933 | 1945 | |
| 1934 | 1946 | res = 0xff; |
| 1935 | 1947 | for(i=0;i<0xe;i++) |
| 1936 | | res &= space.machine().root_device().ioport(keynames[i])->read(); |
| 1948 | res &= machine().root_device().ioport(keynames[i])->read(); |
| 1937 | 1949 | |
| 1938 | | state->m_pio_latchb = res; |
| 1950 | m_pio_latchb = res; |
| 1939 | 1951 | |
| 1940 | 1952 | return res; |
| 1941 | 1953 | } |
| 1942 | 1954 | |
| 1943 | | state->m_pio_latchb = space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read(); |
| 1955 | m_pio_latchb = machine().root_device().ioport(keynames[m_key_mux & 0xf])->read(); |
| 1944 | 1956 | |
| 1945 | | return space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read(); |
| 1957 | return machine().root_device().ioport(keynames[m_key_mux & 0xf])->read(); |
| 1946 | 1958 | } |
| 1947 | 1959 | |
| 1948 | 1960 | #if 0 |
| 1949 | | static READ8_DEVICE_HANDLER( mz2500_pio1_portb_r ) |
| 1961 | READ8_MEMBER(mz2500_state::mz2500_pio1_portb_r) |
| 1950 | 1962 | { |
| 1951 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1952 | | return state->m_pio_latchb; |
| 1963 | return m_pio_latchb; |
| 1953 | 1964 | } |
| 1954 | 1965 | #endif |
| 1955 | 1966 | |
| 1956 | 1967 | static Z80PIO_INTERFACE( mz2500_pio1_intf ) |
| 1957 | 1968 | { |
| 1958 | 1969 | DEVCB_NULL, |
| 1959 | | DEVCB_DEVICE_HANDLER( "z80pio_1", mz2500_pio1_porta_r ), |
| 1960 | | DEVCB_DEVICE_HANDLER( "z80pio_1", mz2500_pio1_porta_w ), |
| 1970 | DEVCB_DRIVER_MEMBER( mz2500_state,mz2500_pio1_porta_r ), |
| 1971 | DEVCB_DRIVER_MEMBER( mz2500_state,mz2500_pio1_porta_w ), |
| 1961 | 1972 | DEVCB_NULL, |
| 1962 | | DEVCB_DEVICE_HANDLER( "z80pio_1", mz2500_pio1_porta_r ), |
| 1973 | DEVCB_DRIVER_MEMBER( mz2500_state,mz2500_pio1_porta_r ), |
| 1963 | 1974 | DEVCB_NULL, |
| 1964 | 1975 | DEVCB_NULL |
| 1965 | 1976 | }; |
| 1966 | 1977 | |
| 1967 | 1978 | |
| 1968 | | static READ8_DEVICE_HANDLER( opn_porta_r ) |
| 1979 | READ8_MEMBER(mz2500_state::opn_porta_r) |
| 1969 | 1980 | { |
| 1970 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1971 | | return state->m_ym_porta; |
| 1981 | return m_ym_porta; |
| 1972 | 1982 | } |
| 1973 | 1983 | |
| 1974 | | static WRITE8_DEVICE_HANDLER( opn_porta_w ) |
| 1984 | WRITE8_MEMBER(mz2500_state::opn_porta_w) |
| 1975 | 1985 | { |
| 1976 | | mz2500_state *state = space.machine().driver_data<mz2500_state>(); |
| 1977 | 1986 | /* |
| 1978 | 1987 | ---- x--- mouse select |
| 1979 | 1988 | ---- -x-- palette bit (16/4096 colors) |
| 1980 | 1989 | ---- --x- floppy reverse bit (controls wd17xx bits in command registers) |
| 1981 | 1990 | */ |
| 1982 | 1991 | |
| 1983 | | state->m_fdc_reverse = (data & 2) ? 0x00 : 0xff; |
| 1984 | | state->m_pal_select = (data & 4) ? 1 : 0; |
| 1992 | m_fdc_reverse = (data & 2) ? 0x00 : 0xff; |
| 1993 | m_pal_select = (data & 4) ? 1 : 0; |
| 1985 | 1994 | |
| 1986 | | state->m_ym_porta = data; |
| 1995 | m_ym_porta = data; |
| 1987 | 1996 | } |
| 1988 | 1997 | |
| 1989 | 1998 | static const ym2203_interface ym2203_interface_1 = |
| r18156 | r18157 | |
| 1991 | 2000 | { |
| 1992 | 2001 | AY8910_LEGACY_OUTPUT, |
| 1993 | 2002 | AY8910_DEFAULT_LOADS, |
| 1994 | | DEVCB_DEVICE_HANDLER("ym", opn_porta_r), // read A |
| 2003 | DEVCB_DRIVER_MEMBER(mz2500_state,opn_porta_r), // read A |
| 1995 | 2004 | DEVCB_INPUT_PORT("DSW1"), // read B |
| 1996 | | DEVCB_DEVICE_HANDLER("ym", opn_porta_w), // write A |
| 2005 | DEVCB_DRIVER_MEMBER(mz2500_state,opn_porta_w), // write A |
| 1997 | 2006 | DEVCB_NULL // write B |
| 1998 | 2007 | }, |
| 1999 | 2008 | DEVCB_NULL |
| r18156 | r18157 | |
| 2040 | 2049 | |
| 2041 | 2050 | /* PIT8253 Interface */ |
| 2042 | 2051 | |
| 2043 | | static WRITE_LINE_DEVICE_HANDLER( pit8253_clk0_irq ) |
| 2052 | WRITE_LINE_MEMBER(mz2500_state::pit8253_clk0_irq) |
| 2044 | 2053 | { |
| 2045 | | mz2500_state *drvstate = device->machine().driver_data<mz2500_state>(); |
| 2046 | | if(drvstate->m_irq_mask[1]/* && state & 1*/) |
| 2047 | | device->machine().device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE,drvstate->m_irq_vector[1]); |
| 2054 | if(m_irq_mask[1]/* && state & 1*/) |
| 2055 | machine().device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE,m_irq_vector[1]); |
| 2048 | 2056 | } |
| 2049 | 2057 | |
| 2050 | 2058 | static const struct pit8253_config mz2500_pit8253_intf = |
| r18156 | r18157 | |
| 2053 | 2061 | { |
| 2054 | 2062 | 31250, |
| 2055 | 2063 | DEVCB_NULL, |
| 2056 | | DEVCB_DEVICE_LINE("pit", pit8253_clk0_irq) |
| 2064 | DEVCB_DRIVER_LINE_MEMBER(mz2500_state,pit8253_clk0_irq) |
| 2057 | 2065 | }, |
| 2058 | 2066 | { |
| 2059 | 2067 | 0, |
| r18156 | r18157 | |
| 2068 | 2076 | } |
| 2069 | 2077 | }; |
| 2070 | 2078 | |
| 2071 | | static WRITE_LINE_DEVICE_HANDLER( mz2500_rtc_alarm_irq ) |
| 2079 | WRITE_LINE_MEMBER(mz2500_state::mz2500_rtc_alarm_irq) |
| 2072 | 2080 | { |
| 2073 | | //mz2500_state *drvstate = device->machine().driver_data<mz2500_state>(); |
| 2074 | 2081 | /* TODO: doesn't work yet */ |
| 2075 | | // if(drvstate->m_irq_mask[3] && state & 1) |
| 2076 | | // device.device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE,drvstate->m_irq_vector[3]); |
| 2082 | // if(m_irq_mask[3] && state & 1) |
| 2083 | // device.device("maincpu")->execute().set_input_line_and_vector(0, HOLD_LINE,drvm_irq_vector[3]); |
| 2077 | 2084 | } |
| 2078 | 2085 | |
| 2079 | 2086 | static RP5C15_INTERFACE( rtc_intf ) |
| 2080 | 2087 | { |
| 2081 | | DEVCB_DEVICE_LINE(RP5C15_TAG, mz2500_rtc_alarm_irq), |
| 2088 | DEVCB_DRIVER_LINE_MEMBER(mz2500_state,mz2500_rtc_alarm_irq), |
| 2082 | 2089 | DEVCB_NULL |
| 2083 | 2090 | }; |
| 2084 | 2091 | |
trunk/src/mess/drivers/vtech1.c
| r18156 | r18157 | |
| 199 | 199 | DECLARE_WRITE8_MEMBER(vtech1_video_bank_w); |
| 200 | 200 | DECLARE_DRIVER_INIT(vtech1h); |
| 201 | 201 | DECLARE_DRIVER_INIT(vtech1); |
| 202 | DECLARE_READ8_MEMBER(vtech1_printer_r); |
| 203 | DECLARE_WRITE8_MEMBER(vtech1_strobe_w); |
| 204 | DECLARE_READ8_MEMBER(vtech1_mc6847_videoram_r); |
| 202 | 205 | }; |
| 203 | 206 | |
| 204 | 207 | |
| r18156 | r18157 | |
| 480 | 483 | PRINTER |
| 481 | 484 | ***************************************************************************/ |
| 482 | 485 | |
| 483 | | static READ8_DEVICE_HANDLER( vtech1_printer_r ) |
| 486 | READ8_MEMBER(vtech1_state::vtech1_printer_r) |
| 484 | 487 | { |
| 485 | | centronics_device *centronics = space.machine().device<centronics_device>("centronics"); |
| 488 | centronics_device *centronics = machine().device<centronics_device>("centronics"); |
| 486 | 489 | return 0xfe | centronics->busy_r(); |
| 487 | 490 | } |
| 488 | 491 | |
| 489 | 492 | /* TODO: figure out how this really works */ |
| 490 | | static WRITE8_DEVICE_HANDLER( vtech1_strobe_w ) |
| 493 | WRITE8_MEMBER(vtech1_state::vtech1_strobe_w) |
| 491 | 494 | { |
| 492 | | centronics_device *centronics = space.machine().device<centronics_device>("centronics"); |
| 495 | centronics_device *centronics = machine().device<centronics_device>("centronics"); |
| 493 | 496 | centronics->strobe_w(TRUE); |
| 494 | 497 | centronics->strobe_w(FALSE); |
| 495 | 498 | } |
| r18156 | r18157 | |
| 611 | 614 | VIDEO EMULATION |
| 612 | 615 | ***************************************************************************/ |
| 613 | 616 | |
| 614 | | static READ8_DEVICE_HANDLER( vtech1_mc6847_videoram_r ) |
| 617 | READ8_MEMBER(vtech1_state::vtech1_mc6847_videoram_r) |
| 615 | 618 | { |
| 616 | | vtech1_state *vtech1 = space.machine().driver_data<vtech1_state>(); |
| 617 | 619 | if (offset == ~0) return 0xff; |
| 618 | | vtech1->m_mc6847->inv_w(BIT(vtech1->m_videoram[offset], 6)); |
| 619 | | vtech1->m_mc6847->as_w(BIT(vtech1->m_videoram[offset], 7)); |
| 620 | m_mc6847->inv_w(BIT(m_videoram[offset], 6)); |
| 621 | m_mc6847->as_w(BIT(m_videoram[offset], 7)); |
| 620 | 622 | |
| 621 | | return vtech1->m_videoram[offset]; |
| 623 | return m_videoram[offset]; |
| 622 | 624 | } |
| 623 | 625 | |
| 624 | 626 | |
| r18156 | r18157 | |
| 733 | 735 | |
| 734 | 736 | static ADDRESS_MAP_START( vtech1_io, AS_IO, 8, vtech1_state ) |
| 735 | 737 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 736 | | AM_RANGE(0x00, 0x00) AM_DEVREAD_LEGACY("centronics", vtech1_printer_r) |
| 737 | | AM_RANGE(0x0d, 0x0d) AM_DEVWRITE_LEGACY("centronics", vtech1_strobe_w) |
| 738 | AM_RANGE(0x00, 0x00) AM_READ(vtech1_printer_r) |
| 739 | AM_RANGE(0x0d, 0x0d) AM_WRITE(vtech1_strobe_w) |
| 738 | 740 | AM_RANGE(0x0e, 0x0e) AM_DEVWRITE("centronics", centronics_device, write) |
| 739 | 741 | AM_RANGE(0x10, 0x1f) AM_READWRITE(vtech1_fdc_r, vtech1_fdc_w) |
| 740 | 742 | AM_RANGE(0x20, 0x2f) AM_READ(vtech1_joystick_r) |
| r18156 | r18157 | |
| 912 | 914 | static const mc6847_interface vtech1_mc6847_bw_intf = |
| 913 | 915 | { |
| 914 | 916 | "screen", |
| 915 | | DEVCB_HANDLER(vtech1_mc6847_videoram_r), |
| 917 | DEVCB_DRIVER_MEMBER(vtech1_state,vtech1_mc6847_videoram_r), |
| 916 | 918 | DEVCB_NULL, /* horz sync */ |
| 917 | 919 | DEVCB_CPU_INPUT_LINE("maincpu", 0), /* field sync */ |
| 918 | 920 | |
| r18156 | r18157 | |
| 932 | 934 | static const mc6847_interface vtech1_mc6847_intf = |
| 933 | 935 | { |
| 934 | 936 | "screen", |
| 935 | | DEVCB_HANDLER(vtech1_mc6847_videoram_r), |
| 937 | DEVCB_DRIVER_MEMBER(vtech1_state,vtech1_mc6847_videoram_r), |
| 936 | 938 | DEVCB_NULL, /* horz sync */ |
| 937 | 939 | DEVCB_CPU_INPUT_LINE("maincpu", 0), /* field sync */ |
| 938 | 940 | |
| r18156 | r18157 | |
| 952 | 954 | static const mc6847_interface vtech1_shrg_mc6847_intf = |
| 953 | 955 | { |
| 954 | 956 | "screen", |
| 955 | | DEVCB_HANDLER(vtech1_mc6847_videoram_r), |
| 957 | DEVCB_DRIVER_MEMBER(vtech1_state,vtech1_mc6847_videoram_r), |
| 956 | 958 | DEVCB_NULL, /* horz sync */ |
| 957 | 959 | DEVCB_CPU_INPUT_LINE("maincpu", 0), /* field sync */ |
| 958 | 960 | |
trunk/src/mess/drivers/vk100.c
| r18156 | r18157 | |
| 193 | 193 | virtual void machine_reset(); |
| 194 | 194 | virtual void video_start(); |
| 195 | 195 | TIMER_CALLBACK_MEMBER(execute_vg); |
| 196 | DECLARE_WRITE_LINE_MEMBER(crtc_vsync); |
| 197 | DECLARE_WRITE_LINE_MEMBER(i8251_rxrdy_int); |
| 198 | DECLARE_WRITE_LINE_MEMBER(i8251_txrdy_int); |
| 199 | DECLARE_WRITE_LINE_MEMBER(i8251_rts); |
| 196 | 200 | }; |
| 197 | 201 | |
| 198 | 202 | // vram access functions: |
| r18156 | r18157 | |
| 873 | 877 | m_TXDivisor = 6336; |
| 874 | 878 | } |
| 875 | 879 | |
| 876 | | static WRITE_LINE_DEVICE_HANDLER(crtc_vsync) |
| 880 | WRITE_LINE_MEMBER(vk100_state::crtc_vsync) |
| 877 | 881 | { |
| 878 | | vk100_state *m_state = device->machine().driver_data<vk100_state>(); |
| 879 | | m_state->m_maincpu->set_input_line(I8085_RST75_LINE, state? ASSERT_LINE : CLEAR_LINE); |
| 880 | | m_state->m_vsync = state; |
| 882 | m_maincpu->set_input_line(I8085_RST75_LINE, state? ASSERT_LINE : CLEAR_LINE); |
| 883 | m_vsync = state; |
| 881 | 884 | } |
| 882 | 885 | |
| 883 | | static WRITE_LINE_DEVICE_HANDLER(i8251_rxrdy_int) |
| 886 | WRITE_LINE_MEMBER(vk100_state::i8251_rxrdy_int) |
| 884 | 887 | { |
| 885 | | vk100_state *m_state = device->machine().driver_data<vk100_state>(); |
| 886 | | m_state->m_maincpu->set_input_line(I8085_RST65_LINE, state?ASSERT_LINE:CLEAR_LINE); |
| 888 | m_maincpu->set_input_line(I8085_RST65_LINE, state?ASSERT_LINE:CLEAR_LINE); |
| 887 | 889 | } |
| 888 | 890 | |
| 889 | | static WRITE_LINE_DEVICE_HANDLER(i8251_txrdy_int) |
| 891 | WRITE_LINE_MEMBER(vk100_state::i8251_txrdy_int) |
| 890 | 892 | { |
| 891 | | vk100_state *m_state = device->machine().driver_data<vk100_state>(); |
| 892 | | m_state->m_maincpu->set_input_line(I8085_RST55_LINE, state?ASSERT_LINE:CLEAR_LINE); |
| 893 | m_maincpu->set_input_line(I8085_RST55_LINE, state?ASSERT_LINE:CLEAR_LINE); |
| 893 | 894 | } |
| 894 | 895 | |
| 895 | | static WRITE_LINE_DEVICE_HANDLER(i8251_rts) |
| 896 | WRITE_LINE_MEMBER(vk100_state::i8251_rts) |
| 896 | 897 | { |
| 897 | | vk100_state *m_state = device->machine().driver_data<vk100_state>(); |
| 898 | 898 | logerror("callback: RTS state changed to %d\n", state); |
| 899 | 899 | // TODO: only change this during loopback mode! |
| 900 | | m_state->m_ACTS = state; |
| 900 | m_ACTS = state; |
| 901 | 901 | } |
| 902 | 902 | |
| 903 | 903 | DRIVER_INIT_MEMBER(vk100_state,vk100) |
| r18156 | r18157 | |
| 957 | 957 | DEVCB_NULL, |
| 958 | 958 | DEVCB_NULL, |
| 959 | 959 | DEVCB_NULL, |
| 960 | | DEVCB_LINE(crtc_vsync), |
| 960 | DEVCB_DRIVER_LINE_MEMBER(vk100_state, crtc_vsync), |
| 961 | 961 | NULL |
| 962 | 962 | }; |
| 963 | 963 | |
| r18156 | r18157 | |
| 969 | 969 | //TODO: DEVCB_DRIVER_LINE_MEMBER(vk100_state, i8251_tx), // out_txd_cb |
| 970 | 970 | DEVCB_NULL, // in_dsr_cb |
| 971 | 971 | DEVCB_NULL, // out_dtr_cb |
| 972 | | DEVCB_LINE(i8251_rts), // out_rts_cb |
| 973 | | DEVCB_LINE(i8251_rxrdy_int), // out_rxrdy_cb |
| 974 | | DEVCB_LINE(i8251_txrdy_int), // out_txrdy_cb |
| 972 | DEVCB_DRIVER_LINE_MEMBER(vk100_state, i8251_rts), // out_rts_cb |
| 973 | DEVCB_DRIVER_LINE_MEMBER(vk100_state, i8251_rxrdy_int), // out_rxrdy_cb |
| 974 | DEVCB_DRIVER_LINE_MEMBER(vk100_state, i8251_txrdy_int), // out_txrdy_cb |
| 975 | 975 | DEVCB_NULL, // out_txempty_cb |
| 976 | 976 | DEVCB_NULL // out_syndet_cb |
| 977 | 977 | }; |
trunk/src/mess/drivers/px4.c
| r18156 | r18157 | |
| 172 | 172 | TIMER_CALLBACK_MEMBER(receive_data); |
| 173 | 173 | TIMER_DEVICE_CALLBACK_MEMBER(frc_tick); |
| 174 | 174 | TIMER_DEVICE_CALLBACK_MEMBER(upd7508_1sec_callback); |
| 175 | void px4_sio_txd(device_t *device,int state); |
| 176 | int px4_sio_rxd(device_t *device); |
| 177 | int px4_sio_pin(device_t *device); |
| 178 | void px4_sio_pout(device_t *device,int state); |
| 179 | void px4_rs232c_txd(device_t *device,int state); |
| 180 | int px4_rs232c_rxd(device_t *device); |
| 181 | void px4_rs232c_rts(device_t *device,int state); |
| 182 | int px4_rs232c_cts(device_t *device); |
| 183 | int px4_rs232c_dsr(device_t *device); |
| 184 | void px4_rs232c_dtr(device_t *device,int state); |
| 185 | int px4_rs232c_dcd(device_t *device); |
| 175 | 186 | }; |
| 176 | 187 | |
| 177 | 188 | |
| r18156 | r18157 | |
| 181 | 192 | |
| 182 | 193 | /* The floppy is connected to this port */ |
| 183 | 194 | |
| 184 | | static WRITE_LINE_DEVICE_HANDLER( px4_sio_txd ) |
| 195 | void px4_state::px4_sio_txd(device_t *device,int state) |
| 185 | 196 | { |
| 186 | 197 | if (VERBOSE) |
| 187 | 198 | logerror("px4_sio_txd: %d\n", state); |
| r18156 | r18157 | |
| 190 | 201 | tf20_txs_w(device, state); |
| 191 | 202 | } |
| 192 | 203 | |
| 193 | | static READ_LINE_DEVICE_HANDLER( px4_sio_rxd ) |
| 204 | int px4_state::px4_sio_rxd(device_t *device) |
| 194 | 205 | { |
| 195 | 206 | if (VERBOSE) |
| 196 | 207 | logerror("px4_sio_rxd\n"); |
| r18156 | r18157 | |
| 201 | 212 | return ASSERT_LINE; |
| 202 | 213 | } |
| 203 | 214 | |
| 204 | | static READ_LINE_DEVICE_HANDLER( px4_sio_pin ) |
| 215 | int px4_state::px4_sio_pin(device_t *device) |
| 205 | 216 | { |
| 206 | 217 | if (VERBOSE) |
| 207 | 218 | logerror("px4_sio_pin\n"); |
| r18156 | r18157 | |
| 212 | 223 | return ASSERT_LINE; |
| 213 | 224 | } |
| 214 | 225 | |
| 215 | | static WRITE_LINE_DEVICE_HANDLER( px4_sio_pout ) |
| 226 | void px4_state::px4_sio_pout(device_t *device,int state) |
| 216 | 227 | { |
| 217 | 228 | if (VERBOSE) |
| 218 | 229 | logerror("px4_sio_pout: %d\n", state); |
| r18156 | r18157 | |
| 228 | 239 | |
| 229 | 240 | /* Currently nothing is connected to this port */ |
| 230 | 241 | |
| 231 | | static WRITE_LINE_DEVICE_HANDLER( px4_rs232c_txd ) |
| 242 | void px4_state::px4_rs232c_txd(device_t *device,int state) |
| 232 | 243 | { |
| 233 | 244 | if (VERBOSE) |
| 234 | 245 | logerror("px4_rs232c_txd: %d\n", state); |
| 235 | 246 | } |
| 236 | 247 | |
| 237 | 248 | #ifdef UNUSED_FUNCTION |
| 238 | | static READ_LINE_DEVICE_HANDLER( px4_rs232c_rxd ) |
| 249 | int px4_state::px4_rs232c_rxd(device_t *device) |
| 239 | 250 | { |
| 240 | 251 | if (VERBOSE) |
| 241 | 252 | logerror("px4_rs232c_rxd\n"); |
| r18156 | r18157 | |
| 243 | 254 | } |
| 244 | 255 | #endif |
| 245 | 256 | |
| 246 | | static WRITE_LINE_DEVICE_HANDLER( px4_rs232c_rts ) |
| 257 | void px4_state::px4_rs232c_rts(device_t *device,int state) |
| 247 | 258 | { |
| 248 | 259 | if (VERBOSE) |
| 249 | 260 | logerror("px4_rs232c_rts: %d\n", state); |
| 250 | 261 | } |
| 251 | 262 | |
| 252 | | static READ_LINE_DEVICE_HANDLER( px4_rs232c_cts ) |
| 263 | int px4_state::px4_rs232c_cts(device_t *device) |
| 253 | 264 | { |
| 254 | 265 | if (VERBOSE) |
| 255 | 266 | logerror("px4_rs232c_cts\n"); |
| r18156 | r18157 | |
| 257 | 268 | return ASSERT_LINE; |
| 258 | 269 | } |
| 259 | 270 | |
| 260 | | static READ_LINE_DEVICE_HANDLER( px4_rs232c_dsr ) |
| 271 | int px4_state::px4_rs232c_dsr(device_t *device) |
| 261 | 272 | { |
| 262 | 273 | if (VERBOSE) |
| 263 | 274 | logerror("px4_rs232c_dsr\n"); |
| r18156 | r18157 | |
| 265 | 276 | return ASSERT_LINE; |
| 266 | 277 | } |
| 267 | 278 | |
| 268 | | static WRITE_LINE_DEVICE_HANDLER( px4_rs232c_dtr ) |
| 279 | void px4_state::px4_rs232c_dtr(device_t *device,int state) |
| 269 | 280 | { |
| 270 | 281 | if (VERBOSE) |
| 271 | 282 | logerror("px4_rs232c_dtr: %d\n", state); |
| 272 | 283 | } |
| 273 | 284 | |
| 274 | | static READ_LINE_DEVICE_HANDLER( px4_rs232c_dcd ) |
| 285 | int px4_state::px4_rs232c_dcd(device_t *device) |
| 275 | 286 | { |
| 276 | 287 | if (VERBOSE) |
| 277 | 288 | logerror("px4_rs232c_dcd\n"); |
trunk/src/mess/drivers/osbexec.c
| r18156 | r18157 | |
| 111 | 111 | virtual void machine_reset(); |
| 112 | 112 | virtual void palette_init(); |
| 113 | 113 | TIMER_CALLBACK_MEMBER(osbexec_video_callback); |
| 114 | DECLARE_READ8_MEMBER(osbexec_pia0_a_r); |
| 115 | DECLARE_WRITE8_MEMBER(osbexec_pia0_a_w); |
| 116 | DECLARE_READ8_MEMBER(osbexec_pia0_b_r); |
| 117 | DECLARE_WRITE8_MEMBER(osbexec_pia0_b_w); |
| 118 | DECLARE_WRITE_LINE_MEMBER(osbexec_pia0_ca2_w); |
| 119 | DECLARE_WRITE_LINE_MEMBER(osbexec_pia0_cb2_w); |
| 120 | DECLARE_WRITE_LINE_MEMBER(osbexec_pia0_irq); |
| 121 | DECLARE_WRITE_LINE_MEMBER(osbexec_pia1_irq); |
| 114 | 122 | }; |
| 115 | 123 | |
| 116 | 124 | |
| r18156 | r18157 | |
| 348 | 356 | CB2 - 60/50 (?) |
| 349 | 357 | */ |
| 350 | 358 | |
| 351 | | static READ8_DEVICE_HANDLER( osbexec_pia0_a_r ) |
| 359 | READ8_MEMBER(osbexec_state::osbexec_pia0_a_r) |
| 352 | 360 | { |
| 353 | | osbexec_state *state = space.machine().driver_data<osbexec_state>(); |
| 354 | 361 | |
| 355 | | return state->m_pia0_porta; |
| 362 | return m_pia0_porta; |
| 356 | 363 | } |
| 357 | 364 | |
| 358 | 365 | |
| 359 | | static WRITE8_DEVICE_HANDLER( osbexec_pia0_a_w ) |
| 366 | WRITE8_MEMBER(osbexec_state::osbexec_pia0_a_w) |
| 360 | 367 | { |
| 361 | | osbexec_state *state = space.machine().driver_data<osbexec_state>(); |
| 362 | 368 | |
| 363 | 369 | logerror("osbexec_pia0_a_w: %02x\n", data ); |
| 364 | 370 | |
| 365 | | state->m_pia0_porta = data; |
| 371 | m_pia0_porta = data; |
| 366 | 372 | |
| 367 | | state->set_banks(space.machine()); |
| 373 | set_banks(machine()); |
| 368 | 374 | } |
| 369 | 375 | |
| 370 | 376 | |
| 371 | | static READ8_DEVICE_HANDLER( osbexec_pia0_b_r ) |
| 377 | READ8_MEMBER(osbexec_state::osbexec_pia0_b_r) |
| 372 | 378 | { |
| 373 | | osbexec_state *state = space.machine().driver_data<osbexec_state>(); |
| 374 | 379 | |
| 375 | | return state->m_pia0_portb; |
| 380 | return m_pia0_portb; |
| 376 | 381 | } |
| 377 | 382 | |
| 378 | 383 | |
| 379 | | static WRITE8_DEVICE_HANDLER( osbexec_pia0_b_w ) |
| 384 | WRITE8_MEMBER(osbexec_state::osbexec_pia0_b_w) |
| 380 | 385 | { |
| 381 | | osbexec_state *state = space.machine().driver_data<osbexec_state>(); |
| 382 | 386 | |
| 383 | | state->m_pia0_portb = data; |
| 387 | m_pia0_portb = data; |
| 384 | 388 | |
| 385 | | speaker_level_w( state->m_speaker, ( data & 0x08 ) ? 0 : 1 ); |
| 389 | speaker_level_w( m_speaker, ( data & 0x08 ) ? 0 : 1 ); |
| 386 | 390 | |
| 387 | 391 | switch ( data & 0x06 ) |
| 388 | 392 | { |
| 389 | 393 | case 0x02: |
| 390 | | wd17xx_set_drive( state->m_mb8877, 1 ); |
| 394 | wd17xx_set_drive( m_mb8877, 1 ); |
| 391 | 395 | break; |
| 392 | 396 | case 0x04: |
| 393 | | wd17xx_set_drive( state->m_mb8877, 0 ); |
| 397 | wd17xx_set_drive( m_mb8877, 0 ); |
| 394 | 398 | break; |
| 395 | 399 | } |
| 396 | 400 | |
| 397 | | wd17xx_dden_w( state->m_mb8877, ( data & 0x01 ) ? 1 : 0 ); |
| 401 | wd17xx_dden_w( m_mb8877, ( data & 0x01 ) ? 1 : 0 ); |
| 398 | 402 | } |
| 399 | 403 | |
| 400 | 404 | |
| 401 | | static WRITE_LINE_DEVICE_HANDLER( osbexec_pia0_ca2_w ) |
| 405 | WRITE_LINE_MEMBER(osbexec_state::osbexec_pia0_ca2_w) |
| 402 | 406 | { |
| 403 | 407 | logerror("osbexec_pia0_ca2_w: state = %d\n", state); |
| 404 | 408 | } |
| 405 | 409 | |
| 406 | 410 | |
| 407 | | static WRITE_LINE_DEVICE_HANDLER( osbexec_pia0_cb2_w ) |
| 411 | WRITE_LINE_MEMBER(osbexec_state::osbexec_pia0_cb2_w) |
| 408 | 412 | { |
| 409 | | osbexec_state *st = device->machine().driver_data<osbexec_state>(); |
| 410 | 413 | |
| 411 | | st->m_pia0_cb2 = state; |
| 414 | m_pia0_cb2 = state; |
| 412 | 415 | } |
| 413 | 416 | |
| 414 | 417 | |
| 415 | | static WRITE_LINE_DEVICE_HANDLER( osbexec_pia0_irq ) |
| 418 | WRITE_LINE_MEMBER(osbexec_state::osbexec_pia0_irq) |
| 416 | 419 | { |
| 417 | | osbexec_state *st = device->machine().driver_data<osbexec_state>(); |
| 418 | 420 | |
| 419 | | st->m_pia0_irq_state = state; |
| 420 | | st->update_irq_state(device->machine()); |
| 421 | m_pia0_irq_state = state; |
| 422 | update_irq_state(machine()); |
| 421 | 423 | } |
| 422 | 424 | |
| 423 | 425 | |
| 424 | 426 | static const pia6821_interface osbexec_pia0_config = |
| 425 | 427 | { |
| 426 | | DEVCB_HANDLER( osbexec_pia0_a_r ), /* in_a_func */ /* port A - banking */ |
| 427 | | DEVCB_HANDLER( osbexec_pia0_b_r), /* in_b_func */ /* modem / speaker */ |
| 428 | DEVCB_DRIVER_MEMBER(osbexec_state, osbexec_pia0_a_r ), /* in_a_func */ /* port A - banking */ |
| 429 | DEVCB_DRIVER_MEMBER(osbexec_state, osbexec_pia0_b_r), /* in_b_func */ /* modem / speaker */ |
| 428 | 430 | DEVCB_NULL, /* in_ca1_func */ /* DMA IRQ */ |
| 429 | 431 | DEVCB_NULL, /* in_cb1_func */ /* Vblank (rtc irq) */ |
| 430 | 432 | DEVCB_NULL, /* in_ca2_func */ |
| 431 | 433 | DEVCB_NULL, /* in_cb2_func */ |
| 432 | | DEVCB_HANDLER( osbexec_pia0_a_w ), /* out_a_func */ /* port A - banking */ |
| 433 | | DEVCB_HANDLER( osbexec_pia0_b_w ), /* out_b_func */ /* modem / speaker */ |
| 434 | | DEVCB_LINE( osbexec_pia0_ca2_w ), /* out_ca2_func */ /* Keyboard strobe */ |
| 435 | | DEVCB_LINE( osbexec_pia0_cb2_w ), /* out_cb2_func */ /* 60/50 */ |
| 436 | | DEVCB_LINE( osbexec_pia0_irq ), /* irq_a_func */ /* IRQ */ |
| 437 | | DEVCB_LINE( osbexec_pia0_irq ) /* irq_b_func */ /* IRQ */ |
| 434 | DEVCB_DRIVER_MEMBER(osbexec_state, osbexec_pia0_a_w ), /* out_a_func */ /* port A - banking */ |
| 435 | DEVCB_DRIVER_MEMBER(osbexec_state, osbexec_pia0_b_w ), /* out_b_func */ /* modem / speaker */ |
| 436 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia0_ca2_w ), /* out_ca2_func */ /* Keyboard strobe */ |
| 437 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia0_cb2_w ), /* out_cb2_func */ /* 60/50 */ |
| 438 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia0_irq ), /* irq_a_func */ /* IRQ */ |
| 439 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia0_irq ) /* irq_b_func */ /* IRQ */ |
| 438 | 440 | }; |
| 439 | 441 | |
| 440 | 442 | |
| 441 | | static WRITE_LINE_DEVICE_HANDLER( osbexec_pia1_irq ) |
| 443 | WRITE_LINE_MEMBER(osbexec_state::osbexec_pia1_irq) |
| 442 | 444 | { |
| 443 | | osbexec_state *st = device->machine().driver_data<osbexec_state>(); |
| 444 | 445 | |
| 445 | | st->m_pia1_irq_state = state; |
| 446 | | st->update_irq_state(device->machine()); |
| 446 | m_pia1_irq_state = state; |
| 447 | update_irq_state(machine()); |
| 447 | 448 | } |
| 448 | 449 | |
| 449 | 450 | |
| r18156 | r18157 | |
| 459 | 460 | DEVCB_NULL, /* out_b_func */ |
| 460 | 461 | DEVCB_NULL, /* out_ca2_func */ |
| 461 | 462 | DEVCB_NULL, /* out_cb2_func */ |
| 462 | | DEVCB_LINE( osbexec_pia1_irq ), /* irq_a_func */ |
| 463 | | DEVCB_LINE( osbexec_pia1_irq ) /* irq_b_func */ |
| 463 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia1_irq ), /* irq_a_func */ |
| 464 | DEVCB_DRIVER_LINE_MEMBER(osbexec_state, osbexec_pia1_irq ) /* irq_b_func */ |
| 464 | 465 | }; |
| 465 | 466 | |
| 466 | 467 | |
trunk/src/mess/drivers/spc1000.c
| r18156 | r18157 | |
| 39 | 39 | DECLARE_READ8_MEMBER(spc1000_video_ram_r); |
| 40 | 40 | DECLARE_READ8_MEMBER(spc1000_keyboard_r); |
| 41 | 41 | virtual void machine_reset(); |
| 42 | DECLARE_WRITE8_MEMBER(spc1000_gmode_w); |
| 43 | DECLARE_READ8_MEMBER(spc1000_gmode_r); |
| 44 | DECLARE_READ8_MEMBER(spc1000_mc6847_videoram_r); |
| 42 | 45 | }; |
| 43 | 46 | |
| 44 | 47 | |
| r18156 | r18157 | |
| 98 | 101 | return ioport(keynames[offset])->read(); |
| 99 | 102 | } |
| 100 | 103 | |
| 101 | | static WRITE8_DEVICE_HANDLER(spc1000_gmode_w) |
| 104 | WRITE8_MEMBER(spc1000_state::spc1000_gmode_w) |
| 102 | 105 | { |
| 103 | | spc1000_state *state = space.machine().driver_data<spc1000_state>(); |
| 104 | | state->m_GMODE = data; |
| 106 | m_GMODE = data; |
| 105 | 107 | |
| 106 | | // state->m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA |
| 108 | // m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA |
| 107 | 109 | // [PS2,PS1] is used to set screen 0/1 pages |
| 108 | | state->m_vdg->gm1_w(BIT(data, 1)); |
| 109 | | state->m_vdg->gm0_w(BIT(data, 2)); |
| 110 | | state->m_vdg->ag_w(BIT(data, 3)); |
| 111 | | state->m_vdg->css_w(BIT(data, 7)); |
| 110 | m_vdg->gm1_w(BIT(data, 1)); |
| 111 | m_vdg->gm0_w(BIT(data, 2)); |
| 112 | m_vdg->ag_w(BIT(data, 3)); |
| 113 | m_vdg->css_w(BIT(data, 7)); |
| 112 | 114 | } |
| 113 | 115 | |
| 114 | | static READ8_DEVICE_HANDLER(spc1000_gmode_r) |
| 116 | READ8_MEMBER(spc1000_state::spc1000_gmode_r) |
| 115 | 117 | { |
| 116 | | spc1000_state *state = space.machine().driver_data<spc1000_state>(); |
| 117 | | return state->m_GMODE; |
| 118 | return m_GMODE; |
| 118 | 119 | } |
| 119 | 120 | |
| 120 | 121 | static ADDRESS_MAP_START( spc1000_io , AS_IO, 8, spc1000_state ) |
| 121 | 122 | ADDRESS_MAP_UNMAP_HIGH |
| 122 | 123 | AM_RANGE(0x0000, 0x1fff) AM_READWRITE(spc1000_video_ram_r, spc1000_video_ram_w) |
| 123 | | AM_RANGE(0x2000, 0x3fff) AM_DEVREADWRITE_LEGACY("mc6847", spc1000_gmode_r, spc1000_gmode_w) |
| 124 | AM_RANGE(0x2000, 0x3fff) AM_READWRITE(spc1000_gmode_r, spc1000_gmode_w) |
| 124 | 125 | AM_RANGE(0x8000, 0x8009) AM_READ(spc1000_keyboard_r) |
| 125 | 126 | AM_RANGE(0xA000, 0xA000) AM_READWRITE(spc1000_iplk_r, spc1000_iplk_w) |
| 126 | 127 | AM_RANGE(0x4000, 0x4000) AM_DEVWRITE_LEGACY("ay8910", ay8910_address_w) |
| r18156 | r18157 | |
| 242 | 243 | m_IPLK = 1; |
| 243 | 244 | } |
| 244 | 245 | |
| 245 | | static READ8_DEVICE_HANDLER( spc1000_mc6847_videoram_r ) |
| 246 | READ8_MEMBER(spc1000_state::spc1000_mc6847_videoram_r) |
| 246 | 247 | { |
| 247 | | spc1000_state *state = space.machine().driver_data<spc1000_state>(); |
| 248 | 248 | if (offset == ~0) return 0xff; |
| 249 | 249 | |
| 250 | | // state->m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA |
| 250 | // m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA |
| 251 | 251 | // [PS2,PS1] is used to set screen 0/1 pages |
| 252 | | if ( !BIT(state->m_GMODE, 3) ) { // text mode (~A/G set to A) |
| 253 | | unsigned int page = (BIT(state->m_GMODE, 5) << 1) | BIT(state->m_GMODE, 4); |
| 254 | | state->m_vdg->inv_w(BIT(state->m_video_ram[offset+page*0x200+0x800], 0)); |
| 255 | | state->m_vdg->css_w(BIT(state->m_video_ram[offset+page*0x200+0x800], 1)); |
| 256 | | state->m_vdg->as_w(BIT(state->m_video_ram[offset+page*0x200+0x800], 2)); |
| 257 | | state->m_vdg->intext_w(BIT(state->m_video_ram[offset+page*0x200+0x800], 3)); |
| 258 | | return state->m_video_ram[offset+page*0x200]; |
| 252 | if ( !BIT(m_GMODE, 3) ) { // text mode (~A/G set to A) |
| 253 | unsigned int page = (BIT(m_GMODE, 5) << 1) | BIT(m_GMODE, 4); |
| 254 | m_vdg->inv_w(BIT(m_video_ram[offset+page*0x200+0x800], 0)); |
| 255 | m_vdg->css_w(BIT(m_video_ram[offset+page*0x200+0x800], 1)); |
| 256 | m_vdg->as_w(BIT(m_video_ram[offset+page*0x200+0x800], 2)); |
| 257 | m_vdg->intext_w(BIT(m_video_ram[offset+page*0x200+0x800], 3)); |
| 258 | return m_video_ram[offset+page*0x200]; |
| 259 | 259 | } else { // graphics mode: uses full 6KB of VRAM |
| 260 | | return state->m_video_ram[offset]; |
| 260 | return m_video_ram[offset]; |
| 261 | 261 | } |
| 262 | 262 | } |
| 263 | 263 | |
| r18156 | r18157 | |
| 280 | 280 | static const mc6847_interface spc1000_mc6847_intf = |
| 281 | 281 | { |
| 282 | 282 | "screen", |
| 283 | | DEVCB_HANDLER(spc1000_mc6847_videoram_r), // data fetch |
| 283 | DEVCB_DRIVER_MEMBER(spc1000_state,spc1000_mc6847_videoram_r), // data fetch |
| 284 | 284 | DEVCB_NULL, |
| 285 | 285 | DEVCB_NULL, |
| 286 | 286 | |
trunk/src/mess/drivers/pk8000.c
| r18156 | r18157 | |
| 31 | 31 | virtual void video_start(); |
| 32 | 32 | UINT32 screen_update_pk8000(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 33 | 33 | INTERRUPT_GEN_MEMBER(pk8000_interrupt); |
| 34 | DECLARE_WRITE8_MEMBER(pk8000_80_porta_w); |
| 35 | DECLARE_READ8_MEMBER(pk8000_80_portb_r); |
| 36 | DECLARE_WRITE8_MEMBER(pk8000_80_portc_w); |
| 37 | DECLARE_READ8_MEMBER(pk8000_84_porta_r); |
| 38 | DECLARE_WRITE8_MEMBER(pk8000_84_porta_w); |
| 39 | DECLARE_WRITE8_MEMBER(pk8000_84_portc_w); |
| 34 | 40 | }; |
| 35 | 41 | |
| 36 | 42 | |
| r18156 | r18157 | |
| 100 | 106 | break; |
| 101 | 107 | } |
| 102 | 108 | } |
| 103 | | static WRITE8_DEVICE_HANDLER(pk8000_80_porta_w) |
| 109 | WRITE8_MEMBER(pk8000_state::pk8000_80_porta_w) |
| 104 | 110 | { |
| 105 | | pk8000_set_bank(space.machine(),data); |
| 111 | pk8000_set_bank(machine(),data); |
| 106 | 112 | } |
| 107 | 113 | |
| 108 | | static READ8_DEVICE_HANDLER(pk8000_80_portb_r) |
| 114 | READ8_MEMBER(pk8000_state::pk8000_80_portb_r) |
| 109 | 115 | { |
| 110 | | pk8000_state *state = space.machine().driver_data<pk8000_state>(); |
| 111 | 116 | static const char *const keynames[] = { "LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" }; |
| 112 | | if(state->m_keyboard_line>9) { |
| 117 | if(m_keyboard_line>9) { |
| 113 | 118 | return 0xff; |
| 114 | 119 | } |
| 115 | | return space.machine().root_device().ioport(keynames[state->m_keyboard_line])->read(); |
| 120 | return machine().root_device().ioport(keynames[m_keyboard_line])->read(); |
| 116 | 121 | } |
| 117 | 122 | |
| 118 | | static WRITE8_DEVICE_HANDLER(pk8000_80_portc_w) |
| 123 | WRITE8_MEMBER(pk8000_state::pk8000_80_portc_w) |
| 119 | 124 | { |
| 120 | | pk8000_state *state = space.machine().driver_data<pk8000_state>(); |
| 121 | | state->m_keyboard_line = data & 0x0f; |
| 125 | m_keyboard_line = data & 0x0f; |
| 122 | 126 | |
| 123 | | speaker_level_w(space.machine().device(SPEAKER_TAG), BIT(data,7)); |
| 127 | speaker_level_w(machine().device(SPEAKER_TAG), BIT(data,7)); |
| 124 | 128 | |
| 125 | | cassette_device_image(space.machine())->change_state( |
| 129 | cassette_device_image(machine())->change_state( |
| 126 | 130 | (BIT(data,4)) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, |
| 127 | 131 | CASSETTE_MASK_MOTOR); |
| 128 | | cassette_device_image(space.machine())->output((BIT(data,6)) ? +1.0 : 0.0); |
| 132 | cassette_device_image(machine())->output((BIT(data,6)) ? +1.0 : 0.0); |
| 129 | 133 | } |
| 130 | 134 | |
| 131 | 135 | static I8255_INTERFACE( pk8000_ppi8255_interface_1 ) |
| 132 | 136 | { |
| 133 | 137 | DEVCB_NULL, |
| 134 | | DEVCB_HANDLER(pk8000_80_porta_w), |
| 135 | | DEVCB_HANDLER(pk8000_80_portb_r), |
| 138 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_80_porta_w), |
| 139 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_80_portb_r), |
| 136 | 140 | DEVCB_NULL, |
| 137 | 141 | DEVCB_NULL, |
| 138 | | DEVCB_HANDLER(pk8000_80_portc_w) |
| 142 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_80_portc_w) |
| 139 | 143 | }; |
| 140 | 144 | |
| 141 | | static READ8_DEVICE_HANDLER(pk8000_84_porta_r) |
| 145 | READ8_MEMBER(pk8000_state::pk8000_84_porta_r) |
| 142 | 146 | { |
| 143 | 147 | return pk8000_video_mode; |
| 144 | 148 | } |
| 145 | 149 | |
| 146 | | static WRITE8_DEVICE_HANDLER(pk8000_84_porta_w) |
| 150 | WRITE8_MEMBER(pk8000_state::pk8000_84_porta_w) |
| 147 | 151 | { |
| 148 | 152 | pk8000_video_mode = data; |
| 149 | 153 | } |
| 150 | 154 | |
| 151 | | static WRITE8_DEVICE_HANDLER(pk8000_84_portc_w) |
| 155 | WRITE8_MEMBER(pk8000_state::pk8000_84_portc_w) |
| 152 | 156 | { |
| 153 | 157 | pk8000_video_enable = BIT(data,4); |
| 154 | 158 | } |
| 155 | 159 | static I8255_INTERFACE( pk8000_ppi8255_interface_2 ) |
| 156 | 160 | { |
| 157 | | DEVCB_HANDLER(pk8000_84_porta_r), |
| 158 | | DEVCB_HANDLER(pk8000_84_porta_w), |
| 161 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_porta_r), |
| 162 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_porta_w), |
| 159 | 163 | DEVCB_NULL, |
| 160 | 164 | DEVCB_NULL, |
| 161 | 165 | DEVCB_NULL, |
| 162 | | DEVCB_HANDLER(pk8000_84_portc_w) |
| 166 | DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_portc_w) |
| 163 | 167 | }; |
| 164 | 168 | |
| 165 | 169 | READ8_MEMBER(pk8000_state::pk8000_joy_1_r) |
trunk/src/mess/drivers/pc8801.c
| r18156 | r18157 | |
| 454 | 454 | INTERRUPT_GEN_MEMBER(pc8801_vrtc_irq); |
| 455 | 455 | TIMER_CALLBACK_MEMBER(pc8801fd_upd765_tc_to_zero); |
| 456 | 456 | TIMER_DEVICE_CALLBACK_MEMBER(pc8801_rtc_irq); |
| 457 | DECLARE_READ8_MEMBER(cpu_8255_c_r); |
| 458 | DECLARE_WRITE8_MEMBER(cpu_8255_c_w); |
| 459 | DECLARE_READ8_MEMBER(fdc_8255_c_r); |
| 460 | DECLARE_WRITE8_MEMBER(fdc_8255_c_w); |
| 461 | DECLARE_WRITE_LINE_MEMBER(pic_int_w); |
| 462 | DECLARE_WRITE_LINE_MEMBER(pic_enlg_w); |
| 463 | DECLARE_READ8_MEMBER(opn_porta_r); |
| 464 | DECLARE_READ8_MEMBER(opn_portb_r); |
| 457 | 465 | }; |
| 458 | 466 | |
| 459 | 467 | |
| r18156 | r18157 | |
| 1820 | 1828 | AM_RANGE(0xfc, 0xff) AM_DEVREADWRITE("d8255_master", i8255_device, read, write) |
| 1821 | 1829 | ADDRESS_MAP_END |
| 1822 | 1830 | |
| 1823 | | static READ8_DEVICE_HANDLER( cpu_8255_c_r ) |
| 1831 | READ8_MEMBER(pc8801_state::cpu_8255_c_r) |
| 1824 | 1832 | { |
| 1825 | | pc8801_state *state = space.machine().driver_data<pc8801_state>(); |
| 1826 | | // space.machine().scheduler().synchronize(); // force resync |
| 1833 | // machine().scheduler().synchronize(); // force resync |
| 1827 | 1834 | |
| 1828 | | return state->m_i8255_1_pc >> 4; |
| 1835 | return m_i8255_1_pc >> 4; |
| 1829 | 1836 | } |
| 1830 | 1837 | |
| 1831 | | static WRITE8_DEVICE_HANDLER( cpu_8255_c_w ) |
| 1838 | WRITE8_MEMBER(pc8801_state::cpu_8255_c_w) |
| 1832 | 1839 | { |
| 1833 | | pc8801_state *state = space.machine().driver_data<pc8801_state>(); |
| 1834 | | // space.machine().scheduler().synchronize(); // force resync |
| 1840 | // machine().scheduler().synchronize(); // force resync |
| 1835 | 1841 | |
| 1836 | | state->m_i8255_0_pc = data; |
| 1842 | m_i8255_0_pc = data; |
| 1837 | 1843 | } |
| 1838 | 1844 | |
| 1839 | 1845 | |
| r18156 | r18157 | |
| 1843 | 1849 | DEVCB_NULL, // Port A write |
| 1844 | 1850 | DEVCB_DEVICE_MEMBER("d8255_slave", i8255_device, pa_r), // Port B read |
| 1845 | 1851 | DEVCB_NULL, // Port B write |
| 1846 | | DEVCB_HANDLER(cpu_8255_c_r), // Port C read |
| 1847 | | DEVCB_HANDLER(cpu_8255_c_w) // Port C write |
| 1852 | DEVCB_DRIVER_MEMBER(pc8801_state,cpu_8255_c_r), // Port C read |
| 1853 | DEVCB_DRIVER_MEMBER(pc8801_state,cpu_8255_c_w) // Port C write |
| 1848 | 1854 | }; |
| 1849 | 1855 | |
| 1850 | | static READ8_DEVICE_HANDLER( fdc_8255_c_r ) |
| 1856 | READ8_MEMBER(pc8801_state::fdc_8255_c_r) |
| 1851 | 1857 | { |
| 1852 | | pc8801_state *state = space.machine().driver_data<pc8801_state>(); |
| 1853 | | // space.machine().scheduler().synchronize(); // force resync |
| 1858 | // machine().scheduler().synchronize(); // force resync |
| 1854 | 1859 | |
| 1855 | | return state->m_i8255_0_pc >> 4; |
| 1860 | return m_i8255_0_pc >> 4; |
| 1856 | 1861 | } |
| 1857 | 1862 | |
| 1858 | | static WRITE8_DEVICE_HANDLER( fdc_8255_c_w ) |
| 1863 | WRITE8_MEMBER(pc8801_state::fdc_8255_c_w) |
| 1859 | 1864 | { |
| 1860 | | pc8801_state *state = space.machine().driver_data<pc8801_state>(); |
| 1861 | | // space.machine().scheduler().synchronize(); // force resync |
| 1865 | // machine().scheduler().synchronize(); // force resync |
| 1862 | 1866 | |
| 1863 | | state->m_i8255_1_pc = data; |
| 1867 | m_i8255_1_pc = data; |
| 1864 | 1868 | } |
| 1865 | 1869 | |
| 1866 | 1870 | static I8255A_INTERFACE( slave_fdd_intf ) |
| r18156 | r18157 | |
| 1869 | 1873 | DEVCB_NULL, // Port A write |
| 1870 | 1874 | DEVCB_DEVICE_MEMBER("d8255_master", i8255_device, pa_r), // Port B read |
| 1871 | 1875 | DEVCB_NULL, // Port B write |
| 1872 | | DEVCB_HANDLER(fdc_8255_c_r), // Port C read |
| 1873 | | DEVCB_HANDLER(fdc_8255_c_w) // Port C write |
| 1876 | DEVCB_DRIVER_MEMBER(pc8801_state,fdc_8255_c_r), // Port C read |
| 1877 | DEVCB_DRIVER_MEMBER(pc8801_state,fdc_8255_c_w) // Port C write |
| 1874 | 1878 | }; |
| 1875 | 1879 | |
| 1876 | 1880 | |
| r18156 | r18157 | |
| 2301 | 2305 | } |
| 2302 | 2306 | } |
| 2303 | 2307 | |
| 2304 | | static WRITE_LINE_DEVICE_HANDLER( pic_int_w ) |
| 2308 | WRITE_LINE_MEMBER(pc8801_state::pic_int_w) |
| 2305 | 2309 | { |
| 2310 | device_t *device = machine().device("maincpu"); |
| 2306 | 2311 | // if (state == ASSERT_LINE) |
| 2307 | 2312 | // { |
| 2308 | 2313 | // } |
| 2309 | 2314 | } |
| 2310 | 2315 | |
| 2311 | | static WRITE_LINE_DEVICE_HANDLER( pic_enlg_w ) |
| 2316 | WRITE_LINE_MEMBER(pc8801_state::pic_enlg_w) |
| 2312 | 2317 | { |
| 2318 | device_t *device = machine().device("maincpu"); |
| 2313 | 2319 | //if (state == CLEAR_LINE) |
| 2314 | 2320 | //{ |
| 2315 | 2321 | //} |
| r18156 | r18157 | |
| 2317 | 2323 | |
| 2318 | 2324 | static I8214_INTERFACE( pic_intf ) |
| 2319 | 2325 | { |
| 2320 | | DEVCB_DEVICE_LINE("maincpu", pic_int_w), |
| 2321 | | DEVCB_DEVICE_LINE("maincpu", pic_enlg_w) |
| 2326 | DEVCB_DRIVER_LINE_MEMBER(pc8801_state,pic_int_w), |
| 2327 | DEVCB_DRIVER_LINE_MEMBER(pc8801_state,pic_enlg_w) |
| 2322 | 2328 | }; |
| 2323 | 2329 | |
| 2324 | 2330 | static IRQ_CALLBACK( pc8801_irq_callback ) |
| r18156 | r18157 | |
| 2568 | 2574 | |
| 2569 | 2575 | /* YM2203 Interface */ |
| 2570 | 2576 | |
| 2571 | | static READ8_DEVICE_HANDLER( opn_porta_r ) |
| 2577 | READ8_MEMBER(pc8801_state::opn_porta_r) |
| 2572 | 2578 | { |
| 2573 | | pc8801_state *state = space.machine().driver_data<pc8801_state>(); |
| 2574 | 2579 | |
| 2575 | | if(space.machine().root_device().ioport("BOARD_CONFIG")->read() & 2) |
| 2580 | if(machine().root_device().ioport("BOARD_CONFIG")->read() & 2) |
| 2576 | 2581 | { |
| 2577 | 2582 | UINT8 shift,res; |
| 2578 | 2583 | |
| 2579 | | shift = (state->m_mouse.phase & 1) ? 0 : 4; |
| 2580 | | res = (state->m_mouse.phase & 2) ? state->m_mouse.y : state->m_mouse.x; |
| 2584 | shift = (m_mouse.phase & 1) ? 0 : 4; |
| 2585 | res = (m_mouse.phase & 2) ? m_mouse.y : m_mouse.x; |
| 2581 | 2586 | |
| 2582 | | // printf("%d\n",state->m_mouse.phase); |
| 2587 | // printf("%d\n",m_mouse.phase); |
| 2583 | 2588 | |
| 2584 | 2589 | return ((res >> shift) & 0x0f) | 0xf0; |
| 2585 | 2590 | } |
| 2586 | 2591 | |
| 2587 | | return space.machine().root_device().ioport("OPN_PA")->read(); |
| 2592 | return machine().root_device().ioport("OPN_PA")->read(); |
| 2588 | 2593 | } |
| 2589 | | static READ8_DEVICE_HANDLER( opn_portb_r ) { return device->machine().root_device().ioport("OPN_PB")->read(); } |
| 2594 | READ8_MEMBER(pc8801_state::opn_portb_r){ return machine().root_device().ioport("OPN_PB")->read(); } |
| 2590 | 2595 | |
| 2591 | 2596 | static const ym2203_interface pc88_ym2203_intf = |
| 2592 | 2597 | { |
| 2593 | 2598 | { |
| 2594 | 2599 | AY8910_LEGACY_OUTPUT, |
| 2595 | 2600 | AY8910_DEFAULT_LOADS, |
| 2596 | | DEVCB_HANDLER(opn_porta_r), |
| 2597 | | DEVCB_HANDLER(opn_portb_r), |
| 2601 | DEVCB_DRIVER_MEMBER(pc8801_state,opn_porta_r), |
| 2602 | DEVCB_DRIVER_MEMBER(pc8801_state,opn_portb_r), |
| 2598 | 2603 | DEVCB_NULL, |
| 2599 | 2604 | DEVCB_NULL |
| 2600 | 2605 | }, |
| r18156 | r18157 | |
| 2606 | 2611 | { |
| 2607 | 2612 | AY8910_LEGACY_OUTPUT | AY8910_SINGLE_OUTPUT, |
| 2608 | 2613 | AY8910_DEFAULT_LOADS, |
| 2609 | | DEVCB_HANDLER(opn_porta_r), |
| 2610 | | DEVCB_HANDLER(opn_portb_r), |
| 2614 | DEVCB_DRIVER_MEMBER(pc8801_state,opn_porta_r), |
| 2615 | DEVCB_DRIVER_MEMBER(pc8801_state,opn_portb_r), |
| 2611 | 2616 | DEVCB_NULL, |
| 2612 | 2617 | DEVCB_NULL |
| 2613 | 2618 | }, |
trunk/src/mess/drivers/a2600.c
| r18156 | r18157 | |
| 115 | 115 | DECLARE_MACHINE_START(a2600); |
| 116 | 116 | DECLARE_MACHINE_START(a2600p); |
| 117 | 117 | TIMER_CALLBACK_MEMBER(modeDPC_timer_callback); |
| 118 | DECLARE_WRITE8_MEMBER(switch_A_w); |
| 119 | DECLARE_READ8_MEMBER(switch_A_r); |
| 120 | DECLARE_WRITE8_MEMBER(switch_B_w); |
| 121 | DECLARE_WRITE_LINE_MEMBER(irq_callback); |
| 122 | DECLARE_READ8_MEMBER(riot_input_port_8_r); |
| 118 | 123 | }; |
| 119 | 124 | |
| 120 | 125 | |
| r18156 | r18157 | |
| 1175 | 1180 | AM_RANGE(0x1000, 0x1FFF) AM_ROMBANK("bank1") |
| 1176 | 1181 | ADDRESS_MAP_END |
| 1177 | 1182 | |
| 1178 | | static WRITE8_DEVICE_HANDLER(switch_A_w) |
| 1183 | WRITE8_MEMBER(a2600_state::switch_A_w) |
| 1179 | 1184 | { |
| 1180 | | a2600_state *state = space.machine().driver_data<a2600_state>(); |
| 1181 | | running_machine &machine = space.machine(); |
| 1182 | | |
| 1183 | 1185 | /* Left controller port */ |
| 1184 | | if ( machine.root_device().ioport("CONTROLLERS")->read() / CATEGORY_SELECT == 0x03 ) |
| 1186 | if ( machine().root_device().ioport("CONTROLLERS")->read() / CATEGORY_SELECT == 0x03 ) |
| 1185 | 1187 | { |
| 1186 | | state->m_keypad_left_column = data / 16; |
| 1188 | m_keypad_left_column = data / 16; |
| 1187 | 1189 | } |
| 1188 | 1190 | |
| 1189 | 1191 | /* Right controller port */ |
| 1190 | | switch( machine.root_device().ioport("CONTROLLERS")->read() % CATEGORY_SELECT ) |
| 1192 | switch( machine().root_device().ioport("CONTROLLERS")->read() % CATEGORY_SELECT ) |
| 1191 | 1193 | { |
| 1192 | 1194 | case 0x03: /* Keypad */ |
| 1193 | | state->m_keypad_right_column = data & 0x0F; |
| 1195 | m_keypad_right_column = data & 0x0F; |
| 1194 | 1196 | break; |
| 1195 | 1197 | case 0x0a: /* KidVid voice module */ |
| 1196 | | machine.device<cassette_image_device>(CASSETTE_TAG)->change_state(( data & 0x02 ) ? (cassette_state)CASSETTE_MOTOR_DISABLED : (cassette_state)(CASSETTE_MOTOR_ENABLED | CASSETTE_PLAY), (cassette_state)CASSETTE_MOTOR_DISABLED ); |
| 1198 | machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(( data & 0x02 ) ? (cassette_state)CASSETTE_MOTOR_DISABLED : (cassette_state)(CASSETTE_MOTOR_ENABLED | CASSETTE_PLAY), (cassette_state)CASSETTE_MOTOR_DISABLED ); |
| 1197 | 1199 | break; |
| 1198 | 1200 | } |
| 1199 | 1201 | } |
| 1200 | 1202 | |
| 1201 | | static READ8_DEVICE_HANDLER( switch_A_r ) |
| 1203 | READ8_MEMBER(a2600_state::switch_A_r) |
| 1202 | 1204 | { |
| 1203 | 1205 | static const UINT8 driving_lookup[4] = { 0x00, 0x02, 0x03, 0x01 }; |
| 1204 | | running_machine &machine = space.machine(); |
| 1205 | 1206 | UINT8 val = 0; |
| 1206 | 1207 | |
| 1207 | 1208 | /* Left controller port PINs 1-4 ( 4321 ) */ |
| 1208 | | switch( machine.root_device().ioport("CONTROLLERS")->read() / CATEGORY_SELECT ) |
| 1209 | switch( machine().root_device().ioport("CONTROLLERS")->read() / CATEGORY_SELECT ) |
| 1209 | 1210 | { |
| 1210 | 1211 | case 0x00: /* Joystick */ |
| 1211 | 1212 | case 0x05: /* Joystick w/Boostergrip */ |
| 1212 | | val |= machine.root_device().ioport("SWA_JOY")->read() & 0xF0; |
| 1213 | val |= machine().root_device().ioport("SWA_JOY")->read() & 0xF0; |
| 1213 | 1214 | break; |
| 1214 | 1215 | case 0x01: /* Paddle */ |
| 1215 | | val |= machine.root_device().ioport("SWA_PAD")->read() & 0xF0; |
| 1216 | val |= machine().root_device().ioport("SWA_PAD")->read() & 0xF0; |
| 1216 | 1217 | break; |
| 1217 | 1218 | case 0x02: /* Driving */ |
| 1218 | 1219 | val |= 0xC0; |
| 1219 | | val |= ( driving_lookup[ ( machine.root_device().ioport("WHEEL_L")->read() & 0x18 ) >> 3 ] << 4 ); |
| 1220 | val |= ( driving_lookup[ ( machine().root_device().ioport("WHEEL_L")->read() & 0x18 ) >> 3 ] << 4 ); |
| 1220 | 1221 | break; |
| 1221 | 1222 | case 0x06: /* Trakball CX-22 */ |
| 1222 | 1223 | case 0x07: /* Trakball CX-80 / ST mouse */ |
| r18156 | r18157 | |
| 1227 | 1228 | } |
| 1228 | 1229 | |
| 1229 | 1230 | /* Right controller port PINs 1-4 ( 4321 ) */ |
| 1230 | | switch( machine.root_device().ioport("CONTROLLERS")->read() % CATEGORY_SELECT ) |
| 1231 | switch( machine().root_device().ioport("CONTROLLERS")->read() % CATEGORY_SELECT ) |
| 1231 | 1232 | { |
| 1232 | 1233 | case 0x00: /* Joystick */ |
| 1233 | 1234 | case 0x05: /* Joystick w/Boostergrip */ |
| 1234 | | val |= machine.root_device().ioport("SWA_JOY")->read() & 0x0F; |
| 1235 | val |= machine().root_device().ioport("SWA_JOY")->read() & 0x0F; |
| 1235 | 1236 | break; |
| 1236 | 1237 | case 0x01: /* Paddle */ |
| 1237 | | val |= machine.root_device().ioport("SWA_PAD")->read() & 0x0F; |
| 1238 | val |= machine().root_device().ioport("SWA_PAD")->read() & 0x0F; |
| 1238 | 1239 | break; |
| 1239 | 1240 | case 0x02: /* Driving */ |
| 1240 | 1241 | val |= 0x0C; |
| 1241 | | val |= ( driving_lookup[ ( machine.root_device().ioport("WHEEL_R")->read() & 0x18 ) >> 3 ] ); |
| 1242 | val |= ( driving_lookup[ ( machine().root_device().ioport("WHEEL_R")->read() & 0x18 ) >> 3 ] ); |
| 1242 | 1243 | break; |
| 1243 | 1244 | case 0x06: /* Trakball CX-22 */ |
| 1244 | 1245 | case 0x07: /* Trakball CX-80 / ST mouse */ |
| r18156 | r18157 | |
| 1251 | 1252 | return val; |
| 1252 | 1253 | } |
| 1253 | 1254 | |
| 1254 | | static WRITE8_DEVICE_HANDLER(switch_B_w ) |
| 1255 | WRITE8_MEMBER(a2600_state::switch_B_w) |
| 1255 | 1256 | { |
| 1256 | 1257 | } |
| 1257 | 1258 | |
| 1258 | | static WRITE_LINE_DEVICE_HANDLER( irq_callback ) |
| 1259 | WRITE_LINE_MEMBER(a2600_state::irq_callback) |
| 1259 | 1260 | { |
| 1260 | 1261 | } |
| 1261 | 1262 | |
| 1262 | | static READ8_DEVICE_HANDLER( riot_input_port_8_r ) |
| 1263 | READ8_MEMBER(a2600_state::riot_input_port_8_r) |
| 1263 | 1264 | { |
| 1264 | | return space.machine().root_device().ioport("SWB")->read(); |
| 1265 | return machine().root_device().ioport("SWB")->read(); |
| 1265 | 1266 | } |
| 1266 | 1267 | |
| 1267 | 1268 | static const riot6532_interface r6532_interface = |
| 1268 | 1269 | { |
| 1269 | | DEVCB_HANDLER(switch_A_r), |
| 1270 | | DEVCB_HANDLER(riot_input_port_8_r), |
| 1271 | | DEVCB_HANDLER(switch_A_w), |
| 1272 | | DEVCB_HANDLER(switch_B_w), |
| 1273 | | DEVCB_LINE(irq_callback) |
| 1270 | DEVCB_DRIVER_MEMBER(a2600_state,switch_A_r), |
| 1271 | DEVCB_DRIVER_MEMBER(a2600_state,riot_input_port_8_r), |
| 1272 | DEVCB_DRIVER_MEMBER(a2600_state,switch_A_w), |
| 1273 | DEVCB_DRIVER_MEMBER(a2600_state,switch_B_w), |
| 1274 | DEVCB_DRIVER_LINE_MEMBER(a2600_state, irq_callback) |
| 1274 | 1275 | }; |
| 1275 | 1276 | |
| 1276 | 1277 | |
trunk/src/mess/drivers/atari400.c
| r18156 | r18157 | |
| 239 | 239 | DECLARE_DRIVER_INIT(a800xl); |
| 240 | 240 | DECLARE_DRIVER_INIT(a600xl); |
| 241 | 241 | virtual void palette_init(); |
| 242 | DECLARE_WRITE8_MEMBER(a1200xl_pia_pb_w); |
| 243 | DECLARE_WRITE8_MEMBER(a800xl_pia_pb_w); |
| 244 | DECLARE_WRITE8_MEMBER(xegs_pia_pb_w); |
| 242 | 245 | }; |
| 243 | 246 | |
| 244 | 247 | /************************************************************** |
| r18156 | r18157 | |
| 905 | 908 | * |
| 906 | 909 | **************************************************************/ |
| 907 | 910 | |
| 908 | | static WRITE8_DEVICE_HANDLER(a1200xl_pia_pb_w) { a1200xl_mmu(device->machine(), data); } |
| 909 | | static WRITE8_DEVICE_HANDLER(a800xl_pia_pb_w) |
| 911 | WRITE8_MEMBER(a400_state::a1200xl_pia_pb_w){ device_t *device = machine().device("pia"); a1200xl_mmu(device->machine(), data); } |
| 912 | WRITE8_MEMBER(a400_state::a800xl_pia_pb_w) |
| 910 | 913 | { |
| 914 | device_t *device = machine().device("pia"); |
| 911 | 915 | if (downcast<pia6821_device *>(device)->port_b_z_mask() != 0xff) |
| 912 | | a800xl_mmu(space.machine(), data); |
| 916 | a800xl_mmu(machine(), data); |
| 913 | 917 | } |
| 914 | 918 | |
| 915 | | static WRITE8_DEVICE_HANDLER(xegs_pia_pb_w) |
| 919 | WRITE8_MEMBER(a400_state::xegs_pia_pb_w) |
| 916 | 920 | { |
| 921 | device_t *device = machine().device("pia"); |
| 917 | 922 | if (downcast<pia6821_device *>(device)->port_b_z_mask() != 0xff) |
| 918 | | xegs_mmu(space.machine(), data); |
| 923 | xegs_mmu(machine(), data); |
| 919 | 924 | } |
| 920 | 925 | |
| 921 | 926 | static const pokey_interface atari_pokey_interface = |
| r18156 | r18157 | |
| 977 | 982 | DEVCB_NULL, /* line CA2 in */ |
| 978 | 983 | DEVCB_NULL, /* line CB2 in */ |
| 979 | 984 | DEVCB_NULL, /* port A out */ |
| 980 | | DEVCB_DEVICE_HANDLER("pia", a1200xl_pia_pb_w), /* port B out */ |
| 985 | DEVCB_DRIVER_MEMBER(a400_state, a1200xl_pia_pb_w), /* port B out */ |
| 981 | 986 | DEVCB_NULL, /* line CA2 out */ |
| 982 | 987 | DEVCB_DEVICE_LINE("fdc",atarifdc_pia_cb2_w), /* port CB2 out */ |
| 983 | 988 | DEVCB_NULL, /* IRQA */ |
| r18156 | r18157 | |
| 993 | 998 | DEVCB_NULL, /* line CA2 in */ |
| 994 | 999 | DEVCB_NULL, /* line CB2 in */ |
| 995 | 1000 | DEVCB_NULL, /* port A out */ |
| 996 | | DEVCB_DEVICE_HANDLER("pia", a800xl_pia_pb_w), /* port B out */ |
| 1001 | DEVCB_DRIVER_MEMBER(a400_state,a800xl_pia_pb_w), /* port B out */ |
| 997 | 1002 | DEVCB_NULL, /* line CA2 out */ |
| 998 | 1003 | DEVCB_DEVICE_LINE("fdc",atarifdc_pia_cb2_w), /* port CB2 out */ |
| 999 | 1004 | DEVCB_NULL, /* IRQA */ |
| r18156 | r18157 | |
| 1009 | 1014 | DEVCB_NULL, /* line CA2 in */ |
| 1010 | 1015 | DEVCB_NULL, /* line CB2 in */ |
| 1011 | 1016 | DEVCB_NULL, /* port A out */ |
| 1012 | | DEVCB_DEVICE_HANDLER("pia", xegs_pia_pb_w), /* port B out */ |
| 1017 | DEVCB_DRIVER_MEMBER(a400_state,xegs_pia_pb_w), /* port B out */ |
| 1013 | 1018 | DEVCB_NULL, /* line CA2 out */ |
| 1014 | 1019 | DEVCB_DEVICE_LINE("fdc",atarifdc_pia_cb2_w), /* port CB2 out */ |
| 1015 | 1020 | DEVCB_NULL, /* IRQA */ |