import qemu

class syborg_pointer(qemu.devclass):

  REG_ID           = 0

  REG_LATCH        = 1

  REG_FIFO_COUNT   = 2

  REG_X            = 3

  REG_Y            = 4

  REG_Z            = 5

  REG_BUTTONS      = 6

  REG_INT_ENABLE   = 7

  REG_FIFO_SIZE    = 8

  class fifo_entry:

    def __init__(self, x, y, z, buttons):

      self.x = x

      self.y = y

      self.z = z

      self.buttons = buttons

  def update_irq(self):

    self.set_irq_level(0, (len(self.fifo) > 0) and self.int_enabled)

  def event(self, x, y, z, buttons):

    if len(self.fifo) < self.fifo_size:

      self.fifo.append(self.fifo_entry(x, y, z, buttons))

    self.update_irq()

  def create(self):

    self.absolute = self.properties["absolute"]

    self.fifo_size = self.properties["fifo-size"]

    self.fifo=[]

    self.current = self.fifo_entry(0, 0, 0, 0)

    self.int_enabled = False

    qemu.register_mouse(self.event, self.absolute)

  def read_reg(self, offset):

    offset >>= 2

    if offset == self.REG_ID:

      return 0xc51d0006 if self.absolute else 0xc51d0005

    elif offset == self.REG_FIFO_COUNT:

      return len(self.fifo)

    elif offset == self.REG_X:

      return self.current.x

    elif offset == self.REG_Y:

      return self.current.y

    elif offset == self.REG_Z:

      return self.current.z

    elif offset == self.REG_BUTTONS:

      return self.current.buttons

    elif offset == self.REG_INT_ENABLE:

      return self.int_enabled

    elif offset == self.REG_FIFO_SIZE:

      return self.fifo_size

    return 0

  def write_reg(self, offset, value):

    offset >>= 2

    if offset == self.REG_LATCH:

      if len(self.fifo) == 0:

        return

      self.current = self.fifo.pop(0)

      self.update_irq()

    elif offset == self.REG_INT_ENABLE:

      self.int_enabled = ((value & 1) != 0)

      self.update_irq()

  def save(self, f):

    f.put_u32(self.fifo_size)

    f.put_u32(self.int_enabled)

    f.put_u32(len(self.fifo) + 1)

    for d in [self.current] + self.fifo:

      f.put_u32(d.x)

      f.put_u32(d.y)

      f.put_u32(d.z)

      f.put_u32(d.buttons)

  def load(self, f):

    if self.fifo_size != f.get_u32():

      raise ValueError, "fifo size mismatch"

    self.int_enabled = f.get_u32()

    n = f.get_u32()

    self.fifo = []

    while n > 0:

      x = f.get_u32()

      y = f.get_u32()

      z = f.get_u32()

      buttons = f.get_u32()

      self.fifo.append(self.fifo_entry(x, y, z, buttons))

      n -= 1;

    self.current = self.fifo.pop(0);

  # Device class properties

  regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]

  irqs = 1

  name = "syborg,pointer"

  properties = {"fifo-size":16, "absolute":1}

qemu.register_device(syborg_pointer)