stk500v2.c File Reference

#include "ac_cfg.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "stk500_private.h"
#include "stk500v2.h"
#include "stk500v2_private.h"
#include "usbdevs.h"
#include "jtagmkII.h"
#include "jtagmkII_private.h"
#include "jtag3.h"
#include "jtag3_private.h"

Include dependency graph for stk500v2.c:

Go to the source code of this file.

Classes
struct	carddata
struct	jtagispentry

Macros
#define	JTAGMKII_PRIVATE_EXPORTED
#define	JTAG3_PRIVATE_EXPORTED
#define	STK500V2_XTAL   7372800U
#define	SERIAL_TIMEOUT   2
#define	RETRIES   0
#define	DEBUG(...)
#define	DEBUGRECV(...)
#define	PDATA(pgm)   ((struct pdata *)(pgm->cookie))
#define	SZ_READ_FLASH_EE   USHRT_MAX
#define	SZ_SPI_MULTI   (USHRT_MAX - 1)

Enumerations
enum	hvmode { PPMODE , HVSPMODE }

Functions
static int	stk500v2_getparm (PROGRAMMER *pgm, unsigned char parm, unsigned char *value)
static int	stk500v2_setparm (PROGRAMMER *pgm, unsigned char parm, unsigned char value)
static int	stk500v2_getparm2 (PROGRAMMER *pgm, unsigned char parm, unsigned int *value)
static int	stk500v2_setparm2 (PROGRAMMER *pgm, unsigned char parm, unsigned int value)
static int	stk500v2_setparm_real (PROGRAMMER *pgm, unsigned char parm, unsigned char value)
static void	stk500v2_print_parms1 (PROGRAMMER *pgm, const char *p)
static int	stk500v2_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500v2_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static unsigned int	stk500v2_mode_for_pagesize (unsigned int pagesize)
static double	stk500v2_sck_to_us (PROGRAMMER *pgm, unsigned char dur)
static int	stk500v2_set_sck_period_mk2 (PROGRAMMER *pgm, double v)
static int	stk600_set_sck_period (PROGRAMMER *pgm, double v)
static void	stk600_setup_xprog (PROGRAMMER *pgm)
static void	stk600_setup_isp (PROGRAMMER *pgm)
static int	stk600_xprog_program_enable (PROGRAMMER *pgm, AVRPART *p)
void	stk500v2_setup (PROGRAMMER *pgm)
static void	stk500v2_jtagmkII_setup (PROGRAMMER *pgm)
static void	stk500v2_jtag3_setup (PROGRAMMER *pgm)
void	stk500v2_teardown (PROGRAMMER *pgm)
static void	stk500v2_jtagmkII_teardown (PROGRAMMER *pgm)
static void	stk500v2_jtag3_teardown (PROGRAMMER *pgm)
static int	stk500v2_send_mk2 (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	stk500v2_jtagmkII_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	stk500v2_jtag3_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	stk500v2_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
int	stk500v2_drain (PROGRAMMER *pgm, int display)
static int	stk500v2_recv_mk2 (PROGRAMMER *pgm, unsigned char *msg, size_t maxsize)
static int	stk500v2_jtagmkII_recv (PROGRAMMER *pgm, unsigned char *msg, size_t maxsize)
static int	stk500v2_jtag3_recv (PROGRAMMER *pgm, unsigned char *msg, size_t maxsize)
static int	stk500v2_recv (PROGRAMMER *pgm, unsigned char *msg, size_t maxsize)
int	stk500v2_getsync (PROGRAMMER *pgm)
static int	stk500v2_command (PROGRAMMER *pgm, unsigned char *buf, size_t len, size_t maxlen)
static int	stk500v2_cmd (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res)
static int	stk500v2_jtag3_cmd (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res)
static int	stk500v2_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	stk500hv_chip_erase (PROGRAMMER *pgm, AVRPART *p, enum hvmode mode)
static int	stk500pp_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	stk500hvsp_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static void	stk500v2_translate_conn_status (unsigned char status, char *msg)
static int	stk500v2_program_enable (PROGRAMMER *pgm, AVRPART *p)
static int	stk500pp_program_enable (PROGRAMMER *pgm, AVRPART *p)
static int	stk500hvsp_program_enable (PROGRAMMER *pgm, AVRPART *p)
static int	stk500v2_initialize (PROGRAMMER *pgm, AVRPART *p)
static int	stk500v2_jtag3_initialize (PROGRAMMER *pgm, AVRPART *p)
static int	stk500hv_initialize (PROGRAMMER *pgm, AVRPART *p, enum hvmode mode)
static int	stk500pp_initialize (PROGRAMMER *pgm, AVRPART *p)
static int	stk500hvsp_initialize (PROGRAMMER *pgm, AVRPART *p)
static void	stk500v2_jtag3_disable (PROGRAMMER *pgm)
static void	stk500v2_disable (PROGRAMMER *pgm)
static void	stk500hv_disable (PROGRAMMER *pgm, enum hvmode mode)
static void	stk500pp_disable (PROGRAMMER *pgm)
static void	stk500hvsp_disable (PROGRAMMER *pgm)
static void	stk500v2_enable (PROGRAMMER *pgm)
static int	stk500v2_open (PROGRAMMER *pgm, char *port)
static int	stk600_open (PROGRAMMER *pgm, char *port)
static void	stk500v2_close (PROGRAMMER *pgm)
static int	stk500v2_loadaddr (PROGRAMMER *pgm, unsigned int addr)
static int	stk500hv_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value, enum hvmode mode)
static int	stk500pp_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	stk500hvsp_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	stk500isp_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	stk500hv_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data, enum hvmode mode)
static int	stk500pp_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	stk500hvsp_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	stk500isp_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	stk500hv_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes, enum hvmode mode)
static int	stk500pp_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500hvsp_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500hv_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes, enum hvmode mode)
static int	stk500pp_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500hvsp_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk500v2_page_erase (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int addr)
static int	stk500v2_set_vtarget (PROGRAMMER *pgm, double v)
static int	stk500v2_set_varef (PROGRAMMER *pgm, unsigned int chan, double v)
static int	stk500v2_set_fosc (PROGRAMMER *pgm, double v)
static int	stk500v2_set_sck_period (PROGRAMMER *pgm, double v)
static int	stk600_set_vtarget (PROGRAMMER *pgm, double v)
static int	stk600_set_varef (PROGRAMMER *pgm, unsigned int chan, double v)
static int	stk600_set_fosc (PROGRAMMER *pgm, double v)
static int	stk500v2_jtag3_set_sck_period (PROGRAMMER *pgm, double v)
static const char *	stk600_get_cardname (const struct carddata *table, size_t nele, int id)
static void	stk500v2_display (PROGRAMMER *pgm, const char *p)
static double	f_to_kHz_MHz (double f, const char **unit)
static void	stk500v2_print_parms (PROGRAMMER *pgm)
static int	stk500v2_perform_osccal (PROGRAMMER *pgm)
static int	stk500v2_jtagmkII_open (PROGRAMMER *pgm, char *port)
static void	stk500v2_jtagmkII_close (PROGRAMMER *pgm)
static void	stk500v2_jtag3_close (PROGRAMMER *pgm)
static int	stk500v2_dragon_isp_open (PROGRAMMER *pgm, char *port)
static int	stk500v2_dragon_hv_open (PROGRAMMER *pgm, char *port)
static int	stk500v2_jtag3_open (PROGRAMMER *pgm, char *port)
static int	stk600_xprog_command (PROGRAMMER *pgm, unsigned char *b, unsigned int cmdsize, unsigned int responsesize)
static unsigned char	stk600_xprog_memtype (PROGRAMMER *pgm, unsigned long addr)
static void	stk600_xprog_disable (PROGRAMMER *pgm)
static int	stk600_xprog_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	stk600_xprog_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	stk600_xprog_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk600_xprog_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	stk600_xprog_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	stk600_xprog_page_erase (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int addr)
void	stk500v2_initpgm (PROGRAMMER *pgm)
void	stk500pp_initpgm (PROGRAMMER *pgm)
void	stk500hvsp_initpgm (PROGRAMMER *pgm)
void	stk500v2_jtagmkII_initpgm (PROGRAMMER *pgm)
void	stk500v2_dragon_isp_initpgm (PROGRAMMER *pgm)
void	stk500v2_dragon_pp_initpgm (PROGRAMMER *pgm)
void	stk500v2_dragon_hvsp_initpgm (PROGRAMMER *pgm)
void	stk600_initpgm (PROGRAMMER *pgm)
void	stk600pp_initpgm (PROGRAMMER *pgm)
void	stk600hvsp_initpgm (PROGRAMMER *pgm)
void	stk500v2_jtag3_initpgm (PROGRAMMER *pgm)
void	stk500v2_set_upload_size (PROGRAMMER *pgm, int size)

Variables
static const char *	pgmname []
static const struct carddata	routing_cards []
static const struct carddata	socket_cards []
struct {
unsigned int	state
const char *	description
}	connection_status []
static double	avrispmkIIfreqs []
const char	stk500v2_desc [] = "Atmel STK500 Version 2.x firmware"
const char	stk500pp_desc [] = "Atmel STK500 V2 in parallel programming mode"
const char	stk500hvsp_desc [] = "Atmel STK500 V2 in high-voltage serial programming mode"
const char	stk500v2_jtagmkII_desc [] = "Atmel JTAG ICE mkII in ISP mode"
const char	stk500v2_dragon_isp_desc [] = "Atmel AVR Dragon in ISP mode"
const char	stk500v2_dragon_pp_desc [] = "Atmel AVR Dragon in PP mode"
const char	stk500v2_dragon_hvsp_desc [] = "Atmel AVR Dragon in HVSP mode"
const char	stk600_desc [] = "Atmel STK600"
const char	stk600pp_desc [] = "Atmel STK600 in parallel programming mode"
const char	stk600hvsp_desc [] = "Atmel STK600 in high-voltage serial programming mode"
const char	stk500v2_jtag3_desc [] = "Atmel JTAGICE3 in ISP mode"

---

Class Documentation

carddata

struct carddata

Class Members
int	id
const char *	name

jtagispentry

struct jtagispentry

Class Members
unsigned char	cmd
unsigned short	size

Macro Definition Documentation

DEBUG

#define DEBUG

(

...

)

DEBUGRECV

#define DEBUGRECV

(

...

)

JTAG3_PRIVATE_EXPORTED

#define JTAG3_PRIVATE_EXPORTED

JTAGMKII_PRIVATE_EXPORTED

#define JTAGMKII_PRIVATE_EXPORTED

PDATA

#define PDATA

(

pgm

)

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

RETRIES

#define RETRIES   0

SERIAL_TIMEOUT

#define SERIAL_TIMEOUT   2

STK500V2_XTAL

#define STK500V2_XTAL   7372800U

SZ_READ_FLASH_EE

#define SZ_READ_FLASH_EE   USHRT_MAX

SZ_SPI_MULTI

#define SZ_SPI_MULTI   (USHRT_MAX - 1)

Enumeration Type Documentation

hvmode

enum hvmode

Enumerator
PPMODE
HVSPMODE

{
  PPMODE, HVSPMODE
};

Function Documentation

f_to_kHz_MHz()

static double f_to_kHz_MHz ( double  f, const char **  unit  )

static

{
  if (f > 1e6) {
    f /= 1e6;
    *unit = "MHz";
  } else if (f > 1e3) {
    f /= 1000;
    *unit = "kHz";
  } else
    *unit = "Hz";
 
  return f;
}

Referenced by stk500v2_print_parms1().

Here is the caller graph for this function:

stk500hv_chip_erase()

static int stk500hv_chip_erase ( PROGRAMMER *  pgm, AVRPART *  p, enum hvmode  mode  )

static

{
  int result;
  unsigned char buf[3];
 
  pgm->pgm_led(pgm, ON);
 
  if (mode == PPMODE) {
    buf[0] = CMD_CHIP_ERASE_PP;
    buf[1] = p->chiperasepulsewidth;
    buf[2] = p->chiperasepolltimeout;
  } else {
    buf[0] = CMD_CHIP_ERASE_HVSP;
    buf[1] = p->chiperasepolltimeout;
    buf[2] = p->chiperasetime;
  }
  result = stk500v2_command(pgm, buf, 3, sizeof(buf));
  usleep(p->chip_erase_delay);
  pgm->initialize(pgm, p);
 
  pgm->pgm_led(pgm, OFF);
 
  return result >= 0? 0: -1;
}

References avrpart::chip_erase_delay, avrpart::chiperasepolltimeout, avrpart::chiperasepulsewidth, avrpart::chiperasetime, CMD_CHIP_ERASE_HVSP, CMD_CHIP_ERASE_PP, programmer_t::initialize, OFF, ON, pgm, programmer_t::pgm_led, PPMODE, stk500v2_command(), and usleep().

Referenced by stk500hvsp_chip_erase(), and stk500pp_chip_erase().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_disable()

static void stk500hv_disable ( PROGRAMMER *  pgm, enum hvmode  mode  )

static

{
  unsigned char buf[16];
  int result;
 
  free(PDATA(pgm)->flash_pagecache);
  PDATA(pgm)->flash_pagecache = NULL;
  free(PDATA(pgm)->eeprom_pagecache);
  PDATA(pgm)->eeprom_pagecache = NULL;
 
  buf[0] = mode == PPMODE? CMD_LEAVE_PROGMODE_PP:
  (PDATA(pgm)->pgmtype == PGMTYPE_STK600?
   CMD_LEAVE_PROGMODE_HVSP_STK600:
   CMD_LEAVE_PROGMODE_HVSP);
  buf[1] = 15;  // p->hvleavestabdelay;
  buf[2] = 15;  // p->resetdelay;
 
  result = stk500v2_command(pgm, buf, 3, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500hv_disable(): "
                    "failed to leave programming mode\n",
                    progname);
  }
 
  return;
}

References avrdude_message(), CMD_LEAVE_PROGMODE_HVSP, CMD_LEAVE_PROGMODE_HVSP_STK600, CMD_LEAVE_PROGMODE_PP, free(), MSG_INFO, PDATA, pgm, PPMODE, progname, and stk500v2_command().

Referenced by stk500hvsp_disable(), and stk500pp_disable().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_initialize()

static int stk500hv_initialize ( PROGRAMMER *  pgm, AVRPART *  p, enum hvmode  mode  )

static

{
  unsigned char buf[CTL_STACK_SIZE + 1];
  int result;
  LNODEID ln;
  AVRMEM * m;
 
  if (p->ctl_stack_type != (mode == PPMODE? CTL_STACK_PP: CTL_STACK_HVSP)) {
    avrdude_message(MSG_INFO, "%s: stk500hv_initialize(): "
                    "%s programming control stack not defined for part \"%s\"\n",
                    progname,
                    (mode == PPMODE? "parallel": "high-voltage serial"),
                    p->desc);
    return -1;
  }
 
  buf[0] = CMD_SET_CONTROL_STACK;
  memcpy(buf + 1, p->controlstack, CTL_STACK_SIZE);
 
  result = stk500v2_command(pgm, buf, CTL_STACK_SIZE + 1, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500hv_initalize(): "
                    "failed to set control stack\n",
                    progname);
    return -1;
  }
 
  /*
   * Examine the avrpart's memory definitions, and initialize the page
   * caches.  For devices/memory that are not page oriented, treat
   * them as page size 1 for EEPROM, and 2 for flash.
   */
  PDATA(pgm)->flash_pagesize = 2;
  PDATA(pgm)->eeprom_pagesize = 1;
  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
    m = ldata(ln);
    if (strcmp(m->desc, "flash") == 0) {
      if (m->page_size > 0) {
        if (m->page_size > 256)
          PDATA(pgm)->flash_pagesize = 256;
        else
          PDATA(pgm)->flash_pagesize = m->page_size;
      }
    } else if (strcmp(m->desc, "eeprom") == 0) {
      if (m->page_size > 0)
  PDATA(pgm)->eeprom_pagesize = m->page_size;
    }
  }
  free(PDATA(pgm)->flash_pagecache);
  free(PDATA(pgm)->eeprom_pagecache);
  if ((PDATA(pgm)->flash_pagecache = malloc(PDATA(pgm)->flash_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500hv_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500hv_initialize(): Out of memory\n",
      progname);
    free(PDATA(pgm)->flash_pagecache);
    return -1;
  }
  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
 
  return pgm->program_enable(pgm, p);
}

References avrdude_message(), CMD_SET_CONTROL_STACK, avrpart::controlstack, CTL_STACK_HVSP, CTL_STACK_PP, CTL_STACK_SIZE, avrpart::ctl_stack_type, avrpart::desc, avrmem::desc, free(), ldata(), lfirst(), lnext(), long, malloc(), avrpart::mem, MSG_INFO, avrmem::page_size, PDATA, pgm, PPMODE, progname, programmer_t::program_enable, and stk500v2_command().

Referenced by stk500hvsp_initialize(), and stk500pp_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_paged_load()

static int stk500hv_paged_load ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes, enum hvmode  mode  )

static

{
  unsigned int block_size, hiaddr, addrshift, use_ext_addr;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char commandbuf[3], buf[266];
  int result;
 
  DEBUG("STK500V2: stk500hv_paged_load(..,%s,%u,%u,%u)\n",
        m->desc, page_size, addr, n_bytes);
 
  page_size = m->readsize;
 
  hiaddr = UINT_MAX;
  addrshift = 0;
  use_ext_addr = 0;
 
  // determine which command is to be used
  if (strcmp(m->desc, "flash") == 0) {
    commandbuf[0] = mode == PPMODE? CMD_READ_FLASH_PP: CMD_READ_FLASH_HVSP;
    addrshift = 1;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  }
  else if (strcmp(m->desc, "eeprom") == 0) {
    commandbuf[0] = mode == PPMODE? CMD_READ_EEPROM_PP: CMD_READ_EEPROM_HVSP;
  }
 
  for (; addr < maxaddr; addr += page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
    DEBUG("block_size at addr %d is %d\n",addr,block_size);
 
    memcpy(buf, commandbuf, sizeof(commandbuf));
 
    buf[1] = block_size >> 8;
    buf[2] = block_size & 0xff;
 
    // Ensure a new "load extended address" will be issued
    // when crossing a 64 KB boundary in flash.
    if (hiaddr != (addr & ~0xFFFF)) {
      hiaddr = addr & ~0xFFFF;
      if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
        return -1;
    }
 
    result = stk500v2_command(pgm, buf, 3, sizeof(buf));
    if (result < 0) {
      avrdude_message(MSG_INFO, "%s: stk500hv_paged_load: read command failed\n",
                      progname);
      return -1;
    }
#if 0
    for (i = 0; i < page_size; i++) {
      avrdude_message(MSG_INFO, "%02X", buf[2 + i]);
      if (i % 16 == 15) avrdude_message(MSG_INFO, "\n");
    }
#endif
 
    memcpy(&m->buf[addr], &buf[2], block_size);
  }
 
  return n_bytes;
}

References AVR_OP_LOAD_EXT_ADDR, avrdude_message(), avrmem::buf, CMD_READ_EEPROM_HVSP, CMD_READ_EEPROM_PP, CMD_READ_FLASH_HVSP, CMD_READ_FLASH_PP, DEBUG, avrmem::desc, MSG_INFO, avrmem::op, pgm, PPMODE, progname, avrmem::readsize, stk500v2_command(), and stk500v2_loadaddr().

Referenced by stk500hvsp_paged_load(), and stk500pp_paged_load().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_paged_write()

static int stk500hv_paged_write ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes, enum hvmode  mode  )

static

{
  unsigned int block_size, last_addr, addrshift, use_ext_addr;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char commandbuf[5], buf[266];
  int result;
 
  DEBUG("STK500V2: stk500hv_paged_write(..,%s,%u,%u)\n",
        m->desc, page_size, addr, n_bytes);
 
  addrshift = 0;
  use_ext_addr = 0;
 
  // determine which command is to be used
  if (strcmp(m->desc, "flash") == 0) {
    addrshift = 1;
    PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
    commandbuf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  } else if (strcmp(m->desc, "eeprom") == 0) {
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
    commandbuf[0] = mode == PPMODE? CMD_PROGRAM_EEPROM_PP: CMD_PROGRAM_EEPROM_HVSP;
  }
  /*
   * Synthesize the mode byte.  This is simpler than adding yet
   * another parameter to the avrdude.conf file.  We calculate the
   * bits corresponding to the page size, as explained in AVR068.  We
   * set bit 7, to indicate this is to actually write the page to the
   * target device.  We set bit 6 to indicate this is the very last
   * page to be programmed, whatever this means -- we just pretend we
   * don't know any better. ;-)  Finally, we set bit 0 to say this is
   * a paged memory, after all, that's why we got here at all.
   */
  commandbuf[3] = 0x80 | 0x40;
  if (page_size > 2) {
    unsigned int rv = stk500v2_mode_for_pagesize(page_size);
    if (rv == 0)
      return -1;
    commandbuf[3] |= rv;
    commandbuf[3] |= 0x01;
  }
  commandbuf[4] = m->delay;
 
  if (page_size == 0) page_size = 256;
 
  last_addr = UINT_MAX;   /* impossible address */
 
  for (; addr < maxaddr; addr += page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
 
    DEBUG("block_size at addr %d is %d\n",addr,block_size);
 
    memcpy(buf, commandbuf, sizeof(commandbuf));
 
    buf[1] = page_size >> 8;
    buf[2] = page_size & 0xff;
 
    if ((last_addr == UINT_MAX) || (last_addr + block_size != addr)) {
      if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
        return -1;
    }
    last_addr=addr;
 
    memcpy(buf + 5, m->buf + addr, block_size);
    if (block_size != page_size)
      memset(buf + 5 + block_size, 0xff, page_size - block_size);
 
    result = stk500v2_command(pgm, buf, page_size + 5, sizeof(buf));
    if (result < 0) {
      avrdude_message(MSG_INFO, "%s: stk500hv_paged_write: write command failed\n",
                      progname);
      return -1;
    }
  }
 
  return n_bytes;
}

References AVR_OP_LOAD_EXT_ADDR, avrdude_message(), avrmem::buf, CMD_PROGRAM_EEPROM_HVSP, CMD_PROGRAM_EEPROM_PP, CMD_PROGRAM_FLASH_HVSP, CMD_PROGRAM_FLASH_PP, DEBUG, avrmem::delay, avrmem::desc, long, MSG_INFO, avrmem::op, PDATA, pgm, PPMODE, progname, stk500v2_command(), stk500v2_loadaddr(), and stk500v2_mode_for_pagesize().

