jtag3.c File Reference

#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 "jtag3.h"
#include "jtag3_private.h"
#include "usbdevs.h"

Include dependency graph for jtag3.c:

Go to the source code of this file.

Classes
struct	pdata

Macros
#define	PDATA(pgm)   ((struct pdata *)(pgm->cookie))
#define	PGM_FL_IS_DW   (0x0001)
#define	PGM_FL_IS_PDI   (0x0002)
#define	PGM_FL_IS_JTAG   (0x0004)
#define	PGM_FL_IS_EDBG   (0x0008)

Functions
static int	jtag3_open (PROGRAMMER *pgm, char *port)
static int	jtag3_edbg_prepare (PROGRAMMER *pgm)
static int	jtag3_edbg_signoff (PROGRAMMER *pgm)
static int	jtag3_edbg_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	jtag3_edbg_recv_frame (PROGRAMMER *pgm, unsigned char **msg)
static int	jtag3_initialize (PROGRAMMER *pgm, AVRPART *p)
static int	jtag3_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	jtag3_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	jtag3_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	jtag3_set_sck_period (PROGRAMMER *pgm, double v)
static void	jtag3_print_parms1 (PROGRAMMER *pgm, const char *p)
static int	jtag3_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static unsigned char	jtag3_memtype (PROGRAMMER *pgm, AVRPART *p, unsigned long addr)
static unsigned int	jtag3_memaddr (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr)
void	jtag3_setup (PROGRAMMER *pgm)
void	jtag3_teardown (PROGRAMMER *pgm)
static unsigned long	b4_to_u32 (unsigned char *b)
static void	u32_to_b4 (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 void	jtag3_print_data (unsigned char *b, size_t s)
static void	jtag3_prmsg (PROGRAMMER *pgm, unsigned char *data, size_t len)
static void	jtag3_prevent (PROGRAMMER *pgm, unsigned char *data, size_t len)
int	jtag3_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	jtag3_drain (PROGRAMMER *pgm, int display)
static int	jtag3_recv_frame (PROGRAMMER *pgm, unsigned char **msg)
int	jtag3_recv (PROGRAMMER *pgm, unsigned char **msg)
int	jtag3_command (PROGRAMMER *pgm, unsigned char *cmd, unsigned int cmdlen, unsigned char **resp, const char *descr)
int	jtag3_getsync (PROGRAMMER *pgm, int mode)
static int	jtag3_chip_erase_dw (PROGRAMMER *pgm, AVRPART *p)
static int	jtag3_program_enable_dummy (PROGRAMMER *pgm, AVRPART *p)
static int	jtag3_program_enable (PROGRAMMER *pgm)
static int	jtag3_program_disable (PROGRAMMER *pgm)
static int	jtag3_set_sck_xmega_pdi (PROGRAMMER *pgm, unsigned char *clk)
static int	jtag3_set_sck_xmega_jtag (PROGRAMMER *pgm, unsigned char *clk)
static int	jtag3_set_sck_mega_jtag (PROGRAMMER *pgm, unsigned char *clk)
static void	jtag3_disable (PROGRAMMER *pgm)
static void	jtag3_enable (PROGRAMMER *pgm)
static int	jtag3_parseextparms (PROGRAMMER *pgm, LISTID extparms)
int	jtag3_open_common (PROGRAMMER *pgm, char *port)
static int	jtag3_open_dw (PROGRAMMER *pgm, char *port)
static int	jtag3_open_pdi (PROGRAMMER *pgm, char *port)
void	jtag3_close (PROGRAMMER *pgm)
static int	jtag3_page_erase (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int addr)
static int	jtag3_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
int	jtag3_getparm (PROGRAMMER *pgm, unsigned char scope, unsigned char section, unsigned char parm, unsigned char *value, unsigned char length)
int	jtag3_setparm (PROGRAMMER *pgm, unsigned char scope, unsigned char section, unsigned char parm, unsigned char *value, unsigned char length)
static void	jtag3_display (PROGRAMMER *pgm, const char *p)
static void	jtag3_print_parms (PROGRAMMER *pgm)
void	jtag3_initpgm (PROGRAMMER *pgm)
void	jtag3_dw_initpgm (PROGRAMMER *pgm)
void	jtag3_pdi_initpgm (PROGRAMMER *pgm)

Variables
const char	jtag3_desc [] = "Atmel JTAGICE3"
const char	jtag3_dw_desc [] = "Atmel JTAGICE3 in debugWire mode"
const char	jtag3_pdi_desc [] = "Atmel JTAGICE3 in PDI mode"

Macro Definition Documentation

PDATA

#define PDATA

(

pgm

)

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

PGM_FL_IS_DW

#define PGM_FL_IS_DW   (0x0001)

PGM_FL_IS_EDBG

#define PGM_FL_IS_EDBG   (0x0008)

PGM_FL_IS_JTAG

#define PGM_FL_IS_JTAG   (0x0004)

PGM_FL_IS_PDI

#define PGM_FL_IS_PDI   (0x0002)

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 jtag3_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 jtag3_prevent().

Here is the caller graph for this function:

jtag3_chip_erase()

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

static

{
  unsigned char buf[8], *resp;
 
  buf[0] = SCOPE_AVR;
  buf[1] = CMD3_ERASE_MEMORY;
  buf[2] = 0;
  buf[3] = XMEGA_ERASE_CHIP;
  buf[4] = buf[5] = buf[6] = buf[7] = 0; /* page address */
 
  if (jtag3_command(pgm, buf, 8, &resp, "chip erase") < 0)
    return -1;
 
  free(resp);
  return 0;
}

References CMD3_ERASE_MEMORY, free(), jtag3_command(), pgm, SCOPE_AVR, and XMEGA_ERASE_CHIP.

Referenced by jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_chip_erase_dw()

static int jtag3_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 jtag3_dw_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_close()

void jtag3_close

(

PROGRAMMER *

pgm

)

{
  unsigned char buf[4], *resp;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_close()\n", progname);
 
  buf[0] = SCOPE_AVR;
  buf[1] = CMD3_SIGN_OFF;
  buf[2] = buf[3] = 0;
 
  if (jtag3_command(pgm, buf, 3, &resp, "AVR sign-off") >= 0)
    free(resp);
 
  buf[0] = SCOPE_GENERAL;
  buf[1] = CMD3_SIGN_OFF;
 
  if (jtag3_command(pgm, buf, 4, &resp, "sign-off") >= 0)
    free(resp);
 
  if (pgm->flag & PGM_FL_IS_EDBG)
    jtag3_edbg_signoff(pgm);
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

References avrdude_message(), CMD3_SIGN_OFF, programmer_t::fd, programmer_t::flag, free(), filedescriptor::ifd, jtag3_command(), jtag3_edbg_signoff(), MSG_NOTICE2, pgm, PGM_FL_IS_EDBG, progname, SCOPE_AVR, SCOPE_GENERAL, and serial_close.

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_command()

int jtag3_command	(	PROGRAMMER *	pgm,
		unsigned char *	cmd,
		unsigned int	cmdlen,
		unsigned char **	resp,
		const char *	descr
	)

{
  int status;
  unsigned char c;
 
  avrdude_message(MSG_NOTICE2, "%s: Sending %s command: ",
      progname, descr);
  jtag3_send(pgm, cmd, cmdlen);
 
  status = jtag3_recv(pgm, resp);
  if (status <= 0) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_NOTICE2, "%s: %s command: timeout/error communicating with programmer (status %d)\n",
                    progname, descr, status);
    return -1;
  } else if (verbose >= 3) {
    putc('\n', stderr);
    jtag3_prmsg(pgm, *resp, status);
  } else {
    avrdude_message(MSG_NOTICE2, "0x%02x (%d bytes msg)\n", (*resp)[1], status);
  }
 
  c = (*resp)[1];
  if ((c & RSP3_STATUS_MASK) != RSP3_OK) {
    avrdude_message(MSG_INFO, "%s: bad response to %s command: 0x%02x\n",
                    progname, descr, c);
    free(*resp);
    resp = 0;
    return -1;
  }
 
  return status;
}

References avrdude_message(), cmd, free(), jtag3_prmsg(), jtag3_recv(), jtag3_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RSP3_OK, RSP3_STATUS_MASK, and verbose.

Referenced by jtag3_chip_erase(), jtag3_close(), jtag3_display(), jtag3_getparm(), jtag3_getsync(), jtag3_initialize(), jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_program_disable(), jtag3_program_enable(), jtag3_read_byte(), jtag3_setparm(), and jtag3_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_disable()

static void jtag3_disable ( PROGRAMMER *  pgm )

static

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

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

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_display()

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

static

{
  unsigned char parms[5];
  unsigned char cmd[4], *resp, c;
  int status;
 
  /*
   * Ask for:
   *  PARM3_HW_VER (1 byte)
   *  PARM3_FW_MAJOR (1 byte)
   *  PARM3_FW_MINOR (1 byte)
   *  PARM3_FW_RELEASE (2 bytes)
   */
  if (jtag3_getparm(pgm, SCOPE_GENERAL, 0, PARM3_HW_VER, parms, 5) < 0)
    return;
 
  cmd[0] = SCOPE_INFO;
  cmd[1] = CMD3_GET_INFO;
  cmd[2] = 0;
  cmd[3] = CMD3_INFO_SERIAL;
 
  if ((status = jtag3_command(pgm, cmd, 4, &resp, "get info (serial number)")) < 0)
    return;
 
  c = resp[1];
  if (c != RSP3_INFO) {
    avrdude_message(MSG_INFO, "%s: jtag3_display(): response is not RSP3_INFO\n",
                    progname);
    free(resp);
    return;
  }
  memmove(resp, resp + 3, status - 3);
  resp[status - 3] = 0;
 
  avrdude_message(MSG_INFO, "%sICE hardware version: %d\n", p, parms[0]);
  avrdude_message(MSG_INFO, "%sICE firmware version: %d.%02d (rel. %d)\n", p,
    parms[1], parms[2],
    (parms[3] | (parms[4] << 8)));
  avrdude_message(MSG_INFO, "%sSerial number   : %s\n", p, resp);
  free(resp);
 
  jtag3_print_parms1(pgm, p);
}

