X-Git-Url: http://git.rot13.org/?p=goodfet;a=blobdiff_plain;f=client%2FGoodFETAT91X40.py;h=0776c2d68064d7f6ad22e90ec066019322c0f992;hp=12803b5977e05b1034007ae2857f72d711b07252;hb=d08bfd3c7cdc687fd68ba9025702c262665e52d3;hpb=74e36bf601fbabbc05222940ace614ae0387d57c

diff --git a/client/GoodFETAT91X40.py b/client/GoodFETAT91X40.py
index 12803b5..0776c2d 100644
--- a/client/GoodFETAT91X40.py
+++ b/client/GoodFETAT91X40.py
@@ -265,7 +265,7 @@ def mcr_decode(mcr):
     #print hex(drp)
     if drp and drp != 1:
         drp = 2
-	return (validAddrBits, maxAddrSpace, validCS, codeLabel, drp)
+    return (validAddrBits, maxAddrSpace, validCS, codeLabel, drp)
 
 def mcr_decode_str(mcr):
     ( validAddrBits, maxAddrSpace, validCS, codeLabel, drp) = mcr_decode(mcr)
@@ -330,10 +330,10 @@ class GoodFETAT91X40(GoodFETARM7):
         addr = EBI_BASE + (chipnum*4)
         self.ARMwriteChunk(addr,[value])
 
-    def getEBIMemoryMap(self):
+    def getEBIMemoryMapstr(self):
         keys = ebi_memory_map_items.keys()
         keys.sort()
-        output = [ "EBI Memory Map"]
+        output = [ "===EBI Memory Map==="]
         for x in xrange(8):
             desc,name,rw,default = ebi_memory_map_items[x*4]
             output.append("\nMAP: %s (%s) - default: %x\n%s"%(name,desc,default,self.getChipSelectRegstr(x)))
@@ -345,9 +345,8 @@ class GoodFETAT91X40(GoodFETARM7):
         return mcr
     def getMemoryControlRegisterstr(self):
         return mcr_decode_str(self.getMemoryControlRegister())
-    def getEBIMCR(self):
-        print "EBI Memory Control Register\n"
-        print self.getMemoryControlRegisterstr()
+    def getEBIMCRstr(self):
+        return  "EBI Memory Control Register\n" + self.getMemoryControlRegisterstr()
 
     def getInterruptSourceModeReg(self, regnum):
         regval = self.ARMreadMem(AIC_SMR[regnum][0])
@@ -520,6 +519,10 @@ def at91x40_main():
 
     at91x40_cli_handler(client, sys.argv)
 
+
+
+BLOCK_DWORDS = 48
+BLOCK_SIZE   = 4 * BLOCK_DWORDS
 def at91x40_cli_handler(client, argv):
 
     if(argv[1]=="chipRegStr"):
@@ -580,89 +583,110 @@ def at91x40_cli_handler(client, argv):
             # Yes, this requires that you set the start and stop addresses
             special_reg_num=int(argv[5])
             special_addr=int(argv[6],16)
+        err_list = []
         
         print "Dumping from %04x to %04x as %s." % (start,stop,f)
-        #h = IntelHex16bit(None)
         # FIXME: get mcu state and return it to that state
         client.halt()
 
         h = IntelHex(None)
