mirror of
https://github.com/TomHarte/CLK.git
synced 2026-04-22 08:16:42 +00:00
Recasts the [M]FM parser in terms of the new factoring.
Temporarily breaks SSD writing support.
This commit is contained in:
Thomas Harte
@@ -9,218 +9,50 @@
|
||||
#include "Parser.hpp"
|
||||
|
||||
#include "Constants.hpp"
|
||||
#include "../../DiskImage/DiskImage.hpp"
|
||||
#include "../../SingleTrackDisk/SingleTrackDisk.hpp"
|
||||
#include "../../Track/TrackSerialiser.hpp"
|
||||
#include "SegmentParser.hpp"
|
||||
|
||||
using namespace Storage::Encodings::MFM;
|
||||
|
||||
Parser::Parser(bool is_mfm) :
|
||||
Storage::Disk::Controller(4000000),
|
||||
crc_generator_(0x1021, 0xffff),
|
||||
shift_register_(0), is_mfm_(is_mfm),
|
||||
track_(0), head_(0) {
|
||||
Storage::Time bit_length;
|
||||
bit_length.length = 1;
|
||||
bit_length.clock_rate = is_mfm ? 500000 : 250000; // i.e. 250 kbps (including clocks)
|
||||
set_expected_bit_length(bit_length);
|
||||
|
||||
drive_.reset(new Storage::Disk::Drive(4000000, 300, 2));
|
||||
set_drive(drive_);
|
||||
drive_->set_motor_on(true);
|
||||
}
|
||||
|
||||
Parser::Parser(bool is_mfm, const std::shared_ptr<Storage::Disk::Disk> &disk) :
|
||||
Parser(is_mfm) {
|
||||
drive_->set_disk(disk);
|
||||
}
|
||||
is_mfm_(is_mfm), disk_(disk) {}
|
||||
|
||||
Parser::Parser(bool is_mfm, const std::shared_ptr<Storage::Disk::Track> &track) :
|
||||
Parser(is_mfm) {
|
||||
drive_->set_disk(std::make_shared<Disk::DiskImageHolder<Disk::SingleTrackDiskImage>>(track));
|
||||
}
|
||||
|
||||
void Parser::seek_to_track(uint8_t track) {
|
||||
int difference = (int)track - (int)track_;
|
||||
track_ = track;
|
||||
|
||||
if(difference) {
|
||||
int direction = difference < 0 ? -1 : 1;
|
||||
difference *= direction;
|
||||
|
||||
for(int c = 0; c < difference; c++) drive_->step(direction);
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<Sector> Parser::get_sector(uint8_t head, uint8_t track, uint8_t sector) {
|
||||
// Switch head and track if necessary.
|
||||
if(head_ != head) {
|
||||
drive_->set_head(head);
|
||||
}
|
||||
seek_to_track(track);
|
||||
int track_index = get_index(head, track, 0);
|
||||
|
||||
// Populate the sector cache if it's not already populated by asking for sectors unless and until
|
||||
// one is returned that has already been seen.
|
||||
if(decoded_tracks_.find(track_index) == decoded_tracks_.end()) {
|
||||
std::shared_ptr<Sector> first_sector = get_next_sector();
|
||||
std::set<uint8_t> visited_sectors;
|
||||
if(first_sector) {
|
||||
while(1) {
|
||||
std::shared_ptr<Sector> next_sector = get_next_sector();
|
||||
if(next_sector) {
|
||||
if(visited_sectors.find(next_sector->address.sector) != visited_sectors.end()) {
|
||||
break;
|
||||
}
|
||||
visited_sectors.insert(next_sector->address.sector);
|
||||
}
|
||||
}
|
||||
}
|
||||
decoded_tracks_.insert(track_index);
|
||||
void Parser::install_sectors_from_track(const Storage::Disk::Track::Address &address) {
|
||||
if(sectors_by_address_by_track_.find(address) != sectors_by_address_by_track_.end()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check cache for sector.
|
||||
int index = get_index(head, track, sector);
|
||||
auto cached_sector = sectors_by_index_.find(index);
|
||||
if(cached_sector != sectors_by_index_.end()) {
|
||||
return cached_sector->second;
|
||||
std::shared_ptr<Storage::Disk::Track> track = disk_->get_track_at_position((unsigned int)address.head, (unsigned int)address.position);
|
||||
if(!track) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If it wasn't found, it doesn't exist.
|
||||
return nullptr;
|
||||
std::map<size_t, Sector> sectors = sectors_from_segment(
|
||||
Storage::Disk::track_serialisation(*track, is_mfm_ ? MFMBitLength : FMBitLength),
|
||||
is_mfm_);
|
||||
|
||||
std::map<int, Storage::Encodings::MFM::Sector> sectors_by_id;
|
||||
for(auto §or : sectors) {
|
||||
sectors_by_id.insert(std::make_pair(sector.second.address.sector, std::move(sector.second)));
|
||||
}
|
||||
sectors_by_address_by_track_.insert(std::make_pair(address, std::move(sectors_by_id)));
|
||||
}
|
||||
|
||||
void Parser::process_input_bit(int value) {
|
||||
shift_register_ = ((shift_register_ << 1) | (unsigned int)value) & 0xffff;
|
||||
bit_count_++;
|
||||
}
|
||||
Sector *Parser::get_sector(int head, int track, uint8_t sector) {
|
||||
Disk::Track::Address address;
|
||||
address.position = track;
|
||||
address.head = head;
|
||||
install_sectors_from_track(address);
|
||||
|
||||
void Parser::process_index_hole() {
|
||||
index_count_++;
|
||||
}
|
||||
|
||||
uint8_t Parser::get_byte_for_shift_value(uint16_t value) {
|
||||
return (uint8_t)(
|
||||
((value&0x0001) >> 0) |
|
||||
((value&0x0004) >> 1) |
|
||||
((value&0x0010) >> 2) |
|
||||
((value&0x0040) >> 3) |
|
||||
((value&0x0100) >> 4) |
|
||||
((value&0x0400) >> 5) |
|
||||
((value&0x1000) >> 6) |
|
||||
((value&0x4000) >> 7));
|
||||
}
|
||||
|
||||
uint8_t Parser::get_next_byte() {
|
||||
bit_count_ = 0;
|
||||
// Archetypal MFM is 500,000 bps given that the drive has an RPM of 300. Clock rate was
|
||||
// specified at 4,000,000. So that's an idealised 8 cycles per bit, Jump ahead 14
|
||||
// times that...
|
||||
run_for(Cycles(14 * 8));
|
||||
|
||||
// ... and proceed at half-idealised-bit intervals to get the next bit. Then proceed very gingerly indeed.
|
||||
while(bit_count_ < 15) run_for(Cycles(4));
|
||||
while(bit_count_ < 16) run_for(Cycles(2));
|
||||
|
||||
uint8_t byte = get_byte_for_shift_value((uint16_t)shift_register_);
|
||||
crc_generator_.add(byte);
|
||||
return byte;
|
||||
}
|
||||
|
||||
std::shared_ptr<Sector> Parser::get_next_sector() {
|
||||
std::shared_ptr<Sector> sector(new Sector);
|
||||
index_count_ = 0;
|
||||
|
||||
while(index_count_ < 2) {
|
||||
// look for an ID address mark
|
||||
bool id_found = false;
|
||||
while(!id_found) {
|
||||
run_for(Cycles(1));
|
||||
if(is_mfm_) {
|
||||
while(shift_register_ == MFMSync) {
|
||||
uint8_t mark = get_next_byte();
|
||||
if(mark == IDAddressByte) {
|
||||
crc_generator_.set_value(MFMPostSyncCRCValue);
|
||||
id_found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if(shift_register_ == FMIDAddressMark) {
|
||||
crc_generator_.reset();
|
||||
id_found = true;
|
||||
}
|
||||
}
|
||||
if(index_count_ >= 2) return nullptr;
|
||||
}
|
||||
|
||||
crc_generator_.add(IDAddressByte);
|
||||
sector->address.track = get_next_byte();
|
||||
sector->address.side = get_next_byte();
|
||||
sector->address.sector = get_next_byte();
|
||||
sector->size = get_next_byte();
|
||||
uint16_t header_crc = crc_generator_.get_value();
|
||||
if((header_crc >> 8) != get_next_byte()) sector->has_header_crc_error = true;
|
||||
if((header_crc & 0xff) != get_next_byte()) sector->has_header_crc_error = true;
|
||||
|
||||
// look for data mark
|
||||
bool data_found = false;
|
||||
while(!data_found) {
|
||||
run_for(Cycles(1));
|
||||
if(is_mfm_) {
|
||||
while(shift_register_ == MFMSync) {
|
||||
uint8_t mark = get_next_byte();
|
||||
if(mark == DataAddressByte) {
|
||||
crc_generator_.set_value(MFMPostSyncCRCValue);
|
||||
data_found = true;
|
||||
break;
|
||||
}
|
||||
if(mark == IDAddressByte) return nullptr;
|
||||
}
|
||||
} else {
|
||||
if(shift_register_ == FMDataAddressMark) {
|
||||
crc_generator_.reset();
|
||||
data_found = true;
|
||||
}
|
||||
if(shift_register_ == FMIDAddressMark) return nullptr;
|
||||
}
|
||||
if(index_count_ >= 2) return nullptr;
|
||||
}
|
||||
crc_generator_.add(DataAddressByte);
|
||||
|
||||
size_t data_size = (size_t)(128 << sector->size);
|
||||
sector->data.reserve(data_size);
|
||||
for(size_t c = 0; c < data_size; c++) {
|
||||
sector->data.push_back(get_next_byte());
|
||||
}
|
||||
uint16_t data_crc = crc_generator_.get_value();
|
||||
if((data_crc >> 8) != get_next_byte()) sector->has_data_crc_error = true;
|
||||
if((data_crc & 0xff) != get_next_byte()) sector->has_data_crc_error = true;
|
||||
|
||||
// Put this sector into the cache.
|
||||
int index = get_index(head_, track_, sector->address.sector);
|
||||
sectors_by_index_[index] = sector;
|
||||
|
||||
return sector;
|
||||
auto sectors = sectors_by_address_by_track_.find(address);
|
||||
if(sectors == sectors_by_address_by_track_.end()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::shared_ptr<Sector> Parser::get_sector(uint8_t sector) {
|
||||
std::shared_ptr<Sector> first_sector;
|
||||
index_count_ = 0;
|
||||
while(!first_sector && index_count_ < 2) first_sector = get_next_sector();
|
||||
if(!first_sector) return nullptr;
|
||||
if(first_sector->address.sector == sector) return first_sector;
|
||||
|
||||
while(1) {
|
||||
std::shared_ptr<Sector> next_sector = get_next_sector();
|
||||
if(!next_sector) continue;
|
||||
if(next_sector->address.sector == first_sector->address.sector) return nullptr;
|
||||
if(next_sector->address.sector == sector) return next_sector;
|
||||
auto stored_sector = sectors->second.find(sector);
|
||||
if(stored_sector == sectors->second.end()) {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
int Parser::get_index(uint8_t head, uint8_t track, uint8_t sector) {
|
||||
return head | (track << 8) | (sector << 16);
|
||||
return &stored_sector->second;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user