esp8266_flash.c

#include "main-header.h"
#include "espressif/esp8266_flash.h"
#include "espressif/esp8266_flash.h"
 
 
static int read_timeout = 12;   /* a read from serial port 'blocks' at most this amount of seconds */
static long started;            /* keep note of when we started reading from the port */
 
static int esp_flash_baud = 115200;
static void writebyte(byte b);
static void writebuf_escaped(const byte *buf, int len);
static void writebyte_escaped(const byte b);
static int read_response(struct espflash_response *response);
static int readbyte();
static void init_timer();
static byte is_timer_expired();
static int is_valid_response(struct espflash_response *response);
 
extern struct ringbuffer esp_ringbuffer;
/************************ HELPER ******************************/
/*
 * \brief send a packet (from C0 to C0). Escape bytes where necessary
 */
static void send_packet(const byte *buf) {
  int len = 1;
 
  while (buf[len] != 0xC0) {
    len++;
  }
  writebyte(0xC0);
  writebuf_escaped(buf + 1, len - 2);
  writebyte(0xC0);
}
 
 
static void writebyte(byte b) {
  write_serial_char(USART_ESP8266, b);
  //printf("FLASHDEBUG-ESP8266_TX: 0x%x (%i)\r\n",b,b);
}
 
static void writebuf_escaped(const byte *buf, int len) {
  int i;
 
  for (i = 0; i < len; i++) {
    writebyte_escaped(buf[i]);
  }
}
static void writebyte_escaped(const byte b) {
  if (b == 0xC0) {
    writebyte(0xDB);
    writebyte(0xDC);
  } else if (b == 0xDB) {
    writebyte(0xDB);
    writebyte(0xDD);
  } else {
    writebyte(b);
  }
}
 
static void write16bit_escaped(int num) {
  writebyte_escaped(num & 0xFF);
  writebyte_escaped((num >> 8) & 0xFF);
}
 
static void write32bit_escaped(long num) {
  writebyte_escaped(num & 0xFF);
  writebyte_escaped((num >> 8) & 0xFF);
  writebyte_escaped((num >> 16) & 0xFF);
  writebyte_escaped((num >> 24) & 0xFF);
}
 
/************************ BRIDGE ******************************/
/*
 * \brief bridge usb & wifi
 */
static void clear_serial_buf() {
  ringbuffer_init(&esp_ringbuffer);
}
void espflash_settimeout(const int timeo) {
  read_timeout = timeo;
}
 
/************************ SYNC ******************************/
/*
 * \brief sync esp flash romloader
 */
int espflash_sync() {
  struct espflash_response response;
  const byte syncbytes[] = { 0xC0, 0,    ESP_SYNC, 0x24, 0x07, 0x07, 0x12, 0x20,
                             0x55, 0x55, 0x55,     0x55, 0x55, 0x55, 0x55, 0x55,
                             0x55, 0x55, 0x55,     0x55, 0x55, 0x55, 0x55, 0x55,
                             0x55, 0x55, 0x55,     0x55, 0x55, 0x55, 0x55, 0x55,
                             0x55, 0x55, 0x55,     0x55, 0x55, 0x55, 0x55, 0x55,
                             0xC0 };
  int i;
  int res = 0;
  int max_attempts = 8;
 
  avoid_watchdog();
  printf("Esp8266 off...\r\n");
  mculib_pin_set(ESP8266_MCULIBHANDLE, PIN_ESP8266_CHPD, 0);
  mculib_pin_set(ESP8266_MCULIBHANDLE, PIN_ESP8266_GPIO0, 0);
  Delay(100);
  clear_serial_buf();
  printf("Esp8266 on...\r\n");
  mculib_pin_set(ESP8266_MCULIBHANDLE, PIN_ESP8266_CHPD, 1);
  //hard_reset_esp8266(WIFIMODE_FLASH);
  set_esp8266_usart_mode(ESP8266_USART_PASSTHROUGH);
  int baud = esp_flash_baud;
 
  //baud = 74880;
  if ((i = mculib_serialport_enable(ESP8266_MCULIBHANDLE, USART_ESP8266, baud))) {
    printf("Failed to enable serialport #%i: %i\r\n", USART_ESP8266, i);
    return 43;
  }
  printf("ESP8266 syncing @%i baud\r\n", baud);
  espflash_settimeout(2);
  // write_serial_char(USART_ESP8266,'\r');
  // write_serial_char(USART_ESP8266,'\n');
  avoid_watchdog();
 
  // stupid test:
  res = 1;
  if (res == 0) {
    // optional
    long started = 0;
    while (res < 10) {
      if (started != mculib_get_seconds_since_boot()) {
        send_packet(syncbytes);
        res++;
        started = mculib_get_seconds_since_boot();
        printf("Sent sync packet #%i\r\n", res);
      }
      i = ringbuffer_get_byte(&esp_ringbuffer);
      if (i != -1) {
        printf("Received: %i (0x%x)\r\n", i, i);
      }
    }
  }
  res = 59;
  // production...
  espflash_settimeout(1);
  for (i = 0; i < max_attempts; i++) {
    printf("sync %i of %i)\r\n", (i + 1), max_attempts);
    avoid_watchdog();
    send_packet(syncbytes);
    res = read_response(&response);
    if (res != 0) {
      printf("Failed to read response - error %i\r\n", res);
    } else {
      if (response.status != 0) {
        printf("Sync Response Status: %i\r\n", response.status);
        clear_serial_buf();
        //return 31;
        res = 31;
      } else {
        // it succeeded
        espflash_settimeout(10);
        printf("ESP8266 (or ESP32) synced @ %i baud\r\n", baud);
        return 0;
      }
    }
  }
  // it failed
  espflash_settimeout(10);
  if (res == 0) {
    Delay(50); // wait a bit in case esp sends more sync replies.
    clear_serial_buf();
  }
  return res;
}
 
