Previous

199869 Revisions

Next

r18431 Wednesday 10th October, 2012 at 21:14:56 UTC by smf
Uses logical levels rather than voltage levels for control signals, you have to write 0 to the data lines when you're not sending data. Added a kludge to stop the ff from the 6522 from preventing the bus from being read, this may or may not be how the hardware really works. [smf]

[src/emu/machine]	scsibus.c scsicb.c scsidev.c scsihle.c
[src/mess/drivers]	bullet.c v1050.c
[src/mess/machine]	d9060.c d9060.h e01.c lux4105.c lux4105.h rmnimbus.c

trunk/src/emu/machine/scsibus.c

r18430	r18431
9	9
10	10	void scsibus_device::scsi_update()
11	11	{
12		UINT32 newdata = SCSI_MASK_ALL;
	12	UINT32 newdata = 0;
13	13
14	14	for( int i = 0; i < deviceCount; i++ )
15	15	{
16		newdata &= devices[ i ]->data_out;
	16	newdata |= devices[ i ]->data_out;
17	17	}
18	18
	19	newdata &= SCSI_MASK_ALL;
	20
19	21	UINT32 mask = data ^ newdata;
20	22
21	23	if( mask != 0 )
r18430	r18431
47	49	}
48	50	}
49	51
50		data = SCSI_MASK_ALL;
	52	data = 0;
51	53	}
52	54
53	55	const device_type SCSIBUS = &device_creator<scsibus_device>;

trunk/src/emu/machine/scsihle.c

