2016-07-15 10:51:11 +00:00
|
|
|
//
|
2016-09-26 00:05:56 +00:00
|
|
|
// DiskController.hpp
|
2016-07-15 10:51:11 +00:00
|
|
|
// Clock Signal
|
|
|
|
//
|
|
|
|
// Created by Thomas Harte on 14/07/2016.
|
|
|
|
// Copyright © 2016 Thomas Harte. All rights reserved.
|
|
|
|
//
|
|
|
|
|
2016-09-26 00:05:56 +00:00
|
|
|
#ifndef Storage_Disk_Controller_hpp
|
|
|
|
#define Storage_Disk_Controller_hpp
|
2016-07-15 10:51:11 +00:00
|
|
|
|
2016-09-26 01:24:16 +00:00
|
|
|
#include "Drive.hpp"
|
2016-07-15 12:28:34 +00:00
|
|
|
#include "DigitalPhaseLockedLoop.hpp"
|
2016-12-24 18:07:23 +00:00
|
|
|
#include "PCMSegment.hpp"
|
2016-12-25 03:51:26 +00:00
|
|
|
#include "PCMPatchedTrack.hpp"
|
2017-08-20 15:54:54 +00:00
|
|
|
|
2017-08-06 13:45:16 +00:00
|
|
|
#include "../../ClockReceiver/ClockReceiver.hpp"
|
2017-08-20 15:54:54 +00:00
|
|
|
#include "../../ClockReceiver/Sleeper.hpp"
|
2016-07-15 10:51:11 +00:00
|
|
|
|
|
|
|
namespace Storage {
|
2016-08-27 21:15:09 +00:00
|
|
|
namespace Disk {
|
2016-07-15 10:51:11 +00:00
|
|
|
|
2016-08-01 10:04:55 +00:00
|
|
|
/*!
|
2016-09-26 01:24:16 +00:00
|
|
|
Provides the shell for emulating a disk controller — something that is connected to a disk drive and uses a
|
|
|
|
phase locked loop ('PLL') to decode a bit stream from the surface of the disk.
|
2016-08-01 10:04:55 +00:00
|
|
|
|
|
|
|
Partly abstract; it is expected that subclasses will provide methods to deal with receiving a newly-recognised
|
|
|
|
bit from the PLL and with crossing the index hole.
|
|
|
|
|
2016-09-26 01:24:16 +00:00
|
|
|
TODO: communication of head size and permissible stepping extents, appropriate simulation of gain.
|
2016-08-01 10:04:55 +00:00
|
|
|
*/
|
2017-09-10 23:23:23 +00:00
|
|
|
class Controller: public DigitalPhaseLockedLoop::Delegate, public Drive::EventDelegate, public Sleeper, public Sleeper::SleepObserver {
|
2016-09-26 01:24:16 +00:00
|
|
|
protected:
|
2016-08-01 10:04:55 +00:00
|
|
|
/*!
|
2017-09-11 02:56:05 +00:00
|
|
|
Constructs a @c Controller that will be run at @c clock_rate.
|
2016-08-01 10:04:55 +00:00
|
|
|
*/
|
2017-09-11 02:56:05 +00:00
|
|
|
Controller(Cycles clock_rate);
|
2016-07-15 12:28:34 +00:00
|
|
|
|
2016-08-01 10:04:55 +00:00
|
|
|
/*!
|
2016-09-19 02:03:06 +00:00
|
|
|
Communicates to the PLL the expected length of a bit as a fraction of a second.
|
2016-08-01 10:04:55 +00:00
|
|
|
*/
|
2016-07-15 12:28:34 +00:00
|
|
|
void set_expected_bit_length(Time bit_length);
|
2016-07-15 10:51:11 +00:00
|
|
|
|
2016-08-01 10:04:55 +00:00
|
|
|
/*!
|
|
|
|
Advances the drive by @c number_of_cycles cycles.
|
|
|
|
*/
|
2017-07-28 02:05:29 +00:00
|
|
|
void run_for(const Cycles cycles);
|
2016-07-15 10:51:11 +00:00
|
|
|
|
2016-08-01 10:04:55 +00:00
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Sets the current drive. This drive is the one the PLL listens to.
|
2016-08-01 10:04:55 +00:00
|
|
|
*/
|
2016-09-26 01:24:16 +00:00
|
|
|
void set_drive(std::shared_ptr<Drive> drive);
|
2016-12-26 02:06:58 +00:00
|
|
|
|
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Should be implemented by subclasses; communicates each bit that the PLL recognises.
|
2016-12-26 02:06:58 +00:00
|
|
|
*/
|
2017-09-10 23:23:23 +00:00
|
|
|
virtual void process_input_bit(int value) = 0;
|
2016-08-01 10:04:55 +00:00
|
|
|
|
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Should be implemented by subclasses; communicates that the index hole has been reached.
|
2016-08-01 10:04:55 +00:00
|
|
|
*/
|
2017-09-10 23:23:23 +00:00
|
|
|
virtual void process_index_hole() = 0;
|
2016-07-15 10:51:11 +00:00
|
|
|
|
2016-12-01 03:26:02 +00:00
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Should be implemented by subclasses if they implement writing; communicates that
|
|
|
|
all bits supplied to write_bit have now been written.
|
2016-12-01 03:26:02 +00:00
|
|
|
*/
|
2017-09-10 23:23:23 +00:00
|
|
|
virtual void process_write_completed();
|
2016-12-01 03:26:02 +00:00
|
|
|
|
2016-12-08 03:19:20 +00:00
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Puts the drive returned by get_drive() into write mode, supplying the current bit length.
|
2017-08-15 20:05:10 +00:00
|
|
|
|
|
|
|
@param clamp_to_index_hole If @c true then writing will automatically be truncated by
|
|
|
|
the index hole. Writing will continue over the index hole otherwise.
|
2016-12-08 03:19:20 +00:00
|
|
|
*/
|
2017-08-15 20:05:10 +00:00
|
|
|
void begin_writing(bool clamp_to_index_hole);
|
2016-12-08 03:19:20 +00:00
|
|
|
|
|
|
|
/*!
|
2017-09-10 23:23:23 +00:00
|
|
|
Returns the connected drive or, if none is connected, an invented one. No guarantees are
|
|
|
|
made about the lifetime or the exclusivity of the invented drive.
|
2016-12-25 17:31:38 +00:00
|
|
|
*/
|
2017-09-10 23:23:23 +00:00
|
|
|
Drive &get_drive();
|
2016-09-26 01:24:16 +00:00
|
|
|
|
2017-08-20 15:54:54 +00:00
|
|
|
bool is_sleeping();
|
|
|
|
|
2016-07-15 12:28:34 +00:00
|
|
|
private:
|
2016-12-03 16:59:28 +00:00
|
|
|
Time bit_length_;
|
2017-07-25 01:04:47 +00:00
|
|
|
int clock_rate_multiplier_;
|
2017-09-11 02:56:05 +00:00
|
|
|
int clock_rate_;
|
2016-07-29 09:19:01 +00:00
|
|
|
|
2016-12-03 16:59:28 +00:00
|
|
|
std::shared_ptr<DigitalPhaseLockedLoop> pll_;
|
|
|
|
std::shared_ptr<Drive> drive_;
|
2016-09-26 01:24:16 +00:00
|
|
|
|
2017-09-10 23:23:23 +00:00
|
|
|
std::shared_ptr<Drive> empty_drive_;
|
2016-12-24 18:07:23 +00:00
|
|
|
|
2017-09-10 23:23:23 +00:00
|
|
|
void set_component_is_sleeping(void *component, bool is_sleeping);
|
2016-12-25 17:31:38 +00:00
|
|
|
|
2017-09-10 23:23:23 +00:00
|
|
|
// for Drive::EventDelegate
|
|
|
|
void process_event(const Track::Event &event);
|
|
|
|
void advance(const Cycles cycles);
|
2017-08-20 15:54:54 +00:00
|
|
|
|
2017-09-10 23:23:23 +00:00
|
|
|
// to satisfy DigitalPhaseLockedLoop::Delegate
|
|
|
|
void digital_phase_locked_loop_output_bit(int value);
|
2016-07-15 10:51:11 +00:00
|
|
|
};
|
|
|
|
|
2016-08-27 21:15:09 +00:00
|
|
|
}
|
2016-07-15 10:51:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* DiskDrive_hpp */
|