Previous

199869 Revisions

Next

r17483 Sunday 26th August, 2012 at 14:25:29 UTC by smf
(MESS) converted scsibus from legacy device to c++ (nw)

[src/mess/drivers]	bullet.c v1050.c
[src/mess/includes]	bullet.h rmnimbus.h v1050.h
[src/mess/machine]	d9060.c d9060.h e01.c e01.h lux4105.c lux4105.h rmnimbus.c scsibus.c scsibus.h

trunk/src/mess/machine/scsibus.c

r17482	r17483
1	1	/*
2		SCSIBus.c
	2	SCSIBus.c
3	3
4		Implementation of a raw SCSI/SASI bus for machines that don't use a SCSI
5		controler chip such as the RM Nimbus, which implements it as a bunch of
6		74LS series chips.
	4	Implementation of a raw SCSI/SASI bus for machines that don't use a SCSI
	5	controler chip such as the RM Nimbus, which implements it as a bunch of
	6	74LS series chips.
7	7
8	8	*/
9	9
r17482	r17483
23	23	3   2 + line changes
24	24	*/
25	25
26		#define LOGLEVEL         0
27		#define ENABLE_DATA_DUMP   1
	26	#define LOGLEVEL            0
28	27
29	28	#define LOG(level,...)      if(LOGLEVEL>=level) logerror(__VA_ARGS__)
30	29
31		typedef struct _scsibus_t scsibus_t;
32		struct _scsibus_t
33		{
34		scsidev_device          *devices[8];
35		const SCSIBus_interface *interface;
36
37		devcb_resolved_write_line out_bsy_func;
38		devcb_resolved_write_line out_sel_func;
39		devcb_resolved_write_line out_cd_func;
40		devcb_resolved_write_line out_io_func;
41		devcb_resolved_write_line out_msg_func;
42		devcb_resolved_write_line out_req_func;
43		devcb_resolved_write_line out_rst_func;
44
45		UINT8       linestate;
46		UINT8       last_id;
47		UINT8       phase;
48
49		UINT8       command[CMD_BUF_SIZE];
50		UINT8       cmd_idx;
51		UINT8       is_linked;
52
53		UINT8      status;
54		UINT8      sense;
55
56		UINT8       data[ADAPTEC_BUF_SIZE];
57		UINT16      data_idx;
58		int         xfer_count;
59		int         bytes_left;
60		int         data_last;
61		int         sectorbytes;
62
63		emu_timer   *req_timer;
64		emu_timer   *ack_timer;
65		emu_timer   *sel_timer;
66		emu_timer   *dataout_timer;
67		};
68
69		static void set_scsi_line_now(device_t *device, UINT8 line, UINT8 state);
70		static void set_scsi_line_ack(device_t *device, UINT8 state);
71		static void scsi_in_line_changed(device_t *device, UINT8 line, UINT8 state);
72		static void scsi_out_line_change(device_t *device, UINT8 line, UINT8 state);
73		static void scsi_out_line_change_now(device_t *device, UINT8 line, UINT8 state);
74		static void scsi_out_line_req(device_t *device, UINT8 state);
75		static TIMER_CALLBACK(req_timer_callback);
76		static TIMER_CALLBACK(ack_timer_callback);
77		static TIMER_CALLBACK(sel_timer_callback);
78		static TIMER_CALLBACK(dataout_timer_callback);
79
80		static void scsi_change_phase(device_t *device, UINT8 newphase);
81
82	30	static const char *const linenames[] =
83	31	{
84		"select", "busy", "request", "acknoledge", "C/D", "I/O", "message", "reset"
	32	"select", "busy", "request", "acknoledge", "C/D", "I/O", "message", "reset"
85	33	};
86	34
87	35	static const char *const phasenames[] =
88	36	{
89		"data out", "data in", "command", "status", "none", "none", "message out", "message in", "bus free","select"
	37	"data out", "data in", "command", "status", "none", "none", "message out", "message in", "bus free","select"
90	38	};
91	39
92		INLINE scsibus_t *get_token(device_t *device)
	40	void scsibus_device::dump_bytes(UINT8 *buff, int count)
93	41	{
94		assert(device != NULL);
95		assert(device->type() == SCSIBUS);
	42	int byteno;
96	43
97		return (scsibus_t *) downcast<legacy_device_base *>(device)->token();
	44	for(byteno=0; byteno<count; byteno++)
	45	{
	46	logerror("%02X ",buff[byteno]);
	47	}
98	48	}
99	49
100		static void dump_bytes(UINT8 *buff, int count)
	50	void scsibus_device::dump_command_bytes()
101	51	{
102		int byteno;
103
104		for(byteno=0; byteno<count; byteno++)
105		{
106		logerror("%02X ",buff[byteno]);
107		}
	52	logerror("sending command 0x%02X to ScsiID %d\n",command[0],last_id);
	53	dump_bytes(command,cmd_idx);
	54	logerror("\n\n");
108	55	}
109	56
110		static void dump_command_bytes(scsibus_t   *bus)
	57	void scsibus_device::dump_data_bytes(int count)
111	58	{
112
113		logerror("sending command 0x%02X to ScsiID %d\n",bus->command[0],bus->last_id);
114		dump_bytes(bus->command,bus->cmd_idx);
115		logerror("\n\n");
	59	logerror("Data buffer[0..%d]\n",count);
	60	dump_bytes(buffer,count);
	61	logerror("\n\n");
116	62	}
117	63
118		#if ENABLE_DATA_DUMP
119		static void dump_data_bytes(scsibus_t   *bus, int count)
	64	void scsibus_device::scsibus_read_data()
120	65	{
	66	data_last = (bytes_left >= sectorbytes) ? sectorbytes : bytes_left;
121	67
122		logerror("Data buffer[0..%d]\n",count);
123		dump_bytes(bus->data,count);
124		logerror("\n\n");
125		}
126		#endif
	68	LOG(2,"SCSIBUS:scsibus_read_data bytes_left=%04X, data_last=%04X, xfer_count=%04X\n",bytes_left,data_last,xfer_count);
127	69
128		static void scsibus_read_data(scsibus_t   *bus)
129		{
130		bus->data_last = (bus->bytes_left >= bus->sectorbytes) ? bus->sectorbytes : bus->bytes_left;
131
132		LOG(2,"SCSIBUS:scsibus_read_data bus->bytes_left=%04X, bus->data_last=%04X, bus->xfer_count=%04X\n",bus->bytes_left,bus->data_last,bus->xfer_count);
133
134		if (bus->data_last > 0)
135		{
136		bus->devices[bus->last_id]->ReadData(bus->data, bus->data_last);
137		bus->bytes_left-=bus->data_last;
138		bus->data_idx=0;
139		}
	70	if (data_last > 0)
	71	{
	72	devices[last_id]->ReadData(buffer, data_last);
	73	bytes_left-=data_last;
	74	data_idx=0;
	75	}
140	76	}
141	77
142		static void scsibus_write_data(scsibus_t   *bus)
	78	void scsibus_device::scsibus_write_data()
143	79	{
144		if(bus->bytes_left >= bus->sectorbytes)
145		{
146		bus->devices[bus->last_id]->WriteData(bus->data, bus->sectorbytes);
	80	if(bytes_left >= sectorbytes)
	81	{
	82	devices[last_id]->WriteData(buffer, sectorbytes);
147	83
148		bus->bytes_left-=bus->sectorbytes;
149		bus->data_idx=0;
150		}
	84	bytes_left-=sectorbytes;
	85	data_idx=0;
	86	}
151	87	}
152	88
153	89	/* SCSI Bus read/write */
154	90
155		UINT8 scsi_data_r(device_t *device)
	91	UINT8 scsibus_device::scsi_data_r()
156	92	{
157		scsibus_t   *bus = get_token(device);
158		UINT8       result = 0;
	93	UINT8 result = 0;
159	94
160		switch (bus->phase)
161		{
162		case SCSI_PHASE_DATAIN :
163		result=bus->data[bus->data_idx++];
	95	switch (phase)
	96	{
	97	case SCSI_PHASE_DATAIN:
	98	result=buffer[data_idx++];
164	99
165		// check to see if we have reached the end of the block buffer
166		// and that there is more data to read from the scsi disk
167		if((bus->data_idx==bus->sectorbytes) && (bus->bytes_left>0) && IS_READ_COMMAND())
168		{
169		scsibus_read_data(bus);
170		}
171		break;
	100	// check to see if we have reached the end of the block buffer
	101	// and that there is more data to read from the scsi disk
	102	if((data_idx==sectorbytes) && (bytes_left>0) && IS_READ_COMMAND())
	103	{
	104	scsibus_read_data();
	105	}
	106	break;
172	107
173		case SCSI_PHASE_STATUS :
174		result=bus->status;      // return command status
175		break;
	108	case SCSI_PHASE_STATUS:
	109	result=status; // return command status
	110	break;
176	111
177		case SCSI_PHASE_MESSAGE_IN :
178		result=0;              // no errors for the time being !
179		break;
180		}
	112	case SCSI_PHASE_MESSAGE_IN:
	113	result=0; // no errors for the time being !
	114	break;
	115	}
181	116
182		LOG(2,"scsi_data_r : %02x phase=%s, data_idx=%d, cmd_idx=%d\n",result,phasenames[bus->phase],bus->data_idx,bus->cmd_idx);
183		return result;
	117	LOG(2,"scsi_data_r : %02x phase=%s, data_idx=%d, cmd_idx=%d\n",result,phasenames[phase],data_idx,cmd_idx);
	118	return result;
184	119	}
185	120
186		READ8_DEVICE_HANDLER( scsi_data_r )
	121	READ8_MEMBER( scsibus_device::scsi_data_r )
187	122	{
188		return scsi_data_r(device);
	123	return scsi_data_r();
189	124	}
190	125
191		void scsi_data_w(device_t *device, UINT8 data)
	126	void scsibus_device::scsi_data_w( UINT8 data )
192	127	{
193		scsibus_t   *bus = get_token(device);
	128	switch (phase)
	129	{
	130	// Note this assumes we only have one initiator and therefore
	131	// only one line active.
	132	case SCSI_PHASE_BUS_FREE:
	133	last_id=scsibus_driveno(data);
	134	break;
194	135
195		switch (bus->phase)
196		{
197		// Note this assumes we only have one initiator and therefore
198		// only one line active.
199		case SCSI_PHASE_BUS_FREE :
200		bus->last_id=scsibus_driveno(data);
201		break;
	136	case SCSI_PHASE_COMMAND:
	137	command[cmd_idx++]=data;
	138	break;
202	139
203		case SCSI_PHASE_COMMAND :
204		bus->command[bus->cmd_idx++]=data;
205		break;
	140	case SCSI_PHASE_DATAOUT:
206	141
207		case SCSI_PHASE_DATAOUT :
	142	//LOG(1,"SCSIBUS:xfer_count=%02X, bytes_left=%02X data_idx=%02X\n",xfer_count,bytes_left,data_idx);
208	143
209		//LOG(1,"SCSIBUS:xfer_count=%02X, bytes_left=%02X data_idx=%02X\n",bus->xfer_count,bus->bytes_left,bus->data_idx);
	144	if(IS_COMMAND(SCSI_CMD_FORMAT_UNIT))
	145	{
	146	// Only store the first 4 bytes of the bad block list (the header)
	147	//if(data_idx<4)
	148	buffer[data_idx++]=data;
	149	dump_data_bytes(4);
	150	//else
	151	//   data_idx++;
210	152
211		if(IS_COMMAND(SCSI_CMD_FORMAT_UNIT))
212		{
213		// Only store the first 4 bytes of the bad block list (the header)
214		//if(bus->data_idx<4)
215		bus->data[bus->data_idx++]=data;
216		dump_data_bytes(bus,4);
217		//else
218		//   bus->data_idx++;
219
220	153	// If we have the first byte, then cancel the dataout timout
221		if(bus->data_idx==1)
222		bus->dataout_timer->adjust(attotime::never);
	154	if(data_idx==1)
	155	dataout_timer->adjust(attotime::never);
223	156
224		// When we have the first 3 bytes, calculate how many more are in the
225		// bad block list.
226		if(bus->data_idx==3)
227		{
228		bus->xfer_count+=((bus->data[2]<<8)+bus->data[3]);
229		bus->data_last=bus->xfer_count;
230		LOG(1,"format_unit reading an extra %d bytes\n",bus->xfer_count-4);
231		dump_data_bytes(bus,4);
232		}
233		}
	157	// When we have the first 3 bytes, calculate how many more are in the
	158	// bad block list.
	159	if(data_idx==3)
	160	{
	161	xfer_count+=((buffer[2]<<8)+buffer[3]);
	162	data_last=xfer_count;
	163	LOG(1,"format_unit reading an extra %d bytes\n",xfer_count-4);
	164	dump_data_bytes(4);
	165	}
	166	}
234	167	else
235	168	{
236		bus->data[bus->data_idx++]=data;
	169	buffer[data_idx++]=data;
237	170	}
238	171
239		// If the data buffer is full, and we are writing blocks flush it to the SCSI disk
240		if((bus->data_idx == bus->sectorbytes) && IS_WRITE_COMMAND())
241		scsibus_write_data(bus);
242		break;
243		}
	172	// If the data buffer is full, and we are writing blocks flush it to the SCSI disk
	173	if((data_idx == sectorbytes) && IS_WRITE_COMMAND())
	174	scsibus_write_data();
	175	break;
	176	}
244	177	}
245	178
246		WRITE8_DEVICE_HANDLER( scsi_data_w )
	179	WRITE8_MEMBER( scsibus_device::scsi_data_w )
