tinyprog: ensure start at multiple of 256

The SPI Flash method used by program_sectors() will wrap around from
the end of the 256-octet sector to the start of the 256-octet sector
if a write starts part way into the 256-octet sector and writes more
octets than (256-start_offset), due to only incrementing the low address
bits.  Add checks to ensure program_sectors() is only usable with a
start address that is a multiple of 256 to avoid scrambled data in
the flash due this SPI Flash wrap around.

Author: ewenmcneill

programmer/tinyprog/__init__.py

@@ -497,16 +497,27 @@ def program_fast(self, addr, data):
             return False
 
     def program_sectors(self, addr, data):
+        minor_sector_size = 256
         sector_size = 4 * 1024
 
+        # The SPI flash program sector action will wrap around if we
+        # start part way into a 256-octet sector and program 256 octets, due
+        # to the way that it increments the address.  So ensure that the
+        # addresses are always a multiple of 256 octets.
+        #
+        if ((addr % minor_sector_size) != 0):
+            raise ValueError("Address must be a multiple of {0}, not {1}".
+                             format(minor_sector_size, addr))
+
         with tqdm(desc="    Programming and Verifying", unit="B",
                   unit_scale=True, total=len(data)) as pbar:
             for offset in range(0, len(data), sector_size):
                 current_addr = addr + offset
+                assert((current_addr % minor_sector_size) == 0)
+
                 current_write_data = data[offset:offset + sector_size]
                 self.erase(current_addr, sector_size, disable_progress=True)
 
-                minor_sector_size = 256
                 for minor_offset in range(0, 4 * 1024, minor_sector_size):
                     minor_write_data = current_write_data[
                         minor_offset:minor_offset + minor_sector_size]
@@ -519,12 +530,22 @@ def program_sectors(self, addr, data):
                     # only happen on the final minor sector to be written.)
                     #
                     if (len(minor_write_data) < minor_sector_size):
-                         pad_len = minor_sector_size - len(minor_write_data)
+                         offset_from_start_of_sector = (
+                             (current_addr + minor_offset) %
+                                 minor_sector_size
+                         )
+                         expected_write_size = (
+                             minor_sector_size - offset_from_start_of_sector
+                         )
+                         assert(offset_from_start_of_sector == 0)
+
+                         pad_len = (minor_sector_size - len(minor_write_data) -
+                                    offset_from_start_of_sector)
                          padding = b'\xff' * pad_len
 
                          minor_write_data = bytearray(minor_write_data)
                          minor_write_data.extend(padding)
-                         assert(len(minor_write_data) == minor_sector_size)
+                         assert(len(minor_write_data) == expected_write_size)
 
                     self.write(
                         current_addr + minor_offset,