stk500.c File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "stk500.h"
#include "stk500_private.h"

Include dependency graph for stk500.c:

Go to the source code of this file.

Classes
struct	pdata

Macros
#define	STK500_XTAL   7372800U
#define	MAX_SYNC_ATTEMPTS   10
#define	PDATA(pgm)   ((struct pdata *)(pgm->cookie))

Functions
static int	stk500_getparm (PROGRAMMER *pgm, unsigned parm, unsigned *value)
static int	stk500_setparm (PROGRAMMER *pgm, unsigned parm, unsigned value)
static void	stk500_print_parms1 (PROGRAMMER *pgm, const char *p)
static int	stk500_send (PROGRAMMER *pgm, unsigned char *buf, size_t len)
static int	stk500_recv (PROGRAMMER *pgm, unsigned char *buf, size_t len)
int	stk500_drain (PROGRAMMER *pgm, int display)
int	stk500_getsync (PROGRAMMER *pgm)
static int	stk500_cmd (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res)
static int	stk500_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	stk500_program_enable (PROGRAMMER *pgm, AVRPART *p)
static int	stk500_set_extended_parms (PROGRAMMER *pgm, int n, unsigned char *cmd)
static int	mib510_isp (PROGRAMMER *pgm, unsigned char cmd)
static int	stk500_initialize (PROGRAMMER *pgm, AVRPART *p)
static void	stk500_disable (PROGRAMMER *pgm)
static void	stk500_enable (PROGRAMMER *pgm)
static int	stk500_open (PROGRAMMER *pgm, char *port)
static void	stk500_close (PROGRAMMER *pgm)
static int	stk500_loadaddr (PROGRAMMER *pgm, AVRMEM *mem, unsigned int addr)
static int	stk500_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500_set_vtarget (PROGRAMMER *pgm, double v)
static int	stk500_set_varef (PROGRAMMER *pgm, unsigned int chan, double v)
static int	stk500_set_fosc (PROGRAMMER *pgm, double v)
static int	stk500_set_sck_period (PROGRAMMER *pgm, double v)
static void	stk500_display (PROGRAMMER *pgm, const char *p)
static void	stk500_print_parms (PROGRAMMER *pgm)
static void	stk500_setup (PROGRAMMER *pgm)
static void	stk500_teardown (PROGRAMMER *pgm)
void	stk500_initpgm (PROGRAMMER *pgm)

Variables
const char	stk500_desc [] = "Atmel STK500 Version 1.x firmware"

Macro Definition Documentation

MAX_SYNC_ATTEMPTS

#define MAX_SYNC_ATTEMPTS   10

PDATA

#define PDATA

(

pgm

)

((struct pdata *)(pgm->cookie))

STK500_XTAL

#define STK500_XTAL   7372800U

Function Documentation

mib510_isp()

static int mib510_isp ( PROGRAMMER *  pgm, unsigned char  cmd  )

static

{
  unsigned char buf[9];
  int tries = 0;
 
  buf[0] = 0xaa;
  buf[1] = 0x55;
  buf[2] = 0x55;
  buf[3] = 0xaa;
  buf[4] = 0x17;
  buf[5] = 0x51;
  buf[6] = 0x31;
  buf[7] = 0x13;
  buf[8] = cmd;
 
 
 retry:
 
  tries++;
 
  stk500_send(pgm, buf, 9);
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "%s: mib510_isp(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: mib510_isp(): protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -1;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_OK) {
    return 0;
  }
  else if (buf[0] == Resp_STK_NODEVICE) {
    avrdude_message(MSG_INFO, "%s: mib510_isp(): no device\n",
            progname);
    return -1;
  }
 
  if (buf[0] == Resp_STK_FAILED)
  {
      avrdude_message(MSG_INFO, "%s: mib510_isp(): command %d failed\n",
                      progname, cmd);
      return -1;
  }
 
 
  avrdude_message(MSG_INFO, "%s: mib510_isp(): unknown response=0x%02x\n",
          progname, buf[0]);
 
  return -1;
}

References avrdude_message(), cmd, MSG_INFO, pgm, progname, Resp_STK_FAILED, Resp_STK_INSYNC, Resp_STK_NODEVICE, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), and stk500_send().

Referenced by stk500_close(), and stk500_open().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_chip_erase()

static int stk500_chip_erase ( PROGRAMMER *  pgm, AVRPART *  p  )

static

{
  unsigned char cmd[4];
  unsigned char res[4];
 
  if (pgm->cmd == NULL) {
    avrdude_message(MSG_INFO, "%s: Error: %s programmer uses stk500_chip_erase() but does not\n"
                    "provide a cmd() method.\n",
                    progname, pgm->type);
    return -1;
  }
 
  if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
    avrdude_message(MSG_INFO, "chip erase instruction not defined for part \"%s\"\n",
            p->desc);
    return -1;
  }
 
  pgm->pgm_led(pgm, ON);
 
  memset(cmd, 0, sizeof(cmd));
 
  avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
  pgm->cmd(pgm, cmd, res);
  usleep(p->chip_erase_delay);
  pgm->initialize(pgm, p);
 
  pgm->pgm_led(pgm, OFF);
 
  return 0;
}

References AVR_OP_CHIP_ERASE, avr_set_bits(), avrdude_message(), avrpart::chip_erase_delay, programmer_t::cmd, cmd, avrpart::desc, programmer_t::initialize, MSG_INFO, OFF, ON, avrpart::op, pgm, programmer_t::pgm_led, progname, programmer_t::type, and usleep().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_close()

static void stk500_close ( PROGRAMMER *  pgm )

static