247	180	{
248		scsi_data_w(device, data);
	181	scsi_data_w( data );
249	182	}
250	183
251	184	/* Get/Set lines */
252	185
253		UINT8 get_scsi_lines(device_t *device)
	186	UINT8 scsibus_device::get_scsi_line(UINT8 lineno)
254	187	{
255		scsibus_t   *bus = get_token(device);
	188	UINT8 result=0;
256	189
257		return bus->linestate;
258		}
	190	switch (lineno)
	191	{
	192	case SCSI_LINE_SEL:   result=(linestate & (1<<SCSI_LINE_SEL)) >> SCSI_LINE_SEL; break;
	193	case SCSI_LINE_BSY:   result=(linestate & (1<<SCSI_LINE_BSY)) >> SCSI_LINE_BSY; break;
	194	case SCSI_LINE_REQ:   result=(linestate & (1<<SCSI_LINE_REQ)) >> SCSI_LINE_REQ; break;
	195	case SCSI_LINE_ACK:   result=(linestate & (1<<SCSI_LINE_ACK)) >> SCSI_LINE_ACK; break;
	196	case SCSI_LINE_CD:    result=(linestate & (1<<SCSI_LINE_CD )) >> SCSI_LINE_CD; break;
	197	case SCSI_LINE_IO:    result=(linestate & (1<<SCSI_LINE_IO )) >> SCSI_LINE_IO; break;
	198	case SCSI_LINE_MSG:   result=(linestate & (1<<SCSI_LINE_MSG)) >> SCSI_LINE_MSG; break;
	199	case SCSI_LINE_RESET: result=(linestate & (1<<SCSI_LINE_RESET)) >> SCSI_LINE_RESET; break;
	200	}
259	201
260		UINT8 get_scsi_line(device_t *device, UINT8 lineno)
261		{
262		scsibus_t   *bus = get_token(device);
263		UINT8       result=0;
	202	LOG(3,"get_scsi_line(%s)=%d\n",linenames[lineno],result);
264	203
265		switch (lineno)
266		{
267		case SCSI_LINE_SEL      : result=(bus->linestate & (1<<SCSI_LINE_SEL)) >> SCSI_LINE_SEL; break;
268		case SCSI_LINE_BSY      : result=(bus->linestate & (1<<SCSI_LINE_BSY)) >> SCSI_LINE_BSY; break;
269		case SCSI_LINE_REQ      : result=(bus->linestate & (1<<SCSI_LINE_REQ)) >> SCSI_LINE_REQ; break;
270		case SCSI_LINE_ACK      : result=(bus->linestate & (1<<SCSI_LINE_ACK)) >> SCSI_LINE_ACK; break;
271		case SCSI_LINE_CD       : result=(bus->linestate & (1<<SCSI_LINE_CD )) >> SCSI_LINE_CD; break;
272		case SCSI_LINE_IO       : result=(bus->linestate & (1<<SCSI_LINE_IO )) >> SCSI_LINE_IO; break;
273		case SCSI_LINE_MSG      : result=(bus->linestate & (1<<SCSI_LINE_MSG)) >> SCSI_LINE_MSG; break;
274		case SCSI_LINE_RESET    : result=(bus->linestate & (1<<SCSI_LINE_RESET)) >> SCSI_LINE_RESET; break;
275		}
276
277		LOG(3,"get_scsi_line(%s)=%d\n",linenames[lineno],result);
278
279		return result;
	204	return result;
280	205	}
281	206
282		READ_LINE_DEVICE_HANDLER( scsi_bsy_r ) { return get_scsi_line(device, SCSI_LINE_BSY); }
283		READ_LINE_DEVICE_HANDLER( scsi_sel_r ) { return get_scsi_line(device, SCSI_LINE_SEL); }
284		READ_LINE_DEVICE_HANDLER( scsi_cd_r ) { return get_scsi_line(device, SCSI_LINE_CD); }
285		READ_LINE_DEVICE_HANDLER( scsi_io_r ) { return get_scsi_line(device, SCSI_LINE_IO); }
286		READ_LINE_DEVICE_HANDLER( scsi_msg_r ) { return get_scsi_line(device, SCSI_LINE_MSG); }
287		READ_LINE_DEVICE_HANDLER( scsi_req_r ) { return get_scsi_line(device, SCSI_LINE_REQ); }
288		READ_LINE_DEVICE_HANDLER( scsi_ack_r ) { return get_scsi_line(device, SCSI_LINE_ACK); }
289		READ_LINE_DEVICE_HANDLER( scsi_rst_r ) { return get_scsi_line(device, SCSI_LINE_RESET); }
	207	READ_LINE_MEMBER( scsibus_device::scsi_bsy_r ) { return get_scsi_line(SCSI_LINE_BSY); }
	208	READ_LINE_MEMBER( scsibus_device::scsi_sel_r ) { return get_scsi_line(SCSI_LINE_SEL); }
	209	READ_LINE_MEMBER( scsibus_device::scsi_cd_r ) { return get_scsi_line(SCSI_LINE_CD); }
	210	READ_LINE_MEMBER( scsibus_device::scsi_io_r ) { return get_scsi_line(SCSI_LINE_IO); }
	211	READ_LINE_MEMBER( scsibus_device::scsi_msg_r ) { return get_scsi_line(SCSI_LINE_MSG); }
	212	READ_LINE_MEMBER( scsibus_device::scsi_req_r ) { return get_scsi_line(SCSI_LINE_REQ); }
	213	READ_LINE_MEMBER( scsibus_device::scsi_ack_r ) { return get_scsi_line(SCSI_LINE_ACK); }
	214	READ_LINE_MEMBER( scsibus_device::scsi_rst_r ) { return get_scsi_line(SCSI_LINE_RESET); }
290	215
291		void set_scsi_line(device_t *device, UINT8 line, UINT8 state)
	216	void scsibus_device::set_scsi_line(UINT8 line, UINT8 state)
292	217	{
293		scsibus_t   *bus = get_token(device);
294		UINT8       changed;
	218	UINT8 changed;
295	219
296		changed = ((bus->linestate & (1<<line)) != (state << line));
	220	changed = ((linestate & (1<<line)) != (state << line));
297	221
298		LOG(3,"set_scsi_line(%s,%d), changed=%d, linestate=%02X\n",linenames[line],state,changed,bus->linestate);
	222	LOG(3,"set_scsi_line(%s,%d), changed=%d, linestate=%02X\n",linenames[line],state,changed,linestate);
299	223
300		if(changed)
301		{
302		if (line==SCSI_LINE_ACK)
303		set_scsi_line_ack(device,state);
304		else
305		set_scsi_line_now(device,line,state);
306		}
	224	if(changed)
	225	{
	226	if (line==SCSI_LINE_ACK)
	227	set_scsi_line_ack(state);
	228	else
	229	set_scsi_line_now(line,state);
	230	}
307	231	}
308	232
309		WRITE_LINE_DEVICE_HANDLER( scsi_bsy_w ) { return set_scsi_line(device, SCSI_LINE_BSY, state); }
310		WRITE_LINE_DEVICE_HANDLER( scsi_sel_w ) { return set_scsi_line(device, SCSI_LINE_SEL, state); }
311		WRITE_LINE_DEVICE_HANDLER( scsi_cd_w ) { return set_scsi_line(device, SCSI_LINE_CD, state); }
312		WRITE_LINE_DEVICE_HANDLER( scsi_io_w ) { return set_scsi_line(device, SCSI_LINE_IO, state); }
313		WRITE_LINE_DEVICE_HANDLER( scsi_msg_w ) { return set_scsi_line(device, SCSI_LINE_MSG, state); }
314		WRITE_LINE_DEVICE_HANDLER( scsi_req_w ) { return set_scsi_line(device, SCSI_LINE_REQ, state); }
315		WRITE_LINE_DEVICE_HANDLER( scsi_ack_w ) { return set_scsi_line(device, SCSI_LINE_ACK, state); }
316		WRITE_LINE_DEVICE_HANDLER( scsi_rst_w ) { return set_scsi_line(device, SCSI_LINE_RESET, state); }
	233	WRITE_LINE_MEMBER( scsibus_device::scsi_bsy_w ) { set_scsi_line(SCSI_LINE_BSY, state); }
	234	WRITE_LINE_MEMBER( scsibus_device::scsi_sel_w ) { set_scsi_line(SCSI_LINE_SEL, state); }
	235	WRITE_LINE_MEMBER( scsibus_device::scsi_cd_w ) { set_scsi_line(SCSI_LINE_CD, state); }
	236	WRITE_LINE_MEMBER( scsibus_device::scsi_io_w ) { set_scsi_line(SCSI_LINE_IO, state); }
	237	WRITE_LINE_MEMBER( scsibus_device::scsi_msg_w ) { set_scsi_line(SCSI_LINE_MSG, state); }
	238	WRITE_LINE_MEMBER( scsibus_device::scsi_req_w ) { set_scsi_line(SCSI_LINE_REQ, state); }
	239	WRITE_LINE_MEMBER( scsibus_device::scsi_ack_w ) { set_scsi_line(SCSI_LINE_ACK, state); }
	240	WRITE_LINE_MEMBER( scsibus_device::scsi_rst_w ) { set_scsi_line(SCSI_LINE_RESET, state); }
317	241
318		static void set_scsi_line_now(device_t *device, UINT8 line, UINT8 state)
	242	void scsibus_device::set_scsi_line_now(UINT8 line, UINT8 state)
319	243	{
320		scsibus_t   *bus = get_token(device);
	244	if(state)
	245	linestate |= (1<<line);
	246	else
	247	linestate &= ~(1<<line);
321	248
322		if(state)
323		bus->linestate |= (1<<line);
324		else
325		bus->linestate &= ~(1<<line);
326
327		scsi_in_line_changed(device,line,state);
	249	scsi_in_line_changed(line,state);
328	250	}
329	251
330		void set_scsi_line_ack(device_t *device, UINT8 state)
	252	void scsibus_device::set_scsi_line_ack(UINT8 state)
331	253	{
332		scsibus_t   *bus = get_token(device);
333
334		bus->ack_timer->adjust(attotime::from_nsec(ACK_DELAY_NS),state);
	254	ack_timer->adjust(attotime::from_nsec(ACK_DELAY_NS),state);
335	255	}
336	256
337		static void scsibus_exec_command(device_t *device)
	257	void scsibus_device::scsibus_exec_command()
