Fixed bug where back-to-back invocations of blisp would fail

Author: Pavlos1

include/blisp.h

@@ -16,6 +16,7 @@ struct blisp_segment_header {
 struct blisp_device {
   struct blisp_chip* chip;
   void* serial_port;
+  uint32_t serial_timeout; // in ms
   bool is_usb;
   uint32_t current_baud_rate;
   uint8_t rx_buffer[5000];  // TODO:

lib/blisp.c

@@ -26,6 +26,16 @@ blisp_return_t blisp_device_init(struct blisp_device* device,
   device->chip = chip;
   device->is_usb = false;
   fill_crcs(&bl808_header);
+
+  if (device->chip->type == BLISP_CHIP_BL808) {
+    // TODO: For some reason the BL808 does not send pending ('PD') responses
+    //       during long (i.e. erase) operations, so we must disable response
+    //       timeouts. Further investigation is necessary.
+    device->serial_timeout = 0;
+  } else {
+    device->serial_timeout = 1000;
+  }
+
   return BLISP_OK;
 }
 
@@ -145,16 +155,9 @@ blisp_return_t blisp_receive_response(struct blisp_device* device,
                                       bool expect_payload) {
   // TODO: Check checksum
   int ret;
-  uint32_t read_timeout = 1000;
-  if (device->chip->type == BLISP_CHIP_BL808) {
-    // TODO: For some reason the BL808 does not send pending ('PD') responses
-    //       during long (i.e. erase) operations, so we must disable response
-    //       timeouts. Further investigation is necessary.
-    read_timeout = 0;  
-  }
 
   struct sp_port* serial_port = device->serial_port;
-  ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, read_timeout);
+  ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, device->serial_timeout);
   if (ret < 2) {
     blisp_dlog("Failed to receive response, ret: %d", ret);
     return BLISP_ERR_NO_RESPONSE;

tools/blisp/src/common.c

@@ -67,19 +67,41 @@ blisp_return_t blisp_common_init_device(struct blisp_device* device,
  */
 blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
   blisp_return_t ret = 0;
-
-  printf("Sending a handshake...\n");
-  ret = blisp_device_handshake(device, false);
-  if (ret != BLISP_OK) {
-    fprintf(stderr, "Failed to handshake with device, ret: %d\n", ret);
-    return ret;
-  }
-  printf("Handshake successful!\nGetting chip info...\n");
+  uint32_t previous_timeout;
   struct blisp_boot_info boot_info;
+
+  // We may already be in communication with the chip from a previous
+  // invocation of this command. In that case, it will not respond to our
+  // handshake. We detect this by trying to send a command to it, using a
+  // (relatively) short timeout.
+  //
+  // NOTE: This appears to be how BouffaloLab software does it as well.
+  //
+  // NOTE: Modifying the timeout is mandatory for BL808;
+  //       see blisp.c:blisp_device_init()
+  previous_timeout = device->serial_timeout;
+  device->serial_timeout = 500;
+  printf("Testing if we can skip the handshake...\n");
   ret = blisp_device_get_boot_info(device, &boot_info);
-  if (ret != BLISP_OK) {
-    fprintf(stderr, "Failed to get boot info, ret: %d\n", ret);
-    return ret;
+  device->serial_timeout = previous_timeout;
+
+  if (ret == BLISP_OK) {
+    printf("Skipping handshake!\n");
+  } else {
+    printf("We can't; ignore the previous error.\n");
+    printf("Sending a handshake...\n");
+    ret = blisp_device_handshake(device, false);
+    if (ret != BLISP_OK) {
+      fprintf(stderr, "Failed to handshake with device, ret: %d\n", ret);
+      return ret;
+    }
+
+    printf("Handshake successful!\nGetting chip info...\n");
+    ret = blisp_device_get_boot_info(device, &boot_info);
+    if (ret != BLISP_OK) {
+      fprintf(stderr, "Failed to get boot info, ret: %d\n", ret);
+      return ret;
+    }
   }
 
   // TODO: Do we want this to print in big endian to match the output