6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-11-26 08:49:37 +00:00
Code Issues Projects Releases Wiki Activity

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.

Browse Source
This commit is contained in:
Thomas Harte 2017-08-12 12:52:36 -04:00
parent 89ace671a4
commit 0f15a2f97f
2 changed files with 45 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
Components/8272/i8272.cpp
View File

@ -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;
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());
}

42
Components/8272/i8272.hpp
View File

@ -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_;
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<Storage::Disk::Drive> 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);
};
}