338	258	{
339		scsibus_t   *bus = get_token(device);
340		int         command_local = 0;
341		int         newphase;
	259	int command_local = 0;
	260	int newphase;
342	261
343		if(LOGLEVEL)
344		dump_command_bytes(bus);
	262	if(LOGLEVEL)
	263	dump_command_bytes();
345	264
346		//bus->is_linked=bus->command[bus->cmd_idx-1] & 0x01;
347		bus->is_linked=0;
	265	//is_linked=command[cmd_idx-1] & 0x01;
	266	is_linked=0;
348	267
349	268	// Assume command will succeed, if not set sytatus below.
350		if (bus->command[0]!=SCSI_CMD_REQUEST_SENSE)
	269	if (command[0]!=SCSI_CMD_REQUEST_SENSE)
351	270	SET_STATUS_SENSE(SCSI_STATUS_OK,SCSI_SENSE_NO_SENSE);
352	271
353		// Check for locally executed commands, and if found execute them
354		switch (bus->command[0])
355		{
	272	// Check for locally executed commands, and if found execute them
	273	switch (command[0])
	274	{
356	275	// Test ready
357		case SCSI_CMD_TEST_READY :
	276	case SCSI_CMD_TEST_READY:
358	277	LOG(1,"SCSIBUS: test_ready\n");
359		command_local=1;
360		bus->xfer_count=0;
361		bus->data_last=bus->xfer_count;
362		bus->bytes_left=0;
363		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	278	command_local=1;
	279	xfer_count=0;
	280	data_last=xfer_count;
	281	bytes_left=0;
	282	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
364	283	break;
365	284
366	285	// Recalibrate drive
367		case SCSI_CMD_RECALIBRATE :
	286	case SCSI_CMD_RECALIBRATE:
368	287	LOG(1,"SCSIBUS: Recalibrate drive\n");
369		command_local=1;
370		bus->xfer_count=0;
371		bus->data_last=bus->xfer_count;
372		bus->bytes_left=0;
373		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	288	command_local=1;
	289	xfer_count=0;
	290	data_last=xfer_count;
	291	bytes_left=0;
	292	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
374	293	break;
375	294
376	295	// Request sense, return previous error codes
377		case SCSI_CMD_REQUEST_SENSE :
	296	case SCSI_CMD_REQUEST_SENSE:
378	297	LOG(1,"SCSIBUS: request_sense\n");
379		command_local=1;
380		bus->xfer_count=SCSI_SENSE_SIZE;
381		bus->data_last=bus->xfer_count;
382		bus->bytes_left=0;
383		bus->data[0]=bus->sense;
384		bus->data[1]=0x00;
385		bus->data[2]=0x00;
386		bus->data[3]=0x00;
	298	command_local=1;
	299	xfer_count=SCSI_SENSE_SIZE;
	300	data_last=xfer_count;
	301	bytes_left=0;
	302	buffer[0]=sense;
	303	buffer[1]=0x00;
	304	buffer[2]=0x00;
	305	buffer[3]=0x00;
387	306	SET_STATUS_SENSE(SCSI_STATUS_OK,SCSI_SENSE_NO_SENSE);
388		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	307	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
389	308	break;
390	309
391		// Format unit
392		case SCSI_CMD_FORMAT_UNIT :
393		LOG(1,"SCSIBUS: format unit bus->command[1]=%02X & 0x10\n",(bus->command[1] & 0x10));
394		command_local=1;
395		if((bus->command[1] & 0x10)==0x10)
396		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
397		else
398		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	310	// Format unit
	311	case SCSI_CMD_FORMAT_UNIT:
	312	LOG(1,"SCSIBUS: format unit command[1]=%02X & 0x10\n",(command[1] & 0x10));
	313	command_local=1;
	314	if((command[1] & 0x10)==0x10)
	315	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	316	else
	317	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
399	318
400		bus->xfer_count=4;
401		bus->data_last=bus->xfer_count;
402		bus->bytes_left=0;
403		bus->dataout_timer->adjust(attotime::from_seconds(FORMAT_UNIT_TIMEOUT));
404		break;
	319	xfer_count=4;
	320	data_last=xfer_count;
	321	bytes_left=0;
	322	dataout_timer->adjust(attotime::from_seconds(FORMAT_UNIT_TIMEOUT));
	323	break;
405	324
406	325	// Check track format Xebec
407		case SCSI_CMD_CHECK_TRACK_FORMAT :
	326	case SCSI_CMD_CHECK_TRACK_FORMAT:
408	327	LOG(1,"SCSIBUS: check track format\n");
409		command_local=1;
410		bus->xfer_count=0;
411		bus->data_last=bus->xfer_count;
412		bus->bytes_left=0;
413		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	328	command_local=1;
	329	xfer_count=0;
	330	data_last=xfer_count;
	331	bytes_left=0;
	332	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
414	333	break;
415	334
416	335	// Setup drive parameters Xebec
417		case SCSI_CMD_INIT_DRIVE_PARAMS :
	336	case SCSI_CMD_INIT_DRIVE_PARAMS:
418	337	LOG(1,"SCSIBUS: init_drive_params: Xebec S1410\n");
419		command_local=1;
420		bus->xfer_count=XEBEC_PARAMS_SIZE;
421		bus->data_last=bus->xfer_count;
422		bus->bytes_left=0;
423		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
424		break;
	338	command_local=1;
	339	xfer_count=XEBEC_PARAMS_SIZE;
	340	data_last=xfer_count;
	341	bytes_left=0;
	342	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	343	break;
425	344
426	345	// Format bad track Xebec
427		case SCSI_CMD_FORMAT_ALT_TRACK :
	346	case SCSI_CMD_FORMAT_ALT_TRACK:
428	347	LOG(1,"SCSIBUS: format_alt_track: Xebec S1410\n");
429		command_local=1;
430		bus->xfer_count=XEBEC_ALT_TRACK_SIZE;
431		bus->data_last=bus->xfer_count;
432		bus->bytes_left=0;
433		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
434		break;
	348	command_local=1;
	349	xfer_count=XEBEC_ALT_TRACK_SIZE;
	350	data_last=xfer_count;
	351	bytes_left=0;
	352	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	353	break;
435	354
436	355	// Write buffer Xebec S1410 specific
437		case SCSI_CMD_WRITE_SEC_BUFFER :
	356	case SCSI_CMD_WRITE_SEC_BUFFER:
438	357	LOG(1,"SCSIBUS: write_sector_buffer: Xebec S1410\n");
439		command_local=1;
440		bus->xfer_count=XEBEC_SECTOR_BUFFER_SIZE;
441		bus->data_last=bus->xfer_count;
442		bus->bytes_left=0;
443		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
444		break;
	358	command_local=1;
	359	xfer_count=XEBEC_SECTOR_BUFFER_SIZE;
	360	data_last=xfer_count;
	361	bytes_left=0;
	362	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	363	break;
445	364
446	365	// Read buffer Xebec S1410 specific
447		case SCSI_CMD_READ_SEC_BUFFER :
448		LOG(1,"SCSIBUS: read_sector_buffer: Xebec S1410\n");
449		command_local=1;
450		bus->xfer_count=XEBEC_SECTOR_BUFFER_SIZE;
451		bus->data_last=bus->xfer_count;
452		bus->bytes_left=0;
453		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAIN);
454		break;
	366	case SCSI_CMD_READ_SEC_BUFFER:
	367	LOG(1,"SCSIBUS: read_sector_buffer: Xebec S1410\n");
	368	command_local=1;
	369	xfer_count=XEBEC_SECTOR_BUFFER_SIZE;
	370	data_last=xfer_count;
	371	bytes_left=0;
	372	devices[last_id]->SetPhase(SCSI_PHASE_DATAIN);
	373	break;
455	374
456	375	// Write buffer, Adaptec ACB40x0 specific
457		case SCSI_CMD_WRITE_DATA_BUFFER :
	376	case SCSI_CMD_WRITE_DATA_BUFFER:
458	377	LOG(1,"SCSIBUS: write_buffer: Adaptec ACB40x0\n");
459		command_local=1;
460		bus->xfer_count=ADAPTEC_DATA_BUFFER_SIZE;
461		bus->data_last=bus->xfer_count;
462		bus->bytes_left=0;
463		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
464		break;
	378	command_local=1;
	379	xfer_count=ADAPTEC_DATA_BUFFER_SIZE;
	380	data_last=xfer_count;
	381	bytes_left=0;
	382	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	383	break;
465	384
466	385	// Read buffer, Adaptec ACB40x0 specific
467		case SCSI_CMD_READ_DATA_BUFFER :
468		LOG(1,"SCSIBUS: read_data_buffer: Adaptec ACB40x0\n");
469		command_local=1;
470		bus->xfer_count=ADAPTEC_DATA_BUFFER_SIZE;
471		bus->data_last=bus->xfer_count;
472		bus->bytes_left=0;
473		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAIN);
474		break;
	386	case SCSI_CMD_READ_DATA_BUFFER:
	387	LOG(1,"SCSIBUS: read_data_buffer: Adaptec ACB40x0\n");
	388	command_local=1;
	389	xfer_count=ADAPTEC_DATA_BUFFER_SIZE;
	390	data_last=xfer_count;
	391	bytes_left=0;
	392	devices[last_id]->SetPhase(SCSI_PHASE_DATAIN);
	393	break;
475	394
476	395	// Send diagnostic info
477		case SCSI_CMD_SEND_DIAGNOSTIC :
478		LOG(1,"SCSIBUS: send_diagnostic\n");
479		command_local=1;
480		bus->xfer_count=(bus->command[3]<<8)+bus->command[4];
481		bus->data_last=bus->xfer_count;
482		bus->bytes_left=0;
483		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
484		break;
	396	case SCSI_CMD_SEND_DIAGNOSTIC:
	397	LOG(1,"SCSIBUS: send_diagnostic\n");
	398	command_local=1;
	399	xfer_count=(command[3]<<8)+command[4];
	400	data_last=xfer_count;
	401	bytes_left=0;
	402	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	403	break;
485	404
486		case SCSI_CMD_SEARCH_DATA_EQUAL :
487		LOG(1,"SCSIBUS: Search_data_equal ACB40x0\n");
488		command_local=1;
489		bus->xfer_count=0;
490		bus->data_last=bus->xfer_count;
491		bus->bytes_left=0;
492		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	405	case SCSI_CMD_SEARCH_DATA_EQUAL:
	406	LOG(1,"SCSIBUS: Search_data_equal ACB40x0\n");
	407	command_local=1;
	408	xfer_count=0;
	409	data_last=xfer_count;
	410	bytes_left=0;
	411	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
493	412	break;
494	413
495		case SCSI_CMD_READ_DEFECT :
496		LOG(1,"SCSIBUS: read defect list\n");
497		command_local=1;
	414	case SCSI_CMD_READ_DEFECT:
	415	LOG(1,"SCSIBUS: read defect list\n");
	416	command_local=1;
498	417
499		bus->data[0] = 0x00;
500		bus->data[1] = bus->command[2];
501		bus->data[3] = 0x00;         // defect list len msb
502		bus->data[4] = 0x00;         // defect list len lsb
	418	buffer[0] = 0x00;
	419	buffer[1] = command[2];
	420	buffer[3] = 0x00; // defect list len msb
	421	buffer[4] = 0x00; // defect list len lsb
503	422
504		bus->xfer_count=4;
505		bus->data_last=bus->xfer_count;
506		bus->bytes_left=0;
507		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAIN);
508		break;
	423	xfer_count=4;
	424	data_last=xfer_count;
	425	bytes_left=0;
	426	devices[last_id]->SetPhase(SCSI_PHASE_DATAIN);
	427	break;
509	428
510		// write buffer
511		case SCSI_CMD_BUFFER_WRITE :
512		LOG(1,"SCSIBUS: write_buffer\n");
513		command_local=1;
514		bus->xfer_count=(bus->command[7]<<8)+bus->command[8];
515		bus->data_last=bus->xfer_count;
516		bus->bytes_left=0;
517		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAOUT);
518		break;
	429	// write buffer
	430	case SCSI_CMD_BUFFER_WRITE:
	431	LOG(1,"SCSIBUS: write_buffer\n");
	432	command_local=1;
	433	xfer_count=(command[7]<<8)+command[8];
	434	data_last=xfer_count;
	435	bytes_left=0;
	436	devices[last_id]->SetPhase(SCSI_PHASE_DATAOUT);
	437	break;
519	438
520		// read buffer
521		case SCSI_CMD_BUFFER_READ   :
522		LOG(1,"SCSIBUS: read_buffer\n");
523		command_local=1;
524		bus->xfer_count=(bus->command[7]<<8)+bus->command[8];
525		bus->data_last=bus->xfer_count;
526		bus->bytes_left=0;
527		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_DATAIN);
528		break;
	439	// read buffer
	440	case SCSI_CMD_BUFFER_READ:
	441	LOG(1,"SCSIBUS: read_buffer\n");
	442	command_local=1;
	443	xfer_count=(command[7]<<8)+command[8];
	444	data_last=xfer_count;
	445	bytes_left=0;
	446	devices[last_id]->SetPhase(SCSI_PHASE_DATAIN);
	447	break;
529	448
530	449	// Xebec S1410
531		case SCSI_CMD_RAM_DIAGS :
532		case SCSI_CMD_DRIVE_DIAGS :
533		case SCSI_CMD_CONTROLER_DIAGS :
534		LOG(1,"SCSIBUS: Xebec RAM, disk or Controler diags [%02X]\n",bus->command[0]);
535		command_local=1;
536		bus->xfer_count=0;
537		bus->data_last=bus->xfer_count;
538		bus->bytes_left=0;
539		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	450	case SCSI_CMD_RAM_DIAGS:
	451	case SCSI_CMD_DRIVE_DIAGS:
	452	case SCSI_CMD_CONTROLER_DIAGS:
	453	LOG(1,"SCSIBUS: Xebec RAM, disk or Controler diags [%02X]\n",command[0]);
	454	command_local=1;
	455	xfer_count=0;
	456	data_last=xfer_count;
	457	bytes_left=0;
	458	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
540	459	break;
541	460
542	461	// Commodore D9060/9090
543		case SCSI_CMD_PHYSICAL_DEVICE_ID :
	462	case SCSI_CMD_PHYSICAL_DEVICE_ID:
544	463	LOG(1,"SCSIBUS: physical device ID\n");
545		command_local=1;
546		bus->xfer_count=0;
547		bus->data_last=bus->xfer_count;
548		bus->bytes_left=0;
549		bus->devices[bus->last_id]->SetPhase(SCSI_PHASE_STATUS);
	464	command_local=1;
	465	xfer_count=0;
	466	data_last=xfer_count;
	467	bytes_left=0;
	468	devices[last_id]->SetPhase(SCSI_PHASE_STATUS);
550	469	break;
551	470	}
552	471
553	472
554		// Check for locally executed command, if not then pass it on
555		// to the disk driver
556		if(!command_local)
557		{
558		bus->devices[bus->last_id]->SetCommand(bus->command, bus->cmd_idx);
559		bus->devices[bus->last_id]->ExecCommand(&bus->xfer_count);
560		bus->bytes_left=bus->xfer_count;
561		bus->data_last=bus->xfer_count;
562		bus->data_idx=0;
563		}
	473	// Check for locally executed command, if not then pass it on
	474	// to the disk driver
	475	if(!command_local)
	476	{
	477	devices[last_id]->SetCommand(command, cmd_idx);
	478	devices[last_id]->ExecCommand(&xfer_count);
	479	bytes_left=xfer_count;
	480	data_last=xfer_count;
	481	data_idx=0;
	482	}