Referenced by stk500hvsp_paged_write(), and stk500pp_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_read_byte()

static int stk500hv_read_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char *  value, enum hvmode  mode  )

static

{
  int result, cmdlen = 2;
  unsigned char buf[266];
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0, use_ext_addr = 0, addrshift = 0;
  unsigned char *cache_ptr = NULL;
 
  avrdude_message(MSG_NOTICE2, "%s: stk500hv_read_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (strcmp(mem->desc, "flash") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_FLASH_PP: CMD_READ_FLASH_HVSP;
    cmdlen = 3;
    pagesize = PDATA(pgm)->flash_pagesize;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
    cache_ptr = PDATA(pgm)->flash_pagecache;
    addrshift = 1;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_EEPROM_PP: CMD_READ_EEPROM_HVSP;
    cmdlen = 3;
    pagesize = mem->page_size;
    if (pagesize == 0)
      pagesize = 1;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
    cache_ptr = PDATA(pgm)->eeprom_pagecache;
  } else if (strcmp(mem->desc, "lfuse") == 0 ||
       strcmp(mem->desc, "fuse") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_FUSE_PP: CMD_READ_FUSE_HVSP;
    addr = 0;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_FUSE_PP: CMD_READ_FUSE_HVSP;
    addr = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_FUSE_PP: CMD_READ_FUSE_HVSP;
    addr = 2;
  } else if (strcmp(mem->desc, "lock") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_LOCK_PP: CMD_READ_LOCK_HVSP;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_OSCCAL_PP: CMD_READ_OSCCAL_HVSP;
  } else if (strcmp(mem->desc, "signature") == 0) {
    buf[0] = mode == PPMODE? CMD_READ_SIGNATURE_PP: CMD_READ_SIGNATURE_HVSP;
  }
 
  /*
   * In HV mode, we have to use paged reads for flash and
   * EEPROM, and cache the results in a page cache.
   *
   * Page cache validation is based on "{flash,eeprom}_pageaddr"
   * (holding the base address of the most recent cache fill
   * operation).  This variable is set to (unsigned long)-1L when the
   * cache needs to be invalidated.
   */
  if (pagesize && paddr == *paddr_ptr) {
    *value = cache_ptr[addr & (pagesize - 1)];
    return 0;
  }
 
  if (cmdlen == 3) {
    /* long command, fill in # of bytes */
    buf[1] = (pagesize >> 8) & 0xff;
    buf[2] = pagesize & 0xff;
 
    /* flash and EEPROM reads require the load address command */
    if (stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
        return -1;
  } else {
    buf[1] = (char)addr;
  }
 
  avrdude_message(MSG_NOTICE2, "%s: stk500hv_read_byte(): Sending read memory command: ",
      progname);
 
  result = stk500v2_command(pgm, buf, cmdlen, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500hv_read_byte(): "
                    "timeout/error communicating with programmer\n",
                    progname);
    return -1;
  }
 
  if (pagesize) {
    *paddr_ptr = paddr;
    memcpy(cache_ptr, buf + 2, pagesize);
    *value = cache_ptr[addr & (pagesize - 1)];
  } else {
    *value = buf[2];
  }
 
  return 0;
}

References AVR_OP_LOAD_EXT_ADDR, avrdude_message(), CMD_READ_EEPROM_HVSP, CMD_READ_EEPROM_PP, CMD_READ_FLASH_HVSP, CMD_READ_FLASH_PP, CMD_READ_FUSE_HVSP, CMD_READ_FUSE_PP, CMD_READ_LOCK_HVSP, CMD_READ_LOCK_PP, CMD_READ_OSCCAL_HVSP, CMD_READ_OSCCAL_PP, CMD_READ_SIGNATURE_HVSP, CMD_READ_SIGNATURE_PP, avrmem::desc, MSG_INFO, MSG_NOTICE2, avrmem::op, avrmem::page_size, PDATA, pgm, PPMODE, progname, stk500v2_command(), and stk500v2_loadaddr().

Referenced by stk500hvsp_read_byte(), and stk500pp_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hv_write_byte()

static int stk500hv_write_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char  data, enum hvmode  mode  )

static

{
  int result, cmdlen, timeout = 0, pulsewidth = 0;
  unsigned char buf[266];
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0, use_ext_addr = 0, addrshift = 0;
  unsigned char *cache_ptr = NULL;
 
  avrdude_message(MSG_NOTICE2, "%s: stk500hv_write_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (strcmp(mem->desc, "flash") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_FLASH_PP: CMD_PROGRAM_FLASH_HVSP;
    pagesize = PDATA(pgm)->flash_pagesize;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
    cache_ptr = PDATA(pgm)->flash_pagecache;
    addrshift = 1;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (mem->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_EEPROM_PP: CMD_PROGRAM_EEPROM_HVSP;
    pagesize = mem->page_size;
    if (pagesize == 0)
      pagesize = 1;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
    cache_ptr = PDATA(pgm)->eeprom_pagecache;
  } else if (strcmp(mem->desc, "lfuse") == 0 ||
       strcmp(mem->desc, "fuse") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_FUSE_PP: CMD_PROGRAM_FUSE_HVSP;
    addr = 0;
    pulsewidth = p->programfusepulsewidth;
    timeout = p->programfusepolltimeout;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_FUSE_PP: CMD_PROGRAM_FUSE_HVSP;
    addr = 1;
    pulsewidth = p->programfusepulsewidth;
    timeout = p->programfusepolltimeout;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_FUSE_PP: CMD_PROGRAM_FUSE_HVSP;
    addr = 2;
    pulsewidth = p->programfusepulsewidth;
    timeout = p->programfusepolltimeout;
  } else if (strcmp(mem->desc, "lock") == 0) {
    buf[0] = mode == PPMODE? CMD_PROGRAM_LOCK_PP: CMD_PROGRAM_LOCK_HVSP;
    pulsewidth = p->programlockpulsewidth;
    timeout = p->programlockpolltimeout;
  } else {
    avrdude_message(MSG_INFO, "%s: stk500hv_write_byte(): "
                    "unsupported memory type: %s\n",
                    progname, mem->desc);
    return -1;
  }
 
  cmdlen = 5 + pagesize;
 
  /*
   * In HV mode, we have to use paged writes for flash and
   * EEPROM.  As both, flash and EEPROM cells can only be programmed
   * from `1' to `0' bits (even EEPROM does not support auto-erase in
   * parallel mode), we just pre-fill the page cache with 0xff, so all
   * those cells that are outside our current address will remain
   * unaffected.
   */
  if (pagesize) {
    memset(cache_ptr, 0xff, pagesize);
    cache_ptr[addr & (pagesize - 1)] = data;
 
    /* long command, fill in # of bytes */
    buf[1] = (pagesize >> 8) & 0xff;
    buf[2] = pagesize & 0xff;
 
    /*
     * Synthesize the mode byte.  This is simpler than adding yet
     * another parameter to the avrdude.conf file.  We calculate the
     * bits corresponding to the page size, as explained in AVR068.
     * We set bit 7, to indicate this is to actually write the page to
     * the target device.  We set bit 6 to indicate this is the very
     * last page to be programmed, whatever this means -- we just
     * pretend we don't know any better. ;-)  Bit 0 is set if this is
     * a paged memory, which means it has a page size of more than 2.
     */
    buf[3] = 0x80 | 0x40;
    if (pagesize > 2) {
      unsigned int rv = stk500v2_mode_for_pagesize(pagesize);
      if (rv == 0)
        return -1;
      buf[3] |= rv;
      buf[3] |= 0x01;
    }
    buf[4] = mem->delay;
    memcpy(buf + 5, cache_ptr, pagesize);
 
    /* flash and EEPROM reads require the load address command */
    if (stk500v2_loadaddr(pgm, use_ext_addr | (paddr >> addrshift)) < 0)
        return -1;
  } else {
    buf[1] = (char)addr;
    buf[2] = data;
    if (mode == PPMODE) {
      buf[3] = pulsewidth;
      buf[4] = timeout;
    } else {
      buf[3] = timeout;
      cmdlen--;
    }
  }
 
  avrdude_message(MSG_NOTICE2, "%s: stk500hv_write_byte(): Sending write memory command: ",
      progname);
 
  result = stk500v2_command(pgm, buf, cmdlen, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500hv_write_byte(): "
                    "timeout/error communicating with programmer\n",
                    progname);
    return -1;
  }
 
  if (pagesize) {
    /* Invalidate the page cache. */
    *paddr_ptr = (unsigned long)-1L;
  }
 
  return 0;
}

References AVR_OP_LOAD_EXT_ADDR, avrdude_message(), CMD_PROGRAM_EEPROM_HVSP, CMD_PROGRAM_EEPROM_PP, CMD_PROGRAM_FLASH_HVSP, CMD_PROGRAM_FLASH_PP, CMD_PROGRAM_FUSE_HVSP, CMD_PROGRAM_FUSE_PP, CMD_PROGRAM_LOCK_HVSP, CMD_PROGRAM_LOCK_PP, avrmem::delay, avrmem::desc, long, MSG_INFO, MSG_NOTICE2, avrmem::op, avrmem::page_size, PDATA, pgm, PPMODE, progname, avrpart::programfusepolltimeout, avrpart::programfusepulsewidth, avrpart::programlockpolltimeout, avrpart::programlockpulsewidth, stk500v2_command(), stk500v2_loadaddr(), and stk500v2_mode_for_pagesize().

Referenced by stk500hvsp_write_byte(), and stk500pp_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_chip_erase()

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

static

{
  return stk500hv_chip_erase(pgm, p, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_chip_erase().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_disable()

static void stk500hvsp_disable ( PROGRAMMER *  pgm )

static

{
  stk500hv_disable(pgm, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_disable().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_initialize()

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

static

{
  return stk500hv_initialize(pgm, p, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_initialize().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_initpgm()

void stk500hvsp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK500HVSP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500hvsp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500hvsp_disable;
  pgm->program_enable = stk500hvsp_program_enable;
  pgm->chip_erase     = stk500hvsp_chip_erase;
  pgm->open           = stk500v2_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500hvsp_read_byte;
  pgm->write_byte     = stk500hvsp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500hvsp_paged_write;
  pgm->paged_load     = stk500hvsp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk500v2_set_vtarget;
  pgm->set_varef      = stk500v2_set_varef;
  pgm->set_fosc       = stk500v2_set_fosc;
  pgm->set_sck_period = stk500v2_set_sck_period;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500hvsp_chip_erase(), stk500hvsp_disable(), stk500hvsp_initialize(), stk500hvsp_paged_load(), stk500hvsp_paged_write(), stk500hvsp_program_enable(), stk500hvsp_read_byte(), stk500hvsp_write_byte(), stk500v2_close(), stk500v2_display(), stk500v2_enable(), stk500v2_open(), stk500v2_print_parms(), stk500v2_set_fosc(), stk500v2_set_sck_period(), stk500v2_set_varef(), stk500v2_set_vtarget(), stk500v2_setup(), stk500v2_teardown(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500hvsp_paged_load()

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

static

{
  return stk500hv_paged_load(pgm, p, m, page_size, addr, n_bytes, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_paged_load().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_paged_write()

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

static

{
  return stk500hv_paged_write(pgm, p, m, page_size, addr, n_bytes, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_paged_write().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_program_enable()

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

static

{
  unsigned char buf[16];
 
  PDATA(pgm)->lastpart = p;
 
  buf[0] = PDATA(pgm)->pgmtype == PGMTYPE_STK600?
  CMD_ENTER_PROGMODE_HVSP_STK600:
  CMD_ENTER_PROGMODE_HVSP;
  buf[1] = p->hventerstabdelay;
  buf[2] = p->hvspcmdexedelay;
  buf[3] = p->synchcycles;
  buf[4] = p->latchcycles;
  buf[5] = p->togglevtg;
  buf[6] = p->poweroffdelay;
  buf[7] = p->resetdelayms;
  buf[8] = p->resetdelayus;
 
  return stk500v2_command(pgm, buf, 9, sizeof(buf));
}

References CMD_ENTER_PROGMODE_HVSP, CMD_ENTER_PROGMODE_HVSP_STK600, avrpart::hventerstabdelay, avrpart::hvspcmdexedelay, avrpart::latchcycles, PDATA, pgm, avrpart::poweroffdelay, avrpart::resetdelayms, avrpart::resetdelayus, stk500v2_command(), avrpart::synchcycles, and avrpart::togglevtg.

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_read_byte()

static int stk500hvsp_read_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char *  value  )

static

{
  return stk500hv_read_byte(pgm, p, mem, addr, value, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_read_byte().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500hvsp_write_byte()

static int stk500hvsp_write_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char  data  )

static

{
  return stk500hv_write_byte(pgm, p, mem, addr, data, HVSPMODE);
}

References HVSPMODE, pgm, and stk500hv_write_byte().

Referenced by stk500hvsp_initpgm(), stk500v2_dragon_hvsp_initpgm(), and stk600hvsp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500isp_read_byte()

static int stk500isp_read_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char *  value  )

static

{
  int result, pollidx;
  unsigned char buf[6];
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0;
  unsigned char *cache_ptr = NULL;
  OPCODE *op;
 
  avrdude_message(MSG_NOTICE2, "%s: stk500isp_read_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (strcmp(mem->desc, "flash") == 0 ||
      strcmp(mem->desc, "eeprom") == 0) {
    // use paged access, and cache result
    if (strcmp(mem->desc, "flash") == 0) {
      pagesize = PDATA(pgm)->flash_pagesize;
      paddr = addr & ~(pagesize - 1);
      paddr_ptr = &PDATA(pgm)->flash_pageaddr;
      cache_ptr = PDATA(pgm)->flash_pagecache;
    } else {
      pagesize = mem->page_size;
      if (pagesize == 0)
  pagesize = 1;
      paddr = addr & ~(pagesize - 1);
      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
      cache_ptr = PDATA(pgm)->eeprom_pagecache;
    }
 
    if (paddr == *paddr_ptr) {
      *value = cache_ptr[addr & (pagesize - 1)];
      return 0;
    }
 
    if (stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
      return -1;
 
    *paddr_ptr = paddr;
    memcpy(cache_ptr, &mem->buf[paddr], pagesize);
    *value = cache_ptr[addr & (pagesize - 1)];
 
    return 0;
  }
 
  if (strcmp(mem->desc, "lfuse") == 0 ||
       strcmp(mem->desc, "fuse") == 0) {
    buf[0] = CMD_READ_FUSE_ISP;
    addr = 0;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    buf[0] = CMD_READ_FUSE_ISP;
    addr = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    buf[0] = CMD_READ_FUSE_ISP;
    addr = 2;
  } else if (strcmp(mem->desc, "lock") == 0) {
    buf[0] = CMD_READ_LOCK_ISP;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    buf[0] = CMD_READ_OSCCAL_ISP;
  } else if (strcmp(mem->desc, "signature") == 0) {
    buf[0] = CMD_READ_SIGNATURE_ISP;
  }
 
  memset(buf + 1, 0, 5);
  if ((op = mem->op[AVR_OP_READ]) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500isp_read_byte(): invalid operation AVR_OP_READ on %s memory\n",
                    progname, mem->desc);
    return -1;
  }
  avr_set_bits(op, buf + 2);
  if ((pollidx = avr_get_output_index(op)) == -1) {
    avrdude_message(MSG_INFO, "%s: stk500isp_read_byte(): cannot determine pollidx to read %s memory\n",
                    progname, mem->desc);
    pollidx = 3;
  }
  buf[1] = pollidx + 1;
  avr_set_addr(op, buf + 2, addr);
 
  avrdude_message(MSG_NOTICE2, "%s: stk500isp_read_byte(): Sending read memory command: ",
      progname);
 
  result = stk500v2_command(pgm, buf, 6, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500isp_read_byte(): "
                    "timeout/error communicating with programmer\n",
                    progname);
    return -1;
  }
 
  *value = buf[2];
 
  return 0;
}

References avr_get_output_index(), AVR_OP_READ, avr_set_addr(), avr_set_bits(), avrdude_message(), avrmem::buf, CMD_READ_FUSE_ISP, CMD_READ_LOCK_ISP, CMD_READ_OSCCAL_ISP, CMD_READ_SIGNATURE_ISP, avrmem::desc, MSG_INFO, MSG_NOTICE2, avrmem::op, avrmem::page_size, PDATA, pgm, progname, stk500v2_command(), and stk500v2_paged_load().

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500isp_write_byte()

static int stk500isp_write_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char  data  )

static

{
  int result;
  unsigned char buf[5];
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0;
  unsigned char *cache_ptr = NULL;
  OPCODE *op;
 
  avrdude_message(MSG_NOTICE2, "%s: stk500isp_write_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (strcmp(mem->desc, "flash") == 0 ||
      strcmp(mem->desc, "eeprom") == 0) {
    if (strcmp(mem->desc, "flash") == 0) {
      pagesize = PDATA(pgm)->flash_pagesize;
      paddr = addr & ~(pagesize - 1);
      paddr_ptr = &PDATA(pgm)->flash_pageaddr;
      cache_ptr = PDATA(pgm)->flash_pagecache;
    } else {
      pagesize = mem->page_size;
      if (pagesize == 0)
  pagesize = 1;
      paddr = addr & ~(pagesize - 1);
      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
      cache_ptr = PDATA(pgm)->eeprom_pagecache;
    }
 
    /*
     * We use paged writes for flash and EEPROM, reading back the
     * current page first, modify the byte to write, and write out the
     * entire page.
     */
    if (stk500v2_paged_load(pgm, p, mem, pagesize, paddr, pagesize) < 0)
      return -1;
 
    memcpy(cache_ptr, mem->buf + paddr, pagesize);
    *paddr_ptr = paddr;
    cache_ptr[addr & (pagesize - 1)] = data;
    memcpy(mem->buf + paddr, cache_ptr, pagesize);
 
    stk500v2_paged_write(pgm, p, mem, pagesize, paddr, pagesize);
 
    return 0;
  }
 
  memset(buf, 0, sizeof buf);
  if (strcmp(mem->desc, "lfuse") == 0 ||
       strcmp(mem->desc, "fuse") == 0) {
    buf[0] = CMD_PROGRAM_FUSE_ISP;
    addr = 0;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    buf[0] = CMD_PROGRAM_FUSE_ISP;
    addr = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    buf[0] = CMD_PROGRAM_FUSE_ISP;
    addr = 2;
  } else if (strcmp(mem->desc, "lock") == 0) {
    buf[0] = CMD_PROGRAM_LOCK_ISP;
  } else {
    avrdude_message(MSG_INFO, "%s: stk500isp_write_byte(): "
                    "unsupported memory type: %s\n",
                    progname, mem->desc);
    return -1;
  }
 
  if ((op = mem->op[AVR_OP_WRITE]) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500isp_write_byte(): "
                    "no AVR_OP_WRITE for %s memory\n",
                    progname, mem->desc);
    return -1;
  }
 
  avr_set_bits(op, buf + 1);
  avr_set_addr(op, buf + 1, addr);
  avr_set_input(op, buf + 1, data);
 
  avrdude_message(MSG_NOTICE2, "%s: stk500isp_write_byte(): Sending write memory command: ",
      progname);
 
  result = stk500v2_command(pgm, buf, 5, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500isp_write_byte(): "
                    "timeout/error communicating with programmer\n",
                    progname);
    return -1;
  }
 
  /*
   * Prevent verification readback to be too fast, see
   * https://savannah.nongnu.org/bugs/index.php?42267
   *
   * After all, this is just an ugly hack working around some
   * brokeness in the Atmel firmware starting with the AVRISPmkII (the
   * old JTAGICEmkII isn't affected).  Let's hope 10 ms of additional
   * delay are good enough for everyone.
   */
  usleep(10000);
 
  return 0;
}

References AVR_OP_WRITE, avr_set_addr(), avr_set_bits(), avr_set_input(), avrdude_message(), avrmem::buf, CMD_PROGRAM_FUSE_ISP, CMD_PROGRAM_LOCK_ISP, avrmem::desc, MSG_INFO, MSG_NOTICE2, avrmem::op, avrmem::page_size, PDATA, pgm, progname, stk500v2_command(), stk500v2_paged_load(), stk500v2_paged_write(), and usleep().

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_chip_erase()

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

static

{
  return stk500hv_chip_erase(pgm, p, PPMODE);
}

References pgm, PPMODE, and stk500hv_chip_erase().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_disable()

static void stk500pp_disable ( PROGRAMMER *  pgm )

static

{
  stk500hv_disable(pgm, PPMODE);
}

References pgm, PPMODE, and stk500hv_disable().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_initialize()

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

static

{
  return stk500hv_initialize(pgm, p, PPMODE);
}

References pgm, PPMODE, and stk500hv_initialize().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_initpgm()

void stk500pp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK500PP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500pp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500pp_disable;
  pgm->program_enable = stk500pp_program_enable;
  pgm->chip_erase     = stk500pp_chip_erase;
  pgm->open           = stk500v2_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500pp_read_byte;
  pgm->write_byte     = stk500pp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500pp_paged_write;
  pgm->paged_load     = stk500pp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk500v2_set_vtarget;
  pgm->set_varef      = stk500v2_set_varef;
  pgm->set_fosc       = stk500v2_set_fosc;
  pgm->set_sck_period = stk500v2_set_sck_period;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500pp_chip_erase(), stk500pp_disable(), stk500pp_initialize(), stk500pp_paged_load(), stk500pp_paged_write(), stk500pp_program_enable(), stk500pp_read_byte(), stk500pp_write_byte(), stk500v2_close(), stk500v2_display(), stk500v2_enable(), stk500v2_open(), stk500v2_print_parms(), stk500v2_set_fosc(), stk500v2_set_sck_period(), stk500v2_set_varef(), stk500v2_set_vtarget(), stk500v2_setup(), stk500v2_teardown(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500pp_paged_load()

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

static

{
  return stk500hv_paged_load(pgm, p, m, page_size, addr, n_bytes, PPMODE);
}

References pgm, PPMODE, and stk500hv_paged_load().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_paged_write()

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

static

{
  return stk500hv_paged_write(pgm, p, m, page_size, addr, n_bytes, PPMODE);
}

References pgm, PPMODE, and stk500hv_paged_write().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_program_enable()

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

static

{
  unsigned char buf[16];
 
  PDATA(pgm)->lastpart = p;
 
  buf[0] = CMD_ENTER_PROGMODE_PP;
  buf[1] = p->hventerstabdelay;
  buf[2] = p->progmodedelay;
  buf[3] = p->latchcycles;
  buf[4] = p->togglevtg;
  buf[5] = p->poweroffdelay;
  buf[6] = p->resetdelayms;
  buf[7] = p->resetdelayus;
 
  return stk500v2_command(pgm, buf, 8, sizeof(buf));
}

References CMD_ENTER_PROGMODE_PP, avrpart::hventerstabdelay, avrpart::latchcycles, PDATA, pgm, avrpart::poweroffdelay, avrpart::progmodedelay, avrpart::resetdelayms, avrpart::resetdelayus, stk500v2_command(), and avrpart::togglevtg.

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_read_byte()

static int stk500pp_read_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char *  value  )

static

{
  return stk500hv_read_byte(pgm, p, mem, addr, value, PPMODE);
}

References pgm, PPMODE, and stk500hv_read_byte().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500pp_write_byte()

static int stk500pp_write_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char  data  )

static

{
  return stk500hv_write_byte(pgm, p, mem, addr, data, PPMODE);
}

References pgm, PPMODE, and stk500hv_write_byte().

Referenced by stk500pp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_chip_erase()

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

static

{
  int result;
  unsigned char buf[16];
 
  if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_chip_erase: chip erase instruction not defined for part \"%s\"\n",
            progname, p->desc);
    return -1;
  }
 
  pgm->pgm_led(pgm, ON);
 
  buf[0] = CMD_CHIP_ERASE_ISP;
  buf[1] = p->chip_erase_delay / 1000;
  buf[2] = 0; // use delay (?)
  avr_set_bits(p->op[AVR_OP_CHIP_ERASE], buf+3);
  result = stk500v2_command(pgm, buf, 7, sizeof(buf));
  usleep(p->chip_erase_delay);
  pgm->initialize(pgm, p);
 
  pgm->pgm_led(pgm, OFF);
 
  return result >= 0? 0: -1;
}

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

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_close()

static void stk500v2_close ( PROGRAMMER *  pgm )

static

{
  DEBUG("STK500V2: stk500v2_close()\n");
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

References DEBUG, programmer_t::fd, filedescriptor::ifd, pgm, and serial_close.

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the caller graph for this function:

stk500v2_cmd()

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

static

{
  unsigned char buf[8];
  int result;
 
  DEBUG("STK500V2: stk500v2_cmd(%02x,%02x,%02x,%02x)\n",cmd[0],cmd[1],cmd[2],cmd[3]);
 
  buf[0] = CMD_SPI_MULTI;
  buf[1] = 4;
  buf[2] = 4;
  buf[3] = 0;
  buf[4] = cmd[0];
  buf[5] = cmd[1];
  buf[6] = cmd[2];
  buf[7] = cmd[3];
 
  result = stk500v2_command(pgm, buf, 8, sizeof(buf));
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_cmd(): failed to send command\n",
            progname);
    return -1;
  } else if (result < 6) {
    avrdude_message(MSG_INFO, "%s: stk500v2_cmd(): short reply, len = %d\n",
            progname, result);
    return -1;
  }
 
  res[0] = buf[2];
  res[1] = buf[3];
  res[2] = buf[4];
  res[3] = buf[5];
 
  return 0;
}

References avrdude_message(), cmd, CMD_SPI_MULTI, DEBUG, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtagmkII_initpgm(), and stk600_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_command()

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

static

                                                       {
  int i;
  int tries = 0;
  int status;
 
  DEBUG("STK500V2: stk500v2_command(");
  for (i=0;i<len;i++) DEBUG("0x%02x ",buf[i]);
  DEBUG(", %d)\n",len);
 
retry:
  tries++;
 
  RETURN_IF_CANCEL();
 
  // send the command to the programmer
  if (stk500v2_send(pgm, buf, len) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_command(): can't communicate with device\n", progname);
    return -1;
  }
 
  RETURN_IF_CANCEL();
 
  // attempt to read the status back
  status = stk500v2_recv(pgm,buf,maxlen);
 
  RETURN_IF_CANCEL();
 
  // if we got a successful readback, return
  if (status > 0) {
    DEBUG(" = %d\n",status);
    if (status < 2) {
      avrdude_message(MSG_INFO, "%s: stk500v2_command(): short reply\n", progname);
      return -1;
    }
    if (buf[0] == CMD_XPROG_SETMODE || buf[0] == CMD_XPROG) {
        /*
         * Decode XPROG wrapper errors.
         */
        const char *msg;
        int i;
 
        /*
         * For CMD_XPROG_SETMODE, the status is returned in buf[1].
         * For CMD_XPROG, buf[1] contains the XPRG_CMD_* command, and
         * buf[2] contains the status.
         */
        i = buf[0] == CMD_XPROG_SETMODE? 1: 2;
 
        if (buf[i] != XPRG_ERR_OK) {
            switch (buf[i]) {
            case XPRG_ERR_FAILED:   msg = "Failed"; break;
            case XPRG_ERR_COLLISION: msg = "Collision"; break;
            case XPRG_ERR_TIMEOUT:  msg = "Timeout"; break;
            default:                msg = "Unknown"; break;
            }
            avrdude_message(MSG_INFO, "%s: stk500v2_command(): error in %s: %s\n",
                    progname,
                    (buf[0] == CMD_XPROG_SETMODE? "CMD_XPROG_SETMODE": "CMD_XPROG"),
                    msg);
            return -1;
        }
        return 0;
    } else {
        /*
         * Decode STK500v2 errors.
         */
        if (buf[1] >= STATUS_CMD_TOUT && buf[1] < 0xa0) {
            const char *msg;
            char msgbuf[30];
            switch (buf[1]) {
            case STATUS_CMD_TOUT:
                msg = "Command timed out";
                break;
 
            case STATUS_RDY_BSY_TOUT:
                msg = "Sampling of the RDY/nBSY pin timed out";
                break;
 
            case STATUS_SET_PARAM_MISSING:
                msg = "The `Set Device Parameters' have not been "
                    "executed in advance of this command";
 
            default:
                sprintf(msgbuf, "unknown, code 0x%02x", buf[1]);
                msg = msgbuf;
                break;
            }
            if (quell_progress < 2) {
                avrdude_message(MSG_INFO, "%s: stk500v2_command(): warning: %s\n",
                        progname, msg);
            }
        } else if (buf[1] == STATUS_CMD_OK) {
            return status;
        } else if (buf[1] == STATUS_CMD_FAILED) {
            avrdude_message(MSG_INFO, "%s: stk500v2_command(): command failed\n",
                            progname);
        } else if (buf[1] == STATUS_CMD_UNKNOWN) {
            avrdude_message(MSG_INFO, "%s: stk500v2_command(): unknown command\n",
                            progname);
        } else {
            avrdude_message(MSG_INFO, "%s: stk500v2_command(): unknown status 0x%02x\n",
                    progname, buf[1]);
        }
        return -1;
    }
  }
 
  // otherwise try to sync up again
  status = stk500v2_getsync(pgm);
  if (status != 0) {
    if (tries > RETRIES) {
      avrdude_message(MSG_INFO, "%s: stk500v2_command(): failed miserably to execute command 0x%02x\n",
              progname,buf[0]);
      return -1;
    } else
      goto retry;
  }
 
  DEBUG(" = 0\n");
  return 0;
}

References avrdude_message(), CMD_XPROG, CMD_XPROG_SETMODE, DEBUG, MSG_INFO, pgm, progname, quell_progress, RETRIES, RETURN_IF_CANCEL, STATUS_CMD_FAILED, STATUS_CMD_OK, STATUS_CMD_TOUT, STATUS_CMD_UNKNOWN, STATUS_RDY_BSY_TOUT, STATUS_SET_PARAM_MISSING, stk500v2_getsync(), stk500v2_recv(), stk500v2_send(), XPRG_ERR_COLLISION, XPRG_ERR_FAILED, XPRG_ERR_OK, and XPRG_ERR_TIMEOUT.

Referenced by stk500hv_chip_erase(), stk500hv_disable(), stk500hv_initialize(), stk500hv_paged_load(), stk500hv_paged_write(), stk500hv_read_byte(), stk500hv_write_byte(), stk500hvsp_program_enable(), stk500isp_read_byte(), stk500isp_write_byte(), stk500pp_program_enable(), stk500v2_chip_erase(), stk500v2_cmd(), stk500v2_disable(), stk500v2_getparm(), stk500v2_getparm2(), stk500v2_jtag3_disable(), stk500v2_loadaddr(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_program_enable(), stk500v2_set_upload_size(), stk500v2_setparm2(), stk500v2_setparm_real(), stk600_xprog_command(), and stk600_xprog_program_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_disable()

static void stk500v2_disable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[16];
  int result;
 
  buf[0] = CMD_LEAVE_PROGMODE_ISP;
  buf[1] = 1; // preDelay;
  buf[2] = 1; // postDelay;
 
  result = stk500v2_command(pgm, buf, 3, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_disable(): failed to leave programming mode\n",
                    progname);
  }
 
  return;
}

References avrdude_message(), CMD_LEAVE_PROGMODE_ISP, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_display()

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

static

{
  unsigned char maj = 0;
  unsigned char min = 0;
  unsigned char hdw = 0;
  unsigned char topcard = 0;
  unsigned char maj_s1 = 0;
  unsigned char min_s1 = 0;
  unsigned char maj_s2 = 0;
  unsigned char min_s2 = 0;
  unsigned int rev = 0;
  const char *topcard_name, *pgmname;
 
  switch (PDATA(pgm)->pgmtype) {
    case PGMTYPE_UNKNOWN:     pgmname = "Unknown"; break;
    case PGMTYPE_STK500:      pgmname = "STK500"; break;
    case PGMTYPE_AVRISP:      pgmname = "AVRISP"; break;
    case PGMTYPE_AVRISP_MKII: pgmname = "AVRISP mkII"; break;
    case PGMTYPE_STK600:      pgmname = "STK600"; break;
    default:                  pgmname = "None";
  }
  if (PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE_MKII &&
      PDATA(pgm)->pgmtype != PGMTYPE_JTAGICE3) {
    avrdude_message(MSG_INFO, "%sProgrammer Model: %s\n", p, pgmname);
    stk500v2_getparm(pgm, PARAM_HW_VER, &hdw);
    stk500v2_getparm(pgm, PARAM_SW_MAJOR, &maj);
    stk500v2_getparm(pgm, PARAM_SW_MINOR, &min);
    avrdude_message(MSG_INFO, "%sHardware Version: %d\n", p, hdw);
    avrdude_message(MSG_INFO, "%sFirmware Version Master : %d.%02d\n", p, maj, min);
    if (PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
      stk500v2_getparm(pgm, PARAM_SW_MAJOR_SLAVE1, &maj_s1);
      stk500v2_getparm(pgm, PARAM_SW_MINOR_SLAVE1, &min_s1);
      stk500v2_getparm(pgm, PARAM_SW_MAJOR_SLAVE2, &maj_s2);
      stk500v2_getparm(pgm, PARAM_SW_MINOR_SLAVE2, &min_s2);
      avrdude_message(MSG_INFO, "%sFirmware Version Slave 1: %d.%02d\n", p, maj_s1, min_s1);
      avrdude_message(MSG_INFO, "%sFirmware Version Slave 2: %d.%02d\n", p, maj_s2, min_s2);
    }
  }
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_STK500) {
    stk500v2_getparm(pgm, PARAM_TOPCARD_DETECT, &topcard);
    switch (topcard) {
      case 0xAA: topcard_name = "STK501"; break;
      case 0x55: topcard_name = "STK502"; break;
      case 0xFA: topcard_name = "STK503"; break;
      case 0xEE: topcard_name = "STK504"; break;
      case 0xE4: topcard_name = "STK505"; break;
      case 0xDD: topcard_name = "STK520"; break;
      default: topcard_name = "Unknown"; break;
    }
    avrdude_message(MSG_INFO, "%sTopcard         : %s\n", p, topcard_name);
  } else if (PDATA(pgm)->pgmtype == PGMTYPE_STK600) {
    stk500v2_getparm(pgm, PARAM_ROUTINGCARD_ID, &topcard);
    avrdude_message(MSG_INFO, "%sRouting card    : %s\n", p,
      stk600_get_cardname(routing_cards,
        sizeof routing_cards / sizeof routing_cards[0],
        topcard));
    stk500v2_getparm(pgm, PARAM_SOCKETCARD_ID, &topcard);
    avrdude_message(MSG_INFO, "%sSocket card     : %s\n", p,
      stk600_get_cardname(socket_cards,
        sizeof socket_cards / sizeof socket_cards[0],
        topcard));
    stk500v2_getparm2(pgm, PARAM2_RC_ID_TABLE_REV, &rev);
    avrdude_message(MSG_INFO, "%sRC_ID table rev : %d\n", p, rev);
    stk500v2_getparm2(pgm, PARAM2_EC_ID_TABLE_REV, &rev);
    avrdude_message(MSG_INFO, "%sEC_ID table rev : %d\n", p, rev);
  }
  stk500v2_print_parms1(pgm, p);
 
  return;
}

