Previous

199869 Revisions

Next

r22776 Sunday 12th May, 2013 at 00:12:47 UTC by smf
fixed variable and parameter conflict (nw)

[src/emu/machine]

ds2401.c ds2401.h

trunk/src/emu/machine/ds2401.c

r22775	r22776
40	40	t_pdh  = attotime::from_usec( 30);
41	41	t_pdl  = attotime::from_usec(120);
42	42
43		save_item(NAME(state));
44		save_item(NAME(bit));
45		save_item(NAME(byte));
46		save_item(NAME(shift));
47		save_item(NAME(rx));
48		save_item(NAME(tx));
	43	save_item(NAME(m_state));
	44	save_item(NAME(m_bit));
	45	save_item(NAME(m_byte));
	46	save_item(NAME(m_shift));
	47	save_item(NAME(m_rx));
	48	save_item(NAME(m_tx));
49	49
50		timer_main  = timer_alloc(TIMER_MAIN);
51		timer_reset = timer_alloc(TIMER_RESET);
	50	m_timer_main  = timer_alloc(TIMER_MAIN);
	51	m_timer_reset = timer_alloc(TIMER_RESET);
52	52	}
53	53
54	54	void ds2401_device::device_reset()
55	55	{
56		state = STATE_IDLE;
57		bit = 0;
58		byte = 0;
59		shift = 0;
60		rx = true;
61		tx = true;
	56	m_state = STATE_IDLE;
	57	m_bit = 0;
	58	m_byte = 0;
	59	m_shift = 0;
	60	m_rx = true;
	61	m_tx = true;
62	62
63	63	if(m_region)
64	64	{
65	65	if(m_region->bytes() == SIZE_DATA)
66	66	{
67		memcpy(data, m_region->base(), SIZE_DATA);
	67	memcpy(m_data, m_region->base(), SIZE_DATA);
68	68	return;
69	69	}
70	70
r22775	r22776
75	75	logerror("ds2401 %s: Warning, no id provided, answer will be all zeroes.\n", tag());
76	76	}
77	77
78		memset(data, 0, SIZE_DATA);
	78	memset(m_data, 0, SIZE_DATA);
79	79	}
80	80
81	81	void ds2401_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
r22775	r22776
84	84	{
85	85	case TIMER_RESET:
86	86	verboselog(1, "timer_reset\n");
87		state = STATE_RESET;
88		timer_reset->adjust(attotime::never);
	87	m_state = STATE_RESET;
	88	m_timer_reset->adjust(attotime::never);
89	89	break;
90	90
91	91	case TIMER_MAIN:
92		switch(state)
	92	switch(m_state)
93	93	{
94	94	case STATE_RESET1:
95		verboselog(2, "timer_main state_reset1 %d\n", rx);
96		tx = false;
97		state = STATE_RESET2;
98		timer_main->adjust(t_pdl);
	95	verboselog(2, "timer_main state_reset1 %d\n", m_rx);
	96	m_tx = false;
	97	m_state = STATE_RESET2;
	98	m_timer_main->adjust(t_pdl);
99	99	break;
100	100
101	101	case STATE_RESET2:
102		verboselog(2, "timer_main state_reset2 %d\n", rx);
103		tx = true;
104		bit = 0;
105		shift = 0;
106		state = STATE_COMMAND;
	102	verboselog(2, "timer_main state_reset2 %d\n", m_rx);
	103	m_tx = true;
	104	m_bit = 0;
	105	m_shift = 0;
	106	m_state = STATE_COMMAND;
107	107	break;
108	108
109	109	case STATE_COMMAND:
110		verboselog(2, "timer_main state_command %d\n", rx);
	110	verboselog(2, "timer_main state_command %d\n", m_rx);
111	111
112		shift >>= 1;
113		if(rx)
	112	m_shift >>= 1;
	113	if(m_rx)
114	114	{
115		shift |= 0x80;
	115	m_shift |= 0x80;
116	116	}
117	117
118		bit++;
119		if(bit == 8)
	118	m_bit++;
	119	if(m_bit == 8)
120	120	{
121		switch(shift)
	121	switch(m_shift)
122	122	{
123	123	case COMMAND_READROM:
124	124	verboselog(1, "timer_main readrom\n");
125		bit = 0;
126		byte = 0;
127		state = STATE_READROM;
	125	m_bit = 0;
	126	m_byte = 0;
	127	m_state = STATE_READROM;
128	128	break;
129	129
130	130	default:
131		verboselog(0, "timer_main command not handled %02x\n", shift);
132		state = STATE_IDLE;
	131	verboselog(0, "timer_main command not handled %02x\n", m_shift);
	132	m_state = STATE_IDLE;
133	133	break;
134	134	}
135	135	}
136	136	break;
137	137
138	138	case STATE_READROM:
139		tx = true;
	139	m_tx = true;
140	140
141		if(byte == SIZE_DATA)
	141	if( m_byte == SIZE_DATA )
142	142	{
143	143	verboselog(1, "timer_main readrom finished\n");
144		state = STATE_IDLE;
	144	m_state = STATE_IDLE;
145	145	}
146	146	else
147	147	{
r22775	r22776
149	149	}
150	150	break;
151	151	default:
152		verboselog(0, "timer_main state not handled: %d\n", state);
	152	verboselog(0, "timer_main state not handled: %d\n", m_state);
153	153	break;
154	154	}
155	155	}
r22775	r22776
159	159	{
160	160	verboselog(1, "write(%d)\n", state);
161	161
162		if(!state && rx)
	162	if(!state && m_rx)
163	163	{
164		switch(state)
	164	switch(m_state)
165	165	{
166	166	case STATE_IDLE:
167	167	break;
168	168
169	169	case STATE_COMMAND:
170	170	verboselog(2, "state_command\n");
171		timer_main->adjust(t_samp);
	171	m_timer_main->adjust(t_samp);
172	172	break;
173	173
174	174	case STATE_READROM:
175		if(!bit)
	175	if(!m_bit)
176	176	{
177		shift = data[7 - byte];
178		verboselog(1, "<- data %02x\n", shift);
	177	m_shift = m_data[7 - m_byte];
	178	verboselog(1, "<- data %02x\n", m_shift);
179	179	}
180	180
181		tx = shift & 1;
182		shift >>= 1;
	181	m_tx = m_shift & 1;
	182	m_shift >>= 1;
183	183
184		bit++;
185		if(bit == 8)
	184	m_bit++;
	185	if(m_bit == 8)
186	186	{
187		bit = 0;
188		byte++;
	187	m_bit = 0;
	188	m_byte++;
189	189	}
190	190
191		verboselog(2, "state_readrom %d\n", tx);
192		timer_main->adjust(t_rdv);
	191	verboselog(2, "state_readrom %d\n", m_tx);
	192	m_timer_main->adjust(t_rdv);
193	193	break;
194	194
195	195	default:
196		verboselog(0, "state not handled: %d\n", state );
	196	verboselog(0, "state not handled: %d\n", m_state );
197	197	break;
198	198	}
199	199
200		timer_reset->adjust(t_rstl);
	200	m_timer_reset->adjust(t_rstl);
201	201	}
202		else if(state && !rx)
	202	else if(state && !m_rx)
203	203	{
204		switch(state)
	204	switch(m_state)
205	205	{
206	206	case STATE_RESET:
207		state = STATE_RESET1;
208		timer_main->adjust(t_pdh);
	207	m_state = STATE_RESET1;
	208	m_timer_main->adjust(t_pdh);
209	209	break;
210	210	}
211	211
212		timer_reset->adjust(attotime::never);
	212	m_timer_reset->adjust(attotime::never);
213	213	}
214	214
215		rx = state;
	215	m_rx = state;
216	216	}
217	217
218	218	READ_LINE_MEMBER( ds2401_device::read )
219	219	{
220		verboselog(2, "read %d\n", tx && rx);
221		return tx && rx;
	220	verboselog(2, "read %d\n", m_tx && m_rx);
	221	return m_tx && m_rx;
222	222	}
223	223
224	224	UINT8 ds2401_device::direct_read(int index)
225	225	{
226		return data[index];
	226	return m_data[index];
227	227	}
228	228
229	229	/*

trunk/src/emu/machine/ds2401.h

r22775	r22776
51	51	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
52	52
53	53	// internal state
54		int state, bit, shift;
55		UINT8 byte;
56		bool rx, tx;
57		UINT8 data[SIZE_DATA];
58		emu_timer *timer_main, *timer_reset;
	54	int m_state, m_bit, m_shift;
	55	UINT8 m_byte;
	56	bool m_rx, m_tx;
	57	UINT8 m_data[SIZE_DATA];
	58	emu_timer *m_timer_main, *m_timer_reset;
59	59	attotime t_samp, t_rdv, t_rstl, t_pdh, t_pdl;
60	60
61	61	private:

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team