564	483
565		bus->devices[bus->last_id]->GetPhase(&newphase);
	484	devices[last_id]->GetPhase(&newphase);
566	485
567		scsi_change_phase(device,newphase);
	486	scsi_change_phase(newphase);
568	487
569		LOG(1,"SCSIBUS:xfer_count=%02X, bytes_left=%02X data_idx=%02X\n",bus->xfer_count,bus->bytes_left,bus->data_idx);
	488	LOG(1,"SCSIBUS:xfer_count=%02X, bytes_left=%02X data_idx=%02X\n",xfer_count,bytes_left,data_idx);
570	489
571		// This is correct as we need to read from disk for commands other than just read data
572		if ((bus->phase == SCSI_PHASE_DATAIN) && (!command_local))
573		scsibus_read_data(bus);
	490	// This is correct as we need to read from disk for commands other than just read data
	491	if ((phase == SCSI_PHASE_DATAIN) && (!command_local))
	492	scsibus_read_data();
574	493	}
575	494
576		static int datain_done(scsibus_t   *bus)
	495	int scsibus_device::datain_done()
577	496	{
578		int result=0;
	497	int result=0;
579	498
580		// Read data commands
581		if(IS_READ_COMMAND() && (bus->data_idx == bus->data_last) && (bus->bytes_left == 0))
582		result=1;
583		else if (bus->data_idx==bus->data_last)
584		result=1;
	499	// Read data commands
	500	if(IS_READ_COMMAND() && (data_idx == data_last) && (bytes_left == 0))
	501	result=1;
	502	else if (data_idx==data_last)
	503	result=1;
585	504
586		return result;
	505	return result;
587	506	}
588	507
589		static int dataout_done(scsibus_t   *bus)
	508	int scsibus_device::dataout_done()
590	509	{
591		int result=0;
	510	int result=0;
592	511
593		// Write data commands
594		if(IS_WRITE_COMMAND() && (bus->data_idx == 0) && (bus->bytes_left == 0))
595		result=1;
596		else if (bus->data_idx==bus->data_last)
597		result=1;
	512	// Write data commands
	513	if(IS_WRITE_COMMAND() && (data_idx == 0) && (bytes_left == 0))
	514	result=1;
	515	else if (data_idx==data_last)
	516	result=1;
598	517
599		return result;
	518	return result;
600	519	}
601	520
602		static void check_process_dataout(device_t *device)
	521	void scsibus_device::check_process_dataout()
603	522	{
604		scsibus_t      *bus = get_token(device);
605		int            capacity=0;
606		int            tracks;
607		adaptec_sense_t   *sense;
	523	int capacity=0;
	524	int tracks;
	525	adaptec_sense_t *sense;
608	526
609		LOG(1,"SCSIBUS:check_process_dataout cmd=%02X\n",bus->command[0]);
	527	LOG(1,"SCSIBUS:check_process_dataout cmd=%02X\n",command[0]);
610	528
611		switch (bus->command[0])
	529	switch (command[0])
612	530	{
613		case SCSI_CMD_INIT_DRIVE_PARAMS :
614		tracks=((bus->data[0]<<8)+bus->data[1]);
615		capacity=(tracks * bus->data[2]) * 17;
616		LOG(1,"Tracks=%d, Heads=%d\n",tracks,bus->data[2]);
	531	case SCSI_CMD_INIT_DRIVE_PARAMS:
	532	tracks=((buffer[0]<<8)+buffer[1]);
	533	capacity=(tracks * buffer[2]) * 17;
	534	LOG(1,"Tracks=%d, Heads=%d\n",tracks,buffer[2]);
617	535	LOG(1,"Setting disk capacity to %d blocks\n",capacity);
618	536	//debugger_break(device->machine());
619	537	break;
620	538
621		case SCSI_CMD_MODE_SELECT :
622		sense=(adaptec_sense_t *)bus->data;
	539	case SCSI_CMD_MODE_SELECT:
	540	sense=(adaptec_sense_t *)buffer;
623	541	tracks=(sense->cylinder_count[0]<<8)+sense->cylinder_count[1];
624	542	capacity=(tracks * sense->head_count * 17);
625	543	LOG(1,"Tracks=%d, Heads=%d sec/track=%d\n",tracks,sense->head_count,sense->sectors_per_track);
626	544	LOG(1,"Setting disk capacity to %d blocks\n",capacity);
627		dump_data_bytes(bus,0x16);
	545	dump_data_bytes(0x16);
628	546	//debugger_break(device->machine());
629	547	break;
630	548	}
631	549	}
632	550
633	551
634		static void scsi_in_line_changed(device_t *device, UINT8 line, UINT8 state)
	552	void scsibus_device::scsi_in_line_changed(UINT8 line, UINT8 state)
635	553	{
636		scsibus_t   *bus = get_token(device);
637		void      *hdfile;
	554	void *hdfile;
638	555
639		// Reset aborts and returns to bus free
640		if((line==SCSI_LINE_RESET) && (state==0))
641		{
642		scsi_change_phase(device,SCSI_PHASE_BUS_FREE);
643		bus->cmd_idx=0;
644		bus->data_idx=0;
645		bus->is_linked=0;
	556	// Reset aborts and returns to bus free
	557	if((line==SCSI_LINE_RESET) && (state==0))
	558	{
	559	scsi_change_phase(SCSI_PHASE_BUS_FREE);
	560	cmd_idx=0;
	561	data_idx=0;
	562	is_linked=0;
646	563
647		return;
648		}
	564	return;
	565	}
649	566
650		switch (bus->phase)
651		{
652		case SCSI_PHASE_BUS_FREE :
653		if((line==SCSI_LINE_SEL) && (bus->devices[bus->last_id]!=NULL))
654		{
	567	switch (phase)
	568	{
	569	case SCSI_PHASE_BUS_FREE:
	570	if((line==SCSI_LINE_SEL) && (devices[last_id]!=NULL))
	571	{
655	572	// Check to see if device had image file mounted, if not, do not set busy,
656	573	// and stay busfree.
657		bus->devices[bus->last_id]->GetDevice(&hdfile);
	574	devices[last_id]->GetDevice(&hdfile);
658	575	if(hdfile!=(void *)NULL)
659	576	{
660	577	if(state==0)
661		bus->sel_timer->adjust(attotime::from_nsec(BSY_DELAY_NS));
	578	sel_timer->adjust(attotime::from_nsec(BSY_DELAY_NS));
662	579	else
663		scsi_change_phase(device,SCSI_PHASE_COMMAND);
	580	scsi_change_phase(SCSI_PHASE_COMMAND);
664	581	}
665		}
666		break;
	582	}
	583	break;
667	584
668		case SCSI_PHASE_COMMAND :
669		if(line==SCSI_LINE_ACK)
670		{
671		if(state)
672		{
673		// If the command is ready go and execute it
674		if(bus->cmd_idx==get_scsi_cmd_len(bus->command[0]))
675		{
676		scsibus_exec_command(device);
677		}
678		else
679		scsi_out_line_change(device,SCSI_LINE_REQ,0);
680		}
681		else
682		scsi_out_line_change(device,SCSI_LINE_REQ,1);
683		}
684		break;
	585	case SCSI_PHASE_COMMAND:
	586	if(line==SCSI_LINE_ACK)
	587	{
	588	if(state)
	589	{
	590	// If the command is ready go and execute it
	591	if(cmd_idx==get_scsi_cmd_len(command[0]))
	592	{
	593	scsibus_exec_command();
	594	}
	595	else
	596	scsi_out_line_change(SCSI_LINE_REQ,0);
	597	}
	598	else
	599	scsi_out_line_change(SCSI_LINE_REQ,1);
	600	}
	601	break;
685	602
686		case SCSI_PHASE_DATAIN :
687		if(line==SCSI_LINE_ACK)
688		{
689		if(state)
690		{
691		if(datain_done(bus))
692		scsi_change_phase(device,SCSI_PHASE_STATUS);
693		else
694		scsi_out_line_change(device,SCSI_LINE_REQ,0);
695		}
696		else
697		scsi_out_line_change(device,SCSI_LINE_REQ,1);
698		}
699		break;
	603	case SCSI_PHASE_DATAIN:
	604	if(line==SCSI_LINE_ACK)
	605	{
	606	if(state)
	607	{
	608	if(datain_done())
	609	scsi_change_phase(SCSI_PHASE_STATUS);
	610	else
	611	scsi_out_line_change(SCSI_LINE_REQ,0);
	612	}
	613	else
	614	scsi_out_line_change(SCSI_LINE_REQ,1);
	615	}
	616	break;
700	617
701		case SCSI_PHASE_DATAOUT :
702		if(line==SCSI_LINE_ACK)
703		{
704		if(state)
705		{
706		if(dataout_done(bus))
	618	case SCSI_PHASE_DATAOUT:
	619	if(line==SCSI_LINE_ACK)
	620	{
	621	if(state)
	622	{
	623	if(dataout_done())
707	624	{
708		check_process_dataout(device);
709		scsi_change_phase(device,SCSI_PHASE_STATUS);
	625	check_process_dataout();
	626	scsi_change_phase(SCSI_PHASE_STATUS);
710	627	}
711		else
712		scsi_out_line_change(device,SCSI_LINE_REQ,0);
713		}
714		else
715		scsi_out_line_change(device,SCSI_LINE_REQ,1);
716		}
717		break;
	628	else
	629	scsi_out_line_change(SCSI_LINE_REQ,0);
	630	}
	631	else
	632	scsi_out_line_change(SCSI_LINE_REQ,1);
	633	}
	634	break;
718	635
719		case SCSI_PHASE_STATUS :
720		if(line==SCSI_LINE_ACK)
721		{
722		if(state)
723		{
724		if(bus->cmd_idx > 0)
725		{
726		scsi_change_phase(device,SCSI_PHASE_MESSAGE_IN);
727		}
728		else
729		scsi_out_line_change(device,SCSI_LINE_REQ,0);
730		}
	636	case SCSI_PHASE_STATUS:
	637	if(line==SCSI_LINE_ACK)
	638	{
	639	if(state)
	640	{
	641	if(cmd_idx > 0)
	642	{
	643	scsi_change_phase(SCSI_PHASE_MESSAGE_IN);
	644	}
	645	else
	646	scsi_out_line_change(SCSI_LINE_REQ,0);
	647	}
731	648	else
732	649	{
733		bus->cmd_idx++;
734		scsi_out_line_change(device,SCSI_LINE_REQ,1);
	650	cmd_idx++;
	651	scsi_out_line_change(SCSI_LINE_REQ,1);
735	652	}
736		}
737		break;
	653	}
	654	break;
738	655
739		case SCSI_PHASE_MESSAGE_IN :
740		if(line==SCSI_LINE_ACK)
741		{
742		if(state)
743		{
744		if(bus->cmd_idx > 0)
745		{
746		if(bus->is_linked)
747		scsi_change_phase(device,SCSI_PHASE_COMMAND);
748		else
749		scsi_change_phase(device,SCSI_PHASE_BUS_FREE);
750		}
751		else
752		scsi_out_line_change(device,SCSI_LINE_REQ,0);
753		}
754		else
	656	case SCSI_PHASE_MESSAGE_IN:
	657	if(line==SCSI_LINE_ACK)
	658	{
	659	if(state)
755	660	{
756		bus->cmd_idx++;
757		scsi_out_line_change(device,SCSI_LINE_REQ,1);
	661	if(cmd_idx > 0)
	662	{
	663	if(is_linked)
	664	scsi_change_phase(SCSI_PHASE_COMMAND);
	665	else
	666	scsi_change_phase(SCSI_PHASE_BUS_FREE);
	667	}
	668	else
	669	scsi_out_line_change(SCSI_LINE_REQ,0);
758	670	}
759		}
760		break;
761		}
	671	else
	672	{
	673	cmd_idx++;
	674	scsi_out_line_change(SCSI_LINE_REQ,1);
	675	}
	676	}
	677	break;
	678	}
762	679	}
763	680
764		static void scsi_out_line_change(device_t *device, UINT8 line, UINT8 state)
	681	void scsibus_device::scsi_out_line_change(UINT8 line, UINT8 state)
765	682	{
766		if(line==SCSI_LINE_REQ)
767		scsi_out_line_req(device,state);
768		else
769		scsi_out_line_change_now(device,line,state);
	683	if(line==SCSI_LINE_REQ)
	684	scsi_out_line_req(state);
	685	else
	686	scsi_out_line_change_now(line,state);
770	687	}
771	688
772		static void scsi_out_line_change_now(device_t *device, UINT8 line, UINT8 state)
	689	void scsibus_device::scsi_out_line_change_now(UINT8 line, UINT8 state)