References avrdude_message(), MSG_INFO, PARAM2_EC_ID_TABLE_REV, PARAM2_RC_ID_TABLE_REV, PARAM_HW_VER, PARAM_ROUTINGCARD_ID, PARAM_SOCKETCARD_ID, PARAM_SW_MAJOR, PARAM_SW_MAJOR_SLAVE1, PARAM_SW_MAJOR_SLAVE2, PARAM_SW_MINOR, PARAM_SW_MINOR_SLAVE1, PARAM_SW_MINOR_SLAVE2, PARAM_TOPCARD_DETECT, PDATA, pgm, pgmname, routing_cards, socket_cards, stk500v2_getparm(), stk500v2_getparm2(), stk500v2_print_parms1(), and stk600_get_cardname().

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_dragon_hv_open()

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

static

{
  return -1;
//   union pinfo pinfo;
//   void *mycookie;
 
//   avrdude_message(MSG_NOTICE2, "%s: stk500v2_dragon_hv_open()\n", progname);
 
//   /*
//    * The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
//    * attaching.  If the config file or command-line parameters specify
//    * a higher baud rate, we switch to it later on, after establishing
//    * the connection with the ICE.
//    */
//   pinfo.baud = 19200;
 
//   /*
//    * If the port name starts with "usb", divert the serial routines
//    * to the USB ones.  The serial_open() function for USB overrides
//    * the meaning of the "baud" parameter to be the USB device ID to
//    * search for.
//    */
//   if (strncmp(port, "usb", 3) == 0) {
// #if defined(HAVE_LIBUSB)
//     serdev = &usb_serdev;
//     pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
//     pinfo.usbinfo.flags = 0;
//     pinfo.usbinfo.pid = USB_DEVICE_AVRDRAGON;
//     pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
//     pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
//     pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
//     pgm->fd.usb.eep = 0;           /* no seperate EP for events */
// #else
//     avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
//     return -1;
// #endif
//   }
 
//   strcpy(pgm->port, port);
//   if (serial_open(port, pinfo, &pgm->fd)==-1) {
//     return -1;
//   }
 
//   /*
//    * drain any extraneous input
//    */
//   stk500v2_drain(pgm, 0);
 
//   mycookie = pgm->cookie;
//   pgm->cookie = PDATA(pgm)->chained_pdata;
//   if (jtagmkII_getsync(pgm, EMULATOR_MODE_HV) != 0) {
//     avrdude_message(MSG_INFO, "%s: failed to sync with the AVR Dragon in HV mode\n",
//             progname);
//     pgm->cookie = mycookie;
//     return -1;
//   }
//   pgm->cookie = mycookie;
 
//   PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
 
//   if (pgm->bitclock != 0.0) {
//     if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
//       return -1;
//   }
 
//   return 0;
}

Referenced by stk500v2_dragon_hvsp_initpgm(), and stk500v2_dragon_pp_initpgm().

Here is the caller graph for this function:

stk500v2_dragon_hvsp_initpgm()

void stk500v2_dragon_hvsp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "DRAGON_HVSP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500hvsp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500hvsp_disable;
  pgm->program_enable = stk500hvsp_program_enable;
  pgm->chip_erase     = stk500hvsp_chip_erase;
  pgm->open           = stk500v2_dragon_hv_open;
  pgm->close          = stk500v2_jtagmkII_close;
  pgm->read_byte      = stk500hvsp_read_byte;
  pgm->write_byte     = stk500hvsp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500hvsp_paged_write;
  pgm->paged_load     = stk500hvsp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk500v2_set_vtarget;
  pgm->set_varef      = stk500v2_set_varef;
  pgm->set_fosc       = stk500v2_set_fosc;
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
  pgm->setup          = stk500v2_jtagmkII_setup;
  pgm->teardown       = stk500v2_jtagmkII_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500hvsp_chip_erase(), stk500hvsp_disable(), stk500hvsp_initialize(), stk500hvsp_paged_load(), stk500hvsp_paged_write(), stk500hvsp_program_enable(), stk500hvsp_read_byte(), stk500hvsp_write_byte(), stk500v2_display(), stk500v2_dragon_hv_open(), stk500v2_enable(), stk500v2_jtagmkII_close(), stk500v2_jtagmkII_setup(), stk500v2_jtagmkII_teardown(), stk500v2_print_parms(), stk500v2_set_fosc(), stk500v2_set_sck_period_mk2(), stk500v2_set_varef(), stk500v2_set_vtarget(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500v2_dragon_isp_initpgm()

void stk500v2_dragon_isp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "DRAGON_ISP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500v2_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500v2_disable;
  pgm->program_enable = stk500v2_program_enable;
  pgm->chip_erase     = stk500v2_chip_erase;
  pgm->cmd            = stk500v2_cmd;
  pgm->open           = stk500v2_dragon_isp_open;
  pgm->close          = stk500v2_jtagmkII_close;
  pgm->read_byte      = stk500isp_read_byte;
  pgm->write_byte     = stk500isp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500v2_paged_write;
  pgm->paged_load     = stk500v2_paged_load;
  pgm->page_erase     = stk500v2_page_erase;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
  pgm->setup          = stk500v2_jtagmkII_setup;
  pgm->teardown       = stk500v2_jtagmkII_teardown;
  pgm->page_size      = 256;
}

References 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_erase, 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_sck_period, programmer_t::setup, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_cmd(), stk500v2_disable(), stk500v2_display(), stk500v2_dragon_isp_open(), stk500v2_enable(), stk500v2_initialize(), stk500v2_jtagmkII_close(), stk500v2_jtagmkII_setup(), stk500v2_jtagmkII_teardown(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_print_parms(), stk500v2_program_enable(), stk500v2_set_sck_period_mk2(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500v2_dragon_isp_open()

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

static

{
  return -1;
//   union pinfo pinfo;
//   void *mycookie;
 
//   avrdude_message(MSG_NOTICE2, "%s: stk500v2_dragon_isp_open()\n", progname);
 
//   /*
//    * The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
//    * attaching.  If the config file or command-line parameters specify
//    * a higher baud rate, we switch to it later on, after establishing
//    * the connection with the ICE.
//    */
//   pinfo.baud = 19200;
 
//   /*
//    * If the port name starts with "usb", divert the serial routines
//    * to the USB ones.  The serial_open() function for USB overrides
//    * the meaning of the "baud" parameter to be the USB device ID to
//    * search for.
//    */
//   if (strncmp(port, "usb", 3) == 0) {
// #if defined(HAVE_LIBUSB)
//     serdev = &usb_serdev;
//     pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
//     pinfo.usbinfo.flags = 0;
//     pinfo.usbinfo.pid = USB_DEVICE_AVRDRAGON;
//     pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
//     pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
//     pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
//     pgm->fd.usb.eep = 0;           /* no seperate EP for events */
// #else
//     avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
//     return -1;
// #endif
//   }
 
//   strcpy(pgm->port, port);
//   if (serial_open(port, pinfo, &pgm->fd)==-1) {
//     return -1;
//   }
 
//   /*
//    * drain any extraneous input
//    */
//   stk500v2_drain(pgm, 0);
 
//   mycookie = pgm->cookie;
//   pgm->cookie = PDATA(pgm)->chained_pdata;
//   if (jtagmkII_getsync(pgm, EMULATOR_MODE_SPI) != 0) {
//     avrdude_message(MSG_INFO, "%s: failed to sync with the AVR Dragon in ISP mode\n",
//             progname);
//     pgm->cookie = mycookie;
//     return -1;
//   }
//   pgm->cookie = mycookie;
 
//   PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
 
//   if (pgm->bitclock != 0.0) {
//     if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
//       return -1;
//   }
 
//   return 0;
}

Referenced by stk500v2_dragon_isp_initpgm().

Here is the caller graph for this function:

stk500v2_dragon_pp_initpgm()

void stk500v2_dragon_pp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "DRAGON_PP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500pp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500pp_disable;
  pgm->program_enable = stk500pp_program_enable;
  pgm->chip_erase     = stk500pp_chip_erase;
  pgm->open           = stk500v2_dragon_hv_open;
  pgm->close          = stk500v2_jtagmkII_close;
  pgm->read_byte      = stk500pp_read_byte;
  pgm->write_byte     = stk500pp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500pp_paged_write;
  pgm->paged_load     = stk500pp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk500v2_set_vtarget;
  pgm->set_varef      = stk500v2_set_varef;
  pgm->set_fosc       = stk500v2_set_fosc;
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
  pgm->setup          = stk500v2_jtagmkII_setup;
  pgm->teardown       = stk500v2_jtagmkII_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500pp_chip_erase(), stk500pp_disable(), stk500pp_initialize(), stk500pp_paged_load(), stk500pp_paged_write(), stk500pp_program_enable(), stk500pp_read_byte(), stk500pp_write_byte(), stk500v2_display(), stk500v2_dragon_hv_open(), stk500v2_enable(), stk500v2_jtagmkII_close(), stk500v2_jtagmkII_setup(), stk500v2_jtagmkII_teardown(), stk500v2_print_parms(), stk500v2_set_fosc(), stk500v2_set_sck_period_mk2(), stk500v2_set_varef(), stk500v2_set_vtarget(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500v2_drain()

int stk500v2_drain	(	PROGRAMMER *	pgm,
		int	display
	)

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by stk500v2_open(), stk600_open(), and wiring_open().

Here is the caller graph for this function:

stk500v2_enable()

static void stk500v2_enable ( PROGRAMMER *  pgm )

static

{
  return;
}

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the caller graph for this function:

stk500v2_getparm()

static int stk500v2_getparm ( PROGRAMMER *  pgm, unsigned char  parm, unsigned char *  value  )

static

{
  unsigned char buf[32];
 
  buf[0] = CMD_GET_PARAMETER;
  buf[1] = parm;
 
  if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_getparm(): failed to get parameter 0x%02x\n",
            progname, parm);
    return -1;
  }
 
  *value = buf[2];
 
  return 0;
}

References avrdude_message(), CMD_GET_PARAMETER, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_display(), stk500v2_print_parms1(), stk500v2_program_enable(), stk500v2_set_varef(), stk500v2_set_vtarget(), stk500v2_setparm(), and stk600_set_varef().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_getparm2()

static int stk500v2_getparm2 ( PROGRAMMER *  pgm, unsigned char  parm, unsigned int *  value  )

static

{
  unsigned char buf[32];
 
  buf[0] = CMD_GET_PARAMETER;
  buf[1] = parm;
 
  if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_getparm2(): failed to get parameter 0x%02x\n",
            progname, parm);
    return -1;
  }
 
  *value = ((unsigned)buf[2] << 8) | buf[3];
 
  return 0;
}

