Previous

15994 Revisions

Next

r14548 Monday 20th February, 2012 at 08:10:37 UTC by Miodrag Milanović
mc146818 - Set period even if timer is disabled, required for windows nt diserial - added optinal rx and tx timers and callbacks ins8250 - serial rx line high on start and fix for msr register bitbanger - added 19200bps Fixes for terminal callback All by Carl, credited in MAME (no whatsnew)

[src/emu]	diserial.c diserial.h
[src/emu/imagedev]	bitbngr.c
[src/emu/machine]	ins8250.c ins8250.h mc146818.c microtch.c microtch.h
[src/mess/machine]	null_modem.h ser_mouse.c ser_mouse.h terminal.c terminal.h

src/emu/imagedev/bitbngr.c

r14547	r14548
154	154	UINT32 bitbanger_device::baud_value(void)
155	155	{
156	156	static const float bauds[] = { 150.0f, 300.0f, 600.0f, 1200.0f, 2400.0f, 4800.0f, 9600.0f,
157		14400.0f, 28800.0f, 38400.0f, 57600.0f, 115200.0f};
	157	14400.0f, 19200.0f, 28800.0f, 38400.0f, 57600.0f, 115200.0f};
158	158	float result = tune_value() * bauds[m_baud];
159	159	return (UINT32)result;
160	160	}
r14547	r14548
167	167	const char *bitbanger_device::baud_string(void)
168	168	{
169	169	static const char *const bauds[] = { "150", "300", "600", "1200", "2400", "4800",
170		"9600", "14400", "28800", "38400", "57600", "115200"};
	170	"9600", "14400", "19200", "28800", "38400", "57600", "115200"};
171	171
172	172	return(bauds[m_baud]);
173	173	}

src/emu/diserial.c

r14547	r14548
37	37
38	38	m_serial_parity_table[i] = sum & 0x01;
39	39	}
	40	m_rcv_clock = NULL;
	41	m_tra_clock = NULL;
40	42	}
41	43
42	44	device_serial_interface::~device_serial_interface()
43	45	{
44	46	}
45	47
	48	void device_serial_interface::set_rcv_rate(int baud)
	49	{
	50	if(!m_rcv_clock)
	51	m_rcv_clock = device().machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(device_serial_interface::rcv_timer), this));
46	52
	53	m_rcv_baud = baud;
	54	receive_register_reset();
	55	m_rcv_clock->adjust(attotime::never);
	56	}
	57
	58	void device_serial_interface::set_tra_rate(int baud)
	59	{
	60	if(!m_tra_clock)
	61	m_tra_clock = device().machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(device_serial_interface::tra_timer), this));
	62
	63	m_tra_baud = baud;
	64	transmit_register_reset();
	65	m_tra_clock->adjust(attotime::never);
	66	}
	67
	68	void device_serial_interface::tra_timer(void *ptr, int param)
	69	{
	70	tra_callback();
	71	if(is_transmit_register_empty())
	72	{
	73	m_tra_clock->adjust(attotime::never);
	74	tra_complete();
	75	}
	76	}
	77
	78	void device_serial_interface::rcv_timer(void *ptr, int param)
	79	{
	80	rcv_callback();
	81	if(is_receive_register_full())
	82	{
	83	m_rcv_clock->adjust(attotime::never);
	84	rcv_complete();
	85	}
	86	}
	87
47	88	void device_serial_interface::set_data_frame(int num_data_bits, int stop_bit_count, int parity_code)
48	89	{
49	90	m_df_word_length = num_data_bits;
r14547	r14548
66	107	m_rcv_flags |= RECEIVE_REGISTER_WAITING_FOR_START_BIT;
67	108	}
68	109
	110	UINT8 device_serial_interface::check_for_start(UINT8 bit)
	111	{
	112	m_rcv_line = bit;
	113	if(m_rcv_flags & RECEIVE_REGISTER_SYNCHRONISED)
	114	return 0;
	115	receive_register_update_bit(bit);
	116	if(m_rcv_flags & RECEIVE_REGISTER_SYNCHRONISED)
	117	{
	118	if(m_rcv_clock && m_rcv_baud)
	119	// make start delay just a bit longer to make sure we are called after the sender
	120	m_rcv_clock->adjust(attotime::from_hz((m_rcv_baud*2)/3), 0, attotime::from_hz(m_rcv_baud));
	121	return 1;
	122	}
	123	return 0;
	124	}
	125