References avrdude_message(), cmd, CMD3_GET_INFO, CMD3_INFO_SERIAL, free(), jtag3_command(), jtag3_getparm(), jtag3_print_parms1(), MSG_INFO, PARM3_HW_VER, pgm, progname, RSP3_INFO, SCOPE_GENERAL, and SCOPE_INFO.

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_drain()

static int jtag3_drain ( PROGRAMMER *  pgm, int  display  )

static

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by jtag3_open_common().

Here is the caller graph for this function:

jtag3_dw_initpgm()

void jtag3_dw_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAGICE3_DW");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtag3_initialize;
  pgm->display        = jtag3_display;
  pgm->enable         = jtag3_enable;
  pgm->disable        = jtag3_disable;
  pgm->program_enable = jtag3_program_enable_dummy;
  pgm->chip_erase     = jtag3_chip_erase_dw;
  pgm->open           = jtag3_open_dw;
  pgm->close          = jtag3_close;
  pgm->read_byte      = jtag3_read_byte;
  pgm->write_byte     = jtag3_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtag3_paged_write;
  pgm->paged_load     = jtag3_paged_load;
  pgm->print_parms    = jtag3_print_parms;
  pgm->setup          = jtag3_setup;
  pgm->teardown       = jtag3_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, jtag3_chip_erase_dw(), jtag3_close(), jtag3_disable(), jtag3_display(), jtag3_enable(), jtag3_initialize(), jtag3_open_dw(), jtag3_paged_load(), jtag3_paged_write(), jtag3_print_parms(), jtag3_program_enable_dummy(), jtag3_read_byte(), jtag3_setup(), jtag3_teardown(), jtag3_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:

jtag3_edbg_prepare()

static int jtag3_edbg_prepare ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[USBDEV_MAX_XFER_3];
  unsigned char status[USBDEV_MAX_XFER_3];
  int rv;
 
  avrdude_message(MSG_DEBUG, "\n%s: jtag3_edbg_prepare()\n",
      progname);
 
  if (verbose >= 4)
    memset(buf, 0, USBDEV_MAX_XFER_3);
 
  buf[0] = CMSISDAP_CMD_CONNECT;
  buf[1] = CMSISDAP_CONN_SWD;
  if (serial_send(&pgm->fd, buf, pgm->fd.usb.max_xfer) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
  rv = serial_recv(&pgm->fd, status, pgm->fd.usb.max_xfer);
  if (rv != pgm->fd.usb.max_xfer) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): failed to read from serial port (%d)\n",
                    progname, rv);
    return -1;
  }
  if (status[0] != CMSISDAP_CMD_CONNECT ||
      status[1] == 0)
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): unexpected response 0x%02x, 0x%02x\n",
                    progname, status[0], status[1]);
  avrdude_message(MSG_NOTICE2, "%s: jtag3_edbg_prepare(): connection status 0x%02x\n",
                    progname, status[1]);
 
  buf[0] = CMSISDAP_CMD_LED;
  buf[1] = CMSISDAP_LED_CONNECT;
  buf[2] = 1;
  if (serial_send(&pgm->fd, buf, pgm->fd.usb.max_xfer) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
  rv = serial_recv(&pgm->fd, status, pgm->fd.usb.max_xfer);
  if (rv != pgm->fd.usb.max_xfer) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): failed to read from serial port (%d)\n",
                    progname, rv);
    return -1;
  }
  if (status[0] != CMSISDAP_CMD_LED ||
      status[1] != 0)
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_prepare(): unexpected response 0x%02x, 0x%02x\n",
                    progname, status[0], status[1]);
 
  return 0;
}

References avrdude_message(), CMSISDAP_CMD_CONNECT, CMSISDAP_CMD_LED, CMSISDAP_CONN_SWD, CMSISDAP_LED_CONNECT, programmer_t::fd, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, pgm, progname, serial_recv, serial_send, filedescriptor::usb, USBDEV_MAX_XFER_3, and verbose.

Referenced by jtag3_getsync().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_edbg_recv_frame()

static int jtag3_edbg_recv_frame ( PROGRAMMER *  pgm, unsigned char **  msg  )

static

                                                                        {
  int rv, len = 0;
  unsigned char *buf = NULL;
  unsigned char *request;
 
  avrdude_message(MSG_TRACE, "%s: jtag3_edbg_recv():\n", progname);
 
  if ((buf = malloc(USBDEV_MAX_XFER_3)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): out of memory\n",
      progname);
    return -1;
  }
  if ((request = malloc(pgm->fd.usb.max_xfer)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): out of memory\n",
      progname);
    free(buf);
    return -1;
  }
 
  *msg = buf;
 
  int nfrags = 0;
  int thisfrag = 0;
 
  do {
    request[0] = EDBG_VENDOR_AVR_RSP;
 
    if (serial_send(&pgm->fd, request, pgm->fd.usb.max_xfer) != 0) {
      avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): error sending CMSIS-DAP vendor command\n",
                      progname);
      free(request);
      free(*msg);
      return -1;
    }
 
    rv = serial_recv(&pgm->fd, buf, pgm->fd.usb.max_xfer);
 
    if (rv < 0) {
      /* timeout in receive */
      avrdude_message(MSG_NOTICE2, "%s: jtag3_edbg_recv(): Timeout receiving packet\n",
                      progname);
      free(*msg);
      free(request);
      return -1;
    }
 
    if (buf[0] != EDBG_VENDOR_AVR_RSP) {
      avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): Unexpected response 0x%02x\n",
                      progname, buf[0]);
      free(*msg);
      free(request);
      return -1;
    }
 
    /* calculate fragment information */
    if (thisfrag == 0) {
      /* first fragment */
      nfrags = buf[1] & 0x0F;
      thisfrag = 1;
    } else {
      if (nfrags != (buf[1] & 0x0F)) {
        avrdude_message(MSG_INFO,
                        "%s: jtag3_edbg_recv(): "
                        "Inconsistent # of fragments; had %d, now %d\n",
                        progname, nfrags, (buf[1] & 0x0F));
        free(*msg);
        free(request);
        return -1;
      }
    }
    if (thisfrag != ((buf[1] >> 4) & 0x0F)) {
      avrdude_message(MSG_INFO,
                      "%s: jtag3_edbg_recv(): "
                      "Inconsistent fragment number; expect %d, got %d\n",
                      progname, thisfrag, ((buf[1] >> 4) & 0x0F));
      free(*msg);
      free(request);
      return -1;
    }
 
    int thislen = (buf[2] << 8) | buf[3];
    if (thislen > rv + 4) {
      avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): Unexpected length value (%d > %d)\n",
                      progname, thislen, rv + 4);
      thislen = rv + 4;
    }
    if (len + thislen > USBDEV_MAX_XFER_3) {
      avrdude_message(MSG_INFO, "%s: jtag3_edbg_recv(): Length exceeds max size (%d > %d)\n",
                      progname, len + thislen, USBDEV_MAX_XFER_3);
      thislen = USBDEV_MAX_XFER_3 - len;
    }
    memmove(buf, buf + 4, thislen);
    thisfrag++;
    len += thislen;
    buf += thislen;
  } while (thisfrag <= nfrags);
 
  free(request);
  return len;
}

References avrdude_message(), EDBG_VENDOR_AVR_RSP, programmer_t::fd, free(), malloc(), MSG_INFO, MSG_NOTICE2, MSG_TRACE, pgm, progname, serial_recv, serial_send, filedescriptor::usb, and USBDEV_MAX_XFER_3.

Referenced by jtag3_recv_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_edbg_send()

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

static

{
  unsigned char buf[USBDEV_MAX_XFER_3];
  unsigned char status[USBDEV_MAX_XFER_3];
  int rv;
 
  if (verbose >= 4)
    {
      memset(buf, 0, USBDEV_MAX_XFER_3);
      memset(status, 0, USBDEV_MAX_XFER_3);
    }
 
  avrdude_message(MSG_DEBUG, "\n%s: jtag3_edbg_send(): sending %lu bytes\n",
      progname, (unsigned long)len);
 
  /* 4 bytes overhead for CMD, fragment #, and length info */
  int max_xfer = pgm->fd.usb.max_xfer;
  int nfragments = (len + max_xfer - 1) / max_xfer;
  if (nfragments > 1)
    {
      avrdude_message(MSG_DEBUG, "%s: jtag3_edbg_send(): fragmenting into %d packets\n",
                      progname, nfragments);
    }
  int frag;
  for (frag = 0; frag < nfragments; frag++)
    {
      int this_len;
 
      /* All fragments have the (CMSIS-DAP layer) CMD, the fragment
       * identifier, and the length field. */
      buf[0] = EDBG_VENDOR_AVR_CMD;
      buf[1] = ((frag + 1) << 4) | nfragments;
 
      if (frag == 0)
        {
          /* Only first fragment has TOKEN and seq#, thus four bytes
           * less payload than subsequent fragments. */
          this_len = len < max_xfer - 8? len: max_xfer - 8;
          buf[2] = (this_len + 4) >> 8;
          buf[3] = (this_len + 4) & 0xff;
          buf[4] = TOKEN;
          buf[5] = 0;                   /* dummy */
          u16_to_b2(buf + 6, PDATA(pgm)->command_sequence);
          memcpy(buf + 8, data, this_len);
        }
      else
        {
          this_len = len < max_xfer - 4? len: max_xfer - 4;
          buf[2] = (this_len) >> 8;
          buf[3] = (this_len) & 0xff;
          memcpy(buf + 4, data, this_len);
        }
 
      if (serial_send(&pgm->fd, buf, max_xfer) != 0) {
        avrdude_message(MSG_INFO, "%s: jtag3_edbg_send(): failed to send command to serial port\n",
                        progname);
        return -1;
      }
      rv = serial_recv(&pgm->fd, status, max_xfer);
 
      if (rv < 0) {
        /* timeout in receive */
        avrdude_message(MSG_NOTICE2, "%s: jtag3_edbg_send(): Timeout receiving packet\n",
                        progname);
        return -1;
      }
      if (status[0] != EDBG_VENDOR_AVR_CMD ||
          (frag == nfragments - 1 && status[1] != 0x01))
        {
          /* what to do in this case? */
          avrdude_message(MSG_INFO, "%s: jtag3_edbg_send(): Unexpected response 0x%02x, 0x%02x\n",
                          progname, status[0], status[1]);
        }
      data += this_len;
      len -= this_len;
    }
 
  return 0;
}

