macemu/BasiliskII/src/cdrom.cpp

1150 lines
35 KiB
C++
Raw Normal View History

1999-10-03 14:16:26 +00:00
/*
* cdrom.cpp - CD-ROM driver
*
2008-01-01 09:40:36 +00:00
* Basilisk II (C) 1997-2008 Christian Bauer
1999-10-03 14:16:26 +00:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* SEE ALSO
* Inside Macintosh: Devices, chapter 1 "Device Manager"
* Technote DV 05: "Drive Queue Elements"
* Technote DV 22: "CD-ROM Driver Calls"
* Technote DV 23: "Driver Education"
* Technote FL 24: "Don't Look at ioPosOffset for Devices"
* Technote FL 36: "Apple Extensions to ISO 9660"
*/
#include "sysdeps.h"
1999-10-03 14:16:26 +00:00
#include <string.h>
#include <vector>
#ifndef NO_STD_NAMESPACE
using std::vector;
#endif
1999-10-03 14:16:26 +00:00
#include "cpu_emulation.h"
#include "main.h"
#include "macos_util.h"
#include "sys.h"
#include "prefs.h"
#include "cdrom.h"
#define DEBUG 0
#include "debug.h"
// CDROM disk/drive icon
const uint8 CDROMIcon[258] = {
0x3f, 0xff, 0xff, 0xf0, 0x40, 0x00, 0x00, 0x08, 0x80, 0x1f, 0xc0, 0x04, 0x80, 0x75, 0x70, 0x04,
0x81, 0xaa, 0xac, 0x04, 0x83, 0x55, 0x56, 0x04, 0x86, 0xaa, 0xab, 0x04, 0x8d, 0x55, 0x55, 0x84,
0x8a, 0xaa, 0xaa, 0xc4, 0x95, 0x5f, 0xd5, 0x44, 0x9a, 0xb0, 0x6a, 0xe4, 0xb5, 0x67, 0x35, 0x64,
0xaa, 0xcf, 0x9a, 0xb4, 0xb5, 0x5c, 0x55, 0x74, 0xaa, 0xd8, 0x5a, 0xb4, 0xb5, 0x58, 0x55, 0x74,
0xaa, 0xc8, 0x9a, 0xb4, 0xb5, 0x67, 0x35, 0x74, 0x9a, 0xb0, 0x6a, 0xf4, 0x95, 0x5f, 0xd5, 0x64,
0x8a, 0xaa, 0xaa, 0xe4, 0x8d, 0x55, 0x55, 0xc4, 0x86, 0xaa, 0xab, 0xc4, 0x83, 0x55, 0x57, 0x84,
0x81, 0xaa, 0xaf, 0x04, 0x80, 0xf5, 0x7e, 0x04, 0x80, 0x3f, 0xf8, 0x04, 0x80, 0x0f, 0xe0, 0x04,
0xff, 0xff, 0xff, 0xfc, 0x80, 0x00, 0x00, 0x04, 0x80, 0x1f, 0xf0, 0x04, 0x7f, 0xff, 0xff, 0xf8,
1999-10-03 14:16:26 +00:00
0x3f, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc,
0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xf8,
1999-10-03 14:16:26 +00:00
0, 0
};
// Tables for converting bin<->BCD
static const uint8 bin2bcd[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
static const uint8 bcd2bin[256] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1999-10-03 14:16:26 +00:00
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
// Struct for each drive
struct cdrom_drive_info {
cdrom_drive_info() : num(0), fh(NULL), start_byte(0), status(0) {}
cdrom_drive_info(void *fh_) : num(0), fh(fh_), start_byte(0), status(0) {}
void close_fh(void) { SysAllowRemoval(fh); Sys_close(fh); }
1999-10-03 14:16:26 +00:00
int num; // Drive number
void *fh; // File handle
int block_size; // CD-ROM block size
int twok_offset; // Offset of beginning of 2K block to last Prime position
loff_t start_byte; // Start of HFS partition on disk
1999-10-03 14:16:26 +00:00
bool to_be_mounted; // Flag: drive must be mounted in accRun
bool mount_non_hfs; // Flag: Issue disk-inserted events for non-HFS disks
1999-10-03 14:16:26 +00:00
uint8 toc[804]; // TOC of currently inserted disk
uint8 lead_out[3]; // MSF address of lead-out track
uint8 stop_at[3]; // MSF address of audio play stopping point
uint8 start_at[3]; // MSF address of position set by track search or audio play
1999-10-03 14:16:26 +00:00
uint8 play_mode; // Audio play mode
uint8 play_order; // Play mode order (normal, shuffle, program)
bool repeat; // Repeat flag
1999-10-03 14:16:26 +00:00
uint8 power_mode; // Power mode
uint32 status; // Mac address of drive status record
};
// List of drives handled by this driver
typedef vector<cdrom_drive_info> drive_vec;
static drive_vec drives;
1999-10-03 14:16:26 +00:00
int last_drive_num; // track last drive called to support multiple audio CDs
1999-10-03 14:16:26 +00:00
// Icon address (Mac address space, set by PatchROM())
uint32 CDROMIconAddr;
// Flag: Control(accRun) has been called, interrupt routine is now active
static bool acc_run_called = false;
1999-10-03 14:16:26 +00:00
/*
* Get pointer to drive info or drives.end() if not found
1999-10-03 14:16:26 +00:00
*/
static drive_vec::iterator get_drive_info(int num)
1999-10-03 14:16:26 +00:00
{
drive_vec::iterator info, end = drives.end();
for (info = drives.begin(); info != end; ++info) {
if (info->num == num) {
last_drive_num = num;
1999-10-03 14:16:26 +00:00
return info;
}
1999-10-03 14:16:26 +00:00
}
return info;
1999-10-03 14:16:26 +00:00
}
/*
* Find HFS partition, set info->start_byte (0 = no HFS partition)
*/
static void find_hfs_partition(cdrom_drive_info &info)
1999-10-03 14:16:26 +00:00
{
info.start_byte = 0;
1999-10-03 14:16:26 +00:00
uint8 *map = new uint8[512];
D(bug("Looking for HFS partitions on CD-ROM...\n"));
1999-10-03 14:16:26 +00:00
// Search first 64 blocks for HFS partition
for (int i=0; i<64; i++) {
if (Sys_read(info.fh, map, i * 512, 512) != 512)
1999-10-03 14:16:26 +00:00
break;
D(bug(" block %d, signature '%c%c' (%02x%02x)\n", i, map[0], map[1], map[0], map[1]));
// Not a partition map block? Then look at next block
uint16 sig = (map[0] << 8) | map[1];
2000-07-22 16:07:23 +00:00
if (sig != 0x504d)
1999-10-03 14:16:26 +00:00
continue;
// Partition map block found, Apple HFS partition?
1999-10-03 14:16:26 +00:00
if (strcmp((char *)(map + 48), "Apple_HFS") == 0) {
info.start_byte = (loff_t)((map[8] << 24) | (map[9] << 16) | (map[10] << 8) | map[11]) << 9;
#if DEBUG
uint32 num_blocks = (map[12] << 24) | (map[13] << 16) | (map[14] << 8) | map[15];
D(bug(" HFS partition found at %d, %d blocks\n", info.start_byte, num_blocks));
#endif
1999-10-03 14:16:26 +00:00
break;
}
}
delete[] map;
}
/*
* Read TOC of disk and set lead_out
*/
static void read_toc(cdrom_drive_info &info)
1999-10-03 14:16:26 +00:00
{
// Read TOC
memset(info.toc, 0, sizeof(info.toc));
SysCDReadTOC(info.fh, info.toc);
#if DEBUG
// Dump TOC for debugging
D(bug(" TOC:\n %02x%02x%02x%02x : %d bytes, first track = %d, last track = %d\n", info.toc[0], info.toc[1], info.toc[2], info.toc[3], (info.toc[0] << 8) | info.toc[1], info.toc[2], info.toc[3]));
for (int i=4; i<804; i+=8) {
D(bug(" %02x%02x%02x%02x%02x%02x%02x%02x: ", info.toc[i+0], info.toc[i+1], info.toc[i+2], info.toc[i+3], info.toc[i+4], info.toc[i+5], info.toc[i+6], info.toc[i+7]));
const char *type = (info.toc[i+2] == 0xaa ? "lead-out" : (info.toc[i+1] & 0x04 ? "data" : "audio"));
D(bug("track %d (%s), addr/ctrl 0x%02x, M %d S %d F %d\n", info.toc[i+2], type, info.toc[i+1], info.toc[i+5], info.toc[i+6], info.toc[i+7]));
if (info.toc[i+2] == 0xaa)
break;
}
#endif
// Default start
info.start_at[0] = 0;
info.start_at[1] = 0;
info.start_at[2] = 0;
1999-10-03 14:16:26 +00:00
// Find lead-out track
info.lead_out[0] = 0;
info.lead_out[1] = 0;
info.lead_out[2] = 0;
1999-10-03 14:16:26 +00:00
for (int i=4; i<804; i+=8) {
if (info.toc[i+2] == 0xaa) {
info.stop_at[0] = info.lead_out[0] = info.toc[i+5];
info.stop_at[1] = info.lead_out[1] = info.toc[i+6];
info.stop_at[2] = info.lead_out[2] = info.toc[i+7];
1999-10-03 14:16:26 +00:00
break;
}
}
D(bug(" Lead-Out M %d S %d F %d\n", info.lead_out[0], info.lead_out[1], info.lead_out[2]));
1999-10-03 14:16:26 +00:00
}
/*
* Convert audio positioning type/position to MSF address
* Return: false = error
*/
static bool position2msf(const cdrom_drive_info &info, uint16 postype, uint32 pos, bool stopping, uint8 &m, uint8 &s, uint8 &f)
1999-10-03 14:16:26 +00:00
{
switch (postype) {
case 0:
m = pos / (60 * 75);
s = (pos / 75) % 60;
f = pos % 75;
return true;
case 1:
m = bcd2bin[(pos >> 16) & 0xff];
s = bcd2bin[(pos >> 8) & 0xff];
f = bcd2bin[pos & 0xff];
return true;
case 2: {
uint8 track = bcd2bin[pos & 0xff];
if (stopping)
track++;
for (int i=4; i<804; i+=8) {
if (info.toc[i+2] == track || info.toc[i+2] == 0xaa) {
m = info.toc[i+5];
s = info.toc[i+6];
f = info.toc[i+7];
1999-10-03 14:16:26 +00:00
return true;
}
}
return false;
}
default:
return false;
}
}
/*
* Initialization
*/
void CDROMInit(void)
{
2023-08-06 11:51:03 +00:00
SysAddCDROMPrefs();
// Add drives specified in preferences
int index = 0;
const char *str;
while ((str = PrefsFindString("cdrom", index++)) != NULL) {
2023-08-06 11:51:03 +00:00
void *fh = Sys_open(str, true, true);
if (fh)
drives.push_back(cdrom_drive_info(fh));
1999-10-03 14:16:26 +00:00
}
if (!drives.empty()) { // set to first drive by default
last_drive_num = drives.begin()->num;
}
else {
last_drive_num = 0;
}
1999-10-03 14:16:26 +00:00
}
2023-08-06 11:51:03 +00:00
void CDROMDrop(const char *path) {
if (!drives.empty())
drives.front().fh = Sys_open(path, true, true);
}
1999-10-03 14:16:26 +00:00
/*
* Deinitialization
*/
void CDROMExit(void)
{
drive_vec::iterator info, end = drives.end();
for (info = drives.begin(); info != end; ++info)
info->close_fh();
drives.clear();
1999-10-03 14:16:26 +00:00
}
/*
* Disk was inserted, flag for mounting
*/
bool CDROMMountVolume(void *fh)
{
drive_vec::iterator info = drives.begin(), end = drives.end();
while (info != end && info->fh != fh)
++info;
if (info != end) {
1999-10-03 14:16:26 +00:00
if (SysIsDiskInserted(info->fh)) {
SysPreventRemoval(info->fh);
WriteMacInt8(info->status + dsDiskInPlace, 1);
read_toc(*info);
find_hfs_partition(*info);
1999-10-03 14:16:26 +00:00
if (info->start_byte != 0 || info->mount_non_hfs)
info->to_be_mounted = true;
}
return true;
} else
return false;
}
/*
* Mount volumes for which the to_be_mounted flag is set
* (called during interrupt time)
*/
static void mount_mountable_volumes(void)
{
drive_vec::iterator info, end = drives.end();
for (info = drives.begin(); info != end; ++info) {
// Disk in drive?
if (ReadMacInt8(info->status + dsDiskInPlace) == 0) {
// No, check if disk was inserted
if (SysIsDiskInserted(info->fh))
CDROMMountVolume(info->fh);
}
// Mount disk if flagged
if (info->to_be_mounted) {
D(bug(" mounting drive %d\n", info->num));
M68kRegisters r;
r.d[0] = info->num;
r.a[0] = 7; // diskEvent
Execute68kTrap(0xa02f, &r); // PostEvent()
info->to_be_mounted = false;
}
}
}
1999-10-03 14:16:26 +00:00
/*
* Driver Open() routine
*/
int16 CDROMOpen(uint32 pb, uint32 dce)
{
D(bug("CDROMOpen\n"));
1999-10-03 14:16:26 +00:00
// Set up DCE
WriteMacInt32(dce + dCtlPosition, 0);
acc_run_called = false;
1999-10-03 14:16:26 +00:00
// Install drives
drive_vec::iterator info, end = drives.end();
for (info = drives.begin(); info != end; ++info) {
1999-10-03 14:16:26 +00:00
info->num = FindFreeDriveNumber(1);
info->to_be_mounted = false;
1999-10-03 14:16:26 +00:00
if (info->fh) {
info->mount_non_hfs = true;
info->block_size = 512;
info->twok_offset = -1;
info->play_mode = 0x09;
info->play_order = 0;
info->repeat = 0;
1999-10-03 14:16:26 +00:00
info->power_mode = 0;
1999-10-03 14:16:26 +00:00
// Allocate drive status record
M68kRegisters r;
r.d[0] = SIZEOF_DrvSts;
Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
if (r.a[0] == 0)
continue;
info->status = r.a[0];
D(bug(" DrvSts at %08lx\n", info->status));
1999-10-03 14:16:26 +00:00
// Set up drive status
WriteMacInt8(info->status + dsWriteProt, 0x80);
WriteMacInt8(info->status + dsInstalled, 1);
WriteMacInt8(info->status + dsSides, 1);
1999-10-03 14:16:26 +00:00
// Disk in drive?
if (SysIsDiskInserted(info->fh)) {
SysPreventRemoval(info->fh);
WriteMacInt8(info->status + dsDiskInPlace, 1);
read_toc(*info);
find_hfs_partition(*info);
1999-10-03 14:16:26 +00:00
info->to_be_mounted = true;
}
1999-10-03 14:16:26 +00:00
// Add drive to drive queue
D(bug(" adding drive %d\n", info->num));
r.d[0] = (info->num << 16) | (CDROMRefNum & 0xffff);
r.a[0] = info->status + dsQLink;
Execute68kTrap(0xa04e, &r); // AddDrive()
}
}
CDROMOpenDone();
1999-10-03 14:16:26 +00:00
return noErr;
}
/*
* Driver Prime() routine
*/
int16 CDROMPrime(uint32 pb, uint32 dce)
{
WriteMacInt32(pb + ioActCount, 0);
1999-10-03 14:16:26 +00:00
// Drive valid and disk inserted?
drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
if (info == drives.end())
1999-10-03 14:16:26 +00:00
return nsDrvErr;
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
// Get parameters
void *buffer = Mac2HostAddr(ReadMacInt32(pb + ioBuffer));
size_t length = ReadMacInt32(pb + ioReqCount);
loff_t position = ReadMacInt32(dce + dCtlPosition);
if ((length & (info->block_size - 1)) || (position & (info->block_size - 1)))
return paramErr;
info->twok_offset = (position + info->start_byte) & 0x7ff;
1999-10-03 14:16:26 +00:00
size_t actual = 0;
if ((ReadMacInt16(pb + ioTrap) & 0xff) == aRdCmd) {
1999-10-03 14:16:26 +00:00
// Read
actual = Sys_read(info->fh, buffer, position + info->start_byte, length);
if (actual != length) {
1999-10-03 14:16:26 +00:00
// Read error, tried to read HFS root block?
if (length == 0x200 && position == 0x400) {
1999-10-03 14:16:26 +00:00
// Yes, fake (otherwise audio CDs won't get mounted)
memset(buffer, 0, 0x200);
actual = 0x200;
} else {
1999-10-03 14:16:26 +00:00
return readErr;
}
1999-10-03 14:16:26 +00:00
}
} else {
1999-10-03 14:16:26 +00:00
return wPrErr;
}
1999-10-03 14:16:26 +00:00
// Update ParamBlock and DCE
WriteMacInt32(pb + ioActCount, actual);
WriteMacInt32(dce + dCtlPosition, ReadMacInt32(dce + dCtlPosition) + actual);
return noErr;
}
/*
* Driver Control() routine
*/
int16 CDROMControl(uint32 pb, uint32 dce)
{
uint16 code = ReadMacInt16(pb + csCode);
D(bug("CDROMControl %d\n", code));
1999-10-03 14:16:26 +00:00
// General codes
switch (code) {
case 1: // KillIO
return noErr;
case 65: { // Periodic action (accRun, "insert" disks on startup)
mount_mountable_volumes();
WriteMacInt16(dce + dCtlFlags, ReadMacInt16(dce + dCtlFlags) & ~0x2000); // Disable periodic action
acc_run_called = true;
1999-10-03 14:16:26 +00:00
return noErr;
}
case 81: // Set poll freq
1999-10-03 14:16:26 +00:00
WriteMacInt16(dce + dCtlDelay, ReadMacInt16(pb + csParam));
return noErr;
}
1999-10-03 14:16:26 +00:00
// Drive valid?
drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
if (info == drives.end()) {
if (drives.empty()) {
1999-10-03 14:16:26 +00:00
return nsDrvErr;
} else {
// Audio calls tend to end up without correct reference
// Real mac would just play first disc, but we can guess correct one from last data call
info = get_drive_info(last_drive_num);
2020-08-10 04:01:22 +00:00
if (info == drives.end()) return nsDrvErr;
}
}
1999-10-03 14:16:26 +00:00
// Drive-specific codes
switch (code) {
case 5: // VerifyTheDisc
if (ReadMacInt8(info->status + dsDiskInPlace) > 0)
return noErr;
else
return offLinErr;
1999-10-03 14:16:26 +00:00
case 6: // FormatTheDisc
return writErr;
1999-10-03 14:16:26 +00:00
case 7: // EjectTheDisc
if (ReadMacInt8(info->status + dsDiskInPlace) > 0) {
SysAllowRemoval(info->fh);
SysEject(info->fh);
WriteMacInt8(info->status + dsDiskInPlace, 0);
info->twok_offset = -1;
2023-08-06 11:51:03 +00:00
info->close_fh();
info->fh = NULL;
return noErr;
} else {
return offLinErr;
1999-10-03 14:16:26 +00:00
}
1999-10-03 14:16:26 +00:00
case 21: // GetDriveIcon
case 22: // GetMediaIcon
WriteMacInt32(pb + csParam, CDROMIconAddr);
return noErr;
case 23: // GetDriveInfo
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam, 0x00000b01); // Unspecified external removable SCSI disk
return noErr;
// TODO: revist this section, is it necessary with DriverGestalt also in Status section?
case 43: { // DriverGestalt
int selector = ReadMacInt32(pb + csParam);
switch (selector) {
case FOURCC('v','e','r','s'):
WriteMacInt32(pb + csParam + 4, 0x05208000); // vers 5.2.0
break;
case FOURCC('d','e','v','t'):
WriteMacInt32(pb + csParam + 4, FOURCC('c','d','r','m'));
break;
case FOURCC('i','n','t','f'):
case FOURCC('d','A','P','I'):
WriteMacInt32(pb + csParam + 4, FOURCC('a','t','p','i'));
break;
case FOURCC('s','y','n','c'):
WriteMacInt32(pb + csParam + 4, 1); // true/false = sync/async
break;
case FOURCC('c','d','3','d'):
WriteMacInt32(pb + csParam + 4, 0);
break;
}
return noErr;
}
1999-10-03 14:16:26 +00:00
case 70: { // SetPowerMode
uint8 mode = ReadMacInt8(pb + csParam);
if (mode > 3) {
1999-10-03 14:16:26 +00:00
return paramErr;
} else {
1999-10-03 14:16:26 +00:00
info->power_mode = mode;
return noErr;
}
}
1999-10-03 14:16:26 +00:00
case 76: // ModifyPostEvent
2015-08-06 08:37:58 +00:00
info->mount_non_hfs = ReadMacInt16(pb + csParam) != 0;
1999-10-03 14:16:26 +00:00
return noErr;
1999-10-03 14:16:26 +00:00
case 79: { // Change block size
uint16 size = ReadMacInt16(pb + csParam);
D(bug(" change block size to %d bytes\n", size));
if (size != 512 && size != 2048) {
1999-10-03 14:16:26 +00:00
return paramErr;
} else {
1999-10-03 14:16:26 +00:00
info->block_size = size;
return noErr;
}
}
1999-10-03 14:16:26 +00:00
case 80: // SetUserEject
if (ReadMacInt8(info->status + dsDiskInPlace) > 0) {
if (ReadMacInt16(pb + csParam) == 1)
SysAllowRemoval(info->fh);
else
SysPreventRemoval(info->fh);
return noErr;
} else {
1999-10-03 14:16:26 +00:00
return offLinErr;
}
1999-10-03 14:16:26 +00:00
case 100: { // ReadTOC
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
int action = ReadMacInt16(pb + csParam);
D(bug(" read TOC %d\n", action));
switch (action) {
case 1: // Get first/last track number
WriteMacInt8(pb + csParam, bin2bcd[info->toc[2]]);
WriteMacInt8(pb + csParam + 1, bin2bcd[info->toc[3]]);
WriteMacInt16(pb + csParam + 2, 0);
break;
1999-10-03 14:16:26 +00:00
case 2: // Get lead out MSF starting address
WriteMacInt8(pb + csParam, bin2bcd[info->lead_out[0]]);
WriteMacInt8(pb + csParam + 1, bin2bcd[info->lead_out[1]]);
WriteMacInt8(pb + csParam + 2, bin2bcd[info->lead_out[2]]);
WriteMacInt8(pb + csParam + 3, 0);
break;
1999-10-03 14:16:26 +00:00
case 3: { // Get track starting address
uint32 buf = ReadMacInt32(pb + csParam + 2);
1999-10-03 14:16:26 +00:00
uint16 buf_size = ReadMacInt16(pb + csParam + 6);
int track = bcd2bin[ReadMacInt8(pb + csParam + 8)];
1999-10-03 14:16:26 +00:00
// Search start track in TOC
int i;
for (i=4; i<804; i+=8) {
if (info->toc[i+2] == track)
break;
}
1999-10-03 14:16:26 +00:00
// Fill buffer
if (i != 804) {
1999-10-03 14:16:26 +00:00
while (buf_size > 0) {
WriteMacInt8(buf, info->toc[i+1] & 0x0f); buf++; // Control
WriteMacInt8(buf, bin2bcd[info->toc[i+5]]); buf++; // M
WriteMacInt8(buf, bin2bcd[info->toc[i+6]]); buf++; // S
WriteMacInt8(buf, bin2bcd[info->toc[i+7]]); buf++; // F
1999-10-03 14:16:26 +00:00
// Lead-Out? Then stop
if (info->toc[i+2] == 0xaa)
break;
1999-10-03 14:16:26 +00:00
buf_size -= 4;
i += 8;
}
}
1999-10-03 14:16:26 +00:00
break;
}
case 4: { // Type 4 TOC for non-AppleCD SC
uint32 buf = ReadMacInt32(pb + csParam + 2);
uint16 buf_size = 512; // buffer must be 512 bytes for this TOC type
// start filling buffer
WriteMacInt8(buf, 0); buf++; // first byte reserved for 0
buf_size--;
int i = 4;
// in TOC, first 4 are session and/or track number; so tracks start at i = 4
// (info->toc[2] is first track num and info->toc[3] is last num)
// each track entry is 8 bytes:
// 0: unused, 1: control, 2: tracknum, 3: unused
// 4: unused, 5: MIN, 6: SEC, 7: FRAME
// entry for point A0 (first track num)
WriteMacInt8(buf, info->toc[i+1] & 0x0f); buf++; // control field
WriteMacInt8(buf, bin2bcd[info->toc[2]]); buf++; // track number
WriteMacInt8(buf, bin2bcd[info->toc[i+5]]); buf++; // PMIN
WriteMacInt8(buf, bin2bcd[info->toc[i+6]]); buf++; // PSEC
WriteMacInt8(buf, bin2bcd[info->toc[i+7]]); buf++; // PFRAME
buf_size -= 5; // every 8 bits written decreases byte buffer size by 1
// entry for point A1 (last track)
int buf_a1 = buf; // save for filling last track num
buf += 5; buf_size -= 5;
// entry for point A2 (address of start of lead out)
int buf_a2 = buf; // save for filling at end
buf += 5; buf_size -= 5;
// Fill buffer
while (i <= 804 && buf_size > 1) { // index 511 never used
// Lead out? then fill a2 and stop
if (info->toc[i+2] == 0xaa) {
// entry for point a2
WriteMacInt8(buf_a2, info->toc[i+1] & 0x0f); // Control
WriteMacInt8(buf_a2 + 1, bin2bcd[info->toc[i+2]]); // tracknum
WriteMacInt8(buf_a2 + 2, bin2bcd[info->lead_out[0]]); // M, same as toc[i+5]
WriteMacInt8(buf_a2 + 3, bin2bcd[info->lead_out[1]]); // S
WriteMacInt8(buf_a2 + 4, bin2bcd[info->lead_out[2]]); // F
break;
}
WriteMacInt8(buf, info->toc[i+1] & 0x0f); buf++; // Control
WriteMacInt8(buf, bin2bcd[info->toc[i+2]]); buf++; // tracknum
WriteMacInt8(buf, bin2bcd[info->toc[i+5]]); buf++; // M
WriteMacInt8(buf, bin2bcd[info->toc[i+6]]); buf++; // S
WriteMacInt8(buf, bin2bcd[info->toc[i+7]]); buf++; // F
// Last track? fill a1 as well
if (info->toc[i+2] == info->toc[3]) {
// entry for point a1
WriteMacInt8(buf_a1, info->toc[i+1] & 0x0f); // Control
WriteMacInt8(buf_a1 + 1, bin2bcd[info->toc[3]]); // tracknum
WriteMacInt8(buf_a1 + 2, bin2bcd[info->toc[i+5]]); // M
WriteMacInt8(buf_a1 + 3, bin2bcd[info->toc[i+6]]); // S
WriteMacInt8(buf_a1 + 4, bin2bcd[info->toc[i+7]]); // F
}
buf_size -= 5;
i += 8;
}
// fill rest of buffer with zeroes
while (buf_size > 0) {
WriteMacInt8(buf, 0); buf++;
buf_size--;
}
break;
}
1999-10-03 14:16:26 +00:00
case 5: // Get session information
WriteMacInt16(pb + csParam, 1); // First session number
WriteMacInt16(pb + csParam + 2, 1); // Last session number
WriteMacInt16(pb + csParam + 4, bin2bcd[info->toc[2]]); // First track number of last session
WriteMacInt8(pb + csParam + 6, info->toc[5] & 0x0f); // Control
WriteMacInt8(pb + csParam + 7, bin2bcd[info->toc[9]]); // M
WriteMacInt8(pb + csParam + 8, bin2bcd[info->toc[10]]); // S
WriteMacInt8(pb + csParam + 9, bin2bcd[info->toc[11]]); // F
break;
1999-10-03 14:16:26 +00:00
default:
printf("FATAL: .AppleCD/Control(100): unimplemented TOC type\n");
return paramErr;
}
return noErr;
}
1999-10-03 14:16:26 +00:00
case 101: { // ReadTheQSubcode
if (ReadMacInt8(info->status + dsDiskInPlace) == 0) {
Mac_memset(pb + csParam, 0, 10);
1999-10-03 14:16:26 +00:00
return offLinErr;
}
1999-10-03 14:16:26 +00:00
uint8 pos[16];
if (SysCDGetPosition(info->fh, pos)) {
uint32 p = pb + csParam;
WriteMacInt8(p, pos[5] & 0x0f); p++; // Control
WriteMacInt8(p, bin2bcd[pos[6]]); p++; // Track number
WriteMacInt8(p, bin2bcd[pos[7]]); p++; // Index number
WriteMacInt8(p, bin2bcd[pos[13]]); p++; // M (rel)
WriteMacInt8(p, bin2bcd[pos[14]]); p++; // S (rel)
WriteMacInt8(p, bin2bcd[pos[15]]); p++; // F (rel)
WriteMacInt8(p, bin2bcd[pos[9]]); p++; // M (abs)
WriteMacInt8(p, bin2bcd[pos[10]]); p++; // S (abs)
WriteMacInt8(p, bin2bcd[pos[11]]); p++; // F (abs)
WriteMacInt8(p, 0);
1999-10-03 14:16:26 +00:00
return noErr;
} else {
1999-10-03 14:16:26 +00:00
return ioErr;
}
1999-10-03 14:16:26 +00:00
}
1999-10-03 14:16:26 +00:00
case 102: // ReadHeader
printf("FATAL: .AppleCD/Control(102): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 103: { // AudioTrackSearch
2000-07-22 16:07:23 +00:00
D(bug(" AudioTrackSearch postype %d, pos %08x, hold %d\n", ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), ReadMacInt16(pb + csParam + 6)));
1999-10-03 14:16:26 +00:00
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, info->start_at[0], info->start_at[1], info->start_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
info->play_mode = ReadMacInt8(pb + csParam + 9) & 0x0f;
if (!SysCDPlay(info->fh, info->start_at[0], info->start_at[1], info->start_at[2], info->stop_at[0], info->stop_at[1], info->stop_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
if (ReadMacInt16(pb + csParam + 6) == 0) // Hold
SysCDPause(info->fh);
1999-10-03 14:16:26 +00:00
return noErr;
}
1999-10-03 14:16:26 +00:00
case 104: // AudioPlay
D(bug(" AudioPlay postype %d, pos %08lx, hold %d\n", ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), ReadMacInt16(pb + csParam + 6)));
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
if (ReadMacInt16(pb + csParam + 6)) {
// Given stopping address
if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
} else {
// Given starting address
if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, info->start_at[0], info->start_at[1], info->start_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
}
// Still need to process the AudioPlay command
info->play_mode = ReadMacInt8(pb + csParam + 9) & 0x0f;
if (!SysCDPlay(info->fh, info->start_at[0], info->start_at[1], info->start_at[2], info->stop_at[0], info->stop_at[1], info->stop_at[2]))
return paramErr;
1999-10-03 14:16:26 +00:00
return noErr;
1999-10-03 14:16:26 +00:00
case 105: // AudioPause
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
switch (ReadMacInt32(pb + csParam)) {
case 0:
if (!SysCDResume(info->fh))
return paramErr;
break;
case 1:
if (!SysCDPause(info->fh))
return paramErr;
break;
default:
return paramErr;
}
return noErr;
1999-10-03 14:16:26 +00:00
case 106: // AudioStop
D(bug(" AudioStop postype %d, pos %08lx\n", ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2)));
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
if (ReadMacInt16(pb + csParam) == 0 && ReadMacInt32(pb + csParam + 2) == 0) {
// Stop immediately
if (!SysCDStop(info->fh, info->lead_out[0], info->lead_out[1], info->lead_out[2]))
return paramErr;
} else {
// Given stopping address
if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), true, info->stop_at[0], info->stop_at[1], info->stop_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
}
return noErr;
1999-10-03 14:16:26 +00:00
case 107: { // AudioStatus
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
1999-10-03 14:16:26 +00:00
uint8 pos[16];
if (!SysCDGetPosition(info->fh, pos))
return paramErr;
uint32 p = pb + csParam;
1999-10-03 14:16:26 +00:00
switch (pos[1]) {
case 0x11:
WriteMacInt8(p, 0); // Audio play in progress
1999-10-03 14:16:26 +00:00
break;
case 0x12:
WriteMacInt8(p, 1); // Audio play paused
1999-10-03 14:16:26 +00:00
break;
case 0x13:
WriteMacInt8(p, 3); // Audio play completed
1999-10-03 14:16:26 +00:00
break;
case 0x14:
WriteMacInt8(p, 4); // Error occurred
1999-10-03 14:16:26 +00:00
break;
default:
WriteMacInt8(p, 5); // No audio play operation requested
1999-10-03 14:16:26 +00:00
break;
}
p++;
WriteMacInt8(p, info->play_mode); p++;
WriteMacInt8(p, pos[5] & 0x0f); p++; // Control
WriteMacInt8(p, bin2bcd[pos[9]]); p++; // M (abs)
WriteMacInt8(p, bin2bcd[pos[10]]); p++; // S (abs)
WriteMacInt8(p, bin2bcd[pos[11]]); p++; // F (abs)
1999-10-03 14:16:26 +00:00
return noErr;
}
1999-10-03 14:16:26 +00:00
case 108: { // AudioScan
if (ReadMacInt8(info->status + dsDiskInPlace) == 0)
return offLinErr;
if (!position2msf(*info, ReadMacInt16(pb + csParam), ReadMacInt32(pb + csParam + 2), false, info->start_at[0], info->start_at[1], info->start_at[2]))
1999-10-03 14:16:26 +00:00
return paramErr;
if (!SysCDScan(info->fh, info->start_at[0], info->start_at[1], info->start_at[2], ReadMacInt16(pb + csParam + 6) != 0)) {
1999-10-03 14:16:26 +00:00
return paramErr;
} else {
1999-10-03 14:16:26 +00:00
return noErr;
}
1999-10-03 14:16:26 +00:00
}
1999-10-03 14:16:26 +00:00
case 109: // AudioControl
SysCDSetVolume(info->fh, ReadMacInt8(pb + csParam), ReadMacInt8(pb + csParam + 1));
return noErr;
1999-10-03 14:16:26 +00:00
case 110: // ReadMCN
printf("FATAL: .AppleCD/Control(110): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 111: // ReadISRC
printf("FATAL: .AppleCD/Control(111): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 112: { // ReadAudioVolume
uint8 left = 0, right = 0;
1999-10-03 14:16:26 +00:00
SysCDGetVolume(info->fh, left, right);
WriteMacInt8(pb + csParam, left);
WriteMacInt8(pb + csParam + 1, right);
return noErr;
}
1999-10-03 14:16:26 +00:00
case 113: // GetSpindleSpeed
WriteMacInt16(pb + csParam, 0xff);
return noErr;
1999-10-03 14:16:26 +00:00
case 114: // SetSpindleSpeed
return noErr;
1999-10-03 14:16:26 +00:00
case 115: // ReadAudio
printf("FATAL: .AppleCD/Control(115): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 116: // ReadAllSubcodes
printf("FATAL: .AppleCD/Control(116): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 122: // SetTrackList
printf("FATAL: .AppleCD/Control(122): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 123: // GetTrackList
printf("FATAL: .AppleCD/Control(123): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 124: // GetTrackIndex
printf("FATAL: .AppleCD/Control(124): unimplemented call\n");
return controlErr;
1999-10-03 14:16:26 +00:00
case 125: // SetPlayMode
// repeat flag (0 is off, 1 is on)
info->repeat = ReadMacInt8(pb + csParam);
// playmode (0 is normal, 1 is shuffle, 2 is program mode)
info->play_order = ReadMacInt8(pb + csParam + 1);
// D(bug(" SetPlayMode %04x\n", ReadMacInt16(pb + csParam)));
// printf("FATAL: .AppleCD/Control(125): unimplemented call\n");
return noErr;
1999-10-03 14:16:26 +00:00
case 126: // GetPlayMode (Apple's Audio CD program needs this)
// repeat flag
WriteMacInt8(pb + csParam, bcd2bin[info->repeat]);
// playmode
WriteMacInt8(pb + csParam + 1, bcd2bin[info->play_order]);
1999-10-03 14:16:26 +00:00
return noErr;
1999-10-03 14:16:26 +00:00
default:
printf("WARNING: Unknown CDROMControl(%d)\n", code);
return controlErr;
}
}
/*
* Driver Status() routine
*/
int16 CDROMStatus(uint32 pb, uint32 dce)
{
drive_vec::iterator info = get_drive_info(ReadMacInt16(pb + ioVRefNum));
1999-10-03 14:16:26 +00:00
uint16 code = ReadMacInt16(pb + csCode);
D(bug("CDROMStatus %d\n", code));
// General codes (we can get these even if the drive was invalid)
1999-10-03 14:16:26 +00:00
switch (code) {
case 43: { // DriverGestalt
uint32 sel = ReadMacInt32(pb + csParam);
D(bug(" driver gestalt %c%c%c%c\n", sel >> 24, sel >> 16, sel >> 8, sel));
switch (sel) {
2000-07-22 16:07:23 +00:00
case FOURCC('v','e','r','s'): // Version
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam + 4, 0x05208000);
break;
2000-07-22 16:07:23 +00:00
case FOURCC('d','e','v','t'): // Device type
WriteMacInt32(pb + csParam + 4, FOURCC('c','d','r','m'));
1999-10-03 14:16:26 +00:00
break;
2000-07-22 16:07:23 +00:00
case FOURCC('i','n','t','f'): // Interface type
// WriteMacInt32(pb + csParam + 4, EMULATOR_ID_4);
WriteMacInt32(pb + csParam + 4, FOURCC('a','t','p','i'));
1999-10-03 14:16:26 +00:00
break;
2000-07-22 16:07:23 +00:00
case FOURCC('s','y','n','c'): // Only synchronous operation?
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam + 4, 0x01000000);
// WriteMacInt32(pb + csParam + 4, 1);
1999-10-03 14:16:26 +00:00
break;
2000-07-22 16:07:23 +00:00
case FOURCC('b','o','o','t'): // Boot ID
if (info != drives.end())
1999-10-03 14:16:26 +00:00
WriteMacInt16(pb + csParam + 4, info->num);
else
WriteMacInt16(pb + csParam + 4, 0);
WriteMacInt16(pb + csParam + 6, (uint16)CDROMRefNum);
break;
2000-07-22 16:07:23 +00:00
case FOURCC('w','i','d','e'): // 64-bit access supported?
1999-10-03 14:16:26 +00:00
WriteMacInt16(pb + csParam + 4, 0);
break;
2000-07-22 16:07:23 +00:00
case FOURCC('p','u','r','g'): // Purge flags
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam + 4, 0);
break;
2000-07-22 16:07:23 +00:00
case FOURCC('e','j','e','c'): // Eject flags
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam + 4, 0x00030003); // Don't eject on shutdown/restart
break;
2000-07-22 16:07:23 +00:00
case FOURCC('f','l','u','s'): // Flush flags
1999-10-03 14:16:26 +00:00
WriteMacInt16(pb + csParam + 4, 0);
break;
2000-07-22 16:07:23 +00:00
case FOURCC('v','m','o','p'): // Virtual memory attributes
1999-10-03 14:16:26 +00:00
WriteMacInt32(pb + csParam + 4, 0); // Drive not available for VM
break;
case FOURCC('c', 'd', '3', 'd'):
WriteMacInt16(pb + csParam + 4, 0);
break;
1999-10-03 14:16:26 +00:00
default:
return statusErr;
}
return noErr;
}
case 97: { // WhoIsThere
uint8 drives_present = 0;
drive_vec::iterator info, end = drives.end();
for (info = drives.begin(); info != end; ++info) {
if (info->num <= 6)
drives_present |= (1 << info->num);
}
WriteMacInt8(pb + csParam + 1, drives_present);
return noErr;
}
1999-10-03 14:16:26 +00:00
}
1999-10-03 14:16:26 +00:00
// Drive valid?
if (info == drives.end()) {
if (drives.empty()) {
1999-10-03 14:16:26 +00:00
return nsDrvErr;
} else {
info = get_drive_info(last_drive_num);
2020-08-10 04:01:22 +00:00
if (info == drives.end()) return nsDrvErr;
}
}
1999-10-03 14:16:26 +00:00
// Drive-specific codes
switch (code) {
2000-10-11 17:40:07 +00:00
case 6: // Return format list
if (ReadMacInt16(pb + csParam) > 0) {
uint32 adr = ReadMacInt32(pb + csParam + 2);
WriteMacInt16(pb + csParam, 1); // 1 format
2015-08-06 08:37:58 +00:00
WriteMacInt32(adr, uint32(SysGetFileSize(info->fh) / 512)); // Number of blocks
2000-10-11 17:40:07 +00:00
WriteMacInt32(adr + 4, 0); // heads/track/sectors
return noErr;
} else {
2000-10-11 17:40:07 +00:00
return paramErr;
}
1999-10-03 14:16:26 +00:00
case 8: // DriveStatus
Mac2Mac_memcpy(pb + csParam, info->status, 22);
1999-10-03 14:16:26 +00:00
return noErr;
1999-10-03 14:16:26 +00:00
case 70: // GetPowerMode
WriteMacInt16(pb + csParam, info->power_mode << 8);
return noErr;
1999-10-03 14:16:26 +00:00
case 95: // Get2KOffset
if (info->twok_offset > 0) {
WriteMacInt16(pb + csParam, info->twok_offset);
return noErr;
} else {
1999-10-03 14:16:26 +00:00
return statusErr;
}
1999-10-03 14:16:26 +00:00
case 96: // Get drive type
WriteMacInt16(pb + csParam, 3); // Apple CD 300 or newer
return noErr;
1999-10-03 14:16:26 +00:00
case 98: // Get block size
WriteMacInt16(pb + csParam, info->block_size);
return noErr;
1999-10-03 14:16:26 +00:00
case 120: // Return device ident
WriteMacInt32(pb + csParam, 0);
return noErr;
1999-10-03 14:16:26 +00:00
case 121: // Get CD features
WriteMacInt16(pb + csParam, 0x0200); // 300 KB/s
WriteMacInt16(pb + csParam + 2, 0x0c00); // SCSI-2, stereo
1999-10-03 14:16:26 +00:00
return noErr;
1999-10-03 14:16:26 +00:00
default:
printf("WARNING: Unknown CDROMStatus(%d)\n", code);
return statusErr;
}
}
/*
* Driver interrupt routine (1Hz) - check for volumes to be mounted
*/
void CDROMInterrupt(void)
{
if (!acc_run_called)
return;
mount_mountable_volumes();
}