Adafruit_Floppy.h

#ifndef ADAFRUIT_FLOPPY_H
#define ADAFRUIT_FLOPPY_H

#include "Arduino.h"
#include <Adafruit_SPIDevice.h>
// to implement SdFat Block Driver
//
#define DISABLE_FS_H_WARNING
#include "SdFat.h"
#include "SdFatConfig.h"

#define FLOPPY_IBMPC_HD_TRACKS 80
#define FLOPPY_IBMPC_DD_TRACKS 40
#define FLOPPY_HEADS 2

#define MFM_IBMPC1200K_SECTORS_PER_TRACK 15
#define MFM_IBMPC1440K_SECTORS_PER_TRACK 18
#define MFM_IBMPC360K_SECTORS_PER_TRACK 9
#define MFM_IBMPC720K_SECTORS_PER_TRACK 9
#define MFM_BYTES_PER_SECTOR 512UL

#define STEP_OUT HIGH
#define STEP_IN LOW
#define MAX_FLUX_PULSE_PER_TRACK                                               \
  (uint32_t)(500000UL / 5 *                                                    \
             1.5) // 500khz / 5 hz per track rotation, 1.5 rotations

#define BUSTYPE_IBMPC 1
#define BUSTYPE_SHUGART 2

typedef enum {
  IBMPC360K,
  IBMPC720K,
  IBMPC720K_360RPM,
  IBMPC1200K,
  IBMPC1440K,
  IBMPC1440K_360RPM,
  AUTODETECT,
} adafruit_floppy_disk_t;

/**************************************************************************/
/**************************************************************************/
class Adafruit_FloppyBase {
protected:
  Adafruit_FloppyBase(int indexpin, int wrdatapin, int wrgatepin, int rddatapin,
                      bool is_apple2 = false);

public:
  bool begin(void);
  virtual void end();

  virtual void soft_reset(void);

  /**************************************************************************/
  /**************************************************************************/
  virtual void select(bool selected) = 0;
  /**************************************************************************/
  /**************************************************************************/
  bool drive_is_selected(void) { return is_drive_selected; }

  /**************************************************************************/
  /**************************************************************************/
  virtual bool spin_motor(bool motor_on) = 0;
  /**************************************************************************/
  /**************************************************************************/
  bool motor_is_spinning(void) { return is_motor_spinning; }
  /**************************************************************************/
  /**************************************************************************/
  bool index_pulses_seen(void) { return is_index_seen; }
  /**************************************************************************/
  /**************************************************************************/
  virtual bool goto_track(int track_num) = 0;
  /**************************************************************************/
  /**************************************************************************/
  virtual bool side(int head) = 0;
  /**************************************************************************/
  /**************************************************************************/
  virtual int get_side() = 0;
  /**************************************************************************/
  /**************************************************************************/
  virtual int track(void) = 0;
  /**************************************************************************/
  /**************************************************************************/
  virtual bool get_write_protect() = 0;

  /**************************************************************************/
  /**************************************************************************/
  virtual bool get_track0_sense() = 0;

  /**************************************************************************/
  /**************************************************************************/
  virtual bool get_ready_sense() = 0;

  /**************************************************************************/
  /**************************************************************************/
  virtual bool set_density(bool high_density) = 0;

  size_t decode_track_mfm(uint8_t *sectors, size_t n_sectors,
                          uint8_t *sector_validity, const uint8_t *pulses,
                          size_t n_pulses, float nominal_bit_time_us,
                          bool clear_validity = false,
                          uint8_t *logical_track = nullptr);

  size_t encode_track_mfm(const uint8_t *sectors, size_t n_sectors,
                          uint8_t *pulses, size_t max_pulses,
                          float nominal_bit_time_us, uint8_t logical_track);

  size_t capture_track(volatile uint8_t *pulses, size_t max_pulses,
                       int32_t *falling_index_offset,
                       bool store_greaseweazle = false, uint32_t capture_ms = 0,
                       uint32_t index_wait_ms = 250)
      __attribute__((optimize("O3")));

  bool write_track(uint8_t *pulses, size_t n_pulses,
                   bool store_greaseweazle = false, bool use_index = true)
      __attribute__((optimize("O3")));
  void print_pulse_bins(uint8_t *pulses, size_t n_pulses, uint8_t max_bins = 64,
                        bool is_gw_format = false, uint32_t min_bin_size = 100);
  void print_pulses(uint8_t *pulses, size_t n_pulses,
                    bool is_gw_format = false);
  uint32_t getSampleFrequency(void);

#if defined(LED_BUILTIN)
  int8_t led_pin = LED_BUILTIN; 
#else
  int8_t led_pin = -1; 
#endif

  uint16_t select_delay_us = 10;  
  uint16_t step_delay_us = 10000; 
  uint16_t settle_delay_ms = 15;  
  uint16_t motor_delay_ms = 1000; 
  uint16_t watchdog_delay_ms =
      1000; 
  uint8_t bus_type = BUSTYPE_IBMPC; 

  Stream *debug_serial = nullptr; 

protected:
  bool read_index();
  bool is_drive_selected; 
  bool is_motor_spinning; 
  bool is_index_seen;     

private:
#if defined(__SAMD51__)
  void deinit_capture(void);
  void enable_capture(void);

