AVR_Tiny_Bootloader.c

/*

 * AVR_Tiny_Bootloader.c

 *

 * Created: 11.02.2014 16:25:16

 *  Author: Marius Dege

 // pf    write hexfile to flash memory

 //      return value:  pf+

 //      The + indicates successful interpretation of the command.

 //      Now an intel hex file can be send to the MCU over the UART.

 //      For every successful read and parsed record line a '.' is printed. When a flash page write is done, a '*' is printed.

 //      In case a checksum error is detected in a record line, a '-' is printed and the command is terminated.

 //

 // pe    write hexfile to eeprom memory

 //      return value:  pe+

 //      The + indicates successful interpretation of the command.

 //      Now an intel hex file can be send to the MCU over the UART.

 //      For every successful read and parsed record line a '.' is printed. When a record line was written to eeprom, a '*' is printed.

 //      In case a checksum error is detected in a record line, a '-' is printed and the command is terminated.

 //

 // g    jump to application at bottom of flash 0x0000

 //      return value:  g+

 //      The + indicates successful interpretation of the command.

 //NOTE: .bootloader==WORDADRESSE; BOOTADRESSE=BYTEADRESSE!!!!

//Folgende ATTinys können unterstützt werden by Hardware UART (mind. 256byte SRAM):

//ATtiny167/87  -  Start @  WORD/WORD

//ATtiny4313  -  Start @ 0x4A0 WORD

//ATtiny441/841  -  Start @  WORD/WORD

//ATtiny828    -  Start @  WORD

//ATtiny1634  -  Start @  WORD  -  HouseBasic (0)

*/

#define F_CPU 16000000UL

// bootloader uses XON/XOFF handshake

#define XON    'G'    //17

#define XOFF  'H'    //19

// other communication characters

#define BREAK 3

#define LINE_FEED 0x0A

// define the line ending, make sure to have set your terminal program to match this!

// 0x0a is '\n' - we write the hex number to avoid problems with different compilers handling the '\n' in different ways

#define LINE_ENDING    LINE_FEED

#define CheckedVersion  'E'

#define GoBackToLoader  '^'

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/boot.h>

#include <avr/wdt.h>

#include <stdint.h>

#include <avr/eeprom.h>

#include <avr/pgmspace.h>

#include <stdint.h>

#include <avr/delay.h>

void (*app_start)(void)=0x0000;

static void boot_rs232init(uint32_t baud) BOOTLOADER_SECTION;

static void boot_sendchar(char data) BOOTLOADER_SECTION;

static void boot_sendstring(char *p) BOOTLOADER_SECTION;

static char boot_readchar(void) BOOTLOADER_SECTION;

uint8_t boot_kbhit(void) BOOTLOADER_SECTION;

uint8_t asciiToHex(uint8_t ucNibble) BOOTLOADER_SECTION;

uint8_t asciiToHex2(uint8_t ucNibbleHigh, uint8_t ucNibbleLow) BOOTLOADER_SECTION;

void bootloader(uint8_t sync, uint8_t SystemVersion) BOOTLOADER_SECTION __attribute__((noreturn));

void bootloader(uint8_t sync, uint8_t SystemVersion) 

