Merge branch 'feature/pull_request' into 'master'

Pull request

See merge request espressif/esp-serial-flasher!28

examples/common/example_common.c

@@ -85,7 +85,7 @@ void get_example_binaries(target_chip_t target, example_binaries_t *bins)
 
 #endif
 
-esp_loader_error_t connect_to_target(uint32_t higrer_baudrate)
+esp_loader_error_t connect_to_target(uint32_t higher_baudrate)
 {
     esp_loader_connect_args_t connect_config = ESP_LOADER_CONNECT_DEFAULT();
 
@@ -96,8 +96,8 @@ esp_loader_error_t connect_to_target(uint32_t higrer_baudrate)
     }
     printf("Connected to target\n");
 
-    if (higrer_baudrate && esp_loader_get_target() != ESP8266_CHIP) {
-        err = esp_loader_change_baudrate(higrer_baudrate);
+    if (higher_baudrate && esp_loader_get_target() != ESP8266_CHIP) {
+        err = esp_loader_change_baudrate(higher_baudrate);
         if (err == ESP_LOADER_ERROR_UNSUPPORTED_FUNC) {
             printf("ESP8266 does not support change baudrate command.");
             return err;
@@ -105,7 +105,7 @@ esp_loader_error_t connect_to_target(uint32_t higrer_baudrate)
             printf("Unable to change baud rate on target.");
             return err;
         } else {
-            err = loader_port_change_baudrate(higrer_baudrate);
+            err = loader_port_change_baudrate(higher_baudrate);
             if (err != ESP_LOADER_SUCCESS) {
                 printf("Unable to change baud rate.");
                 return err;

examples/esp32_example/main/main.c

@@ -32,7 +32,7 @@ void app_main(void)
         .gpio0_trigger_pin = GPIO_NUM_26,
     };
 
-    if ( loader_port_esp32_init(&config) != ESP_LOADER_SUCCESS) {
+    if (loader_port_esp32_init(&config) != ESP_LOADER_SUCCESS) {
         ESP_LOGE("example", "serial initialization failed.");
         return;
     }

port/esp32_port.c

@@ -31,8 +31,8 @@ static void dec_to_hex_str(const uint8_t dec, uint8_t hex_str[3])
         '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
     };
 
-    hex_str[0] = dec_to_hex[(dec >> 4)];
-    hex_str[1] = dec_to_hex[(dec & 0xF)];
+    hex_str[0] = dec_to_hex[dec >> 4];
+    hex_str[1] = dec_to_hex[dec & 0xF];
     hex_str[2] = '\0';
 }
 
@@ -117,7 +117,7 @@ esp_loader_error_t loader_port_serial_write(const uint8_t *data, uint16_t size,
 
     uart_write_bytes(s_uart_port, (const char *)data, size);
     esp_err_t err = uart_wait_tx_done(s_uart_port, pdMS_TO_TICKS(timeout));
-    
+
     if (err == ESP_OK) {
         return ESP_LOADER_SUCCESS;
     } else if (err == ESP_ERR_TIMEOUT) {
@@ -149,9 +149,7 @@ esp_loader_error_t loader_port_serial_read(uint8_t *data, uint16_t size, uint32_
 void loader_port_enter_bootloader(void)
 {
     gpio_set_level(s_gpio0_trigger_pin, 0);
-    gpio_set_level(s_reset_trigger_pin, 0);
-    loader_port_delay_ms(50);
-    gpio_set_level(s_reset_trigger_pin, 1);
+    loader_port_reset_target();
     loader_port_delay_ms(50);
     gpio_set_level(s_gpio0_trigger_pin, 1);
 }

private_include/serial_comm_prv.h

@@ -183,7 +183,7 @@ typedef struct __attribute__((packed))
     uint32_t sector_size;
     uint32_t page_size;
     uint32_t status_mask;
-} write_spi_command_t;  
+} write_spi_command_t;
 
 
 #ifdef __cplusplus

src/esp_loader.c

@@ -35,18 +35,6 @@ static const uint32_t DEFAULT_FLASH_TIMEOUT = 3000;       // timeout for most fl
 static const uint32_t ERASE_REGION_TIMEOUT_PER_MB = 10000; // timeout (per megabyte) for erasing a region
 static const uint8_t  PADDING_PATTERN = 0xFF;
 
-#define MEGABYTE  1024 * 1024
-
-size_t size_id_to_flash_size[] = {
-    MEGABYTE / 4,  // 256KB,
-    MEGABYTE / 2,  // 512KB,
-    1 * MEGABYTE,  // 1MB,
-    2 * MEGABYTE,  // 2MB,
-    4 * MEGABYTE,  // 4MB,
-    8 * MEGABYTE,  // 8MB,
-    16 * MEGABYTE  // 16MB
-};
-
 typedef enum {
     SPI_FLASH_READ_ID = 0x9F
 } spi_flash_cmd_t;
@@ -90,7 +78,7 @@ static inline void md5_final(uint8_t digets[16]) { }
 
 static uint32_t timeout_per_mb(uint32_t size_bytes, uint32_t time_per_mb)
 {
-    uint32_t timeout = ERASE_REGION_TIMEOUT_PER_MB * (size_bytes / 1e6);
+    uint32_t timeout = time_per_mb * (size_bytes / 1e6);
     return MAX(timeout, DEFAULT_FLASH_TIMEOUT);
 }
 
@@ -147,13 +135,9 @@ static esp_loader_error_t spi_set_data_lengths(size_t mosi_bits, size_t miso_bit
 
 static esp_loader_error_t spi_set_data_lengths_8266(size_t mosi_bits, size_t miso_bits)
 {
-    uint32_t mosi_bitlen_shift = 17;
-    uint32_t miso_bitlen_shift = 8;
     uint32_t mosi_mask = (mosi_bits == 0) ? 0 : mosi_bits - 1;
     uint32_t miso_mask = (miso_bits == 0) ? 0 : miso_bits - 1;
-    uint32_t usr_reg = (miso_mask << miso_bitlen_shift) | (mosi_mask << mosi_bitlen_shift);
-
-    return esp_loader_write_register(s_reg->usr1, usr_reg);
+    return esp_loader_write_register(s_reg->usr1, (miso_mask << 8) | (mosi_mask << 17));
 }
 
 static esp_loader_error_t spi_flash_command(spi_flash_cmd_t cmd, void *data_tx, size_t tx_size, void *data_rx, size_t rx_size)
@@ -196,7 +180,7 @@ static esp_loader_error_t spi_flash_command(spi_flash_cmd_t cmd, void *data_tx,
         RETURN_ON_ERROR( esp_loader_write_register(s_reg->w0, 0) );
     } else {
         uint32_t *data = (uint32_t *)data_tx;
-        uint32_t words_to_write = MIN((tx_size + 31) / 8 * 4, 1);
+        uint32_t words_to_write = (tx_size + 31) / (8 * 4);
         uint32_t data_reg_addr = s_reg->w0;
 
         while (words_to_write--) {
@@ -241,7 +225,7 @@ static esp_loader_error_t detect_flash_size(size_t *flash_size)
         return ESP_LOADER_ERROR_UNSUPPORTED_CHIP;
     }
 
-    *flash_size = size_id_to_flash_size[size_id - 0x12];
+    *flash_size = 1 << size_id;
 
     return ESP_LOADER_SUCCESS;
 }
@@ -251,8 +235,8 @@ esp_loader_error_t esp_loader_flash_start(uint32_t offset, uint32_t image_size,
     uint32_t blocks_to_write = (image_size + block_size - 1) / block_size;
     uint32_t erase_size = block_size * blocks_to_write;
     s_flash_write_size = block_size;
-    size_t flash_size = 0;
 
+    size_t flash_size = 0;
     if (detect_flash_size(&flash_size) == ESP_LOADER_SUCCESS) {
         if (image_size > flash_size) {
             return ESP_LOADER_ERROR_IMAGE_SIZE;
@@ -326,18 +310,13 @@ esp_loader_error_t esp_loader_change_baudrate(uint32_t baudrate)
 
 static void hexify(const uint8_t raw_md5[16], uint8_t hex_md5_out[32])
 {
-    uint8_t high_nibble, low_nibble;
-
     static const uint8_t dec_to_hex[] = {
         '0', '1', '2', '3', '4', '5', '6', '7',
         '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
     };
-
     for (int i = 0; i < 16; i++) {
-        high_nibble = (raw_md5[i] / 16);
-        low_nibble = (raw_md5[i] - (high_nibble * 16));
-        *hex_md5_out++ = dec_to_hex[high_nibble];
-        *hex_md5_out++ = dec_to_hex[low_nibble];
+        *hex_md5_out++ = dec_to_hex[raw_md5[i] >> 4];
+        *hex_md5_out++ = dec_to_hex[raw_md5[i] & 0xF];
     }
 }
 

src/serial_comm.c

@@ -56,7 +56,7 @@ static esp_loader_error_t SLIP_receive_data(uint8_t *buff, uint32_t size)
     uint8_t ch;
 
     for (int i = 0; i < size; i++) {
-        RETURN_ON_ERROR( serial_read(&ch, 1)) ;
+        RETURN_ON_ERROR( serial_read(&ch, 1) );
 
         if (ch == 0xDB) {
             RETURN_ON_ERROR( serial_read(&ch, 1) );
@@ -105,29 +105,33 @@ static esp_loader_error_t SLIP_receive_packet(uint8_t *buff, uint32_t size)
 
 static esp_loader_error_t SLIP_send(const uint8_t *data, uint32_t size)
 {
-    uint32_t to_write = 0;
-    uint32_t written = 0;
+    uint32_t to_write = 0;  // Bytes ready to write as they are
+    uint32_t written = 0;   // Bytes already written
 
     for (int i = 0; i < size; i++) {
         if (data[i] != 0xC0 && data[i] != 0xDB) {
-            to_write++;
+            to_write++; // Queue this byte for writing
             continue;
         }
 
+        // We have a byte that needs encoding, write the queue first
         if (to_write > 0) {
             RETURN_ON_ERROR( serial_write(&data[written], to_write) );
         }
 
+        // Write the encoded byte
         if (data[i] == 0xC0) {
             RETURN_ON_ERROR( serial_write(C0_REPLACEMENT, 2) );
         } else {
             RETURN_ON_ERROR( serial_write(DB_REPLACEMENT, 2) );
         }
 
+        // Update to start again after the encoded byte
         written = i + 1;
         to_write = 0;
     }
 
+    // Write the rest of the bytes that didn't need encoding
     if (to_write > 0) {
         RETURN_ON_ERROR( serial_write(&data[written], to_write) );
     }
@@ -239,13 +243,13 @@ esp_loader_error_t loader_flash_begin_cmd(uint32_t offset,
                                           uint32_t blocks_to_write,
                                           target_chip_t target)
 {
-    size_t encription = target == ESP32S2_CHIP ? 0 : sizeof(uint32_t);
+    size_t removeEncryption = target == ESP32S2_CHIP ? 0 : sizeof(uint32_t);
 
     begin_command_t begin_cmd = {
         .common = {
             .direction = WRITE_DIRECTION,
             .command = FLASH_BEGIN,
-            .size = CMD_SIZE(begin_cmd) - encription,
+            .size = CMD_SIZE(begin_cmd) - removeEncryption,
             .checksum = 0
         },
         .erase_size = erase_size,
@@ -257,8 +261,7 @@ esp_loader_error_t loader_flash_begin_cmd(uint32_t offset,
 
     s_sequence_number = 0;
 
-
-    return send_cmd(&begin_cmd, sizeof(begin_cmd) - encription, NULL);
+    return send_cmd(&begin_cmd.common, sizeof(begin_cmd) - removeEncryption, NULL);
 }