#include "ac_cfg.h"
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "crc16.h"
#include "jtagmkII.h"
#include "jtagmkII_private.h"
#include "usbdevs.h"

Include dependency graph for jtagmkII.c:

Classes
struct	pdata

Macros
#define	PDATA(pgm) ((struct pdata *)(pgm->cookie))

#define	OCDEN (1 << 7)

#define	RC(x) { x, #x },

#define	PGM_FL_IS_DW (0x0001)

#define	PGM_FL_IS_PDI (0x0002)

#define	PGM_FL_IS_JTAG (0x0004)

#define	ERROR_SAB 0xFFFFFFFF

#define	MAXTRIES 33

#define	FWVER(maj, min) ((maj << 8) \| (min))

Functions
static int	jtagmkII_open (PROGRAMMER pgm, char port)

static int	jtagmkII_initialize (PROGRAMMER pgm, AVRPART p)

static int	jtagmkII_chip_erase (PROGRAMMER pgm, AVRPART p)

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

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

static int	jtagmkII_reset (PROGRAMMER *pgm, unsigned char flags)

static int	jtagmkII_set_sck_period (PROGRAMMER *pgm, double v)

static int	jtagmkII_setparm (PROGRAMMER pgm, unsigned char parm, unsigned char value)

static void	jtagmkII_print_parms1 (PROGRAMMER pgm, const char p)

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

static unsigned char	jtagmkII_memtype (PROGRAMMER pgm, AVRPART p, unsigned long addr)

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

static int	jtagmkII_open32 (PROGRAMMER pgm, char port)

static void	jtagmkII_close32 (PROGRAMMER *pgm)

static int	jtagmkII_reset32 (PROGRAMMER *pgm, unsigned short flags)

static int	jtagmkII_initialize32 (PROGRAMMER pgm, AVRPART p)

static int	jtagmkII_chip_erase32 (PROGRAMMER pgm, AVRPART p)

static unsigned long	jtagmkII_read_SABaddr (PROGRAMMER *pgm, unsigned long addr, unsigned int prefix)

static int	jtagmkII_write_SABaddr (PROGRAMMER *pgm, unsigned long addr, unsigned int prefix, unsigned long val)

static int	jtagmkII_avr32_reset (PROGRAMMER *pgm, unsigned char val, unsigned char ret1, unsigned char ret2)

static int	jtagmkII_smc_init32 (PROGRAMMER *pgm)

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

static int	jtagmkII_flash_lock32 (PROGRAMMER *pgm, unsigned char lock, unsigned int page)

static int	jtagmkII_flash_erase32 (PROGRAMMER *pgm, unsigned int page)

static int	jtagmkII_flash_write_page32 (PROGRAMMER *pgm, unsigned int page)

static int	jtagmkII_flash_clear_pagebuffer32 (PROGRAMMER *pgm)

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

void	jtagmkII_setup (PROGRAMMER *pgm)

void	jtagmkII_teardown (PROGRAMMER *pgm)

static unsigned long	b4_to_u32 (unsigned char *b)

static unsigned long	b4_to_u32r (unsigned char *b)

static void	u32_to_b4 (unsigned char *b, unsigned long l)

static void	u32_to_b4r (unsigned char *b, unsigned long l)

static unsigned short	b2_to_u16 (unsigned char *b)

static void	u16_to_b2 (unsigned char *b, unsigned short l)

static const char *	jtagmkII_get_rc (unsigned int rc)

static void	jtagmkII_print_memory (unsigned char *b, size_t s)

static void	jtagmkII_prmsg (PROGRAMMER pgm, unsigned char data, size_t len)

int	jtagmkII_send (PROGRAMMER pgm, unsigned char data, size_t len)

static int	jtagmkII_drain (PROGRAMMER *pgm, int display)

static int	jtagmkII_recv_frame (PROGRAMMER pgm, unsigned char msg, unsigned short seqno)

int	jtagmkII_recv (PROGRAMMER pgm, unsigned char *msg)

int	jtagmkII_getsync (PROGRAMMER *pgm, int mode)

static int	jtagmkII_chip_erase_dw (PROGRAMMER pgm, AVRPART p)

static void	jtagmkII_set_devdescr (PROGRAMMER pgm, AVRPART p)

static void	jtagmkII_set_xmega_params (PROGRAMMER pgm, AVRPART p)

static int	jtagmkII_program_enable_INFO (PROGRAMMER pgm, AVRPART p)

static int	jtagmkII_program_enable (PROGRAMMER *pgm)

static int	jtagmkII_program_disable (PROGRAMMER *pgm)

static unsigned char	jtagmkII_get_baud (long baud)

static void	jtagmkII_disable (PROGRAMMER *pgm)

static void	jtagmkII_enable (PROGRAMMER *pgm)

static int	jtagmkII_parseextparms (PROGRAMMER *pgm, LISTID extparms)

static int	jtagmkII_open_dw (PROGRAMMER pgm, char port)

static int	jtagmkII_open_pdi (PROGRAMMER pgm, char port)

static int	jtagmkII_dragon_open (PROGRAMMER pgm, char port)

static int	jtagmkII_dragon_open_dw (PROGRAMMER pgm, char port)

static int	jtagmkII_dragon_open_pdi (PROGRAMMER pgm, char port)

void	jtagmkII_close (PROGRAMMER *pgm)

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

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

int	jtagmkII_getparm (PROGRAMMER pgm, unsigned char parm, unsigned char value)

static void	jtagmkII_display (PROGRAMMER pgm, const char p)

static void	jtagmkII_print_parms (PROGRAMMER *pgm)

void	jtagmkII_initpgm (PROGRAMMER *pgm)

void	jtagmkII_dw_initpgm (PROGRAMMER *pgm)

void	jtagmkII_pdi_initpgm (PROGRAMMER *pgm)

void	jtagmkII_dragon_initpgm (PROGRAMMER *pgm)

void	jtagmkII_dragon_dw_initpgm (PROGRAMMER *pgm)

void	jtagmkII_avr32_initpgm (PROGRAMMER *pgm)

void	jtagmkII_dragon_pdi_initpgm (PROGRAMMER *pgm)

Variables
struct {

unsigned int	code

const char *	descr

}	jtagresults []

const char	jtagmkII_desc [] = "Atmel JTAG ICE mkII"

const char	jtagmkII_dw_desc [] = "Atmel JTAG ICE mkII in debugWire mode"

const char	jtagmkII_pdi_desc [] = "Atmel JTAG ICE mkII in PDI mode"

const char	jtagmkII_dragon_desc [] = "Atmel AVR Dragon in JTAG mode"

const char	jtagmkII_dragon_dw_desc [] = "Atmel AVR Dragon in debugWire mode"

const char	jtagmkII_avr32_desc [] = "Atmel JTAG ICE mkII in AVR32 mode"

const char	jtagmkII_dragon_pdi_desc [] = "Atmel AVR Dragon in PDI mode"

Macro Definition Documentation

◆ ERROR_SAB

#define ERROR_SAB 0xFFFFFFFF

◆ FWVER

#define FWVER	(	maj,
		min
	)	((maj << 8) \| (min))

◆ MAXTRIES

#define MAXTRIES 33

◆ OCDEN

#define OCDEN (1 << 7)

◆ PDATA

#define PDATA ( pgm ) ((struct pdata *)(pgm->cookie))

◆ PGM_FL_IS_DW

#define PGM_FL_IS_DW (0x0001)

◆ PGM_FL_IS_JTAG

#define PGM_FL_IS_JTAG (0x0004)

◆ PGM_FL_IS_PDI

#define PGM_FL_IS_PDI (0x0002)

◆ RC

#define RC ( x ) { x, #x },

Function Documentation

◆ b2_to_u16()

static unsigned short b2_to_u16 ( unsigned char * b )

static

{
  unsigned short l;
  l = b[0];
  l += (unsigned)b[1] << 8;
 
  return l;
}

Referenced by jtagmkII_print_parms1().

Here is the caller graph for this function:

◆ b4_to_u32()

static unsigned long b4_to_u32 ( unsigned char * b )

static

{
  unsigned long l;
  l = b[0];
  l += (unsigned)b[1] << 8;
  l += (unsigned)b[2] << 16;
  l += (unsigned)b[3] << 24;
 
  return l;
}

Referenced by jtagmkII_prmsg().

Here is the caller graph for this function:

◆ b4_to_u32r()

static unsigned long b4_to_u32r ( unsigned char * b )

static

{
  unsigned long l;
  l = b[3];
  l += (unsigned)b[2] << 8;
  l += (unsigned)b[1] << 16;
  l += (unsigned)b[0] << 24;
 
  return l;
}

Referenced by jtagmkII_read_SABaddr().

Here is the caller graph for this function:

◆ jtagmkII_avr32_initpgm()

void jtagmkII_avr32_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "JTAGMKII_AVR32");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize32;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase32;
  pgm->open           = jtagmkII_open32;
  pgm->close          = jtagmkII_close32;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write32;
  pgm->paged_load     = jtagmkII_paged_load32;
  pgm->print_parms    = jtagmkII_print_parms;
  //pgm->set_sck_period = jtagmkII_set_sck_period;
  //pgm->parseextparams = jtagmkII_parseextparms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_JTAG;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase32(), jtagmkII_close32(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_enable(), jtagmkII_initialize32(), jtagmkII_open32(), jtagmkII_paged_load32(), jtagmkII_paged_write32(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, PGM_FL_IS_JTAG, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_avr32_reset()

static int jtagmkII_avr32_reset	(	PROGRAMMER *	pgm,
		unsigned char	val,
		unsigned char	ret1,
		unsigned char	ret2
	)

static

{
  int status;
  unsigned char buf[3], *resp;
 
  avrdude_message(MSG_NOTICE, "%s: jtagmkII_avr32_reset(%2.2x)\n",
          progname, val);
 
  buf[0] = CMND_GET_IR;
  buf[1] = 0x0C;
  status = jtagmkII_send(pgm, buf, 2);
  if(status < 0) return -1;
 
  status = jtagmkII_recv(pgm, &resp);
  if (status != 2 || resp[0] != 0x87 || resp[1] != ret1) {
    avrdude_message(MSG_NOTICE, "%s: jtagmkII_avr32_reset(): "
        "Get_IR, expecting %2.2x but got %2.2x\n",
        progname, ret1, resp[1]);
 
    //return -1;
  }
 
  buf[0] = CMND_GET_xxx;
  buf[1] = 5;
  buf[2] = val;
  status = jtagmkII_send(pgm, buf, 3);
  if(status < 0) return -1;
 
  status = jtagmkII_recv(pgm, &resp);
  if (status != 2 || resp[0] != 0x87 || resp[1] != ret2) {
    avrdude_message(MSG_NOTICE, "%s: jtagmkII_avr32_reset(): "
        "Get_XXX, expecting %2.2x but got %2.2x\n",
        progname, ret2, resp[1]);
    //return -1;
  }
 
  return 0;
}

References avrdude_message(), CMND_GET_IR, CMND_GET_xxx, jtagmkII_recv(), jtagmkII_send(), MSG_NOTICE, pgm, and progname.

Referenced by jtagmkII_chip_erase32(), and jtagmkII_reset32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_chip_erase()

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

static

{
  int status, len;
  unsigned char buf[6], *resp, c;
 
  if (p->flags & AVRPART_HAS_PDI) {
    buf[0] = CMND_XMEGA_ERASE;
    buf[1] = XMEGA_ERASE_CHIP;
    memset(buf + 2, 0, 4);      /* address of area to be erased */
    len = 6;
  } else {
    buf[0] = CMND_CHIP_ERASE;
    len = 1;
  }
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_chip_erase(): Sending %schip erase command: ",
                    progname,
                    (p->flags & AVRPART_HAS_PDI)? "Xmega ": "");
  jtagmkII_send(pgm, buf, len);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_chip_erase(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_chip_erase(): "
                    "bad response to chip erase command: %s\n",
                    progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  if (!(p->flags & AVRPART_HAS_PDI))
      pgm->initialize(pgm, p);
 
  return 0;
}

References avrdude_message(), AVRPART_HAS_PDI, CMND_CHIP_ERASE, CMND_XMEGA_ERASE, avrpart::flags, free(), programmer_t::initialize, jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RSP_OK, verbose, and XMEGA_ERASE_CHIP.

Referenced by jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_chip_erase32()

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

static

{
  int status=0, loops;
  unsigned char *resp, buf[3], x, ret[4], *retP;
  unsigned long val=0;
  unsigned int lineno;
 
  avrdude_message(MSG_NOTICE, "%s: jtagmkII_chip_erase32()\n",
          progname);
 
  status = jtagmkII_reset32(pgm, AVR32_RESET_CHIP_ERASE);
  if(status != 0) {lineno = __LINE__; goto eRR;}
 
  // sequence of IR transitions
  ret[0] = 0x01;
  ret[1] = 0x05;
  ret[2] = 0x01;
  ret[3] = 0x00;
 
  retP = ret;
  for(loops=0; loops<1000; ++loops) {
    buf[0] = CMND_GET_IR;
    buf[1] = 0x0F;
    status = jtagmkII_send(pgm, buf, 2);
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_recv(pgm, &resp);
    if (status != 2 || resp[0] != 0x87) {
      {lineno = __LINE__; goto eRR;}
    }
    x = resp[1];
    free(resp);
    if(x == *retP) ++retP;
    if(*retP == 0x00) break;
  }
  if(loops == 1000) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_avr32_reset(pgm, 0x00, 0x01, 0x01);
  if(status < 0) {lineno = __LINE__; goto eRR;}
 
  val = jtagmkII_read_SABaddr(pgm, 0x00000010, 0x06);
  if(val != 0x00000000) {lineno = __LINE__; goto eRR;}
 
  // AVR32 "special"
  buf[0] = CMND_SET_PARAMETER;
  buf[1] = 0x03;
  buf[2] = 0x02;
  jtagmkII_send(pgm, buf, 3);
  status = jtagmkII_recv(pgm, &resp);
  if(status < 0 || resp[0] != RSP_OK) {lineno = __LINE__; goto eRR;}
  free(resp);
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_reset32(): "
      "failed at line %d (status=%x val=%lx)\n",
      progname, lineno, status, val);
    return -1;
}

References AVR32_RESET_CHIP_ERASE, avrdude_message(), CMND_GET_IR, CMND_SET_PARAMETER, free(), jtagmkII_avr32_reset(), jtagmkII_read_SABaddr(), jtagmkII_recv(), jtagmkII_reset32(), jtagmkII_send(), lineno, MSG_INFO, MSG_NOTICE, pgm, progname, and RSP_OK.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_chip_erase_dw()

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

static

{
 
  avrdude_message(MSG_INFO, "%s: Chip erase not supported in debugWire mode\n",
    progname);
 
  return 0;
}

References avrdude_message(), MSG_INFO, and progname.

Referenced by jtagmkII_dragon_dw_initpgm(), and jtagmkII_dw_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_close()

void jtagmkII_close ( PROGRAMMER * pgm )

{
  int status;
  unsigned char buf[1], *resp, c;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_close()\n", progname);
 
  if (pgm->flag & PGM_FL_IS_PDI) {
    /* When in PDI mode, restart target. */
    buf[0] = CMND_GO;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_close(): Sending GO command: ",
        progname);
    jtagmkII_send(pgm, buf, 1);
 
    status = jtagmkII_recv(pgm, &resp);
    if (status <= 0) {
      if (verbose >= 2)
  putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
                      "timeout/error communicating with programmer (status %d)\n",
                      progname, status);
    } else {
      if (verbose >= 3) {
  putc('\n', stderr);
  jtagmkII_prmsg(pgm, resp, status);
      } else if (verbose == 2)
  avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
      c = resp[0];
      free(resp);
      if (c != RSP_OK) {
  avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
                        "bad response to GO command: %s\n",
                        progname, jtagmkII_get_rc(c));
      }
    }
  }
 
  buf[0] = CMND_SIGN_OFF;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_close(): Sending sign-off command: ",
      progname);
  jtagmkII_send(pgm, buf, 1);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
                    "bad response to sign-off command: %s\n",
                    progname, jtagmkII_get_rc(c));
  }
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

References avrdude_message(), CMND_GO, CMND_SIGN_OFF, programmer_t::fd, programmer_t::flag, free(), filedescriptor::ifd, jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, pgm, PGM_FL_IS_PDI, progname, RSP_OK, serial_close, and verbose.

Referenced by jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_close32()

static void jtagmkII_close32 ( PROGRAMMER * pgm )

static