-        i=start
-        while i<=stop:
-            err_cnt = 0
-            #data=client.ARMreadMem(i, 48)
-            try:
-                data=client.ARMreadChunk(i, 48, verbose=0)
-                print "Dumped %06x."%i
-                for dword in data:
-                    if i<=stop and dword != 0xdeadbeef:
-                        h.puts( i, struct.pack("<I", dword) )
-                        err_cnt = 0
-                    i+=4
-            # FIXME: get mcu state and return it to that state
-            except:
-                # Handle exceptions by counting errors after pausing to let ARM settle
-                err_cnt = 1
-                fail = 0
-                while err_cnt:
-                    time.sleep(.25)
-                    if err_cnt == 100:
-                        print "Unknown error occurred at least 100 times. Resync did not work. Writing incomplete data to file."
-                        fail = 1
-                        break
-                    else:
-                        try:
-                            print "Unknown error during read. Resync and retry."
-
-                            # If we error out several times then reset the chip and restart
-                            # This uses a special register value from a Chip Select Register
-                            # to test that the chip is in the operation state we expect
-                            if not ((err_cnt+1) % 2):
-                                reset_cnt = 0
-                                while True:
-                                    print "    Reset:",reset_cnt
-                                    check_addr = client.getChipSelectReg(special_reg_num)
-                                    print "    Special Addr:",hex(special_addr)
-                                    print "    Check Addr:",hex(check_addr)
-                                    if (special_addr == check_addr):
-                                        break
-                                    if reset_cnt == 10:
-                                        reset_cnt = 0
-                                        print "    Resetting Target"
-                                        client.ARMresettarget(1000)
-                                        client.halt()
-                                    reset_cnt += 1
-                                    time.sleep(.25)
-                            else:
-                                #Resync ARM and Watch Dog
-                                client.resume()
-                                client.halt()
-
-                            #Disable Watch Dog
-                            if client.checkWatchDog():
-                                client.disableWatchDog()
+        base = start
+        err_cnt = 0
+        reset_cnt = 0
+        while base<=stop:
+            confirmed = False
+            while not confirmed: 
+                i = base
+                try:
+                    data=client.ARMreadChunk(i, BLOCK_DWORDS, verbose=0)
+                    print "Dumped %06x."%i
+                    for dword in data:
+                        if i<=stop:# and dword != 0xdeadbeef:
+                            h.puts( i, struct.pack("<I", dword) )
                             err_cnt = 0
-                        except:
-                            err_cnt += 1
-                            pass
-                if fail:
-                    break
+                        i += 4
+
+                    confirmed=True
+
+                # FIXME: get mcu state and return it to that state
+                except:
+                    # Handle exceptions by counting errors after pausing to let ARM settle
+                    err_cnt = 1
+                    fail = 0
+                    while err_cnt:
+                        time.sleep(.25)
+                        if err_cnt == 100:
+                            print "Unknown error occurred at least 100 times. Resync did not work. Writing incomplete data to file."
+                            fail = 1
+                            break
+                        else:
+                            try:
+                                print "Unknown error during read. Resync and retry."
+                                err_list.append("0x%06x"%i)
+
+                                # If we error out several times then reset the chip and restart
+                                # This uses a special register value from a Chip Select Register
+                                # to test that the chip is in the operation state we expect
+                                if not ((err_cnt+1) % 2):
+                                    while True:
+                                        print "    Reset:",reset_cnt
+                                        check_addr = client.getChipSelectReg(special_reg_num)
+                                        print "    Special Addr:",hex(special_addr)
+                                        print "    Check Addr:",hex(check_addr)
+                                        if (special_addr == check_addr):
+                                            break
+                                        if reset_cnt == 10:
+                                            reset_cnt = 0
+                                            print "    Resetting Target"
+                                            client.ARMresettarget(1000)
+                                            client.halt()
+                                        reset_cnt += 1
+                                        time.sleep(.25)
+                                else:
+                                    #Resync ARM and Watch Dog
+                                    client.resume()
+                                    client.halt()
+
+                                err_cnt = 0
+                            except:
+                                err_cnt += 1
+                                pass
+                    if fail:
+                        break
+
+            # we've confirmed the write on this block... move on.
+            base += BLOCK_SIZE
 
-        client.resume()
         h.write_hex_file(f)
+        print "Addresses that required resync:"
+        if err_list:
+            for e in err_list:
+                print "   ",e
+        else:
+            print "   None"
+
+        try:
+            client.resume()
+        except:
+            print "error resuming...  resetting"
+            try:
+                client.ARMresettarget()
+            except:
+                print "error resetting!  just exiting"
 
 
 
     if(argv[1]=="memorymap"):
         client.halt()
-        print client.getEBIMCR()
+        print "=============================================="
+        print client.getEBIMCRstr()
         print ""
-        print client.getEBIMemoryMap()
+        print client.getEBIMemoryMapstr()
         client.resume()
 
     if(argv[1]=="memorycontrolreg"):
         client.halt()
-        print client.getEBIMCR()
+        print client.getEBIMCRstr()
         client.resume()