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

(MESS) Cleaned up tagmap usage in the spectrum drivers a bit. (nw)

Browse Source
This commit is contained in:
Wilbert Pol 2013-02-07 20:55:30 +00:00
parent bdcf0dd2a8
commit 46ef255061
11 changed files with 339 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/mess/drivers/atm.c
View File

@ -26,26 +26,24 @@ class atm_state : public spectrum_state
public:
atm_state(const machine_config &mconfig, device_type type, const char *tag)
: spectrum_state(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_bank1(*this, "bank1")
, m_bank2(*this, "bank2")
, m_bank3(*this, "bank3")
, m_bank4(*this, "bank4")
, m_beta(*this, BETA_DISK_TAG)
, m_ram(*this, RAM_TAG)
{ }
DECLARE_WRITE8_MEMBER(atm_port_7ffd_w);
DIRECT_UPDATE_MEMBER(atm_direct);
DECLARE_MACHINE_RESET(atm);
protected:
required_device<cpu_device> m_maincpu;
required_memory_bank m_bank1;
required_memory_bank m_bank2;
required_memory_bank m_bank3;
required_memory_bank m_bank4;
required_device<device_t> m_beta;
required_device<ram_device> m_ram;
private:
UINT8 *m_p_ram;
void atm_update_memory();

124
src/mess/drivers/elwro800.c
View File

@ -34,7 +34,14 @@ class elwro800_state : public spectrum_state
{
public:
elwro800_state(const machine_config &mconfig, device_type type, const char *tag)
: spectrum_state(mconfig, type, tag) { }
: spectrum_state(mconfig, type, tag)
, m_i8251(*this, "i8251")
, m_i8255(*this, "ppi8255")
, m_centronics(*this, "centronics")
, m_io_line8(*this, "LINE8")
, m_io_line9(*this, "LINE9")
, m_io_network_id(*this, "NETWORK ID")
{ }
/* for elwro800 */
/* RAM mapped at 0 */
@ -52,6 +59,16 @@ public:
INTERRUPT_GEN_MEMBER(elwro800jr_interrupt);
DECLARE_READ8_MEMBER(i8255_port_c_r);
DECLARE_WRITE8_MEMBER(i8255_port_c_w);
protected:
required_device<i8251_device> m_i8251;
required_device<i8255_device> m_i8255;
required_device<centronics_device> m_centronics;
required_ioport m_io_line8;
required_ioport m_io_line9;
required_ioport m_io_network_id;
void elwro800jr_mmu_w(UINT8 data);
};
@ -80,15 +97,13 @@ DIRECT_UPDATE_MEMBER(elwro800_state::elwro800_direct_handler)
WRITE8_MEMBER(elwro800_state::elwro800jr_fdc_control_w)
{
upd765a_device *fdc = machine().device<upd765a_device>("upd765");
m_upd765_0->get_device()->mon_w(!BIT(data, 0));
m_upd765_1->get_device()->mon_w(!BIT(data, 1));
machine().device<floppy_connector>("upd765:0")->get_device()->mon_w(!BIT(data, 0));
machine().device<floppy_connector>("upd765:1")->get_device()->mon_w(!BIT(data, 1));
fdc->tc_w(data & 0x04);
m_upd765->tc_w(data & 0x04);
if(!(data & 8))
fdc->reset();
m_upd765->reset();
}
/*************************************
@ -97,13 +112,12 @@ WRITE8_MEMBER(elwro800_state::elwro800jr_fdc_control_w)
*
*************************************/
static void elwro800jr_mmu_w(running_machine &machine, UINT8 data)
void elwro800_state::elwro800jr_mmu_w(UINT8 data)
{
UINT8 *prom = machine.root_device().memregion("proms")->base() + 0x200;
UINT8 *messram = machine.device<ram_device>(RAM_TAG)->pointer();
UINT8 *prom = memregion("proms")->base() + 0x200;
UINT8 *messram = m_ram->pointer();
UINT8 cs;
UINT8 ls175;
elwro800_state *state = machine.driver_data<elwro800_state>();
ls175 = BITSWAP8(data, 7, 6, 5, 4, 4, 5, 7, 6) & 0x0f;
@ -111,48 +125,48 @@ static void elwro800jr_mmu_w(running_machine &machine, UINT8 data)
if (!BIT(cs,0))
{
// rom BAS0
state->membank("bank1")->set_base(state->memregion("maincpu")->base() + 0x0000); /* BAS0 ROM */
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_write(0x0000, 0x1fff);
state->m_ram_at_0000 = 0;
membank("bank1")->set_base(memregion("maincpu")->base() + 0x0000); /* BAS0 ROM */
m_maincpu->space(AS_PROGRAM).nop_write(0x0000, 0x1fff);
m_ram_at_0000 = 0;
}
else if (!BIT(cs,4))
{
// rom BOOT
state->membank("bank1")->set_base(machine.root_device().memregion("maincpu")->base() + 0x4000); /* BOOT ROM */
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_write(0x0000, 0x1fff);
state->m_ram_at_0000 = 0;
membank("bank1")->set_base(memregion("maincpu")->base() + 0x4000); /* BOOT ROM */
m_maincpu->space(AS_PROGRAM).nop_write(0x0000, 0x1fff);
m_ram_at_0000 = 0;
}
else
{
// RAM
state->membank("bank1")->set_base(messram);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x0000, 0x1fff, "bank1");
state->m_ram_at_0000 = 1;
membank("bank1")->set_base(messram);
m_maincpu->space(AS_PROGRAM).install_write_bank(0x0000, 0x1fff, "bank1");
m_ram_at_0000 = 1;
}
cs = prom[((0x2000 >> 10) | (ls175 << 6)) & 0x1ff];
if (!BIT(cs,1))
{
state->membank("bank2")->set_base(machine.root_device().memregion("maincpu")->base() + 0x2000); /* BAS1 ROM */
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_write(0x2000, 0x3fff);
membank("bank2")->set_base(memregion("maincpu")->base() + 0x2000); /* BAS1 ROM */
m_maincpu->space(AS_PROGRAM).nop_write(0x2000, 0x3fff);
}
else
{
state->membank("bank2")->set_base(messram + 0x2000); /* RAM */
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x2000, 0x3fff, "bank2");
membank("bank2")->set_base(messram + 0x2000); /* RAM */
m_maincpu->space(AS_PROGRAM).install_write_bank(0x2000, 0x3fff, "bank2");
}
if (BIT(ls175,2))
{
// relok
state->m_screen_location = messram + 0xe000;
m_screen_location = messram + 0xe000;
}
else
{
state->m_screen_location = messram + 0x4000;
m_screen_location = messram + 0x4000;
}
state->m_NR = BIT(ls175,3);
m_NR = BIT(ls175,3);
if (BIT(ls175,3))
{
logerror("Reading network number\n");
@ -167,14 +181,12 @@ static void elwro800jr_mmu_w(running_machine &machine, UINT8 data)
READ8_MEMBER(elwro800_state::i8255_port_c_r)
{
centronics_device *centronics = machine().device<centronics_device>("centronics");
return (centronics->ack_r() << 2);
return (m_centronics->ack_r() << 2);
}
WRITE8_MEMBER(elwro800_state::i8255_port_c_w)
{
centronics_device *centronics = machine().device<centronics_device>("centronics");
centronics->strobe_w((data >> 7) & 0x01);
m_centronics->strobe_w((data >> 7) & 0x01);
}
static I8255_INTERFACE(elwro800jr_ppi8255_interface)
@ -227,7 +239,7 @@ READ8_MEMBER(elwro800_state::elwro800jr_io_r)
int mask = 0x8000;
int data = 0xff;
int i;
char port_name[6] = "LINE0";
ioport_port *io_ports[9] = { m_io_line7, m_io_line6, m_io_line5, m_io_line4, m_io_line3, m_io_line2, m_io_line1, m_io_line0, m_io_line8 };
if ( !m_NR )
{
@ -235,32 +247,24 @@ READ8_MEMBER(elwro800_state::elwro800jr_io_r)
{
if (!(offset & mask))
{
if (i == 8)
{
port_name[4] = '8';
}
else
{
port_name[4] = '0' + (7 - i);
}
data &= (ioport(port_name)->read());
data &= io_ports[i]->read();
}
}
if ((offset & 0xff) == 0xfb)
{
data &= ioport("LINE9")->read();
data &= m_io_line9->read();
}
/* cassette input from wav */
if ((machine().device<cassette_image_device>(CASSETTE_TAG))->input() > 0.0038 )
if (m_cassette->input() > 0.0038 )
{
data &= ~0x40;
}
}
else
{
data = ioport("NETWORK ID")->read();
data = m_io_network_id->read();
}
return data;
@ -272,33 +276,30 @@ READ8_MEMBER(elwro800_state::elwro800jr_io_r)
else if (!BIT(cs,2))
{
// CS55
i8255_device *ppi = machine().device<i8255_device>("ppi8255");
return ppi->read(space, (offset & 0x03) ^ 0x03);
return m_i8255->read(space, (offset & 0x03) ^ 0x03);
}
else if (!BIT(cs,3))
{
// CSFDC
upd765a_device *fdc = machine().device<upd765a_device>("upd765");
if (offset & 1)
{
return fdc->fifo_r(space, 0, 0xff);
return m_upd765->fifo_r(space, 0, 0xff);
}
else
{
return fdc->msr_r(space, 0, 0xff);
return m_upd765->msr_r(space, 0, 0xff);
}
}
else if (!BIT(cs,4))
{
// CS51
i8251_device *usart = machine().device<i8251_device>("i8251");
if (offset & 1)
{
return usart->status_r(space, 0);
return m_i8251->status_r(space, 0);
}
else
{
return usart->data_r(space, 0);
return m_i8251->data_r(space, 0);
}
}
else if (!BIT(cs,5))
@ -325,34 +326,31 @@ WRITE8_MEMBER(elwro800_state::elwro800jr_io_w)
else if (!BIT(cs,1))
{
// CF7
elwro800jr_mmu_w(machine(), data);
elwro800jr_mmu_w(data);
}
else if (!BIT(cs,2))
{
// CS55
i8255_device *ppi = machine().device<i8255_device>("ppi8255");
ppi->write(space, (offset & 0x03) ^ 0x03, data);
m_i8255->write(space, (offset & 0x03) ^ 0x03, data);
}
else if (!BIT(cs,3))
{
// CSFDC
upd765a_device *fdc = machine().device<upd765a_device>("upd765");
if (offset & 1)
{
fdc->fifo_w(space, 0, data, 0xff);
m_upd765->fifo_w(space, 0, data, 0xff);
}
}
else if (!BIT(cs,4))
{
// CS51
i8251_device *usart = machine().device<i8251_device>("i8251");
if (offset & 1)
{
usart->control_w(space, 0, data);
m_i8251->control_w(space, 0, data);
}
else
{
usart->data_w(space, 0, data);
m_i8251->data_w(space, 0, data);
}
}
else if (!BIT(cs,5))
@ -502,7 +500,7 @@ INPUT_PORTS_END
MACHINE_RESET_MEMBER(elwro800_state,elwro800)
{
UINT8 *messram = machine().device<ram_device>(RAM_TAG)->pointer();
UINT8 *messram = m_ram->pointer();
m_df_on_databus = 0xdf;
memset(messram, 0, 64*1024);
@ -513,9 +511,9 @@ MACHINE_RESET_MEMBER(elwro800_state,elwro800)
m_port_1ffd_data = -1;
// this is a reset of ls175 in mmu
elwro800jr_mmu_w(machine(), 0);
elwro800jr_mmu_w(0);
machine().device("maincpu")->memory().space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(elwro800_state::elwro800_direct_handler), this));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(elwro800_state::elwro800_direct_handler), this));
}
static const cassette_interface elwro800jr_cassette_interface =

