6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-07-10 12:29:01 +00:00
Code Issues Projects Releases Wiki Activity
73f8488150
CLK/Components/8272/i8272.cpp

389 lines
11 KiB
C++
Raw Normal View History

Strung up an empty shell that eventually should contain the 8272, and added appropriate IO decoding to the Amstrad.
2017-08-05 23:45:52 +00:00
//
// i8272.cpp
// Clock Signal
//
// Created by Thomas Harte on 05/08/2017.
// Copyright © 2017 Thomas Harte. All rights reserved.
//
#include "i8272.hpp"
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
#include <cstdio>
Strung up an empty shell that eventually should contain the 8272, and added appropriate IO decoding to the Amstrad.
2017-08-05 23:45:52 +00:00
using namespace Intel;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
namespace {
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
const uint8_t StatusRQM = 0x80; // Set: ready to send or receive from processor.
const uint8_t StatusDIO = 0x40; // Set: data is expected to be taken from the 8272 by the processor.
const uint8_t StatusNDM = 0x20; // Set: the execution phase of a data transfer command is ongoing and DMA mode is disabled.
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
const uint8_t StatusCB = 0x10; // Set: the FDC is busy.
Started resetting 'busy' when entering the result phase. AMSDOS now complains of a missing disk after failing to find sector 01. My belief is that it should end up asking for C1. So this is not even getting through a failure to find a sector correctly yet.
2017-08-06 23:48:17 +00:00
//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.
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
}
Switched disk controllers to be instantiated explicitly in terms of cycles, created an Amstrad-specific subclass of the 8272 to record the direct programmatic availability of all disk motors bundled together, and otherwise adjusted to ensure the thing is clocked and that the motor is enabled and disabled appropriately. The 8272 is also now formally a subclass of the incoming MDM controller.
2017-08-06 13:45:16 +00:00
i8272::i8272(Cycles clock_rate, int clock_rate_multiplier, int revolutions_per_minute) :
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
Storage::Disk::MFMController(clock_rate, clock_rate_multiplier, revolutions_per_minute),
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
main_status_(StatusRQM),
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
interesting_event_mask_((int)Event8272::CommandByte),
resume_point_(0),
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
delay_time_(0),
Removed formal storage of ST3, as it just seems to be composed live. This may turn out also to be the best way to deal with ST0–2, time will tell. Also took a stab at the error in responding properly to the ROM's intended use of seek might be accepting new commands as replacements for old ones rather than rejecting them. That didn't seem to do the trick.
2017-08-07 02:10:12 +00:00
status_{0, 0, 0} {
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
posit_event((int)Event8272::CommandByte);
Switched disk controllers to be instantiated explicitly in terms of cycles, created an Amstrad-specific subclass of the 8272 to record the direct programmatic availability of all disk motors bundled together, and otherwise adjusted to ensure the thing is clocked and that the motor is enabled and disabled appropriately. The 8272 is also now formally a subclass of the incoming MDM controller.
2017-08-06 13:45:16 +00:00
}
void i8272::run_for(Cycles cycles) {
Storage::Disk::MFMController::run_for(cycles);
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
// check for an expired timer
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
if(delay_time_ > 0) {
if(cycles.as_int() >= delay_time_) {
delay_time_ = 0;
posit_event((int)Event8272::Timer);
} else {
delay_time_ -= cycles.as_int();
}
}
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
// update seek status of any drives presently seeking
for(int c = 0; c < 4; c++) {
if(drives_[c].phase == Drive::Seeking) {
drives_[c].step_rate_counter += cycles.as_int();
int steps = drives_[c].step_rate_counter / (8000 * step_rate_time_);
drives_[c].step_rate_counter %= (8000 * step_rate_time_);
while(steps--) {
if(
(drives_[c].target_head_position == (int)drives_[c].head_position) ||
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
(drives_[c].drive->get_is_track_zero() && drives_[c].target_head_position == -1)) {
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
drives_[c].phase = Drive::CompletedSeeking;
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
if(drives_[c].target_head_position == -1) drives_[c].head_position = 0;
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
} else {
int direction = (drives_[c].target_head_position < drives_[c].head_position) ? -1 : 1;
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
drives_[c].drive->step(direction);
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
drives_[c].head_position += direction;
}
}
}
}
Switched disk controllers to be instantiated explicitly in terms of cycles, created an Amstrad-specific subclass of the 8272 to record the direct programmatic availability of all disk motors bundled together, and otherwise adjusted to ensure the thing is clocked and that the motor is enabled and disabled appropriately. The 8272 is also now formally a subclass of the incoming MDM controller.
2017-08-06 13:45:16 +00:00
}
Strung up an empty shell that eventually should contain the 8272, and added appropriate IO decoding to the Amstrad.
2017-08-05 23:45:52 +00:00
void i8272::set_register(int address, uint8_t value) {
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
// don't consider attempted sets to the status register
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
if(!address) return;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
// if not ready for commands, do nothing
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
if(!(main_status_ & StatusRQM)) return;
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
// accumulate latest byte in the command byte sequence
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
command_.push_back(value);
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
posit_event((int)Event8272::CommandByte);
Strung up an empty shell that eventually should contain the 8272, and added appropriate IO decoding to the Amstrad.
2017-08-05 23:45:52 +00:00
}
uint8_t i8272::get_register(int address) {
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
if(address) {
Collapsed implementations of recalibrate and seek, and decided to intend to go for an upward count on steps taken rather than a downward one. But seek continues presently to fail.
2017-08-07 01:52:52 +00:00
// printf("8272 get data\n");
Renamed `result_` to `result_stack_` to emphasis the fact that it goes backwards. Switched meaning of CB so that it is set for the entire command, execution and result phases.
2017-08-07 00:17:12 +00:00
if(result_stack_.empty()) return 0xff;
uint8_t result = result_stack_.back();
result_stack_.pop_back();
if(result_stack_.empty()) posit_event((int)Event8272::ResultEmpty);
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
return result;
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
} else {
Removed formal storage of ST3, as it just seems to be composed live. This may turn out also to be the best way to deal with ST0–2, time will tell. Also took a stab at the error in responding properly to the ROM's intended use of seek might be accepting new commands as replacements for old ones rather than rejecting them. That didn't seem to do the trick.
2017-08-07 02:10:12 +00:00
// printf("Main status: %02x\n", main_status_);
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
return main_status_;
Mildly increased work in here, still primarily oriented towards logging what I actually need to get done.
2017-08-06 02:26:59 +00:00
}
Strung up an empty shell that eventually should contain the 8272, and added appropriate IO decoding to the Amstrad.
2017-08-05 23:45:52 +00:00
}
Switched disk controllers to be instantiated explicitly in terms of cycles, created an Amstrad-specific subclass of the 8272 to record the direct programmatic availability of all disk motors bundled together, and otherwise adjusted to ensure the thing is clocked and that the motor is enabled and disabled appropriately. The 8272 is also now formally a subclass of the incoming MDM controller.
2017-08-06 13:45:16 +00:00
Disks are now communicated to the 8272. Which is able to handle four of them.
2017-08-06 17:24:14 +00:00
void i8272::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
if(drive < 4 && drive >= 0) {
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
drives_[drive].drive->set_disk(disk);
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
}
Disks are now communicated to the 8272. Which is able to handle four of them.
2017-08-06 17:24:14 +00:00
}
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
#define BEGIN_SECTION() switch(resume_point_) { default:
#define END_SECTION() }
#define WAIT_FOR_EVENT(mask) resume_point_ = __LINE__; interesting_event_mask_ = (int)mask; return; case __LINE__:
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
#define PASTE(x, y) x##y
#define CONCAT(x, y) PASTE(x, y)
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
#define FIND_HEADER() \
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
CONCAT(find_header, __LINE__): WAIT_FOR_EVENT((int)Event::Token | (int)Event::IndexHole); \
if(event_type == (int)Event::IndexHole) index_hole_limit_--; \
else if(get_latest_token().type == Token::ID) goto CONCAT(header_found, __LINE__); \
\
if(index_hole_limit_) goto CONCAT(find_header, __LINE__); \
CONCAT(header_found, __LINE__): 0;\
Made a first attempt to return sector contents.
2017-08-07 00:40:29 +00:00
#define FIND_DATA() \
CONCAT(find_data, __LINE__): WAIT_FOR_EVENT((int)Event::Token | (int)Event::IndexHole); \
if(event_type == (int)Event::Token && get_latest_token().type != Token::Data) goto CONCAT(find_data, __LINE__);
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
#define READ_HEADER() \
Made a first attempt to return sector contents.
2017-08-07 00:40:29 +00:00
distance_into_section_ = 0; \
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
set_data_mode(Reading); \
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
CONCAT(read_header, __LINE__): WAIT_FOR_EVENT(Event::Token); \
Made a first attempt to return sector contents.
2017-08-07 00:40:29 +00:00
header_[distance_into_section_] = get_latest_token().byte_value; \
distance_into_section_++; \
if(distance_into_section_ != 7) goto CONCAT(read_header, __LINE__); \
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
set_data_mode(Scanning);
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
#define SET_DRIVE_HEAD_MFM() \
if(!dma_mode_) main_status_ |= StatusNDM; \
set_drive(drives_[command_[1]&3].drive); \
set_is_double_density(command_[0] & 0x40);
Made an effort to start inspecting ID fields, at least. Discovered that my emulation has somehow stopped proceeding beyond sense interrupt status though. Fix one in that area: adjust ST0 just in time for the sense interrupt status response, as that'll need to specify the drive number properly.
2017-08-06 22:06:20 +00:00
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
void i8272::posit_event(int event_type) {
if(!(interesting_event_mask_ & event_type)) return;
interesting_event_mask_ &= ~event_type;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
BEGIN_SECTION();
wait_for_command:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
set_data_mode(Storage::Disk::MFMController::DataMode::Scanning);
main_status_ &= ~(StatusCB | StatusNDM);
command_.clear();
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
wait_for_complete_command_sequence:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
main_status_ |= StatusRQM;
WAIT_FOR_EVENT(Event8272::CommandByte)
main_status_ |= StatusCB;
main_status_ &= ~StatusRQM;
switch(command_[0] & 0x1f) {
case 0x06: // read data
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto read_data;
case 0x0b: // read deleted data
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto read_deleted_data;
case 0x05: // write data
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto write_data;
case 0x09: // write deleted data
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto write_deleted_data;
case 0x02: // read track
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto read_track;
case 0x0a: // read ID
if(command_.size() < 2) goto wait_for_complete_command_sequence;
goto read_id;
case 0x0d: // format track
if(command_.size() < 6) goto wait_for_complete_command_sequence;
goto format_track;
case 0x11: // scan low
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto scan_low;
case 0x19: // scan low or equal
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto scan_low_or_equal;
case 0x1d: // scan high or equal
if(command_.size() < 9) goto wait_for_complete_command_sequence;
goto scan_high_or_equal;
case 0x07: // recalibrate
if(command_.size() < 2) goto wait_for_complete_command_sequence;
goto recalibrate;
case 0x08: // sense interrupt status
goto sense_interrupt_status;
case 0x03: // specify
if(command_.size() < 3) goto wait_for_complete_command_sequence;
goto specify;
case 0x04: // sense drive status
if(command_.size() < 2) goto wait_for_complete_command_sequence;
goto sense_drive_status;
case 0x0f: // seek
if(command_.size() < 3) goto wait_for_complete_command_sequence;
goto seek;
default: // invalid
goto invalid;
}
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
read_data:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
printf("Read data, sector %02x %02x %02x %02x\n", command_[2], command_[3], command_[4], command_[5]);
SET_DRIVE_HEAD_MFM();
cylinder_ = command_[2];
head_ = command_[3];
sector_ = command_[4];
size_ = command_[5];
index_hole_limit_ = 2;
find_next_sector:
FIND_HEADER();
if(!index_hole_limit_) goto read_data_not_found;
READ_HEADER();
if(header_[0] != cylinder_ || header_[1] != head_ || header_[2] != sector_ || header_[3] != size_) goto find_next_sector;
FIND_DATA();
distance_into_section_ = 0;
set_data_mode(Reading);
get_byte:
WAIT_FOR_EVENT(Event::Token);
result_stack_.push_back(get_latest_token().byte_value);
distance_into_section_++;
main_status_ |= StatusRQM | StatusDIO;
WAIT_FOR_EVENT(Event8272::ResultEmpty);
main_status_ &= ~StatusRQM;
if(distance_into_section_ < (128 << size_)) goto get_byte;
set_data_mode(Scanning);
goto post_st012chrn;
read_data_not_found:
printf("Not found\n");
status_[1] |= 0x4;
status_[0] = 0x40; // (status_[0] & ~0xc0) |
goto post_st012chrn;
Added respect for the index-hole limit on reading, and an error phase.
2017-08-06 23:25:44 +00:00
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
read_deleted_data:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Read deleted data unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
write_data:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Write data unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
write_deleted_data:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Write deleted data unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
read_track:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Read track unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
read_id:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
printf("Read ID\n");
SET_DRIVE_HEAD_MFM();
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
index_hole_limit_ = 2;
read_id_find_next_sector:
FIND_HEADER();
if(!index_hole_limit_) goto read_id_not_found;
READ_HEADER();
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
cylinder_ = header_[0];
head_ = header_[1];
sector_ = header_[2];
size_ = header_[3];
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
goto post_st012chrn;
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
read_id_not_found:
status_[1] |= 0x4;
status_[0] = 0x40;
With the ROM now using a read ID to set its expectations, implemented that and fixed FIND/READ_HEADER macros for multiple use. Execution now reaches the unimplemented section of read data.
2017-08-07 00:32:46 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
goto post_st012chrn;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
format_track:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Fromat track unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
scan_low:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Scan low unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
scan_low_or_equal:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Scan low or equal unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
scan_high_or_equal:
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
printf("Scan high or equal unimplemented!!\n");
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
goto wait_for_command;
recalibrate:
Collapsed implementations of recalibrate and seek, and decided to intend to go for an upward count on steps taken rather than a downward one. But seek continues presently to fail.
2017-08-07 01:52:52 +00:00
seek:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
printf((command_.size() > 2) ? "Seek\n" : "Recalibrate\n");
if(drives_[command_[1]&3].phase != Drive::Seeking) {
status_[0] = status_[1] = status_[2] = 0;
drives_[command_[1]&3].phase = Drive::Seeking;
drives_[command_[1]&3].steps_taken = 0;
drives_[command_[1]&3].target_head_position = (command_.size() > 2) ? command_[2] : -1;
drives_[command_[1]&3].step_rate_counter = 0;
main_status_ |= 1 << (command_[1]&3);
}
goto wait_for_command;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
sense_interrupt_status:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
printf("Sense interrupt status\n");
// Find the first drive that is in the CompletedSeeking state and return for that;
// if none has done so then return a single 0x80.
{
int found_drive = -1;
for(int c = 0; c < 4; c++) {
if(drives_[c].phase == Drive::CompletedSeeking) {
found_drive = c;
break;
}
}
if(found_drive != -1) {
drives_[found_drive].phase = Drive::NotSeeking;
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(status_[0]);
} else {
result_stack_.push_back(0x80);
Made an attempt at some of the correct seek/recalibrate behaviour: it's now asynchronous from command processing and able to work on up to four drives at once. I just probably am not yet hitting all the status flags I need to hit.
2017-08-06 19:22:07 +00:00
}
}
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
goto post_result;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
specify:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
step_rate_time_ = command_[1] &0xf0; // i.e. 16 to 240m
head_unload_time_ = command_[1] & 0x0f; // i.e. 1 to 16ms
head_load_time_ = command_[2] & ~1; // i.e. 2 to 254 ms in increments of 2ms
dma_mode_ = !(command_[2] & 1);
goto wait_for_command;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
sense_drive_status:
Removed formal storage of ST3, as it just seems to be composed live. This may turn out also to be the best way to deal with ST0–2, time will tell. Also took a stab at the error in responding properly to the ROM's intended use of seek might be accepting new commands as replacements for old ones rather than rejecting them. That didn't seem to do the trick.
2017-08-07 02:10:12 +00:00
printf("Sense drive status unimplemented!!\n");
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
goto wait_for_command;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
invalid:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
// A no-op, causing the FDC to go back into standby mode.
goto wait_for_command;
post_st012chrn:
result_stack_.push_back(size_);
result_stack_.push_back(sector_);
result_stack_.push_back(head_);
result_stack_.push_back(cylinder_);
result_stack_.push_back(status_[2]);
result_stack_.push_back(status_[1]);
result_stack_.push_back(status_[0]);
goto post_result;
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
post_result:
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
// Set ready to send data to the processor, no longer in non-DMA execution phase.
main_status_ |= StatusRQM | StatusDIO;
main_status_ &= ~StatusNDM;
Started resetting 'busy' when entering the result phase. AMSDOS now complains of a missing disk after failing to find sector 01. My belief is that it should end up asking for C1. So this is not even getting through a failure to find a sector correctly yet.
2017-08-06 23:48:17 +00:00
Reaching the end of the usable part of my day, decided to tidy up a little before bed with indentation that reflects a distinction between top-level entry points and mere loops.
2017-08-07 02:14:18 +00:00
WAIT_FOR_EVENT(Event8272::ResultEmpty);
main_status_ &= ~StatusDIO;
goto wait_for_command;
Added storage for the extended four status registers, and made an attempt at implementing the two most trivial result-phase commands. Am slightly paused momentarily trying to figure out whether seek activity is orthogonal to read/write activity.
2017-08-06 16:55:57 +00:00
Started on a real ugly-implementation coroutine approach, and implemented specify as a fairly trivial first command: it has no result phase, and is the only thing called by AMSDOS as part of the initialisation sequence.
2017-08-06 16:36:18 +00:00
END_SECTION()
Switched disk controllers to be instantiated explicitly in terms of cycles, created an Amstrad-specific subclass of the 8272 to record the direct programmatic availability of all disk motors bundled together, and otherwise adjusted to ensure the thing is clocked and that the motor is enabled and disabled appropriately. The 8272 is also now formally a subclass of the incoming MDM controller.
2017-08-06 13:45:16 +00:00
}
Reference in New Issue Copy Permalink