Relented: it actually looks like status bytes aren't per-drive. But each drive may fail at seeking individually. So that piece of state accumulates at the 8272 drive.

Components/8272/i8272.cpp

@@ -17,10 +17,6 @@ const uint8_t StatusRequest = 0x80;	// Set: ready to send or receive from proces
 const uint8_t StatusDirection = 0x40;	// Set: data is expected to be taken from the 8272 by the processor.
 const uint8_t StatusNonDMAExecuting = 0x20;	// Set: the execution phase of a data transfer command is ongoing and DMA mode is disabled.
 const uint8_t StatusBusy = 0x10;	// Set: the FDC is busy.
-//const uint8_t StatusD3B = 0x08;	// Set: drive 3 is seeking.
-//const uint8_t StatusD2B = 0x04;	// Set: drive 2 is seeking.
-//const uint8_t StatusD1B = 0x02;	// Set: drive 1 is seeking.
-//const uint8_t StatusD0B = 0x01;	// Set: drive 0 is seeking.
 }
 
 i8272::i8272(Cycles clock_rate, int clock_rate_multiplier, int revolutions_per_minute) :
@@ -60,7 +56,7 @@ void i8272::run_for(Cycles cycles) {
 					drives_[c].head_position += direction;
 
 					// Check for completion.
-					if(seek_is_satisfied(c)) {
+					if(drives_[c].seek_is_satisfied()) {
 						drives_[c].phase = Drive::CompletedSeeking;
 						if(drives_[c].target_head_position == -1) drives_[c].head_position = 0;
 						break;
@@ -154,12 +150,14 @@ void i8272::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
 	if(distance_into_section_ < 6) goto CONCAT(read_header, __LINE__);	\
 	set_data_mode(Scanning);
 
+#define CLEAR_STATUS()	\
+	status_[0] = status_[1] = status_[2] = 0;
+
 #define SET_DRIVE_HEAD_MFM()	\
 	if(!dma_mode_) main_status_ |= StatusNonDMAExecuting;	\
 	active_drive_ = command_[1]&3;	\
 	active_head_ = (command_[1] >> 2)&1;	\
 	set_drive(drives_[active_drive_].drive);	\
-	drives_[active_drive_].clear_status();	\
 	drives_[active_drive_].drive->set_head((unsigned int)active_head_);	\
 	set_is_double_density(command_[0] & 0x40);	\
 	invalidate_track();
@@ -290,6 +288,7 @@ void i8272::posit_event(int event_type) {
 		// cylinder, head, sector and size registers from the command stream.
 			SET_DRIVE_HEAD_MFM();
 			LOAD_HEAD();
+			CLEAR_STATUS();
 			cylinder_ = command_[2];
 			head_ = command_[3];
 			sector_ = command_[4];
@@ -344,8 +343,8 @@ void i8272::posit_event(int event_type) {
 		read_data_not_found:
 			printf("Not found\n");
 
-			drives_[active_drive_].status[1] |= 0x4;
+			status_[1] |= 0x4;
-			drives_[active_drive_].status[0] = 0x40;	// (status_[0] & ~0xc0) |
+			status_[0] = 0x40;
 			goto post_st012chrn;
 
 	read_deleted_data:
@@ -414,15 +413,15 @@ void i8272::posit_event(int event_type) {
 		// a recalibrate the target is -1 and ::run_for knows that -1 means the terminal condition is the drive
 		// returning that its at track zero, and that it should reset the drive's current position once reached.
 			if(drives_[command_[1]&3].phase != Drive::Seeking) {
-				drives_[command_[1]&3].clear_status();
 				int drive = command_[1]&3;
 				drives_[drive].phase = Drive::Seeking;
 				drives_[drive].steps_taken = 0;
 				drives_[drive].target_head_position = (command_.size() > 2) ? command_[2] : -1;
 				drives_[drive].step_rate_counter = 0;
+				drives_[drive].seek_failed = false;
 
 				// Check whether any steps are even needed.
-				if(seek_is_satisfied(drive)) {
+				if(drives_[drive].seek_is_satisfied()) {
 					drives_[drive].phase = Drive::CompletedSeeking;
 				} else {
 					main_status_ |= 1 << (command_[1]&3);
@@ -446,11 +445,11 @@ void i8272::posit_event(int event_type) {
 				// If a drive was found, return its results. Otherwise return a single 0x80.
 				if(found_drive != -1) {
 					drives_[found_drive].phase = Drive::NotSeeking;
-					drives_[found_drive].status[0] = (uint8_t)found_drive | 0x20;
+					status_[0] = (uint8_t)found_drive | 0x20;
 					main_status_ &= ~(1 << found_drive);
 
 					result_stack_.push_back(drives_[found_drive].head_position);
-					result_stack_.push_back(drives_[found_drive].status[0]);
+					result_stack_.push_back(status_[0]);
 				} else {
 					result_stack_.push_back(0x80);
 				}
@@ -494,9 +493,9 @@ void i8272::posit_event(int event_type) {
 			result_stack_.push_back(head_);
 			result_stack_.push_back(cylinder_);
 
-			result_stack_.push_back(drives_[active_drive_].status[2]);
+			result_stack_.push_back(status_[2]);
-			result_stack_.push_back(drives_[active_drive_].status[1]);
+			result_stack_.push_back(status_[1]);
-			result_stack_.push_back(drives_[active_drive_].status[0]);
+			result_stack_.push_back(status_[0]);
 
 			goto post_result;
 
@@ -518,7 +517,7 @@ void i8272::posit_event(int event_type) {
 	END_SECTION()
 }
 
-bool i8272::seek_is_satisfied(int drive) {
+bool i8272::Drive::seek_is_satisfied() {
-	return	(drives_[drive].target_head_position == drives_[drive].head_position) ||
+	return	(target_head_position == head_position) ||
-			(drives_[drive].target_head_position == -1 && drives_[drive].drive->get_is_track_zero());
+			(target_head_position == -1 && drive->get_is_track_zero());
 }

Components/8272/i8272.hpp

@@ -29,67 +29,81 @@ class i8272: public Storage::Disk::MFMController {
 		void set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive);
 
 	private:
-		void posit_event(int type);
+		// Status registers.
 		uint8_t main_status_;
+		uint8_t status_[3];
 
+		// A buffer for accumulating the incoming command, and one for accumulating the result.
 		std::vector<uint8_t> command_;
 		std::vector<uint8_t> result_stack_;
 
+		// Event stream: the 8272-specific events, plus the current event state.
 		enum class Event8272: int {
 			CommandByte	= (1 << 3),
 			Timer = (1 << 4),
 			ResultEmpty = (1 << 5),
 		};
-
+		void posit_event(int type);
 		int interesting_event_mask_;
 		int resume_point_;
+
+		// The counter used for ::Timer events.
 		int delay_time_;
 
-		int step_rate_time_;
+		// The connected drives.
-		int head_unload_time_;
-		int head_load_time_;
-		bool dma_mode_;
-
 		struct Drive {
 			uint8_t head_position;
-			uint8_t status[3];
 
-			// Seeking state.
+			// Seeking: persistent state.
 			enum Phase {
 				NotSeeking,
 				Seeking,
 				CompletedSeeking
 			} phase;
+			bool seek_failed;
+
+			// Seeking: transient state.
 			int step_rate_counter;
 			int steps_taken;
 			int target_head_position;	// either an actual number, or -1 to indicate to step until track zero
 
+			/// @returns @c true if the currently queued-up seek or recalibrate has reached where it should be.
+			bool seek_is_satisfied();
+
 			// Head state.
 			int head_unload_delay[2];
 			bool head_is_loaded[2];
 
+			// The connected drive.
 			std::shared_ptr<Storage::Disk::Drive> drive;
 
 			Drive() :
 				head_position(0), phase(NotSeeking),
 				drive(new Storage::Disk::Drive),
-				status{0, 0, 0}, head_is_loaded{false, false} {};
+				head_is_loaded{false, false} {};
-			void clear_status() {
-				status[0] = status[1] = status[2] = 0;
-			}
 		} drives_[4];
+
+		// User-supplied parameters; as per the specify command.
+		int step_rate_time_;
+		int head_unload_time_;
+		int head_load_time_;
+		bool dma_mode_;
+
+		// A count of head unload timers currently running.
 		int head_timers_running_;
 
+		// Transient storage and counters used while reading the disk.
 		uint8_t header_[6];
 		int distance_into_section_;
 		int index_hole_limit_;
 
+		// Keeps track of the drive and head in use during commands.
 		int active_drive_;
 		int active_head_;
 
+		// Internal registers.
 		uint8_t cylinder_, head_, sector_, size_;
 
-		bool seek_is_satisfied(int drive);
 };
 
 }