References avrdude_message(), EDBG_VENDOR_AVR_CMD, programmer_t::fd, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, PDATA, pgm, progname, serial_recv, serial_send, TOKEN, u16_to_b2(), filedescriptor::usb, USBDEV_MAX_XFER_3, and verbose.

Referenced by jtag3_send().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_edbg_signoff()

static int jtag3_edbg_signoff ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[USBDEV_MAX_XFER_3];
  unsigned char status[USBDEV_MAX_XFER_3];
  int rv;
 
  avrdude_message(MSG_DEBUG, "\n%s: jtag3_edbg_signoff()\n",
      progname);
 
  if (verbose >= 4)
    memset(buf, 0, USBDEV_MAX_XFER_3);
 
  buf[0] = CMSISDAP_CMD_LED;
  buf[1] = CMSISDAP_LED_CONNECT;
  buf[2] = 0;
  if (serial_send(&pgm->fd, buf, pgm->fd.usb.max_xfer) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
  rv = serial_recv(&pgm->fd, status, pgm->fd.usb.max_xfer);
  if (rv != pgm->fd.usb.max_xfer) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): failed to read from serial port (%d)\n",
                    progname, rv);
    return -1;
  }
  if (status[0] != CMSISDAP_CMD_LED ||
      status[1] != 0)
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): unexpected response 0x%02x, 0x%02x\n",
                    progname, status[0], status[1]);
 
  buf[0] = CMSISDAP_CMD_DISCONNECT;
  if (serial_send(&pgm->fd, buf, pgm->fd.usb.max_xfer) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
  rv = serial_recv(&pgm->fd, status, pgm->fd.usb.max_xfer);
  if (rv != pgm->fd.usb.max_xfer) {
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): failed to read from serial port (%d)\n",
                    progname, rv);
    return -1;
  }
  if (status[0] != CMSISDAP_CMD_DISCONNECT ||
      status[1] != 0)
    avrdude_message(MSG_INFO, "%s: jtag3_edbg_signoff(): unexpected response 0x%02x, 0x%02x\n",
                    progname, status[0], status[1]);
 
  return 0;
}

References avrdude_message(), CMSISDAP_CMD_DISCONNECT, CMSISDAP_CMD_LED, CMSISDAP_LED_CONNECT, programmer_t::fd, MSG_DEBUG, MSG_INFO, pgm, progname, serial_recv, serial_send, filedescriptor::usb, USBDEV_MAX_XFER_3, and verbose.

Referenced by jtag3_close().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_enable()

static void jtag3_enable ( PROGRAMMER *  pgm )

static

{
  return;
}

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the caller graph for this function:

jtag3_getparm()

int jtag3_getparm	(	PROGRAMMER *	pgm,
		unsigned char	scope,
		unsigned char	section,
		unsigned char	parm,
		unsigned char *	value,
		unsigned char	length
	)

{
  int status;
  unsigned char buf[6], *resp, c;
  char descr[60];
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_getparm()\n", progname);
 
  buf[0] = scope;
  buf[1] = CMD3_GET_PARAMETER;
  buf[2] = 0;
  buf[3] = section;
  buf[4] = parm;
  buf[5] = length;
 
  sprintf(descr, "get parameter (scope 0x%02x, section %d, parm %d)",
    scope, section, parm);
 
  if ((status = jtag3_command(pgm, buf, 6, &resp, descr)) < 0)
    return -1;
 
  c = resp[1];
  if (c != RSP3_DATA || status < 3) {
    avrdude_message(MSG_INFO, "%s: jtag3_getparm(): "
                    "bad response to %s\n",
                    progname, descr);
    free(resp);
    return -1;
  }
 
  status -= 3;
  memcpy(value, resp + 3, (length < status? length: status));
  free(resp);
 
  return 0;
}

References avrdude_message(), CMD3_GET_PARAMETER, free(), jtag3_command(), MSG_INFO, MSG_NOTICE2, pgm, progname, and RSP3_DATA.

Referenced by jtag3_display(), jtag3_initialize(), and jtag3_print_parms1().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_getsync()

int jtag3_getsync	(	PROGRAMMER *	pgm,
		int	mode
	)

                                              {
 
  unsigned char buf[3], *resp;
 
  avrdude_message(MSG_DEBUG, "%s: jtag3_getsync()\n", progname);
 
  if (pgm->flag & PGM_FL_IS_EDBG) {
    if (jtag3_edbg_prepare(pgm) < 0)
      return -1;
  }
 
  /* Get the sign-on information. */
  buf[0] = SCOPE_GENERAL;
  buf[1] = CMD3_SIGN_ON;
  buf[2] = 0;
 
  if (jtag3_command(pgm, buf, 3, &resp, "sign-on") < 0)
    return -1;
 
  free(resp);
 
  return 0;
}

References avrdude_message(), CMD3_SIGN_ON, programmer_t::flag, free(), jtag3_command(), jtag3_edbg_prepare(), MSG_DEBUG, pgm, PGM_FL_IS_EDBG, progname, and SCOPE_GENERAL.

Referenced by jtag3_open(), jtag3_open_dw(), and jtag3_open_pdi().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_initialize()

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

static

