/**
 * Copyright (c) 2011-2025 Bill Greiman
 * This file is part of the SdFat library for SD memory cards.
 *
 * MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
#pragma once
/**
 * \file
 * \brief Driver to test with no Arduino includes.
 */

#include <avr/interrupt.h>

#include "../../../common/SysCall.h"
#define nop asm volatile("nop\n\t")
#ifndef HIGH
#define HIGH 1
#endif  // HIGH
#ifndef LOW
#define LOW 0
#endif  // LOW
#ifndef INPUT
#define INPUT 0
#endif  // INPUT
#ifndef OUTPUT
#define OUTPUT 1
#endif  // OUTPUT

inline uint8_t unoBit(uint8_t pin) {
  return 1 << (pin < 8 ? pin : pin < 14 ? pin - 8 : pin - 14);
}
inline uint8_t unoDigitalRead(uint8_t pin) {
  volatile uint8_t* reg = pin < 8 ? &PIND : pin < 14 ? &PINB : &PINC;
  return *reg & unoBit(pin);
}
inline void unoDigitalWrite(uint8_t pin, uint8_t value) {
  volatile uint8_t* port = pin < 8 ? &PORTD : pin < 14 ? &PORTB : &PORTC;
  uint8_t bit = unoBit(pin);
  cli();
  if (value) {
    *port |= bit;
  } else {
    *port &= ~bit;
  }
  sei();
}

inline void unoPinMode(uint8_t pin, uint8_t mode) {
  uint8_t bit = unoBit(pin);
  volatile uint8_t* reg = pin < 8 ? &DDRD : pin < 14 ? &DDRB : &DDRC;

  cli();
  if (mode == OUTPUT) {
    *reg |= bit;
  } else {
    *reg &= ~bit;
    // handle INPUT pull-up
    unoDigitalWrite(pin, mode != INPUT);
  }
  sei();
}

#define UNO_SS 10
#define UNO_MOSI 11
#define UNO_MISO 12
#define UNO_SCK 13
//------------------------------------------------------------------------------
/**
 * \class SdSpiDriverBareUno
 * \brief Optimized SPI class for access to SD and SDHC flash memory cards.
 */
class SdSpiDriverBareUno {
 public:
  /** Activate SPI hardware. */
  void activate() {}
  /** Initialize the SPI bus.
   *
   * \param[in] spiConfig SD card configuration.
   */
  void begin(SdSpiConfig spiConfig) {
    m_csPin = spiConfig.csPin;
    unoPinMode(m_csPin, OUTPUT);
    unoDigitalWrite(m_csPin, HIGH);
    unoDigitalWrite(UNO_SS, HIGH);
    unoPinMode(UNO_SS, OUTPUT);
    SPCR |= _BV(MSTR);
    SPCR |= _BV(SPE);
    SPSR = 0;
    unoPinMode(UNO_SCK, OUTPUT);
    unoPinMode(UNO_MOSI, OUTPUT);
  }
  /** Deactivate SPI hardware. */
  void deactivate() {}
  /** deactivate SPI driver. */
  void end() {}
  /** Receive a byte.
   *
   * \return The byte.
   */
  uint8_t receive() { return transfer(0XFF); }
  /** Receive multiple bytes.
   *
   * \param[out] buf Buffer to receive the data.
   * \param[in] count Number of bytes to receive.
   *
   * \return Zero for no error or nonzero error code.
   */
  uint8_t receive(uint8_t* buf, size_t count) {
    if (count == 0) {
      return 0;
    }
    uint8_t* pr = buf;
    SPDR = 0XFF;
    while (--count > 0) {
      while (!(SPSR & _BV(SPIF))) {
      }
      uint8_t in = SPDR;
      SPDR = 0XFF;
      *pr++ = in;
      // nops to optimize loop for 16MHz CPU 8 MHz SPI
      nop;
      nop;
    }
    while (!(SPSR & _BV(SPIF))) {
    }
    *pr = SPDR;
    return 0;
  }
  /** Send a byte.
   *
   * \param[in] data Byte to send
   */
  void send(uint8_t data) { transfer(data); }
  /** Send multiple bytes.
   *
   * \param[in] buf Buffer for data to be sent.
   * \param[in] count Number of bytes to send.
   */
  void send(const uint8_t* buf, size_t count) {
    if (count == 0) {
      return;
    }
    SPDR = *buf++;
    while (--count > 0) {
      uint8_t b = *buf++;
      while (!(SPSR & (1 << SPIF))) {
      }
      SPDR = b;
      // nops to optimize loop for 16MHz CPU 8 MHz SPI
      nop;
      nop;
    }
    while (!(SPSR & (1 << SPIF))) {
    }
  }
  /** Set CS low. */
  void select() { unoDigitalWrite(m_csPin, LOW); }
  /** Save high speed SPISettings after SD initialization.
   *
   * \param[in] spiConfig SPI options.
   */
  void setSckSpeed(uint32_t maxSck) {
    (void)maxSck;
    SPSR |= 1 << SPI2X;
  }
  static uint8_t transfer(uint8_t data) {
    SPDR = data;
    while (!(SPSR & _BV(SPIF))) {
    }  // wait
    return SPDR;
  }
  /** Set CS high. */
  void unselect() { unoDigitalWrite(m_csPin, HIGH); }

 private:
  SdCsPin_t m_csPin;
};