{
  // MIB510 close
  if (strcmp(ldata(lfirst(pgm->id)), "mib510") == 0)
    (void)mib510_isp(pgm, 0);
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

References programmer_t::fd, programmer_t::id, filedescriptor::ifd, ldata(), lfirst(), mib510_isp(), pgm, serial_close, and void().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_cmd()

static int stk500_cmd ( PROGRAMMER *  pgm, const unsigned char *  cmd, unsigned char *  res  )

static

{
  unsigned char buf[32];
 
  buf[0] = Cmnd_STK_UNIVERSAL;
  buf[1] = cmd[0];
  buf[2] = cmd[1];
  buf[3] = cmd[2];
  buf[4] = cmd[3];
  buf[5] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 6);
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_cmd(): programmer is out of sync\n", progname);
    return -1;
  }
 
  res[0] = cmd[1];
  res[1] = cmd[2];
  res[2] = cmd[3];
  if (stk500_recv(pgm, &res[3], 1) < 0)
    return -1;
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] != Resp_STK_OK) {
    avrdude_message(MSG_INFO, "%s: stk500_cmd(): protocol error\n", progname);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), cmd, Cmnd_STK_UNIVERSAL, MSG_INFO, pgm, progname, Resp_STK_INSYNC, Resp_STK_OK, stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initpgm(), and stk500_loadaddr().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_disable()

static void stk500_disable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[16];
  int tries=0;
 
 retry:
  
  tries++;
 
  buf[0] = Cmnd_STK_LEAVE_PROGMODE;
  buf[1] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 2);
  if (stk500_recv(pgm, buf, 1) < 0)
    return;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "%s: stk500_disable(): can't get into sync\n",
              progname);
      return;
    }
    if (stk500_getsync(pgm) < 0)
      return;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_disable(): protocol error, expect=0x%02x, "
                    "resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return;
  if (buf[0] == Resp_STK_OK) {
    return;
  }
  else if (buf[0] == Resp_STK_NODEVICE) {
    avrdude_message(MSG_INFO, "%s: stk500_disable(): no device\n",
            progname);
    return;
  }
 
  avrdude_message(MSG_INFO, "%s: stk500_disable(): unknown response=0x%02x\n",
          progname, buf[0]);
 
  return;
}

References avrdude_message(), Cmnd_STK_LEAVE_PROGMODE, MSG_INFO, pgm, progname, Resp_STK_INSYNC, Resp_STK_NODEVICE, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_display()

static void stk500_display ( PROGRAMMER *  pgm, const char *  p  )

static

{
  unsigned maj, min, hdw, topcard;
 
  stk500_getparm(pgm, Parm_STK_HW_VER, &hdw);
  stk500_getparm(pgm, Parm_STK_SW_MAJOR, &maj);
  stk500_getparm(pgm, Parm_STK_SW_MINOR, &min);
  stk500_getparm(pgm, Param_STK500_TOPCARD_DETECT, &topcard);
 
  avrdude_message(MSG_INFO, "%sHardware Version: %d\n", p, hdw);
  avrdude_message(MSG_INFO, "%sFirmware Version: %d.%d\n", p, maj, min);
  if (topcard < 3) {
    const char *n = "Unknown";
 
    switch (topcard) {
      case 1:
  n = "STK502";
  break;
 
      case 2:
  n = "STK501";
  break;
    }
    avrdude_message(MSG_INFO, "%sTopcard         : %s\n", p, n);
  }
  stk500_print_parms1(pgm, p);
 
  return;
}

References avrdude_message(), MSG_INFO, Param_STK500_TOPCARD_DETECT, Parm_STK_HW_VER, Parm_STK_SW_MAJOR, Parm_STK_SW_MINOR, pgm, stk500_getparm(), and stk500_print_parms1().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_drain()

int stk500_drain	(	PROGRAMMER *	pgm,
		int	display
	)

{
  return serial_drain(&pgm->fd, display);
}

References programmer_t::fd, pgm, and serial_drain.

Referenced by arduino_open(), stk500_getsync(), and stk500_open().

Here is the caller graph for this function:

stk500_enable()

static void stk500_enable ( PROGRAMMER *  pgm )

static

{
  return;
}

Referenced by stk500_initpgm().

Here is the caller graph for this function:

stk500_getparm()

static int stk500_getparm ( PROGRAMMER *  pgm, unsigned  parm, unsigned *  value  )

static

{
  unsigned char buf[16];
  unsigned v;
  int tries = 0;
 
 retry:
  tries++;
  buf[0] = Cmnd_STK_GET_PARAMETER;
  buf[1] = parm;
  buf[2] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 3);
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "\n%s: stk500_getparm(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "\n%s: stk500_getparm(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -2;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  v = buf[0];
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_FAILED) {
    avrdude_message(MSG_INFO, "\n%s: stk500_getparm(): parameter 0x%02x failed\n",
                    progname, v);
    return -3;
  }
  else if (buf[0] != Resp_STK_OK) {
    avrdude_message(MSG_INFO, "\n%s: stk500_getparm(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -3;
  }
 
  *value = v;
 
  return 0;
}

References avrdude_message(), Cmnd_STK_GET_PARAMETER, MSG_INFO, pgm, progname, Resp_STK_FAILED, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_display(), stk500_initialize(), stk500_print_parms1(), stk500_set_varef(), and stk500_set_vtarget().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_getsync()

int stk500_getsync

(

PROGRAMMER *

pgm

)

