ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/cdrom.cpp

Comparing BasiliskII/src/cdrom.cpp (file contents):
Revision 1.1 by cebix, 1999-10-03T14:16:25Z vs.
Revision 1.16 by cebix, 2002-01-15T14:58:32Z

#	Line 1 | Line 1
1		/*
2		*  cdrom.cpp - CD-ROM driver
3		*
4	<	*  Basilisk II (C) 1997-1999 Christian Bauer
4	>	*  Basilisk II (C) 1997-2002 Christian Bauer
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 28 | Line 28
28		*    Technote FL 36: "Apple Extensions to ISO 9660"
29		*/
30
31	+	#include "sysdeps.h"
32	+
33		#include <string.h>
34	+	#include <vector>
35	+
36	+	#ifndef NO_STD_NAMESPACE
37	+	using std::vector;
38	+	#endif
39
33	–	#include "sysdeps.h"
40		#include "cpu_emulation.h"
41		#include "main.h"
42		#include "macos_util.h"
#	Line 97 | Line 103 | static const uint8 bin2bcd[256] = {
103		};
104
105		static const uint8 bcd2bin[256] = {
106	<	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
106	>	0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
107		10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
108		20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
109		30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
#	Line 117 | Line 123 | static const uint8 bcd2bin[256] = {
123
124
125		// Struct for each drive
126	<	struct DriveInfo {
127	<	DriveInfo()
128	<	{
129	<	next = NULL;
130	<	num = 0;
125	<	fh = NULL;
126	<	start_byte = 0;
127	<	status = 0;
128	<	}
126	>	struct cdrom_drive_info {
127	>	cdrom_drive_info() : num(0), fh(NULL), start_byte(0), status(0) {}
128	>	cdrom_drive_info(void *fh_) : num(0), fh(fh_), start_byte(0), status(0) {}
129	>
130	>	void close_fh(void) { SysAllowRemoval(fh); Sys_close(fh); }
131
130	–	DriveInfo *next;        // Pointer to next DriveInfo (must be first in struct!)
132		int num;                        // Drive number
133		void *fh;                       // File handle
134		int block_size;         // CD-ROM block size
135		int twok_offset;        // Offset of beginning of 2K block to last Prime position
136	<	uint32 start_byte;      // Start of HFS partition on disk
136	>	loff_t start_byte;      // Start of HFS partition on disk
137		bool to_be_mounted;     // Flag: drive must be mounted in accRun
138		bool mount_non_hfs;     // Flag: Issue disk-inserted events for non-HFS disks
139
#	Line 145 | Line 146 | struct DriveInfo {
146		uint32 status;          // Mac address of drive status record
147		};
148
149	<	// Linked list of DriveInfos
150	<	static DriveInfo *first_drive_info;
149	>	// List of drives handled by this driver
150	>	typedef vector<cdrom_drive_info> drive_vec;
151	>	static drive_vec drives;
152
153		// Icon address (Mac address space, set by PatchROM())
154		uint32 CDROMIconAddr;
155
156	+	// Flag: Control(accRun) has been called, interrupt routine is now active
157	+	static bool acc_run_called = false;
158	+
159
160		/*
161	<	*  Get pointer to drive info, NULL = invalid drive number
161	>	*  Get pointer to drive info or drives.end() if not found
162		*/
163
164	<	static DriveInfo *get_drive_info(int num)
164	>	static drive_vec::iterator get_drive_info(int num)
165		{
166	<	DriveInfo *info = first_drive_info;
167	<	while (info != NULL) {
166	>	drive_vec::iterator info, end = drives.end();
167	>	for (info = drives.begin(); info != end; ++info) {
168		if (info->num == num)
169		return info;
165	–	info = info->next;
170		}
171	<	return NULL;
171	>	return info;
172		}
173
174
#	Line 172 | Line 176 | static DriveInfo *get_drive_info(int num
176		*  Find HFS partition, set info->start_byte (0 = no HFS partition)
177		*/
178
179	<	static void find_hfs_partition(DriveInfo *info)
179	>	static void find_hfs_partition(cdrom_drive_info &info)
180		{
181	<	info->start_byte = 0;
181	>	info.start_byte = 0;
182		uint8 *map = new uint8[512];
183
184		// Search first 64 blocks for HFS partition
185		for (int i=0; i<64; i++) {
186	<	if (Sys_read(info->fh, map, i * 512, 512) != 512)
186	>	if (Sys_read(info.fh, map, i * 512, 512) != 512)
187		break;
188
189	<	// Skip driver descriptor
190	<	uint16 sig = ntohs(((uint16 *)map)[0]);
191	<	if (sig == 'ER')
188	<	continue;
189	<
190	<	// No partition map? Then look at next block
191	<	if (sig != 'PM')
189	>	// Not a partition map block? Then look at next block
190	>	uint16 sig = (map[0] << 8) | map[1];
191	>	if (sig != 0x504d)
192		continue;
193
194	<	// Partition map found, Apple HFS partition?
194	>	// Partition map block found, Apple HFS partition?
195		if (strcmp((char *)(map + 48), "Apple_HFS") == 0) {
196	<	info->start_byte = ntohl(((uint32 *)map)[2]) << 9;
197	<	D(bug(" HFS partition found at %ld, %ld blocks\n", info->start_byte, ntohl(((uint32 *)map)[3])));
196	>	info.start_byte = ntohl(((uint32 *)map)[2]) << 9;
197	>	D(bug(" HFS partition found at %d, %d blocks\n", info.start_byte, ntohl(((uint32 *)map)[3])));
198		break;
199		}
200		}
#	Line 206 | Line 206 | static void find_hfs_partition(DriveInfo
206		*  Read TOC of disk and set lead_out
207		*/
208
209	<	static void read_toc(DriveInfo *info)
209	>	static void read_toc(cdrom_drive_info &info)
210		{
211		// Read TOC
212	<	memset(&info->toc, 0, sizeof(info->toc));
213	<	SysCDReadTOC(info->fh, info->toc);
214	<	D(bug(" TOC: %08lx %08lx\n", ntohl(((uint32 *)info->toc)[0]), ntohl(((uint32 *)info->toc)[1])));
212	>	memset(info.toc, 0, sizeof(info.toc));
213	>	SysCDReadTOC(info.fh, info.toc);
214	>	D(bug(" TOC: %08lx %08lx\n", ntohl(((uint32 *)info.toc)[0]), ntohl(((uint32 *)info.toc)[1])));
215
216		// Find lead-out track
217	<	info->lead_out[0] = 0;
218	<	info->lead_out[1] = 0;
219	<	info->lead_out[2] = 0;
217	>	info.lead_out[0] = 0;
218	>	info.lead_out[1] = 0;
219	>	info.lead_out[2] = 0;
220		for (int i=4; i<804; i+=8) {
221	<	if (info->toc[i+2] == 0xaa) {
222	<	info->stop_at[0] = info->lead_out[0] = info->toc[i+5];
223	<	info->stop_at[1] = info->lead_out[1] = info->toc[i+6];
224	<	info->stop_at[2] = info->lead_out[2] = info->toc[i+7];
221	>	if (info.toc[i+2] == 0xaa) {
222	>	info.stop_at[0] = info.lead_out[0] = info.toc[i+5];
223	>	info.stop_at[1] = info.lead_out[1] = info.toc[i+6];
224	>	info.stop_at[2] = info.lead_out[2] = info.toc[i+7];
225		break;
226		}
227		}
228	<	D(bug(" Lead-Out M %d S %d F %d\n", info->lead_out[0], info->lead_out[1], info->lead_out[2]));
228	>	D(bug(" Lead-Out M %d S %d F %d\n", info.lead_out[0], info.lead_out[1], info.lead_out[2]));
229		}
230
231
#	Line 234 | Line 234 | static void read_toc(DriveInfo *info)
234		*  Return: false = error
235		*/
236
237	<	static bool position2msf(DriveInfo *info, uint16 postype, uint32 pos, bool stopping, uint8 &m, uint8 &s, uint8 &f)
237	>	static bool position2msf(const cdrom_drive_info &info, uint16 postype, uint32 pos, bool stopping, uint8 &m, uint8 &s, uint8 &f)
238		{
239		switch (postype) {
240		case 0:
#	Line 252 | Line 252 | static bool position2msf(DriveInfo *info
252		if (stopping)
253		track++;
254		for (int i=4; i<804; i+=8) {
255	<	if (info->toc[i+2] == track || info->toc[i+2] == 0xaa) {
256	<	m = info->toc[i+5];
257	<	s = info->toc[i+6];
258	<	f = info->toc[i+7];
255	>	if (info.toc[i+2] == track || info.toc[i+2] == 0xaa) {
256	>	m = info.toc[i+5];
257	>	s = info.toc[i+6];
258	>	f = info.toc[i+7];
259		return true;
260		}
261		}
#	Line 273 | Line 273 | static bool position2msf(DriveInfo *info
273
274		void CDROMInit(void)
275		{
276	–	first_drive_info = NULL;
277	–
276		// No drives specified in prefs? Then add defaults
277		if (PrefsFindString("cdrom", 0) == NULL)
278		SysAddCDROMPrefs();
279
280		// Add drives specified in preferences
281	<	int32 index = 0;
281	>	int index = 0;
282		const char *str;
283		while ((str = PrefsFindString("cdrom", index++)) != NULL) {
284		void *fh = Sys_open(str, true);
285	<	if (fh) {
286	<	DriveInfo *info = new DriveInfo;
289	<	info->fh = fh;
290	<	DriveInfo *p = (DriveInfo *)&first_drive_info;
291	<	while (p->next != NULL)
292	<	p = p->next;
293	<	p->next = info;
294	<	}
285	>	if (fh)
286	>	drives.push_back(cdrom_drive_info(fh));
287		}
288		}
289
#	Line 302 | Line 294 | void CDROMInit(void)
294
295		void CDROMExit(void)
296		{
297	<	DriveInfo *info = first_drive_info, *next;
298	<	while (info != NULL) {
299	<	Sys_close(info->fh);
300	<	next = info->next;
309	<	delete info;
310	<	info = next;
311	<	}
297	>	drive_vec::iterator info, end = drives.end();
298	>	for (info = drives.begin(); info != end; ++info)
299	>	info->close_fh();
300	>	drives.clear();
301		}
302
303
#	Line 318 | Line 307 | void CDROMExit(void)
307
308		bool CDROMMountVolume(void *fh)
309		{
310	<	DriveInfo *info;
311	<	for (info = first_drive_info; info != NULL && info->fh != fh; info = info->next) ;
312	<	if (info) {
310	>	drive_vec::iterator info = drives.begin(), end = drives.end();
311	>	while (info != end && info->fh != fh)
312	>	++info;
313	>	if (info != end) {
314		if (SysIsDiskInserted(info->fh)) {
315		SysPreventRemoval(info->fh);
316		WriteMacInt8(info->status + dsDiskInPlace, 1);
317	<	read_toc(info);
318	<	find_hfs_partition(info);
317	>	read_toc(*info);
318	>	find_hfs_partition(*info);
319		if (info->start_byte != 0 || info->mount_non_hfs)
320		info->to_be_mounted = true;
321		}
#	Line 336 | Line 326 | bool CDROMMountVolume(void *fh)
326
327
328		/*
329	+	*  Mount volumes for which the to_be_mounted flag is set
330	+	*  (called during interrupt time)
331	+	*/
332	+
333	+	static void mount_mountable_volumes(void)
334	+	{
335	+	drive_vec::iterator info, end = drives.end();
336	+	for (info = drives.begin(); info != end; ++info) {
337	+
338	+	// Disk in drive?
339	+	if (ReadMacInt8(info->status + dsDiskInPlace) == 0) {
340	+
341	+	// No, check if disk was inserted
342	+	if (SysIsDiskInserted(info->fh))
343	+	CDROMMountVolume(info->fh);
344	+	}
345	+
346	+	// Mount disk if flagged
347	+	if (info->to_be_mounted) {
348	+	D(bug(" mounting drive %d\n", info->num));
349	+	M68kRegisters r;
350	+	r.d[0] = info->num;
351	+	r.a[0] = 7;     // diskEvent
352	+	Execute68kTrap(0xa02f, &r);             // PostEvent()
353	+	info->to_be_mounted = false;
354	+	}
355	+	}
356	+	}
357	+
358	+
359	+	/*
360		*  Driver Open() routine
361		*/
362
#	Line 345 | Line 366 | int16 CDROMOpen(uint32 pb, uint32 dce)
366
367		// Set up DCE
368		WriteMacInt32(dce + dCtlPosition, 0);
369	+	acc_run_called = false;
370
371		// Install drives
372	<	for (DriveInfo *info = first_drive_info; info; info = info->next) {
372	>	drive_vec::iterator info, end = drives.end();
373	>	for (info = drives.begin(); info != end; ++info) {
374
375		info->num = FindFreeDriveNumber(1);
376		info->to_be_mounted = false;
#	Line 377 | Line 400 | int16 CDROMOpen(uint32 pb, uint32 dce)
400		if (SysIsDiskInserted(info->fh)) {
401		SysPreventRemoval(info->fh);
402		WriteMacInt8(info->status + dsDiskInPlace, 1);
403	<	read_toc(info);
404	<	find_hfs_partition(info);
403	>	read_toc(*info);
404	>	find_hfs_partition(*info);
405		info->to_be_mounted = true;
406		}
407
#	Line 402 | Line 425 | int16 CDROMPrime(uint32 pb, uint32 dce)
425		WriteMacInt32(pb + ioActCount, 0);
426
427		// Drive valid and disk inserted?
428	<	DriveInfo *info;
429	<	if ((info = get_drive_info(ReadMacInt16(pb + ioVRefNum))) == NULL)
428	>	drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
429	>	if (info == drives.end())
430		return nsDrvErr;
431		if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
432		return offLinErr;
#	Line 456 | Line 479 | int16 CDROMControl(uint32 pb, uint32 dce
479		case 1:         // KillIO
480		return noErr;
481
482	<	case 65: {      // Periodic action ("insert" disks on startup and check for disk changes)
483	<	DriveInfo *info = first_drive_info;
484	<	while (info != NULL) {
485	<
463	<	// Disk in drive?
464	<	if (ReadMacInt8(info->status + dsDiskInPlace) == 0) {
465	<
466	<	// No, check if disk was inserted
467	<	if (SysIsDiskInserted(info->fh))
468	<	CDROMMountVolume(info->fh);
469	<	}
470	<
471	<	// Mount disk if flagged
472	<	if (info->to_be_mounted) {
473	<	D(bug(" mounting drive %d\n", info->num));
474	<	M68kRegisters r;
475	<	r.d[0] = info->num;
476	<	r.a[0] = 7;     // diskEvent
477	<	Execute68kTrap(0xa02f, &r);             // PostEvent()
478	<	info->to_be_mounted = false;
479	<	}
480	<
481	<	info = info->next;
482	<	}
482	>	case 65: {      // Periodic action (accRun, "insert" disks on startup)
483	>	mount_mountable_volumes();
484	>	WriteMacInt16(dce + dCtlFlags, ReadMacInt16(dce + dCtlFlags) & ~0x2000);        // Disable periodic action
485	>	acc_run_called = true;
486		return noErr;
487		}
488
#	Line 489 | Line 492 | int16 CDROMControl(uint32 pb, uint32 dce
492		}
493
494		// Drive valid?
495	<	DriveInfo *info;
496	<	if ((info = get_drive_info(ReadMacInt16(pb + ioVRefNum))) == NULL)
497	<	if (first_drive_info == NULL)
495	>	drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
496	>	if (info == drives.end()) {
497	>	if (drives.empty())
498		return nsDrvErr;
499		else
500	<	info = first_drive_info;        // This is needed for Apple's Audio CD program
500	>	info = drives.begin();  // This is needed for Apple's Audio CD program
501	>	}
502
503		// Drive-specific codes
504		switch (code) {
#	Line 521 | Line 525 | int16 CDROMControl(uint32 pb, uint32 dce
525		WriteMacInt32(pb + csParam, CDROMIconAddr);
526		return noErr;
527
528	<	case 23:                // DriveInfo
528	>	case 23:                // drive_info
529		WriteMacInt32(pb + csParam, 0x00000b01);        // Unspecified external removable SCSI disk
530		return noErr;
531
#	Line 581 | Line 585 | int16 CDROMControl(uint32 pb, uint32 dce
585		break;
586
587		case 3: {               // Get track starting address
588	<	uint8 *buf = Mac2HostAddr(ReadMacInt32(pb + csParam + 2));
588	>	uint32 buf = ReadMacInt32(pb + csParam + 2);
589		uint16 buf_size = ReadMacInt16(pb + csParam + 6);
590		int track = bcd2bin[ReadMacInt8(pb + csParam + 8)];
591
#	Line 595 | Line 599 | int16 CDROMControl(uint32 pb, uint32 dce
599		// Fill buffer
600		if (i != 804)
601		while (buf_size > 0) {
602	<	*buf++ = info->toc[i+1] & 0x0f;         // Control
603	<	*buf++ = bin2bcd[info->toc[i+5]];       // M
604	<	*buf++ = bin2bcd[info->toc[i+6]];       // S
605	<	*buf++ = bin2bcd[info->toc[i+7]];       // F
602	>	WriteMacInt8(buf, info->toc[i+1] & 0x0f); buf++;        // Control
603	>	WriteMacInt8(buf, bin2bcd[info->toc[i+5]]); buf++;      // M
604	>	WriteMacInt8(buf, bin2bcd[info->toc[i+6]]); buf++;      // S
605	>	WriteMacInt8(buf, bin2bcd[info->toc[i+7]]); buf++;      // F
606
607		// Lead-Out? Then stop
608		if (info->toc[i+2] == 0xaa)
#	Line 629 | Line 633 | int16 CDROMControl(uint32 pb, uint32 dce
633
634		case 101: {             // ReadTheQSubcode
635		if (ReadMacInt8(info->status + dsDiskInPlace) == 0) {
636	<	memset(Mac2HostAddr(pb + csParam), 0, 10);
636	>	Mac_memset(pb + csParam, 0, 10);
637		return offLinErr;
638		}
639
640		uint8 pos[16];
641		if (SysCDGetPosition(info->fh, pos)) {
642	<	uint8 *p = Mac2HostAddr(pb + csParam);
643	<	*p++ = pos[5] & 0x0f;           // Control
644	<	*p++ = bin2bcd[pos[6]];         // Track number
645	<	*p++ = bin2bcd[pos[7]];         // Index number
646	<	*p++ = bin2bcd[pos[13]];        // M (rel)
647	<	*p++ = bin2bcd[pos[14]];        // S (rel)
648	<	*p++ = bin2bcd[pos[15]];        // F (rel)
649	<	*p++ = bin2bcd[pos[9]];         // M (abs)
650	<	*p++ = bin2bcd[pos[10]];        // S (abs)
651	<	*p++ = bin2bcd[pos[11]];        // F (abs)
652	<	*p++ = 0;
642	>	uint32 p = pb + csParam;
643	>	WriteMacInt8(p, pos[5] & 0x0f); p++;    // Control
644	>	WriteMacInt8(p, bin2bcd[pos[6]]); p++;  // Track number
645	>	WriteMacInt8(p, bin2bcd[pos[7]]); p++;  // Index number
646	>	WriteMacInt8(p, bin2bcd[pos[13]]); p++; // M (rel)
647	>	WriteMacInt8(p, bin2bcd[pos[14]]); p++; // S (rel)
648	>	WriteMacInt8(p, bin2bcd[pos[15]]); p++; // F (rel)
649	>	WriteMacInt8(p, bin2bcd[pos[9]]); p++;  // M (abs)
650	>	WriteMacInt8(p, bin2bcd[pos[10]]); p++; // S (abs)
651	>	WriteMacInt8(p, bin2bcd[pos[11]]); p++; // F (abs)
652	>	WriteMacInt8(p, 0);
653		return noErr;
654		} else
655		return ioErr;
#	Line 656 | Line 660 | int16 CDROMControl(uint32 pb, uint32 dce
660		return controlErr;
661
662		case 103: {             // AudioTrackSearch
663	<	D(bug(" AudioTrackSearch postype %d, pos %08lx, hold %d\n", ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), ReadMacInt16(pb + csParam + 6)));
663	>	D(bug(" AudioTrackSearch postype %d, pos %08x, hold %d\n", ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), ReadMacInt16(pb + csParam + 6)));
664		if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
665		return offLinErr;
666
667		uint8 start_m, start_s, start_f;
668	<	if (!position2msf(info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
668	>	if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
669		return paramErr;
670		info->play_mode = ReadMacInt8(pb + csParam + 9) & 0x0f;
671		if (!SysCDPlay(info->fh, start_m, start_s, start_f, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
#	Line 678 | Line 682 | int16 CDROMControl(uint32 pb, uint32 dce
682
683		if (ReadMacInt16(pb + csParam + 6)) {
684		// Given stopping address
685	<	if (!position2msf(info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
685	>	if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
686		return paramErr;
687		} else {
688		// Given starting address
689		uint8 start_m, start_s, start_f;
690	<	if (!position2msf(info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
690	>	if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
691		return paramErr;
692		info->play_mode = ReadMacInt8(pb + csParam + 9) & 0x0f;
693		if (!SysCDPlay(info->fh, start_m, start_s, start_f, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
#	Line 720 | Line 724 | int16 CDROMControl(uint32 pb, uint32 dce
724		return paramErr;
725		} else {
726		// Given stopping address
727	<	if (!position2msf(info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
727	>	if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
728		return paramErr;
729		}
730		return noErr;
#	Line 733 | Line 737 | int16 CDROMControl(uint32 pb, uint32 dce
737		if (!SysCDGetPosition(info->fh, pos))
738		return paramErr;
739
740	<	uint8 *p = Mac2HostAddr(pb + csParam);
740	>	uint32 p = pb + csParam;
741		switch (pos[1]) {
742		case 0x11:
743	<	*p++ = 0;       // Audio play in progress
743	>	WriteMacInt8(p, 0);     // Audio play in progress
744		break;
745		case 0x12:
746	<	*p++ = 1;       // Audio play paused
746	>	WriteMacInt8(p, 1);     // Audio play paused
747		break;
748		case 0x13:
749	<	*p++ = 3;       // Audio play completed
749	>	WriteMacInt8(p, 3);     // Audio play completed
750		break;
751		case 0x14:
752	<	*p++ = 4;       // Error occurred
752	>	WriteMacInt8(p, 4);     // Error occurred
753		break;
754		default:
755	<	*p++ = 5;       // No audio play operation requested
755	>	WriteMacInt8(p, 5);     // No audio play operation requested
756		break;
757		}
758	<	*p++ = info->play_mode;
759	<	*p++ = pos[5] & 0x0f;           // Control
760	<	*p++ = bin2bcd[pos[9]];         // M (abs)
761	<	*p++ = bin2bcd[pos[10]];        // S (abs)
762	<	*p++ = bin2bcd[pos[11]];        // F (abs)
758	>	p++;
759	>	WriteMacInt8(p, info->play_mode); p++;
760	>	WriteMacInt8(p, pos[5] & 0x0f); p++;    // Control
761	>	WriteMacInt8(p, bin2bcd[pos[9]]); p++;  // M (abs)
762	>	WriteMacInt8(p, bin2bcd[pos[10]]); p++; // S (abs)
763	>	WriteMacInt8(p, bin2bcd[pos[11]]); p++; // F (abs)
764		return noErr;
765		}
766
#	Line 764 | Line 769 | int16 CDROMControl(uint32 pb, uint32 dce
769		return offLinErr;
770
771		uint8 start_m, start_s, start_f;
772	<	if (!position2msf(info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
772	>	if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, start_m, start_s, start_f))
773		return paramErr;
774
775		if (!SysCDScan(info->fh, start_m, start_s, start_f, ReadMacInt16(pb + csParam + 6)))
#	Line 842 | Line 847 | int16 CDROMControl(uint32 pb, uint32 dce
847
848		int16 CDROMStatus(uint32 pb, uint32 dce)
849		{
850	<	DriveInfo *info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
850	>	drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
851		uint16 code = ReadMacInt16(pb + csCode);
852		D(bug("CDROMStatus %d\n", code));
853
854	<	// General codes
854	>	// General codes (we can get these even if the drive was invalid)
855		switch (code) {
856		case 43: {      // DriverGestalt
857		uint32 sel = ReadMacInt32(pb + csParam);
858		D(bug(" driver gestalt %c%c%c%c\n", sel >> 24, sel >> 16,  sel >> 8, sel));
859		switch (sel) {
860	<	case 'vers':    // Version
860	>	case FOURCC('v','e','r','s'):   // Version
861		WriteMacInt32(pb + csParam + 4, 0x05208000);
862		break;
863	<	case 'devt':    // Device type
864	<	WriteMacInt32(pb + csParam + 4, 'cdrm');
863	>	case FOURCC('d','e','v','t'):   // Device type
864	>	WriteMacInt32(pb + csParam + 4, FOURCC('c','d','r','m'));
865		break;
866	<	case 'intf':    // Interface type
867	<	WriteMacInt32(pb + csParam + 4, 'basi');
866	>	case FOURCC('i','n','t','f'):   // Interface type
867	>	WriteMacInt32(pb + csParam + 4, EMULATOR_ID_4);
868		break;
869	<	case 'sync':    // Only synchronous operation?
869	>	case FOURCC('s','y','n','c'):   // Only synchronous operation?
870		WriteMacInt32(pb + csParam + 4, 0x01000000);
871		break;
872	<	case 'boot':    // Boot ID
873	<	if (info != NULL)
872	>	case FOURCC('b','o','o','t'):   // Boot ID
873	>	if (info != drives.end())
874		WriteMacInt16(pb + csParam + 4, info->num);
875		else
876		WriteMacInt16(pb + csParam + 4, 0);
877		WriteMacInt16(pb + csParam + 6, (uint16)CDROMRefNum);
878		break;
879	<	case 'wide':    // 64-bit access supported?
879	>	case FOURCC('w','i','d','e'):   // 64-bit access supported?
880		WriteMacInt16(pb + csParam + 4, 0);
881		break;
882	<	case 'purg':    // Purge flags
882	>	case FOURCC('p','u','r','g'):   // Purge flags
883		WriteMacInt32(pb + csParam + 4, 0);
884		break;
885	<	case 'ejec':    // Eject flags
885	>	case FOURCC('e','j','e','c'):   // Eject flags
886		WriteMacInt32(pb + csParam + 4, 0x00030003);    // Don't eject on shutdown/restart
887		break;
888	<	case 'flus':    // Flush flags
888	>	case FOURCC('f','l','u','s'):   // Flush flags
889		WriteMacInt16(pb + csParam + 4, 0);
890		break;
891	<	case 'vmop':    // Virtual memory attributes
891	>	case FOURCC('v','m','o','p'):   // Virtual memory attributes
892		WriteMacInt32(pb + csParam + 4, 0);     // Drive not available for VM
893		break;
894		default:
#	Line 894 | Line 899 | int16 CDROMStatus(uint32 pb, uint32 dce)
899		}
900
901		// Drive valid?
902	<	if (info == NULL)
903	<	if (first_drive_info == NULL)
902	>	if (info == drives.end()) {
903	>	if (drives.empty())
904		return nsDrvErr;
905		else
906	<	info = first_drive_info;        // This is needed for Apple's Audio CD program
906	>	info = drives.begin();  // This is needed for Apple's Audio CD program
907	>	}
908
909		// Drive-specific codes
910		switch (code) {
911	+	case 6:                 // Return format list
912	+	if (ReadMacInt16(pb + csParam) > 0) {
913	+	uint32 adr = ReadMacInt32(pb + csParam + 2);
914	+	WriteMacInt16(pb + csParam, 1);                                         // 1 format
915	+	WriteMacInt32(adr, SysGetFileSize(info->fh) / 512);     // Number of blocks
916	+	WriteMacInt32(adr + 4, 0);                                                      // heads/track/sectors
917	+	return noErr;
918	+	} else
919	+	return paramErr;
920	+
921		case 8:                 // DriveStatus
922	<	memcpy(Mac2HostAddr(pb + csParam), Mac2HostAddr(info->status), 22);
922	>	Mac2Mac_memcpy(pb + csParam, info->status, 22);
923		return noErr;
924
925		case 70:                // GetPowerMode
#	Line 939 | Line 955 | int16 CDROMStatus(uint32 pb, uint32 dce)
955		return statusErr;
956		}
957		}
958	+
959	+
960	+	/*
961	+	*  Driver interrupt routine (1Hz) - check for volumes to be mounted
962	+	*/
963	+
964	+	void CDROMInterrupt(void)
965	+	{
966	+	if (!acc_run_called)
967	+	return;
968	+
969	+	mount_mountable_volumes();
970	+	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines