Previous

199869 Revisions

Next

r20952 Monday 11th February, 2013 at 19:43:00 UTC by Sandro Ronco
(MESS) Modernized PCF8593 RTC. (nw)

[src/mess/machine]

cybiko.c pcf8593.c pcf8593.h

trunk/src/mess/machine/pcf8593.c

r20951	r20952
6	6
7	7	*********************************************************************/
8	8
9		#include <time.h>
10	9	#include "pcf8593.h"
11	10
12	11
r20951	r20952
17	16	#define LOG_LEVEL  1
18	17	#define _logerror(level,x)  do { if (LOG_LEVEL > level) logerror x; } while (0)
19	18
20		#define RTC_MODE_NONE  0
21		#define RTC_MODE_SEND  1
22		#define RTC_MODE_RECV  2
23
24	19	// get/set date
25		#define RTC_GET_DATE_YEAR       ((rtc->data[5] >> 6) & 3)
26		#define RTC_SET_DATE_YEAR(x)    rtc->data[5] = (rtc->data[5] & 0x3F) | (((x) % 4) << 6)
27		#define RTC_GET_DATE_MONTH      bcd_to_dec( rtc->data[6])
28		#define RTC_SET_DATE_MONTH(x)   rtc->data[6] = dec_to_bcd( x)
29		#define RTC_GET_DATE_DAY        (bcd_to_dec( rtc->data[5] & 0x3F))
30		#define RTC_SET_DATE_DAY(x)     rtc->data[5] = (rtc->data[5] & 0xC0) | dec_to_bcd( x)
	20	#define RTC_GET_DATE_YEAR       ((m_data[5] >> 6) & 3)
	21	#define RTC_SET_DATE_YEAR(x)    m_data[5] = (m_data[5] & 0x3F) | (((x) % 4) << 6)
	22	#define RTC_GET_DATE_MONTH      bcd_to_integer( m_data[6])
	23	#define RTC_SET_DATE_MONTH(x)   m_data[6] = convert_to_bcd( x)
	24	#define RTC_GET_DATE_DAY        (bcd_to_integer( m_data[5] & 0x3F))
	25	#define RTC_SET_DATE_DAY(x)     m_data[5] = (m_data[5] & 0xC0) | convert_to_bcd( x)
31	26
32	27	// get/set time
33		#define RTC_GET_TIME_HOUR       bcd_to_dec( rtc->data[4])
34		#define RTC_SET_TIME_HOUR(x)    rtc->data[4] = dec_to_bcd( x)
35		#define RTC_GET_TIME_MINUTE     bcd_to_dec( rtc->data[3])
36		#define RTC_SET_TIME_MINUTE(x)  rtc->data[3] = dec_to_bcd( x)
37		#define RTC_GET_TIME_SECOND     bcd_to_dec( rtc->data[2])
38		#define RTC_SET_TIME_SECOND(x)  rtc->data[2] = dec_to_bcd( x)
	28	#define RTC_GET_TIME_HOUR       bcd_to_integer( m_data[4])
	29	#define RTC_SET_TIME_HOUR(x)    m_data[4] = convert_to_bcd( x)
	30	#define RTC_GET_TIME_MINUTE     bcd_to_integer( m_data[3])
	31	#define RTC_SET_TIME_MINUTE(x)  m_data[3] = convert_to_bcd( x)
	32	#define RTC_GET_TIME_SECOND     bcd_to_integer( m_data[2])
	33	#define RTC_SET_TIME_SECOND(x)  m_data[2] = convert_to_bcd( x)
39	34
40	35
41		/***************************************************************************
42		TYPE DEFINITIONS
43		***************************************************************************/
	36	//**************************************************************************
	37	//  GLOBAL VARIABLES
	38	//**************************************************************************
44	39
45		struct pcf8593_t
46		{
47		UINT8 data[16];
48		int pin_scl, pin_sda, inp;
49		int active;
50		int bits;
51		UINT8 data_recv_index, data_recv[50];
52		UINT8 mode, pos;
53		emu_timer *timer;
54		};
	40	const device_type PCF8593 = &device_creator<pcf8593_device>;
55	41
56	42
57		/***************************************************************************
58		PROTOTYPES
59		***************************************************************************/
	43	//-------------------------------------------------
	44	//  pcf8593_device - constructor
	45	//-------------------------------------------------
60	46
61		static void pcf8593_clear_buffer_rx(device_t *device);
62		static TIMER_CALLBACK( pcf8593_timer_callback );
	47	pcf8593_device::pcf8593_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	48	: device_t(mconfig, PCF8593, "PCF8593 RTC", tag, owner, clock),
	49	device_rtc_interface(mconfig, *this),
	50	device_nvram_interface(mconfig, *this)
	51	{
	52	}
63	53
64	54
65		/***************************************************************************
66		INLINE FUNCTIONS
67		***************************************************************************/
	55	//-------------------------------------------------
	56	//  device_start - device-specific startup
	57	//-------------------------------------------------
68	58
69		INLINE pcf8593_t *get_token(device_t *device)
	59	void pcf8593_device::device_start()
70	60	{
71		assert(device != NULL);
72		assert(device->type() == PCF8593);
73
74		return (pcf8593_t *) downcast<pcf8593_device *>(device)->token();
	61	_logerror( 0, ("pcf8593_init\n"));
	62	memset(m_register, 0, sizeof(m_register));
	63	m_timer = timer_alloc(TIMER_UPDATE_COUNTER);
	64	m_timer->adjust(attotime::from_seconds(1), 0, attotime::from_seconds(1));
75	65	}
76	66
	67	//-------------------------------------------------
	68	//  device_reset - device-specific reset
	69	//-------------------------------------------------
77	70
78		/***************************************************************************
79		IMPLEMENTATION
80		***************************************************************************/
	71	void pcf8593_device::device_reset()
	72	{
	73	_logerror( 0, ("pcf8593_reset\n"));
	74	m_pin_scl = 1;
	75	m_pin_sda = 1;
	76	m_active  = FALSE;
	77	m_inp     = 0;
	78	m_mode    = RTC_MODE_RECV;
	79	m_bits    = 0;
	80	m_pos     = 0;
	81	clear_buffer_rx();
	82	set_time(true, RTC_GET_DATE_YEAR, RTC_GET_DATE_MONTH, RTC_GET_DATE_DAY, 0, RTC_GET_TIME_HOUR, RTC_GET_TIME_MINUTE, RTC_GET_TIME_SECOND);
	83	}
81	84
82		/*-------------------------------------------------
83		DEVICE_START( pcf8593 )
84		-------------------------------------------------*/
85	85
86		static DEVICE_START( pcf8593 )
	86	//-------------------------------------------------
	87	//  device_timer - handler timer events
	88	//-------------------------------------------------
	89
	90	void pcf8593_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
87	91	{
88		pcf8593_t *rtc = get_token(device);
	92	switch(id)
	93	{
	94	case TIMER_UPDATE_COUNTER:
	95	_logerror( 2, ("pcf8593_timer_callback (%d)\n", param));
	96	// check if counting is enabled
	97	if (!(m_data[0] & 0x80))
	98	advance_seconds();
	99	break;
	100	}
	101	}
89	102
90		_logerror( 0, ("pcf8593_init\n"));
91		memset( rtc, 0, sizeof(*rtc));
92		rtc->timer = device->machine().scheduler().timer_alloc(FUNC(pcf8593_timer_callback), (void *) device);
93		rtc->timer->adjust(attotime::from_seconds(1), 0, attotime::from_seconds(1));
	103
	104	//-------------------------------------------------
	105	//  rtc_clock_updated -
	106	//-------------------------------------------------
	107
	108	void pcf8593_device::rtc_clock_updated(int year, int month, int day, int day_of_week, int hour, int minute, int second)
	109	{
	110	RTC_SET_TIME_SECOND(second);
	111	RTC_SET_TIME_MINUTE(minute);
	112	RTC_SET_TIME_HOUR(hour);
	113	RTC_SET_DATE_DAY(day);
	114	RTC_SET_DATE_MONTH(month);
	115	RTC_SET_DATE_YEAR(year);
94	116	}
95	117
96	118
	119	//-------------------------------------------------
	120	//  nvram_default - called to initialize NVRAM to
	121	//  its default state
	122	//-------------------------------------------------
