--- nono/vm/spc.cpp	2026/04/29 17:04:36	1.1.1.4
+++ nono/vm/spc.cpp	2026/04/29 17:05:37	1.1.1.18
@@ -4,50 +4,37 @@
 // Licensed under nono-license.txt
 //
 
+//
+// SPC (MB89352)
+//
+
 #include "spc.h"
+#include "config.h"
 #include "mainapp.h"
-#include "mpu680x0.h"
-#include "mpu88xx0.h"
-#include "mystring.h"
+#include "monitor.h"
+#include "pedec.h"
 #include "scheduler.h"
-#include "vm.h"
+#include "scsidev.h"
 
 // time 時間後に呼び出すコールバックをセットする。
 // func の書式が面倒なのを省略して書きたいため。
 #define CallAfter(func_, name_, time_)	do { \
-	event.func = (DeviceCallback_t)&SPCDevice::func_; \
-	event.SetName(name_); \
-	event.code = 0; \
-	event.time = time_; \
-	event.Start(); \
+	phase_event.func = ToEventCallback(&SPCDevice::func_); \
+	phase_event.time = time_; \
+	phase_event.SetName(name_); \
+	scheduler->RestartEvent(phase_event); \
 } while (0)
 
-std::unique_ptr<SPCDevice> gSPC;
-
 // コンストラクタ
 SPCDevice::SPCDevice()
+	: inherited(OBJ_SPC)
 {
-	logname = "spc";
-	devname = "SPC";
-	// これらは XIOSpace で必要なので、LUNA ではダミー。
-	// もうちょっといい方法を考えたほうがいい。
-	devaddr = 0xe96000;
-	devlen = 0x2000;
-
-	SetConfigName("spc0");
-	myid = -1;
-
-	monitor.Init(70, 15);
+	// 初期値は不定だが表示上困るのでとりあえず。
+	myid = 7;
 
-	// 汎用イベント
-	// 名前とコールバック関数は都度セットする。
-	event.dev = this;
-	event.SetName("SPC phase");
-
-	// TC カウンタイベント
-	event_tc.dev = this;
-	event_tc.code = 0;
-	event_tc.SetName("SPC Timer");
+	monitor = gMonitorManager->Regist(ID_MONITOR_SPC, this);
+	monitor->func = ToMonitorCallback(&SPCDevice::MonitorUpdate);
+	// サイズは Init で決まる
 }
 
 // デストラクタ
@@ -56,56 +43,94 @@ SPCDevice::~SPCDevice()
 }
 
 bool