{
  int status, lineno;
  unsigned char *resp, buf[3], c;
  unsigned long val=0;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_close32()\n", progname);
 
  // AVR32 "special"
  buf[0] = CMND_SET_PARAMETER;
  buf[1] = 0x03;
  buf[2] = 0x02;
  jtagmkII_send(pgm, buf, 3);
  status = jtagmkII_recv(pgm, &resp);
  if(status < 0 || resp[0] != RSP_OK) {lineno = __LINE__; goto eRR;}
  free(resp);
 
  buf[0] = CMND_SIGN_OFF;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_close(): Sending sign-off command: ",
      progname);
  jtagmkII_send(pgm, buf, 1);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
      "timeout/error communicating with programmer (status %d)\n",
      progname, status);
    return;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_close(): "
      "bad response to sign-off command: %s\n",
      progname, jtagmkII_get_rc(c));
  }
 
  ret:
    serial_close(&pgm->fd);
    pgm->fd.ifd = -1;
    return;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_reset32(): "
      "failed at line %d (status=%x val=%lx)\n",
      progname, lineno, status, val);
    goto ret;
}

References avrdude_message(), CMND_SET_PARAMETER, CMND_SIGN_OFF, programmer_t::fd, free(), filedescriptor::ifd, jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), lineno, MSG_INFO, MSG_NOTICE2, pgm, progname, RSP_OK, serial_close, and verbose.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_disable()

static void jtagmkII_disable ( PROGRAMMER * pgm )

static

{
 
  free(PDATA(pgm)->flash_pagecache);
  PDATA(pgm)->flash_pagecache = NULL;
  free(PDATA(pgm)->eeprom_pagecache);
  PDATA(pgm)->eeprom_pagecache = NULL;
 
  /*
   * jtagmkII_program_disable() doesn't do anything if the
   * device is currently not in programming mode, so just
   * call it unconditionally here.
   */
  (void)jtagmkII_program_disable(pgm);
}

References free(), jtagmkII_program_disable(), PDATA, pgm, and void().

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_display()

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

static

{
  unsigned char hw[4], fw[4];
 
  if (jtagmkII_getparm(pgm, PAR_HW_VERSION, hw) < 0 ||
      jtagmkII_getparm(pgm, PAR_FW_VERSION, fw) < 0)
    return;
 
  avrdude_message(MSG_INFO, "%sM_MCU hardware version: %d\n", p, hw[0]);
  avrdude_message(MSG_INFO, "%sM_MCU firmware version: %d.%02d\n", p, fw[1], fw[0]);
  avrdude_message(MSG_INFO, "%sS_MCU hardware version: %d\n", p, hw[1]);
  avrdude_message(MSG_INFO, "%sS_MCU firmware version: %d.%02d\n", p, fw[3], fw[2]);
  avrdude_message(MSG_INFO, "%sSerial number:          %02x:%02x:%02x:%02x:%02x:%02x\n",
    p, PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2], PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
 
  jtagmkII_print_parms1(pgm, p);
 
  return;
}

References avrdude_message(), jtagmkII_getparm(), jtagmkII_print_parms1(), MSG_INFO, PAR_FW_VERSION, PAR_HW_VERSION, PDATA, and pgm.

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_dragon_dw_initpgm()

void jtagmkII_dragon_dw_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "DRAGON_DW");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase_dw;
  pgm->open           = jtagmkII_dragon_open_dw;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_DW;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase_dw(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_dragon_open_dw(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, PGM_FL_IS_DW, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_dragon_initpgm()

void jtagmkII_dragon_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "DRAGON_JTAG");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase;
  pgm->open           = jtagmkII_dragon_open;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->page_erase     = jtagmkII_page_erase;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->set_sck_period = jtagmkII_set_sck_period;
  pgm->parseextparams = jtagmkII_parseextparms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_JTAG;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_dragon_open(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_parseextparms(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_set_sck_period(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::parseextparams, pgm, PGM_FL_IS_JTAG, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_sck_period, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_dragon_open()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_dragon_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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_JTAG) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_JTAG, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_AVRDRAGON, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_dragon_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_dragon_open_dw()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_dragon_open_dw()\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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_DEBUGWIRE) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_DEBUGWIRE, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_AVRDRAGON, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_dragon_dw_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_dragon_open_pdi()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_dragon_open_pdi()\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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_PDI) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_PDI, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_AVRDRAGON, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_dragon_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_dragon_pdi_initpgm()

void jtagmkII_dragon_pdi_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "DRAGON_PDI");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase;
  pgm->open           = jtagmkII_dragon_open_pdi;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->page_erase     = jtagmkII_page_erase;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_PDI;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_dragon_open_pdi(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, PGM_FL_IS_PDI, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_drain()

static int jtagmkII_drain	(	PROGRAMMER *	pgm,
		int	display
	)

static

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by jtagmkII_dragon_open(), jtagmkII_dragon_open_dw(), jtagmkII_dragon_open_pdi(), jtagmkII_open(), jtagmkII_open32(), jtagmkII_open_dw(), and jtagmkII_open_pdi().

Here is the caller graph for this function:

◆ jtagmkII_dw_initpgm()

void jtagmkII_dw_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "JTAGMKII_DW");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase_dw;
  pgm->open           = jtagmkII_open_dw;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_DW;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase_dw(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_open_dw(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, PGM_FL_IS_DW, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_enable()

static void jtagmkII_enable ( PROGRAMMER * pgm )

static

{
  return;
}

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the caller graph for this function:

◆ jtagmkII_flash_clear_pagebuffer32()

static int jtagmkII_flash_clear_pagebuffer32 ( PROGRAMMER * pgm )

static

{
  int status, lineno, i;
  unsigned long val=0, cmd, err;
 
  cmd = AVR32_FLASHC_FCMD_KEY | AVR32_FLASHC_FCMD_CLEAR_PAGE_BUFFER;
  status = jtagmkII_write_SABaddr(pgm, AVR32_FLASHC_FCMD, 0x05, cmd);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  err = 0;
  for(i=0; i<256; ++i) {
    val = jtagmkII_read_SABaddr(pgm, AVR32_FLASHC_FSR, 0x05);
    if(val == ERROR_SAB) continue;
    err |= val;
    if(val & AVR32_FLASHC_FSR_RDY) break;
  }
  if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
  if(!(val & AVR32_FLASHC_FSR_RDY)) {lineno = __LINE__; goto eRR;}
  if(err & AVR32_FLASHC_FSR_ERR) {lineno = __LINE__; goto eRR;}
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_flash_clear_pagebuffer32(): "
      "failed at line %d cmd %8.8lx val %lx\n",
      progname, lineno, cmd, val);
    return -1;
}

References AVR32_FLASHC_FCMD, AVR32_FLASHC_FCMD_CLEAR_PAGE_BUFFER, AVR32_FLASHC_FCMD_KEY, AVR32_FLASHC_FSR, AVR32_FLASHC_FSR_ERR, AVR32_FLASHC_FSR_RDY, avrdude_message(), cmd, ERROR_SAB, jtagmkII_read_SABaddr(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, pgm, and progname.

Referenced by jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_flash_erase32()

static int jtagmkII_flash_erase32	(	PROGRAMMER *	pgm,
		unsigned int	page
	)

static

{
  int status, lineno, i;
  unsigned long val=0, cmd=0, err=0;
 
  for(i=0; i<256; ++i) {
    val = jtagmkII_read_SABaddr(pgm, AVR32_FLASHC_FSR, 0x05);
    if(val == ERROR_SAB) continue;
    if(val & AVR32_FLASHC_FSR_RDY) break;
  }
  if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
  if(!(val&AVR32_FLASHC_FSR_RDY)) {lineno = __LINE__; goto eRR;} // Flash better be ready
 
  page <<= 8;
  cmd = AVR32_FLASHC_FCMD_KEY | page | AVR32_FLASHC_FCMD_ERASE_PAGE;
  status = jtagmkII_write_SABaddr(pgm, AVR32_FLASHC_FCMD, 0x05, cmd);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
//avrdude_message(MSG_INFO, "ERASE %x -> %x\n", cmd, AVR32_FLASHC_FCMD);
 
  err = 0;
  for(i=0; i<256; ++i) {
    val = jtagmkII_read_SABaddr(pgm, AVR32_FLASHC_FSR, 0x05);
    if(val == ERROR_SAB) continue;
    err |= val;
    if(val & AVR32_FLASHC_FSR_RDY) break;
  }
  if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
  if(!(val & AVR32_FLASHC_FSR_RDY)) {lineno = __LINE__; goto eRR;}
  if(err & AVR32_FLASHC_FSR_ERR) {lineno = __LINE__; goto eRR;}
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_flash_erase32(): "
      "failed at line %d page %d cmd %8.8lx val %lx\n",
      progname, lineno, page, cmd, val);
    return -1;
}

References AVR32_FLASHC_FCMD, AVR32_FLASHC_FCMD_ERASE_PAGE, AVR32_FLASHC_FCMD_KEY, AVR32_FLASHC_FSR, AVR32_FLASHC_FSR_ERR, AVR32_FLASHC_FSR_RDY, avrdude_message(), cmd, ERROR_SAB, jtagmkII_read_SABaddr(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, pgm, and progname.

Referenced by jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_flash_lock32()

static int jtagmkII_flash_lock32	(	PROGRAMMER *	pgm,
		unsigned char	lock,
		unsigned int	page
	)

static

{
  int status, lineno, i;
  unsigned long val, cmd=0;
 
  for(i=0; i<256; ++i) {
    val = jtagmkII_read_SABaddr(pgm, AVR32_FLASHC_FSR, 0x05);
    if(val == ERROR_SAB) continue;
    if(val & AVR32_FLASHC_FSR_RDY) break;
  }
  if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
  if(!(val&AVR32_FLASHC_FSR_RDY)) {lineno = __LINE__; goto eRR;} // Flash better be ready
 
  page <<= 8;
  cmd = AVR32_FLASHC_FCMD_KEY | page | (lock ? AVR32_FLASHC_FCMD_LOCK : AVR32_FLASHC_FCMD_UNLOCK);
  status = jtagmkII_write_SABaddr(pgm, AVR32_FLASHC_FCMD, 0x05, cmd);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_flash_lock32(): "
      "failed at line %d page %d cmd %8.8lx\n",
      progname, lineno, page, cmd);
    return -1;
}

References AVR32_FLASHC_FCMD, AVR32_FLASHC_FCMD_KEY, AVR32_FLASHC_FCMD_LOCK, AVR32_FLASHC_FCMD_UNLOCK, AVR32_FLASHC_FSR, AVR32_FLASHC_FSR_RDY, avrdude_message(), cmd, ERROR_SAB, jtagmkII_read_SABaddr(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, pgm, and progname.

Referenced by jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_flash_write_page32()

static int jtagmkII_flash_write_page32	(	PROGRAMMER *	pgm,
		unsigned int	page
	)

static

{
  int status, lineno, i;
  unsigned long val=0, cmd, err;
 
  page <<= 8;
  cmd = AVR32_FLASHC_FCMD_KEY | page | AVR32_FLASHC_FCMD_WRITE_PAGE;
  status = jtagmkII_write_SABaddr(pgm, AVR32_FLASHC_FCMD, 0x05, cmd);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  err = 0;
  for(i=0; i<256; ++i) {
    val = jtagmkII_read_SABaddr(pgm, AVR32_FLASHC_FSR, 0x05);
    if(val == ERROR_SAB) continue;
    err |= val;
    if(val & AVR32_FLASHC_FSR_RDY) break;
  }
  if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
  if(!(val & AVR32_FLASHC_FSR_RDY)) {lineno = __LINE__; goto eRR;}
  if(err & AVR32_FLASHC_FSR_ERR) {lineno = __LINE__; goto eRR;}
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_flash_write_page32(): "
      "failed at line %d page %d cmd %8.8lx val %lx\n",
      progname, lineno, page, cmd, val);
    return -1;
}

References AVR32_FLASHC_FCMD, AVR32_FLASHC_FCMD_KEY, AVR32_FLASHC_FCMD_WRITE_PAGE, AVR32_FLASHC_FSR, AVR32_FLASHC_FSR_ERR, AVR32_FLASHC_FSR_RDY, avrdude_message(), cmd, ERROR_SAB, jtagmkII_read_SABaddr(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, pgm, and progname.

Referenced by jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_get_baud()

static unsigned char jtagmkII_get_baud ( long baud )

static

{
  static struct {
    long baud;
    unsigned char val;
  } baudtab[] = {
    { 2400L, PAR_BAUD_2400 },
    { 4800L, PAR_BAUD_4800 },
    { 9600L, PAR_BAUD_9600 },
    { 19200L, PAR_BAUD_19200 },
    { 38400L, PAR_BAUD_38400 },
    { 57600L, PAR_BAUD_57600 },
    { 115200L, PAR_BAUD_115200 },
    { 14400L, PAR_BAUD_14400 },
  };
  int i;
 
  for (i = 0; i < sizeof baudtab / sizeof baudtab[0]; i++)
    if (baud == baudtab[i].baud)
      return baudtab[i].val;
 
  return 0;
}

References baudtab, PAR_BAUD_115200, PAR_BAUD_14400, PAR_BAUD_19200, PAR_BAUD_2400, PAR_BAUD_38400, PAR_BAUD_4800, PAR_BAUD_57600, and PAR_BAUD_9600.

Referenced by jtagmkII_initialize().

Here is the caller graph for this function:

◆ jtagmkII_get_rc()

static const char * jtagmkII_get_rc ( unsigned int rc )

static

{
  int i;
  static char msg[50];
 
  for (i = 0; i < sizeof jtagresults / sizeof jtagresults[0]; i++)
    if (jtagresults[i].code == rc)
      return jtagresults[i].descr;
 
  sprintf(msg, "Unknown JTAG ICE mkII result code 0x%02x", rc);
  return msg;
}

References jtagresults.

Referenced by jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_close32(), jtagmkII_getparm(), jtagmkII_getsync(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_read_byte(), jtagmkII_reset(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), and jtagmkII_write_byte().

Here is the caller graph for this function:

◆ jtagmkII_getparm()

int jtagmkII_getparm	(	PROGRAMMER *	pgm,
		unsigned char	parm,
		unsigned char *	value
	)

{
  int status;
  unsigned char buf[2], *resp, c;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_getparm()\n", progname);
 
  buf[0] = CMND_GET_PARAMETER;
  buf[1] = parm;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_getparm(): "
      "Sending get parameter command (parm 0x%02x): ",
      progname, parm);
  jtagmkII_send(pgm, buf, 2);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_getparm(): "
      "timeout/error communicating with programmer (status %d)\n",
      progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  if (c != RSP_PARAMETER) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_getparm(): "
      "bad response to get parameter command: %s\n",
      progname, jtagmkII_get_rc(c));
    free(resp);
    return -1;
  }
 
  memcpy(value, resp + 1, 4);
  free(resp);
 
  return 0;
}

References avrdude_message(), CMND_GET_PARAMETER, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RSP_PARAMETER, and verbose.

Referenced by jtagmkII_display(), jtagmkII_print_parms1(), and jtagmkII_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_getsync()

