avr
/
avrdude
mirror of https://github.com/mariusgreuel/avrdude.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add basic support for STK500. 

git-svn-id: svn://svn.savannah.nongnu.org/avrdude/trunk/avrdude@160 81a1dc3b-b13d-400b-aceb-764788c761c2
This commit is contained in:
bsd 2002-12-01 04:30:01 +00:00
parent 580ff186eb
commit da6e6490a4
10 changed files with 1086 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
avrdude.conf.sample
View File

@ -118,6 +118,12 @@ programmer
miso = 10;
;
programmer
id = "stk500";
desc = "Atmel STK500";
type = stk500;
;
programmer
id = "stk200";
desc = "STK200";
@ -156,9 +162,64 @@ programmer
;
#define ATTINY10 0x10
#define ATTINY11 0x11
#define ATTINY12 0x12
#define ATTINY22 0x20
#define ATTINY26 0x21
#define ATTINY28 0x22
#define AT90S1200 0x33
#define AT90S2313 0x40
#define AT90S2323 0x41
#define AT90S2333 0x42
#define AT90S2343 0x43
#define AT90S4414 0x50
#define AT90S4433 0x51
#define AT90S4434 0x52
#define AT90S8515 0x60
#define AT90S8535 0x61
#define AT90C8534 0x62
#define ATMEGA8515 0x63
#define ATMEGA8535 0x64
#define ATMEGA8 0x70
#define ATMEGA161 0x80
#define ATMEGA163 0x81
#define ATMEGA16 0x82
#define ATMEGA162 0x83
#define ATMEGA169 0x84
#define ATMEGA323 0x90
#define ATMEGA32 0x91
#define ATMEGA103 0xB1
#define ATMEGA128 0xB2
#define AT86RF401 0xD0
#define AT89START 0xE0
#define AT89S51 0xE0
#define AT89S52 0xE1
part
id = "t15";
desc = "ATtiny15";
devicecode = 0x13;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -242,6 +303,7 @@ part
part
id = "1200";
desc = "AT90S1200";
devicecode = 0x33;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -318,6 +380,7 @@ part
part
id = "4414";
desc = "AT90S4414";
devicecode = 0x50;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -374,6 +437,7 @@ part
part
id = "2313";
desc = "AT90S2313";
devicecode = 0x40;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -435,6 +499,7 @@ part
part
id = "2333";
desc = "AT90S2333";
devicecode = 0x42;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -512,6 +577,7 @@ part
part
id = "4433";
desc = "AT90S4433";
devicecode = 0x51;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -589,6 +655,7 @@ part
part
id = "4434";
desc = "AT90S4434";
devicecode = 0x52;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -665,6 +732,7 @@ part
part
id = "8515";
desc = "AT90S8515";
devicecode = 0x63;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -735,6 +803,7 @@ part
part
id = "8535";
desc = "AT90S8535";
devicecode = 0x64;
chip_erase_delay = 20000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -791,6 +860,7 @@ part
part
id = "m103";
desc = "ATMEGA103";
devicecode = 0xB1;
chip_erase_delay = 112000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -879,6 +949,7 @@ part
part
id = "m128";
desc = "ATMEGA128";
devicecode = 0xB2;
chip_erase_delay = 9000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -991,6 +1062,7 @@ part
part
id = "m16";
desc = "ATMEGA16";
devicecode = 0x82;
chip_erase_delay = 9000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -1091,6 +1163,7 @@ part
part
id = "m163";
desc = "ATMEGA163";
devicecode = 0x81;
chip_erase_delay = 32000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
@ -1200,6 +1273,7 @@ part
part
id = "m8";
desc = "ATMEGA8";
devicecode = 0x70;
chip_erase_delay = 9000;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";

59
avrpart.h Normal file
View File

