From 0f15a2f97f5e1eb26db03640e5068432a72aab4a Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Sat, 12 Aug 2017 12:52:36 -0400 Subject: [PATCH] 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 | 35 ++++++++++++++++---------------- Components/8272/i8272.hpp | 42 ++++++++++++++++++++++++++------------- 2 files changed, 45 insertions(+), 32 deletions(-) diff --git a/Components/8272/i8272.cpp b/Components/8272/i8272.cpp index ce6395aba..39d70d2c9 100644 --- a/Components/8272/i8272.cpp +++ b/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 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; - drives_[active_drive_].status[0] = 0x40; // (status_[0] & ~0xc0) | + status_[1] |= 0x4; + 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(drives_[active_drive_].status[1]); - result_stack_.push_back(drives_[active_drive_].status[0]); + result_stack_.push_back(status_[2]); + result_stack_.push_back(status_[1]); + 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) { - return (drives_[drive].target_head_position == drives_[drive].head_position) || - (drives_[drive].target_head_position == -1 && drives_[drive].drive->get_is_track_zero()); +bool i8272::Drive::seek_is_satisfied() { + return (target_head_position == head_position) || + (target_head_position == -1 && drive->get_is_track_zero()); } diff --git a/Components/8272/i8272.hpp b/Components/8272/i8272.hpp index d204427b3..137e56b3f 100644 --- a/Components/8272/i8272.hpp +++ b/Components/8272/i8272.hpp @@ -29,67 +29,81 @@ class i8272: public Storage::Disk::MFMController { void set_disk(std::shared_ptr 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 command_; std::vector 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_; - int head_unload_time_; - int head_load_time_; - bool dma_mode_; - + // The connected drives. 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 drive; Drive() : head_position(0), phase(NotSeeking), drive(new Storage::Disk::Drive), - status{0, 0, 0}, head_is_loaded{false, false} {}; - void clear_status() { - status[0] = status[1] = status[2] = 0; - } + head_is_loaded{false, false} {}; } 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); }; }