//---------------------------------------------------------------------------
//
//  SCSI Target Emulator RaSCSI (*^..^*)
//  for Raspberry Pi
//
//  Powered by XM6 TypeG Technorogy.
//  Copyright (C) 2016-2017 GIMONS
//	[ ホストファイルシステム ブリッジドライバ ]
//
//---------------------------------------------------------------------------

#include <stdio.h>
#include <string.h>
#include <sys/dos.h>
#include <sys/scsi.h>
#include <iocslib.h>
#include "bridge.h"

//---------------------------------------------------------------------------
//
//  変数宣言
//
//---------------------------------------------------------------------------
volatile BYTE *request;				// リクエストヘッダアドレス
DWORD command;						// コマンド番号
DWORD unit;							// ユニット番号

//===========================================================================
//
/// ファイルシステム(SCSI連携)
//
//===========================================================================
typedef struct
{
	char DeviceType;
	char RMB;
	char ANSI_Ver;
	char RDF;
	char AddLen;
	char RESV0;
	char RESV1;
	char OptFunc;
	char VendorID[8];
	char ProductID[16];
	char FirmRev[4];
} INQUIRY_T;

int scsiid;	// SCSI ID

//---------------------------------------------------------------------------
//
// 初期化
//
//---------------------------------------------------------------------------
BOOL SCSI_Init(void)
{
	int i;
	INQUIRY_T inq;

	// SCSI ID未定
	scsiid = -1;
	
	for (i = 0; i <= 7; i++) {
		if (S_INQUIRY(sizeof(INQUIRY_T) , i, (struct INQUIRY*)&inq) < 0) {
			continue;
		}

		if (memcmp(&(inq.ProductID), "RASCSI BRIDGE", 13) != 0) {
			continue;
		}

		// SCSI ID確定
		scsiid = i;
		return TRUE;
	}

	return FALSE;
}

//---------------------------------------------------------------------------
//
// コマンド送信
//
//---------------------------------------------------------------------------
int SCSI_SendCmd(BYTE *buf, int len)
{
	int ret;
	BYTE cmdbuf[10];
	BYTE sts;
	BYTE msg;
	BYTE retbuf[4];
	
	ret = FS_FATAL_MEDIAOFFLINE;

	cmdbuf[0] = 0x2a;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = (BYTE)(len >> 16);
	cmdbuf[7] = (BYTE)(len >> 8);
	cmdbuf[8] = (BYTE)len;
	cmdbuf[9] = 0;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return ret;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return ret;
	}

	if (S_DATAOUT_P(len, buf) != 0) {
		return ret;
	}

	if (S_STSIN(&sts) != 0) {
		return ret;
	}

	if (S_MSGIN(&msg) != 0) {
		return ret;
	}

	cmdbuf[0] = 0x28;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = 0;
	cmdbuf[7] = 0;
	cmdbuf[8] = 4;
	cmdbuf[9] = 0;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return ret;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return ret;
	}

	if (S_DATAIN_P(4, retbuf) != 0) {
		return ret;
	}

	if (S_STSIN(&sts) != 0) {
		return ret;
	}

	if (S_MSGIN(&msg) != 0) {
		return ret;
	}
	
	ret = *(int*)retbuf;
	return ret;
}

//---------------------------------------------------------------------------
//
// コマンド呼び出し
//
//---------------------------------------------------------------------------
int SCSI_CalCmd(BYTE *buf, int len, BYTE *outbuf, int outlen)
{
	int ret;
	BYTE cmdbuf[10];
	BYTE sts;
	BYTE msg;
	BYTE retbuf[4];
	
	ret = FS_FATAL_MEDIAOFFLINE;

	cmdbuf[0] = 0x2a;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = (BYTE)(len >> 16);
	cmdbuf[7] = (BYTE)(len >> 8);
	cmdbuf[8] = (BYTE)len;
	cmdbuf[9] = 0;
	
	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return ret;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return ret;
	}

	if (S_DATAOUT_P(len, buf) != 0) {
		return ret;
	}

	if (S_STSIN(&sts) != 0) {
		return ret;
	}

	if (S_MSGIN(&msg) != 0) {
		return ret;
	}

	cmdbuf[0] = 0x28;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = 0;
	cmdbuf[7] = 0;
	cmdbuf[8] = 4;
	cmdbuf[9] = 0;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return ret;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return ret;
	}

	if (S_DATAIN_P(4, retbuf) != 0) {
		return ret;
	}

	if (S_STSIN(&sts) != 0) {
		return ret;
	}

	if (S_MSGIN(&msg) != 0) {
		return ret;
	}

	// エラーなら返却データの受信を止める
	ret = *(int*)retbuf;
	if (ret < 0) {
		return ret;
	}

	cmdbuf[0] = 0x28;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = (BYTE)(outlen >> 16);
	cmdbuf[7] = (BYTE)(outlen >> 8);
	cmdbuf[8] = (BYTE)outlen;
	cmdbuf[9] = 1;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return ret;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return ret;
	}

	if (S_DATAIN_P(outlen, outbuf) != 0) {
		return ret;
	}

	if (S_STSIN(&sts) != 0) {
		return ret;
	}

	if (S_MSGIN(&msg) != 0) {
		return ret;
	}
	
	ret = *(int*)retbuf;
	return ret;
}

//---------------------------------------------------------------------------
//
// オプションデータ取得
//
//---------------------------------------------------------------------------
BOOL SCSI_ReadOpt(BYTE *buf, int len)
{
	BYTE cmdbuf[10];
	BYTE sts;
	BYTE msg;

	cmdbuf[0] = 0x28;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = (BYTE)(len >> 16);
	cmdbuf[7] = (BYTE)(len >> 8);
	cmdbuf[8] = (BYTE)len;
	cmdbuf[9] = 2;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return FALSE;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return FALSE;
	}

	if (S_DATAIN_P(len, buf) != 0) {
		return FALSE;
	}

	if (S_STSIN(&sts) != 0) {
		return FALSE;
	}

	if (S_MSGIN(&msg) != 0) {
		return FALSE;
	}
	
	return TRUE;
}

