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
Files
eca2c5f88e134776bbf3e092b510d94fc2c3876d
avrdude/src/main.c

1939 lines
61 KiB
C
Raw Blame History

/*
* avrdude - A Downloader/Uploader for AVR device programmers
* Copyright (C) 2000-2005 Brian S. Dean <bsd@bdmicro.com>
* Copyright (C) Joerg Wunsch <j@uriah.heep.sax.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Program an Atmel AVR device through one of the supported programmers
*
* For parallel port connected programmers, the pin definitions can be changed
* via a config file. See the config file for instructions on how to add a
* programmer definition.
*
*/
// For AVRDUDE_FULL_VERSION and possibly others
#include <ac_cfg.h>
#include <stdio.h>
#include <stdlib.h>
#include <whereami.h>
#include <stdarg.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <ctype.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#if !defined(WIN32)
#include <dirent.h>
#endif
#include "avrdude.h"
#include "libavrdude.h"
#include "config.h"
#include "developer_opts.h"
char *progname = "avrdude";
static const char *avrdude_message_type(int msglvl) {
switch(msglvl) {
case MSG_EXT_ERROR:
return "OS error";
case MSG_ERROR:
return "error";
case MSG_WARNING:
return "warning";
case MSG_INFO:
return "info";
case MSG_NOTICE:
return "notice";
case MSG_NOTICE2:
return "notice2";
case MSG_DEBUG:
return "debug";
case MSG_TRACE:
return "trace";
case MSG_TRACE2:
return "trace2";
default:
return "unknown msglvl";
}
}
/*
* Core messaging routine for msg_xyz(), [pli]msg_xyz() and term_out()
* See #define lines in avrdude.h of how it is normally called
*
* Named that way as there used to be a now gone different avrdude_message()
*/
int avrdude_message2(FILE *fp, int lno, const char *file, const char *func,
int msgmode, int msglvl, const char *format, ...) {
int rc = 0;
va_list ap;
static struct { // Memorise whether last print ended at beginning of line
FILE *fp;
int bol; // Are we at the beginning of a line for this fp stream?
} bols[5 + 1]; // Cater for up to 5 different FILE pointers plus one catch-all
size_t bi = 0; // bi is index to bols[] array
for(bi = 0; bi < sizeof bols/sizeof *bols - 1; bi++) { // Note the -1, so bi is valid after loop
if(!bols[bi].fp) { // First free space
bols[bi].fp = fp; // Insert fp in first free space
bols[bi].bol = 1; // Assume beginning of line on first use
}
if(bols[bi].fp == fp)
break;
}
if(msglvl <= MSG_ERROR) // Serious error? Free progress bars (if any)
report_progress(1, -1, NULL);
if(msgmode & MSG2_FLUSH) {
fflush(stdout);
fflush(stderr);
}
// Reduce effective verbosity level by number of -q above one when printing to stderr
if((fp == stderr? verblevel: verbose) >= msglvl) {
if(msgmode & MSG2_LEFT_MARGIN && !bols[bi].bol) {
fprintf(fp, "\n");
bols[bi].bol = 1;
}
// Keep vertical tab at start of format string as conditional new line
if(*format == '\v') {
format++;
if(!bols[bi].bol) {
fprintf(fp, "\n");
bols[bi].bol = 1;
}
}
if(msgmode & (MSG2_PROGNAME | MSG2_TYPE)) {
if(msgmode & MSG2_PROGNAME) {
fprintf(fp, "%s", progname);
bols[bi].bol = 0;
}
if(msgmode & MSG2_TYPE) {
const char *mt = avrdude_message_type(msglvl);
if(bols[bi].bol)
fprintf(fp, "%c%s", msgmode & (MSG2_UCFIRST)? toupper(*mt & 0xff): *mt, mt + 1);
else
fprintf(fp, " %s", mt);
bols[bi].bol = 0;
}
if(verblevel >= MSG_NOTICE2) {
const char *bfname = strrchr(file, '/'); // Only print basename
#if defined (WIN32)
if(!bfname)
bfname = strrchr(file, '\\');
#endif
bfname = bfname? bfname + 1: file;
if(msgmode & MSG2_FUNCTION)
fprintf(fp, " %s()", func);
if(msgmode & MSG2_FILELINE)
fprintf(fp, " %s %d", bfname, lno);
}
fprintf(fp, ": ");
} else if(msgmode & MSG2_INDENT1) {
fprintf(fp, "%*s", (int) strlen(progname) + 1, "");
bols[bi].bol = 0;
} else if(msgmode & MSG2_INDENT2) {
fprintf(fp, "%*s", (int) strlen(progname) + 2, "");
bols[bi].bol = 0;
}
// Figure out whether this print will leave us at beginning of line
// Determine required size first
va_start(ap, format);
rc = vsnprintf(NULL, 0, format, ap);
va_end(ap);
if(rc < 0) // Some errror?
return 0;
rc++; // Accommodate terminating nul
char *p = mmt_malloc(rc);
va_start(ap, format);
rc = vsnprintf(p, rc, format, ap);
va_end(ap);
if(rc < 0) {
mmt_free(p);
return 0;
}
if(*p) { // Finally: print!
if(bols[bi].bol && (msgmode & MSG2_UCFIRST))
fprintf(fp, "%c%s", toupper(*p & 0xff), p + 1);
else
fprintf(fp, "%s", p);
bols[bi].bol = p[strlen(p) - 1] == '\n';
}
mmt_free(p);
}
if(msgmode & MSG2_FLUSH)
fflush(fp);
return rc;
}
struct list_walk_cookie {
FILE *f;
const char *prefix;
};
libavrdude_context *cx; // Context pointer, eventually the only global variable
static LISTID updates = NULL;
static LISTID extended_params = NULL;
static LISTID additional_config_files = NULL;
static PROGRAMMER *pgm;
// Global options
int verbose; // Verbose output
int quell_progress; // Quell progress report and un-verbose output
int ovsigck; // 1 = override sig check, 0 = don't
const char *partdesc; // Part -p string
const char *pgmid; // Programmer -c string
static char usr_config[PATH_MAX]; // Per-user config file
// Usage message
static void usage(void) {
char *home = getenv("HOME");
size_t l = home? strlen(home): 0;
char *cfg = home && str_casestarts(usr_config, home)?
mmt_sprintf("~/%s", usr_config + l + (usr_config[l] == '/')): mmt_sprintf("%s", usr_config);
msg_error("Usage: %s {<option>}\n"
"Options:\n"
" -p --part <part> Specify AVR device; -p ? lists all known parts\n"
" -p --part <wildcard>/<flags>\n"
" Run developer options for matched AVR devices,\n"
" e.g., -p ATmega328P/s or /S for part definition\n"
" -b --baud <baudrate> Override RS-232 baud rate\n"
" -B --bitclock <period> Bit clock period (us)\n"
" -C --config <file> Specify location of configuration file\n"
" -C --config +<file> Additional config file (*)\n"
" -N --noconfig Do not load %s%s\n"
" -c --programmer <pgm> Specify programmer; -c ? and -c ?type list all\n"
" -c --programmer <wildcard>/<flags>\n"
" Run developer options for matched programmers,\n"
" e.g., -c 'ur*'/s for programmer definition\n"
" -A --keep-trailing-0xff Disable trailing-0xff removal for file/AVR read\n"
" -D --noerase Disable auto-erase for flash memory; implies -A\n"
" -i --isp-clock-delay <delay>\n"
" Bit state change delay [in microseconds] for\n"
" bit-banged ISP and TPI programmers\n"
" -P --port <port> Connection; -P ?s or -P ?sa lists serial ones\n"
" -r --reconnect Reconnect to -P port after \"touching\" it; wait\n"
" 400 ms for each -r; needed for some USB boards\n"
" -F --force Override invalid signature or initial checks\n"
" -e --erase Perform a chip erase at the beginning\n"
" -O --osccal Perform RC oscillator calibration (see AVR053)\n"
" -t --terminal Run interactive terminal on its turn (*)\n"
" -T --command <line> Run terminal command <line> on its turn (*)\n"
" -U --memory <mem>:r|w|v:<file>[:fmt]\n"
" Carry out memory operation on its turn (*)\n"
" -n --test-memory Do not write to the device whilst processing -U\n"
" -V --noverify-memory Do not automatically verify during -U\n"
" -E --exitspecs <exitsp>{,<exitsp>}\n"
" Programmer exit specifications list\n"
" -x --extended <param> Pass <param> to programmer, see -x help (*)\n"
" -v --verbose Verbose output; -v -v for more\n"
" -q --quell Quell progress output; -q -q for less\n"
" -l --logfile logfile Use logfile rather than stderr for diagnostics\n"
" --version Print version and exit\n"
" -h --help Display this usage\n"
"(*) These options can be repeatedly used on the command line\n"
"\navrdude version %s https://github.com/avrdudes/avrdude\n",
progname, strlen(cfg) < 24? "config file ": "", cfg, AVRDUDE_FULL_VERSION);
mmt_free(cfg);
}
// Potentially shorten copy of prog description if it's the suggested mode
static void pmshorten(char *desc, const char *modes) {
struct {
const char *end, *mode;
} pairs[] = {
{" in parallel programming mode", "HVPP"},
{" in PP mode", "HVPP"},
{" in high-voltage serial programming mode", "HVSP"},
{" in HV serial programming mode", "HVSP"},
{" in HVSP mode", "HVSP"},
{" in ISP mode", "ISP"},
{" in ISP mode", "TPI, ISP"},
{" in TPI mode", "TPI"},
{" in debugWire mode", "debugWIRE"},
{" in AVR32 mode", "aWire"},
{" in PDI mode", "PDI"},
{" in UPDI mode", "UPDI"},
{" in JTAG mode", "JTAG"},
{" in JTAG mode", "JTAGmkI"},
{" in JTAG mode", "XMEGAJTAG"},
{" in JTAG mode", "AVR32JTAG"},
{" in JTAG mode", "JTAG, XMEGAJTAG, AVR32JTAG"},
{" in JTAG mode", "JTAG, XMEGAJTAG"},
{" for bootloader", "bootloader"},
};
size_t len = strlen(desc);
for(size_t i = 0; i < sizeof pairs/sizeof *pairs; i++) {
size_t elen = strlen(pairs[i].end);
if(len > elen && str_caseeq(desc + len - elen, pairs[i].end) && str_eq(modes, pairs[i].mode)) {
desc[len - elen] = 0;
break;
}
}
}
static void list_programmers(FILE *f, const char *prefix, LISTID programmers, int pm) {
LNODEID ln1;
LNODEID ln2;
PROGRAMMER *pgm;
int maxlen = 0, len;
PROGRAMMER *dry = locate_programmer(programmers, "dryrun");
sort_programmers(programmers);
// Compute max length of programmer names
for(ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
pgm = ldata(ln1);
if(!is_programmer(pgm))
continue;
for(ln2 = lfirst(pgm->id); ln2; ln2 = lnext(ln2))
if(!pm || !pgm->prog_modes || (pm & pgm->prog_modes)) {
const char *id = ldata(ln2);
if(*id == 0 || *id == '.')
continue;
if((len = strlen(id)) > maxlen)
maxlen = len;
}
}
for(ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
pgm = ldata(ln1);
if(!is_programmer(pgm))
continue;
for(ln2 = lfirst(pgm->id); ln2; ln2 = lnext(ln2)) {
// List programmer if pm or prog_modes uninitialised or if they are compatible otherwise
if(!pm || !pgm->prog_modes || (pm & pgm->prog_modes)) {
const char *id = ldata(ln2);
if(*id == 0 || *id == '.')
continue;
char *desc = mmt_strdup(pgm->desc);
const char *strmodes = str_prog_modes(pgm->prog_modes);
pmshorten(desc, avr_prog_modes(pm & pgm->prog_modes));
if(verbose > 0)
fprintf(f, "%s%-*s = %s (%s) [%s:%d]", prefix, maxlen, id, desc,
strmodes, pgm->config_file, pgm->lineno);
else
fprintf(f, "%s%-*s = %s (%s)", prefix, maxlen, id, desc, strmodes);
if(pm != ~0 && strchr(strmodes, ' ') && !(dry && pgm->initpgm == dry->initpgm))
fprintf(f, " via %s", str_prog_modes(pm & pgm->prog_modes));
fprintf(f, "\n");
mmt_free(desc);
}
}
}
}
static void list_programmer_types_callback(const char *name, const char *desc, void *cookie) {
struct list_walk_cookie *c = (struct list_walk_cookie *) cookie;
fprintf(c->f, "%s%-16s = %-s\n", c->prefix, name, desc);
}
static void list_programmer_types(FILE *f, const char *prefix) {
struct list_walk_cookie c;
c.f = f;
c.prefix = prefix;
walk_programmer_types(list_programmer_types_callback, &c);
}
// Return a list of long names for a part followed by prog modes in brackets
static const char *part_ccdesc(const AVRPART *p) {
char *name[5]; // Max 5 alternative names
int nn = 0, i;
char *pmodes = mmt_strdup(str_prog_modes(p->prog_modes));
char ret[6*(64+2) + 256 + 20], *r = ret;
// Create list name[] of alternative names to p->desc
for(LNODEID ln = lfirst(p->variants); ln; ln = lnext(ln)) {
const char *alt = ldata(ln), *end, *q;
if((end = strchr(alt, ':')) && end > alt && *alt != '-') {
if((q = strchr(alt, '-')) && q < end)
end = q;
if(strncasecmp(p->desc, alt, end-alt) || p->desc[end-alt]) { // Variant's base is not p->desc
// printf("X %.*s", (int) (end-alt), alt);
for(i = 0; i < nn; i++)
if(!strncasecmp(name[i], alt, end-alt) && !name[i][end-alt])
break;
if(i == nn && nn < 5)
name[nn++] = str_sprintf("%.*s", (int) (end-alt), alt);
}
}
}
sprintf(r, "%.64s", p->desc), r += strlen(r);
for(i = 0; i < nn; i++) {
sprintf(r, ", %.64s", name[i]), r += strlen(r);
mmt_free(name[i]);
}
sprintf(r, " (%.256s)", pmodes);
mmt_free(pmodes);
return str_ccprintf("%s", ret);
}
static void list_parts(FILE *f, const char *prefix, LISTID avrparts, int pm) {
LNODEID ln1;
AVRPART *p;
int maxlen = 0, len;
sort_avrparts(avrparts);
// Compute max length of part names
for(ln1 = lfirst(avrparts); ln1; ln1 = lnext(ln1)) {
p = ldata(ln1);
// List part if pm or prog_modes uninitialised or if they are compatible otherwise
if(!pm || !p->prog_modes || (pm & p->prog_modes)) {
if(verbose < MSG_NOTICE2 && p->id[0] == '.') // Hide ids starting with '.'
continue;
if((len = strlen(p->id)) > maxlen)
maxlen = len;
}
}
for(ln1 = lfirst(avrparts); ln1; ln1 = lnext(ln1)) {
p = ldata(ln1);
// List part if pm or prog_modes uninitialised or if they are compatible otherwise
if(!pm || !p->prog_modes || (pm & p->prog_modes)) {
if(verbose < MSG_NOTICE2 && p->id[0] == '.') // Hide ids starting with '.'
continue;
if(verbose > 0)
fprintf(f, "%s%-*s = %-18s [%s:%d]", prefix, maxlen, p->id, part_ccdesc(p),
p->config_file, p->lineno);
else
fprintf(f, "%s%-*s = %s", prefix, maxlen, p->id, part_ccdesc(p));
if(pm != ~0)
fprintf(f, " via %s", avr_prog_modes(pm & p->prog_modes));
fprintf(f, "\n");
if(verbose > 0)
for(LNODEID ln = lfirst(p->variants); ln; ln = lnext(ln))
fprintf(f, "%s%s- %s\n", prefix, prefix, (char *) ldata(ln));
}
}
}
static void exithook(void) {
if(pgm->teardown)
pgm->teardown(pgm);
}
static void cleanup_main(void) {
if(updates) {
ldestroy_cb(updates, (void (*)(void *)) free_update);
updates = NULL;
}
if(extended_params) {
ldestroy(extended_params);
extended_params = NULL;
}
if(additional_config_files) {
ldestroy(additional_config_files);
additional_config_files = NULL;
}
cleanup_config();
}
static void replace_backslashes(char *s) {
// Replace all backslashes with forward slashes
for(size_t i = 0; i < strlen(s); i++) {
if(s[i] == '\\') {
s[i] = '/';
}
}
}
// Return whether a part/programmer string is a developer option and if so which type
static int dev_opt(const char *str) {
return !str? 0: str_eq(str, "*") || str_starts(str, "*/s")? 2: // Print PART DEFINITIONS comment as well
strchr(str, '/') && !locate_part(part_list, str);
}
typedef struct {
size_t dist;
int common_modes;
const char *pgmid;
const char *desc;
} pgm_distance;
static int cmp_pgmid(const void *a, const void *b) {
const pgm_distance *pa = a, *pb = b;
int ret = pa->dist - pb->dist;
if(ret)
return ret;
return strcmp(pa->pgmid, pb->pgmid);
}
static int suggest_programmers(const char *programmer, LISTID programmers) {
const size_t max_distance = 64; // Don't show suggestions if they are way far out
int nid = 0; // Number of possible programmer ids
for(LNODEID ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
PROGRAMMER *pgm = ldata(ln1);
if(is_programmer(pgm))
for(LNODEID ln2 = lfirst(pgm->id); ln2; ln2 = lnext(ln2))
nid++;
}
pgm_distance *d = mmt_malloc(nid*sizeof *d);
// Fill d[] struct
int idx = 0;
AVRPART *p = locate_part(part_list, partdesc);
for(LNODEID ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
PROGRAMMER *pgm = ldata(ln1);
if(!is_programmer(pgm))
continue;
for(LNODEID ln2 = lfirst(pgm->id); ln2; ln2 = lnext(ln2)) {
if(idx < nid) {
d[idx].pgmid = ldata(ln2);
d[idx].desc = pgm->desc;
d[idx].dist = str_weighted_damerau_levenshtein(d[idx].pgmid, programmer);
d[idx].common_modes = pgm->prog_modes & (p? p->prog_modes: ~0);
idx++;
}
}
}
int n = 0, pgmid_maxlen = 0, comp = 0, len;
if(nid) { // Sort list so programmers according to string distance
qsort(d, nid, sizeof(*d), cmp_pgmid);
size_t dst = d[nid > 2? 2: nid - 1].dist;
if(dst > max_distance)
dst = max_distance;
for(; n < nid && d[n].dist <= dst; n++)
if(d[n].common_modes) {
if((len = strlen(d[n].pgmid)) > pgmid_maxlen)
pgmid_maxlen = len;
comp++;
}
}
if(comp) {
msg_info("similar programmer name%s:\n", str_plural(comp));
for(int i = 0; i < n; i++)
if(d[i].common_modes)
msg_info(" %-*s = %s\n", pgmid_maxlen, d[i].pgmid, d[i].desc);
}
mmt_free(d);
return n;
}
static void programmer_not_found(const char *programmer, const PROGRAMMER *pgm, const AVRPART *pt) {
int pmode = pt? pt->prog_modes: ~0;
if(!programmer || !*programmer) {
pmsg_error("no programmer has been specified on the command line or in the\n");
imsg_error("config file(s); specify one using the -c option and try again\n");
return;
}
if(str_eq(programmer, "?")) {
lmsg_error("Valid programmers are:\n");
list_programmers(stderr, " ", programmers, ~0);
msg_error("\n");
return;
}
sort_programmers(programmers);
// If there were partial matches then they were not unique: count and list them
int pmatches = 0, maxlen = 0, len;
for(LNODEID ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
PROGRAMMER *pg = ldata(ln1);
if(is_programmer(pg) && (pg->prog_modes & pmode))
for(LNODEID ln2 = lfirst(pg->id); ln2; ln2 = lnext(ln2)) {
const char *id = (const char *) ldata(ln2);
if(str_casestarts(id, programmer)) { // Partial initial match
pmatches++;
if((len = strlen(id)) > maxlen)
maxlen = len;
}
}
}
if(pmatches) {
pmsg_error("%s is not a unique start of a programmer name; consider:\n", programmer);
for(LNODEID ln1 = lfirst(programmers); ln1; ln1 = lnext(ln1)) {
PROGRAMMER *pg = ldata(ln1);
if(is_programmer(pg) && (pg->prog_modes & pmode))
for(LNODEID ln2 = lfirst(pg->id); ln2; ln2 = lnext(ln2)) {
const char *id = (const char *) ldata(ln2);
if(str_casestarts(id, programmer))
msg_error(" %-*s = %s\n", maxlen, id, pg->desc);
}
}
} else if(!pgm || !pgm->id || !lsize(pgm->id)) {
PROGRAMMER *pg = locate_programmer(programmers, programmer);
if(!pgm && pt && pg && !(pg->prog_modes & pmode)) {
pmsg_error("programmer %s and part %s have no programming modes in common\n", programmer, pt->desc);
msg_info("use -c? -p %s to see all possible programmers for %s\n", pt->desc, pt->desc);
} else {
pmsg_error("cannot find programmer id %s\n", programmer);
suggest_programmers(programmer, programmers);
msg_info("use -c? to see all possible programmers\n");
}
} else
pmsg_error("programmer %s lacks %s setting\n", programmer,
!pgm->prog_modes? "prog_modes": !pgm->initpgm? "type": "some");
}
static void part_not_found(const char *partdesc) {
msg_error("\n");
if(partdesc && *partdesc)
pmsg_error("AVR part %s not found. Use -p? to see all valid parts\n", partdesc);
else
pmsg_error("no AVR part has been specified; use -p part or -p? to see all valid parts\n");
}
#if !defined(WIN32)
// Safely concatenate dir/file into dst that has size n
static char *concatpath(char *dst, char *dir, char *file, size_t n) {
// Dir or file empty?
if(!dir || !*dir || !file || !*file)
return NULL;
size_t len = strlen(dir);
// Insufficient space?
if(len + (dir[len - 1] != '/') + strlen(file) > n - 1)
return NULL;
if(dst != dir)
strcpy(dst, dir);
if(dst[len - 1] != '/')
strcat(dst, "/");
strcat(dst, file);
return dst;
}
#endif
int main(int argc, char *argv[]) {
int rc; // General return code checking
int exitrc; // Exit code for main()
int i; // General loop counter
int ch; // Options flag
struct avrpart *p; // Which avr part we are programming
AVRMEM *sig; // Signature data
struct stat sb;
UPDATE *upd;
LNODEID *ln;
// Options/operating mode variables
int erase; // 1=erase chip, 0=don't
int flashread; // 1=flash is going to be read, 0=no flash reads
int calibrate; // 1=calibrate RC oscillator, 0=don't
int no_avrduderc; // 1=don't load personal conf file
char *port; // Device port (/dev/xxx)
const char *exitspecs; // Exit specs string from command line
int explicit_c; // 1=explicit -c on command line, 0=not specified there
int explicit_e; // 1=explicit -e on command line, 0=not specified there
char sys_config[PATH_MAX]; // System wide config file
char executable_abspath[PATH_MAX]; // Absolute path to avrdude executable
char executable_dirpath[PATH_MAX]; // Absolute path to folder with executable
bool executable_abspath_found = false; // Absolute path to executable found
bool sys_config_found = false; // avrdude.conf file found
char *e; // For strtod() error checking
const char *errstr; // For str_int() error checking
int baudrate; // Override default programmer baud rate
int touch_1200bps; // Touch serial port prior to programming
double bitclock; // Specify programmer bit clock (JTAG ICE)
int ispdelay; // Specify the delay for ISP clock
int init_ok; // Device initialization worked well
int is_open; // Device open succeeded
int ce_delayed; // Chip erase delayed
char *logfile; // Use logfile rather than stderr for diagnostics
int showversion; // Show version and exit
enum updateflags uflags = UF_AUTO_ERASE | UF_VERIFY; // Flags for do_op()
init_cx(NULL);
#ifdef _MSC_VER
_set_printf_count_output(1);
#endif
// Set line buffering for file descriptors so we see stdout and stderr properly interleaved
setvbuf(stdout, (char *) NULL, _IOLBF, 0);
setvbuf(stderr, (char *) NULL, _IOLBF, 0);
sys_config[0] = '\0';
progname = strrchr(argv[0], '/');
#if defined (WIN32)
// Take care of backslash as dir sep in W32
if(!progname)
progname = strrchr(argv[0], '\\');
#endif // WIN32
if(progname)
progname++;
else
progname = argv[0];
// Remove trailing .exe
if(str_ends(progname, ".exe")) {
progname = mmt_strdup(progname); // Don't write to argv[0]
progname[strlen(progname) - 4] = 0;
}
avrdude_conf_version = "";
default_programmer = "";
default_parallel = "";
default_serial = "";
default_spi = "";
default_baudrate = 0;
default_bitclock = 0.0;
default_linuxgpio = "";
allow_subshells = 0;
init_config();
atexit(cleanup_main);
updates = lcreat(NULL, 0);
if(updates == NULL) {
pmsg_error("cannot initialize updater list\n");
exit(1);
}
extended_params = lcreat(NULL, 0);
if(extended_params == NULL) {
pmsg_error("cannot initialize extended parameter list\n");
exit(1);
}
additional_config_files = lcreat(NULL, 0);
if(additional_config_files == NULL) {
pmsg_error("cannot initialize additional config files list\n");
exit(1);
}
partdesc = NULL;
port = NULL;
erase = 0;
flashread = 0;
calibrate = 0;
no_avrduderc = 0;
p = NULL;
ovsigck = 0;
quell_progress = 0;
exitspecs = NULL;
pgm = NULL;
pgmid = "";
explicit_c = 0;
explicit_e = 0;
verbose = 0;
baudrate = 0;
touch_1200bps = 0;
bitclock = 0.0;
ispdelay = 0;
is_open = 0;
ce_delayed = 0;
logfile = NULL;
showversion = 0;
if(argc == 1) { // No arguments?
usage();
return 0;
}
// Determine the location of personal configuration file
#if defined(WIN32)
win_set_path(usr_config, sizeof usr_config, USER_CONF_FILE);
#else
usr_config[0] = 0;
if(!concatpath(usr_config, getenv("XDG_CONFIG_HOME"), XDG_USER_CONF_FILE, sizeof usr_config))
concatpath(usr_config, getenv("HOME"), ".config/" XDG_USER_CONF_FILE, sizeof usr_config);
if(stat(usr_config, &sb) < 0 || (sb.st_mode & S_IFREG) == 0)
concatpath(usr_config, getenv("HOME"), USER_CONF_FILE, sizeof usr_config);
#endif
// Process command line arguments
struct option longopts[] = {
{"keep-trailing-0xff", no_argument, NULL, 'A'},
{"baud", required_argument, NULL, 'b'},
{"bitclock", required_argument, NULL, 'B'},
{"programmer", required_argument, NULL, 'c'},
{"config", required_argument, NULL, 'C'},
{"noerase", no_argument, NULL, 'D'},
{"erase", no_argument, NULL, 'e'},
{"exitspecs", required_argument, NULL, 'E'},
{"force", no_argument, NULL, 'F'},
{"help", no_argument, NULL, 'h'},
{"isp-clock-delay", required_argument, NULL, 'i'},
{"logfile", required_argument, NULL, 'l'},
{"test-memory", no_argument, NULL, 'n'},
{"noconfig", no_argument, NULL, 'N'},
{"osccal", no_argument, NULL, 'O'},
{"part", required_argument, NULL, 'p'},
{"port", required_argument, NULL, 'P'},
{"quell", no_argument, NULL, 'q'},
{"reconnect", no_argument, NULL, 'r'},
{"terminal", no_argument, NULL, 't'},
{"command", required_argument, NULL, 'T'},
{"memory", required_argument, NULL, 'U'},
{"verbose", no_argument, NULL, 'v'},
{"noverify-memory", no_argument, NULL, 'V'},
{"version", no_argument, &showversion, 1},
{"extended", required_argument, NULL, 'x'},
{NULL, 0, NULL, 0}
};
const char shortopts[] =
"aAb:B:c:C:dDeE:fFgGhHi:IjJkKl:LmMnNoOp:P:qQrRsStT:uU:vVwWx:XyYzZ0123456789";
int option_idx = 0;
while((ch = getopt_long(argc, argv, shortopts, longopts, &option_idx)) != -1) {
switch(ch) {
case 'b': // Override default programmer baud rate
baudrate = str_int(optarg, STR_INT32, &errstr);
if(errstr) {
pmsg_error("invalid baud rate %s specified: %s\n", optarg, errstr);
exit(1);
}
break;
case 'B': // Specify bit clock period
bitclock = strtod(optarg, &e);
if((e == optarg) || bitclock <= 0.0) {
pmsg_error("invalid bit clock period %s\n", optarg);
exit(1);
}
while(*e && isascii(*e & 0xff) && isspace(*e & 0xff))
e++;
if(*e == 0 || str_caseeq(e, "us")) // us is optional and the default
;
else if(str_caseeq(e, "m") || str_caseeq(e, "mhz"))
bitclock = 1/bitclock;
else if(str_caseeq(e, "k") || str_caseeq(e, "khz"))
bitclock = 1e3/bitclock;
else if(str_caseeq(e, "hz"))
bitclock = 1e6/bitclock;
else {
pmsg_error("invalid bit clock unit %s\n", e);
exit(1);
}
break;
case 'c': // Programmer
pgmid = optarg;
explicit_c = 1;
break;
case 'C': // System wide configuration file (can be repeated)
if(optarg[0] == '+') {
ladd(additional_config_files, optarg + 1);
} else {
strncpy(sys_config, optarg, PATH_MAX);
sys_config[PATH_MAX - 1] = 0;
}
break;
case 'D': // Disable auto-erase
uflags &= ~UF_AUTO_ERASE;
// Fall through
case 'A': // Keep trailing flash 0xff
cx->avr_disableffopt = 1;
break;
case 'e': // Perform a chip erase
erase = 1;
explicit_e = 1;
uflags &= ~UF_AUTO_ERASE;
break;
case 'E': // Voltage levels on exit
exitspecs = optarg;
break;
case 'F': // Override invalid signature check
ovsigck = 1;
break;
case 'h': // Help message
usage();
exit(0);
case 'i': // ISP clock delay
ispdelay = str_int(optarg, STR_INT32, &errstr);
if(errstr || ispdelay == 0) {
pmsg_error("invalid isp clock delay %s specified", optarg);
if(errstr)
msg_error(": %s\n", errstr);
else
msg_error("\n");
exit(1);
}
break;
case 'l': // Log file
logfile = optarg;
break;
case 'n': // -U does not write to chip
uflags |= UF_NOWRITE;
break;
case 'N': // Do not load user config file
no_avrduderc = 1;
break;
case 'O': // Perform RC oscillator calibration
calibrate = 1;
break;
case 'p': // Specify AVR part
partdesc = optarg;
break;
case 'P': // Port
port = mmt_strdup(optarg);
break;
case 'q': // Quell progress output
quell_progress++;
break;
case 'r': // Reconnect
touch_1200bps++;
break;
case 't': // Enter terminal mode (can be repeated)
ladd(updates, cmd_update("interactive terminal"));
break;
case 'T': // Execute terminal command (can be repeated)
ladd(updates, cmd_update(optarg));
break;
case 'U': // Memory operation (can be repeated)
upd = parse_op(optarg);
if(upd == NULL) {
pmsg_error("unable to parse update operation %s\n", optarg);
exit(1);
}
ladd(updates, upd);
break;
case 'v': // Increase verbosity
verbose++;
break;
case 'V': // No verification on -U
uflags &= ~UF_VERIFY;
break;
case 'x': // Extended parameter (can be repeated)
ladd(extended_params, optarg);
break;
case '?': // Some error with options
if(optopt == '?')
usage();
exit(optopt != '?');
case 0: // Nothing to do for long options
break;
default:
usage();
msg_error("\n");
pmsg_error("invalid option -%c\n", ch);
exit(1);
}
}
if(showversion) {
printf(
"%c%s version %s\n"
"Copyright see https://github.com/avrdudes/avrdude/blob/main/AUTHORS\n"
"Use https://github.com/avrdudes/avrdude/issues to report bugs and ask questions\n",
toupper((uint8_t) *progname), *progname? progname+1: "", AVRDUDE_FULL_VERSION
);
exit(0);
}
if(logfile != NULL) {
FILE *newstderr = freopen(logfile, "w", stderr);
if(newstderr == NULL) {
// Help! There's no stderr to complain to anymore now
printf("Cannot create logfile %s: %s\n", logfile, strerror(errno));
return 1;
}
}
msg_debug("$ "); // Record command line
for(int i = 0; i < argc; i++)
msg_debug("%s%c", str_ccsharg(argv[i]), i == argc - 1? '\n': ' ');
size_t ztest;
if(1 != sscanf("42", "%zi", &ztest) || ztest != 42)
pmsg_warning("linked C library does not conform to C99; %s may not work as expected\n", progname);
// Search for system configuration file unless -C conffile was given
if(strlen(sys_config) == 0) {
/*
* Executable abspath: Determine the absolute path to avrdude executable.
* This will be used to locate the avrdude.conf file later.
*/
int executable_dirpath_len = 0;
int executable_abspath_len = wai_getExecutablePath(executable_abspath, PATH_MAX,
&executable_dirpath_len);
if(executable_abspath_len > 0 && executable_dirpath_len > 0) {
executable_abspath_found = true;
executable_abspath[executable_abspath_len] = '\0';
replace_backslashes(executable_abspath);
// Define executable_dirpath to be the path to the parent folder of the executable
strcpy(executable_dirpath, executable_abspath);
executable_dirpath[executable_dirpath_len] = '\0';
msg_trace2("executable_abspath = %s\n", executable_abspath);
msg_trace2("executable_abspath_len = %i\n", executable_abspath_len);
msg_trace2("executable_dirpath = %s\n", executable_dirpath);
msg_trace2("executable_dirpath_len = %i\n", executable_dirpath_len);
}
/*
* System config
* -------------
* Determine the location of avrdude.conf. Check in this order:
* 1. <dirpath of executable>/../etc/avrdude.conf
* 2. <dirpath of executable>/avrdude.conf
* 3. CONFIG_DIR/avrdude.conf
*
* When found, write the result into the 'sys_config' variable.
*/
if(executable_abspath_found) {
// 1. Check <dirpath of executable>/../etc/avrdude.conf
strcpy(sys_config, executable_dirpath);
sys_config[PATH_MAX - 1] = '\0';
i = strlen(sys_config);
if(i && (sys_config[i - 1] != '/'))
strcat(sys_config, "/");
strcat(sys_config, "../etc/" SYSTEM_CONF_FILE);
sys_config[PATH_MAX - 1] = '\0';
if(access(sys_config, F_OK) == 0) {
sys_config_found = true;
} else {
// 2. Check <dirpath of executable>/avrdude.conf
strcpy(sys_config, executable_dirpath);
sys_config[PATH_MAX - 1] = '\0';
i = strlen(sys_config);
if(i && (sys_config[i - 1] != '/'))
strcat(sys_config, "/");
strcat(sys_config, SYSTEM_CONF_FILE);
sys_config[PATH_MAX - 1] = '\0';
if(access(sys_config, F_OK) == 0) {
sys_config_found = true;
}
}
}
if(!sys_config_found) {
// 3. Check CONFIG_DIR/avrdude.conf
#if defined(WIN32)
win_set_path(sys_config, sizeof sys_config, SYSTEM_CONF_FILE);
#else
strcpy(sys_config, CONFIG_DIR);
i = strlen(sys_config);
if(i && (sys_config[i - 1] != '/'))
strcat(sys_config, "/");
strcat(sys_config, SYSTEM_CONF_FILE);
#endif
if(access(sys_config, F_OK) == 0) {
sys_config_found = true;
}
}
}
// Debug output
msg_trace2("sys_config = %s\n", sys_config);
msg_trace2("sys_config_found = %s\n", sys_config_found? "true": "false");
msg_trace2("\n");
if(quell_progress == 0)
terminal_setup_update_progress();
// Print out an identifying string so folks can tell what version they are running
pmsg_notice("%s version %s\n", progname, AVRDUDE_FULL_VERSION);
pmsg_notice("Copyright see https://github.com/avrdudes/avrdude/blob/main/AUTHORS\n\n");
if(*sys_config) {
char *real_sys_config = realpath(sys_config, NULL);
if(real_sys_config) {
pmsg_notice("system wide configuration file is %s\n", real_sys_config);
} else
pmsg_warning("cannot determine realpath() of config file %s: %s\n", sys_config, strerror(errno));
rc = read_config(real_sys_config);
if(rc) {
pmsg_error("unable to process system wide configuration file %s\n", real_sys_config);
exit(1);
}
mmt_free(real_sys_config);
}
if(usr_config[0] != 0 && !no_avrduderc) {
int ok = (rc = stat(usr_config, &sb)) >= 0 && (sb.st_mode & S_IFREG);
pmsg_notice("user configuration file %s%s%s\n", ok? "is ": "", usr_config,
rc < 0? " does not exist": !(sb.st_mode & S_IFREG)? " is not a regular file, skipping": "");
if(ok) {
rc = read_config(usr_config);
if(rc) {
pmsg_error("unable to process user configuration file %s\n", usr_config);
exit(1);
}
}
}
if(!str_eq(avrdude_conf_version, AVRDUDE_FULL_VERSION)) {
pmsg_warning("system wide configuration file version (%s)\n", avrdude_conf_version);
imsg_warning("does not match Avrdude build version (%s)\n", AVRDUDE_FULL_VERSION);
}
if(lsize(additional_config_files) > 0) {
LNODEID ln1;
const char *p = NULL;
for(ln1 = lfirst(additional_config_files); ln1; ln1 = lnext(ln1)) {
p = ldata(ln1);
pmsg_notice("additional configuration file is %s\n", p);
rc = read_config(p);
if(rc) {
pmsg_error("unable to process additional configuration file %s\n", p);
exit(1);
}
}
}
// Sort memories of all parts in canonical order
for(LNODEID ln1 = lfirst(part_list); ln1; ln1 = lnext(ln1))
if((p = ldata(ln1))->mem)
lsort(p->mem, avr_mem_cmp);
// Set bitclock from configuration files unless changed by command line
if(default_bitclock > 0 && bitclock == 0.0) {
bitclock = default_bitclock;
}
if(!(pgmid && *pgmid) && *default_programmer)
pgmid = cache_string(default_programmer);
// Developer options to print parts and/or programmer entries of avrdude.conf
int dev_opt_c = dev_opt(pgmid); // -c <wildcard>/[duASsrtiBUPTIJWHQ]
int dev_opt_p = dev_opt(partdesc); // -p <wildcard>/[cdoASsrw*tiBUPTIJWHQ]
if(dev_opt_c || dev_opt_p) { // See -c/h and or -p/h
dev_output_pgm_part(dev_opt_c, pgmid, dev_opt_p, partdesc);
exit(0);
}
PROGRAMMER *dry = locate_programmer(programmers, "dryrun");
for(LNODEID ln1 = lfirst(part_list); ln1; ln1 = lnext(ln1)) {
AVRPART *p = ldata(ln1);
for(LNODEID ln2 = lfirst(programmers); ln2; ln2 = lnext(ln2)) {
PROGRAMMER *pgm = ldata(ln2);
if(!is_programmer(pgm))
continue;
const char *pnam = pgm->id? ldata(lfirst(pgm->id)): "???";
int pm = pgm->prog_modes & p->prog_modes;
if((pm & (pm - 1)) && !str_eq(pnam, "dryrun") && !(dry && pgm->initpgm == dry->initpgm))
pmsg_warning("%s and %s share multiple modes (%s)\n", pnam, p->desc, avr_prog_modes(pm));
}
}
if(port) {
if(str_eq(port, "?s")) {
list_available_serialports(programmers);
exit(0);
} else if(str_eq(port, "?sa")) {
lmsg_error("Valid serial adapters are:\n");
list_serialadapters(stderr, " ", programmers);
exit(0);
}
}
if(partdesc) {
if(str_eq(partdesc, "?")) {
if(pgmid && *pgmid && explicit_c) {
PROGRAMMER *pgm = locate_programmer_starts_set(programmers, pgmid, &pgmid, NULL);
if(!pgm || !is_programmer(pgm)) {
programmer_not_found(pgmid, pgm, NULL);
exit(1);
}
msg_error("\nValid parts for programmer %s are:\n", pgmid);
list_parts(stderr, " ", part_list, pgm->prog_modes);
} else {
msg_error("\nValid parts are:\n");
list_parts(stderr, " ", part_list, ~0);
}
msg_error("\n");
exit(1);
}
}
if(pgmid) {
if(str_eq(pgmid, "?")) {
if(partdesc && *partdesc) {
AVRPART *p = locate_part(part_list, partdesc);
if(!p) {
part_not_found(partdesc);
exit(1);
}
msg_error("\nValid programmers for part %s are:\n", p->desc);
list_programmers(stderr, " ", programmers, p->prog_modes);
} else {
msg_error("\nValid programmers are:\n");
list_programmers(stderr, " ", programmers, ~0);
}
msg_error("\n");
exit(1);
}
if(str_eq(pgmid, "?type")) {
msg_error("\nValid programmer types are:\n");
list_programmer_types(stderr, " ");
msg_error("\n");
exit(1);
}
}
msg_notice("\n");
if(!pgmid || !*pgmid) {
programmer_not_found(NULL, NULL, NULL);
exit(1);
}
p = partdesc && *partdesc? locate_part(part_list, partdesc): NULL;
pgm = locate_programmer_starts_set(programmers, pgmid, &pgmid, p);
if(pgm == NULL || !is_programmer(pgm)) {
programmer_not_found(pgmid, pgm, p);
exit(1);
}
if(p && !(p->prog_modes & pgm->prog_modes)) {
pmsg_error("-c %s cannot program %s for lack of a common programming mode\n", pgmid, p->desc);
if(!ovsigck) {
imsg_error("use -F to override this check\n");
exit(1);
}
}
if(pgm->initpgm) {
pgm->initpgm(pgm);
} else {
msg_error("\n");
pmsg_error("cannot initialize the programmer\n\n");
exit(1);
}
if(pgm->setup) {
pgm->setup(pgm);
}
if(pgm->teardown) {
atexit(exithook);
}
if(lsize(extended_params) > 0) {
if(pgm->parseextparams == NULL) {
for(LNODEID ln = lfirst(extended_params); ln; ln = lnext(ln)) {
const char *extended_param = ldata(ln);
if(str_eq(extended_param, "help")) {
msg_error("%s -c %s extended options:\n", progname, pgmid);
msg_error(" -x help Show this help menu and exit\n");
exit(0);
} else
pmsg_error("programmer does not support extended parameter -x %s, option ignored\n", extended_param);
}
} else {
int rc = pgm->parseextparams(pgm, extended_params);
if(rc == LIBAVRDUDE_EXIT_OK)
exit(0);
if(rc < 0) {
pmsg_error("unable to parse list of -x parameters\n");
exit(1);
}
}
}
if(port == NULL) {
switch(pgm->conntype) {
case CONNTYPE_PARALLEL:
port = mmt_strdup(default_parallel);
break;
case CONNTYPE_SERIAL:
port = mmt_strdup(default_serial);
break;
case CONNTYPE_USB:
port = mmt_strdup(DEFAULT_USB);
break;
case CONNTYPE_SPI:
#ifdef HAVE_LINUXSPI
port = mmt_strdup(*default_spi? default_spi: "unknown");
#else
port = mmt_strdup("unknown");
#endif
break;
case CONNTYPE_LINUXGPIO:
port = mmt_strdup(default_linuxgpio);
break;
default:
port = mmt_strdup("unknown");
break;
}
}
int is_dryrun = str_eq(pgm->type, "dryrun") || (dry && pgm->initpgm == dry->initpgm);
if((port[0] == 0 || str_eq(port, "unknown")) && !is_dryrun) {
msg_error("\n");
pmsg_error("no port has been specified on the command line or in the config file;\n");
imsg_error("specify a port using the -P option and try again\n");
exit(1);
}
/*
* Divide a serialadapter port string into tokens separated by colons.
* There are two ways such a port string can be presented:
* 1) -P <serialadapter>[:<sernum>]
* 2) -P usb:<usbvid>:<usbpid>[:<sernum>]
* In either case the serial number is optional. The USB vendor and
* product ids are hexadecimal numbers.
*/
bool print_ports = true;
SERIALADAPTER *ser = NULL;
if(pgm->conntype == CONNTYPE_SERIAL) {
char *portdup = mmt_strdup(port);
char *port_tok[4], *tok = portdup;
for(int t = 0, maxt = str_starts(portdup, DEFAULT_USB ":")? 4: 2; t < 4; t++) {
char *save = tok && t < maxt? tok: "";
if(t < maxt - 1 && tok && (tok = strchr(tok, ':')))
*tok++ = 0;
port_tok[t] = mmt_strdup(save);
}
mmt_free(portdup);
// Use libserialport to find the actual serial port
ser = locate_programmer(programmers, port_tok[0]);
if(is_serialadapter(ser)) {
#ifdef HAVE_LIBSERIALPORT
int rv = setport_from_serialadapter(&port, ser, port_tok[1]);
if(rv == -1) {
pmsg_warning("serial adapter %s", port_tok[0]);
if(port_tok[1][0])
msg_warning(" with serial number %s", port_tok[1]);
else if(ser->usbsn && ser->usbsn[0])
msg_warning(" with serial number %s", ser->usbsn);
msg_warning(" not connected to host\n");
} else if(rv == -2)
print_ports = false;
if(rv)
ser = NULL;
#endif
} else if(str_eq(port_tok[0], DEFAULT_USB)) {
// Port or usb:[vid]:[pid]
int vid, pid;
if(sscanf(port_tok[1], "%x", &vid) > 0 && sscanf(port_tok[2], "%x", &pid) > 0) {
int rv = setport_from_vid_pid(&port, vid, pid, port_tok[3]);
if(rv == -1) {
if(port_tok[3][0])
pmsg_warning("serial adapter with USB VID %s and PID %s and serial number %s not connected\n", port_tok[1],
port_tok[2], port_tok[3]);
else
pmsg_warning("serial adapter with USB VID %s and PID %s not connected\n", port_tok[1], port_tok[2]);
} else if(rv == -2)
print_ports = false;
}
}
for(int i = 0; i < 4; i++)
mmt_free(port_tok[i]);
if(touch_1200bps && touch_serialport(&port, 1200, touch_1200bps) < 0)
goto skipopen;
}
// Open the programmer
if(!is_dryrun)
pmsg_notice("using port : %s\n", port);
pmsg_notice("using programmer : %s\n", pgmid);
if(baudrate && !pgm->baudrate && !default_baudrate) { // None set
pmsg_notice("setting baud rate : %d\n", baudrate);
pgm->baudrate = baudrate;
} else if(baudrate && ((pgm->baudrate && pgm->baudrate != baudrate)
|| (!pgm->baudrate && default_baudrate != baudrate))) {
pmsg_notice("overriding baud rate : %d\n", baudrate);
pgm->baudrate = baudrate;
} else if(!pgm->baudrate && default_baudrate) {
pmsg_notice("default baud rate : %d\n", default_baudrate);
pgm->baudrate = default_baudrate;
} else if(ser && ser->baudrate) {
pmsg_notice("serial baud rate : %d\n", ser->baudrate);
pgm->baudrate = ser->baudrate;
} else if(pgm->baudrate != 0)
pmsg_notice("programmer baud rate : %d\n", pgm->baudrate);
if(bitclock != 0.0) {
pmsg_notice("setting bit clk period: %.1f us\n", bitclock);
pgm->bitclock = bitclock*1e-6;
}
if(ispdelay != 0) {
pmsg_notice("setting ISP clk delay : %3i us\n", ispdelay);
pgm->ispdelay = ispdelay;
}
rc = pgm->open(pgm, port);
if(rc < 0) {
if(rc == LIBAVRDUDE_EXIT_FAIL || rc == LIBAVRDUDE_EXIT_OK) {
exitrc = rc == LIBAVRDUDE_EXIT_FAIL;
goto main_exit;
}
pmsg_error("unable to open port %s for programmer %s\n", port, pgmid);
skipopen:
if(print_ports && pgm->conntype == CONNTYPE_SERIAL) {
#ifdef HAVE_LIBSERIALPORT
list_available_serialports(programmers);
if(touch_1200bps == 1)
pmsg_info("alternatively, try -rr or -rrr for longer delays\n");
#endif
}
exitrc = 1;
pgm->ppidata = 0; // Clear all bits at exit
goto main_exit;
}
is_open = 1;
if(partdesc == NULL) {
part_not_found(NULL);
exitrc = 1;
goto main_exit;
}
p = locate_part(part_list, partdesc);
if(p == NULL) {
part_not_found(partdesc);
exitrc = 1;
goto main_exit;
}
if(exitspecs != NULL) {
if(pgm->parseexitspecs == NULL) {
pmsg_warning("-E option not supported by this programmer type\n");
exitspecs = NULL;
} else {
int rc = pgm->parseexitspecs(pgm, exitspecs);
if(rc == LIBAVRDUDE_EXIT_OK)
exit(0);
if(rc < 0) {
pmsg_error("unable to parse list of -E parameters\n");
exit(1);
}
}
}
if(avr_initmem(p) != 0) {
msg_error("\n");
pmsg_error("unable to initialize memories\n");
exitrc = 1;
goto main_exit;
}
if(verbose > 0) {
if((str_eq(pgm->type, "avr910"))) {
imsg_notice("avr910_devcode (avrdude.conf) : ");
if(p->avr910_devcode)
msg_notice("0x%02x\n", (uint8_t) p->avr910_devcode);
else
msg_notice("none\n");
}
}
/*
* Now that we know which part we are going to program, locate any -U options
* using the default memory region, fill in the device-dependent default
* region name ("application" for Xmega parts or "flash" otherwise) and check
* for basic problems with memory names or file access with a view to exit
* before programming.
*/
int doexit = 0;
for(ln = lfirst(updates); ln; ln = lnext(ln)) {
upd = ldata(ln);
if(upd->memstr == NULL && upd->cmdline == NULL) {
const char *mtype = is_pdi(p)? "application": "flash";
pmsg_notice2("defaulting memstr in -U %c:%s option to \"%s\"\n",
(upd->op == DEVICE_READ)? 'r': (upd->op == DEVICE_WRITE)? 'w': 'v', upd->filename, mtype);
upd->memstr = mmt_strdup(mtype);
}
rc = update_dryrun(p, upd);
if(rc && rc != LIBAVRDUDE_SOFTFAIL)
doexit = 1;
}
if(doexit) {
exitrc = 1;
goto main_exit;
}
if(calibrate) {
// Perform an RC oscillator calibration as outlined in appnote AVR053
if(pgm->perform_osccal == 0) {
pmsg_error("programmer does not support RC oscillator calibration\n");
exitrc = 1;
} else {
pmsg_notice2("performing RC oscillator calibration\n");
exitrc = pgm->perform_osccal(pgm);
}
if(exitrc)
pmsg_error("RC calibration unsuccesful\n");
else
pmsg_notice("calibration value is now stored in EEPROM at address 0\n");
goto main_exit;
}
if(verbose > 0 && quell_progress < 2) {
avr_display(stderr, pgm, p, "", verbose);
msg_notice2("\n");
programmer_display(pgm, "");
}
lmsg_info("");
exitrc = 0;
// Enable the programmer
pgm->enable(pgm, p);
// Turn off all the status LEDs and reset LED states
led_set(pgm, LED_BEG);
// Initialize the chip in preparation for accepting commands
int reinitialised = 0;
int erased_by_unlock = 0;
init_again:
init_ok = (rc = pgm->initialize(pgm, p)) >= 0;
if(!init_ok) {
if(rc == LIBAVRDUDE_EXIT_FAIL || rc == LIBAVRDUDE_EXIT_OK) {
exitrc = rc == LIBAVRDUDE_EXIT_FAIL;
goto main_exit;
}
if(rc == LIBAVRDUDE_DEVICE_LOCKED) { // The pickit5 with UPDI is a bit tricky
if(!explicit_e) { // UPDI has no access to the system when locked: must be erased first
// If tasks are pending on the command line issue error otherwise just warn
exitrc = updates && lsize(updates) > 0;
if(exitrc)
pmsg_error("device locked; chip erase option -e required for unlocking device first\n");
else
pmsg_warning("device locked; any operation will require chip erase option -e\n");
goto main_exit;
}
// Have to go in blind: cannot even read out the device ID
pmsg_notice2("-e option specified on locked device; erasing it should unlock\n");
// Reinitialise at most once if erase successful
if(reinitialised++)
pmsg_error("re-initialization failed despite part erasure; try re-running command line\n");
else if(pgm->chip_erase(pgm, p) == LIBAVRDUDE_SUCCESS) {
erased_by_unlock = 1;
goto init_again;
}
exitrc = 1;
goto main_exit;
}
pmsg_error("initialization failed (rc = %d)\n", rc);
if(rc == -2)
imsg_error(" - the programmer ISP clock is too fast for the target\n");
else
imsg_error(" - double check the connections and try again\n");
if(str_eq(pgm->type, "serialupdi"))
imsg_error(" - use -b to set lower baud rate, e.g. -b %d\n", baudrate? baudrate/2: 57600);
else if(str_eq(pgm->type, "buspirate_bb") || str_eq(pgm->type, "linuxgpio") ||
str_eq(pgm->type, "par") || str_eq(pgm->type, "SERBB")) {
imsg_error(" - use -i %sto set a longer delay (in microseconds) between each bit state change, e.g. -i 50\n",
bitclock? "instead of -B ": "");
}
else
imsg_error(" - use -B to set lower the bit clock frequency, e.g. -B 125kHz\n");
if(str_starts(pgm->type, "pickit5"))
imsg_error(" - reset the programmer by unplugging it");
if(!ovsigck) {
imsg_error(" - use -F to override this check\n");
exitrc = 1;
goto main_exit;
}
}
// Indicate programmer is ready
led_set(pgm, LED_RDY);
msg_notice("\n");
pmsg_notice("AVR device initialized and ready to accept instructions\n");
/*
* Let's read the signature bytes to make sure there is at least a chip on
* the other end that is responding correctly. A check against
* 0xffffff/0x000000 should ensure that the signature bytes are valid.
*/
if(!is_awire(p)) { // Not AVR32
int attempt = 0;
int waittime = 10000; // 10 ms
sig_again:
usleep(waittime);
if(init_ok) {
rc = avr_signature(pgm, p);
if(rc == LIBAVRDUDE_EXIT_FAIL || rc == LIBAVRDUDE_EXIT_OK) {
exitrc = rc == LIBAVRDUDE_EXIT_FAIL;
goto main_exit;
}
if(rc != LIBAVRDUDE_SUCCESS) {
if(rc == LIBAVRDUDE_SOFTFAIL && is_updi(p) && attempt < 1) {
attempt++;
if(erase) {
erase = 0;
if(uflags & UF_NOWRITE) {
pmsg_warning("conflicting -e and -n options specified, NOT erasing chip\n");
} else {
pmsg_info("unlocking the chip");
exitrc = avr_unlock(pgm, p);
if(exitrc)
goto main_exit;
msg_info(" and trying again\n");
goto sig_again;
}
}
if(!ovsigck) {
pmsg_error("double check chip or use -F to override this check\n");
exitrc = 1;
goto main_exit;
}
}
pmsg_error("unable to read signature data (rc = %d)\n", rc);
if(!ovsigck) {
imsg_error("use -F to override this check\n");
exitrc = 1;
goto main_exit;
}
}
}
sig = avr_locate_signature(p);
if(sig == NULL)
pmsg_warning("signature memory not defined for device %s\n", p->desc);
else {
const char *mculist = str_ccmcunames_signature(sig->buf, pgm->prog_modes);
if(!*mculist) { // No matching signatures?
if(is_updi(p)) { // UPDI parts have different(!) offsets for signature
int k, n = 0; // Gather list of known different signature offsets
unsigned myoff = sig->offset, offlist[10];
for(LNODEID ln1 = lfirst(part_list); ln1; ln1 = lnext(ln1)) {
AVRMEM *m = avr_locate_signature(ldata(ln1));
if(m && m->offset != myoff) {
for(k = 0; k < n; k++)
if(m->offset == offlist[k])
break;
if(k == n && k < (int) (sizeof offlist/sizeof *offlist))
offlist[n++] = m->offset;
}
}
// Now go through the list of other(!) sig offsets and try these
for(k = 0; k < n; k++) {
sig->offset = offlist[k];
if(avr_signature(pgm, p) >= 0)
if(*(mculist = str_ccmcunames_signature(sig->buf, pgm->prog_modes)))
break;
}
sig->offset = myoff;
}
}
int ff = 1, zz = 1;
for(i = 0; i < sig->size; i++) {
if(sig->buf[i] != 0xff)
ff = 0;
if(sig->buf[i] != 0x00)
zz = 0;
}
bool signature_matches = sig->size >= 3 && !memcmp(sig->buf, p->signature, 3);
int showsig = !signature_matches || ff || zz || verbose > 0;
if(showsig)
pmsg_info("device signature =%s", str_cchex(sig->buf, sig->size, 1));
if(*mculist && showsig)
msg_info(" (%s)", is_dryrun? p->desc: mculist);
if(ff || zz) { // All three bytes are 0xff or all three bytes are 0x00
if(++attempt < 3) {
waittime *= 5;
msg_info(" (retrying)\n");
goto sig_again;
}
msg_info("\n");
pmsg_error("invalid device signature\n");
if(!ovsigck) {
pmsg_error("expected signature for %s is%s\n", p->desc, str_cchex(p->signature, 3, 1));
imsg_error(" - double check connections and try again, or use -F to carry on regardless\n");
exitrc = 1;
goto main_exit;
}
} else if(showsig) {
msg_info("\n");
}
if(!signature_matches) {
if(ovsigck) {
pmsg_warning("expected signature for %s is%s\n", p->desc, str_cchex(p->signature, 3, 1));
} else {
pmsg_error("expected signature for %s is%s\n", p->desc, str_cchex(p->signature, 3, 1));
imsg_error(" - double check chip or use -F to carry on regardless\n");
exitrc = 1;
goto main_exit;
}
}
}
}
if(uflags & UF_AUTO_ERASE) {
if((p->prog_modes & (PM_PDI | PM_UPDI)) && pgm->page_erase && lsize(updates) > 0) {
for(ln = lfirst(updates); ln; ln = lnext(ln)) {
upd = ldata(ln);
if(upd->memstr && upd->op == DEVICE_WRITE && memlist_contains_flash(upd->memstr, p)) {
cx->avr_disableffopt = 1; // Must write full flash file including trailing 0xff
pmsg_notice("NOT erasing chip as page erase will be used for new flash%s contents;\n",
avr_locate_bootrow(p)? "/bootrow": "");
imsg_notice("unprogrammed flash contents remains: use -e for an explicit chip-erase\n");
break;
}
}
} else {
uflags &= ~UF_AUTO_ERASE;
for(ln = lfirst(updates); ln; ln = lnext(ln)) {
upd = ldata(ln);
if(upd->cmdline && *str_ltrim(upd->cmdline) && str_starts("erase", str_ltrim(upd->cmdline)))
break; // -T erase already erases the chip: no auto-erase needed
if(upd->cmdline || (upd->memstr && // Might be reading flash?
(upd->op == DEVICE_READ || upd->op == DEVICE_VERIFY) && memlist_contains_flash(upd->memstr, p)))
flashread = 1;
if(upd->memstr && upd->op == DEVICE_WRITE && memlist_contains_flash(upd->memstr, p)) {
if(flashread) {
pmsg_info("NOT auto-erasing chip as flash might need reading before writing to it\n");
} else {
if(!is_generated_fname(upd->filename) || generated_file_has_contents(p, upd->filename)) {
erase = 1;
pmsg_notice("auto-erasing chip as flash memory needs programming (-U %s:w:...)\n", upd->memstr);
imsg_notice("specify the -D option to disable this feature\n");
}
}
break;
}
}
}
}
if(init_ok && erase && !erased_by_unlock) {
/*
* Erase the chip's flash and eeprom memories, this is required before the
* chip can accept new programming. Skip if it was already erased when unlocking.
*/
if(uflags & UF_NOWRITE) {
if(explicit_e)
pmsg_warning("conflicting -e and -n specified, NOT erasing chip\n");
else
pmsg_notice("-n specified, NOT erasing chip\n");
} else {
exitrc = avr_chip_erase(pgm, p);
if(exitrc == LIBAVRDUDE_SOFTFAIL) {
pmsg_notice("delaying chip erase until first -U upload to flash\n");
ce_delayed = 1;
exitrc = 0;
} else if(exitrc) {
pmsg_error("chip erase failed\n");
goto main_exit;
} else
pmsg_notice("erased chip\n");
}
}
if(!init_ok && !ovsigck) { // Bail out on failed initialisation unless -F was given
exitrc = 1;
goto main_exit;
}
int wrmem = 0, terminal = 0;
if(lsize(updates) <= 1)
uflags |= UF_NOHEADING;
for(ln = lfirst(updates); ln; ln = lnext(ln)) {
const AVRMEM *m;
upd = ldata(ln);
if(upd->cmdline && wrmem) { // Invalidate cache if device was written to
wrmem = 0;
pgm->reset_cache(pgm, p);
} else if(!upd->cmdline) { // Flush cache before any device memory access
pgm->flush_cache(pgm, p);
wrmem |= upd->op == DEVICE_WRITE;
}
if((uflags & UF_NOWRITE) && upd->cmdline && !terminal++)
pmsg_warning("the terminal ignores option -n, that is, it writes to the device\n");
rc = do_op(pgm, p, upd, uflags);
if(rc && rc != LIBAVRDUDE_SOFTFAIL) {
exitrc = 1;
break;
} else if(rc == 0 && upd->op == DEVICE_WRITE && (m = avr_locate_mem(p, upd->memstr)) && mem_is_in_flash(m))
ce_delayed = 0; // Redeemed chip erase promise
}
pgm->flush_cache(pgm, p);
if(pgm->end_programming)
if(pgm->end_programming(pgm, p) < 0)
pmsg_error("could not end programming, aborting\n");
main_exit:
// Program complete
if(is_open) {
// Clear rdy LED and summarise interaction in err, pgm and vfy LEDs
led_set(pgm, LED_END);
pgm->powerdown(pgm);
pgm->disable(pgm);
pgm->close(pgm);
}
if(cx->usb_access_error) {
pmsg_info("\nUSB access errors detected; this could have many reasons; if it is\n"
"USB permission problems, avrdude is likely to work when run as root\n"
"but this is not good practice; instead you might want to\n");
#if 0 && !defined(WIN32)
DIR *dir;
if((dir = opendir("/etc/udev/rules.d"))) { // Linux udev land
closedir(dir);
imsg_info("run the command below to show udev rules recitifying USB access\n" "$ %s -c %s/u\n", progname, pgmid);
} else
#endif
imsg_info("check out USB port permissions on your OS and set them correctly\n");
}
msg_info("\n");
pmsg_info("%s done. Thank you.\n", progname);
return ce_delayed? 1: exitrc;
}
Reference in New Issue View Git Blame Copy Permalink