Register names for NRF.
[goodfet] / client / GoodFETARM.py
1 #!/usr/bin/env python
2 # GoodFET Client Library
3
4 #
5 # Good luck with alpha / beta code.
6 # Contributions and bug reports welcome.
7 #
8
9 import sys, binascii, struct
10 import atlasutils.smartprint as asp
11
12 #Global Commands
13 READ  = 0x00
14 WRITE = 0x01
15 PEEK  = 0x02
16 POKE  = 0x03
17 SETUP = 0x10
18 START = 0x20
19 STOP  = 0x21
20 CALL  = 0x30
21 EXEC  = 0x31
22 NOK   = 0x7E
23 OK    = 0x7F
24
25 # ARM7TDMI JTAG commands
26 GET_DEBUG_CTRL      = 0x80
27 SET_DEBUG_CTRL      = 0x81
28 GET_PC              = 0x82
29 SET_PC              = 0x83
30 GET_CHIP_ID         = 0x84
31 GET_DEBUG_STATE     = 0x85
32 GET_WATCHPOINT      = 0x86
33 SET_WATCHPOINT      = 0x87
34 GET_REGISTER        = 0x88
35 SET_REGISTER        = 0x89
36 GET_REGISTERS       = 0x8a
37 SET_REGISTERS       = 0x8b
38 HALTCPU             = 0x8c
39 RESUMECPU           = 0x8d
40 DEBUG_INSTR         = 0x8e      #
41 STEP_INSTR          = 0x8f      #
42 STEP_REPLACE        = 0x90      #
43 READ_CODE_MEMORY    = 0x91      # ??
44 WRITE_FLASH_PAGE    = 0x92      # ??
45 READ_FLASH_PAGE     = 0x93      # ??
46 MASS_ERASE_FLASH    = 0x94      # ??
47 PROGRAM_FLASH       = 0x95
48 LOCKCHIP            = 0x96      # ??
49 CHIP_ERASE          = 0x97      # can do?
50 # Really ARM specific stuff
51 GET_CPSR            = 0x98
52 SET_CPSR            = 0x99
53 GET_SPSR            = 0x9a
54 SET_SPSR            = 0x9b
55 SET_MODE_THUMB      = 0x9c
56 SET_MODE_ARM        = 0x9d
57
58 from GoodFET import GoodFET
59 from intelhex import IntelHex
60
61
62
63
64 class GoodFETARM(GoodFET):
65     """A GoodFET variant for use with ARM7TDMI microprocessor."""
66     def ARMhaltcpu(self):
67         """Halt the CPU."""
68         self.writecmd(0x33,HALTCPU,0,self.data)
69     def ARMreleasecpu(self):
70         """Resume the CPU."""
71         self.writecmd(0x33,RESUMECPU,0,self.data)
72     def ARMsetModeArm(self):
73         self.writecmd(0x33,SET_MODE_ARM,0,self.data)
74     def ARMtest(self):
75         self.ARMreleasecpu()
76         self.ARMhaltcpu()
77         print "Status: %s" % self.ARMstatusstr()
78         
79         #Grab ident three times, should be equal.
80         ident1=self.ARMident()
81         ident2=self.ARMident()
82         ident3=self.ARMident()
83         if(ident1!=ident2 or ident2!=ident3):
84             print "Error, repeated ident attempts unequal."
85             print "%04x, %04x, %04x" % (ident1, ident2, ident3)
86         
87         #Set and Check Registers
88         regs = [1024+x for x in range(1,15)]
89         regr = []
90         for x in range(len(regs)):
91             self.ARMset_register(x, regs[x])
92
93         for x in range(len(regs)):
94             regr.append(self.ARMget_register(x))
95         
96         for x in range(len(regs)):
97             if regs[x] != regr[x]:
98                 print "Error, R%d fail: %x != %x"%(x,regs[x],regr[x])
99
100         return
101
102
103
104
105         #Single step, printing PC.
106         print "Tracing execution at startup."
107         for i in range(15):
108             pc=self.ARMgetPC()
109             byte=self.ARMpeekcodebyte(i)
110             #print "PC=%04x, %02x" % (pc, byte)
111             self.ARMstep_instr()
112         
113         print "Verifying that debugging a NOP doesn't affect the PC."
114         for i in range(1,15):
115             pc=self.ARMgetPC()
116             self.ARMdebuginstr([NOP])
117             if(pc!=self.ARMgetPC()):
118                 print "ERROR: PC changed during ARMdebuginstr([NOP])!"
119         
120         print "Checking pokes to XRAM."
121         for i in range(0xf000,0xf020):
122             self.ARMpokedatabyte(i,0xde)
123             if(self.ARMpeekdatabyte(i)!=0xde):
124                 print "Error in DATA at 0x%04x" % i
125         
126         #print "Status: %s." % self.ARMstatusstr()
127         #Exit debugger
128         self.stop()
129         print "Done."
130
131     def setup(self):
132         """Move the FET into the JTAG ARM application."""
133         #print "Initializing ARM."
134         self.writecmd(0x33,SETUP,0,self.data)
135     def ARMget_dbgstate(self):
136         """Read the config register of an ARM."""
137         retval = struct.unpack("<L", self.data[:4])[0]
138         return retval
139     def ARMget_dbgctrl(self):
140         """Read the config register of an ARM."""
141         self.writecmd(0x33,GET_DEBUG_CTRL,0,self.data)
142         retval = struct.unpack("B", self.data)[0]
143         return retval
144     def ARMset_dbgctrl(self,config):
145         """Write the config register of an ARM."""
146         self.writecmd(0x33,SET_DEBUG_CTRL,1,[config&7])
147     def ARMlockchip(self):
148         """Set the flash lock bit in info mem."""
149         self.writecmd(0x33, LOCKCHIP, 0, [])
150     
151
152     def ARMidentstr(self):
153         ident=self.ARMident()
154         ver     = ident >> 28
155         partno  = (ident >> 12) & 0x10
156         mfgid   = ident & 0xfff
157         return "mfg: %x\npartno: %x\nver: %x\n(%x)" % (ver, partno, mfgid, ident); 
158     def ARMident(self):
159         """Get an ARM's ID."""
160         self.writecmd(0x33,GET_CHIP_ID,0,[])
161         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
162         return retval
163     def ARMgetPC(self):
164         """Get an ARM's PC."""
165         self.writecmd(0x33,GET_PC,0,[])
166         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
167         return retval
168     def ARMget_register(self, reg):
169         """Get an ARM's Register"""
170         self.writecmd(0x33,GET_REGISTER,1,[reg&0xff])
171         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
172         return retval
173     def ARMset_register(self, reg, val):
174         """Get an ARM's Register"""
175         self.writecmd(0x33,SET_REGISTER,8,[reg,0,0,0,val&0xff, (val>>8)&0xff, (val>>16)&0xff, val>>24])
176         #self.writecmd(0x33,SET_REGISTER,8,[reg,0,0,0, (val>>16)&0xff, val>>24, val&0xff, (val>>8)&0xff])
177         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
178         return retval
179     def ARMget_registers(self):
180         """Get ARM Registers"""
181         self.writecmd(0x33,GET_REGISTERS,0, [])
182         retval = []
183         for x in range(0,len(self.data), 4):
184           retval.append(struct.unpack("<L", self.data[x:x+4])[0])
185         return retval
186     def ARMset_registers(self, regs):
187         """Set ARM Registers"""
188         regarry = []
189         for reg in regs:
190           regarry.extend([reg&0xff, (reg>>8)&0xff, (reg>>16)&0xff, reg>>24])
191         self.writecmd(0x33,SET_REGISTERS,16*4,regarry)
192         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
193         return retval
194     def ARMcmd(self,phrase):
195         self.writecmd(0x33,READ,len(phrase),phrase)
196         val=ord(self.data[0])
197         print "Got %02x" % val
198         return val
199     def ARMdebuginstr(self,instr):
200         if type (instr) == int:
201             instr = struct.pack("<L", instr)
202         self.writecmd(0x33,DEBUG_INSTR,len(instr),instr)
203         return (self.data[0])
204     def ARMpeekcodebyte(self,adr):
205         """Read the contents of code memory at an address."""
206         self.data=[adr&0xff, (adr&0xff00)>>8]
207         self.writecmd(0x33,PEEK,2,self.data)
208         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
209         return retval
210     def ARMpeekdatabyte(self,adr):
211         """Read the contents of data memory at an address."""
212         self.data=[adr&0xff, (adr&0xff00)>>8]
213         self.writecmd(0x33, PEEK, 2, self.data)
214         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
215         return retval
216     def ARMpokedatabyte(self,adr,val):
217         """Write a byte to data memory."""
218         self.data=[adr&0xff, (adr&0xff00)>>8, val]
219         self.writecmd(0x33, POKE, 3, self.data)
220         retval = struct.unpack("<L", "".join(self.data[0:4]))[0]
221         return retval
222     def ARMchiperase(self):
223         """Erase all of the target's memory."""
224         self.writecmd(0x33,CHIP_ERASE,0,[])
225     def ARMstatus(self):
226         """Check the status."""
227         self.writecmd(0x33,GET_DEBUG_STATE,0,[])
228         return ord(self.data[0])
229     ARMstatusbits={
230                   0x10 : "TBIT",
231                   0x08 : "cgenL",
232                   0x04 : "Interrupts Enabled (or not?)",
233                   0x02 : "DBGRQ",
234                   0x01 : "DGBACK"
235                   }
236     ARMctrlbits={
237                   0x04 : "disable interrupts",
238                   0x02 : "force dbgrq",
239                   0x01 : "force dbgack"
240                   }
241                   
242     def ARMstatusstr(self):
243         """Check the status as a string."""
244         status=self.ARMstatus()
245         str=""
246         i=1
247         while i<0x100:
248             if(status&i):
249                 str="%s %s" %(self.ARMstatusbits[i],str)
250             i*=2
251         return str
252     def start(self):
253         """Start debugging."""
254         self.writecmd(0x33,START,0,self.data)
255         #ident=self.ARMidentstr()
256         #print "Target identifies as %s." % ident
257         #print "Status: %s." % self.ARMstatusstr()
258         #self.ARMreleasecpu()
259         #self.ARMhaltcpu()
260         #print "Status: %s." % self.ARMstatusstr()
261         
262     def stop(self):
263         """Stop debugging."""
264         self.writecmd(0x33,STOP,0,self.data)
265     def ARMstep_instr(self):
266         """Step one instruction."""
267         self.writecmd(0x33,STEP_INSTR,0,self.data)
268     def ARMflashpage(self,adr):
269         """Flash 2kB a page of flash from 0xF000 in XDATA"""
270         data=[adr&0xFF,
271               (adr>>8)&0xFF,
272               (adr>>16)&0xFF,
273               (adr>>24)&0xFF]
274         print "Flashing buffer to 0x%06x" % adr
275         self.writecmd(0x33,MASS_FLASH_PAGE,4,data)
276
277     def writecmd(self, app, verb, count=0, data=[]):
278         """Write a command and some data to the GoodFET."""
279         self.serialport.write(chr(app))
280         self.serialport.write(chr(verb))
281         count = len(data)
282         #if data!=None:
283         #    count=len(data); #Initial count ignored.
284
285         #print "TX %02x %02x %04x" % (app,verb,count)
286
287         #little endian 16-bit length
288         self.serialport.write(chr(count&0xFF))
289         self.serialport.write(chr(count>>8))
290
291         #print "count=%02x, len(data)=%04x" % (count,len(data))
292
293         if count!=0:
294             if(isinstance(data,list)):
295                 for i in range(0,count):
296                     #print "Converting %02x at %i" % (data[i],i)
297                     data[i]=chr(data[i])
298             #print type(data)
299             outstr=''.join(data)
300             self.serialport.write(outstr)
301         if not self.besilent:
302             self.readcmd()
303
304