References avrdude_message(), CMD_GET_PARAMETER, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_display(), stk500v2_print_parms1(), and stk600_set_vtarget().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_getsync()

int stk500v2_getsync

(

PROGRAMMER *

pgm

)

                                       {
  int tries = 0;
  unsigned char buf[1], resp[32];
  int status;
 
  DEBUG("STK500V2: stk500v2_getsync()\n");
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII ||
      PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
    return 0;
 
retry:
  tries++;
 
  RETURN_IF_CANCEL();
 
  // send the sync command and see if we can get there
  buf[0] = CMD_SIGN_ON;
  if (stk500v2_send(pgm, buf, 1) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_getsync(): can't communicate with device\n", progname);
    return -1;
  }
 
  RETURN_IF_CANCEL();
 
  // try to get the response back and see where we got
  status = stk500v2_recv(pgm, resp, sizeof(resp));
 
  RETURN_IF_CANCEL();
 
  // if we got bytes returned, check to see what came back
  if (status > 0) {
    if ((resp[0] == CMD_SIGN_ON) && (resp[1] == STATUS_CMD_OK) &&
  (status > 3)) {
      // success!
      unsigned int siglen = resp[2];
      if (siglen >= strlen("STK500_2") &&
    memcmp(resp + 3, "STK500_2", strlen("STK500_2")) == 0) {
  PDATA(pgm)->pgmtype = PGMTYPE_STK500;
      } else if (siglen >= strlen("AVRISP_2") &&
     memcmp(resp + 3, "AVRISP_2", strlen("AVRISP_2")) == 0) {
  PDATA(pgm)->pgmtype = PGMTYPE_AVRISP;
      } else if (siglen >= strlen("AVRISP_MK2") &&
     memcmp(resp + 3, "AVRISP_MK2", strlen("AVRISP_MK2")) == 0) {
  PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
      } else if (siglen >= strlen("STK600") &&
    memcmp(resp + 3, "STK600", strlen("STK600")) == 0) {
  PDATA(pgm)->pgmtype = PGMTYPE_STK600;
      } else {
  resp[siglen + 3] = 0;
        avrdude_message(MSG_NOTICE, "%s: stk500v2_getsync(): got response from unknown "
                          "programmer %s, assuming STK500\n",
                          progname, resp + 3);
  PDATA(pgm)->pgmtype = PGMTYPE_STK500;
      }
      avrdude_message(MSG_DEBUG, "%s: stk500v2_getsync(): found %s programmer\n",
                        progname, pgmname[PDATA(pgm)->pgmtype]);
      return 0;
    } else {
      if (tries > RETRIES) {
        avrdude_message(MSG_INFO, "%s: stk500v2_getsync(): can't communicate with device: resp=0x%02x\n",
                        progname, resp[0]);
        return -6;
      } else
        goto retry;
    }
 
  // or if we got a timeout
  } else if (status == -1) {
    if (tries > RETRIES) {
      avrdude_message(MSG_INFO, "%s: stk500v2_getsync(): timeout communicating with programmer\n",
              progname);
      return -1;
    } else
      goto retry;
 
  // or any other error
  } else {
    if (tries > RETRIES) {
      avrdude_message(MSG_INFO, "%s: stk500v2_getsync(): error communicating with programmer: (%d)\n",
              progname,status);
    } else
      goto retry;
  }
 
  return 0;
}

References avrdude_message(), CMD_SIGN_ON, DEBUG, MSG_DEBUG, MSG_INFO, MSG_NOTICE, PDATA, pgm, pgmname, progname, RETRIES, RETURN_IF_CANCEL, STATUS_CMD_OK, stk500v2_recv(), and stk500v2_send().

Referenced by stk500v2_command(), stk500v2_open(), stk600_open(), and wiring_open().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_initialize()

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

static

{
 
  LNODEID ln;
  AVRMEM * m;
 
  if ((PDATA(pgm)->pgmtype == PGMTYPE_STK600 ||
       PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
       PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) != 0
      && (p->flags & (AVRPART_HAS_PDI | AVRPART_HAS_TPI)) != 0) {
    /*
     * This is an ATxmega device, must use XPROG protocol for the
     * remaining actions.
     */
    if ((p->flags & AVRPART_HAS_PDI) != 0) {
      /*
       * Find out where the border between application and boot area
       * is.
       */
      AVRMEM *bootmem = avr_locate_mem(p, "boot");
      AVRMEM *flashmem = avr_locate_mem(p, "flash");
      if (bootmem == NULL || flashmem == NULL) {
        avrdude_message(MSG_INFO, "%s: stk500v2_initialize(): Cannot locate \"flash\" and \"boot\" memories in description\n",
                        progname);
      } else {
        PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
      }
    }
    stk600_setup_xprog(pgm);
  } else {
    stk600_setup_isp(pgm);
  }
 
  /*
   * Examine the avrpart's memory definitions, and initialize the page
   * caches.  For devices/memory that are not page oriented, treat
   * them as page size 1 for EEPROM, and 2 for flash.
   */
  PDATA(pgm)->flash_pagesize = 2;
  PDATA(pgm)->eeprom_pagesize = 1;
  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
    m = ldata(ln);
    if (strcmp(m->desc, "flash") == 0) {
      if (m->page_size > 0) {
        if (m->page_size > 256)
          PDATA(pgm)->flash_pagesize = 256;
        else
          PDATA(pgm)->flash_pagesize = m->page_size;
      }
    } else if (strcmp(m->desc, "eeprom") == 0) {
      if (m->page_size > 0)
  PDATA(pgm)->eeprom_pagesize = m->page_size;
    }
  }
  free(PDATA(pgm)->flash_pagecache);
  free(PDATA(pgm)->eeprom_pagecache);
  if ((PDATA(pgm)->flash_pagecache = malloc(PDATA(pgm)->flash_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_initialize(): Out of memory\n",
      progname);
    free(PDATA(pgm)->flash_pagecache);
    return -1;
  }
  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
 
  if (p->flags & AVRPART_IS_AT90S1200) {
    /*
     * AT90S1200 needs a positive reset pulse after a chip erase.
     */
    pgm->disable(pgm);
    usleep(10000);
  }
  return pgm->program_enable(pgm, p);
}

References avr_locate_mem(), avrdude_message(), AVRPART_HAS_PDI, AVRPART_HAS_TPI, AVRPART_IS_AT90S1200, avrmem::desc, programmer_t::disable, avrpart::flags, free(), ldata(), lfirst(), lnext(), long, malloc(), avrpart::mem, MSG_INFO, avrmem::offset, avrmem::page_size, PDATA, pgm, progname, programmer_t::program_enable, stk600_setup_isp(), stk600_setup_xprog(), and usleep().

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtagmkII_initpgm(), and stk600_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_initpgm()

void stk500v2_initpgm

(

PROGRAMMER *

pgm

)

{
 
  strcpy(pgm->type, "STK500V2");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500v2_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500v2_disable;
  pgm->program_enable = stk500v2_program_enable;
  pgm->chip_erase     = stk500v2_chip_erase;
  pgm->cmd            = stk500v2_cmd;
  pgm->open           = stk500v2_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500isp_read_byte;
  pgm->write_byte     = stk500isp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500v2_paged_write;
  pgm->paged_load     = stk500v2_paged_load;
  pgm->page_erase     = stk500v2_page_erase;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk500v2_set_vtarget;
  pgm->set_varef      = stk500v2_set_varef;
  pgm->set_fosc       = stk500v2_set_fosc;
  pgm->set_sck_period = stk500v2_set_sck_period;
  pgm->perform_osccal = stk500v2_perform_osccal;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
  pgm->set_upload_size= stk500v2_set_upload_size;
}

References 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_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::perform_osccal, 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_upload_size, programmer_t::set_varef, programmer_t::set_vtarget, programmer_t::setup, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_close(), stk500v2_cmd(), stk500v2_disable(), stk500v2_display(), stk500v2_enable(), stk500v2_initialize(), stk500v2_open(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_print_parms(), stk500v2_program_enable(), stk500v2_set_fosc(), stk500v2_set_sck_period(), stk500v2_set_upload_size(), stk500v2_set_varef(), stk500v2_set_vtarget(), stk500v2_setup(), stk500v2_teardown(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Referenced by stk500generic_open(), stk500generic_setup(), stk500generic_teardown(), and wiring_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_jtag3_close()

static void stk500v2_jtag3_close ( PROGRAMMER *  pgm )

static

{
  // void *mycookie;
 
  // avrdude_message(MSG_NOTICE2, "%s: stk500v2_jtag3_close()\n", progname);
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // jtag3_close(pgm);
  // pgm->cookie = mycookie;
}

Referenced by stk500v2_jtag3_initpgm().

Here is the caller graph for this function:

stk500v2_jtag3_cmd()

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

static

{
  avrdude_message(MSG_INFO, "%s: stk500v2_jtag3_cmd(): Not available in JTAGICE3\n",
                  progname);
 
  return -1;
}

References avrdude_message(), MSG_INFO, and progname.

Referenced by stk500v2_jtag3_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_jtag3_disable()

static void stk500v2_jtag3_disable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[16];
  int result;
 
  free(PDATA(pgm)->flash_pagecache);
  PDATA(pgm)->flash_pagecache = NULL;
  free(PDATA(pgm)->eeprom_pagecache);
  PDATA(pgm)->eeprom_pagecache = NULL;
 
  buf[0] = CMD_LEAVE_PROGMODE_ISP;
  buf[1] = 1; // preDelay;
  buf[2] = 1; // postDelay;
 
  result = stk500v2_command(pgm, buf, 3, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_disable(): failed to leave programming mode\n",
                    progname);
  }
 
  return;
}

References avrdude_message(), CMD_LEAVE_PROGMODE_ISP, free(), MSG_INFO, PDATA, pgm, progname, and stk500v2_command().

Referenced by stk500v2_jtag3_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_jtag3_initialize()

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

static

{
  return -1;
  // unsigned char parm[4], *resp;
  // LNODEID ln;
  // AVRMEM * m;
  // void *mycookie;
 
  // if ((p->flags & AVRPART_HAS_PDI) ||
  //     (p->flags & AVRPART_HAS_TPI)) {
  //   avrdude_message(MSG_INFO, "%s: jtag3_initialize(): part %s has no ISP interface\n",
   //    progname, p->desc);
  //   return -1;
  // }
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
 
  // if (p->flags & AVRPART_HAS_DW)
  //   parm[0] = PARM3_ARCH_TINY;
  // else
  //   parm[0] = PARM3_ARCH_MEGA;
  // if (jtag3_setparm(pgm, SCOPE_AVR, 0, PARM3_ARCH, parm, 1) < 0) {
  //   pgm->cookie = mycookie;
  //   return -1;
  // }
 
  // parm[0] = PARM3_SESS_PROGRAMMING;
  // if (jtag3_setparm(pgm, SCOPE_AVR, 0, PARM3_SESS_PURPOSE, parm, 1) < 0) {
  //   pgm->cookie = mycookie;
  //   return -1;
  // }
 
  // parm[0] = PARM3_CONN_ISP;
  // if (jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CONNECTION, parm, 1) < 0) {
  //   pgm->cookie = mycookie;
  //   return -1;
  // }
 
  // parm[0] = SCOPE_AVR_ISP;
  // parm[1] = 0x1e;
  // jtag3_send(pgm, parm, 2);
 
  // if (jtag3_recv(pgm, &resp) > 0)
  //   free(resp);
 
  // pgm->cookie = mycookie;
 
  // /*
  //  * Examine the avrpart's memory definitions, and initialize the page
  //  * caches.  For devices/memory that are not page oriented, treat
  //  * them as page size 1 for EEPROM, and 2 for flash.
  //  */
  // PDATA(pgm)->flash_pagesize = 2;
  // PDATA(pgm)->eeprom_pagesize = 1;
 //  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
 //    m = ldata(ln);
 //    if (strcmp(m->desc, "flash") == 0) {
 //      if (m->page_size > 0) {
 //        if (m->page_size > 256)
 //          PDATA(pgm)->flash_pagesize = 256;
 //        else
 //          PDATA(pgm)->flash_pagesize = m->page_size;
 //      }
 //    } else if (strcmp(m->desc, "eeprom") == 0) {
 //      if (m->page_size > 0)
  // PDATA(pgm)->eeprom_pagesize = m->page_size;
 //    }
 //  }
 //  free(PDATA(pgm)->flash_pagecache);
 //  free(PDATA(pgm)->eeprom_pagecache);
 //  if ((PDATA(pgm)->flash_pagecache = malloc(PDATA(pgm)->flash_pagesize)) == NULL) {
 //    avrdude_message(MSG_INFO, "%s: stk500hv_initialize(): Out of memory\n",
  //     progname);
 //    return -1;
 //  }
 //  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
 //    avrdude_message(MSG_INFO, "%s: stk500hv_initialize(): Out of memory\n",
  //     progname);
 //    free(PDATA(pgm)->flash_pagecache);
 //    return -1;
 //  }
 //  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
 
 //  return pgm->program_enable(pgm, p);
}

Referenced by stk500v2_jtag3_initpgm().

Here is the caller graph for this function:

stk500v2_jtag3_initpgm()

void stk500v2_jtag3_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAG3_ISP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500v2_jtag3_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500v2_jtag3_disable;
  pgm->program_enable = stk500v2_program_enable;
  pgm->chip_erase     = stk500v2_chip_erase;
  pgm->cmd            = stk500v2_jtag3_cmd;
  pgm->open           = stk500v2_jtag3_open;
  pgm->close          = stk500v2_jtag3_close;
  pgm->read_byte      = stk500isp_read_byte;
  pgm->write_byte     = stk500isp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500v2_paged_write;
  pgm->paged_load     = stk500v2_paged_load;
  pgm->page_erase     = stk500v2_page_erase;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_sck_period = stk500v2_jtag3_set_sck_period;
  pgm->perform_osccal = stk500v2_perform_osccal;
  pgm->setup          = stk500v2_jtag3_setup;
  pgm->teardown       = stk500v2_jtag3_teardown;
  pgm->page_size      = 256;
}

References 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_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::perform_osccal, pgm, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_sck_period, programmer_t::setup, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_display(), stk500v2_enable(), stk500v2_jtag3_close(), stk500v2_jtag3_cmd(), stk500v2_jtag3_disable(), stk500v2_jtag3_initialize(), stk500v2_jtag3_open(), stk500v2_jtag3_set_sck_period(), stk500v2_jtag3_setup(), stk500v2_jtag3_teardown(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_print_parms(), stk500v2_program_enable(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500v2_jtag3_open()

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

static

{
  return -1;
  // void *mycookie;
  // int rv;
 
  // avrdude_message(MSG_NOTICE2, "%s: stk500v2_jtag3_open()\n", progname);
 
  // if (jtag3_open_common(pgm, port) < 0)
  //   return -1;
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // if ((rv = jtag3_getsync(pgm, 42)) != 0) {
  //   if (rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
  //       avrdude_message(MSG_INFO, "%s: failed to sync with the JTAGICE3 in ISP mode\n",
  //                       progname);
  //   pgm->cookie = mycookie;
  //   return -1;
  // }
  // pgm->cookie = mycookie;
 
  // PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE3;
 
  // if (pgm->bitclock != 0.0) {
  //   if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
  //     return -1;
  // }
 
  // return 0;
}

Referenced by stk500v2_jtag3_initpgm().

Here is the caller graph for this function:

stk500v2_jtag3_recv()

static int stk500v2_jtag3_recv ( PROGRAMMER *  pgm, unsigned char *  msg, size_t  maxsize  )

static

{
  return -1;
  // int rv;
  // unsigned char *jtagmsg;
  // void *mycookie;
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // rv = jtag3_recv(pgm, &jtagmsg);
  // pgm->cookie = mycookie;
  // if (rv <= 0) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtag3_recv(): error in jtagmkII_recv()\n",
  //           progname);
  //   return -1;
  // }
  // /* Getting more data than expected is a normal case for the EDBG
  //    implementation of JTAGICE3, as they always request a full 512
  //    octets from the ICE.  Thus, only complain at high verbose
  //    levels. */
  // if (rv - 1 > maxsize) {
  //   avrdude_message(MSG_DEBUG, "%s: stk500v2_jtag3_recv(): got %u bytes, have only room for %u bytes\n",
  //                     progname, (unsigned)rv - 1, (unsigned)maxsize);
  //   rv = maxsize;
  // }
  // if (jtagmsg[0] != SCOPE_AVR_ISP) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtag3_recv(): message is not AVR ISP: 0x%02x\n",
  //                   progname, jtagmsg[0]);
  //   free(jtagmsg);
  //   return -1;
  // }
  // memcpy(msg, jtagmsg + 1, rv - 1);
  // free(jtagmsg);
  // return rv;
}

Referenced by stk500v2_jtag3_set_sck_period(), stk500v2_print_parms1(), and stk500v2_recv().

Here is the caller graph for this function:

stk500v2_jtag3_send()

static int stk500v2_jtag3_send ( PROGRAMMER *  pgm, unsigned char *  data, size_t  len  )

static

{
  return -1;
  // unsigned char *cmdbuf;
  // int rv;
  // void *mycookie;
 
  // if ((cmdbuf = malloc(len + 1)) == NULL) {
  //   avrdude_message(MSG_INFO, "%s: out of memory for command packet\n",
  //           progname);
  //   exit(1);
  // }
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // cmdbuf[0] = SCOPE_AVR_ISP;
  // memcpy(cmdbuf + 1, data, len);
  // rv = jtag3_send(pgm, cmdbuf, len + 1);
  // free(cmdbuf);
  // pgm->cookie = mycookie;
 
  // return rv;
}

Referenced by stk500v2_jtag3_set_sck_period(), stk500v2_print_parms1(), and stk500v2_send().

Here is the caller graph for this function:

stk500v2_jtag3_set_sck_period()

static int stk500v2_jtag3_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned char value[3];
  unsigned int sck;
 
  if (v < 1E-6)
    sck = 0x400;
  else if (v > 1E-3)
    sck = 1;
  else
    sck = (unsigned)(1.0 / (1000.0 * v));
 
  value[0] = CMD_SET_SCK;
  value[1] = sck & 0xff;
  value[2] = (sck >> 8) & 0xff;
 
  if (stk500v2_jtag3_send(pgm, value, 3) < 0)
    return -1;
  if (stk500v2_jtag3_recv(pgm, value, 3) < 0)
    return -1;
  return 0;
}

References CMD_SET_SCK, pgm, stk500v2_jtag3_recv(), and stk500v2_jtag3_send().

Referenced by stk500v2_jtag3_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_jtag3_setup()

static void stk500v2_jtag3_setup ( PROGRAMMER *  pgm )

static

{
  // void *mycookie, *theircookie;
 
  // if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_setup(): Out of memory allocating private data\n",
  //                   progname);
  //   exit(1);
  // }
  // memset(pgm->cookie, 0, sizeof(struct pdata));
  // PDATA(pgm)->command_sequence = 1;
 
  // /*
  //  * Now, have the JTAGICE3 backend allocate its own private
  //  * data.  Store our own cookie in a safe place for the time being.
  //  */
  // mycookie = pgm->cookie;
  // jtag3_setup(pgm);
  // theircookie = pgm->cookie;
  // pgm->cookie = mycookie;
  // PDATA(pgm)->chained_pdata = theircookie;
}

Referenced by stk500v2_jtag3_initpgm().

Here is the caller graph for this function:

stk500v2_jtag3_teardown()

static void stk500v2_jtag3_teardown ( PROGRAMMER *  pgm )

static

{
  // void *mycookie;
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // jtag3_teardown(pgm);
 
  // free(mycookie);
}

Referenced by stk500v2_jtag3_initpgm().

Here is the caller graph for this function:

stk500v2_jtagmkII_close()

static void stk500v2_jtagmkII_close ( PROGRAMMER *  pgm )

static

{
  // void *mycookie;
 
  // avrdude_message(MSG_NOTICE2, "%s: stk500v2_jtagmkII_close()\n", progname);
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // jtagmkII_close(pgm);
  // pgm->cookie = mycookie;
}

Referenced by stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_jtagmkII_initpgm().

Here is the caller graph for this function:

stk500v2_jtagmkII_initpgm()

void stk500v2_jtagmkII_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAGMKII_ISP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500v2_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500v2_disable;
  pgm->program_enable = stk500v2_program_enable;
  pgm->chip_erase     = stk500v2_chip_erase;
  pgm->cmd            = stk500v2_cmd;
  pgm->open           = stk500v2_jtagmkII_open;
  pgm->close          = stk500v2_jtagmkII_close;
  pgm->read_byte      = stk500isp_read_byte;
  pgm->write_byte     = stk500isp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500v2_paged_write;
  pgm->paged_load     = stk500v2_paged_load;
  pgm->page_erase     = stk500v2_page_erase;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_sck_period = stk500v2_set_sck_period_mk2;
  pgm->perform_osccal = stk500v2_perform_osccal;
  pgm->setup          = stk500v2_jtagmkII_setup;
  pgm->teardown       = stk500v2_jtagmkII_teardown;
  pgm->page_size      = 256;
}

