userconfig.c

#include "main-header.h"
#include "userconfig.h"
 
struct user_config userconfiginram;
static uint32_t curpid;
static uint8_t max;
static uint8_t lastpos;
static uint32_t userconfig_calc_checksum(struct user_config *cfg) {
  return crc32(&cfg->userdata, cfg->validbytes);
}
 
static struct user_config *get_cfg() {
  struct user_config *cfg = get_flash_user_config_addr();
 
  if (cfg == NULL) {
    printf("[userconfig] warning - NO USERCONFIG FLASH SECTION (struct too big? %i bytes)!!!\r\n", sizeof(_user_config));
  }
  return cfg;
}
uint32_t userconfig_size() {
  struct user_config *cfg = get_cfg();
 
  if (cfg == NULL) {
    return 0;
  }
  uint32_t c = userconfig_calc_checksum(cfg);
 
  if (c != cfg->checksum) {
    printf("[userconfig] Invalid checksum\r\n");
    return 0;
  }
  return cfg->validbytes;
}
uint32_t userconfig_version() {
  struct user_config *cfg = get_cfg();
 
  if (cfg == NULL) {
    return 0;
  }
  return cfg->data_version;
}
 
int userconfig_copy(uint8_t *buf, uint16_t bufsize, uint16_t *actual_size) {
  struct user_config *cfg = get_cfg();
 
  if (cfg == NULL) {
    return 1;
  }
  if (cfg->validbytes > bufsize) {
    return 2;
  }
  int i;
 
  printf("[userconfig] copying userdata from userconfig at %p\r\n",cfg);
  for (i = 0; i < cfg->validbytes; i++) {
    buf[i] = cfg->userdata[i];
  }
  *actual_size = cfg->validbytes;
  return 0;
}
 
/*****************************************************************************
* flash update stuff
*****************************************************************************/
static int userconfig_receive_init(struct command *com) {
  lastpos = 0;
  userconfiginram.validbytes = 0;
  uint16_t r16;
  int r;
 
  if ((r = namedarg_uint16(com, "max", &r16)) != 0) {
    return 2;
  }
  max = (uint8_t)r16;
  if ((r = namedarg_uint32(com, "pid", &curpid)) != 0) {
    return 2;
  }
  return 1;
}
 
// receive a data update
static int userconfig_receive_data(struct command *com) {
  uint32_t pid;
  int r;
 
  if ((r = namedarg_uint32(com, "pid", &pid)) != 0) {
    return 2;
  }
  if (pid != curpid) {
    printf("[userconfig]: pid mismatch\r\n");
    return 2;
  }
  if ((r = namedarg_uint32(com, "pos", &pid)) != 0) {
    return 2;
  }
  if ((lastpos + 1) != ((uint8_t)pid)) {
    printf("[userconfig]: Pos out of sequence: %i vs %i\r\n", (uint32_t)lastpos, pid);
    return 2;
  }
  lastpos = pid;
  if ((r = namedarg_uint32(com, "size", &pid)) != 0) {
    printf("[userconfig]: missing size\r\n");
    return 2;
  }
  const char *data = namedarg(com, "data");
 
  if (data == NULL) {
    printf("[userconfig]: missing data\r\n");
    return 2;
  }
  const uint8_t *bytes = (const uint8_t *)data;
  uint32_t i;
  uint32_t j = userconfiginram.validbytes;
 
  if ((j + pid) > sizeof(userconfiginram.userdata)) {
    printf("[userconfig: too big (%i bytes does not fit into %i bytes buffer\r\n", (j + pid), sizeof(userconfiginram.userdata));
    return 2;
  }
  for (i = 0; i < pid; i++) {
    userconfiginram.userdata[j] = bytes[i];
    j++;
  }
  userconfiginram.validbytes = j;
  if (lastpos < max) {
    // not last packet just yet..
    return 1;
  }
 
  // close it up and flash it
  r = write_user_config_to_flash();
  if (r != 0) {
    return 2;
  }
  return 1;
}
// return (00==ok)
int userconfig_write(uint8_t *buf, uint32_t size) {
  if (size > sizeof(userconfiginram.userdata)) {
    printf("[userconfig]: buf too big (%i > %i)\r\n", size, sizeof(userconfiginram.userdata));
    return 5;
  }
  uint32_t i;
 
  for (i = 0; i < size; i++) {
    userconfiginram.userdata[i] = buf[i];
  }
  userconfiginram.validbytes = size;
  return write_user_config_to_flash();
}
 
