Fix lost serial bytes during flash operations

-Keep interrupts enabled during flash operations
-Shortened I2C ISR

Author: gerargz

source/board/microbitv2/microbitv2.c

@@ -40,7 +40,7 @@
 #include "virtual_fs.h"
 #include "vfs_manager.h"
 #include "cortex_m.h"
-#include "FlashPrg.h"
+#include "fsl_flash.h"
 
 #ifdef DRAG_N_DROP_SUPPORT
 #include "flash_intf.h"
@@ -90,6 +90,7 @@ extern target_cfg_t target_device_nrf52_64;
 extern main_usb_connect_t usb_state;
 extern bool go_to_sleep;
 extern i2c_slave_handle_t g_s_handle;
+extern flash_config_t g_flash;
 
 typedef enum main_shutdown_state {
     MAIN_SHUTDOWN_WAITING = 0,
@@ -762,11 +763,33 @@ static bool file_extension_allowed(const vfs_filename_t  filename)
     return false;
 }
 
+static uint32_t erase_storage_sector(uint32_t adr)
+{
+    int status = FLASH_Erase(&g_flash, adr, g_flash.PFlashSectorSize, kFLASH_apiEraseKey);
+    if (status == kStatus_Success)
+    {
+        status = FLASH_VerifyErase(&g_flash, adr, g_flash.PFlashSectorSize, kFLASH_marginValueNormal);
+    }
+    return status;
+}
+
+static uint32_t program_storage_page(uint32_t adr, uint32_t sz, uint32_t *buf)
+{
+    int status = FLASH_Program(&g_flash, adr, buf, sz);
+    if (status == kStatus_Success)
+    {
+        // Must use kFlashMargin_User, or kFlashMargin_Factory for verify program
+        status = FLASH_VerifyProgram(&g_flash, adr, sz,
+                              buf, kFLASH_marginValueUser,
+                              NULL, NULL);
+    }
+    return status;
+}
+
 static void i2c_write_flash_callback(uint8_t* pData, uint8_t size) {
     i2cFlashCmd_t* pI2cCommand = (i2cFlashCmd_t*) pData;
 
     uint32_t status = 0;
-    cortex_int_state_t state;
 
     uint32_t storage_address = pI2cCommand->cmdData.write.addr2 << 16 |
                             pI2cCommand->cmdData.write.addr1 << 8 |
@@ -781,10 +804,8 @@ static void i2c_write_flash_callback(uint8_t* pData, uint8_t size) {
         case gFlashDataWrite_c:
             /* Validate length field matches with I2C Write data */
             if (size == length + 8) { 
-                /* Address range and alignment validation done inside ProgramPage() */
-                state = cortex_int_get_and_disable();
-                status = ProgramPage(address, length, (uint32_t *) data);
-                cortex_int_restore(state);
+                /* Address range and alignment validation done inside program_storage_page() */
+                status = program_storage_page(address, length, (uint32_t *) data);
 
                 if (0 != status) {
                     pI2cCommand->cmdId = gFlashError_c;
@@ -832,9 +853,7 @@ static void i2c_write_flash_callback(uint8_t* pData, uint8_t size) {
                 start_addr < (FLASH_CONFIG_ADDRESS + FLASH_INTERFACE_SIZE) &&
                 end_addr < (FLASH_CONFIG_ADDRESS + FLASH_INTERFACE_SIZE)) {
                 for (uint32_t addr = start_addr; addr <= end_addr && status == 0; addr += DAPLINK_SECTOR_SIZE) {
-                    state = cortex_int_get_and_disable();
-                    status = EraseSector(addr);
-                    cortex_int_restore(state);
+                    status = erase_storage_sector(addr);
                 }
 
                 if (status != 0) {
@@ -925,26 +944,20 @@ static void i2c_write_flash_callback(uint8_t* pData, uint8_t size) {
             // Check first is config is already present in flash
             // If differences are found, erase and write new config
             if (0 != memcmp(&gflashConfig, (void *)FLASH_CONFIG_ADDRESS, sizeof(flashConfig_t))) {
-                state = cortex_int_get_and_disable();
-                status = EraseSector(FLASH_CONFIG_ADDRESS);
-                cortex_int_restore(state);
+                status = erase_storage_sector(FLASH_CONFIG_ADDRESS);
 
                 if (status != 0) {
                     pI2cCommand->cmdId = gFlashError_c;
                 }
                 else {
-                    state = cortex_int_get_and_disable();
-                    status = ProgramPage(FLASH_CONFIG_ADDRESS, sizeof(flashConfig_t), (uint32_t *) &gflashConfig);
-                    cortex_int_restore(state);
+                    status = program_storage_page(FLASH_CONFIG_ADDRESS, sizeof(flashConfig_t), (uint32_t *) &gflashConfig);
                 }
             }
             i2c_fillBuffer((uint8_t*) pI2cCommand, 0, 1);
         break;
         case gFlashCfgErase_c:
             // Erase flash sector containing flash config
-            state = cortex_int_get_and_disable();
-            status = EraseSector(FLASH_CONFIG_ADDRESS);
-            cortex_int_restore(state);
+            status = erase_storage_sector(FLASH_CONFIG_ADDRESS);
 
             if (status != 0) {
                 pI2cCommand->cmdId = gFlashError_c;

source/daplink/interface/main.c

@@ -53,6 +53,7 @@
 // Reset events
 #define FLAGS_MAIN_RESET        (1 << 2)
 // Other Events
+#define FLAGS_BOARD_EVENT       (1 << 3)
 #define FLAGS_MAIN_POWERDOWN    (1 << 4)
 #define FLAGS_MAIN_DISABLEDEBUG (1 << 5)
 #define FLAGS_MAIN_PROC_USB     (1 << 9)
@@ -133,6 +134,11 @@ __WEAK void board_handle_powerdown()
     // TODO: put the interface chip in sleep mode
 }
 
+__WEAK void board_custom_event()
+{
+
+}
+
 // Timer task, set flags every 30mS and 90mS
 void timer_task_30mS(void * arg)
 {
@@ -182,6 +188,13 @@ void main_powerdown_event(void)
     return;
 }
 
+// Set custom board event
+void main_board_event(void)
+{
+    osThreadFlagsSet(main_task_id, FLAGS_BOARD_EVENT);
+    return;
+}
+
 // Disable debug on target
 void main_disable_debug_event(void)
 {
@@ -285,6 +298,7 @@ void main_task(void * arg)
                        | FLAGS_MAIN_DISABLEDEBUG    // Disable target debug
                        | FLAGS_MAIN_PROC_USB        // process usb events
                        | FLAGS_MAIN_CDC_EVENT       // cdc event
+                       | FLAGS_BOARD_EVENT          // custom board event
                        , osFlagsWaitAny
                        , osWaitForever);
 
@@ -324,6 +338,10 @@ void main_task(void * arg)
         if (flags & FLAGS_MAIN_CDC_EVENT) {
             cdc_process_event();
         }
+        
+        if (flags & FLAGS_BOARD_EVENT) {
+            board_custom_event();
+        }
 
         if (flags & FLAGS_MAIN_90MS) {
             // Update USB busy status

source/daplink/interface/main.h

@@ -48,6 +48,7 @@ extern "C" {
 void main_reset_target(uint8_t send_unique_id);
 void main_usb_set_test_mode(bool enabled);
 void main_powerdown_event(void);
+void main_board_event(void);
 void main_disable_debug_event(void);
 void main_cdc_send_event(void);
 void main_msc_disconnect_event(void);

source/hic_hal/freescale/kl27z/i2c.c

@@ -3,6 +3,7 @@
 #include "fsl_clock.h"
 #include "fsl_port.h"
 #include "settings.h" // for config_get_overflow_detect
+#include "main.h"
 
 /* I2C source clock */
 #define I2C_SLAVE_BASEADDR I2C1
@@ -13,21 +14,17 @@
 #define I2C_SLAVE_UPPER_ADDR_7BIT   (0x72U)
 #define I2C_DATA_LENGTH             (1024U + 8U)
 
-// We'll start with 5 RX commands
-#define RX_CMDS_LENGTH              5
-#define I2C_CMD_SLEEP               0xABU
 
 static uint8_t g_slave_TX_buff[I2C_DATA_LENGTH];
 static uint8_t g_slave_RX_buff[I2C_DATA_LENGTH];
 i2c_slave_handle_t g_s_handle;
 static volatile bool g_SlaveCompletionFlag = false;
 static volatile bool g_SlaveRxFlag = false;
-uint8_t address_match = 0;
+static uint8_t address_match = 0;
+static uint32_t transferredCount = 0;
 
 static i2cWriteCallback_t pfWriteCommsCallback = NULL;
 static i2cReadCallback_t pfReadCommsCallback = NULL;
-static i2cWriteCallback_t pfWriteHIDCallback = NULL;
-static i2cReadCallback_t pfReadHIDCallback = NULL;
 static i2cWriteCallback_t pfWriteFlashCallback = NULL;
 static i2cReadCallback_t pfReadFlashCallback = NULL;
 
@@ -46,6 +43,7 @@ static void i2c_slave_callback(I2C_Type *base, i2c_slave_transfer_t *xfer, void
             /*  Update information for transmit process */
             xfer->data     = g_slave_TX_buff;
             xfer->dataSize = I2C_DATA_LENGTH;
+            g_SlaveRxFlag = false;
             break;
 
         /*  Receive request */
@@ -65,32 +63,12 @@ static void i2c_slave_callback(I2C_Type *base, i2c_slave_transfer_t *xfer, void
             g_SlaveCompletionFlag = true;
             xfer->data            = NULL;
             xfer->dataSize        = 0;
+            transferredCount = xfer->transferredCount;
 
             // Default driver couldn't differentiate between RX or TX completion
             // Check flag set in kI2C_SlaveReceiveEvent
-            if (g_SlaveRxFlag) {
-                g_SlaveRxFlag = false;
-                
-                if (pfWriteCommsCallback && address_match == I2C_SLAVE_NRF_KL_COMMS) {
-                    pfWriteCommsCallback(&g_slave_RX_buff[0], xfer->transferredCount);
-                }
-                if (pfWriteHIDCallback && address_match == I2C_SLAVE_HID) {
-                    pfWriteHIDCallback(&g_slave_RX_buff[0], xfer->transferredCount);
-                }
-                if (pfWriteFlashCallback && address_match == I2C_SLAVE_FLASH) {
-                    pfWriteFlashCallback(&g_slave_RX_buff[0], xfer->transferredCount);
-                }
-            } else { 
-                if (pfReadCommsCallback && address_match == I2C_SLAVE_NRF_KL_COMMS) {
-                    pfReadCommsCallback(&g_slave_TX_buff[0], xfer->transferredCount);
-                }
-                if (pfReadHIDCallback && address_match == I2C_SLAVE_HID) {
-                    pfReadHIDCallback(&g_slave_TX_buff[0], xfer->transferredCount);
-                }
-                if (pfReadFlashCallback && address_match == I2C_SLAVE_FLASH) {
-                    pfReadFlashCallback(&g_slave_TX_buff[0], xfer->transferredCount);
-                }
-            }
+
+            main_board_event();
             break;
 
         default:
@@ -99,6 +77,25 @@ static void i2c_slave_callback(I2C_Type *base, i2c_slave_transfer_t *xfer, void
     }
 }
 
+void board_custom_event() {
+    
+    if (g_SlaveRxFlag) {
+        if (pfWriteCommsCallback && address_match == I2C_SLAVE_NRF_KL_COMMS) {
+            pfWriteCommsCallback(&g_slave_RX_buff[0], transferredCount);
+        }
+        if (pfWriteFlashCallback && address_match == I2C_SLAVE_FLASH) {
+            pfWriteFlashCallback(&g_slave_RX_buff[0], transferredCount);
+        }
+    } else { 
+        if (pfReadCommsCallback && address_match == I2C_SLAVE_NRF_KL_COMMS) {
+            pfReadCommsCallback(&g_slave_TX_buff[0], transferredCount);
+        }
+        if (pfReadFlashCallback && address_match == I2C_SLAVE_FLASH) {
+            pfReadFlashCallback(&g_slave_TX_buff[0], transferredCount);
+        }
+    }
+}
+
 static void i2c_init_pins(void) {
     /* Port C Clock Gate Control: Clock enabled */
     CLOCK_EnableClock(kCLOCK_PortC);
@@ -173,7 +170,6 @@ status_t i2c_RegisterWriteCallback(i2cWriteCallback_t writeCallback, uint8_t sla
             pfWriteCommsCallback = writeCallback;
             break;
         case I2C_SLAVE_HID:
-            pfWriteHIDCallback = writeCallback;
             break;
         case I2C_SLAVE_FLASH:
             pfWriteFlashCallback = writeCallback;
@@ -195,7 +191,6 @@ status_t i2c_RegisterReadCallback(i2cReadCallback_t readCallback, uint8_t slaveA
             pfReadCommsCallback = readCallback;
             break;
         case I2C_SLAVE_HID:
-            pfReadHIDCallback = readCallback;
             break;
         case I2C_SLAVE_FLASH:
             pfReadFlashCallback = readCallback;