69	126	/* this is generic code to be used in serial chip implementations */
70	127	/* the majority of serial chips work in the same way and this code will work */
71	128	/* for them */
r14547	r14548
201	258	int i;
202	259	unsigned char transmit_data;
203	260
	261	if(m_tra_clock && m_tra_baud)
	262	m_tra_clock->adjust(attotime::from_hz(m_tra_baud), 0, attotime::from_hz(m_tra_baud));
204	263
205	264	m_tra_bit_count_transmitted = 0;
206	265	m_tra_bit_count = 0;

src/emu/diserial.h

r14547	r14548
75	75	/* TX = Transmit data. (OUTPUT) */
76	76	#define SERIAL_STATE_TX_DATA   0x00020
77	77
78
79	78	// ======================> device_serial_interface
80	79	class device_serial_interface : public device_interface
81	80	{
r14547	r14548
92	91	void receive_register_update_bit(int bit);
93	92	void receive_register_extract();
94	93
	94	void set_rcv_rate(int baud);
	95	void set_tra_rate(int baud);
95	96
96	97	void transmit_register_reset();
97	98	void transmit_register_add_bit(int bit);
r14547	r14548
114	115	void set_other_connection(device_serial_interface *other_connection);
115	116
116	117	void connect(device_serial_interface *other_connection);
	118	UINT8 check_for_start(UINT8 bit);
117	119	protected:
118	120	UINT8 m_input_state;
119	121	UINT8 m_connection_state;
	122	virtual void tra_callback() { }
	123	virtual void rcv_callback() { receive_register_update_bit(m_rcv_line); }
	124	virtual void tra_complete() { }
	125	virtual void rcv_complete() { }
120	126	private:
	127	void tra_timer(void *ptr, int param);
	128	void rcv_timer(void *ptr, int param);
	129
121	130	UINT8 m_serial_parity_table[256];
122	131
123	132	// Data frame
r14547	r14548
150	159	/* length of data to send */
151	160	UINT8 m_tra_bit_count;
152	161
	162	emu_timer *m_rcv_clock;
	163	emu_timer *m_tra_clock;
	164	int m_rcv_baud;
	165	int m_tra_baud;
	166	UINT8 m_rcv_line;
	167
153	168	device_serial_interface *m_other_connection;
154	169	};
155	170

src/emu/machine/ins8250.c

r14547	r14548
169	169	int baud;
170	170	if(m_regs.dl == 0)
171	171	{
172		m_timer->adjust(attotime::never);
	172	set_tra_rate(0);
	173	set_rcv_rate(0);
173	174	return;
174	175	}
175	176	baud = clock()/(m_regs.dl*16);
176		m_timer->adjust(attotime::zero, 0, attotime::from_hz(baud));
	177	set_tra_rate(baud);
	178	set_rcv_rate(baud);
