flashapp.c

Go to the documentation of this file.

#include "flashapp.h"
#include "led.h"
#include "app_update.h"
#include "user_app_exe.h"
static char errbuf[80];
static uint8_t flashloader;
static byte flashbuf[512];
static int offset = 0;
static byte flashmode = 0;
static void *baseadr;
static uint32_t f_flags = 0;
 
const struct consumerinfo flashconsumerinfo = { &flash_app_consumer, &flash_app_close };
 
static void flash_start() {
  led_indicate(LED_FLASHSTART);
}
static void flash_end() {
  led_indicate(LED_FLASHEND);
}
static int comparemem(byte *adr1, byte *adr2, int size) {
  int i;
 
  for (i = 0; i < size; i++) {
    if (*adr1++ != *adr2++) {
      return 0;
    }
  }
  return 1;
}
 
static void set_new_userapp(int streamfd, void *baseaddr) {
  if (userapp_checksum_valid(baseadr)) {
    printf("[flashapp] Set new userapp to %p\r\n", baseadr);
    config_set_userapp((int32_t)baseadr);
    return;
  }
  struct userapp_info *uai = baseadr;
 
  if (uai->magic != 0x53435541) {
    stream_seterror(streamfd, "[flashapp] not setting new userapp, invalid magic %p\r\n", uai->magic);
    return;
  }
  uint32_t checksum = calc_crc32((void *)uai, uai->length, 8);
 
  stream_seterror(streamfd, "[flashapp] Not setting new userapp to %p (checksum error). Calculated: %p, Expected: %p (length=%i)\r\n", baseadr, checksum, uai->checksum, uai->length);
}
 
void flash_debug() {
  baseadr = (void *)0x08034800;
  flash_app_close(1, 77);
}
int flash_app_close(int fd, int reason) {
  if (reason != 0) {
    goto no_activate;
  }
 
  if (f_flags & (1 << FLASH_FLAGS_SET_LATEST_USERAPP)) {
    set_new_userapp(fd, baseadr);
    invoke_stop();
    user_app_exe_init(); // re-init
  }
  if (f_flags & (1 << FLASH_FLAGS_START_USERAPP)) {
    user_app_enable(); // enable userapp. after we finished flashing, it makes sense to try the userapp again
  }
  if ((f_flags & (1 << FLASH_FLAGS_USE_DIRECT_WRITE)) == 0) {
    mculib_flash_lock(MAIN_MCULIBHANDLE);
  }
  // if flags has not been set, OR flag bit has been set:
  if ((f_flags == 0) || (f_flags & (1 << FLASH_FLAGS_SET_LATEST_APP))) {
    if (flashloader == 0) {
      struct app_header *ah = baseadr;
      if (ah->magic == 0x53434657) {
        set_latest_app(baseadr);
      }
    }
  }
 
no_activate:
  flash_end();
  printf("[flashapp] Flash closed (fd=%i,reason=%i,flags=%i)\r\n", fd, reason, f_flags);
  return 0;
}
 
 
int flash_app_consumer(int streamfd, byte *b, int size) {
  int r;
 
  r = 0;
 
  // do some real work
 
  // get size and check base
  if (offset == 0) {
    flash_start();
    if (!flashloader) {
      struct app_header *header = (struct app_header *)b;
      if (header->base != ((uint32_t)baseadr)) {
        stream_seterror(streamfd, "[flashapp] Base mismatch. Expected %p and got %p", baseadr, header->base);
        flash_end();
        return 101;
      }
    }
  }
  if (flashmode == 5) {
    stream_seterror(streamfd, "[flashapp] Flash failed - previous block was padded");
    flash_end();
    return 82;
  }
  if (size < sizeof(flashbuf)) {
    size = sizeof(flashbuf);
    flashmode = 5;
  }
 
  // simple retry mechanism
  int retries = 0;
 
  for (;;) {
    retries++;
    if ((r = flash_write(b, baseadr + offset, size))) {
      if (retries > 3) {
        stream_seterror(streamfd, "%s", errbuf);
        goto fail;
      }
    } else {
      break;
    }
  }
  printf("[flashapp] written from %i to %i at %p\r\n", offset, offset + size, baseadr + offset);
  offset = offset + size;
  flash_end();
  return 0;
fail:
  flash_end();
  return r;
}
 
int flash_write(byte *b, void *adr, int size) {
  int r;
 
  // if direct access, just copy the bytes
  if ((f_flags & (1 << FLASH_FLAGS_USE_DIRECT_WRITE)) != 0) {
    byte *target = (byte *)adr;
    for (r = 0; r < size; r++) {
      target[r] = b[r];
    }
    return 0;
  }
 
 
  // write to flash
  if (comparemem(b, adr, size)) {
    // only execute if actually different.
    // otherwise just return sucessfully
    printf("[flashapp] %i bytes @ %p optimized out, bytes identical\r\n", size, adr);
    return 0;
  }
  mculib_flash_lock(MAIN_MCULIBHANDLE);
  if ((r = mculib_flash_unlock(MAIN_MCULIBHANDLE))) {
    snprintf(errbuf, sizeof(errbuf), "[flashapp] unlock failed (%i)\r\n", r);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return r;
  }
  if ((f_flags & (1 << FLASH_FLAGS_PRE_ERASE)) == 0) {
    if ((r = mculib_flash_erase(MAIN_MCULIBHANDLE, adr, size))) {
      snprintf(errbuf, sizeof(errbuf), "[flashapp] erase failed (%i)\r\n", r);
      mculib_flash_lock(MAIN_MCULIBHANDLE);
      return r;
    }
  }
  if ((f_flags & (1 << FLASH_FLAGS_WRITE_OLD))) {
    r = mculib_flash_write(MAIN_MCULIBHANDLE, b, adr, size);
  } else {
    // page is faster, but not tested as well yet - 8/1/2022 cnw
    r = mculib_flash_write_page(MAIN_MCULIBHANDLE, b, adr, size);
  }
  mculib_flash_lock(MAIN_MCULIBHANDLE);
  if (r) {
    snprintf(errbuf, sizeof(errbuf), "[flashapp] write failure at address %p (%i bytes): %i\r\n", adr, size, r);
    return r;
  }
  printf("[flashapp] written %i bytes @ %p\n", size, adr);
  return 0;
}
 