int jtagmkII_getsync	(	PROGRAMMER *	pgm,
		int	mode
	)

                                                 {
  int tries;
#define MAXTRIES 33
  unsigned char buf[3], *resp, c = 0xff;
  int status;
  unsigned int fwver, hwver;
  int is_dragon;
 
  avrdude_message(MSG_DEBUG, "%s: jtagmkII_getsync()\n", progname);
 
  if (strncmp(pgm->type, "JTAG", strlen("JTAG")) == 0) {
    is_dragon = 0;
  } else if (strncmp(pgm->type, "DRAGON", strlen("DRAGON")) == 0) {
    is_dragon = 1;
  } else {
    avrdude_message(MSG_INFO, "%s: Programmer is neither JTAG ICE mkII nor AVR Dragon\n",
                    progname);
    return -1;
  }
  for (tries = 0; tries < MAXTRIES; tries++) {
 
    /* Get the sign-on information. */
    buf[0] = CMND_GET_SIGN_ON;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_getsync(): Sending sign-on command: ",
        progname);
    jtagmkII_send(pgm, buf, 1);
 
    status = jtagmkII_recv(pgm, &resp);
    if (status <= 0) {
  avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): sign-on command: "
    "status %d\n",
    progname, status);
    } else if (verbose >= 3) {
      putc('\n', stderr);
      jtagmkII_prmsg(pgm, resp, status);
    } else if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
 
    if (status > 0) {
      if ((c = resp[0]) == RSP_SIGN_ON) {
  fwver = ((unsigned)resp[8] << 8) | (unsigned)resp[7];
        PDATA(pgm)->fwver = fwver;
  hwver = (unsigned)resp[9];
  memcpy(PDATA(pgm)->serno, resp + 10, 6);
  if (status > 17) {
    avrdude_message(MSG_NOTICE, "JTAG ICE mkII sign-on message:\n");
    avrdude_message(MSG_NOTICE, "Communications protocol version: %u\n",
      (unsigned)resp[1]);
    avrdude_message(MSG_NOTICE, "M_MCU:\n");
    avrdude_message(MSG_NOTICE, "  boot-loader FW version:        %u\n",
      (unsigned)resp[2]);
    avrdude_message(MSG_NOTICE, "  firmware version:              %u.%02u\n",
      (unsigned)resp[4], (unsigned)resp[3]);
    avrdude_message(MSG_NOTICE, "  hardware version:              %u\n",
      (unsigned)resp[5]);
    avrdude_message(MSG_NOTICE, "S_MCU:\n");
    avrdude_message(MSG_NOTICE, "  boot-loader FW version:        %u\n",
      (unsigned)resp[6]);
    avrdude_message(MSG_NOTICE, "  firmware version:              %u.%02u\n",
      (unsigned)resp[8], (unsigned)resp[7]);
    avrdude_message(MSG_NOTICE, "  hardware version:              %u\n",
      (unsigned)resp[9]);
    avrdude_message(MSG_NOTICE, "Serial number:                   "
      "%02x:%02x:%02x:%02x:%02x:%02x\n",
      PDATA(pgm)->serno[0], PDATA(pgm)->serno[1], PDATA(pgm)->serno[2], PDATA(pgm)->serno[3], PDATA(pgm)->serno[4], PDATA(pgm)->serno[5]);
    resp[status - 1] = '\0';
    avrdude_message(MSG_NOTICE, "Device ID:                       %s\n",
      resp + 16);
  }
  break;
      }
      free(resp);
    }
  }
  if (tries >= MAXTRIES) {
    if (status <= 0)
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                      "timeout/error communicating with programmer (status %d)\n",
                      progname, status);
    else
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                      "bad response to sign-on command: %s\n",
                      progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  PDATA(pgm)->device_descriptor_length = sizeof(struct device_descriptor);
  /*
   * There's no official documentation from Atmel about what firmware
   * revision matches what device descriptor length.  The algorithm
   * below has been found empirically.
   */
#define FWVER(maj, min) ((maj << 8) | (min))
  if (!is_dragon && fwver < FWVER(3, 16)) {
    PDATA(pgm)->device_descriptor_length -= 2;
    avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                    "S_MCU firmware version might be too old to work correctly\n",
                    progname);
  } else if (!is_dragon && fwver < FWVER(4, 0)) {
    PDATA(pgm)->device_descriptor_length -= 2;
  }
  if (mode != EMULATOR_MODE_SPI)
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_getsync(): Using a %u-byte device descriptor\n",
                    progname, (unsigned)PDATA(pgm)->device_descriptor_length);
  if (mode == EMULATOR_MODE_SPI) {
    PDATA(pgm)->device_descriptor_length = 0;
    if (!is_dragon && fwver < FWVER(4, 14)) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): ISP functionality requires firmware "
                      "version >= 4.14\n",
                      progname);
      return -1;
    }
  }
  if (mode == EMULATOR_MODE_PDI || mode == EMULATOR_MODE_JTAG_XMEGA) {
    if (!is_dragon && mode == EMULATOR_MODE_PDI && hwver < 1) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): Xmega PDI support requires hardware "
                      "revision >= 1\n",
                      progname);
      return -1;
    }
    if (!is_dragon && fwver < FWVER(5, 37)) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): Xmega support requires firmware "
                      "version >= 5.37\n",
                      progname);
      return -1;
    }
    if (is_dragon && fwver < FWVER(6, 11)) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): Xmega support requires firmware "
                      "version >= 6.11\n",
                      progname);
      return -1;
    }
  }
#undef FWVER
 
  if(mode < 0) return 0;  // for AVR32
 
  tries = 0;
retry:
  /* Turn the ICE into JTAG or ISP mode as requested. */
  buf[0] = mode;
  if (jtagmkII_setparm(pgm, PAR_EMULATOR_MODE, buf) < 0) {
    if (mode == EMULATOR_MODE_SPI) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                      "ISP activation failed, trying debugWire\n",
                      progname);
      buf[0] = EMULATOR_MODE_DEBUGWIRE;
      if (jtagmkII_setparm(pgm, PAR_EMULATOR_MODE, buf) < 0)
  return -1;
      else {
  /*
   * We are supposed to send a CMND_RESET with the
   * MONCOM_DISABLE flag set right now, and then
   * restart from scratch.
   *
   * As this will make the ICE sign off from USB, so
   * we risk losing our USB connection, it's easier
   * to instruct the user to restart AVRDUDE rather
   * than trying to cope with all this inside the
   * program.
   */
  (void)jtagmkII_reset(pgm, 0x04);
  if (tries++ > 3) {
      avrdude_message(MSG_INFO, "%s: Failed to return from debugWIRE to ISP.\n",
                            progname);
      return -1;
  }
  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;
      }
    } else {
      return -1;
    }
  }
 
  /* GET SYNC forces the target into STOPPED mode */
  buf[0] = CMND_GET_SYNC;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_getsync(): Sending get sync command: ",
      progname);
  jtagmkII_send(pgm, buf, 1);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_getsync(): "
                    "bad response to set parameter command: %s\n",
                    progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMND_GET_SIGN_ON, CMND_GET_SYNC, EMULATOR_MODE_DEBUGWIRE, EMULATOR_MODE_JTAG_XMEGA, EMULATOR_MODE_PDI, EMULATOR_MODE_SPI, free(), FWVER, jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_reset(), jtagmkII_send(), jtagmkII_setparm(), MAXTRIES, MSG_DEBUG, MSG_INFO, MSG_NOTICE, MSG_NOTICE2, PAR_EMULATOR_MODE, PDATA, pgm, progname, RSP_OK, RSP_SIGN_ON, programmer_t::type, verbose, and void().

Referenced by jtagmkII_dragon_open(), jtagmkII_dragon_open_dw(), jtagmkII_dragon_open_pdi(), jtagmkII_initialize(), jtagmkII_open(), jtagmkII_open32(), jtagmkII_open_dw(), and jtagmkII_open_pdi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_initialize()

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

static

{
  AVRMEM hfuse;
  unsigned char b;
  int ok;
  const char *ifname;
 
  ok = 0;
  if (pgm->flag & PGM_FL_IS_DW) {
    ifname = "debugWire";
    if (p->flags & AVRPART_HAS_DW)
      ok = 1;
  } else if (pgm->flag & PGM_FL_IS_PDI) {
    ifname = "PDI";
    if (p->flags & AVRPART_HAS_PDI)
      ok = 1;
  } else {
    ifname = "JTAG";
    if (p->flags & AVRPART_HAS_JTAG)
      ok = 1;
  }
 
  if (!ok) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_initialize(): part %s has no %s interface\n",
      progname, p->desc, ifname);
    return -1;
  }
 
  if ((serdev->flags & SERDEV_FL_CANSETSPEED) && pgm->baudrate && pgm->baudrate != 19200) {
    if ((b = jtagmkII_get_baud(pgm->baudrate)) == 0) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_initialize(): unsupported baudrate %d\n",
        progname, pgm->baudrate);
    } else {
      avrdude_message(MSG_NOTICE2, "%s: jtagmkII_initialize(): "
    "trying to set baudrate to %d\n",
    progname, pgm->baudrate);
      if (jtagmkII_setparm(pgm, PAR_BAUD_RATE, &b) == 0)
  serial_setspeed(&pgm->fd, pgm->baudrate);
    }
  }
  if ((pgm->flag & PGM_FL_IS_JTAG) && pgm->bitclock != 0.0) {
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_initialize(): "
        "trying to set JTAG clock period to %.1f us\n",
        progname, pgm->bitclock);
    if (jtagmkII_set_sck_period(pgm, pgm->bitclock) != 0)
      return -1;
  }
 
  if ((pgm->flag & PGM_FL_IS_JTAG) &&
      jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_initialize(): Failed to setup JTAG chain\n",
            progname);
    return -1;
  }
 
  /*
   * If this is an ATxmega device in JTAG mode, change the emulator
   * mode from JTAG to JTAG_XMEGA.
   */
  if ((pgm->flag & PGM_FL_IS_JTAG) &&
      (p->flags & AVRPART_HAS_PDI)) {
    if (jtagmkII_getsync(pgm, EMULATOR_MODE_JTAG_XMEGA) < 0)
      return -1;
  }
  /*
   * Must set the device descriptor before entering programming mode.
   */
  if (PDATA(pgm)->fwver >= 0x700 && (p->flags & AVRPART_HAS_PDI) != 0)
    jtagmkII_set_xmega_params(pgm, p);
  else
    jtagmkII_set_devdescr(pgm, p);
 
  PDATA(pgm)->boot_start = ULONG_MAX;
  /*
   * If this is an ATxmega device in JTAG mode, change the emulator
   * mode from JTAG to JTAG_XMEGA.
   */
  if ((pgm->flag & PGM_FL_IS_JTAG) &&
      (p->flags & AVRPART_HAS_PDI)) {
    /*
     * 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: jtagmkII_initialize(): Cannot locate \"flash\" and \"boot\" memories in description\n",
                      progname);
    } else {
      if (PDATA(pgm)->fwver < 0x700) {
        /* V7+ firmware does not need this anymore */
        unsigned char par[4];
 
        u32_to_b4(par, flashmem->offset);
        (void) jtagmkII_setparm(pgm, PAR_PDI_OFFSET_START, par);
        u32_to_b4(par, bootmem->offset);
        (void) jtagmkII_setparm(pgm, PAR_PDI_OFFSET_END, par);
      }
 
      PDATA(pgm)->boot_start = bootmem->offset - flashmem->offset;
    }
  }
 
  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: jtagmkII_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_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 (PDATA(pgm)->fwver >= 0x700 && (p->flags & AVRPART_HAS_PDI)) {
    /*
     * Work around for
     * https://savannah.nongnu.org/bugs/index.php?37942
     *
     * Firmware version 7.24 (at least) on the Dragon behaves very
     * strange when it gets a RESET request here.  All subsequent
     * responses are completely off, so the emulator becomes unusable.
     * This appears to be a firmware bug (earlier versions, at least
     * 7.14, didn't experience this), but by omitting the RESET for
     * Xmega devices, we can work around it.
     */
  } else {
    if (jtagmkII_reset(pgm, 0x01) < 0)
      return -1;
  }
 
  if ((pgm->flag & PGM_FL_IS_JTAG) && !(p->flags & AVRPART_HAS_PDI)) {
    strcpy(hfuse.desc, "hfuse");
    if (jtagmkII_read_byte(pgm, p, &hfuse, 1, &b) < 0)
      return -1;
    if ((b & OCDEN) != 0)
      avrdude_message(MSG_INFO, "%s: jtagmkII_initialize(): warning: OCDEN fuse not programmed, "
                      "single-byte EEPROM updates not possible\n",
                      progname);
  }
 
  return 0;
}

References avr_locate_mem(), avrdude_message(), AVRPART_HAS_DW, AVRPART_HAS_JTAG, AVRPART_HAS_PDI, programmer_t::baudrate, programmer_t::bitclock, avrpart::desc, avrmem::desc, EMULATOR_MODE_JTAG_XMEGA, programmer_t::fd, programmer_t::flag, avrpart::flags, serial_device::flags, free(), jtagmkII_get_baud(), jtagmkII_getsync(), jtagmkII_read_byte(), jtagmkII_reset(), jtagmkII_set_devdescr(), jtagmkII_set_sck_period(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), long, malloc(), MSG_INFO, MSG_NOTICE2, OCDEN, avrmem::offset, PAR_BAUD_RATE, PAR_DAISY_CHAIN_INFO, PAR_PDI_OFFSET_END, PAR_PDI_OFFSET_START, PDATA, pgm, PGM_FL_IS_DW, PGM_FL_IS_JTAG, PGM_FL_IS_PDI, progname, serdev, SERDEV_FL_CANSETSPEED, serial_setspeed, u32_to_b4(), and void().

Referenced by jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_initialize32()

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

static

{
  int status, j;
  unsigned char buf[6], *resp;
 
  if (jtagmkII_setparm(pgm, PAR_DAISY_CHAIN_INFO, PDATA(pgm)->jtagchain) < 0) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_initialize(): Failed to setup JTAG chain\n",
            progname);
    return -1;
  }
 
  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: jtagmkII_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_initialize32(): Out of memory\n",
      progname);
    free(PDATA(pgm)->flash_pagecache);
    return -1;
  }
  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
 
  for(j=0; j<2; ++j) {
    buf[0] = CMND_GET_IR;
    buf[1] = 0x1;
    if(jtagmkII_send(pgm, buf, 2) < 0)
      return -1;
    status = jtagmkII_recv(pgm, &resp);
    if(status <= 0 || resp[0] != 0x87) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_initialize32(): "
                "timeout/error communicating with programmer (status %d)\n",
                progname, status);
      return -1;
    }
    free(resp);
 
    memset(buf, 0, sizeof(buf));
    buf[0] = CMND_GET_xxx;
    buf[1] = 0x20;
    if(jtagmkII_send(pgm, buf, 6) < 0)
      return -1;
    status = jtagmkII_recv(pgm, &resp);
    if(status <= 0 || resp[0] != 0x87) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_initialize32(): "
                "timeout/error communicating with programmer (status %d)\n",
                progname, status);
      return -1;
    }
 
    if (status != 5 ||
    resp[2] != p->signature[0] ||
    resp[3] != p->signature[1] ||
    resp[4] != p->signature[2]) {
      avrdude_message(MSG_INFO, "%s: Expected signature for %s is %02X %02X %02X\n",
          progname, p->desc,
          p->signature[0], p->signature[1], p->signature[2]);
      if (!ovsigck) {
        avrdude_message(MSG_INFO, "%sDouble check chip, "
        "or use -F to override this check.\n",
                progbuf);
        return -1;
      }
    }
    free(resp);
  }
 
  return 0;
}

References avrdude_message(), CMND_GET_IR, CMND_GET_xxx, avrpart::desc, free(), jtagmkII_recv(), jtagmkII_send(), jtagmkII_setparm(), long, malloc(), MSG_INFO, ovsigck, PAR_DAISY_CHAIN_INFO, PDATA, pgm, progbuf, progname, avrpart::signature, and verbose.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_initpgm()

