#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.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 <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "term.h"

Include dependency graph for main.c:

Classes
struct	list_walk_cookie

Macros
#define	MSGBUFFER_SIZE 4096

Functions
static void	avrdude_message_handler_null (const char msg, unsigned size, void user_p)

void	avrdude_message_handler_set (avrdude_message_handler_t newhandler, void *user_p)

int	avrdude_message (const int msglvl, const char *format,...)

static void	avrdude_progress_handler_null (const char task, unsigned progress, void user_p)

void	avrdude_progress_handler_set (avrdude_progress_handler_t newhandler, void *user_p)

void	avrdude_progress_external (const char *task, unsigned progress)

static void	avrdude_oom_handler_null (const char context, void user_p)

void	avrdude_oom_handler_set (avrdude_oom_handler_t newhandler, void *user_p)

void	avrdude_oom (const char *context)

void	avrdude_cancel ()

static void	usage (void)

static void	update_progress_no_tty (int percent, double etime, char *hdr)

static void	list_programmers_callback (const char name, const char desc, const char cfgname, int cfglineno, void cookie)

static void	list_programmers (FILE f, const char prefix, LISTID programmers)

static void	list_programmer_types_callback (const char name, const char desc, void *cookie)

static void	list_programmer_types (FILE f, const char prefix)

static void	list_avrparts_callback (const char name, const char desc, const char cfgname, int cfglineno, void cookie)

static void	list_parts (FILE f, const char prefix, LISTID avrparts)

static int	cleanup_main (int status)

int	avrdude_main (int argc, char *argv[])

Variables
char *	version = VERSION "-prusa3d"

char *	progname

char	progbuf [PATH_MAX]

char	msgbuffer [MSGBUFFER_SIZE]

bool	cancel_flag = false

static void *	avrdude_message_handler_user_p = NULL

static avrdude_message_handler_t	avrdude_message_handler = avrdude_message_handler_null

static void *	avrdude_progress_handler_user_p = NULL

static avrdude_progress_handler_t	avrdude_progress_handler = avrdude_progress_handler_null

static void *	avrdude_oom_handler_user_p = NULL

static avrdude_oom_handler_t	avrdude_oom_handler = avrdude_oom_handler_null

static LISTID	updates = NULL

static LISTID	extended_params = NULL

static LISTID	additional_config_files = NULL

static PROGRAMMER *	pgm

static bool	pgm_setup = false

int	verbose

int	quell_progress

int	ovsigck

Class Documentation

◆ list_walk_cookie

struct list_walk_cookie

Class Members
FILE *	f
const char *	prefix

Macro Definition Documentation

◆ MSGBUFFER_SIZE

#define MSGBUFFER_SIZE 4096

Function Documentation

◆ avrdude_cancel()

void avrdude_cancel ( )

{
    cancel_flag = true;
}

References cancel_flag.

Referenced by Slic3r::AvrDude::cancel().

Here is the caller graph for this function:

◆ avrdude_main()

int avrdude_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 */
  int              len;         /* length for various strings */
  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     calibrate;   /* 1=calibrate RC oscillator, 0=don't */
  char  * port;        /* device port (/dev/xxx) */
  int     terminal;    /* 1=enter terminal mode, 0=don't */
  int     verify;      /* perform a verify operation */
  char  * exitspecs;   /* exit specs string from command line */
  char  * programmer;  /* programmer id */
  char  * partdesc;    /* part id */
  // char    sys_config[PATH_MAX]; /* system wide config file */
  char    usr_config[PATH_MAX]; /* per-user config file */
  char  * e;           /* for strtol() error checking */
  int     baudrate;    /* override default programmer baud rate */
  double  bitclock;    /* Specify programmer bit clock (JTAG ICE) */
  int     ispdelay;    /* Specify the delay for ISP clock */
  int     safemode;    /* Enable safemode, 1=safemode on, 0=normal */
  int     silentsafe;  /* Don't ask about fuses, 1=silent, 0=normal */
  int     init_ok;     /* Device initialization worked well */
  int     is_open;     /* Device open succeeded */
  // char  * logfile;     /* Use logfile rather than stderr for diagnostics */
  enum updateflags uflags = UF_AUTO_ERASE; /* Flags for do_op() */
  unsigned char safemode_lfuse = 0xff;
  unsigned char safemode_hfuse = 0xff;
  unsigned char safemode_efuse = 0xff;
  unsigned char safemode_fuse = 0xff;
 
  char * safemode_response;
  int fuses_specified = 0;
  int fuses_updated = 0;
// #if !defined(WIN32NATIVE)
//   char  * homedir;
// #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);
 
  progname = strrchr(argv[0],'/');
 
  cancel_flag = false;
 
#if defined (WIN32NATIVE)
  /* take care of backslash as dir sep in W32 */
  if (!progname) progname = strrchr(argv[0],'\\');
#endif /* WIN32NATIVE */
 
  if (progname)
    progname++;
  else
    progname = argv[0];
 
  default_parallel[0] = 0;
  default_serial[0]   = 0;
  default_bitclock    = 0.0;
  default_safemode    = -1;
 
  init_config();
 
  // atexit(cleanup_main);
 
  updates = lcreat(NULL, 0);
  if (updates == NULL) {
    avrdude_message(MSG_INFO, "%s: cannot initialize updater list\n", progname);
    return cleanup_main(1);
  }
 
  extended_params = lcreat(NULL, 0);
  if (extended_params == NULL) {
    avrdude_message(MSG_INFO, "%s: cannot initialize extended parameter list\n", progname);
    return cleanup_main(1);
  }
 
  additional_config_files = lcreat(NULL, 0);
  if (additional_config_files == NULL) {
    avrdude_message(MSG_INFO, "%s: cannot initialize additional config files list\n", progname);
    return cleanup_main(1);
  }
 
  partdesc      = NULL;
  port          = NULL;
  erase         = 0;
  calibrate     = 0;
  p             = NULL;
  ovsigck       = 0;
  terminal      = 0;
  verify        = 1;        /* on by default */
  quell_progress = 0;
  exitspecs     = NULL;
  pgm           = NULL;
  programmer    = default_programmer;
  verbose       = 0;
  baudrate      = 0;
  bitclock      = 0.0;
  ispdelay      = 0;
  safemode      = 1;       /* Safemode on by default */
  silentsafe    = 0;       /* Ask by default */
  is_open       = 0;
  // logfile       = NULL;
 
// #if defined(WIN32NATIVE)
 
//   win_sys_config_set(sys_config);
//   win_usr_config_set(usr_config);
 
// #else
 
//   strcpy(sys_config, CONFIG_DIR);
//   i = strlen(sys_config);
//   if (i && (sys_config[i-1] != '/'))
//     strcat(sys_config, "/");
//   strcat(sys_config, "avrdude.conf");
 
  usr_config[0] = 0;
//   homedir = getenv("HOME");
//   if (homedir != NULL) {
//     strcpy(usr_config, homedir);
//     i = strlen(usr_config);
//     if (i && (usr_config[i-1] != '/'))
//       strcat(usr_config, "/");
//     strcat(usr_config, ".avrduderc");
//   }
 
