Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-25 17:56:43 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

modernized photon and small cleanup (nw)

Browse Source
This commit is contained in:
Miodrag Milanovic 2013-04-03 12:29:48 +00:00
parent 76fc9a0f03
commit 53c7405802
4 changed files with 134 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
src/mame/drivers/photon.c
View File

@ -22,30 +22,28 @@
#include "sound/speaker.h" #include "sound/speaker.h"
class photon_state : public driver_device class photon_state : public pk8000_base_state
{ {
public: public:
photon_state(const machine_config &mconfig, device_type type, const char *tag) photon_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) { } : pk8000_base_state(mconfig, type, tag) { }
DECLARE_WRITE8_MEMBER(pk8000_80_porta_w); DECLARE_WRITE8_MEMBER(pk8000_80_porta_w);
DECLARE_READ8_MEMBER(pk8000_80_portb_r); DECLARE_READ8_MEMBER(pk8000_80_portb_r);
DECLARE_WRITE8_MEMBER(pk8000_80_portc_w); DECLARE_WRITE8_MEMBER(pk8000_80_portc_w);
DECLARE_READ8_MEMBER(pk8000_84_porta_r);
DECLARE_WRITE8_MEMBER(pk8000_84_porta_w);
DECLARE_WRITE8_MEMBER(pk8000_84_portc_w);
virtual void machine_reset(); virtual void machine_reset();
virtual void video_start(); virtual void video_start();
UINT32 screen_update_photon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_photon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(pk8000_interrupt); INTERRUPT_GEN_MEMBER(pk8000_interrupt);
IRQ_CALLBACK_MEMBER(pk8000_irq_callback); IRQ_CALLBACK_MEMBER(pk8000_irq_callback);
void pk8000_set_bank(UINT8 data);
}; };
static void pk8000_set_bank(running_machine &machine,UINT8 data) void photon_state::pk8000_set_bank(UINT8 data)
{ {
UINT8 *rom = machine.root_device().memregion("maincpu")->base(); UINT8 *rom = memregion("maincpu")->base();
UINT8 *ram = machine.root_device().memregion("maincpu")->base(); UINT8 *ram = memregion("maincpu")->base();
UINT8 block1 = data & 3; UINT8 block1 = data & 3;
UINT8 block2 = (data >> 2) & 3; UINT8 block2 = (data >> 2) & 3;
UINT8 block3 = (data >> 4) & 3; UINT8 block3 = (data >> 4) & 3;
@ -53,57 +51,57 @@ static void pk8000_set_bank(running_machine &machine,UINT8 data)
switch(block1) { switch(block1) {
case 0: case 0:
machine.root_device().membank("bank1")->set_base(rom + 0x10000); membank("bank1")->set_base(rom + 0x10000);
machine.root_device().membank("bank5")->set_base(ram); membank("bank5")->set_base(ram);
break; break;
case 1: break; case 1: break;
case 2: break; case 2: break;
case 3: case 3:
machine.root_device().membank("bank1")->set_base(ram); membank("bank1")->set_base(ram);
machine.root_device().membank("bank5")->set_base(ram); membank("bank5")->set_base(ram);
break; break;
} }
switch(block2) { switch(block2) {
case 0: case 0:
machine.root_device().membank("bank2")->set_base(rom + 0x14000); membank("bank2")->set_base(rom + 0x14000);
machine.root_device().membank("bank6")->set_base(ram + 0x4000); membank("bank6")->set_base(ram + 0x4000);
break; break;
case 1: break; case 1: break;
case 2: break; case 2: break;
case 3: case 3:
machine.root_device().membank("bank2")->set_base(ram + 0x4000); membank("bank2")->set_base(ram + 0x4000);
machine.root_device().membank("bank6")->set_base(ram + 0x4000); membank("bank6")->set_base(ram + 0x4000);
break; break;
} }
switch(block3) { switch(block3) {
case 0: case 0:
machine.root_device().membank("bank3")->set_base(rom + 0x18000); membank("bank3")->set_base(rom + 0x18000);
machine.root_device().membank("bank7")->set_base(ram + 0x8000); membank("bank7")->set_base(ram + 0x8000);
break; break;
case 1: break; case 1: break;
case 2: break; case 2: break;
case 3: case 3:
machine.root_device().membank("bank3")->set_base(ram + 0x8000); membank("bank3")->set_base(ram + 0x8000);
machine.root_device().membank("bank7")->set_base(ram + 0x8000); membank("bank7")->set_base(ram + 0x8000);
break; break;
} }
switch(block4) { switch(block4) {
case 0: case 0:
machine.root_device().membank("bank4")->set_base(rom + 0x1c000); membank("bank4")->set_base(rom + 0x1c000);
machine.root_device().membank("bank8")->set_base(ram + 0xc000); membank("bank8")->set_base(ram + 0xc000);
break; break;
case 1: break; case 1: break;
case 2: break; case 2: break;
case 3: case 3:
machine.root_device().membank("bank4")->set_base(ram + 0xc000); membank("bank4")->set_base(ram + 0xc000);
machine.root_device().membank("bank8")->set_base(ram + 0xc000); membank("bank8")->set_base(ram + 0xc000);
break; break;
} }
} }
WRITE8_MEMBER(photon_state::pk8000_80_porta_w) WRITE8_MEMBER(photon_state::pk8000_80_porta_w)
{ {
pk8000_set_bank(machine(),data); pk8000_set_bank(data);
} }
READ8_MEMBER(photon_state::pk8000_80_portb_r) READ8_MEMBER(photon_state::pk8000_80_portb_r)
@ -126,28 +124,14 @@ static I8255_INTERFACE( pk8000_ppi8255_interface_1 )
DEVCB_DRIVER_MEMBER(photon_state,pk8000_80_portc_w) DEVCB_DRIVER_MEMBER(photon_state,pk8000_80_portc_w)
}; };
READ8_MEMBER(photon_state::pk8000_84_porta_r)
{
return pk8000_video_mode;
}
WRITE8_MEMBER(photon_state::pk8000_84_porta_w)
{
pk8000_video_mode = data;
}
WRITE8_MEMBER(photon_state::pk8000_84_portc_w)
{
pk8000_video_enable = BIT(data,4);
}
static I8255A_INTERFACE( pk8000_ppi8255_interface_2 ) static I8255A_INTERFACE( pk8000_ppi8255_interface_2 )
{ {
DEVCB_DRIVER_MEMBER(photon_state,pk8000_84_porta_r), DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_porta_r),
DEVCB_DRIVER_MEMBER(photon_state,pk8000_84_porta_w), DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_porta_w),
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
DEVCB_DRIVER_MEMBER(photon_state,pk8000_84_portc_w) DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_portc_w)
}; };
static ADDRESS_MAP_START(pk8000_mem, AS_PROGRAM, 8, photon_state ) static ADDRESS_MAP_START(pk8000_mem, AS_PROGRAM, 8, photon_state )
@ -162,14 +146,14 @@ static ADDRESS_MAP_START( pk8000_io , AS_IO, 8, photon_state )
ADDRESS_MAP_UNMAP_HIGH ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x80, 0x83) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write) AM_RANGE(0x80, 0x83) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write)
AM_RANGE(0x84, 0x87) AM_DEVREADWRITE("ppi8255_2", i8255_device, read, write) AM_RANGE(0x84, 0x87) AM_DEVREADWRITE("ppi8255_2", i8255_device, read, write)
AM_RANGE(0x88, 0x88) AM_READWRITE_LEGACY(pk8000_video_color_r,pk8000_video_color_w) AM_RANGE(0x88, 0x88) AM_READWRITE(pk8000_video_color_r,pk8000_video_color_w)
AM_RANGE(0x8c, 0x8c) AM_READ_PORT("JOY1") AM_RANGE(0x8c, 0x8c) AM_READ_PORT("JOY1")
AM_RANGE(0x8d, 0x8d) AM_READ_PORT("JOY2") AM_RANGE(0x8d, 0x8d) AM_READ_PORT("JOY2")
AM_RANGE(0x90, 0x90) AM_READWRITE_LEGACY(pk8000_text_start_r,pk8000_text_start_w) AM_RANGE(0x90, 0x90) AM_READWRITE(pk8000_text_start_r,pk8000_text_start_w)
AM_RANGE(0x91, 0x91) AM_READWRITE_LEGACY(pk8000_chargen_start_r,pk8000_chargen_start_w) AM_RANGE(0x91, 0x91) AM_READWRITE(pk8000_chargen_start_r,pk8000_chargen_start_w)
AM_RANGE(0x92, 0x92) AM_READWRITE_LEGACY(pk8000_video_start_r,pk8000_video_start_w) AM_RANGE(0x92, 0x92) AM_READWRITE(pk8000_video_start_r,pk8000_video_start_w)
AM_RANGE(0x93, 0x93) AM_READWRITE_LEGACY(pk8000_color_start_r,pk8000_color_start_w) AM_RANGE(0x93, 0x93) AM_READWRITE(pk8000_color_start_r,pk8000_color_start_w)
AM_RANGE(0xa0, 0xbf) AM_READWRITE_LEGACY(pk8000_color_r,pk8000_color_w) AM_RANGE(0xa0, 0xbf) AM_READWRITE(pk8000_color_r,pk8000_color_w)
ADDRESS_MAP_END ADDRESS_MAP_END
static INPUT_PORTS_START( photon ) static INPUT_PORTS_START( photon )
@ -200,7 +184,7 @@ IRQ_CALLBACK_MEMBER(photon_state::pk8000_irq_callback)
void photon_state::machine_reset() void photon_state::machine_reset()
{ {
pk8000_set_bank(machine(),0); pk8000_set_bank(0);
machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(photon_state::pk8000_irq_callback),this)); machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(photon_state::pk8000_irq_callback),this));
} }
@ -230,7 +214,6 @@ static MACHINE_CONFIG_START( photon, photon_state )
MCFG_SCREEN_VISIBLE_AREA(0, 256+32-1, 0, 192+32-1) MCFG_SCREEN_VISIBLE_AREA(0, 256+32-1, 0, 192+32-1)
MCFG_SCREEN_UPDATE_DRIVER(photon_state, screen_update_photon) MCFG_SCREEN_UPDATE_DRIVER(photon_state, screen_update_photon)
MCFG_PALETTE_LENGTH(16) MCFG_PALETTE_LENGTH(16)
MCFG_PALETTE_INIT(pk8000)
MCFG_I8255_ADD( "ppi8255_1", pk8000_ppi8255_interface_1 ) MCFG_I8255_ADD( "ppi8255_1", pk8000_ppi8255_interface_1 )