References 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_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::perform_osccal, pgm, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_sck_period, programmer_t::setup, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_cmd(), stk500v2_disable(), stk500v2_display(), stk500v2_enable(), stk500v2_initialize(), stk500v2_jtagmkII_close(), stk500v2_jtagmkII_open(), stk500v2_jtagmkII_setup(), stk500v2_jtagmkII_teardown(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_print_parms(), stk500v2_program_enable(), stk500v2_set_sck_period_mk2(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk500v2_jtagmkII_open()

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

static

{
  return -1;
//   union pinfo pinfo;
//   void *mycookie;
//   int rv;
 
//   avrdude_message(MSG_NOTICE2, "%s: stk500v2_jtagmkII_open()\n", progname);
 
//   /*
//    * The JTAG ICE mkII always starts with a baud rate of 19200 Bd upon
//    * attaching.  If the config file or command-line parameters specify
//    * a higher baud rate, we switch to it later on, after establishing
//    * the connection with the ICE.
//    */
//   pinfo.baud = 19200;
 
//   /*
//    * If the port name starts with "usb", divert the serial routines
//    * to the USB ones.  The serial_open() function for USB overrides
//    * the meaning of the "baud" parameter to be the USB device ID to
//    * search for.
//    */
//   if (strncmp(port, "usb", 3) == 0) {
// #if defined(HAVE_LIBUSB)
//     serdev = &usb_serdev;
//     pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
//     pinfo.usbinfo.flags = 0;
//     pinfo.usbinfo.pid = USB_DEVICE_JTAGICEMKII;
//     pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
//     pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
//     pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
//     pgm->fd.usb.eep = 0;           /* no seperate EP for events */
// #else
//     avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
//     return -1;
// #endif
//   }
 
//   strcpy(pgm->port, port);
//   if (serial_open(port, pinfo, &pgm->fd)==-1) {
//     return -1;
//   }
 
//   /*
//    * drain any extraneous input
//    */
//   stk500v2_drain(pgm, 0);
 
//   mycookie = pgm->cookie;
//   pgm->cookie = PDATA(pgm)->chained_pdata;
//   if ((rv = jtagmkII_getsync(pgm, EMULATOR_MODE_SPI)) != 0) {
//     if (rv != JTAGII_GETSYNC_FAIL_GRACEFUL)
//         avrdude_message(MSG_INFO, "%s: failed to sync with the JTAG ICE mkII in ISP mode\n",
//                         progname);
//     pgm->cookie = mycookie;
//     return -1;
//   }
//   pgm->cookie = mycookie;
 
//   PDATA(pgm)->pgmtype = PGMTYPE_JTAGICE_MKII;
 
//   if (pgm->bitclock != 0.0) {
//     if (pgm->set_sck_period(pgm, pgm->bitclock) != 0)
//       return -1;
//   }
 
//   return 0;
}

Referenced by stk500v2_jtagmkII_initpgm().

Here is the caller graph for this function:

stk500v2_jtagmkII_recv()

static int stk500v2_jtagmkII_recv ( PROGRAMMER *  pgm, unsigned char *  msg, size_t  maxsize  )

static

{
  return -1;
  // int rv;
  // unsigned char *jtagmsg;
  // void *mycookie;
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // rv = jtagmkII_recv(pgm, &jtagmsg);
  // pgm->cookie = mycookie;
  // if (rv <= 0) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtagmkII_recv(): error in jtagmkII_recv()\n",
  //           progname);
  //   return -1;
  // }
  // if (rv - 1 > maxsize) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtagmkII_recv(): got %u bytes, have only room for %u bytes\n",
  //                   progname, (unsigned)rv - 1, (unsigned)maxsize);
  //   rv = maxsize;
  // }
  // switch (jtagmsg[0]) {
  // case RSP_SPI_DATA:
  //   break;
  // case RSP_FAILED:
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtagmkII_recv(): failed\n",
   //    progname);
  //   return -1;
  // case RSP_ILLEGAL_MCU_STATE:
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtagmkII_recv(): illegal MCU state\n",
   //    progname);
  //   return -1;
  // default:
  //   avrdude_message(MSG_INFO, "%s: stk500v2_jtagmkII_recv(): unknown status %d\n",
   //    progname, jtagmsg[0]);
  //   return -1;
  // }
  // memcpy(msg, jtagmsg + 1, rv - 1);
  // return rv;
}

Referenced by stk500v2_recv().

Here is the caller graph for this function:

stk500v2_jtagmkII_send()

static int stk500v2_jtagmkII_send ( PROGRAMMER *  pgm, unsigned char *  data, size_t  len  )

static

{
  return -1;
  // unsigned char *cmdbuf;
  // int rv;
  // unsigned short sz;
  // void *mycookie;
 
  // sz = get_jtagisp_return_size(data[0]);
  // if (sz == 0) {
  //   avrdude_message(MSG_INFO, "%s: unsupported encapsulated ISP command: %#x\n",
   //    progname, data[0]);
  //   return -1;
  // }
  // if (sz == SZ_READ_FLASH_EE) {
  //   /*
  //    * For CMND_READ_FLASH_ISP and CMND_READ_EEPROM_ISP, extract the
  //    * size of the return data from the request.  Note that the
  //    * request itself has the size in big endian format, while we are
  //    * supposed to deliver it in little endian.
  //    */
  //   sz = 3 + (data[1] << 8) + data[2];
  // } else if (sz == SZ_SPI_MULTI) {
  //   /*
  //    * CMND_SPI_MULTI has the Rx size encoded in its 3rd byte.
  //    */
  //   sz = 3 + data[2];
  // }
 
  // if ((cmdbuf = malloc(len + 3)) == NULL) {
  //   avrdude_message(MSG_INFO, "%s: out of memory for command packet\n",
  //           progname);
  //   exit(1);
  // }
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // cmdbuf[0] = CMND_ISP_PACKET;
  // cmdbuf[1] = sz & 0xff;
  // cmdbuf[2] = (sz >> 8) & 0xff;
  // memcpy(cmdbuf + 3, data, len);
  // rv = jtagmkII_send(pgm, cmdbuf, len + 3);
  // free(cmdbuf);
  // pgm->cookie = mycookie;
 
  // return rv;
}

Referenced by stk500v2_send().

Here is the caller graph for this function:

stk500v2_jtagmkII_setup()

static void stk500v2_jtagmkII_setup ( PROGRAMMER *  pgm )

static

{
  // void *mycookie, *theircookie;
 
  // if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
  //   avrdude_message(MSG_INFO, "%s: stk500v2_setup(): Out of memory allocating private data\n",
  //                   progname);
  //   exit(1);
  // }
  // memset(pgm->cookie, 0, sizeof(struct pdata));
  // PDATA(pgm)->command_sequence = 1;
 
  // /*
  //  * Now, have the JTAG ICE mkII backend allocate its own private
  //  * data.  Store our own cookie in a safe place for the time being.
  //  */
  // mycookie = pgm->cookie;
  // jtagmkII_setup(pgm);
  // theircookie = pgm->cookie;
  // pgm->cookie = mycookie;
  // PDATA(pgm)->chained_pdata = theircookie;
}

Referenced by stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_jtagmkII_initpgm().

Here is the caller graph for this function:

stk500v2_jtagmkII_teardown()

static void stk500v2_jtagmkII_teardown ( PROGRAMMER *  pgm )

static

{
  // void *mycookie;
 
  // mycookie = pgm->cookie;
  // pgm->cookie = PDATA(pgm)->chained_pdata;
  // jtagmkII_teardown(pgm);
 
  // free(mycookie);
}

Referenced by stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_jtagmkII_initpgm().

Here is the caller graph for this function:

stk500v2_loadaddr()

static int stk500v2_loadaddr ( PROGRAMMER *  pgm, unsigned int  addr  )

static

{
  unsigned char buf[16];
  int result;
 
  DEBUG("STK500V2: stk500v2_loadaddr(%d)\n",addr);
 
  buf[0] = CMD_LOAD_ADDRESS;
  buf[1] = (addr >> 24) & 0xff;
  buf[2] = (addr >> 16) & 0xff;
  buf[3] = (addr >> 8) & 0xff;
  buf[4] = addr & 0xff;
 
  result = stk500v2_command(pgm, buf, 5, sizeof(buf));
 
  if (result < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_loadaddr(): failed to set load address\n",
                    progname);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMD_LOAD_ADDRESS, DEBUG, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500hv_paged_load(), stk500hv_paged_write(), stk500hv_read_byte(), stk500hv_write_byte(), stk500v2_paged_load(), stk500v2_paged_write(), stk600_xprog_paged_load(), and stk600_xprog_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_mode_for_pagesize()

static unsigned int stk500v2_mode_for_pagesize ( unsigned int  pagesize )

static

{
  switch (pagesize)
    {
    case 256:  return 0u << 1;
    case 2:    return 1u << 1;
    case 4:    return 2u << 1;
    case 8:    return 3u << 1;
    case 16:   return 4u << 1;
    case 32:   return 5u << 1;
    case 64:   return 6u << 1;
    case 128:  return 7u << 1;
    }
  avrdude_message(MSG_INFO, "%s: stk500v2_mode_for_pagesize(): invalid pagesize: %u\n",
                  progname, pagesize);
  return 0;
}

References avrdude_message(), MSG_INFO, and progname.

Referenced by stk500hv_paged_write(), and stk500hv_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_open()

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

static

{
  union pinfo pinfo = { .baud = 115200 };
 
  DEBUG("STK500V2: stk500v2_open()\n");
 
  if (pgm->baudrate)
    pinfo.baud = pgm->baudrate;
 
  PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
 
  if(strcasecmp(port, "avrdoper") == 0){
#if defined(HAVE_LIBUSB) || (defined(WIN32NATIVE) && defined(HAVE_LIBHID))
    serdev = &avrdoper_serdev;
    PDATA(pgm)->pgmtype = PGMTYPE_STK500;
#else
    avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
    return -1;
#endif
  }
 
  /*
   * If the port name starts with "usb", divert the serial routines
   * to the USB ones.  The serial_open() function for USB overrides
   * the meaning of the "baud" parameter to be the USB device ID to
   * search for.
   */
  if (strncmp(port, "usb", 3) == 0) {
#if defined(HAVE_LIBUSB)
    serdev = &usb_serdev_frame;
    pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
    pinfo.usbinfo.flags = 0;
    pinfo.usbinfo.pid = USB_DEVICE_AVRISPMKII;
    PDATA(pgm)->pgmtype = PGMTYPE_AVRISP_MKII;
    pgm->set_sck_period = stk500v2_set_sck_period_mk2;
    pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
    pgm->fd.usb.rep = USBDEV_BULK_EP_READ_MKII;
    pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_MKII;
    pgm->fd.usb.eep = 0;           /* no seperate EP for events */
#else
    avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
    return -1;
#endif
  }
 
  strcpy(pgm->port, port);
  if (serial_open(port, pinfo, &pgm->fd)==-1) {
    return -1;
  }
 
  /*
   * drain any extraneous input
   */
  stk500v2_drain(pgm, 0);
 
  stk500v2_getsync(pgm);
 
  stk500v2_drain(pgm, 0);
 
  if (pgm->bitclock != 0.0) {
    if (pgm->set_sck_period(pgm, pgm->bitclock) != 0) {
      serial_close(&pgm->fd);
      return -1;
    }
  }
 
  return 0;
}

References avrdoper_serdev, avrdude_message(), pinfo::baud, programmer_t::baudrate, programmer_t::bitclock, DEBUG, programmer_t::fd, MSG_INFO, PDATA, pgm, programmer_t::port, serdev, serial_close, serial_open, programmer_t::set_sck_period, stk500v2_drain(), stk500v2_getsync(), stk500v2_set_sck_period_mk2(), strcasecmp, filedescriptor::usb, USB_DEVICE_AVRISPMKII, usb_serdev_frame, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), and stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_page_erase()

static int stk500v2_page_erase ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  addr  )

static

{
  avrdude_message(MSG_INFO, "%s: stk500v2_page_erase(): this function must never be called\n",
                  progname);
  return -1;
}

References avrdude_message(), MSG_INFO, and progname.

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_paged_load()

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

static

{
  unsigned int block_size, hiaddr, addrshift, use_ext_addr;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char commandbuf[4];
  unsigned char buf[275]; // max buffer size for stk500v2 at this point
  unsigned char cmds[4];
  int result;
  OPCODE * rop;
 
  DEBUG("STK500V2: stk500v2_paged_load(..,%s,%u,%u,%u)\n",
        m->desc, page_size, addr, n_bytes);
 
  page_size = m->readsize;
 
  rop = m->op[AVR_OP_READ];
 
  hiaddr = UINT_MAX;
  addrshift = 0;
  use_ext_addr = 0;
 
  // determine which command is to be used
  if (strcmp(m->desc, "flash") == 0) {
    commandbuf[0] = CMD_READ_FLASH_ISP;
    rop = m->op[AVR_OP_READ_LO];
    addrshift = 1;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  }
  else if (strcmp(m->desc, "eeprom") == 0) {
    commandbuf[0] = CMD_READ_EEPROM_ISP;
  }
 
  // the read command is common to both methods
  if (rop == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_paged_load: read instruction not defined for part \"%s\"\n",
            progname, p->desc);
    return -1;
  }
  avr_set_bits(rop, cmds);
  commandbuf[3] = cmds[0];
 
  for (; addr < maxaddr; addr += page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
    DEBUG("block_size at addr %d is %d\n",addr,block_size);
 
    memcpy(buf,commandbuf,sizeof(commandbuf));
 
    buf[1] = block_size >> 8;
    buf[2] = block_size & 0xff;
 
    // Ensure a new "load extended address" will be issued
    // when crossing a 64 KB boundary in flash.
    if (hiaddr != (addr & ~0xFFFF)) {
      hiaddr = addr & ~0xFFFF;
      if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
        return -1;
    }
 
    result = stk500v2_command(pgm,buf,4,sizeof(buf));
    if (result < 0) {
      avrdude_message(MSG_INFO, "%s: stk500v2_paged_load: read command failed\n",
                      progname);
      return -1;
    }
#if 0
    for (i=0;i<page_size;i++) {
      avrdude_message(MSG_INFO, "%02X",buf[2+i]);
      if (i%16 == 15) avrdude_message(MSG_INFO, "\n");
    }
#endif
 
    memcpy(&m->buf[addr], &buf[2], block_size);
  }
 
  return n_bytes;
}

References AVR_OP_LOAD_EXT_ADDR, AVR_OP_READ, AVR_OP_READ_LO, avr_set_bits(), avrdude_message(), avrmem::buf, CMD_READ_EEPROM_ISP, CMD_READ_FLASH_ISP, DEBUG, avrpart::desc, avrmem::desc, MSG_INFO, avrmem::op, pgm, progname, avrmem::readsize, stk500v2_command(), and stk500v2_loadaddr().

Referenced by stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_paged_write()

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

static

{
// static int page = 0;
  unsigned int block_size, last_addr, addrshift, use_ext_addr;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char commandbuf[10];
  unsigned char buf[266];
  unsigned char cmds[4];
  int result;
  OPCODE * rop, * wop;
 
  // Prusa3D workaround for a bug in the USB communication controller. The semicolon character is used as an initial character
  // for special command sequences for the USB communication chip. The early releases of the USB communication chip had
  // a bug, which produced a 0x0ff character after the semicolon. The patch is to program the semicolons by flashing
  // firmware blocks twice: First the low nibbles of semicolons, second the high nibbles of the semicolon characters.
  //
  // Inside the 2nd round of a firmware block flashing?
  bool prusa3d_semicolon_workaround_round2 = false;
  // Buffer containing the other nibbles of semicolons to be flashed in the 2nd round.
  unsigned char prusa3d_semicolon_workaround_round2_data[256];
 
  DEBUG("STK500V2: stk500v2_paged_write(..,%s,%u,%u,%u)\n",
        m->desc, page_size, addr, n_bytes);
 
  if (page_size == 0) page_size = 256;
  addrshift = 0;
  use_ext_addr = 0;
 
  // determine which command is to be used
  if (strcmp(m->desc, "flash") == 0) {
    addrshift = 1;
    commandbuf[0] = CMD_PROGRAM_FLASH_ISP;
    /*
     * If bit 31 is set, this indicates that the following read/write
     * operation will be performed on a memory that is larger than
     * 64KBytes. This is an indication to STK500 that a load extended
     * address must be executed.
     */
    if (m->op[AVR_OP_LOAD_EXT_ADDR] != NULL) {
      use_ext_addr = (1U << 31);
    }
  } else if (strcmp(m->desc, "eeprom") == 0) {
    commandbuf[0] = CMD_PROGRAM_EEPROM_ISP;
  }
  commandbuf[4] = m->delay;
 
  if (addrshift == 0) {
    wop = m->op[AVR_OP_WRITE];
    rop = m->op[AVR_OP_READ];
  }
  else {
    wop = m->op[AVR_OP_WRITE_LO];
    rop = m->op[AVR_OP_READ_LO];
  }
 
  // if the memory is paged, load the appropriate commands into the buffer
  if (m->mode & 0x01) {
    commandbuf[3] = m->mode | 0x80;   // yes, write the page to flash
 
    if (m->op[AVR_OP_LOADPAGE_LO] == NULL) {
      avrdude_message(MSG_INFO, "%s: stk500v2_paged_write: loadpage instruction not defined for part \"%s\"\n",
              progname, p->desc);
      return -1;
    }
    avr_set_bits(m->op[AVR_OP_LOADPAGE_LO], cmds);
    commandbuf[5] = cmds[0];
 
    if (m->op[AVR_OP_WRITEPAGE] == NULL) {
      avrdude_message(MSG_INFO, "%s: stk500v2_paged_write: write page instruction not defined for part \"%s\"\n",
              progname, p->desc);
      return -1;
    }
    avr_set_bits(m->op[AVR_OP_WRITEPAGE], cmds);
    commandbuf[6] = cmds[0];
 
  // otherwise, we need to load different commands in
  } 
  else {
    commandbuf[3] = m->mode | 0x80;   // yes, write the words to flash
 
    if (wop == NULL) {
      avrdude_message(MSG_INFO, "%s: stk500v2_paged_write: write instruction not defined for part \"%s\"\n",
              progname, p->desc);
      return -1;
    }
    avr_set_bits(wop, cmds);
    commandbuf[5] = cmds[0];
    commandbuf[6] = 0;
  }
 
  // the read command is common to both methods
  if (rop == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_paged_write: read instruction not defined for part \"%s\"\n",
            progname, p->desc);
    return -1;
  }
  avr_set_bits(rop, cmds);
  commandbuf[7] = cmds[0];
 
  commandbuf[8] = m->readback[0];
  commandbuf[9] = m->readback[1];
 
  last_addr=UINT_MAX;   /* impossible address */
 
  for (; addr < maxaddr; addr += prusa3d_semicolon_workaround_round2 ? 0 : page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
 
    DEBUG("block_size at addr %d is %d\n",addr,block_size);
 
    memcpy(buf,commandbuf,sizeof(commandbuf));
 
    buf[1] = block_size >> 8;
    buf[2] = block_size & 0xff;
 
    if((last_addr==UINT_MAX)||(last_addr+block_size != addr)||prusa3d_semicolon_workaround_round2){
      if (stk500v2_loadaddr(pgm, use_ext_addr | (addr >> addrshift)) < 0)
        return -1;
    }
    last_addr=addr;
 
    if (prusa3d_semicolon_workaround_round2) {
        // printf("Round 2: address %d\r\n", addr);
        memcpy(buf+10, prusa3d_semicolon_workaround_round2_data, block_size);
        prusa3d_semicolon_workaround_round2 = false;
    } else {
        for (size_t i = 0; i < block_size; ++ i) {
            unsigned char b = m->buf[addr+i];
            if (b == ';') {
              // printf("semicolon at %d %d\r\n", addr, i);
              prusa3d_semicolon_workaround_round2_data[i] = b | 0x0f0;
              b |= 0x0f;
              prusa3d_semicolon_workaround_round2 = true;
            } else 
              prusa3d_semicolon_workaround_round2_data[i] = 0x0ff;
            buf[i+10] = b;
        }
    }
 
    result = stk500v2_command(pgm,buf,block_size+10, sizeof(buf));
    if (result < 0) {
      avrdude_message(MSG_INFO, "%s: stk500v2_paged_write: write command failed\n",
                      progname);
      return -1;
    }
  }
 
  return n_bytes;
}

References AVR_OP_LOAD_EXT_ADDR, AVR_OP_LOADPAGE_LO, AVR_OP_READ, AVR_OP_READ_LO, AVR_OP_WRITE, AVR_OP_WRITE_LO, AVR_OP_WRITEPAGE, avr_set_bits(), avrdude_message(), avrmem::buf, CMD_PROGRAM_EEPROM_ISP, CMD_PROGRAM_FLASH_ISP, DEBUG, avrmem::delay, avrpart::desc, avrmem::desc, avrmem::mode, MSG_INFO, avrmem::op, pgm, progname, avrmem::readback, stk500v2_command(), and stk500v2_loadaddr().

Referenced by stk500isp_write_byte(), stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_perform_osccal()

static int stk500v2_perform_osccal ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[32];
  int rv;
 
  buf[0] = CMD_OSCCAL;
 
  rv = stk500v2_command(pgm, buf, 1, sizeof(buf));
  if (rv < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_perform_osccal(): failed\n",
            progname);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMD_OSCCAL, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), and stk600_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_print_parms()

static void stk500v2_print_parms ( PROGRAMMER *  pgm )

static

{
  stk500v2_print_parms1(pgm, "");
}

References pgm, and stk500v2_print_parms1().

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_print_parms1()

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

static

