void i8251_device::device_reset()
{
LOG(("I8251: Reset\n"));
/* what is the default setup when the 8251 has been reset??? */
/* i8251 datasheet explains the state of tx pin at reset */
/* tx is set to 1 */
set_out_data_bit(1);
/* assumption, rts is set to 1 */
m_connection_state &= ~SERIAL_STATE_RTS;
serial_connection_out();
transmit_register_reset();
receive_register_reset();
/* expecting mode byte */
m_flags |= I8251_EXPECTING_MODE;
/* not expecting a sync byte */
m_flags &= ~I8251_EXPECTING_SYNC_BYTE;
/* no character to read by cpu */
/* transmitter is ready and is empty */
m_status = I8251_STATUS_TX_EMPTY | I8251_STATUS_TX_READY;
m_mode_byte = 0;
m_command = 0;
/* update tx empty pin output */
update_tx_empty();
/* update rx ready pin output */
update_rx_ready();
/* update tx ready pin output */
update_tx_ready();
}
void wangpc_keyboard_device::device_reset()
{
transmit_register_reset();
receive_register_reset();
set_out_data_bit(1);
serial_connection_out();
}
static TIMER_CALLBACK(poly88_cassette_timer_callback)
{
poly88_state *state = machine.driver_data<poly88_state>();
int data;
int current_level;
// if (!(input_port_read(machine, "DSW0") & 0x02)) /* V.24 / Tape Switch */
//{
/* tape reading */
if (cassette_get_state(machine.device("cassette"))&CASSETTE_PLAY)
{
if (state->m_clk_level_tape)
{
state->m_previous_level = (cassette_input(machine.device("cassette")) > 0.038) ? 1 : 0;
state->m_clk_level_tape = 0;
}
else
{
current_level = (cassette_input(machine.device("cassette")) > 0.038) ? 1 : 0;
if (state->m_previous_level!=current_level)
{
data = (!state->m_previous_level && current_level) ? 1 : 0;
//data = current_level;
set_out_data_bit(state->m_cassette_serial_connection.State, data);
serial_connection_out(machine, &state->m_cassette_serial_connection);
msm8251_receive_clock(machine.device("uart"));
state->m_clk_level_tape = 1;
}
}
}
/* tape writing */
if (cassette_get_state(machine.device("cassette"))&CASSETTE_RECORD)
{
data = get_in_data_bit(state->m_cassette_serial_connection.input_state);
data ^= state->m_clk_level_tape;
cassette_output(machine.device("cassette"), data&0x01 ? 1 : -1);
if (!state->m_clk_level_tape)
msm8251_transmit_clock(machine.device("uart"));
state->m_clk_level_tape = state->m_clk_level_tape ? 0 : 1;
return;
}
state->m_clk_level_tape = 1;
if (!state->m_clk_level)
msm8251_transmit_clock(machine.device("uart"));
state->m_clk_level = state->m_clk_level ? 0 : 1;
// }
}
void mos6551_device::update_serial()
{
int brg = m_ctrl & CTRL_BRG_MASK;
if (brg == CTRL_BRG_16X_EXTCLK)
{
set_rcv_rate(m_ext_rxc / 16);
set_tra_rate(m_ext_rxc / 16);
}
else
{
int baud = clock() / brg_divider[brg] / 16;
set_tra_rate(baud);
if (m_ctrl & CTRL_RXC_BRG)
{
set_rcv_rate(baud);
}
else
{
set_rcv_rate(m_ext_rxc / 16);
}
int num_data_bits = 8;
int stop_bit_count = 1;
int parity_code = PARITY_NONE;
switch (m_ctrl & CTRL_WL_MASK)
{
case CTRL_WL_8: num_data_bits = 8; break;
case CTRL_WL_7: num_data_bits = 7; break;
case CTRL_WL_6: num_data_bits = 6; break;
case CTRL_WL_5: num_data_bits = 5; break;
}
set_data_frame(num_data_bits, stop_bit_count, parity_code, false);
}
if (m_cmd & CMD_DTR)
m_connection_state |= DTR;
else
m_connection_state &= ~DTR;
m_dtr_handler((m_connection_state & DTR) ? 0 : 1);
if ((m_cmd & CMD_TC_MASK) == CMD_TC_RTS_HI)
m_connection_state &= ~RTS;
else
m_connection_state |= RTS;
m_rts_handler((m_connection_state & RTS) ? 0 : 1);
serial_connection_out();
}
void i8251_device::update_tx_empty()
{
if (m_status & I8251_STATUS_TX_EMPTY)
{
/* tx is in marking state (high) when tx empty! */
set_out_data_bit(1);
serial_connection_out();
}
m_out_txempty_func((m_status & I8251_STATUS_TX_EMPTY) != 0);
}
void z80dart_channel::set_rts(int state)
{
m_out_rts_func(state);
if (state)
m_connection_state &= ~SERIAL_STATE_RTS;
else
m_connection_state |= SERIAL_STATE_RTS;
serial_connection_out();
}
void z80dart_channel::set_dtr(int state)
{
m_dtr = state;
m_out_dtr_func(m_dtr);
if (state)
m_connection_state &= ~SERIAL_STATE_DTR;
else
m_connection_state |= SERIAL_STATE_DTR;
serial_connection_out();
}
/* only works for one cassette so far */
static void exidy_cassette_timer_callback(int dummy)
{
cassette_clock_counter++;
if (cassette_clock_counter==(4800/1200))
{
/* reset counter */
cassette_clock_counter = 0;
/* toggle state of clock */
cassette_clock_state^=0x0ffffffff;
/* previously was 0, now gone 1 */
/* +ve edge detected */
if (cassette_clock_state)
{
int bit;
/* clock bits into cassette flip flops */
/* bit is inverted! */
/* detect level */
bit = 1;
if (cassette_input(image_from_devtype_and_index(IO_CASSETTE, 0)) > 0.0038)
bit = 0;
cassette_input_ff[0] = bit;
/* detect level */
bit = 1;
if (cassette_input(image_from_devtype_and_index(IO_CASSETTE, 1)) > 0.0038)
bit = 0;
cassette_input_ff[1] = bit;
logerror("cassette bit: %0d\n",bit);
/* set out data bit */
set_out_data_bit(cassette_serial_connection.State, cassette_input_ff[0]);
/* output through serial connection */
serial_connection_out(&cassette_serial_connection);
/* update hd6402 receive clock */
hd6402_receive_clock();
}
}
}
inline void im6402_device::transmit()
{
if (is_transmit_register_empty() && !m_tbre)
{
transmit_register_setup(m_tbr);
set_tbre(ASSERT_LINE);
set_tre(CLEAR_LINE);
}
if (!is_transmit_register_empty())
{
int bit = transmit_register_get_data_bit();
m_out_tro_func(bit);
serial_connection_out();
if (is_transmit_register_empty())
{
set_tre(ASSERT_LINE);
}
}
}
void i8251_device::transmit_clock()
{
/* transmit enable? */
if (m_command & (1<<0))
{
/* transmit register full? */
if ((m_status & I8251_STATUS_TX_READY)==0)
{
/* if transmit reg is empty */
if (is_transmit_register_empty())
{
/* set it up */
transmit_register_setup(m_data);
/* i8251 transmit reg now empty */
m_status |=I8251_STATUS_TX_EMPTY;
/* ready for next transmit */
m_status |=I8251_STATUS_TX_READY;
update_tx_empty();
update_tx_ready();
}
}
/* if transmit is not empty... transmit data */
if (!is_transmit_register_empty())
{
UINT8 data = transmit_register_get_data_bit();
// logerror("I8251\n");
//transmit_register_send_bit();
m_out_txd_func(data);
m_connection_state &=~SERIAL_STATE_TX_DATA;
m_connection_state|=(data<<5);
serial_connection_out();
}
}
#if 0
/* hunt mode? */
/* after each bit has been shifted in, it is compared against the current sync byte */
if (m_command & (1<<7))
{
/* data matches sync byte? */
if (m_data == m_sync_bytes[m_sync_byte_offset])
{
/* sync byte matches */
/* update for next sync byte? */
m_sync_byte_offset++;
/* do all sync bytes match? */
if (m_sync_byte_offset == m_sync_byte_count)
{
/* ent hunt mode */
m_command &=~(1<<7);
}
}
else
{
/* if there is no match, reset */
m_sync_byte_offset = 0;
}
}
#endif
}
