// $Id: bootloader.c,v 1.24 2004/09/17 17:06:08 jwhui Exp $

/*									tab:4
 *
 *
 * "Copyright (c) 2000-2004 The Regents of the University  of California.  
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice, the following
 * two paragraphs and the author appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 */

/**
 * bootloader.c - Bootloader is now a self-contained executable. A
 * mica2 and mica2dot can be set to always boot into the bootloader
 * first, before invoking the application. This allows the user to
 * input a special gesture (i.e. reset the node 3 times quickly) to
 * load a golden image stored in flash onto the node.
 *
 * @author  Jonathan Hui <jwhui@cs.berkeley.edu>
 * @since   0.1
 */

#include <bootloader.h>
#include <bl_functions.h>

#define SUCCESS 1
#define FAIL    0

void int2leds(uint8_t value) {
  if (value & 0x1) TOSH_CLR_RED_LED_PIN();
  else TOSH_SET_RED_LED_PIN();
  if (value & 0x2) TOSH_CLR_GREEN_LED_PIN();
  else TOSH_SET_GREEN_LED_PIN();
  if (value & 0x4) TOSH_CLR_YELLOW_LED_PIN();
  else TOSH_SET_YELLOW_LED_PIN();
}

void onDelaySequence() {

  uint8_t output = 0x7;
  uint8_t i;

  for ( i = 0; i < 3; i++ ) {
    int2leds(output);
    delayFull();
    output >>= 0x1;
  }
  int2leds(output);

}

void gestureNotify() {

  uint8_t output = 0x7;
  uint8_t i;

  for ( i = 0; i < 3; i++ ) {
    int2leds(output);
    delayHalf();
    int2leds(0x0);
    delayHalf();
  }

}

uint8_t SPIOutput(uint8_t spiOut) {
  if (spiOut & 0x80)
    TOSH_SET_FLASH_OUT_PIN();
  else
    TOSH_CLR_FLASH_OUT_PIN();	
  spiOut <<=1;
  return spiOut;
}

uint8_t SPIInput(uint8_t spiIn) {
  spiIn <<= 1;			
  if (TOSH_READ_FLASH_IN_PIN())
    spiIn |= 1;		
  return spiIn;
}

uint8_t SPIByte(uint8_t spiOut) {
  uint8_t spiIn = 0;
  uint8_t i;
  for (i = 0; i < 8; i++) {
    spiOut = SPIOutput(spiOut);
    TOSH_SET_FLASH_CLK_PIN();
    spiIn = SPIInput(spiIn);
    TOSH_CLR_FLASH_CLK_PIN();
  }
  return spiIn;
}

void eepromStartRead(uint16_t pageAddr) {

  uint16_t byteAddr = 0;
  uint8_t  cmdBuf[4];
  uint8_t  i;

  cmdBuf[0] = 0x68;	                         // EE Flash opcode
  cmdBuf[1] = (pageAddr >> 7) & 0x0F;	         // pageAddr[10:7] in lower nibble
  cmdBuf[2] = (pageAddr << 1) + (byteAddr >> 8); // pageAddr[6:0]+ byteAddr[8]
  cmdBuf[3] = (uint8_t)byteAddr;		 // byteAddr[7:0]

  // select the flash
  TOSH_CLR_FLASH_CLK_PIN();
  TOSH_CLR_FLASH_SELECT_PIN();

  for(i = 0; i < 4; i++)
    SPIByte(cmdBuf[i]); // writeout the command
  for(i = 0; i < 4; i++)
    SPIByte(0x0);	// write out 4 fill bytes

  // Flash requires 1 additional (65th) clock to setup data on SOut pin
  TOSH_SET_FLASH_CLK_PIN();
  TOSH_CLR_FLASH_CLK_PIN();

}

void eepromStopRead() {
  TOSH_SET_FLASH_SELECT_PIN();
}

uint8_t eepromReadByte(uint32_t* externalAddr) {
  uint32_t tmpExternalAddr = *externalAddr;
  if (tmpExternalAddr % BL_EXTERNAL_PAGE_SIZE == 0) {
    eepromStopRead();
    eepromStartRead(tmpExternalAddr / BL_EXTERNAL_PAGE_SIZE);
  }
  *externalAddr = tmpExternalAddr + 1;
  return SPIByte(0);
}