{
  unsigned char vtarget = 0;
  unsigned char vadjust = 0;
  unsigned char sck_duration = 0;
  unsigned char osc_pscale = 0;
  unsigned char osc_cmatch = 0;
  unsigned varef = 0;
  unsigned sck_stk600 = 0;
  unsigned clock_conf = 0;
  unsigned dac, oct;
  // unsigned char vtarget_jtag[4];
  int prescale;
  double f;
  const char *unit;
  // void *mycookie;
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII) {
    return;
    // mycookie = pgm->cookie;
    // pgm->cookie = PDATA(pgm)->chained_pdata;
    // jtagmkII_getparm(pgm, PAR_OCD_VTARGET, vtarget_jtag);
    // pgm->cookie = mycookie;
    // avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p,
     //  b2_to_u16(vtarget_jtag) / 1000.0);
  } else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3) {
    return;
    // mycookie = pgm->cookie;
    // pgm->cookie = PDATA(pgm)->chained_pdata;
    // jtag3_getparm(pgm, SCOPE_GENERAL, 1, PARM3_VTARGET, vtarget_jtag, 2);
    // pgm->cookie = mycookie;
    // avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p,
     //  b2_to_u16(vtarget_jtag) / 1000.0);
 
  } else {
    stk500v2_getparm(pgm, PARAM_VTARGET, &vtarget);
    avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p, vtarget / 10.0);
  }
 
  switch (PDATA(pgm)->pgmtype) {
  case PGMTYPE_STK500:
    stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration);
    stk500v2_getparm(pgm, PARAM_VADJUST, &vadjust);
    stk500v2_getparm(pgm, PARAM_OSC_PSCALE, &osc_pscale);
    stk500v2_getparm(pgm, PARAM_OSC_CMATCH, &osc_cmatch);
    avrdude_message(MSG_INFO, "%sSCK period      : %.1f us\n", p,
      stk500v2_sck_to_us(pgm, sck_duration));
    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 {
      prescale = 1;
      f = STK500V2_XTAL / 2;
 
      switch (osc_pscale) {
        case 2: prescale = 8; break;
        case 3: prescale = 32; break;
        case 4: prescale = 64; break;
        case 5: prescale = 128; break;
        case 6: prescale = 256; break;
        case 7: prescale = 1024; break;
      }
      f /= prescale;
      f /= (osc_cmatch + 1);
      f = f_to_kHz_MHz(f, &unit);
      avrdude_message(MSG_INFO, "%.3f %s\n", f, unit);
    }
    break;
 
  case PGMTYPE_AVRISP_MKII:
  case PGMTYPE_JTAGICE_MKII:
    stk500v2_getparm(pgm, PARAM_SCK_DURATION, &sck_duration);
    avrdude_message(MSG_INFO, "%sSCK period      : %.2f us\n", p,
      (float) 1000000 / avrispmkIIfreqs[sck_duration]);
    break;
 
  case PGMTYPE_JTAGICE3:
    {
      unsigned char cmd[4];
 
      cmd[0] = CMD_GET_SCK;
      if (stk500v2_jtag3_send(pgm, cmd, 1) >= 0 &&
    stk500v2_jtag3_recv(pgm, cmd, 4) >= 2) {
  unsigned int sck = cmd[1] | (cmd[2] << 8);
  avrdude_message(MSG_INFO, "%sSCK period      : %.2f us\n", p,
    (float)(1E6 / (1000.0 * sck)));
      }
    }
    break;
 
  case PGMTYPE_STK600:
    stk500v2_getparm2(pgm, PARAM2_AREF0, &varef);
    avrdude_message(MSG_INFO, "%sVaref 0         : %.2f V\n", p, varef / 100.0);
    stk500v2_getparm2(pgm, PARAM2_AREF1, &varef);
    avrdude_message(MSG_INFO, "%sVaref 1         : %.2f V\n", p, varef / 100.0);
    stk500v2_getparm2(pgm, PARAM2_SCK_DURATION, &sck_stk600);
    avrdude_message(MSG_INFO, "%sSCK period      : %.2f us\n", p,
      (float) (sck_stk600 + 1) / 8.0);
    stk500v2_getparm2(pgm, PARAM2_CLOCK_CONF, &clock_conf);
    oct = (clock_conf & 0xf000) >> 12u;
    dac = (clock_conf & 0x0ffc) >> 2u;
    f = pow(2, (double)oct) * 2078.0 / (2 - (double)dac / 1024.0);
    f = f_to_kHz_MHz(f, &unit);
    avrdude_message(MSG_INFO, "%sOscillator      : %.3f %s\n",
            p, f, unit);
    break;
 
  default:
    avrdude_message(MSG_INFO, "%sSCK period      : %.1f us\n", p,
    sck_duration * 8.0e6 / STK500V2_XTAL + 0.05);
    break;
  }
 
  return;
}

References avrdude_message(), avrispmkIIfreqs, cmd, CMD_GET_SCK, f_to_kHz_MHz(), MSG_INFO, PARAM2_AREF0, PARAM2_AREF1, PARAM2_CLOCK_CONF, PARAM2_SCK_DURATION, PARAM_OSC_CMATCH, PARAM_OSC_PSCALE, PARAM_SCK_DURATION, PARAM_VADJUST, PARAM_VTARGET, PDATA, pgm, stk500v2_getparm(), stk500v2_getparm2(), stk500v2_jtag3_recv(), stk500v2_jtag3_send(), stk500v2_sck_to_us(), and STK500V2_XTAL.

Referenced by stk500v2_display(), and stk500v2_print_parms().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_program_enable()

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

static

{
  unsigned char buf[16];
  char msg[100];             /* see remarks above about size needed */
  int rv;
  // int tries;
 
  PDATA(pgm)->lastpart = p;
 
  if (p->op[AVR_OP_PGM_ENABLE] == NULL) {
    avrdude_message(MSG_INFO, "%s: stk500v2_program_enable(): program enable instruction not defined for part \"%s\"\n",
      progname, p->desc);
    return -1;
  }
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_STK500 ||
      PDATA(pgm)->pgmtype == PGMTYPE_STK600)
      /* Activate AVR-style (low active) RESET */
      stk500v2_setparm_real(pgm, PARAM_RESET_POLARITY, 0x01);
 
  // tries = 0;
// retry:
  buf[0] = CMD_ENTER_PROGMODE_ISP;
  buf[1] = p->timeout;
  buf[2] = p->stabdelay;
  buf[3] = p->cmdexedelay;
  buf[4] = p->synchloops;
  buf[5] = p->bytedelay;
  buf[6] = p->pollvalue;
  buf[7] = p->pollindex;
  avr_set_bits(p->op[AVR_OP_PGM_ENABLE], buf+8);
  buf[10] = buf[11] = 0;
 
  rv = stk500v2_command(pgm, buf, 12, sizeof(buf));
 
  if (rv < 0) {
    switch (PDATA(pgm)->pgmtype)
    {
    case PGMTYPE_STK600:
    case PGMTYPE_AVRISP_MKII:
        if (stk500v2_getparm(pgm, PARAM_STATUS_TGT_CONN, &buf[0]) != 0) {
            avrdude_message(MSG_INFO, "%s: stk500v2_program_enable(): cannot get connection status\n",
                            progname);
        } else {
            stk500v2_translate_conn_status(buf[0], msg);
            avrdude_message(MSG_INFO, "%s: stk500v2_program_enable():"
                    " bad AVRISPmkII connection status: %s\n",
                    progname, msg);
        }
        break;
 
    case PGMTYPE_JTAGICE3:
        return -1;
        // if (buf[1] == STATUS_CMD_FAILED &&
        //     (p->flags & AVRPART_HAS_DW) != 0) {
        //     void *mycookie;
        //     unsigned char cmd[4], *resp;
 
        //     /* Try debugWIRE, and MONCON_DISABLE */
        //     avrdude_message(MSG_NOTICE2, "%s: No response in ISP mode, trying debugWIRE\n",
        //                         progname);
 
        //     mycookie = pgm->cookie;
        //     pgm->cookie = PDATA(pgm)->chained_pdata;
 
        //     cmd[0] = PARM3_CONN_DW;
        //     if (jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CONNECTION, cmd, 1) < 0) {
        //         pgm->cookie = mycookie;
        //         break;
        //     }
 
        //     cmd[0] = SCOPE_AVR;
 
        //     cmd[1] = CMD3_SIGN_ON;
        //     cmd[2] = cmd[3] = 0;
        //     if (jtag3_command(pgm, cmd, 4, &resp, "AVR sign-on") >= 0) {
        //         free(resp);
 
        //         cmd[1] = CMD3_START_DW_DEBUG;
        //         if (jtag3_command(pgm, cmd, 4, &resp, "start DW debug") >= 0) {
        //             free(resp);
 
        //             cmd[1] = CMD3_MONCON_DISABLE;
        //             if (jtag3_command(pgm, cmd, 3, &resp, "MonCon disable") >= 0)
        //                 free(resp);
        //         }
        //     }
        //     pgm->cookie = mycookie;
        //     if (tries++ > 3) {
        //         avrdude_message(MSG_INFO, "%s: Failed to return from debugWIRE to ISP.\n",
        //                         progname);
        //         break;
        //     }
        //     avrdude_message(MSG_INFO, "%s: Target prepared for ISP, signed off.\n"
        //                     "%s: Now retrying without power-cycling the target.\n",
        //                     progname, progname);
        //     goto retry;
        // }
        break;
 
    default:
        /* cannot report anything for other pgmtypes */
        break;
    }
  }
 
  return rv;
}

References AVR_OP_PGM_ENABLE, avr_set_bits(), avrdude_message(), avrpart::bytedelay, CMD_ENTER_PROGMODE_ISP, avrpart::cmdexedelay, avrpart::desc, MSG_INFO, avrpart::op, PARAM_RESET_POLARITY, PARAM_STATUS_TGT_CONN, PDATA, pgm, avrpart::pollindex, avrpart::pollvalue, progname, avrpart::stabdelay, stk500v2_command(), stk500v2_getparm(), stk500v2_setparm_real(), stk500v2_translate_conn_status(), avrpart::synchloops, and avrpart::timeout.

Referenced by stk500v2_dragon_isp_initpgm(), stk500v2_initpgm(), stk500v2_jtag3_initpgm(), stk500v2_jtagmkII_initpgm(), stk600_initpgm(), and stk600_setup_isp().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_recv()

static int stk500v2_recv ( PROGRAMMER *  pgm, unsigned char *  msg, size_t  maxsize  )

static

                                                                               {
  enum states { sINIT, sSTART, sSEQNUM, sSIZE1, sSIZE2, sTOKEN, sDATA, sCSUM, sDONE }  state = sSTART;
  unsigned int msglen = 0;
  unsigned int curlen = 0;
  int timeout = 0;
  unsigned char c, checksum = 0;
 
  /*
   * The entire timeout handling here is not very consistent, see
   *
   * https://savannah.nongnu.org/bugs/index.php?43626
   */
  long timeoutval = SERIAL_TIMEOUT;   // seconds
  struct timeval tv;
  double tstart, tnow;
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
      PDATA(pgm)->pgmtype == PGMTYPE_STK600)
    return stk500v2_recv_mk2(pgm, msg, maxsize);
  else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
    return stk500v2_jtagmkII_recv(pgm, msg, maxsize);
  else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
    return stk500v2_jtag3_recv(pgm, msg, maxsize);
 
  DEBUG("STK500V2: stk500v2_recv(): ");
 
  gettimeofday(&tv, NULL);
  tstart = tv.tv_sec;
 
  while ( (state != sDONE ) && (!timeout) ) {
    RETURN_IF_CANCEL();
    if (serial_recv(&pgm->fd, &c, 1) < 0)
      goto timedout;
    DEBUG("0x%02x ",c);
    checksum ^= c;
 
    switch (state) {
      case sSTART:
        DEBUGRECV("hoping for start token...");
        if (c == MESSAGE_START) {
          DEBUGRECV("got it\n");
          checksum = MESSAGE_START;
          state = sSEQNUM;
        } else
          DEBUGRECV("sorry\n");
        break;
      case sSEQNUM:
        DEBUGRECV("hoping for sequence...\n");
        if (c == PDATA(pgm)->command_sequence) {
          DEBUGRECV("got it, incrementing\n");
          state = sSIZE1;
          PDATA(pgm)->command_sequence++;
        } else {
          DEBUGRECV("sorry\n");
          state = sSTART;
        }
        break;
      case sSIZE1:
        DEBUGRECV("hoping for size LSB\n");
        msglen = (unsigned)c * 256;
        state = sSIZE2;
        break;
      case sSIZE2:
        DEBUGRECV("hoping for size MSB...");
        msglen += (unsigned)c;
        DEBUG(" msg is %u bytes\n",msglen);
        state = sTOKEN;
        break;
      case sTOKEN:
        if (c == TOKEN) state = sDATA;
        else state = sSTART;
        break;
      case sDATA:
        if (curlen < maxsize) {
          msg[curlen] = c;
        } else {
          avrdude_message(MSG_INFO, "%s: stk500v2_recv(): buffer too small, received %d byte into %u byte buffer\n",
                  progname,curlen,(unsigned int)maxsize);
          return -2;
        }
        if ((curlen == 0) && (msg[0] == ANSWER_CKSUM_ERROR)) {
          avrdude_message(MSG_INFO, "%s: stk500v2_recv(): previous packet sent with wrong checksum\n",
                  progname);
          return -3;
        }
        curlen++;
        if (curlen == msglen) state = sCSUM;
        break;
      case sCSUM:
        if (checksum == 0) {
          state = sDONE;
        } else {
          state = sSTART;
          avrdude_message(MSG_INFO, "%s: stk500v2_recv(): checksum error\n",
                  progname);
          return -4;
        }
        break;
      default:
        avrdude_message(MSG_INFO, "%s: stk500v2_recv(): unknown state\n",
                progname);
        return -5;
     } /* switch */
 
     gettimeofday(&tv, NULL);
     tnow = tv.tv_sec;
     if (tnow-tstart > timeoutval) {      // wuff - signed/unsigned/overflow
      timedout:
       avrdude_message(MSG_INFO, "%s: stk500v2_recv(): timeout\n",
               progname);
       return -1;
     }
 
  } /* while */
  DEBUG("\n");
 
  return (int)(msglen+6);
}

References ANSWER_CKSUM_ERROR, avrdude_message(), DEBUG, DEBUGRECV, programmer_t::fd, gettimeofday(), MESSAGE_START, MSG_INFO, PDATA, pgm, progname, RETURN_IF_CANCEL, serial_recv, SERIAL_TIMEOUT, stk500v2_jtag3_recv(), stk500v2_jtagmkII_recv(), and stk500v2_recv_mk2().

Referenced by stk500v2_command(), and stk500v2_getsync().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_recv_mk2()

static int stk500v2_recv_mk2 ( PROGRAMMER *  pgm, unsigned char *  msg, size_t  maxsize  )

static

{
  int rv;
 
  rv = serial_recv(&pgm->fd, msg, maxsize);
  if (rv < 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_recv_mk2: error in USB receive\n", progname);
    return -1;
  }
 
  return rv;
}

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

Referenced by stk500v2_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_sck_to_us()

static double stk500v2_sck_to_us ( PROGRAMMER *  pgm, unsigned char  dur  )

static

{
  double x;
 
  if (dur == 0)
    return 0.5425;
  if (dur == 1)
    return 2.17;
  if (dur == 2)
    return 8.68;
  if (dur == 3)
    return 17.36;
 
  x = (double)dur + 10.0 / 12.0;
  x = 1.0 / x;
  x /= 24.0;
  x *= (double)STK500V2_XTAL;
  return 1E6 / x;
}

References STK500V2_XTAL.

Referenced by stk500v2_print_parms1().

Here is the caller graph for this function:

stk500v2_send()

static int stk500v2_send ( PROGRAMMER *  pgm, unsigned char *  data, size_t  len  )

static

{
  unsigned char buf[275 + 6];   // max MESSAGE_BODY of 275 bytes, 6 bytes overhead
  int i;
 
  if (PDATA(pgm)->pgmtype == PGMTYPE_AVRISP_MKII ||
      PDATA(pgm)->pgmtype == PGMTYPE_STK600)
    return stk500v2_send_mk2(pgm, data, len);
  else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE_MKII)
    return stk500v2_jtagmkII_send(pgm, data, len);
  else if (PDATA(pgm)->pgmtype == PGMTYPE_JTAGICE3)
    return stk500v2_jtag3_send(pgm, data, len);
 
  buf[0] = MESSAGE_START;
  buf[1] = PDATA(pgm)->command_sequence;
  buf[2] = (char)(len / 256);
  buf[3] = len % 256;
  buf[4] = TOKEN;
  memcpy(buf+5, data, len);
 
  // calculate the XOR checksum
  buf[5+len] = 0;
  for (i=0;i<5+len;i++)
    buf[5+len] ^= buf[i];
 
  DEBUG("STK500V2: stk500v2_send(");
  for (i=0;i<len+6;i++) DEBUG("0x%02x ",buf[i]);
  DEBUG(", %d)\n",len+6);
 
  if (serial_send(&pgm->fd, buf, len+6) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_send(): failed to send command to serial port\n",progname);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), DEBUG, programmer_t::fd, MESSAGE_START, MSG_INFO, PDATA, pgm, progname, serial_send, stk500v2_jtag3_send(), stk500v2_jtagmkII_send(), stk500v2_send_mk2(), and TOKEN.

Referenced by stk500v2_command(), and stk500v2_getsync().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_send_mk2()

static int stk500v2_send_mk2 ( PROGRAMMER *  pgm, unsigned char *  data, size_t  len  )

static

{
  if (serial_send(&pgm->fd, data, len) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500_send_mk2(): failed to send command to serial port\n",progname);
    return -1;
  }
 
  return 0;
}

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

Referenced by stk500v2_send().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_fosc()

static int stk500v2_set_fosc ( PROGRAMMER *  pgm, double  v  )

static

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

References avrdude_message(), MSG_INFO, PARAM_OSC_CMATCH, PARAM_OSC_PSCALE, pgm, progname, stk500v2_setparm(), and STK500V2_XTAL.

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_sck_period()

static int stk500v2_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned int d;
  unsigned char dur;
  double f = 1 / v;
 
  if (f >= 1.8432E6)
    d = 0;
  else if (f > 460.8E3)
    d = 1;
  else if (f > 115.2E3)
    d = 2;
  else if (f > 57.6E3)
    d = 3;
  else
    d = (unsigned int)ceil(1 / (24 * f / (double)STK500V2_XTAL) - 10.0 / 12.0);
  if (d >= 255)
    d = 254;
  dur = d;
 
  return stk500v2_setparm(pgm, PARAM_SCK_DURATION, dur);
}

References ceil(), PARAM_SCK_DURATION, pgm, stk500v2_setparm(), and STK500V2_XTAL.

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), and stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_sck_period_mk2()

static int stk500v2_set_sck_period_mk2 ( PROGRAMMER *  pgm, double  v  )

static

{
  int i;
 
  for (i = 0; i < sizeof(avrispmkIIfreqs); i++) {
    if (1 / avrispmkIIfreqs[i] >= v)
      break;
  }
 
  avrdude_message(MSG_NOTICE2, "Using p = %.2f us for SCK (param = %d)\n",
      1000000 / avrispmkIIfreqs[i], i);
 
  return stk500v2_setparm(pgm, PARAM_SCK_DURATION, i);
}

References avrdude_message(), avrispmkIIfreqs, MSG_NOTICE2, PARAM_SCK_DURATION, pgm, and stk500v2_setparm().

Referenced by stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_isp_initpgm(), stk500v2_dragon_pp_initpgm(), stk500v2_jtagmkII_initpgm(), and stk500v2_open().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_upload_size()

void stk500v2_set_upload_size	(	PROGRAMMER *	pgm,
		int	size
	)

{
  unsigned char buf[16];
  buf[0] = CMD_SET_UPLOAD_SIZE_PRUSA3D;
  buf[1] = size & 0xff;
  buf[2] = size >> 8;
  buf[3] = size >> 16;
  stk500v2_command(pgm, buf, 4, sizeof(buf));
}

References CMD_SET_UPLOAD_SIZE_PRUSA3D, pgm, and stk500v2_command().

Referenced by stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_varef()

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

static

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

References avrdude_message(), MSG_INFO, PARAM_VADJUST, PARAM_VTARGET, pgm, progname, stk500v2_getparm(), and stk500v2_setparm().

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_set_vtarget()

static int stk500v2_set_vtarget ( PROGRAMMER *  pgm, double  v  )

static

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

References avrdude_message(), MSG_INFO, PARAM_VADJUST, PARAM_VTARGET, pgm, progname, stk500v2_getparm(), and stk500v2_setparm().

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_dragon_hvsp_initpgm(), stk500v2_dragon_pp_initpgm(), and stk500v2_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_setparm()

static int stk500v2_setparm ( PROGRAMMER *  pgm, unsigned char  parm, unsigned char  value  )

static

{
  unsigned char current_value = 0;
  int res;
 
  res = stk500v2_getparm(pgm, parm, &current_value);
  if (res < 0)
    avrdude_message(MSG_INFO, "%s: Unable to get parameter 0x%02x\n", progname, parm);
 
  // don't issue a write if the correct value is already set.
  if (value == current_value) {
    avrdude_message(MSG_NOTICE2, "%s: Skipping parameter write; parameter value already set.\n", progname);
    return 0;
  }
 
  return stk500v2_setparm_real(pgm, parm, value);
}

References avrdude_message(), MSG_INFO, MSG_NOTICE2, pgm, progname, stk500v2_getparm(), and stk500v2_setparm_real().

Referenced by stk500v2_set_fosc(), stk500v2_set_sck_period(), stk500v2_set_sck_period_mk2(), stk500v2_set_varef(), stk500v2_set_vtarget(), and stk600_set_vtarget().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_setparm2()

static int stk500v2_setparm2 ( PROGRAMMER *  pgm, unsigned char  parm, unsigned int  value  )

static

