1 import qemu

     2 import os

     3 

     4 class syborg_usbtest(qemu.devclass):

     5   REG_ID           = 0

     6   REG_INT_ENABLE   = 1

     7   REG_DATA_TYPE    = 2

     8   REG_DMA_ADDR     = 3

     9   REG_DMA_SIZE     = 4

    10 

    11   def loadIMG(self):

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

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

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

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

    16 

    17   def timertick(self):

    18     if self.cha==0:

    19         compSize=self.bmpsize

    20         buf=self.buf

    21         self.cha=1

    22     else:

    23         compSize=self.Csize

    24         buf=self.bufC

    25         self.cha=0

    26     if self.dma_size < compSize:

    27         self.dma_size = 0

    28     else:

    29         for x in buf:

    30 	    ch = ord(x)

    31 	    if self.dma_size > 0:

    32             	self.dma_writeb(self.dma_addr, ch)

    33             	self.dma_addr += 1

    34 		self.dma_size -= 1

    35     self.set_irq_level(0, self.int_enable)

    36 

    37   def timer_on(self):

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

    39     self.ptimer.run(0)

    40 

    41   def timer_off(self):

    42     self.ptimer.stop()

    43     self.set_irq_level(0, self.int_enable)

    44 

    45   def capturedata(self):

    46     if self.dma_size < self.Csize:

    47         self.dma_size = 0

    48     else:

    49         for x in self.bufC:

    50 	    ch = ord(x)

    51 	    if self.dma_size > 0:

    52             	self.dma_writeb(self.dma_addr, ch)

    53             	self.dma_addr += 1

    54 		self.dma_size -= 1

    55     self.set_irq_level(0, self.int_enable)

    56 

    57   def create(self):

    58     self.int_enable = 1

    59     self.dma_addr = 0

    60     self.dma_size =0

    61     self.cha=0

    62     self.loadIMG()

    63 

    64   def write_reg(self, offset, value):

    65     offset >>= 2

    66     if offset==self.REG_INT_ENABLE:

    67         self.int_enable=value

    68         if value==1:

    69 	    if self.data_type==0:

    70                 self.timer_on()

    71             elif self.data_type==1:

    72                 self.capturedata()

    73         else:

    74 	    if self.data_type==0:

    75            	self.timer_off()

    76             elif self.data_type==1:

    77 	        self.set_irq_level(0, self.int_enable)

    78     elif offset == self.REG_DATA_TYPE:

    79       self.data_type = value

    80     elif offset == self.REG_DMA_ADDR:

    81       self.dma_addr = value

    82     elif offset == self.REG_DMA_SIZE:

    83       self.dma_size = value

    84 

    85   def read_reg(self, offset):

    86     offset >>= 2

    87     if offset == self.REG_ID:

    88       return 0xc600f000

    89     elif offset == self.REG_INT_ENABLE:

    90       return self.int_enable

    91     elif offset == self.REG_DMA_ADDR:

    92       return self.dma_addr

    93     elif offset == self.REG_DMA_SIZE:

    94       return self.dma_size

    95     return 0

    96 

    97   def save(self, f):

    98     f.put_u32(self.int_enable)

    99     f.put_u32(self.dma_addr)

   100     f.put_u32(self.dma_size)

   101 

   102   def load(self, f):

   103     self.int_enable = f.get_u32()

   104     self.dma_addr = f.get_u32()

   105     self.dma_size = f.get_u32()

   106 

   107   # Device class properties

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

   109   irqs = 1

   110   name = "syborg,usbtest"

   111   properties={"chardev":None}

   112 

   113 qemu.register_device(syborg_usbtest)