commit 35866cfb84ecb9657798a219f0572c97d9424c39 Author: Xavier Rey-Robert Date: Thu May 3 15:47:57 2018 +0200 first commit diff --git a/bin/raspberrypi/rascsi.tar.gz b/bin/raspberrypi/rascsi.tar.gz new file mode 100644 index 00000000..61b0b19e Binary files /dev/null and b/bin/raspberrypi/rascsi.tar.gz differ diff --git a/bin/x68k/RASDRV.SYS b/bin/x68k/RASDRV.SYS new file mode 100644 index 00000000..72700ab6 Binary files /dev/null and b/bin/x68k/RASDRV.SYS differ diff --git a/bin/x68k/RASETHER.SYS b/bin/x68k/RASETHER.SYS new file mode 100644 index 00000000..9e5fd2de Binary files /dev/null and b/bin/x68k/RASETHER.SYS differ diff --git a/doc/converter.txt b/doc/converter.txt new file mode 100644 index 00000000..b9b2fe42 --- /dev/null +++ b/doc/converter.txt @@ -0,0 +1,158 @@ +------------------------------------------------------------------------------ + + SCSI Target Emulator RaSCSI (*^..^*) + version 1.33 for Raspberry Pi + + Powered by XM6 TypeG Technology. + Copyright (C) 2016-2018 GIMONS + +------------------------------------------------------------------------------ + +□変換基板の必要性について + SCSIはTTLレベルで5Vを220Ωと330Ωで分圧（パッシブターミネータの場合）する + ことで各信号線に3V弱の電圧がかかった状態が定常状態（信号的にはネゲート)に + なっています。 + + イニシエータ側もしくはターゲット側が信号をアサートする（＝0V）にしようと + すると両端のターミネータから合わせて5000÷220×2=45mAの電流が流れることに + なります（X68000のSCSIコントローラであるMB89352のデータシートを見ればシンク + 電流としてIol48mAとなっています）。 + + RPIのGPIOはこのような大きなシンク電流は吸収できません。電気的に安全な接続 + を行うためには汎用ロジックIC等で変換基板を作る必要があります。汎用ロジック + ICで48mAものシンク電流に耐えるのは74LS06とか07といったオープンコレクタで + ハイパワータイプのものを使用します。 + + 作者は74HC541×3,74HC126×1,74HC04×1で基本的なSCSIの方向制御を行い更に + 74LS07×3を使ってバスをドライブする回路を組んでみたところ問題なく動作する + ことを確認しました。 + + 他にも74LS641の派生版である74LS641-1を使用すると回路はシンプルに構成できる + でしょう。ノーマル品と違ってシンク電流が48mA対応なので74LS07を使用する必要 + はありません。しかし入手性はそれほど良くありません。 + +□変換基板の回路図案 + 同じフォルダに回路図案を入れています。 + + ・target.png + SCSIのターゲットモードを使用するための変換基板回路図です。基本機能である + HDDやMOのエミュレーションを行うのであればこの回路図相当の物を作れば良い + でしょう。使用するGPIOピンも最も少ない構成になります。 + + ピンアサインを変更しなければRaSCSIのstandardディレクトリに含まれる + バイナリを使用することが可能です。 + + ・initiator.png + SCSIのターゲットモードに加えイニシエータモードを使用するための変換基板 + 回路図です。基本機能に加えてRPIがイニシエータとなって物理HDDにコマンド + を発行することが可能になります。モードの制御に追加で一つGPIOピンを消費 + します。このイニシエータモードを使用したサンプルプログラムとしてrasdump + を用意しました。実HDDやMOからイメージファイルにダンプすることができます。 + オプションでリストア機能も使用できます。 + + ピンアサインのカスタマイズでPIN_INDに標準では7を設定してコンパイルする + 必要があります。ピンアサインのカスタマイズを参照してください。 + + ・fullspec.png + SCSIのターゲットモード、イニシエータモードに加えてSCSIの通信をモニター + することができる変換基板回路図です。SCSIプロトコロルを解析する等の特殊 + 要件がある場合はこの回路が最適です。全ての74LS641-1の方向制御をRaSCSI + から行いますのでGPIOピンを三つ余分に使用してしまいます。SCSIの開発に + 興味があればこの回路を組んでみてはどうでしょうか。特徴としてGPIOピン + を余分に使用する代わりに上のイニシエータモードが使用できる基板と比較 + して74LS86が必要にならないため基板がシンプルになるという恩恵があります。 + + ピンアサインのカスタマイズで、PIN_TAD,PIN_IND,PIN_DTDにそれぞれ標準 + では6,7,8を設定してコンパイルする必要があります。ピンアサインの + カスタマイズを参照してください。 + +□既存のものを手に入れる方法 + 最近では主にTwitter界隈を通じてRaSCSI用の変換基板を作成していただいて + いる方々がいらっしゃいます。 + + また秋葉原で委託販売されてます。 + + 家電のKENCHAN 同人ハード（キット）のページ等です。 + http://www.kadenken.com/shopbrand/ct76/" + + 現在のところ市販されているものとして + + ・BELさん開発のあいぼむ版 + ・tomcatさん開発のGAMERnium版 + + があります。 + +□ピンアサインのカスタマイズ + GPIOの信号制御論理やピンアサインはgpiobus.hとrascsidrv.cに定義があります。 + 定義が分かれているのはrascsidrv.cだけGPLなので敢えて分離しています。 + 御察し下さい。 + + カスタマイズ例としてgpiobus.hとrascsidrv.cに下記の二つの変換基板用定義例を + 用意しました。配布物の中にはコンパイル済みバイナリも含まれています。 + + ・BELさん開発のあいぼむ版 + ・tomcatさん開発のGAMERnium版 + +□カスタマイズ方法 + ・RaSCSI起動時のメッセージです。 + CONNECT_DESC + + ・信号制御モードを選択します。 + SIGNAL_CONTROL_MODE + + 0:SCSI論理仕様 + 直結またはHPに公開した74LS641-1等を使用する変換基板 + アーサート:0V + ネゲート :オープンコレクタ出力(バスから切り離す) + + 1:負論理仕様(負論理->SCSI論理への変換基板を使用する場合) + 現時点でこの仕様による変換基板は存在しません + アーサート:0V -> (CONVERT) -> 0V + ネゲート :3.3V -> (CONVERT) -> オープンコレクタ出力 + + 2:正論理仕様(正論理->SCSI論理への変換基板を使用する場合) + RaSCSI Adapter Rev.C @132sync等 + + アーサート:3.3V -> (CONVERT) -> 0V + ネゲート :0V -> (CONVERT) -> オープンコレクタ出力 + + ・制御信号ピンアサイン + PIN_ACT:SCSIコマンドを処理中の状態を示す信号のピン番号。 + PIN_ENB:起動から終了の間の有効信号を示す信号のピン番号。 + PIN_TAD:ターゲット信号(BSY,IO,CD,MSG,REG)の入出力方向を示す信号のピン番号。 + PIN_IND:イニシーエータ信号(SEL,ATN,RST,ACK)の入出力方向を示す信号のピン番号。 + PIN_DTD:データ信号(DT0...DT7,DP)の入出力方向を示す信号のピン番号。 + + ・制御信号出力論理 + 0V:FALSE 3.3V:TRUEで指定します。 + + ACT_ON:PIN_ACT信号の論理です。 + ENB_ON:PIN_ENB信号の論理です。 + TAD_IN:PIN_TAD入力方向時の論理です。 + IND_IN:PIN_ENB入力方向時の論理です。 + DTD_IN:PIN_ENB入力方向時の論理です。 + + ・SCSI信号ピンアサイン + PIN_DT0〜PIN_SEL:それぞれSCSI信号のピン番号です。 + +□コンパイル方法 + + ・実行ファイル(rascsi,rasctl) + gpiobus.hを修正 + make clean + make + + ・カーネルドライバ(rascsidrv.ko) + @OS最新化(必要あれば) + sudo apt-get update + sudo apt-get upgrade + sudo reboot + + Aカーネルヘッダー取得(必要あれば) + sudo apt-get install raspberrypi-kernel-headers + + Bコンパイル + cd kernelmodule + rascsidrv.cの修正 + make +[EOF] diff --git a/doc/fullspec.png b/doc/fullspec.png new file mode 100644 index 00000000..47692e59 Binary files /dev/null and b/doc/fullspec.png differ diff --git a/doc/initiator.png b/doc/initiator.png new file mode 100644 index 00000000..cabd0051 Binary files /dev/null and b/doc/initiator.png differ diff --git a/doc/pinassign.png b/doc/pinassign.png new file mode 100644 index 00000000..a334ade7 Binary files /dev/null and b/doc/pinassign.png differ diff --git a/doc/rascsi.txt b/doc/rascsi.txt new file mode 100644 index 00000000..c6c90190 --- /dev/null +++ b/doc/rascsi.txt @@ -0,0 +1,315 @@ +------------------------------------------------------------------------------ + + SCSI Target Emulator RaSCSI (*^..^*) + version 1.34 for Raspberry Pi + + Powered by XM6 TypeG Technology. + Copyright (C) 2016-2018 GIMONS + +------------------------------------------------------------------------------ +□RaSCSIとは + RaSCSIはRaspberry Piで動作するSCSIデバイス(ハードディスク，MO，CD-ROM)を + 仮想的に再現するエミュレータです。SCSIを採用したSHARPのX68000で使用する + ことを目的として開発しました。RaSCSIを導入したRaspberry PiをX68000のSCSI + コネクタに接続するだけで物理的なSCSIデバイスとして認識されます。 + + X68000以外にもSCSIを採用したFM TOWNSやPC98等のレトロPCでも使用できるかも + しれません。作者はFM TOWNSとPC9821Ceで動作するところまでは確認しています。 + + RaSCSIはSCSIデバイスをエミュレートするソフトウェアに加えてRaspberry Piの + GPIOコネクタをSCSIコネクタに変換する機構の総称を指します。 + +□動作環境 + (1)Raspberry Pi + Raspberry Pi 3 Model B を推奨します。 + + Raspberry Pi 2 Model BやZeroでも動作すると考えられます。 + ピンアサインを独自に変更しRaspberry Pi 1で動作させたという報告もあります。 + + (2)OS + RASPBIAN STRETCHで開発およびテストしています。 + sudo apt-get update及びsudo apt-get upgradeで最新にしています。 + このドキュメントを記述している時点で"Linux raspberrypi 4.14.34-v7+"です。 + + RaSCSIはSCSI信号をGPIOを利用して制御しているので可能な限り低レイテンシー + の状態で使用する必要があります。したがってCUIモードで利用することを推奨 + します。更に不要なサービスは極力停止して下さい。 + +□SCSIコネクタとの接続方法 + 状況が複雑になってきましたのでRaSCSIのホームページ上で情報提供しています。 + このドキュメントの最後にある公式ホームページを参考にして下さい。 + +□配布物 + 配布するアーカイブには実行ファイル、ドキュメント、ソースコードのそれぞれが + ディレクトリで分かれて含まれています。 + + bin/ ･･･ 実行ファイル + raspberrypi/ ･･･ RPI用のプログラム + rascsi.tar.gz ･･･ 実行ファイルとカーネルモジュールをtar+gzipしたもの。 + + x68k/ ･･･ X68000用のプログラム + RASDRV.SYS ･･･ ホストドライブドライバ + RASETHER.SYS ･･･ イーサネットドライバ + + doc/ ･･･ ドキュメント + rascsi.txt ･･･ 当ドキュメント + x68k.txt ･･･ X68000固有機能の説明 + converter.txt ･･･ 変換基板の説明 + pinassign.png ･･･ ピンアサイン図 + target.png ･･･ 変換基板回路図案(ターゲットモード) + initiator.png ･･･ 変換基板回路図案(イニシエータサポート) + fullspec.png ･･･ 変換基板回路図案(フルスペック) + + src/ ･･･ ソースコード + raspberrypi/ ･･･ RPI用のプログラムソース一式 + x68k/ ･･･ X68000用のプログラム一式 + + + RPIで使用するプログラムはrascsi.tar.gzですのでRPI上に転送してから解凍して + 下さい。パーミッション等を維持するためにRPI上で解凍することを推奨します。 + + rascsi.tar.gzにはstandard,fullspec,aibom,gamerniumのディレクトリが含まれ + ています。通常はstandardディレクトリにある実行ファイルを使用して下さい。 + + aibom,gamerniumディレクトリのものは"あいぼむ版","GAMERnium版"の変換基板を + 使用する時のものです。 + + fullspecディレクトリのものは公開したフルスペック版変換基板の回路図案で + 変換基板を作成した時に使用する時のものです。 + +□RASCI本体の使用方法(rascsi) + + sudo rascsi [-ID{01234567} FILE] ... + + ルート権限が必要ですのでsudo等で起動する必要があります。 + オプションに-hを付けると簡単なHELPが表示されます + + Usage: ./rascsi [-ID{0|1|2|3|4|5|6|7} FILE] ... + + ID is SCSI identification number. + FILE is disk image file. + + Detected images type based on file extension. + hdf : SASI HD image(XM6 SASI HD image) + hds : SCSI HD image(XM6 SCSI HD image) + hdn : SCSI HD image(NEC GENUINE) + hdi : SCSI HD image(Anex86 HD image) + nhd : SCSI HD image(T98Next HD image) + hda : SCSI HD image(APPLE GENUINE) + mos : SCSI MO image(XM6 SCSI MO image) + iso : SCSI CD image(ISO 9660 image) + + 引数では-ID{01234567}とFILEの一組で一つのSCSIデバイスを指定できます。 + + -IDの後ろの番号はSCSI IDです。SCSI IDは0-7を指定できますが通常レトロPC本体 + がイニシエータとしてID7等を使用していると思います。その場合は0-6を指定する + ことになります。 + + FILEは仮想ディスクイメージのファイルパスです。イメージファイル名には拡張子 + が必要です。拡張子によってHD,MO,CDの種別を判定しています。 + + 例)SCSI ID0にHDIMAGE0.HDS,ID1にHDIMAGE1.HDSを指定して起動する場合、 + sudo rascsi -ID0 HDIMAGE0.HDS -ID1 HDIMAGE1.HDS + + 終了する場合はCTRL+Cで停止します。 + バックグラウンドで起動した場合にはkillコマンド該当プロセスにINTシグナルか + HUPシグナルを送ることで終了します。 + + rascsiは起動後にソケット(6868ポート)を開いて外部からの管理コマンドを受け + 付ける状態になります。したがって既に別プロセスとしてrascsiが起動している + 場合はエラーメッセージとともに起動を中断します。 + +□管理ツールの使用方法(rasctl) + バージョン1.10からrasctlという管理ツールを提供します。これはrascsiプロセス + がバックグラウンドで起動(6868ポートで接続待ちの状態)している場合にディスク + 操作のコマンドを発行することが可能となります。コマンドラインは下記の通り。 + + rasctl -i ID [-c CMD] [-t TYPE] [-f FILE] + + ID : SCSI ID + CMD : 操作コマンド + attach : ディスクを取り付ける + detatch : ディスクを取り外す + insert : メディアを挿入する(MOまたはCDのみ) + eject : メディアを取り出す(MOまたはCDのみ) + protect : メディアを書き込み禁止にする(MOのみ) + TYPE : ディスク種別 + hd : ハードディスク(SASI/SCSI) + mo : MO(光磁気ディスク) + cd : CDROM(CDROMドライブ) + bridge : ブリッジデバイス + FILE : ディスクイメージファイルのパス + + IDは必須です。CMDは省略時はattachと解釈します。TYPEはコマンドがattachの + 場合にはFILEの拡張子から自動判定します。FILEはTYPEを明示的に指定している + 場合は拡張子が異なっても構いません。基本的CMD,TYPEの解釈は大文字小文字を + 無視します。現在のところ最初の1文字でのみ判定しています。 + + コマンド例 + rascsi -i 0 -f HDIMAGE0.HDS + + の場合はSCSI IDは0。CMDはデフォルトでattachでありTYPEは拡張子HDSから判断 + するのでhdと推測することになりrascsi起動時のオプション指定と同等です。 + + 現在の状態を確認するにために-lオプションのみを指定するとデバイス一覧が表示 + されます。コマンドラインは下記の通り。 + + rasctl -l + + rasctl自体の起動にはルート権限は必要ありません。 + +□ディスクダンプツールの使用方法(rasdump) + 直結もしくは直結基板、またはイニシエータ対応とした変換基板向けのサンプル + プログラムです。現在のところ変換基板では"あいぼむ版"のみ対応してます。 + + 名前の通りSCSI HDDやMOのイメージをダンプ(オプションでリストア)します。 + 自身のIDはBIDで指定して下さい。省略時は7を使用します。 + + rasdump -i ID [-b BID] -f FILE [-r] + ID : ターゲットデバイスのSCSI ID + BID : RaSCSI自身のSCSI ID + FILE : ダンプファイル名 + -r ： リストアモード + + サンプルなので必要最低限の処理しか実装していませんので改造するなりして + ご使用下さい。 + +□カーネルモジュールの導入方法(rascsidrv.ko) + version 1.24から安定化のためにGPIO制御の一部をカーネルモジュールで動作 + させる拡張を加えました。 + + カーネルモジュールを導入しなくても動作できますが、X68000シリーズのSASI + を使用する場合や純正SCSIボードを増設した場合はカーネルモジュールの導入 + を行っていないと動作が不安定になります。 + + カーネルモジュールを有効にするには + + sudo insmod rascsidrv.ko + + を実行してください。 + + カーネルモジュールの起動を確認するにはdmesgコマンドで出力されるログの + 最後に次のような表示がされている筈です。 + + "RaSCSI GPIO Driver Loaded(STANDARD)" + + 注意！ + カーネルモジュールは使用中のOSのバージョンに依存します。 + + rascsiやrasctlと同じ階層にあるrascsidrv.koはRaspberry Pi 2/3用の + "Linux raspberrypi 4.14.34-v7+"でコンパイルしたモジュールになります。 + + 同じ階層のrpi1orZero/rascsidrv.koはRaspberry Pi 1/Zero用です。 + "Linux raspberrypi 4.14.34+"でコンパイルしたモジュールになります。 + + 自身でカーネルモジュールをコンパイルする手順を簡単に記しておきます。 + + ・OSの最新化 + sudo apt-get update + sudo apt-get upgrade + sudo reboot + + ・カーネルヘッダー取得 + sudo apt-get install raspberrypi-kernel-headers + + ・コンパイル + cd kernelmodule + make + +□サポートするディスクイメージ + (1)SCSI ハードディスク + HDSファイル形式 (拡張子HDS/HDN/HDI/NHD/HDA) + ファイルサイズは10MB以上4095MB以下の範囲で任意のサイズ(但し512バイト単位) + + 拡張子が"HDN"の場合はNEC純正55ボード(PC-9801-55)向けの純正ハードディスク + エミュレーションを行います。INQUIRYで返却される情報やMODE SENSEのサイズに + に違いがあります。 + + 拡張子が"HDI","NHD"の場合はそれぞれPC98エミュレータであるAnex86及びT98Next + のSCSIハードディスクイメージを使用するものです。HDNの時と同様に一部の情報 + がNEC用に変換されます。 + + 拡張子が"HDA"の場合はAPPLE純正ハードディスクエミュレーションを行います。 + INQUIRY及びMODE SENSEで返却される情報に違いがあります。 + + (2)SASI ハードディスク + HDFファイル形式 (拡張子HDF) + ファイルサイズは10441728バイト、20748288バイト、41496576バイトのいずれか + (それぞれ10MBドライブ、20MBドライブ、40MBドライブに対応) + + (3)SCSI 光磁気(MO)ディスク + MOSファイル形式 (拡張子MOS) + ファイルサイズは次の4種類のいずれか： + 128MBタイプ (127398912バイト) + 230MBタイプ (228518400バイト) + 540MBタイプ (533248000バイト) + 640MBタイプ (635600896バイト) + 128MB,230MB,540MBは512バイト/セクタ、640MBは2048バイト/セクタになります。 + + (4)SCSI CD-ROMディスク + ISOファイル形式 (拡張子ISO、ISO9660ベタイメージ) + モード1(2048バイト/セクタ)で、データのみ格納されたファイルとRAW形式で記録 + されたファイルの両方に対応しています。 + +□ディスクイメージの作成 + RaSCSI自体がX68000エミュレータであるXM6 TypeGの派生物です。従ってディスク + イメージの作成はXM6 TypeGの「ツール」メニューから行うことを前提としています。 + もちろん先に説明した仕様に従えばdd等で空のイメージファイルを作成することも + 可能です。 + + 例）100MBのHDSイメージ(空ファイル)を作る場合 + + dd if=/dev/zero of=HARDDISK.HDS bs=512 count=204800 + +□動作実績 + 作者の開発環境であるX68000 PRO(内蔵SASI/純正SCSIボード)、X68030 内蔵SCSI、 + XVI Compact 内蔵SCSIで動作確認しています。Mach-2でも動作しました。 + + 他にも初代X68000,ACE,EXPERT,XVI,PRO2,SUPER等で動作報告がありましたので、 + X68000シリーズはほぼ問題ないでしょう。 + + その他のレトロPCではFM TOWNSシリーズ、PC98シリーズ、Apple Macintosh、 + MSX(MEGA-SCSI利用)で動作報告があります。 + + その他の機種でもちらほらと動作報告を頂いています。 + +□活用方法 +　XM6等のX68000エミュレータを使用している場合はエミュレータで環境構築したHDD + イメージをFTP等でRaspberry Piに転送することでX68000の実機に接続できます。 + またその逆も然りで実機上に存在するファイルを格納したHDDイメージをPCにFTP等 + で転送することでエミュレータで活用することができます。 + +□ライセンス + RaSCSIはカーネルドライバを除きあるがまま"AS IS"で配布されるソフトウェアです。 + カーネルドライバのソースrascsidrv.cのみGPLです(御察っし下さい)。 + + つまり使用者が受けたあらゆる損害に対して一切責任を持ちません。またソフト + ウェアに不備もしくは不具合があったとしてもそれを修正する責任もありません。 + + RaSCSIを利用することでRaspberry PiやレトロPCが故障するリスクがあります。 + あくまで自己責任でチャレンジしてください。 + + XM6 TypeG同様に実験成果公開という性質上私のHP以外での配布を認めておりません。 + + XM6のライセンス条項を継承していますので雑誌/書籍での紹介事前の許諾が必要です。 + そもそも2017年にもなってSCSIに反応するのは限られた人だけだと思います。 + +□変換基板の頒布について + 変換基板の頒布については作者に許諾を得る必要はありません。 + 一応ご連絡いただければ何かとサポートできるかもしれません。 + + 但しレトロPCのSCSI環境改善を応援するという趣旨から、 + 有料の場合は + + 基板製作費 ＋ パーツ費用 ＋ 運送費 ＋（社会通念上一般的な）手数料 + + を大きく越えるような頒布についてはお止め下さい。 + +□公開ホームページ + http://www.geocities.jp/kugimoto0715/rascsi/index.html + +□連絡先 + twitter https://twitter.com/kugimoto0715 + e-mail kugimoto0715@yahoo.co.jp + +[EOF] diff --git a/doc/target.png b/doc/target.png new file mode 100644 index 00000000..52c28cc5 Binary files /dev/null and b/doc/target.png differ diff --git a/doc/x68k.txt b/doc/x68k.txt new file mode 100644 index 00000000..16bc9dec --- /dev/null +++ b/doc/x68k.txt @@ -0,0 +1,109 @@ +------------------------------------------------------------------------------ + + SCSI Target Emulator RaSCSI (*^..^*) + version 1.33 for Raspberry Pi + + Powered by XM6 TypeG Technology. + Copyright (C) 2016-2018 GIMONS + +------------------------------------------------------------------------------ +□X68000固有の機能について + RaSCSIにはブリッジデバイスという仮想的なSCSIデバイスが実装されておりX68000と + ホストであるRaspberry Piの橋渡しを行うことができます。このブリッジデバイスと + X68000用の専用ドライバを使用して下記の機能を提供します。 + + ・イーサーネット + Neptune-Xと同様のイーサーネット機能を提供します。SCSI接続のイーサーネット + BOXのようにRaSCSIが振舞います。Raspberry PiのTAPデバイスにパケットを中継 + することで実現しています。Ether+と似たものです。 + + ・ホストファイルシステム + X68000のエミュレーターでは標準的な機能であるWindrv相当の機能を提供します。 + Raspberry Pi上のファイルシステムをリモートドライブとしてマウントすること + ができます。 + +□ブジッジデバイスの起動方法 + RaSCSI起動時にファイル名として"BRIDGE"というキーワードを設定するとそのIDに + 対してブジッリデバイスを生成します。 + + ex) + sudo rascsi -ID0 HDIMAGE0.HDS -ID6 BRIDGE + +□イーサーネット接続 + 配布物に含まれるRASETHER.SYSを使用します。このデバイスドライバがブリッジ + デバイスと連携してイーサーネットのパケット送受信を行うことができます。 + + 以下、Raspberry Piの仮想アダプタ(TAP)のIPアドレスを「192.168.68.1」として、 + X68000側を「192.168.68.3」とするケースで説明します。 + + ・X68000の設定 + RASETHER.SYSはNeptune-X用ドライバを改造して作ったものですので使用方法は + 全く同じです。X68000をネット接続するためには他に環境設定を行う必要があり + ます。設定方法は自力で調べていただくようお願いします。 + + 以下実際に使用しているCONFIG.SYSとAUTOEXEC.BATの抜粋です。 + + [CONFIG.SYS抜粋] + PROCESS = 3 10 10 + DEVICE = \NETWORK\RASETHER.SYS + + [AUTOEXEC.BAT抜粋] + SET SYSROOT=A:/NETWORK/ + SET temp=A:\ + SET tmp=A:\ + SET HOME=A:/NETWORK/ETC/ + SET HOST=X68000 + XIP.X + IFCONFIG.X lp0 up + IFCONFIG.X en0 192.168.68.3 netmask 255.255.255.0 up + INETDCONF.X +router 192.168.68.1 -rip + INETDCONF.X + + ・Raspberry Piの設定 + TAPデバイスというものを利用していますのでTAPを有効にしてください。恐らく + 最近のJessieであれば最初から有効なはずです。確認方法は/dev/net/tunという + ファイルが存在すれば有効となっていると判断できます。 + + 仮想アダプタの作成方法は次の様に行います。 + + [/etc/rc.local等から設定] + ip tuntap add ras0 mode tap user root + ip link set ras0 up + ifconfig ras0 inet 192.168.68.1/8 up + route add -net 192.168.68.0 netmask 255.255.255.0 dev ras0 + + 上記によってRaspberry Pi(192.168.68.1)とX68000(192.168.68.3)の間で通信が + 可能になります。 + + インターネット等と接続する場合はRaspberry Pi側でブリッジやルーティングの + 設定が必要になります。ご自身の環境に合わせて設定してください。無線LANの + 場合にブリッジ構成するには色々と課題があるようなのでフォワーディングと + NAT構成等もお勧めです。作者はrc.localで次のような設定で使用しています。 + + echo 1 > /proc/sys/net/ipv4/ip_forward + iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE + +□ホストファイルシステム連携 + X68000エミュレータでよく利用されるWindrvやWindrvXMと同等の機能を提供します。 + 専用のRASDRV.SYSというデバイスドライバを組み込めばRaspberri Piのファイル + システムがX68000側のドライブに見えて操作できるということです。 + + デバイスドライバの登録は簡単です。 + 例えば + + DEVICE = \SYS\RASDRV.SYS + + この場合はデフォルトでRaspberry Piのルートディレクトリをマウントします。 + デバイスドライバ起動時にどのドライブにマウントされたか表示されます。 + ルートを以外をマウントする場合はディレクトリを指定して下さい。/home/pi等を + マウントするには + + DEVICE = \SYS\RASDRV.SYS /home/pi + + と指定します。複数のディレクトリを指定すれば別々のドライブとしてマウントする + ことが可能です。 + + SUSIEをご利用の方はSUSIEより先にRASDRV.SYSを組み込んで下さい。後に組み込むと + 正しく認識できなくなると報告があります。 + +[EOF] diff --git a/src/raspberrypi/Makefile b/src/raspberrypi/Makefile new file mode 100644 index 00000000..70eb4cef --- /dev/null +++ b/src/raspberrypi/Makefile @@ -0,0 +1,51 @@ +CC = gcc +CFLAGS = -DNDEBUG -O3 +CXX = g++ +CXXFLAGS = -DNDEBUG -O3 + +RASCSI = rascsi +RASCTL = rasctl +RASDUMP = rasdump + +BIN_ALL = $(RASCSI) $(RASCTL) $(RASDUMP) + +SRC_RASCSI = \ + rascsi.cpp \ + scsi.cpp \ + disk.cpp \ + gpiobus.cpp \ + ctapdriver.cpp \ + cfilesystem.cpp \ + filepath.cpp \ + fileio.cpp + +SRC_RASCTL = \ + rasctl.cpp + +SRC_RASDUMP = \ + rasdump.cpp \ + scsi.cpp \ + gpiobus.cpp \ + filepath.cpp \ + fileio.cpp + +OBJ_RASCSI := $(SRC_RASCSI:.cpp=.o) +OBJ_RASCTL := $(SRC_RASCTL:.c=.o) +OBJ_RASDUMP := $(SRC_RASDUMP:.c=.o) + +.cpp.o: + $(CXX) $(CXXFLAGS) -c $< + +ALL: $(BIN_ALL) + +$(RASCSI): $(OBJ_RASCSI) $ + $(CXX) -o $@ $(OBJ_RASCSI) -lpthread + +$(RASCTL): $(OBJ_RASCTL) $ + $(CXX) -o $@ $(OBJ_RASCTL) + +$(RASDUMP): $(OBJ_RASDUMP) $ + $(CXX) -o $@ $(OBJ_RASDUMP) + +clean: + rm -f *.o $(BIN_ALL) diff --git a/src/raspberrypi/cfilesystem.cpp b/src/raspberrypi/cfilesystem.cpp new file mode 100644 index 00000000..347814da --- /dev/null +++ b/src/raspberrypi/cfilesystem.cpp @@ -0,0 +1,4228 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ 繝帙せ繝医ヵ繧｡繧､繝ｫ繧ｷ繧ｹ繝繝 ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "log.h" +#include "filepath.h" +#include "cfilesystem.h" + +//--------------------------------------------------------------------------- +// +// 貍｢蟄励さ繝ｼ繝牙､画鋤 +// +//--------------------------------------------------------------------------- +#define IC_BUF_SIZE 1024 +static char convert_buf[IC_BUF_SIZE]; +#ifndef __NetBSD__ +// POSIX.1貅匁侠iconv(3)繧剃ｽｿ逕ｨ +#define CONVERT(src, dest, inbuf, outbuf, outsize) \ + convert(src, dest, (char *)inbuf, outbuf, outsize) +static void convert(char const *src, char const *dest, + char *inbuf, char *outbuf, size_t outsize) +#else +// NetBSD迚iconv(3)繧剃ｽｿ逕ｨ: 隨ｬ2蠑墓焚縺ｯconst char ** +#define CONVERT(src, dest, inbuf, outbuf, outsize) \ + convert(src, dest, inbuf, outbuf, outsize) +static void convert(char const *src, char const *dest, + const char *inbuf, char *outbuf, size_t outsize) +#endif +{ + iconv_t cd; + size_t in; + size_t out; + size_t ret; + + *outbuf = '\0'; + in = strlen(inbuf); + out = outsize - 1; + + cd = iconv_open(dest, src); + if (cd == (iconv_t)-1) { + return; + } + + ret = iconv(cd, &inbuf, &in, &outbuf, &out); + if (ret == (size_t)-1) { + return; + } + + iconv_close(cd); + *outbuf = '\0'; +} + +//--------------------------------------------------------------------------- +// +// SJIS->UTF8螟画鋤 +// +//--------------------------------------------------------------------------- +static char* SJIS2UTF8(const char *sjis, char *utf8, size_t bufsize) +{ + CONVERT("SJIS", "UTF-8", sjis, utf8, bufsize); + return convert_buf; +} + +//--------------------------------------------------------------------------- +// +// UTF8->SJIS螟画鋤 +// +//--------------------------------------------------------------------------- +static char* UTF82SJIS(const char *utf8, char *sjis, size_t bufsize) +{ + CONVERT("UTF-8", "SJIS", utf8, sjis, bufsize); + return convert_buf; +} + +//--------------------------------------------------------------------------- +// +// SJIS->UTF8螟画鋤(邁｡譏鍋沿) +// +//--------------------------------------------------------------------------- +static char* S2U(const char *sjis) +{ + SJIS2UTF8(sjis, convert_buf, IC_BUF_SIZE); + return convert_buf; +} + +//--------------------------------------------------------------------------- +// +// UTF8->SJIS螟画鋤(邁｡譏鍋沿) +// +//--------------------------------------------------------------------------- +static char* U2S(const char *utf8) +{ + UTF82SJIS(utf8, convert_buf, IC_BUF_SIZE); + return convert_buf; +} + +//--------------------------------------------------------------------------- +// +/// 繝代せ蜷榊叙蠕 +/// +/// Human68k逕ｨnamests讒矩菴薙°繧峨？uman68k繝代せ蜷阪ｒ蜿門ｾ励☆繧九 +/// 譖ｸ縺崎ｾｼ縺ｿ蜈医ヰ繝繝輔ぃ縺ｯ66繝舌う繝亥ｿ隕√ +// +//--------------------------------------------------------------------------- +void Human68k::namests_t::GetCopyPath(BYTE* szPath) const +{ + ASSERT(this); + ASSERT(szPath); + + BYTE* p = szPath; + for (size_t i = 0; i < 65; i++) { + BYTE c = path[i]; + if (c == '\0') + break; + if (c == 0x09) { + c = '/'; + } + *p++ = c; + } + + *p = '\0'; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷榊叙蠕 +/// +/// Human68k逕ｨnamests讒矩菴薙°繧峨？uman68k繝輔ぃ繧､繝ｫ蜷阪ｒ蜿門ｾ励☆繧九 +/// 譖ｸ縺崎ｾｼ縺ｿ蜈医ヰ繝繝輔ぃ縺ｯ23繝舌う繝亥ｿ隕√ +// +//--------------------------------------------------------------------------- +void Human68k::namests_t::GetCopyFilename(BYTE* szFilename) const +{ + ASSERT(this); + ASSERT(szFilename); + + size_t i; + BYTE* p = szFilename; + + // 繝輔ぃ繧､繝ｫ蜷肴悽菴楢ｻ｢騾 + for (i = 0; i < 8; i++) { + BYTE c = name[i]; + if (c == ' ') { + // 繝輔ぃ繧､繝ｫ蜷堺ｸｭ縺ｫ繧ｹ繝壹ｼ繧ｹ縺悟ｺ迴ｾ縺励◆蝣ｴ蜷医∽ｻ･髯阪ｮ繧ｨ繝ｳ繝医Μ縺檎ｶ壹＞縺ｦ縺繧九°縺ｩ縺縺狗｢ｺ隱 + /// @todo 8+3譁蟄励→TewntyOne莠呈鋤繝｢繝ｼ繝峨〒蜍穂ｽ懊ｒ螟峨∴繧九∋縺 + // add[0] 縺梧怏蜉ｹ縺ｪ譁蟄励↑繧臥ｶ壹¢繧 + if (add[0] != '\0') + goto next_name; + // name[i] 繧医ｊ蠕後↓遨ｺ逋ｽ莉･螟悶ｮ譁蟄励′蟄伜惠縺吶ｋ縺ｪ繧臥ｶ壹¢繧 + for (size_t j = i + 1; j < 8; j++) { + if (name[j] != ' ') + goto next_name; + } + // 繝輔ぃ繧､繝ｫ蜷咲ｵらｫｯ縺ｪ繧芽ｻ｢騾∫ｵゆｺ + break; + } + next_name: + *p++ = c; + } + // 蜈ｨ縺ｦ縺ｮ譁蟄励ｒ隱ｭ縺ｿ霎ｼ繧縺ｨ縲√％縺薙〒 i >= 8 縺ｨ縺ｪ繧 + + // 繝輔ぃ繧､繝ｫ蜷肴悽菴薙′8譁蟄嶺ｻ･荳翫↑繧芽ｿｽ蜉驛ｨ蛻繧ょ刈縺医ｋ + if (i >= 8) { + // 繝輔ぃ繧､繝ｫ蜷崎ｿｽ蜉驛ｨ蛻霆｢騾 + for (i = 0; i < 10; i++) { + BYTE c = add[i]; + if (c == '\0') + break; + *p++ = c; + } + // 蜈ｨ縺ｦ縺ｮ譁蟄励ｒ隱ｭ縺ｿ霎ｼ繧縺ｨ縲√％縺薙〒 i >= 10 縺ｨ縺ｪ繧 + } + + // 諡｡蠑ｵ蟄舌′蟄伜惠縺吶ｋ蝣ｴ蜷医ｯ霆｢騾 + if (ext[0] != ' ' || ext[1] != ' ' || ext[2] != ' ') { + *p++ = '.'; + for (i = 0; i < 3; i++) { + BYTE c = ext[i]; + if (c == ' ') { + // 諡｡蠑ｵ蟄蝉ｸｭ縺ｫ繧ｹ繝壹ｼ繧ｹ縺悟ｺ迴ｾ縺励◆蝣ｴ蜷医∽ｻ･髯阪ｮ繧ｨ繝ｳ繝医Μ縺檎ｶ壹＞縺ｦ縺繧九°縺ｩ縺縺狗｢ｺ隱 + /// @todo 8+3譁蟄励→TewntyOne莠呈鋤繝｢繝ｼ繝峨〒蜍穂ｽ懊ｒ螟峨∴繧九∋縺 + // ext[i] 繧医ｊ蠕後↓遨ｺ逋ｽ莉･螟悶ｮ譁蟄励′蟄伜惠縺吶ｋ縺ｪ繧臥ｶ壹¢繧 + for (size_t j = i + 1; j < 3; j++) { + if (ext[j] != ' ') + goto next_ext; + } + // 諡｡蠑ｵ蟄千ｵらｫｯ縺ｪ繧芽ｻ｢騾∫ｵゆｺ + break; + } + next_ext: + *p++ = c; + } + // 蜈ｨ縺ｦ縺ｮ譁蟄励ｒ隱ｭ縺ｿ霎ｼ繧縺ｨ縲√％縺薙〒 i >= 3 縺ｨ縺ｪ繧 + } + + // 逡ｪ蜈ｵ霑ｽ蜉 + *p = '\0'; +} + +//=========================================================================== +// +// 繝帙せ繝亥ｴ繝峨Λ繧､繝 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +/// 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CHostDrv::CHostDrv() +{ + // 蛻晄悄蛹 + m_bWriteProtect = FALSE; + m_bEnable = FALSE; + m_capCache.sectors = 0; + m_bVolumeCache = FALSE; + m_szVolumeCache[0] = _T('\0'); + m_szBase[0] = _T('\0'); + m_nRing = 0; +} + +//--------------------------------------------------------------------------- +// +/// 繝繧ｹ繝医Λ繧ｯ繧ｿ final +// +//--------------------------------------------------------------------------- +CHostDrv::~CHostDrv() +{ + CHostPath* p; + while ((p = (CHostPath*)m_cRing.Next()) != &m_cRing) { + delete p; + ASSERT(m_nRing); + m_nRing--; + } + + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); + ASSERT(m_nRing == 0); +} + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔→繝ｭ繝ｼ繝) +// +//--------------------------------------------------------------------------- +void CHostDrv::Init(const TCHAR* szBase, DWORD nFlag) +{ + ASSERT(this); + ASSERT(szBase); + ASSERT(strlen(szBase) < FILEPATH_MAX); + ASSERT(m_bWriteProtect == FALSE); + ASSERT(m_bEnable == FALSE); + ASSERT(m_capCache.sectors == 0); + ASSERT(m_bVolumeCache == FALSE); + ASSERT(m_szVolumeCache[0] == _T('\0')); + + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); + ASSERT(m_nRing == 0); + + // 繝代Λ繝｡繝ｼ繧ｿ繧貞女縺大叙繧 + if (nFlag & FSFLAG_WRITE_PROTECT) + m_bWriteProtect = TRUE; + strcpy(m_szBase, szBase); + + // 繝吶ｼ繧ｹ繝代せ縺ｮ譛蠕後ｮ繝代せ蛹ｺ蛻繧翫槭ｼ繧ｯ繧貞炎髯､縺吶ｋ + /// @warning Unicode蛻ｩ逕ｨ譎ゅｯ菫ｮ豁｣縺悟ｿ隕 + TCHAR* pClear = NULL; + TCHAR* p = m_szBase; + for (;;) { + TCHAR c = *p; + if (c == _T('\0')) + break; + if (c == _T('/') || c == _T('\\')) { + pClear = p; + } else { + pClear = NULL; + } + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + p++; + if (*p == _T('\0')) + break; + } + p++; + } + if (pClear) + *pClear = _T('\0'); + + // 迥ｶ諷区峩譁ｰ + m_bEnable = TRUE; +} + +//--------------------------------------------------------------------------- +// +/// 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +BOOL CHostDrv::isMediaOffline() +{ + ASSERT(this); + + // 繧ｪ繝輔Λ繧､繝ｳ迥ｶ諷九メ繧ｧ繝繧ｯ + return m_bEnable == FALSE; +} + +//--------------------------------------------------------------------------- +// +/// 繝｡繝繧｣繧｢繝舌う繝医ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +BYTE CHostDrv::GetMediaByte() const +{ + ASSERT(this); + + return Human68k::MEDIA_REMOTE; +} + +//--------------------------------------------------------------------------- +// +/// 繝峨Λ繧､繝也憾諷九ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD CHostDrv::GetStatus() const +{ + ASSERT(this); + + return 0x40 | (m_bEnable ? (m_bWriteProtect ? 0x08 : 0) | 0x02 : 0); +} + +//--------------------------------------------------------------------------- +// +/// 繝｡繝繧｣繧｢迥ｶ諷玖ｨｭ螳 +// +//--------------------------------------------------------------------------- +void CHostDrv::SetEnable(BOOL bEnable) +{ + ASSERT(this); + + m_bEnable = bEnable; + + if (bEnable == FALSE) { + // 繧ｭ繝｣繝繧ｷ繝･豸亥悉 + m_capCache.sectors = 0; + m_bVolumeCache = FALSE; + m_szVolumeCache[0] = _T('\0'); + } +} + +//--------------------------------------------------------------------------- +// +/// 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +void CHostDrv::GetVolume(TCHAR* szLabel) +{ + ASSERT(this); + ASSERT(szLabel); + ASSERT(m_bEnable); + + // 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ +#ifdef RASCSI + strcpy(m_szVolumeCache, m_szBase); +#else + m_szVolumeCache[0] = _T('\0'); +#endif + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_bVolumeCache = TRUE; + + // 蜀螳ｹ繧定ｻ｢騾 + strcpy(szLabel, m_szVolumeCache); +} + +//--------------------------------------------------------------------------- +// +/// 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν繧貞叙蠕 +/// +/// 繧ｭ繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧九懊Μ繝･繝ｼ繝繝ｩ繝吶Ν諠蝣ｱ繧定ｻ｢騾√☆繧九 +/// 繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ縺梧怏蜉ｹ縺ｪ繧欝RUE繧偵∫┌蜉ｹ縺ｪ繧宇ALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostDrv::GetVolumeCache(TCHAR* szLabel) const +{ + ASSERT(this); + ASSERT(szLabel); + + // 蜀螳ｹ繧定ｻ｢騾 + strcpy(szLabel, m_szVolumeCache); + + return m_bVolumeCache; +} + +//--------------------------------------------------------------------------- +// +/// 螳ｹ驥上ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD CHostDrv::GetCapacity(Human68k::capacity_t* pCapacity) +{ + ASSERT(this); + ASSERT(pCapacity); + ASSERT(m_bEnable); + + DWORD nFree = 0x7FFF8000; + DWORD freearea; + DWORD clusters; + DWORD sectors; + + freearea = 0xFFFF; + clusters = 0xFFFF; + sectors = 64; + + // 繝代Λ繝｡繝ｼ繧ｿ遽蝗ｲ諠ｳ螳 + ASSERT(freearea <= 0xFFFF); + ASSERT(clusters <= 0xFFFF); + ASSERT(sectors <= 64); + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_capCache.freearea = (WORD)freearea; + m_capCache.clusters = (WORD)clusters; + m_capCache.sectors = (WORD)sectors; + m_capCache.bytes = 512; + + // 蜀螳ｹ繧定ｻ｢騾 + memcpy(pCapacity, &m_capCache, sizeof(m_capCache)); + + return nFree; +} + +//--------------------------------------------------------------------------- +// +/// 繧ｭ繝｣繝繧ｷ繝･縺九ｉ螳ｹ驥上ｒ蜿門ｾ +/// +/// 繧ｭ繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧句ｮｹ驥乗ュ蝣ｱ繧定ｻ｢騾√☆繧九 +/// 繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ縺梧怏蜉ｹ縺ｪ繧欝RUE繧偵∫┌蜉ｹ縺ｪ繧宇ALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostDrv::GetCapacityCache(Human68k::capacity_t* pCapacity) const +{ + ASSERT(this); + ASSERT(pCapacity); + + // 蜀螳ｹ繧定ｻ｢騾 + memcpy(pCapacity, &m_capCache, sizeof(m_capCache)); + + return m_capCache.sectors != 0; +} + +//--------------------------------------------------------------------------- +// +/// 蜈ｨ縺ｦ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostDrv::CleanCache() +{ + ASSERT(this); + + Lock(); + for (CHostPath* p = (CHostPath*)m_cRing.Next(); p != &m_cRing;) { + p->Release(); + p = (CHostPath*)p->Next(); + } + Unlock(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostDrv::CleanCache(const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + + Lock(); + CHostPath* p = FindCache(szHumanPath); + if (p) { + p->Restore(); + p->Release(); + } + Unlock(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ莉･荳九ｮ繧ｭ繝｣繝繧ｷ繝･繧貞ｨ縺ｦ譖ｴ譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostDrv::CleanCacheChild(const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + + Lock(); + CHostPath* p = (CHostPath*)m_cRing.Next(); + while (p != &m_cRing) { + if (p->isSameChild(szHumanPath)) + p->Release(); + p = (CHostPath*)p->Next(); + } + Unlock(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostDrv::DeleteCache(const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + + Lock(); + CHostPath* p = FindCache(szHumanPath); + if (p) { + delete p; + ASSERT(m_nRing); + m_nRing--; + } + Unlock(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ縺後く繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧九°讀懃ｴ｢縺吶ｋ +/// +/// 謇譛峨☆繧九く繝｣繧ｷ繝･繝舌ャ繝輔ぃ縺ｮ荳ｭ縺九ｉ螳悟ｨ荳閾ｴ縺ｧ讀懃ｴ｢縺励∬ｦ九▽縺九ｌ縺ｰ縺昴ｮ蜷咲ｧｰ繧定ｿ斐☆縲 +/// 繝輔ぃ繧､繝ｫ蜷阪ｒ髯､螟悶＠縺ｦ縺翫￥縺薙→縲 +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +// +//--------------------------------------------------------------------------- +CHostPath* CHostDrv::FindCache(const BYTE* szHuman) +{ + ASSERT(this); + ASSERT(szHuman); + + // 謇謖√＠縺ｦ縺繧句ｨ縺ｦ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｮ荳ｭ縺九ｉ螳悟ｨ荳閾ｴ縺吶ｋ繧ゅｮ繧呈､懃ｴ｢ + for (CHostPath* p = (CHostPath*)m_cRing.Next(); p != &m_cRing;) { + if (p->isSameHuman(szHuman)) + return p; + p = (CHostPath*)p->Next(); + } + + return NULL; +} + +//--------------------------------------------------------------------------- +// +/// 繧ｭ繝｣繝繧ｷ繝･諠蝣ｱ繧貞縺ｫ縲√帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧堤佐蠕励☆繧 +/// +/// 繝代せ縺後く繝｣繝繧ｷ繝･縺ｫ縺ゅｋ縺狗｢ｺ隱阪ゅ↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縲 +/// 隕九▽縺九▲縺溘く繝｣繝繧ｷ繝･縺ｮ譖ｴ譁ｰ繝√ぉ繝繧ｯ縲よ峩譁ｰ縺悟ｿ隕√↑繧峨お繝ｩ繝ｼ縲 +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +// +//--------------------------------------------------------------------------- +CHostPath* CHostDrv::CopyCache(CHostFiles* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + ASSERT(strlen((const char*)pFiles->GetHumanPath()) < HUMAN68K_PATH_MAX); + + // 繧ｭ繝｣繝繧ｷ繝･讀懃ｴ｢ + CHostPath* pPath = FindCache(pFiles->GetHumanPath()); + if (pPath == NULL) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繧ｭ繝｣繝繧ｷ繝･縺ｪ縺 + + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ遘ｻ蜍 + pPath->Insert(&m_cRing); + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ繝√ぉ繝繧ｯ + if (pPath->isRefresh()) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ縺悟ｿ隕 + + // 繝帙せ繝亥ｴ縺ｮ繝代せ蜷阪ｒ菫晏ｭ + pFiles->SetResult(pPath->GetHost()); + + return pPath; +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｮ讒狗ｯ峨↓蠢隕√↑諠蝣ｱ繧偵☆縺ｹ縺ｦ蜿門ｾ励☆繧 +/// +/// 繝輔ぃ繧､繝ｫ蜷阪ｯ逵∫払蜿ｯ閭ｽ縲(譎ｮ騾壹ｯ謖螳壹＠縺ｪ縺) +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +/// 繝吶ｼ繧ｹ繝代せ譛ｫ蟆ｾ縺ｫ繝代せ蛹ｺ蛻繧頑枚蟄励ｒ縺､縺代↑縺繧医≧豕ｨ諢上 +/// 繝輔ぃ繧､繝ｫ繧｢繧ｯ繧ｻ繧ｹ縺悟､夂匱縺吶ｋ蜿ｯ閭ｽ諤ｧ縺後≠繧九→縺阪ｯ縲〃M繧ｹ繝ｬ繝繝峨ｮ蜍穂ｽ懊ｒ髢句ｧ九＆縺帙ｋ縲 +/// +/// 菴ｿ縺縺九◆: +/// CopyCache()縺励※繧ｨ繝ｩ繝ｼ縺ｮ蝣ｴ蜷医ｯMakeCache()縺吶ｋ縲ょｿ縺壽ｭ｣縺励＞繝帙せ繝亥ｴ縺ｮ繝代せ縺悟叙蠕励〒縺阪ｋ縲 +/// +/// 繝輔ぃ繧､繝ｫ蜷阪→繝代せ蜷阪ｒ縺吶∋縺ｦ蛻髮｢縺吶ｋ縲 +/// 荳贋ｽ阪ョ繧｣繝ｬ繧ｯ繝医Μ縺九ｉ鬆縺ｫ縲√く繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧九°縺ｩ縺縺狗｢ｺ隱阪 +/// 繧ｭ繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧後ｰ遐ｴ譽繝√ぉ繝繧ｯ縲らｴ譽縺励◆蝣ｴ蜷域悴繧ｭ繝｣繝繧ｷ繝･謇ｱ縺縺ｨ縺ｪ繧九 +/// 繧ｭ繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺縺ｪ縺代ｌ縺ｰ繧ｭ繝｣繝繧ｷ繝･繧呈ｧ狗ｯ峨 +/// 鬆逡ｪ縺ｫ縺吶∋縺ｦ縺ｮ繝繧｣繝ｬ繧ｯ繝医Μ繝ｻ繝輔ぃ繧､繝ｫ蜷阪↓蟇ｾ縺励※陦後↑縺邨ゆｺ縲 +/// 繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷ｴ蜷医ｯNULL縺ｨ縺ｪ繧九 +// +//--------------------------------------------------------------------------- +CHostPath* CHostDrv::MakeCache(CHostFiles* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + ASSERT(strlen((const char*)pFiles->GetHumanPath()) < HUMAN68K_PATH_MAX); + + ASSERT(m_szBase); + ASSERT(strlen(m_szBase) < FILEPATH_MAX); + + BYTE szHumanPath[HUMAN68K_PATH_MAX]; // 繝ｫ繝ｼ繝医°繧蛾縺ｫ繝代せ蜷阪′蜈･繧 + szHumanPath[0] = '\0'; + size_t nHumanPath = 0; + + TCHAR szHostPath[FILEPATH_MAX]; + strcpy(szHostPath, m_szBase); + size_t nHostPath = strlen(szHostPath); + + CHostPath* pPath; + const BYTE* p = pFiles->GetHumanPath(); + for (;;) { + // 繝代せ蛹ｺ蛻繧翫ｒ霑ｽ蜉 + if (nHumanPath + 1 >= HUMAN68K_PATH_MAX) + return NULL; // 繧ｨ繝ｩ繝ｼ: Human68k繝代せ縺碁聞縺吶℃繧 + szHumanPath[nHumanPath++] = '/'; + szHumanPath[nHumanPath] = '\0'; + if (nHostPath + 1 >= FILEPATH_MAX) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繝帙せ繝亥ｴ縺ｮ繝代せ縺碁聞縺吶℃繧 + szHostPath[nHostPath++] = _T('/'); + szHostPath[nHostPath] = _T('\0'); + + // 繝輔ぃ繧､繝ｫ縺縺｣縺薙＞繧後ｋ + BYTE szHumanFilename[24]; // 繝輔ぃ繧､繝ｫ蜷埼Κ蛻 + p = SeparateCopyFilename(p, szHumanFilename); + if (p == NULL) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繝輔ぃ繧､繝ｫ蜷崎ｪｭ縺ｿ霎ｼ縺ｿ螟ｱ謨 + size_t n = strlen((const char*)szHumanFilename); + if (nHumanPath + n >= HUMAN68K_PATH_MAX) + return NULL; // 繧ｨ繝ｩ繝ｼ: Human68k繝代せ縺碁聞縺吶℃繧 + + // 隧ｲ蠖薙ヱ繧ｹ縺後く繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧九°ｼ + pPath = FindCache(szHumanPath); + if (pPath == NULL) { + // 繧ｭ繝｣繝繧ｷ繝･譛螟ｧ謨ｰ繝√ぉ繝繧ｯ + if (m_nRing >= XM6_HOST_DIRENTRY_CACHE_MAX) { + // 譛繧ょ商縺繧ｭ繝｣繝繧ｷ繝･繧堤ｴ譽縺励※蜀榊茜逕ｨ + pPath = (CHostPath*)m_cRing.Prev(); + pPath->Clean(); // 蜈ｨ繝輔ぃ繧､繝ｫ隗｣謾ｾ 譖ｴ譁ｰ繝√ぉ繝繧ｯ逕ｨ繝上Φ繝峨Ν繧りｧ｣謾ｾ + } else { + // 譁ｰ隕冗匳骭ｲ + pPath = new CHostPath; + ASSERT(pPath); + m_nRing++; + } + pPath->SetHuman(szHumanPath); + pPath->SetHost(szHostPath); + + // 迥ｶ諷区峩譁ｰ + pPath->Refresh(); + } + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ繝√ぉ繝繧ｯ + if (pPath->isRefresh()) { + // 迥ｶ諷区峩譁ｰ + pPath->Refresh(); + } + + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ + pPath->Insert(&m_cRing); + + // 繝輔ぃ繧､繝ｫ蜷阪′縺ｪ縺代ｌ縺ｰ縺薙％縺ｧ邨ゆｺ + if (n == 0) + break; + + // 谺｡縺ｮ繝代せ繧呈､懃ｴ｢ + // 繝代せ縺ｮ騾比ｸｭ縺ｪ繧峨ョ繧｣繝ｬ繧ｯ繝医Μ縺九←縺縺狗｢ｺ隱 + const CHostFilename* pFilename; + if (*p != '\0') + pFilename = pPath->FindFilename(szHumanFilename, Human68k::AT_DIRECTORY); + else + pFilename = pPath->FindFilename(szHumanFilename); + if (pFilename == NULL) + return NULL; // 繧ｨ繝ｩ繝ｼ: 騾比ｸｭ縺ｮ繝代せ蜷/繝輔ぃ繧､繝ｫ蜷阪′隕九▽縺九ｉ縺ｪ縺 + + // 繝代せ蜷阪ｒ騾｣邨 + strcpy((char*)szHumanPath + nHumanPath, (const char*)szHumanFilename); + nHumanPath += n; + + n = strlen(pFilename->GetHost()); + if (nHostPath + n >= FILEPATH_MAX) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繝帙せ繝亥ｴ縺ｮ繝代せ縺碁聞縺吶℃繧 + strcpy(szHostPath + nHostPath, pFilename->GetHost()); + nHostPath += n; + + // PLEASE CONTINUE + if (*p == '\0') + break; + } + + // 繝帙せ繝亥ｴ縺ｮ繝代せ蜷阪ｒ菫晏ｭ + pFiles->SetResult(szHostPath); + + return pPath; +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧呈､懃ｴ｢ (繝代せ蜷+繝輔ぃ繧､繝ｫ蜷(逵∫払蜿ｯ)+螻樊ｧ) +/// +/// 縺ゅｉ縺九§繧∝ｨ縺ｦ縺ｮHuman68k逕ｨ繝代Λ繝｡繝ｼ繧ｿ繧定ｨｭ螳壹＠縺ｦ縺翫￥縺薙→縲 +// +//--------------------------------------------------------------------------- +BOOL CHostDrv::Find(CHostFiles* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + + // 謗剃ｻ門宛蠕｡髢句ｧ + Lock(); + + // 繝代せ蜷咲佐蠕励♀繧医ｳ繧ｭ繝｣繝繧ｷ繝･讒狗ｯ + CHostPath* pPath = CopyCache(pFiles); + if (pPath == NULL) { + pPath = MakeCache(pFiles); + if (pPath == NULL) { + Unlock(); + CleanCache(); + return FALSE; // 繧ｨ繝ｩ繝ｼ: 繧ｭ繝｣繝繧ｷ繝･讒狗ｯ牙､ｱ謨 + } + } + + // 繝帙せ繝亥ｴ縺ｮ繝代せ蜷阪ｒ菫晏ｭ + pFiles->SetResult(pPath->GetHost()); + + // 繝代せ蜷阪ｮ縺ｿ縺ｪ繧臥ｵゆｺ + if (pFiles->isPathOnly()) { + Unlock(); + return TRUE; // 豁｣蟶ｸ邨ゆｺ: 繝代せ蜷阪ｮ縺ｿ + } + + // 繝輔ぃ繧､繝ｫ蜷肴､懃ｴ｢ + const CHostFilename* pFilename = pFiles->Find(pPath); + if (pFilename == NULL) { + Unlock(); + return FALSE; // 繧ｨ繝ｩ繝ｼ: 繝輔ぃ繧､繝ｫ蜷阪′迯ｲ蠕励〒縺阪∪縺帙ｓ + } + + // Human68k蛛ｴ縺ｮ讀懃ｴ｢邨先棡菫晏ｭ + pFiles->SetEntry(pFilename); + + // 繝帙せ繝亥ｴ縺ｮ繝輔Ν繝代せ蜷堺ｿ晏ｭ + pFiles->AddResult(pFilename->GetHost()); + + // 謗剃ｻ門宛蠕｡邨ゆｺ + Unlock(); + + return TRUE; +} + +//=========================================================================== +// +// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 繝輔ぃ繧､繝ｫ蜷 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +/// 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CHostFilename::CHostFilename() +{ +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧定ｨｭ螳 +// +//--------------------------------------------------------------------------- +void CHostFilename::SetHost(const TCHAR* szHost) +{ + ASSERT(this); + ASSERT(szHost); + ASSERT(strlen(szHost) < FILEPATH_MAX); + + strcpy(m_szHost, szHost); +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷崎ｦ∫ｴ繧偵さ繝斐ｼ +// +//--------------------------------------------------------------------------- +BYTE* CHostFilename::CopyName(BYTE* pWrite, const BYTE* pFirst, const BYTE* pLast) // static +{ + ASSERT(pWrite); + ASSERT(pFirst); + ASSERT(pLast); + + for (const BYTE* p = pFirst; p < pLast; p++) { + *pWrite++ = *p; + } + + return pWrite; +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧貞､画鋤 +/// +/// 縺ゅｉ縺九§繧ヾetHost()繧貞ｮ溯｡後＠縺ｦ縺翫￥縺薙→縲 +/// 18+3縺ｮ蜻ｽ蜷崎ｦ丞援縺ｫ蠕薙▲縺溷錐蜑榊､画鋤繧定｡後↑縺縲 +/// 繝輔ぃ繧､繝ｫ蜷榊磯ｭ縺翫ｈ縺ｳ譛ｫ蟆ｾ縺ｮ遨ｺ逋ｽ縺ｯ縲？uman68k縺ｧ謇ｱ縺医↑縺縺溘ａ閾ｪ蜍慕噪縺ｫ蜑企勁縺輔ｌ繧九 +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ蜷榊燕驛ｨ蛻繧偵√ヵ繧｡繧､繝ｫ蜷榊､画鋤譎ゅｮ諡｡蠑ｵ蟄舌ｮ菴咲ｽｮ諠蝣ｱ繧剃ｽｿ縺｣縺ｦ逕滓舌☆繧九 +/// 縺昴ｮ蠕後√ヵ繧｡繧､繝ｫ蜷阪ｮ逡ｰ蟶ｸ蛻､螳壹ｒ陦後↑縺縲(繧ｹ繝壹ｼ繧ｹ8譁蟄励□縺代ｮ繝輔ぃ繧､繝ｫ蜷阪↑縺ｩ) +/// 繝輔ぃ繧､繝ｫ蜷阪ｮ驥崎､蛻､螳壹ｯ陦後↑繧上↑縺縺ｮ縺ｧ豕ｨ諢上ゅ％繧後ｉ縺ｮ蛻､螳壹ｯ荳贋ｽ阪け繝ｩ繧ｹ縺ｧ陦後↑縺縲 +/// TwentyOne version 1.36c modified +14 patchlevel9莉･髯阪ｮ諡｡蠑ｵ蟄占ｦ丞援縺ｫ蟇ｾ蠢懊＆縺帙ｋ縲 +// +//--------------------------------------------------------------------------- +void CHostFilename::ConvertHuman(int nCount) +{ + char szHost[FILEPATH_MAX]; + + ASSERT(this); + + // 迚ｹ谿翫ョ繧｣繝ｬ繧ｯ繝医Μ蜷阪ｮ蝣ｴ蜷医ｯ螟画鋤縺励↑縺 + if (m_szHost[0] == _T('.') && + (m_szHost[1] == _T('\0') || (m_szHost[1] == _T('.') && m_szHost[2] == _T('\0')))) { + strcpy((char*)m_szHuman, m_szHost); /// @warning Unicode譎りｦ∽ｿｮ豁｣ 竊 貂 + + m_bCorrect = TRUE; + m_pszHumanLast = m_szHuman + strlen((const char*)m_szHuman); + m_pszHumanExt = m_pszHumanLast; + return; + } + + size_t nMax = 18; // 繝吶ｼ繧ｹ驛ｨ蛻(繝吶ｼ繧ｹ蜷阪→諡｡蠑ｵ蟄仙錐)縺ｮ繝舌う繝域焚 + DWORD nOption = CFileSys::GetFileOption(); + if (nOption & WINDRV_OPT_CONVERT_LENGTH) + nMax = 8; + + // 繝吶ｼ繧ｹ蜷埼Κ蛻縺ｮ陬懈ｭ｣貅門ｙ + BYTE szNumber[8]; + BYTE* pNumber = NULL; + if (nCount >= 0) { + pNumber = &szNumber[8]; + for (DWORD i = 0; i < 5; i++) { // 譛螟ｧ5+1譯√∪縺ｧ (繝吶ｼ繧ｹ蜷榊磯ｭ2繝舌う繝医ｯ蠢縺壽ｮ九☆) + int n = nCount % 36; + nMax--; + pNumber--; + *pNumber = (BYTE)(n + (n < 10 ? '0' : 'A' - 10)); + nCount /= 36; + if (nCount == 0) + break; + } + nMax--; + pNumber--; + BYTE c = (BYTE)((nOption >> 24) & 0x7F); + if (c == 0) + c = XM6_HOST_FILENAME_MARK; + *pNumber = c; + } + + // 譁蟄怜､画鋤 + /// @warning Unicode譛ｪ蟇ｾ蠢懊ゅ＞縺壹ｌUnicode縺ｮ荳也阜縺ｫ鬟ｮ縺ｾ繧後◆譎ゅｯ縺薙％縺ｧ螟画鋤繧定｡後↑縺 竊 貂 + BYTE szHuman[FILEPATH_MAX]; + const BYTE* pFirst = szHuman; + const BYTE* pLast; + const BYTE* pExt = NULL; + + { + strcpy(szHost, m_szHost); + const BYTE* pRead = (const BYTE*)szHost; + BYTE* pWrite = szHuman; + const BYTE* pPeriod = SeparateExt(pRead); + + for (bool bFirst = true;; bFirst = false) { + BYTE c = *pRead++; + switch (c) { + case ' ': + if (nOption & WINDRV_OPT_REDUCED_SPACE) + continue; + if (nOption & WINDRV_OPT_CONVERT_SPACE) + c = '_'; + else if (pWrite == szHuman) + continue; // 蜈磯ｭ縺ｮ遨ｺ逋ｽ縺ｯ辟｡隕 + break; + case '=': + case '+': + if (nOption & WINDRV_OPT_REDUCED_BADCHAR) + continue; + if (nOption & WINDRV_OPT_CONVERT_BADCHAR) + c = '_'; + break; + case '-': + if (bFirst) { + if (nOption & WINDRV_OPT_REDUCED_HYPHEN) + continue; + if (nOption & WINDRV_OPT_CONVERT_HYPHEN) + c = '_'; + break; + } + if (nOption & WINDRV_OPT_REDUCED_HYPHENS) + continue; + if (nOption & WINDRV_OPT_CONVERT_HYPHENS) + c = '_'; + break; + case '.': + if (pRead - 1 == pPeriod) { // Human68k諡｡蠑ｵ蟄舌ｯ萓句､悶→縺吶ｋ + pExt = pWrite; + break; + } + if (bFirst) { + if (nOption & WINDRV_OPT_REDUCED_PERIOD) + continue; + if (nOption & WINDRV_OPT_CONVERT_PERIOD) + c = '_'; + break; + } + if (nOption & WINDRV_OPT_REDUCED_PERIODS) + continue; + if (nOption & WINDRV_OPT_CONVERT_PERIODS) + c = '_'; + break; + } + *pWrite++ = c; + if (c == '\0') + break; + } + + pLast = pWrite - 1; + } + + // 諡｡蠑ｵ蟄占｣懈ｭ｣ + if (pExt) { + // 譛ｫ蟆ｾ縺ｮ遨ｺ逋ｽ繧貞炎髯､縺吶ｋ + while (pExt < pLast - 1 && *(pLast - 1) == ' ') { + pLast--; + BYTE* p = (BYTE*)pLast; + *p = '\0'; + } + + // 螟画鋤蠕後↓螳滉ｽ薙′縺ｪ縺上↑縺｣縺溷ｴ蜷医ｯ蜑企勁 + if (pExt + 1 >= pLast) { + pLast = pExt; + BYTE* p = (BYTE*)pLast; + *p = '\0'; // 蠢ｵ縺ｮ縺溘ａ + } + } else { + pExt = pLast; + } + + // 逋ｻ蝣ｴ莠ｺ迚ｩ邏ｹ莉 + // + // pFirst: 菫ｺ縺ｯ繝ｪ繝ｼ繝繝ｼ縲ゅヵ繧｡繧､繝ｫ蜷榊磯ｭ + // pCut: 騾夂ｧｰ繝輔ぉ繧､繧ｹ縲よ怙蛻昴ｮ繝斐Μ繧ｪ繝峨ｮ蜃ｺ迴ｾ菴咲ｽｮ 縺昴ｮ蠕後吶ｼ繧ｹ蜷咲ｵらｫｯ菴咲ｽｮ縺ｨ縺ｪ繧 + // pSecond: 繧医♂縺翫∪縺｡縺ｩ縺縲ゆｿｺ讒倥％縺昴槭ｼ繝峨ャ繧ｯ縲よ僑蠑ｵ蟄仙錐縺ｮ髢句ｧ倶ｽ咲ｽｮ縲ゅ□縺九ｉ菴輔 + // pExt: B繝ｻA繝ｻ繝舌Λ繧ｫ繧ｹ縲Human68k諡｡蠑ｵ蟄舌ｮ螟ｩ謇阪□縲ゅ〒繧ゅ3譁蟄励ｈ繧企聞縺蜷榊燕縺ｯ蜍伜ｼ√↑縲 + // 譛蠕後ｮ繝斐Μ繧ｪ繝峨ｮ蜃ｺ迴ｾ菴咲ｽｮ 隧ｲ蠖薙＠縺ｪ縺代ｌ縺ｰpLast縺ｨ蜷後§蛟､ + // + // 竊菟First 竊菟Stop 竊菟Second 竊 竊菟Ext + // T h i s _ i s _ a . V e r y . L o n g . F i l e n a m e . t x t \0 + // 竊叢Cut 竊 竊叢Cut蛻晄悄菴咲ｽｮ 竊叢Last + // + // 荳願ｨ倥ｮ蝣ｴ蜷医∝､画鋤蠕後ｯ This.Long.Filename.txt 縺ｨ縺ｪ繧 + + // 1譁蟄礼岼蛻､螳 + const BYTE* pCut = pFirst; + const BYTE* pStop = pExt - nMax; // 諡｡蠑ｵ蟄仙錐縺ｯ譛螟ｧ17繝舌う繝医→縺吶ｋ(繝吶ｼ繧ｹ蜷阪ｒ谿九☆) + if (pFirst < pExt) { + pCut++; // 蠢縺1繝舌う繝医ｯ繝吶ｼ繧ｹ蜷阪ｒ菴ｿ縺 + BYTE c = *pFirst; + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + pCut++; // 繝吶ｼ繧ｹ蜷 譛蟆2繝舌う繝 + pStop++; // 諡｡蠑ｵ蟄仙錐 譛螟ｧ16繝舌う繝 + } + } + if (pStop < pFirst) + pStop = pFirst; + + // 繝吶ｼ繧ｹ蜷榊愛螳 + pCut = (BYTE*)strchr((const char*)pCut, '.'); // SJIS2繝舌う繝育岼縺ｯ蠢縺0x40莉･荳翫↑縺ｮ縺ｧ蝠城｡後↑縺 + if (pCut == NULL) + pCut = pLast; + if ((size_t)(pCut - pFirst) > nMax) + pCut = pFirst + nMax; // 蠕後⊇縺ｩSJIS2繝舌う繝亥愛螳/陬懈ｭ｣繧定｡後↑縺 縺薙％縺ｧ蛻､螳壹＠縺ｦ縺ｯ縺縺代↑縺 + + // 諡｡蠑ｵ蟄仙錐蛻､螳 + const BYTE* pSecond = pExt; + const BYTE* p; + for (p = pExt - 1; pStop < p; p--) { + if (*p == '.') + pSecond = p; // SJIS2繝舌う繝育岼縺ｯ蠢縺0x40莉･荳翫↑縺ｮ縺ｧ蝠城｡後↑縺 + } + + // 繝吶ｼ繧ｹ蜷阪ｒ遏ｭ邵ｮ + size_t nExt = pExt - pSecond; // 諡｡蠑ｵ蟄仙錐驛ｨ蛻縺ｮ髟ｷ縺 + if ((size_t)(pCut - pFirst) + nExt > nMax) + pCut = pFirst + nMax - nExt; + // 2繝舌う繝域枚蟄励ｮ騾比ｸｭ縺ｪ繧峨＆繧峨↓遏ｭ邵ｮ + for (p = pFirst; p < pCut; p++) { + BYTE c = *p; + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + p++; + if (p >= pCut) { + pCut--; + break; + } + } + } + + // 蜷榊燕縺ｮ邨仙粋 + BYTE* pWrite = m_szHuman; + pWrite = CopyName(pWrite, pFirst, pCut); // 繝吶ｼ繧ｹ蜷阪ｒ霆｢騾 + if (pNumber) + pWrite = CopyName(pWrite, pNumber, &szNumber[8]); // 陬懈ｭ｣譁蟄励ｒ霆｢騾 + pWrite = CopyName(pWrite, pSecond, pExt); // 諡｡蠑ｵ蟄仙錐繧定ｻ｢騾 + m_pszHumanExt = pWrite; // 諡｡蠑ｵ蟄蝉ｽ咲ｽｮ菫晏ｭ + pWrite = CopyName(pWrite, pExt, pLast); // Human68k諡｡蠑ｵ蟄舌ｒ霆｢騾 + m_pszHumanLast = pWrite; // 邨らｫｯ菴咲ｽｮ菫晏ｭ + *pWrite = '\0'; + + // 螟画鋤邨先棡縺ｮ遒ｺ隱 + m_bCorrect = TRUE; + + // 繝輔ぃ繧､繝ｫ蜷肴悽菴薙′蟄伜惠縺励↑縺代ｌ縺ｰ荳榊粋譬ｼ + if (m_pszHumanExt <= m_szHuman) + m_bCorrect = FALSE; + + // 繝輔ぃ繧､繝ｫ蜷肴悽菴薙′1譁蟄嶺ｻ･荳翫〒縺九▽遨ｺ逋ｽ縺ｧ邨ゆｺ縺励※縺繧後ｰ荳榊粋譬ｼ + // 繝輔ぃ繧､繝ｫ蜷肴悽菴薙′8譁蟄嶺ｻ･荳翫ｮ蝣ｴ蜷医∫炊隲紋ｸ翫ｯ遨ｺ逋ｽ縺ｧ縺ｮ邨ゆｺ縺瑚｡ｨ迴ｾ蜿ｯ + // 閭ｽ縺縺後？uman68k縺ｧ縺ｯ豁｣縺励￥謇ｱ縺医↑縺縺溘ａ縲√％繧後ｂ荳榊粋譬ｼ縺ｨ縺吶ｋ + else if (m_pszHumanExt[-1] == ' ') + m_bCorrect = FALSE; + + // 螟画鋤邨先棡縺檎音谿翫ョ繧｣繝ｬ繧ｯ繝医Μ蜷阪→蜷後§縺ｪ繧我ｸ榊粋譬ｼ + if (m_szHuman[0] == '.' && + (m_szHuman[1] == '\0' || (m_szHuman[1] == '.' && m_szHuman[2] == '\0'))) + m_bCorrect = FALSE; +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧定､陬ｽ +/// +/// 繝輔ぃ繧､繝ｫ蜷埼Κ蛻縺ｮ諠蝣ｱ繧定､陬ｽ縺励，onvertHuman()逶ｸ蠖薙ｮ蛻晄悄蛹門虚菴懊ｒ陦後↑縺縲 +// +//--------------------------------------------------------------------------- +void CHostFilename::CopyHuman(const BYTE* szHuman) +{ + ASSERT(this); + ASSERT(szHuman); + ASSERT(strlen((const char*)szHuman) < 23); + + strcpy((char*)m_szHuman, (const char*)szHuman); + m_bCorrect = TRUE; + m_pszHumanLast = m_szHuman + strlen((const char*)m_szHuman); + m_pszHumanExt = (BYTE*)SeparateExt(m_szHuman); +} + +//--------------------------------------------------------------------------- +// +/// Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 +/// +/// ConvertHuman()縺ｧ險ｭ螳壽ｸ医∩縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｒ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｫ蜿肴丐縺吶ｋ縲 +// +//--------------------------------------------------------------------------- +void CHostFilename::SetEntryName() +{ + ASSERT(this); + + // 繝輔ぃ繧､繝ｫ蜷崎ｨｭ螳 + BYTE* p = m_szHuman; + size_t i; + for (i = 0; i < 8; i++) { + if (p < m_pszHumanExt) + m_dirHuman.name[i] = *p++; + else + m_dirHuman.name[i] = ' '; + } + + for (i = 0; i < 10; i++) { + if (p < m_pszHumanExt) + m_dirHuman.add[i] = *p++; + else + m_dirHuman.add[i] = '\0'; + } + + if (*p == '.') + p++; + for (i = 0; i < 3; i++) { + BYTE c = *p; + if (c) + p++; + m_dirHuman.ext[i] = c; + } +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ縺悟刈蟾･縺輔ｌ縺溘°隱ｿ譟ｻ +// +//--------------------------------------------------------------------------- +BOOL CHostFilename::isReduce() const +{ + ASSERT(this); + + return strcmp((LPTSTR)m_szHost, (const char*)m_szHuman) != 0; /// @warning Unicode譎りｦ∽ｿｮ豁｣ 竊 貂 +} + +//--------------------------------------------------------------------------- +// +/// Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ螻樊ｧ蛻､螳 +// +//--------------------------------------------------------------------------- +BOOL CHostFilename::CheckAttribute(DWORD nHumanAttribute) const +{ + ASSERT(this); + + BYTE nAttribute = m_dirHuman.attr; + if ((nAttribute & (Human68k::AT_ARCHIVE | Human68k::AT_DIRECTORY | Human68k::AT_VOLUME)) == 0) + nAttribute |= Human68k::AT_ARCHIVE; + + return nAttribute & nHumanAttribute; +} + +//--------------------------------------------------------------------------- +// +/// Human68k繝輔ぃ繧､繝ｫ蜷阪°繧画僑蠑ｵ蟄舌ｒ蛻髮｢ +// +//--------------------------------------------------------------------------- +const BYTE* CHostFilename::SeparateExt(const BYTE* szHuman) // static +{ + // 繝輔ぃ繧､繝ｫ蜷阪ｮ髟ｷ縺輔ｒ迯ｲ蠕 + size_t nLength = strlen((const char*)szHuman); + const BYTE* pFirst = szHuman; + const BYTE* pLast = pFirst + nLength; + + // Human68k諡｡蠑ｵ蟄舌ｮ菴咲ｽｮ繧堤｢ｺ隱 + const BYTE* pExt = (BYTE*)strrchr((const char*)pFirst, '.'); // SJIS2繝舌う繝育岼縺ｯ蠢縺0x40莉･荳翫↑縺ｮ縺ｧ蝠城｡後↑縺 + if (pExt == NULL) + pExt = pLast; + // 繝輔ぃ繧､繝ｫ蜷阪′20ｽ22譁蟄励°縺､19譁蟄礼岼縺'.'縺九▽'.'縺ｧ邨ゆｺ縺ｨ縺縺繝代ち繝ｼ繝ｳ繧堤音蛻･謇ｱ縺縺吶ｋ + if (20 <= nLength && nLength <= 22 && pFirst[18] == '.' && pFirst[nLength - 1] == '.') + pExt = pFirst + 18; + // 諡｡蠑ｵ蟄舌ｮ譁蟄玲焚繧定ｨ育ｮ (-1:縺ｪ縺 0:繝斐Μ繧ｪ繝峨□縺 1ｽ3:Human68k諡｡蠑ｵ蟄 4莉･荳:諡｡蠑ｵ蟄仙錐) + size_t nExt = pLast - pExt - 1; + // '.' 縺梧枚蟄怜怜磯ｭ莉･螟悶↓蟄伜惠縺励※縲√°縺､1ｽ3譁蟄励ｮ蝣ｴ蜷医ｮ縺ｿ諡｡蠑ｵ蟄舌→縺ｿ縺ｪ縺 + if (pExt == pFirst || nExt < 1 || nExt > 3) + pExt = pLast; + + return pExt; +} + +//=========================================================================== +// +// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 繝代せ蜷 +// +//=========================================================================== + +DWORD CHostPath::g_nId; ///< 隴伜挨ID逕滓千畑繧ｫ繧ｦ繝ｳ繧ｿ + +//--------------------------------------------------------------------------- +// +/// 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CHostPath::CHostPath() +{ + m_bRefresh = TRUE; + +#ifdef _DEBUG + // 蠢縺壼､縺梧峩譁ｰ縺輔ｌ繧九ｮ縺ｧ蛻晄悄蛹紋ｸ崎ｦ (繝繝舌ャ繧ｰ譎ゅｮ蛻晄悄蜍穂ｽ懃｢ｺ隱咲畑) + m_nId = 0; +#endif // _DEBUG +} + +//--------------------------------------------------------------------------- +// +/// 繝繧ｹ繝医Λ繧ｯ繧ｿ final +// +//--------------------------------------------------------------------------- +CHostPath::~CHostPath() +{ + Clean(); +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷埼伜沺遒ｺ菫 +/// +/// 縺ｻ縺ｨ繧薙←縺ｮ繧ｱ繝ｼ繧ｹ縺ｧ縺ｯ縲√帙せ繝亥ｴ繝輔ぃ繧､繝ｫ蜷阪ｮ髟ｷ縺輔ｯ繝舌ャ繝輔ぃ譛螟ｧ髟ｷ縺ｫ +/// 豈斐∋縺ｦ髱槫ｸｸ縺ｫ遏ｭ縺縲ゅ＆繧峨↓繝輔ぃ繧､繝ｫ蜷阪ｯ螟ｧ驥上↓逕滓舌＆繧後ｋ蜿ｯ閭ｽ諤ｧ縺後≠繧九 +/// 縺昴ｮ縺溘ａ譁蟄玲焚縺ｫ蠢懊§縺溷庄螟蛾聞縺ｧ遒ｺ菫昴☆繧九 +// +//--------------------------------------------------------------------------- +CHostPath::ring_t* CHostPath::Alloc(size_t nLength) // static +{ + ASSERT(nLength < FILEPATH_MAX); + + size_t n = offsetof(ring_t, f) + CHostFilename::Offset() + (nLength + 1) * sizeof(TCHAR); + ring_t* p = (ring_t*)malloc(n); + ASSERT(p); + + p->r.Init(); // 讎帛錐縺ｯ螟ｧ荳亥､ｫ縺ｧ縺呻ｼ + + return p; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ蜷埼伜沺隗｣謾ｾ +// +//--------------------------------------------------------------------------- +void CHostPath::Free(ring_t* pRing) // static +{ + ASSERT(pRing); + + pRing->~ring_t(); + free(pRing); +} + +//--------------------------------------------------------------------------- +// +/// 蜀榊茜逕ｨ縺ｮ縺溘ａ縺ｮ蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +void CHostPath::Clean() +{ + ASSERT(this); + + Release(); + + // 蜈ｨ繝輔ぃ繧､繝ｫ蜷阪ｒ隗｣謾ｾ + ring_t* p; + while ((p = (ring_t*)m_cRing.Next()) != (ring_t*)&m_cRing) { + Free(p); + } +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧堤峩謗･謖螳壹☆繧 +// +//--------------------------------------------------------------------------- +void CHostPath::SetHuman(const BYTE* szHuman) +{ + ASSERT(this); + ASSERT(szHuman); + ASSERT(strlen((const char*)szHuman) < HUMAN68K_PATH_MAX); + + strcpy((char*)m_szHuman, (const char*)szHuman); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧堤峩謗･謖螳壹☆繧 +// +//--------------------------------------------------------------------------- +void CHostPath::SetHost(const TCHAR* szHost) +{ + ASSERT(this); + ASSERT(szHost); + ASSERT(strlen(szHost) < FILEPATH_MAX); + + strcpy(m_szHost, szHost); +} + +//--------------------------------------------------------------------------- +// +/// 譁蟄怜玲ｯ碑ｼ (繝ｯ繧､繝ｫ繝峨き繝ｼ繝牙ｯｾ蠢) +// +//--------------------------------------------------------------------------- +int CHostPath::Compare(const BYTE* pFirst, const BYTE* pLast, const BYTE* pBufFirst, const BYTE* pBufLast) +{ + ASSERT(pFirst); + ASSERT(pLast); + ASSERT(pBufFirst); + ASSERT(pBufLast); + + // 譁蟄玲ｯ碑ｼ + BOOL bSkip0 = FALSE; + BOOL bSkip1 = FALSE; + for (const BYTE* p = pFirst; p < pLast; p++) { + // 1譁蟄苓ｪｭ縺ｿ霎ｼ縺ｿ + BYTE c = *p; + BYTE d = '\0'; + if (pBufFirst < pBufLast) + d = *pBufFirst++; + + // 豈碑ｼ縺ｮ縺溘ａ縺ｮ譁蟄苓｣懈ｭ｣ + if (bSkip0 == FALSE) { + if (bSkip1 == FALSE) { // c繧Ｅ繧1繝舌う繝育岼 + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + bSkip0 = TRUE; + } + if ((0x80 <= d && d <= 0x9F) || 0xE0 <= d) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + bSkip1 = TRUE; + } + if (c == d) + continue; // 鬮倡｢ｺ邇縺ｧ蛻､螳壼ｮ御ｺ縺吶ｋ + if ((CFileSys::GetFileOption() & WINDRV_OPT_ALPHABET) == 0) { + if ('A' <= c && c <= 'Z') + c += 'a' - 'A'; // 蟆乗枚蟄怜喧 + if ('A' <= d && d <= 'Z') + d += 'a' - 'A'; // 蟆乗枚蟄怜喧 + } + } else { // c縺縺代′1繝舌う繝育岼 + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + bSkip0 = TRUE; + } + bSkip1 = FALSE; + } + } else { + if (bSkip1 == FALSE) { // d縺縺代′1繝舌う繝育岼 + bSkip0 = FALSE; + if ((0x80 <= d && d <= 0x9F) || 0xE0 <= d) { // 蜴ｳ蟇縺ｫ縺ｯ 0x81ｽ0x9F 0xE0ｽ0xEF + bSkip1 = TRUE; + } + } else { // c繧Ｅ繧2繝舌う繝育岼 + bSkip0 = FALSE; + bSkip1 = FALSE; + } + } + + // 豈碑ｼ + if (c == d) + continue; + if (c == '?') + continue; + return 1; + } + if (pBufFirst < pBufLast) + return 2; + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧呈ｯ碑ｼ縺吶ｋ +// +//--------------------------------------------------------------------------- +BOOL CHostPath::isSameHuman(const BYTE* szHuman) const +{ + ASSERT(this); + ASSERT(szHuman); + + // 譁蟄玲焚險育ｮ + size_t nLength = strlen((const char*)m_szHuman); + size_t n = strlen((const char*)szHuman); + + // 譁蟄玲焚繝√ぉ繝繧ｯ + if (nLength != n) + return FALSE; + + // Human68k繝代せ蜷阪ｮ豈碑ｼ + return Compare(m_szHuman, m_szHuman + nLength, szHuman, szHuman + n) == 0; +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧呈ｯ碑ｼ縺吶ｋ +// +//--------------------------------------------------------------------------- +BOOL CHostPath::isSameChild(const BYTE* szHuman) const +{ + ASSERT(this); + ASSERT(szHuman); + + // 譁蟄玲焚險育ｮ + size_t nLength = strlen((const char*)m_szHuman); + size_t n = strlen((const char*)szHuman); + + // 譁蟄玲焚繝√ぉ繝繧ｯ + if (nLength < n) + return FALSE; + + // Human68k繝代せ蜷阪ｮ豈碑ｼ + return Compare(m_szHuman, m_szHuman + n, szHuman, szHuman + n) == 0; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷阪ｒ讀懃ｴ｢ +/// +/// 謇譛峨☆繧九く繝｣繧ｷ繝･繝舌ャ繝輔ぃ縺ｮ荳ｭ縺九ｉ讀懃ｴ｢縺励∬ｦ九▽縺九ｌ縺ｰ縺昴ｮ蜷咲ｧｰ繧定ｿ斐☆縲 +/// 繝代せ蜷阪ｒ髯､螟悶＠縺ｦ縺翫￥縺薙→縲 +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +// +//--------------------------------------------------------------------------- +const CHostFilename* CHostPath::FindFilename(const BYTE* szHuman, DWORD nHumanAttribute) const +{ + ASSERT(this); + ASSERT(szHuman); + + // 譁蟄玲焚險育ｮ + const BYTE* pFirst = szHuman; + size_t nLength = strlen((const char*)pFirst); + const BYTE* pLast = pFirst + nLength; + + // 謇謖√＠縺ｦ縺繧句ｨ縺ｦ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｮ荳ｭ縺九ｉ螳悟ｨ荳閾ｴ縺吶ｋ繧ゅｮ繧呈､懃ｴ｢ + const ring_t* p = (ring_t*)m_cRing.Next(); + for (; p != (ring_t*)&m_cRing; p = (ring_t*)p->r.Next()) { + // 螻樊ｧ繝√ぉ繝繧ｯ + if (p->f.CheckAttribute(nHumanAttribute) == 0) + continue; + // 譁蟄玲焚險育ｮ + const BYTE* pBufFirst = p->f.GetHuman(); + const BYTE* pBufLast = p->f.GetHumanLast(); + size_t nBufLength = pBufLast - pBufFirst; + // 譁蟄玲焚繝√ぉ繝繧ｯ + if (nLength != nBufLength) + continue; + // 繝輔ぃ繧､繝ｫ蜷阪メ繧ｧ繝繧ｯ + if (Compare(pFirst, pLast, pBufFirst, pBufLast) == 0) + return &p->f; + } + + return NULL; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷阪ｒ讀懃ｴ｢ (繝ｯ繧､繝ｫ繝峨き繝ｼ繝牙ｯｾ蠢) +/// +/// 謇譛峨☆繧九ヰ繝繝輔ぃ縺ｮ荳ｭ縺九ｉ讀懃ｴ｢縺励∬ｦ九▽縺九ｌ縺ｰ縺昴ｮ蜷咲ｧｰ繧定ｿ斐☆縲 +/// 繝代せ蜷阪ｒ髯､螟悶＠縺ｦ縺翫￥縺薙→縲 +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +// +//--------------------------------------------------------------------------- +const CHostFilename* CHostPath::FindFilenameWildcard(const BYTE* szHuman, DWORD nHumanAttribute, find_t* pFind) const +{ + ASSERT(this); + ASSERT(szHuman); + ASSERT(pFind); + + // 讀懃ｴ｢繝輔ぃ繧､繝ｫ蜷阪ｒ譛ｬ菴薙→Human68k諡｡蠑ｵ蟄舌↓蛻縺代ｋ + const BYTE* pFirst = szHuman; + const BYTE* pLast = pFirst + strlen((const char*)pFirst); + const BYTE* pExt = CHostFilename::SeparateExt(pFirst); + + // 髢句ｧ句慍轤ｹ縺ｸ遘ｻ蜍 + const ring_t* p = (ring_t*)m_cRing.Next(); + if (pFind->count > 0) { + if (pFind->id == m_nId) { + // 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺悟酔荳縺ｪ繧峨∝燕蝗槭ｮ菴咲ｽｮ縺九ｉ蜊ｳ邯咏ｶ + p = pFind->pos; + } else { + // 髢句ｧ句慍轤ｹ繧偵ョ繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ蜀螳ｹ縺九ｉ讀懃ｴ｢縺吶ｋ + DWORD n = 0; + for (;; p = (ring_t*)p->r.Next()) { + if (p == (ring_t*)&m_cRing) { + // 蜷御ｸ繧ｨ繝ｳ繝医Μ縺瑚ｦ九▽縺九ｉ縺ｪ縺九▲縺溷ｴ蜷医∝屓謨ｰ縺九ｉ謗ｨ螳 (蠢ｵ縺ｮ縺溘ａ) + p = (ring_t*)m_cRing.Next(); + n = 0; + for (; p != (ring_t*)&m_cRing; p = (ring_t*)p->r.Next()) { + if (n >= pFind->count) + break; + n++; + } + break; + } + if (p->f.isSameEntry(&pFind->entry)) { + // 蜷御ｸ繧ｨ繝ｳ繝医Μ繧堤匱隕 + pFind->count = n; + break; + } + n++; + } + } + } + + // 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + for (; p != (ring_t*)&m_cRing; p = (ring_t*)p->r.Next()) { + pFind->count++; + + // 螻樊ｧ繝√ぉ繝繧ｯ + if (p->f.CheckAttribute(nHumanAttribute) == 0) + continue; + + // 繝輔ぃ繧､繝ｫ蜷阪ｒ譛ｬ菴薙→Human68k諡｡蠑ｵ蟄舌↓蛻縺代ｋ + const BYTE* pBufFirst = p->f.GetHuman(); + const BYTE* pBufLast = p->f.GetHumanLast(); + const BYTE* pBufExt = p->f.GetHumanExt(); + + // 譛ｬ菴捺ｯ碑ｼ + if (Compare(pFirst, pExt, pBufFirst, pBufExt)) + continue; + + // Human68k諡｡蠑ｵ蟄先ｯ碑ｼ + // 諡｡蠑ｵ蟄.???縺ｮ蝣ｴ蜷医ｯ縲？uman68k諡｡蠑ｵ蟄舌ｮ繝斐Μ繧ｪ繝峨↑縺励↓繧ゅ槭ャ繝√＆縺帙ｋ + if (strcmp((const char*)pExt, ".???") == 0 || + Compare(pExt, pLast, pBufExt, pBufLast) == 0) { + // 谺｡縺ｮ蛟呵｣懊ｮ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ蜀螳ｹ繧定ｨ倬鹸 + const ring_t* pNext = (ring_t*)p->r.Next(); + pFind->id = m_nId; + pFind->pos = pNext; + if (pNext != (ring_t*)&m_cRing) + memcpy(&pFind->entry, pNext->f.GetEntry(), sizeof(pFind->entry)); + else + memset(&pFind->entry, 0, sizeof(pFind->entry)); + return &p->f; + } + } + + pFind->id = m_nId; + pFind->pos = p; + memset(&pFind->entry, 0, sizeof(pFind->entry)); + return NULL; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ螟画峩縺瑚｡後↑繧上ｌ縺溘°遒ｺ隱 +// +//--------------------------------------------------------------------------- +BOOL CHostPath::isRefresh() +{ + ASSERT(this); + + return m_bRefresh; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜀肴ｧ区 +/// +/// 縺薙％縺ｧ蛻昴ａ縺ｦ縲√帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ隕ｳ貂ｬ縺瑚｡後↑繧上ｌ繧九 +/// 蠢縺壻ｸ贋ｽ阪〒謗剃ｻ門宛蠕｡繧定｡後↑縺縺薙→縲 +// +//--------------------------------------------------------------------------- +void CHostPath::Refresh() +{ + ASSERT(this); + ASSERT(strlen(m_szHost) + 22 < FILEPATH_MAX); + + // 繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝嶺ｿ晏ｭ + Backup(); + + TCHAR szPath[FILEPATH_MAX]; + strcpy(szPath, m_szHost); + + // 譖ｴ譁ｰ繝輔Λ繧ｰ螟画峩 + m_bRefresh = FALSE; + + // 莉･蜑阪ｮ繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ繧剃ｿ晏ｭ + CRing cRingBackup; + m_cRing.InsertRing(&cRingBackup); + + // 繝輔ぃ繧､繝ｫ蜷咲匳骭ｲ + /// @todo 繝輔ぃ繧､繝ｫ驥崎､蜃ｦ逅繧偵帙せ繝亥ｴAPI繧堤ｵ檎罰縺帙★縺ｫ蜈ｨ縺ｦ閾ｪ蜑阪〒蜃ｦ逅縺吶ｋ縲 + BOOL bUpdate = FALSE; + DIR* pd = NULL; + for (DWORD i = 0; i < XM6_HOST_DIRENTRY_FILE_MAX; i++) { + TCHAR szFilename[FILEPATH_MAX]; + if (pd == NULL) { + pd = opendir(S2U(szPath)); + if (pd == NULL) + break; + } + // 繝輔ぃ繧､繝ｫ蜷阪ｒ迯ｲ蠕 + struct dirent* pe = readdir(pd); + if (pe == NULL) + break; + strcpy(szFilename, U2S(pe->d_name)); + + // 繝輔ぃ繧､繝ｫ蜷埼伜沺遒ｺ菫 + ring_t* pRing = Alloc(strlen(szFilename)); + CHostFilename* pFilename = &pRing->f; + pFilename->SetHost(szFilename); + + // 莉･蜑阪ｮ繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ縺ｫ隧ｲ蠖薙☆繧九ヵ繧｡繧､繝ｫ蜷阪′縺ゅｌ縺ｰ縺昴ｮHuman68k蜷咲ｧｰ繧貞━蜈医☆繧 + ring_t* pCache = (ring_t*)cRingBackup.Next(); + for (;;) { + if (pCache == (ring_t*)&cRingBackup) { + pCache = NULL; // 隧ｲ蠖薙☆繧九お繝ｳ繝医Μ縺ｪ縺 + bUpdate = TRUE; // 譁ｰ隕上お繝ｳ繝医Μ縺ｨ遒ｺ螳 + pFilename->ConvertHuman(); + break; + } + if (strcmp(pFilename->GetHost(), pCache->f.GetHost()) == 0) { + pFilename->CopyHuman(pCache->f.GetHuman()); // Human68k蜷咲ｧｰ縺ｮ繧ｳ繝斐ｼ + break; + } + pCache = (ring_t*)pCache->r.Next(); + } + + // 譁ｰ隕上お繝ｳ繝医Μ縺ｮ蝣ｴ蜷医ｯ繝輔ぃ繧､繝ｫ蜷埼崎､繧偵メ繧ｧ繝繧ｯ縺吶ｋ + // 繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪°繧牙､画峩縺後≠縺｣縺溘°縲？uman68k縺ｧ陦ｨ迴ｾ縺ｧ縺阪↑縺繝輔ぃ繧､繝ｫ蜷阪ｮ蝣ｴ蜷医ｯ + // 莉･荳九ｮ繝√ぉ繝繧ｯ繧貞ｨ縺ｦ繝代せ縺吶ｋ繝輔ぃ繧､繝ｫ蜷阪ｒ譁ｰ縺溘↓逕滓舌☆繧 + // 繝ｻ豁｣縺励＞繝輔ぃ繧､繝ｫ蜷阪〒縺ゅｋ縺薙→ + // 繝ｻ驕主悉縺ｮ繧ｨ繝ｳ繝医Μ縺ｫ蜷悟錐縺ｮ繧ゅｮ縺悟ｭ伜惠縺励↑縺縺薙→ + // 繝ｻ蜷悟錐縺ｮ螳溘ヵ繧｡繧､繝ｫ蜷阪′蟄伜惠縺励↑縺縺薙→ + if (pFilename->isReduce() || !pFilename->isCorrect()) { // 繝輔ぃ繧､繝ｫ蜷榊､画峩縺悟ｿ隕√°遒ｺ隱 + for (DWORD n = 0; n < XM6_HOST_FILENAME_PATTERN_MAX; n++) { + // 豁｣縺励＞繝輔ぃ繧､繝ｫ蜷阪°縺ｩ縺縺狗｢ｺ隱 + if (pFilename->isCorrect()) { + // 驕主悉縺ｮ繧ｨ繝ｳ繝医Μ縺ｨ荳閾ｴ縺吶ｋ縺狗｢ｺ隱 + const CHostFilename* pCheck = FindFilename(pFilename->GetHuman()); + if (pCheck == NULL) { + // 荳閾ｴ縺吶ｋ繧ゅｮ縺後↑縺代ｌ縺ｰ縲∝ｮ溘ヵ繧｡繧､繝ｫ縺悟ｭ伜惠縺吶ｋ縺狗｢ｺ隱 + strcpy(szPath, m_szHost); + strcat(szPath, (const char*)pFilename->GetHuman()); /// @warning Unicode譎りｦ∽ｿｮ豁｣ 竊 貂 + struct stat sb; + if (stat(S2U(szPath), &sb)) + break; // 蛻ｩ逕ｨ蜿ｯ閭ｽ繝代ち繝ｼ繝ｳ繧堤匱隕 + } + } + // 譁ｰ縺励＞蜷榊燕繧堤函謌 + pFilename->ConvertHuman(n); + } + } + + // 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ蜷咲ｧｰ + pFilename->SetEntryName(); + + // 諠蝣ｱ蜿門ｾ + strcpy(szPath, m_szHost); + strcat(szPath, U2S(pe->d_name)); + + struct stat sb; + if (stat(S2U(szPath), &sb)) + continue; + + // 螻樊ｧ + BYTE nHumanAttribute = Human68k::AT_ARCHIVE; + if (S_ISDIR(sb.st_mode)) + nHumanAttribute = Human68k::AT_DIRECTORY; + if ((sb.st_mode & 0200) == 0) + nHumanAttribute |= Human68k::AT_READONLY; + pFilename->SetEntryAttribute(nHumanAttribute); + + // 繧ｵ繧､繧ｺ + DWORD nHumanSize = (DWORD)sb.st_size; + pFilename->SetEntrySize(nHumanSize); + + // 譌･莉俶凾蛻ｻ + WORD nHumanDate = 0; + WORD nHumanTime = 0; + struct tm* pt = localtime(&sb.st_mtime); + if (pt) { + nHumanDate = (WORD)(((pt->tm_year - 80) << 9) | ((pt->tm_mon + 1) << 5) | pt->tm_mday); + nHumanTime = (WORD)((pt->tm_hour << 11) | (pt->tm_min << 5) | (pt->tm_sec >> 1)); + } + pFilename->SetEntryDate(nHumanDate); + pFilename->SetEntryTime(nHumanTime); + + // 繧ｯ繝ｩ繧ｹ繧ｿ逡ｪ蜿ｷ險ｭ螳 + pFilename->SetEntryCluster(0); + + // 莉･蜑阪ｮ繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ縺ｨ豈碑ｼ + if (pCache) { + if (pCache->f.isSameEntry(pFilename->GetEntry())) { + Free(pRing); // 莉雁屓菴懈舌＠縺溘お繝ｳ繝医Μ縺ｯ遐ｴ譽縺 + pRing = pCache; // 莉･蜑阪ｮ繧ｭ繝｣繝繧ｷ繝･蜀螳ｹ繧剃ｽｿ縺 + } else { + Free(pCache); // 谺｡蝗槭ｮ讀懃ｴ｢蟇ｾ雎｡縺九ｉ髯､螟 + bUpdate = TRUE; // 荳閾ｴ縺励↑縺代ｌ縺ｰ譖ｴ譁ｰ縺ゅｊ + } + } + + // 繝ｪ繝ｳ繧ｰ譛ｫ蟆ｾ縺ｸ霑ｽ蜉 + pRing->r.InsertTail(&m_cRing); + } + + closedir(pd); + + // 谿句ｭ倥☆繧九く繝｣繝繧ｷ繝･蜀螳ｹ繧貞炎髯､ + ring_t* p; + while ((p = (ring_t*)cRingBackup.Next()) != (ring_t*)&cRingBackup) { + bUpdate = TRUE; // 蜑企勁縺ｫ繧医▲縺ｦ繧ｨ繝ｳ繝医Μ謨ｰ縺ｮ貂帛ｰ代′蛻､譏 + Free(p); + } + + // 譖ｴ譁ｰ縺瑚｡後↑繧上ｌ縺溘ｉ隴伜挨ID繧貞､画峩 + if (bUpdate) + m_nId = ++g_nId; + // ASSERT(m_nId); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｒ菫晏ｭ +// +//--------------------------------------------------------------------------- +void CHostPath::Backup() +{ + ASSERT(this); + ASSERT(m_szHost); + ASSERT(strlen(m_szHost) < FILEPATH_MAX); + + TCHAR szPath[FILEPATH_MAX]; + strcpy(szPath, m_szHost); + size_t len = strlen(szPath); + + m_tBackup = 0; + if (len > 1) { // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医ｯ菴輔ｂ縺励↑縺 + len--; + ASSERT(szPath[len] == _T('/')); + szPath[len] = _T('\0'); + struct stat sb; + if (stat(S2U(szPath), &sb) == 0) + m_tBackup = sb.st_mtime; + } +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｒ蠕ｩ蜈 +// +//--------------------------------------------------------------------------- +void CHostPath::Restore() const +{ + ASSERT(this); + ASSERT(m_szHost); + ASSERT(strlen(m_szHost) < FILEPATH_MAX); + + TCHAR szPath[FILEPATH_MAX]; + strcpy(szPath, m_szHost); + size_t len = strlen(szPath); + + if (m_tBackup) { + ASSERT(len); + len--; + ASSERT(szPath[len] == _T('/')); + szPath[len] = _T('\0'); + + struct utimbuf ut; + ut.actime = m_tBackup; + ut.modtime = m_tBackup; + utime(szPath, &ut); + } +} + +//--------------------------------------------------------------------------- +// +/// 譖ｴ譁ｰ +// +//--------------------------------------------------------------------------- +void CHostPath::Release() +{ + ASSERT(this); + + m_bRefresh = TRUE; +} + +//=========================================================================== +// +// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ邂｡逅 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +/// 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CHostEntry::CHostEntry() +{ + for (size_t n = 0; n < DriveMax; n++) { + m_pDrv[n] = NULL; + } + + m_nTimeout = 0; +} + +//--------------------------------------------------------------------------- +// +/// 繝繧ｹ繝医Λ繧ｯ繧ｿ final +// +//--------------------------------------------------------------------------- +CHostEntry::~CHostEntry() +{ + Clean(); + +#ifdef _DEBUG + // 繧ｪ繝悶ず繧ｧ繧ｯ繝育｢ｺ隱 + for (size_t n = 0; n < DriveMax; n++) { + ASSERT(m_pDrv[n] == NULL); + } +#endif // _DEBUG +} + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) +// +//--------------------------------------------------------------------------- +void CHostEntry::Init() +{ + ASSERT(this); + +#ifdef _DEBUG + // 繧ｪ繝悶ず繧ｧ繧ｯ繝育｢ｺ隱 + for (size_t n = 0; n < DriveMax; n++) { + ASSERT(m_pDrv[n] == NULL); + } +#endif // _DEBUG +} + +//--------------------------------------------------------------------------- +// +/// 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) +// +//--------------------------------------------------------------------------- +void CHostEntry::Clean() +{ + ASSERT(this); + + // 繧ｪ繝悶ず繧ｧ繧ｯ繝亥炎髯､ + for (size_t n = 0; n < DriveMax; n++) { + delete m_pDrv[n]; + m_pDrv[n] = NULL; + } +} + +//--------------------------------------------------------------------------- +// +/// 蜈ｨ縺ｦ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostEntry::CleanCache() +{ + ASSERT(this); + + for (size_t i = 0; i < DriveMax; i++) { + if (m_pDrv[i]) + m_pDrv[i]->CleanCache(); + } + + CHostPath::InitId(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝ｦ繝九ャ繝医ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostEntry::CleanCache(DWORD nUnit) +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + m_pDrv[nUnit]->CleanCache(); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostEntry::CleanCache(DWORD nUnit, const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + m_pDrv[nUnit]->CleanCache(szHumanPath); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ莉･荳九ｮ繧ｭ繝｣繝繧ｷ繝･繧貞ｨ縺ｦ譖ｴ譁ｰ縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostEntry::CleanCacheChild(DWORD nUnit, const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + m_pDrv[nUnit]->CleanCacheChild(szHumanPath); +} + +//--------------------------------------------------------------------------- +// +/// 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､縺吶ｋ +// +//--------------------------------------------------------------------------- +void CHostEntry::DeleteCache(DWORD nUnit, const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + m_pDrv[nUnit]->DeleteCache(szHumanPath); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧呈､懃ｴ｢ (繝代せ蜷+繝輔ぃ繧､繝ｫ蜷(逵∫払蜿ｯ)+螻樊ｧ) +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::Find(DWORD nUnit, CHostFiles* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->Find(pFiles); +} + +void CHostEntry::ShellNotify(DWORD, const TCHAR*) {} + +//--------------------------------------------------------------------------- +// +/// 繝峨Λ繧､繝冶ｨｭ螳 +// +//--------------------------------------------------------------------------- +void CHostEntry::SetDrv(DWORD nUnit, CHostDrv* pDrv) +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit] == NULL); + + m_pDrv[nUnit] = pDrv; +} + +//--------------------------------------------------------------------------- +// +/// 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺具ｼ +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::isWriteProtect(DWORD nUnit) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->isWriteProtect(); +} + +//--------------------------------------------------------------------------- +// +/// 繧｢繧ｯ繧ｻ繧ｹ蜿ｯ閭ｽ縺具ｼ +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::isEnable(DWORD nUnit) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->isEnable(); +} + +//--------------------------------------------------------------------------- +// +/// 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::isMediaOffline(DWORD nUnit) +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->isMediaOffline(); +} + +//--------------------------------------------------------------------------- +// +/// 繝｡繝繧｣繧｢繝舌う繝医ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +BYTE CHostEntry::GetMediaByte(DWORD nUnit) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->GetMediaByte(); +} + +//--------------------------------------------------------------------------- +// +/// 繝峨Λ繧､繝也憾諷九ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD CHostEntry::GetStatus(DWORD nUnit) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->GetStatus(); +} + +//--------------------------------------------------------------------------- +// +/// 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +void CHostEntry::GetVolume(DWORD nUnit, TCHAR* szLabel) +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + m_pDrv[nUnit]->GetVolume(szLabel); +} + +//--------------------------------------------------------------------------- +// +/// 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν繧貞叙蠕 +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::GetVolumeCache(DWORD nUnit, TCHAR* szLabel) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->GetVolumeCache(szLabel); +} + +//--------------------------------------------------------------------------- +// +/// 螳ｹ驥上ｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD CHostEntry::GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity) +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->GetCapacity(pCapacity); +} + +//--------------------------------------------------------------------------- +// +/// 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繧ｯ繝ｩ繧ｹ繧ｿ繧ｵ繧､繧ｺ繧貞叙蠕 +// +//--------------------------------------------------------------------------- +BOOL CHostEntry::GetCapacityCache(DWORD nUnit, Human68k::capacity_t* pCapacity) const +{ + ASSERT(this); + ASSERT(nUnit < DriveMax); + ASSERT(m_pDrv[nUnit]); + + return m_pDrv[nUnit]->GetCapacityCache(pCapacity); +} + +//--------------------------------------------------------------------------- +// +/// Human68k繝輔Ν繝代せ蜷阪°繧牙磯ｭ縺ｮ隕∫ｴ繧貞髮｢繝ｻ繧ｳ繝斐ｼ +/// +/// Human68k繝輔Ν繝代せ蜷阪ｮ蜈磯ｭ縺ｮ隕∫ｴ繧偵ヱ繧ｹ蛹ｺ蛻繧頑枚蟄励ｒ髯､螟悶＠縺ｦ蜿門ｾ励☆繧九 +/// 譖ｸ縺崎ｾｼ縺ｿ蜈医ヰ繝繝輔ぃ縺ｯ23繝舌う繝亥ｿ隕√ +/// Human68k繝代せ縺ｯ蠢縺/縺ｧ髢句ｧ九☆繧九％縺ｨ縲 +/// 騾比ｸｭ/縺2縺､莉･荳企｣邯壹＠縺ｦ蜃ｺ迴ｾ縺励◆蝣ｴ蜷医ｯ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ縲 +/// 譁蟄怜礼ｵらｫｯ縺/縺縺代ｮ蝣ｴ蜷医ｯ遨ｺ縺ｮ譁蟄怜励→縺励※蜃ｦ逅縺励√お繝ｩ繝ｼ縺ｫ縺ｯ縺励↑縺縲 +// +//--------------------------------------------------------------------------- +const BYTE* CHostDrv::SeparateCopyFilename(const BYTE* szHuman, BYTE* szBuffer) // static +{ + ASSERT(szHuman); + ASSERT(szBuffer); + + const size_t nMax = 22; + const BYTE* p = szHuman; + + BYTE c = *p++; // 隱ｭ縺ｿ霎ｼ縺ｿ + if (c != '/' && c != '\\') + return NULL; // 繧ｨ繝ｩ繝ｼ: 荳肴ｭ｣縺ｪ繝代せ蜷 + + // 繝輔ぃ繧､繝ｫ縺縺｣縺薙＞繧後ｋ + size_t i = 0; + for (;;) { + c = *p; // 隱ｭ縺ｿ霎ｼ縺ｿ + if (c == '\0') + break; // 譁蟄怜礼ｵらｫｯ縺ｪ繧臥ｵゆｺ (邨らｫｯ菴咲ｽｮ繧定ｿ斐☆) + if (c == '/' || c == '\\') { + if (i == 0) + return NULL; // 繧ｨ繝ｩ繝ｼ: 繝代せ蛹ｺ蛻繧頑枚蟄励′騾｣邯壹＠縺ｦ縺繧 + break; // 繝代せ縺ｮ蛹ｺ蛻繧翫ｒ隱ｭ繧薙□繧臥ｵゆｺ (譁蟄励ｮ菴咲ｽｮ繧定ｿ斐☆) + } + p++; + + if (i >= nMax) + return NULL; // 繧ｨ繝ｩ繝ｼ: 1繝舌う繝育岼縺後ヰ繝繝輔ぃ邨らｫｯ縺ｫ縺九°繧 + szBuffer[i++] = c; // 譖ｸ縺崎ｾｼ縺ｿ + + if ((0x80 <= c && c <= 0x9F) || 0xE0 <= c) { // 蜴ｳ蟇縺ｫ縺ｯ0x81ｽ0x9F縺ｨ0xE0ｽ0xEF + c = *p++; // 隱ｭ縺ｿ霎ｼ縺ｿ + if (c < 0x40) + return NULL; // 繧ｨ繝ｩ繝ｼ: 荳肴ｭ｣縺ｪSJIS2繝舌う繝育岼 + + if (i >= nMax) + return NULL; // 繧ｨ繝ｩ繝ｼ: 2繝舌う繝育岼縺後ヰ繝繝輔ぃ邨らｫｯ縺ｫ縺九°繧 + szBuffer[i++] = c; // 譖ｸ縺崎ｾｼ縺ｿ + } + } + szBuffer[i] = '\0'; // 譖ｸ縺崎ｾｼ縺ｿ + + return p; +} + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫ讀懃ｴ｢蜃ｦ逅 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +void CHostFiles::Init() +{ + ASSERT(this); +} + +//--------------------------------------------------------------------------- +// +/// 繝代せ蜷阪ｻ繝輔ぃ繧､繝ｫ蜷阪ｒ蜀驛ｨ縺ｧ逕滓 +// +//--------------------------------------------------------------------------- +void CHostFiles::SetPath(const Human68k::namests_t* pNamests) +{ + ASSERT(this); + ASSERT(pNamests); + + pNamests->GetCopyPath(m_szHumanPath); + pNamests->GetCopyFilename(m_szHumanFilename); + m_nHumanWildcard = 0; + m_nHumanAttribute = Human68k::AT_ARCHIVE; + m_findNext.Clear(); +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｧ繝輔ぃ繧､繝ｫ繧呈､懃ｴ｢縺励帙せ繝亥ｴ縺ｮ諠蝣ｱ繧堤函謌 +// +//--------------------------------------------------------------------------- +BOOL CHostFiles::Find(DWORD nUnit, CHostEntry* pEntry) +{ + ASSERT(this); + ASSERT(pEntry); + + return pEntry->Find(nUnit, this); +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷肴､懃ｴ｢ +// +//--------------------------------------------------------------------------- +const CHostFilename* CHostFiles::Find(CHostPath* pPath) +{ + ASSERT(this); + ASSERT(pPath); + + if (m_nHumanWildcard) + return pPath->FindFilenameWildcard(m_szHumanFilename, m_nHumanAttribute, &m_findNext); + + return pPath->FindFilename(m_szHumanFilename, m_nHumanAttribute); +} + +//--------------------------------------------------------------------------- +// +/// Human68k蛛ｴ縺ｮ讀懃ｴ｢邨先棡菫晏ｭ +// +//--------------------------------------------------------------------------- +void CHostFiles::SetEntry(const CHostFilename* pFilename) +{ + ASSERT(this); + ASSERT(pFilename); + + // Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ菫晏ｭ + memcpy(&m_dirHuman, pFilename->GetEntry(), sizeof(m_dirHuman)); + + // Human68k繝輔ぃ繧､繝ｫ蜷堺ｿ晏ｭ + strcpy((char*)m_szHumanResult, (const char*)pFilename->GetHuman()); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧定ｨｭ螳 +// +//--------------------------------------------------------------------------- +void CHostFiles::SetResult(const TCHAR* szPath) +{ + ASSERT(this); + ASSERT(szPath); + ASSERT(strlen(szPath) < FILEPATH_MAX); + + strcpy(m_szHostResult, szPath); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｫ繝輔ぃ繧､繝ｫ蜷阪ｒ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +void CHostFiles::AddResult(const TCHAR* szPath) +{ + ASSERT(this); + ASSERT(szPath); + ASSERT(strlen(m_szHostResult) + strlen(szPath) < FILEPATH_MAX); + + strcat(m_szHostResult, szPath); +} + +//--------------------------------------------------------------------------- +// +/// 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｫHuman68k縺ｮ譁ｰ隕上ヵ繧｡繧､繝ｫ蜷阪ｒ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +void CHostFiles::AddFilename() +{ + ASSERT(this); + ASSERT(strlen(m_szHostResult) + strlen((const char*)m_szHumanFilename) < FILEPATH_MAX); + + /// @warning Unicode譛ｪ蟇ｾ蠢懊ゅ＞縺壹ｌUnicode縺ｮ荳也阜縺ｫ鬟ｮ縺ｾ繧後◆譎ゅｯ縺薙％縺ｧ螟画鋤繧定｡後↑縺 竊 貂 + strcat(m_szHostResult, (const char*)m_szHumanFilename); +} + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫ讀懃ｴ｢鬆伜沺 繝槭ロ繝ｼ繧ｸ繝｣ +// +//=========================================================================== + +#ifdef _DEBUG +//--------------------------------------------------------------------------- +// +/// 繝繧ｹ繝医Λ繧ｯ繧ｿ final +// +//--------------------------------------------------------------------------- +CHostFilesManager::~CHostFilesManager() +{ + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); +} +#endif // _DEBUG + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) +// +//--------------------------------------------------------------------------- +void CHostFilesManager::Init() +{ + ASSERT(this); + + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); + + // 繝｡繝｢繝ｪ遒ｺ菫 + for (DWORD i = 0; i < XM6_HOST_FILES_MAX; i++) { + ring_t* p = new ring_t; + ASSERT(p); + p->r.Insert(&m_cRing); + } +} + +//--------------------------------------------------------------------------- +// +/// 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) +// +//--------------------------------------------------------------------------- +void CHostFilesManager::Clean() +{ + ASSERT(this); + + // 繝｡繝｢繝ｪ隗｣謾ｾ + CRing* p; + while ((p = m_cRing.Next()) != &m_cRing) { + delete (ring_t*)p; + } +} + +//--------------------------------------------------------------------------- +// +/// 遒ｺ菫 +// +//--------------------------------------------------------------------------- +CHostFiles* CHostFilesManager::Alloc(DWORD nKey) +{ + ASSERT(this); + ASSERT(nKey); + + // 譛ｫ蟆ｾ縺九ｉ驕ｸ謚 + ring_t* p = (ring_t*)m_cRing.Prev(); + + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ遘ｻ蜍 + p->r.Insert(&m_cRing); + + // 繧ｭ繝ｼ繧定ｨｭ螳 + p->f.SetKey(nKey); + + return &p->f; +} + +//--------------------------------------------------------------------------- +// +/// 讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +CHostFiles* CHostFilesManager::Search(DWORD nKey) +{ + ASSERT(this); + // ASSERT(nKey); // DPB遐ｴ謳阪↓繧医ｊ讀懃ｴ｢繧ｭ繝ｼ縺0縺ｫ縺ｪ繧九％縺ｨ繧ゅ≠繧 + + // 隧ｲ蠖薙☆繧九が繝悶ず繧ｧ繧ｯ繝医ｒ讀懃ｴ｢ + ring_t* p = (ring_t*)m_cRing.Next(); + for (; p != (ring_t*)&m_cRing; p = (ring_t*)p->r.Next()) { + if (p->f.isSameKey(nKey)) { + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ遘ｻ蜍 + p->r.Insert(&m_cRing); + return &p->f; + } + } + + return NULL; +} + +//--------------------------------------------------------------------------- +// +/// 隗｣謾ｾ +// +//--------------------------------------------------------------------------- +void CHostFilesManager::Free(CHostFiles* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + + // 隗｣謾ｾ + pFiles->SetKey(0); + pFiles->Init(); + + // 繝ｪ繝ｳ繧ｰ譛ｫ蟆ｾ縺ｸ遘ｻ蜍 + ring_t* p = (ring_t*)((size_t)pFiles - offsetof(ring_t, f)); + p->r.InsertTail(&m_cRing); +} + +//=========================================================================== +// +// FCB蜃ｦ逅 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +void CHostFcb::Init() +{ + ASSERT(this); + + m_bUpdate = FALSE; + m_pFile = NULL; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝峨ｒ險ｭ螳 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::SetMode(DWORD nHumanMode) +{ + ASSERT(this); + + switch (nHumanMode & Human68k::OP_MASK) { + case Human68k::OP_READ: + m_pszMode = "rb"; + break; + case Human68k::OP_WRITE: + m_pszMode = "wb"; + break; + case Human68k::OP_FULL: + m_pszMode = "r+b"; + break; + default: + return FALSE; + } + + m_bFlag = (nHumanMode & Human68k::OP_SPECIAL) != 0; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蜷阪ｒ險ｭ螳 +// +//--------------------------------------------------------------------------- +void CHostFcb::SetFilename(const TCHAR* szFilename) +{ + ASSERT(this); + ASSERT(szFilename); + ASSERT(strlen(szFilename) < FILEPATH_MAX); + + strcpy(m_szFilename, szFilename); +} + +//--------------------------------------------------------------------------- +// +/// Human68k繝代せ蜷阪ｒ險ｭ螳 +// +//--------------------------------------------------------------------------- +void CHostFcb::SetHumanPath(const BYTE* szHumanPath) +{ + ASSERT(this); + ASSERT(szHumanPath); + ASSERT(strlen((const char*)szHumanPath) < HUMAN68K_PATH_MAX); + + strcpy((char*)m_szHumanPath, (const char*)szHumanPath); +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ菴懈 +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::Create(DWORD nHumanAttribute, BOOL bForce) +{ + ASSERT(this); + ASSERT((nHumanAttribute & (Human68k::AT_DIRECTORY | Human68k::AT_VOLUME)) == 0); + ASSERT(strlen(m_szFilename) > 0); + ASSERT(m_pFile == NULL); + + // 驥崎､繝√ぉ繝繧ｯ + if (bForce == FALSE) { + struct stat sb; + if (stat(S2U(m_szFilename), &sb) == 0) + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ菴懈 + m_pFile = fopen(S2U(m_szFilename), "w+b"); /// @warning 逅諠ｳ蜍穂ｽ懊ｯ螻樊ｧ縺斐→荳頑嶌縺 + + return m_pFile != NULL; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::Open() +{ + struct stat st; + + ASSERT(this); + ASSERT(strlen(m_szFilename) > 0); + + // 繝繧｣繝ｬ繧ｯ繝医Μ縺ｪ繧牙､ｱ謨 + if (stat(S2U(m_szFilename), &st) == 0) { + if ((st.st_mode & S_IFMT) == S_IFDIR) { + return FALSE || m_bFlag; + } + } + + // 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + if (m_pFile == NULL) + m_pFile = fopen(S2U(m_szFilename), m_pszMode); + + return m_pFile != NULL || m_bFlag; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::Rewind(DWORD nOffset) +{ + ASSERT(this); + ASSERT(m_pFile); + + if (fseek(m_pFile, nOffset, SEEK_SET)) + return FALSE; + + return ftell(m_pFile) != -1L; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ +/// +/// 0繝舌う繝郁ｪｭ縺ｿ霎ｼ縺ｿ縺ｧ繧よｭ｣蟶ｸ蜍穂ｽ懊→縺吶ｋ縲 +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯ-1繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +DWORD CHostFcb::Read(BYTE* pBuffer, DWORD nSize) +{ + ASSERT(this); + ASSERT(pBuffer); + ASSERT(m_pFile); + + size_t nResult = fread(pBuffer, sizeof(BYTE), nSize, m_pFile); + if (ferror(m_pFile)) + nResult = (size_t)-1; + + return (DWORD)nResult; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ +/// +/// 0繝舌う繝域嶌縺崎ｾｼ縺ｿ縺ｧ繧よｭ｣蟶ｸ蜍穂ｽ懊→縺吶ｋ縲 +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯ-1繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +DWORD CHostFcb::Write(const BYTE* pBuffer, DWORD nSize) +{ + ASSERT(this); + ASSERT(pBuffer); + ASSERT(m_pFile); + + size_t nResult = fwrite(pBuffer, sizeof(BYTE), nSize, m_pFile); + if (ferror(m_pFile)) + nResult = (size_t)-1; + + return (DWORD)nResult; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ蛻繧願ｩｰ繧 +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::Truncate() +{ + ASSERT(this); + ASSERT(m_pFile); + + return ftruncate(fileno(m_pFile), ftell(m_pFile)) == 0; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯ-1繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +DWORD CHostFcb::Seek(DWORD nOffset, DWORD nHumanSeek) +{ + ASSERT(this); + ASSERT(nHumanSeek == Human68k::SK_BEGIN || + nHumanSeek == Human68k::SK_CURRENT || nHumanSeek == Human68k::SK_END); + ASSERT(m_pFile); + + int nSeek; + switch (nHumanSeek) { + case Human68k::SK_BEGIN: + nSeek = SEEK_SET; + break; + case Human68k::SK_CURRENT: + nSeek = SEEK_CUR; + break; + // case SK_END: + default: + nSeek = SEEK_END; + break; + } + if (fseek(m_pFile, nOffset, nSeek)) + return (DWORD)-1; + + return (DWORD)ftell(m_pFile); +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ譎ょ綾險ｭ螳 +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::TimeStamp(DWORD nHumanTime) +{ + ASSERT(this); + ASSERT(m_pFile || m_bFlag); + + struct tm t = { 0 }; + t.tm_year = (nHumanTime >> 25) + 80; + t.tm_mon = ((nHumanTime >> 21) - 1) & 15; + t.tm_mday = (nHumanTime >> 16) & 31; + t.tm_hour = (nHumanTime >> 11) & 15; + t.tm_min = (nHumanTime >> 5) & 63; + t.tm_sec = (nHumanTime & 31) << 1; + time_t ti = mktime(&t); + if (ti == (time_t)-1) + return FALSE; + struct utimbuf ut; + ut.actime = ti; + ut.modtime = ti; + + // 繧ｯ繝ｭ繝ｼ繧ｺ譎ゅ↓譖ｴ譁ｰ譎ょ綾縺御ｸ頑嶌縺阪＆繧後ｋ縺ｮ繧帝亟豁｢縺吶ｋ縺溘ａ + // 繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｮ譖ｴ譁ｰ蜑阪↓繝輔Λ繝繧ｷ繝･縺励※蜷梧悄縺輔○繧 + fflush(m_pFile); + + return utime(S2U(m_szFilename), &ut) == 0 || m_bFlag; +} + +//--------------------------------------------------------------------------- +// +/// 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ +/// +/// 繧ｨ繝ｩ繝ｼ縺ｮ譎ゅｯFALSE繧定ｿ斐☆縲 +// +//--------------------------------------------------------------------------- +BOOL CHostFcb::Close() +{ + ASSERT(this); + + BOOL bResult = TRUE; + + // 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + // Close竊巽ree(蜀驛ｨ縺ｧ蜀榊ｺｦClose)縺ｨ縺縺豬√ｌ繧ゅ≠繧九ｮ縺ｧ蠢縺壼晄悄蛹悶☆繧九％縺ｨ縲 + if (m_pFile) { + fclose(m_pFile); + m_pFile = NULL; + } + + return bResult; +} + +//=========================================================================== +// +// FCB蜃ｦ逅 繝槭ロ繝ｼ繧ｸ繝｣ +// +//=========================================================================== + +#ifdef _DEBUG +//--------------------------------------------------------------------------- +// +/// 繝繧ｹ繝医Λ繧ｯ繧ｿ final +// +//--------------------------------------------------------------------------- +CHostFcbManager::~CHostFcbManager() +{ + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); +} +#endif // _DEBUG + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) +// +//--------------------------------------------------------------------------- +void CHostFcbManager::Init() +{ + ASSERT(this); + + // 螳滉ｽ薙′蟄伜惠縺励↑縺縺薙→繧堤｢ｺ隱 (蠢ｵ縺ｮ縺溘ａ) + ASSERT(m_cRing.Next() == &m_cRing); + ASSERT(m_cRing.Prev() == &m_cRing); + + // 繝｡繝｢繝ｪ遒ｺ菫 + for (DWORD i = 0; i < XM6_HOST_FCB_MAX; i++) { + ring_t* p = new ring_t; + ASSERT(p); + p->r.Insert(&m_cRing); + } +} + +//--------------------------------------------------------------------------- +// +/// 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) +// +//--------------------------------------------------------------------------- +void CHostFcbManager::Clean() +{ + ASSERT(this); + + // 繝｡繝｢繝ｪ隗｣謾ｾ + CRing* p; + while ((p = m_cRing.Next()) != &m_cRing) { + delete (ring_t*)p; + } +} + +//--------------------------------------------------------------------------- +// +/// 遒ｺ菫 +// +//--------------------------------------------------------------------------- +CHostFcb* CHostFcbManager::Alloc(DWORD nKey) +{ + ASSERT(this); + ASSERT(nKey); + + // 譛ｫ蟆ｾ縺九ｉ驕ｸ謚 + ring_t* p = (ring_t*)m_cRing.Prev(); + + // 菴ｿ逕ｨ荳ｭ縺ｪ繧峨お繝ｩ繝ｼ (蠢ｵ縺ｮ縺溘ａ) + if (p->f.isSameKey(0) == FALSE) { + ASSERT(0); + return NULL; + } + + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ遘ｻ蜍 + p->r.Insert(&m_cRing); + + // 繧ｭ繝ｼ繧定ｨｭ螳 + p->f.SetKey(nKey); + + return &p->f; +} + +//--------------------------------------------------------------------------- +// +/// 讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +CHostFcb* CHostFcbManager::Search(DWORD nKey) +{ + ASSERT(this); + ASSERT(nKey); + + // 隧ｲ蠖薙☆繧九が繝悶ず繧ｧ繧ｯ繝医ｒ讀懃ｴ｢ + ring_t* p = (ring_t*)m_cRing.Next(); + while (p != (ring_t*)&m_cRing) { + if (p->f.isSameKey(nKey)) { + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ遘ｻ蜍 + p->r.Insert(&m_cRing); + return &p->f; + } + p = (ring_t*)p->r.Next(); + } + + return NULL; +} + +//--------------------------------------------------------------------------- +// +/// 隗｣謾ｾ +// +//--------------------------------------------------------------------------- +void CHostFcbManager::Free(CHostFcb* pFcb) +{ + ASSERT(this); + ASSERT(pFcb); + + // 隗｣謾ｾ + pFcb->SetKey(0); + pFcb->Close(); + + // 繝ｪ繝ｳ繧ｰ譛ｫ蟆ｾ縺ｸ遘ｻ蜍 + ring_t* p = (ring_t*)((size_t)pFcb - offsetof(ring_t, f)); + p->r.InsertTail(&m_cRing); +} + +//=========================================================================== +// +// 繝帙せ繝亥ｴ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝 +// +//=========================================================================== + +DWORD CFileSys::g_nOption; ///< 繝輔ぃ繧､繝ｫ蜷榊､画鋤繝輔Λ繧ｰ + +//--------------------------------------------------------------------------- +// +/// 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CFileSys::CFileSys() +{ + // 繧ｳ繝ｳ繝輔ぅ繧ｰ繝繝ｼ繧ｿ蛻晄悄蛹 + m_nDrives = 0; + + for (size_t n = 0; n < DriveMax; n++) { + m_nFlag[n] = 0; + m_szBase[n][0] = _T('\0'); + } + + // TwentyOne繧ｪ繝励す繝ｧ繝ｳ逶｣隕門晄悄蛹 + m_nKernel = 0; + m_nKernelSearch = 0; + + // 蜍穂ｽ懊ヵ繝ｩ繧ｰ蛻晄悄蛹 + m_nOptionDefault = 0; + m_nOption = 0; + ASSERT(g_nOption == 0); +} + +//--------------------------------------------------------------------------- +// +/// 繝ｪ繧ｻ繝繝 (蜈ｨ繧ｯ繝ｭ繝ｼ繧ｺ) +// +//--------------------------------------------------------------------------- +void CFileSys::Reset() +{ + ASSERT(this); + + // 莉ｮ諠ｳ繧ｻ繧ｯ繧ｿ鬆伜沺蛻晄悄蛹 + m_nHostSectorCount = 0; + memset(m_nHostSectorBuffer, 0, sizeof(m_nHostSectorBuffer)); + + // 繝輔ぃ繧､繝ｫ讀懃ｴ｢鬆伜沺 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + m_cFiles.Clean(); + + // FCB謫堺ｽ憺伜沺 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + m_cFcb.Clean(); + + // 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + m_cEntry.Clean(); + + // TwentyOne繧ｪ繝励す繝ｧ繝ｳ逶｣隕門晄悄蛹 + m_nKernel = 0; + m_nKernelSearch = 0; + + // 蜍穂ｽ懊ヵ繝ｩ繧ｰ蛻晄悄蛹 + SetOption(m_nOptionDefault); +} + +//--------------------------------------------------------------------------- +// +/// 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔→繝ｭ繝ｼ繝) +// +//--------------------------------------------------------------------------- +void CFileSys::Init() +{ + ASSERT(this); + + // 繝輔ぃ繧､繝ｫ讀懃ｴ｢鬆伜沺 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔ｻ繝ｭ繝ｼ繝画凾) + m_cFiles.Init(); + + // FCB謫堺ｽ憺伜沺 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔ｻ繝ｭ繝ｼ繝画凾) + m_cFcb.Init(); + + // 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔ｻ繝ｭ繝ｼ繝画凾) + m_cEntry.Init(); + + // 繝代せ蛟句挨險ｭ螳壹ｮ譛臥┌繧貞愛螳 + DWORD nDrives = m_nDrives; + if (nDrives == 0) { + // 蛟句挨險ｭ螳壹ｒ菴ｿ繧上★縺ｫ繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ繧剃ｽｿ逕ｨ縺吶ｋ + strcpy(m_szBase[0], _T("/")); + m_nFlag[0] = 0; + nDrives++; + } + + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧堤匳骭ｲ + DWORD nUnit = 0; + for (DWORD n = 0; n < nDrives; n++) { + // 繝吶ｼ繧ｹ繝代せ縺悟ｭ伜惠縺励↑縺繧ｨ繝ｳ繝医Μ縺ｯ逋ｻ骭ｲ縺励↑縺 + if (m_szBase[n][0] == _T('\0')) + continue; + + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧1繝ｦ繝九ャ繝育函謌 + CHostDrv* p = new CHostDrv; // std::nothrow + if (p) { + m_cEntry.SetDrv(nUnit, p); + p->Init(m_szBase[n], m_nFlag[n]); + + // 谺｡縺ｮ繝ｦ繝九ャ繝医∈ + nUnit++; + } + } + + // 逋ｻ骭ｲ縺励◆繝峨Λ繧､繝匁焚繧剃ｿ晏ｭ + m_nUnits = nUnit; +} + +//--------------------------------------------------------------------------- +// +/// $40 - 繝繝舌う繧ｹ襍ｷ蜍 +// +//--------------------------------------------------------------------------- +DWORD CFileSys::InitDevice(const Human68k::argument_t* pArgument) +{ + ASSERT(this); + + // 繧ｪ繝励す繝ｧ繝ｳ蛻晄悄蛹 + InitOption(pArgument); + + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝蛻晄悄蛹 + Init(); + + return m_nUnits; +} + +//--------------------------------------------------------------------------- +// +/// $41 - 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +int CFileSys::CheckDir(DWORD nUnit, const Human68k::namests_t* pNamests) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_INVALIDFUNC; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝悶〒mint謫堺ｽ懈凾縺ｫ逋ｽ蟶ｯ繧貞ｺ縺輔↑縺繧医≧謾ｹ濶ｯ + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + if (f.isRootPath()) + return 0; + f.SetPathOnly(); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_DIRNOTFND; + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $42 - 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 +// +//--------------------------------------------------------------------------- +int CFileSys::MakeDir(DWORD nUnit, const Human68k::namests_t* pNamests) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetPathOnly(); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_INVALIDPATH; + f.AddFilename(); + + // 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + if (mkdir(S2U(f.GetPath()), 0777)) + return FS_INVALIDPATH; + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $43 - 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 +// +//--------------------------------------------------------------------------- +int CFileSys::RemoveDir(DWORD nUnit, const Human68k::namests_t* pNamests) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetAttribute(Human68k::AT_DIRECTORY); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_DIRNOTFND; + + // 繧ｭ繝｣繝繧ｷ繝･蜑企勁 + BYTE szHuman[HUMAN68K_PATH_MAX + 24]; + ASSERT(strlen((const char*)f.GetHumanPath()) + + strlen((const char*)f.GetHumanFilename()) < HUMAN68K_PATH_MAX + 24); + strcpy((char*)szHuman, (const char*)f.GetHumanPath()); + strcat((char*)szHuman, (const char*)f.GetHumanFilename()); + strcat((char*)szHuman, "/"); + m_cEntry.DeleteCache(nUnit, szHuman); + + // 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 + if (rmdir(S2U(f.GetPath()))) + return FS_CANTDELETE; + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $44 - 繝輔ぃ繧､繝ｫ蜷榊､画峩 +// +//--------------------------------------------------------------------------- +int CFileSys::Rename(DWORD nUnit, const Human68k::namests_t* pNamests, const Human68k::namests_t* pNamestsNew) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetAttribute(Human68k::AT_ALL); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_FILENOTFND; + + CHostFiles fNew; + fNew.SetPath(pNamestsNew); + fNew.SetPathOnly(); + if (fNew.Find(nUnit, &m_cEntry) == FALSE) + return FS_INVALIDPATH; + fNew.AddFilename(); + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + if (f.GetAttribute() & Human68k::AT_DIRECTORY) + m_cEntry.CleanCacheChild(nUnit, f.GetHumanPath()); + + // 繝輔ぃ繧､繝ｫ蜷榊､画峩 + char szFrom[FILENAME_MAX]; + char szTo[FILENAME_MAX]; + SJIS2UTF8(f.GetPath(), szFrom, FILENAME_MAX); + SJIS2UTF8(fNew.GetPath(), szTo, FILENAME_MAX); + if (rename(szFrom, szTo)) { + return FS_FILENOTFND; + } + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + m_cEntry.CleanCache(nUnit, fNew.GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $45 - 繝輔ぃ繧､繝ｫ蜑企勁 +// +//--------------------------------------------------------------------------- +int CFileSys::Delete(DWORD nUnit, const Human68k::namests_t* pNamests) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_FILENOTFND; + + // 繝輔ぃ繧､繝ｫ蜑企勁 + if (unlink(S2U(f.GetPath()))) + return FS_CANTDELETE; + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $46 - 繝輔ぃ繧､繝ｫ螻樊ｧ蜿門ｾ/險ｭ螳 +// +//--------------------------------------------------------------------------- +int CFileSys::Attribute(DWORD nUnit, const Human68k::namests_t* pNamests, DWORD nHumanAttribute) +{ + ASSERT(this); + ASSERT(pNamests); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetAttribute(Human68k::AT_ALL); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_FILENOTFND; + + // 螻樊ｧ蜿門ｾ励↑繧臥ｵゆｺ + if (nHumanAttribute == 0xFF) + return f.GetAttribute(); + + // 螻樊ｧ繝√ぉ繝繧ｯ + if (nHumanAttribute & Human68k::AT_VOLUME) + return FS_CANTACCESS; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 螻樊ｧ逕滓 + DWORD nAttribute = (nHumanAttribute & Human68k::AT_READONLY) | + (f.GetAttribute() & ~Human68k::AT_READONLY); + if (f.GetAttribute() != nAttribute) { + struct stat sb; + if (stat(S2U(f.GetPath()), &sb)) + return FS_FILENOTFND; + mode_t m = sb.st_mode & 0777; + if (nAttribute & Human68k::AT_READONLY) + m &= 0555; // ugo-w + else + m |= 0200; // u+w + + // 螻樊ｧ險ｭ螳 + if (chmod(S2U(f.GetPath()), m)) + return FS_FILENOTFND; + } + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + + // 螟画峩蠕後ｮ螻樊ｧ蜿門ｾ + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_FILENOTFND; + + return f.GetAttribute(); +} + +//--------------------------------------------------------------------------- +// +/// $47 - 繝輔ぃ繧､繝ｫ讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +int CFileSys::Files(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::files_t* pFiles) +{ + ASSERT(this); + ASSERT(pNamests); + ASSERT(nKey); + ASSERT(pFiles); + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後≠繧後ｰ隗｣謾ｾ縺励※縺翫￥ + CHostFiles* pHostFiles = m_cFiles.Search(nKey); + if (pHostFiles != NULL) { + m_cFiles.Free(pHostFiles); + } + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ + /** @note + 逶ｴ蜑阪ｮ繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ縺ｧ豁｣縺励￥繧ｨ繝ｩ繝ｼ繧定ｿ斐＠縺ｦ縺繧九↓繧ゅ°縺九ｏ繧 + 縺壹√懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ励ｒ螳溯｡後☆繧玖｡悟о縺ｮ謔ｪ縺繧｢繝励Μ縺ｧ繝帙せ繝亥ｴ縺ｮ + 繝ｪ繝繝ｼ繝舌ヶ繝ｫ繝｡繝繧｣繧｢(CD-ROM繝峨Λ繧､繝也ｭ)縺檎區蟶ｯ繧貞ｺ縺吶ｮ繧帝亟縺舌◆繧√ + 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ励ｯ繝｡繝繧｣繧｢繝√ぉ繝繧ｯ繧偵○縺壹↓陦後↑縺莉墓ｧ倥→縺励◆縲 + */ + if ((pFiles->fatr & (Human68k::AT_ARCHIVE | Human68k::AT_DIRECTORY | Human68k::AT_VOLUME)) + == Human68k::AT_VOLUME) { + // 繝代せ繝√ぉ繝繧ｯ + CHostFiles f; + f.SetPath(pNamests); + if (f.isRootPath() == FALSE) + return FS_FILENOTFND; + + // 繝舌ャ繝輔ぃ繧堤｢ｺ菫昴○縺壹√＞縺阪↑繧顔ｵ先棡繧定ｿ斐☆ + if (FilesVolume(nUnit, pFiles) == FALSE) + return FS_FILENOTFND; + return 0; + } + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 繝舌ャ繝輔ぃ遒ｺ菫 + pHostFiles = m_cFiles.Alloc(nKey); + if (pHostFiles == NULL) + return FS_OUTOFMEM; + + // 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ + pHostFiles->SetPath(pNamests); + if (pHostFiles->isRootPath() == FALSE) { + pHostFiles->SetPathOnly(); + if (pHostFiles->Find(nUnit, &m_cEntry) == FALSE) { + m_cFiles.Free(pHostFiles); + return FS_DIRNOTFND; + } + } + + // 繝ｯ繧､繝ｫ繝峨き繝ｼ繝我ｽｿ逕ｨ蜿ｯ閭ｽ縺ｫ險ｭ螳 + pHostFiles->SetPathWildcard(); + pHostFiles->SetAttribute(pFiles->fatr); + + // 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + if (pHostFiles->Find(nUnit, &m_cEntry) == FALSE) { + m_cFiles.Free(pHostFiles); + return FS_FILENOTFND; + } + + // 讀懃ｴ｢邨先棡繧呈ｼ邏 + pFiles->attr = (BYTE)pHostFiles->GetAttribute(); + pFiles->date = pHostFiles->GetDate(); + pFiles->time = pHostFiles->GetTime(); + pFiles->size = pHostFiles->GetSize(); + strcpy((char*)pFiles->full, (const char*)pHostFiles->GetHumanResult()); + + // 謫ｬ莨ｼ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧呈欠螳 + pFiles->sector = nKey; + pFiles->offset = 0; + + // 繝輔ぃ繧､繝ｫ蜷阪↓繝ｯ繧､繝ｫ繝峨き繝ｼ繝峨′縺ｪ縺代ｌ縺ｰ縲√％縺ｮ譎らせ縺ｧ繝舌ャ繝輔ぃ繧定ｧ｣謾ｾ蜿ｯ閭ｽ + if (pNamests->wildcard == 0) { + // 縺励°縺励∽ｻｮ諠ｳ繧ｻ繧ｯ繧ｿ縺ｮ繧ｨ繝溘Η繝ｬ繝ｼ繧ｷ繝ｧ繝ｳ縺ｧ菴ｿ縺蜿ｯ閭ｽ諤ｧ縺後≠繧九◆繧√√☆縺舌↓縺ｯ隗｣謾ｾ縺励↑縺 + // m_cFiles.Free(pHostFiles); + } + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $48 - 繝輔ぃ繧､繝ｫ谺｡讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +int CFileSys::NFiles(DWORD nUnit, DWORD nKey, Human68k::files_t* pFiles) +{ + ASSERT(this); + ASSERT(nKey); + ASSERT(pFiles); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 繝舌ャ繝輔ぃ讀懃ｴ｢ + CHostFiles* pHostFiles = m_cFiles.Search(nKey); + if (pHostFiles == NULL) + return FS_INVALIDPTR; + + // 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + if (pHostFiles->Find(nUnit, &m_cEntry) == FALSE) { + m_cFiles.Free(pHostFiles); + return FS_FILENOTFND; + } + + ASSERT(pFiles->sector == nKey); + ASSERT(pFiles->offset == 0); + + // 讀懃ｴ｢邨先棡繧呈ｼ邏 + pFiles->attr = (BYTE)pHostFiles->GetAttribute(); + pFiles->date = pHostFiles->GetDate(); + pFiles->time = pHostFiles->GetTime(); + pFiles->size = pHostFiles->GetSize(); + strcpy((char*)pFiles->full, (const char*)pHostFiles->GetHumanResult()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $49 - 繝輔ぃ繧､繝ｫ譁ｰ隕丈ｽ懈 +// +//--------------------------------------------------------------------------- +int CFileSys::Create(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb, DWORD nHumanAttribute, BOOL bForce) +{ + ASSERT(this); + ASSERT(pNamests); + ASSERT(nKey); + ASSERT(pFcb); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後≠繧後ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + if (m_cFcb.Search(nKey) != NULL) + return FS_INVALIDPTR; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetPathOnly(); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_INVALIDPATH; + f.AddFilename(); + + // 螻樊ｧ繝√ぉ繝繧ｯ + if (nHumanAttribute & (Human68k::AT_DIRECTORY | Human68k::AT_VOLUME)) + return FS_CANTACCESS; + + // 繝代せ蜷堺ｿ晏ｭ + CHostFcb* pHostFcb = m_cFcb.Alloc(nKey); + if (pHostFcb == NULL) + return FS_OUTOFMEM; + pHostFcb->SetFilename(f.GetPath()); + pHostFcb->SetHumanPath(f.GetHumanPath()); + + // 繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝芽ｨｭ螳 + pFcb->mode = (WORD)((pFcb->mode & ~Human68k::OP_MASK) | Human68k::OP_FULL); + if (pHostFcb->SetMode(pFcb->mode) == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_ILLEGALMOD; + } + + // 繝輔ぃ繧､繝ｫ菴懈 + if (pHostFcb->Create(nHumanAttribute, bForce) == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_FILEEXIST; + } + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, f.GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $4A - 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +int CFileSys::Open(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb) +{ + ASSERT(this); + ASSERT(pNamests); + ASSERT(nKey); + ASSERT(pFcb); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + switch (pFcb->mode & Human68k::OP_MASK) { + case Human68k::OP_WRITE: + case Human68k::OP_FULL: + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + } + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後≠繧後ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + if (m_cFcb.Search(nKey) != NULL) + return FS_INVALIDPRM; + + // 繝代せ蜷咲函謌 + CHostFiles f; + f.SetPath(pNamests); + f.SetAttribute(Human68k::AT_ALL); + if (f.Find(nUnit, &m_cEntry) == FALSE) + return FS_FILENOTFND; + + // 繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝 + pFcb->date = f.GetDate(); + pFcb->time = f.GetTime(); + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ + pFcb->size = f.GetSize(); + + // 繝代せ蜷堺ｿ晏ｭ + CHostFcb* pHostFcb = m_cFcb.Alloc(nKey); + if (pHostFcb == NULL) + return FS_OUTOFMEM; + pHostFcb->SetFilename(f.GetPath()); + pHostFcb->SetHumanPath(f.GetHumanPath()); + + // 繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝芽ｨｭ螳 + if (pHostFcb->SetMode(pFcb->mode) == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_ILLEGALMOD; + } + + // 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + if (pHostFcb->Open() == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDPATH; + } + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $4B - 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +int CFileSys::Close(DWORD nUnit, DWORD nKey, Human68k::fcb_t* /* pFcb */) +{ + ASSERT(this); + ASSERT(nKey); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + CHostFcb* pHostFcb = m_cFcb.Search(nKey); + if (pHostFcb == NULL) + return FS_INVALIDPRM; + + // 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ縺ｨ鬆伜沺隗｣謾ｾ + m_cFcb.Free(pHostFcb); + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + if (pHostFcb->isUpdate()) + m_cEntry.CleanCache(nUnit, pHostFcb->GetHumanPath()); + + /// @note 繧ｯ繝ｭ繝ｼ繧ｺ譎ゅｮFCB縺ｮ迥ｶ諷九ｒ莉悶ｮ繝繝舌う繧ｹ縺ｨ蜷医ｏ縺帙◆縺 + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $4C - 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ +/// +/// 0繝舌う繝郁ｪｭ縺ｿ霎ｼ縺ｿ縺ｧ繧よｭ｣蟶ｸ邨ゆｺ縺吶ｋ縲 +// +//--------------------------------------------------------------------------- +int CFileSys::Read(DWORD nKey, Human68k::fcb_t* pFcb, BYTE* pBuffer, DWORD nSize) +{ + ASSERT(this); + ASSERT(nKey); + ASSERT(pFcb); + // ASSERT(pBuffer); // 蠢隕∵凾縺ｮ縺ｿ蛻､螳 + ASSERT(nSize <= 0xFFFFFF); // 繧ｯ繝ｪ繝繝玲ｸ + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + CHostFcb* pHostFcb = m_cFcb.Search(nKey); + if (pHostFcb == NULL) + return FS_NOTOPENED; + + // 繝舌ャ繝輔ぃ蟄伜惠遒ｺ隱 + if (pBuffer == NULL) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDFUNC; + } + + // 隱ｭ縺ｿ霎ｼ縺ｿ + DWORD nResult; + nResult = pHostFcb->Read(pBuffer, nSize); + if (nResult == (DWORD)-1) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDFUNC; /// @note 縺薙ｌ縺ｫ蜉縺医※繧ｨ繝ｩ繝ｼ繧ｳ繝ｼ繝10(隱ｭ縺ｿ霎ｼ縺ｿ繧ｨ繝ｩ繝ｼ)繧定ｿ斐☆縺ｹ縺 + } + ASSERT(nResult <= nSize); + + // 繝輔ぃ繧､繝ｫ繝昴う繝ｳ繧ｿ譖ｴ譁ｰ + pFcb->fileptr += nResult; /// @note 繧ｪ繝ｼ繝舌ｼ繝輔Ο繝ｼ遒ｺ隱阪ｯ蠢隕√§繧繧阪≧縺具ｼ + + return nResult; +} + +//--------------------------------------------------------------------------- +// +/// $4D - 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ +/// +/// 0繝舌う繝域嶌縺崎ｾｼ縺ｿ縺ｮ蝣ｴ蜷医ｯ繝輔ぃ繧､繝ｫ繧貞繧願ｩｰ繧√ｋ縲 +// +//--------------------------------------------------------------------------- +int CFileSys::Write(DWORD nKey, Human68k::fcb_t* pFcb, const BYTE* pBuffer, DWORD nSize) +{ + ASSERT(this); + ASSERT(nKey); + ASSERT(pFcb); + // ASSERT(pBuffer); // 蠢隕∵凾縺ｮ縺ｿ蛻､螳 + ASSERT(nSize <= 0xFFFFFF); // 繧ｯ繝ｪ繝繝玲ｸ + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + CHostFcb* pHostFcb = m_cFcb.Search(nKey); + if (pHostFcb == NULL) + return FS_NOTOPENED; + + DWORD nResult; + if (nSize == 0) { + // 蛻繧願ｩｰ繧 + if (pHostFcb->Truncate() == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_CANTSEEK; + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ譖ｴ譁ｰ + pFcb->size = pFcb->fileptr; + + nResult = 0; + } else { + // 繝舌ャ繝輔ぃ蟄伜惠遒ｺ隱 + if (pBuffer == NULL) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDFUNC; + } + + // 譖ｸ縺崎ｾｼ縺ｿ + nResult = pHostFcb->Write(pBuffer, nSize); + if (nResult == (DWORD)-1) { + m_cFcb.Free(pHostFcb); + return FS_CANTWRITE; /// @note 縺薙ｌ縺ｫ蜉縺医※繧ｨ繝ｩ繝ｼ繧ｳ繝ｼ繝11(譖ｸ縺崎ｾｼ縺ｿ繧ｨ繝ｩ繝ｼ)繧定ｿ斐☆縺ｹ縺 + } + ASSERT(nResult <= nSize); + + // 繝輔ぃ繧､繝ｫ繝昴う繝ｳ繧ｿ譖ｴ譁ｰ + pFcb->fileptr += nResult; /// @note 繧ｪ繝ｼ繝舌ｼ繝輔Ο繝ｼ遒ｺ隱阪ｯ蠢隕√§繧繧阪≧縺具ｼ + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ譖ｴ譁ｰ + if (pFcb->size < pFcb->fileptr) + pFcb->size = pFcb->fileptr; + } + + // 繝輔Λ繧ｰ譖ｴ譁ｰ + pHostFcb->SetUpdate(); + + return nResult; +} + +//--------------------------------------------------------------------------- +// +/// $4E - 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ +// +//--------------------------------------------------------------------------- +int CFileSys::Seek(DWORD nKey, Human68k::fcb_t* pFcb, DWORD nSeek, int nOffset) +{ + ASSERT(this); + ASSERT(pFcb); + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + CHostFcb* pHostFcb = m_cFcb.Search(nKey); + if (pHostFcb == NULL) + return FS_NOTOPENED; + + // 繝代Λ繝｡繝ｼ繧ｿ繝√ぉ繝繧ｯ + if (nSeek > Human68k::SK_END) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDPRM; + } + + // 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + DWORD nResult = pHostFcb->Seek(nOffset, nSeek); + if (nResult == (DWORD)-1) { + m_cFcb.Free(pHostFcb); + return FS_CANTSEEK; + } + + // 繝輔ぃ繧､繝ｫ繝昴う繝ｳ繧ｿ譖ｴ譁ｰ + pFcb->fileptr = nResult; + + return nResult; +} + +//--------------------------------------------------------------------------- +// +/// $4F - 繝輔ぃ繧､繝ｫ譎ょ綾蜿門ｾ/險ｭ螳 +/// +/// 邨先棡縺ｮ荳贋ｽ16Bit縺$FFFF縺縺ｨ繧ｨ繝ｩ繝ｼ縲 +// +//--------------------------------------------------------------------------- +DWORD CFileSys::TimeStamp(DWORD nUnit, DWORD nKey, Human68k::fcb_t* pFcb, DWORD nHumanTime) +{ + ASSERT(this); + ASSERT(nKey); + ASSERT(pFcb); + + // 蜿門ｾ励ｮ縺ｿ + if (nHumanTime == 0) + return ((DWORD)pFcb->date << 16) | pFcb->time; + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 譌｢縺ｫ蜷後§繧ｭ繝ｼ繧呈戟縺､鬆伜沺縺後↑縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ縺ｨ縺吶ｋ + CHostFcb* pHostFcb = m_cFcb.Search(nKey); + if (pHostFcb == NULL) + return FS_NOTOPENED; + + // 譎ょ綾險ｭ螳 + if (pHostFcb->TimeStamp(nHumanTime) == FALSE) { + m_cFcb.Free(pHostFcb); + return FS_INVALIDPRM; + } + pFcb->date = (WORD)(nHumanTime >> 16); + pFcb->time = (WORD)nHumanTime; + + // 繧ｭ繝｣繝繧ｷ繝･譖ｴ譁ｰ + m_cEntry.CleanCache(nUnit, pHostFcb->GetHumanPath()); + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $50 - 螳ｹ驥丞叙蠕 +// +//--------------------------------------------------------------------------- +int CFileSys::GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity) +{ + ASSERT(this); + ASSERT(pCapacity); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 螳ｹ驥丞叙蠕 + return m_cEntry.GetCapacity(nUnit, pCapacity); +} + +//--------------------------------------------------------------------------- +// +/// $51 - 繝峨Λ繧､繝也憾諷区､懈渊/蛻ｶ蠕｡ +// +//--------------------------------------------------------------------------- +int CFileSys::CtrlDrive(DWORD nUnit, Human68k::ctrldrive_t* pCtrlDrive) +{ + ASSERT(this); + ASSERT(pCtrlDrive); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_INVALIDFUNC; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝悶〒mint謫堺ｽ懈凾縺ｫ逋ｽ蟶ｯ繧貞ｺ縺輔↑縺繧医≧謾ｹ濶ｯ + + switch (pCtrlDrive->status) { + case 0: // 迥ｶ諷区､懈渊 + case 9: // 迥ｶ諷区､懈渊2 + pCtrlDrive->status = (BYTE)m_cEntry.GetStatus(nUnit); + return pCtrlDrive->status; + + case 1: // 繧､繧ｸ繧ｧ繧ｯ繝 + case 2: // 繧､繧ｸ繧ｧ繧ｯ繝育ｦ∵ｭ｢1 (譛ｪ螳溯｣) + case 3: // 繧､繧ｸ繧ｧ繧ｯ繝郁ｨｱ蜿ｯ1 (譛ｪ螳溯｣) + case 4: // 繝｡繝繧｣繧｢譛ｪ謖ｿ蜈･譎ゅ↓LED轤ｹ貊 (譛ｪ螳溯｣) + case 5: // 繝｡繝繧｣繧｢譛ｪ謖ｿ蜈･譎ゅ↓LED豸育ｯ (譛ｪ螳溯｣) + case 6: // 繧､繧ｸ繧ｧ繧ｯ繝育ｦ∵ｭ｢2 (譛ｪ螳溯｣) + case 7: // 繧､繧ｸ繧ｧ繧ｯ繝郁ｨｱ蜿ｯ2 (譛ｪ螳溯｣) + return 0; + + case 8: // 繧､繧ｸ繧ｧ繧ｯ繝域､懈渊 + return 1; + } + + return FS_INVALIDFUNC; +} + +//--------------------------------------------------------------------------- +// +/// $52 - DPB蜿門ｾ +/// +/// 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓DPB縺悟叙蠕励〒縺阪↑縺縺ｨHuman68k蜀驛ｨ縺ｧ繝峨Λ繧､繝悶′豸域ｻ縺吶ｋ縺溘ａ縲 +/// 遽蝗ｲ螟悶ｮ繝ｦ繝九ャ繝医〒繧ゅ→縺ｫ縺九￥豁｣蟶ｸ邉ｻ縺ｨ縺励※蜃ｦ逅縺吶ｋ縲 +// +//--------------------------------------------------------------------------- +int CFileSys::GetDPB(DWORD nUnit, Human68k::dpb_t* pDpb) +{ + ASSERT(this); + ASSERT(pDpb); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + + Human68k::capacity_t cap; + BYTE media = Human68k::MEDIA_REMOTE; + if (nUnit < m_nUnits) { + media = m_cEntry.GetMediaByte(nUnit); + + // 繧ｻ繧ｯ繧ｿ諠蝣ｱ迯ｲ蠕 + if (m_cEntry.GetCapacityCache(nUnit, &cap) == FALSE) { + // 謇句虚繧､繧ｸ繧ｧ繧ｯ繝医□縺ｨ繝｡繝繧｣繧｢繝√ぉ繝繧ｯ繧偵☆繧頑栢縺代ｋ縺溘ａ縺薙％縺ｧ謐墓拷 + if (m_cEntry.isEnable(nUnit) == FALSE) + goto none; + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + goto none; + + // 繝峨Λ繧､繝也憾諷句叙蠕 + m_cEntry.GetCapacity(nUnit, &cap); + } + } else { + none: + cap.clusters = 4; // 縺ｾ縺｣縺｣縺溘￥蝠城｡後↑縺繝繧ｹ繧茨ｼ + cap.sectors = 64; + cap.bytes = 512; + } + + // 繧ｷ繝輔ヨ謨ｰ險育ｮ + DWORD nSize = 1; + DWORD nShift = 0; + for (;;) { + if (nSize >= cap.sectors) + break; + nSize <<= 1; + nShift++; + } + + // 繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ險育ｮ + // + // 莉･荳九ｮ鬆縺ｫ荳ｦ縺ｹ繧九 + // 繧ｯ繝ｩ繧ｹ繧ｿ0: 譛ｪ菴ｿ逕ｨ + // 繧ｯ繝ｩ繧ｹ繧ｿ1: FAT + // 繧ｯ繝ｩ繧ｹ繧ｿ2: 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ + // 繧ｯ繝ｩ繧ｹ繧ｿ3: 繝繝ｼ繧ｿ鬆伜沺(謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ) + DWORD nFat = cap.sectors; + DWORD nRoot = cap.sectors * 2; + DWORD nData = cap.sectors * 3; + + // DPB險ｭ螳 + pDpb->sector_size = (WORD)cap.bytes; // 1繧ｻ繧ｯ繧ｿ蠖薙ｊ縺ｮ繝舌う繝域焚 + pDpb->cluster_size = + (BYTE)(cap.sectors - 1); // 1繧ｯ繝ｩ繧ｹ繧ｿ蠖薙ｊ縺ｮ繧ｻ繧ｯ繧ｿ謨ｰ - 1 + pDpb->shift = (BYTE)nShift; // 繧ｯ繝ｩ繧ｹ繧ｿ竊偵そ繧ｯ繧ｿ縺ｮ繧ｷ繝輔ヨ謨ｰ + pDpb->fat_sector = (WORD)nFat; // FAT 縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + pDpb->fat_max = 1; // FAT 鬆伜沺縺ｮ蛟区焚 + pDpb->fat_size = (BYTE)cap.sectors; // FAT 縺ｮ蜊繧√ｋ繧ｻ繧ｯ繧ｿ謨ｰ(隍蜀吝繧帝勁縺) + pDpb->file_max = + (WORD)(cap.sectors * cap.bytes / 0x20); // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｫ蜈･繧九ヵ繧｡繧､繝ｫ縺ｮ蛟区焚 + pDpb->data_sector = (WORD)nData; // 繝繝ｼ繧ｿ鬆伜沺縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + pDpb->cluster_max = (WORD)cap.clusters; // 邱上け繝ｩ繧ｹ繧ｿ謨ｰ + 1 + pDpb->root_sector = (WORD)nRoot; // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + pDpb->media = media; // 繝｡繝繧｣繧｢繝舌う繝 + + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $53 - 繧ｻ繧ｯ繧ｿ隱ｭ縺ｿ霎ｼ縺ｿ +/// +/// 繧ｻ繧ｯ繧ｿ縺ｯ逍台ｼｼ逧縺ｫ讒狗ｯ峨＠縺溘ｂ縺ｮ繧剃ｽｿ逕ｨ縺吶ｋ縲 +/// 繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ縺ｯ$200繝舌う繝亥崋螳壹 +// +//--------------------------------------------------------------------------- +int CFileSys::DiskRead(DWORD nUnit, BYTE* pBuffer, DWORD nSector, DWORD nSize) +{ + ASSERT(this); + ASSERT(pBuffer); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝紋ｸ翫〒逋ｺ逕 + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 繧ｻ繧ｯ繧ｿ謨ｰ1莉･螟悶ｮ蝣ｴ蜷医ｯ繧ｨ繝ｩ繝ｼ + if (nSize != 1) + return FS_INVALIDPRM; + + // 繧ｻ繧ｯ繧ｿ諠蝣ｱ迯ｲ蠕 + Human68k::capacity_t cap; + if (m_cEntry.GetCapacityCache(nUnit, &cap) == FALSE) { + // 繝峨Λ繧､繝也憾諷句叙蠕 + m_cEntry.GetCapacity(nUnit, &cap); + } + + // 謫ｬ莨ｼ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｸ縺ｮ繧｢繧ｯ繧ｻ繧ｹ + CHostFiles* pHostFiles = m_cFiles.Search(nSector); + if (pHostFiles) { + // 謫ｬ莨ｼ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧堤函謌 + Human68k::dirent_t* dir = (Human68k::dirent_t*)pBuffer; + memcpy(pBuffer, pHostFiles->GetEntry(), sizeof(*dir)); + memset(pBuffer + sizeof(*dir), 0xE5, 0x200 - sizeof(*dir)); + + // 謫ｬ莨ｼ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ蜀縺ｫ繝輔ぃ繧､繝ｫ螳滉ｽ薙ｒ謖縺呎闘莨ｼ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ繧定ｨ倬鹸 + // 縺ｪ縺翫〕zdsys縺ｧ縺ｯ莉･荳九ｮ蠑上〒隱ｭ縺ｿ霎ｼ縺ｿ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ繧堤ｮ怜ｺ縺励※縺繧九 + // (dirent.cluster - 2) * (dpb.cluster_size + 1) + dpb.data_sector + /// @warning 繝ｪ繝医Ν繧ｨ繝ｳ繝繧｣繧｢繝ｳ蟆ら畑 + dir->cluster = (WORD)(m_nHostSectorCount + 2); // 謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + m_nHostSectorBuffer[m_nHostSectorCount] = nSector; // 謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ縺ｮ謖縺吝ｮ滉ｽ + m_nHostSectorCount++; + m_nHostSectorCount %= XM6_HOST_PSEUDO_CLUSTER_MAX; + + return 0; + } + + // 繧ｯ繝ｩ繧ｹ繧ｿ逡ｪ蜿ｷ縺九ｉ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ繧堤ｮ怜ｺ + DWORD n = nSector - (3 * cap.sectors); + DWORD nMod = 1; + if (cap.sectors) { + // 繝｡繝繧｣繧｢縺悟ｭ伜惠縺励↑縺蝣ｴ蜷医ｯcap.sectors縺0縺ｫ縺ｪ繧九ｮ縺ｧ豕ｨ諢 + nMod = n % cap.sectors; + n /= cap.sectors; + } + + // 繝輔ぃ繧､繝ｫ螳滉ｽ薙∈縺ｮ繧｢繧ｯ繧ｻ繧ｹ + if (nMod == 0 && n < XM6_HOST_PSEUDO_CLUSTER_MAX) { + pHostFiles = m_cFiles.Search(m_nHostSectorBuffer[n]); // 螳滉ｽ薙ｒ讀懃ｴ｢ + if (pHostFiles) { + // 謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ繧堤函謌 + CHostFcb f; + f.SetFilename(pHostFiles->GetPath()); + f.SetMode(Human68k::OP_READ); + if (f.Open() == FALSE) + return FS_INVALIDPRM; + memset(pBuffer, 0, 0x200); + DWORD nResult = f.Read(pBuffer, 0x200); + f.Close(); + if (nResult == (DWORD)-1) + return FS_INVALIDPRM; + + return 0; + } + } + + return FS_INVALIDPRM; +} + +//--------------------------------------------------------------------------- +// +/// $54 - 繧ｻ繧ｯ繧ｿ譖ｸ縺崎ｾｼ縺ｿ +// +//--------------------------------------------------------------------------- +int CFileSys::DiskWrite(DWORD nUnit) +{ + ASSERT(this); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + if (m_cEntry.isWriteProtect(nUnit)) + return FS_FATAL_WRITEPROTECT; + + // 迴ｾ螳溘ｒ遯√″縺､縺代ｋ + return FS_INVALIDPRM; +} + +//--------------------------------------------------------------------------- +// +/// $55 - IOCTRL +// +//--------------------------------------------------------------------------- +int CFileSys::Ioctrl(DWORD nUnit, DWORD nFunction, Human68k::ioctrl_t* pIoctrl) +{ + ASSERT(this); + ASSERT(pIoctrl); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_INVALIDFUNC; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝悶〒mint謫堺ｽ懈凾縺ｫ逋ｽ蟶ｯ繧貞ｺ縺輔↑縺繧医≧謾ｹ濶ｯ + + switch (nFunction) { + case 0: + // 繝｡繝繧｣繧｢繝舌う繝医ｮ迯ｲ蠕 + pIoctrl->media = m_cEntry.GetMediaByte(nUnit); + return 0; + + case 1: + // Human68k莠呈鋤縺ｮ縺溘ａ縺ｮ繝繝溘ｼ + pIoctrl->param = (unsigned long)-1; + return 0; + + case 2: + switch (pIoctrl->param) { + case -1: + // 繝｡繝繧｣繧｢蜀崎ｪ崎ｭ + m_cEntry.isMediaOffline(nUnit); + return 0; + + case 0: + case 1: + // Human68k莠呈鋤縺ｮ縺溘ａ縺ｮ繝繝溘ｼ + return 0; + } + break; + + case -1: + // 蟶ｸ鬧仙愛螳 + memcpy(pIoctrl->buffer, "WindrvXM", 8); + return 0; + + case -2: + // 繧ｪ繝励す繝ｧ繝ｳ險ｭ螳 + SetOption(pIoctrl->param); + return 0; + + case -3: + // 繧ｪ繝励す繝ｧ繝ｳ迯ｲ蠕 + pIoctrl->param = GetOption(); + return 0; + } + + return FS_NOTIOCTRL; +} + +//--------------------------------------------------------------------------- +// +/// $56 - 繝輔Λ繝繧ｷ繝･ +// +//--------------------------------------------------------------------------- +int CFileSys::Flush(DWORD nUnit) +{ + ASSERT(this); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_INVALIDFUNC; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝悶〒mint縺九ｉ繧ｳ繝槭Φ繝峨ｒ螳溯｡後＠謌ｻ繧区凾縺ｫ逋ｽ蟶ｯ繧貞ｺ縺輔↑縺繧医≧謾ｹ濶ｯ + + // 蟶ｸ縺ｫ謌仙粥 + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $57 - 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ +// +//--------------------------------------------------------------------------- +int CFileSys::CheckMedia(DWORD nUnit) +{ + ASSERT(this); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + if (nUnit >= m_nUnits) + return FS_INVALIDFUNC; // 繝ｬ繧ｸ繝･繝ｼ繝蠕後↓辟｡蜉ｹ縺ｪ繝峨Λ繧､繝悶〒mint謫堺ｽ懈凾縺ｫ逋ｽ蟶ｯ繧貞ｺ縺輔↑縺繧医≧謾ｹ濶ｯ + + // 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ + m_cEntry.CleanCache(nUnit); + return 0; +} + +//--------------------------------------------------------------------------- +// +/// $58 - 謗剃ｻ門宛蠕｡ +// +//--------------------------------------------------------------------------- +int CFileSys::Lock(DWORD nUnit) +{ + ASSERT(this); + + // 繝ｦ繝九ャ繝医メ繧ｧ繝繧ｯ + if (nUnit >= DriveMax) + return FS_FATAL_INVALIDUNIT; + ASSERT(nUnit < m_nUnits); + if (nUnit >= m_nUnits) + return FS_FATAL_MEDIAOFFLINE; // 蠢ｵ縺ｮ縺溘ａ + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FS_FATAL_MEDIAOFFLINE; + + // 蟶ｸ縺ｫ謌仙粥 + return 0; +} + +//--------------------------------------------------------------------------- +// +/// 繧ｪ繝励す繝ｧ繝ｳ險ｭ螳 +// +//--------------------------------------------------------------------------- +void CFileSys::SetOption(DWORD nOption) +{ + ASSERT(this); + + // 繧ｪ繝励す繝ｧ繝ｳ險ｭ螳壼､画峩縺ｧ繧ｭ繝｣繝繧ｷ繝･繧ｯ繝ｪ繧｢ + if (m_nOption ^ nOption) + m_cEntry.CleanCache(); + + m_nOption = nOption; + g_nOption = nOption; +} + +//--------------------------------------------------------------------------- +// +/// 繧ｪ繝励す繝ｧ繝ｳ蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +void CFileSys::InitOption(const Human68k::argument_t* pArgument) +{ + ASSERT(this); + ASSERT(pArgument); + + // 繝峨Λ繧､繝匁焚繧貞晄悄蛹 + m_nDrives = 0; + + const BYTE* pp = pArgument->buf; + pp += strlen((const char*)pp) + 1; + + DWORD nOption = m_nOptionDefault; + for (;;) { + ASSERT(pp < pArgument->buf + sizeof(*pArgument)); + const BYTE* p = pp; + BYTE c = *p++; + if (c == '\0') + break; + + DWORD nMode; + if (c == '+') { + nMode = 1; + } else if (c == '-') { + nMode = 0; + } else if (c == '/') { + // 繝繝輔か繝ｫ繝医吶ｼ繧ｹ繝代せ縺ｮ謖螳 + if (m_nDrives < DriveMax) { + p--; + strcpy(m_szBase[m_nDrives], (const char *)p); + m_nDrives++; + } + pp += strlen((const char*)pp) + 1; + continue; + } else { + // 繧ｪ繝励す繝ｧ繝ｳ謖螳壹〒縺ｯ縺ｪ縺縺ｮ縺ｧ谺｡縺ｸ + pp += strlen((const char*)pp) + 1; + continue; + } + + for (;;) { + c = *p++; + if (c == '\0') + break; + + DWORD nBit = 0; + switch (c) { + case 'A': case 'a': nBit = WINDRV_OPT_CONVERT_LENGTH; break; + case 'T': case 't': nBit = WINDRV_OPT_COMPARE_LENGTH; nMode ^= 1; break; + case 'C': case 'c': nBit = WINDRV_OPT_ALPHABET; break; + + case 'E': nBit = WINDRV_OPT_CONVERT_PERIOD; break; + case 'P': nBit = WINDRV_OPT_CONVERT_PERIODS; break; + case 'N': nBit = WINDRV_OPT_CONVERT_HYPHEN; break; + case 'H': nBit = WINDRV_OPT_CONVERT_HYPHENS; break; + case 'X': nBit = WINDRV_OPT_CONVERT_BADCHAR; break; + case 'S': nBit = WINDRV_OPT_CONVERT_SPACE; break; + + case 'e': nBit = WINDRV_OPT_REDUCED_PERIOD; break; + case 'p': nBit = WINDRV_OPT_REDUCED_PERIODS; break; + case 'n': nBit = WINDRV_OPT_REDUCED_HYPHEN; break; + case 'h': nBit = WINDRV_OPT_REDUCED_HYPHENS; break; + case 'x': nBit = WINDRV_OPT_REDUCED_BADCHAR; break; + case 's': nBit = WINDRV_OPT_REDUCED_SPACE; break; + } + + if (nMode) + nOption |= nBit; + else + nOption &= ~nBit; + } + + pp = p; + } + + // 繧ｪ繝励す繝ｧ繝ｳ險ｭ螳 + if (nOption != m_nOption) { + SetOption(nOption); + } +} + +//--------------------------------------------------------------------------- +// +/// 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL CFileSys::FilesVolume(DWORD nUnit, Human68k::files_t* pFiles) +{ + ASSERT(this); + ASSERT(pFiles); + + // 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν蜿門ｾ + TCHAR szVolume[32]; + BOOL bResult = m_cEntry.GetVolumeCache(nUnit, szVolume); + if (bResult == FALSE) { + // 謇句虚繧､繧ｸ繧ｧ繧ｯ繝医□縺ｨ繝｡繝繧｣繧｢繝√ぉ繝繧ｯ繧偵☆繧頑栢縺代ｋ縺溘ａ縺薙％縺ｧ謐墓拷 + if (m_cEntry.isEnable(nUnit) == FALSE) + return FALSE; + + // 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + if (m_cEntry.isMediaOffline(nUnit)) + return FALSE; + + // 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν蜿門ｾ + m_cEntry.GetVolume(nUnit, szVolume); + } + if (szVolume[0] == _T('\0')) + return FALSE; + + pFiles->attr = Human68k::AT_VOLUME; + pFiles->time = 0; + pFiles->date = 0; + pFiles->size = 0; + + CHostFilename fname; + fname.SetHost(szVolume); + fname.ConvertHuman(); + strcpy((char*)pFiles->full, (const char*)fname.GetHuman()); + + return TRUE; +} diff --git a/src/raspberrypi/cfilesystem.h b/src/raspberrypi/cfilesystem.h new file mode 100644 index 00000000..58dabe8e --- /dev/null +++ b/src/raspberrypi/cfilesystem.h @@ -0,0 +1,1157 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ 繝帙せ繝医ヵ繧｡繧､繝ｫ繧ｷ繧ｹ繝繝 ] +// +//--------------------------------------------------------------------------- + +#ifndef cfilesystem_h +#define cfilesystem_h + +//--------------------------------------------------------------------------- +// +// 繧ｹ繝繝ｼ繧ｿ繧ｹ繧ｳ繝ｼ繝牙ｮ夂ｾｩ +// +//--------------------------------------------------------------------------- +#define FS_INVALIDFUNC 0xFFFFFFFF ///< 辟｡蜉ｹ縺ｪ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ繧ｳ繝ｼ繝峨ｒ螳溯｡後＠縺 +#define FS_FILENOTFND 0xFFFFFFFE ///< 謖螳壹＠縺溘ヵ繧｡繧､繝ｫ縺瑚ｦ九▽縺九ｉ縺ｪ縺 +#define FS_DIRNOTFND 0xFFFFFFFD ///< 謖螳壹＠縺溘ョ繧｣繝ｬ繧ｯ繝医Μ縺瑚ｦ九▽縺九ｉ縺ｪ縺 +#define FS_OVEROPENED 0xFFFFFFFC ///< 繧ｪ繝ｼ繝励Φ縺励※縺繧九ヵ繧｡繧､繝ｫ縺悟､壹☆縺弱ｋ +#define FS_CANTACCESS 0xFFFFFFFB ///< 繝繧｣繝ｬ繧ｯ繝医Μ繧繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｯ繧｢繧ｯ繧ｻ繧ｹ荳榊庄 +#define FS_NOTOPENED 0xFFFFFFFA ///< 謖螳壹＠縺溘ワ繝ｳ繝峨Ν縺ｯ繧ｪ繝ｼ繝励Φ縺輔ｌ縺ｦ縺縺ｪ縺 +#define FS_INVALIDMEM 0xFFFFFFF9 ///< 繝｡繝｢繝ｪ邂｡逅鬆伜沺縺檎ｴ螢翫＆繧後◆ +#define FS_OUTOFMEM 0xFFFFFFF8 ///< 螳溯｡後↓蠢隕√↑繝｡繝｢繝ｪ縺後↑縺 +#define FS_INVALIDPTR 0xFFFFFFF7 ///< 辟｡蜉ｹ縺ｪ繝｡繝｢繝ｪ邂｡逅繝昴う繝ｳ繧ｿ繧呈欠螳壹＠縺 +#define FS_INVALIDENV 0xFFFFFFF6 ///< 荳肴ｭ｣縺ｪ迺ｰ蠅繧呈欠螳壹＠縺 +#define FS_ILLEGALFMT 0xFFFFFFF5 ///< 螳溯｡後ヵ繧｡繧､繝ｫ縺ｮ繝輔か繝ｼ繝槭ャ繝医′逡ｰ蟶ｸ +#define FS_ILLEGALMOD 0xFFFFFFF4 ///< 繧ｪ繝ｼ繝励Φ縺ｮ繧｢繧ｯ繧ｻ繧ｹ繝｢繝ｼ繝峨′逡ｰ蟶ｸ +#define FS_INVALIDPATH 0xFFFFFFF3 ///< 繝輔ぃ繧､繝ｫ蜷阪ｮ謖螳壹↓隱､繧翫′縺ゅｋ +#define FS_INVALIDPRM 0xFFFFFFF2 ///< 辟｡蜉ｹ縺ｪ繝代Λ繝｡繝ｼ繧ｿ縺ｧ繧ｳ繝ｼ繝ｫ縺励◆ +#define FS_INVALIDDRV 0xFFFFFFF1 ///< 繝峨Λ繧､繝匁欠螳壹↓隱､繧翫′縺ゅｋ +#define FS_DELCURDIR 0xFFFFFFF0 ///< 繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｯ蜑企勁縺ｧ縺阪↑縺 +#define FS_NOTIOCTRL 0xFFFFFFEF ///< IOCTRL縺ｧ縺阪↑縺繝繝舌う繧ｹ +#define FS_LASTFILE 0xFFFFFFEE ///< 縺薙ｌ莉･荳翫ヵ繧｡繧､繝ｫ縺瑚ｦ九▽縺九ｉ縺ｪ縺 +#define FS_CANTWRITE 0xFFFFFFED ///< 謖螳壹ｮ繝輔ぃ繧､繝ｫ縺ｯ譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪↑縺 +#define FS_DIRALREADY 0xFFFFFFEC ///< 謖螳壹ｮ繝繧｣繝ｬ繧ｯ繝医Μ縺ｯ譌｢縺ｫ逋ｻ骭ｲ縺輔ｌ縺ｦ縺繧 +#define FS_CANTDELETE 0xFFFFFFEB ///< 繝輔ぃ繧､繝ｫ縺後≠繧九ｮ縺ｧ蜑企勁縺ｧ縺阪↑縺 +#define FS_CANTRENAME 0xFFFFFFEA ///< 繝輔ぃ繧､繝ｫ縺後≠繧九ｮ縺ｧ繝ｪ繝阪ｼ繝縺ｧ縺阪↑縺 +#define FS_DISKFULL 0xFFFFFFE9 ///< 繝繧｣繧ｹ繧ｯ縺御ｸ譚ｯ縺ｧ繝輔ぃ繧､繝ｫ縺御ｽ懊ｌ縺ｪ縺 +#define FS_DIRFULL 0xFFFFFFE8 ///< 繝繧｣繝ｬ繧ｯ繝医Μ縺御ｸ譚ｯ縺ｧ繝輔ぃ繧､繝ｫ縺御ｽ懊ｌ縺ｪ縺 +#define FS_CANTSEEK 0xFFFFFFE7 ///< 謖螳壹ｮ菴咲ｽｮ縺ｫ縺ｯ繧ｷ繝ｼ繧ｯ縺ｧ縺阪↑縺 +#define FS_SUPERVISOR 0xFFFFFFE6 ///< 繧ｹ繝ｼ繝代ｼ繝舌う繧ｶ迥ｶ諷九〒繧ｹ繝ｼ繝代ヰ繧､繧ｶ謖螳壹＠縺 +#define FS_THREADNAME 0xFFFFFFE5 ///< 蜷後§繧ｹ繝ｬ繝繝牙錐縺悟ｭ伜惠縺吶ｋ +#define FS_BUFWRITE 0xFFFFFFE4 ///< 繝励Ο繧ｻ繧ｹ髢馴壻ｿ｡縺ｮ繝舌ャ繝輔ぃ縺梧嶌霎ｼ縺ｿ遖∵ｭ｢ +#define FS_BACKGROUND 0xFFFFFFE3 ///< 繝舌ャ繧ｯ繧ｰ繝ｩ繧ｦ繝ｳ繝峨励Ο繧ｻ繧ｹ繧定ｵｷ蜍輔〒縺阪↑縺 +#define FS_OUTOFLOCK 0xFFFFFFE0 ///< 繝ｭ繝繧ｯ鬆伜沺縺瑚ｶｳ繧翫↑縺 +#define FS_LOCKED 0xFFFFFFDF ///< 繝ｭ繝繧ｯ縺輔ｌ縺ｦ縺縺ｦ繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪↑縺 +#define FS_DRIVEOPENED 0xFFFFFFDE ///< 謖螳壹ｮ繝峨Λ繧､繝悶ｯ繝上Φ繝峨Λ縺後が繝ｼ繝励Φ縺輔ｌ縺ｦ縺繧 +#define FS_LINKOVER 0xFFFFFFDD ///< 繧ｷ繝ｳ繝懊Μ繝繧ｯ繝ｪ繝ｳ繧ｯ繝阪せ繝医′16蝗槭ｒ雜縺医◆ +#define FS_FILEEXIST 0xFFFFFFB0 ///< 繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺吶ｋ + +#define FS_FATAL_MEDIAOFFLINE 0xFFFFFFA3 ///< 繝｡繝繧｣繧｢縺悟･縺｣縺ｦ縺縺ｪ縺 +#define FS_FATAL_WRITEPROTECT 0xFFFFFFA2 ///< 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢驕募渚 +#define FS_FATAL_INVALIDCOMMAND 0xFFFFFFA1 ///< 荳肴ｭ｣縺ｪ繧ｳ繝槭Φ繝臥分蜿ｷ +#define FS_FATAL_INVALIDUNIT 0xFFFFFFA0 ///< 荳肴ｭ｣縺ｪ繝ｦ繝九ャ繝育分蜿ｷ + +#define HUMAN68K_PATH_MAX 96 ///< Human68k縺ｮ繝代せ譛螟ｧ髟ｷ + +//=========================================================================== +// +/// Human68k 蜷榊燕遨ｺ髢 +// +//=========================================================================== +namespace Human68k { + /// 繝輔ぃ繧､繝ｫ螻樊ｧ繝薙ャ繝 + enum attribute_t { + AT_READONLY = 0x01, ///< 隱ｭ縺ｿ霎ｼ縺ｿ蟆ら畑螻樊ｧ + AT_HIDDEN = 0x02, ///< 髫縺怜ｱ樊ｧ + AT_SYSTEM = 0x04, ///< 繧ｷ繧ｹ繝繝螻樊ｧ + AT_VOLUME = 0x08, ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν螻樊ｧ + AT_DIRECTORY = 0x10, ///< 繝繧｣繝ｬ繧ｯ繝医Μ螻樊ｧ + AT_ARCHIVE = 0x20, ///< 繧｢繝ｼ繧ｫ繧､繝門ｱ樊ｧ + AT_ALL = 0xFF, ///< 蜈ｨ縺ｦ縺ｮ螻樊ｧ繝薙ャ繝医′1 + }; + + /// 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝 + enum open_t { + OP_READ = 0, ///< 隱ｭ縺ｿ霎ｼ縺ｿ + OP_WRITE = 1, ///< 譖ｸ縺崎ｾｼ縺ｿ + OP_FULL = 2, ///< 隱ｭ縺ｿ譖ｸ縺 + OP_MASK = 0x0F, ///< 蛻､螳夂畑繝槭せ繧ｯ + OP_SHARE_NONE = 0x10, ///< 蜈ｱ譛臥ｦ∵ｭ｢ + OP_SHARE_READ = 0x20, ///< 隱ｭ縺ｿ霎ｼ縺ｿ蜈ｱ譛 + OP_SHARE_WRITE = 0x30, ///< 譖ｸ縺崎ｾｼ縺ｿ蜈ｱ譛 + OP_SHARE_FULL = 0x40, ///< 隱ｭ縺ｿ譖ｸ縺榊ｱ譛 + OP_SHARE_MASK = 0x70, ///< 蜈ｱ譛牙愛螳夂畑繝槭せ繧ｯ + OP_SPECIAL = 0x100, ///< 霎樊嶌繧｢繧ｯ繧ｻ繧ｹ + }; + + /// 繧ｷ繝ｼ繧ｯ遞ｮ鬘 + enum seek_t { + SK_BEGIN = 0, ///< 繝輔ぃ繧､繝ｫ蜈磯ｭ縺九ｉ + SK_CURRENT = 1, ///< 迴ｾ蝨ｨ菴咲ｽｮ縺九ｉ + SK_END = 2, ///< 繝輔ぃ繧､繝ｫ譛ｫ蟆ｾ縺九ｉ + }; + + /// 繝｡繝繧｣繧｢繝舌う繝 + enum media_t { + MEDIA_2DD_10 = 0xE0, ///< 2DD/10繧ｻ繧ｯ繧ｿ + MEDIA_1D_9 = 0xE5, ///< 1D/9繧ｻ繧ｯ繧ｿ + MEDIA_2D_9 = 0xE6, ///< 2D/9繧ｻ繧ｯ繧ｿ + MEDIA_1D_8 = 0xE7, ///< 1D/8繧ｻ繧ｯ繧ｿ + MEDIA_2D_8 = 0xE8, ///< 2D/8繧ｻ繧ｯ繧ｿ + MEDIA_2HT = 0xEA, ///< 2HT + MEDIA_2HS = 0xEB, ///< 2HS + MEDIA_2HDE = 0xEC, ///< 2DDE + MEDIA_1DD_9 = 0xEE, ///< 1DD/9繧ｻ繧ｯ繧ｿ + MEDIA_1DD_8 = 0xEF, ///< 1DD/8繧ｻ繧ｯ繧ｿ + MEDIA_MANUAL = 0xF1, ///< 繝ｪ繝｢繝ｼ繝医ラ繝ｩ繧､繝 (謇句虚繧､繧ｸ繧ｧ繧ｯ繝) + MEDIA_REMOVABLE = 0xF2, ///< 繝ｪ繝｢繝ｼ繝医ラ繝ｩ繧､繝 (繝ｪ繝繝ｼ繝舌ヶ繝ｫ) + MEDIA_REMOTE = 0xF3, ///< 繝ｪ繝｢繝ｼ繝医ラ繝ｩ繧､繝 + MEDIA_DAT = 0xF4, ///< SCSI-DAT + MEDIA_CDROM = 0xF5, ///< SCSI-CDROM + MEDIA_MO = 0xF6, ///< SCSI-MO + MEDIA_SCSI_HD = 0xF7, ///< SCSI-HD + MEDIA_SASI_HD = 0xF8, ///< SASI-HD + MEDIA_RAMDISK = 0xF9, ///< RAM繝繧｣繧ｹ繧ｯ + MEDIA_2HQ = 0xFA, ///< 2HQ + MEDIA_2DD_8 = 0xFB, ///< 2DD/8繧ｻ繧ｯ繧ｿ + MEDIA_2DD_9 = 0xFC, ///< 2DD/9繧ｻ繧ｯ繧ｿ + MEDIA_2HC = 0xFD, ///< 2HC + MEDIA_2HD = 0xFE, ///< 2HD + }; + + /// namests讒矩菴 + struct namests_t { + BYTE wildcard; ///< 繝ｯ繧､繝ｫ繝峨き繝ｼ繝画枚蟄玲焚 + BYTE drive; ///< 繝峨Λ繧､繝也分蜿ｷ + BYTE path[65]; ///< 繝代せ(繧ｵ繝悶ョ繧｣繝ｬ繧ｯ繝医Μ+/) + BYTE name[8]; ///< 繝輔ぃ繧､繝ｫ蜷 (PADDING 0x20) + BYTE ext[3]; ///< 諡｡蠑ｵ蟄 (PADDING 0x20) + BYTE add[10]; ///< 繝輔ぃ繧､繝ｫ蜷崎ｿｽ蜉 (PADDING 0x00) + + // 譁蟄怜怜叙蠕 + void FASTCALL GetCopyPath(BYTE* szPath) const; + ///< 繝代せ蜷榊叙蠕 + void FASTCALL GetCopyFilename(BYTE* szFilename) const; + ///< 繝輔ぃ繧､繝ｫ蜷榊叙蠕 + }; + + /// files讒矩菴 + struct files_t { + BYTE fatr; ///< + 0 讀懃ｴ｢縺吶ｋ螻樊ｧ 隱ｭ霎ｼ蟆ら畑 + // BYTE drive; ///< + 1 繝峨Λ繧､繝也分蜿ｷ 隱ｭ霎ｼ蟆ら畑 + DWORD sector; ///< + 2 繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｻ繧ｯ繧ｿ DOS _FILES蜈磯ｭ繧｢繝峨Ξ繧ｹ縺ｧ莉｣逕ｨ + // WORD cluster; ///< + 6 繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｯ繝ｩ繧ｹ繧ｿ 隧ｳ邏ｰ荳肴 (譛ｪ菴ｿ逕ｨ) + WORD offset; ///< + 8 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 譖ｸ霎ｼ蟆ら畑 + // BYTE name[8]; ///< +10 菴懈･ｭ逕ｨ繝輔ぃ繧､繝ｫ蜷 隱ｭ霎ｼ蟆ら畑 (譛ｪ菴ｿ逕ｨ) + // BYTE ext[3]; ///< +18 菴懈･ｭ逕ｨ諡｡蠑ｵ蟄 隱ｭ霎ｼ蟆ら畑 (譛ｪ菴ｿ逕ｨ) + BYTE attr; ///< +21 繝輔ぃ繧､繝ｫ螻樊ｧ 譖ｸ霎ｼ蟆ら畑 + WORD time; ///< +22 譛邨ょ､画峩譎ょ綾 譖ｸ霎ｼ蟆ら畑 + WORD date; ///< +24 譛邨ょ､画峩譛域律 譖ｸ霎ｼ蟆ら畑 + DWORD size; ///< +26 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ 譖ｸ霎ｼ蟆ら畑 + BYTE full[23]; ///< +30 繝輔Ν繝輔ぃ繧､繝ｫ蜷 譖ｸ霎ｼ蟆ら畑 + }; + + /// FCB讒矩菴 + struct fcb_t { + // BYTE pad00[6]; ///< + 0ｽ+ 5 (譛ｪ菴ｿ逕ｨ) + DWORD fileptr; ///< + 6ｽ+ 9 繝輔ぃ繧､繝ｫ繝昴う繝ｳ繧ｿ + // BYTE pad01[4]; ///< +10ｽ+13 (譛ｪ菴ｿ逕ｨ) + WORD mode; ///< +14ｽ+15 繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝 + // BYTE pad02[16]; ///< +16ｽ+31 (譛ｪ菴ｿ逕ｨ) + // DWORD zero; ///< +32ｽ+35 繧ｪ繝ｼ繝励Φ縺ｮ縺ｨ縺0縺梧嶌縺崎ｾｼ縺ｾ繧後※縺繧 (譛ｪ菴ｿ逕ｨ) + // BYTE name[8]; ///< +36ｽ+43 繝輔ぃ繧､繝ｫ蜷 (PADDING 0x20) (譛ｪ菴ｿ逕ｨ) + // BYTE ext[3]; ///< +44ｽ+46 諡｡蠑ｵ蟄 (PADDING 0x20) (譛ｪ菴ｿ逕ｨ) + BYTE attr; ///< +47 繝輔ぃ繧､繝ｫ螻樊ｧ + // BYTE add[10]; ///< +48ｽ+57 繝輔ぃ繧､繝ｫ蜷崎ｿｽ蜉 (PADDING 0x00) (譛ｪ菴ｿ逕ｨ) + WORD time; ///< +58ｽ+59 譛邨ょ､画峩譎ょ綾 + WORD date; ///< +60ｽ+61 譛邨ょ､画峩譛域律 + // WORD cluster; ///< +62ｽ+63 繧ｯ繝ｩ繧ｹ繧ｿ逡ｪ蜿ｷ (譛ｪ菴ｿ逕ｨ) + DWORD size; ///< +64ｽ+67 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ + // BYTE pad03[28]; ///< +68ｽ+95 FAT繧ｭ繝｣繝繧ｷ繝･ (譛ｪ菴ｿ逕ｨ) + }; + + /// capacity讒矩菴 + struct capacity_t { + WORD freearea; ///< + 0 菴ｿ逕ｨ蜿ｯ閭ｽ縺ｪ繧ｯ繝ｩ繧ｹ繧ｿ謨ｰ + WORD clusters; ///< + 2 邱上け繝ｩ繧ｹ繧ｿ謨ｰ + WORD sectors; ///< + 4 繧ｯ繝ｩ繧ｹ繧ｿ縺ゅ◆繧翫ｮ繧ｻ繧ｯ繧ｿ謨ｰ + WORD bytes; ///< + 6 繧ｻ繧ｯ繧ｿ蠖薙◆繧翫ｮ繝舌う繝域焚 + }; + + /// ctrldrive讒矩菴 + struct ctrldrive_t { + BYTE status; ///< +13 迥ｶ諷 + BYTE pad[3]; ///< Padding + }; + + /// DPB讒矩菴 + struct dpb_t { + WORD sector_size; ///< + 0 1繧ｻ繧ｯ繧ｿ蠖薙ｊ縺ｮ繝舌う繝域焚 + BYTE cluster_size; ///< + 2 1繧ｯ繝ｩ繧ｹ繧ｿ蠖薙ｊ縺ｮ繧ｻ繧ｯ繧ｿ謨ｰ-1 + BYTE shift; ///< + 3 繧ｯ繝ｩ繧ｹ繧ｿ竊偵そ繧ｯ繧ｿ縺ｮ繧ｷ繝輔ヨ謨ｰ + WORD fat_sector; ///< + 4 FAT縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + BYTE fat_max; ///< + 6 FAT鬆伜沺縺ｮ蛟区焚 + BYTE fat_size; ///< + 7 FAT縺ｮ蜊繧√ｋ繧ｻ繧ｯ繧ｿ謨ｰ(隍蜀吝繧帝勁縺) + WORD file_max; ///< + 8 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｫ蜈･繧九ヵ繧｡繧､繝ｫ縺ｮ蛟区焚 + WORD data_sector; ///< +10 繝繝ｼ繧ｿ鬆伜沺縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + WORD cluster_max; ///< +12 邱上け繝ｩ繧ｹ繧ｿ謨ｰ+1 + WORD root_sector; ///< +14 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + // DWORD driverentry; ///< +16 繝繝舌う繧ｹ繝峨Λ繧､繝舌∈縺ｮ繝昴う繝ｳ繧ｿ (譛ｪ菴ｿ逕ｨ) + BYTE media; ///< +20 繝｡繝繧｣繧｢隴伜挨蟄 + // BYTE flag; ///< +21 DPB菴ｿ逕ｨ繝輔Λ繧ｰ (譛ｪ菴ｿ逕ｨ) + }; + + /// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ讒矩菴 + struct dirent_t { + BYTE name[8]; ///< + 0 繝輔ぃ繧､繝ｫ蜷 (PADDING 0x20) + BYTE ext[3]; ///< + 8 諡｡蠑ｵ蟄 (PADDING 0x20) + BYTE attr; ///< +11 繝輔ぃ繧､繝ｫ螻樊ｧ + BYTE add[10]; ///< +12 繝輔ぃ繧､繝ｫ蜷崎ｿｽ蜉 (PADDING 0x00) + WORD time; ///< +22 譛邨ょ､画峩譎ょ綾 + WORD date; ///< +24 譛邨ょ､画峩譛域律 + WORD cluster; ///< +26 繧ｯ繝ｩ繧ｹ繧ｿ逡ｪ蜿ｷ + DWORD size; ///< +28 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ + }; + + /// IOCTRL繝代Λ繝｡繝ｼ繧ｿ蜈ｱ逕ｨ菴 + union ioctrl_t { + BYTE buffer[8]; ///< 繝舌う繝亥腰菴阪〒縺ｮ繧｢繧ｯ繧ｻ繧ｹ + DWORD param; ///< 繝代Λ繝｡繝ｼ繧ｿ(蜈磯ｭ4繝舌う繝) + WORD media; ///< 繝｡繝繧｣繧｢繝舌う繝(蜈磯ｭ2繝舌う繝) + }; + + /// 繧ｳ繝槭Φ繝峨Λ繧､繝ｳ蠑墓焚讒矩菴 + /** + 蜈磯ｭ縺ｫ繝峨Λ繧､繝占ｪ霄ｫ縺ｮ繝代せ縺悟性縺ｾ繧後ｋ縺溘ａHUMAN68K_PATH_MAX莉･荳翫ｮ繧ｵ繧､繧ｺ縺ｫ縺吶ｋ縲 + */ + struct argument_t { + BYTE buf[256]; ///< 繧ｳ繝槭Φ繝峨Λ繧､繝ｳ蠑墓焚 + }; +} + +/// FILES逕ｨ繝舌ャ繝輔ぃ蛟区焚 +/** +騾壼ｸｸ縺ｯ謨ｰ蛟九〒蜊∝縺縺後？uman68k縺ｮ隍謨ｰ縺ｮ繝励Ο繧ｻ繧ｹ縺後槭Ν繝√ち繧ｹ繧ｯ縺ｧ蜷梧凾縺ｫ +豺ｱ縺髫主ｱ､縺ｫ貂｡縺｣縺ｦ菴懈･ｭ縺吶ｋ譎ゅ↑縺ｩ縺ｯ縺薙ｮ蛟､繧貞｢励ｄ縺吝ｿ隕√′縺ゅｋ縲 + +繝繝輔か繝ｫ繝医ｯ20蛟九 +*/ +#define XM6_HOST_FILES_MAX 20 + +/// FCB逕ｨ繝舌ャ繝輔ぃ蛟区焚 +/** +蜷梧凾縺ｫ繧ｪ繝ｼ繝励Φ縺ｧ縺阪ｋ繝輔ぃ繧､繝ｫ謨ｰ縺ｯ縺薙ｌ縺ｧ豎ｺ縺ｾ繧九 + +繝繝輔か繝ｫ繝医ｯ100繝輔ぃ繧､繝ｫ縲 +*/ +#define XM6_HOST_FCB_MAX 100 + +/// 莉ｮ諠ｳ繧ｻ繧ｯ繧ｿ/繧ｯ繝ｩ繧ｹ繧ｿ 譛螟ｧ蛟区焚 +/** +繝輔ぃ繧､繝ｫ螳滉ｽ薙ｮ蜈磯ｭ繧ｻ繧ｯ繧ｿ縺ｸ縺ｮ繧｢繧ｯ繧ｻ繧ｹ縺ｫ蟇ｾ蠢懊☆繧九◆繧√ｮ莉ｮ諠ｳ繧ｻ繧ｯ繧ｿ縺ｮ蛟区焚縲 +lzdsys縺ｫ繧医ｋ繧｢繧ｯ繧ｻ繧ｹ繧定｡後↑縺繧ｹ繝ｬ繝繝峨ｮ謨ｰ繧医ｊ螟壹ａ縺ｫ遒ｺ菫昴☆繧九 + +繝繝輔か繝ｫ繝医ｯ10繧ｻ繧ｯ繧ｿ縲 +*/ +#define XM6_HOST_PSEUDO_CLUSTER_MAX 10 + +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 繧ｭ繝｣繝繧ｷ繝･蛟区焚 +/** +Human68k縺ｯ縲√し繝悶ョ繧｣繝ｬ繧ｯ繝医Μ蜀縺ｧ蜃ｦ逅繧定｡後↑縺髫帙↓繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ +縺ｮ繝√ぉ繝繧ｯ繧貞､ｧ驥上↓逋ｺ陦後☆繧九ゅ％縺ｮ蠢懃ｭ斐ｒ鬮倬溷喧縺吶ｋ縺溘ａ縺ｮ邁｡譏薙く繝｣繝繧ｷ繝･ +縺ｮ蛟区焚繧呈欠螳壹☆繧九ゅく繝｣繝繧ｷ繝･縺ｯ蜷繝峨Λ繧､繝匁ｯ弱↓遒ｺ菫昴＆繧後ｋ縲 +螟壹＞縺ｻ縺ｩ鬮倬溘↓縺ｪ繧九′縲∝｢励ｄ縺励☆縺弱ｋ縺ｨ繝帙せ繝OS蛛ｴ縺ｫ雋諡縺後°縺九ｋ縺ｮ縺ｧ豕ｨ諢上 + +繝繝輔か繝ｫ繝医ｯ16蛟九 +*/ +#define XM6_HOST_DIRENTRY_CACHE_MAX 16 + +/// 1繝繧｣繝ｬ繧ｯ繝医Μ縺ｫ蜿守ｴ阪〒縺阪ｋ繧ｨ繝ｳ繝医Μ縺ｮ譛螟ｧ謨ｰ +/** +繝繧｣繝ｬ繧ｯ繝医Μ蜀縺ｫ繝輔ぃ繧､繝ｫ縺悟､ｧ驥上↓蟄伜惠縺吶ｋ縺ｨ縲∝ｽ捺凾縺ｮ繧｢繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ縺 +諠ｳ螳壹＠縺ｦ縺縺ｪ縺螟ｧ驥上ｮ繝繝ｼ繧ｿ繧定ｿ斐＠縺ｦ縺励∪縺縺薙→縺ｫ縺ｪ繧九ゅい繝励Μ縺ｫ繧医▲縺ｦ縺ｯ +荳驛ｨ縺励°隱崎ｭ倥＆繧後↑縺九▲縺溘ｊ縲騾溷ｺｦ縺悟､ｧ蟷縺ｫ菴惹ｸ九＠縺溘ｊ縲√Γ繝｢繝ｪ荳崎ｶｳ縺ｧ蛛懈ｭ｢ +縺吶ｋ縺ｪ縺ｩ縺ｮ蜊ｱ髯ｺ諤ｧ縺悟ｭ伜惠縺吶ｋ縲ゅ％縺ｮ縺溘ａ荳企剞繧定ｨｭ螳壹☆繧九％縺ｨ縺ｧ蟇ｾ蜃ｦ縺吶ｋ縲 +萓九∴縺ｰ縺ｨ縺ゅｋ繝輔ぃ繧､繝ｩ縺ｮ蝣ｴ蜷医2560繝輔ぃ繧､繝ｫ縺御ｸ企剞縺ｨ縺ｪ縺｣縺ｦ縺繧九ゅ％縺ｮ謨ｰ繧 +荳縺､縺ｮ逶ｮ螳峨→縺吶ｋ縺ｮ縺瑚憶縺縲 + +繝繝輔か繝ｫ繝医ｯ邏6荳繧ｨ繝ｳ繝医Μ縲(FAT縺ｮ繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｧ縺ｮ荳企剞蛟､) +*/ +#define XM6_HOST_DIRENTRY_FILE_MAX 65535 + +/// 繝輔ぃ繧､繝ｫ蜷阪ｮ驥崎､髯､螟悶ヱ繧ｿ繝ｼ繝ｳ縺ｮ譛螟ｧ謨ｰ +/** +Human68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｯ縲√帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ蜷咲ｧｰ繧偵ｂ縺ｨ縺ｫ閾ｪ +蜍慕函謌舌＆繧後ｋ縺後？uman68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｈ繧翫ｂ繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｮ蜷 +遘ｰ縺ｮ縺ｻ縺縺碁聞縺縺溘ａ縲∝酔蜷阪ｮ繝輔ぃ繧､繝ｫ蜷阪′逕滓舌＆繧後※縺励∪縺蜿ｯ閭ｽ諤ｧ縺後≠繧九 +縺昴ｮ譎ゅ？uman68k蛛ｴ縺九ｉ繝輔ぃ繧､繝ｫ蜷阪ｒ蛹ｺ蛻･縺ｧ縺阪ｋ繧医≧縺ｫ縺吶ｋ縺溘ａ縲仝indrvXM +迢ｬ閾ｪ縺ｮ蜻ｽ蜷崎ｦ丞援縺ｫ蠕薙▲縺ｦ蛻･蜷阪ｒ逕滓舌＠縺ｦ隗｣豎ｺ縺励※縺繧九 +逅隲紋ｸ翫ｯ邏6蜊荳(36縺ｮ5荵)騾壹ｊ縺ｮ蛻･蜷阪ｒ逕滓舌〒縺阪ｋ譁ｹ蠑上ｒ蜿悶▲縺ｦ縺繧九′縲∝ｮ +髫帙↓縺ｯ謨ｰ逋ｾ繝代ち繝ｼ繝ｳ莉･荳翫ｮ驥崎､蛻､螳壹′逋ｺ逕溘☆繧九→蜃ｦ逅縺ｫ譎る俣縺後°縺九▲縺ｦ縺励∪ +縺縺溘ａ縲驥崎､縺ｮ荳企剞繧定ｨｭ螳壹☆繧九％縺ｨ縺ｧ騾溷ｺｦ繧堤ｶｭ謖√☆繧九ょｸｸ隴倡噪縺ｪ驕狗畑縺ｧ縺ゅｌ +縺ｰ縲∽ｻ｣譖ｿ蜷阪ｯ謨ｰ繝代ち繝ｼ繝ｳ繧ゅ≠繧後ｰ蜊∝驕狗畑縺ｧ縺阪ｋ縺ｯ縺壹〒縺ゅｊ縲√％縺ｮ蛟､繧貞庄閭ｽ +縺ｪ髯舌ｊ蟆上＆縺蛟､縺ｫ縺吶ｋ縺薙→縺ｧ繝代ヵ繧ｩ繝ｼ繝槭Φ繧ｹ縺ｮ謾ｹ蝟縺梧悄蠕縺ｧ縺阪ｋ縲 +縺薙ｮ蛟区焚繧定ｶ縺医ｋ繝輔ぃ繧､繝ｫ蜷阪′驥崎､縺励※縺励∪縺｣縺溷ｴ蜷医ｯ縲∝酔蜷阪ｮ繧ｨ繝ｳ繝医Μ縺 +隍謨ｰ逕滓舌＆繧後ｋ縲ゅ％縺ｮ蝣ｴ蜷医√ヵ繧｡繧､繝ｫ荳隕ｧ縺ｧ縺ｯ隕九∴繧九′繝輔ぃ繧､繝ｫ蜷阪〒謖螳壹☆ +繧九→譛蛻昴ｮ繧ｨ繝ｳ繝医Μ縺ｮ縺ｿ謇ｱ縺医ｋ迥ｶ諷九→縺ｪ繧九 + +繝繝輔か繝ｫ繝医ｯ36繝代ち繝ｼ繝ｳ縲 +*/ +#define XM6_HOST_FILENAME_PATTERN_MAX 36 + +/// 繝輔ぃ繧､繝ｫ蜷埼崎､髦ｲ豁｢繝槭ｼ繧ｯ +/** +繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪→Human68k蛛ｴ繝輔ぃ繧､繝ｫ蜷阪ｮ蜷咲ｧｰ縺ｮ蛹ｺ蛻･繧偵▽縺代ｋ縺ｨ縺阪↓ +菴ｿ縺譁蟄励ゅさ繝槭Φ繝峨す繧ｧ繝ｫ遲峨ｮ繧ｨ繧ｹ繧ｱ繝ｼ繝玲枚蟄励→驥阪↑繧峨↑縺繧ゅｮ繧帝∈縺ｶ縺ｨ蜷峨 + +繝繝輔か繝ｫ繝医ｯ縲掘縲阪 +*/ +#define XM6_HOST_FILENAME_MARK '@' + +/// WINDRV蜍穂ｽ懊ヵ繝ｩ繧ｰ +/** +騾壼ｸｸ縺ｯ0縺ｫ縺吶ｋ縲ゅヵ繧｡繧､繝ｫ蜑企勁縺ｫOS縺ｮ縺斐∩邂ｱ讖溯ｽ繧貞茜逕ｨ縺吶ｋ蝣ｴ蜷医ｯ1縺ｫ縺吶ｋ縲 +縺昴ｌ莉･螟悶ｮ蛟､縺ｯ蟆譚･縺ｮ縺溘ａ縺ｮ莠育ｴ縺ｨ縺吶ｋ縲 +蜀驛ｨ蜍穂ｽ懊ヵ繝ｩ繧ｰ縺ｨ繝｡繝繧｣繧｢繝舌う繝亥⊃陬縺ｪ縺ｩ繧定ｦ玖ｶ翫＠縺溷ｰ譚･縺ｮ諡｡蠑ｵ逕ｨ縲 +*/ +enum { + WINDRV_OPT_REMOVE = 0x00000001, + ///< Bit 0: 繝輔ぃ繧､繝ｫ蜑企勁蜃ｦ逅 0:逶ｴ謗･ 1:縺斐∩邂ｱ + WINDRV_OPT_ALPHABET = 0x00000020, + ///< Bit 5: 繝輔ぃ繧､繝ｫ蜷肴ｯ碑ｼ Alphabet蛹ｺ蛻･ 0:縺ｪ縺 1:縺ゅｊ 0:-C 1:+C + WINDRV_OPT_COMPARE_LENGTH = 0x00000040, + ///< Bit 6: 繝輔ぃ繧､繝ｫ蜷肴ｯ碑ｼ 譁蟄玲焚(譛ｪ螳溯｣) 0:18+3 1:8+3 0:+T 1:-T + WINDRV_OPT_CONVERT_LENGTH = 0x00000080, + ///< Bit 7: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 譁蟄玲焚 0:18+3 1:8+3 0:-A 1:+A + + WINDRV_OPT_CONVERT_SPACE = 0x00000100, + ///< Bit 8: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 繧ｹ繝壹ｼ繧ｹ 0:縺ｪ縺 1:'_' + WINDRV_OPT_CONVERT_BADCHAR = 0x00000200, + ///< Bit 9: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 辟｡蜉ｹ縺ｪ譁蟄 0:縺ｪ縺 1:'_' + WINDRV_OPT_CONVERT_HYPHENS = 0x00000400, + ///< Bit10: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 荳ｭ髢薙ｮ繝上う繝輔Φ 0:縺ｪ縺 1:'_' + WINDRV_OPT_CONVERT_HYPHEN = 0x00000800, + ///< Bit11: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 蜈磯ｭ縺ｮ繝上う繝輔Φ 0:縺ｪ縺 1:'_' + WINDRV_OPT_CONVERT_PERIODS = 0x00001000, + ///< Bit12: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 荳ｭ髢薙ｮ繝斐Μ繧ｪ繝 0:縺ｪ縺 1:'_' + WINDRV_OPT_CONVERT_PERIOD = 0x00002000, + ///< Bit13: 繝輔ぃ繧､繝ｫ蜷榊､画鋤 蜈磯ｭ縺ｮ繝斐Μ繧ｪ繝 0:縺ｪ縺 1:'_' + + WINDRV_OPT_REDUCED_SPACE = 0x00010000, + ///< Bit16: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 繧ｹ繝壹ｼ繧ｹ 0:縺ｪ縺 1:遏ｭ邵ｮ + WINDRV_OPT_REDUCED_BADCHAR = 0x00020000, + ///< Bit17: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 辟｡蜉ｹ縺ｪ譁蟄 0:縺ｪ縺 1:遏ｭ邵ｮ + WINDRV_OPT_REDUCED_HYPHENS = 0x00040000, + ///< Bit18: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 荳ｭ髢薙ｮ繝上う繝輔Φ 0:縺ｪ縺 1:遏ｭ邵ｮ + WINDRV_OPT_REDUCED_HYPHEN = 0x00080000, + ///< Bit19: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 蜈磯ｭ縺ｮ繝上う繝輔Φ 0:縺ｪ縺 1:遏ｭ邵ｮ + WINDRV_OPT_REDUCED_PERIODS = 0x00100000, + ///< Bit20: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 荳ｭ髢薙ｮ繝斐Μ繧ｪ繝 0:縺ｪ縺 1:遏ｭ邵ｮ + WINDRV_OPT_REDUCED_PERIOD = 0x00200000, + ///< Bit21: 繝輔ぃ繧､繝ｫ蜷咲洒邵ｮ 蜈磯ｭ縺ｮ繝斐Μ繧ｪ繝 0:縺ｪ縺 1:遏ｭ邵ｮ + + // Bit24ｽ30 繝輔ぃ繧､繝ｫ驥崎､髦ｲ豁｢繝槭ｼ繧ｯ 0:閾ｪ蜍 1ｽ127:譁蟄 +}; + +/// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝蜍穂ｽ懊ヵ繝ｩ繧ｰ +/** +騾壼ｸｸ縺ｯ0縺ｫ縺吶ｋ縲ゅΜ繝ｼ繝峨が繝ｳ繝ｪ繝ｼ縺ｧ繝槭え繝ｳ繝医＠縺溘＞繝峨Λ繧､繝悶ｮ蝣ｴ蜷医ｯ1縺ｫ縺吶ｋ縲 +縺昴ｌ莉･螟悶ｮ蛟､縺ｯ蟆譚･縺ｮ縺溘ａ縺ｮ莠育ｴ縺ｨ縺吶ｋ縲 +蛻､螳壹′蝗ｰ髮｣縺ｪ繝繝舌う繧ｹ(閾ｪ菴弑SB繧ｹ繝医Ξ繝ｼ繧ｸ縺ｨ縺)縺ｮ縺溘ａ縺ｮ菫晞匱逕ｨ縲 +*/ +enum { + FSFLAG_WRITE_PROTECT = 0x00000001, + ///< Bit0: 蠑ｷ蛻ｶ譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢ + FSFLAG_REMOVABLE = 0x00000002, + ///< Bit1: 蠑ｷ蛻ｶ繝ｪ繝繝ｼ繝舌ヶ繝ｫ繝｡繝繧｣繧｢ + FSFLAG_MANUAL = 0x00000004, + ///< Bit2: 蠑ｷ蛻ｶ謇句虚繧､繧ｸ繧ｧ繧ｯ繝 +}; + +//=========================================================================== +// +/// 縺ｾ繧九▲縺ｨ繝ｪ繝ｳ繧ｰ繝ｪ繧ｹ繝 +/// +/// 蜈磯ｭ(root.next)縺梧怙繧よ眠縺励＞繧ｪ繝悶ず繧ｧ繧ｯ繝医 +/// 譛ｫ蟆ｾ(root.prev)縺梧怙繧ょ商縺/譛ｪ菴ｿ逕ｨ繧ｪ繝悶ず繧ｧ繧ｯ繝医 +/// 繧ｳ繝ｼ繝牙柑邇霑ｽ豎ゅｮ縺溘ａ縲‥elete譎ゅｯ蠢縺壹昴う繝ｳ繧ｿ繧偵い繝繝励く繝｣繧ｹ繝医☆繧九％縺ｨ縲 +// +//=========================================================================== +class CRing { +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CRing() { Init(); } + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + ~CRing() { Remove(); } + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final + void Init() { ASSERT(this); next = prev = this; } + ///< 蛻晄悄蛹 + + CRing* Next() const { ASSERT(this); return next; } + ///< 谺｡縺ｮ隕∫ｴ繧貞叙蠕 + CRing* Prev() const { ASSERT(this); return prev; } + ///< 蜑阪ｮ隕∫ｴ繧貞叙蠕 + + void Insert(CRing* pRoot) + { + ASSERT(this); + // 隧ｲ蠖薙が繝悶ず繧ｧ繧ｯ繝医ｒ蛻繧企屬縺 + ASSERT(next); + ASSERT(prev); + next->prev = prev; + prev->next = next; + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ謖ｿ蜈･ + ASSERT(pRoot); + ASSERT(pRoot->next); + next = pRoot->next; + prev = pRoot; + pRoot->next->prev = this; + pRoot->next = this; + } + ///< 繧ｪ繝悶ず繧ｧ繧ｯ繝亥繧企屬縺 & 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ謖ｿ蜈･ + + void InsertTail(CRing* pRoot) + { + ASSERT(this); + // 隧ｲ蠖薙が繝悶ず繧ｧ繧ｯ繝医ｒ蛻繧企屬縺 + ASSERT(next); + ASSERT(prev); + next->prev = prev; + prev->next = next; + // 繝ｪ繝ｳ繧ｰ譛ｫ蟆ｾ縺ｸ謖ｿ蜈･ + ASSERT(pRoot); + ASSERT(pRoot->prev); + next = pRoot; + prev = pRoot->prev; + pRoot->prev->next = this; + pRoot->prev = this; + } + ///< 繧ｪ繝悶ず繧ｧ繧ｯ繝亥繧企屬縺 & 繝ｪ繝ｳ繧ｰ譛ｫ蟆ｾ縺ｸ謖ｿ蜈･ + + void InsertRing(CRing* pRoot) + { + ASSERT(this); + if (next == prev) return; + + // 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ謖ｿ蜈･ + ASSERT(pRoot); + ASSERT(pRoot->next); + pRoot->next->prev = prev; + prev->next = pRoot->next; + pRoot->next = next; + next->prev = pRoot; + + // 閾ｪ蛻閾ｪ霄ｫ繧堤ｩｺ縺ｫ縺吶ｋ + next = prev = this; + } + ///< 閾ｪ蛻莉･螟悶ｮ繧ｪ繝悶ず繧ｧ繧ｯ繝亥繧企屬縺 & 繝ｪ繝ｳ繧ｰ蜈磯ｭ縺ｸ謖ｿ蜈･ + + void Remove() + { + ASSERT(this); + // 隧ｲ蠖薙が繝悶ず繧ｧ繧ｯ繝医ｒ蛻繧企屬縺 + ASSERT(next); + ASSERT(prev); + next->prev = prev; + prev->next = next; + // 螳牙ｨ縺ｮ縺溘ａ閾ｪ蛻閾ｪ霄ｫ繧呈欠縺励※縺翫￥ (菴募ｺｦ蛻繧企屬縺励※繧ょ撫鬘後↑縺) + next = prev = this; + } + ///< 繧ｪ繝悶ず繧ｧ繧ｯ繝亥繧企屬縺 + +private: + CRing* next; ///< 谺｡縺ｮ隕∫ｴ + CRing* prev; ///< 蜑阪ｮ隕∫ｴ +}; + +//=========================================================================== +// +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 繝輔ぃ繧､繝ｫ蜷 +// +//=========================================================================== +class CHostFilename { +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostFilename(); + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + static size_t Offset() { return offsetof(CHostFilename, m_szHost); } + ///< 繧ｪ繝輔そ繝繝井ｽ咲ｽｮ蜿門ｾ + + void SetHost(const TCHAR* szHost); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧定ｨｭ螳 + const TCHAR* GetHost() const { ASSERT(this); return m_szHost; } + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧貞叙蠕 + void ConvertHuman(int nCount = -1); + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧貞､画鋤 + void CopyHuman(const BYTE* szHuman); + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧定､陬ｽ + BOOL isReduce() const; + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ縺悟刈蟾･縺輔ｌ縺溘°隱ｿ譟ｻ + BOOL isCorrect() const { ASSERT(this); return m_bCorrect; } + ///< Human68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷崎ｦ丞援縺ｫ蜷郁ｴ縺励※縺繧九°隱ｿ譟ｻ + const BYTE* GetHuman() const { ASSERT(this); return m_szHuman; } + ///< Human68k繝輔ぃ繧､繝ｫ蜷阪ｒ蜿門ｾ + const BYTE* GetHumanLast() const { ASSERT(this); return m_pszHumanLast; } + ///< Human68k繝輔ぃ繧､繝ｫ蜷阪ｒ蜿門ｾ + const BYTE* GetHumanExt() const { ASSERT(this); return m_pszHumanExt; } + ///< Human68k繝輔ぃ繧､繝ｫ蜷阪ｒ蜿門ｾ + void SetEntryName(); + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + void SetEntryAttribute(BYTE nHumanAttribute) + { ASSERT(this); m_dirHuman.attr = nHumanAttribute; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + void SetEntrySize(DWORD nHumanSize) + { ASSERT(this); m_dirHuman.size = nHumanSize; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + void SetEntryDate(WORD nHumanDate) + { ASSERT(this); m_dirHuman.date = nHumanDate; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + void SetEntryTime(WORD nHumanTime) + { ASSERT(this); m_dirHuman.time = nHumanTime; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + void SetEntryCluster(WORD nHumanCluster) + { ASSERT(this); m_dirHuman.cluster = nHumanCluster; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧定ｨｭ螳 + const Human68k::dirent_t* GetEntry() const { ASSERT(this); return &m_dirHuman; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧貞叙蠕 + BOOL CheckAttribute(DWORD nHumanAttribute) const; + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ螻樊ｧ蛻､螳 + BOOL isSameEntry(const Human68k::dirent_t* pdirHuman) const + { ASSERT(this); ASSERT(pdirHuman); return memcmp(&m_dirHuman, pdirHuman, sizeof(m_dirHuman)) == 0; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ荳閾ｴ蛻､螳 + + // 繝代せ蜷肴桃菴 + static const BYTE* SeparateExt(const BYTE* szHuman); + ///< Human68k繝輔ぃ繧､繝ｫ蜷阪°繧画僑蠑ｵ蟄舌ｒ蛻髮｢ + +private: + static BYTE* CopyName(BYTE* pWrite, const BYTE* pFirst, const BYTE* pLast); + ///< Human68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷崎ｦ∫ｴ繧偵さ繝斐ｼ + + const BYTE* m_pszHumanLast; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜀驛ｨ蜷阪ｮ邨らｫｯ菴咲ｽｮ + const BYTE* m_pszHumanExt; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜀驛ｨ蜷阪ｮ諡｡蠑ｵ蟄蝉ｽ咲ｽｮ + BOOL m_bCorrect; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜀驛ｨ蜷阪′豁｣縺励¢繧後ｰ逵 + BYTE m_szHuman[24]; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜀驛ｨ蜷 + Human68k::dirent_t m_dirHuman; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜈ｨ諠蝣ｱ + TCHAR m_szHost[FILEPATH_MAX]; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮ繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ (蜿ｯ螟蛾聞) +}; + +//=========================================================================== +// +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ 繝代せ蜷 +/// +/// Human68k蛛ｴ縺ｮ繝代せ蜷阪ｯ縲∝ｿ縺壼磯ｭ縺/縺ｧ蟋九∪繧翫∵忰蟆ｾ縺/縺ｧ邨ゅｏ繧九 +/// 繝ｦ繝九ャ繝育分蜿ｷ縺ｯ謖√◆縺ｪ縺縲 +/// 鬮倬溷喧縺ｮ縺溘ａ縲√帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｫ縺ｯ繝吶ｼ繧ｹ繝代せ驛ｨ蛻繧ょ性繧縲 +// +//=========================================================================== +/** @note +縺ｻ縺ｨ繧薙←縺ｮHuman68k縺ｮ繧｢繝励Μ縺ｯ縲√ヵ繧｡繧､繝ｫ縺ｮ譖ｴ譁ｰ遲峨↓繧医▲縺ｦ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ +繝ｳ繝医Μ縺ｫ螟画峩縺檎函縺倥◆髫帙∬ｦｪ繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｯ螟牙喧縺励↑縺繧 +縺ｮ縺ｨ諠ｳ螳壹＠縺ｦ菴懊ｉ繧後※縺繧九 +縺ｨ縺薙ｍ縺後帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｧ縺ｯ隕ｪ繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝 +繧ょ､牙喧縺励※縺励∪縺繧ゅｮ縺御ｸｻ豬√→縺ｪ縺｣縺ｦ縺励∪縺｣縺ｦ縺繧九 + +縺薙ｮ縺溘ａ縲√ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｳ繝斐ｼ遲峨↓縺翫＞縺ｦ縲√い繝励Μ蛛ｴ縺ｯ豁｣遒ｺ縺ｫ繧ｿ繧､繝繧ｹ繧ｿ +繝ｳ繝玲ュ蝣ｱ縺ｪ縺ｩ繧定ｨｭ螳壹＠縺ｦ縺繧九↓繧ゅ°縺九ｏ繧峨★縲∝ｮ溯｡檎ｵ先棡縺ｧ縺ｯ譎ょ綾諠蝣ｱ縺御ｸ頑嶌 +縺阪＆繧後※縺励∪縺縺ｨ縺縺諠ｨ蜉縺瑚ｵｷ縺阪※縺励∪縺縲 + +縺昴％縺ｧ繝繧｣繝ｬ繧ｯ繝医Μ繧ｭ繝｣繝繧ｷ繝･蜀縺ｫFAT繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｮ繧ｨ繝溘Η繝ｬ繝ｼ繧ｷ繝ｧ繝ｳ +讖溯ｽ繧貞ｮ溯｣縺励◆縲ゅ帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ譖ｴ譁ｰ譎ゅ↓繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝玲ュ +蝣ｱ繧貞ｾｩ蜈縺吶ｋ縺薙→縺ｧHuman68k蛛ｴ縺ｮ譛溷ｾ縺吶ｋ邨先棡縺ｨ荳閾ｴ縺輔○繧九 +*/ +class CHostPath: public CRing { + /// 繝｡繝｢繝ｪ邂｡逅逕ｨ + struct ring_t { + CRing r; ///< 蜀迺ｰ + CHostFilename f; ///< 螳滉ｽ + }; + +public: + /// 讀懃ｴ｢逕ｨ繝舌ャ繝輔ぃ + struct find_t { + DWORD count; ///< 讀懃ｴ｢螳溯｡悟屓謨ｰ + 1 (0縺ｮ縺ｨ縺阪ｯ莉･荳九ｮ蛟､縺ｯ辟｡蜉ｹ) + DWORD id; ///< 谺｡蝗樊､懃ｴ｢繧堤ｶ夊｡後☆繧九ヱ繧ｹ縺ｮ繧ｨ繝ｳ繝医Μ隴伜挨ID + const ring_t* pos; ///< 谺｡蝗樊､懃ｴ｢繧堤ｶ夊｡後☆繧倶ｽ咲ｽｮ (隴伜挨ID荳閾ｴ譎) + Human68k::dirent_t entry; ///< 谺｡蝗樊､懃ｴ｢繧堤ｶ夊｡後☆繧九お繝ｳ繝医Μ蜀螳ｹ + + void Clear() { count = 0; } + ///< 蛻晄悄蛹 + }; + + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostPath(); + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + ~CHostPath(); + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final + void Clean(); + ///< 蜀榊茜逕ｨ縺ｮ縺溘ａ縺ｮ蛻晄悄蛹 + + void SetHuman(const BYTE* szHuman); + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧堤峩謗･謖螳壹☆繧 + void SetHost(const TCHAR* szHost); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧堤峩謗･謖螳壹☆繧 + BOOL isSameHuman(const BYTE* szHuman) const; + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧呈ｯ碑ｼ縺吶ｋ + BOOL isSameChild(const BYTE* szHuman) const; + ///< Human68k蛛ｴ縺ｮ蜷咲ｧｰ繧呈ｯ碑ｼ縺吶ｋ + const TCHAR* GetHost() const { ASSERT(this); return m_szHost; } + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｮ迯ｲ蠕 + const CHostFilename* FindFilename(const BYTE* szHuman, DWORD nHumanAttribute = Human68k::AT_ALL) const; + ///< 繝輔ぃ繧､繝ｫ蜷阪ｒ讀懃ｴ｢ + const CHostFilename* FindFilenameWildcard(const BYTE* szHuman, DWORD nHumanAttribute, find_t* pFind) const; + ///< 繝輔ぃ繧､繝ｫ蜷阪ｒ讀懃ｴ｢ (繝ｯ繧､繝ｫ繝峨き繝ｼ繝牙ｯｾ蠢) + BOOL isRefresh(); + ///< 繝輔ぃ繧､繝ｫ螟画峩縺瑚｡後↑繧上ｌ縺溘°遒ｺ隱 + void Refresh(); + ///< 繝輔ぃ繧､繝ｫ蜀肴ｧ区 + void Backup(); + /// 繝帙せ繝亥ｴ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｒ菫晏ｭ + void Restore() const; + /// 繝帙せ繝亥ｴ縺ｮ繧ｿ繧､繝繧ｹ繧ｿ繝ｳ繝励ｒ蠕ｩ蜈 + void Release(); + ///< 譖ｴ譁ｰ + + // CHostEntry縺悟茜逕ｨ縺吶ｋ螟夜ΚAPI + static void InitId() { g_nId = 0; } + ///< 隴伜挨ID逕滓千畑繧ｫ繧ｦ繝ｳ繧ｿ蛻晄悄蛹 + +private: + static ring_t* Alloc(size_t nLength); + ///< 繝輔ぃ繧､繝ｫ蜷埼伜沺遒ｺ菫 + static void Free(ring_t* pRing); + ///< 繝輔ぃ繧､繝ｫ蜷埼伜沺隗｣謾ｾ + static int Compare(const BYTE* pFirst, const BYTE* pLast, const BYTE* pBufFirst, const BYTE* pBufLast); + ///< 譁蟄怜玲ｯ碑ｼ (繝ｯ繧､繝ｫ繝峨き繝ｼ繝牙ｯｾ蠢) + + CRing m_cRing; ///< CHostFilename騾｣邨千畑 + time_t m_tBackup; ///< 譎ょ綾蠕ｩ蜈逕ｨ + BOOL m_bRefresh; ///< 譖ｴ譁ｰ繝輔Λ繧ｰ + DWORD m_nId; ///< 隴伜挨ID (蛟､縺悟､牙喧縺励◆蝣ｴ蜷医ｯ譖ｴ譁ｰ繧呈э蜻ｳ縺吶ｋ) + BYTE m_szHuman[HUMAN68K_PATH_MAX]; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮHuman68k蜀驛ｨ蜷 + TCHAR m_szHost[FILEPATH_MAX]; ///< 隧ｲ蠖薙お繝ｳ繝医Μ縺ｮ繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ + + static DWORD g_nId; ///< 隴伜挨ID逕滓千畑繧ｫ繧ｦ繝ｳ繧ｿ +}; + +//=========================================================================== +// +/// 繝輔ぃ繧､繝ｫ讀懃ｴ｢蜃ｦ逅 +/// +/// Human68k蛛ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｒ蜀驛ｨUnicode縺ｧ蜃ｦ逅縺吶ｋ縺ｮ縺ｯ豁｣逶ｴ繧ｭ繝縺縲ゅ→ +/// 縺縺繧上¢縺ｧ縲∝ｨ縺ｦBYTE縺ｫ螟画鋤縺励※蜃ｦ逅縺吶ｋ縲ょ､画鋤蜃ｦ逅縺ｯ繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ +/// 繝ｳ繝医Μ繧ｭ繝｣繝繧ｷ繝･縺御ｸ謇九↓諡縺縲仝INDRV蛛ｴ縺ｯ縺吶∋縺ｦ繧ｷ繝輔ヨJIS縺ｮ縺ｿ縺ｧ謇ｱ +/// 縺医ｋ繧医≧縺ｫ縺吶ｋ縲 +/// 縺ｾ縺溘？uman68k蛛ｴ蜷咲ｧｰ縺ｯ縲∝ｮ悟ｨ縺ｫ繝吶ｼ繧ｹ繝代せ謖螳壹°繧臥峡遶九＆縺帙ｋ縲 +/// +/// 繝輔ぃ繧､繝ｫ繧呈桶縺逶ｴ蜑阪↓縲√ョ繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧堤函謌舌☆繧九 +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ縺ｮ逕滓仙ｦ逅縺ｯ鬮倥さ繧ｹ繝医ｮ縺溘ａ縲∽ｸ蠎ｦ逕滓舌＠縺溘お繝ｳ繝医Μ縺ｯ +/// 蜿ｯ閭ｽ縺ｪ髯舌ｊ邯ｭ謖√＠縺ｦ菴ｿ縺蝗槭☆縲 +/// +/// 繝輔ぃ繧､繝ｫ讀懃ｴ｢縺ｯ3譁ｹ蠑上ゅ☆縺ｹ縺ｦCHostFiles::Find()縺ｧ蜃ｦ逅縺吶ｋ縲 +/// 1. 繝代せ蜷阪ｮ縺ｿ讀懃ｴ｢ 螻樊ｧ縺ｯ繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ縺ｿ _CHKDIR _CREATE +/// 2. 繝代せ蜷+繝輔ぃ繧､繝ｫ蜷+螻樊ｧ縺ｮ讀懃ｴ｢ _OPEN +/// 3. 繝代せ蜷+繝ｯ繧､繝ｫ繝峨き繝ｼ繝+螻樊ｧ縺ｮ讀懃ｴ｢ _FILES _NFILES +/// 讀懃ｴ｢邨先棡縺ｯ縲√ョ繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ諠蝣ｱ縺ｨ縺励※菫晄戟縺励※縺翫￥縲 +// +//=========================================================================== +class CHostFiles { +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostFiles() { SetKey(0); Init(); } + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + void Init(); + ///< 蛻晄悄蛹 + + void SetKey(DWORD nKey) { ASSERT(this); m_nKey = nKey; } + ///< 讀懃ｴ｢繧ｭ繝ｼ險ｭ螳 + BOOL isSameKey(DWORD nKey) const { ASSERT(this); return m_nKey == nKey; } + ///< 讀懃ｴ｢繧ｭ繝ｼ豈碑ｼ + void SetPath(const Human68k::namests_t* pNamests); + ///< 繝代せ蜷阪ｻ繝輔ぃ繧､繝ｫ蜷阪ｒ蜀驛ｨ縺ｧ逕滓 + BOOL isRootPath() const { return m_szHumanPath[1] == '\0'; } + ///< 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ蛻､螳 + void SetPathWildcard() { m_nHumanWildcard = 1; } + ///< 繝ｯ繧､繝ｫ繝峨き繝ｼ繝峨↓繧医ｋ繝輔ぃ繧､繝ｫ讀懃ｴ｢繧呈怏蜉ｹ蛹 + void SetPathOnly() { m_nHumanWildcard = 0xFF; } + ///< 繝代せ蜷阪ｮ縺ｿ繧呈怏蜉ｹ蛹 + BOOL isPathOnly() const { return m_nHumanWildcard == 0xFF; } + ///< 繝代せ蜷阪ｮ縺ｿ險ｭ螳壹°蛻､螳 + void SetAttribute(DWORD nHumanAttribute) { m_nHumanAttribute = nHumanAttribute; } + ///< 讀懃ｴ｢螻樊ｧ繧定ｨｭ螳 + BOOL Find(DWORD nUnit, class CHostEntry* pEntry); + ///< Human68k蛛ｴ縺ｧ繝輔ぃ繧､繝ｫ繧呈､懃ｴ｢縺励帙せ繝亥ｴ縺ｮ諠蝣ｱ繧堤函謌 + const CHostFilename* Find(CHostPath* pPath); + ///< 繝輔ぃ繧､繝ｫ蜷肴､懃ｴ｢ + void SetEntry(const CHostFilename* pFilename); + ///< Human68k蛛ｴ縺ｮ讀懃ｴ｢邨先棡菫晏ｭ + void SetResult(const TCHAR* szPath); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧定ｨｭ螳 + void AddResult(const TCHAR* szPath); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｫ繝輔ぃ繧､繝ｫ蜷阪ｒ霑ｽ蜉 + void AddFilename(); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｫHuman68k縺ｮ譁ｰ隕上ヵ繧｡繧､繝ｫ蜷阪ｒ霑ｽ蜉 + + const TCHAR* GetPath() const { ASSERT(this); return m_szHostResult; } + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧貞叙蠕 + const Human68k::dirent_t* GetEntry() const { ASSERT(this); return &m_dirHuman; } + ///< Human68k繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ繧貞叙蠕 + DWORD GetAttribute() const { ASSERT(this); return m_dirHuman.attr; } + ///< Human68k螻樊ｧ繧貞叙蠕 + WORD GetDate() const { ASSERT(this); return m_dirHuman.date; } + ///< Human68k譌･莉倥ｒ蜿門ｾ + WORD GetTime() const { ASSERT(this); return m_dirHuman.time; } + ///< Human68k譎ょ綾繧貞叙蠕 + DWORD GetSize() const { ASSERT(this); return m_dirHuman.size; } + ///< Human68k繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ繧貞叙蠕 + const BYTE* GetHumanFilename() const { ASSERT(this); return m_szHumanFilename; } + ///< Human68k繝輔ぃ繧､繝ｫ蜷阪ｒ蜿門ｾ + const BYTE* GetHumanResult() const { ASSERT(this); return m_szHumanResult; } + ///< Human68k繝輔ぃ繧､繝ｫ蜷肴､懃ｴ｢邨先棡繧貞叙蠕 + const BYTE* GetHumanPath() const { ASSERT(this); return m_szHumanPath; } + ///< Human68k繝代せ蜷阪ｒ蜿門ｾ + +private: + DWORD m_nKey; ///< Human68k縺ｮFILES繝舌ャ繝輔ぃ繧｢繝峨Ξ繧ｹ 0縺ｪ繧画悴菴ｿ逕ｨ + DWORD m_nHumanWildcard; ///< Human68k縺ｮ繝ｯ繧､繝ｫ繝峨き繝ｼ繝画ュ蝣ｱ + DWORD m_nHumanAttribute; ///< Human68k縺ｮ讀懃ｴ｢螻樊ｧ + CHostPath::find_t m_findNext; ///< 谺｡蝗樊､懃ｴ｢菴咲ｽｮ諠蝣ｱ + Human68k::dirent_t m_dirHuman; ///< 讀懃ｴ｢邨先棡 Human68k繝輔ぃ繧､繝ｫ諠蝣ｱ + BYTE m_szHumanFilename[24]; ///< Human68k縺ｮ繝輔ぃ繧､繝ｫ蜷 + BYTE m_szHumanResult[24]; ///< 讀懃ｴ｢邨先棡 Human68k繝輔ぃ繧､繝ｫ蜷 + BYTE m_szHumanPath[HUMAN68K_PATH_MAX]; + ///< Human68k縺ｮ繝代せ蜷 + TCHAR m_szHostResult[FILEPATH_MAX]; ///< 讀懃ｴ｢邨先棡 繝帙せ繝亥ｴ縺ｮ繝輔Ν繝代せ蜷 +}; + +//=========================================================================== +// +/// 繝輔ぃ繧､繝ｫ讀懃ｴ｢鬆伜沺 繝槭ロ繝ｼ繧ｸ繝｣ +// +//=========================================================================== +class CHostFilesManager { +public: +#ifdef _DEBUG + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + ~CHostFilesManager(); + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final +#endif // _DEBUG + void Init(); + ///< 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) + void Clean(); + ///< 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + + CHostFiles* Alloc(DWORD nKey); + ///< 遒ｺ菫 + CHostFiles* Search(DWORD nKey); + ///< 讀懃ｴ｢ + void Free(CHostFiles* pFiles); + ///< 隗｣謾ｾ +private: + /// 繝｡繝｢繝ｪ邂｡逅逕ｨ + struct ring_t { + CRing r; ///< 蜀迺ｰ + CHostFiles f; ///< 螳滉ｽ + }; + + CRing m_cRing; ///< CHostFiles騾｣邨千畑 +}; + +//=========================================================================== +// +/// FCB蜃ｦ逅 +// +//=========================================================================== +class CHostFcb { +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostFcb() { SetKey(0); Init(); } + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + ~CHostFcb() { Close(); } + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final + void Init(); + ///< 蛻晄悄蛹 + + void SetKey(DWORD nKey) { ASSERT(this); m_nKey = nKey; } + ///< 讀懃ｴ｢繧ｭ繝ｼ險ｭ螳 + BOOL isSameKey(DWORD nKey) const { ASSERT(this); return m_nKey == nKey; } + ///< 讀懃ｴ｢繧ｭ繝ｼ豈碑ｼ + void SetUpdate() { ASSERT(this); m_bUpdate = TRUE; } + ///< 譖ｴ譁ｰ + BOOL isUpdate() const { ASSERT(this); return m_bUpdate; } + ///< 譖ｴ譁ｰ迥ｶ諷句叙蠕 + BOOL SetMode(DWORD nHumanMode); + ///< 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝峨ｒ險ｭ螳 + void SetFilename(const TCHAR* szFilename); + ///< 繝輔ぃ繧､繝ｫ蜷阪ｒ險ｭ螳 + void SetHumanPath(const BYTE* szHumanPath); + ///< Human68k繝代せ蜷阪ｒ險ｭ螳 + const BYTE* GetHumanPath() const { ASSERT(this); return m_szHumanPath; } + ///< Human68k繝代せ蜷阪ｒ蜿門ｾ + + BOOL Create(DWORD nHumanAttribute, BOOL bForce); + ///< 繝輔ぃ繧､繝ｫ菴懈 + BOOL Open(); + ///< 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + BOOL Rewind(DWORD nOffset); + ///< 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + DWORD Read(BYTE* pBuffer, DWORD nSize); + ///< 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ + DWORD Write(const BYTE* pBuffer, DWORD nSize); + ///< 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ + BOOL Truncate(); + ///< 繝輔ぃ繧､繝ｫ蛻繧願ｩｰ繧 + DWORD Seek(DWORD nOffset, DWORD nHumanSeek); + ///< 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + BOOL TimeStamp(DWORD nHumanTime); + ///< 繝輔ぃ繧､繝ｫ譎ょ綾險ｭ螳 + BOOL Close(); + ///< 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + +private: + DWORD m_nKey; ///< Human68k縺ｮFCB繝舌ャ繝輔ぃ繧｢繝峨Ξ繧ｹ (0縺ｪ繧画悴菴ｿ逕ｨ) + BOOL m_bUpdate; ///< 譖ｴ譁ｰ繝輔Λ繧ｰ + FILE* m_pFile; ///< 繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｪ繝悶ず繧ｧ繧ｯ繝 + const char* m_pszMode; ///< 繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ繝｢繝ｼ繝 + bool m_bFlag; ///< 繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ繝輔Λ繧ｰ + BYTE m_szHumanPath[HUMAN68K_PATH_MAX]; + ///< Human68k縺ｮ繝代せ蜷 + TCHAR m_szFilename[FILEPATH_MAX]; ///< 繝帙せ繝亥ｴ縺ｮ繝輔ぃ繧､繝ｫ蜷 +}; + +//=========================================================================== +// +/// FCB蜃ｦ逅 繝槭ロ繝ｼ繧ｸ繝｣ +// +//=========================================================================== +class CHostFcbManager { +public: +#ifdef _DEBUG + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + ~CHostFcbManager(); + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final +#endif // _DEBUG + void Init(); + ///< 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) + void Clean(); + ///< 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + + CHostFcb* Alloc(DWORD nKey); + ///< 遒ｺ菫 + CHostFcb* Search(DWORD nKey); + ///< 讀懃ｴ｢ + void Free(CHostFcb* p); + ///< 隗｣謾ｾ + +private: + /// 繝｡繝｢繝ｪ邂｡逅逕ｨ + struct ring_t { + CRing r; ///< 蜀迺ｰ + CHostFcb f; ///< 螳滉ｽ + }; + + CRing m_cRing; ///< CHostFcb騾｣邨千畑 +}; + +//=========================================================================== +// +/// 繝帙せ繝亥ｴ繝峨Λ繧､繝 +/// +/// 繝峨Λ繧､繝匁ｯ弱↓蠢隕√↑諠蝣ｱ縺ｮ菫晄戟縺ｫ蟆ょｿｵ縺励∫ｮ｡逅縺ｯCHostEntry縺ｧ陦後↑縺縲 +// +//=========================================================================== +class CHostDrv +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostDrv(); + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + ~CHostDrv(); + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final + void Init(const TCHAR* szBase, DWORD nFlag); + ///< 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔→繝ｭ繝ｼ繝) + + BOOL isWriteProtect() const { ASSERT(this); return m_bWriteProtect; } + ///< 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺具ｼ + BOOL isEnable() const { ASSERT(this); return m_bEnable; } + ///< 繧｢繧ｯ繧ｻ繧ｹ蜿ｯ閭ｽ縺具ｼ + BOOL isMediaOffline(); + ///< 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + BYTE GetMediaByte() const; + ///< 繝｡繝繧｣繧｢繝舌う繝医ｮ蜿門ｾ + DWORD GetStatus() const; + ///< 繝峨Λ繧､繝也憾諷九ｮ蜿門ｾ + void SetEnable(BOOL bEnable); + ///< 繝｡繝繧｣繧｢迥ｶ諷玖ｨｭ螳 + void GetVolume(TCHAR* szLabel); + ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ + BOOL GetVolumeCache(TCHAR* szLabel) const; + ///< 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν繧貞叙蠕 + DWORD GetCapacity(Human68k::capacity_t* pCapacity); + ///< 螳ｹ驥上ｮ蜿門ｾ + BOOL GetCapacityCache(Human68k::capacity_t* pCapacity) const; + ///< 繧ｭ繝｣繝繧ｷ繝･縺九ｉ螳ｹ驥上ｒ蜿門ｾ + + // 繧ｭ繝｣繝繧ｷ繝･謫堺ｽ + void CleanCache(); + ///< 蜈ｨ縺ｦ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ + void CleanCache(const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ + void CleanCacheChild(const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ莉･荳九ｮ繧ｭ繝｣繝繧ｷ繝･繧貞ｨ縺ｦ譖ｴ譁ｰ縺吶ｋ + void DeleteCache(const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､縺吶ｋ + CHostPath* FindCache(const BYTE* szHuman); + ///< 謖螳壹＆繧後◆繝代せ縺後く繝｣繝繧ｷ繝･縺輔ｌ縺ｦ縺繧九°讀懃ｴ｢縺吶ｋ + CHostPath* CopyCache(CHostFiles* pFiles); + ///< 繧ｭ繝｣繝繧ｷ繝･諠蝣ｱ繧貞縺ｫ縲√帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧堤佐蠕励☆繧 + CHostPath* MakeCache(CHostFiles* pFiles); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ縺ｮ讒狗ｯ峨↓蠢隕√↑諠蝣ｱ繧偵☆縺ｹ縺ｦ蜿門ｾ励☆繧 + BOOL Find(CHostFiles* pFiles); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧呈､懃ｴ｢ (繝代せ蜷+繝輔ぃ繧､繝ｫ蜷(逵∫払蜿ｯ)+螻樊ｧ) + +private: + // 繝代せ蜷肴桃菴 + static const BYTE* SeparateCopyFilename(const BYTE* szHuman, BYTE* szBuffer); + ///< Human68k繝輔Ν繝代せ蜷阪°繧牙磯ｭ縺ｮ隕∫ｴ繧貞髮｢繝ｻ繧ｳ繝斐ｼ + + // 謗剃ｻ門宛蠕｡ + void Lock() {} + void Unlock() {} + + /// 繝｡繝｢繝ｪ邂｡逅逕ｨ + struct ring_t { + CRing r; ///< 蜀迺ｰ + CHostPath f; ///< 螳滉ｽ + }; + + BOOL m_bWriteProtect; ///< 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺ｪ繧欝RUE + BOOL m_bEnable; ///< 繝｡繝繧｣繧｢縺悟茜逕ｨ蜿ｯ閭ｽ縺ｪ繧欝RUE + DWORD m_nRing; ///< 繝代せ蜷堺ｿ晄戟謨ｰ + CRing m_cRing; ///< CHostPath騾｣邨千畑 + Human68k::capacity_t m_capCache; ///< 繧ｻ繧ｯ繧ｿ諠蝣ｱ繧ｭ繝｣繝繧ｷ繝･ sectors == 0 縺ｪ繧画悴繧ｭ繝｣繝繧ｷ繝･ + BOOL m_bVolumeCache; ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν隱ｭ縺ｿ霎ｼ縺ｿ貂医∩縺ｪ繧欝RUE + TCHAR m_szVolumeCache[24]; ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν繧ｭ繝｣繝繧ｷ繝･ + TCHAR m_szBase[FILEPATH_MAX]; ///< 繝吶ｼ繧ｹ繝代せ +}; + +//=========================================================================== +// +/// 繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ邂｡逅 +// +//=========================================================================== +class CHostEntry { +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CHostEntry(); + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + ~CHostEntry(); + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ final + void Init(); + ///< 蛻晄悄蛹 (繝峨Λ繧､繝千ｵ霎ｼ縺ｿ譎) + void Clean(); + ///< 隗｣謾ｾ (襍ｷ蜍輔ｻ繝ｪ繧ｻ繝繝域凾) + + // 繧ｭ繝｣繝繧ｷ繝･謫堺ｽ + void CleanCache(); + ///< 蜈ｨ縺ｦ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ + void CleanCache(DWORD nUnit); + ///< 謖螳壹＆繧後◆繝ｦ繝九ャ繝医ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ + void CleanCache(DWORD nUnit, const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧呈峩譁ｰ縺吶ｋ + void CleanCacheChild(DWORD nUnit, const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ莉･荳九ｮ繧ｭ繝｣繝繧ｷ繝･繧貞ｨ縺ｦ譖ｴ譁ｰ縺吶ｋ + void DeleteCache(DWORD nUnit, const BYTE* szHumanPath); + ///< 謖螳壹＆繧後◆繝代せ縺ｮ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､縺吶ｋ + BOOL Find(DWORD nUnit, CHostFiles* pFiles); + ///< 繝帙せ繝亥ｴ縺ｮ蜷咲ｧｰ繧呈､懃ｴ｢ (繝代せ蜷+繝輔ぃ繧､繝ｫ蜷(逵∫払蜿ｯ)+螻樊ｧ) + void ShellNotify(DWORD nEvent, const TCHAR* szPath); + ///< 繝帙せ繝亥ｴ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝迥ｶ諷句､牙喧騾夂衍 + + // 繝峨Λ繧､繝悶が繝悶ず繧ｧ繧ｯ繝域桃菴 + void SetDrv(DWORD nUnit, CHostDrv* pDrv); + ///< 繝峨Λ繧､繝冶ｨｭ螳 + BOOL isWriteProtect(DWORD nUnit) const; + ///< 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺具ｼ + BOOL isEnable(DWORD nUnit) const; + ///< 繧｢繧ｯ繧ｻ繧ｹ蜿ｯ閭ｽ縺具ｼ + BOOL isMediaOffline(DWORD nUnit); + ///< 繝｡繝繧｣繧｢繝√ぉ繝繧ｯ + BYTE GetMediaByte(DWORD nUnit) const; + ///< 繝｡繝繧｣繧｢繝舌う繝医ｮ蜿門ｾ + DWORD GetStatus(DWORD nUnit) const; + ///< 繝峨Λ繧､繝也憾諷九ｮ蜿門ｾ + void GetVolume(DWORD nUnit, TCHAR* szLabel); + ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν縺ｮ蜿門ｾ + BOOL GetVolumeCache(DWORD nUnit, TCHAR* szLabel) const; + ///< 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν繧貞叙蠕 + DWORD GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity); + ///< 螳ｹ驥上ｮ蜿門ｾ + BOOL GetCapacityCache(DWORD nUnit, Human68k::capacity_t* pCapacity) const; + ///< 繧ｭ繝｣繝繧ｷ繝･縺九ｉ繧ｯ繝ｩ繧ｹ繧ｿ繧ｵ繧､繧ｺ繧貞叙蠕 + + /// 螳壽焚 + enum { + DriveMax = 10 ///< 繝峨Λ繧､繝匁怙螟ｧ蛟呵｣懈焚 + }; + +private: + CHostDrv* m_pDrv[DriveMax]; ///< 繝帙せ繝亥ｴ繝峨Λ繧､繝悶が繝悶ず繧ｧ繧ｯ繝 + DWORD m_nTimeout; ///< 譛蠕後↓繧ｿ繧､繝繧｢繧ｦ繝医メ繧ｧ繝繧ｯ繧定｡後↑縺｣縺滓凾蛻ｻ +}; + +//=========================================================================== +// +/// 繝帙せ繝亥ｴ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝 +// +//=========================================================================== +/** @note +迴ｾ蝨ｨ縺ｮ隕玖ｧ｣縲 + +XM6縺ｮ險ｭ險域晄Φ縺ｨ縺ｯ蜿阪☆繧九′縲…lass Windrv縺ｾ縺溘ｯclass CWindrv縺ｫ逶ｴ謗･ +class CFileSys縺ｸ縺ｮ繝昴う繝ｳ繧ｿ繧呈戟縺溘○繧区婿豕輔ｒ讓｡邏｢縺吶ｋ縺ｹ縺阪〒縺ゅｋ縲 +縺薙ｌ縺ｫ繧医ｊ縲∽ｻ･荳九ｮ繝｡繝ｪ繝繝医′蠕励ｉ繧後ｋ縲 + +繝｡繝ｪ繝繝医◎縺ｮ1縲 +繧ｳ繝槭Φ繝峨ワ繝ｳ繝峨Λ縺ｮ螟ｧ驥上ｮ繝｡繧ｽ繝繝臥ｾ､繧剃ｸ繝ｶ謇縺ｧ髮荳ｭ邂｡逅縺ｧ縺阪ｋ縲 +繧ｳ繝槭Φ繝峨ワ繝ｳ繝峨Λ縺ｯ繝帙せ繝亥ｴ縺ｮ莉墓ｧ伜､画峩縺ｪ縺ｩ縺ｮ隕∝屏縺ｫ繧医▲縺ｦ豼縺励￥螟牙喧縺吶ｋ +蜿ｯ閭ｽ諤ｧ縺碁ｫ倥＞縺溘ａ縲√Γ繧ｽ繝繝峨ｮ霑ｽ蜉蜑企勁繧蠑墓焚縺ｮ螟画峩縺ｪ縺ｩ縺ｮ繝｡繝ｳ繝繝翫Φ繧ｹ縺 +螟ｧ蟷縺ｫ讌ｽ縺ｫ縺ｪ繧九 + +繝｡繝ｪ繝繝医◎縺ｮ2縲 +莉ｮ諠ｳ髢｢謨ｰ縺ｮ繝繝ｼ繝悶Ν逕滓舌ｻ蜿らｧ蜃ｦ逅縺ｫ髢｢縺吶ｋ蜃ｦ逅繧ｳ繝ｼ繝峨ｒ鬧騾舌〒縺阪ｋ縲 +XM6縺ｧ縺ｯ隍謨ｰ縺ｮ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ蜷梧凾縺ｫ菴ｿ縺繧医≧縺ｪ螳溯｣縺ｯ +縺ゅｊ縺医↑縺縲ゅ▽縺ｾ繧翫ヵ繧｡繧､繝ｫ繧ｷ繧ｹ繝繝繧ｪ繝悶ず繧ｧ繧ｯ繝医↓繝昴Μ繝｢繝ｼ繝輔ぅ繧ｺ繝縺ｯ +縺ｾ縺｣縺溘￥蠢隕√↑縺縺ｩ縺薙ｍ縺九√◆縺繧ｯ繝ｭ繝繧ｯ縺ｮ辟｡鬧縺ｨ縺ｪ縺｣縺ｦ縺繧九□縺代〒縺ゅｋ縲 + +隧ｦ縺励↓螟峨∴縺ｦ縺ｿ縺溘ょｮ滄圀蜉ｹ邇荳翫′縺｣縺溘 +windrv.h蜀縺ｮFILESYS_FAST_STRUCTURE縺ｮ蛟､繧貞､峨∴縺ｦ繧ｳ繝ｳ繝代う繝ｩ縺ｮ蜷舌￥繧ｽ繝ｼ繧ｹ +繧呈ｯ碑ｼ縺吶ｌ縺ｰ荳逶ｮ迸ｭ辟ｶ縲ゆｽ墓腐遘√′縺薙ｓ縺ｪ髟ｷ譁繧呈嶌縺薙≧縺ｨ諤昴▲縺溘ｮ縺九ｒ逅隗｣縺ｧ +縺阪ｋ縺ｯ縺壹 + +荳譁ｹ繝ｭ繧ｷ繧｢縺ｯclass CWindrv蜀縺ｫclass CFileSys繧堤峩謗･險ｭ鄂ｮ縺励◆縲 +(譛ｬ蠖薙ｯclass CHost繧貞ｻ豁｢縺励※逶ｴ謗･鄂ｮ縺阪◆縺窶ｦ窶ｦ濶ｯ縺譁ｹ豕輔ｯ縺ｪ縺繧ゅｮ縺銀ｦ窶ｦ) +*/ +class CFileSys +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CFileSys(); + ///< 繝繝輔か繝ｫ繝医さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~CFileSys() {}; + ///< 繝繧ｹ繝医Λ繧ｯ繧ｿ + + // 蛻晄悄蛹悶ｻ邨ゆｺ + void Reset(); + ///< 繝ｪ繧ｻ繝繝 (蜈ｨ繧ｯ繝ｭ繝ｼ繧ｺ) + void Init(); + ///< 蛻晄悄蛹 (繝繝舌う繧ｹ襍ｷ蜍輔→繝ｭ繝ｼ繝) + + // 繧ｳ繝槭Φ繝峨ワ繝ｳ繝峨Λ + DWORD InitDevice(const Human68k::argument_t* pArgument); + ///< $40 - 繝繝舌う繧ｹ襍ｷ蜍 + int CheckDir(DWORD nUnit, const Human68k::namests_t* pNamests); + ///< $41 - 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ + int MakeDir(DWORD nUnit, const Human68k::namests_t* pNamests); + ///< $42 - 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + int RemoveDir(DWORD nUnit, const Human68k::namests_t* pNamests); + ///< $43 - 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 + int Rename(DWORD nUnit, const Human68k::namests_t* pNamests, const Human68k::namests_t* pNamestsNew); + ///< $44 - 繝輔ぃ繧､繝ｫ蜷榊､画峩 + int Delete(DWORD nUnit, const Human68k::namests_t* pNamests); + ///< $45 - 繝輔ぃ繧､繝ｫ蜑企勁 + int Attribute(DWORD nUnit, const Human68k::namests_t* pNamests, DWORD nHumanAttribute); + ///< $46 - 繝輔ぃ繧､繝ｫ螻樊ｧ蜿門ｾ/險ｭ螳 + int Files(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::files_t* pFiles); + ///< $47 - 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + int NFiles(DWORD nUnit, DWORD nKey, Human68k::files_t* pFiles); + ///< $48 - 繝輔ぃ繧､繝ｫ谺｡讀懃ｴ｢ + int Create(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb, DWORD nHumanAttribute, BOOL bForce); + ///< $49 - 繝輔ぃ繧､繝ｫ菴懈 + int Open(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb); + ///< $4A - 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + int Close(DWORD nUnit, DWORD nKey, Human68k::fcb_t* pFcb); + ///< $4B - 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + int Read(DWORD nKey, Human68k::fcb_t* pFcb, BYTE* pAddress, DWORD nSize); + ///< $4C - 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ + int Write(DWORD nKey, Human68k::fcb_t* pFcb, const BYTE* pAddress, DWORD nSize); + ///< $4D - 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ + int Seek(DWORD nKey, Human68k::fcb_t* pFcb, DWORD nSeek, int nOffset); + ///< $4E - 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + DWORD TimeStamp(DWORD nUnit, DWORD nKey, Human68k::fcb_t* pFcb, DWORD nHumanTime); + ///< $4F - 繝輔ぃ繧､繝ｫ譎ょ綾蜿門ｾ/險ｭ螳 + int GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity); + ///< $50 - 螳ｹ驥丞叙蠕 + int CtrlDrive(DWORD nUnit, Human68k::ctrldrive_t* pCtrlDrive); + ///< $51 - 繝峨Λ繧､繝也憾諷区､懈渊/蛻ｶ蠕｡ + int GetDPB(DWORD nUnit, Human68k::dpb_t* pDpb); + ///< $52 - DPB蜿門ｾ + int DiskRead(DWORD nUnit, BYTE* pBuffer, DWORD nSector, DWORD nSize); + ///< $53 - 繧ｻ繧ｯ繧ｿ隱ｭ縺ｿ霎ｼ縺ｿ + int DiskWrite(DWORD nUnit); + ///< $54 - 繧ｻ繧ｯ繧ｿ譖ｸ縺崎ｾｼ縺ｿ + int Ioctrl(DWORD nUnit, DWORD nFunction, Human68k::ioctrl_t* pIoctrl); + ///< $55 - IOCTRL + int Flush(DWORD nUnit); + ///< $56 - 繝輔Λ繝繧ｷ繝･ + int CheckMedia(DWORD nUnit); + ///< $57 - 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ + int Lock(DWORD nUnit); + ///< $58 - 謗剃ｻ門宛蠕｡ + + void SetOption(DWORD nOption); + ///< 繧ｪ繝励す繝ｧ繝ｳ險ｭ螳 + DWORD GetOption() const { ASSERT(this); return m_nOption; } + ///< 繧ｪ繝励す繝ｧ繝ｳ蜿門ｾ + DWORD GetDefault() const { ASSERT(this); return m_nOptionDefault; } + ///< 繝繝輔か繝ｫ繝医が繝励す繝ｧ繝ｳ蜿門ｾ + static DWORD GetFileOption() { return g_nOption; } + ///< 繝輔ぃ繧､繝ｫ蜷榊､画鋤繧ｪ繝励す繝ｧ繝ｳ蜿門ｾ + void ShellNotify(DWORD nEvent, const TCHAR* szPath) + { ASSERT(this); m_cEntry.ShellNotify(nEvent, szPath); } + ///< 繝帙せ繝亥ｴ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝迥ｶ諷句､牙喧騾夂衍 + + /// 螳壽焚 + enum { + DriveMax = CHostEntry::DriveMax ///< 繝峨Λ繧､繝匁怙螟ｧ蛟呵｣懈焚 + }; + +private: + // 蜀驛ｨ陬懷勧逕ｨ + void InitOption(const Human68k::argument_t* pArgument); + ///< 繧ｪ繝励す繝ｧ繝ｳ蛻晄悄蛹 + BOOL FilesVolume(DWORD nUnit, Human68k::files_t* pFiles); + ///< 繝懊Μ繝･繝ｼ繝繝ｩ繝吶Ν蜿門ｾ + + DWORD m_nUnits; ///< 迴ｾ蝨ｨ縺ｮ繝峨Λ繧､繝悶が繝悶ず繧ｧ繧ｯ繝域焚 (繝ｬ繧ｸ繝･繝ｼ繝豈弱↓螟牙喧) + + DWORD m_nOption; ///< 迴ｾ蝨ｨ縺ｮ蜍穂ｽ懊ヵ繝ｩ繧ｰ + DWORD m_nOptionDefault; ///< 繝ｪ繧ｻ繝繝域凾縺ｮ蜍穂ｽ懊ヵ繝ｩ繧ｰ + + DWORD m_nDrives; ///< 繝吶ｼ繧ｹ繝代せ迥ｶ諷句ｾｩ蜈逕ｨ縺ｮ蛟呵｣懈焚 (0縺ｪ繧画ｯ主屓繧ｹ繧ｭ繝｣繝ｳ) + + DWORD m_nKernel; ///< 繧ｫ繝ｼ繝阪Ν繝√ぉ繝繧ｯ逕ｨ繧ｫ繧ｦ繝ｳ繧ｿ + DWORD m_nKernelSearch; ///< NUL繝繝舌う繧ｹ縺ｮ蜈磯ｭ繧｢繝峨Ξ繧ｹ + + DWORD m_nHostSectorCount; ///< 謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ逡ｪ蜿ｷ + + CHostFilesManager m_cFiles; ///< 繝輔ぃ繧､繝ｫ讀懃ｴ｢鬆伜沺 + CHostFcbManager m_cFcb; ///< FCB謫堺ｽ憺伜沺 + CHostEntry m_cEntry; ///< 繝峨Λ繧､繝悶が繝悶ず繧ｧ繧ｯ繝医→繝繧｣繝ｬ繧ｯ繝医Μ繧ｨ繝ｳ繝医Μ + + DWORD m_nHostSectorBuffer[XM6_HOST_PSEUDO_CLUSTER_MAX]; + ///< 謫ｬ莨ｼ繧ｻ繧ｯ繧ｿ縺ｮ謖縺吶ヵ繧｡繧､繝ｫ螳滉ｽ + + DWORD m_nFlag[DriveMax]; ///< 繝吶ｼ繧ｹ繝代せ迥ｶ諷句ｾｩ蜈逕ｨ縺ｮ蜍穂ｽ懊ヵ繝ｩ繧ｰ蛟呵｣ + TCHAR m_szBase[DriveMax][FILEPATH_MAX]; + ///< 繝吶ｼ繧ｹ繝代せ迥ｶ諷句ｾｩ蜈逕ｨ縺ｮ蛟呵｣ + static DWORD g_nOption; ///< 繝輔ぃ繧､繝ｫ蜷榊､画鋤繝輔Λ繧ｰ +}; + +#endif // cfilesystem_h diff --git a/src/raspberrypi/cqueue.h b/src/raspberrypi/cqueue.h new file mode 100644 index 00000000..27802a51 --- /dev/null +++ b/src/raspberrypi/cqueue.h @@ -0,0 +1,68 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2004 ＰＩ．(ytanaka@ipc-tokai.or.jp) +// [ MFC キュー ] +// +//--------------------------------------------------------------------------- + +#if !defined(queue_h) +#define queue_h + +//=========================================================================== +// +// キュー +// +//=========================================================================== +class CQueue +{ +public: + // 内部データ定義 + typedef struct _QUQUEINFO { + BYTE *pBuf; // バッファ + DWORD dwSize; // サイズ + DWORD dwMask; // マスク(サイズ-1) + DWORD dwRead; // Readポインタ + DWORD dwWrite; // Writeポインタ + DWORD dwNum; // 個数 + DWORD dwTotalRead; // 合計Read + DWORD dwTotalWrite; // 合計Write + } QUEUEINFO, *LPQUEUEINFO; + + // 基本ファンクション + CQueue(); + // コンストラクタ + virtual ~CQueue(); + // デストラクタ + BOOL FASTCALL Init(DWORD dwSize); + // 初期化 + + // API + void FASTCALL Clear(); + // クリア + BOOL FASTCALL IsEmpty() const { return (BOOL)(m_Queue.dwNum == 0); } + // キューが空かチェック + DWORD FASTCALL GetNum() const { return m_Queue.dwNum; } + // キューのデータ数を取得 + DWORD FASTCALL Get(BYTE *pDest); + // キュー内のデータをすべて取得 + DWORD FASTCALL Copy(BYTE *pDest) const; + // キュー内のデータをすべて取得(キュー進めない) + void FASTCALL Discard(DWORD dwNum); + // キューを進める + void FASTCALL Back(DWORD dwNum); + // キューを戻す + DWORD FASTCALL GetFree() const; + // キューの空き個数を取得 + BOOL FASTCALL Insert(const BYTE *pSrc, DWORD dwLength); + // キューに挿入 + void FASTCALL GetQueue(QUEUEINFO *pInfo) const; + // キュー情報取得 + +private: + QUEUEINFO m_Queue; + // 内部ワーク +}; + +#endif // queue_h diff --git a/src/raspberrypi/ctapdriver.cpp b/src/raspberrypi/ctapdriver.cpp new file mode 100644 index 00000000..fbcb3d44 --- /dev/null +++ b/src/raspberrypi/ctapdriver.cpp @@ -0,0 +1,209 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ TAP繝峨Λ繧､繝 ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "ctapdriver.h" + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CTapDriver::CTapDriver() +{ + // 蛻晄悄蛹 + m_hTAP = -1; + memset(&m_MacAddr, 0, sizeof(m_MacAddr)); +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +#ifdef __linux__ +BOOL FASTCALL CTapDriver::Init() +{ + char dev[IFNAMSIZ] = "ras0"; + struct ifreq ifr; + int ret; + + ASSERT(this); + + // TAP繝繝舌う繧ｹ蛻晄悄蛹 + if ((m_hTAP = open("/dev/net/tun", O_RDWR)) < 0) { + printf("Error: can't open tun\n"); + return FALSE; + } + + // IFF_NO_PI for no extra packet information + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_flags = IFF_TAP | IFF_NO_PI; + strncpy(ifr.ifr_name, dev, IFNAMSIZ); + if ((ret = ioctl(m_hTAP, TUNSETIFF, (void *)&ifr)) < 0) { + printf("Error: can't ioctl TUNSETIFF\n"); + close(m_hTAP); + return FALSE; + } + + // MAC繧｢繝峨Ξ繧ｹ蜿門ｾ + ifr.ifr_addr.sa_family = AF_INET; + if ((ret = ioctl(m_hTAP, SIOCGIFHWADDR, &ifr)) < 0) { + printf("Error: can't ioctl SIOCGIFHWADDR\n"); + close(m_hTAP); + return FALSE; + } + + // MAC繧｢繝峨Ξ繧ｹ菫晏ｭ + memcpy(m_MacAddr, ifr.ifr_hwaddr.sa_data, sizeof(m_MacAddr)); + return TRUE; +} +#endif // __linux__ + +#ifdef __NetBSD__ +BOOL FASTCALL CTapDriver::Init() +{ + struct ifreq ifr; + struct ifaddrs *ifa, *a; + + ASSERT(this); + + // TAP繝繝舌う繧ｹ蛻晄悄蛹 + if ((m_hTAP = open("/dev/tap", O_RDWR)) < 0) { + printf("Error: can't open tap\n"); + return FALSE; + } + + // 繝繝舌う繧ｹ蜷榊叙蠕 + if (ioctl(m_hTAP, TAPGIFNAME, (void *)&ifr) < 0) { + printf("Error: can't ioctl TAPGIFNAME\n"); + close(m_hTAP); + return FALSE; + } + + // MAC繧｢繝峨Ξ繧ｹ蜿門ｾ + if (getifaddrs(&ifa) == -1) { + printf("Error: can't getifaddrs\n"); + close(m_hTAP); + return FALSE; + } + for (a = ifa; a != NULL; a = a->ifa_next) + if (strcmp(ifr.ifr_name, a->ifa_name) == 0 && + a->ifa_addr->sa_family == AF_LINK) + break; + if (a == NULL) { + printf("Error: can't get MAC address\n"); + close(m_hTAP); + return FALSE; + } + + // MAC繧｢繝峨Ξ繧ｹ菫晏ｭ + memcpy(m_MacAddr, LLADDR((struct sockaddr_dl *)a->ifa_addr), + sizeof(m_MacAddr)); + freeifaddrs(ifa); + + printf("Tap device : %s\n", ifr.ifr_name); + + return TRUE; +} +#endif // __NetBSD__ + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL CTapDriver::Cleanup() +{ + ASSERT(this); + + // TAP繝繝舌う繧ｹ隗｣謾ｾ + if (m_hTAP != -1) { + close(m_hTAP); + m_hTAP = -1; + } +} + +//--------------------------------------------------------------------------- +// +// MAC繧｢繝峨Ξ繧ｹ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL CTapDriver::GetMacAddr(BYTE *mac) +{ + ASSERT(this); + ASSERT(mac); + + memcpy(mac, m_MacAddr, sizeof(m_MacAddr)); +} + +//--------------------------------------------------------------------------- +// +// 蜿嶺ｿ｡ +// +//--------------------------------------------------------------------------- +int FASTCALL CTapDriver::Rx(BYTE *buf) +{ + struct pollfd fds; + DWORD dwReceived; + + ASSERT(this); + ASSERT(m_hTAP != -1); + + // 蜿嶺ｿ｡蜿ｯ閭ｽ縺ｪ繝繝ｼ繧ｿ縺後≠繧九°隱ｿ縺ｹ繧 + fds.fd = m_hTAP; + fds.events = POLLIN | POLLERR; + fds.revents = 0; + poll(&fds, 1, 0); + if (!(fds.revents & POLLIN)) { + return 0; + } + + // 蜿嶺ｿ｡ + dwReceived = read(m_hTAP, buf, ETH_FRAME_LEN); + if (dwReceived == (DWORD)-1) { + return 0; + } + + // 蜿嶺ｿ｡縺梧怏蜉ｹ縺ｧ縺ゅｌ縺ｰ + if (dwReceived > 0) { + // FCS繧帝勁縺乗怙蟆上ヵ繝ｬ繝ｼ繝繧ｵ繧､繧ｺ(60繝舌う繝)縺ｫ繝代ョ繧｣繝ｳ繧ｰ + if (dwReceived < 60) { + memset(buf + dwReceived, 0, 60 - dwReceived); + dwReceived = 60; + } + + // 繝繝溘ｼ縺ｮFCS繧剃ｻ伜刈縺吶ｋ + memset(buf + dwReceived, 0, 4); + dwReceived += 4; + } + + // 繝舌う繝域焚繧定ｿ泌唆 + return dwReceived; +} + +//--------------------------------------------------------------------------- +// +// 騾∽ｿ｡ +// +//--------------------------------------------------------------------------- +int FASTCALL CTapDriver::Tx(BYTE *buf, int len) +{ + ASSERT(this); + ASSERT(m_hTAP != -1); + + // 騾∽ｿ｡髢句ｧ + return write(m_hTAP, buf, len); +} \ No newline at end of file diff --git a/src/raspberrypi/ctapdriver.h b/src/raspberrypi/ctapdriver.h new file mode 100644 index 00000000..9f7b3f44 --- /dev/null +++ b/src/raspberrypi/ctapdriver.h @@ -0,0 +1,53 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ TAP繝峨Λ繧､繝 ] +// +//--------------------------------------------------------------------------- + +#if !defined(ctapdriver_h) +#define ctapdriver_h + +#ifndef ETH_FRAME_LEN +#define ETH_FRAME_LEN 1514 +#endif + +//=========================================================================== +// +// Tap繝峨Λ繧､繝 +// +//=========================================================================== +class CTapDriver +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CTapDriver(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Init(); + // 蛻晄悄蛹 + void FASTCALL Cleanup(); + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + void FASTCALL GetMacAddr(BYTE *mac); + // MAC繧｢繝峨Ξ繧ｹ蜿門ｾ + int FASTCALL Rx(BYTE *buf); + // 蜿嶺ｿ｡ + int FASTCALL Tx(BYTE *buf, int len); + // 騾∽ｿ｡ + +private: + BYTE m_MacAddr[6]; + // MAC繧｢繝峨Ξ繧ｹ + BOOL m_bTxValid; + // 騾∽ｿ｡譛牙柑繝輔Λ繧ｰ + int m_hTAP; + // 繝繧｣繧ｹ繧ｯ繝励Μ繧ｿ +}; + +#endif // ctapdriver_h diff --git a/src/raspberrypi/disk.cpp b/src/raspberrypi/disk.cpp new file mode 100644 index 00000000..869e1284 --- /dev/null +++ b/src/raspberrypi/disk.cpp @@ -0,0 +1,9160 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2014-2018 GIMONS +// +// XM6i +// Copyright (C) 2010-2015 isaki@NetBSD.org +// Copyright (C) 2010 Y.Sugahara +// +// Imported sava's Anex86/T98Next image and MO format support patch. +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ 繝繧｣繧ｹ繧ｯ ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "fileio.h" +#ifdef RASCSI +#include "filepath.h" +#include "ctapdriver.h" +#include "cfilesystem.h" +#include "disk.h" +#else +#include "vm.h" +#include "disk.h" +#include "windrv.h" +#include "ctapdriver.h" +#include "mfc_com.h" +#include "mfc_host.h" +#endif // RASCSI + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ +// +//=========================================================================== +//#define DISK_LOG + +#ifdef RASCSI +#define BENDER_SIGNATURE "RaSCSI" +#else +#define BENDER_SIGNATURE "XM6" +#endif + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ繝医Λ繝繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +DiskTrack::DiskTrack() +{ + // 蜀驛ｨ諠蝣ｱ縺ｮ蛻晄悄蛹 + dt.track = 0; + dt.size = 0; + dt.sectors = 0; + dt.raw = FALSE; + dt.init = FALSE; + dt.changed = FALSE; + dt.length = 0; + dt.buffer = NULL; + dt.maplen = 0; + dt.changemap = NULL; + dt.imgoffset = 0; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +DiskTrack::~DiskTrack() +{ + // 繝｡繝｢繝ｪ隗｣謾ｾ縺ｯ陦後≧縺後∬ｪ蜍輔そ繝ｼ繝悶ｯ縺励↑縺 + if (dt.buffer) { +#ifdef RASCSI + free(dt.buffer); +#else + delete[] dt.buffer; +#endif // RASCSI + dt.buffer = NULL; + } + if (dt.changemap) { + delete[] dt.changemap; + dt.changemap = NULL; + } +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +void FASTCALL DiskTrack::Init( + int track, int size, int sectors, BOOL raw, off64_t imgoff) +{ + ASSERT(track >= 0); + ASSERT((size == 8) || (size == 9) || (size == 11)); + ASSERT((sectors > 0) && (sectors <= 0x100)); + ASSERT(imgoff >= 0); + + // 繝代Λ繝｡繝ｼ繧ｿ繧定ｨｭ螳 + dt.track = track; + dt.size = size; + dt.sectors = sectors; + dt.raw = raw; + + // 蛻晄悄蛹悶＆繧後※縺縺ｪ縺(繝ｭ繝ｼ繝峨☆繧句ｿ隕√≠繧) + dt.init = FALSE; + + // 螟画峩縺輔ｌ縺ｦ縺縺ｪ縺 + dt.changed = FALSE; + + // 螳溘ョ繝ｼ繧ｿ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝 + dt.imgoffset = imgoff; +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskTrack::Load(const Filepath& path) +{ + Fileio fio; + off64_t offset; + int i; + int length; + + ASSERT(this); + + // 譌｢縺ｫ繝ｭ繝ｼ繝峨＆繧後※縺繧後ｰ荳崎ｦ + if (dt.init) { + ASSERT(dt.buffer); + ASSERT(dt.changemap); + return TRUE; + } + + // 繧ｪ繝輔そ繝繝医ｒ險育ｮ(縺薙ｌ莉･蜑阪ｮ繝医Λ繝繧ｯ縺ｯ256繧ｻ繧ｯ繧ｿ菫晄戟縺ｨ縺ｿ縺ｪ縺) + offset = ((off64_t)dt.track << 8); + if (dt.raw) { + ASSERT(dt.size == 11); + offset *= 0x930; + offset += 0x10; + } else { + offset <<= dt.size; + } + + // 螳溘う繝｡繝ｼ繧ｸ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝医ｒ霑ｽ蜉 + offset += dt.imgoffset; + + // 繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨ育ｮ(縺薙ｮ繝医Λ繝繧ｯ縺ｮ繝繝ｼ繧ｿ繧ｵ繧､繧ｺ) + length = dt.sectors << dt.size; + + // 繝舌ャ繝輔ぃ縺ｮ繝｡繝｢繝ｪ繧堤｢ｺ菫 + ASSERT((dt.size == 8) || (dt.size == 9) || (dt.size == 11)); + ASSERT((dt.sectors > 0) && (dt.sectors <= 0x100)); + try { + // 繝舌ャ繝輔ぃ髟ｷ縺檎焚縺ｪ繧九↑繧芽ｧ｣謾ｾ + if (dt.length != (DWORD)length) { + if (dt.buffer) { +#ifdef RASCSI + free(dt.buffer); +#else + delete[] dt.buffer; +#endif // RASCSI + dt.buffer = NULL; + } + } + + // 繝舌ャ繝輔ぃ遒ｺ菫 + dt.length = length; + if (dt.buffer == NULL) { +#ifdef RASCSI + posix_memalign((void **)&dt.buffer, 512, ((dt.length + 511) / 512) * 512); +#else + dt.buffer = new BYTE[dt.length]; +#endif // RASCSI + } + } + catch (...) { + dt.length = 0; + dt.buffer = NULL; + return FALSE; + } + if (!dt.buffer) { + return FALSE; + } + + // 螟画峩繝槭ャ繝励ｮ繝｡繝｢繝ｪ繧堤｢ｺ菫 + try { + // 繝舌ャ繝輔ぃ髟ｷ縺檎焚縺ｪ繧九↑繧芽ｧ｣謾ｾ + if (dt.maplen != (DWORD)dt.sectors) { + if (dt.changemap) { + delete[] dt.changemap; + dt.changemap = NULL; + } + } + + // 繝舌ャ繝輔ぃ遒ｺ菫 + dt.maplen = dt.sectors; + if (dt.changemap == NULL) { + dt.changemap = new BOOL[dt.maplen]; + } + } + catch (...) { + dt.maplen = 0; + dt.changemap = NULL; + return FALSE; + } + if (!dt.changemap) { + return FALSE; + } + + // 螟画峩繝槭ャ繝励ｒ繧ｯ繝ｪ繧｢ + memset(dt.changemap, 0x00, dt.sectors * sizeof(BOOL)); + + // 繝輔ぃ繧､繝ｫ縺九ｉ隱ｭ縺ｿ霎ｼ繧 +#ifdef RASCSI + if (!fio.OpenDIO(path, Fileio::ReadOnly)) { +#else + if (!fio.Open(path, Fileio::ReadOnly)) { +#endif // RASCSI + return FALSE; + } + if (dt.raw) { + // 蛻蜑ｲ隱ｭ縺ｿ + for (i = 0; i < dt.sectors; i++) { + // 繧ｷ繝ｼ繧ｯ + if (!fio.Seek(offset)) { + fio.Close(); + return FALSE; + } + + // 隱ｭ縺ｿ霎ｼ縺ｿ + if (!fio.Read(&dt.buffer[i << dt.size], 1 << dt.size)) { + fio.Close(); + return FALSE; + } + + // 谺｡縺ｮ繧ｪ繝輔そ繝繝 + offset += 0x930; + } + } else { + // 騾｣邯夊ｪｭ縺ｿ + if (!fio.Seek(offset)) { + fio.Close(); + return FALSE; + } + if (!fio.Read(dt.buffer, length)) { + fio.Close(); + return FALSE; + } + } + fio.Close(); + + // 繝輔Λ繧ｰ繧堤ｫ九※縲∵ｭ｣蟶ｸ邨ゆｺ + dt.init = TRUE; + dt.changed = FALSE; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskTrack::Save(const Filepath& path) +{ + off64_t offset; + int i; + Fileio fio; + int length; + + ASSERT(this); + + // 蛻晄悄蛹悶＆繧後※縺縺ｪ縺代ｌ縺ｰ荳崎ｦ + if (!dt.init) { + return TRUE; + } + + // 螟画峩縺輔ｌ縺ｦ縺縺ｪ縺代ｌ縺ｰ荳崎ｦ + if (!dt.changed) { + return TRUE; + } + + // 譖ｸ縺崎ｾｼ繧蠢隕√′縺ゅｋ + ASSERT(dt.buffer); + ASSERT(dt.changemap); + ASSERT((dt.size == 8) || (dt.size == 9) || (dt.size == 11)); + ASSERT((dt.sectors > 0) && (dt.sectors <= 0x100)); + + // RAW繝｢繝ｼ繝峨〒縺ｯ譖ｸ縺崎ｾｼ縺ｿ縺ｯ縺ゅｊ縺医↑縺 + ASSERT(!dt.raw); + + // 繧ｪ繝輔そ繝繝医ｒ險育ｮ(縺薙ｌ莉･蜑阪ｮ繝医Λ繝繧ｯ縺ｯ256繧ｻ繧ｯ繧ｿ菫晄戟縺ｨ縺ｿ縺ｪ縺) + offset = ((off64_t)dt.track << 8); + offset <<= dt.size; + + // 螳溘う繝｡繝ｼ繧ｸ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝医ｒ霑ｽ蜉 + offset += dt.imgoffset; + + // 繧ｻ繧ｯ繧ｿ縺ゅ◆繧翫ｮ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨ育ｮ + length = 1 << dt.size; + + // 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + if (!fio.Open(path, Fileio::ReadWrite)) { + return FALSE; + } + + // 譖ｸ縺崎ｾｼ縺ｿ繝ｫ繝ｼ繝 + for (i = 0; i < dt.sectors; i++) { + // 螟画峩縺輔ｌ縺ｦ縺繧後ｰ + if (dt.changemap[i]) { + // 繧ｷ繝ｼ繧ｯ縲∵嶌縺崎ｾｼ縺ｿ + if (!fio.Seek(offset + ((off64_t)i << dt.size))) { + fio.Close(); + return FALSE; + } + if (!fio.Write(&dt.buffer[i << dt.size], length)) { + fio.Close(); + return FALSE; + } + + // 螟画峩繝輔Λ繧ｰ繧定誠縺ｨ縺 + dt.changemap[i] = FALSE; + } + } + + // 繧ｯ繝ｭ繝ｼ繧ｺ + fio.Close(); + + // 螟画峩繝輔Λ繧ｰ繧定誠縺ｨ縺励∫ｵゆｺ + dt.changed = FALSE; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繝ｼ繝峨そ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskTrack::Read(BYTE *buf, int sec) const +{ + ASSERT(this); + ASSERT(buf); + ASSERT((sec >= 0) & (sec < 0x100)); + + // 蛻晄悄蛹悶＆繧後※縺縺ｪ縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ + if (!dt.init) { + return FALSE; + } + + // 繧ｻ繧ｯ繧ｿ縺梧怏蜉ｹ謨ｰ繧定ｶ縺医※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (sec >= dt.sectors) { + return FALSE; + } + + // 繧ｳ繝斐ｼ + ASSERT(dt.buffer); + ASSERT((dt.size == 8) || (dt.size == 9) || (dt.size == 11)); + ASSERT((dt.sectors > 0) && (dt.sectors <= 0x100)); + memcpy(buf, &dt.buffer[(off64_t)sec << dt.size], (off64_t)1 << dt.size); + + // 謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｩ繧､繝医そ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskTrack::Write(const BYTE *buf, int sec) +{ + int offset; + int length; + + ASSERT(this); + ASSERT(buf); + ASSERT((sec >= 0) & (sec < 0x100)); + ASSERT(!dt.raw); + + // 蛻晄悄蛹悶＆繧後※縺縺ｪ縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ + if (!dt.init) { + return FALSE; + } + + // 繧ｻ繧ｯ繧ｿ縺梧怏蜉ｹ謨ｰ繧定ｶ縺医※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (sec >= dt.sectors) { + return FALSE; + } + + // 繧ｪ繝輔そ繝繝医√Ξ繝ｳ繧ｰ繧ｹ繧定ｨ育ｮ + offset = sec << dt.size; + length = 1 << dt.size; + + // 豈碑ｼ + ASSERT(dt.buffer); + ASSERT((dt.size == 8) || (dt.size == 9) || (dt.size == 11)); + ASSERT((dt.sectors > 0) && (dt.sectors <= 0x100)); + if (memcmp(buf, &dt.buffer[offset], length) == 0) { + // 蜷後§繧ゅｮ繧呈嶌縺崎ｾｼ繧ゅ≧縺ｨ縺励※縺繧九ｮ縺ｧ縲∵ｭ｣蟶ｸ邨ゆｺ + return TRUE; + } + + // 繧ｳ繝斐ｼ縲∝､画峩縺ゅｊ + memcpy(&dt.buffer[offset], buf, length); + dt.changemap[sec] = TRUE; + dt.changed = TRUE; + + // 謌仙粥 + return TRUE; +} + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +DiskCache::DiskCache( + const Filepath& path, int size, int blocks, off64_t imgoff) +{ + int i; + + ASSERT((size == 8) || (size == 9) || (size == 11)); + ASSERT(blocks > 0); + ASSERT(imgoff >= 0); + + // 繧ｭ繝｣繝繧ｷ繝･繝ｯ繝ｼ繧ｯ + for (i = 0; i < CacheMax; i++) { + cache[i].disktrk = NULL; + cache[i].serial = 0; + } + + // 縺昴ｮ莉 + serial = 0; + sec_path = path; + sec_size = size; + sec_blocks = blocks; + cd_raw = FALSE; + imgoffset = imgoff; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +DiskCache::~DiskCache() +{ + // 繝医Λ繝繧ｯ繧偵け繝ｪ繧｢ + Clear(); +} + +//--------------------------------------------------------------------------- +// +// RAW繝｢繝ｼ繝芽ｨｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL DiskCache::SetRawMode(BOOL raw) +{ + ASSERT(this); + ASSERT(sec_size == 11); + + // 險ｭ螳 + cd_raw = raw; +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskCache::Save() +{ + int i; + + ASSERT(this); + + // 繝医Λ繝繧ｯ繧剃ｿ晏ｭ + for (i = 0; i < CacheMax; i++) { + // 譛牙柑縺ｪ繝医Λ繝繧ｯ縺 + if (cache[i].disktrk) { + // 菫晏ｭ + if (!cache[i].disktrk->Save(sec_path)) { + return FALSE; + } + } + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･諠蝣ｱ蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskCache::GetCache(int index, int& track, DWORD& aserial) const +{ + ASSERT(this); + ASSERT((index >= 0) && (index < CacheMax)); + + // 譛ｪ菴ｿ逕ｨ縺ｪ繧宇ALSE + if (!cache[index].disktrk) { + return FALSE; + } + + // 繝医Λ繝繧ｯ縺ｨ繧ｷ繝ｪ繧｢繝ｫ繧定ｨｭ螳 + track = cache[index].disktrk->GetTrack(); + aserial = cache[index].serial; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繧｢ +// +//--------------------------------------------------------------------------- +void FASTCALL DiskCache::Clear() +{ + int i; + + ASSERT(this); + + // 繧ｭ繝｣繝繧ｷ繝･繝ｯ繝ｼ繧ｯ繧定ｧ｣謾ｾ + for (i = 0; i < CacheMax; i++) { + if (cache[i].disktrk) { + delete cache[i].disktrk; + cache[i].disktrk = NULL; + } + } +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繧ｯ繧ｿ繝ｪ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskCache::Read(BYTE *buf, int block) +{ + int track; + DiskTrack *disktrk; + + ASSERT(this); + ASSERT(sec_size != 0); + + // 蜈医↓譖ｴ譁ｰ + Update(); + + // 繝医Λ繝繧ｯ繧堤ｮ怜ｺ(256繧ｻ繧ｯ繧ｿ/繝医Λ繝繧ｯ縺ｫ蝗ｺ螳) + track = block >> 8; + + // 縺昴ｮ繝医Λ繝繧ｯ繝繝ｼ繧ｿ繧貞ｾ励ｋ + disktrk = Assign(track); + if (!disktrk) { + return FALSE; + } + + // 繝医Λ繝繧ｯ縺ｫ莉ｻ縺帙ｋ + return disktrk->Read(buf, (BYTE)block); +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繧ｯ繧ｿ繝ｩ繧､繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskCache::Write(const BYTE *buf, int block) +{ + int track; + DiskTrack *disktrk; + + ASSERT(this); + ASSERT(sec_size != 0); + + // 蜈医↓譖ｴ譁ｰ + Update(); + + // 繝医Λ繝繧ｯ繧堤ｮ怜ｺ(256繧ｻ繧ｯ繧ｿ/繝医Λ繝繧ｯ縺ｫ蝗ｺ螳) + track = block >> 8; + + // 縺昴ｮ繝医Λ繝繧ｯ繝繝ｼ繧ｿ繧貞ｾ励ｋ + disktrk = Assign(track); + if (!disktrk) { + return FALSE; + } + + // 繝医Λ繝繧ｯ縺ｫ莉ｻ縺帙ｋ + return disktrk->Write(buf, (BYTE)block); +} + +//--------------------------------------------------------------------------- +// +// 繝医Λ繝繧ｯ縺ｮ蜑ｲ繧雁ｽ薙※ +// +//--------------------------------------------------------------------------- +DiskTrack* FASTCALL DiskCache::Assign(int track) +{ + int i; + int c; + DWORD s; + DiskTrack *disktrk; + + ASSERT(this); + ASSERT(sec_size != 0); + ASSERT(track >= 0); + + // 縺ｾ縺壹∵里縺ｫ蜑ｲ繧雁ｽ薙※縺輔ｌ縺ｦ縺縺ｪ縺縺玖ｪｿ縺ｹ繧 + for (i = 0; i < CacheMax; i++) { + if (cache[i].disktrk) { + if (cache[i].disktrk->GetTrack() == track) { + // 繝医Λ繝繧ｯ縺御ｸ閾ｴ + cache[i].serial = serial; + return cache[i].disktrk; + } + } + } + + // 谺｡縺ｫ縲∫ｩｺ縺縺ｦ縺繧九ｂ縺ｮ縺後↑縺縺玖ｪｿ縺ｹ繧 + for (i = 0; i < CacheMax; i++) { + if (!cache[i].disktrk) { + // 繝ｭ繝ｼ繝峨ｒ隧ｦ縺ｿ繧 + if (Load(i, track)) { + // 繝ｭ繝ｼ繝画仙粥 + cache[i].serial = serial; + return cache[i].disktrk; + } + + // 繝ｭ繝ｼ繝牙､ｱ謨 + return NULL; + } + } + + // 譛蠕後↓縲√す繝ｪ繧｢繝ｫ逡ｪ蜿ｷ縺ｮ荳逡ｪ闍･縺繧ゅｮ繧呈爾縺励∝炎髯､縺吶ｋ + + // 繧､繝ｳ繝繝繧ｯ繧ｹ0繧貞呵｣彡縺ｨ縺吶ｋ + s = cache[0].serial; + c = 0; + + // 蛟呵｣懊→繧ｷ繝ｪ繧｢繝ｫ繧呈ｯ碑ｼ縺励√ｈ繧雁ｰ上＆縺繧ゅｮ縺ｸ譖ｴ譁ｰ縺吶ｋ + for (i = 0; i < CacheMax; i++) { + ASSERT(cache[i].disktrk); + + // 譌｢縺ｫ蟄伜惠縺吶ｋ繧ｷ繝ｪ繧｢繝ｫ縺ｨ豈碑ｼ縲∵峩譁ｰ + if (cache[i].serial < s) { + s = cache[i].serial; + c = i; + } + } + + // 縺薙ｮ繝医Λ繝繧ｯ繧剃ｿ晏ｭ + if (!cache[c].disktrk->Save(sec_path)) { + return NULL; + } + + // 縺薙ｮ繝医Λ繝繧ｯ繧貞炎髯､ + disktrk = cache[c].disktrk; + cache[c].disktrk = NULL; + + // 繝ｭ繝ｼ繝 + if (Load(c, track, disktrk)) { + // 繝ｭ繝ｼ繝画仙粥 + cache[c].serial = serial; + return cache[c].disktrk; + } + + // 繝ｭ繝ｼ繝牙､ｱ謨 + return NULL; +} + +//--------------------------------------------------------------------------- +// +// 繝医Λ繝繧ｯ縺ｮ繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL DiskCache::Load(int index, int track, DiskTrack *disktrk) +{ + int sectors; + + ASSERT(this); + ASSERT((index >= 0) && (index < CacheMax)); + ASSERT(track >= 0); + ASSERT(!cache[index].disktrk); + + // 縺薙ｮ繝医Λ繝繧ｯ縺ｮ繧ｻ繧ｯ繧ｿ謨ｰ繧貞叙蠕 + sectors = sec_blocks - (track << 8); + ASSERT(sectors > 0); + if (sectors > 0x100) { + sectors = 0x100; + } + + // 繝繧｣繧ｹ繧ｯ繝医Λ繝繧ｯ繧剃ｽ懈 + if (disktrk == NULL) { + disktrk = new DiskTrack(); + } + + // 繝繧｣繧ｹ繧ｯ繝医Λ繝繧ｯ繧貞晄悄蛹 + disktrk->Init(track, sec_size, sectors, cd_raw, imgoffset); + + // 繝ｭ繝ｼ繝峨ｒ隧ｦ縺ｿ繧 + if (!disktrk->Load(sec_path)) { + // 螟ｱ謨 + delete disktrk; + return FALSE; + } + + // 蜑ｲ繧雁ｽ薙※謌仙粥縲√Ρ繝ｼ繧ｯ繧定ｨｭ螳 + cache[index].disktrk = disktrk; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｷ繝ｪ繧｢繝ｫ逡ｪ蜿ｷ縺ｮ譖ｴ譁ｰ +// +//--------------------------------------------------------------------------- +void FASTCALL DiskCache::Update() +{ + int i; + + ASSERT(this); + + // 譖ｴ譁ｰ縺励※縲0莉･螟悶ｯ菴輔ｂ縺励↑縺 + serial++; + if (serial != 0) { + return; + } + + // 蜈ｨ繧ｭ繝｣繝繧ｷ繝･縺ｮ繧ｷ繝ｪ繧｢繝ｫ繧偵け繝ｪ繧｢(32bit繝ｫ繝ｼ繝励＠縺ｦ縺繧) + for (i = 0; i < CacheMax; i++) { + cache[i].serial = 0; + } +} + + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Disk::Disk() +{ + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + disk.id = MAKEID('N', 'U', 'L', 'L'); + disk.ready = FALSE; + disk.writep = FALSE; + disk.readonly = FALSE; + disk.removable = FALSE; + disk.lock = FALSE; + disk.attn = FALSE; + disk.reset = FALSE; + disk.size = 0; + disk.blocks = 0; + disk.lun = 0; + disk.code = 0; + disk.dcache = NULL; + disk.imgoffset = 0; + + // 縺昴ｮ莉 + cache_wb = TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Disk::~Disk() +{ + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･縺ｮ菫晏ｭ + if (disk.ready) { + // 繝ｬ繝繧｣縺ｮ蝣ｴ蜷医ｮ縺ｿ + if (disk.dcache) { + disk.dcache->Save(); + } + } + + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･縺ｮ蜑企勁 + if (disk.dcache) { + delete disk.dcache; + disk.dcache = NULL; + } +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL Disk::Reset() +{ + ASSERT(this); + + // 繝ｭ繝繧ｯ縺ｪ縺励√い繝繝ｳ繧ｷ繝ｧ繝ｳ縺ｪ縺励√Μ繧ｻ繝繝医≠繧 + disk.lock = FALSE; + disk.attn = FALSE; + disk.reset = TRUE; +} + +#ifndef RASCSI +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Save(Fileio *fio, int ver) +{ + DWORD sz; + DWORD padding; + + ASSERT(this); + ASSERT(fio); + + // 繧ｵ繧､繧ｺ繧偵そ繝ｼ繝 + sz = 52; + if (!fio->Write(&sz, sizeof(sz))) { + return FALSE; + } + + // 螳滉ｽ薙ｒ繧ｻ繝ｼ繝 + PROP_EXPORT(fio, disk.id); + PROP_EXPORT(fio, disk.ready); + PROP_EXPORT(fio, disk.writep); + PROP_EXPORT(fio, disk.readonly); + PROP_EXPORT(fio, disk.removable); + PROP_EXPORT(fio, disk.lock); + PROP_EXPORT(fio, disk.attn); + PROP_EXPORT(fio, disk.reset); + PROP_EXPORT(fio, disk.size); + PROP_EXPORT(fio, disk.blocks); + PROP_EXPORT(fio, disk.lun); + PROP_EXPORT(fio, disk.code); + PROP_EXPORT(fio, padding); + + // 繝代せ繧偵そ繝ｼ繝 + if (!diskpath.Save(fio, ver)) { + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Load(Fileio *fio, int ver) +{ + DWORD sz; + disk_t buf; + DWORD padding; + Filepath path; + + ASSERT(this); + ASSERT(fio); + + // version2.03繧医ｊ蜑阪ｯ縲√ョ繧｣繧ｹ繧ｯ縺ｯ繧ｻ繝ｼ繝悶＠縺ｦ縺縺ｪ縺 + if (ver <= 0x0202) { + return TRUE; + } + + // 迴ｾ蝨ｨ縺ｮ繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､ + if (disk.dcache) { + disk.dcache->Save(); + delete disk.dcache; + disk.dcache = NULL; + } + + // 繧ｵ繧､繧ｺ繧偵Ο繝ｼ繝峨∫ｧ蜷 + if (!fio->Read(&sz, sizeof(sz))) { + return FALSE; + } + if (sz != 52) { + return FALSE; + } + + // 繝舌ャ繝輔ぃ縺ｸ繝ｭ繝ｼ繝 + PROP_IMPORT(fio, buf.id); + PROP_IMPORT(fio, buf.ready); + PROP_IMPORT(fio, buf.writep); + PROP_IMPORT(fio, buf.readonly); + PROP_IMPORT(fio, buf.removable); + PROP_IMPORT(fio, buf.lock); + PROP_IMPORT(fio, buf.attn); + PROP_IMPORT(fio, buf.reset); + PROP_IMPORT(fio, buf.size); + PROP_IMPORT(fio, buf.blocks); + PROP_IMPORT(fio, buf.lun); + PROP_IMPORT(fio, buf.code); + PROP_IMPORT(fio, padding); + + // 繝代せ繧偵Ο繝ｼ繝 + if (!path.Load(fio, ver)) { + return FALSE; + } + + // ID縺御ｸ閾ｴ縺励◆蝣ｴ蜷医ｮ縺ｿ縲∫ｧｻ蜍 + if (disk.id == buf.id) { + // NULL縺ｪ繧我ｽ輔ｂ縺励↑縺 + if (IsNULL()) { + return TRUE; + } + + // 繧ｻ繝ｼ繝悶＠縺滓凾縺ｨ蜷後§遞ｮ鬘槭ｮ繝繝舌う繧ｹ + disk.ready = FALSE; + if (Open(path)) { + // Open蜀縺ｧ繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･縺ｯ菴懈舌＆繧後※縺繧 + // 繝励Ο繝代ユ繧｣縺ｮ縺ｿ遘ｻ蜍 + if (!disk.readonly) { + disk.writep = buf.writep; + } + disk.lock = buf.lock; + disk.attn = buf.attn; + disk.reset = buf.reset; + disk.lun = buf.lun; + disk.code = buf.code; + + // 豁｣蟶ｸ縺ｫ繝ｭ繝ｼ繝峨〒縺阪◆ + return TRUE; + } + } + + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･蜀堺ｽ懈 + if (!IsReady()) { + disk.dcache = NULL; + } else { + disk.dcache = new DiskCache(diskpath, disk.size, disk.blocks); + } + + return TRUE; +} +#endif // RASCSI + +//--------------------------------------------------------------------------- +// +// NULL繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::IsNULL() const +{ + ASSERT(this); + + if (disk.id == MAKEID('N', 'U', 'L', 'L')) { + return TRUE; + } + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// SASI繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::IsSASI() const +{ + ASSERT(this); + + if (disk.id == MAKEID('S', 'A', 'H', 'D')) { + return TRUE; + } + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// 窶ｻ豢ｾ逕溘け繝ｩ繧ｹ縺ｧ縲√が繝ｼ繝励Φ謌仙粥蠕後ｮ蠕悟ｦ逅縺ｨ縺励※蜻ｼ縺ｳ蜃ｺ縺吶％縺ｨ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Open(const Filepath& path, BOOL /*attn*/) +{ + Fileio fio; + + ASSERT(this); + ASSERT((disk.size == 8) || (disk.size == 9) || (disk.size == 11)); + ASSERT(disk.blocks > 0); + + // 繝ｬ繝繧｣ + disk.ready = TRUE; + + // 繧ｭ繝｣繝繧ｷ繝･蛻晄悄蛹 + ASSERT(!disk.dcache); + disk.dcache = new DiskCache( + path, disk.size, disk.blocks, disk.imgoffset); + + // 隱ｭ縺ｿ譖ｸ縺阪が繝ｼ繝励Φ蜿ｯ閭ｽ縺 + if (fio.Open(path, Fileio::ReadWrite)) { + // 譖ｸ縺崎ｾｼ縺ｿ險ｱ蜿ｯ縲√Μ繝ｼ繝峨が繝ｳ繝ｪ繝ｼ縺ｧ縺ｪ縺 + disk.writep = FALSE; + disk.readonly = FALSE; + fio.Close(); + } else { + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縲√Μ繝ｼ繝峨が繝ｳ繝ｪ繝ｼ + disk.writep = TRUE; + disk.readonly = TRUE; + } + + // 繝ｭ繝繧ｯ縺輔ｌ縺ｦ縺縺ｪ縺 + disk.lock = FALSE; + + // 繝代せ菫晏ｭ + diskpath = path; + + // 謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧､繧ｸ繧ｧ繧ｯ繝 +// +//--------------------------------------------------------------------------- +void FASTCALL Disk::Eject(BOOL force) +{ + ASSERT(this); + + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ縺ｧ縺ｪ縺代ｌ縺ｰ繧､繧ｸ繧ｧ繧ｯ繝医〒縺阪↑縺 + if (!disk.removable) { + return; + } + + // 繝ｬ繝繧｣縺ｧ縺ｪ縺代ｌ縺ｰ繧､繧ｸ繧ｧ繧ｯ繝亥ｿ隕√↑縺 + if (!disk.ready) { + return; + } + + // 蠑ｷ蛻ｶ繝輔Λ繧ｰ縺後↑縺蝣ｴ蜷医√Ο繝繧ｯ縺輔ｌ縺ｦ縺縺ｪ縺縺薙→縺悟ｿ隕 + if (!force) { + if (disk.lock) { + return; + } + } + + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､ + disk.dcache->Save(); + delete disk.dcache; + disk.dcache = NULL; + + // 繝弱ャ繝医Ξ繝繧｣縲√い繝繝ｳ繧ｷ繝ｧ繝ｳ縺ｪ縺 + disk.ready = FALSE; + disk.writep = FALSE; + disk.readonly = FALSE; + disk.attn = FALSE; +} + +//--------------------------------------------------------------------------- +// +// 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢ +// +//--------------------------------------------------------------------------- +void FASTCALL Disk::WriteP(BOOL writep) +{ + ASSERT(this); + + // 繝ｬ繝繧｣縺ｧ縺ゅｋ縺薙→ + if (!disk.ready) { + return; + } + + // Read Only縺ｮ蝣ｴ蜷医ｯ縲√励Ο繝繧ｯ繝育憾諷九ｮ縺ｿ + if (disk.readonly) { + ASSERT(disk.writep); + return; + } + + // 繝輔Λ繧ｰ險ｭ螳 + disk.writep = writep; +} + +//--------------------------------------------------------------------------- +// +// 蜀驛ｨ繝ｯ繝ｼ繧ｯ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL Disk::GetDisk(disk_t *buffer) const +{ + ASSERT(this); + ASSERT(buffer); + + // 蜀驛ｨ繝ｯ繝ｼ繧ｯ繧偵さ繝斐ｼ + *buffer = disk; +} + +//--------------------------------------------------------------------------- +// +// 繝代せ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL Disk::GetPath(Filepath& path) const +{ + path = diskpath; +} + +//--------------------------------------------------------------------------- +// +// 繝輔Λ繝繧ｷ繝･ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Flush() +{ + ASSERT(this); + + // 繧ｭ繝｣繝繧ｷ繝･縺後↑縺代ｌ縺ｰ菴輔ｂ縺励↑縺 + if (!disk.dcache) { + return TRUE; + } + + // 繧ｭ繝｣繝繧ｷ繝･繧剃ｿ晏ｭ + return disk.dcache->Save(); +} + +//--------------------------------------------------------------------------- +// +// 繝ｬ繝繧｣繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::CheckReady() +{ + ASSERT(this); + + // 繝ｪ繧ｻ繝繝医↑繧峨√せ繝繝ｼ繧ｿ繧ｹ繧定ｿ斐☆ + if (disk.reset) { + disk.code = DISK_DEVRESET; + disk.reset = FALSE; + return FALSE; + } + + // 繧｢繝繝ｳ繧ｷ繝ｧ繝ｳ縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繧定ｿ斐☆ + if (disk.attn) { + disk.code = DISK_ATTENTION; + disk.attn = FALSE; + return FALSE; + } + + // 繝弱ャ繝医Ξ繝繧｣縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繧定ｿ斐☆ + if (!disk.ready) { + disk.code = DISK_NOTREADY; + return FALSE; + } + + // 繧ｨ繝ｩ繝ｼ縺ｪ縺励↓蛻晄悄蛹 + disk.code = DISK_NOERROR; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// 窶ｻ蟶ｸ譎よ仙粥縺吶ｋ蠢隕√′縺ゅｋ +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::Inquiry( + const DWORD* /*cdb*/, BYTE* /*buf*/, DWORD /*major*/, DWORD /*minor*/) +{ + ASSERT(this); + + // 繝繝輔か繝ｫ繝医ｯINQUIRY螟ｱ謨 + disk.code = DISK_INVALIDCMD; + return 0; +} + +//--------------------------------------------------------------------------- +// +// REQUEST SENSE +// 窶ｻSASI縺ｯ蛻･蜃ｦ逅 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::RequestSense(const DWORD *cdb, BYTE *buf) +{ + int size; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + + // 繧ｨ繝ｩ繝ｼ縺後↑縺蝣ｴ蜷医↓髯舌ｊ縲√ヮ繝繝医Ξ繝繧｣繧偵メ繧ｧ繝繧ｯ + if (disk.code == DISK_NOERROR) { + if (!disk.ready) { + disk.code = DISK_NOTREADY; + } + } + + // 繧ｵ繧､繧ｺ豎ｺ螳(繧｢繝ｭ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ繝ｬ繝ｳ繧ｰ繧ｹ縺ｫ蠕薙≧) + size = (int)cdb[4]; + ASSERT((size >= 0) && (size < 0x100)); + + // SCSI-1縺ｧ縺ｯ縲√し繧､繧ｺ0縺ｮ縺ｨ縺阪↓4繝舌う繝郁ｻ｢騾√☆繧(SCSI-2縺ｧ縺ｯ縺薙ｮ莉墓ｧ倥ｯ蜑企勁) + if (size == 0) { + size = 4; + } + + // 繝舌ャ繝輔ぃ繧偵け繝ｪ繧｢ + memset(buf, 0, size); + + // 諡｡蠑ｵ繧ｻ繝ｳ繧ｹ繝繝ｼ繧ｿ繧貞性繧√◆縲18繝舌う繝医ｒ險ｭ螳 + buf[0] = 0x70; + buf[2] = (BYTE)(disk.code >> 16); + buf[7] = 10; + buf[12] = (BYTE)(disk.code >> 8); + buf[13] = (BYTE)disk.code; + + // 繧ｳ繝ｼ繝峨ｒ繧ｯ繝ｪ繧｢ + disk.code = 0x00; + + return size; +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT繝√ぉ繝繧ｯ +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::SelectCheck(const DWORD *cdb) +{ + int length; + + ASSERT(this); + ASSERT(cdb); + + // SCSIHD縺ｧ縺ｪ縺上そ繝ｼ繝悶ヱ繝ｩ繝｡繝ｼ繧ｿ縺瑚ｨｭ螳壹＆繧後※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (disk.id != MAKEID('S', 'C', 'H', 'D')) { + // 繧ｻ繝ｼ繝悶ヱ繝ｩ繝｡繝ｼ繧ｿ縺瑚ｨｭ螳壹＆繧後※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return 0; + } + } + + // 繝代Λ繝｡繝ｼ繧ｿ繝ｬ繝ｳ繧ｰ繧ｹ縺ｧ謖螳壹＆繧後◆繝繝ｼ繧ｿ繧貞女縺大叙繧 + length = (int)cdb[4]; + return length; +} + + +//--------------------------------------------------------------------------- +// +// MODE SELECT(10)繝√ぉ繝繧ｯ +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::SelectCheck10(const DWORD *cdb) +{ + DWORD length; + + ASSERT(this); + ASSERT(cdb); + + // SCSIHD縺ｧ縺ｪ縺上そ繝ｼ繝悶ヱ繝ｩ繝｡繝ｼ繧ｿ縺瑚ｨｭ螳壹＆繧後※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (disk.id != MAKEID('S', 'C', 'H', 'D')) { + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return 0; + } + } + + // 繝代Λ繝｡繝ｼ繧ｿ繝ｬ繝ｳ繧ｰ繧ｹ縺ｧ謖螳壹＆繧後◆繝繝ｼ繧ｿ繧貞女縺大叙繧 + length = cdb[7]; + length <<= 8; + length |= cdb[8]; + if (length > 0x800) { + length = 0x800; + } + + return (int)length; +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::ModeSelect(const DWORD *cdb, const BYTE *buf, int length) +{ + ASSERT(this); + ASSERT(buf); + ASSERT(length >= 0); + + // 險ｭ螳壹〒縺阪↑縺 + disk.code = DISK_INVALIDPRM; + + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// MODE SENSE +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::ModeSense(const DWORD *cdb, BYTE *buf) +{ + int page; + int length; + int size; + BOOL valid; + BOOL change; + int ret; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x1a); + + // 繝ｬ繝ｳ繧ｰ繧ｹ蜿門ｾ励√ヰ繝繝輔ぃ繧ｯ繝ｪ繧｢ + length = (int)cdb[4]; + ASSERT((length >= 0) && (length < 0x100)); + memset(buf, 0, length); + + // 螟画峩蜿ｯ閭ｽ繝輔Λ繧ｰ蜿門ｾ + if ((cdb[2] & 0xc0) == 0x40) { + change = TRUE; + } else { + change = FALSE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝牙叙蠕(0x00縺ｯ譛蛻昴°繧益alid) + page = cdb[2] & 0x3f; + if (page == 0x00) { + valid = TRUE; + } else { + valid = FALSE; + } + + // 蝓ｺ譛ｬ諠蝣ｱ + size = 4; + + // MEDIUM TYPE + if (disk.id == MAKEID('S', 'C', 'M', 'O')) { + buf[1] = 0x03; // optical reversible or erasable + } + + // DEVICE SPECIFIC PARAMETER + if (disk.writep) { + buf[2] = 0x80; + } + + // DBD縺0縺ｪ繧峨√ヶ繝ｭ繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち繧定ｿｽ蜉 + if ((cdb[1] & 0x08) == 0) { + // 繝｢繝ｼ繝峨ヱ繝ｩ繝｡繝ｼ繧ｿ繝倥ャ繝 + buf[3] = 0x08; + + // 繝ｬ繝繧｣縺ｮ蝣ｴ蜷医↓髯舌ｊ + if (disk.ready) { + // 繝悶Ο繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち(繝悶Ο繝繧ｯ謨ｰ) + buf[5] = (BYTE)(disk.blocks >> 16); + buf[6] = (BYTE)(disk.blocks >> 8); + buf[7] = (BYTE)disk.blocks; + + // 繝悶Ο繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち(繝悶Ο繝繧ｯ繝ｬ繝ｳ繧ｰ繧ｹ) + size = 1 << disk.size; + buf[9] = (BYTE)(size >> 16); + buf[10] = (BYTE)(size >> 8); + buf[11] = (BYTE)size; + } + + // 繧ｵ繧､繧ｺ蜀崎ｨｭ螳 + size = 12; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝1(read-write error recovery) + if ((page == 0x01) || (page == 0x3f)) { + size += AddError(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝3(format device) + if ((page == 0x03) || (page == 0x3f)) { + size += AddFormat(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝4(drive parameter) + if ((page == 0x04) || (page == 0x3f)) { + size += AddDrive(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝6(optical) + if (disk.id == MAKEID('S', 'C', 'M', 'O')) { + if ((page == 0x06) || (page == 0x3f)) { + size += AddOpt(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝8(caching) + if ((page == 0x08) || (page == 0x3f)) { + size += AddCache(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝13(CD-ROM) + if (disk.id == MAKEID('S', 'C', 'C', 'D')) { + if ((page == 0x0d) || (page == 0x3f)) { + size += AddCDROM(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝14(CD-DA) + if (disk.id == MAKEID('S', 'C', 'C', 'D')) { + if ((page == 0x0e) || (page == 0x3f)) { + size += AddCDDA(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ(繝吶Φ繝迚ｹ谿) + ret = AddVendor(page, change, &buf[size]); + if (ret > 0) { + size += ret; + valid = TRUE; + } + + // 繝｢繝ｼ繝峨ョ繝ｼ繧ｿ繝ｬ繝ｳ繧ｰ繧ｹ繧呈怙邨りｨｭ螳 + buf[0] = (BYTE)(size - 1); + + // 繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繝壹ｼ繧ｸ縺 + if (!valid) { + disk.code = DISK_INVALIDCDB; + return 0; + } + + // MODE SENSE謌仙粥 + disk.code = DISK_NOERROR; + return length; +} + +//--------------------------------------------------------------------------- +// +// MODE SENSE(10) +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::ModeSense10(const DWORD *cdb, BYTE *buf) +{ + int page; + int length; + int size; + BOOL valid; + BOOL change; + int ret; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x5a); + + // 繝ｬ繝ｳ繧ｰ繧ｹ蜿門ｾ励√ヰ繝繝輔ぃ繧ｯ繝ｪ繧｢ + length = cdb[7]; + length <<= 8; + length |= cdb[8]; + if (length > 0x800) { + length = 0x800; + } + ASSERT((length >= 0) && (length < 0x800)); + memset(buf, 0, length); + + // 螟画峩蜿ｯ閭ｽ繝輔Λ繧ｰ蜿門ｾ + if ((cdb[2] & 0xc0) == 0x40) { + change = TRUE; + } else { + change = FALSE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝牙叙蠕(0x00縺ｯ譛蛻昴°繧益alid) + page = cdb[2] & 0x3f; + if (page == 0x00) { + valid = TRUE; + } else { + valid = FALSE; + } + + // 蝓ｺ譛ｬ諠蝣ｱ + size = 4; + if (disk.writep) { + buf[2] = 0x80; + } + + // DBD縺0縺ｪ繧峨√ヶ繝ｭ繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち繧定ｿｽ蜉 + if ((cdb[1] & 0x08) == 0) { + // 繝｢繝ｼ繝峨ヱ繝ｩ繝｡繝ｼ繧ｿ繝倥ャ繝 + buf[3] = 0x08; + + // 繝ｬ繝繧｣縺ｮ蝣ｴ蜷医↓髯舌ｊ + if (disk.ready) { + // 繝悶Ο繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち(繝悶Ο繝繧ｯ謨ｰ) + buf[5] = (BYTE)(disk.blocks >> 16); + buf[6] = (BYTE)(disk.blocks >> 8); + buf[7] = (BYTE)disk.blocks; + + // 繝悶Ο繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち(繝悶Ο繝繧ｯ繝ｬ繝ｳ繧ｰ繧ｹ) + size = 1 << disk.size; + buf[9] = (BYTE)(size >> 16); + buf[10] = (BYTE)(size >> 8); + buf[11] = (BYTE)size; + } + + // 繧ｵ繧､繧ｺ蜀崎ｨｭ螳 + size = 12; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝1(read-write error recovery) + if ((page == 0x01) || (page == 0x3f)) { + size += AddError(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝3(format device) + if ((page == 0x03) || (page == 0x3f)) { + size += AddFormat(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝4(drive parameter) + if ((page == 0x04) || (page == 0x3f)) { + size += AddDrive(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝6(optical) + if (disk.id == MAKEID('S', 'C', 'M', 'O')) { + if ((page == 0x06) || (page == 0x3f)) { + size += AddOpt(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝8(caching) + if ((page == 0x08) || (page == 0x3f)) { + size += AddCache(change, &buf[size]); + valid = TRUE; + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝13(CD-ROM) + if (disk.id == MAKEID('S', 'C', 'C', 'D')) { + if ((page == 0x0d) || (page == 0x3f)) { + size += AddCDROM(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝14(CD-DA) + if (disk.id == MAKEID('S', 'C', 'C', 'D')) { + if ((page == 0x0e) || (page == 0x3f)) { + size += AddCDDA(change, &buf[size]); + valid = TRUE; + } + } + + // 繝壹ｼ繧ｸ(繝吶Φ繝迚ｹ谿) + ret = AddVendor(page, change, &buf[size]); + if (ret > 0) { + size += ret; + valid = TRUE; + } + + // 繝｢繝ｼ繝峨ョ繝ｼ繧ｿ繝ｬ繝ｳ繧ｰ繧ｹ繧呈怙邨りｨｭ螳 + buf[0] = (BYTE)(size - 1); + + // 繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繝壹ｼ繧ｸ縺 + if (!valid) { + disk.code = DISK_INVALIDCDB; + return 0; + } + + // MODE SENSE謌仙粥 + disk.code = DISK_NOERROR; + return length; +} + +//--------------------------------------------------------------------------- +// +// 繧ｨ繝ｩ繝ｼ繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddError(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x01; + buf[1] = 0x0a; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 12; + } + + // 繝ｪ繝医Λ繧､繧ｫ繧ｦ繝ｳ繝医ｯ0縲√Μ繝溘ャ繝医ち繧､繝縺ｯ陬鄂ｮ蜀驛ｨ縺ｮ繝繝輔か繝ｫ繝亥､繧剃ｽｿ逕ｨ + return 12; +} + +//--------------------------------------------------------------------------- +// +// 繝輔か繝ｼ繝槭ャ繝医壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddFormat(BOOL change, BYTE *buf) +{ + int size; + + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x80 | 0x03; + buf[1] = 0x16; + + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚縺ｯ螟画峩蜿ｯ閭ｽ縺ｫ隕九○繧(螳滄圀縺ｫ縺ｯ螟画峩縺ｧ縺阪↑縺縺) + if (change) { + buf[0xc] = 0xff; + buf[0xd] = 0xff; + return 24; + } + + if (disk.ready) { + // 1繧ｾ繝ｼ繝ｳ縺ｮ繝医Λ繝繧ｯ謨ｰ繧8縺ｫ險ｭ螳(TODO) + buf[0x3] = 0x08; + + // 繧ｻ繧ｯ繧ｿ/繝医Λ繝繧ｯ繧25縺ｫ險ｭ螳(TODO) + buf[0xa] = 0x00; + buf[0xb] = 0x19; + + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚繧定ｨｭ螳 + size = 1 << disk.size; + buf[0xc] = (BYTE)(size >> 8); + buf[0xd] = (BYTE)size; + } + + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ螻樊ｧ繧定ｨｭ螳 + if (disk.removable) { + buf[20] = 0x20; + } + + return 24; +} + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝悶壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddDrive(BOOL change, BYTE *buf) +{ + DWORD cylinder; + + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x04; + buf[1] = 0x16; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 24; + } + + if (disk.ready) { + // 繧ｷ繝ｪ繝ｳ繝謨ｰ繧定ｨｭ螳(邱上ヶ繝ｭ繝繧ｯ謨ｰ繧25繧ｻ繧ｯ繧ｿ/繝医Λ繝繧ｯ縺ｨ8繝倥ャ繝峨〒髯､邂) + cylinder = disk.blocks; + cylinder >>= 3; + cylinder /= 25; + buf[0x2] = (BYTE)(cylinder >> 16); + buf[0x3] = (BYTE)(cylinder >> 8); + buf[0x4] = (BYTE)cylinder; + + // 繝倥ャ繝峨ｒ8縺ｧ蝗ｺ螳 + buf[0x5] = 0x8; + } + + return 24; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝励ユ繧｣繧ｫ繝ｫ繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddOpt(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x06; + buf[1] = 0x02; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 4; + } + + // 譖ｴ譁ｰ繝悶Ο繝繧ｯ縺ｮ繝ｬ繝昴ｼ繝医ｯ陦後ｏ縺ｪ縺 + return 4; +} + +//--------------------------------------------------------------------------- +// +// 繧ｭ繝｣繝繧ｷ繝･繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddCache(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x08; + buf[1] = 0x0a; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 12; + } + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｭ繝｣繝繧ｷ繝･縺ｮ縺ｿ譛牙柑縲√励Μ繝輔ぉ繝繝√ｯ陦後ｏ縺ｪ縺 + return 12; +} + +//--------------------------------------------------------------------------- +// +// CD-ROM繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddCDROM(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x0d; + buf[1] = 0x06; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 8; + } + + // 繧､繝ｳ繧｢繧ｯ繝繧｣繝悶ち繧､繝槭ｯ2sec + buf[3] = 0x05; + + // MSF蛟肴焚縺ｯ縺昴ｌ縺槭ｌ60, 75 + buf[5] = 60; + buf[7] = 75; + + return 8; +} + +//--------------------------------------------------------------------------- +// +// CD-DA繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddCDDA(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x0e; + buf[1] = 0x0e; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 16; + } + + // 繧ｪ繝ｼ繝繧｣繧ｪ縺ｯ謫堺ｽ懷ｮ御ｺ繧貞ｾ縺｡縲 隍謨ｰ繝医Λ繝繧ｯ縺ｫ縺ｾ縺溘′繧輝LAY繧定ｨｱ蜿ｯ縺吶ｋ + return 16; +} + +//--------------------------------------------------------------------------- +// +// Vendor迚ｹ谿翫壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::AddVendor(int page, BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + return 0; +} + +//--------------------------------------------------------------------------- +// +// READ DEFECT DATA(10) +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::ReadDefectData10(const DWORD *cdb, BYTE *buf) +{ + DWORD length; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x37); + + // 繝ｬ繝ｳ繧ｰ繧ｹ蜿門ｾ励√ヰ繝繝輔ぃ繧ｯ繝ｪ繧｢ + length = cdb[7]; + length <<= 8; + length |= cdb[8]; + if (length > 0x800) { + length = 0x800; + } + ASSERT((length >= 0) && (length < 0x800)); + memset(buf, 0, length); + + // P/G/FORMAT + buf[1] = (cdb[1] & 0x18) | 5; + buf[3] = 8; + + buf[4] = 0xff; + buf[5] = 0xff; + buf[6] = 0xff; + buf[7] = 0xff; + + buf[8] = 0xff; + buf[9] = 0xff; + buf[10] = 0xff; + buf[11] = 0xff; + + // 繝ｪ繧ｹ繝育┌縺 + disk.code = DISK_NODEFECT; + return 4; +} + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// TEST UNIT READY +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::TestUnitReady(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // TEST UNIT READY謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// REZERO UNIT +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Rezero(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // REZERO謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// FORMAT UNIT +// 窶ｻSASI縺ｯ繧ｪ繝壹さ繝ｼ繝$06縲ヾCSI縺ｯ繧ｪ繝壹さ繝ｼ繝$04 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Format(const DWORD *cdb) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // FMTDATA=1縺ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺(菴縺優EFECT LIST縺檎┌縺縺ｪ繧碓K) + if ((cdb[1] & 0x10) != 0 && cdb[4] != 0) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // FORMAT謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// REASSIGN BLOCKS +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Reassign(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // REASSIGN BLOCKS謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// READ +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::Read(BYTE *buf, DWORD block) +{ + ASSERT(this); + ASSERT(buf); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 繝医ｼ繧ｿ繝ｫ繝悶Ο繝繧ｯ謨ｰ繧定ｶ縺医※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (block >= disk.blocks) { + disk.code = DISK_INVALIDLBA; + return 0; + } + + // 繧ｭ繝｣繝繧ｷ繝･縺ｫ莉ｻ縺帙ｋ + if (!disk.dcache->Read(buf, block)) { + disk.code = DISK_READFAULT; + return 0; + } + + // 謌仙粥 + return (1 << disk.size); +} + +//--------------------------------------------------------------------------- +// +// WRITE繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::WriteCheck(DWORD block) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 繝医ｼ繧ｿ繝ｫ繝悶Ο繝繧ｯ謨ｰ繧定ｶ縺医※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (block >= disk.blocks) { + return 0; + } + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺ｪ繧峨お繝ｩ繝ｼ + if (disk.writep) { + disk.code = DISK_WRITEPROTECT; + return 0; + } + + // 謌仙粥 + return (1 << disk.size); +} + +//--------------------------------------------------------------------------- +// +// WRITE +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Write(const BYTE *buf, DWORD block) +{ + ASSERT(this); + ASSERT(buf); + + // 繝ｬ繝繧｣縺ｧ縺ｪ縺代ｌ縺ｰ繧ｨ繝ｩ繝ｼ + if (!disk.ready) { + disk.code = DISK_NOTREADY; + return FALSE; + } + + // 繝医ｼ繧ｿ繝ｫ繝悶Ο繝繧ｯ謨ｰ繧定ｶ縺医※縺繧後ｰ繧ｨ繝ｩ繝ｼ + if (block >= disk.blocks) { + disk.code = DISK_INVALIDLBA; + return FALSE; + } + + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢縺ｪ繧峨お繝ｩ繝ｼ + if (disk.writep) { + disk.code = DISK_WRITEPROTECT; + return FALSE; + } + + // 繧ｭ繝｣繝繧ｷ繝･縺ｫ莉ｻ縺帙ｋ + if (!disk.dcache->Write(buf, block)) { + disk.code = DISK_WRITEFAULT; + return FALSE; + } + + // 繝ｩ繧､繝医せ繝ｫ繝ｼ繧ｭ繝｣繝繧ｷ繝･ + if (!cache_wb) { + Flush(); + } + + // 謌仙粥 + disk.code = DISK_NOERROR; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// SEEK +// 窶ｻLBA縺ｮ繝√ぉ繝繧ｯ縺ｯ陦後ｏ縺ｪ縺(SASI IOCS) +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Seek(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // SEEK謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// ASSIGN +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Assign(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // 謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// SPECIFY +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Specify(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // 謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// START STOP UNIT +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::StartStop(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x1b); + + // 繧､繧ｸ繧ｧ繧ｯ繝医ン繝繝医ｒ隕九※縲∝ｿ隕√↑繧峨う繧ｸ繧ｧ繧ｯ繝 + if (cdb[4] & 0x02) { + if (disk.lock) { + // 繝ｭ繝繧ｯ縺輔ｌ縺ｦ縺繧九ｮ縺ｧ縲√う繧ｸ繧ｧ繧ｯ繝医〒縺阪↑縺 + disk.code = DISK_PREVENT; + return FALSE; + } + + // 繧､繧ｸ繧ｧ繧ｯ繝 + Eject(FALSE); + } + + // OK + disk.code = DISK_NOERROR; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// SEND DIAGNOSTIC +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::SendDiag(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x1d); + + // PF繝薙ャ繝医ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + if (cdb[1] & 0x10) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // 繝代Λ繝｡繝ｼ繧ｿ繝ｪ繧ｹ繝医ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + if ((cdb[3] != 0) || (cdb[4] != 0)) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // 蟶ｸ縺ｫ謌仙粥 + disk.code = DISK_NOERROR; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// PREVENT/ALLOW MEDIUM REMOVAL +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Removal(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x1e); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return FALSE; + } + + // 繝ｭ繝繧ｯ繝輔Λ繧ｰ繧定ｨｭ螳 + if (cdb[4] & 0x01) { + disk.lock = TRUE; + } else { + disk.lock = FALSE; + } + + // REMOVAL謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// READ CAPACITY +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::ReadCapacity(const DWORD* /*cdb*/, BYTE *buf) +{ + DWORD blocks; + DWORD length; + + ASSERT(this); + ASSERT(buf); + + // 繝舌ャ繝輔ぃ繧ｯ繝ｪ繧｢ + memset(buf, 0, 8); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 隲也炊繝悶Ο繝繧ｯ繧｢繝峨Ξ繧ｹ縺ｮ邨らｫｯ(disk.blocks - 1)繧剃ｽ懈 + ASSERT(disk.blocks > 0); + blocks = disk.blocks - 1; + buf[0] = (BYTE)(blocks >> 24); + buf[1] = (BYTE)(blocks >> 16); + buf[2] = (BYTE)(blocks >> 8); + buf[3] = (BYTE)blocks; + + // 繝悶Ο繝繧ｯ繝ｬ繝ｳ繧ｰ繧ｹ(1 << disk.size)繧剃ｽ懈 + length = 1 << disk.size; + buf[4] = (BYTE)(length >> 24); + buf[5] = (BYTE)(length >> 16); + buf[6] = (BYTE)(length >> 8); + buf[7] = (BYTE)length; + + // 霑秘√し繧､繧ｺ繧定ｿ斐☆ + return 8; +} + +//--------------------------------------------------------------------------- +// +// VERIFY +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::Verify(const DWORD *cdb) +{ + DWORD record; + DWORD blocks; + + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x2f); + + // 繝代Λ繝｡繝ｼ繧ｿ蜿門ｾ + record = cdb[2]; + record <<= 8; + record |= cdb[3]; + record <<= 8; + record |= cdb[4]; + record <<= 8; + record |= cdb[5]; + blocks = cdb[7]; + blocks <<= 8; + blocks |= cdb[8]; + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 繝代Λ繝｡繝ｼ繧ｿ繝√ぉ繝繧ｯ + if (disk.blocks < (record + blocks)) { + disk.code = DISK_INVALIDLBA; + return FALSE; + } + + // 謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// READ TOC +// +//--------------------------------------------------------------------------- +int FASTCALL Disk::ReadToc(const DWORD *cdb, BYTE *buf) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x43); + ASSERT(buf); + + // 縺薙ｮ繧ｳ繝槭Φ繝峨ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + disk.code = DISK_INVALIDCMD; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::PlayAudio(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x45); + + // 縺薙ｮ繧ｳ繝槭Φ繝峨ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + disk.code = DISK_INVALIDCMD; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO MSF +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::PlayAudioMSF(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x47); + + // 縺薙ｮ繧ｳ繝槭Φ繝峨ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + disk.code = DISK_INVALIDCMD; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO TRACK +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Disk::PlayAudioTrack(const DWORD *cdb) +{ + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x48); + + // 縺薙ｮ繧ｳ繝槭Φ繝峨ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + disk.code = DISK_INVALIDCMD; + return FALSE; +} + +//=========================================================================== +// +// SASI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SASIHD::SASIHD() : Disk() +{ + // SASI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ + disk.id = MAKEID('S', 'A', 'H', 'D'); +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIHD::Reset() +{ + // 繝ｭ繝繧ｯ迥ｶ諷玖ｧ｣髯､縲√い繝繝ｳ繧ｷ繝ｧ繝ｳ隗｣髯､ + disk.lock = FALSE; + disk.attn = FALSE; + + // 繝ｪ繧ｻ繝繝医↑縺励√さ繝ｼ繝峨ｒ繧ｯ繝ｪ繧｢ + disk.reset = FALSE; + disk.code = 0x00; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIHD::Open(const Filepath& path, BOOL /*attn*/) +{ + Fileio fio; + off64_t size; + + ASSERT(this); + ASSERT(!disk.ready); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ縺ｮ蜿門ｾ + size = fio.GetFileSize(); + fio.Close(); + + // 10MB, 20MB, 40MB縺ｮ縺ｿ + switch (size) { + // 10MB + case 0x9f5400: + break; + + // 20MB + case 0x13c9800: + break; + + // 40MB + case 0x2793000: + break; + + // 縺昴ｮ莉(繧ｵ繝昴ｼ繝医＠縺ｪ縺) + default: + return FALSE; + } + + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ縺ｨ繝悶Ο繝繧ｯ謨ｰ + disk.size = 8; + disk.blocks = (DWORD)(size >> 8); + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + return Disk::Open(path); +} + +//--------------------------------------------------------------------------- +// +// REQUEST SENSE +// +//--------------------------------------------------------------------------- +int FASTCALL SASIHD::RequestSense(const DWORD *cdb, BYTE *buf) +{ + int size; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + + // 繧ｵ繧､繧ｺ豎ｺ螳 + size = (int)cdb[4]; + ASSERT((size >= 0) && (size < 0x100)); + + // SASI縺ｯ髱樊僑蠑ｵ繝輔か繝ｼ繝槭ャ繝医↓蝗ｺ螳 + memset(buf, 0, size); + buf[0] = (BYTE)(disk.code >> 16); + buf[1] = (BYTE)(disk.lun << 5); + + // 繧ｳ繝ｼ繝峨ｒ繧ｯ繝ｪ繧｢ + disk.code = 0x00; + + return size; +} + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIHD::SCSIHD() : Disk() +{ + // SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ + disk.id = MAKEID('S', 'C', 'H', 'D'); +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIHD::Reset() +{ + // 繝ｭ繝繧ｯ迥ｶ諷玖ｧ｣髯､縲√い繝繝ｳ繧ｷ繝ｧ繝ｳ隗｣髯､ + disk.lock = FALSE; + disk.attn = FALSE; + + // 繝ｪ繧ｻ繝繝医↑縺励√さ繝ｼ繝峨ｒ繧ｯ繝ｪ繧｢ + disk.reset = FALSE; + disk.code = 0x00; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIHD::Open(const Filepath& path, BOOL /*attn*/) +{ + Fileio fio; + off64_t size; + + ASSERT(this); + ASSERT(!disk.ready); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ縺ｮ蜿門ｾ + size = fio.GetFileSize(); + fio.Close(); + + // 512繝舌う繝亥腰菴阪〒縺ゅｋ縺薙→ + if (size & 0x1ff) { + return FALSE; + } + + // 10MB莉･荳 + if (size < 0x9f5400) { + return FALSE; + } + // xm6i縺ｫ貅悶§縺ｦ2TB + // 繧医￥莨ｼ縺溘ｂ縺ｮ縺 wxw/wxw_cfg.cpp 縺ｫ繧ゅ≠繧 + if (size > 2LL * 1024 * 1024 * 1024 * 1024) { + return FALSE; + } + + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ縺ｨ繝悶Ο繝繧ｯ謨ｰ + disk.size = 9; + disk.blocks = (DWORD)(size >> 9); + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + return Disk::Open(path); +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + char vendor[32]; + char product[32]; + char rev[32]; + int size; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x12); + + // EVPD繝√ぉ繝繧ｯ + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return 0; + } + + // 繝ｬ繝繧｣繝√ぉ繝繧ｯ(繧､繝｡繝ｼ繧ｸ繝輔ぃ繧､繝ｫ縺後↑縺蝣ｴ蜷医√お繝ｩ繝ｼ縺ｨ縺吶ｋ) + if (!disk.ready) { + disk.code = DISK_NOTREADY; + return 0; + } + + // 蝓ｺ譛ｬ繝繝ｼ繧ｿ + // buf[0] ... Direct Access Device + // buf[2] ... SCSI-2貅匁侠縺ｮ繧ｳ繝槭Φ繝我ｽ鍋ｳｻ + // buf[3] ... SCSI-2貅匁侠縺ｮInquiry繝ｬ繧ｹ繝昴Φ繧ｹ + // buf[4] ... Inquiry霑ｽ蜉繝繝ｼ繧ｿ + memset(buf, 0, 8); + + // SCSI-2 譛ｬ縺ｮ p.104 4.4.3 荳榊ｽ薙↑繝ｭ繧ｸ繧ｫ繝ｫ繝ｦ繝九ャ繝医ｮ蜃ｦ逅 + if (((cdb[1] >> 5) & 0x07) != disk.lun) { + buf[0] = 0x7f; + } + + buf[2] = 0x02; + buf[3] = 0x02; + buf[4] = 122 + 3; // 螳櫞DD縺ｫ霑代＞蛟､ + + // 遨ｺ逋ｽ縺ｧ蝓九ａ繧 + memset(&buf[8], 0x20, buf[4] - 3); + + // 繝吶Φ繝蜷/陬ｽ蜩∝錐繧呈ｱｺ螳 + sprintf(vendor, BENDER_SIGNATURE); + size = disk.blocks >> 11; + if (size < 300) + sprintf(product, "PRODRIVE LPS%dS", size); + else if (size < 600) + sprintf(product, "MAVERICK%dS", size); + else if (size < 800) + sprintf(product, "LIGHTNING%dS", size); + else if (size < 1000) + sprintf(product, "TRAILBRAZER%dS", size); + else if (size < 2000) + sprintf(product, "FIREBALL%dS", size); + else + sprintf(product, "FBSE%d.%dS", size / 1000, (size % 1000) / 100); + + // 繝吶Φ繝蜷 + memcpy(&buf[8], vendor, strlen(vendor)); + + // 陬ｽ蜩∝錐 + memcpy(&buf[16], product, strlen(product)); + + // 繝ｪ繝薙ず繝ｧ繝ｳ + sprintf(rev, "0%01d%01d%01d", + (int)major, (int)(minor >> 4), (int)(minor & 0x0f)); + memcpy(&buf[32], rev, 4); + + // 霑泌唆縺ｧ縺阪ｋ繝繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + size = (buf[4] + 5); + + // 逶ｸ謇九ｮ繝舌ャ繝輔ぃ縺悟ｰ代↑縺代ｌ縺ｰ蛻ｶ髯舌☆繧 + if (size > (int)cdb[4]) { + size = (int)cdb[4]; + } + + // 謌仙粥 + disk.code = DISK_NOERROR; + return size; +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIHD::ModeSelect(const DWORD *cdb, const BYTE *buf, int length) +{ + int page; + int size; + + ASSERT(this); + ASSERT(buf); + ASSERT(length >= 0); + + // PF + if (cdb[1] & 0x10) { + // Mode Parameter header + if (length >= 12) { + // 繝悶Ο繝繧ｯ繝ｬ繝ｳ繧ｰ繧ｹ縺ｮ繝舌う繝域焚繧偵メ繧ｧ繝繧ｯ + size = 1 << disk.size; + if (buf[9] != (BYTE)(size >> 16) || + buf[10] != (BYTE)(size >> 8) || buf[11] != (BYTE)size) { + // 莉翫ｮ縺ｨ縺薙ｍ繧ｻ繧ｯ繧ｿ髟ｷ縺ｮ螟画峩縺ｯ險ｱ縺輔↑縺 + disk.code = DISK_INVALIDPRM; + return FALSE; + } + buf += 12; + length -= 12; + } + + // 繝壹ｼ繧ｸ縺ｮ隗｣譫 + while (length > 0) { + // 繝壹ｼ繧ｸ縺ｮ蜿門ｾ + page = buf[0]; + + switch (page) { + // format device + case 0x03: + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚繧偵メ繧ｧ繝繧ｯ + size = 1 << disk.size; + if (buf[0xc] != (BYTE)(size >> 8) || buf[0xd] != (BYTE)size) { + // 莉翫ｮ縺ｨ縺薙ｍ繧ｻ繧ｯ繧ｿ髟ｷ縺ｮ螟画峩縺ｯ險ｱ縺輔↑縺 + disk.code = DISK_INVALIDPRM; + return FALSE; + } + break; + + // 縺昴ｮ莉悶壹ｼ繧ｸ + default: + break; + } + + // 谺｡縺ｮ繝壹ｼ繧ｸ縺ｸ + size = buf[1] + 2; + length -= size; + buf += size; + } + } + + // 縺ｨ繧翫≠縺医★繧ｨ繝ｩ繝ｼ縺ｯ逋ｺ逕溘＆縺帙↑縺(MINIX) + disk.code = DISK_NOERROR; + + return TRUE; +} + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ(PC-9801-55 NEC邏疲ｭ｣/Anex86/T98Next) +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIHD_NEC::SCSIHD_NEC() : SCSIHD() +{ + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + cylinders = 0; + heads = 0; + sectors = 0; + sectorsize = 0; + imgoffset = 0; + imgsize = 0; +} + +static inline WORD getWordLE(const BYTE *b) +{ + return ((WORD)(b[1]) << 8) | b[0]; +} +static inline DWORD getDwordLE(const BYTE *b) +{ + return ((DWORD)(b[3]) << 24) | ((DWORD)(b[2]) << 16) | + ((DWORD)(b[1]) << 8) | b[0]; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL attn) +{ + Fileio fio; + off64_t size; + BYTE hdr[512]; + LPCTSTR ext; + + ASSERT(this); + ASSERT(!disk.ready); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ縺ｮ蜿門ｾ + size = fio.GetFileSize(); + + // 繝倥ャ繝繝ｼ隱ｭ縺ｿ霎ｼ縺ｿ + if (size >= sizeof(hdr)) { + if (!fio.Read(hdr, sizeof(hdr))) { + fio.Close(); + return FALSE; + } + } + fio.Close(); + + // 512繝舌う繝亥腰菴阪〒縺ゅｋ縺薙→ + if (size & 0x1ff) { + return FALSE; + } + + // 10MB莉･荳 + if (size < 0x9f5400) { + return FALSE; + } + // xm6i縺ｫ貅悶§縺ｦ2TB + // 繧医￥莨ｼ縺溘ｂ縺ｮ縺 wxw/wxw_cfg.cpp 縺ｫ繧ゅ≠繧 + if (size > 2LL * 1024 * 1024 * 1024 * 1024) { + return FALSE; + } + + // 諡｡蠑ｵ蟄仙挨縺ｫ繝代Λ繝｡繝ｼ繧ｿ繧呈ｱｺ螳 + ext = path.GetFileExt(); + if (xstrcasecmp(ext, ".HDN") == 0) { + // 繝繝輔か繝ｫ繝郁ｨｭ螳壹→縺励※繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ512,繧ｻ繧ｯ繧ｿ謨ｰ25,繝倥ャ繝画焚8繧呈Φ螳 + imgoffset = 0; + imgsize = size; + sectorsize = 512; + sectors = 25; + heads = 8; + cylinders = (int)(size >> 9); + cylinders >>= 3; + cylinders /= 25; + } else if (xstrcasecmp(ext, ".HDI") == 0) { // Anex86 HD image? + imgoffset = getDwordLE(&hdr[4 + 4]); + imgsize = getDwordLE(&hdr[4 + 4 + 4]); + sectorsize = getDwordLE(&hdr[4 + 4 + 4 + 4]); + sectors = getDwordLE(&hdr[4 + 4 + 4 + 4 + 4]); + heads = getDwordLE(&hdr[4 + 4 + 4 + 4 + 4 + 4]); + cylinders = getDwordLE(&hdr[4 + 4 + 4 + 4 + 4 + 4 + 4]); + } else if (xstrcasecmp(ext, ".NHD") == 0 && + memcmp(hdr, "T98HDDIMAGE.R0\0", 15) == 0) { // T98Next HD image? + imgoffset = getDwordLE(&hdr[0x10 + 0x100]); + cylinders = getDwordLE(&hdr[0x10 + 0x100 + 4]); + heads = getWordLE(&hdr[0x10 + 0x100 + 4 + 4]); + sectors = getWordLE(&hdr[0x10 + 0x100 + 4 + 4 + 2]); + sectorsize = getWordLE(&hdr[0x10 + 0x100 + 4 + 4 + 2 + 2]); + imgsize = (off64_t)cylinders * heads * sectors * sectorsize; + } + + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ縺ｯ256縺ｾ縺溘ｯ512繧偵し繝昴ｼ繝 + if (sectorsize != 256 && sectorsize != 512) { + return FALSE; + } + + // 繧､繝｡繝ｼ繧ｸ繧ｵ繧､繧ｺ縺ｮ謨ｴ蜷域ｧ繝√ぉ繝繧ｯ + if (imgoffset + imgsize > size || (imgsize % sectorsize != 0)) { + return FALSE; + } + + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ + for(disk.size = 16; disk.size > 0; --(disk.size)) { + if ((1 << disk.size) == sectorsize) + break; + } + if (disk.size <= 0 || disk.size > 16) { + return FALSE; + } + + // 繝悶Ο繝繧ｯ謨ｰ + disk.blocks = (DWORD)(imgsize >> disk.size); + disk.imgoffset = imgoffset; + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + return Disk::Open(path); +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_NEC::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + int size; + + // 蝓ｺ蠎輔け繝ｩ繧ｹ + size = SCSIHD::Inquiry(cdb, buf, major, minor); + + // 蝓ｺ蠎輔け繝ｩ繧ｹ縺ｧ繧ｨ繝ｩ繝ｼ縺ｪ繧臥ｵゆｺ + if (size == 0) { + return 0; + } + + // SCSI1逶ｸ蠖薙↓螟画峩 + buf[2] = 0x01; + buf[3] = 0x01; + + // 繝吶Φ繝繝ｼ蜷榊ｷｮ縺玲崛縺 + buf[8] = 'N'; + buf[9] = 'E'; + buf[10] = 'C'; + + return size; +} + +//--------------------------------------------------------------------------- +// +// 繧ｨ繝ｩ繝ｼ繝壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_NEC::AddError(BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x01; + buf[1] = 0x06; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 8; + } + + // 繝ｪ繝医Λ繧､繧ｫ繧ｦ繝ｳ繝医ｯ0縲√Μ繝溘ャ繝医ち繧､繝縺ｯ陬鄂ｮ蜀驛ｨ縺ｮ繝繝輔か繝ｫ繝亥､繧剃ｽｿ逕ｨ + return 8; +} + +//--------------------------------------------------------------------------- +// +// 繝輔か繝ｼ繝槭ャ繝医壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf) +{ + int size; + + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x80 | 0x03; + buf[1] = 0x16; + + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚縺ｯ螟画峩蜿ｯ閭ｽ縺ｫ隕九○繧(螳滄圀縺ｫ縺ｯ螟画峩縺ｧ縺阪↑縺縺) + if (change) { + buf[0xc] = 0xff; + buf[0xd] = 0xff; + return 24; + } + + if (disk.ready) { + // 1繧ｾ繝ｼ繝ｳ縺ｮ繝医Λ繝繧ｯ謨ｰ繧定ｨｭ螳(PC-9801-55縺ｯ縺薙ｮ蛟､繧定ｦ九※縺繧九ｈ縺縺) + buf[0x2] = (BYTE)(heads >> 8); + buf[0x3] = (BYTE)heads; + + // 1繝医Λ繝繧ｯ縺ｮ繧ｻ繧ｯ繧ｿ謨ｰ繧定ｨｭ螳 + buf[0xa] = (BYTE)(sectors >> 8); + buf[0xb] = (BYTE)sectors; + + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚繧定ｨｭ螳 + size = 1 << disk.size; + buf[0xc] = (BYTE)(size >> 8); + buf[0xd] = (BYTE)size; + } + + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ螻樊ｧ繧定ｨｭ螳(譏斐ｮ蜷肴ｮ) + if (disk.removable) { + buf[20] = 0x20; + } + + return 24; +} + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝悶壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_NEC::AddDrive(BOOL change, BYTE *buf) +{ + DWORD cylinder; + + ASSERT(this); + ASSERT(buf); + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x04; + buf[1] = 0x12; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 20; + } + + if (disk.ready) { + // 繧ｷ繝ｪ繝ｳ繝謨ｰ繧定ｨｭ螳 + buf[0x2] = (BYTE)(cylinders >> 16); + buf[0x3] = (BYTE)(cylinders >> 8); + buf[0x4] = (BYTE)cylinders; + + // 繝倥ャ繝画焚繧定ｨｭ螳 + buf[0x5] = (BYTE)heads; + } + + return 20; +} + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ(Macintosh Apple邏疲ｭ｣) +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIHD_APPLE::SCSIHD_APPLE() : SCSIHD() +{ +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_APPLE::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + int size; + char vendor[32]; + char product[32]; + + // 蝓ｺ蠎輔け繝ｩ繧ｹ + size = SCSIHD::Inquiry(cdb, buf, major, minor); + + // 蝓ｺ蠎輔け繝ｩ繧ｹ縺ｧ繧ｨ繝ｩ繝ｼ縺ｪ繧臥ｵゆｺ + if (size == 0) { + return 0; + } + + // 繝吶Φ繝蜷 + sprintf(vendor, " SEAGATE"); + memcpy(&buf[8], vendor, strlen(vendor)); + + // 陬ｽ蜩∝錐 + sprintf(product, " ST225N"); + memcpy(&buf[16], product, strlen(product)); + + return size; +} + +//--------------------------------------------------------------------------- +// +// Vendor迚ｹ谿翫壹ｼ繧ｸ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIHD_APPLE::AddVendor(int page, BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝48 + if ((page != 0x30) && (page != 0x3f)) { + return 0; + } + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x30; + buf[1] = 0x1c; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 30; + } + + // APPLE COMPUTER, INC. + memcpy(&buf[0xa], "APPLE COMPUTER, INC.", 20); + + return 30; +} + +//=========================================================================== +// +// SCSI 蜈臥｣∵ｰ励ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIMO::SCSIMO() : Disk() +{ + // SCSI 蜈臥｣∵ｰ励ョ繧｣繧ｹ繧ｯ + disk.id = MAKEID('S', 'C', 'M', 'O'); + + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ + disk.removable = TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIMO::Open(const Filepath& path, BOOL attn) +{ + Fileio fio; + off64_t size; + + ASSERT(this); + ASSERT(!disk.ready); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ縺ｮ蜿門ｾ + size = fio.GetFileSize(); + fio.Close(); + + switch (size) { + // 128MB + case 0x797f400: + disk.size = 9; + disk.blocks = 248826; + break; + + // 230MB + case 0xd9eea00: + disk.size = 9; + disk.blocks = 446325; + break; + + // 540MB + case 0x1fc8b800: + disk.size = 9; + disk.blocks = 1041500; + break; + + // 640MB + case 0x25e28000: + disk.size = 11; + disk.blocks = 310352; + break; + + // 縺昴ｮ莉(繧ｨ繝ｩ繝ｼ) + default: + return FALSE; + } + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + Disk::Open(path); + + // 繝ｬ繝繧｣縺ｪ繧峨い繝繝ｳ繧ｷ繝ｧ繝ｳ + if (disk.ready && attn) { + disk.attn = TRUE; + } + + return TRUE; +} + +#ifndef RASCSI +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIMO::Load(Fileio *fio, int ver) +{ + DWORD sz; + disk_t buf; + DWORD padding; + Filepath path; + + ASSERT(this); + ASSERT(fio); + ASSERT(ver >= 0x0200); + + // version2.03繧医ｊ蜑阪ｯ縲√ョ繧｣繧ｹ繧ｯ縺ｯ繧ｻ繝ｼ繝悶＠縺ｦ縺縺ｪ縺 + if (ver <= 0x0202) { + return TRUE; + } + + // 繧ｵ繧､繧ｺ繧偵Ο繝ｼ繝峨∫ｧ蜷 + if (!fio->Read(&sz, sizeof(sz))) { + return FALSE; + } + if (sz != 52) { + return FALSE; + } + + // 繝舌ャ繝輔ぃ縺ｸ繝ｭ繝ｼ繝 + PROP_IMPORT(fio, buf.id); + PROP_IMPORT(fio, buf.ready); + PROP_IMPORT(fio, buf.writep); + PROP_IMPORT(fio, buf.readonly); + PROP_IMPORT(fio, buf.removable); + PROP_IMPORT(fio, buf.lock); + PROP_IMPORT(fio, buf.attn); + PROP_IMPORT(fio, buf.reset); + PROP_IMPORT(fio, buf.size); + PROP_IMPORT(fio, buf.blocks); + PROP_IMPORT(fio, buf.lun); + PROP_IMPORT(fio, buf.code); + PROP_IMPORT(fio, padding); + + // 繝代せ繧偵Ο繝ｼ繝 + if (!path.Load(fio, ver)) { + return FALSE; + } + + // 蠢縺壹う繧ｸ繧ｧ繧ｯ繝 + Eject(TRUE); + + // ID縺御ｸ閾ｴ縺励◆蝣ｴ蜷医ｮ縺ｿ縲∫ｧｻ蜍 + if (disk.id != buf.id) { + // 繧ｻ繝ｼ繝匁凾縺ｫMO縺ｧ縺ｪ縺九▲縺溘ゅう繧ｸ繧ｧ繧ｯ繝育憾諷九ｒ邯ｭ謖 + return TRUE; + } + + // 蜀阪が繝ｼ繝励Φ繧定ｩｦ縺ｿ繧 + if (!Open(path, FALSE)) { + // 蜀阪が繝ｼ繝励Φ縺ｧ縺阪↑縺縲ゅう繧ｸ繧ｧ繧ｯ繝育憾諷九ｒ邯ｭ謖 + return TRUE; + } + + // Open蜀縺ｧ繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･縺ｯ菴懈舌＆繧後※縺繧九ゅ励Ο繝代ユ繧｣縺ｮ縺ｿ遘ｻ蜍 + if (!disk.readonly) { + disk.writep = buf.writep; + } + disk.lock = buf.lock; + disk.attn = buf.attn; + disk.reset = buf.reset; + disk.lun = buf.lun; + disk.code = buf.code; + + // 豁｣蟶ｸ縺ｫ繝ｭ繝ｼ繝峨〒縺阪◆ + return TRUE; +} +#endif // RASCSI + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIMO::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + int size; + char rev[32]; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x12); + + // EVPD繝√ぉ繝繧ｯ + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // 蝓ｺ譛ｬ繝繝ｼ繧ｿ + // buf[0] ... Optical Memory Device + // buf[1] ... 繝ｪ繝繝ｼ繝舌ヶ繝ｫ + // buf[2] ... SCSI-2貅匁侠縺ｮ繧ｳ繝槭Φ繝我ｽ鍋ｳｻ + // buf[3] ... SCSI-2貅匁侠縺ｮInquiry繝ｬ繧ｹ繝昴Φ繧ｹ + // buf[4] ... Inquiry霑ｽ蜉繝繝ｼ繧ｿ + memset(buf, 0, 8); + buf[0] = 0x07; + + // SCSI-2 譛ｬ縺ｮ p.104 4.4.3 荳榊ｽ薙↑繝ｭ繧ｸ繧ｫ繝ｫ繝ｦ繝九ャ繝医ｮ蜃ｦ逅 + if (((cdb[1] >> 5) & 0x07) != disk.lun) { + buf[0] = 0x7f; + } + + buf[1] = 0x80; + buf[2] = 0x02; + buf[3] = 0x02; + buf[4] = 36 - 5; // 蠢鬆 + + // 遨ｺ逋ｽ縺ｧ蝓九ａ繧 + memset(&buf[8], 0x20, buf[4] - 3); + + // 繝吶Φ繝 + memcpy(&buf[8], BENDER_SIGNATURE, strlen(BENDER_SIGNATURE)); + + // 陬ｽ蜩∝錐 + memcpy(&buf[16], "M2513A", 6); + + // 繝ｪ繝薙ず繝ｧ繝ｳ(XM6縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳNo) + sprintf(rev, "0%01d%01d%01d", + (int)major, (int)(minor >> 4), (int)(minor & 0x0f)); + memcpy(&buf[32], rev, 4); + + // 霑泌唆縺ｧ縺阪ｋ繝繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + size = (buf[4] + 5); + + // 逶ｸ謇九ｮ繝舌ャ繝輔ぃ縺悟ｰ代↑縺代ｌ縺ｰ蛻ｶ髯舌☆繧 + if (size > (int)cdb[4]) { + size = (int)cdb[4]; + } + + // 謌仙粥 + disk.code = DISK_NOERROR; + return size; +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT +// 窶ｻdisk.code縺ｮ蠖ｱ髻ｿ繧貞女縺代↑縺 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIMO::ModeSelect(const DWORD *cdb, const BYTE *buf, int length) +{ + int page; + int size; + + ASSERT(this); + ASSERT(buf); + ASSERT(length >= 0); + + // PF + if (cdb[1] & 0x10) { + // Mode Parameter header + if (length >= 12) { + // 繝悶Ο繝繧ｯ繝ｬ繝ｳ繧ｰ繧ｹ縺ｮ繝舌う繝域焚繧偵メ繧ｧ繝繧ｯ + size = 1 << disk.size; + if (buf[9] != (BYTE)(size >> 16) || + buf[10] != (BYTE)(size >> 8) || buf[11] != (BYTE)size) { + // 莉翫ｮ縺ｨ縺薙ｍ繧ｻ繧ｯ繧ｿ髟ｷ縺ｮ螟画峩縺ｯ險ｱ縺輔↑縺 + disk.code = DISK_INVALIDPRM; + return FALSE; + } + buf += 12; + length -= 12; + } + + // 繝壹ｼ繧ｸ縺ｮ隗｣譫 + while (length > 0) { + // 繝壹ｼ繧ｸ縺ｮ蜿門ｾ + page = buf[0]; + + switch (page) { + // format device + case 0x03: + // 迚ｩ逅繧ｻ繧ｯ繧ｿ縺ｮ繝舌う繝域焚繧偵メ繧ｧ繝繧ｯ + size = 1 << disk.size; + if (buf[0xc] != (BYTE)(size >> 8) || buf[0xd] != (BYTE)size) { + // 莉翫ｮ縺ｨ縺薙ｍ繧ｻ繧ｯ繧ｿ髟ｷ縺ｮ螟画峩縺ｯ險ｱ縺輔↑縺 + disk.code = DISK_INVALIDPRM; + return FALSE; + } + break; + // vendor unique format + case 0x20: + // just ignore, for now + break; + + // 縺昴ｮ莉悶壹ｼ繧ｸ + default: + break; + } + + // 谺｡縺ｮ繝壹ｼ繧ｸ縺ｸ + size = buf[1] + 2; + length -= size; + buf += size; + } + } + + // 縺ｨ繧翫≠縺医★繧ｨ繝ｩ繝ｼ縺ｯ逋ｺ逕溘＆縺帙↑縺(MINIX) + disk.code = DISK_NOERROR; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// Vendor Unique Format Page 20h (MO) +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIMO::AddVendor(int page, BOOL change, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + // 繝壹ｼ繧ｸ繧ｳ繝ｼ繝20h + if ((page != 0x20) && (page != 0x3f)) { + return 0; + } + + // 繧ｳ繝ｼ繝峨ｻ繝ｬ繝ｳ繧ｰ繧ｹ繧定ｨｭ螳 + buf[0] = 0x20; + buf[1] = 0x0a; + + // 螟画峩蜿ｯ閭ｽ鬆伜沺縺ｯ縺ｪ縺 + if (change) { + return 12; + } + + /* + mode page code 20h - Vendor Unique Format Page + format mode XXh type 0 + information: http://h20628.www2.hp.com/km-ext/kmcsdirect/emr_na-lpg28560-1.pdf + + offset description + 02h format mode + 03h type of format (0) + 04~07h size of user band (total sectors?) + 08~09h size of spare band (spare sectors?) + 0A~0Bh number of bands + + actual value of each 3.5inches optical medium (grabbed by Fujitsu M2513EL) + + 128M 230M 540M 640M + --------------------------------------------------- + size of user band 3CBFAh 6CF75h FE45Ch 4BC50h + size of spare band 0400h 0401h 08CAh 08C4h + number of bands 0001h 000Ah 0012h 000Bh + + further information: http://r2089.blog36.fc2.com/blog-entry-177.html + */ + + if (disk.ready) { + unsigned spare = 0; + unsigned bands = 0; + + if (disk.size == 9) switch (disk.blocks) { + // 128MB + case 248826: + spare = 1024; + bands = 1; + break; + + // 230MB + case 446325: + spare = 1025; + bands = 10; + break; + + // 540MB + case 1041500: + spare = 2250; + bands = 18; + break; + } + + if (disk.size == 11) switch (disk.blocks) { + // 640MB + case 310352: + spare = 2244; + bands = 11; + break; + + // 1.3GB (lpproj: not tested with real device) + case 605846: + spare = 4437; + bands = 18; + break; + } + + buf[2] = 0; // format mode + buf[3] = 0; // type of format + buf[4] = (BYTE)(disk.blocks >> 24); + buf[5] = (BYTE)(disk.blocks >> 16); + buf[6] = (BYTE)(disk.blocks >> 8); + buf[7] = (BYTE)disk.blocks; + buf[8] = (BYTE)(spare >> 8); + buf[9] = (BYTE)spare; + buf[10] = (BYTE)(bands >> 8); + buf[11] = (BYTE)bands; + } + + return 12; +} + +//=========================================================================== +// +// CD繝医Λ繝繧ｯ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CDTrack::CDTrack(SCSICD *scsicd) +{ + ASSERT(scsicd); + + // 隕ｪ縺ｨ縺ｪ繧気D-ROM繝繝舌う繧ｹ繧定ｨｭ螳 + cdrom = scsicd; + + // 繝医Λ繝繧ｯ辟｡蜉ｹ + valid = FALSE; + + // 縺昴ｮ莉悶ｮ繝繝ｼ繧ｿ繧貞晄悄蛹 + track_no = -1; + first_lba = 0; + last_lba = 0; + audio = FALSE; + raw = FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CDTrack::~CDTrack() +{ +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL CDTrack::Init(int track, DWORD first, DWORD last) +{ + ASSERT(this); + ASSERT(!valid); + ASSERT(track >= 1); + ASSERT(first < last); + + // 繝医Λ繝繧ｯ逡ｪ蜿ｷ繧定ｨｭ螳壹∵怏蜉ｹ蛹 + track_no = track; + valid = TRUE; + + // LBA繧定ｨ俶ｶ + first_lba = first; + last_lba = last; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝代せ險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL CDTrack::SetPath(BOOL cdda, const Filepath& path) +{ + ASSERT(this); + ASSERT(valid); + + // CD-DA縺九√ョ繝ｼ繧ｿ縺 + audio = cdda; + + // 繝代せ險俶ｶ + imgpath = path; +} + +//--------------------------------------------------------------------------- +// +// 繝代せ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL CDTrack::GetPath(Filepath& path) const +{ + ASSERT(this); + ASSERT(valid); + + // 繝代せ繧定ｿ斐☆ + path = imgpath; +} + +//--------------------------------------------------------------------------- +// +// 繧､繝ｳ繝繝繧ｯ繧ｹ霑ｽ蜉 +// +//--------------------------------------------------------------------------- +void FASTCALL CDTrack::AddIndex(int index, DWORD lba) +{ + ASSERT(this); + ASSERT(valid); + ASSERT(index > 0); + ASSERT(first_lba <= lba); + ASSERT(lba <= last_lba); + + // 迴ｾ蝨ｨ縺ｯ繧､繝ｳ繝繝繧ｯ繧ｹ縺ｯ繧ｵ繝昴ｼ繝医＠縺ｪ縺 + ASSERT(FALSE); +} + +//--------------------------------------------------------------------------- +// +// 髢句ｧ記BA蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD FASTCALL CDTrack::GetFirst() const +{ + ASSERT(this); + ASSERT(valid); + ASSERT(first_lba < last_lba); + + return first_lba; +} + +//--------------------------------------------------------------------------- +// +// 邨らｫｯLBA蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD FASTCALL CDTrack::GetLast() const +{ + ASSERT(this); + ASSERT(valid); + ASSERT(first_lba < last_lba); + + return last_lba; +} + +//--------------------------------------------------------------------------- +// +// 繝悶Ο繝繧ｯ謨ｰ蜿門ｾ +// +//--------------------------------------------------------------------------- +DWORD FASTCALL CDTrack::GetBlocks() const +{ + ASSERT(this); + ASSERT(valid); + ASSERT(first_lba < last_lba); + + // 髢句ｧ記BA縺ｨ譛邨LBA縺九ｉ邂怜ｺ + return (DWORD)(last_lba - first_lba + 1); +} + +//--------------------------------------------------------------------------- +// +// 繝医Λ繝繧ｯ逡ｪ蜿ｷ蜿門ｾ +// +//--------------------------------------------------------------------------- +int FASTCALL CDTrack::GetTrackNo() const +{ + ASSERT(this); + ASSERT(valid); + ASSERT(track_no >= 1); + + return track_no; +} + +//--------------------------------------------------------------------------- +// +// 譛牙柑縺ｪ繝悶Ο繝繧ｯ縺 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL CDTrack::IsValid(DWORD lba) const +{ + ASSERT(this); + + // 繝医Λ繝繧ｯ閾ｪ菴薙′辟｡蜉ｹ縺ｪ繧峨：ALSE + if (!valid) { + return FALSE; + } + + // first繧医ｊ蜑阪↑繧峨：ALSE + if (lba < first_lba) { + return FALSE; + } + + // last繧医ｊ蠕後↑繧峨：ALSE + if (last_lba < lba) { + return FALSE; + } + + // 縺薙ｮ繝医Λ繝繧ｯ + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝繧｣繧ｪ繝医Λ繝繧ｯ縺 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL CDTrack::IsAudio() const +{ + ASSERT(this); + ASSERT(valid); + + return audio; +} + +//=========================================================================== +// +// CD-DA繝舌ャ繝輔ぃ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CDDABuf::CDDABuf() +{ +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +CDDABuf::~CDDABuf() +{ +} + +//=========================================================================== +// +// SCSI CD-ROM +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSICD::SCSICD() : Disk() +{ + int i; + + // SCSI CD-ROM + disk.id = MAKEID('S', 'C', 'C', 'D'); + + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ縲∵嶌霎ｼ縺ｿ遖∵ｭ｢ + disk.removable = TRUE; + disk.writep = TRUE; + + // RAW蠖｢蠑上〒縺ｪ縺 + rawfile = FALSE; + + // 繝輔Ξ繝ｼ繝蛻晄悄蛹 + frame = 0; + + // 繝医Λ繝繧ｯ蛻晄悄蛹 + for (i = 0; i < TrackMax; i++) { + track[i] = NULL; + } + tracks = 0; + dataindex = -1; + audioindex = -1; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSICD::~SCSICD() +{ + // 繝医Λ繝繧ｯ繧ｯ繝ｪ繧｢ + ClearTrack(); +} + +#ifndef RASCSI +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::Load(Fileio *fio, int ver) +{ + DWORD sz; + disk_t buf; + DWORD padding; + Filepath path; + + ASSERT(this); + ASSERT(fio); + ASSERT(ver >= 0x0200); + + // version2.03繧医ｊ蜑阪ｯ縲√ョ繧｣繧ｹ繧ｯ縺ｯ繧ｻ繝ｼ繝悶＠縺ｦ縺縺ｪ縺 + if (ver <= 0x0202) { + return TRUE; + } + + // 繧ｵ繧､繧ｺ繧偵Ο繝ｼ繝峨∫ｧ蜷 + if (!fio->Read(&sz, sizeof(sz))) { + return FALSE; + } + if (sz != 52) { + return FALSE; + } + + // 繝舌ャ繝輔ぃ縺ｸ繝ｭ繝ｼ繝 + PROP_IMPORT(fio, buf.id); + PROP_IMPORT(fio, buf.ready); + PROP_IMPORT(fio, buf.writep); + PROP_IMPORT(fio, buf.readonly); + PROP_IMPORT(fio, buf.removable); + PROP_IMPORT(fio, buf.lock); + PROP_IMPORT(fio, buf.attn); + PROP_IMPORT(fio, buf.reset); + PROP_IMPORT(fio, buf.size); + PROP_IMPORT(fio, buf.blocks); + PROP_IMPORT(fio, buf.lun); + PROP_IMPORT(fio, buf.code); + PROP_IMPORT(fio, padding); + + // 繝代せ繧偵Ο繝ｼ繝 + if (!path.Load(fio, ver)) { + return FALSE; + } + + // 蠢縺壹う繧ｸ繧ｧ繧ｯ繝 + Eject(TRUE); + + // ID縺御ｸ閾ｴ縺励◆蝣ｴ蜷医ｮ縺ｿ縲∫ｧｻ蜍 + if (disk.id != buf.id) { + // 繧ｻ繝ｼ繝匁凾縺ｫCD-ROM縺ｧ縺ｪ縺九▲縺溘ゅう繧ｸ繧ｧ繧ｯ繝育憾諷九ｒ邯ｭ謖 + return TRUE; + } + + // 蜀阪が繝ｼ繝励Φ繧定ｩｦ縺ｿ繧 + if (!Open(path, FALSE)) { + // 蜀阪が繝ｼ繝励Φ縺ｧ縺阪↑縺縲ゅう繧ｸ繧ｧ繧ｯ繝育憾諷九ｒ邯ｭ謖 + return TRUE; + } + + // Open蜀縺ｧ繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･縺ｯ菴懈舌＆繧後※縺繧九ゅ励Ο繝代ユ繧｣縺ｮ縺ｿ遘ｻ蜍 + if (!disk.readonly) { + disk.writep = buf.writep; + } + disk.lock = buf.lock; + disk.attn = buf.attn; + disk.reset = buf.reset; + disk.lun = buf.lun; + disk.code = buf.code; + + // 蜀榊ｺｦ縲√ョ繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧堤ｴ譽 + if (disk.dcache) { + delete disk.dcache; + disk.dcache = NULL; + } + disk.dcache = NULL; + + // 證ｫ螳 + disk.blocks = track[0]->GetBlocks(); + if (disk.blocks > 0) { + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧剃ｽ懊ｊ逶ｴ縺 + track[0]->GetPath(path); + disk.dcache = new DiskCache(path, disk.size, disk.blocks); + disk.dcache->SetRawMode(rawfile); + + // 繝繝ｼ繧ｿ繧､繝ｳ繝繝繧ｯ繧ｹ繧貞崎ｨｭ螳 + dataindex = 0; + } + + return TRUE; +} +#endif // RASCSI + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::Open(const Filepath& path, BOOL attn) +{ + Fileio fio; + off64_t size; + char file[5]; + + ASSERT(this); + ASSERT(!disk.ready); + + // 蛻晄悄蛹悶√ヨ繝ｩ繝繧ｯ繧ｯ繝ｪ繧｢ + disk.blocks = 0; + rawfile = FALSE; + ClearTrack(); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 迚ｩ逅CD繧｢繧ｯ繧ｻ繧ｹ縺ｪ繧峨け繝ｭ繝ｼ繧ｺ縺励※蟋碑ｭｲ縺吶ｋ + if (path.GetPath()[0] == _T('\\')) { + // 繧ｯ繝ｭ繝ｼ繧ｺ + fio.Close(); + + // 迚ｩ逅CD繧ｪ繝ｼ繝励Φ + if (!OpenPhysical(path)) { + return FALSE; + } + } else { + // 繧ｵ繧､繧ｺ蜿門ｾ + size = fio.GetFileSize(); + if (size <= 4) { + fio.Close(); + return FALSE; + } + + // CUE繧ｷ繝ｼ繝医°縲！SO繝輔ぃ繧､繝ｫ縺九ｮ蛻､螳壹ｒ陦後≧ + fio.Read(file, 4); + file[4] = '\0'; + fio.Close(); + + // FILE縺ｧ蟋九∪縺｣縺ｦ縺繧後ｰ縲，UE繧ｷ繝ｼ繝医→縺ｿ縺ｪ縺 + if (xstrncasecmp(file, "FILE", 4) == 0) { + // CUE縺ｨ縺励※繧ｪ繝ｼ繝励Φ + if (!OpenCue(path)) { + return FALSE; + } + } else { + // ISO縺ｨ縺励※繧ｪ繝ｼ繝励Φ + if (!OpenIso(path)) { + return FALSE; + } + } + } + + // 繧ｪ繝ｼ繝励Φ謌仙粥 + ASSERT(disk.blocks > 0); + disk.size = 11; + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + Disk::Open(path); + + // RAW繝輔Λ繧ｰ繧定ｨｭ螳 + ASSERT(disk.dcache); + disk.dcache->SetRawMode(rawfile); + + // ROM繝｡繝繧｣繧｢縺ｪ縺ｮ縺ｧ縲∵嶌縺崎ｾｼ縺ｿ縺ｯ縺ｧ縺阪↑縺 + disk.writep = TRUE; + + // 繝ｬ繝繧｣縺ｪ繧峨い繝繝ｳ繧ｷ繝ｧ繝ｳ + if (disk.ready && attn) { + disk.attn = TRUE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ(CUE) +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::OpenCue(const Filepath& /*path*/) +{ + ASSERT(this); + + // 蟶ｸ縺ｫ螟ｱ謨 + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ(ISO) +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::OpenIso(const Filepath& path) +{ + Fileio fio; + off64_t size; + BYTE header[12]; + BYTE sync[12]; + + ASSERT(this); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繧ｵ繧､繧ｺ蜿門ｾ + size = fio.GetFileSize(); + if (size < 0x800) { + fio.Close(); + return FALSE; + } + + // 譛蛻昴ｮ12繝舌う繝医ｒ隱ｭ縺ｿ蜿悶▲縺ｦ縲√け繝ｭ繝ｼ繧ｺ + if (!fio.Read(header, sizeof(header))) { + fio.Close(); + return FALSE; + } + + // RAW蠖｢蠑上°繝√ぉ繝繧ｯ + memset(sync, 0xff, sizeof(sync)); + sync[0] = 0x00; + sync[11] = 0x00; + rawfile = FALSE; + if (memcmp(header, sync, sizeof(sync)) == 0) { + // 00,FFx10,00縺ｪ縺ｮ縺ｧ縲ヽAW蠖｢蠑上→謗ｨ螳壹＆繧後ｋ + if (!fio.Read(header, 4)) { + fio.Close(); + return FALSE; + } + + // MODE1/2048縺ｾ縺溘ｯMODE1/2352縺ｮ縺ｿ繧ｵ繝昴ｼ繝 + if (header[3] != 0x01) { + // 繝｢繝ｼ繝峨′驕輔≧ + fio.Close(); + return FALSE; + } + + // RAW繝輔ぃ繧､繝ｫ縺ｫ險ｭ螳 + rawfile = TRUE; + } + fio.Close(); + + if (rawfile) { + // 繧ｵ繧､繧ｺ縺2536縺ｮ蛟肴焚縺ｧ縲700MB莉･荳九〒縺ゅｋ縺薙→ + if (size % 0x930) { + return FALSE; + } + if (size > 912579600) { + return FALSE; + } + + // 繝悶Ο繝繧ｯ謨ｰ繧定ｨｭ螳 + disk.blocks = (DWORD)(size / 0x930); + } else { + // 繧ｵ繧､繧ｺ縺2048縺ｮ蛟肴焚縺ｧ縲700MB莉･荳九〒縺ゅｋ縺薙→ + if (size & 0x7ff) { + return FALSE; + } + if (size > 0x2bed5000) { + return FALSE; + } + + // 繝悶Ο繝繧ｯ謨ｰ繧定ｨｭ螳 + disk.blocks = (DWORD)(size >> 11); + } + + // 繝繝ｼ繧ｿ繝医Λ繝繧ｯ1縺､縺ｮ縺ｿ菴懈 + ASSERT(!track[0]); + track[0] = new CDTrack(this); + track[0]->Init(1, 0, disk.blocks - 1); + track[0]->SetPath(FALSE, path); + tracks = 1; + dataindex = 0; + + // 繧ｪ繝ｼ繝励Φ謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ(Physical) +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::OpenPhysical(const Filepath& path) +{ + Fileio fio; + off64_t size; + + ASSERT(this); + + // 隱ｭ縺ｿ霎ｼ縺ｿ繧ｪ繝ｼ繝励Φ縺悟ｿ隕 + if (!fio.Open(path, Fileio::ReadOnly)) { + return FALSE; + } + + // 繧ｵ繧､繧ｺ蜿門ｾ + size = fio.GetFileSize(); + if (size < 0x800) { + fio.Close(); + return FALSE; + } + + // 繧ｯ繝ｭ繝ｼ繧ｺ + fio.Close(); + + // 繧ｵ繧､繧ｺ縺2048縺ｮ蛟肴焚縺ｧ縲700MB莉･荳九〒縺ゅｋ縺薙→ + if (size & 0x7ff) { + return FALSE; + } + if (size > 0x2bed5000) { + return FALSE; + } + + // 繝悶Ο繝繧ｯ謨ｰ繧定ｨｭ螳 + disk.blocks = (DWORD)(size >> 11); + + // 繝繝ｼ繧ｿ繝医Λ繝繧ｯ1縺､縺ｮ縺ｿ菴懈 + ASSERT(!track[0]); + track[0] = new CDTrack(this); + track[0]->Init(1, 0, disk.blocks - 1); + track[0]->SetPath(FALSE, path); + tracks = 1; + dataindex = 0; + + // 繧ｪ繝ｼ繝励Φ謌仙粥 + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSICD::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + char rev[32]; + int size; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x12); + + // EVPD繝√ぉ繝繧ｯ + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // 蝓ｺ譛ｬ繝繝ｼ繧ｿ + // buf[0] ... CD-ROM Device + // buf[1] ... 繝ｪ繝繝ｼ繝舌ヶ繝ｫ + // buf[2] ... SCSI-2貅匁侠縺ｮ繧ｳ繝槭Φ繝我ｽ鍋ｳｻ + // buf[3] ... SCSI-2貅匁侠縺ｮInquiry繝ｬ繧ｹ繝昴Φ繧ｹ + // buf[4] ... Inquiry霑ｽ蜉繝繝ｼ繧ｿ + memset(buf, 0, 8); + buf[0] = 0x05; + + // SCSI-2 譛ｬ縺ｮ p.104 4.4.3 荳榊ｽ薙↑繝ｭ繧ｸ繧ｫ繝ｫ繝ｦ繝九ャ繝医ｮ蜃ｦ逅 + if (((cdb[1] >> 5) & 0x07) != disk.lun) { + buf[0] = 0x7f; + } + + buf[1] = 0x80; + buf[2] = 0x02; + buf[3] = 0x02; + buf[4] = 36 - 5; // 蠢鬆 + + // 遨ｺ逋ｽ縺ｧ蝓九ａ繧 + memset(&buf[8], 0x20, buf[4] - 3); + + // 繝吶Φ繝 + memcpy(&buf[8], BENDER_SIGNATURE, strlen(BENDER_SIGNATURE)); + + // 陬ｽ蜩∝錐 + memcpy(&buf[16], "CD-ROM CDU-55S", 14); + + // 繝ｪ繝薙ず繝ｧ繝ｳ(XM6縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳNo) + sprintf(rev, "0%01d%01d%01d", + (int)major, (int)(minor >> 4), (int)(minor & 0x0f)); + memcpy(&buf[32], rev, 4); + + // 霑泌唆縺ｧ縺阪ｋ繝繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + size = (buf[4] + 5); + + // 逶ｸ謇九ｮ繝舌ャ繝輔ぃ縺悟ｰ代↑縺代ｌ縺ｰ蛻ｶ髯舌☆繧 + if (size > (int)cdb[4]) { + size = (int)cdb[4]; + } + + // 謌仙粥 + disk.code = DISK_NOERROR; + return size; +} + +//--------------------------------------------------------------------------- +// +// READ +// +//--------------------------------------------------------------------------- +int FASTCALL SCSICD::Read(BYTE *buf, DWORD block) +{ + int index; + Filepath path; + + ASSERT(this); + ASSERT(buf); + + // 迥ｶ諷九メ繧ｧ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 繝医Λ繝繧ｯ讀懃ｴ｢ + index = SearchTrack(block); + + // 辟｡蜉ｹ縺ｪ繧峨∫ｯ蝗ｲ螟 + if (index < 0) { + disk.code = DISK_INVALIDLBA; + return 0; + } + ASSERT(track[index]); + + // 迴ｾ蝨ｨ縺ｮ繝繝ｼ繧ｿ繝医Λ繝繧ｯ縺ｨ逡ｰ縺ｪ縺｣縺ｦ縺繧後ｰ + if (dataindex != index) { + // 迴ｾ蝨ｨ縺ｮ繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧貞炎髯､(Save縺ｮ蠢隕√ｯ縺ｪ縺) + delete disk.dcache; + disk.dcache = NULL; + + // 繝悶Ο繝繧ｯ謨ｰ繧貞崎ｨｭ螳 + disk.blocks = track[index]->GetBlocks(); + ASSERT(disk.blocks > 0); + + // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･繧剃ｽ懊ｊ逶ｴ縺 + track[index]->GetPath(path); + disk.dcache = new DiskCache(path, disk.size, disk.blocks); + disk.dcache->SetRawMode(rawfile); + + // 繝繝ｼ繧ｿ繧､繝ｳ繝繝繧ｯ繧ｹ繧貞崎ｨｭ螳 + dataindex = index; + } + + // 蝓ｺ譛ｬ繧ｯ繝ｩ繧ｹ + ASSERT(dataindex >= 0); + return Disk::Read(buf, block); +} + +//--------------------------------------------------------------------------- +// +// READ TOC +// +//--------------------------------------------------------------------------- +int FASTCALL SCSICD::ReadToc(const DWORD *cdb, BYTE *buf) +{ + int last; + int index; + int length; + int loop; + int i; + BOOL msf; + DWORD lba; + + ASSERT(this); + ASSERT(cdb); + ASSERT(cdb[0] == 0x43); + ASSERT(buf); + + // 繝ｬ繝繧｣繝√ぉ繝繧ｯ + if (!CheckReady()) { + return 0; + } + + // 繝ｬ繝繧｣縺ｧ縺ゅｋ縺ｪ繧峨√ヨ繝ｩ繝繧ｯ縺梧怙菴1縺､莉･荳雁ｭ伜惠縺吶ｋ + ASSERT(tracks > 0); + ASSERT(track[0]); + + // 繧｢繝ｭ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ繝ｬ繝ｳ繧ｰ繧ｹ蜿門ｾ励√ヰ繝繝輔ぃ繧ｯ繝ｪ繧｢ + length = cdb[7] << 8; + length |= cdb[8]; + memset(buf, 0, length); + + // MSF繝輔Λ繧ｰ蜿門ｾ + if (cdb[1] & 0x02) { + msf = TRUE; + } else { + msf = FALSE; + } + + // 譛邨ゅヨ繝ｩ繝繧ｯ逡ｪ蜿ｷ繧貞叙蠕励√メ繧ｧ繝繧ｯ + last = track[tracks - 1]->GetTrackNo(); + if ((int)cdb[6] > last) { + // 縺溘□縺輸A縺ｯ髯､螟 + if (cdb[6] != 0xaa) { + disk.code = DISK_INVALIDCDB; + return 0; + } + } + + // 髢句ｧ九う繝ｳ繝繝繧ｯ繧ｹ繧偵メ繧ｧ繝繧ｯ + index = 0; + if (cdb[6] != 0x00) { + // 繝医Λ繝繧ｯ逡ｪ蜿ｷ縺御ｸ閾ｴ縺吶ｋ縺ｾ縺ｧ縲√ヨ繝ｩ繝繧ｯ繧帝ｲ繧√ｋ + while (track[index]) { + if ((int)cdb[6] == track[index]->GetTrackNo()) { + break; + } + index++; + } + + // 隕九▽縺九ｉ縺ｪ縺代ｌ縺ｰAA縺九∝驛ｨ繧ｨ繝ｩ繝ｼ + if (!track[index]) { + if (cdb[6] == 0xaa) { + // AA縺ｪ縺ｮ縺ｧ縲∵怙邨LBA+1繧定ｿ斐☆ + buf[0] = 0x00; + buf[1] = 0x0a; + buf[2] = (BYTE)track[0]->GetTrackNo(); + buf[3] = (BYTE)last; + buf[6] = 0xaa; + lba = track[tracks - 1]->GetLast() + 1; + if (msf) { + LBAtoMSF(lba, &buf[8]); + } else { + buf[10] = (BYTE)(lba >> 8); + buf[11] = (BYTE)lba; + } + return length; + } + + // 縺昴ｌ莉･螟悶ｯ繧ｨ繝ｩ繝ｼ + disk.code = DISK_INVALIDCDB; + return 0; + } + } + + // 莉雁屓霑斐☆繝医Λ繝繧ｯ繝繧｣繧ｹ繧ｯ繝ｪ繝励ち縺ｮ蛟区焚(繝ｫ繝ｼ繝玲焚) + loop = last - track[index]->GetTrackNo() + 1; + ASSERT(loop >= 1); + + // 繝倥ャ繝菴懈 + buf[0] = (BYTE)(((loop << 3) + 2) >> 8); + buf[1] = (BYTE)((loop << 3) + 2); + buf[2] = (BYTE)track[0]->GetTrackNo(); + buf[3] = (BYTE)last; + buf += 4; + + // 繝ｫ繝ｼ繝 + for (i = 0; i < loop; i++) { + // ADR縺ｨControl + if (track[index]->IsAudio()) { + // 繧ｪ繝ｼ繝繧｣繧ｪ繝医Λ繝繧ｯ + buf[1] = 0x10; + } else { + // 繝繝ｼ繧ｿ繝医Λ繝繧ｯ + buf[1] = 0x14; + } + + // 繝医Λ繝繧ｯ逡ｪ蜿ｷ + buf[2] = (BYTE)track[index]->GetTrackNo(); + + // 繝医Λ繝繧ｯ繧｢繝峨Ξ繧ｹ + if (msf) { + LBAtoMSF(track[index]->GetFirst(), &buf[4]); + } else { + buf[6] = (BYTE)(track[index]->GetFirst() >> 8); + buf[7] = (BYTE)(track[index]->GetFirst()); + } + + // 繝舌ャ繝輔ぃ縺ｨ繧､繝ｳ繝繝繧ｯ繧ｹ繧帝ｲ繧√ｋ + buf += 8; + index++; + } + + // 繧｢繝ｭ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ繝ｬ繝ｳ繧ｰ繧ｹ縺縺大ｿ縺夊ｿ斐☆ + return length; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::PlayAudio(const DWORD* /*cdb*/) +{ + ASSERT(this); + + disk.code = DISK_INVALIDCDB; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO MSF +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::PlayAudioMSF(const DWORD* /*cdb*/) +{ + ASSERT(this); + + disk.code = DISK_INVALIDCDB; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO TRACK +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::PlayAudioTrack(const DWORD* /*cdb*/) +{ + ASSERT(this); + + disk.code = DISK_INVALIDCDB; + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// LBA竊樽SF螟画鋤 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSICD::LBAtoMSF(DWORD lba, BYTE *msf) const +{ + DWORD m; + DWORD s; + DWORD f; + + ASSERT(this); + + // 75縲75*60縺ｧ縺昴ｌ縺槭ｌ菴吶ｊ繧貞ｺ縺 + m = lba / (75 * 60); + s = lba % (75 * 60); + f = s % 75; + s /= 75; + + // 蝓ｺ轤ｹ縺ｯM=0,S=2,F=0 + s += 2; + if (s >= 60) { + s -= 60; + m++; + } + + // 譬ｼ邏 + ASSERT(m < 0x100); + ASSERT(s < 60); + ASSERT(f < 75); + msf[0] = 0x00; + msf[1] = (BYTE)m; + msf[2] = (BYTE)s; + msf[3] = (BYTE)f; +} + +//--------------------------------------------------------------------------- +// +// MSF竊鱈BA螟画鋤 +// +//--------------------------------------------------------------------------- +DWORD FASTCALL SCSICD::MSFtoLBA(const BYTE *msf) const +{ + DWORD lba; + + ASSERT(this); + ASSERT(msf[2] < 60); + ASSERT(msf[3] < 75); + + // 1, 75, 75*60縺ｮ蛟肴焚縺ｧ蜷育ｮ + lba = msf[1]; + lba *= 60; + lba += msf[2]; + lba *= 75; + lba += msf[3]; + + // 蝓ｺ轤ｹ縺ｯM=0,S=2,F=0縺ｪ縺ｮ縺ｧ縲150繧貞ｼ輔￥ + lba -= 150; + + return lba; +} + +//--------------------------------------------------------------------------- +// +// 繝医Λ繝繧ｯ繧ｯ繝ｪ繧｢ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSICD::ClearTrack() +{ + int i; + + ASSERT(this); + + // 繝医Λ繝繧ｯ繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ蜑企勁 + for (i = 0; i < TrackMax; i++) { + if (track[i]) { + delete track[i]; + track[i] = NULL; + } + } + + // 繝医Λ繝繧ｯ謨ｰ0 + tracks = 0; + + // 繝繝ｼ繧ｿ縲√が繝ｼ繝繧｣繧ｪ縺ｨ繧りｨｭ螳壹↑縺 + dataindex = -1; + audioindex = -1; +} + +//--------------------------------------------------------------------------- +// +// 繝医Λ繝繧ｯ讀懃ｴ｢ +// 窶ｻ隕九▽縺九ｉ縺ｪ縺代ｌ縺ｰ-1繧定ｿ斐☆ +// +//--------------------------------------------------------------------------- +int FASTCALL SCSICD::SearchTrack(DWORD lba) const +{ + int i; + + ASSERT(this); + + // 繝医Λ繝繧ｯ繝ｫ繝ｼ繝 + for (i = 0; i < tracks; i++) { + // 繝医Λ繝繧ｯ縺ｫ閨槭￥ + ASSERT(track[i]); + if (track[i]->IsValid(lba)) { + return i; + } + } + + // 隕九▽縺九ｉ縺ｪ縺九▲縺 + return -1; +} + +//--------------------------------------------------------------------------- +// +// 繝輔Ξ繝ｼ繝騾夂衍 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSICD::NextFrame() +{ + ASSERT(this); + ASSERT((frame >= 0) && (frame < 75)); + + // 繝輔Ξ繝ｼ繝繧0ｽ74縺ｮ遽蝗ｲ縺ｧ險ｭ螳 + frame = (frame + 1) % 75; + + // 1蜻ｨ縺励◆繧宇ALSE + if (frame != 0) { + return TRUE; + } else { + return FALSE; + } +} + +//--------------------------------------------------------------------------- +// +// CD-DA繝舌ャ繝輔ぃ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSICD::GetBuf(DWORD* /*buffer*/, int /*samples*/, DWORD /*rate*/) +{ + ASSERT(this); +} + +//=========================================================================== +// +// SCSI 繝帙せ繝医ヶ繝ｪ繝繧ｸ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIBR::SCSIBR() : Disk() +{ + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ + disk.id = MAKEID('S', 'C', 'B', 'R'); + + // TAP繝峨Λ繧､繝千函謌 + tap = new CTapDriver(); + m_bTapEnable = tap->Init(); + + // MAC繧｢繝峨Ξ繧ｹ繧堤函謌 + memset(mac_addr, 0x00, 6); + if (m_bTapEnable) { + tap->GetMacAddr(mac_addr); + mac_addr[5]++; + } + + // 繝代こ繝繝亥女菫｡繝輔Λ繧ｰ繧ｪ繝 + packet_enable = FALSE; + + // 繝帙せ繝医ヵ繧｡繧､繝ｫ繧ｷ繧ｹ繝繝逕滓 + fs = new CFileSys(); + fs->Reset(); +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SCSIBR::~SCSIBR() +{ + // TAP繝峨Λ繧､繝占ｧ｣謾ｾ + if (tap) { + tap->Cleanup(); + delete tap; + } + + // 繝帙せ繝医ヵ繧｡繧､繝ｫ繧ｷ繧ｹ繝繝隗｣謾ｾ + if (fs) { + fs->Reset(); + delete fs; + } +} + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor) +{ + char rev[32]; + int size; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + ASSERT(cdb[0] == 0x12); + + // EVPD繝√ぉ繝繧ｯ + if (cdb[1] & 0x01) { + disk.code = DISK_INVALIDCDB; + return FALSE; + } + + // 蝓ｺ譛ｬ繝繝ｼ繧ｿ + // buf[0] ... Communication Device + // buf[2] ... SCSI-2貅匁侠縺ｮ繧ｳ繝槭Φ繝我ｽ鍋ｳｻ + // buf[3] ... SCSI-2貅匁侠縺ｮInquiry繝ｬ繧ｹ繝昴Φ繧ｹ + // buf[4] ... Inquiry霑ｽ蜉繝繝ｼ繧ｿ + memset(buf, 0, 8); + buf[0] = 0x09; + + // SCSI-2 譛ｬ縺ｮ p.104 4.4.3 荳榊ｽ薙↑繝ｭ繧ｸ繧ｫ繝ｫ繝ｦ繝九ャ繝医ｮ蜃ｦ逅 + if (((cdb[1] >> 5) & 0x07) != disk.lun) { + buf[0] = 0x7f; + } + + buf[2] = 0x02; + buf[3] = 0x02; + buf[4] = 36 - 5 + 8; // 蠢鬆 + 8繝舌う繝域僑蠑ｵ + + // 遨ｺ逋ｽ縺ｧ蝓九ａ繧 + memset(&buf[8], 0x20, buf[4] - 3); + + // 繝吶Φ繝 + memcpy(&buf[8], BENDER_SIGNATURE, strlen(BENDER_SIGNATURE)); + + // 陬ｽ蜩∝錐 + memcpy(&buf[16], "RASCSI BRIDGE", 13); + + // 繝ｪ繝薙ず繝ｧ繝ｳ(XM6縺ｮ繝舌ｼ繧ｸ繝ｧ繝ｳNo) + sprintf(rev, "0%01d%01d%01d", + (int)major, (int)(minor >> 4), (int)(minor & 0x0f)); + memcpy(&buf[32], rev, 4); + + // 繧ｪ繝励す繝ｧ繝ｳ讖溯ｽ譛牙柑繝輔Λ繧ｰ + buf[36] = '0'; + + // TAP譛牙柑 + if (m_bTapEnable) { + buf[37] = '1'; + } + + // CFileSys譛牙柑 + buf[38] = '1'; + + // 霑泌唆縺ｧ縺阪ｋ繝繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + size = (buf[4] + 5); + + // 逶ｸ謇九ｮ繝舌ャ繝輔ぃ縺悟ｰ代↑縺代ｌ縺ｰ蛻ｶ髯舌☆繧 + if (size > (int)cdb[4]) { + size = (int)cdb[4]; + } + + // 謌仙粥 + disk.code = DISK_NOERROR; + return size; +} + +//--------------------------------------------------------------------------- +// +// TEST UNIT READY +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIBR::TestUnitReady(const DWORD* /*cdb*/) +{ + ASSERT(this); + + // TEST UNIT READY謌仙粥 + disk.code = DISK_NOERROR; + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// GET MESSAGE(10) +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::GetMessage10(const DWORD *cdb, BYTE *buf) +{ + int type; + int func; + int phase; + int total_len; + int i; + + ASSERT(this); + + // 繧ｿ繧､繝 + type = cdb[2]; + + // 讖溯ｽ逡ｪ蜿ｷ + func = cdb[3]; + + // 繝輔ぉ繝ｼ繧ｺ + phase = cdb[9]; + + switch (type) { + case 1: // 繧､繝ｼ繧ｵ繝阪ャ繝 + // TAP辟｡蜉ｹ縺ｪ繧牙ｦ逅縺励↑縺 + if (!m_bTapEnable) { + return 0; + } + + switch (func) { + case 0: // MAC繧｢繝峨Ξ繧ｹ蜿門ｾ + return GetMacAddr(buf); + + case 1: // 蜿嶺ｿ｡繝代こ繝繝亥叙蠕(繧ｵ繧､繧ｺ/繝舌ャ繝輔ぃ蛻･) + if (phase == 0) { + // 繝代こ繝繝医し繧､繧ｺ蜿門ｾ + ReceivePacket(); + buf[0] = (BYTE)(packet_len >> 8); + buf[1] = (BYTE)packet_len; + return 2; + } else { + // 繝代こ繝繝医ョ繝ｼ繧ｿ蜿門ｾ + GetPacketBuf(buf); + return packet_len; + } + + case 2: // 蜿嶺ｿ｡繝代こ繝繝亥叙蠕(繧ｵ繧､繧ｺｼ九ヰ繝繝輔ぃ蜷梧凾) + ReceivePacket(); + buf[0] = (BYTE)(packet_len >> 8); + buf[1] = (BYTE)packet_len; + GetPacketBuf(&buf[2]); + return packet_len + 2; + + case 3: // 隍謨ｰ繝代こ繝繝亥酔譎ょ叙蠕(繧ｵ繧､繧ｺｼ九ヰ繝繝輔ぃ蜷梧凾) + // 繝代こ繝繝域焚縺ｮ荳企剞縺ｯ迴ｾ迥ｶ10蛟九↓豎ｺ繧∵遠縺｡ + // 縺薙ｌ莉･荳雁｢励ｄ縺励※繧ゅ≠縺ｾ繧企溘￥縺ｪ繧峨↑縺? + total_len = 0; + for (i = 0; i < 10; i++) { + ReceivePacket(); + *buf++ = (BYTE)(packet_len >> 8); + *buf++ = (BYTE)packet_len; + total_len += 2; + if (packet_len == 0) + break; + GetPacketBuf(buf); + buf += packet_len; + total_len += packet_len; + } + return total_len; + } + break; + + case 2: // 繝帙せ繝医ラ繝ｩ繧､繝 + switch (phase) { + case 0: // 邨先棡繧ｳ繝ｼ繝牙叙蠕 + return ReadFsResult(buf); + + case 1: // 霑泌唆繝繝ｼ繧ｿ蜿門ｾ + return ReadFsOut(buf); + + case 2: // 霑泌唆霑ｽ蜉繝繝ｼ繧ｿ蜿門ｾ + return ReadFsOpt(buf); + } + break; + } + + // 繧ｨ繝ｩ繝ｼ + ASSERT(FALSE); + return 0; +} + +//--------------------------------------------------------------------------- +// +// SEND MESSAGE(10) +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIBR::SendMessage10(const DWORD *cdb, BYTE *buf) +{ + int type; + int func; + int phase; + int len; + + ASSERT(this); + ASSERT(cdb); + ASSERT(buf); + + // 繧ｿ繧､繝 + type = cdb[2]; + + // 讖溯ｽ逡ｪ蜿ｷ + func = cdb[3]; + + // 繝輔ぉ繝ｼ繧ｺ + phase = cdb[9]; + + // 繝ｩ繧､繝域焚繧貞叙蠕 + len = cdb[6]; + len <<= 8; + len |= cdb[7]; + len <<= 8; + len |= cdb[8]; + + switch (type) { + case 1: // 繧､繝ｼ繧ｵ繝阪ャ繝 + // TAP辟｡蜉ｹ縺ｪ繧牙ｦ逅縺励↑縺 + if (!m_bTapEnable) { + return FALSE; + } + + switch (func) { + case 0: // MAC繧｢繝峨Ξ繧ｹ險ｭ螳 + SetMacAddr(buf); + return TRUE; + + case 1: // 繝代こ繝繝磯∽ｿ｡ + SendPacket(buf, len); + return TRUE; + } + break; + + case 2: // 繝帙せ繝医ラ繝ｩ繧､繝 + switch (phase) { + case 0: // 繧ｳ繝槭Φ繝臥匱陦 + WriteFs(func, buf); + return TRUE; + + case 1: // 霑ｽ蜉繝繝ｼ繧ｿ譖ｸ縺崎ｾｼ縺ｿ + WriteFsOpt(buf, len); + return TRUE; + } + break; + } + + // 繧ｨ繝ｩ繝ｼ + ASSERT(FALSE); + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// MAC繧｢繝峨Ξ繧ｹ蜿門ｾ +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::GetMacAddr(BYTE *mac) +{ + ASSERT(this); + ASSERT(mac); + + memcpy(mac, mac_addr, 6); + return 6; +} + +//--------------------------------------------------------------------------- +// +// MAC繧｢繝峨Ξ繧ｹ險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::SetMacAddr(BYTE *mac) +{ + ASSERT(this); + ASSERT(mac); + + memcpy(mac_addr, mac, 6); +} + +//--------------------------------------------------------------------------- +// +// 繝代こ繝繝亥女菫｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::ReceivePacket() +{ + static const BYTE bcast_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; + BYTE buf[0x1000]; + + ASSERT(this); + ASSERT(tap); + + // 蜑阪ｮ繝代こ繝繝医′蜿嶺ｿ｡縺輔ｌ縺ｦ縺縺ｪ縺 + if (packet_enable) { + return; + } + + // 繝代こ繝繝亥女菫｡ + packet_len = tap->Rx(packet_buf); + + // 蜿嶺ｿ｡繝代こ繝繝医°讀懈渊 + if (memcmp(packet_buf, mac_addr, 6) != 0) { + if (memcmp(packet_buf, bcast_addr, 6) != 0) { + packet_len = 0; + return; + } + } + + // 繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ繧定ｶ翫∴縺溘ｉ謐ｨ縺ｦ繧 + if (packet_len > 2048) { + packet_len = 0; + return; + } + + // 蜿嶺ｿ｡繝舌ャ繝輔ぃ縺ｫ譬ｼ邏 + if (packet_len > 0) { + packet_enable = TRUE; + } +} + +//--------------------------------------------------------------------------- +// +// 繝代こ繝繝亥叙蠕 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::GetPacketBuf(BYTE *buf) +{ + int len; + + ASSERT(this); + ASSERT(tap); + ASSERT(buf); + + // 繧ｵ繧､繧ｺ蛻ｶ髯 + len = packet_len; + if (len > 2048) { + len = 2048; + } + + // 繧ｳ繝斐ｼ + memcpy(buf, packet_buf, len); + + // 蜿嶺ｿ｡貂医∩ + packet_enable = FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繝代こ繝繝磯∽ｿ｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::SendPacket(BYTE *buf, int len) +{ + ASSERT(this); + ASSERT(tap); + ASSERT(buf); + + tap->Tx(buf, len); +} + +//--------------------------------------------------------------------------- +// +// $40 - 繝繝舌う繧ｹ襍ｷ蜍 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_InitDevice(BYTE *buf) +{ + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + fs->Reset(); + fsresult = fs->InitDevice((Human68k::argument_t*)buf); +} + +//--------------------------------------------------------------------------- +// +// $41 - 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_CheckDir(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + fsresult = fs->CheckDir(nUnit, pNamests); +} + +//--------------------------------------------------------------------------- +// +// $42 - 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_MakeDir(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + fsresult = fs->MakeDir(nUnit, pNamests); +} + +//--------------------------------------------------------------------------- +// +// $43 - 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_RemoveDir(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + fsresult = fs->RemoveDir(nUnit, pNamests); +} + +//--------------------------------------------------------------------------- +// +// $44 - 繝輔ぃ繧､繝ｫ蜷榊､画峩 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Rename(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + Human68k::namests_t* pNamestsNew; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + pNamestsNew = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + fsresult = fs->Rename(nUnit, pNamests, pNamestsNew); +} + +//--------------------------------------------------------------------------- +// +// $45 - 繝輔ぃ繧､繝ｫ蜑企勁 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Delete(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + fsresult = fs->Delete(nUnit, pNamests); +} + +//--------------------------------------------------------------------------- +// +// $46 - 繝輔ぃ繧､繝ｫ螻樊ｧ蜿門ｾ/險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Attribute(BYTE *buf) +{ + DWORD nUnit; + Human68k::namests_t *pNamests; + DWORD nHumanAttribute; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + dp = (DWORD*)&buf[i]; + nHumanAttribute = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->Attribute(nUnit, pNamests, nHumanAttribute); +} + +//--------------------------------------------------------------------------- +// +// $47 - 繝輔ぃ繧､繝ｫ讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Files(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::namests_t *pNamests; + Human68k::files_t *files; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + files = (Human68k::files_t*)&buf[i]; + i += sizeof(Human68k::files_t); + + files->sector = ntohl(files->sector); + files->offset = ntohs(files->offset); + files->time = ntohs(files->time); + files->date = ntohs(files->date); + files->size = ntohl(files->size); + + fsresult = fs->Files(nUnit, nKey, pNamests, files); + + files->sector = htonl(files->sector); + files->offset = htons(files->offset); + files->time = htons(files->time); + files->date = htons(files->date); + files->size = htonl(files->size); + + i = 0; + memcpy(&fsout[i], files, sizeof(Human68k::files_t)); + i += sizeof(Human68k::files_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $48 - 繝輔ぃ繧､繝ｫ谺｡讀懃ｴ｢ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_NFiles(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::files_t *files; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + files = (Human68k::files_t*)&buf[i]; + i += sizeof(Human68k::files_t); + + files->sector = ntohl(files->sector); + files->offset = ntohs(files->offset); + files->time = ntohs(files->time); + files->date = ntohs(files->date); + files->size = ntohl(files->size); + + fsresult = fs->NFiles(nUnit, nKey, files); + + files->sector = htonl(files->sector); + files->offset = htons(files->offset); + files->time = htons(files->time); + files->date = htons(files->date); + files->size = htonl(files->size); + + i = 0; + memcpy(&fsout[i], files, sizeof(Human68k::files_t)); + i += sizeof(Human68k::files_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $49 - 繝輔ぃ繧､繝ｫ菴懈 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Create(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::namests_t *pNamests; + Human68k::fcb_t *pFcb; + DWORD nAttribute; + BOOL bForce; + DWORD *dp; + BOOL *bp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + dp = (DWORD*)&buf[i]; + nAttribute = ntohl(*dp); + i += sizeof(DWORD); + + bp = (BOOL*)&buf[i]; + bForce = ntohl(*bp); + i += sizeof(BOOL); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Create(nUnit, nKey, pNamests, pFcb, nAttribute, bForce); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $4A - 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Open(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::namests_t *pNamests; + Human68k::fcb_t *pFcb; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pNamests = (Human68k::namests_t*)&buf[i]; + i += sizeof(Human68k::namests_t); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Open(nUnit, nKey, pNamests, pFcb); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $4B - 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Close(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::fcb_t *pFcb; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Close(nUnit, nKey, pFcb); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $4C - 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Read(BYTE *buf) +{ + DWORD nKey; + Human68k::fcb_t *pFcb; + DWORD nSize; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + dp = (DWORD*)&buf[i]; + nSize = ntohl(*dp); + i += sizeof(DWORD); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Read(nKey, pFcb, fsopt, nSize); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; + + fsoptlen = fsresult; +} + +//--------------------------------------------------------------------------- +// +// $4D - 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Write(BYTE *buf) +{ + DWORD nKey; + Human68k::fcb_t *pFcb; + DWORD nSize; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + dp = (DWORD*)&buf[i]; + nSize = ntohl(*dp); + i += sizeof(DWORD); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Write(nKey, pFcb, fsopt, nSize); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $4E - 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Seek(BYTE *buf) +{ + DWORD nKey; + Human68k::fcb_t *pFcb; + DWORD nMode; + int nOffset; + DWORD *dp; + int *ip; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + dp = (DWORD*)&buf[i]; + nMode = ntohl(*dp); + i += sizeof(DWORD); + + ip = (int*)&buf[i]; + nOffset = ntohl(*ip); + i += sizeof(int); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->Seek(nKey, pFcb, nMode, nOffset); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $4F - 繝輔ぃ繧､繝ｫ譎ょ綾蜿門ｾ/險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_TimeStamp(BYTE *buf) +{ + DWORD nUnit; + DWORD nKey; + Human68k::fcb_t *pFcb; + DWORD nHumanTime; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nKey = ntohl(*dp); + i += sizeof(DWORD); + + pFcb = (Human68k::fcb_t*)&buf[i]; + i += sizeof(Human68k::fcb_t); + + dp = (DWORD*)&buf[i]; + nHumanTime = ntohl(*dp); + i += sizeof(DWORD); + + pFcb->fileptr = ntohl(pFcb->fileptr); + pFcb->mode = ntohs(pFcb->mode); + pFcb->time = ntohs(pFcb->time); + pFcb->date = ntohs(pFcb->date); + pFcb->size = ntohl(pFcb->size); + + fsresult = fs->TimeStamp(nUnit, nKey, pFcb, nHumanTime); + + pFcb->fileptr = htonl(pFcb->fileptr); + pFcb->mode = htons(pFcb->mode); + pFcb->time = htons(pFcb->time); + pFcb->date = htons(pFcb->date); + pFcb->size = htonl(pFcb->size); + + i = 0; + memcpy(&fsout[i], pFcb, sizeof(Human68k::fcb_t)); + i += sizeof(Human68k::fcb_t); + + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $50 - 螳ｹ驥丞叙蠕 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_GetCapacity(BYTE *buf) +{ + DWORD nUnit; + Human68k::capacity_t cap; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->GetCapacity(nUnit, &cap); + + cap.freearea = htons(cap.freearea); + cap.clusters = htons(cap.clusters); + cap.sectors = htons(cap.sectors); + cap.bytes = htons(cap.bytes); + + memcpy(fsout, &cap, sizeof(Human68k::capacity_t)); + fsoutlen = sizeof(Human68k::capacity_t); +} + +//--------------------------------------------------------------------------- +// +// $51 - 繝峨Λ繧､繝也憾諷区､懈渊/蛻ｶ蠕｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_CtrlDrive(BYTE *buf) +{ + DWORD nUnit; + Human68k::ctrldrive_t *pCtrlDrive; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + pCtrlDrive = (Human68k::ctrldrive_t*)&buf[i]; + i += sizeof(Human68k::ctrldrive_t); + + fsresult = fs->CtrlDrive(nUnit, pCtrlDrive); + + memcpy(fsout, pCtrlDrive, sizeof(Human68k::ctrldrive_t)); + fsoutlen = sizeof(Human68k::ctrldrive_t); +} + +//--------------------------------------------------------------------------- +// +// $52 - DPB蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_GetDPB(BYTE *buf) +{ + DWORD nUnit; + Human68k::dpb_t dpb; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->GetDPB(nUnit, &dpb); + + dpb.sector_size = htons(dpb.sector_size); + dpb.fat_sector = htons(dpb.fat_sector); + dpb.file_max = htons(dpb.file_max); + dpb.data_sector = htons(dpb.data_sector); + dpb.cluster_max = htons(dpb.cluster_max); + dpb.root_sector = htons(dpb.root_sector); + + memcpy(fsout, &dpb, sizeof(Human68k::dpb_t)); + fsoutlen = sizeof(Human68k::dpb_t); +} + +//--------------------------------------------------------------------------- +// +// $53 - 繧ｻ繧ｯ繧ｿ隱ｭ縺ｿ霎ｼ縺ｿ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_DiskRead(BYTE *buf) +{ + DWORD nUnit; + DWORD nSector; + DWORD nSize; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nSector = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nSize = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->DiskRead(nUnit, fsout, nSector, nSize); + fsoutlen = 0x200; +} + +//--------------------------------------------------------------------------- +// +// $54 - 繧ｻ繧ｯ繧ｿ譖ｸ縺崎ｾｼ縺ｿ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_DiskWrite(BYTE *buf) +{ + DWORD nUnit; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->DiskWrite(nUnit); +} + +//--------------------------------------------------------------------------- +// +// $55 - IOCTRL +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Ioctrl(BYTE *buf) +{ + DWORD nUnit; + DWORD nFunction; + Human68k::ioctrl_t *pIoctrl; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + dp = (DWORD*)&buf[i]; + nFunction = ntohl(*dp); + i += sizeof(DWORD); + + pIoctrl = (Human68k::ioctrl_t*)&buf[i]; + i += sizeof(Human68k::ioctrl_t); + + switch (nFunction) { + case 2: + case -2: + pIoctrl->param = htonl(pIoctrl->param); + break; + } + + fsresult = fs->Ioctrl(nUnit, nFunction, pIoctrl); + + switch (nFunction) { + case 0: + pIoctrl->media = htons(pIoctrl->media); + break; + case 1: + case -3: + pIoctrl->param = htonl(pIoctrl->param); + break; + } + + i = 0; + memcpy(&fsout[i], pIoctrl, sizeof(Human68k::ioctrl_t)); + i += sizeof(Human68k::ioctrl_t); + fsoutlen = i; +} + +//--------------------------------------------------------------------------- +// +// $56 - 繝輔Λ繝繧ｷ繝･ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Flush(BYTE *buf) +{ + DWORD nUnit; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->Flush(nUnit); +} + +//--------------------------------------------------------------------------- +// +// $57 - 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_CheckMedia(BYTE *buf) +{ + DWORD nUnit; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->CheckMedia(nUnit); +} + +//--------------------------------------------------------------------------- +// +// $58 - 謗剃ｻ門宛蠕｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::FS_Lock(BYTE *buf) +{ + DWORD nUnit; + DWORD *dp; + int i; + + ASSERT(this); + ASSERT(fs); + ASSERT(buf); + + i = 0; + dp = (DWORD*)buf; + nUnit = ntohl(*dp); + i += sizeof(DWORD); + + fsresult = fs->Lock(nUnit); +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(邨先棡繧ｳ繝ｼ繝) +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::ReadFsResult(BYTE *buf) +{ + DWORD *dp; + + ASSERT(this); + ASSERT(buf); + + dp = (DWORD*)buf; + *dp = htonl(fsresult); + return sizeof(DWORD); +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(霑泌唆繝繝ｼ繧ｿ) +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::ReadFsOut(BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + memcpy(buf, fsout, fsoutlen); + return fsoutlen; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(霑泌唆繧ｪ繝励す繝ｧ繝ｳ繝繝ｼ繧ｿ) +// +//--------------------------------------------------------------------------- +int FASTCALL SCSIBR::ReadFsOpt(BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + memcpy(buf, fsopt, fsoptlen); + return fsoptlen; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝譖ｸ縺崎ｾｼ縺ｿ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::WriteFs(int func, BYTE *buf) +{ + ASSERT(this); + ASSERT(buf); + + fsresult = FS_FATAL_INVALIDCOMMAND; + fsoutlen = 0; + fsoptlen = 0; + + // 繧ｳ繝槭Φ繝牙蟯 + func &= 0x1f; + switch (func) { + case 0x00: return FS_InitDevice(buf); // $40 - 繝繝舌う繧ｹ襍ｷ蜍 + case 0x01: return FS_CheckDir(buf); // $41 - 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ + case 0x02: return FS_MakeDir(buf); // $42 - 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + case 0x03: return FS_RemoveDir(buf); // $43 - 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 + case 0x04: return FS_Rename(buf); // $44 - 繝輔ぃ繧､繝ｫ蜷榊､画峩 + case 0x05: return FS_Delete(buf); // $45 - 繝輔ぃ繧､繝ｫ蜑企勁 + case 0x06: return FS_Attribute(buf); // $46 - 繝輔ぃ繧､繝ｫ螻樊ｧ蜿門ｾ/險ｭ螳 + case 0x07: return FS_Files(buf); // $47 - 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + case 0x08: return FS_NFiles(buf); // $48 - 繝輔ぃ繧､繝ｫ谺｡讀懃ｴ｢ + case 0x09: return FS_Create(buf); // $49 - 繝輔ぃ繧､繝ｫ菴懈 + case 0x0A: return FS_Open(buf); // $4A - 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + case 0x0B: return FS_Close(buf); // $4B - 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + case 0x0C: return FS_Read(buf); // $4C - 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ + case 0x0D: return FS_Write(buf); // $4D - 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ + case 0x0E: return FS_Seek(buf); // $4E - 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + case 0x0F: return FS_TimeStamp(buf); // $4F - 繝輔ぃ繧､繝ｫ譖ｴ譁ｰ譎ょ綾縺ｮ蜿門ｾ/險ｭ螳 + case 0x10: return FS_GetCapacity(buf); // $50 - 螳ｹ驥丞叙蠕 + case 0x11: return FS_CtrlDrive(buf); // $51 - 繝峨Λ繧､繝門宛蠕｡/迥ｶ諷区､懈渊 + case 0x12: return FS_GetDPB(buf); // $52 - DPB蜿門ｾ + case 0x13: return FS_DiskRead(buf); // $53 - 繧ｻ繧ｯ繧ｿ隱ｭ縺ｿ霎ｼ縺ｿ + case 0x14: return FS_DiskWrite(buf); // $54 - 繧ｻ繧ｯ繧ｿ譖ｸ縺崎ｾｼ縺ｿ + case 0x15: return FS_Ioctrl(buf); // $55 - IOCTRL + case 0x16: return FS_Flush(buf); // $56 - 繝輔Λ繝繧ｷ繝･ + case 0x17: return FS_CheckMedia(buf); // $57 - 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ + case 0x18: return FS_Lock(buf); // $58 - 謗剃ｻ門宛蠕｡ + } +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝譖ｸ縺崎ｾｼ縺ｿ(蜈･蜉帙が繝励す繝ｧ繝ｳ繝繝ｼ繧ｿ) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIBR::WriteFsOpt(BYTE *buf, int num) +{ + ASSERT(this); + + memcpy(fsopt, buf, num); +} + +//=========================================================================== +// +// SASI 繝繝舌う繧ｹ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +#ifdef RASCSI +SASIDEV::SASIDEV() +#else +SASIDEV::SASIDEV(Device *dev) +#endif // RASCSI +{ + int i; + +#ifndef RASCSI + // 繝帙せ繝医ョ繝舌う繧ｹ繧定ｨ俶ｶ + host = dev; +#endif // RASCSI + + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + ctrl.phase = BUS::busfree; + ctrl.id = -1; + ctrl.bus = NULL; + memset(ctrl.cmd, 0x00, sizeof(ctrl.cmd)); + ctrl.status = 0x00; + ctrl.message = 0x00; + ctrl.bufsize = 0x800; + ctrl.buffer = new BYTE[ctrl.bufsize]; + memset(ctrl.buffer, 0x00, ctrl.bufsize); + ctrl.blocks = 0; + ctrl.next = 0; + ctrl.offset = 0; + ctrl.length = 0; + + // 隲也炊繝ｦ繝九ャ繝亥晄悄蛹 + for (i = 0; i < UnitMax; i++) { + ctrl.unit[i] = NULL; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +SASIDEV::~SASIDEV() +{ + // 繝舌ャ繝輔ぃ繧帝幕謾ｾ + if (ctrl.buffer) { + delete ctrl.buffer; + ctrl.buffer = NULL; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝舌う繧ｹ繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Reset() +{ + int i; + + ASSERT(this); + + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + memset(ctrl.cmd, 0x00, sizeof(ctrl.cmd)); + ctrl.phase = BUS::busfree; + ctrl.status = 0x00; + ctrl.message = 0x00; + memset(ctrl.buffer, 0x00, ctrl.bufsize); + ctrl.blocks = 0; + ctrl.next = 0; + ctrl.offset = 0; + ctrl.length = 0; + + // 繝ｦ繝九ャ繝亥晄悄蛹 + for (i = 0; i < UnitMax; i++) { + if (ctrl.unit[i]) { + ctrl.unit[i]->Reset(); + } + } +} + +#ifndef RASCSI +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIDEV::Save(Fileio *fio, int /*ver*/) +{ + DWORD sz; + + ASSERT(this); + ASSERT(fio); + + // 繧ｵ繧､繧ｺ繧偵そ繝ｼ繝 + sz = 2120; + if (!fio->Write(&sz, sizeof(sz))) { + return FALSE; + } + + // 螳滉ｽ薙ｒ繧ｻ繝ｼ繝 + PROP_EXPORT(fio, ctrl.phase); + PROP_EXPORT(fio, ctrl.id); + PROP_EXPORT(fio, ctrl.cmd); + PROP_EXPORT(fio, ctrl.status); + PROP_EXPORT(fio, ctrl.message); + if (!fio->Write(ctrl.buffer, 0x800)) { + return FALSE; + } + PROP_EXPORT(fio, ctrl.blocks); + PROP_EXPORT(fio, ctrl.next); + PROP_EXPORT(fio, ctrl.offset); + PROP_EXPORT(fio, ctrl.length); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIDEV::Load(Fileio *fio, int ver) +{ + DWORD sz; + + ASSERT(this); + ASSERT(fio); + + // version3.11繧医ｊ蜑阪ｯ繧ｻ繝ｼ繝悶＠縺ｦ縺縺ｪ縺 + if (ver <= 0x0311) { + return TRUE; + } + + // 繧ｵ繧､繧ｺ繧偵Ο繝ｼ繝峨∫ｧ蜷 + if (!fio->Read(&sz, sizeof(sz))) { + return FALSE; + } + if (sz != 2120) { + return FALSE; + } + + // 螳滉ｽ薙ｒ繝ｭ繝ｼ繝 + PROP_IMPORT(fio, ctrl.phase); + PROP_IMPORT(fio, ctrl.id); + PROP_IMPORT(fio, ctrl.cmd); + PROP_IMPORT(fio, ctrl.status); + PROP_IMPORT(fio, ctrl.message); + if (!fio->Read(ctrl.buffer, 0x800)) { + return FALSE; + } + PROP_IMPORT(fio, ctrl.blocks); + PROP_IMPORT(fio, ctrl.next); + PROP_IMPORT(fio, ctrl.offset); + PROP_IMPORT(fio, ctrl.length); + + return TRUE; +} +#endif // RASCSI + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ謗･邯 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Connect(int id, BUS *bus) +{ + ASSERT(this); + + ctrl.id = id; + ctrl.bus = bus; +} + +//--------------------------------------------------------------------------- +// +// 隲也炊繝ｦ繝九ャ繝亥叙蠕 +// +//--------------------------------------------------------------------------- +Disk* FASTCALL SASIDEV::GetUnit(int no) +{ + ASSERT(this); + ASSERT(no < UnitMax); + + return ctrl.unit[no]; +} + +//--------------------------------------------------------------------------- +// +// 隲也炊繝ｦ繝九ャ繝郁ｨｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::SetUnit(int no, Disk *dev) +{ + ASSERT(this); + ASSERT(no < UnitMax); + + ctrl.unit[no] = dev; +} + +//--------------------------------------------------------------------------- +// +// 譛牙柑縺ｪ隲也炊繝ｦ繝九ャ繝医ｒ謖√▲縺ｦ縺繧九°霑斐☆ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIDEV::HasUnit() +{ + int i; + + ASSERT(this); + + for (i = 0; i < UnitMax; i++) { + if (ctrl.unit[i]) { + return TRUE; + } + } + + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 蜀驛ｨ繝繝ｼ繧ｿ蜿門ｾ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::GetCTRL(ctrl_t *buffer) +{ + ASSERT(this); + ASSERT(buffer); + + // 蜀驛ｨ繝ｯ繝ｼ繧ｯ繧偵さ繝斐ｼ + *buffer = ctrl; +} + +//--------------------------------------------------------------------------- +// +// 繝薙ず繝ｼ迥ｶ諷九ｮ繝ｦ繝九ャ繝医ｒ蜿門ｾ +// +//--------------------------------------------------------------------------- +Disk* FASTCALL SASIDEV::GetBusyUnit() +{ + DWORD lun; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + return ctrl.unit[lun]; +} + +//--------------------------------------------------------------------------- +// +// 螳溯｡ +// +//--------------------------------------------------------------------------- +BUS::phase_t FASTCALL SASIDEV::Process() +{ + ASSERT(this); + + // 譛ｪ謗･邯壹↑繧我ｽ輔ｂ縺励↑縺 + if (ctrl.id < 0 || ctrl.bus == NULL) { + return ctrl.phase; + } + + // 繝舌せ諠蝣ｱ縺ｮ蜿悶ｊ霎ｼ縺ｿ + ctrl.bus->Aquire(); + + // 繝ｪ繧ｻ繝繝 + if (ctrl.bus->GetRST()) { +#if defined(DISK_LOG) + Log(Log::Normal, "RESET菫｡蜿ｷ蜿嶺ｿ｡"); +#endif // DISK_LOG + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧偵Μ繧ｻ繝繝 + Reset(); + + // 繝舌せ繧ゅΜ繧ｻ繝繝 + ctrl.bus->Reset(); + return ctrl.phase; + } + + // 繝輔ぉ繝ｼ繧ｺ蜃ｦ逅 + switch (ctrl.phase) { + // 繝舌せ繝輔Μ繝ｼ + case BUS::busfree: + BusFree(); + break; + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ + case BUS::selection: + Selection(); + break; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝(MCI=000) + case BUS::dataout: + DataOut(); + break; + + // 繝繝ｼ繧ｿ繧､繝ｳ(MCI=001) + case BUS::datain: + DataIn(); + break; + + // 繧ｳ繝槭Φ繝(MCI=010) + case BUS::command: + Command(); + break; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ(MCI=011) + case BUS::status: + Status(); + break; + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ(MCI=111) + case BUS::msgin: + MsgIn(); + break; + + // 縺昴ｮ莉 + default: + ASSERT(FALSE); + break; + } + + return ctrl.phase; +} + +//--------------------------------------------------------------------------- +// +// 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::BusFree() +{ + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::busfree) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::busfree; + + // 菫｡蜿ｷ邱 + ctrl.bus->SetBSY(FALSE); + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(FALSE); + ctrl.bus->SetIO(FALSE); + ctrl.bus->SetREQ(FALSE); + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ縺ｨ繝｡繝繧ｻ繝ｼ繧ｸ繧貞晄悄蛹 + ctrl.status = 0x00; + ctrl.message = 0x00; + + // 繝舌せ繧ｯ繝ｪ繧｢繝繧｣繝ｬ繧､ + ctrl.bus->SleepNsec(Time_phase_bsy); + return; + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ陦 + if (ctrl.bus->GetSEL() && !ctrl.bus->GetBSY()) { + Selection(); + } +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Selection() +{ + DWORD id; + + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::selection) { + // ID縺御ｸ閾ｴ縺励※縺縺ｪ縺代ｌ縺ｰ辟｡蜉ｹ + id = 1 << ctrl.id; + if ((ctrl.bus->GetDAT() & id) == 0) { + return; + } + + // 譛牙柑縺ｪ繝ｦ繝九ャ繝医′辟｡縺代ｌ縺ｰ邨ゆｺ + if (!HasUnit()) { + return; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ ID=%d (繝繝舌う繧ｹ縺ゅｊ)", ctrl.id); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + ctrl.phase = BUS::selection; + + // BSY繧剃ｸ翫£縺ｦ蠢懃ｭ + ctrl.bus->SetBSY(TRUE); + return; + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ螳御ｺ縺ｧ繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ遘ｻ陦 + if (!ctrl.bus->GetSEL() && ctrl.bus->GetBSY()) { + Command(); + } +} + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Command() +{ + BYTE data; + int count; + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::command) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::command; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(TRUE); + ctrl.bus->SetIO(FALSE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after); + + // 繝繝ｼ繧ｿ霆｢騾√ｯ6繝舌う繝x1繝悶Ο繝繧ｯ + ctrl.offset = 0; + ctrl.length = 6; + ctrl.blocks = 1; + + // 譛蛻昴ｮ1繝舌う繝医ｒ蜿門ｾ(蜻ｽ莉､髟ｷ險育ｮ励ｮ縺溘ａ) + count = ctrl.bus->ReceiveHandShake(&data, 1); + ctrl.buffer[ctrl.offset] = data; + + // 繝ｪ繧ｶ繝ｫ繝FALSE縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (count != 1) { + Error(); + return; + } + + if (ctrl.buffer[0] >= 0x20 && ctrl.buffer[0] <= 0x7D) { + // 10繝舌う繝CDB + ctrl.length = 10; + } + + // 繧ｪ繝輔そ繝繝医→繝ｬ繝ｳ繧ｰ繧ｹ + ctrl.offset++; + ctrl.length--; + return; + } + + // 蜿嶺ｿ｡ + Receive(); +} + +//--------------------------------------------------------------------------- +// +// 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Execute() +{ + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "螳溯｡後ヵ繧ｧ繝ｼ繧ｺ 繧ｳ繝槭Φ繝$%02X", ctrl.cmd[0]); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::execute; + + // 繝繝ｼ繧ｿ霆｢騾√ｮ縺溘ａ縺ｮ蛻晄悄蛹 + ctrl.offset = 0; + ctrl.blocks = 1; + + // 繧ｳ繝槭Φ繝牙挨蜃ｦ逅 + switch (ctrl.cmd[0]) { + // TEST UNIT READY + case 0x00: + CmdTestUnitReady(); + return; + + // REZERO UNIT + case 0x01: + CmdRezero(); + return; + + // REQUEST SENSE + case 0x03: + CmdRequestSense(); + return; + + // FORMAT UNIT + case 0x04: + CmdFormat(); + return; + + // FORMAT UNIT + case 0x06: + CmdFormat(); + return; + + // REASSIGN BLOCKS + case 0x07: + CmdReassign(); + return; + + // READ(6) + case 0x08: + CmdRead6(); + return; + + // WRITE(6) + case 0x0a: + CmdWrite6(); + return; + + // SEEK(6) + case 0x0b: + CmdSeek6(); + return; + + // ASSIGN(SASI縺ｮ縺ｿ) + case 0x0e: + CmdAssign(); + return; + + // SPECIFY(SASI縺ｮ縺ｿ) + case 0xc2: + CmdSpecify(); + return; + } + + // 縺昴ｌ莉･螟悶ｯ蟇ｾ蠢懊＠縺ｦ縺縺ｪ縺 + Log(Log::Warning, "譛ｪ蟇ｾ蠢懊さ繝槭Φ繝 $%02X", ctrl.cmd[0]); + CmdInvalid(); +} + +//--------------------------------------------------------------------------- +// +// 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Status() +{ + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::status) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::status; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(TRUE); + ctrl.bus->SetIO(TRUE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after_status); + + // 繝繝ｼ繧ｿ霆｢騾√ｯ1繝舌う繝x1繝悶Ο繝繧ｯ + ctrl.offset = 0; + ctrl.length = 1; + ctrl.blocks = 1; + ctrl.buffer[0] = (BYTE)ctrl.status; + return; + } + + // 騾∽ｿ｡ + Send(); +} + +//--------------------------------------------------------------------------- +// +// 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::MsgIn() +{ + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::msgin) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::msgin; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(TRUE); + ctrl.bus->SetCD(TRUE); + ctrl.bus->SetIO(TRUE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after); + + // length, blocks縺ｯ險ｭ螳壽ｸ医∩ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.blocks > 0); + ctrl.offset = 0; + return; + } + + // 騾∽ｿ｡ + Send(); +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::DataIn() +{ + ASSERT(this); + ASSERT(ctrl.length >= 0); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::datain) { + // 繝ｬ繝ｳ繧ｰ繧ｹ0縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ + if (ctrl.length == 0) { + Status(); + return; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before_data); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::datain; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(FALSE); + ctrl.bus->SetIO(TRUE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after); + + // length, blocks縺ｯ險ｭ螳壽ｸ医∩ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.blocks > 0); + ctrl.offset = 0; + return; + } + + // 騾∽ｿ｡ + Send(); +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::DataOut() +{ + ASSERT(this); + ASSERT(ctrl.length >= 0); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::dataout) { + // 繝ｬ繝ｳ繧ｰ繧ｹ0縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ + if (ctrl.length == 0) { + Status(); + return; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before_data); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::dataout; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(FALSE); + ctrl.bus->SetIO(FALSE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after); + + // length, blocks縺ｯ險ｭ螳壽ｸ医∩ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.blocks > 0); + ctrl.offset = 0; + return; + } + + // 蜿嶺ｿ｡ + Receive(); +} + +//--------------------------------------------------------------------------- +// +// 蜈ｱ騾壹お繝ｩ繝ｼ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Error() +{ + DWORD lun; + + ASSERT(this); + + // 繝舌せ諠蝣ｱ縺ｮ蜿悶ｊ霎ｼ縺ｿ + ctrl.bus->Aquire(); + + // 繝ｪ繧ｻ繝繝医メ繧ｧ繝繧ｯ + if (ctrl.bus->GetRST()) { + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧偵Μ繧ｻ繝繝 + Reset(); + + // 繝舌せ繧ゅΜ繧ｻ繝繝 + ctrl.bus->Reset(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縲√Γ繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ縺ｯ繝舌せ繝輔Μ繝ｼ + if (ctrl.phase == BUS::status || ctrl.phase == BUS::msgin) { + BusFree(); + return; + } + +#if defined(DISK_LOG) + Log(Log::Warning, "繧ｨ繝ｩ繝ｼ(繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ)"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ縺ｨ繝｡繝繧ｻ繝ｼ繧ｸ繧定ｨｭ螳(CHECK CONDITION) + ctrl.status = (lun << 5) | 0x02; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// TEST UNIT READY +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdTestUnitReady() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "TEST UNIT READY繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->TestUnitReady(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// REZERO UNIT +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdRezero() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "REZERO UNIT繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Rezero(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// REQUEST SENSE +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdRequestSense() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "REQUEST SENSE繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->RequestSense(ctrl.cmd, ctrl.buffer); + ASSERT(ctrl.length > 0); + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｻ繝ｳ繧ｹ繧ｭ繝ｼ $%02X", ctrl.buffer[2]); +#endif // DISK_LOG + + // 繝ｪ繝ｼ繝峨ヵ繧ｧ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// FORMAT UNIT +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdFormat() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "FORMAT UNIT繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Format(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// REASSIGN BLOCKS +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdReassign() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "REASSIGN BLOCKS繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Reassign(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// READ(6) +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdRead6() +{ + DWORD lun; + DWORD record; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝ｬ繧ｳ繝ｼ繝臥分蜿ｷ縺ｨ繝悶Ο繝繧ｯ謨ｰ繧貞叙蠕 + record = ctrl.cmd[1] & 0x1f; + record <<= 8; + record |= ctrl.cmd[2]; + record <<= 8; + record |= ctrl.cmd[3]; + ctrl.blocks = ctrl.cmd[4]; + if (ctrl.blocks == 0) { + ctrl.blocks = 0x100; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "READ(6)繧ｳ繝槭Φ繝 繝ｬ繧ｳ繝ｼ繝=%06X 繝悶Ο繝繧ｯ=%d", record, ctrl.blocks); +#endif // DISK_LOG + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->Read(ctrl.buffer, record); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.next = record + 1; + + // 繝ｪ繝ｼ繝峨ヵ繧ｧ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// WRITE(6) +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdWrite6() +{ + DWORD lun; + DWORD record; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝ｬ繧ｳ繝ｼ繝臥分蜿ｷ縺ｨ繝悶Ο繝繧ｯ謨ｰ繧貞叙蠕 + record = ctrl.cmd[1] & 0x1f; + record <<= 8; + record |= ctrl.cmd[2]; + record <<= 8; + record |= ctrl.cmd[3]; + ctrl.blocks = ctrl.cmd[4]; + if (ctrl.blocks == 0) { + ctrl.blocks = 0x100; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "WRITE(6)繧ｳ繝槭Φ繝 繝ｬ繧ｳ繝ｼ繝=%06X 繝悶Ο繝繧ｯ=%d", record, ctrl.blocks); +#endif // DISK_LOG + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->WriteCheck(record); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.next = record + 1; + + // 繝ｩ繧､繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// SEEK(6) +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdSeek6() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "SEEK(6)繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Seek(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// ASSIGN +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdAssign() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "ASSIGN繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Assign(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 4繝舌う繝医ｮ繝繝ｼ繧ｿ繧偵Μ繧ｯ繧ｨ繧ｹ繝 + ctrl.length = 4; + + // 繝ｩ繧､繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// SPECIFY +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdSpecify() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "SPECIFY繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Assign(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 10繝舌う繝医ｮ繝繝ｼ繧ｿ繧偵Μ繧ｯ繧ｨ繧ｹ繝 + ctrl.length = 10; + + // 繝ｩ繧､繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// 繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繧ｳ繝槭Φ繝 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::CmdInvalid() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (ctrl.unit[lun]) { + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.unit[lun]->InvalidCmd(); + } + + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); +} + +//=========================================================================== +// +// 繝繝ｼ繧ｿ霆｢騾 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ騾∽ｿ｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Send() +{ + int len; + BOOL result; + + ASSERT(this); + ASSERT(!ctrl.bus->GetREQ()); + ASSERT(!ctrl.bus->GetACK()); + ASSERT(ctrl.bus->GetIO()); + + // 繝ｬ繝ｳ繧ｰ繧ｹ!=0縺ｪ繧蛾∽ｿ｡ + if (ctrl.length != 0) { + len = ctrl.bus->SendHandShake( + &ctrl.buffer[ctrl.offset], ctrl.length); + + // 蜈ｨ縺ｦ騾∽ｿ｡縺ｧ縺阪↑縺代ｌ縺ｰ繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (len != ctrl.length) { + Error(); + return; + } + + // 繧ｪ繝輔そ繝繝医→繝ｬ繝ｳ繧ｰ繧ｹ + ctrl.offset += ctrl.length; + ctrl.length = 0; + return; + } + + // 繝悶Ο繝繧ｯ貂帷ｮ励√Μ繧ｶ繝ｫ繝亥晄悄蛹 + ctrl.blocks--; + result = TRUE; + + // 繝繝ｼ繧ｿ蠑輔″蜿悶ｊ蠕後ｮ蜃ｦ逅(繝ｪ繝ｼ繝/繝繝ｼ繧ｿ繧､繝ｳ縺ｮ縺ｿ) + if (ctrl.phase == BUS::datain) { + if (ctrl.blocks != 0) { + // 谺｡縺ｮ繝舌ャ繝輔ぃ繧定ｨｭ螳(offset, length繧偵そ繝繝医☆繧九％縺ｨ) + result = XferIn(ctrl.buffer); + } + } + + // 繝ｪ繧ｶ繝ｫ繝FALSE縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (!result) { + Error(); + return; + } + + // 繝悶Ο繝繧ｯ!=0縺ｪ繧蛾∽ｿ｡邯咏ｶ + if (ctrl.blocks != 0){ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.offset == 0); + return; + } + + // 谺｡繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ蜍 + switch (ctrl.phase) { + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + case BUS::msgin: + // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + BusFree(); + break; + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + case BUS::datain: + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); + break; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + case BUS::status: + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + ctrl.length = 1; + ctrl.blocks = 1; + ctrl.buffer[0] = ctrl.message; + MsgIn(); + break; + + // 縺昴ｮ莉(縺ゅｊ縺医↑縺) + default: + ASSERT(FALSE); + break; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ蜿嶺ｿ｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Receive() +{ + BOOL result; + int i; + int len; + + ASSERT(this); + + // REQ,ACK縺御ｸ九′縺｣縺ｦ縺繧九％縺ｨ + ASSERT(!ctrl.bus->GetREQ()); + ASSERT(!ctrl.bus->GetACK()); + ASSERT(!ctrl.bus->GetIO()); + + // 繝ｬ繝ｳ繧ｰ繧ｹ!=0縺ｪ繧牙女菫｡ + if (ctrl.length != 0) { + // 蜿嶺ｿ｡ + len = ctrl.bus->ReceiveHandShake( + &ctrl.buffer[ctrl.offset], ctrl.length); + + // 蜈ｨ縺ｦ蜿嶺ｿ｡縺ｧ縺阪↑縺代ｌ縺ｰ繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (len != ctrl.length) { + Error(); + return; + } + + // 繧ｪ繝輔そ繝繝医→繝ｬ繝ｳ繧ｰ繧ｹ + ctrl.offset += ctrl.length; + ctrl.length = 0; + return; + } + + // 繝悶Ο繝繧ｯ貂帷ｮ励√Μ繧ｶ繝ｫ繝亥晄悄蛹 + ctrl.blocks--; + result = TRUE; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ縺ｮ蜃ｦ逅 + if (ctrl.phase == BUS::dataout) { + if (ctrl.blocks == 0) { + // 縺薙ｮ繝舌ャ繝輔ぃ縺ｧ邨ゆｺ + result = XferOut(FALSE); + } else { + // 谺｡縺ｮ繝舌ャ繝輔ぃ縺ｫ邯壹￥(offset, length繧偵そ繝繝医☆繧九％縺ｨ) + result = XferOut(TRUE); + } + } + + // 繝ｪ繧ｶ繝ｫ繝FALSE縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (!result) { + Error(); + return; + } + + // 繝悶Ο繝繧ｯ!=0縺ｪ繧牙女菫｡邯咏ｶ + if (ctrl.blocks != 0){ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.offset == 0); + return; + } + + // 谺｡繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ蜍 + switch (ctrl.phase) { + // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + case BUS::command: + // 繧ｳ繝槭Φ繝峨ョ繝ｼ繧ｿ霆｢騾 + len = 6; + if (ctrl.buffer[0] >= 0x20 && ctrl.buffer[0] <= 0x7D) { + // 10繝舌う繝CDB + len = 10; + } + for (i = 0; i < len; i++) { + ctrl.cmd[i] = (DWORD)ctrl.buffer[i]; +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｳ繝槭Φ繝 $%02X", ctrl.cmd[i]); +#endif // DISK_LOG + } + + // 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ + Execute(); + break; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + case BUS::dataout: + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); + break; + + // 縺昴ｮ莉(縺ゅｊ縺医↑縺) + default: + ASSERT(FALSE); + break; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ霆｢騾！N +// 窶ｻoffset, length繧貞崎ｨｭ螳壹☆繧九％縺ｨ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIDEV::XferIn(BYTE *buf) +{ + DWORD lun; + + ASSERT(this); + ASSERT(ctrl.phase == BUS::datain); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + return FALSE; + } + + // READ邉ｻ繧ｳ繝槭Φ繝峨↓髯舌ｋ + switch (ctrl.cmd[0]) { + // READ(6) + case 0x08: + // READ(10) + case 0x28: + // 繝繧｣繧ｹ繧ｯ縺九ｉ隱ｭ縺ｿ蜿悶ｊ繧定｡後≧ + ctrl.length = ctrl.unit[lun]->Read(buf, ctrl.next); + ctrl.next++; + + // 繧ｨ繝ｩ繝ｼ縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ + if (ctrl.length <= 0) { + // 繝繝ｼ繧ｿ繧､繝ｳ荳ｭ豁｢ + return FALSE; + } + + // 豁｣蟶ｸ縺ｪ繧峨√Ρ繝ｼ繧ｯ險ｭ螳 + ctrl.offset = 0; + break; + + // 縺昴ｮ莉(縺ゅｊ縺医↑縺) + default: + ASSERT(FALSE); + return FALSE; + } + + // 繝舌ャ繝輔ぃ險ｭ螳壹↓謌仙粥縺励◆ + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ霆｢騾＾UT +// 窶ｻcont=TRUE縺ｮ蝣ｴ蜷医｛ffset, length繧貞崎ｨｭ螳壹☆繧九％縺ｨ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SASIDEV::XferOut(BOOL cont) +{ + DWORD lun; + SCSIBR *bridge; + + ASSERT(this); + ASSERT(ctrl.phase == BUS::dataout); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + return FALSE; + } + + // MODE SELECT縺ｾ縺溘ｯ縲仝RITE邉ｻ + switch (ctrl.cmd[0]) { + // MODE SELECT + case 0x15: + // MODE SELECT(10) + case 0x55: + if (!ctrl.unit[lun]->ModeSelect(ctrl.cmd, ctrl.buffer, ctrl.offset)) { + // MODE SELECT縺ｫ螟ｱ謨 + return FALSE; + } + break; + + // WRITE(6) + case 0x0a: + // WRITE(10) + case 0x2a: + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｯSEND MESSAGE10縺ｫ蟾ｮ縺玲崛縺医ｋ + if (ctrl.unit[lun]->GetID() == MAKEID('S', 'C', 'B', 'R')) { + bridge = (SCSIBR*)ctrl.unit[lun]; + if (!bridge->SendMessage10(ctrl.cmd, ctrl.buffer)) { + // 譖ｸ縺崎ｾｼ縺ｿ螟ｱ謨 + return FALSE; + } + + // 豁｣蟶ｸ縺ｪ繧峨√Ρ繝ｼ繧ｯ險ｭ螳 + ctrl.offset = 0; + break; + } + + // WRITE AND VERIFY + case 0x2e: + // 譖ｸ縺崎ｾｼ縺ｿ繧定｡後≧ + if (!ctrl.unit[lun]->Write(ctrl.buffer, ctrl.next - 1)) { + // 譖ｸ縺崎ｾｼ縺ｿ螟ｱ謨 + return FALSE; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ縺悟ｿ隕√↑縺縺ｪ繧峨％縺薙∪縺ｧ + ctrl.next++; + if (!cont) { + break; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧偵メ繧ｧ繝繧ｯ + ctrl.length = ctrl.unit[lun]->WriteCheck(ctrl.next); + if (ctrl.length <= 0) { + // 譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪↑縺 + return FALSE; + } + + // 豁｣蟶ｸ縺ｪ繧峨√Ρ繝ｼ繧ｯ險ｭ螳 + ctrl.offset = 0; + break; + + default: + ASSERT(FALSE); + break; + } + + // 繝舌ャ繝輔ぃ菫晏ｭ倥↓謌仙粥縺励◆ + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繧ｰ蜃ｺ蜉 +// +//--------------------------------------------------------------------------- +void FASTCALL SASIDEV::Log(Log::loglevel level, const char *format, ...) +{ + char buffer[0x200]; + va_list args; + va_start(args, format); + +#ifdef RASCSI +#ifndef DISK_LOG + if (level == Log::Warning) { + return; + } +#endif // DISK_LOG +#endif // RASCSI + + // 繝輔か繝ｼ繝槭ャ繝 + vsprintf(buffer, format, args); + + // 蜿ｯ螟蛾聞蠑墓焚邨ゆｺ + va_end(args); + + // 繝ｭ繧ｰ蜃ｺ蜉 +#ifdef RASCSI + printf("%s\n", buffer); +#else + host->GetVM()->GetLog()->Format(level, host, buffer); +#endif // RASCSI +} + +//=========================================================================== +// +// SCSI 繝繝舌う繧ｹ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +#ifdef RASCSI +SCSIDEV::SCSIDEV() : SASIDEV() +#else +SCSIDEV::SCSIDEV(Device *dev) : SASIDEV(dev) +#endif +{ + // 蜷梧悄霆｢騾√Ρ繝ｼ繧ｯ蛻晄悄蛹 + scsi.syncenable = FALSE; + scsi.syncperiod = 50; + scsi.syncoffset = 0; + scsi.atnmsg = FALSE; + scsi.msc = 0; + memset(scsi.msb, 0x00, sizeof(scsi.msb)); +} + +//--------------------------------------------------------------------------- +// +// 繝繝舌う繧ｹ繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Reset() +{ + ASSERT(this); + + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + scsi.atnmsg = FALSE; + scsi.msc = 0; + memset(scsi.msb, 0x00, sizeof(scsi.msb)); + + // 蝓ｺ蠎輔け繝ｩ繧ｹ + SASIDEV::Reset(); +} + +//--------------------------------------------------------------------------- +// +// 螳溯｡ +// +//--------------------------------------------------------------------------- +BUS::phase_t FASTCALL SCSIDEV::Process() +{ + ASSERT(this); + + // 譛ｪ謗･邯壹↑繧我ｽ輔ｂ縺励↑縺 + if (ctrl.id < 0 || ctrl.bus == NULL) { + return ctrl.phase; + } + + // 繝舌せ諠蝣ｱ縺ｮ蜿悶ｊ霎ｼ縺ｿ + ctrl.bus->Aquire(); + + // 繝ｪ繧ｻ繝繝 + if (ctrl.bus->GetRST()) { +#if defined(DISK_LOG) + Log(Log::Normal, "RESET菫｡蜿ｷ蜿嶺ｿ｡"); +#endif // DISK_LOG + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧偵Μ繧ｻ繝繝 + Reset(); + + // 繝舌せ繧ゅΜ繧ｻ繝繝 + ctrl.bus->Reset(); + return ctrl.phase; + } + + // 繝輔ぉ繝ｼ繧ｺ蜃ｦ逅 + switch (ctrl.phase) { + + // 繝舌せ繝輔Μ繝ｼ + case BUS::busfree: + BusFree(); + break; + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + case BUS::selection: + Selection(); + break; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝(MCI=000) + case BUS::dataout: + DataOut(); + break; + + // 繝繝ｼ繧ｿ繧､繝ｳ(MCI=001) + case BUS::datain: + DataIn(); + break; + + // 繧ｳ繝槭Φ繝(MCI=010) + case BUS::command: + Command(); + break; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ(MCI=011) + case BUS::status: + Status(); + break; + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝(MCI=110) + case BUS::msgout: + MsgOut(); + break; + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ(MCI=111) + case BUS::msgin: + MsgIn(); + break; + + // 縺昴ｮ莉 + default: + ASSERT(FALSE); + break; + } + + return ctrl.phase; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::BusFree() +{ + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::busfree) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::busfree; + + // 菫｡蜿ｷ邱 + ctrl.bus->SetBSY(FALSE); + ctrl.bus->SetMSG(FALSE); + ctrl.bus->SetCD(FALSE); + ctrl.bus->SetIO(FALSE); + ctrl.bus->SetREQ(FALSE); + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ縺ｨ繝｡繝繧ｻ繝ｼ繧ｸ繧貞晄悄蛹 + ctrl.status = 0x00; + ctrl.message = 0x00; + + // ATN繝｡繝繧ｻ繝ｼ繧ｸ蜿嶺ｿ｡繧ｹ繧ｿ繝ｼ繧ｿ繧ｹ蛻晄悄蛹 + scsi.atnmsg = FALSE; + + // 繝舌せ繧ｯ繝ｪ繧｢繝繧｣繝ｬ繧､ + ctrl.bus->SleepNsec(Time_phase_bsy); + + return; + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ陦 + if (ctrl.bus->GetSEL() && !ctrl.bus->GetBSY()) { + Selection(); + } +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Selection() +{ + DWORD id; + + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::selection) { + // ID縺御ｸ閾ｴ縺励※縺縺ｪ縺代ｌ縺ｰ辟｡蜉ｹ + id = 1 << ctrl.id; + if ((ctrl.bus->GetDAT() & id) == 0) { + return; + } + + // 譛牙柑縺ｪ繝ｦ繝九ャ繝医′辟｡縺代ｌ縺ｰ邨ゆｺ + if (!HasUnit()) { + return; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ ID=%d (繝繝舌う繧ｹ縺ゅｊ)", ctrl.id); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::selection; + + // BSY繧剃ｸ翫£縺ｦ蠢懃ｭ + ctrl.bus->SetBSY(TRUE); + return; + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ螳御ｺ + if (!ctrl.bus->GetSEL() && ctrl.bus->GetBSY()) { + // ATN=1縺ｪ繧峨Γ繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ縲√◎縺縺ｧ縺ｪ縺代ｌ縺ｰ繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + if (ctrl.bus->GetATN()) { + MsgOut(); + } else { + Command(); + } + } +} + +//--------------------------------------------------------------------------- +// +// 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Execute() +{ + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "螳溯｡後ヵ繧ｧ繝ｼ繧ｺ 繧ｳ繝槭Φ繝$%02X", ctrl.cmd[0]); +#endif // DISK_LOG + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::execute; + + // 繝繝ｼ繧ｿ霆｢騾√ｮ縺溘ａ縺ｮ蛻晄悄蛹 + ctrl.offset = 0; + ctrl.blocks = 1; + + // 蜃ｦ逅譎る俣縺ｮ繝繧｣繝ｬ繧､ + ctrl.bus->SleepNsec(100 * 1000); + + // 繧ｳ繝槭Φ繝牙挨蜃ｦ逅 + switch (ctrl.cmd[0]) { + // TEST UNIT READY + case 0x00: + CmdTestUnitReady(); + return; + + // REZERO + case 0x01: + CmdRezero(); + return; + + // REQUEST SENSE + case 0x03: + CmdRequestSense(); + return; + + // FORMAT UNIT + case 0x04: + CmdFormat(); + return; + + // REASSIGN BLOCKS + case 0x07: + CmdReassign(); + return; + + // READ(6) + case 0x08: + CmdRead6(); + return; + + // WRITE(6) + case 0x0a: + CmdWrite6(); + return; + + // SEEK(6) + case 0x0b: + CmdSeek6(); + return; + + // INQUIRY + case 0x12: + CmdInquiry(); + return; + + // MODE SELECT + case 0x15: + CmdModeSelect(); + return; + + // MDOE SENSE + case 0x1a: + CmdModeSense(); + return; + + // START STOP UNIT + case 0x1b: + CmdStartStop(); + return; + + // SEND DIAGNOSTIC + case 0x1d: + CmdSendDiag(); + return; + + // PREVENT/ALLOW MEDIUM REMOVAL + case 0x1e: + CmdRemoval(); + return; + + // READ CAPACITY + case 0x25: + CmdReadCapacity(); + return; + + // READ(10) + case 0x28: + CmdRead10(); + return; + + // WRITE(10) + case 0x2a: + CmdWrite10(); + return; + + // SEEK(10) + case 0x2b: + CmdSeek10(); + return; + + // WRITE and VERIFY + case 0x2e: + CmdWrite10(); + return; + + // VERIFY + case 0x2f: + CmdVerify(); + return; + + // SYNCHRONIZE CACHE + case 0x35: + CmdSynchronizeCache(); + return; + + // READ DEFECT DATA(10) + case 0x37: + CmdReadDefectData10(); + return; + + // READ TOC + case 0x43: + CmdReadToc(); + return; + + // PLAY AUDIO(10) + case 0x45: + CmdPlayAudio10(); + return; + + // PLAY AUDIO MSF + case 0x47: + CmdPlayAudioMSF(); + return; + + // PLAY AUDIO TRACK + case 0x48: + CmdPlayAudioTrack(); + return; + + // MODE SELECT(10) + case 0x55: + CmdModeSelect10(); + return; + + // MDOE SENSE(10) + case 0x5a: + CmdModeSense10(); + return; + } + + // 縺昴ｌ莉･螟悶ｯ蟇ｾ蠢懊＠縺ｦ縺縺ｪ縺 + Log(Log::Normal, "譛ｪ蟇ｾ蠢懊さ繝槭Φ繝 $%02X", ctrl.cmd[0]); + CmdInvalid(); +} + +//--------------------------------------------------------------------------- +// +// 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::MsgOut() +{ + ASSERT(this); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ + if (ctrl.phase != BUS::msgout) { + +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ"); +#endif // DISK_LOG + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ蠕後ｮ繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ縺ｯIDENTIFY繝｡繝繧ｻ繝ｼ繧ｸ縺ｮ蜃ｦ逅 + if (ctrl.phase == BUS::selection) { + scsi.atnmsg = TRUE; + scsi.msc = 0; + memset(scsi.msb, 0x00, sizeof(scsi.msb)); + } + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蜑阪ｮ繧ｦ繧ｧ繧､繝 + ctrl.bus->SleepNsec(Time_phase_before); + + // 繝輔ぉ繝ｼ繧ｺ險ｭ螳 + ctrl.phase = BUS::msgout; + + // 繧ｿ繝ｼ繧ｲ繝繝医′謫堺ｽ懊☆繧倶ｿ｡蜿ｷ邱 + ctrl.bus->SetMSG(TRUE); + ctrl.bus->SetCD(TRUE); + ctrl.bus->SetIO(FALSE); + + // 繝輔ぉ繝ｼ繧ｺ繝√ぉ繝ｳ繧ｸ蠕後ｮ莠亥相譎る俣 + ctrl.bus->SleepNsec(Time_phase_after); + + // 繝繝ｼ繧ｿ霆｢騾√ｯ1繝舌う繝x1繝悶Ο繝繧ｯ + ctrl.offset = 0; + ctrl.length = 1; + ctrl.blocks = 1; + return; + } + + // 蜿嶺ｿ｡ + Receive(); +} + +//--------------------------------------------------------------------------- +// +// 蜈ｱ騾壹お繝ｩ繝ｼ蜃ｦ逅 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Error() +{ + ASSERT(this); + + // 繝舌せ諠蝣ｱ縺ｮ蜿悶ｊ霎ｼ縺ｿ + ctrl.bus->Aquire(); + + // 繝ｪ繧ｻ繝繝医メ繧ｧ繝繧ｯ + if (ctrl.bus->GetRST()) { + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧偵Μ繧ｻ繝繝 + Reset(); + + // 繝舌せ繧ゅΜ繧ｻ繝繝 + ctrl.bus->Reset(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縲√Γ繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ縺ｯ繝舌せ繝輔Μ繝ｼ + if (ctrl.phase == BUS::status || ctrl.phase == BUS::msgin) { + BusFree(); + return; + } + +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｨ繝ｩ繝ｼ(繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ)"); +#endif // DISK_LOG + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ縺ｨ繝｡繝繧ｻ繝ｼ繧ｸ繧定ｨｭ螳(CHECK CONDITION) + ctrl.status = 0x02; + ctrl.message = 0x00; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// INQUIRY +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdInquiry() +{ + Disk *disk; + int lun; + DWORD major; + DWORD minor; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "INQUIRY繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 譛牙柑縺ｪ繝ｦ繝九ャ繝医ｒ謗｢縺 + disk = NULL; + for (lun = 0; lun < UnitMax; lun++) { + if (ctrl.unit[lun]) { + disk = ctrl.unit[lun]; + break; + } + } + + // 繝繧｣繧ｹ繧ｯ蛛ｴ縺ｧ蜃ｦ逅(譛ｬ譚･縺ｯ繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ縺ｧ蜃ｦ逅縺輔ｌ繧) + if (disk) { +#ifdef RASCSI + major = (DWORD)(RASCSI >> 8); + minor = (DWORD)(RASCSI & 0xff); +#else + host->GetVM()->GetVersion(major, minor); +#endif // RASCSI + ctrl.length = ctrl.unit[lun]->Inquiry(ctrl.cmd, ctrl.buffer, major, minor); + } else { + ctrl.length = 0; + } + + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 蜷梧悄霆｢騾√し繝昴ｼ繝域ュ蝣ｱ縺ｮ霑ｽ蜉 + if (scsi.syncenable) { + ctrl.buffer[7] |= (1 << 4); + } + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdModeSelect() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "MODE SELECT繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->SelectCheck(ctrl.cmd); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// MODE SENSE +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdModeSense() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "MODE SENSE繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->ModeSense(ctrl.cmd, ctrl.buffer); + ASSERT(ctrl.length >= 0); + if (ctrl.length == 0) { + Log(Log::Warning, "繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺МODE SENSE繝壹ｼ繧ｸ $%02X", ctrl.cmd[2]); + + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// START STOP UNIT +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdStartStop() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "START STOP UNIT繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->StartStop(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// SEND DIAGNOSTIC +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdSendDiag() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "SEND DIAGNOSTIC繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->SendDiag(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// PREVENT/ALLOW MEDIUM REMOVAL +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdRemoval() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "PREVENT/ALLOW MEDIUM REMOVAL繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Removal(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// READ CAPACITY +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdReadCapacity() +{ + DWORD lun; + int length; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "READ CAPACITY繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + length = ctrl.unit[lun]->ReadCapacity(ctrl.cmd, ctrl.buffer); + ASSERT(length >= 0); + if (length <= 0) { + Error(); + return; + } + + // 繝ｬ繝ｳ繧ｰ繧ｹ險ｭ螳 + ctrl.length = length; + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// READ(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdRead10() +{ + DWORD lun; + DWORD record; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｪ繧峨Γ繝繧ｻ繝ｼ繧ｸ蜿嶺ｿ｡ + if (ctrl.unit[lun]->GetID() == MAKEID('S', 'C', 'B', 'R')) { + CmdGetMessage10(); + return; + } + + // 繝ｬ繧ｳ繝ｼ繝臥分蜿ｷ縺ｨ繝悶Ο繝繧ｯ謨ｰ繧貞叙蠕 + record = ctrl.cmd[2]; + record <<= 8; + record |= ctrl.cmd[3]; + record <<= 8; + record |= ctrl.cmd[4]; + record <<= 8; + record |= ctrl.cmd[5]; + ctrl.blocks = ctrl.cmd[7]; + ctrl.blocks <<= 8; + ctrl.blocks |= ctrl.cmd[8]; + +#if defined(DISK_LOG) + Log(Log::Normal, "READ(10)繧ｳ繝槭Φ繝 繝ｬ繧ｳ繝ｼ繝=%08X 繝悶Ο繝繧ｯ=%d", record, ctrl.blocks); +#endif // DISK_LOG + + // 繝悶Ο繝繧ｯ謨ｰ0縺ｯ蜃ｦ逅縺励↑縺 + if (ctrl.blocks == 0) { + Status(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->Read(ctrl.buffer, record); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.next = record + 1; + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// WRITE(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdWrite10() +{ + DWORD lun; + DWORD record; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｪ繧峨Γ繝繧ｻ繝ｼ繧ｸ蜿嶺ｿ｡ + if (ctrl.unit[lun]->GetID() == MAKEID('S', 'C', 'B', 'R')) { + CmdSendMessage10(); + return; + } + + // 繝ｬ繧ｳ繝ｼ繝臥分蜿ｷ縺ｨ繝悶Ο繝繧ｯ謨ｰ繧貞叙蠕 + record = ctrl.cmd[2]; + record <<= 8; + record |= ctrl.cmd[3]; + record <<= 8; + record |= ctrl.cmd[4]; + record <<= 8; + record |= ctrl.cmd[5]; + ctrl.blocks = ctrl.cmd[7]; + ctrl.blocks <<= 8; + ctrl.blocks |= ctrl.cmd[8]; + +#if defined(DISK_LOG) + Log(Log::Normal, "WRTIE(10)繧ｳ繝槭Φ繝 繝ｬ繧ｳ繝ｼ繝=%08X 繝悶Ο繝繧ｯ=%d", record, ctrl.blocks); +#endif // DISK_LOG + + // 繝悶Ο繝繧ｯ謨ｰ0縺ｯ蜃ｦ逅縺励↑縺 + if (ctrl.blocks == 0) { + Status(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->WriteCheck(record); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.next = record + 1; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// SEEK(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdSeek10() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "SEEK(10)繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Seek(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// VERIFY +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdVerify() +{ + DWORD lun; + BOOL status; + DWORD record; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝ｬ繧ｳ繝ｼ繝臥分蜿ｷ縺ｨ繝悶Ο繝繧ｯ謨ｰ繧貞叙蠕 + record = ctrl.cmd[2]; + record <<= 8; + record |= ctrl.cmd[3]; + record <<= 8; + record |= ctrl.cmd[4]; + record <<= 8; + record |= ctrl.cmd[5]; + ctrl.blocks = ctrl.cmd[7]; + ctrl.blocks <<= 8; + ctrl.blocks |= ctrl.cmd[8]; + +#if defined(DISK_LOG) + Log(Log::Normal, "VERIFY繧ｳ繝槭Φ繝 繝ｬ繧ｳ繝ｼ繝=%08X 繝悶Ο繝繧ｯ=%d", record, ctrl.blocks); +#endif // DISK_LOG + + // 繝悶Ο繝繧ｯ謨ｰ0縺ｯ蜃ｦ逅縺励↑縺 + if (ctrl.blocks == 0) { + Status(); + return; + } + + // BytChk=0縺ｪ繧 + if ((ctrl.cmd[1] & 0x02) == 0) { + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->Seek(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); + return; + } + + // 繝繧ｹ繝郁ｪｭ縺ｿ霎ｼ縺ｿ + ctrl.length = ctrl.unit[lun]->Read(ctrl.buffer, record); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.next = record + 1; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// SYNCHRONIZE CACHE +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdSynchronizeCache() +{ + DWORD lun; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 謌仙粥縺励◆縺薙→縺ｫ縺吶ｋ(譛ｪ螳溯｣) + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// READ DEFECT DATA(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdReadDefectData10() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "READ DEFECT DATA(10)繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->ReadDefectData10(ctrl.cmd, ctrl.buffer); + ASSERT(ctrl.length >= 0); + + if (ctrl.length <= 4) { + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// READ TOC +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdReadToc() +{ + DWORD lun; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->ReadToc(ctrl.cmd, ctrl.buffer); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdPlayAudio10() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->PlayAudio(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO MSF +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdPlayAudioMSF() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->PlayAudioMSF(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// PLAY AUDIO TRACK +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdPlayAudioTrack() +{ + DWORD lun; + BOOL status; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + status = ctrl.unit[lun]->PlayAudioTrack(ctrl.cmd); + if (!status) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); +} + +//--------------------------------------------------------------------------- +// +// MODE SELECT10 +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdModeSelect10() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "MODE SELECT10繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->SelectCheck10(ctrl.cmd); + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//--------------------------------------------------------------------------- +// +// MODE SENSE(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdModeSense10() +{ + DWORD lun; + + ASSERT(this); + +#if defined(DISK_LOG) + Log(Log::Normal, "MODE SENSE(10)繧ｳ繝槭Φ繝"); +#endif // DISK_LOG + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝峨Λ繧､繝悶〒繧ｳ繝槭Φ繝牙ｦ逅 + ctrl.length = ctrl.unit[lun]->ModeSense10(ctrl.cmd, ctrl.buffer); + ASSERT(ctrl.length >= 0); + if (ctrl.length == 0) { + Log(Log::Warning, "繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺МODE SENSE(10)繝壹ｼ繧ｸ $%02X", ctrl.cmd[2]); + + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// GET MESSAGE(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdGetMessage10() +{ + DWORD lun; + SCSIBR *bridge; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｧ縺ｪ縺縺ｪ繧峨お繝ｩ繝ｼ + if (ctrl.unit[lun]->GetID() != MAKEID('S', 'C', 'B', 'R')) { + Error(); + return; + } + + // 繝舌ャ繝輔ぃ縺ｮ蜀咲｢ｺ菫(繝悶Ο繝繧ｯ豈弱ｮ霆｢騾√〒縺ｯ縺ｪ縺縺溘ａ) + if (ctrl.bufsize < 0x1000000) { + delete ctrl.buffer; + ctrl.bufsize = 0x1000000; + ctrl.buffer = new BYTE[ctrl.bufsize]; + } + + // 繝峨Λ繧､繝悶〒蜃ｦ逅縺吶ｋ + bridge = (SCSIBR*)ctrl.unit[lun]; + ctrl.length = bridge->GetMessage10(ctrl.cmd, ctrl.buffer); + + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.blocks = 1; + ctrl.next = 1; + + // 繝ｪ繝ｼ繝峨ヵ繧ｧ繝ｼ繧ｺ + DataIn(); +} + +//--------------------------------------------------------------------------- +// +// SEND MESSAGE(10) +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::CmdSendMessage10() +{ + DWORD lun; + + ASSERT(this); + + // 隲也炊繝ｦ繝九ャ繝 + lun = (ctrl.cmd[1] >> 5) & 0x07; + if (!ctrl.unit[lun]) { + Error(); + return; + } + + // 繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｧ縺ｪ縺縺ｪ繧峨お繝ｩ繝ｼ + if (ctrl.unit[lun]->GetID() != MAKEID('S', 'C', 'B', 'R')) { + Error(); + return; + } + + // 繝舌ャ繝輔ぃ縺ｮ蜀咲｢ｺ菫(繝悶Ο繝繧ｯ豈弱ｮ霆｢騾√〒縺ｯ縺ｪ縺縺溘ａ) + if (ctrl.bufsize < 0x1000000) { + delete ctrl.buffer; + ctrl.bufsize = 0x1000000; + ctrl.buffer = new BYTE[ctrl.bufsize]; + } + + // 霆｢騾驥上ｒ險ｭ螳 + ctrl.length = ctrl.cmd[6]; + ctrl.length <<= 8; + ctrl.length |= ctrl.cmd[7]; + ctrl.length <<= 8; + ctrl.length |= ctrl.cmd[8]; + + if (ctrl.length <= 0) { + // 螟ｱ謨(繧ｨ繝ｩ繝ｼ) + Error(); + return; + } + + // 谺｡縺ｮ繝悶Ο繝繧ｯ繧定ｨｭ螳 + ctrl.blocks = 1; + ctrl.next = 1; + + // 繝ｩ繧､繝医ヵ繧ｧ繝ｼ繧ｺ + DataOut(); +} + +//=========================================================================== +// +// 繝繝ｼ繧ｿ霆｢騾 +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ騾∽ｿ｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Send() +{ + int len; + BOOL result; + + ASSERT(this); + ASSERT(!ctrl.bus->GetREQ()); + ASSERT(!ctrl.bus->GetACK()); + ASSERT(ctrl.bus->GetIO()); + + // 繝ｬ繝ｳ繧ｰ繧ｹ!=0縺ｪ繧蛾∽ｿ｡ + if (ctrl.length != 0) { + len = ctrl.bus->SendHandShake( + &ctrl.buffer[ctrl.offset], ctrl.length); + + // 蜈ｨ縺ｦ騾∽ｿ｡縺ｧ縺阪↑縺代ｌ縺ｰ繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (len != ctrl.length) { + Error(); + return; + } + + // 繧ｪ繝輔そ繝繝医→繝ｬ繝ｳ繧ｰ繧ｹ + ctrl.offset += ctrl.length; + ctrl.length = 0; + return; + } + + // 繝悶Ο繝繧ｯ貂帷ｮ励√Μ繧ｶ繝ｫ繝亥晄悄蛹 + ctrl.blocks--; + result = TRUE; + + // 繝繝ｼ繧ｿ蠑輔″蜿悶ｊ蠕後ｮ蜃ｦ逅(繝ｪ繝ｼ繝/繝繝ｼ繧ｿ繧､繝ｳ縺ｮ縺ｿ) + if (ctrl.phase == BUS::datain) { + if (ctrl.blocks != 0) { + // 谺｡縺ｮ繝舌ャ繝輔ぃ繧定ｨｭ螳(offset, length繧偵そ繝繝医☆繧九％縺ｨ) + result = XferIn(ctrl.buffer); + } + } + + // 繝ｪ繧ｶ繝ｫ繝FALSE縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (!result) { + Error(); + return; + } + + // 繝悶Ο繝繧ｯ!=0縺ｪ繧蛾∽ｿ｡邯咏ｶ + if (ctrl.blocks != 0){ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.offset == 0); + return; + } + + // 谺｡繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ蜍 + switch (ctrl.phase) { + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + case BUS::msgin: + // IDENTIFY繝｡繝繧ｻ繝ｼ繧ｸ縺ｮ諡｡蠑ｵ繝｡繝繧ｻ繝ｼ繧ｸ縺ｫ蟇ｾ縺吶ｋ蠢懃ｭ秘∽ｿ｡螳御ｺ + if (scsi.atnmsg) { + // 繝輔Λ繧ｰ繧ｪ繝 + scsi.atnmsg = FALSE; + + // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + Command(); + } else { + // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + BusFree(); + } + break; + + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + case BUS::datain: + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); + break; + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + case BUS::status: + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + ctrl.length = 1; + ctrl.blocks = 1; + ctrl.buffer[0] = ctrl.message; + MsgIn(); + break; + + // 縺昴ｮ莉(縺ゅｊ縺医↑縺) + default: + ASSERT(FALSE); + break; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ蜿嶺ｿ｡ +// +//--------------------------------------------------------------------------- +void FASTCALL SCSIDEV::Receive() +{ + BYTE data; + BOOL result; + int i; + int len; + + ASSERT(this); + + // REQ,ACK縺御ｸ九′縺｣縺ｦ縺繧九％縺ｨ + ASSERT(!ctrl.bus->GetREQ()); + ASSERT(!ctrl.bus->GetACK()); + ASSERT(!ctrl.bus->GetIO()); + + // 繝ｬ繝ｳ繧ｰ繧ｹ!=0縺ｪ繧牙女菫｡ + if (ctrl.length != 0) { + // 蜿嶺ｿ｡ + len = ctrl.bus->ReceiveHandShake( + &ctrl.buffer[ctrl.offset], ctrl.length); + + // 蜈ｨ縺ｦ蜿嶺ｿ｡縺ｧ縺阪↑縺代ｌ縺ｰ繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (len != ctrl.length) { + Error(); + return; + } + + // 繧ｪ繝輔そ繝繝医→繝ｬ繝ｳ繧ｰ繧ｹ + ctrl.offset += ctrl.length; + ctrl.length = 0;; + return; + } + + // 繝悶Ο繝繧ｯ貂帷ｮ励√Μ繧ｶ繝ｫ繝亥晄悄蛹 + ctrl.blocks--; + result = TRUE; + + // 繝繝ｼ繧ｿ蜿礼炊蠕後ｮ蜃ｦ逅(繝輔ぉ繝ｼ繧ｺ蛻･) + switch (ctrl.phase) { + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + case BUS::dataout: + if (ctrl.blocks == 0) { + // 縺薙ｮ繝舌ャ繝輔ぃ縺ｧ邨ゆｺ + result = XferOut(FALSE); + } else { + // 谺｡縺ｮ繝舌ャ繝輔ぃ縺ｫ邯壹￥(offset, length繧偵そ繝繝医☆繧九％縺ｨ) + result = XferOut(TRUE); + } + break; + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + case BUS::msgout: + ctrl.message = ctrl.buffer[0]; + if (!XferMsg(ctrl.message)) { + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医↓螟ｱ謨励＠縺溘ｉ縲∝叉蠎ｧ縺ｫ繝舌せ繝輔Μ繝ｼ + BusFree(); + return; + } + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ縺ｫ蛯吶∴縲√Γ繝繧ｻ繝ｼ繧ｸ繝繝ｼ繧ｿ繧偵け繝ｪ繧｢縺励※縺翫￥ + ctrl.message = 0x00; + break; + + default: + break; + } + + // 繝ｪ繧ｶ繝ｫ繝FALSE縺ｪ繧峨√せ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ縺ｸ遘ｻ陦 + if (!result) { + Error(); + return; + } + + // 繝悶Ο繝繧ｯ!=0縺ｪ繧牙女菫｡邯咏ｶ + if (ctrl.blocks != 0){ + ASSERT(ctrl.length > 0); + ASSERT(ctrl.offset == 0); + return; + } + + // 谺｡繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ蜍 + switch (ctrl.phase) { + // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + case BUS::command: + // 繧ｳ繝槭Φ繝峨ョ繝ｼ繧ｿ霆｢騾 + len = 6; + if (ctrl.buffer[0] >= 0x20 && ctrl.buffer[0] <= 0x7D) { + // 10繝舌う繝CDB + len = 10; + } + for (i = 0; i < len; i++) { + ctrl.cmd[i] = (DWORD)ctrl.buffer[i]; +#if defined(DISK_LOG) + Log(Log::Normal, "繧ｳ繝槭Φ繝 $%02X", ctrl.cmd[i]); +#endif // DISK_LOG + } + + // 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ + Execute(); + break; + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + case BUS::msgout: + // ATN縺後い繧ｵ繝ｼ繝医＠邯壹¢繧矩剞繧翫Γ繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ繧堤ｶ咏ｶ + if (ctrl.bus->GetATN()) { + // 繝繝ｼ繧ｿ霆｢騾√ｯ1繝舌う繝x1繝悶Ο繝繧ｯ + ctrl.offset = 0; + ctrl.length = 1; + ctrl.blocks = 1; + return; + } + + // ATN縺ｧ騾∽ｿ｡縺輔ｌ縺溘Γ繝繧ｻ繝ｼ繧ｸ縺ｮ隗｣譫 + if (scsi.atnmsg) { + i = 0; + while (i < scsi.msc) { + // 繝｡繝繧ｻ繝ｼ繧ｸ縺ｮ遞ｮ鬘 + data = scsi.msb[i]; + + // ABORT + if (data == 0x06) { +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧ｳ繝ｼ繝 ABORT $%02X", data); +#endif // DISK_LOG + BusFree(); + return; + } + + // BUS DEVICE RESET + if (data == 0x0C) { +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧ｳ繝ｼ繝 BUS DEVICE RESET $%02X", data); +#endif // DISK_LOG + scsi.syncoffset = 0; + BusFree(); + return; + } + + // IDENTIFY + if (data >= 0x80) { +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧ｳ繝ｼ繝 IDENTIFY $%02X", data); +#endif // DISK_LOG + } + + // 諡｡蠑ｵ繝｡繝繧ｻ繝ｼ繧ｸ + if (data == 0x01) { +#if defined(DISK_LOG) + Log(Log::Normal, "繝｡繝繧ｻ繝ｼ繧ｸ繧ｳ繝ｼ繝 EXTENDED MESSAGE $%02X", data); +#endif // DISK_LOG + + // 蜷梧悄霆｢騾√′蜿ｯ閭ｽ縺ｪ譎ゅ□縺代メ繧ｧ繝繧ｯ + if (!scsi.syncenable || scsi.msb[i + 2] != 0x01) { + ctrl.length = 1; + ctrl.blocks = 1; + ctrl.buffer[0] = 0x07; + MsgIn(); + return; + } + + // Transfer period factor(50 x 4 = 200ns縺ｫ蛻ｶ髯) + scsi.syncperiod = scsi.msb[i + 3]; + if (scsi.syncperiod > 50) { + scsi.syncoffset = 50; + } + + // REQ/ACK offset(16縺ｫ蛻ｶ髯) + scsi.syncoffset = scsi.msb[i + 4]; + if (scsi.syncoffset > 16) { + scsi.syncoffset = 16; + } + + // STDR蠢懃ｭ斐Γ繝繧ｻ繝ｼ繧ｸ逕滓 + ctrl.length = 5; + ctrl.blocks = 1; + ctrl.buffer[0] = 0x01; + ctrl.buffer[1] = 0x03; + ctrl.buffer[2] = 0x01; + ctrl.buffer[3] = scsi.syncperiod; + ctrl.buffer[4] = scsi.syncoffset; + MsgIn(); + return; + } + + // 谺｡縺ｸ + i++; + } + } + + // ATN繝｡繝繧ｻ繝ｼ繧ｸ蜿嶺ｿ｡繧ｹ繧ｿ繝ｼ繧ｿ繧ｹ蛻晄悄蛹 + scsi.atnmsg = FALSE; + + // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + Command(); + break; + + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + case BUS::dataout: + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + Status(); + break; + + // 縺昴ｮ莉(縺ゅｊ縺医↑縺) + default: + ASSERT(FALSE); + break; + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ霆｢騾｀SG +// +//--------------------------------------------------------------------------- +BOOL FASTCALL SCSIDEV::XferMsg(DWORD msg) +{ + ASSERT(this); + ASSERT(ctrl.phase == BUS::msgout); + + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ョ繝ｼ繧ｿ縺ｮ菫晏ｭ + if (scsi.atnmsg) { + scsi.msb[scsi.msc] = msg; + scsi.msc++; + scsi.msc %= 256; + } + + return TRUE; +} diff --git a/src/raspberrypi/disk.h b/src/raspberrypi/disk.h new file mode 100644 index 00000000..0d440890 --- /dev/null +++ b/src/raspberrypi/disk.h @@ -0,0 +1,1108 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2014-2018 GIMONS +// +// XM6i +// Copyright (C) 2010-2015 isaki@NetBSD.org +// +// Imported sava's Anex86/T98Next image and MO format support patch. +// +// [ 繝繧｣繧ｹ繧ｯ ] +// +//--------------------------------------------------------------------------- + +#if !defined(disk_h) +#define disk_h + +#include "log.h" +#include "scsi.h" + +//--------------------------------------------------------------------------- +// +// 繧ｨ繝ｩ繝ｼ螳夂ｾｩ(REQUEST SENSE縺ｧ霑斐＆繧後ｋ繧ｻ繝ｳ繧ｹ繧ｳ繝ｼ繝) +// +// MSB 莠育ｴ(0x00) +// 繧ｻ繝ｳ繧ｹ繧ｭ繝ｼ +// 諡｡蠑ｵ繧ｻ繝ｳ繧ｹ繧ｳ繝ｼ繝(ASC) +// LSB 諡｡蠑ｵ繧ｻ繝ｳ繧ｹ繧ｳ繝ｼ繝峨け繧ｩ繝ｪ繝輔ぃ繧､繧｢(ASCQ) +// +//--------------------------------------------------------------------------- +#define DISK_NOERROR 0x00000000 // NO ADDITIONAL SENSE INFO. +#define DISK_DEVRESET 0x00062900 // POWER ON OR RESET OCCURED +#define DISK_NOTREADY 0x00023a00 // MEDIUM NOT PRESENT +#define DISK_ATTENTION 0x00062800 // MEDIUM MAY HAVE CHANGED +#define DISK_PREVENT 0x00045302 // MEDIUM REMOVAL PREVENTED +#define DISK_READFAULT 0x00031100 // UNRECOVERED READ ERROR +#define DISK_WRITEFAULT 0x00030300 // PERIPHERAL DEVICE WRITE FAULT +#define DISK_WRITEPROTECT 0x00042700 // WRITE PROTECTED +#define DISK_MISCOMPARE 0x000e1d00 // MISCOMPARE DURING VERIFY +#define DISK_INVALIDCMD 0x00052000 // INVALID COMMAND OPERATION CODE +#define DISK_INVALIDLBA 0x00052100 // LOGICAL BLOCK ADDR. OUT OF RANGE +#define DISK_INVALIDCDB 0x00052400 // INVALID FIELD IN CDB +#define DISK_INVALIDLUN 0x00052500 // LOGICAL UNIT NOT SUPPORTED +#define DISK_INVALIDPRM 0x00052600 // INVALID FIELD IN PARAMETER LIST +#define DISK_INVALIDMSG 0x00054900 // INVALID MESSAGE ERROR +#define DISK_PARAMLEN 0x00051a00 // PARAMETERS LIST LENGTH ERROR +#define DISK_PARAMNOT 0x00052601 // PARAMETERS NOT SUPPORTED +#define DISK_PARAMVALUE 0x00052602 // PARAMETERS VALUE INVALID +#define DISK_PARAMSAVE 0x00053900 // SAVING PARAMETERS NOT SUPPORTED +#define DISK_NODEFECT 0x00010000 // DEFECT LIST NOT FOUND + +#if 0 +#define DISK_AUDIOPROGRESS 0x00??0011 // AUDIO PLAY IN PROGRESS +#define DISK_AUDIOPAUSED 0x00??0012 // AUDIO PLAY PAUSED +#define DISK_AUDIOSTOPPED 0x00??0014 // AUDIO PLAY STOPPED DUE TO ERROR +#define DISK_AUDIOCOMPLETE 0x00??0013 // AUDIO PLAY SUCCESSFULLY COMPLETED +#endif + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ繝医Λ繝繧ｯ +// +//=========================================================================== +class DiskTrack +{ +public: + // 蜀驛ｨ繝繝ｼ繧ｿ螳夂ｾｩ + typedef struct { + int track; // 繝医Λ繝繧ｯ繝翫Φ繝舌ｼ + int size; // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ(8 or 9) + int sectors; // 繧ｻ繧ｯ繧ｿ謨ｰ(<=0x100) + DWORD length; // 繝繝ｼ繧ｿ繝舌ャ繝輔ぃ髟ｷ + BYTE *buffer; // 繝繝ｼ繧ｿ繝舌ャ繝輔ぃ + BOOL init; // 繝ｭ繝ｼ繝画ｸ医∩縺 + BOOL changed; // 螟画峩貂医∩繝輔Λ繧ｰ + DWORD maplen; // 螟画峩貂医∩繝槭ャ繝鈴聞 + BOOL *changemap; // 螟画峩貂医∩繝槭ャ繝 + BOOL raw; // RAW繝｢繝ｼ繝 + off64_t imgoffset; // 螳溘ョ繝ｼ繧ｿ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝 + } disktrk_t; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + DiskTrack(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~DiskTrack(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + void FASTCALL Init(int track, int size, int sectors, BOOL raw = FALSE, + off64_t imgoff = 0); + // 蛻晄悄蛹 + BOOL FASTCALL Load(const Filepath& path); + // 繝ｭ繝ｼ繝 + BOOL FASTCALL Save(const Filepath& path); + // 繧ｻ繝ｼ繝 + + // 繝ｪ繝ｼ繝峨ｻ繝ｩ繧､繝 + BOOL FASTCALL Read(BYTE *buf, int sec) const; + // 繧ｻ繧ｯ繧ｿ繝ｪ繝ｼ繝 + BOOL FASTCALL Write(const BYTE *buf, int sec); + // 繧ｻ繧ｯ繧ｿ繝ｩ繧､繝 + + // 縺昴ｮ莉 + int FASTCALL GetTrack() const { return dt.track; } + // 繝医Λ繝繧ｯ蜿門ｾ + BOOL FASTCALL IsChanged() const { return dt.changed; } + // 螟画峩繝輔Λ繧ｰ繝√ぉ繝繧ｯ + +private: + // 蜀驛ｨ繝繝ｼ繧ｿ + disktrk_t dt; + // 蜀驛ｨ繝繝ｼ繧ｿ +}; + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･ +// +//=========================================================================== +class DiskCache +{ +public: + // 蜀驛ｨ繝繝ｼ繧ｿ螳夂ｾｩ + typedef struct { + DiskTrack *disktrk; // 蜑ｲ繧雁ｽ薙※繝医Λ繝繧ｯ + DWORD serial; // 譛邨ゅす繝ｪ繧｢繝ｫ + } cache_t; + + // 繧ｭ繝｣繝繧ｷ繝･謨ｰ + enum { + CacheMax = 16 // 繧ｭ繝｣繝繧ｷ繝･縺吶ｋ繝医Λ繝繧ｯ謨ｰ + }; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + DiskCache(const Filepath& path, int size, int blocks, + off64_t imgoff = 0); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~DiskCache(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + void FASTCALL SetRawMode(BOOL raw); + // CD-ROM raw繝｢繝ｼ繝芽ｨｭ螳 + + // 繧｢繧ｯ繧ｻ繧ｹ + BOOL FASTCALL Save(); + // 蜈ｨ繧ｻ繝ｼ繝厄ｼ隗｣謾ｾ + BOOL FASTCALL Read(BYTE *buf, int block); + // 繧ｻ繧ｯ繧ｿ繝ｪ繝ｼ繝 + BOOL FASTCALL Write(const BYTE *buf, int block); + // 繧ｻ繧ｯ繧ｿ繝ｩ繧､繝 + BOOL FASTCALL GetCache(int index, int& track, DWORD& serial) const; + // 繧ｭ繝｣繝繧ｷ繝･諠蝣ｱ蜿門ｾ + +private: + // 蜀驛ｨ邂｡逅 + void FASTCALL Clear(); + // 繝医Λ繝繧ｯ繧偵☆縺ｹ縺ｦ繧ｯ繝ｪ繧｢ + DiskTrack* FASTCALL Assign(int track); + // 繝医Λ繝繧ｯ縺ｮ繝ｭ繝ｼ繝 + BOOL FASTCALL Load(int index, int track, DiskTrack *disktrk = NULL); + // 繝医Λ繝繧ｯ縺ｮ繝ｭ繝ｼ繝 + void FASTCALL Update(); + // 繧ｷ繝ｪ繧｢繝ｫ逡ｪ蜿ｷ譖ｴ譁ｰ + + // 蜀驛ｨ繝繝ｼ繧ｿ + cache_t cache[CacheMax]; + // 繧ｭ繝｣繝繧ｷ繝･邂｡逅 + DWORD serial; + // 譛邨ゅい繧ｯ繧ｻ繧ｹ繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝 + Filepath sec_path; + // 繝代せ + int sec_size; + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ(8 or 9 or 11) + int sec_blocks; + // 繧ｻ繧ｯ繧ｿ繝悶Ο繝繧ｯ謨ｰ + BOOL cd_raw; + // CD-ROM RAW繝｢繝ｼ繝 + off64_t imgoffset; + // 螳溘ョ繝ｼ繧ｿ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝 +}; + +//=========================================================================== +// +// 繝繧｣繧ｹ繧ｯ +// +//=========================================================================== +class Disk +{ +public: + // 蜀驛ｨ繝ｯ繝ｼ繧ｯ + typedef struct { + DWORD id; // 繝｡繝繧｣繧｢ID + BOOL ready; // 譛牙柑縺ｪ繝繧｣繧ｹ繧ｯ + BOOL writep; // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢ + BOOL readonly; // 隱ｭ縺ｿ霎ｼ縺ｿ蟆ら畑 + BOOL removable; // 蜿悶ｊ螟悶＠ + BOOL lock; // 繝ｭ繝繧ｯ + BOOL attn; // 繧｢繝繝ｳ繧ｷ繝ｧ繝ｳ + BOOL reset; // 繝ｪ繧ｻ繝繝 + int size; // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ + DWORD blocks; // 邱上そ繧ｯ繧ｿ謨ｰ + DWORD lun; // LUN + DWORD code; // 繧ｹ繝繝ｼ繧ｿ繧ｹ繧ｳ繝ｼ繝 + DiskCache *dcache; // 繝繧｣繧ｹ繧ｯ繧ｭ繝｣繝繧ｷ繝･ + off64_t imgoffset; // 螳溘ョ繝ｼ繧ｿ縺ｾ縺ｧ縺ｮ繧ｪ繝輔そ繝繝 + } disk_t; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + Disk(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~Disk(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + virtual void FASTCALL Reset(); + // 繝繝舌う繧ｹ繝ｪ繧ｻ繝繝 +#ifndef RASCSI + virtual BOOL FASTCALL Save(Fileio *fio, int ver); + // 繧ｻ繝ｼ繝 + virtual BOOL FASTCALL Load(Fileio *fio, int ver); + // 繝ｭ繝ｼ繝 +#endif // RASCSI + + // ID + DWORD FASTCALL GetID() const { return disk.id; } + // 繝｡繝繧｣繧｢ID蜿門ｾ + BOOL FASTCALL IsNULL() const; + // NULL繝√ぉ繝繧ｯ + BOOL FASTCALL IsSASI() const; + // SASI繝√ぉ繝繧ｯ + + // 繝｡繝繧｣繧｢謫堺ｽ + virtual BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ + void FASTCALL GetPath(Filepath& path) const; + // 繝代せ蜿門ｾ + void FASTCALL Eject(BOOL force); + // 繧､繧ｸ繧ｧ繧ｯ繝 + BOOL FASTCALL IsReady() const { return disk.ready; } + // Ready繝√ぉ繝繧ｯ + void FASTCALL WriteP(BOOL flag); + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢ + BOOL FASTCALL IsWriteP() const { return disk.writep; } + // 譖ｸ縺崎ｾｼ縺ｿ遖∵ｭ｢繝√ぉ繝繧ｯ + BOOL FASTCALL IsReadOnly() const { return disk.readonly; } + // Read Only繝√ぉ繝繧ｯ + BOOL FASTCALL IsRemovable() const { return disk.removable; } + // 繝ｪ繝繝ｼ繝舌ヶ繝ｫ繝√ぉ繝繧ｯ + BOOL FASTCALL IsLocked() const { return disk.lock; } + // 繝ｭ繝繧ｯ繝√ぉ繝繧ｯ + BOOL FASTCALL IsAttn() const { return disk.attn; } + // 莠､謠帙メ繧ｧ繝繧ｯ + BOOL FASTCALL Flush(); + // 繧ｭ繝｣繝繧ｷ繝･繝輔Λ繝繧ｷ繝･ + void FASTCALL GetDisk(disk_t *buffer) const; + // 蜀驛ｨ繝ｯ繝ｼ繧ｯ蜿門ｾ + + // 繝励Ο繝代ユ繧｣ + void FASTCALL SetLUN(DWORD lun) { disk.lun = lun; } + // LUN繧ｻ繝繝 + DWORD FASTCALL GetLUN() { return disk.lun; } + // LUN蜿門ｾ + // 繧ｳ繝槭Φ繝 + virtual int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + virtual int FASTCALL RequestSense(const DWORD *cdb, BYTE *buf); + // REQUEST SENSE繧ｳ繝槭Φ繝 + int FASTCALL SelectCheck(const DWORD *cdb); + // SELECT繝√ぉ繝繧ｯ + int FASTCALL SelectCheck10(const DWORD *cdb); + // SELECT(10)繝√ぉ繝繧ｯ + virtual BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); + // MODE SELECT繧ｳ繝槭Φ繝 + virtual int FASTCALL ModeSense(const DWORD *cdb, BYTE *buf); + // MODE SENSE繧ｳ繝槭Φ繝 + virtual int FASTCALL ModeSense10(const DWORD *cdb, BYTE *buf); + // MODE SENSE(10)繧ｳ繝槭Φ繝 + int FASTCALL ReadDefectData10(const DWORD *cdb, BYTE *buf); + // READ DEFECT DATA(10)繧ｳ繝槭Φ繝 + virtual BOOL FASTCALL TestUnitReady(const DWORD *cdb); + // TEST UNIT READY繧ｳ繝槭Φ繝 + BOOL FASTCALL Rezero(const DWORD *cdb); + // REZERO繧ｳ繝槭Φ繝 + BOOL FASTCALL Format(const DWORD *cdb); + // FORMAT UNIT繧ｳ繝槭Φ繝 + BOOL FASTCALL Reassign(const DWORD *cdb); + // REASSIGN UNIT繧ｳ繝槭Φ繝 + virtual int FASTCALL Read(BYTE *buf, DWORD block); + // READ繧ｳ繝槭Φ繝 + int FASTCALL WriteCheck(DWORD block); + // WRITE繝√ぉ繝繧ｯ + BOOL FASTCALL Write(const BYTE *buf, DWORD block); + // WRITE繧ｳ繝槭Φ繝 + BOOL FASTCALL Seek(const DWORD *cdb); + // SEEK繧ｳ繝槭Φ繝 + BOOL FASTCALL Assign(const DWORD *cdb); + // ASSIGN繧ｳ繝槭Φ繝 + BOOL FASTCALL Specify(const DWORD *cdb); + // SPECIFY繧ｳ繝槭Φ繝 + BOOL FASTCALL StartStop(const DWORD *cdb); + // START STOP UNIT繧ｳ繝槭Φ繝 + BOOL FASTCALL SendDiag(const DWORD *cdb); + // SEND DIAGNOSTIC繧ｳ繝槭Φ繝 + BOOL FASTCALL Removal(const DWORD *cdb); + // PREVENT/ALLOW MEDIUM REMOVAL繧ｳ繝槭Φ繝 + int FASTCALL ReadCapacity(const DWORD *cdb, BYTE *buf); + // READ CAPACITY繧ｳ繝槭Φ繝 + BOOL FASTCALL Verify(const DWORD *cdb); + // VERIFY繧ｳ繝槭Φ繝 + virtual int FASTCALL ReadToc(const DWORD *cdb, BYTE *buf); + // READ TOC繧ｳ繝槭Φ繝 + virtual BOOL FASTCALL PlayAudio(const DWORD *cdb); + // PLAY AUDIO繧ｳ繝槭Φ繝 + virtual BOOL FASTCALL PlayAudioMSF(const DWORD *cdb); + // PLAY AUDIO MSF繧ｳ繝槭Φ繝 + virtual BOOL FASTCALL PlayAudioTrack(const DWORD *cdb); + // PLAY AUDIO TRACK繧ｳ繝槭Φ繝 + void FASTCALL InvalidCmd() { disk.code = DISK_INVALIDCMD; } + // 繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繧ｳ繝槭Φ繝 + + // 縺昴ｮ莉 + void SetCacheWB(BOOL enable) { cache_wb = enable; } + // 繧ｭ繝｣繝繧ｷ繝･繝｢繝ｼ繝芽ｨｭ螳 + +protected: + // 繧ｵ繝門ｦ逅 + virtual int FASTCALL AddError(BOOL change, BYTE *buf); + // 繧ｨ繝ｩ繝ｼ繝壹ｼ繧ｸ霑ｽ蜉 + virtual int FASTCALL AddFormat(BOOL change, BYTE *buf); + // 繝輔か繝ｼ繝槭ャ繝医壹ｼ繧ｸ霑ｽ蜉 + virtual int FASTCALL AddDrive(BOOL change, BYTE *buf); + // 繝峨Λ繧､繝悶壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddOpt(BOOL change, BYTE *buf); + // 繧ｪ繝励ユ繧｣繧ｫ繝ｫ繝壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddCache(BOOL change, BYTE *buf); + // 繧ｭ繝｣繝繧ｷ繝･繝壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddCDROM(BOOL change, BYTE *buf); + // CD-ROM繝壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddCDDA(BOOL change, BYTE *buf); + // CD-DA繝壹ｼ繧ｸ霑ｽ蜉 + virtual int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); + // 繝吶Φ繝迚ｹ谿翫壹ｼ繧ｸ霑ｽ蜉 + BOOL FASTCALL CheckReady(); + // 繝ｬ繝繧｣繝√ぉ繝繧ｯ + + // 蜀驛ｨ繝繝ｼ繧ｿ + disk_t disk; + // 繝繧｣繧ｹ繧ｯ蜀驛ｨ繝繝ｼ繧ｿ + Filepath diskpath; + // 繝代せ(GetPath逕ｨ) + BOOL cache_wb; + // 繧ｭ繝｣繝繧ｷ繝･繝｢繝ｼ繝 +}; + +//=========================================================================== +// +// SASI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== +class SASIHD : public Disk +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SASIHD(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + void FASTCALL Reset(); + // 繝ｪ繧ｻ繝繝 + BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ + // 繧ｳ繝槭Φ繝 + int FASTCALL RequestSense(const DWORD *cdb, BYTE *buf); + // REQUEST SENSE繧ｳ繝槭Φ繝 +}; + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== +class SCSIHD : public Disk +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSIHD(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + void FASTCALL Reset(); + // 繝ｪ繧ｻ繝繝 + BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ + + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); + // MODE SELECT(6)繧ｳ繝槭Φ繝 +}; + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ(PC-9801-55 NEC邏疲ｭ｣/Anex86/T98Next) +// +//=========================================================================== +class SCSIHD_NEC : public SCSIHD +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSIHD_NEC(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + + BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ + + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + + // 繧ｵ繝門ｦ逅 + int FASTCALL AddError(BOOL change, BYTE *buf); + // 繧ｨ繝ｩ繝ｼ繝壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddFormat(BOOL change, BYTE *buf); + // 繝輔か繝ｼ繝槭ャ繝医壹ｼ繧ｸ霑ｽ蜉 + int FASTCALL AddDrive(BOOL change, BYTE *buf); + // 繝峨Λ繧､繝悶壹ｼ繧ｸ霑ｽ蜉 + +private: + int cylinders; + // 繧ｷ繝ｪ繝ｳ繝謨ｰ + int heads; + // 繝倥ャ繝画焚 + int sectors; + // 繧ｻ繧ｯ繧ｿ謨ｰ + int sectorsize; + // 繧ｻ繧ｯ繧ｿ繧ｵ繧､繧ｺ + off64_t imgoffset; + // 繧､繝｡繝ｼ繧ｸ繧ｪ繝輔そ繝繝 + off64_t imgsize; + // 繧､繝｡繝ｼ繧ｸ繧ｵ繧､繧ｺ +}; + +//=========================================================================== +// +// SCSI 繝上ｼ繝峨ョ繧｣繧ｹ繧ｯ(Macintosh Apple邏疲ｭ｣) +// +//=========================================================================== +class SCSIHD_APPLE : public SCSIHD +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSIHD_APPLE(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry( + const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + + // 繧ｵ繝門ｦ逅 + int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); + // 繝吶Φ繝迚ｹ谿翫壹ｼ繧ｸ霑ｽ蜉 +}; + +//=========================================================================== +// +// SCSI 蜈臥｣∵ｰ励ョ繧｣繧ｹ繧ｯ +// +//=========================================================================== +class SCSIMO : public Disk +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSIMO(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ +#ifndef RASCSI + BOOL FASTCALL Load(Fileio *fio, int ver); + // 繝ｭ繝ｼ繝 +#endif // RASCSI + + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); + // MODE SELECT(6)繧ｳ繝槭Φ繝 + + // 繧ｵ繝門ｦ逅 + int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); + // 繝吶Φ繝迚ｹ谿翫壹ｼ繧ｸ霑ｽ蜉 +}; + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｩ繧ｹ蜈郁｡悟ｮ夂ｾｩ +// +//--------------------------------------------------------------------------- +class SCSICD; + +//=========================================================================== +// +// CD-ROM 繝医Λ繝繧ｯ +// +//=========================================================================== +class CDTrack +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CDTrack(SCSICD *scsicd); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~CDTrack(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Init(int track, DWORD first, DWORD last); + // 蛻晄悄蛹 + + // 繝励Ο繝代ユ繧｣ + void FASTCALL SetPath(BOOL cdda, const Filepath& path); + // 繝代せ險ｭ螳 + void FASTCALL GetPath(Filepath& path) const; + // 繝代せ蜿門ｾ + void FASTCALL AddIndex(int index, DWORD lba); + // 繧､繝ｳ繝繝繧ｯ繧ｹ霑ｽ蜉 + DWORD FASTCALL GetFirst() const; + // 髢句ｧ記BA蜿門ｾ + DWORD FASTCALL GetLast() const; + // 邨らｫｯLBA蜿門ｾ + DWORD FASTCALL GetBlocks() const; + // 繝悶Ο繝繧ｯ謨ｰ蜿門ｾ + int FASTCALL GetTrackNo() const; + // 繝医Λ繝繧ｯ逡ｪ蜿ｷ蜿門ｾ + BOOL FASTCALL IsValid(DWORD lba) const; + // 譛牙柑縺ｪLBA縺 + BOOL FASTCALL IsAudio() const; + // 繧ｪ繝ｼ繝繧｣繧ｪ繝医Λ繝繧ｯ縺 + +private: + SCSICD *cdrom; + // 隕ｪ繝繝舌う繧ｹ + BOOL valid; + // 譛牙柑縺ｪ繝医Λ繝繧ｯ + int track_no; + // 繝医Λ繝繧ｯ逡ｪ蜿ｷ + DWORD first_lba; + // 髢句ｧ記BA + DWORD last_lba; + // 邨ゆｺLBA + BOOL audio; + // 繧ｪ繝ｼ繝繧｣繧ｪ繝医Λ繝繧ｯ繝輔Λ繧ｰ + BOOL raw; + // RAW繝繝ｼ繧ｿ繝輔Λ繧ｰ + Filepath imgpath; + // 繧､繝｡繝ｼ繧ｸ繝輔ぃ繧､繝ｫ繝代せ +}; + +//=========================================================================== +// +// CD-DA 繝舌ャ繝輔ぃ +// +//=========================================================================== +class CDDABuf +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + CDDABuf(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~CDDABuf(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ +#if 0 + BOOL Init(); + // 蛻晄悄蛹 + BOOL FASTCALL Load(const Filepath& path); + // 繝ｭ繝ｼ繝 + BOOL FASTCALL Save(const Filepath& path); + // 繧ｻ繝ｼ繝 + + // API + void FASTCALL Clear(); + // 繝舌ャ繝輔ぃ繧ｯ繝ｪ繧｢ + BOOL FASTCALL Open(Filepath& path); + // 繝輔ぃ繧､繝ｫ謖螳 + BOOL FASTCALL GetBuf(DWORD *buffer, int frames); + // 繝舌ャ繝輔ぃ蜿門ｾ + BOOL FASTCALL IsValid(); + // 譛牙柑繝√ぉ繝繧ｯ + BOOL FASTCALL ReadReq(); + // 隱ｭ縺ｿ霎ｼ縺ｿ隕∵ｱ + BOOL FASTCALL IsEnd() const; + // 邨ゆｺ繝√ぉ繝繧ｯ + +private: + Filepath wavepath; + // Wave繝代せ + BOOL valid; + // 繧ｪ繝ｼ繝励Φ邨先棡 + DWORD *buf; + // 繝繝ｼ繧ｿ繝舌ャ繝輔ぃ + DWORD read; + // Read繝昴う繝ｳ繧ｿ + DWORD write; + // Write繝昴う繝ｳ繧ｿ + DWORD num; + // 繝繝ｼ繧ｿ譛牙柑謨ｰ + DWORD rest; + // 繝輔ぃ繧､繝ｫ谿九ｊ繧ｵ繧､繧ｺ +#endif +}; + +//=========================================================================== +// +// SCSI CD-ROM +// +//=========================================================================== +class SCSICD : public Disk +{ +public: + // 繝医Λ繝繧ｯ謨ｰ + enum { + TrackMax = 96 // 繝医Λ繝繧ｯ譛螟ｧ謨ｰ + }; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSICD(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~SCSICD(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); + // 繧ｪ繝ｼ繝励Φ +#ifndef RASCSI + BOOL FASTCALL Load(Fileio *fio, int ver); + // 繝ｭ繝ｼ繝 +#endif // RASCSI + + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + int FASTCALL Read(BYTE *buf, DWORD block); + // READ繧ｳ繝槭Φ繝 + int FASTCALL ReadToc(const DWORD *cdb, BYTE *buf); + // READ TOC繧ｳ繝槭Φ繝 + BOOL FASTCALL PlayAudio(const DWORD *cdb); + // PLAY AUDIO繧ｳ繝槭Φ繝 + BOOL FASTCALL PlayAudioMSF(const DWORD *cdb); + // PLAY AUDIO MSF繧ｳ繝槭Φ繝 + BOOL FASTCALL PlayAudioTrack(const DWORD *cdb); + // PLAY AUDIO TRACK繧ｳ繝槭Φ繝 + + // CD-DA + BOOL FASTCALL NextFrame(); + // 繝輔Ξ繝ｼ繝騾夂衍 + void FASTCALL GetBuf(DWORD *buffer, int samples, DWORD rate); + // CD-DA繝舌ャ繝輔ぃ蜿門ｾ + + // LBA-MSF螟画鋤 + void FASTCALL LBAtoMSF(DWORD lba, BYTE *msf) const; + // LBA竊樽SF螟画鋤 + DWORD FASTCALL MSFtoLBA(const BYTE *msf) const; + // MSF竊鱈BA螟画鋤 + +private: + // 繧ｪ繝ｼ繝励Φ + BOOL FASTCALL OpenCue(const Filepath& path); + // 繧ｪ繝ｼ繝励Φ(CUE) + BOOL FASTCALL OpenIso(const Filepath& path); + // 繧ｪ繝ｼ繝励Φ(ISO) + BOOL FASTCALL OpenPhysical(const Filepath& path); + // 繧ｪ繝ｼ繝励Φ(Physical) + BOOL rawfile; + // RAW繝輔Λ繧ｰ + + // 繝医Λ繝繧ｯ邂｡逅 + void FASTCALL ClearTrack(); + // 繝医Λ繝繧ｯ繧ｯ繝ｪ繧｢ + int FASTCALL SearchTrack(DWORD lba) const; + // 繝医Λ繝繧ｯ讀懃ｴ｢ + CDTrack* track[TrackMax]; + // 繝医Λ繝繧ｯ繧ｪ繝悶ず繧ｧ繧ｯ繝 + int tracks; + // 繝医Λ繝繧ｯ繧ｪ繝悶ず繧ｧ繧ｯ繝域怏蜉ｹ謨ｰ + int dataindex; + // 迴ｾ蝨ｨ縺ｮ繝繝ｼ繧ｿ繝医Λ繝繧ｯ + int audioindex; + // 迴ｾ蝨ｨ縺ｮ繧ｪ繝ｼ繝繧｣繧ｪ繝医Λ繝繧ｯ + + int frame; + // 繝輔Ξ繝ｼ繝逡ｪ蜿ｷ + +#if 0 + CDDABuf da_buf; + // CD-DA繝舌ャ繝輔ぃ + int da_num; + // CD-DA繝医Λ繝繧ｯ謨ｰ + int da_cur; + // CD-DA繧ｫ繝ｬ繝ｳ繝医ヨ繝ｩ繝繧ｯ + int da_next; + // CD-DA繝阪け繧ｹ繝医ヨ繝ｩ繝繧ｯ + BOOL da_req; + // CD-DA繝繝ｼ繧ｿ隕∵ｱ +#endif +}; + +//=========================================================================== +// +// SCSI 繝帙せ繝医ヶ繝ｪ繝繧ｸ +// +//=========================================================================== +class CTapDriver; +class CFileSys; +class SCSIBR : public Disk +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + SCSIBR(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~SCSIBR(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + + // 繧ｳ繝槭Φ繝 + int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); + // INQUIRY繧ｳ繝槭Φ繝 + BOOL FASTCALL TestUnitReady(const DWORD *cdb); + // TEST UNIT READY繧ｳ繝槭Φ繝 + int FASTCALL GetMessage10(const DWORD *cdb, BYTE *buf); + // GET MESSAGE10繧ｳ繝槭Φ繝 + BOOL FASTCALL SendMessage10(const DWORD *cdb, BYTE *buf); + // SEND MESSAGE10繧ｳ繝槭Φ繝 + +private: + int FASTCALL GetMacAddr(BYTE *buf); + // MAC繧｢繝峨Ξ繧ｹ蜿門ｾ + void FASTCALL SetMacAddr(BYTE *buf); + // MAC繧｢繝峨Ξ繧ｹ險ｭ螳 + void FASTCALL ReceivePacket(); + // 繝代こ繝繝亥女菫｡ + void FASTCALL GetPacketBuf(BYTE *buf); + // 繝代こ繝繝亥叙蠕 + void FASTCALL SendPacket(BYTE *buf, int len); + // 繝代こ繝繝磯∽ｿ｡ + + CTapDriver *tap; + // TAP繝峨Λ繧､繝 + BOOL m_bTapEnable; + // TAP譛牙柑繝輔Λ繧ｰ + BYTE mac_addr[6]; + // MAC繧｢繝峨Ξ繧ｹ + int packet_len; + // 蜿嶺ｿ｡繝代こ繝繝医し繧､繧ｺ + BYTE packet_buf[0x1000]; + // 蜿嶺ｿ｡繝代こ繝繝医ヰ繝繝輔ぃ + BOOL packet_enable; + // 蜿嶺ｿ｡繝代こ繝繝域怏蜉ｹ + + + int FASTCALL ReadFsResult(BYTE *buf); + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(邨先棡繧ｳ繝ｼ繝) + int FASTCALL ReadFsOut(BYTE *buf); + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(霑泌唆繝繝ｼ繧ｿ) + int FASTCALL ReadFsOpt(BYTE *buf); + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝隱ｭ縺ｿ霎ｼ縺ｿ(繧ｪ繝励す繝ｧ繝ｳ繝繝ｼ繧ｿ) + void FASTCALL WriteFs(int func, BYTE *buf); + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝譖ｸ縺崎ｾｼ縺ｿ(螳溯｡) + void FASTCALL WriteFsOpt(BYTE *buf, int len); + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝譖ｸ縺崎ｾｼ縺ｿ(繧ｪ繝励す繝ｧ繝ｳ繝繝ｼ繧ｿ) + + // 繧ｳ繝槭Φ繝峨ワ繝ｳ繝峨Λ + void FASTCALL FS_InitDevice(BYTE *buf); + // $40 - 繝繝舌う繧ｹ襍ｷ蜍 + void FASTCALL FS_CheckDir(BYTE *buf); + // $41 - 繝繧｣繝ｬ繧ｯ繝医Μ繝√ぉ繝繧ｯ + void FASTCALL FS_MakeDir(BYTE *buf); + // $42 - 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + void FASTCALL FS_RemoveDir(BYTE *buf); + // $43 - 繝繧｣繝ｬ繧ｯ繝医Μ蜑企勁 + void FASTCALL FS_Rename(BYTE *buf); + // $44 - 繝輔ぃ繧､繝ｫ蜷榊､画峩 + void FASTCALL FS_Delete(BYTE *buf); + // $45 - 繝輔ぃ繧､繝ｫ蜑企勁 + void FASTCALL FS_Attribute(BYTE *buf); + // $46 - 繝輔ぃ繧､繝ｫ螻樊ｧ蜿門ｾ/險ｭ螳 + void FASTCALL FS_Files(BYTE *buf); + // $47 - 繝輔ぃ繧､繝ｫ讀懃ｴ｢ + void FASTCALL FS_NFiles(BYTE *buf); + // $48 - 繝輔ぃ繧､繝ｫ谺｡讀懃ｴ｢ + void FASTCALL FS_Create(BYTE *buf); + // $49 - 繝輔ぃ繧､繝ｫ菴懈 + void FASTCALL FS_Open(BYTE *buf); + // $4A - 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + void FASTCALL FS_Close(BYTE *buf); + // $4B - 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + void FASTCALL FS_Read(BYTE *buf); + // $4C - 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ + void FASTCALL FS_Write(BYTE *buf); + // $4D - 繝輔ぃ繧､繝ｫ譖ｸ縺崎ｾｼ縺ｿ + void FASTCALL FS_Seek(BYTE *buf); + // $4E - 繝輔ぃ繧､繝ｫ繧ｷ繝ｼ繧ｯ + void FASTCALL FS_TimeStamp(BYTE *buf); + // $4F - 繝輔ぃ繧､繝ｫ譎ょ綾蜿門ｾ/險ｭ螳 + void FASTCALL FS_GetCapacity(BYTE *buf); + // $50 - 螳ｹ驥丞叙蠕 + void FASTCALL FS_CtrlDrive(BYTE *buf); + // $51 - 繝峨Λ繧､繝也憾諷区､懈渊/蛻ｶ蠕｡ + void FASTCALL FS_GetDPB(BYTE *buf); + // $52 - DPB蜿門ｾ + void FASTCALL FS_DiskRead(BYTE *buf); + // $53 - 繧ｻ繧ｯ繧ｿ隱ｭ縺ｿ霎ｼ縺ｿ + void FASTCALL FS_DiskWrite(BYTE *buf); + // $54 - 繧ｻ繧ｯ繧ｿ譖ｸ縺崎ｾｼ縺ｿ + void FASTCALL FS_Ioctrl(BYTE *buf); + // $55 - IOCTRL + void FASTCALL FS_Flush(BYTE *buf); + // $56 - 繝輔Λ繝繧ｷ繝･ + void FASTCALL FS_CheckMedia(BYTE *buf); + // $57 - 繝｡繝繧｣繧｢莠､謠帙メ繧ｧ繝繧ｯ + void FASTCALL FS_Lock(BYTE *buf); + // $58 - 謗剃ｻ門宛蠕｡ + + CFileSys *fs; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繝繧ｵ繝ｼ + DWORD fsresult; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繧ｹ邨先棡繧ｳ繝ｼ繝 + BYTE fsout[0x800]; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繧ｹ邨先棡繝舌ャ繝輔ぃ + DWORD fsoutlen; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繧ｹ邨先棡繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ + BYTE fsopt[0x1000000]; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繧ｹ繝舌ャ繝輔ぃ + DWORD fsoptlen; + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝繧｢繧ｯ繧ｻ繧ｹ繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ +}; + +//=========================================================================== +// +// SASI 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ +// +//=========================================================================== +class SASIDEV +{ +public: + // 隲也炊繝ｦ繝九ャ繝域怙螟ｧ謨ｰ + enum { + UnitMax = 8 + }; + + // 繝輔ぉ繝ｼ繧ｺ繧ｿ繧､繝溘Φ繧ｰ(隱ｿ謨ｴ逕ｨ) + enum { + Time_phase_bsy = 800, + Time_phase_before = 6000, // min 4000ns + Time_phase_before_data = 60000, // min 40000ns + Time_phase_after = 6000, // min 4000ns + Time_phase_after_status = 12000, // min 9000ns + }; + + // 蜀驛ｨ繝繝ｼ繧ｿ螳夂ｾｩ + typedef struct { + // 蜈ｨ闊ｬ + BUS::phase_t phase; // 驕ｷ遘ｻ繝輔ぉ繝ｼ繧ｺ + int id; // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩID(0-7) + BUS *bus; // 繝舌せ + + // 繧ｳ繝槭Φ繝 + DWORD cmd[10]; // 繧ｳ繝槭Φ繝峨ョ繝ｼ繧ｿ + DWORD status; // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝繝ｼ繧ｿ + DWORD message; // 繝｡繝繧ｻ繝ｼ繧ｸ繝繝ｼ繧ｿ + + // 霆｢騾 + BYTE *buffer; // 霆｢騾√ヰ繝繝輔ぃ + int bufsize; // 霆｢騾√ヰ繝繝輔ぃ繧ｵ繧､繧ｺ + DWORD blocks; // 霆｢騾√ヶ繝ｭ繝繧ｯ謨ｰ + DWORD next; // 谺｡縺ｮ繝ｬ繧ｳ繝ｼ繝 + DWORD offset; // 霆｢騾√が繝輔そ繝繝 + DWORD length; // 霆｢騾∵ｮ九ｊ髟ｷ縺 + + // 隲也炊繝ｦ繝九ャ繝 + Disk *unit[UnitMax]; + // 隲也炊繝ｦ繝九ャ繝 + } ctrl_t; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ +#ifdef RASCSI + SASIDEV(); +#else + SASIDEV(Device *dev); +#endif //RASCSI + + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~SASIDEV(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + virtual void FASTCALL Reset(); + // 繝繝舌う繧ｹ繝ｪ繧ｻ繝繝 +#ifndef RASCSI + virtual BOOL FASTCALL Save(Fileio *fio, int ver); + // 繧ｻ繝ｼ繝 + virtual BOOL FASTCALL Load(Fileio *fio, int ver); + // 繝ｭ繝ｼ繝 +#endif //RASCSI + + // 螟夜ΚAPI + virtual BUS::phase_t FASTCALL Process(); + // 螳溯｡ + + // 謗･邯 + void FASTCALL Connect(int id, BUS *sbus); + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ謗･邯 + Disk* FASTCALL GetUnit(int no); + // 隲也炊繝ｦ繝九ャ繝亥叙蠕 + void FASTCALL SetUnit(int no, Disk *dev); + // 隲也炊繝ｦ繝九ャ繝郁ｨｭ螳 + BOOL FASTCALL HasUnit(); + // 譛牙柑縺ｪ隲也炊繝ｦ繝九ャ繝医ｒ謖√▲縺ｦ縺繧九°霑斐☆ + + // 縺昴ｮ莉 + BUS::phase_t FASTCALL GetPhase() {return ctrl.phase;} + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + int FASTCALL GetID() {return ctrl.id;} + // ID蜿門ｾ + void FASTCALL GetCTRL(ctrl_t *buffer); + // 蜀驛ｨ諠蝣ｱ蜿門ｾ + ctrl_t* FASTCALL GetWorkAddr() { return &ctrl; } + // 蜀驛ｨ諠蝣ｱ繧｢繝峨Ξ繧ｹ蜿門ｾ + virtual BOOL FASTCALL IsSASI() const {return TRUE;} + // SASI繝√ぉ繝繧ｯ + Disk* FASTCALL GetBusyUnit(); + // 繝薙ず繝ｼ迥ｶ諷九ｮ繝ｦ繝九ャ繝医ｒ蜿門ｾ + +protected: + // 繝輔ぉ繝ｼ繧ｺ蜃ｦ逅 + virtual void FASTCALL BusFree(); + // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + virtual void FASTCALL Selection(); + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + virtual void FASTCALL Command(); + // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + virtual void FASTCALL Execute(); + // 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ + void FASTCALL Status(); + // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + void FASTCALL MsgIn(); + // 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + void FASTCALL DataIn(); + // 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ + void FASTCALL DataOut(); + // 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + virtual void FASTCALL Error(); + // 蜈ｱ騾壹お繝ｩ繝ｼ蜃ｦ逅 + + // 繧ｳ繝槭Φ繝 + void FASTCALL CmdTestUnitReady(); + // TEST UNIT READY繧ｳ繝槭Φ繝 + void FASTCALL CmdRezero(); + // REZERO UNIT繧ｳ繝槭Φ繝 + void FASTCALL CmdRequestSense(); + // REQUEST SENSE繧ｳ繝槭Φ繝 + void FASTCALL CmdFormat(); + // FORMAT繧ｳ繝槭Φ繝 + void FASTCALL CmdReassign(); + // REASSIGN BLOCKS繧ｳ繝槭Φ繝 + void FASTCALL CmdRead6(); + // READ(6)繧ｳ繝槭Φ繝 + void FASTCALL CmdWrite6(); + // WRITE(6)繧ｳ繝槭Φ繝 + void FASTCALL CmdSeek6(); + // SEEK(6)繧ｳ繝槭Φ繝 + void FASTCALL CmdAssign(); + // ASSIGN繧ｳ繝槭Φ繝 + void FASTCALL CmdSpecify(); + // SPECIFY繧ｳ繝槭Φ繝 + void FASTCALL CmdInvalid(); + // 繧ｵ繝昴ｼ繝医＠縺ｦ縺縺ｪ縺繧ｳ繝槭Φ繝 + + // 繝繝ｼ繧ｿ霆｢騾 + virtual void FASTCALL Send(); + // 繝繝ｼ繧ｿ騾∽ｿ｡ + virtual void FASTCALL Receive(); + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + BOOL FASTCALL XferIn(BYTE* buf); + // 繝繝ｼ繧ｿ霆｢騾！N + BOOL FASTCALL XferOut(BOOL cont); + // 繝繝ｼ繧ｿ霆｢騾＾UT + + // 繝ｭ繧ｰ + void FASTCALL Log(Log::loglevel level, const char *format, ...); + // 繝ｭ繧ｰ蜃ｺ蜉 + +protected: +#ifndef RASCSI + Device *host; + // 繝帙せ繝医ョ繝舌う繧ｹ +#endif // RASCSI + + ctrl_t ctrl; + // 蜀驛ｨ繝繝ｼ繧ｿ +}; + +//=========================================================================== +// +// SCSI 繝繝舌う繧ｹ(SASI 繝繝舌う繧ｹ繧堤ｶ呎価) +// +//=========================================================================== +class SCSIDEV : public SASIDEV +{ +public: + // 蜀驛ｨ繝繝ｼ繧ｿ螳夂ｾｩ + typedef struct { + // 蜷梧悄霆｢騾 + BOOL syncenable; // 蜷梧悄霆｢騾∝庄閭ｽ + int syncperiod; // 蜷梧悄霆｢騾√ヴ繝ｪ繧ｪ繝 + int syncoffset; // 蜷梧悄霆｢騾√が繝輔そ繝繝 + int syncack; // 蜷梧悄霆｢騾、CK謨ｰ + + // ATN繝｡繝繧ｻ繝ｼ繧ｸ + BOOL atnmsg; + int msc; + BOOL msb[256]; + } scsi_t; + +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ +#ifdef RASCSI + SCSIDEV(); +#else + SCSIDEV(Device *dev); +#endif // RASCSI + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + + void FASTCALL Reset(); + // 繝繝舌う繧ｹ繝ｪ繧ｻ繝繝 + + // 螟夜ΚAPI + BUS::phase_t FASTCALL Process(); + // 螳溯｡ + + void FASTCALL SyncTransfer(BOOL enable) { scsi.syncenable = enable; } + // 蜷梧悄霆｢騾∝庄閭ｽ險ｭ螳 + + // 縺昴ｮ莉 + BOOL FASTCALL IsSASI() const {return FALSE;} + // SASI繝√ぉ繝繧ｯ + +private: + // 繝輔ぉ繝ｼ繧ｺ + void FASTCALL BusFree(); + // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + void FASTCALL Selection(); + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + void FASTCALL Execute(); + // 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ + void FASTCALL MsgOut(); + // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + void FASTCALL Error(); + // 蜈ｱ騾壹お繝ｩ繝ｼ蜃ｦ逅 + + // 繧ｳ繝槭Φ繝 + void FASTCALL CmdInquiry(); + // INQUIRY繧ｳ繝槭Φ繝 + void FASTCALL CmdModeSelect(); + // MODE SELECT繧ｳ繝槭Φ繝 + void FASTCALL CmdModeSense(); + // MODE SENSE繧ｳ繝槭Φ繝 + void FASTCALL CmdStartStop(); + // START STOP UNIT繧ｳ繝槭Φ繝 + void FASTCALL CmdSendDiag(); + // SEND DIAGNOSTIC繧ｳ繝槭Φ繝 + void FASTCALL CmdRemoval(); + // PREVENT/ALLOW MEDIUM REMOVAL繧ｳ繝槭Φ繝 + void FASTCALL CmdReadCapacity(); + // READ CAPACITY繧ｳ繝槭Φ繝 + void FASTCALL CmdRead10(); + // READ(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdWrite10(); + // WRITE(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdSeek10(); + // SEEK(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdVerify(); + // VERIFY繧ｳ繝槭Φ繝 + void FASTCALL CmdSynchronizeCache(); + // SYNCHRONIZE CACHE 繧ｳ繝槭Φ繝 + void FASTCALL CmdReadDefectData10(); + // READ DEFECT DATA(10) 繧ｳ繝槭Φ繝 + void FASTCALL CmdReadToc(); + // READ TOC繧ｳ繝槭Φ繝 + void FASTCALL CmdPlayAudio10(); + // PLAY AUDIO(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdPlayAudioMSF(); + // PLAY AUDIO MSF繧ｳ繝槭Φ繝 + void FASTCALL CmdPlayAudioTrack(); + // PLAY AUDIO TRACK INDEX繧ｳ繝槭Φ繝 + void FASTCALL CmdModeSelect10(); + // MODE SELECT(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdModeSense10(); + // MODE SENSE(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdGetMessage10(); + // GET MESSAGE(10)繧ｳ繝槭Φ繝 + void FASTCALL CmdSendMessage10(); + // SEND MESSAGE(10)繧ｳ繝槭Φ繝 + + // 繝繝ｼ繧ｿ霆｢騾 + void FASTCALL Send(); + // 繝繝ｼ繧ｿ騾∽ｿ｡ + void FASTCALL Receive(); + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + BOOL FASTCALL XferMsg(DWORD msg); + // 繝繝ｼ繧ｿ霆｢騾｀SG + + scsi_t scsi; + // 蜀驛ｨ繝繝ｼ繧ｿ +}; + +#endif // disk_h diff --git a/src/raspberrypi/fileio.cpp b/src/raspberrypi/fileio.cpp new file mode 100644 index 00000000..c72c4c4c --- /dev/null +++ b/src/raspberrypi/fileio.cpp @@ -0,0 +1,367 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2010-2018 GIMONS +// [ 繝輔ぃ繧､繝ｫI/O(RaSCSI逕ｨ繧ｵ繝悶そ繝繝) ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "filepath.h" +#include "fileio.h" + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫI/O +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Fileio::Fileio() +{ + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + handle = -1; +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Fileio::~Fileio() +{ + ASSERT(handle == -1); + + // Release縺ｧ縺ｮ螳牙ｨ遲 + Close(); +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Load(const Filepath& path, void *buffer, int size) +{ + ASSERT(this); + ASSERT(buffer); + ASSERT(size > 0); + ASSERT(handle < 0); + + // 繧ｪ繝ｼ繝励Φ + if (!Open(path, ReadOnly)) { + return FALSE; + } + + // 隱ｭ縺ｿ霎ｼ縺ｿ + if (!Read(buffer, size)) { + Close(); + return FALSE; + } + + // 繧ｯ繝ｭ繝ｼ繧ｺ + Close(); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Save(const Filepath& path, void *buffer, int size) +{ + ASSERT(this); + ASSERT(buffer); + ASSERT(size > 0); + ASSERT(handle < 0); + + // 繧ｪ繝ｼ繝励Φ + if (!Open(path, WriteOnly)) { + return FALSE; + } + + // 隱ｭ縺ｿ霎ｼ縺ｿ + if (!Write(buffer, size)) { + Close(); + return FALSE; + } + + // 繧ｯ繝ｭ繝ｼ繧ｺ + Close(); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Open(LPCTSTR fname, OpenMode mode) +{ + ASSERT(this); + ASSERT(fname); + ASSERT(handle < 0); + + // 繝後Ν譁蟄怜励°繧峨ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｯ蠢縺壼､ｱ謨励＆縺帙ｋ + if (fname[0] == _T('\0')) { + handle = -1; + return FALSE; + } + + // 繝｢繝ｼ繝牙挨 + switch (mode) { + // 隱ｭ縺ｿ霎ｼ縺ｿ縺ｮ縺ｿ + case ReadOnly: + handle = open(fname, O_RDONLY); + break; + + // 譖ｸ縺崎ｾｼ縺ｿ縺ｮ縺ｿ + case WriteOnly: + handle = open(fname, O_CREAT | O_WRONLY | O_TRUNC, 0666); + break; + + // 隱ｭ縺ｿ譖ｸ縺堺ｸ｡譁ｹ + case ReadWrite: + // CD-ROM縺九ｉ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｯRW縺梧仙粥縺励※縺励∪縺 + if (access(fname, 0x06) != 0) { + return FALSE; + } + handle = open(fname, O_RDWR); + break; + + // 繧｢繝壹Φ繝 + case Append: + handle = open(fname, O_CREAT | O_WRONLY | O_APPEND, 0666); + break; + + // 縺昴ｌ莉･螟 + default: + ASSERT(FALSE); + break; + } + + // 邨先棡隧穂ｾ｡ + if (handle == -1) { + return FALSE; + } + ASSERT(handle >= 0); + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::OpenDIO(LPCTSTR fname, OpenMode mode) +{ + ASSERT(this); + ASSERT(fname); + ASSERT(handle < 0); + + // 繝後Ν譁蟄怜励°繧峨ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｯ蠢縺壼､ｱ謨励＆縺帙ｋ + if (fname[0] == _T('\0')) { + handle = -1; + return FALSE; + } + + // 繝｢繝ｼ繝牙挨 + switch (mode) { + // 隱ｭ縺ｿ霎ｼ縺ｿ縺ｮ縺ｿ + case ReadOnly: + handle = open(fname, O_RDONLY | O_DIRECT); + break; + + // 譖ｸ縺崎ｾｼ縺ｿ縺ｮ縺ｿ + case WriteOnly: + handle = open(fname, O_CREAT | O_WRONLY | O_TRUNC | O_DIRECT, 0666); + break; + + // 隱ｭ縺ｿ譖ｸ縺堺ｸ｡譁ｹ + case ReadWrite: + // CD-ROM縺九ｉ縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ縺ｯRW縺梧仙粥縺励※縺励∪縺 + if (access(fname, 0x06) != 0) { + return FALSE; + } + handle = open(fname, O_RDWR | O_DIRECT); + break; + + // 繧｢繝壹Φ繝 + case Append: + handle = open(fname, O_CREAT | O_WRONLY | O_APPEND | O_DIRECT, 0666); + break; + + // 縺昴ｌ莉･螟 + default: + ASSERT(FALSE); + break; + } + + // 邨先棡隧穂ｾ｡ + if (handle == -1) { + return FALSE; + } + ASSERT(handle >= 0); + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Open(const Filepath& path, OpenMode mode) +{ + ASSERT(this); + + return Open(path.GetPath(), mode); +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::OpenDIO(const Filepath& path, OpenMode mode) +{ + ASSERT(this); + + return OpenDIO(path.GetPath(), mode); +} + +//--------------------------------------------------------------------------- +// +// 隱ｭ縺ｿ霎ｼ縺ｿ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Read(void *buffer, int size) +{ + int count; + + ASSERT(this); + ASSERT(buffer); + ASSERT(size > 0); + ASSERT(handle >= 0); + + // 隱ｭ縺ｿ霎ｼ縺ｿ + count = read(handle, buffer, size); + if (count != size) { + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 譖ｸ縺崎ｾｼ縺ｿ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Write(const void *buffer, int size) +{ + int count; + + ASSERT(this); + ASSERT(buffer); + ASSERT(size > 0); + ASSERT(handle >= 0); + + // 隱ｭ縺ｿ霎ｼ縺ｿ + count = write(handle, buffer, size); + if (count != size) { + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｷ繝ｼ繧ｯ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Fileio::Seek(off64_t offset, BOOL relative) +{ + ASSERT(this); + ASSERT(handle >= 0); + ASSERT(offset >= 0); + + // 逶ｸ蟇ｾ繧ｷ繝ｼ繧ｯ縺ｪ繧峨が繝輔そ繝繝医↓迴ｾ蝨ｨ蛟､繧定ｿｽ蜉 + if (relative) { + offset += GetFilePos(); + } + + if (lseek(handle, offset, SEEK_SET) != offset) { + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ蜿門ｾ +// +//--------------------------------------------------------------------------- +off64_t FASTCALL Fileio::GetFileSize() +{ + off64_t cur; + off64_t end; + + ASSERT(this); + ASSERT(handle >= 0); + + // 繝輔ぃ繧､繝ｫ菴咲ｽｮ繧64bit縺ｧ蜿門ｾ + cur = GetFilePos(); + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ繧64bit縺ｧ蜿門ｾ + end = lseek(handle, 0, SEEK_END); + + // 菴咲ｽｮ繧貞縺ｫ謌ｻ縺 + Seek(cur); + + return end; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ菴咲ｽｮ蜿門ｾ +// +//--------------------------------------------------------------------------- +off64_t FASTCALL Fileio::GetFilePos() const +{ + off64_t pos; + + ASSERT(this); + ASSERT(handle >= 0); + + // 繝輔ぃ繧､繝ｫ菴咲ｽｮ繧64bit縺ｧ蜿門ｾ + pos = lseek(handle, 0, SEEK_CUR); + return pos; + +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｭ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +void FASTCALL Fileio::Close() +{ + ASSERT(this); + + if (handle != -1) { + close(handle); + handle = -1; + } +} diff --git a/src/raspberrypi/fileio.h b/src/raspberrypi/fileio.h new file mode 100644 index 00000000..22f02ac9 --- /dev/null +++ b/src/raspberrypi/fileio.h @@ -0,0 +1,83 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2005 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2013-2018 GIMONS +// [ 繝輔ぃ繧､繝ｫI/O(RaSCSI逕ｨ繧ｵ繝悶そ繝繝) ] +// +//--------------------------------------------------------------------------- + +#if !defined(fileio_h) +#define fileio_h + +//=========================================================================== +// +// 繝槭け繝ｭ(Load,Save逕ｨ) +// +//=========================================================================== +#define PROP_IMPORT(f, p) \ + if (!f->Read(&(p), sizeof(p))) {\ + return FALSE;\ + }\ + +#define PROP_EXPORT(f, p) \ + if (!f->Write(&(p), sizeof(p))) {\ + return FALSE;\ + }\ + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫI/O +// +//=========================================================================== +class Fileio +{ +public: + enum OpenMode { + ReadOnly, // 隱ｭ縺ｿ霎ｼ縺ｿ縺ｮ縺ｿ + WriteOnly, // 譖ｸ縺崎ｾｼ縺ｿ縺ｮ縺ｿ + ReadWrite, // 隱ｭ縺ｿ譖ｸ縺堺ｸ｡譁ｹ + Append // 繧｢繝壹Φ繝 + }; + +public: + Fileio(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~Fileio(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Load(const Filepath& path, void *buffer, int size); + // ROM,RAM繝ｭ繝ｼ繝 + BOOL FASTCALL Save(const Filepath& path, void *buffer, int size); + // RAM繧ｻ繝ｼ繝 + + BOOL FASTCALL Open(LPCTSTR fname, OpenMode mode); + // 繧ｪ繝ｼ繝励Φ + BOOL FASTCALL OpenDIO(LPCTSTR fname, OpenMode mode); + // 繧ｪ繝ｼ繝励Φ + BOOL FASTCALL Open(const Filepath& path, OpenMode mode); + // 繧ｪ繝ｼ繝励Φ + BOOL FASTCALL OpenDIO(const Filepath& path, OpenMode mode); + // 繧ｪ繝ｼ繝励Φ + BOOL FASTCALL Seek(off64_t offset, BOOL relative = FALSE); + // 繧ｷ繝ｼ繧ｯ + BOOL FASTCALL Read(void *buffer, int size); + // 隱ｭ縺ｿ霎ｼ縺ｿ + BOOL FASTCALL Write(const void *buffer, int size); + // 譖ｸ縺崎ｾｼ縺ｿ + off64_t FASTCALL GetFileSize(); + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ蜿門ｾ + off64_t FASTCALL GetFilePos() const; + // 繝輔ぃ繧､繝ｫ菴咲ｽｮ蜿門ｾ + void FASTCALL Close(); + // 繧ｯ繝ｭ繝ｼ繧ｺ + BOOL FASTCALL IsValid() const { return (BOOL)(handle != -1); } + // 譛牙柑繝√ぉ繝繧ｯ + int FASTCALL GetHandle() const { return handle; } + // 繝上Φ繝峨Ν蜿門ｾ + +private: + int handle; // 繝輔ぃ繧､繝ｫ繝上Φ繝峨Ν +}; + +#endif // fileio_h diff --git a/src/raspberrypi/filepath.cpp b/src/raspberrypi/filepath.cpp new file mode 100644 index 00000000..43d2e410 --- /dev/null +++ b/src/raspberrypi/filepath.cpp @@ -0,0 +1,273 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2012-2018 GIMONS +// [ 繝輔ぃ繧､繝ｫ繝代せ(繧ｵ繝悶そ繝繝) ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "filepath.h" +#include "fileio.h" + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫ繝代せ +// +//=========================================================================== + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Filepath::Filepath() +{ + // 繧ｯ繝ｪ繧｢ + Clear(); +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +Filepath::~Filepath() +{ +} + +//--------------------------------------------------------------------------- +// +// 莉｣蜈･貍皮ｮ怜ｭ +// +//--------------------------------------------------------------------------- +Filepath& Filepath::operator=(const Filepath& path) +{ + // 繝代せ險ｭ螳(蜀驛ｨ縺ｧSplit縺輔ｌ繧) + SetPath(path.GetPath()); + + return *this; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繧｢ +// +//--------------------------------------------------------------------------- +void FASTCALL Filepath::Clear() +{ + ASSERT(this); + + // 繝代せ縺翫ｈ縺ｳ蜷驛ｨ蛻繧偵け繝ｪ繧｢ + m_szPath[0] = _T('\0'); + m_szDir[0] = _T('\0'); + m_szFile[0] = _T('\0'); + m_szExt[0] = _T('\0'); +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ險ｭ螳(繝ｦ繝ｼ繧ｶ) MBCS逕ｨ +// +//--------------------------------------------------------------------------- +void FASTCALL Filepath::SetPath(LPCSTR path) +{ + ASSERT(this); + ASSERT(path); + ASSERT(strlen(path) < _MAX_PATH); + + // 繝代せ蜷阪さ繝斐ｼ + strcpy(m_szPath, (LPTSTR)path); + + // 蛻髮｢ + Split(); +} + +//--------------------------------------------------------------------------- +// +// 繝代せ蛻髮｢ +// +//--------------------------------------------------------------------------- +void FASTCALL Filepath::Split() +{ + LPTSTR pDir; + LPTSTR pDirName; + LPTSTR pBase; + LPTSTR pBaseName; + LPTSTR pExtName; + + ASSERT(this); + + // 繝代ｼ繝繧貞晄悄蛹 + m_szDir[0] = _T('\0'); + m_szFile[0] = _T('\0'); + m_szExt[0] = _T('\0'); + + // 蛻髮｢ + pDir = strdup(m_szPath); + pDirName = dirname(pDir); + pBase = strdup(m_szPath); + pBaseName = basename(pBase); + pExtName = strrchr(pBaseName, '.'); + + // 霆｢騾 + if (pDirName) { + strcpy(m_szDir, pDirName); + strcat(m_szDir, "/"); + } + + if (pExtName) { + strcpy(m_szExt, pExtName); + *pExtName = 0; + } + + if (pBaseName) { + strcpy(m_szFile, pBaseName); + } + + // 隗｣謾ｾ + free(pDir); + free(pBase); +} + +//--------------------------------------------------------------------------- +// +// 繝代せ蜷域 +// +//--------------------------------------------------------------------------- +void FASTCALL Filepath::Make() +{ + ASSERT(this); + + // 繝代せ蛻晄悄蛹 + m_szPath[0] = _T('\0'); + + // 蜷域 + strcat(m_szPath, m_szDir); + strcat(m_szPath, m_szFile); + strcat(m_szPath, m_szExt); +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繧｢縺輔ｌ縺ｦ縺繧九° +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Filepath::IsClear() const +{ + // Clear()縺ｮ騾 + if ((m_szPath[0] == _T('\0')) && + (m_szDir[0] == _T('\0')) && + (m_szFile[0] == _T('\0')) && + (m_szExt[0] == _T('\0'))) { + // 遒ｺ縺九↓縲√け繝ｪ繧｢縺輔ｌ縺ｦ縺繧 + return TRUE; + } + + // 繧ｯ繝ｪ繧｢縺輔ｌ縺ｦ縺縺ｪ縺 + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｷ繝ｧ繝ｼ繝亥錐蜿門ｾ +// 窶ｻ霑斐＆繧後ｋ繝昴う繝ｳ繧ｿ縺ｯ荳譎ら噪縺ｪ繧ゅｮ縲ゅ☆縺舌さ繝斐ｼ縺吶ｋ縺薙→ +// 窶ｻFDIDisk縺ｮdisk.name縺ｨ縺ｮ髢｢菫ゅ〒縲∵枚蟄怜励ｯ譛螟ｧ59譁蟄+邨らｫｯ縺ｨ縺吶ｋ縺薙→ +// +//--------------------------------------------------------------------------- +const char* FASTCALL Filepath::GetShort() const +{ + char szFile[_MAX_FNAME]; + char szExt[_MAX_EXT]; + + ASSERT(this); + + // TCHAR譁蟄怜励°繧営har譁蟄怜励∈螟画鋤 + strcpy(szFile, m_szFile); + strcpy(szExt, m_szExt); + + // 蝗ｺ螳壹ヰ繝繝輔ぃ縺ｸ蜷域 + strcpy(ShortName, szFile); + strcat(ShortName, szExt); + + // strlen縺ｧ隱ｿ縺ｹ縺溘→縺阪∵怙螟ｧ59縺ｫ縺ｪ繧九ｈ縺縺ｫ邏ｰ蟾･ + ShortName[59] = '\0'; + + // const char縺ｨ縺励※霑斐☆ + return (const char*)ShortName; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ蜷搾ｼ区僑蠑ｵ蟄仙叙蠕 +// 窶ｻ霑斐＆繧後ｋ繝昴う繝ｳ繧ｿ縺ｯ荳譎ら噪縺ｪ繧ゅｮ縲ゅ☆縺舌さ繝斐ｼ縺吶ｋ縺薙→ +// +//--------------------------------------------------------------------------- +LPCTSTR FASTCALL Filepath::GetFileExt() const +{ + ASSERT(this); + + // 蝗ｺ螳壹ヰ繝繝輔ぃ縺ｸ蜷域 + strcpy(FileExt, m_szExt); + + // LPCTSTR縺ｨ縺励※霑斐☆ + return (LPCTSTR)FileExt; +} + +//--------------------------------------------------------------------------- +// +// 繝代せ豈碑ｼ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Filepath::CmpPath(const Filepath& path) const +{ + // 繝代せ縺悟ｮ悟ｨ荳閾ｴ縺励※縺繧後ｰTRUE + if (strcmp(path.GetPath(), GetPath()) == 0) { + return TRUE; + } + + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Filepath::Save(Fileio *fio, int /*ver*/) +{ + ASSERT(this); + ASSERT(fio); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝ｭ繝ｼ繝 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL Filepath::Load(Fileio *fio, int /*ver*/) +{ + ASSERT(this); + ASSERT(fio); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｷ繝ｧ繝ｼ繝亥錐 +// +//--------------------------------------------------------------------------- +char Filepath::ShortName[_MAX_FNAME + _MAX_DIR]; + +//--------------------------------------------------------------------------- +// +// 繝輔ぃ繧､繝ｫ蜷搾ｼ区僑蠑ｵ蟄 +// +//--------------------------------------------------------------------------- +TCHAR Filepath::FileExt[_MAX_FNAME + _MAX_DIR]; \ No newline at end of file diff --git a/src/raspberrypi/filepath.h b/src/raspberrypi/filepath.h new file mode 100644 index 00000000..1817a429 --- /dev/null +++ b/src/raspberrypi/filepath.h @@ -0,0 +1,81 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2012-2018 GIMONS +// [ 繝輔ぃ繧､繝ｫ繝代せ(繧ｵ繝悶そ繝繝) ] +// +//--------------------------------------------------------------------------- + +#if !defined(filepath_h) +#define filepath_h + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳夂ｾｩ +// +//--------------------------------------------------------------------------- +#define FILEPATH_MAX _MAX_PATH + +//=========================================================================== +// +// 繝輔ぃ繧､繝ｫ繝代せ +// 窶ｻ莉｣蜈･貍皮ｮ怜ｭ舌ｒ逕ｨ諢上☆繧九％縺ｨ +// +//=========================================================================== +class Filepath +{ +public: + Filepath(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~Filepath(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + Filepath& operator=(const Filepath& path); + // 莉｣蜈･ + + void FASTCALL Clear(); + // 繧ｯ繝ｪ繧｢ + void FASTCALL SetPath(LPCSTR path); + // 繝輔ぃ繧､繝ｫ險ｭ螳(繝ｦ繝ｼ繧ｶ) MBCS逕ｨ + BOOL FASTCALL IsClear() const; + // 繧ｯ繝ｪ繧｢縺輔ｌ縺ｦ縺繧九° + LPCTSTR FASTCALL GetPath() const { return m_szPath; } + // 繝代せ蜷榊叙蠕 + const char* FASTCALL GetShort() const; + // 繧ｷ繝ｧ繝ｼ繝亥錐蜿門ｾ(const char*) + LPCTSTR FASTCALL GetFileExt() const; + // 繧ｷ繝ｧ繝ｼ繝亥錐蜿門ｾ(LPCTSTR) + BOOL FASTCALL CmpPath(const Filepath& path) const; + // 繝代せ豈碑ｼ + + BOOL FASTCALL Save(Fileio *fio, int ver); + // 繧ｻ繝ｼ繝 + BOOL FASTCALL Load(Fileio *fio, int ver); + // 繝ｭ繝ｼ繝 + +private: + void FASTCALL Split(); + // 繝代せ蛻蜑ｲ + void FASTCALL Make(); + // 繝代せ蜷域 + void FASTCALL SetCurDir(); + // 繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ險ｭ螳 + TCHAR m_szPath[_MAX_PATH]; + // 繝輔ぃ繧､繝ｫ繝代せ + TCHAR m_szDrive[_MAX_DRIVE]; + // 繝峨Λ繧､繝 + TCHAR m_szDir[_MAX_DIR]; + // 繝繧｣繝ｬ繧ｯ繝医Μ + TCHAR m_szFile[_MAX_FNAME]; + // 繝輔ぃ繧､繝ｫ + TCHAR m_szExt[_MAX_EXT]; + // 諡｡蠑ｵ蟄 + + static char ShortName[_MAX_FNAME + _MAX_DIR]; + // 繧ｷ繝ｧ繝ｼ繝亥錐(char) + static TCHAR FileExt[_MAX_FNAME + _MAX_DIR]; + // 繧ｷ繝ｧ繝ｼ繝亥錐(TCHAR) +}; + +#endif // filepath_h diff --git a/src/raspberrypi/gpiobus.cpp b/src/raspberrypi/gpiobus.cpp new file mode 100644 index 00000000..792f8070 --- /dev/null +++ b/src/raspberrypi/gpiobus.cpp @@ -0,0 +1,1192 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ GPIO-SCSI繝舌せ ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "gpiobus.h" + +#ifdef __linux__ +//--------------------------------------------------------------------------- +// +// imported from bcm_host.c +// +//--------------------------------------------------------------------------- +static DWORD get_dt_ranges(const char *filename, DWORD offset) +{ + DWORD address; + FILE *fp; + BYTE buf[4]; + + address = ~0; + fp = fopen(filename, "rb"); + if (fp) { + fseek(fp, offset, SEEK_SET); + if (fread(buf, 1, sizeof buf, fp) == sizeof buf) { + address = + buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3] << 0; + } + fclose(fp); + } + return address; +} + +DWORD bcm_host_get_peripheral_address(void) +{ + DWORD address; + + address = get_dt_ranges("/proc/device-tree/soc/ranges", 4); + return address == (DWORD)~0 ? 0x20000000 : address; +} +#endif // __linux__ + +#ifdef __NetBSD__ +// Raspberry Pi繧ｷ繝ｪ繝ｼ繧ｺ繧剃ｻｮ螳壹＠縺ｦCPU縺九ｉ繧｢繝峨Ξ繧ｹ繧呈耳螳 +DWORD bcm_host_get_peripheral_address(void) +{ + char buf[1024]; + size_t len = sizeof(buf); + DWORD address; + + if (sysctlbyname("hw.model", buf, &len, NULL, 0) || + strstr(buf, "ARM1176JZ-S") != buf) { + // CPU繝｢繝繝ｫ縺ｮ蜿門ｾ励↓螟ｱ謨 || BCM2835縺ｧ縺ｯ縺ｪ縺 + // BCM283[67]縺ｮ繧｢繝峨Ξ繧ｹ繧剃ｽｿ逕ｨ + address = 0x3f000000; + } else { + // BCM2835縺ｮ繧｢繝峨Ξ繧ｹ繧剃ｽｿ逕ｨ + address = 0x20000000; + } + printf("Peripheral address : 0x%lx\n", address); + return address; +} +#endif + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +GPIOBUS::GPIOBUS() +{ +} + +//--------------------------------------------------------------------------- +// +// 繝繧ｹ繝医Λ繧ｯ繧ｿ +// +//--------------------------------------------------------------------------- +GPIOBUS::~GPIOBUS() +{ +} + +//--------------------------------------------------------------------------- +// +// 繝斐Φ讖溯ｽ險ｭ螳(蜈･蜃ｺ蜉幄ｨｭ螳) +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::PinConfig(int pin, int mode) +{ + int index; + DWORD mask; + + // 譛ｪ菴ｿ逕ｨ縺ｪ繧臥┌蜉ｹ + if (pin < 0) { + return; + } + + index = pin / 10; + mask = ~(0x7 << ((pin % 10) * 3)); + gpio[index] = (gpio[index] & mask) | ((mode & 0x7) << ((pin % 10) * 3)); +} + +//--------------------------------------------------------------------------- +// +// 繝斐Φ讖溯ｽ險ｭ螳(繝励Ν繧｢繝繝/繝繧ｦ繝ｳ) +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::PullConfig(int pin, int mode) +{ + // 譛ｪ菴ｿ逕ｨ縺ｪ繧臥┌蜉ｹ + if (pin < 0) { + return; + } + + gpio[GPIO_PUD] = mode & 0x3; + usleep(1); + gpio[GPIO_CLK_0] = 0x1 << pin; + usleep(1); + gpio[GPIO_PUD] = 0; + gpio[GPIO_CLK_0] = 0; +} + +//--------------------------------------------------------------------------- +// +// Drive Strength險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::DrvConfig(DWORD drive) +{ + DWORD data; + + // 繧ｫ繝ｼ繝阪Ν繝峨Λ繧､繝舌′縺ゅｌ縺ｰIOCTL縺ｧ萓晞ｼ縺吶ｋ + if (drvfd >= 0) { + ioctl(drvfd, IOCTL_PADS, (DWORD)drive); + } else { + data = pads[PAD_0_27]; + pads[PAD_0_27] = (0xFFFFFFF8 & data) | drive | 0x5a000000; + } +} + +//--------------------------------------------------------------------------- +// +// 繝斐Φ蜃ｺ蜉幄ｨｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::PinSetSignal(int pin, BOOL ast) +{ + // 譛ｪ菴ｿ逕ｨ縺ｪ繧臥┌蜉ｹ + if (pin < 0) { + return; + } + + if (ast) { + gpio[GPIO_SET_0] = 0x1 << pin; + } else { + gpio[GPIO_CLR_0] = 0x1 << pin; + } +} + +//--------------------------------------------------------------------------- +// +// 繝ｯ繝ｼ繧ｯ繝繝ｼ繝悶Ν菴懈 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::MakeTable(void) +{ + const int pintbl[] = { + PIN_DT0, PIN_DT1, PIN_DT2, PIN_DT3, PIN_DT4, + PIN_DT5, PIN_DT6, PIN_DT7, PIN_DP + }; + + int i; + int j; + BOOL tblParity[256]; + DWORD bits; + DWORD parity; +#if SIGNAL_CONTROL_MODE == 0 + int index; + int shift; +#else + DWORD gpclr; + DWORD gpset; +#endif + + // 繝代Μ繝繧｣繝繝ｼ繝悶Ν菴懈 + for (i = 0; i < 0x100; i++) { + bits = (DWORD)i; + parity = 0; + for (j = 0; j < 8; j++) { + parity ^= bits & 1; + bits >>= 1; + } + parity = ~parity; + tblParity[i] = parity & 1; + } + +#if SIGNAL_CONTROL_MODE == 0 + // 繝槭せ繧ｯ縺ｨ險ｭ螳壹ョ繝ｼ繧ｿ逕滓 + memset(tblDatMsk, 0xff, sizeof(tblDatMsk)); + memset(tblDatSet, 0x00, sizeof(tblDatSet)); + for (i = 0; i < 0x100; i++) { + // 讀懈渊逕ｨ繝薙ャ繝亥 + bits = (DWORD)i; + + // 繝代Μ繝繧｣蜿門ｾ + if (tblParity[i]) { + bits |= (1 << 8); + } + + // 繝薙ャ繝域､懈渊 + for (j = 0; j < 9; j++) { + // 繧､繝ｳ繝繝繧ｯ繧ｹ縺ｨ繧ｷ繝輔ヨ驥剰ｨ育ｮ + index = pintbl[j] / 10; + shift = (pintbl[j] % 10) * 3; + + // 繝槭せ繧ｯ繝繝ｼ繧ｿ + tblDatMsk[index][i] &= ~(0x7 << shift); + + // 險ｭ螳壹ョ繝ｼ繧ｿ + if (bits & 1) { + tblDatSet[index][i] |= (1 << shift); + } + + bits >>= 1; + } + } +#else + // 繝槭せ繧ｯ縺ｨ險ｭ螳壹ョ繝ｼ繧ｿ逕滓 + memset(tblDatMsk, 0x00, sizeof(tblDatMsk)); + memset(tblDatSet, 0x00, sizeof(tblDatSet)); + for (i = 0; i < 0x100; i++) { + // 讀懈渊逕ｨ繝薙ャ繝亥 + bits = (DWORD)i; + + // 繝代Μ繝繧｣蜿門ｾ + if (tblParity[i]) { + bits |= (1 << 8); + } + +#if SIGNAL_CONTROL_MODE == 1 + // 雋隲也炊縺ｯ蜿崎ｻ｢ + bits = ~bits; +#endif + + // GPIO繝ｬ繧ｸ繧ｹ繧ｿ諠蝣ｱ縺ｮ菴懈 + gpclr = 0; + gpset = 0; + for (j = 0; j < 9; j++) { + if (bits & 1) { + gpset |= (1 << pintbl[j]); + } else { + gpclr |= (1 << pintbl[j]); + } + bits >>= 1; + } + + tblDatMsk[i] = gpclr; + tblDatSet[i] = gpset; + } +#endif +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::Init(mode_e mode) +{ + DWORD base; + DWORD addr; + int fd; + void *map; + int i; + int j; + int pullmode; + + // 蜍穂ｽ懊Δ繝ｼ繝峨ｮ菫晏ｭ + actmode = mode; + + // 繝吶ｼ繧ｹ繧｢繝峨Ξ繧ｹ縺ｮ蜿門ｾ + base = (DWORD)bcm_host_get_peripheral_address(); + + // 繧ｫ繝ｼ繝阪Ν繝峨Λ繧､繝舌が繝ｼ繝励Φ + drvfd = open(DRIVER_PATH, O_RDWR); + if (drvfd >= 0) { + printf("Activated RaSCSI GPIO Driver.\n"); + ioctl(drvfd, IOCTL_INIT, base); + ioctl(drvfd, IOCTL_MODE, (DWORD)actmode); + } + + // /dev/mem,/dev/gpiomem縺ｮ鬆縺ｫ繧ｪ繝ｼ繝励Φ繧定ｩｦ縺ｿ繧 + addr = base + GPIO_OFFSET; + fd = open("/dev/mem", O_RDWR | O_SYNC); + if (fd == -1) { + // /dev/gpiomem繧偵が繝ｼ繝励Φ + addr = 0; + fd = open("/dev/gpiomem", O_RDWR | O_SYNC); + if (fd == -1) { + return FALSE; + } + } + + // GPIO縺ｮI/O繝昴ｼ繝医ｒ繝槭ャ繝励☆繧 + map = mmap(NULL, 164, + PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr); + if (map == MAP_FAILED) { + close(fd); + return FALSE; + } + + // GPIO縺ｮI/O繝昴ｼ繝医い繝峨Ξ繧ｹ遒ｺ菫 + gpio = (DWORD *)map; + level = &gpio[GPIO_LEV_0]; + + // PADS縺ｮ蜃ｦ逅縺ｯ繧ｫ繝ｼ繝阪Ν繝峨Λ繧､繝舌′辟｡縺譎ゅ□縺(sudo縺悟ｿ隕√→縺ｪ繧) + if (drvfd < 0) { + // /dev/mem繧偵が繝ｼ繝励Φ + fd = open("/dev/mem", O_RDWR | O_SYNC); + if (fd == -1) { + return FALSE; + } + + // PADS縺ｮI/O繝昴ｼ繝医ｒ繝槭ャ繝励☆繧 + map = mmap(NULL, 56, + PROT_READ | PROT_WRITE, MAP_SHARED, fd, base + PADS_OFFSET); + close(fd); + if (map == MAP_FAILED) { + return FALSE; + } + + // PADS縺ｮI/O繝昴ｼ繝医い繝峨Ξ繧ｹ遒ｺ菫 + pads = (DWORD *)map; + } + + // Drive Strength繧16mA縺ｫ險ｭ螳 + DrvConfig(7); + + // 繝励Ν繧｢繝繝/繝励Ν繝繧ｦ繝ｳ繧定ｨｭ螳 +#if SIGNAL_CONTROL_MODE == 0 + pullmode = GPIO_PULLNONE; +#elif SIGNAL_CONTROL_MODE == 1 + pullmode = GPIO_PULLUP; +#else + pullmode = GPIO_PULLDOWN; +#endif + + // 蜈ｨ菫｡蜿ｷ蛻晄悄蛹 + for (i = 0; SignalTable[i] >= 0; i++) { + j = SignalTable[i]; + PinSetSignal(j, FALSE); + PinConfig(j, GPIO_INPUT); + PullConfig(j, pullmode); + } + + // 蛻ｶ蠕｡菫｡蜿ｷ繧定ｨｭ螳 + PinSetSignal(PIN_ACT, FALSE); + PinSetSignal(PIN_TAD, FALSE); + PinSetSignal(PIN_IND, FALSE); + PinSetSignal(PIN_DTD, FALSE); + PinConfig(PIN_ACT, GPIO_OUTPUT); + PinConfig(PIN_TAD, GPIO_OUTPUT); + PinConfig(PIN_IND, GPIO_OUTPUT); + PinConfig(PIN_DTD, GPIO_OUTPUT); + + // 譛牙柑菫｡蜿ｷ繧定ｨｭ螳 + PinSetSignal(PIN_ENB, ENB_ON); + PinConfig(PIN_ENB, GPIO_OUTPUT); + + // GPFSEL繝舌ャ繧ｯ繧｢繝繝 + gpfsel[0] = gpio[GPIO_FSEL_0]; + gpfsel[1] = gpio[GPIO_FSEL_1]; + gpfsel[2] = gpio[GPIO_FSEL_2]; + gpfsel[3] = gpio[GPIO_FSEL_3]; + + // 繝ｯ繝ｼ繧ｯ繝繝ｼ繝悶Ν菴懈 + MakeTable(); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::Cleanup() +{ + int i; + int j; + + // 蛻ｶ蠕｡菫｡蜿ｷ繧定ｨｭ螳 + PinSetSignal(PIN_ENB, FALSE); + PinSetSignal(PIN_ACT, FALSE); + PinSetSignal(PIN_TAD, FALSE); + PinSetSignal(PIN_IND, FALSE); + PinSetSignal(PIN_DTD, FALSE); + PinConfig(PIN_ACT, GPIO_INPUT); + PinConfig(PIN_TAD, GPIO_INPUT); + PinConfig(PIN_IND, GPIO_INPUT); + PinConfig(PIN_DTD, GPIO_INPUT); + + // 蜈ｨ菫｡蜿ｷ蛻晄悄蛹 + for (i = 0; SignalTable[i] >= 0; i++) { + j = SignalTable[i]; + PinSetSignal(j, FALSE); + PinConfig(j, GPIO_INPUT); + PullConfig(j, GPIO_PULLNONE); + } + + // Drive Strength繧8mA縺ｫ險ｭ螳 + DrvConfig(3); + + // 繧ｫ繝ｼ繝阪Ν繝峨Λ繧､繝 + if (drvfd >= 0) { + close(drvfd); + drvfd = -1; + } +} + +//--------------------------------------------------------------------------- +// +// 蛻ｶ蠕｡菫｡蜿ｷ險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetControl(int pin, BOOL ast) +{ + PinSetSignal(pin, ast); +} + +//--------------------------------------------------------------------------- +// +// 蜈･蜃ｺ蜉帙Δ繝ｼ繝芽ｨｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetMode(int pin, int mode) +{ + int index; + int shift; + DWORD data; + +#if SIGNAL_CONTROL_MODE == 0 + if (mode == OUT) { + return; + } +#endif + + index = pin / 10; + shift = (pin % 10) * 3; + data = gpfsel[index]; + data &= ~(0x7 << shift); + if (mode == OUT) { + data |= (1 << shift); + } + gpio[index] = data; + gpfsel[index] = data; +} + +//--------------------------------------------------------------------------- +// +// 蜈･蜉帑ｿ｡蜿ｷ蛟､蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetSignal(int pin) +{ + return (signals >> pin) & 1; +} + +//--------------------------------------------------------------------------- +// +// 蜃ｺ蜉帑ｿ｡蜿ｷ蛟､險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetSignal(int pin, BOOL ast) +{ +#if SIGNAL_CONTROL_MODE == 0 + int index; + int shift; + DWORD data; + + index = pin / 10; + shift = (pin % 10) * 3; + data = gpfsel[index]; + data &= ~(0x7 << shift); + if (ast) { + data |= (1 << shift); + } + gpio[index] = data; + gpfsel[index] = data; +#elif SIGNAL_CONTROL_MODE == 1 + if (ast) { + gpio[GPIO_CLR_0] = 0x1 << pin; + } else { + gpio[GPIO_SET_0] = 0x1 << pin; + } +#elif SIGNAL_CONTROL_MODE == 2 + if (ast) { + gpio[GPIO_SET_0] = 0x1 << pin; + } else { + gpio[GPIO_CLR_0] = 0x1 << pin; + } +#endif +} + +//--------------------------------------------------------------------------- +// +// 繝翫ヮ遘貞腰菴阪ｮ繧ｹ繝ｪ繝ｼ繝 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SleepNsec(DWORD nsec) +{ + DWORD count; + + count = (nsec + 8 - 1) / 8; + while (count--) { + gpio[GPIO_PUD] = 0; + } +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::Reset() +{ + int i; + int j; + + // 繧｢繧ｯ繝繧｣繝紋ｿ｡蜿ｷ繧偵が繝 + SetControl(PIN_ACT, ACT_OFF); + + // 蜈ｨ菫｡蜿ｷ繧偵ロ繧ｲ繝ｼ繝医↓險ｭ螳 + for (i = 0;; i++) { + j = SignalTable[i]; + if (j < 0) { + break; + } + + SetSignal(j, OFF); + } + + if (actmode == TARGET) { + // 繧ｿ繝ｼ繧ｲ繝繝医Δ繝ｼ繝 + + // 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ繧貞･蜉帙↓險ｭ螳 + SetControl(PIN_TAD, TAD_IN); + SetMode(PIN_BSY, IN); + SetMode(PIN_MSG, IN); + SetMode(PIN_CD, IN); + SetMode(PIN_REQ, IN); + SetMode(PIN_IO, IN); + + // 繧､繝九す繧ｨ繝ｼ繧ｿ菫｡蜿ｷ繧貞･蜉帙↓險ｭ螳 + SetControl(PIN_IND, IND_IN); + SetMode(PIN_SEL, IN); + SetMode(PIN_ATN, IN); + SetMode(PIN_ACK, IN); + SetMode(PIN_RST, IN); + + // 繝繝ｼ繧ｿ繝舌せ菫｡蜿ｷ繧貞･蜉帙↓險ｭ螳 + SetControl(PIN_DTD, DTD_IN); + SetMode(PIN_DT0, IN); + SetMode(PIN_DT1, IN); + SetMode(PIN_DT2, IN); + SetMode(PIN_DT3, IN); + SetMode(PIN_DT4, IN); + SetMode(PIN_DT5, IN); + SetMode(PIN_DT6, IN); + SetMode(PIN_DT7, IN); + SetMode(PIN_DP, IN); + } else { + // 繧､繝九す繧ｨ繝ｼ繧ｿ繝｢繝ｼ繝 + + // 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ繧貞･蜉帙↓險ｭ螳 + SetControl(PIN_TAD, TAD_IN); + SetMode(PIN_BSY, IN); + SetMode(PIN_MSG, IN); + SetMode(PIN_CD, IN); + SetMode(PIN_REQ, IN); + SetMode(PIN_IO, IN); + + // 繧､繝九す繧ｨ繝ｼ繧ｿ菫｡蜿ｷ繧貞ｺ蜉帙↓險ｭ螳 + SetControl(PIN_IND, IND_OUT); + SetMode(PIN_SEL, OUT); + SetMode(PIN_ATN, OUT); + SetMode(PIN_ACK, OUT); + SetMode(PIN_RST, OUT); + + // 繝繝ｼ繧ｿ繝舌せ菫｡蜿ｷ繧貞ｺ蜉帙↓險ｭ螳 + SetControl(PIN_DTD, DTD_OUT); + SetMode(PIN_DT0, OUT); + SetMode(PIN_DT1, OUT); + SetMode(PIN_DT2, OUT); + SetMode(PIN_DT3, OUT); + SetMode(PIN_DT4, OUT); + SetMode(PIN_DT5, OUT); + SetMode(PIN_DT6, OUT); + SetMode(PIN_DT7, OUT); + SetMode(PIN_DP, OUT); + } + + // 蜈ｨ菫｡蜿ｷ蛻晄悄蛹 + signals = 0; +} + +//--------------------------------------------------------------------------- +// +// 繝舌せ菫｡蜿ｷ蜿悶ｊ霎ｼ縺ｿ +// +//--------------------------------------------------------------------------- +DWORD FASTCALL GPIOBUS::Aquire() +{ + signals = *level; + +#if SIGNAL_CONTROL_MODE < 2 + // 雋隲也炊縺ｪ繧牙渚霆｢縺吶ｋ(蜀驛ｨ蜃ｦ逅縺ｯ豁｣隲也炊縺ｫ邨ｱ荳) + signals = ~signals; +#endif + + return signals; +} + +//--------------------------------------------------------------------------- +// +// BSY繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetBSY() +{ + return GetSignal(PIN_BSY); +} + +//--------------------------------------------------------------------------- +// +// BSY繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetBSY(BOOL ast) +{ + if (actmode == TARGET) { + if (ast) { + // 繧｢繧ｯ繝繧｣繝紋ｿ｡蜿ｷ繧偵が繝ｳ + SetControl(PIN_ACT, ACT_ON); + + // 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ繧貞ｺ蜉帙↓險ｭ螳 + SetControl(PIN_TAD, TAD_OUT); + SetMode(PIN_BSY, OUT); + SetMode(PIN_MSG, OUT); + SetMode(PIN_CD, OUT); + SetMode(PIN_REQ, OUT); + SetMode(PIN_IO, OUT); + } else { + // 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ繧貞･蜉帙↓險ｭ螳 + SetControl(PIN_TAD, TAD_IN); + SetMode(PIN_BSY, IN); + SetMode(PIN_MSG, IN); + SetMode(PIN_CD, IN); + SetMode(PIN_REQ, IN); + SetMode(PIN_IO, IN); + + // 繧｢繧ｯ繝繧｣繝紋ｿ｡蜿ｷ繧偵が繝 + SetControl(PIN_ACT, ACT_OFF); + } + } + + // BSY菫｡蜿ｷ繧定ｨｭ螳 + SetSignal(PIN_BSY, ast); +} + +//--------------------------------------------------------------------------- +// +// SEL繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetSEL() +{ + return GetSignal(PIN_SEL); +} + +//--------------------------------------------------------------------------- +// +// SEL繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetSEL(BOOL ast) +{ + if (actmode == INITIATOR && ast) { + // 繧｢繧ｯ繝繧｣繝紋ｿ｡蜿ｷ繧偵が繝ｳ + SetControl(PIN_ACT, ACT_ON); + } + + // SEL菫｡蜿ｷ繧定ｨｭ螳 + SetSignal(PIN_SEL, ast); +} + +//--------------------------------------------------------------------------- +// +// ATN繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetATN() +{ + return GetSignal(PIN_ATN); +} + +//--------------------------------------------------------------------------- +// +// ATN繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetATN(BOOL ast) +{ + SetSignal(PIN_ATN, ast); +} + +//--------------------------------------------------------------------------- +// +// ACK繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetACK() +{ + return GetSignal(PIN_ACK); +} + +//--------------------------------------------------------------------------- +// +// ACK繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetACK(BOOL ast) +{ + SetSignal(PIN_ACK, ast); +} + +//--------------------------------------------------------------------------- +// +// RST繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetRST() +{ + return GetSignal(PIN_RST); +} + +//--------------------------------------------------------------------------- +// +// RST繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetRST(BOOL ast) +{ + SetSignal(PIN_RST, ast); +} + +//--------------------------------------------------------------------------- +// +// MSG繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetMSG() +{ + return GetSignal(PIN_MSG); +} + +//--------------------------------------------------------------------------- +// +// MSG繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetMSG(BOOL ast) +{ + SetSignal(PIN_MSG, ast); +} + +//--------------------------------------------------------------------------- +// +// CD繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetCD() +{ + return GetSignal(PIN_CD); +} + +//--------------------------------------------------------------------------- +// +// CD繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetCD(BOOL ast) +{ + SetSignal(PIN_CD, ast); +} + +//--------------------------------------------------------------------------- +// +// IO繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetIO() +{ + BOOL ast; + ast = GetSignal(PIN_IO); + + if (actmode == INITIATOR) { + // IO菫｡蜿ｷ縺ｫ繧医▲縺ｦ繝繝ｼ繧ｿ縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ螟画峩 + if (ast) { + SetControl(PIN_DTD, DTD_IN); + SetMode(PIN_DT0, IN); + SetMode(PIN_DT1, IN); + SetMode(PIN_DT2, IN); + SetMode(PIN_DT3, IN); + SetMode(PIN_DT4, IN); + SetMode(PIN_DT5, IN); + SetMode(PIN_DT6, IN); + SetMode(PIN_DT7, IN); + SetMode(PIN_DP, IN); + } else { + SetControl(PIN_DTD, DTD_OUT); + SetMode(PIN_DT0, OUT); + SetMode(PIN_DT1, OUT); + SetMode(PIN_DT2, OUT); + SetMode(PIN_DT3, OUT); + SetMode(PIN_DT4, OUT); + SetMode(PIN_DT5, OUT); + SetMode(PIN_DT6, OUT); + SetMode(PIN_DT7, OUT); + SetMode(PIN_DP, OUT); + } + } + + return ast; +} + +//--------------------------------------------------------------------------- +// +// IO繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetIO(BOOL ast) +{ + SetSignal(PIN_IO, ast); + + if (actmode == TARGET) { + // IO菫｡蜿ｷ縺ｫ繧医▲縺ｦ繝繝ｼ繧ｿ縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ螟画峩 + if (ast) { + SetControl(PIN_DTD, DTD_OUT); + SetMode(PIN_DT0, OUT); + SetMode(PIN_DT1, OUT); + SetMode(PIN_DT2, OUT); + SetMode(PIN_DT3, OUT); + SetMode(PIN_DT4, OUT); + SetMode(PIN_DT5, OUT); + SetMode(PIN_DT6, OUT); + SetMode(PIN_DT7, OUT); + SetMode(PIN_DP, OUT); + } else { + SetControl(PIN_DTD, DTD_IN); + SetMode(PIN_DT0, IN); + SetMode(PIN_DT1, IN); + SetMode(PIN_DT2, IN); + SetMode(PIN_DT3, IN); + SetMode(PIN_DT4, IN); + SetMode(PIN_DT5, IN); + SetMode(PIN_DT6, IN); + SetMode(PIN_DT7, IN); + SetMode(PIN_DP, IN); + } + } +} + +//--------------------------------------------------------------------------- +// +// REQ繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BOOL FASTCALL GPIOBUS::GetREQ() +{ + return GetSignal(PIN_REQ); +} + +//--------------------------------------------------------------------------- +// +// REQ繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetREQ(BOOL ast) +{ + SetSignal(PIN_REQ, ast); +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν蜿門ｾ +// +//--------------------------------------------------------------------------- +BYTE FASTCALL GPIOBUS::GetDAT() +{ + DWORD data; + + data = Aquire(); + data = + ((data >> (PIN_DT0 - 0)) & (1 << 0)) | + ((data >> (PIN_DT1 - 1)) & (1 << 1)) | + ((data >> (PIN_DT2 - 2)) & (1 << 2)) | + ((data >> (PIN_DT3 - 3)) & (1 << 3)) | + ((data >> (PIN_DT4 - 4)) & (1 << 4)) | + ((data >> (PIN_DT5 - 5)) & (1 << 5)) | + ((data >> (PIN_DT6 - 6)) & (1 << 6)) | + ((data >> (PIN_DT7 - 7)) & (1 << 7)); + + return (BYTE)data; +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +void FASTCALL GPIOBUS::SetDAT(BYTE dat) +{ + // 繝昴ｼ繝医∈譖ｸ縺崎ｾｼ縺ｿ +#if SIGNAL_CONTROL_MODE == 0 + gpfsel[0] &= tblDatMsk[0][dat]; + gpfsel[0] |= tblDatSet[0][dat]; + gpio[GPIO_FSEL_0] = gpfsel[0]; + + gpfsel[1] &= tblDatMsk[1][dat]; + gpfsel[1] |= tblDatSet[1][dat]; + gpio[GPIO_FSEL_1] = gpfsel[1]; + + gpfsel[2] &= tblDatMsk[2][dat]; + gpfsel[2] |= tblDatSet[2][dat]; + gpio[GPIO_FSEL_2] = gpfsel[2]; +#else + gpio[GPIO_CLR_0] = tblDatMsk[dat]; + gpio[GPIO_SET_0] = tblDatSet[dat]; +#endif +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ蜿嶺ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ +// +//--------------------------------------------------------------------------- +int FASTCALL GPIOBUS::ReceiveHandShake(BYTE *buf, int count) +{ + int i; + DWORD loop; + DWORD phase; + + if (drvfd >= 0) { + return read(drvfd, buf, count); + } else { + if (actmode == TARGET) { + for (i = 0; i < count; i++) { + // REQ繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_REQ, ON); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // 繝繝ｼ繧ｿ蜿門ｾ + *buf = GetDAT(); + + // REQ繝阪ご繝ｼ繝 + SetSignal(PIN_REQ, OFF); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + + // 蜿嶺ｿ｡謨ｰ繧定ｿ泌唆 + return i; + } else { + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + phase = signals & GPIO_MCI; + + for (i = 0; i < count; i++) { + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 繝繝ｼ繧ｿ蜿門ｾ + *buf = GetDAT(); + + // ACK繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_ACK, ON); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // ACK繝阪ご繝ｼ繝 + SetSignal(PIN_ACK, OFF); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + + // 蜿嶺ｿ｡謨ｰ繧定ｿ泌唆 + return i; + } + } +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ騾∽ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ +// +//--------------------------------------------------------------------------- +int FASTCALL GPIOBUS::SendHandShake(BYTE *buf, int count) +{ + int i; + DWORD loop; + DWORD phase; + + if (drvfd >= 0) { + return write(drvfd, buf, count); + } else { + if (actmode == TARGET) { + for (i = 0; i < count; i++) { + // 繝繝ｼ繧ｿ險ｭ螳 + SetDAT(*buf); + + // 菫｡蜿ｷ邱壹′螳牙ｮ壹☆繧九∪縺ｧ繧ｦ繧ｧ繧､繝 + SleepNsec(150); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // REQ繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_REQ, ON); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // REQ繝阪ご繝ｼ繝 + SetSignal(PIN_REQ, OFF); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // 騾∽ｿ｡謨ｰ繧定ｿ泌唆 + return i; + } else { + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + phase = signals & GPIO_MCI; + + for (i = 0; i < count; i++) { + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 繝繝ｼ繧ｿ險ｭ螳 + SetDAT(*buf); + + // 菫｡蜿ｷ邱壹′螳牙ｮ壹☆繧九∪縺ｧ繧ｦ繧ｧ繧､繝 + SleepNsec(150); + + // ACK繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_ACK, ON); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // ACK繝阪ご繝ｼ繝 + SetSignal(PIN_ACK, OFF); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + + // 騾∽ｿ｡謨ｰ繧定ｿ泌唆 + return i; + } + } +} + +//--------------------------------------------------------------------------- +// +// 菫｡蜿ｷ繝繝ｼ繝悶Ν +// +//--------------------------------------------------------------------------- +const int GPIOBUS::SignalTable[19] = { + PIN_DT0, PIN_DT1, PIN_DT2, PIN_DT3, + PIN_DT4, PIN_DT5, PIN_DT6, PIN_DT7, PIN_DP, + PIN_SEL,PIN_ATN, PIN_RST, PIN_ACK, + PIN_BSY, PIN_MSG, PIN_CD, PIN_IO, PIN_REQ, + -1 +}; diff --git a/src/raspberrypi/gpiobus.h b/src/raspberrypi/gpiobus.h new file mode 100644 index 00000000..82f556f6 --- /dev/null +++ b/src/raspberrypi/gpiobus.h @@ -0,0 +1,479 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ GPIO-SCSI繝舌せ ] +// +//--------------------------------------------------------------------------- + +#if !defined(gpiobus_h) +#define gpiobus_h + +#include "scsi.h" + +//--------------------------------------------------------------------------- +// +// 謗･邯壽婿豕募ｮ夂ｾｩ縺ｮ驕ｸ謚 +// +//--------------------------------------------------------------------------- +#define CONNECT_TYPE_STANDARD // 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_FULLSPEC // 繝輔Ν繧ｹ繝壹ャ繧ｯ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_AIBOM // AIBOM迚(豁｣隲也炊,蝗ｺ譛峨ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_GAMERNIUM // GAMERnium.com迚(讓呎ｺ冶ｫ也炊,蝗ｺ譛峨ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) + +//--------------------------------------------------------------------------- +// +// 菫｡蜿ｷ蛻ｶ蠕｡隲也炊蜿翫ｳ繝斐Φ繧｢繧ｵ繧､繝ｳ繧ｫ繧ｹ繧ｿ繝槭う繧ｺ +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// SIGNAL_CONTROL_MODE:菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +// Version1.22縺九ｉ菫｡蜿ｷ蛻ｶ蠕｡縺ｮ隲也炊繧偵き繧ｹ繧ｿ繝槭う繧ｺ縺ｧ縺阪∪縺吶 +// +// 0:SCSI隲也炊莉墓ｧ +// 逶ｴ邨舌∪縺溘ｯHP縺ｫ蜈ｬ髢九＠縺74LS641-1遲峨ｒ菴ｿ逕ｨ縺吶ｋ螟画鋤蝓ｺ譚ｿ +// 繧｢繝ｼ繧ｵ繝ｼ繝:0V +// 繝阪ご繝ｼ繝 :繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉(繝舌せ縺九ｉ蛻繧企屬縺) +// +// 1:雋隲也炊莉墓ｧ(雋隲也炊->SCSI隲也炊縺ｸ縺ｮ螟画鋤蝓ｺ譚ｿ繧剃ｽｿ逕ｨ縺吶ｋ蝣ｴ蜷) +// 迴ｾ譎らせ縺ｧ縺薙ｮ莉墓ｧ倥↓繧医ｋ螟画鋤蝓ｺ譚ｿ縺ｯ蟄伜惠縺励∪縺帙ｓ +// 繧｢繝ｼ繧ｵ繝ｼ繝:0V -> (CONVERT) -> 0V +// 繝阪ご繝ｼ繝 :3.3V -> (CONVERT) -> 繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉 +// +// 2:豁｣隲也炊莉墓ｧ(豁｣隲也炊->SCSI隲也炊縺ｸ縺ｮ螟画鋤蝓ｺ譚ｿ繧剃ｽｿ逕ｨ縺吶ｋ蝣ｴ蜷) +// RaSCSI Adapter Rev.C @132sync遲 +// +// 繧｢繝ｼ繧ｵ繝ｼ繝:3.3V -> (CONVERT) -> 0V +// 繝阪ご繝ｼ繝 :0V -> (CONVERT) -> 繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ險ｭ螳 +// 蛻ｶ蠕｡菫｡蜿ｷ縺ｫ蟇ｾ縺吶ｋGPIO繝斐Φ縺ｮ繝槭ャ繝斐Φ繧ｰ繝繝ｼ繝悶Ν縺ｧ縺吶 +// +// 蛻ｶ蠕｡菫｡蜿ｷ +// PIN_ACT +// SCSI繧ｳ繝槭Φ繝峨ｒ蜃ｦ逅荳ｭ縺ｮ迥ｶ諷九ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_ENB +// 襍ｷ蜍輔°繧臥ｵゆｺ縺ｮ髢薙ｮ譛牙柑菫｡蜿ｷ繧堤､ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_TAD +// 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ(BSY,IO,CD,MSG,REG)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_IND +// 繧､繝九す繝ｼ繧ｨ繝ｼ繧ｿ菫｡蜿ｷ(SEL,ATN,RST,ACK)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_DTD +// 繝繝ｼ繧ｿ菫｡蜿ｷ(DT0...DT7,DP)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +// 0V:FALSE 3.3V:TRUE縺ｧ謖螳壹＠縺ｾ縺吶 +// +// ACT_ON +// PIN_ACT菫｡蜿ｷ縺ｮ隲也炊縺ｧ縺吶 +// ENB_ON +// PIN_ENB菫｡蜿ｷ縺ｮ隲也炊縺ｧ縺吶 +// TAD_IN +// PIN_TAD蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// IND_IN +// PIN_ENB蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// DTD_IN +// PIN_ENB蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ險ｭ螳 +// SCSI縺ｮ菫｡蜿ｷ縺ｫ蟇ｾ縺吶ｋGPIO繝斐Φ縺ｮ繝槭ャ繝斐Φ繧ｰ繝繝ｼ繝悶Ν縺ｧ縺吶 +// PIN_DT0ｽ霸IN_SEL +// +//--------------------------------------------------------------------------- + +#ifdef CONNECT_TYPE_STANDARD +// +// RaSCSI 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +// +#define CONNECT_DESC "STANDARD" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 5 // ENABLE +#define PIN_IND -1 // INITIATOR CTRL DIRECTION +#define PIN_TAD -1 // TARGET CTRL DIRECTION +#define PIN_DTD -1 // DATA DIRECTION + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 10 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 11 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 12 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 13 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 14 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 15 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 16 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 17 // 繝繝ｼ繧ｿ7 +#define PIN_DP 18 // 繝代Μ繝繧｣ +#define PIN_ATN 19 // ATN +#define PIN_RST 20 // RST +#define PIN_ACK 21 // ACK +#define PIN_REQ 22 // REQ +#define PIN_MSG 23 // MSG +#define PIN_CD 24 // CD +#define PIN_IO 25 // IO +#define PIN_BSY 26 // BSY +#define PIN_SEL 27 // SEL +#endif + +#ifdef CONNECT_TYPE_FULLSPEC +// +// RaSCSI 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +// +#define CONNECT_DESC "FULLSPEC" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 5 // ENABLE +#define PIN_IND 6 // INITIATOR CTRL DIRECTION +#define PIN_TAD 7 // TARGET CTRL DIRECTION +#define PIN_DTD 8 // DATA DIRECTION + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 10 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 11 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 12 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 13 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 14 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 15 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 16 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 17 // 繝繝ｼ繧ｿ7 +#define PIN_DP 18 // 繝代Μ繝繧｣ +#define PIN_ATN 19 // ATN +#define PIN_RST 20 // RST +#define PIN_ACK 21 // ACK +#define PIN_REQ 22 // REQ +#define PIN_MSG 23 // MSG +#define PIN_CD 24 // CD +#define PIN_IO 25 // IO +#define PIN_BSY 26 // BSY +#define PIN_SEL 27 // SEL +#endif + +#ifdef CONNECT_TYPE_AIBOM +// +// RaSCSI Adapter 縺ゅ＞縺ｼ繧迚 +// + +#define CONNECT_DESC "AIBOM PRODUCTS version" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 2 // SCSI豁｣隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN FALSE // DATA SIGNAL INPUT + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 17 // ENABLE +#define PIN_IND 27 // INITIATOR CTRL DIRECTION +#define PIN_TAD -1 // TARGET CTRL DIRECTION +#define PIN_DTD 18 // DATA DIRECTION + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 6 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 12 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 13 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 16 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 19 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 20 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 26 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 21 // 繝繝ｼ繧ｿ7 +#define PIN_DP 5 // 繝代Μ繝繧｣ +#define PIN_ATN 22 // ATN +#define PIN_RST 25 // RST +#define PIN_ACK 10 // ACK +#define PIN_REQ 7 // REQ +#define PIN_MSG 9 // MSG +#define PIN_CD 11 // CD +#define PIN_IO 23 // IO +#define PIN_BSY 24 // BSY +#define PIN_SEL 8 // SEL +#endif + +#ifdef CONNECT_TYPE_GAMERNIUM +// +// RaSCSI Adapter GAMERnium.com迚 +// + +#define CONNECT_DESC "GAMERnium.com version"// 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 14 // ACTIVE +#define PIN_ENB 6 // ENABLE +#define PIN_IND 7 // INITIATOR CTRL DIRECTION +#define PIN_TAD 8 // TARGET CTRL DIRECTION +#define PIN_DTD 5 // DATA DIRECTION + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 21 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 26 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 20 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 19 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 16 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 13 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 12 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 11 // 繝繝ｼ繧ｿ7 +#define PIN_DP 25 // 繝代Μ繝繧｣ +#define PIN_ATN 10 // ATN +#define PIN_RST 22 // RST +#define PIN_ACK 24 // ACK +#define PIN_REQ 15 // REQ +#define PIN_MSG 17 // MSG +#define PIN_CD 18 // CD +#define PIN_IO 4 // IO +#define PIN_BSY 27 // BSY +#define PIN_SEL 23 // SEL +#endif + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(GPIO) +// +//--------------------------------------------------------------------------- +#define GPIO_OFFSET 0x200000 +#define PADS_OFFSET 0x100000 +#define GPIO_INPUT 0 +#define GPIO_OUTPUT 1 +#define GPIO_PULLNONE 0 +#define GPIO_PULLDOWN 1 +#define GPIO_PULLUP 2 +#define GPIO_FSEL_0 0 +#define GPIO_FSEL_1 1 +#define GPIO_FSEL_2 2 +#define GPIO_FSEL_3 3 +#define GPIO_SET_0 7 +#define GPIO_CLR_0 10 +#define GPIO_LEV_0 13 +#define GPIO_EDS_0 16 +#define GPIO_REN_0 19 +#define GPIO_FEN_0 22 +#define GPIO_HEN_0 25 +#define GPIO_LEN_0 28 +#define GPIO_AREN_0 31 +#define GPIO_AFEN_0 34 +#define GPIO_PUD 37 +#define GPIO_CLK_0 38 +#define PAD_0_27 11 + +#define GPIO_INEDGE ((1 << PIN_BSY) | \ + (1 << PIN_SEL) | \ + (1 << PIN_ATN) | \ + (1 << PIN_ACK) | \ + (1 << PIN_RST)) + +#define GPIO_MCI ((1 << PIN_MSG) | \ + (1 << PIN_CD) | \ + (1 << PIN_IO)) + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(蛻ｶ蠕｡菫｡蜿ｷ) +// +//--------------------------------------------------------------------------- +#define ACT_OFF !ACT_ON +#define ENB_OFF !ENB_ON +#define TAD_OUT !TAD_IN +#define IND_OUT !IND_IN +#define DTD_OUT !DTD_IN + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(SCSI) +// +//--------------------------------------------------------------------------- +#define IN GPIO_INPUT +#define OUT GPIO_OUTPUT +#define ON TRUE +#define OFF FALSE + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(繝峨Λ繧､繝) +// +//--------------------------------------------------------------------------- +#define DEVICE_NAME "rascsidrv" +#define DRIVER_PATH "/dev/" DEVICE_NAME +#define IOCTL_INIT 0x100 +#define IOCTL_MODE 0x101 +#define IOCTL_PADS 0x102 + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｩ繧ｹ螳夂ｾｩ +// +//--------------------------------------------------------------------------- +class GPIOBUS : public BUS +{ +public: + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + GPIOBUS(); + // 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ + virtual ~GPIOBUS(); + // 繝繧ｹ繝医Λ繧ｯ繧ｿ + BOOL FASTCALL Init(mode_e mode = TARGET); + // 蛻晄悄蛹 + void FASTCALL Reset(); + // 繝ｪ繧ｻ繝繝 + void FASTCALL Cleanup(); + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + + DWORD FASTCALL Aquire(); + // 菫｡蜿ｷ蜿悶ｊ霎ｼ縺ｿ + + BOOL FASTCALL GetBSY(); + // BSY繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetBSY(BOOL ast); + // BSY繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetSEL(); + // SEL繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetSEL(BOOL ast); + // SEL繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetATN(); + // ATN繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetATN(BOOL ast); + // ATN繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetACK(); + // ACK繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetACK(BOOL ast); + // ACK繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetRST(); + // RST繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetRST(BOOL ast); + // RST繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetMSG(); + // MSG繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetMSG(BOOL ast); + // MSG繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetCD(); + // CD繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetCD(BOOL ast); + // CD繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetIO(); + // IO繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetIO(BOOL ast); + // IO繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BOOL FASTCALL GetREQ(); + // REQ繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetREQ(BOOL ast); + // REQ繧ｷ繧ｰ繝翫Ν險ｭ螳 + + BYTE FASTCALL GetDAT(); + // 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν蜿門ｾ + void FASTCALL SetDAT(BYTE dat); + // 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν險ｭ螳 + int FASTCALL ReceiveHandShake(BYTE *buf, int count); + // 繝繝ｼ繧ｿ蜿嶺ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ + int FASTCALL SendHandShake(BYTE *buf, int count); + // 繝繝ｼ繧ｿ騾∽ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ + + // 繧ｿ繧､繝樣未菫 + void FASTCALL SleepNsec(DWORD nsec); + // 繝翫ヮ遘貞腰菴阪ｮ繧ｹ繝ｪ繝ｼ繝 + +private: + void FASTCALL DrvConfig(DWORD drive); + // GPIO繝峨Λ繧､繝冶ｽ蜉幄ｨｭ螳 + void FASTCALL PinConfig(int pin, int mode); + // GPIO繝斐Φ讖溯ｽ險ｭ螳(蜈･蜃ｺ蜉幄ｨｭ螳) + void FASTCALL PullConfig(int pin, int mode); + // GPIO繝斐Φ讖溯ｽ險ｭ螳(繝励Ν繧｢繝繝/繝繧ｦ繝ｳ) + void FASTCALL PinSetSignal(int pin, BOOL ast); + // GPIO繝斐Φ蜃ｺ蜉帑ｿ｡蜿ｷ險ｭ螳 + void FASTCALL MakeTable(); + // 繝ｯ繝ｼ繧ｯ繝繝ｼ繝悶Ν菴懈 + void FASTCALL SetControl(int pin, BOOL ast); + // 蛻ｶ蠕｡菫｡蜿ｷ險ｭ螳 + void FASTCALL SetMode(int pin, int mode); + // SCSI蜈･蜃ｺ蜉帙Δ繝ｼ繝芽ｨｭ螳 + BOOL FASTCALL GetSignal(int pin); + // SCSI蜈･蜉帑ｿ｡蜿ｷ蛟､蜿門ｾ + void FASTCALL SetSignal(int pin, BOOL ast); + // SCSI蜃ｺ蜉帑ｿ｡蜿ｷ蛟､險ｭ螳 + + mode_e actmode; // 蜍穂ｽ懊Δ繝ｼ繝 + + volatile DWORD *gpio; // GPIO繝ｬ繧ｸ繧ｹ繧ｿ + + volatile DWORD *pads; // PADS繝ｬ繧ｸ繧ｹ繧ｿ + + volatile DWORD *level; // GPIO蜈･蜉帙Ξ繝吶Ν + + DWORD gpfsel[4]; // GPFSEL0-4繝舌ャ繧ｯ繧｢繝繝 + + DWORD signals; // 繝舌せ蜈ｨ菫｡蜿ｷ + +#if SIGNAL_CONTROL_MODE == 0 + DWORD tblDatMsk[3][256]; // 繝繝ｼ繧ｿ繝槭せ繧ｯ逕ｨ繝繝ｼ繝悶Ν + + DWORD tblDatSet[3][256]; // 繝繝ｼ繧ｿ險ｭ螳夂畑繝繝ｼ繝悶Ν +#else + DWORD tblDatMsk[256]; // 繝繝ｼ繧ｿ繝槭せ繧ｯ逕ｨ繝繝ｼ繝悶Ν + + DWORD tblDatSet[256]; // 繝繝ｼ繧ｿ險ｭ螳夂畑繝繝ｼ繝悶Ν +#endif + + int drvfd; // 繧ｫ繝ｼ繝阪Ν繝峨Λ繧､繝舌ヵ繧｡繧､繝ｫ繝繧｣繧ｹ繧ｯ繝励Μ繧ｿ + + static const int SignalTable[19]; // 繧ｷ繧ｰ繝翫Ν繝繝ｼ繝悶Ν +}; + +#endif // gpiobus_h diff --git a/src/raspberrypi/kernelmodule/Makefile b/src/raspberrypi/kernelmodule/Makefile new file mode 100644 index 00000000..5ed61fdc --- /dev/null +++ b/src/raspberrypi/kernelmodule/Makefile @@ -0,0 +1,9 @@ +KERNEL_HEADERS=/lib/modules/$(shell uname -r)/build +obj-m := rascsidrv.o +ccflags-y := -O3 + +all: + $(MAKE) -C $(KERNEL_HEADERS) M=$(PWD) modules + +clean: + $(MAKE) -C $(KERNEL_HEADERS) M=$(PWD) clean diff --git a/src/raspberrypi/kernelmodule/rascsidrv.c b/src/raspberrypi/kernelmodule/rascsidrv.c new file mode 100644 index 00000000..9dd239f9 --- /dev/null +++ b/src/raspberrypi/kernelmodule/rascsidrv.c @@ -0,0 +1,1122 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ GPIO繝峨Λ繧､繝 ] +// +//--------------------------------------------------------------------------- + +#include +#include +#include +#include +#include + +//--------------------------------------------------------------------------- +// +// 蝓ｺ譛ｬ蝙句ｮ夂ｾｩ +// +//--------------------------------------------------------------------------- +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned long DWORD; +typedef int BOOL; + +#if !defined(FALSE) +#define FALSE 0 +#endif + +#if !defined(TRUE) +#define TRUE 1 +#endif + +//--------------------------------------------------------------------------- +// +// 謗･邯壽婿豕募ｮ夂ｾｩ縺ｮ驕ｸ謚 +// +//--------------------------------------------------------------------------- +#define CONNECT_TYPE_STANDARD // 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_FULLSPEC // 繝輔Ν繧ｹ繝壹ャ繧ｯ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_AIBOM // AIBOM迚(豁｣隲也炊,蝗ｺ譛峨ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +//#define CONNECT_TYPE_GAMERNIUM // GAMERnium.com迚(讓呎ｺ冶ｫ也炊,蝗ｺ譛峨ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) + +//--------------------------------------------------------------------------- +// +// 菫｡蜿ｷ蛻ｶ蠕｡隲也炊蜿翫ｳ繝斐Φ繧｢繧ｵ繧､繝ｳ繧ｫ繧ｹ繧ｿ繝槭う繧ｺ +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// SIGNAL_CONTROL_MODE:菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +// Version1.22縺九ｉ菫｡蜿ｷ蛻ｶ蠕｡縺ｮ隲也炊繧偵き繧ｹ繧ｿ繝槭う繧ｺ縺ｧ縺阪∪縺吶 +// +// 0:SCSI隲也炊莉墓ｧ +// 逶ｴ邨舌∪縺溘ｯHP縺ｫ蜈ｬ髢九＠縺74LS641-1遲峨ｒ菴ｿ逕ｨ縺吶ｋ螟画鋤蝓ｺ譚ｿ +// 繧｢繝ｼ繧ｵ繝ｼ繝:0V +// 繝阪ご繝ｼ繝 :繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉(繝舌せ縺九ｉ蛻繧企屬縺) +// +// 1:雋隲也炊莉墓ｧ(雋隲也炊->SCSI隲也炊縺ｸ縺ｮ螟画鋤蝓ｺ譚ｿ繧剃ｽｿ逕ｨ縺吶ｋ蝣ｴ蜷) +// 迴ｾ譎らせ縺ｧ縺薙ｮ莉墓ｧ倥↓繧医ｋ螟画鋤蝓ｺ譚ｿ縺ｯ蟄伜惠縺励∪縺帙ｓ +// 繧｢繝ｼ繧ｵ繝ｼ繝:0V -> (CONVERT) -> 0V +// 繝阪ご繝ｼ繝 :3.3V -> (CONVERT) -> 繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉 +// +// 2:豁｣隲也炊莉墓ｧ(豁｣隲也炊->SCSI隲也炊縺ｸ縺ｮ螟画鋤蝓ｺ譚ｿ繧剃ｽｿ逕ｨ縺吶ｋ蝣ｴ蜷) +// RaSCSI Adapter Rev.C @132sync遲 +// +// 繧｢繝ｼ繧ｵ繝ｼ繝:3.3V -> (CONVERT) -> 0V +// 繝阪ご繝ｼ繝 :0V -> (CONVERT) -> 繧ｪ繝ｼ繝励Φ繧ｳ繝ｬ繧ｯ繧ｿ蜃ｺ蜉 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ險ｭ螳 +// 蛻ｶ蠕｡菫｡蜿ｷ縺ｫ蟇ｾ縺吶ｋGPIO繝斐Φ縺ｮ繝槭ャ繝斐Φ繧ｰ繝繝ｼ繝悶Ν縺ｧ縺吶 +// +// 蛻ｶ蠕｡菫｡蜿ｷ +// PIN_ACT +// SCSI繧ｳ繝槭Φ繝峨ｒ蜃ｦ逅荳ｭ縺ｮ迥ｶ諷九ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_ENB +// 襍ｷ蜍輔°繧臥ｵゆｺ縺ｮ髢薙ｮ譛牙柑菫｡蜿ｷ繧堤､ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_TAD +// 繧ｿ繝ｼ繧ｲ繝繝井ｿ｡蜿ｷ(BSY,IO,CD,MSG,REG)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_IND +// 繧､繝九す繝ｼ繧ｨ繝ｼ繧ｿ菫｡蜿ｷ(SEL,ATN,RST,ACK)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// PIN_DTD +// 繝繝ｼ繧ｿ菫｡蜿ｷ(DT0...DT7,DP)縺ｮ蜈･蜃ｺ蜉帶婿蜷代ｒ遉ｺ縺吩ｿ｡蜿ｷ縺ｮ繝斐Φ逡ｪ蜿ｷ縲 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +// 0V:FALSE 3.3V:TRUE縺ｧ謖螳壹＠縺ｾ縺吶 +// +// ACT_ON +// PIN_ACT菫｡蜿ｷ縺ｮ隲也炊縺ｧ縺吶 +// ENB_ON +// PIN_ENB菫｡蜿ｷ縺ｮ隲也炊縺ｧ縺吶 +// TAD_IN +// PIN_TAD蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// IND_IN +// PIN_ENB蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// DTD_IN +// PIN_ENB蜈･蜉帶婿蜷第凾縺ｮ隲也炊縺ｧ縺吶 +// +//--------------------------------------------------------------------------- + +//--------------------------------------------------------------------------- +// +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ險ｭ螳 +// SCSI縺ｮ菫｡蜿ｷ縺ｫ蟇ｾ縺吶ｋGPIO繝斐Φ縺ｮ繝槭ャ繝斐Φ繧ｰ繝繝ｼ繝悶Ν縺ｧ縺吶 +// PIN_DT0ｽ霸IN_SEL +// +//--------------------------------------------------------------------------- + +#ifdef CONNECT_TYPE_STANDARD +// +// RaSCSI 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +// +#define CONNECT_DESC "STANDARD" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 5 // ENABLE +#define PIN_IND -1 // INITIATOR CTRL DIRECTION +#define PIN_TAD -1 // TARGET CTRL DIRECTION +#define PIN_DTD -1 // DATA DIRECTION + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 10 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 11 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 12 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 13 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 14 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 15 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 16 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 17 // 繝繝ｼ繧ｿ7 +#define PIN_DP 18 // 繝代Μ繝繧｣ +#define PIN_ATN 19 // ATN +#define PIN_RST 20 // RST +#define PIN_ACK 21 // ACK +#define PIN_REQ 22 // REQ +#define PIN_MSG 23 // MSG +#define PIN_CD 24 // CD +#define PIN_IO 25 // IO +#define PIN_BSY 26 // BSY +#define PIN_SEL 27 // SEL +#endif + +#ifdef CONNECT_TYPE_FULLSPEC +// +// RaSCSI 讓呎ｺ(SCSI隲也炊,讓呎ｺ悶ヴ繝ｳ繧｢繧ｵ繧､繝ｳ) +// +#define CONNECT_DESC "FULLSPEC" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 5 // ENABLE +#define PIN_IND 6 // INITIATOR CTRL DIRECTION +#define PIN_TAD 7 // TARGET CTRL DIRECTION +#define PIN_DTD 8 // DATA DIRECTION + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 10 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 11 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 12 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 13 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 14 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 15 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 16 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 17 // 繝繝ｼ繧ｿ7 +#define PIN_DP 18 // 繝代Μ繝繧｣ +#define PIN_ATN 19 // ATN +#define PIN_RST 20 // RST +#define PIN_ACK 21 // ACK +#define PIN_REQ 22 // REQ +#define PIN_MSG 23 // MSG +#define PIN_CD 24 // CD +#define PIN_IO 25 // IO +#define PIN_BSY 26 // BSY +#define PIN_SEL 27 // SEL +#endif + +#ifdef CONNECT_TYPE_AIBOM +// +// RaSCSI Adapter 縺ゅ＞縺ｼ繧迚 +// + +#define CONNECT_DESC "AIBOM PRODUCTS version" // 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 2 // SCSI豁｣隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN FALSE // DATA SIGNAL INPUT + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 4 // ACTIVE +#define PIN_ENB 17 // ENABLE +#define PIN_IND 27 // INITIATOR CTRL DIRECTION +#define PIN_TAD -1 // TARGET CTRL DIRECTION +#define PIN_DTD 18 // DATA DIRECTION + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 6 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 12 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 13 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 16 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 19 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 20 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 26 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 21 // 繝繝ｼ繧ｿ7 +#define PIN_DP 5 // 繝代Μ繝繧｣ +#define PIN_ATN 22 // ATN +#define PIN_RST 25 // RST +#define PIN_ACK 10 // ACK +#define PIN_REQ 7 // REQ +#define PIN_MSG 9 // MSG +#define PIN_CD 11 // CD +#define PIN_IO 23 // IO +#define PIN_BSY 24 // BSY +#define PIN_SEL 8 // SEL +#endif + +#ifdef CONNECT_TYPE_GAMERNIUM +// +// RaSCSI Adapter GAMERnium.com迚 +// + +#define CONNECT_DESC "GAMERnium.com version"// 襍ｷ蜍墓凾繝｡繝繧ｻ繝ｼ繧ｸ + +// 菫｡蜿ｷ蛻ｶ蠕｡繝｢繝ｼ繝蛾∈謚 +#define SIGNAL_CONTROL_MODE 0 // SCSI隲也炊莉墓ｧ + +// 蛻ｶ蠕｡菫｡蜿ｷ蜃ｺ蜉幄ｫ也炊 +#define ACT_ON TRUE // ACTIVE SIGNAL ON +#define ENB_ON TRUE // ENABLE SIGNAL ON +#define IND_IN FALSE // INITIATOR SIGNAL INPUT +#define TAD_IN FALSE // TARGET SIGNAL INPUT +#define DTD_IN TRUE // DATA SIGNAL INPUT + +// 蛻ｶ蠕｡菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ(-1縺ｮ蝣ｴ蜷医ｯ蛻ｶ蠕｡辟｡縺) +#define PIN_ACT 14 // ACTIVE +#define PIN_ENB 6 // ENABLE +#define PIN_IND 7 // INITIATOR CTRL DIRECTION +#define PIN_TAD 8 // TARGET CTRL DIRECTION +#define PIN_DTD 5 // DATA DIRECTION + +// SCSI菫｡蜿ｷ繝斐Φ繧｢繧ｵ繧､繝ｳ +#define PIN_DT0 21 // 繝繝ｼ繧ｿ0 +#define PIN_DT1 26 // 繝繝ｼ繧ｿ1 +#define PIN_DT2 20 // 繝繝ｼ繧ｿ2 +#define PIN_DT3 19 // 繝繝ｼ繧ｿ3 +#define PIN_DT4 16 // 繝繝ｼ繧ｿ4 +#define PIN_DT5 13 // 繝繝ｼ繧ｿ5 +#define PIN_DT6 12 // 繝繝ｼ繧ｿ6 +#define PIN_DT7 11 // 繝繝ｼ繧ｿ7 +#define PIN_DP 25 // 繝代Μ繝繧｣ +#define PIN_ATN 10 // ATN +#define PIN_RST 22 // RST +#define PIN_ACK 24 // ACK +#define PIN_REQ 15 // REQ +#define PIN_MSG 17 // MSG +#define PIN_CD 18 // CD +#define PIN_IO 4 // IO +#define PIN_BSY 27 // BSY +#define PIN_SEL 23 // SEL +#endif + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(GPIO) +// +//--------------------------------------------------------------------------- +#define GPIO_OFFSET 0x200000 +#define PADS_OFFSET 0x100000 +#define GPIO_INPUT 0 +#define GPIO_OUTPUT 1 +#define GPIO_PULLNONE 0 +#define GPIO_PULLDOWN 1 +#define GPIO_PULLUP 2 +#define GPIO_FSEL_0 0 +#define GPIO_FSEL_1 1 +#define GPIO_FSEL_2 2 +#define GPIO_FSEL_3 3 +#define GPIO_SET_0 7 +#define GPIO_CLR_0 10 +#define GPIO_LEV_0 13 +#define GPIO_EDS_0 16 +#define GPIO_REN_0 19 +#define GPIO_FEN_0 22 +#define GPIO_HEN_0 25 +#define GPIO_LEN_0 28 +#define GPIO_AREN_0 31 +#define GPIO_AFEN_0 34 +#define GPIO_PUD 37 +#define GPIO_CLK_0 38 +#define PAD_0_27 11 + +#define GPIO_INEDGE ((1 << PIN_BSY) | \ + (1 << PIN_SEL) | \ + (1 << PIN_ATN) | \ + (1 << PIN_ACK) | \ + (1 << PIN_RST)) + +#define GPIO_MCI ((1 << PIN_MSG) | \ + (1 << PIN_CD) | \ + (1 << PIN_IO)) + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(蛻ｶ蠕｡菫｡蜿ｷ) +// +//--------------------------------------------------------------------------- +#define ACT_OFF !ACT_ON +#define ENB_OFF !ENB_ON +#define TAD_OUT !TAD_IN +#define IND_OUT !IND_IN +#define DTD_OUT !DTD_IN + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(SCSI) +// +//--------------------------------------------------------------------------- +#define IN GPIO_INPUT +#define OUT GPIO_OUTPUT +#define ON TRUE +#define OFF FALSE + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險(繝峨Λ繧､繝) +// +//--------------------------------------------------------------------------- +#define DEVICE_NAME "rascsidrv" +#define DRIVER_PATH "/dev/" DEVICE_NAME +#define IOCTL_INIT 0x100 +#define IOCTL_MODE 0x101 +#define IOCTL_PADS 0x102 + +//--------------------------------------------------------------------------- +// +// 蜍穂ｽ懊Δ繝ｼ繝 +// +//--------------------------------------------------------------------------- +enum mode_e { + TARGET = 0, + INITIATOR = 1, + MONITOR = 2, +}; + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝宣未謨ｰ螳｣險 +// +//--------------------------------------------------------------------------- +static int drv_init(void); +static void drv_exit(void); + +//--------------------------------------------------------------------------- +// +// 繧ｨ繝ｳ繝医Μ繝昴う繝ｳ繝亥ｮ｣險 +// +//--------------------------------------------------------------------------- +int drv_open(struct inode *inode, struct file *file); +int drv_close(struct inode *inode, struct file *file); +long drv_ioctl(struct file *file, unsigned int cmd, unsigned long arg); +ssize_t drv_read( + struct file *file, char __user *buf, size_t count, loff_t *fops); +ssize_t drv_write( + struct file *file, const char __user *buf, size_t count, loff_t *fops); +struct file_operations drv_fops = { + .open = drv_open, + .release = drv_close, + .unlocked_ioctl = drv_ioctl, + .read = drv_read, + .write = drv_write, +}; + +//--------------------------------------------------------------------------- +// +// 螟画焚螳｣險(繝峨Λ繧､繝千匳骭ｲ) +// +//--------------------------------------------------------------------------- +static dev_t drv_dev; +static dev_t drv_devno; +static struct cdev drv_cdev; +static struct class *drv_class; + +//--------------------------------------------------------------------------- +// +// 螟画焚螳｣險(GPIO蛻ｶ蠕｡) +// +//--------------------------------------------------------------------------- +static DWORD baseaddr; // BASE繧｢繝峨Ξ繧ｹ +static volatile DWORD *gpio; // GPIO繝ｬ繧ｸ繧ｹ繧ｿ +static volatile DWORD *level; // GPIO繝ｬ繧ｸ繧ｹ繧ｿ(繝ｬ繝吶Ν) +static volatile DWORD *pads; // PADS繝ｬ繧ｸ繧ｹ繧ｿ + +#if SIGNAL_CONTROL_MODE == 0 +static DWORD gpfsel[4]; // FSEL繝舌ャ繧ｯ繧｢繝繝 +#endif + +//--------------------------------------------------------------------------- +// +// 螟画焚螳｣險(SCSI蛻ｶ蠕｡) +// +//--------------------------------------------------------------------------- +static enum mode_e actmode; // 蜍穂ｽ懊Δ繝ｼ繝 +static DWORD signals; // SCSI蜈ｨ菫｡蜿ｷ + +static BOOL tblParity[256]; +#if SIGNAL_CONTROL_MODE == 0 +static DWORD tblDatMsk[3][256]; // 繝繝ｼ繧ｿ繝槭せ繧ｯ逕ｨ繝繝ｼ繝悶Ν +static DWORD tblDatSet[3][256]; // 繝繝ｼ繧ｿ險ｭ螳夂畑繝繝ｼ繝悶Ν +#else +static DWORD tblDatMsk[256]; // 繝繝ｼ繧ｿ繝槭せ繧ｯ逕ｨ繝繝ｼ繝悶Ν +static DWORD tblDatSet[256]; // 繝繝ｼ繧ｿ險ｭ螳夂畑繝繝ｼ繝悶Ν +#endif + +//--------------------------------------------------------------------------- +// +// 繝ｯ繝ｼ繧ｯ繝繝ｼ繝悶Ν菴懈 +// +//--------------------------------------------------------------------------- +void MakeTable(void) +{ + const int pintbl[] = { + PIN_DT0, PIN_DT1, PIN_DT2, PIN_DT3, PIN_DT4, + PIN_DT5, PIN_DT6, PIN_DT7, PIN_DP + }; + + int i; + int j; + DWORD bits; + DWORD parity; +#if SIGNAL_CONTROL_MODE == 0 + int index; + int shift; +#else + DWORD gpclr; + DWORD gpset; +#endif + + // 繝代Μ繝繧｣繝繝ｼ繝悶Ν菴懈 + for (i = 0; i < 0x100; i++) { + bits = (DWORD)i; + parity = 0; + for (j = 0; j < 8; j++) { + parity ^= bits & 1; + bits >>= 1; + } + parity = ~parity; + tblParity[i] = parity & 1; + } + +#if SIGNAL_CONTROL_MODE == 0 + // 繝槭せ繧ｯ縺ｨ險ｭ螳壹ョ繝ｼ繧ｿ逕滓 + memset(tblDatMsk, 0xff, sizeof(tblDatMsk)); + memset(tblDatSet, 0x00, sizeof(tblDatSet)); + for (i = 0; i < 0x100; i++) { + // 讀懈渊逕ｨ繝薙ャ繝亥 + bits = (DWORD)i; + + // 繝代Μ繝繧｣蜿門ｾ + if (tblParity[i]) { + bits |= (1 << 8); + } + + // 繝薙ャ繝域､懈渊 + for (j = 0; j < 9; j++) { + // 繧､繝ｳ繝繝繧ｯ繧ｹ縺ｨ繧ｷ繝輔ヨ驥剰ｨ育ｮ + index = pintbl[j] / 10; + shift = (pintbl[j] % 10) * 3; + + // 繝槭せ繧ｯ繝繝ｼ繧ｿ + tblDatMsk[index][i] &= ~(0x7 << shift); + + // 險ｭ螳壹ョ繝ｼ繧ｿ + if (bits & 1) { + tblDatSet[index][i] |= (1 << shift); + } + + bits >>= 1; + } + } +#else + // 繝槭せ繧ｯ縺ｨ險ｭ螳壹ョ繝ｼ繧ｿ逕滓 + memset(tblDatMsk, 0x00, sizeof(tblDatMsk)); + memset(tblDatSet, 0x00, sizeof(tblDatSet)); + for (i = 0; i < 0x100; i++) { + // 讀懈渊逕ｨ繝薙ャ繝亥 + bits = (DWORD)i; + + // 繝代Μ繝繧｣蜿門ｾ + if (tblParity[i]) { + bits |= (1 << 8); + } + +#if SIGNAL_CONTROL_MODE == 1 + // 雋隲也炊縺ｯ蜿崎ｻ｢ + bits = ~bits; +#endif + + // GPIO繝ｬ繧ｸ繧ｹ繧ｿ諠蝣ｱ縺ｮ菴懈 + gpclr = 0; + gpset = 0; + for (j = 0; j < 9; j++) { + if (bits & 1) { + gpset |= (1 << pintbl[j]); + } else { + gpclr |= (1 << pintbl[j]); + } + bits >>= 1; + } + + tblDatMsk[i] = gpclr; + tblDatSet[i] = gpset; + } +#endif +} + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝仙晄悄蛹 +// +//--------------------------------------------------------------------------- +static int drv_init(void) +{ + printk(KERN_INFO "RaSCSI GPIO Driver Loaded(%s)\n", CONNECT_DESC); + + // 繝繝舌う繧ｹ逡ｪ蜿ｷ蜿門ｾ + if (alloc_chrdev_region( + &drv_dev, + 0, + 1, + DEVICE_NAME) < 0) { + printk(KERN_DEBUG "Failed to allocate region\n"); + goto init_error; + } + + // 繧ｯ繝ｩ繧ｹ逋ｻ骭ｲ + if ((drv_class = class_create( + THIS_MODULE, + DEVICE_NAME)) == NULL) { + printk(KERN_DEBUG "Failed to create class\n"); + goto init_error; + } + + // 繝繝舌う繧ｹ蛻晄悄蛹 + cdev_init(&drv_cdev, &drv_fops); + drv_cdev.owner = THIS_MODULE; + if (cdev_add(&drv_cdev, drv_dev, 1) < 0) { + printk(KERN_ALERT "Failed to add device\n"); + goto init_error; + } + + // 繝繝舌う繧ｹ菴懈 + drv_devno = MKDEV(MAJOR(drv_dev), MINOR(drv_dev)); + if (device_create( + drv_class, + NULL, + drv_devno, + NULL, + DEVICE_NAME) == NULL) { + printk(KERN_DEBUG "Failed to create device\n"); + goto init_error; + } + + // 繝ｯ繝ｼ繧ｯ繝繝ｼ繝悶Ν逕滓 + MakeTable(); + + // 繝ｯ繝ｼ繧ｯ繧ｯ繝ｪ繧｢ + baseaddr = ~0; + gpio = NULL; + level = NULL; + pads = NULL; + + return 0; + +init_error: + drv_exit(); + return -1; +} + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝占ｧ｣謾ｾ +// +//--------------------------------------------------------------------------- +static void drv_exit(void) +{ + // 繧ｯ繝ｩ繧ｹ逋ｻ骭ｲ隗｣髯､ + if (drv_class) { + device_destroy(drv_class, drv_devno); + class_destroy(drv_class); + drv_class = NULL; + } + + // 繝繝舌う繧ｹ逋ｻ骭ｲ隗｣髯､ + if (drv_dev){ + unregister_chrdev_region(drv_dev, 1); + drv_dev = 0; + } + + printk(KERN_INFO "RaSCSI GPIO Driver Unloaded\n"); +} + +//--------------------------------------------------------------------------- +// +// 繧ｪ繝ｼ繝励Φ +// +//--------------------------------------------------------------------------- +int drv_open(struct inode *inode, struct file *file) +{ + // 蜍穂ｽ懊Δ繝ｼ繝牙晄悄蛹 + actmode = TARGET; + + return 0; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｭ繝ｼ繧ｺ +// +//--------------------------------------------------------------------------- +int drv_close(struct inode *inode, struct file *file) +{ + // 繧｢繝ｳ繝槭ャ繝 + if (gpio) { + iounmap(gpio); + gpio = NULL; + } + + if (pads) { + iounmap(pads); + pads = NULL; + } + + // 繝吶ｼ繧ｹ繧｢繝峨Ξ繧ｹ繧ｯ繝ｪ繧｢ + baseaddr = ~0; + + return 0; +} + +//--------------------------------------------------------------------------- +// +// 繝峨Λ繧､繝 IOCTL +// +//--------------------------------------------------------------------------- +long drv_ioctl( + struct file *file, unsigned int cmd, unsigned long arg) +{ + DWORD data; + DWORD drive; + + switch (cmd) { + case IOCTL_INIT: + // 蛻晄悄蛹悶ｯ繧ｪ繝ｼ繝励Φ蠕後↓1蝗樣剞繧 + if (baseaddr != ~0) { + break; + } + + // 繝吶ｼ繧ｹ繧｢繝峨Ξ繧ｹ + baseaddr = arg; + + // GPIO繝ｬ繧ｸ繧ｹ繧ｿ繧偵槭ャ繝 + gpio = (DWORD *)ioremap_nocache(baseaddr + GPIO_OFFSET, 164); + level = &gpio[GPIO_LEV_0]; + + // PADS繝ｬ繧ｸ繧ｹ繧ｿ繧偵槭ャ繝 + pads = (DWORD *)ioremap_nocache(baseaddr + PADS_OFFSET, 56); + break; + + case IOCTL_MODE: + // 蜍穂ｽ懊Δ繝ｼ繝牙､画峩 + actmode = (enum mode_e)arg; + break; + + case IOCTL_PADS: + // DriveStrength螟画峩 + if (!pads) { + return -1; + } + + data = pads[PAD_0_27]; + drive = arg; + pads[PAD_0_27] = (0xFFFFFFF8 & data) | drive | 0x5a000000; + break; + + default: + break; + } + + return 0; +} + +//--------------------------------------------------------------------------- +// +// 繝舌せ菫｡蜿ｷ蜿悶ｊ霎ｼ縺ｿ +// +//--------------------------------------------------------------------------- +static inline DWORD Aquire(void) +{ + signals = *level; + +#if SIGNAL_CONTROL_MODE < 2 + // 雋隲也炊縺ｪ繧牙渚霆｢縺吶ｋ(蜀驛ｨ蜃ｦ逅縺ｯ豁｣隲也炊縺ｫ邨ｱ荳) + signals = ~signals; +#endif + + return signals; +} + +//--------------------------------------------------------------------------- +// +// 繝翫ヮ遘貞腰菴阪ｮ繧ｹ繝ｪ繝ｼ繝 +// +// GPIO髢｢菫ゅｮ繝ｬ繧ｸ繧ｹ繧ｿ縺ｯ繧ｳ繧｢繧ｯ繝ｭ繝繧ｯ縺400縺ｮ譎ゅ↓險域ｸｬ縺励◆騾溷ｺｦ繧貞盾閠縺ｫ縺励◆縲 +// 繝ｪ繝ｼ繝:48ns +// 繝ｩ繧､繝: 8ns +// +//--------------------------------------------------------------------------- +static inline void SleepNsec(DWORD nsec) +{ + DWORD count; + + count = (nsec + 8 - 1) / 8; + while (count--) { + gpio[GPIO_PUD] = 0; + } +} + +//--------------------------------------------------------------------------- +// +// 繧ｷ繧ｰ繝翫Ν險ｭ螳 +// +//--------------------------------------------------------------------------- +static inline void SetSignal(int pin, BOOL ast) +{ +#if SIGNAL_CONTROL_MODE == 0 + int index; + int shift; + DWORD data; + + index = pin / 10; + shift = (pin % 10) * 3; + data = gpfsel[index]; + data &= ~(0x7 << shift); + if (ast) { + data |= (1 << shift); + } + gpio[GPIO_FSEL_0 + index] = data; + gpfsel[index] = data; +#elif SIGNAL_CONTROL_MODE == 1 + if (ast) { + gpio[GPIO_CLR_0] = 0x1 << pin; + } else { + gpio[GPIO_SET_0] = 0x1 << pin; + } +#elif SIGNAL_CONTROL_MODE == 2 + if (ast) { + gpio[GPIO_SET_0] = 0x1 << pin; + } else { + gpio[GPIO_CLR_0] = 0x1 << pin; + } +#endif +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ蜿門ｾ +// +//--------------------------------------------------------------------------- +static inline BYTE GetDAT(void) +{ + DWORD data; + + data = Aquire(); + data = + ((data >> (PIN_DT0 - 0)) & (1 << 0)) | + ((data >> (PIN_DT1 - 1)) & (1 << 1)) | + ((data >> (PIN_DT2 - 2)) & (1 << 2)) | + ((data >> (PIN_DT3 - 3)) & (1 << 3)) | + ((data >> (PIN_DT4 - 4)) & (1 << 4)) | + ((data >> (PIN_DT5 - 5)) & (1 << 5)) | + ((data >> (PIN_DT6 - 6)) & (1 << 6)) | + ((data >> (PIN_DT7 - 7)) & (1 << 7)); + + return (BYTE)data; +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ險ｭ螳 +// +//--------------------------------------------------------------------------- +static inline void SetDAT(BYTE dat) +{ + // 繝昴ｼ繝医∈譖ｸ縺崎ｾｼ縺ｿ +#if SIGNAL_CONTROL_MODE == 0 + gpfsel[0] &= tblDatMsk[0][dat]; + gpfsel[0] |= tblDatSet[0][dat]; + gpio[GPIO_FSEL_0] = gpfsel[0]; + + gpfsel[1] &= tblDatMsk[1][dat]; + gpfsel[1] |= tblDatSet[1][dat]; + gpio[GPIO_FSEL_1] = gpfsel[1]; + + gpfsel[2] &= tblDatMsk[2][dat]; + gpfsel[2] |= tblDatSet[2][dat]; + gpio[GPIO_FSEL_2] = gpfsel[2]; +#else + gpio[GPIO_CLR_0] = tblDatMsk[dat]; + gpio[GPIO_SET_0] = tblDatSet[dat]; +#endif +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繝ｼ繝 +// +//--------------------------------------------------------------------------- +ssize_t drv_read( + struct file *file, char __user *buf, size_t count, loff_t *fops) +{ + ssize_t i; + BYTE data; + DWORD loop; + DWORD phase; + +#if SIGNAL_CONTROL_MODE == 0 + // FSEL莠句燕蜿門ｾ + gpfsel[0] = gpio[GPIO_FSEL_0]; + gpfsel[1] = gpio[GPIO_FSEL_1]; + gpfsel[2] = gpio[GPIO_FSEL_2]; +#endif + + // 蜑ｲ繧願ｾｼ縺ｿ遖∵ｭ｢ + local_irq_disable(); + local_fiq_disable(); + + if (actmode == TARGET) { + for (i = 0; i < count; i++) { + // REQ繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_REQ, TRUE); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // 繝繝ｼ繧ｿ蜿門ｾ + data = GetDAT(); + + // REQ繝阪ご繝ｼ繝 + SetSignal(PIN_REQ, FALSE); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // 繝繝ｼ繧ｿ霑泌唆 + if (copy_to_user(buf, (unsigned char *)&data, 1)) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + } else { + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + Aquire(); + phase = signals & GPIO_MCI; + + for (i = 0; i < count; i++) { + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 繝繝ｼ繧ｿ蜿門ｾ + data = GetDAT(); + + // ACK繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_ACK, TRUE); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡ + loop = 30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // ACK繝阪ご繝ｼ繝 + SetSignal(PIN_ACK, FALSE); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 繝繝ｼ繧ｿ霑泌唆 + if (copy_to_user(buf, (unsigned char *)&data, 1)) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + } + + // 蜑ｲ繧願ｾｼ縺ｿ遖∵ｭ｢隗｣髯､ + local_fiq_enable(); + local_irq_enable(); + + return i; +} + +//--------------------------------------------------------------------------- +// +// 繝ｩ繧､繝 +// +//--------------------------------------------------------------------------- +ssize_t drv_write( + struct file *file, const char __user *buf, size_t count, loff_t *fops) +{ + size_t i; + BYTE data; + DWORD loop; + DWORD phase; + + // 蜑ｲ繧願ｾｼ縺ｿ遖∵ｭ｢ + local_irq_disable(); + local_fiq_disable(); + +#if SIGNAL_CONTROL_MODE == 0 + // FSEL莠句燕蜿門ｾ + gpfsel[0] = gpio[GPIO_FSEL_0]; + gpfsel[1] = gpio[GPIO_FSEL_1]; + gpfsel[2] = gpio[GPIO_FSEL_2]; +#endif + + if (actmode == TARGET) { + for (i = 0; i < count; i++) { + // 繝繝ｼ繧ｿ蜿悶ｊ霎ｼ縺ｿ + if (copy_from_user((unsigned char *)&data, buf, 1)) { + break; + } + + // 繝繝ｼ繧ｿ險ｭ螳 + SetDAT(data); + + // 菫｡蜿ｷ邱壹′螳牙ｮ壹☆繧九∪縺ｧ繧ｦ繧ｧ繧､繝 + SleepNsec(150); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // REQ繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_REQ, TRUE); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + + // REQ繝阪ご繝ｼ繝 + SetSignal(PIN_REQ, FALSE); + + // ACK繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & (1 << PIN_RST))) { + break; + } + + // 谺｡繝繝ｼ繧ｿ + buf++; + }; + + // ACK繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_ACK)) && + !(signals & (1 << PIN_RST)) && loop > 0); + } else { + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + Aquire(); + phase = signals & GPIO_MCI; + + for (i = 0; i < count; i++) { + // 繝繝ｼ繧ｿ蜿悶ｊ霎ｼ縺ｿ + if (copy_from_user((unsigned char *)&data, buf, 1)) { + break; + } + + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while (!(signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // REQ繧｢繧ｵ繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 繝繝ｼ繧ｿ險ｭ螳 + SetDAT(data); + + // 菫｡蜿ｷ邱壹′螳牙ｮ壹☆繧九∪縺ｧ繧ｦ繧ｧ繧､繝 + SleepNsec(150); + + // ACK繧｢繧ｵ繝ｼ繝 + SetSignal(PIN_ACK, TRUE); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡ + loop = (DWORD)30000000; + do { + Aquire(); + loop--; + } while ((signals & (1 << PIN_REQ)) && + ((signals & GPIO_MCI) == phase) && loop > 0); + + // ACK繝阪ご繝ｼ繝 + SetSignal(PIN_ACK, FALSE); + + // REQ繝阪ご繝ｼ繝亥ｾ縺｡縺ｧ繧ｿ繧､繝繧｢繧ｦ繝 + if (loop == 0 || (signals & GPIO_MCI) != phase) { + break; + } + + // 谺｡繝繝ｼ繧ｿ縺ｸ + buf++; + } + } + + // 蜑ｲ繧願ｾｼ縺ｿ遖∵ｭ｢隗｣髯､ + local_fiq_enable(); + local_irq_enable(); + + return i; +} + +module_init(drv_init); +module_exit(drv_exit); + +MODULE_DESCRIPTION("RASCSI GPIO Driver"); +MODULE_VERSION("1.0"); +MODULE_AUTHOR("GIMONS"); +MODULE_LICENSE("GPL"); diff --git a/src/raspberrypi/log.h b/src/raspberrypi/log.h new file mode 100644 index 00000000..4448418f --- /dev/null +++ b/src/raspberrypi/log.h @@ -0,0 +1,31 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ 繝ｭ繧ｰ ] +// +//--------------------------------------------------------------------------- + +#if !defined(log_h) +#define log_h + +//=========================================================================== +// +// 繝ｭ繧ｰ +// +//=========================================================================== +class Log +{ +public: + enum loglevel { + Detail, // 隧ｳ邏ｰ繝ｬ繝吶Ν + Normal, // 騾壼ｸｸ繝ｬ繝吶Ν + Warning, // 隴ｦ蜻翫Ξ繝吶Ν + Debug // 繝繝舌ャ繧ｰ繝ｬ繝吶Ν + }; +}; + +#endif // log_h diff --git a/src/raspberrypi/os.h b/src/raspberrypi/os.h new file mode 100644 index 00000000..d2d043e9 --- /dev/null +++ b/src/raspberrypi/os.h @@ -0,0 +1,145 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// Imported NetBSD support and some optimisation patch by Rin Okuyama. +// +// [ OS蝗ｺ譛 ] +// +//--------------------------------------------------------------------------- + +#if !defined(os_h) +#define os_h + +//--------------------------------------------------------------------------- +// +// #define +// +//--------------------------------------------------------------------------- +#ifndef _LARGEFILE64_SOURCE +#define _LARGEFILE64_SOURCE +#endif + +#ifndef _FILE_OFFSET_BITS +#define _FILE_OFFSET_BITS 64 +#endif + +//--------------------------------------------------------------------------- +// +// #include +// +//--------------------------------------------------------------------------- + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__linux__) +#include +#include +#elif defined(__NetBSD__) +#include +#include +#include +#include +#include +#include +#else +#error unsupported platform +#endif + +//--------------------------------------------------------------------------- +// +// 蝓ｺ譛ｬ繝槭け繝ｭ +// +//--------------------------------------------------------------------------- +#undef FASTCALL +#define FASTCALL + +#undef CDECL +#define CDECL + +#undef INLINE +#define INLINE + +#if !defined(ASSERT) +#if !defined(NDEBUG) +#define ASSERT(cond) assert(cond) +#else +#define ASSERT(cond) ((void)0) +#endif // NDEBUG +#endif // ASSERT + +#if !defined(ASSERT_DIAG) +#if !defined(NDEBUG) +#define ASSERT_DIAG() AssertDiag() +#else +#define ASSERT_DIAG() ((void)0) +#endif // NDEBUG +#endif // ASSERT_DIAG + +//--------------------------------------------------------------------------- +// +// 蝓ｺ譛ｬ蝙句ｮ夂ｾｩ +// +//--------------------------------------------------------------------------- +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned long DWORD; +typedef int BOOL; +typedef char TCHAR; +typedef char *LPTSTR; +typedef const char *LPCTSTR; +typedef const char *LPCSTR; + +#if !defined(FALSE) +#define FALSE 0 +#endif + +#if !defined(TRUE) +#define TRUE 1 +#endif + +#if !defined(_T) +#define _T(x) x +#endif + +#define _MAX_PATH 260 +#define _MAX_DRIVE 3 +#define _MAX_DIR 256 +#define _MAX_FNAME 256 +#define _MAX_EXT 256 + +#define off64_t off_t + +#define xstrcasecmp strcasecmp +#define xstrncasecmp strncasecmp + +#endif // os_h diff --git a/src/raspberrypi/rascsi.cpp b/src/raspberrypi/rascsi.cpp new file mode 100644 index 00000000..a697f101 --- /dev/null +++ b/src/raspberrypi/rascsi.cpp @@ -0,0 +1,758 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ 繝｡繧､繝ｳ ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "fileio.h" +#include "filepath.h" +#include "disk.h" +#include "gpiobus.h" + +//--------------------------------------------------------------------------- +// +// 螟画焚螳｣險 +// +//--------------------------------------------------------------------------- +enum { + CtrlMax = 8, // 譛螟ｧSCSI繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ謨ｰ +}; + +SASIDEV *ctrl[CtrlMax]; // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ +Disk *disk[CtrlMax]; // 繝繧｣繧ｹ繧ｯ +Filepath image[CtrlMax]; // 繧､繝｡繝ｼ繧ｸ繝輔ぃ繧､繝ｫ繝代せ +GPIOBUS bus; // 繝舌せ +BUS::phase_t phase; // 繝輔ぉ繝ｼ繧ｺ +int actid; // 繧｢繧ｯ繝繧｣繝悶↑繧ｳ繝ｳ繝医Ο繝ｼ繝ｩID +volatile BOOL bRun; // 螳溯｡御ｸｭ繝輔Λ繧ｰ + +BOOL bServer; // 繧ｵ繝ｼ繝舌ｼ繝｢繝ｼ繝峨ヵ繝ｩ繧ｰ +int monfd; // 繝｢繝九ち繝ｼ逕ｨ繧ｽ繧ｱ繝繝FD +pthread_t monthread; // 繝｢繝九ち繝ｼ繧ｹ繝ｬ繝繝 +static void *MonThread(void *param); + +//--------------------------------------------------------------------------- +// +// 繧ｷ繧ｰ繝翫Ν蜃ｦ逅 +// +//--------------------------------------------------------------------------- +void KillHandler(int sig) +{ + // 蛛懈ｭ｢謖遉ｺ + bRun = FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繝舌リ繝ｼ蜃ｺ蜉 +// +//--------------------------------------------------------------------------- +BOOL Banner(int argc, char* argv[]) +{ + printf("SCSI Target Emulator RaSCSI(*^..^*) "); + printf("version %01d.%01d%01d\n", + (int)((VERSION >> 8) & 0xf), + (int)((VERSION >> 4) & 0xf), + (int)((VERSION ) & 0xf)); + printf("Powered by XM6 TypeG Technology / "); + printf("Copyright (C) 2016-2018 GIMONS\n"); + printf("Connect type : %s\n", CONNECT_DESC); + + if (argc > 1 && strcmp(argv[1], "-h") == 0) { + printf("\n"); + printf("Usage: %s [-ID{0|1|2|3|4|5|6|7} FILE] ...\n\n", argv[0]); + printf(" IDn is SCSI identification number.\n"); + printf(" FILE is disk image file.\n\n"); + printf(" Detected images type based on file extension.\n"); + printf(" hdf : SASI HD image(XM6 SASI HD image)\n"); + printf(" hds : SCSI HD image(XM6 SCSI HD image)\n"); + printf(" hdn : SCSI HD image(NEC GENUINE)\n"); + printf(" hdi : SCSI HD image(Anex86 HD image)\n"); + printf(" nhd : SCSI HD image(T98Next HD image)\n"); + printf(" hda : SCSI HD image(APPLE GENUINE)\n"); + printf(" mos : SCSI MO image(XM6 SCSI MO image)\n"); + printf(" iso : SCSI CD image(ISO 9660 image)\n"); + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +BOOL Init() +{ + int i; + struct sockaddr_in server; + + // 繝｢繝九ち繝ｼ逕ｨ繧ｽ繧ｱ繝繝育函謌 + monfd = socket(PF_INET, SOCK_STREAM, 0); + memset(&server, 0, sizeof(server)); + server.sin_family = PF_INET; + server.sin_port = htons(6868); + server.sin_addr.s_addr = htonl(INADDR_ANY); + if (bind(monfd, (struct sockaddr *)&server, + sizeof(struct sockaddr_in)) < 0) { + if (errno != EADDRINUSE) { + return FALSE; + } + bServer = FALSE; + return TRUE; + } else { + bServer = TRUE; + } + + // 蜑ｲ繧願ｾｼ縺ｿ繝上Φ繝峨Λ險ｭ螳 + if (signal(SIGINT, KillHandler) == SIG_ERR) { + return FALSE; + } + if (signal(SIGHUP, KillHandler) == SIG_ERR) { + return FALSE; + } + if (signal(SIGTERM, KillHandler) == SIG_ERR) { + return FALSE; + } + + // GPIO蛻晄悄蛹 + if (!bus.Init()) { + return FALSE; + } + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ蛻晄悄蛹 + for (i = 0; i < CtrlMax; i++) { + ctrl[i] = NULL; + } + + // 繝繧｣繧ｹ繧ｯ蛻晄悄蛹 + for (i = 0; i < CtrlMax; i++) { + disk[i] = NULL; + } + + // 繧､繝｡繝ｼ繧ｸ繝代せ蛻晄悄蛹 + for (i = 0; i < CtrlMax; i++) { + image[i].Clear(); + } + + // 繧｢繧ｯ繝繧｣繝蜂D蛻晄悄蛹 + actid = -1; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 +// +//--------------------------------------------------------------------------- +void Cleanup() +{ + int i; + + // 繝繧｣繧ｹ繧ｯ蜑企勁 + for (i = 0; i < CtrlMax; i++) { + if (disk[i]) { + delete disk[i]; + disk[i] = NULL; + } + } + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ蜑企勁 + for (i = 0; i < CtrlMax; i++) { + if (ctrl[i]) { + delete ctrl[i]; + ctrl[i] = NULL; + } + } + + // 繝舌せ繧偵け繝ｪ繝ｼ繝ｳ繧｢繝繝 + bus.Cleanup(); + + // 繝｢繝九ち繝ｼ逕ｨ繧ｽ繧ｱ繝繝医け繝ｭ繝ｼ繧ｺ + if (monfd >= 0) { + close(monfd); + } +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void Reset() +{ + int i; + + // 繧｢繧ｯ繝繧｣繝蜂D蛻晄悄蛹 + actid = -1; + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繝ｪ繧ｻ繝繝 + for (i = 0; i < CtrlMax; i++) { + if (ctrl[i]) { + ctrl[i]->Reset(); + } + } + + // 繝舌せ菫｡蜿ｷ邱壹ｒ繝ｪ繧ｻ繝繝 + bus.Reset(); +} + +//--------------------------------------------------------------------------- +// +// 繝繝舌う繧ｹ荳隕ｧ陦ｨ遉ｺ +// +//--------------------------------------------------------------------------- +void ListDevice(FILE *fp) +{ + int i; + Filepath filepath; + BOOL find; + char type[5]; + + find = FALSE; + type[4] = 0; + for (i = 0; i < 8; i++) { + if (disk[i] == NULL) { + continue; + } + + // 繝倥ャ繝繝ｼ蜃ｺ蜉 + if (!find) { + fprintf(fp, "\n"); + fprintf(fp, "---+------+---------------------------------------\n"); + fprintf(fp, "ID | TYPE | DEVICE STATUS\n"); + fprintf(fp, "---+------+---------------------------------------\n"); + find = TRUE; + } + + // ID,繧ｿ繧､繝怜ｺ蜉 + type[0] = (char)(disk[i]->GetID() >> 24); + type[1] = (char)(disk[i]->GetID() >> 16); + type[2] = (char)(disk[i]->GetID() >> 8); + type[3] = (char)(disk[i]->GetID()); + fprintf(fp, " %d | %s | ", i, type); + + // 繝槭え繝ｳ繝育憾諷句ｺ蜉 + if (disk[i]->GetID() == MAKEID('S', 'C', 'B', 'R')) { + fprintf(fp, "%s", "RaSCSI BRIDGE"); + } else { + disk[i]->GetPath(filepath); + fprintf(fp, "%s", + (disk[i]->IsRemovable() && !disk[i]->IsReady()) ? + "NO MEDIA" : filepath.GetPath()); + } + + // 繝ｩ繧､繝医励Ο繝繧ｯ繝育憾諷句ｺ蜉 + if (disk[i]->IsRemovable() && disk[i]->IsReady() && disk[i]->IsWriteP()) { + fprintf(fp, "(WRITEPROTECT)"); + } + + // 谺｡縺ｮ陦後∈ + fprintf(fp, "\n"); + } + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ縺檎┌縺蝣ｴ蜷 + if (!find) { + fprintf(fp, "No device is installed.\n"); + return; + } + + fprintf(fp, "---+------+---------------------------------------\n"); +} + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝牙ｦ逅 +// +//--------------------------------------------------------------------------- +BOOL ProcessCmd(FILE *fp, int id, int cmd, int type, char *file) +{ + int len; + char *ext; + Filepath filepath; + + // ID繝√ぉ繝繧ｯ + if (id < 0 || id > 7) { + fprintf(fp, "Error : Invalid ID\n"); + return FALSE; + } + + // 謗･邯壹さ繝槭Φ繝 + if (cmd == 0) { // ATTACH + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧定ｧ｣謾ｾ + if (ctrl[id]) { + ctrl[id]->SetUnit(0, NULL); + delete ctrl[id]; + ctrl[id] = NULL; + } + + // 繝繧｣繧ｹ繧ｯ繧定ｧ｣謾ｾ + if (disk[id]) { + delete disk[id]; + disk[id] = NULL; + } + + // SASI縺ｨSCSI繧定ｦ句縺代ｋ + if (type == 0) { + // 繝代せ繝√ぉ繝繧ｯ + if (!file) { + return FALSE; + } + + // 譛菴5譁蟄 + len = strlen(file); + if (len < 5) { + return FALSE; + } + + // 諡｡蠑ｵ蟄舌メ繧ｧ繝繧ｯ + if (file[len - 4] != '.') { + return FALSE; + } + + // 諡｡蠑ｵ蟄舌′SASI繧ｿ繧､繝励〒辟｡縺代ｌ縺ｰSCSI縺ｫ蟾ｮ縺玲崛縺 + ext = &file[len - 3]; + if (xstrcasecmp(ext, "hdf") != 0) { + type = 1; + } + } + + // 繧ｿ繧､繝怜挨縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧堤函謌 + switch (type) { + case 0: // HDF + disk[id] = new SASIHD(); + break; + case 1: // HDS/HDN/HDI/NHD/HDA + if (xstrcasecmp(ext, "hdn") == 0 || + xstrcasecmp(ext, "hdi") == 0 || xstrcasecmp(ext, "nhd") == 0) { + disk[id] = new SCSIHD_NEC(); + } else if (xstrcasecmp(ext, "hda") == 0) { + disk[id] = new SCSIHD_APPLE(); + } else { + disk[id] = new SCSIHD(); + } + break; + case 2: // MO + disk[id] = new SCSIMO(); + break; + case 3: // CD + disk[id] = new SCSICD(); + break; + case 4: // BRIDGE + disk[id] = new SCSIBR(); + break; + default: + fprintf(fp, "Error : Invalid device type\n"); + return FALSE; + } + + // 繧ｿ繧､繝励↓蜷医ｏ縺帙※繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ繧剃ｽ懊ｋ + if (type == 0) { + ctrl[id] = new SASIDEV(); + } else { + ctrl[id] = new SCSIDEV(); + } + + // 繝峨Λ繧､繝悶ｯ繝輔ぃ繧､繝ｫ縺ｮ遒ｺ隱阪ｒ陦後≧ + if (type <= 1 || (type <= 3 && xstrcasecmp(file, "-") != 0)) { + // 繝代せ繧定ｨｭ螳 + filepath.SetPath(file); + + // 繧ｪ繝ｼ繝励Φ + if (!disk[id]->Open(filepath)) { + fprintf(fp, "Error : File open error [%s]\n", file); + delete disk[id]; + disk[id] = NULL; + delete ctrl[id]; + ctrl[id] = NULL; + return FALSE; + } + } + + // 繝ｩ繧､繝医せ繝ｫ繝ｼ縺ｫ險ｭ螳 + disk[id]->SetCacheWB(FALSE); + + // 譁ｰ縺溘↑繝繧｣繧ｹ繧ｯ繧呈磁邯 + ctrl[id]->Connect(id, &bus); + ctrl[id]->SetUnit(0, disk[id]); + return TRUE; + } + + // 譛牙柑縺ｪ繧ｳ繝槭Φ繝峨° + if (cmd > 4) { + fprintf(fp, "Error : Invalid command\n"); + return FALSE; + } + + // 繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ縺悟ｭ伜惠縺吶ｋ縺 + if (ctrl[id] == NULL) { + fprintf(fp, "Error : No such device\n"); + return FALSE; + } + + // 繝繧｣繧ｹ繧ｯ縺悟ｭ伜惠縺吶ｋ縺 + if (disk[id] == NULL) { + fprintf(fp, "Error : No such device\n"); + return FALSE; + } + + // 蛻譁ｭ繧ｳ繝槭Φ繝 + if (cmd == 1) { // DETACH + ctrl[id]->SetUnit(0, NULL); + delete disk[id]; + disk[id] = NULL; + delete ctrl[id]; + ctrl[id] = NULL; + return TRUE; + } + + // MO縺気D縺ｮ蝣ｴ蜷医□縺第怏蜉ｹ + if (disk[id]->GetID() != MAKEID('S', 'C', 'M', 'O') && + disk[id]->GetID() != MAKEID('S', 'C', 'C', 'D')) { + fprintf(fp, "Error : Operation denied(Deveice isn't MO or CD)\n"); + return FALSE; + } + + switch (cmd) { + case 2: // INSERT + // 繝代せ繧定ｨｭ螳 + filepath.SetPath(file); + + // 繧ｪ繝ｼ繝励Φ + if (!disk[id]->Open(filepath)) { + fprintf(fp, "Error : File open error [%s]\n", file); + return FALSE; + } + break; + + case 3: // EJECT + disk[id]->Eject(TRUE); + break; + + case 4: // PROTECT + if (disk[id]->GetID() != MAKEID('S', 'C', 'M', 'O')) { + fprintf(fp, "Error : Operation denied(Deveice isn't MO)\n"); + return FALSE; + } + disk[id]->WriteP(!disk[id]->IsWriteP()); + break; + default: + ASSERT(FALSE); + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 蠑墓焚蜃ｦ逅 +// +//--------------------------------------------------------------------------- +BOOL ParseArgument(int argc, char* argv[]) +{ + int i; + int id; + int type; + char *argID; + char *argPath; + int len; + char *ext; + + // ID縺ｨ繝代せ謖螳壹′縺ｪ縺代ｌ縺ｰ蜃ｦ逅繧剃ｸｭ譁ｭ + if (argc < 3) { + return TRUE; + } + + // 蠑墓焚縺ｮ隗｣隱ｭ髢句ｧ + i = 1; + argc--; + + // ID縺ｨ繝代せ繧貞叙蠕 + while (argc >= 2) { + argc -= 2; + argID = argv[i++]; + argPath = argv[i++]; + + // -ID or -id縺ｮ蠖｢蠑上ｒ繝√ぉ繝繧ｯ + if (strlen(argID) != 4 || xstrncasecmp(argID, "-id", 3) != 0) { + fprintf(stderr, + "Error : Invalid argument(-IDn) [%s]\n", argID); + return FALSE; + } + + // ID逡ｪ蜿ｷ繧偵メ繧ｧ繝繧ｯ(0-7) + if (argID[3] < '0' || argID[3] > '7') { + fprintf(stderr, + "Error : Invalid argument(-IDn n=0-7) [%c]\n", argID[3]); + return FALSE; + } + + // ID遒ｺ螳 + id = argID[3] - '0'; + + // 縺吶〒縺ｫ繧｢繧ｯ繝繧｣繝悶↑繝繝舌う繧ｹ縺後≠繧九↑繧峨せ繧ｭ繝繝 + if (disk[id]) { + continue; + } + + // 繝繝舌う繧ｹ繧ｿ繧､繝励ｒ蛻晄悄蛹 + type = -1; + + // 繧､繝ｼ繧ｵ繝阪ャ繝医→繝帙せ繝医ヶ繝ｪ繝繧ｸ縺ｮ繝√ぉ繝繧ｯ + if (xstrcasecmp(argPath, "bridge") == 0) { + type = 4; + } else { + // 繝代せ縺ｮ髟ｷ縺輔ｒ繝√ぉ繝繧ｯ + len = strlen(argPath); + if (len < 5) { + fprintf(stderr, + "Error : Invalid argument(File path is short) [%s]\n", + argPath); + return FALSE; + } + + // 諡｡蠑ｵ蟄舌ｒ謖√▲縺ｦ縺繧九°ｼ + if (argPath[len - 4] != '.') { + fprintf(stderr, + "Error : Invalid argument(No extension) [%s]\n", argPath); + return FALSE; + } + + // 繧ｿ繧､繝励ｒ豎ｺ繧√ｋ + ext = &argPath[len - 3]; + if (xstrcasecmp(ext, "hdf") == 0 || + xstrcasecmp(ext, "hds") == 0 || + xstrcasecmp(ext, "hdn") == 0 || + xstrcasecmp(ext, "hdi") == 0 || xstrcasecmp(ext, "nhd") == 0 || + xstrcasecmp(ext, "hda") == 0) { + // HD(SASI/SCSI) + type = 0; + } else if (strcasecmp(ext, "mos") == 0) { + // MO + type = 2; + } else if (strcasecmp(ext, "iso") == 0) { + // CD + type = 3; + } else { + // 繧ｿ繧､繝励′蛻､蛻･縺ｧ縺阪↑縺 + fprintf(stderr, + "Error : Invalid argument(file type) [%s]\n", ext); + return FALSE; + } + } + + // 繧ｳ繝槭Φ繝牙ｮ溯｡ + if (!ProcessCmd(stderr, id, 0, type, argPath)) { + return FALSE; + } + } + + // 繝繝舌う繧ｹ繝ｪ繧ｹ繝郁｡ｨ遉ｺ + ListDevice(stdout); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝｢繝九ち繝ｼ繧ｹ繝ｬ繝繝 +// +//--------------------------------------------------------------------------- +static void *MonThread(void *param) +{ + struct sockaddr_in client; + socklen_t len; + int fd; + FILE *fp; + BYTE buf[BUFSIZ]; + int id; + int cmd; + int type; + char *file; + BOOL list; + + // 逶｣隕匁ｺ門ｙ + listen(monfd, 1); + + while (1) { + // 謗･邯壼ｾ縺｡ + memset(&client, 0, sizeof(client)); + len = sizeof(client); + fd = accept(monfd, (struct sockaddr*)&client, &len); + if (fd < 0) { + break; + } + + // 繧ｳ繝槭Φ繝牙叙蠕 + fp = fdopen(fd, "r+"); + fgets((char *)buf, BUFSIZ, fp); + buf[strlen((const char*)buf) - 1] = 0; + + // 繝繝舌う繧ｹ繝ｪ繧ｹ繝郁｡ｨ遉ｺ縺ｪ縺ｮ縺句宛蠕｡繧ｳ繝槭Φ繝峨°繧貞愛譁ｭ + if (strncasecmp((char*)buf, "list", 4) == 0) { + list = TRUE; + } else { + list = FALSE; + id = (int)(buf[0] - '0'); + cmd = (int)(buf[2] - '0'); + type = (int)(buf[4] - '0'); + file = (char*)&buf[6]; + } + + // 繝舌せ繝輔Μ繝ｼ縺ｮ繧ｿ繧､繝溘Φ繧ｰ縺ｾ縺ｧ蠕縺､ + while (phase != BUS::busfree) { + usleep(500 * 1000); + } + + if (list) { + // 繝ｪ繧ｹ繝郁｡ｨ遉ｺ + ListDevice(fp); + } else { + // 繧ｳ繝槭Φ繝牙ｮ溯｡ + ProcessCmd(fp, id, cmd, type, file); + } + + // 謗･邯夊ｧ｣謾ｾ + fclose(fp); + close(fd); + } + + return NULL; +} + +//--------------------------------------------------------------------------- +// +// 荳ｻ蜃ｦ逅 +// +//--------------------------------------------------------------------------- +int main(int argc, char* argv[]) +{ + int i; + DWORD dwBusBak; + DWORD dwBusIn; + struct sched_param schparam; + + // 繝舌リ繝ｼ蜃ｺ蜉 + if (!Banner(argc, argv)) { + exit(0); + } + + // 蛻晄悄蛹 + if (!Init()) { + fprintf(stderr, "Error : Initializing\n"); + + // 諱舌ｉ縺俊oot縺ｧ縺ｯ辟｡縺ｼ + exit(EPERM); + } + + // 譌｢縺ｫ襍ｷ蜍輔＠縺ｦ縺繧具ｼ + if (!bServer) { + fprintf(stderr, "Error : Already running RaSCSI\n"); + exit(0); + } + + // 讒狗ｯ + if (!ParseArgument(argc, argv)) { + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + Cleanup(); + + // 蠑墓焚繧ｨ繝ｩ繝ｼ縺ｧ邨ゆｺ + exit(EINVAL); + } + + // 繝｢繝九ち繝ｼ繧ｹ繝ｬ繝繝臥函謌 + bRun = TRUE; + pthread_create(&monthread, NULL, MonThread, NULL); + + // 繝ｪ繧ｻ繝繝 + Reset(); + + // 繝｡繧､繝ｳ繝ｫ繝ｼ繝玲ｺ門ｙ + phase = BUS::busfree; + dwBusBak = bus.Aquire(); + + // 繝｡繧､繝ｳ繝ｫ繝ｼ繝 + while(bRun) { + // 繝舌せ縺ｮ蜈･蜉帑ｿ｡蜿ｷ螟牙喧讀懷ｺ + dwBusIn = bus.Aquire(); + + // 蜈･蜉帑ｿ｡蜿ｷ螟牙喧讀懷ｺ + if ((dwBusIn & GPIO_INEDGE) == (dwBusBak & GPIO_INEDGE)) { + usleep(0); + continue; + } + + // 繝舌せ縺ｮ蜈･蜉帑ｿ｡蜿ｷ繧剃ｿ晏ｭ + dwBusBak = dwBusIn; + + // 縺昴ｂ縺昴ｂ繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ菫｡蜿ｷ縺檎┌縺代ｌ縺ｰ辟｡隕 + if (!bus.GetSEL() || bus.GetBSY()) { + continue; + } + + // 蜈ｨ繧ｳ繝ｳ繝医Ο繝ｼ繝ｩ縺ｫ騾夂衍 + for (i = 0; i < CtrlMax; i++) { + if (!ctrl[i]) { + continue; + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ縺ｫ遘ｻ陦後＠縺溘ち繝ｼ繧ｲ繝繝医ｒ謗｢縺 + if (ctrl[i]->Process() == BUS::selection) { + // 繧ｿ繝ｼ繧ｲ繝繝医ｮID繧貞叙蠕 + actid = i; + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + phase = BUS::selection; + break; + } + } + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ縺碁幕蟋九＆繧後※縺縺ｪ縺代ｌ縺ｰ繝舌せ縺ｮ逶｣隕悶∈謌ｻ繧 + if (phase != BUS::selection) { + continue; + } + + // 繧ｿ繝ｼ繧ｲ繝繝郁ｵｰ陦碁幕蟋 + + // 繧ｹ繧ｱ繧ｸ繝･繝ｼ繝ｪ繝ｳ繧ｰ繝昴Μ繧ｷ繝ｼ險ｭ螳(譛蜆ｪ蜈) + schparam.sched_priority = sched_get_priority_max(SCHED_FIFO); + sched_setscheduler(0, SCHED_FIFO, &schparam); + + // 繝舌せ繝輔Μ繝ｼ縺ｫ縺ｪ繧九∪縺ｧ繝ｫ繝ｼ繝 + while (bRun) { + // 繧ｿ繝ｼ繧ｲ繝繝磯ｧ蜍 + phase = ctrl[actid]->Process(); + + // 繝舌せ繝輔Μ繝ｼ縺ｫ縺ｪ縺｣縺溘ｉ邨ゆｺ + if (phase == BUS::busfree) { + break; + } + } + + // 繝舌せ繝輔Μ繝ｼ縺ｧ繧ｻ繝繧ｷ繝ｧ繝ｳ邨ゆｺ + actid = -1; + phase = BUS::busfree; + bus.Reset(); + dwBusBak = bus.Aquire(); + + // 繧ｹ繧ｱ繧ｸ繝･繝ｼ繝ｪ繝ｳ繧ｰ繝昴Μ繧ｷ繝ｼ險ｭ螳(繝弱ｼ繝槭Ν) + schparam.sched_priority = 0; + sched_setscheduler(0, SCHED_OTHER, &schparam); + } + + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + Cleanup(); + + // 邨ゆｺ + exit(0); +} diff --git a/src/raspberrypi/rasctl.cpp b/src/raspberrypi/rasctl.cpp new file mode 100644 index 00000000..3759ce8d --- /dev/null +++ b/src/raspberrypi/rasctl.cpp @@ -0,0 +1,247 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ 蛻ｶ蠕｡繧ｳ繝槭Φ繝蛾∽ｿ｡ ] +// +//--------------------------------------------------------------------------- + +#include "os.h" + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝蛾∽ｿ｡ +// +//--------------------------------------------------------------------------- +BOOL SendCommand(char *buf) +{ + int fd; + struct sockaddr_in server; + FILE *fp; + + // 繧ｳ繝槭Φ繝臥畑繧ｽ繧ｱ繝繝育函謌 + fd = socket(PF_INET, SOCK_STREAM, 0); + memset(&server, 0, sizeof(server)); + server.sin_family = PF_INET; + server.sin_port = htons(6868); + server.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + // 謗･邯 + if (connect(fd, (struct sockaddr *)&server, + sizeof(struct sockaddr_in)) < 0) { + fprintf(stderr, "Error : Can't connect to rascsi process\n"); + return FALSE; + } + + // 騾∽ｿ｡ + fp = fdopen(fd, "r+"); + setvbuf(fp, NULL, _IONBF, 0); + fprintf(fp, buf); + + // 繝｡繝繧ｻ繝ｼ繧ｸ蜿嶺ｿ｡ + while (1) { + if (fgets((char *)buf, BUFSIZ, fp) == NULL) { + break; + } + printf("%s", buf); + } + + // 繧ｽ繧ｱ繝繝医ｒ髢峨§繧 + fclose(fp); + close(fd); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 荳ｻ蜃ｦ逅 +// +//--------------------------------------------------------------------------- +int main(int argc, char* argv[]) +{ + int opt; + int id; + int cmd; + int type; + char *file; + BOOL list; + int len; + char *ext; + char buf[BUFSIZ]; + + id = -1; + cmd = -1; + type = -1; + file = NULL; + list = FALSE; + + // 繝倥Ν繝励ｮ陦ｨ遉ｺ + if (argc < 2) { + fprintf(stderr, "SCSI Target Emulator RaSCSI Controller\n"); + fprintf(stderr, + "Usage: %s -i ID [-c CMD] [-t TYPE] [-f FILE]\n", + argv[0]); + fprintf(stderr, " where ID := {0|1|2|3|4|5|6|7}\n"); + fprintf(stderr, " CMD := {attach|detatch|insert|eject|protect}\n"); + fprintf(stderr, " TYPE := {hd|mo|cd|bridge}\n"); + fprintf(stderr, " FILE := image file path\n"); + fprintf(stderr, " CMD is 'attach' or 'insert' and FILE parameter is required.\n"); + fprintf(stderr, "Usage: %s -l\n", argv[0]); + fprintf(stderr, " Print device list.\n"); + exit(0); + } + + // 蠑墓焚隗｣譫 + opterr = 0; + while ((opt = getopt(argc, argv, "i:c:t:f:l")) != -1) { + switch (opt) { + case 'i': + id = optarg[0] - '0'; + break; + + case 'c': + switch (optarg[0]) { + case 'a': // ATTACH + case 'A': + cmd = 0; + break; + case 'd': // DETACH + case 'D': + cmd = 1; + break; + case 'i': // INSERT + case 'I': + cmd = 2; + break; + case 'e': // EJECT + case 'E': + cmd = 3; + break; + case 'p': // PROTECT + case 'P': + cmd = 4; + break; + } + break; + + case 't': + switch (optarg[0]) { + case 's': // HD(SASI) + case 'S': + case 'h': // HD(SCSI) + case 'H': + type = 0; + break; + case 'm': // MO + case 'M': + type = 2; + break; + case 'c': // CD + case 'C': + type = 3; + break; + case 'b': // BRIDGE + case 'B': + type = 4; + break; + } + break; + + case 'f': + file = optarg; + break; + + case 'l': + list = TRUE; + break; + } + } + + // 繝ｪ繧ｹ繝郁｡ｨ遉ｺ縺ｮ縺ｿ + if (id < 0 && cmd < 0 && type < 0 && file == NULL && list) { + sprintf(buf, "list\n"); + SendCommand(buf); + exit(0); + } + + // ID繝√ぉ繝繧ｯ + if (id < 0 || id > 7) { + fprintf(stderr, "Error : Invalid ID\n"); + exit(EINVAL); + } + + // 繧ｳ繝槭Φ繝峨メ繧ｧ繝繧ｯ + if (cmd < 0) { + cmd = 0; // 繝繝輔か繝ｫ繝医ｯATTATCH縺ｨ縺吶ｋ + } + + // 繧ｿ繧､繝励メ繧ｧ繝繧ｯ + if (cmd == 0 && type < 0) { + + // 諡｡蠑ｵ蟄舌°繧峨ち繧､繝怜愛蛻･繧定ｩｦ縺ｿ繧 + len = file ? strlen(file) : 0; + if (len > 4 && file[len - 4] == '.') { + ext = &file[len - 3]; + if (xstrcasecmp(ext, "hdf") == 0 || + xstrcasecmp(ext, "hds") == 0 || + xstrcasecmp(ext, "hdn") == 0 || + xstrcasecmp(ext, "hdi") == 0 || + xstrcasecmp(ext, "nhd") == 0 || + xstrcasecmp(ext, "hda") == 0) { + // HD(SASI/SCSI) + type = 0; + } else if (xstrcasecmp(ext, "mos") == 0) { + // MO + type = 2; + } else if (xstrcasecmp(ext, "iso") == 0) { + // CD + type = 3; + } + } + + if (type < 0) { + fprintf(stderr, "Error : Invalid type\n"); + exit(EINVAL); + } + } + + // 繝輔ぃ繧､繝ｫ繝√ぉ繝繧ｯ(繧ｳ繝槭Φ繝峨ｯATTACH縺ｧ繧ｿ繧､繝励ｯHD) + if (cmd == 0 && type >= 0 && type <= 1) { + if (!file) { + fprintf(stderr, "Error : Invalid file path\n"); + exit(EINVAL); + } + } + + // 繝輔ぃ繧､繝ｫ繝√ぉ繝繧ｯ(繧ｳ繝槭Φ繝峨ｯINSERT) + if (cmd == 2) { + if (!file) { + fprintf(stderr, "Error : Invalid file path\n"); + exit(EINVAL); + } + } + + // 蠢隕√〒縺ｪ縺дype縺ｯ0縺ｨ縺励※縺翫￥ + if (type < 0) { + type = 0; + } + + // 騾∽ｿ｡繧ｳ繝槭Φ繝臥函謌 + sprintf(buf, "%d %d %d %s\n", id, cmd, type, file ? file : "-"); + if (!SendCommand(buf)) { + exit(ENOTCONN); + } + + // 繝ｪ繧ｹ繝郁｡ｨ遉ｺ + if (list) { + sprintf(buf, "list\n"); + SendCommand(buf); + } + + // 邨ゆｺ + exit(0); +} diff --git a/src/raspberrypi/rasdump.cpp b/src/raspberrypi/rasdump.cpp new file mode 100644 index 00000000..c1ceef53 --- /dev/null +++ b/src/raspberrypi/rasdump.cpp @@ -0,0 +1,1006 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// [ HDD繝繝ｳ繝励Θ繝ｼ繝繧｣繝ｪ繝繧｣(繧､繝九す繝ｼ繧ｨ繧ｿ繝｢繝ｼ繝) ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "fileio.h" +#include "filepath.h" +#include "gpiobus.h" + +//--------------------------------------------------------------------------- +// +// 螳壽焚螳｣險 +// +//--------------------------------------------------------------------------- +#define BUFSIZE 1024 * 64 // 64KB縺舌ｉ縺縺九↑縺 + +//--------------------------------------------------------------------------- +// +// 螟画焚螳｣險 +// +//--------------------------------------------------------------------------- +GPIOBUS bus; // 繝舌せ +int targetid; // 繧ｿ繝ｼ繧ｲ繝繝医ョ繝舌う繧ｹID +int boardid; // 繝懊ｼ繝迂D(閾ｪ霄ｫ縺ｮID) +Filepath hdsfile; // HDS繝輔ぃ繧､繝ｫ +BOOL restore; // 繝ｪ繧ｹ繝医い繝輔Λ繧ｰ +BYTE buffer[BUFSIZE]; // 繝ｯ繝ｼ繧ｯ繝舌ャ繝輔ぃ +int result; // 邨先棡繧ｳ繝ｼ繝 + +//--------------------------------------------------------------------------- +// +// 髢｢謨ｰ螳｣險 +// +//--------------------------------------------------------------------------- +void Cleanup(); + +//--------------------------------------------------------------------------- +// +// 繧ｷ繧ｰ繝翫Ν蜃ｦ逅 +// +//--------------------------------------------------------------------------- +void KillHandler(int sig) +{ + // 蛛懈ｭ｢謖遉ｺ + Cleanup(); + exit(0); +} + +//--------------------------------------------------------------------------- +// +// 繝舌リ繝ｼ蜃ｺ蜉 +// +//--------------------------------------------------------------------------- +BOOL Banner(int argc, char* argv[]) +{ + printf("RaSCSI hard disk dump utility "); + printf("version %01d.%01d%01d\n", + (int)((VERSION >> 8) & 0xf), + (int)((VERSION >> 4) & 0xf), + (int)((VERSION ) & 0xf)); + + if (argc < 2 || strcmp(argv[1], "-h") == 0) { + printf("Usage: %s -i ID [-b BID] -f FILE [-r]\n", argv[0]); + printf(" ID is target device SCSI ID {0|1|2|3|4|5|6|7}.\n"); + printf(" BID is rascsi board SCSI ID {0|1|2|3|4|5|6|7}. Default is 7.\n"); + printf(" FILE is HDS file path.\n"); + printf(" -r is restore operation.\n"); + return FALSE; + } + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 蛻晄悄蛹 +// +//--------------------------------------------------------------------------- +BOOL Init() +{ + // 蜑ｲ繧願ｾｼ縺ｿ繝上Φ繝峨Λ險ｭ螳 + if (signal(SIGINT, KillHandler) == SIG_ERR) { + return FALSE; + } + if (signal(SIGHUP, KillHandler) == SIG_ERR) { + return FALSE; + } + if (signal(SIGTERM, KillHandler) == SIG_ERR) { + return FALSE; + } + + // GPIO蛻晄悄蛹 + if (!bus.Init(BUS::INITIATOR)) { + return FALSE; + } + + // 繝ｯ繝ｼ繧ｯ蛻晄悄蛹 + targetid = -1; + boardid = 7; + restore = FALSE; + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 +// +//--------------------------------------------------------------------------- +void Cleanup() +{ + // 繝舌せ繧偵け繝ｪ繝ｼ繝ｳ繧｢繝繝 + bus.Cleanup(); +} + +//--------------------------------------------------------------------------- +// +// 繝ｪ繧ｻ繝繝 +// +//--------------------------------------------------------------------------- +void Reset() +{ + // 繝舌せ菫｡蜿ｷ邱壹ｒ繝ｪ繧ｻ繝繝 + bus.Reset(); +} + +//--------------------------------------------------------------------------- +// +// 蠑墓焚蜃ｦ逅 +// +//--------------------------------------------------------------------------- +BOOL ParseArgument(int argc, char* argv[]) +{ + int opt; + char *file; + + // 蛻晄悄蛹 + file = NULL; + + // 蠑墓焚隗｣譫 + opterr = 0; + while ((opt = getopt(argc, argv, "i:b:f:r")) != -1) { + switch (opt) { + case 'i': + targetid = optarg[0] - '0'; + break; + + case 'b': + boardid = optarg[0] - '0'; + break; + + case 'f': + file = optarg; + break; + + case 'r': + restore = TRUE; + break; + } + } + + // TARGET ID繝√ぉ繝繧ｯ + if (targetid < 0 || targetid > 7) { + fprintf(stderr, + "Error : Invalid target id range\n"); + return FALSE; + } + + // BOARD ID繝√ぉ繝繧ｯ + if (boardid < 0 || boardid > 7) { + fprintf(stderr, + "Error : Invalid board id range\n"); + return FALSE; + } + + // TARGET縺ｨBOARD縺ｮID驥崎､繝√ぉ繝繧ｯ + if (targetid == boardid) { + fprintf(stderr, + "Error : Invalid target or board id\n"); + return FALSE; + } + + // 繝輔ぃ繧､繝ｫ繝√ぉ繝繧ｯ + if (!file) { + fprintf(stderr, + "Error : Invalid file path\n"); + return FALSE; + } + + hdsfile.SetPath(file); + + return TRUE; +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぉ繝ｼ繧ｺ蠕縺｡ +// +//--------------------------------------------------------------------------- +BOOL WaitPhase(BUS::phase_t phase) +{ + int count; + + // REQ繧貞ｾ縺､(6遘) + count = 30000; + do { + usleep(200); + bus.Aquire(); + if (bus.GetREQ()) { + break; + } + } while (count--); + + // 繝輔ぉ繝ｼ繧ｺ縺御ｸ閾ｴ縺吶ｌ縺ｰOK + bus.Aquire(); + if (bus.GetPhase() == phase) { + return TRUE; + } + + // 繝輔ぉ繝ｼ繧ｺ縺御ｸ閾ｴ縺吶ｌ縺ｰOK(繝ｪ繝医Λ繧､) + usleep(1000 * 1000); + bus.Aquire(); + if (bus.GetPhase() == phase) { + return TRUE; + } + + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +void BusFree() +{ + bus.Reset(); +} + +//--------------------------------------------------------------------------- +// +// 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +BOOL Selection(int id) +{ + BYTE data; + int count; + + // ID險ｭ螳壹→SEL繧｢繧ｵ繝ｼ繝 + data = 0; + data |= (1 << boardid); + data |= (1 << id); + bus.SetDAT(data); + bus.SetSEL(TRUE); + + // BSY繧貞ｾ縺､ + count = 10000; + do { + usleep(20); + bus.Aquire(); + if (bus.GetBSY()) { + break; + } + } while (count--); + + // SEL繝阪ご繝ｼ繝 + bus.SetSEL(FALSE); + + // 繧ｿ繝ｼ繧ｲ繝繝医′繝薙ず繝ｼ迥ｶ諷九↑繧画仙粥 + return bus.GetBSY(); +} + +//--------------------------------------------------------------------------- +// +// 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +BOOL Command(BYTE *buf, int length) +{ + int count; + + // 繝輔ぉ繝ｼ繧ｺ蠕縺｡ + if (!WaitPhase(BUS::command)) { + return FALSE; + } + + // 繧ｳ繝槭Φ繝蛾∽ｿ｡ + count = bus.SendHandShake(buf, length); + + // 騾∽ｿ｡邨先棡縺御ｾ晞ｼ謨ｰ縺ｨ蜷後§縺ｪ繧画仙粥 + if (count == length) { + return TRUE; + } + + // 騾∽ｿ｡繧ｨ繝ｩ繝ｼ + return FALSE; +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +int DataIn(BYTE *buf, int length) +{ + int count; + + // 繝輔ぉ繝ｼ繧ｺ蠕縺｡ + if (!WaitPhase(BUS::datain)) { + return -1; + } + + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + return bus.ReceiveHandShake(buf, length); +} + +//--------------------------------------------------------------------------- +// +// 繝繝ｼ繧ｿ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +int DataOut(BYTE *buf, int length) +{ + int count; + + // 繝輔ぉ繝ｼ繧ｺ蠕縺｡ + if (!WaitPhase(BUS::dataout)) { + return -1; + } + + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + return bus.SendHandShake(buf, length); +} + +//--------------------------------------------------------------------------- +// +// 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +int Status() +{ + BYTE buf[256]; + + // 繝輔ぉ繝ｼ繧ｺ蠕縺｡ + if (!WaitPhase(BUS::status)) { + return -2; + } + + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + if (bus.ReceiveHandShake(buf, 1) == 1) { + return (int)buf[0]; + } + + // 蜿嶺ｿ｡繧ｨ繝ｩ繝ｼ + return -1; +} + +//--------------------------------------------------------------------------- +// +// 繝｡繝繧ｻ繝ｼ繧ｸ繧､繝ｳ繝輔ぉ繝ｼ繧ｺ螳溯｡ +// +//--------------------------------------------------------------------------- +int MessageIn() +{ + BYTE buf[256]; + + // 繝輔ぉ繝ｼ繧ｺ蠕縺｡ + if (!WaitPhase(BUS::msgin)) { + return -2; + } + + // 繝繝ｼ繧ｿ蜿嶺ｿ｡ + if (bus.ReceiveHandShake(buf, 1) == 1) { + return (int)buf[0]; + } + + // 蜿嶺ｿ｡繧ｨ繝ｩ繝ｼ + return -1; +} + +//--------------------------------------------------------------------------- +// +// TEST UNIT READY螳溯｡ +// +//--------------------------------------------------------------------------- +int TestUnitReady(int id) +{ + BYTE cmd[256]; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 6); + cmd[0] = 0x00; + if (!Command(cmd, 6)) { + result = -2; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + return result; +} + +//--------------------------------------------------------------------------- +// +// REQUEST SENSE螳溯｡ +// +//--------------------------------------------------------------------------- +int RequestSense(int id, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 6); + cmd[0] = 0x03; + cmd[4] = 0xff; + if (!Command(cmd, 6)) { + result = -2; + goto exit; + } + + // DATAIN + memset(buf, 0x00, sizeof(buf)); + count = DataIn(buf, 256); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// MODE SENSE螳溯｡ +// +//--------------------------------------------------------------------------- +int ModeSense(int id, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 6); + cmd[0] = 0x1a; + cmd[2] = 0x3f; + cmd[4] = 0xff; + if (!Command(cmd, 6)) { + result = -2; + goto exit; + } + + // DATAIN + memset(buf, 0x00, sizeof(buf)); + count = DataIn(buf, 256); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// INQUIRY螳溯｡ +// +//--------------------------------------------------------------------------- +int Inquiry(int id, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 6); + cmd[0] = 0x12; + cmd[4] = 0xff; + if (!Command(cmd, 6)) { + result = -2; + goto exit; + } + + // DATAIN + memset(buf, 0x00, sizeof(buf)); + count = DataIn(buf, 255); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// READ CAPACITY螳溯｡ +// +//--------------------------------------------------------------------------- +int ReadCapacity(int id, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 10); + cmd[0] = 0x25; + if (!Command(cmd, 10)) { + result = -2; + goto exit; + } + + // DATAIN + memset(buf, 0x00, sizeof(buf)); + count = DataIn(buf, 8); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// READ10螳溯｡ +// +//--------------------------------------------------------------------------- +int Read10(int id, DWORD bstart, DWORD blength, DWORD length, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 10); + cmd[0] = 0x28; + cmd[2] = (BYTE)(bstart >> 24); + cmd[3] = (BYTE)(bstart >> 16); + cmd[4] = (BYTE)(bstart >> 8); + cmd[5] = (BYTE)bstart; + cmd[7] = (BYTE)(blength >> 8); + cmd[8] = (BYTE)blength; + if (!Command(cmd, 10)) { + result = -2; + goto exit; + } + + // DATAIN + count = DataIn(buf, length); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// WRITE10螳溯｡ +// +//--------------------------------------------------------------------------- +int Write10(int id, DWORD bstart, DWORD blength, DWORD length, BYTE *buf) +{ + BYTE cmd[256]; + int count; + + // 邨先棡繧ｳ繝ｼ繝牙晄悄蛹 + result = 0; + + // SELECTION + if (!Selection(id)) { + result = -1; + goto exit; + } + + // COMMAND + memset(cmd, 0x00, 10); + cmd[0] = 0x2a; + cmd[2] = (BYTE)(bstart >> 24); + cmd[3] = (BYTE)(bstart >> 16); + cmd[4] = (BYTE)(bstart >> 8); + cmd[5] = (BYTE)bstart; + cmd[7] = (BYTE)(blength >> 8); + cmd[8] = (BYTE)blength; + if (!Command(cmd, 10)) { + result = -2; + goto exit; + } + + // DATAOUT + count = DataOut(buf, length); + if (count <= 0) { + result = -3; + goto exit; + } + + // STATUS + if (Status() < 0) { + result = -4; + goto exit; + } + + // MESSAGE IN + if (MessageIn() < 0) { + result = -5; + goto exit; + } + +exit: + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // 謌仙粥縺ｧ縺ゅｌ縺ｰ霆｢騾∵焚繧定ｿ斐☆ + if (result == 0) { + return count; + } + + return result; +} + +//--------------------------------------------------------------------------- +// +// 荳ｻ蜃ｦ逅 +// +//--------------------------------------------------------------------------- +int main(int argc, char* argv[]) +{ + int i; + int count; + char str[32]; + DWORD bsiz; + DWORD bnum; + DWORD duni; + DWORD dsiz; + DWORD dnum; + DWORD rest; + Fileio fio; + Fileio::OpenMode omode; + off64_t size; + + // 繝舌リ繝ｼ蜃ｺ蜉 + if (!Banner(argc, argv)) { + exit(0); + } + + // 蛻晄悄蛹 + if (!Init()) { + fprintf(stderr, "Error : Initializing\n"); + + // 諱舌ｉ縺俊oot縺ｧ縺ｯ辟｡縺ｼ + exit(EPERM); + } + + // 讒狗ｯ + if (!ParseArgument(argc, argv)) { + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + Cleanup(); + + // 蠑墓焚繧ｨ繝ｩ繝ｼ縺ｧ邨ゆｺ + exit(EINVAL); + } + + // 繝ｪ繧ｻ繝繝 + Reset(); + + // 繝輔ぃ繧､繝ｫ繧ｪ繝ｼ繝励Φ + if (restore) { + omode = Fileio::ReadOnly; + } else { + omode = Fileio::WriteOnly; + } + if (!fio.Open(hdsfile.GetPath(), omode)) { + fprintf(stderr, "Error : Can't open hds file\n"); + + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + Cleanup(); + exit(EPERM); + } + + // 繝舌せ繝輔Μ繝ｼ + BusFree(); + + // RESET繧ｷ繧ｰ繝翫Ν逋ｺ陦 + bus.SetRST(TRUE); + usleep(1000); + bus.SetRST(FALSE); + + // 繝繝ｳ繝鈴幕蟋 + printf("TARGET ID : %d\n", targetid); + printf("BORAD ID : %d\n", boardid); + + // TEST UNIT READY + count = TestUnitReady(targetid); + if (count < 0) { + fprintf(stderr, "TEST UNIT READY ERROR %d\n", count); + goto cleanup_exit; + } + + // REQUEST SENSE(for CHECK CONDITION) + count = RequestSense(targetid, buffer); + if (count < 0) { + fprintf(stderr, "REQUEST SENSE ERROR %d\n", count); + goto cleanup_exit; + } + + // INQUIRY + count = Inquiry(targetid, buffer); + if (count < 0) { + fprintf(stderr, "INQUIRY ERROR %d\n", count); + goto cleanup_exit; + } + + // INQUIRY縺ｮ諠蝣ｱ繧定｡ｨ遉ｺ + memset(str, 0x00, sizeof(str)); + memcpy(str, &buffer[8], 8); + printf("Vendor : %s\n", str); + memset(str, 0x00, sizeof(str)); + memcpy(str, &buffer[16], 16); + printf("Product : %s\n", str); + memset(str, 0x00, sizeof(str)); + memcpy(str, &buffer[32], 4); + printf("Revison : %s\n", str); + + // 螳ｹ驥丞叙蠕 + count = ReadCapacity(targetid, buffer); + if (count < 0) { + fprintf(stderr, "READ CAPACITY ERROR %d\n", count); + goto cleanup_exit; + } + + // 繝悶Ο繝繧ｯ繧ｵ繧､繧ｺ縺ｨ繝悶Ο繝繧ｯ謨ｰ縺ｮ陦ｨ遉ｺ + bsiz = + (buffer[4] << 24) | (buffer[5] << 16) | + (buffer[6] << 8) | buffer[7]; + bnum = + (buffer[0] << 24) | (buffer[1] << 16) | + (buffer[2] << 8) | buffer[3]; + bnum++; + printf("Number of blocks : %d Blocks\n", bnum); + printf("Block length : %d Bytes\n", bsiz); + printf("Unit Capacity : %d MBytes %d Bytes\n", + bsiz * bnum / 1024 / 1024, + bsiz * bnum); + + // 繝ｪ繧ｹ繝医い繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ縺ｮ蜿門ｾ + if (restore) { + size = fio.GetFileSize(); + printf("Restore file size : %d bytes", (int)size); + if (size != (off64_t)(bsiz * bnum)) { + printf("(WARNING : File size isn't equal to disk size)"); + } + printf("\n"); + } + + // 繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ豈弱↓繝繝ｳ繝励☆繧 + duni = BUFSIZE; + duni /= bsiz; + dsiz = BUFSIZE; + dnum = bnum * bsiz; + dnum /= BUFSIZE; + + if (restore) { + printf("Restore progress : "); + } else { + printf("Dump progress : "); + } + + for (i = 0; i < dnum; i++) { + if (i > 0) { + printf("\033[21D"); + printf("\033[0K"); + } + printf("%3d\%(%7d/%7d)", (i + 1) * 100 / dnum, i * duni, bnum); + fflush(stdout); + + if (restore) { + if (fio.Read(buffer, dsiz)) { + if (Write10(targetid, i * duni, duni, dsiz, buffer) >= 0) { + continue; + } + } + } else { + if (Read10(targetid, i * duni, duni, dsiz, buffer) >= 0) { + if (fio.Write(buffer, dsiz)) { + continue; + } + } + } + + printf("\n"); + printf("Error occured and aborted... %d\n", result); + goto cleanup_exit; + } + + // 螳ｹ驥丈ｸ翫ｮ遶ｯ謨ｰ蜃ｦ逅 + dnum = bnum % duni; + dsiz = dnum * bsiz; + if (dnum > 0) { + if (restore) { + if (fio.Read(buffer, dsiz)) { + Write10(targetid, i * duni, duni, dsiz, buffer); + } + } else { + if (Read10(targetid, i * duni, dnum, dsiz, buffer) >= 0) { + fio.Write(buffer, dsiz); + } + } + } + + // 螳御ｺ繝｡繝繧ｻ繝ｼ繧ｸ + printf("\033[21D"); + printf("\033[0K"); + printf("%3d\%(%7d/%7d)\n", 100, bnum, bnum); + +cleanup_exit: + // 繝輔ぃ繧､繝ｫ繧ｯ繝ｭ繝ｼ繧ｺ + fio.Close(); + + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + Cleanup(); + + // 邨ゆｺ + exit(0); +} diff --git a/src/raspberrypi/scsi.cpp b/src/raspberrypi/scsi.cpp new file mode 100644 index 00000000..b74e5aa6 --- /dev/null +++ b/src/raspberrypi/scsi.cpp @@ -0,0 +1,58 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2014-2018 GIMONS +// +// [ SCSI蜈ｱ騾 ] +// +//--------------------------------------------------------------------------- + +#include "os.h" +#include "xm6.h" +#include "scsi.h" + +//--------------------------------------------------------------------------- +// +// 繝輔ぉ繝ｼ繧ｺ蜿門ｾ +// +//--------------------------------------------------------------------------- +BUS::phase_t FASTCALL BUS::GetPhase() +{ + DWORD mci; + + ASSERT(this); + + // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + if (GetSEL()) { + return selection; + } + + // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + if (!GetBSY()) { + return busfree; + } + + // 繝舌せ縺ｮ菫｡蜿ｷ邱壹°繧峨ち繝ｼ繧ｲ繝繝医ｮ繝輔ぉ繝ｼ繧ｺ繧貞叙蠕 + mci = GetMSG() ? 0x04 : 0x00; + mci |= GetCD() ? 0x02 : 0x00; + mci |= GetIO() ? 0x01 : 0x00; + return GetPhase(mci); +} + +//--------------------------------------------------------------------------- +// +// 繝輔ぉ繝ｼ繧ｺ繝繝ｼ繝悶Ν +// +//--------------------------------------------------------------------------- +const BUS::phase_t BUS::phase_table[8] = { + dataout, + datain, + command, + status, + reserved, + reserved, + msgout, + msgin +}; diff --git a/src/raspberrypi/scsi.h b/src/raspberrypi/scsi.h new file mode 100644 index 00000000..5bed1f73 --- /dev/null +++ b/src/raspberrypi/scsi.h @@ -0,0 +1,128 @@ +//--------------------------------------------------------------------------- +// +// X68000 EMULATOR "XM6" +// +// Copyright (C) 2001-2006 ｼｰｼｩｼ(ytanaka@ipc-tokai.or.jp) +// Copyright (C) 2014-2018 GIMONS +// +// [ SCSI蜈ｱ騾 ] +// +//--------------------------------------------------------------------------- + +#if !defined(scsi_h) +#define scsi_h + +//=========================================================================== +// +// SASI/SCSI 繝舌せ +// +//=========================================================================== +class BUS +{ +public: + // 蜍穂ｽ懊Δ繝ｼ繝牙ｮ夂ｾｩ + enum mode_e { + TARGET = 0, + INITIATOR = 1, + MONITOR = 2, + }; + + // 繝輔ぉ繝ｼ繧ｺ螳夂ｾｩ + enum phase_t { + busfree, // 繝舌せ繝輔Μ繝ｼ繝輔ぉ繝ｼ繧ｺ + arbitration, // 繧｢繝ｼ繝薙ヨ繝ｬ繝ｼ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + selection, // 繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + reselection, // 繝ｪ繧ｻ繝ｬ繧ｯ繧ｷ繝ｧ繝ｳ繝輔ぉ繝ｼ繧ｺ + command, // 繧ｳ繝槭Φ繝峨ヵ繧ｧ繝ｼ繧ｺ + execute, // 螳溯｡後ヵ繧ｧ繝ｼ繧ｺ + datain, // 繝繝ｼ繧ｿ繧､繝ｳ + dataout, // 繝繝ｼ繧ｿ繧｢繧ｦ繝 + status, // 繧ｹ繝繝ｼ繧ｿ繧ｹ繝輔ぉ繝ｼ繧ｺ + msgin, // 繝｡繝繧ｻ繝ｼ繧ｸ繝輔ぉ繝ｼ繧ｺ + msgout, // 繝｡繝繧ｻ繝ｼ繧ｸ繧｢繧ｦ繝医ヵ繧ｧ繝ｼ繧ｺ + reserved // 譛ｪ菴ｿ逕ｨ/繝ｪ繧ｶ繝ｼ繝 + }; + + // 蝓ｺ譛ｬ繝輔ぃ繝ｳ繧ｯ繧ｷ繝ｧ繝ｳ + virtual BOOL FASTCALL Init(mode_e mode) = 0; + // 蛻晄悄蛹 + virtual void FASTCALL Reset() = 0; + // 繝ｪ繧ｻ繝繝 + virtual void FASTCALL Cleanup() = 0; + // 繧ｯ繝ｪ繝ｼ繝ｳ繧｢繝繝 + phase_t FASTCALL GetPhase(); + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + + static phase_t FASTCALL GetPhase(DWORD mci) + { + return phase_table[mci]; + } + // 繝輔ぉ繝ｼ繧ｺ蜿門ｾ + + virtual DWORD FASTCALL Aquire() = 0; + // 菫｡蜿ｷ蜿悶ｊ霎ｼ縺ｿ + + virtual BOOL FASTCALL GetBSY() = 0; + // BSY繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetBSY(BOOL ast) = 0; + // BSY繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetSEL() = 0; + // SEL繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetSEL(BOOL ast) = 0; + // SEL繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetATN() = 0; + // ATN繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetATN(BOOL ast) = 0; + // ATN繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetACK() = 0; + // ACK繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetACK(BOOL ast) = 0; + // ACK繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetRST() = 0; + // RST繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetRST(BOOL ast) = 0; + // RST繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetMSG() = 0; + // MSG繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetMSG(BOOL ast) = 0; + // MSG繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetCD() = 0; + // CD繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetCD(BOOL ast) = 0; + // CD繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetIO() = 0; + // IO繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetIO(BOOL ast) = 0; + // IO繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BOOL FASTCALL GetREQ() = 0; + // REQ繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetREQ(BOOL ast) = 0; + // REQ繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual BYTE FASTCALL GetDAT() = 0; + // 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν蜿門ｾ + virtual void FASTCALL SetDAT(BYTE dat) = 0; + // 繝繝ｼ繧ｿ繧ｷ繧ｰ繝翫Ν險ｭ螳 + + virtual int FASTCALL ReceiveHandShake(BYTE *buf, int count) = 0; + // 繝繝ｼ繧ｿ蜿嶺ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ + virtual int FASTCALL SendHandShake(BYTE *buf, int count) = 0; + // 繝繝ｼ繧ｿ騾∽ｿ｡繝上Φ繝峨す繧ｧ繧､繧ｯ + + virtual void FASTCALL SleepNsec(DWORD nsec) = 0; + // 繝翫ヮ遘貞腰菴阪ｮ繧ｹ繝ｪ繝ｼ繝 + +private: + static const phase_t phase_table[8]; + // 繝輔ぉ繝ｼ繧ｺ繝繝ｼ繝悶Ν +}; + +#endif // scsi_h diff --git a/src/raspberrypi/xm6.h b/src/raspberrypi/xm6.h new file mode 100644 index 00000000..cdd09a2c --- /dev/null +++ b/src/raspberrypi/xm6.h @@ -0,0 +1,49 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technology. +// Copyright (C) 2016-2018 GIMONS +// +// [ 蜈ｱ騾壼ｮ夂ｾｩ ] +// +//--------------------------------------------------------------------------- + +#if !defined(xm6_h) +#define xm6_h + +//--------------------------------------------------------------------------- +// +// VERSION +// +//--------------------------------------------------------------------------- +#define VERSION 0x0134 + +//--------------------------------------------------------------------------- +// +// RaSCSI +// +//--------------------------------------------------------------------------- +#define RASCSI VERSION + +//--------------------------------------------------------------------------- +// +// ID繝槭け繝ｭ +// +//--------------------------------------------------------------------------- +#define MAKEID(a, b, c, d) ((DWORD)((a<<24) | (b<<16) | (c<<8) | d)) + +//--------------------------------------------------------------------------- +// +// 繧ｯ繝ｩ繧ｹ螳｣險 +// +//--------------------------------------------------------------------------- +class Fileio; + // 繝輔ぃ繧､繝ｫ蜈･蜃ｺ蜉 +class Disk; + // SASI/SCSI繝繧｣繧ｹ繧ｯ +class Filepath; + // 繝輔ぃ繧､繝ｫ繝代せ + +#endif // xm6_h diff --git a/src/x68k/RASDRV/BRIDGE.C b/src/x68k/RASDRV/BRIDGE.C new file mode 100644 index 00000000..cf0f9918 --- /dev/null +++ b/src/x68k/RASDRV/BRIDGE.C @@ -0,0 +1,2414 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ ホストファイルシステム ブリッジドライバ ] +// +//--------------------------------------------------------------------------- + +#include +#include +#include +#include +#include +#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 コー +// ル処理内で設定されるので書き込む必要はない. +// +// +// (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()); +} diff --git a/src/x68k/RASDRV/BRIDGE.H b/src/x68k/RASDRV/BRIDGE.H new file mode 100644 index 00000000..b59c642d --- /dev/null +++ b/src/x68k/RASDRV/BRIDGE.H @@ -0,0 +1,256 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ ホストファイルシステム ブリッジドライバ ] +// +//--------------------------------------------------------------------------- + +#ifndef bridge_h +#define bridge_h + +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned long DWORD; +typedef int BOOL; + +#if !defined(FALSE) +#define FALSE 0 +#endif + +#if !defined(TRUE) +#define TRUE 1 +#endif + +#define FASTCALL +#define ASSERT(x) + +//--------------------------------------------------------------------------- +// +// 定数定義 +// +//--------------------------------------------------------------------------- +#define FILEPATH_MAX _MAX_PATH +#define WINDRV_CLIPSIZE_MAX 0xC00000 + +//--------------------------------------------------------------------------- +// +// ステータスコード定義 +// +//--------------------------------------------------------------------------- +#define FS_INVALIDFUNC 0xFFFFFFFF // 無効なファンクションコードを実行した +#define FS_FILENOTFND 0xFFFFFFFE // 指定したファイルが見つからない +#define FS_DIRNOTFND 0xFFFFFFFD // 指定したディレクトリが見つからない +#define FS_OVEROPENED 0xFFFFFFFC // オープンしているファイルが多すぎる +#define FS_CANTACCESS 0xFFFFFFFB // ディレクトリやボリュームラベルはアクセス不可 +#define FS_NOTOPENED 0xFFFFFFFA // 指定したハンドルはオープンされていない +#define FS_INVALIDMEM 0xFFFFFFF9 // メモリ管理領域が破壊された +#define FS_OUTOFMEM 0xFFFFFFF8 // 実行に必要なメモリがない +#define FS_INVALIDPTR 0xFFFFFFF7 // 無効なメモリ管理ポインタを指定した +#define FS_INVALIDENV 0xFFFFFFF6 // 不正な環境を指定した +#define FS_ILLEGALFMT 0xFFFFFFF5 // 実行ファイルのフォーマットが異常 +#define FS_ILLEGALMOD 0xFFFFFFF4 // オープンのアクセスモードが異常 +#define FS_INVALIDPATH 0xFFFFFFF3 // ファイル名の指定に誤りがある +#define FS_INVALIDPRM 0xFFFFFFF2 // 無効なパラメータでコールした +#define FS_INVALIDDRV 0xFFFFFFF1 // ドライブ指定に誤りがある +#define FS_DELCURDIR 0xFFFFFFF0 // カレントディレクトリは削除できない +#define FS_NOTIOCTRL 0xFFFFFFEF // IOCTRLできないデバイス +#define FS_LASTFILE 0xFFFFFFEE // これ以上ファイルが見つからない +#define FS_CANTWRITE 0xFFFFFFED // 指定のファイルは書き込みできない +#define FS_DIRALREADY 0xFFFFFFEC // 指定のディレクトリは既に登録されている +#define FS_CANTDELETE 0xFFFFFFEB // ファイルがあるので削除できない +#define FS_CANTRENAME 0xFFFFFFEA // ファイルがあるのでリネームできない +#define FS_DISKFULL 0xFFFFFFE9 // ディスクが一杯でファイルが作れない +#define FS_DIRFULL 0xFFFFFFE8 // ディレクトリが一杯でファイルが作れない +#define FS_CANTSEEK 0xFFFFFFE7 // 指定の位置にはシークできない +#define FS_SUPERVISOR 0xFFFFFFE6 // スーパーバイザ状態でスーパバイザ指定した +#define FS_THREADNAME 0xFFFFFFE5 // 同じスレッド名が存在する +#define FS_BUFWRITE 0xFFFFFFE4 // プロセス間通信のバッファが書込み禁止 +#define FS_BACKGROUND 0xFFFFFFE3 // バックグラウンドプロセスを起動できない +#define FS_OUTOFLOCK 0xFFFFFFE0 // ロック領域が足りない +#define FS_LOCKED 0xFFFFFFDF // ロックされていてアクセスできない +#define FS_DRIVEOPENED 0xFFFFFFDE // 指定のドライブはハンドラがオープンされている +#define FS_LINKOVER 0xFFFFFFDD // シンボリックリンクネストが16回を超えた +#define FS_FILEEXIST 0xFFFFFFB0 // ファイルが存在する + +#define FS_FATAL_MEDIAOFFLINE 0xFFFFFFA3 // メディアが入っていない +#define FS_FATAL_WRITEPROTECT 0xFFFFFFA2 // 書き込み禁止違反 +#define FS_FATAL_INVALIDCOMMAND 0xFFFFFFA1 // 不正なコマンド番号 +#define FS_FATAL_INVALIDUNIT 0xFFFFFFA0 // 不正なユニット番号 + +#define HUMAN68K_PATH_MAX 96 // Human68kのパス最大長 + +//=========================================================================== +// +/// Human68k 名前空間 +// +//=========================================================================== +/// ファイル属性ビット +enum attribute_t { + AT_READONLY = 0x01, // 読み込み専用属性 + AT_HIDDEN = 0x02, // 隠し属性 + AT_SYSTEM = 0x04, // システム属性 + AT_VOLUME = 0x08, // ボリュームラベル属性 + AT_DIRECTORY= 0x10, // ディレクトリ属性 + AT_ARCHIVE = 0x20, // アーカイブ属性 + AT_ALL = 0xFF, // 全ての属性ビットが1 +}; + +/// ファイルオープンモード +enum open_t { + OP_READ = 0, // 読み込み + OP_WRITE = 1, // 書き込み + OP_FULL = 2, // 読み書き + OP_MASK = 0x0F, // 判定用マスク + OP_SHARE_NONE = 0x10, // 共有禁止 + OP_SHARE_READ = 0x20, // 読み込み共有 + OP_SHARE_WRITE = 0x30, // 書き込み共有 + OP_SHARE_FULL = 0x40, // 読み書き共有 + OP_SHARE_MASK = 0x70, // 共有判定用マスク + OP_SPECIAL = 0x100,// 辞書アクセス +}; + +/// シーク種類 +enum seek_t { + SK_BEGIN = 0, // ファイル先頭から + SK_CURRENT = 1, // 現在位置から + SK_END = 2, // ファイル末尾から +}; + +/// メディアバイト +enum media_t { + MEDIA_2DD_10 = 0xE0, // 2DD/10セクタ + MEDIA_1D_9 = 0xE5, // 1D/9セクタ + MEDIA_2D_9 = 0xE6, // 2D/9セクタ + MEDIA_1D_8 = 0xE7, // 1D/8セクタ + MEDIA_2D_8 = 0xE8, // 2D/8セクタ + MEDIA_2HT = 0xEA, // 2HT + MEDIA_2HS = 0xEB, // 2HS + MEDIA_2HDE = 0xEC, // 2DDE + MEDIA_1DD_9 = 0xEE, // 1DD/9セクタ + MEDIA_1DD_8 = 0xEF, // 1DD/8セクタ + MEDIA_MANUAL = 0xF1, // リモートドライブ (手動イジェクト) + MEDIA_REMOVABLE = 0xF2, // リモートドライブ (リムーバブル) + MEDIA_REMOTE = 0xF3, // リモートドライブ + MEDIA_DAT = 0xF4, // SCSI-DAT + MEDIA_CDROM = 0xF5, // SCSI-CDROM + MEDIA_MO = 0xF6, // SCSI-MO + MEDIA_SCSI_HD = 0xF7, // SCSI-HD + MEDIA_SASI_HD = 0xF8, // SASI-HD + MEDIA_RAMDISK = 0xF9, // RAMディスク + MEDIA_2HQ = 0xFA, // 2HQ + MEDIA_2DD_8 = 0xFB, // 2DD/8セクタ + MEDIA_2DD_9 = 0xFC, // 2DD/9セクタ + MEDIA_2HC = 0xFD, // 2HC + MEDIA_2HD = 0xFE, // 2HD +}; + +/// namests構造体 +typedef struct { + BYTE wildcard; // ワイルドカード文字数 + BYTE drive; // ドライブ番号 + BYTE path[65]; // パス(サブディレクトリ+/) + BYTE name[8]; // ファイル名 (PADDING 0x20) + BYTE ext[3]; // 拡張子 (PADDING 0x20) + BYTE add[10]; // ファイル名追加 (PADDING 0x00) +} namests_t; + +/// files構造体 +typedef struct { + BYTE fatr; // + 0 検索する属性 読込専用 + BYTE pad1[3]; // padding +// BYTE drive; // + 1 ドライブ番号 読込専用 + DWORD sector; // + 2 ディレクトリのセクタ DOS _FILES先頭アドレスで代用 +// WORD cluster; // + 6 ディレクトリのクラスタ 詳細不明 (未使用) + WORD offset; // + 8 ディレクトリエントリ 書込専用 +// BYTE name[8]; // +10 作業用ファイル名 読込専用 (未使用) +// BYTE ext[3]; // +18 作業用拡張子 読込専用 (未使用) + BYTE attr; // +21 ファイル属性 書込専用 + BYTE pad2; // padding + WORD time; // +22 最終変更時刻 書込専用 + WORD date; // +24 最終変更月日 書込専用 + DWORD size; // +26 ファイルサイズ 書込専用 + BYTE full[23]; // +30 フルファイル名 書込専用 + BYTE pad3; // padding +} files_t; + +/// FCB構造体 +typedef struct { +// BYTE pad00[6]; // + 0〜+ 5 (未使用) + DWORD fileptr; // + 6〜+ 9 ファイルポインタ +// BYTE pad01[4]; // +10〜+13 (未使用) + WORD mode; // +14〜+15 オープンモード +// BYTE pad02[16]; // +16〜+31 (未使用) +// DWORD zero; // +32〜+35 オープンのとき0が書き込まれている (未使用) +// BYTE name[8]; // +36〜+43 ファイル名 (PADDING 0x20) (未使用) +// BYTE ext[3]; // +44〜+46 拡張子 (PADDING 0x20) (未使用) + BYTE attr; // +47 ファイル属性 + BYTE pad; // padding +// BYTE add[10]; // +48〜+57 ファイル名追加 (PADDING 0x00) (未使用) + WORD time; // +58〜+59 最終変更時刻 + WORD date; // +60〜+61 最終変更月日 +// WORD cluster; // +62〜+63 クラスタ番号 (未使用) + DWORD size; // +64〜+67 ファイルサイズ +// BYTE pad03[28]; // +68〜+95 FATキャッシュ (未使用) +} fcb_t; + +/// capacity構造体 +typedef struct { + WORD freearea; // + 0 使用可能なクラスタ数 + WORD clusters; // + 2 総クラスタ数 + WORD sectors; // + 4 クラスタあたりのセクタ数 + WORD bytes; // + 6 セクタ当たりのバイト数 +} capacity_t; + +/// ctrldrive構造体 +typedef struct { + BYTE status; // +13 状態 + BYTE pad[3]; // padding +} ctrldrive_t; + +/// DPB構造体 +typedef struct { + WORD sector_size; // + 0 1セクタ当りのバイト数 + BYTE cluster_size; // + 2 1クラスタ当りのセクタ数-1 + BYTE shift; // + 3 クラスタ→セクタのシフト数 + WORD fat_sector; // + 4 FATの先頭セクタ番号 + BYTE fat_max; // + 6 FAT領域の個数 + BYTE fat_size; // + 7 FATの占めるセクタ数(複写分を除く) + WORD file_max; // + 8 ルートディレクトリに入るファイルの個数 + WORD data_sector; // +10 データ領域の先頭セクタ番号 + WORD cluster_max; // +12 総クラスタ数+1 + WORD root_sector; // +14 ルートディレクトリの先頭セクタ番号 +// DWORD driverentry; // +16 デバイスドライバへのポインタ (未使用) + BYTE media; // +20 メディア識別子 +// BYTE flag; // +21 DPB使用フラグ (未使用) + BYTE pad; // padding +} dpb_t; + +/// ディレクトリエントリ構造体 +typedef struct { + BYTE name[8]; // + 0 ファイル名 (PADDING 0x20) + BYTE ext[3]; // + 8 拡張子 (PADDING 0x20) + BYTE attr; // +11 ファイル属性 + BYTE add[10]; // +12 ファイル名追加 (PADDING 0x00) + WORD time; // +22 最終変更時刻 + WORD date; // +24 最終変更月日 + WORD cluster; // +26 クラスタ番号 + DWORD size; // +28 ファイルサイズ +} dirent_t; + +/// IOCTRLパラメータ共用体 +typedef union { + BYTE buffer[8]; // バイト単位でのアクセス + DWORD param; // パラメータ(先頭4バイト) + WORD media; // メディアバイト(先頭2バイト) +} ioctrl_t; + +/// コマンドライン引数構造体 +typedef struct { + BYTE buf[256]; // コマンドライン引数 +} argument_t; + +#endif // bridge_h diff --git a/src/x68k/RASDRV/Makefile b/src/x68k/RASDRV/Makefile new file mode 100644 index 00000000..4a449de3 --- /dev/null +++ b/src/x68k/RASDRV/Makefile @@ -0,0 +1,17 @@ +# +# Makefile for RASDRV.SYS +# + +CC = gcc -O2 -Wall -fomit-frame-pointer +AS = has +LK = hlk -l -x + +RASDRV.SYS : RASDRV.o BRIDGE.o + $(LK) -o $@ $^ libc.a libiocs.a libscsi.a + +RASDRV.o : RASDRV.S + $(AS) $^ + +BRIDGE.o : BRIDGE.C + $(CC) -c -o $@ $^ + \ No newline at end of file diff --git a/src/x68k/RASDRV/RASDRV.S b/src/x68k/RASDRV/RASDRV.S new file mode 100644 index 00000000..4bd36f1e --- /dev/null +++ b/src/x68k/RASDRV/RASDRV.S @@ -0,0 +1,193 @@ +*--------------------------------------------------------------------------- +* +* SCSI Target Emulator RaSCSI (*^..^*) +* for Raspberry Pi +* +* Powered by XM6 TypeG Technorogy. +* Copyright (C) 2016-2017 GIMONS +* [ ホストファイルシステム ブリッジドライバ ] +* +* Based on +* X68k Emulator Host Filesystem Driver version 0.27 +* Programmed By co +* +*--------------------------------------------------------------------------- + + CPU 68010 + + INCLUDE DOSCALL.MAC + INCLUDE IOCSCALL.MAC + +.XREF _Init, _Process ;bridge.c + +COMMAND EQU 2 コマンド番号 +ERRLOW EQU 3 エラーコード下位8ビット +ERRHIGH EQU 4 エラーコード上位8ビット +MXUNIT EQU 13 ユニット数 +DEVEND EQU 14 ドライバ終了アドレス +BDEVNO EQU 22 ベースドライブ番号 + +DDHEADER: + DC.L -1 +$00 リンクポインタ + DC.W $2040 +$04 デバイス属性 + DC.L DDSTRATEGY +$06 + DC.L DDENTRY_FIRST +$0A + DC.B '*EMUHOST' +$0E デバイス名 + +DDREQUEST: + DC.L 0 + +DDSTRATEGY: + MOVE.L A5,DDREQUEST + RTS + +*デバイスドライバエントリ +DDENTRY: + MOVE.L SP,(STACK_BUFF) + LEA (DEF_STACK),SP + MOVEM.L D1-D3/A0-A2,-(SP) + MOVEM.L DDREQUEST(PC),D0 D0.L: リクエストヘッダアドレス + MOVE.L D0,-(SP) + BSR _Process + ADDQ.L #4,SP + MOVEM.L (SP)+,D1-D3/A0-A2 + MOVEA.L (STACK_BUFF),SP + RTS + +KEEP_HERE: + +*初回のみのデバイスドライバエントリ +DDENTRY_FIRST: + MOVEM.L D1-D3/A0-A2/A5,-(SP) + MOVEA.L DDREQUEST(PC),A5 A5.L: リクエストヘッダアドレス +* CMPI.B #$40,COMMAND(A5) 現行のHuman68kではチェック不要 +* BNE UNSUPPORTED エラー: 未対応 + +*タイトル表示 + PEA MESSAGE_TITLE(PC) + DOS _PRINT + ADDQ.L #4,SP + +*デバイスチェック +DEVICE_CHECK: + BSR _Init + + TST.L D0 + BEQ NOTFOUND エラー: デバイスが存在しません + +*常駐開始 + LEA DDENTRY(PC),A1 + + LEA DDHEADER+$0A(PC),A0 + MOVE.L A1,(A0) ドライバエントリを設定 + MOVE.L #PROG_END,DEVEND(A5) 常駐終了アドレスを設定 + + ST.B MXUNIT(A5) ポート未実装の判定のため負の値を設定しておく + JSR (A1) ドライバエントリを実行 + + TST.B MXUNIT(A5) ユニット数確認 + BLE NODRIVE エラー: ドライブがありません + + MOVE.B BDEVNO(A5),D0 + MOVE.B MXUNIT(A5),D1 + LEA FIRSTDRIVE(PC),A0 + ADD.B D0,(A0) 開始ドライブ名書き換え + ADD.B D1,D0 終了ドライブ名書き換え + ADD.B D0,LASTDRIVE-FIRSTDRIVE(A0) + + PEA MESSAGE_DRIVENAME(PC) 正常: ドライブA: + DOS _PRINT + + PEA MESSAGE_DRIVENAME2(PC) 正常: からZ: + SUBQ.B #2,D1 + BCS @F + DOS _PRINT +@@ ADDQ.L #8,SP + + PEA MESSAGE_DRIVENAME3(PC) 正常: を登録しました + BRA QUIT + +NOTFOUND: + PEA MESSAGE_NOTFOUND(PC) エラー: デバイスが存在しません + BRA ABORT + +UNSUPPORTED: + PEA MESSAGE_UNSUPPORTED(PC) エラー: 未対応 + BRA ABORT + +NODRIVE: + PEA MESSAGE_NODRIVE(PC) エラー: ドライブがありません + +ABORT: + MOVE.B #$0D,ERRLOW(A5) + MOVE.B #$70,ERRHIGH(A5) + +QUIT: + DOS _PRINT + ADDQ.L #4,SP + + MOVEM.L (SP)+,D1-D3/A0-A2/A5 + RTS + +SECRET: + PEA MESSAGE_TITLE2(PC) + DOS _PRINT + PEA CREDIT(PC) + DOS _PRINT + ADDQ.L #8,SP + DOS _EXIT + + DATA + +*エラーメッセージ +MESSAGE_NOTFOUND: + DC.B 'デバイスが存在しません',$0D,$0A,0 + +MESSAGE_UNSUPPORTED: + DC.B '未対応',$0D,$0A,0 + +MESSAGE_NODRIVE: + DC.B 'ドライブがありません',$0D,$0A,0 + +*登録メッセージ +MESSAGE_DRIVENAME: + DC.B 'ドライブ' +FIRSTDRIVE: + DC.B 'A:',0 +MESSAGE_DRIVENAME2: + DC.B 'から' +LASTDRIVE: + DC.B '@:',0 +MESSAGE_DRIVENAME3: + DC.B 'を登録しました',$0D,$0A,0 + +*タイトル +MESSAGE_TITLE: + DC.B $0D,$0A +MESSAGE_TITLE2: + DC.B 'RaSCSI FileSystem Driver version 1.21',$0D,$0A,0 + +*ありがとう！ +CREDIT: + DC.B 'Coded by GIMONS',$0D,$0A + DC.B 'Special thanks to',$0D,$0A + DC.B 9,'co',$0D,$0A + DC.B 9,'ＰＩ．',$0D,$0A + DC.B 9,'立花＠桑島技研',$0D,$0A + DC.B 0 + + BSS + QUAD + +STACK_BUFF: + .DS.L 1 + + STACK + QUAD + + .DS.B 1024*2 +DEF_STACK: + + +PROG_END: + END SECRET diff --git a/src/x68k/RASDRV/RASDRV.TXT b/src/x68k/RASDRV/RASDRV.TXT new file mode 100644 index 00000000..cbb094e2 --- /dev/null +++ b/src/x68k/RASDRV/RASDRV.TXT @@ -0,0 +1,29 @@ +RaSCSI ファイルシステムドライバ +RASDRV version 1.21 + +■概要 + +　本プログラムはX68000実機で動作しているHuman68kからRaSCSIのブリッジデバイスを + 通してRaspberry Pi側のファイルシステムを直接操作するためのデバイスドライバです。 +　X68000エミュレータであるXM6及びXM6改ならびにTypeGのWindrvXMと同等の機能を提供 +　します。 + +■解説 + +　利用するにはRaspberry PiのRaSCSIでブリッジデバイスを有効にする必要があります。 + 例えばSCSI ID6にブリッジデバイスを有効にする場合はrascsi -ID6 BRIDGEといった + 指定が必要です。 + +　次にデバイスドライバRASCSI.SYSを実機の環境にコピーします。あとはCONFIG.SYSの + 後半部分に以下のように記述してください。 + + DEVICE = \SYS\RASDRV.SYS + +　起動オプションを指定しない場合はRaspberry Piのルートディレクトリ配下をマウント +　します。引数にディレクトリ名を指定することでそのディレクトリをマウントできます。 + 例えば/home/pi/appと/home/pi/dataというディレクトリをマウントする場合は + + DEVICE = \SYS\RASDRV.SYS /home/pi/app /home/pi/data + + と記述することで二つのディレクトリを別々のドライブとしてマウント可能です。 + その他のオプションとしてWindrvXMのものが指定可能です。 diff --git a/src/x68k/RASETHER/Makefile b/src/x68k/RASETHER/Makefile new file mode 100644 index 00000000..92557b33 --- /dev/null +++ b/src/x68k/RASETHER/Makefile @@ -0,0 +1,33 @@ +# +# Makefile for RASETHER.SYS +# + +TARGET = RASETHER.SYS + +OBJS = re.o asmsub.o main.o scsictl.o +LIBS = libc.a libgnu.a libscsi.a + +CC = gcc -O2 -Wall -fomit-frame-pointer +CFLAGS = -D__DOS_INLINE__ -D__IOCS_INLINE__ +#CFLAGS = -D__DOS_INLINE__ -D__IOCS_INLINE__ -DUSE_DMA + +AS = has +ASFLAGS = +LD = hlk +LDFLAGS = -l -x + +all: $(TARGET) + +$(TARGET): $(OBJS) + $(LD) $(LDFLAGS) -o $@ $^ $(LIBS) + +scsictl.o: scsictl.c scsictl.h + $(COMPILE.c) $< + +main.o: main.c main.h scsictl.h + $(COMPILE.c) $< + +asmsub.o: asmsub.s + +# EOF + \ No newline at end of file diff --git a/src/x68k/RASETHER/RASETHER.DOC b/src/x68k/RASETHER/RASETHER.DOC new file mode 100644 index 00000000..5e37f13c --- /dev/null +++ b/src/x68k/RASETHER/RASETHER.DOC @@ -0,0 +1,42 @@ +RaSCSI用 Ethernetドライバ +RASETHER version 1.20 + +Based on + Neptune-X board driver for Human-68k(ESP-X) version 0.03 + Programed 1996-7 by Shi-MAD. + Special thanks to Niggle, FIRST, yamapu ... + +● このプログラムは + + Shi-MAD さんの作られた Ethernet 用 ISA バスブリッジ "Neptune-X" 用デバ + イスドライバ ether_ne.sys を改造した ether_ne.sys ver0.03 +M01 +1 +L12を + 参考にして開発したRaSCSI用のイーサーネット通信ドライバです。 + +● 使い方 + + 基本的にはオリジナルのドライバと同じようにデバイスドライバとしてCONFIG.SYS + で組み込んで下さい。 + +　例） + DEVICE = \SYS\RASETHER.SYS + +　以下のオプションが指定可能です。 + -tx [xは数字] : 使用するtrapを指定します。xは０から６が指定可能です。 + ただし、指定したtrapが使用中である場合は、trap #0から + 空いている所を自動探索し、見つかった空きtrapを利用し + ます。 + -n : APIにtrapを使用しません。 + + RASETHERで拡張したオプションは以下のとおりです。 + -px [xは数字] : パケット受信のポーリング間隔を指定します1がデフォルトです。 + 1の場合は約16ms毎にポーリングします。2,3･･･8まで指定が可能 + です。数字が一つ増えるごとに16ms間隔が大きくなります。 + + -ix [xは数字] : ポーリングに使用する割り込みのタイプを指定します。 + デフォルトは0でMFPのGPIP割り込み(V-DISP)を利用します。 + 1を指定するとTimer-A割り込みを使用します。 + + +● このドライバについて + オリジナルのether_ne.sys及び改造版のether_ne.sys ver0.03 +M01 +1 +L12の + 利用規定に従います。 diff --git a/src/x68k/RASETHER/asmsub.s b/src/x68k/RASETHER/asmsub.s new file mode 100644 index 00000000..87d85957 --- /dev/null +++ b/src/x68k/RASETHER/asmsub.s @@ -0,0 +1,22 @@ +* asmsub.s + + .xdef _DI, _EI * ne2000.c nagai. + + .text + .even + + + +_DI: + move.w sr,sendp_sr + ori.w #$700,sr + rts +_EI: + move.w sendp_sr,sr + rts + +sendp_sr: + .ds.w 1 + + + .even diff --git a/src/x68k/RASETHER/main.c b/src/x68k/RASETHER/main.c new file mode 100644 index 00000000..a6b6bb4a --- /dev/null +++ b/src/x68k/RASETHER/main.c @@ -0,0 +1,282 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ RaSCSI イーサーネット メイン ] +// +// Based on +// Neptune-X board driver for Human-68k(ESP-X) version 0.03 +// Programed 1996-7 by Shi-MAD. +// Special thanks to Niggle, FIRST, yamapu ... +// +//--------------------------------------------------------------------------- + +#include +#include +#include +#include "main.h" +#include "scsictl.h" + +unsigned int scsiid; +int trap_no; +int num_of_prt; +struct prt PRT_LIST[NPRT]; + +// マルチキャスト（未対応） +#ifdef MULTICAST +int num_of_multicast; +struct eaddr multicast_array[NMULTICAST]; +#endif + +/************************************************ + * * + ************************************************/ +static int sprint_eaddr(unsigned char* dst, void* e) +{ + unsigned char* p = e; + + return sprintf( + dst, + "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x", + p[0], p[1], p[2], p[3], p[4], p[5]); +} + +/************************************************ + * TRAP nが使用可能か調べる * + ************************************************/ +static int is_valid_trap(int trap_no) +{ + unsigned int addr; + + if (trap_no < 0 || 7 < trap_no) { + return 0; + } + + // 使用中かどうかチェック + addr = (unsigned int)_dos_intvcg(TRAP_VECNO(trap_no)); + + // 処理アドレスの最上位バイトにベクタ番号が入っていれば未使用 + if (addr & 0xff000000) { + return -1; + } + + return 0; +} + +/************************************************ + * 未使用のTRAP nを検索 * + ************************************************/ +static int search_trap_no(int def) +{ + int i; + + // もしdefが使用可能ならそれに決定 + if (is_valid_trap(def)) { + return def; + } + + for (i = 0; i <= 6; i++) { + if (is_valid_trap(i)) { + return i; + } + } + + return -1; +} + +/************************************************ + * vector set * + ************************************************/ +static void* trap_vector(int trap_no, void *func) +{ + return _dos_intvcs(TRAP_VECNO(trap_no), func); +} + +/************************************************ + 初期化関数（ne.sイニシャライズで呼びます） * + ************************************************/ +int Initialize(void) +{ + unsigned char buff[128]; + unsigned char buff2[32]; + struct eaddr ether_addr; + + if (SearchRaSCSI()) + { + Print("RaSCSI Ether Adapter の存在を確認できませんでした\r\n"); + return -1; + } + + if (InitList(NPRT) + || InitRaSCSI()) + { + Print("RaSCSI Ether Adapter Driver の初期化に失敗しました\r\n"); + return -1; + } + + memset(ðer_addr, 0x00, sizeof(ether_addr)); + GetMacAddr(ðer_addr); + + // 未使用trap番号を調べる（指定番号優先） + if (trap_no >= 0) { + trap_no = search_trap_no(trap_no); + } + + if (trap_no >= 0) { + // trapをフックする + trap_vector(trap_no, (void*)trap_entry); + sprintf(buff, " API trap number:%d ", trap_no); + } else { + sprintf(buff, " API trap number:n/a "); + } + Print(buff); + + sprintf(buff, "SCSI ID:%d ", scsiid); + Print(buff); + + sprint_eaddr(buff2, ether_addr.eaddr); + sprintf(buff, "MAC Addr:%s\r\n", buff2); + Print(buff); + + // ポーリング開始 + RegisterIntProcess(poll_interval); + + return 0; +} + +/************************************************ + * プロトコルリスト初期化 * + ************************************************/ +int InitList(int n) +{ + struct prt* p; + int i; + + p = &PRT_LIST[0]; + for (i = 0; i < NPRT; i++, p++) { + p->type = -1; + p->func = 0; + p->malloc = (malloc_func)-1; + } + num_of_prt = 0; + +#ifdef MULTICAST + num_of_multicast = 0; +#endif + + return 0; +} + +/************************************************ + * 受信ハンドラ（プロトコル）追加 * + ************************************************/ +int AddList(int type, int_handler handler) +{ + struct prt* p; + int i, result; + + if (type == -1) { + return -1; + } + + result = -1; + + // overwrite if alreay exist + p = &PRT_LIST[0]; + for (i = 0; i < NPRT; i++, p++) { + if ((p->type == type && p->malloc != (malloc_func)-1) + || p->type == -1) + { + if (p->type == -1) + num_of_prt++; + + p->type = type; + p->func = handler; + p->malloc = (malloc_func)-1; + i++; + p++; + result = 0; + break; + } + } + + // clear if exist more + for (; i < NPRT; i++, p++) { + if (p->type == type && p->malloc != (malloc_func)-1) { + p->type = -1; + } + } + + return result; +} + +/************************************************ + * 受信ハンドラ（プロトコル）削除 * + ************************************************/ +int DeleteList(int type) +{ + struct prt* p; + int i, result; + + if (type == -1) { + return -1; + } + + result = -1; + for (i = 0, p = &PRT_LIST[0]; i < NPRT; i++, p++) { + if (p->type == type && p->malloc != (malloc_func)-1) { + p->type = -1; + result = 0; + num_of_prt--; + } + } + + return result; +} + +/************************************************ + * 受信ハンドラ（プロトコル）サーチ * + ************************************************/ +int_handler SearchList(int type) +{ + struct prt* p; + int i; + + if (type == -1) { + return 0; + } + + for (i = 0, p = &PRT_LIST[0]; i < NPRT; i++, p++) { + if (p->type == type) { + return p->func; + } + } + + return 0; +} + + +/************************************************ + * 受信ハンドラ（プロトコル）サーチ * + ************************************************/ +int_handler SearchList2(int type, int n) +{ + struct prt *p; + int i, cur; + + if (type == -1) { + return NULL; + } + + cur = 0; + for (i = 0, p = &PRT_LIST[0]; i < NPRT; i++, p++) { + if (p->type == type && cur++ == n) { + return p->func; + } + } + + return NULL; +} diff --git a/src/x68k/RASETHER/main.h b/src/x68k/RASETHER/main.h new file mode 100644 index 00000000..fa481a06 --- /dev/null +++ b/src/x68k/RASETHER/main.h @@ -0,0 +1,81 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ RaSCSI イーサーネット メイン ] +// +// Based on +// Neptune-X board driver for Human-68k(ESP-X) version 0.03 +// Programed 1996-7 by Shi-MAD. +// Special thanks to Niggle, FIRST, yamapu ... +// +//--------------------------------------------------------------------------- + +#ifndef main_h +#define main_h + +#define ID_EN0 (('e'<<24)+('n'<<16)+('0'<<8)) +#undef MULTICAST + +// number of protocol type we can handle **EDIT this** +#define NPRT (16) + +// number of multicast address we can handle **EDIT this** +#define NMULTICAST (64) +/* ただし、まだマルチキャストには対応していない */ + +struct eaddr { + unsigned char eaddr [6]; +}; + +typedef void (*int_handler) (int, void*, int); +typedef void (*malloc_func) (unsigned int*); + +struct prt { + int type; + int_handler func; + malloc_func malloc; +}; + + +// グローバル変数 +extern unsigned int scsiid; +extern int trap_no; +extern int num_of_prt; +extern struct prt PRT_LIST [NPRT]; + +#ifdef MULTICAST +extern int num_of_multicast; +extern struct eaddr multicast_array [NMULTICAST]; +#endif + + +// プロトタイプ宣言 +extern int Initialize (void); +extern int InitList (int); +extern int AddList (int, int_handler); +extern int DeleteList (int); +extern int_handler SearchList (int); +extern int_handler SearchList2 (int, int); +extern malloc_func GetMallocFunc (int, int); + +#ifdef MULTICAST +extern int AddMulticastArray (struct eaddr*); +extern void DelMulticastArray (struct eaddr*); +extern void MakeMulticastTable (unsigned char*); +#endif + + +// ne.s 内関数 +extern void trap_entry (void); + + +#include +#define Print _iocs_b_print + +#define TRAP_VECNO(n) (0x20 + n) + +#endif // main_h diff --git a/src/x68k/RASETHER/re.s b/src/x68k/RASETHER/re.s new file mode 100644 index 00000000..2eba98a8 --- /dev/null +++ b/src/x68k/RASETHER/re.s @@ -0,0 +1,574 @@ +**--------------------------------------------------------------------------- +** +** SCSI Target Emulator RaSCSI (*^..^*) +** for Raspberry Pi +** +** Powered by XM6 TypeG Technorogy. +** Copyright (C) 2016-2017 GIMONS +** [ RaSCSI イーサーネット ドライバ ] +** +** Based on +** Neptune-X board driver for Human-68k(ESP-X) version 0.03 +** Programed 1996-7 by Shi-MAD. +** Special thanks to Niggle, FIRST, yamapu ... +** +**--------------------------------------------------------------------------- + +* Include Files ----------------------- * + + .include doscall.mac + .include iocscall.mac + + +* Global Symbols ---------------------- * + +* +* Ｃ言語用 外部宣言 +* + .xref _Initialize, _AddList, _SearchList, _DeleteList ;main.c + .xref _GetMacAddr, _SetMacAddr ;scsictl.c + .xref _SendPacket, _SetPacketReception ;scsictl.c +* .xref _AddMulticastAddr, _DelMulticastAddr ;未実装 + +* +* Ｃ言語用 外部変数 +* + .xref _num_of_prt ;main.c 登録プロトコル数 + .xref _trap_no ;使用trapナンバー + .xref _trans_counter ;scsictl.c 送信/受信バイト数 + .xref _intr_type ;scsictl.c 割り込み種別 + .xref _poll_interval ;scsictl.c ポーリング間隔 + + +* Text Section -------------------------------- * + + .cpu 68000 + .text + + +* +* デバイスヘッダー +* +device_header: + .dc.l -1 ;リンクポインター + .dc $8000 ;device att. + .dc.l strategy_entry ;stategy entry + .dc.l interupt_entry ;interupt entry + .dc.b '/dev/en0' ;device name + .dc.b 'EthD' ;for etherlib.a + .dc.b 'RASC' ;driver name (この後にエントリーを置く) + +* 'RASC' から superjsr_entry の間には何も置かないこと + +* +* イーサドライバ 関数 エントリー ( for DOS _SUPERJSR ) +* in: d0: command number +* a0: args +* +superjsr_entry: + movem.l d1-d7/a1-a7,-(sp) + +* move.l d0,-(sp) +* pea (mes11,pc) +* DOS _PRINT +* addq.l #4,sp +* move.l (sp)+,d0 +* .data +*mes11: .dc.b 'en0:spjEntry',13,10,0 +* .text + + bsr do_command + movem.l (sp)+,d1-d7/a1-a7 + rts ;普通のリターン + + +* +* イーサドライバ 関数 エントリー ( for trap #n ) +* in: d0: command number +* a0: args +* +_trap_entry:: + movem.l d1-d7/a1-a7,-(sp) + +* move.l d0,-(sp) +* pea (mes10,pc) +* DOS _PRINT +* addq.l #4,sp +* move.l (sp)+,d0 +* .data +*mes10: .dc.b 'en0:trapEntry',13,10,0 +* .text + + bsr do_command + movem.l (sp)+,d1-d7/a1-a7 + rte ;割り込みリターン + + +* +* 各処理ふりわけ +* +do_command: + moveq #FUNC_MIN,d1 + cmp.l d0,d1 + bgt error ;d0<-2 なら未対応コマンド番号 + moveq #FUNC_MAX,d1 + cmp.l d1,d0 + bgt error ;9 + bsr _SetPacketReception ;割り込み許可 ... scsictl.c + addq.l #4,sp + +* moveq #0,d0 ;SetPacketReception() で常に 0 が返るので省略 +set_int_addr_rts: + rts + + +* +* コマンド 06: 割り込みハンドラのアドレス取得 +* return: interupt address +* +get_int_addr: +* pea (mes07,pc) +* DOS _PRINT +* addq.l #4,sp +* .data +*mes07: .dc.b 'GetIntAddr',13,10,0 +* .text + + pea (a0) + bsr _SearchList + addq.l #4,sp + rts + + +* +* コマンド 07: 割り込みハンドラの削除 +* return: 0 (if no errors) +* +del_int_addr: +* pea (mes06,pc) +* DOS _PRINT +* addq.l #4,sp +* .data +*mes06: .dc.b 'DelIntAddr',13,10,0 +* .text + + pea (a0) + bsr _DeleteList ;main.c 関数 + move.l d0,(sp)+ + bmi del_int_addr_ret ;削除失敗 + + tst.l (_num_of_prt) ;ハンドラが一つもなくなれば割り込みを禁止する + bne del_int_addr_ret + + clr.l -(sp) ;0=<禁止> + bsr _SetPacketReception ;割り込み禁止 ... scsictl.c + addq.l #4,sp + +* moveq #0,d0 ;SetPacketReception() で常に 0 が返るので省略 +del_int_addr_ret: + rts + + +* +* コマンド 08: マルチキャストアドレスの設定 +* +set_multicast_addr: +* pea (mes08,pc) +* .data +* DOS _PRINT +* addq.l #4,sp +*mes08: .dc.b 'SetMulticastAddr',13,10,0 +* .text + + moveq #0,d0 + rts + + +* +* コマンド 09: 統計読み出し +* +get_statistics: +* pea (mes09,pc) +* DOS _PRINT +* addq.l #4,sp +* .data +*mes09: .dc.b 'GetStatistics',13,10,0 +* .text + + moveq #0,d0 + rts + +* +* デバイスドライバエントリー +* +strategy_entry: + move.l a5,(request_buffer) + rts + + +interupt_entry: + move.l sp,(stack_buff) ;自前のスタックエリアを使う + lea (def_stack),sp ; + + movem.l d1-d7/a0-a5,-(sp) + movea.l (request_buffer,pc),a5 + tst.b (2,a5) + bne errorret + + pea (mestitle,pc) + DOS _PRINT + addq.l #4,sp + movea.l (18,a5),a4 +@@: + tst.b (a4)+ + bne @b + + moveq #0,d0 + move.l d0,(_trap_no) + move.l d0,(_intr_type) + moveq #1,d0 + move.l d0,(_poll_interval) + +arg_loop: + move.b (a4)+,d0 + beq arg_end + cmpi.b #'-',d0 + beq @f + cmpi.b #'/',d0 + bne param_errret +@@: + move.b (a4)+,d0 + beq param_errret +opt_loop: + andi.b #$df,d0 + cmpi.b #'I',d0 + beq opt_i + cmpi.b #'P',d0 + beq opt_p + cmpi.b #'T',d0 + beq opt_t + cmpi.b #'N',d0 + beq opt_n + bra param_errret + +opt_n: + moveq #-1,d0 + move.l d0,(_trap_no) + move.b (a4)+,d0 + beq arg_loop + bra opt_loop + +opt_t: + bsr get_num + tst.b d0 + bne param_errret + cmpi #6,d2 + bgt param_errret + move.l d2,(_trap_no) + move.b (a4)+,d0 + beq arg_loop + bra opt_loop + +opt_p: + bsr get_num + tst.b d0 + bne param_errret + cmpi #1,d2 + blt param_errret + cmpi #8,d2 + bgt param_errret + move.l d2,(_poll_interval) + move.b (a4)+,d0 + beq arg_loop + bra opt_loop + +opt_i: + bsr get_num + tst.b d0 + bne param_errret + cmpi #1,d2 + bgt param_errret + move.l d2,(_intr_type) + move.b (a4)+,d0 + beq arg_loop + bra opt_loop + +arg_end: + bsr _Initialize ;main.c 関数 + ;I/Oアドレス設定 + ;MACアドレス取得 + ;プロトコルリスト初期化 + ;SCSICTL初期化 + ;割り込みハンドラ（ベクタ設定） + ;trapサービス（ベクタ設定） + tst.l d0 + bne errorret + +* moveq #0,d0 + move.l #prog_end,(14,a5) + bra intret + + +param_errret: + pea (mesparam_err,pc) + DOS _PRINT + addq.l #4,sp +errorret: + move #$5003,d0 +intret: + move.b d0,(4,a5) + lsr #8,d0 + move.b d0,(3,a5) + movem.l (sp)+,d1-d7/a0-a5 + + movea.l (stack_buff,pc),sp ;スタックポインタを元にもどす + rts + +get_num: + moveq #1,d0 + moveq #0,d1 + moveq #0,d2 +@@: + move.b (a4),d1 + subi.b #'0',d1 + bcs @f + cmpi.b #9,d1 + bgt @f + move.b #0,d0 + andi #$f,d1 + mulu #10,d2 + add d1,d2 + addq.l #1,a4 + bra @b +@@: + rts + + +* Data Section ------------------------ * + + .data +mestitle: + .dc.b 13,10 + .dc.b 'RaSCSI Ethernet Driver version 1.20 / Based on ether_ne.sys+M01L12',13,10 + .dc.b 0 +mesparam_err: + .dc.b 'パラメータが異常です',13,10,0 + .even + + +* BSS --------------------------------- * + + .bss + .quad + +stack_buff: + .ds.l 1 +request_buffer: + .ds.l 1 +stack_buff_i: + .ds.l 1 + + +* Stack Section ----------------------- * + + .stack + .quad + +* +* スタックエリア +* + .ds.b 1024*8 +def_stack: + +prog_end: + .end + + +* EOF --------------------------------- * diff --git a/src/x68k/RASETHER/scsictl.c b/src/x68k/RASETHER/scsictl.c new file mode 100644 index 00000000..8d30dc6d --- /dev/null +++ b/src/x68k/RASETHER/scsictl.c @@ -0,0 +1,537 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ RaSCSI イーサーネット SCSI制御部 ] +// +// Based on +// Neptune-X board driver for Human-68k(ESP-X) version 0.03 +// Programed 1996-7 by Shi-MAD. +// Special thanks to Niggle, FIRST, yamapu ... +// +//--------------------------------------------------------------------------- + +#include +#include +#include +#include +#include +#include "main.h" +#include "scsictl.h" + +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; + +typedef struct +{ + INQUIRY_T info; + char options[8]; +} INQUIRYOPT_T; + +#define MFP_AEB 0xe88003 +#define MFP_IERB 0xe88009 +#define MFP_IMRB 0xe88015 + +// asmsub.s 内のサブルーチン +extern void DI(); +extern void EI(); + +volatile short* iocsexec = (short*)0xa0e; // IOCS実行中ワーク +struct trans_counter trans_counter; // 送受信カウンタ +unsigned char rx_buff[2048]; // 受信バッファ +int imr; // 割り込み許可フラグ +int scsistop; // SCSI停止中フラグ +int intr_type; // 割り込み種別(0:V-DISP 1:TimerA) +int poll_interval; // ポーリング間隔(設定) +int poll_current; // ポーリング間隔(現在) +int idle; // アイドルカウンタ + +#define POLLING_SLEEP 255 // 4-5s + +/************************************************ + * MACアドレス取得命令発行 * + ************************************************/ +int SCSI_GETMACADDR(unsigned char *mac) +{ + unsigned char cmd[10]; + unsigned char sts; + unsigned char msg; + + if (S_SELECT(scsiid) != 0) { + return 0; + } + + cmd[0] = 0x28; + cmd[1] = 0; + cmd[2] = 1; + cmd[3] = 0; + cmd[4] = 0; + cmd[5] = 0; + cmd[6] = 0; + cmd[7] = 0; + cmd[8] = 6; + cmd[9] = 0; + if (S_CMDOUT(10, cmd) != 0) { + return 0; + } + +#ifdef USE_DMA + if (S_DATAIN(6, mac) != 0) { +#else + if (S_DATAIN_P(6, mac) != 0) { +#endif + return 0; + } + + S_STSIN(&sts); + S_MSGIN(&msg); + + return 1; +} + +/************************************************ + * MACアドレス設定命令発行 * + ************************************************/ +int SCSI_SETMACADDR(const unsigned char *mac) +{ + unsigned char cmd[10]; + unsigned char sts; + unsigned char msg; + + if (S_SELECT(scsiid) != 0) { + return 0; + } + + cmd[0] = 0x2a; + cmd[1] = 0; + cmd[2] = 1; + cmd[3] = 0; + cmd[4] = 0; + cmd[5] = 0; + cmd[6] = 0; + cmd[7] = 0; + cmd[8] = 6; + cmd[9] = 0; + if (S_CMDOUT(10, cmd) != 0) { + return 0; + } + +#ifdef USE_DMA + S_DATAOUT(6, mac); +#else + S_DATAOUT_P(6, mac); +#endif + + S_STSIN(&sts); + S_MSGIN(&msg); + + return 1; +} + +/************************************************ + * パケット受信サイズ取得命令発行 * + ************************************************/ +int SCSI_GETPACKETLEN(int *len) +{ + unsigned char cmd[10]; + unsigned char buf[2]; + unsigned char sts; + unsigned char msg; + + if (S_SELECT(scsiid) != 0) { + return 0; + } + + cmd[0] = 0x28; + cmd[1] = 0; + cmd[2] = 1; + cmd[3] = 1; + cmd[4] = 0; + cmd[5] = 0; + cmd[6] = 0; + cmd[7] = 0; + cmd[8] = 2; + cmd[9] = 0; + if (S_CMDOUT(10, cmd) != 0) { + return 0; + } + +#ifdef USE_DMA + if (S_DATAIN(2, buf) != 0) { +#else + if (S_DATAIN_P(2, buf) != 0) { +#endif + return 0; + } + + S_STSIN(&sts); + S_MSGIN(&msg); + + *len = (int)(buf[0] << 8) + (int)(buf[1]); + + return 1; +} + +/************************************************ + * パケット受信命令発行 * + ************************************************/ +int SCSI_GETPACKETBUF(unsigned char *buf, int len) +{ + unsigned char cmd[10]; + unsigned char sts; + unsigned char msg; + + if (S_SELECT(scsiid) != 0) { + return 0; + } + + cmd[0] = 0x28; + cmd[1] = 0; + cmd[2] = 1; + cmd[3] = 1; + cmd[4] = 0; + cmd[5] = 0; + cmd[6] = (unsigned char)(len >> 16); + cmd[7] = (unsigned char)(len >> 8); + cmd[8] = (unsigned char)len; + cmd[9] = 1; + if (S_CMDOUT(10, cmd) != 0) { + return 0; + } + +#ifdef USE_DMA + if (S_DATAIN(len, buf) != 0) { +#else + if (S_DATAIN_P(len, buf) != 0) { +#endif + return 0; + } + + S_STSIN(&sts); + S_MSGIN(&msg); + + return 1; +} + +/************************************************ + * パケット送信命令発行 * + ************************************************/ +int SCSI_SENDPACKET(const unsigned char *buf, int len) +{ + unsigned char cmd[10]; + unsigned char sts; + unsigned char msg; + + if (S_SELECT(scsiid) != 0) { + return 0; + } + + cmd[0] = 0x2a; + cmd[1] = 0; + cmd[2] = 1; + cmd[3] = 1; + cmd[4] = 0; + cmd[5] = 0; + cmd[6] = (unsigned char)(len >> 16); + cmd[7] = (unsigned char)(len >> 8); + cmd[8] = (unsigned char)len; + cmd[9] = 0; + if (S_CMDOUT(10, cmd) != 0) { + return 0; + } + +#ifdef USE_DMA + S_DATAOUT(len, buf); +#else + S_DATAOUT_P(len, buf); +#endif + S_STSIN(&sts); + S_MSGIN(&msg); + + return 1; +} + +/************************************************ + * MACアドレス取得 * + ************************************************/ +int GetMacAddr(struct eaddr* buf) +{ + if (SCSI_GETMACADDR(buf->eaddr) != 0) { + return 0; + } else { + return -1; + } +} + +/************************************************ + * MACアドレス設定 * + ************************************************/ +int SetMacAddr(const struct eaddr* data) +{ + if (SCSI_SETMACADDR(data->eaddr) != 0) { + return 0; + } else { + return -1; + } +} + +/************************************************ + * RaSCSI検索 * + ************************************************/ +int SearchRaSCSI() +{ + int i; + INQUIRYOPT_T inq; + + for (i = 0; i <= 7; i++) { + // BRIDGEデバイス検索 + if (S_INQUIRY(sizeof(INQUIRY_T) , i, (struct INQUIRY*)&inq) < 0) { + continue; + } + + if (memcmp(&(inq.info.ProductID), "RASCSI BRIDGE", 13) != 0) { + continue; + } + + // TAP初期化状態を取得 + if (S_INQUIRY(sizeof(INQUIRYOPT_T) , i, (struct INQUIRY*)&inq) < 0) { + continue; + } + + if (inq.options[1] != '1') { + continue; + } + + // SCSI ID確定 + scsiid = i; + return 0; + } + + return -1; +} + +/************************************************ + * RaSCSI初期化 関数 * + ************************************************/ +int InitRaSCSI(void) +{ +#ifdef MULTICAST + unsigned char multicast_table[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; +#endif + + imr = 0; + scsistop = 0; + poll_current = -1; + idle = 0; + + return 0; +} + +/************************************************ + * RaSCSI 割り込み処理 関数(ポーリング) * + ************************************************/ +void interrupt IntProcess(void) +{ + unsigned char phase; + unsigned int len; + int type; + int_handler func; + int i; + + // V-DISP GPIP割り込みはアイドルカウンタで制御 + if (intr_type == 0) { + // アイドル加算 + idle++; + + // 次回の処理予定に到達していないならスキップ + if (idle < poll_current) { + return; + } + + // アイドルカウンタをクリア + idle = 0; + } + + // 割り込み開始 + + // 割り込み許可の時だけ + if (imr == 0) { + return; + } + + // IOCS実行中ならばスキップ + if (*iocsexec != -1) { + return; + } + + // 受信処理中は割り込み禁止 + DI (); + + // バスフリーの時だけ + phase = S_PHASE(); + if (phase != 0) { + // 終了 + goto ei_exit; + } + + // 受信処理 + if (SCSI_GETPACKETLEN(&len) == 0) { + // RaSCSI停止中 + scsistop = 1; + + // ポーリング間隔の再設定(寝る) + UpdateIntProcess(POLLING_SLEEP); + + // 終了 + goto ei_exit; + } + + // RaSCSIは動作中 + if (scsistop) { + scsistop = 0; + + // ポーリング間隔の再設定(急ぐ) + UpdateIntProcess(poll_interval); + } + + // パケットは到着してなかった + if (len == 0) { + // 終了 + goto ei_exit; + } + + // 受信バッファメモリへパケット転送 + if (SCSI_GETPACKETBUF(rx_buff, len) == 0) { + // 失敗 + goto ei_exit; + } + + // 割り込み許可 + EI (); + + // パケットタイプでデータ分別 + type = rx_buff[12] * 256 + rx_buff[13]; + i = 0; + while ((func = SearchList2(type, i))) { + i++; + func(len, (void*)&rx_buff, ID_EN0); + } + trans_counter.recv_byte += len; + return; + +ei_exit: + // 割り込み許可 + EI (); +} + +/************************************************ + * RaSCSI パケット送信 関数 (ne.sから) * + ************************************************/ +int SendPacket(int len, const unsigned char* data) +{ + if (len < 1) { + return 0; + } + + if (len > 1514) { // 6 + 6 + 2 + 1500 + return -1; // エラー + } + + // RaSCSI停止中のようならエラー + if (scsistop) { + return -1; + } + + // 送信処理中は割り込み禁止 + DI (); + + // 送信処理と送信フラグアップ + if (SCSI_SENDPACKET(data, len) == 0) { + // 割り込み許可 + EI (); + return -1; + } + + // 割り込み許可 + EI (); + + // 送信依頼済み + trans_counter.send_byte += len; + + return 0; +} + +/************************************************ + * RaSCSI 割り込み許可、不許可設定 関数 * + ************************************************/ +int SetPacketReception(int i) +{ + imr = i; + return 0; +} + +/************************************************ + * RaSCSI 割り込み処理登録 * + ************************************************/ +void RegisterIntProcess(int n) +{ + volatile unsigned char *p; + + // ポーリング間隔(現在)の更新とアイドルカウンタクリア + poll_current = n; + idle = 0; + + if (intr_type == 0) { + // V-DISP GPIP割り込みベクタを書き換えて + // 割り込みを有効にする + B_INTVCS(0x46, (int)IntProcess); + p = (unsigned char *)MFP_AEB; + *p = *p | 0x10; + p = (unsigned char *)MFP_IERB; + *p = *p | 0x40; + p = (unsigned char *)MFP_IMRB; + *p = *p | 0x40; + } else if (intr_type == 1) { + // TimerAはカウントモードを設定 + VDISPST(NULL, 0, 0); + VDISPST(IntProcess, 0, poll_current); + } +} + +/************************************************ + * RaSCSI 割り込み処理変更 * + ************************************************/ +void UpdateIntProcess(int n) +{ + // ポーリング間隔(現在)と同じなら更新しない + if (n == poll_current) { + return; + } + + // ポーリング間隔(現在)の更新とアイドルカウンタクリア + poll_current = n; + idle = 0; + + if (intr_type == 1) { + // TimerAは再登録必要 + VDISPST(NULL, 0, 0); + VDISPST(IntProcess, 0, poll_current); + } +} + +// EOF diff --git a/src/x68k/RASETHER/scsictl.h b/src/x68k/RASETHER/scsictl.h new file mode 100644 index 00000000..ae6bf477 --- /dev/null +++ b/src/x68k/RASETHER/scsictl.h @@ -0,0 +1,40 @@ +//--------------------------------------------------------------------------- +// +// SCSI Target Emulator RaSCSI (*^..^*) +// for Raspberry Pi +// +// Powered by XM6 TypeG Technorogy. +// Copyright (C) 2016-2017 GIMONS +// [ RaSCSI イーサーネット SCSI制御部 ] +// +// Based on +// Neptune-X board driver for Human-68k(ESP-X) version 0.03 +// Programed 1996-7 by Shi-MAD. +// Special thanks to Niggle, FIRST, yamapu ... +// +//--------------------------------------------------------------------------- + +#ifndef scsictl_h +#define scsictl_h + +// グローバル変数 +extern int intr_type; +extern int poll_interval; + +// 送受信カウンタ +struct trans_counter { + unsigned int send_byte; + unsigned int recv_byte; +}; +extern struct trans_counter trans_counter; + +extern int SearchRaSCSI(); +extern int InitRaSCSI(void); +extern int GetMacAddr(struct eaddr* buf); +extern int SetMacAddr(const struct eaddr* data); +extern int SetPacketReception(int i); +extern int SendPacket(int len, const unsigned char* data); +extern void RegisterIntProcess(int n); +extern void UpdateIntProcess(int n); + +#endif // scsictl_h