// #endif
 
  len = (int)strlen(progname) + 2;
  for (i=0; i<len; i++)
    progbuf[i] = ' ';
  progbuf[i] = 0;
 
  /*
   * check for no arguments
   */
  if (argc == 1) {
    usage();
    return 0;
  }
 
 
  /*
   * process command line arguments
   */
  optind = 1;    // Reset getopt, makes it possible to use it multiple times
  while ((ch = getopt(argc,argv,"?b:B:c:C:DeE:Fi:l:np:OP:qstU:uvVx:yY:")) != -1) {
 
    switch (ch) {
      case 'b': /* override default programmer baud rate */
        baudrate = strtol(optarg, &e, 0);
        if ((e == optarg) || (*e != 0)) {
          avrdude_message(MSG_INFO, "%s: invalid baud rate specified '%s'\n",
                  progname, optarg);
          return cleanup_main(1);
        }
        break;
 
      case 'B': /* specify JTAG ICE bit clock period */
  bitclock = strtod(optarg, &e);
  if (*e != 0) {
    /* trailing unit of measure present */
    size_t suffixlen = strlen(e);
    switch (suffixlen) {
    case 2:
      if ((e[0] != 'h' && e[0] != 'H') || e[1] != 'z')
        bitclock = 0.0;
      else
        /* convert from Hz to microseconds */
        bitclock = 1E6 / bitclock;
      break;
 
    case 3:
      if ((e[1] != 'h' && e[1] != 'H') || e[2] != 'z')
        bitclock = 0.0;
      else {
        switch (e[0]) {
        case 'M':
        case 'm':   /* no Millihertz here :) */
    bitclock = 1.0 / bitclock;
    break;
 
        case 'k':
    bitclock = 1E3 / bitclock;
    break;
 
        default:
    bitclock = 0.0;
    break;
        }
      }
      break;
 
    default:
      bitclock = 0.0;
      break;
    }
    if (bitclock == 0.0)
      avrdude_message(MSG_INFO, "%s: invalid bit clock unit of measure '%s'\n",
          progname, e);
  }
  if ((e == optarg) || bitclock == 0.0) {
    avrdude_message(MSG_INFO, "%s: invalid bit clock period specified '%s'\n",
                  progname, optarg);
          return cleanup_main(1);
        }
        break;
 
      case 'i': /* specify isp clock delay */
  ispdelay = strtol(optarg, &e,10);
  if ((e == optarg) || (*e != 0) || ispdelay == 0) {
    avrdude_message(MSG_INFO, "%s: invalid isp clock delay specified '%s'\n",
                  progname, optarg);
          return cleanup_main(1);
        }
        break;
 
      case 'c': /* programmer id */
        programmer = optarg;
        break;
 
      // case 'C': /* system wide configuration file */
      //   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;
        break;
 
      case 'e': /* perform a chip erase */
        erase = 1;
        uflags &= ~UF_AUTO_ERASE;
        break;
 
      case 'E':
        exitspecs = optarg;
        break;
 
      case 'F': /* override invalid signature check */
        ovsigck = 1;
        break;
 
  //     case 'l':
  // logfile = optarg;
  // break;
 
      case 'n':
        uflags |= UF_NOWRITE;
        break;
 
      case 'O': /* perform RC oscillator calibration */
  calibrate = 1;
  break;
 
      case 'p' : /* specify AVR part */
        partdesc = optarg;
        break;
 
      case 'P':
        port = optarg;
        break;
 
      case 'q' : /* Quell progress output */
        quell_progress++ ;
        break;
 
      case 's' : /* Silent safemode */
        silentsafe = 1;
        safemode = 1;
        break;
        
      case 't': /* enter terminal mode */
        terminal = 1;
        break;
 
      case 'u' : /* Disable safemode */
        safemode = 0;
        break;
 
      case 'U':
        upd = parse_op(optarg);
        if (upd == NULL) {
          avrdude_message(MSG_INFO, "%s: error parsing update operation '%s'\n",
                  progname, optarg);
          return cleanup_main(1);
        }
        ladd(updates, upd);
 
        if (verify && upd->op == DEVICE_WRITE) {
          upd = dup_update(upd);
          upd->op = DEVICE_VERIFY;
          ladd(updates, upd);
        }
        break;
 
      case 'v':
        verbose++;
        break;
 
      case 'V':
        verify = 0;
        break;
 
      case 'x':
        ladd(extended_params, optarg);
        break;
 
      case 'y':
        avrdude_message(MSG_INFO, "%s: erase cycle counter no longer supported\n",
                progname);
        break;
 
      case 'Y':
        avrdude_message(MSG_INFO, "%s: erase cycle counter no longer supported\n",
                progname);
        break;
 
      case '?': /* help */
        usage();
        return cleanup_main(0);
        break;
 
      default:
        avrdude_message(MSG_INFO, "%s: invalid option -%c\n\n", progname, ch);
        usage();
        return cleanup_main(1);
        break;
    }
 
  }
 
  // 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;
  //   }
  // }
 
  if (quell_progress == 0) {
    // if (isatty (STDERR_FILENO))
    //   update_progress = update_progress_tty;
    // else {
    //   update_progress = update_progress_no_tty;
    //   /* disable all buffering of stderr for compatibility with
    //      software that captures and redirects output to a GUI
    //      i.e. Programmers Notepad */
    //   setvbuf( stderr, NULL, _IONBF, 0 );
    //   setvbuf( stdout, NULL, _IONBF, 0 );
    // }
    update_progress = update_progress_no_tty;
  }
 
  /*
   * Print out an identifying string so folks can tell what version
   * they are running
   */
  avrdude_message(MSG_NOTICE, "\n%s: Version %s, compiled on %s at %s\n"
                    "%sCopyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/\n"
                    "%sCopyright (c) 2007-2014 Joerg Wunsch\n\n",
                    progname, version, __DATE__, __TIME__, progbuf, progbuf);
  // avrdude_message(MSG_NOTICE, "%sSystem wide configuration file is \"%s\"\n",
  //           progbuf, sys_config);
 
  // rc = read_config(sys_config);
  rc = read_config_builtin();
  if (rc) {
    // avrdude_message(MSG_INFO, "%s: error reading system wide configuration file \"%s\"\n",
    //                 progname, sys_config);
    avrdude_message(MSG_INFO, "%s: error reading built-in configuration file\n", progname);
    return cleanup_main(1);
  }
 
  if (usr_config[0] != 0) {
    avrdude_message(MSG_NOTICE, "%sUser configuration file is \"%s\"\n",
              progbuf, usr_config);
 
    rc = stat(usr_config, &sb);
    if ((rc < 0) || ((sb.st_mode & S_IFREG) == 0)) {
      avrdude_message(MSG_NOTICE, "%sUser configuration file does not exist or is not a "
                      "regular file, skipping\n",
                      progbuf);
    }
    else {
      rc = read_config(usr_config);
      if (rc) {
        avrdude_message(MSG_INFO, "%s: error reading user configuration file \"%s\"\n",
                progname, usr_config);
        return cleanup_main(1);
      }
    }
  }
 
  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);
      avrdude_message(MSG_NOTICE, "%sAdditional configuration file is \"%s\"\n",
                      progbuf, p);
 
      rc = read_config(p);
      if (rc) {
        avrdude_message(MSG_INFO, "%s: error reading additional configuration file \"%s\"\n",
                        progname, p);
        return cleanup_main(1);
      }
    }
  }
 
  // set bitclock from configuration files unless changed by command line
  if (default_bitclock > 0 && bitclock == 0.0) {
    bitclock = default_bitclock;
  }
 
  avrdude_message(MSG_NOTICE, "\n");
 
  if (partdesc) {
    if (strcmp(partdesc, "?") == 0) {
      avrdude_message(MSG_INFO, "\n");
      avrdude_message(MSG_INFO, "Valid parts are:\n");
      list_parts(stderr, "  ", part_list);
      avrdude_message(MSG_INFO, "\n");
      return cleanup_main(1);
    }
  }
 
  if (programmer) {
    if (strcmp(programmer, "?") == 0) {
      avrdude_message(MSG_INFO, "\n");
      avrdude_message(MSG_INFO, "Valid programmers are:\n");
      list_programmers(stderr, "  ", programmers);
      avrdude_message(MSG_INFO, "\n");
      return cleanup_main(1);
    }
    if (strcmp(programmer, "?type") == 0) {
      avrdude_message(MSG_INFO, "\n");
      avrdude_message(MSG_INFO, "Valid programmer types are:\n");
      list_programmer_types(stderr, "  ");
      avrdude_message(MSG_INFO, "\n");
      return cleanup_main(1);
    }
  }
 
 
  if (programmer[0] == 0) {
    avrdude_message(MSG_INFO, "\n%s: no programmer has been specified on the command line "
                    "or the config file\n",
                    progname);
    avrdude_message(MSG_INFO, "%sSpecify a programmer using the -c option and try again\n\n",
                    progbuf);
    return cleanup_main(1);
  }
 
  pgm = locate_programmer(programmers, programmer);
  if (pgm == NULL) {
    avrdude_message(MSG_INFO, "\n");
    avrdude_message(MSG_INFO, "%s: Can't find programmer id \"%s\"\n",
                    progname, programmer);
    avrdude_message(MSG_INFO, "\nValid programmers are:\n");
    list_programmers(stderr, "  ", programmers);
    avrdude_message(MSG_INFO, "\n");
    return cleanup_main(1);
  }
 
  if (pgm->initpgm) {
    pgm->initpgm(pgm);
  } else {
    avrdude_message(MSG_INFO, "\n%s: Can't initialize the programmer.\n\n",
                    progname);
    return cleanup_main(1);
  }
 
  if (pgm->setup) {
    pgm->setup(pgm);
  }
  pgm_setup = true;   // Replaces the atexit hook
  // if (pgm->teardown) {
  //   atexit(exithook);
  // }
 
  if (lsize(extended_params) > 0) {
    if (pgm->parseextparams == NULL) {
      avrdude_message(MSG_INFO, "%s: WARNING: Programmer doesn't support extended parameters,"
                      " -x option(s) ignored\n",
                      progname);
    } else {
      if (pgm->parseextparams(pgm, extended_params) < 0) {
        avrdude_message(MSG_INFO, "%s: Error parsing extended parameter list\n",
                        progname);
        return cleanup_main(1);
      }
    }
  }
 
  if (port == NULL) {
    switch (pgm->conntype)
    {
      case CONNTYPE_PARALLEL:
        port = default_parallel;
        break;
 
      case CONNTYPE_SERIAL:
        port = default_serial;
        break;
 
      case CONNTYPE_USB:
        port = DEFAULT_USB;
        break;
    }
  }
 
  if (partdesc == NULL) {
    avrdude_message(MSG_INFO, "%s: No AVR part has been specified, use \"-p Part\"\n\n",
                    progname);
    avrdude_message(MSG_INFO, "Valid parts are:\n");
    list_parts(stderr, "  ", part_list);
    avrdude_message(MSG_INFO, "\n");
    return cleanup_main(1);
  }
 
 
  p = locate_part(part_list, partdesc);
  if (p == NULL) {
    avrdude_message(MSG_INFO, "%s: AVR Part \"%s\" not found.\n\n",
                    progname, partdesc);
    avrdude_message(MSG_INFO, "Valid parts are:\n");
    list_parts(stderr, "  ", part_list);
    avrdude_message(MSG_INFO, "\n");
    return cleanup_main(1);
  }
 
 
  if (exitspecs != NULL) {
    if (pgm->parseexitspecs == NULL) {
      avrdude_message(MSG_INFO, "%s: WARNING: -E option not supported by this programmer type\n",
                      progname);
      exitspecs = NULL;
    }
    else if (pgm->parseexitspecs(pgm, exitspecs) < 0) {
      usage();
      return cleanup_main(1);
    }
  }
 
  if (default_safemode == 0) {
    /* configuration disables safemode: revert meaning of -u */
    if (safemode == 0)
      /* -u was given: enable safemode */
      safemode = 1;
    else
      /* -u not given: turn off */
      safemode = 0;
  }
 
  if (isatty(STDIN_FILENO) == 0 && silentsafe == 0)
    safemode  = 0;       /* Turn off safemode if this isn't a terminal */
 
 
  if(p->flags & AVRPART_AVR32) {
    safemode = 0;
  }
 
  if(p->flags & (AVRPART_HAS_PDI | AVRPART_HAS_TPI)) {
    safemode = 0;
  }
 
 
  if (avr_initmem(p) != 0)
  {
    avrdude_message(MSG_INFO, "\n%s: failed to initialize memories\n",
            progname);
    return cleanup_main(1);
  }
 
  /*
   * Now that we know which part we are going to program, locate any
   * -U options using the default memory region, and fill in the
   * device-dependent default region name, either "application" (for
   * Xmega devices), or "flash" (everything else).
   */
  for (ln=lfirst(updates); ln; ln=lnext(ln)) {
    upd = ldata(ln);
    if (upd->memtype == NULL) {
      const char *mtype = (p->flags & AVRPART_HAS_PDI)? "application": "flash";
      avrdude_message(MSG_NOTICE2, "%s: defaulting memtype in -U %c:%s option to \"%s\"\n",
                      progname,
                      (upd->op == DEVICE_READ)? 'r': (upd->op == DEVICE_WRITE)? 'w': 'v',
                      upd->filename, mtype);
      if ((upd->memtype = strdup(mtype)) == NULL) {
        avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
        return cleanup_main(1);
      }
    }
  }
 
  /*
   * open the programmer
   */
  if (port[0] == 0) {
    avrdude_message(MSG_INFO, "\n%s: no port has been specified on the command line "
            "or the config file\n",
            progname);
    avrdude_message(MSG_INFO, "%sSpecify a port using the -P option and try again\n\n",
            progbuf);
    return cleanup_main(1);
  }
 
  if (verbose) {
    avrdude_message(MSG_NOTICE, "%sUsing Port                    : %s\n", progbuf, port);
    avrdude_message(MSG_NOTICE, "%sUsing Programmer              : %s\n", progbuf, programmer);
    if ((strcmp(pgm->type, "avr910") == 0)) {
    avrdude_message(MSG_NOTICE, "%savr910_devcode (avrdude.conf) : ", progbuf);
      if(p->avr910_devcode)avrdude_message(MSG_INFO, "0x%x\n", p->avr910_devcode);
    else avrdude_message(MSG_NOTICE, "none\n");
    }
  }
 
  if (baudrate != 0) {
    avrdude_message(MSG_NOTICE, "%sOverriding Baud Rate          : %d\n", progbuf, baudrate);
    pgm->baudrate = baudrate;
  }
 
  if (bitclock != 0.0) {
    avrdude_message(MSG_NOTICE, "%sSetting bit clk period        : %.1f\n", progbuf, bitclock);
    pgm->bitclock = bitclock * 1e-6;
  }
 
  if (ispdelay != 0) {
    avrdude_message(MSG_NOTICE, "%sSetting isp clock delay        : %3i\n", progbuf, ispdelay);
    pgm->ispdelay = ispdelay;
  }
 
  rc = pgm->open(pgm, port);
  if (rc < 0) {
    exitrc = 1;
    pgm->ppidata = 0; /* clear all bits at exit */
    avrdude_message(MSG_INFO, "%s: Could not open port: %s\n", progname, port);
    goto main_exit;
  }
  is_open = 1;
 
  if (calibrate) {
    /*
     * perform an RC oscillator calibration
     * as outlined in appnote AVR053
     */
    if (pgm->perform_osccal == 0) {
      avrdude_message(MSG_INFO, "%s: programmer does not support RC oscillator calibration\n",
                      progname);
      exitrc = 1;
    } else {
      avrdude_message(MSG_INFO, "%s: performing RC oscillator calibration\n", progname);
      exitrc = pgm->perform_osccal(pgm);
    }
    if (exitrc == 0 && quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: calibration value is now stored in EEPROM at address 0\n",
                      progname);
    }
    goto main_exit;
  }
 
  if (verbose) {
    avr_display(stderr, p, progbuf, verbose);
    avrdude_message(MSG_NOTICE, "\n");
    programmer_display(pgm, progbuf);
  }
 
  if (quell_progress < 2) {
    avrdude_message(MSG_INFO, "\n");
  }
 
  exitrc = 0;
 
  /*
   * enable the programmer
   */
  pgm->enable(pgm);
 
  /*
   * turn off all the status leds
   */
  pgm->rdy_led(pgm, OFF);
  pgm->err_led(pgm, OFF);
  pgm->pgm_led(pgm, OFF);
  pgm->vfy_led(pgm, OFF);
 
  /*
   * initialize the chip in preperation for accepting commands
   */
  init_ok = (rc = pgm->initialize(pgm, p)) >= 0;
  if (!init_ok) {
    avrdude_message(MSG_INFO, "%s: initialization failed, rc=%d\n", progname, rc);
    if (!ovsigck) {
      avrdude_message(MSG_INFO, "%sDouble check connections and try again, "
              "or use -F to override\n"
              "%sthis check.\n\n",
              progbuf, progbuf);
      exitrc = 1;
      goto main_exit;
    }
  }
 
  /* indicate ready */
  pgm->rdy_led(pgm, ON);
 
  if (quell_progress < 2) {
    avrdude_message(MSG_INFO, "%s: AVR device initialized and ready to accept instructions\n",
                    progname);
  }
 
  /*
   * 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(!(p->flags & AVRPART_AVR32)) {
    int attempt = 0;
    int waittime = 10000;       /* 10 ms */
 
  sig_again:
    usleep(waittime);
    if (init_ok) {
      rc = avr_signature(pgm, p);
      if (rc != 0) {
        avrdude_message(MSG_INFO, "%s: error reading signature data, rc=%d\n",
          progname, rc);
        exitrc = 1;
        goto main_exit;
      }
    }
  
    sig = avr_locate_mem(p, "signature");
    if (sig == NULL) {
      avrdude_message(MSG_INFO, "%s: WARNING: signature data not defined for device \"%s\"\n",
                      progname, p->desc);
    }
 
    if (sig != NULL) {
      int ff, zz;
 
      if (quell_progress < 2) {
        avrdude_message(MSG_INFO, "%s: Device signature = 0x", progname);
      }
      ff = zz = 1;
      for (i=0; i<sig->size; i++) {
        if (quell_progress < 2) {
          avrdude_message(MSG_INFO, "%02x", sig->buf[i]);
        }
        if (sig->buf[i] != 0xff)
          ff = 0;
        if (sig->buf[i] != 0x00)
          zz = 0;
      }
      if (quell_progress < 2) {
        AVRPART * part;
 
        part = locate_part_by_signature(part_list, sig->buf, sig->size);
        if (part) {
          avrdude_message(MSG_INFO, " (probably %s)", part->id);
        }
      }
      if (ff || zz) {
        if (++attempt < 3) {
          waittime *= 5;
          if (quell_progress < 2) {
              avrdude_message(MSG_INFO, " (retrying)\n");
          }
          goto sig_again;
        }
        if (quell_progress < 2) {
            avrdude_message(MSG_INFO, "\n");
        }
        avrdude_message(MSG_INFO, "%s: Yikes!  Invalid device signature.\n", progname);
        if (!ovsigck) {
          avrdude_message(MSG_INFO, "%sDouble check connections and try again, "
                  "or use -F to override\n"
                  "%sthis check.\n\n",
                  progbuf, progbuf);
          exitrc = 1;
          goto main_exit;
        }
      } else {
        if (quell_progress < 2) {
          avrdude_message(MSG_INFO, "\n");
        }
      }
 
      if (sig->size != 3 ||
          sig->buf[0] != p->signature[0] ||
          sig->buf[1] != p->signature[1] ||
          sig->buf[2] != p->signature[2]) {
        avrdude_message(MSG_INFO, "%s: Expected signature for %s is %02X %02X %02X\n",
                        progname, p->desc,
                        p->signature[0], p->signature[1], p->signature[2]);
        if (!ovsigck) {
          avrdude_message(MSG_INFO, "%sDouble check chip, "
                  "or use -F to override this check.\n",
                  progbuf);
          exitrc = 1;
          goto main_exit;
        }
      }
    }
  }
 
  if (init_ok && safemode == 1) {
    /* If safemode is enabled, go ahead and read the current low, high,
       and extended fuse bytes as needed */
 
    rc = safemode_readfuses(&safemode_lfuse, &safemode_hfuse,
                           &safemode_efuse, &safemode_fuse, pgm, p);
 
    if (rc != 0) {
 
    //Check if the programmer just doesn't support reading
      if (rc == -5)
      {
        avrdude_message(MSG_NOTICE, "%s: safemode: Fuse reading not support by programmer.\n"
            "              Safemode disabled.\n", progname);
      }
      else
      {
 
          avrdude_message(MSG_INFO, "%s: safemode: To protect your AVR the programming "
                        "will be aborted\n",
                         progname);
          exitrc = 1;
        goto main_exit;
      }
    } else {
      //Save the fuses as default
      safemode_memfuses(1, &safemode_lfuse, &safemode_hfuse, &safemode_efuse, &safemode_fuse);
    }
  }
 
  if (uflags & UF_AUTO_ERASE) {
    if ((p->flags & AVRPART_HAS_PDI) && pgm->page_erase != NULL &&
        lsize(updates) > 0) {
      if (quell_progress < 2) {
        avrdude_message(MSG_INFO, "%s: NOTE: Programmer supports page erase for Xmega devices.\n"
                        "%sEach page will be erased before programming it, but no chip erase is performed.\n"
                        "%sTo disable page erases, specify the -D option; for a chip-erase, use the -e option.\n",
                        progname, progbuf, progbuf);
      }
    } else {
      AVRMEM * m;
      const char *memname = (p->flags & AVRPART_HAS_PDI)? "application": "flash";
 
      uflags &= ~UF_AUTO_ERASE;
      for (ln=lfirst(updates); ln; ln=lnext(ln)) {
        upd = ldata(ln);
        m = avr_locate_mem(p, upd->memtype);
        if (m == NULL)
          continue;
        if ((strcasecmp(m->desc, memname) == 0) && (upd->op == DEVICE_WRITE)) {
          erase = 1;
          if (quell_progress < 2) {
            avrdude_message(MSG_INFO, "%s: NOTE: \"%s\" memory has been specified, an erase cycle "
                            "will be performed\n"
                            "%sTo disable this feature, specify the -D option.\n",
                            progname, memname, progbuf);
          }
          break;
        }
      }
    }
  }
 
  if (init_ok && erase) {
    /*
     * erase the chip's flash and eeprom memories, this is required
     * before the chip can accept new programming
     */
    if (uflags & UF_NOWRITE) {
      avrdude_message(MSG_INFO, "%s: conflicting -e and -n options specified, NOT erasing chip\n",
                      progname);
    } else {
      if (quell_progress < 2) {
        avrdude_message(MSG_INFO, "%s: erasing chip\n", progname);
      }
      exitrc = avr_chip_erase(pgm, p);
      if(exitrc) goto main_exit;
    }
  }
 
  if (terminal) {
    /*
     * terminal mode
     */
    exitrc = terminal_mode(pgm, p);
  }
 
  if (!init_ok) {
    /*
     * If we came here by the -tF options, bail out now.
     */
    exitrc = 1;
    goto main_exit;
  }
 
 
  for (ln=lfirst(updates); ln; ln=lnext(ln)) {
    upd = ldata(ln);
    rc = do_op(pgm, p, upd, uflags);
    if (rc) {
      exitrc = 1;
      break;
    }
  }
 
  /* Right before we exit programming mode, which will make the fuse
     bits active, check to make sure they are still correct */
  if (safemode == 1) {
    /* If safemode is enabled, go ahead and read the current low,
     * high, and extended fuse bytes as needed */
    unsigned char safemodeafter_lfuse = 0xff;
    unsigned char safemodeafter_hfuse = 0xff;
    unsigned char safemodeafter_efuse = 0xff;
    unsigned char safemodeafter_fuse  = 0xff;
    unsigned char failures = 0;
    char yes[1] = {'y'};
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "\n");
    }
 
    //Restore the default fuse values
    safemode_memfuses(0, &safemode_lfuse, &safemode_hfuse, &safemode_efuse, &safemode_fuse);
 
    /* Try reading back fuses, make sure they are reliable to read back */
    if (safemode_readfuses(&safemodeafter_lfuse, &safemodeafter_hfuse,
                           &safemodeafter_efuse, &safemodeafter_fuse, pgm, p) != 0) {
      /* Uh-oh.. try once more to read back fuses */
      if (safemode_readfuses(&safemodeafter_lfuse, &safemodeafter_hfuse,
                             &safemodeafter_efuse, &safemodeafter_fuse, pgm, p) != 0) {
        avrdude_message(MSG_INFO, "%s: safemode: Sorry, reading back fuses was unreliable. "
                        "I have given up and exited programming mode\n",
                        progname);
        exitrc = 1;
        goto main_exit;        
      }
    }
    
    /* Now check what fuses are against what they should be */
    if (safemodeafter_fuse != safemode_fuse) {
      fuses_updated = 1;
      avrdude_message(MSG_INFO, "%s: safemode: fuse changed! Was %x, and is now %x\n",
              progname, safemode_fuse, safemodeafter_fuse);
 
              
      /* Ask user - should we change them */
       
       if (silentsafe == 0)
            safemode_response = terminal_get_input("Would you like this fuse to be changed back? [y/n] ");
       else
            safemode_response = yes;
       
       if (tolower((int)(safemode_response[0])) == 'y') {
              
            /* Enough chit-chat, time to program some fuses and check them */
            if (safemode_writefuse (safemode_fuse, "fuse", pgm, p,
                                    10) == 0) {
                avrdude_message(MSG_INFO, "%s: safemode: and is now rescued\n", progname);
            }
            else {
                avrdude_message(MSG_INFO, "%s: and COULD NOT be changed\n", progname);
                failures++;
            }
      }
    }
 
    /* Now check what fuses are against what they should be */
    if (safemodeafter_lfuse != safemode_lfuse) {
      fuses_updated = 1;
      avrdude_message(MSG_INFO, "%s: safemode: lfuse changed! Was %x, and is now %x\n",
              progname, safemode_lfuse, safemodeafter_lfuse);
 
              
      /* Ask user - should we change them */
       
       if (silentsafe == 0)
            safemode_response = terminal_get_input("Would you like this fuse to be changed back? [y/n] ");
       else
            safemode_response = yes;
       
       if (tolower((int)(safemode_response[0])) == 'y') {
              
            /* Enough chit-chat, time to program some fuses and check them */
            if (safemode_writefuse (safemode_lfuse, "lfuse", pgm, p,
                                    10) == 0) {
                avrdude_message(MSG_INFO, "%s: safemode: and is now rescued\n", progname);
            }
            else {
                avrdude_message(MSG_INFO, "%s: and COULD NOT be changed\n", progname);
                failures++;
            }
      }
    }
 
    /* Now check what fuses are against what they should be */
    if (safemodeafter_hfuse != safemode_hfuse) {
      fuses_updated = 1;
      avrdude_message(MSG_INFO, "%s: safemode: hfuse changed! Was %x, and is now %x\n",
              progname, safemode_hfuse, safemodeafter_hfuse);
              
      /* Ask user - should we change them */
       if (silentsafe == 0)
            safemode_response = terminal_get_input("Would you like this fuse to be changed back? [y/n] ");
       else
            safemode_response = yes;
       if (tolower((int)(safemode_response[0])) == 'y') {
 
            /* Enough chit-chat, time to program some fuses and check them */
            if (safemode_writefuse(safemode_hfuse, "hfuse", pgm, p,
                                    10) == 0) {
                avrdude_message(MSG_INFO, "%s: safemode: and is now rescued\n", progname);
            }
            else {
                avrdude_message(MSG_INFO, "%s: and COULD NOT be changed\n", progname);
                failures++;
            }
      }
    }
 
    /* Now check what fuses are against what they should be */
    if (safemodeafter_efuse != safemode_efuse) {
      fuses_updated = 1;
      avrdude_message(MSG_INFO, "%s: safemode: efuse changed! Was %x, and is now %x\n",
              progname, safemode_efuse, safemodeafter_efuse);
 
      /* Ask user - should we change them */
       if (silentsafe == 0)
            safemode_response = terminal_get_input("Would you like this fuse to be changed back? [y/n] ");
       else
            safemode_response = yes;
       if (tolower((int)(safemode_response[0])) == 'y') {
              
            /* Enough chit-chat, time to program some fuses and check them */
            if (safemode_writefuse (safemode_efuse, "efuse", pgm, p,
                                    10) == 0) {
                avrdude_message(MSG_INFO, "%s: safemode: and is now rescued\n", progname);
            }
            else {
                avrdude_message(MSG_INFO, "%s: and COULD NOT be changed\n", progname);
                failures++;
            }
       }
    }
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: safemode: ", progname);
      if (failures == 0) {
        avrdude_message(MSG_INFO, "Fuses OK (E:%02X, H:%02X, L:%02X)\n",
                safemode_efuse, safemode_hfuse, safemode_lfuse);
      }
      else {
        avrdude_message(MSG_INFO, "Fuses not recovered, sorry\n");
      }
    }
 
    if (fuses_updated && fuses_specified) {
      exitrc = 1;
    }
 
  }
 
 