{
  unsigned char buf[32], resp[32];
  int attempt;
 
  /*
   * get in sync */
  buf[0] = Cmnd_STK_GET_SYNC;
  buf[1] = Sync_CRC_EOP;
  
  /*
   * First send and drain a few times to get rid of line noise 
   */
   
  stk500_send(pgm, buf, 2);
  stk500_drain(pgm, 0);
  stk500_send(pgm, buf, 2);
  stk500_drain(pgm, 0);
 
  for (attempt = 0; attempt < MAX_SYNC_ATTEMPTS; attempt++) {
    stk500_send(pgm, buf, 2);
    stk500_recv(pgm, resp, 1);
    if (resp[0] == Resp_STK_INSYNC){
      break;
    }
    avrdude_message(MSG_INFO, "%s: stk500_getsync() attempt %d of %d: not in sync: resp=0x%02x\n",
                    progname, attempt + 1, MAX_SYNC_ATTEMPTS, resp[0]);
  }
  if (attempt == MAX_SYNC_ATTEMPTS) {
    stk500_drain(pgm, 0);
    return -1;
  }
 
  if (stk500_recv(pgm, resp, 1) < 0)
    return -1;
  if (resp[0] != Resp_STK_OK) {
    avrdude_message(MSG_INFO, "%s: stk500_getsync(): can't communicate with device: "
                    "resp=0x%02x\n",
                    progname, resp[0]);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), Cmnd_STK_GET_SYNC, MAX_SYNC_ATTEMPTS, MSG_INFO, pgm, progname, Resp_STK_INSYNC, Resp_STK_OK, stk500_drain(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by arduino_open(), mib510_isp(), stk500_disable(), stk500_getparm(), stk500_initialize(), stk500_loadaddr(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500_program_enable(), stk500_set_extended_parms(), and stk500_setparm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_initialize()

static int stk500_initialize ( PROGRAMMER *  pgm, AVRPART *  p  )

static

{
  unsigned char buf[32];
  AVRMEM * m;
  int tries;
  unsigned maj, min;
  int rc;
  int n_extparms;
 
  stk500_getparm(pgm, Parm_STK_SW_MAJOR, &maj);
  stk500_getparm(pgm, Parm_STK_SW_MINOR, &min);
 
  // MIB510 does not need extparams
  if (strcmp(ldata(lfirst(pgm->id)), "mib510") == 0)
    n_extparms = 0;
  else if ((maj > 1) || ((maj == 1) && (min > 10)))
    n_extparms = 4;
  else
    n_extparms = 3;
 
  tries = 0;
 
 retry:
  tries++;
 
  memset(buf, 0, sizeof(buf));
 
  /*
   * set device programming parameters
   */
  buf[0] = Cmnd_STK_SET_DEVICE;
 
  buf[1] = p->stk500_devcode;
  buf[2] = 0; /* device revision */
 
  if ((p->flags & AVRPART_SERIALOK) && (p->flags & AVRPART_PARALLELOK))
    buf[3] = 0; /* device supports parallel and serial programming */
  else
    buf[3] = 1; /* device supports parallel only */
 
  if (p->flags & AVRPART_PARALLELOK) {
    if (p->flags & AVRPART_PSEUDOPARALLEL) {
      buf[4] = 0; /* pseudo parallel interface */
      n_extparms = 0;
    }
    else {
      buf[4] = 1; /* full parallel interface */
    }
  }
 
#if 0
  avrdude_message(MSG_INFO, "%s: stk500_initialize(): n_extparms = %d\n",
          progname, n_extparms);
#endif
    
  buf[5] = 1; /* polling supported - XXX need this in config file */
  buf[6] = 1; /* programming is self-timed - XXX need in config file */
 
  m = avr_locate_mem(p, "lock");
  if (m)
    buf[7] = m->size;
  else
    buf[7] = 0;
 
  /*
   * number of fuse bytes
   */
  buf[8] = 0;
  m = avr_locate_mem(p, "fuse");
  if (m)
    buf[8] += m->size;
  m = avr_locate_mem(p, "lfuse");
  if (m)
    buf[8] += m->size;
  m = avr_locate_mem(p, "hfuse");
  if (m)
    buf[8] += m->size;
  m = avr_locate_mem(p, "efuse");
  if (m)
    buf[8] += m->size;
 
  m = avr_locate_mem(p, "flash");
  if (m) {
    buf[9] = m->readback[0];
    buf[10] = m->readback[1];
    if (m->paged) {
      buf[13] = (m->page_size >> 8) & 0x00ff;
      buf[14] = m->page_size & 0x00ff;
    }
    buf[17] = (m->size >> 24) & 0xff;
    buf[18] = (m->size >> 16) & 0xff;
    buf[19] = (m->size >> 8) & 0xff;
    buf[20] = m->size & 0xff;
  }
  else {
    buf[9]  = 0xff;
    buf[10] = 0xff;
    buf[13] = 0;
    buf[14] = 0;
    buf[17] = 0;
    buf[18] = 0;
    buf[19] = 0;
    buf[20] = 0;
  }
 
  m = avr_locate_mem(p, "eeprom");
  if (m) {
    buf[11] = m->readback[0];
    buf[12] = m->readback[1];
    buf[15] = (m->size >> 8) & 0x00ff;
    buf[16] = m->size & 0x00ff;
  }
  else {
    buf[11] = 0xff;
    buf[12] = 0xff;
    buf[15] = 0;
    buf[16] = 0;
  }
 
  buf[21] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 22);
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_initialize(): programmer not in sync, resp=0x%02x\n",
                    progname, buf[0]);
    if (tries > 33)
      return -1;
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_initialize(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -1;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] != Resp_STK_OK) {
    avrdude_message(MSG_INFO, "%s: stk500_initialize(): (b) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_OK, buf[0]);
    return -1;
  }
 
  if (n_extparms) {
    if ((p->pagel == 0) || (p->bs2 == 0)) {
      avrdude_message(MSG_NOTICE2, "%s: PAGEL and BS2 signals not defined in the configuration "
                          "file for part %s, using dummy values\n",
                          progname, p->desc);
      buf[2] = 0xD7;            /* they look somehow possible, */
      buf[3] = 0xA0;            /* don't they? ;) */
    }
    else {
      buf[2] = p->pagel;
      buf[3] = p->bs2;
    }
    buf[0] = n_extparms+1;
 
    /*
     * m is currently pointing to eeprom memory if the part has it
     */
    if (m)
      buf[1] = m->page_size;
    else
      buf[1] = 0;
 
 
    if (n_extparms == 4) {
      if (p->reset_disposition == RESET_DEDICATED)
        buf[4] = 0;
      else
        buf[4] = 1;
    }
 
    rc = stk500_set_extended_parms(pgm, n_extparms+1, buf);
    if (rc) {
      avrdude_message(MSG_INFO, "%s: stk500_initialize(): failed\n", progname);
      return -1;
    }
  }
 
  return pgm->program_enable(pgm, p);
}

References avr_locate_mem(), avrdude_message(), AVRPART_PARALLELOK, AVRPART_PSEUDOPARALLEL, AVRPART_SERIALOK, avrpart::bs2, Cmnd_STK_SET_DEVICE, avrpart::desc, avrpart::flags, programmer_t::id, ldata(), lfirst(), MSG_INFO, MSG_NOTICE2, avrmem::page_size, avrmem::paged, avrpart::pagel, Parm_STK_SW_MAJOR, Parm_STK_SW_MINOR, pgm, progname, programmer_t::program_enable, avrmem::readback, RESET_DEDICATED, avrpart::reset_disposition, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, avrmem::size, avrpart::stk500_devcode, stk500_getparm(), stk500_getsync(), stk500_recv(), stk500_send(), stk500_set_extended_parms(), and Sync_CRC_EOP.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_initpgm()

void stk500_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK500");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500_initialize;
  pgm->display        = stk500_display;
  pgm->enable         = stk500_enable;
  pgm->disable        = stk500_disable;
  pgm->program_enable = stk500_program_enable;
  pgm->chip_erase     = stk500_chip_erase;
  pgm->cmd            = stk500_cmd;
  pgm->open           = stk500_open;
  pgm->close          = stk500_close;
  pgm->read_byte      = avr_read_byte_default;
  pgm->write_byte     = avr_write_byte_default;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500_paged_write;
  pgm->paged_load     = stk500_paged_load;
  pgm->print_parms    = stk500_print_parms;
  pgm->set_vtarget    = stk500_set_vtarget;
  pgm->set_varef      = stk500_set_varef;
  pgm->set_fosc       = stk500_set_fosc;
  pgm->set_sck_period = stk500_set_sck_period;
  pgm->setup          = stk500_setup;
  pgm->teardown       = stk500_teardown;
  pgm->page_size      = 256;
}