void reboot() {
  ENABLE_WDT();
  while(1);
}

uint8_t programBuf(void *buf, uint32_t pageBaseByteAddr, uint16_t length) {

  uint16_t newImgAddr, oldImgAddr;

  if (((uint32_t)BOOTLOADER_START <= pageBaseByteAddr
       && pageBaseByteAddr <= (uint32_t)BOOTLOADER_END)
      || (pageBaseByteAddr < BL_ADDRESS_LOW)
      || (pageBaseByteAddr >= BL_ADDRESS_HIGH)){
    // trying to write into bootloader section, load golden image
    return FAIL;
  }

  newImgAddr = eeprom_read_word((uint16_t*)BL_NEW_IMG_START_PAGE_ADDR);
  oldImgAddr = eeprom_read_word((uint16_t*)BL_CUR_IMG_START_PAGE_ADDR);

  if (newImgAddr != oldImgAddr
      && oldImgAddr != 0xffff) {
    // invalidate current image address
    eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+0), 0xff);
    eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+1), 0xff);
    while(!eeprom_is_ready());
  }

  eeprom_write_page(buf, pageBaseByteAddr, length);

  return SUCCESS;

}

uint8_t programImg(uint32_t startPage) {

  uint8_t  buf[BL_INTERNAL_PAGE_SIZE];
  uint32_t pageAddr;
  uint32_t sectionLength;
  uint32_t internalAddr;
  uint32_t externalAddr;
  uint32_t i;

  externalAddr = startPage * BL_EXTERNAL_PAGE_SIZE;

  internalAddr = 0;
  for ( i = 0; i < 4; i++ )
    internalAddr |= ((uint32_t)eepromReadByte(&externalAddr) & 0xff) << (i*8);

  sectionLength = 0;
  for ( i = 0; i < 4; i++ )
    sectionLength |= ((uint32_t)eepromReadByte(&externalAddr) & 0xff) << (i*8);    

  while (sectionLength > 0) {
    for (i = 0; i < sectionLength; i++, internalAddr++) {
      if (i != 0 && internalAddr % BL_INTERNAL_PAGE_SIZE == 0) {
	pageAddr = (internalAddr / BL_INTERNAL_PAGE_SIZE) - ((uint32_t) 1);
	int2leds(pageAddr);
	if (programBuf(buf, pageAddr * BL_INTERNAL_PAGE_SIZE, BL_INTERNAL_PAGE_SIZE) == FAIL)
	  return FAIL;
      }

      buf[internalAddr % BL_INTERNAL_PAGE_SIZE] = eepromReadByte(&externalAddr);
    }

    pageAddr = internalAddr / BL_INTERNAL_PAGE_SIZE;
    if (internalAddr % BL_INTERNAL_PAGE_SIZE == 0)
      pageAddr--;

    if (programBuf(buf, pageAddr * BL_INTERNAL_PAGE_SIZE, BL_INTERNAL_PAGE_SIZE) == FAIL)
      return FAIL;

    internalAddr = 0;
    for ( i = 0; i < 4; i++ )
      internalAddr |= ((uint32_t)eepromReadByte(&externalAddr) & 0xff) << (i*8);

    sectionLength = 0;
    for ( i = 0; i < 4; i++ )
      sectionLength |= ((uint32_t)eepromReadByte(&externalAddr) & 0xff) << (i*8);
  }

  eepromStopRead();  

  return SUCCESS;

}

void incrementFlashWord(uint16_t* flashPtr) {
  uint16_t tmpCounter = eeprom_read_word(flashPtr);
  if (tmpCounter++ < 0xfffe) { 
    eeprom_write_byte((uint8_t*)((uint16_t)flashPtr+0), (tmpCounter>>0)&0xff);
    eeprom_write_byte((uint8_t*)((uint16_t)flashPtr+1), (tmpCounter>>8)&0xff);
    while(!eeprom_is_ready());
  }
}