51
src/mame/includes/pk8000.h
View File

@ -1,21 +1,36 @@
/*----------- defined in video/pk8000.c -----------*/ class pk8000_base_state : public driver_device
{
public:
pk8000_base_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) { }
DECLARE_READ8_MEMBER(pk8000_video_color_r);
DECLARE_WRITE8_MEMBER(pk8000_video_color_w);
DECLARE_READ8_MEMBER(pk8000_text_start_r);
DECLARE_WRITE8_MEMBER(pk8000_text_start_w);
DECLARE_READ8_MEMBER(pk8000_chargen_start_r);
DECLARE_WRITE8_MEMBER(pk8000_chargen_start_w);
DECLARE_READ8_MEMBER(pk8000_video_start_r);
DECLARE_WRITE8_MEMBER(pk8000_video_start_w);
DECLARE_READ8_MEMBER(pk8000_color_start_r);
DECLARE_WRITE8_MEMBER(pk8000_color_start_w);
DECLARE_READ8_MEMBER(pk8000_color_r);
DECLARE_WRITE8_MEMBER(pk8000_color_w);
DECLARE_READ8_MEMBER(pk8000_84_porta_r);
DECLARE_WRITE8_MEMBER(pk8000_84_porta_w);
DECLARE_WRITE8_MEMBER(pk8000_84_portc_w);
DECLARE_READ8_HANDLER(pk8000_video_color_r); virtual void palette_init();
DECLARE_WRITE8_HANDLER(pk8000_video_color_w);
DECLARE_READ8_HANDLER(pk8000_text_start_r);
DECLARE_WRITE8_HANDLER(pk8000_text_start_w);
DECLARE_READ8_HANDLER(pk8000_chargen_start_r);
DECLARE_WRITE8_HANDLER(pk8000_chargen_start_w);
DECLARE_READ8_HANDLER(pk8000_video_start_r);
DECLARE_WRITE8_HANDLER(pk8000_video_start_w);
DECLARE_READ8_HANDLER(pk8000_color_start_r);
DECLARE_WRITE8_HANDLER(pk8000_color_start_w);
DECLARE_READ8_HANDLER(pk8000_color_r);
DECLARE_WRITE8_HANDLER(pk8000_color_w);
extern UINT8 pk8000_video_mode; UINT32 pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *videomem);
extern UINT8 pk8000_video_enable; protected:
UINT8 m_pk8000_text_start;
UINT8 m_pk8000_chargen_start;
UINT8 m_pk8000_video_start;
UINT8 m_pk8000_color_start;
PALETTE_INIT( pk8000 ); UINT8 m_pk8000_video_mode;
UINT8 m_pk8000_video_color;
UINT32 pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *videomem); UINT8 m_pk8000_color[32];
UINT8 m_pk8000_video_enable;
};