void jtagmkII_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "JTAGMKII");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase;
  pgm->open           = jtagmkII_open;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->page_erase     = jtagmkII_page_erase;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->set_sck_period = jtagmkII_set_sck_period;
  pgm->parseextparams = jtagmkII_parseextparms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_JTAG;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_open(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_parseextparms(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_set_sck_period(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, programmer_t::parseextparams, pgm, PGM_FL_IS_JTAG, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_sck_period, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_memaddr()

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

static

{
  /*
   * Xmega devices handled by V7+ firmware don't want to be told their
   * m->offset within the write memory command.
   */
  if (PDATA(pgm)->fwver >= 0x700 && (p->flags & AVRPART_HAS_PDI) != 0) {
    if (addr >= PDATA(pgm)->boot_start)
      /*
       * all memories but "flash" are smaller than boot_start anyway, so
       * no need for an extra check we are operating on "flash"
       */
      return addr - PDATA(pgm)->boot_start;
    else
      /* normal flash, or anything else */
      return addr;
  }
  /*
   * Old firmware, or non-Xmega device.  Non-Xmega (and non-AVR32)
   * devices always have an m->offset of 0, so we don't have to
   * distinguish them here.
   */
  return addr + m->offset;
}

References AVRPART_HAS_PDI, avrpart::flags, avrmem::offset, PDATA, and pgm.

Referenced by jtagmkII_paged_load(), and jtagmkII_paged_write().

Here is the caller graph for this function:

◆ jtagmkII_memtype()

static unsigned char jtagmkII_memtype	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		unsigned long	addr
	)

static

{
  if ( p->flags & AVRPART_HAS_PDI ) {
    if (addr >= PDATA(pgm)->boot_start)
      return MTYPE_BOOT_FLASH;
    else
      return MTYPE_FLASH;
  } else {
    return MTYPE_FLASH_PAGE;
  }
}

References AVRPART_HAS_PDI, avrpart::flags, MTYPE_BOOT_FLASH, MTYPE_FLASH, MTYPE_FLASH_PAGE, PDATA, and pgm.

Referenced by jtagmkII_page_erase(), jtagmkII_paged_load(), and jtagmkII_paged_write().

Here is the caller graph for this function:

◆ jtagmkII_open()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: 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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_JTAG) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_JTAG, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_JTAGICEMKII, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_open32()

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

static

{
  int status;
  unsigned char buf[6], *resp;
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_open32()\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
   */
  jtagmkII_drain(pgm, 0);
 
  status = jtagmkII_getsync(pgm, -1);
  if(status < 0) return -1;
 
  // FIXME: Error handling is bad here: memory leak in resp (?) and port not closed
 
  // AVR32 "special"
  buf[0] = CMND_SET_PARAMETER;
  buf[1] = 0x2D;
  buf[2] = 0x03;
  jtagmkII_send(pgm, buf, 3);
  status = jtagmkII_recv(pgm, &resp);
  if(status < 0 || resp[0] != RSP_OK)
    return -1;
  free(resp);
 
  buf[1] = 0x03;
  buf[2] = 0x02;
  jtagmkII_send(pgm, buf, 3);
  status = jtagmkII_recv(pgm, &resp);
  if(status < 0 || resp[0] != RSP_OK)
    return -1;
  free(resp);
 
  buf[1] = 0x03;
  buf[2] = 0x04;
  jtagmkII_send(pgm, buf, 3);
  status = jtagmkII_recv(pgm, &resp);
  if(status < 0 || resp[0] != RSP_OK)
    return -1;
  free(resp);
 
  return 0;
}

References avrdude_message(), pinfo::baud, CMND_SET_PARAMETER, programmer_t::fd, free(), jtagmkII_drain(), jtagmkII_getsync(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, RSP_OK, serdev, serial_open, filedescriptor::usb, USB_DEVICE_JTAGICEMKII, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_open_dw()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_open_dw()\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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_DEBUGWIRE) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_DEBUGWIRE, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_JTAGICEMKII, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_dw_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_open_pdi()

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

static

{
  union pinfo pinfo;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_open_pdi()\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
   */
  jtagmkII_drain(pgm, 0);
 
  if (jtagmkII_getsync(pgm, EMULATOR_MODE_PDI) < 0) {
    serial_close(&pgm->fd);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), pinfo::baud, EMULATOR_MODE_PDI, programmer_t::fd, jtagmkII_drain(), jtagmkII_getsync(), MSG_INFO, MSG_NOTICE2, pgm, programmer_t::port, progname, serdev, serial_close, serial_open, filedescriptor::usb, USB_DEVICE_JTAGICEMKII, usb_serdev, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_MKII, USBDEV_BULK_EP_WRITE_MKII, USBDEV_MAX_XFER_MKII, and pinfo::usbinfo.

Referenced by jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_page_erase()

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

static

{
  unsigned char cmd[6];
  unsigned char *resp;
  int status, tries;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_page_erase(.., %s, 0x%x)\n",
      progname, m->desc, addr);
 
  if (!(p->flags & AVRPART_HAS_PDI)) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_page_erase: not an Xmega device\n",
      progname);
    return -1;
  }
  if ((pgm->flag & PGM_FL_IS_DW)) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_page_erase: not applicable to debugWIRE\n",
      progname);
    return -1;
  }
 
  if (jtagmkII_program_enable(pgm) < 0)
    return -1;
 
  cmd[0] = CMND_XMEGA_ERASE;
  if (strcmp(m->desc, "flash") == 0) {
    if (jtagmkII_memtype(pgm, p, addr) == MTYPE_FLASH)
      cmd[1] = XMEGA_ERASE_APP_PAGE;
    else
      cmd[1] = XMEGA_ERASE_BOOT_PAGE;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[1] = XMEGA_ERASE_EEPROM_PAGE;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[1] = XMEGA_ERASE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[1] = XMEGA_ERASE_BOOT_PAGE;
  } else {
    cmd[1] = XMEGA_ERASE_APP_PAGE;
  }
  serial_recv_timeout = 100;
 
  /*
   * Don't use jtagmkII_memaddr() here.  While with all other
   * commands, firmware 7+ doesn't require the NVM offsets being
   * applied, the erase page commands make an exception, and do
   * require the NVM offsets as part of the (page) address.
   */
  u32_to_b4(cmd + 2, addr + m->offset);
 
  tries = 0;
 
  retry:
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_page_erase(): "
            "Sending xmega erase command: ",
            progname);
  jtagmkII_send(pgm, cmd, sizeof cmd);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_page_erase(): "
                      "timeout/error communicating with programmer (status %d)\n",
                      progname, status);
    if (tries++ < 4) {
      serial_recv_timeout *= 2;
      goto retry;
    }
    avrdude_message(MSG_INFO, "%s: jtagmkII_page_erase(): fatal timeout/"
                    "error communicating with programmer (status %d)\n",
                    progname, status);
    serial_recv_timeout = otimeout;
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  if (resp[0] != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_page_erase(): "
                    "bad response to xmega erase command: %s\n",
                    progname, jtagmkII_get_rc(resp[0]));
    free(resp);
    serial_recv_timeout = otimeout;
    return -1;
  }
  free(resp);
 
  serial_recv_timeout = otimeout;
 
  return 0;
}

References avrdude_message(), AVRPART_HAS_PDI, cmd, CMND_XMEGA_ERASE, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_memtype(), jtagmkII_prmsg(), jtagmkII_program_enable(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, MTYPE_FLASH, avrmem::offset, pgm, PGM_FL_IS_DW, progname, RSP_OK, serial_recv_timeout, u32_to_b4(), verbose, XMEGA_ERASE_APP_PAGE, XMEGA_ERASE_BOOT_PAGE, XMEGA_ERASE_EEPROM_PAGE, and XMEGA_ERASE_USERSIG.

Referenced by jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_paged_load()

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

static

{
  unsigned int block_size;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char cmd[10];
  unsigned char *resp;
  int status, tries, dynamic_memtype = 0;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_paged_load(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtagmkII_program_enable(pgm) < 0)
    return -1;
 
  page_size = m->readsize;
 
  cmd[0] = CMND_READ_MEMORY;
  if (strcmp(m->desc, "flash") == 0) {
    cmd[1] = jtagmkII_memtype(pgm, p, addr);
    if (p->flags & AVRPART_HAS_PDI)
      /* dynamically decide between flash/boot memtype */
      dynamic_memtype = 1;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[1] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_EEPROM : MTYPE_EEPROM_PAGE;
    if (pgm->flag & PGM_FL_IS_DW)
      return -1;
  } else if ( ( strcmp(m->desc, "prodsig") == 0 ) ) {
    cmd[1] = MTYPE_PRODSIG;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[1] = MTYPE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[1] = MTYPE_BOOT_FLASH;
  } else if ( p->flags & AVRPART_HAS_PDI ) {
    cmd[1] = MTYPE_FLASH;
  } else {
    cmd[1] = MTYPE_SPM;
  }
  serial_recv_timeout = 100;
  for (; addr < maxaddr; addr += page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
    avrdude_message(MSG_DEBUG, "%s: jtagmkII_paged_load(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    if (dynamic_memtype)
      cmd[1] = jtagmkII_memtype(pgm, p, addr);
 
    u32_to_b4(cmd + 2, block_size);
    u32_to_b4(cmd + 6, jtagmkII_memaddr(pgm, p, m, addr));
 
    tries = 0;
 
    retry:
      avrdude_message(MSG_NOTICE2, "%s: jtagmkII_paged_load(): Sending read memory command: ",
        progname);
    jtagmkII_send(pgm, cmd, 10);
 
    status = jtagmkII_recv(pgm, &resp);
    if (status <= 0) {
      if (verbose >= 2)
  putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_load(): "
                        "timeout/error communicating with programmer (status %d)\n",
                        progname, status);
      if (tries++ < 4) {
  serial_recv_timeout *= 2;
  goto retry;
      }
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_load(): fatal timeout/"
                      "error communicating with programmer (status %d)\n",
                      progname, status);
      serial_recv_timeout = otimeout;
      return -1;
    }
    if (verbose >= 3) {
      putc('\n', stderr);
      jtagmkII_prmsg(pgm, resp, status);
    } else if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
    if (resp[0] != RSP_MEMORY) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_load(): "
        "bad response to read memory command: %s\n",
        progname, jtagmkII_get_rc(resp[0]));
      free(resp);
      serial_recv_timeout = otimeout;
      return -1;
    }
    memcpy(m->buf + addr, resp + 1, status-1);
    free(resp);
  }
  serial_recv_timeout = otimeout;
 
  return n_bytes;
}

References avrdude_message(), AVRPART_HAS_PDI, avrmem::buf, cmd, CMND_READ_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_memaddr(), jtagmkII_memtype(), jtagmkII_prmsg(), jtagmkII_program_enable(), jtagmkII_recv(), jtagmkII_send(), MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MTYPE_BOOT_FLASH, MTYPE_EEPROM, MTYPE_EEPROM_PAGE, MTYPE_FLASH, MTYPE_PRODSIG, MTYPE_SPM, MTYPE_USERSIG, pgm, PGM_FL_IS_DW, progname, avrmem::readsize, RSP_MEMORY, serial_recv_timeout, u32_to_b4(), and verbose.

Referenced by jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_paged_load32()

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

static

{
  unsigned int block_size;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char cmd[7];
  unsigned char *resp;
  int lineno, status;
  unsigned long val=0;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_paged_load32(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  serial_recv_timeout = 256;
 
  if(!(p->flags & AVRPART_WRITE)) {
    status = jtagmkII_reset32(pgm, AVR32_RESET_READ);
    if(status != 0) {lineno = __LINE__; goto eRR;}
  }
 
  // Init SMC and set clocks
  if(!(p->flags & AVRPART_INIT_SMC)) {
    status = jtagmkII_smc_init32(pgm);
    if(status != 0) {lineno = __LINE__; goto eRR;} // PLL 0
    p->flags |= AVRPART_INIT_SMC;
  }
 
  // Init SMC and set clocks
  if(!(p->flags & AVRPART_INIT_SMC)) {
    status = jtagmkII_smc_init32(pgm);
    if(status != 0) {lineno = __LINE__; goto eRR;} // PLL 0
    p->flags |= AVRPART_INIT_SMC;
  }
 
  //avrdude_message(MSG_INFO, "\n pageSize=%d bytes=%d pages=%d m->offset=0x%x pgm->page_size %d\n",
  //        page_size, n_bytes, pages, m->offset, pgm->page_size);
 
  cmd[0] = CMND_READ_MEMORY32;
  cmd[1] = 0x40;
  cmd[2] = 0x05;
 
  for (; addr < maxaddr; addr += block_size) {
    block_size = ((maxaddr-addr) < pgm->page_size) ? (maxaddr - addr) : pgm->page_size;
    avrdude_message(MSG_DEBUG, "%s: jtagmkII_paged_load32(): "
              "block_size at addr %d is %d\n",
              progname, addr, block_size);
 
    u32_to_b4r(cmd + 3, m->offset + addr);
 
    status = jtagmkII_send(pgm, cmd, 7);
    if(status<0) {lineno = __LINE__; goto eRR;}
    status = jtagmkII_recv(pgm, &resp);
    if(status<0) {lineno = __LINE__; goto eRR;}
 
    if (verbose >= 3) {
      putc('\n', stderr);
      jtagmkII_prmsg(pgm, resp, status);
    } else if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
    if (resp[0] != 0x87) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_load32(): "
              "bad response to write memory command: %s\n",
              progname, jtagmkII_get_rc(resp[0]));
      free(resp);
      return -1;
    }
    memcpy(m->buf + addr, resp + 1, block_size);
    free(resp);
 
  }
 
  serial_recv_timeout = otimeout;
 
  status = jtagmkII_reset32(pgm, AVR32_SET4RUNNING);
  if(status < 0) {lineno = __LINE__; goto eRR;}
 
  return addr;
 
  eRR:
    serial_recv_timeout = otimeout;
    avrdude_message(MSG_INFO, "%s: jtagmkII_paged_load32(): "
      "failed at line %d (status=%x val=%lx)\n",
      progname, lineno, status, val);
    return -1;
}

References AVR32_RESET_READ, AVR32_SET4RUNNING, avrdude_message(), AVRPART_INIT_SMC, AVRPART_WRITE, avrmem::buf, cmd, CMND_READ_MEMORY32, avrmem::desc, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_reset32(), jtagmkII_send(), jtagmkII_smc_init32(), lineno, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, avrmem::offset, programmer_t::page_size, pgm, progname, serial_recv_timeout, u32_to_b4r(), and verbose.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_paged_write()

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

static

{
  unsigned int block_size;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char *cmd;
  unsigned char *resp;
  int status, tries, dynamic_memtype = 0;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_paged_write(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtagmkII_program_enable(pgm) < 0)
    return -1;
 
  if (page_size == 0) page_size = 256;
  else if (page_size > 256) page_size = 256;
 
  if ((cmd = malloc(page_size + 10)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write(): Out of memory\n",
      progname);
    return -1;
  }
 
  cmd[0] = CMND_WRITE_MEMORY;
  if (strcmp(m->desc, "flash") == 0) {
    PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
    cmd[1] = jtagmkII_memtype(pgm, p, addr);
    if (p->flags & AVRPART_HAS_PDI)
      /* dynamically decide between flash/boot memtype */
      dynamic_memtype = 1;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    if (pgm->flag & PGM_FL_IS_DW) {
      /*
       * jtagmkII_paged_write() to EEPROM attempted while in
       * DW mode.  Use jtagmkII_write_byte() instead.
       */
      for (; addr < maxaddr; addr++) {
  status = jtagmkII_write_byte(pgm, p, m, addr, m->buf[addr]);
  if (status < 0) {
    free(cmd);
    return -1;
  }
      }
      free(cmd);
      return n_bytes;
    }
    cmd[1] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_EEPROM : MTYPE_EEPROM_PAGE;
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[1] = MTYPE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[1] = MTYPE_BOOT_FLASH;
  } else if ( p->flags & AVRPART_HAS_PDI ) {
    cmd[1] = MTYPE_FLASH;
  } else {
    cmd[1] = MTYPE_SPM;
  }
  serial_recv_timeout = 100;
  for (; addr < maxaddr; addr += page_size) {
    if ((maxaddr - addr) < page_size)
      block_size = maxaddr - addr;
    else
      block_size = page_size;
    avrdude_message(MSG_DEBUG, "%s: jtagmkII_paged_write(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    if (dynamic_memtype)
      cmd[1] = jtagmkII_memtype(pgm, p, addr);
 
    u32_to_b4(cmd + 2, page_size);
    u32_to_b4(cmd + 6, jtagmkII_memaddr(pgm, p, m, addr));
 
    /*
     * The JTAG ICE will refuse to write anything but a full page, at
     * least for the flash ROM.  If a partial page has been requested,
     * set the remainder to 0xff.  (Maybe we should rather read back
     * the existing contents instead before?  Doesn't matter much, as
     * bits cannot be written to 1 anyway.)
     */
    memset(cmd + 10, 0xff, page_size);
    memcpy(cmd + 10, m->buf + addr, block_size);
 
    tries = 0;
 
    retry:
      avrdude_message(MSG_NOTICE2, "%s: jtagmkII_paged_write(): "
        "Sending write memory command: ",
        progname);
    jtagmkII_send(pgm, cmd, page_size + 10);
 
    status = jtagmkII_recv(pgm, &resp);
    if (status <= 0) {
      if (verbose >= 2)
  putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write(): "
                        "timeout/error communicating with programmer (status %d)\n",
                        progname, status);
      if (tries++ < 4) {
  serial_recv_timeout *= 2;
  goto retry;
      }
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write(): fatal timeout/"
                      "error communicating with programmer (status %d)\n",
                      progname, status);
      free(cmd);
      serial_recv_timeout = otimeout;
      return -1;
    }
    if (verbose >= 3) {
      putc('\n', stderr);
      jtagmkII_prmsg(pgm, resp, status);
    } else if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
    if (resp[0] != RSP_OK) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write(): "
                      "bad response to write memory command: %s\n",
                      progname, jtagmkII_get_rc(resp[0]));
      free(resp);
      free(cmd);
      serial_recv_timeout = otimeout;
      return -1;
    }
    free(resp);
  }
 
  free(cmd);
  serial_recv_timeout = otimeout;
 
  return n_bytes;
}

References avrdude_message(), AVRPART_HAS_PDI, avrmem::buf, cmd, CMND_WRITE_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_memaddr(), jtagmkII_memtype(), jtagmkII_prmsg(), jtagmkII_program_enable(), jtagmkII_recv(), jtagmkII_send(), jtagmkII_write_byte(), long, malloc(), MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MTYPE_BOOT_FLASH, MTYPE_EEPROM, MTYPE_EEPROM_PAGE, MTYPE_FLASH, MTYPE_SPM, MTYPE_USERSIG, PDATA, pgm, PGM_FL_IS_DW, progname, RSP_OK, serial_recv_timeout, u32_to_b4(), and verbose.

Referenced by jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_paged_write32()

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

static