97	123
98		/*-------------------------------------------------
99		DEVICE_RESET( pcf8593 )
100		-------------------------------------------------*/
	124	void pcf8593_device::nvram_default()
	125	{
	126	memset(m_data, 0, sizeof(m_data));
	127	}
101	128
102		static DEVICE_RESET( pcf8593 )
	129	//-------------------------------------------------
	130	//  nvram_read - called to read NVRAM from the
	131	//  .nv file
	132	//-------------------------------------------------
	133
	134	void pcf8593_device::nvram_read(emu_file &file)
103	135	{
104		pcf8593_t *rtc = get_token(device);
	136	file.read(m_data, sizeof(m_data));
	137	}
105	138
106		_logerror( 0, ("pcf8593_reset\n"));
107		rtc->pin_scl = 1;
108		rtc->pin_sda = 1;
109		rtc->active  = FALSE;
110		rtc->inp     = 0;
111		rtc->mode    = RTC_MODE_RECV;
112		rtc->bits    = 0;
113		pcf8593_clear_buffer_rx(device);
114		rtc->pos     = 0;
	139
	140	//-------------------------------------------------
	141	//  nvram_write - called to write NVRAM to the
	142	//  .nv file
	143	//-------------------------------------------------
	144
	145	void pcf8593_device::nvram_write(emu_file &file)
	146	{
	147	file.write(m_data, sizeof(m_data));
115	148	}
116	149
117	150
r20951	r20952
120	153	pcf8593_pin_scl
121	154	-------------------------------------------------*/
122	155
123		void pcf8593_pin_scl(device_t *device, int data)
	156	WRITE_LINE_MEMBER(pcf8593_device::scl_w)
124	157	{
125		pcf8593_t *rtc = get_token(device);
126
127	158	// send bit
128		if ((rtc->active) && (!rtc->pin_scl) && (data))
	159	if ((m_active) && (!m_pin_scl) && (state))
129	160	{
130		switch (rtc->mode)
	161	switch (m_mode)
131	162	{
132	163	// HOST -> RTC
133	164	case RTC_MODE_RECV :
134	165	{
135	166	// get bit
136		if (rtc->pin_sda) rtc->data_recv[rtc->data_recv_index] = rtc->data_recv[rtc->data_recv_index] | (0x80 >> rtc->bits);
137		rtc->bits++;
	167	if (m_pin_sda) m_data_recv[m_data_recv_index] = m_data_recv[m_data_recv_index] | (0x80 >> m_bits);
	168	m_bits++;
138	169	// bit 9 = end
139		if (rtc->bits > 8)
	170	if (m_bits > 8)
140	171	{
141		_logerror( 2, ("pcf8593_write_byte(%02X)\n", rtc->data_recv[rtc->data_recv_index]));
	172	_logerror( 2, ("pcf8593_write_byte(%02X)\n", m_data_recv[m_data_recv_index]));
142	173	// enter receive mode when 1st byte = 0xA3
143		if ((rtc->data_recv[0] == 0xA3) && (rtc->data_recv_index == 0))
	174	if ((m_data_recv[0] == 0xA3) && (m_data_recv_index == 0))
144	175	{
145		rtc->mode = RTC_MODE_SEND;
	176	m_mode = RTC_MODE_SEND;
146	177	}
147	178	// A2 + xx = "read from pos xx" command
148		if ((rtc->data_recv[0] == 0xA2) && (rtc->data_recv_index == 1))
	179	if ((m_data_recv[0] == 0xA2) && (m_data_recv_index == 1))
149	180	{
150		rtc->pos = rtc->data_recv[1];
	181	m_pos = m_data_recv[1];
151	182	}
152	183	// A2 + xx + .. = write byte
153		if ((rtc->data_recv[0] == 0xA2) && (rtc->data_recv_index >= 2))
	184	if ((m_data_recv[0] == 0xA2) && (m_data_recv_index >= 2))
154	185	{
155	186	UINT8 rtc_pos, rtc_val;
156		rtc_pos = rtc->data_recv[1] + (rtc->data_recv_index - 2);
157		rtc_val = rtc->data_recv[rtc->data_recv_index];
	187	rtc_pos = m_data_recv[1] + (m_data_recv_index - 2);
	188	rtc_val = m_data_recv[m_data_recv_index];
158	189	//if (rtc_pos == 0) rtc_val = rtc_val & 3; // what is this doing here?
159		rtc->data[rtc_pos] = rtc_val;
	190	m_data[rtc_pos] = rtc_val;
	191	set_time(false, RTC_GET_DATE_YEAR, RTC_GET_DATE_MONTH, RTC_GET_DATE_DAY, 0, RTC_GET_TIME_HOUR, RTC_GET_TIME_MINUTE, RTC_GET_TIME_SECOND);
160	192	}
161	193	// next byte
162		rtc->bits = 0;
163		rtc->data_recv_index++;
	194	m_bits = 0;
	195	m_data_recv_index++;
164	196	}
165	197	}
166	198	break;
r20951	r20952
168	200	case RTC_MODE_SEND :
169	201	{
170	202	// set bit
171		rtc->inp = (rtc->data[rtc->pos] >> (7 - rtc->bits)) & 1;
172		rtc->bits++;
	203	m_inp = (m_data[m_pos] >> (7 - m_bits)) & 1;
	204	m_bits++;
173	205	// bit 9 = end
174		if (rtc->bits > 8)
	206	if (m_bits > 8)
175	207	{
176		_logerror( 2, ("pcf8593_read_byte(%02X)\n", rtc->data[rtc->pos]));
	208	_logerror( 2, ("pcf8593_read_byte(%02X)\n", m_data[m_pos]));
177	209	// end ?
178		if (rtc->pin_sda)
	210	if (m_pin_sda)
179	211	{
180	212	_logerror( 2, ("pcf8593 end\n"));
181		rtc->mode = RTC_MODE_RECV;
182		pcf8593_clear_buffer_rx(device);
	213	m_mode = RTC_MODE_RECV;
	214	clear_buffer_rx();
183	215	}
184	216	// next byte
185		rtc->bits = 0;
186		rtc->pos++;
	217	m_bits = 0;
	218	m_pos++;
187	219	}
188	220	}
189	221	break;
190	222	}
191	223	}
192	224	// save scl
193		rtc->pin_scl = data;
	225	m_pin_scl = state;
194	226	}
195	227
196	228
r20951	r20952
199	231	pcf8593_pin_sda_w
200	232	-------------------------------------------------*/
201	233
202		void pcf8593_pin_sda_w(device_t *device, int data)
	234	WRITE_LINE_MEMBER(pcf8593_device::sda_w)