107
src/mame/video/pk8000.c
View File

@ -1,74 +1,64 @@
#include "emu.h" #include "emu.h"
#include "includes/pk8000.h" #include "includes/pk8000.h"
static UINT8 pk8000_text_start; READ8_MEMBER(pk8000_base_state::pk8000_video_color_r)
static UINT8 pk8000_chargen_start;
static UINT8 pk8000_video_start;
static UINT8 pk8000_color_start;
UINT8 pk8000_video_mode;
static UINT8 pk8000_video_color;
static UINT8 pk8000_color[32];
UINT8 pk8000_video_enable;
READ8_HANDLER(pk8000_video_color_r)
{ {
return pk8000_video_color; return m_pk8000_video_color;
} }
WRITE8_HANDLER(pk8000_video_color_w) WRITE8_MEMBER(pk8000_base_state::pk8000_video_color_w)
{ {
pk8000_video_color = data; m_pk8000_video_color = data;
} }
READ8_HANDLER(pk8000_text_start_r) READ8_MEMBER(pk8000_base_state::pk8000_text_start_r)
{ {
return pk8000_text_start; return m_pk8000_text_start;
} }
WRITE8_HANDLER(pk8000_text_start_w) WRITE8_MEMBER(pk8000_base_state::pk8000_text_start_w)
{ {
pk8000_text_start = data; m_pk8000_text_start = data;
} }
READ8_HANDLER(pk8000_chargen_start_r) READ8_MEMBER(pk8000_base_state::pk8000_chargen_start_r)
{ {
return pk8000_chargen_start; return m_pk8000_chargen_start;
} }
WRITE8_HANDLER(pk8000_chargen_start_w) WRITE8_MEMBER(pk8000_base_state::pk8000_chargen_start_w)
{ {
pk8000_chargen_start = data; m_pk8000_chargen_start = data;
} }
READ8_HANDLER(pk8000_video_start_r) READ8_MEMBER(pk8000_base_state::pk8000_video_start_r)
{ {
return pk8000_video_start; return m_pk8000_video_start;
} }
WRITE8_HANDLER(pk8000_video_start_w) WRITE8_MEMBER(pk8000_base_state::pk8000_video_start_w)
{ {
pk8000_video_start = data; m_pk8000_video_start = data;
} }
READ8_HANDLER(pk8000_color_start_r) READ8_MEMBER(pk8000_base_state::pk8000_color_start_r)
{ {
return pk8000_color_start; return m_pk8000_color_start;
} }
WRITE8_HANDLER(pk8000_color_start_w) WRITE8_MEMBER(pk8000_base_state::pk8000_color_start_w)
{ {
pk8000_color_start = data; m_pk8000_color_start = data;
} }
READ8_HANDLER(pk8000_color_r) READ8_MEMBER(pk8000_base_state::pk8000_color_r)
{ {
return pk8000_color[offset]; return m_pk8000_color[offset];
} }
WRITE8_HANDLER(pk8000_color_w) WRITE8_MEMBER(pk8000_base_state::pk8000_color_w)
{ {
pk8000_color[offset] = data; m_pk8000_color[offset] = data;
} }
static const rgb_t pk8000_palette[16] = { static const rgb_t pk8000_palette[16] = {
@ -90,33 +80,48 @@ static const rgb_t pk8000_palette[16] = {
MAKE_RGB(0xff, 0xff, 0xff), // F MAKE_RGB(0xff, 0xff, 0xff), // F
}; };
PALETTE_INIT( pk8000 ) void pk8000_base_state::palette_init()
{ {
palette_set_colors(machine, 0, pk8000_palette, ARRAY_LENGTH(pk8000_palette)); palette_set_colors(machine(), 0, pk8000_palette, ARRAY_LENGTH(pk8000_palette));
} }
UINT32 pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *videomem) READ8_MEMBER(pk8000_base_state::pk8000_84_porta_r)
{
return m_pk8000_video_mode;
}
WRITE8_MEMBER(pk8000_base_state::pk8000_84_porta_w)
{
m_pk8000_video_mode = data;
}
WRITE8_MEMBER(pk8000_base_state::pk8000_84_portc_w)
{
m_pk8000_video_enable = BIT(data,4);
}
UINT32 pk8000_base_state::pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *videomem)
{ {
int x,y,j,b; int x,y,j,b;
UINT16 offset = (pk8000_video_mode & 0xc0) << 8; UINT16 offset = (m_pk8000_video_mode & 0xc0) << 8;
rectangle my_rect; rectangle my_rect;
my_rect.set(0, 256+32-1, 0, 192+32-1); my_rect.set(0, 256+32-1, 0, 192+32-1);
if (pk8000_video_enable) { if (m_pk8000_video_enable) {
bitmap.fill((pk8000_video_color >> 4) & 0x0f, my_rect); bitmap.fill((m_pk8000_video_color >> 4) & 0x0f, my_rect);
if (BIT(pk8000_video_mode,4)==0){ if (BIT(m_pk8000_video_mode,4)==0){
// Text mode // Text mode
if (BIT(pk8000_video_mode,5)==0){ if (BIT(m_pk8000_video_mode,5)==0){
// 32 columns // 32 columns
for (y = 0; y < 24; y++) for (y = 0; y < 24; y++)
{ {
for (x = 0; x < 32; x++) for (x = 0; x < 32; x++)
{ {
UINT8 chr = videomem[x +(y*32) + ((pk8000_text_start & 0x0f) << 10)+offset] ; UINT8 chr = videomem[x +(y*32) + ((m_pk8000_text_start & 0x0f) << 10)+offset] ;
UINT8 color= pk8000_color[chr>>3]; UINT8 color= m_pk8000_color[chr>>3];
for (j = 0; j < 8; j++) { for (j = 0; j < 8; j++) {
UINT8 code = videomem[((chr<<3) + j) + ((pk8000_chargen_start & 0x0e) << 10)+offset]; UINT8 code = videomem[((chr<<3) + j) + ((m_pk8000_chargen_start & 0x0e) << 10)+offset];
for (b = 0; b < 8; b++) for (b = 0; b < 8; b++)
{ {
@ -132,12 +137,12 @@ UINT32 pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const re
{ {
for (x = 0; x < 42; x++) for (x = 0; x < 42; x++)
{ {
UINT8 chr = videomem[x +(y*64) + ((pk8000_text_start & 0x0e) << 10)+offset] ; UINT8 chr = videomem[x +(y*64) + ((m_pk8000_text_start & 0x0e) << 10)+offset] ;
for (j = 0; j < 8; j++) { for (j = 0; j < 8; j++) {
UINT8 code = videomem[((chr<<3) + j) + ((pk8000_chargen_start & 0x0e) << 10)+offset]; UINT8 code = videomem[((chr<<3) + j) + ((m_pk8000_chargen_start & 0x0e) << 10)+offset];
for (b = 2; b < 8; b++) for (b = 2; b < 8; b++)
{ {
UINT8 col = ((code >> b) & 0x01) ? (pk8000_video_color) & 0x0f : (pk8000_video_color>>4) & 0x0f; UINT8 col = ((code >> b) & 0x01) ? (m_pk8000_video_color) & 0x0f : (m_pk8000_video_color>>4) & 0x0f;
bitmap.pix16((y*8)+j+16, x*6+(7-b)+16+8) = col; bitmap.pix16((y*8)+j+16, x*6+(7-b)+16+8) = col;
} }
} }
@ -148,11 +153,11 @@ UINT32 pk8000_video_update(screen_device &screen, bitmap_ind16 &bitmap, const re
//Graphics //Graphics
for (y = 0; y < 24; y++) for (y = 0; y < 24; y++)
{ {
UINT16 off_color = (((~pk8000_color_start) & 0x08) << 10)+offset + ((y>>3)<<11); UINT16 off_color = (((~m_pk8000_color_start) & 0x08) << 10)+offset + ((y>>3)<<11);
UINT16 off_code = (((~pk8000_video_start) & 0x08) << 10)+offset + ((y>>3)<<11); UINT16 off_code = (((~m_pk8000_video_start) & 0x08) << 10)+offset + ((y>>3)<<11);
for (x = 0; x < 32; x++) for (x = 0; x < 32; x++)
{ {
UINT8 chr = videomem[x +(y*32) + ((pk8000_chargen_start & 0x0e) << 10)+offset] ; UINT8 chr = videomem[x +(y*32) + ((m_pk8000_chargen_start & 0x0e) << 10)+offset] ;
for (j = 0; j < 8; j++) { for (j = 0; j < 8; j++) {
UINT8 color= videomem[((chr<<3) + j)+off_color]; UINT8 color= videomem[((chr<<3) + j)+off_color];
UINT8 code = videomem[((chr<<3) + j)+off_code]; UINT8 code = videomem[((chr<<3) + j)+off_code];

41
src/mess/drivers/pk8000.c
View File

@ -18,11 +18,11 @@
#include "machine/ram.h" #include "machine/ram.h"
class pk8000_state : public driver_device class pk8000_state : public pk8000_base_state
{ {
public: public:
pk8000_state(const machine_config &mconfig, device_type type, const char *tag) pk8000_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) : pk8000_base_state(mconfig, type, tag)
, m_maincpu(*this, "maincpu") , m_maincpu(*this, "maincpu")
, m_cassette(*this, CASSETTE_TAG) , m_cassette(*this, CASSETTE_TAG)
, m_ram(*this, RAM_TAG) , m_ram(*this, RAM_TAG)
@ -51,9 +51,7 @@ public:
DECLARE_WRITE8_MEMBER(pk8000_80_porta_w); DECLARE_WRITE8_MEMBER(pk8000_80_porta_w);
DECLARE_READ8_MEMBER(pk8000_80_portb_r); DECLARE_READ8_MEMBER(pk8000_80_portb_r);
DECLARE_WRITE8_MEMBER(pk8000_80_portc_w); DECLARE_WRITE8_MEMBER(pk8000_80_portc_w);
DECLARE_READ8_MEMBER(pk8000_84_porta_r);
DECLARE_WRITE8_MEMBER(pk8000_84_porta_w);
DECLARE_WRITE8_MEMBER(pk8000_84_portc_w);
IRQ_CALLBACK_MEMBER(pk8000_irq_callback); IRQ_CALLBACK_MEMBER(pk8000_irq_callback);
protected: protected:
@ -171,28 +169,14 @@ static I8255_INTERFACE( pk8000_ppi8255_interface_1 )
DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_80_portc_w) DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_80_portc_w)
}; };
READ8_MEMBER(pk8000_state::pk8000_84_porta_r)
{
return pk8000_video_mode;
}
WRITE8_MEMBER(pk8000_state::pk8000_84_porta_w)
{
pk8000_video_mode = data;
}
WRITE8_MEMBER(pk8000_state::pk8000_84_portc_w)
{
pk8000_video_enable = BIT(data,4);
}
static I8255_INTERFACE( pk8000_ppi8255_interface_2 ) static I8255_INTERFACE( pk8000_ppi8255_interface_2 )
{ {
DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_porta_r), DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_porta_r),
DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_porta_w), DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_porta_w),
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
DEVCB_DRIVER_MEMBER(pk8000_state,pk8000_84_portc_w) DEVCB_DRIVER_MEMBER(pk8000_base_state,pk8000_84_portc_w)
}; };
READ8_MEMBER(pk8000_state::pk8000_joy_1_r) READ8_MEMBER(pk8000_state::pk8000_joy_1_r)
@ -220,14 +204,14 @@ static ADDRESS_MAP_START( pk8000_io , AS_IO, 8, pk8000_state )
ADDRESS_MAP_UNMAP_HIGH ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x80, 0x83) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write) AM_RANGE(0x80, 0x83) AM_DEVREADWRITE("ppi8255_1", i8255_device, read, write)
AM_RANGE(0x84, 0x87) AM_DEVREADWRITE("ppi8255_2", i8255_device, read, write) AM_RANGE(0x84, 0x87) AM_DEVREADWRITE("ppi8255_2", i8255_device, read, write)
AM_RANGE(0x88, 0x88) AM_READWRITE_LEGACY(pk8000_video_color_r,pk8000_video_color_w) AM_RANGE(0x88, 0x88) AM_READWRITE(pk8000_video_color_r,pk8000_video_color_w)
AM_RANGE(0x8c, 0x8c) AM_READ(pk8000_joy_1_r) AM_RANGE(0x8c, 0x8c) AM_READ(pk8000_joy_1_r)
AM_RANGE(0x8d, 0x8d) AM_READ(pk8000_joy_2_r) AM_RANGE(0x8d, 0x8d) AM_READ(pk8000_joy_2_r)
AM_RANGE(0x90, 0x90) AM_READWRITE_LEGACY(pk8000_text_start_r,pk8000_text_start_w) AM_RANGE(0x90, 0x90) AM_READWRITE(pk8000_text_start_r,pk8000_text_start_w)
AM_RANGE(0x91, 0x91) AM_READWRITE_LEGACY(pk8000_chargen_start_r,pk8000_chargen_start_w) AM_RANGE(0x91, 0x91) AM_READWRITE(pk8000_chargen_start_r,pk8000_chargen_start_w)
AM_RANGE(0x92, 0x92) AM_READWRITE_LEGACY(pk8000_video_start_r,pk8000_video_start_w) AM_RANGE(0x92, 0x92) AM_READWRITE(pk8000_video_start_r,pk8000_video_start_w)
AM_RANGE(0x93, 0x93) AM_READWRITE_LEGACY(pk8000_color_start_r,pk8000_color_start_w) AM_RANGE(0x93, 0x93) AM_READWRITE(pk8000_color_start_r,pk8000_color_start_w)
AM_RANGE(0xa0, 0xbf) AM_READWRITE_LEGACY(pk8000_color_r,pk8000_color_w) AM_RANGE(0xa0, 0xbf) AM_READWRITE(pk8000_color_r,pk8000_color_w)
ADDRESS_MAP_END ADDRESS_MAP_END
/* Input ports */ /* Input ports */
@ -405,7 +389,6 @@ static MACHINE_CONFIG_START( pk8000, pk8000_state )
MCFG_SCREEN_UPDATE_DRIVER(pk8000_state, screen_update_pk8000) MCFG_SCREEN_UPDATE_DRIVER(pk8000_state, screen_update_pk8000)
MCFG_PALETTE_LENGTH(16) MCFG_PALETTE_LENGTH(16)
MCFG_PALETTE_INIT(pk8000)
MCFG_I8255_ADD( "ppi8255_1", pk8000_ppi8255_interface_1 ) MCFG_I8255_ADD( "ppi8255_1", pk8000_ppi8255_interface_1 )