{
  unsigned int block_size;
  unsigned char *cmd=NULL;
  unsigned char *resp;
  int lineno, status, pages, sPageNum, pageNum, blocks;
  unsigned long val=0;
  unsigned long otimeout = serial_recv_timeout;
  unsigned int maxaddr = addr + n_bytes;
 
  serial_recv_timeout = 256;
 
  if(n_bytes == 0) return -1;
 
  status = jtagmkII_reset32(pgm, AVR32_RESET_WRITE);
  if(status != 0) {lineno = __LINE__; goto eRR;}
  p->flags |= AVRPART_WRITE;
 
  pages = (n_bytes - addr - 1)/page_size + 1;
  sPageNum = addr/page_size;
  //avrdude_message(MSG_INFO, "\n pageSize=%d bytes=%d pages=%d m->offset=0x%x pgm->page_size %d\n",
  //        page_size, n_bytes, pages, m->offset, pgm->page_size);
 
  // Before any errors can happen
  if ((cmd = malloc(pgm->page_size + 10)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write32(): Out of memory\n", progname);
    return -1;
  }
 
  // Init SMC and set clocks
  if(!(p->flags & AVRPART_INIT_SMC)) {
    status = jtagmkII_smc_init32(pgm);
    if(status != 0) {lineno = __LINE__; goto eRR;} // PLL 0
    p->flags |= AVRPART_INIT_SMC;
  }
 
  // First unlock the pages
  for(pageNum=sPageNum; pageNum < pages; ++pageNum) {
    status =jtagmkII_flash_lock32(pgm, 0, pageNum);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
 
  // Then erase them (guess could do this in the same loop above?)
  for(pageNum=sPageNum; pageNum < pages; ++pageNum) {
    status =jtagmkII_flash_erase32(pgm, pageNum);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
 
  cmd[0] = CMND_WRITE_MEMORY32;
  u32_to_b4r(&cmd[1], 0x40000000);  // who knows
  cmd[5] = 0x5;
 
  for(pageNum=sPageNum; pageNum < pages; ++pageNum) {
 
    status = jtagmkII_flash_clear_pagebuffer32(pgm);
    if(status != 0) {lineno = __LINE__; goto eRR;}
 
    for(blocks=0; blocks<2; ++blocks) {
      block_size = ((maxaddr-addr) < pgm->page_size) ? (maxaddr - addr) : pgm->page_size;
      avrdude_message(MSG_DEBUG, "%s: jtagmkII_paged_write32(): "
                "block_size at addr %d is %d\n",
                progname, addr, block_size);
 
      u32_to_b4r(cmd + 6, m->offset + addr);
      memset(cmd + 10, 0xff, pgm->page_size);
      memcpy(cmd + 10, m->buf + addr, block_size);
 
      status = jtagmkII_send(pgm, cmd, pgm->page_size + 10);
      if(status<0) {lineno = __LINE__; goto eRR;}
      status = jtagmkII_recv(pgm, &resp);
      if (status<0) {lineno = __LINE__; goto eRR;}
 
      if (verbose >= 3) {
        putc('\n', stderr);
        jtagmkII_prmsg(pgm, resp, status);
      } else if (verbose == 2)
        avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
      if (resp[0] != RSP_OK) {
        avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write32(): "
                "bad response to write memory command: %s\n",
                progname, jtagmkII_get_rc(resp[0]));
        free(resp);
        free(cmd);
        return -1;
      }
      free(resp);
 
      addr += block_size;
 
 
    }
    status = jtagmkII_flash_write_page32(pgm, pageNum);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
  free(cmd);
  serial_recv_timeout = otimeout;
 
  status = jtagmkII_reset32(pgm, AVR32_SET4RUNNING);  // AVR32_SET4RUNNING | AVR32_RELEASE_JTAG
  if(status < 0) {lineno = __LINE__; goto eRR;}
 
  return addr;
 
  eRR:
    serial_recv_timeout = otimeout;
    free(cmd);
    avrdude_message(MSG_INFO, "%s: jtagmkII_paged_write32(): "
      "failed at line %d (status=%x val=%lx)\n",
      progname, lineno, status, val);
    return -1;
}

References AVR32_RESET_WRITE, AVR32_SET4RUNNING, avrdude_message(), AVRPART_INIT_SMC, AVRPART_WRITE, avrmem::buf, cmd, CMND_WRITE_MEMORY32, avrpart::flags, free(), jtagmkII_flash_clear_pagebuffer32(), jtagmkII_flash_erase32(), jtagmkII_flash_lock32(), jtagmkII_flash_write_page32(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_reset32(), jtagmkII_send(), jtagmkII_smc_init32(), lineno, malloc(), MSG_DEBUG, MSG_INFO, MSG_NOTICE2, avrmem::offset, programmer_t::page_size, pgm, progname, RSP_OK, serial_recv_timeout, u32_to_b4r(), and verbose.

Referenced by jtagmkII_avr32_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_parseextparms()

static int jtagmkII_parseextparms	(	PROGRAMMER *	pgm,
		LISTID	extparms
	)

static

{
  LNODEID ln;
  const char *extended_param;
  int rv = 0;
 
  for (ln = lfirst(extparms); ln; ln = lnext(ln)) {
    extended_param = ldata(ln);
 
    if (strncmp(extended_param, "jtagchain=", strlen("jtagchain=")) == 0) {
      unsigned int ub, ua, bb, ba;
      if (sscanf(extended_param, "jtagchain=%u,%u,%u,%u", &ub, &ua, &bb, &ba)
          != 4) {
        avrdude_message(MSG_INFO, "%s: jtagmkII_parseextparms(): invalid JTAG chain '%s'\n",
                        progname, extended_param);
        rv = -1;
        continue;
      }
      avrdude_message(MSG_NOTICE2, "%s: jtagmkII_parseextparms(): JTAG chain parsed as:\n"
                        "%s %u units before, %u units after, %u bits before, %u bits after\n",
                        progname,
                        progbuf, ub, ua, bb, ba);
      PDATA(pgm)->jtagchain[0] = ub;
      PDATA(pgm)->jtagchain[1] = ua;
      PDATA(pgm)->jtagchain[2] = bb;
      PDATA(pgm)->jtagchain[3] = ba;
 
      continue;
    }
 
    avrdude_message(MSG_INFO, "%s: jtagmkII_parseextparms(): invalid extended parameter '%s'\n",
                    progname, extended_param);
    rv = -1;
  }
 
  return rv;
}

References avrdude_message(), ldata(), lfirst(), lnext(), MSG_INFO, MSG_NOTICE2, PDATA, pgm, progbuf, and progname.

Referenced by jtagmkII_dragon_initpgm(), and jtagmkII_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_pdi_initpgm()

void jtagmkII_pdi_initpgm ( PROGRAMMER * pgm )

{
  strcpy(pgm->type, "JTAGMKII_PDI");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkII_initialize;
  pgm->display        = jtagmkII_display;
  pgm->enable         = jtagmkII_enable;
  pgm->disable        = jtagmkII_disable;
  pgm->program_enable = jtagmkII_program_enable_INFO;
  pgm->chip_erase     = jtagmkII_chip_erase;
  pgm->open           = jtagmkII_open_pdi;
  pgm->close          = jtagmkII_close;
  pgm->read_byte      = jtagmkII_read_byte;
  pgm->write_byte     = jtagmkII_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkII_paged_write;
  pgm->paged_load     = jtagmkII_paged_load;
  pgm->page_erase     = jtagmkII_page_erase;
  pgm->print_parms    = jtagmkII_print_parms;
  pgm->setup          = jtagmkII_setup;
  pgm->teardown       = jtagmkII_teardown;
  pgm->page_size      = 256;
  pgm->flag           = PGM_FL_IS_PDI;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::flag, programmer_t::initialize, jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_disable(), jtagmkII_display(), jtagmkII_enable(), jtagmkII_initialize(), jtagmkII_open_pdi(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_print_parms(), jtagmkII_program_enable_INFO(), jtagmkII_read_byte(), jtagmkII_setup(), jtagmkII_teardown(), jtagmkII_write_byte(), programmer_t::open, programmer_t::page_erase, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, PGM_FL_IS_PDI, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

◆ jtagmkII_print_memory()

static void jtagmkII_print_memory	(	unsigned char *	b,
		size_t	s
	)

static

{
  int i;
 
  if (s < 2)
    return;
 
  for (i = 0; i < s - 1; i++) {
    avrdude_message(MSG_INFO, "0x%02x ", b[i + 1]);
    if (i % 16 == 15)
      putc('\n', stderr);
    else
      putc(' ', stderr);
  }
  if (i % 16 != 0)
    putc('\n', stderr);
}

References avrdude_message(), and MSG_INFO.

Referenced by jtagmkII_prmsg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_print_parms()

static void jtagmkII_print_parms ( PROGRAMMER * pgm )

static

{
  jtagmkII_print_parms1(pgm, "");
}

References jtagmkII_print_parms1(), and pgm.

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_print_parms1()

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

static

{
  unsigned char vtarget[4], jtag_clock[4];
  char clkbuf[20];
  double clk;
 
  if (jtagmkII_getparm(pgm, PAR_OCD_VTARGET, vtarget) < 0)
    return;
 
  avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p,
    b2_to_u16(vtarget) / 1000.0);
 
  if ((pgm->flag & PGM_FL_IS_JTAG)) {
    if (jtagmkII_getparm(pgm, PAR_OCD_JTAG_CLK, jtag_clock) < 0)
      return;
 
    if (jtag_clock[0] == 0) {
      strcpy(clkbuf, "6.4 MHz");
      clk = 6.4e6;
    } else if (jtag_clock[0] == 1) {
      strcpy(clkbuf, "2.8 MHz");
      clk = 2.8e6;
    } else if (jtag_clock[0] <= 5) {
      sprintf(clkbuf, "%.1f MHz", 5.35 / (double)jtag_clock[0]);
      clk = 5.35e6 / (double)jtag_clock[0];
    } else {
      sprintf(clkbuf, "%.1f kHz", 5.35e3 / (double)jtag_clock[0]);
      clk = 5.35e6 / (double)jtag_clock[0];
 
      avrdude_message(MSG_INFO, "%sJTAG clock      : %s (%.1f us)\n", p, clkbuf,
        1.0e6 / clk);
    }
  }
 
  return;
}

References avrdude_message(), b2_to_u16(), programmer_t::flag, jtagmkII_getparm(), MSG_INFO, PAR_OCD_JTAG_CLK, PAR_OCD_VTARGET, pgm, and PGM_FL_IS_JTAG.

Referenced by jtagmkII_display(), and jtagmkII_print_parms().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_prmsg()

static void jtagmkII_prmsg	(	PROGRAMMER *	pgm,
		unsigned char *	data,
		size_t	len
	)

static

{
  int i;
 
  if (verbose >= 4) {
    avrdude_message(MSG_TRACE, "Raw message:\n");
 
    for (i = 0; i < len; i++) {
      avrdude_message(MSG_TRACE, "0x%02x", data[i]);
      if (i % 16 == 15)
  putc('\n', stderr);
      else
  putc(' ', stderr);
    }
    if (i % 16 != 0)
      putc('\n', stderr);
  }
 
  switch (data[0]) {
  case RSP_OK:
    avrdude_message(MSG_INFO, "OK\n");
    break;
 
  case RSP_FAILED:
    avrdude_message(MSG_INFO, "FAILED\n");
    break;
 
  case RSP_ILLEGAL_BREAKPOINT:
    avrdude_message(MSG_INFO, "Illegal breakpoint\n");
    break;
 
  case RSP_ILLEGAL_COMMAND:
    avrdude_message(MSG_INFO, "Illegal command\n");
    break;
 
  case RSP_ILLEGAL_EMULATOR_MODE:
    avrdude_message(MSG_INFO, "Illegal emulator mode");
    if (len > 1)
      switch (data[1]) {
      case EMULATOR_MODE_DEBUGWIRE: avrdude_message(MSG_INFO, ": DebugWire"); break;
      case EMULATOR_MODE_JTAG:      avrdude_message(MSG_INFO, ": JTAG"); break;
      case EMULATOR_MODE_HV:        avrdude_message(MSG_INFO, ": HVSP/PP"); break;
      case EMULATOR_MODE_SPI:       avrdude_message(MSG_INFO, ": SPI"); break;
      case EMULATOR_MODE_JTAG_XMEGA: avrdude_message(MSG_INFO, ": JTAG/Xmega"); break;
      }
    putc('\n', stderr);
    break;
 
  case RSP_ILLEGAL_JTAG_ID:
    avrdude_message(MSG_INFO, "Illegal JTAG ID\n");
    break;
 
  case RSP_ILLEGAL_MCU_STATE:
    avrdude_message(MSG_INFO, "Illegal MCU state");
    if (len > 1)
      switch (data[1]) {
      case STOPPED:     avrdude_message(MSG_INFO, ": Stopped"); break;
      case RUNNING:     avrdude_message(MSG_INFO, ": Running"); break;
      case PROGRAMMING: avrdude_message(MSG_INFO, ": Programming"); break;
      }
    putc('\n', stderr);
    break;
 
  case RSP_ILLEGAL_MEMORY_TYPE:
    avrdude_message(MSG_INFO, "Illegal memory type\n");
    break;
 
  case RSP_ILLEGAL_MEMORY_RANGE:
    avrdude_message(MSG_INFO, "Illegal memory range\n");
    break;
 
  case RSP_ILLEGAL_PARAMETER:
    avrdude_message(MSG_INFO, "Illegal parameter\n");
    break;
 
  case RSP_ILLEGAL_POWER_STATE:
    avrdude_message(MSG_INFO, "Illegal power state\n");
    break;
 
  case RSP_ILLEGAL_VALUE:
    avrdude_message(MSG_INFO, "Illegal value\n");
    break;
 
  case RSP_NO_TARGET_POWER:
    avrdude_message(MSG_INFO, "No target power\n");
    break;
 
  case RSP_SIGN_ON:
    avrdude_message(MSG_INFO, "Sign-on succeeded\n");
    /* Sign-on data will be printed below anyway. */
    break;
 
  case RSP_MEMORY:
    avrdude_message(MSG_INFO, "memory contents:\n");
    jtagmkII_print_memory(data, len);
    break;
 
  case RSP_PARAMETER:
    avrdude_message(MSG_INFO, "parameter values:\n");
    jtagmkII_print_memory(data, len);
    break;
 
  case RSP_SPI_DATA:
    avrdude_message(MSG_INFO, "SPI data returned:\n");
    for (i = 1; i < len; i++)
      avrdude_message(MSG_INFO, "0x%02x ", data[i]);
    putc('\n', stderr);
    break;
 
  case EVT_BREAK:
    avrdude_message(MSG_INFO, "BREAK event");
    if (len >= 6) {
      avrdude_message(MSG_INFO, ", PC = 0x%lx, reason ", b4_to_u32(data + 1));
      switch (data[5]) {
      case 0x00:
  avrdude_message(MSG_INFO, "unspecified");
  break;
      case 0x01:
  avrdude_message(MSG_INFO, "program break");
  break;
      case 0x02:
  avrdude_message(MSG_INFO, "data break PDSB");
  break;
      case 0x03:
  avrdude_message(MSG_INFO, "data break PDMSB");
  break;
      default:
  avrdude_message(MSG_INFO, "unknown: 0x%02x", data[5]);
      }
    }
    putc('\n', stderr);
    break;
 
  default:
    avrdude_message(MSG_INFO, "unknown message 0x%02x\n", data[0]);
  }
 
  putc('\n', stderr);
}

References avrdude_message(), b4_to_u32(), EMULATOR_MODE_DEBUGWIRE, EMULATOR_MODE_HV, EMULATOR_MODE_JTAG, EMULATOR_MODE_JTAG_XMEGA, EMULATOR_MODE_SPI, EVT_BREAK, jtagmkII_print_memory(), MSG_INFO, MSG_TRACE, PROGRAMMING, RSP_FAILED, RSP_ILLEGAL_BREAKPOINT, RSP_ILLEGAL_COMMAND, RSP_ILLEGAL_EMULATOR_MODE, RSP_ILLEGAL_JTAG_ID, RSP_ILLEGAL_MCU_STATE, RSP_ILLEGAL_MEMORY_RANGE, RSP_ILLEGAL_MEMORY_TYPE, RSP_ILLEGAL_PARAMETER, RSP_ILLEGAL_POWER_STATE, RSP_ILLEGAL_VALUE, RSP_MEMORY, RSP_NO_TARGET_POWER, RSP_OK, RSP_PARAMETER, RSP_SIGN_ON, RSP_SPI_DATA, RUNNING, STOPPED, and verbose.

Referenced by jtagmkII_chip_erase(), jtagmkII_close(), jtagmkII_close32(), jtagmkII_getparm(), jtagmkII_getsync(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_read_byte(), jtagmkII_reset(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), and jtagmkII_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_program_disable()

static int jtagmkII_program_disable ( PROGRAMMER * pgm )

static

{
  int status;
  unsigned char buf[1], *resp, c;
 
  if (!PDATA(pgm)->prog_enabled)
    return 0;
 
  buf[0] = CMND_LEAVE_PROGMODE;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_program_disable(): "
      "Sending leave progmode command: ",
      progname);
  jtagmkII_send(pgm, buf, 1);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_program_disable(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_program_disable(): "
                    "bad response to leave progmode command: %s\n",
                    progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  PDATA(pgm)->prog_enabled = 0;
  (void)jtagmkII_reset(pgm, 0x01);
 
  return 0;
}

References avrdude_message(), CMND_LEAVE_PROGMODE, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_reset(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, PDATA, pgm, progname, RSP_OK, verbose, and void().

Referenced by jtagmkII_disable(), and jtagmkII_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_program_enable()

static int jtagmkII_program_enable ( PROGRAMMER * pgm )

static

{
  int status;
  unsigned char buf[1], *resp, c;
  int use_ext_reset;
 
  if (PDATA(pgm)->prog_enabled)
    return 0;
 
  for (use_ext_reset = 0; use_ext_reset <= 1; use_ext_reset++) {
    buf[0] = CMND_ENTER_PROGMODE;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_program_enable(): "
        "Sending enter progmode command: ",
        progname);
    jtagmkII_send(pgm, buf, 1);
 
    status = jtagmkII_recv(pgm, &resp);
    if (status <= 0) {
      if (verbose >= 2)
  putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkII_program_enable(): "
                      "timeout/error communicating with programmer (status %d)\n",
                      progname, status);
      return -1;
    }
    if (verbose >= 3) {
      putc('\n', stderr);
      jtagmkII_prmsg(pgm, resp, status);
    } else if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
    c = resp[0];
    free(resp);
    if (c != RSP_OK) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_program_enable(): "
                      "bad response to enter progmode command: %s\n",
                      progname, jtagmkII_get_rc(c));
      if (c == RSP_ILLEGAL_JTAG_ID) {
  if (use_ext_reset == 0) {
    unsigned char parm[] = { 1};
          avrdude_message(MSG_INFO, "%s: retrying with external reset applied\n",
                            progname);
 
    (void)jtagmkII_setparm(pgm, PAR_EXTERNAL_RESET, parm);
    continue;
  }
 
  avrdude_message(MSG_INFO, "%s: JTAGEN fuse disabled?\n", progname);
  return -1;
      }
    }
  }
 
  PDATA(pgm)->prog_enabled = 1;
  return 0;
}

References avrdude_message(), CMND_ENTER_PROGMODE, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), jtagmkII_setparm(), MSG_INFO, MSG_NOTICE2, PAR_EXTERNAL_RESET, PDATA, pgm, progname, RSP_ILLEGAL_JTAG_ID, RSP_OK, verbose, and void().

Referenced by jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_read_byte(), and jtagmkII_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_program_enable_INFO()

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

static

{
  return 0;
}

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the caller graph for this function:

◆ jtagmkII_read_byte()

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

static

{
  unsigned char cmd[10];
  unsigned char *resp = NULL, *cache_ptr = NULL;
  int status, tries, unsupp;
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_read_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtagmkII_program_enable(pgm) < 0)
    return -1;
 
  cmd[0] = CMND_READ_MEMORY;
  unsupp = 0;
 
  addr += mem->offset;
  cmd[1] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_FLASH : MTYPE_FLASH_PAGE;
  if (strcmp(mem->desc, "flash") == 0 ||
      strcmp(mem->desc, "application") == 0 ||
      strcmp(mem->desc, "apptable") == 0 ||
      strcmp(mem->desc, "boot") == 0) {
    pagesize = PDATA(pgm)->flash_pagesize;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
    cache_ptr = PDATA(pgm)->flash_pagecache;
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    if ( (pgm->flag & PGM_FL_IS_DW) || ( p->flags & AVRPART_HAS_PDI ) ) {
      /* debugWire cannot use page access for EEPROM */
      cmd[1] = MTYPE_EEPROM;
    } else {
      cmd[1] = MTYPE_EEPROM_PAGE;
      pagesize = mem->page_size;
      paddr = addr & ~(pagesize - 1);
      paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
      cache_ptr = PDATA(pgm)->eeprom_pagecache;
    }
  } else if (strcmp(mem->desc, "lfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 0;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 1;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 2;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "lock", 4) == 0) {
    cmd[1] = MTYPE_LOCK_BITS;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
  } else if (strcmp(mem->desc, "usersig") == 0) {
    cmd[1] = MTYPE_USERSIG;
  } else if (strcmp(mem->desc, "prodsig") == 0) {
    cmd[1] = MTYPE_PRODSIG;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[1] = MTYPE_OSCCAL_BYTE;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "signature") == 0) {
    cmd[1] = MTYPE_SIGN_JTAG;
 
    if (pgm->flag & PGM_FL_IS_DW) {
      /*
       * In debugWire mode, there is no accessible memory area to read
       * the signature from, but the essential two bytes can be read
       * as a parameter from the ICE.
       */
      unsigned char parm[4];
 
      switch (addr) {
      case 0:
  *value = 0x1E;    /* Atmel vendor ID */
  break;
 
      case 1:
      case 2:
  if (jtagmkII_getparm(pgm, PAR_TARGET_SIGNATURE, parm) < 0)
    return -1;
  *value = parm[2 - addr];
  break;
 
      default:
  avrdude_message(MSG_INFO, "%s: illegal address %lu for signature memory\n",
    progname, addr);
  return -1;
      }
      return 0;
    }
 
  }
 
  /*
   * If the respective memory area is not supported under debugWire,
   * leave here.
   */
  if (unsupp) {
    *value = 42;
    return -1;
  }
 
  /*
   * To improve the read speed, we used 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 (pagesize) {
    u32_to_b4(cmd + 2, pagesize);
    u32_to_b4(cmd + 6, paddr);
  } else {
    u32_to_b4(cmd + 2, 1);
    u32_to_b4(cmd + 6, addr);
  }
 
  tries = 0;
  retry:
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_read_byte(): Sending read memory command: ",
      progname);
  jtagmkII_send(pgm, cmd, 10);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_byte(): "
        "timeout/error communicating with programmer (status %d)\n",
        progname, status);
    if (tries++ < 3)
      goto retry;
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_byte(): "
      "fatal timeout/error communicating with programmer (status %d)\n",
      progname, status);
    if (status < 0)
      resp = 0;
    goto fail;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  if (resp[0] != RSP_MEMORY) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_byte(): "
      "bad response to read memory command: %s\n",
      progname, jtagmkII_get_rc(resp[0]));
    goto fail;
  }
 
  if (pagesize) {
    *paddr_ptr = paddr;
    memcpy(cache_ptr, resp + 1, pagesize);
    *value = cache_ptr[addr & (pagesize - 1)];
  } else
    *value = resp[1];
 
  free(resp);
  return 0;
 
fail:
  free(resp);
  return -1;
}

References avrdude_message(), AVRPART_HAS_PDI, cmd, CMND_READ_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_getparm(), jtagmkII_prmsg(), jtagmkII_program_enable(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM, MTYPE_EEPROM_PAGE, MTYPE_FLASH, MTYPE_FLASH_PAGE, MTYPE_FUSE_BITS, MTYPE_LOCK_BITS, MTYPE_OSCCAL_BYTE, MTYPE_PRODSIG, MTYPE_SIGN_JTAG, MTYPE_USERSIG, avrmem::offset, avrmem::page_size, PAR_TARGET_SIGNATURE, PDATA, pgm, PGM_FL_IS_DW, progname, RSP_MEMORY, u32_to_b4(), and verbose.

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initialize(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_read_SABaddr()

static unsigned long jtagmkII_read_SABaddr	(	PROGRAMMER *	pgm,
		unsigned long	addr,
		unsigned int	prefix
	)

static

{
  unsigned char buf[6], *resp;
  int status;
  unsigned long val;
  unsigned long otimeout = serial_recv_timeout;
 
  serial_recv_timeout = 256;
 
  buf[0] = CMND_READ_SAB;
  buf[1] = prefix;
  u32_to_b4r(&buf[2], addr);
 
  if(jtagmkII_send(pgm, buf, 6) < 0)
    return ERROR_SAB;
 
  status = jtagmkII_recv(pgm, &resp);
  if(status <= 0 || resp[0] != 0x87) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_SABaddr(): "
        "timeout/error communicating with programmer (status %d) resp=%x\n",
        progname, status, resp[0]);
    serial_recv_timeout = otimeout;
 
    if(status > 0) {
      int i;
      avrdude_message(MSG_INFO, "Cmd: ");
      for(i=0; i<6; ++i) avrdude_message(MSG_INFO, "%2.2x ", buf[i]);
      avrdude_message(MSG_INFO, "\n");
      avrdude_message(MSG_INFO, "Data: ");
      for(i=0; i<status; ++i) avrdude_message(MSG_INFO, "%2.2x ", resp[i]);
      avrdude_message(MSG_INFO, "\n");
    }
    return ERROR_SAB;
  }
 
  if(status != 5) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_SABaddr(): "
        "wrong number of bytes (status %d)\n",
        progname, status);
    serial_recv_timeout = otimeout;
    return ERROR_SAB;
  }
 
  val = b4_to_u32r(&resp[1]);
  free(resp);
 
  if (verbose) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_read_SABaddr(): "
        "OCD Register %lx -> %4.4lx\n",
        progname, addr, val);
  }
  serial_recv_timeout = otimeout;
  return val;
}

References avrdude_message(), b4_to_u32r(), CMND_READ_SAB, ERROR_SAB, free(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, pgm, progname, serial_recv_timeout, u32_to_b4r(), and verbose.

Referenced by jtagmkII_chip_erase32(), jtagmkII_flash_clear_pagebuffer32(), jtagmkII_flash_erase32(), jtagmkII_flash_lock32(), jtagmkII_flash_write_page32(), jtagmkII_reset32(), and jtagmkII_smc_init32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_recv()

int jtagmkII_recv	(	PROGRAMMER *	pgm,
		unsigned char **	msg
	)

                                                         {
  unsigned short r_seqno;
  int rv;
 
  for (;;) {
    if ((rv = jtagmkII_recv_frame(pgm, msg, &r_seqno)) <= 0)
      return rv;
    avrdude_message(MSG_DEBUG, "%s: jtagmkII_recv(): "
        "Got message seqno %d (command_sequence == %d)\n",
        progname, r_seqno, PDATA(pgm)->command_sequence);
    if (r_seqno == PDATA(pgm)->command_sequence) {
      if (++(PDATA(pgm)->command_sequence) == 0xffff)
  PDATA(pgm)->command_sequence = 0;
      /*
       * We move the payload to the beginning of the buffer, to make
       * the job easier for the caller.  We have to return the
       * original pointer though, as the caller must free() it.
       */
      memmove(*msg, *msg + 8, rv);
 
      if (verbose == 4)
      {
          int i = rv;
          unsigned char *p = *msg;
          avrdude_message(MSG_TRACE, "%s: Recv: ", progname);
 
          while (i) {
            unsigned char c = *p;
            if (isprint(c)) {
              avrdude_message(MSG_TRACE, "%c ", c);
            }
            else {
              avrdude_message(MSG_TRACE, ". ");
            }
            avrdude_message(MSG_TRACE, "[%02x] ", c);
 
            p++;
            i--;
          }
          avrdude_message(MSG_TRACE, "\n");
      }
      return rv;
    }
    if (r_seqno == 0xffff) {
      avrdude_message(MSG_DEBUG, "%s: jtagmkII_recv(): got asynchronous event\n",
    progname);
    } else {
      avrdude_message(MSG_NOTICE2, "%s: jtagmkII_recv(): "
    "got wrong sequence number, %u != %u\n",
    progname, r_seqno, PDATA(pgm)->command_sequence);
    }
    free(*msg);
  }
}