@ -0,0 +1,59 @@
#ifndef __avrpart_h__
#define __avrpart_h__
#include "lists.h"
/*
* AVR serial programming instructions
*/
enum {
AVR_OP_READ,
AVR_OP_WRITE,
AVR_OP_READ_LO,
AVR_OP_READ_HI,
AVR_OP_WRITE_LO,
AVR_OP_WRITE_HI,
AVR_OP_LOADPAGE_LO,
AVR_OP_LOADPAGE_HI,
AVR_OP_WRITEPAGE,
AVR_OP_CHIP_ERASE,
AVR_OP_PGM_ENABLE,
AVR_OP_MAX
};
enum {
AVR_CMDBIT_IGNORE, /* bit is ignored on input and output */
AVR_CMDBIT_VALUE, /* bit is set to 0 or 1 for input or output */
AVR_CMDBIT_ADDRESS, /* this bit represents an input address bit */
AVR_CMDBIT_INPUT, /* this bit is an input bit */
AVR_CMDBIT_OUTPUT /* this bit is an output bit */
};
/*
* serial programming instruction bit specifications
*/
typedef struct cmdbit {
int type; /* AVR_CMDBIT_* */
int bitno; /* which input bit to use for this command bit */
int value; /* bit value if type == AVR_CMDBIT_VALUD */
} CMDBIT;
typedef struct opcode {
CMDBIT bit[32]; /* opcode bit specs */
} OPCODE;
#define AVR_DESCLEN 64
#define AVR_IDLEN 32
typedef struct avrpart {
char desc[AVR_DESCLEN]; /* long part name */
char id[AVR_IDLEN]; /* short part name */
int devicecode; /* Atmel STK500 device code */
int chip_erase_delay; /* microseconds */
OPCODE * op[AVR_OP_MAX]; /* opcodes */
LISTID mem; /* avr memory definitions */
} AVRPART;
#endif

11
config_gram.y
View File