/************************ READ RESPONSE ******************************/
/*
 * \brief read esp sync reader
 */
 
static int readbyte() {
  int esp;
 
  init_timer();
  while (((esp = ringbuffer_get_byte(&esp_ringbuffer)) >= 256) && (!is_timer_expired())) {
  }
  if (esp >= 256) {
    return -1;
  }
  return esp;
}
 
static int read_response(struct espflash_response *response) {
  int b;
 
  response->status = 172;
  b = 0;
  long srr = mculib_get_seconds_since_boot(); // start_read_response ;-)
 
  // read bytes until we hit 0xC0
  while (((b = readbyte()) != -1) && (b != 0xc0)) {
    if ((mculib_get_seconds_since_boot() - srr) > 10) {
      return 4;
    }
    //printf("Received: %i\r\n",(int)b);
  }
  if (b == -1) {
    return 8;
  }
  // we did read a 0xC0 which is either end of last packet or beginning of
  // a new packet.
  byte skipC0 = 1;
  byte pos = 0;
  byte *vb;
 
  for (;;) {
    avoid_watchdog();
    if ((mculib_get_seconds_since_boot() - srr) > (read_timeout * 5)) {
      return 6;
    }
    b = readbyte();
    if (b == -1) {
      printf("ESP8266-Flash: Whilst reading packet we got a timeout\r\n");
      printf("ESP8266-Flash: Read %i bytes so far. skipC0=%i\r\n", pos, skipC0);
      //timeout is always bad.
      return 2;
    }
    // ignore all leading 0xC0 and read until we find a non-0xC0 byte,
    // which then is definitely start of packet.
    if ((skipC0) && (b == 0xC0)) {
      continue;
    }
    skipC0 = 0; // no longer skip 0xC0's
    if (b == 0xC0) {
      // got end of packet!
      // check validity!
      if (!is_valid_response(response)) {
        return 7; // packet was invalid
      }
      return 0;
    }
 
    if (pos == 1) {
      response->command = b;
    } else if (pos == 2) {
      response->size = (b & 0xFF);                              // body-size
    } else if (pos == 3) {
      response->size = response->size | ((b & 0xFF) << 8);      // body-size
    } else if ((pos >= 4) && (pos <= 7)) {
      vb = (byte *)&response->value;
      vb[pos - 4] = (byte)(b & 0xff);
    } else if (pos == 8) {
      response->status = b;
    } else if (pos == 9) {
      response->error = b;
    } else {
      //return 10; // packet too long. weird.
    }
    pos++;
  }
  return 0;
}
 
static int wait_for_response(struct espflash_response *response, int command) {
  for (;;) {
    int res = read_response(response);
    if ((res == 0) && (response->command == command)) {
      return 0;
    }
    if (res != 0) {
      return res;
    }
  }
}
 
static int is_valid_response(struct espflash_response *response) {
  if (response == NULL) {
    return 0;
  }
  CNWDEBUG("Command: %i\n", response->command);
  if (response->command == ESP_SYNC) {
    response->status = 0;
    response->error = 0;
    return 1;
  }
  return 0;
}
 
/********************************************************************
 * timer helpers
 */
 
static byte is_timer_expired() {
  if ((mculib_get_seconds_since_boot() - started) >= read_timeout) {
    return 1;
  }
  return 0;
}
static void init_timer() {
  started = mculib_get_seconds_since_boot();
}
 
/*
 * \brief read a register, store result in *result
 *
 * return 0 if ok, otherwise errorcode
 */
int espflash_read_register(long regnum, long *result) {
  struct espflash_response response;
 
  clear_serial_buf();
  writebyte(0xC0);
  writebyte(0);
  writebyte(ESP_READ_REG);
  write16bit_escaped(4);        // length
  write32bit_escaped(0);        // no checksum here
  write32bit_escaped(regnum);
  writebyte(0xC0);
  int res = wait_for_response(&response, ESP_READ_REG);
 
  if ((res == 0) && (response.status != 0)) {
    printf("ESP8266 replied %i to read_reg()!\r\n", response.status);
    return 53;
  }
  void *x;
 
  x = (void *)response.value;
  printf("Read register value: %p\r\n", x);
  *result = response.value;
  return res;
}
 
int esp8266_flash_from_serialport() {
  return 0;
}
 
void espflash_set_baud(int baud) {
  esp_flash_baud = baud;
  printf("Flash baudrate set to %i\r\n", esp_flash_baud);
}
int espflash_finish() {
  struct espflash_response response;
  const byte finish[] = { 0xC0, 0, ESP_FLASH_END, 4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0xC0 };
 
  clear_serial_buf();
  send_packet(finish);
  int res = read_response(&response);
 
  if ((res == 0) && (response.command != ESP_FLASH_END)) {
    printf("We're confused. esp8266 replied with command %i to ESP_FLASH_END\r\n", response.command);
    return 36;
  }
  if ((res == 0) && (response.status != 0)) {
    printf("ESP8266 replied %i to flash finish()!\r\n", response.status);
    return 31;
  }
  return res;
}