r18430	r18431
280	280	switch( tid )
281	281	{
282	282	case 0:
283		scsi_out(param * SCSI_MASK_REQ, SCSI_MASK_REQ);
	283	scsi_out(param ? SCSI_MASK_REQ : 0, SCSI_MASK_REQ);
284	284	break;
285	285
286	286	case 1:
287		scsi_out(param * SCSI_MASK_BSY, SCSI_MASK_BSY);
	287	scsi_out(param ? SCSI_MASK_BSY : 0, SCSI_MASK_BSY);
288	288	break;
289	289
290	290	case 2:
r18430	r18431
411	411	switch(phase)
412	412	{
413	413	case SCSI_PHASE_BUS_FREE:
414		scsi_out( SCSI_MASK_ALL, SCSI_MASK_ALL );
	414	scsi_out( 0, SCSI_MASK_ALL );
415	415	LOG(1,"SCSIBUS: done\n\n");
416	416	break;
417	417
418	418	case SCSI_PHASE_COMMAND:
419		scsi_out( SCSI_MASK_DATA | SCSI_MASK_IO | SCSI_MASK_MSG, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
	419	scsi_out( SCSI_MASK_CD, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
420	420	LOG(1,"\nSCSIBUS: Command begin\n");
421		scsi_out_req_delay( 0 );
	421	scsi_out_req_delay( 1 );
422	422	break;
423	423
424	424	case SCSI_PHASE_DATAOUT:
425		scsi_out( SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
426		scsi_out_req_delay( 0 );
	425	scsi_out( 0, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
	426	scsi_out_req_delay( 1 );
427	427	break;
428	428
429	429	case SCSI_PHASE_DATAIN:
430		scsi_out( SCSI_MASK_CD | SCSI_MASK_MSG, SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
431		scsi_out_req_delay( 0 );
	430	scsi_out( SCSI_MASK_IO, SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
	431	scsi_out_req_delay( 1 );
432	432	break;
433	433
434	434	case SCSI_PHASE_STATUS:
435		scsi_out( SCSI_STATUS_OK | SCSI_MASK_MSG, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
436		scsi_out_req_delay( 0 );
	435	scsi_out( SCSI_STATUS_OK | SCSI_MASK_CD | SCSI_MASK_IO, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
	436	scsi_out_req_delay( 1 );
437	437	break;
438	438
439	439	case SCSI_PHASE_MESSAGE_OUT:
440		scsi_out( SCSI_MASK_DATA | SCSI_MASK_IO, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
441		scsi_out_req_delay( 0 );
	440	scsi_out( SCSI_MASK_CD | SCSI_MASK_MSG, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );
	441	scsi_out_req_delay( 1 );
442	442	break;
443	443
444	444	case SCSI_PHASE_MESSAGE_IN:
445		scsi_out( 0, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );// no errors for the time being !
446		scsi_out_req_delay( 0 );
	445	scsi_out( 0 | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG, SCSI_MASK_DATA | SCSI_MASK_CD | SCSI_MASK_IO | SCSI_MASK_MSG );// no errors for the time being !
	446	scsi_out_req_delay( 1 );
447	447	break;
448	448	}
449	449	}
r18430	r18431
451	451	void scsihle_device::scsi_in( UINT32 data, UINT32 mask )
452	452	{
453	453	// Reset aborts and returns to bus free
454		if( ( mask & SCSI_MASK_RST ) != 0 && ( data & SCSI_MASK_RST ) == 0 )
	454	if( ( mask & SCSI_MASK_RST ) != 0 && ( data & SCSI_MASK_RST ) != 0 )
455	455	{
456	456	scsi_change_phase(SCSI_PHASE_BUS_FREE);
457	457	cmd_idx=0;
r18430	r18431
474	474	GetDevice(&hdfile);
475	475	if(hdfile!=(void *)NULL)
476	476	{
477		if( ( data & SCSI_MASK_SEL ) != 0 )
	477	if( ( data & SCSI_MASK_SEL ) == 0 )
478	478	{
479	479	sectorbytes = GetSectorBytes();
480	480	scsi_change_phase(SCSI_PHASE_COMMAND);
481	481	}
482	482	else
483	483	{
484		sel_timer->adjust(attotime::from_nsec(BSY_DELAY_NS),0);
	484	sel_timer->adjust(attotime::from_nsec(BSY_DELAY_NS),1);
485	485	}
486	486	}
487	487	}
r18430	r18431
490	490	case SCSI_PHASE_COMMAND:
491	491	if( ( mask & SCSI_MASK_ACK ) != 0 )
492	492	{
493		if( ( data & SCSI_MASK_ACK ) != 0 )
	493	if( ( data & SCSI_MASK_ACK ) == 0 )
494	494	{
495	495	command[ cmd_idx++ ] = data & SCSI_MASK_DATA;
496	496
r18430	r18431
501	501	}
502	502	else
503	503	{
504		scsi_out_req_delay( 0 );
	504	scsi_out_req_delay( 1 );
505	505	}
506	506	}
507	507	else
508	508	{
509		scsi_out_req_delay( 1 );
	509	scsi_out_req_delay( 0 );
510	510	}
511	511	}
512	512	break;
r18430	r18431
514	514	case SCSI_PHASE_DATAIN:
515	515	if( ( mask & SCSI_MASK_ACK ) != 0 )
516	516	{
517		if( ( data & SCSI_MASK_ACK ) != 0 )
	517	if( ( data & SCSI_MASK_ACK ) == 0 )
518	518	{
519	519	// check to see if we have reached the end of the block buffer
520	520	// and that there is more data to read from the scsi disk
r18430	r18431
530	530	else
531	531	{
532	532	scsi_out( buffer[ data_idx++ ], SCSI_MASK_DATA );
533		scsi_out_req_delay( 0 );
	533	scsi_out_req_delay( 1 );
534	534	}
535	535	}
536	536	else
537	537	{
538		scsi_out_req_delay( 1 );
	538	scsi_out_req_delay( 0 );
539	539	}
540	540	}
541	541	break;
r18430	r18431
543	543	case SCSI_PHASE_DATAOUT:
544	544	if( ( mask & SCSI_MASK_ACK ) != 0 )
545	545	{
546		if( ( data & SCSI_MASK_ACK ) != 0 )
	546	if( ( data & SCSI_MASK_ACK ) == 0 )
547	547	{
548	548	//LOG(1,"SCSIBUS:bytes_left=%02X data_idx=%02X\n",bytes_left,data_idx);
549	549	buffer[data_idx++]=data & SCSI_MASK_DATA;
r18430	r18431
578	578	}
579	579	else
580	580	{
581		scsi_out_req_delay( 0 );
	581	scsi_out_req_delay( 1 );
582	582	}
583	583	}
584	584	else
585	585	{
586		scsi_out_req_delay( 1 );
	586	scsi_out_req_delay( 0 );
587	587	}
588	588	}
589	589	break;
r18430	r18431
591	591	case SCSI_PHASE_STATUS:
592	592	if( ( mask & SCSI_MASK_ACK ) != 0 )
593	593	{
594		if( ( data & SCSI_MASK_ACK ) != 0 )
	594	if( ( data & SCSI_MASK_ACK ) == 0 )
595	595	{
596	596	if(cmd_idx > 0)
597	597	{
r18430	r18431
599	599	}
600	600	else
601	601	{
602		scsi_out_req_delay( 0 );
	602	scsi_out_req_delay( 1 );
603	603	}
604	604	}
605	605	else
606	606	{
607	607	cmd_idx++;
608		scsi_out_req_delay( 1 );
	608	scsi_out_req_delay( 0 );
609	609	}
610	610	}
611	611	break;
r18430	r18431
613	613	case SCSI_PHASE_MESSAGE_IN:
614	614	if( ( mask & SCSI_MASK_ACK ) != 0 )
615	615	{
616		if( ( data & SCSI_MASK_ACK ) != 0 )
	616	if( ( data & SCSI_MASK_ACK ) == 0 )
617	617	{
618	618	if(cmd_idx > 0)
619	619	{
r18430	r18431
624	624	}
625	625	else
626	626	{
627		scsi_out_req_delay( 0 );
	627	scsi_out_req_delay( 1 );
628	628	}
629	629	}
630	630	else
631	631	{
632	632	cmd_idx++;
633		scsi_out_req_delay( 1 );
	633	scsi_out_req_delay( 0 );
634	634	}
635	635	}
636	636	break;

trunk/src/emu/machine/scsicb.c

r18430	r18431
45	45	{
46	46	scsidev_device::device_start();
47	47
48		linestate = SCSI_MASK_ALL;
	48	linestate = 0;
49	49
50	50	out_bsy_func.resolve(_out_bsy_func, *this);
51	51	out_sel_func.resolve(_out_sel_func, *this);
r18430	r18431
118	118
119	119	UINT8 scsicb_device::get_scsi_line( UINT32 mask )
120	120	{
121		UINT8 state = (int)( ( linestate & mask ) != 0 );
	121	UINT8 state;
122	122
	123	if( ( linestate & mask ) != 0 )
	124	{
	125	state = 1;
	126	}
	127	else
	128	{
	129	state = 0;
	130	}
	131
123	132	verboselog( 1, machine(), "%s get_scsi_line %s %d\n", tag(), get_line_name( mask ), state );
124	133
125	134	return state;
r18430	r18431
129	138	{
130	139	verboselog( 1, machine(), "%s set_scsi_line %s %d\n", tag(), get_line_name( mask ), state );
131	140
132		scsi_out( state * mask, mask );
	141	if( state )
	142	{
	143	scsi_out( mask, mask );
	144	}
	145	else
	146	{
	147	scsi_out( 0, mask );
	148	}
133	149	}
134	150
135	151	void scsicb_device::trigger_callback( UINT32 update_mask, UINT32 line_mask, devcb_resolved_write_line &write_line )
136	152	{
137	153	if( ( update_mask & line_mask ) != 0 && !write_line.isnull() )
138	154	{
139		int state = (int)( ( linestate & line_mask ) != 0 );
	155	UINT8 state;
140	156
	157	if( ( linestate & line_mask ) != 0 )
	158	{
	159	state = 1;
	160	}
	161	else
	162	{
	163	state = 0;
	164	}
	165
141	166	verboselog( 1, machine(), "%s trigger_callback %s %d\n", tag(), get_line_name( line_mask ), state );
142	167
143	168	write_line( state );

trunk/src/emu/machine/scsidev.c

r18430	r18431
18	18
19	19	void scsidev_device::device_start()
20	20	{
21		data_out = SCSI_MASK_ALL;
	21	data_out = 0;
22	22	}
23	23
24	24	void scsidev_device::scsi_out( UINT32 data, UINT32 mask )

trunk/src/mess/machine/lux4105.c

r18430	r18431
36	36
37	37	WRITE_LINE_MEMBER( luxor_4105_device::sasi_bsy_w )
38	38	{
39		if (!state)
	39	if (state)
40	40	{
41		m_sasibus->scsi_sel_w(1);
	41	m_sasibus->scsi_sel_w(0);
42	42	}
43	43	}
44	44
45	45	WRITE_LINE_MEMBER( luxor_4105_device::sasi_io_w )
46	46	{
47		if (!m_io && state)
	47	if (!state)
48	48	{
49	49	m_sasibus->scsi_data_w(m_data);
50	50	}
51	51
52		m_io = state;
53
54	52	update_trrq_int();
55	53	}
56	54
r18430	r18431
58	56	{
59	57	if (state)
60	58	{
61		m_sasibus->scsi_ack_w(1);
	59	m_sasibus->scsi_ack_w(0);
62	60	}
63	61
64	62	update_trrq_int();
r18430	r18431
145	143
146	144	inline void luxor_4105_device::update_trrq_int()
147	145	{
148		int cd = m_sasibus->scsi_cd_r();
149		int req = m_sasibus->scsi_req_r();
	146	int cd = !m_sasibus->scsi_cd_r();
	147	int req = !m_sasibus->scsi_req_r();
150	148	int trrq = !(cd & !req);
151	149
152	150	if (BIT(m_dma, 5))
r18430	r18431
180	178	luxor_4105_device::luxor_4105_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
181	179	: device_t(mconfig, LUXOR_4105, "Luxor 4105", tag, owner, clock),
182	180	device_abc1600bus_card_interface(mconfig, *this),
183		m_sasibus(*this, SASIBUS_TAG ":host"),
184		m_io(1)
	181	m_sasibus(*this, SASIBUS_TAG ":host")
185	182	{
186	183	}
187	184
r18430	r18431
196	193
197	194	// state saving
198	195	save_item(NAME(m_cs));
199		save_item(NAME(m_io));
200	196	save_item(NAME(m_data));
201	197	save_item(NAME(m_dma));
202	198	}
r18430	r18431
212	208	m_data = 0;
213	209	m_dma = 0;
214	210
215		m_sasibus->scsi_rst_w(0);
216	211	m_sasibus->scsi_rst_w(1);
	212	m_sasibus->scsi_rst_w(0);
217	213
218	214	m_slot->trrq_w(1);
219	215	}
r18430	r18431
279	275
280	276	*/
281	277
282		data = !m_sasibus->scsi_bsy_r();
283		data |= !m_sasibus->scsi_req_r() << 2;
284		data |= !m_sasibus->scsi_cd_r() << 3;
285		data |= !m_sasibus->scsi_io_r() << 6;
	278	data = m_sasibus->scsi_bsy_r();
	279	data |= m_sasibus->scsi_req_r() << 2;
	280	data |= m_sasibus->scsi_cd_r() << 3;
	281	data |= m_sasibus->scsi_io_r() << 6;
286	282	}
287	283
288	284	return data;
r18430	r18431
299	295
300	296	if (m_cs)
301	297	{
302		if (m_sasibus->scsi_bsy_r())
	298	if (!m_sasibus->scsi_bsy_r())
303	299	{
304	300	ioport("1E")->read();
305	301	}
306	302	else
307	303	{
308		if (!m_sasibus->scsi_io_r())
	304	if (m_sasibus->scsi_io_r())
309	305	{
310	306	data = m_sasibus->scsi_data_r();
311	307
312		if (!m_sasibus->scsi_req_r())
	308	if (m_sasibus->scsi_req_r())
313	309	{
314		m_sasibus->scsi_ack_w(0);
	310	m_sasibus->scsi_ack_w(1);
315	311	}
316	312	}
317	313	}
r18430	r18431
331	327	{
332	328	m_data = data;
333	329
334		if (m_sasibus->scsi_io_r())
	330	if (!m_sasibus->scsi_io_r())
335	331	{
336	332	m_sasibus->scsi_data_w(m_data);
337	333
338		if (!m_sasibus->scsi_req_r())
	334	if (m_sasibus->scsi_req_r())
339	335	{
340		m_sasibus->scsi_ack_w(0);
	336	m_sasibus->scsi_ack_w(1);
341	337	}
342	338	}
343	339	}
r18430	r18431
352	348	{
353	349	if (m_cs)
354	350	{
355		m_sasibus->scsi_sel_w(0);
	351	m_sasibus->scsi_sel_w(1);
356	352	}
357	353	}
358	354
r18430	r18431
368	364	m_data = 0;
369	365	m_dma = 0;
370	366
371		m_sasibus->scsi_rst_w(0);
372	367	m_sasibus->scsi_rst_w(1);
	368	m_sasibus->scsi_rst_w(0);
373	369	}
374	370	}
375	371

trunk/src/mess/machine/lux4105.h

r18430	r18431
74	74	required_device<scsicb_device> m_sasibus;
75	75
76	76	int m_cs;
77		int m_io;
78	77	UINT8 m_data;
79	78	UINT8 m_dma;
80	79	};

trunk/src/mess/machine/rmnimbus.c

r18430	r18431
2418	2418	rmnimbus_state *state = machine.driver_data<rmnimbus_state>();
2419	2419
2420	2420	state->m_nimbus_drives.reg410_in=0;
2421		state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_req_r() ? HDC_REQ_MASK : 0);
2422		state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_cd_r()  ? HDC_CD_MASK  : 0);
2423		state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_io_r()  ? HDC_IO_MASK  : 0);
2424		state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_bsy_r() ? HDC_BSY_MASK : 0);
2425		state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_msg_r() ? HDC_MSG_MASK : 0);
	2421	state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_req_r() ? 0 : HDC_REQ_MASK);
	2422	state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_cd_r()  ? 0 : HDC_CD_MASK);
	2423	state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_io_r()  ? 0 : HDC_IO_MASK);
	2424	state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_bsy_r() ? 0 : HDC_BSY_MASK);
	2425	state->m_nimbus_drives.reg410_in |= (state->m_scsibus->scsi_msg_r() ? 0 : HDC_MSG_MASK);
