Previous

199869 Revisions

Next

r18279 Thursday 4th October, 2012 at 11:09:41 UTC by smf
renamed scsidev to scsihle (nw)

[src/emu]	emu.mak
[src/emu/machine]	53c810.c 53c810.h am53cf96.c am53cf96.h ncr539x.c ncr539x.h scsibus.c scsibus.h scsicd.c scsicd.h scsidev.c scsidev.h scsihd.c scsihd.h scsihle.c* scsihle.h* wd33c93.c wd33c93.h
[src/mame/drivers]	firebeat.c konamigv.c ksys573.c twinkle.c
[src/mame/machine]	gdrom.c gdrom.h
[src/mess/machine]	fm_scsi.c fm_scsi.h mb89352.c mb89352.h ncr5380.c ncr5380.h

trunk/src/emu/emu.mak

r18278	r18279
252	252	$(EMUMACHINE)/scsicb.o      \
253	253	$(EMUMACHINE)/scsibus.o      \
254	254	$(EMUMACHINE)/scsicd.o      \
255		$(EMUMACHINE)/scsidev.o      \
256	255	$(EMUMACHINE)/scsihd.o      \
	256	$(EMUMACHINE)/scsihle.o      \
257	257	$(EMUMACHINE)/secflash.o   \
258	258	$(EMUMACHINE)/seibu_cop.o   \
259	259	$(EMUMACHINE)/smc91c9x.o   \

trunk/src/emu/machine/scsidev.c

r18278	r18279
1		/***************************************************************************
2
3		scsidev.c - Base class for scsi devices.
4
5		***************************************************************************/
6
7		#include "emu.h"
8		#include "scsidev.h"
9
10		scsidev_device::scsidev_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) :
11		device_t(mconfig, type, name, tag, owner, clock)
12		{
13		}
14
15		void scsidev_device::device_start()
16		{
17		save_item( NAME( command ) );
18		save_item( NAME( commandLength ) );
19		save_item( NAME( phase ) );
20		}
21
22		#define SCSI_SENSE_SIZE            4
23
24		void scsidev_device::ExecCommand( int *transferLength )
25		{
26		UINT8 *command;
27		int commandLength;
28		GetCommand( &command, &commandLength );
29
30		switch( command[ 0 ] )
31		{
32		case SCSI_CMD_TEST_UNIT_READY:
33		SetPhase( SCSI_PHASE_STATUS );
34		*transferLength = 0;
35		break;
36
37		case SCSI_CMD_RECALIBRATE:
38		SetPhase( SCSI_PHASE_STATUS );
39		*transferLength = 0;
40		break;
41
42		case SCSI_CMD_REQUEST_SENSE:
43		SetPhase( SCSI_PHASE_DATAOUT );
44		*transferLength = SCSI_SENSE_SIZE;
45		break;
46
47		case SCSI_CMD_SEND_DIAGNOSTIC:
48		SetPhase( SCSI_PHASE_DATAOUT );
49		*transferLength = ( command[ 3 ] << 8 ) + command[ 4 ];
50		break;
51
52		default:
53		logerror( "%s: SCSIDEV unknown command %02x\n", machine().describe_context(), command[ 0 ] );
54		*transferLength = 0;
55		break;
56		}
57		}
58
59		void scsidev_device::ReadData( UINT8 *data, int dataLength )
60		{
61		UINT8 *command;
62		int commandLength;
63		GetCommand( &command, &commandLength );
64
65		switch( command[ 0 ] )
66		{
67		case SCSI_CMD_REQUEST_SENSE:
68		data[ 0 ] = SCSI_SENSE_NO_SENSE;
69		data[ 1 ] = 0x00;
70		data[ 2 ] = 0x00;
71		data[ 3 ] = 0x00;
72		break;
73		default:
74		logerror( "%s: SCSIDEV unknown read %02x\n", machine().describe_context(), command[ 0 ] );
75		break;
76		}
77		}
78
79		void scsidev_device::WriteData( UINT8 *data, int dataLength )
80		{
81		UINT8 *command;
82		int commandLength;
83		GetCommand( &command, &commandLength );
84
85		switch( command[ 0 ] )
86		{
87		case SCSI_CMD_SEND_DIAGNOSTIC:
88		break;
89
90		default:
91		logerror( "%s: SCSIDEV unknown write %02x\n", machine().describe_context(), command[ 0 ] );
92		break;
93		}
94		}
95
96		void scsidev_device::SetPhase( int _phase )
97		{
98		phase = _phase;
99		}
100
101		void scsidev_device::GetPhase( int *_phase)
102		{
103		*_phase = phase;
104		}
105
106		void scsidev_device::SetCommand( UINT8 *_command, int _commandLength )
107		{
108		if( _commandLength > sizeof( command ) )
109		{
110		/// TODO: output an error.
111		return;
112		}
113
114		memcpy( command, _command, _commandLength );
115		commandLength = _commandLength;
116
117		SetPhase( SCSI_PHASE_COMMAND );
118		}
119
120		void scsidev_device::GetCommand( UINT8 **_command, int *_commandLength )
121		{
122		*_command = command;
123		*_commandLength = commandLength;
124		}
125
126		int scsidev_device::GetDeviceID()
127		{
128		return scsiID;
129		}
130
131		int scsidev_device::GetSectorBytes()
132		{
133		return 0;
134		}
135
136		void scsidev_device::static_set_deviceid( device_t &device, int _scsiID )
137		{
138		scsidev_device &scsidev = downcast<scsidev_device &>(device);
139		scsidev.scsiID = _scsiID;
140		}
141
142		int SCSILengthFromUINT8( UINT8 *length )
143		{
144		if( *length == 0 )
145		{
146		return 256;
147		}
148
149		return *length;
150		}
151
152		int SCSILengthFromUINT16( UINT8 *length )
153		{
154		return ( *(length) << 8 ) | *(length + 1 );
155		}

