Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-07 17:27:06 +03:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/mamedev/mame

Browse Source
This commit is contained in:
David Haywood 2016-03-30 00:17:16 +01:00
commit 7ac5dcae54
5 changed files with 64 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/devices/cpu/sm510/sm510.cpp
View File

@ -22,7 +22,7 @@
- SM511 undocumented/guessed opcodes:
* $01 is guessed as DIV to ACC transfer, unknown which bits
* $5d is certainly CEND
* $65 is certainly IDIV, but not sure if it behaves same as on SM510
* $65 is certainly divider reset, but not sure if it behaves same as on SM510
*/
@ -144,6 +144,7 @@ void sm510_base_device::device_start()
void sm510_base_device::device_reset()
{
// ACL
m_skip = false;
m_halt = false;
m_op = m_prev_op = 0;
@ -317,7 +318,7 @@ TIMER_CALLBACK_MEMBER(sm510_base_device::div_timer_cb)
{
m_div = (m_div + 1) & 0x7fff;
// 1S signal on overflow(falling edge of f1)
// 1S signal on overflow(falling edge of F1)
if (m_div == 0)
m_1s = true;

1
src/devices/cpu/sm510/sm510.h
View File

@ -284,6 +284,7 @@ protected:
void op_skip();
void op_cend();
void op_idiv();
void op_dr();
void op_dta();
void op_illegal();

10
src/devices/cpu/sm510/sm510op.cpp
View File

@ -450,10 +450,16 @@ void sm510_base_device::op_idiv()
m_div = 0;
}
void sm510_base_device::op_dr()
{
// DR: reset divider low 8 bits
m_div &= 0x7f;
}
void sm510_base_device::op_dta()
{
// DTA: transfer divider low bits to ACC
m_acc = BITSWAP16(m_div,0,0,0,0, 0,0,0,0, 0,0,0,0, 7,8,9,10) & 0xf;
// DTA: transfer divider low 4 bits to ACC
m_acc = BITSWAP16(m_div,0,0,0,0, 0,0,0,0, 0,0,0,0, 14,13,12,11) & 0xf;
}
void sm510_base_device::op_illegal()

2
src/devices/cpu/sm510/sm511core.cpp
View File

@ -127,7 +127,7 @@ void sm511_device::execute_one()
case 0x62: op_wr(); break;
case 0x63: op_ws(); break;
case 0x64: op_incb(); break;
case 0x65: op_idiv(); break;
case 0x65: op_dr(); break; // guessed
case 0x66: op_rc(); break;
case 0x67: op_sc(); break;
case 0x6c: op_decb(); break;

124
src/emu/attotime.h
View File

@ -1,34 +1,35 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************
attotime.h
Support functions for working with attotime data.
****************************************************************************
Attotime is an attosecond-accurate timing system implemented as
96-bit integers.
1 second = 1e0 seconds
1 millisecond = 1e-3 seconds
1 microsecond = 1e-6 seconds
1 nanosecond = 1e-9 seconds
1 picosecond = 1e-12 seconds
1 femtosecond = 1e-15 seconds
1 attosecond = 1e-18 seconds
This may seem insanely accurate, but it has its uses when multiple
clocks in the system are run by independent crystals. It is also
useful to compute the attotime for something small, say 1 clock tick,
and still have it be accurate and useful for scaling.
Attotime consists of a 32-bit seconds count and a 64-bit attoseconds
count. Because the lower bits are kept as attoseconds and not as a
full 64-bit value, there is headroom to make some operations simpler.
***************************************************************************/
/**************************************************************************/
/**
* @file attotime.h
* Support functions for working with attotime data.
* @defgroup ATTOTIME
* @{
* Support functions for working with attotime data.
*
* @class attotime
* Attotime is an attosecond-accurate timing system implemented as
* 96-bit integers.
*
* 1 second = 1e0 seconds
* 1 millisecond = 1e-3 seconds
* 1 microsecond = 1e-6 seconds
* 1 nanosecond = 1e-9 seconds
* 1 picosecond = 1e-12 seconds
* 1 femtosecond = 1e-15 seconds
* 1 attosecond = 1e-18 seconds
*
* This may seem insanely accurate, but it has its uses when multiple
* clocks in the system are run by independent crystals. It is also
* useful to compute the attotime for something small, say 1 clock tick,
* and still have it be accurate and useful for scaling.
*
* Attotime consists of a 32-bit seconds count and a 64-bit attoseconds
* count. Because the lower bits are kept as attoseconds and not as a
* full 64-bit value, there is headroom to make some operations simpler.
*/
/**************************************************************************/
#pragma once
@ -91,6 +92,7 @@ public:
: m_seconds(0),
m_attoseconds(0) { }
/** Constructs with @p secs seconds and @p attos attoseconds. */
attotime(seconds_t secs, attoseconds_t attos)
: m_seconds(secs),
m_attoseconds(attos) { }
@ -109,24 +111,32 @@ public:
// queries
bool is_zero() const { return (m_seconds == 0 && m_attoseconds == 0); }
/** Test if value is above @ref ATTOTIME_MAX_SECONDS (considered an overflow) */
bool is_never() const { return (m_seconds >= ATTOTIME_MAX_SECONDS); }
// conversion to other forms
double as_double() const { return double(m_seconds) + ATTOSECONDS_TO_DOUBLE(m_attoseconds); }
attoseconds_t as_attoseconds() const;
UINT64 as_ticks(UINT32 frequency) const;
/** Convert to string using at @p precision */
const char *as_string(int precision = 9) const;
/** @return the attoseconds portion. */
attoseconds_t attoseconds() const { return m_attoseconds; }
/** @return the seconds portion. */
seconds_t seconds() const { return m_seconds; }
// conversion from other forms
static attotime from_double(double _time);
static attotime from_ticks(UINT64 ticks, UINT32 frequency);
/** Create an attotime from a integer count of seconds @seconds */
static attotime from_seconds(INT32 seconds) { return attotime(seconds, 0); }
/** Create an attotime from a integer count of milliseconds @msec */
static attotime from_msec(INT64 msec) { return attotime(msec / 1000, (msec % 1000) * (ATTOSECONDS_PER_SECOND / 1000)); }
/** Create an attotime from a integer count of microseconds @usec */
static attotime from_usec(INT64 usec) { return attotime(usec / 1000000, (usec % 1000000) * (ATTOSECONDS_PER_SECOND / 1000000)); }
/** Create an attotime from a integer count of nanoseconds @nsec */
static attotime from_nsec(INT64 nsec) { return attotime(nsec / 1000000000, (nsec % 1000000000) * (ATTOSECONDS_PER_SECOND / 1000000000)); }
/** Create an attotime from at the given frequency @frequency */
static attotime from_hz(double frequency) { assert(frequency > 0); double d = 1 / frequency; return attotime(floor(d), modf(d, &d) * ATTOSECONDS_PER_SECOND); }
// math
@ -143,18 +153,14 @@ public:
static const attotime never;
static const attotime zero;
};
/** @} */
//**************************************************************************
// INLINE FUNCTIONS
//**************************************************************************
//-------------------------------------------------
// operator+ - handle addition between two
// attotimes
//-------------------------------------------------
/** handle addition between two attotimes */
inline attotime operator+(const attotime &left, const attotime &right)
{
attotime result;
@ -204,11 +210,7 @@ inline attotime &attotime::operator+=(const attotime &right)
}
//-------------------------------------------------
// operator- - handle subtraction between two
// attotimes
//-------------------------------------------------
/** handle subtraction between two attotimes */
inline attotime operator-(const attotime &left, const attotime &right)
{
attotime result;
@ -250,12 +252,7 @@ inline attotime &attotime::operator-=(const attotime &right)
}
//-------------------------------------------------
// operator* - handle multiplication/division by
// an integral factor; defined in terms of the
// assignment operators
//-------------------------------------------------
/** handle multiplication by an integral factor; defined in terms of the assignment operators */
inline attotime operator*(const attotime &left, UINT32 factor)
{
attotime result = left;
@ -270,6 +267,7 @@ inline attotime operator*(UINT32 factor, const attotime &right)
return result;
}
/** handle division by an integral factor; defined in terms of the assignment operators */
inline attotime operator/(const attotime &left, UINT32 factor)
{
attotime result = left;
@ -278,11 +276,7 @@ inline attotime operator/(const attotime &left, UINT32 factor)
}
//-------------------------------------------------
// operator== - handle comparisons between
// attotimes
//-------------------------------------------------
/** handle comparisons between attotimes */
inline bool operator==(const attotime &left, const attotime &right)
{
return (left.m_seconds == right.m_seconds && left.m_attoseconds == right.m_attoseconds);
@ -345,12 +339,7 @@ inline attotime max(const attotime &left, const attotime &right)
return right;
}
//-------------------------------------------------
// as_attoseconds - convert to an attoseconds
// value, clamping to +/- 1 second
//-------------------------------------------------
/** Convert to an attoseconds value, clamping to +/- 1 second */
inline attoseconds_t attotime::as_attoseconds() const
{
// positive values between 0 and 1 second
@ -371,11 +360,7 @@ inline attoseconds_t attotime::as_attoseconds() const
}
//-------------------------------------------------
// as_ticks - convert to ticks at the given
// frequency
//-------------------------------------------------
/** as_ticks - convert to ticks at @p frequency */
inline UINT64 attotime::as_ticks(UINT32 frequency) const
{
UINT32 fracticks = (attotime(0, m_attoseconds) * frequency).m_seconds;
@ -383,11 +368,7 @@ inline UINT64 attotime::as_ticks(UINT32 frequency) const
}
//-------------------------------------------------
// from_ticks - create an attotime from a tick
// count at the given frequency
//-------------------------------------------------
/** Create an attotime from a tick count @ticks at the given frequency @frequency */
inline attotime attotime::from_ticks(UINT64 ticks, UINT32 frequency)
{
attoseconds_t attos_per_tick = HZ_TO_ATTOSECONDS(frequency);
@ -400,12 +381,7 @@ inline attotime attotime::from_ticks(UINT64 ticks, UINT32 frequency)
return attotime(secs, (UINT64)remainder * attos_per_tick);
}
//-------------------------------------------------
// from_double - create an attotime from floating
// point count of seconds
//-------------------------------------------------
/** Create an attotime from floating point count of seconds @p _time */
inline attotime attotime::from_double(double _time)
{
seconds_t secs = floor(_time);