177	179	}
178	180
179	181	WRITE8_MEMBER( ins8250_uart_device::ins8250_w )
r14547	r14548
191	193	else
192	194	{
193	195	m_regs.thr = data;
194		m_regs.lsr &= ~0x60;
	196	m_regs.lsr &= ~0x20;
195	197	if ( m_regs.mcr & 0x10 )
196	198	{
	199	m_regs.lsr &= ~0x40;
197	200	m_regs.lsr |= 1;
198	201	m_regs.rbr = data;
199	202	trigger_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
200	203	}
	204	else
	205	if(m_regs.lsr & 0x40)
	206	tra_complete();
201	207	}
202	208	break;
203	209	case 1:
r14547	r14548
356	362	return data;
357	363	}
358	364
	365	void ins8250_uart_device::rcv_complete()
	366	{
	367	if(m_regs.lsr & 0x01)
	368	{
	369	m_regs.lsr |= 0x02; //overrun
	370	trigger_int(COM_INT_PENDING_RECEIVER_LINE_STATUS);
	371	receive_register_reset();
	372	}
	373	else
	374	{
	375	m_regs.lsr |= 0x01;
	376	receive_register_extract();
	377	m_regs.rbr = get_received_char();
	378	trigger_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
	379	}
	380	}
	381
	382	void ins8250_uart_device::tra_complete()
	383	{
	384	if(!(m_regs.lsr & 0x20))
	385	{
	386	transmit_register_setup(m_regs.thr);
	387	m_regs.lsr &= ~0x40;
	388	m_regs.lsr |= 0x20;
	389	trigger_int(COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
	390	}
	391	else
	392	m_regs.lsr |= 0x40;
	393	}
	394
	395	void ins8250_uart_device::tra_callback()
	396	{
	397	m_out_tx_func(transmit_register_get_data_bit());
	398	}
	399
359	400	void ins8250_uart_device::update_msr(int bit, UINT8 state)
360	401	{
361	402	UINT8 mask = (1<<bit);
362	403	if((m_regs.msr & mask) == (state<<bit))
363	404	return;
364		m_regs.msr = (m_regs.msr & ~mask) | (mask & (state<<bit));
365		m_regs.msr = (m_regs.msr & ~(mask << 4)) | (1<<(bit+4));
	405	m_regs.msr |= mask;
	406	m_regs.msr = (m_regs.msr & ~(mask << 4)) | (state<<(bit+4));
366	407	trigger_int(COM_INT_PENDING_MODEM_STATUS_REGISTER);
367	408	}
368	409
r14547	r14548
386	427	update_msr(0, (state&&1));
387	428	}
388	429
389		void ins8250_uart_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
390		{
391		receive_register_update_bit(m_rx_line);
392		if(is_receive_register_full())
393		{
394		if(m_regs.lsr & 0x01)
395		{
396		m_regs.lsr |= 0x02; //overrun
397		trigger_int(COM_INT_PENDING_RECEIVER_LINE_STATUS);
398		}
399		else
400		{
401		m_regs.lsr |= 0x01;
402		receive_register_extract();
403		m_regs.rbr = get_received_char();
404		trigger_int(COM_INT_PENDING_RECEIVED_DATA_AVAILABLE);
405		}
406		receive_register_reset();
407		}
408
409		if(is_transmit_register_empty())
410		{
411		if(!(m_regs.lsr & 0x20))
412		{
413		transmit_register_setup(m_regs.thr);
414		m_regs.lsr &= ~0x40;
415		m_regs.lsr |= 0x20;
416		trigger_int(COM_INT_PENDING_TRANSMITTER_HOLDING_REGISTER_EMPTY);
417		}
418		else
419		m_regs.lsr |= 0x40;
420		}
421		else
422		m_out_tx_func(transmit_register_get_data_bit());
423		}
424
425	430	void ins8250_uart_device::device_start()
426	431	{
427	432	m_out_tx_func.resolve(m_out_tx_cb, *this);
r14547	r14548
431	436	m_out_out1_func.resolve(m_out_out1_cb, *this);
432	437	m_out_out2_func.resolve(m_out_out2_cb, *this);
433	438
434		m_timer = timer_alloc();
435	439	}
436	440
437	441	void ins8250_uart_device::device_reset()
r14547	r14548
443	447	m_regs.mcr = 0;
444	448	m_regs.lsr = (1<<5) | (1<<6);
445	449	m_int_pending = 0;
446		m_rx_line = 0;
447		m_timer->adjust(attotime::never);
448	450	receive_register_reset();
449	451	transmit_register_reset();
450	452	m_out_rts_func(0);
451	453	m_out_dtr_func(0);
452	454	m_out_out1_func(0);
453	455	m_out_out2_func(0);
	456	m_out_tx_func(1);