trunk/src/emu/machine/scsidev.h

r18278	r18279
1		/***************************************************************************
2
3		scsidev.h
4
5		***************************************************************************/
6
7		#ifndef _SCSIDEV_H_
8		#define _SCSIDEV_H_
9
10		// base handler
11		class scsidev_device : public device_t
12		{
13		public:
14		// construction/destruction
15		scsidev_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
16
17		virtual void SetDevice( void *device ) = 0;
18		virtual void GetDevice( void **device ) = 0;
19		virtual void SetCommand( UINT8 *command, int commandLength );
20		virtual void GetCommand( UINT8 **command, int *commandLength );
21		virtual void ExecCommand( int *transferLength );
22		virtual void WriteData( UINT8 *data, int dataLength );
23		virtual void ReadData( UINT8 *data, int dataLength );
24		virtual void SetPhase( int phase );
25		virtual void GetPhase( int *phase );
26		virtual int GetDeviceID();
27		virtual int GetSectorBytes();
28
29		// configuration helpers
30		static void static_set_deviceid(device_t &device, int _scsiID);
31
32		protected:
33		// device-level overrides
34		virtual void device_start();
35
36		private:
37		UINT8 command[16];
38		int commandLength;
39		int phase;
40		int scsiID;
41		};
42
43		extern int SCSILengthFromUINT8( UINT8 *length );
44		extern int SCSILengthFromUINT16( UINT8 *length );
45
46		#define SCSI_PHASE_DATAOUT ( 0 )
47		#define SCSI_PHASE_DATAIN ( 1 )
48		#define SCSI_PHASE_COMMAND ( 2 )
49		#define SCSI_PHASE_STATUS ( 3 )
50		#define SCSI_PHASE_MESSAGE_OUT ( 6 )
51		#define SCSI_PHASE_MESSAGE_IN ( 7 )
52
53		#define SCSI_CMD_TEST_UNIT_READY ( 0x00 )
54		#define SCSI_CMD_RECALIBRATE ( 0x01 )
55		#define SCSI_CMD_REQUEST_SENSE ( 0x03 )
56		#define SCSI_CMD_MODE_SELECT ( 0x15 )
57		#define SCSI_CMD_SEND_DIAGNOSTIC ( 0x1d )
58
59		//
60		// Status / Sense data taken from Adaptec ACB40x0 documentation.
61		//
62
63		#define SCSI_STATUS_OK            0x00
64		#define SCSI_STATUS_CHECK         0x02
65		#define SCSI_STATUS_EQUAL         0x04
66		#define SCSI_STATUS_BUSY         0x08
67
68		#define SCSI_SENSE_ADDR_VALID      0x80
69		#define SCSI_SENSE_NO_SENSE         0x00
70		#define SCSI_SENSE_NO_INDEX         0x01
71		#define SCSI_SENSE_SEEK_NOT_COMP   0x02
72		#define SCSI_SENSE_WRITE_FAULT      0x03
73		#define SCSI_SENSE_DRIVE_NOT_READY   0x04
74		#define SCSI_SENSE_NO_TRACK0      0x06
75		#define SCSI_SENSE_ID_CRC_ERROR      0x10
76		#define SCSI_SENSE_UNCORRECTABLE   0x11
77		#define SCSI_SENSE_ADDRESS_NF      0x12
78		#define SCSI_SENSE_RECORD_NOT_FOUND   0x14
79		#define SCSI_SENSE_SEEK_ERROR      0x15
80		#define SCSI_SENSE_DATA_CHECK_RETRY   0x18
81		#define SCSI_SENSE_ECC_VERIFY      0x19
82		#define SCSI_SENSE_INTERLEAVE_ERROR   0x1A
83		#define SCSI_SENSE_UNFORMATTED      0x1C
84		#define SCSI_SENSE_ILLEGAL_COMMAND   0x20
85		#define SCSI_SENSE_ILLEGAL_ADDRESS   0x21
86		#define SCSI_SENSE_VOLUME_OVERFLOW   0x23
87		#define SCSI_SENSE_BAD_ARGUMENT      0x24
88		#define SCSI_SENSE_INVALID_LUN      0x25
89		#define SCSI_SENSE_CART_CHANGED      0x28
90		#define SCSI_SENSE_ERROR_OVERFLOW   0x2C
91
92		// SCSI IDs
93		enum
94		{
95		SCSI_ID_0 = 0,
96		SCSI_ID_1,
97		SCSI_ID_2,
98		SCSI_ID_3,
99		SCSI_ID_4,
100		SCSI_ID_5,
101		SCSI_ID_6,
102		SCSI_ID_7
103		};
104
105		#define MCFG_SCSIDEV_ADD(_tag, _type, _id) \
106		MCFG_DEVICE_ADD(_tag, _type, 0) \
107		scsidev_device::static_set_deviceid(*device, _id);
108
109		#endif

