import qemu

class syborg_timer(qemu.devclass):
  REG_ID            = 0
  REG_RUNNING       = 1
  REG_ONESHOT       = 2
  REG_LIMIT         = 3
  REG_VALUE         = 4
  REG_INT_ENABLE    = 5
  REG_INT_STATUS    = 6
  REG_FREQ          = 7

  def update(self):
    self.set_irq_level(0, (self.int_status & self.int_enable) != 0)

  def timer_tick(self):
    self.int_status |= 1
    if (self.oneshot):
      self.running = False
    self.update()

  def create(self):
    self.freq = self.properties["frequency"]
    if self.freq == 0:
      raise ValueError, "Zero/unset frequency"
    self.timer = qemu.ptimer(self.timer_tick, self.freq)
    self.running = False
    self.oneshot = False
    self.int_status = 0
    self.int_enable = 0
    self.limit = 0

  def read_reg(self, offset):
    offset >>= 2
    if offset == self.REG_ID:
      return 0xc51d0003
    elif offset == self.REG_RUNNING:
      return 1 if self.running else 0
    elif offset == self.REG_ONESHOT:
      return 1 if self.oneshot else 0
    elif offset == self.REG_LIMIT:
      return self.limit
    elif offset == self.REG_VALUE:
      return self.timer.count
    elif offset == self.REG_INT_ENABLE:
      return self.int_enable
    elif offset == self.REG_INT_STATUS:
      return self.int_status
    elif offset == self.REG_FREQ:
      return self.freq
    return 0

  def write_reg(self, offset, value):
    offset >>= 2
    if offset == self.REG_RUNNING:
      if self.running != (value != 0):
        self.running = (value != 0)
        if self.running:
          self.timer.run(self.oneshot)
        else:
          self.timer.stop()
    elif offset == self.REG_ONESHOT:
      if self.running:
        self.timer.stop()
      self.oneshot = (value != 0)
      if self.running:
        self.timer.run(self.oneshot);
    elif offset == self.REG_LIMIT:
      self.limit = value
      self.timer.set_limit(value, True)
    elif offset == self.REG_VALUE:
      self.timer.count = value
    elif offset == self.REG_INT_ENABLE:
      self.int_enable = value & 1
      self.update()
    elif offset == self.REG_INT_STATUS:
      self.int_status &= ~value
      self.update()

  def save(self, f):
    f.put_u32(self.running)
    f.put_u32(self.oneshot)
    f.put_u32(self.limit)
    f.put_u32(self.int_status)
    f.put_u32(self.int_enable)
    self.timer.put(f)

  def load(self, f):
    self.running = (f.get_u32() != 0)
    self.oneshot = (f.get_u32() != 0)
    self.limit = f.get_u32()
    self.int_status = f.get_u32()
    self.int_enable = f.get_u32()
    self.timer.get(f)

  # Device class properties
  regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]
  irqs = 1
  name = "syborg,timer"
  properties = {"frequency":0}

qemu.register_device(syborg_timer)