{
  unsigned char conn = 0, parm[4];
  const char *ifname;
  unsigned char cmd[4], *resp;
  int status;
 
  /*
   * At least, as of firmware 2.12, the JTAGICE3 doesn't handle
   * splitting packets correctly.  On a large transfer, the first
   * split packets are correct, but remaining packets contain just
   * garbage.
   *
   * We move the check here so in case future firmware versions fix
   * this, the check below can be made dependended on the actual
   * firmware level.  Retrieving the firmware version can always be
   * accomplished with USB 1.1 (64 byte max) packets.
   *
   * Allow to override the check by -F (so users could try on newer
   * firmware), but warn loudly.
   */
  if (jtag3_getparm(pgm, SCOPE_GENERAL, 0, PARM3_FW_MAJOR, parm, 2) < 0)
    return -1;
  if (pgm->fd.usb.max_xfer < USBDEV_MAX_XFER_3 && (pgm->flag & PGM_FL_IS_EDBG) == 0) {
    avrdude_message(MSG_INFO, "%s: the JTAGICE3's firmware %d.%d is broken on USB 1.1 connections, sorry\n",
                    progname, parm[0], parm[1]);
    if (ovsigck) {
      avrdude_message(MSG_INFO, "%s: forced to continue by option -F; THIS PUTS THE DEVICE'S DATA INTEGRITY AT RISK!\n",
                      progname);
    } else {
      return -1;
    }
  }
 
  if (pgm->flag & PGM_FL_IS_DW) {
    ifname = "debugWire";
    if (p->flags & AVRPART_HAS_DW)
      conn = PARM3_CONN_DW;
  } else if (pgm->flag & PGM_FL_IS_PDI) {
    ifname = "PDI";
    if (p->flags & AVRPART_HAS_PDI)
      conn = PARM3_CONN_PDI;
  } else {
    ifname = "JTAG";
    if (p->flags & AVRPART_HAS_JTAG)
      conn = PARM3_CONN_JTAG;
  }
 
  if (conn == 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_initialize(): part %s has no %s interface\n",
      progname, p->desc, ifname);
    return -1;
  }
 
  if (p->flags & AVRPART_HAS_PDI)
    parm[0] = PARM3_ARCH_XMEGA;
  else if (p->flags & AVRPART_HAS_DW)
    parm[0] = PARM3_ARCH_TINY;
  else
    parm[0] = PARM3_ARCH_MEGA;
  if (jtag3_setparm(pgm, SCOPE_AVR, 0, PARM3_ARCH, parm, 1) < 0)
    return -1;
 
  parm[0] = PARM3_SESS_PROGRAMMING;
  if (jtag3_setparm(pgm, SCOPE_AVR, 0, PARM3_SESS_PURPOSE, parm, 1) < 0)
    return -1;
 
  parm[0] = conn;
  if (jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CONNECTION, parm, 1) < 0)
    return -1;
 
  if (conn == PARM3_CONN_PDI)
    PDATA(pgm)->set_sck = jtag3_set_sck_xmega_pdi;
  else if (conn == PARM3_CONN_JTAG) {
    if (p->flags & AVRPART_HAS_PDI)
      PDATA(pgm)->set_sck = jtag3_set_sck_xmega_jtag;
    else
      PDATA(pgm)->set_sck = jtag3_set_sck_mega_jtag;
  }
  if (pgm->bitclock != 0.0 && PDATA(pgm)->set_sck != NULL)
  {
    unsigned int clock = 1E-3 / pgm->bitclock; /* kHz */
    avrdude_message(MSG_NOTICE2, "%s: jtag3_initialize(): "
        "trying to set JTAG clock to %u kHz\n",
        progname, clock);
    parm[0] = clock & 0xff;
    parm[1] = (clock >> 8) & 0xff;
    if (PDATA(pgm)->set_sck(pgm, parm) < 0)
      return -1;
  }
 
  if (conn == PARM3_CONN_JTAG)
  {
    avrdude_message(MSG_NOTICE2, "%s: jtag3_initialize(): "
        "trying to set JTAG daisy-chain info to %d,%d,%d,%d\n",
        progname,
        PDATA(pgm)->jtagchain[0], PDATA(pgm)->jtagchain[1],
        PDATA(pgm)->jtagchain[2], PDATA(pgm)->jtagchain[3]);
    if (jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_JTAGCHAIN, PDATA(pgm)->jtagchain, 4) < 0)
      return -1;
  }
 
  /* set device descriptor data */
  if ((p->flags & AVRPART_HAS_PDI))
  {
    struct xmega_device_desc xd;
    LNODEID ln;
    AVRMEM * m;
 
    u16_to_b2(xd.nvm_base_addr, p->nvm_base);
    u16_to_b2(xd.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->readsize != 0 && m->readsize < m->page_size)
    PDATA(pgm)->flash_pagesize = m->readsize;
  else
    PDATA(pgm)->flash_pagesize = m->page_size;
  u16_to_b2(xd.flash_page_size, m->page_size);
      } else if (strcmp(m->desc, "eeprom") == 0) {
  PDATA(pgm)->eeprom_pagesize = m->page_size;
  xd.eeprom_page_size = m->page_size;
  u16_to_b2(xd.eeprom_size, m->size);
  u32_to_b4(xd.nvm_eeprom_offset, m->offset);
      } else if (strcmp(m->desc, "application") == 0) {
  u32_to_b4(xd.app_size, m->size);
  u32_to_b4(xd.nvm_app_offset, m->offset);
      } else if (strcmp(m->desc, "boot") == 0) {
  u16_to_b2(xd.boot_size, m->size);
  u32_to_b4(xd.nvm_boot_offset, m->offset);
      } else if (strcmp(m->desc, "fuse1") == 0) {
  u32_to_b4(xd.nvm_fuse_offset, m->offset & ~7);
      } else if (strncmp(m->desc, "lock", 4) == 0) {
  u32_to_b4(xd.nvm_lock_offset, m->offset);
      } else if (strcmp(m->desc, "usersig") == 0) {
  u32_to_b4(xd.nvm_user_sig_offset, m->offset);
      } else if (strcmp(m->desc, "prodsig") == 0) {
  u32_to_b4(xd.nvm_prod_sig_offset, m->offset);
      } else if (strcmp(m->desc, "data") == 0) {
  u32_to_b4(xd.nvm_data_offset, m->offset);
      }
    }
 
    if (jtag3_setparm(pgm, SCOPE_AVR, 2, PARM3_DEVICEDESC, (unsigned char *)&xd, sizeof xd) < 0)
      return -1;
  }
  else
  {
    struct mega_device_desc md;
    LNODEID ln;
    AVRMEM * m;
    unsigned int flashsize = 0;
 
    memset(&md, 0, sizeof md);
 
    for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
      m = ldata(ln);
      if (strcmp(m->desc, "flash") == 0) {
  if (m->readsize != 0 && m->readsize < m->page_size)
    PDATA(pgm)->flash_pagesize = m->readsize;
  else
    PDATA(pgm)->flash_pagesize = m->page_size;
  u16_to_b2(md.flash_page_size, m->page_size);
  u32_to_b4(md.flash_size, (flashsize = m->size));
  // do we need it?  just a wild guess
  u32_to_b4(md.boot_address, (m->size - m->page_size * 4) / 2);
      } else if (strcmp(m->desc, "eeprom") == 0) {
  PDATA(pgm)->eeprom_pagesize = m->page_size;
  md.eeprom_page_size = m->page_size;
  u16_to_b2(md.eeprom_size, m->size);
      }
    }
 
    //md.sram_offset[2] = p->sram;  // do we need it?
    if (p->ocdrev == -1) {
      int ocdrev;
 
      /* lacking a proper definition, guess the OCD revision */
      if (p->flags & AVRPART_HAS_DW)
  ocdrev = 1;   /* exception: ATtiny13, 2313, 4313 */
      else if (flashsize > 128 * 1024)
  ocdrev = 4;
      else
  ocdrev = 3;   /* many exceptions from that, actually */
      avrdude_message(MSG_INFO, "%s: part definition for %s lacks \"ocdrev\"; guessing %d\n",
                      progname, p->desc, ocdrev);
      md.ocd_revision = ocdrev;
    } else {
      md.ocd_revision = p->ocdrev;
    }
    md.always_one = 1;
    md.allow_full_page_bitstream = (p->flags & AVRPART_ALLOWFULLPAGEBITSTREAM) != 0;
    md.idr_address = p->idr;
 
    if (p->eecr == 0)
      p->eecr = 0x3f;   /* matches most "modern" mega/tiny AVRs */
    md.eearh_address = p->eecr - 0x20 + 3;
    md.eearl_address = p->eecr - 0x20 + 2;
    md.eecr_address = p->eecr - 0x20;
    md.eedr_address = p->eecr - 0x20 + 1;
    md.spmcr_address = p->spmcr;
    //md.osccal_address = p->osccal;  // do we need it at all?
 
    if (jtag3_setparm(pgm, SCOPE_AVR, 2, PARM3_DEVICEDESC, (unsigned char *)&md, sizeof md) < 0)
      return -1;
  }
 
  int use_ext_reset;
 
  for (use_ext_reset = 0; use_ext_reset <= 1; use_ext_reset++) {
    cmd[0] = SCOPE_AVR;
    cmd[1] = CMD3_SIGN_ON;
    cmd[2] = 0;
    cmd[3] = use_ext_reset;     /* external reset */
 
    if ((status = jtag3_command(pgm, cmd, 4, &resp, "AVR sign-on")) >= 0)
      break;
 
    avrdude_message(MSG_INFO, "%s: retrying with external reset applied\n",
        progname);
  }
 
  if (use_ext_reset > 1) {
    avrdude_message(MSG_INFO, "%s: JTAGEN fuse disabled?\n", progname);
    return -1;
  }
 
  /*
   * Depending on the target connection, there are two different
   * possible replies of the ICE.  For a JTAG connection, the reply
   * format is RSP3_DATA, followed by 4 bytes of the JTAG ID read from
   * the device (followed by a trailing 0).  For all other connections
   * (except ISP which is handled completely differently, but that
   * doesn't apply here anyway), the response is just RSP_OK.
   */
  if (resp[1] == RSP3_DATA && status >= 7)
    /* JTAG ID has been returned */
    avrdude_message(MSG_NOTICE, "%s: JTAG ID returned: 0x%02x 0x%02x 0x%02x 0x%02x\n",
      progname, resp[3], resp[4], resp[5], resp[6]);
 
  free(resp);
 
  PDATA(pgm)->boot_start = ULONG_MAX;
  if ((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: jtagmk3_initialize(): Cannot locate \"flash\" and \"boot\" memories in description\n",
                      progname);
    } else {
      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: jtag3_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtag3_initialize(): Out of memory\n",
      progname);
    free(PDATA(pgm)->flash_pagecache);
    return -1;
  }
  PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
 
  return 0;
}

References mega_device_desc::allow_full_page_bitstream, mega_device_desc::always_one, xmega_device_desc::app_size, avr_locate_mem(), avrdude_message(), AVRPART_ALLOWFULLPAGEBITSTREAM, AVRPART_HAS_DW, AVRPART_HAS_JTAG, AVRPART_HAS_PDI, programmer_t::bitclock, mega_device_desc::boot_address, xmega_device_desc::boot_size, cmd, CMD3_SIGN_ON, avrpart::desc, avrmem::desc, mega_device_desc::eearh_address, mega_device_desc::eearl_address, avrpart::eecr, mega_device_desc::eecr_address, mega_device_desc::eedr_address, mega_device_desc::eeprom_page_size, xmega_device_desc::eeprom_page_size, mega_device_desc::eeprom_size, xmega_device_desc::eeprom_size, programmer_t::fd, programmer_t::flag, avrpart::flags, mega_device_desc::flash_page_size, xmega_device_desc::flash_page_size, mega_device_desc::flash_size, free(), avrpart::idr, mega_device_desc::idr_address, jtag3_command(), jtag3_getparm(), jtag3_set_sck_mega_jtag(), jtag3_set_sck_xmega_jtag(), jtag3_set_sck_xmega_pdi(), jtag3_setparm(), ldata(), lfirst(), lnext(), long, malloc(), avrpart::mcu_base, xmega_device_desc::mcu_base_addr, avrpart::mem, MSG_INFO, MSG_NOTICE, MSG_NOTICE2, xmega_device_desc::nvm_app_offset, avrpart::nvm_base, xmega_device_desc::nvm_base_addr, xmega_device_desc::nvm_boot_offset, xmega_device_desc::nvm_data_offset, xmega_device_desc::nvm_eeprom_offset, xmega_device_desc::nvm_fuse_offset, xmega_device_desc::nvm_lock_offset, xmega_device_desc::nvm_prod_sig_offset, xmega_device_desc::nvm_user_sig_offset, mega_device_desc::ocd_revision, avrpart::ocdrev, avrmem::offset, ovsigck, avrmem::page_size, PARM3_ARCH, PARM3_ARCH_MEGA, PARM3_ARCH_TINY, PARM3_ARCH_XMEGA, PARM3_CONN_DW, PARM3_CONN_JTAG, PARM3_CONN_PDI, PARM3_CONNECTION, PARM3_DEVICEDESC, PARM3_FW_MAJOR, PARM3_JTAGCHAIN, PARM3_SESS_PROGRAMMING, PARM3_SESS_PURPOSE, PDATA, pgm, PGM_FL_IS_DW, PGM_FL_IS_EDBG, PGM_FL_IS_PDI, progname, avrmem::readsize, RSP3_DATA, SCOPE_AVR, SCOPE_GENERAL, avrmem::size, avrpart::spmcr, mega_device_desc::spmcr_address, u16_to_b2(), u32_to_b4(), filedescriptor::usb, and USBDEV_MAX_XFER_3.

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_initpgm()

void jtag3_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAGICE3");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtag3_initialize;
  pgm->display        = jtag3_display;
  pgm->enable         = jtag3_enable;
  pgm->disable        = jtag3_disable;
  pgm->program_enable = jtag3_program_enable_dummy;
  pgm->chip_erase     = jtag3_chip_erase;
  pgm->open           = jtag3_open;
  pgm->close          = jtag3_close;
  pgm->read_byte      = jtag3_read_byte;
  pgm->write_byte     = jtag3_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtag3_paged_write;
  pgm->paged_load     = jtag3_paged_load;
  pgm->page_erase     = jtag3_page_erase;
  pgm->print_parms    = jtag3_print_parms;
  pgm->set_sck_period = jtag3_set_sck_period;
  pgm->parseextparams = jtag3_parseextparms;
  pgm->setup          = jtag3_setup;
  pgm->teardown       = jtag3_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, jtag3_chip_erase(), jtag3_close(), jtag3_disable(), jtag3_display(), jtag3_enable(), jtag3_initialize(), jtag3_open(), jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_parseextparms(), jtag3_print_parms(), jtag3_program_enable_dummy(), jtag3_read_byte(), jtag3_set_sck_period(), jtag3_setup(), jtag3_teardown(), jtag3_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:

jtag3_memaddr()

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

static

{
  if ((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;
  }
  /*
   * Non-Xmega device.
   */
  return addr;
}

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

Referenced by jtag3_paged_load(), and jtag3_paged_write().

Here is the caller graph for this function:

jtag3_memtype()

static unsigned char jtag3_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 jtag3_page_erase(), jtag3_paged_load(), and jtag3_paged_write().

Here is the caller graph for this function:

jtag3_open()

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

static

{
  avrdude_message(MSG_NOTICE2, "%s: jtag3_open()\n", progname);
 
  if (jtag3_open_common(pgm, port) < 0)
    return -1;
 
  if (jtag3_getsync(pgm, PARM3_CONN_JTAG) < 0)
    return -1;
 
  return 0;
}

References avrdude_message(), jtag3_getsync(), jtag3_open_common(), MSG_NOTICE2, PARM3_CONN_JTAG, pgm, and progname.

Referenced by jtag3_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_open_common()

int jtag3_open_common	(	PROGRAMMER *	pgm,
		char *	port
	)

{
  union pinfo pinfo;
  LNODEID usbpid;
  int rv = -1;
 
#if !defined(HAVE_LIBUSB) && !defined(HAVE_LIBHIDAPI)
  avrdude_message(MSG_INFO, "avrdude was compiled without USB or HIDAPI support.\n");
  return -1;
#endif
 
  if (strncmp(port, "usb", 3) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_open_common(): JTAGICE3/EDBG port names must start with \"usb\"\n",
                    progname);
    return -1;
  }
 
  if (pgm->usbvid)
    pinfo.usbinfo.vid = pgm->usbvid;
  else
    pinfo.usbinfo.vid = USB_VENDOR_ATMEL;
 
  /* If the config entry did not specify a USB PID, insert the default one. */
  if (lfirst(pgm->usbpid) == NULL)
    ladd(pgm->usbpid, (void *)USB_DEVICE_JTAGICE3);
 
#if defined(HAVE_LIBHIDAPI)
  /*
   * Try HIDAPI first.  LibUSB is more generic, but might then cause
   * troubles for HID-class devices in some OSes (like Windows).
   */
  serdev = &usbhid_serdev;
  for (usbpid = lfirst(pgm->usbpid); rv < 0 && usbpid != NULL; usbpid = lnext(usbpid)) {
    pinfo.usbinfo.flags = PINFO_FL_SILENT;
    pinfo.usbinfo.pid = *(int *)(ldata(usbpid));
    pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_3;
    pgm->fd.usb.rep = USBDEV_BULK_EP_READ_3;
    pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_3;
    pgm->fd.usb.eep = 0;
 
    strcpy(pgm->port, port);
    rv = serial_open(port, pinfo, &pgm->fd);
  }
  if (rv < 0) {
#endif  /* HAVE_LIBHIDAPI */
#if defined(HAVE_LIBUSB)
    serdev = &usb_serdev_frame;
    for (usbpid = lfirst(pgm->usbpid); rv < 0 && usbpid != NULL; usbpid = lnext(usbpid)) {
      pinfo.usbinfo.flags = PINFO_FL_SILENT;
      pinfo.usbinfo.pid = *(int *)(ldata(usbpid));
      pgm->fd.usb.max_xfer = USBDEV_MAX_XFER_3;
      pgm->fd.usb.rep = USBDEV_BULK_EP_READ_3;
      pgm->fd.usb.wep = USBDEV_BULK_EP_WRITE_3;
      pgm->fd.usb.eep = USBDEV_EVT_EP_READ_3;
 
      strcpy(pgm->port, port);
      rv = serial_open(port, pinfo, &pgm->fd);
    }
#endif  /* HAVE_LIBUSB */
#if defined(HAVE_LIBHIDAPI)
  }
#endif
  if (rv < 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_open_common(): Did not find any device matching VID 0x%04x and PID list: ",
                    progname, (unsigned)pinfo.usbinfo.vid);
    int notfirst = 0;
    for (usbpid = lfirst(pgm->usbpid); usbpid != NULL; usbpid = lnext(usbpid)) {
      if (notfirst)
        avrdude_message(MSG_INFO, ", ");
      avrdude_message(MSG_INFO, "0x%04x", (unsigned int)(*(int *)(ldata(usbpid))));
      notfirst = 1;
    }
    fputc('\n', stderr);
 
    return -1;
  }
 
  if (pgm->fd.usb.eep == 0)
  {
    /* The event EP has been deleted by usb_open(), so we are
       running on a CMSIS-DAP device, using EDBG protocol */
    pgm->flag |= PGM_FL_IS_EDBG;
    avrdude_message(MSG_NOTICE, "%s: Found CMSIS-DAP compliant device, using EDBG protocol\n",
                      progname);
  }
 
  /*
   * drain any extraneous input
   */
  jtag3_drain(pgm, 0);
 
  return 0;
}

References avrdude_message(), programmer_t::fd, programmer_t::flag, jtag3_drain(), ladd(), ldata(), lfirst(), lnext(), MSG_INFO, MSG_NOTICE, pgm, PGM_FL_IS_EDBG, PINFO_FL_SILENT, programmer_t::port, progname, serdev, serial_open, filedescriptor::usb, USB_DEVICE_JTAGICE3, usb_serdev_frame, USB_VENDOR_ATMEL, USBDEV_BULK_EP_READ_3, USBDEV_BULK_EP_WRITE_3, USBDEV_EVT_EP_READ_3, USBDEV_MAX_XFER_3, usbhid_serdev, pinfo::usbinfo, programmer_t::usbpid, and programmer_t::usbvid.

Referenced by jtag3_open(), jtag3_open_dw(), and jtag3_open_pdi().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_open_dw()

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

static

{
  avrdude_message(MSG_NOTICE2, "%s: jtag3_open_dw()\n", progname);
 
  if (jtag3_open_common(pgm, port) < 0)
    return -1;
 
  if (jtag3_getsync(pgm, PARM3_CONN_DW) < 0)
    return -1;
 
  return 0;
}

References avrdude_message(), jtag3_getsync(), jtag3_open_common(), MSG_NOTICE2, PARM3_CONN_DW, pgm, and progname.

Referenced by jtag3_dw_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_open_pdi()

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

static

{
  avrdude_message(MSG_NOTICE2, "%s: jtag3_open_pdi()\n", progname);
 
  if (jtag3_open_common(pgm, port) < 0)
    return -1;
 
  if (jtag3_getsync(pgm, PARM3_CONN_PDI) < 0)
    return -1;
 
  return 0;
}

References avrdude_message(), jtag3_getsync(), jtag3_open_common(), MSG_NOTICE2, PARM3_CONN_PDI, pgm, and progname.

Referenced by jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_page_erase()

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

static

{
  unsigned char cmd[8], *resp;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_page_erase(.., %s, 0x%x)\n",
      progname, m->desc, addr);
 
  if (!(p->flags & AVRPART_HAS_PDI)) {
    avrdude_message(MSG_INFO, "%s: jtag3_page_erase: not an Xmega device\n",
      progname);
    return -1;
  }
 
  if (jtag3_program_enable(pgm) < 0)
    return -1;
 
  cmd[0] = SCOPE_AVR;
  cmd[1] = CMD3_ERASE_MEMORY;
  cmd[2] = 0;
 
  if (strcmp(m->desc, "flash") == 0) {
    if (jtag3_memtype(pgm, p, addr) == MTYPE_FLASH)
      cmd[3] = XMEGA_ERASE_APP_PAGE;
    else
      cmd[3] = XMEGA_ERASE_BOOT_PAGE;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[3] = XMEGA_ERASE_EEPROM_PAGE;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[3] = XMEGA_ERASE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[3] = XMEGA_ERASE_BOOT_PAGE;
  } else {
    cmd[3] = XMEGA_ERASE_APP_PAGE;
  }
 
  u32_to_b4(cmd + 4, addr + m->offset);
 
  if (jtag3_command(pgm, cmd, 8, &resp, "page erase") < 0)
    return -1;
 
  free(resp);
  return 0;
}

References avrdude_message(), AVRPART_HAS_PDI, cmd, CMD3_ERASE_MEMORY, avrmem::desc, avrpart::flags, free(), jtag3_command(), jtag3_memtype(), jtag3_program_enable(), MSG_INFO, MSG_NOTICE2, MTYPE_FLASH, avrmem::offset, pgm, progname, SCOPE_AVR, u32_to_b4(), XMEGA_ERASE_APP_PAGE, XMEGA_ERASE_BOOT_PAGE, XMEGA_ERASE_EEPROM_PAGE, and XMEGA_ERASE_USERSIG.

Referenced by jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_paged_load()

