AVR Bootloader for MK-FlightCtrl
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

504 lines
11 KiB

/***************************************************************************
* Copyright (C) 09/2007 by Olaf Rempel *
* razzor@kopf-tisch.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; version 2 of the License, *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/boot.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
/*
* ATMega 644P:
* Fuse E: 0xFD (2.7V BOD)
* Fuse H: 0xDC (1024 words bootloader)
* Fuse L: 0xFF (ext. Crystal)
*/
#define F_CPU 20000000
#include <util/delay.h>
#define BAUDRATE 57600
#define UART_CALC_BAUDRATE(baudRate) ((uint32_t)(F_CPU) / ((uint32_t)(baudRate)*16) -1)
#define APP_END 0xF7FF
#define LED_RT (1<<PORTB0) /* low active */
#define LED_GN (1<<PORTB1) /* high active */
#define TWI_CLK 100000
#define TWI_ADDRESS_BASE 0x28 /* 0x29 - 0x2C */
#define TWI_DEVCODE 0x76 /* Mega8 */
#define OWN_DEVCODE 0x74 /* Mega644 */
#define OWN_SIGNATURE { 0x1E, 0x96, 0x0A } /* Mega644P */
/* SLA+R */
#define CMD_WAIT 0x00
#define CMD_READ_VERSION 0x01
#define CMD_READ_MEMORY 0x02
/* SLA+W */
#define CMD_SWITCH_APPLICATION CMD_READ_VERSION
#define CMD_WRITE_MEMORY CMD_READ_MEMORY
/* CMD_SWITCH_APPLICATION parameter */
#define BOOTTYPE_BOOTLOADER 0x00
#define BOOTTYPE_APPLICATION 0x80
/* CMD_{READ|WRITE}_* parameter */
#define MEMTYPE_CHIPINFO 0x00
#define MEMTYPE_FLASH 0x01
#define MEMTYPE_EEPROM 0x02
#define MEMTYPE_PARAMETERS 0x03
static void sendchar(uint8_t data)
{
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = data;
}
static uint8_t recvchar(void)
{
loop_until_bit_is_set(UCSR0A, RXC0);
return UDR0;
}
static void i2c_master_tx(uint8_t val)
{
TWDR = val;
TWCR = (1<<TWINT) | (1<<TWEN);
loop_until_bit_is_set(TWCR, TWINT);
}
static uint8_t i2c_master_rx(uint8_t ack)
{
if (ack)
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
else
TWCR = (1<<TWINT) | (1<<TWEN);
loop_until_bit_is_set(TWCR, TWINT);
return TWDR;
}
static void i2c_stop(void)
{
PORTB |= LED_RT;
TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN);
}
static void i2c_start_address(uint8_t addr)
{
while (1) {
PORTB &= ~LED_RT;
TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
loop_until_bit_is_set(TWCR, TWINT);
i2c_master_tx(addr);
uint8_t status = (TWSR & 0xF8);
if (status == 0x18 || status == 0x40)
break;
i2c_stop();
_delay_ms(1);
}
}
static void i2c_switch_app(uint8_t i2c_dev, uint8_t app, uint8_t show_version)
{
i2c_start_address(i2c_dev);
i2c_master_tx(CMD_SWITCH_APPLICATION);
i2c_master_tx(app);
i2c_stop();
_delay_ms(100);
if (show_version) {
i2c_start_address(i2c_dev);
i2c_master_tx(CMD_READ_VERSION);
i2c_start_address(i2c_dev | 0x01);
uint8_t cnt = 16;
while (cnt--) {
sendchar(i2c_master_rx(cnt));
}
i2c_stop();
}
}
static uint8_t page_buf[SPM_PAGESIZE];
static void eraseFlash(void)
{
uint16_t address = 0;
while (APP_END > address) {
boot_page_erase(address);
boot_spm_busy_wait();
address += SPM_PAGESIZE;
}
boot_rww_enable();
}
static void writeFlashPage(uint16_t address, uint16_t size)
{
uint16_t pagestart = address;
uint16_t data;
uint8_t *tmp = page_buf;
do {
data = *tmp++;
data |= *tmp++ << 8;
boot_page_fill(address, data);
address += 2;
size -= 2;
} while (size);
boot_page_write(pagestart);
boot_spm_busy_wait();
boot_rww_enable();
}
static void writeEEpromPage(uint16_t address, uint16_t size)
{
uint8_t *tmp = page_buf;
do {
EEARL = address;
EEARH = (address >> 8);
EEDR = *tmp++;
address++;
EECR |= (1<<EEMPE);
EECR |= (1<<EEPE);
eeprom_busy_wait();
size--;
} while (size);
}
static void readFlashPage(uint16_t address, uint16_t size)
{
uint16_t data;
do {
data = pgm_read_word_near(address);
sendchar(data);
sendchar((data >> 8));
address += 2;
size -= 2;
} while (size);
}
static void readEEpromPage(uint16_t address, uint16_t size)
{
do {
EEARL = address;
EEARH = (address >> 8);
EECR |= (1<<EERE);
address++;
sendchar(EEDR);
size--;
} while (size);
}
/* 0-2: signature, 3: pagesize, 4-5: flash size, 6-7: eeprom size */
static uint8_t chipinfo[8];
void cmd_loop(uint8_t val)
{
uint16_t address = 0;
uint16_t page_size = 0;
uint8_t i2c_dev = 0;
while (1) {
uint8_t response = 0xFF;
// Autoincrement?
if (val == 'a') {
response = 'Y';
// write address
} else if (val == 'A') {
address = recvchar();
address = (address << 8) | recvchar();
response = '\r';
// Buffer load support
} else if (val == 'b') {
sendchar('Y');
page_size = (i2c_dev == 0) ? sizeof(page_buf) : chipinfo[3];
sendchar((page_size >> 8) & 0xFF);
response = page_size & 0Xff;
// Start buffer load
} else if (val == 'B') {
uint16_t size;
uint16_t cnt;
uint8_t *tmp = page_buf;
size = recvchar() << 8;
size |= recvchar();
val = recvchar();
for (cnt = 0; cnt < page_size; cnt++)
*tmp++ = (cnt < size) ? recvchar() : 0xFF;
if (i2c_dev != 0) {
i2c_start_address(i2c_dev);
i2c_master_tx(CMD_WRITE_MEMORY);
i2c_master_tx((val == 'F') ? MEMTYPE_FLASH : MEMTYPE_EEPROM);
i2c_master_tx(address >> 8);
i2c_master_tx(address & 0xFF);
address += page_size;
tmp = page_buf;
while (cnt--)
i2c_master_tx(*tmp++);
i2c_stop();
} else {
if (val == 'F' && address < APP_END) {
writeFlashPage(address, size);
} else if (val == 'E' && address < E2END) {
writeEEpromPage(address, size);
}
address += size;
}
response = '\r';
// Block read
} else if (val == 'g') {
uint16_t size = recvchar() << 8;
size |= recvchar();
val = recvchar();
if (i2c_dev != 0) {
i2c_start_address(i2c_dev);
i2c_master_tx(CMD_READ_MEMORY);
i2c_master_tx((val == 'F') ? MEMTYPE_FLASH : MEMTYPE_EEPROM);
i2c_master_tx(address >> 8);
i2c_master_tx(address & 0xFF);
i2c_start_address(i2c_dev | 0x01);
while (size--) {
sendchar(i2c_master_rx(size > 0));
address++;
}
i2c_stop();
} else {
if (val == 'F') {
readFlashPage(address, size);
} else if (val == 'E') {
readEEpromPage(address, size);
}
address += size;
}
// Chip erase
} else if (val == 'e') {
if (i2c_dev == 0) {
eraseFlash();
}
response = '\r';
// Exit upgrade
} else if (val == 'E') {
sendchar('\r');
if (i2c_dev == 0) {
return;
}
// Enter / Leave programming mode
} else if (val == 'P' || val == 'L') {
if (i2c_dev != 0) {
val = (val == 'P') ? BOOTTYPE_BOOTLOADER : BOOTTYPE_APPLICATION;
i2c_switch_app(i2c_dev, val, 0);
}
response = '\r';
// return programmer type
} else if (val == 'p') {
response = 'S';
// Return device type
} else if (val == 't') {
sendchar((i2c_dev == 0) ? OWN_DEVCODE : TWI_DEVCODE);
response = '\0';
// clear and set LED ignored
} else if ((val == 'x') || (val == 'y') || (val == 'T')) {
recvchar();
response = '\r';
// Return software identifier
} else if (val == 'S') {
sendchar('F');
sendchar('C');
sendchar('_');
sendchar('B');
sendchar('O');
sendchar('O');
response = 'T';
// Return Software Version
} else if (val == 'V' || val == 'v') {
sendchar('0');
response = '8';
// Return Signature Bytes
} else if (val == 's') {
if (i2c_dev != 0) {
sendchar(chipinfo[2]);
sendchar(chipinfo[1]);
response = chipinfo[0];
} else {
uint8_t sig[3] = OWN_SIGNATURE;
sendchar(sig[2]);
sendchar(sig[1]);
response = sig[0];
}
// set i2c target
} else if (val == '0') {
i2c_dev = 0;
} else if (val >= '1' && val <= '4') {
i2c_dev = (val - '0' + TWI_ADDRESS_BASE) << 1;
i2c_switch_app(i2c_dev, BOOTTYPE_BOOTLOADER, 1);
i2c_start_address(i2c_dev);
i2c_master_tx(CMD_READ_MEMORY);
i2c_master_tx(MEMTYPE_CHIPINFO);
i2c_master_tx(0x00);
i2c_master_tx(0x00);
i2c_start_address(i2c_dev | 0x01);
uint8_t i;
for (i = 0; i < sizeof(chipinfo); i++) {
uint8_t more = (i < (sizeof(chipinfo) -1));
chipinfo[i] = i2c_master_rx(more);
}
i2c_stop();
// test props
} else if (val == 'k' || val == 'l') {
if (i2c_dev != 0) {
i2c_start_address(i2c_dev);
i2c_master_tx(0x00 + (val - 'k') * 0x10);
i2c_stop();
response = val;
}
// get Version
} else if (val == 'I') {
if (i2c_dev != 0) {
i2c_switch_app(i2c_dev, BOOTTYPE_APPLICATION, 1);
}
// fake MK-TOOL specific stuff
} else if (val == 0xAA) {
sendchar('M');
sendchar('K');
sendchar('B');
response = 'L';
/* ESC */
} else if (val != 0x1b) {
response = '?';
}
if (response != 0xFF) {
sendchar(response);
}
val = recvchar();
}
}
static void (*jump_to_app)(void) __attribute__ ((noreturn)) = 0x0000;
/*
* For newer devices the watchdog timer remains active even after a
* system reset. So disable it as soon as possible.
* automagically called on startup
*/
void disable_wdt_timer(void) __attribute__((naked, section(".init3")));
void disable_wdt_timer(void)
{
MCUSR = 0;
WDTCSR = (1<<WDCE) | (1<<WDE);
WDTCSR = (0<<WDE);
}
/* linking without vectors, still need __vector_default */
void __vector_default(void) {}
int main(void) __attribute__ ((noreturn));
int main(void)
{
DDRB = LED_GN | LED_RT;
PORTB = LED_RT;
/* Set baudrate */
UBRR0H = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UBRR0L = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
/* USART: rx/tx enable, 8n1 */
UCSR0B = (1<<TXEN0) | (1<<RXEN0);
UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
/* enable TWI interface */
TWBR = ((F_CPU/TWI_CLK)-16)/2;
TWCR = (1<<TWSTO) | (1<<TWEN);
uint8_t prev = 0x00;
uint8_t boot_timeout = 100;
while (boot_timeout-- > 0) {
if (UCSR0A & (1<<RXC0)) {
uint8_t val = recvchar();
if (prev == 0x1B && (val == 0xAA || val == 'S')) {
PORTB |= LED_GN;
cmd_loop(val);
boot_timeout = 0;
}
prev = val;
}
_delay_ms(10);
if (!(boot_timeout & 0x03))
PORTB ^= LED_GN;
}
PORTB = LED_RT;
jump_to_app();
}