2011-06-25 16:19:18 +02:00
|
|
|
/***************************************************************************
|
|
|
|
* C based avr910 / avr109 ISP Adapter *
|
|
|
|
* *
|
|
|
|
* Copyright (C) 2006 - 20011 by Olaf Rempel *
|
|
|
|
* razzor AT kopf MINUS tisch DOT 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/pgmspace.h>
|
|
|
|
#include <avr/interrupt.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
|
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
/* *********************************************************************** */
|
|
|
|
#if defined(CONFIG_ispprog)
|
2006-05-07 15:35:21 +02:00
|
|
|
/*
|
|
|
|
* using ATmega16 @7.3728MHz:
|
2011-06-25 16:19:18 +02:00
|
|
|
* Fuse H: 0xDA (512 words bootloader, jtag disabled)
|
|
|
|
* Fuse L: 0xFF (ext. Crystal)
|
2006-05-07 15:35:21 +02:00
|
|
|
*/
|
2012-11-18 13:12:27 +01:00
|
|
|
#define F_CPU 7372800
|
|
|
|
#define BAUDRATE 115200
|
|
|
|
#define TIMER_RELOAD (0xFF - 72) /* 10ms @7.3728MHz */
|
2006-05-05 19:02:04 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
#define ISP_RESET PORTB1 /* to target */
|
|
|
|
#define ISP_LED PORTB3 /* low active */
|
|
|
|
#define ISP_MOSI PORTB5 /* to target */
|
|
|
|
#define ISP_MISO PORTB6 /* to target */
|
|
|
|
#define ISP_SCK PORTB7 /* to target */
|
|
|
|
#define RESET_IN PORTD3 /* high active */
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
#define ISP_INACTIVE() { /* ISP_SCK, ISP_MOSI and ISP_RESET are inputs */ \
|
|
|
|
DDRB &= ~((1<<ISP_SCK) | (1<<ISP_MOSI) | (1<<ISP_RESET)); \
|
|
|
|
PORTB |= (1<<ISP_RESET); \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ISP_ACTIVE() { /* ISP_SCK, ISP_MOSI and ISP_RESET are outputs, set ISP_RESET low */ \
|
|
|
|
DDRB |= ((1<<ISP_SCK) | (1<<ISP_MOSI) | (1<<ISP_RESET)); \
|
|
|
|
PORTB &= ~(1<<ISP_RESET); \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ISP_LED_ON() { PORTB &= ~(1<<ISP_LED); };
|
|
|
|
#define ISP_LED_OFF() { PORTB |= (1<<ISP_LED); };
|
|
|
|
#define ISP_CHECK() (PIND & (1<<RESET_IN))
|
|
|
|
|
|
|
|
#define GPIO_INIT() { /* ISP_RESET and ISP_LED are outputs, pullup SlaveSelect */ \
|
|
|
|
PORTB = (1<<ISP_RESET) | (1<<ISP_LED) | (1<<PORTB4); \
|
|
|
|
DDRB = (1<<ISP_RESET) | (1<<ISP_LED); \
|
|
|
|
};
|
|
|
|
|
|
|
|
/* *********************************************************************** */
|
|
|
|
#elif defined(CONFIG_ispprog2)
|
|
|
|
/*
|
|
|
|
* using ATmega328P @8MHz:
|
|
|
|
* Fuse E: 0xFA (2.7V BOD)
|
|
|
|
* Fuse H: 0xDC (512 words bootloader)
|
|
|
|
* Fuse L: 0xE2 (internal osc)
|
|
|
|
*/
|
|
|
|
#define F_CPU 8000000
|
|
|
|
#define BAUDRATE 115200
|
|
|
|
#define TIMER_RELOAD (0xFF - 78) /* 10ms @8MHz */
|
|
|
|
|
|
|
|
/* trim internal oscillator to get "good" baudrate */
|
|
|
|
#define OSCCAL_VALUE 0x80
|
|
|
|
|
|
|
|
#define ISP_RESET PORTB2 /* to target */
|
|
|
|
#define ISP_LED PORTB0 /* high active */
|
|
|
|
#define ISP_MOSI PORTB3 /* to target */
|
|
|
|
#define ISP_MISO PORTB4 /* to target */
|
|
|
|
#define ISP_SCK PORTB5 /* to target */
|
|
|
|
#define RESET_IN PORTB1 /* low active */
|
|
|
|
|
2014-10-14 21:45:04 +02:00
|
|
|
#define ISP_INACTIVE() { /* ISP_SCK, ISP_MOSI are inputs, set ISP_RESET high */ \
|
|
|
|
DDRB &= ~((1<<ISP_SCK) | (1<<ISP_MOSI)); \
|
2014-10-12 11:13:30 +02:00
|
|
|
PORTB |= (1<<ISP_RESET); \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ISP_ACTIVE() { /* ISP_SCK, ISP_MOSI and ISP_RESET are outputs, set ISP_RESET low */ \
|
2014-10-14 21:45:04 +02:00
|
|
|
DDRB |= ((1<<ISP_SCK) | (1<<ISP_MOSI)); \
|
2014-10-12 11:13:30 +02:00
|
|
|
PORTB &= ~(1<<ISP_RESET); \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ISP_LED_ON() { PORTB |= (1<<ISP_LED); };
|
|
|
|
#define ISP_LED_OFF() { PORTB &= ~(1<<ISP_LED); };
|
|
|
|
#define ISP_CHECK() !(PINB & (1<<RESET_IN))
|
|
|
|
|
|
|
|
#define GPIO_INIT() { /* ISP_RESET and ISP_LED are outputs, pullup RESET_IN and SlaveSelect */ \
|
|
|
|
PORTB = (1<<ISP_RESET) | (1<<RESET_IN) | (1<<PORTB2); \
|
|
|
|
DDRB = (1<<ISP_RESET) | (1<<ISP_LED); \
|
|
|
|
};
|
|
|
|
|
|
|
|
/* *********************************************************************** */
|
|
|
|
#else
|
|
|
|
#error "unknown CONFIG"
|
|
|
|
#endif
|
|
|
|
/* *********************************************************************** */
|
|
|
|
|
2008-03-27 20:06:02 +01:00
|
|
|
#include <util/delay.h>
|
|
|
|
#define UART_CALC_BAUDRATE(baudRate) (((uint32_t)F_CPU) / (((uint32_t)baudRate)*16) -1)
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2011-06-25 16:19:18 +02:00
|
|
|
/* F_CPU /4 (1.8432MHz) */
|
2012-11-18 13:12:27 +01:00
|
|
|
#define SPI_MODE4 ((1<<SPE) | (1<<MSTR))
|
2011-06-25 16:19:18 +02:00
|
|
|
/* F_CPU /16 (460.8kHz) */
|
2014-10-14 21:56:16 +02:00
|
|
|
#define SPI_MODE3 ((1<<SPE) | (1<<MSTR) | (1<<SPR0))
|
2011-06-25 16:19:18 +02:00
|
|
|
/* F_CPU /64 (115.2kHz) */
|
2014-10-14 21:56:16 +02:00
|
|
|
#define SPI_MODE2 ((1<<SPE) | (1<<MSTR) | (1<<SPR1))
|
2011-06-25 16:19:18 +02:00
|
|
|
/* F_CPU /128 (57.6kHz) */
|
2012-11-18 13:12:27 +01:00
|
|
|
#define SPI_MODE1 ((1<<SPE) | (1<<MSTR) | (1<<SPR1) | (1<<SPR0))
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
static const uint8_t spi_modes[4] = { SPI_MODE1, SPI_MODE2, SPI_MODE3, SPI_MODE4 };
|
|
|
|
|
|
|
|
#define SPI_SPEED_PROBE 0xFF
|
|
|
|
|
|
|
|
static uint8_t spi_speed = SPI_SPEED_PROBE;
|
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
#define POLL_00 0x01 /* value 0x00 can not be polled from flash/eeprom */
|
|
|
|
#define POLL_7F 0x02 /* value 0x7F can not be polled from flash/eeprom */
|
|
|
|
#define POLL_80 0x04 /* value 0x80 can not be polled from flash/eeprom */
|
|
|
|
#define POLL_FF 0x08 /* value 0xFF can not be polled from flash/eeprom */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
|
|
|
struct _device {
|
2012-11-18 13:12:27 +01:00
|
|
|
uint8_t sig[3]; /* device signature */
|
|
|
|
uint8_t devcode; /* avr910 device code */
|
2012-12-31 13:16:35 +01:00
|
|
|
uint16_t pagemask; /* pagemask (pagesize in words!) */
|
2012-11-18 13:12:27 +01:00
|
|
|
uint16_t flags; /* quirks for this device */
|
2011-06-25 16:19:18 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct _device device;
|
|
|
|
|
2012-12-31 13:16:35 +01:00
|
|
|
static const struct _device devices[] PROGMEM = {
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x90, 0x01 }, 0x13, 0x00, POLL_00 | POLL_FF }, /* at90s1200 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x90, 0x05 }, 0x55, ???, ??? }, /* tiny12 */
|
|
|
|
// { { 0x1E, 0x90, 0x06 }, 0x56, ???, ??? }, /* tiny15 */
|
|
|
|
// { { 0x1E, 0x90, 0x07 }, 0xFF, ???, ??? }, /* tiny13 */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x91, 0x01 }, 0x20, 0x00, POLL_7F | POLL_80 | POLL_FF }, /* at90s2313 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x91, 0x02 }, 0x48, ???, ??? }, /* at90s2323 */
|
|
|
|
// { { 0x1E, 0x91, 0x03 }, 0x4C, ???, ??? }, /* at90s2343 */
|
|
|
|
// { { 0x1E, 0x91, 0x05 }, 0x34, ???, ??? }, /* at90s2333 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x91, 0x08 }, 0x20, 0x0F, POLL_FF }, /* tiny25 (at90s2313 devcode) */
|
|
|
|
{ { 0x1E, 0x91, 0x09 }, 0x5E, 0x0F, POLL_FF }, /* tiny26 */
|
|
|
|
{ { 0x1E, 0x91, 0x0A }, 0x5E, 0x0F, POLL_FF }, /* tiny2313 (tiny26 devcode) */
|
|
|
|
{ { 0x1E, 0x91, 0x0B }, 0x20, 0x0F, POLL_FF }, /* tiny24 (at90s2313 devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x91, 0x0C }, 0xFF, 0x0F, POLL_FF }, /* tiny261a */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x92, 0x01 }, 0x28, ???, ??? }, /* at90s4414 */
|
|
|
|
// { { 0x1E, 0x92, 0x02 }, 0x6C, ???, ??? }, /* at90s4434 */
|
|
|
|
// { { 0x1E, 0x92, 0x03 }, 0x30, ???, ??? }, /* at90s4433 */
|
|
|
|
// { { 0x1E, 0x92, 0x05 }, 0xFF, 0x1F, POLL_FF }, /* mega48 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x92, 0x06 }, 0x20, 0x1F, POLL_FF }, /* tiny45 (at90s2313 devcode) */
|
|
|
|
{ { 0x1E, 0x92, 0x07 }, 0x20, 0x1F, POLL_FF }, /* tiny44 (at90s2313 devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x92, 0x08 }, 0xFF, 0x1F, POLL_FF }, /* mega461a */
|
|
|
|
// { { 0x1E, 0x92, 0x0A }, 0xFF, 0x1F, POLL_FF }, /* mega48pa */
|
|
|
|
// { { 0x1E, 0x92, 0x0D }, 0x5E, 0x1F, POLL_FF }, /* tiny4313 (tiny26 devcode) */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x93, 0x01 }, 0x38, 0x00, POLL_7F | POLL_80 | POLL_FF }, /* at90s8515 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x93, 0x03 }, 0x68, ???, ??? }, /* at90s8535 */
|
|
|
|
// { { 0x1E, 0x93, 0x05 }, 0x65, ???, ??? }, /* mega83 */
|
|
|
|
// { { 0x1E, 0x93, 0x06 }, 0x3A, 0x1F, POLL_FF }, /* mega8515 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x93, 0x07 }, 0x76, 0x1F, POLL_00 | POLL_FF }, /* mega8 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x93, 0x08 }, 0x69, 0x1F, POLL_FF }, /* mega8535 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x93, 0x0A }, 0xFF, 0x1F, POLL_FF }, /* mega88 (no devcode) */
|
|
|
|
{ { 0x1E, 0x93, 0x0B }, 0x20, 0x1F, POLL_FF }, /* tiny85 (at90s2313 devcode) */
|
|
|
|
{ { 0x1E, 0x93, 0x0C }, 0x20, 0x1F, POLL_FF }, /* tiny84 (at90s2313 devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x93, 0x0D }, 0xFF, 0x1F, POLL_FF }, /* tiny861a */
|
|
|
|
// { { 0x1E, 0x93, 0x0F }, 0xFF, 0x1F, POLL_FF }, /* mega88pa */
|
|
|
|
// { { 0x1E, 0x93, 0x11 }, 0xFF, 0x1F, POLL_FF }, /* tiny88 */
|
|
|
|
// { { 0x1E, 0x93, 0x81 }, 0xFF, 0x1F, POLL_FF }, /* at90pwm2/3 */
|
|
|
|
// { { 0x1E, 0x93, 0x82 }, 0xFF, 0x3F, POLL_FF }, /* at90usb82 */
|
|
|
|
// { { 0x1E, 0x93, 0x83 }, 0xFF, 0x1F, POLL_FF }, /* at90pwm2b/3b */
|
|
|
|
// { { 0x1E, 0x93, 0x89 }, 0xFF, 0x1F, POLL_FF }, /* mega8u2 */
|
|
|
|
|
|
|
|
// { { 0x1E, 0x94, 0x01 }, 0x60, ???, ??? }, /* mega161 */
|
|
|
|
// { { 0x1E, 0x94, 0x02 }, 0x64, ???, ??? }, /* mega163 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x94, 0x03 }, 0x74, 0x3F, POLL_FF }, /* mega16 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x94, 0x04 }, 0x63, 0x3F, POLL_FF }, /* mega162 */
|
|
|
|
// { { 0x1E, 0x94, 0x05 }, 0x78, 0x3F, POLL_FF }, /* mega169 */
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x94, 0x06 }, 0xFF, 0x3F, POLL_FF }, /* mega168 (no devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x94, 0x0A }, 0x74, 0x3F, POLL_FF }, /* mega164pa (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x94, 0x0B }, 0xFF, 0x3F, POLL_FF }, /* mega168pa */
|
|
|
|
// { { 0x1E, 0x94, 0x0F }, 0xFF, 0x3F, POLL_FF }, /* mega164a */
|
|
|
|
// { { 0x1E, 0x94, 0x82 }, 0xFF, 0x3F, POLL_FF }, /* at90usb162 */
|
|
|
|
// { { 0x1E, 0x94, 0x88 }, 0xFF, 0x3F, POLL_FF }, /* mega16u4 */
|
|
|
|
// { { 0x1E, 0x94, 0x89 }, 0xFF, 0x3F, POLL_FF }, /* mega16u2 */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x95, 0x02 }, 0x72, 0x3F, POLL_FF }, /* mega32 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x95, 0x03 }, 0x75, 0x3F, POLL_FF }, /* mega329 (mega169 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x04 }, 0x75, 0x3F, POLL_FF }, /* mega3290 (mega169 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x05 }, 0x74, 0x3F, POLL_FF }, /* mega325 (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x06 }, 0x74, 0x3F, POLL_FF }, /* mega3250 (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x08 }, 0x74, 0x3F, POLL_FF }, /* mega324p (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x0B }, 0x75, 0x3F, POLL_FF }, /* mega329p (mega169 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x0C }, 0x75, 0x3F, POLL_FF }, /* mega3290p (mega169 devcode) */
|
2014-09-29 22:26:41 +02:00
|
|
|
{ { 0x1E, 0x95, 0x0F }, 0xFF, 0x3F, POLL_FF }, /* mega328p (no devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x95, 0x11 }, 0x74, 0x3F, POLL_FF }, /* mega324pa (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x95, 0x15 }, 0xFF, 0x3F, POLL_FF }, /* mega324a */
|
|
|
|
// { { 0x1E, 0x95, 0x81 }, 0xFF, 0x3F, POLL_FF }, /* at90can32 */
|
2012-12-31 13:16:35 +01:00
|
|
|
{ { 0x1E, 0x95, 0x87 }, 0xFF, 0x3F, POLL_FF }, /* mega32u4 (no devcode) */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x95, 0x8A }, 0xFF, 0x3F, POLL_FF }, /* mega32u2 */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x96, 0x02 }, 0x45, 0x7F, POLL_FF }, /* mega64 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x96, 0x03 }, 0x75, 0x7F, POLL_FF }, /* mega649 (mega169 devcode) */
|
|
|
|
// { { 0x1E, 0x96, 0x04 }, 0x75, 0x7F, POLL_FF }, /* mega6490 (mega169 devcode) */
|
|
|
|
// { { 0x1E, 0x96, 0x05 }, 0x74, 0x7F, POLL_FF }, /* mega645 (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x96, 0x06 }, 0x74, 0x7F, POLL_FF }, /* mega6450 (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x96, 0x08 }, 0xFF, 0x7F, POLL_FF }, /* mega640 */
|
|
|
|
{ { 0x1E, 0x96, 0x09 }, 0x74, 0x7F, POLL_FF }, /* mega644a (mega16 devcode) */
|
|
|
|
{ { 0x1E, 0x96, 0x0A }, 0x74, 0x7F, POLL_FF }, /* mega644pa (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x96, 0x81 }, 0xFF, 0x7F, POLL_FF }, /* at90can64 */
|
|
|
|
// { { 0x1E, 0x96, 0x82 }, 0xFF, 0x7F, POLL_FF }, /* at90usb646/647 */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
{ { 0x1E, 0x97, 0x01 }, 0x41, 0x7F, POLL_7F | POLL_80 | POLL_FF }, /* mega103 */
|
|
|
|
{ { 0x1E, 0x97, 0x02 }, 0x43, 0x7F, POLL_FF }, /* mega128 */
|
2014-10-05 12:32:26 +02:00
|
|
|
// { { 0x1E, 0x97, 0x03 }, 0xFF, 0x7F, POLL_FF }, /* mega1280 */
|
|
|
|
// { { 0x1E, 0x97, 0x04 }, 0xFF, 0x7F, POLL_FF }, /* mega1281 */
|
|
|
|
// { { 0x1E, 0x97, 0x05 }, 0x74, 0x7F, POLL_FF }, /* mega1284p (mega16 devcode) */
|
|
|
|
// { { 0x1E, 0x97, 0x06 }, 0xFF, 0x7F, POLL_FF }, /* mega1284 */
|
|
|
|
// { { 0x1E, 0x97, 0x81 }, 0xFF, 0x7F, POLL_FF }, /* at90can128 */
|
|
|
|
// { { 0x1E, 0x97, 0x82 }, 0xFF, 0x7F, POLL_FF }, /* at90usb1286/1287 */
|
|
|
|
|
|
|
|
// { { 0x1E, 0x98, 0x01 }, 0xFF, ???, ??? }, /* mega2560 */
|
|
|
|
// { { 0x1E, 0x98, 0x02 }, 0xFF, ???, ??? }, /* mega2561 */
|
|
|
|
|
|
|
|
// { { 0x1E, 0xA7, 0x01 }, 0xFF, ???, ??? }, /* mega128rfa1 */
|
2011-06-25 16:19:18 +02:00
|
|
|
};
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
#define EV_NONE 0x00
|
|
|
|
#define EV_STATE_ENTER 0x01
|
|
|
|
#define EV_BUTTON_PRESSED 0x02
|
|
|
|
#define EV_BUTTON_RELEASED 0x03
|
|
|
|
#define EV_TIMEOUT 0x04
|
|
|
|
#define EV_PROG_ENTER 0x11
|
|
|
|
#define EV_PROG_LEAVE 0x12
|
|
|
|
|
|
|
|
#define STATE_IDLE 0x00 /* nothing */
|
|
|
|
#define STATE_RESET_SYNC 0x01
|
|
|
|
#define STATE_RESET_RETRY 0x02
|
|
|
|
#define STATE_RESET_PROGMODE 0x03
|
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
|
|
|
|
#define LED_OFF 0x00
|
|
|
|
#define LED_SLOW 0x20
|
|
|
|
#define LED_FAST 0x08
|
|
|
|
#define LED_ON 0x80
|
|
|
|
#define LED_SPEED1 0x20
|
|
|
|
#define LED_SPEED2 0x10
|
|
|
|
#define LED_SPEED3 0x08
|
|
|
|
#define LED_SPEED4 0x04
|
|
|
|
|
|
|
|
#define CMD_PROG_ENABLE_1 0xAC
|
|
|
|
#define CMD_PROG_ENABLE_2 0x53
|
|
|
|
#define CMD_CHIP_ERASE_1 0xAC
|
|
|
|
#define CMD_CHIP_ERASE_2 0x80
|
|
|
|
#define CMD_POLL_BUSY_1 0xF0 /* not used */
|
|
|
|
#define CMD_POLL_BUSY_2 0x00 /* not used */
|
|
|
|
|
|
|
|
#define CMD_LOAD_EADDR_1 0x4D /* not used */
|
|
|
|
#define CMD_LOAD_EADDR_2 0x00 /* not used */
|
|
|
|
#define CMD_LOAD_FLASH_HI 0x48
|
|
|
|
#define CMD_LOAD_FLASH_LO 0x40
|
|
|
|
#define CMD_LOAD_EEPROM_PAGE 0xC1 /* not used */
|
|
|
|
|
|
|
|
#define CMD_READ_FLASH_LO 0x20
|
|
|
|
#define CMD_READ_FLASH_HI 0x28
|
|
|
|
#define CMD_READ_EEPROM 0xA0
|
|
|
|
#define CMD_READ_LOCK_1 0x58
|
|
|
|
#define CMD_READ_LOCK_2 0x00
|
|
|
|
#define CMD_READ_SIG_1 0x30
|
|
|
|
#define CMD_READ_SIG_2 0x00
|
|
|
|
#define CMD_READ_FUSE_1 0x50
|
|
|
|
#define CMD_READ_FUSE_2 0x00
|
|
|
|
#define CMD_READ_FUSE_H_1 0x58
|
|
|
|
#define CMD_READ_FUSE_H_2 0x08
|
|
|
|
#define CMD_READ_FUSE_E_1 0x50
|
|
|
|
#define CMD_READ_FUSE_E_2 0x08
|
|
|
|
#define CMD_READ_CAL 0x38 /* not used */
|
|
|
|
|
|
|
|
#define CMD_WRITE_FLASH_PAGE 0x4C
|
|
|
|
#define CMD_WRITE_EEPROM 0xC0
|
|
|
|
#define CMD_WRITE_EEPROM_PAGE 0xC2 /* not used */
|
|
|
|
#define CMD_WRITE_LOCK_1 0xAC
|
|
|
|
#define CMD_WRITE_LOCK_2 0xE0
|
|
|
|
#define CMD_WRITE_FUSE_1 0xAC
|
|
|
|
#define CMD_WRITE_FUSE_2 0xA0
|
|
|
|
#define CMD_WRITE_FUSE_H_1 0xAC /* not used */
|
|
|
|
#define CMD_WRITE_FUSE_H_2 0xA8 /* not used */
|
|
|
|
#define CMD_WRITE_FUSE_E_1 0xAC /* not used */
|
|
|
|
#define CMD_WRITE_FUSE_E_2 0xA4 /* not used */
|
2008-03-27 20:06:02 +01:00
|
|
|
|
2012-02-19 12:54:54 +01:00
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
static volatile uint8_t led_mode = LED_OFF;
|
2008-03-27 20:06:02 +01:00
|
|
|
|
2011-06-25 16:19:18 +02:00
|
|
|
static uint8_t last_cmd;
|
|
|
|
static uint8_t last_val;
|
|
|
|
static uint16_t last_addr;
|
2006-05-07 15:22:11 +02:00
|
|
|
|
|
|
|
/* Send one byte to PC */
|
2008-03-27 20:06:02 +01:00
|
|
|
static void ser_send(uint8_t data)
|
2006-05-05 19:02:04 +02:00
|
|
|
{
|
2014-10-12 11:13:30 +02:00
|
|
|
#if defined(__AVR_ATmega16__)
|
|
|
|
loop_until_bit_is_set(UCSRA, UDRE);
|
2012-11-18 13:12:27 +01:00
|
|
|
UDR = data;
|
2014-10-12 11:13:30 +02:00
|
|
|
#elif defined(__AVR_ATmega328P__)
|
|
|
|
loop_until_bit_is_set(UCSR0A, UDRE0);
|
|
|
|
UDR0 = data;
|
|
|
|
#endif
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* ser_send */
|
|
|
|
|
2006-05-05 19:02:04 +02:00
|
|
|
|
2006-05-07 15:22:11 +02:00
|
|
|
/* Receive one byte from PC */
|
2008-03-27 20:06:02 +01:00
|
|
|
static uint8_t ser_recv(void)
|
2006-05-05 19:02:04 +02:00
|
|
|
{
|
2014-10-12 11:13:30 +02:00
|
|
|
#if defined(__AVR_ATmega16__)
|
2012-11-18 13:12:27 +01:00
|
|
|
loop_until_bit_is_set(UCSRA, RXC);
|
|
|
|
return UDR;
|
2014-10-12 11:13:30 +02:00
|
|
|
#elif defined(__AVR_ATmega328P__)
|
|
|
|
loop_until_bit_is_set(UCSR0A, RXC0);
|
|
|
|
return UDR0;
|
|
|
|
#endif
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* ser_recv */
|
2006-05-05 19:02:04 +02:00
|
|
|
|
2006-05-07 15:22:11 +02:00
|
|
|
/* Send one byte to target, and return received one */
|
2008-03-27 20:06:02 +01:00
|
|
|
static uint8_t spi_rxtx(uint8_t val)
|
2006-05-06 22:55:42 +02:00
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
SPDR = val;
|
|
|
|
loop_until_bit_is_set(SPSR, SPIF);
|
|
|
|
return SPDR;
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* spi_rxtx */
|
|
|
|
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2006-05-07 15:22:11 +02:00
|
|
|
/* Control reset and SPI lines */
|
2008-03-27 20:06:02 +01:00
|
|
|
static void set_reset(uint8_t mode)
|
2006-05-06 22:55:42 +02:00
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
if (mode) {
|
2014-10-12 11:13:30 +02:00
|
|
|
ISP_INACTIVE();
|
2012-11-18 13:12:27 +01:00
|
|
|
} else {
|
2014-10-12 11:13:30 +02:00
|
|
|
ISP_ACTIVE();
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* set_reset */
|
|
|
|
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2008-03-27 20:06:02 +01:00
|
|
|
/* writes a byte to target flash/eeprom */
|
|
|
|
static void mem_write(uint8_t cmd, uint16_t addr, uint8_t val)
|
2006-05-06 22:55:42 +02:00
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
spi_rxtx(cmd);
|
|
|
|
spi_rxtx(addr >> 8);
|
|
|
|
spi_rxtx(addr & 0xFF);
|
|
|
|
spi_rxtx(val);
|
|
|
|
|
|
|
|
/* remember values for polling */
|
|
|
|
last_cmd = cmd;
|
|
|
|
last_addr = addr;
|
|
|
|
last_val = val;
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* mem_write */
|
|
|
|
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2006-05-07 15:22:11 +02:00
|
|
|
/* read a byte from target flash/eeprom */
|
2008-03-27 20:06:02 +01:00
|
|
|
static uint8_t mem_read(uint8_t cmd, uint16_t addr)
|
2006-05-06 22:55:42 +02:00
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
spi_rxtx(cmd);
|
|
|
|
spi_rxtx(addr >> 8);
|
|
|
|
spi_rxtx(addr & 0xFF);
|
|
|
|
return spi_rxtx(0x00);
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* mem_read */
|
|
|
|
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2006-05-07 15:22:11 +02:00
|
|
|
/* wait until byte/page is written to target memory */
|
2008-03-27 20:06:02 +01:00
|
|
|
static void poll(void)
|
2006-05-06 22:55:42 +02:00
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
uint8_t cmd, val, poll = 0xFF;
|
|
|
|
|
|
|
|
if (((last_val == 0x00) && (device.flags & POLL_00)) ||
|
|
|
|
((last_val == 0x7F) && (device.flags & POLL_7F)) ||
|
|
|
|
((last_val == 0x80) && (device.flags & POLL_80)) ||
|
|
|
|
((last_val == 0xFF) && (device.flags & POLL_FF))
|
|
|
|
) {
|
|
|
|
/* wait default time */
|
|
|
|
_delay_ms(15);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (last_cmd == CMD_WRITE_EEPROM) {
|
|
|
|
cmd = CMD_READ_EEPROM;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* CMD_WRITE_FLASH -> CMD_READ_FLASH */
|
|
|
|
cmd = (last_cmd & 0x08) | 0x20;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* poll until we get correct value */
|
|
|
|
do {
|
|
|
|
val = mem_read(cmd, last_addr);
|
|
|
|
} while ((val != last_val) && poll--);
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* poll */
|
2006-05-06 22:55:42 +02:00
|
|
|
|
|
|
|
|
2011-06-25 16:19:18 +02:00
|
|
|
static void mem_pagewrite(uint16_t addr)
|
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
spi_rxtx(CMD_WRITE_FLASH_PAGE);
|
|
|
|
spi_rxtx(addr >> 8);
|
|
|
|
spi_rxtx(addr & 0xFF);
|
|
|
|
spi_rxtx(0x00);
|
2006-05-05 19:02:04 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
poll();
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* mem_pagewrite */
|
|
|
|
|
2006-05-06 22:55:42 +02:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
static void reset_statemachine(uint8_t event);
|
|
|
|
static volatile uint16_t reset_timer = 0x0000;
|
|
|
|
static volatile uint8_t reset_state;
|
|
|
|
|
2014-10-16 21:29:43 +02:00
|
|
|
|
2012-02-19 12:54:54 +01:00
|
|
|
static void cmdloop(void) __attribute__ ((noreturn));
|
2011-06-25 16:19:18 +02:00
|
|
|
static void cmdloop(void)
|
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
static uint8_t page_buf[256];
|
|
|
|
uint16_t addr = 0;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
switch (ser_recv()) {
|
|
|
|
/* Enter programming mode */
|
|
|
|
case 'P': {
|
2014-10-14 21:56:16 +02:00
|
|
|
reset_statemachine(EV_PROG_ENTER);
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
while (1) {
|
|
|
|
if (reset_state == STATE_IDLE) {
|
|
|
|
ser_send('!');
|
|
|
|
break;
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
} else if (reset_state == STATE_RESET_PROGMODE) {
|
|
|
|
/* device not supported */
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Autoincrement address */
|
|
|
|
case 'a':
|
|
|
|
ser_send('Y');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Set address */
|
|
|
|
case 'A':
|
|
|
|
addr = (ser_recv() << 8);
|
|
|
|
addr |= ser_recv();
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Write program memory, low byte */
|
|
|
|
case 'c':
|
|
|
|
led_mode = LED_FAST;
|
|
|
|
mem_write(CMD_LOAD_FLASH_LO, addr, ser_recv());
|
|
|
|
|
|
|
|
/* poll on byte addressed targets */
|
|
|
|
if (device.pagemask == 0x00) {
|
|
|
|
poll();
|
|
|
|
}
|
|
|
|
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Write program memory, high byte */
|
|
|
|
case 'C':
|
|
|
|
led_mode = LED_FAST;
|
|
|
|
mem_write(CMD_LOAD_FLASH_HI, addr, ser_recv());
|
|
|
|
|
|
|
|
/* poll on byte addressed targets */
|
|
|
|
if (device.pagemask == 0x00) {
|
|
|
|
poll();
|
|
|
|
}
|
|
|
|
|
|
|
|
addr++;
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Issue Page Write */
|
|
|
|
case 'm':
|
|
|
|
led_mode = LED_FAST;
|
|
|
|
mem_pagewrite(last_addr);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Read Lock Bits */
|
|
|
|
case 'r':
|
|
|
|
ser_send(mem_read(CMD_READ_LOCK_1, CMD_READ_LOCK_2 << 8));
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Read program memory */
|
|
|
|
case 'R':
|
|
|
|
led_mode = LED_SLOW;
|
|
|
|
ser_send(mem_read(CMD_READ_FLASH_HI, addr));
|
|
|
|
ser_send(mem_read(CMD_READ_FLASH_LO, addr));
|
|
|
|
addr++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Read data memory */
|
|
|
|
case 'd':
|
|
|
|
led_mode = LED_SLOW;
|
|
|
|
ser_send(mem_read(CMD_READ_EEPROM, addr));
|
|
|
|
addr++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Write data memory */
|
|
|
|
case 'D':
|
|
|
|
led_mode = LED_FAST;
|
|
|
|
mem_write(CMD_WRITE_EEPROM, addr, ser_recv());
|
|
|
|
poll();
|
|
|
|
|
|
|
|
addr++;
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Chip erase */
|
|
|
|
case 'e':
|
|
|
|
spi_rxtx(CMD_CHIP_ERASE_1);
|
|
|
|
spi_rxtx(CMD_CHIP_ERASE_2);
|
|
|
|
spi_rxtx(0x00);
|
|
|
|
spi_rxtx(0x00);
|
|
|
|
|
|
|
|
_delay_ms(10);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Write lock bits */
|
|
|
|
case 'l': {
|
|
|
|
uint8_t val = ser_recv();
|
|
|
|
spi_rxtx(CMD_WRITE_LOCK_1);
|
|
|
|
spi_rxtx(CMD_WRITE_LOCK_2);
|
|
|
|
spi_rxtx(0x00);
|
|
|
|
spi_rxtx(val);
|
|
|
|
|
|
|
|
_delay_ms(10);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read fusebits */
|
|
|
|
case 'F':
|
|
|
|
ser_send(mem_read(CMD_READ_FUSE_1, CMD_READ_FUSE_2 << 8));
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Read high fusebits */
|
|
|
|
case 'N':
|
|
|
|
ser_send(mem_read(CMD_READ_FUSE_H_1, CMD_READ_FUSE_H_2 << 8));
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Read extended fusebits */
|
|
|
|
case 'Q':
|
|
|
|
ser_send(mem_read(CMD_READ_FUSE_E_1, CMD_READ_FUSE_E_2 << 8));
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Leave programming mode */
|
|
|
|
case 'L':
|
|
|
|
|
|
|
|
/* Exit Bootloader */
|
|
|
|
case 'E':
|
2014-10-14 21:56:16 +02:00
|
|
|
reset_statemachine(EV_PROG_LEAVE);
|
2012-11-18 13:12:27 +01:00
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Select device type */
|
|
|
|
case 'T': {
|
|
|
|
ser_recv(); // ignore
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read signature bytes */
|
|
|
|
case 's': {
|
|
|
|
uint8_t i = 2;
|
|
|
|
do {
|
|
|
|
ser_send(device.sig[i]);
|
|
|
|
} while (i--);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return supported device codes */
|
|
|
|
case 't': {
|
|
|
|
uint8_t limit = 0x00;
|
|
|
|
while (1) {
|
|
|
|
uint8_t i;
|
|
|
|
uint8_t search = 0xFF;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(devices); i++) {
|
|
|
|
uint8_t devcode = pgm_read_byte(&devices[i].devcode);
|
|
|
|
if ((devcode > limit) && (devcode < search)) {
|
|
|
|
search = devcode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (search == 0xFF)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ser_send(search);
|
|
|
|
limit = search;
|
|
|
|
}
|
|
|
|
ser_send(0x00);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return software identifier */
|
|
|
|
case 'S':
|
|
|
|
ser_send('A');
|
|
|
|
ser_send('V');
|
|
|
|
ser_send('R');
|
|
|
|
ser_send('-');
|
|
|
|
ser_send('I');
|
|
|
|
ser_send('S');
|
|
|
|
ser_send('P');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Return software version */
|
|
|
|
case 'V':
|
|
|
|
ser_send('3');
|
|
|
|
ser_send('8');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Return hardware version */
|
|
|
|
case 'v':
|
|
|
|
ser_send('1');
|
|
|
|
ser_send('2');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Return programmer type */
|
|
|
|
case 'p':
|
|
|
|
ser_send('S');
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Set LED */
|
|
|
|
case 'x':
|
|
|
|
ser_recv();
|
|
|
|
led_mode = LED_ON;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Clear LED */
|
|
|
|
case 'y':
|
|
|
|
ser_recv();
|
|
|
|
led_mode = LED_OFF;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Report Block write Mode */
|
|
|
|
case 'b': {
|
|
|
|
ser_send('Y');
|
|
|
|
ser_send(sizeof(page_buf) >> 8);
|
|
|
|
ser_send(sizeof(page_buf) & 0xFF);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Block Write */
|
|
|
|
case 'B': {
|
|
|
|
uint16_t size, i;
|
|
|
|
uint8_t type;
|
|
|
|
|
|
|
|
led_mode = LED_FAST;
|
|
|
|
|
|
|
|
size = ser_recv() << 8;
|
|
|
|
size |= ser_recv();
|
|
|
|
type = ser_recv();
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
page_buf[i] = ser_recv();
|
|
|
|
|
|
|
|
if (type == 'F') {
|
|
|
|
for (i = 0; i < size; i += 2) {
|
|
|
|
mem_write(CMD_LOAD_FLASH_LO, addr, page_buf[i]);
|
|
|
|
mem_write(CMD_LOAD_FLASH_HI, addr, page_buf[i+1]);
|
|
|
|
|
|
|
|
addr++;
|
|
|
|
|
|
|
|
if ((addr & device.pagemask) == 0x00) {
|
|
|
|
mem_pagewrite(last_addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size != sizeof(page_buf)) {
|
|
|
|
mem_pagewrite(last_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (type == 'E') {
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
mem_write(CMD_WRITE_EEPROM, addr, page_buf[i]);
|
|
|
|
poll();
|
|
|
|
addr++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Block Read */
|
|
|
|
case 'g': {
|
|
|
|
uint16_t size, i;
|
|
|
|
uint8_t type;
|
|
|
|
|
|
|
|
led_mode = LED_SLOW;
|
|
|
|
|
|
|
|
size = ser_recv() << 8;
|
|
|
|
size |= ser_recv();
|
|
|
|
type = ser_recv();
|
|
|
|
|
|
|
|
if (type == 'F') {
|
|
|
|
for (i = 0; i < size; i += 2) {
|
|
|
|
ser_send(mem_read(CMD_READ_FLASH_LO, addr));
|
|
|
|
ser_send(mem_read(CMD_READ_FLASH_HI, addr));
|
|
|
|
addr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (type == 'E') {
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
ser_send(mem_read(CMD_READ_EEPROM, addr));
|
|
|
|
addr++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write fusebits */
|
|
|
|
case 'f': {
|
|
|
|
uint8_t val = ser_recv();
|
|
|
|
spi_rxtx(CMD_WRITE_FUSE_1);
|
|
|
|
spi_rxtx(CMD_WRITE_FUSE_2);
|
|
|
|
spi_rxtx(0x00);
|
|
|
|
spi_rxtx(val);
|
|
|
|
|
|
|
|
_delay_ms(10);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Universial command */
|
|
|
|
case ':': {
|
|
|
|
uint8_t val[3];
|
|
|
|
val[0] = ser_recv();
|
|
|
|
val[1] = ser_recv();
|
|
|
|
val[2] = ser_recv();
|
|
|
|
|
|
|
|
spi_rxtx(val[0]);
|
|
|
|
spi_rxtx(val[1]);
|
|
|
|
ser_send(spi_rxtx(val[2]));
|
|
|
|
|
|
|
|
_delay_ms(10);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* New universal command */
|
|
|
|
case '.': {
|
|
|
|
uint8_t val[4];
|
|
|
|
val[0] = ser_recv();
|
|
|
|
val[1] = ser_recv();
|
|
|
|
val[2] = ser_recv();
|
|
|
|
val[3] = ser_recv();
|
|
|
|
|
|
|
|
spi_rxtx(val[0]);
|
|
|
|
spi_rxtx(val[1]);
|
|
|
|
spi_rxtx(val[2]);
|
|
|
|
ser_send(spi_rxtx(val[3]));
|
|
|
|
|
|
|
|
_delay_ms(10);
|
|
|
|
ser_send('\r');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ESC */
|
|
|
|
case 0x1B:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ser_send('?');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* cmdloop */
|
|
|
|
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
static void reset_statemachine(uint8_t event)
|
2011-06-25 16:19:18 +02:00
|
|
|
{
|
2014-10-14 21:56:16 +02:00
|
|
|
static uint8_t reset_retries;
|
|
|
|
static uint8_t reset_cause;
|
|
|
|
|
|
|
|
uint8_t state;
|
|
|
|
uint8_t oldstate;
|
|
|
|
uint16_t timer;
|
|
|
|
|
|
|
|
cli();
|
|
|
|
/* copy state, disable timer */
|
|
|
|
state = reset_state;
|
|
|
|
timer = reset_timer;
|
|
|
|
reset_timer = 0x0000;
|
|
|
|
sei();
|
2012-11-18 13:12:27 +01:00
|
|
|
|
|
|
|
do {
|
2014-10-14 21:56:16 +02:00
|
|
|
oldstate = state;
|
2012-11-18 13:12:27 +01:00
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case STATE_IDLE:
|
|
|
|
if (event == EV_STATE_ENTER) {
|
|
|
|
led_mode = LED_OFF;
|
2014-10-14 21:56:16 +02:00
|
|
|
timer = 0; /* stop timer */
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
/* put device in RUN mode */
|
2012-11-18 13:12:27 +01:00
|
|
|
set_reset(1);
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
} else if ((event == EV_BUTTON_PRESSED) || (event == EV_PROG_ENTER)) {
|
|
|
|
memset(&device, 0x00, sizeof(struct _device));
|
|
|
|
reset_retries = 5;
|
|
|
|
reset_cause = event;
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
/* probe SPI speed of device */
|
|
|
|
if (spi_speed == SPI_SPEED_PROBE) {
|
|
|
|
spi_speed = 3;
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
state = STATE_RESET_SYNC;
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
case STATE_RESET_SYNC:
|
2012-11-18 13:12:27 +01:00
|
|
|
if (event == EV_STATE_ENTER) {
|
2014-10-14 21:56:16 +02:00
|
|
|
led_mode = LED_ON;
|
|
|
|
timer = 5; /* timeout 50ms */
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
/* set SPI speed */
|
|
|
|
SPCR = spi_modes[spi_speed];
|
|
|
|
|
|
|
|
/* put device in ISP mode */
|
|
|
|
set_reset(0);
|
2012-11-18 13:12:27 +01:00
|
|
|
|
|
|
|
} else if (event == EV_TIMEOUT) {
|
2014-10-14 21:56:16 +02:00
|
|
|
uint8_t sync;
|
|
|
|
spi_rxtx(CMD_PROG_ENABLE_1);
|
|
|
|
spi_rxtx(CMD_PROG_ENABLE_2);
|
|
|
|
sync = spi_rxtx(0x00);
|
|
|
|
spi_rxtx(0x00);
|
|
|
|
|
|
|
|
if (sync == CMD_PROG_ENABLE_2) {
|
|
|
|
uint8_t i;
|
|
|
|
uint8_t sig[3];
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
sig[i] = mem_read(CMD_READ_SIG_1, (CMD_READ_SIG_2 << 8) | i);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(devices); i++) {
|
|
|
|
if (memcmp_P(sig, devices[i].sig, sizeof(device.sig)) == 0) {
|
|
|
|
memcpy_P(&device, &devices[i], sizeof(struct _device));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
state = (reset_cause == EV_PROG_ENTER) ? STATE_RESET_PROGMODE
|
|
|
|
: STATE_IDLE;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
state = STATE_RESET_RETRY;
|
|
|
|
}
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
case STATE_RESET_RETRY:
|
2012-11-18 13:12:27 +01:00
|
|
|
if (event == EV_STATE_ENTER) {
|
2014-10-14 21:56:16 +02:00
|
|
|
led_mode = LED_OFF;
|
|
|
|
timer = 5; /* timeout 50ms */
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
/* put device in RUN mode */
|
|
|
|
set_reset(1);
|
2012-11-18 13:12:27 +01:00
|
|
|
|
|
|
|
} else if (event == EV_TIMEOUT) {
|
2014-10-14 21:56:16 +02:00
|
|
|
reset_retries--;
|
|
|
|
if (reset_retries > 0) {
|
|
|
|
/* try lower frequency */
|
|
|
|
if (spi_speed > 0) {
|
|
|
|
spi_speed--;
|
|
|
|
}
|
|
|
|
|
|
|
|
state = STATE_RESET_SYNC;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* got no sync, probe speed again next time */
|
|
|
|
spi_speed = SPI_SPEED_PROBE;
|
|
|
|
state = STATE_IDLE;
|
|
|
|
}
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
case STATE_RESET_PROGMODE:
|
2012-11-18 13:12:27 +01:00
|
|
|
if (event == EV_STATE_ENTER) {
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
} else if (event == EV_PROG_LEAVE) {
|
|
|
|
/* was in prog mode (osc changed?), probe speed next time */
|
|
|
|
spi_speed = SPI_SPEED_PROBE;
|
|
|
|
state = STATE_IDLE;
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
} else if (event == EV_BUTTON_PRESSED) {
|
|
|
|
state = STATE_IDLE;
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
state = STATE_IDLE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
event = (oldstate != state) ? EV_STATE_ENTER
|
|
|
|
: EV_NONE;
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
} while (oldstate != state);
|
2012-11-18 13:12:27 +01:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
cli();
|
|
|
|
/* copy state back */
|
|
|
|
reset_timer = timer;
|
|
|
|
reset_state = state;
|
|
|
|
sei();
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* reset_statemachine */
|
|
|
|
|
2011-06-25 16:19:18 +02:00
|
|
|
|
|
|
|
/* time keeping */
|
|
|
|
ISR(TIMER0_OVF_vect)
|
|
|
|
{
|
2012-11-18 13:12:27 +01:00
|
|
|
uint8_t event = EV_NONE;
|
|
|
|
|
|
|
|
/* restart timer */
|
|
|
|
TCNT0 = TIMER_RELOAD;
|
|
|
|
|
|
|
|
static uint8_t prev_pressed;
|
2014-10-12 11:13:30 +02:00
|
|
|
if (ISP_CHECK()) {
|
2012-11-18 13:12:27 +01:00
|
|
|
if (!prev_pressed) {
|
|
|
|
event = EV_BUTTON_PRESSED;
|
|
|
|
prev_pressed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (prev_pressed) {
|
|
|
|
event = EV_BUTTON_RELEASED;
|
|
|
|
prev_pressed = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
if (reset_timer) {
|
|
|
|
reset_timer--;
|
|
|
|
if (reset_timer == 0) {
|
2012-11-18 13:12:27 +01:00
|
|
|
event = EV_TIMEOUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (event != EV_NONE) {
|
2014-10-14 21:56:16 +02:00
|
|
|
reset_statemachine(event);
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* update LED */
|
|
|
|
static uint8_t led_timer;
|
|
|
|
|
|
|
|
if (led_mode & ((led_timer++ & 0xFF) | 0x80)) {
|
2014-10-12 11:13:30 +02:00
|
|
|
ISP_LED_ON();
|
2012-11-18 13:12:27 +01:00
|
|
|
} else {
|
2014-10-12 11:13:30 +02:00
|
|
|
ISP_LED_OFF();
|
2012-11-18 13:12:27 +01:00
|
|
|
}
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* TIMER0_OVF_vect */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
#if defined(__AVR_ATmega328P__)
|
|
|
|
/*
|
|
|
|
* 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);
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* disable_wdt_timer */
|
|
|
|
#endif /* defined(__AVR_ATmega328P__) */
|
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
|
2012-02-19 12:54:54 +01:00
|
|
|
int main(void) __attribute__ ((noreturn));
|
2011-06-25 16:19:18 +02:00
|
|
|
int main(void)
|
|
|
|
{
|
2014-10-12 11:13:30 +02:00
|
|
|
GPIO_INIT();
|
|
|
|
|
|
|
|
#if defined(OSCCAL_VALUE)
|
|
|
|
OSCCAL = OSCCAL_VALUE;
|
|
|
|
#endif /* defined(OSCCAL_VALUE) */
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
#if defined(__AVR_ATmega16__)
|
2012-11-18 13:12:27 +01:00
|
|
|
/* Set baud rate */
|
|
|
|
UBRRH = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
|
|
|
|
UBRRL = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
/* enable usart with 8n1 */
|
|
|
|
UCSRB = (1<<TXEN) | (1<<RXEN);
|
|
|
|
UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
|
2014-10-12 11:13:30 +02:00
|
|
|
#elif defined(__AVR_ATmega328P__)
|
|
|
|
/* Set baud rate */
|
|
|
|
UBRR0H = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
|
|
|
|
UBRR0L = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
|
|
|
|
|
|
|
|
/* enable usart with 8n1 */
|
|
|
|
UCSR0B = (1<<TXEN0) | (1<<RXEN0);
|
|
|
|
UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
|
|
|
|
#endif
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
/* enable SPI master mode */
|
2014-10-14 21:56:16 +02:00
|
|
|
SPCR = SPI_MODE4;
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-12 11:13:30 +02:00
|
|
|
#if defined(__AVR_ATmega16__)
|
2012-11-18 13:12:27 +01:00
|
|
|
/* timer0, FCPU/1024, overflow interrupt */
|
|
|
|
TCCR0 = (1<<CS02) | (1<<CS00);
|
|
|
|
TIMSK = (1<<TOIE0);
|
2014-10-12 11:13:30 +02:00
|
|
|
#elif defined(__AVR_ATmega328P__)
|
|
|
|
TCCR0B = (1<<CS02) | (1<<CS00);
|
|
|
|
TIMSK0 = (1<<TOIE0);
|
|
|
|
#endif
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2014-10-14 21:56:16 +02:00
|
|
|
/* init statemachine */
|
|
|
|
reset_statemachine(EV_STATE_ENTER);
|
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
sei();
|
2011-06-25 16:19:18 +02:00
|
|
|
|
2012-11-18 13:12:27 +01:00
|
|
|
cmdloop();
|
2014-10-16 21:29:43 +02:00
|
|
|
} /* main */
|