References avrdude_message(), free(), jtagmkII_recv_frame(), MSG_DEBUG, MSG_NOTICE2, MSG_TRACE, PDATA, pgm, progname, and verbose.

Referenced by jtagmkII_avr32_reset(), jtagmkII_chip_erase(), jtagmkII_chip_erase32(), jtagmkII_close(), jtagmkII_close32(), jtagmkII_getparm(), jtagmkII_getsync(), jtagmkII_initialize32(), jtagmkII_open32(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_read_byte(), jtagmkII_read_SABaddr(), jtagmkII_reset(), jtagmkII_reset32(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), jtagmkII_write_byte(), and jtagmkII_write_SABaddr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_recv_frame()

static int jtagmkII_recv_frame	(	PROGRAMMER *	pgm,
		unsigned char **	msg,
		unsigned short *	seqno
	)

static

                                     {
  enum states { sSTART,
    /* NB: do NOT change the sequence of the following: */
    sSEQNUM1, sSEQNUM2,
    sSIZE1, sSIZE2, sSIZE3, sSIZE4,
    sTOKEN,
    sDATA,
    sCSUM1, sCSUM2,
    /* end NB */
    sDONE
  }  state = sSTART;
  unsigned long msglen = 0, l = 0;
  int headeridx = 0;
  int timeout = 0;
  int ignorpkt = 0;
  int rv;
  unsigned char c, *buf = NULL, header[8];
  unsigned short r_seqno = 0;
  unsigned short checksum = 0;
 
  struct timeval tv;
  double timeoutval = 100;  /* seconds */
  double tstart, tnow;
 
  avrdude_message(MSG_TRACE, "%s: jtagmkII_recv():\n", progname);
 
  gettimeofday(&tv, NULL);
  tstart = tv.tv_sec;
 
  while ( (state != sDONE ) && (!timeout) ) {
    if (state == sDATA) {
      rv = 0;
      if (ignorpkt) {
  /* skip packet's contents */
  for(l = 0; l < msglen; l++)
    rv += serial_recv(&pgm->fd, &c, 1);
      } else {
  rv += serial_recv(&pgm->fd, buf + 8, msglen);
      }
      if (rv != 0) {
  timedout:
  /* timeout in receive */
        avrdude_message(MSG_NOTICE2, "%s: jtagmkII_recv(): Timeout receiving packet\n",
                          progname);
  free(buf);
  return -1;
      }
    } else {
      if (serial_recv(&pgm->fd, &c, 1) != 0)
  goto timedout;
    }
    checksum ^= c;
 
    if (state < sDATA)
      header[headeridx++] = c;
 
    switch (state) {
      case sSTART:
        if (c == MESSAGE_START) {
          state = sSEQNUM1;
        } else {
    headeridx = 0;
  }
        break;
      case sSEQNUM1:
      case sSEQNUM2:
  r_seqno >>= 8;
  r_seqno |= ((unsigned)c << 8);
  state++;
  break;
      case sSIZE1:
      case sSIZE2:
      case sSIZE3:
      case sSIZE4:
  msglen >>= 8;
  msglen |= ((unsigned)c << 24);
        state++;
        break;
      case sTOKEN:
        if (c == TOKEN) {
    state = sDATA;
    if (msglen > MAX_MESSAGE) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_recv(): msglen %lu exceeds max message "
                            "size %u, ignoring message\n",
                            progname, msglen, MAX_MESSAGE);
      state = sSTART;
      headeridx = 0;
    } else if ((buf = malloc(msglen + 10)) == NULL) {
      avrdude_message(MSG_INFO, "%s: jtagmkII_recv(): out of memory\n",
        progname);
      ignorpkt++;
    } else {
      memcpy(buf, header, 8);
    }
  } else {
    state = sSTART;
    headeridx = 0;
  }
        break;
      case sDATA:
  /* The entire payload has been read above. */
  l = msglen + 8;
        state = sCSUM1;
        break;
      case sCSUM1:
      case sCSUM2:
  buf[l++] = c;
  if (state == sCSUM2) {
    if (crcverify(buf, msglen + 10)) {
      if (verbose >= 9)
        avrdude_message(MSG_TRACE2, "%s: jtagmkII_recv(): CRC OK",
          progname);
      state = sDONE;
    } else {
      avrdude_message(MSG_INFO, "%s: jtagmkII_recv(): checksum error\n",
        progname);
      free(buf);
      return -4;
    }
  } else
    state++;
        break;
      default:
        avrdude_message(MSG_INFO, "%s: jtagmkII_recv(): unknown state\n",
                progname);
  free(buf);
        return -5;
     }
 
     gettimeofday(&tv, NULL);
     tnow = tv.tv_sec;
     if (tnow - tstart > timeoutval) {
       avrdude_message(MSG_INFO, "%s: jtagmkII_recv_frame(): timeout\n",
               progname);
       return -1;
     }
 
  }
  avrdude_message(MSG_DEBUG, "\n");
 
  *seqno = r_seqno;
  *msg = buf;
 
  return msglen;
}