static int jtag3_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[12];
  unsigned char *resp;
  int status, dynamic_memtype = 0;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_paged_load(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtag3_program_enable(pgm) < 0)
    return -1;
 
  page_size = m->readsize;
 
  cmd[0] = SCOPE_AVR;
  cmd[1] = CMD3_READ_MEMORY;
  cmd[2] = 0;
 
  if (strcmp(m->desc, "flash") == 0) {
    cmd[3] = jtag3_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[3] = ( 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[3] = MTYPE_PRODSIG;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[3] = MTYPE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[3] = MTYPE_BOOT_FLASH;
  } else if ( p->flags & AVRPART_HAS_PDI ) {
    cmd[3] = MTYPE_FLASH;
  } else {
    cmd[3] = 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: jtag3_paged_load(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    if (dynamic_memtype)
      cmd[3] = jtag3_memtype(pgm, p, addr);
 
    u32_to_b4(cmd + 8, block_size);
    u32_to_b4(cmd + 4, jtag3_memaddr(pgm, p, m, addr));
 
    if ((status = jtag3_command(pgm, cmd, 12, &resp, "read memory")) < 0)
      return -1;
 
    if (resp[1] != RSP3_DATA ||
  status < block_size + 4) {
      avrdude_message(MSG_INFO, "%s: wrong/short reply to read memory command\n",
        progname);
      serial_recv_timeout = otimeout;
      free(resp);
      return -1;
    }
    memcpy(m->buf + addr, resp + 3, status - 4);
    free(resp);
  }
  serial_recv_timeout = otimeout;
 
  return n_bytes;
}

References avrdude_message(), AVRPART_HAS_PDI, avrmem::buf, cmd, CMD3_READ_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtag3_command(), jtag3_memaddr(), jtag3_memtype(), jtag3_program_enable(), 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, RSP3_DATA, SCOPE_AVR, serial_recv_timeout, and u32_to_b4().

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_paged_write()

static int jtag3_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, dynamic_memtype = 0;
  long otimeout = serial_recv_timeout;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_paged_write(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtag3_program_enable(pgm) < 0)
    return -1;
 
  if (page_size == 0) page_size = 256;
 
  if ((cmd = malloc(page_size + 13)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtag3_paged_write(): Out of memory\n",
      progname);
    return -1;
  }
 
  cmd[0] = SCOPE_AVR;
  cmd[1] = CMD3_WRITE_MEMORY;
  cmd[2] = 0;
  if (strcmp(m->desc, "flash") == 0) {
    PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
    cmd[3] = jtag3_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) {
      /*
       * jtag3_paged_write() to EEPROM attempted while in
       * DW mode.  Use jtag3_write_byte() instead.
       */
      for (; addr < maxaddr; addr++) {
  status = jtag3_write_byte(pgm, p, m, addr, m->buf[addr]);
  if (status < 0) {
    free(cmd);
    return -1;
  }
      }
      free(cmd);
      return n_bytes;
    }
    cmd[3] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_EEPROM_XMEGA : MTYPE_EEPROM_PAGE;
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
  } else if ( ( strcmp(m->desc, "usersig") == 0 ) ) {
    cmd[3] = MTYPE_USERSIG;
  } else if ( ( strcmp(m->desc, "boot") == 0 ) ) {
    cmd[3] = MTYPE_BOOT_FLASH;
  } else if ( p->flags & AVRPART_HAS_PDI ) {
    cmd[3] = MTYPE_FLASH;
  } else {
    cmd[3] = 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: jtag3_paged_write(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    if (dynamic_memtype)
      cmd[3] = jtag3_memtype(pgm, p, addr);
 
    u32_to_b4(cmd + 8, page_size);
    u32_to_b4(cmd + 4, jtag3_memaddr(pgm, p, m, addr));
    cmd[12] = 0;
 
    /*
     * 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 + 13, 0xff, page_size);
    memcpy(cmd + 13, m->buf + addr, block_size);
 
    if ((status = jtag3_command(pgm, cmd, page_size + 13,
        &resp, "write memory")) < 0) {
      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, CMD3_WRITE_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtag3_command(), jtag3_memaddr(), jtag3_memtype(), jtag3_program_enable(), jtag3_write_byte(), long, malloc(), MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MTYPE_BOOT_FLASH, MTYPE_EEPROM_PAGE, MTYPE_EEPROM_XMEGA, MTYPE_FLASH, MTYPE_SPM, MTYPE_USERSIG, PDATA, pgm, PGM_FL_IS_DW, progname, SCOPE_AVR, serial_recv_timeout, and u32_to_b4().

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), jtag3_pdi_initpgm(), and jtag3_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_parseextparms()

static int jtag3_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: jtag3_parseextparms(): invalid JTAG chain '%s'\n",
                        progname, extended_param);
        rv = -1;
        continue;
      }
      avrdude_message(MSG_NOTICE2, "%s: jtag3_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: jtag3_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 jtag3_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_pdi_initpgm()

void jtag3_pdi_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAGICE3_PDI");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtag3_initialize;
  pgm->display        = jtag3_display;
  pgm->enable         = jtag3_enable;
  pgm->disable        = jtag3_disable;
  pgm->program_enable = jtag3_program_enable_dummy;
  pgm->chip_erase     = jtag3_chip_erase;
  pgm->open           = jtag3_open_pdi;
  pgm->close          = jtag3_close;
  pgm->read_byte      = jtag3_read_byte;
  pgm->write_byte     = jtag3_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtag3_paged_write;
  pgm->paged_load     = jtag3_paged_load;
  pgm->page_erase     = jtag3_page_erase;
  pgm->print_parms    = jtag3_print_parms;
  pgm->set_sck_period = jtag3_set_sck_period;
  pgm->setup          = jtag3_setup;
  pgm->teardown       = jtag3_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, jtag3_chip_erase(), jtag3_close(), jtag3_disable(), jtag3_display(), jtag3_enable(), jtag3_initialize(), jtag3_open_pdi(), jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_print_parms(), jtag3_program_enable_dummy(), jtag3_read_byte(), jtag3_set_sck_period(), jtag3_setup(), jtag3_teardown(), jtag3_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::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:

jtag3_prevent()

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

static

{
  int i;
 
  if (verbose >= 4) {
    avrdude_message(MSG_TRACE, "Raw event:\n");
 
    for (i = 0; i < len; i++) {
      avrdude_message(MSG_TRACE, "%02x ", data[i]);
      if (i % 16 == 15)
  putc('\n', stderr);
      else
  putc(' ', stderr);
    }
    if (i % 16 != 0)
      putc('\n', stderr);
  }
 
  avrdude_message(MSG_INFO, "Event serial 0x%04x, ",
    (data[3] << 8) | data[2]);
 
  switch (data[4]) {
    case SCOPE_INFO:
      avrdude_message(MSG_INFO, "[info] ");
      break;
 
    case SCOPE_GENERAL:
      avrdude_message(MSG_INFO, "[general] ");
      break;
 
    case SCOPE_AVR:
      avrdude_message(MSG_INFO, "[AVR] ");
      break;
 
    default:
      avrdude_message(MSG_INFO, "[scope 0x%02x] ", data[0]);
      break;
  }
 
  switch (data[5]) {
  case EVT3_BREAK:
    avrdude_message(MSG_INFO, "BREAK");
    if (len >= 11) {
      avrdude_message(MSG_INFO, ", PC = 0x%lx, reason ", b4_to_u32(data + 6));
      switch (data[10]) {
      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[10]);
      }
      /* There are two more bytes of data which always appear to be
       * 0x01, 0x00.  Purpose unknown. */
    }
    break;
 
  case EVT3_SLEEP:
    if (len >= 8 && data[7] == 0)
      avrdude_message(MSG_INFO, "sleeping");
    else if (len >= 8 && data[7] == 1)
      avrdude_message(MSG_INFO, "wakeup");
    else
      avrdude_message(MSG_INFO, "unknown SLEEP event");
    break;
 
  case EVT3_POWER:
    if (len >= 8 && data[7] == 0)
      avrdude_message(MSG_INFO, "power-down");
    else if (len >= 8 && data[7] == 1)
      avrdude_message(MSG_INFO, "power-up");
    else
      avrdude_message(MSG_INFO, "unknown POWER event");
    break;
 
  default:
    avrdude_message(MSG_INFO, "UNKNOWN 0x%02x", data[5]);
    break;
  }
  putc('\n', stderr);
}

References avrdude_message(), b4_to_u32(), EVT3_BREAK, EVT3_POWER, EVT3_SLEEP, MSG_INFO, MSG_TRACE, SCOPE_AVR, SCOPE_GENERAL, SCOPE_INFO, and verbose.

Referenced by jtag3_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_print_data()

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

static

