#include <cstdint>
#include <cstring>
#include <cassert>
#include <functional>

#include "omap35x_intc.hh"
#include "util.hh"
#include "mmio.hh"
#include "globals.hh"
#include "drv_omap35x_gpt.hh"

#define TIOCP_CFG 4
#define TISR 6
#define TIER 7
#define TWER 8
#define TCLR 9
#define TCRR 10
#define TLDR 11
#define TPIR 18
#define TNIR 19

class OMAP35x_GPT_impl {
public:
  OMAP35x_GPT_impl(uintptr_t base, int irq) : base_{base}, irq_{irq}, ticks_(0) {
  }

  ~OMAP35x_GPT_impl() {
    global::intc->disable_int(irq_);
  }

  void ticktimer(int_handler_t handler) {
    r_tiocp_cfg() = 0x215; // Clockactiviy = 2, emufree = 0, idlemode = 2 (smartidle), wakeup = ena, autoidle = 1
    r_tldr() = -327;
    r_tcrr() = -327;
    r_tpir() = 320000;
    r_tnir() = -680000;

    handler_ = handler;
    global::intc->register_handler(irq_, std::bind(&OMAP35x_GPT_impl::irqhandler, this), 0);

    r_tclr() = 0x3; // autoreload = 1, start = 1
  
    r_tier() = 0x2; // Overflow int = enable
    r_twer() = 0x2; // Overflow wakeup = enable

    global::intc->enable_int(irq_);
  }

  void ustimer() {
    r_tiocp_cfg() = 0x215; // Clockactiviy = 2, emufree = 0, idlemode = 2 (smartidle), wakeup = ena, autoidle = 1
    
    r_tldr() = 0;
    r_tcrr() = 0;
    r_tclr() = 0x3; // autoreload = 1, start = 1
  }

  uint32_t getTicks() const {
    return ticks_;
  }

  uint32_t getCounter() {
    return r_tcrr();
  }

private:
  void irqhandler() {
    ++ticks_;

    if(handler_)
      handler_();
    
    r_tisr() = 0x2;
  }
  
  uint32_t volatile& r_tidr() {return _reg32(base_.get_virt(), 0x0); }
  uint32_t volatile& r_tiocp_cfg() {return _reg32(base_.get_virt(), 0x10); }
  uint32_t volatile& r_tistat() {return _reg32(base_.get_virt(), 0x14); }
  uint32_t volatile& r_tisr() {return _reg32(base_.get_virt(), 0x18); }
  uint32_t volatile& r_tier() {return _reg32(base_.get_virt(), 0x1c); }
  uint32_t volatile& r_twer() {return _reg32(base_.get_virt(), 0x20); }
  uint32_t volatile& r_tclr() {return _reg32(base_.get_virt(), 0x24); }
  uint32_t volatile& r_tcrr() {return _reg32(base_.get_virt(), 0x28); }
  uint32_t volatile& r_tldr() {return _reg32(base_.get_virt(), 0x2c); }
  uint32_t volatile& r_ttgr() {return _reg32(base_.get_virt(), 0x30); }
  uint32_t volatile& r_twps() {return _reg32(base_.get_virt(), 0x34); }
  uint32_t volatile& r_tmar() {return _reg32(base_.get_virt(), 0x38); }
  uint32_t volatile& r_tcar1() {return _reg32(base_.get_virt(), 0x3c); }
  uint32_t volatile& r_tsicr() {return _reg32(base_.get_virt(), 0x40); }
  uint32_t volatile& r_tcar2() {return _reg32(base_.get_virt(), 0x44); }
  uint32_t volatile& r_tpir() {return _reg32(base_.get_virt(), 0x48); }
  uint32_t volatile& r_tnir() {return _reg32(base_.get_virt(), 0x4c); }
  uint32_t volatile& r_tcvr() {return _reg32(base_.get_virt(), 0x50); }
  uint32_t volatile& r_tocr() {return _reg32(base_.get_virt(), 0x54); }
  uint32_t volatile& r_towr() {return _reg32(base_.get_virt(), 0x58); }

  MMIO_alloc base_;
  int irq_;
  int_handler_t handler_;
  volatile uint32_t ticks_;
};


OMAP35x_GPT::OMAP35x_GPT(uintptr_t base, int irq) : impl_{new OMAP35x_GPT_impl{base, irq}} {
}

OMAP35x_GPT::~OMAP35x_GPT() {
}

void OMAP35x_GPT::ticktimer(int_handler_t handler) {
  impl_->ticktimer(handler);
}

uint32_t OMAP35x_GPT::getTicks() const {
  return impl_->getTicks();
}

void OMAP35x_GPT::ustimer() {
  impl_->ustimer();
}

uint32_t OMAP35x_GPT::getCounter() {
  return impl_->getCounter();
}