pl011.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <optional>
 
#include "mmio_accessor.hpp"
 
namespace pl011 {
 
class Pl011 {
 public:
  auto PutChar(uint8_t c) const -> void {
    while (mmio_.Read<uint32_t>(kRegFR) & kFRTxFIFO) {
    }
    mmio_.Write<uint32_t>(kRegDR, c);
  }
 
  [[nodiscard]] auto GetChar() const -> uint8_t {
    while (mmio_.Read<uint32_t>(kRegFR) & kFRRXFE) {
    }
    return static_cast<uint8_t>(mmio_.Read<uint32_t>(kRegDR));
  }
 
  [[nodiscard]] auto TryGetChar() const -> std::optional<uint8_t> {
    if (mmio_.Read<uint32_t>(kRegFR) & kFRRXFE) {
      return std::nullopt;
    }
    return static_cast<uint8_t>(mmio_.Read<uint32_t>(kRegDR));
  }
 
  [[nodiscard]] auto HasData() const -> bool {
    return !(mmio_.Read<uint32_t>(kRegFR) & kFRRXFE);
  }
 
  [[nodiscard]] auto GetMaskedInterruptStatus() const -> uint32_t {
    return mmio_.Read<uint32_t>(kRegMIS);
  }
 
  [[nodiscard]] auto GetRawInterruptStatus() const -> uint32_t {
    return mmio_.Read<uint32_t>(kRegRIS);
  }
 
  auto ClearInterrupt(uint32_t mask) const -> void {
    mmio_.Write<uint32_t>(kRegICR, mask);
  }
 
  [[nodiscard]] auto IsInterruptPending() const -> bool {
    return GetMaskedInterruptStatus() != 0;
  }
 
  template <typename Callback>
  auto HandleInterrupt(Callback&& callback) -> void {
    while (HasData()) {
      callback(GetChar());
    }
  }
 
 
  explicit Pl011(uint64_t dev_addr, uint64_t clock = 0, uint64_t baud_rate = 0)
      : mmio_(dev_addr), base_clock_(clock), baud_rate_(baud_rate) {
    mmio_.Write<uint32_t>(kRegRSRECR, 0);
    mmio_.Write<uint32_t>(kRegCR, 0);
 
    if (baud_rate_ != 0) {
      uint32_t divisor = (base_clock_ * 4) / baud_rate_;
      mmio_.Write<uint32_t>(kRegIBRD, divisor >> 6);
      mmio_.Write<uint32_t>(kRegFBRD, divisor & 0x3f);
    }
 
    mmio_.Write<uint32_t>(kRegLCRH, kLCRHWlen8);
    mmio_.Write<uint32_t>(kRegIMSC, kIMSCRxim);
    mmio_.Write<uint32_t>(kRegCR, kCREnable | kCRTxEnable | kCRRxEnable);
  }
  Pl011() = default;
  Pl011(const Pl011&) = delete;
  Pl011(Pl011&&) = default;
  auto operator=(const Pl011&) -> Pl011& = delete;
  auto operator=(Pl011&&) -> Pl011& = default;
  ~Pl011() = default;
 
 private:
  static constexpr uint32_t kRegDR = 0x00;
  static constexpr uint32_t kRegRSRECR = 0x04;
  static constexpr uint32_t kRegFR = 0x18;
  static constexpr uint32_t kRegIBRD = 0x24;
  static constexpr uint32_t kRegFBRD = 0x28;
  static constexpr uint32_t kRegLCRH = 0x2C;
  static constexpr uint32_t kRegCR = 0x30;
  static constexpr uint32_t kRegIMSC = 0x38;
  static constexpr uint32_t kRegRIS = 0x3C;
  static constexpr uint32_t kRegMIS = 0x40;
  static constexpr uint32_t kRegICR = 0x44;
 
  static constexpr uint32_t kFRTxFIFO = (1 << 5);
  static constexpr uint32_t kFRRXFE = (1 << 4);
 
  static constexpr uint32_t kLCRHWlen8 = (3 << 5);
 
  static constexpr uint32_t kCREnable = (1 << 0);
  static constexpr uint32_t kCRTxEnable = (1 << 8);
  static constexpr uint32_t kCRRxEnable = (1 << 9);
 
  static constexpr uint32_t kIMSCRxim = (1 << 4);
 
  MmioAccessor mmio_{};
  uint64_t base_clock_{0};
  uint64_t baud_rate_{0};
};
 
}  // namespace pl011