4
src/mess/drivers/pentagon.c
View File

@ -14,13 +14,11 @@ class pentagon_state : public spectrum_state
public:
pentagon_state(const machine_config &mconfig, device_type type, const char *tag)
: spectrum_state(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_bank1(*this, "bank1")
, m_bank2(*this, "bank2")
, m_bank3(*this, "bank3")
, m_bank4(*this, "bank4")
, m_beta(*this, BETA_DISK_TAG)
, m_ram(*this, RAM_TAG)
{ }
DECLARE_DIRECT_UPDATE_MEMBER(pentagon_direct);
@ -28,13 +26,11 @@ public:
DECLARE_MACHINE_RESET(pentagon);
protected:
required_device<cpu_device> m_maincpu;
required_memory_bank m_bank1;
required_memory_bank m_bank2;
required_memory_bank m_bank3;
required_memory_bank m_bank4;
required_device<device_t> m_beta;
required_device<ram_device> m_ram;
private:
UINT8 *m_p_ram;
void pentagon_update_memory();

6
src/mess/drivers/scorpion.c
View File

@ -160,13 +160,11 @@ class scorpion_state : public spectrum_state
public:
scorpion_state(const machine_config &mconfig, device_type type, const char *tag)
: spectrum_state(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_bank1(*this, "bank1")
, m_bank2(*this, "bank2")
, m_bank3(*this, "bank3")
, m_bank4(*this, "bank4")
, m_beta(*this, BETA_DISK_TAG)
, m_ram(*this, RAM_TAG)
{ }
DECLARE_DIRECT_UPDATE_MEMBER(scorpion_direct);
@ -177,13 +175,11 @@ public:
DECLARE_MACHINE_RESET(scorpion);
TIMER_DEVICE_CALLBACK_MEMBER(nmi_check_callback);
protected:
required_device<cpu_device> m_maincpu;
required_memory_bank m_bank1;
required_memory_bank m_bank2;
required_memory_bank m_bank3;
required_memory_bank m_bank4;
required_device<device_t> m_beta;
required_device<ram_device> m_ram;
private:
UINT8 *m_p_ram;
void scorpion_update_memory();
@ -288,7 +284,7 @@ DIRECT_UPDATE_MEMBER(scorpion_state::scorpion_direct)
TIMER_DEVICE_CALLBACK_MEMBER(scorpion_state::nmi_check_callback)
{
if ((machine().root_device().ioport("NMI")->read() & 1)==1)
if ((m_io_nmi->read() & 1)==1)
{
m_port_1ffd_data |= 0x02;
scorpion_update_memory();

46
src/mess/drivers/spec128.c
View File

@ -169,40 +169,37 @@ static const ay8910_interface spectrum_ay_interface =
/****************************************************************************************************/
/* Spectrum 128 specific functions */
static WRITE8_HANDLER(spectrum_128_port_7ffd_w)
WRITE8_MEMBER(spectrum_state::spectrum_128_port_7ffd_w)
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
/* D0-D2: RAM page located at 0x0c000-0x0ffff */
/* D3 - Screen select (screen 0 in ram page 5, screen 1 in ram page 7 */
/* D4 - ROM select - which rom paged into 0x0000-0x03fff */
/* D5 - Disable paging */
/* disable paging? */
if (state->m_port_7ffd_data & 0x20)
if (m_port_7ffd_data & 0x20)
return;
/* store new state */
state->m_port_7ffd_data = data;
m_port_7ffd_data = data;
/* update memory */
spectrum_128_update_memory(space.machine());
spectrum_128_update_memory();
}
void spectrum_128_update_memory(running_machine &machine)
void spectrum_state::spectrum_128_update_memory()
{
spectrum_state *state = machine.driver_data<spectrum_state>();
UINT8 *messram = machine.device<ram_device>(RAM_TAG)->pointer();
UINT8 *messram = m_ram->pointer();
unsigned char *ChosenROM;
int ROMSelection;
if (state->m_port_7ffd_data & 8)
if (m_port_7ffd_data & 8)
{
state->m_screen_location = messram + (7<<14);
m_screen_location = messram + (7<<14);
}
else
{
state->m_screen_location = messram + (5<<14);
m_screen_location = messram + (5<<14);
}
/* select ram at 0x0c000-0x0ffff */
@ -210,28 +207,27 @@ void spectrum_128_update_memory(running_machine &machine)
int ram_page;
unsigned char *ram_data;
ram_page = state->m_port_7ffd_data & 0x07;
ram_page = m_port_7ffd_data & 0x07;
ram_data = messram + (ram_page<<14);
state->membank("bank4")->set_base(ram_data);
membank("bank4")->set_base(ram_data);
}
/* ROM switching */
ROMSelection = ((state->m_port_7ffd_data>>4) & 0x01);
ROMSelection = ((m_port_7ffd_data>>4) & 0x01);
/* rom 0 is 128K rom, rom 1 is 48 BASIC */
ChosenROM = machine.root_device().memregion("maincpu")->base() + 0x010000 + (ROMSelection<<14);
ChosenROM = memregion("maincpu")->base() + 0x010000 + (ROMSelection<<14);
state->membank("bank1")->set_base(ChosenROM);
membank("bank1")->set_base(ChosenROM);
}
static READ8_HANDLER ( spectrum_128_ula_r )
READ8_MEMBER( spectrum_state::spectrum_128_ula_r )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
int vpos = space.machine().primary_screen->vpos();
int vpos = machine().primary_screen->vpos();
return vpos<193 ? state->m_screen_location[0x1800|(vpos&0xf8)<<2]:0xff;
return vpos<193 ? m_screen_location[0x1800|(vpos&0xf8)<<2]:0xff;
}
static ADDRESS_MAP_START (spectrum_128_io, AS_IO, 8, spectrum_state )
@ -239,10 +235,10 @@ static ADDRESS_MAP_START (spectrum_128_io, AS_IO, 8, spectrum_state )
AM_RANGE(0x001f, 0x001f) AM_READ(spectrum_port_1f_r) AM_MIRROR(0xff00)
AM_RANGE(0x007f, 0x007f) AM_READ(spectrum_port_7f_r) AM_MIRROR(0xff00)
AM_RANGE(0x00df, 0x00df) AM_READ(spectrum_port_df_r) AM_MIRROR(0xff00)
AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(spectrum_128_port_7ffd_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x4000, 0x4000) AM_WRITE(spectrum_128_port_7ffd_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x8000, 0x8000) AM_DEVWRITE_LEGACY("ay8912", ay8910_data_w) AM_MIRROR(0x3ffd)
AM_RANGE(0xc000, 0xc000) AM_DEVREADWRITE_LEGACY("ay8912", ay8910_r, ay8910_address_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x0001, 0x0001) AM_READ_LEGACY(spectrum_128_ula_r) AM_MIRROR(0xfffe)
AM_RANGE(0x0001, 0x0001) AM_READ(spectrum_128_ula_r) AM_MIRROR(0xfffe)
ADDRESS_MAP_END
static ADDRESS_MAP_START (spectrum_128_mem, AS_PROGRAM, 8, spectrum_state )
@ -254,7 +250,7 @@ ADDRESS_MAP_END
MACHINE_RESET_MEMBER(spectrum_state,spectrum_128)
{
UINT8 *messram = machine().device<ram_device>(RAM_TAG)->pointer();
UINT8 *messram = m_ram->pointer();
memset(messram,0,128*1024);
/* 0x0000-0x3fff always holds ROM */
@ -270,7 +266,7 @@ MACHINE_RESET_MEMBER(spectrum_state,spectrum_128)
/* set initial ram config */
m_port_7ffd_data = 0;
m_port_1ffd_data = -1;
spectrum_128_update_memory(machine());
spectrum_128_update_memory();
}
/* F4 Character Displayer */

98
src/mess/drivers/specpls3.c
View File

@ -172,51 +172,47 @@ static const int spectrum_plus3_memory_selections[]=
4,7,6,3
};
static WRITE8_HANDLER(spectrum_plus3_port_3ffd_w)
WRITE8_MEMBER( spectrum_state::spectrum_plus3_port_3ffd_w )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
if (state->m_floppy==1)
space.machine().device<upd765a_device>("upd765")->fifo_w(space, 0, data, 0xff);
if (m_floppy==1)
m_upd765->fifo_w(space, 0, data, 0xff);
}
static READ8_HANDLER(spectrum_plus3_port_3ffd_r)
READ8_MEMBER( spectrum_state::spectrum_plus3_port_3ffd_r )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
if (state->m_floppy==0)
if (m_floppy==0)
return 0xff;
else
return space.machine().device<upd765a_device>("upd765")->fifo_r(space, 0, 0xff);
return m_upd765->fifo_r(space, 0, 0xff);
}
static READ8_HANDLER(spectrum_plus3_port_2ffd_r)
READ8_MEMBER( spectrum_state::spectrum_plus3_port_2ffd_r )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
if (state->m_floppy==0)
if (m_floppy==0)
return 0xff;
else
return space.machine().device<upd765a_device>("upd765")->msr_r(space, 0, 0xff);
return m_upd765->msr_r(space, 0, 0xff);
}
void spectrum_plus3_update_memory(running_machine &machine)
void spectrum_state::spectrum_plus3_update_memory()
{
spectrum_state *state = machine.driver_data<spectrum_state>();
address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *messram = machine.device<ram_device>(RAM_TAG)->pointer();
address_space &space = m_maincpu->space(AS_PROGRAM);
UINT8 *messram = m_ram->pointer();
if (state->m_port_7ffd_data & 8)
if (m_port_7ffd_data & 8)
{
logerror("+3 SCREEN 1: BLOCK 7\n");
state->m_screen_location = messram + (7 << 14);
m_screen_location = messram + (7 << 14);
}
else
{
logerror("+3 SCREEN 0: BLOCK 5\n");
state->m_screen_location = messram + (5 << 14);
m_screen_location = messram + (5 << 14);
}
if ((state->m_port_1ffd_data & 0x01) == 0)
if ((m_port_1ffd_data & 0x01) == 0)
{
int ram_page;
unsigned char *ram_data;
@ -226,29 +222,29 @@ void spectrum_plus3_update_memory(running_machine &machine)
int ROMSelection;
/* select ram at 0x0c000-0x0ffff */
ram_page = state->m_port_7ffd_data & 0x07;
ram_page = m_port_7ffd_data & 0x07;
ram_data = messram + (ram_page<<14);
state->membank("bank4")->set_base(ram_data);
membank("bank4")->set_base(ram_data);
logerror("RAM at 0xc000: %02x\n", ram_page);
/* Reset memory between 0x4000 - 0xbfff in case extended paging was being used */
/* Bank 5 in 0x4000 - 0x7fff */
state->membank("bank2")->set_base(messram + (5 << 14));
membank("bank2")->set_base(messram + (5 << 14));
/* Bank 2 in 0x8000 - 0xbfff */
state->membank("bank3")->set_base(messram + (2 << 14));
membank("bank3")->set_base(messram + (2 << 14));
ROMSelection = ((state->m_port_7ffd_data >> 4) & 0x01) |
((state->m_port_1ffd_data >> 1) & 0x02);
ROMSelection = ((m_port_7ffd_data >> 4) & 0x01) |
((m_port_1ffd_data >> 1) & 0x02);
/* rom 0 is editor, rom 1 is syntax, rom 2 is DOS, rom 3 is 48 BASIC */
ChosenROM = machine.root_device().memregion("maincpu")->base() + 0x010000 + (ROMSelection << 14);
ChosenROM = memregion("maincpu")->base() + 0x010000 + (ROMSelection << 14);
state->membank("bank1")->set_base(ChosenROM);
membank("bank1")->set_base(ChosenROM);
space.unmap_write(0x0000, 0x3fff);
logerror("rom switch: %02x\n", ROMSelection);
@ -261,23 +257,23 @@ void spectrum_plus3_update_memory(running_machine &machine)
int MemorySelection;
unsigned char *ram_data;
MemorySelection = (state->m_port_1ffd_data >> 1) & 0x03;
MemorySelection = (m_port_1ffd_data >> 1) & 0x03;
memory_selection = &spectrum_plus3_memory_selections[(MemorySelection << 2)];
ram_data = messram + (memory_selection[0] << 14);
state->membank("bank1")->set_base(ram_data);
membank("bank1")->set_base(ram_data);
/* allow writes to 0x0000-0x03fff */
space.install_write_bank(0x0000, 0x3fff, "bank1");
ram_data = messram + (memory_selection[1] << 14);
state->membank("bank2")->set_base(ram_data);
membank("bank2")->set_base(ram_data);
ram_data = messram + (memory_selection[2] << 14);
state->membank("bank3")->set_base(ram_data);
membank("bank3")->set_base(ram_data);
ram_data = messram + (memory_selection[3] << 14);
state->membank("bank4")->set_base(ram_data);
membank("bank4")->set_base(ram_data);
logerror("extended memory paging: %02x\n", MemorySelection);
}
@ -285,45 +281,41 @@ void spectrum_plus3_update_memory(running_machine &machine)
static WRITE8_HANDLER(spectrum_plus3_port_7ffd_w)
WRITE8_MEMBER( spectrum_state::spectrum_plus3_port_7ffd_w )
{
/* D0-D2: RAM page located at 0x0c000-0x0ffff */
/* D3 - Screen select (screen 0 in ram page 5, screen 1 in ram page 7 */
/* D4 - ROM select - which rom paged into 0x0000-0x03fff */
/* D5 - Disable paging */
spectrum_state *state = space.machine().driver_data<spectrum_state>();
/* disable paging? */
if (state->m_port_7ffd_data & 0x20)
if (m_port_7ffd_data & 0x20)
return;
/* store new state */
state->m_port_7ffd_data = data;
m_port_7ffd_data = data;
/* update memory */
spectrum_plus3_update_memory(space.machine());
spectrum_plus3_update_memory();
}
static WRITE8_HANDLER(spectrum_plus3_port_1ffd_w)
WRITE8_HANDLER( spectrum_state::spectrum_plus3_port_1ffd_w )
{
/* D0-D1: ROM/RAM paging */
/* D2: Affects if d0-d1 work on ram/rom */
/* D3 - Disk motor on/off */
/* D4 - parallel port strobe */
spectrum_state *state = space.machine().driver_data<spectrum_state>();
m_upd765_0->get_device()->mon_w(!BIT(data, 3));
m_upd765_1->get_device()->mon_w(!BIT(data, 3));
space.machine().device<floppy_connector>("upd765:0")->get_device()->mon_w(!BIT(data, 3));
space.machine().device<floppy_connector>("upd765:1")->get_device()->mon_w(!BIT(data, 3));
state->m_port_1ffd_data = data;
m_port_1ffd_data = data;
/* disable paging? */
if ((state->m_port_7ffd_data & 0x20)==0)
if ((m_port_7ffd_data & 0x20)==0)
{
/* no */
spectrum_plus3_update_memory(space.machine());
spectrum_plus3_update_memory();
}
}
@ -333,17 +325,17 @@ static ADDRESS_MAP_START (spectrum_plus3_io, AS_IO, 8, spectrum_state )
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0x0000) AM_READWRITE(spectrum_port_fe_r,spectrum_port_fe_w) AM_MIRROR(0xfffe) AM_MASK(0xffff)
AM_RANGE(0x001f, 0x001f) AM_READ(spectrum_port_1f_r) AM_MIRROR(0xff00)
AM_RANGE(0x4000, 0x4000) AM_WRITE_LEGACY(spectrum_plus3_port_7ffd_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x4000, 0x4000) AM_WRITE(spectrum_plus3_port_7ffd_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x8000, 0x8000) AM_DEVWRITE_LEGACY("ay8912", ay8910_data_w) AM_MIRROR(0x3ffd)
AM_RANGE(0xc000, 0xc000) AM_DEVREADWRITE_LEGACY("ay8912", ay8910_r, ay8910_address_w) AM_MIRROR(0x3ffd)
AM_RANGE(0x1000, 0x1000) AM_WRITE_LEGACY(spectrum_plus3_port_1ffd_w) AM_MIRROR(0x0ffd)
AM_RANGE(0x2000, 0x2000) AM_READ_LEGACY(spectrum_plus3_port_2ffd_r) AM_MIRROR(0x0ffd)
AM_RANGE(0x3000, 0x3000) AM_READWRITE_LEGACY(spectrum_plus3_port_3ffd_r,spectrum_plus3_port_3ffd_w) AM_MIRROR(0x0ffd)
AM_RANGE(0x1000, 0x1000) AM_WRITE(spectrum_plus3_port_1ffd_w) AM_MIRROR(0x0ffd)
AM_RANGE(0x2000, 0x2000) AM_READ(spectrum_plus3_port_2ffd_r) AM_MIRROR(0x0ffd)
AM_RANGE(0x3000, 0x3000) AM_READWRITE(spectrum_plus3_port_3ffd_r,spectrum_plus3_port_3ffd_w) AM_MIRROR(0x0ffd)
ADDRESS_MAP_END
MACHINE_RESET_MEMBER(spectrum_state,spectrum_plus3)
{
UINT8 *messram = machine().device<ram_device>(RAM_TAG)->pointer();
UINT8 *messram = m_ram->pointer();
memset(messram,0,128*1024);
MACHINE_RESET_CALL_MEMBER(spectrum);
@ -351,7 +343,7 @@ MACHINE_RESET_MEMBER(spectrum_state,spectrum_plus3)
/* Initial configuration */
m_port_7ffd_data = 0;
m_port_1ffd_data = 0;
spectrum_plus3_update_memory(machine());
spectrum_plus3_update_memory();
}
DRIVER_INIT_MEMBER(spectrum_state,plus3)