773	690	{
774		scsibus_t   *bus = get_token(device);
	691	if(state)
	692	linestate |= (1<<line);
	693	else
	694	linestate &= ~(1<<line);
775	695
776		if(state)
777		bus->linestate |= (1<<line);
778		else
779		bus->linestate &= ~(1<<line);
	696	LOG(3,"scsi_out_line_change(%s,%d)\n",linenames[line],state);
780	697
781		LOG(3,"scsi_out_line_change(%s,%d)\n",linenames[line],state);
	698	if(line_change_cb!=NULL)
	699	line_change_cb(line,state);
782	700
783		if(bus->interface->line_change_cb!=NULL)
784		bus->interface->line_change_cb(device,line,state);
785
786	701	switch (line)
787	702	{
788		case SCSI_LINE_BSY: bus->out_bsy_func(state); break;
789		case SCSI_LINE_SEL: bus->out_sel_func(state); break;
790		case SCSI_LINE_CD: bus->out_cd_func(state); break;
791		case SCSI_LINE_IO: bus->out_io_func(state); break;
792		case SCSI_LINE_MSG: bus->out_msg_func(state); break;
793		case SCSI_LINE_REQ: bus->out_req_func(state); break;
794		case SCSI_LINE_RESET: bus->out_rst_func(state); break;
	703	case SCSI_LINE_BSY: out_bsy_func(state); break;
	704	case SCSI_LINE_SEL: out_sel_func(state); break;
	705	case SCSI_LINE_CD: out_cd_func(state); break;
	706	case SCSI_LINE_IO: out_io_func(state); break;
	707	case SCSI_LINE_MSG: out_msg_func(state); break;
	708	case SCSI_LINE_REQ: out_req_func(state); break;
	709	case SCSI_LINE_RESET: out_rst_func(state); break;
795	710	}
796	711	}
797	712
798		static void scsi_out_line_req(device_t *device, UINT8 state)
	713	void scsibus_device::scsi_out_line_req(UINT8 state)
799	714	{
800		scsibus_t   *bus = get_token(device);
801
802		bus->req_timer->adjust(attotime::from_nsec(REQ_DELAY_NS),state);
	715	req_timer->adjust(attotime::from_nsec(REQ_DELAY_NS),state);
803	716	}
804	717
805
806		static TIMER_CALLBACK(req_timer_callback)
	718	void scsibus_device::device_timer(emu_timer &timer, device_timer_id tid, int param, void *ptr)
807	719	{
808		scsi_out_line_change_now((device_t *)ptr, SCSI_LINE_REQ, param);
809		}
	720	switch( tid )
	721	{
	722	case 0:
	723	scsi_out_line_change_now(SCSI_LINE_REQ, param);
	724	break;
810	725
811		static TIMER_CALLBACK(ack_timer_callback)
812		{
813		set_scsi_line_now((device_t *)ptr, SCSI_LINE_ACK, param);
814		}
	726	case 1:
	727	set_scsi_line_now(SCSI_LINE_ACK, param);
	728	break;
815	729
816		static TIMER_CALLBACK(sel_timer_callback)
817		{
818		scsi_out_line_change_now((device_t *)ptr, SCSI_LINE_BSY, param);
819		}
	730	case 2:
	731	scsi_out_line_change_now(SCSI_LINE_BSY, param);
	732	break;
820	733
821		static TIMER_CALLBACK(dataout_timer_callback)
822		{
823		scsibus_t   *bus = get_token((device_t *)ptr);
824
825		// Some drives, notably the ST225N and ST125N, accept fromat unit commands
826		// with flags set indicating that bad block data should be transfered but
827		// don't then implemnt a data in phase, this timeout it to catch these !
828		if(IS_COMMAND(SCSI_CMD_FORMAT_UNIT) && (bus->data_idx==0))
829		scsi_change_phase((device_t *)ptr,SCSI_PHASE_STATUS);
830
	734	case 3:
	735	// Some drives, notably the ST225N and ST125N, accept fromat unit commands
	736	// with flags set indicating that bad block data should be transfered but
	737	// don't then implemnt a data in phase, this timeout it to catch these !
	738	if(IS_COMMAND(SCSI_CMD_FORMAT_UNIT) && (data_idx==0))
	739	scsi_change_phase(SCSI_PHASE_STATUS);
	740	break;
	741	}
831	742	}
832	743
833		UINT8 get_scsi_phase(device_t *device)
	744	void scsibus_device::scsi_change_phase(UINT8 newphase)
834	745	{
835		scsibus_t   *bus = get_token(device);
	746	LOG(1,"scsi_change_phase() from=%s, to=%s\n",phasenames[phase],phasenames[newphase]);
836	747
837		return bus->phase;
838		}
	748	phase=newphase;
	749	cmd_idx=0;
	750	data_idx=0;
839	751
840
841		static void scsi_change_phase(device_t *device, UINT8 newphase)
842		{
843		scsibus_t   *bus = get_token(device);
844
845		LOG(1,"scsi_change_phase() from=%s, to=%s\n",phasenames[bus->phase],phasenames[newphase]);
846
847		bus->phase=newphase;
848		bus->cmd_idx=0;
849		bus->data_idx=0;
850
851		switch(bus->phase)
852		{
853		case SCSI_PHASE_BUS_FREE :
854		scsi_out_line_change(device,SCSI_LINE_CD,1);
855		scsi_out_line_change(device,SCSI_LINE_IO,1);
856		scsi_out_line_change(device,SCSI_LINE_MSG,1);
857		scsi_out_line_change(device,SCSI_LINE_REQ,1);
858		scsi_out_line_change(device,SCSI_LINE_BSY,1);
	752	switch(phase)
	753	{
	754	case SCSI_PHASE_BUS_FREE:
	755	scsi_out_line_change(SCSI_LINE_CD,1);
	756	scsi_out_line_change(SCSI_LINE_IO,1);
	757	scsi_out_line_change(SCSI_LINE_MSG,1);
	758	scsi_out_line_change(SCSI_LINE_REQ,1);
	759	scsi_out_line_change(SCSI_LINE_BSY,1);
859	760	LOG(1,"SCSIBUS: done\n\n");
860	761	//if (IS_COMMAND(SCSI_CMD_READ_CAPACITY))
861	762	//  debugger_break(device->machine());
862		break;
	763	break;
863	764
864		case SCSI_PHASE_COMMAND :
865		scsi_out_line_change(device,SCSI_LINE_CD,0);
866		scsi_out_line_change(device,SCSI_LINE_IO,1);
867		scsi_out_line_change(device,SCSI_LINE_MSG,1);
868		scsi_out_line_change(device,SCSI_LINE_REQ,0);
	765	case SCSI_PHASE_COMMAND:
	766	scsi_out_line_change(SCSI_LINE_CD,0);
	767	scsi_out_line_change(SCSI_LINE_IO,1);
	768	scsi_out_line_change(SCSI_LINE_MSG,1);
	769	scsi_out_line_change(SCSI_LINE_REQ,0);
869	770	LOG(1,"\nSCSIBUS: Command begin\n");
870		break;
	771	break;
871	772
872		case SCSI_PHASE_DATAOUT :
873		scsi_out_line_change(device,SCSI_LINE_CD,1);
874		scsi_out_line_change(device,SCSI_LINE_IO,1);
875		scsi_out_line_change(device,SCSI_LINE_MSG,1);
876		scsi_out_line_change(device,SCSI_LINE_REQ,0);
877		break;
	773	case SCSI_PHASE_DATAOUT:
	774	scsi_out_line_change(SCSI_LINE_CD,1);
	775	scsi_out_line_change(SCSI_LINE_IO,1);
	776	scsi_out_line_change(SCSI_LINE_MSG,1);
	777	scsi_out_line_change(SCSI_LINE_REQ,0);
	778	break;
878	779
879		case SCSI_PHASE_DATAIN :
880		scsi_out_line_change(device,SCSI_LINE_CD,1);
881		scsi_out_line_change(device,SCSI_LINE_IO,0);
882		scsi_out_line_change(device,SCSI_LINE_MSG,1);
883		scsi_out_line_change(device,SCSI_LINE_REQ,0);
884		break;
	780	case SCSI_PHASE_DATAIN:
	781	scsi_out_line_change(SCSI_LINE_CD,1);
	782	scsi_out_line_change(SCSI_LINE_IO,0);
	783	scsi_out_line_change(SCSI_LINE_MSG,1);
	784	scsi_out_line_change(SCSI_LINE_REQ,0);
	785	break;
885	786
886		case SCSI_PHASE_STATUS :
887		scsi_out_line_change(device,SCSI_LINE_CD,0);
888		scsi_out_line_change(device,SCSI_LINE_IO,0);
889		scsi_out_line_change(device,SCSI_LINE_MSG,1);
890		scsi_out_line_change(device,SCSI_LINE_REQ,0);
891		break;
	787	case SCSI_PHASE_STATUS:
	788	scsi_out_line_change(SCSI_LINE_CD,0);
	789	scsi_out_line_change(SCSI_LINE_IO,0);
	790	scsi_out_line_change(SCSI_LINE_MSG,1);
	791	scsi_out_line_change(SCSI_LINE_REQ,0);
	792	break;
892	793
893		case SCSI_PHASE_MESSAGE_OUT :
894		scsi_out_line_change(device,SCSI_LINE_CD,0);
895		scsi_out_line_change(device,SCSI_LINE_IO,1);
896		scsi_out_line_change(device,SCSI_LINE_MSG,0);
897		scsi_out_line_change(device,SCSI_LINE_REQ,0);
898		break;
	794	case SCSI_PHASE_MESSAGE_OUT:
	795	scsi_out_line_change(SCSI_LINE_CD,0);
	796	scsi_out_line_change(SCSI_LINE_IO,1);
	797	scsi_out_line_change(SCSI_LINE_MSG,0);
	798	scsi_out_line_change(SCSI_LINE_REQ,0);
	799	break;
899	800
900		case SCSI_PHASE_MESSAGE_IN :
901		scsi_out_line_change(device,SCSI_LINE_CD,0);
902		scsi_out_line_change(device,SCSI_LINE_IO,0);
903		scsi_out_line_change(device,SCSI_LINE_MSG,0);
904		scsi_out_line_change(device,SCSI_LINE_REQ,0);
905		break;
906		}
	801	case SCSI_PHASE_MESSAGE_IN:
	802	scsi_out_line_change(SCSI_LINE_CD,0);
	803	scsi_out_line_change(SCSI_LINE_IO,0);
	804	scsi_out_line_change(SCSI_LINE_MSG,0);
	805	scsi_out_line_change(SCSI_LINE_REQ,0);
	806	break;
	807	}
907	808	}
908	809
909		UINT8 scsibus_driveno(UINT8 drivesel)
	810	UINT8 scsibus_device::scsibus_driveno(UINT8 drivesel)
910	811	{
911		switch (drivesel)
912		{
913		case 0x01   : return 0;
914		case 0x02   : return 1;
915		case 0x04   : return 2;
916		case 0x08   : return 3;
917		case 0x10   : return 4;
918		case 0x20   : return 5;
919		case 0x40   : return 6;
920		case 0x80   : return 7;
921		default : return 0;
922		}
	812	switch (drivesel)
	813	{
	814	case 0x01: return 0;
	815	case 0x02: return 1;
	816	case 0x04: return 2;
	817	case 0x08: return 3;
	818	case 0x10: return 4;
	819	case 0x20: return 5;
	820	case 0x40: return 6;
	821	case 0x80: return 7;
	822	default: return 0;
	823	}
923	824	}
924	825
925	826	// get the length of a SCSI command based on it's command byte type
926		int get_scsi_cmd_len(int cbyte)
	827	int scsibus_device::get_scsi_cmd_len(int cbyte)
927	828	{
928	829	int group;
929	830
r17482	r17483
938	839	return 6;
939	840	}
940	841
941		void init_scsibus(device_t *device, int sectorbytes)
	842	void scsibus_device::init_scsibus(int _sectorbytes)
942	843	{
943		scsibus_t               *bus = get_token(device);
944		const SCSIConfigTable   *scsidevs = bus->interface->scsidevs;
945
946		// try to open the devices
947		for (int devno = 0; devno < scsidevs->devs_present; devno++)
948		{
949		LOG(1,"SCSIBUS:init devno=%d \n",devno);
950		scsidev_device *scsidev = device->machine().device<scsidev_device>( scsidevs->devices[devno].tag );
951		bus->devices[scsidev->GetDeviceID()] = scsidev;
952		}
953
954		bus->sectorbytes = sectorbytes;
	844	sectorbytes = _sectorbytes;
955	845	}
956	846
957		static DEVICE_START( scsibus )
	847	scsibus_device::scsibus_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	848	: device_t(mconfig, SCSIBUS, "SCSI bus", tag, owner, clock)
958	849	{
959		scsibus_t               *bus = get_token(device);
960
961		assert(device->static_config() != NULL);
962		bus->interface = (const SCSIBus_interface*)device->static_config();
963
964		memset(bus->devices, 0, sizeof(bus->devices));
965
966		bus->out_bsy_func.resolve(bus->interface->out_bsy_func, *device);
967		bus->out_sel_func.resolve(bus->interface->out_sel_func, *device);
968		bus->out_cd_func.resolve(bus->interface->out_cd_func, *device);
969		bus->out_io_func.resolve(bus->interface->out_io_func, *device);
970		bus->out_msg_func.resolve(bus->interface->out_msg_func, *device);
971		bus->out_req_func.resolve(bus->interface->out_req_func, *device);
972		bus->out_rst_func.resolve(bus->interface->out_rst_func, *device);
973
974		// All lines start high - inactive
975		bus->linestate=0xFF;
976
977		// Start with bus free
978		bus->phase=SCSI_PHASE_BUS_FREE;
979
980		// Setup req/ack/sel timers
981		bus->req_timer=device->machine().scheduler().timer_alloc(FUNC(req_timer_callback), (void *)device);
982		bus->ack_timer=device->machine().scheduler().timer_alloc(FUNC(ack_timer_callback), (void *)device);
983		bus->sel_timer=device->machine().scheduler().timer_alloc(FUNC(sel_timer_callback), (void *)device);
984		bus->dataout_timer=device->machine().scheduler().timer_alloc(FUNC(dataout_timer_callback), (void *)device);
985
986	850	}
987	851
988		static DEVICE_STOP( scsibus )
	852	void scsibus_device::device_config_complete()
