Previous

199869 Revisions

Next

r26281 Tuesday 19th November, 2013 at 17:30:35 UTC by smf
fixed compiling with MSVC, added enums for T10 commands, moved seek(6) from 2410 to t10sbc (nw)

[src/emu]	diserial.h
[src/emu/machine]	nscsi_s1410.c t10mmc.c t10mmc.h t10sbc.c t10sbc.h t10spc.c t10spc.h
[src/mame/machine]	gdrom.c
[src/mess/machine]	acb4070.c s1410.c

trunk/src/mame/machine/gdrom.c

r26280	r26281
137	137	}
138	138	else
139	139	{
140		lba = (command[2]<<16 | command[3]<<8 | command[4]) - 150;
141		blocks = command[8]<<16 | command[9]<<8 | command[10];
	140	m_lba = (command[2]<<16 | command[3]<<8 | command[4]) - 150;
	141	m_blocks = command[8]<<16 | command[9]<<8 | command[10];
142	142
143	143	read_type = (command[1] >> 1) & 7;
144	144	data_select = (command[1]>>4) & 0xf;
r26280	r26281
153	153	fatalerror("GDROM: Unhandled data_select %d\n", data_select);
154	154	}
155	155
156		printf("GDROM: CD_READ at LBA %x for %d blocks (%d bytes, read type %d, data select %d)\n", lba, blocks, blocks * m_sector_bytes, read_type, data_select);
	156	printf("GDROM: CD_READ at LBA %x for %d blocks (%d bytes, read type %d, data select %d)\n", m_lba, m_blocks, m_blocks * m_sector_bytes, read_type, data_select);
157	157
158		if (num_subblocks > 1)
	158	if (m_num_subblocks > 1)
159	159	{
160		cur_subblock = lba % num_subblocks;
161		lba /= num_subblocks;
	160	m_cur_subblock = m_lba % m_num_subblocks;
	161	m_lba /= m_num_subblocks;
162	162	}
163	163	else
164	164	{
165		cur_subblock = 0;
	165	m_cur_subblock = 0;
166	166	}
167	167
168	168	if (m_cdda != NULL)
r26280	r26281
172	172
173	173	m_phase = SCSI_PHASE_DATAIN;
174	174	m_status_code = SCSI_STATUS_CODE_GOOD;
175		m_transfer_length = blocks * m_sector_bytes;
	175	m_transfer_length = m_blocks * m_sector_bytes;
176	176	}
177	177	break;
178	178
r26280	r26281
180	180	case 0x14:
181	181	{
182	182	int start_trk = command[2];// ok?
183		int end_trk = cdrom_get_last_track(cdrom);
	183	int end_trk = cdrom_get_last_track(m_cdrom);
184	184	int length;
185	185	int allocation_length = SCSILengthFromUINT16( &command[ 3 ] );
186	186
r26280	r26281
263	263
264	264	case 0x30: // CD_READ
265	265	logerror("GDROM: read %x dataLength, \n", dataLength);
266		if ((cdrom) && (blocks))
	266	if ((m_cdrom) && (m_blocks))
267	267	{
268	268	while (dataLength > 0)
269	269	{
270		if (!cdrom_read_data(cdrom, lba, tmp_buffer, CD_TRACK_MODE1))
	270	if (!cdrom_read_data(m_cdrom, m_lba, tmp_buffer, CD_TRACK_MODE1))
271	271	{
272	272	logerror("GDROM: CD read error!\n");
273	273	}
274	274
275		logerror("True LBA: %d, buffer half: %d\n", lba, cur_subblock * m_sector_bytes);
	275	logerror("True LBA: %d, buffer half: %d\n", m_lba, m_cur_subblock * m_sector_bytes);
276	276
277		memcpy(data, &tmp_buffer[cur_subblock * m_sector_bytes], m_sector_bytes);
	277	memcpy(data, &tmp_buffer[m_cur_subblock * m_sector_bytes], m_sector_bytes);
278	278
279		cur_subblock++;
280		if (cur_subblock >= num_subblocks)
	279	m_cur_subblock++;
	280	if (m_cur_subblock >= m_num_subblocks)
281	281	{
282		cur_subblock = 0;
	282	m_cur_subblock = 0;
283	283
284		lba++;
285		blocks--;
	284	m_lba++;
	285	m_blocks--;
286	286	}
287	287
288		last_lba = lba;
	288	m_last_lba = m_lba;
289	289	dataLength -= m_sector_bytes;
290	290	data += m_sector_bytes;
291	291	}
r26280	r26281
317	317	start_trk = 1;
318	318	}
319	319
320		end_trk = cdrom_get_last_track(cdrom);
	320	end_trk = cdrom_get_last_track(m_cdrom);
321	321	len = (end_trk * 8) + 2;
322	322
323	323	// the returned TOC DATA LENGTH must be the full amount,
r26280	r26281
349	349	}
350	350
351	351	data[dptr++] = 0;
352		data[dptr++] = cdrom_get_adr_control(cdrom, cdrom_track);
	352	data[dptr++] = cdrom_get_adr_control(m_cdrom, cdrom_track);
353	353	data[dptr++] = i;
354	354	data[dptr++] = 0;
355	355
356		tstart = cdrom_get_track_start(cdrom, cdrom_track);
	356	tstart = cdrom_get_track_start(m_cdrom, cdrom_track);
357	357	if ((command[1]&2)>>1)
358	358	tstart = lba_to_msf(tstart);
359	359	data[dptr++] = (tstart>>24) & 0xff;

trunk/src/emu/machine/t10mmc.c

r26280	r26281
13	13	{
14	14	t10spc::t10_start(device);
15	15
16		device.save_item(NAME(lba));
17		device.save_item(NAME(blocks));
18		device.save_item(NAME(last_lba));
19		device.save_item(NAME(num_subblocks));
20		device.save_item(NAME(cur_subblock));
	16	device.save_item(NAME(m_lba));
	17	device.save_item(NAME(m_blocks));
	18	device.save_item(NAME(m_last_lba));
	19	device.save_item(NAME(m_num_subblocks));
	20	device.save_item(NAME(m_cur_subblock));
21	21	device.save_item(NAME(m_audio_sense));
22	22	}
23	23
r26280	r26281
26	26	t10spc::t10_reset();
27	27
28	28	SetDevice( m_image->get_cdrom_file() );
29		if( !cdrom )
	29	if( !m_cdrom )
30	30	{
31	31	logerror( "T10MMC %s: no CD found!\n", m_image->tag() );
32	32	}
33	33
34		lba = 0;
35		blocks = 0;
36		last_lba = 0;
	34	m_lba = 0;
	35	m_blocks = 0;
	36	m_last_lba = 0;
37	37	m_sector_bytes = 2048;
38		num_subblocks = 1;
39		cur_subblock = 0;
	38	m_num_subblocks = 1;
	39	m_cur_subblock = 0;
