Tooltron

#include "bootloader.h"

// Setup the default fuses

// This seems to be broken for now...

/*

FUSES = {

    .low = (FUSE_SUT0 & FUSE_CKSEL3 & FUSE_CKSEL2 & FUSE_CKSEL0),

    .high = (FUSE_EESAVE & FUSE_SPIEN),

    .extended = (FUSE_SELFPRGEN)

};

*/

// Error thresholds

#define MAX_RETRIES 5       // Number of times to retry before giving up

/**

 * Where we store the jump to user code. The jump address is in words

 * due to how the rjmp instruction works. It is 1 word below the bootloader

 * We declare it as noreturn to save some space since we will never return

 * to the bootloader unless we do a system reset

 */

void (*main_start)(void) __attribute__((noreturn)) = (void*)(BOOT_START/2 - 1);

typedef union {

    uint8_t bytes[2];

    int16_t sword;

} rjump_t;

// SPM_PAGESIZE is set to 32 bytes

void onboard_program_write(uint16_t page, uint8_t *buf) {

  uint16_t i;

  boot_page_erase (page);

  boot_spm_busy_wait ();      // Wait until the memory is erased.

  for (i=0; i < SPM_PAGESIZE; i+=2){

    // Set up little-endian word.

    boot_page_fill (page + i, buf[i] | (buf[i+1] <<8));

  }

  boot_page_write (page);     // Store buffer in flash page.

  boot_spm_busy_wait();       // Wait until the memory is written.

}

int main(void) {

  uint8_t mbuf[MAX_PAYLOAD_SIZE];

  rjump_t jbuf;

  uint16_t caddr;

  uint16_t prog_len;

  uint8_t resp;

  uint8_t i;

  uint8_t retries;

  uint8_t addr;

  uint8_t boot;

  // This is where we jump to if we fail out because of retries

  retry_jpnt:

  // We set the variables here

  caddr = MAIN_ADDR;

  retries = 0;

  boot = FALSE;

  // Grab the address from EEPROM

  addr = read_addr();

  // Initialize the Pins

  DDRB = LED_GREEN | LED_YELLOW | LED_RED;  // Set the LED pins as outputs

  PORTB = 0x00;                             // LEDs on == in bootloader

  DDRD = RELAY;                             // Set Relay as an output

  PORTD = 0x00;                             // Turn relay off

  // Clear the watchdog timer

  if (MCUSR & _BV(WDRF)) {

      MCUSR &= ~_BV(WDRF);

      wdt_disable();

      WDTCSR = 0;

      boot = TRUE;

  }

  // External override at bootup to enter bootloading mode

  if (!(BUT_PORT & (BUT_RED | BUT_BLACK))) {

      boot = TRUE;

  }

  // Initialize the RS485

  rs485_init(BAUD9600);

  //Execute user code if we aren't supposed to enter bootloading mode

  if (boot == FALSE) {

      goto run_user_code;

  }

  // Send the boot packet

  // We're not using the loop variable i right now and we are ignoring the

  // packet length so we're just going to "capture" the length and ignore it

  send_packet(TT_BOOT, addr, NULL, 0);

  resp = parse_packet(mbuf, &i, addr);

  // Enter programming mode 

  if (resp == TT_PROGM) {

    prog_len = mbuf[0];

    prog_len |= mbuf[1] << 8;

    // This will insert a NOP into the user code jump in case

    // the programming fails

    for (i = 0; i < PROGD_PACKET_SIZE; i++) {

      mbuf[i]= 0;

    }

    onboard_program_write(BOOT_START - SPM_PAGESIZE, mbuf);

  // Run user code

  } else {

      run_user_code:

      LED_PORT = LED_GREEN | LED_YELLOW | LED_RED;

      main_start();

  }

  send_packet(TT_ACK, addr, NULL, 0);

  while(1) {

      // We are ignoring the length of the packet so we are reusing the loop

      // variable i which is not being used right now to throw away the value

      resp = parse_packet(mbuf, &i, addr);

      if (resp == TT_PROGD) {

          // We need to muck with the reset vector jump in the first page

          if (caddr == MAIN_ADDR) {

              // Store the jump to user code

              jbuf.bytes[0] = mbuf[0];

              jbuf.bytes[1] = mbuf[1];

              // Rewrite the user code jump to be correct since we are

              // using relative jumps (rjmp)

              jbuf.sword &= 0x0FFF;

              jbuf.sword -= (BOOT_START >> 1) - 1;

              jbuf.sword &= 0x0FFF;

              jbuf.sword |= 0xC000;

              // Rewrite the reset vector to jump to the bootloader

              mbuf[0] = (BOOT_START/2 - 1) & 0xFF;

              mbuf[1] = 0xC0 | (((BOOT_START/2 - 1) >> 8) & 0x0F);

          }

          // Write the page to the flash

          onboard_program_write(caddr, mbuf);

          caddr += PROGD_PACKET_SIZE;

          retries = 0;

      } else {

          send_packet(TT_NACK, addr, NULL, 0);

          retries++;

          // If we failed too many times, reset. This goes to the start

          // of the bootloader function

          if (retries > MAX_RETRIES) {

              goto retry_jpnt;

          } else {

              continue;

          }

      }

      send_packet(TT_ACK, addr, NULL, 0);

      // Once we write the last packet we must override the jump to

      // user code to point to the correct address

      if (prog_len <= PROGD_PACKET_SIZE) {

          //for (i = 0; i < MAX_PAYLOAD_SIZE; i++) {

          //    mbuf[i]= 0;

          //}

          mbuf[PROGD_PACKET_SIZE-2] = jbuf.bytes[0];

          mbuf[PROGD_PACKET_SIZE-1] = jbuf.bytes[1];

          onboard_program_write(BOOT_START - SPM_PAGESIZE, mbuf);

          // Jump to user code that we just wrote

          goto run_user_code;

      } else { 

          prog_len -= PROGD_PACKET_SIZE;

      }

  }

  // Should never get here

  return -1;

}