989	853	{
	854	// inherit a copy of the static data
	855	const SCSIBus_interface *intf = reinterpret_cast<const SCSIBus_interface *>(static_config());
	856	if (intf != NULL)
	857	{
	858	*static_cast<SCSIBus_interface *>(this) = *intf;
	859	}
990	860	}
991	861
992		static DEVICE_RESET( scsibus )
	862	void scsibus_device::device_start()
993	863	{
994		}
	864	memset(devices, 0, sizeof(devices));
995	865
996		DEVICE_GET_INFO( scsibus )
997		{
998		switch ( state )
999		{
1000		/* --- the following bits of info are returned as 64-bit signed integers --- */
1001		case DEVINFO_INT_TOKEN_BYTES:         info->i = sizeof(scsibus_t);            break;
1002		case DEVINFO_INT_INLINE_CONFIG_BYTES:   info->i = 0;                      break;
	866	out_bsy_func.resolve(_out_bsy_func, *this);
	867	out_sel_func.resolve(_out_sel_func, *this);
	868	out_cd_func.resolve(_out_cd_func, *this);
	869	out_io_func.resolve(_out_io_func, *this);
	870	out_msg_func.resolve(_out_msg_func, *this);
	871	out_req_func.resolve(_out_req_func, *this);
	872	out_rst_func.resolve(_out_rst_func, *this);
1003	873
1004		/* --- the following bits of info are returned as pointers to data or functions --- */
1005		case DEVINFO_FCT_START:                info->start = DEVICE_START_NAME(scsibus);   break;
1006		case DEVINFO_FCT_STOP:                info->stop  = DEVICE_STOP_NAME(scsibus);   break;
1007		case DEVINFO_FCT_RESET:                info->reset = DEVICE_RESET_NAME(scsibus);   break;
	874	// All lines start high - inactive
	875	linestate=0xFF;
1008	876
1009		/* --- the following bits of info are returned as NULL-terminated strings --- */
1010		case DEVINFO_STR_NAME:                strcpy(info->s, "SCSI bus");            break;
1011		case DEVINFO_STR_FAMILY:             strcpy(info->s, "SCSI");                break;
1012		case DEVINFO_STR_VERSION:             strcpy(info->s, "1.0");                break;
1013		case DEVINFO_STR_SOURCE_FILE:         strcpy(info->s, __FILE__);                break;
1014		case DEVINFO_STR_CREDITS:             strcpy(info->s, "Copyright the MAME and MESS Teams"); break;
	877	// Start with bus free
	878	phase=SCSI_PHASE_BUS_FREE;
	879
	880	// Setup req/ack/sel timers
	881	req_timer=timer_alloc(0);
	882	ack_timer=timer_alloc(1);
	883	sel_timer=timer_alloc(2);
	884	dataout_timer=timer_alloc(3);
	885
	886	// try to open the devices
	887	for (int devno = 0; devno < scsidevs->devs_present; devno++)
	888	{
	889	LOG(1,"SCSIBUS:init devno=%d \n",devno);
	890	scsidev_device *scsidev = machine().device<scsidev_device>( scsidevs->devices[devno].tag );
	891	devices[scsidev->GetDeviceID()] = scsidev;
1015	892	}
1016	893	}
1017	894
1018		DEFINE_LEGACY_DEVICE(SCSIBUS, scsibus);
	895	const device_type SCSIBUS = &device_creator<scsibus_device>;

trunk/src/mess/machine/scsibus.h

r17482	r17483
10	10	#ifndef _SCSIBUS_H_
11	11	#define _SCSIBUS_H_
12	12
13		#include "emu.h"
14	13	#include "machine/scsi.h"
	14	#include "machine/scsidev.h"
15	15
16	16
17	17	/***************************************************************************
	18	INTERFACE
	19	***************************************************************************/
	20
	21	typedef struct _SCSIBus_interface SCSIBus_interface;
	22	struct _SCSIBus_interface
	23	{
	24	const SCSIConfigTable *scsidevs;      /* SCSI devices */
	25	void (*line_change_cb)(UINT8 line, UINT8 state);
	26
	27	devcb_write_line _out_bsy_func;
	28	devcb_write_line _out_sel_func;
	29	devcb_write_line _out_cd_func;
	30	devcb_write_line _out_io_func;
	31	devcb_write_line _out_msg_func;
	32	devcb_write_line _out_req_func;
	33	devcb_write_line _out_rst_func;
	34	};
	35
	36	/***************************************************************************
18	37	MACROS
19	38	***************************************************************************/
20	39
21		DECLARE_LEGACY_DEVICE(SCSIBUS, scsibus);
22
23	40	#define MCFG_SCSIBUS_ADD(_tag, _intrf) \
24	41	MCFG_DEVICE_ADD(_tag, SCSIBUS, 0) \
25	42	MCFG_DEVICE_CONFIG(_intrf)
r17482	r17483
85	102	#define XEBEC_PARAMS_SIZE         0x08
86	103	#define XEBEC_ALT_TRACK_SIZE      0x03
87	104
88		#define IS_COMMAND(cmd)            (bus->command[0]==cmd)
89		#define IS_READ_COMMAND()          ((bus->command[0]==0x08) || (bus->command[0]==0x28) || (bus->command[0]==0xa8))
90		#define IS_WRITE_COMMAND()         ((bus->command[0]==0x0a) || (bus->command[0]==0x2a))
91		#define SET_STATUS_SENSE(stat,sen)   { bus->status=(stat); bus->sense=(sen); }
	105	#define IS_COMMAND(cmd)            (command[0]==cmd)
	106	#define IS_READ_COMMAND()          ((command[0]==0x08) || (command[0]==0x28) || (command[0]==0xa8))
	107	#define IS_WRITE_COMMAND()         ((command[0]==0x0a) || (command[0]==0x2a))
	108	#define SET_STATUS_SENSE(stat,sen)   { status=(stat); sense=(sen); }
92	109
93	110	#define FORMAT_UNIT_TIMEOUT         5
94	111
r17482	r17483
150	167	UINT8      sectors_per_track;
151	168	} adaptec_sense_t;
152	169
153		/***************************************************************************
154		INTERFACE
155		***************************************************************************/
156
157		typedef struct _SCSIBus_interface SCSIBus_interface;
158		struct _SCSIBus_interface
	170	class scsibus_device : public device_t,
	171	public SCSIBus_interface
159	172	{
160		const SCSIConfigTable *scsidevs;      /* SCSI devices */
161		void (*line_change_cb)(device_t *device, UINT8 line, UINT8 state);
	173	public:
	174	// construction/destruction
	175	scsibus_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	176	/* SCSI Bus read/write */
162	177
163		devcb_write_line out_bsy_func;
164		devcb_write_line out_sel_func;
165		devcb_write_line out_cd_func;
166		devcb_write_line out_io_func;
167		devcb_write_line out_msg_func;
168		devcb_write_line out_req_func;
169		devcb_write_line out_rst_func;
170		};
	178	UINT8 scsi_data_r();
	179	void scsi_data_w( UINT8 data );
	180	DECLARE_READ8_MEMBER( scsi_data_r );
	181	DECLARE_WRITE8_MEMBER( scsi_data_w );
171	182
172		/* SCSI Bus read/write */
	183	/* Get/Set lines */
173	184
174		UINT8 scsi_data_r(device_t *device);
175		void scsi_data_w(device_t *device, UINT8 data);
	185	UINT8 get_scsi_line(UINT8 lineno);
	186	void set_scsi_line(UINT8 line, UINT8 state);
176	187
177		READ8_DEVICE_HANDLER( scsi_data_r );
178		WRITE8_DEVICE_HANDLER( scsi_data_w );
	188	DECLARE_READ_LINE_MEMBER( scsi_bsy_r );
	189	DECLARE_READ_LINE_MEMBER( scsi_sel_r );
	190	DECLARE_READ_LINE_MEMBER( scsi_cd_r );
	191	DECLARE_READ_LINE_MEMBER( scsi_io_r );
	192	DECLARE_READ_LINE_MEMBER( scsi_msg_r );
	193	DECLARE_READ_LINE_MEMBER( scsi_req_r );
	194	DECLARE_READ_LINE_MEMBER( scsi_ack_r );
	195	DECLARE_READ_LINE_MEMBER( scsi_rst_r );
179	196
180		/* Get/Set lines */
	197	DECLARE_WRITE_LINE_MEMBER( scsi_bsy_w );
	198	DECLARE_WRITE_LINE_MEMBER( scsi_sel_w );
	199	DECLARE_WRITE_LINE_MEMBER( scsi_cd_w );
	200	DECLARE_WRITE_LINE_MEMBER( scsi_io_w );
	201	DECLARE_WRITE_LINE_MEMBER( scsi_msg_w );
	202	DECLARE_WRITE_LINE_MEMBER( scsi_req_w );
	203	DECLARE_WRITE_LINE_MEMBER( scsi_ack_w );
	204	DECLARE_WRITE_LINE_MEMBER( scsi_rst_w );
181	205
182		UINT8 get_scsi_lines(device_t *device);
183		UINT8 get_scsi_line(device_t *device, UINT8 lineno);
184		void set_scsi_line(device_t *device, UINT8 line, UINT8 state);
	206	/* Initialisation at machine reset time */
	207	void init_scsibus(int sectorbytes);
185	208
186		READ_LINE_DEVICE_HANDLER( scsi_bsy_r );
187		READ_LINE_DEVICE_HANDLER( scsi_sel_r );
188		READ_LINE_DEVICE_HANDLER( scsi_cd_r );
189		READ_LINE_DEVICE_HANDLER( scsi_io_r );
190		READ_LINE_DEVICE_HANDLER( scsi_msg_r );
191		READ_LINE_DEVICE_HANDLER( scsi_req_r );
192		READ_LINE_DEVICE_HANDLER( scsi_ack_r );
193		READ_LINE_DEVICE_HANDLER( scsi_rst_r );
	209	protected:
	210	// device-level overrides
	211	virtual void device_config_complete();
	212	virtual void device_start();
	213	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
194	214
195		WRITE_LINE_DEVICE_HANDLER( scsi_bsy_w );
196		WRITE_LINE_DEVICE_HANDLER( scsi_sel_w );
197		WRITE_LINE_DEVICE_HANDLER( scsi_cd_w );
198		WRITE_LINE_DEVICE_HANDLER( scsi_io_w );
199		WRITE_LINE_DEVICE_HANDLER( scsi_msg_w );
200		WRITE_LINE_DEVICE_HANDLER( scsi_req_w );
201		WRITE_LINE_DEVICE_HANDLER( scsi_ack_w );
202		WRITE_LINE_DEVICE_HANDLER( scsi_rst_w );
	215	private:
	216	int get_scsi_cmd_len(int cbyte);
	217	UINT8 scsibus_driveno(UINT8  drivesel);
	218	void scsi_change_phase(UINT8 newphase);
	219	void set_scsi_line_now(UINT8 line, UINT8 state);
	220	void set_scsi_line_ack(UINT8 state);
	221	void scsi_in_line_changed(UINT8 line, UINT8 state);
	222	void scsi_out_line_change(UINT8 line, UINT8 state);
	223	void scsi_out_line_change_now(UINT8 line, UINT8 state);
	224	void scsi_out_line_req(UINT8 state);
	225	void scsibus_read_data();
	226	void scsibus_write_data();
	227	int datain_done();
	228	int dataout_done();
	229	void scsibus_exec_command();
	230	void check_process_dataout();
	231	void dump_command_bytes();
	232	void dump_data_bytes(int count);
	233	void dump_bytes(UINT8 *buff, int count);
203	234
204		/* Get current bus phase */
	235	scsidev_device        *devices[8];
205	236
206		UINT8 get_scsi_phase(device_t *device);
	237	devcb_resolved_write_line out_bsy_func;
	238	devcb_resolved_write_line out_sel_func;
	239	devcb_resolved_write_line out_cd_func;
	240	devcb_resolved_write_line out_io_func;
	241	devcb_resolved_write_line out_msg_func;
	242	devcb_resolved_write_line out_req_func;
	243	devcb_resolved_write_line out_rst_func;
207	244
208		/* utility functions */
	245	UINT8       linestate;
	246	UINT8       last_id;
	247	UINT8       phase;
209	248
210		/* get a drive's number from it's select line */
211		UINT8 scsibus_driveno(UINT8  drivesel);
	249	UINT8       command[CMD_BUF_SIZE];
	250	UINT8       cmd_idx;
	251	UINT8       is_linked;
212	252
213		/* get the number of bytes for a scsi command */
214		int get_scsi_cmd_len(int cbyte);
	253	UINT8       status;
	254	UINT8       sense;