454	457	}
455	458
456	459	void ins8250_uart_device::device_config_complete()

src/emu/machine/ins8250.h

r14547	r14548
34	34	DECLARE_WRITE_LINE_MEMBER( dsr_w );
35	35	DECLARE_WRITE_LINE_MEMBER( ri_w );
36	36	DECLARE_WRITE_LINE_MEMBER( cts_w );
37		DECLARE_WRITE_LINE_MEMBER( rx_w ) { m_rx_line = state; }
	37	DECLARE_WRITE_LINE_MEMBER( rx_w ) { check_for_start(state); }
38	38	void input_callback(UINT8 state) { m_input_state = state; }
39	39
40	40	protected:
41	41	virtual void device_start();
42	42	virtual void device_config_complete();
43	43	virtual void device_reset();
	44	virtual void rcv_complete();
	45	virtual void tra_complete();
	46	virtual void tra_callback();
	47
44	48	enum {
45	49	TYPE_INS8250 = 0,
46	50	TYPE_INS8250A,
r14547	r14548
64	68	UINT8 scr;  /* 7 RW scratch register */
65	69	} m_regs;
66	70	UINT8 m_int_pending;
67		UINT8 m_rx_line;
68	71
69	72	devcb_resolved_write_line   m_out_tx_func;
70	73	devcb_resolved_write_line   m_out_dtr_func;
r14547	r14548
77	80	void update_clock();
78	81	void trigger_int(int flag);
79	82	void clear_int(int flag);
80		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
81	83	void update_msr(int bit, UINT8 state);
82
83		emu_timer *m_timer;
84	84	};
85	85
86	86	class ins8250_device : public ins8250_uart_device

src/emu/machine/microtch.c

r14547	r14548
308	308	void microtouch_serial_device::device_start()
309	309	{
310	310	microtouch_device::device_start();
311		m_timer->adjust(attotime::from_hz(clock()), 0, attotime::from_hz(clock()));
312	311	set_data_frame(8, 1, SERIAL_PARITY_NONE); //8N1?
	312	set_tra_rate(clock());
	313	set_rcv_rate(clock());
313	314	m_out_stx_func.resolve(m_out_stx_cb, *this);
314	315	m_count = 0;
315	316	m_output_valid = false;
r14547	r14548
317	318	save_item(NAME(m_count));
318	319	save_item(NAME(m_output_valid));
319	320	save_item(NAME(m_output));
320		save_item(NAME(m_rx_line));
321	321	}
322	322
323		void microtouch_serial_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
	323	void microtouch_serial_device::tx(UINT8 data)
324	324	{
	325	m_output = data;
	326	m_output_valid = true;
325	327	if(is_transmit_register_empty())
326		{
327		if(m_output_valid)
328		{
329		transmit_register_setup(m_output);
330		m_output_valid = false;
331		}
332		}
333		else
334		m_out_stx_func(transmit_register_get_data_bit());
	328	tra_complete();
	329	}
335	330
336		receive_register_update_bit(m_rx_line);
337		if(is_receive_register_full())
	331	void microtouch_serial_device::tra_callback()
	332	{
	333	m_out_stx_func(transmit_register_get_data_bit());
	334	}
	335
	336	void microtouch_serial_device::tra_complete()
	337	{
	338	if(m_output_valid)
338	339	{
339		receive_register_extract();
340		microtouch_device::rx(*memory_nonspecific_space(machine()), 0, get_received_char());
341		receive_register_reset();
	340	transmit_register_setup(m_output);
	341	m_output_valid = false;
342	342	}
	343	}
343	344
344		if((m_count == 0) && (m_output_valid == false))
345		microtouch_device::device_timer(timer, id, param, ptr);
346
347		++m_count %= 8;
	345	void microtouch_serial_device::rcv_complete()
	346	{
	347	receive_register_extract();
	348	microtouch_device::rx(*memory_nonspecific_space(machine()), 0, get_received_char());
348	349	}

