diff --git a/src/stk500v2.c b/src/stk500v2.c
index 3f6243c5..1fdf3bf8 100644
--- a/src/stk500v2.c
+++ b/src/stk500v2.c
@@ -19,8 +19,6 @@
* along with this program. If not, see .
*/
-/* Based on Id: stk500.c,v 1.46 2004/12/22 01:52:45 bdean Exp */
-
/*
* avrdude interface for Atmel STK500V2 programmer
*
@@ -54,17 +52,17 @@
#include "usbdevs.h"
/*
- * We need to import enough from the JTAG ICE mkII definitions to be
- * able to talk to the ICE, query some parameters etc. The macro
+ * We need to import enough from the JTAG ICE mkII definitions to be able to
+ * talk to the ICE, query some parameters etc. The macro
* JTAGMKII_PRIVATE_EXPORTED limits the amount of definitions that
- * jtagmkII_private.h will export, so to avoid conflicts with those
- * names that are identical to the STK500v2 ones.
+ * jtagmkII_private.h will export, so to avoid conflicts with those names that
+ * are identical to the STK500v2 ones.
*/
-#include "jtagmkII.h" // public interfaces from jtagmkII.c
+#include "jtagmkII.h"
#define JTAGMKII_PRIVATE_EXPORTED
#include "jtagmkII_private.h"
-#include "jtag3.h" // public interfaces from jtagmkII.c
+#include "jtag3.h"
#define JTAG3_PRIVATE_EXPORTED
#include "jtag3_private.h"
@@ -81,27 +79,22 @@
#define DEBUGRECV(...) msg_trace2(__VA_ARGS__)
-enum hvmode
-{
+enum hvmode {
PPMODE, HVSPMODE
};
-
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
-
-/*
- * Data structure for displaying STK600 routing and socket cards.
- */
-struct carddata
-{
+// Data structure for displaying STK600 routing and socket cards
+struct carddata {
int id;
const char *name;
};
static const char *pgmname(const PROGRAMMER *pgm) {
unsigned int i = PDATA(pgm)->pgmtype;
- const char *name[] = { // Parallel to PGMTYPE_ definitions in stk500v2_private.h
+
+ const char *name[] = { // Parallel to PGMTYPE_ definitions in stk500v2_private.h
"unknown",
"STK500",
"AVRISP",
@@ -111,12 +104,11 @@ static const char *pgmname(const PROGRAMMER *pgm) {
"JTAGICE3",
};
- return i==PGMTYPE_STK500 && PDATA(pgm)->is_scratchmonkey? "SCRATCHMONKEY": // STK500 with LEDs
- iis_scratchmonkey? "SCRATCHMONKEY" : // STK500 with LEDs
+ i < sizeof name/sizeof *name? name[i]: "None";
}
-struct jtagispentry
-{
+struct jtagispentry {
unsigned char cmd;
unsigned short size;
#define SZ_READ_FLASH_EE USHRT_MAX
@@ -124,56 +116,56 @@ struct jtagispentry
};
static const struct jtagispentry jtagispcmds[] = {
- /* generic */
- { CMD_SET_PARAMETER, 2 },
- { CMD_GET_PARAMETER, 3 },
- { CMD_OSCCAL, 2 },
- { CMD_LOAD_ADDRESS, 2 },
- /* ISP mode */
- { CMD_ENTER_PROGMODE_ISP, 2 },
- { CMD_LEAVE_PROGMODE_ISP, 2 },
- { CMD_CHIP_ERASE_ISP, 2 },
- { CMD_PROGRAM_FLASH_ISP, 2 },
- { CMD_READ_FLASH_ISP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_EEPROM_ISP, 2 },
- { CMD_READ_EEPROM_ISP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_FUSE_ISP, 3 },
- { CMD_READ_FUSE_ISP, 4 },
- { CMD_PROGRAM_LOCK_ISP, 3 },
- { CMD_READ_LOCK_ISP, 4 },
- { CMD_READ_SIGNATURE_ISP, 4 },
- { CMD_READ_OSCCAL_ISP, 4 },
- { CMD_SPI_MULTI, SZ_SPI_MULTI },
- /* all HV modes */
- { CMD_SET_CONTROL_STACK, 2 },
- /* HVSP mode */
- { CMD_ENTER_PROGMODE_HVSP, 2 },
- { CMD_LEAVE_PROGMODE_HVSP, 2 },
- { CMD_CHIP_ERASE_HVSP, 2 },
- { CMD_PROGRAM_FLASH_HVSP, 2 },
- { CMD_READ_FLASH_HVSP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_EEPROM_HVSP, 2 },
- { CMD_READ_EEPROM_HVSP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_FUSE_HVSP, 2 },
- { CMD_READ_FUSE_HVSP, 3 },
- { CMD_PROGRAM_LOCK_HVSP, 2 },
- { CMD_READ_LOCK_HVSP, 3 },
- { CMD_READ_SIGNATURE_HVSP, 3 },
- { CMD_READ_OSCCAL_HVSP, 3 },
- /* PP mode */
- { CMD_ENTER_PROGMODE_PP, 2 },
- { CMD_LEAVE_PROGMODE_PP, 2 },
- { CMD_CHIP_ERASE_PP, 2 },
- { CMD_PROGRAM_FLASH_PP, 2 },
- { CMD_READ_FLASH_PP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_EEPROM_PP, 2 },
- { CMD_READ_EEPROM_PP, SZ_READ_FLASH_EE },
- { CMD_PROGRAM_FUSE_PP, 2 },
- { CMD_READ_FUSE_PP, 3 },
- { CMD_PROGRAM_LOCK_PP, 2 },
- { CMD_READ_LOCK_PP, 3 },
- { CMD_READ_SIGNATURE_PP, 3 },
- { CMD_READ_OSCCAL_PP, 3 },
+ // Generic
+ {CMD_SET_PARAMETER, 2},
+ {CMD_GET_PARAMETER, 3},
+ {CMD_OSCCAL, 2},
+ {CMD_LOAD_ADDRESS, 2},
+ // ISP mode
+ {CMD_ENTER_PROGMODE_ISP, 2},
+ {CMD_LEAVE_PROGMODE_ISP, 2},
+ {CMD_CHIP_ERASE_ISP, 2},
+ {CMD_PROGRAM_FLASH_ISP, 2},
+ {CMD_READ_FLASH_ISP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_EEPROM_ISP, 2},
+ {CMD_READ_EEPROM_ISP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_FUSE_ISP, 3},
+ {CMD_READ_FUSE_ISP, 4},
+ {CMD_PROGRAM_LOCK_ISP, 3},
+ {CMD_READ_LOCK_ISP, 4},
+ {CMD_READ_SIGNATURE_ISP, 4},
+ {CMD_READ_OSCCAL_ISP, 4},
+ {CMD_SPI_MULTI, SZ_SPI_MULTI},
+ // All HV modes
+ {CMD_SET_CONTROL_STACK, 2},
+ // HVSP mode
+ {CMD_ENTER_PROGMODE_HVSP, 2},
+ {CMD_LEAVE_PROGMODE_HVSP, 2},
+ {CMD_CHIP_ERASE_HVSP, 2},
+ {CMD_PROGRAM_FLASH_HVSP, 2},
+ {CMD_READ_FLASH_HVSP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_EEPROM_HVSP, 2},
+ {CMD_READ_EEPROM_HVSP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_FUSE_HVSP, 2},
+ {CMD_READ_FUSE_HVSP, 3},
+ {CMD_PROGRAM_LOCK_HVSP, 2},
+ {CMD_READ_LOCK_HVSP, 3},
+ {CMD_READ_SIGNATURE_HVSP, 3},
+ {CMD_READ_OSCCAL_HVSP, 3},
+ // PP mode
+ {CMD_ENTER_PROGMODE_PP, 2},
+ {CMD_LEAVE_PROGMODE_PP, 2},
+ {CMD_CHIP_ERASE_PP, 2},
+ {CMD_PROGRAM_FLASH_PP, 2},
+ {CMD_READ_FLASH_PP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_EEPROM_PP, 2},
+ {CMD_READ_EEPROM_PP, SZ_READ_FLASH_EE},
+ {CMD_PROGRAM_FUSE_PP, 2},
+ {CMD_READ_FUSE_PP, 3},
+ {CMD_PROGRAM_LOCK_PP, 2},
+ {CMD_READ_LOCK_PP, 3},
+ {CMD_READ_SIGNATURE_PP, 3},
+ {CMD_READ_OSCCAL_PP, 3},
};
/*
@@ -185,80 +177,79 @@ static const struct jtagispentry jtagispcmds[] = {
1
*/
+
/*
- * These two tables can be semi-automatically updated from
- * targetboards.xml using tools/get-stk600-cards.xsl.
+ * These two tables can be semi-automatically updated from targetboards.xml
+ * using tools/get-stk600-cards.xsl.
*/
-static const struct carddata routing_cards[] =
-{
- { 0x01, "STK600-RC020T-1" },
- { 0x03, "STK600-RC028T-3" },
- { 0x05, "STK600-RC040M-5" },
- { 0x08, "STK600-RC020T-8" },
- { 0x0A, "STK600-RC040M-4" },
- { 0x0C, "STK600-RC008T-2" },
- { 0x0D, "STK600-RC028M-6" },
- { 0x10, "STK600-RC064M-10" },
- { 0x11, "STK600-RC100M-11" },
- { 0x13, "STK600-RC100X-13" },
- { 0x15, "STK600-RC044X-15" },
- { 0x18, "STK600-RC100M-18" },
- { 0x19, "STK600-RCPWM-19" },
- { 0x1A, "STK600-RC064X-14" },
- { 0x1B, "STK600-RC032U-20" },
- { 0x1C, "STK600-RC014T-12" },
- { 0x1E, "STK600-RC064U-17" },
- { 0x1F, "STK600-RCuC3B0-21" },
- { 0x20, "STK600-RCPWM-22" },
- { 0x21, "STK600-RC020T-23" },
- { 0x22, "STK600-RC044M-24" },
- { 0x23, "STK600-RC044U-25" },
- { 0x24, "STK600-RCPWM-26" },
- { 0x25, "STK600-RCuC3B48-27" },
- { 0x27, "STK600-RC032M-29" },
- { 0x28, "STK600-RC044M-30" },
- { 0x29, "STK600-RC044M-31" },
- { 0x2A, "STK600-RC014T-42" },
- { 0x2B, "STK600-RC020T-43" },
- { 0x30, "STK600-RCUC3A144-32" },
- { 0x34, "STK600-RCUC3L0-34" },
- { 0x38, "STK600-RCUC3C0-36" },
- { 0x3B, "STK600-RCUC3C0-37" },
- { 0x3E, "STK600-RCUC3A144-33" },
- { 0x46, "STK600-RCuC3A100-28" },
- { 0x55, "STK600-RC064M-9" },
- { 0x88, "STK600-RCUC3C1-38" },
- { 0x8B, "STK600-RCUC3C1-39" },
- { 0xA0, "STK600-RC008T-7" },
- { 0xB8, "STK600-RCUC3C2-40" },
- { 0xBB, "STK600-RCUC3C2-41" },
+static const struct carddata routing_cards[] = {
+ {0x01, "STK600-RC020T-1"},
+ {0x03, "STK600-RC028T-3"},
+ {0x05, "STK600-RC040M-5"},
+ {0x08, "STK600-RC020T-8"},
+ {0x0A, "STK600-RC040M-4"},
+ {0x0C, "STK600-RC008T-2"},
+ {0x0D, "STK600-RC028M-6"},
+ {0x10, "STK600-RC064M-10"},
+ {0x11, "STK600-RC100M-11"},
+ {0x13, "STK600-RC100X-13"},
+ {0x15, "STK600-RC044X-15"},
+ {0x18, "STK600-RC100M-18"},
+ {0x19, "STK600-RCPWM-19"},
+ {0x1A, "STK600-RC064X-14"},
+ {0x1B, "STK600-RC032U-20"},
+ {0x1C, "STK600-RC014T-12"},
+ {0x1E, "STK600-RC064U-17"},
+ {0x1F, "STK600-RCuC3B0-21"},
+ {0x20, "STK600-RCPWM-22"},
+ {0x21, "STK600-RC020T-23"},
+ {0x22, "STK600-RC044M-24"},
+ {0x23, "STK600-RC044U-25"},
+ {0x24, "STK600-RCPWM-26"},
+ {0x25, "STK600-RCuC3B48-27"},
+ {0x27, "STK600-RC032M-29"},
+ {0x28, "STK600-RC044M-30"},
+ {0x29, "STK600-RC044M-31"},
+ {0x2A, "STK600-RC014T-42"},
+ {0x2B, "STK600-RC020T-43"},
+ {0x30, "STK600-RCUC3A144-32"},
+ {0x34, "STK600-RCUC3L0-34"},
+ {0x38, "STK600-RCUC3C0-36"},
+ {0x3B, "STK600-RCUC3C0-37"},
+ {0x3E, "STK600-RCUC3A144-33"},
+ {0x46, "STK600-RCuC3A100-28"},
+ {0x55, "STK600-RC064M-9"},
+ {0x88, "STK600-RCUC3C1-38"},
+ {0x8B, "STK600-RCUC3C1-39"},
+ {0xA0, "STK600-RC008T-7"},
+ {0xB8, "STK600-RCUC3C2-40"},
+ {0xBB, "STK600-RCUC3C2-41"},
};
-static const struct carddata socket_cards[] =
-{
- { 0x01, "STK600-TQFP48" },
- { 0x02, "STK600-TQFP32" },
- { 0x03, "STK600-TQFP100" },
- { 0x04, "STK600-SOIC" },
- { 0x06, "STK600-TQFP144" },
- { 0x09, "STK600-TinyX3U" },
- { 0x0C, "STK600-TSSOP44" },
- { 0x0D, "STK600-TQFP44" },
- { 0x0E, "STK600-TQFP64-2" },
- { 0x0F, "STK600-ATMEGA2560" },
- { 0x15, "STK600-MLF64" },
- { 0x16, "STK600-ATXMEGAT0" },
- { 0x18, "QT600-ATMEGA324-QM64" },
- { 0x19, "STK600-ATMEGA128RFA1" },
- { 0x1A, "QT600-ATTINY88-QT8" },
- { 0x1B, "QT600-ATXMEGA128A1-QT16" },
- { 0x1C, "QT600-AT32UC3L-QM64" },
- { 0x1D, "STK600-HVE2" },
- { 0x1E, "STK600-ATTINY10" },
- { 0x55, "STK600-TQFP64" },
- { 0x69, "STK600-uC3-144" },
- { 0xF0, "STK600-ATXMEGA1281A1" },
- { 0xF1, "STK600-DIP" },
+static const struct carddata socket_cards[] = {
+ {0x01, "STK600-TQFP48"},
+ {0x02, "STK600-TQFP32"},
+ {0x03, "STK600-TQFP100"},
+ {0x04, "STK600-SOIC"},
+ {0x06, "STK600-TQFP144"},
+ {0x09, "STK600-TinyX3U"},
+ {0x0C, "STK600-TSSOP44"},
+ {0x0D, "STK600-TQFP44"},
+ {0x0E, "STK600-TQFP64-2"},
+ {0x0F, "STK600-ATMEGA2560"},
+ {0x15, "STK600-MLF64"},
+ {0x16, "STK600-ATXMEGAT0"},
+ {0x18, "QT600-ATMEGA324-QM64"},
+ {0x19, "STK600-ATMEGA128RFA1"},
+ {0x1A, "QT600-ATTINY88-QT8"},
+ {0x1B, "QT600-ATXMEGA128A1-QT16"},
+ {0x1C, "QT600-AT32UC3L-QM64"},
+ {0x1D, "STK600-HVE2"},
+ {0x1E, "STK600-ATTINY10"},
+ {0x55, "STK600-TQFP64"},
+ {0x69, "STK600-uC3-144"},
+ {0xF0, "STK600-ATXMEGA1281A1"},
+ {0xF1, "STK600-DIP"},
};
static int stk500v2_getparm(const PROGRAMMER *pgm, unsigned char parm, unsigned char *value);
@@ -268,11 +259,9 @@ static int stk500v2_setparm2(const PROGRAMMER *pgm, unsigned char parm, unsigned
static int stk500v2_setparm_real(const PROGRAMMER *pgm, unsigned char parm, unsigned char value);
static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp);
static int stk500v2_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes);
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes);
static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes);
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes);
static unsigned int stk500v2_mode_for_pagesize(unsigned int pagesize);
@@ -295,7 +284,7 @@ void stk500v2_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->command_sequence = 1;
PDATA(pgm)->boot_start = ULONG_MAX;
- PDATA(pgm)->xtal = str_starts(pgmid, "scratchmonkey") ? SCRATCHMONKEY_XTAL : STK500V2_XTAL;
+ PDATA(pgm)->xtal = str_starts(pgmid, "scratchmonkey")? SCRATCHMONKEY_XTAL: STK500V2_XTAL;
}
static void stk500v2_jtagmkII_setup(PROGRAMMER *pgm) {
@@ -305,8 +294,8 @@ static void stk500v2_jtagmkII_setup(PROGRAMMER *pgm) {
PDATA(pgm)->command_sequence = 1;
/*
- * Now, have the JTAG ICE mkII backend allocate its own private
- * data. Store our own cookie in a safe place for the time being.
+ * Now, have the JTAG ICE mkII backend allocate its own private data. Store
+ * our own cookie in a safe place for the time being.
*/
mycookie = pgm->cookie;
jtagmkII_setup(pgm);
@@ -322,8 +311,8 @@ static void stk500v2_jtag3_setup(PROGRAMMER *pgm) {
PDATA(pgm)->command_sequence = 1;
/*
- * Now, have the JTAGICE3 backend allocate its own private
- * data. Store our own cookie in a safe place for the time being.
+ * Now, have the JTAGICE3 backend allocate its own private data. Store our
+ * own cookie in a safe place for the time being.
*/
mycookie = pgm->cookie;
jtag3_setup(pgm);
@@ -343,6 +332,7 @@ static void stk500v2_jtagmkII_teardown(PROGRAMMER *pgm) {
mmt_free(PDATA(pgm)->eeprom_pagecache);
void *mycookie = pgm->cookie;
+
pgm->cookie = PDATA(pgm)->chained_pdata;
jtagmkII_teardown(pgm);
pgm->cookie = mycookie;
@@ -355,6 +345,7 @@ static void stk500v2_jtagmkII_teardown(PROGRAMMER *pgm) {
static void stk500v2_jtag3_teardown(PROGRAMMER *pgm) {
if(pgm->cookie) {
void *mycookie = pgm->cookie;
+
pgm->cookie = PDATA(pgm)->chained_pdata;
jtag3_teardown(pgm);
pgm->cookie = mycookie;
@@ -364,11 +355,11 @@ static void stk500v2_jtag3_teardown(PROGRAMMER *pgm) {
pgm->cookie = NULL;
}
-
static unsigned short b2_to_u16(unsigned char *b) {
unsigned short l;
+
l = b[0];
- l += (unsigned)b[1] << 8;
+ l += (unsigned) b[1] << 8;
return l;
}
@@ -379,10 +370,10 @@ static void u16_to_b2(unsigned char *b, unsigned short l) {
}
static double f_to_kHz_MHz(double f, const char **unit) {
- if (f >= 1e6) {
+ if(f >= 1e6) {
f /= 1e6;
*unit = "MHz";
- } else if (f >= 1e3) {
+ } else if(f >= 1e3) {
f /= 1000;
*unit = "kHz";
} else
@@ -392,15 +383,15 @@ static double f_to_kHz_MHz(double f, const char **unit) {
}
static int get_decimals(double f) {
- if (f >= 1e6)
+ if(f >= 1e6)
return 6;
- if (f >= 1e3)
+ if(f >= 1e3)
return 3;
return 0;
}
static int stk500v2_send_mk2(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
- if (serial_send(&pgm->fd, data, len) != 0) {
+ if(serial_send(&pgm->fd, data, len) != 0) {
pmsg_error("unable to send command to serial port\n");
return -1;
}
@@ -408,20 +399,18 @@ static int stk500v2_send_mk2(const PROGRAMMER *pgm, unsigned char *data, size_t
return 0;
}
-static unsigned short get_jtagisp_return_size(unsigned char cmd)
-{
- for (size_t i = 0; i < sizeof jtagispcmds / sizeof jtagispcmds[0]; i++)
- if (jtagispcmds[i].cmd == cmd)
+static unsigned short get_jtagisp_return_size(unsigned char cmd) {
+ for(size_t i = 0; i < sizeof jtagispcmds/sizeof jtagispcmds[0]; i++)
+ if(jtagispcmds[i].cmd == cmd)
return jtagispcmds[i].size;
return 0;
}
/*
- * Send the data as a JTAG ICE mkII encapsulated ISP packet.
- * Unlike what AVR067 says, the packet gets a length of our
- * response buffer prepended, and replies with RSP_SPI_DATA
- * if successful.
+ * Send the data as a JTAG ICE mkII encapsulated ISP packet. Unlike what AVR067
+ * says, the packet gets a length of our response buffer prepended, and replies
+ * with RSP_SPI_DATA if successful.
*/
static int stk500v2_jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
unsigned char *cmdbuf;
@@ -429,27 +418,26 @@ static int stk500v2_jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, si
unsigned short sz;
sz = get_jtagisp_return_size(data[0]);
- if (sz == 0) {
+ if(sz == 0) {
pmsg_error("unsupported encapsulated ISP command: %#x\n", data[0]);
return -1;
}
- if (sz == SZ_READ_FLASH_EE) {
+ if(sz == SZ_READ_FLASH_EE) {
/*
- * For CMND_READ_FLASH_ISP and CMND_READ_EEPROM_ISP, extract the
- * size of the return data from the request. Note that the
- * request itself has the size in big endian format, while we are
- * supposed to deliver it in little endian.
+ * For CMND_READ_FLASH_ISP and CMND_READ_EEPROM_ISP, extract the size of
+ * the return data from the request. Note that the request itself has the
+ * size in big endian format, while we are supposed to deliver it in little
+ * endian.
*/
sz = 3 + (data[1] << 8) + data[2];
- } else if (sz == SZ_SPI_MULTI) {
- /*
- * CMND_SPI_MULTI has the Rx size encoded in its 3rd byte.
- */
+ } else if(sz == SZ_SPI_MULTI) {
+ // CMND_SPI_MULTI has the Rx size encoded in its 3rd byte
sz = 3 + data[2];
}
cmdbuf = mmt_malloc(len + 3);
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
cmdbuf[0] = CMND_ISP_PACKET;
cmdbuf[1] = sz & 0xff;
@@ -462,15 +450,14 @@ static int stk500v2_jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, si
return rv;
}
-/*
- * Send the data as a JTAGICE3 encapsulated ISP packet.
- */
+// Send the data as a JTAGICE3 encapsulated ISP packet
static int stk500v2_jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
unsigned char *cmdbuf;
int rv;
cmdbuf = mmt_malloc(len + 1);
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
cmdbuf[0] = SCOPE_AVR_ISP;
memcpy(cmdbuf + 1, data, len);
@@ -482,34 +469,33 @@ static int stk500v2_jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_
}
static int stk500v2_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
- unsigned char buf[275 + 6]; // max MESSAGE_BODY of 275 bytes, 6 bytes overhead
+ unsigned char buf[275 + 6]; // Max MESSAGE_BODY of 275 bytes, 6 bytes overhead
- if (PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
- PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+ if(PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
return stk500v2_send_mk2(pgm, data, len);
- else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
+ if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
return stk500v2_jtagmkII_send(pgm, data, len);
- else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+ if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
return stk500v2_jtag3_send(pgm, data, len);
buf[0] = MESSAGE_START;
buf[1] = PDATA(pgm)->command_sequence;
- buf[2] = len / 256;
- buf[3] = len % 256;
+ buf[2] = len/256;
+ buf[3] = len%256;
buf[4] = TOKEN;
- memcpy(buf+5, data, len);
+ memcpy(buf + 5, data, len);
- // calculate the XOR checksum
- buf[5+len] = 0;
- for (size_t i=0; i<5+len; i++)
- buf[5+len] ^= buf[i];
+ // Calculate the XOR checksum
+ buf[5 + len] = 0;
+ for(size_t i = 0; i < 5 + len; i++)
+ buf[5 + len] ^= buf[i];
DEBUG("STK500V2: stk500v2_send(");
- for (size_t i=0; ifd, buf, len+6) != 0) {
+ if(serial_send(&pgm->fd, buf, len + 6) != 0) {
pmsg_error("unable to send command to serial port\n");
return -1;
}
@@ -517,18 +503,15 @@ static int stk500v2_send(const PROGRAMMER *pgm, unsigned char *data, size_t len)
return 0;
}
-
int stk500v2_drain(const PROGRAMMER *pgm, int display) {
return serial_drain(&pgm->fd, display);
}
-static int stk500v2_recv_mk2(const PROGRAMMER *pgm, unsigned char *msg,
- size_t maxsize)
-{
+static int stk500v2_recv_mk2(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsize) {
int rv;
rv = serial_recv(&pgm->fd, msg, maxsize);
- if (rv < 0) {
+ if(rv < 0) {
pmsg_error("unable to receive from USB\n");
return -1;
}
@@ -536,21 +519,20 @@ static int stk500v2_recv_mk2(const PROGRAMMER *pgm, unsigned char *msg,
return rv;
}
-static int stk500v2_jtagmkII_recv(const PROGRAMMER *pgm, unsigned char *msg,
- size_t maxsize)
-{
+static int stk500v2_jtagmkII_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsize) {
int rv;
unsigned char *jtagmsg;
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
rv = jtagmkII_recv(pgmcp, &jtagmsg);
pgm_free(pgmcp);
- if (rv <= 0) {
+ if(rv <= 0) {
pmsg_error("unable to receive\n");
return -1;
}
- if ((size_t) rv - 1 > maxsize) {
+ if((size_t) rv - 1 > maxsize) {
pmsg_warning("got %u bytes, have only room for %u bytes\n", (unsigned) rv - 1, (unsigned) maxsize);
rv = maxsize;
}
@@ -572,30 +554,30 @@ static int stk500v2_jtagmkII_recv(const PROGRAMMER *pgm, unsigned char *msg,
return rv;
}
-static int stk500v2_jtag3_recv(const PROGRAMMER *pgm, unsigned char *msg,
- size_t maxsize)
-{
+static int stk500v2_jtag3_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsize) {
int rv;
unsigned char *jtagmsg;
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
rv = jtag3_recv(pgmcp, &jtagmsg);
pgm_free(pgmcp);
- if (rv <= 0) {
+ if(rv <= 0) {
pmsg_error("unable to receive\n");
return -1;
}
- /* Getting more data than expected is a normal case for the EDBG
- implementation of JTAGICE3, as they always request a full 512
- octets from the ICE. Thus, only complain at high verbose
- levels. */
- if ((size_t) rv - 1 > maxsize) {
+ /*
+ * Getting more data than expected is a normal case for the EDBG
+ * implementation of JTAGICE3, as they always request a full 512 octets from
+ * the ICE. Thus, only complain at high verbose levels.
+ */
+ if((size_t) rv - 1 > maxsize) {
pmsg_debug("%s(): got %u bytes, have only room for %u bytes\n", __func__, (unsigned) rv - 1, (unsigned) maxsize);
rv = maxsize;
}
- if (jtagmsg[0] != SCOPE_AVR_ISP) {
+ if(jtagmsg[0] != SCOPE_AVR_ISP) {
pmsg_error("message is not AVR ISP: 0x%02x\n", jtagmsg[0]);
mmt_free(jtagmsg);
return -1;
@@ -606,7 +588,7 @@ static int stk500v2_jtag3_recv(const PROGRAMMER *pgm, unsigned char *msg,
}
static int stk500v2_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsize) {
- enum states { sINIT, sSTART, sSEQNUM, sSIZE1, sSIZE2, sTOKEN, sDATA, sCSUM, sDONE } state = sSTART;
+ enum states { sINIT, sSTART, sSEQNUM, sSIZE1, sSIZE2, sTOKEN, sDATA, sCSUM, sDONE } state = sSTART;
unsigned int msglen = 0;
unsigned int curlen = 0;
int timeout = 0;
@@ -614,109 +596,109 @@ static int stk500v2_recv(const PROGRAMMER *pgm, unsigned char *msg, size_t maxsi
/*
* The entire timeout handling here is not very consistent, see
- *
* https://savannah.nongnu.org/bugs/index.php?43626
*/
- long timeoutval = SERIAL_TIMEOUT; // seconds
+ long timeoutval = SERIAL_TIMEOUT; // Seconds
double tstart, tnow;
- if (PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
- PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+ if(PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
return stk500v2_recv_mk2(pgm, msg, maxsize);
- else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
+ else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
return stk500v2_jtagmkII_recv(pgm, msg, maxsize);
- else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+ else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
return stk500v2_jtag3_recv(pgm, msg, maxsize);
DEBUG("STK500V2: stk500v2_recv(): ");
tstart = avr_timestamp();
- while ( (state != sDONE ) && (!timeout) ) {
- if (serial_recv(&pgm->fd, &c, 1) < 0)
+ while((state != sDONE) && (!timeout)) {
+ if(serial_recv(&pgm->fd, &c, 1) < 0)
goto timedout;
- DEBUG("0x%02x ",c);
+ DEBUG("0x%02x ", c);
checksum ^= c;
switch (state) {
- case sSTART:
- DEBUGRECV("hoping for start token ...");
- if (c == MESSAGE_START) {
- DEBUGRECV("got it\n");
- checksum = MESSAGE_START;
- state = sSEQNUM;
- } else
- DEBUGRECV("sorry\n");
- break;
- case sSEQNUM:
- DEBUGRECV("hoping for sequence ...\n");
- if (c == PDATA(pgm)->command_sequence) {
- DEBUGRECV("got it, incrementing\n");
- state = sSIZE1;
- PDATA(pgm)->command_sequence++;
- } else {
- DEBUGRECV("sorry\n");
- state = sSTART;
- }
- break;
- case sSIZE1:
- DEBUGRECV("hoping for size LSB\n");
- msglen = (unsigned)c * 256;
- state = sSIZE2;
- break;
- case sSIZE2:
- DEBUGRECV("hoping for size MSB ...");
- msglen += (unsigned)c;
- DEBUG(" msg is %u bytes\n",msglen);
- state = sTOKEN;
- break;
- case sTOKEN:
- if (c == TOKEN) state = sDATA;
- else state = sSTART;
- break;
- case sDATA:
- if (curlen < maxsize) {
- msg[curlen] = c;
- } else {
- pmsg_error("buffer too small, received %d byte into %u byte buffer\n",
- curlen, (unsigned int) maxsize);
- return -2;
- }
- if ((curlen == 0) && (msg[0] == ANSWER_CKSUM_ERROR)) {
- pmsg_error("previous packet sent with wrong checksum\n");
- return -3;
- }
- curlen++;
- if (curlen == msglen) state = sCSUM;
- break;
- case sCSUM:
- if (checksum == 0) {
- state = sDONE;
- } else {
- state = sSTART;
- pmsg_error("wrong checksum\n");
- return -4;
- }
- break;
- default:
- pmsg_error("unknown state\n");
- return -5;
- } /* switch */
+ case sSTART:
+ DEBUGRECV("hoping for start token ...");
+ if(c == MESSAGE_START) {
+ DEBUGRECV("got it\n");
+ checksum = MESSAGE_START;
+ state = sSEQNUM;
+ } else
+ DEBUGRECV("sorry\n");
+ break;
+ case sSEQNUM:
+ DEBUGRECV("hoping for sequence ...\n");
+ if(c == PDATA(pgm)->command_sequence) {
+ DEBUGRECV("got it, incrementing\n");
+ state = sSIZE1;
+ PDATA(pgm)->command_sequence++;
+ } else {
+ DEBUGRECV("sorry\n");
+ state = sSTART;
+ }
+ break;
+ case sSIZE1:
+ DEBUGRECV("hoping for size LSB\n");
+ msglen = (unsigned) c *256;
- tnow = avr_timestamp();
- if (tnow-tstart > timeoutval) {
- timedout:
- pmsg_error("timeout\n");
- return -1;
- }
+ state = sSIZE2;
+ break;
+ case sSIZE2:
+ DEBUGRECV("hoping for size MSB ...");
+ msglen += (unsigned) c;
+ DEBUG(" msg is %u bytes\n", msglen);
+ state = sTOKEN;
+ break;
+ case sTOKEN:
+ if(c == TOKEN)
+ state = sDATA;
+ else
+ state = sSTART;
+ break;
+ case sDATA:
+ if(curlen < maxsize) {
+ msg[curlen] = c;
+ } else {
+ pmsg_error("buffer too small, received %d byte into %u byte buffer\n", curlen, (unsigned int) maxsize);
+ return -2;
+ }
+ if((curlen == 0) && (msg[0] == ANSWER_CKSUM_ERROR)) {
+ pmsg_error("previous packet sent with wrong checksum\n");
+ return -3;
+ }
+ curlen++;
+ if(curlen == msglen)
+ state = sCSUM;
+ break;
+ case sCSUM:
+ if(checksum == 0) {
+ state = sDONE;
+ } else {
+ state = sSTART;
+ pmsg_error("wrong checksum\n");
+ return -4;
+ }
+ break;
+ default:
+ pmsg_error("unknown state\n");
+ return -5;
+ } // Switch
- } /* while */
+ tnow = avr_timestamp();
+ if(tnow - tstart > timeoutval) {
+ timedout:
+ pmsg_error("timeout\n");
+ return -1;
+ }
+
+ } // While
DEBUG("\n");
- return (int)(msglen+6);
+ return (int) (msglen + 6);
}
-
int stk500v2_getsync(const PROGRAMMER *pgm) {
int tries = 0;
unsigned char buf[1], resp[32];
@@ -724,51 +706,53 @@ int stk500v2_getsync(const PROGRAMMER *pgm) {
DEBUG("STK500V2: stk500v2_getsync()\n");
- if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII ||
- PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
+ if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII || PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
return 0;
long bak_serial_recv_timeout = serial_recv_timeout;
+
serial_recv_timeout = 200;
retry:
tries++;
- // send the sync command and see if we can get there
+ // Send the sync command and see if we can get there
buf[0] = CMD_SIGN_ON;
stk500v2_send(pgm, buf, 1);
- // try to get the response back and see where we got
+ // Try to get the response back and see where we got
memset(resp, 0, sizeof resp);
status = stk500v2_recv(pgm, resp, sizeof(resp));
- // if we got bytes returned, check to see what came back
- if (status > 0) {
- if (resp[0] == CMD_SIGN_ON && resp[1] == STATUS_CMD_OK && status > 3) {
- // success!
+ // If we got bytes returned, check to see what came back
+ if(status > 0) {
+ if(resp[0] == CMD_SIGN_ON && resp[1] == STATUS_CMD_OK && status > 3) {
+ // Success!
char *name = (char *) resp + 3;
+
if(str_starts(name, "STK500_2")) {
- PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+ PDATA(pgm)->pgmtype = PGMTYPE_STK500;
} else if(str_starts(name, "SCRATCHMONKEY")) {
- PDATA(pgm)->is_scratchmonkey = 1;
- PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+ PDATA(pgm)->is_scratchmonkey = 1;
+ PDATA(pgm)->pgmtype = PGMTYPE_STK500;
} else if(str_starts(name, "AVRISP_2")) {
- PDATA(pgm)->pgmtype = PGMTYPE_AVRISP;
+ PDATA(pgm)->pgmtype = PGMTYPE_AVRISP;
} else if(str_starts(name, "AVRISP_MK2")) {
- PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
+ PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
} else if(str_starts(name, "STK600")) {
- PDATA(pgm)->pgmtype = PGMTYPE_STK600;
+ PDATA(pgm)->pgmtype = PGMTYPE_STK600;
} else {
unsigned int len = resp[2];
- resp[len + 3 >= sizeof resp? sizeof resp - 1: len + 3] = 0;
+
+ resp[len + 3 >= sizeof resp? sizeof resp - 1: len + 3] = 0;
pmsg_notice("%s(): unknown programmer %s, assuming STK500\n", __func__, name);
- PDATA(pgm)->pgmtype = PGMTYPE_STK500;
+ PDATA(pgm)->pgmtype = PGMTYPE_STK500;
}
pmsg_debug("%s(): found %s programmer\n", __func__, pgmname(pgm));
serial_recv_timeout = bak_serial_recv_timeout;
return 0;
} else {
- if (tries > RETRIES) {
+ if(tries > RETRIES) {
pmsg_error("cannot communicate with device: resp=0x%02x\n", resp[0]);
serial_recv_timeout = bak_serial_recv_timeout;
return -6;
@@ -776,18 +760,18 @@ retry:
goto retry;
}
- // or if we got a timeout
- } else if (status == -1) {
- if (tries > RETRIES) {
+ // Or if we got a timeout
+ } else if(status == -1) {
+ if(tries > RETRIES) {
pmsg_error("timeout communicating with programmer\n");
serial_recv_timeout = bak_serial_recv_timeout;
return -1;
} else
goto retry;
- // or any other error
+ // Or any other error
} else {
- if (tries > RETRIES) {
+ if(tries > RETRIES) {
pmsg_error("unable to communicate with programmer (%d)\n", status);
} else
goto retry;
@@ -797,109 +781,111 @@ retry:
return 0;
}
-static int stk500v2_command(const PROGRAMMER *pgm, unsigned char *buf,
- size_t len, size_t maxlen) {
+static int stk500v2_command(const PROGRAMMER *pgm, unsigned char *buf, size_t len, size_t maxlen) {
int tries = 0;
int status;
DEBUG("STK500V2: stk500v2_command(");
- for (size_t i=0; i 0) {
- DEBUG(" = %d\n",status);
- if (status < 2) {
+ // If we got a successful readback, return
+ if(status > 0) {
+ DEBUG(" = %d\n", status);
+ if(status < 2) {
pmsg_error("short reply\n");
return -1;
}
- if (buf[0] == CMD_XPROG_SETMODE || buf[0] == CMD_XPROG) {
- /*
- * Decode XPROG wrapper errors.
- */
- const char *msg;
- int i;
+ if(buf[0] == CMD_XPROG_SETMODE || buf[0] == CMD_XPROG) {
+ // Decode XPROG wrapper errors
+ const char *msg;
+ int i;
- /*
- * For CMD_XPROG_SETMODE, the status is returned in buf[1].
- * For CMD_XPROG, buf[1] contains the XPRG_CMD_* command, and
- * buf[2] contains the status.
- */
- i = buf[0] == CMD_XPROG_SETMODE? 1: 2;
+ /*
+ * For CMD_XPROG_SETMODE, the status is returned in buf[1]. For
+ * CMD_XPROG, buf[1] contains the XPRG_CMD_* command, and buf[2] contains
+ * the status.
+ */
+ i = buf[0] == CMD_XPROG_SETMODE? 1: 2;
- if (buf[i] != XPRG_ERR_OK) {
- switch (buf[i]) {
- case XPRG_ERR_FAILED: msg = "Failed"; break;
- case XPRG_ERR_COLLISION: msg = "Collision"; break;
- case XPRG_ERR_TIMEOUT: msg = "Timeout"; break;
- default: msg = "Unknown"; break;
- }
- pmsg_error("%s: %s\n",
- buf[0]==CMD_XPROG_SETMODE? "CMD_XPROG_SETMODE": "CMD_XPROG", msg);
- return -1;
- }
- return 0;
- } else {
- /*
- * Decode STK500v2 errors.
- */
- if (buf[1] >= STATUS_CMD_TOUT && buf[1] < 0xa0) {
- const char *msg;
- char msgbuf[30];
- switch (buf[1]) {
- case STATUS_CMD_TOUT:
- msg = "Command timed out";
- break;
-
- case STATUS_RDY_BSY_TOUT:
- msg = "Sampling of the RDY/nBSY pin timed out";
- break;
-
- case STATUS_SET_PARAM_MISSING:
- msg = "The `Set Device Parameters' have not been "
- "executed in advance of this command";
- break;
-
- default:
- sprintf(msgbuf, "unknown, code 0x%02x", buf[1]);
- msg = msgbuf;
- break;
- }
- pmsg_warning("%s\n", msg);
- } else if (buf[1] == STATUS_CMD_OK) {
- return status;
- } else if (buf[1] == STATUS_CMD_FAILED) {
- pmsg_error("command failed\n");
- } else if (buf[1] == STATUS_CLOCK_ERROR) {
- pmsg_error("target clock speed error\n");
- return -2;
- } else if (buf[1] == STATUS_CMD_UNKNOWN) {
- pmsg_error("unknown command\n");
- } else {
- pmsg_error("unknown status 0x%02x\n", buf[1]);
+ if(buf[i] != XPRG_ERR_OK) {
+ switch (buf[i]) {
+ case XPRG_ERR_FAILED:
+ msg = "Failed";
+ break;
+ case XPRG_ERR_COLLISION:
+ msg = "Collision";
+ break;
+ case XPRG_ERR_TIMEOUT:
+ msg = "Timeout";
+ break;
+ default:
+ msg = "Unknown";
+ break;
}
+ pmsg_error("%s: %s\n", buf[0] == CMD_XPROG_SETMODE? "CMD_XPROG_SETMODE": "CMD_XPROG", msg);
return -1;
+ }
+ return 0;
+ } else {
+ // Decode STK500v2 errors
+ if(buf[1] >= STATUS_CMD_TOUT && buf[1] < 0xa0) {
+ const char *msg;
+ char msgbuf[30];
+
+ switch (buf[1]) {
+ case STATUS_CMD_TOUT:
+ msg = "Command timed out";
+ break;
+
+ case STATUS_RDY_BSY_TOUT:
+ msg = "Sampling of the RDY/nBSY pin timed out";
+ break;
+
+ case STATUS_SET_PARAM_MISSING:
+ msg = "The `Set Device Parameters' have not been " "executed in advance of this command";
+ break;
+
+ default:
+ sprintf(msgbuf, "unknown, code 0x%02x", buf[1]);
+ msg = msgbuf;
+ break;
+ }
+ pmsg_warning("%s\n", msg);
+ } else if(buf[1] == STATUS_CMD_OK) {
+ return status;
+ } else if(buf[1] == STATUS_CMD_FAILED) {
+ pmsg_error("command failed\n");
+ } else if(buf[1] == STATUS_CLOCK_ERROR) {
+ pmsg_error("target clock speed error\n");
+ return -2;
+ } else if(buf[1] == STATUS_CMD_UNKNOWN) {
+ pmsg_error("unknown command\n");
+ } else {
+ pmsg_error("unknown status 0x%02x\n", buf[1]);
+ }
+ return -1;
}
}
- // otherwise try to sync up again
+ // Otherwise try to sync up again
status = stk500v2_getsync(pgm);
- if (status != 0) {
- if (tries > RETRIES) {
+ if(status != 0) {
+ if(tries > RETRIES) {
pmsg_error("failed to execute command 0x%02x\n", buf[0]);
return -1;
} else
@@ -910,13 +896,11 @@ retry:
return 0;
}
-static int stk500v2_cmd(const PROGRAMMER *pgm, const unsigned char *cmd,
- unsigned char *res)
-{
+static int stk500v2_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
unsigned char buf[8];
int result;
- DEBUG("STK500V2: stk500v2_cmd(%02x,%02x,%02x,%02x)\n",cmd[0],cmd[1],cmd[2],cmd[3]);
+ DEBUG("STK500V2: stk500v2_cmd(%02x,%02x,%02x,%02x)\n", cmd[0], cmd[1], cmd[2], cmd[3]);
buf[0] = CMD_SPI_MULTI;
buf[1] = 4;
@@ -928,10 +912,10 @@ static int stk500v2_cmd(const PROGRAMMER *pgm, const unsigned char *cmd,
buf[7] = cmd[3];
result = stk500v2_command(pgm, buf, 8, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("send command failed\n");
return -1;
- } else if (result < 6) {
+ } else if(result < 6) {
pmsg_error("short reply, len = %d\n", result);
return -1;
}
@@ -944,50 +928,42 @@ static int stk500v2_cmd(const PROGRAMMER *pgm, const unsigned char *cmd,
return 0;
}
-
-static int stk500v2_jtag3_cmd(const PROGRAMMER *pgm, const unsigned char *cmd,
- unsigned char *res)
-{
+static int stk500v2_jtag3_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
pmsg_error("not available in JTAGICE3\n");
return -1;
}
-
-/*
- * issue the 'chip erase' command to the AVR device
- */
+// Issue the 'chip erase' command to the AVR device
static int stk500v2_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
int result;
unsigned char buf[16];
- if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
+ if(p->op[AVR_OP_CHIP_ERASE] == NULL) {
pmsg_error("chip erase instruction not defined for part %s\n", p->desc);
return -1;
}
buf[0] = CMD_CHIP_ERASE_ISP;
- buf[1] = p->chip_erase_delay / 1000;
- buf[2] = 0; // use delay (?)
- memset(buf+3, 0, 4);
- avr_set_bits(p->op[AVR_OP_CHIP_ERASE], buf+3);
+ buf[1] = p->chip_erase_delay/1000;
+ buf[2] = 0; // Use delay (?)
+ memset(buf + 3, 0, 4);
+ avr_set_bits(p->op[AVR_OP_CHIP_ERASE], buf + 3);
result = stk500v2_command(pgm, buf, 7, sizeof(buf));
- usleep(p->chip_erase_delay); // should not be needed
- if (PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII) { // skip for JTAGICE mkII (FW v7.39)
- pgm->initialize(pgm, p); // should not be needed
+ usleep(p->chip_erase_delay); // Should not be needed
+ if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII) { // Skip for JTAGICE mkII (FW v7.39)
+ pgm->initialize(pgm, p); // Should not be needed
}
return result >= 0? 0: -1;
}
-/*
- * issue the 'chip erase' command to the AVR device, generic HV mode
- */
+// Issue the 'chip erase' command to the AVR device, generic HV mode
static int stk500hv_chip_erase(const PROGRAMMER *pgm, const AVRPART *p, enum hvmode mode) {
int result;
unsigned char buf[3];
- if (mode == PPMODE) {
+ if(mode == PPMODE) {
buf[0] = CMD_CHIP_ERASE_PP;
buf[1] = p->chiperasepulsewidth;
buf[2] = p->chiperasepolltimeout;
@@ -1003,39 +979,35 @@ static int stk500hv_chip_erase(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
return result >= 0? 0: -1;
}
-/*
- * issue the 'chip erase' command to the AVR device, parallel mode
- */
+// Issue the 'chip erase' command to the AVR device, parallel mode
static int stk500pp_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500hv_chip_erase(pgm, p, PPMODE);
}
-/*
- * issue the 'chip erase' command to the AVR device, HVSP mode
- */
+// Issue the 'chip erase' command to the AVR device, HVSP mode
static int stk500hvsp_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500hv_chip_erase(pgm, p, HVSPMODE);
}
/*
- * Max length of returned message is the sum of all the description
- * strings in the table below, plus 2 characters for separation each.
- * Currently, this is 74 chars plus the terminating nul.
+ * Max length of returned message is the sum of all the description strings in
+ * the table below, plus 2 characters for separation each. Currently, this is
+ * 74 chars plus the terminating nul.
*/
static void stk500v2_translate_conn_status(unsigned char status, char *msg) {
struct {
unsigned int state;
const char *description;
} const conn_status[] = {
- { STATUS_CONN_FAIL_SDO, "SDO fail" },
- { STATUS_CONN_FAIL_RST, "RST fail" },
- { STATUS_CONN_FAIL_SCK, "SCK fail" },
- { STATUS_TGT_NOT_DETECTED, "Target not detected" },
- { STATUS_TGT_REVERSE_INSERTED, "Target reverse inserted" },
+ {STATUS_CONN_FAIL_SDO, "SDO fail"},
+ {STATUS_CONN_FAIL_RST, "RST fail"},
+ {STATUS_CONN_FAIL_SCK, "SCK fail"},
+ {STATUS_TGT_NOT_DETECTED, "Target not detected"},
+ {STATUS_TGT_REVERSE_INSERTED, "Target reverse inserted"},
};
*msg = 0;
- for(size_t i = 0; i < sizeof conn_status / sizeof *conn_status; i++) {
+ for(size_t i = 0; i < sizeof conn_status/sizeof *conn_status; i++) {
if(status & conn_status[i].state) {
if(*msg)
strcat(msg, ", ");
@@ -1046,26 +1018,22 @@ static void stk500v2_translate_conn_status(unsigned char status, char *msg) {
sprintf(msg, "Unknown status 0x%02x", status);
}
-
-/*
- * issue the 'program enable' command to the AVR device
- */
+// Issue the 'program enable' command to the AVR device
static int stk500v2_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char buf[16];
- char msg[100]; /* see remarks above about size needed */
+ char msg[100]; // See remarks above about size needed
int rv, tries;
PDATA(pgm)->lastpart = p;
- if (p->op[AVR_OP_PGM_ENABLE] == NULL) {
+ if(p->op[AVR_OP_PGM_ENABLE] == NULL) {
pmsg_error("program enable instruction not defined for part %s\n", p->desc);
return -1;
}
- if (PDATA(pgm)->pgmtype == PGMTYPE_STK500 ||
- PDATA(pgm)->pgmtype == PGMTYPE_STK600)
- /* Activate AVR-style (low active) RESET */
- stk500v2_setparm_real(pgm, PARAM_RESET_POLARITY, 0x01);
+ if(PDATA(pgm)->pgmtype == PGMTYPE_STK500 || PDATA(pgm)->pgmtype == PGMTYPE_STK600)
+ // Activate AVR-style (low active) RESET
+ stk500v2_setparm_real(pgm, PARAM_RESET_POLARITY, 0x01);
tries = 0;
retry:
@@ -1077,79 +1045,77 @@ retry:
buf[5] = p->bytedelay;
buf[6] = p->pollvalue;
buf[7] = p->pollindex;
- memset(buf+8, 0, 4);
- avr_set_bits(p->op[AVR_OP_PGM_ENABLE], buf+8);
+ memset(buf + 8, 0, 4);
+ avr_set_bits(p->op[AVR_OP_PGM_ENABLE], buf + 8);
rv = stk500v2_command(pgm, buf, 12, sizeof(buf));
- if (rv < 0) {
- switch (PDATA(pgm)->pgmtype)
- {
+ if(rv < 0) {
+ switch (PDATA(pgm)->pgmtype) {
case PGMTYPE_STK600:
case PGMTYPE_AVRISP_MKII:
- if (stk500v2_getparm(pgm, PARAM_STATUS_TGT_CONN, &buf[0]) != 0) {
- pmsg_error("cannot get connection status\n");
- } else {
- stk500v2_translate_conn_status(buf[0], msg);
- pmsg_error("bad AVRISPmkII connection status: %s\n", msg);
- }
- break;
+ if(stk500v2_getparm(pgm, PARAM_STATUS_TGT_CONN, &buf[0]) != 0) {
+ pmsg_error("cannot get connection status\n");
+ } else {
+ stk500v2_translate_conn_status(buf[0], msg);
+ pmsg_error("bad AVRISPmkII connection status: %s\n", msg);
+ }
+ break;
case PGMTYPE_JTAGICE3:
- if (buf[1] == STATUS_CMD_FAILED && (p->prog_modes & PM_debugWIRE)) {
- unsigned char cmd[4], *resp;
+ if(buf[1] == STATUS_CMD_FAILED && (p->prog_modes & PM_debugWIRE)) {
+ unsigned char cmd[4], *resp;
- /* Try debugWIRE, and MONCON_DISABLE */
- pmsg_notice2("no response in ISP mode, trying debugWIRE\n");
+ // Try debugWIRE, and MONCON_DISABLE
+ pmsg_notice2("no response in ISP mode, trying debugWIRE\n");
- PROGRAMMER *pgmcp = pgm_dup(pgm);
- pgmcp->cookie = PDATA(pgm)->chained_pdata;
+ PROGRAMMER *pgmcp = pgm_dup(pgm);
- cmd[0] = PARM3_CONN_DW;
- if (jtag3_setparm(pgmcp, SCOPE_AVR, 1, PARM3_CONNECTION, cmd, 1) < 0) {
- pgm_free(pgmcp);
- break;
- }
+ pgmcp->cookie = PDATA(pgm)->chained_pdata;
- cmd[0] = SCOPE_AVR;
-
- cmd[1] = CMD3_SIGN_ON;
- cmd[2] = cmd[3] = 0;
- if (jtag3_command(pgmcp, cmd, 4, &resp, "AVR sign-on") >= 0) {
- mmt_free(resp);
-
- cmd[1] = CMD3_START_DW_DEBUG;
- if (jtag3_command(pgmcp, cmd, 4, &resp, "start DW debug") >= 0) {
- mmt_free(resp);
-
- cmd[1] = CMD3_MONCON_DISABLE;
- if (jtag3_command(pgmcp, cmd, 3, &resp, "MonCon disable") >= 0)
- mmt_free(resp);
- }
- }
- pgm_free(pgmcp);
- if (tries++ > 3) {
- pmsg_error("unable to return from debugWIRE to ISP\n");
- break;
- }
- pmsg_warning("target prepared for ISP, signed off; now\n");
- imsg_warning("retrying without power-cycling the target\n");
- goto retry;
+ cmd[0] = PARM3_CONN_DW;
+ if(jtag3_setparm(pgmcp, SCOPE_AVR, 1, PARM3_CONNECTION, cmd, 1) < 0) {
+ pgm_free(pgmcp);
+ break;
}
- break;
+
+ cmd[0] = SCOPE_AVR;
+
+ cmd[1] = CMD3_SIGN_ON;
+ cmd[2] = cmd[3] = 0;
+ if(jtag3_command(pgmcp, cmd, 4, &resp, "AVR sign-on") >= 0) {
+ mmt_free(resp);
+
+ cmd[1] = CMD3_START_DW_DEBUG;
+ if(jtag3_command(pgmcp, cmd, 4, &resp, "start DW debug") >= 0) {
+ mmt_free(resp);
+
+ cmd[1] = CMD3_MONCON_DISABLE;
+ if(jtag3_command(pgmcp, cmd, 3, &resp, "MonCon disable") >= 0)
+ mmt_free(resp);
+ }
+ }
+ pgm_free(pgmcp);
+ if(tries++ > 3) {
+ pmsg_error("unable to return from debugWIRE to ISP\n");
+ break;
+ }
+ pmsg_warning("target prepared for ISP, signed off; now\n");
+ imsg_warning("retrying without power-cycling the target\n");
+ goto retry;
+ }
+ break;
default:
- /* cannot report anything for other pgmtypes */
- break;
+ // Cannot report anything for other pgmtypes
+ break;
}
}
return rv;
}
-/*
- * issue the 'program enable' command to the AVR device, parallel mode
- */
+// Issue the 'program enable' command to the AVR device, parallel mode
static int stk500pp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char buf[16];
@@ -1167,17 +1133,13 @@ static int stk500pp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500v2_command(pgm, buf, 8, sizeof(buf));
}
-/*
- * issue the 'program enable' command to the AVR device, HVSP mode
- */
+// Issue the 'program enable' command to the AVR device, HVSP mode
static int stk500hvsp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char buf[16];
PDATA(pgm)->lastpart = p;
- buf[0] = PDATA(pgm)->pgmtype == PGMTYPE_STK600?
- CMD_ENTER_PROGMODE_HVSP_STK600:
- CMD_ENTER_PROGMODE_HVSP;
+ buf[0] = PDATA(pgm)->pgmtype == PGMTYPE_STK600? CMD_ENTER_PROGMODE_HVSP_STK600: CMD_ENTER_PROGMODE_HVSP;
buf[1] = p->hventerstabdelay;
buf[2] = p->hvspcmdexedelay;
buf[3] = p->synchcycles;
@@ -1190,27 +1152,21 @@ static int stk500hvsp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500v2_command(pgm, buf, 9, sizeof(buf));
}
-
-/*
- * initialize the AVR device and prepare it to accept commands
- */
+// Initialize the AVR device and prepare it to accept commands
static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
LNODEID ln;
- AVRMEM * m;
+ AVRMEM *m;
- if ((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
- PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
- PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0
- && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
- /*
- * This is an ATxmega device, must use XPROG protocol for the
- * remaining actions.
- */
- if (p->prog_modes & PM_PDI) {
+ if((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
+ PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
+ PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
+ // This is an ATxmega device, must use XPROG protocol for the remaining actions
+ if(p->prog_modes & PM_PDI) {
// Find the border between application and boot area
AVRMEM *bootmem = avr_locate_boot(p);
AVRMEM *flashmem = avr_locate_flash(p);
- if (bootmem == NULL || flashmem == NULL) {
+
+ if(bootmem == NULL || flashmem == NULL) {
pmsg_error("cannot locate flash or boot memories\n");
} else {
PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
@@ -1222,48 +1178,52 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
// Read or write target voltage
- if (PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+ if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
// Read current target voltage set value
unsigned char vtarg_read = 0;
- if (stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
+
+ if(stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
return -1;
- if (PDATA(pgm)->vtarg_get)
- msg_info("Target voltage value read as %.2f V\n", (vtarg_read / 10.0));
+ if(PDATA(pgm)->vtarg_get)
+ msg_info("Target voltage value read as %.2f V\n", (vtarg_read/10.0));
// Write target voltage value
else {
- msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read / 10.0), PDATA(pgm)->vtarg_data);
+ msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), PDATA(pgm)->vtarg_data);
if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
return -1;
}
}
// Read or write analog reference voltage
- if (PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
+ if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
// STK500: Read current analog reference voltage
unsigned char varef_read = 0;
- if (stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0 )
+
+ if(stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0)
return -1;
- if (PDATA(pgm)->varef_get)
- msg_info("Analog reference voltage value read as %.2f V\n", (varef_read / 10.0));
+ if(PDATA(pgm)->varef_get)
+ msg_info("Analog reference voltage value read as %.2f V\n", (varef_read/10.0));
// STK500: Write analog reference voltage
else {
msg_info("Changing analog reference voltage from %.2f V to %.2f V\n",
- (varef_read / 10.0), PDATA(pgm)->varef_data);
+ varef_read/10.0, PDATA(pgm)->varef_data);
if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
return -1;
}
} else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
// STK600: Read current target voltage set value
unsigned int varef_read = 0;
- if (stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0 ? PARAM2_AREF0 : PARAM2_AREF1, &varef_read) < 0)
+
+ if(stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
return -1;
- if (PDATA(pgm)->varef_get)
- msg_info("Analog reference channel %d voltage read as %.2f V\n", PDATA(pgm)->varef_channel, (varef_read / 100.0));
+ if(PDATA(pgm)->varef_get)
+ msg_info("Analog reference channel %d voltage read as %.2f V\n",
+ PDATA(pgm)->varef_channel, (varef_read/100.0));
// STK600: Write target voltage value for channel n
else {
msg_info("Changing analog reference channel %d voltage from %.2f V to %.2f V\n",
- PDATA(pgm)->varef_channel, (varef_read / 100.0), PDATA(pgm)->varef_data);
+ PDATA(pgm)->varef_channel, (varef_read/100.0), PDATA(pgm)->varef_data);
if(pgm->set_varef(pgm, PDATA(pgm)->varef_channel, PDATA(pgm)->varef_data) < 0)
return -1;
}
@@ -1271,18 +1231,20 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
// Read or write clock generator frequency
- if (PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
+ if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
if(PDATA(pgm)->pgmtype == PGMTYPE_STK500 || PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
- const char *unit_get = {"Hz"};
+ const char *unit_get = { "Hz" };
double f_get = stk500v2_fosc_value(pgm);
- if (f_get)
+
+ if(f_get)
f_get = f_to_kHz_MHz(f_get, &unit_get);
- if (PDATA(pgm)->fosc_get)
- msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
+ if(PDATA(pgm)->fosc_get)
+ msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
// Write new osc freq
else {
const char *unit_set;
double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+
msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
return -1;
@@ -1291,24 +1253,24 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
/*
- * Examine the avrpart's memory definitions, and initialize the page
- * caches. For devices/memory that are not page oriented, treat
- * them as page size 1 for EEPROM, and 2 for flash.
+ * Examine the avrpart's memory definitions, and initialize the page caches.
+ * For devices/memory that are not page oriented, treat them as page size 1
+ * for EEPROM, and 2 for flash.
*/
PDATA(pgm)->flash_pagesize = 2;
PDATA(pgm)->eeprom_pagesize = 1;
- for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
+ for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
m = ldata(ln);
- if (mem_is_flash(m)) {
- if (m->page_size > 1) {
- if (m->page_size > 256)
+ if(mem_is_flash(m)) {
+ if(m->page_size > 1) {
+ if(m->page_size > 256)
PDATA(pgm)->flash_pagesize = 256;
else
PDATA(pgm)->flash_pagesize = m->page_size;
}
- } else if (mem_is_eeprom(m)) {
- if (m->page_size > 1)
- PDATA(pgm)->eeprom_pagesize = m->page_size;
+ } else if(mem_is_eeprom(m)) {
+ if(m->page_size > 1)
+ PDATA(pgm)->eeprom_pagesize = m->page_size;
}
}
mmt_free(PDATA(pgm)->flash_pagecache);
@@ -1317,10 +1279,8 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
- if (p->flags & AVRPART_IS_AT90S1200) {
- /*
- * AT90S1200 needs a positive reset pulse after a chip erase.
- */
+ if(p->flags & AVRPART_IS_AT90S1200) {
+ // AT90S1200 needs a positive reset pulse after a chip erase
pgm->disable(pgm);
usleep(10000);
}
@@ -1328,41 +1288,39 @@ static int stk500v2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return pgm->program_enable(pgm, p);
}
-
-/*
- * initialize the AVR device and prepare it to accept commands
- */
+// Initialize the AVR device and prepare it to accept commands
static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char parm[4], *resp;
LNODEID ln;
- AVRMEM * m;
+ AVRMEM *m;
- // FIXME: condition below looks fishy, suspect the code wants !(p->prog_modes & (PM_debugWIRE | PM_JTAG | PM_JTAGmkI /* | PM_XMEGAJTAG | PM_AVR32JTAG */))
- if (p->prog_modes & (PM_PDI | PM_TPI)) {
+ // FIXME: how does condition below make sense?
+ if(p->prog_modes & (PM_PDI | PM_TPI)) {
pmsg_error("part %s has no ISP interface\n", p->desc);
return -1;
}
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
- if (p->prog_modes & PM_debugWIRE)
+ if(p->prog_modes & PM_debugWIRE)
parm[0] = PARM3_ARCH_TINY;
else
parm[0] = PARM3_ARCH_MEGA;
- if (jtag3_setparm(pgmcp, SCOPE_AVR, 0, PARM3_ARCH, parm, 1) < 0) {
+ if(jtag3_setparm(pgmcp, SCOPE_AVR, 0, PARM3_ARCH, parm, 1) < 0) {
pgm_free(pgmcp);
return -1;
}
parm[0] = PARM3_SESS_PROGRAMMING;
- if (jtag3_setparm(pgmcp, SCOPE_AVR, 0, PARM3_SESS_PURPOSE, parm, 1) < 0) {
+ if(jtag3_setparm(pgmcp, SCOPE_AVR, 0, PARM3_SESS_PURPOSE, parm, 1) < 0) {
pgm_free(pgmcp);
return -1;
}
parm[0] = PARM3_CONN_ISP;
- if (jtag3_setparm(pgmcp, SCOPE_AVR, 1, PARM3_CONNECTION, parm, 1) < 0) {
+ if(jtag3_setparm(pgmcp, SCOPE_AVR, 1, PARM3_CONNECTION, parm, 1) < 0) {
pgm_free(pgmcp);
return -1;
}
@@ -1371,38 +1329,52 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
parm[1] = 0x1e;
jtag3_send(pgmcp, parm, 2);
- if (jtag3_recv(pgmcp, &resp) > 0)
+ if(jtag3_recv(pgmcp, &resp) > 0)
mmt_free(resp);
// Read or write SUFFER register
- if (PDATA(pgm)->suffer_get || PDATA(pgm)->suffer_set) {
+ if(PDATA(pgm)->suffer_get || PDATA(pgm)->suffer_set) {
// Read existing SUFFER value
- if (jtag3_getparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10, MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data, 1) < 0)
+ if(jtag3_getparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
+ MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data, 1) < 0) {
+
return -1;
- if (!PDATA(pgm)->suffer_set)
+ }
+ if(!PDATA(pgm)->suffer_set)
imsg_info("SUFFER register value read as 0x%02x\n", PDATA(pgm)->suffer_data[0]);
// Write new SUFFER value
else {
- if (jtag3_setparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10, MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data+1, 1) < 0)
+ if(jtag3_setparm(pgmcp, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
+ MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data + 1, 1) < 0) {
+
return -1;
- imsg_info("SUFFER register value changed from 0x%02x to 0x%02x\n", PDATA(pgm)->suffer_data[0], PDATA(pgm)->suffer_data[1]);
+ }
+ imsg_info("SUFFER register value changed from 0x%02x to 0x%02x\n",
+ PDATA(pgm)->suffer_data[0], PDATA(pgm)->suffer_data[1]);
}
}
// Read or write Vtarg switch
- if (PDATA(pgm)->vtarg_switch_get || PDATA(pgm)->vtarg_switch_set) {
+ if(PDATA(pgm)->vtarg_switch_get || PDATA(pgm)->vtarg_switch_set) {
// Read existing Vtarg switch value
- if (jtag3_getparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL, EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data, 1) < 0)
+ if(jtag3_getparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL,
+ EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data, 1) < 0) {
+
return -1;
- if (!PDATA(pgm)->vtarg_switch_set)
- pmsg_info("Vtarg switch setting read as %u: target power is switched %s\n", PDATA(pgm)->vtarg_switch_data[0], PDATA(pgm)->vtarg_switch_data[0] ? "on" : "off");
- // Write Vtarg switch value
- else {
- if (jtag3_setparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL, EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data+1, 1) < 0)
+ }
+ if(!PDATA(pgm)->vtarg_switch_set) {
+ pmsg_info("Vtarg switch setting read as %u: target power is switched %s\n",
+ PDATA(pgm)->vtarg_switch_data[0], PDATA(pgm)->vtarg_switch_data[0]? "on": "off");
+ } else { // Write Vtarg switch value
+ if(jtag3_setparm(pgmcp, SCOPE_EDBG, EDBG_CTXT_CONTROL,
+ EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data + 1, 1) < 0) {
+
return -1;
- pmsg_info("Vtarg switch setting changed from %u to %u\n", PDATA(pgm)->vtarg_switch_data[0], PDATA(pgm)->vtarg_switch_data[1]);
- // Exit early is the target power switch is off and print sensible info message
- if (PDATA(pgm)->vtarg_switch_data[1] == 0) {
+ }
+ pmsg_info("Vtarg switch setting changed from %u to %u\n", PDATA(pgm)->vtarg_switch_data[0],
+ PDATA(pgm)->vtarg_switch_data[1]);
+ // Exit early if the target power switch is off and print sensible info message
+ if(PDATA(pgm)->vtarg_switch_data[1] == 0) {
pmsg_info("turn on the Vtarg switch to establish connection with the target\n\n");
return -1;
}
@@ -1410,19 +1382,21 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
// Read or write target voltage
- if (PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+ if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
// Read current target voltage set value
unsigned char buf[2];
- if (jtag3_getparm(pgmcp, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, 2) < 0)
+
+ if(jtag3_getparm(pgmcp, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, 2) < 0)
return -1;
- double vtarg_read = b2_to_u16(buf) / 1000.0;
- if (PDATA(pgm)->vtarg_get)
+ double vtarg_read = b2_to_u16(buf)/1000.0;
+
+ if(PDATA(pgm)->vtarg_get)
msg_info("Target voltage value read as %.2f V\n", vtarg_read);
// Write target voltage value
else {
- u16_to_b2(buf, (unsigned)(PDATA(pgm)->vtarg_data * 1000));
+ u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
msg_info("Changing target voltage from %.2f V to %.2f V\n", vtarg_read, PDATA(pgm)->vtarg_data);
- if (jtag3_setparm(pgmcp, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
+ if(jtag3_setparm(pgmcp, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
msg_warning("Cannot set target voltage %.2f V\n", PDATA(pgm)->vtarg_data);
return -1;
}
@@ -1432,24 +1406,24 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
mmt_free(pgmcp);
/*
- * Examine the avrpart's memory definitions, and initialize the page
- * caches. For devices/memory that are not page oriented, treat
- * them as page size 1 for EEPROM, and 2 for flash.
+ * Examine the avrpart's memory definitions, and initialize the page caches.
+ * For devices/memory that are not page oriented, treat them as page size 1
+ * for EEPROM, and 2 for flash.
*/
PDATA(pgm)->flash_pagesize = 2;
PDATA(pgm)->eeprom_pagesize = 1;
- for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
+ for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
m = ldata(ln);
- if (mem_is_flash(m)) {
- if (m->page_size > 1) {
- if (m->page_size > 256)
+ if(mem_is_flash(m)) {
+ if(m->page_size > 1) {
+ if(m->page_size > 256)
PDATA(pgm)->flash_pagesize = 256;
else
PDATA(pgm)->flash_pagesize = m->page_size;
}
- } else if (mem_is_eeprom(m)) {
- if (m->page_size > 1)
- PDATA(pgm)->eeprom_pagesize = m->page_size;
+ } else if(mem_is_eeprom(m)) {
+ if(m->page_size > 1)
+ PDATA(pgm)->eeprom_pagesize = m->page_size;
}
}
mmt_free(PDATA(pgm)->flash_pagecache);
@@ -1461,17 +1435,14 @@ static int stk500v2_jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return pgm->program_enable(pgm, p);
}
-
-/*
- * initialize the AVR device and prepare it to accept commands, generic HV mode
- */
+// Initialize the AVR device and prepare it to accept commands, generic HV mode
static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvmode mode) {
unsigned char buf[CTL_STACK_SIZE + 1];
int result;
LNODEID ln;
- AVRMEM * m;
+ AVRMEM *m;
- if (p->ctl_stack_type != (mode == PPMODE? CTL_STACK_PP: CTL_STACK_HVSP)) {
+ if(p->ctl_stack_type != (mode == PPMODE? CTL_STACK_PP: CTL_STACK_HVSP)) {
pmsg_error("%s programming control stack not defined for part %s\n",
mode == PPMODE? "parallel": "high-voltage serial", p->desc);
return -1;
@@ -1482,54 +1453,56 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
result = stk500v2_command(pgm, buf, CTL_STACK_SIZE + 1, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("unable to set control stack\n");
return -1;
}
// Read or write target voltage
- if (PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
+ if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
// Read current target voltage set value
unsigned char vtarg_read = 0;
- if (stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
+
+ if(stk500v2_getparm(pgm, PARAM_VTARGET, &vtarg_read) < 0)
return -1;
- if (PDATA(pgm)->vtarg_get)
- msg_info("Target voltage value read as %.2f V\n", (vtarg_read / 10.0));
+ if(PDATA(pgm)->vtarg_get)
+ msg_info("Target voltage value read as %.2f V\n", (vtarg_read/10.0));
// Write target voltage value
else {
- msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read / 10.0), PDATA(pgm)->vtarg_data);
+ msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), PDATA(pgm)->vtarg_data);
if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
return -1;
}
}
// Read or write analog reference voltage
- if (PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
+ if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
// STK500: Read current analog reference voltage
unsigned char varef_read = 0;
- if (stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0)
+
+ if(stk500v2_getparm(pgm, PARAM_VADJUST, &varef_read) < 0)
return -1;
- if (PDATA(pgm)->varef_get)
- msg_info("Analog reference voltage value read as %.2f V\n", (varef_read / 10.0));
- // STK500: Write analog reference voltage
- else {
+ if(PDATA(pgm)->varef_get) {
+ msg_info("Analog reference voltage value read as %.2f V\n", varef_read/10.0);
+ } else { // STK500: Write analog reference voltage
msg_info("Changing analog reference voltage from %.2f V to %.2f V\n",
- (varef_read / 10.0), PDATA(pgm)->varef_data);
+ varef_read/10.0, PDATA(pgm)->varef_data);
if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
return -1;
}
} else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
// STK600: Read current target voltage set value
unsigned int varef_read = 0;
- if (stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0 ? PARAM2_AREF0 : PARAM2_AREF1, &varef_read) < 0)
+
+ if(stk500v2_getparm2(pgm, PDATA(pgm)->varef_channel == 0? PARAM2_AREF0: PARAM2_AREF1, &varef_read) < 0)
return -1;
- if (PDATA(pgm)->varef_get)
- msg_info("Analog reference channel %d voltage read as %.2f V\n", PDATA(pgm)->varef_channel, (varef_read / 100.0));
- // STK600: Write target voltage value for channel n
- else {
+ if(PDATA(pgm)->varef_get) {
+ msg_info("Analog reference channel %d voltage read as %.2f V\n",
+ PDATA(pgm)->varef_channel, (varef_read/100.0));
+ } else { // STK600: Write target voltage value for channel n
msg_info("Changing analog reference channel %d voltage from %.2f V to %.2f V\n",
- PDATA(pgm)->varef_channel, (varef_read / 100.0), PDATA(pgm)->varef_data);
+ PDATA(pgm)->varef_channel, (varef_read/100.0), PDATA(pgm)->varef_data);
if(pgm->set_varef(pgm, PDATA(pgm)->varef_channel, PDATA(pgm)->varef_data) < 0)
return -1;
}
@@ -1537,37 +1510,54 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
}
// Read or write clock generator frequency
- if (PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
+ if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
// Read current target voltage set value
unsigned char osc_pscale = 0;
unsigned char osc_cmatch = 0;
- const char *unit_get = {"Hz"};
+ const char *unit_get = { "Hz" };
double f_get = 0.0;
- if (stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale) < 0
- || stk500v2_getparm(pgm, PARAM_OSC_CMATCH, &osc_cmatch) < 0)
+
+ if(stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale) < 0 ||
+ stk500v2_getparm(pgm, PARAM_OSC_CMATCH, &osc_cmatch) < 0) {
+
return -1;
+ }
if(osc_pscale) {
int prescale = 1;
- f_get = PDATA(pgm)->xtal / 2;
+
+ f_get = PDATA(pgm)->xtal/2;
switch (osc_pscale) {
- case 2: prescale = 8; break;
- case 3: prescale = 32; break;
- case 4: prescale = 64; break;
- case 5: prescale = 128; break;
- case 6: prescale = 256; break;
- case 7: prescale = 1024; break;
+ case 2:
+ prescale = 8;
+ break;
+ case 3:
+ prescale = 32;
+ break;
+ case 4:
+ prescale = 64;
+ break;
+ case 5:
+ prescale = 128;
+ break;
+ case 6:
+ prescale = 256;
+ break;
+ case 7:
+ prescale = 1024;
+ break;
}
f_get /= prescale;
f_get /= (osc_cmatch + 1);
f_get = f_to_kHz_MHz(f_get, &unit_get);
}
- if (PDATA(pgm)->fosc_get)
- msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
+ if(PDATA(pgm)->fosc_get)
+ msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
// Write target voltage value
else {
const char *unit_set;
double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+
msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
return -1;
@@ -1575,19 +1565,21 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
} else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
// Read current target voltage set value
unsigned int clock_conf = 0;
- if (stk500v2_getparm2(pgm, PARAM2_CLOCK_CONF, &clock_conf) < 0)
+
+ if(stk500v2_getparm2(pgm, PARAM2_CLOCK_CONF, &clock_conf) < 0)
return -1;
unsigned int oct = (clock_conf & 0xf000) >> 12u;
unsigned int dac = (clock_conf & 0x0ffc) >> 2u;
- double f_get = pow(2, (double)oct) * 2078.0 / (2 - (double)dac / 1024.0);
- const char *unit_get = {"Hz"};
+ double f_get = pow(2, (double) oct)*2078.0/(2 - (double) dac/1024.0);
+ const char *unit_get = { "Hz" };
f_get = f_to_kHz_MHz(f_get, &unit_get);
- if (PDATA(pgm)->fosc_get)
- msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
+ if(PDATA(pgm)->fosc_get)
+ msg_info("Oscillator currently set to %.3f %s\n", f_get, unit_get);
// Write target voltage value
else {
const char *unit_set;
double f_set = f_to_kHz_MHz(PDATA(pgm)->fosc_data, &unit_set);
+
msg_info("Changing oscillator frequency from %.3f %s to %.3f %s\n", f_get, unit_get, f_set, unit_set);
if(pgm->set_fosc(pgm, PDATA(pgm)->fosc_data) < 0)
return -1;
@@ -1596,24 +1588,24 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
}
/*
- * Examine the avrpart's memory definitions, and initialize the page
- * caches. For devices/memory that are not page oriented, treat
- * them as page size 1 for EEPROM, and 2 for flash.
+ * Examine the avrpart's memory definitions, and initialize the page caches.
+ * For devices/memory that are not page oriented, treat them as page size 1
+ * for EEPROM, and 2 for flash.
*/
PDATA(pgm)->flash_pagesize = 2;
PDATA(pgm)->eeprom_pagesize = 1;
- for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
+ for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
m = ldata(ln);
- if (mem_is_flash(m)) {
- if (m->page_size > 1) {
- if (m->page_size > 256)
+ if(mem_is_flash(m)) {
+ if(m->page_size > 1) {
+ if(m->page_size > 256)
PDATA(pgm)->flash_pagesize = 256;
else
PDATA(pgm)->flash_pagesize = m->page_size;
}
- } else if (mem_is_eeprom(m)) {
- if (m->page_size > 1)
- PDATA(pgm)->eeprom_pagesize = m->page_size;
+ } else if(mem_is_eeprom(m)) {
+ if(m->page_size > 1)
+ PDATA(pgm)->eeprom_pagesize = m->page_size;
}
}
mmt_free(PDATA(pgm)->flash_pagecache);
@@ -1625,16 +1617,12 @@ static int stk500hv_initialize(const PROGRAMMER *pgm, const AVRPART *p, enum hvm
return pgm->program_enable(pgm, p);
}
-/*
- * initialize the AVR device and prepare it to accept commands, PP mode
- */
+// Initialize the AVR device and prepare it to accept commands, PP mode
static int stk500pp_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500hv_initialize(pgm, p, PPMODE);
}
-/*
- * initialize the AVR device and prepare it to accept commands, HVSP mode
- */
+// Initialize the AVR device and prepare it to accept commands, HVSP mode
static int stk500hvsp_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return stk500hv_initialize(pgm, p, HVSPMODE);
}
@@ -1649,12 +1637,12 @@ static void stk500v2_jtag3_disable(const PROGRAMMER *pgm) {
PDATA(pgm)->eeprom_pagecache = NULL;
buf[0] = CMD_LEAVE_PROGMODE_ISP;
- buf[1] = 1; // preDelay;
- buf[2] = 1; // postDelay;
+ buf[1] = 1; // preDelay;
+ buf[2] = 1; // postDelay;
result = stk500v2_command(pgm, buf, 3, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("unable to leave programming mode\n");
}
@@ -1666,21 +1654,19 @@ static void stk500v2_disable(const PROGRAMMER *pgm) {
int result;
buf[0] = CMD_LEAVE_PROGMODE_ISP;
- buf[1] = 1; // preDelay;
- buf[2] = 1; // postDelay;
+ buf[1] = 1; // preDelay;
+ buf[2] = 1; // postDelay;
result = stk500v2_command(pgm, buf, 3, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("unable to leave programming mode\n");
}
return;
}
-/*
- * Leave programming mode, generic HV mode
- */
+// Leave programming mode, generic HV mode
static void stk500hv_disable(const PROGRAMMER *pgm, enum hvmode mode) {
unsigned char buf[16];
int result;
@@ -1691,31 +1677,25 @@ static void stk500hv_disable(const PROGRAMMER *pgm, enum hvmode mode) {
PDATA(pgm)->eeprom_pagecache = NULL;
buf[0] = mode == PPMODE? CMD_LEAVE_PROGMODE_PP:
- (PDATA(pgm)->pgmtype == PGMTYPE_STK600?
- CMD_LEAVE_PROGMODE_HVSP_STK600:
- CMD_LEAVE_PROGMODE_HVSP);
- buf[1] = 15; // p->hvleavestabdelay;
- buf[2] = 15; // p->resetdelay;
+ (PDATA(pgm)->pgmtype == PGMTYPE_STK600? CMD_LEAVE_PROGMODE_HVSP_STK600: CMD_LEAVE_PROGMODE_HVSP);
+ buf[1] = 15; // p->hvleavestabdelay;
+ buf[2] = 15; // p->resetdelay;
result = stk500v2_command(pgm, buf, 3, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("unable to leave programming mode\n");
}
return;
}
-/*
- * Leave programming mode, PP mode
- */
+// Leave programming mode, PP mode
static void stk500pp_disable(const PROGRAMMER *pgm) {
stk500hv_disable(pgm, PPMODE);
}
-/*
- * Leave programming mode, HVSP mode
- */
+// Leave programming mode, HVSP mode
static void stk500hvsp_disable(const PROGRAMMER *pgm) {
stk500hv_disable(pgm, HVSPMODE);
}
@@ -1724,17 +1704,17 @@ static void stk500v2_enable(PROGRAMMER *pgm, const AVRPART *p) {
// Previously stk500v2_initialize() set up pgm
if(pgm->initialize == stk500v2_initialize) {
if((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
- PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
- PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0
- && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
+ PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
+ PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0 && (p->prog_modes & (PM_PDI | PM_TPI)) != 0) {
stk600_setup_xprog(pgm);
} else {
stk600_setup_isp(pgm);
}
}
AVRMEM *mem = avr_locate_flash(p);
- if(mem && mem->op[AVR_OP_WRITE_LO]) // Old part that can only write flash bytewise
- if(mem->page_size < 2) // Override page size, as STK500v2/EDBG uses flash word addresses
+
+ if(mem && mem->op[AVR_OP_WRITE_LO]) // Old part that can only write flash bytewise
+ if(mem->page_size < 2) // Override page size, as STK500v2/EDBG uses flash word addresses
mem->page_size = 2;
return;
@@ -1744,17 +1724,18 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
int rv = 0;
bool help = false;
- for (LNODEID ln = lfirst(extparms); ln; ln = lnext(ln)) {
+ for(LNODEID ln = lfirst(extparms); ln; ln = lnext(ln)) {
const char *extended_param = ldata(ln);
- if (str_starts(extended_param, "vtarg")) {
- if (pgm->extra_features & HAS_VTARG_ADJ) {
+ if(str_starts(extended_param, "vtarg")) {
+ if(pgm->extra_features & HAS_VTARG_ADJ) {
// Set target voltage
- if (str_starts(extended_param, "vtarg=") ) {
- double vtarg_set_val = -1; // default = invalid value
+ if(str_starts(extended_param, "vtarg=")) {
+ double vtarg_set_val = -1; // Default = invalid value
int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
- PDATA(pgm)->vtarg_data = (double)((int)(vtarg_set_val * 100 + .5)) / 100;
- if (sscanf_success < 1 || vtarg_set_val < 0) {
+
+ PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
+ if(sscanf_success < 1 || vtarg_set_val < 0) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
break;
@@ -1770,12 +1751,13 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
}
}
- if (str_starts(extended_param, "varef")) {
- if (pgm->extra_features & HAS_VAREF_ADJ) {
+ if(str_starts(extended_param, "varef")) {
+ if(pgm->extra_features & HAS_VAREF_ADJ) {
int sscanf_success = 0;
double varef_set_val = -1;
+
// Get new analog reference voltage for channel 0
- if (str_starts(extended_param, "varef=")) {
+ if(str_starts(extended_param, "varef=")) {
sscanf_success = sscanf(extended_param, "varef=%lf", &varef_set_val);
PDATA(pgm)->varef_channel = 0;
PDATA(pgm)->varef_set = true;
@@ -1787,7 +1769,7 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
PDATA(pgm)->varef_set = true;
}
// Get new analog reference voltage for channel 1
- else if (str_starts(extended_param, "varef1=") && str_contains(pgm->type, "STK600")) {
+ else if(str_starts(extended_param, "varef1=") && str_contains(pgm->type, "STK600")) {
sscanf_success = sscanf(extended_param, "varef1=%lf", &varef_set_val);
PDATA(pgm)->varef_channel = 1;
PDATA(pgm)->varef_set = true;
@@ -1805,9 +1787,9 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
continue;
}
// Set analog reference voltage
- if (PDATA(pgm)->varef_set) {
- PDATA(pgm)->varef_data = (double)((int)(varef_set_val * 100 + .5)) / 100;
- if (sscanf_success < 1 || varef_set_val < 0) {
+ if(PDATA(pgm)->varef_set) {
+ PDATA(pgm)->varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
+ if(sscanf_success < 1 || varef_set_val < 0) {
pmsg_error("invalid value in -x %s\n", extended_param);
PDATA(pgm)->varef_set = false;
rv = -1;
@@ -1818,23 +1800,25 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
}
}
- if (str_starts(extended_param, "fosc")) {
- if (pgm->extra_features & HAS_FOSC_ADJ) {
+ if(str_starts(extended_param, "fosc")) {
+ if(pgm->extra_features & HAS_FOSC_ADJ) {
// Set clock generator frequency
- if (str_starts(extended_param, "fosc=")) {
- char fosc_str[16] = {0};
+ if(str_starts(extended_param, "fosc=")) {
+ char fosc_str[16] = { 0 };
int sscanf_success = sscanf(extended_param, "fosc=%15[0-9.eE MmKkHhZzof]", fosc_str);
- if (sscanf_success < 1) {
+
+ if(sscanf_success < 1) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
break;
}
char *endp;
double v = strtod(fosc_str, &endp);
- if (endp == fosc_str){ // no number
- while ( *endp == ' ' ) // remove leading spaces
+
+ if(endp == fosc_str) { // No number
+ while(*endp == ' ') // Remove leading spaces
++endp;
- if (str_starts(endp, "off"))
+ if(str_starts(endp, "off"))
PDATA(pgm)->fosc_data = 0.0;
else {
pmsg_error("invalid fosc value %s\n", endp);
@@ -1842,74 +1826,75 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
break;
}
}
- while ( *endp == ' ' ) // remove leading spaces before unit
+ while(*endp == ' ') // Remove leading spaces before unit
++endp;
- if (*endp == 'm' || *endp == 'M')
- PDATA(pgm)->fosc_data = v * 1e6;
- else if (*endp == 'k' || *endp == 'K')
- PDATA(pgm)->fosc_data = v * 1e3;
- else if (*endp == 0 || *endp == 'h' || *endp == 'H' || *endp == 0)
- PDATA(pgm)->fosc_data = v;
+ if(*endp == 'm' || *endp == 'M')
+ PDATA(pgm)->fosc_data = v*1e6;
+ else if(*endp == 'k' || *endp == 'K')
+ PDATA(pgm)->fosc_data = v*1e3;
+ else if(*endp == 0 || *endp == 'h' || *endp == 'H' || *endp == 0)
+ PDATA(pgm)->fosc_data = v;
PDATA(pgm)->fosc_set = true;
continue;
}
// Get clock generator frequency
else if(str_eq(extended_param, "fosc")) {
PDATA(pgm)->fosc_get = true;
- continue;
+ continue;
}
}
}
- if (str_starts(extended_param, "xtal")) {
+ if(str_starts(extended_param, "xtal")) {
// Set clock generator frequency
- if (str_starts(extended_param, "xtal=")) {
- char xtal_str[16] = {0};
+ if(str_starts(extended_param, "xtal=")) {
+ char xtal_str[16] = { 0 };
int sscanf_success = sscanf(extended_param, "xtal=%15[0-9.eE MmKkHhZz]", xtal_str);
- if (sscanf_success < 1) {
+
+ if(sscanf_success < 1) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
break;
}
char *endp;
double v = strtod(xtal_str, &endp);
- if (endp == xtal_str){
+
+ if(endp == xtal_str) {
pmsg_error("invalid xtal value %s\n", xtal_str);
rv = -1;
break;
}
- while ( *endp == ' ' ) // remove leading spaces before unit
+ while(*endp == ' ') // Remove leading spaces before unit
++endp;
- if (*endp == 'm' || *endp == 'M') // fits also e.g. "nnnnMHz"
- PDATA(pgm)->xtal = v * 1e6;
- else if (*endp == 'k' || *endp == 'K')
- PDATA(pgm)->xtal = v * 1e3;
- else if (*endp == 0 || *endp == 'h' || *endp == 'H') // "nnnn" or "nnnnHz"
- PDATA(pgm)->xtal = (unsigned)v;
+ if(*endp == 'm' || *endp == 'M') // Fits also e.g. "nnnnMHz"
+ PDATA(pgm)->xtal = v*1e6;
+ else if(*endp == 'k' || *endp == 'K')
+ PDATA(pgm)->xtal = v*1e3;
+ else if(*endp == 0 || *endp == 'h' || *endp == 'H') // "nnnn" or "nnnnHz"
+ PDATA(pgm)->xtal = (unsigned) v;
continue;
}
}
- if (str_eq(extended_param, "help")) {
+ if(str_eq(extended_param, "help")) {
help = true;
rv = LIBAVRDUDE_EXIT;
}
- if (!help) {
+ if(!help) {
pmsg_error("invalid extended parameter -x %s\n", extended_param);
rv = -1;
}
msg_error("%s -c %s extended options:\n", progname, pgmid);
- if (pgm->extra_features & HAS_VTARG_ADJ) {
+ if(pgm->extra_features & HAS_VTARG_ADJ) {
msg_error(" -x vtarg Read target supply voltage\n");
msg_error(" -x vtarg= Set target supply voltage to V\n");
}
- if (pgm->extra_features & HAS_VAREF_ADJ) {
- if (str_contains(pgm->type, "STK500")) {
+ if(pgm->extra_features & HAS_VAREF_ADJ) {
+ if(str_contains(pgm->type, "STK500")) {
msg_error(" -x varef Read analog reference voltage\n");
msg_error(" -x varef= Set analog reference voltage to V\n");
- }
- else if (str_contains(pgm->type, "STK600")) {
+ } else if(str_contains(pgm->type, "STK600")) {
msg_error(" -x varef Read channel 0 analog reference voltage\n");
msg_error(" -x varef0 Alias for -x varef\n");
msg_error(" -x varef1 Read channel 1 analog reference voltage\n");
@@ -1918,7 +1903,7 @@ static int stk500v2_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
msg_error(" -x varef1= Set channel 1 analog reference voltage to V\n");
}
}
- if (pgm->extra_features & HAS_FOSC_ADJ) {
+ if(pgm->extra_features & HAS_FOSC_ADJ) {
msg_error(" -x fosc Read oscillator clock frequency\n");
msg_error(" -x fosc=[unit] Set oscillator clock frequency to Hz (or kHz/MHz)\n");
msg_error(" -x fosc=off Switch the oscillator clock off\n");
@@ -1947,15 +1932,14 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
if(pgm->extra_features & HAS_SUFFER) {
// Set SUFFER value
if(str_starts(extended_param, "suffer=")) {
- if(sscanf(extended_param, "suffer=%hhi", PDATA(pgm)->suffer_data+1) < 1) {
+ if(sscanf(extended_param, "suffer=%hhi", PDATA(pgm)->suffer_data + 1) < 1) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
break;
}
if((PDATA(pgm)->suffer_data[1] & 0x78) != 0x78) {
PDATA(pgm)->suffer_data[1] |= 0x78;
- pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n",
- PDATA(pgm)->suffer_data[1]);
+ pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", PDATA(pgm)->suffer_data[1]);
}
PDATA(pgm)->suffer_set = true;
continue;
@@ -1975,7 +1959,8 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
if(pgm->extra_features & HAS_VTARG_SWITCH) {
// Set Vtarget switch value
if(str_starts(extended_param, "vtarg_switch=")) {
- int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", PDATA(pgm)->vtarg_switch_data+1);
+ int sscanf_success = sscanf(extended_param, "vtarg_switch=%hhi", PDATA(pgm)->vtarg_switch_data + 1);
+
if(sscanf_success < 1 || PDATA(pgm)->vtarg_switch_data[1] > 1) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
@@ -1998,10 +1983,11 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
if(str_starts(extended_param, "vtarg")) {
if(pgm->extra_features & HAS_VTARG_ADJ) {
// Set target voltage
- if(str_starts(extended_param, "vtarg=") ) {
+ if(str_starts(extended_param, "vtarg=")) {
double vtarg_set_val = 0;
int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
- PDATA(pgm)->vtarg_data = (double)((int)(vtarg_set_val * 100 + .5)) / 100;
+
+ PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
if(sscanf_success < 1 || vtarg_set_val < 0) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
@@ -2021,8 +2007,7 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
}
}
- if(str_starts(extended_param, "mode") &&
- (str_starts(pgmid, "pickit4") || str_starts(pgmid, "snap"))) {
+ if(str_starts(extended_param, "mode") && (str_starts(pgmid, "pickit4") || str_starts(pgmid, "snap"))) {
// Flag a switch to AVR mode
if(str_caseeq(extended_param, "mode=avr")) {
PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_AVR;
@@ -2062,13 +2047,12 @@ static int stk500v2_jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extp
}
if(str_starts(pgmid, "pickit4") || str_starts(pgmid, "snap"))
msg_error(" -x mode=avr|pic Set programmer to AVR or PIC mode, then exit\n");
- msg_error (" -x help Show this help menu and exit\n");
+ msg_error(" -x help Show this help menu and exit\n");
return rv;
}
return rv;
}
-
// ScratchMonkey LED functions (Arduino Micro, Nano and UNO)
enum {
SCRATCHMONKEY_RDY_LED = 1, // D5 (green)
@@ -2108,16 +2092,17 @@ static int scratchmonkey_vfy_led(const PROGRAMMER *pgm, int value) {
}
static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
- union pinfo pinfo = { .serialinfo.baud = 115200, .serialinfo.cflags = SERIAL_8N1 };
+ union pinfo pinfo = {.serialinfo.baud = 115200,.serialinfo.cflags = SERIAL_8N1 };
DEBUG("STK500V2: stk500v2_open()\n");
- if (pgm->baudrate)
+ if(pgm->baudrate)
pinfo.serialinfo.baud = pgm->baudrate;
PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
- if(str_caseeq(port, "avrdoper")){
+ if(str_caseeq(port, "avrdoper")) {
+
#if defined(HAVE_LIBHIDAPI)
serdev = &avrdoper_serdev;
PDATA(pgm)->pgmtype = PGMTYPE_STK500;
@@ -2128,12 +2113,12 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
}
/*
- * If the port name starts with "usb", divert the serial routines
- * to the USB ones. The serial_open() function for USB overrides
- * the meaning of the "baud" parameter to be the USB device ID to
- * search for.
+ * If the port name starts with "usb", divert the serial routines to the USB
+ * ones. The serial_open() function for USB overrides the meaning of the
+ * "baud" parameter to be the USB device ID to search for.
*/
- if (str_starts(port, "usb")) {
+ if(str_starts(port, "usb")) {
+
#if defined(HAVE_LIBUSB)
serdev = &usb_serdev_frame;
pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
@@ -2144,7 +2129,7 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
- pgm->fd.usb.eep = 0; /* no seperate EP for events */
+ pgm->fd.usb.eep = 0; // No seperate EP for events
#else
pmsg_error("avrdude was compiled without usb support\n");
return -1;
@@ -2152,15 +2137,15 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
}
pgm->port = port;
- if (serial_open(port, pinfo, &pgm->fd)==-1) {
+ if(serial_open(port, pinfo, &pgm->fd) == -1) {
return -1;
}
// Make USB serial number and USB product name available to programmer
- if (serdev) {
- if (serdev->usbsn)
+ if(serdev) {
+ if(serdev->usbsn)
pgm->usbsn = serdev->usbsn;
- if (serdev->usbproduct)
+ if(serdev->usbproduct)
pgm->usbproduct = serdev->usbproduct;
}
@@ -2168,8 +2153,8 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
if(stk500v2_drain(pgm, 0) < 0 || stk500v2_getsync(pgm) < 0 || stk500v2_drain(pgm, 0) < 0)
return -1;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
@@ -2183,24 +2168,23 @@ static int stk500v2_open(PROGRAMMER *pgm, const char *port) {
return 0;
}
-
static int stk600_open(PROGRAMMER *pgm, const char *port) {
- union pinfo pinfo = { .serialinfo.baud = 115200, .serialinfo.cflags = SERIAL_8N1 };
+ union pinfo pinfo = {.serialinfo.baud = 115200,.serialinfo.cflags = SERIAL_8N1 };
DEBUG("STK500V2: stk600_open()\n");
- if (pgm->baudrate)
+ if(pgm->baudrate)
pinfo.serialinfo.baud = pgm->baudrate;
PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
/*
- * If the port name starts with "usb", divert the serial routines
- * to the USB ones. The serial_open() function for USB overrides
- * the meaning of the "baud" parameter to be the USB device ID to
- * search for.
+ * If the port name starts with "usb", divert the serial routines to the USB
+ * ones. The serial_open() function for USB overrides the meaning of the
+ * "baud" parameter to be the USB device ID to search for.
*/
- if (str_starts(port, "usb")) {
+ if(str_starts(port, "usb")) {
+
#if defined(HAVE_LIBUSB)
serdev = &usb_serdev_frame;
pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
@@ -2211,7 +2195,7 @@ static int stk600_open(PROGRAMMER *pgm, const char *port) {
pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
pgm->fd.usb.rep = USBDEV_BULK_EP_READ_STK600;
pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_STK600;
- pgm->fd.usb.eep = 0; /* no seperate EP for events */
+ pgm->fd.usb.eep = 0; // No seperate EP for events
#else
pmsg_error("avrdude was compiled without usb support\n");
return -1;
@@ -2219,7 +2203,7 @@ static int stk600_open(PROGRAMMER *pgm, const char *port) {
}
pgm->port = port;
- if (serial_open(port, pinfo, &pgm->fd)==-1) {
+ if(serial_open(port, pinfo, &pgm->fd) == -1) {
return -1;
}
@@ -2227,15 +2211,14 @@ static int stk600_open(PROGRAMMER *pgm, const char *port) {
if(stk500v2_drain(pgm, 0) < 0 || stk500v2_getsync(pgm) < 0 || stk500v2_drain(pgm, 0) < 0)
return -1;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
return 0;
}
-
static void stk500v2_close(PROGRAMMER *pgm) {
DEBUG("STK500V2: stk500v2_close()\n");
@@ -2243,12 +2226,11 @@ static void stk500v2_close(PROGRAMMER *pgm) {
pgm->fd.ifd = -1;
}
-
static int stk500v2_loadaddr(const PROGRAMMER *pgm, unsigned int addr) {
unsigned char buf[16];
int result;
- DEBUG("STK500V2: stk500v2_loadaddr(%d)\n",addr);
+ DEBUG("STK500V2: stk500v2_loadaddr(%d)\n", addr);
buf[0] = CMD_LOAD_ADDRESS;
buf[1] = (addr >> 24) & 0xff;
@@ -2258,7 +2240,7 @@ static int stk500v2_loadaddr(const PROGRAMMER *pgm, unsigned int addr) {
result = stk500v2_command(pgm, buf, 5, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("unable to set load address\n");
return -1;
}
@@ -2266,14 +2248,9 @@ static int stk500v2_loadaddr(const PROGRAMMER *pgm, unsigned int addr) {
return 0;
}
-
-/*
- * Read a single byte, generic HV mode
- */
+// Read a single byte, generic HV mode
static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char * value,
- enum hvmode mode)
-{
+ unsigned long addr, unsigned char *value, enum hvmode mode) {
int result, cmdlen = 2;
unsigned char buf[266];
unsigned long paddr = 0UL, *paddr_ptr = NULL;
@@ -2282,7 +2259,7 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
pmsg_notice2("stk500hv_read_byte(.., %s, 0x%lx, ...)\n", mem->desc, addr);
- if (mem_is_flash(mem)) {
+ if(mem_is_flash(mem)) {
buf[0] = mode == PPMODE? CMD_READ_FLASH_PP: CMD_READ_FLASH_HVSP;
cmdlen = 3;
pagesize = PDATA(pgm)->flash_pagesize;
@@ -2291,35 +2268,34 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
cache_ptr = PDATA(pgm)->flash_pagecache;
addrshift = 1;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- } else if (mem_is_eeprom(mem)) {
+ } else if(mem_is_eeprom(mem)) {
buf[0] = mode == PPMODE? CMD_READ_EEPROM_PP: CMD_READ_EEPROM_HVSP;
cmdlen = 3;
pagesize = mem->page_size;
- if (pagesize == 0)
+ if(pagesize == 0)
pagesize = 1;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
buf[0] = mode == PPMODE? CMD_READ_FUSE_PP: CMD_READ_FUSE_HVSP;
if(mem_is_a_fuse(mem))
addr = mem_fuse_offset(mem);
- } else if (mem_is_lock(mem)) {
+ } else if(mem_is_lock(mem)) {
buf[0] = mode == PPMODE? CMD_READ_LOCK_PP: CMD_READ_LOCK_HVSP;
- } else if (mem_is_calibration(mem)) {
+ } else if(mem_is_calibration(mem)) {
buf[0] = mode == PPMODE? CMD_READ_OSCCAL_PP: CMD_READ_OSCCAL_HVSP;
- } else if (mem_is_signature(mem)) {
+ } else if(mem_is_signature(mem)) {
buf[0] = mode == PPMODE? CMD_READ_SIGNATURE_PP: CMD_READ_SIGNATURE_HVSP;
- } else if (mem_is_in_sigrow(mem)) {
- buf[0] = addr&1?
+ } else if(mem_is_in_sigrow(mem)) {
+ buf[0] = addr & 1?
(mode == PPMODE? CMD_READ_OSCCAL_PP: CMD_READ_OSCCAL_HVSP):
(mode == PPMODE? CMD_READ_SIGNATURE_PP: CMD_READ_SIGNATURE_HVSP);
addr = (addr + avr_sigrow_offset(p, mem, addr))/2;
@@ -2329,27 +2305,26 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
}
/*
- * In HV mode, we have to use paged reads for flash and
- * EEPROM, and cache the results in a page cache.
+ * In HV mode, we have to use paged reads for flash and EEPROM, and cache the
+ * results in a page cache.
*
- * Page cache validation is based on "{flash,eeprom}_pageaddr"
- * (holding the base address of the most recent cache fill
- * operation). This variable is set to ~0UL when the
- * cache needs to be invalidated.
+ * Page cache validation is based on "{flash,eeprom}_pageaddr" (holding the
+ * base address of the most recent cache fill operation). This variable is
+ * set to ~0UL when the cache needs to be invalidated.
*/
- if (pagesize && paddr == *paddr_ptr) {
+ if(pagesize && paddr == *paddr_ptr) {
*value = cache_ptr[addr & (pagesize - 1)];
return 0;
}
- if (cmdlen == 3) {
- /* long command, fill in # of bytes */
+ if(cmdlen == 3) {
+ // Long command, fill in # of bytes
buf[1] = (pagesize >> 8) & 0xff;
buf[2] = pagesize & 0xff;
- /* flash and EEPROM reads require the load address command */
- if (stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
- return -1;
+ // Flash and EEPROM reads require the load address command
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
+ return -1;
} else {
buf[1] = addr;
}
@@ -2358,12 +2333,12 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
result = stk500v2_command(pgm, buf, cmdlen, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("timeout/error communicating with programmer\n");
return -1;
}
- if (pagesize) {
+ if(pagesize) {
*paddr_ptr = paddr;
memcpy(cache_ptr, buf + 2, pagesize);
*value = cache_ptr[addr & (pagesize - 1)];
@@ -2374,33 +2349,26 @@ static int stk500hv_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
return 0;
}
-/*
- * Read a single byte, PP mode
- */
+// Read a single byte, PP mode
static int stk500pp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char * value)
-{
+ unsigned long addr, unsigned char *value) {
return stk500hv_read_byte(pgm, p, mem, addr, value, PPMODE);
}
-/*
- * Read a single byte, HVSP mode
- */
+// Read a single byte, HVSP mode
static int stk500hvsp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char * value)
-{
+ unsigned long addr, unsigned char *value) {
return stk500hv_read_byte(pgm, p, mem, addr, value, HVSPMODE);
}
/*
* Read a single byte, ISP mode
*
- * By now, only used on the JTAGICE3 which does not implement the
- * CMD_SPI_MULTI SPI passthrough command.
+ * By now, only used on the JTAGICE3 which does not implement the CMD_SPI_MULTI
+ * SPI passthrough command.
*/
static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char * value)
-{
+ unsigned long addr, unsigned char *value) {
int result, pollidx, offset = 0;
unsigned char buf[6];
unsigned long paddr = 0UL, *paddr_ptr = NULL;
@@ -2410,28 +2378,28 @@ static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
pmsg_notice2("stk500isp_read_byte(.., %s, 0x%lx, ...)\n", mem->desc, addr);
- if (mem_is_flash(mem) || mem_is_eeprom(mem)) {
- // use paged access, and cache result
- if (mem_is_flash(mem)) {
+ if(mem_is_flash(mem) || mem_is_eeprom(mem)) {
+ // Use paged access, and cache result
+ if(mem_is_flash(mem)) {
pagesize = PDATA(pgm)->flash_pagesize;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->flash_pageaddr;
cache_ptr = PDATA(pgm)->flash_pagecache;
} else {
pagesize = mem->page_size;
- if (pagesize == 0)
+ if(pagesize == 0)
pagesize = 1;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
}
- if (paddr == *paddr_ptr) {
+ if(paddr == *paddr_ptr) {
*value = cache_ptr[addr & (pagesize - 1)];
return 0;
}
- if (stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
+ if(stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
return -1;
*paddr_ptr = paddr;
@@ -2441,31 +2409,31 @@ static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
return 0;
}
- if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
buf[0] = CMD_READ_FUSE_ISP;
if(mem_is_a_fuse(mem))
addr = mem_fuse_offset(mem);
- } else if (mem_is_lock(mem)) {
+ } else if(mem_is_lock(mem)) {
buf[0] = CMD_READ_LOCK_ISP;
- } else if (mem_is_calibration(mem)) {
+ } else if(mem_is_calibration(mem)) {
buf[0] = CMD_READ_OSCCAL_ISP;
- } else if (mem_is_signature(mem)) {
+ } else if(mem_is_signature(mem)) {
buf[0] = CMD_READ_SIGNATURE_ISP;
- } else if (mem_is_in_sigrow(mem)) { // Sernum and prodsig/sigrow (m324pb/m328pb)
- buf[0] = addr&1? CMD_READ_OSCCAL_ISP: CMD_READ_SIGNATURE_ISP;
+ } else if(mem_is_in_sigrow(mem)) { // Sernum and prodsig/sigrow (m324pb/m328pb)
+ buf[0] = addr & 1? CMD_READ_OSCCAL_ISP: CMD_READ_SIGNATURE_ISP;
offset = avr_sigrow_offset(p, mem, addr);
} else {
pmsg_error("unsupported memory %s\n", mem->desc);
return -1;
}
- if ((op = mem->op[AVR_OP_READ]) == NULL) {
+ if((op = mem->op[AVR_OP_READ]) == NULL) {
pmsg_error("invalid operation AVR_OP_READ on %s memory\n", mem->desc);
return -1;
}
- memset(buf+2, 0, 4);
+ memset(buf + 2, 0, 4);
avr_set_bits(op, buf + 2);
- if ((pollidx = avr_get_output_index(op)) == -1) {
+ if((pollidx = avr_get_output_index(op)) == -1) {
pmsg_warning("cannot determine pollidx to read %s memory\n", mem->desc);
pollidx = 3;
}
@@ -2476,7 +2444,7 @@ static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
result = stk500v2_command(pgm, buf, 6, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("timeout/error communicating with programmer\n");
return -1;
}
@@ -2486,13 +2454,9 @@ static int stk500isp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
return 0;
}
-/*
- * Write one byte, generic HV mode
- */
+// Write one byte, generic HV mode
static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char data,
- enum hvmode mode)
-{
+ unsigned long addr, unsigned char data, enum hvmode mode) {
int result, cmdlen, timeout = 0, pulsewidth = 0;
unsigned char buf[266];
unsigned long paddr = 0UL, *paddr_ptr = NULL;
@@ -2501,7 +2465,7 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
pmsg_notice2("stk500hv_write_byte(.., %s, 0x%lx, ...)\n", mem->desc, addr);
- if (mem_is_flash(mem)) {
+ if(mem_is_flash(mem)) {
buf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
pagesize = PDATA(pgm)->flash_pagesize;
paddr = addr & ~(pagesize - 1);
@@ -2509,34 +2473,34 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
cache_ptr = PDATA(pgm)->flash_pagecache;
addrshift = 1;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- } else if (mem_is_eeprom(mem)) {
+ } else if(mem_is_eeprom(mem)) {
buf[0] = mode == PPMODE? CMD_PROGRAM_EEPROM_PP: CMD_PROGRAM_EEPROM_HVSP;
pagesize = mem->page_size;
- if (pagesize == 0)
+ if(pagesize == 0)
pagesize = 1;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
buf[0] = mode == PPMODE? CMD_PROGRAM_FUSE_PP: CMD_PROGRAM_FUSE_HVSP;
pulsewidth = p->programfusepulsewidth;
timeout = p->programfusepolltimeout;
if(mem_is_a_fuse(mem))
addr = mem_fuse_offset(mem);
- } else if (mem_is_lock(mem)) {
+ } else if(mem_is_lock(mem)) {
buf[0] = mode == PPMODE? CMD_PROGRAM_LOCK_PP: CMD_PROGRAM_LOCK_HVSP;
pulsewidth = p->programlockpulsewidth;
timeout = p->programlockpolltimeout;
} else if(mem_is_readonly(mem)) {
unsigned char is;
+
if(pgm->read_byte(pgm, p, mem, addr, &is) >= 0 && is == data)
return 0;
@@ -2550,35 +2514,34 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
cmdlen = 5 + pagesize;
/*
- * In HV mode, we have to use paged writes for flash and
- * EEPROM. As both, flash and EEPROM cells can only be programmed
- * from `1' to `0' bits (even EEPROM does not support auto-erase in
- * parallel mode), we just pre-fill the page cache with 0xff, so all
- * those cells that are outside our current address will remain
- * unaffected.
+ * In HV mode, we have to use paged writes for flash and EEPROM. As both,
+ * flash and EEPROM cells can only be programmed from `1' to `0' bits (even
+ * EEPROM does not support auto-erase in parallel mode), we just pre-fill the
+ * page cache with 0xff, so all those cells that are outside our current
+ * address will remain unaffected.
*/
- if (pagesize) {
+ if(pagesize) {
memset(cache_ptr, 0xff, pagesize);
cache_ptr[addr & (pagesize - 1)] = data;
- /* long command, fill in # of bytes */
+ // Long command, fill in # of bytes
buf[1] = (pagesize >> 8) & 0xff;
buf[2] = pagesize & 0xff;
/*
- * Synthesize the mode byte. This is simpler than adding yet
- * another parameter to the avrdude.conf file. We calculate the
- * bits corresponding to the page size, as explained in AVR068.
- * We set bit 7, to indicate this is to actually write the page to
- * the target device. We set bit 6 to indicate this is the very
- * last page to be programmed, whatever this means -- we just
- * pretend we don't know any better. ;-) Bit 0 is set if this is
- * a paged memory, which means it has a page size of more than 2.
+ * Synthesize the mode byte. This is simpler than adding yet another
+ * parameter to the avrdude.conf file. We calculate the bits corresponding
+ * to the page size, as explained in AVR068. We set bit 7, to indicate this
+ * is to actually write the page to the target device. We set bit 6 to
+ * indicate this is the very last page to be programmed, whatever this
+ * means -- we just pretend we don't know any better. ;-) Bit 0 is set if
+ * this is a paged memory, which means it has a page size of more than 2.
*/
buf[3] = 0x80 | 0x40;
- if (pagesize > 2) {
+ if(pagesize > 2) {
unsigned int rv = stk500v2_mode_for_pagesize(pagesize);
- if (rv == 0)
+
+ if(rv == 0)
return -1;
buf[3] |= rv;
buf[3] |= 0x01;
@@ -2586,13 +2549,13 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
buf[4] = mem->delay;
memcpy(buf + 5, cache_ptr, pagesize);
- /* flash and EEPROM reads require the load address command */
- if (stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
- return -1;
+ // Flash and EEPROM reads require the load address command
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
+ return -1;
} else {
buf[1] = addr;
buf[2] = data;
- if (mode == PPMODE) {
+ if(mode == PPMODE) {
buf[3] = pulsewidth;
buf[4] = timeout;
} else {
@@ -2605,44 +2568,34 @@ static int stk500hv_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
result = stk500v2_command(pgm, buf, cmdlen, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("timeout/error communicating with programmer\n");
return -1;
}
- if (pagesize) {
- /* Invalidate the page cache. */
+ if(pagesize) {
+ // Invalidate the page cache
*paddr_ptr = ~0UL;
}
return 0;
}
-/*
- * Write one byte, PP mode
- */
+// Write one byte, PP mode
static int stk500pp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char data)
-{
+ unsigned long addr, unsigned char data) {
return stk500hv_write_byte(pgm, p, mem, addr, data, PPMODE);
}
-/*
- * Write one byte, HVSP mode
- */
+// Write one byte, HVSP mode
static int stk500hvsp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char data)
-{
+ unsigned long addr, unsigned char data) {
return stk500hv_write_byte(pgm, p, mem, addr, data, HVSPMODE);
}
-
-/*
- * Write one byte, ISP mode
- */
+// Write one byte, ISP mode
static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char data)
-{
+ unsigned long addr, unsigned char data) {
int result;
unsigned char buf[5];
unsigned long paddr = 0UL, *paddr_ptr = NULL;
@@ -2652,18 +2605,18 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
pmsg_notice2("stk500isp_write_byte(.., %s, 0x%lx, ...)\n", mem->desc, addr);
- if (mem_is_flash(mem) || mem_is_eeprom(mem)) {
- if (mem_is_flash(mem)) {
+ if(mem_is_flash(mem) || mem_is_eeprom(mem)) {
+ if(mem_is_flash(mem)) {
pagesize = PDATA(pgm)->flash_pagesize;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->flash_pageaddr;
cache_ptr = PDATA(pgm)->flash_pagecache;
- if ((mem->mode & 1) == 0)
- /* old, unpaged device, really write single bytes */
+ if((mem->mode & 1) == 0)
+ // Old, unpaged device, really write single bytes
pagesize = 1;
} else {
pagesize = mem->page_size;
- if (pagesize == 0)
+ if(pagesize == 0)
pagesize = 1;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
@@ -2671,11 +2624,10 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
}
/*
- * We use paged writes for flash and EEPROM, reading back the
- * current page first, modify the byte to write, and write out the
- * entire page.
+ * We use paged writes for flash and EEPROM, reading back the current page
+ * first, modify the byte to write, and write out the entire page.
*/
- if (stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
+ if(stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
return -1;
memcpy(cache_ptr, mem->buf + paddr, pagesize);
@@ -2689,14 +2641,15 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
}
memset(buf, 0, sizeof buf);
- if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
buf[0] = CMD_PROGRAM_FUSE_ISP;
if(mem_is_a_fuse(mem))
addr = mem_fuse_offset(mem);
- } else if (mem_is_lock(mem)) {
+ } else if(mem_is_lock(mem)) {
buf[0] = CMD_PROGRAM_LOCK_ISP;
} else if(mem_is_readonly(mem)) {
unsigned char is;
+
if(pgm->read_byte(pgm, p, mem, addr, &is) >= 0 && is == data)
return 0;
pmsg_error("cannot write to read-only memory %s of %s\n", mem->desc, p->desc);
@@ -2706,7 +2659,7 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
return -1;
}
- if ((op = mem->op[AVR_OP_WRITE]) == NULL) {
+ if((op = mem->op[AVR_OP_WRITE]) == NULL) {
pmsg_error("no AVR_OP_WRITE for %s memory\n", mem->desc);
return -1;
}
@@ -2719,7 +2672,7 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
result = stk500v2_command(pgm, buf, 5, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("timeout/error communicating with programmer\n");
return -1;
}
@@ -2728,10 +2681,10 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
* Prevent verification readback to be too fast, see
* https://savannah.nongnu.org/bugs/index.php?42267
*
- * After all, this is just an ugly hack working around some
- * brokeness in the Atmel firmware starting with the AVRISPmkII (the
- * old JTAGICEmkII isn't affected). Let's hope 10 ms of additional
- * delay are good enough for everyone.
+ * After all, this is just an ugly hack working around some brokeness in the
+ * Atmel firmware starting with the AVRISPmkII (the old JTAGICEmkII isn't
+ * affected). Let's hope 10 ms of additional delay are good enough for
+ * everyone.
*/
usleep(10000);
@@ -2739,58 +2692,54 @@ static int stk500isp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
}
static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
unsigned int block_size, last_addr, addrshift, use_ext_addr;
unsigned int maxaddr = addr + n_bytes;
unsigned char commandbuf[10];
unsigned char buf[266];
unsigned char cmds[4];
int result;
- OPCODE * rop, * wop;
+ OPCODE *rop, *wop;
- DEBUG("STK500V2: stk500v2_paged_write(..,%s,%u,%u,%u)\n",
- m->desc, page_size, addr, n_bytes);
+ DEBUG("STK500V2: stk500v2_paged_write(..,%s,%u,%u,%u)\n", m->desc, page_size, addr, n_bytes);
- if (page_size == 0) page_size = 256;
+ if(page_size == 0)
+ page_size = 256;
addrshift = 0;
use_ext_addr = 0;
- // determine which command is to be used
- if (mem_is_flash(m)) {
+ // Determine which command is to be used
+ if(mem_is_flash(m)) {
addrshift = 1;
- PDATA(pgm)->flash_pageaddr = ~0UL; // Invalidate cache
+ PDATA(pgm)->flash_pageaddr = ~0UL; // Invalidate cache
commandbuf[0] = CMD_PROGRAM_FLASH_ISP;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- } else if (mem_is_eeprom(m)) {
+ } else if(mem_is_eeprom(m)) {
PDATA(pgm)->eeprom_pageaddr = ~0UL; // Invalidate cache
commandbuf[0] = CMD_PROGRAM_EEPROM_ISP;
}
commandbuf[4] = m->delay;
- if (addrshift == 0) {
+ if(addrshift == 0) {
wop = m->op[AVR_OP_WRITE];
rop = m->op[AVR_OP_READ];
- }
- else {
+ } else {
wop = m->op[AVR_OP_WRITE_LO];
rop = m->op[AVR_OP_READ_LO];
}
- // if the memory is paged, load the appropriate commands into the buffer
- if (m->mode & 0x01) {
- commandbuf[3] = m->mode | 0x80; // yes, write the page to flash
+ // If the memory is paged, load the appropriate commands into the buffer
+ if(m->mode & 0x01) {
+ commandbuf[3] = m->mode | 0x80; // Yes, write the page to flash
- if (m->op[AVR_OP_LOADPAGE_LO] == NULL) {
+ if(m->op[AVR_OP_LOADPAGE_LO] == NULL) {
pmsg_error("loadpage instruction not defined for part %s\n", p->desc);
return -1;
}
@@ -2798,7 +2747,7 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
avr_set_bits(m->op[AVR_OP_LOADPAGE_LO], cmds);
commandbuf[5] = cmds[0];
- if (m->op[AVR_OP_WRITEPAGE] == NULL) {
+ if(m->op[AVR_OP_WRITEPAGE] == NULL) {
pmsg_error("write page instruction not defined for part %s\n", p->desc);
return -1;
}
@@ -2807,12 +2756,11 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
avr_set_bits(m->op[AVR_OP_WRITEPAGE], cmds);
commandbuf[6] = cmds[0];
- // otherwise, we need to load different commands in
- }
- else {
- commandbuf[3] = m->mode | 0x80; // yes, write the words to flash
+ // Otherwise, we need to load different commands in
+ } else {
+ commandbuf[3] = m->mode | 0x80; // Yes, write the words to flash
- if (wop == NULL) {
+ if(wop == NULL) {
pmsg_error("write instruction not defined for part %s\n", p->desc);
return -1;
}
@@ -2822,8 +2770,8 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
commandbuf[6] = 0;
}
- // the read command is common to both methods
- if (rop == NULL) {
+ // The read command is common to both methods
+ if(rop == NULL) {
pmsg_error("read instruction not defined for memory %s of part %s\n", m->desc, p->desc);
return -1;
}
@@ -2834,35 +2782,36 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
commandbuf[8] = m->readback[0];
commandbuf[9] = m->readback[1];
- last_addr=UINT_MAX; /* impossible address */
+ last_addr = UINT_MAX; // Impossible address
- for (; addr < maxaddr; addr += page_size) {
- if ((maxaddr - addr) < page_size)
+ for(; addr < maxaddr; addr += page_size) {
+ if((maxaddr - addr) < page_size)
block_size = maxaddr - addr;
else
block_size = page_size;
- DEBUG("block_size at addr %d is %d\n",addr,block_size);
+ DEBUG("block_size at addr %d is %d\n", addr, block_size);
- memcpy(buf,commandbuf,sizeof(commandbuf));
+ memcpy(buf, commandbuf, sizeof(commandbuf));
buf[1] = block_size >> 8;
buf[2] = block_size & 0xff;
- if((last_addr==UINT_MAX)||(last_addr+block_size != addr)){
- if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
+ if((last_addr == UINT_MAX) || (last_addr + block_size != addr)) {
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
return -1;
}
- last_addr=addr;
+ last_addr = addr;
- memcpy(buf+10,m->buf+addr, block_size);
+ memcpy(buf + 10, m->buf + addr, block_size);
// Do not send request to write empty flash pages except for bootloaders (fixes Issue #425)
- unsigned char *p = m->buf+addr;
- result = (pgm->prog_modes & PM_SPM) || !addrshift || *p != 0xff || memcmp(p, p+1, block_size-1)?
- stk500v2_command(pgm, buf, block_size+10, sizeof buf): 0;
+ unsigned char *p = m->buf + addr;
- if (result < 0) {
+ result = (pgm->prog_modes & PM_SPM) || !addrshift || *p != 0xff || memcmp(p, p + 1, block_size - 1)?
+ stk500v2_command(pgm, buf, block_size + 10, sizeof buf): 0;
+
+ if(result < 0) {
pmsg_error("write command failed\n");
return -1;
}
@@ -2871,92 +2820,86 @@ static int stk500v2_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
return n_bytes;
}
-/*
- * Write pages of flash/EEPROM, generic HV mode
- */
+// Write pages of flash/EEPROM, generic HV mode
static int stk500hv_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes,
- enum hvmode mode)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes, enum hvmode mode) {
unsigned int block_size, last_addr, addrshift, use_ext_addr;
unsigned int maxaddr = addr + n_bytes;
unsigned char commandbuf[5], buf[266];
int result;
- DEBUG("STK500V2: stk500hv_paged_write(..,%s,%u,%u,%u)\n",
- m->desc, page_size, addr, n_bytes);
+ DEBUG("STK500V2: stk500hv_paged_write(..,%s,%u,%u,%u)\n", m->desc, page_size, addr, n_bytes);
addrshift = 0;
use_ext_addr = 0;
- // determine which command is to be used
- if (mem_is_flash(m)) {
+ // Determine which command is to be used
+ if(mem_is_flash(m)) {
addrshift = 1;
PDATA(pgm)->flash_pageaddr = ~0UL;
commandbuf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- } else if (mem_is_eeprom(m)) {
+ } else if(mem_is_eeprom(m)) {
PDATA(pgm)->eeprom_pageaddr = ~0UL;
commandbuf[0] = mode == PPMODE? CMD_PROGRAM_EEPROM_PP: CMD_PROGRAM_EEPROM_HVSP;
}
/*
- * Synthesize the mode byte. This is simpler than adding yet
- * another parameter to the avrdude.conf file. We calculate the
- * bits corresponding to the page size, as explained in AVR068. We
- * set bit 7, to indicate this is to actually write the page to the
- * target device. We set bit 6 to indicate this is the very last
- * page to be programmed, whatever this means -- we just pretend we
- * don't know any better. ;-) Finally, we set bit 0 to say this is
- * a paged memory, after all, that's why we got here at all.
+ * Synthesize the mode byte. This is simpler than adding yet another
+ * parameter to the avrdude.conf file. We calculate the bits corresponding
+ * to the page size, as explained in AVR068. We set bit 7, to indicate this
+ * is to actually write the page to the target device. We set bit 6 to
+ * indicate this is the very last page to be programmed, whatever this means
+ * -- we just pretend we don't know any better. ;-) Finally, we set bit 0 to
+ * say this is a paged memory, after all, that's why we got here at all.
*/
commandbuf[3] = 0x80 | 0x40;
- if (page_size > 2) {
+ if(page_size > 2) {
unsigned int rv = stk500v2_mode_for_pagesize(page_size);
- if (rv == 0)
+
+ if(rv == 0)
return -1;
commandbuf[3] |= rv;
commandbuf[3] |= 0x01;
}
commandbuf[4] = m->delay;
- if (page_size == 0) page_size = 256;
+ if(page_size == 0)
+ page_size = 256;
- last_addr = UINT_MAX; /* impossible address */
+ last_addr = UINT_MAX; // Impossible address
- for (; addr < maxaddr; addr += page_size) {
- if ((maxaddr - addr) < page_size)
+ for(; addr < maxaddr; addr += page_size) {
+ if((maxaddr - addr) < page_size)
block_size = maxaddr - addr;
else
block_size = page_size;
- DEBUG("block_size at addr %d is %d\n",addr,block_size);
+ DEBUG("block_size at addr %d is %d\n", addr, block_size);
memcpy(buf, commandbuf, sizeof(commandbuf));
buf[1] = page_size >> 8;
buf[2] = page_size & 0xff;
- if ((last_addr == UINT_MAX) || (last_addr + block_size != addr)) {
- if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
+ if((last_addr == UINT_MAX) || (last_addr + block_size != addr)) {
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
return -1;
}
- last_addr=addr;
+ last_addr = addr;
memcpy(buf + 5, m->buf + addr, block_size);
- if (block_size != page_size)
+ if(block_size != page_size)
memset(buf + 5 + block_size, 0xff, page_size - block_size);
result = stk500v2_command(pgm, buf, page_size + 5, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("write command failed\n");
return -1;
}
@@ -2965,40 +2908,29 @@ static int stk500hv_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
return n_bytes;
}
-/*
- * Write pages of flash/EEPROM, PP mode
- */
+// Write pages of flash/EEPROM, PP mode
static int stk500pp_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return stk500hv_paged_write(pgm, p, m, page_size, addr, n_bytes, PPMODE);
}
-/*
- * Write pages of flash/EEPROM, HVSP mode
- */
+// Write pages of flash/EEPROM, HVSP mode
static int stk500hvsp_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return stk500hv_paged_write(pgm, p, m, page_size, addr, n_bytes, HVSPMODE);
}
static int stk500v2_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
unsigned int block_size, hiaddr, addrshift, use_ext_addr;
unsigned int maxaddr = addr + n_bytes;
unsigned char commandbuf[4];
- unsigned char buf[275]; // max buffer size for stk500v2 at this point
+ unsigned char buf[275]; // Max buffer size for stk500v2 at this point
unsigned char cmds[4];
int result;
- OPCODE * rop;
+ OPCODE *rop;
- DEBUG("STK500V2: stk500v2_paged_load(..,%s,%u,%u,%u)\n",
- m->desc, page_size, addr, n_bytes);
+ DEBUG("STK500V2: stk500v2_paged_load(..,%s,%u,%u,%u)\n", m->desc, page_size, addr, n_bytes);
page_size = m->readsize;
@@ -3008,27 +2940,25 @@ static int stk500v2_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
addrshift = 0;
use_ext_addr = 0;
- // determine which command is to be used
- if (mem_is_flash(m)) {
+ // Determine which command is to be used
+ if(mem_is_flash(m)) {
commandbuf[0] = CMD_READ_FLASH_ISP;
rop = m->op[AVR_OP_READ_LO];
addrshift = 1;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- }
- else if (mem_is_eeprom(m)) {
+ } else if(mem_is_eeprom(m)) {
commandbuf[0] = CMD_READ_EEPROM_ISP;
}
- // the read command is common to both methods
- if (rop == NULL) {
+ // The read command is common to both methods
+ if(rop == NULL) {
pmsg_error("read instruction not defined for memory %s of part %s\n", m->desc, p->desc);
return -1;
}
@@ -3036,35 +2966,35 @@ static int stk500v2_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
avr_set_bits(rop, cmds);
commandbuf[3] = cmds[0];
- for (; addr < maxaddr; addr += page_size) {
- if ((maxaddr - addr) < page_size)
+ for(; addr < maxaddr; addr += page_size) {
+ if((maxaddr - addr) < page_size)
block_size = maxaddr - addr;
else
block_size = page_size;
- DEBUG("block_size at addr %d is %d\n",addr,block_size);
+ DEBUG("block_size at addr %d is %d\n", addr, block_size);
- memcpy(buf,commandbuf,sizeof(commandbuf));
+ memcpy(buf, commandbuf, sizeof(commandbuf));
buf[1] = block_size >> 8;
buf[2] = block_size & 0xff;
- // Ensure a new "load extended address" will be issued
- // when crossing a 64 KB boundary in flash.
- if (hiaddr != (addr & ~0xFFFF)) {
+ // Ensure load extended address will be issued when crossing a 64 KB boundary in flash
+ if(hiaddr != (addr & ~0xFFFF)) {
hiaddr = addr & ~0xFFFF;
- if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
return -1;
}
- result = stk500v2_command(pgm,buf,4,sizeof(buf));
- if (result < 0) {
+ result = stk500v2_command(pgm, buf, 4, sizeof(buf));
+ if(result < 0) {
pmsg_error("read command failed\n");
return -1;
}
+
#if 0
- for (i=0; idesc, page_size, addr, n_bytes);
+ DEBUG("STK500V2: stk500hv_paged_load(..,%s,%u,%u,%u)\n", m->desc, page_size, addr, n_bytes);
page_size = m->readsize;
@@ -3098,53 +3021,51 @@ static int stk500hv_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
addrshift = 0;
use_ext_addr = 0;
- // determine which command is to be used
- if (mem_is_flash(m)) {
+ // Determine which command is to be used
+ if(mem_is_flash(m)) {
commandbuf[0] = mode == PPMODE? CMD_READ_FLASH_PP: CMD_READ_FLASH_HVSP;
addrshift = 1;
/*
- * If bit 31 is set, this indicates that the following read/write
- * operation will be performed on a memory that is larger than
- * 64KBytes. This is an indication to STK500 that a load extended
- * address must be executed.
+ * If bit 31 is set, this indicates that the following read/write operation
+ * will be performed on a memory that is larger than 64KBytes. This is an
+ * indication to STK500 that a load extended address must be executed.
*/
- if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
+ if(m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
use_ext_addr = (1U << 31);
}
- }
- else if (mem_is_eeprom(m)) {
+ } else if(mem_is_eeprom(m)) {
commandbuf[0] = mode == PPMODE? CMD_READ_EEPROM_PP: CMD_READ_EEPROM_HVSP;
}
- for (; addr < maxaddr; addr += page_size) {
- if ((maxaddr - addr) < page_size)
+ for(; addr < maxaddr; addr += page_size) {
+ if((maxaddr - addr) < page_size)
block_size = maxaddr - addr;
else
block_size = page_size;
- DEBUG("block_size at addr %d is %d\n",addr,block_size);
+ DEBUG("block_size at addr %d is %d\n", addr, block_size);
memcpy(buf, commandbuf, sizeof(commandbuf));
buf[1] = block_size >> 8;
buf[2] = block_size & 0xff;
- // Ensure a new "load extended address" will be issued
- // when crossing a 64 KB boundary in flash.
- if (hiaddr != (addr & ~0xFFFF)) {
+ // Ensure load extended address will be issued when crossing a 64 KB boundary in flash
+ if(hiaddr != (addr & ~0xFFFF)) {
hiaddr = addr & ~0xFFFF;
- if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
+ if(stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
return -1;
}
result = stk500v2_command(pgm, buf, 3, sizeof(buf));
- if (result < 0) {
+ if(result < 0) {
pmsg_error("read command failed\n");
return -1;
}
+
#if 0
- for (i = 0; i < page_size; i++) {
+ for(i = 0; i < page_size; i++) {
msg_notice("%02X", buf[2 + i]);
- if (i % 16 == 15)
+ if(i%16 == 15)
msg_notice("\n");
}
#endif
@@ -3155,73 +3076,57 @@ static int stk500hv_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
return n_bytes;
}
-/*
- * Read pages of flash/EEPROM, PP mode
- */
+// Read pages of flash/EEPROM, PP mode
static int stk500pp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return stk500hv_paged_load(pgm, p, m, page_size, addr, n_bytes, PPMODE);
}
-/*
- * Read pages of flash/EEPROM, HVSP mode
- */
+// Read pages of flash/EEPROM, HVSP mode
static int stk500hvsp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return stk500hv_paged_load(pgm, p, m, page_size, addr, n_bytes, HVSPMODE);
}
-
static int stk500v2_set_vtarget(const PROGRAMMER *pgm, double v) {
unsigned char uaref = 0;
- unsigned char utarg = (unsigned)((v + 0.049) * 10);
+ unsigned char utarg = (unsigned) ((v + 0.049)*10);
- if (stk500v2_getparm(pgm, PARAM_VADJUST, &uaref) != 0) {
+ if(stk500v2_getparm(pgm, PARAM_VADJUST, &uaref) != 0) {
pmsg_error("cannot obtain V[aref]\n");
return -1;
}
- if (uaref > utarg) {
+ if(uaref > utarg) {
pmsg_warning("reducing V[aref] from %.1f to %.1f\n", uaref/10.0, v);
- if (stk500v2_setparm(pgm, PARAM_VADJUST, utarg) != 0)
+ if(stk500v2_setparm(pgm, PARAM_VADJUST, utarg) != 0)
return -1;
}
return stk500v2_setparm(pgm, PARAM_VTARGET, utarg);
}
-
static int stk500v2_get_vtarget(const PROGRAMMER *pgm, double *v) {
*v = stk500v2_vtarget_value(pgm);
return 0;
}
-
-static int stk500v2_set_varef(const PROGRAMMER *pgm, unsigned int chan /* unused */,
- double v)
-{
+static int stk500v2_set_varef(const PROGRAMMER *pgm, unsigned int chan, double v) {
unsigned char utarg = 0;
- unsigned char uaref = (unsigned)((v + 0.049) * 10);
+ unsigned char uaref = (unsigned) ((v + 0.049)*10);
- if (stk500v2_getparm(pgm, PARAM_VTARGET, &utarg) != 0) {
+ if(stk500v2_getparm(pgm, PARAM_VTARGET, &utarg) != 0) {
pmsg_error("cannot obtain V[target]\n");
return -1;
}
- if (uaref > utarg) {
- pmsg_error("V[aref] must not be greater than "
- "V[target] = %.1f\n", utarg/10.0);
+ if(uaref > utarg) {
+ pmsg_error("V[aref] must not be greater than " "V[target] = %.1f\n", utarg/10.0);
return -1;
}
return stk500v2_setparm(pgm, PARAM_VADJUST, uaref);
}
-
-static int stk500v2_get_varef(const PROGRAMMER *pgm, unsigned int chan, double *v)
-{
+static int stk500v2_get_varef(const PROGRAMMER *pgm, unsigned int chan, double *v) {
if(PDATA(pgm)->pgmtype == PGMTYPE_STK500)
*v = stk500v2_varef_value(pgm);
else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
@@ -3237,10 +3142,10 @@ static int stk500v2_get_varef(const PROGRAMMER *pgm, unsigned int chan, double *
return 0;
}
-
static int stk500v2_set_fosc(const PROGRAMMER *pgm, double v) {
int fosc;
unsigned char prescale, cmatch;
+
const unsigned ps[] = {
1, 8, 32, 64, 128, 256, 1024
};
@@ -3248,83 +3153,81 @@ static int stk500v2_set_fosc(const PROGRAMMER *pgm, double v) {
int rc;
prescale = cmatch = 0;
- if (v > 0.0) {
- if (v > PDATA(pgm)->xtal / 2) {
+ if(v > 0.0) {
+ if(v > PDATA(pgm)->xtal/2) {
const char *unit;
- if (v >= 1e6) {
+
+ if(v >= 1e6) {
v /= 1e6;
unit = "MHz";
- } else if (v >= 1e3) {
+ } else if(v >= 1e3) {
v /= 1e3;
unit = "kHz";
} else
unit = "Hz";
- pmsg_warning("f = %.3f %s too high, using %.3f MHz\n",
- v, unit, PDATA(pgm)->xtal / 2e6);
- fosc = PDATA(pgm)->xtal / 2;
+ pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, PDATA(pgm)->xtal/2e6);
+ fosc = PDATA(pgm)->xtal/2;
} else
- fosc = (unsigned)v;
+ fosc = (unsigned) v;
- for (idx = 0; idx < sizeof(ps) / sizeof(ps[0]); idx++) {
- if ((unsigned) fosc >= PDATA(pgm)->xtal / (256 * ps[idx] * 2)) {
- /* this prescaler value can handle our frequency */
+ for(idx = 0; idx < sizeof(ps)/sizeof(ps[0]); idx++) {
+ if((unsigned) fosc >= PDATA(pgm)->xtal/(256*ps[idx] * 2)) {
+ // This prescaler value can handle our frequency
prescale = idx + 1;
- cmatch = (unsigned)(PDATA(pgm)->xtal / (2 * fosc * ps[idx])) - 1;
+ cmatch = (unsigned) (PDATA(pgm)->xtal/(2*fosc*ps[idx])) - 1;
break;
}
}
- if (idx == sizeof(ps) / sizeof(ps[0])) {
- pmsg_warning("f = %u Hz too low, %u Hz min\n",
- fosc, PDATA(pgm)->xtal / (256 * 1024 * 2));
+ if(idx == sizeof(ps)/sizeof(ps[0])) {
+ pmsg_warning("f = %u Hz too low, %u Hz min\n", fosc, PDATA(pgm)->xtal/(256*1024*2));
return -1;
}
}
- if ((rc = stk500v2_setparm(pgm, PARAM_OSC_PSCALE, prescale)) != 0
- || (rc = stk500v2_setparm(pgm, PARAM_OSC_CMATCH, cmatch)) != 0)
+ if((rc = stk500v2_setparm(pgm, PARAM_OSC_PSCALE, prescale)) != 0 ||
+ (rc = stk500v2_setparm(pgm, PARAM_OSC_CMATCH, cmatch)) != 0) {
+
return rc;
+ }
return 0;
}
-
static int stk500v2_get_fosc(const PROGRAMMER *pgm, double *v) {
*v = stk500v2_fosc_value(pgm);
return 0;
}
-
-/* The list of SCK frequencies supported by the AVRISP mkII, as listed
- * in AVR069 */
+// The list of SCK frequencies supported by the AVRISP mkII, as listed in AVR069
static const double avrispmkIIfreqs[] = {
- 8000000, 4000000, 2000000, 1000000, 500000, 250000, 125000,
- 96386, 89888, 84211, 79208, 74767, 70797, 67227, 64000,
- 61069, 58395, 55945, 51613, 49690, 47905, 46243, 43244,
- 41885, 39409, 38278, 36200, 34335, 32654, 31129, 29740,
- 28470, 27304, 25724, 24768, 23461, 22285, 21221, 20254,
- 19371, 18562, 17583, 16914, 16097, 15356, 14520, 13914,
- 13224, 12599, 12031, 11511, 10944, 10431, 9963, 9468,
- 9081, 8612, 8239, 7851, 7498, 7137, 6809, 6478, 6178,
- 5879, 5607, 5359, 5093, 4870, 4633, 4418, 4209, 4019,
- 3823, 3645, 3474, 3310, 3161, 3011, 2869, 2734, 2611,
- 2484, 2369, 2257, 2152, 2052, 1956, 1866, 1779, 1695,
- 1615, 1539, 1468, 1398, 1333, 1271, 1212, 1155, 1101,
- 1049, 1000, 953, 909, 866, 826, 787, 750, 715, 682,
- 650, 619, 590, 563, 536, 511, 487, 465, 443, 422,
- 402, 384, 366, 349, 332, 317, 302, 288, 274, 261,
- 249, 238, 226, 216, 206, 196, 187, 178, 170, 162,
- 154, 147, 140, 134, 128, 122, 116, 111, 105, 100,
- 95.4, 90.9, 86.6, 82.6, 78.7, 75.0, 71.5, 68.2,
- 65.0, 61.9, 59.0, 56.3, 53.6, 51.1
+ 8000000, 4000000, 2000000, 1000000, 500000, 250000, 125000,
+ 96386, 89888, 84211, 79208, 74767, 70797, 67227, 64000,
+ 61069, 58395, 55945, 51613, 49690, 47905, 46243, 43244,
+ 41885, 39409, 38278, 36200, 34335, 32654, 31129, 29740,
+ 28470, 27304, 25724, 24768, 23461, 22285, 21221, 20254,
+ 19371, 18562, 17583, 16914, 16097, 15356, 14520, 13914,
+ 13224, 12599, 12031, 11511, 10944, 10431, 9963, 9468,
+ 9081, 8612, 8239, 7851, 7498, 7137, 6809, 6478, 6178,
+ 5879, 5607, 5359, 5093, 4870, 4633, 4418, 4209, 4019,
+ 3823, 3645, 3474, 3310, 3161, 3011, 2869, 2734, 2611,
+ 2484, 2369, 2257, 2152, 2052, 1956, 1866, 1779, 1695,
+ 1615, 1539, 1468, 1398, 1333, 1271, 1212, 1155, 1101,
+ 1049, 1000, 953, 909, 866, 826, 787, 750, 715, 682,
+ 650, 619, 590, 563, 536, 511, 487, 465, 443, 422,
+ 402, 384, 366, 349, 332, 317, 302, 288, 274, 261,
+ 249, 238, 226, 216, 206, 196, 187, 178, 170, 162,
+ 154, 147, 140, 134, 128, 122, 116, 111, 105, 100,
+ 95.4, 90.9, 86.6, 82.6, 78.7, 75.0, 71.5, 68.2,
+ 65.0, 61.9, 59.0, 56.3, 53.6, 51.1
};
-#define NavrispmkIIfreqs (sizeof avrispmkIIfreqs / sizeof *avrispmkIIfreqs)
+#define NavrispmkIIfreqs (sizeof avrispmkIIfreqs/sizeof *avrispmkIIfreqs)
static int stk500v2_set_sck_period_mk2(const PROGRAMMER *pgm, double v) {
size_t i;
for(i = 0; i < NavrispmkIIfreqs; i++)
- if(1 / avrispmkIIfreqs[i] >= v)
+ if(1/avrispmkIIfreqs[i] >= v)
break;
if(i >= NavrispmkIIfreqs) {
@@ -3332,28 +3235,31 @@ static int stk500v2_set_sck_period_mk2(const PROGRAMMER *pgm, double v) {
return -1;
}
- msg_notice2("Using p = %.2f us for SCK (i = %d)\n", 1e6 / avrispmkIIfreqs[i], (int) i);
+ msg_notice2("Using p = %.2f us for SCK (i = %d)\n", 1e6/avrispmkIIfreqs[i], (int) i);
return stk500v2_setparm(pgm, PARAM_SCK_DURATION, i);
}
-/*
- * Return the "mode" value for the parallel and HVSP modes that
- * corresponds to the pagesize.
- */
-static unsigned int stk500v2_mode_for_pagesize(unsigned int pagesize)
-{
- switch (pagesize)
- {
- case 256: return 0u << 1;
- case 2: return 1u << 1;
- case 4: return 2u << 1;
- case 8: return 3u << 1;
- case 16: return 4u << 1;
- case 32: return 5u << 1;
- case 64: return 6u << 1;
- case 128: return 7u << 1;
- }
+// Return the "mode" value for the parallel and HVSP modes that corresponds to* the pagesize
+static unsigned int stk500v2_mode_for_pagesize(unsigned int pagesize) {
+ switch (pagesize) {
+ case 256:
+ return 0u << 1;
+ case 2:
+ return 1u << 1;
+ case 4:
+ return 2u << 1;
+ case 8:
+ return 3u << 1;
+ case 16:
+ return 4u << 1;
+ case 32:
+ return 5u << 1;
+ case 64:
+ return 6u << 1;
+ case 128:
+ return 7u << 1;
+ }
pmsg_error("invalid pagesize: %u\n", pagesize);
return 0;
}
@@ -3361,32 +3267,32 @@ static unsigned int stk500v2_mode_for_pagesize(unsigned int pagesize)
/*
* See pseudo-code in AVR068
*
- * This algorithm only fits for the STK500 itself. For the (old)
- * AVRISP, the resulting ISP clock is only half. While this would be
- * easy to fix in the algorithm, we'd need to add another
- * configuration flag for this to the config file. Given the old
- * AVRISP devices are virtually no longer around (and the AVRISPmkII
- * uses a different algorithm below), it's probably not worth the
- * hassle.
- * Originally, magic constants based on the XTAL frequency
- * 7.3728 MHz of the original STK500 HW were used here.
+ * This algorithm only fits for the STK500 itself. For the (old) AVRISP, the
+ * resulting ISP clock is only half. While this would be easy to fix in the
+ * algorithm, we'd need to add another configuration flag for this to the
+ * config file. Given the old AVRISP devices are virtually no longer around
+ * (and the AVRISPmkII uses a different algorithm below), it's probably not
+ * worth the hassle.
+ *
+ * Originally, magic constants based on the XTAL frequency 7.3728 MHz of the
+ * original STK500 HW were used here.
*/
static int stk500v2_set_sck_period(const PROGRAMMER *pgm, double v) {
unsigned int d;
unsigned char dur;
- double f = 1 / v;
+ double f = 1/v;
- if (f >= PDATA(pgm)->xtal / 4.0) // 1.8432E6
+ if(f >= PDATA(pgm)->xtal/4.0) // 1.8432E6
d = 0;
- else if (f > PDATA(pgm)->xtal / 16.0) // 460.8E3
+ else if(f > PDATA(pgm)->xtal/16.0) // 460.8E3
d = 1;
- else if (f > PDATA(pgm)->xtal / 64.0) // 115.2E3
+ else if(f > PDATA(pgm)->xtal/64.0) // 115.2E3
d = 2;
- else if (f > PDATA(pgm)->xtal / 128.0) // 57.6E3
+ else if(f > PDATA(pgm)->xtal/128.0) // 57.6E3
d = 3;
else
- d = (unsigned int)ceil(1 / (24 * f / (double)PDATA(pgm)->xtal) - 10.0 / 12.0);
- if (d >= 255)
+ d = (unsigned int) ceil(1/(24*f/(double) PDATA(pgm)->xtal) - 10.0/12.0);
+ if(d >= 255)
d = 254;
dur = d;
@@ -3394,91 +3300,84 @@ static int stk500v2_set_sck_period(const PROGRAMMER *pgm, double v) {
}
static int stk500v2_get_sck_period(const PROGRAMMER *pgm, double *v) {
- *v = stk500v2_sck_duration_value(pgm) / 1e6;
+ *v = stk500v2_sck_duration_value(pgm)/1e6;
return 0;
}
-
static double stk500v2_sck_to_us(const PROGRAMMER *pgm, unsigned char dur) {
double x;
- if (dur == 0)
- return 4.E6 / PDATA(pgm)->xtal; // 0.5425;
- if (dur == 1)
- return 16.E6 / PDATA(pgm)->xtal; // 2.17;
- if (dur == 2)
- return 64.E6 / PDATA(pgm)->xtal; // 8.68;
- if (dur == 3)
- return 128.E6 / PDATA(pgm)->xtal; // 17.36;
+ if(dur == 0)
+ return 4.E6/PDATA(pgm)->xtal; // 0.5425;
+ if(dur == 1)
+ return 16.E6/PDATA(pgm)->xtal; // 2.17;
+ if(dur == 2)
+ return 64.E6/PDATA(pgm)->xtal; // 8.68;
+ if(dur == 3)
+ return 128.E6/PDATA(pgm)->xtal; // 17.36;
- x = (double)dur + 10.0 / 12.0;
- x = 1.0 / x;
+ x = (double) dur + 10.0/12.0;
+ x = 1.0/x;
x /= 24.0;
- x *= (double)PDATA(pgm)->xtal;
- return 1e6 / x;
+ x *= (double) PDATA(pgm)->xtal;
+ return 1e6/x;
}
-
static int stk600_set_vtarget(const PROGRAMMER *pgm, double v) {
unsigned int uaref = 0;
- unsigned char utarg = (unsigned)((v + 0.049) * 10);
+ unsigned char utarg = (unsigned) ((v + 0.049)*10);
int rv;
- if (stk500v2_getparm2(pgm, PARAM2_AREF0, &uaref) != 0) {
+ if(stk500v2_getparm2(pgm, PARAM2_AREF0, &uaref) != 0) {
pmsg_error("cannot obtain V[aref][0]\n");
return -1;
}
- if (uaref > (unsigned)utarg * 10) {
+ if(uaref > (unsigned) utarg*10) {
pmsg_warning("reducing V[aref][0] from %.2f V to %.1f\n", uaref/100.0, v);
- uaref = 10 * (unsigned)utarg;
- if (stk500v2_setparm2(pgm, PARAM2_AREF0, uaref) != 0)
+ uaref = 10 * (unsigned) utarg;
+ if(stk500v2_setparm2(pgm, PARAM2_AREF0, uaref) != 0)
return -1;
}
- if (stk500v2_getparm2(pgm, PARAM2_AREF1, &uaref) != 0) {
+ if(stk500v2_getparm2(pgm, PARAM2_AREF1, &uaref) != 0) {
pmsg_error("cannot obtain V[aref][1]\n");
return -1;
}
- if (uaref > (unsigned)utarg * 10) {
+ if(uaref > (unsigned) utarg*10) {
pmsg_warning("reducing V[aref][1] from %.2f V to %.1f\n", uaref/100.0, v);
- uaref = 10 * (unsigned)utarg;
- if (stk500v2_setparm2(pgm, PARAM2_AREF1, uaref)
- != 0)
+ uaref = 10 * (unsigned) utarg;
+ if(stk500v2_setparm2(pgm, PARAM2_AREF1, uaref)
+ != 0)
return -1;
}
- /*
- * Vtarget on the STK600 can only be adjusted while not being in
- * programming mode.
- */
- if (PDATA(pgm)->lastpart)
- pgm->disable(pgm);
+ // Vtarget on the STK600 can only be adjusted while not being in programming mode
+ if(PDATA(pgm)->lastpart)
+ pgm->disable(pgm);
rv = stk500v2_setparm(pgm, PARAM_VTARGET, utarg);
- if (PDATA(pgm)->lastpart)
- pgm->program_enable(pgm, PDATA(pgm)->lastpart);
+ if(PDATA(pgm)->lastpart)
+ pgm->program_enable(pgm, PDATA(pgm)->lastpart);
return rv;
}
-
static int stk600_set_varef(const PROGRAMMER *pgm, unsigned int chan, double v) {
unsigned char utarg = 0;
- unsigned int uaref = (unsigned)((v + 0.0049) * 100);
+ unsigned int uaref = (unsigned) ((v + 0.0049)*100);
- if (stk500v2_getparm(pgm, PARAM_VTARGET, &utarg) != 0) {
+ if(stk500v2_getparm(pgm, PARAM_VTARGET, &utarg) != 0) {
pmsg_error("cannot obtain V[target]\n");
return -1;
}
- if (uaref > (unsigned)utarg * 10) {
+ if(uaref > (unsigned) utarg*10) {
pmsg_error("V[aref] must not be greater than V[target] = %.1f\n", utarg/10.0);
return -1;
}
- switch (chan)
- {
+ switch (chan) {
case 0:
return stk500v2_setparm2(pgm, PARAM2_AREF0, uaref);
@@ -3491,12 +3390,11 @@ static int stk600_set_varef(const PROGRAMMER *pgm, unsigned int chan, double v)
}
}
-
static int stk600_set_fosc(const PROGRAMMER *pgm, double v) {
unsigned int oct, dac;
- oct = 1.443 * log(v / 1039.0);
- dac = 2048 - (2078.0 * pow(2, (double)(10 + oct))) / v;
+ oct = 1.443*log(v/1039.0);
+ dac = 2048 - (2078.0*pow(2, (double) (10 + oct)))/v;
return stk500v2_setparm2(pgm, PARAM2_CLOCK_CONF, (oct << 12) | (dac << 2));
}
@@ -3504,9 +3402,9 @@ static int stk600_set_fosc(const PROGRAMMER *pgm, double v) {
static int stk600_set_sck_period(const PROGRAMMER *pgm, double v) {
unsigned int sck;
- sck = ceil((16e6 / (2 * 1.0 / v)) - 1);
+ sck = ceil((16e6/(2*1.0/v)) - 1);
- if (sck >= 4096)
+ if(sck >= 4096)
sck = 4095;
return stk500v2_setparm2(pgm, PARAM2_SCK_DURATION, sck);
@@ -3516,40 +3414,42 @@ static int stk500v2_jtag3_set_sck_period(const PROGRAMMER *pgm, double v) {
unsigned char value[3];
unsigned int sck;
- if (v < 1 / (1000.0 * 0xffff))
+ if(v < 1/(1000.0*0xffff))
sck = 0xffff;
- else if (v > 1E-3)
+ else if(v > 1E-3)
sck = 1;
else
- sck = 1.0 / (1000.0 * v);
+ sck = 1.0/(1000.0*v);
value[0] = CMD_SET_SCK;
value[1] = sck & 0xff;
value[2] = (sck >> 8) & 0xff;
- if (stk500v2_jtag3_send(pgm, value, 3) < 0)
+ if(stk500v2_jtag3_send(pgm, value, 3) < 0)
return -1;
- if (stk500v2_jtag3_recv(pgm, value, 3) < 0)
+ if(stk500v2_jtag3_recv(pgm, value, 3) < 0)
return -1;
return 0;
}
static int stk500v2_jtag3_get_sck_period(const PROGRAMMER *pgm, double *v) {
unsigned char cmd[4];
+
*v = 0;
cmd[0] = CMD_GET_SCK;
- if (stk500v2_jtag3_send(pgm, cmd, 1) < 0 || stk500v2_jtag3_recv(pgm, cmd, 4) < 2) {
+ if(stk500v2_jtag3_send(pgm, cmd, 1) < 0 || stk500v2_jtag3_recv(pgm, cmd, 4) < 2) {
pmsg_error("cannot read ISP clock speed\n");
return -1;
}
unsigned int sck = cmd[1] | (cmd[2] << 8);
+
if(!sck) {
pmsg_error("reported ISP clock speed not valid\n");
return -1;
}
- *v = 1 / (1000.0 * sck);
+ *v = 1/(1000.0*sck);
return 0;
}
@@ -3559,7 +3459,7 @@ static int stk500v2_getparm(const PROGRAMMER *pgm, unsigned char parm, unsigned
buf[0] = CMD_GET_PARAMETER;
buf[1] = parm;
- if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
+ if(stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
pmsg_error("unable to get parameter 0x%02x\n", parm);
return -1;
}
@@ -3576,7 +3476,7 @@ static int stk500v2_setparm_real(const PROGRAMMER *pgm, unsigned char parm, unsi
buf[1] = parm;
buf[2] = value;
- if (stk500v2_command(pgm, buf, 3, sizeof(buf)) < 0) {
+ if(stk500v2_command(pgm, buf, 3, sizeof(buf)) < 0) {
pmsg_error("unable to set parameter 0x%02x\n", parm);
return -1;
}
@@ -3589,13 +3489,13 @@ static int stk500v2_setparm(const PROGRAMMER *pgm, unsigned char parm, unsigned
int res;
res = stk500v2_getparm(pgm, parm, ¤t_value);
- if (res < 0) {
+ if(res < 0) {
pmsg_error("unable to get parameter 0x%02x\n", parm);
return -1;
}
- // don't issue a write if the correct value is already set.
- if (value == current_value) {
+ // Don't issue a write if the correct value is already set
+ if(value == current_value) {
pmsg_notice2("skipping parameter write; parameter value already set\n");
return 0;
}
@@ -3609,12 +3509,12 @@ static int stk500v2_getparm2(const PROGRAMMER *pgm, unsigned char parm, unsigned
buf[0] = CMD_GET_PARAMETER;
buf[1] = parm;
- if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
+ if(stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
pmsg_error("unable to get parameter 0x%02x\n", parm);
return -1;
}
- *value = ((unsigned)buf[2] << 8) | buf[3];
+ *value = ((unsigned) buf[2] << 8) | buf[3];
return 0;
}
@@ -3627,7 +3527,7 @@ static int stk500v2_setparm2(const PROGRAMMER *pgm, unsigned char parm, unsigned
buf[2] = value >> 8;
buf[3] = value;
- if (stk500v2_command(pgm, buf, 4, sizeof(buf)) < 0) {
+ if(stk500v2_command(pgm, buf, 4, sizeof(buf)) < 0) {
pmsg_error("unable to set parameter 0x%02x\n", parm);
return -1;
}
@@ -3635,40 +3535,35 @@ static int stk500v2_setparm2(const PROGRAMMER *pgm, unsigned char parm, unsigned
return 0;
}
-static const char *stk600_get_cardname(const struct carddata *table,
- size_t nele, int id)
-{
+static const char *stk600_get_cardname(const struct carddata *table, size_t nele, int id) {
const struct carddata *cdp;
- if (id == 0xFF)
- /* 0xFF means this card is not present at all. */
+ if(id == 0xFF)
+ // 0xFF means this card is not present at all
return "Not present";
- for (cdp = table; nele > 0; cdp++, nele--)
- if (cdp->id == id)
+ for(cdp = table; nele > 0; cdp++, nele--)
+ if(cdp->id == id)
return cdp->name;
return "Unknown";
}
-
static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
- unsigned char maj = 0, min = 0, hdw = 0, topcard = 0,
- maj_s1 = 0, min_s1 = 0, maj_s2 = 0, min_s2 = 0;
+ unsigned char maj = 0, min = 0, hdw = 0, topcard = 0, maj_s1 = 0, min_s1 = 0, maj_s2 = 0, min_s2 = 0;
unsigned int rev = 0;
const char *topcard_name;
- if (PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII &&
- PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
+ if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII && PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
msg_info("%sProgrammer model : %s\n", p, pgmname(pgm));
stk500v2_getparm(pgm, PARAM_HW_VER, &hdw);
stk500v2_getparm(pgm, PARAM_SW_MAJOR, &maj);
stk500v2_getparm(pgm, PARAM_SW_MINOR, &min);
msg_info("%sHW version : %d\n", p, hdw);
- if (pgm->usbsn && *pgm->usbsn)
+ if(pgm->usbsn && *pgm->usbsn)
msg_info("%sSerial number : %s\n", p, pgm->usbsn);
msg_info("%sFW Version Controller : %d.%02d\n", p, maj, min);
- if (PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+ if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
stk500v2_getparm(pgm, PARAM_SW_MAJOR_PERIPHERY1, &maj_s1);
stk500v2_getparm(pgm, PARAM_SW_MINOR_PERIPHERY1, &min_s1);
stk500v2_getparm(pgm, PARAM_SW_MAJOR_PERIPHERY2, &maj_s2);
@@ -3678,35 +3573,46 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
}
}
- if (PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
+ if(PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
stk500v2_getparm(pgm, PARAM_TOPCARD_DETECT, &topcard);
switch (topcard) {
- case 0xAA: topcard_name = "STK501"; break;
- case 0x55: topcard_name = "STK502"; break;
- case 0xFA: topcard_name = "STK503"; break;
- case 0xEE: topcard_name = "STK504"; break;
- case 0xE4: topcard_name = "STK505"; break;
- case 0xDD: topcard_name = "STK520"; break;
- default: topcard_name = "Unknown"; break;
+ case 0xAA:
+ topcard_name = "STK501";
+ break;
+ case 0x55:
+ topcard_name = "STK502";
+ break;
+ case 0xFA:
+ topcard_name = "STK503";
+ break;
+ case 0xEE:
+ topcard_name = "STK504";
+ break;
+ case 0xE4:
+ topcard_name = "STK505";
+ break;
+ case 0xDD:
+ topcard_name = "STK520";
+ break;
+ default:
+ topcard_name = "Unknown";
+ break;
}
msg_info("%sTopcard : %s\n", p, topcard_name);
- } else if (PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
+ } else if(PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
stk500v2_getparm(pgm, PARAM_ROUTINGCARD_ID, &topcard);
msg_info("%sRouting card : %s\n", p,
- stk600_get_cardname(routing_cards,
- sizeof routing_cards / sizeof routing_cards[0],
- topcard));
+ stk600_get_cardname(routing_cards, sizeof routing_cards/sizeof routing_cards[0], topcard));
stk500v2_getparm(pgm, PARAM_SOCKETCARD_ID, &topcard);
msg_info("%sSocket card : %s\n", p,
- stk600_get_cardname(socket_cards,
- sizeof socket_cards / sizeof socket_cards[0],
- topcard));
+ stk600_get_cardname(socket_cards, sizeof socket_cards/sizeof socket_cards[0], topcard));
stk500v2_getparm2(pgm, PARAM2_RC_ID_TABLE_REV, &rev);
msg_info("%sRC_ID table rev : %d\n", p, rev);
stk500v2_getparm2(pgm, PARAM2_EC_ID_TABLE_REV, &rev);
msg_info("%sEC_ID table rev : %d\n", p, rev);
- } else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3) {
+ } else if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3) {
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
jtag3_display(pgmcp, p);
pgm_free(pgmcp);
@@ -3716,86 +3622,87 @@ static void stk500v2_display(const PROGRAMMER *pgm, const char *p) {
return;
}
-
static double stk500v2_vtarget_value(const PROGRAMMER *pgm) {
- if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) {
+ if(PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) {
unsigned char vtarget_jtag[4];
+
memset(vtarget_jtag, 0, sizeof vtarget_jtag);
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
jtagmkII_getparm(pgmcp, PAR_OCD_VTARGET, vtarget_jtag);
pgm_free(pgmcp);
- return b2_to_u16(vtarget_jtag) / 1000.0;
+ return b2_to_u16(vtarget_jtag)/1000.0;
}
- if (PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
+ if(PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
unsigned char vtarget = 0;
+
stk500v2_getparm(pgm, PARAM_VTARGET, &vtarget);
- return vtarget / 10.0;
+ return vtarget/10.0;
}
return 0;
}
-
static double stk500v2_sck_duration_value(const PROGRAMMER *pgm) {
unsigned char sck_duration = 0;
unsigned int sck_stk600 = 0;
switch (PDATA(pgm)->pgmtype) {
case PGMTYPE_STK500:
- return stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration) < 0? 0:
- stk500v2_sck_to_us(pgm, sck_duration);
+ return stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration) < 0? 0: stk500v2_sck_to_us(pgm, sck_duration);
case PGMTYPE_AVRISP_MKII:
case PGMTYPE_JTAGICE_MKII:
return stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration) < 0 ||
- sck_duration >= NavrispmkIIfreqs? 0: 1e6 / avrispmkIIfreqs[sck_duration];
+ sck_duration >= NavrispmkIIfreqs? 0: 1e6/avrispmkIIfreqs[sck_duration];
case PGMTYPE_JTAGICE3:
{
unsigned char cmd[4];
+
cmd[0] = CMD_GET_SCK;
- if (stk500v2_jtag3_send(pgm, cmd, 1) >= 0 && stk500v2_jtag3_recv(pgm, cmd, 4) >= 2) {
+ if(stk500v2_jtag3_send(pgm, cmd, 1) >= 0 && stk500v2_jtag3_recv(pgm, cmd, 4) >= 2) {
unsigned int sck = cmd[1] | (cmd[2] << 8);
- return sck? 1E6 / (1000.0 * sck): 0;
+
+ return sck? 1E6/(1000.0*sck): 0;
}
return 0;
}
case PGMTYPE_STK600:
- return stk500v2_getparm2(pgm, PARAM2_SCK_DURATION, &sck_stk600) < 0? 0: (sck_stk600 + 1) / 8.0;
+ return stk500v2_getparm2(pgm, PARAM2_SCK_DURATION, &sck_stk600) < 0? 0: (sck_stk600 + 1)/8.0;
default:
- return sck_duration * 8.0e6 / PDATA(pgm)->xtal + 0.05;
+ return sck_duration*8.0e6/PDATA(pgm)->xtal + 0.05;
}
return 0;
}
-
static double stk500v2_varef_value(const PROGRAMMER *pgm) {
unsigned char vadjust = 0;
- if (stk500v2_getparm(pgm, PARAM_VADJUST, &vadjust) < 0)
- return 0;
- return vadjust / 10.0;
-}
+ if(stk500v2_getparm(pgm, PARAM_VADJUST, &vadjust) < 0)
+ return 0;
+ return vadjust/10.0;
+}
static double stk600_varef_0_value(const PROGRAMMER *pgm) {
unsigned int varef = 0;
- if (stk500v2_getparm2(pgm, PARAM2_AREF0, &varef) < 0)
- return 0;
- return varef / 100.0;
-}
+ if(stk500v2_getparm2(pgm, PARAM2_AREF0, &varef) < 0)
+ return 0;
+ return varef/100.0;
+}
static double stk600_varef_1_value(const PROGRAMMER *pgm) {
unsigned int varef = 0;
- if (stk500v2_getparm2(pgm, PARAM2_AREF1, &varef) < 0)
- return 0;
- return varef / 100.0;
-}
+ if(stk500v2_getparm2(pgm, PARAM2_AREF1, &varef) < 0)
+ return 0;
+ return varef/100.0;
+}
static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
unsigned char osc_pscale = 0, osc_cmatch = 0, sck_duration = 0;
@@ -3805,23 +3712,35 @@ static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
switch (PDATA(pgm)->pgmtype) {
case PGMTYPE_STK500:
- if (stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale) < 0)
+ if(stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale) < 0)
return 0.0;
- if (stk500v2_getparm(pgm, PARAM_OSC_CMATCH, &osc_cmatch) < 0)
+ if(stk500v2_getparm(pgm, PARAM_OSC_CMATCH, &osc_cmatch) < 0)
return 0.0;
- if (osc_pscale == 0)
+ if(osc_pscale == 0)
return 0.0;
prescale = 1;
- fosc = PDATA(pgm)->xtal / 2;
+ fosc = PDATA(pgm)->xtal/2;
switch (osc_pscale) {
- case 2: prescale = 8; break;
- case 3: prescale = 32; break;
- case 4: prescale = 64; break;
- case 5: prescale = 128; break;
- case 6: prescale = 256; break;
- case 7: prescale = 1024; break;
+ case 2:
+ prescale = 8;
+ break;
+ case 3:
+ prescale = 32;
+ break;
+ case 4:
+ prescale = 64;
+ break;
+ case 5:
+ prescale = 128;
+ break;
+ case 6:
+ prescale = 256;
+ break;
+ case 7:
+ prescale = 1024;
+ break;
}
fosc /= prescale;
fosc /= (osc_cmatch + 1);
@@ -3830,14 +3749,14 @@ static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
case PGMTYPE_AVRISP_MKII:
case PGMTYPE_JTAGICE_MKII:
return stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration) < 0 ||
- sck_duration >= NavrispmkIIfreqs? 0: 1e6 / avrispmkIIfreqs[sck_duration];
+ sck_duration >= NavrispmkIIfreqs? 0: 1e6/avrispmkIIfreqs[sck_duration];
case PGMTYPE_STK600:
- if (stk500v2_getparm2(pgm, PARAM2_CLOCK_CONF, &clock_conf) < 0)
+ if(stk500v2_getparm2(pgm, PARAM2_CLOCK_CONF, &clock_conf) < 0)
return 0.0;
oct = (clock_conf & 0xf000) >> 12u;
dac = (clock_conf & 0x0ffc) >> 2u;
- fosc = pow(2, (double)oct) * 2078.0 / (2 - (double)dac / 1024.0);
+ fosc = pow(2, (double) oct)*2078.0/(2 - (double) dac/1024.0);
return fosc;
default:
@@ -3845,25 +3764,24 @@ static double stk500v2_fosc_value(const PROGRAMMER *pgm) {
}
}
-
static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp) {
double f;
int decimals;
const char *unit;
- if (pgm->extra_features & HAS_VTARG_READ) {
+ if(pgm->extra_features & HAS_VTARG_READ) {
fmsg_out(fp, "%sVtarget : %.1f V\n", p, stk500v2_vtarget_value(pgm));
}
switch (PDATA(pgm)->pgmtype) {
case PGMTYPE_STK500:
- if (pgm->extra_features & HAS_VAREF_ADJ) {
+ if(pgm->extra_features & HAS_VAREF_ADJ) {
fmsg_out(fp, "%sVaref : %.1f V\n", p, stk500v2_varef_value(pgm));
}
- if (pgm->extra_features & HAS_FOSC_ADJ) {
+ if(pgm->extra_features & HAS_FOSC_ADJ) {
fmsg_out(fp, "%sOscillator : ", p);
f = stk500v2_fosc_value(pgm);
- if (f == 0.0)
+ if(f == 0.0)
fmsg_out(fp, "Off\n");
else {
decimals = get_decimals(f);
@@ -3872,10 +3790,10 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
}
}
// SCK duration is always available
- fmsg_out(fp, "%sSCK period : %.1f us\n", p,
- stk500v2_sck_duration_value(pgm));
+ fmsg_out(fp, "%sSCK period : %.1f us\n", p, stk500v2_sck_duration_value(pgm));
// XTAL frequency is always available
double f = PDATA(pgm)->xtal;
+
decimals = get_decimals(f);
f = f_to_kHz_MHz(f, &unit);
fmsg_out(fp, "%sXTAL frequency : %.*f %s\n", p, decimals, f, unit);
@@ -3889,16 +3807,19 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
case PGMTYPE_JTAGICE3:
{
unsigned char cmd[4];
+
cmd[0] = CMD_GET_SCK;
- if (stk500v2_jtag3_send(pgm, cmd, 1) >= 0 && stk500v2_jtag3_recv(pgm, cmd, 4) >= 2) {
- unsigned int sck = cmd[1] | (cmd[2] << 8);
- fmsg_out(fp, "%sSCK period : %.1f us\n", p, (1E6 / (1000.0 * sck)));
+ if(stk500v2_jtag3_send(pgm, cmd, 1) >= 0 && stk500v2_jtag3_recv(pgm, cmd, 4) >= 2) {
+ unsigned int sck = cmd[1] | (cmd[2] << 8);
+
+ fmsg_out(fp, "%sSCK period : %.1f us\n", p, (1E6/(1000.0*sck)));
}
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
pgmcp->id = lcreat(NULL, 0);
// Copy pgm->id contents over to pgmcp->id
- for(LNODEID ln=lfirst(pgm->id); ln; ln=lnext(ln))
+ for(LNODEID ln = lfirst(pgm->id); ln; ln = lnext(ln))
ladd(pgmcp->id, mmt_strdup(ldata(ln)));
jtag3_print_parms1(pgmcp, p, fp);
pgm_free(pgmcp);
@@ -3906,12 +3827,12 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
break;
case PGMTYPE_STK600:
- if (pgm->extra_features & HAS_VAREF_ADJ) {
+ if(pgm->extra_features & HAS_VAREF_ADJ) {
fmsg_out(fp, "%sVaref 0 : %.2f V\n", p, stk600_varef_0_value(pgm));
fmsg_out(fp, "%sVaref 1 : %.2f V\n", p, stk600_varef_1_value(pgm));
}
fmsg_out(fp, "%sSCK period : %.1f us\n", p, stk500v2_sck_duration_value(pgm));
- if (pgm->extra_features & HAS_FOSC_ADJ) {
+ if(pgm->extra_features & HAS_FOSC_ADJ) {
f = stk500v2_fosc_value(pgm);
f = f_to_kHz_MHz(f, &unit);
fmsg_out(fp, "%sOscillator : %.3f %s\n", p, f, unit);
@@ -3926,7 +3847,6 @@ static void stk500v2_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp
return;
}
-
static void stk500v2_print_parms(const PROGRAMMER *pgm, FILE *fp) {
stk500v2_print_parms1(pgm, "", fp);
}
@@ -3938,7 +3858,7 @@ static int stk500v2_perform_osccal(const PROGRAMMER *pgm) {
buf[0] = CMD_OSCCAL;
rv = stk500v2_command(pgm, buf, 1, sizeof(buf));
- if (rv < 0) {
+ if(rv < 0) {
pmsg_error("unable to perform oscillator calibaration\n");
return -1;
}
@@ -3947,15 +3867,12 @@ static int stk500v2_perform_osccal(const PROGRAMMER *pgm) {
}
/*
- * Wrapper functions for the JTAG ICE mkII in ISP mode. This mode
- * uses the normal JTAG ICE mkII packet stream to communicate with the
- * ICE, but then encapsulates AVRISP mkII commands using
- * CMND_ISP_PACKET.
+ * Wrapper functions for the JTAG ICE mkII in ISP mode. This mode uses the
+ * normal JTAG ICE mkII packet stream to communicate with the ICE, but then
+ * encapsulates AVRISP mkII commands using CMND_ISP_PACKET.
*/
-/*
- * Open a JTAG ICE mkII in ISP mode.
- */
+// Open a JTAG ICE mkII in ISP mode
static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
union pinfo pinfo;
void *mycookie;
@@ -3965,20 +3882,20 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
/*
* The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
- * attaching. If the config file or command-line parameters specify
- * a higher baud rate, we switch to it later on, after establishing
- * the connection with the ICE.
+ * attaching. If the config file or command-line parameters specify a higher
+ * baud rate, we switch to it later on, after establishing the connection
+ * with the ICE.
*/
pinfo.serialinfo.baud = 19200;
pinfo.serialinfo.cflags = SERIAL_8N1;
/*
- * If the port name starts with "usb", divert the serial routines
- * to the USB ones. The serial_open() function for USB overrides
- * the meaning of the "baud" parameter to be the USB device ID to
- * search for.
+ * If the port name starts with "usb", divert the serial routines to the USB
+ * ones. The serial_open() function for USB overrides the meaning of the
+ * "baud" parameter to be the USB device ID to search for.
*/
- if (str_starts(port, "usb")) {
+ if(str_starts(port, "usb")) {
+
#if defined(HAVE_LIBUSB)
serdev = &usb_serdev;
pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
@@ -3987,7 +3904,7 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
- pgm->fd.usb.eep = 0; /* no seperate EP for events */
+ pgm->fd.usb.eep = 0; // No seperate EP for events
#else
pmsg_error("avrdude was compiled without usb support\n");
return -1;
@@ -3995,20 +3912,18 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
}
pgm->port = port;
- if (serial_open(port, pinfo, &pgm->fd)==-1) {
+ if(serial_open(port, pinfo, &pgm->fd) == -1) {
return -1;
}
- /*
- * drain any extraneous input
- */
+ // Drain any extraneous input
stk500v2_drain(pgm, 0);
mycookie = pgm->cookie;
pgm->cookie = PDATA(pgm)->chained_pdata;
- if ((rv = jtagmkII_getsync(pgm, EMULATOR_MODE_SPI)) != 0) {
- if (rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
- pmsg_error("unable to sync with the JTAG ICE mkII in ISP mode\n");
+ if((rv = jtagmkII_getsync(pgm, EMULATOR_MODE_SPI)) != 0) {
+ if(rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
+ pmsg_error("unable to sync with the JTAG ICE mkII in ISP mode\n");
pgm->cookie = mycookie;
return -1;
}
@@ -4016,20 +3931,16 @@ static int stk500v2_jtagmkII_open(PROGRAMMER *pgm, const char *port) {
PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
return 0;
}
-
-/*
- * Close an AVR Dragon or JTAG ICE mkII in ISP/HVSP/PP mode.
- */
-static void stk500v2_jtagmkII_close(PROGRAMMER * pgm)
-{
+// Close an AVR Dragon or JTAG ICE mkII in ISP/HVSP/PP mode
+static void stk500v2_jtagmkII_close(PROGRAMMER *pgm) {
void *mycookie;
pmsg_notice2("stk500v2_jtagmkII_close()\n");
@@ -4040,12 +3951,8 @@ static void stk500v2_jtagmkII_close(PROGRAMMER * pgm)
pgm->cookie = mycookie;
}
-
-/*
- * Close JTAGICE3.
- */
-static void stk500v2_jtag3_close(PROGRAMMER * pgm)
-{
+// Close JTAGICE3
+static void stk500v2_jtag3_close(PROGRAMMER *pgm) {
void *mycookie;
pmsg_notice2("stk500v2_jtag3_close()\n");
@@ -4056,17 +3963,13 @@ static void stk500v2_jtag3_close(PROGRAMMER * pgm)
pgm->cookie = mycookie;
}
-
/*
- * Wrapper functions for the AVR Dragon in ISP mode. This mode
- * uses the normal JTAG ICE mkII packet stream to communicate with the
- * ICE, but then encapsulates AVRISP mkII commands using
- * CMND_ISP_PACKET.
+ * Wrapper functions for the AVR Dragon in ISP mode. This mode uses the normal
+ * JTAG ICE mkII packet stream to communicate with the ICE, but then
+ * encapsulates AVRISP mkII commands using CMND_ISP_PACKET.
*/
-/*
- * Open an AVR Dragon in ISP mode.
- */
+// Open an AVR Dragon in ISP mode
static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
union pinfo pinfo;
void *mycookie;
@@ -4075,20 +3978,20 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
/*
* The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
- * attaching. If the config file or command-line parameters specify
- * a higher baud rate, we switch to it later on, after establishing
- * the connection with the ICE.
+ * attaching. If the config file or command-line parameters specify a higher
+ * baud rate, we switch to it later on, after establishing the connection
+ * with the ICE.
*/
pinfo.serialinfo.baud = 19200;
pinfo.serialinfo.cflags = SERIAL_8N1;
/*
- * If the port name starts with "usb", divert the serial routines
- * to the USB ones. The serial_open() function for USB overrides
- * the meaning of the "baud" parameter to be the USB device ID to
- * search for.
+ * If the port name starts with "usb", divert the serial routines to the USB
+ * ones. The serial_open() function for USB overrides the meaning of the
+ * "baud" parameter to be the USB device ID to search for.
*/
- if (str_starts(port, "usb")) {
+ if(str_starts(port, "usb")) {
+
#if defined(HAVE_LIBUSB)
serdev = &usb_serdev;
pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
@@ -4097,7 +4000,7 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
- pgm->fd.usb.eep = 0; /* no seperate EP for events */
+ pgm->fd.usb.eep = 0; // No seperate EP for events
#else
pmsg_error("avrdude was compiled without usb support\n");
return -1;
@@ -4105,18 +4008,16 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
}
pgm->port = port;
- if (serial_open(port, pinfo, &pgm->fd)==-1) {
+ if(serial_open(port, pinfo, &pgm->fd) == -1) {
return -1;
}
- /*
- * drain any extraneous input
- */
+ // Drain any extraneous input
stk500v2_drain(pgm, 0);
mycookie = pgm->cookie;
pgm->cookie = PDATA(pgm)->chained_pdata;
- if (jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
+ if(jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
pmsg_error("unable to sync with the AVR Dragon in ISP mode\n");
pgm->cookie = mycookie;
return -1;
@@ -4125,15 +4026,14 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
return 0;
}
-
/*
* Wrapper functions for the AVR Dragon in HV mode. This mode
* uses the normal JTAG ICE mkII packet stream to communicate with the
@@ -4141,9 +4041,7 @@ static int stk500v2_dragon_isp_open(PROGRAMMER *pgm, const char *port) {
* CMND_ISP_PACKET.
*/
-/*
- * Open an AVR Dragon in HV mode (HVSP or parallel).
- */
+// Open an AVR Dragon in HV mode (HVSP or parallel)
static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
union pinfo pinfo;
@@ -4151,20 +4049,20 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
/*
* The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
- * attaching. If the config file or command-line parameters specify
- * a higher baud rate, we switch to it later on, after establishing
- * the connection with the ICE.
+ * attaching. If the config file or command-line parameters specify a higher
+ * baud rate, we switch to it later on, after establishing the connection
+ * with the ICE.
*/
pinfo.serialinfo.baud = 19200;
pinfo.serialinfo.cflags = SERIAL_8N1;
/*
- * If the port name starts with "usb", divert the serial routines
- * to the USB ones. The serial_open() function for USB overrides
- * the meaning of the "baud" parameter to be the USB device ID to
- * search for.
+ * If the port name starts with "usb", divert the serial routines to the USB
+ * ones. The serial_open() function for USB overrides the meaning of the
+ * "baud" parameter to be the USB device ID to search for.
*/
- if (str_starts(port, "usb")) {
+ if(str_starts(port, "usb")) {
+
#if defined(HAVE_LIBUSB)
serdev = &usb_serdev;
pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
@@ -4173,7 +4071,7 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
- pgm->fd.usb.eep = 0; /* no seperate EP for events */
+ pgm->fd.usb.eep = 0; // No seperate EP for events
#else
pmsg_error("avrdude was compiled without usb support\n");
return -1;
@@ -4181,18 +4079,17 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
}
pgm->port = port;
- if (serial_open(port, pinfo, &pgm->fd)==-1) {
+ if(serial_open(port, pinfo, &pgm->fd) == -1) {
return -1;
}
- /*
- * drain any extraneous input
- */
+ // Drain any extraneous input
stk500v2_drain(pgm, 0);
PROGRAMMER *pgmcp = pgm_dup(pgm);
+
pgmcp->cookie = PDATA(pgm)->chained_pdata;
- if (jtagmkII_getsync(pgmcp, EMULATOR_MODE_HV) != 0) {
+ if(jtagmkII_getsync(pgmcp, EMULATOR_MODE_HV) != 0) {
pmsg_error("unable to sync with the AVR Dragon in HV mode\n");
pgm_free(pgmcp);
return -1;
@@ -4200,8 +4097,8 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
pgm_free(pgmcp);
PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
@@ -4209,15 +4106,12 @@ static int stk500v2_dragon_hv_open(PROGRAMMER *pgm, const char *port) {
}
/*
- * Wrapper functions for the JTAGICE3 in ISP mode. This mode
- * uses the normal JTAGICE3 packet stream to communicate with the
- * ICE, but then encapsulates AVRISP mkII commands using
- * scope AVRISP.
+ * Wrapper functions for the JTAGICE3 in ISP mode. This mode uses the normal
+ * JTAGICE3 packet stream to communicate with the ICE, but then encapsulates
+ * AVRISP mkII commands using scope AVRISP.
*/
-/*
- * Open a JTAGICE3 in ISP mode.
- */
+// Open a JTAGICE3 in ISP mode
static int stk500v2_jtag3_open(PROGRAMMER *pgm, const char *port) {
void *mycookie;
int rv;
@@ -4225,14 +4119,14 @@ static int stk500v2_jtag3_open(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("%s()\n", __func__);
rv = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
- if (rv < 0)
+ if(rv < 0)
return rv;
mycookie = pgm->cookie;
pgm->cookie = PDATA(pgm)->chained_pdata;
- if ((rv = jtag3_getsync(pgm, 42)) != 0) {
- if (rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
- pmsg_error("unable to sync with the JTAGICE3 in ISP mode\n");
+ if((rv = jtag3_getsync(pgm, 42)) != 0) {
+ if(rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
+ pmsg_error("unable to sync with the JTAGICE3 in ISP mode\n");
pgm->cookie = mycookie;
return -1;
}
@@ -4240,636 +4134,596 @@ static int stk500v2_jtag3_open(PROGRAMMER *pgm, const char *port) {
PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE3;
- if (pgm->bitclock != 0.0) {
- if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
+ if(pgm->bitclock != 0.0) {
+ if(pgm->set_sck_period(pgm, pgm->bitclock) != 0)
return -1;
}
return 0;
}
-
-/*
- * XPROG wrapper
- */
+// XPROG wrapper
static int stk600_xprog_command(const PROGRAMMER *pgm, unsigned char *b,
- unsigned int cmdsize, unsigned int responsesize)
-{
- unsigned char *newb;
- unsigned int s;
- int rv;
+ unsigned int cmdsize, unsigned int responsesize) {
- if (cmdsize < responsesize)
- s = responsesize;
- else
- s = cmdsize;
+ unsigned char *newb;
+ unsigned int s;
+ int rv;
- newb = mmt_malloc(s + 1);
- newb[0] = CMD_XPROG;
- memcpy(newb + 1, b, cmdsize);
- rv = stk500v2_command(pgm, newb, cmdsize + 1, responsesize + 1);
- if (rv == 0)
- memcpy(b, newb + 1, responsesize);
+ if(cmdsize < responsesize)
+ s = responsesize;
+ else
+ s = cmdsize;
- mmt_free(newb);
+ newb = mmt_malloc(s + 1);
+ newb[0] = CMD_XPROG;
+ memcpy(newb + 1, b, cmdsize);
+ rv = stk500v2_command(pgm, newb, cmdsize + 1, responsesize + 1);
+ if(rv == 0)
+ memcpy(b, newb + 1, responsesize);
- return rv;
+ mmt_free(newb);
+
+ return rv;
}
-
-/*
- * issue the 'program enable' command to the AVR device, XPROG version
- */
+// Issue the 'program enable' command to the AVR device, XPROG version
static int stk600_xprog_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
- unsigned char buf[16];
- unsigned int eepagesize = 42;
- unsigned int nvm_base;
- AVRMEM *mem = NULL;
- int use_tpi;
+ unsigned char buf[16];
+ unsigned int eepagesize = 42;
+ unsigned int nvm_base;
+ AVRMEM *mem = NULL;
+ int use_tpi;
- use_tpi = (p->prog_modes & PM_TPI) != 0;
+ use_tpi = (p->prog_modes & PM_TPI) != 0;
- if (!use_tpi) {
- if (p->nvm_base == 0) {
- pmsg_error("no nvm_base parameter for PDI device\n");
- return -1;
- }
- if ((mem = avr_locate_eeprom(p)) != NULL) {
- if (mem->page_size <= 1) {
- pmsg_error("no EEPROM page_size parameter for PDI device\n");
- return -1;
- }
- eepagesize = mem->page_size;
- }
+ if(!use_tpi) {
+ if(p->nvm_base == 0) {
+ pmsg_error("no nvm_base parameter for PDI device\n");
+ return -1;
}
-
- buf[0] = CMD_XPROG_SETMODE;
- buf[1] = use_tpi? XPRG_MODE_TPI: XPRG_MODE_PDI;
- if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
- pmsg_error("CMD_XPROG_SETMODE(XPRG_MODE_%s) failed\n", use_tpi? "TPI": "PDI");
+ if((mem = avr_locate_eeprom(p)) != NULL) {
+ if(mem->page_size <= 1) {
+ pmsg_error("no EEPROM page_size parameter for PDI device\n");
return -1;
+ }
+ eepagesize = mem->page_size;
+ }
+ }
+
+ buf[0] = CMD_XPROG_SETMODE;
+ buf[1] = use_tpi? XPRG_MODE_TPI: XPRG_MODE_PDI;
+ if(stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
+ pmsg_error("CMD_XPROG_SETMODE(XPRG_MODE_%s) failed\n", use_tpi? "TPI": "PDI");
+ return -1;
+ }
+
+ buf[0] = XPRG_CMD_ENTER_PROGMODE;
+ if(stk600_xprog_command(pgm, buf, 1, 2) < 0) {
+ pmsg_error("XPRG_CMD_ENTER_PROGMODE failed\n");
+ return -1;
+ }
+
+ if(use_tpi) {
+ // Whatever all that might mean, it matches what AVR Studio does
+ if(stk500v2_setparm_real(pgm, PARAM_DISCHARGEDELAY, 232) < 0)
+ return -1;
+
+ buf[0] = XPRG_CMD_SET_PARAM;
+ buf[1] = XPRG_PARAM_NVMCMD_ADDR;
+ buf[2] = 51;
+ if(stk600_xprog_command(pgm, buf, 3, 2) < 0) {
+ pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMCMD_ADDR) failed\n");
+ return -1;
}
- buf[0] = XPRG_CMD_ENTER_PROGMODE;
- if (stk600_xprog_command(pgm, buf, 1, 2) < 0) {
- pmsg_error("XPRG_CMD_ENTER_PROGMODE failed\n");
+ buf[0] = XPRG_CMD_SET_PARAM;
+ buf[1] = XPRG_PARAM_NVMCSR_ADDR;
+ buf[2] = 50;
+ if(stk600_xprog_command(pgm, buf, 3, 2) < 0) {
+ pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMCSR_ADDR) failed\n");
+ return -1;
+ }
+ } else {
+ buf[0] = XPRG_CMD_SET_PARAM;
+ buf[1] = XPRG_PARAM_NVMBASE;
+ nvm_base = p->nvm_base;
+ /*
+ * The 0x01000000 appears to be an indication to the programmer that the
+ * respective address is located in IO (i.e., SRAM) memory address space
+ * rather than flash. This is not documented anywhere in AVR079 but
+ * matches what AVR Studio does.
+ */
+ nvm_base |= 0x01000000;
+ buf[2] = nvm_base >> 24;
+ buf[3] = nvm_base >> 16;
+ buf[4] = nvm_base >> 8;
+ buf[5] = nvm_base;
+ if(stk600_xprog_command(pgm, buf, 6, 2) < 0) {
+ pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMBASE) failed\n");
+ return -1;
+ }
+
+ if(mem != NULL) {
+ buf[0] = XPRG_CMD_SET_PARAM;
+ buf[1] = XPRG_PARAM_EEPPAGESIZE;
+ buf[2] = eepagesize >> 8;
+ buf[3] = eepagesize;
+ if(stk600_xprog_command(pgm, buf, 4, 2) < 0) {
+ pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_EEPPAGESIZE) failed\n");
return -1;
+ }
}
+ }
- if (use_tpi) {
- /*
- * Whatever all that might mean, it matches what AVR Studio
- * does.
- */
- if (stk500v2_setparm_real(pgm, PARAM_DISCHARGEDELAY, 232) < 0)
- return -1;
+ // Read XMEGA chip silicon revision
+ if(p->prog_modes & PM_PDI) {
+ AVRMEM *m = avr_locate_io(p);
+ unsigned char chip_rev[AVR_CHIP_REVLEN];
- buf[0] = XPRG_CMD_SET_PARAM;
- buf[1] = XPRG_PARAM_NVMCMD_ADDR;
- buf[2] = 51;
- if (stk600_xprog_command(pgm, buf, 3, 2) < 0) {
- pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMCMD_ADDR) failed\n");
- return -1;
- }
+ if(m && pgm->read_byte(pgm, p, m, p->mcu_base + 3, chip_rev) >= 0)
+ pmsg_notice("silicon revision: %x.%x\n", chip_rev[0] >> 4, chip_rev[0] & 0x0f);
+ else
+ pmsg_warning("cannot read silicon revision; is avrdude.conf up to date?\n");
+ }
- buf[0] = XPRG_CMD_SET_PARAM;
- buf[1] = XPRG_PARAM_NVMCSR_ADDR;
- buf[2] = 50;
- if (stk600_xprog_command(pgm, buf, 3, 2) < 0) {
- pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMCSR_ADDR) failed\n");
- return -1;
- }
- } else {
- buf[0] = XPRG_CMD_SET_PARAM;
- buf[1] = XPRG_PARAM_NVMBASE;
- nvm_base = p->nvm_base;
- /*
- * The 0x01000000 appears to be an indication to the programmer
- * that the respective address is located in IO (i.e., SRAM)
- * memory address space rather than flash. This is not documented
- * anywhere in AVR079 but matches what AVR Studio does.
- */
- nvm_base |= 0x01000000;
- buf[2] = nvm_base >> 24;
- buf[3] = nvm_base >> 16;
- buf[4] = nvm_base >> 8;
- buf[5] = nvm_base;
- if (stk600_xprog_command(pgm, buf, 6, 2) < 0) {
- pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMBASE) failed\n");
- return -1;
- }
-
- if (mem != NULL) {
- buf[0] = XPRG_CMD_SET_PARAM;
- buf[1] = XPRG_PARAM_EEPPAGESIZE;
- buf[2] = eepagesize >> 8;
- buf[3] = eepagesize;
- if (stk600_xprog_command(pgm, buf, 4, 2) < 0) {
- pmsg_error("XPRG_CMD_SET_PARAM(XPRG_PARAM_EEPPAGESIZE) failed\n");
- return -1;
- }
- }
- }
-
- // Read XMEGA chip silicon revision
- if(p->prog_modes & PM_PDI) {
- AVRMEM *m = avr_locate_io(p);
- unsigned char chip_rev[AVR_CHIP_REVLEN];
- if(m && pgm->read_byte(pgm, p, m, p->mcu_base+3, chip_rev) >= 0)
- pmsg_notice("silicon revision: %x.%x\n", chip_rev[0] >> 4, chip_rev[0] & 0x0f);
- else
- pmsg_warning("cannot read silicon revision; is avrdude.conf up to date?\n");
- }
-
- return 0;
+ return 0;
}
static unsigned char stk600_xprog_mtype(const PROGRAMMER *pgm, unsigned long addr) {
- if (addr >= PDATA(pgm)->boot_start)
- return XPRG_MEM_TYPE_BOOT;
- else
- return XPRG_MEM_TYPE_APPL;
+ if(addr >= PDATA(pgm)->boot_start)
+ return XPRG_MEM_TYPE_BOOT;
+ else
+ return XPRG_MEM_TYPE_APPL;
}
-
static void stk600_xprog_disable(const PROGRAMMER *pgm) {
- unsigned char buf[2];
+ unsigned char buf[2];
- buf[0] = XPRG_CMD_LEAVE_PROGMODE;
- if (stk600_xprog_command(pgm, buf, 1, 2) < 0) {
- pmsg_error("XPRG_CMD_LEAVE_PROGMODE failed\n");
- }
+ buf[0] = XPRG_CMD_LEAVE_PROGMODE;
+ if(stk600_xprog_command(pgm, buf, 1, 2) < 0) {
+ pmsg_error("XPRG_CMD_LEAVE_PROGMODE failed\n");
+ }
}
static int stk600_xprog_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char data)
-{
- unsigned char b[9 + 256];
- int need_erase = 0;
- unsigned char write_size = 1;
- unsigned char memcode;
+ unsigned long addr, unsigned char data) {
+ unsigned char b[9 + 256];
+ int need_erase = 0;
+ unsigned char write_size = 1;
+ unsigned char memcode;
- memset(b, 0, sizeof(b));
+ memset(b, 0, sizeof(b));
- if (mem_is_flash(mem)) {
- memcode = stk600_xprog_mtype(pgm, addr);
- } else if (mem_is_application(mem) || mem_is_apptable(mem)) {
- memcode = XPRG_MEM_TYPE_APPL;
- } else if (mem_is_boot(mem)) {
- memcode = XPRG_MEM_TYPE_BOOT;
- } else if (mem_is_eeprom(mem)) {
- memcode = XPRG_MEM_TYPE_EEPROM;
- } else if (mem_is_io(mem) || mem_is_sram(mem)) {
- memcode = XPRG_MEM_TYPE_APPL;
- addr += avr_data_offset(p);
- } else if (mem_is_lock(mem)) {
- memcode = XPRG_MEM_TYPE_LOCKBITS;
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
- memcode = XPRG_MEM_TYPE_FUSE;
- if (p->prog_modes & PM_TPI)
- need_erase = 1;
- } else if (mem_is_userrow(mem)) {
- memcode = XPRG_MEM_TYPE_USERSIG;
- } else if(mem_is_readonly(mem)) {
- unsigned char is;
- if(pgm->read_byte(pgm, p, mem, addr, &is) >= 0 && is == data)
- return 0;
+ if(mem_is_flash(mem)) {
+ memcode = stk600_xprog_mtype(pgm, addr);
+ } else if(mem_is_application(mem) || mem_is_apptable(mem)) {
+ memcode = XPRG_MEM_TYPE_APPL;
+ } else if(mem_is_boot(mem)) {
+ memcode = XPRG_MEM_TYPE_BOOT;
+ } else if(mem_is_eeprom(mem)) {
+ memcode = XPRG_MEM_TYPE_EEPROM;
+ } else if(mem_is_io(mem) || mem_is_sram(mem)) {
+ memcode = XPRG_MEM_TYPE_APPL;
+ addr += avr_data_offset(p);
+ } else if(mem_is_lock(mem)) {
+ memcode = XPRG_MEM_TYPE_LOCKBITS;
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ memcode = XPRG_MEM_TYPE_FUSE;
+ if(p->prog_modes & PM_TPI)
+ need_erase = 1;
+ } else if(mem_is_userrow(mem)) {
+ memcode = XPRG_MEM_TYPE_USERSIG;
+ } else if(mem_is_readonly(mem)) {
+ unsigned char is;
- pmsg_error("cannot write to read-only memory %s of %s\n", mem->desc, p->desc);
+ if(pgm->read_byte(pgm, p, mem, addr, &is) >= 0 && is == data)
+ return 0;
+
+ pmsg_error("cannot write to read-only memory %s of %s\n", mem->desc, p->desc);
+ return -1;
+ } else {
+ pmsg_error("unsupported memory %s\n", mem->desc);
+ return -1;
+ }
+ addr += mem->offset;
+
+ if(need_erase) {
+ b[0] = XPRG_CMD_ERASE;
+ b[1] = XPRG_ERASE_CONFIG;
+ b[2] = mem->offset >> 24;
+ b[3] = mem->offset >> 16;
+ b[4] = mem->offset >> 8;
+ b[5] = mem->offset + 1;
+ if(stk600_xprog_command(pgm, b, 6, 2) < 0) {
+ pmsg_error("XPRG_CMD_ERASE(XPRG_ERASE_CONFIG) failed\n");
return -1;
- } else {
- pmsg_error("unsupported memory %s\n", mem->desc);
- return -1;
}
- addr += mem->offset;
+ }
- if (need_erase) {
- b[0] = XPRG_CMD_ERASE;
- b[1] = XPRG_ERASE_CONFIG;
- b[2] = mem->offset >> 24;
- b[3] = mem->offset >> 16;
- b[4] = mem->offset >> 8;
- b[5] = mem->offset + 1;
- if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
- pmsg_error("XPRG_CMD_ERASE(XPRG_ERASE_CONFIG) failed\n");
- return -1;
- }
- }
-
- if (p->prog_modes & PM_TPI) {
- /*
- * Some TPI memories (configuration aka. fuse) require a
- * larger write block size. We record that as a blocksize in
- * avrdude.conf.
- */
- if (mem->blocksize != 0)
- write_size = mem->blocksize;
- }
- b[0] = XPRG_CMD_WRITE_MEM;
- b[1] = memcode;
- b[2] = 0; /* pagemode: non-paged write */
- b[3] = addr >> 24;
- b[4] = addr >> 16;
- b[5] = addr >> 8;
- b[6] = addr;
- b[7] = 0;
- b[8] = write_size;
- b[9] = data;
- if (stk600_xprog_command(pgm, b, 9 + write_size, 2) < 0) {
- pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
- return -1;
- }
- return 0;
+ if(p->prog_modes & PM_TPI) {
+ /*
+ * Some TPI memories (configuration aka. fuse) require a larger write block
+ * size. We record that as a blocksize in avrdude.conf.
+ */
+ if(mem->blocksize != 0)
+ write_size = mem->blocksize;
+ }
+ b[0] = XPRG_CMD_WRITE_MEM;
+ b[1] = memcode;
+ b[2] = 0; // Pagemode: non-paged write
+ b[3] = addr >> 24;
+ b[4] = addr >> 16;
+ b[5] = addr >> 8;
+ b[6] = addr;
+ b[7] = 0;
+ b[8] = write_size;
+ b[9] = data;
+ if(stk600_xprog_command(pgm, b, 9 + write_size, 2) < 0) {
+ pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
+ return -1;
+ }
+ return 0;
}
-
static int stk600_xprog_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned long addr, unsigned char * value)
-{
- unsigned char b[8];
+ unsigned long addr, unsigned char *value) {
+ unsigned char b[8];
- if (mem_is_flash(mem)) {
- b[1] = stk600_xprog_mtype(pgm, addr);
- } else if (mem_is_application(mem) || mem_is_apptable(mem)) {
- b[1] = XPRG_MEM_TYPE_APPL;
- } else if (mem_is_boot(mem)) {
- b[1] = XPRG_MEM_TYPE_BOOT;
- } else if (mem_is_eeprom(mem)) {
- b[1] = XPRG_MEM_TYPE_EEPROM;
- } else if (mem_is_io(mem) || mem_is_sram(mem)) {
- b[1] = XPRG_MEM_TYPE_APPL;
- addr += avr_data_offset(p);
- } else if (mem_is_signature(mem)) {
- b[1] = XPRG_MEM_TYPE_APPL;
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
- b[1] = XPRG_MEM_TYPE_FUSE;
- } else if (mem_is_lock(mem)) {
- b[1] = XPRG_MEM_TYPE_LOCKBITS;
- } else if (mem_is_calibration(mem) || mem_is_in_sigrow(mem)) {
- b[1] = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
- } else if (mem_is_userrow(mem)) {
- b[1] = XPRG_MEM_TYPE_USERSIG;
- } else {
- pmsg_error("unsupported memory %s\n", mem->desc);
- return -1;
- }
- addr += mem->offset;
+ if(mem_is_flash(mem)) {
+ b[1] = stk600_xprog_mtype(pgm, addr);
+ } else if(mem_is_application(mem) || mem_is_apptable(mem)) {
+ b[1] = XPRG_MEM_TYPE_APPL;
+ } else if(mem_is_boot(mem)) {
+ b[1] = XPRG_MEM_TYPE_BOOT;
+ } else if(mem_is_eeprom(mem)) {
+ b[1] = XPRG_MEM_TYPE_EEPROM;
+ } else if(mem_is_io(mem) || mem_is_sram(mem)) {
+ b[1] = XPRG_MEM_TYPE_APPL;
+ addr += avr_data_offset(p);
+ } else if(mem_is_signature(mem)) {
+ b[1] = XPRG_MEM_TYPE_APPL;
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ b[1] = XPRG_MEM_TYPE_FUSE;
+ } else if(mem_is_lock(mem)) {
+ b[1] = XPRG_MEM_TYPE_LOCKBITS;
+ } else if(mem_is_calibration(mem) || mem_is_in_sigrow(mem)) {
+ b[1] = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
+ } else if(mem_is_userrow(mem)) {
+ b[1] = XPRG_MEM_TYPE_USERSIG;
+ } else {
+ pmsg_error("unsupported memory %s\n", mem->desc);
+ return -1;
+ }
+ addr += mem->offset;
+
+ b[0] = XPRG_CMD_READ_MEM;
+ b[2] = addr >> 24;
+ b[3] = addr >> 16;
+ b[4] = addr >> 8;
+ b[5] = addr;
+ b[6] = 0;
+ b[7] = 1;
+ if(stk600_xprog_command(pgm, b, 8, 3) < 0) {
+ pmsg_error("XPRG_CMD_READ_MEM failed\n");
+ return -1;
+ }
+ *value = b[2];
+ return 0;
+}
+
+static int stk600_xprog_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
+ unsigned char *b;
+ unsigned int offset;
+ unsigned char mtype;
+ int n_bytes_orig = n_bytes, dynamic_mtype = 0;
+ unsigned long use_ext_addr = 0;
+
+ // The XPROG read command supports at most 256 bytes in one transfer
+ if(page_size > 256)
+ page_size = 256; // Not really a page size anymore
+
+ /*
+ * Fancy offsets everywhere. This is probably what AVR079 means when writing
+ * about the "TIF address space".
+ */
+ if(mem_is_flash(mem)) {
+ mtype = 0;
+ dynamic_mtype = 1;
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_application(mem) || mem_is_apptable(mem)) {
+ mtype = XPRG_MEM_TYPE_APPL;
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_boot(mem)) {
+ mtype = XPRG_MEM_TYPE_BOOT;
+ // @@@ Should consider flash size instead to decide whether to use extended addressing
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_eeprom(mem)) {
+ mtype = XPRG_MEM_TYPE_EEPROM;
+ } else if(mem_is_io(mem) || mem_is_sram(mem)) {
+ mtype = XPRG_MEM_TYPE_APPL;
+ addr += avr_data_offset(p);
+ } else if(mem_is_signature(mem)) {
+ mtype = XPRG_MEM_TYPE_APPL;
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ mtype = XPRG_MEM_TYPE_FUSE;
+ } else if(mem_is_lock(mem)) {
+ mtype = XPRG_MEM_TYPE_LOCKBITS;
+ } else if(mem_is_calibration(mem) || mem_is_in_sigrow(mem)) {
+ mtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
+ } else if(mem_is_userrow(mem)) {
+ mtype = XPRG_MEM_TYPE_USERSIG;
+ } else {
+ pmsg_error("unsupported memory %s\n", mem->desc);
+ return -1;
+ }
+ offset = addr;
+ addr += mem->offset;
+
+ b = mmt_malloc(page_size + 2);
+ if(stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
+ mmt_free(b);
+ return -1;
+ }
+
+ while(n_bytes != 0) {
+ if(dynamic_mtype)
+ mtype = stk600_xprog_mtype(pgm, addr - mem->offset);
b[0] = XPRG_CMD_READ_MEM;
+ b[1] = mtype;
b[2] = addr >> 24;
b[3] = addr >> 16;
b[4] = addr >> 8;
b[5] = addr;
- b[6] = 0;
- b[7] = 1;
- if (stk600_xprog_command(pgm, b, 8, 3) < 0) {
- pmsg_error("XPRG_CMD_READ_MEM failed\n");
- return -1;
+ b[6] = page_size >> 8;
+ b[7] = page_size;
+ if(stk600_xprog_command(pgm, b, 8, page_size + 2) < 0) {
+ pmsg_error("XPRG_CMD_READ_MEM failed\n");
+ mmt_free(b);
+ return -1;
}
- *value = b[2];
- return 0;
-}
-
-
-static int stk600_xprog_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
- unsigned char *b;
- unsigned int offset;
- unsigned char mtype;
- int n_bytes_orig = n_bytes, dynamic_mtype = 0;
- unsigned long use_ext_addr = 0;
-
- /*
- * The XPROG read command supports at most 256 bytes in one
- * transfer.
- */
- if (page_size > 256)
- page_size = 256; /* not really a page size anymore */
-
- /*
- * Fancy offsets everywhere.
- * This is probably what AVR079 means when writing about the
- * "TIF address space".
- */
- if (mem_is_flash(mem)) {
- mtype = 0;
- dynamic_mtype = 1;
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_application(mem) || mem_is_apptable(mem)) {
- mtype = XPRG_MEM_TYPE_APPL;
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_boot(mem)) {
- mtype = XPRG_MEM_TYPE_BOOT;
- // Do we have to consider the total amount of flash
- // instead to decide whether to use extended addressing?
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_eeprom(mem)) {
- mtype = XPRG_MEM_TYPE_EEPROM;
- } else if (mem_is_io(mem) || mem_is_sram(mem)) {
- mtype = XPRG_MEM_TYPE_APPL;
- addr += avr_data_offset(p);
- } else if (mem_is_signature(mem)) {
- mtype = XPRG_MEM_TYPE_APPL;
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
- mtype = XPRG_MEM_TYPE_FUSE;
- } else if (mem_is_lock(mem)) {
- mtype = XPRG_MEM_TYPE_LOCKBITS;
- } else if (mem_is_calibration(mem) || mem_is_in_sigrow(mem)) {
- mtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
- } else if (mem_is_userrow(mem)) {
- mtype = XPRG_MEM_TYPE_USERSIG;
- } else {
- pmsg_error("unsupported memory %s\n", mem->desc);
- return -1;
+ memcpy(mem->buf + offset, b + 2, page_size);
+ if(n_bytes < page_size) {
+ n_bytes = page_size;
}
- offset = addr;
- addr += mem->offset;
+ offset += page_size;
+ addr += page_size;
+ n_bytes -= page_size;
+ }
+ mmt_free(b);
- b = mmt_malloc(page_size + 2);
- if (stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
- mmt_free(b);
- return -1;
- }
-
- while (n_bytes != 0) {
- if (dynamic_mtype)
- mtype = stk600_xprog_mtype(pgm, addr - mem->offset);
-
- b[0] = XPRG_CMD_READ_MEM;
- b[1] = mtype;
- b[2] = addr >> 24;
- b[3] = addr >> 16;
- b[4] = addr >> 8;
- b[5] = addr;
- b[6] = page_size >> 8;
- b[7] = page_size;
- if (stk600_xprog_command(pgm, b, 8, page_size + 2) < 0) {
- pmsg_error("XPRG_CMD_READ_MEM failed\n");
- mmt_free(b);
- return -1;
- }
- memcpy(mem->buf + offset, b + 2, page_size);
- if (n_bytes < page_size) {
- n_bytes = page_size;
- }
- offset += page_size;
- addr += page_size;
- n_bytes -= page_size;
- }
- mmt_free(b);
-
- return n_bytes_orig;
+ return n_bytes_orig;
}
static int stk600_xprog_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem,
- unsigned int page_size,
- unsigned int addr, unsigned int n_bytes)
-{
- unsigned char *b;
- unsigned int offset;
- unsigned char mtype;
- int n_bytes_orig = n_bytes, dynamic_mtype = 0;
- size_t writesize;
- unsigned long use_ext_addr = 0;
- unsigned char writemode;
+ unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
+ unsigned char *b;
+ unsigned int offset;
+ unsigned char mtype;
+ int n_bytes_orig = n_bytes, dynamic_mtype = 0;
+ size_t writesize;
+ unsigned long use_ext_addr = 0;
+ unsigned char writemode;
- /*
- * The XPROG read command supports at most 256 bytes in one
- * transfer.
- */
- if (page_size > 512) {
- pmsg_error("cannot handle page size > 512\n");
- return -1;
- }
+ // The XPROG read command supports at most 256 bytes in one transfer
+ if(page_size > 512) {
+ pmsg_error("cannot handle page size > 512\n");
+ return -1;
+ }
- /*
- * Fancy offsets everywhere.
- * This is probably what AVR079 means when writing about the
- * "TIF address space".
- */
- if (mem_is_flash(mem)) {
- mtype = 0;
- dynamic_mtype = 1;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_application(mem) || mem_is_apptable(mem)) {
- mtype = XPRG_MEM_TYPE_APPL;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_boot(mem)) {
- mtype = XPRG_MEM_TYPE_BOOT;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- // Do we have to consider the total amount of flash
- // instead to decide whether to use extended addressing?
- if (mem->size > 64 * 1024)
- use_ext_addr = (1UL << 31);
- } else if (mem_is_eeprom(mem)) {
- mtype = XPRG_MEM_TYPE_EEPROM;
- writemode = (1 << XPRG_MEM_WRITE_WRITE) | (1 << XPRG_MEM_WRITE_ERASE);
- } else if (mem_is_signature(mem)) {
- mtype = XPRG_MEM_TYPE_APPL;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- } else if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
- mtype = XPRG_MEM_TYPE_FUSE;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- } else if (mem_is_lock(mem)) {
- mtype = XPRG_MEM_TYPE_LOCKBITS;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- } else if (mem_is_calibration(mem)) {
- mtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- } else if (mem_is_userrow(mem)) {
- mtype = XPRG_MEM_TYPE_USERSIG;
- writemode = (1 << XPRG_MEM_WRITE_WRITE);
- } else {
- pmsg_error("unsupported memory %s\n", mem->desc);
- return -1;
- }
- offset = addr;
- addr += mem->offset;
+ /*
+ * Fancy offsets everywhere. This is probably what AVR079 means when writing
+ * about the "TIF address space".
+ */
+ if(mem_is_flash(mem)) {
+ mtype = 0;
+ dynamic_mtype = 1;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_application(mem) || mem_is_apptable(mem)) {
+ mtype = XPRG_MEM_TYPE_APPL;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_boot(mem)) {
+ mtype = XPRG_MEM_TYPE_BOOT;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ // @@@ Should consider flash size instead to decide whether to use extended addressing
+ if(mem->size > 64*1024)
+ use_ext_addr = (1UL << 31);
+ } else if(mem_is_eeprom(mem)) {
+ mtype = XPRG_MEM_TYPE_EEPROM;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE) | (1 << XPRG_MEM_WRITE_ERASE);
+ } else if(mem_is_signature(mem)) {
+ mtype = XPRG_MEM_TYPE_APPL;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ } else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
+ mtype = XPRG_MEM_TYPE_FUSE;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ } else if(mem_is_lock(mem)) {
+ mtype = XPRG_MEM_TYPE_LOCKBITS;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ } else if(mem_is_calibration(mem)) {
+ mtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ } else if(mem_is_userrow(mem)) {
+ mtype = XPRG_MEM_TYPE_USERSIG;
+ writemode = (1 << XPRG_MEM_WRITE_WRITE);
+ } else {
+ pmsg_error("unsupported memory %s\n", mem->desc);
+ return -1;
+ }
+ offset = addr;
+ addr += mem->offset;
- b = mmt_malloc(page_size + 9);
- if (stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
+ b = mmt_malloc(page_size + 9);
+ if(stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
+ mmt_free(b);
+ return -1;
+ }
+
+ while(n_bytes != 0) {
+
+ if(dynamic_mtype)
+ mtype = stk600_xprog_mtype(pgm, addr - mem->offset);
+
+ if(page_size > 256) {
+ /*
+ * AVR079 is not quite clear. While it suggests that downloading up to
+ * 512 bytes (256 words) were OK, it obviously isn't -- 512-byte pages on
+ * the ATxmega128A1 are getting corrupted when written as a single piece.
+ * It writes random junk somewhere beyond byte 256. Splitting it into 256
+ * byte chunks, and only setting the erase page/write page bits in the
+ * final chunk helps.
+ */
+ if(page_size%256 != 0) {
+ pmsg_error("page size not multiple of 256\n");
mmt_free(b);
return -1;
+ }
+ unsigned int chunk;
+
+ for(chunk = 0; chunk < page_size; chunk += 256) {
+ if(n_bytes < 256) {
+ memset(b + 9 + n_bytes, 0xff, 256 - n_bytes);
+ writesize = n_bytes;
+ } else {
+ writesize = 256;
+ }
+ b[0] = XPRG_CMD_WRITE_MEM;
+ b[1] = mtype;
+ b[2] = writemode;
+ b[3] = addr >> 24;
+ b[4] = addr >> 16;
+ b[5] = addr >> 8;
+ b[6] = addr;
+ b[7] = 1;
+ b[8] = 0;
+ memcpy(b + 9, mem->buf + offset, writesize);
+ if(stk600_xprog_command(pgm, b, 256 + 9, 2) < 0) {
+ pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
+ mmt_free(b);
+ return -1;
+ }
+ if(n_bytes < 256)
+ n_bytes = 256;
+
+ offset += 256;
+ addr += 256;
+ n_bytes -= 256;
+ }
+ } else {
+ if(n_bytes < page_size) {
+ // This can easily happen if the input file was not a multiple of the page size
+ memset(b + 9 + n_bytes, 0xff, page_size - n_bytes);
+ writesize = n_bytes;
+ } else {
+ writesize = page_size;
+ }
+ b[0] = XPRG_CMD_WRITE_MEM;
+ b[1] = mtype;
+ b[2] = writemode;
+ b[3] = addr >> 24;
+ b[4] = addr >> 16;
+ b[5] = addr >> 8;
+ b[6] = addr;
+ b[7] = page_size >> 8;
+ b[8] = page_size;
+ memcpy(b + 9, mem->buf + offset, writesize);
+ if(stk600_xprog_command(pgm, b, page_size + 9, 2) < 0) {
+ pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
+ mmt_free(b);
+ return -1;
+ }
+ if(n_bytes < page_size)
+ n_bytes = page_size;
+
+ offset += page_size;
+ addr += page_size;
+ n_bytes -= page_size;
}
+ }
+ mmt_free(b);
- while (n_bytes != 0) {
-
- if (dynamic_mtype)
- mtype = stk600_xprog_mtype(pgm, addr - mem->offset);
-
- if (page_size > 256) {
- /*
- * AVR079 is not quite clear. While it suggests that
- * downloading up to 512 bytes (256 words) were OK, it
- * obviously isn't -- 512-byte pages on the ATxmega128A1
- * are getting corrupted when written as a single piece.
- * It writes random junk somewhere beyond byte 256.
- * Splitting it into 256 byte chunks, and only setting the
- * erase page / write page bits in the final chunk helps.
- */
- if (page_size % 256 != 0) {
- pmsg_error("page size not multiple of 256\n");
- mmt_free(b);
- return -1;
- }
- unsigned int chunk;
- for (chunk = 0; chunk < page_size; chunk += 256) {
- if (n_bytes < 256) {
- memset(b + 9 + n_bytes, 0xff, 256 - n_bytes);
- writesize = n_bytes;
- } else {
- writesize = 256;
- }
- b[0] = XPRG_CMD_WRITE_MEM;
- b[1] = mtype;
- b[2] = writemode;
- b[3] = addr >> 24;
- b[4] = addr >> 16;
- b[5] = addr >> 8;
- b[6] = addr;
- b[7] = 1;
- b[8] = 0;
- memcpy(b + 9, mem->buf + offset, writesize);
- if (stk600_xprog_command(pgm, b, 256 + 9, 2) < 0) {
- pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
- mmt_free(b);
- return -1;
- }
- if (n_bytes < 256)
- n_bytes = 256;
-
- offset += 256;
- addr += 256;
- n_bytes -= 256;
- }
- } else {
- if (n_bytes < page_size) {
- /*
- * This can easily happen if the input file was not a
- * multiple of the page size.
- */
- memset(b + 9 + n_bytes, 0xff, page_size - n_bytes);
- writesize = n_bytes;
- } else {
- writesize = page_size;
- }
- b[0] = XPRG_CMD_WRITE_MEM;
- b[1] = mtype;
- b[2] = writemode;
- b[3] = addr >> 24;
- b[4] = addr >> 16;
- b[5] = addr >> 8;
- b[6] = addr;
- b[7] = page_size >> 8;
- b[8] = page_size;
- memcpy(b + 9, mem->buf + offset, writesize);
- if (stk600_xprog_command(pgm, b, page_size + 9, 2) < 0) {
- pmsg_error("XPRG_CMD_WRITE_MEM failed\n");
- mmt_free(b);
- return -1;
- }
- if (n_bytes < page_size)
- n_bytes = page_size;
-
- offset += page_size;
- addr += page_size;
- n_bytes -= page_size;
- }
- }
- mmt_free(b);
-
- return n_bytes_orig;
+ return n_bytes_orig;
}
static int stk600_xprog_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
- unsigned char b[6];
- AVRMEM *mem;
- unsigned int addr = 0;
+ unsigned char b[6];
+ AVRMEM *mem;
+ unsigned int addr = 0;
- if (p->prog_modes & PM_TPI) {
- if ((mem = avr_locate_flash(p)) == NULL) {
- pmsg_error("no FLASH definition found for TPI device\n");
- return -1;
- }
- addr = mem->offset + 1;
- }
-
- b[0] = XPRG_CMD_ERASE;
- b[1] = XPRG_ERASE_CHIP;
- b[2] = addr >> 24;
- b[3] = addr >> 16;
- b[4] = addr >> 8;
- b[5] = addr;
- if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
- pmsg_error("XPRG_CMD_ERASE(XPRG_ERASE_CHIP) failed\n");
- return -1;
- }
- return 0;
-}
-
-static int stk600_xprog_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
- unsigned int addr)
-{
- unsigned char b[6];
-
- if (mem_is_flash(m)) {
- b[1] = stk600_xprog_mtype(pgm, addr) == XPRG_MEM_TYPE_APPL?
- XPRG_ERASE_APP_PAGE: XPRG_ERASE_BOOT_PAGE;
- } else if (mem_is_application(m) || mem_is_apptable(m)) {
- b[1] = XPRG_ERASE_APP_PAGE;
- } else if (mem_is_boot(m)) {
- b[1] = XPRG_ERASE_BOOT_PAGE;
- } else if (mem_is_eeprom(m)) {
- b[1] = XPRG_ERASE_EEPROM_PAGE;
- } else if (mem_is_userrow(m)) {
- b[1] = XPRG_ERASE_USERSIG;
- } else {
- pmsg_error("unknown paged memory %s\n", m->desc);
+ if(p->prog_modes & PM_TPI) {
+ if((mem = avr_locate_flash(p)) == NULL) {
+ pmsg_error("no FLASH definition found for TPI device\n");
return -1;
}
- addr += m->offset;
- b[0] = XPRG_CMD_ERASE;
- b[2] = addr >> 24;
- b[3] = addr >> 16;
- b[4] = addr >> 8;
- b[5] = addr;
- if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
- pmsg_error("XPRG_CMD_ERASE(%d) failed\n", b[1]);
- return -1;
- }
- return 0;
+ addr = mem->offset + 1;
+ }
+
+ b[0] = XPRG_CMD_ERASE;
+ b[1] = XPRG_ERASE_CHIP;
+ b[2] = addr >> 24;
+ b[3] = addr >> 16;
+ b[4] = addr >> 8;
+ b[5] = addr;
+ if(stk600_xprog_command(pgm, b, 6, 2) < 0) {
+ pmsg_error("XPRG_CMD_ERASE(XPRG_ERASE_CHIP) failed\n");
+ return -1;
+ }
+ return 0;
}
-/*
- * Modify pgm's methods for XPROG operation.
- */
-static void stk600_setup_xprog(PROGRAMMER * pgm)
-{
- pgm->program_enable = stk600_xprog_program_enable;
- pgm->disable = stk600_xprog_disable;
- pgm->read_byte = stk600_xprog_read_byte;
- pgm->write_byte = stk600_xprog_write_byte;
- pgm->paged_load = stk600_xprog_paged_load;
- pgm->paged_write = stk600_xprog_paged_write;
- pgm->page_erase = stk600_xprog_page_erase;
- pgm->chip_erase = stk600_xprog_chip_erase;
+static int stk600_xprog_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, unsigned int addr) {
+ unsigned char b[6];
+
+ if(mem_is_flash(m)) {
+ b[1] = stk600_xprog_mtype(pgm, addr) == XPRG_MEM_TYPE_APPL? XPRG_ERASE_APP_PAGE: XPRG_ERASE_BOOT_PAGE;
+ } else if(mem_is_application(m) || mem_is_apptable(m)) {
+ b[1] = XPRG_ERASE_APP_PAGE;
+ } else if(mem_is_boot(m)) {
+ b[1] = XPRG_ERASE_BOOT_PAGE;
+ } else if(mem_is_eeprom(m)) {
+ b[1] = XPRG_ERASE_EEPROM_PAGE;
+ } else if(mem_is_userrow(m)) {
+ b[1] = XPRG_ERASE_USERSIG;
+ } else {
+ pmsg_error("unknown paged memory %s\n", m->desc);
+ return -1;
+ }
+ addr += m->offset;
+ b[0] = XPRG_CMD_ERASE;
+ b[2] = addr >> 24;
+ b[3] = addr >> 16;
+ b[4] = addr >> 8;
+ b[5] = addr;
+ if(stk600_xprog_command(pgm, b, 6, 2) < 0) {
+ pmsg_error("XPRG_CMD_ERASE(%d) failed\n", b[1]);
+ return -1;
+ }
+ return 0;
}
+// Modify pgm's methods for XPROG operation
+static void stk600_setup_xprog(PROGRAMMER *pgm) {
+ pgm->program_enable = stk600_xprog_program_enable;
+ pgm->disable = stk600_xprog_disable;
+ pgm->read_byte = stk600_xprog_read_byte;
+ pgm->write_byte = stk600_xprog_write_byte;
+ pgm->paged_load = stk600_xprog_paged_load;
+ pgm->paged_write = stk600_xprog_paged_write;
+ pgm->page_erase = stk600_xprog_page_erase;
+ pgm->chip_erase = stk600_xprog_chip_erase;
+}
-/*
- * Modify pgm's methods for ISP operation.
- */
-static void stk600_setup_isp(PROGRAMMER * pgm)
-{
+// Modify pgm's methods for ISP operation
+static void stk600_setup_isp(PROGRAMMER *pgm) {
pgm->program_enable = stk500v2_program_enable;
pgm->disable = stk500v2_disable;
pgm->read_byte = stk500isp_read_byte;
@@ -4885,50 +4739,44 @@ const char stk500v2_desc[] = "Atmel STK500 Version 2.x firmware";
void stk500v2_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK500V2");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500v2_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500v2_disable;
+ // Mandatory functions
+ pgm->initialize = stk500v2_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500v2_disable;
pgm->program_enable = stk500v2_program_enable;
- pgm->chip_erase = stk500v2_chip_erase;
- pgm->cmd = stk500v2_cmd;
- pgm->open = stk500v2_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500isp_read_byte;
- pgm->write_byte = stk500isp_write_byte;
+ pgm->chip_erase = stk500v2_chip_erase;
+ pgm->cmd = stk500v2_cmd;
+ pgm->open = stk500v2_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500isp_read_byte;
+ pgm->write_byte = stk500isp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500v2_paged_write;
- pgm->paged_load = stk500v2_paged_load;
- pgm->page_erase = NULL;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500v2_paged_write;
+ pgm->paged_load = stk500v2_paged_load;
+ pgm->page_erase = NULL;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->perform_osccal = stk500v2_perform_osccal;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
- /*
- * hardware dependent functions
- */
- if (pgm->extra_features & HAS_VTARG_ADJ)
- pgm->set_vtarget = stk500v2_set_vtarget;
- if (pgm->extra_features & HAS_VTARG_READ)
- pgm->get_vtarget = stk500v2_get_vtarget;
- if (pgm->extra_features & HAS_VAREF_ADJ) {
- pgm->set_varef = stk500v2_set_varef;
- pgm->get_varef = stk500v2_get_varef;
+ // Hardware dependent functions
+ if(pgm->extra_features & HAS_VTARG_ADJ)
+ pgm->set_vtarget = stk500v2_set_vtarget;
+ if(pgm->extra_features & HAS_VTARG_READ)
+ pgm->get_vtarget = stk500v2_get_vtarget;
+ if(pgm->extra_features & HAS_VAREF_ADJ) {
+ pgm->set_varef = stk500v2_set_varef;
+ pgm->get_varef = stk500v2_get_varef;
}
- if (pgm->extra_features & HAS_FOSC_ADJ) {
- pgm->set_fosc = stk500v2_set_fosc;
- pgm->get_fosc = stk500v2_get_fosc;
+ if(pgm->extra_features & HAS_FOSC_ADJ) {
+ pgm->set_fosc = stk500v2_set_fosc;
+ pgm->get_fosc = stk500v2_get_fosc;
}
}
@@ -4937,41 +4785,35 @@ const char stk500pp_desc[] = "Atmel STK500 V2 in parallel programming mode";
void stk500pp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK500PP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500pp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500pp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500pp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500pp_disable;
pgm->program_enable = stk500pp_program_enable;
- pgm->chip_erase = stk500pp_chip_erase;
- pgm->open = stk500v2_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500pp_read_byte;
- pgm->write_byte = stk500pp_write_byte;
+ pgm->chip_erase = stk500pp_chip_erase;
+ pgm->open = stk500v2_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500pp_read_byte;
+ pgm->write_byte = stk500pp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500pp_paged_write;
- pgm->paged_load = stk500pp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500pp_paged_write;
+ pgm->paged_load = stk500pp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
- /*
- * hardware dependent functions
- */
- if (pgm->extra_features & HAS_VTARG_ADJ)
- pgm->set_vtarget = stk500v2_set_vtarget;
- if (pgm->extra_features & HAS_VAREF_ADJ)
- pgm->set_varef = stk500v2_set_varef;
- if (pgm->extra_features & HAS_FOSC_ADJ)
- pgm->set_fosc = stk500v2_set_fosc;
+ // Hardware dependent functions
+ if(pgm->extra_features & HAS_VTARG_ADJ)
+ pgm->set_vtarget = stk500v2_set_vtarget;
+ if(pgm->extra_features & HAS_VAREF_ADJ)
+ pgm->set_varef = stk500v2_set_varef;
+ if(pgm->extra_features & HAS_FOSC_ADJ)
+ pgm->set_fosc = stk500v2_set_fosc;
}
const char stk500hvsp_desc[] = "Atmel STK500 V2 in high-voltage serial programming mode";
@@ -4979,41 +4821,35 @@ const char stk500hvsp_desc[] = "Atmel STK500 V2 in high-voltage serial programmi
void stk500hvsp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK500HVSP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500hvsp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500hvsp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500hvsp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500hvsp_disable;
pgm->program_enable = stk500hvsp_program_enable;
- pgm->chip_erase = stk500hvsp_chip_erase;
- pgm->open = stk500v2_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500hvsp_read_byte;
- pgm->write_byte = stk500hvsp_write_byte;
+ pgm->chip_erase = stk500hvsp_chip_erase;
+ pgm->open = stk500v2_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500hvsp_read_byte;
+ pgm->write_byte = stk500hvsp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500hvsp_paged_write;
- pgm->paged_load = stk500hvsp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500hvsp_paged_write;
+ pgm->paged_load = stk500hvsp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
- /*
- * hardware dependent functions
- */
- if (pgm->extra_features & HAS_VTARG_ADJ)
- pgm->set_vtarget = stk500v2_set_vtarget;
- if (pgm->extra_features & HAS_VAREF_ADJ)
- pgm->set_varef = stk500v2_set_varef;
- if (pgm->extra_features & HAS_FOSC_ADJ)
- pgm->set_fosc = stk500v2_set_fosc;
+ // Hardware dependent functions
+ if(pgm->extra_features & HAS_VTARG_ADJ)
+ pgm->set_vtarget = stk500v2_set_vtarget;
+ if(pgm->extra_features & HAS_VAREF_ADJ)
+ pgm->set_varef = stk500v2_set_varef;
+ if(pgm->extra_features & HAS_FOSC_ADJ)
+ pgm->set_fosc = stk500v2_set_fosc;
}
const char stk500v2_jtagmkII_desc[] = "Atmel JTAG ICE mkII in ISP mode";
@@ -5021,34 +4857,30 @@ const char stk500v2_jtagmkII_desc[] = "Atmel JTAG ICE mkII in ISP mode";
void stk500v2_jtagmkII_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "JTAGMKII_ISP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500v2_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500v2_disable;
+ // Mandatory functions
+ pgm->initialize = stk500v2_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500v2_disable;
pgm->program_enable = stk500v2_program_enable;
- pgm->chip_erase = stk500v2_chip_erase;
- pgm->cmd = stk500v2_cmd;
- pgm->open = stk500v2_jtagmkII_open;
- pgm->close = stk500v2_jtagmkII_close;
- pgm->read_byte = stk500isp_read_byte;
- pgm->write_byte = stk500isp_write_byte;
+ pgm->chip_erase = stk500v2_chip_erase;
+ pgm->cmd = stk500v2_cmd;
+ pgm->open = stk500v2_jtagmkII_open;
+ pgm->close = stk500v2_jtagmkII_close;
+ pgm->read_byte = stk500isp_read_byte;
+ pgm->write_byte = stk500isp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500v2_paged_write;
- pgm->paged_load = stk500v2_paged_load;
- pgm->page_erase = NULL;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500v2_paged_write;
+ pgm->paged_load = stk500v2_paged_load;
+ pgm->page_erase = NULL;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period_mk2;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->perform_osccal = stk500v2_perform_osccal;
- pgm->setup = stk500v2_jtagmkII_setup;
- pgm->teardown = stk500v2_jtagmkII_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_jtagmkII_setup;
+ pgm->teardown = stk500v2_jtagmkII_teardown;
+ pgm->page_size = 256;
}
const char stk500v2_dragon_isp_desc[] = "Atmel AVR Dragon in ISP mode";
@@ -5056,34 +4888,30 @@ const char stk500v2_dragon_isp_desc[] = "Atmel AVR Dragon in ISP mode";
void stk500v2_dragon_isp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "DRAGON_ISP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500v2_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500v2_disable;
+ // Mandatory functions
+ pgm->initialize = stk500v2_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500v2_disable;
pgm->program_enable = stk500v2_program_enable;
- pgm->chip_erase = stk500v2_chip_erase;
- pgm->cmd = stk500v2_cmd;
- pgm->open = stk500v2_dragon_isp_open;
- pgm->close = stk500v2_jtagmkII_close;
- pgm->read_byte = stk500isp_read_byte;
- pgm->write_byte = stk500isp_write_byte;
+ pgm->chip_erase = stk500v2_chip_erase;
+ pgm->cmd = stk500v2_cmd;
+ pgm->open = stk500v2_dragon_isp_open;
+ pgm->close = stk500v2_jtagmkII_close;
+ pgm->read_byte = stk500isp_read_byte;
+ pgm->write_byte = stk500isp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500v2_paged_write;
- pgm->paged_load = stk500v2_paged_load;
- pgm->page_erase = NULL;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500v2_paged_write;
+ pgm->paged_load = stk500v2_paged_load;
+ pgm->page_erase = NULL;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period_mk2;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->perform_osccal = stk500v2_perform_osccal;
- pgm->setup = stk500v2_jtagmkII_setup;
- pgm->teardown = stk500v2_jtagmkII_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_jtagmkII_setup;
+ pgm->teardown = stk500v2_jtagmkII_teardown;
+ pgm->page_size = 256;
}
const char stk500v2_dragon_pp_desc[] = "Atmel AVR Dragon in PP mode";
@@ -5091,31 +4919,27 @@ const char stk500v2_dragon_pp_desc[] = "Atmel AVR Dragon in PP mode";
void stk500v2_dragon_pp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "DRAGON_PP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500pp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500pp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500pp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500pp_disable;
pgm->program_enable = stk500pp_program_enable;
- pgm->chip_erase = stk500pp_chip_erase;
- pgm->open = stk500v2_dragon_hv_open;
- pgm->close = stk500v2_jtagmkII_close;
- pgm->read_byte = stk500pp_read_byte;
- pgm->write_byte = stk500pp_write_byte;
+ pgm->chip_erase = stk500pp_chip_erase;
+ pgm->open = stk500v2_dragon_hv_open;
+ pgm->close = stk500v2_jtagmkII_close;
+ pgm->read_byte = stk500pp_read_byte;
+ pgm->write_byte = stk500pp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500pp_paged_write;
- pgm->paged_load = stk500pp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500pp_paged_write;
+ pgm->paged_load = stk500pp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period_mk2;
pgm->get_sck_period = stk500v2_get_sck_period;
- pgm->setup = stk500v2_jtagmkII_setup;
- pgm->teardown = stk500v2_jtagmkII_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_jtagmkII_setup;
+ pgm->teardown = stk500v2_jtagmkII_teardown;
+ pgm->page_size = 256;
}
const char stk500v2_dragon_hvsp_desc[] = "Atmel AVR Dragon in HVSP mode";
@@ -5123,31 +4947,27 @@ const char stk500v2_dragon_hvsp_desc[] = "Atmel AVR Dragon in HVSP mode";
void stk500v2_dragon_hvsp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "DRAGON_HVSP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500hvsp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500hvsp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500hvsp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500hvsp_disable;
pgm->program_enable = stk500hvsp_program_enable;
- pgm->chip_erase = stk500hvsp_chip_erase;
- pgm->open = stk500v2_dragon_hv_open;
- pgm->close = stk500v2_jtagmkII_close;
- pgm->read_byte = stk500hvsp_read_byte;
- pgm->write_byte = stk500hvsp_write_byte;
+ pgm->chip_erase = stk500hvsp_chip_erase;
+ pgm->open = stk500v2_dragon_hv_open;
+ pgm->close = stk500v2_jtagmkII_close;
+ pgm->read_byte = stk500hvsp_read_byte;
+ pgm->write_byte = stk500hvsp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500hvsp_paged_write;
- pgm->paged_load = stk500hvsp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500hvsp_paged_write;
+ pgm->paged_load = stk500hvsp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_set_sck_period_mk2;
pgm->get_sck_period = stk500v2_get_sck_period;
- pgm->setup = stk500v2_jtagmkII_setup;
- pgm->teardown = stk500v2_jtagmkII_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_jtagmkII_setup;
+ pgm->teardown = stk500v2_jtagmkII_teardown;
+ pgm->page_size = 256;
}
const char stk600_desc[] = "Atmel STK600";
@@ -5155,41 +4975,37 @@ const char stk600_desc[] = "Atmel STK600";
void stk600_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK600");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500v2_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500v2_disable;
+ // Mandatory functions
+ pgm->initialize = stk500v2_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500v2_disable;
pgm->program_enable = stk500v2_program_enable;
- pgm->chip_erase = stk500v2_chip_erase;
- pgm->cmd = stk500v2_cmd;
- pgm->open = stk600_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500isp_read_byte;
- pgm->write_byte = stk500isp_write_byte;
+ pgm->chip_erase = stk500v2_chip_erase;
+ pgm->cmd = stk500v2_cmd;
+ pgm->open = stk600_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500isp_read_byte;
+ pgm->write_byte = stk500isp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500v2_paged_write;
- pgm->paged_load = stk500v2_paged_load;
- pgm->page_erase = NULL;
- pgm->print_parms = stk500v2_print_parms;
- pgm->set_vtarget = stk600_set_vtarget;
- pgm->get_vtarget = stk500v2_get_vtarget;
- pgm->set_varef = stk600_set_varef;
- pgm->get_varef = stk500v2_get_varef;
- pgm->set_fosc = stk600_set_fosc;
- pgm->get_fosc = stk500v2_get_fosc;
+ // Optional functions
+ pgm->paged_write = stk500v2_paged_write;
+ pgm->paged_load = stk500v2_paged_load;
+ pgm->page_erase = NULL;
+ pgm->print_parms = stk500v2_print_parms;
+ pgm->set_vtarget = stk600_set_vtarget;
+ pgm->get_vtarget = stk500v2_get_vtarget;
+ pgm->set_varef = stk600_set_varef;
+ pgm->get_varef = stk500v2_get_varef;
+ pgm->set_fosc = stk600_set_fosc;
+ pgm->get_fosc = stk500v2_get_fosc;
pgm->set_sck_period = stk600_set_sck_period;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->perform_osccal = stk500v2_perform_osccal;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
}
const char stk600pp_desc[] = "Atmel STK600 in parallel programming mode";
@@ -5197,38 +5013,34 @@ const char stk600pp_desc[] = "Atmel STK600 in parallel programming mode";
void stk600pp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK600PP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500pp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500pp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500pp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500pp_disable;
pgm->program_enable = stk500pp_program_enable;
- pgm->chip_erase = stk500pp_chip_erase;
- pgm->open = stk600_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500pp_read_byte;
- pgm->write_byte = stk500pp_write_byte;
+ pgm->chip_erase = stk500pp_chip_erase;
+ pgm->open = stk600_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500pp_read_byte;
+ pgm->write_byte = stk500pp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500pp_paged_write;
- pgm->paged_load = stk500pp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
- pgm->set_vtarget = stk600_set_vtarget;
- pgm->get_vtarget = stk500v2_get_vtarget;
- pgm->set_varef = stk600_set_varef;
- pgm->get_varef = stk500v2_get_varef;
- pgm->set_fosc = stk600_set_fosc;
- pgm->get_fosc = stk500v2_get_fosc;
+ // Optional functions
+ pgm->paged_write = stk500pp_paged_write;
+ pgm->paged_load = stk500pp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
+ pgm->set_vtarget = stk600_set_vtarget;
+ pgm->get_vtarget = stk500v2_get_vtarget;
+ pgm->set_varef = stk600_set_varef;
+ pgm->get_varef = stk500v2_get_varef;
+ pgm->set_fosc = stk600_set_fosc;
+ pgm->get_fosc = stk500v2_get_fosc;
pgm->set_sck_period = stk600_set_sck_period;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
}
const char stk600hvsp_desc[] = "Atmel STK600 in high-voltage serial programming mode";
@@ -5236,38 +5048,34 @@ const char stk600hvsp_desc[] = "Atmel STK600 in high-voltage serial programming
void stk600hvsp_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "STK600HVSP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500hvsp_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500hvsp_disable;
+ // Mandatory functions
+ pgm->initialize = stk500hvsp_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500hvsp_disable;
pgm->program_enable = stk500hvsp_program_enable;
- pgm->chip_erase = stk500hvsp_chip_erase;
- pgm->open = stk600_open;
- pgm->close = stk500v2_close;
- pgm->read_byte = stk500hvsp_read_byte;
- pgm->write_byte = stk500hvsp_write_byte;
+ pgm->chip_erase = stk500hvsp_chip_erase;
+ pgm->open = stk600_open;
+ pgm->close = stk500v2_close;
+ pgm->read_byte = stk500hvsp_read_byte;
+ pgm->write_byte = stk500hvsp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500hvsp_paged_write;
- pgm->paged_load = stk500hvsp_paged_load;
- pgm->print_parms = stk500v2_print_parms;
- pgm->set_vtarget = stk600_set_vtarget;
- pgm->get_vtarget = stk500v2_get_vtarget;
- pgm->set_varef = stk600_set_varef;
- pgm->get_varef = stk500v2_get_varef;
- pgm->set_fosc = stk600_set_fosc;
- pgm->get_fosc = stk500v2_get_fosc;
+ // Optional functions
+ pgm->paged_write = stk500hvsp_paged_write;
+ pgm->paged_load = stk500hvsp_paged_load;
+ pgm->print_parms = stk500v2_print_parms;
+ pgm->set_vtarget = stk600_set_vtarget;
+ pgm->get_vtarget = stk500v2_get_vtarget;
+ pgm->set_varef = stk600_set_varef;
+ pgm->get_varef = stk500v2_get_varef;
+ pgm->set_fosc = stk600_set_fosc;
+ pgm->get_fosc = stk500v2_get_fosc;
pgm->set_sck_period = stk600_set_sck_period;
pgm->get_sck_period = stk500v2_get_sck_period;
pgm->parseextparams = stk500v2_parseextparms;
- pgm->setup = stk500v2_setup;
- pgm->teardown = stk500v2_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_setup;
+ pgm->teardown = stk500v2_teardown;
+ pgm->page_size = 256;
}
const char stk500v2_jtag3_desc[] = "Atmel JTAGICE3 in ISP mode";
@@ -5275,41 +5083,35 @@ const char stk500v2_jtag3_desc[] = "Atmel JTAGICE3 in ISP mode";
void stk500v2_jtag3_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "JTAG3_ISP");
- /*
- * mandatory functions
- */
- pgm->initialize = stk500v2_jtag3_initialize;
- pgm->display = stk500v2_display;
- pgm->enable = stk500v2_enable;
- pgm->disable = stk500v2_jtag3_disable;
+ // Mandatory functions
+ pgm->initialize = stk500v2_jtag3_initialize;
+ pgm->display = stk500v2_display;
+ pgm->enable = stk500v2_enable;
+ pgm->disable = stk500v2_jtag3_disable;
pgm->program_enable = stk500v2_program_enable;
- pgm->chip_erase = stk500v2_chip_erase;
- pgm->cmd = stk500v2_jtag3_cmd;
- pgm->open = stk500v2_jtag3_open;
- pgm->close = stk500v2_jtag3_close;
- pgm->read_byte = stk500isp_read_byte;
- pgm->write_byte = stk500isp_write_byte;
+ pgm->chip_erase = stk500v2_chip_erase;
+ pgm->cmd = stk500v2_jtag3_cmd;
+ pgm->open = stk500v2_jtag3_open;
+ pgm->close = stk500v2_jtag3_close;
+ pgm->read_byte = stk500isp_read_byte;
+ pgm->write_byte = stk500isp_write_byte;
- /*
- * optional functions
- */
- pgm->paged_write = stk500v2_paged_write;
- pgm->paged_load = stk500v2_paged_load;
- pgm->page_erase = NULL;
- pgm->print_parms = stk500v2_print_parms;
+ // Optional functions
+ pgm->paged_write = stk500v2_paged_write;
+ pgm->paged_load = stk500v2_paged_load;
+ pgm->page_erase = NULL;
+ pgm->print_parms = stk500v2_print_parms;
pgm->set_sck_period = stk500v2_jtag3_set_sck_period;
pgm->get_sck_period = stk500v2_jtag3_get_sck_period;
pgm->perform_osccal = stk500v2_perform_osccal;
pgm->parseextparams = stk500v2_jtag3_parseextparms;
- pgm->setup = stk500v2_jtag3_setup;
- pgm->teardown = stk500v2_jtag3_teardown;
- pgm->page_size = 256;
+ pgm->setup = stk500v2_jtag3_setup;
+ pgm->teardown = stk500v2_jtag3_teardown;
+ pgm->page_size = 256;
- /*
- * hardware dependent functions
- */
- if (pgm->extra_features & HAS_VTARG_ADJ)
+ // Hardware dependent functions
+ if(pgm->extra_features & HAS_VTARG_ADJ)
pgm->set_vtarget = jtag3_set_vtarget;
- if (pgm->extra_features & HAS_VTARG_READ)
+ if(pgm->extra_features & HAS_VTARG_READ)
pgm->get_vtarget = jtag3_get_vtarget;
}