215	255
216		/* Initialisation at machine reset time */
217		void init_scsibus(device_t *device, int sectorbytes);
	256	UINT8       buffer[ADAPTEC_BUF_SIZE];
	257	UINT16      data_idx;
	258	int         xfer_count;
	259	int         bytes_left;
	260	int         data_last;
	261	int         sectorbytes;
218	262
	263	emu_timer *req_timer;
	264	emu_timer *ack_timer;
	265	emu_timer *sel_timer;
	266	emu_timer *dataout_timer;
	267	};
	268
	269	// device type definition
	270	extern const device_type SCSIBUS;
	271
219	272	#endif

trunk/src/mess/machine/lux4105.c

r17482	r17483
42	42	{
43	43	if (!state)
44	44	{
45		scsi_sel_w(m_sasibus, 1);
	45	m_sasibus->scsi_sel_w(1);
46	46	}
47	47	}
48	48
r17482	r17483
50	50	{
51	51	if (!m_io && state)
52	52	{
53		scsi_data_w(m_sasibus, m_data);
	53	m_sasibus->scsi_data_w(m_data);
54	54	}
55	55
56	56	m_io = state;
r17482	r17483
62	62	{
63	63	if (state)
64	64	{
65		scsi_ack_w(m_sasibus, 1);
	65	m_sasibus->scsi_ack_w(1);
66	66	}
67	67
68	68	update_trrq_int();
r17482	r17483
147	147
148	148	inline void luxor_4105_device::update_trrq_int()
149	149	{
150		int cd = scsi_cd_r(m_sasibus);
151		int req = scsi_req_r(m_sasibus);
	150	int cd = m_sasibus->scsi_cd_r();
	151	int req = m_sasibus->scsi_req_r();
152	152	int trrq = !(cd & !req);
153	153
154	154	if (BIT(m_dma, 5))
r17482	r17483
210	210
211	211	void luxor_4105_device::device_reset()
212	212	{
213		init_scsibus(m_sasibus, 512);
	213	m_sasibus->init_scsibus(512);
214	214
215	215	m_cs = 0;
216	216	m_data = 0;
217	217	m_dma = 0;
218	218
219		scsi_rst_w(m_sasibus, 0);
220		scsi_rst_w(m_sasibus, 1);
	219	m_sasibus->scsi_rst_w(0);
	220	m_sasibus->scsi_rst_w(1);
221	221
222	222	m_slot->trrq_w(1);
223	223	}
r17482	r17483
283	283
284	284	*/
285	285
286		data = !scsi_bsy_r(m_sasibus);
287		data |= !scsi_req_r(m_sasibus) << 2;
288		data |= !scsi_cd_r(m_sasibus) << 3;
289		data |= !scsi_io_r(m_sasibus) << 6;
	286	data = !m_sasibus->scsi_bsy_r();
	287	data |= !m_sasibus->scsi_req_r() << 2;
	288	data |= !m_sasibus->scsi_cd_r() << 3;
	289	data |= !m_sasibus->scsi_io_r() << 6;
290	290	}
291	291
292	292	return data;
r17482	r17483
303	303
304	304	if (m_cs)
305	305	{
306		if (scsi_bsy_r(m_sasibus))
	306	if (m_sasibus->scsi_bsy_r())
307	307	{
308	308	ioport("1E")->read();
309	309	}
310	310	else
311	311	{
312		if (!scsi_io_r(m_sasibus))
	312	if (!m_sasibus->scsi_io_r())
313	313	{
314		data = scsi_data_r(m_sasibus);
	314	data = m_sasibus->scsi_data_r();
315	315
316		if (!scsi_req_r(m_sasibus))
	316	if (!m_sasibus->scsi_req_r())
317	317	{
318		scsi_ack_w(m_sasibus, 0);
	318	m_sasibus->scsi_ack_w(0);
319	319	}
320	320	}
321	321	}
r17482	r17483
335	335	{
336	336	m_data = data;
337	337
338		if (scsi_io_r(m_sasibus))
	338	if (m_sasibus->scsi_io_r())
339	339	{
340		scsi_data_w(m_sasibus, m_data);
	340	m_sasibus->scsi_data_w(m_data);
341	341
342		if (!scsi_req_r(m_sasibus))
	342	if (!m_sasibus->scsi_req_r())
343	343	{
344		scsi_ack_w(m_sasibus, 0);
	344	m_sasibus->scsi_ack_w(0);
345	345	}
346	346	}
347	347	}
r17482	r17483
356	356	{
357	357	if (m_cs)
358	358	{
359		scsi_sel_w(m_sasibus, 0);
	359	m_sasibus->scsi_sel_w(0);
360	360	}
361	361	}
362	362
r17482	r17483
372	372	m_data = 0;
373	373	m_dma = 0;
374	374
375		scsi_rst_w(m_sasibus, 0);
376		scsi_rst_w(m_sasibus, 1);
	375	m_sasibus->scsi_rst_w(0);
	376	m_sasibus->scsi_rst_w(1);
377	377	}
378	378	}
379	379

trunk/src/mess/machine/lux4105.h

r17482	r17483
71	71
72	72	abc1600bus_slot_device *m_slot;
73	73
74		required_device<device_t> m_sasibus;
	74	required_device<scsibus_device> m_sasibus;
75	75
76	76	int m_cs;
77	77	int m_io;

trunk/src/mess/machine/d9060.c

r17482	r17483
387	387
388	388	UINT8 data = 0;
389	389
390		data |= !scsi_cd_r(m_sasibus) << 2;
391		data |= !scsi_bsy_r(m_sasibus) << 3;
392		data |= !scsi_io_r(m_sasibus) << 6;
393		data |= !scsi_msg_r(m_sasibus) << 7;
	390	data |= !m_sasibus->scsi_cd_r() << 2;
	391	data |= !m_sasibus->scsi_bsy_r() << 3;
	392	data |= !m_sasibus->scsi_io_r() << 6;
	393	data |= !m_sasibus->scsi_msg_r() << 7;
394	394
395	395	// drive type
396	396	data |= (m_variant == TYPE_9060) << 4;
r17482	r17483
415	415
416	416	*/
417	417
418		scsi_sel_w(m_sasibus, !BIT(data, 0));
419		scsi_rst_w(m_sasibus, !BIT(data, 1));
	418	m_sasibus->scsi_sel_w(!BIT(data, 0));
	419	m_sasibus->scsi_rst_w(!BIT(data, 1));
420	420	}
421	421
422	422	READ_LINE_MEMBER( base_d9060_device::req_r )
423	423	{
424		return !scsi_req_r(m_sasibus);
	424	return !m_sasibus->scsi_req_r();
425	425	}
426	426
427	427	WRITE_LINE_MEMBER( base_d9060_device::ack_w )
428	428	{
429		scsi_ack_w(m_sasibus, state);
	429	m_sasibus->scsi_ack_w(state);
430	430	}
431	431
432	432	WRITE_LINE_MEMBER( base_d9060_device::enable_w )
r17482	r17483
436	436
437	437	static const via6522_interface via_intf =
438	438	{
439		DEVCB_DEVICE_HANDLER(SASIBUS_TAG, scsi_data_r),
	439	DEVCB_DEVICE_MEMBER(SASIBUS_TAG, scsibus_device, scsi_data_r),
440	440	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, base_d9060_device, via_pb_r),
441	441	DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, base_d9060_device, req_r),
442	442	DEVCB_NULL,
443	443	DEVCB_NULL,
444	444	DEVCB_NULL,
445	445
446		DEVCB_DEVICE_HANDLER(SASIBUS_TAG, scsi_data_w),
	446	DEVCB_DEVICE_MEMBER(SASIBUS_TAG, scsibus_device, scsi_data_w),
447	447	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, base_d9060_device, via_pb_w),
448	448	DEVCB_NULL,
449	449	DEVCB_NULL,
r17482	r17483
571	571
572	572	void base_d9060_device::device_reset()
573	573	{
574		init_scsibus(m_sasibus, 256);
	574	m_sasibus->init_scsibus(256);
575	575
576	576	m_maincpu->set_input_line(M6502_SET_OVERFLOW, ASSERT_LINE);
577	577	m_maincpu->set_input_line(M6502_SET_OVERFLOW, CLEAR_LINE);

trunk/src/mess/machine/d9060.h

r17482	r17483
91	91	required_device<riot6532_device> m_riot0;
92	92	required_device<riot6532_device> m_riot1;
93	93	required_device<via6522_device> m_via;
94		required_device<device_t> m_sasibus;
	94	required_device<scsibus_device> m_sasibus;
95	95
96	96	// IEEE-488 bus
97	97	int m_rfdo;                     // not ready for data output

trunk/src/mess/machine/rmnimbus.c

r17482	r17483
2280	2280	drq_callback(device->machine(),1);
2281	2281	}
2282	2282
	2283	static UINT8 fdc_driveno(UINT8 drivesel)
	2284	{
	2285	switch (drivesel)
	2286	{
	2287	case 0x01: return 0;
	2288	case 0x02: return 1;
	2289	case 0x04: return 2;
	2290	case 0x08: return 3;
	2291	case 0x10: return 4;
	2292	case 0x20: return 5;
	2293	case 0x40: return 6;
	2294	case 0x80: return 7;
	2295	default: return 0;
	2296	}
	2297	}
	2298