References avr_read_byte_default(), avr_write_byte_default(), programmer_t::chip_erase, programmer_t::close, programmer_t::cmd, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::initialize, programmer_t::open, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_fosc, programmer_t::set_sck_period, programmer_t::set_varef, programmer_t::set_vtarget, programmer_t::setup, stk500_chip_erase(), stk500_close(), stk500_cmd(), stk500_disable(), stk500_display(), stk500_enable(), stk500_initialize(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500_print_parms(), stk500_program_enable(), stk500_set_fosc(), stk500_set_sck_period(), stk500_set_varef(), stk500_set_vtarget(), stk500_setup(), stk500_teardown(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Referenced by arduino_initpgm(), and stk500generic_open().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_loadaddr()

static int stk500_loadaddr ( PROGRAMMER *  pgm, AVRMEM *  mem, unsigned int  addr  )

static

{
  unsigned char buf[16];
  int tries;
  unsigned char ext_byte;
  OPCODE * lext;
 
  tries = 0;
 retry:
  tries++;
 
  /* To support flash > 64K words the correct Extended Address Byte is needed */
  lext = mem->op[AVR_OP_LOAD_EXT_ADDR];
  if (lext != NULL) {
    ext_byte = (addr >> 16) & 0xff;
    if (ext_byte != PDATA(pgm)->ext_addr_byte) {
      /* Either this is the first addr load, or a 64K word boundary is
       * crossed, so set the ext addr byte */
      avr_set_bits(lext, buf);
      avr_set_addr(lext, buf, addr);
      stk500_cmd(pgm, buf, buf);
      PDATA(pgm)->ext_addr_byte = ext_byte;
    }
  }
 
  buf[0] = Cmnd_STK_LOAD_ADDRESS;
  // Workaround for the infamous ';' bug in the Prusa3D usb to serial converter.
  // Send the binary data by nibbles to avoid transmitting the ';' character.
  buf[1] = addr & 0x0f;
  buf[2] = addr & 0xf0;
  buf[3] = (addr >> 8) & 0x0f;
  buf[4] = (addr >> 8) & 0xf0;
  buf[5] = Sync_CRC_EOP;
  stk500_send(pgm, buf, 6);
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "%s: stk500_loadaddr(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_loadaddr(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -1;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_OK) {
    return 0;
  }
 
  avrdude_message(MSG_INFO, "%s: loadaddr(): (b) protocol error, "
                  "expect=0x%02x, resp=0x%02x\n",
                  progname, Resp_STK_INSYNC, buf[0]);
 
  return -1;
}

References AVR_OP_LOAD_EXT_ADDR, avr_set_addr(), avr_set_bits(), avrdude_message(), Cmnd_STK_LOAD_ADDRESS, MSG_INFO, avrmem::op, PDATA, pgm, progname, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, stk500_cmd(), stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_paged_load(), and stk500_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_open()

static int stk500_open ( PROGRAMMER *  pgm, char *  port  )

static

{
  union pinfo pinfo;
  strcpy(pgm->port, port);
  pinfo.baud = pgm->baudrate? pgm->baudrate: 115200;
  if (serial_open(port, pinfo, &pgm->fd)==-1) {
    return -1;
  }
 
  /*
   * drain any extraneous input
   */
  stk500_drain(pgm, 0);
 
  // MIB510 init
  if (strcmp(ldata(lfirst(pgm->id)), "mib510") == 0 &&
      mib510_isp(pgm, 1) != 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  if (stk500_getsync(pgm) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References pinfo::baud, programmer_t::baudrate, programmer_t::fd, programmer_t::id, ldata(), lfirst(), mib510_isp(), pgm, programmer_t::port, serial_close, serial_open, stk500_drain(), and stk500_getsync().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_paged_load()

static int stk500_paged_load ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes  )

static

{
  unsigned char buf[16];
  int memtype;
  int a_div;
  int tries;
  unsigned int n;
  int block_size;
 
  if (strcmp(m->desc, "flash") == 0) {
    memtype = 'F';
  }
  else if (strcmp(m->desc, "eeprom") == 0) {
    memtype = 'E';
  }
  else {
    return -2;
  }
 
  if ((m->op[AVR_OP_LOADPAGE_LO]) || (m->op[AVR_OP_READ_LO]))
    a_div = 2;
  else
    a_div = 1;
 
  n = addr + n_bytes;
  for (; addr < n; addr += block_size) {
    // MIB510 uses fixed blocks size of 256 bytes
    if (strcmp(ldata(lfirst(pgm->id)), "mib510") == 0) {
      block_size = 256;
    } else {
      if (n - addr < page_size)
        block_size = n - addr;
      else
        block_size = page_size;
    }
 
    tries = 0;
  retry:
    tries++;
    stk500_loadaddr(pgm, m, addr/a_div);
    buf[0] = Cmnd_STK_READ_PAGE;
    // Workaround for the infamous ';' bug in the Prusa3D usb to serial converter.
    // Send the binary data by nibbles to avoid transmitting the ';' character.
    buf[1] = (block_size >> 8) & 0xf0;
    buf[2] = (block_size >> 8) & 0x0f;
    buf[3] = block_size & 0xf0;
    buf[4] = block_size & 0x0f;
    buf[5] = memtype;
    buf[6] = Sync_CRC_EOP;
    stk500_send(pgm, buf, 7);
 
    if (stk500_recv(pgm, buf, 1) < 0)
      return -1;
    if (buf[0] == Resp_STK_NOSYNC) {
      if (tries > 33) {
        avrdude_message(MSG_INFO, "\n%s: stk500_paged_load(): can't get into sync\n",
                progname);
        return -3;
      }
      if (stk500_getsync(pgm) < 0)
  return -1;
      goto retry;
    }
    else if (buf[0] != Resp_STK_INSYNC) {
      avrdude_message(MSG_INFO, "\n%s: stk500_paged_load(): (a) protocol error, "
                      "expect=0x%02x, resp=0x%02x\n",
                      progname, Resp_STK_INSYNC, buf[0]);
      return -4;
    }
 
    if (stk500_recv(pgm, &m->buf[addr], block_size) < 0)
      return -1;
 
    if (stk500_recv(pgm, buf, 1) < 0)
      return -1;
 
    if(strcmp(ldata(lfirst(pgm->id)), "mib510") == 0) {
      if (buf[0] != Resp_STK_INSYNC) {
      avrdude_message(MSG_INFO, "\n%s: stk500_paged_load(): (a) protocol error, "
                      "expect=0x%02x, resp=0x%02x\n",
                      progname, Resp_STK_INSYNC, buf[0]);
      return -5;
    }
  }
    else {
      if (buf[0] != Resp_STK_OK) {
        avrdude_message(MSG_INFO, "\n%s: stk500_paged_load(): (a) protocol error, "
                        "expect=0x%02x, resp=0x%02x\n",
                        progname, Resp_STK_OK, buf[0]);
        return -5;
      }
    }
  }
 
  return n_bytes;
}

References AVR_OP_LOADPAGE_LO, AVR_OP_READ_LO, avrdude_message(), avrmem::buf, Cmnd_STK_READ_PAGE, avrmem::desc, programmer_t::id, ldata(), lfirst(), MSG_INFO, avrmem::op, pgm, progname, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_loadaddr(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_paged_write()

static int stk500_paged_write ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes  )

static

{
  unsigned char *buf = alloca(page_size + 16);
  int memtype;
  int a_div;
  int block_size;
  int tries;
  unsigned int n;
  unsigned int i, j;
  unsigned int prusa3d_semicolon_workaround_round = 0;
  bool has_semicolon = false;
 
  if (strcmp(m->desc, "flash") == 0) {
    memtype = 'F';
  }
  else if (strcmp(m->desc, "eeprom") == 0) {
    memtype = 'E';
  }
  else {
    return -2;
  }
 
  if ((m->op[AVR_OP_LOADPAGE_LO]) || (m->op[AVR_OP_READ_LO]))
    a_div = 2;
  else
    a_div = 1;
 
  n = addr + n_bytes;
#if 0
  avrdude_message(MSG_INFO, "n_bytes   = %d\n"
                  "n         = %u\n"
                  "a_div     = %d\n"
                  "page_size = %d\n",
                  n_bytes, n, a_div, page_size);
#endif     
 
  for (; addr < n; addr += block_size) {
    // MIB510 uses fixed blocks size of 256 bytes
    if (strcmp(ldata(lfirst(pgm->id)), "mib510") == 0) {
      block_size = 256;
    } else {
      if (n - addr < page_size)
        block_size = n - addr;
      else
        block_size = page_size;
    }
    tries = 0;
  retry:
    tries++;
    stk500_loadaddr(pgm, m, addr/a_div);
 
    for (i = 0; i < n_bytes; ++ i)
      if (m->buf[addr + i] == ';') {
        has_semicolon = true;
        break;
      }
 
    for (prusa3d_semicolon_workaround_round = 0; prusa3d_semicolon_workaround_round < (has_semicolon ? 2u : 1u); prusa3d_semicolon_workaround_round++) {
      /* build command block and avoid multiple send commands as it leads to a crash
          of the silabs usb serial driver on mac os x */
      i = 0;
      buf[i++] = Cmnd_STK_PROG_PAGE;
      // Workaround for the infamous ';' bug in the Prusa3D usb to serial converter.
      // Send the binary data by nibbles to avoid transmitting the ';' character.
      buf[i++] = (block_size >> 8) & 0xf0;
      buf[i++] = (block_size >> 8) & 0x0f;
      buf[i++] = block_size & 0xf0;
      buf[i++] = block_size & 0x0f;
      buf[i++] = memtype;
      if (has_semicolon) {
        for (j = 0; j < (unsigned)block_size; ++i, ++ j) {
          buf[i] = m->buf[addr + j];
          if (buf[i] == ';')
            buf[i] |= (prusa3d_semicolon_workaround_round ? 0xf0 : 0x0f);
        }
      } else {
        memcpy(&buf[i], &m->buf[addr], block_size);
        i += block_size;
      }
      buf[i++] = Sync_CRC_EOP;
      stk500_send( pgm, buf, i);
 
      if (stk500_recv(pgm, buf, 1) < 0)
        return -1;
      if (buf[0] == Resp_STK_NOSYNC) {
        if (tries > 33) {
          avrdude_message(MSG_INFO, "\n%s: stk500_paged_write(): can't get into sync\n",
                  progname);
          return -3;
        }
        if (stk500_getsync(pgm) < 0)
          return -1;
        goto retry;
      }
      else if (buf[0] != Resp_STK_INSYNC) {
        avrdude_message(MSG_INFO, "\n%s: stk500_paged_write(): (a) protocol error, "
                        "expect=0x%02x, resp=0x%02x\n",
                        progname, Resp_STK_INSYNC, buf[0]);
        return -4;
      }
      
      if (stk500_recv(pgm, buf, 1) < 0)
        return -1;
      if (buf[0] != Resp_STK_OK) {
        avrdude_message(MSG_INFO, "\n%s: stk500_paged_write(): (a) protocol error, "
                        "expect=0x%02x, resp=0x%02x\n",
                        progname, Resp_STK_INSYNC, buf[0]);
        return -5;
      }
    }
  }
 
  return n_bytes;
}

References AVR_OP_LOADPAGE_LO, AVR_OP_READ_LO, avrdude_message(), avrmem::buf, Cmnd_STK_PROG_PAGE, avrmem::desc, programmer_t::id, ldata(), lfirst(), MSG_INFO, avrmem::op, pgm, progname, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_loadaddr(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_print_parms()

static void stk500_print_parms ( PROGRAMMER *  pgm )

static

{
  stk500_print_parms1(pgm, "");
}

References pgm, and stk500_print_parms1().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_print_parms1()

static void stk500_print_parms1 ( PROGRAMMER *  pgm, const char *  p  )

static

{
  unsigned vtarget, vadjust, osc_pscale, osc_cmatch, sck_duration;
 
  stk500_getparm(pgm, Parm_STK_VTARGET, &vtarget);
  stk500_getparm(pgm, Parm_STK_VADJUST, &vadjust);
  stk500_getparm(pgm, Parm_STK_OSC_PSCALE, &osc_pscale);
  stk500_getparm(pgm, Parm_STK_OSC_CMATCH, &osc_cmatch);
  stk500_getparm(pgm, Parm_STK_SCK_DURATION, &sck_duration);
 
  avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p, vtarget / 10.0);
  avrdude_message(MSG_INFO, "%sVaref           : %.1f V\n", p, vadjust / 10.0);
  avrdude_message(MSG_INFO, "%sOscillator      : ", p);
  if (osc_pscale == 0)
    avrdude_message(MSG_INFO, "Off\n");
  else {
    int prescale = 1;
    double f = STK500_XTAL / 2;
    const char *unit;
 
    switch (osc_pscale) {
      case 2: prescale = 8; break;
      case 3: prescale = 32; break;
      case 4: prescale = 64; break;
      case 5: prescale = 128; break;
      case 6: prescale = 256; break;
      case 7: prescale = 1024; break;
    }
    f /= prescale;
    f /= (osc_cmatch + 1);
    if (f > 1e6) {
      f /= 1e6;
      unit = "MHz";
    } else if (f > 1e3) {
      f /= 1000;
      unit = "kHz";
    } else
      unit = "Hz";
    avrdude_message(MSG_INFO, "%.3f %s\n", f, unit);
  }
  avrdude_message(MSG_INFO, "%sSCK period      : %.1f us\n", p,
    sck_duration * 8.0e6 / STK500_XTAL + 0.05);
 
  return;
}

References avrdude_message(), MSG_INFO, Parm_STK_OSC_CMATCH, Parm_STK_OSC_PSCALE, Parm_STK_SCK_DURATION, Parm_STK_VADJUST, Parm_STK_VTARGET, pgm, stk500_getparm(), and STK500_XTAL.

Referenced by stk500_display(), and stk500_print_parms().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_program_enable()

static int stk500_program_enable ( PROGRAMMER *  pgm, AVRPART *  p  )

static

{
  unsigned char buf[16];
  int tries=0;
 
 retry:
  
  tries++;
 
  buf[0] = Cmnd_STK_ENTER_PROGMODE;
  buf[1] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 2);
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "%s: stk500_program_enable(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_program_enable(): protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -1;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_OK) {
    return 0;
  }
  else if (buf[0] == Resp_STK_NODEVICE) {
    avrdude_message(MSG_INFO, "%s: stk500_program_enable(): no device\n",
            progname);
    return -1;
  }
 
  if(buf[0] == Resp_STK_FAILED)
  {
      avrdude_message(MSG_INFO, "%s: stk500_program_enable(): failed to enter programming mode\n",
                      progname);
    return -1;
  }
 
 
  avrdude_message(MSG_INFO, "%s: stk500_program_enable(): unknown response=0x%02x\n",
          progname, buf[0]);
 
  return -1;
}

References avrdude_message(), Cmnd_STK_ENTER_PROGMODE, MSG_INFO, pgm, progname, Resp_STK_FAILED, Resp_STK_INSYNC, Resp_STK_NODEVICE, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_recv()

static int stk500_recv ( PROGRAMMER *  pgm, unsigned char *  buf, size_t  len  )

static

{
  int rv;
 
  rv = serial_recv(&pgm->fd, buf, len);
  if (rv < 0) {
    avrdude_message(MSG_INFO, "%s: stk500_recv(): programmer is not responding\n",
                    progname);
    return -1;
  }
  return 0;
}

References avrdude_message(), programmer_t::fd, MSG_INFO, pgm, progname, and serial_recv.

Referenced by mib510_isp(), stk500_cmd(), stk500_disable(), stk500_getparm(), stk500_getsync(), stk500_initialize(), stk500_loadaddr(), stk500_paged_load(), stk500_paged_write(), stk500_program_enable(), stk500_set_extended_parms(), and stk500_setparm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_send()

static int stk500_send ( PROGRAMMER *  pgm, unsigned char *  buf, size_t  len  )

static

{
  return serial_send(&pgm->fd, buf, len);
}

References programmer_t::fd, pgm, and serial_send.

Referenced by mib510_isp(), stk500_cmd(), stk500_disable(), stk500_getparm(), stk500_getsync(), stk500_initialize(), stk500_loadaddr(), stk500_paged_load(), stk500_paged_write(), stk500_program_enable(), stk500_set_extended_parms(), and stk500_setparm().

Here is the caller graph for this function:

stk500_set_extended_parms()

static int stk500_set_extended_parms ( PROGRAMMER *  pgm, int  n, unsigned char *  cmd  )

static

{
  unsigned char buf[16];
  int tries=0;
  int i;
 
 retry:
  
  tries++;
 
  buf[0] = Cmnd_STK_SET_DEVICE_EXT;
  for (i=0; i<n; i++) {
    buf[1+i] = cmd[i];
  }
  i++;
  buf[i] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, i+1);
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "%s: stk500_set_extended_parms(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "%s: stk500_set_extended_parms(): protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -1;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_OK) {
    return 0;
  }
  else if (buf[0] == Resp_STK_NODEVICE) {
    avrdude_message(MSG_INFO, "%s: stk500_set_extended_parms(): no device\n",
            progname);
    return -1;
  }
 
  if(buf[0] == Resp_STK_FAILED)
  {
      avrdude_message(MSG_INFO, "%s: stk500_set_extended_parms(): failed to set extended "
                      "device programming parameters\n",
                      progname);
    return -1;
  }
 
 
  avrdude_message(MSG_INFO, "%s: stk500_set_extended_parms(): unknown response=0x%02x\n",
          progname, buf[0]);
 
  return -1;
}