203	235	{
204		pcf8593_t *rtc = get_token(device);
205
206	236	// clock is high
207		if (rtc->pin_scl)
	237	if (m_pin_scl)
208	238	{
209	239	// log init I2C
210		if (data) _logerror( 1, ("pcf8593 init i2c\n"));
	240	if (state) _logerror( 1, ("pcf8593 init i2c\n"));
211	241	// start condition (high to low when clock is high)
212		if ((!data) && (rtc->pin_sda))
	242	if ((!state) && (m_pin_sda))
213	243	{
214	244	_logerror( 1, ("pcf8593 start condition\n"));
215		rtc->active          = TRUE;
216		rtc->bits            = 0;
217		rtc->data_recv_index = 0;
218		pcf8593_clear_buffer_rx(device);
219		//rtc->pos = 0;
	245	m_active          = TRUE;
	246	m_bits            = 0;
	247	m_data_recv_index = 0;
	248	clear_buffer_rx();
	249	//m_pos = 0;
220	250	}
221	251	// stop condition (low to high when clock is high)
222		if ((data) && (!rtc->pin_sda))
	252	if ((state) && (!m_pin_sda))
223	253	{
224	254	_logerror( 1, ("pcf8593 stop condition\n"));
225		rtc->active = FALSE;
	255	m_active = FALSE;
226	256	}
227	257	}
228	258	// save sda
229		rtc->pin_sda = data;
	259	m_pin_sda = state;
230	260	}
231	261
232	262
r20951	r20952
235	265	pcf8593_pin_sda_r
236	266	-------------------------------------------------*/
237	267
238		int pcf8593_pin_sda_r(device_t *device)
	268	READ_LINE_MEMBER(pcf8593_device::sda_r)
239	269	{
240		pcf8593_t *rtc = get_token(device);
241		return rtc->inp;
	270	return m_inp;
242	271	}
243	272
244	273
r20951	r20952
247	276	pcf8593_clear_buffer_rx
248	277	-------------------------------------------------*/
249	278
250		void pcf8593_clear_buffer_rx(device_t *device)
	279	void pcf8593_device::clear_buffer_rx()