{
  int i;
 
  if (s < 2)
    return;
 
  for (i = 0; i < s; i++) {
    avrdude_message(MSG_INFO, "0x%02x", b[i]);
    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 jtag3_prmsg().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_print_parms()

static void jtag3_print_parms ( PROGRAMMER *  pgm )

static

{
  jtag3_print_parms1(pgm, "");
}

References jtag3_print_parms1(), and pgm.

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_print_parms1()

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

static

{
  unsigned char buf[2];
 
  if (jtag3_getparm(pgm, SCOPE_GENERAL, 1, PARM3_VTARGET, buf, 2) < 0)
    return;
 
  avrdude_message(MSG_INFO, "%sVtarget         : %.2f V\n", p,
    b2_to_u16(buf) / 1000.0);
 
  if (jtag3_getparm(pgm, SCOPE_AVR, 1, PARM3_CLK_MEGA_PROG, buf, 2) < 0)
    return;
  avrdude_message(MSG_INFO, "%sJTAG clock megaAVR/program: %u kHz\n", p,
    b2_to_u16(buf));
 
  if (jtag3_getparm(pgm, SCOPE_AVR, 1, PARM3_CLK_MEGA_DEBUG, buf, 2) < 0)
    return;
  avrdude_message(MSG_INFO, "%sJTAG clock megaAVR/debug:   %u kHz\n", p,
    b2_to_u16(buf));
 
  if (jtag3_getparm(pgm, SCOPE_AVR, 1, PARM3_CLK_XMEGA_JTAG, buf, 2) < 0)
    return;
  avrdude_message(MSG_INFO, "%sJTAG clock Xmega: %u kHz\n", p,
    b2_to_u16(buf));
 
  if (jtag3_getparm(pgm, SCOPE_AVR, 1, PARM3_CLK_XMEGA_PDI, buf, 2) < 0)
    return;
  avrdude_message(MSG_INFO, "%sPDI clock Xmega : %u kHz\n", p,
    b2_to_u16(buf));
}

References avrdude_message(), b2_to_u16(), jtag3_getparm(), MSG_INFO, PARM3_CLK_MEGA_DEBUG, PARM3_CLK_MEGA_PROG, PARM3_CLK_XMEGA_JTAG, PARM3_CLK_XMEGA_PDI, PARM3_VTARGET, pgm, SCOPE_AVR, and SCOPE_GENERAL.

Referenced by jtag3_display(), and jtag3_print_parms().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_prmsg()

static void jtag3_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, "%02x ", data[i]);
      if (i % 16 == 15)
  putc('\n', stderr);
      else
  putc(' ', stderr);
    }
    if (i % 16 != 0)
      putc('\n', stderr);
  }
 
  switch (data[0]) {
    case SCOPE_INFO:
      avrdude_message(MSG_INFO, "[info] ");
      break;
 
    case SCOPE_GENERAL:
      avrdude_message(MSG_INFO, "[general] ");
      break;
 
    case SCOPE_AVR_ISP:
      avrdude_message(MSG_INFO, "[AVRISP] ");
      jtag3_print_data(data + 1, len - 1);
      return;
 
    case SCOPE_AVR:
      avrdude_message(MSG_INFO, "[AVR] ");
      break;
 
    default:
      avrdude_message(MSG_INFO, "[scope 0x%02x] ", data[0]);
      break;
  }
 
  switch (data[1]) {
    case RSP3_OK:
      avrdude_message(MSG_INFO, "OK\n");
      break;
 
    case RSP3_FAILED:
      avrdude_message(MSG_INFO, "FAILED");
      if (len > 3)
      {
  char reason[50];
  sprintf(reason, "0x%02x", data[3]);
  switch (data[3])
  {
    case RSP3_FAIL_NO_ANSWER:
      strcpy(reason, "target does not answer");
      break;
 
    case RSP3_FAIL_NO_TARGET_POWER:
      strcpy(reason, "no target power");
      break;
 
    case RSP3_FAIL_NOT_UNDERSTOOD:
      strcpy(reason, "command not understood");
      break;
 
    case RSP3_FAIL_WRONG_MODE:
      strcpy(reason, "wrong (programming) mode");
      break;
 
    case RSP3_FAIL_PDI:
      strcpy(reason, "PDI failure");
      break;
 
    case RSP3_FAIL_UNSUPP_MEMORY:
      strcpy(reason, "unsupported memory type");
      break;
 
    case RSP3_FAIL_WRONG_LENGTH:
      strcpy(reason, "wrong length in memory access");
      break;
 
    case RSP3_FAIL_DEBUGWIRE:
      strcpy(reason, "debugWIRE communication failed");
      break;
  }
  avrdude_message(MSG_INFO, ", reason: %s\n", reason);
      }
      else
      {
  avrdude_message(MSG_INFO, ", unspecified reason\n");
      }
      break;
 
    case RSP3_DATA:
      avrdude_message(MSG_INFO, "Data returned:\n");
      jtag3_print_data(data + 2, len - 2);
      break;
 
    case RSP3_INFO:
      avrdude_message(MSG_INFO, "Info returned:\n");
      for (i = 2; i < len; i++) {
  if (isprint(data[i]))
    putc(data[i], stderr);
  else
    avrdude_message(MSG_INFO, "\\%03o", data[i]);
      }
      putc('\n', stderr);
      break;
 
    case RSP3_PC:
      if (len < 7)
      {
  avrdude_message(MSG_INFO, "PC reply too short\n");
      }
      else
      {
  unsigned long pc = (data[6] << 24) | (data[5] << 16)
    | (data[4] << 8) | data[3];
  avrdude_message(MSG_INFO, "PC 0x%0lx\n", pc);
      }
      break;
 
  default:
    avrdude_message(MSG_INFO, "unknown message 0x%02x\n", data[1]);
  }
}

References avrdude_message(), jtag3_print_data(), MSG_INFO, MSG_TRACE, RSP3_DATA, RSP3_FAIL_DEBUGWIRE, RSP3_FAIL_NO_ANSWER, RSP3_FAIL_NO_TARGET_POWER, RSP3_FAIL_NOT_UNDERSTOOD, RSP3_FAIL_PDI, RSP3_FAIL_UNSUPP_MEMORY, RSP3_FAIL_WRONG_LENGTH, RSP3_FAIL_WRONG_MODE, RSP3_FAILED, RSP3_INFO, RSP3_OK, RSP3_PC, SCOPE_AVR, SCOPE_AVR_ISP, SCOPE_GENERAL, SCOPE_INFO, and verbose.

Referenced by jtag3_command().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_program_disable()

static int jtag3_program_disable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[3], *resp;
 
  if (!PDATA(pgm)->prog_enabled)
    return 0;
 
  buf[0] = SCOPE_AVR;
  buf[1] = CMD3_LEAVE_PROGMODE;
  buf[2] = 0;
 
  if (jtag3_command(pgm, buf, 3, &resp, "leave progmode") < 0)
    return -1;
 
  free(resp);
 
  PDATA(pgm)->prog_enabled = 0;
 
  return 0;
}

References CMD3_LEAVE_PROGMODE, free(), jtag3_command(), PDATA, pgm, and SCOPE_AVR.

Referenced by jtag3_disable().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_program_enable()

static int jtag3_program_enable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[3], *resp;
 
  if (PDATA(pgm)->prog_enabled)
    return 0;
 
  buf[0] = SCOPE_AVR;
  buf[1] = CMD3_ENTER_PROGMODE;
  buf[2] = 0;
 
  if (jtag3_command(pgm, buf, 3, &resp, "enter progmode") >= 0) {
    free(resp);
    PDATA(pgm)->prog_enabled = 1;
 
    return 0;
  }
 
  return -1;
}

References CMD3_ENTER_PROGMODE, free(), jtag3_command(), PDATA, pgm, and SCOPE_AVR.

Referenced by jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_read_byte(), and jtag3_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_program_enable_dummy()

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

static

{
  return 0;
}

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the caller graph for this function:

jtag3_read_byte()

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

static

{
  unsigned char cmd[12];
  unsigned char *resp, *cache_ptr = NULL;
  int status, unsupp = 0;
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_read_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (!(pgm->flag & PGM_FL_IS_DW) && jtag3_program_enable(pgm) < 0)
    return -1;
 
  cmd[0] = SCOPE_AVR;
  cmd[1] = CMD3_READ_MEMORY;
  cmd[2] = 0;
 
  cmd[3] = ( 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) {
    addr += mem->offset & (512 * 1024 - 1); /* max 512 KiB flash */
    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 ) ) {
      cmd[3] = MTYPE_EEPROM;
    } else {
      cmd[3] = 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[3] = MTYPE_FUSE_BITS;
    addr = 0;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = 1;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = 2;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "lock", 4) == 0) {
    cmd[3] = MTYPE_LOCK_BITS;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = mem->offset & 7;
  } else if (strcmp(mem->desc, "usersig") == 0) {
    cmd[3] = MTYPE_USERSIG;
  } else if (strcmp(mem->desc, "prodsig") == 0) {
    cmd[3] = MTYPE_PRODSIG;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[3] = MTYPE_OSCCAL_BYTE;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "signature") == 0) {
    static unsigned char signature_cache[2];
 
    cmd[3] = MTYPE_SIGN_JTAG;
 
    /*
     * dW can read out the signature on JTAGICE3, but only allows
     * for a full three-byte read.  We cache them in a local
     * variable to avoid multiple reads.  This optimization does not
     * harm for other connection types either.
     */
    u32_to_b4(cmd + 8, 3);
    u32_to_b4(cmd + 4, 0);
 
    if (addr == 0) {
      if ((status = jtag3_command(pgm, cmd, 12, &resp, "read memory")) < 0)
  return -1;
 
      signature_cache[0] = resp[4];
      signature_cache[1] = resp[5];
      *value = resp[3];
      free(resp);
      return 0;
    } else if (addr <= 2) {
      *value = signature_cache[addr - 1];
      return 0;
    } else {
      /* should not happen */
      avrdude_message(MSG_INFO, "address out of range for signature memory: %lu\n", addr);
      return -1;
    }
  }
 
  /*
   * 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 + 8, pagesize);
    u32_to_b4(cmd + 4, paddr);
  } else {
    u32_to_b4(cmd + 8, 1);
    u32_to_b4(cmd + 4, addr);
  }
 
  if ((status = jtag3_command(pgm, cmd, 12, &resp, "read memory")) < 0)
    return -1;
 
  if (resp[1] != RSP3_DATA ||
      status < (pagesize? pagesize: 1) + 4) {
    avrdude_message(MSG_INFO, "%s: wrong/short reply to read memory command\n",
      progname);
    free(resp);
    return -1;
  }
 
  if (pagesize) {
    *paddr_ptr = paddr;
    memcpy(cache_ptr, resp + 3, pagesize);
    *value = cache_ptr[addr & (pagesize - 1)];
  } else
    *value = resp[3];
 
  free(resp);
  return 0;
}

References avrdude_message(), AVRPART_HAS_PDI, cmd, CMD3_READ_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtag3_command(), jtag3_program_enable(), 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, PDATA, pgm, PGM_FL_IS_DW, progname, RSP3_DATA, SCOPE_AVR, and u32_to_b4().

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), jtag3_pdi_initpgm(), and jtag3_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_recv()

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

                                                      {
  unsigned short r_seqno;
  int rv;
 
  for (;;) {
    if ((rv = jtag3_recv_frame(pgm, msg)) <= 0)
      return rv;
 
    if ((rv & USB_RECV_FLAG_EVENT) != 0) {
      if (verbose >= 3)
  jtag3_prevent(pgm, *msg, rv & USB_RECV_LENGTH_MASK);
 
      free(*msg);
      continue;
    }
 
    rv &= USB_RECV_LENGTH_MASK;
    r_seqno = ((*msg)[2] << 8) | (*msg)[1];
    avrdude_message(MSG_DEBUG, "%s: jtag3_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.
       */
      rv -= 3;
      memmove(*msg, *msg + 3, rv);
 
      return rv;
    }
    avrdude_message(MSG_NOTICE2, "%s: jtag3_recv(): "
        "got wrong sequence number, %u != %u\n",
        progname, r_seqno, PDATA(pgm)->command_sequence);
 
    free(*msg);
  }
}

References avrdude_message(), free(), jtag3_prevent(), jtag3_recv_frame(), MSG_DEBUG, MSG_NOTICE2, PDATA, pgm, progname, USB_RECV_FLAG_EVENT, USB_RECV_LENGTH_MASK, and verbose.

Referenced by jtag3_command().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_recv_frame()

static int jtag3_recv_frame ( PROGRAMMER *  pgm, unsigned char **  msg  )

