Style changes

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);
 }

src/esp_loader.c

@@ -147,13 +147,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)
@@ -251,8 +247,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 +322,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

@@ -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);
 }