X-Git-Url: http://git.rot13.org/?p=goodfet;a=blobdiff_plain;f=client%2FGoodFET.py;h=5c38ca99b89c1a824e968a6d7611b822a6e9342e;hp=cfc207961760353a84698826a9d314003f2840b9;hb=170b91225ad57f56cb8f30f938cc7af3cfd2ebfe;hpb=c9fa78dd91736cd5004d23fd9535c30be4f978ff diff --git a/client/GoodFET.py b/client/GoodFET.py index cfc2079..5c38ca9 100755 --- a/client/GoodFET.py +++ b/client/GoodFET.py @@ -6,15 +6,58 @@ # This code is being rewritten and refactored. You've been warned! import sys, time, string, cStringIO, struct, glob, serial, os; +import sqlite3; +def getClient(name="GoodFET"): + import GoodFET, GoodFETCC, GoodFETAVR, GoodFETSPI, GoodFETMSP430; + if(name=="GoodFET" or name=="monitor"): return GoodFET.GoodFET(); + elif name=="cc" or name=="chipcon": return GoodFETCC.GoodFETCC(); + elif name=="avr": return GoodFETAVR.GoodFETAVR(); + elif name=="spi": return GoodFETSPI.GoodFETSPI(); + elif name=="msp430": return GoodFETMSP430.GoodFETMSP430(); + + print "Unsupported target: %s" % name; + sys.exit(0); + +class SymbolTable: + """GoodFET Symbol Table""" + db=sqlite3.connect(":memory:"); + + def __init__(self, *args, **kargs): + self.db.execute("create table if not exists symbols(adr,name,memory,size,comment);"); + def get(self,name): + self.db.commit(); + c=self.db.cursor(); + try: + c.execute("select adr,memory from symbols where name=?",(name,)); + for row in c: + #print "Found it."; + sys.stdout.flush(); + return row[0]; + #print "No dice."; + except:# sqlite3.OperationalError: + #print "SQL error."; + return eval(name); + return eval(name); + def define(self,adr,name,comment="",memory="vn",size=16): + self.db.execute("insert into symbols(adr,name,memory,size,comment)" + "values(?,?,?,?,?);", ( + adr,name,memory,size,comment)); + #print "Set %s=%s." % (name,adr); class GoodFET: """GoodFET Client Library""" GLITCHAPP=0x71; + symbols=SymbolTable(); def __init__(self, *args, **kargs): self.data=[0]; + def getConsole(self): + from GoodFETConsole import GoodFETConsole; + return GoodFETConsole(self); + def name2adr(self,name): + return self.symbols.get(name); def timeout(self): print "timeout\n"; def serInit(self, port=None): @@ -40,8 +83,12 @@ class GoodFET: parity = serial.PARITY_NONE ) - #Explicitly set RTS + #This might cause problems, but it makes failure graceful. + #self.serialport._timeout = 5; + + #Explicitly set RTS and DTR to halt board. self.serialport.setRTS(1); + self.serialport.setDTR(1); #Drop DTR, which is !RST, low to begin the app. self.serialport.setDTR(0); self.serialport.flushInput() @@ -64,7 +111,7 @@ class GoodFET: #if data!=None: # count=len(data); #Initial count ignored. - #print "TX %02x %02x" % (app,verb); + #print "TX %02x %02x %04x" % (app,verb,count); #little endian 16-bit length self.serialport.write(chr(count&0xFF)); @@ -73,11 +120,12 @@ class GoodFET: #print "count=%02x, len(data)=%04x" % (count,len(data)); if count!=0: - for i in range(0,count): + if(isinstance(data,list)): + for i in range(0,count): #print "Converting %02x at %i" % (data[i],i) - data[i]=chr(data[i]); + data[i]=chr(data[i]); + #print type(data); outstr=''.join(data); - #outstr=data; self.serialport.write(outstr); if not self.besilent: self.readcmd(); @@ -104,20 +152,34 @@ class GoodFET: #Debugging string; print, but wait. if self.app==0xFF and self.verb==0xFF: print "# DEBUG %s" % self.serialport.read(self.count); + sys.stdout.flush(); else: self.data=self.serialport.read(self.count); return self.data; #Glitching stuff. - def glitchAPP(self,app): + def glitchApp(self,app): """Glitch into a device by its application.""" self.data=[app&0xff]; self.writecmd(self.GLITCHAPP,0x80,1,self.data); #return ord(self.data[0]); - def glitchVERB(self,app,verb, data): - """Glitch during a transaction..""" + def glitchVerb(self,app,verb,data): + """Glitch during a transaction.""" + if data==None: data=[]; self.data=[app&0xff, verb&0xFF]+data; self.writecmd(self.GLITCHAPP,0x81,len(self.data),self.data); #return ord(self.data[0]); + def glitchstart(self): + """Glitch into the AVR application.""" + self.glitchVerb(self.APP,0x20,None); + def glitchstarttime(self): + """Measure the timer of the START verb.""" + return self.glitchTime(self.APP,0x20,None); + def glitchTime(self,app,verb,data): + """Time the execution of a verb.""" + if data==None: data=[]; + self.data=[app&0xff, verb&0xFF]+data; + self.writecmd(self.GLITCHAPP,0x82,len(self.data),self.data); + return ord(self.data[0])+(ord(self.data[1])<<8); def glitchVoltages(self,low=0x0880, high=0x0fff): """Set glitching voltages. (0x0fff is max.)""" self.data=[low&0xff, (low>>8)&0xff, @@ -145,6 +207,14 @@ class GoodFET: def dir(self,byte): """Write a byte to P5DIR.""" self.writecmd(0,0xA0,1,[byte]); + def call(self,adr): + """Call to an address.""" + self.writecmd(0,0x30,2, + [adr&0xFF,(adr>>8)&0xFF]); + def execute(self,code): + """Execute supplied code.""" + self.writecmd(0,0x31,2,#len(code), + code); def peekbyte(self,address): """Read a byte of memory from the monitor.""" self.data=[address&0xff,address>>8]; @@ -227,21 +297,50 @@ class GoodFET: print "Self-test complete."; + # The following functions ought to be implemented in + # every client. - def I2Csetup(self): - """Move the FET into the I2C application.""" - self.writecmd(0x02,0x10,0,self.data); #SPI/SETUP - def I2Cstart(self): - """Start an I2C transaction.""" - self.writecmd(0x02,0x20,0,self.data); #SPI/SETUP - def I2Cstop(self): - """Stop an I2C transaction.""" - self.writecmd(0x02,0x21,0,self.data); #SPI/SETUP - def I2Cread(self,len=1): - """Read len bytes by I2C.""" - self.writecmd(0x02,0x00,1,[len]); #SPI/SETUP - return self.data; - def I2Cwrite(self,bytes): - """Write bytes by I2C.""" - self.writecmd(0x02,0x01,len(bytes),bytes); #SPI/SETUP - return ord(self.data[0]); + def infostring(self): + a=self.peekbyte(0xff0); + b=self.peekbyte(0xff1); + return "%02x%02x" % (a,b); + def lock(self): + print "Locking Unsupported."; + def erase(self): + print "Erasure Unsupported."; + def setup(self): + return; + def start(self): + return; + def test(self): + print "Unimplemented."; + return; + def status(self): + print "Unimplemented."; + return; + def halt(self): + print "Unimplemented."; + return; + def resume(self): + print "Unimplemented."; + return; + def getpc(self): + print "Unimplemented."; + return 0xdead; + def flash(self,file): + """Flash an intel hex file to code memory.""" + print "Flash not implemented."; + def dump(self,file,start=0,stop=0xffff): + """Dump an intel hex file from code memory.""" + print "Dump not implemented."; + + def peek32(self,address, memory="vn"): + return (self.peek16(address,memory)+ + (self.peek16(address+2,memory)<<16)); + def peek16(self,address, memory="vn"): + return (self.peek8(address,memory)+ + (self.peek8(address+1,memory)<<8)); + def peek8(self,address, memory="vn"): + return self.peekbyte(address); #monitor + def loadsymbols(self): + return;