src/emu/machine/microtch.h

r14547	r14548
80	80	public:
81	81	microtouch_serial_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
82	82
83		DECLARE_WRITE_LINE_MEMBER(rx) {m_rx_line = state;}
	83	DECLARE_WRITE_LINE_MEMBER(rx) { check_for_start(state); }
84	84	protected:
85	85	virtual void device_start();
86		virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
87	86	virtual void device_config_complete();
88		virtual void tx(UINT8 data) {m_output = data; m_output_valid = true;}
	87	virtual void tx(UINT8 data);
89	88	virtual void input_callback(UINT8 state) { m_input_state = state; }
	89	virtual void tra_callback();
	90	virtual void tra_complete();
	91	virtual void rcv_complete();
90	92	private:
91	93	int m_count;
92	94	bool m_output_valid;
93	95	UINT8 m_output;
94		UINT8 m_rx_line;
95	96	devcb_resolved_write_line m_out_stx_func;
96	97	};
97	98

src/emu/machine/mc146818.c

r14547	r14548
476	476	case 0x0a:
477	477	// fixme: allow different time base
478	478	data &= 0x0f;
479		if (m_data[0x0b] & 0x40) {
480		if (data > 2)
481		m_period = attotime::from_hz(32768 >> (data - 1));
482		else if (data > 0)
483		m_period = attotime::from_hz(32768 >> (data + 6));
484		else m_period = attotime::never;
485		rate = attotime::zero;
486		} else rate = attotime::never;
	479	if (data > 2)
	480	m_period = attotime::from_hz(32768 >> (data - 1));
	481	else if (data > 0)
	482	m_period = attotime::from_hz(32768 >> (data + 6));
	483	else m_period = attotime::never;
	484
	485	if(m_data[0x0b] & 0x40)
	486	rate = attotime::zero;
	487	else rate = attotime::never;
	488
487	489	m_periodic_timer->adjust(rate, 0, m_period);
488	490	data |= m_data[m_index % MC146818_DATA_SIZE] & 0xf0;
489	491	m_data[m_index % MC146818_DATA_SIZE] = data;

src/mess/machine/ser_mouse.c

r14547	r14548
35	35	m_timer = timer_alloc();
36	36	m_enabled = false;
37	37	set_frame();
	38	set_tra_rate(1200);
38	39	}
39	40
40	41	void serial_mouse_device::device_reset()
r14547	r14548
51	52	m_owner->out_cts(0);
52	53	}
53	54
	55	void serial_mouse_device::tra_complete()
	56	{
	57	if(m_tail != m_head)
	58	transmit_register_setup(unqueue_data());
	59	}
	60
	61	void serial_mouse_device::tra_callback()
	62	{
	63	m_rbit = transmit_register_get_data_bit();
	64	m_owner->out_rx(m_rbit);
	65	}
	66
54	67	/**************************************************************************
55	68	*  Check for mouse moves and buttons. Build delta x/y packets
56	69	**************************************************************************/
r14547	r14548
62	75	int mbc;
63	76
64	77	/* Do not get deltas or send packets if queue is not empty (Prevents drifting) */
65		if ((m_head==m_tail) && (m_count == 0))
	78	if (m_head==m_tail)
66	79	{
67	80	nx = input_port_read(*this, "ser_mouse_x");
68	81
r14547	r14548
87	100	mouse_trans(dx, dy, nb, mbc);
88	101	}
89	102
90		++m_count %= 8;
91	103
92		if(is_transmit_register_empty())
93		{
94		if(m_tail != m_head)
95		transmit_register_setup(unqueue_data());
96		}
97		else
98		{
99		m_rbit = transmit_register_get_data_bit();
100		m_owner->out_rx(m_rbit);
101		}
	104	if(m_tail != m_head && is_transmit_register_empty())
	105	transmit_register_setup(unqueue_data());