//---------------------------------------------------------------------------
//
// オプションデータ書き込み
//
//---------------------------------------------------------------------------
BOOL SCSI_WriteOpt(BYTE *buf, int len)
{
	BYTE cmdbuf[10];
	BYTE sts;
	BYTE msg;

	cmdbuf[0] = 0x2a;
	cmdbuf[1] = 0;
	cmdbuf[2] = 2;
	cmdbuf[3] = command;
	cmdbuf[4] = 0;
	cmdbuf[5] = 0;
	cmdbuf[6] = (BYTE)(len >> 16);
	cmdbuf[7] = (BYTE)(len >> 8);
	cmdbuf[8] = (BYTE)len;
	cmdbuf[9] = 1;

	// セレクトがタイムアウトする時には再試行
	if (S_SELECT(scsiid) != 0) {
		S_RESET();
		if (S_SELECT(scsiid) != 0) {
			return FALSE;
		}
	}

	if (S_CMDOUT(10, cmdbuf) != 0) {
		return FALSE;
	}

	if (S_DATAOUT_P(len, buf) != 0) {
		return FALSE;
	}

	if (S_STSIN(&sts) != 0) {
		return FALSE;
	}

	if (S_MSGIN(&msg) != 0) {
		return FALSE;
	}

	return TRUE;
}

//===========================================================================
//
/// ファイルシステム
//
//===========================================================================

//---------------------------------------------------------------------------
//
//  $40 - デバイス起動
//
//---------------------------------------------------------------------------
DWORD FS_InitDevice(const argument_t* pArgument)
{
	return (DWORD)SCSI_SendCmd((BYTE*)pArgument, sizeof(argument_t));
}

//---------------------------------------------------------------------------
//
//  $41 - ディレクトリチェック
//
//---------------------------------------------------------------------------
int FS_CheckDir(const namests_t* pNamests)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $42 - ディレクトリ作成
//
//---------------------------------------------------------------------------
int FS_MakeDir(const namests_t* pNamests)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $43 - ディレクトリ削除
//
//---------------------------------------------------------------------------
int FS_RemoveDir(const namests_t* pNamests)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $44 - ファイル名変更
//
//---------------------------------------------------------------------------
int FS_Rename(const namests_t* pNamests, const namests_t* pNamestsNew)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);

	memcpy(&buf[i], pNamestsNew, sizeof(namests_t));
	i += sizeof(namests_t);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $45 - ファイル削除
//
//---------------------------------------------------------------------------
int FS_Delete(const namests_t* pNamests)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $46 - ファイル属性取得/設定
//
//---------------------------------------------------------------------------
int FS_Attribute(const namests_t* pNamests, DWORD nHumanAttribute)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);

	dp = (DWORD*)&buf[i];
	*dp = nHumanAttribute;
	i += sizeof(DWORD);
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $47 - ファイル検索
//
//---------------------------------------------------------------------------
int FS_Files(DWORD nKey,
	const namests_t* pNamests, files_t* info)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);

	memcpy(&buf[i], info, sizeof(files_t));
	i += sizeof(files_t);
	
	return SCSI_CalCmd(buf, i, (BYTE*)info, sizeof(files_t));
}

//---------------------------------------------------------------------------
//
//  $48 - ファイル次検索
//
//---------------------------------------------------------------------------
int FS_NFiles(DWORD nKey, files_t* info)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], info, sizeof(files_t));
	i += sizeof(files_t);
	
	return SCSI_CalCmd(buf, i, (BYTE*)info, sizeof(files_t));
}

//---------------------------------------------------------------------------
//
//  $49 - ファイル作成
//
//---------------------------------------------------------------------------
int FS_Create(DWORD nKey,
	const namests_t* pNamests, fcb_t* pFcb, DWORD nAttribute, BOOL bForce)
{
	BYTE buf[256];
	DWORD *dp;
	BOOL *bp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	dp = (DWORD*)&buf[i];
	*dp = nAttribute;
	i += sizeof(DWORD);

	bp = (BOOL*)&buf[i];
	*bp = bForce;
	i += sizeof(BOOL);
	
	return SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));
}

//---------------------------------------------------------------------------
//
//  $4A - ファイルオープン
//
//---------------------------------------------------------------------------
int FS_Open(DWORD nKey,
	const namests_t* pNamests, fcb_t* pFcb)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pNamests, sizeof(namests_t));
	i += sizeof(namests_t);
	
	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	return SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));
}

//---------------------------------------------------------------------------
//
//  $4B - ファイルクローズ
//
//---------------------------------------------------------------------------
int FS_Close(DWORD nKey, fcb_t* pFcb)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);
	
	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	return SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));
}

//---------------------------------------------------------------------------
//
//  $4C - ファイル読み込み
//
//---------------------------------------------------------------------------
int FS_Read(DWORD nKey, fcb_t* pFcb, BYTE* pAddress, DWORD nSize)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	int nResult;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	dp = (DWORD*)&buf[i];
	*dp = nSize;
	i += sizeof(DWORD);
	
	nResult = SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));

	if (nResult > 0) {
		SCSI_ReadOpt(pAddress, nResult);
	}
	
	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4D - ファイル書き込み
//
//---------------------------------------------------------------------------
int FS_Write(DWORD nKey, fcb_t* pFcb, BYTE* pAddress, DWORD nSize)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);
	
	dp = (DWORD*)&buf[i];
	*dp = nSize;
	i += sizeof(DWORD);

	if (nSize != 0) {
		if (!SCSI_WriteOpt(pAddress, nSize)) {
			return FS_FATAL_MEDIAOFFLINE;
		}
	}
	
	return SCSI_SendCmd(buf, i);
}

//---------------------------------------------------------------------------
//
//  $4E - ファイルシーク
//
//---------------------------------------------------------------------------
int FS_Seek(DWORD nKey, fcb_t* pFcb, DWORD nMode, int nOffset)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	dp = (DWORD*)&buf[i];
	*dp = nMode;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nOffset;
	i += sizeof(int);
	
	return SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));
}

//---------------------------------------------------------------------------
//
//  $4F - ファイル時刻取得/設定
//
//---------------------------------------------------------------------------
DWORD FS_TimeStamp(DWORD nKey,
	fcb_t* pFcb, DWORD nHumanTime)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nKey;
	i += sizeof(DWORD);

	memcpy(&buf[i], pFcb, sizeof(fcb_t));
	i += sizeof(fcb_t);

	dp = (DWORD*)&buf[i];
	*dp = nHumanTime;
	i += sizeof(DWORD);
	
	return (DWORD)SCSI_CalCmd(buf, i, (BYTE*)pFcb, sizeof(fcb_t));
}