56
src/mess/drivers/spectrum.c
View File

@ -275,13 +275,8 @@ SamRam
#include "emu.h"
#include "cpu/z80/z80.h"
#include "sound/speaker.h"
#include "sound/wave.h"
#include "includes/spectrum.h"
#include "imagedev/snapquik.h"
#include "imagedev/cartslot.h"
#include "imagedev/cassette.h"
#include "machine/ram.h"
#include "formats/tzx_cas.h"
#include "formats/spec_snqk.h"
@ -298,7 +293,6 @@ SamRam
WRITE8_MEMBER(spectrum_state::spectrum_port_fe_w)
{
device_t *speaker = machine().device(SPEAKER_TAG);
unsigned char Changed;
Changed = m_port_fe_data^data;
@ -306,19 +300,19 @@ WRITE8_MEMBER(spectrum_state::spectrum_port_fe_w)
/* border colour changed? */
if ((Changed & 0x07)!=0)
{
spectrum_UpdateBorderBitmap(machine());
spectrum_UpdateBorderBitmap();
}
if ((Changed & (1<<4))!=0)
{
/* DAC output state */
speaker_level_w(speaker,(data>>4) & 0x01);
speaker_level_w(m_speaker,(data>>4) & 0x01);
}
if ((Changed & (1<<3))!=0)
{
/* write cassette data */
machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & (1<<3)) ? -1.0 : +1.0);
m_cassette->output((data & (1<<3)) ? -1.0 : +1.0);
}
m_port_fe_data = data;
@ -333,16 +327,16 @@ READ8_MEMBER(spectrum_state::spectrum_port_fe_r)
int lines = offset >> 8;
int data = 0xff;
int cs_extra1 = ioport("PLUS0")->read_safe(0xff) & 0x1f;
int cs_extra2 = ioport("PLUS1")->read_safe(0xff) & 0x1f;
int cs_extra3 = ioport("PLUS2")->read_safe(0xff) & 0x1f;
int ss_extra1 = ioport("PLUS3")->read_safe(0xff) & 0x1f;
int ss_extra2 = ioport("PLUS4")->read_safe(0xff) & 0x1f;
int cs_extra1 = m_io_plus0 ? m_io_plus0->read() & 0x1f : 0x1f;
int cs_extra2 = m_io_plus1 ? m_io_plus1->read() & 0x1f : 0x1f;
int cs_extra3 = m_io_plus2 ? m_io_plus2->read() & 0x1f : 0x1f;
int ss_extra1 = m_io_plus3 ? m_io_plus3->read() & 0x1f : 0x1f;
int ss_extra2 = m_io_plus4 ? m_io_plus4->read() & 0x1f : 0x1f;
/* Caps - V */
if ((lines & 1) == 0)
{
data &= ioport("LINE0")->read();
data &= m_io_line0->read();
/* CAPS for extra keys */
if (cs_extra1 != 0x1f || cs_extra2 != 0x1f || cs_extra3 != 0x1f)
data &= ~0x01;
@ -350,32 +344,32 @@ READ8_MEMBER(spectrum_state::spectrum_port_fe_r)
/* A - G */
if ((lines & 2) == 0)
data &= ioport("LINE1")->read();
data &= m_io_line1->read();
/* Q - T */
if ((lines & 4) == 0)
data &= ioport("LINE2")->read();
data &= m_io_line2->read();
/* 1 - 5 */
if ((lines & 8) == 0)
data &= ioport("LINE3")->read() & cs_extra1;
data &= m_io_line3->read() & cs_extra1;
/* 6 - 0 */
if ((lines & 16) == 0)
data &= ioport("LINE4")->read() & cs_extra2;
data &= m_io_line4->read() & cs_extra2;
/* Y - P */
if ((lines & 32) == 0)
data &= ioport("LINE5")->read() & ss_extra1;
data &= m_io_line5->read() & ss_extra1;
/* H - Enter */
if ((lines & 64) == 0)
data &= ioport("LINE6")->read();
data &= m_io_line6->read();
/* B - Space */
if ((lines & 128) == 0)
{
data &= ioport("LINE7")->read() & cs_extra3 & ss_extra2;
data &= m_io_line7->read() & cs_extra3 & ss_extra2;
/* SYMBOL SHIFT for extra keys */
if (ss_extra1 != 0x1f || ss_extra2 != 0x1f)
data &= ~0x02;
@ -384,14 +378,14 @@ READ8_MEMBER(spectrum_state::spectrum_port_fe_r)
data |= (0xe0); /* Set bits 5-7 - as reset above */
/* cassette input from wav */
if ((machine().device<cassette_image_device>(CASSETTE_TAG))->input() > 0.0038 )
if (m_cassette->input() > 0.0038 )
{
data &= ~0x40;
}
/* Issue 2 Spectrums default to having bits 5, 6 & 7 set.
Issue 3 Spectrums default to having bits 5 & 7 set and bit 6 reset. */
if (ioport("CONFIG")->read() & 0x80)
if (m_io_config->read() & 0x80)
data ^= (0x40);
return data;
@ -400,19 +394,19 @@ READ8_MEMBER(spectrum_state::spectrum_port_fe_r)
/* kempston joystick interface */
READ8_MEMBER(spectrum_state::spectrum_port_1f_r)
{
return ioport("KEMPSTON")->read() & 0x1f;
return m_io_kempston->read() & 0x1f;
}
/* fuller joystick interface */
READ8_MEMBER(spectrum_state::spectrum_port_7f_r)
{
return ioport("FULLER")->read() | (0xff^0x8f);
return m_io_fuller->read() | (0xff^0x8f);
}
/* mikrogen joystick interface */
READ8_MEMBER(spectrum_state::spectrum_port_df_r)
{
return ioport("MIKROGEN")->read() | (0xff^0x1f);
return m_io_mikrogen->read() | (0xff^0x1f);
}
READ8_MEMBER(spectrum_state::spectrum_port_ula_r)
@ -613,9 +607,9 @@ INPUT_PORTS_END
DRIVER_INIT_MEMBER(spectrum_state,spectrum)
{
address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
address_space &space = m_maincpu->space(AS_PROGRAM);
switch (machine().device<ram_device>(RAM_TAG)->size())
switch (m_ram->size())
{
case 48*1024:
space.install_ram(0x8000, 0xffff, NULL); // Fall through
@ -677,7 +671,7 @@ DEVICE_IMAGE_LOAD_MEMBER( spectrum_state,spectrum_cart )
return IMAGE_INIT_FAIL;
}
if (image.fread(image.device().machine().root_device().memregion("maincpu")->base(), filesize) != filesize)
if (image.fread(memregion("maincpu")->base(), filesize) != filesize)
{
image.seterror(IMAGE_ERROR_UNSPECIFIED, "Error loading file");
return IMAGE_INIT_FAIL;
@ -686,7 +680,7 @@ DEVICE_IMAGE_LOAD_MEMBER( spectrum_state,spectrum_cart )
else
{
filesize = image.get_software_region_length("rom");
memcpy(image.device().machine().root_device().memregion("maincpu")->base(), image.get_software_region("rom"), filesize);
memcpy(memregion("maincpu")->base(), image.get_software_region("rom"), filesize);
}
return IMAGE_INIT_PASS;
}

149
src/mess/drivers/timex.c
View File

@ -169,29 +169,23 @@ static const ay8910_interface spectrum_ay_interface =
/* TS2048 specific functions */
static READ8_HANDLER(ts2068_port_f4_r)
READ8_MEMBER( spectrum_state::ts2068_port_f4_r )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
return state->m_port_f4_data;
return m_port_f4_data;
}
static WRITE8_HANDLER(ts2068_port_f4_w)
WRITE8_MEMBER( spectrum_state::ts2068_port_f4_w )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
state->m_port_f4_data = data;
ts2068_update_memory(space.machine());
m_port_f4_data = data;
ts2068_update_memory();
}
static READ8_HANDLER(ts2068_port_ff_r)
READ8_MEMBER( spectrum_state::ts2068_port_ff_r )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
return state->m_port_ff_data;
return m_port_ff_data;
}
static WRITE8_HANDLER(ts2068_port_ff_w)
WRITE8_MEMBER( spectrum_state::ts2068_port_ff_w )
{
/* Bits 0-2 Video Mode Select
Bits 3-5 64 column mode ink/paper selection
@ -199,10 +193,8 @@ static WRITE8_HANDLER(ts2068_port_ff_w)
Bit 6 17ms Interrupt Inhibit
Bit 7 Cartridge (0) / EXROM (1) select
*/
spectrum_state *state = space.machine().driver_data<spectrum_state>();
state->m_port_ff_data = data;
ts2068_update_memory(space.machine());
m_port_ff_data = data;
ts2068_update_memory();
logerror("Port %04x write %02x\n", offset, data);
}
@ -224,33 +216,32 @@ static WRITE8_HANDLER(ts2068_port_ff_w)
* at the same time.
*
*******************************************************************/
void ts2068_update_memory(running_machine &machine)
void spectrum_state::ts2068_update_memory()
{
spectrum_state *state = machine.driver_data<spectrum_state>();
UINT8 *messram = machine.device<ram_device>(RAM_TAG)->pointer();
address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *messram = m_ram->pointer();
address_space &space = m_maincpu->space(AS_PROGRAM);
unsigned char *ChosenROM, *ExROM;
const timex_cart_t *timex_cart = timex_cart_data();
int timex_cart_type = timex_cart->type;
UINT8 timex_cart_chunks = timex_cart->chunks;
UINT8 *DOCK = timex_cart->data;
ExROM = state->memregion("maincpu")->base() + 0x014000;
ExROM = memregion("maincpu")->base() + 0x014000;
if (state->m_port_f4_data & 0x01)
if (m_port_f4_data & 0x01)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
space.install_read_bank(0x0000, 0x1fff, "bank1");
space.unmap_write(0x0000, 0x1fff);
state->membank("bank1")->set_base(ExROM);
membank("bank1")->set_base(ExROM);
logerror("0000-1fff EXROM\n");
}
else
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank1")->set_base(DOCK);
membank("bank1")->set_base(DOCK);
space.install_read_bank(0x0000, 0x1fff, "bank1");
if (timex_cart_chunks&0x01)
space.install_write_bank(0x0000, 0x1fff, "bank9");
@ -269,18 +260,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
ChosenROM = machine.root_device().memregion("maincpu")->base() + 0x010000;
state->membank("bank1")->set_base(ChosenROM);
ChosenROM = memregion("maincpu")->base() + 0x010000;
membank("bank1")->set_base(ChosenROM);
space.install_read_bank(0x0000, 0x1fff, "bank1");
space.unmap_write(0x0000, 0x1fff);
logerror("0000-1fff HOME\n");
}
if (state->m_port_f4_data & 0x02)
if (m_port_f4_data & 0x02)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank2")->set_base(ExROM);
membank("bank2")->set_base(ExROM);
space.install_read_bank(0x2000, 0x3fff, "bank2");
space.unmap_write(0x2000, 0x3fff);
logerror("2000-3fff EXROM\n");
@ -289,7 +280,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank2")->set_base(DOCK+0x2000);
membank("bank2")->set_base(DOCK+0x2000);
space.install_read_bank(0x2000, 0x3fff, "bank2");
if (timex_cart_chunks&0x02)
space.install_write_bank(0x2000, 0x3fff, "bank10");
@ -307,18 +298,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
ChosenROM = machine.root_device().memregion("maincpu")->base() + 0x012000;
state->membank("bank2")->set_base(ChosenROM);
ChosenROM = memregion("maincpu")->base() + 0x012000;
membank("bank2")->set_base(ChosenROM);
space.install_read_bank(0x2000, 0x3fff, "bank2");
space.unmap_write(0x2000, 0x3fff);
logerror("2000-3fff HOME\n");
}
if (state->m_port_f4_data & 0x04)
if (m_port_f4_data & 0x04)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank3")->set_base(ExROM);
membank("bank3")->set_base(ExROM);
space.install_read_bank(0x4000, 0x5fff, "bank3");
space.unmap_write(0x4000, 0x5fff);
logerror("4000-5fff EXROM\n");
@ -327,7 +318,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank3")->set_base(DOCK+0x4000);
membank("bank3")->set_base(DOCK+0x4000);
space.install_read_bank(0x4000, 0x5fff, "bank3");
if (timex_cart_chunks&0x04)
space.install_write_bank(0x4000, 0x5fff, "bank11");
@ -344,18 +335,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank3")->set_base(messram);
state->membank("bank11")->set_base(messram);
membank("bank3")->set_base(messram);
membank("bank11")->set_base(messram);
space.install_read_bank(0x4000, 0x5fff, "bank3");
space.install_write_bank(0x4000, 0x5fff, "bank11");
logerror("4000-5fff RAM\n");
}
if (state->m_port_f4_data & 0x08)
if (m_port_f4_data & 0x08)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank4")->set_base(ExROM);
membank("bank4")->set_base(ExROM);
space.install_read_bank(0x6000, 0x7fff, "bank4");
space.unmap_write(0x6000, 0x7fff);
logerror("6000-7fff EXROM\n");
@ -364,7 +355,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank4")->set_base(DOCK+0x6000);
membank("bank4")->set_base(DOCK+0x6000);
space.install_read_bank(0x6000, 0x7fff, "bank4");
if (timex_cart_chunks&0x08)
space.install_write_bank(0x6000, 0x7fff, "bank12");
@ -381,18 +372,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank4")->set_base(messram + 0x2000);
state->membank("bank12")->set_base(messram + 0x2000);
membank("bank4")->set_base(messram + 0x2000);
membank("bank12")->set_base(messram + 0x2000);
space.install_read_bank(0x6000, 0x7fff, "bank4");
space.install_write_bank(0x6000, 0x7fff, "bank12");
logerror("6000-7fff RAM\n");
}
if (state->m_port_f4_data & 0x10)
if (m_port_f4_data & 0x10)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank5")->set_base(ExROM);
membank("bank5")->set_base(ExROM);
space.install_read_bank(0x8000, 0x9fff, "bank5");
space.unmap_write(0x8000, 0x9fff);
logerror("8000-9fff EXROM\n");
@ -401,7 +392,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank5")->set_base(DOCK+0x8000);
membank("bank5")->set_base(DOCK+0x8000);
space.install_read_bank(0x8000, 0x9fff,"bank5");
if (timex_cart_chunks&0x10)
space.install_write_bank(0x8000, 0x9fff,"bank13");
@ -418,18 +409,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank5")->set_base(messram + 0x4000);
state->membank("bank13")->set_base(messram + 0x4000);
membank("bank5")->set_base(messram + 0x4000);
membank("bank13")->set_base(messram + 0x4000);
space.install_read_bank(0x8000, 0x9fff,"bank5");
space.install_write_bank(0x8000, 0x9fff,"bank13");
logerror("8000-9fff RAM\n");
}
if (state->m_port_f4_data & 0x20)
if (m_port_f4_data & 0x20)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank6")->set_base(ExROM);
membank("bank6")->set_base(ExROM);
space.install_read_bank(0xa000, 0xbfff, "bank6");
space.unmap_write(0xa000, 0xbfff);
logerror("a000-bfff EXROM\n");
@ -438,7 +429,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank6")->set_base(DOCK+0xa000);
membank("bank6")->set_base(DOCK+0xa000);
space.install_read_bank(0xa000, 0xbfff, "bank6");
if (timex_cart_chunks&0x20)
space.install_write_bank(0xa000, 0xbfff, "bank14");
@ -456,18 +447,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank6")->set_base(messram + 0x6000);
state->membank("bank14")->set_base(messram + 0x6000);
membank("bank6")->set_base(messram + 0x6000);
membank("bank14")->set_base(messram + 0x6000);
space.install_read_bank(0xa000, 0xbfff, "bank6");
space.install_write_bank(0xa000, 0xbfff, "bank14");
logerror("a000-bfff RAM\n");
}
if (state->m_port_f4_data & 0x40)
if (m_port_f4_data & 0x40)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank7")->set_base(ExROM);
membank("bank7")->set_base(ExROM);
space.install_read_bank(0xc000, 0xdfff, "bank7");
space.unmap_write(0xc000, 0xdfff);
logerror("c000-dfff EXROM\n");
@ -476,7 +467,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank7")->set_base(DOCK+0xc000);
membank("bank7")->set_base(DOCK+0xc000);
space.install_read_bank(0xc000, 0xdfff, "bank7");
if (timex_cart_chunks&0x40)
space.install_write_bank(0xc000, 0xdfff, "bank15");
@ -493,18 +484,18 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank7")->set_base(messram + 0x8000);
state->membank("bank15")->set_base(messram + 0x8000);
membank("bank7")->set_base(messram + 0x8000);
membank("bank15")->set_base(messram + 0x8000);
space.install_read_bank(0xc000, 0xdfff, "bank7");
space.install_write_bank(0xc000, 0xdfff, "bank15");
logerror("c000-dfff RAM\n");
}
if (state->m_port_f4_data & 0x80)
if (m_port_f4_data & 0x80)
{
if (state->m_port_ff_data & 0x80)
if (m_port_ff_data & 0x80)
{
state->membank("bank8")->set_base(ExROM);
membank("bank8")->set_base(ExROM);
space.install_read_bank(0xe000, 0xffff, "bank8");
space.unmap_write(0xe000, 0xffff);
logerror("e000-ffff EXROM\n");
@ -513,7 +504,7 @@ void ts2068_update_memory(running_machine &machine)
{
if (timex_cart_type == TIMEX_CART_DOCK)
{
state->membank("bank8")->set_base(DOCK+0xe000);
membank("bank8")->set_base(DOCK+0xe000);
space.install_read_bank(0xe000, 0xffff, "bank8");
if (timex_cart_chunks&0x80)
space.install_write_bank(0xe000, 0xffff, "bank16");
@ -530,8 +521,8 @@ void ts2068_update_memory(running_machine &machine)
}
else
{
state->membank("bank8")->set_base(messram + 0xa000);
state->membank("bank16")->set_base(messram + 0xa000);
membank("bank8")->set_base(messram + 0xa000);
membank("bank16")->set_base(messram + 0xa000);
space.install_read_bank(0xe000, 0xffff, "bank8");
space.install_write_bank(0xe000, 0xffff, "bank16");
logerror("e000-ffff RAM\n");
@ -542,11 +533,11 @@ static ADDRESS_MAP_START(ts2068_io, AS_IO, 8, spectrum_state )
AM_RANGE(0x1f, 0x1f) AM_READ(spectrum_port_1f_r ) AM_MIRROR(0xff00)
AM_RANGE(0x7f, 0x7f) AM_READ(spectrum_port_7f_r ) AM_MIRROR(0xff00)
AM_RANGE(0xdf, 0xdf) AM_READ(spectrum_port_df_r ) AM_MIRROR(0xff00)
AM_RANGE(0xf4, 0xf4) AM_READWRITE_LEGACY(ts2068_port_f4_r,ts2068_port_f4_w ) AM_MIRROR(0xff00)
AM_RANGE(0xf4, 0xf4) AM_READWRITE(ts2068_port_f4_r,ts2068_port_f4_w ) AM_MIRROR(0xff00)
AM_RANGE(0xf5, 0xf5) AM_DEVWRITE_LEGACY("ay8912", ay8910_address_w ) AM_MIRROR(0xff00)
AM_RANGE(0xf6, 0xf6) AM_DEVREADWRITE_LEGACY("ay8912", ay8910_r, ay8910_data_w ) AM_MIRROR(0xff00)
AM_RANGE(0xfe, 0xfe) AM_READWRITE(spectrum_port_fe_r,spectrum_port_fe_w ) AM_MIRROR(0xff00) AM_MASK(0xffff)
AM_RANGE(0xff, 0xff) AM_READWRITE_LEGACY(ts2068_port_ff_r,ts2068_port_ff_w ) AM_MIRROR(0xff00)
AM_RANGE(0xff, 0xff) AM_READWRITE(ts2068_port_ff_r,ts2068_port_ff_w ) AM_MIRROR(0xff00)
ADDRESS_MAP_END
static ADDRESS_MAP_START(ts2068_mem, AS_PROGRAM, 8, spectrum_state )
@ -565,7 +556,7 @@ MACHINE_RESET_MEMBER(spectrum_state,ts2068)
{
m_port_ff_data = 0;
m_port_f4_data = 0;
ts2068_update_memory(machine());
ts2068_update_memory();
MACHINE_RESET_CALL_MEMBER(spectrum);
}
@ -575,11 +566,9 @@ MACHINE_RESET_MEMBER(spectrum_state,ts2068)
/* TC2048 specific functions */
static WRITE8_HANDLER( tc2048_port_ff_w )
WRITE8_MEMBER( spectrum_state::tc2048_port_ff_w )
{
spectrum_state *state = space.machine().driver_data<spectrum_state>();
state->m_port_ff_data = data;
m_port_ff_data = data;
logerror("Port %04x write %02x\n", offset, data);
}
@ -588,7 +577,7 @@ static ADDRESS_MAP_START(tc2048_io, AS_IO, 8, spectrum_state )
AM_RANGE(0x1f, 0x1f) AM_READ(spectrum_port_1f_r) AM_MIRROR(0xff00)
AM_RANGE(0x7f, 0x7f) AM_READ(spectrum_port_7f_r) AM_MIRROR(0xff00)
AM_RANGE(0xdf, 0xdf) AM_READ(spectrum_port_df_r) AM_MIRROR(0xff00)
AM_RANGE(0xff, 0xff) AM_READWRITE_LEGACY(ts2068_port_ff_r,tc2048_port_ff_w) AM_MIRROR(0xff00)
AM_RANGE(0xff, 0xff) AM_READWRITE(ts2068_port_ff_r,tc2048_port_ff_w) AM_MIRROR(0xff00)
ADDRESS_MAP_END
static ADDRESS_MAP_START(tc2048_mem, AS_PROGRAM, 8, spectrum_state )
@ -598,7 +587,7 @@ ADDRESS_MAP_END
MACHINE_RESET_MEMBER(spectrum_state,tc2048)
{
UINT8 *messram = machine().device<ram_device>(RAM_TAG)->pointer();
UINT8 *messram = m_ram->pointer();
membank("bank1")->set_base(messram);
membank("bank2")->set_base(messram);

8
src/mess/formats/spec_snqk.c
View File

@ -86,7 +86,7 @@ static void spectrum_update_paging(running_machine &machine)
if (state->m_port_7ffd_data == -1)
return;
if (state->m_port_1ffd_data == -1)
spectrum_128_update_memory(machine);
state->spectrum_128_update_memory();
else
{
@ -95,7 +95,7 @@ static void spectrum_update_paging(running_machine &machine)
state->m_port_1ffd_data = 0x04;
else
state->m_port_1ffd_data = 0x00;
spectrum_plus3_update_memory(machine);
state->spectrum_plus3_update_memory();
}
}
@ -2440,13 +2440,13 @@ void spectrum_setup_z80(running_machine &machine, UINT8 *snapdata, UINT32 snapsi
{
state->m_port_f4_data = 0x03;
state->m_port_ff_data = 0x00;
ts2068_update_memory(machine);
state->ts2068_update_memory();
}
if (z80_type == SPECTRUM_Z80_SNAPSHOT_TS2068 && !strcmp(machine.system().name,"ts2068"))
{
state->m_port_f4_data = snapdata[35];
state->m_port_ff_data = snapdata[36];
ts2068_update_memory(machine);
state->ts2068_update_memory();
}
}
}

105
src/mess/includes/spectrum.h
View File

@ -10,6 +10,9 @@
#include "imagedev/snapquik.h"
#include "imagedev/cartslot.h"
#include "machine/upd765.h"
#include "imagedev/cassette.h"
#include "sound/speaker.h"
#include "machine/ram.h"
/* Spectrum crystals */
@ -70,8 +73,36 @@ class spectrum_state : public driver_device
{
public:
spectrum_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag) ,
m_video_ram(*this, "video_ram"){ }
: driver_device(mconfig, type, tag)
, m_video_ram(*this, "video_ram")
, m_maincpu(*this, "maincpu")
, m_cassette(*this, CASSETTE_TAG)
, m_ram(*this, RAM_TAG)
, m_speaker(*this, SPEAKER_TAG)
, m_upd765(*this, "upd765")
, m_upd765_0(*this, "upd765:0")
, m_upd765_1(*this, "upd765:1")
, m_io_line0(*this, "LINE0")
, m_io_line1(*this, "LINE1")
, m_io_line2(*this, "LINE2")
, m_io_line3(*this, "LINE3")
, m_io_line4(*this, "LINE4")
, m_io_line5(*this, "LINE5")
, m_io_line6(*this, "LINE6")
, m_io_line7(*this, "LINE7")
, m_io_nmi(*this, "NMI")
, m_io_config(*this, "CONFIG")
, m_io_joy_intf(*this, "JOY_INTF")
, m_io_kempston(*this, "KEMPSTON")
, m_io_fuller(*this, "FULLER")
, m_io_mikrogen(*this, "MIKROGEN")
, m_io_plus0(*this, "PLUS0")
, m_io_plus1(*this, "PLUS1")
, m_io_plus2(*this, "PLUS2")
, m_io_plus3(*this, "PLUS3")
, m_io_plus4(*this, "PLUS4")
{ }
int m_port_fe_data;
int m_port_7ffd_data;
@ -106,6 +137,22 @@ public:
DECLARE_READ8_MEMBER(spectrum_port_7f_r);
DECLARE_READ8_MEMBER(spectrum_port_df_r);
DECLARE_READ8_MEMBER(spectrum_port_ula_r);
DECLARE_WRITE8_MEMBER(spectrum_128_port_7ffd_w);
DECLARE_READ8_MEMBER(spectrum_128_ula_r);
DECLARE_WRITE8_MEMBER(spectrum_plus3_port_3ffd_w);
DECLARE_READ8_MEMBER(spectrum_plus3_port_3ffd_r);
DECLARE_READ8_MEMBER(spectrum_plus3_port_2ffd_r);
DECLARE_WRITE8_MEMBER(spectrum_plus3_port_7ffd_w);
DECLARE_WRITE8_MEMBER(spectrum_plus3_port_1ffd_w);
DECLARE_READ8_MEMBER(ts2068_port_f4_r);
DECLARE_WRITE8_MEMBER(ts2068_port_f4_w);
DECLARE_READ8_MEMBER(ts2068_port_ff_r);
DECLARE_WRITE8_MEMBER(ts2068_port_ff_w);
DECLARE_WRITE8_MEMBER(tc2048_port_ff_w);
DECLARE_DRIVER_INIT(spectrum);
DECLARE_DRIVER_INIT(plus2);
DECLARE_DRIVER_INIT(plus3);
@ -131,6 +178,42 @@ public:
bitmap_ind16 m_border_bitmap;
DECLARE_FLOPPY_FORMATS( floppy_formats );
void spectrum_128_update_memory();
void spectrum_plus3_update_memory();
void ts2068_update_memory();
protected:
required_device<cpu_device> m_maincpu;
required_device<cassette_image_device> m_cassette;
required_device<ram_device> m_ram;
required_device<device_t> m_speaker;
optional_device<upd765a_device> m_upd765;
optional_device<floppy_connector> m_upd765_0;
optional_device<floppy_connector> m_upd765_1;
// Regular spectrum ports; marked as optional because of other subclasses
optional_ioport m_io_line0;
optional_ioport m_io_line1;
optional_ioport m_io_line2;
optional_ioport m_io_line3;
optional_ioport m_io_line4;
optional_ioport m_io_line5;
optional_ioport m_io_line6;
optional_ioport m_io_line7;
optional_ioport m_io_nmi;
optional_ioport m_io_config;
optional_ioport m_io_joy_intf;
optional_ioport m_io_kempston;
optional_ioport m_io_fuller;
optional_ioport m_io_mikrogen;
// Plus ports
optional_ioport m_io_plus0;
optional_ioport m_io_plus1;
optional_ioport m_io_plus2;
optional_ioport m_io_plus3;
optional_ioport m_io_plus4;
void spectrum_UpdateBorderBitmap();
};
@ -141,26 +224,8 @@ INPUT_PORTS_EXTERN( spec_plus );
MACHINE_CONFIG_EXTERN( spectrum );
/*----------- defined in drivers/spec128.c -----------*/
MACHINE_CONFIG_EXTERN( spectrum_128 );
void spectrum_128_update_memory(running_machine &machine);
/*----------- defined in drivers/specpls3.c -----------*/
void spectrum_plus3_update_memory(running_machine &machine);
/*----------- defined in drivers/timex.c -----------*/
void ts2068_update_memory(running_machine &machine);
/*----------- defined in video/spectrum.c -----------*/
void spectrum_UpdateBorderBitmap(running_machine &machine);
#endif /* __SPECTRUM_H__ */

63
src/mess/video/spectrum.c
View File

@ -67,7 +67,7 @@ void spectrum_state::screen_eof_spectrum(screen_device &screen, bool state)
}
spectrum_UpdateBorderBitmap(machine());
spectrum_UpdateBorderBitmap();
}
}
@ -181,55 +181,44 @@ PALETTE_INIT_MEMBER(spectrum_state,spectrum)
/* The code below is just a per-pixel 'partial update' for the border */
INLINE void spectrum_GetNextPos(running_machine &machine, unsigned int &x, unsigned int &y)
void spectrum_state::spectrum_UpdateBorderBitmap()
{
spectrum_state *state = machine.driver_data<spectrum_state>();
int width = state->m_border_bitmap.width();
int height = state->m_border_bitmap.height();
unsigned int x = machine().primary_screen->hpos();
unsigned int y = machine().primary_screen->vpos();
int width = m_border_bitmap.width();
int height = m_border_bitmap.height();
x += 1;
if (x>width)
if (m_border_bitmap.valid())
{
x = 0;
y += 1;
int colour = m_port_fe_data & 0x07;
if (y>height)
{
y = 0;
}
}
}
void spectrum_UpdateBorderBitmap(running_machine &machine)
{
spectrum_state *state = machine.driver_data<spectrum_state>();
unsigned int x = machine.primary_screen->hpos();
unsigned int y = machine.primary_screen->vpos();
int width = state->m_border_bitmap.width();
int height = state->m_border_bitmap.height();
if (state->m_border_bitmap.valid())
{
int colour = state->m_port_fe_data & 0x07;
//printf("update border from %d,%d to %d,%d\n", state->m_previous_border_x, state->m_previous_border_y, x, y);
//printf("update border from %d,%d to %d,%d\n", m_previous_border_x, m_previous_border_y, x, y);
do
{
if (state->m_previous_border_y < height)
if (m_previous_border_y < height)
{
UINT16* bm = &state->m_border_bitmap.pix16(state->m_previous_border_y);
UINT16* bm = &m_border_bitmap.pix16(m_previous_border_y);
if (state->m_previous_border_x < width)
bm[state->m_previous_border_x] = colour;
if (m_previous_border_x < width)
bm[m_previous_border_x] = colour;
}
spectrum_GetNextPos(machine, state->m_previous_border_x, state->m_previous_border_y);
m_previous_border_x += 1;
if (m_previous_border_x > width)
{
m_previous_border_x = 0;
m_previous_border_y += 1;
if (m_previous_border_y > height)
{
m_previous_border_y = 0;
}
}
}
while (!((state->m_previous_border_x == x) && (state->m_previous_border_y == y)));
while (!((m_previous_border_x == x) && (m_previous_border_y == y)));
}
else