References avrdude_message(), cmd, Cmnd_STK_SET_DEVICE_EXT, MSG_INFO, pgm, progname, Resp_STK_FAILED, Resp_STK_INSYNC, Resp_STK_NODEVICE, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_set_fosc()

static int stk500_set_fosc ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned prescale, cmatch, fosc;
  static unsigned ps[] = {
    1, 8, 32, 64, 128, 256, 1024
  };
  int idx, rc;
 
  prescale = cmatch = 0;
  if (v > 0.0) {
    if (v > STK500_XTAL / 2) {
      const char *unit;
      if (v > 1e6) {
        v /= 1e6;
        unit = "MHz";
      } else if (v > 1e3) {
        v /= 1e3;
        unit = "kHz";
      } else
        unit = "Hz";
      avrdude_message(MSG_INFO, "%s: stk500_set_fosc(): f = %.3f %s too high, using %.3f MHz\n",
                      progname, v, unit, STK500_XTAL / 2e6);
      fosc = STK500_XTAL / 2;
    } else
      fosc = (unsigned)v;
    
    for (idx = 0; idx < sizeof(ps) / sizeof(ps[0]); idx++) {
      if (fosc >= STK500_XTAL / (256 * ps[idx] * 2)) {
        /* this prescaler value can handle our frequency */
        prescale = idx + 1;
        cmatch = (unsigned)(STK500_XTAL / (2 * fosc * ps[idx])) - 1;
        break;
      }
    }
    if (idx == sizeof(ps) / sizeof(ps[0])) {
      avrdude_message(MSG_INFO, "%s: stk500_set_fosc(): f = %u Hz too low, %u Hz min\n",
          progname, fosc, STK500_XTAL / (256 * 1024 * 2));
      return -1;
    }
  }
  
  if ((rc = stk500_setparm(pgm, Parm_STK_OSC_PSCALE, prescale)) != 0
      || (rc = stk500_setparm(pgm, Parm_STK_OSC_CMATCH, cmatch)) != 0)
    return rc;
  
  return 0;
}