//---------------------------------------------------------------------------
//
//  $50 - 容量取得
//
//---------------------------------------------------------------------------
int FS_GetCapacity(capacity_t* cap)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	return SCSI_CalCmd(buf, i, (BYTE*)cap, sizeof(capacity_t));
}

//---------------------------------------------------------------------------
//
//  $51 - ドライブ状態検査/制御
//
//---------------------------------------------------------------------------
int FS_CtrlDrive(ctrldrive_t* pCtrlDrive)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	memcpy(&buf[i], pCtrlDrive, sizeof(ctrldrive_t));
	i += sizeof(ctrldrive_t);
	
	return SCSI_CalCmd(buf, i, (BYTE*)pCtrlDrive, sizeof(ctrldrive_t));
}

//---------------------------------------------------------------------------
//
//  $52 - DPB取得
//
//---------------------------------------------------------------------------
int FS_GetDPB(dpb_t* pDpb)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	return SCSI_CalCmd(buf, i, (BYTE*)pDpb, sizeof(dpb_t));
}

//---------------------------------------------------------------------------
//
//  $53 - セクタ読み込み
//
//---------------------------------------------------------------------------
int FS_DiskRead(BYTE* pBuffer, DWORD nSector, DWORD nSize)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nSector;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nSize;
	i += sizeof(DWORD);
	
	return SCSI_CalCmd(buf, i, (BYTE*)pBuffer, 0x200);
}

//---------------------------------------------------------------------------
//
//  $54 - セクタ書き込み
//
//---------------------------------------------------------------------------
int FS_DiskWrite()
{
	BYTE buf[256];
	DWORD *dp;
	
	dp = (DWORD*)buf;
	*dp = unit;

	return SCSI_SendCmd(buf, 4);
}

//---------------------------------------------------------------------------
//
//  $55 - IOCTRL
//
//---------------------------------------------------------------------------
int FS_Ioctrl(DWORD nFunction, ioctrl_t* pIoctrl)
{
	BYTE buf[256];
	DWORD *dp;
	int i;
	
	i = 0;
	dp = (DWORD*)buf;
	*dp = unit;
	i += sizeof(DWORD);

	dp = (DWORD*)&buf[i];
	*dp = nFunction;
	i += sizeof(DWORD);

	memcpy(&buf[i], pIoctrl, sizeof(ioctrl_t));
	i += sizeof(ioctrl_t);
	
	return SCSI_CalCmd(buf, i, (BYTE*)pIoctrl, sizeof(ioctrl_t));
}

//---------------------------------------------------------------------------
//
//  $56 - フラッシュ
//
//---------------------------------------------------------------------------
int FS_Flush()
{
	BYTE buf[256];
	DWORD *dp;
	
	dp = (DWORD*)buf;
	*dp = unit;

	return SCSI_SendCmd(buf, 4);
}

//---------------------------------------------------------------------------
//
//  $57 - メディア交換チェック
//
//---------------------------------------------------------------------------
int FS_CheckMedia()
{
	BYTE buf[256];
	DWORD *dp;
	
	dp = (DWORD*)buf;
	*dp = unit;

	return SCSI_SendCmd(buf, 4);
}

//---------------------------------------------------------------------------
//
//  $58 - 排他制御
//
//---------------------------------------------------------------------------
int FS_Lock()
{
	BYTE buf[256];
	DWORD *dp;
	
	dp = (DWORD*)buf;
	*dp = unit;

	return SCSI_SendCmd(buf, 4);
}

//===========================================================================
//
//	コマンドハンドラ
//
//===========================================================================
#define GetReqByte(a) (request[a])
#define SetReqByte(a,d) (request[a] = (d))
#define GetReqWord(a) (*((WORD*)&request[a]))
#define SetReqWord(a,d) (*((WORD*)&request[a]) = (d))
#define GetReqLong(a) (*((DWORD*)&request[a]))
#define SetReqLong(a,d) (*((DWORD*)&request[a]) = (d))
#define GetReqAddr(a) ((BYTE*)((*((DWORD*)&request[a])) & 0x00ffffff))

//---------------------------------------------------------------------------
//
//  NAMESTS読み込み
//
//---------------------------------------------------------------------------
void GetNameStsPath(BYTE *addr, namests_t* pNamests)
{
	DWORD i;

	ASSERT(this);
	ASSERT(pNamests);

	// ワイルドカード情報
	pNamests->wildcard = *addr;

	// ドライブ番号
	pNamests->drive = addr[1];

	// パス名
	for (i = 0; i < sizeof(pNamests->path); i++) {
		pNamests->path[i] = addr[2 + i];
	}

	// ファイル名1
	memset(pNamests->name, 0x20, sizeof(pNamests->name));

	// 拡張子
	memset(pNamests->ext, 0x20, sizeof(pNamests->ext));

	// ファイル名2
	memset(pNamests->add, 0, sizeof(pNamests->add));
}

//---------------------------------------------------------------------------
//
//  NAMESTS読み込み
//
//---------------------------------------------------------------------------
void GetNameSts(BYTE *addr, namests_t* pNamests)
{
	DWORD i;

	ASSERT(this);
	ASSERT(pNamests);
	ASSERT(addr <= 0xFFFFFF);

	// ワイルドカード情報
	pNamests->wildcard = *addr;

	// ドライブ番号
	pNamests->drive = addr[1];

	// パス名
	for (i = 0; i < sizeof(pNamests->path); i++) {
		pNamests->path[i] = addr[2 + i];
	}

	// ファイル名1
	for (i = 0; i < sizeof(pNamests->name); i++) {
		pNamests->name[i] = addr[67 + i];
	}

	// 拡張子
	for (i = 0; i < sizeof(pNamests->ext); i++) {
		pNamests->ext[i] = addr[75 + i];
	}

	// ファイル名2
	for (i = 0; i < sizeof(pNamests->add); i++) {
		pNamests->add[i] = addr[78 + i];
	}
}