{
  unsigned char buf[32];
 
  buf[0] = CMD_SET_PARAMETER;
  buf[1] = parm;
  buf[2] = value >> 8;
  buf[3] = value;
 
  if (stk500v2_command(pgm, buf, 4, sizeof(buf)) < 0) {
    avrdude_message(MSG_INFO, "\n%s: stk500v2_setparm2(): failed to set parameter 0x%02x\n",
            progname, parm);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMD_SET_PARAMETER, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk600_set_fosc(), stk600_set_sck_period(), stk600_set_varef(), and stk600_set_vtarget().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_setparm_real()

static int stk500v2_setparm_real ( PROGRAMMER *  pgm, unsigned char  parm, unsigned char  value  )

static

{
  unsigned char buf[32];
 
  buf[0] = CMD_SET_PARAMETER;
  buf[1] = parm;
  buf[2] = value;
 
  if (stk500v2_command(pgm, buf, 3, sizeof(buf)) < 0) {
    avrdude_message(MSG_INFO, "\n%s: stk500v2_setparm(): failed to set parameter 0x%02x\n",
            progname, parm);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMD_SET_PARAMETER, MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk500v2_program_enable(), stk500v2_setparm(), and stk600_xprog_program_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_setup()

void stk500v2_setup

(

PROGRAMMER *

pgm

)

{
  if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
    // avrdude_message(MSG_INFO, "%s: stk500v2_setup(): Out of memory allocating private data\n",
    //                 progname);
    // exit(1);
    avrdude_oom("stk500v2_setup(): Out of memory allocating private data\n");
  }
  memset(pgm->cookie, 0, sizeof(struct pdata));
  PDATA(pgm)->command_sequence = 1;
  PDATA(pgm)->boot_start = ULONG_MAX;
}

References avrdude_oom(), programmer_t::cookie, malloc(), PDATA, and pgm.

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), stk600pp_initpgm(), and wiring_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_teardown()

void stk500v2_teardown

(

PROGRAMMER *

pgm

)

{
  free(pgm->cookie);
}

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

Referenced by stk500hvsp_initpgm(), stk500pp_initpgm(), stk500v2_initpgm(), stk600_initpgm(), stk600hvsp_initpgm(), stk600pp_initpgm(), and wiring_teardown().

Here is the call graph for this function:

Here is the caller graph for this function:

stk500v2_translate_conn_status()

static void stk500v2_translate_conn_status ( unsigned char  status, char *  msg  )

static

{
    size_t i;
    int need_comma;
 
    *msg = 0;
    need_comma = 0;
 
    for (i = 0;
         i < sizeof connection_status / sizeof connection_status[0];
         i++)
    {
        if ((status & connection_status[i].state) != 0)
        {
            if (need_comma)
                strcat(msg, ", ");
            strcat(msg, connection_status[i].description);
            need_comma = 1;
        }
    }
    if (*msg == 0)
        sprintf(msg, "Unknown status 0x%02x", status);
}

References connection_status.

Referenced by stk500v2_program_enable().

Here is the caller graph for this function:

stk600_get_cardname()

static const char * stk600_get_cardname ( const struct carddata *  table, size_t  nele, int  id  )

static

{
  const struct carddata *cdp;
 
  if (id == 0xFF)
    /* 0xFF means this card is not present at all. */
    return "Not present";
 
  for (cdp = table; nele > 0; cdp++, nele--)
    if (cdp->id == id)
      return cdp->name;
 
  return "Unknown";
}

References carddata::id, and carddata::name.

Referenced by stk500v2_display().

Here is the caller graph for this function:

stk600_initpgm()

void stk600_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK600");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500v2_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500v2_disable;
  pgm->program_enable = stk500v2_program_enable;
  pgm->chip_erase     = stk500v2_chip_erase;
  pgm->cmd            = stk500v2_cmd;
  pgm->open           = stk600_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500isp_read_byte;
  pgm->write_byte     = stk500isp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500v2_paged_write;
  pgm->paged_load     = stk500v2_paged_load;
  pgm->page_erase     = stk500v2_page_erase;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk600_set_vtarget;
  pgm->set_varef      = stk600_set_varef;
  pgm->set_fosc       = stk600_set_fosc;
  pgm->set_sck_period = stk600_set_sck_period;
  pgm->perform_osccal = stk500v2_perform_osccal;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
}

References 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_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::perform_osccal, 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, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_close(), stk500v2_cmd(), stk500v2_disable(), stk500v2_display(), stk500v2_enable(), stk500v2_initialize(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_perform_osccal(), stk500v2_print_parms(), stk500v2_program_enable(), stk500v2_setup(), stk500v2_teardown(), stk600_open(), stk600_set_fosc(), stk600_set_sck_period(), stk600_set_varef(), stk600_set_vtarget(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk600_open()

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

static

{
  union pinfo pinfo = { .baud = 115200 };
 
  DEBUG("STK500V2: stk600_open()\n");
 
  if (pgm->baudrate)
    pinfo.baud = pgm->baudrate;
 
  PDATA(pgm)->pgmtype = PGMTYPE_UNKNOWN;
 
  /*
   * If the port name starts with "usb", divert the serial routines
   * to the USB ones.  The serial_open() function for USB overrides
   * the meaning of the "baud" parameter to be the USB device ID to
   * search for.
   */
  if (strncmp(port, "usb", 3) == 0) {
#if defined(HAVE_LIBUSB)
    serdev = &usb_serdev_frame;
    pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
    pinfo.usbinfo.flags = 0;
    pinfo.usbinfo.pid = USB_DEVICE_STK600;
    PDATA(pgm)->pgmtype = PGMTYPE_STK600;
    pgm->set_sck_period = stk600_set_sck_period;
    pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_MKII;
    pgm->fd.usb.rep = USBDEV_BULK_EP_READ_STK600;
    pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_STK600;
    pgm->fd.usb.eep = 0;           /* no seperate EP for events */
#else
    avrdude_message(MSG_INFO, "avrdude was compiled without usb support.\n");
    return -1;
#endif
  }
 
  strcpy(pgm->port, port);
  if (serial_open(port, pinfo, &pgm->fd)==-1) {
    return -1;
  }
 
  /*
   * drain any extraneous input
   */
  stk500v2_drain(pgm, 0);
 
  stk500v2_getsync(pgm);
 
  stk500v2_drain(pgm, 0);
 
  if (pgm->bitclock != 0.0) {
    if (pgm->set_sck_period(pgm, pgm->bitclock) != 0) {
      serial_close(&pgm->fd);
      return -1;
    }
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, programmer_t::baudrate, programmer_t::bitclock, DEBUG, programmer_t::fd, MSG_INFO, PDATA, pgm, programmer_t::port, serdev, serial_close, serial_open, programmer_t::set_sck_period, stk500v2_drain(), stk500v2_getsync(), stk600_set_sck_period(), filedescriptor::usb, USB_DEVICE_STK600, usb_serdev_frame, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_STK600, USBDEV_BULK_EP_WRITE_STK600, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_set_fosc()

static int stk600_set_fosc ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned int oct, dac;
 
  oct = (unsigned)(1.443 * log(v / 1039.0));
  dac = (unsigned)(2048.0 - (2078.0 * pow(2, (double)(10 + oct))) / v);
 
  return stk500v2_setparm2(pgm, PARAM2_CLOCK_CONF, (oct << 12) | (dac << 2));
}

References log(), PARAM2_CLOCK_CONF, pgm, and stk500v2_setparm2().

Referenced by stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_set_sck_period()

static int stk600_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned int sck;
 
  sck = (unsigned)ceil((16e6 / (2 * 1.0 / v)) - 1);
 
  if (sck >= 4096)
    sck = 4095;
 
  return stk500v2_setparm2(pgm, PARAM2_SCK_DURATION, sck);
}

References ceil(), PARAM2_SCK_DURATION, pgm, and stk500v2_setparm2().

Referenced by stk600_initpgm(), stk600_open(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_set_varef()

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

static

{
  unsigned char utarg;
  unsigned int uaref;
 
  uaref = (unsigned)((v + 0.0049) * 100);
 
  if (stk500v2_getparm(pgm, PARAM_VTARGET, &utarg) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_varef(): cannot obtain V[target]\n",
                    progname);
    return -1;
  }
 
  if (uaref > (unsigned)utarg * 10) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_varef(): V[aref] must not be greater than "
                    "V[target] = %.1f\n",
                    progname, utarg / 10.0);
    return -1;
  }
 
  switch (chan)
  {
  case 0:
    return stk500v2_setparm2(pgm, PARAM2_AREF0, uaref);
 
  case 1:
    return stk500v2_setparm2(pgm, PARAM2_AREF1, uaref);
 
  default:
    avrdude_message(MSG_INFO, "%s: stk500v2_set_varef(): invalid channel %d\n",
                    progname, chan);
    return -1;
  }
}

References avrdude_message(), MSG_INFO, PARAM2_AREF0, PARAM2_AREF1, PARAM_VTARGET, pgm, progname, stk500v2_getparm(), and stk500v2_setparm2().

Referenced by stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_set_vtarget()

static int stk600_set_vtarget ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned char utarg;
  unsigned int uaref;
  int rv;
 
  utarg = (unsigned)((v + 0.049) * 10);
 
  if (stk500v2_getparm2(pgm, PARAM2_AREF0, &uaref) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_vtarget(): cannot obtain V[aref][0]\n",
                    progname);
    return -1;
  }
 
  if (uaref > (unsigned)utarg * 10) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_vtarget(): reducing V[aref][0] from %.2f to %.1f\n",
                    progname, uaref / 100.0, v);
    uaref = 10 * (unsigned)utarg;
    if (stk500v2_setparm2(pgm, PARAM2_AREF0, uaref)
  != 0)
      return -1;
  }
 
  if (stk500v2_getparm2(pgm, PARAM2_AREF1, &uaref) != 0) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_vtarget(): cannot obtain V[aref][1]\n",
                    progname);
    return -1;
  }
 
  if (uaref > (unsigned)utarg * 10) {
    avrdude_message(MSG_INFO, "%s: stk500v2_set_vtarget(): reducing V[aref][1] from %.2f to %.1f\n",
                    progname, uaref / 100.0, v);
    uaref = 10 * (unsigned)utarg;
    if (stk500v2_setparm2(pgm, PARAM2_AREF1, uaref)
  != 0)
      return -1;
  }
 
  /*
   * Vtarget on the STK600 can only be adjusted while not being in
   * programming mode.
   */
  if (PDATA(pgm)->lastpart)
      pgm->disable(pgm);
  rv = stk500v2_setparm(pgm, PARAM_VTARGET, utarg);
  if (PDATA(pgm)->lastpart)
      pgm->program_enable(pgm, PDATA(pgm)->lastpart);
 
  return rv;
}

References avrdude_message(), programmer_t::disable, MSG_INFO, PARAM2_AREF0, PARAM2_AREF1, PARAM_VTARGET, PDATA, pgm, progname, programmer_t::program_enable, stk500v2_getparm2(), stk500v2_setparm(), and stk500v2_setparm2().

Referenced by stk600_initpgm(), stk600hvsp_initpgm(), and stk600pp_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_setup_isp()

static void stk600_setup_isp ( PROGRAMMER *  pgm )

static

{
    pgm->program_enable = stk500v2_program_enable;
    pgm->disable = stk500v2_disable;
    pgm->read_byte = stk500isp_read_byte;
    pgm->write_byte = stk500isp_write_byte;
    pgm->paged_load = stk500v2_paged_load;
    pgm->paged_write = stk500v2_paged_write;
    pgm->page_erase = stk500v2_page_erase;
    pgm->chip_erase = stk500v2_chip_erase;
}

References programmer_t::chip_erase, programmer_t::disable, programmer_t::page_erase, programmer_t::paged_load, programmer_t::paged_write, pgm, programmer_t::program_enable, programmer_t::read_byte, stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_disable(), stk500v2_page_erase(), stk500v2_paged_load(), stk500v2_paged_write(), stk500v2_program_enable(), and programmer_t::write_byte.

Referenced by stk500v2_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_setup_xprog()

static void stk600_setup_xprog ( PROGRAMMER *  pgm )

static

{
    pgm->program_enable = stk600_xprog_program_enable;
    pgm->disable = stk600_xprog_disable;
    pgm->read_byte = stk600_xprog_read_byte;
    pgm->write_byte = stk600_xprog_write_byte;
    pgm->paged_load = stk600_xprog_paged_load;
    pgm->paged_write = stk600_xprog_paged_write;
    pgm->page_erase = stk600_xprog_page_erase;
    pgm->chip_erase = stk600_xprog_chip_erase;
}

References programmer_t::chip_erase, programmer_t::disable, programmer_t::page_erase, programmer_t::paged_load, programmer_t::paged_write, pgm, programmer_t::program_enable, programmer_t::read_byte, stk600_xprog_chip_erase(), 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(), and programmer_t::write_byte.

Referenced by stk500v2_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_chip_erase()

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

static

{
    unsigned char b[6];
    AVRMEM *mem;
    unsigned int addr = 0;
 
    if (p->flags & AVRPART_HAS_TPI) {
        if ((mem = avr_locate_mem(p, "flash")) == NULL) {
            avrdude_message(MSG_INFO, "%s: stk600_xprog_chip_erase(): no FLASH definition found for TPI device\n",
                            progname);
            return -1;
        }
        addr = mem->offset + 1;
    }
 
    b[0] = XPRG_CMD_ERASE;
    b[1] = XPRG_ERASE_CHIP;
    b[2] = addr >> 24;
    b[3] = addr >> 16;
    b[4] = addr >> 8;
    b[5] = addr;
    if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
      avrdude_message(MSG_INFO, "%s: stk600_xprog_chip_erase(): XPRG_CMD_ERASE(XPRG_ERASE_CHIP) failed\n",
                            progname);
      return -1;
  }
    return 0;
}

References avr_locate_mem(), avrdude_message(), AVRPART_HAS_TPI, avrpart::flags, MSG_INFO, avrmem::offset, pgm, progname, stk600_xprog_command(), XPRG_CMD_ERASE, and XPRG_ERASE_CHIP.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_command()

static int stk600_xprog_command ( PROGRAMMER *  pgm, unsigned char *  b, unsigned int  cmdsize, unsigned int  responsesize  )

static

{
    unsigned char *newb;
    unsigned int s;
    int rv;
 
    if (cmdsize < responsesize)
        s = responsesize;
    else
        s = cmdsize;
 
    if ((newb = malloc(s + 1)) == 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_cmd(): out of memory\n",
                progname);
        return -1;
    }
 
    newb[0] = CMD_XPROG;
    memcpy(newb + 1, b, cmdsize);
    rv = stk500v2_command(pgm, newb, cmdsize + 1, responsesize + 1);
    if (rv == 0) {
        memcpy(b, newb + 1, responsesize);
    }
 
    free(newb);
 
    return rv;
}

References avrdude_message(), CMD_XPROG, free(), malloc(), MSG_INFO, pgm, progname, and stk500v2_command().

Referenced by stk600_xprog_chip_erase(), stk600_xprog_disable(), stk600_xprog_page_erase(), stk600_xprog_paged_load(), stk600_xprog_paged_write(), stk600_xprog_program_enable(), stk600_xprog_read_byte(), and stk600_xprog_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_disable()

static void stk600_xprog_disable ( PROGRAMMER *  pgm )

static

{
    unsigned char buf[2];
 
    buf[0] = XPRG_CMD_LEAVE_PROGMODE;
    if (stk600_xprog_command(pgm, buf, 1, 2) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_program_disable(): XPRG_CMD_LEAVE_PROGMODE failed\n",
                        progname);
    }
}

References avrdude_message(), MSG_INFO, pgm, progname, stk600_xprog_command(), and XPRG_CMD_LEAVE_PROGMODE.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_memtype()

static unsigned char stk600_xprog_memtype ( PROGRAMMER *  pgm, unsigned long  addr  )

static

{
    if (addr >= PDATA(pgm)->boot_start)
        return XPRG_MEM_TYPE_BOOT;
    else
        return XPRG_MEM_TYPE_APPL;
}

References PDATA, pgm, XPRG_MEM_TYPE_APPL, and XPRG_MEM_TYPE_BOOT.

Referenced by stk600_xprog_page_erase(), stk600_xprog_paged_load(), stk600_xprog_paged_write(), stk600_xprog_read_byte(), and stk600_xprog_write_byte().

Here is the caller graph for this function:

stk600_xprog_page_erase()

static int stk600_xprog_page_erase ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  addr  )

static

{
    unsigned char b[6];
 
    if (strcmp(m->desc, "flash") == 0) {
      b[1] = stk600_xprog_memtype(pgm, addr) == XPRG_MEM_TYPE_APPL?
        XPRG_ERASE_APP_PAGE: XPRG_ERASE_BOOT_PAGE;
    } else if (strcmp(m->desc, "application") == 0 ||
               strcmp(m->desc, "apptable") == 0) {
      b[1] = XPRG_ERASE_APP_PAGE;
    } else if (strcmp(m->desc, "boot") == 0) {
      b[1] = XPRG_ERASE_BOOT_PAGE;
    } else if (strcmp(m->desc, "eeprom") == 0) {
      b[1] = XPRG_ERASE_EEPROM_PAGE;
    } else if (strcmp(m->desc, "usersig") == 0) {
      b[1] = XPRG_ERASE_USERSIG;
    } else {
      avrdude_message(MSG_INFO, "%s: stk600_xprog_page_erase(): unknown paged memory \"%s\"\n",
                      progname, m->desc);
      return -1;
    }
    addr += m->offset;
    b[0] = XPRG_CMD_ERASE;
    b[2] = addr >> 24;
    b[3] = addr >> 16;
    b[4] = addr >> 8;
    b[5] = addr;
    if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
      avrdude_message(MSG_INFO, "%s: stk600_xprog_page_erase(): XPRG_CMD_ERASE(%d) failed\n",
                            progname, b[1]);
      return -1;
  }
    return 0;
}

References avrdude_message(), avrmem::desc, MSG_INFO, avrmem::offset, pgm, progname, stk600_xprog_command(), stk600_xprog_memtype(), XPRG_CMD_ERASE, XPRG_ERASE_APP_PAGE, XPRG_ERASE_BOOT_PAGE, XPRG_ERASE_EEPROM_PAGE, XPRG_ERASE_USERSIG, and XPRG_MEM_TYPE_APPL.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_paged_load()

static int stk600_xprog_paged_load ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes  )

static

{
    unsigned char *b;
    unsigned int offset;
    unsigned char memtype;
    int n_bytes_orig = n_bytes, dynamic_memtype = 0;
    unsigned long use_ext_addr = 0;
 
    /*
     * The XPROG read command supports at most 256 bytes in one
     * transfer.
     */
    if (page_size > 256)
  page_size = 256;  /* not really a page size anymore */
 
    /*
     * Fancy offsets everywhere.
     * This is probably what AVR079 means when writing about the
     * "TIF address space".
     */
    if (strcmp(mem->desc, "flash") == 0) {
        memtype = 0;
        dynamic_memtype = 1;
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "application") == 0 ||
               strcmp(mem->desc, "apptable") == 0) {
        memtype = XPRG_MEM_TYPE_APPL;
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "boot") == 0) {
        memtype = XPRG_MEM_TYPE_BOOT;
        // Do we have to consider the total amount of flash
        // instead to decide whether to use extended addressing?
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "eeprom") == 0) {
        memtype = XPRG_MEM_TYPE_EEPROM;
    } else if (strcmp(mem->desc, "signature") == 0) {
        memtype = XPRG_MEM_TYPE_APPL;
    } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
        memtype = XPRG_MEM_TYPE_FUSE;
    } else if (strncmp(mem->desc, "lock", strlen("lock")) == 0) {
        memtype = XPRG_MEM_TYPE_LOCKBITS;
    } else if (strcmp(mem->desc, "calibration") == 0) {
        memtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
    } else if (strcmp(mem->desc, "usersig") == 0) {
        memtype = XPRG_MEM_TYPE_USERSIG;
    } else {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_load(): unknown paged memory \"%s\"\n",
                        progname, mem->desc);
        return -1;
    }
    offset = addr;
    addr += mem->offset;
 
    if ((b = malloc(page_size + 2)) == NULL) {
  avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_load(): out of memory\n",
                        progname);
        return -1;
    }
 
    if (stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
        free(b);
        return -1;
    }
 
    while (n_bytes != 0) {
  if (dynamic_memtype)
      memtype = stk600_xprog_memtype(pgm, addr - mem->offset);
 
  b[0] = XPRG_CMD_READ_MEM;
  b[1] = memtype;
  b[2] = addr >> 24;
  b[3] = addr >> 16;
  b[4] = addr >> 8;
  b[5] = addr;
  b[6] = page_size >> 8;
  b[7] = page_size;
  if (stk600_xprog_command(pgm, b, 8, page_size + 2) < 0) {
      avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_load(): XPRG_CMD_READ_MEM failed\n",
                            progname);
      free(b);
      return -1;
  }
  memcpy(mem->buf + offset, b + 2, page_size);
  if (n_bytes < page_size) {
      n_bytes = page_size;
  }
  offset += page_size;
  addr += page_size;
  n_bytes -= page_size;
    }
    free(b);
 
    return n_bytes_orig;
}

References avrdude_message(), avrmem::buf, avrmem::desc, free(), malloc(), MSG_INFO, avrmem::offset, pgm, progname, avrmem::size, stk500v2_loadaddr(), stk600_xprog_command(), stk600_xprog_memtype(), XPRG_CMD_READ_MEM, XPRG_MEM_TYPE_APPL, XPRG_MEM_TYPE_BOOT, XPRG_MEM_TYPE_EEPROM, XPRG_MEM_TYPE_FACTORY_CALIBRATION, XPRG_MEM_TYPE_FUSE, XPRG_MEM_TYPE_LOCKBITS, and XPRG_MEM_TYPE_USERSIG.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_paged_write()

static int stk600_xprog_paged_write ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned int  page_size, unsigned int  addr, unsigned int  n_bytes  )

static