2426	2426
2427	2427	state->m_nimbus_drives.drq_ff=0;
2428	2428	}
r18430	r18431
2438	2438
2439	2439	state->m_nimbus_drives.reg410_out=data;
2440	2440
2441		state->m_scsibus->scsi_rst_w((data & HDC_RESET_MASK) ? 0 : 1);
2442		state->m_scsibus->scsi_sel_w((data & HDC_SEL_MASK) ? 0 : 1);
	2441	state->m_scsibus->scsi_rst_w((data & HDC_RESET_MASK) ? 1 : 0);
	2442	state->m_scsibus->scsi_sel_w((data & HDC_SEL_MASK) ? 1 : 0);
2443	2443	}
2444	2444
2445	2445	static void hdc_post_rw(running_machine &machine)
r18430	r18431
2447	2447	rmnimbus_state *state = machine.driver_data<rmnimbus_state>();
2448	2448
2449	2449	if((state->m_nimbus_drives.reg410_in & HDC_REQ_MASK)==0)
2450		state->m_scsibus->scsi_ack_w(0);
	2450	state->m_scsibus->scsi_ack_w(1);
2451	2451
2452	2452	state->m_nimbus_drives.drq_ff=0;
2453	2453	}
r18430	r18431
2492	2492
2493	2493	last=m_nimbus_drives.reg410_in & mask;
2494	2494
2495		if(state)
	2495	if(!state)
