1 import qemu |
1 import qemu |
2 import os |
2 import os |
|
3 from ctypes import cdll |
|
4 import ctypes |
|
5 import datetime |
3 |
6 |
4 class syborg_usbtest(qemu.devclass): |
7 class syborg_usbtest(qemu.devclass): |
5 REG_ID = 0 |
8 REG_ID = 0 |
6 REG_INT_ENABLE = 1 |
9 REG_INT_ENABLE = 1 |
7 REG_DATA_TYPE = 2 |
10 REG_DATA_TYPE = 2 |
8 REG_DMA_ADDR = 3 |
11 REG_DMA_ADDR = 3 |
9 REG_DMA_SIZE = 4 |
12 REG_DMA_SIZE = 4 |
|
13 REG_DMA_INFO = 5 |
|
14 REG_DMA_INFOSIZE = 6 |
|
15 REG_DMA_CONNECT = 7 |
|
16 REG_DMA_DISCONNECT = 8 |
10 |
17 |
11 def loadIMG(self): |
18 def loaddll(self): |
12 self.buf = open('test1.BMP','rb').read() |
19 #Load DLL |
13 self.bufC = open('test.BMP','rb').read() |
20 print "start dll load" |
14 self.bmpsize = os.path.getsize('test1.BMP') |
21 self.path = r'.\webcamapi.dll' |
15 self.Csize = os.path.getsize('test.BMP') |
22 self.webcamdll = cdll.LoadLibrary(self.path) |
|
23 print "end dll load" |
16 |
24 |
17 def timertick(self): |
25 def connect(self): |
18 if self.cha==0: |
26 #Connect to USB Camera |
19 compSize=self.bmpsize |
27 print "Connect to USB Camera" |
20 buf=self.buf |
28 if self.infobuffer == 0: |
21 self.cha=1 |
29 self.infobuffer = ctypes.create_string_buffer(self.infosize) |
22 else: |
30 |
23 compSize=self.Csize |
31 self.DevHandle = self.webcamdll.ConnectDevHandle() |
24 buf=self.bufC |
32 self.bufSize = ctypes.c_int() |
25 self.cha=0 |
33 self.PinHandle = self.webcamdll.ConnectPinHandle(self.DevHandle, ctypes.byref(self.bufSize), ctypes.byref(self.infobuffer)) |
26 if self.dma_size < compSize: |
34 |
27 self.dma_size = 0 |
35 infobuf = self.infobuffer |
28 else: |
36 |
29 for x in buf: |
37 for x in infobuf: |
30 ch = ord(x) |
38 ch = ord(x) |
31 if self.dma_size > 0: |
39 if self.infosize > 0: |
32 self.dma_writeb(self.dma_addr, ch) |
40 self.dma_writeb(self.dataformat, ch) |
33 self.dma_addr += 1 |
41 self.dataformat += 1 |
34 self.dma_size -= 1 |
42 self.infosize -= 1 |
|
43 |
|
44 def readframe(self): |
|
45 #Read frame data |
|
46 if self.buffer == 0: |
|
47 self.buffer = ctypes.create_string_buffer(self.bufSize.value) |
|
48 |
|
49 self.timelog("Read frame data Start") |
|
50 self.Ret = self.webcamdll.ReadFrameData(self.PinHandle, ctypes.byref(self.buffer), self.bufSize.value) |
|
51 self.timelog("Read frame data End") |
|
52 |
|
53 #Write frame data. This is for debug. |
|
54 #self.Ret = self.webcamdll.WriteFrameData("_frameData.bin", ctypes.byref(self.buffer), self.bufSize.value); |
|
55 |
|
56 buf = self.buffer |
|
57 length = len(buf) |
|
58 count = 0 |
|
59 for x in range(1, length, 2): |
|
60 if self.dma_size > 0: |
|
61 self.buf = ord(buf[count+1]) << 8 | ord(buf[count+0]) |
|
62 self.dma_writel(self.dma_addr, self.buf) |
|
63 self.dma_addr += 2 |
|
64 self.dma_size -= 2 |
|
65 count += 2 |
|
66 |
35 self.set_irq_level(0, self.int_enable) |
67 self.set_irq_level(0, self.int_enable) |
36 |
68 |
37 def timer_on(self): |
69 def timelog(self,buf): |
38 self.ptimer = qemu.ptimer(self.timertick, 1) |
70 date = datetime.datetime.today().isoformat() |
39 self.ptimer.run(0) |
71 print "%(view)s %(time)s" % {"view":buf,"time":date} |
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 |
72 |
57 def create(self): |
73 def create(self): |
58 self.int_enable = 1 |
74 self.int_enable = 1 |
59 self.dma_addr = 0 |
75 self.dma_addr = 0 |
60 self.dma_size =0 |
76 self.dma_size = 0 |
61 self.cha=0 |
77 self.cha = 0 |
62 self.loadIMG() |
78 self.dataformat = 0 |
|
79 self.infosize = 0 |
|
80 self.buffer = 0 |
|
81 self.infobuffer = 0 |
63 |
82 |
64 def write_reg(self, offset, value): |
83 def write_reg(self, offset, value): |
|
84 #This func is called when PDD performed WriteReg func. |
65 offset >>= 2 |
85 offset >>= 2 |
66 if offset==self.REG_INT_ENABLE: |
86 if offset==self.REG_INT_ENABLE: |
67 self.int_enable=value |
87 self.int_enable=value |
68 if value==1: |
88 if value==1: |
69 if self.data_type==0: |
89 if self.data_type==0: |
70 self.timer_on() |
90 self.readframe() |
71 elif self.data_type==1: |
|
72 self.capturedata() |
|
73 else: |
91 else: |
74 if self.data_type==0: |
92 if self.data_type==0: |
75 self.timer_off() |
93 self.set_irq_level(0, self.int_enable) |
76 elif self.data_type==1: |
94 #self.timer_off() |
77 self.set_irq_level(0, self.int_enable) |
95 elif self.data_type==1: |
|
96 self.set_irq_level(0, self.int_enable) |
78 elif offset == self.REG_DATA_TYPE: |
97 elif offset == self.REG_DATA_TYPE: |
79 self.data_type = value |
98 self.data_type = value |
80 elif offset == self.REG_DMA_ADDR: |
99 elif offset == self.REG_DMA_ADDR: |
81 self.dma_addr = value |
100 self.dma_addr = value |
82 elif offset == self.REG_DMA_SIZE: |
101 elif offset == self.REG_DMA_SIZE: |
83 self.dma_size = value |
102 self.dma_size = value |
|
103 elif offset == self.REG_DMA_INFO: |
|
104 self.dataformat = value |
|
105 elif offset == self.REG_DMA_INFOSIZE: |
|
106 self.infosize = value |
|
107 elif offset == self.REG_DMA_CONNECT: |
|
108 self.loaddll() |
|
109 self.connect() |
|
110 elif offset == self.REG_DMA_DISCONNECT: |
|
111 self.Ret = self.webcamdll.DisconnectPinHandle(self.PinHandle) |
|
112 self.set_irq_level(0, self.int_enable) |
84 |
113 |
85 def read_reg(self, offset): |
114 def read_reg(self, offset): |
|
115 #This func is called when PDD performed ReadReg func. |
86 offset >>= 2 |
116 offset >>= 2 |
87 if offset == self.REG_ID: |
117 if offset == self.REG_ID: |
88 return 0xc600f000 |
118 return 0xc600f000 |
89 elif offset == self.REG_INT_ENABLE: |
119 elif offset == self.REG_INT_ENABLE: |
90 return self.int_enable |
120 return self.int_enable |
91 elif offset == self.REG_DMA_ADDR: |
121 elif offset == self.REG_DMA_ADDR: |
92 return self.dma_addr |
122 return self.dma_addr |
93 elif offset == self.REG_DMA_SIZE: |
123 elif offset == self.REG_DMA_SIZE: |
94 return self.dma_size |
124 return self.dma_size |
|
125 elif offset == self.REG_DMA_FORMAT: |
|
126 return self.dataformat |
95 return 0 |
127 return 0 |
96 |
128 |
97 def save(self, f): |
129 def save(self, f): |
98 f.put_u32(self.int_enable) |
130 f.put_u32(self.int_enable) |
99 f.put_u32(self.dma_addr) |
131 f.put_u32(self.dma_addr) |
100 f.put_u32(self.dma_size) |
132 f.put_u32(self.dma_size) |
|
133 f.put_u32(self.dataformat) |
|
134 f.put_u32(self.infosize) |
|
135 f.put_u32(self.buffer) |
|
136 f.put_u32(self.infobuffer) |
101 |
137 |
102 def load(self, f): |
138 def load(self, f): |
103 self.int_enable = f.get_u32() |
139 self.int_enable = f.get_u32() |
104 self.dma_addr = f.get_u32() |
140 self.dma_addr = f.get_u32() |
105 self.dma_size = f.get_u32() |
141 self.dma_size = f.get_u32() |
|
142 self.dataformat = f.get_u32() |
|
143 self.infosize = f.get_u32() |
|
144 self.buffer = f.get_u32() |
|
145 self.infobuffer = f.get_u32() |
106 |
146 |
107 # Device class properties |
147 # Device class properties |
108 regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)] |
148 regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)] |
109 irqs = 1 |
149 irqs = 1 |
110 name = "syborg,usbtest" |
150 name = "syborg,usbtest" |