References avrdude_message(), crcverify(), programmer_t::fd, free(), gettimeofday(), malloc(), MAX_MESSAGE, MESSAGE_START, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MSG_TRACE, MSG_TRACE2, pgm, progname, serial_recv, and verbose.

Referenced by jtagmkII_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_reset()

static int jtagmkII_reset	(	PROGRAMMER *	pgm,
		unsigned char	flags
	)

static

{
  int status;
  unsigned char buf[2], *resp, c;
 
  /*
   * In debugWire mode, don't reset.  Do a forced stop, and tell the
   * ICE to stop any timers, too.
   */
  if (pgm->flag & PGM_FL_IS_DW) {
    unsigned char parm[] = { 0 };
 
    (void)jtagmkII_setparm(pgm, PAR_TIMERS_RUNNING, parm);
  }
 
  buf[0] = (pgm->flag & PGM_FL_IS_DW)? CMND_FORCED_STOP: CMND_RESET;
  buf[1] = (pgm->flag & PGM_FL_IS_DW)? 1: flags;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_reset(): Sending %s command: ",
      progname, (pgm->flag & PGM_FL_IS_DW)? "stop": "reset");
  jtagmkII_send(pgm, buf, 2);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_reset(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_reset(): "
                    "bad response to reset command: %s\n",
                    progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMND_FORCED_STOP, CMND_RESET, programmer_t::flag, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), jtagmkII_setparm(), MSG_INFO, MSG_NOTICE2, PAR_TIMERS_RUNNING, pgm, PGM_FL_IS_DW, progname, RSP_OK, verbose, and void().

Referenced by jtagmkII_getsync(), jtagmkII_initialize(), and jtagmkII_program_disable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_reset32()

static int jtagmkII_reset32	(	PROGRAMMER *	pgm,
		unsigned short	flags
	)

static

{
  int status, j, lineno;
  unsigned char *resp, buf[3];
  unsigned long val=0;
 
  avrdude_message(MSG_NOTICE, "%s: jtagmkII_reset32(%2.2x)\n",
          progname, flags);
 
  status = -1;
 
  // Happens at the start of a programming operation
  if(flags & AVR32_RESET_READ) {
    buf[0] = CMND_GET_IR;
    buf[1] = 0x11;
    status = jtagmkII_send(pgm, buf, 2);
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_recv(pgm, &resp);
    if (status != 2 || resp[0] != 0x87 || resp[1] != 01)
      {lineno = __LINE__; goto eRR;};
  }
 
  if(flags & (AVR32_RESET_WRITE | AVR32_SET4RUNNING)) {
    // AVR_RESET(0x1F)
    status = jtagmkII_avr32_reset(pgm, 0x1F, 0x01, 0x00);
    if(status < 0) {lineno = __LINE__; goto eRR;}
    // AVR_RESET(0x07)
    status = jtagmkII_avr32_reset(pgm, 0x07, 0x11, 0x1F);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
 
  //if(flags & AVR32_RESET_COMMON)
  {
    val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
    if(val != 0) {lineno = __LINE__; goto eRR;}
    val = jtagmkII_read_SABaddr(pgm, AVR32_DC, 0x01);
    if(val != 0) {lineno = __LINE__; goto eRR;}
  }
 
  if(flags & (AVR32_RESET_READ | AVR32_RESET_CHIP_ERASE)) {
    status = jtagmkII_write_SABaddr(pgm, AVR32_DC, 0x01,
                                    AVR32_DC_DBE | AVR32_DC_DBR);
    if(status < 0) return -1;
  }
 
  if(flags & (AVR32_RESET_WRITE | AVR32_SET4RUNNING)) {
    status = jtagmkII_write_SABaddr(pgm, AVR32_DC, 0x01,
             AVR32_DC_ABORT | AVR32_DC_RESET | AVR32_DC_DBE | AVR32_DC_DBR);
    if(status < 0) return -1;
    for(j=0; j<21; ++j) {
      val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
    }
    if(val != 0x04000000) {lineno = __LINE__; goto eRR;}
 
    // AVR_RESET(0x00)
    status = jtagmkII_avr32_reset(pgm, 0x00, 0x01, 0x07);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
//  if(flags & (AVR32_RESET_READ | AVR32_RESET_WRITE))
  {
    for(j=0; j<2; ++j) {
      val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
      if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
      if((val&0x05000020) != 0x05000020) {lineno = __LINE__; goto eRR;}
    }
  }
 
  //if(flags & (AVR32_RESET_READ | AVR32_RESET_WRITE | AVR32_RESET_CHIP_ERASE))
  {
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val != 0x00000000) {lineno = __LINE__; goto eRR;}
  }
 
  // Read chip configuration - common for all
  if(flags & (AVR32_RESET_READ | AVR32_RESET_WRITE | AVR32_RESET_CHIP_ERASE)) {
    for(j=0; j<2; ++j) {
      val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
      if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
      if((val&0x05000020) != 0x05000020) {lineno = __LINE__; goto eRR;}
    }
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val != 0x00000000) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe1b00040);  // mfsr R0, 256
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DCEMU, 0x01, 0x00000000);
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe5b00045);  // mtdr R0, 276
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
    if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
    if((val&0x05000020) != 0x05000020) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val != 0x00000000) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe1b00041);  // mfsr R0, 260
    if(status < 0) {lineno = __LINE__; goto eRR;}
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DCEMU, 0x01, 0x00000000);
    if(status < 0) {lineno = __LINE__; goto eRR;}
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe5b00045);  // mtdr R0, 276
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, 0x00000010, 0x06); // need to recheck who does this...
    if(val != 0x00000000) {lineno = __LINE__; goto eRR;}
  }
 
  if(flags & AVR32_RESET_CHIP_ERASE) {
    status = jtagmkII_avr32_reset(pgm, 0x1f, 0x01, 0x00);
    if(status < 0) {lineno = __LINE__; goto eRR;}
    status = jtagmkII_avr32_reset(pgm, 0x01, 0x11, 0x1f);
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
 
  if(flags & AVR32_SET4RUNNING) {
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe1b00014);  // mfsr R0, 80
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe7b00044);  // mtdr 272, R0
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCSR, 0x01);
    if(val != 0x00000001) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DCCPU, 0x01);
    if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DCEMU, 0x01, 0x00000000);
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xe5b00045);  // mfdr R0, 276
    if(status < 0) {lineno = __LINE__; goto eRR;}
 
    val = jtagmkII_read_SABaddr(pgm, AVR32_DS, 0x01);
    if(val == ERROR_SAB) {lineno = __LINE__; goto eRR;}
    if((val&0x05000020) != 0x05000020) {lineno = __LINE__; goto eRR;}
 
    status = jtagmkII_write_SABaddr(pgm, AVR32_DINST, 0x01, 0xd623d703);  // retd
    if(status < 0) {lineno = __LINE__; goto eRR;}
  }
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_reset32(): "
      "failed at line %d (status=%x val=%lx)\n",
      progname, lineno, status, val);
    return -1;
}

References AVR32_DC, AVR32_DC_ABORT, AVR32_DC_DBE, AVR32_DC_DBR, AVR32_DC_RESET, AVR32_DCCPU, AVR32_DCEMU, AVR32_DCSR, AVR32_DINST, AVR32_DS, AVR32_RESET_CHIP_ERASE, AVR32_RESET_READ, AVR32_RESET_WRITE, AVR32_SET4RUNNING, avrdude_message(), CMND_GET_IR, ERROR_SAB, jtagmkII_avr32_reset(), jtagmkII_read_SABaddr(), jtagmkII_recv(), jtagmkII_send(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, MSG_NOTICE, pgm, and progname.

Referenced by jtagmkII_chip_erase32(), jtagmkII_paged_load32(), and jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_send()

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

{
  unsigned char *buf;
 
  avrdude_message(MSG_DEBUG, "\n%s: jtagmkII_send(): sending %lu bytes\n",
      progname, (unsigned long)len);
 
  if ((buf = malloc(len + 10)) == NULL)
    {
      avrdude_message(MSG_INFO, "%s: jtagmkII_send(): out of memory",
        progname);
      return -1;
    }
 
  buf[0] = MESSAGE_START;
  u16_to_b2(buf + 1, PDATA(pgm)->command_sequence);
  u32_to_b4(buf + 3, len);
  buf[7] = TOKEN;
  memcpy(buf + 8, data, len);
 
  crcappend(buf, len + 8);
 
  if (serial_send(&pgm->fd, buf, len + 10) != 0) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_send(): failed to send command to serial port\n",
                    progname);
    free(buf);
    return -1;
  }
 
  free(buf);
 
  return 0;
}

References avrdude_message(), crcappend(), programmer_t::fd, free(), malloc(), MESSAGE_START, MSG_DEBUG, MSG_INFO, PDATA, pgm, progname, serial_send, TOKEN, u16_to_b2(), and u32_to_b4().

Referenced by jtagmkII_avr32_reset(), jtagmkII_chip_erase(), jtagmkII_chip_erase32(), jtagmkII_close(), jtagmkII_close32(), jtagmkII_getparm(), jtagmkII_getsync(), jtagmkII_initialize32(), jtagmkII_open32(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_read_byte(), jtagmkII_read_SABaddr(), jtagmkII_reset(), jtagmkII_reset32(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), jtagmkII_setparm(), jtagmkII_write_byte(), and jtagmkII_write_SABaddr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_set_devdescr()

static void jtagmkII_set_devdescr	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

static

{
  int status;
  unsigned char *resp, c;
  LNODEID ln;
  AVRMEM * m;
  struct {
    unsigned char cmd;
    struct device_descriptor dd;
  } sendbuf;
 
  memset(&sendbuf, 0, sizeof sendbuf);
  sendbuf.cmd = CMND_SET_DEVICE_DESCRIPTOR;
  sendbuf.dd.ucSPMCRAddress = p->spmcr;
  sendbuf.dd.ucRAMPZAddress = p->rampz;
  sendbuf.dd.ucIDRAddress = p->idr;
  u16_to_b2(sendbuf.dd.EECRAddress, p->eecr);
  sendbuf.dd.ucAllowFullPageBitstream =
    (p->flags & AVRPART_ALLOWFULLPAGEBITSTREAM) != 0;
  sendbuf.dd.EnablePageProgramming =
    (p->flags & AVRPART_ENABLEPAGEPROGRAMMING) != 0;
  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
    m = ldata(ln);
    if (strcmp(m->desc, "flash") == 0) {
      if (m->page_size > 256)
        PDATA(pgm)->flash_pagesize = 256;
      else
        PDATA(pgm)->flash_pagesize = m->page_size;
      u32_to_b4(sendbuf.dd.ulFlashSize, m->size);
      u16_to_b2(sendbuf.dd.uiFlashPageSize, m->page_size);
      u16_to_b2(sendbuf.dd.uiFlashpages, m->size / m->page_size);
      if (p->flags & AVRPART_HAS_DW) {
  memcpy(sendbuf.dd.ucFlashInst, p->flash_instr, FLASH_INSTR_SIZE);
  memcpy(sendbuf.dd.ucEepromInst, p->eeprom_instr, EEPROM_INSTR_SIZE);
      }
    } else if (strcmp(m->desc, "eeprom") == 0) {
      sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
    }
  }
  sendbuf.dd.ucCacheType =
    (p->flags & AVRPART_HAS_PDI)? 0x02 /* ATxmega */: 0x00;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_set_devdescr(): "
      "Sending set device descriptor command: ",
      progname);
  jtagmkII_send(pgm, (unsigned char *)&sendbuf,
    PDATA(pgm)->device_descriptor_length + sizeof(unsigned char));
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_set_devdescr(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_set_devdescr(): "
                    "bad response to set device descriptor command: %s\n",
                    progname, jtagmkII_get_rc(c));
  }
}

References avrdude_message(), AVRPART_ALLOWFULLPAGEBITSTREAM, AVRPART_ENABLEPAGEPROGRAMMING, AVRPART_HAS_DW, AVRPART_HAS_PDI, cmd, CMND_SET_DEVICE_DESCRIPTOR, avrmem::desc, avrpart::eecr, avrpart::eeprom_instr, EEPROM_INSTR_SIZE, avrpart::flags, avrpart::flash_instr, FLASH_INSTR_SIZE, free(), avrpart::idr, jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), ldata(), lfirst(), lnext(), avrpart::mem, MSG_INFO, MSG_NOTICE2, avrmem::page_size, PDATA, pgm, progname, avrpart::rampz, RSP_OK, avrmem::size, avrpart::spmcr, u16_to_b2(), u32_to_b4(), and verbose.

Referenced by jtagmkII_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_set_sck_period()

static int jtagmkII_set_sck_period	(	PROGRAMMER *	pgm,
		double	v
	)

static

{
  unsigned char dur;
 
  v = 1 / v;      /* convert to frequency */
  if (v >= 6.4e6)
    dur = 0;
  else if (v >= 2.8e6)
    dur = 1;
  else if (v >= 20.9e3)
    dur = (unsigned char)(5.35e6 / v);
  else
    dur = 255;
 
  return jtagmkII_setparm(pgm, PAR_OCD_JTAG_CLK, &dur);
}

References jtagmkII_setparm(), PAR_OCD_JTAG_CLK, and pgm.

Referenced by jtagmkII_dragon_initpgm(), jtagmkII_initialize(), and jtagmkII_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_set_xmega_params()

static void jtagmkII_set_xmega_params	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

static

{
  int status;
  unsigned char *resp, c;
  LNODEID ln;
  AVRMEM * m;
  struct {
    unsigned char cmd;
    struct xmega_device_desc dd;
  } sendbuf;
 
  memset(&sendbuf, 0, sizeof sendbuf);
  sendbuf.cmd = CMND_SET_XMEGA_PARAMS;
  u16_to_b2(sendbuf.dd.whatever, 0x0002);
  sendbuf.dd.datalen = 47;
  u16_to_b2(sendbuf.dd.nvm_base_addr, p->nvm_base);
  u16_to_b2(sendbuf.dd.mcu_base_addr, p->mcu_base);
 
  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
    m = ldata(ln);
    if (strcmp(m->desc, "flash") == 0) {
      if (m->page_size > 256)
        PDATA(pgm)->flash_pagesize = 256;
      else
        PDATA(pgm)->flash_pagesize = m->page_size;
      u16_to_b2(sendbuf.dd.flash_page_size, m->page_size);
    } else if (strcmp(m->desc, "eeprom") == 0) {
      sendbuf.dd.eeprom_page_size = m->page_size;
      u16_to_b2(sendbuf.dd.eeprom_size, m->size);
      u32_to_b4(sendbuf.dd.nvm_eeprom_offset, m->offset);
    } else if (strcmp(m->desc, "application") == 0) {
      u32_to_b4(sendbuf.dd.app_size, m->size);
      u32_to_b4(sendbuf.dd.nvm_app_offset, m->offset);
    } else if (strcmp(m->desc, "boot") == 0) {
      u16_to_b2(sendbuf.dd.boot_size, m->size);
      u32_to_b4(sendbuf.dd.nvm_boot_offset, m->offset);
    } else if (strcmp(m->desc, "fuse1") == 0) {
      u32_to_b4(sendbuf.dd.nvm_fuse_offset, m->offset & ~7);
    } else if (strncmp(m->desc, "lock", 4) == 0) {
      u32_to_b4(sendbuf.dd.nvm_lock_offset, m->offset);
    } else if (strcmp(m->desc, "usersig") == 0) {
      u32_to_b4(sendbuf.dd.nvm_user_sig_offset, m->offset);
    } else if (strcmp(m->desc, "prodsig") == 0) {
      u32_to_b4(sendbuf.dd.nvm_prod_sig_offset, m->offset);
    } else if (strcmp(m->desc, "data") == 0) {
      u32_to_b4(sendbuf.dd.nvm_data_offset, m->offset);
    }
  }
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_set_xmega_params(): "
      "Sending set Xmega params command: ",
      progname);
  jtagmkII_send(pgm, (unsigned char *)&sendbuf, sizeof sendbuf);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_set_xmega_params(): "
                    "timeout/error communicating with programmer (status %d)\n",
                    progname, status);
    return;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_set_xmega_params(): "
                    "bad response to set device descriptor command: %s\n",
                    progname, jtagmkII_get_rc(c));
  }
}

References avrdude_message(), cmd, CMND_SET_XMEGA_PARAMS, avrmem::desc, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), ldata(), lfirst(), lnext(), avrpart::mcu_base, avrpart::mem, MSG_INFO, MSG_NOTICE2, avrpart::nvm_base, avrmem::offset, avrmem::page_size, PDATA, pgm, progname, RSP_OK, avrmem::size, u16_to_b2(), u32_to_b4(), and verbose.

Referenced by jtagmkII_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_setparm()

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

static