2496	2496	m_nimbus_drives.reg410_in|=mask;
2497	2497	else
2498	2498	m_nimbus_drives.reg410_in&=~mask;
r18430	r18431
2506	2506	switch( mask )
2507	2507	{
2508	2508	case HDC_REQ_MASK:
2509		if (state==0)
	2509	if (state)
2510	2510	{
2511	2511	if(((m_nimbus_drives.reg410_in & HDC_CD_MASK)==HDC_CD_MASK) && (last!=0))
2512	2512	{
r18430	r18431
2516	2516	}
2517	2517	else
2518	2518	{
2519		m_scsibus->scsi_ack_w(1);
	2519	m_scsibus->scsi_ack_w(0);
2520	2520	}
2521	2521	break;
2522	2522
2523	2523	case HDC_IO_MASK:
2524		if (state==0)
	2524	if (state)
2525	2525	{
2526	2526	printf( "switch to input mode\n" );
2527		m_scsibus->scsi_data_w(0xff);
	2527	m_scsibus->scsi_data_w(0);
2528	2528	}
2529	2529	break;
2530	2530	}

trunk/src/mess/machine/e01.c

r18430	r18431
266	266
267	267	WRITE_LINE_MEMBER( e01_device::scsi_bsy_w )
268	268	{
269		if (!state)
	269	if (state)
270	270	{
271		m_scsibus->scsi_sel_w(1);
	271	m_scsibus->scsi_sel_w(0);
272	272	}
273	273	}
274	274
275	275	WRITE_LINE_MEMBER( e01_device::scsi_req_w )
276	276	{
277		if (state)
	277	if (!state)
278	278	{
279		m_scsibus->scsi_ack_w(1);
	279	m_scsibus->scsi_ack_w(0);
280	280	}
281	281
282	282	m_hdc_irq = !state;
r18430	r18431
692	692	{
693	693	UINT8 data = m_scsibus->scsi_data_r(space, 0);
694	694
695		m_scsibus->scsi_ack_w(0);
	695	m_scsibus->scsi_ack_w(1);
696	696
697	697	return data;
698	698	}
r18430	r18431
706	706	{
707	707	m_scsibus->scsi_data_w(space, 0, data);
708	708
709		m_scsibus->scsi_ack_w(0);
	709	m_scsibus->scsi_ack_w(1);
710	710	}
711	711
712	712
r18430	r18431
734	734	UINT8 data = 0;
735	735
736	736	// SCSI bus
737		data |= !m_scsibus->scsi_msg_r();
738		data |= !m_scsibus->scsi_bsy_r() << 1;
739		data |= !m_scsibus->scsi_req_r() << 5;
740		data |= !m_scsibus->scsi_io_r() << 6;
741		data |= !m_scsibus->scsi_cd_r() << 7;
	737	data |= m_scsibus->scsi_msg_r();
	738	data |= m_scsibus->scsi_bsy_r() << 1;
	739	data |= m_scsibus->scsi_req_r() << 5;
	740	data |= m_scsibus->scsi_io_r() << 6;
	741	data |= m_scsibus->scsi_cd_r() << 7;
742	742
743	743	// TODO NIRQ
744	744
r18430	r18431
752	752
753	753	WRITE8_MEMBER( e01_device::hdc_select_w )
754	754	{
755		m_scsibus->scsi_sel_w(0);
	755	m_scsibus->scsi_sel_w(1);
756	756	}
757	757
758	758

trunk/src/mess/machine/d9060.c

r18430	r18431
143	143
144	144	WRITE_LINE_MEMBER( base_d9060_device::req_w )
145	145	{
146		m_via->write_ca1(!state);
	146	m_via->write_ca1(state);
147	147	}
148	148
149	149	static const SCSICB_interface sasi_intf =
r18430	r18431
377	377
378	378	UINT8 data = 0;
379	379
380		data |= !m_sasibus->scsi_cd_r() << 2;
381		data |= !m_sasibus->scsi_bsy_r() << 3;
382		data |= !m_sasibus->scsi_io_r() << 6;
383		data |= !m_sasibus->scsi_msg_r() << 7;
	380	data |= m_sasibus->scsi_cd_r() << 2;
	381	data |= m_sasibus->scsi_bsy_r() << 3;
	382	data |= m_sasibus->scsi_io_r() << 6;
	383	data |= m_sasibus->scsi_msg_r() << 7;
384	384
385	385	// drive type
386	386	data |= (m_variant == TYPE_9060) << 4;
r18430	r18431
405	405
406	406	*/
407	407
408		m_sasibus->scsi_sel_w(!BIT(data, 0));
409		m_sasibus->scsi_rst_w(!BIT(data, 1));
	408	m_sasibus->scsi_sel_w(BIT(data, 0));
	409	m_sasibus->scsi_rst_w(BIT(data, 1));
410	410	}
411	411
412	412	READ_LINE_MEMBER( base_d9060_device::req_r )
413	413	{
414		return !m_sasibus->scsi_req_r();
	414	return m_sasibus->scsi_req_r();
415	415	}
416	416
417	417	WRITE_LINE_MEMBER( base_d9060_device::ack_w )
418	418	{
419		m_sasibus->scsi_ack_w(state);
	419	m_sasibus->scsi_ack_w(!state);
420	420	}
421	421
422	422	WRITE_LINE_MEMBER( base_d9060_device::enable_w )
423	423	{
424	424	m_enable = state;
	425
	426	if( !m_enable )
	427	{
	428	m_sasibus->scsi_data_w( m_data );
	429	}
	430	else
	431	{
	432	m_sasibus->scsi_data_w( 0 );
	433	}
425	434	}
426	435
	436	WRITE8_MEMBER( base_d9060_device::scsi_data_w )
	437	{
	438	m_data = data;
	439
	440	if( !m_enable )
	441	{
	442	m_sasibus->scsi_data_w( m_data );
	443	}
	444	}
	445
427	446	static const via6522_interface via_intf =
428	447	{
429	448	DEVCB_DEVICE_MEMBER(SASIBUS_TAG ":host", scsicb_device, scsi_data_r),
r18430	r18431
433	452	DEVCB_NULL,
434	453	DEVCB_NULL,
435	454
436		DEVCB_DEVICE_MEMBER(SASIBUS_TAG ":host", scsicb_device, scsi_data_w),
	455	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, base_d9060_device, scsi_data_w),
437	456	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, base_d9060_device, via_pb_w),
438	457	DEVCB_NULL,
439	458	DEVCB_NULL,
r18430	r18431
520	539	m_rfdo(1),
521	540	m_daco(1),
522	541	m_atna(1),
523		m_enable(1),
	542	m_enable(0),
