/* Read/Write common */
void psion_state::io_rw(address_space &space, UINT16 offset)
{
if (space.debugger_access())
return;
switch (offset & 0xffc0)
{
case 0xc0:
/* switch off, CPU goes into standby mode */
m_enable_nmi = 0;
m_stby_pwr = 1;
space.machine().device<cpu_device>("maincpu")->suspend(SUSPEND_REASON_HALT, 1);
break;
case 0x100:
m_pulse = 1;
break;
case 0x140:
m_pulse = 0;
break;
case 0x200:
m_kb_counter = 0;
break;
case 0x180:
beep_set_state(m_beep, 1);
break;
case 0x1c0:
beep_set_state(m_beep, 0);
break;
case 0x240:
if (offset == 0x260 && (m_rom_bank_count || m_ram_bank_count))
{
m_ram_bank=0;
m_rom_bank=0;
update_banks(machine());
}
else
m_kb_counter++;
break;
case 0x280:
if (offset == 0x2a0 && m_ram_bank_count)
{
m_ram_bank++;
update_banks(machine());
}
else
m_enable_nmi = 1;
break;
case 0x2c0:
if (offset == 0x2e0 && m_rom_bank_count)
{
m_rom_bank++;
update_banks(machine());
}
else
m_enable_nmi = 0;
break;
}
}
SYSTEM_CONFIG_END
/* Driver Initialization */
static void setup_beep(int dummy) {
beep_set_state( 0, 0 );
beep_set_frequency( 0, 300 );
}
static MACHINE_START( lx800 )
{
lx800_state *lx800 = machine.driver_data<lx800_state>();
lx800->m_speaker = machine.device(BEEPER_TAG);
beep_set_state(lx800->m_speaker, 0);
beep_set_frequency(lx800->m_speaker, 4000); /* ? */
}
void apollo_kbd_device::beeper::on()
{
if (keyboard_has_beeper())
{
beep_set_frequency(m_beeper, 1000);
beep_set_state(m_beeper, 1);
m_timer->adjust( attotime::from_msec(10), 0, attotime::zero);
}
}
ROM_END
/* Driver Initialization */
TIMER_CALLBACK_MEMBER(sb2m600_state::setup_beep)
{
device_t *speaker = machine().device(BEEPER_TAG);
beep_set_state(speaker, 0);
beep_set_frequency(speaker, 300);
}
static WRITE8_HANDLER( lx800_portc_w )
{
lx800_state *lx800 = space->machine().driver_data<lx800_state>();
logerror("%s: lx800_portc_w(%02x): %02x\n", space->machine().describe_context(), offset, data);
logerror("--> err: %d, ack: %d, fire: %d, buzzer: %d\n", BIT(data, 4), BIT(data, 5), BIT(data, 6), BIT(data, 7));
output_set_value("online_led", !BIT(data, 2));
beep_set_state(lx800->m_speaker, !BIT(data, 7));
}
static TIMER_DEVICE_CALLBACK( update_irq ) //only mm2
{
mephisto_state *state = timer.machine().driver_data<mephisto_state>();
device_t *speaker = timer.machine().device("beep");
cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, ASSERT_LINE);
cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, CLEAR_LINE);
beep_set_state(speaker,state->m_led_status&64?1:0);
}
static INTERRUPT_GEN( vblank_callback )
{
/* also update the speaker on the European version */
beep_device *beep = device->machine->device<beep_device>("beep");
if (beep != NULL)
{
z80ctc_device *ctc = device->machine->device<z80ctc_device>("ctc");
beep_set_state(beep, 1);
beep_set_frequency(beep, ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds));
}
}
INPUT_PORTS_END
TIMER_DEVICE_CALLBACK_MEMBER(mephisto_state::update_nmi)
{
if (m_allowNMI)
{
m_allowNMI = 0;
machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
}
beep_set_state(m_beep, m_led_status&64?1:0);
}
static WRITE8_HANDLER( h19_c0_w )
{
h19_state *state = space->machine().driver_data<h19_state>();
/* Beeper control - a 96L02 contains 2 oneshots, one for bell and one for keyclick.
- lengths need verifying
offset 00-1F = keyclick
offset 20-3F = terminal bell */
UINT8 length = (offset & 0x20) ? 200 : 4;
beep_set_state(state->m_beeper, 1);
space->machine().scheduler().timer_set(attotime::from_msec(length), FUNC(h19_beepoff));
}
INPUT_PORTS_END
static TIMER_DEVICE_CALLBACK( update_nmi )
{
mephisto_state *state = timer.machine().driver_data<mephisto_state>();
device_t *speaker = timer.machine().device("beep");
if (state->m_allowNMI) {
state->m_allowNMI = 0;
cputag_set_input_line(timer.machine(), "maincpu", INPUT_LINE_NMI,PULSE_LINE);
}
beep_set_state(speaker,state->m_led_status&64?1:0);
}
INPUT_PORTS_END
/***************************************************************************
Machine Config(s)
***************************************************************************/
void destiny_state::machine_start()
{
beep_set_frequency(machine().device(BEEPER_TAG),800); // TODO: determine exact frequency thru schematics
beep_set_state(machine().device(BEEPER_TAG),0);
}
static WRITE16_HANDLER( glasgow_lcd_flag_w )
{
glasgow_state *state = space->machine().driver_data<glasgow_state>();
device_t *speaker = space->machine().device("beep");
UINT16 lcd_flag = data & 0x8100;
beep_set_state(speaker, (lcd_flag & 0x100) ? 1 : 0);
if (lcd_flag)
state->m_led7 = 255;
else
{
state->m_led7 = 0;
mboard_key_selector = 1;
}
}
void alphatro_state::machine_reset()
{
// do what the IPL does
// UINT8* RAM = machine().device<ram_device>("ram")->pointer();
UINT8* ROM = memregion("maincpu")->base();
cpu_set_reg(m_maincpu, STATE_GENPC, 0xe000);
memcpy(m_p_ram, ROM, 0xf000); // copy BASIC to RAM, which the undumped IPL is supposed to do.
memcpy(m_p_videoram, ROM+0x1000, 0x1000);
// membank("bank1")->set_base(RAM);
// probably not correct, exact meaning of port is unknown, vblank/vsync is too slow.
m_sys_timer->adjust(attotime::from_usec(10),0,attotime::from_usec(10));
m_serial_timer->adjust(attotime::from_hz(500),0,attotime::from_hz(500)); // USART clock - this is a guesstimate
m_timer_bit = 0;
beep_set_state(m_beep, 0);
beep_set_frequency(m_beep, 950); /* piezo-device needs to be measured */
}
void lx800_state::machine_start()
{
beep_set_state(m_beep, 0);
beep_set_frequency(m_beep, 4000); /* ? */
}
static TIMER_CALLBACK( alphatro_beepoff )
{
alphatro_state *state = machine.driver_data<alphatro_state>();
beep_set_state(state->m_beep, 0);
}
static void studio2_out_q(int level)
{
beep_set_state(0, level);
}
void apollo_kbd_device::beeper::off()
{
beep_set_state(m_beeper, 0);
}
static TIMER_CALLBACK( h19_beepoff )
{
h19_state *state = machine.driver_data<h19_state>();
beep_set_state(state->m_beep, 0);
}
static void port_w(hd61700_cpu_device &device, UINT8 data)
{
beep_set_state(device.machine().device(BEEPER_TAG), (BIT(data,7) ^ BIT(data,6)));
//printf("%x\n", data);
}
