Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-29 09:03:08 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

still more cleanup and more efficient outputs (nw)

Browse Source
This commit is contained in:
Vas Crabb 2018-03-04 21:50:21 +11:00
parent d307d8d8a2
commit c24ce82371
11 changed files with 360 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
src/mame/drivers/glasgow.cpp
View File

@ -59,45 +59,39 @@ public:
, m_maincpu(*this, "maincpu")
, m_beep(*this, "beeper")
, m_keyboard(*this, "LINE.%u", 0)
, m_pieces(*this, "P%u", 0U)
, m_leds(*this, "led%u", 0U)
, m_digits(*this, "digit%u", 0U)
{ }
void glasgow(machine_config &config);
void amsterd(machine_config &config);
void dallas32(machine_config &config);
protected:
DECLARE_WRITE16_MEMBER(glasgow_lcd_w);
DECLARE_WRITE16_MEMBER(glasgow_lcd_flag_w);
DECLARE_WRITE8_MEMBER(glasgow_lcd_w);
DECLARE_WRITE8_MEMBER(glasgow_lcd_flag_w);
DECLARE_READ16_MEMBER(glasgow_keys_r);
DECLARE_WRITE16_MEMBER(glasgow_keys_w);
DECLARE_READ16_MEMBER(glasgow_board_r);
DECLARE_WRITE16_MEMBER(glasgow_board_w);
DECLARE_WRITE16_MEMBER(glasgow_beeper_w);
DECLARE_READ16_MEMBER(read_board);
DECLARE_WRITE16_MEMBER(write_board);
DECLARE_WRITE16_MEMBER(write_beeper);
DECLARE_WRITE16_MEMBER(write_lcd);
DECLARE_WRITE16_MEMBER(write_lcd_flag);
DECLARE_WRITE16_MEMBER(write_irq_flag);
DECLARE_READ16_MEMBER(read_newkeys16);
DECLARE_WRITE32_MEMBER(write_beeper32);
DECLARE_READ32_MEMBER(read_board32);
DECLARE_WRITE32_MEMBER(write_board32);
DECLARE_WRITE32_MEMBER(write_keys32);
DECLARE_WRITE32_MEMBER(write_lcd32);
DECLARE_WRITE32_MEMBER(write_lcd_flag32);
DECLARE_READ32_MEMBER(read_newkeys32);
TIMER_DEVICE_CALLBACK_MEMBER(update_nmi);
TIMER_DEVICE_CALLBACK_MEMBER(update_nmi32);
DECLARE_MACHINE_START(dallas32);
DECLARE_MACHINE_START(glasgow);
DECLARE_MACHINE_RESET(glasgow);
void amsterd_mem(address_map &map);
void dallas32_mem(address_map &map);
virtual void machine_start() override;
virtual void machine_reset() override;
static uint8_t pos_to_num( uint8_t );
void set_board();
void glasgow_pieces_w();
void glasgow_mem(address_map &map);
private:
required_device<cpu_device> m_maincpu;
required_device<beep_device> m_beep;
required_ioport_array<8> m_keyboard;
output_finder<64> m_pieces;
output_finder<64> m_leds;
output_finder<4> m_digits;
uint8_t m_lcd_shift_counter;
uint8_t m_led7;
uint8_t m_key_select;
@ -111,25 +105,40 @@ private:
uint16_t m_Line18_REED;
uint8_t m_selected[2];
uint8_t pos_to_num( uint8_t );
void set_board( );
void glasgow_pieces_w( );
required_device<cpu_device> m_maincpu;
required_device<beep_device> m_beep;
required_ioport_array<8> m_keyboard;
private:
struct BOARD_FIELD { uint8_t field, piece; };
BOARD_FIELD m_board[8][8];
static const BOARD_FIELD s_start_board[8][8];
};
struct BOARD_FIELD // FIXME: global structure
class amsterd_state : public glasgow_state
{
uint8_t field;
uint8_t piece;
public:
using glasgow_state::glasgow_state;
void amsterd(machine_config &config);
void dallas32(machine_config &config);
protected:
DECLARE_WRITE8_MEMBER(write_lcd);
DECLARE_WRITE8_MEMBER(write_lcd_flag);
DECLARE_WRITE8_MEMBER(write_beeper);
DECLARE_READ16_MEMBER(read_board);
DECLARE_WRITE8_MEMBER(write_board);
DECLARE_WRITE16_MEMBER(write_lcd_invert);
DECLARE_READ8_MEMBER(read_newkeys);
DECLARE_READ32_MEMBER(read_board32);
DECLARE_WRITE32_MEMBER(write_keys32);
TIMER_DEVICE_CALLBACK_MEMBER(update_nmi32);
void amsterd_mem(address_map &map);
void dallas32_mem(address_map &map);
};
BOARD_FIELD l_board[8][8]; // FIXME: mutable global state
/* starts at bottom left corner */
const BOARD_FIELD l_start_board[8][8] =
const glasgow_state::BOARD_FIELD glasgow_state::s_start_board[8][8] =
{
{ {7,10}, {6,8}, {5,9}, {4,11}, {3,12}, {2,9}, {1,8}, {0,10} },
{ {15,7}, {14,7}, {13,7}, {12,7}, { 11,7}, {10,7}, {9,7}, {8,7} },
@ -143,62 +152,52 @@ const BOARD_FIELD l_start_board[8][8] =
{ {63,4}, {62,2}, {61,3}, {60,5}, {59,6}, {58,3}, {57,2}, {56,4} }
};
uint8_t glasgow_state::pos_to_num( uint8_t val )
uint8_t glasgow_state::pos_to_num(uint8_t val)
{
switch (val)
{
case 0xfe: return 7;
case 0xfd: return 6;
case 0xfb: return 5;
case 0xf7: return 4;
case 0xef: return 3;
case 0xdf: return 2;
case 0xbf: return 1;
case 0x7f: return 0;
default: return 0xff;
case 0xfe: return 7;
case 0xfd: return 6;
case 0xfb: return 5;
case 0xf7: return 4;
case 0xef: return 3;
case 0xdf: return 2;
case 0xbf: return 1;
case 0x7f: return 0;
default: return 0xff;
}
}
void glasgow_state::set_board( )
void glasgow_state::set_board()
{
uint8_t i_AH, i_18;
for (i_AH = 0; i_AH < 8; i_AH++)
{
for (i_18 = 0; i_18 < 8; i_18++)
{
// copy start postition to l_board
l_board[i_18][i_AH] = l_start_board[i_18][i_AH];
}
}
// copy start postition to m_board
for (uint8_t i_AH = 0; i_AH < 8; i_AH++)
for (uint8_t i_18 = 0; i_18 < 8; i_18++)
m_board[i_18][i_AH] = s_start_board[i_18][i_AH];
}
void glasgow_state::glasgow_pieces_w( )
void glasgow_state::glasgow_pieces_w()
{
// This causes the pieces to display on-screen
uint8_t i_18, i_AH;
for (i_18 = 0; i_18 < 8; i_18++)
for (i_AH = 0; i_AH < 8; i_AH++)
output().set_indexed_value("P", 63 - l_board[i_18][i_AH].field, l_board[i_18][i_AH].piece);
for (uint8_t i_18 = 0; i_18 < 8; i_18++)
for (uint8_t i_AH = 0; i_AH < 8; i_AH++)
m_pieces[63 - m_board[i_18][i_AH].field] = m_board[i_18][i_AH].piece;
}
WRITE16_MEMBER( glasgow_state::glasgow_lcd_w )
WRITE8_MEMBER( glasgow_state::glasgow_lcd_w )
{
uint8_t lcd_data = data >> 8;
if (m_led7 == 0)
output().set_digit_value(m_lcd_shift_counter, lcd_data);
m_digits[m_lcd_shift_counter] = data;
m_lcd_shift_counter--;
m_lcd_shift_counter &= 3;
}
WRITE16_MEMBER( glasgow_state::glasgow_lcd_flag_w )
WRITE8_MEMBER( glasgow_state::glasgow_lcd_flag_w )
{
uint16_t lcd_flag = data & 0x8100;
uint8_t const lcd_flag = data & 0x81;
m_beep->set_state(BIT(lcd_flag, 8));
m_beep->set_state(BIT(lcd_flag, 0));
if (lcd_flag)
m_led7 = 255;
@ -220,7 +219,7 @@ READ16_MEMBER( glasgow_state::glasgow_keys_r )
if ((data < 0xff) && (m_mouse_down == 0))
{
uint8_t pos2num_res = pos_to_num(data);
uint8_t piece = l_board[m_board_row][pos2num_res].piece;
uint8_t piece = m_board[m_board_row][pos2num_res].piece;
if (pos2num_res > 7)
logerror("Position out of bound!");
@ -229,17 +228,17 @@ READ16_MEMBER( glasgow_state::glasgow_keys_r )
{
if (m_selected[0] < 8)
{
l_board[m_selected[0]][m_selected[1]].piece = 0; // remove shadow
m_board[m_selected[0]][m_selected[1]].piece = 0; // remove shadow
m_selected[0] = 0xff;
}
l_board[m_board_row][pos2num_res].piece = m_mouse_hold;
m_board[m_board_row][pos2num_res].piece = m_mouse_hold;
m_mouse_hold = 0;
}
else
if ((m_mouse_hold == 0) && (piece) && (piece < 13)) // picking up a piece
{
m_mouse_hold = piece;
l_board[m_board_row][pos2num_res].piece = m_mouse_hold + 12; // replace piece with shadow
m_board[m_board_row][pos2num_res].piece = m_mouse_hold + 12; // replace piece with shadow
m_selected[0] = m_board_row;
m_selected[1] = pos2num_res; // save position of shadow
}
@ -256,7 +255,7 @@ READ16_MEMBER( glasgow_state::glasgow_keys_r )
m_mouse_hold = 0;
if (m_selected[0] < 8)
{
l_board[m_selected[0]][m_selected[1]].piece = 0; // remove shadow
m_board[m_selected[0]][m_selected[1]].piece = 0; // remove shadow
m_selected[0] = 0xff;
}
}
@ -288,7 +287,7 @@ READ16_MEMBER( glasgow_state::glasgow_board_r )
// if there is a piece on the field -> set bit in data
for (i_AH = 0; i_AH < 8; i_AH++)
{
if (!l_board[m_Line18_REED][i_AH].piece)
if (!m_board[m_Line18_REED][i_AH].piece)
data |= (1 << i_AH);
}
}
@ -318,26 +317,23 @@ WRITE16_MEMBER( glasgow_state::glasgow_board_w )
WRITE16_MEMBER( glasgow_state::glasgow_beeper_w )
{
uint8_t i_AH, i_18;
uint8_t LED;
uint16_t LineAH = data >> 8;
uint16_t const LineAH = data >> 8;
if (LineAH && m_Line18_LED)
{
for (i_AH = 0; i_AH < 8; i_AH++)
for (uint8_t i_AH = 0; i_AH < 8; i_AH++)
{
if (LineAH & (1 << i_AH))
{
for (i_18 = 0; i_18 < 8; i_18++)
for (uint8_t i_18 = 0; i_18 < 8; i_18++)
{
if (!(m_Line18_LED & (1 << i_18)))
{
LED = l_board[i_18][i_AH].field;
output().set_led_value(LED, 1); // LED on
m_leds[m_board[i_18][i_AH].field] = 1; // LED on
}
else
{
// LED off
// LED off
}
}
}
@ -346,75 +342,66 @@ WRITE16_MEMBER( glasgow_state::glasgow_beeper_w )
else
{
// No LED -> all LED's off
for (i_AH = 0; i_AH < 8; i_AH++)
for (uint8_t i_AH = 0; i_AH < 8; i_AH++)
{
for (i_18 = 0; i_18 < 8; i_18++)
{
// LED off
LED = l_board[i_18][i_AH].field;
output().set_led_value(LED, 0);
}
for (uint8_t i_18 = 0; i_18 < 8; i_18++)
m_leds[m_board[i_18][i_AH].field] = 0; // LED off
}
}
}
WRITE16_MEMBER( glasgow_state::write_beeper )
WRITE16_MEMBER( amsterd_state::write_lcd_invert )
{
m_lcd_invert = 1;
}
WRITE16_MEMBER( glasgow_state::write_lcd )
WRITE8_MEMBER( amsterd_state::write_lcd )
{
uint8_t lcd_data = data >> 8;
output().set_digit_value(m_lcd_shift_counter, m_lcd_invert ? lcd_data^0xff : lcd_data);
m_digits[m_lcd_shift_counter] = m_lcd_invert ? (data ^ 0xff) : data;
m_lcd_shift_counter--;
m_lcd_shift_counter &= 3;
logerror("LCD Offset = %d Data low = %x \n", offset, lcd_data);
logerror("LCD Offset = %d Data low = %x \n", offset, data);
}
WRITE16_MEMBER( glasgow_state::write_lcd_flag )
WRITE8_MEMBER( amsterd_state::write_lcd_flag )
{
m_lcd_invert = 0;
uint8_t lcd_flag = data >> 8;
//beep_set_state(0, lcd_flag & 1 ? 1 : 0);
if (lcd_flag == 0)
//beep_set_state(0, (data & 1) ? 1 : 0);
if (!data)
m_key_selector = 1;
// The key function in the rom expects after writing to
// the a value from the second key row;
m_led7 = (lcd_flag) ? 255 : 0;
m_led7 = data ? 255 : 0;
logerror("LCD Flag 16 = %x \n", data);
logerror("LCD Flag = %x\n", data);
}
READ16_MEMBER( glasgow_state::read_board )
READ16_MEMBER( amsterd_state::read_board )
{
return 0xff00; // Mephisto need it for working
}
WRITE16_MEMBER( glasgow_state::write_board )
WRITE8_MEMBER( amsterd_state::write_board )
{
uint8_t board = data >> 8;
if (board == 0xff)
if (data == 0xff)
m_key_selector = 0;
// The key function in the rom expects after writing to
// the chess board a value from the first key row;
logerror("Write Board = %x \n", data >> 8);
logerror("Write Board = %x\n", data);
glasgow_pieces_w();
}
WRITE16_MEMBER( glasgow_state::write_irq_flag )
WRITE8_MEMBER( amsterd_state::write_beeper )
{
m_beep->set_state(BIT(data, 8));
logerror("Write 0x800004 = %x \n", data);
m_beep->set_state(BIT(data, 0));
}
READ16_MEMBER( glasgow_state::read_newkeys16 ) //Amsterdam, Roma
READ8_MEMBER( amsterd_state::read_newkeys ) //Amsterdam, Roma, Dallas 32, Roma 32
{
uint16_t data;
uint8_t data;
if (m_key_selector)
data = ioport("LINE1")->read();
@ -422,8 +409,7 @@ READ16_MEMBER( glasgow_state::read_newkeys16 ) //Amsterdam, Roma
data = ioport("LINE0")->read();
logerror("read Keyboard Offset = %x Data = %x Select = %x \n", offset, data, m_key_selector);
data <<= 8;
return data ;
return data;
}
@ -441,54 +427,14 @@ READ16_MEMBER(read_test)
*/
WRITE32_MEMBER( glasgow_state::write_lcd32 )
{
uint8_t lcd_data = data >> 8;
output().set_digit_value(m_lcd_shift_counter, m_lcd_invert ? lcd_data^0xff : lcd_data);
m_lcd_shift_counter--;
m_lcd_shift_counter &= 3;
// logerror("LCD Offset = %d Data = %x \n ", offset, lcd_data);
}
WRITE32_MEMBER( glasgow_state::write_lcd_flag32 )
{
uint8_t lcd_flag = data >> 24;
m_lcd_invert = 0;
if (lcd_flag == 0)
m_key_selector = 1;
logerror("LCD Flag 32 = %x \n", lcd_flag);
// beep_set_state(0, lcd_flag & 1 ? 1 : 0);
m_led7 = (lcd_flag) ? 255 : 0;
}
WRITE32_MEMBER( glasgow_state::write_keys32 )
WRITE32_MEMBER( amsterd_state::write_keys32 )
{
m_lcd_invert = 1;
m_key_select = data;
logerror("Write Key = %x \n", m_key_select);
}
READ32_MEMBER( glasgow_state::read_newkeys32 ) // Dallas 32, Roma 32
{
uint32_t data;
if (m_key_selector)
data = ioport("LINE1")->read();
else
data = ioport("LINE0")->read();
//if (key_selector == 1) data = input_port_read(machine, "LINE0"); else data = 0;
logerror("read Keyboard Offset = %x Data = %x\n", offset, data);
data <<= 24;
return data ;
}
READ32_MEMBER( glasgow_state::read_board32 )
READ32_MEMBER( amsterd_state::read_board32 )
{
logerror("read board 32 Offset = %x \n", offset);
return 0;
@ -502,47 +448,41 @@ READ16_MEMBER(read_board_amsterd)
}
#endif
WRITE32_MEMBER( glasgow_state::write_board32 )
{
uint8_t board = data >> 24;
if (board == 0xff)
m_key_selector = 0;
logerror("Write Board = %x \n", data);
glasgow_pieces_w();
}
WRITE32_MEMBER( glasgow_state::write_beeper32 )
{
m_beep->set_state(data & 0x01000000);
logerror("Write 0x8000004 = %x \n", data);
}
TIMER_DEVICE_CALLBACK_MEMBER( glasgow_state::update_nmi)
{
m_maincpu->set_input_line(7, HOLD_LINE);
}
TIMER_DEVICE_CALLBACK_MEMBER( glasgow_state::update_nmi32 )
TIMER_DEVICE_CALLBACK_MEMBER( amsterd_state::update_nmi32 )
{
m_maincpu->set_input_line(6, HOLD_LINE); // this was 7 in the old code, which is correct?
}
MACHINE_START_MEMBER( glasgow_state, glasgow )
void glasgow_state::machine_start()
{
m_pieces.resolve();
m_leds.resolve();
m_digits.resolve();
save_item(NAME(m_lcd_shift_counter));
save_item(NAME(m_led7));
save_item(NAME(m_key_select));
save_item(NAME(m_lcd_invert));
save_item(NAME(m_key_selector));
save_item(NAME(m_read_board_flag));
save_item(NAME(m_mouse_hold));
save_item(NAME(m_board_row));
save_item(NAME(m_mouse_down));
save_item(NAME(m_Line18_LED));
save_item(NAME(m_Line18_REED));
save_item(NAME(m_selected));
m_key_selector = 0;
m_lcd_shift_counter = 3;
}
MACHINE_START_MEMBER( glasgow_state, dallas32 )
{
m_lcd_shift_counter = 3;
}
MACHINE_RESET_MEMBER( glasgow_state, glasgow )
void glasgow_state::machine_reset()
{
m_lcd_shift_counter = 3;
m_selected[0] = 0xff;
@ -551,39 +491,39 @@ MACHINE_RESET_MEMBER( glasgow_state, glasgow )
ADDRESS_MAP_START(glasgow_state::glasgow_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1FFFF)
ADDRESS_MAP_GLOBAL_MASK(0x1ffff)
AM_RANGE(0x000000, 0x00ffff) AM_ROM
AM_RANGE(0x010000, 0x010001) AM_WRITE( glasgow_lcd_w )
AM_RANGE(0x010000, 0x010001) AM_WRITE8( glasgow_lcd_w, 0xff00 )
AM_RANGE(0x010002, 0x010003) AM_READWRITE( glasgow_keys_r, glasgow_keys_w )
AM_RANGE(0x010004, 0x010005) AM_WRITE( glasgow_lcd_flag_w )
AM_RANGE(0x010004, 0x010005) AM_WRITE8( glasgow_lcd_flag_w, 0xff00 )
AM_RANGE(0x010006, 0x010007) AM_READWRITE( glasgow_board_r, glasgow_beeper_w )
AM_RANGE(0x010008, 0x010009) AM_WRITE( glasgow_board_w )
AM_RANGE(0x01c000, 0x01ffff) AM_RAM // 16KB
ADDRESS_MAP_END
ADDRESS_MAP_START(glasgow_state::amsterd_mem)
ADDRESS_MAP_START(amsterd_state::amsterd_mem)
// ADDRESS_MAP_GLOBAL_MASK(0x7FFFF)
AM_RANGE(0x000000, 0x00ffff) AM_ROM
AM_RANGE(0x800002, 0x800003) AM_WRITE( write_lcd )
AM_RANGE(0x800008, 0x800009) AM_WRITE( write_lcd_flag )
AM_RANGE(0x800004, 0x800005) AM_WRITE( write_irq_flag )
AM_RANGE(0x800010, 0x800011) AM_WRITE( write_board )
AM_RANGE(0x800002, 0x800003) AM_WRITE8( write_lcd, 0xff00 )
AM_RANGE(0x800008, 0x800009) AM_WRITE8( write_lcd_flag, 0xff00 )
AM_RANGE(0x800004, 0x800005) AM_WRITE8( write_beeper, 0xff00 )
AM_RANGE(0x800010, 0x800011) AM_WRITE8( write_board, 0xff00 )
AM_RANGE(0x800020, 0x800021) AM_READ( read_board )
AM_RANGE(0x800040, 0x800041) AM_READ( read_newkeys16 )
AM_RANGE(0x800088, 0x800089) AM_WRITE( write_beeper )
AM_RANGE(0x800040, 0x800041) AM_READ8( read_newkeys, 0xff00 )
AM_RANGE(0x800088, 0x800089) AM_WRITE( write_lcd_invert )
AM_RANGE(0xffc000, 0xffffff) AM_RAM // 16KB
ADDRESS_MAP_END
ADDRESS_MAP_START(glasgow_state::dallas32_mem)
ADDRESS_MAP_START(amsterd_state::dallas32_mem)
// ADDRESS_MAP_GLOBAL_MASK(0x1FFFF)
AM_RANGE(0x000000, 0x00ffff) AM_ROM
AM_RANGE(0x010000, 0x01ffff) AM_RAM // 64KB
AM_RANGE(0x800000, 0x800003) AM_WRITE( write_lcd32 )
AM_RANGE(0x800004, 0x800007) AM_WRITE( write_beeper32 )
AM_RANGE(0x800008, 0x80000B) AM_WRITE( write_lcd_flag32 )
AM_RANGE(0x800010, 0x800013) AM_WRITE( write_board32 )
AM_RANGE(0x800000, 0x800003) AM_WRITE8( write_lcd, 0x0000ff00 )
AM_RANGE(0x800004, 0x800007) AM_WRITE8( write_beeper, 0xff000000 )
AM_RANGE(0x800008, 0x80000b) AM_WRITE8( write_lcd_flag, 0xff000000 )
AM_RANGE(0x800010, 0x800013) AM_WRITE8( write_board, 0xff000000 )
AM_RANGE(0x800020, 0x800023) AM_READ( read_board32 )
AM_RANGE(0x800040, 0x800043) AM_READ( read_newkeys32 )
AM_RANGE(0x800040, 0x800043) AM_READ8( read_newkeys, 0xff000000 )
AM_RANGE(0x800088, 0x80008b) AM_WRITE( write_keys32 )
ADDRESS_MAP_END
@ -718,8 +658,6 @@ MACHINE_CONFIG_START(glasgow_state::glasgow)
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", M68000, 12000000)
MCFG_CPU_PROGRAM_MAP(glasgow_mem)
MCFG_MACHINE_START_OVERRIDE(glasgow_state, glasgow )
MCFG_MACHINE_RESET_OVERRIDE(glasgow_state, glasgow )
/* video hardware */
MCFG_DEFAULT_LAYOUT(layout_glasgow)
@ -731,7 +669,7 @@ MACHINE_CONFIG_START(glasgow_state::glasgow)
MCFG_TIMER_DRIVER_ADD_PERIODIC("nmi_timer", glasgow_state, update_nmi, attotime::from_hz(50))
MACHINE_CONFIG_END
MACHINE_CONFIG_START(glasgow_state::amsterd)
MACHINE_CONFIG_START(amsterd_state::amsterd)
glasgow(config);
/* basic machine hardware */
@ -739,16 +677,15 @@ MACHINE_CONFIG_START(glasgow_state::amsterd)
MCFG_CPU_PROGRAM_MAP(amsterd_mem)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(glasgow_state::dallas32)
MACHINE_CONFIG_START(amsterd_state::dallas32)
glasgow(config);
/* basic machine hardware */
MCFG_CPU_REPLACE("maincpu", M68020, 14000000)
MCFG_CPU_PROGRAM_MAP(dallas32_mem)
MCFG_MACHINE_START_OVERRIDE(glasgow_state, dallas32)
MCFG_DEVICE_REMOVE("nmi_timer")
MCFG_TIMER_DRIVER_ADD_PERIODIC("nmi_timer", glasgow_state, update_nmi32, attotime::from_hz(50))
MCFG_TIMER_DRIVER_ADD_PERIODIC("nmi_timer", amsterd_state, update_nmi32, attotime::from_hz(50))
MACHINE_CONFIG_END
@ -810,9 +747,9 @@ ROM_END
/* YEAR, NAME, PARENT, COMPAT, MACHINE, INPUT, CLASS, INIT, COMPANY, FULLNAME, FLAGS */
CONS( 1984, glasgow, 0, 0, glasgow, old_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto III S Glasgow", 0)
CONS( 1984, amsterd, 0, 0, amsterd, new_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Amsterdam", MACHINE_NOT_WORKING)
CONS( 1984, amsterd, 0, 0, amsterd, new_keyboard, amsterd_state, 0, "Hegener & Glaser Muenchen", "Mephisto Amsterdam", MACHINE_NOT_WORKING)
CONS( 1984, dallas, glasgow, 0, glasgow, old_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Dallas", MACHINE_NOT_WORKING)
CONS( 1984, roma, amsterd, 0, glasgow, new_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Roma", MACHINE_NOT_WORKING)
CONS( 1984, dallas32, amsterd, 0, dallas32, new_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Dallas 32 Bit", MACHINE_NOT_WORKING)
CONS( 1984, roma32, amsterd, 0, dallas32, new_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Roma 32 Bit", MACHINE_NOT_WORKING)
CONS( 1984, dallas16, amsterd, 0, amsterd, new_keyboard, glasgow_state, 0, "Hegener & Glaser Muenchen", "Mephisto Dallas 16 Bit", MACHINE_NOT_WORKING)
CONS( 1984, dallas32, amsterd, 0, dallas32, new_keyboard, amsterd_state, 0, "Hegener & Glaser Muenchen", "Mephisto Dallas 32 Bit", MACHINE_NOT_WORKING)
CONS( 1984, roma32, amsterd, 0, dallas32, new_keyboard, amsterd_state, 0, "Hegener & Glaser Muenchen", "Mephisto Roma 32 Bit", MACHINE_NOT_WORKING)
CONS( 1984, dallas16, amsterd, 0, amsterd, new_keyboard, amsterd_state, 0, "Hegener & Glaser Muenchen", "Mephisto Dallas 16 Bit", MACHINE_NOT_WORKING)

98
src/mame/drivers/hp9845.cpp
View File

@ -410,27 +410,22 @@ INPUT_PORTS_END
// hp9845_base_state
// *******************
hp9845_base_state::hp9845_base_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_lpu(*this , "lpu"),
m_ppu(*this , "ppu"),
m_screen(*this , "screen"),
m_palette(*this , "palette"),
m_gv_timer(*this , "gv_timer"),
m_io_key0(*this , "KEY0"),
m_io_key1(*this , "KEY1"),
m_io_key2(*this , "KEY2"),
m_io_key3(*this , "KEY3"),
m_io_shiftlock(*this, "SHIFTLOCK"),
m_t14(*this , "t14"),
m_t15(*this , "t15"),
m_beeper(*this , "beeper"),
m_beep_timer(*this , "beep_timer"),
m_io_slot0(*this , "slot0"),
m_io_slot1(*this , "slot1"),
m_io_slot2(*this , "slot2"),
m_io_slot3(*this , "slot3"),
m_ram(*this , RAM_TAG),
m_chargen(*this , "chargen")
driver_device(mconfig, type, tag),
m_lpu(*this, "lpu"),
m_ppu(*this, "ppu"),
m_screen(*this, "screen"),
m_palette(*this, "palette"),
m_gv_timer(*this, "gv_timer"),
m_io_key(*this, "KEY%u", 0U),
m_io_shiftlock(*this, "SHIFTLOCK"),
m_t14(*this, "t14"),
m_t15(*this, "t15"),
m_beeper(*this, "beeper"),
m_beep_timer(*this, "beep_timer"),
m_io_slot(*this, "slot%u", 0U),
m_ram(*this, RAM_TAG),
m_softkeys(*this, "Softkey%u", 0U),
m_chargen(*this, "chargen")
{
}
@ -443,7 +438,7 @@ void hp9845_base_state::setup_ram_block(unsigned block , unsigned offset)
void hp9845_base_state::machine_start()
{
machine().first_screen()->register_screen_bitmap(m_bitmap);
m_screen->register_screen_bitmap(m_bitmap);
// setup RAM dynamically for -ramsize
// 0K..64K
@ -487,22 +482,11 @@ void hp9845_base_state::machine_reset()
int sc;
read16_delegate rhandler;
write16_delegate whandler;
if ((sc = m_io_slot0->get_rw_handlers(rhandler , whandler)) >= 0) {
logerror("Install R/W handlers for slot 0 @ SC = %d\n" , sc);
m_ppu->space(AS_IO).install_readwrite_handler(sc * 4 , sc * 4 + 3 , rhandler , whandler);
}
if ((sc = m_io_slot1->get_rw_handlers(rhandler , whandler)) >= 0) {
logerror("Install R/W handlers for slot 1 @ SC = %d\n" , sc);
m_ppu->space(AS_IO).install_readwrite_handler(sc * 4 , sc * 4 + 3 , rhandler , whandler);
}
if ((sc = m_io_slot2->get_rw_handlers(rhandler , whandler)) >= 0) {
logerror("Install R/W handlers for slot 2 @ SC = %d\n" , sc);
m_ppu->space(AS_IO).install_readwrite_handler(sc * 4 , sc * 4 + 3 , rhandler , whandler);
}
if ((sc = m_io_slot3->get_rw_handlers(rhandler , whandler)) >= 0) {
logerror("Install R/W handlers for slot 3 @ SC = %d\n" , sc);
m_ppu->space(AS_IO).install_readwrite_handler(sc * 4 , sc * 4 + 3 , rhandler , whandler);
}
for (unsigned i = 0; 4 > i; ++i)
if ((sc = m_io_slot[i]->get_rw_handlers(rhandler , whandler)) >= 0) {
logerror("Install R/W handlers for slot %u @ SC = %d\n", i, sc);
m_ppu->space(AS_IO).install_readwrite_handler(sc * 4 , sc * 4 + 3 , rhandler , whandler);
}
// Some sensible defaults
m_video_load_mar = false;
@ -638,12 +622,12 @@ void hp9845_base_state::flg_w(uint8_t sc , int state)
}
}
void hp9845_base_state::kb_scan_ioport(ioport_value pressed , ioport_port *port , unsigned idx_base , int& max_seq_len , unsigned& max_seq_idx)
void hp9845_base_state::kb_scan_ioport(ioport_value pressed , ioport_port &port , unsigned idx_base , int& max_seq_len , unsigned& max_seq_idx)
{
while (pressed) {
unsigned bit_no = 31 - count_leading_zeros(pressed);
ioport_value mask = BIT_MASK(bit_no);
int seq_len = port->field(mask)->seq().length();
int seq_len = port.field(mask)->seq().length();
if (seq_len > max_seq_len) {
max_seq_len = seq_len;
max_seq_idx = bit_no + idx_base;
@ -654,11 +638,11 @@ void hp9845_base_state::kb_scan_ioport(ioport_value pressed , ioport_port *port
TIMER_DEVICE_CALLBACK_MEMBER(hp9845_base_state::kb_scan)
{
ioport_value input[ 4 ];
input[ 0 ] = m_io_key0->read();
input[ 1 ] = m_io_key1->read();
input[ 2 ] = m_io_key2->read();
input[ 3 ] = m_io_key3->read();
ioport_value input[ 4 ]{
m_io_key[0]->read(),
m_io_key[1]->read(),
m_io_key[2]->read(),
m_io_key[3]->read() };
// Shift lock
ioport_value shiftlock = m_io_shiftlock->read();
@ -703,10 +687,8 @@ TIMER_DEVICE_CALLBACK_MEMBER(hp9845_base_state::kb_scan)
int max_seq_len = 0;
unsigned max_seq_idx = 0;
kb_scan_ioport(input[ 0 ] & ~m_kb_state[ 0 ] , m_io_key0 , 0 , max_seq_len , max_seq_idx);
kb_scan_ioport(input[ 1 ] & ~m_kb_state[ 1 ] , m_io_key1 , 32 , max_seq_len , max_seq_idx);
kb_scan_ioport(input[ 2 ] & ~m_kb_state[ 2 ] , m_io_key2 , 64 , max_seq_len , max_seq_idx);
kb_scan_ioport(input[ 3 ] & ~m_kb_state[ 3 ] , m_io_key3 , 96 , max_seq_len , max_seq_idx);
for (unsigned i = 0; 4 > i; ++i)
kb_scan_ioport(input[i] & ~m_kb_state[i] , *m_io_key[i] , i << 5 , max_seq_len , max_seq_idx);
// TODO: handle repeat key
// TODO: handle ctrl+stop
@ -827,14 +809,14 @@ INPUT_CHANGED_MEMBER(hp9845_base_state::togglekey_changed)
break;
case 1: // Prt all
{
bool state = BIT(m_io_key0->read(), 1);
bool state = BIT(m_io_key[0]->read(), 1);
popmessage("PRT ALL %s", state ? "ON" : "OFF");
output().set_value("prt_all_led" , state);
}
break;
case 2: // Auto st
{
bool state = BIT(m_io_key0->read(), 17);
bool state = BIT(m_io_key[0]->read(), 17);
popmessage("AUTO ST %s", state ? "ON" : "OFF");
output().set_value("auto_st_led" , state);
}
@ -1404,7 +1386,7 @@ protected:
void update_line_pattern();
void pattern_fill(uint16_t x0 , uint16_t y0 , uint16_t x1 , uint16_t y1 , unsigned fill_idx);
static uint16_t get_gv_mem_addr(unsigned x , unsigned y);
virtual void update_graphic_bits(void) = 0;
virtual void update_graphic_bits() = 0;
static int get_wrapped_scanline(unsigned scanline);
void render_lp_cursor(unsigned video_scanline , unsigned pen_idx);
@ -1415,7 +1397,7 @@ protected:
void compute_lp_data();
void lp_scanline_update(unsigned video_scanline);
virtual void update_gcursor(void) = 0;
virtual void update_gcursor() = 0;
bool m_alpha_sel;
bool m_gv_sk_en;
@ -1613,7 +1595,7 @@ INPUT_CHANGED_MEMBER(hp9845ct_base_state::softkey_changed)
uint8_t softkey_data = m_io_softkeys->read();
unsigned softkey;
for (softkey = 0; softkey < 8; softkey++) {
output().set_indexed_value("Softkey" , softkey , !BIT(softkey_data , 7 - softkey));
m_softkeys[softkey] = !BIT(softkey_data , 7 - softkey);
}
for (softkey = 0; softkey < 8 && BIT(softkey_data , 7 - softkey); softkey++) {
}
@ -2099,7 +2081,7 @@ protected:
virtual void advance_gv_fsm(bool ds , bool trigger) override;
virtual void update_graphic_bits() override;
virtual void update_gcursor(void) override;
virtual void update_gcursor() override;
// Palette indexes
static constexpr unsigned pen_graphic(unsigned rgb) { return rgb; }
@ -2799,7 +2781,7 @@ void hp9845c_state::update_graphic_bits()
m_ppu->dmar_w(dmar);
}
void hp9845c_state::update_gcursor(void)
void hp9845c_state::update_gcursor()
{
m_gv_cursor_color = ~m_gv_lyc & 0x7;
m_gv_cursor_y = (~m_gv_lyc >> 6) & 0x1ff;
@ -2836,7 +2818,7 @@ protected:
virtual void advance_gv_fsm(bool ds , bool trigger) override;
virtual void update_graphic_bits() override;
virtual void update_gcursor(void) override;
virtual void update_gcursor() override;
std::vector<uint16_t> m_graphic_mem;
@ -3644,7 +3626,7 @@ void hp9845t_state::update_graphic_bits()
m_ppu->dmar_w(dmar);
}
void hp9845t_state::update_gcursor(void)
void hp9845t_state::update_gcursor()
{
m_gv_cursor_fs = (m_gv_lyc & 0x3) == 0;
m_gv_cursor_gc = !BIT(m_gv_lyc , 1);

2
src/mame/drivers/maygay1b.cpp
View File

@ -710,7 +710,7 @@ WRITE8_MEMBER(maygay1b_state::mcu_port1_w)
{
bit_offset = i - 4;
}
output().set_lamp_value((8 * m_lamp_strobe) + i + 128, ((data & (1 << bit_offset)) != 0));
m_lamps[((m_lamp_strobe << 3) & 0x78) | i | 128] = BIT(data, bit_offset);
}
#endif
}

43
src/mame/drivers/mwsub.cpp
View File

@ -22,11 +22,18 @@ class submar_state : public driver_device
{
public:
submar_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu")
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_motors(*this, "motor%u", 0U)
, m_lamps(*this, "lamp%u", 0U)
, m_solenoids(*this, "solenoid%u", 0U)
, m_digits(*this, "digit%u", 0U)
{ }
required_device<cpu_device> m_maincpu;
void submar(machine_config &config);
protected:
virtual void machine_start() override;
DECLARE_READ8_MEMBER(submar_sensor0_r);
DECLARE_READ8_MEMBER(submar_sensor1_r);
@ -36,9 +43,15 @@ public:
DECLARE_WRITE8_MEMBER(submar_sound_w);
DECLARE_WRITE8_MEMBER(submar_led_w);
DECLARE_WRITE8_MEMBER(submar_irq_clear_w);
void submar(machine_config &config);
void submar_map(address_map &map);
void submar_portmap(address_map &map);
required_device<cpu_device> m_maincpu;
output_finder<8> m_motors;
output_finder<8> m_lamps;
output_finder<8> m_solenoids;
output_finder<4> m_digits;
};
@ -48,6 +61,14 @@ public:
***************************************************************************/
void submar_state::machine_start()
{
m_motors.resolve();
m_lamps.resolve();
m_solenoids.resolve();
m_digits.resolve();
}
READ8_MEMBER(submar_state::submar_sensor0_r)
{
// ?
@ -71,7 +92,7 @@ WRITE8_MEMBER(submar_state::submar_motor_w)
// d6: stir water
// d7: n/c
for (int i = 0; i < 8; i++)
output().set_indexed_value("motor", i, data >> i & 1);
m_motors[i] = BIT(data, i);
}
WRITE8_MEMBER(submar_state::submar_lamp_w)
@ -85,7 +106,7 @@ WRITE8_MEMBER(submar_state::submar_lamp_w)
// d6: front ship hit
// d7: scenery
for (int i = 0; i < 8; i++)
output().set_lamp_value(i, data >> i & 1);
m_lamps[i] = BIT(data, i);
}
WRITE8_MEMBER(submar_state::submar_solenoid_w)
@ -93,7 +114,7 @@ WRITE8_MEMBER(submar_state::submar_solenoid_w)
// d0-d4: ship1-5
// d5-d7: n/c
for (int i = 0; i < 8; i++)
output().set_indexed_value("solenoid", i, data >> i & 1);
m_solenoids[i] = BIT(data, i);
}
WRITE8_MEMBER(submar_state::submar_sound_w)
@ -111,12 +132,12 @@ WRITE8_MEMBER(submar_state::submar_sound_w)
WRITE8_MEMBER(submar_state::submar_led_w)
{
// 7447 (BCD to LED segment)
const uint8_t _7447_map[16] =
{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x67,0x58,0x4c,0x62,0x69,0x78,0x00 };
static constexpr uint8_t _7447_map[16] =
{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x67,0x58,0x4c,0x62,0x69,0x78,0x00 };
// 2 digits per write. port 4: time, port 5: score
output().set_digit_value((offset << 1 & 2) | 0, _7447_map[data >> 4]);
output().set_digit_value((offset << 1 & 2) | 1, _7447_map[data & 0x0f]);
m_digits[((offset << 1) & 2) | 0] = _7447_map[data >> 4];
m_digits[((offset << 1) & 2) | 1] = _7447_map[data & 0x0f];
}
WRITE8_MEMBER(submar_state::submar_irq_clear_w)

43
src/mame/drivers/segajw.cpp
View File

@ -45,38 +45,46 @@ class segajw_state : public driver_device
{
public:
segajw_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_audiocpu(*this, "audiocpu"),
m_soundlatch(*this, "soundlatch")
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_audiocpu(*this, "audiocpu")
, m_soundlatch(*this, "soundlatch")
, m_lamps(*this, "lamp%u", 0U)
, m_towerlamps(*this, "towerlamp%u", 0U)
{ }
DECLARE_INPUT_CHANGED_MEMBER(coin_drop_start);
DECLARE_CUSTOM_INPUT_MEMBER(coin_sensors_r);
DECLARE_CUSTOM_INPUT_MEMBER(hopper_sensors_r);
void segajw(machine_config &config);
protected:
DECLARE_READ8_MEMBER(coin_counter_r);
DECLARE_WRITE8_MEMBER(coin_counter_w);
DECLARE_WRITE8_MEMBER(hopper_w);
DECLARE_WRITE8_MEMBER(lamps1_w);
DECLARE_WRITE8_MEMBER(lamps2_w);
DECLARE_WRITE8_MEMBER(coinlockout_w);
DECLARE_INPUT_CHANGED_MEMBER(coin_drop_start);
DECLARE_CUSTOM_INPUT_MEMBER(coin_sensors_r);
DECLARE_CUSTOM_INPUT_MEMBER(hopper_sensors_r);
void segajw(machine_config &config);
// driver_device overrides
virtual void machine_start() override;
virtual void machine_reset() override;
void ramdac_map(address_map &map);
void segajw_audiocpu_io_map(address_map &map);
void segajw_audiocpu_map(address_map &map);
void segajw_hd63484_map(address_map &map);
void segajw_map(address_map &map);
protected:
private:
// devices
required_device<cpu_device> m_maincpu;
required_device<cpu_device> m_audiocpu;
required_device<generic_latch_8_device> m_soundlatch;
output_finder<16> m_lamps;
output_finder<3> m_towerlamps;
// driver_device overrides
virtual void machine_start() override;
virtual void machine_reset() override;
uint64_t m_coin_start_cycles;
uint64_t m_hopper_start_cycles;
uint8_t m_coin_counter;
@ -101,21 +109,21 @@ WRITE8_MEMBER(segajw_state::hopper_w)
WRITE8_MEMBER(segajw_state::lamps1_w)
{
for (int i = 0; i < 8; i++)
output().set_lamp_value(i, BIT(data, i));
m_lamps[i] = BIT(data, i);
}
WRITE8_MEMBER(segajw_state::lamps2_w)
{
for (int i = 0; i < 8; i++)
output().set_lamp_value(8 + i, BIT(data, i));
m_lamps[8 + i] = BIT(data, i);
}
WRITE8_MEMBER(segajw_state::coinlockout_w)
{
machine().bookkeeping().coin_lockout_w(0, data & 1);
for(int i=0; i<3; i++)
output().set_indexed_value("towerlamp", i, BIT(data, 3 + i));
for (int i = 0; i < 3; i++)
m_towerlamps[i] = BIT(data, 3 + i);
}
INPUT_CHANGED_MEMBER( segajw_state::coin_drop_start )
@ -338,6 +346,9 @@ INPUT_PORTS_END
void segajw_state::machine_start()
{
m_lamps.resolve();
m_towerlamps.resolve();
save_item(NAME(m_coin_start_cycles));
save_item(NAME(m_hopper_start_cycles));
save_item(NAME(m_coin_counter));

68
src/mame/drivers/segaufo.cpp
View File

@ -75,32 +75,22 @@
class ufo_state : public driver_device
{
public:
ufo_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
ufo_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_io1(*this, "io1"),
m_io2(*this, "io2"),
m_upd(*this, "upd")
m_upd(*this, "upd"),
m_counters(*this, "counter%u", 0U),
m_digits(*this, "digit%u", 0U)
{ }
required_device<cpu_device> m_maincpu;
required_device<sega_315_5296_device> m_io1;
required_device<sega_315_5296_device> m_io2;
optional_device<upd7759_device> m_upd;
struct Player
{
struct Motor
{
uint8_t running;
uint8_t direction;
float position;
float speed;
} motor[4];
} m_player[2];
uint8_t m_stepper;
void ufomini(machine_config &config);
void ufo21(machine_config &config);
void newufo(machine_config &config);
void ufo800(machine_config &config);
protected:
void motor_tick(int p, int m);
DECLARE_WRITE_LINE_MEMBER(pit_out0);
@ -127,14 +117,32 @@ public:
virtual void machine_start() override;
TIMER_DEVICE_CALLBACK_MEMBER(simulate_xyz);
TIMER_DEVICE_CALLBACK_MEMBER(update_info);
void ufomini(machine_config &config);
void ufo21(machine_config &config);
void newufo(machine_config &config);
void ufo800(machine_config &config);
void ex_ufo21_portmap(address_map &map);
void ex_ufo800_portmap(address_map &map);
void ufo_map(address_map &map);
void ufo_portmap(address_map &map);
void ex_ufo21_portmap(address_map &map);
void ex_ufo800_portmap(address_map &map);
private:
struct Player
{
struct Motor
{
uint8_t running;
uint8_t direction;
float position;
float speed;
} motor[4];
} m_player[2];
uint8_t m_stepper;
required_device<cpu_device> m_maincpu;
required_device<sega_315_5296_device> m_io1;
required_device<sega_315_5296_device> m_io2;
optional_device<upd7759_device> m_upd;
output_finder<2 * 4> m_counters;
output_finder<2> m_digits;
};
@ -171,7 +179,7 @@ TIMER_DEVICE_CALLBACK_MEMBER(ufo_state::update_info)
// 3 C: 000 = closed, 100 = open
for (int p = 0; p < 2; p++)
for (int m = 0; m < 4; m++)
output().set_indexed_value("counter", p*4 + m, (uint8_t)(m_player[p].motor[m].position * 100));
m_counters[(p << 2) | m] = uint8_t(m_player[p].motor[m].position * 100);
#if 0
char msg1[0x100] = {0};
@ -288,12 +296,12 @@ WRITE8_MEMBER(ufo_state::cp_lamps_w)
WRITE8_MEMBER(ufo_state::cp_digits_w)
{
static const uint8_t lut_7448[0x10] =
{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x67,0x58,0x4c,0x62,0x69,0x78,0x00 };
static constexpr uint8_t lut_7448[0x10] =
{ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x67,0x58,0x4c,0x62,0x69,0x78,0x00 };
// d0-d3: cpanel digit
// other bits: ?
output().set_digit_value(offset & 1, lut_7448[data & 0xf]);
m_digits[offset & 1] = lut_7448[data & 0xf];
}
WRITE8_MEMBER(ufo_state::crane_xyz_w)

29
src/mame/includes/hp9845.h
View File

@ -3,10 +3,11 @@
// *******************************
// Driver for HP 9845B/C/T systems
// *******************************
#ifndef MAME_INCLUDES_HP9845_H
#define MAME_INCLUDES_HP9845_H
#pragma once
#include "cpu/hphybrid/hphybrid.h"
#include "machine/hp_taco.h"
#include "sound/beep.h"
@ -20,6 +21,9 @@ class hp9845_base_state : public driver_device
public:
hp9845_base_state(const machine_config &mconfig, device_type type, const char *tag);
DECLARE_INPUT_CHANGED_MEMBER(togglekey_changed);
protected:
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void device_reset() override;
@ -28,13 +32,13 @@ public:
virtual DECLARE_READ16_MEMBER(graphic_r) = 0;
virtual DECLARE_WRITE16_MEMBER(graphic_w) = 0;
attotime time_to_gv_mem_availability(void) const;
attotime time_to_gv_mem_availability() const;
IRQ_CALLBACK_MEMBER(irq_callback);
void update_irq(void);
void update_irq();
DECLARE_WRITE8_MEMBER(irq_w);
void irq_w(uint8_t sc , int state);
void update_flg_sts(void);
void update_flg_sts();
DECLARE_WRITE8_MEMBER(sts_w);
void sts_w(uint8_t sc , int state);
DECLARE_WRITE8_MEMBER(flg_w);
@ -58,36 +62,29 @@ public:
DECLARE_WRITE_LINE_MEMBER(t15_flg_w);
DECLARE_WRITE_LINE_MEMBER(t15_sts_w);
DECLARE_INPUT_CHANGED_MEMBER(togglekey_changed);
void hp9845_base(machine_config &config);
void global_mem_map(address_map &map);
void ppu_io_map(address_map &map);
protected:
required_device<hp_5061_3001_cpu_device> m_lpu;
required_device<hp_5061_3001_cpu_device> m_ppu;
required_device<screen_device> m_screen;
required_device<palette_device> m_palette;
required_device<timer_device> m_gv_timer;
required_ioport m_io_key0;
required_ioport m_io_key1;
required_ioport m_io_key2;
required_ioport m_io_key3;
required_ioport_array<4> m_io_key;
required_ioport m_io_shiftlock;
required_device<hp_taco_device> m_t14;
required_device<hp_taco_device> m_t15;
required_device<beep_device> m_beeper;
required_device<timer_device> m_beep_timer;
required_device<hp9845_io_slot_device> m_io_slot0;
required_device<hp9845_io_slot_device> m_io_slot1;
required_device<hp9845_io_slot_device> m_io_slot2;
required_device<hp9845_io_slot_device> m_io_slot3;
required_device_array<hp9845_io_slot_device, 4> m_io_slot;
required_device<ram_device> m_ram;
output_finder<8> m_softkeys;
void setup_ram_block(unsigned block , unsigned offset);
virtual void advance_gv_fsm(bool ds , bool trigger) = 0;
void kb_scan_ioport(ioport_value pressed , ioport_port *port , unsigned idx_base , int& max_seq_len , unsigned& max_seq_idx);
void kb_scan_ioport(ioport_value pressed , ioport_port &port , unsigned idx_base , int& max_seq_len , unsigned& max_seq_idx);
void update_kb_prt_irq();
// Character generator

53
src/mame/machine/bfm_bd1.cpp
View File

@ -102,20 +102,17 @@ static const uint16_t BD1charset[]=
};
bfm_bd1_device::bfm_bd1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, BFM_BD1, tag, owner, clock),
m_port_val(0)
: device_t(mconfig, BFM_BD1, tag, owner, clock)
, m_outputs()
, m_port_val(0)
{
}
void bfm_bd1_device::static_set_value(device_t &device, int val)
{
bfm_bd1_device &bd1 = downcast<bfm_bd1_device &>(device);
bd1.m_port_val = val;
}
void bfm_bd1_device::device_start()
{
save_item(NAME(m_cursor));
m_outputs = std::make_unique<output_finder<16> >(*this, "vfd%u", unsigned(m_port_val) << 4);
m_outputs->resolve();
save_item(NAME(m_cursor_pos));
save_item(NAME(m_window_start)); // display window start pos 0-15
save_item(NAME(m_window_end)); // display window end pos 0-15
@ -127,15 +124,14 @@ void bfm_bd1_device::device_start()
save_item(NAME(m_display_mode));
save_item(NAME(m_flash_rate));
save_item(NAME(m_flash_control));
save_item(NAME(m_chars));
save_item(NAME(m_attrs));
save_item(NAME(m_outputs));
save_item(NAME(m_user_data)); // user defined character data (16 bit)
save_item(NAME(m_user_def)); // user defined character state
save_item(NAME(m_sclk));
save_item(NAME(m_data));
device_reset();
save_item(NAME(m_cursor));
save_item(NAME(m_chars));
save_item(NAME(m_attrs));
save_item(NAME(m_user_data)); // user defined character data (16 bit)
save_item(NAME(m_user_def)); // user defined character state
}
void bfm_bd1_device::device_reset()
@ -157,9 +153,8 @@ void bfm_bd1_device::device_reset()
m_sclk = 0;
m_data = 0;
memset(m_chars, 0, sizeof(m_chars));
memset(m_outputs, 0, sizeof(m_outputs));
memset(m_attrs, 0, sizeof(m_attrs));
std::fill(std::begin(m_chars), std::end(m_chars), 0);
std::fill(std::begin(m_attrs), std::end(m_attrs), 0);
}
uint16_t bfm_bd1_device::set_display(uint16_t segin)
@ -174,18 +169,8 @@ void bfm_bd1_device::device_post_load()
void bfm_bd1_device::update_display()
{
for (int i =0; i<16; i++)
{
if (m_attrs[i] != AT_BLANK)
{
m_outputs[i] = set_display(m_chars[i]);
}
else
{
m_outputs[i] = 0;
}
machine().output().set_indexed_value("vfd", (m_port_val*16) + i, m_outputs[i]);
}
for (int i = 0; i < 16; i++)
(*m_outputs)[i] = (m_attrs[i] != AT_BLANK) ? set_display(m_chars[i]) : 0;
}
///////////////////////////////////////////////////////////////////////////
void bfm_bd1_device::blank(int data)
@ -300,8 +285,8 @@ int bfm_bd1_device::write_char(int data)
case 0x01: // clr inside window
if ( m_window_size > 0 )
{
memset(m_chars+m_window_start,0,m_window_size);
memset(m_attrs+m_window_start,0,m_window_size);
std::fill_n(m_chars + m_window_start, m_window_size, 0);
std::fill_n(m_attrs + m_window_start, m_window_size, 0);
}
break;
@ -330,8 +315,8 @@ int bfm_bd1_device::write_char(int data)
break;
case 0x03: // clr entire display
memset(m_chars, 0, sizeof(m_chars));
memset(m_attrs, 0, sizeof(m_attrs));
std::fill(std::begin(m_chars), std::end(m_chars), 0);
std::fill(std::begin(m_attrs), std::end(m_attrs), 0);
}
break;

23
src/mame/machine/bfm_bd1.h
View File

@ -7,12 +7,10 @@
#define MCFG_BFMBD1_ADD(_tag,_val) \
MCFG_DEVICE_ADD(_tag, BFM_BD1,60)\
MCFG_DEVICE_ADD(_tag, BFM_BD1, 60)\
MCFG_BD1_PORT(_val)
#define MCFG_BD1_PORT(_val) \
bfm_bd1_device::static_set_value(*device, _val);
#define MCFG_BFMBD1_REMOVE(_tag) \
MCFG_DEVICE_REMOVE(_tag)
downcast<bfm_bd1_device &>(*device).set_port_val(_val);
class bfm_bd1_device : public device_t
{
@ -20,11 +18,10 @@ public:
bfm_bd1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_value(device_t &device, int val);
void set_port_val(uint8_t val) { m_port_val = val; }
int write_char(int data);
virtual void update_display();
uint8_t m_port_val;
void blank(int data);
void shift_clock(int state);
@ -35,11 +32,19 @@ public:
DECLARE_WRITE_LINE_MEMBER( por );
protected:
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
private:
static const uint8_t AT_NORMAL = 0x00;
static const uint8_t AT_FLASH = 0x01;
static const uint8_t AT_BLANK = 0x02;
static const uint8_t AT_FLASHED = 0x80; // set when character should be blinked off
std::unique_ptr<output_finder<16> > m_outputs;
uint8_t m_port_val;
int m_cursor_pos;
int m_window_start; // display window start pos 0-15
int m_window_end; // display window end pos 0-15
@ -56,15 +61,9 @@ protected:
uint8_t m_cursor;
uint16_t m_chars[16];
uint16_t m_outputs[16];
uint8_t m_attrs[16];
uint16_t m_user_data; // user defined character data (16 bit)
uint16_t m_user_def; // user defined character state
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
};
DECLARE_DEVICE_TYPE(BFM_BD1, bfm_bd1_device)

61
src/mame/machine/bfm_bda.cpp
View File

@ -84,20 +84,17 @@ static const uint16_t BDAcharset[]=
};
bfm_bda_device::bfm_bda_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, BFM_BDA, tag, owner, clock),
m_port_val(0)
: device_t(mconfig, BFM_BDA, tag, owner, clock)
, m_outputs()
, m_port_val(0)
{
}
void bfm_bda_device::static_set_value(device_t &device, int val)
{
bfm_bda_device &BDA = downcast<bfm_bda_device &>(device);
BDA.m_port_val = val;
}
void bfm_bda_device::device_start()
{
save_item(NAME(m_cursor));
m_outputs = std::make_unique<output_finder<16> >(*this, "vfd%u", unsigned(m_port_val) << 4);
m_outputs->resolve();
save_item(NAME(m_cursor_pos));
save_item(NAME(m_window_start)); // display window start pos 0-15
save_item(NAME(m_window_end)); // display window end pos 0-15
@ -111,13 +108,12 @@ void bfm_bda_device::device_start()
save_item(NAME(m_display_mode));
save_item(NAME(m_flash_rate));
save_item(NAME(m_flash_control));
save_item(NAME(m_cursor));
save_item(NAME(m_chars));
save_item(NAME(m_attrs));
save_item(NAME(m_outputs));
save_item(NAME(m_user_data)); // user defined character data (16 bit)
save_item(NAME(m_user_def)); // user defined character state
device_reset();
}
void bfm_bda_device::device_reset()
@ -139,9 +135,8 @@ void bfm_bda_device::device_reset()
m_user_data = 0;
m_user_def = 0;
memset(m_chars, 0, sizeof(m_chars));
memset(m_outputs, 0, sizeof(m_outputs));
memset(m_attrs, 0, sizeof(m_attrs));
std::fill(std::begin(m_chars), std::end(m_chars), 0);
std::fill(std::begin(m_attrs), std::end(m_attrs), 0);
}
uint16_t bfm_bda_device::set_display(uint16_t segin)
@ -151,26 +146,13 @@ uint16_t bfm_bda_device::set_display(uint16_t segin)
void bfm_bda_device::device_post_load()
{
for (int i =0; i<16; i++)
{
machine().output().set_indexed_value("vfd", (m_port_val*16) + i, m_outputs[i]);
}
update_display();
}
void bfm_bda_device::update_display()
{
for (int i =0; i<16; i++)
{
if (m_attrs[i] != AT_BLANK)
{
m_outputs[i] = set_display(m_chars[i]);
}
else
{
m_outputs[i] = 0;
}
machine().output().set_indexed_value("vfd", (m_port_val*16) + i, m_outputs[i]);
}
for (int i = 0; i < 16; i++)
(*m_outputs)[i] = (m_attrs[i] != AT_BLANK) ? set_display(m_chars[i]) : 0;
}
///////////////////////////////////////////////////////////////////////////
void bfm_bda_device::blank(int data)
@ -185,6 +167,7 @@ void bfm_bda_device::blank(int data)
}
}
break;
case 0x01: // blank inside window
if ( m_window_size > 0 )
{
@ -194,6 +177,7 @@ void bfm_bda_device::blank(int data)
}
}
break;
case 0x02: // blank outside window
if ( m_window_size > 0 )
{
@ -311,8 +295,8 @@ int bfm_bda_device::write_char(int data)
case 0x01: // clr inside window
if ( m_window_size > 0 )
{
memset(m_chars+m_window_start,0,m_window_size);
memset(m_attrs+m_window_start,0,m_window_size);
std::fill_n(m_chars + m_window_start, m_window_size, 0);
std::fill_n(m_attrs + m_window_start, m_window_size, 0);
}
break;
@ -341,10 +325,8 @@ int bfm_bda_device::write_char(int data)
break;
case 0x03: // clr entire display
{
memset(m_chars, 0, sizeof(m_chars));
memset(m_attrs, 0, sizeof(m_attrs));
}
std::fill(std::begin(m_chars), std::end(m_chars), 0);
std::fill(std::begin(m_attrs), std::end(m_attrs), 0);
}
break;
@ -405,7 +387,6 @@ void bfm_bda_device::setdata(int segdata, int data)
case 0x2C: // semicolon
case 0x2E: // decimal point
if( m_chars[m_pcursor_pos] & (1<<12))
{
move++;
@ -444,7 +425,6 @@ void bfm_bda_device::setdata(int segdata, int data)
switch ( mode )
{
case 0: // rotate left
m_cursor_pos &= 0x0F;
if ( change )
@ -457,7 +437,6 @@ void bfm_bda_device::setdata(int segdata, int data)
case 1: // Rotate right
m_cursor_pos &= 0x0F;
if ( change )
@ -469,7 +448,6 @@ void bfm_bda_device::setdata(int segdata, int data)
break;
case 2: // Scroll left
if ( m_cursor_pos < m_window_end )
{
m_scroll_active = 0;
@ -507,7 +485,6 @@ void bfm_bda_device::setdata(int segdata, int data)
break;
case 3: // Scroll right
if ( m_cursor_pos > m_window_start )
{
if ( change )

24
src/mame/machine/bfm_bda.h
View File

@ -7,12 +7,10 @@
#define MCFG_BFMBDA_ADD(_tag,_val) \
MCFG_DEVICE_ADD(_tag, BFM_BDA,60)\
MCFG_DEVICE_ADD(_tag, BFM_BDA, 60)\
MCFG_BDA_PORT(_val)
#define MCFG_BDA_PORT(_val) \
bfm_bda_device::static_set_value(*device, _val);
#define MCFG_BFMBDA_REMOVE(_tag) \
MCFG_DEVICE_REMOVE(_tag)
downcast<bfm_bda_device &>(*device).set_port_val(_val);
class bfm_bda_device : public device_t
{
@ -20,11 +18,10 @@ public:
bfm_bda_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_value(device_t &device, int val);
void set_port_val(uint8_t val) { m_port_val = val; }
int write_char(int data);
virtual void update_display();
uint8_t m_port_val;
void blank(int data);
void shift_data(int data);
@ -32,11 +29,19 @@ public:
uint16_t set_display(uint16_t segin);
protected:
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
private:
static const uint8_t AT_NORMAL = 0x00;
static const uint8_t AT_FLASH = 0x01;
static const uint8_t AT_BLANK = 0x02;
static const uint8_t AT_FLASHED = 0x80; // set when character should be blinked off
std::unique_ptr<output_finder<16> > m_outputs;
uint8_t m_port_val;
int m_cursor_pos;
int m_window_start; // display window start pos 0-15
int m_window_end; // display window end pos 0-15
@ -50,17 +55,12 @@ protected:
int m_display_mode;
int m_flash_rate;
int m_flash_control;
uint8_t m_cursor;
uint16_t m_chars[16];
uint16_t m_outputs[16];
uint8_t m_attrs[16];
uint16_t m_user_data; // user defined character data (16 bit)
uint16_t m_user_def; // user defined character state
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
};
DECLARE_DEVICE_TYPE(BFM_BDA, bfm_bda_device)