  bool init_generate(void);
  void deinit_generate(void);
  void enable_generate(void);
  void disable_generate(void);
#endif

  bool start_polled_capture(void);
  void disable_capture(void);

  bool init_capture(void);
  void enable_background_capture(void);
  void wait_for_index_pulse_low(void);

  int8_t _indexpin, _wrdatapin, _wrgatepin, _rddatapin;
  bool _is_apple2;

#ifdef BUSIO_USE_FAST_PINIO
  BusIO_PortReg *indexPort;
  BusIO_PortMask indexMask;
  uint32_t dummyPort = 0;
#endif
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_Floppy : public Adafruit_FloppyBase {
public:
  Adafruit_Floppy(int8_t densitypin, int8_t indexpin, int8_t selectpin,
                  int8_t motorpin, int8_t directionpin, int8_t steppin,
                  int8_t wrdatapin, int8_t wrgatepin, int8_t track0pin,
                  int8_t protectpin, int8_t rddatapin, int8_t sidepin,
                  int8_t readypin);
  void end() override;
  void soft_reset(void) override;

  void select(bool selected) override;
  bool spin_motor(bool motor_on) override;
  bool goto_track(int track) override;
  bool side(int head) override;
  int track(void) override;
  int get_side(void) override;
  void step(bool dir, uint8_t times);
  bool set_density(bool high_density) override;
  bool get_write_protect() override;
  bool get_track0_sense() override;
  bool get_ready_sense() override;

private:
  // theres a lot of GPIO!
  int8_t _densitypin, _selectpin, _motorpin, _directionpin, _steppin,
      _track0pin, _protectpin, _sidepin, _readypin;

  int _track = -1, _side = -1;
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_Apple2Floppy : public Adafruit_FloppyBase {
public:
  /**************************************************************************/
  /**************************************************************************/
  enum StepMode {
    STEP_MODE_WHOLE,   //< One step moves by one data track
    STEP_MODE_HALF,    //< Two steps move by one data track
    STEP_MODE_QUARTER, //< Four steps move by one data track
  };

  Adafruit_Apple2Floppy(int8_t indexpin, int8_t selectpin, int8_t phase1pin,
                        int8_t phase2pin, int8_t phase3pin, int8_t phase4pin,
                        int8_t wrdatapin, int8_t wrgatepin, int8_t protectpin,
                        int8_t rddatapin);
  void end() override;
  void soft_reset(void) override;

  void select(bool selected) override;
  bool spin_motor(bool motor_on) override;
  bool goto_track(int track) override;
  bool side(int head) override;
  int track(void) override;
  bool set_density(bool high_density) override;
  bool get_write_protect() override;
  bool get_track0_sense() override;
  bool get_ready_sense() override { return true; }

  int quartertrack();
  bool goto_quartertrack(int);
  void step_mode(StepMode mode);

  int get_side() override { return 0; }

private:
  int _step_multiplier() const;
  // theres not much GPIO!
  int8_t _selectpin, _phase1pin, _phase2pin, _phase3pin, _phase4pin,
      _protectpin;
  int _quartertrack = -1;
  StepMode _step_mode = STEP_MODE_HALF;
  void _step(int dir, int times);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_MFM_Floppy : public FsBlockDeviceInterface {
public:
  Adafruit_MFM_Floppy(Adafruit_Floppy *floppy,
                      adafruit_floppy_disk_t format = AUTODETECT);

  bool begin(void);
  void end(void);

  uint32_t size(void) const;
  int32_t readTrack(int track, bool head);

  uint8_t sectors_per_track(void) const { return _sectors_per_track; }
  uint8_t tracks_per_side(void) const { return _tracks_per_side; }

  bool dirty() const { return _dirty; }

  void removed();
  bool inserted(adafruit_floppy_disk_t format);

  //------------- SdFat v2 FsBlockDeviceInterface API -------------//
  virtual bool isBusy();
  virtual uint32_t sectorCount();
  virtual bool syncDevice();

  virtual bool readSector(uint32_t block, uint8_t *dst);
  virtual bool readSectors(uint32_t block, uint8_t *dst, size_t ns);
  virtual bool writeSector(uint32_t block, const uint8_t *src);
  virtual bool writeSectors(uint32_t block, const uint8_t *src, size_t ns);

  uint8_t track_data[MFM_IBMPC1440K_SECTORS_PER_TRACK * MFM_BYTES_PER_SECTOR];

  uint8_t track_validity[MFM_IBMPC1440K_SECTORS_PER_TRACK];

private:
  bool autodetect();
#if defined(PICO_BOARD) || defined(__RP2040__) || defined(ARDUINO_ARCH_RP2040)
  uint16_t _last;
#endif
  static constexpr uint8_t NO_TRACK = UINT8_MAX;
  uint8_t _sectors_per_track = 0;
  uint8_t _tracks_per_side = 0;
  uint8_t _last_track_read = NO_TRACK; // last cached track
  uint16_t _bit_time_ns;
  bool _high_density = true;
  bool _dirty = false, _track_has_errors = false;
  bool _double_step = false;
  Adafruit_Floppy *_floppy = nullptr;
  adafruit_floppy_disk_t _format = AUTODETECT;

  uint8_t _flux[125000];
  size_t _n_flux;
};

#endif