Subversion Repositories neo430

// #################################################################################################
// #  < NEO430 Bootloader >                                                                        #
// # ********************************************************************************************* #
// # Boot from IMEM, UART or SPI Flash at SPI.CS[0]                                                #
// #                                                                                               #
// # UART configuration: 8N1 at 19200 baud                                                         #
// # Boot Flash: 8-bit SPI, 24-bit addresses (like Micron N25Q032A) @ NEO430_SPI.CS[0]             #
// # NEO430_GPIO.out[0] is used as high-active status LED                                          #
// #                                                                                               #
// # Auto boot sequence after timeout:                                                             #
// #  -> Try booting from SPI flash at SPI.CS[0]                                                   #
// #  -> Permanently light up status led and freeze if SPI flash booting attempt fails             #
// # ********************************************************************************************* #
// # BSD 3-Clause License                                                                          #
// #                                                                                               #
// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #
// #                                                                                               #
// # Redistribution and use in source and binary forms, with or without modification, are          #
// # permitted provided that the following conditions are met:                                     #
// #                                                                                               #
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
// #    conditions and the following disclaimer.                                                   #
// #                                                                                               #
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
// #    conditions and the following disclaimer in the documentation and/or other materials        #
// #    provided with the distribution.                                                            #
// #                                                                                               #
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
// #    endorse or promote products derived from this software without specific prior written      #
// #    permission.                                                                                #
// #                                                                                               #
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
// # ********************************************************************************************* #
// # The NEO430 Processor - https://github.com/stnolting/neo430                                    #
// #################################################################################################
 
// Libraries
#include <stdint.h>
#include <neo430.h>
 
// SPI flash: NEO430 boot base address
#define SPI_FLASH_BOOT_ADR  0x00040000L
 
// Configuration
#define BAUD_RATE        19200 // default UART baud rate
#define AUTOBOOT_TIMEOUT 4     // countdown (seconds) to auto boot
#define STATUS_LED       0     // GPIO.out(0) is status LED
 
// SPI flash hardware configuration
#define SPI_FLASH_CS     0
 
// SPI flash commands
#define SPI_FLASH_CMD_READ           0x03
#define SPI_FLASH_CMD_READ_STATUS    0x05
#define SPI_FLASH_CMD_WRITE_ENABLE   0x06
#define SPI_FLASH_CMD_PAGE_PROGRAM   0x02
#define SPI_FLASH_CMD_SECTOR_ERASE   0xD8
#define SPI_FLASH_CMD_READ_ID        0x9E
#define SPI_FLASH_CMD_POWER_DOWN     0xB9
#define SPI_FLASH_CMD_RELEASE        0xAB
 
// Image sources
#define UART_IMAGE       0x00
#define EEPROM_IMAGE_SPI 0x01
 
// Error codes
#define ERROR_EEPROM     0x00 // EEPROM access error
#define ERROR_ROMACCESS  0x01 // cannot write to IMEM
#define ERROR_EXECUTABLE 0x02 // invalid executable format
#define ERROR_SIZE       0x04 // executable is too big
#define ERROR_CHECKSUM   0x08 // checksum error
 
// Scratch registers - abuse unused IRQ vectors for this ;)
#define TIMEOUT_CNT IRQVEC_GPIO
 
// Macros
#define xstr(a) str(a)
#define str(a) #a
#define SPI_FLASH_SEL {SPI_CT |= 1 << (SPI_FLASH_CS+SPI_CT_CS_SEL0);}
 
// Function prototypes
void     __attribute__((__interrupt__)) timer_irq_handler(void);
void     __attribute__((__naked__)) start_app(void);
void     print_help(void);
void     store_eeprom(void);
void     eeprom_write_word(uint32_t a, uint16_t d);
void     get_image(uint8_t src);
uint16_t get_image_word(uint32_t a, uint8_t src);
void     __attribute__((__naked__)) system_error(uint8_t err_code);
 
// Function prototypes - SPI flash
uint8_t spi_flash_read_byte();
void    spi_flash_write_byte(uint32_t adr, uint8_t data);
void    spi_flash_erase_sector(uint32_t base_adr);
uint8_t spi_flash_read_status(void);
void    spi_flash_write_cmd(uint16_t cmd);
uint8_t spi_flash_read_1st_id(void);
void    spi_flash_adr_conv(uint32_t adr, uint16_t *hi, uint16_t *mi, uint16_t *lo);
 
 
/* ------------------------------------------------------------
 * INFO Bootloader main
 * ------------------------------------------------------------ */
