Mirrors/avrdude
1
0
Fork 0
mirror of https://github.com/avrdudes/avrdude.git synced 2026-06-02 09:46:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

Replace PDATA(pgm)-> with my.

Browse Source
This commit is contained in:
Stefan Rueger
2024-08-18 15:56:29 +01:00
parent 347ca085c3
commit 6d6b0fa861
18 changed files with 874 additions and 874 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/arduino.c
View File

@@ -44,13 +44,13 @@ static int arduino_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
const char *extended_param = ldata(ln);
if(sscanf(extended_param, "attempts=%i", &attempts) == 1) {
PDATA(pgm)->retry_attempts = attempts;
my.retry_attempts = attempts;
pmsg_info("setting number of retry attempts to %d\n", attempts);
continue;
}
if(str_eq(extended_param, "noautoreset")) {
PDATA(pgm)->autoreset = false;
my.autoreset = false;
continue;
}
@@ -121,7 +121,7 @@ static int arduino_open(PROGRAMMER *pgm, const char *port) {
return -1;
}
if(PDATA(pgm)->autoreset) {
if(my.autoreset) {
// This code assumes a negative-logic USB to TTL serial adapter
// Set RTS/DTR high to discharge the series-capacitor, if present
serial_set_dtr_rts(&pgm->fd, 0);

62
src/avr910.c
View File

@@ -50,7 +50,7 @@ struct pdata {
unsigned long caddr;
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// Print error and return when command failed
#define EI(x) do { \
@@ -71,7 +71,7 @@ struct pdata {
static void avr910_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->test_blockmode = 1;
my.test_blockmode = 1;
}
static void avr910_teardown(PROGRAMMER *pgm) {
@@ -165,30 +165,30 @@ static int avr910_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
// See if programmer supports autoincrement of address
EI(avr910_send(pgm, "a", 1));
EI(avr910_recv(pgm, &PDATA(pgm)->has_auto_incr_addr, 1));
if(PDATA(pgm)->has_auto_incr_addr == 'Y')
EI(avr910_recv(pgm, &my.has_auto_incr_addr, 1));
if(my.has_auto_incr_addr == 'Y')
msg_notice("programmer supports auto addr increment\n");
// Check support for buffered memory access, ignore if not available
if(PDATA(pgm)->test_blockmode == 1) {
if(my.test_blockmode == 1) {
EI(avr910_send(pgm, "b", 1));
EI(avr910_recv(pgm, &c, 1));
if(c == 'Y') {
EI(avr910_recv(pgm, &c, 1));
PDATA(pgm)->buffersize = (unsigned int) (unsigned char) c << 8;
my.buffersize = (unsigned int) (unsigned char) c << 8;
EI(avr910_recv(pgm, &c, 1));
PDATA(pgm)->buffersize += (unsigned int) (unsigned char) c;
msg_notice("programmer supports buffered memory access with " "buffersize = %u bytes\n", PDATA(pgm)->buffersize);
PDATA(pgm)->use_blockmode = 1;
my.buffersize += (unsigned int) (unsigned char) c;
msg_notice("programmer supports buffered memory access with " "buffersize = %u bytes\n", my.buffersize);
my.use_blockmode = 1;
} else {
PDATA(pgm)->use_blockmode = 0;
my.use_blockmode = 0;
}
} else {
PDATA(pgm)->use_blockmode = 0;
my.use_blockmode = 0;
}
if(PDATA(pgm)->devcode == 0) {
if(my.devcode == 0) {
char devtype_1st;
int dev_supported = 0;
@@ -226,7 +226,7 @@ static int avr910_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
buf[1] = ovsigck? devtype_1st: p->avr910_devcode;
} else {
// Devcode overridden by -x devcode= option
buf[1] = (char) (PDATA(pgm)->devcode);
buf[1] = (char) (my.devcode);
}
// Tell the programmer which part we selected
@@ -291,13 +291,13 @@ static int avr910_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
break;
}
pmsg_notice2("%s(): devcode overwritten as 0x%02x\n", __func__, devcode);
PDATA(pgm)->devcode = devcode;
my.devcode = devcode;
continue;
}
if(str_eq(extended_param, "no_blockmode")) {
pmsg_notice2("avr910_parseextparms(-x): no testing for Blockmode\n");
PDATA(pgm)->test_blockmode = 0;
my.test_blockmode = 0;
continue;
}
@@ -370,7 +370,7 @@ static int avr910_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
}
addr >>= 1;
PDATA(pgm)->ctype = 0; // Invalidate read cache
my.ctype = 0; // Invalidate read cache
} else if(mem_is_eeprom(m)) {
cmd[0] = 'D';
} else {
@@ -389,8 +389,8 @@ static int avr910_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, const
unsigned long addr, unsigned char *value) {
char buf[2];
if(PDATA(pgm)->ctype == 'F' && PDATA(pgm)->caddr == addr) {
*value = PDATA(pgm)->cvalue;
if(my.ctype == 'F' && my.caddr == addr) {
*value = my.cvalue;
return 0;
}
@@ -400,9 +400,9 @@ static int avr910_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, const
EI(avr910_recv(pgm, buf, sizeof(buf)));
*value = buf[(addr & 1) ^ 1]; // MSB in buffer first
PDATA(pgm)->ctype = 'F';
PDATA(pgm)->cvalue = buf[addr & 1];
PDATA(pgm)->caddr = addr ^ 1;
my.ctype = 'F';
my.cvalue = buf[addr & 1];
my.caddr = addr ^ 1;
return 0;
}
@@ -439,7 +439,7 @@ static int avr910_paged_write_flash(const PROGRAMMER *pgm, const AVRPART *p, con
int page_bytes = page_size;
int page_wr_cmd_pending = 0;
PDATA(pgm)->ctype = 0; // Invalidate read cache
my.ctype = 0; // Invalidate read cache
page_addr = addr;
avr910_set_addr(pgm, addr >> 1);
@@ -471,7 +471,7 @@ static int avr910_paged_write_flash(const PROGRAMMER *pgm, const AVRPART *p, con
page_addr = addr;
page_bytes = page_size;
} else if((PDATA(pgm)->has_auto_incr_addr != 'Y') && ((addr & 0x01) == 0)) {
} else if((my.has_auto_incr_addr != 'Y') && ((addr & 0x01) == 0)) {
avr910_set_addr(pgm, addr >> 1);
}
}
@@ -506,7 +506,7 @@ static int avr910_paged_write_eeprom(const PROGRAMMER *pgm, const AVRPART *p,
addr++;
if(PDATA(pgm)->has_auto_incr_addr != 'Y')
if(my.has_auto_incr_addr != 'Y')
avr910_set_addr(pgm, addr);
}
@@ -517,7 +517,7 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
int isee = mem_is_eeprom(m);
if(PDATA(pgm)->use_blockmode == 0) {
if(my.use_blockmode == 0) {
if(mem_is_flash(m))
return avr910_paged_write_flash(pgm, p, m, page_size, addr, n_bytes);
if(isee)
@@ -525,10 +525,10 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
return -2;
}
if(PDATA(pgm)->use_blockmode == 1) {
if(my.use_blockmode == 1) {
unsigned int max_addr = addr + n_bytes;
char *cmd;
unsigned int blocksize = PDATA(pgm)->buffersize;
unsigned int blocksize = my.buffersize;
if(!mem_is_flash(m) && !isee)
return -2;
@@ -536,7 +536,7 @@ static int avr910_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
if(isee)
blocksize = 1; // Write single bytes only to EEPROM
else
PDATA(pgm)->ctype = 0; // Invalidate read cache
my.ctype = 0; // Invalidate read cache
avr910_set_addr(pgm, isee? addr: addr >> 1);
@@ -584,9 +584,9 @@ static int avr910_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
avr910_set_addr(pgm, isee? addr: addr >> 1);
if(PDATA(pgm)->use_blockmode) {
if(my.use_blockmode) {
// Use buffered mode
int blocksize = PDATA(pgm)->buffersize;
int blocksize = my.buffersize;
cmd[0] = 'g';
cmd[3] = isee? 'E': 'F';
@@ -616,7 +616,7 @@ static int avr910_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
addr += isee? 1: 2;
if(PDATA(pgm)->has_auto_incr_addr != 'Y')
if(my.has_auto_incr_addr != 'Y')
avr910_set_addr(pgm, isee? addr: addr >> 1);
}
}

164
src/buspirate.c
View File

@@ -80,19 +80,19 @@ struct pdata {
char buf_local[100]; // Local buffer for buspirate_readline_noexit()
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// ====== Feature checks ======
static inline int buspirate_uses_ascii(const PROGRAMMER *pgm) {
return (PDATA(pgm)->flag & BP_FLAG_XPARM_FORCE_ASCII);
return (my.flag & BP_FLAG_XPARM_FORCE_ASCII);
}
static inline int buspirate_uses_pullups(const PROGRAMMER *pgm) {
return (PDATA(pgm)->flag & BP_FLAG_PULLUPS);
return (my.flag & BP_FLAG_PULLUPS);
}
static inline int buspirate_uses_hiz(const PROGRAMMER *pgm) {
return (PDATA(pgm)->flag & BP_FLAG_HIZ);
return (my.flag & BP_FLAG_HIZ);
}
// ====== Serial talker functions - binmode ======
@@ -141,7 +141,7 @@ static int buspirate_expect_bin(const PROGRAMMER *pgm,
unsigned char *send_data, size_t send_len, unsigned char *expect_data, size_t expect_len) {
unsigned char *recv_buf = alloca(expect_len);
if((PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) == 0) {
if((my.flag & BP_FLAG_IN_BINMODE) == 0) {
pmsg_error("called from ascii mode\n");
return -1;
}
@@ -163,7 +163,7 @@ static int buspirate_getc(const PROGRAMMER *pgm) {
int rc;
unsigned char ch = 0;
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
pmsg_error("called from binmode\n");
return EOF;
}
@@ -180,8 +180,8 @@ static char *buspirate_readline_noexit(const PROGRAMMER *pgm, char *buf, size_t
long orig_serial_recv_timeout = serial_recv_timeout;
if(buf == NULL) {
buf = PDATA(pgm)->buf_local;
len = sizeof(PDATA(pgm)->buf_local);
buf = my.buf_local;
len = sizeof(my.buf_local);
}
buf_p = buf;
memset(buf, 0, len);
@@ -196,7 +196,7 @@ static char *buspirate_readline_noexit(const PROGRAMMER *pgm, char *buf, size_t
break;
}
buf_p++;
serial_recv_timeout = PDATA(pgm)->serial_recv_timeout;
serial_recv_timeout = my.serial_recv_timeout;
}
serial_recv_timeout = orig_serial_recv_timeout;
pmsg_debug("%s(): %s%s", __func__, buf, *buf && buf[strlen(buf) - 1] == '\n'? "": "\n");
@@ -223,7 +223,7 @@ static int buspirate_send(const PROGRAMMER *pgm, const char *str) {
pmsg_debug("%s(): %s", __func__, str);
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
pmsg_error("called from binmode\n");
return -1;
}
@@ -294,17 +294,17 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
const char *extended_param = ldata(ln);
if(str_eq(extended_param, "ascii")) {
PDATA(pgm)->flag |= BP_FLAG_XPARM_FORCE_ASCII;
my.flag |= BP_FLAG_XPARM_FORCE_ASCII;
continue;
}
if(str_eq(extended_param, "pullups")) {
PDATA(pgm)->flag |= BP_FLAG_PULLUPS;
my.flag |= BP_FLAG_PULLUPS;
continue;
}
if(str_eq(extended_param, "hiz")) {
PDATA(pgm)->flag |= BP_FLAG_HIZ;
my.flag |= BP_FLAG_HIZ;
continue;
}
@@ -314,13 +314,13 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
rv = -1;
break;
}
if(PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ) {
if(my.flag & BP_FLAG_XPARM_RAWFREQ) {
pmsg_error("set either spifreq or rawfreq\n");
rv = -1;
break;
}
PDATA(pgm)->flag |= BP_FLAG_XPARM_SPIFREQ;
PDATA(pgm)->spifreq = spifreq;
my.flag |= BP_FLAG_XPARM_SPIFREQ;
my.spifreq = spifreq;
continue;
}
@@ -330,13 +330,13 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
rv = -1;
break;
}
if(PDATA(pgm)->flag & BP_FLAG_XPARM_SPIFREQ) {
if(my.flag & BP_FLAG_XPARM_SPIFREQ) {
pmsg_error("set either spifreq or rawfreq\n");
rv = -1;
break;
}
PDATA(pgm)->flag |= BP_FLAG_XPARM_RAWFREQ;
PDATA(pgm)->spifreq = rawfreq;
my.flag |= BP_FLAG_XPARM_RAWFREQ;
my.spifreq = rawfreq;
continue;
}
@@ -347,8 +347,8 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
rv = -1;
break;
}
PDATA(pgm)->cpufreq = cpufreq;
PDATA(pgm)->flag |= BP_FLAG_XPARM_CPUFREQ;
my.cpufreq = cpufreq;
my.flag |= BP_FLAG_XPARM_CPUFREQ;
continue;
}
@@ -358,28 +358,28 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
while((resetpin = strtok(preset, ","))) {
preset = NULL; // For subsequent strtok() calls
if(str_caseeq(resetpin, "cs"))
PDATA(pgm)->reset |= BP_RESET_CS;
my.reset |= BP_RESET_CS;
else if(str_caseeq(resetpin, "aux") || str_caseeq(reset, "aux1"))
PDATA(pgm)->reset |= BP_RESET_AUX;
my.reset |= BP_RESET_AUX;
else if(str_caseeq(resetpin, "aux2"))
PDATA(pgm)->reset |= BP_RESET_AUX2;
my.reset |= BP_RESET_AUX2;
else {
pmsg_error("-x reset= value must be either CS, AUX or AUX2\n");
rv = -1;
break;
}
}
PDATA(pgm)->flag |= BP_FLAG_XPARM_RESET;
my.flag |= BP_FLAG_XPARM_RESET;
continue;
}
if(str_eq(extended_param, "nopagedwrite")) {
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
my.flag |= BP_FLAG_NOPAGEDWRITE;
continue;
}
if(str_eq(extended_param, "nopagedread")) {
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
my.flag |= BP_FLAG_NOPAGEDREAD;
continue;
}
@@ -389,7 +389,7 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
rv = -1;
break;
}
PDATA(pgm)->serial_recv_timeout = serial_recv_timeout;
my.serial_recv_timeout = serial_recv_timeout;
continue;
}
@@ -422,15 +422,15 @@ static int buspirate_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
static int buspirate_verifyconfig(const PROGRAMMER *pgm) {
// Default reset pin is CS
if(PDATA(pgm)->reset == 0x00)
PDATA(pgm)->reset |= BP_RESET_CS;
if(my.reset == 0x00)
my.reset |= BP_RESET_CS;
if((PDATA(pgm)->reset != BP_RESET_CS) && buspirate_uses_ascii(pgm)) {
if((my.reset != BP_RESET_CS) && buspirate_uses_ascii(pgm)) {
pmsg_error("RESET pin other than CS is not supported in ASCII mode\n");
return -1;
}
if(((PDATA(pgm)->flag & BP_FLAG_XPARM_SPIFREQ) || (PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ))
if(((my.flag & BP_FLAG_XPARM_SPIFREQ) || (my.flag & BP_FLAG_XPARM_RAWFREQ))
&& buspirate_uses_ascii(pgm)) {
pmsg_error("SPI speed selection is not supported in ASCII mode\n");
return -1;
@@ -472,7 +472,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
buspirate_send_bin(pgm, buf, 1);
buspirate_recv_bin(pgm, buf, 5);
if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
// Disable PWM
if(buspirate_expect_bin_byte(pgm, 0x13, 0x01) != 1) {
pmsg_error("did not get a response to stop PWM command\n");
@@ -495,7 +495,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
rc = buspirate_recv_bin(pgm, buf, sizeof(buf) - 1);
if(buspirate_is_prompt((const char *) buf)) {
PDATA(pgm)->flag &= ~BP_FLAG_IN_BINMODE;
my.flag &= ~BP_FLAG_IN_BINMODE;
break;
}
if(rc == EOF)
@@ -503,7 +503,7 @@ static void buspirate_reset_from_binmode(const PROGRAMMER *pgm) {
memset(buf, '\0', sizeof(buf));
}
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
pmsg_error("reset failed; you may need to powercycle it\n");
return;
}
@@ -519,13 +519,13 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
char config; // Command to setup submode parameters
} submode;
if(PDATA(pgm)->flag & BP_FLAG_XPARM_RAWFREQ) {
if(my.flag & BP_FLAG_XPARM_RAWFREQ) {
submode.name = "Raw-wire";
submode.enter = 0x05;
submode.entered_format = "RAW%1d";
submode.config = 0x8C;
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
my.flag |= BP_FLAG_NOPAGEDWRITE;
my.flag |= BP_FLAG_NOPAGEDREAD;
} else {
submode.name = "SPI";
submode.enter = 0x01;
@@ -551,20 +551,20 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
// Expecting 'BBIOx' reply
memset(buf, 0, sizeof(buf));
buspirate_recv_bin(pgm, buf, 5);
if(sscanf((const char *) buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
if(sscanf((const char *) buf, "BBIO%1d", &my.binmode_version) != 1) {
pmsg_error("binary mode not confirmed: %s\n", buf);
buspirate_reset_from_binmode(pgm);
return -1;
}
msg_notice2("BusPirate binmode version: %d\n", PDATA(pgm)->binmode_version);
msg_notice2("BusPirate binmode version: %d\n", my.binmode_version);
PDATA(pgm)->flag |= BP_FLAG_IN_BINMODE;
my.flag |= BP_FLAG_IN_BINMODE;
if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
unsigned short pwm_duty;
unsigned short pwm_period;
pwm_period = 16000/(PDATA(pgm)->cpufreq) - 1; // Oscillator runs at 32MHz, we don't use a prescaler
pwm_period = 16000/(my.cpufreq) - 1; // Oscillator runs at 32MHz, we don't use a prescaler
pwm_duty = pwm_period/2; // 50% duty cycle
msg_notice2("setting up PWM for cpufreq\n");
@@ -588,13 +588,13 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
buspirate_send_bin(pgm, buf, 1);
memset(buf, 0, sizeof(buf));
buspirate_recv_bin(pgm, buf, 4);
if(sscanf((const char *) buf, submode.entered_format, &PDATA(pgm)->submode_version) != 1) {
if(sscanf((const char *) buf, submode.entered_format, &my.submode_version) != 1) {
pmsg_error("%s mode not confirmed: %s\n", submode.name, buf);
buspirate_reset_from_binmode(pgm);
return -1;
}
msg_notice2("BusPirate %s version: %d\n", submode.name, PDATA(pgm)->submode_version);
if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDWRITE) {
msg_notice2("BusPirate %s version: %d\n", submode.name, my.submode_version);
if(my.flag & BP_FLAG_NOPAGEDWRITE) {
pmsg_notice2("paged flash write disabled\n");
pgm->paged_write = NULL;
} else {
@@ -604,7 +604,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
buspirate_recv_bin(pgm, buf, 1);
if(buf[0] != 0x01) {
// Disable paged write
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDWRITE;
my.flag |= BP_FLAG_NOPAGEDWRITE;
pgm->paged_write = NULL;
// Return to SPI mode (0x00s have landed us back in binary bitbang mode)
@@ -624,18 +624,18 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
* 0b0100wxyz - Configure peripherals w=power, x=pull-ups/aux2, y=AUX, z=CS
* we want power (0x48) and all reset pins high
*/
PDATA(pgm)->current_peripherals_config = 0x48 | PDATA(pgm)->reset;
my.current_peripherals_config = 0x48 | my.reset;
if(buspirate_uses_pullups(pgm)) {
PDATA(pgm)->current_peripherals_config |= 1 << 2;
my.current_peripherals_config |= 1 << 2;
submode.config &= ~(1 << 3);
pmsg_info("enabling pull-ups (open-collector)\n");
}
if(buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
if(buspirate_expect_bin_byte(pgm, my.current_peripherals_config, 0x01) < 0)
return -1;
usleep(50000); // Sleep for 50 ms after power up
// 01100xxx - Set speed
if(buspirate_expect_bin_byte(pgm, 0x60 | PDATA(pgm)->spifreq, 0x01) < 0)
if(buspirate_expect_bin_byte(pgm, 0x60 | my.spifreq, 0x01) < 0)
return -1;
// Submode config
@@ -643,7 +643,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
return -1;
// AVR Extended Commands - test for existence
if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDREAD) {
if(my.flag & BP_FLAG_NOPAGEDREAD) {
pmsg_notice2("paged flash read disabled\n");
pgm->paged_load = NULL;
} else {
@@ -660,7 +660,7 @@ static int buspirate_start_mode_bin(PROGRAMMER *pgm) {
msg_notice2("AVR Extended Commands version %d\n", ver);
} else {
msg_notice2("AVR Extended Commands not found\n");
PDATA(pgm)->flag |= BP_FLAG_NOPAGEDREAD;
my.flag |= BP_FLAG_NOPAGEDREAD;
pgm->paged_load = NULL;
}
}
@@ -783,7 +783,7 @@ static void buspirate_enable(PROGRAMMER *pgm, const AVRPART *p) {
msg_debug("** %s", rcvd);
}
if(!(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)) {
if(!(my.flag & BP_FLAG_IN_BINMODE)) {
msg_info("using ASCII mode\n");
if(buspirate_start_spi_mode_ascii(pgm) < 0) {
pmsg_error("unable to start ascii SPI mode\n");
@@ -793,7 +793,7 @@ static void buspirate_enable(PROGRAMMER *pgm, const AVRPART *p) {
}
static void buspirate_disable(const PROGRAMMER *pgm) {
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
serial_recv_timeout = 100;
buspirate_reset_from_binmode(pgm);
} else {
@@ -808,16 +808,16 @@ static int buspirate_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
static void buspirate_powerup(const PROGRAMMER *pgm) {
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
// Powerup in BinMode is handled in binary mode init
return;
} else {
if(buspirate_expect(pgm, "W\n", "POWER SUPPLIES ON", 1)) {
if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
char buf[25];
int ok = 0;
snprintf(buf, sizeof(buf), "%d\n", PDATA(pgm)->cpufreq);
snprintf(buf, sizeof(buf), "%d\n", my.cpufreq);
if(buspirate_expect(pgm, "g\n", "Frequency in kHz", 1)) {
if(buspirate_expect(pgm, buf, "Duty cycle in %", 1)) {
if(buspirate_expect(pgm, "50\n", "PWM active", 1)) {
@@ -837,11 +837,11 @@ static void buspirate_powerup(const PROGRAMMER *pgm) {
}
static void buspirate_powerdown(const PROGRAMMER *pgm) {
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
// Powerdown in BinMode is handled in binary mode init
return;
} else {
if(PDATA(pgm)->flag & BP_FLAG_XPARM_CPUFREQ) {
if(my.flag & BP_FLAG_XPARM_CPUFREQ) {
if(!buspirate_expect(pgm, "g\n", "PWM disabled", 1)) {
pmsg_error("did not get a response to stop PWM command\n");
}
@@ -903,7 +903,7 @@ static int buspirate_cmd_ascii(const PROGRAMMER *pgm, const unsigned char *cmd,
}
static int buspirate_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)
if(my.flag & BP_FLAG_IN_BINMODE)
return buspirate_cmd_bin(pgm, cmd, res);
else
return buspirate_cmd_ascii(pgm, cmd, res);
@@ -920,7 +920,7 @@ static int buspirate_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const A
msg_debug("buspirate_paged_load(..,%s,%d,%d,%d)\n", m->desc, m->page_size, address, n_bytes);
// This should never happen, but still ...
if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDREAD) {
if(my.flag & BP_FLAG_NOPAGEDREAD) {
pmsg_error("called while in nopagedread mode\n");
return -1;
}
@@ -971,12 +971,12 @@ static int buspirate_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
unsigned char cmd_buf[4096] = { '\0' };
unsigned char send_byte, recv_byte;
if(!(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE)) {
if(!(my.flag & BP_FLAG_IN_BINMODE)) {
// Return if we are not in binary mode
return -1;
}
if(PDATA(pgm)->flag & BP_FLAG_NOPAGEDWRITE) {
if(my.flag & BP_FLAG_NOPAGEDWRITE) {
// Return if we've nominated not to use paged writes
return -1;
}
@@ -1066,10 +1066,10 @@ static int buspirate_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char cmd[4];
unsigned char res[4];
if(PDATA(pgm)->flag & BP_FLAG_IN_BINMODE) {
if(my.flag & BP_FLAG_IN_BINMODE) {
// Clear configured reset pin(s): CS and/or AUX and/or AUX2
PDATA(pgm)->current_peripherals_config &= ~PDATA(pgm)->reset;
if(buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
my.current_peripherals_config &= ~my.reset;
if(buspirate_expect_bin_byte(pgm, my.current_peripherals_config, 0x01) < 0)
return -1;
} else
buspirate_expect(pgm, "{\n", "CS ENABLED", 1);
@@ -1111,7 +1111,7 @@ static int buspirate_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
// Interface - management
static void buspirate_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->serial_recv_timeout = 100;
my.serial_recv_timeout = 100;
}
static void buspirate_teardown(PROGRAMMER *pgm) {
@@ -1174,23 +1174,23 @@ static void buspirate_bb_enable(PROGRAMMER *pgm, const AVRPART *p) {
// Expecting 'BBIOx' reply
memset(buf, 0, sizeof(buf));
buspirate_recv_bin(pgm, buf, 5);
if(sscanf((char *) buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
if(sscanf((char *) buf, "BBIO%1d", &my.binmode_version) != 1) {
pmsg_error("binary mode not confirmed: %s\n", buf);
buspirate_reset_from_binmode(pgm);
return;
}
msg_info("BusPirate binmode version: %d\n", PDATA(pgm)->binmode_version);
msg_info("BusPirate binmode version: %d\n", my.binmode_version);
PDATA(pgm)->flag |= BP_FLAG_IN_BINMODE;
my.flag |= BP_FLAG_IN_BINMODE;
// Set pin directions and an initial pin status (all high)
PDATA(pgm)->pin_dir = 0x12; // AUX, SDI input; everything else output
buf[0] = PDATA(pgm)->pin_dir | 0x40;
my.pin_dir = 0x12; // AUX, SDI input; everything else output
buf[0] = my.pin_dir | 0x40;
buspirate_send_bin(pgm, buf, 1);
buspirate_recv_bin(pgm, buf, 1);
PDATA(pgm)->pin_val = 0x3f; // PULLUP, AUX, SDO, CLK, SDI, CS high
buf[0] = PDATA(pgm)->pin_val | 0x80;
my.pin_val = 0x3f; // PULLUP, AUX, SDO, CLK, SDI, CS high
buf[0] = my.pin_val | 0x80;
buspirate_send_bin(pgm, buf, 1);
buspirate_recv_bin(pgm, buf, 1);
@@ -1229,14 +1229,14 @@ static int buspirate_bb_getpin(const PROGRAMMER *pgm, int pinfunc) {
if(pin < 1 || pin > 5)
return -1;
buf[0] = PDATA(pgm)->pin_dir | 0x40;
buf[0] = my.pin_dir | 0x40;
if(buspirate_send_bin(pgm, buf, 1) < 0)
return -1;
// Read all of the previously-expected-but-unread bytes
while(PDATA(pgm)->unread_bytes > 0) {
while(my.unread_bytes > 0) {
if(buspirate_recv_bin(pgm, buf, 1) < 0)
return -1;
PDATA(pgm)->unread_bytes--;
my.unread_bytes--;
}
// Now read the actual response
@@ -1265,11 +1265,11 @@ static int buspirate_bb_setpin_internal(const PROGRAMMER *pgm, int pin, int valu
msg_debug("set pin %d = %d\n", pin, value);
if(value)
PDATA(pgm)->pin_val |= (1 << (pin - 1));
my.pin_val |= (1 << (pin - 1));
else
PDATA(pgm)->pin_val &= ~(1 << (pin - 1));
my.pin_val &= ~(1 << (pin - 1));
buf[0] = PDATA(pgm)->pin_val | 0x80;
buf[0] = my.pin_val | 0x80;
if(buspirate_send_bin(pgm, buf, 1) < 0)
return -1;
/*
@@ -1277,7 +1277,7 @@ static int buspirate_bb_setpin_internal(const PROGRAMMER *pgm, int pin, int valu
* quick optimization that saves some USB round trips, improving read times
* by a factor of 3.
*/
PDATA(pgm)->unread_bytes++;
my.unread_bytes++;
return 0;
}

34
src/butterfly.c
View File

@@ -56,7 +56,7 @@ struct pdata {
bool autoreset;
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// Print error and return when command failed
#define EI(x) do { \
@@ -251,8 +251,8 @@ static int butterfly_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
// See if programmer supports autoincrement of address
EI(butterfly_send(pgm, "a", 1));
EI(butterfly_recv(pgm, &PDATA(pgm)->has_auto_incr_addr, 1));
if(PDATA(pgm)->has_auto_incr_addr == 'Y')
EI(butterfly_recv(pgm, &my.has_auto_incr_addr, 1));
if(my.has_auto_incr_addr == 'Y')
msg_notice("programmer supports auto addr increment\n");
// Check support for buffered memory access, abort if not available
@@ -264,10 +264,10 @@ static int butterfly_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
};
EI(butterfly_recv(pgm, &c, 1));
PDATA(pgm)->buffersize = (unsigned int) (unsigned char) c << 8;
my.buffersize = (unsigned int) (unsigned char) c << 8;
EI(butterfly_recv(pgm, &c, 1));
PDATA(pgm)->buffersize += (unsigned int) (unsigned char) c;
msg_notice("programmer supports buffered memory access with buffersize=%i bytes\n", PDATA(pgm)->buffersize);
my.buffersize += (unsigned int) (unsigned char) c;
msg_notice("programmer supports buffered memory access with buffersize=%i bytes\n", my.buffersize);
// Get list of devices that the programmer supports
@@ -335,7 +335,7 @@ static int butterfly_open(PROGRAMMER *pgm, const char *port) {
return -1;
}
if(PDATA(pgm)->autoreset) {
if(my.autoreset) {
// This code assumes a negative-logic USB to TTL serial adapter
// Set RTS/DTR high to discharge the series-capacitor, if present
pmsg_notice2("toggling the DTR/RTS lines to trigger a hardware reset\n");
@@ -411,7 +411,7 @@ static int butterfly_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const A
if(mem_is_flash(m)) {
int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
PDATA(pgm)->ctype = 0; // Invalidate read cache
my.ctype = 0; // Invalidate read cache
cmd[0] = 'B';
cmd[1] = 0;
cmd[2] = 2;
@@ -464,8 +464,8 @@ static int butterfly_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, co
return -1;
}
if(PDATA(pgm)->ctype == mtype && PDATA(pgm)->caddr == addr) {
*value = PDATA(pgm)->cvalue;
if(my.ctype == mtype && my.caddr == addr) {
*value = my.cvalue;
return 0;
}
@@ -476,10 +476,10 @@ static int butterfly_read_byte_flash(const PROGRAMMER *pgm, const AVRPART *p, co
EI(butterfly_send(pgm, msg, 4));
EI(butterfly_recv(pgm, buf, sizeof(buf)));
PDATA(pgm)->ctype = mtype;
my.ctype = mtype;
*value = buf[addr & 1];
PDATA(pgm)->cvalue = buf[1 - (addr & 1)];
PDATA(pgm)->caddr = addr ^ 1;
my.cvalue = buf[1 - (addr & 1)];
my.caddr = addr ^ 1;
return 0;
}
@@ -525,7 +525,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
unsigned int max_addr = addr + n_bytes;
char *cmd;
unsigned int blocksize = PDATA(pgm)->buffersize;
unsigned int blocksize = my.buffersize;
int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
int isee = mem_is_eeprom(m);
@@ -535,7 +535,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
if(isee) // Write single bytes to EEPROM
blocksize = 1;
else
PDATA(pgm)->ctype = 0; // Invalidate flash byte read cache
my.ctype = 0; // Invalidate flash byte read cache
(ext_addr? butterfly_set_extaddr: butterfly_set_addr) (pgm, isee? addr: addr >> 1);
@@ -575,7 +575,7 @@ static int butterfly_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
static int butterfly_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
unsigned int max_addr = addr + n_bytes;
int blocksize = PDATA(pgm)->buffersize;
int blocksize = my.buffersize;
int ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
int isee = mem_is_eeprom(m);
@@ -637,7 +637,7 @@ static int butterfly_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
extended_param = ldata(ln);
if(str_eq(extended_param, "autoreset")) {
PDATA(pgm)->autoreset = true;
my.autoreset = true;
continue;
}

30
src/ch341a.c
View File

@@ -96,7 +96,7 @@ struct pdata {
int USB_init; // Used in ch341a_open()
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// ----------------------------------------------------------------------
@@ -128,10 +128,10 @@ static int CH341USBTransferPart(const PROGRAMMER *pgm, enum libusb_endpoint_dire
int ret, bytestransferred;
if(!PDATA(pgm)->usbhandle)
if(!my.usbhandle)
return 0;
if((ret = libusb_bulk_transfer(PDATA(pgm)->usbhandle, CH341A_USB_BULK_ENDPOINT | dir,
if((ret = libusb_bulk_transfer(my.usbhandle, CH341A_USB_BULK_ENDPOINT | dir,
buff, size, &bytestransferred, CH341A_USB_TIMEOUT))) {
pmsg_error("libusb_bulk_transfer for IN_EP failed, return value %d (%s)\n", ret, libusb_error_name(ret));
@@ -203,9 +203,9 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
pmsg_trace("ch341a_open(\"%s\")\n", port);
if(!PDATA(pgm)->USB_init) {
PDATA(pgm)->USB_init = 1;
libusb_init(&PDATA(pgm)->ctx);
if(!my.USB_init) {
my.USB_init = 1;
libusb_init(&my.ctx);
}
if(usbpid) {
@@ -218,7 +218,7 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
vid = pgm->usbvid? pgm->usbvid: CH341A_VID;
libusb_device **dev_list;
int dev_list_len = libusb_get_device_list(PDATA(pgm)->ctx, &dev_list);
int dev_list_len = libusb_get_device_list(my.ctx, &dev_list);
for(j = 0; j < dev_list_len; ++j) {
libusb_device *dev = dev_list[j];
@@ -237,17 +237,17 @@ static int ch341a_open(PROGRAMMER *pgm, const char *port) {
libusb_free_device_list(dev_list, 1);
if(handle != NULL) {
errorCode = 0;
PDATA(pgm)->usbhandle = handle;
my.usbhandle = handle;
}
if(errorCode != 0) {
pmsg_error("could not find USB device with vid=0x%x pid=0x%x\n", vid, pid);
return -1;
}
if((r = libusb_claim_interface(PDATA(pgm)->usbhandle, 0))) {
if((r = libusb_claim_interface(my.usbhandle, 0))) {
pmsg_error("libusb_claim_interface failed, return value %d (%s)\n", r, libusb_error_name(r));
libusb_close(PDATA(pgm)->usbhandle);
libusb_exit(PDATA(pgm)->ctx);
libusb_close(my.usbhandle);
libusb_exit(my.ctx);
return -1;
}
return 0;
@@ -263,11 +263,11 @@ static void ch341a_close(PROGRAMMER *pgm) {
CH341ChipSelect(pgm, cs, false);
if(PDATA(pgm)->usbhandle != NULL) {
libusb_release_interface(PDATA(pgm)->usbhandle, 0);
libusb_close(PDATA(pgm)->usbhandle);
if(my.usbhandle != NULL) {
libusb_release_interface(my.usbhandle, 0);
libusb_close(my.usbhandle);
}
libusb_exit(PDATA(pgm)->ctx);
libusb_exit(my.ctx);
}
static int ch341a_initialize(const PROGRAMMER *pgm, const AVRPART *p) {

236
src/jtag3.c
View File

@@ -133,7 +133,7 @@ struct pdata {
unsigned char signature_cache[2]; // Used in jtag3_read_byte()
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
/*
* pgm->flag is marked as "for private use of the programmer". The following
@@ -463,7 +463,7 @@ int jtag3_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
buf = mmt_malloc(len + 4);
buf[0] = TOKEN;
buf[1] = 0; // Dummy
u16_to_b2(buf + 2, PDATA(pgm)->command_sequence);
u16_to_b2(buf + 2, my.command_sequence);
memcpy(buf + 4, data, len);
if(serial_send(&pgm->fd, buf, len + 4) != 0) {
@@ -514,7 +514,7 @@ static int jtag3_edbg_send(const PROGRAMMER *pgm, unsigned char *data, size_t le
buf[3] = (this_len + 4) & 0xff;
buf[4] = TOKEN;
buf[5] = 0; // Dummy
u16_to_b2(buf + 6, PDATA(pgm)->command_sequence);
u16_to_b2(buf + 6, my.command_sequence);
if(this_len < 0) {
pmsg_error("unexpected this_len = %d\n", this_len);
return -1;
@@ -790,10 +790,10 @@ int jtag3_recv(const PROGRAMMER *pgm, unsigned char **msg) {
rv &= USB_RECV_LENGTH_MASK;
r_seqno = ((*msg)[2] << 8) | (*msg)[1];
pmsg_debug("%s(): got message seqno %d (command_sequence == %d)\n",
__func__, r_seqno, PDATA(pgm)->command_sequence);
if(r_seqno == PDATA(pgm)->command_sequence) {
if(++(PDATA(pgm)->command_sequence) == 0xffff)
PDATA(pgm)->command_sequence = 0;
__func__, r_seqno, my.command_sequence);
if(r_seqno == my.command_sequence) {
if(++(my.command_sequence) == 0xffff)
my.command_sequence = 0;
/*
* We move the payload to the beginning of the buffer, to make the job
* easier for the caller. We have to return the original pointer though,
@@ -809,7 +809,7 @@ int jtag3_recv(const PROGRAMMER *pgm, unsigned char **msg) {
return rv;
}
pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, PDATA(pgm)->command_sequence);
pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, my.command_sequence);
mmt_free(*msg);
}
@@ -913,7 +913,7 @@ static int jtag3_unlock_erase_key(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
mmt_free(resp);
PDATA(pgm)->prog_enabled = 1;
my.prog_enabled = 1;
buf[0] = 0; // Disable
if(jtag3_setparm(pgm, SCOPE_AVR, SET_GET_CTXT_OPTIONS, PARM3_OPT_CHIP_ERASE_TO_ENTER, buf, 1) < 0)
@@ -936,7 +936,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
unsigned char buf[3], *resp;
int status;
if(PDATA(pgm)->prog_enabled)
if(my.prog_enabled)
return 0;
buf[0] = SCOPE_AVR;
@@ -945,7 +945,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
if((status = jtag3_command(pgm, buf, 3, &resp, "enter progmode")) >= 0) {
mmt_free(resp);
PDATA(pgm)->prog_enabled = 1;
my.prog_enabled = 1;
return LIBAVRDUDE_SUCCESS;
}
@@ -956,7 +956,7 @@ static int jtag3_program_enable(const PROGRAMMER *pgm) {
static int jtag3_program_disable(const PROGRAMMER *pgm) {
unsigned char buf[3], *resp;
if(!PDATA(pgm)->prog_enabled)
if(!my.prog_enabled)
return 0;
buf[0] = SCOPE_AVR;
@@ -968,7 +968,7 @@ static int jtag3_program_disable(const PROGRAMMER *pgm) {
mmt_free(resp);
PDATA(pgm)->prog_enabled = 0;
my.prog_enabled = 0;
return 0;
}
@@ -1060,27 +1060,27 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
if(conn == PARM3_CONN_PDI || conn == PARM3_CONN_UPDI)
PDATA(pgm)->set_sck = jtag3_set_sck_xmega_pdi;
my.set_sck = jtag3_set_sck_xmega_pdi;
else if(conn == PARM3_CONN_JTAG) {
if(p->prog_modes & PM_PDI)
PDATA(pgm)->set_sck = jtag3_set_sck_xmega_jtag;
my.set_sck = jtag3_set_sck_xmega_jtag;
else
PDATA(pgm)->set_sck = jtag3_set_sck_mega_jtag;
my.set_sck = jtag3_set_sck_mega_jtag;
}
if(pgm->bitclock != 0.0 && PDATA(pgm)->set_sck != NULL) {
if(pgm->bitclock != 0.0 && my.set_sck != NULL) {
unsigned int clock = 1E-3/pgm->bitclock; // kHz
pmsg_notice2("%s(): trying to set JTAG clock to %u kHz\n", __func__, clock);
parm[0] = clock & 0xff;
parm[1] = (clock >> 8) & 0xff;
if(PDATA(pgm)->set_sck(pgm, parm) < 0)
if(my.set_sck(pgm, parm) < 0)
return -1;
}
if(conn == PARM3_CONN_JTAG) {
pmsg_notice2("%s(): trying to set JTAG daisy-chain info to %d,%d,%d,%d\n", __func__,
PDATA(pgm)->jtagchain[0], PDATA(pgm)->jtagchain[1], PDATA(pgm)->jtagchain[2], PDATA(pgm)->jtagchain[3]);
if(jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_JTAGCHAIN, PDATA(pgm)->jtagchain, 4) < 0)
my.jtagchain[0], my.jtagchain[1], my.jtagchain[2], my.jtagchain[3]);
if(jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_JTAGCHAIN, my.jtagchain, 4) < 0)
return -1;
}
@@ -1088,51 +1088,51 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
jtag3_print_parms1(pgm, progbuf, stderr);
// Read or write SUFFER register
if(PDATA(pgm)->suffer_get || PDATA(pgm)->suffer_set) {
if(my.suffer_get || my.suffer_set) {
// Read existing SUFFER value
if(jtag3_getparm(pgm, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data, 1) < 0) {
MEDBG_REG_SUFFER_OFFSET, my.suffer_data, 1) < 0) {
return -1;
}
if(!PDATA(pgm)->suffer_set)
msg_info("SUFFER register value read as 0x%02x\n", PDATA(pgm)->suffer_data[0]);
if(!my.suffer_set)
msg_info("SUFFER register value read as 0x%02x\n", my.suffer_data[0]);
// Write new SUFFER value
else {
if(jtag3_setparm(pgm, SCOPE_EDBG, MEDBG_REG_SUFFER_BANK + 0x10,
MEDBG_REG_SUFFER_OFFSET, PDATA(pgm)->suffer_data + 1, 1) < 0) {
MEDBG_REG_SUFFER_OFFSET, my.suffer_data + 1, 1) < 0) {
return -1;
}
msg_info("SUFFER register value changed from 0x%02x to 0x%02x\n",
PDATA(pgm)->suffer_data[0], PDATA(pgm)->suffer_data[1]);
my.suffer_data[0], my.suffer_data[1]);
}
}
// Read or write Vtarg switch
if(PDATA(pgm)->vtarg_switch_get || PDATA(pgm)->vtarg_switch_set) {
if(my.vtarg_switch_get || my.vtarg_switch_set) {
// Read existing Vtarg switch value
if(jtag3_getparm(pgm, SCOPE_EDBG, EDBG_CTXT_CONTROL,
EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data, 1) < 0) {
EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data, 1) < 0) {
return -1;
}
if(!PDATA(pgm)->vtarg_switch_set)
msg_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");
if(!my.vtarg_switch_set)
msg_info("Vtarg switch setting read as %u: target power is switched %s\n", my.vtarg_switch_data[0],
my.vtarg_switch_data[0]? "on": "off");
// Write Vtarg switch value
else {
if(jtag3_setparm(pgm, SCOPE_EDBG, EDBG_CTXT_CONTROL,
EDBG_CONTROL_TARGET_POWER, PDATA(pgm)->vtarg_switch_data + 1, 1) < 0) {
EDBG_CONTROL_TARGET_POWER, my.vtarg_switch_data + 1, 1) < 0) {
return -1;
}
imsg_info("Vtarg switch setting changed from %u to %u\n", PDATA(pgm)->vtarg_switch_data[0],
PDATA(pgm)->vtarg_switch_data[1]);
imsg_info("Vtarg switch setting changed from %u to %u\n", my.vtarg_switch_data[0],
my.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) {
if(my.vtarg_switch_data[1] == 0) {
pmsg_info("turn on the Vtarg switch to establish connection with the target\n\n");
return -1;
}
}
}
// Read or write target voltage
if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
if(my.vtarg_get || my.vtarg_set) {
// Read current target voltage set value
unsigned char buf[2];
@@ -1140,14 +1140,14 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
double vtarg_read = b2_to_u16(buf)/1000.0;
if(PDATA(pgm)->vtarg_get)
if(my.vtarg_get)
msg_info("Target voltage value read as %.2fV\n", vtarg_read);
// Write target voltage value
else {
u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, PDATA(pgm)->vtarg_data);
u16_to_b2(buf, (unsigned) (my.vtarg_data*1000));
msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, my.vtarg_data);
if(jtag3_setparm(pgm, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
msg_warning("Cannot set target voltage %.2fV\n", PDATA(pgm)->vtarg_data);
msg_warning("Cannot set target voltage %.2fV\n", my.vtarg_data);
return -1;
}
}
@@ -1167,12 +1167,12 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
m = ldata(ln);
if(mem_is_flash(m)) {
if(m->readsize != 0 && m->readsize < m->page_size)
PDATA(pgm)->flash_pagesize = m->readsize;
my.flash_pagesize = m->readsize;
else
PDATA(pgm)->flash_pagesize = m->page_size;
my.flash_pagesize = m->page_size;
u16_to_b2(xd.flash_page_size, m->page_size);
} else if(mem_is_eeprom(m)) {
PDATA(pgm)->eeprom_pagesize = m->page_size;
my.eeprom_pagesize = m->page_size;
xd.eeprom_page_size = m->page_size;
u16_to_b2(xd.eeprom_size, m->size);
u32_to_b4(xd.nvm_eeprom_offset, m->offset);
@@ -1212,9 +1212,9 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
xd.prog_base_msb = m->offset >> 16;
if(m->readsize != 0 && m->readsize < m->page_size)
PDATA(pgm)->flash_pagesize = m->readsize;
my.flash_pagesize = m->readsize;
else
PDATA(pgm)->flash_pagesize = m->page_size;
my.flash_pagesize = m->page_size;
xd.flash_page_size = m->page_size & 0xFF;
xd.flash_page_size_msb = (m->page_size) >> 8;
@@ -1225,7 +1225,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
else
xd.address_mode = UPDI_ADDRESS_MODE_16BIT;
} else if(mem_is_eeprom(m)) {
PDATA(pgm)->eeprom_pagesize = m->page_size;
my.eeprom_pagesize = m->page_size;
xd.eeprom_page_size = m->page_size;
u16_to_b2(xd.eeprom_bytes, m->size);
@@ -1246,7 +1246,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
// Generate UPDI high-voltage pulse if user asks for it and hardware supports it
if(PDATA(pgm)->use_hvupdi == true && p->hvupdi_variant != HV_UPDI_VARIANT_1) {
if(my.use_hvupdi == true && p->hvupdi_variant != HV_UPDI_VARIANT_1) {
parm[0] = PARM3_UPDI_HV_NONE;
for(LNODEID ln = lfirst(pgm->hvupdi_support); ln; ln = lnext(ln)) {
if(*(int *) ldata(ln) == p->hvupdi_variant) {
@@ -1304,15 +1304,15 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
m = ldata(ln);
if(mem_is_flash(m)) {
if(m->readsize != 0 && m->readsize < m->page_size)
PDATA(pgm)->flash_pagesize = m->readsize;
my.flash_pagesize = m->readsize;
else
PDATA(pgm)->flash_pagesize = m->page_size;
my.flash_pagesize = m->page_size;
u16_to_b2(md.flash_page_size, m->page_size);
u32_to_b4(md.flash_size, (flashsize = m->size));
// Do we need it? Just a wild guess
u32_to_b4(md.boot_address, (m->size - m->page_size*4)/2);
} else if(mem_is_eeprom(m)) {
PDATA(pgm)->eeprom_pagesize = m->page_size;
my.eeprom_pagesize = m->page_size;
md.eeprom_page_size = m->page_size;
u16_to_b2(md.eeprom_size, m->size);
}
@@ -1394,7 +1394,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
mmt_free(resp);
if(pgm->read_sib) {
if(pgm->read_sib(pgm, p, PDATA(pgm)->sib_string) < 0) {
if(pgm->read_sib(pgm, p, my.sib_string) < 0) {
pmsg_warning("cannot read SIB string from target %s\n", p->desc);
}
}
@@ -1406,7 +1406,7 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
pmsg_notice("silicon revision: %x.%x\n", chip_rev[0] >> 4, chip_rev[0] & 0x0f);
}
PDATA(pgm)->boot_start = ULONG_MAX;
my.boot_start = ULONG_MAX;
if(p->prog_modes & PM_PDI) {
// Find the border between application and boot area
AVRMEM *bootmem = avr_locate_boot(p);
@@ -1415,24 +1415,24 @@ static int jtag3_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
if(bootmem == NULL || flashmem == NULL) {
pmsg_error("cannot locate flash or boot memories in description\n");
} else {
PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
my.boot_start = bootmem->offset - flashmem->offset;
}
}
mmt_free(PDATA(pgm)->flash_pagecache);
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
mmt_free(my.flash_pagecache);
mmt_free(my.eeprom_pagecache);
my.flash_pagecache = mmt_malloc(my.flash_pagesize);
my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
return 0;
}
static void jtag3_disable(const PROGRAMMER *pgm) {
mmt_free(PDATA(pgm)->flash_pagecache);
PDATA(pgm)->flash_pagecache = NULL;
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->eeprom_pagecache = NULL;
mmt_free(my.flash_pagecache);
my.flash_pagecache = NULL;
mmt_free(my.eeprom_pagecache);
my.eeprom_pagecache = NULL;
/*
* jtag3_program_disable() doesn't do anything if the device is currently not
@@ -1465,10 +1465,10 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
}
pmsg_notice2("%s(): JTAG chain parsed as:\n", __func__);
imsg_notice2("%u units before, %u units after, %u bits before, %u bits after\n", ub, ua, bb, ba);
PDATA(pgm)->jtagchain[0] = ub;
PDATA(pgm)->jtagchain[1] = ua;
PDATA(pgm)->jtagchain[2] = bb;
PDATA(pgm)->jtagchain[3] = ba;
my.jtagchain[0] = ub;
my.jtagchain[1] = ua;
my.jtagchain[2] = bb;
my.jtagchain[3] = ba;
continue;
}
// HVUPDI
@@ -1487,7 +1487,7 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
rv = -1;
break;
}
PDATA(pgm)->use_hvupdi = true;
my.use_hvupdi = true;
continue;
}
// SUFFER bits
@@ -1500,21 +1500,21 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
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", my.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]);
if((my.suffer_data[1] & 0x78) != 0x78) {
my.suffer_data[1] |= 0x78;
pmsg_info("setting -x suffer=0x%02x so that reserved bits 3..6 are set\n", my.suffer_data[1]);
}
PDATA(pgm)->suffer_set = true;
my.suffer_set = true;
continue;
}
// Get SUFFER value
if(str_eq(extended_param, "suffer")) {
PDATA(pgm)->suffer_get = true;
my.suffer_get = true;
continue;
}
pmsg_error("invalid setting in -x %s; use -x suffer or -x suffer=<n>\n", extended_param);
@@ -1527,19 +1527,19 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
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", my.vtarg_switch_data + 1);
if(sscanf_success < 1 || PDATA(pgm)->vtarg_switch_data[1] > 1) {
if(sscanf_success < 1 || my.vtarg_switch_data[1] > 1) {
pmsg_error("invalid value in -x %s\n", extended_param);
rv = -1;
break;
}
PDATA(pgm)->vtarg_switch_set = true;
my.vtarg_switch_set = true;
continue;
}
// Get Vtarget switch value
if(str_eq(extended_param, "vtarg_switch")) {
PDATA(pgm)->vtarg_switch_get = true;
my.vtarg_switch_get = true;
continue;
}
pmsg_error("invalid setting in -x %s; use -x vtarg_switch or -x vtarg_switch=<0..1>\n", extended_param);
@@ -1555,18 +1555,18 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
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;
my.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;
}
PDATA(pgm)->vtarg_set = true;
my.vtarg_set = true;
continue;
}
// Get target voltage
else if(str_eq(extended_param, "vtarg")) {
PDATA(pgm)->vtarg_get = true;
my.vtarg_get = true;
continue;
}
pmsg_error("invalid setting in -x %s; use -x vtarg or -x vtarg=<dbl>\n", extended_param);
@@ -1578,12 +1578,12 @@ static int jtag3_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
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;
my.pk4_snap_mode = PK4_SNAP_MODE_AVR;
continue;
}
// Flag a switch to PIC mode
if(str_caseeq(extended_param, "mode=pic")) {
PDATA(pgm)->pk4_snap_mode = PK4_SNAP_MODE_PIC;
my.pk4_snap_mode = PK4_SNAP_MODE_PIC;
continue;
}
pmsg_error("invalid setting in -x %s; use -x mode=avr or -x mode=pic\n", extended_param);
@@ -1786,7 +1786,7 @@ int jtag3_open_common(PROGRAMMER *pgm, const char *port, int mode_switch) {
static int jtag3_open(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("jtag3_open()\n");
int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
if(rc < 0)
return rc;
@@ -1797,7 +1797,7 @@ static int jtag3_open(PROGRAMMER *pgm, const char *port) {
static int jtag3_open_dw(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("jtag3_open_dw()\n");
int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
if(rc < 0)
return rc;
@@ -1810,7 +1810,7 @@ static int jtag3_open_dw(PROGRAMMER *pgm, const char *port) {
static int jtag3_open_pdi(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("jtag3_open_pdi()\n");
int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
if(rc < 0)
return rc;
@@ -1828,7 +1828,7 @@ static int jtag3_open_updi(PROGRAMMER *pgm, const char *port) {
msg_notice2(" %d", *(int *) ldata(ln));
msg_notice2("\n");
int rc = jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
int rc = jtag3_open_common(pgm, port, my.pk4_snap_mode);
if(rc < 0)
return rc;
@@ -1883,10 +1883,10 @@ static int jtag3_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRME
if(mem_is_in_flash(m)) {
cmd[3] = is_updi(p) || jtag3_mtype(pgm, p, m, addr) == MTYPE_FLASH? XMEGA_ERASE_APP_PAGE: XMEGA_ERASE_BOOT_PAGE;
PDATA(pgm)->flash_pageaddr = ~0UL;
my.flash_pageaddr = ~0UL;
} else if(mem_is_eeprom(m)) {
cmd[3] = XMEGA_ERASE_EEPROM_PAGE;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_userrow(m)) {
cmd[3] = XMEGA_ERASE_USERSIG;
} else if(mem_is_bootrow(m)) {
@@ -1933,7 +1933,7 @@ static int jtag3_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
cmd[1] = CMD3_WRITE_MEMORY;
cmd[2] = 0;
if(mem_is_flash(m)) {
PDATA(pgm)->flash_pageaddr = ~0UL;
my.flash_pageaddr = ~0UL;
cmd[3] = jtag3_mtype(pgm, p, m, addr);
if(p->prog_modes & PM_PDI)
// Dynamically decide between flash/boot mtype
@@ -1955,7 +1955,7 @@ static int jtag3_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
return n_bytes;
}
cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM_PAGE;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_userrow(m) || mem_is_bootrow(m)) {
cmd[3] = MTYPE_USERSIG;
} else if(mem_is_boot(m)) {
@@ -2126,10 +2126,10 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_FLASH_PAGE;
if(mem_is_in_flash(mem)) {
addr += mem->offset & (512*1024 - 1); // Max 512 KiB flash @@@ could be max 8M
pagesize = PDATA(pgm)->flash_pagesize;
pagesize = my.flash_pagesize;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->flash_pageaddr;
cache_ptr = PDATA(pgm)->flash_pagecache;
paddr_ptr = &my.flash_pageaddr;
cache_ptr = my.flash_pagecache;
} else if(mem_is_eeprom(mem)) {
if((pgm->flag & PGM_FL_IS_DW) || (p->prog_modes & (PM_PDI | PM_UPDI))) {
cmd[3] = MTYPE_EEPROM;
@@ -2138,8 +2138,8 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
}
pagesize = mem->page_size;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
paddr_ptr = &my.eeprom_pageaddr;
cache_ptr = my.eeprom_pagecache;
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[3] = MTYPE_FUSE_BITS;
if(!(p->prog_modes & PM_UPDI) && mem_is_a_fuse(mem))
@@ -2173,11 +2173,11 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
p->desc, addr, AVR_SIBLEN - 1);
return -1;
}
if(!*PDATA(pgm)->sib_string) {
if(!*my.sib_string) {
pmsg_error("cannot read byte from %s sib as memory not initialised\n", p->desc);
return -1;
}
*value = PDATA(pgm)->sib_string[addr];
*value = my.sib_string[addr];
return 0;
} else if(mem_is_signature(mem)) {
cmd[3] = MTYPE_SIGN_JTAG;
@@ -2195,13 +2195,13 @@ static int jtag3_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM
if((status = jtag3_command(pgm, cmd, 12, &resp, "read memory")) < 0)
return status;
PDATA(pgm)->signature_cache[0] = resp[4];
PDATA(pgm)->signature_cache[1] = resp[5];
my.signature_cache[0] = resp[4];
my.signature_cache[1] = resp[5];
*value = resp[3];
mmt_free(resp);
return 0;
} else if(addr <= 2) {
*value = PDATA(pgm)->signature_cache[addr - 1];
*value = my.signature_cache[addr - 1];
return 0;
} else {
// Should not happen
@@ -2300,19 +2300,19 @@ static int jtag3_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRME
cmd[2] = 0;
cmd[3] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_SPM;
if(mem_is_flash(mem)) {
cache_ptr = PDATA(pgm)->flash_pagecache;
pagesize = PDATA(pgm)->flash_pagesize;
PDATA(pgm)->flash_pageaddr = ~0UL;
cache_ptr = my.flash_pagecache;
pagesize = my.flash_pagesize;
my.flash_pageaddr = ~0UL;
if(pgm->flag & PGM_FL_IS_DW)
unsupp = 1;
} else if(mem_is_eeprom(mem)) {
if(pgm->flag & PGM_FL_IS_DW) {
cmd[3] = MTYPE_EEPROM;
} else {
cache_ptr = PDATA(pgm)->eeprom_pagecache;
pagesize = PDATA(pgm)->eeprom_pagesize;
cache_ptr = my.eeprom_pagecache;
pagesize = my.eeprom_pagesize;
}
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[3] = MTYPE_FUSE_BITS;
if(!(p->prog_modes & PM_UPDI) && mem_is_a_fuse(mem))
@@ -2392,12 +2392,12 @@ static int jtag3_set_sck_period(const PROGRAMMER *pgm, double v) {
parm[0] = clock & 0xff;
parm[1] = (clock >> 8) & 0xff;
if(PDATA(pgm)->set_sck == NULL) {
if(my.set_sck == NULL) {
pmsg_error("no backend to set the SCK period for\n");
return -1;
}
return (PDATA(pgm)->set_sck(pgm, parm) < 0)? -1: 0;
return (my.set_sck(pgm, parm) < 0)? -1: 0;
}
static int jtag3_get_sck_period(const PROGRAMMER *pgm, double *v) {
@@ -2769,14 +2769,14 @@ static unsigned char jtag3_mtype(const PROGRAMMER *pgm, const AVRPART *p, const
return
!is_pdi(p)? MTYPE_FLASH_PAGE:
mem_is_boot(m)? MTYPE_BOOT_FLASH:
mem_is_flash(m) && is_pdi(p) && addr >= PDATA(pgm)->boot_start? MTYPE_BOOT_FLASH: MTYPE_FLASH;
mem_is_flash(m) && is_pdi(p) && addr >= my.boot_start? MTYPE_BOOT_FLASH: MTYPE_FLASH;
}
static unsigned int jtag3_memaddr(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, unsigned long addr) {
if(is_pdi(p)) { // Xmega
if(mem_is_flash(m) && addr >= PDATA(pgm)->boot_start) // Boot is special and gets its own region
addr -= PDATA(pgm)->boot_start;
if(mem_is_in_flash(m) && !mem_is_boot(m)) // Apptable, application and flash
if(mem_is_flash(m) && addr >= my.boot_start) // Boot is special and gets its own region
addr -= my.boot_start;
if(mem_is_in_flash(m) && !mem_is_boot(m)) // Apptable, application and flash
addr += avr_flash_offset(p, m, addr);
if(mem_is_in_sigrow(m)) {
AVRMEM *sigrow = avr_locate_sigrow(p);
@@ -2890,7 +2890,7 @@ static int jtag3_initialize_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
int status;
// Read or write target voltage
if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
if(my.vtarg_get || my.vtarg_set) {
// Read current target voltage set value
unsigned char buf[2];
@@ -2898,14 +2898,14 @@ static int jtag3_initialize_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
double vtarg_read = b2_to_u16(buf)/1000.0;
if(PDATA(pgm)->vtarg_get)
if(my.vtarg_get)
msg_info("Target voltage value read as %.2fV\n", vtarg_read);
// Write target voltage value
else {
u16_to_b2(buf, (unsigned) (PDATA(pgm)->vtarg_data*1000));
msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, PDATA(pgm)->vtarg_data);
u16_to_b2(buf, (unsigned) (my.vtarg_data*1000));
msg_info("Changing target voltage from %.2f to %.2fV\n", vtarg_read, my.vtarg_data);
if(jtag3_setparm(pgm, SCOPE_GENERAL, 1, PARM3_VADJUST, buf, sizeof(buf)) < 0) {
msg_warning("Cannot set target voltage %.2fV\n", PDATA(pgm)->vtarg_data);
msg_warning("Cannot set target voltage %.2fV\n", my.vtarg_data);
return -1;
}
}
@@ -3096,7 +3096,7 @@ static int jtag3_chip_erase_tpi(const PROGRAMMER *pgm, const AVRPART *p) {
static int jtag3_open_tpi(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("jtag3_open_tpi()\n");
return jtag3_open_common(pgm, port, PDATA(pgm)->pk4_snap_mode);
return jtag3_open_common(pgm, port, my.pk4_snap_mode);
}
void jtag3_close_tpi(PROGRAMMER *pgm) {

76
src/jtagmkI.c
View File

@@ -50,7 +50,7 @@ struct pdata {
int prog_enabled; // Cached value of PROGRAMMING status
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
/*
* Table of baud rates supported by the mkI ICE, accompanied by their internal
@@ -322,10 +322,10 @@ static void jtagmkI_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
for(ln = lfirst(p->mem); ln; ln = lnext(ln)) {
m = ldata(ln);
if(mem_is_flash(m)) {
PDATA(pgm)->flash_pagesize = m->page_size;
u16_to_b2(sendbuf.dd.uiFlashPageSize, PDATA(pgm)->flash_pagesize);
my.flash_pagesize = m->page_size;
u16_to_b2(sendbuf.dd.uiFlashPageSize, my.flash_pagesize);
} else if(mem_is_eeprom(m)) {
sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
sendbuf.dd.ucEepromPageSize = my.eeprom_pagesize = m->page_size;
}
}
@@ -370,7 +370,7 @@ static int jtagmkI_program_enable_dummy(const PROGRAMMER *pgm, const AVRPART *p)
static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
unsigned char buf[1], resp[2];
if(PDATA(pgm)->prog_enabled)
if(my.prog_enabled)
return 0;
buf[0] = CMD_ENTER_PROGMODE;
@@ -387,7 +387,7 @@ static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
msg_notice2("OK\n");
}
PDATA(pgm)->prog_enabled = 1;
my.prog_enabled = 1;
return 0;
}
@@ -395,7 +395,7 @@ static int jtagmkI_program_enable(const PROGRAMMER *pgm) {
static int jtagmkI_program_disable(const PROGRAMMER *pgm) {
unsigned char buf[1], resp[2];
if(!PDATA(pgm)->prog_enabled)
if(!my.prog_enabled)
return 0;
if(pgm->fd.ifd != -1) {
@@ -413,7 +413,7 @@ static int jtagmkI_program_disable(const PROGRAMMER *pgm) {
msg_notice2("OK\n");
}
}
PDATA(pgm)->prog_enabled = 0;
my.prog_enabled = 0;
return 0;
}
@@ -440,13 +440,13 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
jtagmkI_drain(pgm, 0);
if((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
if((serdev->flags & SERDEV_FL_CANSETSPEED) && my.initial_baudrate != pgm->baudrate) {
if((b = jtagmkI_get_baud(pgm->baudrate)) == 0) {
pmsg_error("unsupported baudrate %d\n", pgm->baudrate);
} else {
pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, pgm->baudrate);
if(jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
PDATA(pgm)->initial_baudrate = pgm->baudrate; // Don't adjust again later
my.initial_baudrate = pgm->baudrate; // Don't adjust again later
serial_setparams(&pgm->fd, pgm->baudrate, SERIAL_8N1);
}
}
@@ -472,15 +472,15 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
// Must set the device descriptor before entering programming mode
jtagmkI_set_devdescr(pgm, p);
jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, PDATA(pgm)->flash_pagesize & 0xff);
jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, PDATA(pgm)->flash_pagesize >> 8);
jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, PDATA(pgm)->eeprom_pagesize & 0xff);
jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, my.flash_pagesize & 0xff);
jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, my.flash_pagesize >> 8);
jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, my.eeprom_pagesize & 0xff);
mmt_free(PDATA(pgm)->flash_pagecache);
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
mmt_free(my.flash_pagecache);
mmt_free(my.eeprom_pagecache);
my.flash_pagecache = mmt_malloc(my.flash_pagesize);
my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
if(jtagmkI_reset(pgm) < 0)
return -1;
@@ -494,10 +494,10 @@ static int jtagmkI_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
static void jtagmkI_disable(const PROGRAMMER *pgm) {
mmt_free(PDATA(pgm)->flash_pagecache);
PDATA(pgm)->flash_pagecache = NULL;
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->eeprom_pagecache = NULL;
mmt_free(my.flash_pagecache);
my.flash_pagecache = NULL;
mmt_free(my.eeprom_pagecache);
my.eeprom_pagecache = NULL;
(void) jtagmkI_program_disable(pgm);
}
@@ -512,7 +512,7 @@ static int jtagmkI_open(PROGRAMMER *pgm, const char *port) {
pmsg_notice2("jtagmkI_open()\n");
pgm->port = port;
PDATA(pgm)->initial_baudrate = -1L;
my.initial_baudrate = -1L;
for(i = 0; i < sizeof(baudtab)/sizeof(baudtab[0]); i++) {
union pinfo pinfo;
@@ -528,7 +528,7 @@ static int jtagmkI_open(PROGRAMMER *pgm, const char *port) {
jtagmkI_drain(pgm, 0);
if(jtagmkI_getsync(pgm) == 0) {
PDATA(pgm)->initial_baudrate = baudtab[i].baud;
my.initial_baudrate = baudtab[i].baud;
pmsg_notice2("%s(): succeeded\n", __func__);
return 0;
}
@@ -551,11 +551,11 @@ static void jtagmkI_close(PROGRAMMER *pgm) {
* Revert baud rate to what it used to be when we started. This appears to
* make AVR Studio happier when it is about to access the ICE later on.
*/
if((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
if((b = jtagmkI_get_baud(PDATA(pgm)->initial_baudrate)) == 0) {
pmsg_error("unsupported baudrate %d\n", PDATA(pgm)->initial_baudrate);
if((serdev->flags & SERDEV_FL_CANSETSPEED) && my.initial_baudrate != pgm->baudrate) {
if((b = jtagmkI_get_baud(my.initial_baudrate)) == 0) {
pmsg_error("unsupported baudrate %d\n", my.initial_baudrate);
} else {
pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, PDATA(pgm)->initial_baudrate);
pmsg_notice2("%s(): trying to set baudrate to %d\n", __func__, my.initial_baudrate);
if(jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
serial_setparams(&pgm->fd, pgm->baudrate, SERIAL_8N1);
}
@@ -597,13 +597,13 @@ static int jtagmkI_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
cmd[0] = CMD_WRITE_MEM;
if(mem_is_flash(m)) {
cmd[1] = MTYPE_FLASH_PAGE;
PDATA(pgm)->flash_pageaddr = ~0UL;
page_size = PDATA(pgm)->flash_pagesize;
my.flash_pageaddr = ~0UL;
page_size = my.flash_pagesize;
is_flash = 1;
} else if(mem_is_eeprom(m)) {
cmd[1] = MTYPE_EEPROM_PAGE;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
page_size = PDATA(pgm)->eeprom_pagesize;
my.eeprom_pageaddr = ~0UL;
page_size = my.eeprom_pagesize;
}
datacmd[0] = CMD_DATA;
@@ -790,15 +790,15 @@ static int jtagmkI_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
cmd[1] = MTYPE_FLASH_PAGE;
pagesize = mem->page_size;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->flash_pageaddr;
cache_ptr = PDATA(pgm)->flash_pagecache;
paddr_ptr = &my.flash_pageaddr;
cache_ptr = my.flash_pagecache;
is_flash = 1;
} else if(mem_is_eeprom(mem)) {
cmd[1] = MTYPE_EEPROM_PAGE;
pagesize = mem->page_size;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
paddr_ptr = &my.eeprom_pageaddr;
cache_ptr = my.eeprom_pagecache;
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[1] = MTYPE_FUSE_BITS;
if(mem_is_a_fuse(mem))
@@ -894,12 +894,12 @@ static int jtagmkI_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
if(mem_is_flash(mem)) {
cmd[1] = MTYPE_SPM;
need_progmode = 0;
PDATA(pgm)->flash_pageaddr = ~0UL;
my.flash_pageaddr = ~0UL;
} else if(mem_is_eeprom(mem)) {
cmd[1] = MTYPE_EEPROM;
need_progmode = 0;
need_dummy_read = 1;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[1] = MTYPE_FUSE_BITS;
need_dummy_read = 1;

178
src/jtagmkII.c
View File

@@ -101,7 +101,7 @@ struct pdata {
char msg[64]; // Used in jtagmkII_get_rc()
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
#define RC(x) { x, #x },
static const struct {
@@ -175,7 +175,7 @@ static int jtagmkII_paged_load32(const PROGRAMMER *pgm, const AVRPART *p, const
void jtagmkII_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->rts_mode = RTS_MODE_DEFAULT;
my.rts_mode = RTS_MODE_DEFAULT;
}
void jtagmkII_teardown(PROGRAMMER *pgm) {
@@ -238,8 +238,8 @@ static const char *jtagmkII_get_rc(const PROGRAMMER *pgm, unsigned int rc) {
if(jtagresults[i].code == rc)
return jtagresults[i].descr;
sprintf(PDATA(pgm)->msg, "Unknown JTAG ICE mkII result code 0x%02x", rc);
return PDATA(pgm)->msg;
sprintf(my.msg, "Unknown JTAG ICE mkII result code 0x%02x", rc);
return my.msg;
}
static void jtagmkII_print_memory(unsigned char *b, size_t s) {
@@ -422,7 +422,7 @@ int jtagmkII_send(const PROGRAMMER *pgm, unsigned char *data, size_t len) {
buf = mmt_malloc(len + 10);
buf[0] = MESSAGE_START;
u16_to_b2(buf + 1, PDATA(pgm)->command_sequence);
u16_to_b2(buf + 1, my.command_sequence);
u32_to_b4(buf + 3, len);
buf[7] = TOKEN;
memcpy(buf + 8, data, len);
@@ -594,10 +594,10 @@ int jtagmkII_recv(const PROGRAMMER *pgm, unsigned char **msg) {
if((rv = jtagmkII_recv_frame(pgm, msg, &r_seqno)) <= 0)
return rv;
pmsg_debug("%s(): got message seqno %d (command_sequence == %d)\n",
__func__, r_seqno, PDATA(pgm)->command_sequence);
if(r_seqno == PDATA(pgm)->command_sequence) {
if(++(PDATA(pgm)->command_sequence) == 0xffff)
PDATA(pgm)->command_sequence = 0;
__func__, r_seqno, my.command_sequence);
if(r_seqno == my.command_sequence) {
if(++(my.command_sequence) == 0xffff)
my.command_sequence = 0;
/*
* We move the payload to the beginning of the buffer, to make the job
* easier for the caller. We have to return the original pointer though,
@@ -613,7 +613,7 @@ int jtagmkII_recv(const PROGRAMMER *pgm, unsigned char **msg) {
if(r_seqno == 0xffff) {
pmsg_debug("%s(): got asynchronous event\n", __func__);
} else {
pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, PDATA(pgm)->command_sequence);
pmsg_notice2("%s(): got wrong sequence number, %u != %u\n", __func__, r_seqno, my.command_sequence);
}
mmt_free(*msg);
}
@@ -657,9 +657,9 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
if(status > 0) {
if((c = resp[0]) == RSP_SIGN_ON) {
fwver = ((unsigned) resp[8] << 8) | (unsigned) resp[7];
PDATA(pgm)->fwver = fwver;
my.fwver = fwver;
hwver = (unsigned) resp[9];
memcpy(PDATA(pgm)->serno, resp + 10, 6);
memcpy(my.serno, resp + 10, 6);
if(status > 17) {
imsg_notice2("JTAG ICE mkII sign-on message:\n");
imsg_notice2("Communications protocol version: %u\n", (unsigned) resp[1]);
@@ -672,8 +672,8 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
imsg_notice2(" firmware version: %u.%02u\n", (unsigned) resp[8], (unsigned) resp[7]);
imsg_notice2(" hardware version: %u\n", (unsigned) resp[9]);
imsg_notice2("Serial number: %02x:%02x:%02x:%02x:%02x:%02x\n",
PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2],
PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
my.serno[0], my.serno[1], my.serno[2],
my.serno[3], my.serno[4], my.serno[5]);
resp[status - 1] = '\0';
imsg_notice2("Device ID: %s\n", resp + 16);
}
@@ -691,7 +691,7 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
return -1;
}
PDATA(pgm)->device_descriptor_length = sizeof(struct device_descriptor);
my.device_descriptor_length = sizeof(struct device_descriptor);
/*
* There's no official documentation from Atmel about what firmware revision
* matches what device descriptor length. The algorithm below has been found
@@ -699,16 +699,16 @@ int jtagmkII_getsync(const PROGRAMMER *pgm, int mode) {
*/
#define FWVER(maj, min) ((maj << 8) | (min))
if(!is_dragon && fwver < FWVER(3, 16)) {
PDATA(pgm)->device_descriptor_length -= 2;
my.device_descriptor_length -= 2;
pmsg_warning("S_MCU firmware version might be too old to work correctly\n");
} else if(!is_dragon && fwver < FWVER(4, 0)) {
PDATA(pgm)->device_descriptor_length -= 2;
my.device_descriptor_length -= 2;
}
if(mode != EMULATOR_MODE_SPI)
pmsg_notice2("%s(): using a %u-byte device descriptor\n",
__func__, (unsigned) PDATA(pgm)->device_descriptor_length);
__func__, (unsigned) my.device_descriptor_length);
if(mode == EMULATOR_MODE_SPI) {
PDATA(pgm)->device_descriptor_length = 0;
my.device_descriptor_length = 0;
if(!is_dragon && fwver < FWVER(4, 14)) {
pmsg_error("ISP functionality requires firmware version >= 4.14\n");
return -1;
@@ -830,7 +830,7 @@ static int jtagmkII_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
if(p->prog_modes & PM_Classic)
pgm->initialize(pgm, p);
PDATA(pgm)->recently_written = 1;
my.recently_written = 1;
return 0;
}
@@ -870,9 +870,9 @@ static void jtagmkII_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
if(mem_is_flash(m)) {
if(m->page_size > 256)
PDATA(pgm)->flash_pagesize = 256;
my.flash_pagesize = 256;
else
PDATA(pgm)->flash_pagesize = m->page_size;
my.flash_pagesize = m->page_size;
u32_to_b4(sendbuf.dd.ulFlashSize, m->size);
u16_to_b2(sendbuf.dd.uiFlashPageSize, m->page_size);
u16_to_b2(sendbuf.dd.uiFlashpages, m->size/m->page_size);
@@ -881,13 +881,13 @@ static void jtagmkII_set_devdescr(const PROGRAMMER *pgm, const AVRPART *p) {
memcpy(sendbuf.dd.ucEepromInst, p->eeprom_instr, EEPROM_INSTR_SIZE);
}
} else if(mem_is_eeprom(m)) {
sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
sendbuf.dd.ucEepromPageSize = my.eeprom_pagesize = m->page_size;
}
}
sendbuf.dd.ucCacheType = p->prog_modes & (PM_PDI | PM_UPDI)? 0x02: 0x00;
pmsg_notice2("%s(): sending set device descriptor command: ", __func__);
jtagmkII_send(pgm, (unsigned char *) &sendbuf, PDATA(pgm)->device_descriptor_length + sizeof(unsigned char));
jtagmkII_send(pgm, (unsigned char *) &sendbuf, my.device_descriptor_length + sizeof(unsigned char));
status = jtagmkII_recv(pgm, &resp);
if(status <= 0) {
@@ -928,9 +928,9 @@ static void jtagmkII_set_xmega_params(const PROGRAMMER *pgm, const AVRPART *p) {
m = ldata(ln);
if(mem_is_flash(m)) {
if(m->page_size > 256)
PDATA(pgm)->flash_pagesize = 256;
my.flash_pagesize = 256;
else
PDATA(pgm)->flash_pagesize = m->page_size;
my.flash_pagesize = m->page_size;
u16_to_b2(sendbuf.dd.flash_page_size, m->page_size);
} else if(mem_is_eeprom(m)) {
sendbuf.dd.eeprom_page_size = m->page_size;
@@ -1027,7 +1027,7 @@ static int jtagmkII_program_enable(const PROGRAMMER *pgm) {
unsigned char buf[1], *resp, c;
int use_ext_reset;
if(PDATA(pgm)->prog_enabled)
if(my.prog_enabled)
return 0;
for(use_ext_reset = 0; use_ext_reset <= 1; use_ext_reset++) {
@@ -1065,7 +1065,7 @@ static int jtagmkII_program_enable(const PROGRAMMER *pgm) {
}
}
PDATA(pgm)->prog_enabled = 1;
my.prog_enabled = 1;
return 0;
}
@@ -1073,7 +1073,7 @@ static int jtagmkII_program_disable(const PROGRAMMER *pgm) {
int status;
unsigned char buf[1], *resp, c;
if(!PDATA(pgm)->prog_enabled)
if(!my.prog_enabled)
return 0;
buf[0] = CMND_LEAVE_PROGMODE;
@@ -1098,8 +1098,8 @@ static int jtagmkII_program_disable(const PROGRAMMER *pgm) {
return -1;
}
PDATA(pgm)->recently_written = 0;
PDATA(pgm)->prog_enabled = 0;
my.recently_written = 0;
my.prog_enabled = 0;
(void) jtagmkII_reset(pgm, 0x01);
return 0;
@@ -1157,8 +1157,8 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
int ok;
const char *ifname;
if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", PDATA(pgm)->rts_mode == RTS_MODE_LOW? "LOW": "HIGH");
if(my.rts_mode != RTS_MODE_DEFAULT) {
pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", my.rts_mode == RTS_MODE_LOW? "LOW": "HIGH");
}
// Abort and print error if programmer does not support the target microcontroller
@@ -1203,7 +1203,7 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
}
if((pgm->flag & PGM_FL_IS_JTAG) && jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
if((pgm->flag & PGM_FL_IS_JTAG) && jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, my.jtagchain) < 0) {
pmsg_error("unable to setup JTAG chain\n");
return -1;
}
@@ -1217,12 +1217,12 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
return -1;
}
// Must set the device descriptor before entering programming mode
if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI)) != 0)
if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI)) != 0)
jtagmkII_set_xmega_params(pgm, p);
else
jtagmkII_set_devdescr(pgm, p);
PDATA(pgm)->boot_start = ULONG_MAX;
my.boot_start = ULONG_MAX;
if((p->prog_modes & (PM_PDI | PM_UPDI))) {
// Find the border between application and boot area
AVRMEM *bootmem = avr_locate_boot(p);
@@ -1232,7 +1232,7 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
if(str_starts(pgmid, "jtagmkII"))
pmsg_error("cannot locate flash or boot memories in description\n");
} else {
if(PDATA(pgm)->fwver < 0x700) {
if(my.fwver < 0x700) {
// V7+ firmware does not need this anymore
unsigned char par[4];
@@ -1242,17 +1242,17 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
(void) jtagmkII_setparm(pgm, PAR_PDI_OFFSET_END, par);
}
PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
my.boot_start = bootmem->offset - flashmem->offset;
}
}
mmt_free(PDATA(pgm)->flash_pagecache);
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
mmt_free(my.flash_pagecache);
mmt_free(my.eeprom_pagecache);
my.flash_pagecache = mmt_malloc(my.flash_pagesize);
my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
/*
* Work around for
* https://savannah.nongnu.org/bugs/index.php?37942
@@ -1286,10 +1286,10 @@ static int jtagmkII_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
static void jtagmkII_disable(const PROGRAMMER *pgm) {
mmt_free(PDATA(pgm)->flash_pagecache);
PDATA(pgm)->flash_pagecache = NULL;
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->eeprom_pagecache = NULL;
mmt_free(my.flash_pagecache);
my.flash_pagecache = NULL;
mmt_free(my.eeprom_pagecache);
my.eeprom_pagecache = NULL;
/*
* jtagmkII_program_disable() doesn't do anything if the device is currently
@@ -1328,10 +1328,10 @@ static int jtagmkII_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
}
pmsg_notice2("%s(): JTAG chain parsed as:\n", __func__);
imsg_notice2("%u units before, %u units after, %u bits before, %u bits after\n", ub, ua, bb, ba);
PDATA(pgm)->jtagchain[0] = ub;
PDATA(pgm)->jtagchain[1] = ua;
PDATA(pgm)->jtagchain[2] = bb;
PDATA(pgm)->jtagchain[3] = ba;
my.jtagchain[0] = ub;
my.jtagchain[1] = ua;
my.jtagchain[2] = bb;
my.jtagchain[3] = ba;
continue;
}
}
@@ -1341,9 +1341,9 @@ static int jtagmkII_parseextparms(const PROGRAMMER *pgm, const LISTID extparms)
if(sscanf(extended_param, "rtsdtr=%4s", rts_mode) == 1) {
if(str_caseeq(rts_mode, "low")) {
PDATA(pgm)->rts_mode = RTS_MODE_LOW;
my.rts_mode = RTS_MODE_LOW;
} else if(str_caseeq(rts_mode, "high")) {
PDATA(pgm)->rts_mode = RTS_MODE_HIGH;
my.rts_mode = RTS_MODE_HIGH;
} else {
pmsg_error("RTS/DTR mode must be LOW or HIGH\n");
rv = -1;
@@ -1519,9 +1519,9 @@ static int jtagmkII_open_pdi(PROGRAMMER *pgm, const char *port) {
jtagmkII_drain(pgm, 0);
// Set RTS/DTR high or low based on the user specified rts_mode
if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
if(my.rts_mode != RTS_MODE_DEFAULT) {
serial_set_dtr_rts(&pgm->fd, 0);
serial_set_dtr_rts(&pgm->fd, PDATA(pgm)->rts_mode == RTS_MODE_LOW? 1: 0);
serial_set_dtr_rts(&pgm->fd, my.rts_mode == RTS_MODE_LOW? 1: 0);
}
if(jtagmkII_getsync(pgm, EMULATOR_MODE_PDI) < 0)
@@ -1731,7 +1731,7 @@ void jtagmkII_close(PROGRAMMER *pgm) {
pmsg_error("bad response to sign-off command: %s\n", jtagmkII_get_rc(pgm, c));
}
if(PDATA(pgm)->rts_mode != RTS_MODE_DEFAULT) {
if(my.rts_mode != RTS_MODE_DEFAULT) {
pmsg_notice("releasing DTR/RTS handshake lines\n");
serial_set_dtr_rts(&pgm->fd, 0);
}
@@ -1852,7 +1852,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
cmd = mmt_malloc(page_size + 10);
cmd[0] = CMND_WRITE_MEMORY;
if(mem_is_flash(m)) {
PDATA(pgm)->flash_pageaddr = ~0UL;
my.flash_pageaddr = ~0UL;
cmd[1] = jtagmkII_mtype(pgm, p, addr);
if(p->prog_modes & (PM_PDI | PM_UPDI)) // Dynamically decide between flash/boot mtype
dynamic_mtype = 1;
@@ -1873,7 +1873,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
return n_bytes;
}
cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM_PAGE;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_userrow(m) || mem_is_bootrow(m)) {
cmd[1] = MTYPE_USERSIG;
} else if(mem_is_boot(m)) {
@@ -1944,7 +1944,7 @@ static int jtagmkII_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const A
mmt_free(cmd);
serial_recv_timeout = otimeout;
PDATA(pgm)->recently_written = 1;
my.recently_written = 1;
return n_bytes;
}
@@ -2032,7 +2032,7 @@ static int jtagmkII_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AV
}
serial_recv_timeout = otimeout;
PDATA(pgm)->recently_written = 0;
my.recently_written = 0;
return n_bytes;
}
@@ -2078,10 +2078,10 @@ static int jtagmkII_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
addr += mem->offset;
cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_FLASH: MTYPE_FLASH_PAGE;
if(mem_is_in_flash(mem)) {
pagesize = PDATA(pgm)->flash_pagesize;
pagesize = my.flash_pagesize;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->flash_pageaddr;
cache_ptr = PDATA(pgm)->flash_pagecache;
paddr_ptr = &my.flash_pageaddr;
cache_ptr = my.flash_pagecache;
} else if(mem_is_eeprom(mem)) {
if((pgm->flag & PGM_FL_IS_DW) || (p->prog_modes & (PM_PDI | PM_UPDI))) {
// debugWire cannot use page access for EEPROM
@@ -2090,8 +2090,8 @@ static int jtagmkII_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVR
cmd[1] = MTYPE_EEPROM_PAGE;
pagesize = mem->page_size;
paddr = addr & ~(pagesize - 1);
paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
cache_ptr = PDATA(pgm)->eeprom_pagecache;
paddr_ptr = &my.eeprom_pageaddr;
cache_ptr = my.eeprom_pagecache;
}
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[1] = MTYPE_FUSE_BITS;
@@ -2227,7 +2227,7 @@ retry:
*value = resp[1];
mmt_free(resp);
PDATA(pgm)->recently_written = 0;
my.recently_written = 0;
return 0;
fail:
@@ -2258,14 +2258,14 @@ static int jtagmkII_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AV
writesize = 2;
if(str_eq(p->family_id, "megaAVR") || str_eq(p->family_id, "tinyAVR")) // AVRs with UPDI except AVR-Dx/Ex
need_progmode = 0;
PDATA(pgm)->flash_pageaddr = ~0UL;
my.flash_pageaddr = ~0UL;
if(pgm->flag & PGM_FL_IS_DW)
unsupp = 1;
} else if(mem_is_eeprom(mem)) {
cmd[1] = p->prog_modes & (PM_PDI | PM_UPDI)? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM;
if(str_eq(p->family_id, "megaAVR") || str_eq(p->family_id, "tinyAVR")) // AVRs with UPDI except AVR-Dx/Ex
need_progmode = 0;
PDATA(pgm)->eeprom_pageaddr = ~0UL;
my.eeprom_pageaddr = ~0UL;
} else if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) {
cmd[1] = MTYPE_FUSE_BITS;
if((p->prog_modes & PM_Classic) && mem_is_a_fuse(mem))
@@ -2337,7 +2337,7 @@ retry:
}
mmt_free(resp);
PDATA(pgm)->recently_written = 1;
my.recently_written = 1;
return 0;
fail:
@@ -2533,8 +2533,8 @@ static void jtagmkII_display(const PROGRAMMER *pgm, const char *p) {
msg_info("%sSec. MCU HW version : %d\n", p, hw[1]);
msg_info("%sSec. MCU FW version : %d.%02d\n", p, fw[3], fw[2]);
msg_info("%sSerial number : %02x:%02x:%02x:%02x:%02x:%02x\n", p,
PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2],
PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
my.serno[0], my.serno[1], my.serno[2],
my.serno[3], my.serno[4], my.serno[5]);
jtagmkII_print_parms1(pgm, p, stderr);
@@ -2581,7 +2581,7 @@ static void jtagmkII_print_parms(const PROGRAMMER *pgm, FILE *fp) {
static unsigned char jtagmkII_mtype(const PROGRAMMER *pgm, const AVRPART *p, unsigned long addr) {
if(p->prog_modes & (PM_PDI | PM_UPDI)) {
if(addr >= PDATA(pgm)->boot_start)
if(addr >= my.boot_start)
return MTYPE_BOOT_FLASH;
else
return MTYPE_FLASH;
@@ -2595,13 +2595,13 @@ static unsigned int jtagmkII_memaddr(const PROGRAMMER *pgm, const AVRPART *p, co
* Xmega devices handled by V7+ firmware don't want to be told their
* m->offset within the write memory command.
*/
if(PDATA(pgm)->fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
if(addr >= PDATA(pgm)->boot_start)
if(my.fwver >= 0x700 && (p->prog_modes & (PM_PDI | PM_UPDI))) {
if(addr >= my.boot_start)
/*
* All memories but "flash" are smaller than boot_start anyway, so no
* need for an extra check we are operating on "flash"
*/
return addr - PDATA(pgm)->boot_start;
return addr - my.boot_start;
else
// Normal flash, or anything else
return addr;
@@ -3021,16 +3021,16 @@ static int jtagmkII_initialize32(const PROGRAMMER *pgm, const AVRPART *p) {
int status, j;
unsigned char buf[6], *resp;
if(jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
if(jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, my.jtagchain) < 0) {
pmsg_error("unable to setup JTAG chain\n");
return -1;
}
mmt_free(PDATA(pgm)->flash_pagecache);
mmt_free(PDATA(pgm)->eeprom_pagecache);
PDATA(pgm)->flash_pagecache = mmt_malloc(PDATA(pgm)->flash_pagesize);
PDATA(pgm)->eeprom_pagecache = mmt_malloc(PDATA(pgm)->eeprom_pagesize);
PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = ~0UL;
mmt_free(my.flash_pagecache);
mmt_free(my.eeprom_pagecache);
my.flash_pagecache = mmt_malloc(my.flash_pagesize);
my.eeprom_pagecache = mmt_malloc(my.eeprom_pagesize);
my.flash_pageaddr = my.eeprom_pageaddr = ~0UL;
for(j = 0; j < 2; ++j) {
buf[0] = CMND_GET_IR;
@@ -3356,18 +3356,18 @@ static int jtagmkII_paged_load32(const PROGRAMMER *pgm, const AVRPART *p_unused,
serial_recv_timeout = 256;
if(!(PDATA(pgm)->flags32 & FLAGS32_WRITE)) {
if(!(my.flags32 & FLAGS32_WRITE)) {
status = jtagmkII_reset32(pgm, AVR32_RESET_READ);
if(status != 0)
gotoerr;
}
// Init SMC and set clocks
if(!(PDATA(pgm)->flags32 & FLAGS32_INIT_SMC)) {
if(!(my.flags32 & FLAGS32_INIT_SMC)) {
status = jtagmkII_smc_init32(pgm);
if(status != 0)
gotoerr; // PLL 0
PDATA(pgm)->flags32 |= FLAGS32_INIT_SMC;
my.flags32 |= FLAGS32_INIT_SMC;
}
// msg_error("\n pageSize=%d bytes=%d pages=%d m->offset=0x%x pgm->page_size %d\n",
@@ -3438,7 +3438,7 @@ static int jtagmkII_paged_write32(const PROGRAMMER *pgm, const AVRPART *p_unused
status = jtagmkII_reset32(pgm, AVR32_RESET_WRITE);
if(status != 0)
gotoerr;
PDATA(pgm)->flags32 |= FLAGS32_WRITE;
my.flags32 |= FLAGS32_WRITE;
pages = (n_bytes - addr - 1)/page_size + 1;
sPageNum = addr/page_size;
@@ -3448,11 +3448,11 @@ static int jtagmkII_paged_write32(const PROGRAMMER *pgm, const AVRPART *p_unused
// Before any errors can happen
cmd = mmt_malloc(pgm->page_size + 10);
// Init SMC and set clocks
if(!(PDATA(pgm)->flags32 & FLAGS32_INIT_SMC)) {
if(!(my.flags32 & FLAGS32_INIT_SMC)) {
status = jtagmkII_smc_init32(pgm);
if(status != 0)
gotoerr; // PLL 0
PDATA(pgm)->flags32 |= FLAGS32_INIT_SMC;
my.flags32 |= FLAGS32_INIT_SMC;
}
// First unlock the pages
@@ -3698,7 +3698,7 @@ static int jtagmkII_updi_term_keep_alive(const PROGRAMMER *pgm, const AVRPART *p
// Read the signature if most recent operation was an erase or a write to ensure it finished
static int jtagmkII_updi_end_programming(const PROGRAMMER *pgm, const AVRPART *p) {
return PDATA(pgm)->recently_written? avr_read(pgm, p, "signature", NULL): 0;
return my.recently_written? avr_read(pgm, p, "signature", NULL): 0;
}
#ifdef __OBJC__

18
src/micronucleus.c
View File

@@ -77,7 +77,7 @@
#define MICRONUCLEUS_DEFAULT_TIMEOUT 500
#define MICRONUCLEUS_MAX_MAJOR_VERSION 2
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// -----------------------------------------------------------------------------
@@ -497,7 +497,7 @@ static void micronucleus_teardown(PROGRAMMER *pgm) {
static int micronucleus_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
pmsg_debug("micronucleus_initialize()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
int result = micronucleus_get_bootloader_info(pdata);
@@ -520,7 +520,7 @@ static void micronucleus_powerup(const PROGRAMMER *pgm) {
static void micronucleus_powerdown(const PROGRAMMER *pgm) {
pmsg_debug("micronucleus_powerdown()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(pdata->write_last_page) {
pdata->write_last_page = false;
@@ -560,7 +560,7 @@ static int micronucleus_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p,
return -1;
}
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
mem->buf[0] = 0x1E;
mem->buf[1] = pdata->signature1;
@@ -571,7 +571,7 @@ static int micronucleus_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p,
static int micronucleus_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
pmsg_debug("micronucleus_chip_erase()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
return micronucleus_erase_device(pdata);
}
@@ -579,7 +579,7 @@ static int micronucleus_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
static int micronucleus_open(PROGRAMMER *pgm, const char *port) {
pmsg_debug("micronucleus_open(\"%s\")\n", port);
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
const char *bus_name = NULL;
char *dev_name = NULL;
@@ -705,7 +705,7 @@ static int micronucleus_open(PROGRAMMER *pgm, const char *port) {
static void micronucleus_close(PROGRAMMER *pgm) {
pmsg_debug("micronucleus_close()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(pdata->usb_handle != NULL) {
usb_close(pdata->usb_handle);
@@ -743,7 +743,7 @@ static int micronucleus_paged_write(const PROGRAMMER *pgm, const AVRPART *p, con
pmsg_debug("micronucleus_paged_write(page_size=0x%X, addr=0x%X, n_bytes=0x%X)\n", page_size, addr, n_bytes);
if(mem_is_flash(mem)) {
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(n_bytes > page_size) {
pmsg_error("buffer size %u exceeds page size %u\n", n_bytes, page_size);
@@ -789,7 +789,7 @@ static int micronucleus_parseextparams(const PROGRAMMER *pgm, const LISTID xpara
pmsg_debug("micronucleus_parseextparams()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
for(LNODEID node = lfirst(xparams); node; node = lnext(node)) {
const char *extended_param = ldata(node);

76
src/pickit2.c
View File

@@ -122,7 +122,7 @@ struct pdata {
int transaction_timeout; // USB trans timeout in ms
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
#define CMD_NOP 0x5A
#define CMD_GET_VERSION 0x76
@@ -159,8 +159,8 @@ struct pdata {
static void pickit2_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->transaction_timeout = 1500; // Can be changed with -x timeout=ms
PDATA(pgm)->clock_period = 10; // Can be changed with -x clockrate=us or -B or -i
my.transaction_timeout = 1500; // Can be changed with -x timeout=ms
my.clock_period = 10; // Can be changed with -x clockrate=us or -B or -i
}
static void pickit2_teardown(PROGRAMMER *pgm) {
@@ -171,9 +171,9 @@ static void pickit2_teardown(PROGRAMMER *pgm) {
static int pickit2_open(PROGRAMMER *pgm, const char *port) {
#ifdef WIN32
PDATA(pgm)->usb_handle = open_hid(PICKIT2_VID, PICKIT2_PID);
my.usb_handle = open_hid(PICKIT2_VID, PICKIT2_PID);
if(PDATA(pgm)->usb_handle == INVALID_HANDLE_VALUE) {
if(my.usb_handle == INVALID_HANDLE_VALUE) {
// No PICkit2 found
pmsg_error("cannot find PICkit2 with vid=0x%x pid=0x%x\n", PICKIT2_VID, PICKIT2_PID);
return -1;
@@ -182,7 +182,7 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
short wbuf[80 - 1];
char *cbuf = mmt_malloc(sizeof wbuf/sizeof *wbuf + (pgm->desc? strlen(pgm->desc): 0) + 2);
HidD_GetProductString(PDATA(pgm)->usb_handle, wbuf, sizeof wbuf/sizeof *wbuf);
HidD_GetProductString(my.usb_handle, wbuf, sizeof wbuf/sizeof *wbuf);
if(pgm->desc && *pgm->desc)
strcpy(cbuf, pgm->desc);
@@ -194,7 +194,7 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
mmt_free(cbuf);
}
#else
if(usb_open_device(pgm, &(PDATA(pgm)->usb_handle), PICKIT2_VID, PICKIT2_PID) < 0) {
if(usb_open_device(pgm, &(my.usb_handle), PICKIT2_VID, PICKIT2_PID) < 0) {
// No PICkit2 found
pmsg_error("cannot find PICkit2 with vid=0x%x pid=0x%x\n", PICKIT2_VID, PICKIT2_PID);
return -1;
@@ -202,9 +202,9 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
#endif
if(pgm->ispdelay > 0) {
PDATA(pgm)->clock_period = MIN(pgm->ispdelay, 255);
my.clock_period = MIN(pgm->ispdelay, 255);
} else if(pgm->bitclock > 0.0) {
PDATA(pgm)->clock_period = MIN(pgm->bitclock*1e6, 255);
my.clock_period = MIN(pgm->bitclock*1e6, 255);
}
return 0;
@@ -213,11 +213,11 @@ static int pickit2_open(PROGRAMMER *pgm, const char *port) {
static void pickit2_close(PROGRAMMER *pgm) {
#ifdef WIN32
CloseHandle(PDATA(pgm)->usb_handle);
CloseHandle(PDATA(pgm)->read_event);
CloseHandle(PDATA(pgm)->write_event);
CloseHandle(my.usb_handle);
CloseHandle(my.read_event);
CloseHandle(my.write_event);
#else
usb_close(PDATA(pgm)->usb_handle);
usb_close(my.usb_handle);
#endif // WIN32
}
@@ -246,7 +246,7 @@ static int pickit2_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
CMD_SET_VPP_4(5),
CMD_EXEC_SCRIPT_2(24),
SCR_SPI_SETUP_PINS_4, // SDO, SDI, SCK
SCR_SET_ICSP_DELAY_2(PDATA(pgm)->clock_period), // Slow down the SPI
SCR_SET_ICSP_DELAY_2(my.clock_period), // Slow down the SPI
SCR_VDD_ON,
SCR_MCLR_GND_OFF, // Let reset float high
SCR_VPP_PWM_ON,
@@ -879,20 +879,20 @@ static int usb_read_interrupt(const PROGRAMMER *pgm, void *buff, int size, int t
OVERLAPPED ovr;
DWORD bytesRead = 0;
if(PDATA(pgm)->read_event == NULL) {
PDATA(pgm)->read_event = CreateEvent(0, 0, 0, 0);
if(my.read_event == NULL) {
my.read_event = CreateEvent(0, 0, 0, 0);
}
memset(&ovr, 0, sizeof(ovr));
ovr.hEvent = PDATA(pgm)->read_event;
ovr.hEvent = my.read_event;
ReadFile(PDATA(pgm)->usb_handle, buff, size, &bytesRead, &ovr);
if(WaitForSingleObject(PDATA(pgm)->read_event, timeout) == WAIT_TIMEOUT) {
CancelIo(PDATA(pgm)->usb_handle);
ReadFile(my.usb_handle, buff, size, &bytesRead, &ovr);
if(WaitForSingleObject(my.read_event, timeout) == WAIT_TIMEOUT) {
CancelIo(my.usb_handle);
return -1;
}
GetOverlappedResult(PDATA(pgm)->usb_handle, &ovr, &bytesRead, 0);
GetOverlappedResult(my.usb_handle, &ovr, &bytesRead, 0);
return bytesRead > 0? (int) bytesRead: -1;
}
@@ -902,30 +902,30 @@ static int usb_write_interrupt(const PROGRAMMER *pgm, const void *buff, int size
OVERLAPPED ovr;
DWORD bytesWritten = 0;
if(PDATA(pgm)->write_event == NULL) {
PDATA(pgm)->write_event = CreateEvent(0, 0, 0, 0);
if(my.write_event == NULL) {
my.write_event = CreateEvent(0, 0, 0, 0);
}
memset(&ovr, 0, sizeof(ovr));
ovr.hEvent = PDATA(pgm)->write_event;
ovr.hEvent = my.write_event;
WriteFile(PDATA(pgm)->usb_handle, buff, size, &bytesWritten, &ovr);
if(WaitForSingleObject(PDATA(pgm)->write_event, timeout) == WAIT_TIMEOUT) {
CancelIo(PDATA(pgm)->usb_handle);
WriteFile(my.usb_handle, buff, size, &bytesWritten, &ovr);
if(WaitForSingleObject(my.write_event, timeout) == WAIT_TIMEOUT) {
CancelIo(my.usb_handle);
return -1;
}
GetOverlappedResult(PDATA(pgm)->usb_handle, &ovr, &bytesWritten, 0);
GetOverlappedResult(my.usb_handle, &ovr, &bytesWritten, 0);
return bytesWritten > 0? (int) bytesWritten: -1;
}
static int pickit2_write_report(const PROGRAMMER *pgm, const unsigned char report[65]) {
return usb_write_interrupt(pgm, report, 65, PDATA(pgm)->transaction_timeout); // XXX
return usb_write_interrupt(pgm, report, 65, my.transaction_timeout); // XXX
}
static int pickit2_read_report(const PROGRAMMER *pgm, unsigned char report[65]) {
return usb_read_interrupt(pgm, report, 65, PDATA(pgm)->transaction_timeout);
return usb_read_interrupt(pgm, report, 65, my.transaction_timeout);
}
#else // WIN32
@@ -937,8 +937,8 @@ static int usb_open_device(PROGRAMMER *pgm, struct usb_dev_handle **device, int
usb_dev_handle *handle = NULL;
int errorCode = USB_ERROR_NOTFOUND;
if(!PDATA(pgm)->USB_init) {
PDATA(pgm)->USB_init = 1;
if(!my.USB_init) {
my.USB_init = 1;
usb_init();
}
usb_find_busses();
@@ -980,14 +980,14 @@ static int usb_open_device(PROGRAMMER *pgm, struct usb_dev_handle **device, int
static int pickit2_write_report(const PROGRAMMER *pgm, const unsigned char report[65]) {
// Endpoint 1 OUT??
return usb_interrupt_write(PDATA(pgm)->usb_handle, USB_ENDPOINT_OUT | 1, (char *) (report + 1), 64,
PDATA(pgm)->transaction_timeout);
return usb_interrupt_write(my.usb_handle, USB_ENDPOINT_OUT | 1, (char *) (report + 1), 64,
my.transaction_timeout);
}
static int pickit2_read_report(const PROGRAMMER *pgm, unsigned char report[65]) {
// Endpoint 1 IN??
return usb_interrupt_read(PDATA(pgm)->usb_handle, USB_ENDPOINT_IN | 1, (char *) (report + 1), 64,
PDATA(pgm)->transaction_timeout);
return usb_interrupt_read(my.usb_handle, USB_ENDPOINT_IN | 1, (char *) (report + 1), 64,
my.transaction_timeout);
}
#endif // WIN32
@@ -1012,7 +1012,7 @@ static int pickit2_parseextparams(const PROGRAMMER *pgm, const LISTID extparms)
clock_rate = (int) (1000000/(clock_period + 5e-7)); // Assume highest speed is 2MHz
pmsg_notice2("%s(): effective clock rate set to 0x%02x\n", __func__, clock_rate);
PDATA(pgm)->clock_period = clock_period;
my.clock_period = clock_period;
continue;
}
@@ -1026,7 +1026,7 @@ static int pickit2_parseextparams(const PROGRAMMER *pgm, const LISTID extparms)
}
pmsg_notice2("%s(): usb timeout set to 0x%02x\n", __func__, timeout);
PDATA(pgm)->transaction_timeout = timeout;
my.transaction_timeout = timeout;
continue;
}

116
src/stk500.c
View File

@@ -100,14 +100,14 @@ int stk500_getsync(const PROGRAMMER *pgm) {
stk500_send(pgm, buf, 2);
stk500_drain(pgm, 0);
if(PDATA(pgm)->retry_attempts)
max_sync_attempts = PDATA(pgm)->retry_attempts;
if(my.retry_attempts)
max_sync_attempts = my.retry_attempts;
else
max_sync_attempts = MAX_SYNC_ATTEMPTS;
for(attempt = 0; attempt < max_sync_attempts; attempt++) {
// Restart Arduino bootloader for every sync attempt
if(str_eq(pgm->type, "Arduino") && PDATA(pgm)->autoreset && attempt > 0) {
if(str_eq(pgm->type, "Arduino") && my.autoreset && attempt > 0) {
// This code assumes a negative-logic USB to TTL serial adapter
// Pull the RTS/DTR line low to reset AVR: it is still high from open()/last attempt
serial_set_dtr_rts(&pgm->fd, 1);
@@ -517,7 +517,7 @@ retry:
}
}
// Read or write target voltage
if(PDATA(pgm)->vtarg_get || PDATA(pgm)->vtarg_set) {
if(my.vtarg_get || my.vtarg_set) {
// Read current target voltage set value
unsigned int vtarg_read = 0;
@@ -525,17 +525,17 @@ retry:
pmsg_error("cannot obtain V[target]\n");
return rc;
}
if(PDATA(pgm)->vtarg_get)
if(my.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);
if(pgm->set_vtarget(pgm, PDATA(pgm)->vtarg_data) < 0)
msg_info("Changing target voltage from %.2f V to %.2f V\n", (vtarg_read/10.0), my.vtarg_data);
if(pgm->set_vtarget(pgm, my.vtarg_data) < 0)
return -1;
}
}
// Read or write analog reference voltage
if(PDATA(pgm)->varef_get || PDATA(pgm)->varef_set) {
if(my.varef_get || my.varef_set) {
// Read current analog reference voltage
unsigned int varef_read = 0;
@@ -543,17 +543,17 @@ retry:
pmsg_error("cannot obtain V[aref]\n");
return rc;
}
if(PDATA(pgm)->varef_get)
if(my.varef_get)
msg_info("Analog reference voltage value read as %.2f V\n", (varef_read/10.0));
// 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);
if(pgm->set_varef(pgm, 0, PDATA(pgm)->varef_data) < 0)
msg_info("Changing analog reference voltage from %.2f V to %.2f V\n", (varef_read/10.0), my.varef_data);
if(pgm->set_varef(pgm, 0, my.varef_data) < 0)
return -1;
}
}
// Read or write clock generator frequency
if(PDATA(pgm)->fosc_get || PDATA(pgm)->fosc_set) {
if(my.fosc_get || my.fosc_set) {
// Read current target voltage set value
unsigned int osc_pscale = 0;
unsigned int osc_cmatch = 0;
@@ -568,7 +568,7 @@ retry:
if(osc_pscale) {
int prescale = 1;
f_get = PDATA(pgm)->xtal/2;
f_get = my.xtal/2;
switch(osc_pscale) {
case 2:
prescale = 8;
@@ -593,15 +593,15 @@ retry:
f_get /= (osc_cmatch + 1);
f_get = f_to_kHz_MHz(f_get, &unit_get);
}
if(PDATA(pgm)->fosc_get)
if(my.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);
double f_set = f_to_kHz_MHz(my.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)
if(pgm->set_fosc(pgm, my.fosc_data) < 0)
return -1;
}
}
@@ -618,7 +618,7 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
const char *extended_param = ldata(ln);
if(sscanf(extended_param, "attempts=%i", &attempts) == 1) {
PDATA(pgm)->retry_attempts = attempts;
my.retry_attempts = attempts;
pmsg_info("setting number of retry attempts to %d\n", attempts);
continue;
}
@@ -629,17 +629,17 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
double vtarg_set_val = -1; // Default = invlid value
int sscanf_success = sscanf(extended_param, "vtarg=%lf", &vtarg_set_val);
PDATA(pgm)->vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
my.vtarg_data = (double) ((int) (vtarg_set_val*100 + .5))/100;
if(sscanf_success < 1 || vtarg_set_val < 0) {
pmsg_error("invalid target voltage in -x %s\n", extended_param);
rv = -1;
break;
}
PDATA(pgm)->vtarg_set = true;
my.vtarg_set = true;
continue;
} else if((pgm->extra_features & HAS_VTARG_READ) && str_eq(extended_param, "vtarg")) {
// Get target voltage
PDATA(pgm)->vtarg_get = true;
my.vtarg_get = true;
continue;
}
}
@@ -652,24 +652,24 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
// Get new analog reference voltage for channel 0
if(str_starts(extended_param, "varef=")) {
sscanf_success = sscanf(extended_param, "varef=%lf", &varef_set_val);
PDATA(pgm)->varef_set = true;
my.varef_set = true;
}
// Get new analog reference voltage for channel 0
else if(str_starts(extended_param, "varef0=")) {
sscanf_success = sscanf(extended_param, "varef0=%lf", &varef_set_val);
PDATA(pgm)->varef_set = true;
my.varef_set = true;
}
// Get current analog reference voltage for channel 0
else if(str_eq(extended_param, "varef") || str_eq(extended_param, "varef0")) {
PDATA(pgm)->varef_get = true;
my.varef_get = true;
continue;
}
// Set analog reference voltage
if(PDATA(pgm)->varef_set) {
PDATA(pgm)->varef_data = (double) ((int) (varef_set_val*100 + .5))/100;
if(my.varef_set) {
my.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;
my.varef_set = false;
rv = -1;
break;
}
@@ -702,22 +702,22 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
rv = -1;
break;
}
PDATA(pgm)->fosc_data = 0.0;
my.fosc_data = 0.0;
}
while(*endp == ' ') // Remove leading spaces before unit
++endp;
if(*endp == 'm' || *endp == 'M')
PDATA(pgm)->fosc_data = v*1e6;
my.fosc_data = v*1e6;
else if(*endp == 'k' || *endp == 'K')
PDATA(pgm)->fosc_data = v*1e3;
my.fosc_data = v*1e3;
else if(*endp == 0 || *endp == 'h' || *endp == 'H')
PDATA(pgm)->fosc_data = v;
PDATA(pgm)->fosc_set = true;
my.fosc_data = v;
my.fosc_set = true;
continue;
}
// Get clock generator frequency
else if(str_eq(extended_param, "fosc")) {
PDATA(pgm)->fosc_get = true;
my.fosc_get = true;
continue;
}
}
@@ -745,11 +745,11 @@ static int stk500_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
while(*endp == ' ') // Remove leading spaces before unit
++endp;
if(*endp == 'm' || *endp == 'M') // Fits also e.g. "nnnnMHz"
PDATA(pgm)->xtal = v*1e6;
my.xtal = v*1e6;
else if(*endp == 'k' || *endp == 'K')
PDATA(pgm)->xtal = v*1e3;
my.xtal = v*1e3;
else if(*endp == 0 || *endp == 'h' || *endp == 'H') // "nnnn" or "nnnnHz"
PDATA(pgm)->xtal = v;
my.xtal = v;
continue;
}
}
@@ -890,16 +890,16 @@ retry:
// Support large flash by sending the correct extended address byte when needed
if(pgm->prog_modes & PM_SPM) { // Bootloaders, eg, optiboot, optiboot_dx, optiboot_x
if(pgm->prog_modes & PM_SPM) { // Bootloaders, eg, optiboot, optiboot_dx, optiboot_x
if(mem->size/a_div > 64*1024) { // Extended addressing needed
ext_byte = (addr >> 16) & 0xff;
if(ext_byte != PDATA(pgm)->ext_addr_byte) { // First addr load or a different 64k section
if(ext_byte != my.ext_addr_byte) { // First addr load or a different 64k section
buf[0] = 0x4d; // Protocol bytes that bootloaders expect
buf[1] = 0x00;
buf[2] = ext_byte;
buf[3] = 0x00;
if(stk500_cmd(pgm, buf, buf) == 0)
PDATA(pgm)->ext_addr_byte = ext_byte;
my.ext_addr_byte = ext_byte;
}
/*
* Ensure next paged r/w will load ext addr again if page sits just below
@@ -915,19 +915,19 @@ retry:
* exposes the discrepancy.
*/
if((addr & 0xffff0000) != ((addr + mem->page_size/a_div) & 0xffff0000))
PDATA(pgm)->ext_addr_byte = 0xff;
my.ext_addr_byte = 0xff;
}
} else { // Programmer *not* for bootloaders? Original stk500v1 protocol!
OPCODE *lext = mem->op[AVR_OP_LOAD_EXT_ADDR];
if(lext) {
ext_byte = (addr >> 16) & 0xff;
if(ext_byte != PDATA(pgm)->ext_addr_byte) { // First addr load or a different 64k section
if(ext_byte != my.ext_addr_byte) { // First addr load or a different 64k section
memset(buf, 0, 4); // Part's load_ext_addr command is typically 4d 00 ext_addr 00
avr_set_bits(lext, buf);
avr_set_addr(lext, buf, addr);
if(stk500_cmd(pgm, buf, buf) == 0)
PDATA(pgm)->ext_addr_byte = ext_byte;
my.ext_addr_byte = ext_byte;
}
}
}
@@ -1215,7 +1215,7 @@ static int stk500_set_fosc(const PROGRAMMER *pgm, double v) {
prescale = cmatch = 0;
if(v > 0.0) {
if(v > PDATA(pgm)->xtal/2.0) {
if(v > my.xtal/2.0) {
const char *unit;
if(v >= 1e6) {
@@ -1226,21 +1226,21 @@ static int stk500_set_fosc(const PROGRAMMER *pgm, double v) {
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.0;
pmsg_warning("f = %.3f %s too high, using %.3f MHz\n", v, unit, my.xtal/2e6);
fosc = my.xtal/2.0;
} else
fosc = (unsigned) v;
for(idx = 0; idx < sizeof(ps)/sizeof(ps[0]); idx++) {
if(fosc >= PDATA(pgm)->xtal/(256*ps[idx] * 2)) {
if(fosc >= my.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) (my.xtal/(2*fosc*ps[idx])) - 1;
break;
}
}
if(idx == sizeof(ps)/sizeof(ps[0])) {
pmsg_warning("f = %u Hz too low, using %u Hz\n", fosc, PDATA(pgm)->xtal/(256*1024*2));
pmsg_warning("f = %u Hz too low, using %u Hz\n", fosc, my.xtal/(256*1024*2));
prescale = idx;
cmatch = 255;
}
@@ -1277,7 +1277,7 @@ static int stk500_get_fosc(const PROGRAMMER *pgm, double *v) {
return rc;
}
*v = !prescale? 0: PDATA(pgm)->xtal/((cmatch + 1)*2*ps[prescale - 1]);
*v = !prescale? 0: my.xtal/((cmatch + 1)*2*ps[prescale - 1]);
return 0;
}
@@ -1295,7 +1295,7 @@ static int stk500_set_sck_period(const PROGRAMMER *pgm, double v) {
double min, max;
int rv = 0;
min = 8.0/PDATA(pgm)->xtal;
min = 8.0/my.xtal;
max = 255*min;
dur = v/min + 0.5;
@@ -1322,7 +1322,7 @@ static int stk500_get_sck_period(const PROGRAMMER *pgm, double *v) {
pmsg_error("cannot obtain Parm_STK_SCK_DURATION\n");
return rv;
}
*v = dur*8.0/PDATA(pgm)->xtal;
*v = dur*8.0/my.xtal;
return 0;
}
@@ -1477,7 +1477,7 @@ static void stk500_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp)
fmsg_out(fp, "Off\n");
else {
int prescale = 1;
double f = PDATA(pgm)->xtal/2.0;
double f = my.xtal/2.0;
switch(osc_pscale) {
case 2:
@@ -1508,9 +1508,9 @@ static void stk500_print_parms1(const PROGRAMMER *pgm, const char *p, FILE *fp)
}
stk500_getparm(pgm, Parm_STK_SCK_DURATION, &sck_duration);
fmsg_out(fp, "%sSCK period : %.1f us\n", p, sck_duration*8.0e6/PDATA(pgm)->xtal + 0.0499);
fmsg_out(fp, "%sSCK period : %.1f us\n", p, sck_duration*8.0e6/my.xtal + 0.0499);
double f = PDATA(pgm)->xtal;
double f = my.xtal;
decimals = get_decimals(f);
f = f_to_kHz_MHz(f, &unit);
@@ -1525,16 +1525,16 @@ static void stk500_print_parms(const PROGRAMMER *pgm, FILE *fp) {
static void stk500_setup(PROGRAMMER *pgm) {
pgm->cookie = mmt_malloc(sizeof(struct pdata));
PDATA(pgm)->ext_addr_byte = 0xff;
PDATA(pgm)->xbeeResetPin = XBEE_DEFAULT_RESET_PIN;
my.ext_addr_byte = 0xff;
my.xbeeResetPin = XBEE_DEFAULT_RESET_PIN;
// nanoSTK (Arduino Nano HW) uses 16 MHz
if(str_starts(pgmid, "nanoSTK"))
PDATA(pgm)->xtal = 16000000U;
my.xtal = 16000000U;
else
PDATA(pgm)->xtal = STK500_XTAL;
my.xtal = STK500_XTAL;
// The -c arduino programmer has auto-reset enabled be default
if(str_eq(pgm->type, "Arduino"))
PDATA(pgm)->autoreset = true;
my.autoreset = true;
}
static void stk500_teardown(PROGRAMMER *pgm) {

2
src/stk500.h
View File

@@ -62,5 +62,5 @@ struct pdata {
bool autoreset;
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
#endif

552
src/stk500v2.c
View File

File diff suppressed because it is too large Load Diff

18
src/teensy.c
View File

@@ -59,7 +59,7 @@
#define TEENSY_CONNECT_WAIT 100
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// -----------------------------------------------------------------------------
@@ -229,7 +229,7 @@ static void teensy_teardown(PROGRAMMER *pgm) {
static int teensy_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
pmsg_debug("teensy_initialize()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
int result = teensy_get_bootloader_info(pdata, p);
@@ -252,7 +252,7 @@ static void teensy_powerup(const PROGRAMMER *pgm) {
static void teensy_powerdown(const PROGRAMMER *pgm) {
pmsg_debug("teensy_powerdown()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(pdata->erase_flash) {
teensy_erase_flash(pdata);
@@ -286,7 +286,7 @@ static int teensy_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p, const
return -1;
}
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
memcpy(mem->buf, pdata->sig_bytes, sizeof(pdata->sig_bytes));
@@ -296,7 +296,7 @@ static int teensy_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *p, const
static int teensy_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
pmsg_debug("teensy_chip_erase()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
// Schedule a chip erase, either at first write or on powerdown.
pdata->erase_flash = true;
@@ -307,7 +307,7 @@ static int teensy_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
static int teensy_open(PROGRAMMER *pgm, const char *port) {
pmsg_debug("teensy_open(\"%s\")\n", port);
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
const char *bus_name = NULL;
char *dev_name = NULL;
@@ -400,7 +400,7 @@ static int teensy_open(PROGRAMMER *pgm, const char *port) {
static void teensy_close(PROGRAMMER *pgm) {
pmsg_debug("teensy_close()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(pdata->hid_handle != NULL) {
hid_close(pdata->hid_handle);
@@ -438,7 +438,7 @@ static int teensy_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVR
pmsg_debug("teensy_paged_write(page_size=0x%X, addr=0x%X, n_bytes=0x%X)\n", page_size, addr, n_bytes);
if(mem_is_flash(mem)) {
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
if(n_bytes > page_size) {
pmsg_error("buffer size %u exceeds page size %u\n", n_bytes, page_size);
@@ -485,7 +485,7 @@ static int teensy_parseextparams(const PROGRAMMER *pgm, const LISTID xparams) {
pmsg_debug("teensy_parseextparams()\n");
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
for(LNODEID node = lfirst(xparams); node; node = lnext(node)) {
const char *extended_param = ldata(node);

68
src/usbasp.c
View File

@@ -88,12 +88,12 @@ struct pdata {
int USB_init; // Used in both usbOpenDevice() variants
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
#ifdef USE_LIBUSB_1_0
static const char *errstr(const PROGRAMMER *pgm, int result) {
char *msg = PDATA(pgm)->msg;
size_t msgsiz = sizeof(PDATA(pgm)->msg);
char *msg = my.msg;
size_t msgsiz = sizeof(my.msg);
int n = 0;
switch(result) {
@@ -212,21 +212,21 @@ static int usbasp_tpi_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const
// Dispatching wrappers
static int usbasp_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) {
return PDATA(pgm)->use_tpi? usbasp_tpi_cmd(pgm, cmd, res): usbasp_spi_cmd(pgm, cmd, res);
return my.use_tpi? usbasp_tpi_cmd(pgm, cmd, res): usbasp_spi_cmd(pgm, cmd, res);
}
static int usbasp_program_enable(const PROGRAMMER *pgm, const AVRPART *p) {
return PDATA(pgm)->use_tpi? usbasp_tpi_program_enable(pgm, p): usbasp_spi_program_enable(pgm, p);
return my.use_tpi? usbasp_tpi_program_enable(pgm, p): usbasp_spi_program_enable(pgm, p);
}
static int usbasp_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
return PDATA(pgm)->use_tpi? usbasp_tpi_chip_erase(pgm, p): usbasp_spi_chip_erase(pgm, p);
return my.use_tpi? usbasp_tpi_chip_erase(pgm, p): usbasp_spi_chip_erase(pgm, p);
}
static int usbasp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return PDATA(pgm)->use_tpi?
return my.use_tpi?
usbasp_tpi_paged_load(pgm, p, m, page_size, addr, n_bytes):
usbasp_spi_paged_load(pgm, p, m, page_size, addr, n_bytes);
}
@@ -234,19 +234,19 @@ static int usbasp_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
static int usbasp_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
unsigned int page_size, unsigned int addr, unsigned int n_bytes) {
return PDATA(pgm)->use_tpi?
return my.use_tpi?
usbasp_tpi_paged_write(pgm, p, m, page_size, addr, n_bytes):
usbasp_spi_paged_write(pgm, p, m, page_size, addr, n_bytes);
}
static int usbasp_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
return PDATA(pgm)->use_tpi? usbasp_tpi_set_sck_period(pgm, sckperiod): usbasp_spi_set_sck_period(pgm, sckperiod);
return my.use_tpi? usbasp_tpi_set_sck_period(pgm, sckperiod): usbasp_spi_set_sck_period(pgm, sckperiod);
}
static int usbasp_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m,
unsigned long addr, unsigned char *value) {
return PDATA(pgm)->use_tpi?
return my.use_tpi?
usbasp_tpi_read_byte(pgm, p, m, addr, value):
avr_read_byte_default(pgm, p, m, addr, value);
}
@@ -264,7 +264,7 @@ static int usbasp_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRM
return -1;
}
return PDATA(pgm)->use_tpi?
return my.use_tpi?
usbasp_tpi_write_byte(pgm, p, m, addr, data):
avr_write_byte_default(pgm, p, m, addr, data);
}
@@ -288,7 +288,7 @@ static int usbasp_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
if(str_eq(extended_param, "section_config")) {
pmsg_notice2("%s(): set section_e to 1 (config section)\n", __func__);
PDATA(pgm)->section_e = 1;
my.section_e = 1;
continue;
}
@@ -388,7 +388,7 @@ static int usbasp_transmit(const PROGRAMMER *pgm,
}
#ifdef USE_LIBUSB_1_0
nbytes = libusb_control_transfer(PDATA(pgm)->usbhandle,
nbytes = libusb_control_transfer(my.usbhandle,
(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | (receive << 7)) & 0xff,
functionid & 0xff,
((send[1] << 8) | send[0]) & 0xffff, ((send[3] << 8) | send[2]) & 0xffff, buffer, buffersize & 0xffff, 5000);
@@ -397,7 +397,7 @@ static int usbasp_transmit(const PROGRAMMER *pgm,
return -1;
}
#else
nbytes = usb_control_msg(PDATA(pgm)->usbhandle,
nbytes = usb_control_msg(my.usbhandle,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | (receive << 7),
functionid, (send[1] << 8) | send[0], (send[3] << 8) | send[2], (char *) buffer, buffersize, 5000);
if(nbytes < 0) {
@@ -456,13 +456,13 @@ static int usbOpenDevice(const PROGRAMMER *pgm, libusb_device_handle ** device,
int j;
int r;
if(!PDATA(pgm)->USB_init) {
PDATA(pgm)->USB_init = 1;
libusb_init(&PDATA(pgm)->ctx);
if(!my.USB_init) {
my.USB_init = 1;
libusb_init(&my.ctx);
}
libusb_device **dev_list;
int dev_list_len = libusb_get_device_list(PDATA(pgm)->ctx, &dev_list);
int dev_list_len = libusb_get_device_list(my.ctx, &dev_list);
for(j = 0; j < dev_list_len; ++j) {
libusb_device *dev = dev_list[j];
@@ -546,8 +546,8 @@ static int usbOpenDevice(const PROGRAMMER *pgm, usb_dev_handle ** device, int ve
usb_dev_handle *handle = NULL;
int errorCode = USB_ERROR_NOTFOUND;
if(!PDATA(pgm)->USB_init) {
PDATA(pgm)->USB_init = 1;
if(!my.USB_init) {
my.USB_init = 1;
usb_init();
}
usb_find_busses();
@@ -634,10 +634,10 @@ static int usbasp_open(PROGRAMMER *pgm, const char *port) {
pid = USBASP_SHARED_PID;
}
vid = pgm->usbvid? pgm->usbvid: USBASP_SHARED_VID;
if(usbOpenDevice(pgm, &PDATA(pgm)->usbhandle, vid, pgm->usbvendor, pid, pgm->usbproduct, port) != 0) {
if(usbOpenDevice(pgm, &my.usbhandle, vid, pgm->usbvendor, pid, pgm->usbproduct, port) != 0) {
if(str_eq(pgmid, "usbasp")) {
// Check if device with old VID/PID is available
if(usbOpenDevice(pgm, &PDATA(pgm)->usbhandle, USBASP_OLD_VID, "www.fischl.de",
if(usbOpenDevice(pgm, &my.usbhandle, USBASP_OLD_VID, "www.fischl.de",
USBASP_OLD_PID, "USBasp", port) == 0) {
cx->usb_access_error = 0;
@@ -669,26 +669,26 @@ static int usbasp_open(PROGRAMMER *pgm, const char *port) {
static void usbasp_close(PROGRAMMER *pgm) {
pmsg_debug("usbasp_close()\n");
if(PDATA(pgm)->usbhandle != NULL) {
if(my.usbhandle != NULL) {
unsigned char temp[4];
memset(temp, 0, sizeof(temp));
if(PDATA(pgm)->use_tpi) {
if(my.use_tpi) {
usbasp_transmit(pgm, 1, USBASP_FUNC_TPI_DISCONNECT, temp, temp, sizeof(temp));
} else {
usbasp_transmit(pgm, 1, USBASP_FUNC_DISCONNECT, temp, temp, sizeof(temp));
}
#ifdef USE_LIBUSB_1_0
libusb_close(PDATA(pgm)->usbhandle);
libusb_close(my.usbhandle);
#else
usb_close(PDATA(pgm)->usbhandle);
usb_close(my.usbhandle);
#endif
}
#ifdef USE_LIBUSB_1_0
libusb_exit(PDATA(pgm)->ctx);
libusb_exit(my.ctx);
#else
// Nothing for usb 0.1?
#endif
@@ -710,7 +710,7 @@ static void usbasp_display(const PROGRAMMER *pgm, const char *p) {
static int usbasp_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
unsigned char temp[4];
unsigned char res[4];
struct pdata *pdata = PDATA(pgm);
struct pdata *pdata = &my;
pmsg_debug("usbasp_initialize()\n");
@@ -832,7 +832,7 @@ static int usbasp_spi_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const
}
// Set blocksize depending on sck frequency
if((PDATA(pgm)->sckfreq_hz > 0) && (PDATA(pgm)->sckfreq_hz < 10000)) {
if((my.sckfreq_hz > 0) && (my.sckfreq_hz < 10000)) {
blocksize = USBASP_READBLOCKSIZE/10;
} else {
blocksize = USBASP_READBLOCKSIZE;
@@ -898,7 +898,7 @@ static int usbasp_spi_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const
}
// Set blocksize depending on sck frequency
if((PDATA(pgm)->sckfreq_hz > 0) && (PDATA(pgm)->sckfreq_hz < 10000)) {
if((my.sckfreq_hz > 0) && (my.sckfreq_hz < 10000)) {
blocksize = USBASP_WRITEBLOCKSIZE/10;
} else {
blocksize = USBASP_WRITEBLOCKSIZE;
@@ -977,7 +977,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
memset(res, 0, sizeof(res));
// Reset global sck frequency to auto
PDATA(pgm)->sckfreq_hz = 0;
my.sckfreq_hz = 0;
if(sckperiod == 0) {
// Auto sck set
@@ -993,7 +993,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
// Check if programmer is capable of 3 MHz SCK, if not then ommit 3 MHz setting
size_t i;
if(PDATA(pgm)->sck_3mhz) {
if(my.sck_3mhz) {
pmsg_notice2("connected USBasp is capable of 3 MHz SCK\n");
i = 0;
} else {
@@ -1017,7 +1017,7 @@ static int usbasp_spi_set_sck_period(const PROGRAMMER *pgm, double sckperiod) {
}
// Save used sck frequency
PDATA(pgm)->sckfreq_hz = usefreq;
my.sckfreq_hz = usefreq;
pmsg_info("set SCK frequency to %i Hz\n", usefreq);
}
@@ -1126,7 +1126,7 @@ static int usbasp_tpi_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) {
int pr_1;
int nvm_cmd;
switch(PDATA(pgm)->section_e) {
switch(my.section_e) {
// Config bits section erase
case 1:
pr_0 = 0x41;

88
src/usbtiny.c
View File

@@ -70,7 +70,7 @@ struct pdata {
int retries;
};
#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
#define my (*(struct pdata *) (pgm->cookie))
// ----------------------------------------------------------------------
@@ -89,7 +89,7 @@ static int usb_control(const PROGRAMMER *pgm, unsigned int requestid,
int nbytes;
nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
nbytes = usb_control_msg(my.usb_handle,
USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid,
val, index, // 2 bytes each of data
NULL, 0, // No data buffer in control message
@@ -120,12 +120,12 @@ static int usb_in(const PROGRAMMER *pgm,
timeout = USB_TIMEOUT + (buflen*bitclk)/1000;
for(i = 0; i < 10; i++) {
nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
nbytes = usb_control_msg(my.usb_handle,
USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid, val, index, (char *) buffer, buflen, timeout);
if(nbytes == buflen) {
return nbytes;
}
PDATA(pgm)->retries++;
my.retries++;
}
msg_error("\n");
pmsg_error("%s (expected %d, got %d)\n", usb_strerror(), buflen, nbytes);
@@ -134,9 +134,9 @@ static int usb_in(const PROGRAMMER *pgm,
// Report the number of retries, and reset the counter.
static void check_retries(const PROGRAMMER *pgm, const char *operation) {
if(PDATA(pgm)->retries > 0)
pmsg_info("%d retries during %s\n", PDATA(pgm)->retries, operation);
PDATA(pgm)->retries = 0;
if(my.retries > 0)
pmsg_info("%d retries during %s\n", my.retries, operation);
my.retries = 0;
}
// Wrapper for simple usb_control_msg messages to send data to programmer
@@ -151,7 +151,7 @@ static int usb_out(const PROGRAMMER *pgm,
*/
timeout = USB_TIMEOUT + (buflen*bitclk)/1000;
nbytes = usb_control_msg(PDATA(pgm)->usb_handle,
nbytes = usb_control_msg(my.usb_handle,
USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, requestid, val, index, (char *) buffer, buflen, timeout);
if(nbytes != buflen) {
msg_error("\n");
@@ -202,7 +202,7 @@ static unsigned short tpi_frame(unsigned char b) {
static int usbtiny_tpi_tx(const PROGRAMMER *pgm, unsigned char b0) {
unsigned char res[4];
if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*PDATA(pgm)->sck_period) < 0)
if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*my.sck_period) < 0)
return -1;
msg_debug("CMD_TPI_TX: [0x%02x]\n", b0);
return 1;
@@ -213,7 +213,7 @@ static int usbtiny_tpi_txtx(const PROGRAMMER *pgm, unsigned char b0, unsigned ch
unsigned char res[4];
if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), tpi_frame(b1), res, sizeof(res),
8*sizeof(res)*PDATA(pgm)->sck_period) < 0) {
8*sizeof(res)*my.sck_period) < 0) {
return -1;
}
@@ -231,7 +231,7 @@ static int usbtiny_tpi_txrx(const PROGRAMMER *pgm, unsigned char b0) {
unsigned char res[4], r;
short w;
if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*PDATA(pgm)->sck_period) < 0)
if(usb_in(pgm, USBTINY_SPI, tpi_frame(b0), 0xffff, res, sizeof(res), 8*sizeof(res)*my.sck_period) < 0)
return -1;
w = (res[2] << 8) | res[3];
@@ -305,7 +305,7 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
usb_find_busses(); // Have libusb scan all the usb buses available
usb_find_devices(); // Have libusb scan all the usb devices available
PDATA(pgm)->usb_handle = NULL;
my.usb_handle = NULL;
if(pgm->usbvid)
vid = pgm->usbvid;
@@ -330,10 +330,10 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
// If -P was given, match device by device name and bus name
if(name != NULL && (NULL == dev_name || !str_eq(bus->dirname, bus_name) || !str_eq(dev->filename, dev_name)))
continue;
PDATA(pgm)->usb_handle = usb_open(dev); // Attempt to connect to device
my.usb_handle = usb_open(dev); // Attempt to connect to device
// Wrong permissions or something?
if(!PDATA(pgm)->usb_handle) {
if(!my.usb_handle) {
pmsg_warning("cannot open USB device: %s\n", usb_strerror());
continue;
}
@@ -345,7 +345,7 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
pmsg_error("invalid -P %s; use -P usb:bus:device\n", name);
return -1;
}
if(!PDATA(pgm)->usb_handle) {
if(!my.usb_handle) {
pmsg_error("cannot find USBtiny device (0x%x/0x%x)\n", vid, pid);
return -1;
}
@@ -355,19 +355,19 @@ static int usbtiny_open(PROGRAMMER *pgm, const char *name) {
// Clean up the handle for the usbtiny
static void usbtiny_close(PROGRAMMER *pgm) {
if(!PDATA(pgm)->usb_handle) // Not a valid handle, bail!
if(!my.usb_handle) // Not a valid handle, bail!
return;
usb_close(PDATA(pgm)->usb_handle); // Ask libusb to clean up
PDATA(pgm)->usb_handle = NULL;
usb_close(my.usb_handle); // Ask libusb to clean up
my.usb_handle = NULL;
}
/* A simple calculator function determines the maximum size of data we can
shove through a USB connection without getting errors */
static void usbtiny_set_chunk_size(const PROGRAMMER *pgm, int period) {
PDATA(pgm)->chunk_size = CHUNK_SIZE; // Start with the maximum (default)
while(PDATA(pgm)->chunk_size > 8 && period > 16) {
my.chunk_size = CHUNK_SIZE; // Start with the maximum (default)
while(my.chunk_size > 8 && period > 16) {
// Reduce the chunk size for a slow SCK to reduce the maximum time of a single USB transfer
PDATA(pgm)->chunk_size >>= 1;
my.chunk_size >>= 1;
period >>= 1;
}
}
@@ -375,24 +375,24 @@ static void usbtiny_set_chunk_size(const PROGRAMMER *pgm, int period) {
/* Given a SCK bit-clock speed (in useconds) we verify its an OK speed and tell the
USBtiny to update itself to the new frequency */
static int usbtiny_set_sck_period(const PROGRAMMER *pgm, double v) {
PDATA(pgm)->sck_period = (int) (v*1e6 + 0.5); // Convert from us to int, the 0.5 is for rounding up
my.sck_period = (int) (v*1e6 + 0.5); // Convert from us to int, the 0.5 is for rounding up
// Make sure its not 0, as that will confuse the usbtiny
if(PDATA(pgm)->sck_period < SCK_MIN)
PDATA(pgm)->sck_period = SCK_MIN;
if(my.sck_period < SCK_MIN)
my.sck_period = SCK_MIN;
// We can't go slower, due to the byte-size of the clock variable
if(PDATA(pgm)->sck_period > SCK_MAX)
PDATA(pgm)->sck_period = SCK_MAX;
if(my.sck_period > SCK_MAX)
my.sck_period = SCK_MAX;
pmsg_notice("setting SCK period to %d usec\n", PDATA(pgm)->sck_period);
pmsg_notice("setting SCK period to %d usec\n", my.sck_period);
// Send the command to the usbtiny device; MEME: for at90's fix resetstate?
if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
return -1;
// With the new speed, we'll have to update how much data we send per usb transfer
usbtiny_set_chunk_size(pgm, PDATA(pgm)->sck_period);
usbtiny_set_chunk_size(pgm, my.sck_period);
return 0;
}
@@ -406,11 +406,11 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
usbtiny_set_sck_period(pgm, pgm->bitclock);
} else {
// -B option not specified: use default
PDATA(pgm)->sck_period = SCK_DEFAULT;
pmsg_notice("using SCK period of %d usec\n", PDATA(pgm)->sck_period);
if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
my.sck_period = SCK_DEFAULT;
pmsg_notice("using SCK period of %d usec\n", my.sck_period);
if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
return -1;
usbtiny_set_chunk_size(pgm, PDATA(pgm)->sck_period);
usbtiny_set_chunk_size(pgm, my.sck_period);
}
// Let the device wake up.
@@ -426,7 +426,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
memset(res, 0xaa, sizeof(res));
if(usb_in(pgm, USBTINY_SPI, LITTLE_TO_BIG_16(0x1234), LITTLE_TO_BIG_16(0x5678),
res, 4, 32*PDATA(pgm)->sck_period) < 0) {
res, 4, 32*my.sck_period) < 0) {
pmsg_error("usb_in() failed\n");
return -1;
@@ -439,7 +439,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
}
// Keep TPIDATA high for >= 16 clock cycles:
if(usb_in(pgm, USBTINY_SPI, 0xffff, 0xffff, res, 4, 32*PDATA(pgm)->sck_period) < 0) {
if(usb_in(pgm, USBTINY_SPI, 0xffff, 0xffff, res, 4, 32*my.sck_period) < 0) {
pmsg_error("unable to switch chip into TPI mode\n");
return -1;
}
@@ -449,8 +449,8 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
if(pgm->program_enable(pgm, p) >= 0)
break;
// No response, RESET and try again
if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_HIGH, 0) < 0 ||
usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, RESET_LOW, 0) < 0)
if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_HIGH, 0) < 0 ||
usb_control(pgm, USBTINY_POWERUP, my.sck_period, RESET_LOW, 0) < 0)
return -1;
usleep(50000);
}
@@ -462,7 +462,7 @@ static int usbtiny_initialize(const PROGRAMMER *pgm, const AVRPART *p) {
static int usbtiny_setpin(const PROGRAMMER *pgm, int pinfunc, int value) {
// USBtiny is not a bit bang device, but it can set RESET
if(pinfunc == PIN_AVR_RESET) {
if(usb_control(pgm, USBTINY_POWERUP, PDATA(pgm)->sck_period, value? RESET_HIGH: RESET_LOW, 0) < 0)
if(usb_control(pgm, USBTINY_POWERUP, my.sck_period, value? RESET_HIGH: RESET_LOW, 0) < 0)
return -1;
usleep(50000);
return 0;
@@ -472,7 +472,7 @@ static int usbtiny_setpin(const PROGRAMMER *pgm, int pinfunc, int value) {
// Tell the USBtiny to release the output pins, etc
static void usbtiny_powerdown(const PROGRAMMER *pgm) {
if(!PDATA(pgm)->usb_handle)
if(!my.usb_handle)
return; // Wasn't connected in the first place
usb_control(pgm, USBTINY_POWERDOWN, 0, 0, 1);
}
@@ -487,7 +487,7 @@ static int usbtiny_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned
nbytes = usb_in(pgm, USBTINY_SPI, (cmd[1] << 8) | cmd[0], // Convert to 16-bit words
(cmd[3] << 8) | cmd[2], // "
res, 4, 8*PDATA(pgm)->sck_period);
res, 4, 8*my.sck_period);
if(nbytes < 0)
return -1;
check_retries(pgm, "SPI command");
@@ -635,7 +635,7 @@ static int usbtiny_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVR
}
for(; addr < maxaddr; addr += chunk) {
chunk = PDATA(pgm)->chunk_size; // Start with the maximum chunk size possible
chunk = my.chunk_size; // Start with the maximum chunk size possible
if(addr + chunk > maxaddr)
chunk = maxaddr - addr;
@@ -645,7 +645,7 @@ static int usbtiny_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVR
addr, // Address in memory
m->buf + addr, // Pointer to where we store data
chunk, // Number of bytes
32*PDATA(pgm)->sck_period) < 0) { // Each byte gets turned into a 4-byte SPI cmd
32*my.sck_period) < 0) { // Each byte gets turned into a 4-byte SPI cmd
// usb_in() multiplies this per byte
return -1;
}
@@ -688,7 +688,7 @@ static int usbtiny_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
for(; addr < maxaddr; addr += chunk) {
// Start with the max chunk size
chunk = PDATA(pgm)->chunk_size;
chunk = my.chunk_size;
if(addr + chunk > maxaddr) {
chunk = maxaddr - addr;
}
@@ -703,7 +703,7 @@ static int usbtiny_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AV
m->buf + addr, // Pointer to data
chunk, // Number of bytes to write
// Each byte gets turned into a 4-byte SPI cmd; usb_out() multiplies this per byte; then add the cmd-delay
32*PDATA(pgm)->sck_period + delay) < 0) {
32*my.sck_period + delay) < 0) {
return -1;
}

16
src/wiring.c
View File

@@ -58,7 +58,7 @@ struct wiringpdata {
// pdata is stk500v2's private data (inherited)
#define WIRINGPDATA(pgm) ((struct wiringpdata *)(((struct pdata *)(pgm->cookie)) -> chained_pdata))
#define mywiring (*(struct wiringpdata *) (((struct pdata *) (pgm->cookie)) -> chained_pdata))
static void wiring_setup(PROGRAMMER *pgm) {
// First, have STK500v2 backend allocate its own private data
@@ -92,7 +92,7 @@ static int wiring_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
break;
}
pmsg_notice2("%s(): snooze time set to %d ms\n", __func__, val);
WIRINGPDATA(pgm)->snoozetime = val;
mywiring.snoozetime = val;
continue;
}
@@ -105,12 +105,12 @@ static int wiring_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
break;
}
pmsg_notice2("%s(): delay set to %d ms\n", __func__, val);
WIRINGPDATA(pgm)->delay = val;
mywiring.delay = val;
continue;
}
if(str_eq(extended_param, "noautoreset")) {
WIRINGPDATA(pgm)->noautoreset = true;
mywiring.noautoreset = true;
continue;
}
@@ -144,14 +144,14 @@ static int wiring_open(PROGRAMMER *pgm, const char *port) {
serial_open(port, pinfo, &pgm->fd);
// If we have a snoozetime, then we wait and do NOT toggle DTR/RTS
if(WIRINGPDATA(pgm)->snoozetime > 0) {
timetosnooze = WIRINGPDATA(pgm)->snoozetime;
if(mywiring.snoozetime > 0) {
timetosnooze = mywiring.snoozetime;
pmsg_notice2("%s(): snoozing for %d ms\n", __func__, timetosnooze);
while(timetosnooze--)
usleep(1000);
pmsg_notice2("%s(): done snoozing\n", __func__);
} else if(WIRINGPDATA(pgm)->noautoreset == false) {
} else if(mywiring.noautoreset == false) {
// This code assumes a negative-logic USB to TTL serial adapter
// Set RTS/DTR high to discharge the series-capacitor, if present
pmsg_notice2("%s(): releasing DTR/RTS\n", __func__);
@@ -167,7 +167,7 @@ static int wiring_open(PROGRAMMER *pgm, const char *port) {
// Set the RTS/DTR line back to high, so direct connection to reset works
serial_set_dtr_rts(&pgm->fd, 0);
int delay = WIRINGPDATA(pgm)->delay;
int delay = mywiring.delay;
if((100 + delay) > 0)
usleep((100 + delay)*1000); // Wait until board comes out of reset

8
src/xbee.c
View File

@@ -1424,7 +1424,7 @@ static int xbee_open(PROGRAMMER *pgm, const char *port) {
// Wireless is lossier than normal serial
serial_recv_timeout = 1000;
serdev = &PDATA(pgm)->xbee_serdev;
serdev = &my.xbee_serdev;
serdev->open = xbeedev_open;
serdev->close = xbeedev_close;
serdev->rawclose = xbeedev_close;
@@ -1438,7 +1438,7 @@ static int xbee_open(PROGRAMMER *pgm, const char *port) {
return -1;
}
xbeedev_setresetpin(&pgm->fd, PDATA(pgm)->xbeeResetPin);
xbeedev_setresetpin(&pgm->fd, my.xbeeResetPin);
// Clear DTR and RTS
serial_set_dtr_rts(&pgm->fd, 0);
@@ -1514,7 +1514,7 @@ static int xbee_parseextparms(const PROGRAMMER *pgm, const LISTID extparms) {
break;
}
PDATA(pgm)->xbeeResetPin = resetpin;
my.xbeeResetPin = resetpin;
continue;
}
@@ -1542,7 +1542,7 @@ void xbee_initpgm(PROGRAMMER *pgm) {
/*
* This behaves like an Arduino, but with packet encapsulation of the serial
* streams, XBee device management, and XBee GPIO for the Auto-Reset feature.
* stk500.c sets PDATA(pgm)->xbeeResetPin
* stk500.c sets my.xbeeResetPin
*/
stk500_initpgm(pgm);