// init for an incoming flash (called before 1st flash_app_consumer)
// also used by usb
int flash_app_init(void *base, uint32_t flags) {
  printf("[flashapp] init, base=%p, flags=%i\r\n", base, flags);
  f_flags = flags;
  offset = 0;
  flashmode = 0;
  baseadr = base;
  if (f_flags & (1 << FLASH_FLAGS_STOP_USERAPP)) {
    user_app_disable(); // disable userapp
  }
  return 0;
}
static void flash_action_not_supported(struct command *com, int errno) {
  send_command_reply_with_args(com, COMFLAGS_ACK, "errno=%i", errno);
}
void flashcom(struct command *com) {
  const char *para;
  struct command *data = NULL;
 
  errbuf[0] = 0; // clear, we use it later in fail function
  int bases = loader_get_app_base_address_count();
  int i;
  int fd;
 
  int ec = 0;
  void *writeto = NULL;
  uint32_t flags = 0;
 
  flashloader = 0;
 
  if ((para = namedarg(com, "action")) != NULL) {       // it is a new modern "action" command
    return flash_action_not_supported(com, 1);          // 1 indicates "not supported"
  }
  if ((para = namedarg(com, "flags")) != NULL) {        // para flags?
    flags = atoi(para);
  }
 
  // NEWER method: we allow the server to set a base.
  if ((para = namedarg(com, "base")) != NULL) { // did server specify base?
    long base = ascii_parse_hex((const byte *)para, strlen(para), NULL);
    if (base == 0) {
      ec = 6;
      goto fail;
    }
    if ((void *)base == get_app_header()) {
      ec = 7;
      goto fail;
    }
    writeto = (void *)base;
    if ((para = namedarg(com, "lf")) != NULL) { // para lf? if so we're special, trying to write loader
      flashloader = 1;
      printf("[flashapp] Update loader enabled (2)\r\n");
    }
    goto got_base;
  }
 
 
  // CURRENT method: we work out a base that suits us (and expect the binary to match)
 
  if ((para = namedarg(com, "lf")) != NULL) { // para lf? if so we're special, trying to write loader
    flashloader = 1;
    printf("[flashapp] Update loader enabled\r\n");
    writeto = (void *)0x8000000;
    goto got_base;
  }
 
 
 
  printf("[flashapp] Got %i base addresses\r\n", bases);
  for (i = 0; i < bases; i++) {
    void *optadr = loader_get_app_base_address(i);
    printf("[flashapp] %i. baseaddress = %p\r\n", i, optadr);
    if ((optadr != NULL) && (optadr != get_app_header())) {
      writeto = optadr;
      break;
    }
  }
  if (writeto == NULL) {
    printf("[flashapp] No baseaddress for flash!\n");
    ec = 1;
    goto fail;
  }
 
 
got_base:
  printf("[flashapp] Expecting flash at address 0x%p\r\n", writeto);
  flash_app_init(writeto, flags);
  // writeto is now the best address to write to
  if ((para = namedarg(com, "fd")) == NULL) {
    ec = 2;
    goto fail;
  }
  fd = atoi(para);
  // associate this consumer with the stream and provide a buffer to the stream
  int er = stream_associate(fd, &flashconsumerinfo, (byte *)&flashbuf, sizeof(flashbuf), 512);
 
  if (er != 0) {
    printf("[flashapp] Failed to associate stream with flash (%i)\r\n", er);
    ec = 3;
    goto fail;
  }
  data = get_data_reply(com);
  if (data == NULL) {
    printf("[flashapp] failed to alloc command\r\n");
    ec = 4;
    goto fail;
  }
  struct app_header *ap = (struct app_header *)writeto;
 
  command_add_arg(data, "base=%p", writeto);
  command_add_arg(data, "version=%i", ap->version);
  if (send_command(data) != 0) {
    printf("[flashapp] Failed to send flash data to sender\r\n");
    ec = 5;
    goto fail;
  }
 
  if (data != NULL) {
    free_command(data);
  }
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
  printf("[flashapp] Flash setup ok (base=%p)\r\n", writeto);
  return;
fail:
  printf("[flashapp] Flash setup failed (%i)\r\n", ec);
  if (data != NULL) {
    free_command(data);
  }
  char e[100];
  char e2[200];
 
  snprintf(e, 99, "err=%i", ec);
  snprintf(e2, 100, "em=%s", errbuf);
  send_command_reply_with_args(com, COMFLAGS_ACK, e, e2);
}