int main(void) {
 
  // ****************************************************************
  // Processor hardware initialization
  // ****************************************************************
 
  // stack setup
  // -> done in boot_crt0
 
  // disable watchdog timer
  neo430_wdt_disable();
 
  // clear status register and disable interrupts, clear interrupt buffer, enable write access to IMEM
  asm volatile ("mov %0, r2" : : "i" ((1<<R_FLAG) | (1<<Q_FLAG)));
 
  // disable TRNG
  TRNG_CT = 0;
 
  // disable Wishbone interface
  WB32_CT = 0;
 
  // disable PWM
  PWM_CT = 0;
 
  // disable TWI
  TWI_CT = 0;
 
  // disable EXIRQ
  EXIRQ_CT = 0;
 
  // disable FREQ_GEN
  FREQ_GEN_CT = 0;
 
  // init GPIO
  GPIO_IRQMASK = 0; // no pin change interrupt please, thanks
  neo430_gpio_port_set(1<<STATUS_LED); // activate status LED, clear all others
 
  // init interrupt vectors
  IRQVEC_TIMER  = (uint16_t)(&timer_irq_handler); // timer match
//IRQVEC_EXT    = 0; // unused
//IRQVEC_SERIAL = 0; // unused
 
  // set Baud rate & init UART control register:
  // enable UART, no IRQs
  neo430_uart_setup(BAUD_RATE);
  neo430_uart_char_read(); // clear UART RX buffer
 
  // set SPI config:
  // enable SPI, no IRQ, MSB first, 8-bit mode, SPI clock mode 0, set SPI speed, disable all SPI CS lines (set high)
  neo430_spi_enable(SPI_PRSC_8); // this also resets the SPI module
 
  // Timeout counter: init timer, irq tick @ ~1Hz (prescaler = 4096)
  // THR = f_main / (1Hz + 4096) -1
  TMR_CT = 0; // reset timer
  //uint32_t clock = CLOCKSPEED_32bit >> 14; // divide by 4096
  TMR_THRES = (CLOCKSPEED_HI << 2) -1; // "fake" ;D
  // enable timer, auto reset, enable IRQ, prsc = 1:2^16, start timer
  TMR_CT = (1<<TMR_CT_EN) | (1<<TMR_CT_ARST) | (1<<TMR_CT_IRQ) | ((16-1)<<TMR_CT_PRSC0) | (1<<TMR_CT_RUN);
  TIMEOUT_CNT = 0; // console timeout ticker
 
  neo430_eint(); // enable global interrupts
 
 
  // ****************************************************************
  // Show bootloader intro and system information
  // ****************************************************************
  neo430_uart_br_print("\n\nNEO430 Bootloader\n"
                       "\n"
                       "BLV: "__DATE__"\n"
                       "HWV: 0x");
  neo430_uart_print_hex_word(HW_VERSION);
  neo430_uart_br_print("\nUSR: 0x");
  neo430_uart_print_hex_word(USER_CODE);
  neo430_uart_br_print("\nCLK: 0x");
  neo430_uart_print_hex_word(CLOCKSPEED_HI);
  neo430_uart_print_hex_word(CLOCKSPEED_LO);
  neo430_uart_br_print("\nROM: 0x");
  neo430_uart_print_hex_word(IMEM_SIZE);
  neo430_uart_br_print("\nRAM: 0x");
  neo430_uart_print_hex_word(DMEM_SIZE);
  neo430_uart_br_print("\nSYS: 0x");
  neo430_uart_print_hex_word(SYS_FEATURES);
 
 
  // get SPI flash out of power down mode
  spi_flash_write_cmd((uint16_t)SPI_FLASH_CMD_RELEASE);
 
 
  // ****************************************************************
  // Auto boot sequence
  // ****************************************************************
  neo430_uart_br_print("\n\nAutoboot in "xstr(AUTOBOOT_TIMEOUT)"s. Press key to abort.\n\n");
  while (1) { // wait for any key to be pressed or timeout
 
    // timeout? start auto boot sequence
    if (TIMEOUT_CNT == 4*AUTOBOOT_TIMEOUT) { // in 0.25 seconds
      get_image(EEPROM_IMAGE_SPI); // try loading from EEPROM
      neo430_uart_br_print("\n");
      start_app(); // start app
    }
 
    // key pressed? -> enter user console
    if ((UART_RTX & (1<<UART_RTX_AVAIL)) != 0) {
      break;
    }
  }
  print_help();
 
 
  // ****************************************************************
  // Bootloader console
  // ****************************************************************
  while (1) {
 
    neo430_uart_br_print("\nCMD:> ");
    char c = neo430_uart_getc();
    neo430_uart_putc(c); // echo
    neo430_uart_br_print("\n");
 
    if (c == 'r') { // restart bootloader
      asm volatile ("mov #0xF000, r0"); // jump to beginning of bootloader ROM
    }
    else if (c == 'h') { // help menu
      print_help();
    }
    else if (c == 'u') { // upload program to RAM via UART
      get_image(UART_IMAGE);
    }
    else if (c == 'p') { // program EEPROM from RAM
      store_eeprom();
    }
    else if (c == 'e') { // start program in RAM
      start_app();
    }
    else { // unknown command
      neo430_uart_br_print("Bad CMD");
    }
  }
}
 
 
/* ------------------------------------------------------------
 * INFO Timer IRQ handler
 * ------------------------------------------------------------ */