static

                                                                   {
  int rv;
  unsigned char *buf = NULL;
 
  if (pgm->flag & PGM_FL_IS_EDBG)
    return jtag3_edbg_recv_frame(pgm, msg);
 
  avrdude_message(MSG_TRACE, "%s: jtag3_recv():\n", progname);
 
  if ((buf = malloc(pgm->fd.usb.max_xfer)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtag3_recv(): out of memory\n",
      progname);
    return -1;
  }
  if (verbose >= 4)
    memset(buf, 0, pgm->fd.usb.max_xfer);
 
  rv = serial_recv(&pgm->fd, buf, pgm->fd.usb.max_xfer);
 
  if (rv < 0) {
    /* timeout in receive */
    avrdude_message(MSG_NOTICE2, "%s: jtag3_recv(): Timeout receiving packet\n",
                      progname);
    free(buf);
    return -1;
  }
 
  *msg = buf;
 
  return rv;
}

References avrdude_message(), programmer_t::fd, programmer_t::flag, free(), jtag3_edbg_recv_frame(), malloc(), MSG_INFO, MSG_NOTICE2, MSG_TRACE, pgm, PGM_FL_IS_EDBG, progname, serial_recv, filedescriptor::usb, and verbose.

Referenced by jtag3_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_send()

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

{
  unsigned char *buf;
 
  if (pgm->flag & PGM_FL_IS_EDBG)
    return jtag3_edbg_send(pgm, data, len);
 
  avrdude_message(MSG_DEBUG, "\n%s: jtag3_send(): sending %lu bytes\n",
      progname, (unsigned long)len);
 
  if ((buf = malloc(len + 4)) == NULL)
    {
      avrdude_message(MSG_INFO, "%s: jtag3_send(): out of memory",
        progname);
      return -1;
    }
 
  buf[0] = TOKEN;
  buf[1] = 0;                   /* dummy */
  u16_to_b2(buf + 2, PDATA(pgm)->command_sequence);
  memcpy(buf + 4, data, len);
 
  if (serial_send(&pgm->fd, buf, len + 4) != 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_send(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
 
  free(buf);
 
  return 0;
}

References avrdude_message(), programmer_t::fd, programmer_t::flag, free(), jtag3_edbg_send(), malloc(), MSG_DEBUG, MSG_INFO, PDATA, pgm, PGM_FL_IS_EDBG, progname, serial_send, TOKEN, and u16_to_b2().

Referenced by jtag3_command().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_set_sck_mega_jtag()

static int jtag3_set_sck_mega_jtag ( PROGRAMMER *  pgm, unsigned char *  clk  )

static

{
    return jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CLK_MEGA_PROG, clk, 2);
}

References jtag3_setparm(), PARM3_CLK_MEGA_PROG, pgm, and SCOPE_AVR.

Referenced by jtag3_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_set_sck_period()

static int jtag3_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned char parm[2];
  unsigned int clock = 1E-3 / v; /* kHz */
 
  parm[0] = clock & 0xff;
  parm[1] = (clock >> 8) & 0xff;
 
  if (PDATA(pgm)->set_sck == NULL) {
    avrdude_message(MSG_INFO, "%s: No backend to set the SCK period for\n",
      progname);
    return -1;
  }
 
  return (PDATA(pgm)->set_sck(pgm, parm) < 0)? -1: 0;
}

References avrdude_message(), MSG_INFO, PDATA, pgm, and progname.

Referenced by jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_set_sck_xmega_jtag()

static int jtag3_set_sck_xmega_jtag ( PROGRAMMER *  pgm, unsigned char *  clk  )

static

{
    return jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CLK_XMEGA_JTAG, clk, 2);
}

References jtag3_setparm(), PARM3_CLK_XMEGA_JTAG, pgm, and SCOPE_AVR.

Referenced by jtag3_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_set_sck_xmega_pdi()

static int jtag3_set_sck_xmega_pdi ( PROGRAMMER *  pgm, unsigned char *  clk  )

static

{
    return jtag3_setparm(pgm, SCOPE_AVR, 1, PARM3_CLK_XMEGA_PDI, clk, 2);
}

References jtag3_setparm(), PARM3_CLK_XMEGA_PDI, pgm, and SCOPE_AVR.

Referenced by jtag3_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_setparm()

int jtag3_setparm	(	PROGRAMMER *	pgm,
		unsigned char	scope,
		unsigned char	section,
		unsigned char	parm,
		unsigned char *	value,
		unsigned char	length
	)

{
  int status;
  unsigned char *buf, *resp;
  char descr[60];
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_setparm()\n", progname);
 
  sprintf(descr, "set parameter (scope 0x%02x, section %d, parm %d)",
    scope, section, parm);
 
  if ((buf = malloc(6 + length)) == NULL)
  {
    avrdude_message(MSG_INFO, "%s: jtag3_setparm(): Out of memory\n",
      progname);
    return -1;
  }
 
  buf[0] = scope;
  buf[1] = CMD3_SET_PARAMETER;
  buf[2] = 0;
  buf[3] = section;
  buf[4] = parm;
  buf[5] = length;
  memcpy(buf + 6, value, length);
 
  status = jtag3_command(pgm, buf, length + 6, &resp, descr);
 
  free(buf);
  if (status > 0)
    free(resp);
 
  return status;
}

References avrdude_message(), CMD3_SET_PARAMETER, free(), jtag3_command(), malloc(), MSG_INFO, MSG_NOTICE2, pgm, and progname.

Referenced by jtag3_initialize(), jtag3_set_sck_mega_jtag(), jtag3_set_sck_xmega_jtag(), and jtag3_set_sck_xmega_pdi().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_setup()

void jtag3_setup

(

PROGRAMMER *

pgm

)

{
  if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
    avrdude_message(MSG_INFO, "%s: jtag3_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 jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_teardown()

void jtag3_teardown

(

PROGRAMMER *

pgm

)

{
  free(pgm->cookie);
}

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

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), and jtag3_pdi_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtag3_write_byte()

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

static

{
  unsigned char cmd[14];
  unsigned char *resp;
  unsigned char *cache_ptr = 0;
  int status, unsupp = 0;
  unsigned int pagesize = 0;
 
  avrdude_message(MSG_NOTICE2, "%s: jtag3_write_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  cmd[0] = SCOPE_AVR;
  cmd[1] = CMD3_WRITE_MEMORY;
  cmd[2] = 0;
  cmd[3] = ( p->flags & AVRPART_HAS_PDI ) ? MTYPE_FLASH : MTYPE_SPM;
  if (strcmp(mem->desc, "flash") == 0) {
     cache_ptr = PDATA(pgm)->flash_pagecache;
     pagesize = PDATA(pgm)->flash_pagesize;
     PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
     if (pgm->flag & PGM_FL_IS_DW)
       unsupp = 1;
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    if (pgm->flag & PGM_FL_IS_DW) {
      cmd[3] = MTYPE_EEPROM;
    } else {
      cache_ptr = PDATA(pgm)->eeprom_pagecache;
      pagesize = PDATA(pgm)->eeprom_pagesize;
    }
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
  } else if (strcmp(mem->desc, "lfuse") == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = 0;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = 1;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = 2;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strncmp(mem->desc, "fuse", strlen("fuse")) == 0) {
    cmd[3] = MTYPE_FUSE_BITS;
    addr = mem->offset & 7;
  } else if (strcmp(mem->desc, "usersig") == 0) {
    cmd[3] = MTYPE_USERSIG;
  } else if (strcmp(mem->desc, "prodsig") == 0) {
    cmd[3] = MTYPE_PRODSIG;
  } else if (strncmp(mem->desc, "lock", 4) == 0) {
    cmd[3] = MTYPE_LOCK_BITS;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[3] = MTYPE_OSCCAL_BYTE;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  } else if (strcmp(mem->desc, "signature") == 0) {
    cmd[3] = MTYPE_SIGN_JTAG;
    if (pgm->flag & PGM_FL_IS_DW)
      unsupp = 1;
  }
 
  if (unsupp)
    return -1;
 
  if (pagesize != 0) {
    /* flash or EEPROM write: use paged algorithm */
    unsigned char dummy;
    int i;
 
    /* step #1: ensure the page cache is up to date */
    if (jtag3_read_byte(pgm, p, mem, addr, &dummy) < 0)
      return -1;
    /* step #2: update our value in page cache, and copy
     * cache to mem->buf */
    cache_ptr[addr & (pagesize - 1)] = data;
    addr &= ~(pagesize - 1);  /* page base address */
    memcpy(mem->buf + addr, cache_ptr, pagesize);
    /* step #3: write back */
    i = jtag3_paged_write(pgm, p, mem, pagesize, addr, pagesize);
    if (i < 0)
      return -1;
    else
      return 0;
  }
 
  /* non-paged writes go here */
  if (!(pgm->flag & PGM_FL_IS_DW) && jtag3_program_enable(pgm) < 0)
    return -1;
 
  u32_to_b4(cmd + 8, 1);
  u32_to_b4(cmd + 4, addr);
  cmd[12] = 0;
  cmd[13] = data;
 
  if ((status = jtag3_command(pgm, cmd, 14, &resp, "write memory")) < 0)
    return -1;
 
  free(resp);
 
  return 0;
}

References avrdude_message(), AVRPART_HAS_PDI, avrmem::buf, cmd, CMD3_WRITE_MEMORY, avrmem::desc, programmer_t::flag, avrpart::flags, free(), jtag3_command(), jtag3_paged_write(), jtag3_program_enable(), jtag3_read_byte(), long, MSG_NOTICE2, MTYPE_EEPROM, 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, SCOPE_AVR, and u32_to_b4().

Referenced by jtag3_dw_initpgm(), jtag3_initpgm(), jtag3_paged_write(), and jtag3_pdi_initpgm().

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 jtag3_edbg_send(), jtag3_initialize(), and jtag3_send().

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 jtag3_initialize(), jtag3_page_erase(), jtag3_paged_load(), jtag3_paged_write(), jtag3_read_byte(), and jtag3_write_byte().

Here is the caller graph for this function:

Variable Documentation

jtag3_desc

const char jtag3_desc[] = "Atmel JTAGICE3"

jtag3_dw_desc

const char jtag3_dw_desc[] = "Atmel JTAGICE3 in debugWire mode"

jtag3_pdi_desc

const char jtag3_pdi_desc[] = "Atmel JTAGICE3 in PDI mode"