// do crc and write to flash (return 0==ok)
int  write_user_config_to_flash() {
  int r;
  struct user_config *cfg = get_cfg();
 
  if (cfg == NULL) {
    return 2;
  }
  if (userconfiginram.validbytes == cfg->validbytes) {
    int i;
    int found = 0;
    for (i = 0; i < cfg->validbytes; i++) {
      if ((userconfiginram.userdata[i] != cfg->userdata[i])) {
        found = 1;
        break;
      }
    }
    if (found == 0) {
      printf("[userconfig] no change, not flashing\r\n");
      return 0;
    }
  }
  uint32_t size = sizeof(struct user_config);
 
  userconfiginram.checksum = userconfig_calc_checksum(&userconfiginram);
  userconfiginram.data_version = cfg->data_version + 1;
  if ((r = mculib_flash_unlock(MAIN_MCULIBHANDLE))) {
    printf("[userconfig]: Unlock flash failed: %i\r\n", r);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return 2;
  }
  if ((r = mculib_flash_erase(MAIN_MCULIBHANDLE, (void *)cfg, size + 4))) { // must erase 4 byte aligned. address calculatin in hw.c takes this into account
    printf("[userconfig]: Erase config failed: %i\r\n", r);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return 2;
  }
  printf("[userconfig]: writing in-ram copy to flash @ 0x%p (%i bytes)\r\n", (void *)cfg, size);
  if ((r = mculib_flash_write(MAIN_MCULIBHANDLE, (void *)&userconfiginram, (void *)cfg, size)) != 0) {
    printf("[userconfig]: Write config failed: %i\r\n", r);
    mculib_flash_lock(MAIN_MCULIBHANDLE);
    return 2;
  }
 
  mculib_flash_lock(MAIN_MCULIBHANDLE);
  printf("[userconfig]: Saved %i bytes to flash. Flash result: %i\r\n", size, r);
 
  return 0;
}
 
// send a section of the buf to server (0=ok, otherwise err)
static int send_userconfig_data(struct command *com, struct user_config *cfg, int cur, int offset, int size) {
  struct command *reply = alloc_command();
 
  if (reply == NULL) {
    return 1;
  }
  const uint8_t *base;
 
  base = (const uint8_t *)&cfg->userdata;
  base = base + offset;
  reply->target = com->sender;
  reply->index = com->index;
  reply->connid = com->connid;
  reply->com = com->com;
  reply->flags = COMFLAGS_DATA;
  command_add_arg(reply, "dseq=%i", cur);
  command_add_binary_arg(reply, size, base);
  send_command(reply);
  free_command(reply);
  return 0;
}
 
// send data to server
static int userconfig_send_data(struct command *com) {
  struct user_config *cfg = get_cfg();
 
  if (cfg == NULL) {
    return 2;
  }
 
  struct command *reply = alloc_command();
 
  if (reply == NULL) {
    return 2;
  }
  int tblen = userconfig_size();
  int tvers = userconfig_version();
 
  printf("[userconfig] sending %i bytes (version %i)\r\n", tblen, tvers);
  int tcoms = 0;
  int cur = 0;
  int offset = 0;
 
  for (;;) {
    if (offset >= tblen) {
      break;
    }
    int size = 128;
    if (offset + size > tblen) {
      size = tblen - offset;
    }
    send_userconfig_data(com, cfg, cur, offset, size);
    tcoms++;
    offset = offset + size;
  }
  reply->target = com->sender;
  reply->index = com->index;
  reply->connid = com->connid;
  reply->com = com->com;
  reply->flags = COMFLAGS_ACK;
  command_add_arg(reply, "total_bytes=%i", tblen);
  command_add_arg(reply, "total_coms=%i", tcoms);
  command_add_arg(reply, "version=%i", tvers);
  command_add_arg(reply, "chk=%p", cfg->checksum);
  deliver_command(reply, NULL);
  printf("[userconfig] sent %i bytes in %i commands\r\n", tblen, tcoms);
  return 0;
}
 
/*
 * brief receive a partial update
 * return 1 for successfull ack, 2 for unsuccessful
 */
int userconfig_receive(struct command *com) {
  uint32_t t;
  int r = namedarg_uint32(com, "ucr", &t);
 
  if (r != 0) {
    return 2;
  }
  if (t == 1) {
    return userconfig_receive_init(com);
  } else if (t == 2) {
    return userconfig_receive_data(com);
  } else if (t == 3) {
    return userconfig_send_data(com); //send data to server
  }
  return 2;
}