UINT64 msm6242_device::bump(int rtc_register, UINT64 delta, UINT64 register_min, UINT64 register_range)
{
UINT64 carry = 0;
if (delta > 0)
{
// get the register value
UINT64 register_value = (rtc_register == RTC_TICKS)
? m_tick
: get_clock_register(rtc_register);
// increment the value
UINT64 new_register_value = ((register_value - register_min + delta) % register_range) + register_min;
// calculate the cary
carry = ((register_value - register_min) + delta) / register_range;
// store the new register value
if (rtc_register == RTC_TICKS)
m_tick = (UINT16) new_register_value;
else
set_clock_register(rtc_register, (int) new_register_value);
}
return carry;
}
void msm6242_device::update_timer()
{
UINT64 callback_ticks = 0;
attotime callback_time = attotime::never;
// we only need to call back if the IRQ flag is on, and we have a handler
if (!m_out_int_handler.isnull() && m_irq_flag == 1)
{
switch(m_irq_type)
{
case IRQ_HOUR:
callback_ticks += (59 - get_clock_register(RTC_MINUTE)) * (0x8000 * 60);
// fall through
case IRQ_MINUTE:
callback_ticks += (59 - get_clock_register(RTC_SECOND)) * 0x8000;
// fall through
case IRQ_SECOND:
callback_ticks += 0x8000 - m_tick;
break;
case IRQ_64THSECOND:
callback_ticks += 0x200 - (m_tick % 0x200);
break;
}
}
// if set, convert ticks to an attotime
if (callback_ticks > 0)
{
// get the current time
UINT64 curtime = current_time();
// we need the absolute callback time, in ticks
UINT64 absolute_callback_ticks = curtime + callback_ticks;
// convert that to an attotime
attotime absolute_callback_time = attotime::from_ticks(absolute_callback_ticks, clock());
// and finally get the delta as an attotime
callback_time = absolute_callback_time - machine().time();
}
m_timer->adjust(callback_time);
}
void device_rtc_interface::adjust_seconds()
{
int seconds = get_clock_register(RTC_SECOND);
set_clock_register(RTC_SECOND, 0);
if (seconds >= 30)
{
advance_minutes();
}
else
{
clock_updated();
}
}
UINT8 msm6242_device::get_clock_nibble(int rtc_register, bool high)
{
int value = get_clock_register(rtc_register);
value /= high ? 10 : 1;
return (UINT8) ((value % 10) & 0x0F);
}
void hp98035_io_card::log_current_time(void)
{
LOG(("Time = %d:%d:%d:%d:%d\n" , get_clock_register(RTC_MONTH) ,
get_clock_register(RTC_DAY) , get_clock_register(RTC_HOUR) ,
get_clock_register(RTC_MINUTE) , get_clock_register(RTC_SECOND)));
}
void hp98035_io_card::clock_short_press(void)
{
LOG(("Short press:%u\n" , m_clock_keys));
bool regen = false;
int tmp;
switch (m_clock_state) {
case CLOCK_OFF:
if (m_clock_keys == KEY_READ_MASK) {
m_clock_state = CLOCK_HHMM;
regen = true;
} else if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_HH;
regen = true;
}
break;
case CLOCK_SS:
if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_HH;
regen = true;
} else if (m_clock_keys == (KEY_CHG_MASK | KEY_READ_MASK)) {
tmp = get_clock_register(RTC_SECOND);
tmp++;
if (tmp >= 60) {
tmp = 0;
}
set_clock_register(RTC_SECOND , tmp);
log_current_time();
//m_clock_1s_div = 0;
regen = true;
}
break;
case CLOCK_HH:
if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_MIN;
regen = true;
} else if (m_clock_keys == (KEY_CHG_MASK | KEY_READ_MASK)) {
tmp = get_clock_register(RTC_HOUR);
tmp++;
if (tmp >= 24) {
tmp = 0;
}
set_clock_register(RTC_HOUR , tmp);
log_current_time();
regen = true;
}
break;
case CLOCK_MIN:
if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_MON;
regen = true;
} else if (m_clock_keys == (KEY_CHG_MASK | KEY_READ_MASK)) {
tmp = get_clock_register(RTC_MINUTE);
tmp++;
if (tmp >= 60) {
tmp = 0;
}
set_clock_register(RTC_MINUTE , tmp);
set_clock_register(RTC_SECOND , 0);
//m_clock_1s_div = 0;
log_current_time();
regen = true;
}
break;
case CLOCK_MON:
if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_DOM;
regen = true;
} else if (m_clock_keys == (KEY_CHG_MASK | KEY_READ_MASK)) {
tmp = get_clock_register(RTC_MONTH);
tmp++;
if (tmp >= 13) {
tmp = 1;
}
set_clock_register(RTC_MONTH , tmp);
log_current_time();
regen = true;
}
break;
case CLOCK_DOM:
if (m_clock_keys == KEY_SET_MASK) {
m_clock_state = CLOCK_OFF;
regen = true;
} else if (m_clock_keys == (KEY_CHG_MASK | KEY_READ_MASK)) {
tmp = get_clock_register(RTC_DAY);
tmp++;
if (tmp > gregorian_days_in_month(get_clock_register(RTC_MONTH) , 0)) {
tmp = 1;
}
set_clock_register(RTC_DAY , tmp);
log_current_time();
regen = true;
}
break;
default:
break;
}
if (regen) {
regen_clock_image();
}
}
void hp98035_io_card::regen_clock_image(void)
{
int tmp;
bool pm;
switch (m_clock_state) {
case CLOCK_OFF:
m_clock_digits[ 0 ] = SEVEN_SEG_OFF;
m_clock_digits[ 1 ] = SEVEN_SEG_OFF;
m_clock_digits[ 2 ] = SEVEN_SEG_OFF;
m_clock_segh = false;
break;
case CLOCK_HHMM:
tmp = get_clock_register(RTC_HOUR);
if (tmp == 0) {
tmp = 12;
} else if (tmp > 12) {
tmp -= 12;
}
set_lhs_digits(tmp);
set_rhs_digits(get_clock_register(RTC_MINUTE));
break;
case CLOCK_SS:
m_clock_segh = false;
m_clock_digits[ 2 ] = SEVEN_SEG_OFF;
set_rhs_digits(get_clock_register(RTC_SECOND));
break;
case CLOCK_HH:
tmp = get_clock_register(RTC_HOUR);
pm = tmp >= 12;
if (tmp == 0) {
tmp = 12;
} else if (tmp > 12) {
tmp -= 12;
}
set_lhs_digits(tmp);
m_clock_digits[ 1 ] = SEVEN_SEG_OFF;
m_clock_digits[ 0 ] = pm ? SEVEN_SEG_P : SEVEN_SEG_A;
break;
case CLOCK_MIN:
m_clock_segh = false;
m_clock_digits[ 2 ] = SEVEN_SEG_OFF;
set_rhs_digits(get_clock_register(RTC_MINUTE));
break;
case CLOCK_MON:
tmp = get_clock_register(RTC_MONTH);
set_lhs_digits(tmp);
m_clock_digits[ 0 ] = SEVEN_SEG_OFF;
m_clock_digits[ 1 ] = SEVEN_SEG_OFF;
break;
case CLOCK_DOM:
m_clock_segh = false;
m_clock_digits[ 2 ] = SEVEN_SEG_OFF;
set_rhs_digits(get_clock_register(RTC_DAY));
break;
default:
m_clock_state = CLOCK_OFF;
break;
}
LOG(("St=%d segh=%d %02x:%02x:%02x\n" , m_clock_state , m_clock_segh , m_clock_digits[ 2 ] ,
m_clock_digits[ 1 ] , m_clock_digits[ 0 ]));
}
