import qemu

import os

class syborg_usbtest(qemu.devclass):

  REG_ID           = 0

  REG_INT_ENABLE   = 1

  REG_DATA_TYPE    = 2

  REG_DMA_ADDR     = 3

  REG_DMA_SIZE     = 4

  def loadIMG(self):

    self.buf = open('test1.BMP','rb').read()

    self.bufC = open('test.BMP','rb').read()

    self.bmpsize = os.path.getsize('test1.BMP')

    self.Csize = os.path.getsize('test.BMP')

  def timertick(self):

    if self.cha==0:

        compSize=self.bmpsize

        buf=self.buf

        self.cha=1

    else:

        compSize=self.Csize

        buf=self.bufC

        self.cha=0

    if self.dma_size < compSize:

        self.dma_size = 0

    else:

        for x in buf:

	    ch = ord(x)

	    if self.dma_size > 0:

            	self.dma_writeb(self.dma_addr, ch)

            	self.dma_addr += 1

		self.dma_size -= 1

    self.set_irq_level(0, self.int_enable)

  def timer_on(self):

    self.ptimer = qemu.ptimer(self.timertick, 1)

    self.ptimer.run(0)

  def timer_off(self):

    self.ptimer.stop()

    self.set_irq_level(0, self.int_enable)

  def capturedata(self):

    if self.dma_size < self.Csize:

        self.dma_size = 0

    else:

        for x in self.bufC:

	    ch = ord(x)

	    if self.dma_size > 0:

            	self.dma_writeb(self.dma_addr, ch)

            	self.dma_addr += 1

		self.dma_size -= 1

    self.set_irq_level(0, self.int_enable)

  def create(self):

    self.int_enable = 1

    self.dma_addr = 0

    self.dma_size =0

    self.cha=0

    self.loadIMG()

  def write_reg(self, offset, value):

    offset >>= 2

    if offset==self.REG_INT_ENABLE:

        self.int_enable=value

        if value==1:

	    if self.data_type==0:

                self.timer_on()

            elif self.data_type==1:

                self.capturedata()

        else:

	    if self.data_type==0:

           	self.timer_off()

            elif self.data_type==1:

	        self.set_irq_level(0, self.int_enable)

    elif offset == self.REG_DATA_TYPE:

      self.data_type = value

    elif offset == self.REG_DMA_ADDR:

      self.dma_addr = value

    elif offset == self.REG_DMA_SIZE:

      self.dma_size = value

  def read_reg(self, offset):

    offset >>= 2

    if offset == self.REG_ID:

      return 0xc600f000

    elif offset == self.REG_INT_ENABLE:

      return self.int_enable

    elif offset == self.REG_DMA_ADDR:

      return self.dma_addr

    elif offset == self.REG_DMA_SIZE:

      return self.dma_size

    return 0

  def save(self, f):

    f.put_u32(self.int_enable)

    f.put_u32(self.dma_addr)

    f.put_u32(self.dma_size)

  def load(self, f):

    self.int_enable = f.get_u32()

    self.dma_addr = f.get_u32()

    self.dma_size = f.get_u32()

  # Device class properties

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

  irqs = 1

  name = "syborg,usbtest"

  properties={"chardev":None}

qemu.register_device(syborg_usbtest)