Прототип загрузки программы в spifi через драйвер

mik32_debug_hal/spifi.py

@@ -1,3 +1,4 @@
+import datetime
 from enum import Enum
 import os
 import pathlib
@@ -209,23 +210,7 @@ def get_segments_list(pages_offsets: List[int], segment_size: int) -> List[int]:
     return list(segments)
 
 
-def check_pages(pages: Dict[int, List[int]], openocd: OpenOcdTclRpc, use_quad_spi=False, use_chip_erase=False):
-    result = 0
-
-    openocd.halt()
-    init(openocd)
-
-    # Сбрасываем микросхему в режиме QPI из всех состояний в нормальный SPI режим.
-    generic_flash.chip_reset_qpi(openocd)
-
-    # Сбрасываем микросхему в режиме SPI из всех состояний в нормальный SPI режим.
-    generic_flash.chip_reset(openocd)
-
-    JEDEC_ID = send_command(openocd, generic_flash.JEDEC_ID_COMMAND,
-                                  Frameform.OPCODE_NOADDR, Fieldform.ALL_SERIAL, 3)
-
-    print(f"JEDEC ID = {JEDEC_ID[0]:02x} {JEDEC_ID[1]:02x} {JEDEC_ID[2]:02x}")
-
+def dma_config(openocd: OpenOcdTclRpc) -> dma.DMA:
     dma_instance = dma.DMA(openocd)
     dma_instance.init()
 
