Pull in the vector table. Patch the vector table to suite the

prog.py

@@ -5,6 +5,7 @@ import binascii
 import random
 import pprint
 import collections
+import struct
 
 import elffile
 
@@ -36,7 +37,20 @@ RETURN_CODE = {
 
 Section = collections.namedtuple('Section', 'name address content')
 
+def fix_vectors(data):
+    """Patch the vector table so the bootloader recognises the code
+    as valid.  Sum of the first eight is zero.
+    """
+    first = data[:4*7]
+    remainder = data[4*8:]
+
+    vectors = struct.unpack('<IIIIIII', first)
+    last = -sum(vectors) & 0xFFFFFFFF
+
+    return first + struct.pack('<I', last) + remainder
+
 class ELFReader:
+    """Reads an ELF file into sections."""
     def __init__(self, name):
         elf = elffile.open(name)
 
@@ -44,17 +58,24 @@ class ELFReader:
         self.sections = []
 
         for header in elf.sectionHeaders:
-            if header.name in ['.text', '.data']:
-                self.sections.append(Section(header.name, header.addr, header.content))
+            if header.name in ['.text', '.data', '.vectors']:
+                content = header.content
+
+                if header.name == '.vectors':
+                    content = fix_vectors(content)
+
+                self.sections.append(Section(header.name, header.addr, content))
         
 class Loader:
+    """Talk with a LPC1114 over the serial bootloader protocol."""
+
     SYNCHRONIZED = 'Synchronized\r\n'
     OK = 'OK\r\n'
 
-    def __init__(self, verbose=False):
+    def __init__(self, port='/dev/ttyUSB0', verbose=True):
         self.verbose = verbose
 
-        self.port = serial.Serial('/dev/ttyUSB0', 115200, timeout=0.5)
+        self.port = serial.Serial(port, 115200, timeout=0.5)
 
     def log(self, msg, eol=True):
         if self.verbose:
@@ -69,6 +90,12 @@ class Loader:
     def set_bsl(self, level):
         self.port.setRTS(level == 0)
 
+    def run(self):
+        self.set_bsl(1)
+        self.set_reset(1)
+        self.set_reset(0)
+        self.set_reset(1)
+
     def sync(self):
         for tries in range(3):
             self.set_bsl(0)
@@ -123,6 +150,40 @@ class Loader:
             else:
                 raise Error('Protocol error')
 
+    def prepare(self, first, last=None):
+        if last == None:
+            last = first
+
+        self.execute('P', (), first, last)
+
+    def erase(self, first, last=None):
+        if last == None:
+            last = first
+
+        self.prepare(first, last)
+        self.execute('E', (), first, last)
+
+    def program(self, address, data):
+        page_size = 256
+        chunk = 512
+        load_address = 0x10000400
+
+        if address % page_size != 0:
+            raise Error('Address must be page size aligned')
+
+        remainder = len(data) % page_size
+
+        if remainder != 0:
+            data += '\xff' * (page_size - remainder)
+
+        assert len(data) % page_size == 0
+
+        for offset in range(0, len(data), chunk):
+            part = data[offset:offset+chunk]
+            self.load(load_address, part)
+            self.prepare(0)
+            self.execute('C', (), address + offset, load_address, len(part))
+
     def go(self, address):
         self.execute('G', (), address, 'T')
 
@@ -138,7 +199,15 @@ class Loader:
         self.execute('U', (), 23130)
 
     def check_ok(self):
-        assert self.readline() == '0'
+        code = self.readline()
+
+        try:
+            code = int(code)
+        except ValueError:
+            raise Error('Invalid result code')
+
+        if code != 0:
+            raise Error(RETURN_CODE[code])
 
     def execute(self, command, result, *kargs):
         send = command
@@ -147,11 +216,7 @@ class Loader:
             send += ' %s' % arg
 
         self.send(send)
-
-        code = int(self.readline())
-
-        if code != 0:
-            raise Error(RETURN_CODE[code])
+        self.check_ok()
 
         values = []
 
@@ -210,13 +275,18 @@ def main():
     loader.sync()
     loader.unlock()
 
+    loader.erase(0)
+
     for arg in sys.argv[1:]:
         data = ELFReader(arg)
 
         for section in data.sections:
-            loader.load(section.address, section.content)
+            loader.program(section.address, section.content)
 
-    loader.go(data.entry)
+    loader.sync()
+    loader.run()
+#    loader.unlock()
+#    loader.go(data.entry)
 
 if __name__ == '__main__':
     main()