{

BOOTSTART:

  wdt_reset();

  wdt_disable();

  cli(); // no irqs.

  //For HouseBasic

  DDRB=0;

  PORTB=0;

  DDRC=0;

  PORTC=0;

  DDRA=(0|(1<<4));    //Set Bluetooth Module on (MD Device Support)

  PORTA=(0|(1<<4));

  uint32_t  ulPageBaseAddress, size, BaudRates[]={300,600,1200,4800,9600,14400,19200,28800,38400,56000,57600,115200,128000,256000};

  uint16_t  usAddr, usExtSegmentAddress, usPageAddressOffset;

  uint8_t    ucFlagEepromWrite, ucFlagWrite, ucFlagEof, ucFlagError, ucComputedChecksum, ucHexRecChecksum, ucRecordType, ucByteCount, ucTmp=0, ucDataByte=0, ucBuffer[55], ucEepromBuffer[25], ucTmpDataByte=0, ucPageWriting=0, ucTmpPageWriting=0;

  boot_rs232init(BaudRates[4]);

  ucTmp=0;

  do

  {

     wdt_reset();

     if(boot_kbhit())

    {    

       if (boot_readchar()=='U' || boot_readchar()=='^')

        ucTmp=150;

      else

      {

        ucTmp++;

        if (ucTmp>=14)

          ucTmp=0;

        boot_rs232init(BaudRates[ucTmp]);

      }

    }

  } while (ucTmp!=150);

  //Send Versions for MDTerm

  boot_sendchar('M');

  boot_sendchar('D');

  boot_sendchar('-');

  boot_sendchar('B');

  boot_sendchar('L');

  boot_sendchar(LINE_FEED);

  wdt_reset();

  // init the buffer to empty buffer

  ucBuffer[0]=0;

  ucTmp=0;

  ucDataByte=0;

  ucPageWriting=0;

  ucTmpPageWriting=0;

  //Send Versions for MDTerm of device    

  do

  {

    wdt_reset();

    if(boot_kbhit())

    {

      boot_sendchar('H');

      boot_sendchar('o');

      boot_sendchar('u');

      boot_sendchar('s');

      boot_sendchar('e');

      boot_sendchar('B');

      boot_sendchar('a');

      boot_sendchar('s');

      boot_sendchar('i');

      boot_sendchar('c');

      boot_sendchar('-');

      boot_sendchar(SystemVersion);

      boot_sendchar(LINE_FEED);

    }

  } while (boot_readchar()!=CheckedVersion); 

  while (1) 

  {

    // show a prompt

    boot_sendchar('>');

    boot_sendchar(XON);  // send XON to allow transmission

    boot_sendchar(LINE_FEED);

    ucTmp=0;

    do

    {

      wdt_reset();

      if (boot_kbhit() && ucTmp<sizeof(ucBuffer))

      {

        ucBuffer[ucTmp]=boot_readchar();

        ucTmp++;

      }

      else if(ucTmp>=sizeof(ucBuffer))

        ucBuffer[ucTmp]=BREAK;

      if (ucBuffer[ucTmp]==GoBackToLoader)

        goto BOOTSTART;

      if (ucBuffer[ucTmp]==BREAK)

      {

        ucBuffer[0]='X';  // set first character to 'X' to avoid any case match in switch

        break;

      }

    } while(ucBuffer[ucTmp-1] != LINE_ENDING);

    ucBuffer[ucTmp-1]=0;  // terminate the string at the new line position    

    boot_sendchar(XOFF);  // send XOFF to pause transmission

    boot_sendstring(ucBuffer);  // echo the command   

    // parse first character of command buffer

    switch(ucBuffer[0]) 

    {

      // jump to application at flash start 0x0000

      case 'g':  wdt_enable(WDTO_250MS);

            wdt_reset();

            boot_sendchar('+');

            boot_sendchar(XON);

            boot_sendchar(LINE_FEED);

            _delay_ms(550);  // wait until last character is transmitted to avoid loss of XON due to uart initialization in main applicatio

            app_start();  // jump to bottom of flash -> application start

            while(1);

        break;

      // read hex file and write to flash or eeprom memory

      case 'p':  boot_sendchar('+');

            boot_sendchar(LINE_FEED);

            wdt_reset();

            ucFlagEepromWrite = 0;  // default is flash programming

            // except we received an 'e' as second character

            if(ucBuffer[1] == 'e') 

            {  

              ucFlagEepromWrite = 1;  // set eeprom flag

            }

            ulPageBaseAddress = 0xFFFFFFFF;  // preset page base address to impossible value

            usPageAddressOffset = 0;  // clear offset

            usExtSegmentAddress = 0;  // clear segment address

            do 

            {

              wdt_reset();

              ucFlagError = 0;  // clear error flag

              ucFlagEof = 0;  // clear end-of-file flag

              ucFlagWrite = 0;  // clear write flag

              ucTmpPageWriting = 0;

              // read one line from hex file into the buffer

              boot_sendchar(XON);

              boot_sendchar(LINE_FEED);

              ucTmp=0;

              do 

              {

                wdt_reset();

                if(boot_kbhit())

                {

                  ucBuffer[ucTmp]=boot_readchar();

                  ucTmp++;

                }

                if (ucBuffer[ucTmp]==GoBackToLoader)

                  goto BOOTSTART;

              } while(ucBuffer[ucTmp-1] != LINE_ENDING);

              boot_sendchar(XOFF);  // send XOFF to pause transmission              

              ucBuffer[ucTmp-1]=0;

              ucTmpPageWriting++;

              //Tinys writing 4 Pages => block page erasing

              if (ucTmpPageWriting>8)

              {

                ucTmpPageWriting=1;

                ucPageWriting=0;

              }

              // grab hex record information, like byte count, address and type of record

              ucByteCount = asciiToHex2(ucBuffer[1], ucBuffer[2]);  // get the number of bytes

              ucComputedChecksum = ucByteCount;  // compute checksum

              usAddr = asciiToHex2(ucBuffer[3], ucBuffer[4]);  // get the address high byte

              ucComputedChecksum += (unsigned char)usAddr;  // compute checksum

              usAddr = (usAddr << 8) + asciiToHex2(ucBuffer[5], ucBuffer[6]);  // get the address low byte  +

              ucComputedChecksum += (unsigned char)(usAddr & 0xFF);  // compute checksum

              ucRecordType = asciiToHex2(ucBuffer[7], ucBuffer[8]);  // get the record type

              ucComputedChecksum += ucRecordType;  // compute checksum

              ucHexRecChecksum = asciiToHex2(ucBuffer[(ucByteCount*2)+9], ucBuffer[(ucByteCount*2)+10]);  // get the checksum

              //Don't overwrite the Bootloader - so fake writing

              if (usAddr>=BOOTADDR && !ucFlagEepromWrite)  //no eeprom

              {

                wdt_reset();

                ulPageBaseAddress=0xFFFFFFFF;

                usPageAddressOffset=0;

                boot_sendstring("FAKE\n");

                boot_sendchar(XOFF);

                boot_sendchar('.');  // progress indicator                

              } 

              else

              {

                // check the record type

                if(ucRecordType==2)    // extendes segment address record

                {  

                  usExtSegmentAddress = (asciiToHex2(ucBuffer[9], ucBuffer[10]) << 8);

                  ucComputedChecksum += (usExtSegmentAddress >> 8);  // compute checksum

                  usExtSegmentAddress += asciiToHex2(ucBuffer[11], ucBuffer[12]);

                  ucComputedChecksum += (usExtSegmentAddress & 0xFF);  // compute checksum

                } 

                else if(ucRecordType==1)   // end of file record

                { 

                  ucFlagEof=1;

                  ucFlagWrite=1;

                  ucTmpPageWriting=0;

                  ucPageWriting=0;

                } 

                else if(ucRecordType==0)   // data record

                { 

                  // set base address for the flash page, if not set

                  if(ulPageBaseAddress == 0xFFFFFFFF) 

                  {

                    ulPageBaseAddress = usAddr;

                  }

                  // parse the data bytes

                  for(ucTmp = 0; ucTmp < (2*ucByteCount); ucTmp += 4)  // increment by four, since we parse the ascii buffer for four ascii character (for ex. two hex numbers)

                  {  

                    wdt_reset();

                    ucDataByte = asciiToHex2(ucBuffer[ucTmp+9], ucBuffer[ucTmp+10]);  // get the low data byte

                    ucComputedChecksum += ucDataByte;  // compute checksum

                    ucTmpDataByte = asciiToHex2(ucBuffer[ucTmp+11], ucBuffer[ucTmp+12]);  // get the high data byte

                    ucComputedChecksum += ucTmpDataByte;  // compute checksum

                    // if we want to program eeprom, we store the data in another buffer

                    if(ucFlagEepromWrite == 1) 

                    { 

                      ucEepromBuffer[usPageAddressOffset] = ucDataByte;

                      ucEepromBuffer[usPageAddressOffset+1] = ucTmpDataByte;

                    } 

                    else  // flash programming

                    {  

                      wdt_reset();

                      boot_page_fill((unsigned long)(ulPageBaseAddress + usPageAddressOffset + (usExtSegmentAddress * 16)), (((unsigned short)ucTmpDataByte) << 8) + (((unsigned short)ucDataByte) & 0x00FF));

                    }

                    wdt_reset();

                    usPageAddressOffset += 2;

                  }

                }

                // check checksum

                if((unsigned char)(ucComputedChecksum + ucHexRecChecksum) != 0x00) // computed checksum plus checksum from hexfile must be zero

                {  

                  ucFlagError = 1;

                  break;        // leave do loop, we do not program anything in case we get a checksum error

                }

                boot_sendchar('.');  // progress indicator

                // check if page is filled, if so, we set the write flag

                if(usPageAddressOffset >= (SPM_PAGESIZE)) 

                {

                  ucFlagWrite = 1;

                }

                if(ucFlagEepromWrite == 1) 

                {

                  ucFlagWrite = 1;

                }

                // check if write flag is set

                if((ucFlagWrite == 1) && (ulPageBaseAddress != 0xFFFFFFFF)) 

                {

                  ulPageBaseAddress += ((unsigned long)usExtSegmentAddress * 16);  // add the extended segment address to the base address

                  // we want to write eeprom

                  if(ucFlagEepromWrite == 1) 

                  {  

                    eeprom_busy_wait();  // wait in case eeprom is busy

                    eeprom_write_block(ucEepromBuffer, (unsigned char*)(unsigned short)ulPageBaseAddress, usPageAddressOffset);

                    eeprom_busy_wait();

                  } 

                  else  // we want to write flash

                  { 

                    // check if page base address exceeds maximum address before bootloader section begins (BOOTADDR comes from -D compiler option)

                    if(ulPageBaseAddress >= (unsigned long)BOOTADDR)

                    {

                      wdt_reset();

                      ucFlagError = 1;

                      break;

                    }

                    //erasing 4 Pages ==> mage only once at times of 8 receive data strings

                    if (!ucPageWriting)

                    {

                      ucPageWriting=1;

                      boot_spm_busy_wait();

                      boot_page_erase((unsigned long)ulPageBaseAddress);  // do a page erase

                    }

                    boot_spm_busy_wait();  // wait for page erase done

                    boot_page_write((unsigned long)ulPageBaseAddress);  // do a page write

                    boot_spm_busy_wait();  // wait for write completed

                    //boot_rww_enable();  // reenable rww section again | goes bad for tinys

                  }

                  boot_sendchar('*');  // * indicates a page write

                  ulPageBaseAddress = 0xFFFFFFFF;

                  usPageAddressOffset = 0;

                }

              }

              wdt_reset();

            } while(!ucFlagError && !ucFlagEof);  // in case of retval or end of file

            // test on error and print + or -

            if(!ucFlagError) 

              boot_sendchar('+');

            else 

              boot_sendchar('-');

        break;

      // no case found, so we listen

      default:   boot_sendchar('-');

    }

  }

}

