razzor/avrboot
1
0
Fork 0
Code Issues Pull Requests Releases Activity
744684bb88
avrboot/main.c

447 lines
14 KiB
C
Raw Blame History

/*****************************************************************************
*
* AVRPROG compatible boot-loader
* Version : 0.2 (24. March 2004)
* Compiler : avr-gcc 3.3.1 / avr-libc 1.0
* size : ca. 610 word ( larger than 512 words :-( )
* by : Martin Thomas, Kaiserslautern, Germany
* eversmith@heizung-thomas.de
*
* based on the Butterfly Bootloader-Code
* Copyright (C) 1996-1998 Atmel Corporation
* Author(s) : BBrandal, PKastnes, ARodland, LHM
*
* The orignal code has been made available by ATMEL together with the
* Butterfly application code. Since ATMEL.NO had no problem with
* the application gcc-port they hopefully will not have any concerns about
* publishing this port. Make sure to keep the copyright notice in derived
* work to avoid trouble.
****************************************************************************
*
* Many functions used by "AVRPROG" (fuses) have been disabled by ATMEL in
* the original source code of the Butterfly Boot-loader not by me.
* Please 'diff' against the original source to see everything that has been
* changed for the gcc port.
*
* The boot interrupt vector is included (this bootloader is completly in
* ".text" section). If you need this space for further functions you have to
* add a separate section for the bootloader-functions and add an attribute
* for this section to _all_ function prototypes of functions in the loader.
* With this the interrupt vector will be placed at .0000 and the bootloader
* code (without interrupt vector) at the adress you define in the linker
* options for the newly created section. See the avr-libc FAQ and the avr-
* libc's avr/boot.h documentation for further details.
*
* For this bootloader a Boot-Size of at least 0x4C4 (1220) bytes =
* 610 words is needed. Sorry, so far efforts to shrink to 512 words failed.
* See the makefile for information how to adopt the linker-settings to
* the selected Boot Size (_Bxxx below)
*
****************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/wdt.h>
/* READFUSELOCK is untested, will not work for Mega169 since not
supported by AVRPROG 1.37 */
// #define ENABLEREADFUSELOCK
#define BAUDRATE 19200
#define XTAL 3686400
/* Select Boot Size (select one, comment out the others)
select at least _B1024 */
// NO! #define _B128
// NO! #define _B256
// NO! #define _B512
#define _B1024
//#define _B2048
#include "chipdef.h"
#define UART_RX_BUFFER_SIZE PAGESIZE
#include "lowlevel.h"
#include "uart.h"
unsigned char BufferLoad(unsigned int , unsigned char ) ;
void BlockRead(unsigned int , unsigned char ) ;
unsigned int address;
unsigned char device;
void send_boot(void)
{
sendchar('A');
sendchar('V');
sendchar('R');
sendchar('B');
sendchar('O');
sendchar('O');
sendchar('T');
}
int main(void)
{
void (*funcptr)( void ) = 0x0000; // Set up function pointer
unsigned int tempi;
char val;
char OK = 1;
PORTA = 0xFF; // Enable pullups on Port A
USART_Init(UART_BAUD_SELECT(BAUDRATE,XTAL),UARTSINGLE);
// USART_Init(UART_BAUD_SELECT(BAUDRATE/2,XTAL),UARTDOUBLE);
MCUCR = (1<<IVCE);
MCUCR = (1<<IVSEL); //move interruptvectors to the Boot sector
/* This is an adoption of the Butterfly Bootloader startup-sequence.
It may look a little strange but separating the login-loop from
the main parser-loop gives a lot a possibilities (timeout, sleep-modes
etc.).
*/
for(;OK;)
{
if((PINA & (1<<PINA7)))
{
// jump to main app if PIN A0 is not grounded
MCUCR = (1<<IVCE);
MCUCR = (0<<IVSEL); //move interruptvectors to the Application sector
funcptr(); // Jump to application sector
}
else
{
val = recchar();
if( val == 0x1B)
{ // AVRPROG connection
while (val != 'S') // Wait for signon
{
val = recchar();
}
send_boot(); // Report signon
OK = 0;
}
else
sendchar('?');
}
}
for(;;)
{
val=recchar();
if(val=='a') //Autoincrement?
{
sendchar('Y'); //Autoincrement is quicker
}
else if(val=='A') //write address
{
address=recchar(); //read address 8 MSB
address=(address<<8)|recchar();
address=address<<1; //convert from word address to byte address
sendchar('\r');
}
else if(val=='b')
{ // Buffer load support
sendchar('Y'); // Report buffer load supported
sendchar((UART_RX_BUFFER_SIZE >> 8) & 0xFF);
// Report buffer size in bytes
sendchar(UART_RX_BUFFER_SIZE & 0xFF);
}
else if(val=='B') // Start buffer load
{
tempi = recchar() << 8; // Load high byte of buffersize
tempi |= recchar(); // Load low byte of buffersize
val = recchar(); // Load memory type ('E' or 'F')
sendchar (BufferLoad(tempi,val));
// Start downloading of buffer
}
else if(val == 'g') // Block read
{
tempi = (recchar() << 8) | recchar();
val = recchar(); // Get memtype
BlockRead(tempi,val); // Perform the block read
}
/*
else if(val=='c') //Write program memory, low byte
{
ldata=recchar();
sendchar('\r');
}
else if(val== 'C') //Write program memory, high byte
{
data=ldata|(recchar()<<8);
if (device == devtype)
{
fill_temp_buffer(data,(address)); //call asm routine.
}
address=address+2;
sendchar('\r');
}
*/
else if(val=='e') //Chip erase
{
if (device == devtype)
{
for(address=0;address < APP_END;address += PAGESIZE) //Application section = 60 pages
{
write_page(address,(1<<PGERS) + (1<<SPMEN)); //Perform page erase
write_page(address,(1<<RWWSRE) + (1<<SPMEN)); //Re-enable the RWW section
}
}
write_page(address,(1<<RWWSRE) + (1<<SPMEN)); //Re-enable the RWW section
sendchar('\r');
}
else if(val=='E') //Exit upgrade
{
// WDTCR = (1<<WDTCE) | (1<<WDE); //Enable Watchdog Timer to give reset
wdt_enable(WDTO_15MS);
sendchar('\r');
}
/*
else if(val=='l') // write lockbits
{
if (device == devtype)
{
write_lock_bits(recchar());
}
sendchar('\r');
}
else if(val== 'm') // write page
{
if (device == devtype)
{
write_page(address,(1<<PGERS) + (1<<SPMEN)); //Perform page erase
write_page((address),0x05);
write_page(address,(1<<RWWSRE) + (1<<SPMEN)); //Re-enable the RWW section
}
sendchar('\r');
}
*/
else if(val=='P') // Enter programming mode
{
sendchar('\r');
}
else if(val=='L') // Leave programming mode
{
sendchar('\r');
}
else if (val=='p') // mt: return programmer type
{
sendchar('S'); // serial programmer
}
/*
else if(val=='R') //Read program memory
{
write_page(0,(1<<RWWSRE) + (1<<SPMEN)); //Re-enable the RWW section
// SPMCSR = (1<<RWWSRE) | (1<<SPMEN);
// __store_program_memory();
// while((SPMCSR & 0x01));
intval=read_program_memory(address,0x00);
sendchar((char)(intval>>8)); //send MSB
sendchar((char)intval); //send LSB
address=address+2;
}
else if (val == 'D') // write EEPROM
{
if (device == devtype)
{
EEARL = address;
EEARH = (address >> 8);
address++;
EEDR = recchar();
EECR |= (1<<EEMWE);
EECR |= (1<<EEWE);
while (EECR & (1<<EEWE))
;
}
sendchar('\r');
}
else if (val == 'd') // read eeprom
{
EEARL = address;
EEARH = (address >> 8);
address++;
EECR |= (1<<EERE);
sendchar(EEDR);
}
*/
#ifdef ENABLEREADFUSELOCK
#warning "Extension 'ReadFuseLock' enabled"
// mt TODO: Read fuse bit seems to work for clock speed, other settings are not
// interpreted correctly. Locks and high fuse do not work at all (in AVRPROG 1.37)
// Reason for this should be the difference between ATmega16 and ATmega169.
// AVRPROG interprets the results as from an ATmega16 while they are from an ATmega169
else if(val=='F') // read fuse bits
{
sendchar(read_program_memory(0x0000,0x09)); // 0x09 for (1<<BLBSET)|(1<<SPMEN)
}
else if(val=='r') // read lock bits
{
sendchar(read_program_memory(0x0001,0x09));
}
else if(val=='N') // read high fuse bits
{
// mt sendchar(read_program_memory(0x0003));
sendchar(read_program_memory(0x0003,0x09));
}
else if(val=='Q') // read extended fuse bits
{
sendchar(read_program_memory(0x0002,0x09));
}
#endif
// end of ENABLEREADFUSELOCK section
else if(val=='t') // Return programmer type
{
sendchar(devtype);
sendchar(0);
}
else if ((val=='x')||(val=='y')) // clear and set LED ignored
{
recchar();
sendchar('\r');
}
else if (val=='T') // set device/programmer type in bootloader (?)
{
device = recchar();
sendchar('\r');
}
else if (val=='S') // Return software identifier
{
send_boot();
}
else if (val=='V') // Return Software Version
{
sendchar('0'); // mt: changed from 2;0 to 0;1
sendchar('2');
}
else if (val=='s') // Return Signature Byte
{
sendchar(sig_byte1);
sendchar(sig_byte2);
sendchar(sig_byte3);
}
else if(val!=0x1b) // if not esc
{
sendchar('?');
}
} // "parser" for-loop
return 0;
}
unsigned char BufferLoad(unsigned int size, unsigned char mem)
{
int data, tempaddress;
tempaddress = address; // Store address in page
if (device == devtype)
{
if (mem == 'F')
{
do {
data = recchar();
data |= (recchar() << 8);
fill_temp_buffer(data,(address));
//call asm routine.
address=address+2; // Select next word in memory
size -= 2; // Reduce number of bytes to write by two
} while(size); // Loop until all bytes written
tempaddress &= 0xFF80; // Ensure the address points to the first byte in the page
write_page((tempaddress),0x05); // Program page contents
write_page(tempaddress,(1<<RWWSRE) + (1<<SPMEN));
//Re-enable the RWW section
if (address != (address & 0xFF80))
{ // Ensure that the address points to the beginning of the next page
address &= 0xFF80;
address += PAGESIZE;
}
} // End FLASH
if (mem == 'E') // Start EEPROM
{
do {
EEARL = address; // Setup EEPROM address
EEARH = (address >> 8);
address++; // Select next byte
EEDR = recchar(); // Load data to write
EECR |= (1<<EEMWE); // Write data into EEPROM
EECR |= (1<<EEWE);
while (EECR & (1<<EEWE)) // Wait for EEPROM write to finish
;
size--; // Decreas number of bytes to write
} while(size); // Loop until all bytes written
}
return '\r'; // Report programming OK
}
return 0; // Report programming failed
}
void BlockRead(unsigned int size, unsigned char mem)
{
unsigned int data;
if (mem == 'E') // Read EEPROM
{
do {
EEARL = address; // Setup EEPROM address
EEARH = (address >> 8);
address++; // Select next EEPROM byte
EECR |= (1<<EERE); // Read EEPROM
sendchar(EEDR); // Transmit EEPROM data to PC
size--; // Decrease number of bytes to read
} while (size); // Repeat until all block has been read
}
else // Read Flash
{
do {
data = read_program_memory(address,0x00);
sendchar((char)data); //send LSB
sendchar((char)(data >> 8)); //send MSB
address += 2; // Select next word in memory
size -= 2; // Subtract two bytes from number of bytes to read
} while (size); // Repeat until all block has been read
}
}
Reference in New Issue View Git Blame Copy Permalink