@ -48,6 +48,7 @@
%token K_BUFF
%token K_CHIP_ERASE_DELAY
%token K_DESC
%token K_DEVICECODE
%token K_EEPROM
%token K_ERRLED
%token K_FLASH
@ -221,7 +222,7 @@ prog_parm :
K_TYPE TKN_EQUAL K_STK500 {
{
fprintf(stderr, "%s: programmer 'stk500' not yet supported\n", progname);
stk500_initpgm(current_prog);
}
} |
@ -328,6 +329,13 @@ part_parm :
free_token($3);
} |
K_DEVICECODE TKN_EQUAL TKN_NUMBER {
{
current_part->devicecode = $3->value.number;
free_token($3);
}
} |
K_CHIP_ERASE_DELAY TKN_EQUAL TKN_NUMBER
{
current_part->chip_erase_delay = $3->value.number;
@ -461,6 +469,7 @@ mem_spec :
#include "config.h"
#include "lists.h"
#include "pindefs.h"
#include "ppi.h"
#include "pgm.h"
#include "avr.h"

1
lexer.l
View File

@ -128,6 +128,7 @@ banked { yylval=NULL; return K_PAGED; }
buff { yylval=NULL; return K_BUFF; }
chip_erase_delay { yylval=NULL; return K_CHIP_ERASE_DELAY; }
desc { yylval=NULL; return K_DESC; }
devicecode { yylval=NULL; return K_DEVICECODE; }
eeprom { yylval=NULL; return K_EEPROM; }
errled { yylval=NULL; return K_ERRLED; }
flash { yylval=NULL; return K_FLASH; }

4
pgm.h
View File

@ -32,6 +32,8 @@
#ifndef __pgm_h__
#define __pgm_h__
#include <limits.h>
#include "avrpart.h"
#include "lists.h"
#include "pindefs.h"
@ -41,11 +43,13 @@
#define OFF 0
#define PGM_DESCLEN 80
#define PGM_PORTLEN PATH_MAX
#define PGM_TYPELEN 32
typedef struct programmer_t {
LISTID id;
char desc[PGM_DESCLEN];
char type[PGM_TYPELEN];
char port[PGM_PORTLEN];
unsigned int pinno[N_PINS];
int ppidata;
int fd;

78
ppi.c
View File

@ -46,6 +46,15 @@
extern char * progname;
extern int do_cycles;
/*
* PPI registers
*/
enum {
PPIDATA,
PPICTRL,
PPISTATUS
};
struct ppipins_t {
int pin;
int reg;
@ -80,6 +89,75 @@ char * ppi_version = "$Id$";
int ppi_getops (int reg, unsigned long * get, unsigned long * set);
int ppi_set (int fd, int reg, int bit);
int ppi_clr (int fd, int reg, int bit);
int ppi_get (int fd, int reg, int bit);
int ppi_toggle (int fd, int reg, int bit);
int ppi_getall (int fd, int reg);
int ppi_setall (int fd, int reg, int val);
int ppi_pulse (int fd, int reg, int bit);
int ppi_setpin (int fd, int pin, int value);
int ppi_getpin (int fd, int pin);
int ppi_pulsepin (int fd, int pin);
int ppi_getpinreg (int pin);
int ppi_sense (int fd);
int ppi_rdy_led (PROGRAMMER * pgm, int value);
int ppi_err_led (PROGRAMMER * pgm, int value);
int ppi_pgm_led (PROGRAMMER * pgm, int value);
int ppi_vfy_led (PROGRAMMER * pgm, int value);
int ppi_cmd (PROGRAMMER * pgm, unsigned char cmd[4],
unsigned char res[4]);
int ppi_chip_erase (PROGRAMMER * pgm, AVRPART * p);
int ppi_program_enable (PROGRAMMER * pgm, AVRPART * p);
void ppi_powerup (PROGRAMMER * pgm);
void ppi_powerdown (PROGRAMMER * pgm);
int ppi_initialize (PROGRAMMER * pgm, AVRPART * p);
int ppi_save (PROGRAMMER * pgm);
void ppi_restore (PROGRAMMER * pgm);
void ppi_disable (PROGRAMMER * pgm);
void ppi_enable (PROGRAMMER * pgm);
void ppi_open (PROGRAMMER * pgm, char * port);
void ppi_close (PROGRAMMER * pgm);
static char vccpins_buf[64];
char * vccpins_str(unsigned int pmask)
{

74
ppi.h
View File

@ -35,82 +35,10 @@
#include "config.h"
/*
* PPI registers
*/
enum {
PPIDATA,
PPICTRL,
PPISTATUS
};
int ppi_getops (int reg, unsigned long * get, unsigned long * set);
int ppi_set (int fd, int reg, int bit);
int ppi_clr (int fd, int reg, int bit);
int ppi_get (int fd, int reg, int bit);
int ppi_toggle (int fd, int reg, int bit);
int ppi_getall (int fd, int reg);
int ppi_setall (int fd, int reg, int val);
int ppi_pulse (int fd, int reg, int bit);
int ppi_setpin (int fd, int pin, int value);
int ppi_getpin (int fd, int pin);
int ppi_pulsepin (int fd, int pin);
void ppi_initpgm (PROGRAMMER * pgm);
int ppi_getpinmask(int pin);
int ppi_getpinreg (int pin);
int ppi_sense (int fd);
void ppi_initpgm (PROGRAMMER * pgm);
int ppi_rdy_led (PROGRAMMER * pgm, int value);
int ppi_err_led (PROGRAMMER * pgm, int value);
int ppi_pgm_led (PROGRAMMER * pgm, int value);
int ppi_vfy_led (PROGRAMMER * pgm, int value);
int ppi_cmd (PROGRAMMER * pgm, unsigned char cmd[4],
unsigned char res[4]);
int ppi_chip_erase (PROGRAMMER * pgm, AVRPART * p);
int ppi_program_enable (PROGRAMMER * pgm, AVRPART * p);
void ppi_powerup (PROGRAMMER * pgm);
void ppi_powerdown (PROGRAMMER * pgm);
int ppi_initialize (PROGRAMMER * pgm, AVRPART * p);
int ppi_save (PROGRAMMER * pgm);
void ppi_restore (PROGRAMMER * pgm);
void ppi_disable (PROGRAMMER * pgm);
void ppi_enable (PROGRAMMER * pgm);
void ppi_open (PROGRAMMER * pgm, char * port);
void ppi_close (PROGRAMMER * pgm);
void ppi_initpgm (PROGRAMMER * pgm);
#endif

715
stk500.c Normal file
View File

@ -0,0 +1,715 @@
/*
* Copyright 2002 Brian S. Dean <bsd@bsdhome.com>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY BRIAN S. DEAN ``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 BRIAN S. DEAN 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.
*
*/
/* $Id$ */
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <termios.h>
#include <sys/time.h>
#include "avr.h"
#include "pgm.h"
#include "stk500_private.h"
extern char * progname;
extern int do_cycles;
char * stk500_version = "$Id$";
int static send(PROGRAMMER * pgm, char * buf, int buflen)
{
struct timeval timeout;
fd_set wfds;
int nfds;
int rc;
if (!buflen)
return 0;
timeout.tv_sec = 0;
timeout.tv_usec = 500000;
while (buflen) {
FD_ZERO(&wfds);
FD_SET(pgm->fd, &wfds);
reselect:
nfds = select(pgm->fd+1, NULL, &wfds, NULL, &timeout);
if (nfds == 0) {
fprintf(stderr, "%s: send(): programmer is not responding on %s\n",
progname, pgm->port);
exit(1);
}
else if (nfds == -1) {
if (errno == EINTR) {
goto reselect;
}
else {
fprintf(stderr, "%s: send(): select(): %s\n",
progname, strerror(errno));
exit(1);
}
}
rc = write(pgm->fd, buf, 1);
if (rc < 0) {
fprintf(stderr, "%s: send(): write error: %s\n",
progname, strerror(errno));
exit(1);
}
buf++;
buflen--;
}
return 0;
}
int static recv(PROGRAMMER * pgm, char * buf, int n)
{
struct timeval timeout;
fd_set rfds;
int nfds;
int rc;
timeout.tv_sec = 0;
timeout.tv_usec = 500000;
while (n) {
FD_ZERO(&rfds);
FD_SET(pgm->fd, &rfds);
reselect:
nfds = select(pgm->fd+1, &rfds, NULL, NULL, &timeout);
if (nfds == 0) {
fprintf(stderr, "%s: recv(): programmer is not responding on %s\n",
progname, pgm->port);
exit(1);
}
else if (nfds == -1) {
if (errno == EINTR) {
goto reselect;
}
else {
fprintf(stderr, "%s: recv(): select(): %s\n",
progname, strerror(errno));
exit(1);
}
}
rc = read(pgm->fd, buf, 1);
if (rc < 0) {
fprintf(stderr, "%s: recv(): read error: %s\n",
progname, strerror(errno));
exit(1);
}
buf++;
n--;
}
return 0;
}
int static drain(PROGRAMMER * pgm, int display)
{
struct timeval timeout;
fd_set rfds;
int nfds;
int rc;
unsigned char buf;
timeout.tv_sec = 0;
timeout.tv_usec = 250000;
if (display) {
fprintf(stderr, "drain>");
}
while (1) {
FD_ZERO(&rfds);
FD_SET(pgm->fd, &rfds);
reselect:
nfds = select(pgm->fd+1, &rfds, NULL, NULL, &timeout);
if (nfds == 0) {
if (display) {
fprintf(stderr, "<drain\n");
}
return 0;
}
else if (nfds == -1) {
if (errno == EINTR) {
goto reselect;
}
else {
fprintf(stderr, "%s: drain(): select(): %s\n",
progname, strerror(errno));
exit(1);
}
}
rc = read(pgm->fd, &buf, 1);
if (rc < 0) {
fprintf(stderr, "%s: drain(): read error: %s\n",
progname, strerror(errno));
exit(1);
}
if (display) {
fprintf(stderr, "%02x ", buf);
}
}
}
static int getsync(PROGRAMMER * pgm)
{
unsigned char buf[32], resp[32];
/*
* get in sync
*/
buf[0] = Cmnd_STK_GET_SYNC;
buf[1] = Sync_CRC_EOP;
send(pgm, buf, 2);
recv(pgm, resp, 1);
if (resp[0] != Resp_STK_INSYNC) {
fprintf(stderr,
"%s: stk500_open(): not in sync: resp=0x%02x\n",
progname, resp[0]);
drain(pgm, 0);
exit(1);
}
recv(pgm, resp, 1);
if (resp[0] != Resp_STK_OK) {
fprintf(stderr,
"%s: stk500_open(): can't communicate with device: resp=0x%02x\n",
progname, resp[0]);
exit(1);
}
return 0;
}
int stk500_rdy_led(PROGRAMMER * pgm, int value)
{
return 0;
}
int stk500_err_led(PROGRAMMER * pgm, int value)
{
return 0;
}
int stk500_pgm_led(PROGRAMMER * pgm, int value)
{
return 0;
}
int stk500_vfy_led(PROGRAMMER * pgm, int value)
{
return 0;
}
/*
* transmit an AVR device command and return the results; 'cmd' and
* 'res' must point to at least a 4 byte data buffer
*/
int stk500_cmd(PROGRAMMER * pgm, unsigned char cmd[4], unsigned char res[4])
{
unsigned char buf[32];
buf[0] = Cmnd_STK_UNIVERSAL;
buf[1] = cmd[0];
buf[2] = cmd[1];
buf[3] = cmd[2];
buf[4] = cmd[3];
buf[5] = Sync_CRC_EOP;
send(pgm, buf, 6);
recv(pgm, buf, 1);
if (buf[0] != Resp_STK_INSYNC) {
fprintf(stderr, "%s: programmer is out of sync\n", progname);
exit(1);
}
res[0] = cmd[1];
res[1] = cmd[2];
res[2] = cmd[3];
recv(pgm, &res[3], 1);
recv(pgm, buf, 1);
if (buf[0] != Resp_STK_OK) {
fprintf(stderr, "%s: protocol error\n", progname);
exit(1);
}
return 0;
}
/*
* issue the 'chip erase' command to the AVR device
*/
int stk500_chip_erase(PROGRAMMER * pgm, AVRPART * p)
{
unsigned char cmd[4];
unsigned char res[4];
int cycles;
int rc;
if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
fprintf(stderr, "chip erase instruction not defined for part \"%s\"\n",
p->desc);
return -1;
}
rc = avr_get_cycle_count(pgm, p, &cycles);
/*
* only print out the current cycle count if we aren't going to
* display it below
*/
if (!do_cycles && ((rc >= 0) && (cycles != 0xffffffff))) {
fprintf(stderr,
"%s: current erase-rewrite cycle count is %d%s\n",
progname, cycles,
do_cycles ? "" : " (if being tracked)");
}
pgm->pgm_led(pgm, ON);
memset(cmd, 0, sizeof(cmd));
avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
pgm->cmd(pgm, cmd, res);
usleep(p->chip_erase_delay);
pgm->initialize(pgm, p);
pgm->pgm_led(pgm, OFF);
if (do_cycles && (cycles != -1)) {
if (cycles == 0x00ffff) {
cycles = 0;
}
cycles++;
fprintf(stderr, "%s: erase-rewrite cycle count is now %d\n",
progname, cycles);
avr_put_cycle_count(pgm, p, cycles);
}
return 0;
}
/*
* issue the 'program enable' command to the AVR device
*/
int stk500_program_enable(PROGRAMMER * pgm, AVRPART * p)
{
unsigned char buf[16];
int tries=0;
retry:
tries++;
buf[0] = Cmnd_STK_ENTER_PROGMODE;
buf[1] = Sync_CRC_EOP;
send(pgm, buf, 2);
recv(pgm, buf, 1);
if (buf[0] == Resp_STK_NOSYNC) {
if (tries > 33) {
fprintf(stderr, "%s: stk500_program_enable(): can't get into sync\n",
progname);
return -1;
}
getsync(pgm);
goto retry;
}
else if (buf[0] != Resp_STK_INSYNC) {
fprintf(stderr,
"%s: stk500_initialize(): (a) protocol error, "
"expect=0x%02x, resp=0x%02x\n",
progname, Resp_STK_INSYNC, buf[0]);
return -1;
}
recv(pgm, buf, 1);
if (buf[0] == Resp_STK_OK) {
return 0;
}
else if (buf[0] == Resp_STK_NODEVICE) {
fprintf(stderr, "%s: stk500_program_enable(): no device\n",
progname);
return -1;
}
fprintf(stderr, "%s: stk500_program_enamble(): unkown response=0x%02x\n",
progname, buf[0]);
return -1;
}
/*
* apply power to the AVR processor
*/
void stk500_powerup(PROGRAMMER * pgm)
{
return;
}
/*
* remove power from the AVR processor
*/
void stk500_powerdown(PROGRAMMER * pgm)
{
return;
}
/*
* initialize the AVR device and prepare it to accept commands
*/
int stk500_initialize(PROGRAMMER * pgm, AVRPART * p)
{
unsigned char buf[32];
AVRMEM * m;
int tries;
/*
* set device programming parameters
*/
buf[0] = Cmnd_STK_SET_DEVICE;
buf[1] = p->devicecode;
buf[2] = 0; /* device revision */
buf[3] = 0; /* parallel and serial programming */
buf[4] = 1; /* full parallel interface */
buf[5] = 1; /* polling supported - XXX need this in config file */
buf[6] = 1; /* programming is self-timed - XXX need in config file */
m = avr_locate_mem(p, "lock");
if (m)
buf[7] = m->size;
else
buf[7] = 0;
/*
* number of fuse bytes
*/
buf[8] = 0;
m = avr_locate_mem(p, "fuse");
if (m)
buf[8] += m->size;
m = avr_locate_mem(p, "lfuse");
if (m)
buf[8] += m->size;
m = avr_locate_mem(p, "hfuse");
if (m)
buf[8] += m->size;
m = avr_locate_mem(p, "efuse");
if (m)
buf[8] += m->size;
m = avr_locate_mem(p, "flash");
if (m) {
buf[9] = m->readback[0];
buf[10] = m->readback[1];
if (m->paged) {
buf[13] = (m->page_size >> 8) & 0x00ff;
buf[14] = m->page_size & 0x00ff;
}
buf[17] = (m->size >> 24) & 0xff;
buf[18] = (m->size >> 16) & 0xff;
buf[19] = (m->size >> 8) & 0xff;
buf[20] = m->size & 0xff;
}
else {
buf[9] = 0xff;
buf[10] = 0xff;
buf[13] = 0;
buf[14] = 0;
buf[17] = 0;
buf[18] = 0;
buf[19] = 0;
buf[20] = 0;
}
m = avr_locate_mem(p, "eeprom");
if (m) {
buf[11] = m->readback[0];
buf[12] = m->readback[1];
buf[15] = (m->size >> 8) & 0x00ff;
buf[16] = m->size & 0x00ff;
}
else {
buf[11] = 0xff;
buf[12] = 0xff;
buf[15] = 0;
buf[16] = 0;
}
buf[21] = Sync_CRC_EOP;
tries = 0;
retry:
tries++;
send(pgm, buf, 22);
recv(pgm, buf, 1);
if (buf[0] == Resp_STK_NOSYNC) {
fprintf(stderr,
"%s: stk500_initialize(): programmer not in sync, resp=0x%02x\n",
progname, buf[0]);
if (tries > 33)
return -1;
getsync(pgm);
goto retry;
return -1;
}
else if (buf[0] != Resp_STK_INSYNC) {
fprintf(stderr,
"%s: stk500_initialize(): (a) protocol error, "
"expect=0x%02x, resp=0x%02x\n",
progname, Resp_STK_INSYNC, buf[0]);
return -1;
}
recv(pgm, buf, 1);
if (buf[0] != Resp_STK_OK) {
fprintf(stderr,
"%s: stk500_initialize(): (b) protocol error, "
"expect=0x%02x, resp=0x%02x\n",
progname, Resp_STK_OK, buf[0]);
return -1;
}
return pgm->program_enable(pgm, p);
}
int stk500_save(PROGRAMMER * pgm)
{
return 0;
}
void stk500_restore(PROGRAMMER * pgm)
{
return;
}
void stk500_disable(PROGRAMMER * pgm)
{
unsigned char buf[16];
int tries=0;
retry:
tries++;
buf[0] = Cmnd_STK_LEAVE_PROGMODE;
buf[1] = Sync_CRC_EOP;
send(pgm, buf, 2);
recv(pgm, buf, 1);
if (buf[0] == Resp_STK_NOSYNC) {
if (tries > 33) {
fprintf(stderr, "%s: stk500_program_enable(): can't get into sync\n",
progname);
return;
}
getsync(pgm);
goto retry;
}
else if (buf[0] != Resp_STK_INSYNC) {
fprintf(stderr,
"%s: stk500_initialize(): (a) protocol error, "
"expect=0x%02x, resp=0x%02x\n",
progname, Resp_STK_INSYNC, buf[0]);
return;
}
recv(pgm, buf, 1);
if (buf[0] == Resp_STK_OK) {
return;
}
else if (buf[0] == Resp_STK_NODEVICE) {
fprintf(stderr, "%s: stk500_program_enable(): no device\n",
progname);
return;
}
fprintf(stderr, "%s: stk500_program_enamble(): unkown response=0x%02x\n",
progname, buf[0]);
return;
}
void stk500_enable(PROGRAMMER * pgm)
{
return;
}
int static set_tty_attr(int fd)
{
int rc;
struct termios termios;
if (!isatty(fd))
return -1;
/*
* initialize terminal modes
*/
rc = tcgetattr(fd, &termios);
if (rc < 0) {
fprintf(stderr, "%s: tcgetattr() failed, %s",
progname, strerror(errno));
return -errno;
}
#if 1
termios.c_iflag &= ~(INPCK | IXOFF | IXON);
termios.c_cflag &= ~(HUPCL | CSTOPB | CRTSCTS);
termios.c_cflag |= (CLOCAL | CREAD);
termios.c_cc [VMIN] = 1;
termios.c_cc [VTIME] = 0;
#else
termios.c_iflag = 0;
termios.c_oflag = 0;
termios.c_cflag &= ~ (PARENB | CSIZE | CSTOPB);
termios.c_cflag |= (CS8 | HUPCL | CREAD | CLOCAL);
termios.c_lflag = 0;
termios.c_cc[VMIN] = 1;
termios.c_cc[VTIME] = 0;
#endif
cfsetospeed(&termios, B115200);
cfsetispeed(&termios, B115200);
rc = tcsetattr(fd, TCSANOW, &termios);
if (rc < 0) {
fprintf(stderr, "%s: tcsetattr() failed, %s", progname, strerror(errno));
return -errno;
}
return 0;
}
void stk500_open(PROGRAMMER * pgm, char * port)
{
int rc;
strcpy(pgm->port, port);
/*
* open the serial port
*/
pgm->fd = open(port, O_RDWR | O_NOCTTY /*| O_NONBLOCK*/);
if (pgm->fd < 0) {
fprintf(stderr, "%s: can't open device \"%s\": %s\n",
progname, port, strerror(errno));
exit(1);
}
/*
* set serial line attributes
*/
rc = set_tty_attr(pgm->fd);
if (rc) {
fprintf(stderr, "%s: can't set attributes for device \"%s\"\n",
progname, port);
exit(1);
}
/*
* drain any extraneous input
*/
drain(pgm, 0);
getsync(pgm);
drain(pgm, 0);
}
void stk500_close(PROGRAMMER * pgm)
{
close(pgm->fd);
pgm->fd = -1;
}
void stk500_display(PROGRAMMER * pgm, char * p)
{
return;
}
void stk500_initpgm(PROGRAMMER * pgm)
{
strcpy(pgm->type, "STK500");
pgm->rdy_led = stk500_rdy_led;
pgm->err_led = stk500_err_led;
pgm->pgm_led = stk500_pgm_led;
pgm->vfy_led = stk500_vfy_led;
pgm->initialize = stk500_initialize;
pgm->display = stk500_display;
pgm->save = stk500_save;
pgm->restore = stk500_restore;
pgm->enable = stk500_enable;
pgm->disable = stk500_disable;
pgm->powerup = stk500_powerup;
pgm->powerdown = stk500_powerdown;
pgm->program_enable = stk500_program_enable;
pgm->chip_erase = stk500_chip_erase;
pgm->cmd = stk500_cmd;
pgm->open = stk500_open;
pgm->close = stk500_close;
}

41
stk500.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 2002 Brian S. Dean <bsd@bsdhome.com>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY BRIAN S. DEAN ``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 BRIAN S. DEAN 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.
*
*/
/* $Id$ */
#ifndef __stk500_h__
#define __stk500_h__
#include "config.h"
void stk500_initpgm (PROGRAMMER * pgm);
#endif

103
stk500_private.h Normal file
View File

@ -0,0 +1,103 @@
//**** ATMEL AVR - A P P L I C A T I O N N O T E ************************
//*
//* Title: AVR061 - STK500 Communication Protocol
//* Filename: command.h
//* Version: 1.0
//* Last updated: 09.09.2002
//*
//* Support E-mail: avr@atmel.com
//*
//**************************************************************************
// *****************[ STK Message constants ]***************************
#define STK_SIGN_ON_MESSAGE "AVR STK" // Sign on string for Cmnd_STK_GET_SIGN_ON
// *****************[ STK Response constants ]***************************
#define Resp_STK_OK 0x10 // ' '
#define Resp_STK_FAILED 0x11 // ' '
#define Resp_STK_UNKNOWN 0x12 // ' '
#define Resp_STK_NODEVICE 0x13 // ' '
#define Resp_STK_INSYNC 0x14 // ' '
#define Resp_STK_NOSYNC 0x15 // ' '
#define Resp_ADC_CHANNEL_ERROR 0x16 // ' '
#define Resp_ADC_MEASURE_OK 0x17 // ' '
#define Resp_PWM_CHANNEL_ERROR 0x18 // ' '
#define Resp_PWM_ADJUST_OK 0x19 // ' '
// *****************[ STK Special constants ]***************************
#define Sync_CRC_EOP 0x20 // 'SPACE'
// *****************[ STK Command constants ]***************************
#define Cmnd_STK_GET_SYNC 0x30 // ' '
#define Cmnd_STK_GET_SIGN_ON 0x31 // ' '
#define Cmnd_STK_SET_PARAMETER 0x40 // ' '
#define Cmnd_STK_GET_PARAMETER 0x41 // ' '
#define Cmnd_STK_SET_DEVICE 0x42 // ' '
#define Cmnd_STK_SET_DEVICE_EXT 0x45 // ' '
#define Cmnd_STK_ENTER_PROGMODE 0x50 // ' '
#define Cmnd_STK_LEAVE_PROGMODE 0x51 // ' '
#define Cmnd_STK_CHIP_ERASE 0x52 // ' '
#define Cmnd_STK_CHECK_AUTOINC 0x53 // ' '
#define Cmnd_STK_LOAD_ADDRESS 0x55 // ' '
#define Cmnd_STK_UNIVERSAL 0x56 // ' '
#define Cmnd_STK_UNIVERSAL_MULTI 0x57 // ' '
#define Cmnd_STK_PROG_FLASH 0x60 // ' '
#define Cmnd_STK_PROG_DATA 0x61 // ' '
#define Cmnd_STK_PROG_FUSE 0x62 // ' '
#define Cmnd_STK_PROG_LOCK 0x63 // ' '
#define Cmnd_STK_PROG_PAGE 0x64 // ' '
#define Cmnd_STK_PROG_FUSE_EXT 0x65 // ' '
#define Cmnd_STK_READ_FLASH 0x70 // ' '
#define Cmnd_STK_READ_DATA 0x71 // ' '
#define Cmnd_STK_READ_FUSE 0x72 // ' '
#define Cmnd_STK_READ_LOCK 0x73 // ' '
#define Cmnd_STK_READ_PAGE 0x74 // ' '
#define Cmnd_STK_READ_SIGN 0x75 // ' '
#define Cmnd_STK_READ_OSCCAL 0x76 // ' '
#define Cmnd_STK_READ_FUSE_EXT 0x77 // ' '
#define Cmnd_STK_READ_OSCCAL_EXT 0x78 // ' '
// *****************[ STK Parameter constants ]***************************
#define Parm_STK_HW_VER 0x80 // ' ' - R
#define Parm_STK_SW_MAJOR 0x81 // ' ' - R
#define Parm_STK_SW_MINOR 0x82 // ' ' - R
#define Parm_STK_LEDS 0x83 // ' ' - R/W
#define Parm_STK_VTARGET 0x84 // ' ' - R/W
#define Parm_STK_VADJUST 0x85 // ' ' - R/W
#define Parm_STK_OSC_PSCALE 0x86 // ' ' - R/W
#define Parm_STK_OSC_CMATCH 0x87 // ' ' - R/W
#define Parm_STK_RESET_DURATION 0x88 // ' ' - R/W
#define Parm_STK_SCK_DURATION 0x89 // ' ' - R/W
#define Parm_STK_BUFSIZEL 0x90 // ' ' - R/W, Range {0..255}
#define Parm_STK_BUFSIZEH 0x91 // ' ' - R/W, Range {0..255}
#define Parm_STK_DEVICE 0x92 // ' ' - R/W, Range {0..255}
#define Parm_STK_PROGMODE 0x93 // ' ' - 'P' or 'S'
#define Parm_STK_PARAMODE 0x94 // ' ' - TRUE or FALSE
#define Parm_STK_POLLING 0x95 // ' ' - TRUE or FALSE
#define Parm_STK_SELFTIMED 0x96 // ' ' - TRUE or FALSE
// *****************[ STK status bit definitions ]***************************
#define Stat_STK_INSYNC 0x01 // INSYNC status bit, '1' - INSYNC
#define Stat_STK_PROGMODE 0x02 // Programming mode, '1' - PROGMODE
#define Stat_STK_STANDALONE 0x04 // Standalone mode, '1' - SM mode
#define Stat_STK_RESET 0x08 // RESET button, '1' - Pushed
#define Stat_STK_PROGRAM 0x10 // Program button, ' 1' - Pushed
#define Stat_STK_LEDG 0x20 // Green LED status, '1' - Lit
#define Stat_STK_LEDR 0x40 // Red LED status, '1' - Lit
#define Stat_STK_LEDBLINK 0x80 // LED blink ON/OFF, '1' - Blink
// *****************************[ End Of COMMAND.H ]**************************