2283	2299	/*
2284	2300	0x410 read bits
2285	2301
r17482	r17483
2297	2313	{
2298	2314	int result = 0;
2299	2315	device_t *fdc = machine().device(FDC_TAG);
2300		device_t *hdc = machine().device(SCSIBUS_TAG);
	2316	scsibus_device *hdc = machine().device<scsibus_device>(SCSIBUS_TAG);
2301	2317
2302	2318	int pc=cpu_get_pc(&space.device());
2303	2319	rmnimbus_state *state = machine().driver_data<rmnimbus_state>();
r17482	r17483
2328	2344	result=m_nimbus_drives.reg410_in ^ INV_BITS_410;
2329	2345	break;
2330	2346	case 0x18 :
2331		result = scsi_data_r(hdc);
	2347	result = hdc->scsi_data_r();
2332	2348	hdc_post_rw(machine());
2333	2349	default:
2334	2350	break;
r17482	r17483
2365	2381	WRITE8_MEMBER(rmnimbus_state::nimbus_disk_w)
2366	2382	{
2367	2383	device_t *fdc = machine().device(FDC_TAG);
2368		device_t *hdc = machine().device(SCSIBUS_TAG);
	2384	scsibus_device *hdc = machine().device<scsibus_device>(SCSIBUS_TAG);
2369	2385	int                 pc=cpu_get_pc(&space.device());
2370	2386	UINT8               reg400_old = m_nimbus_drives.reg400;
2371	2387
r17482	r17483
2408	2424	break;
2409	2425
2410	2426	case 0x18 :
2411		scsi_data_w(hdc, data);
	2427	hdc->scsi_data_w(data);
2412	2428	hdc_post_rw(machine());
2413	2429	break;
2414	2430	}
r17482	r17483
2417	2433	static void hdc_reset(running_machine &machine)
2418	2434	{
2419	2435	rmnimbus_state *state = machine.driver_data<rmnimbus_state>();
2420		device_t *hdc = machine.device(SCSIBUS_TAG);
	2436	scsibus_device *hdc = machine.device<scsibus_device>(SCSIBUS_TAG);
2421	2437
2422		init_scsibus(hdc, 512);
	2438	hdc->init_scsibus(512);
2423	2439
2424	2440	state->m_nimbus_drives.reg410_in=0;
2425		state->m_nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_REQ) ? HDC_REQ_MASK : 0);
2426		state->m_nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_CD)  ? HDC_CD_MASK  : 0);
2427		state->m_nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_IO)  ? HDC_IO_MASK  : 0);
2428		state->m_nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_BSY) ? HDC_BSY_MASK : 0);
2429		state->m_nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_MSG) ? HDC_MSG_MASK : 0);
	2441	state->m_nimbus_drives.reg410_in |= (hdc->get_scsi_line(SCSI_LINE_REQ) ? HDC_REQ_MASK : 0);
	2442	state->m_nimbus_drives.reg410_in |= (hdc->get_scsi_line(SCSI_LINE_CD)  ? HDC_CD_MASK  : 0);
	2443	state->m_nimbus_drives.reg410_in |= (hdc->get_scsi_line(SCSI_LINE_IO)  ? HDC_IO_MASK  : 0);
	2444	state->m_nimbus_drives.reg410_in |= (hdc->get_scsi_line(SCSI_LINE_BSY) ? HDC_BSY_MASK : 0);
	2445	state->m_nimbus_drives.reg410_in |= (hdc->get_scsi_line(SCSI_LINE_MSG) ? HDC_MSG_MASK : 0);
2430	2446
2431	2447	state->m_nimbus_drives.drq_ff=0;
2432	2448	}
r17482	r17483
2434	2450	static void hdc_ctrl_write(running_machine &machine, UINT8 data)
2435	2451	{
2436	2452	rmnimbus_state *state = machine.driver_data<rmnimbus_state>();
2437		device_t *hdc = machine.device(SCSIBUS_TAG);
	2453	scsibus_device *hdc = machine.device<scsibus_device>(SCSIBUS_TAG);
2438	2454
2439	2455	// If we enable the HDC interupt, and an interrupt is pending, go deal with it.
2440	2456	if(((data & HDC_IRQ_MASK) && (~state->m_nimbus_drives.reg410_out & HDC_IRQ_MASK)) &&
r17482	r17483
2443	2459
2444	2460	state->m_nimbus_drives.reg410_out=data;
2445	2461
2446		set_scsi_line(hdc, SCSI_LINE_RESET, (data & HDC_RESET_MASK) ? 0 : 1);
2447		set_scsi_line(hdc, SCSI_LINE_SEL, (data & HDC_SEL_MASK) ? 0 : 1);
	2462	hdc->set_scsi_line(SCSI_LINE_RESET, (data & HDC_RESET_MASK) ? 0 : 1);
	2463	hdc->set_scsi_line(SCSI_LINE_SEL, (data & HDC_SEL_MASK) ? 0 : 1);
2448	2464	}
2449	2465
2450	2466	static void hdc_post_rw(running_machine &machine)
2451	2467	{
2452	2468	rmnimbus_state *state = machine.driver_data<rmnimbus_state>();
2453		device_t *hdc = machine.device(SCSIBUS_TAG);
	2469	scsibus_device *hdc = machine.device<scsibus_device>(SCSIBUS_TAG);
2454	2470
2455	2471	if((state->m_nimbus_drives.reg410_in & HDC_REQ_MASK)==0)
2456		set_scsi_line(hdc,SCSI_LINE_ACK,0);
	2472	hdc->set_scsi_line(SCSI_LINE_ACK,0);
2457	2473
2458	2474	state->m_nimbus_drives.drq_ff=0;
2459	2475	}
r17482	r17483
2506	2522	}
2507	2523	}
2508	2524	else
2509		set_scsi_line(device,SCSI_LINE_ACK,1);
	2525	{
	2526	scsibus_device *hdc = downcast<scsibus_device *>(device);
	2527	hdc->set_scsi_line(SCSI_LINE_ACK,1);
	2528	}
2510	2529	}
2511	2530	}
2512	2531

trunk/src/mess/machine/e01.c

r17482	r17483
274	274	{
275	275	if (!state)
276	276	{
277		scsi_sel_w(m_scsibus, 1);
	277	m_scsibus->scsi_sel_w(1);
278	278	}
279	279	}
280	280
r17482	r17483
282	282	{
283	283	if (state)
284	284	{
285		scsi_ack_w(m_scsibus, 1);
	285	m_scsibus->scsi_ack_w(1);
286	286	}
287	287
288	288	m_hdc_irq = !state;
r17482	r17483
564	564
565	565	void e01_device::device_reset()
566	566	{
567		init_scsibus(m_scsibus, 512);
	567	m_scsibus->init_scsibus(512);
568	568
569	569	m_clk_timer->adjust(attotime::zero, 0, attotime::from_hz(200000));
570	570
r17482	r17483
697	697
698	698	READ8_MEMBER( e01_device::hdc_data_r )
699	699	{
700		UINT8 data = scsi_data_r(m_scsibus, 0);
	700	UINT8 data = m_scsibus->scsi_data_r(space, 0);
701	701
702		scsi_ack_w(m_scsibus, 0);
	702	m_scsibus->scsi_ack_w(0);
703	703
704	704	return data;
705	705	}
r17482	r17483
711	711
712	712	WRITE8_MEMBER( e01_device::hdc_data_w )
713	713	{
714		scsi_data_w(m_scsibus, 0, data);
	714	m_scsibus->scsi_data_w(space, 0, data);
715	715
716		scsi_ack_w(m_scsibus, 0);
	716	m_scsibus->scsi_ack_w(0);
717	717	}
718	718
719	719
r17482	r17483
741	741	UINT8 data = 0;
742	742
743	743	// SCSI bus
744		data |= !scsi_msg_r(m_scsibus);
745		data |= !scsi_bsy_r(m_scsibus) << 1;
746		data |= !scsi_req_r(m_scsibus) << 5;
747		data |= !scsi_io_r(m_scsibus) << 6;
748		data |= !scsi_cd_r(m_scsibus) << 7;
	744	data |= !m_scsibus->scsi_msg_r();
	745	data |= !m_scsibus->scsi_bsy_r() << 1;
	746	data |= !m_scsibus->scsi_req_r() << 5;
	747	data |= !m_scsibus->scsi_io_r() << 6;
	748	data |= !m_scsibus->scsi_cd_r() << 7;
749	749
750	750	// TODO NIRQ
751	751
r17482	r17483
759	759
760	760	WRITE8_MEMBER( e01_device::hdc_select_w )
761	761	{
762		scsi_sel_w(m_scsibus, 0);
	762	m_scsibus->scsi_sel_w(0);
763	763	}
764	764
765	765

trunk/src/mess/machine/e01.h

r17482	r17483
85	85	required_device<device_t> m_adlc;
86	86	required_device<mc146818_device> m_rtc;
87	87	required_device<ram_device> m_ram;
88		required_device<device_t> m_scsibus;
	88	required_device<scsibus_device> m_scsibus;
89	89
90	90	inline void update_interrupts();
91	91	inline void network_irq_enable(int enabled);

trunk/src/mess/includes/v1050.h

r17482	r17483
94	94	required_device<timer_device> m_timer_sio;
95	95	required_device<timer_device> m_timer_ack;
96	96	required_device<timer_device> m_timer_rst;
97		required_device<device_t> m_sasibus;
	97	required_device<scsibus_device> m_sasibus;
98	98
99	99	virtual void machine_start();
100	100	virtual void machine_reset();

trunk/src/mess/includes/bullet.h

r17482	r17483
104	104	m_scsibus(*this, SCSIBUS_TAG)
105	105	{ }
106	106
107		required_device<device_t> m_scsibus;
	107	required_device<scsibus_device> m_scsibus;
108	108
109	109	virtual void machine_start();
110	110	virtual void machine_reset();

trunk/src/mess/includes/rmnimbus.h

r17482	r17483
336	336
337	337	#define FDC_SIDE()          ((state->m_nimbus_drives.reg400 & FDC_SIDE_MASK) >> 4)
338	338	#define FDC_MOTOR()         ((state->m_nimbus_drives.reg400 & FDC_MOTOR_MASKO) >> 5)
339		#define FDC_DRIVE()         (scsibus_driveno(state->m_nimbus_drives.reg400 & FDC_DRIVE_MASK))
	339	#define FDC_DRIVE()         (fdc_driveno(state->m_nimbus_drives.reg400 & FDC_DRIVE_MASK))
340	340	#define HDC_DRQ_ENABLED()   ((state->m_nimbus_drives.reg400 & HDC_DRQ_MASK) ? 1 : 0)
341	341	#define FDC_DRQ_ENABLED(state)   ((state->m_nimbus_drives.reg400 & FDC_DRQ_MASK) ? 1 : 0)
342	342

trunk/src/mess/drivers/v1050.c

r17482	r17483
363	363
364	364	UINT8 data = 0;
365	365
366		data |= scsi_req_r(m_sasibus);
367		data |= !scsi_bsy_r(m_sasibus) << 1;
368		data |= !scsi_msg_r(m_sasibus) << 2;
369		data |= !scsi_cd_r(m_sasibus) << 3;
370		data |= scsi_io_r(m_sasibus) << 4;
	366	data |= m_sasibus->scsi_req_r();
	367	data |= !m_sasibus->scsi_bsy_r() << 1;
	368	data |= !m_sasibus->scsi_msg_r() << 2;
	369	data |= !m_sasibus->scsi_cd_r() << 3;
	370	data |= m_sasibus->scsi_io_r() << 4;
371	371
372	372	return data;
373	373	}
r17482	r17483
376	376	{
377	377	v1050_state *state = timer.machine().driver_data<v1050_state>();
378	378
379		scsi_ack_w(state->m_sasibus, 1);
	379	state->m_sasibus->scsi_ack_w(1);
380	380	}
381	381
382	382	static TIMER_DEVICE_CALLBACK( sasi_rst_tick )
383	383	{
384	384	v1050_state *state = timer.machine().driver_data<v1050_state>();
385	385
386		scsi_rst_w(state->m_sasibus, 1);
	386	state->m_sasibus->scsi_rst_w(1);
387	387	}
388	388
389	389	WRITE8_MEMBER( v1050_state::sasi_ctrl_w )
r17482	r17483
403	403
404	404	*/
405	405
406		scsi_sel_w(m_sasibus, !BIT(data, 0));
	406	m_sasibus->scsi_sel_w(!BIT(data, 0));
407	407
408	408	if (BIT(data, 1))
409	409	{
410	410	// send acknowledge pulse
411		scsi_ack_w(m_sasibus, 0);
	411	m_sasibus->scsi_ack_w(0);
412	412
413	413	m_timer_ack->adjust(attotime::from_nsec(100));
414	414	}
r17482	r17483
416	416	if (BIT(data, 7))
417	417	{
418	418	// send reset pulse
419		scsi_rst_w(m_sasibus, 0);
	419	m_sasibus->scsi_rst_w(0);
420	420
421	421	m_timer_rst->adjust(attotime::from_nsec(100));
422	422	}
r17482	r17483
450	450	AM_RANGE(0xb0, 0xb0) AM_READWRITE(dint_clr_r, dint_clr_w)
451	451	AM_RANGE(0xc0, 0xc0) AM_WRITE(v1050_i8214_w)
452	452	AM_RANGE(0xd0, 0xd0) AM_WRITE(bank_w)
453		AM_RANGE(0xe0, 0xe0) AM_DEVREADWRITE_LEGACY(SASIBUS_TAG, scsi_data_r, scsi_data_w)
	453	AM_RANGE(0xe0, 0xe0) AM_DEVREADWRITE(SASIBUS_TAG, scsibus_device, scsi_data_r, scsi_data_w)
454	454	AM_RANGE(0xe1, 0xe1) AM_READWRITE(sasi_status_r, sasi_ctrl_w)
455	455	ADDRESS_MAP_END
456	456
r17482	r17483
1030	1030	address_space *program = m_maincpu->memory().space(AS_PROGRAM);
1031	1031
1032	1032	// initialize SASI bus
1033		init_scsibus(m_sasibus, 256);
	1033	m_sasibus->init_scsibus(256);
1034	1034
1035	1035	// initialize I8214
1036	1036	m_pic->etlg_w(1);

trunk/src/mess/drivers/bullet.c

r17482	r17483
478	478
479	479	READ8_MEMBER( bulletf_state::scsi_r )
480	480	{
481		UINT8 data = scsi_data_r(m_scsibus, 0);
	481	UINT8 data = m_scsibus->scsi_data_r();
482	482
483		scsi_ack_w(m_scsibus, 0);
	483	m_scsibus->scsi_ack_w(0);
484	484
485	485	m_wack = 0;
486	486	update_dma_rdy();
r17482	r17483
495	495
496	496	WRITE8_MEMBER( bulletf_state::scsi_w )
497	497	{
498		scsi_data_w(m_scsibus, 0, data);
	498	m_scsibus->scsi_data_w(data);
499	499
500		scsi_ack_w(m_scsibus, 0);
	500	m_scsibus->scsi_ack_w(0);
501	501
502	502	m_wack = 0;
503	503	update_dma_rdy();
r17482	r17483
927	927
928	928	UINT8 data = 0;
929	929
930		data |= !scsi_bsy_r(m_scsibus) << 3;
931		data |= !scsi_msg_r(m_scsibus) << 4;
932		data |= !scsi_cd_r(m_scsibus) << 5;
933		data |= !scsi_req_r(m_scsibus) << 6;
934		data |= !scsi_io_r(m_scsibus) << 7;
	930	data |= !m_scsibus->scsi_bsy_r() << 3;
	931	data |= !m_scsibus->scsi_msg_r() << 4;
	932	data |= !m_scsibus->scsi_cd_r() << 5;
	933	data |= !m_scsibus->scsi_req_r() << 6;
	934	data |= !m_scsibus->scsi_io_r() << 7;
935	935
936	936	return data;
937	937	}
r17482	r17483
953	953
954	954	*/
955	955
956		//scsi_atn_w(m_scsibus, !BIT(data, 0));
957		scsi_rst_w(m_scsibus, !BIT(data, 1));
958		scsi_sel_w(m_scsibus, !BIT(data, 2));
	956	//m_scsibus->scsi_atn_w(!BIT(data, 0));
	957	m_scsibus->scsi_rst_w(!BIT(data, 1));
	958	m_scsibus->scsi_sel_w(!BIT(data, 2));
959	959	}
960	960
961	961	WRITE_LINE_MEMBER( bulletf_state::cstrb_w )
r17482	r17483
1036	1036	{
1037	1037	if (state)
1038	1038	{
1039		scsi_ack_w(m_scsibus, 1);
	1039	m_scsibus->scsi_ack_w(1);
1040	1040
1041	1041	m_wack = 1;
1042	1042	}
r17482	r17483
1111	1111	void bulletf_state::machine_start()
1112	1112	{
1113	1113	// initialize SASI bus
1114		init_scsibus(m_scsibus, 512);
	1114	m_scsibus->init_scsibus(512);
1115	1115
1116	1116	// state saving
1117	1117	save_item(NAME(m_fdrdy));

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team