void __attribute__((__interrupt__)) timer_irq_handler(void) {
 
  TIMEOUT_CNT++; // increment system ticker
  neo430_gpio_port_toggle(1<<STATUS_LED); // toggle status LED
}
 
 
/* ------------------------------------------------------------
 * INFO Start application in IMEM
 * INFO "naked" since this is final...
 * ------------------------------------------------------------ */
void __attribute__((__naked__)) start_app(void) {
 
  // put SPI flah into power-down mode
  spi_flash_write_cmd((uint16_t)SPI_FLASH_CMD_POWER_DOWN);
 
  neo430_uart_br_print("Booting...\n\n");
 
  // wait for UART to finish transmitting
  while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);
 
  // deactivate IRQs, no more write access to IMEM, clear all pending IRQs
  asm volatile ("mov %0, r2" : : "i" (1<<Q_FLAG));
 
  // start app in IMEM at address 0x0000
  while (1) {
    asm volatile ("mov #0x0000, r0");
  }
}
 
 
/* ------------------------------------------------------------
 * INFO Print help text
 * ------------------------------------------------------------ */
void print_help(void) {
 
  neo430_uart_br_print("CMDs:\n"
                       "h: Help\n"
                       "r: Restart\n"
                       "u: Upload\n"
                       "p: Prog\n"
                       "e: Execute");
}
 
 
/* ------------------------------------------------------------
 * INFO Store full IMEM content to SPI EEPROM at SPI.CS0
 * ------------------------------------------------------------ */
void store_eeprom(void) {
 
  neo430_uart_br_print("...");
 
  // clear memory before writing
  spi_flash_erase_sector(SPI_FLASH_BOOT_ADR);
 
  // check if eeprom ready (or available at all)
  if (spi_flash_read_1st_id() == 0x00) { // manufacturer ID
    system_error(ERROR_EEPROM);
  }
 
  // write EXE signature
  eeprom_write_word(SPI_FLASH_BOOT_ADR + 0, 0xCAFE);
 
  // write size
  uint16_t end = IMEM_SIZE;
  eeprom_write_word(SPI_FLASH_BOOT_ADR + 2, end);
 
  // store data from IMEM and update checksum
  uint16_t checksum = 0;
  uint16_t i = 0;
  uint16_t *pnt = (uint16_t*)0x0000;
 
  while (i < end) {
    uint16_t d = (uint16_t)*pnt++;
    checksum ^= d;
    eeprom_write_word(SPI_FLASH_BOOT_ADR + 6 + i, d);
    i+= 2;
  }
 
  // write checksum
  eeprom_write_word(SPI_FLASH_BOOT_ADR + 4, checksum);
 
  neo430_uart_br_print("OK");
}
 
 
/* ------------------------------------------------------------
 * INFO EEPROM write data word
 * PARAM a destination address (24 bit effective)
 * PARAM d word to be written
 * ------------------------------------------------------------ */