//---------------------------------------------------------------------------
//
//  FILES読み込み
//
//---------------------------------------------------------------------------
void GetFiles(BYTE *addr, files_t* pFiles)
{
	ASSERT(this);
	ASSERT(pFiles);
	ASSERT(addr <= 0xFFFFFF);

	// 検索情報
	pFiles->fatr = *addr;
	pFiles->sector = *((DWORD*)&addr[2]);
	pFiles->offset = *((WORD*)&addr[8]);;

	pFiles->attr = 0;
	pFiles->time = 0;
	pFiles->date = 0;
	pFiles->size = 0;
	memset(pFiles->full, 0, sizeof(pFiles->full));
}

//---------------------------------------------------------------------------
//
//  FILES書き込み
//
//---------------------------------------------------------------------------
void SetFiles(BYTE *addr, const files_t* pFiles)
{
	DWORD i;

	ASSERT(this);
	ASSERT(pFiles);

	*((DWORD*)&addr[2]) = pFiles->sector;
	*((WORD*)&addr[8]) = pFiles->offset;

	// ファイル情報
	addr[21] = pFiles->attr;
	*((WORD*)&addr[22]) = pFiles->time;
	*((WORD*)&addr[24]) = pFiles->date;
	*((DWORD*)&addr[26]) = pFiles->size;

	// フルファイル名
	addr += 30;
	for (i = 0; i < sizeof(pFiles->full); i++) {
		*addr = pFiles->full[i];
		addr++;
	}
}

//---------------------------------------------------------------------------
//
//  FCB読み込み
//
//---------------------------------------------------------------------------
void GetFcb(BYTE *addr, fcb_t* pFcb)
{
	ASSERT(this);
	ASSERT(pFcb);

	// FCB情報
	pFcb->fileptr = *((DWORD*)&addr[6]);
	pFcb->mode = *((WORD*)&addr[14]);

	// 属性
	pFcb->attr = addr[47];

	// FCB情報
	pFcb->time = *((WORD*)&addr[58]);
	pFcb->date = *((WORD*)&addr[60]);
	pFcb->size = *((DWORD*)&addr[64]);
}

//---------------------------------------------------------------------------
//
//  FCB書き込み
//
//---------------------------------------------------------------------------
void SetFcb(BYTE *addr, const fcb_t* pFcb)
{
	ASSERT(this);
	ASSERT(pFcb);

	// FCB情報
	*((DWORD*)&addr[6]) = pFcb->fileptr;
	*((WORD*)&addr[14]) = pFcb->mode;

	// 属性
	addr[47] = pFcb->attr;

	// FCB情報
	*((WORD*)&addr[58]) = pFcb->time;
	*((WORD*)&addr[60]) = pFcb->date;
	*((DWORD*)&addr[64]) = pFcb->size;
}

//---------------------------------------------------------------------------
//
//  CAPACITY書き込み
//
//---------------------------------------------------------------------------
void SetCapacity(BYTE *addr, const capacity_t* pCapacity)
{
	ASSERT(this);
	ASSERT(pCapacity);

	*((WORD*)&addr[0]) = pCapacity->freearea;
	*((WORD*)&addr[2]) = pCapacity->clusters;
	*((WORD*)&addr[4]) = pCapacity->sectors;
	*((WORD*)&addr[6]) = pCapacity->bytes;
}

//---------------------------------------------------------------------------
//
//  DPB書き込み
//
//---------------------------------------------------------------------------
void SetDpb(BYTE *addr, const dpb_t* pDpb)
{
	ASSERT(this);
	ASSERT(pDpb);

	// DPB情報
	*((WORD*)&addr[0]) = pDpb->sector_size;
	addr[2] = 	pDpb->cluster_size;
	addr[3] = 	pDpb->shift;
	*((WORD*)&addr[4]) = pDpb->fat_sector;
	addr[6] = 	pDpb->fat_max;
	addr[7] = 	pDpb->fat_size;
	*((WORD*)&addr[8]) = pDpb->file_max;
	*((WORD*)&addr[10]) = pDpb->data_sector;
	*((WORD*)&addr[12]) = pDpb->cluster_max;
	*((WORD*)&addr[14]) = pDpb->root_sector;
	addr[20] = 	pDpb->media;
}

//---------------------------------------------------------------------------
//
//  IOCTRL読み込み
//
//---------------------------------------------------------------------------
void GetIoctrl(DWORD param, DWORD func, ioctrl_t* pIoctrl)
{
	DWORD *lp;
	
	ASSERT(this);
	ASSERT(pIoctrl);

	switch (func) {
		case 2:
			// メディア再認識
			pIoctrl->param = param;
			return;

		case -2:
			// オプション設定
			lp = (DWORD*)param;
			pIoctrl->param = *lp;
			return;
	}
}

//---------------------------------------------------------------------------
//
//  IOCTRL書き込み
//
//---------------------------------------------------------------------------
void SetIoctrl(DWORD param, DWORD func, ioctrl_t* pIoctrl)
{
	DWORD i;
	BYTE *bp;
	WORD *wp;
	DWORD *lp;

	ASSERT(this);
	ASSERT(pIoctrl);

	switch (func) {
		case 0:
			// メディアIDの獲得
			wp = (WORD*)param;
			*wp = pIoctrl->media;
			return;

		case 1:
			// Human68k互換のためのダミー
			lp = (DWORD*)param;
			*lp = pIoctrl->param;
			return;

		case -1:
			// 常駐判定
			bp = (BYTE*)param;
			for (i = 0; i < 8; i++) {
				*bp = pIoctrl->buffer[i];
				bp++;
			}
			return;

		case -3:
			// オプション獲得
			lp = (DWORD*)param;
			*lp = pIoctrl->param;
			return;
	}
}

//---------------------------------------------------------------------------
//
//  ARGUMENT読み込み
// 
//  バッファサイズよりも長い場合は転送を打ち切って必ず終端する。
//
//---------------------------------------------------------------------------
void GetArgument(BYTE *addr, argument_t* pArgument)
{
	BOOL bMode;
	BYTE *p;
	DWORD i;
	BYTE c;

	ASSERT(this);
	ASSERT(pArgument);

	bMode = FALSE;
	p = pArgument->buf;
	for (i = 0; i < sizeof(pArgument->buf) - 2; i++) {
		c = addr[i];
		*p++ = c;
		if (bMode == 0) {
			if (c == '\0')
				return;
			bMode = TRUE;
		} else {
			if (c == '\0')
				bMode = FALSE;
		}
	}

	*p++ = '\0';
	*p = '\0';
}