-SPCDevice::Init()
+SPCDevice::Create()
 {
-	if (!inherited::Init()) {
+	if (inherited::Create() == false) {
 		return false;
 	}
 
+	scsi.reset(new SCSIHostDevice(this, "spc0"));
+	if ((bool)scsi == false) {
+		return false;
+	}
+	scsi->SetCallback(
+		ToBusFreeCallback(&SPCDevice::BusFreeCallback),
+		ToSCSIHostCallback(&SPCDevice::SelectionAckCallback),
+		ToSCSIHostCallback(&SPCDevice::TransferReqCallback));
+
+	return true;
+}
+
+// 初期化
+bool
+SPCDevice::Init()
+{
 	// 実行中に別インスタンスを頻繁に参照しないようにここで vmtype を覚えておく
 	vmtype = gMainApp.GetVMType();
 
 	// 入力クロックは機種によって異なる。
 	// X68k は 5MHz が入っている。
-	// LUNA-I はおそらく 6.144MHz だと思われる。LUNA88K は未確認。
+	// LUNA-I はおそらく 6.144MHz だと思われる。LUNA-88K は未確認。
 	const ConfigItem& item = gConfig->Find("!spc-tCLF");
 	t_CLF = item.AsInt();
 
-	return true;
-}
-
+	// アクセスウェイト
+	if (vmtype == VMType::X68030) {
+		// InsideOut p.135
+		read_wait  = busdata::Wait(18 * 40_nsec);
+		write_wait = busdata::Wait(19 * 40_nsec);
+	} else {
+		// 他機種は未調査だけど、判明するまでの間とりあえず
+		// ノーウェイトでない適当な値を入れておく。
+		read_wait  = busdata::Wait(18 * 40_nsec);
+		write_wait = busdata::Wait(19 * 40_nsec);
+	}
 
-// 本体リセットスイッチによるリセット
-void
-SPCDevice::ResetHard()
-{
-	// LUNA は本体回路が分からないのでとりあえずこっち。
-	if (vmtype != VMTYPE_X68030) {
-		Reset();
+	// 割り込み信号線の接続先
+	if (vmtype == VMType::X68030) {
+		// X68030 は PEDEC (I/O コントローラ) にカスケード
+		interrupt = GetPEDECDevice();
+	} else {
+		interrupt = GetInterruptDevice();
 	}
-}
 
-// MPU の RESET 命令によるリセット
-void
-SPCDevice::ResetSoft()
-{
-	// X680x0 はこっちだと分かっている。
-	if (vmtype == VMTYPE_X68030) {
-		Reset();
+	// 汎用イベント
+	// 名前とコールバック関数は都度セットする。
+	phase_event.SetName("SPC Phase");
+	scheduler->RegistEvent(phase_event);
+
+	// TC カウンタイベント
+	timer_event.code = 0;
+	timer_event.SetName("SPC Timer");
+	scheduler->RegistEvent(timer_event);
+
+	// モニタに表示するアドレス
+	if (vmtype == VMType::X68030) {
+		baseaddr = 0xe96021;
+		regoffset = 2;
+	} else {
+		baseaddr = 0xe1000000;
+		regoffset = 4;
 	}
+	// 「イニシエータ以外のターゲット数」はここでは確定している。
+	monitor->SetSize(80, 15 + scsi->GetOwnedBus()->GetTargetCount() + 1);
+
+	return true;
 }
 
-// SPC リセット
+// デバイスリセット
 void
-SPCDevice::Reset()
+SPCDevice::ResetHard(bool poweron)
 {
-	putlog(1, "リセット");
+	putlog(1, "Reset");
 
 	// 初期値 (p.61)
 	spc.sctl = SPC::SCTL_RESET;
 	spc.ints = 0x00;
 	spc.ssts &= 0x0f;
 	spc.serr = 0x00;
+	// 変更しないレジスタは次の通り (p.60)
+	// BDID, TMOD, TC[HML]?, SCMD, PCTL, TEMP(out)
 
 	// XXX マニュアルには書いていないけど、
 	// SDGC bit5 の転送ごとに割り込みを発生させるビットが
@@ -113,186 +138,210 @@ SPCDevice::Reset()
 	// このビットは落ちるのではないだろうか
 	spc.sdgc = 0x00;
 
+	// キューはリセットされる。
+	// mb89351-scsi.pdf (日本語)
+	spc.dreg.Clear();
+
 	// 内部状態
+	MakeIntsMask();
+	ChangeInterrupt();
 	prev_ints = (uint32)-1;
 	prev_ssts = (uint32)-1;
 	set_atn_in_selection = false;
 	transfer_command_running = false;
-	event.Stop();
-	event_tc.Stop();
+	scheduler->StopEvent(phase_event);
+	scheduler->StopEvent(timer_event);
+
+	last_busfree_time = 0;
 }
 
-uint64
-SPCDevice::Read(uint32 addr)
+busdata
+SPCDevice::ReadPort(uint32 offset)
 {
-	uint8 data;
+	busdata data;
 
-	switch (addr) {
+	switch (offset) {
 	 case SPC::BDID:
 		data = 1 << myid;
-		putlog(3, "BDID -> $%02x", data);
-		return data;
+		putlog(3, "BDID -> $%02x", data.Data());
+		break;
 
 	 case SPC::SCTL:
 		data = spc.sctl;
-		putlog(3, "SCTL -> $%02x", data);
-		return data;
+		putlog(3, "SCTL -> $%02x", data.Data());
+		break;
 
 	 case SPC::SCMD:
 		data = spc.scmd;
-		putlog(3, "SCMD -> $%02x", data);
-		return data;
+		putlog(3, "SCMD -> $%02x", data.Data());
+		break;
 
 	 case SPC::TMOD:
 		// MB89352 には存在しないレジスタ。
 		// 下位2ビットは %0 らしいので意味はないだろうけど真似ておく。
-		return 0xfc;
+		data = 0xfc;
+		break;
 
 	 case SPC::INTS:
-		data = spc.ints;
+		data = GetINTS();
 		if (loglevel >= 3) {
-			if (event_tc.active) {
+			uint32 new_ints = data.Data();
+			if (timer_event.IsRunning()) {
 				// イベント中は値が変わった時だけ表示
-				if (prev_ints != data) {
-					putlog("INTS -> $%02x", data);
-					prev_ints = data;
+				if (prev_ints != new_ints) {
+					putlogn("INTS -> $%02x", new_ints);
+					prev_ints = new_ints;
 				}
 			} else {
-				putlog("INTS -> $%02x", data);
+				putlogn("INTS -> $%02x", new_ints);
 				prev_ints = -1U;
 			}
 		}
-		return data;
+		break;
 
 	 case SPC::PSNS:
 		data = GetPSNS();
-		putlog(3, "PSNS -> $%02x", data);
-		return data;
+		putlog(3, "PSNS -> $%02x", data.Data());
+		break;
 
 	 case SPC::SSTS:
 		data = GetSSTS();
 		if (loglevel >= 3) {
-			if (event_tc.active) {
+			uint32 new_ssts = data.Data();
+			if (timer_event.IsRunning()) {
 				// イベント中は値が変わった時だけ表示
-				if (prev_ssts != data) {
-					putlog("SSTS -> $%02x", data);
-					prev_ssts = data;
+				if (prev_ssts != new_ssts) {
+					putlogn("SSTS -> $%02x", new_ssts);
+					prev_ssts = new_ssts;
 				}
 			} else {
-				putlog("SSTS -> $%02x", data);
+				putlogn("SSTS -> $%02x", new_ssts);
 				prev_ssts = -1U;
 			}
 		}
-		return data;
+		break;
 
 	 case SPC::SERR:
-		data = spc.serr;
-		putlog(3, "SERR -> $%02x", data);
-		return data;
+		data = GetSERR();
+		putlog(3, "SERR -> $%02x", data.Data());
+		break;
 
 	 case SPC::PCTL:
 		data = GetPCTL();
-		putlog(3, "PCTL -> $%02x", data);
-		return data;
+		putlog(3, "PCTL -> $%02x", data.Data());
+		break;
 
 	 case SPC::MBC:
-		putlog(0, "MBC 未実装読み込み");
-		return 0xff;
+		putlog(0, "Read MBC (NOT IMPLEMENTED)");
+		data = 0x0f;
+		break;
 
 	 case SPC::DREG:
-		return ReadDREG();
+		data = ReadDREG();
+		break;
 
 	 case SPC::TEMP:
 		data = spc.temp_in;
-		putlog(3, "TEMP -> $%02x", data);
-		return data;
+		putlog(3, "TEMP -> $%02x", data.Data());
+		break;
 
 	 case SPC::TCH:
 		data = spc.tc >> 16;
-		putlog(3, "TCH  -> $%02x", data);
-		return data;
+		putlog(3, "TCH  -> $%02x", data.Data());
+		break;
 
 	 case SPC::TCM:
 		data = (spc.tc >> 8) & 0xff;
-		putlog(3, "TCM  -> $%02x", data);
-		return data;
+		putlog(3, "TCM  -> $%02x", data.Data());
+		break;
 
 	 case SPC::TCL:
 		data = spc.tc & 0xff;
-		putlog(3, "TCL  -> $%02x", data);
-		return data;
+		putlog(3, "TCL  -> $%02x", data.Data());
+		break;
 
 	 case SPC::EXBF:
 		// MB89352 には存在しないレジスタ
-		return 0xff;
+		data = 0xff;
+		break;
+
+	 default:
+		VMPANIC("corrupted offset=%u", offset);
 	}
-	__unreachable();
+
+	data |= read_wait;
+	data |= BusData::Size1;
+	return data;
 }
 
-uint64
-SPCDevice::Write(uint32 addr, uint32 data)
+busdata
+SPCDevice::WritePort(uint32 offset, uint32 data)
 {
-	switch (addr) {
+	busdata r;
+
+	switch (offset) {
 	 case SPC::BDID:
+	 {
+		uint cur_myid = scsi->GetMyID();
 		putlog(3, "BDID <- $%02x", data);
-		if (myid == data) {
+		if (data == cur_myid) {
 			// 同じなら何もしない
-			return 0;
+			break;
 		}
-		if (myid == -1) {
-			// 初回なのでバスに参加
+		if ((int)cur_myid < 0) {
+			// 初回なのでバスに参加。myid はこちらでもコピーを覚えておく。
 			myid = data;
-			scsibus->Attach(this, myid);
+			if (scsi->GetOwnedBus()->AttachDevice(scsi.get(), myid) == false) {
+				putlog(0, "BDID %u conflicts with existing devices!", myid);
+			}
 		} else {
 			// そうでなければ移動?
-			putlog(0, "BDID 変更 %d to %d not implemented", myid, data);
-			return 0;
+			putlog(0, "BDID change %u to %u (NOT IMPLEMENTED)", cur_myid, data);
 		}
-		return 0;
+		break;
+	 }
 
 	 case SPC::SCTL:
 		WriteSCTL(data);
-		return 0;
+		break;
 
 	 case SPC::SCMD:
 		WriteSCMD(data);
-		return 0;
+		break;
 
 	 case SPC::TMOD:
 		// MB89352 には存在しないレジスタ
-		return 0;
+		break;
 
 	 case SPC::INTS:
 		WriteINTS(data);
-		return 0;
+		break;
 
 	 case SPC::SDGC:
 		spc.sdgc = data;
 		putlog(3, "SDGC <- $%02x", spc.sdgc);
-		return 0;
+		break;
 
 	 case SPC::SSTS:
 		// XXX 書き込みはどうなる?
-		return 0;
+		break;
 
 	 case SPC::SERR:
 		// XXX 書き込みはどうなる?
-		return 0;
+		break;
 
 	 case SPC::PCTL:
-		data &= SPC::PCTL_MASK;
-		putlog(3, "PCTL <- $%02x", data);
-		spc.busfree_intr_enable = (data & SPC::PCTL_BFINT_EN);
-		SetXfer(data);
-		return 0;
+		WritePCTL(data);
+		break;
 
 	 case SPC::MBC:
 		// XXX 書き込みはどうなる?
-		return 0;
+		break;
 
 	 case SPC::DREG:
 		putlog(3, "DREG <- $%02x", data);
-		return WriteDREG(data);
+		r = WriteDREG(data);
+		break;
 
 	 case SPC::TEMP:
 		spc.temp_out = data;
@@ -304,41 +353,47 @@ SPCDevice::Write(uint32 addr, uint32 dat
 		// luna68k の /boot はここで SEL が下げてしまうと期待した動作に
 		// ならないようだ。
 		// SPC はセレクションタイムアウトしたからと言って、データバスに出した
-		// ID を自動的に取り下げたりはしないので、手動でデータバスをクリア
-		// してあげないといけない (TEMP に $00 を書き込む)、だったんでは。
-		if (0 && GetPhase() == SCSI::Phase::Selection) {
-			NegateSEL();
+		// ID を自動的に取り下げたりはしないので、TEMP に $00 を書き込むことで
+		// データバスをクリアする、だったんでは。
+		if (0 && scsi->GetPhase() == SCSI::Phase::Selection) {
+			scsi->NegateSEL();
 		}
 		// Out 方向ならバスに出す
-		if (GetIO() == false) {
-			SetData(spc.temp_out);
+		if (scsi->GetIO() == false) {
+			scsi->SetData(spc.temp_out);
 		}
-		return 0;
+		break;
 
 	 case SPC::TCH:
 		spc.tc = (spc.tc & 0x00ffff) | (data << 16);
 		putlog(3, "TCH  <- $%02x (TC=$%06x)", data, spc.tc);
-		return 0;
+		break;
 	 case SPC::TCM:
 		spc.tc = (spc.tc & 0xff00ff) | (data << 8);
 		putlog(3, "TCM  <- $%02x (TC=$%06x)", data, spc.tc);
-		return 0;
+		break;
 	 case SPC::TCL:
 		spc.tc = (spc.tc & 0xffff00) | data;
 		putlog(3, "TCL  <- $%02x (TC=$%06x)", data, spc.tc);
-		return 0;
+		break;
 
 	 case SPC::EXBF:
 		// MB89352 には存在しないレジスタ
-		return 0;
+		break;
+
+	 default:
+		VMPANIC("corrupted offset=%u", offset);
 	}
-	__unreachable();
+
+	r |= write_wait;
+	r |= BusData::Size1;
+	return r;
 }
 
-uint64
-SPCDevice::Peek(uint32 addr)
+busdata
+SPCDevice::PeekPort(uint32 offset)
 {
-	switch (addr) {
+	switch (offset) {
 	 case SPC::BDID:
 		return 1 << myid;
 
@@ -354,7 +409,7 @@ SPCDevice::Peek(uint32 addr)
 		return 0xfc;
 
 	 case SPC::INTS:
-		return spc.ints;
+		return GetINTS();
 
 	 case SPC::PSNS:
 		return GetPSNS();
@@ -363,21 +418,21 @@ SPCDevice::Peek(uint32 addr)
 		return GetSSTS();
 
 	 case SPC::SERR:
-		return spc.serr;
+		return GetSERR();
 
 	 case SPC::PCTL:
 		return GetPCTL();
 
 	 case SPC::MBC:
-		return 0xff;
+		return 0x0f;
 
 	 case SPC::DREG:
 		// X68k は SPC の DREQ 信号から DTACK 信号を作っているため、
 		// DREQ 信号を出さないプログラム転送モードでは DREG へのアクセスが
 		// すべてバスエラーになってしまう。
-		if (vmtype == VMTYPE_X68030) {
+		if (vmtype == VMType::X68030) {
 			if ((spc.scmd & SPC::SCMD_PROGRAM)) {
-				return (uint64)-1;
+				return BusData::BusErr;
 			}
 		}
 		return spc.dreg.Peek(0);
@@ -397,15 +452,24 @@ SPCDevice::Peek(uint32 addr)
 	 case SPC::EXBF:
 		// MB89352 には存在しないレジスタ
 		return 0xff;
+
+	 default:
+		return 0xff;
 	}
-	__unreachable();
 }
 
 bool
-SPCDevice::MonitorUpdate()
+SPCDevice::PokePort(uint32 offset, uint32 data)
+{
+	return false;
+}
+
+void
+SPCDevice::MonitorUpdate(Monitor *, TextScreen& screen)
 {
 	int x;
 	int y;
+	SCSIBus *bus;
 	uint32 sctl;
 	uint32 scmd;
 	uint32 ints;
@@ -416,59 +480,62 @@ SPCDevice::MonitorUpdate()
 	uint32 pctl;
 	uint32 tc;
 
-	monitor.Clear();
+	screen.Clear();
 
+	bus  = scsi->GetOwnedBus();
 	sctl = spc.sctl;
 	scmd = spc.scmd;
-	ints = spc.ints;
+	ints = GetINTS();
 	psns = GetPSNS();
 	sdgc = spc.sdgc;
 	ssts = GetSSTS();
-	serr = spc.serr;
+	serr = GetSERR();
 	pctl = GetPCTL();
 	tc   = spc.tc;
 
+#define A(n)	(baseaddr + (n) * regoffset)
+
 	y = 0;
-	monitor.Print(0, y++, "BDID: $%02x (ID=%d)", (1 << myid), myid);
-	monitor.Print(0, y++, "SCTL: $%02x", sctl);
-	monitor.Print(0, y++, "SCMD: $%02x", scmd);
-	monitor.Print(0, y++, "INTS: $%02x", ints);
-	monitor.Print(0, y++, "PSNS: $%02x", psns);
-	monitor.Print(0, y++, "SDGC: $%02x", sdgc);
-	monitor.Print(0, y++, "SSTS: $%02x", ssts);
-	monitor.Print(0, y++, "SERR: $%02x", serr);
-	monitor.Print(0, y++, "PCTL: $%02x", pctl);
-	monitor.Print(0, y++, "MBC : $XX");
-	monitor.Print(0, y,   "DREG: ");
+	screen.Print(0, y++, "$%08x BDID: $%02x (ID=%u)", A(0), (1 << myid), myid);
+	screen.Print(0, y++, "$%08x SCTL: $%02x", A(1), sctl);
+	screen.Print(0, y++, "$%08x SCMD: $%02x", A(2), scmd);
+	screen.Print(0, y++, "$%08x INTS: $%02x", A(4), ints);
+	screen.Print(0, y++, "$%08x PSNS: $%02x", A(5), psns);
+	screen.Print(0, y++, "$%08x SDGC: $%02x", A(5), sdgc);
+	screen.Print(0, y++, "$%08x SSTS: $%02x", A(6), ssts);
+	screen.Print(0, y++, "$%08x SERR: $%02x", A(7), serr);
+	screen.Print(0, y++, "$%08x PCTL: $%02x", A(8), pctl);
+	screen.Print(0, y++, "$%08x MBC : $XX", A(9));
+	screen.Print(0, y,   "$%08x DREG: ", A(10));
 	{
 		uint i;
 		for (i = 0; i < spc.dreg.Length(); i++) {
-			monitor.Print(6 + i * 4, y, "$%02x", spc.dreg.Peek(i));
+			screen.Print(16 + i * 4, y, "$%02x", spc.dreg.Peek(i));
 		}
 		for (; i < 8; i++) {
-			monitor.Print(6 + i * 4, y, TA::Disable, "---");
+			screen.Puts(16 + i * 4, y, "---");
 		}
 	}
 	y++;
-	monitor.Print(0, y++, "TEMP: $%02x(IN) $%02x(OUT)",
+	screen.Print(0, y++, "$%08x TEMP: $%02x(IN) $%02x(OUT)", A(11),
 		spc.temp_in, spc.temp_out);
-	monitor.Print(0, y++, "TC  : $%06x", tc);
+	screen.Print(0, y++, "$%08x TC  : $%06x", A(12), tc);
 
-	x = 10;
+	x = 20;
 	y = 1;
 
 	// SCTL
 	static const char * const sctl_bits[] = {
 		"RST", "CTRL", "DIAG", "ARB", "PARI", "SEL", "RESL", "INTR"
 	};
-	MonitorReg(x, y, sctl, sctl_bits);
+	MonitorReg(screen, x, y, sctl, sctl_bits);
 	y++;
 
 	// SCMD
 	static const char * const scmd_bits[] = {
-		"", "", "", "RST", "INTC", "PROG", "", "TERM"
+		"", "", "", "RST", "INTC", "PROG", "----", "TERM"
 	};
-	MonitorReg(x, y, scmd, scmd_bits);
+	MonitorReg(screen, x, y, scmd, scmd_bits);
 	static const char * const scmd_cmd[] = {
 		//12345678901234
 		"(Bus Release)",
@@ -480,35 +547,35 @@ SPCDevice::MonitorUpdate()
 		"(ResetACK/REQ)",
 		"(Set ACK/REQ)",
 	};
-	monitor.Puts(x, y, scmd_cmd[scmd >> 5]);
+	screen.Puts(x, y, scmd_cmd[scmd >> 5]);
 	y++;
 
 	// INTS
 	static const char * const ints_bits[] = {
 		"Sel", "Resl", "Disc", "Cmpl", "SReq", "TOut", "HErr", "Rst"
 	};
-	MonitorReg(x, y, ints, ints_bits);
+	MonitorReg(screen, x, y, ints, ints_bits);
 	y++;
 
 	// PSNS
 	static const char * const psns_bits[] = {
 		"REQ", "ACK", "ATN", "SEL", "BSY", "MSG", "C/D", "I/O"
 	};
-	MonitorReg(x, y, psns, psns_bits);
+	MonitorReg(screen, x, y, psns, psns_bits);
 	y++;
 
 	// SDGC
 	static const char * const sdgc_bits[] = {
-		"",    "",    "XfEn", "",   "",    "",    "",    ""
+		"-", "-", "XfEn", "-", "-", "-", "-", "-"
 	};
-	MonitorReg(x, y, sdgc, sdgc_bits);
+	MonitorReg(screen, x, y, sdgc, sdgc_bits);
 	y++;
 
 	// SSTS
 	static const char * const ssts_bits[] = {
 		"", "", "SBSY", "XInP", "RSTI", "TCZ", "Full", "Empt"
 	};
-	MonitorReg(x, y, ssts, ssts_bits);
+	MonitorReg(screen, x, y, ssts, ssts_bits);
 	static const char * const ssts_conn[] = {
 		//12345678
 		"(NotConn)",
@@ -516,121 +583,146 @@ SPCDevice::MonitorUpdate()
 		"(As Init)",
 		"(undef?)",
 	};
-	monitor.Puts(x, y, ssts_conn[ssts >> 6]);
+	screen.Puts(x, y, ssts_conn[ssts >> 6]);
 	y++;
 
 	// SERR
 	static const char * const serr_bits[] = {
-		"", "", "XOut", "", "PErr", "", "Shrt", ""
+		"-", "-", "XOut", "-", "PErr", "-", "Shrt", "-"
 	};
-	MonitorReg(x, y, serr, serr_bits);
+	MonitorReg(screen, x, y, serr, serr_bits);
 	y++;
 
 	// PCTL
 	static const char * const pctl_bits[] = {
-		"BIE", "", "", "", "", "MSG", "C/D", "I/O"
+		"BIE", "-", "-", "-", "-", "MSG", "C/D", "I/O"
 	};
-	MonitorReg(x, y, pctl, pctl_bits);
+	MonitorReg(screen, x, y, pctl, pctl_bits);
 	y++;
 
 	// バス状態
-	x = 52;
+	x = 62;
 	y = 0;
-	SCSI::Phase ph {};
-	uint8 rst = 0;
-	uint8 bsy = 0;
-	uint8 sel = 0;
-	uint8 msg = 0;
-	uint8 cd = 0;
-	uint8 io = 0;
-	uint8 atn = 0;
-	uint8 req = 0;
-	uint8 ack = 0;
-	uint8 data = 0;
-	if (bus) {
-		ph  = GetPhase();
-		rst = GetRST();
-		bsy = GetBSY();
-		sel = GetSEL();
-		msg = GetMSG();
-		cd  = GetCD();
-		io  = GetIO();
-		atn = GetATN();
-		req = GetREQ();
-		ack = GetACK();
-		data = GetData();
-	}
-	monitor.Print(x, y++, "Phase: %s", SCSI::GetPhaseName(ph));
-	monitor.Puts(x, y++, TA::OnOff(rst), "RST");
-	monitor.Puts(x, y++, TA::OnOff(bsy), "BSY");
-	monitor.Puts(x, y++, TA::OnOff(sel), "SEL");
-	monitor.Puts(x, y++, TA::OnOff(msg), "MSG");
-	monitor.Puts(x, y++, TA::OnOff(cd),  "CD");
-	monitor.Puts(x, y++, TA::OnOff(io),  "IO");
-	monitor.Puts(x, y++, TA::OnOff(atn), "ATN");
-	monitor.Puts(x, y++, TA::OnOff(req), "REQ");
-	monitor.Puts(x, y++, TA::OnOff(ack), "ACK");
-	monitor.Print(x, y++, "DATA:$%02x", data);
+	SCSI::Phase ph = bus->GetPhase();
+	uint8 rst = bus->GetRST();
+	uint8 bsy = bus->GetBSY();
+	uint8 sel = bus->GetSEL();
+	uint8 msg = bus->GetMSG();
+	uint8 cd  = bus->GetCD();
+	uint8 io  = bus->GetIO();
+	uint8 atn = bus->GetATN();
+	uint8 req = bus->GetREQ();
+	uint8 ack = bus->GetACK();
+	uint8 data = bus->GetData();
+
+	screen.Print(x, y++, "Phase: %s", SCSI::GetPhaseName(ph));
+	screen.Puts(x, y++, TA::OnOff(rst), "RST");
+	screen.Puts(x, y++, TA::OnOff(bsy), "BSY");
+	screen.Puts(x, y++, TA::OnOff(sel), "SEL");
+	screen.Puts(x, y++, TA::OnOff(msg), "MSG");
+	screen.Puts(x, y++, TA::OnOff(cd),  "CD");
+	screen.Puts(x, y++, TA::OnOff(io),  "IO");
+	screen.Puts(x, y++, TA::OnOff(atn), "ATN");
+	screen.Puts(x, y++, TA::OnOff(req), "REQ");
+	screen.Puts(x, y++, TA::OnOff(ack), "ACK");
+	screen.Print(x, y++, "DATA:$%02x", data);
 
 	y = 2;
-	monitor.Puts(x + 4, y++, "(________)");
-	monitor.Puts(x + 4, y++, "(________)");
-	monitor.Puts(x + 4, y++, "+");
-	monitor.Puts(x + 4, y++, "|");
-	monitor.Puts(x + 4, y++, "+");
+	screen.Puts(x + 4, y++, "(________)");
+	screen.Puts(x + 4, y++, "(________)");
+	screen.Puts(x + 4, y++, "+");
+	screen.Puts(x + 4, y++, "|");
+	screen.Puts(x + 4, y++, "+");
 
 	// BSY, SEL の内訳。"(76543210)" の順。
 	y = 2;
 	for (int i = 0; i < 8; i++) {
 		if ((bsy & (1 << i))) {
-			monitor.Print(x + 4 + 8 - i, y, "%d", i);
+			screen.Print(x + 4 + 8 - i, y, "%u", i);
 		} else {
-			monitor.Print(x + 4 + 8 - i, y, "_");
+			screen.Print(x + 4 + 8 - i, y, "_");
 		}
 	}
 	y++;
 	for (int i = 0; i < 8; i++) {
 		if ((sel & (1 << i))) {
-			monitor.Print(x + 4 + 8 - i, y, "%d", i);
+			screen.Print(x + 4 + 8 - i, y, "%u", i);
 		} else {
-			monitor.Print(x + 4 + 8 - i, y, "_");
+			screen.Print(x + 4 + 8 - i, y, "_");
 		}
 	}
 
 	// 転送フェーズ中なら現在の XferPhase
 	y += 2;
 	if (ph == SCSI::Phase::Transfer) {
-		monitor.Puts(x + 5, y, SCSI::GetXferPhaseName(GetXfer()));
+		screen.Puts(x + 5, y, SCSI::GetXferPhaseName(scsi->GetXfer()));
 	}
 
-	// ターゲット
+	// デバイス一覧
+	// 0         1
+	// 01234567890123456
+	// ID Device     Command
+	// 0: HD(1024MB) $06 Read
+	// 7: Initiator
 	x = 0;
 	y = 14;
-	if (bus) {
-		SCSIDevice *d = bus->GetConnectedTarget();
-		SCSITarget *t = dynamic_cast<SCSITarget*>(d);
-		if (t) {
-			std::vector<uint8> cmds = t->GetCmdSeq();
-			if (cmds.size() > 0) {
-				const char *cmdname = SCSI::GetCommandName(cmds[0]);
-				monitor.Print(x, y, "Command: $%02x", cmds[0]);
-				if (cmdname) {
-					monitor.Puts(x + 14, y, cmdname);
+	screen.Print(x, y++, "ID Device     Command");
+	for (const auto d : bus->GetConnectedDevices()) {
+		std::string desc = SCSI::GetDevTypeName(d->GetDevType());
+
+		const SCSIDisk *disk = dynamic_cast<const SCSIDisk*>(d);
+		if (disk && disk->IsMediumLoaded()) {
+			desc += string_format("(%uMB)",
+				(uint)(disk->GetSize() / 1024 / 1024));
+		}
+
+		// 本体 ID は BDID が設定される前でもエミュレータ的に知ってはいるが、
+		// BDID への書き込みがされなかったりおかしかったりしたら (上の BDID
+		// 欄でも分かるけど) ここも反映されるようにしておく。
+		char idc;
+		if ((int)d->GetMyID() >= 0) {
+			idc = '0' + d->GetMyID();
+		} else {
+			idc = '-';
+		}
+		screen.Print(x, y, "%c: %s", idc, desc.c_str());
+		y++;
+	}
+
+	// 実行中のコマンド
+	x = 14;
+	y = 15;
+	SCSITarget *t = bus->GetSelectedTarget();
+	if (t) {
+		std::vector<uint8> cmds = t->GetCmdSeq();
+		if (cmds.size() > 0) {
+			// この ID のデバイス行に表示したい
+			// XXX もうちょっとマシにしたい
+			const auto connected_devices = bus->GetConnectedDevices();
+			int i = 0;
+			for (; i < connected_devices.size(); i++) {
+				if (t == connected_devices[i]) {
+					break;
 				}
 			}
+			const char *cmdname = SCSI::GetCommandName(cmds[0]);
+			screen.Print(x, y + i, "$%02x %s", cmds[0], cmdname ?: "");
 		}
 	}
-
-	return true;
 }
 
 // レジスタをビットごとに表示する。MonitorUpdate の下請け。
 void
-SPCDevice::MonitorReg(int x, int y, uint32 reg, const char * const *names)
+SPCDevice::MonitorReg(TextScreen& screen,
+	int x, int y, uint32 reg, const char * const *names)
 {
 	for (int i = 0; i < 8; i++) {
-		bool b = reg & (1 << (7 - i));
-		monitor.Puts(x + i * 5, y, TA::OnOff(b), names[i]);
+		if (names[i][0] == '-') {
+			screen.Puts(x + i * 5, y, TA::Disable, "----");
+		} else {
+			bool b = reg & (1 << (7 - i));
+			screen.Puts(x + i * 5, y, TA::OnOff(b), names[i]);
+		}
 	}
 }
 
@@ -645,7 +737,7 @@ SPCDevice::WriteSCTL(uint32 data)
 	putlog(3, "SCTL <- $%02x", spc.sctl);
 	if ((up & SPC::SCTL_RESET)) {
 		// リセット
-		Reset();
+		ResetHard(false);
 	} else {
 		// 通常動作
 	}
@@ -653,7 +745,22 @@ SPCDevice::WriteSCTL(uint32 data)
 		putlog(2, "Control Reset");
 	}
 	if ((spc.sctl & SPC::SCTL_DIAG_MODE)) {
-		putlog(0, "SCTL 未実装 Diag Mode");
+		putlog(0, "SCTL Diag Mode (NOT IMPLEMENTED)");
+	}
+
+	// 割り込みマスクを更新して信号線の状態を変える
+	MakeIntsMask();
+	ChangeInterrupt();
+}
+
+// SCTL_INTR_EN の状態から内部変数 ints_mask を作成する。
+void
+SPCDevice::MakeIntsMask()
+{
+	if ((spc.sctl & SPC::SCTL_INTR_EN)) {
+		spc.ints_mask = SPC::INTS_ENABLE_MASK;
+	} else {
+		spc.ints_mask = SPC::INTS_DISABLE_MASK;
 	}
 }
 
@@ -665,8 +772,7 @@ SPCDevice::WriteSCMD(uint32 data)
 	spc.scmd = data;
 	putlog(3, "SCMD <- $%02x", spc.scmd);
 
-	// Intercept, Program, Terminate Mode の未実装判定は
-	// 転送開始時のみ表示する。
+	// Program, Terminate Mode の未実装判定は転送開始時のみ表示する。
 
 	// RST Out 操作は SCTL Reset がオフの時だけ有効
 	// と書いてあるけど、SCTL Reset がオンならほぼ全機能無効なのでは?
@@ -674,29 +780,34 @@ SPCDevice::WriteSCMD(uint32 data)
 		if ((spc.scmd & SPC::SCMD_RST_OUT)) {
 			// 0 -> 1
 			// すでに RST が立ってたらどうするか
-			if (GetRST() == false) {
+			if (scsi->GetRST() == false) {
 				putlog(1, "SCMD RST Out");
 				BusRelease();
-				AssertRST();
+				scsi->AssertRST();
 				SetINTS(SPC::INTS_RESET_COND);
 			}
 		} else {
 			// 1 -> 0
 			// 特にすることはない?
-			NegateRST();
+			scsi->NegateRST();
 		}
 	}
 
 	switch (spc.scmd >> 5) {
 	 case 0:
-		putlog(2, "SCMD Bus Release コマンド");
+		putlog(2, "SCMD Bus Release command");
+		if ((spc.scmd & SPC::SCMD_INTERCEPT)) {
+			// BusRelease コマンドの発行と共に Intercept ビットが立っていたら
+			// Service Required 割り込みをリセットする?
+			putlog(0, "SCMD Intercept with BusRelease (NOT IMPLEMENTED)");
+		}
 		BusFree();
 		break;
 	 case 1:
 		SelectCommand();
 		break;
 	 case 2:
-		putlog(1, "SCMD Reset ATN コマンド (未実装)");
+		putlog(1, "SCMD Reset ATN command (NOT IMPLEMENTED)");
 		break;
 	 case 3:
 		SetATNCommand();
@@ -705,19 +816,28 @@ SPCDevice::WriteSCMD(uint32 data)
 		TransferCommand();
 		break;
 	 case 5:
-		putlog(2, "SCMD Transfer Pause コマンド (未実装)");
+		putlog(2, "SCMD Transfer Pause command (NOT IMPLEMENTED)");
 		break;
 	 case 6:
-		putlog(2, "SCMD Reset ACK/REQ コマンド");
+		putlog(2, "SCMD Reset ACK/REQ command");
 		// イニシエータなら ACK を、ターゲットなら REQ をリセットする。
 		// ターゲットモードはサポートしないので、操作するのは ACK のみ。
-		NegateACK();
+		scsi->NegateACK();
 		break;
 	 case 7:
-		putlog(2, "SCMD Set ACK/REQ コマンド");
+		putlog(2, "SCMD Set ACK/REQ command");
 		// イニシエータなら ACK を、ターゲットなら REQ をセットする。
 		// ターゲットモードはサポートしないので、操作するのは ACK のみ。
-		AssertACK();
+		if ((spc.scmd & SPC::SCMD_INTERCEPT)) {
+			// Intercept なら DREG を維持したまま (たぶん TEMP で) バスを
+			// 直接アクセスするようだが、この DREG 維持あたりは未対応。
+			// これが影響するのは DREG にデータが滞留してる時だけのはず
+			// なので、その時だけログを出す。(X68030 IPLROM、NetBSD/x68k)
+			if (spc.dreg.Length() != 0) {
+				putlog(0, "SCMD Intercept with SetACK (NOT IMPLEMENTED)");
+			}
+		}
+		scsi->AssertACK();
 		break;
 	}
 }
@@ -733,11 +853,7 @@ SPCDevice::WriteINTS(uint32 data)
 
 	// '1' が書き込まれたビットをクリア
 	spc.ints &= ~data;
-	putlog(3, "INTS <- $%02x (INTS = $%02x)", data, spc.ints);
-
-	// SPC では INTS でビットを落とす行為は、
-	// ホストが割り込み要因に対して処理を完了したことを
-	// SPC に通知する意味が含まれている。
+	putlog(3, "INTS <- $%02x (INTS = $%02x)", data, GetINTS());
 
 	// DISCONNECTED ビットが立っているときは SPC は SCSI から
 	// セレクション、リセレクション要求が来ても応答しない。
@@ -746,85 +862,100 @@ SPCDevice::WriteINTS(uint32 data)
 	// TIMEOUT ビットをクリアした時が
 	if ((ack & SPC::INTS_TIMEOUT)) {
 		// セレクションフェーズなら
-		if (GetPhase() == SCSI::Phase::Selection) {
+		if (scsi->GetPhase() == SCSI::Phase::Selection) {
 			// TC がゼロならバスフリー
 			// そうでなければリスタート
 			if (spc.tc == 0) {
 				BusFree();
 			} else {
-				event_tc.time = spc.tc * t_CLF * 2;
-				event_tc.func = (DeviceCallback_t)&SPCDevice::SelectionTimeout;
-				event_tc.Start();
+				timer_event.func =
+					ToEventCallback(&SPCDevice::SelectionTimeout);
+				timer_event.time = spc.tc * t_CLF * 2;
+				scheduler->RestartEvent(timer_event);
 			}
 		}
 	}
+
+	// 割り込み信号線の状態を変える
+	ChangeInterrupt();
 }
 
 // INTS 設定。
-// INTS にビットを立てる要因が起きた時に data にそれを指定して呼び出す。
-// この関数は INTS を書き換えて、必要なら割り込みを上げる。
+// 引数 data は割り込み要因(ここは内部要因なので INTS_XFER_OUT も指定可能)。
 // INTS レジスタへの書き込み(割り込み要因のクリア)は WriteINTS() のほう。
 void
 SPCDevice::SetINTS(uint32 data)
 {
-	// 立ち上がりでだけ割り込みがかかるわけではないが表示のため。
-	uint32 up = ~spc.ints & data;
-
 	// 指定された要因を立てる
 	spc.ints |= data;
 
 	// Disconnected 割り込みが起きたら ATN を下げる
-	if ((spc.ints & SPC::INTS_DISCONNECTED) && GetATN()) {
-		NegateATN();
+	if ((spc.ints & SPC::INTS_DISCONNECTED) && scsi->GetATN()) {
+		scsi->NegateATN();
 	}
 
-	// 割り込み許可なら割り込み。
-	// RESET_COND はノンマスカブル割り込み。
-	if ((spc.sctl & SPC::SCTL_INTR_EN) || (spc.ints & SPC::INTS_RESET_COND)) {
-		putlog(3, "割り込み ints=$%02x up=$%02x", spc.ints, up);
-		if (vmtype != VMTYPE_X68030) {
-			gMPU->Interrupt(this, 2);
-		} else {
-			// とりあえず内蔵だけ
-			gMPU680x0->Interrupt(this, 1, 0x6c);
-		}
+	ChangeInterrupt();
+}
+
+// INTS レジスタの値を取得
+uint32
+SPCDevice::GetINTS() const
+{
+	// ints の上位には別の割り込み状態が保持されている。
+	// 下位8bit は INTS レジスタのまま。
+	return spc.ints & 0xff;
+}
+
+// 割り込み信号線の状態を変える
+void
+SPCDevice::ChangeInterrupt()
+{
+	// 割り込み状態は ints に集約してあり、
+	// ints_mask は現在の SCTL_INTR_EN 状態に応じたマスクが用意されているので
+	// 単純に AND するだけでよい。
+	if ((spc.ints & spc.ints_mask) != 0) {
+		putlog(3, "Interrupt (ints=$%02x)", spc.ints);
+		interrupt->AssertINT(this);
+	} else {
+		putlog(4, "Negate Interrupt");
+		interrupt->NegateINT(this);
 	}
 }
 
 // PSNS レジスタ値の取得。
-// Read*() と Peek8() から呼ばれる。
+// ReadPort() と PeekPort() から呼ばれる。
 // scsibus 接続前にもモニタの更新などで呼ばれることに注意。
 uint32
 SPCDevice::GetPSNS() const
 {
 	uint32 data = 0;
 
-	if (__predict_false(bus == NULL)) {
+	if (__predict_false(scsi->GetBus() == NULL)) {
 		return 0;
 	}
 
-	if (GetREQ()) {
+	if (scsi->GetREQ()) {
 		data |= SPC::PSNS_REQ;
 	}
-	if (GetACK()) {
+	if (scsi->GetACK()) {
 		data |= SPC::PSNS_ACK;
 	}
-	if (GetATN()) {
+	if (scsi->GetATN()) {
 		data |= SPC::PSNS_ATN;
 	}
-	if (GetSEL()) {
+	if (scsi->GetSEL()) {
 		data |= SPC::PSNS_SEL;
 	}
-	if (GetBSY()) {
+	if (scsi->GetBSY()) {
 		data |= SPC::PSNS_BSY;
 	}
-	data |= (uint32)GetXfer();
+	data |= (uint32)scsi->GetXfer();
 
 	return data;
 }
 
 // SSTS レジスタ値の取得。
-// Read*() と Peek8() から呼ばれる。
+// ReadPort() と PeekPort() から呼ばれる。
 // scsibus 接続前にもモニタの更新などで呼ばれることに注意。
 uint32
 SPCDevice::GetSSTS() const
@@ -832,75 +963,97 @@ SPCDevice::GetSSTS() const
 	uint32 data;
 
 	data = spc.ssts & 0xf0;
-	if (__predict_true(bus != NULL) && GetRST()) {		// RST 信号
+	if (__predict_true(scsi->GetBus() != NULL) && scsi->GetRST()) {	// RST 信号
 		data |= SPC::SSTS_RST_IN;
 	}
 	if (spc.tc == 0) {	// TC がゼロか
 		data |= SPC::SSTS_TC_ZERO;
 	}
-	if (spc.dreg.Length() == 8) {
+	if (spc.dreg.IsFull()) {
 		data |= SPC::SSTS_DREG_FULL;
 	}
-	if (spc.dreg.Length() == 0) {
+	if (spc.dreg.Empty()) {
 		data |= SPC::SSTS_DREG_EMPTY;
 	}
 
 	return data;
 }
 
+// SERR レジスタ値の取得。
+uint32
+SPCDevice::GetSERR() const
+{
+	// SERR レジスタのうち XFER_OUT ビットだけ ints で保持している。
+	uint32 xfer_out = (spc.ints & SPC::INTS_XFER_OUT) >> 3;
+	return spc.serr | xfer_out;
+}
+
+// PCTL レジスタへの書き込み。
+void
+SPCDevice::WritePCTL(uint32 data)
+{
+	data &= SPC::PCTL_MASK;
+	putlog(3, "PCTL <- $%02x", data);
+
+	spc.busfree_intr_enable = (data & SPC::PCTL_BFINT_EN);
+	spc.pctl_out = data & (SPC::PCTL_MSG | SPC::PCTL_CD | SPC::PCTL_IO);
+	// この時点では pctl_out はまだバスに出さない。
+	// バスに出すのは転送開始時のはず。
+}
+
 // PCTL レジスタ値の取得。
-// Read*() と Peek8() から呼ばれる。
-// scsibus 接続前にもモニタの更新などで呼ばれることに注意。
 uint32
 SPCDevice::GetPCTL() const
 {
-	uint32 data;
-
-	data = 0;
-	if (__predict_true(bus != NULL)) {
-		data |= (uint32)GetXfer();
-	}
-	if (spc.busfree_intr_enable) {
-		data |= SPC::PCTL_BFINT_EN;
-	}
-	return data;
+	return spc.busfree_intr_enable | spc.pctl_out;
 }
 
 // DREG レジスタの読み込み
 // (副作用があるので Peek 系からは呼ばないこと)
-uint64
+busdata
 SPCDevice::ReadDREG()
 {
-	uint32 data;
+	busdata data;
 
 	// X68k は SPC の DREQ 信号から DTACK 信号を作っているため、
 	// DREQ 信号を出さないプログラム転送モードでは DREG へのアクセスが
 	// すべてバスエラーになってしまう。
-	if (vmtype == VMTYPE_X68030) {
+	if (vmtype == VMType::X68030) {
 		if ((spc.scmd & SPC::SCMD_PROGRAM)) {
-			return (uint64)-1;
+			data.SetBusErr();
+			return data;
+		} else {
+			// DMA 転送で DREQ が出てないとき DTACK を出さないのを
+			// Retry を返すことで表現している。
+			if (spc.dreg.Length() == 0) {
+				putlog(3, "DREG empty during DMA transferring");
+				data.SetRetry();
+				return data;
+			}
 		}
 	}
 
 	// XFER_OUT は DREG アクセスでリセットされる
-	spc.serr &= ~SPC::SERR_XFER_OUT;
+	spc.ints &= ~SPC::INTS_XFER_OUT;
+	// TransferComplete() が割り込み状態を変化させる可能性があるので
+	// ChangeInterrupt() を最後に呼び出す。
 
 	// 受信データがあれば取り出す
 	if (__predict_true(spc.dreg.Length() > 0)) {
 		bool q_was_full = spc.dreg.IsFull();
 		data = spc.dreg.Dequeue();
 		if (loglevel >= 4) {
-			putlog("DREG -> $%02x (q=%d TC=0x%x)",
-				data, spc.dreg.Length(), spc.tc);
+			putlogn("DREG -> $%02x (q=%u TC=0x%x)",
+				data.Data(), spc.dreg.Length(), spc.tc);
 		} else {
-			putlog(3, "DREG -> $%02x", data);
+			putlog(3, "DREG -> $%02x", data.Data());
 		}
 		// この読み出しが最後だったらこれで転送完了。
 		if (spc.tc == 0 && spc.dreg.Length() == 0) {
 			TransferComplete();
 		}
 		// この読み出しによってバッファに空きが出来たら転送再開。
-		if (transfer_command_running && GetREQ() && q_was_full) {
+		if (transfer_command_running && scsi->GetREQ() && q_was_full) {
 			// XXX 時間は適当
 			CallAfter(HardwareTransfer, "SPC ReadDREG to Transfer", t_CLF);
 		}
@@ -909,40 +1062,63 @@ SPCDevice::ReadDREG()
 		if ((spc.scmd & SPC::SCMD_PROGRAM)) {
 			// XXX プログラム転送中ならどうなる?
 			data = 0xff;
-			putlog(3, "DREG -> $%02x (empty)", data);
+			putlog(3, "DREG -> $%02x (empty)", data.Data());
 		} else {
 			// DMA 転送
-			// XXX どうする?
-			PANIC("DMA転送中の DREG empty");
+			// DMA 側でリトライするのでここには来ないはず
+			VMPANIC("DMA転送中の DREG empty");
 		}
 	}
+
+	// 割り込み状態を確定
+	ChangeInterrupt();
 	return data;
 }
 
 // DREG レジスタへの書き込み
-uint64
+busdata
 SPCDevice::WriteDREG(uint32 data)
 {
+	busdata r;
+
 	// X68k は SPC の DREQ 信号から DTACK 信号を作っているため、
 	// DREQ 信号を出さないプログラム転送モードでは DREG へのアクセスが
 	// すべてバスエラーになってしまう。
-	if (vmtype == VMTYPE_X68030) {
+	if (vmtype == VMType::X68030) {
 		if ((spc.scmd & SPC::SCMD_PROGRAM)) {
-			return (uint64)-1;
+			r.SetBusErr();
+			return data;
+		} else {
+			// DMA 転送で DREQ が出てないとき DTACK を出さないのを
+			// Retry を返すことで表現している。
+			if (spc.dreg.IsFull()) {
+				r.SetRetry();
+				return r;
+			}
 		}
 	}
 
 	// XFER_OUT は DREG アクセスでリセットされる
-	spc.serr &= ~SPC::SERR_XFER_OUT;
+	spc.ints &= ~SPC::INTS_XFER_OUT;
+	ChangeInterrupt();
 
 	// DREG キューに入れて..
-	spc.dreg.Enqueue(data);
+	if (spc.dreg.Enqueue(data) == false) {
+		// XXX キューが一杯だったらどうなるのかは書いてないので分からない。
+		// a) キューを押し出して先頭を破棄する
+		// b) キューの末尾を破棄して新着データで上書きする
+		// c) キューの内容は変わらず新着データを破棄する
+		// どれで実装しても「この時何かしら失われるデータがある」こと自体は
+		// 再現出来ているはずなので、ここではひとまず a) の動作にしておく。
+		putlog(0, "DREG Queue overflow");
+		spc.dreg.EnqueueForce(data);
+	}
 	// ハードウェア転送中で REQ が来てれば送信。
-	if (transfer_command_running && GetREQ()) {
+	if (transfer_command_running && scsi->GetREQ()) {
 		// XXX 時間は適当
 		CallAfter(HardwareTransfer, "SPC WriteDREG to Transfer", t_CLF);
 	}
-	return 0;
+	return r;
 }
 
 // バスフリーフェーズに移行する
@@ -953,7 +1129,7 @@ SPCDevice::BusFree()
 
 	// ここは BDID 書き込み前 (まだ scsibus に自身をつなげる前) にも呼ばれる。
 	// その場合は何もしない。バスフリーのはずでもあるし。
-	if (bus == NULL) {
+	if (scsi->GetBus() == NULL) {
 		return;
 	}
 
@@ -968,15 +1144,15 @@ SPCDevice::BusRelease()
 	// BSY、SEL だけを落とす。それ以外の信号線は正しくはないけどとりあえず
 	// 一括して SCSIHostDevice::BusFreeCB() が落とすことにしてある。
 
-	switch (GetPhase()) {
+	switch (scsi->GetPhase()) {
 	 case SCSI::Phase::BusFree:
 	 case SCSI::Phase::Transfer:
 		break;
 	 case SCSI::Phase::Arbitration:
 	 case SCSI::Phase::Selection:
 	 case SCSI::Phase::Reselection:
-		NegateSEL();
-		NegateBSY();
+		scsi->NegateSEL();
+		scsi->NegateBSY();
 		break;
 	}
 }
@@ -1004,13 +1180,13 @@ SPCDevice::SelectCommand()
 
 		if (data == 0) {
 			// ターゲット ID がない
-			idstr = string_format("#%d", myid);
+			idstr = string_format("#%u", myid);
 		} else {
-			tgtid = DecodeID(data);
-			idstr = string_format("#%d -> #%d", myid, tgtid);
+			tgtid = SCSIBus::DecodeID(data);
+			idstr = string_format("#%u -> #%u", myid, tgtid);
 		}
 	}
-	putlog(2, "Select コマンド (%s)", idstr.c_str());
+	putlog(2, "Select command (%s)", idstr.c_str());
 
 	// アービトレーションありの場合
 	//
@@ -1052,7 +1228,7 @@ SPCDevice::SelectCommand()
 	// t_FRID/t_BFBL はたぶん今からではなくバスフリーになった時点から起算。
 	// t_FRID と t_BFBL は同じ式なのでここでは t_BFBL で統一。
 	uint64 t_BFBL = (6 + spc.GetTCL()) * t_CLF;	// Min
-	uint64 now = gScheduler->GetVirtTime();
+	uint64 now = scheduler->GetVirtTime();
 	if ((last_busfree_time + t_BFBL) > now) {
 		wait = (last_busfree_time + t_BFBL) - now;
 	} else {
@@ -1066,9 +1242,9 @@ SPCDevice::SelectCommand()
 	// N が 0 なら無限大なのでタイマーは動かさない。
 	uint32 N = (spc.tc >> 8) << 8;
 	if (N != 0) {
-		event_tc.time = (N + 15) * t_CLF * 2;
-		event_tc.func = (DeviceCallback_t)&SPCDevice::SelectionTimeout;
-		event_tc.Start();
+		timer_event.func = ToEventCallback(&SPCDevice::SelectionTimeout);
+		timer_event.time = (N + 15) * t_CLF * 2;
+		scheduler->RestartEvent(timer_event);
 	}
 
 	if ((spc.sctl & SPC::SCTL_ARBIT_EN)) {
@@ -1093,7 +1269,7 @@ SPCDevice::SelectCommand()
 
 // アービトレーションフェーズ開始後、規定時間経過したので SEL を立てるところ。
 void
-SPCDevice::Arbitration1(int dummy)
+SPCDevice::Arbitration1(Event& ev)
 {
 	putlog(3, "Arbitration1");
 
@@ -1101,12 +1277,17 @@ SPCDevice::Arbitration1(int dummy)
 
 	// 本当は DB* -> SEL -> ATN の順でタイミングも規定されてるけど省略。
 	// ここでは SEL がトリガーになるので SEL のアサートは最後に行う。
-	SetData(spc.temp_out);
+	// アービトレーションありなら、セレクション/リセレクションフェーズを
+	// 区別するため PCTL に設定された IO をバスに出す(p.27)。
+	// MSG と CD は記述がないけどたぶん一緒に出すだろう。
+	// タイミングもどこでか分からんのでとりあえずここで。
+	scsi->SetData(spc.temp_out);
+	scsi->SetXfer(spc.pctl_out);
 	if (set_atn_in_selection) {
-		AssertATN();
+		scsi->AssertATN();
 		set_atn_in_selection = false;
 	}
-	AssertSEL();
+	scsi->AssertSEL();
 
 	uint64 t_SIDA = 11 * t_CLF - 30;
 	uint64 t_IDBH = 2 * t_CLF - 80;
@@ -1116,17 +1297,17 @@ SPCDevice::Arbitration1(int dummy)
 // アービトレーションフェーズ中、SEL を立ててから規定時間経過したので BSY を
 // 下げるところ。
 void
-SPCDevice::Arbitration2(int dummy)
+SPCDevice::Arbitration2(Event& ev)
 {
 	putlog(3, "Arbitration2");
 
-	NegateBSY();
+	scsi->NegateBSY();
 }
 
 // アービトレーションフェーズを使わない場合のセレクションフェーズで、
 // 規定時間経過したので SEL を立てるところ。
 void
-SPCDevice::Selection1(int dummy)
+SPCDevice::Selection1(Event& ev)
 {
 	putlog(3, "Selection1");
 
@@ -1134,23 +1315,26 @@ SPCDevice::Selection1(int dummy)
 
 	// 本当は DB* -> SEL の順でタイミングも規定されてるけど省略。
 	// ここでは SEL がトリガーになるので SEL のアサートは最後に行う。
-	SetData(spc.temp_out);
-	AssertSEL();
+	// アービトレーションなしなら PCTL に関係なくセレクションフェーズ (IO=0)
+	// を開始する(p.27)。MSG と CD は記述がないけどたぶん一緒に出すだろう。
+	scsi->SetData(spc.temp_out);
+	scsi->SetXfer(0);
+	scsi->AssertSEL();
 }
 
 // セレクションコマンドがタイムアウトした時に呼ばれるコールバック。
 void
-SPCDevice::SelectionTimeout(int dummy)
+SPCDevice::SelectionTimeout(Event& ev)
 {
 	if (loglevel >= 3) {
 		int tgtid;
-		uint8 data = GetData();
+		uint8 data = scsi->GetData();
 		data &= ~(1 << myid);
-		tgtid = DecodeID(data);
+		tgtid = SCSIBus::DecodeID(data);
 		if (tgtid == -1) {
-			putlog("Selection timeout");
+			putlogn("Selection timeout");
 		} else {
-			putlog("Selection timeout (#%d)", tgtid);
+			putlogn("Selection timeout (#%u)", tgtid);
 		}
 	}
 
@@ -1170,7 +1354,7 @@ SPCDevice::SetATNCommand()
 
 	// Select コマンド前なら、セレクションフェーズで ATN を立てる指示。
 	// 接続中(転送フェーズ中?) なら即座に ATN を立てる。
-	switch (GetPhase()) {
+	switch (scsi->GetPhase()) {
 	 case SCSI::Phase::BusFree:
 		set_atn_in_selection = true;
 		break;
@@ -1179,7 +1363,7 @@ SPCDevice::SetATNCommand()
 	 case SCSI::Phase::Reselection:
 		// Select Command 実行中なので実質ここで呼ばれることはないはずだが
 	 case SCSI::Phase::Transfer:
-		AssertATN();
+		scsi->AssertATN();
 		break;
 	}
 }
@@ -1189,20 +1373,21 @@ void
 SPCDevice::TransferCommand()
 {
 	putlog(2, "SCMD Transfer Command (xfer=%s len=0x%x)",
-		SCSI::GetXferPhaseName(GetPCTL() & 7), spc.tc);
+		SCSI::GetXferPhaseName(spc.pctl_out), spc.tc);
 
 	// SCMD レジスタ書き込みのうち Transfer コマンドに関わる未実装機能の
 	// ログ表示は SCMD レジスタ書き込み時ではなくここで表示。
 	if ((spc.scmd & SPC::SCMD_TERM_MODE)) {
-		putlog(0, "SCMD Padding mode not implemented");
-	}
-	if ((spc.scmd & SPC::SCMD_INTERCEPT)) {
-		putlog(0, "SCMD Intercept Transfer not implemented");
+		putlog(0, "SCMD Padding mode (NOT IMPLEMENTED)");
 	}
 
 	transfer_command_running = true;
 	spc.ssts |= SPC::SSTS_SPC_BUSY | SPC::SSTS_IN_PROGRESS;
 
+	// PCTL レジスタに設定してあるフェーズをバスに出す。
+	// XXX どこでかよく分からんけど、とりあえずこの辺で。
+	scsi->SetXfer(spc.pctl_out);
+
 	// 転送開始前に DREG キューを初期化する。
 	// MPU 側が DREG を全部読まずにフェーズを中断とかはたぶん出来るので。
 	// XXX 転送開始前なのかリセットなのか…
@@ -1210,23 +1395,21 @@ SPCDevice::TransferCommand()
 
 	// Transfer コマンド発行時に REQ がアサートされていなければ
 	// アサートされるまで待つ。この場合、ここでは何もすることはなく、
-	// TransferReqCB() が呼ばれてそこから転送フェーズが動き始める。
-	if (GetREQ()) {
+	// OnTransferReq() が呼ばれてそこから転送フェーズが動き始める。
+	if (scsi->GetREQ()) {
 		// コマンドから転送開始までちょっとだけかかる
-		// XXX 4 * t_CLF だと NetBSD カーネルがレースコンディションにはまる。
-		CallAfter(TransferCommandStart, "SPC SCMD to Start", 0 * t_CLF);
+		CallAfter(HardwareTransfer, "SPC SCMD to Start", 4 * t_CLF);
 	}
 }
 
-// バスフリーコールバック (SCSIBus から呼ばれる)
+// バスフリーコールバック (SCSIHostDevice から呼ばれる)。
 // id はこのバスフリーを行ったデバイス (0..7)
 void
-SPCDevice::BusFreeCB(int id)
+SPCDevice::BusFreeCallback(uint id)
 {
 	putlog(4, "BusFree Callback");
 
-	inherited::BusFreeCB(id);
-	last_busfree_time = gScheduler->GetVirtTime();
+	last_busfree_time = scheduler->GetVirtTime();
 
 	transfer_command_running = false;
 	spc.ssts &= ~(SPC::SSTS_CONN_INIT | SPC::SSTS_CONN_TARG);
@@ -1242,19 +1425,15 @@ SPCDevice::BusFreeCB(int id)
 	}
 }
 
-// ターゲットがセレクションに応答したコールバック (SCSIBus から呼ばれる)
+// ターゲットがセレクションに応答したコールバック
+// (SCSIHostDevice から呼ばれる)
 void
-SPCDevice::SelectionAckCB()
+SPCDevice::SelectionAckCallback()
 {
-	// ターゲットが BSY を立てて応答したので、
-	// こちらはデータバスをクリアして SEL を下げる。
-	// これによりセレクションフェーズは成功で完了する。
-	putlog(4, "SelectionAck Calback");
-	SetData(0);
-	NegateSEL();
+	putlog(4, "SelectionAck Callback");
 
 	// タイムアウトイベントを停止
-	event_tc.Stop();
+	scheduler->StopEvent(timer_event);
 
 	spc.ssts &= ~SPC::SSTS_SPC_BUSY;
 	spc.ssts |= SPC::SSTS_CONN_INIT;
@@ -1263,44 +1442,28 @@ SPCDevice::SelectionAckCB()
 	SetINTS(SPC::INTS_COMPLETE);
 }
 
-// 転送フェーズでターゲットが REQ を立てたコールバック (SCSIBus から呼ばれる)
+// 転送フェーズでターゲットが REQ を立てたコールバック
+// (SCSIHostDevice から呼ばれる)
 void
-SPCDevice::TransferReqCB()
+SPCDevice::TransferReqCallback()
 {
 	// REQ が立てば Transfer Command 発行前でも Xfer In Progress は立てる
 	spc.ssts |= SPC::SSTS_IN_PROGRESS;
 
 	if (transfer_command_running) {
-		// ハードウェア転送で SDGC_XFER_ENABLE がセットされていれば、
-		// データ要求が来ている時に XFER_OUT をセット(?)
-		if ((spc.sdgc & SPC::SDGC_XFER_ENABLE)) {
-			spc.serr |= SPC::SERR_XFER_OUT;
-		}
-
 		// Transfer Command 実行中なら REQ 待ちだったので
 		// ここでハードウェア転送を開始。
-		TransferCommandStart(0);
-	} else {
-		// ハードウェア転送中でなくて IN 方向ならここで TEMP に取り込む。
-		if (GetIO()) {
-			spc.temp_in = GetData();
-		}
+		HardwareTransfer(phase_event);
 	}
-}
 
-// Transfer Command の実行開始部分。
-// TransferCommand() と TransferReqCB() から呼ばれる。
-void
-SPCDevice::TransferCommandStart(int dummy)
-{
-	// Transfer コマンドの発行と REQ がアサートの両方が成立した時点で、
-	// SCSI バスの状態と PCTL レジスタの下位3ビットの状態を比較する。
-	// 一致していれば転送開始、そうでなければ Service Required 割り込み。
-	if ((GetPCTL() & 7) == GetXfer()) {
-		HardwareTransfer(0);
-	} else {
-		transfer_command_running = false;
-		SetINTS(SPC::INTS_SERV_REQ);
+	// データシートでは、マニュアル転送で IN 方向の時データバスの内容を
+	// TEMP に取り込むと書いてある(p.78)。
+	// HardwareTransfer によって状態が変更される可能性があるため
+	// もう一回チェック。
+	if (transfer_command_running == false) {
+		if (scsi->GetIO()) {
+			spc.temp_in = scsi->GetData();
+		}
 	}
 }
 
@@ -1308,23 +1471,32 @@ SPCDevice::TransferCommandStart(int dumm
 // イベントコールバックとして呼び出すこと。
 // REQ がアサートされているのを確認してから呼び出すこと。
 // (1バイト送信するとターゲットが再び REQ を上げるなどしてくるので、
-// TransferReqCB() か DREG 書き込みから再びここが呼ばれる)
+// OnTransferReq() か DREG 書き込みから再びここが呼ばれる)
 void
-SPCDevice::HardwareTransfer(int dummy)
+SPCDevice::HardwareTransfer(Event& ev)
 {
 	// SDGC_XFER_ENABLE は転送要求ごとに割り込みを上げる。
 	// (SPC から見て) 入力操作時は読み込めるデータがある場合、出力操作時は
 	// キューにバイトを書き込む必要がある場合に、割り込みを上げる。
 
+	// PCTL のフェーズと SCSI バスのフェーズが一致していれば転送(開始|継続)。
+	// そうでなければ Service Required 割り込み。
+	if (spc.pctl_out != scsi->GetXfer()) {
+		transfer_command_running = false;
+		putlog(3, "Hardware Transfer terminated (phase mismatch)");
+		SetINTS(SPC::INTS_SERV_REQ);
+		return;
+	}
+
 	// DREG が送受信不可能ならここでは何もせずに帰るだけでよい。
 	// その後 DREG アクセスによって送受信可能になればまたこれが呼ばれる。
-	if (GetIO()) {
+	if (scsi->GetIO()) {
 		// Input (ターゲット → イニシエータ)
-		bool queued = spc.dreg.Enqueue(GetData());
+		bool queued = spc.dreg.Enqueue(scsi->GetData());
 		// SDGC_XFER_ENABLE なら読み込めるデータがある場合に割り込み。
 		if ((spc.sdgc & SPC::SDGC_XFER_ENABLE)) {
 			putlog(3, "SDGC XFER_OUT Interrupt");
-			SetINTS(0);
+			SetINTS(SPC::INTS_XFER_OUT);
 		}
 		if (!queued) {
 			putlog(4, "Hardware Transfer (DREG full)");
@@ -1333,36 +1505,29 @@ SPCDevice::HardwareTransfer(int dummy)
 	} else {
 		// Output (イニシエータ → ターゲット)
 		if (spc.dreg.Length() != 0) {
-			SetData(spc.dreg.Dequeue());
+			scsi->SetData(spc.dreg.Dequeue());
 		} else {
 			putlog(4, "Hardware Transfer (DREG empty)");
 			// SDGC_XFER_ENABLE ならキューに書き込む必要がある場合に割り込み。
 			if ((spc.sdgc & SPC::SDGC_XFER_ENABLE)) {
 				putlog(3, "SDGC XFER_OUT Interrupt");
-				SetINTS(0);
+				SetINTS(SPC::INTS_XFER_OUT);
 			}
 			return;
 		}
 	}
-	// SDGC XFER_OUT のログと順序が微妙になるけど、
-	// DREG full/empty で2行出るのを避けたいので。
-	putlog(4, "Hardware Transfer");
-
-	// XXX XFER_OUT はどこで落とすんやろうか。
-	// データ要求が来たら上げるのだから用が済んだら下ろすのかしら。
-	spc.serr &= ~SPC::SERR_XFER_OUT;
 
-	AssertACK();
+	scsi->AssertACK();
 
 	// 転送完了
 	spc.tc--;
-	putlog(4, "Hardware Transfer: %s q=%d tc=%d",
-		(GetIO() ? "IN" : "OUT"), spc.dreg.Length(), spc.tc);
+	putlog(4, "Hardware Transfer: %s q=%u tc=%u",
+		(scsi->GetIO() ? "IN" : "OUT"), spc.dreg.Length(), spc.tc);
 	if (spc.tc == 0) {
 		// どちらでも転送自体はここで完了(?)
 		transfer_command_running = false;
 
-		if (GetIO()) {
+		if (scsi->GetIO()) {
 			// Input 時は TC がゼロになって DREG キューを全部読み出した
 			// ところで完了なので、ここでは何もしない。
 		} else {
@@ -1372,14 +1537,14 @@ SPCDevice::HardwareTransfer(int dummy)
 	}
 
 	// メッセージアウトフェーズの最終バイト送信中(?)に ATN を下げる
-	if (GetXfer() == SCSI::XferPhase::MsgOut && spc.tc == 0) {
-		NegateATN();
+	if (scsi->GetXfer() == SCSI::XferPhase::MsgOut && spc.tc == 0) {
+		scsi->NegateATN();
 	}
 
-	if (GetXfer() == SCSI::XferPhase::MsgIn && spc.tc == 0) {
+	if (scsi->GetXfer() == SCSI::XferPhase::MsgIn && spc.tc == 0) {
 		// ただしメッセージインフェーズの最終バイトなら ACK を下げない。
 	} else {
-		NegateACK();
+		scsi->NegateACK();
 	}
 }