void eeprom_write_word(uint32_t a, uint16_t d) {
 
  uint8_t lo = (uint8_t)(d);
  uint8_t hi = (uint8_t)neo430_bswap(d);
 
  spi_flash_write_byte(a+0, hi);
  spi_flash_write_byte(a+1, lo);
}
 
 
/* ------------------------------------------------------------
 * INFO Get IMEM image from SPI EEPROM at SPI.CS0 or from UART
 * PARAM src Image source 0: UART, 1: SPI_EEPROM
 * RETURN error code (0 if successful)
 * ------------------------------------------------------------ */
void get_image(uint8_t src) {
 
  // abort if IMEM was implemented as true ROM
  if (SYS_FEATURES & (1<<SYS_IROM_EN)) {
    system_error(ERROR_ROMACCESS);
  }
 
  // print intro
  if (src == UART_IMAGE) { // boot via UART
    neo430_uart_br_print("Awaiting BINEXE...");
  }
  else { //if (src == EEPROM_IMAGE_SPI)// boot from EEPROM
    neo430_uart_br_print("Loading...");
  }
 
  // check if valid image
  if (get_image_word(SPI_FLASH_BOOT_ADR + 0, src) != 0xCAFE) { // signature
    system_error(ERROR_EXECUTABLE);
  }
 
  // image size and checksum
  uint16_t size = get_image_word(SPI_FLASH_BOOT_ADR + 2, src); // size in bytes
  uint16_t check = get_image_word(SPI_FLASH_BOOT_ADR + 4, src); // XOR checksum
  uint16_t end = IMEM_SIZE;
  if (size > end) {
    system_error(ERROR_SIZE);
  }
 
  // transfer program data
  uint16_t *pnt = (uint16_t*)0x0000;
  uint16_t checksum = 0x0000;
  uint16_t d = 0, i = 0;
  while (i < size/2) { // in words
    d = get_image_word(SPI_FLASH_BOOT_ADR + 2*i + 6, src);
    checksum ^= d;
    pnt[i++] = d;
  }
 
  // clear rest of IMEM
  while(i < end/2) { // in words
    pnt[i++] = 0x0000;
  }
 
  // error during transfer?
  if (checksum == check) {
    neo430_uart_br_print("OK");
  }
  else {
    system_error(ERROR_CHECKSUM);
  }
}
 
 
/* ------------------------------------------------------------
 * INFO Get image word from SPI_EEPROM or UART
 * PARAM a source address (24 bit effective)
 * PARAM src: 0: UART, 1: SPI_EEPROM
 * RETURN accessed data word
 * ------------------------------------------------------------ */
uint16_t get_image_word(uint32_t a, uint8_t src) {
 
  uint8_t c0 = 0, c1 = 0;
 
  // reads have to be consecutive when reading from the UART
  if (src == UART_IMAGE) { // get image data via UART
    c0 = (uint8_t)neo430_uart_getc();
    c1 = (uint8_t)neo430_uart_getc();
  }
  else {// if (src == EEPROM_IMAGE_SPI) { // get image data from SPI EEPROM
    c0 = spi_flash_read_byte(a+0);
    c1 = spi_flash_read_byte(a+1);
  }
 
  //uint16_t r = (((uint16_t)c0) << 8) | (((uint16_t)c1) << 0);
  uint16_t r = neo430_combine_bytes(c0, c1);
 
  return r;
}
 
 
/* ------------------------------------------------------------
 * INFO Print error message, light up status LED and freeze system
 * INFO "naked" since this is final
 * PARAM error code
 * ------------------------------------------------------------ */
void __attribute__((__naked__)) system_error(uint8_t err_code){
 
  neo430_uart_br_print("\a\nERR_"); // output error code with annoying bell sound
  neo430_uart_print_hex_byte(err_code);
 
  asm volatile ("mov #0, r2"); // deactivate IRQs, no more write access to IMEM
  neo430_gpio_port_set(1<<STATUS_LED); // permanently light up status LED
 
  while(1); // freeze
}
 
 
 
// *************************************************************************************
// SPI flash functions
// *************************************************************************************
 