@@ -267,6 +252,28 @@ def check_pages(pages: Dict[int, List[int]], openocd: OpenOcdTclRpc, use_quad_sp
     dma_instance.channels[1].read_request = dma.ChannelRequest.SPIFI_REQUEST
     dma_instance.channels[1].read_ack = dma.ChannelAck.DISABLE
 
+    return dma_instance
+
+
+def check_pages(pages: Dict[int, List[int]], openocd: OpenOcdTclRpc, use_quad_spi=False, use_chip_erase=False):
+    result = 0
+
+    openocd.halt()
+    init(openocd)
+
+    # Сбрасываем микросхему в режиме QPI из всех состояний в нормальный SPI режим.
+    generic_flash.chip_reset_qpi(openocd)
+
+    # Сбрасываем микросхему в режиме SPI из всех состояний в нормальный SPI режим.
+    generic_flash.chip_reset(openocd)
+
+    JEDEC_ID = send_command(openocd, generic_flash.JEDEC_ID_COMMAND,
+                                  Frameform.OPCODE_NOADDR, Fieldform.ALL_SERIAL, 3)
+
+    print(f"JEDEC ID = {JEDEC_ID[0]:02x} {JEDEC_ID[1]:02x} {JEDEC_ID[2]:02x}")
+
+    dma_instance = dma_config(openocd)
+
     if (use_quad_spi):
         print("Using Quad SPI")
         generic_flash.quad_enable(openocd)
@@ -321,46 +328,7 @@ def write_pages(pages: Dict[int, List[int]], openocd: OpenOcdTclRpc, use_quad_sp
 
     print(f"JEDEC ID = {JEDEC_ID[0]:02x} {JEDEC_ID[1]:02x} {JEDEC_ID[2]:02x}")
 
-    dma_instance = dma.DMA(openocd)
-    dma_instance.init()
-
-    dma_instance.channels[0].write_buffer = 0
-
-    dma_instance.channels[0].channel = dma.ChannelIndex.CHANNEL_0
-    dma_instance.channels[0].priority = dma.ChannelPriority.VERY_HIGH
-
-    dma_instance.channels[0].read_mode = dma.ChannelMode.MEMORY
-    dma_instance.channels[0].read_increment = dma.ChannelIncrement.ENABLE
-    dma_instance.channels[0].read_size = dma.ChannelSize.WORD
-    dma_instance.channels[0].read_burst_size = 2
-    dma_instance.channels[0].read_request = dma.ChannelRequest.SPIFI_REQUEST
-    dma_instance.channels[0].read_ack = dma.ChannelAck.DISABLE
-
-    dma_instance.channels[0].write_mode = dma.ChannelMode.PERIPHERY
-    dma_instance.channels[0].write_increment = dma.ChannelIncrement.DISABLE
-    dma_instance.channels[0].write_size = dma.ChannelSize.WORD
-    dma_instance.channels[0].write_burst_size = 2
-    dma_instance.channels[0].write_request = dma.ChannelRequest.SPIFI_REQUEST
-    dma_instance.channels[0].write_ack = dma.ChannelAck.DISABLE
-
-    dma_instance.channels[1].write_buffer = 0
-
-    dma_instance.channels[1].channel = dma.ChannelIndex.CHANNEL_1
-    dma_instance.channels[1].priority = dma.ChannelPriority.VERY_HIGH
-
-    dma_instance.channels[1].write_mode = dma.ChannelMode.MEMORY
-    dma_instance.channels[1].write_increment = dma.ChannelIncrement.ENABLE
-    dma_instance.channels[1].write_size = dma.ChannelSize.WORD
-    dma_instance.channels[1].write_burst_size = 2
-    dma_instance.channels[1].write_request = dma.ChannelRequest.SPIFI_REQUEST
-    dma_instance.channels[1].write_ack = dma.ChannelAck.DISABLE
-
-    dma_instance.channels[1].read_mode = dma.ChannelMode.PERIPHERY
-    dma_instance.channels[1].read_increment = dma.ChannelIncrement.DISABLE
-    dma_instance.channels[1].read_size = dma.ChannelSize.WORD
-    dma_instance.channels[1].read_burst_size = 2
-    dma_instance.channels[1].read_request = dma.ChannelRequest.SPIFI_REQUEST
-    dma_instance.channels[1].read_ack = dma.ChannelAck.DISABLE
+    dma_instance = dma_config(openocd)
 
     if use_chip_erase:
         generic_flash.erase(openocd, generic_flash.EraseType.CHIP_ERASE)
@@ -440,99 +408,115 @@ def write_pages_by_sectors(pages: Dict[int, List[int]], openocd: OpenOcdTclRpc,
 
     openocd.halt()
     init(openocd)
+    # openocd.run("rwp")
 
     JEDEC_ID = send_command(
         openocd, 0x9F, Frameform.OPCODE_NOADDR, Fieldform.ALL_SERIAL, 3)
     print(f"JEDEC_ID {JEDEC_ID[0]:02x} {JEDEC_ID[1]:02x} {JEDEC_ID[2]:02x}")
 
+    dma_instance = dma_config(openocd)
+
     sectors_list = get_segments_list(list(pages), 4*1024)
 
     openocd.halt()
     pathname = os.path.dirname(sys.argv[0])
 
     # openocd.run("load_image {%s}" % pathlib.Path(os.path.join(pathname, "firmware.hex")))
-    openocd.run("rbp all")
     openocd.run("load_image {%s}" % pathlib.Path(
-        "C:\\Users\\user\\Documents\\PlatformIO\\Projects\\SPIFI_JTAG_driver\\.pio\\build\\mik32v2\\firmware.hex"))
-    openocd.run("bp 0x02002010 1 hw")
-    openocd.resume(0x02000000)
-    if wait_halted(openocd) != 0:
-        return 1
+        "C:\\Users\\user\\.platformio\\packages\\tool-mik32-uploader\\upload_drivers\\jtag_spifi\\.pio\\build\\mik32v2\\firmware.hex"
+        ))
+    
+    openocd.run("wp 0x2003000 4 w")
+    openocd.resume(0x2000000)
+    wait_halted(openocd)
+    openocd.halt()
 
     # spifi erase
-    for sector in sectors_list:
-        print(f"Erase sector {sector}", flush=True)
-        openocd.write_word(0x02002000, 0b0010 | (sector << 8))
-        openocd.resume()
-        if wait_halted(openocd) != 0:
-            return 1
-        print(
-            f"Erase sector {sector} result {openocd.read_word(0x02002008)}", flush=True)
-
-    return 1
+    #
+    # for sector in sectors_list:
+    #     print(f"Erase sector {sector}", flush=True)
+    #     openocd.write_word(0x02002000, 0b0010 | (sector << 8))
+    #     openocd.resume()
+    #     if wait_halted(openocd) != 0:
+    #         return 1
+    #     print(
+    #         f"Erase sector {sector} result {openocd.read_word(0x02002008)}", flush=True)
 
     # spifi erase check
-    for sector in sectors_list:
-        # print(f"Erase sector {sector}", flush=True)
-        # openocd.write_word(0x02002000, 0b0010 | sector)
-        # openocd.resume()
-        # if wait_halted(openocd) != 0:
-        #     return 1
-        # print(f"Erase sector {sector} result {openocd.read_word(0x02002008)}", flush=True)
+    #
+    # for sector in sectors_list:
+    #     # print(f"Erase sector {sector}", flush=True)
+    #     # openocd.write_word(0x02002000, 0b0010 | sector)
+    #     # openocd.resume()
+    #     # if wait_halted(openocd) != 0:
+    #     #     return 1
+    #     # print(f"Erase sector {sector} result {openocd.read_word(0x02002008)}", flush=True)
 
-        page_bytes = [0xff] * 256
+    #     page_bytes = [0xff] * 256
 
-        result = spifi_read_data(openocd, sector, 256, page_bytes)
+    #     result = spifi_read_data(openocd, sector, 256, page_bytes)
 
-        if result == 1:
-            print("Data error")
-            return result
+    #     if result == 1:
+    #         print("Data error")
+    #         return result
 
     for sector in sectors_list:
         print(f"Program sector {sector}", flush=True)
         bytes_list: List[int] = []
         for page in range(16):
-            page = pages.get(page * 256 + sector * 4096)
+            page = pages.get(page * 256 + sector)
             if page is not None:
                 bytes_list.extend(page)
             else:
                 bytes_list.extend([0]*256)
 
-        extend_value = 1 + sector
-        bytes_list.extend([(extend_value >> 0) & 0xFF, (extend_value >> 8)
-                          & 0xFF, (extend_value >> 16) & 0xFF, (extend_value >> 24) & 0xFF])
+        # extend_value = 1 + sector
+        # bytes_list.extend([(extend_value >> 0) & 0xFF, (extend_value >> 8)
+        #                   & 0xFF, (extend_value >> 16) & 0xFF, (extend_value >> 24) & 0xFF])
         # print(bytes_list)
 
-        while (openocd.read_word(0x0200200c) != 1):
-            openocd.resume()
-            openocd.halt()
+        openocd.write_memory(0x02002000, 8, bytes_list)
+        openocd.run(f"set_reg {{t6 {sector}}}")
+
+        openocd.resume()
+        wait_halted(openocd)
+        # openocd.halt()
+        print(f"Check page result {openocd.read_memory(0x2003000, 32, 1)}")
+
+        print(f"{datetime.datetime.now().time()} Program sector {sector} complete", flush=True)
+
+
+
+        # result = generic_flash.read_data(openocd, sector, 4096, bytes_list)
+
+        # for page in range(16):
+        #     page_bytes = pages.get(page * 256 + sector)
+        #     if page_bytes is not None:
+        #         result = generic_flash.read_data(
+        #             openocd, page * 256 + sector, 256, page_bytes, dma=dma_instance)
+
+        # if result == 1:
+        #     print("Data error")
+        #     return result
 
-        openocd.write_memory(0x02001000, 8, bytes_list)
-        while (openocd.read_word(0x0200200c) != 1):
-            openocd.resume()
-            openocd.halt()
-        time.sleep(0.5)
-        openocd.halt()
-        print(
-            f"Program sector {sector} result {openocd.read_word(0x02002008)}", flush=True)
 
     init_memory(openocd)
 
     # check write
-    pages_offsets = list(pages)
-    for index, page_offset in enumerate(pages_offsets):
-        page_bytes = pages[page_offset]
+    #
+    # pages_offsets = list(pages)
+    # for index, page_offset in enumerate(pages_offsets):
+    #     page_bytes = pages[page_offset]
 
-        memory_bytes = openocd.read_memory(page_offset + 0x80000000, 8, 256)
-        print(page_offset, memory_bytes)
+    #     memory_bytes = openocd.read_memory(page_offset + 0x80000000, 8, 256)
+    #     print(page_offset, memory_bytes)
 
-        for i, byte in enumerate(memory_bytes):
-            if byte != page_bytes[i]:
-                print("Data error!")
-                openocd.run("rbp 0x02002010")
-                return result
+    #     for i, byte in enumerate(memory_bytes):
+    #         if byte != page_bytes[i]:
+    #             print("Data error!")
+    #             openocd.run("rbp 0x02002010")
+    #             return result
 
-    openocd.run("rbp 0x02002010")
     if result == 0:
         # Прошивка страниц флеш памяти по SPIFI была завершена
         print("Flashing of flash memory pages via SPIFI has been completed", flush=True)