102	106	}
103	107
104	108	void microsoft_mouse_device::mouse_trans(int dx, int dy, int nb, int mbc)
r14547	r14548
181	185	void serial_mouse_device::set_mouse_enable(bool state)
182	186	{
183	187	if(state && !m_enabled)
184		m_timer->adjust(attotime::zero, 0, attotime::from_hz(1200));
	188	{
	189	m_timer->adjust(attotime::zero, 0, attotime::from_hz(240));
	190	m_rbit = 1;
	191	m_owner->out_rx(1);
	192	}
185	193	else if(!state && m_enabled)
186	194	{
187	195	m_timer->adjust(attotime::never);
188	196	m_head = m_tail = 0;
	197	m_rbit = 0;
	198	m_owner->out_rx(0);
189	199	}
190	200	m_enabled = state;
191	201

src/mess/machine/ser_mouse.h

r14547	r14548
30	30	void queue_data(UINT8 data) {m_queue[m_head] = data; ++m_head %= 256;}
31	31	UINT8 unqueue_data() {UINT8 ret = m_queue[m_tail]; ++m_tail %= 256; return ret;}
32	32	virtual void input_callback(UINT8 state) { m_input_state = state; }
	33	virtual void tra_complete();
	34	virtual void tra_callback();
33	35	private:
34	36	UINT8 m_queue[256];
35	37	UINT8 m_head, m_tail, m_mb;

src/mess/machine/terminal.c

r14547	r14548
551	551	{
552	552	terminal_state *term = get_safe_token(device);
553	553	const terminal_interface *intf = get_interface(device);
554		if(dynamic_cast<serial_terminal_device *>(device->owner()))
555		term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device->owner());
556		else
557		term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device);
	554	term->terminal_keyboard_func.resolve(intf->terminal_keyboard_func, *device);
558	555
559	556	if (device->clock())
560	557	device->machine().scheduler().timer_pulse(attotime::from_hz(device->clock()), FUNC(serial_callback), 0, (void*)device);
r14547	r14548
573	570	term->last_code = 0;
574	571	term->scan_line = 0;
575	572	term->rx_state = START;
576		term->tx_state = STOP;
	573	term->tx_state = DONE;
577	574	}
578	575
579	576	/*
r14547	r14548
754	751	}
755	752
756	753	static const terminal_interface serial_terminal_terminal_interface = {
757		DEVCB_MEMBER(serial_terminal_device, serial_keyboard_func)
	754	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, serial_terminal_device, serial_keyboard_func)
758	755	};
759	756
760	757	static MACHINE_CONFIG_FRAGMENT(serial_terminal_config)
r14547	r14548
767	764	{
768	765	return MACHINE_CONFIG_NAME(serial_terminal_config);
769	766	}
770

src/mess/machine/terminal.h

r14547	r14548
49	49
50	50	UINT8 terminal_keyboard_handler(running_machine &machine, UINT8 last_code, UINT8 *scan_line, UINT8 *tx_shift, int *tx_state, device_t *device);
51	51
52
53	52	class serial_terminal_device :
54	53	public device_t,
55	54	public device_serial_port_interface
r14547	r14548
61	60	DECLARE_WRITE8_MEMBER(serial_keyboard_func) { m_rbit = data&&1; m_owner->out_rx(m_rbit); }
62	61	protected:
63	62	virtual void device_start() { m_owner = dynamic_cast<serial_port_device *>(owner()); }
	63	virtual void device_reset() { m_owner->out_rx(1); m_rbit = 1; }
64	64	private:
65	65	required_device<device_t> m_terminal;
66	66	serial_port_device *m_owner;

src/mess/machine/null_modem.h

r14547	r14548
16	16	virtual void tx(UINT8 state) { m_tbit = state; m_bitbanger->output(state); }
17	17	protected:
18	18	virtual void device_start() { m_owner = dynamic_cast<serial_port_device *>(owner()); }
	19	virtual void device_reset() { m_owner->out_rx(1); m_rbit = 1; }
19	20	private:
20	21	serial_port_device *m_owner;
21	22	required_device<bitbanger_device> m_bitbanger;

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team