//---------------------------------------------------------------------------
//
//  終了値書き込み
//
//---------------------------------------------------------------------------
void SetResult(DWORD nResult)
{
	DWORD code;

	ASSERT(this);

	// 致命的エラー判定
	switch (nResult) {
		case FS_FATAL_INVALIDUNIT:
			code = 0x5001;
			goto fatal;
		case FS_FATAL_INVALIDCOMMAND:
			code = 0x5003;
			goto fatal;
		case FS_FATAL_WRITEPROTECT:
			code = 0x700D;
			goto fatal;
		case FS_FATAL_MEDIAOFFLINE:
			code = 0x7002;
		fatal:
			SetReqByte(3, (BYTE)code);
			SetReqByte(4, code >> 8);
			//  @note リトライ可能を返すときは、(a5 + 18)を書き換えてはいけない。
			//  その後白帯で Retry を選択した場合、書き換えた値を読み込んで誤動作してしまう。
			if (code & 0x2000)
				break;
			nResult = FS_INVALIDFUNC;
		default:
			SetReqLong(18, nResult);
			break;
	}
}

//---------------------------------------------------------------------------
//
//  $40 - デバイス起動
// 
//	in	(offset	size)
//		 0	1.b	定数(22)
//		 2	1.b	コマンド($40/$c0)
//		18	1.l	パラメータアドレス
//		22	1.b	ドライブ番号
//	out	(offset	size)
//		 3	1.b	エラーコード(下位)
//		 4	1.b	〃			(上位)
//		13	1.b	ユニット数
//		14	1.l	デバイスドライバの終了アドレス + 1
//
//    ローカルドライブのコマンド 0 と同様に組み込み時に呼ばれるが、BPB 及
//  びそのポインタの配列を用意する必要はない.
//  他のコマンドと違い、このコマンドだけa5 + 1には有効な値が入っていない
//  (0初期化なども期待してはいけない)ので注意すること。
//
//---------------------------------------------------------------------------
DWORD InitDevice(void)
{
	argument_t arg;
	DWORD units;

	ASSERT(this);
	ASSERT(fs);

	// オプション内容を獲得
	GetArgument(GetReqAddr(18), &arg);

	// Human68k側で利用可能なドライブ数の範囲で、ファイルシステムを構築
	units = FS_InitDevice(&arg);

	// ドライブ数を返信
	SetReqByte(13, units);

	return 0;
}