/* ------------------------------------------------------------
 * Read single byte from flash (24-bit adress)
 * ------------------------------------------------------------ */
uint8_t spi_flash_read_byte(uint32_t adr) {
 
  uint16_t adr_lo;
  uint16_t adr_mi;
  uint16_t adr_hi;
  spi_flash_adr_conv(adr, &adr_hi, &adr_mi, &adr_lo);
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans((uint16_t)SPI_FLASH_CMD_READ);
  // no masking required, SPI unit in 8 bit mode ignores upper 8 bits
  neo430_spi_trans(adr_hi);
  neo430_spi_trans(adr_mi);
  neo430_spi_trans(adr_lo);
  uint16_t data = neo430_spi_trans(0);
 
  neo430_spi_cs_dis();
 
  return (uint8_t)data;
}
 
 
/* ------------------------------------------------------------
 * Write single data byte to flash at base adress
 * ------------------------------------------------------------ */
void spi_flash_write_byte(uint32_t adr, uint8_t data) {
 
  uint16_t adr_lo;
  uint16_t adr_mi;
  uint16_t adr_hi;
  spi_flash_adr_conv(adr, &adr_hi, &adr_mi, &adr_lo);
 
  spi_flash_write_cmd((uint16_t)SPI_FLASH_CMD_WRITE_ENABLE); // allow write-access
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans((uint16_t)SPI_FLASH_CMD_PAGE_PROGRAM);
  // no masking required, SPI unit in 8 bit mode ignores upper 8 bits
  neo430_spi_trans(adr_hi);
  neo430_spi_trans(adr_mi);
  neo430_spi_trans(adr_lo);
  neo430_spi_trans((uint16_t)data);
 
  neo430_spi_cs_dis();
 
  while(spi_flash_read_status());
}
 
 
/* ------------------------------------------------------------
 * Erase sector (64kB) at base adress
 * ------------------------------------------------------------ */
void spi_flash_erase_sector(uint32_t base_adr) {
 
  uint16_t adr_lo;
  uint16_t adr_mi;
  uint16_t adr_hi;
  spi_flash_adr_conv(base_adr, &adr_hi, &adr_mi, &adr_lo);
 
  spi_flash_write_cmd((uint16_t)SPI_FLASH_CMD_WRITE_ENABLE); // allow write-access
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans((uint16_t)SPI_FLASH_CMD_SECTOR_ERASE);
  // no masking required, SPI unit in 8 bit mode ignores upper 8 bits
  neo430_spi_trans(adr_hi);
  neo430_spi_trans(adr_mi);
  neo430_spi_trans(adr_lo);
 
  neo430_spi_cs_dis();
 
  while(spi_flash_read_status());
}
 
 
/* ------------------------------------------------------------
 * Read status register
 * ------------------------------------------------------------ */
uint8_t spi_flash_read_status(void) {
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans((uint16_t)SPI_FLASH_CMD_READ_STATUS);
  uint16_t status = neo430_spi_trans(0);
 
  neo430_spi_cs_dis();
 
  return (uint8_t)status;
}
 
 
/* ------------------------------------------------------------
 * Read first byte of ID (manufacturer ID), should be != 0x00
 * ------------------------------------------------------------ */
uint8_t spi_flash_read_1st_id(void) {
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans((uint16_t)SPI_FLASH_CMD_READ_ID);
  uint16_t id = neo430_spi_trans(0);
 
  neo430_spi_cs_dis();
 
  return (uint8_t)id;
}
 
 
/* ------------------------------------------------------------
 * Write command to flash
 * ------------------------------------------------------------ */
void spi_flash_write_cmd(uint16_t cmd) {
 
  SPI_FLASH_SEL;
 
  neo430_spi_trans(cmd);
 
  neo430_spi_cs_dis();
}
 
 
/* ------------------------------------------------------------
 * Adress conversion helper
 * ------------------------------------------------------------ */
void spi_flash_adr_conv(uint32_t adr, uint16_t *hi, uint16_t *mi, uint16_t *lo) {
 
  uint16_t adr_hi16 = (uint16_t)(adr >> 16);
  uint16_t adr_lo16 = (uint16_t)(adr >>  0);
 
  *lo = adr_lo16;
  *mi = neo430_bswap(adr_lo16);
  *hi = adr_hi16;
}