trunk/src/emu/machine/am53cf96.c

r18278	r18279
11	11
12	12	#include "emu.h"
13	13	#include "am53cf96.h"
14		#include "machine/scsidev.h"
	14	#include "machine/scsihle.h"
15	15
16	16	READ8_MEMBER( am53cf96_device::read )
17	17	{
r18278	r18279
180	180	// try to open the devices
181	181	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
182	182	{
183		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	183	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
184	184	if( scsidev != NULL )
185	185	{
186	186	devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/emu/machine/am53cf96.h

r18278	r18279
6	6	#ifndef _AM53CF96_H_
7	7	#define _AM53CF96_H_
8	8
9		#include "scsidev.h"
	9	#include "machine/scsihle.h"
10	10
11	11	struct AM53CF96interface
12	12	{
r18278	r18279
61	61	private:
62	62	static const device_timer_id TIMER_TRANSFER = 0;
63	63
64		scsidev_device *devices[8];
	64	scsihle_device *devices[8];
65	65
66	66	UINT8 scsi_regs[32];
67	67	UINT8 fifo[16];

trunk/src/emu/machine/scsihd.c

r18278	r18279
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "scsidev.h"
	8	#include "machine/scsihle.h"
9	9	#include "harddisk.h"
10	10	#include "imagedev/harddriv.h"
11	11	#include "scsihd.h"
r18278	r18279
14	14	const device_type SCSIHD = &device_creator<scsihd_device>;
15	15
16	16	scsihd_device::scsihd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
17		: scsidev_device(mconfig, SCSIHD, "SCSIHD", tag, owner, clock)
	17	: scsihle_device(mconfig, SCSIHD, "SCSIHD", tag, owner, clock)
18	18	{
19	19	}
20	20
21	21	scsihd_device::scsihd_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) :
22		scsidev_device(mconfig, type, name, tag, owner, clock)
	22	scsihle_device(mconfig, type, name, tag, owner, clock)
23	23	{
24	24	}
25	25
r18278	r18279
31	31
32	32	void scsihd_device::device_reset()
33	33	{
34		scsidev_device::device_reset();
	34	scsihle_device::device_reset();
35	35
36	36	is_image_device = true;
37	37	disk = subdevice<harddisk_image_device>("image")->get_hard_disk_file();
r18278	r18279
174	174	break;
175	175
176	176	default:
177		scsidev_device::ExecCommand( transferLength );
	177	scsihle_device::ExecCommand( transferLength );
178	178	break;
179	179	}
180	180	}
r18278	r18279
272	272	break;
273	273
274	274	default:
275		scsidev_device::ReadData( data, dataLength );
	275	scsihle_device::ReadData( data, dataLength );
276	276	break;
277	277	}
278	278	}
r18278	r18279
309	309	break;
310	310
311	311	default:
312		scsidev_device::WriteData( data, dataLength );
	312	scsihle_device::WriteData( data, dataLength );
313	313	break;
314	314	}
315	315	}

trunk/src/emu/machine/scsihd.h

r18278	r18279
7	7	#ifndef _SCSIHD_H_
8	8	#define _SCSIHD_H_
9	9
10		#include "machine/scsidev.h"
	10	#include "machine/scsihle.h"
11	11	#include "harddisk.h"
12	12
13		class scsihd_device : public scsidev_device
	13	class scsihd_device : public scsihle_device
14	14	{
15	15	public:
16	16	// construction/destruction

trunk/src/emu/machine/scsicd.c

r18278	r18279
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "scsidev.h"
	8	#include "machine/scsihle.h"
9	9	#include "cdrom.h"
10	10	#include "sound/cdda.h"
11	11	#include "imagedev/chd_cd.h"
r18278	r18279
23	23	const device_type SCSICD = &device_creator<scsicd_device>;
24	24
25	25	scsicd_device::scsicd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
26		: scsidev_device(mconfig, SCSICD, "SCSICD", tag, owner, clock)
	26	: scsihle_device(mconfig, SCSICD, "SCSICD", tag, owner, clock)
27	27	{
28	28	}
29	29
30	30	scsicd_device::scsicd_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) :
31		scsidev_device(mconfig, type, name, tag, owner, clock)
	31	scsihle_device(mconfig, type, name, tag, owner, clock)