void logResetEvent(uint8_t eventType) {
  uint16_t log = eeprom_read_word((uint16_t*)BL_RESET_HISTORY);
  log <<= BL_RESET_LOG_ENTRY_SIZE;
  log |= eventType & BL_RESET_LOG_ENTRY_MASK;
  eeprom_write_byte((uint8_t*)(BL_RESET_HISTORY+0), (log>>0)&0xff);
  eeprom_write_byte((uint8_t*)(BL_RESET_HISTORY+1), (log>>8)&0xff);
  while(!eeprom_is_ready());
}

void setProgFailFlag() {
  uint8_t tmp8 = eeprom_read_byte((uint8_t*)BL_FLAGS_ADDR);
  tmp8 |= BL_PROGRAM_FAIL_FLAG;
  eeprom_write_byte((uint8_t*)BL_FLAGS_ADDR, tmp8);
  while(!eeprom_is_ready());
}

void startupSequence() {

  uint32_t newImgAddr, curImgAddr;
  uint8_t  loadImg;
  uint8_t  gestureCount;

  // get current value of counter
  gestureCount = eeprom_read_byte((uint8_t*)BL_GESTURE_COUNT_ADDR);
  gestureCount = (gestureCount==0xff) ? 0x1 : gestureCount+1;
  loadImg = eeprom_read_byte((uint8_t*)BL_LOAD_IMG_ADDR);

  if (gestureCount >= BL_GESTURE_MAX_COUNT) {
    if (loadImg != 0xff) {
      // reprogram attempt has failed, give up
      eeprom_write_byte((uint8_t*)BL_LOAD_IMG_ADDR, 0xff);
      while(!eeprom_is_ready());
      curImgAddr = eeprom_read_word((uint16_t*)BL_CUR_IMG_START_PAGE_ADDR);
      if (curImgAddr == 0xffff) {
	if (!(eeprom_read_byte((uint8_t*)BL_FLAGS_ADDR) & BL_GOLDEN_IMG_LOADED)) {
	  // don't know what to do, flash LEDs continuously
	  for(;;) gestureNotify();
	}

	// current image has been compromised, load golden image
	eeprom_write_byte((uint8_t*)BL_GESTURE_COUNT_ADDR, BL_GESTURE_MAX_COUNT);    
	while(!eeprom_is_ready());
	reboot();
      }
      eeprom_write_byte((uint8_t*)BL_GESTURE_COUNT_ADDR, 0xff);
      while(!eeprom_is_ready());
    }
    else if (!(eeprom_read_byte((uint8_t*)BL_FLAGS_ADDR) & BL_GOLDEN_IMG_LOADED)) {
      // gesture has been detected, display receipt of gesture on LEDs
      gestureNotify();
      // update new image start address
      eeprom_write_byte((uint8_t*)(BL_NEW_IMG_START_PAGE_ADDR+0), BL_GOLDEN_IMG_ADDR);
      eeprom_write_byte((uint8_t*)(BL_NEW_IMG_START_PAGE_ADDR+1), BL_GOLDEN_IMG_ADDR >> 8);
      while(!eeprom_is_ready());
      // load golden image from flash
      if (programImg(BL_GOLDEN_IMG_ADDR) == FAIL) {
	setProgFailFlag();
	reboot();
      }
      // update current image start address
      eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+0), BL_GOLDEN_IMG_ADDR);
      eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+1), BL_GOLDEN_IMG_ADDR >> 8);
      // clear gesture counter
      gestureCount = 0xff;
    }
  }

  // increment counter
  eeprom_write_byte((uint8_t*)BL_GESTURE_COUNT_ADDR, gestureCount);
  while(!eeprom_is_ready());

  if (loadImg != 0xff) {
    // get address of new program
    newImgAddr = eeprom_read_word((uint16_t*)BL_NEW_IMG_START_PAGE_ADDR);
    if (programImg(newImgAddr) == FAIL) {
      setProgFailFlag();
      reboot();
    }
    // update current image start address
    eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+0), newImgAddr);
    eeprom_write_byte((uint8_t*)(BL_CUR_IMG_START_PAGE_ADDR+1), newImgAddr >> 8);
    eeprom_write_byte((uint8_t*)BL_LOAD_IMG_ADDR, 0xff);
    // clear gesture counter
    eeprom_write_byte((uint8_t*)BL_GESTURE_COUNT_ADDR, 0xff);
    while(!eeprom_is_ready());
  }

  // give user some time and count down LEDs
  onDelaySequence();

  // no gesture detected, reset counter
  eeprom_write_byte((uint8_t*)BL_GESTURE_COUNT_ADDR, 0xff);
  while(!eeprom_is_ready());

  runApp();

}