251	280	{
252		pcf8593_t *rtc = get_token(device);
253		memset( &rtc->data_recv[0], 0, sizeof( rtc->data_recv));
254		rtc->data_recv_index = 0;
	281	memset(&m_data_recv[0], 0, sizeof( m_data_recv));
	282	m_data_recv_index = 0;
255	283	}
256
257
258
259		/*-------------------------------------------------
260		dec_to_bcd
261		-------------------------------------------------*/
262
263		static UINT8 dec_to_bcd( UINT8 data)
264		{
265		return ((data / 10) << 4) | ((data % 10) << 0);
266		}
267
268
269
270		/*-------------------------------------------------
271		bcd_to_dec
272		-------------------------------------------------*/
273
274		static UINT8 bcd_to_dec( UINT8 data)
275		{
276		if ((data & 0x0F) >= 0x0A) data = data - 0x0A + 0x10;
277		if ((data & 0xF0) >= 0xA0) data = data - 0xA0;
278		return (data & 0x0F) + (((data & 0xF0) >> 4) * 10);
279		}
280
281
282
283		/*-------------------------------------------------
284		bcd_to_dec
285		-------------------------------------------------*/
286
287		static void pcf8593_set_time(device_t *device, int hour, int minute, int second)
288		{
289		pcf8593_t *rtc = get_token(device);
290		RTC_SET_TIME_HOUR( hour);
291		RTC_SET_TIME_MINUTE( minute);
292		RTC_SET_TIME_SECOND( second);
293		rtc->data[1] = 0; // hundreds of a seconds
294		}
295
296
297
298		/*-------------------------------------------------
299		pcf8593_set_date
300		-------------------------------------------------*/
301
302		static void pcf8593_set_date(device_t *device, int year, int month, int day)
303		{
304		pcf8593_t *rtc = get_token(device);
305		RTC_SET_DATE_YEAR( year);
306		RTC_SET_DATE_MONTH( month);
307		RTC_SET_DATE_DAY( day);
308		}
309
310
311
312		/*-------------------------------------------------
313		get_days_in_month
314		-------------------------------------------------*/
315
316		static int get_days_in_month( int year, int month)
317		{
318		static const int table[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
319		if ((month == 2) && ((year & 0x03) == 0)) return 29;
320		return table[month-1];
321		}
322
323
324
325		/*-------------------------------------------------
326		TIMER_CALLBACK( pcf8593_timer_callback )
327		-------------------------------------------------*/
328
329		static TIMER_CALLBACK( pcf8593_timer_callback )
330		{
331		device_t *device = (device_t *) ptr;
332		pcf8593_t *rtc = get_token(device);
333		int value;
334
335		_logerror( 2, ("pcf8593_timer_callback (%d)\n", param));
336		// check if counting is enabled
337		if (rtc->data[0] & 0x80) return;
338		// increment second
339		value = RTC_GET_TIME_SECOND;
340		if (value < 59)
341		{
342		RTC_SET_TIME_SECOND( value + 1);
343		}
344		else
345		{
346		RTC_SET_TIME_SECOND( 0);
347		// increment minute
348		value = RTC_GET_TIME_MINUTE;
349		if (value < 59)
350		{
351		RTC_SET_TIME_MINUTE( value + 1);
352		}
353		else
354		{
355		RTC_SET_TIME_MINUTE( 0);
356		// increment hour
357		value = RTC_GET_TIME_HOUR;
358		if (value < 23)
359		{
360		RTC_SET_TIME_HOUR( value + 1);
361		}
362		else
363		{
364		RTC_SET_TIME_HOUR( 0);
365		// increment day
366		value = RTC_GET_DATE_DAY;
367		if (value < get_days_in_month( RTC_GET_DATE_YEAR, RTC_GET_DATE_MONTH))
368		{
369		RTC_SET_DATE_DAY( value + 1);
370		}
371		else
372		{
373		RTC_SET_DATE_DAY( 1);
374		// increase month
375		value = RTC_GET_DATE_MONTH;
376		if (value < 12)
377		{
378		RTC_SET_DATE_MONTH( value + 1);
379		}
380		else
381		{
382		RTC_SET_DATE_MONTH( 1);
383		// increase year
384		RTC_SET_DATE_YEAR( RTC_GET_DATE_YEAR + 1);
385		}
386		}
387		}
388		}
389		}
390		}
391
392
393
394		/*-------------------------------------------------
395		pcf8593_load
396		-------------------------------------------------*/
397
398		void pcf8593_load(device_t *device, emu_file *file)
399		{
400		pcf8593_t *rtc = get_token(device);
401		system_time systime;
402
403		_logerror( 0, ("pcf8593_load (%p)\n", file));
404		file->read(rtc->data, sizeof(rtc->data));
405		device->machine().current_datetime(systime);
406		pcf8593_set_date(device, systime.local_time.year, systime.local_time.month + 1, systime.local_time.mday);
407		pcf8593_set_time(device, systime.local_time.hour, systime.local_time.minute, systime.local_time.second);
408		}
409
410
411
412		/*-------------------------------------------------
413		pcf8593_save
414		-------------------------------------------------*/
415
416		void pcf8593_save(device_t *device, emu_file *file)
417		{
418		pcf8593_t *rtc = get_token(device);
419
420		_logerror( 0, ("pcf8593_save (%p)\n", file));
421		file->write(rtc->data, sizeof(rtc->data));
422		}
423
424		#ifdef UNUSED_FUNCTION
425		NVRAM_HANDLER( pcf8593 )
426		{
427		_logerror( 0, ("nvram_handler_pcf8593 (%p/%d)\n", file, read_or_write));
428		if (read_or_write)
429		{
430		pcf8593_save( file);
431		}
432		else
433		{
434		if (file)
435		{
436		pcf8593_load( file);
437		}
438		else
439		{
440		memset( rtc->data, 0, rtc->size);
441		}
442		}
443		}
444		#endif
445
446
447		const device_type PCF8593 = &device_creator<pcf8593_device>;
448
449		pcf8593_device::pcf8593_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
450		: device_t(mconfig, PCF8593, "PCF8593 RTC", tag, owner, clock)
451		{
452		m_token = global_alloc_clear(pcf8593_t);
453		}
454
455		//-------------------------------------------------
456		//  device_config_complete - perform any
457		//  operations now that the configuration is
458		//  complete
459		//-------------------------------------------------
460
461		void pcf8593_device::device_config_complete()
462		{
463		}
464
465		//-------------------------------------------------
466		//  device_start - device-specific startup
467		//-------------------------------------------------
468
469		void pcf8593_device::device_start()
470		{
471		DEVICE_START_NAME( pcf8593 )(this);
472		}
473
474		//-------------------------------------------------
475		//  device_reset - device-specific reset
476		//-------------------------------------------------
477
478		void pcf8593_device::device_reset()
479		{
480		DEVICE_RESET_NAME( pcf8593 )(this);
481		}

trunk/src/mess/machine/pcf8593.h

r20951	r20952
12	12	#include "emu.h"
13	13
14	14
15		/***************************************************************************
16		MACROS
17		***************************************************************************/
	15	//**************************************************************************
	16	//  INTERFACE CONFIGURATION MACROS
	17	//**************************************************************************
18	18
19		class pcf8593_device : public device_t
	19	#define MCFG_PCF8593_ADD(_tag) \
	20	MCFG_DEVICE_ADD(_tag, PCF8593, 0)
	21
	22	#define MCFG_PCF8593_REMOVE(_tag) \
	23	MCFG_DEVICE_REMOVE(_tag)
	24
	25
	26	// ======================> pcf8593_device
	27
	28	class pcf8593_device :  public device_t,
	29	public device_rtc_interface,
	30	public device_nvram_interface
20	31	{
21	32	public:
22	33	pcf8593_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
23		~pcf8593_device() { global_free(m_token); }
24	34
25		// access to legacy token
26		void *token() const { assert(m_token != NULL); return m_token; }
	35	DECLARE_WRITE_LINE_MEMBER(scl_w);
	36	DECLARE_WRITE_LINE_MEMBER(sda_w);
	37	DECLARE_READ_LINE_MEMBER(sda_r);
	38
27	39	protected:
28	40	// device-level overrides
29		virtual void device_config_complete();
30	41	virtual void device_start();
31	42	virtual void device_reset();
32		private:
33		// internal state
34		void *m_token;
35		};
	43	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
36	44
37		extern const device_type PCF8593;
	45	// device_rtc_interface overrides
	46	virtual bool rtc_feature_y2k() { return true; }
	47	virtual void rtc_clock_updated(int year, int month, int day, int day_of_week, int hour, int minute, int second);
38	48
	49	// device_nvram_interface overrides
	50	virtual void nvram_default();
	51	virtual void nvram_read(emu_file &file);
	52	virtual void nvram_write(emu_file &file);
39	53
40		#define MCFG_PCF8593_ADD(_tag) \
41		MCFG_DEVICE_ADD(_tag, PCF8593, 0)
42		#define MCFG_PCF8593_REMOVE(_tag) \
43		MCFG_DEVICE_REMOVE(_tag)
	54	private:
	55	void clear_buffer_rx();
44	56
	57	static const device_timer_id TIMER_UPDATE_COUNTER = 0;
45	58
	59	// internal state
	60	UINT8       m_data[16];
	61	int         m_pin_scl;
	62	int         m_pin_sda;
	63	int         m_inp;
	64	int         m_active;
	65	int         m_bits;
	66	UINT8       m_data_recv_index;
	67	UINT8       m_data_recv[50];
	68	UINT8       m_mode;
	69	UINT8       m_pos;
	70	emu_timer * m_timer;
	71	enum        { RTC_MODE_NONE, RTC_MODE_SEND, RTC_MODE_RECV };
	72	};