{
    unsigned char *b;
    unsigned int offset;
    unsigned char memtype;
    int n_bytes_orig = n_bytes, dynamic_memtype = 0;
    size_t writesize;
    unsigned long use_ext_addr = 0;
    unsigned char writemode;
 
    /*
     * The XPROG read command supports at most 256 bytes in one
     * transfer.
     */
    if (page_size > 512) {
  avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): cannot handle page size > 512\n",
                        progname);
  return -1;
    }
 
    /*
     * Fancy offsets everywhere.
     * This is probably what AVR079 means when writing about the
     * "TIF address space".
     */
    if (strcmp(mem->desc, "flash") == 0) {
        memtype = 0;
        dynamic_memtype = 1;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "application") == 0 ||
               strcmp(mem->desc, "apptable") == 0) {
        memtype = XPRG_MEM_TYPE_APPL;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "boot") == 0) {
        memtype = XPRG_MEM_TYPE_BOOT;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
        // Do we have to consider the total amount of flash
        // instead to decide whether to use extended addressing?
        if (mem->size > 64 * 1024)
            use_ext_addr = (1UL << 31);
    } else if (strcmp(mem->desc, "eeprom") == 0) {
        memtype = XPRG_MEM_TYPE_EEPROM;
        writemode = (1 << XPRG_MEM_WRITE_WRITE) | (1 << XPRG_MEM_WRITE_ERASE);
    } else if (strcmp(mem->desc, "signature") == 0) {
        memtype = XPRG_MEM_TYPE_APPL;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
    } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
        memtype = XPRG_MEM_TYPE_FUSE;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
    } else if (strncmp(mem->desc, "lock", strlen("lock")) == 0) {
        memtype = XPRG_MEM_TYPE_LOCKBITS;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
    } else if (strcmp(mem->desc, "calibration") == 0) {
        memtype = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
    } else if (strcmp(mem->desc, "usersig") == 0) {
        memtype = XPRG_MEM_TYPE_USERSIG;
        writemode = (1 << XPRG_MEM_WRITE_WRITE);
    } else {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): unknown paged memory \"%s\"\n",
                        progname, mem->desc);
        return -1;
    }
    offset = addr;
    addr += mem->offset;
 
    if ((b = malloc(page_size + 9)) == NULL) {
  avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): out of memory\n",
                        progname);
        return -1;
    }
 
    if (stk500v2_loadaddr(pgm, use_ext_addr) < 0) {
        free(b);
        return -1;
    }
 
    while (n_bytes != 0) {
 
  if (dynamic_memtype)
      memtype = stk600_xprog_memtype(pgm, addr - mem->offset);
 
  if (page_size > 256) {
      /*
       * AVR079 is not quite clear.  While it suggests that
       * downloading up to 512 bytes (256 words) were OK, it
       * obviously isn't -- 512-byte pages on the ATxmega128A1
       * are getting corrupted when written as a single piece.
       * It writes random junk somewhere beyond byte 256.
       * Splitting it into 256 byte chunks, and only setting the
       * erase page / write page bits in the final chunk helps.
       */
      if (page_size % 256 != 0) {
    avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): page size not multiple of 256\n",
                                progname);
    free(b);
    return -1;
      }
      unsigned int chunk;
      for (chunk = 0; chunk < page_size; chunk += 256) {
                if (n_bytes < 256) {
                    memset(b + 9 + n_bytes, 0xff, 256 - n_bytes);
                    writesize = n_bytes;
                } else {
                    writesize = 256;
                }
    b[0] = XPRG_CMD_WRITE_MEM;
    b[1] = memtype;
    b[2] = writemode;
    b[3] = addr >> 24;
    b[4] = addr >> 16;
    b[5] = addr >> 8;
    b[6] = addr;
    b[7] = 1;
    b[8] = 0;
    memcpy(b + 9, mem->buf + offset, writesize);
    if (stk600_xprog_command(pgm, b, 256 + 9, 2) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): XPRG_CMD_WRITE_MEM failed\n",
                                    progname);
        free(b);
        return -1;
    }
    if (n_bytes < 256)
        n_bytes = 256;
 
    offset += 256;
    addr += 256;
    n_bytes -= 256;
      }
  } else {
      if (n_bytes < page_size) {
    /*
     * This can easily happen if the input file was not a
     * multiple of the page size.
     */
    memset(b + 9 + n_bytes, 0xff, page_size - n_bytes);
                writesize = n_bytes;
            } else {
                writesize = page_size;
            }
      b[0] = XPRG_CMD_WRITE_MEM;
      b[1] = memtype;
      b[2] = writemode;
      b[3] = addr >> 24;
      b[4] = addr >> 16;
      b[5] = addr >> 8;
      b[6] = addr;
      b[7] = page_size >> 8;
      b[8] = page_size;
      memcpy(b + 9, mem->buf + offset, writesize);
      if (stk600_xprog_command(pgm, b, page_size + 9, 2) < 0) {
    avrdude_message(MSG_INFO, "%s: stk600_xprog_paged_write(): XPRG_CMD_WRITE_MEM failed\n",
                                progname);
    free(b);
    return -1;
      }
      if (n_bytes < page_size)
    n_bytes = page_size;
 
      offset += page_size;
      addr += page_size;
      n_bytes -= page_size;
  }
    }
    free(b);
 
    return n_bytes_orig;
}

References avrdude_message(), avrmem::buf, avrmem::desc, free(), malloc(), MSG_INFO, avrmem::offset, pgm, progname, avrmem::size, stk500v2_loadaddr(), stk600_xprog_command(), stk600_xprog_memtype(), XPRG_CMD_WRITE_MEM, XPRG_MEM_TYPE_APPL, XPRG_MEM_TYPE_BOOT, XPRG_MEM_TYPE_EEPROM, XPRG_MEM_TYPE_FACTORY_CALIBRATION, XPRG_MEM_TYPE_FUSE, XPRG_MEM_TYPE_LOCKBITS, XPRG_MEM_TYPE_USERSIG, XPRG_MEM_WRITE_ERASE, and XPRG_MEM_WRITE_WRITE.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_program_enable()

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

static

{
    unsigned char buf[16];
    unsigned int eepagesize = 42;
    unsigned int nvm_base;
    AVRMEM *mem = NULL;
    int use_tpi;
 
    use_tpi = (p->flags & AVRPART_HAS_TPI) != 0;
 
    if (!use_tpi) {
        if (p->nvm_base == 0) {
            avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): no nvm_base parameter for PDI device\n",
                            progname);
            return -1;
        }
        if ((mem = avr_locate_mem(p, "eeprom")) != NULL) {
            if (mem->page_size == 0) {
                avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): no EEPROM page_size parameter for PDI device\n",
                                progname);
                return -1;
            }
            eepagesize = mem->page_size;
        }
    }
 
    buf[0] = CMD_XPROG_SETMODE;
    buf[1] = use_tpi? XPRG_MODE_TPI: XPRG_MODE_PDI;
    if (stk500v2_command(pgm, buf, 2, sizeof(buf)) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): CMD_XPROG_SETMODE(XPRG_MODE_%s) failed\n",
                        progname, use_tpi? "TPI": "PDI");
        return -1;
    }
 
    buf[0] = XPRG_CMD_ENTER_PROGMODE;
    if (stk600_xprog_command(pgm, buf, 1, 2) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): XPRG_CMD_ENTER_PROGMODE failed\n",
                        progname);
        return -1;
    }
 
    if (use_tpi) {
        /*
         * Whatever all that might mean, it matches what AVR Studio
         * does.
         */
        if (stk500v2_setparm_real(pgm, PARAM_DISCHARGEDELAY, 232) < 0)
            return -1;
 
        buf[0] = XPRG_CMD_SET_PARAM;
        buf[1] = XPRG_PARAM_TPI_3;
        buf[2] = 51;
        if (stk600_xprog_command(pgm, buf, 3, 2) < 0) {
            avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): XPRG_CMD_SET_PARAM(XPRG_PARAM_TPI_3) failed\n",
                            progname);
            return -1;
        }
 
        buf[0] = XPRG_CMD_SET_PARAM;
        buf[1] = XPRG_PARAM_TPI_4;
        buf[2] = 50;
        if (stk600_xprog_command(pgm, buf, 3, 2) < 0) {
            avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): XPRG_CMD_SET_PARAM(XPRG_PARAM_TPI_4) failed\n",
                            progname);
            return -1;
        }
    } else {
        buf[0] = XPRG_CMD_SET_PARAM;
        buf[1] = XPRG_PARAM_NVMBASE;
        nvm_base = p->nvm_base;
        /*
         * The 0x01000000 appears to be an indication to the programmer
         * that the respective address is located in IO (i.e., SRAM)
         * memory address space rather than flash.  This is not documented
         * anywhere in AVR079 but matches what AVR Studio does.
         */
        nvm_base |= 0x01000000;
        buf[2] = nvm_base >> 24;
        buf[3] = nvm_base >> 16;
        buf[4] = nvm_base >> 8;
        buf[5] = nvm_base;
        if (stk600_xprog_command(pgm, buf, 6, 2) < 0) {
            avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): XPRG_CMD_SET_PARAM(XPRG_PARAM_NVMBASE) failed\n",
                            progname);
            return -1;
        }
 
        if (mem != NULL) {
            buf[0] = XPRG_CMD_SET_PARAM;
            buf[1] = XPRG_PARAM_EEPPAGESIZE;
            buf[2] = eepagesize >> 8;
            buf[3] = eepagesize;
            if (stk600_xprog_command(pgm, buf, 4, 2) < 0) {
                avrdude_message(MSG_INFO, "%s: stk600_xprog_program_enable(): XPRG_CMD_SET_PARAM(XPRG_PARAM_EEPPAGESIZE) failed\n",
                                progname);
                return -1;
            }
        }
    }
 
    return 0;
}

References avr_locate_mem(), avrdude_message(), AVRPART_HAS_TPI, CMD_XPROG_SETMODE, avrpart::flags, MSG_INFO, avrpart::nvm_base, avrmem::page_size, PARAM_DISCHARGEDELAY, pgm, progname, stk500v2_command(), stk500v2_setparm_real(), stk600_xprog_command(), XPRG_CMD_ENTER_PROGMODE, XPRG_CMD_SET_PARAM, XPRG_MODE_PDI, XPRG_MODE_TPI, XPRG_PARAM_EEPPAGESIZE, XPRG_PARAM_NVMBASE, XPRG_PARAM_TPI_3, and XPRG_PARAM_TPI_4.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_read_byte()

static int stk600_xprog_read_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char *  value  )

static

{
    unsigned char b[8];
 
    if (strcmp(mem->desc, "flash") == 0) {
        b[1] = stk600_xprog_memtype(pgm, addr);
    } else if (strcmp(mem->desc, "application") == 0 ||
               strcmp(mem->desc, "apptable") == 0) {
        b[1] = XPRG_MEM_TYPE_APPL;
    } else if (strcmp(mem->desc, "boot") == 0) {
        b[1] = XPRG_MEM_TYPE_BOOT;
    } else if (strcmp(mem->desc, "eeprom") == 0) {
        b[1] = XPRG_MEM_TYPE_EEPROM;
    } else if (strcmp(mem->desc, "signature") == 0) {
        b[1] = XPRG_MEM_TYPE_APPL;
    } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
        b[1] = XPRG_MEM_TYPE_FUSE;
    } else if (strncmp(mem->desc, "lock", strlen("lock")) == 0) {
        b[1] = XPRG_MEM_TYPE_LOCKBITS;
    } else if (strcmp(mem->desc, "calibration") == 0) {
        b[1] = XPRG_MEM_TYPE_FACTORY_CALIBRATION;
    } else if (strcmp(mem->desc, "usersig") == 0) {
        b[1] = XPRG_MEM_TYPE_USERSIG;
    } else {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_read_byte(): unknown memory \"%s\"\n",
                        progname, mem->desc);
        return -1;
    }
    addr += mem->offset;
 
    b[0] = XPRG_CMD_READ_MEM;
    b[2] = (char)(addr >> 24);
    b[3] = (char)(addr >> 16);
    b[4] = (char)(addr >> 8);
    b[5] = (char)addr;
    b[6] = 0;
    b[7] = 1;
    if (stk600_xprog_command(pgm, b, 8, 3) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_read_byte(): XPRG_CMD_READ_MEM failed\n",
                        progname);
        return -1;
    }
    *value = b[2];
    return 0;
}

References avrdude_message(), avrmem::desc, MSG_INFO, avrmem::offset, pgm, progname, stk600_xprog_command(), stk600_xprog_memtype(), XPRG_CMD_READ_MEM, XPRG_MEM_TYPE_APPL, XPRG_MEM_TYPE_BOOT, XPRG_MEM_TYPE_EEPROM, XPRG_MEM_TYPE_FACTORY_CALIBRATION, XPRG_MEM_TYPE_FUSE, XPRG_MEM_TYPE_LOCKBITS, and XPRG_MEM_TYPE_USERSIG.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600_xprog_write_byte()

static int stk600_xprog_write_byte ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  mem, unsigned long  addr, unsigned char  data  )

static

{
    unsigned char b[9 + 256];
    int need_erase = 0;
    unsigned char write_size = 1;
    unsigned char memcode;
 
    memset(b, 0, sizeof(b));
 
    if (strcmp(mem->desc, "flash") == 0) {
        memcode = stk600_xprog_memtype(pgm, addr);
    } else if (strcmp(mem->desc, "application") == 0 ||
               strcmp(mem->desc, "apptable") == 0) {
        memcode = XPRG_MEM_TYPE_APPL;
    } else if (strcmp(mem->desc, "boot") == 0) {
        memcode = XPRG_MEM_TYPE_BOOT;
    } else if (strcmp(mem->desc, "eeprom") == 0) {
        memcode = XPRG_MEM_TYPE_EEPROM;
    } else if (strncmp(mem->desc, "lock", strlen("lock")) == 0) {
        memcode = XPRG_MEM_TYPE_LOCKBITS;
    } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
        memcode = XPRG_MEM_TYPE_FUSE;
        if (p->flags & AVRPART_HAS_TPI)
            /*
             * TPI devices need a mystic erase prior to writing their
             * fuses.
             */
            need_erase = 1;
    } else if (strcmp(mem->desc, "usersig") == 0) {
        memcode = XPRG_MEM_TYPE_USERSIG;
    } else {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_write_byte(): unknown memory \"%s\"\n",
                        progname, mem->desc);
        return -1;
    }
    addr += mem->offset;
 
    if (need_erase) {
        b[0] = XPRG_CMD_ERASE;
        b[1] = XPRG_ERASE_CONFIG;
        b[2] = mem->offset >> 24;
        b[3] = mem->offset >> 16;
        b[4] = mem->offset >> 8;
        b[5] = mem->offset + 1;
        if (stk600_xprog_command(pgm, b, 6, 2) < 0) {
      avrdude_message(MSG_INFO, "%s: stk600_xprog_chip_erase(): XPRG_CMD_ERASE(XPRG_ERASE_CONFIG) failed\n",
                            progname);
      return -1;
  }
    }
 
    if (p->flags & AVRPART_HAS_TPI) {
        /*
         * Some TPI memories (configuration aka. fuse) require a
         * larger write block size.  We record that as a blocksize in
         * avrdude.conf.
         */
        if (mem->blocksize != 0)
            write_size = mem->blocksize;
    }
 
    b[0] = XPRG_CMD_WRITE_MEM;
    b[1] = memcode;
    b[2] = 0;     /* pagemode: non-paged write */
    b[3] = (char)(addr >> 24);
    b[4] = (char)(addr >> 16);
    b[5] = (char)(addr >> 8);
    b[6] = (char)addr;
    b[7] = 0;
    b[8] = write_size;
    b[9] = data;
    if (stk600_xprog_command(pgm, b, 9 + write_size, 2) < 0) {
        avrdude_message(MSG_INFO, "%s: stk600_xprog_write_byte(): XPRG_CMD_WRITE_MEM failed\n",
                        progname);
        return -1;
    }
    return 0;
}

References avrdude_message(), AVRPART_HAS_TPI, avrmem::blocksize, avrmem::desc, avrpart::flags, MSG_INFO, avrmem::offset, pgm, progname, stk600_xprog_command(), stk600_xprog_memtype(), XPRG_CMD_ERASE, XPRG_CMD_WRITE_MEM, XPRG_ERASE_CONFIG, XPRG_MEM_TYPE_APPL, XPRG_MEM_TYPE_BOOT, XPRG_MEM_TYPE_EEPROM, XPRG_MEM_TYPE_FUSE, XPRG_MEM_TYPE_LOCKBITS, and XPRG_MEM_TYPE_USERSIG.

Referenced by stk600_setup_xprog().

Here is the call graph for this function:

Here is the caller graph for this function:

stk600hvsp_initpgm()

void stk600hvsp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK600HVSP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500hvsp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500hvsp_disable;
  pgm->program_enable = stk500hvsp_program_enable;
  pgm->chip_erase     = stk500hvsp_chip_erase;
  pgm->open           = stk600_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500hvsp_read_byte;
  pgm->write_byte     = stk500hvsp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500hvsp_paged_write;
  pgm->paged_load     = stk500hvsp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk600_set_vtarget;
  pgm->set_varef      = stk600_set_varef;
  pgm->set_fosc       = stk600_set_fosc;
  pgm->set_sck_period = stk600_set_sck_period;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500hvsp_chip_erase(), stk500hvsp_disable(), stk500hvsp_initialize(), stk500hvsp_paged_load(), stk500hvsp_paged_write(), stk500hvsp_program_enable(), stk500hvsp_read_byte(), stk500hvsp_write_byte(), stk500v2_close(), stk500v2_display(), stk500v2_enable(), stk500v2_print_parms(), stk500v2_setup(), stk500v2_teardown(), stk600_open(), stk600_set_fosc(), stk600_set_sck_period(), stk600_set_varef(), stk600_set_vtarget(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

stk600pp_initpgm()

void stk600pp_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "STK600PP");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = stk500pp_initialize;
  pgm->display        = stk500v2_display;
  pgm->enable         = stk500v2_enable;
  pgm->disable        = stk500pp_disable;
  pgm->program_enable = stk500pp_program_enable;
  pgm->chip_erase     = stk500pp_chip_erase;
  pgm->open           = stk600_open;
  pgm->close          = stk500v2_close;
  pgm->read_byte      = stk500pp_read_byte;
  pgm->write_byte     = stk500pp_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = stk500pp_paged_write;
  pgm->paged_load     = stk500pp_paged_load;
  pgm->print_parms    = stk500v2_print_parms;
  pgm->set_vtarget    = stk600_set_vtarget;
  pgm->set_varef      = stk600_set_varef;
  pgm->set_fosc       = stk600_set_fosc;
  pgm->set_sck_period = stk600_set_sck_period;
  pgm->setup          = stk500v2_setup;
  pgm->teardown       = stk500v2_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, 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, stk500pp_chip_erase(), stk500pp_disable(), stk500pp_initialize(), stk500pp_paged_load(), stk500pp_paged_write(), stk500pp_program_enable(), stk500pp_read_byte(), stk500pp_write_byte(), stk500v2_close(), stk500v2_display(), stk500v2_enable(), stk500v2_print_parms(), stk500v2_setup(), stk500v2_teardown(), stk600_open(), stk600_set_fosc(), stk600_set_sck_period(), stk600_set_varef(), stk600_set_vtarget(), programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

Variable Documentation

avrispmkIIfreqs

double avrispmkIIfreqs[]

static

Initial value:

= {
  8000000, 4000000, 2000000, 1000000, 500000, 250000, 125000,
  96386, 89888, 84211, 79208, 74767, 70797, 67227, 64000,
  61069, 58395, 55945, 51613, 49690, 47905, 46243, 43244,
  41885, 39409, 38278, 36200, 34335, 32654, 31129, 29740,
  28470, 27304, 25724, 24768, 23461, 22285, 21221, 20254,
  19371, 18562, 17583, 16914, 16097, 15356, 14520, 13914,
  13224, 12599, 12031, 11511, 10944, 10431, 9963, 9468,
  9081, 8612, 8239, 7851, 7498, 7137, 6809, 6478, 6178,
  5879, 5607, 5359, 5093, 4870, 4633, 4418, 4209, 4019,
  3823, 3645, 3474, 3310, 3161, 3011, 2869, 2734, 2611,
  2484, 2369, 2257, 2152, 2052, 1956, 1866, 1779, 1695,
  1615, 1539, 1468, 1398, 1333, 1271, 1212, 1155, 1101,
  1049, 1000, 953, 909, 866, 826, 787, 750, 715, 682,
  650, 619, 590, 563, 536, 511, 487, 465, 443, 422,
  402, 384, 366, 349, 332, 317, 302, 288, 274, 261,
  249, 238, 226, 216, 206, 196, 187, 178, 170, 162,
  154, 147, 140, 134, 128, 122, 116, 111, 105, 100,
  95.4, 90.9, 86.6, 82.6, 78.7, 75.0, 71.5, 68.2,
  65.0, 61.9, 59.0, 56.3, 53.6, 51.1
}

Referenced by stk500v2_print_parms1(), and stk500v2_set_sck_period_mk2().

[struct]

struct { ... } connection_status[]

Initial value:

=
{
  { STATUS_CONN_FAIL_MOSI, "MOSI fail" },
  { STATUS_CONN_FAIL_RST, "RST fail" },
  { STATUS_CONN_FAIL_SCK, "SCK fail" },
  { STATUS_TGT_NOT_DETECTED, "Target not detected" },
  { STATUS_TGT_REVERSE_INSERTED, "Target reverse inserted" },
}

Referenced by stk500v2_translate_conn_status().

pgmname

const char* pgmname[]

static

Initial value:

=
{
  "unknown",
  "STK500",
  "AVRISP",
  "AVRISP mkII",
  "JTAG ICE mkII",
  "STK600",
  "JTAGICE3",
}

Referenced by stk500v2_display(), and stk500v2_getsync().

routing_cards

const struct carddata routing_cards[]

static

Referenced by stk500v2_display().

socket_cards

const struct carddata socket_cards[]

static

Initial value:

=
{
  { 0x01, "STK600-TQFP48" },
  { 0x02, "STK600-TQFP32" },
  { 0x03, "STK600-TQFP100" },
  { 0x04, "STK600-SOIC" },
  { 0x06, "STK600-TQFP144" },
  { 0x09, "STK600-TinyX3U" },
  { 0x0C, "STK600-TSSOP44" },
  { 0x0D, "STK600-TQFP44" },
  { 0x0E, "STK600-TQFP64-2" },
  { 0x0F, "STK600-ATMEGA2560" },
  { 0x15, "STK600-MLF64" },
  { 0x16, "STK600-ATXMEGAT0" },
  { 0x18, "QT600-ATMEGA324-QM64" },
  { 0x19, "STK600-ATMEGA128RFA1" },
  { 0x1A, "QT600-ATTINY88-QT8" },
  { 0x1B, "QT600-ATXMEGA128A1-QT16" },
  { 0x1C, "QT600-AT32UC3L-QM64" },
  { 0x1D, "STK600-HVE2" },
  { 0x1E, "STK600-ATTINY10" },
  { 0x55, "STK600-TQFP64" },
  { 0x69, "STK600-uC3-144" },
  { 0xF0, "STK600-ATXMEGA1281A1" },
  { 0xF1, "STK600-DIP" },
}

Referenced by stk500v2_display().

stk500hvsp_desc

const char stk500hvsp_desc[] = "Atmel STK500 V2 in high-voltage serial programming mode"

stk500pp_desc

const char stk500pp_desc[] = "Atmel STK500 V2 in parallel programming mode"

stk500v2_desc

const char stk500v2_desc[] = "Atmel STK500 Version 2.x firmware"

stk500v2_dragon_hvsp_desc

const char stk500v2_dragon_hvsp_desc[] = "Atmel AVR Dragon in HVSP mode"

stk500v2_dragon_isp_desc

const char stk500v2_dragon_isp_desc[] = "Atmel AVR Dragon in ISP mode"

stk500v2_dragon_pp_desc

const char stk500v2_dragon_pp_desc[] = "Atmel AVR Dragon in PP mode"

stk500v2_jtag3_desc

const char stk500v2_jtag3_desc[] = "Atmel JTAGICE3 in ISP mode"

stk500v2_jtagmkII_desc

const char stk500v2_jtagmkII_desc[] = "Atmel JTAG ICE mkII in ISP mode"

stk600_desc

const char stk600_desc[] = "Atmel STK600"

stk600hvsp_desc

const char stk600hvsp_desc[] = "Atmel STK600 in high-voltage serial programming mode"

stk600pp_desc

const char stk600pp_desc[] = "Atmel STK600 in parallel programming mode"