{
  int status;
  /*
   * As the maximal parameter length is 4 bytes, we use a fixed-length
   * buffer, as opposed to malloc()ing it.
   */
  unsigned char buf[2 + 4], *resp, c;
  size_t size;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_setparm()\n", progname);
 
  switch (parm) {
  case PAR_HW_VERSION: size = 2; break;
  case PAR_FW_VERSION: size = 4; break;
  case PAR_EMULATOR_MODE: size = 1; break;
  case PAR_BAUD_RATE: size = 1; break;
  case PAR_OCD_VTARGET: size = 2; break;
  case PAR_OCD_JTAG_CLK: size = 1; break;
  case PAR_TIMERS_RUNNING: size = 1; break;
  case PAR_EXTERNAL_RESET: size = 1; break;
  case PAR_DAISY_CHAIN_INFO: size = 4; break;
  case PAR_PDI_OFFSET_START:
  case PAR_PDI_OFFSET_END: size = 4; break;
  default:
    avrdude_message(MSG_INFO, "%s: jtagmkII_setparm(): unknown parameter 0x%02x\n",
      progname, parm);
    return -1;
  }
 
  buf[0] = CMND_SET_PARAMETER;
  buf[1] = parm;
  memcpy(buf + 2, value, size);
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_setparm(): "
      "Sending set parameter command (parm 0x%02x, %u bytes): ",
      progname, parm, (unsigned)size);
  jtagmkII_send(pgm, buf, size + 2);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_setparm(): "
      "timeout/error communicating with programmer (status %d)\n",
      progname, status);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  c = resp[0];
  free(resp);
  if (c != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_setparm(): "
      "bad response to set parameter command: %s\n",
      progname, jtagmkII_get_rc(c));
    return -1;
  }
 
  return 0;
}

References avrdude_message(), CMND_SET_PARAMETER, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_recv(), jtagmkII_send(), MSG_INFO, MSG_NOTICE2, PAR_BAUD_RATE, PAR_DAISY_CHAIN_INFO, PAR_EMULATOR_MODE, PAR_EXTERNAL_RESET, PAR_FW_VERSION, PAR_HW_VERSION, PAR_OCD_JTAG_CLK, PAR_OCD_VTARGET, PAR_PDI_OFFSET_END, PAR_PDI_OFFSET_START, PAR_TIMERS_RUNNING, pgm, progname, RSP_OK, and verbose.

Referenced by jtagmkII_getsync(), jtagmkII_initialize(), jtagmkII_initialize32(), jtagmkII_program_enable(), jtagmkII_reset(), and jtagmkII_set_sck_period().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_setup()

void jtagmkII_setup ( PROGRAMMER * pgm )

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

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

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_smc_init32()

static int jtagmkII_smc_init32 ( PROGRAMMER * pgm )

static

{
  int status, lineno;
  unsigned long val;
 
  // HMATRIX 0xFFFF1000
  status = jtagmkII_write_SABaddr(pgm, 0xffff1018, 0x05, 0x04000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1024, 0x05, 0x04000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1008, 0x05, 0x04000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1078, 0x05, 0x04000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1088, 0x05, 0x04000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_write_SABaddr(pgm, 0xffff1018, 0x05, 0x08000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1024, 0x05, 0x08000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1008, 0x05, 0x08000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1078, 0x05, 0x08000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1088, 0x05, 0x08000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_write_SABaddr(pgm, 0xffff1018, 0x05, 0x10000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1024, 0x05, 0x10000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1008, 0x05, 0x10000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1078, 0x05, 0x10000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1088, 0x05, 0x10000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_write_SABaddr(pgm, 0xffff1018, 0x05, 0x00020000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1024, 0x05, 0x00020000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1008, 0x05, 0x00020000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1078, 0x05, 0x00020000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1088, 0x05, 0x00020000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_write_SABaddr(pgm, 0xffff1018, 0x05, 0x02000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1024, 0x05, 0x02000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1008, 0x05, 0x02000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1078, 0x05, 0x02000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xffff1088, 0x05, 0x02000000);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  status = jtagmkII_write_SABaddr(pgm, 0xfffe1c00, 0x05, 0x00010001);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xfffe1c04, 0x05, 0x05070a0b);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xfffe1c08, 0x05, 0x000b000c);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  status = jtagmkII_write_SABaddr(pgm, 0xfffe1c0c, 0x05, 0x00031103);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  // switchToClockSource
  val = jtagmkII_read_SABaddr(pgm, 0xffff0c28, 0x05);
  if (val != 0x00000000) {lineno = __LINE__; goto eRR;} // OSC 0
  status = jtagmkII_write_SABaddr(pgm, 0xffff0c28, 0x05, 0x0000607);
  if (status < 0) {lineno = __LINE__; goto eRR;}
  val = jtagmkII_read_SABaddr(pgm, 0xffff0c00, 0x05);
  if (val != 0x00000000) {lineno = __LINE__; goto eRR;} // PLL 0
  status = jtagmkII_write_SABaddr(pgm, 0xffff0c00, 0x05, 0x0000004);
  if (status < 0) {lineno = __LINE__; goto eRR;} // Power Manager
  status = jtagmkII_write_SABaddr(pgm, 0xffff0c00, 0x05, 0x0000005);
  if (status < 0) {lineno = __LINE__; goto eRR;}
 
  usleep(1000000);
 
  val = jtagmkII_read_SABaddr(pgm, 0xfffe1408, 0x05);
  if (val != 0x0000a001) {lineno = __LINE__; goto eRR;} // PLL 0
 
  // need a small delay to let clock stabliize
  usleep(50*1000);
 
  return 0;
 
  eRR:
    avrdude_message(MSG_INFO, "%s: jtagmkII_smc_init32(): "
      "failed at line %d\n",
      progname, lineno);
    return -1;
}

References avrdude_message(), jtagmkII_read_SABaddr(), jtagmkII_write_SABaddr(), lineno, MSG_INFO, pgm, progname, and usleep().

Referenced by jtagmkII_paged_load32(), and jtagmkII_paged_write32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_teardown()

void jtagmkII_teardown ( PROGRAMMER * pgm )

{
  free(pgm->cookie);
}

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

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_write_byte()

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

static

{
  unsigned char cmd[12];
  unsigned char *resp = NULL, writedata, writedata2 = 0xFF;
  int status, tries, need_progmode = 1, unsupp = 0, writesize = 1;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_write_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  addr += mem->offset;
 
  writedata = data;
  cmd[0] = CMND_WRITE_MEMORY;
  cmd[1] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_FLASH : MTYPE_SPM;
  if (strcmp(mem->desc, "flash") == 0) {
     if ((addr & 1) == 1) {
       /* odd address = high byte */
       writedata = 0xFF;  /* don't modify the low byte */
       writedata2 = data;
       addr &= ~1L;
     }
     writesize = 2;
     need_progmode = 0;
     PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
     if (pgm->flag & PGM_FL_IS_DW)
       unsupp = 1;
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    cmd[1] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_EEPROM_XMEGA: MTYPE_EEPROM;
    need_progmode = 0;
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
  } else if (strcmp(mem->desc, "lfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 0;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 1;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 2;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
  } else if (strcmp(mem->desc, "usersig") == 0) {
    cmd[1] = MTYPE_USERSIG;
  } else if (strcmp(mem->desc, "prodsig") == 0) {
    cmd[1] = MTYPE_PRODSIG;
  } else if (strncmp(mem->desc, "lock", 4) == 0) {
    cmd[1] = MTYPE_LOCK_BITS;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[1] = MTYPE_OSCCAL_BYTE;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "signature") == 0) {
    cmd[1] = MTYPE_SIGN_JTAG;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  }
 
  if (unsupp)
    return -1;
 
  if (need_progmode) {
    if (jtagmkII_program_enable(pgm) < 0)
      return -1;
  } else {
    if (jtagmkII_program_disable(pgm) < 0)
      return -1;
  }
 
  u32_to_b4(cmd + 2, writesize);
  u32_to_b4(cmd + 6, addr);
  cmd[10] = writedata;
  cmd[11] = writedata2;
 
  tries = 0;
  retry:
  avrdude_message(MSG_NOTICE2, "%s: jtagmkII_write_byte(): Sending write memory command: ",
      progname);
  jtagmkII_send(pgm, cmd, 10 + writesize);
 
  status = jtagmkII_recv(pgm, &resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_NOTICE2, "%s: jtagmkII_write_byte(): "
        "timeout/error communicating with programmer (status %d)\n",
        progname, status);
    if (tries++ < 3)
      goto retry;
    avrdude_message(MSG_INFO, "%s: jtagmkII_write_byte(): "
      "fatal timeout/error communicating with programmer (status %d)\n",
      progname, status);
    goto fail;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkII_prmsg(pgm, resp, status);
  } else if (verbose == 2)
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", resp[0], status);
  if (resp[0] != RSP_OK) {
    avrdude_message(MSG_INFO, "%s: jtagmkII_write_byte(): "
      "bad response to write memory command: %s\n",
      progname, jtagmkII_get_rc(resp[0]));
    goto fail;
  }
 
  free(resp);
  return 0;
 
fail:
  free(resp);
  return -1;
}

References avrdude_message(), AVRPART_HAS_PDI, cmd, CMND_WRITE_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtagmkII_get_rc(), jtagmkII_prmsg(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_recv(), jtagmkII_send(), long, MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM, MTYPE_EEPROM_XMEGA, MTYPE_FLASH, MTYPE_FUSE_BITS, MTYPE_LOCK_BITS, MTYPE_OSCCAL_BYTE, MTYPE_PRODSIG, MTYPE_SIGN_JTAG, MTYPE_SPM, MTYPE_USERSIG, avrmem::offset, PDATA, pgm, PGM_FL_IS_DW, progname, RSP_OK, u32_to_b4(), and verbose.

Referenced by jtagmkII_avr32_initpgm(), jtagmkII_dragon_dw_initpgm(), jtagmkII_dragon_initpgm(), jtagmkII_dragon_pdi_initpgm(), jtagmkII_dw_initpgm(), jtagmkII_initpgm(), jtagmkII_paged_write(), and jtagmkII_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jtagmkII_write_SABaddr()

static int jtagmkII_write_SABaddr	(	PROGRAMMER *	pgm,
		unsigned long	addr,
		unsigned int	prefix,
		unsigned long	val
	)

static

{
  unsigned char buf[10], *resp;
  int status;
 
  buf[0] = CMND_WRITE_SAB;
  buf[1] = prefix;
  u32_to_b4r(&buf[2], addr);
  u32_to_b4r(&buf[6], val);
 
  if(jtagmkII_send(pgm, buf, 10) < 0)
    return -1;
 
  status = jtagmkII_recv(pgm, &resp);
  if(status <= 0 || resp[0] != RSP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_write_SABaddr(): "
        "timeout/error communicating with programmer (status %d)\n",
        progname, status);
    return -1;
  }
 
 
  if (verbose) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkII_write_SABaddr(): "
        "OCD Register %lx -> %4.4lx\n",
        progname, addr, val);
  }
  return 0;
}

References avrdude_message(), CMND_WRITE_SAB, jtagmkII_recv(), jtagmkII_send(), MSG_INFO, pgm, progname, RSP_OK, u32_to_b4r(), and verbose.

Referenced by jtagmkII_flash_clear_pagebuffer32(), jtagmkII_flash_erase32(), jtagmkII_flash_lock32(), jtagmkII_flash_write_page32(), jtagmkII_reset32(), and jtagmkII_smc_init32().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ u16_to_b2()

static void u16_to_b2	(	unsigned char *	b,
		unsigned short	l
	)

static

{
  b[0] = l & 0xff;
  b[1] = (l >> 8) & 0xff;
}

Referenced by jtagmkII_send(), jtagmkII_set_devdescr(), and jtagmkII_set_xmega_params().

Here is the caller graph for this function:

◆ u32_to_b4()

static void u32_to_b4	(	unsigned char *	b,
		unsigned long	l
	)

static

{
  b[0] = l & 0xff;
  b[1] = (l >> 8) & 0xff;
  b[2] = (l >> 16) & 0xff;
  b[3] = (l >> 24) & 0xff;
}

Referenced by jtagmkII_initialize(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_write(), jtagmkII_read_byte(), jtagmkII_send(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), and jtagmkII_write_byte().

Here is the caller graph for this function:

◆ u32_to_b4r()

static void u32_to_b4r	(	unsigned char *	b,
		unsigned long	l
	)

static

{
  b[3] = l & 0xff;
  b[2] = (l >> 8) & 0xff;
  b[1] = (l >> 16) & 0xff;
  b[0] = (l >> 24) & 0xff;
}

Referenced by jtagmkII_paged_load32(), jtagmkII_paged_write32(), jtagmkII_read_SABaddr(), and jtagmkII_write_SABaddr().

Here is the caller graph for this function:

Variable Documentation

◆ jtagmkII_avr32_desc

const char jtagmkII_avr32_desc[] = "Atmel JTAG ICE mkII in AVR32 mode"

◆ jtagmkII_desc

const char jtagmkII_desc[] = "Atmel JTAG ICE mkII"

◆ jtagmkII_dragon_desc

const char jtagmkII_dragon_desc[] = "Atmel AVR Dragon in JTAG mode"

◆ jtagmkII_dragon_dw_desc

const char jtagmkII_dragon_dw_desc[] = "Atmel AVR Dragon in debugWire mode"

◆ jtagmkII_dragon_pdi_desc

const char jtagmkII_dragon_pdi_desc[] = "Atmel AVR Dragon in PDI mode"

◆ jtagmkII_dw_desc

const char jtagmkII_dw_desc[] = "Atmel JTAG ICE mkII in debugWire mode"

◆ jtagmkII_pdi_desc

const char jtagmkII_pdi_desc[] = "Atmel JTAG ICE mkII in PDI mode"

◆ [struct]

struct { ... } jtagresults[]

Initial value:

= {
 
}

Referenced by jtagmkII_get_rc().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ ERROR_SAB

◆ FWVER

◆ MAXTRIES

◆ OCDEN

◆ PDATA

◆ PGM_FL_IS_DW

◆ PGM_FL_IS_JTAG

◆ PGM_FL_IS_PDI

◆ RC

Function Documentation

◆ b2_to_u16()

◆ b4_to_u32()

◆ b4_to_u32r()

◆ jtagmkII_avr32_initpgm()

◆ jtagmkII_avr32_reset()

◆ jtagmkII_chip_erase()

◆ jtagmkII_chip_erase32()

◆ jtagmkII_chip_erase_dw()

◆ jtagmkII_close()

◆ jtagmkII_close32()

◆ jtagmkII_disable()

◆ jtagmkII_display()

◆ jtagmkII_dragon_dw_initpgm()

◆ jtagmkII_dragon_initpgm()

◆ jtagmkII_dragon_open()

◆ jtagmkII_dragon_open_dw()

◆ jtagmkII_dragon_open_pdi()

◆ jtagmkII_dragon_pdi_initpgm()

◆ jtagmkII_drain()

◆ jtagmkII_dw_initpgm()

◆ jtagmkII_enable()

◆ jtagmkII_flash_clear_pagebuffer32()

◆ jtagmkII_flash_erase32()

◆ jtagmkII_flash_lock32()

◆ jtagmkII_flash_write_page32()

◆ jtagmkII_get_baud()

◆ jtagmkII_get_rc()

◆ jtagmkII_getparm()

◆ jtagmkII_getsync()

◆ jtagmkII_initialize()

◆ jtagmkII_initialize32()

◆ jtagmkII_initpgm()

◆ jtagmkII_memaddr()

◆ jtagmkII_memtype()

◆ jtagmkII_open()

◆ jtagmkII_open32()

◆ jtagmkII_open_dw()

◆ jtagmkII_open_pdi()

◆ jtagmkII_page_erase()

◆ jtagmkII_paged_load()

◆ jtagmkII_paged_load32()

◆ jtagmkII_paged_write()

◆ jtagmkII_paged_write32()

◆ jtagmkII_parseextparms()

◆ jtagmkII_pdi_initpgm()

◆ jtagmkII_print_memory()

◆ jtagmkII_print_parms()

◆ jtagmkII_print_parms1()

◆ jtagmkII_prmsg()

◆ jtagmkII_program_disable()

◆ jtagmkII_program_enable()

◆ jtagmkII_program_enable_INFO()

◆ jtagmkII_read_byte()

◆ jtagmkII_read_SABaddr()

◆ jtagmkII_recv()

◆ jtagmkII_recv_frame()

◆ jtagmkII_reset()

◆ jtagmkII_reset32()

◆ jtagmkII_send()

◆ jtagmkII_set_devdescr()

◆ jtagmkII_set_sck_period()

◆ jtagmkII_set_xmega_params()

◆ jtagmkII_setparm()

◆ jtagmkII_setup()

◆ jtagmkII_smc_init32()