46	73
47		/***************************************************************************
48		FUNCTION PROTOTYPES
49		***************************************************************************/
50		/* pins */
51		void pcf8593_pin_scl(device_t *device, int data);
52		void pcf8593_pin_sda_w(device_t *device, int data);
53		int  pcf8593_pin_sda_r(device_t *device);
	74	// device type definition
	75	extern const device_type PCF8593;
54	76
55		/* load/save */
56		void pcf8593_load(device_t *device, emu_file *file);
57		void pcf8593_save(device_t *device, emu_file *file);
58
59	77	#endif /* __PCF8593_H__ */

trunk/src/mess/machine/cybiko.c

r20951	r20952
104	104	return TRUE;
105	105	}
106	106
107		static void cybiko_pcf8593_load(running_machine &machine, emu_file *file)
108		{
109		device_t *device = machine.device("rtc");
110		pcf8593_load(device, file);
111		}
112
113		static void cybiko_pcf8593_save(running_machine &machine, emu_file *file)
114		{
115		device_t *device = machine.device("rtc");
116		pcf8593_save(device, file);
117		}
118
119	107	static void cybiko_at45dbxx_load(running_machine &machine, emu_file *file)
120	108	{
121	109	device_t *device = machine.device("flash1");
r20951	r20952
177	165	void cybiko_state::machine_start()
178	166	{
179	167	_logerror( 0, ("machine_start_cybikov1\n"));
180		// real-time clock
181		nvram_system_load( machine(), "rtc", cybiko_pcf8593_load, 0);
182	168	// serial dataflash
183	169	nvram_system_load( machine(), "flash1", cybiko_at45dbxx_load, 1);
184	170	// serial port
r20951	r20952
192	178	device_t *flash2 = machine().device("flash2");
193	179
194	180	_logerror( 0, ("machine_start_cybikov2\n"));
195		// real-time clock
196		nvram_system_load( machine(), "rtc", cybiko_pcf8593_load, 0);
197	181	// serial dataflash
198	182	nvram_system_load( machine(), "flash1", cybiko_at45dbxx_load, 1);
199	183	// multi-purpose flash
r20951	r20952
209	193	{
210	194	device_t *flash2 = machine().device("flash2");
211	195	_logerror( 0, ("machine_start_cybikoxt\n"));
212		// real-time clock
213		nvram_system_load( machine(), "rtc", cybiko_pcf8593_load, 0);
214	196	// multi-purpose flash
215	197	nvram_system_load( machine(), "flash2", cybiko_sst39vfx_load, 1);
216	198	machine().root_device().membank( "bank2" )->set_base( sst39vfx_get_base(flash2));
r20951	r20952
251	233	void cybiko_state::machine_stop_cybikov1()
252	234	{
253	235	_logerror( 0, ("machine_stop_cybikov1\n"));
254		// real-time clock
255		nvram_system_save( machine(), "rtc", cybiko_pcf8593_save);
256	236	// serial dataflash
257	237	nvram_system_save( machine(), "flash1", cybiko_at45dbxx_save);
258	238	// serial port
r20951	r20952
262	242	void cybiko_state::machine_stop_cybikov2()
263	243	{
264	244	_logerror( 0, ("machine_stop_cybikov2\n"));
265		// real-time clock
266		nvram_system_save( machine(), "rtc", cybiko_pcf8593_save);
267	245	// serial dataflash
268	246	nvram_system_save( machine(), "flash1", cybiko_at45dbxx_save);
269	247	// multi-purpose flash
r20951	r20952
275	253	void cybiko_state::machine_stop_cybikoxt()
276	254	{
277	255	_logerror( 0, ("machine_stop_cybikoxt\n"));
278		// real-time clock
279		nvram_system_save( machine(), "rtc", cybiko_pcf8593_save);
280	256	// multi-purpose flash
281	257	nvram_system_save( machine(), "flash2", cybiko_sst39vfx_save);
282	258	// ramdisk
r20951	r20952
441	417	case H8S_IO_PORTF :
442	418	{
443	419	data = H8S_PF_PF2;
444		if (pcf8593_pin_sda_r(m_rtc))
	420	if (m_rtc->sda_r())
445	421	data |= H8S_PF_PF0;
446	422	}
447	423	break;
r20951	r20952
487	463	case H8S_IO_PORTF :
488	464	{
489	465	data = H8S_PF_PF2;
490		if (pcf8593_pin_sda_r(m_rtc))
	466	if (m_rtc->sda_r())
491	467	data |= H8S_PF_PF0;
492	468	}
493	469	break;
r20951	r20952
525	501	// real-time clock
526	502	case H8S_IO_PORTF :
527	503	{
528		if (pcf8593_pin_sda_r(m_rtc))
	504	if (m_rtc->sda_r())
529	505	data |= H8S_PF_PF6;
530	506	}
531	507	break;
r20951	r20952
569	545	// real-time clock
570	546	case H8S_IO_PFDR :
571	547	{
572		pcf8593_pin_scl(m_rtc, (data & H8S_PF_PF1) ? 1 : 0);
	548	m_rtc->scl_w((data & H8S_PF_PF1) ? 1 : 0);
573	549	}
574	550	break;
575	551	// real-time clock
576	552	case H8S_IO_PFDDR :
577	553	{
578		pcf8593_pin_sda_w(m_rtc, (data & H8S_PF_PF0) ? 0 : 1);
	554	m_rtc->sda_w((data & H8S_PF_PF0) ? 0 : 1);
579	555	}
580	556	break;
581	557	}
r20951	r20952
610	586	// real-time clock
611	587	case H8S_IO_PFDR :
612	588	{
613		pcf8593_pin_scl(m_rtc, (data & H8S_PF_PF1) ? 1 : 0);
	589	m_rtc->scl_w((data & H8S_PF_PF1) ? 1 : 0);
614	590	}
615	591	break;
616	592	// real-time clock
617	593	case H8S_IO_PFDDR :
618	594	{
619		pcf8593_pin_sda_w(m_rtc, (data & H8S_PF_PF0) ? 0 : 1);
	595	m_rtc->sda_w((data & H8S_PF_PF0) ? 0 : 1);
620	596	}
621	597	break;
622	598	}
r20951	r20952
643	619	// real-time clock
644	620	case H8S_IO_PFDR :
645	621	{
646		pcf8593_pin_scl(m_rtc, (data & H8S_PF_PF1) ? 1 : 0);
	622	m_rtc->scl_w((data & H8S_PF_PF1) ? 1 : 0);
647	623	}
648	624	break;
649	625	// real-time clock
650	626	case H8S_IO_PFDDR :
651	627	{
652		pcf8593_pin_sda_w(m_rtc, (data & H8S_PF_PF6) ? 0 : 1);
	628	m_rtc->sda_w((data & H8S_PF_PF6) ? 0 : 1);
653	629	}
654	630	break;
655	631	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team