main_exit:
 
  /*
   * program complete
   */
 
  if (is_open) {
    pgm->powerdown(pgm);
 
    pgm->disable(pgm);
 
    pgm->rdy_led(pgm, OFF);
 
    pgm->close(pgm);
  }
 
  if (quell_progress < 2) {
    avrdude_message(MSG_INFO, "\n%s done.  Thank you.\n\n", progname);
  }
 
  return cleanup_main(exitrc);
}

References additional_config_files, avrpart::avr910_devcode, avr_chip_erase(), avr_display(), avr_initmem(), avr_locate_mem(), avr_signature(), avrdude_message(), AVRPART_AVR32, AVRPART_HAS_PDI, AVRPART_HAS_TPI, programmer_t::baudrate, programmer_t::bitclock, avrmem::buf, cancel_flag, cleanup_main(), programmer_t::close, programmer_t::conntype, CONNTYPE_PARALLEL, CONNTYPE_SERIAL, CONNTYPE_USB, default_bitclock, default_parallel, default_programmer, default_safemode, default_serial, DEFAULT_USB, avrpart::desc, avrmem::desc, DEVICE_READ, DEVICE_VERIFY, DEVICE_WRITE, programmer_t::disable, do_op(), dup_update(), programmer_t::enable, programmer_t::err_led, extended_params, avrpart::flags, getopt(), avrpart::id, init_config(), programmer_t::initialize, programmer_t::initpgm, isatty, programmer_t::ispdelay, ladd(), lcreat(), ldata(), lfirst(), list_parts(), list_programmer_types(), list_programmers(), lnext(), locate_part(), locate_part_by_signature(), locate_programmer(), lsize(), MSG_INFO, MSG_NOTICE, MSG_NOTICE2, OFF, ON, programmer_t::open, optarg, optind, ovsigck, programmer_t::page_erase, parse_op(), programmer_t::parseexitspecs, programmer_t::parseextparams, part_list, PATH_MAX, programmer_t::perform_osccal, pgm, programmer_t::pgm_led, pgm_setup, programmer_t::powerdown, programmer_t::ppidata, progbuf, progname, programmer_display(), programmers, quell_progress, programmer_t::rdy_led, read_config(), read_config_builtin(), safemode_memfuses(), safemode_readfuses(), safemode_writefuse(), programmer_t::setup, avrpart::signature, avrmem::size, stat, STDIN_FILENO, strcasecmp, terminal_get_input(), terminal_mode(), programmer_t::type, UF_AUTO_ERASE, UF_NOWRITE, update_progress, update_progress_no_tty(), updates, usage(), usleep(), verbose, version, and programmer_t::vfy_led.

