static void mcr68_common_init(void)
{
int i;
/* reset the 6840's */
m6840_counter_periods[0] = ATTOTIME_IN_HZ(30); /* clocked by /VBLANK */
m6840_counter_periods[1] = attotime_never; /* grounded */
m6840_counter_periods[2] = ATTOTIME_IN_HZ(512 * 30); /* clocked by /HSYNC */
m6840_status = 0x00;
m6840_status_read_since_int = 0x00;
m6840_msb_buffer = m6840_lsb_buffer = 0;
for (i = 0; i < 3; i++)
{
struct counter_state *m6840 = &m6840_state[i];
m6840->control = 0x00;
m6840->latch = 0xffff;
m6840->count = 0xffff;
timer_enable(m6840->timer, FALSE);
m6840->timer_active = 0;
m6840->period = m6840_counter_periods[i];
}
/* initialize the clock */
m6840_internal_counter_period = ATTOTIME_IN_HZ(cpunum_get_clock(0) / 10);
/* reset cocktail flip */
mcr_cocktail_flip = 0;
/* initialize the sound */
mcr_sound_reset();
}
void DS2404_init(running_machine *machine, int ref_year, int ref_month, int ref_day)
{
struct tm ref_tm;
time_t ref_time;
time_t current_time;
emu_timer *timer;
memset( &ref_tm, 0, sizeof( ref_tm ) );
ref_tm.tm_year = ref_year - 1900;
ref_tm.tm_mon = ref_month - 1;
ref_tm.tm_mday = ref_day;
ref_time = mktime( &ref_tm );
time( ¤t_time );
current_time -= ref_time;
ds2404.rtc[ 0 ] = 0x0;
ds2404.rtc[ 1 ] = ( current_time >> 0 ) & 0xff;
ds2404.rtc[ 2 ] = ( current_time >> 8 ) & 0xff;
ds2404.rtc[ 3 ] = ( current_time >> 16 ) & 0xff;
ds2404.rtc[ 4 ] = ( current_time >> 24 ) & 0xff;
timer = timer_alloc( machine, DS2404_tick , NULL);
timer_adjust_periodic( timer, ATTOTIME_IN_HZ( 256 ), 0, ATTOTIME_IN_HZ( 256 ) );
}
void microtouch_init(running_machine *machine, microtouch_tx_func tx_cb, microtouch_touch_func touch_cb)
{
memset(µtouch, 0, sizeof(microtouch));
microtouch.last_touch_state = -1;
microtouch.tx_callback = tx_cb;
microtouch.touch_callback = touch_cb;
microtouch.timer = timer_alloc(machine, microtouch_timer_callback, NULL);
timer_adjust_periodic(microtouch.timer, ATTOTIME_IN_HZ(167*5), 0, ATTOTIME_IN_HZ(167*5));
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.reset_done);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.format_tablet);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_inactive);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_stream);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_touch_state);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_x);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_y);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.rx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.rx_buffer_ptr);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.tx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_num);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_ptr);
};
void z80dart_device::device_start()
{
// resolve callbacks
devcb_resolve_write_line(&m_out_int_func, &m_config.m_out_int_func, this);
m_channel[Z80DART_CH_A].start(this, Z80DART_CH_A, m_config.m_in_rxda_func, m_config.m_out_txda_func, m_config.m_out_dtra_func, m_config.m_out_rtsa_func, m_config.m_out_wrdya_func);
m_channel[Z80DART_CH_B].start(this, Z80DART_CH_B, m_config.m_in_rxdb_func, m_config.m_out_txdb_func, m_config.m_out_dtrb_func, m_config.m_out_rtsb_func, m_config.m_out_wrdyb_func);
if (m_config.m_rx_clock_a != 0)
{
// allocate channel A receive timer
m_rxca_timer = timer_alloc(&m_machine, dart_channel::static_rxca_tick, (void *)&m_channel[Z80DART_CH_A]);
timer_adjust_periodic(m_rxca_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_rx_clock_a));
}
if (m_config.m_tx_clock_a != 0)
{
// allocate channel A transmit timer
m_txca_timer = timer_alloc(&m_machine, dart_channel::static_txca_tick, (void *)&m_channel[Z80DART_CH_A]);
timer_adjust_periodic(m_txca_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_tx_clock_a));
}
if (m_config.m_rx_tx_clock_b != 0)
{
// allocate channel B receive/transmit timer
m_rxtxcb_timer = timer_alloc(&m_machine, dart_channel::static_rxtxcb_tick, (void *)&m_channel[Z80DART_CH_B]);
timer_adjust_periodic(m_rxtxcb_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_rx_tx_clock_b));
}
state_save_register_device_item_array(this, 0, m_int_state);
}
static WRITE8_HANDLER( polyplay_start_timer2 )
{
if (data == 0x03)
timer_adjust(polyplay_timer, attotime_never, 0, attotime_never);
if (data == 0xb5)
timer_adjust(polyplay_timer, ATTOTIME_IN_HZ(40), 0, ATTOTIME_IN_HZ(40));
}
static DEVICE_START( cdp1852 )
{
cdp1852_t *cdp1852 = get_safe_token(device);
const cdp1852_interface *intf = get_interface(device);
/* resolve callbacks */
devcb_resolve_read8(&cdp1852->in_data_func, &intf->in_data_func, device);
devcb_resolve_write8(&cdp1852->out_data_func, &intf->out_data_func, device);
devcb_resolve_write_line(&cdp1852->out_sr_func, &intf->out_sr_func, device);
/* set initial values */
cdp1852->mode = (cdp1852_mode)intf->mode;
if (device->clock > 0)
{
/* create the scan timer */
cdp1852->scan_timer = timer_alloc(device->machine, cdp1852_scan_tick, (void *)device);
timer_adjust_periodic(cdp1852->scan_timer, attotime_zero, 0, ATTOTIME_IN_HZ(device->clock));
}
/* register for state saving */
state_save_register_device_item(device, 0, cdp1852->new_data);
state_save_register_device_item(device, 0, cdp1852->data);
state_save_register_device_item(device, 0, cdp1852->next_data);
state_save_register_device_item(device, 0, cdp1852->sr);
state_save_register_device_item(device, 0, cdp1852->next_sr);
}
static void msm5205_playmode(msm5205_state *voice,int select)
{
static const int prescaler_table[4] = {96,48,64,0};
int prescaler = prescaler_table[select & 3];
int bitwidth = (select & 4) ? 4 : 3;
if( voice->prescaler != prescaler )
{
stream_update(voice->stream);
voice->prescaler = prescaler;
/* timer set */
if( prescaler )
{
attotime period = attotime_mul(ATTOTIME_IN_HZ(voice->clock), prescaler);
timer_adjust_periodic(voice->timer, period, 0, period);
}
else
timer_adjust_oneshot(voice->timer, attotime_never, 0);
}
if( voice->bitwidth != bitwidth )
{
stream_update(voice->stream);
voice->bitwidth = bitwidth;
}
}
void z80dma_device::update_status()
{
UINT16 pending_transfer;
attotime next;
// no transfer is active right now; is there a transfer pending right now?
pending_transfer = is_ready() & m_dma_enabled;
if (pending_transfer)
{
m_is_read = true;
m_cur_cycle = (PORTA_IS_SOURCE ? PORTA_CYCLE_LEN : PORTB_CYCLE_LEN);
next = ATTOTIME_IN_HZ(clock());
timer_adjust_periodic(m_timer,
attotime_zero,
0,
// 1 byte transferred in 4 clock cycles
next);
}
else
{
if (m_is_read)
{
// no transfers active right now
timer_reset(m_timer, attotime_never);
}
}
// set the busreq line
devcb_call_write_line(&m_out_busreq_func, pending_transfer ? ASSERT_LINE : CLEAR_LINE);
}
static void dma8257_update_status(const device_config *device)
{
dma8257_t *dma8257 = get_safe_token(device);
UINT16 pending_transfer;
attotime next;
/* no transfer is active right now; is there a transfer pending right now? */
pending_transfer = dma8257->drq & (dma8257->mode & 0x0F);
if (pending_transfer)
{
next = ATTOTIME_IN_HZ(device->clock / 4 );
timer_adjust_periodic(dma8257->timer,
attotime_zero,
0,
/* 1 byte transferred in 4 clock cycles */
next);
}
else
{
/* no transfers active right now */
timer_reset(dma8257->timer, attotime_never);
}
/* set the halt line */
if (dma8257->intf && dma8257->intf->cputag != NULL)
{
cputag_set_input_line(device->machine, dma8257->intf->cputag, INPUT_LINE_HALT,
pending_transfer ? ASSERT_LINE : CLEAR_LINE);
}
}
static CPU_INIT( sc61860 )
{
sc61860_state *cpustate = get_safe_token(device);
cpustate->config = (sc61860_cpu_core *) device->static_config;
timer_pulse(device->machine, ATTOTIME_IN_HZ(500), cpustate, 0, sc61860_2ms_tick);
cpustate->device = device;
cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
static WRITE8_HANDLER( sound_nmi_rate_w )
{
/* rate is controlled by the value written here */
/* this value is latched into up-counters, which are clocked at the */
/* input clock / 256 */
attotime nmi_rate = attotime_mul(ATTOTIME_IN_HZ(4000000), 4096 * (256 - data));
timer_adjust(sound_nmi_timer, nmi_rate, 0, nmi_rate);
}
static void f3853_timer_start(running_device *device, UINT8 value)
{
f3853_t *f3853 = get_safe_token( device );
attotime period = (value != 0xff) ? attotime_mul(ATTOTIME_IN_HZ(device->clock), f3853_value_to_cycle[value]*31) : attotime_never;
timer_adjust_oneshot(f3853->timer, period, 0);
}
void sega_usb_reset(UINT8 t1_clock_mask)
{
/* halt the USB CPU at reset time */
cpunum_set_input_line(Machine, usb.cpunum, INPUT_LINE_RESET, ASSERT_LINE);
/* start the clock timer */
timer_pulse(attotime_mul(ATTOTIME_IN_HZ(USB_2MHZ_CLOCK), 256), NULL, 0, increment_t1_clock);
usb.t1_clock_mask = t1_clock_mask;
}
static void adjust_display_position_interrupt_timer(running_machine *machine)
{
if ((display_counter + 1) != 0)
{
attotime period = attotime_mul(ATTOTIME_IN_HZ(NEOGEO_PIXEL_CLOCK), display_counter + 1);
if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer current y: %02x current x: %02x target y: %x target x: %x\n", video_screen_get_vpos(machine->primary_screen), video_screen_get_hpos(machine->primary_screen), (display_counter + 1) / NEOGEO_HTOTAL, (display_counter + 1) % NEOGEO_HTOTAL);
timer_adjust_oneshot(display_position_interrupt_timer, period, 0);
}
}
static void a310_set_timer(int tmr)
{
double freq;
if(ioc_timercnt[tmr] != 0) // FIXME: dmdtouch does a divide by zero?
{
freq = 2000000.0 / (double)ioc_timercnt[tmr];
// logerror("IOC: starting timer %d, %d ticks, freq %f Hz\n", tmr, ioc_timercnt[tmr], freq);
timer_adjust_oneshot(timer[tmr], ATTOTIME_IN_HZ(freq), tmr);
}
}
static TIMER_CALLBACK( nmi_callback )
{
/* assert the NMI if it is not disabled */
nmi_state = 1;
nmi_state_update(machine);
/* set a timer to turn it off again on hte next SOUND_CLOCK/16 */
timer_set(machine, ATTOTIME_IN_HZ(SOUND2_CLOCK/16), NULL, 0, nmi_clear);
/* adjust the NMI timer for the next time */
nmi_timer_adjust();
}
static void adjust_display_position_interrupt_timer( running_machine *machine )
{
neogeo_state *state = (neogeo_state *)machine->driver_data;
if ((state->display_counter + 1) != 0)
{
attotime period = attotime_mul(ATTOTIME_IN_HZ(NEOGEO_PIXEL_CLOCK), state->display_counter + 1);
if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer current y: %02x current x: %02x target y: %x target x: %x\n", machine->primary_screen->vpos(), machine->primary_screen->hpos(), (state->display_counter + 1) / NEOGEO_HTOTAL, (state->display_counter + 1) % NEOGEO_HTOTAL);
timer_adjust_oneshot(state->display_position_interrupt_timer, period, 0);
}
}
static void timer_handler(void *param,int c,int count,int clock)
{
struct ym2203_info *info = param;
if( count == 0 )
{ /* Reset FM Timer */
timer_enable(info->timer[c], 0);
}
else
{ /* Start FM Timer */
attotime period = attotime_mul(ATTOTIME_IN_HZ(clock), count);
if (!timer_enable(info->timer[c], 1))
timer_adjust_oneshot(info->timer[c], period, 0);
}
}
void kbdc8042_init(running_machine *machine, const struct kbdc8042_interface *intf)
{
poll_delay = 10;
memset(&kbdc8042, 0, sizeof(kbdc8042));
kbdc8042.type = intf->type;
kbdc8042.set_gate_a20 = intf->set_gate_a20;
kbdc8042.keyboard_interrupt = intf->keyboard_interrupt;
kbdc8042.get_out2 = intf->get_out2;
/* ibmat bios wants 0x20 set! (keyboard locked when not set) 0x80 */
kbdc8042.inport = 0xa0;
at_8042_set_outport(machine, 0xfe, 1);
timer_pulse(machine, ATTOTIME_IN_HZ(60), NULL, 0, kbdc8042_time);
}
AM_RANGE(0x00, 0x3f) AM_RAM
ADDRESS_MAP_END
/****************************************************************************
* Initialize emulation
****************************************************************************/
static void cop410_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
int i;
memset(&R, 0, sizeof(R));
R.G_mask = 0x0F;
R.D_mask = 0x0F;
cop410_serial_timer = timer_alloc(cop410_serial_tick, NULL);
timer_adjust_periodic(cop410_serial_timer, attotime_zero, index, ATTOTIME_IN_HZ(clock));
for (i=0; i<256; i++) InstLen[i]=1;
InstLen[0x60] = InstLen[0x61] = InstLen[0x68] = InstLen[0x69] = InstLen[0x33] = InstLen[0x23] = 2;
for (i=0; i<256; i++) LBIops[i] = 0;
for (i=0x08; i<0x10; i++) LBIops[i] = 1;
for (i=0x18; i<0x20; i++) LBIops[i] = 1;
for (i=0x28; i<0x30; i++) LBIops[i] = 1;
for (i=0x38; i<0x40; i++) LBIops[i] = 1;
state_save_register_item("cop410", index, PC);
state_save_register_item("cop410", index, R.PREVPC);
state_save_register_item("cop410", index, A);
state_save_register_item("cop410", index, B);
state_save_register_item("cop410", index, C);
state_save_register_item("cop410", index, EN);
state_save_register_item("cop410", index, G);
state_save_register_item("cop410", index, Q);
state_save_register_item("cop410", index, SA);
state_save_register_item("cop410", index, SB);
state_save_register_item("cop410", index, SIO);
state_save_register_item("cop410", index, SKL);
state_save_register_item("cop410", index, skip);
state_save_register_item("cop410", index, skipLBI);
state_save_register_item("cop410", index, R.G_mask);
state_save_register_item("cop410", index, R.D_mask);
state_save_register_item("cop410", index, R.last_si);
}
static void sslam_play(const device_config *device, int track, int data)
{
int status = okim6295_r(device,0);
if (data < 0x80) {
if (track) {
if (sslam_track != data) {
sslam_track = data;
sslam_bar = 1;
if (status & 0x08)
okim6295_w(device,0,0x40);
okim6295_w(device,0,(0x80 | data));
okim6295_w(device,0,0x81);
timer_adjust_periodic(music_timer, ATTOTIME_IN_MSEC(4), 0, ATTOTIME_IN_HZ(250)); /* 250Hz for smooth sequencing */
}
}
else {
if ((status & 0x01) == 0) {
okim6295_w(device,0,(0x80 | data));
okim6295_w(device,0,0x11);
}
else if ((status & 0x02) == 0) {
okim6295_w(device,0,(0x80 | data));
okim6295_w(device,0,0x21);
}
else if ((status & 0x04) == 0) {
okim6295_w(device,0,(0x80 | data));
okim6295_w(device,0,0x41);
}
}
}
else { /* use above 0x80 to turn off channels */
if (track) {
timer_enable(music_timer,0);
sslam_track = 0;
sslam_melody = 0;
sslam_bar = 0;
}
data &= 0x7f;
okim6295_w(device,0,data);
}
}
static void duart68681_write_TX(duart68681_state* duart68681, int ch, UINT8 data)
{
attotime period;
duart68681->channel[ch].tx_data = data;
// tx_ready will stay on in local loopback mode
if ((duart68681->channel[ch].MR2 & 0xc0) != 0x80) {
duart68681->channel[ch].tx_ready = 0;
duart68681->channel[ch].SR &= ~STATUS_TRANSMITTER_READY;
}
if (ch == 0)
duart68681->ISR &= ~INT_TXRDYA;
else
duart68681->ISR &= ~INT_TXRDYB;
duart68681_update_interrupts(duart68681);
period = ATTOTIME_IN_HZ(duart68681->channel[ch].baud_rate / 10 );
timer_adjust_oneshot(duart68681->channel[ch].tx_timer, period, ch);
// if local loopback is on, write the transmitted data as if a byte had been recieved
if ((duart68681->channel[ch].MR2&0xC0) == 0x80)
{
if ( duart68681->channel[ch].rx_fifo_num >= RX_FIFO_SIZE )
{
LOG(( "68681: FIFO overflow\n" ));
duart68681->channel[ch].SR |= STATUS_OVERRUN_ERROR;
return;
}
duart68681->channel[ch].rx_fifo[duart68681->channel[ch].rx_fifo_write_ptr++] = data;
if ( duart68681->channel[ch].rx_fifo_write_ptr == RX_FIFO_SIZE )
{
duart68681->channel[ch].rx_fifo_write_ptr = 0;
}
duart68681->channel[ch].rx_fifo_num++;
duart68681_update_interrupts(duart68681);
}
};
static TIMER_CALLBACK( riot_interrupt )
{
/* if we're doing the initial interval counting... */
if (riot_state == RIOT_COUNT)
{
/* generate the IRQ */
riot_irq_flag |= 0x80;
riot_irq_state = riot_timer_irq_enable;
update_irq_state(0);
/* now start counting clock cycles down */
riot_state = RIOT_POST_COUNT;
timer_adjust_oneshot(riot_timer, attotime_mul(ATTOTIME_IN_HZ(SH6532_CLOCK), 0xff), 0);
}
/* if not, we are done counting down */
else
{
riot_state = RIOT_IDLE;
timer_adjust_oneshot(riot_timer, attotime_never, 0);
}
}
else
{
// transparent disable
nbmj8891_videoram1[(dy2 * width) + dx1] = color1;
update_pixel1(dx1, dy2);
nbmj8891_videoram1[(dy2 * width) + dx2] = color2;
update_pixel1(dx2, dy2);
}
}
nb1413m3_busyctr++;
}
}
nb1413m3_busyflag = 0;
timer_set(attotime_mul(ATTOTIME_IN_HZ(400000), nb1413m3_busyctr), NULL, 0, blitter_timer_callback);
}
/******************************************************************************
******************************************************************************/
VIDEO_START( nbmj8891_1layer )
{
UINT8 *CLUT = memory_region(REGION_USER1);
int i;
int width = video_screen_get_width(machine->primary_screen);
int height = video_screen_get_height(machine->primary_screen);
nbmj8891_tmpbitmap0 = video_screen_auto_bitmap_alloc(machine->primary_screen);
nbmj8891_videoram0 = auto_malloc(width * height * sizeof(char));
static WRITE8_HANDLER( exidy_shriot_w )
{
/* I/O is done if A2 == 0 */
if ((offset & 0x04) == 0)
{
switch (offset & 0x03)
{
case 0: /* port A */
if (has_mc3417)
cpunum_set_input_line(machine, 2, INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
riot_porta_data = (riot_porta_data & ~riot_porta_ddr) | (data & riot_porta_ddr);
break;
case 1: /* port A DDR */
riot_porta_ddr = data;
break;
case 2: /* port B */
if (has_tms5220)
{
if (!(data & 0x01) && (riot_portb_data & 0x01))
{
riot_porta_data = tms5220_status_r(machine, 0);
logerror("(%f)%04X:TMS5220 status read = %02X\n", attotime_to_double(timer_get_time()), activecpu_get_previouspc(), riot_porta_data);
}
if (!(data & 0x02) && (riot_portb_data & 0x02))
{
logerror("(%f)%04X:TMS5220 data write = %02X\n", attotime_to_double(timer_get_time()), activecpu_get_previouspc(), riot_porta_data);
tms5220_data_w(machine, 0, riot_porta_data);
}
}
riot_portb_data = (riot_portb_data & ~riot_portb_ddr) | (data & riot_portb_ddr);
break;
case 3: /* port B DDR */
riot_portb_ddr = data;
break;
}
}
/* PA7 edge detect control if A2 == 1 and A4 == 0 */
else if ((offset & 0x10) == 0)
{
riot_PA7_irq_enable = offset & 0x03;
}
/* timer enable if A2 == 1 and A4 == 1 */
else
{
static const int divisors[4] = { 1, 8, 64, 1024 };
/* make sure the IRQ state is clear */
if (riot_state != RIOT_COUNT)
riot_irq_flag &= ~0x80;
riot_irq_state = 0;
update_irq_state(0);
/* set the enable from the offset */
riot_timer_irq_enable = (offset & 0x08) ? 1 : 0;
/* set a new timer */
riot_clock_divisor = divisors[offset & 0x03];
timer_adjust_oneshot(riot_timer, attotime_mul(ATTOTIME_IN_HZ(SH6532_CLOCK), data * riot_clock_divisor), 0);
riot_state = RIOT_COUNT;
}
}
attotime via6522_device::cycles_to_time(int c)
{
return attotime_mul(ATTOTIME_IN_HZ(clock()), c);
}
static void cchasm_refresh (void)
{
int pc = 0;
int done = 0;
int opcode, data;
int currentx = 0, currenty = 0;
int scalex = 0, scaley = 0;
int color = 0;
int total_length = 1; /* length of all lines drawn in a frame */
int move = 0;
vector_clear_list();
while (!done)
{
data = cchasm_ram[pc];
opcode = data >> 12;
data &= 0xfff;
if ((opcode > COLOR) && (data & 0x800))
data |= 0xfffff000;
pc++;
switch (opcode)
{
case HALT:
done=1;
break;
case JUMP:
pc = data - 0xb00;
logerror("JUMP to %x\n", data);
break;
case COLOR:
color = VECTOR_COLOR444(data ^ 0xfff);
break;
case SCALEY:
scaley = data << 5;
break;
case POSY:
move = 1;
currenty = ycenter + (data << 16);
break;
case SCALEX:
scalex = data << 5;
break;
case POSX:
move = 1;
currentx = xcenter - (data << 16);
break;
case LENGTH:
if (move)
{
vector_add_point (currentx, currenty, 0, 0);
move = 0;
}
currentx -= data * scalex;
currenty += data * scaley;
total_length += abs(data);
if (color)
vector_add_point (currentx, currenty, color, 0xff);
else
move = 1;
break;
default:
logerror("Unknown refresh proc opcode %x with data %x at pc = %x\n", opcode, data, pc-2);
done = 1;
break;
}
}
/* Refresh processor runs with 6 MHz */
timer_set (attotime_mul(ATTOTIME_IN_HZ(6000000), total_length), NULL, 0, cchasm_refresh_end);
}
INLINE attotime compute_time_per_character(z80sio *sio, int which)
{
/* fix me -- should compute properly and include data, stop, parity bits */
return attotime_mul(ATTOTIME_IN_HZ(9600), 10);
}
INLINE void nmi_timer_adjust(void)
{
/* adjust timer to go off in the future based on the current rate */
timer_adjust_oneshot(nmi_timer, attotime_mul(ATTOTIME_IN_HZ(SOUND2_CLOCK/16), 256 * (256 - nmi_rate)), 0);
}
}
}
}
}
mc146818->updated = 1; /* clock has been updated */
mc146818->last_refresh = timer_get_time(machine);
}
void mc146818_init(running_machine *machine, MC146818_TYPE type)
{
mc146818 = auto_alloc_clear(machine, struct mc146818_chip);
mc146818->type = type;
mc146818->last_refresh = timer_get_time(machine);
timer_pulse(machine, ATTOTIME_IN_HZ(1), NULL, 0, mc146818_timer);
mc146818_set_base_datetime(machine);
}
void mc146818_load(running_machine *machine)
{
mame_file *file;
file = nvram_fopen(machine, OPEN_FLAG_READ);
if (file)
{
mc146818_load_stream(file);
mame_fclose(file);
}
