UINT8 ppi8255_device::ppi8255_read_port(int port)
{
UINT8 result = 0x00;
if (m_in_mask[port])
{
ppi8255_input(port, devcb_call_read8(&m_port_read[port], 0));
result |= m_read[port] & m_in_mask[port];
}
result |= m_latch[port] & m_out_mask[port];
switch (port)
{
case 0:
/* clear input buffer full flag */
m_ibf_a = 0;
break;
case 1:
/* clear input buffer full flag */
m_ibf_b = 0;
break;
case 2:
/* read special port 2 signals */
ppi8255_get_handshake_signals(1, &result);
break;
}
return result;
}
static UINT8 get_in_a_value(const device_config *device)
{
pia6821_state *p = get_token(device);
UINT8 port_a_data = 0;
UINT8 ret;
/* update the input */
if (p->in_a_func.read != NULL)
port_a_data = devcb_call_read8(&p->in_a_func, 0);
else
{
if (p->in_a_pushed)
port_a_data = p->in_a;
else
{
/* mark all pins disconnected */
p->port_a_z_mask = 0xff;
if (!p->logged_port_a_not_connected && (p->ddr_a != 0xff))
{
logerror("PIA #%s: Warning! No port A read handler. Assuming pins 0x%02X not connected\n", device->tag, p->ddr_a ^ 0xff);
p->logged_port_a_not_connected = TRUE;
}
}
}
/* - connected pins are always read
- disconnected pins read the output buffer in output mode
- disconnected pins are HI in input mode */
ret = (~p->port_a_z_mask & port_a_data) |
( p->port_a_z_mask & p->ddr_a & p->out_a) |
( p->port_a_z_mask & ~p->ddr_a);
return ret;
}
static UINT8 ppi8255_read_port(running_device *device, int port)
{
ppi8255_t *ppi8255 = get_safe_token(device);
UINT8 result = 0x00;
if (ppi8255->in_mask[port])
{
if (ppi8255->port_read[port].read != NULL)
ppi8255_input(device, port, devcb_call_read8(&ppi8255->port_read[port], 0));
result |= ppi8255->read[port] & ppi8255->in_mask[port];
}
result |= ppi8255->latch[port] & ppi8255->out_mask[port];
switch (port)
{
case 0:
/* clear input buffer full flag */
ppi8255->ibf_a = 0;
break;
case 1:
/* clear input buffer full flag */
ppi8255->ibf_b = 0;
break;
case 2:
/* read special port 2 signals */
ppi8255_get_handshake_signals(ppi8255, 1, &result);
break;
}
return result;
}
inline UINT8 i8355_device::read_port(int port)
{
UINT8 data = m_output[port] & m_ddr[port];
if (m_ddr[port] != 0xff)
{
data |= devcb_call_read8(&m_in_port_func[port], 0) & ~m_ddr[port];
}
return data;
}
inline UINT8 i8155_device::read_port(int port)
{
UINT8 data = 0;
switch (port)
{
case PORT_A:
case PORT_B:
switch (get_port_mode(port))
{
case PORT_MODE_INPUT:
data = devcb_call_read8(&m_in_port_func[port], 0);
break;
case PORT_MODE_OUTPUT:
data = m_output[port];
break;
}
break;
case PORT_C:
switch (get_port_mode(PORT_C))
{
case PORT_MODE_INPUT:
data = devcb_call_read8(&m_in_port_func[port], 0) & 0x3f;
break;
case PORT_MODE_OUTPUT:
data = m_output[port] & 0x3f;
break;
default:
logerror("8155 '%s' Unsupported Port C mode!\n", tag());
}
break;
}
return data;
}
void z80dma_device::do_read()
{
UINT8 mode;
mode = TRANSFER_MODE;
switch(mode) {
case TM_TRANSFER:
case TM_SEARCH:
if (PORTA_IS_SOURCE)
{
if (PORTA_MEMORY)
m_latch = devcb_call_read8(&m_in_mreq_func, m_addressA);
else
m_latch = devcb_call_read8(&m_in_iorq_func, m_addressA);
if (LOG) logerror("Z80DMA '%s' A src: %04x %s -> data: %02x\n", tag(), m_addressA, PORTA_MEMORY ? "mem" : "i/o", m_latch);
m_addressA += PORTA_FIXED ? 0 : PORTA_INC ? PORTA_STEP : -PORTA_STEP;
}
else
{
if (PORTB_MEMORY)
m_latch = devcb_call_read8(&m_in_mreq_func, m_addressB);
else
m_latch = devcb_call_read8(&m_in_iorq_func, m_addressB);
if (LOG) logerror("Z80DMA '%s' B src: %04x %s -> data: %02x\n", tag(), m_addressB, PORTB_MEMORY ? "mem" : "i/o", m_latch);
m_addressB += PORTB_FIXED ? 0 : PORTB_INC ? PORTB_STEP : -PORTB_STEP;
}
break;
case TM_SEARCH_TRANSFER:
fatalerror("z80dma_do_operation: unhandled search & transfer mode !\n");
break;
default:
logerror("z80dma_do_operation: invalid mode %d!\n", mode);
break;
}
}
static UINT8 read_mode0(i8255a_t *i8255a, int port)
{
UINT8 data = 0;
if (port_mode(i8255a, port) == MODE_OUTPUT)
{
/* read data from output latch */
data = i8255a->output[port];
}
else
{
/* read data from port */
data = devcb_call_read8(&i8255a->in_port_func[port], 0);
}
return data;
}
static TIMER_CALLBACK( cdp1852_scan_tick )
{
const device_config *device = (const device_config *)ptr;
cdp1852_t *cdp1852 = get_safe_token(device);
switch (cdp1852->mode)
{
case CDP1852_MODE_INPUT:
/* input data into register */
cdp1852->data = devcb_call_read8(&cdp1852->in_data_func, 0);
/* signal processor */
set_sr_line(cdp1852, 0);
break;
case CDP1852_MODE_OUTPUT:
if (cdp1852->new_data)
{
cdp1852->new_data = 0;
/* latch data into register */
cdp1852->data = cdp1852->next_data;
/* output data */
devcb_call_write8(&cdp1852->out_data_func, 0, cdp1852->data);
/* signal peripheral device */
set_sr_line(cdp1852, 1);
cdp1852->next_sr = 0;
}
else
{
set_sr_line(cdp1852, cdp1852->next_sr);
}
break;
}
}
static UINT8 get_in_b_value(const device_config *device)
{
pia6821_state *p = get_token(device);
UINT8 ret;
if (p->ddr_b == 0xff)
/* all output, just return buffer */
ret = p->out_b;
else
{
UINT8 port_b_data;
/* update the input */
if (p->in_b_func.read != NULL)
port_b_data = devcb_call_read8(&p->in_b_func, 0);
else
{
if (p->in_b_pushed)
port_b_data = p->in_b;
else
{
if (!p->logged_port_b_not_connected && (p->ddr_b != 0xff))
{
logerror("PIA #%s: Error! No port B read handler. Three-state pins 0x%02X are undefined\n", device->tag, p->ddr_b ^ 0xff);
p->logged_port_b_not_connected = TRUE;
}
/* undefined -- need to return something */
port_b_data = 0x00;
}
}
/* the DDR determines if the pin or the output buffer is read */
ret = (p->out_b & p->ddr_b) | (port_b_data & ~p->ddr_b);
}
return ret;
}
static UINT8 read_pc(i8255a_t *i8255a)
{
UINT8 data = 0;
UINT8 mask = 0;
/* PC upper */
switch (group_mode(i8255a, GROUP_A))
{
case MODE_0:
if (port_c_upper_mode(i8255a) == MODE_OUTPUT)
{
/* read data from output latch */
data |= i8255a->output[PORT_C] & 0xf0;
}
else
{
/* read data from port */
mask |= 0xf0;
}
break;
case MODE_1:
data |= i8255a->intr[PORT_A] ? 0x08 : 0x00;
if (port_mode(i8255a, PORT_A) == MODE_OUTPUT)
{
data |= i8255a->obf[PORT_A] ? 0x80 : 0x00;
data |= i8255a->inte[PORT_A] ? 0x40 : 0x00;
mask |= 0x30;
}
else
{
data |= i8255a->ibf[PORT_A] ? 0x20 : 0x00;
data |= i8255a->inte[PORT_A] ? 0x10 : 0x00;
mask |= 0xc0;
}
break;
case MODE_2:
data |= i8255a->intr[PORT_A] ? 0x08 : 0x00;
data |= i8255a->inte2 ? 0x10 : 0x00;
data |= i8255a->ibf[PORT_A] ? 0x20 : 0x00;
data |= i8255a->inte1 ? 0x40 : 0x00;
data |= i8255a->obf[PORT_A] ? 0x80 : 0x00;
break;
}
/* PC lower */
switch (group_mode(i8255a, GROUP_B))
{
case MODE_0:
if (port_c_lower_mode(i8255a) == MODE_OUTPUT)
{
/* read data from output latch */
data |= i8255a->output[PORT_C] & 0x0f;
}
else
{
/* read data from port */
mask |= 0x0f;
}
break;
case MODE_1:
data |= i8255a->inte[PORT_B] ? 0x04 : 0x00;
data |= i8255a->intr[PORT_B] ? 0x01 : 0x00;
if (port_mode(i8255a, PORT_B) == MODE_OUTPUT)
{
data |= i8255a->obf[PORT_B] ? 0x02 : 0x00;
}
else
{
data |= i8255a->ibf[PORT_B] ? 0x02 : 0x00;
}
}
if (mask)
{
/* read data from port */
data |= devcb_call_read8(&i8255a->in_port_func[PORT_C], 0) & mask;
}
return data;
}
static READ8_HANDLER( namco_52xx_R0_r )
{
namco_52xx_state *state = get_safe_token(space->cpu->owner);
return devcb_call_read8(&state->romread, state->address) & 0x0f;
}
static READ8_HANDLER( namco_52xx_SI_r )
{
namco_52xx_state *state = get_safe_token(space->cpu->owner);
return devcb_call_read8(&state->si, 0) ? 1 : 0;
}
static READ8_HANDLER( namco_53xx_Rx_r )
{
namco_53xx_state *state = get_safe_token(space->cpu->owner);
return devcb_call_read8(&state->in[offset], 0);
}