//---------------------------------------------------------------------------
//
//  $41 - ディレクトリチェック
// 
//	in	(offset	size)
//		14	1.L	NAMESTS構造体アドレス
//
//---------------------------------------------------------------------------
DWORD CheckDir(void)
{
	namests_t ns;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameStsPath(GetReqAddr(14), &ns);

	// ファイルシステム呼び出し
	nResult = FS_CheckDir(&ns);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $42 - ディレクトリ作成
// 
//	in	(offset	size)
//		14	1.L	NAMESTS構造体アドレス
//
//---------------------------------------------------------------------------
DWORD MakeDir(void)
{
	namests_t ns;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// ファイルシステム呼び出し
	nResult = FS_MakeDir(&ns);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $43 - ディレクトリ削除
// 
//	in	(offset	size)
//		14	1.L	NAMESTS構造体アドレス
//
//---------------------------------------------------------------------------
DWORD RemoveDir(void)
{
	namests_t ns;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// ファイルシステム呼び出し
	nResult = FS_RemoveDir(&ns);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $44 - ファイル名変更
// 
//	in	(offset	size)
//		14	1.L	NAMESTS構造体アドレス 旧ファイル名
//		18	1.L	NAMESTS構造体アドレス 新ファイル名
//
//---------------------------------------------------------------------------
DWORD Rename(void)
{
	namests_t ns;
	namests_t ns_new;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);
	GetNameSts(GetReqAddr(18), &ns_new);

	// ファイルシステム呼び出し
	nResult = FS_Rename(&ns, &ns_new);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $45 - ファイル削除
// 
//	in	(offset	size)
//		14	1.L	NAMESTS構造体アドレス
//
//---------------------------------------------------------------------------
DWORD Delete(void)
{
	namests_t ns;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// ファイルシステム呼び出し
	nResult = FS_Delete(&ns);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $46 - ファイル属性取得/設定
// 
//	in	(offset	size)
//		12	1.B	読み出し時に0x01になるので注意
//		13	1.B	属性 $FFだと読み出し
//		14	1.L	NAMESTS構造体アドレス
//
//---------------------------------------------------------------------------
DWORD Attribute(void)
{
	namests_t ns;
	DWORD attr;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// 対象属性
	attr = GetReqByte(13);

	// ファイルシステム呼び出し
	nResult = FS_Attribute(&ns, attr);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $47 - ファイル検索
// 
//	in	(offset	size)
//		 0	1.b	定数(26)
//		 1	1.b	ユニット番号
//		 2	1.b	コマンド($47/$c7)
//		13	1.b	検索属性 (WindrvXMでは未使用。検索バッファに値が書かれている)
//		14	1.l	ファイル名バッファ(namests 形式)
//		18	1.l	検索バッファ(files 形式) このバッファに検索途中情報と検索結果を書き込む
//	out	(offset	size)
//		 3	1.b	エラーコード(下位)
//		 4	1.b	〃			(上位)
//		18	1.l	リザルトステータス
//
//    ディレクトリから指定ファイルを検索する. DOS _FILES から呼び出される.
//    検索に失敗した場合、若しくは検索に成功してもワイルドカードが使われて
//  いない場合は、次回検索時に必ず失敗させる為に検索バッファのオフセットに
//  -1 を書き込む. 検索が成功した場合は見つかったファイルの情報を設定する
//  と共に、次検索用の情報のセクタ番号、オフセット、ルートディレクトリの場
//  合は更に残りセクタ数を設定する. 検索ドライブ・属性、パス名は DOS コー
//  ル処理内で設定されるので書き込む必要はない.
//
//	<NAMESTS構造体>
//	(offset	size)
//	0	 1.b	NAMWLD	0:ワイルドカードなし -1:ファイル指定なし
//				(ワイルドカードの文字数)
//	1	 1.b	NAMDRV	ドライブ番号(A=0,B=1,…,Z=25)
//	2	65.b	NAMPTH	パス('\'＋あればサブディレクトリ名＋'\')
//	67	 8.b	NAMNM1	ファイル名(先頭 8 文字)
//	75	 3.b	NAMEXT	拡張子
//	78	10.b	NAMNM2	ファイル名(残りの 10 文字)
//
//  パス区切り文字は0x2F(/)や0x5C(\)ではなく0x09(TAB)を使っているので注意。
//
//---------------------------------------------------------------------------
DWORD Files(void)
{
	BYTE *files;
	files_t info;
	namests_t ns;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 検索途中経過格納領域
	files = GetReqAddr(18);
	GetFiles(files, &info);

	// 検索対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// ファイルシステム呼び出し
	nResult = FS_Files((DWORD)files, &ns, &info);

	// 検索結果の反映
	if (nResult >= 0) {
		SetFiles(files, &info);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $48 - ファイル次検索
// 
//	in	(offset	size)
//		18	1.L	FILES構造体アドレス
//
//---------------------------------------------------------------------------
DWORD NFiles(void)
{
	BYTE *files;
	files_t info;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// ワーク領域の読み込み
	files = GetReqAddr(18);
	GetFiles(files, &info);

	// ファイルシステム呼び出し
	nResult = FS_NFiles((DWORD)files, &info);

	// 検索結果の反映
	if (nResult >= 0) {
		SetFiles(files, &info);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $49 - ファイル作成(Create)
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		13	1.B	属性
//		14	1.L	NAMESTS構造体アドレス
//		18	1.L	モード (0:_NEWFILE 1:_CREATE)
//		22	1.L	FCB構造体アドレス
//
//---------------------------------------------------------------------------
DWORD Create(void)
{
	namests_t ns;
	BYTE *pFcb;
	fcb_t fcb;
	DWORD attr;
	BOOL force;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// 属性
	attr = GetReqByte(13);

	// 強制上書きモード
	force = (BOOL)GetReqLong(18);

	// ファイルシステム呼び出し
	nResult = FS_Create((DWORD)pFcb, &ns, &fcb, attr, force);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4A - ファイルオープン
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		14	1.L	NAMESTS構造体アドレス
//		22	1.L	FCB構造体アドレス
//				既にFCBにはほとんどのパラメータが設定済み
//				時刻・日付はオープンした瞬間のものになってるので上書き
//				サイズは0になっているので上書き
//
//---------------------------------------------------------------------------
DWORD Open(void)
{
	namests_t ns;
	BYTE *pFcb;
	fcb_t fcb;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// 対象ファイル名獲得
	GetNameSts(GetReqAddr(14), &ns);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// ファイルシステム呼び出し
	nResult = FS_Open((DWORD)pFcb, &ns, &fcb);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4B - ファイルクローズ
// 
//	in	(offset	size)
//		22	1.L	FCB構造体アドレス
//
//---------------------------------------------------------------------------
DWORD Close(void)
{
	BYTE *pFcb;
	fcb_t fcb;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// ファイルシステム呼び出し
	nResult = FS_Close((DWORD)pFcb, &fcb);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4C - ファイル読み込み
// 
//	in	(offset	size)
//		14	1.L	読み込みバッファ ここにファイル内容を読み込む
//		18	1.L	サイズ 16MBを超える値が指定される可能性もあり
//		22	1.L	FCB構造体アドレス
//
//  バスエラーが発生するアドレスを指定した場合の動作は保証しない。
// 
//  20世紀のアプリは「負の数だとファイルを全部読む」という作法で書かれている
//  可能性が微レ存。あれれー？このファイル16MB超えてるよー？(CV.高山みなみ)
// 
//  むしろ4〜12MBくらいの当時のプログラマーから見た実質的な「∞」の値で
//  クリップするような配慮こそが現代では必要なのではなかろうか。
//  または、末尾が12MBと16MB位置を超えたらサイズをクリップすると良いかも。
//
//---------------------------------------------------------------------------
DWORD Read(void)
{
	BYTE *pFcb;
	fcb_t fcb;
	BYTE *pAddress;
	DWORD nSize;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// 読み込みバッファ
	pAddress = GetReqAddr(14);

	// 読み込みサイズ
	nSize = GetReqLong(18);

	// クリッピング
	if (nSize >= WINDRV_CLIPSIZE_MAX) {
		nSize = WINDRV_CLIPSIZE_MAX;
	}

	// ファイルシステム呼び出し
	nResult = FS_Read((DWORD)pFcb, &fcb, pAddress, nSize);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4D - ファイル書き込み
// 
//	in	(offset	size)
//		14	1.L	書き込みバッファ ここにファイル内容を書き込む
//		18	1.L	サイズ 負の数ならファイルサイズを指定したのと同じ
//		22	1.L	FCB構造体アドレス
//
//  バスエラーが発生するアドレスを指定した場合の動作は保証しない。
//
//---------------------------------------------------------------------------
DWORD Write(void)
{
	BYTE *pFcb;
	fcb_t fcb;
	BYTE *pAddress;
	DWORD nSize;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// 書き込みバッファ
	pAddress = GetReqAddr(14);

	// 書き込みサイズ
	nSize = GetReqLong(18);

	// クリッピング
	if (nSize >= WINDRV_CLIPSIZE_MAX) {
		nSize = WINDRV_CLIPSIZE_MAX;
	}

	// ファイルシステム呼び出し
	nResult = FS_Write((DWORD)pFcb, &fcb, pAddress, nSize);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}
	
	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4E - ファイルシーク
// 
//	in	(offset	size)
//		12	1.B	0x2B になってるときがある 0のときもある
//		13	1.B	モード
//		18	1.L	オフセット
//		22	1.L	FCB構造体アドレス
//
//---------------------------------------------------------------------------
DWORD Seek(void)
{
	BYTE *pFcb;
	fcb_t fcb;
	DWORD nMode;
	DWORD nOffset;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// シークモード
	nMode = GetReqByte(13);

	// シークオフセット
	nOffset = GetReqLong(18);

	// ファイルシステム呼び出し
	nResult = FS_Seek((DWORD)pFcb, &fcb, nMode, nOffset);

	// 結果の反映
	if (nResult >= 0) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $4F - ファイル時刻取得/設定
// 
//	in	(offset	size)
//		18	1.W	DATE
//		20	1.W	TIME
//		22	1.L	FCB構造体アドレス
//
//  FCBが読み込みモードで開かれた状態でも設定変更が可能。
//  FCBだけでは書き込み禁止の判定ができないので注意。
//
//---------------------------------------------------------------------------
DWORD TimeStamp(void)
{
	BYTE *pFcb;
	fcb_t fcb;
	DWORD nTime;
	DWORD nResult;

	ASSERT(this);
	ASSERT(fs);

	// FCB獲得
	pFcb = GetReqAddr(22);
	GetFcb(pFcb, &fcb);

	// 時刻獲得
	nTime = GetReqLong(18);

	// ファイルシステム呼び出し
	nResult = FS_TimeStamp((DWORD)pFcb, &fcb, nTime);

	// 結果の反映
	if (nResult < 0xFFFF0000) {
		SetFcb(pFcb, &fcb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $50 - 容量取得
// 
//	in	(offset	size)
//		 0	1.b	定数(26)
//		 1	1.b	ユニット番号
//		 2	1.b	コマンド($50/$d0)
//		14	1.l	バッファアドレス
//	out	(offset	size)
//		 3	1.b	エラーコード(下位)
//		 4	1.b	〃			(上位)
//		18	1.l	リザルトステータス
//
//    メディアの総容量/空き容量、クラスタ/セクタサイズを収得する. バッファ
//  に書き込む内容は以下の通り. リザルトステータスとして使用可能なバイト数
//  を返すこと.
//
//	(offset	size)
//	0	1.w	使用可能なクラスタ数
//	2	1.w	総クラスタ数
//	4	1.w	1 クラスタ当りのセクタ数
//	6	1.w	1 セクタ当りのバイト数
//
//---------------------------------------------------------------------------
DWORD GetCapacity(void)
{
	BYTE *pCapacity;
	capacity_t cap;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// バッファ取得
	pCapacity = GetReqAddr(14);

#if 0
	// ファイルシステム呼び出し
	nResult = FS_GetCapacity(&cap);
#else
	// いつも同じ内容が返ってくるのでスキップしてみる
	cap.freearea = 0xFFFF;
	cap.clusters = 0xFFFF;
	cap.sectors = 64;
	cap.bytes = 512;
	nResult = 0x7FFF8000;
#endif

	// 結果の反映
	if (nResult >= 0) {
		SetCapacity(pCapacity, &cap);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $51 - ドライブ状態検査/制御
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		13	1.B	状態	0: 状態検査 1: イジェクト
//
//---------------------------------------------------------------------------
DWORD CtrlDrive(void)
{
	ctrldrive_t ctrl;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// ドライブ状態取得
	ctrl.status = GetReqByte(13);

	// ファイルシステム呼び出し
	nResult = FS_CtrlDrive(&ctrl);

	// 結果の反映
	if (nResult >= 0) {
		SetReqByte(13, ctrl.status);
	}
	
	return nResult;
}

//---------------------------------------------------------------------------
//
//  $52 - DPB取得
// 
//	in	(offset	size)
//		 0	1.b	定数(26)
//		 1	1.b	ユニット番号
//		 2	1.b	コマンド($52/$d2)
//		14	1.l	バッファアドレス(先頭アドレス + 2 を指す)
//	out	(offset	size)
//		 3	1.b	エラーコード(下位)
//		 4	1.b	〃			(上位)
//		18	1.l	リザルトステータス
//
//    指定メディアの情報を v1 形式 DPB で返す. このコマンドで設定する必要
//  がある情報は以下の通り(括弧内は DOS コールが設定する). ただし、バッフ
//  ァアドレスはオフセット 2 を指したアドレスが渡されるので注意すること.
//
//	(offset	size)
//	 0	1.b	(ドライブ番号)
//	 1	1.b	(ユニット番号)
//	 2	1.w	1 セクタ当りのバイト数
//	 4	1.b	1 クラスタ当りのセクタ数 - 1
//	 5	1.b	クラスタ→セクタのシフト数
//			bit 7 = 1 で MS-DOS 形式 FAT(16bit Intel 配列)
//	 6	1.w	FAT の先頭セクタ番号
//	 8	1.b	FAT 領域の個数
//	 9	1.b	FAT の占めるセクタ数(複写分を除く)
//	10	1.w	ルートディレクトリに入るファイルの個数
//	12	1.w	データ領域の先頭セクタ番号
//	14	1.w	総クラスタ数 + 1
//	16	1.w	ルートディレクトリの先頭セクタ番号
//	18	1.l	(ドライバヘッダのアドレス)
//	22	1.b	(小文字の物理ドライブ名)
//	23	1.b	(DPB 使用フラグ:常に 0)
//	24	1.l	(次の DPB のアドレス)
//	28	1.w	(カレントディレクトリのクラスタ番号:常に 0)
//	30	64.b	(カレントディレクトリ名)
//
//---------------------------------------------------------------------------
DWORD GetDPB(void)
{
	BYTE *pDpb;
	dpb_t dpb;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// DPB取得
	pDpb = GetReqAddr(14);

	// ファイルシステム呼び出し
	nResult = FS_GetDPB(&dpb);

	// 結果の反映
	if (nResult >= 0) {
		SetDpb(pDpb, &dpb);
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $53 - セクタ読み込み
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		14	1.L	バッファアドレス
//		18	1.L	セクタ数
//		22	1.L	セクタ番号
//
//---------------------------------------------------------------------------
DWORD DiskRead(void)
{
	BYTE *pAddress;
	DWORD nSize;
	DWORD nSector;
	BYTE buffer[0x200];
	int nResult;
	int i;

	ASSERT(this);
	ASSERT(fs);

	pAddress = GetReqAddr(14);	// アドレス (上位ビットが拡張フラグ)
	nSize = GetReqLong(18);		// セクタ数
	nSector = GetReqLong(22);	// セクタ番号

	// ファイルシステム呼び出し
	nResult = FS_DiskRead(buffer, nSector, nSize);

	// 結果の反映
	if (nResult >= 0) {
		for (i = 0; i < sizeof(buffer); i++) {
			*pAddress = buffer[i];
			pAddress++;
		}
	}

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $54 - セクタ書き込み
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		14	1.L	バッファアドレス
//		18	1.L	セクタ数
//		22	1.L	セクタ番号
//
//---------------------------------------------------------------------------
DWORD DiskWrite(void)
{
	BYTE *pAddress;
	DWORD nSize;
	DWORD nSector;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	pAddress = GetReqAddr(14);	// アドレス(上位ビットが拡張フラグ)
	nSize = GetReqLong(18);		// セクタ数
	nSector = GetReqLong(22);	// セクタ番号

	// ファイルシステム呼び出し
	nResult = FS_DiskWrite();

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $55 - IOCTRL
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//		14	1.L	パラメータ
//		18	1.W	機能番号
//
//---------------------------------------------------------------------------
DWORD Ioctrl(void)
{
	DWORD param;
	DWORD func;
	ioctrl_t ioctrl;
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// IOCTRL取得
	param = GetReqLong(14);		// パラメータ
	func = GetReqWord(18);		// 機能番号
	GetIoctrl(param, func, &ioctrl);

	// ファイルシステム呼び出し
	nResult = FS_Ioctrl(func, &ioctrl);

	// 結果の反映
	if (nResult >= 0)
		SetIoctrl(param, func, &ioctrl);

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $56 - フラッシュ
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//
//---------------------------------------------------------------------------
DWORD Flush(void)
{
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// ファイルシステム呼び出し
	nResult = FS_Flush();

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $57 - メディア交換チェック
// 
//	in	(offset	size)
//		 0	1.b	定数(26)
//		 1	1.b	ユニット番号
//		 2	1.b	コマンド($57/$d7)
//	out	(offset	size)
//		 3	1.b	エラーコード(下位)
//		 4	1.b	〃			(上位)
//		18	1.l	リザルトステータス
//
//    メディアが交換されたか否かを調べる. 交換されていた場合のフォーマット
//  確認はこのコマンド内で行うこと.
//
//---------------------------------------------------------------------------
DWORD CheckMedia(void)
{
#if 1
	static DWORD last = 0;
	DWORD now;
#endif
	int nResult;

	ASSERT(this);
	ASSERT(fs);

#if 1
	// 連続で呼び出されるの回避する
	now = TIMEGET();
	if ((now - last) < 3) {
		return 0;
	} else {
		last = now;
	}
#endif

	// ファイルシステム呼び出し
	nResult = FS_CheckMedia();

	return nResult;
}

//---------------------------------------------------------------------------
//
//  $58 - 排他制御
// 
//	in	(offset	size)
//		 1	1.B	ユニット番号
//
//---------------------------------------------------------------------------
DWORD Lock(void)
{
	int nResult;

	ASSERT(this);
	ASSERT(fs);

	// ファイルシステム呼び出し
	nResult = FS_Lock();

	return nResult;
}

//---------------------------------------------------------------------------
//
//  コマンド実行
//
//---------------------------------------------------------------------------
DWORD ExecuteCommand()
{
	ASSERT(this);

	// エラー情報クリア
	SetReqByte(3, 0);
	SetReqByte(4, 0);

	// コマンド番号
	command = (DWORD)GetReqByte(2);	// ビット7はベリファイフラグ

	// ユニット番号
	unit = GetReqByte(1);

	// コマンド分岐
	switch (command & 0x7F) {
		case 0x40: return InitDevice();	// $40 - デバイス起動
		case 0x41: return CheckDir();	// $41 - ディレクトリチェック
		case 0x42: return MakeDir();	// $42 - ディレクトリ作成
		case 0x43: return RemoveDir();	// $43 - ディレクトリ削除
		case 0x44: return Rename();		// $44 - ファイル名変更
		case 0x45: return Delete();		// $45 - ファイル削除
		case 0x46: return Attribute();	// $46 - ファイル属性取得/設定
		case 0x47: return Files();		// $47 - ファイル検索
		case 0x48: return NFiles();		// $48 - ファイル次検索
		case 0x49: return Create();		// $49 - ファイル作成
		case 0x4A: return Open();		// $4A - ファイルオープン
		case 0x4B: return Close();		// $4B - ファイルクローズ
		case 0x4C: return Read();		// $4C - ファイル読み込み
		case 0x4D: return Write();		// $4D - ファイル書き込み
		case 0x4E: return Seek();		// $4E - ファイルシーク
		case 0x4F: return TimeStamp();	// $4F - ファイル更新時刻の取得/設定
		case 0x50: return GetCapacity();// $50 - 容量取得
		case 0x51: return CtrlDrive();	// $51 - ドライブ制御/状態検査
		case 0x52: return GetDPB();		// $52 - DPB取得
		case 0x53: return DiskRead();	// $53 - セクタ読み込み
		case 0x54: return DiskWrite();	// $54 - セクタ書き込み
		case 0x55: return Ioctrl();		// $55 - IOCTRL
#if 0
		case 0x56: return Flush();		// $56 - フラッシュ
#else
		case 0x56: return 0;			// $56 - フラッシュ
#endif
		case 0x57: return CheckMedia();	// $57 - メディア交換チェック
#if 0
		case 0x58: return Lock();		// $58 - 排他制御
#else
		case 0x58: return 0;			// $58 - 排他制御
#endif
	}

	return FS_FATAL_INVALIDCOMMAND;
}

//---------------------------------------------------------------------------
//
//  初期化
//
//---------------------------------------------------------------------------
BOOL Init()
{
	ASSERT(this);

	return SCSI_Init();
}

//---------------------------------------------------------------------------
//
//  実行
//
//---------------------------------------------------------------------------
void Process(DWORD nA5)
{
	ASSERT(this);
	ASSERT(nA5 <= 0xFFFFFF);
	ASSERT(m_bAlloc);
	ASSERT(m_bFree);

	// リクエストヘッダのアドレス
	request = (BYTE*)nA5;

	// コマンド実行
	SetResult(ExecuteCommand());
}