32	32	{
33	33	}
34	34
r18278	r18279
45	45
46	46	void scsicd_device::device_reset()
47	47	{
48		scsidev_device::device_reset();
	48	scsihle_device::device_reset();
49	49
50	50	is_file = TRUE;
51	51	cdrom = subdevice<cdrom_image_device>("image")->get_cdrom_file();
r18278	r18279
375	375	break;
376	376
377	377	default:
378		scsidev_device::ExecCommand( transferLength );
	378	scsihle_device::ExecCommand( transferLength );
379	379	}
380	380	}
381	381
r18278	r18279
711	711	break;
712	712
713	713	default:
714		scsidev_device::ReadData( data, dataLength );
	714	scsihle_device::ReadData( data, dataLength );
715	715	break;
716	716	}
717	717	}
r18278	r18279
759	759	break;
760	760
761	761	default:
762		scsidev_device::WriteData( data, dataLength );
	762	scsihle_device::WriteData( data, dataLength );
763	763	break;
764	764	}
765	765	}

trunk/src/emu/machine/scsicd.h

r18278	r18279
7	7	#ifndef _SCSICD_H_
8	8	#define _SCSICD_H_
9	9
10		#include "machine/scsidev.h"
	10	#include "machine/scsihle.h"
11	11	#include "cdrom.h"
12	12
13		class scsicd_device : public scsidev_device
	13	class scsicd_device : public scsihle_device