References avrdude_message(), MSG_INFO, Parm_STK_OSC_CMATCH, Parm_STK_OSC_PSCALE, pgm, progname, stk500_setparm(), and STK500_XTAL.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_set_sck_period()

static int stk500_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  int dur;
  double min, max;
 
  min = 8.0 / STK500_XTAL;
  max = 255 * min;
  dur = (int)(v / min + 0.5);
 
  if (v < min) {
      dur = 1;
      avrdude_message(MSG_INFO, "%s: stk500_set_sck_period(): p = %.1f us too small, using %.1f us\n",
                      progname, v / 1e-6, dur * min / 1e-6);
  } else if (v > max) {
      dur = 255;
      avrdude_message(MSG_INFO, "%s: stk500_set_sck_period(): p = %.1f us too large, using %.1f us\n",
                      progname, v / 1e-6, dur * min / 1e-6);
  }
 
  return stk500_setparm(pgm, Parm_STK_SCK_DURATION, dur);
}

References avrdude_message(), MSG_INFO, Parm_STK_SCK_DURATION, pgm, progname, stk500_setparm(), and STK500_XTAL.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_set_varef()

static int stk500_set_varef ( PROGRAMMER *  pgm, unsigned int  chan, double  v  )

static

{
  unsigned uaref, utarg;
 
  uaref = (unsigned)((v + 0.049) * 10);
 
  if (stk500_getparm(pgm, Parm_STK_VTARGET, &utarg) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500_set_varef(): cannot obtain V[target]\n",
                    progname);
    return -1;
  }
 
  if (uaref > utarg) {
    avrdude_message(MSG_INFO, "%s: stk500_set_varef(): V[aref] must not be greater than "
                    "V[target] = %.1f\n",
                    progname, utarg / 10.0);
    return -1;
  }
  return stk500_setparm(pgm, Parm_STK_VADJUST, uaref);
}