inline void readResets() {

  uint16_t tmpCounter = 0x0;

  if (eeprom_read_word((uint16_t*)BL_RESET_HISTORY) == 0xffff) {
    eeprom_write_byte((uint8_t*)(BL_WDT_RESET_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_WDT_RESET_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_POWER_ON_RESET_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_POWER_ON_RESET_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_BROWN_OUT_RESET_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_BROWN_OUT_RESET_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_EXTERNAL_RESET_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_EXTERNAL_RESET_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_PROGRAM_FAIL_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_PROGRAM_FAIL_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_NETPROG_RESET_COUNTER+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_NETPROG_RESET_COUNTER+1), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_RESET_HISTORY+0), tmpCounter);
    eeprom_write_byte((uint8_t*)(BL_RESET_HISTORY+1), tmpCounter);
    while(!eeprom_is_ready());
  }

  // watchdog timer reset
  if (IS_WDT_RESET()) {
    incrementFlashWord((uint16_t*)BL_WDT_RESET_COUNTER);
    logResetEvent(BL_WDT_RESET);
  }
  // power on reset
  if (IS_POWER_ON_RESET()) {
    incrementFlashWord((uint16_t*)BL_POWER_ON_RESET_COUNTER);
    logResetEvent(BL_POWER_ON_RESET);
  }
  // brown out reset
  if (IS_BROWN_OUT_RESET()) {
    incrementFlashWord((uint16_t*)BL_BROWN_OUT_RESET_COUNTER);
    logResetEvent(BL_BROWN_OUT_RESET);
  }
  // external reset
  if (IS_EXTERNAL_RESET()) {
    incrementFlashWord((uint16_t*)BL_EXTERNAL_RESET_COUNTER);
    logResetEvent(BL_EXTERNAL_RESET);
  }
  // netprog reset
  if (IS_NETPROG_RESET()) {
    incrementFlashWord((uint16_t*)BL_NETPROG_RESET_COUNTER);
    logResetEvent(BL_NETPROG_RESET);
  }
  // program fail reset
  if (IS_PROG_FAIL_RESET()) {
    incrementFlashWord((uint16_t*)BL_PROGRAM_FAIL_COUNTER);
    logResetEvent(BL_PROGRAM_FAIL);
  }
  // program failure reset is handled at the site of the failure

  CLEAR_WDT_RESET_FLAG();
  CLEAR_POWER_ON_RESET_FLAG();
  CLEAR_BROWN_OUT_RESET_FLAG();
  CLEAR_EXTERNAL_RESET_FLAG();
  CLEAR_NETPROG_RESET_FLAG();
  CLEAR_PROG_FAIL_RESET_FLAG();

}

int main() {

  programBufPtr_t programBufPtr;
  uint32_t programBufAddr;
  uint16_t i;

  DISABLE_INTERRUPTS();
  DISABLE_WDT();
  TOSH_SET_PIN_DIRECTIONS();
  EXTRA_INIT();

  readResets();

  programBufPtr = programBuf;
  programBufAddr = (uint32_t)((uint16_t)programBufPtr);

  for ( i = 0; i < 4; i++ ) {
    uint8_t tmp;
    tmp = (programBufAddr >> (i*8)) & 0xff;
    if (tmp != eeprom_read_byte((uint8_t*)(BL_PROGRAM_BUF_ADDR+i)))
      eeprom_write_byte((uint8_t*)(BL_PROGRAM_BUF_ADDR+i), tmp);
  }

  startupSequence();

  return 0;

}