static void boot_rs232init(uint32_t baud)

{

  uint32_t UBRR_VALE=(((F_CPU+baud*8)/(baud*16)-1));

  //set Baud

  UBRR0H = (uint8_t) (UBRR_VALE >> 8);

  UBRR0L = (uint8_t) (UBRR_VALE);

  UCSR0B = (1 << RXEN0) | (1 << TXEN0);

  UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);  //8N1

}

static void boot_sendchar(char data) 

{

   // send character

  while(!(UCSR0A & (1 << UDRE0)));

    UDR0 = data;   

}

static void boot_sendstring(char *p) 

{

  while (*p)        //while not Null

  {

    boot_sendchar(*p);    //send value at pointer

    p++;        //inkrement pointer

  }

}

static char boot_readchar(void)

{

  // warten bis Zeichen verfuegbar

  if((UCSR0A & (1<<RXC0)))

    return (UDR0);   

}

volatile uint8_t boot_kbhit(void)

{

  if((UCSR0A & (1<<RXC0)))

    return 1;

  return 0;  

}

volatile uint8_t asciiToHex(uint8_t ucNibble) 

{

  // ============================================================================

  // convert hex ascii nibble ('0' - 'f'/'F') into a number

  // in: ascii character (nibble) to be converted

  // out: 4 bit hex number

  // ============================================================================

  uint8_t ucHex = 0;

  // check if ascii character is a lower case letter a-f

  if(ucNibble >= 'a' && ucNibble <= 'f') 

  {

    ucHex = (ucNibble - 'a') + 10;  //+10

  }  

  else if(ucNibble >= 'A' && ucNibble <= 'F')  // or an upper case letter A-F

  {

    ucHex = (ucNibble - 'A') + 10;  //+10

  } 

  else if(ucNibble >= '0' && ucNibble <= '9')  // or if it is a number 0-9

  {

    ucHex = (ucNibble - '0');

  }

  return (ucHex);  // return the hex number

}

volatile uint8_t asciiToHex2(uint8_t ucNibbleHigh, uint8_t ucNibbleLow) 

{

  // ============================================================================

  // convert two hex ascii nibbles into a number

  // in: two ascii characters (high, low nibble) to be converted

  // out: 8 bit hex number

  // ============================================================================

  return ((asciiToHex(ucNibbleHigh) << 4) + asciiToHex(ucNibbleLow));  // just call the function for one nibble twice +

}