40	40	m_audio_sense = 0;
41	41	}
42	42
r26280	r26281
66	66	int t10mmc::toc_tracks()
67	67	{
68	68	int start_track = command[6];
69		int end_track = cdrom_get_last_track(cdrom);
	69	int end_track = cdrom_get_last_track(m_cdrom);
70	70
71	71	if (start_track == 0)
72	72	{
r26280	r26281
92	92	int trk;
93	93
94	94	// keep updating the sense data while playing audio.
95		if (command[0] == SCSI_CMD_REQUEST_SENSE && m_audio_sense != SCSI_SENSE_ASC_ASCQ_NO_SENSE && m_sense_key == SCSI_SENSE_KEY_NO_SENSE && m_sense_asc == 0 && m_sense_ascq == 0)
	95	if (command[0] == T10SPC_CMD_REQUEST_SENSE && m_audio_sense != SCSI_SENSE_ASC_ASCQ_NO_SENSE && m_sense_key == SCSI_SENSE_KEY_NO_SENSE && m_sense_asc == 0 && m_sense_ascq == 0)
96	96	{
97	97	if (m_audio_sense == SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS && !m_cdda->audio_active())
98	98	{
r26280	r26281
109	109
110	110	switch ( command[0] )
111	111	{
112		case 0x12: // INQUIRY
113		logerror("T10MMC: INQUIRY\n");
114		m_phase = SCSI_PHASE_DATAIN;
115		m_status_code = SCSI_STATUS_CODE_GOOD;
116		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
117		if (m_transfer_length > 36)
118		m_transfer_length = 36;
119		break;
	112	case T10SPC_CMD_INQUIRY:
	113	logerror("T10MMC: INQUIRY\n");
	114	m_phase = SCSI_PHASE_DATAIN;
	115	m_status_code = SCSI_STATUS_CODE_GOOD;
	116	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	117	if (m_transfer_length > 36)
	118	m_transfer_length = 36;
	119	break;
120	120
121		case 0x15: // MODE SELECT(6)
122		logerror("T10MMC: MODE SELECT(6) length %x control %x\n", command[4], command[5]);
123		m_phase = SCSI_PHASE_DATAOUT;
124		m_status_code = SCSI_STATUS_CODE_GOOD;
125		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
126		break;
	121	case T10SPC_CMD_MODE_SELECT_6:
	122	logerror("T10MMC: MODE SELECT(6) length %x control %x\n", command[4], command[5]);
	123	m_phase = SCSI_PHASE_DATAOUT;
	124	m_status_code = SCSI_STATUS_CODE_GOOD;
	125	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	126	break;
127	127
128		case 0x1a: // MODE SENSE(6)
129		m_phase = SCSI_PHASE_DATAIN;
130		m_status_code = SCSI_STATUS_CODE_GOOD;
131		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
132		break;
	128	case T10SPC_CMD_MODE_SENSE_6:
	129	m_phase = SCSI_PHASE_DATAIN;
	130	m_status_code = SCSI_STATUS_CODE_GOOD;
	131	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	132	break;
133	133
134		case 0x1b: // START STOP UNIT
135		abort_audio();
136		m_phase = SCSI_PHASE_STATUS;
137		m_status_code = SCSI_STATUS_CODE_GOOD;
138		m_transfer_length = 0;
139		break;
	134	case T10SPC_CMD_START_STOP_UNIT:
	135	abort_audio();
	136	m_phase = SCSI_PHASE_STATUS;
	137	m_status_code = SCSI_STATUS_CODE_GOOD;
	138	m_transfer_length = 0;
	139	break;
140	140
141		case 0x1e: // PREVENT ALLOW MEDIUM REMOVAL
142		m_phase = SCSI_PHASE_STATUS;
143		m_status_code = SCSI_STATUS_CODE_GOOD;
144		m_transfer_length = 0;
145		break;
	141	case T10SPC_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
	142	m_phase = SCSI_PHASE_STATUS;
	143	m_status_code = SCSI_STATUS_CODE_GOOD;
	144	m_transfer_length = 0;
	145	break;
146	146
147		case 0x25: // READ CAPACITY
148		m_phase = SCSI_PHASE_DATAIN;
149		m_status_code = SCSI_STATUS_CODE_GOOD;
150		m_transfer_length = 8;
151		break;
	147	case T10SBC_CMD_READ_CAPACITY:
	148	m_phase = SCSI_PHASE_DATAIN;
	149	m_status_code = SCSI_STATUS_CODE_GOOD;
	150	m_transfer_length = 8;
	151	break;
152	152
153		case 0x28: // READ(10)
	153	case T10SBC_CMD_READ_10:
	154	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	155	m_blocks = SCSILengthFromUINT16( &command[7] );
154	156
155		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
156		blocks = SCSILengthFromUINT16( &command[7] );
	157	logerror("T10MMC: READ(10) at LBA %x for %d blocks (%d bytes)\n", m_lba, m_blocks, m_blocks * m_sector_bytes);
157	158
158		logerror("T10MMC: READ(10) at LBA %x for %d blocks (%d bytes)\n", lba, blocks, blocks * m_sector_bytes);
	159	if (m_num_subblocks > 1)
	160	{
	161	m_cur_subblock = m_lba % m_num_subblocks;
	162	m_lba /= m_num_subblocks;
	163	}
	164	else
	165	{
	166	m_cur_subblock = 0;
	167	}
159	168
160		if (num_subblocks > 1)
161		{
162		cur_subblock = lba % num_subblocks;
163		lba /= num_subblocks;
164		}
165		else
166		{
167		cur_subblock = 0;
168		}
	169	abort_audio();
169	170
170		abort_audio();
	171	m_phase = SCSI_PHASE_DATAIN;
	172	m_status_code = SCSI_STATUS_CODE_GOOD;
	173	m_transfer_length = m_blocks * m_sector_bytes;
	174	break;
171	175
172		m_phase = SCSI_PHASE_DATAIN;
173		m_status_code = SCSI_STATUS_CODE_GOOD;
174		m_transfer_length = blocks * m_sector_bytes;
175		break;
	176	case T10MMC_CMD_READ_SUB_CHANNEL:
	177	//logerror("T10MMC: READ SUB-CHANNEL type %d\n", command[3]);
	178	m_phase = SCSI_PHASE_DATAIN;
	179	m_status_code = SCSI_STATUS_CODE_GOOD;
	180	m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
	181	break;
176	182
177		case 0x42: // READ SUB-CHANNEL
178		//                      logerror("T10MMC: READ SUB-CHANNEL type %d\n", command[3]);
179		m_phase = SCSI_PHASE_DATAIN;
180		m_status_code = SCSI_STATUS_CODE_GOOD;
181		m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
182		break;
	183	case T10MMC_CMD_READ_TOC_PMA_ATIP:
	184	{
	185	int length;
183	186
184		case 0x43: // READ TOC
	187	switch (toc_format())
185	188	{
186		int length;
	189	case TOC_FORMAT_TRACKS:
	190	length = 4 + (8 * toc_tracks());
	191	break;
187	192
188		switch (toc_format())
189		{
190		case TOC_FORMAT_TRACKS:
191		length = 4 + (8 * toc_tracks());
192		break;
	193	case TOC_FORMAT_SESSIONS:
	194	length = 4 + (8 * 1);
	195	break;
193	196
194		case TOC_FORMAT_SESSIONS:
195		length = 4 + (8 * 1);
196		break;
	197	default:
	198	logerror("T10MMC: Unhandled READ TOC format %d\n", toc_format());
	199	length = 0;
	200	break;
	201	}
197	202
198		default:
199		logerror("T10MMC: Unhandled READ TOC format %d\n", toc_format());
200		length = 0;
201		break;
202		}
	203	int allocation_length = SCSILengthFromUINT16( &command[ 7 ] );
203	204
204		int allocation_length = SCSILengthFromUINT16( &command[ 7 ] );
	205	if( length > allocation_length )
	206	{
	207	length = allocation_length;
	208	}
205	209
206		if( length > allocation_length )
207		{
208		length = allocation_length;
209		}
	210	abort_audio();
210	211
211		abort_audio();
	212	m_phase = SCSI_PHASE_DATAIN;
	213	m_status_code = SCSI_STATUS_CODE_GOOD;
	214	m_transfer_length = length;
	215	break;
	216	}
	217	case T10MMC_CMD_PLAY_AUDIO_10:
	218	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	219	m_blocks = SCSILengthFromUINT16( &command[7] );
212	220
213		m_phase = SCSI_PHASE_DATAIN;
214		m_status_code = SCSI_STATUS_CODE_GOOD;
215		m_transfer_length = length;
216		break;
	221	// special cases: lba of 0 means MSF of 00:02:00
	222	if (m_lba == 0)
	223	{
	224	m_lba = 150;
217	225	}
218		case 0x45: // PLAY AUDIO(10)
219		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
220		blocks = SCSILengthFromUINT16( &command[7] );
	226	else if (m_lba == 0xffffffff)
	227	{
	228	logerror("T10MMC: play audio from current not implemented!\n");
	229	}
221	230
222		// special cases: lba of 0 means MSF of 00:02:00
223		if (lba == 0)
224		{
225		lba = 150;
226		}
227		else if (lba == 0xffffffff)
228		{
229		logerror("T10MMC: play audio from current not implemented!\n");
230		}
	231	logerror("T10MMC: PLAY AUDIO(10) at LBA %x for %x blocks\n", m_lba, m_blocks);
231	232
232		logerror("T10MMC: PLAY AUDIO(10) at LBA %x for %x blocks\n", lba, blocks);
	233	trk = cdrom_get_track(m_cdrom, m_lba);
233	234
234		trk = cdrom_get_track(cdrom, lba);
	235	if (cdrom_get_track_type(m_cdrom, trk) == CD_TRACK_AUDIO)
	236	{
	237	m_cdda->start_audio(m_lba, m_blocks);
	238	m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
	239	}
	240	else
	241	{
	242	logerror("T10MMC: track is NOT audio!\n");
	243	set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
	244	}
235	245
236		if (cdrom_get_track_type(cdrom, trk) == CD_TRACK_AUDIO)
237		{
238		m_cdda->start_audio(lba, blocks);
239		m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
240		}
241		else
242		{
243		logerror("T10MMC: track is NOT audio!\n");
244		set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
245		}
	246	m_phase = SCSI_PHASE_STATUS;
	247	m_status_code = SCSI_STATUS_CODE_GOOD;
	248	m_transfer_length = 0;
	249	break;
246	250
247		m_phase = SCSI_PHASE_STATUS;
248		m_status_code = SCSI_STATUS_CODE_GOOD;
249		m_transfer_length = 0;
250		break;
	251	case T10MMC_CMD_PLAY_AUDIO_TRACK_INDEX:
	252	// be careful: tracks here are zero-based, but the SCSI command
	253	// uses the real CD track number which is 1-based!
	254	logerror("T10MMC: PLAY AUDIO T/I: strk %d idx %d etrk %d idx %d frames %d\n", command[4], command[5], command[7], command[8], m_blocks);
	255	m_lba = cdrom_get_track_start(m_cdrom, command[4]-1);
	256	m_blocks = cdrom_get_track_start(m_cdrom, command[7]-1) - m_lba;
	257	if (command[4] > command[7])
	258	{
	259	m_blocks = 0;
	260	}
251	261
252		case 0x48: // PLAY AUDIO TRACK/INDEX
253		// be careful: tracks here are zero-based, but the SCSI command
254		// uses the real CD track number which is 1-based!
255		logerror("T10MMC: PLAY AUDIO T/I: strk %d idx %d etrk %d idx %d frames %d\n", command[4], command[5], command[7], command[8], blocks);
256		lba = cdrom_get_track_start(cdrom, command[4]-1);
257		blocks = cdrom_get_track_start(cdrom, command[7]-1) - lba;
258		if (command[4] > command[7])
259		{
260		blocks = 0;
261		}
	262	if (command[4] == command[7])
	263	{
	264	m_blocks = cdrom_get_track_start(m_cdrom, command[4]) - m_lba;
	265	}
262	266
263		if (command[4] == command[7])
264		{
265		blocks = cdrom_get_track_start(cdrom, command[4]) - lba;
266		}
	267	trk = cdrom_get_track(m_cdrom, m_lba);
267	268
268		trk = cdrom_get_track(cdrom, lba);
	269	if (cdrom_get_track_type(m_cdrom, trk) == CD_TRACK_AUDIO)
	270	{
	271	m_cdda->start_audio(m_lba, m_blocks);
	272	m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
	273	}
	274	else
	275	{
	276	logerror("T10MMC: track is NOT audio!\n");
	277	set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
	278	}
269	279
270		if (cdrom_get_track_type(cdrom, trk) == CD_TRACK_AUDIO)
271		{
272		m_cdda->start_audio(lba, blocks);
273		m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
274		}
275		else
276		{
277		logerror("T10MMC: track is NOT audio!\n");
278		set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
279		}
	280	m_phase = SCSI_PHASE_STATUS;
	281	m_status_code = SCSI_STATUS_CODE_GOOD;
	282	m_transfer_length = 0;
	283	break;
280	284
281		m_phase = SCSI_PHASE_STATUS;
282		m_status_code = SCSI_STATUS_CODE_GOOD;
283		m_transfer_length = 0;
284		break;
	285	case T10MMC_CMD_PAUSE_RESUME:
	286	if (m_cdrom)
	287	{
	288	m_cdda->pause_audio((command[8] & 0x01) ^ 0x01);
	289	}
285	290
286		case 0x4b: // PAUSE/RESUME
287		if (cdrom)
288		{
289		m_cdda->pause_audio((command[8] & 0x01) ^ 0x01);
290		}
	291	logerror("T10MMC: PAUSE/RESUME: %s\n", command[8]&1 ? "RESUME" : "PAUSE");
	292	m_phase = SCSI_PHASE_STATUS;
	293	m_status_code = SCSI_STATUS_CODE_GOOD;
	294	m_transfer_length = 0;
	295	break;
291	296
292		logerror("T10MMC: PAUSE/RESUME: %s\n", command[8]&1 ? "RESUME" : "PAUSE");
293		m_phase = SCSI_PHASE_STATUS;
294		m_status_code = SCSI_STATUS_CODE_GOOD;
295		m_transfer_length = 0;
296		break;
	297	case T10MMC_CMD_STOP_PLAY_SCAN:
	298	abort_audio();
297	299
298		case 0x4e: // STOP
299		abort_audio();
	300	logerror("T10MMC: STOP_PLAY_SCAN\n");
	301	m_phase = SCSI_PHASE_STATUS;
	302	m_status_code = SCSI_STATUS_CODE_GOOD;
	303	m_transfer_length = 0;
	304	break;
300	305
301		logerror("T10MMC: STOP_PLAY_SCAN\n");
302		m_phase = SCSI_PHASE_STATUS;
303		m_status_code = SCSI_STATUS_CODE_GOOD;
304		m_transfer_length = 0;
305		break;
	306	case T10SPC_CMD_MODE_SELECT_10:
	307	logerror("T10MMC: MODE SELECT length %x control %x\n", command[7]<<8 | command[8], command[1]);
	308	m_phase = SCSI_PHASE_DATAOUT;
	309	m_status_code = SCSI_STATUS_CODE_GOOD;
	310	m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
	311	break;
306	312
307		case 0x55: // MODE SELECT(10)
308		logerror("T10MMC: MODE SELECT length %x control %x\n", command[7]<<8 | command[8], command[1]);
309		m_phase = SCSI_PHASE_DATAOUT;
310		m_status_code = SCSI_STATUS_CODE_GOOD;
311		m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
312		break;
	313	case T10SPC_CMD_MODE_SENSE_10:
	314	m_phase = SCSI_PHASE_DATAIN;
	315	m_status_code = SCSI_STATUS_CODE_GOOD;
	316	m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
	317	break;
313	318
314		case 0x5a: // MODE SENSE(10)
315		m_phase = SCSI_PHASE_DATAIN;
316		m_status_code = SCSI_STATUS_CODE_GOOD;
317		m_transfer_length = SCSILengthFromUINT16( &command[ 7 ] );
318		break;
	319	case T10MMC_CMD_PLAY_AUDIO_12:
	320	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	321	m_blocks = command[6]<<24 | command[7]<<16 | command[8]<<8 | command[9];
319	322
320		case 0xa5: // PLAY AUDIO(12)
321		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
322		blocks = command[6]<<24 | command[7]<<16 | command[8]<<8 | command[9];
	323	// special cases: lba of 0 means MSF of 00:02:00
	324	if (m_lba == 0)
	325	{
	326	m_lba = 150;
	327	}
	328	else if (m_lba == 0xffffffff)
	329	{
	330	logerror("T10MMC: play audio from current not implemented!\n");
	331	}
323	332
324		// special cases: lba of 0 means MSF of 00:02:00
325		if (lba == 0)
326		{
327		lba = 150;
328		}
329		else if (lba == 0xffffffff)
330		{
331		logerror("T10MMC: play audio from current not implemented!\n");
332		}
	333	logerror("T10MMC: PLAY AUDIO(12) at LBA %x for %x blocks\n", m_lba, m_blocks);
333	334
334		logerror("T10MMC: PLAY AUDIO(12) at LBA %x for %x blocks\n", lba, blocks);
	335	trk = cdrom_get_track(m_cdrom, m_lba);
335	336
336		trk = cdrom_get_track(cdrom, lba);
	337	if (cdrom_get_track_type(m_cdrom, trk) == CD_TRACK_AUDIO)
	338	{
	339	m_cdda->start_audio(m_lba, m_blocks);
	340	m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
	341	}
	342	else
	343	{
	344	logerror("T10MMC: track is NOT audio!\n");
	345	set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
	346	}
337	347
338		if (cdrom_get_track_type(cdrom, trk) == CD_TRACK_AUDIO)
339		{
340		m_cdda->start_audio(lba, blocks);
341		m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
342		}
343		else
344		{
345		logerror("T10MMC: track is NOT audio!\n");
346		set_sense(SCSI_SENSE_KEY_ILLEGAL_REQUEST, SCSI_SENSE_ASC_ASCQ_ILLEGAL_MODE_FOR_THIS_TRACK);
347		}
	348	m_phase = SCSI_PHASE_STATUS;
	349	m_status_code = SCSI_STATUS_CODE_GOOD;
	350	m_transfer_length = 0;
	351	break;
348	352
349		m_phase = SCSI_PHASE_STATUS;
350		m_status_code = SCSI_STATUS_CODE_GOOD;
351		m_transfer_length = 0;
352		break;
	353	case T10SBC_CMD_READ_12:
	354	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	355	m_blocks = command[7]<<16 | command[8]<<8 | command[9];
353	356
354		case 0xa8: // READ(12)
355		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
356		blocks = command[7]<<16 | command[8]<<8 | command[9];
	357	logerror("T10MMC: READ(12) at LBA %x for %x blocks (%x bytes)\n", m_lba, m_blocks, m_blocks * m_sector_bytes);
357	358
358		logerror("T10MMC: READ(12) at LBA %x for %x blocks (%x bytes)\n", lba, blocks, blocks * m_sector_bytes);
	359	if (m_num_subblocks > 1)
	360	{
	361	m_cur_subblock = m_lba % m_num_subblocks;
	362	m_lba /= m_num_subblocks;
	363	}
	364	else
	365	{
	366	m_cur_subblock = 0;
	367	}
359	368
360		if (num_subblocks > 1)
361		{
362		cur_subblock = lba % num_subblocks;
363		lba /= num_subblocks;
364		}
365		else
366		{
367		cur_subblock = 0;
368		}
	369	abort_audio();
369	370
370		abort_audio();
	371	m_phase = SCSI_PHASE_DATAIN;
	372	m_status_code = SCSI_STATUS_CODE_GOOD;
	373	m_transfer_length = m_blocks * m_sector_bytes;
	374	break;
371	375
372		m_phase = SCSI_PHASE_DATAIN;
373		m_status_code = SCSI_STATUS_CODE_GOOD;
374		m_transfer_length = blocks * m_sector_bytes;
375		break;
	376	case T10MMC_CMD_SET_CD_SPEED:
	377	logerror("T10MMC: SET CD SPEED to %d kbytes/sec.\n", command[2]<<8 | command[3]);
	378	m_phase = SCSI_PHASE_STATUS;
	379	m_status_code = SCSI_STATUS_CODE_GOOD;
	380	m_transfer_length = 0;
	381	break;
376	382
377		case 0xbb: // SET CD SPEED
378		logerror("T10MMC: SET CD SPEED to %d kbytes/sec.\n", command[2]<<8 | command[3]);
379		m_phase = SCSI_PHASE_STATUS;
380		m_status_code = SCSI_STATUS_CODE_GOOD;
381		m_transfer_length = 0;
382		break;
383
384		default:
385		t10spc::ExecCommand();
	383	default:
	384	t10spc::ExecCommand();
386	385	}
387	386	}
388	387
r26280	r26281
397	396
398	397	switch ( command[0] )
399	398	{
400		case 0x12: // INQUIRY
401		data[0] = 0x05; // device is present, device is CD/DVD (MMC-3)
402		data[1] = 0x80; // media is removable
403		data[2] = 0x05; // device complies with SPC-3 standard
404		data[3] = 0x02; // response data format = SPC-3 standard
405		data[4] = 0x1f;
406		data[5] = 0;
407		data[6] = 0;
408		data[7] = 0;
409		memset(&data[8], ' ', 28);
410		memcpy(&data[8], "MAME", 4);
411		memcpy(&data[16], "Virtual CDROM", 13);
412		memcpy(&data[32], "1.0", 3);
413		break;
	399	case T10SPC_CMD_INQUIRY:
	400	data[0] = 0x05; // device is present, device is CD/DVD (MMC-3)
	401	data[1] = 0x80; // media is removable
	402	data[2] = 0x05; // device complies with SPC-3 standard
	403	data[3] = 0x02; // response data format = SPC-3 standard
	404	data[4] = 0x1f;
	405	data[5] = 0;
	406	data[6] = 0;
	407	data[7] = 0;
	408	memset(&data[8], ' ', 28);
	409	memcpy(&data[8], "MAME", 4);
	410	memcpy(&data[16], "Virtual CDROM", 13);
	411	memcpy(&data[32], "1.0", 3);
	412	break;
414	413
415		case 0x25: // READ CAPACITY
416		logerror("T10MMC: READ CAPACITY\n");
	414	case T10SBC_CMD_READ_CAPACITY:
	415	logerror("T10MMC: READ CAPACITY\n");
417	416
418		temp = cdrom_get_track_start(cdrom, 0xaa);
419		temp--; // return the last used block on the disc
	417	temp = cdrom_get_track_start(m_cdrom, 0xaa);
	418	temp--; // return the last used block on the disc
420	419
421		data[0] = (temp>>24) & 0xff;
422		data[1] = (temp>>16) & 0xff;
423		data[2] = (temp>>8) & 0xff;
424		data[3] = (temp & 0xff);
425		data[4] = 0;
426		data[5] = 0;
427		data[6] = (m_sector_bytes>>8)&0xff;
428		data[7] = (m_sector_bytes & 0xff);
429		break;
	420	data[0] = (temp>>24) & 0xff;
	421	data[1] = (temp>>16) & 0xff;
	422	data[2] = (temp>>8) & 0xff;
	423	data[3] = (temp & 0xff);
	424	data[4] = 0;
	425	data[5] = 0;
	426	data[6] = (m_sector_bytes>>8)&0xff;
	427	data[7] = (m_sector_bytes & 0xff);
	428	break;
430	429
431		case 0x28: // READ(10)
432		case 0xa8: // READ(12)
433		logerror("T10MMC: read %x dataLength, \n", dataLength);
434		if ((cdrom) && (blocks))
	430	case T10SBC_CMD_READ_10:
	431	case T10SBC_CMD_READ_12:
	432	logerror("T10MMC: read %x dataLength, \n", dataLength);
	433	if ((m_cdrom) && (m_blocks))
	434	{
	435	while (dataLength > 0)
435	436	{
436		while (dataLength > 0)
	437	if (!cdrom_read_data(m_cdrom, m_lba, tmp_buffer, CD_TRACK_MODE1))
437	438	{
438		if (!cdrom_read_data(cdrom, lba, tmp_buffer, CD_TRACK_MODE1))
439		{
440		logerror("T10MMC: CD read error!\n");
441		}
	439	logerror("T10MMC: CD read error!\n");
	440	}
442	441
443		logerror("True LBA: %d, buffer half: %d\n", lba, cur_subblock * m_sector_bytes);
	442	logerror("True LBA: %d, buffer half: %d\n", m_lba, m_cur_subblock * m_sector_bytes);
444	443
445		memcpy(data, &tmp_buffer[cur_subblock * m_sector_bytes], m_sector_bytes);
	444	memcpy(data, &tmp_buffer[m_cur_subblock * m_sector_bytes], m_sector_bytes);
446	445
447		cur_subblock++;
448		if (cur_subblock >= num_subblocks)
449		{
450		cur_subblock = 0;
	446	m_cur_subblock++;
	447	if (m_cur_subblock >= m_num_subblocks)
	448	{
	449	m_cur_subblock = 0;
451	450
452		lba++;
453		blocks--;
454		}
455
456		last_lba = lba;
457		dataLength -= m_sector_bytes;
458		data += m_sector_bytes;
	451	m_lba++;
	452	m_blocks--;
459	453	}
	454
	455	m_last_lba = m_lba;
	456	dataLength -= m_sector_bytes;
	457	data += m_sector_bytes;
460	458	}
461		break;
	459	}
	460	break;
462	461
463		case 0x42: // READ SUB-CHANNEL
464		switch (command[3])
	462	case T10MMC_CMD_READ_SUB_CHANNEL:
	463	switch (command[3])
	464	{
	465	case 1: // return current position
465	466	{
466		case 1: // return current position
	467	if (!m_cdrom)
467	468	{
468		if (!cdrom)
469		{
470		return;
471		}
	469	return;
	470	}
472	471
473		logerror("T10MMC: READ SUB-CHANNEL Time = %x, SUBQ = %x\n", command[1], command[2]);
	472	logerror("T10MMC: READ SUB-CHANNEL Time = %x, SUBQ = %x\n", command[1], command[2]);
474	473
475		bool msf = (command[1] & 0x2) != 0;
	474	bool msf = (command[1] & 0x2) != 0;
476	475
477		data[0]= 0x00;
	476	data[0]= 0x00;
478	477
479		int audio_active = m_cdda->audio_active();
480		if (audio_active)
	478	int audio_active = m_cdda->audio_active();
	479	if (audio_active)
	480	{
	481	// if audio is playing, get the latest LBA from the CDROM layer
	482	m_last_lba = m_cdda->get_audio_lba();
	483	if (m_cdda->audio_paused())
481	484	{
482		// if audio is playing, get the latest LBA from the CDROM layer
483		last_lba = m_cdda->get_audio_lba();
484		if (m_cdda->audio_paused())
485		{
486		data[1] = 0x12;     // audio is paused
487		}
488		else
489		{
490		data[1] = 0x11;     // audio in progress
491		}
	485	data[1] = 0x12;     // audio is paused
492	486	}
493	487	else
494	488	{
495		last_lba = 0;
496		if (m_cdda->audio_ended())
497		{
498		data[1] = 0x13; // ended successfully
499		}
500		else
501		{
	489	data[1] = 0x11;     // audio in progress
	490	}
	491	}
	492	else
	493	{
	494	m_last_lba = 0;
	495	if (m_cdda->audio_ended())
	496	{
	497	data[1] = 0x13; // ended successfully
	498	}
	499	else
	500	{
502	501	//                          data[1] = 0x14;    // stopped due to error
503		data[1] = 0x15; // No current audio status to return
504		}
	502	data[1] = 0x15; // No current audio status to return
505	503	}
	504	}
506	505
507		if (command[2] & 0x40)
508		{
509		data[2] = 0;
510		data[3] = 12;       // data length
511		data[4] = 0x01; // sub-channel format code
512		data[5] = 0x10 | (audio_active ? 0 : 4);
513		data[6] = cdrom_get_track(cdrom, last_lba) + 1; // track
514		data[7] = 0;    // index
	506	if (command[2] & 0x40)
	507	{
	508	data[2] = 0;
	509	data[3] = 12;       // data length
	510	data[4] = 0x01; // sub-channel format code
	511	data[5] = 0x10 | (audio_active ? 0 : 4);
	512	data[6] = cdrom_get_track(m_cdrom, m_last_lba) + 1; // track
	513	data[7] = 0;    // index
515	514
516		UINT32 frame = last_lba;
	515	UINT32 frame = m_last_lba;
517	516
518		if (msf)
519		{
520		frame = to_msf(frame);
521		}
	517	if (msf)
	518	{
	519	frame = to_msf(frame);
	520	}
522	521
523		data[8] = (frame>>24)&0xff;
524		data[9] = (frame>>16)&0xff;
525		data[10] = (frame>>8)&0xff;
526		data[11] = frame&0xff;
	522	data[8] = (frame>>24)&0xff;
	523	data[9] = (frame>>16)&0xff;
	524	data[10] = (frame>>8)&0xff;
	525	data[11] = frame&0xff;
527	526
528		frame -= cdrom_get_track_start(cdrom, data[6] - 1);
	527	frame -= cdrom_get_track_start(m_cdrom, data[6] - 1);
529	528
530		if (msf)
531		{
532		frame = to_msf(frame);
533		}
534
535		data[12] = (frame>>24)&0xff;
536		data[13] = (frame>>16)&0xff;
537		data[14] = (frame>>8)&0xff;
538		data[15] = frame&0xff;
539		}
540		else
	529	if (msf)
541	530	{
542		data[2] = 0;
543		data[3] = 0;
	531	frame = to_msf(frame);
544	532	}
545		break;
	533
	534	data[12] = (frame>>24)&0xff;
	535	data[13] = (frame>>16)&0xff;
	536	data[14] = (frame>>8)&0xff;
	537	data[15] = frame&0xff;
546	538	}
547		default:
548		logerror("T10MMC: Unknown subchannel type %d requested\n", command[3]);
	539	else
	540	{
	541	data[2] = 0;
	542	data[3] = 0;
	543	}
	544	break;
549	545	}
550		break;
	546	default:
	547	logerror("T10MMC: Unknown subchannel type %d requested\n", command[3]);
	548	}
	549	break;
551	550
552		case 0x43: // READ TOC
553		/*
554		Track numbers are problematic here: 0 = lead-in, 0xaa = lead-out.
555		That makes sense in terms of how real-world CDs are referred to, but
556		our internal routines for tracks use "0" as track 1.  That probably
557		should be fixed...
558		*/
559		{
560		bool msf = (command[1] & 0x2) != 0;
	551	case T10MMC_CMD_READ_TOC_PMA_ATIP:
	552	/*
	553	Track numbers are problematic here: 0 = lead-in, 0xaa = lead-out.
	554	That makes sense in terms of how real-world CDs are referred to, but
	555	our internal routines for tracks use "0" as track 1.  That probably
	556	should be fixed...
	557	*/
	558	{
	559	bool msf = (command[1] & 0x2) != 0;
561	560
562		logerror("T10MMC: READ TOC, format = %d time=%d\n", toc_format(),msf);
563		switch (toc_format())
	561	logerror("T10MMC: READ TOC, format = %d time=%d\n", toc_format(),msf);
	562	switch (toc_format())
	563	{
	564	case TOC_FORMAT_TRACKS:
564	565	{
565		case TOC_FORMAT_TRACKS:
566		{
567		int tracks = toc_tracks();
568		int len = 2 + (tracks * 8);
	566	int tracks = toc_tracks();
	567	int len = 2 + (tracks * 8);
569	568
570		// the returned TOC DATA LENGTH must be the full amount,
571		// regardless of how much we're able to pass back due to in_len
572		int dptr = 0;
573		data[dptr++] = (len>>8) & 0xff;
574		data[dptr++] = (len & 0xff);
575		data[dptr++] = 1;
576		data[dptr++] = cdrom_get_last_track(cdrom);
	569	// the returned TOC DATA LENGTH must be the full amount,
	570	// regardless of how much we're able to pass back due to in_len
	571	int dptr = 0;
	572	data[dptr++] = (len>>8) & 0xff;
	573	data[dptr++] = (len & 0xff);
	574	data[dptr++] = 1;
	575	data[dptr++] = cdrom_get_last_track(m_cdrom);
577	576
578		int first_track = command[6];
579		if (first_track == 0)
	577	int first_track = command[6];
	578	if (first_track == 0)
	579	{
	580	first_track = 1;
	581	}
	582
	583	for (int i = 0; i < tracks; i++)
	584	{
	585	int track = first_track + i;
	586	int cdrom_track = track - 1;
	587	if( i == tracks - 1 )
580	588	{
581		first_track = 1;
	589	track = 0xaa;
	590	cdrom_track = 0xaa;
582	591	}
583	592
584		for (int i = 0; i < tracks; i++)
	593	if( dptr >= dataLength )
585	594	{
586		int track = first_track + i;
587		int cdrom_track = track - 1;
588		if( i == tracks - 1 )
589		{
590		track = 0xaa;
591		cdrom_track = 0xaa;
592		}
593
594		if( dptr >= dataLength )
595		{
596		break;
597		}
598
599		data[dptr++] = 0;
600		data[dptr++] = cdrom_get_adr_control(cdrom, cdrom_track);
601		data[dptr++] = track;
602		data[dptr++] = 0;
603
604		UINT32 tstart = cdrom_get_track_start(cdrom, cdrom_track);
605
606		if (msf)
607		{
608		tstart = to_msf(tstart+150);
609		}
610
611		data[dptr++] = (tstart>>24) & 0xff;
612		data[dptr++] = (tstart>>16) & 0xff;
613		data[dptr++] = (tstart>>8) & 0xff;
614		data[dptr++] = (tstart & 0xff);
	595	break;
615	596	}
616		}
617		break;
618	597
619		case TOC_FORMAT_SESSIONS:
620		{
621		int len = 2 + (8 * 1);
622
623		int dptr = 0;
624		data[dptr++] = (len>>8) & 0xff;
625		data[dptr++] = (len & 0xff);
626		data[dptr++] = 1;
627		data[dptr++] = 1;
628
629	598	data[dptr++] = 0;
630		data[dptr++] = cdrom_get_adr_control(cdrom, 0);
631		data[dptr++] = 1;
	599	data[dptr++] = cdrom_get_adr_control(m_cdrom, cdrom_track);
	600	data[dptr++] = track;
632	601	data[dptr++] = 0;
633	602
634		UINT32 tstart = cdrom_get_track_start(cdrom, 0);
	603	UINT32 tstart = cdrom_get_track_start(m_cdrom, cdrom_track);
635	604
636	605	if (msf)
637	606	{
r26280	r26281
643	612	data[dptr++] = (tstart>>8) & 0xff;
644	613	data[dptr++] = (tstart & 0xff);
645	614	}
646		break;
	615	}
	616	break;
647	617
648		default:
649		logerror("T10MMC: Unhandled READ TOC format %d\n", toc_format());
650		break;
	618	case TOC_FORMAT_SESSIONS:
	619	{
	620	int len = 2 + (8 * 1);
	621
	622	int dptr = 0;
	623	data[dptr++] = (len>>8) & 0xff;
	624	data[dptr++] = (len & 0xff);
	625	data[dptr++] = 1;
	626	data[dptr++] = 1;
	627
	628	data[dptr++] = 0;
	629	data[dptr++] = cdrom_get_adr_control(m_cdrom, 0);
	630	data[dptr++] = 1;
	631	data[dptr++] = 0;
	632
	633	UINT32 tstart = cdrom_get_track_start(m_cdrom, 0);
	634
	635	if (msf)
	636	{
	637	tstart = to_msf(tstart+150);
	638	}
	639
	640	data[dptr++] = (tstart>>24) & 0xff;
	641	data[dptr++] = (tstart>>16) & 0xff;
	642	data[dptr++] = (tstart>>8) & 0xff;
	643	data[dptr++] = (tstart & 0xff);
651	644	}
	645	break;
	646
	647	default:
	648	logerror("T10MMC: Unhandled READ TOC format %d\n", toc_format());
	649	break;
652	650	}
653		break;
	651	}
	652	break;
654	653
655		case 0x1a: // MODE SENSE(6)
656		case 0x5a: // MODE SENSE(10)
657		logerror("T10MMC: MODE SENSE page code = %x, PC = %x\n", command[2] & 0x3f, (command[2]&0xc0)>>6);
	654	case T10SPC_CMD_MODE_SENSE_6:
	655	case T10SPC_CMD_MODE_SENSE_10:
	656	logerror("T10MMC: MODE SENSE page code = %x, PC = %x\n", command[2] & 0x3f, (command[2]&0xc0)>>6);
658	657
659		memset(data, 0, SCSILengthFromUINT16( &command[ 7 ] ));
	658	memset(data, 0, SCSILengthFromUINT16( &command[ 7 ] ));
660	659
661		switch (command[2] & 0x3f)
662		{
663		case 0xe:   // CD Audio control page
664		data[0] = 0x8e; // page E, parameter is savable
665		data[1] = 0x0e; // page length
666		data[2] = 0x04; // IMMED = 1, SOTC = 0
667		data[3] = data[4] = data[5] = data[6] = data[7] = 0; // reserved
	660	switch (command[2] & 0x3f)
	661	{
	662	case 0xe:   // CD Audio control page
	663	data[0] = 0x8e; // page E, parameter is savable
	664	data[1] = 0x0e; // page length
	665	data[2] = 0x04; // IMMED = 1, SOTC = 0
	666	data[3] = data[4] = data[5] = data[6] = data[7] = 0; // reserved
668	667
669		// connect each audio channel to 1 output port
670		data[8] = 1;
671		data[10] = 2;
672		data[12] = 4;
673		data[14] = 8;
	668	// connect each audio channel to 1 output port
	669	data[8] = 1;
	670	data[10] = 2;
	671	data[12] = 4;
	672	data[14] = 8;
674	673
675		// indicate max volume
676		data[9] = data[11] = data[13] = data[15] = 0xff;
677		break;
678		case 0x2a:  // Page capabilities
679		data[0] = 0x2a;
680		data[1] = 0x14; // page length
681		data[2] = 0x00; data[3] = 0x00; // CD-R only
682		data[4] = 0x01; // can play audio
683		data[5] = 0;
684		data[6] = 0;
685		data[7] = 0;
686		data[8] = 0x02; data[9] = 0xc0; // 4x speed
687		data[10] = 0;
688		data[11] = 2; // two volumen levels
689		data[12] = 0x00; data[13] = 0x00; // buffer
690		data[14] = 0x02; data[15] = 0xc0; // 4x read speed
691		data[16] = 0;
692		data[17] = 0;
693		data[18] = 0;
694		data[19] = 0;
695		data[20] = 0;
696		data[21] = 0;
697		break;
	674	// indicate max volume
	675	data[9] = data[11] = data[13] = data[15] = 0xff;
	676	break;
	677	case 0x2a:  // Page capabilities
	678	data[0] = 0x2a;
	679	data[1] = 0x14; // page length
	680	data[2] = 0x00; data[3] = 0x00; // CD-R only
	681	data[4] = 0x01; // can play audio
	682	data[5] = 0;
	683	data[6] = 0;
	684	data[7] = 0;
	685	data[8] = 0x02; data[9] = 0xc0; // 4x speed
	686	data[10] = 0;
	687	data[11] = 2; // two volumen levels
	688	data[12] = 0x00; data[13] = 0x00; // buffer
	689	data[14] = 0x02; data[15] = 0xc0; // 4x read speed
	690	data[16] = 0;
	691	data[17] = 0;
	692	data[18] = 0;
	693	data[19] = 0;
	694	data[20] = 0;
	695	data[21] = 0;
	696	break;
698	697
699		default:
700		logerror("T10MMC: MODE SENSE unknown page %x\n", command[2] & 0x3f);
701		break;
702		}
703		break;
	698	default:
	699	logerror("T10MMC: MODE SENSE unknown page %x\n", command[2] & 0x3f);
	700	break;
	701	}
	702	break;
704	703
705		default:
706		t10spc::ReadData( data, dataLength );
707		break;
	704	default:
	705	t10spc::ReadData( data, dataLength );
	706	break;
708	707	}
709	708	}
710	709
r26280	r26281
716	715	{
717	716	switch (command[ 0 ])
718	717	{
719		case 0x15: // MODE SELECT(6)
720		case 0x55: // MODE SELECT(10)
721		logerror("T10MMC: MODE SELECT page %x\n", data[0] & 0x3f);
	718	case T10SPC_CMD_MODE_SELECT_6:
	719	case T10SPC_CMD_MODE_SELECT_10:
	720	logerror("T10MMC: MODE SELECT page %x\n", data[0] & 0x3f);
722	721
723		switch (data[0] & 0x3f)
724		{
725		case 0x0:   // vendor-specific
726		// check for SGI extension to force 512-byte blocks
727		if ((data[3] == 8) && (data[10] == 2))
728		{
729		logerror("T10MMC: Experimental SGI 512-byte block extension enabled\n");
	722	switch (data[0] & 0x3f)
	723	{
	724	case 0x0:   // vendor-specific
	725	// check for SGI extension to force 512-byte blocks
	726	if ((data[3] == 8) && (data[10] == 2))
	727	{
	728	logerror("T10MMC: Experimental SGI 512-byte block extension enabled\n");
730	729
731		m_sector_bytes = 512;
732		num_subblocks = 4;
733		}
734		else
735		{
736		logerror("T10MMC: Unknown vendor-specific page!\n");
737		}
738		break;
	730	m_sector_bytes = 512;
	731	m_num_subblocks = 4;
	732	}
	733	else
	734	{
	735	logerror("T10MMC: Unknown vendor-specific page!\n");
	736	}
	737	break;
739	738
740		case 0xe:   // audio page
741		logerror("Ch 0 route: %x vol: %x\n", data[8], data[9]);
742		logerror("Ch 1 route: %x vol: %x\n", data[10], data[11]);
743		logerror("Ch 2 route: %x vol: %x\n", data[12], data[13]);
744		logerror("Ch 3 route: %x vol: %x\n", data[14], data[15]);
745		break;
746		}
747		break;
	739	case 0xe:   // audio page
	740	logerror("Ch 0 route: %x vol: %x\n", data[8], data[9]);
	741	logerror("Ch 1 route: %x vol: %x\n", data[10], data[11]);
	742	logerror("Ch 2 route: %x vol: %x\n", data[12], data[13]);
	743	logerror("Ch 3 route: %x vol: %x\n", data[14], data[15]);
	744	break;
	745	}
	746	break;
748	747
749		default:
750		t10spc::WriteData( data, dataLength );
751		break;
752		}
	748	default:
	749	t10spc::WriteData( data, dataLength );
	750	break;
753	751	}
	752	}
754	753
755	754	void t10mmc::GetDevice( void **_cdrom )
756	755	{
757		*(cdrom_file **)_cdrom = cdrom;
	756	*(cdrom_file **)_cdrom = m_cdrom;
758	757	}
759	758
760	759	void t10mmc::SetDevice( void *_cdrom )
761	760	{
762		cdrom = (cdrom_file *)_cdrom;
763		m_cdda->set_cdrom(cdrom);
	761	m_cdrom = (cdrom_file *)_cdrom;
	762	m_cdda->set_cdrom(m_cdrom);
764	763	}

trunk/src/emu/machine/t10mmc.h

r26280	r26281
24	24	virtual void t10_start(device_t &device);
25	25	virtual void t10_reset();
26	26
	27	enum
	28	{
	29	T10MMC_CMD_READ_SUB_CHANNEL = 0x42,
	30	T10MMC_CMD_READ_TOC_PMA_ATIP = 0x43,
	31	T10MMC_CMD_PLAY_AUDIO_10 = 0x45,
	32	T10MMC_CMD_PLAY_AUDIO_TRACK_INDEX = 0x48,
	33	T10MMC_CMD_PAUSE_RESUME = 0x4b,
	34	T10MMC_CMD_STOP_PLAY_SCAN = 0x4e,
	35	T10MMC_CMD_PLAY_AUDIO_12 = 0xa5,
	36	T10MMC_CMD_SET_CD_SPEED = 0xbb,
	37	};
	38
27	39	enum toc_format_t
28	40	{
29	41	TOC_FORMAT_TRACKS = 0,
r26280	r26281
36	48
37	49	cdrom_image_device *m_image;
38	50	cdda_device *m_cdda;
39		cdrom_file *cdrom;
	51	cdrom_file *m_cdrom;
40	52
41		UINT32 lba;
42		UINT32 blocks;
43		UINT32 last_lba;
44		UINT32 num_subblocks;
45		UINT32 cur_subblock;
	53	UINT32 m_lba;
	54	UINT32 m_blocks;
	55	UINT32 m_last_lba;
	56	UINT32 m_num_subblocks;
	57	UINT32 m_cur_subblock;
46	58	int m_audio_sense;
47	59	};
48	60

trunk/src/emu/machine/t10spc.c

r26280	r26281
34	34	{
35	35	switch( command[ 0 ] )
36	36	{
37		case SCSI_CMD_TEST_UNIT_READY:
	37	case T10SPC_CMD_TEST_UNIT_READY:
38	38	m_phase = SCSI_PHASE_STATUS;
39	39	m_status_code = SCSI_STATUS_CODE_GOOD;
40	40	m_transfer_length = 0;
41	41	break;
42	42
43		case SCSI_CMD_RECALIBRATE:
	43	case T10SPC_CMD_RECALIBRATE:
44	44	m_phase = SCSI_PHASE_STATUS;
45	45	m_status_code = SCSI_STATUS_CODE_GOOD;
46	46	m_transfer_length = 0;
47	47	break;
48	48
49		case SCSI_CMD_REQUEST_SENSE:
	49	case T10SPC_CMD_REQUEST_SENSE:
50	50	m_phase = SCSI_PHASE_DATAIN;
51	51	m_status_code = SCSI_STATUS_CODE_GOOD;
52	52	if (command[4] == 0)
r26280	r26281
63	63	}
64	64	break;
65	65
66		case SCSI_CMD_SEND_DIAGNOSTIC:
	66	case T10SPC_CMD_SEND_DIAGNOSTIC:
67	67	m_phase = SCSI_PHASE_DATAOUT;
68	68	m_status_code = SCSI_STATUS_CODE_GOOD;
69	69	m_transfer_length = SCSILengthFromUINT16(&command[3]);
r26280	r26281
81	81	{
82	82	switch( command[ 0 ] )
83	83	{
84		case SCSI_CMD_REQUEST_SENSE:
	84	case T10SPC_CMD_REQUEST_SENSE:
85	85	if (command[4] == 0)
86	86	{
87	87	data[0] = m_sense_asc & 0x7f;
r26280	r26281
124	124	{
125	125	switch( command[ 0 ] )
126	126	{
127		case SCSI_CMD_SEND_DIAGNOSTIC:
	127	case T10SPC_CMD_SEND_DIAGNOSTIC:
128	128	break;
129	129
130	130	default:

trunk/src/emu/machine/t10spc.h

r26280	r26281
60	60	SCSI_STATUS_CODE_TASK_ABORTED = 0x40
61	61	};
62	62
	63	// these are defined here because t10mmc also needs them.
	64	enum
	65	{
	66	T10SBC_CMD_FORMAT_UNIT = 0x04,
	67	T10SBC_CMD_READ_6 = 0x08,
	68	T10SBC_CMD_WRITE_6 = 0x0a,
	69	T10SBC_CMD_SEEK_6 = 0x0b,
	70	T10SBC_CMD_READ_10 = 0x28,
	71	T10SBC_CMD_READ_CAPACITY = 0x25,
	72	T10SBC_CMD_WRITE_10 = 0x2a,
	73	T10SBC_CMD_SEEK_10 = 0x2b,
	74	T10SBC_CMD_READ_12 = 0xa8,
	75	};
	76
	77	enum
	78	{
	79	T10SPC_CMD_TEST_UNIT_READY = 0x00,
	80	T10SPC_CMD_RECALIBRATE = 0x01,
	81	T10SPC_CMD_REQUEST_SENSE = 0x03,
	82	T10SPC_CMD_INQUIRY = 0x12,
	83	T10SPC_CMD_MODE_SELECT_6 = 0x15,
	84	T10SPC_CMD_RESERVE_6 = 0x16,
	85	T10SPC_CMD_RELEASE_6 = 0x17,
	86	T10SPC_CMD_MODE_SENSE_6 = 0x1a,
	87	T10SPC_CMD_START_STOP_UNIT = 0x1b,
	88	T10SPC_CMD_RECEIVE_DIAGNOSTIC_RESULTS = 0x1c,
	89	T10SPC_CMD_SEND_DIAGNOSTIC = 0x1d,
	90	T10SPC_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL = 0x1e,
	91	T10SPC_CMD_WRITE_BUFFER = 0x3b,
	92	T10SPC_CMD_READ_BUFFER = 0x3c,
	93	T10SPC_CMD_LOG_SELECT = 0x4c,
	94	T10SPC_CMD_LOG_SENSE = 0x4d,
	95	T10SPC_CMD_MODE_SELECT_10 = 0x55,
	96	T10SPC_CMD_RESERVE_10 = 0x56,
	97	T10SPC_CMD_RELEASE_10 = 0x57,
	98	T10SPC_CMD_MODE_SENSE_10 = 0x5a,
	99	T10SPC_CMD_PERSISTENT_RESERVE_IN = 0x5e,
	100	T10SPC_CMD_PERSISTENT_RESERVE_OUT = 0x5f,
	101	T10SPC_CMD_EXTENDED_COPY = 0x83,
	102	T10SPC_CMD_RECEIVE_COPY_RESULTS = 0x84,
	103	T10SPC_CMD_REPORT_LUNS = 0xa0,
	104	T10SPC_CMD_REPORT_DEVICE_IDENTIFIER = 0xa3,
	105	T10SPC_CMD_SET_DEVICE_IDENTIFIER = 0xa4,
	106	T10SPC_CMD_MOVE_MEDIUM_ATTACHED = 0xa7,
	107	T10SPC_CMD_READ_ELEMENT_STATUS_ATTACHED = 0xb4
	108	};
	109
63	110	void set_sense(sense_key_t key, sense_asc_ascq_t asc_ascq);
64	111
65	112	UINT8 command[ 32 ];
r26280	r26281
84	131	#define SCSI_PHASE_BUS_FREE ( 8 )
85	132	#define SCSI_PHASE_SELECT ( 9 )
86	133
87		#define SCSI_CMD_TEST_UNIT_READY ( 0x00 )
88		#define SCSI_CMD_RECALIBRATE ( 0x01 )
89		#define SCSI_CMD_REQUEST_SENSE ( 0x03 )
90		#define SCSI_CMD_MODE_SELECT ( 0x15 )
91		#define SCSI_CMD_SEND_DIAGNOSTIC ( 0x1d )
92
93	134	#endif

trunk/src/emu/machine/t10sbc.c

r26280	r26281
4	4	{
5	5	t10spc::t10_start(device);
6	6
7		device.save_item( NAME( lba ) );
8		device.save_item( NAME( blocks ) );
	7	device.save_item( NAME( m_lba ) );
	8	device.save_item( NAME( m_blocks ) );
9	9	}
10	10
11	11	void t10sbc::t10_reset()
12	12	{
13	13	t10spc::t10_reset();
14	14
15		lba = 0;
16		blocks = 0;
	15	m_lba = 0;
	16	m_blocks = 0;
17	17	m_sector_bytes = 512;
18	18
19		disk = m_image->get_hard_disk_file();
20		if (!disk)
	19	m_disk = m_image->get_hard_disk_file();
	20	if (!m_disk)
21	21	{
22	22	logerror("T10SBC %s: no HD found!\n", m_image->owner()->tag());
23	23	}
24	24	else
25	25	{
26	26	// get hard disk sector size from CHD metadata
27		const hard_disk_info *hdinfo = hard_disk_get_info(disk);
	27	const hard_disk_info *hdinfo = hard_disk_get_info(m_disk);
28	28	m_sector_bytes = hdinfo->sectorbytes;
29	29	}
30	30	}
r26280	r26281
34	34	{
35	35	switch ( command[0] )
36	36	{
37		case 0x04: // FORMAT UNIT
38		m_phase = SCSI_PHASE_STATUS;
39		m_status_code = SCSI_STATUS_CODE_GOOD;
40		m_transfer_length = 0;
41		break;
	37	case T10SBC_CMD_FORMAT_UNIT:
	38	m_phase = SCSI_PHASE_STATUS;
	39	m_status_code = SCSI_STATUS_CODE_GOOD;
	40	m_transfer_length = 0;
	41	break;
42	42
43		case 0x08: // READ(6)
44		lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
45		blocks = SCSILengthFromUINT8( &command[4] );
	43	case T10SBC_CMD_SEEK_6:
	44	m_lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
	45
	46	logerror("S1410: SEEK to LBA %x\n", m_lba);
	47
	48	m_phase = SCSI_PHASE_STATUS;
	49	m_transfer_length = 0;
	50	break;
46	51
47		logerror("T10SBC: READ at LBA %x for %x blocks\n", lba, blocks);
	52	case T10SBC_CMD_READ_6:
	53	m_lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
	54	m_blocks = SCSILengthFromUINT8( &command[4] );
48	55
49		m_phase = SCSI_PHASE_DATAIN;
50		m_status_code = SCSI_STATUS_CODE_GOOD;
51		m_transfer_length = blocks * m_sector_bytes;
52		break;
	56	logerror("T10SBC: READ at LBA %x for %x blocks\n", m_lba, m_blocks);
53	57
54		case 0x0a: // WRITE(6)
55		lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
56		blocks = SCSILengthFromUINT8( &command[4] );
	58	m_phase = SCSI_PHASE_DATAIN;
	59	m_status_code = SCSI_STATUS_CODE_GOOD;
	60	m_transfer_length = m_blocks * m_sector_bytes;
	61	break;
57	62
58		logerror("T10SBC: WRITE to LBA %x for %x blocks\n", lba, blocks);
	63	case T10SBC_CMD_WRITE_6:
	64	m_lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
	65	m_blocks = SCSILengthFromUINT8( &command[4] );
59	66
60		m_phase = SCSI_PHASE_DATAOUT;
61		m_status_code = SCSI_STATUS_CODE_GOOD;
62		m_transfer_length = blocks * m_sector_bytes;
63		break;
	67	logerror("T10SBC: WRITE to LBA %x for %x blocks\n", m_lba, m_blocks);
64	68
65		case 0x12: // INQUIRY
66		m_phase = SCSI_PHASE_DATAIN;
67		m_status_code = SCSI_STATUS_CODE_GOOD;
68		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
69		break;
	69	m_phase = SCSI_PHASE_DATAOUT;
	70	m_status_code = SCSI_STATUS_CODE_GOOD;
	71	m_transfer_length = m_blocks * m_sector_bytes;
	72	break;
70	73
71		case 0x15: // MODE SELECT (used to set CDDA volume)
72		logerror("T10SBC: MODE SELECT length %x control %x\n", command[4], command[5]);
73		m_phase = SCSI_PHASE_DATAOUT;
74		m_status_code = SCSI_STATUS_CODE_GOOD;
75		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
76		break;
	74	case T10SPC_CMD_INQUIRY:
	75	m_phase = SCSI_PHASE_DATAIN;
	76	m_status_code = SCSI_STATUS_CODE_GOOD;
	77	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	78	break;
77	79
78		case 0x1a: // MODE SENSE(6)
79		m_phase = SCSI_PHASE_DATAIN;
80		m_status_code = SCSI_STATUS_CODE_GOOD;
81		m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
82		break;
	80	case T10SPC_CMD_MODE_SELECT_6:
	81	logerror("T10SBC: MODE SELECT length %x control %x\n", command[4], command[5]);
	82	m_phase = SCSI_PHASE_DATAOUT;
	83	m_status_code = SCSI_STATUS_CODE_GOOD;
	84	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	85	break;
83	86
84		case 0x25: // READ CAPACITY
85		m_phase = SCSI_PHASE_DATAIN;
86		m_status_code = SCSI_STATUS_CODE_GOOD;
87		m_transfer_length = 8;
88		break;
	87	case T10SPC_CMD_MODE_SENSE_6:
	88	m_phase = SCSI_PHASE_DATAIN;
	89	m_status_code = SCSI_STATUS_CODE_GOOD;
	90	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
	91	break;
89	92
90		case 0x28: // READ(10)
91		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
92		blocks = SCSILengthFromUINT16( &command[7] );
	93	case T10SBC_CMD_READ_CAPACITY:
	94	m_phase = SCSI_PHASE_DATAIN;
	95	m_status_code = SCSI_STATUS_CODE_GOOD;
	96	m_transfer_length = 8;
	97	break;
93	98
94		logerror("T10SBC: READ at LBA %x for %x blocks\n", lba, blocks);
	99	case T10SBC_CMD_READ_10:
	100	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	101	m_blocks = SCSILengthFromUINT16( &command[7] );
95	102
96		m_phase = SCSI_PHASE_DATAIN;
97		m_status_code = SCSI_STATUS_CODE_GOOD;
98		m_transfer_length = blocks * m_sector_bytes;
99		break;
	103	logerror("T10SBC: READ at LBA %x for %x blocks\n", m_lba, m_blocks);
100	104
101		case 0x2a: // WRITE (10)
102		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
103		blocks = SCSILengthFromUINT16( &command[7] );
	105	m_phase = SCSI_PHASE_DATAIN;
	106	m_status_code = SCSI_STATUS_CODE_GOOD;
	107	m_transfer_length = m_blocks * m_sector_bytes;
	108	break;
104	109
105		logerror("T10SBC: WRITE to LBA %x for %x blocks\n", lba, blocks);
	110	case T10SBC_CMD_WRITE_10:
	111	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	112	m_blocks = SCSILengthFromUINT16( &command[7] );
106	113
107		m_phase = SCSI_PHASE_DATAOUT;
108		m_status_code = SCSI_STATUS_CODE_GOOD;
109		m_transfer_length = blocks * m_sector_bytes;
110		break;
	114	logerror("T10SBC: WRITE to LBA %x for %x blocks\n", m_lba, m_blocks);
111	115
112		case 0xa8: // READ(12)
113		lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
114		blocks = command[6]<<24 | command[7]<<16 | command[8]<<8 | command[9];
	116	m_phase = SCSI_PHASE_DATAOUT;
	117	m_status_code = SCSI_STATUS_CODE_GOOD;
	118	m_transfer_length = m_blocks * m_sector_bytes;
	119	break;
115	120
116		logerror("T10SBC: READ at LBA %x for %x blocks\n", lba, blocks);
	121	case T10SBC_CMD_READ_12:
	122	m_lba = command[2]<<24 | command[3]<<16 | command[4]<<8 | command[5];
	123	m_blocks = command[6]<<24 | command[7]<<16 | command[8]<<8 | command[9];
117	124
118		m_phase = SCSI_PHASE_DATAIN;
119		m_status_code = SCSI_STATUS_CODE_GOOD;
120		m_transfer_length = blocks * m_sector_bytes;
121		break;
	125	logerror("T10SBC: READ at LBA %x for %x blocks\n", m_lba, m_blocks);
122	126
123		default:
124		t10spc::ExecCommand();
125		break;
	127	m_phase = SCSI_PHASE_DATAIN;
	128	m_status_code = SCSI_STATUS_CODE_GOOD;
	129	m_transfer_length = m_blocks * m_sector_bytes;
	130	break;
	131
	132	default:
	133	t10spc::ExecCommand();
	134	break;
126	135	}
127	136	}
128	137
129	138	void t10sbc::ReadData( UINT8 *data, int dataLength )
130	139	{
131	140	// if we're a drive without a disk, return all zeroes
132		if (!disk)
	141	if (!m_disk)
133	142	{
134	143	memset(data, 0, dataLength);
135	144	return;
r26280	r26281
137	146
138	147	switch ( command[0] )
139	148	{
140		case 0x12:  // INQUIRY
141		memset( data, 0, dataLength );
142		data[0] = 0x00; // device is direct-access (e.g. hard disk)
143		data[1] = 0x00; // media is not removable
144		data[2] = 0x05; // device complies with SPC-3 standard
145		data[3] = 0x02; // response data format = SPC-3 standard
146		// Apple HD SC setup utility needs to see this
147		strcpy((char *)&data[8], " SEAGATE");
148		strcpy((char *)&data[16], "          ST225N");
149		strcpy((char *)&data[32], "1.0");
150		break;
	149	case T10SPC_CMD_INQUIRY:
	150	memset( data, 0, dataLength );
	151	data[0] = 0x00; // device is direct-access (e.g. hard disk)
	152	data[1] = 0x00; // media is not removable
	153	data[2] = 0x05; // device complies with SPC-3 standard
	154	data[3] = 0x02; // response data format = SPC-3 standard
	155	// Apple HD SC setup utility needs to see this
	156	strcpy((char *)&data[8], " SEAGATE");
	157	strcpy((char *)&data[16], "          ST225N");
	158	strcpy((char *)&data[32], "1.0");
	159	break;
151	160
152		case 0x1a:  // MODE SENSE (6 byte)
153		// special Apple ID page.  this is a vendor-specific page,
154		// so unless collisions occur there should be no need
155		// to change it.
156		if ((command[2] & 0x3f) == 0x30)
157		{
158		memset(data, 0, 40);
159		data[0] = 0x14;
160		strcpy((char *)&data[14], "APPLE COMPUTER, INC.");
161		}
162		break;
	161	case T10SPC_CMD_MODE_SENSE_6:
	162	// special Apple ID page.  this is a vendor-specific page,
	163	// so unless collisions occur there should be no need
	164	// to change it.
	165	if ((command[2] & 0x3f) == 0x30)
	166	{
	167	memset(data, 0, 40);
	168	data[0] = 0x14;
	169	strcpy((char *)&data[14], "APPLE COMPUTER, INC.");
	170	}
	171	break;
163	172
164		case 0x08: // READ(6)
165		case 0x28: // READ(10)
166		case 0xa8: // READ(12)
167		if ((disk) && (blocks))
	173	case T10SBC_CMD_READ_6:
	174	case T10SBC_CMD_READ_10:
	175	case T10SBC_CMD_READ_12:
	176	if ((m_disk) && (m_blocks))
	177	{
	178	while (dataLength > 0)
168	179	{
169		while (dataLength > 0)
	180	if (!hard_disk_read(m_disk, m_lba,  data))
170	181	{
171		if (!hard_disk_read(disk, lba,  data))
172		{
173		logerror("T10SBC: HD read error!\n");
174		}
175		lba++;
176		blocks--;
177		dataLength -= m_sector_bytes;
178		data += m_sector_bytes;
	182	logerror("T10SBC: HD read error!\n");
179	183	}
	184	m_lba++;
	185	m_blocks--;
	186	dataLength -= m_sector_bytes;
	187	data += m_sector_bytes;
180	188	}
181		break;
	189	}
	190	break;
182	191
	192	case T10SBC_CMD_READ_CAPACITY: // READ CAPACITY
	193	{
	194	hard_disk_info *info;
	195	UINT32 temp;
183	196
184		case 0x25: // READ CAPACITY
185		{
186		hard_disk_info *info;
187		UINT32 temp;
	197	info = hard_disk_get_info(m_disk);
188	198
189		info = hard_disk_get_info(disk);
	199	logerror("T10SBC: READ CAPACITY\n");
190	200
191		logerror("T10SBC: READ CAPACITY\n");
	201	// get # of sectors
	202	temp = info->cylinders * info->heads * info->sectors;
	203	temp--;
192	204
193		// get # of sectors
194		temp = info->cylinders * info->heads * info->sectors;
195		temp--;
	205	data[0] = (temp>>24) & 0xff;
	206	data[1] = (temp>>16) & 0xff;
	207	data[2] = (temp>>8) & 0xff;
	208	data[3] = (temp & 0xff);
	209	data[4] = (info->sectorbytes>>24)&0xff;
	210	data[5] = (info->sectorbytes>>16)&0xff;
	211	data[6] = (info->sectorbytes>>8)&0xff;
	212	data[7] = (info->sectorbytes & 0xff);
	213	}
	214	break;
196	215
197		data[0] = (temp>>24) & 0xff;
198		data[1] = (temp>>16) & 0xff;
199		data[2] = (temp>>8) & 0xff;
200		data[3] = (temp & 0xff);
201		data[4] = (info->sectorbytes>>24)&0xff;
202		data[5] = (info->sectorbytes>>16)&0xff;
203		data[6] = (info->sectorbytes>>8)&0xff;
204		data[7] = (info->sectorbytes & 0xff);
205		}
206		break;
207
208		default:
209		t10spc::ReadData( data, dataLength );
210		break;
	216	default:
	217	t10spc::ReadData( data, dataLength );
	218	break;
211	219	}
212	220	}
213	221
214	222	void t10sbc::WriteData( UINT8 *data, int dataLength )
215	223	{
216		if (!disk)
	224	if (!m_disk)
217	225	{
218	226	return;
219	227	}
220	228
221	229	switch ( command[0] )
222	230	{
223		case 0x0a: // WRITE(6)
224		case 0x2a: // WRITE(10)
225		if ((disk) && (blocks))
	231	case T10SPC_CMD_MODE_SELECT_6:
	232	break;
	233
	234	case T10SBC_CMD_WRITE_6:
	235	case T10SBC_CMD_WRITE_10:
	236	if ((m_disk) && (m_blocks))
	237	{
	238	while (dataLength > 0)
226	239	{
227		while (dataLength > 0)
	240	if (!hard_disk_write(m_disk, m_lba, data))
228	241	{
229		if (!hard_disk_write(disk, lba, data))
230		{
231		logerror("T10SBC: HD write error!\n");
232		}
233		lba++;
234		blocks--;
235		dataLength -= m_sector_bytes;
236		data += m_sector_bytes;
	242	logerror("T10SBC: HD write error!\n");
237	243	}
	244	m_lba++;
	245	m_blocks--;
	246	dataLength -= m_sector_bytes;
	247	data += m_sector_bytes;
238	248	}
239		break;
	249	}
	250	break;
240	251
241		default:
242		t10spc::WriteData( data, dataLength );
243		break;
	252	default:
	253	t10spc::WriteData( data, dataLength );
	254	break;
244	255	}
245	256	}
246	257
247	258	void t10sbc::GetDevice( void **_disk )
248	259	{
249		*(hard_disk_file **)_disk = disk;
	260	*(hard_disk_file **)_disk = m_disk;
250	261	}
251	262
252	263	void t10sbc::SetDevice( void *_disk )
253	264	{
254		disk = (hard_disk_file *)_disk;
	265	m_disk = (hard_disk_file *)_disk;
255	266	}

trunk/src/emu/machine/t10sbc.h

r26280	r26281
25	25
26	26	harddisk_image_device *m_image;
27	27
28		UINT32 lba;
29		UINT32 blocks;
	28	UINT32 m_lba;
	29	UINT32 m_blocks;
30	30
31		hard_disk_file *disk;
	31	hard_disk_file *m_disk;
32	32	};
33	33
34	34	#endif

trunk/src/emu/machine/nscsi_s1410.c

r26280	r26281
58	58	blocks = (bytes_per_sector == 256) ? 32 : 17;
59	59
60	60	int track_length = blocks*bytes_per_sector;
61		UINT8 data[track_length];
	61	UINT8 *data = global_alloc_array(UINT8,track_length);
62	62	memset(data, 0xc6, track_length);
63	63
64	64	if(!hard_disk_write(harddisk, lba, data)) {
r26280	r26281
67	67	} else {
68	68	scsi_status_complete(SS_GOOD);
69	69	}
	70	global_free(data);
70	71	}
71	72	break;
72	73

trunk/src/emu/diserial.h

r26280	r26281
149	149	attotime m_tra_rate;
150	150	UINT8 m_rcv_line;
151	151
152		bool m_tra_clock_state, m_rcv_clock_state;
	152	int m_tra_clock_state, m_rcv_clock_state;
153	153
154	154	device_serial_interface *m_other_connection;
155	155

trunk/src/mess/machine/acb4070.c

r26280	r26281
35	35	m_transfer_length = TRANSFERLENGTH_DATA_BUFFER;
36	36	break;
37	37
38		case SCSI_CMD_MODE_SELECT:
	38	case T10SPC_CMD_MODE_SELECT_6:
39	39	m_phase = SCSI_PHASE_DATAOUT;
40	40	m_status_code = SCSI_STATUS_CODE_GOOD;
41	41	m_transfer_length = SCSILengthFromUINT8( &command[ 4 ] );
r26280	r26281
51	51	{
52	52	switch( command[ 0 ] )
53	53	{
54		case SCSI_CMD_MODE_SELECT:
	54	case T10SPC_CMD_MODE_SELECT_6:
55	55	adaptec_sense_t *sense=(adaptec_sense_t *) data;
56	56	int tracks=(sense->cylinder_count[0]<<8)+sense->cylinder_count[1];
57	57	int capacity=(tracks * sense->head_count * 17);

trunk/src/mess/machine/s1410.c

r26280	r26281
203	203
204	204	#define S1410_CMD_CHECK_TRACK_FORMAT ( 0x05 )
205	205	#define S1410_CMD_FORMAT_TRACK ( 0x06 )
206		#define S1410_CMD_SEEK ( 0x0b )
207	206	#define S1410_CMD_INIT_DRIVE_PARAMS ( 0x0c )
208	207	#define S1410_CMD_FORMAT_ALT_TRACK ( 0x0E )
209	208	#define S1410_CMD_WRITE_SEC_BUFFER ( 0x0F )
r26280	r26281
222	221	{
223	222	switch( command[ 0 ] )
224	223	{
225		case SCSI_CMD_RECALIBRATE:
	224	case T10SPC_CMD_RECALIBRATE:
226	225	if (command[1] >> 5)
227	226	{
228	227	m_phase = SCSI_PHASE_STATUS;
r26280	r26281
236	235	}
237	236	break;
238	237
239		case SCSI_CMD_REQUEST_SENSE:
	238	case T10SPC_CMD_REQUEST_SENSE:
240	239	m_phase = SCSI_PHASE_DATAIN;
241	240	m_status_code = SCSI_STATUS_CODE_GOOD;
242	241	m_transfer_length = 4;
r26280	r26281
244	243
245	244	case S1410_CMD_FORMAT_TRACK:
246	245	{
247		lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
	246	m_lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
248	247
249	248	switch( m_sector_bytes )
250	249	{
251	250	case 256:
252		blocks = 32;
	251	m_blocks = 32;
253	252	break;
254	253
255	254	case 512:
256		blocks = 17;
	255	m_blocks = 17;
257	256	break;
258	257	}
259	258
260		logerror("S1410: FORMAT TRACK at LBA %x for %x blocks\n", lba, blocks);
	259	logerror("S1410: FORMAT TRACK at LBA %x for %x blocks\n", m_lba, m_blocks);
261	260
262		int dataLength = blocks * m_sector_bytes;
263		UINT8 data[dataLength];
264		memset(data, 0xc6, dataLength);
	261	if ((m_disk) && (m_blocks))
	262	{
	263	UINT8 *data = global_alloc_array(UINT8, m_sector_bytes);
	264	memset(data, 0xc6, m_sector_bytes);
265	265
266		WriteData(data, dataLength);
	266	while (m_blocks > 0)
	267	{
	268	if (!hard_disk_write(m_disk, m_lba, data))
	269	{
	270	logerror("S1410: HD write error!\n");
	271	}
	272	m_lba++;
	273	m_blocks--;
	274	}
267	275
268		m_phase = SCSI_PHASE_STATUS;
269		m_transfer_length = 0;
	276	global_free(data);
270	277	}
271		break;
272	278
273		case S1410_CMD_SEEK:
274		lba = (command[1]&0x1f)<<16 | command[2]<<8 | command[3];
275
276		logerror("S1410: SEEK to LBA %x\n", lba);
277
278	279	m_phase = SCSI_PHASE_STATUS;
279	280	m_transfer_length = 0;
	281	}
280	282	break;
281	283
282	284	case S1410_CMD_INIT_DRIVE_PARAMS:
r26280	r26281
322	324	{
323	325	switch( command[ 0 ] )
324	326	{
325		case S1410_CMD_FORMAT_TRACK:
326		if ((disk) && (blocks))
327		{
328		while (dataLength > 0)
329		{
330		if (!hard_disk_write(disk, lba, data))
331		{
332		logerror("S1410: HD write error!\n");
333		}
334		lba++;
335		blocks--;
336		dataLength -= m_sector_bytes;
337		data += m_sector_bytes;
338		}
339		}
340		break;
341
342	327	case S1410_CMD_INIT_DRIVE_PARAMS:
343	328	{
344	329	int sectorsPerTrack = 0;
r26280	r26281
372	357	{
373	358	switch( command[ 0 ] )
374	359	{
375		case SCSI_CMD_REQUEST_SENSE:
	360	case T10SPC_CMD_REQUEST_SENSE:
376	361	data[0] = m_sense_asc & 0x7f;
377	362	data[1] = (m_sense_information >> 16) & 0x1f;
378	363	data[2] = (m_sense_information >> 8) & 0xff;

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team