partitions.c

#include "partitions.h"
#include "flashapp.h"
 
extern uint32_t app_base;
 
// return 0 if valid
static int check_partition(struct partition *p) {
  if (p->magic != PART_MAGIC) {
    printf("Partition at %p has invalid magic\r\n", p);
    return 1;
  }
  if (p->layout_version != 1) {
    printf("Partition at %p has invalid layout_version %i\r\n", p, p->layout_version);
    return 2;
  }
  uint32_t crc = calc_crc32((void *)p, sizeof(struct partition), 4);
 
  if (crc != p->crc) {
    printf("Partition at %p has invalid checksum. Stored=%i,Calc=%i\r\n", p, p->crc, crc);
    return 3;
  }
  printf("Partition at %p is valid (sequence %i)\r\n", p, p->part_seq);
  return 0;
}
 
// if partitions exit, do nothing, otherwise create one partition and make this app default in that partition
void partition_init() {
  int i = check_partition((void *)PARTITION_BASE);
 
  if (i == 0) {
    return;
  }
  i = check_partition((void *)PARTITION_BASE + 1024);
  if (i == 0) {
    return;
  }
  printf("Creating partition...\r\n");
  uint8_t buf[1024];
 
  memset(buf, 0, 1024);
  struct partition *np = (void *)&buf;
 
  np->magic = PART_MAGIC;
  np->layout_version = 1;
  np->part_seq = 1;
  struct appdef *ap = &np->appdefs;
 
  ap->size = sizeof(struct appdef);
  ap->app_header = (uint32_t)&app_base; // my base address, defined in linker script
  ap->app_seq = 1;
  // endmarker
  ap = ap + ap->size;
  ap->size = 0;
 
  // finally, calc checksum
  np->crc = calc_crc32(buf, 1024, 4);
  // create partitions...
  printf("Writing partition to flash...\r\n");
  flash_write((void *)&buf, (void *)PARTITION_BASE, 1024);
}
static struct partition *get_active_partition() {
  struct partition *p1 = (void *)PARTITION_BASE;
  struct partition *p2 = (void *)PARTITION_BASE + 1024;
  int v1 = check_partition(p1); // 00=valid
  int v2 = check_partition(p2); // 00=vaild
 
  if ((v1 != 0) && (v2 != 0)) {
    // neither is valid
    return NULL;
  }
  // at least one is valid
 
  // if one is invalid, return the other one
  if (v1 != 0) {
    return p2;
  }
  if (v2 != 0) {
    return p1;
  }
 
  //both are valid
  if (p2->part_seq > p1->part_seq) {
    return p2;
  }
  return p1;
}
 
static struct partition *get_next_partition_to_write() {
  void *x = get_active_partition();
 
  if (x == NULL) {
    return (void *)PARTITION_BASE;
  }
  if (x == (void *)PARTITION_BASE) {
    return (void *)PARTITION_BASE + 1024;
  }
  return (void *)PARTITION_BASE;
}
 
// set the base to be the next app to boot in the partition table
void partition_set_latest_app(void *base) {
  struct partition *pw = get_next_partition_to_write();
  struct partition *pa = get_active_partition();
 
  printf("Active partition: 0x%p\r\n", pa);
  printf("Write  partition: 0x%p\r\n", pw);
  uint8_t buf[1024];
 
  memset(buf, 0, 1024);
  // copy active partition to new one to write
  if (pa != NULL) {
    int i;
    uint8_t *source = (void *)pa;
    for (i = 0; i < 1024; i++) {
      buf[i] = source[i];
    }
  }
  struct partition *np = (void *)&buf;
 
  np->magic = PART_MAGIC;
  np->layout_version = 1;
  np->part_seq++;
  struct appdef *ap = &np->appdefs;
 
  ap->size = sizeof(struct appdef);
  ap->app_header = (uint32_t)base;
  ap->app_seq = 1;
  // endmarker
  ap = ap + ap->size;
  ap->size = 0;
 
  // finally, calc checksum
  np->crc = calc_crc32(buf, 1024, 4);
  // create partitions...
  printf("Writing partition @%p to flash...\r\n", pw);
  flash_write((void *)&buf, (void *)pw, 1024);
}