References avrdude_message(), MSG_INFO, Parm_STK_VADJUST, Parm_STK_VTARGET, pgm, progname, stk500_getparm(), and stk500_setparm().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_set_vtarget()

static int stk500_set_vtarget ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned uaref, utarg;
 
  utarg = (unsigned)((v + 0.049) * 10);
 
  if (stk500_getparm(pgm, Parm_STK_VADJUST, &uaref) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500_set_vtarget(): cannot obtain V[aref]\n",
                    progname);
    return -1;
  }
 
  if (uaref > utarg) {
    avrdude_message(MSG_INFO, "%s: stk500_set_vtarget(): reducing V[aref] from %.1f to %.1f\n",
                    progname, uaref / 10.0, v);
    if (stk500_setparm(pgm, Parm_STK_VADJUST, utarg)
  != 0)
      return -1;
  }
  return stk500_setparm(pgm, Parm_STK_VTARGET, utarg);
}

References avrdude_message(), MSG_INFO, Parm_STK_VADJUST, Parm_STK_VTARGET, pgm, progname, stk500_getparm(), and stk500_setparm().

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_setparm()

static int stk500_setparm ( PROGRAMMER *  pgm, unsigned  parm, unsigned  value  )

static

{
  unsigned char buf[16];
  int tries = 0;
 
 retry:
  tries++;
  buf[0] = Cmnd_STK_SET_PARAMETER;
  buf[1] = parm;
  buf[2] = value;
  buf[3] = Sync_CRC_EOP;
 
  stk500_send(pgm, buf, 4);
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_NOSYNC) {
    if (tries > 33) {
      avrdude_message(MSG_INFO, "\n%s: stk500_setparm(): can't get into sync\n",
              progname);
      return -1;
    }
    if (stk500_getsync(pgm) < 0)
      return -1;
    goto retry;
  }
  else if (buf[0] != Resp_STK_INSYNC) {
    avrdude_message(MSG_INFO, "\n%s: stk500_setparm(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -2;
  }
 
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_OK)
    return 0;
 
  parm = buf[0];  /* if not STK_OK, we've been echoed parm here */
  if (stk500_recv(pgm, buf, 1) < 0)
    return -1;
  if (buf[0] == Resp_STK_FAILED) {
    avrdude_message(MSG_INFO, "\n%s: stk500_setparm(): parameter 0x%02x failed\n",
                    progname, parm);
    return -3;
  }
  else {
    avrdude_message(MSG_INFO, "\n%s: stk500_setparm(): (a) protocol error, "
                    "expect=0x%02x, resp=0x%02x\n",
                    progname, Resp_STK_INSYNC, buf[0]);
    return -3;
  }
}

References avrdude_message(), Cmnd_STK_SET_PARAMETER, MSG_INFO, pgm, progname, Resp_STK_FAILED, Resp_STK_INSYNC, Resp_STK_NOSYNC, Resp_STK_OK, stk500_getsync(), stk500_recv(), stk500_send(), and Sync_CRC_EOP.

Referenced by stk500_set_fosc(), stk500_set_sck_period(), stk500_set_varef(), and stk500_set_vtarget().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_setup()

static void stk500_setup ( PROGRAMMER *  pgm )

static

{
  if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
    avrdude_message(MSG_INFO, "%s: stk500_setup(): Out of memory allocating private data\n",
                    progname);
    return;
  }
  memset(pgm->cookie, 0, sizeof(struct pdata));
  PDATA(pgm)->ext_addr_byte = 0xff; /* Ensures it is programmed before
             * first memory address */
}

References avrdude_message(), programmer_t::cookie, malloc(), MSG_INFO, PDATA, pgm, and progname.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500_teardown()

static void stk500_teardown ( PROGRAMMER *  pgm )

static

{
  free(pgm->cookie);
}

References programmer_t::cookie, free(), and pgm.

Referenced by stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

stk500_desc

const char stk500_desc[] = "Atmel STK500 Version 1.x firmware"