Referenced by Slic3r::AvrDude::priv::run_one().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ avrdude_message()

int avrdude_message	(	const int	msglvl,
		const char *	format,
			...
	)

{
    static const char *format_error = "avrdude_message: Could not format message";
 
    int rc = 0;
    va_list ap;
    if (verbose >= msglvl) {
        va_start(ap, format);
        rc = vsnprintf(msgbuffer, MSGBUFFER_SIZE, format, ap);
 
        if (rc > 0 && rc < MSGBUFFER_SIZE) {
            avrdude_message_handler(msgbuffer, rc, avrdude_message_handler_user_p);
        } else {
            rc = snprintf(msgbuffer, MSGBUFFER_SIZE, "%s: %s", format_error, format);
            if (rc > 0 && rc < MSGBUFFER_SIZE) {
                avrdude_message_handler(msgbuffer, rc, avrdude_message_handler_user_p);
            } else {
                avrdude_message_handler(format_error, (unsigned)strlen(format_error), avrdude_message_handler_user_p);
            }
        }
 
        va_end(ap);
    }
    return rc;
}

References avrdude_message_handler, avrdude_message_handler_user_p, msgbuffer, MSGBUFFER_SIZE, snprintf, and verbose.

Referenced by arduino_open(), arduino_read_sig_bytes(), avr910_initialize(), avr910_parseextparms(), avr910_read_sig_bytes(), avr910_recv(), avr910_setup(), avr910_vfy_cmd_sent(), avr_display(), avr_get_cycle_count(), avr_initmem(), avr_mem_display(), avr_put_cycle_count(), avr_read(), avr_read_byte_default(), avr_signature(), avr_tpi_chip_erase(), avr_tpi_program_enable(), avr_verify(), avr_write(), avr_write_byte_default(), avr_write_page(), avrdude_main(), avrftdi_noftdi_open(), b2ihex(), b2srec(), bitbang_calibrate_delay(), bitbang_check_prerequisites(), bitbang_chip_erase(), bitbang_cmd(), bitbang_cmd_tpi(), bitbang_initialize(), bitbang_program_enable(), bitbang_spi(), bitbang_tpi_rx(), buspirate_bb_enable(), buspirate_bb_getpin(), buspirate_bb_setpin_internal(), buspirate_chip_erase(), buspirate_cmd_ascii(), buspirate_enable(), buspirate_expect_bin(), buspirate_getc(), buspirate_paged_load(), buspirate_paged_write(), buspirate_parseextparms(), buspirate_powerdown(), buspirate_powerup(), buspirate_program_enable(), buspirate_readline(), buspirate_readline_noexit(), buspirate_recv_bin(), buspirate_reset_from_binmode(), buspirate_send(), buspirate_send_bin(), buspirate_start_mode_bin(), buspirate_start_spi_mode_ascii(), buspirate_verifyconfig(), butterfly_initialize(), butterfly_page_erase(), butterfly_read_sig_bytes(), butterfly_recv(), butterfly_vfy_cmd_sent(), cmd_dump(), cmd_erase(), cmd_fosc(), cmd_parms(), cmd_sck(), cmd_send(), cmd_sig(), cmd_varef(), cmd_verbose(), cmd_vtarg(), cmd_write(), dfu_open(), do_cmd(), do_op(), dump_mem(), fileio(), fileio_ihex(), fileio_imm(), fileio_num(), fileio_rbin(), fileio_setparms(), fileio_srec(), fmt_autodetect(), ft245r_nopthread_open(), hexnumber(), ihex2b(), jtag3_chip_erase_dw(), jtag3_close(), jtag3_command(), jtag3_display(), jtag3_edbg_prepare(), jtag3_edbg_recv_frame(), jtag3_edbg_send(), jtag3_edbg_signoff(), jtag3_getparm(), jtag3_getsync(), jtag3_initialize(), jtag3_open(), jtag3_open_common(), jtag3_open_dw(), jtag3_open_pdi(), jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_parseextparms(), jtag3_prevent(), jtag3_print_data(), jtag3_print_parms1(), jtag3_prmsg(), jtag3_read_byte(), jtag3_recv(), jtag3_recv_frame(), jtag3_send(), jtag3_set_sck_period(), jtag3_setparm(), jtag3_setup(), jtag3_write_byte(), jtagmkI_chip_erase(), jtagmkI_close(), jtagmkI_display(), jtagmkI_getparm(), jtagmkI_getsync(), jtagmkI_initialize(), jtagmkI_open(), jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_print_parms1(), jtagmkI_prmsg(), jtagmkI_program_disable(), jtagmkI_program_enable(), jtagmkI_read_byte(), jtagmkI_recv(), jtagmkI_reset(), jtagmkI_resync(), jtagmkI_send(), jtagmkI_set_devdescr(), jtagmkI_setparm(), jtagmkI_setup(), jtagmkI_write_byte(), jtagmkII_avr32_reset(), jtagmkII_chip_erase(), jtagmkII_chip_erase32(), jtagmkII_chip_erase_dw(), jtagmkII_close(), jtagmkII_close32(), jtagmkII_display(), jtagmkII_dragon_open(), jtagmkII_dragon_open_dw(), jtagmkII_dragon_open_pdi(), jtagmkII_flash_clear_pagebuffer32(), jtagmkII_flash_erase32(), jtagmkII_flash_lock32(), jtagmkII_flash_write_page32(), jtagmkII_getparm(), jtagmkII_getsync(), jtagmkII_initialize(), jtagmkII_initialize32(), jtagmkII_open(), jtagmkII_open32(), jtagmkII_open_dw(), jtagmkII_open_pdi(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_parseextparms(), jtagmkII_print_memory(), jtagmkII_print_parms1(), jtagmkII_prmsg(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_read_byte(), jtagmkII_read_SABaddr(), jtagmkII_recv(), jtagmkII_recv_frame(), jtagmkII_reset(), jtagmkII_reset32(), jtagmkII_send(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), jtagmkII_setup(), jtagmkII_smc_init32(), jtagmkII_write_byte(), jtagmkII_write_SABaddr(), linuxgpio_initpgm(), mib510_isp(), net_open(), number(), number_real(), par_initpgm(), parse_op(), pgm_default(), pgm_default_open(), pgm_display_generic_mask(), pgm_dup(), pgm_new(), pickit2_nousb_open(), pin_fill_old_pinlist(), pin_fill_old_pinno(), pins_check(), print_token(), programmer_display(), prusa_init_external_flash(), pyytext(), read_config(), read_config_builtin(), safemode_readfuses(), safemode_writefuse(), ser_close(), ser_drain(), ser_open(), ser_recv(), ser_send(), ser_setspeed(), serbb_open(), serial_baud_lookup(), srec2b(), stk500_chip_erase(), stk500_cmd(), stk500_disable(), stk500_display(), stk500_getparm(), stk500_getsync(), stk500_initialize(), stk500_loadaddr(), stk500_paged_load(), stk500_paged_write(), stk500_print_parms1(), stk500_program_enable(), stk500_recv(), stk500_set_extended_parms(), stk500_set_fosc(), stk500_set_sck_period(), stk500_set_varef(), stk500_set_vtarget(), stk500_setparm(), stk500_setup(), stk500generic_open(), stk500hv_disable(), stk500hv_initialize(), stk500hv_paged_load(), stk500hv_paged_write(), stk500hv_read_byte(), stk500hv_write_byte(), stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_cmd(), stk500v2_command(), stk500v2_disable(), stk500v2_display(), stk500v2_getparm(), stk500v2_getparm2(), stk500v2_getsync(), stk500v2_initialize(), stk500v2_jtag3_cmd(), stk500v2_jtag3_disable(), stk500v2_loadaddr(), stk500v2_mode_for_pagesize(), stk500v2_open(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_print_parms1(), stk500v2_program_enable(), stk500v2_recv(), stk500v2_recv_mk2(), stk500v2_send(), stk500v2_send_mk2(), stk500v2_set_fosc(), stk500v2_set_sck_period_mk2(), stk500v2_set_varef(), stk500v2_set_vtarget(), stk500v2_setparm(), stk500v2_setparm2(), stk500v2_setparm_real(), stk600_open(), stk600_set_varef(), stk600_set_vtarget(), stk600_xprog_chip_erase(), stk600_xprog_command(), stk600_xprog_disable(), stk600_xprog_page_erase(), stk600_xprog_paged_load(), stk600_xprog_paged_write(), stk600_xprog_program_enable(), stk600_xprog_read_byte(), stk600_xprog_write_byte(), string(), update_progress_no_tty(), usage(), usbasp_nousb_open(), usbtiny_nousb_open(), verify_pin_assigned(), wiring_open(), wiring_parseextparms(), yyerror(), and yywarning().

◆ avrdude_message_handler_null()

static void avrdude_message_handler_null	(	const char *	msg,
		unsigned	size,
		void *	user_p
	)

static

{
    // Output to stderr by default
    (void)size;
    (void)user_p;
    fputs(msg, stderr);
}

References void().

Referenced by avrdude_message_handler_set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ avrdude_message_handler_set()

void avrdude_message_handler_set	(	avrdude_message_handler_t	newhandler,
		void *	user_p
	)

{
    if (newhandler != NULL) {
        avrdude_message_handler = newhandler;
        avrdude_message_handler_user_p = user_p;
    } else {
        avrdude_message_handler = avrdude_message_handler_null;
        avrdude_message_handler_user_p = NULL;
    }
}

References avrdude_message_handler, avrdude_message_handler_null(), and avrdude_message_handler_user_p.

Referenced by Slic3r::AvrDude::priv::set_handlers(), and Slic3r::AvrDude::priv::unset_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ avrdude_oom()

void avrdude_oom ( const char * context )

{
    avrdude_oom_handler(context, avrdude_oom_handler_user_p);
}

References avrdude_oom_handler, and avrdude_oom_handler_user_p.

Referenced by avr_dup_mem(), avr_dup_opcode(), avr_new_memtype(), avr_new_opcode(), avr_new_part(), buspirate_setup(), butterfly_setup(), dup_update(), new_update(), parse_op(), pgm_dup(), stk500v2_setup(), and wiring_setup().

Here is the caller graph for this function:

◆ avrdude_oom_handler_null()

static void avrdude_oom_handler_null	(	const char *	context,
		void *	user_p
	)

static

{
    // Output a message and just exit
    fputs("avrdude: Out of memory: ", stderr);
    fputs(context, stderr);
    exit(99);
}

Referenced by avrdude_oom_handler_set().

Here is the caller graph for this function:

◆ avrdude_oom_handler_set()

void avrdude_oom_handler_set	(	avrdude_oom_handler_t	newhandler,
		void *	user_p
	)

{
    if (newhandler != NULL) {
        avrdude_oom_handler = newhandler;
        avrdude_oom_handler_user_p = user_p;
    } else {
        avrdude_oom_handler = avrdude_oom_handler_null;
        avrdude_oom_handler_user_p = NULL;
    }
}

References avrdude_oom_handler, avrdude_oom_handler_null(), and avrdude_oom_handler_user_p.

Referenced by Slic3r::AvrDude::priv::set_handlers(), and Slic3r::AvrDude::priv::unset_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ avrdude_progress_external()

void avrdude_progress_external	(	const char *	task,
		unsigned	progress
	)

{
    avrdude_progress_handler(task, progress, avrdude_progress_handler_user_p);
}

References avrdude_progress_handler, and avrdude_progress_handler_user_p.

Referenced by update_progress_no_tty().

Here is the caller graph for this function:

◆ avrdude_progress_handler_null()

static void avrdude_progress_handler_null	(	const char *	task,
		unsigned	progress,
		void *	user_p
	)

static

{
    // By default do nothing
    (void)task;
    (void)progress;
    (void)user_p;
}

References void().

Referenced by avrdude_progress_handler_set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ avrdude_progress_handler_set()

void avrdude_progress_handler_set	(	avrdude_progress_handler_t	newhandler,
		void *	user_p
	)

{
    if (newhandler != NULL) {
        avrdude_progress_handler = newhandler;
        avrdude_progress_handler_user_p = user_p;
    } else {
        avrdude_progress_handler = avrdude_progress_handler_null;
        avrdude_progress_handler_user_p = NULL;
    }
}

References avrdude_progress_handler, avrdude_progress_handler_null(), and avrdude_progress_handler_user_p.

Referenced by Slic3r::AvrDude::priv::set_handlers(), and Slic3r::AvrDude::priv::unset_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup_main()

static int cleanup_main ( int status )

static

{
    if (pgm_setup && pgm != NULL && pgm->teardown) {
        pgm->teardown(pgm);
    }
 
    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();
 
    return status;
}

References additional_config_files, cleanup_config(), extended_params, free_update(), ldestroy(), ldestroy_cb(), pgm, pgm_setup, programmer_t::teardown, and updates.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_avrparts_callback()

static void list_avrparts_callback	(	const char *	name,
		const char *	desc,
		const char *	cfgname,
		int	cfglineno,
		void *	cookie
	)

static

{
    struct list_walk_cookie *c = (struct list_walk_cookie *)cookie;
 
    /* hide ids starting with '.' */
    if ((verbose < 2) && (name[0] == '.'))
        return;
 
    if (verbose) {
        fprintf(c->f, "%s%-8s = %-18s [%s:%d]\n",
                c->prefix, name, desc, cfgname, cfglineno);
    } else {
        fprintf(c->f, "%s%-8s = %s\n",
                c->prefix, name, desc);
    }
}

References verbose.

Referenced by list_parts().

Here is the caller graph for this function:

◆ list_parts()

static void list_parts	(	FILE *	f,
		const char *	prefix,
		LISTID	avrparts
	)

static

{
    struct list_walk_cookie c;
 
    c.f = f;
    c.prefix = prefix;
 
    sort_avrparts(avrparts);
 
    walk_avrparts(avrparts, list_avrparts_callback, &c);
}

References list_walk_cookie::f, list_avrparts_callback(), list_walk_cookie::prefix, sort_avrparts(), and walk_avrparts().

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_programmer_types()

static void list_programmer_types	(	FILE *	f,
		const char *	prefix
	)

static

{
    struct list_walk_cookie c;
 
    c.f = f;
    c.prefix = prefix;
 
    walk_programmer_types(list_programmer_types_callback, &c);
}

References list_walk_cookie::f, list_programmer_types_callback(), list_walk_cookie::prefix, and walk_programmer_types().

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_programmer_types_callback()

static void list_programmer_types_callback	(	const char *	name,
		const char *	desc,
		void *	cookie
	)

static

{
    struct list_walk_cookie *c = (struct list_walk_cookie *)cookie;
    fprintf(c->f, "%s%-16s = %-s\n",
                c->prefix, name, desc);
}

Referenced by list_programmer_types().

Here is the caller graph for this function:

◆ list_programmers()

static void list_programmers	(	FILE *	f,
		const char *	prefix,
		LISTID	programmers
	)

static

{
    struct list_walk_cookie c;
 
    c.f = f;
    c.prefix = prefix;
 
    sort_programmers(programmers);
 
    walk_programmers(programmers, list_programmers_callback, &c);
}

References list_walk_cookie::f, list_programmers_callback(), list_walk_cookie::prefix, programmers, sort_programmers(), and walk_programmers().

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_programmers_callback()

static void list_programmers_callback	(	const char *	name,
		const char *	desc,
		const char *	cfgname,
		int	cfglineno,
		void *	cookie
	)

static

{
    struct list_walk_cookie *c = (struct list_walk_cookie *)cookie;
    if (verbose){
        fprintf(c->f, "%s%-16s = %-30s [%s:%d]\n",
                c->prefix, name, desc, cfgname, cfglineno);
    } else {
        fprintf(c->f, "%s%-16s = %-s\n",
                c->prefix, name, desc);
    }
}

References verbose.

Referenced by list_programmers().

Here is the caller graph for this function:

◆ update_progress_no_tty()

static void update_progress_no_tty	(	int	percent,
		double	etime,
		char *	hdr
	)

static

{
  static int done = 0;
  static int last = 0;
  static char *header = NULL;
  int cnt = (percent>>1)*2;
 
  // setvbuf(stderr, (char*)NULL, _IONBF, 0);
 
  if (hdr) {
    avrdude_message(MSG_INFO, "\n%s | ", hdr);
    last = 0;
    done = 0;
    header = hdr;
    avrdude_progress_external(header, 0);
  }
  else {
    while ((cnt > last) && (done == 0)) {
      avrdude_message(MSG_INFO, "#");
      cnt -=  2;
    }
 
    if (done == 0) {
      avrdude_progress_external(header, percent > 99 ? 99 : percent);
    }
  }
 
  if ((percent == 100) && (done == 0)) {
    avrdude_message(MSG_INFO, " | 100%% %0.2fs\n\n", etime);
    avrdude_progress_external(header, 100);
    last = 0;
    done = 1;
  }
  else
    last = (percent>>1)*2;    /* Make last a multiple of 2. */
 
  // setvbuf(stderr, (char*)NULL, _IOLBF, 0);
}

References avrdude_message(), avrdude_progress_external(), done, and MSG_INFO.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ usage()

static void usage ( void )

static

{
  avrdude_message(MSG_INFO, 
 "Usage: %s [options]\n"
 "Options:\n"
 "  -p <partno>                Required. Specify AVR device.\n"
 "  -b <baudrate>              Override RS-232 baud rate.\n"
 "  -B <bitclock>              Specify JTAG/STK500v2 bit clock period (us).\n"
 "  -C <config-file>           Specify location of configuration file.\n"
 "  -c <programmer>            Specify programmer type.\n"
 "  -D                         Disable auto erase for flash memory\n"
 "  -i <delay>                 ISP Clock Delay [in microseconds]\n"
 "  -P <port>                  Specify connection port.\n"
 "  -F                         Override invalid signature check.\n"
 "  -e                         Perform a chip erase.\n"
 "  -O                         Perform RC oscillator calibration (see AVR053). \n"
 "  -U <memtype>:r|w|v:<section>:<filename>[:format]\n"
 "                             Memory operation specification.\n"
 "                             Multiple -U options are allowed, each request\n"
 "                             is performed in the order specified.\n"
 "  -n                         Do not write anything to the device.\n"
 "  -V                         Do not verify.\n"
 "  -u                         Disable safemode, default when running from a script.\n"
 "  -s                         Silent safemode operation, will not ask you if\n"
 "                             fuses should be changed back.\n"
 "  -t                         Enter terminal mode.\n"
 "  -E <exitspec>[,<exitspec>] List programmer exit specifications.\n"
 "  -x <extended_param>        Pass <extended_param> to programmer.\n"
 "  -y                         Count # erase cycles in EEPROM.\n"
 "  -Y <number>                Initialize erase cycle # in EEPROM.\n"
 "  -v                         Verbose output. -v -v for more.\n"
 "  -q                         Quell progress output. -q -q for less.\n"
//  "  -l logfile                 Use logfile rather than stderr for diagnostics.\n"
 "  -?                         Display this usage.\n"
 "\navrdude version %s, URL: <http://savannah.nongnu.org/projects/avrdude/>\n"
          ,progname, version);
}