524	543	m_variant(variant)
525	544	{
526	545	}

trunk/src/mess/machine/d9060.h

r18430	r18431
71	71	DECLARE_READ_LINE_MEMBER( req_r );
72	72	DECLARE_WRITE_LINE_MEMBER( ack_w );
73	73	DECLARE_WRITE_LINE_MEMBER( enable_w );
	74	DECLARE_WRITE8_MEMBER( scsi_data_w );
74	75
75	76	protected:
76	77	// device-level overrides
r18430	r18431
99	100
100	101	// SASI bus
101	102	int m_enable;
	103	UINT8 m_data;
102	104
103	105	int m_variant;
104	106	};

trunk/src/mess/drivers/bullet.c

r18430	r18431
482	482	{
483	483	UINT8 data = m_scsibus->scsi_data_r();
484	484
485		m_scsibus->scsi_ack_w(0);
	485	m_scsibus->scsi_ack_w(1);
486	486
487	487	m_wack = 0;
488	488	update_dma_rdy();
r18430	r18431
499	499	{
500	500	m_scsibus->scsi_data_w(data);
501	501
502		m_scsibus->scsi_ack_w(0);
	502	m_scsibus->scsi_ack_w(1);
503	503
504	504	m_wack = 0;
505	505	update_dma_rdy();
r18430	r18431
928	928
929	929	UINT8 data = 0;
930	930
931		data |= !m_scsibus->scsi_bsy_r() << 3;
932		data |= !m_scsibus->scsi_msg_r() << 4;
933		data |= !m_scsibus->scsi_cd_r() << 5;
934		data |= !m_scsibus->scsi_req_r() << 6;
935		data |= !m_scsibus->scsi_io_r() << 7;
	931	data |= m_scsibus->scsi_bsy_r() << 3;
	932	data |= m_scsibus->scsi_msg_r() << 4;
	933	data |= m_scsibus->scsi_cd_r() << 5;
	934	data |= m_scsibus->scsi_req_r() << 6;
	935	data |= m_scsibus->scsi_io_r() << 7;
936	936
937	937	return data;
938	938	}
r18430	r18431
954	954
955	955	*/
956	956
957		//m_scsibus->scsi_atn_w(!BIT(data, 0));
958		m_scsibus->scsi_rst_w(!BIT(data, 1));
959		m_scsibus->scsi_sel_w(!BIT(data, 2));
	957	m_scsibus->scsi_atn_w(BIT(data, 0));
	958	m_scsibus->scsi_rst_w(BIT(data, 1));
	959	m_scsibus->scsi_sel_w(BIT(data, 2));
960	960	}
961	961
962	962	WRITE_LINE_MEMBER( bulletf_state::cstrb_w )
r18430	r18431
1027	1027
1028	1028	WRITE_LINE_MEMBER( bulletf_state::req_w )
1029	1029	{
1030		if (state)
	1030	if (!state)
1031	1031	{
1032		m_scsibus->scsi_ack_w(1);
	1032	m_scsibus->scsi_ack_w(0);
1033	1033
1034	1034	m_wack = 1;
1035	1035	}

trunk/src/mess/drivers/v1050.c

r18430	r18431
349	349	{
350	350	data_out = data;
351	351
352		if( m_sasibus->scsi_io_r() != 0 )
	352	if( !m_sasibus->scsi_io_r() )
353	353	{
354	354	m_sasibus->scsi_data_w( data );
355	355	}
r18430	r18431
357	357
358	358	WRITE_LINE_MEMBER( v1050_state::sasi_io_w )
359	359	{
360		if( state != 0 )
	360	if( !state )
361	361	{
362	362	m_sasibus->scsi_data_w( data_out );
363	363	}
364	364	else
365	365	{
366		m_sasibus->scsi_data_w( 0xff );
	366	m_sasibus->scsi_data_w( 0 );
367	367	}
368	368	}
369	369
r18430	r18431
386	386
387	387	UINT8 data = 0;
388	388
389		data |= m_sasibus->scsi_req_r();
390		data |= !m_sasibus->scsi_bsy_r() << 1;
391		data |= !m_sasibus->scsi_msg_r() << 2;
392		data |= !m_sasibus->scsi_cd_r() << 3;
393		data |= m_sasibus->scsi_io_r() << 4;
	389	data |= !m_sasibus->scsi_req_r();
	390	data |= m_sasibus->scsi_bsy_r() << 1;
	391	data |= m_sasibus->scsi_msg_r() << 2;
	392	data |= m_sasibus->scsi_cd_r() << 3;
	393	data |= !m_sasibus->scsi_io_r() << 4;
394	394
395	395	return data;
396	396	}
397	397
398	398	TIMER_DEVICE_CALLBACK_MEMBER(v1050_state::sasi_ack_tick)
399	399	{
400		m_sasibus->scsi_ack_w(1);
	400	m_sasibus->scsi_ack_w(0);
401	401	}
402	402
403	403	TIMER_DEVICE_CALLBACK_MEMBER(v1050_state::sasi_rst_tick)
404	404	{
405		m_sasibus->scsi_rst_w(1);
	405	m_sasibus->scsi_rst_w(0);
406	406	}
407	407
408	408	WRITE8_MEMBER( v1050_state::sasi_ctrl_w )
r18430	r18431
422	422
423	423	*/
424	424
425		m_sasibus->scsi_sel_w(!BIT(data, 0));
	425	m_sasibus->scsi_sel_w(BIT(data, 0));
426	426
427	427	if (BIT(data, 1))
428	428	{
429	429	// send acknowledge pulse
430		m_sasibus->scsi_ack_w(0);
	430	m_sasibus->scsi_ack_w(1);
431	431
432	432	m_timer_ack->adjust(attotime::from_nsec(100));
433	433	}
r18430	r18431
435	435	if (BIT(data, 7))
436	436	{
437	437	// send reset pulse
438		m_sasibus->scsi_rst_w(0);
	438	m_sasibus->scsi_rst_w(1);
439	439
440	440	m_timer_rst->adjust(attotime::from_nsec(100));
441	441	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team