14	14	{
15	15	public:
16	16	// construction/destruction

trunk/src/emu/machine/53c810.c

r18278	r18279
2	2
3	3	#include "emu.h"
4	4	#include "53c810.h"
5		#include "machine/scsidev.h"
	5	#include "machine/scsihle.h"
6	6
7	7	#define DMA_MAX_ICOUNT   512      /* Maximum number of DMA Scripts opcodes to run */
8	8	#define DASM_OPCODES 0
r18278	r18279
664	664	// try to open the devices
665	665	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
666	666	{
667		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	667	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
668	668	if( scsidev != NULL )
669	669	{
670	670	devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/emu/machine/53c810.h

r18278	r18279
1	1	#ifndef LSI53C810_H
2	2	#define LSI53C810_H
3	3
4		#include "scsidev.h"
	4	#include "machine/scsihle.h"
5	5
6	6	struct LSI53C810interface
7	7	{
r18278	r18279
62	62	UINT32 lsi53c810_dasm_fetch(UINT32 pc);
63	63	unsigned lsi53c810_dasm(char *buf, UINT32 pc);
64	64
65		scsidev_device *devices[8];   /* SCSI IDs 0-7 */
	65	scsihle_device *devices[8];   /* SCSI IDs 0-7 */
66	66	UINT8 last_id;
67	67
68	68	UINT8 scntl0;

trunk/src/emu/machine/scsibus.c

r18278	r18279
8	8	*/
9	9
10	10	#include "emu.h"
11		#include "machine/scsidev.h"
	11	#include "machine/scsihle.h"
12	12	#include "machine/scsibus.h"
13	13	#include "debugger.h"
14	14	#include "debug/debugcpu.h"
r18278	r18279
685	685
686	686	for( device_t *device = first_subdevice(); device != NULL; device = device->next() )
687	687	{
688		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	688	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
689	689	if( scsidev != NULL )
690	690	{
691	691	devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/emu/machine/scsibus.h

r18278	r18279
9	9	#define _SCSIBUS_H_
10	10
11	11	#include "machine/scsicb.h"
12		#include "machine/scsidev.h"
	12	#include "machine/scsihle.h"
13	13
14	14
15	15	/***************************************************************************
r18278	r18279
141	141	void dump_data_bytes(int count);
142	142	void dump_bytes(UINT8 *buff, int count);
143	143
144		scsidev_device          *devices[8];
	144	scsihle_device          *devices[8];
145	145	scsicb_device *m_scsicb;
146	146
147	147	UINT8       linestate;

trunk/src/emu/machine/scsihle.c

r0	r18279
	1	/***************************************************************************
	2
	3	scsidev.c - Base class for scsi devices.
	4
	5	***************************************************************************/
	6
	7	#include "emu.h"
	8	#include "machine/scsihle.h"
	9
	10	scsihle_device::scsihle_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) :
	11	device_t(mconfig, type, name, tag, owner, clock)
	12	{
	13	}
	14
	15	void scsihle_device::device_start()
	16	{
	17	save_item( NAME( command ) );
	18	save_item( NAME( commandLength ) );
	19	save_item( NAME( phase ) );
	20	}
	21
	22	#define SCSI_SENSE_SIZE            4
	23
	24	void scsihle_device::ExecCommand( int *transferLength )
	25	{
	26	UINT8 *command;
	27	int commandLength;
	28	GetCommand( &command, &commandLength );
	29
	30	switch( command[ 0 ] )
	31	{
	32	case SCSI_CMD_TEST_UNIT_READY:
	33	SetPhase( SCSI_PHASE_STATUS );
	34	*transferLength = 0;
	35	break;
	36
	37	case SCSI_CMD_RECALIBRATE:
	38	SetPhase( SCSI_PHASE_STATUS );
	39	*transferLength = 0;
	40	break;
	41
	42	case SCSI_CMD_REQUEST_SENSE:
	43	SetPhase( SCSI_PHASE_DATAOUT );
	44	*transferLength = SCSI_SENSE_SIZE;
	45	break;
	46
	47	case SCSI_CMD_SEND_DIAGNOSTIC:
	48	SetPhase( SCSI_PHASE_DATAOUT );
	49	*transferLength = ( command[ 3 ] << 8 ) + command[ 4 ];
	50	break;
	51
	52	default:
	53	logerror( "%s: SCSIDEV unknown command %02x\n", machine().describe_context(), command[ 0 ] );
	54	*transferLength = 0;
	55	break;
	56	}
	57	}
	58
	59	void scsihle_device::ReadData( UINT8 *data, int dataLength )
	60	{
	61	UINT8 *command;
	62	int commandLength;
	63	GetCommand( &command, &commandLength );
	64
	65	switch( command[ 0 ] )
	66	{
	67	case SCSI_CMD_REQUEST_SENSE:
	68	data[ 0 ] = SCSI_SENSE_NO_SENSE;
	69	data[ 1 ] = 0x00;
	70	data[ 2 ] = 0x00;
	71	data[ 3 ] = 0x00;
	72	break;
	73	default:
	74	logerror( "%s: SCSIDEV unknown read %02x\n", machine().describe_context(), command[ 0 ] );
	75	break;
	76	}
	77	}
	78
	79	void scsihle_device::WriteData( UINT8 *data, int dataLength )
	80	{
	81	UINT8 *command;
	82	int commandLength;
	83	GetCommand( &command, &commandLength );
	84
	85	switch( command[ 0 ] )
	86	{
	87	case SCSI_CMD_SEND_DIAGNOSTIC:
	88	break;
	89
	90	default:
	91	logerror( "%s: SCSIDEV unknown write %02x\n", machine().describe_context(), command[ 0 ] );
	92	break;
	93	}
	94	}
	95
	96	void scsihle_device::SetPhase( int _phase )
	97	{
	98	phase = _phase;
	99	}
	100
	101	void scsihle_device::GetPhase( int *_phase)
	102	{
	103	*_phase = phase;
	104	}
	105
	106	void scsihle_device::SetCommand( UINT8 *_command, int _commandLength )
	107	{
	108	if( _commandLength > sizeof( command ) )
	109	{
	110	/// TODO: output an error.
	111	return;
	112	}
	113
	114	memcpy( command, _command, _commandLength );
	115	commandLength = _commandLength;
	116
	117	SetPhase( SCSI_PHASE_COMMAND );
	118	}
	119
	120	void scsihle_device::GetCommand( UINT8 **_command, int *_commandLength )
	121	{
	122	*_command = command;
	123	*_commandLength = commandLength;
	124	}
	125
	126	int scsihle_device::GetDeviceID()
	127	{
	128	return scsiID;
	129	}
	130
	131	int scsihle_device::GetSectorBytes()
	132	{
	133	return 0;
	134	}
	135
	136	void scsihle_device::static_set_deviceid( device_t &device, int _scsiID )
	137	{
	138	scsihle_device &scsidev = downcast<scsihle_device &>(device);
	139	scsidev.scsiID = _scsiID;
	140	}
	141
	142	int SCSILengthFromUINT8( UINT8 *length )
	143	{
	144	if( *length == 0 )
	145	{
	146	return 256;
	147	}
	148
	149	return *length;
	150	}
	151
	152	int SCSILengthFromUINT16( UINT8 *length )
	153	{
	154	return ( *(length) << 8 ) | *(length + 1 );
	155	}

trunk/src/emu/machine/scsihle.h

r0	r18279
	1	/***************************************************************************
	2
	3	scsidev.h
	4
	5	***************************************************************************/
	6
	7	#ifndef _SCSIDEV_H_
	8	#define _SCSIDEV_H_
	9
	10	// base handler
	11	class scsihle_device : public device_t
	12	{
	13	public:
	14	// construction/destruction
	15	scsihle_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	16
	17	virtual void SetDevice( void *device ) = 0;
	18	virtual void GetDevice( void **device ) = 0;
	19	virtual void SetCommand( UINT8 *command, int commandLength );
	20	virtual void GetCommand( UINT8 **command, int *commandLength );
	21	virtual void ExecCommand( int *transferLength );
	22	virtual void WriteData( UINT8 *data, int dataLength );
	23	virtual void ReadData( UINT8 *data, int dataLength );
	24	virtual void SetPhase( int phase );
	25	virtual void GetPhase( int *phase );
	26	virtual int GetDeviceID();
	27	virtual int GetSectorBytes();
	28
	29	// configuration helpers
	30	static void static_set_deviceid(device_t &device, int _scsiID);
	31
	32	protected:
	33	// device-level overrides
	34	virtual void device_start();
	35
	36	private:
	37	UINT8 command[16];
	38	int commandLength;
	39	int phase;
	40	int scsiID;
	41	};
	42
	43	extern int SCSILengthFromUINT8( UINT8 *length );
	44	extern int SCSILengthFromUINT16( UINT8 *length );
	45
	46	#define SCSI_PHASE_DATAOUT ( 0 )
	47	#define SCSI_PHASE_DATAIN ( 1 )
	48	#define SCSI_PHASE_COMMAND ( 2 )
	49	#define SCSI_PHASE_STATUS ( 3 )
	50	#define SCSI_PHASE_MESSAGE_OUT ( 6 )
	51	#define SCSI_PHASE_MESSAGE_IN ( 7 )
	52
	53	#define SCSI_CMD_TEST_UNIT_READY ( 0x00 )
	54	#define SCSI_CMD_RECALIBRATE ( 0x01 )
	55	#define SCSI_CMD_REQUEST_SENSE ( 0x03 )
	56	#define SCSI_CMD_MODE_SELECT ( 0x15 )
	57	#define SCSI_CMD_SEND_DIAGNOSTIC ( 0x1d )
	58
	59	//
	60	// Status / Sense data taken from Adaptec ACB40x0 documentation.
	61	//
	62
	63	#define SCSI_STATUS_OK            0x00
	64	#define SCSI_STATUS_CHECK         0x02
	65	#define SCSI_STATUS_EQUAL         0x04
	66	#define SCSI_STATUS_BUSY         0x08
	67
	68	#define SCSI_SENSE_ADDR_VALID      0x80
	69	#define SCSI_SENSE_NO_SENSE         0x00
	70	#define SCSI_SENSE_NO_INDEX         0x01
	71	#define SCSI_SENSE_SEEK_NOT_COMP   0x02
	72	#define SCSI_SENSE_WRITE_FAULT      0x03
	73	#define SCSI_SENSE_DRIVE_NOT_READY   0x04
	74	#define SCSI_SENSE_NO_TRACK0      0x06
	75	#define SCSI_SENSE_ID_CRC_ERROR      0x10
	76	#define SCSI_SENSE_UNCORRECTABLE   0x11
	77	#define SCSI_SENSE_ADDRESS_NF      0x12
	78	#define SCSI_SENSE_RECORD_NOT_FOUND   0x14
	79	#define SCSI_SENSE_SEEK_ERROR      0x15
	80	#define SCSI_SENSE_DATA_CHECK_RETRY   0x18
	81	#define SCSI_SENSE_ECC_VERIFY      0x19
	82	#define SCSI_SENSE_INTERLEAVE_ERROR   0x1A
	83	#define SCSI_SENSE_UNFORMATTED      0x1C
	84	#define SCSI_SENSE_ILLEGAL_COMMAND   0x20
	85	#define SCSI_SENSE_ILLEGAL_ADDRESS   0x21
	86	#define SCSI_SENSE_VOLUME_OVERFLOW   0x23
	87	#define SCSI_SENSE_BAD_ARGUMENT      0x24
	88	#define SCSI_SENSE_INVALID_LUN      0x25
	89	#define SCSI_SENSE_CART_CHANGED      0x28
	90	#define SCSI_SENSE_ERROR_OVERFLOW   0x2C
	91
	92	// SCSI IDs
	93	enum
	94	{
	95	SCSI_ID_0 = 0,
	96	SCSI_ID_1,
	97	SCSI_ID_2,
	98	SCSI_ID_3,
	99	SCSI_ID_4,
	100	SCSI_ID_5,
	101	SCSI_ID_6,
	102	SCSI_ID_7
	103	};
	104
	105	#define MCFG_SCSIDEV_ADD(_tag, _type, _id) \
	106	MCFG_DEVICE_ADD(_tag, _type, 0) \
	107	scsihle_device::static_set_deviceid(*device, _id);
	108
	109	#endif

trunk/src/emu/machine/wd33c93.c

r18278	r18279
762	762	// try to open the devices
763	763	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
764	764	{
765		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	765	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
766	766	if( scsidev != NULL )
767	767	{
768	768	devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/emu/machine/wd33c93.h

r18278	r18279
6	6	#ifndef _WD33C93_H_
7	7	#define _WD33C93_H_
8	8
9		#include "scsidev.h"
	9	#include "machine/scsihle.h"
10	10
11	11	struct WD33C93interface
12	12	{
r18278	r18279
93	93	void xferinfo_cmd();
94	94	void dispatch_command();
95	95
96		scsidev_device *devices[8];   // SCSI IDs 0-7
	96	scsihle_device *devices[8];   // SCSI IDs 0-7
97	97
98	98	UINT8      sasr;
99	99	UINT8      regs[WD_AUXILIARY_STATUS+1];

trunk/src/emu/machine/ncr539x.c

r18278	r18279
157	157	// try to open the devices
158	158	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
159	159	{
160		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	160	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
161	161	if( scsidev != NULL )
162	162	{
163	163	m_scsi_devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/emu/machine/ncr539x.h

r18278	r18279
6	6	#ifndef _NCR539x_H_
7	7	#define _NCR539x_H_
8	8
9		#include "machine/scsidev.h"
	9	#include "machine/scsihle.h"
10	10
11	11	struct NCR539Xinterface
12	12	{
r18278	r18279
51	51	void exec_fifo();
52	52	void update_fifo_internal_state(int bytes);
53	53
54		scsidev_device *m_scsi_devices[8];
	54	scsihle_device *m_scsi_devices[8];
55	55
56	56	UINT32 m_xfer_count;
57	57	UINT32 m_dma_size;

trunk/src/mess/machine/fm_scsi.c

r18278	r18279
75	75	// try to open the devices
76	76	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
77	77	{
78		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	78	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
79	79	if( scsidev != NULL )
80	80	{
81	81	m_SCSIdevices[scsidev->GetDeviceID()] = scsidev;

trunk/src/mess/machine/fm_scsi.h

r18278	r18279
8	8	#ifndef FM_SCSI_H_
9	9	#define FM_SCSI_H_
10	10
11		#include "machine/scsidev.h"
	11	#include "machine/scsihle.h"
12	12
13	13	// SCSI input lines (from target)
14	14	#define FMSCSI_LINE_REQ   0x80
r18278	r18279
83	83	devcb_resolved_write_line m_irq_func;
84	84	devcb_resolved_write_line m_drq_func;
85	85
86		scsidev_device* m_SCSIdevices[8];
	86	scsihle_device* m_SCSIdevices[8];
87	87	UINT8 m_command[32];
88	88	UINT8 m_result[32];
89	89	UINT8 m_command_index;

trunk/src/mess/machine/ncr5380.c

r18278	r18279
124	124	// try to open the devices
125	125	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
126	126	{
127		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	127	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
128	128	if( scsidev != NULL )
129	129	{
130	130	m_scsi_devices[scsidev->GetDeviceID()] = scsidev;

trunk/src/mess/machine/ncr5380.h

r18278	r18279
6	6	#ifndef _NCR5380_H_
7	7	#define _NCR5380_H_
8	8
9		#include "machine/scsidev.h"
	9	#include "machine/scsihle.h"
10	10
11	11	struct NCR5380interface
12	12	{
r18278	r18279
62	62	virtual void device_config_complete();
63	63
64	64	private:
65		scsidev_device *m_scsi_devices[8];
	65	scsihle_device *m_scsi_devices[8];
66	66
67	67	UINT8 m_5380_Registers[8];
68	68	UINT8 m_last_id;

trunk/src/mess/machine/mb89352.c

r18278	r18279
157	157	// try to open the devices
158	158	for( device_t *device = owner()->first_subdevice(); device != NULL; device = device->next() )
159	159	{
160		scsidev_device *scsidev = dynamic_cast<scsidev_device *>(device);
	160	scsihle_device *scsidev = dynamic_cast<scsihle_device *>(device);
161	161	if( scsidev != NULL )
162	162	{
163	163	m_SCSIdevices[scsidev->GetDeviceID()] = scsidev;

trunk/src/mess/machine/mb89352.h

r18278	r18279
7	7	#ifndef MB89352_H_
8	8	#define MB89352_H_
9	9
10		#include "machine/scsidev.h"
	10	#include "machine/scsihle.h"
11	11
12	12	// SCSI lines readable via PSNS register (reg 5)
13	13	#define MB89352_LINE_REQ 0x80
r18278	r18279
94	94	devcb_resolved_write_line m_irq_func;
95	95	devcb_resolved_write_line m_drq_func;
96	96
97		scsidev_device* m_SCSIdevices[8];
	97	scsihle_device* m_SCSIdevices[8];
98	98
99	99	UINT8 m_phase;  // current SCSI phase
100	100	UINT8 m_target; // current SCSI target

trunk/src/mame/drivers/firebeat.c

r18278	r18279
158	158	int m_tick;
159	159	int m_layer;
160	160	UINT8 m_atapi_regs[16];
161		scsidev_device *m_atapi_device_data[2];
	161	scsihle_device *m_atapi_device_data[2];
162	162	UINT16 m_atapi_data[32*1024];
163	163	UINT8 m_atapi_scsi_packet[32*1024];
164	164	int m_atapi_data_ptr;
r18278	r18279
962	962	state->m_atapi_data_ptr = 0;
963	963	state->m_atapi_cdata_wait = 0;
964	964
965		state->m_atapi_device_data[0] = machine.device<scsidev_device>( "scsi0" );
966		state->m_atapi_device_data[1] = machine.device<scsidev_device>( "scsi1" );
	965	state->m_atapi_device_data[0] = machine.device<scsihle_device>( "scsi0" );
	966	state->m_atapi_device_data[1] = machine.device<scsihle_device>( "scsi1" );
967	967	}
968	968
969	969	static void atapi_reset(running_machine &machine)

trunk/src/mame/drivers/twinkle.c

r18278	r18279
875	875	{
876	876	/* also hook up CDDA audio to the CD-ROM drive */
877	877	void *cdrom;
878		scsidev_device *scsidev = machine().device<scsidev_device>("scsi:cdrom");
	878	scsihle_device *scsidev = machine().device<scsihle_device>("scsi:cdrom");
879	879	scsidev->GetDevice( &cdrom );
880	880	cdda_set_cdrom(machine().device("cdda"), cdrom);
881	881	}

trunk/src/mame/drivers/konamigv.c

r18278	r18279
323	323	{
324	324	/* also hook up CDDA audio to the CD-ROM drive */
325	325	void *cdrom;
326		scsidev_device *scsidev = machine().device<scsidev_device>("scsi:cdrom");
	326	scsihle_device *scsidev = machine().device<scsihle_device>("scsi:cdrom");
327	327	scsidev->GetDevice( &cdrom );
328	328	cdda_set_cdrom(machine().device("cdda"), cdrom);
329	329	}

trunk/src/mame/drivers/ksys573.c

r18278	r18279
488	488	UINT32 m_control;
489	489
490	490	emu_timer *m_atapi_timer;
491		scsidev_device *m_inserted_cdrom;
492		scsidev_device *m_available_cdroms[ 2 ];
	491	scsihle_device *m_inserted_cdrom;
	492	scsihle_device *m_available_cdroms[ 2 ];
493	493	int m_atapi_data_ptr;
494	494	int m_atapi_data_len;
495	495	int m_atapi_xferlen;
r18278	r18279
1134	1134	state->m_atapi_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(ksys573_state::atapi_xfer_end),state));
1135	1135	state->m_atapi_timer->adjust(attotime::never);
1136	1136
1137		state->m_available_cdroms[ 0 ] = machine.device<scsidev_device>( ":cdrom0" );
	1137	state->m_available_cdroms[ 0 ] = machine.device<scsihle_device>( ":cdrom0" );
1138	1138	if( get_disk_handle( machine, ":cdrom1" ) != NULL )
1139	1139	{
1140		state->m_available_cdroms[ 1 ] = machine.device<scsidev_device>( ":cdrom1" );
	1140	state->m_available_cdroms[ 1 ] = machine.device<scsihle_device>( ":cdrom1" );
1141	1141	}
1142	1142	else
1143	1143	{
r18278	r18279
1365	1365	ksys573_state *state = machine.driver_data<ksys573_state>();
1366	1366	int cart = state->ioport("CART")->read();
1367	1367	int cd = state->ioport( "CD" )->read();
1368		scsidev_device *new_cdrom;
	1368	scsihle_device *new_cdrom;
1369	1369
1370	1370	if( state->machine().device<device_secure_serial_flash>("game_eeprom") )
1371	1371	{

trunk/src/mame/machine/gdrom.c

r18278	r18279
5	5	***************************************************************************/
6	6
7	7	#include "emu.h"
8		#include "machine/scsidev.h"
	8	#include "machine/scsihle.h"
9	9	#include "cdrom.h"
10	10	#include "sound/cdda.h"
11	11	#include "imagedev/chd_cd.h"
r18278	r18279
29	29	const device_type GDROM = &device_creator<gdrom_device>;
30	30
31	31	gdrom_device::gdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
32		: scsidev_device(mconfig, GDROM, "GDROM", tag, owner, clock)
	32	: scsihle_device(mconfig, GDROM, "GDROM", tag, owner, clock)
33	33	{
34	34	}
35	35
r18278	r18279
46	46
47	47	void gdrom_device::device_reset()
48	48	{
49		scsidev_device::device_reset();
	49	scsihle_device::device_reset();
50	50
51	51	is_file = TRUE;
52	52	cdrom = subdevice<cdrom_image_device>("image")->get_cdrom_file();
r18278	r18279
434	434	break;
435	435
436	436	default:
437		scsidev_device::ExecCommand( transferLength );
	437	scsihle_device::ExecCommand( transferLength );
438	438	break;
439	439	}
440	440	}
r18278	r18279
786	786	break;
787	787
788	788	default:
789		scsidev_device::ReadData( data, dataLength );
	789	scsihle_device::ReadData( data, dataLength );
790	790	break;
791	791	}
792	792	}
r18278	r18279
834	834	break;
835	835
836	836	default:
837		scsidev_device::WriteData( data, dataLength );
	837	scsihle_device::WriteData( data, dataLength );
838	838	break;
839	839	}
840	840	}

trunk/src/mame/machine/gdrom.h

r18278	r18279
7	7	#ifndef _GDROM_H_
8	8	#define _GDROM_H_
9	9
10		#include "machine/scsidev.h"
	10	#include "machine/scsihle.h"
11	11
12	12	// Sega GD-ROM handler
13		class gdrom_device : public scsidev_device
	13	class gdrom_device : public scsihle_device
14	14	{
15	15	public:
16	16	// construction/destruction

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team