jtagmkI.c File Reference

#include "ac_cfg.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 "jtagmkI.h"
#include "jtagmkI_private.h"

Include dependency graph for jtagmkI.c:

Go to the source code of this file.

Classes
struct	pdata

Macros
#define	PDATA(pgm)   ((struct pdata *)(pgm->cookie))
#define	OCDEN   (1 << 7)
#define	MAXTRIES   3
#define	MAXTRIES   3

Functions
static int	jtagmkI_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
static int	jtagmkI_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
static int	jtagmkI_set_sck_period (PROGRAMMER *pgm, double v)
static int	jtagmkI_getparm (PROGRAMMER *pgm, unsigned char parm, unsigned char *value)
static int	jtagmkI_setparm (PROGRAMMER *pgm, unsigned char parm, unsigned char value)
static void	jtagmkI_print_parms1 (PROGRAMMER *pgm, const char *p)
static int	jtagmkI_resync (PROGRAMMER *pgm, int maxtries, int signon)
static void	jtagmkI_setup (PROGRAMMER *pgm)
static void	jtagmkI_teardown (PROGRAMMER *pgm)
static void	u32_to_b3 (unsigned char *b, unsigned long l)
static void	u16_to_b2 (unsigned char *b, unsigned short l)
static void	jtagmkI_prmsg (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	jtagmkI_send (PROGRAMMER *pgm, unsigned char *data, size_t len)
static int	jtagmkI_recv (PROGRAMMER *pgm, unsigned char *buf, size_t len)
static int	jtagmkI_drain (PROGRAMMER *pgm, int display)
static int	jtagmkI_getsync (PROGRAMMER *pgm)
static int	jtagmkI_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static void	jtagmkI_set_devdescr (PROGRAMMER *pgm, AVRPART *p)
static int	jtagmkI_reset (PROGRAMMER *pgm)
static int	jtagmkI_program_enable_dummy (PROGRAMMER *pgm, AVRPART *p)
static int	jtagmkI_program_enable (PROGRAMMER *pgm)
static int	jtagmkI_program_disable (PROGRAMMER *pgm)
static unsigned char	jtagmkI_get_baud (long baud)
static int	jtagmkI_initialize (PROGRAMMER *pgm, AVRPART *p)
static void	jtagmkI_disable (PROGRAMMER *pgm)
static void	jtagmkI_enable (PROGRAMMER *pgm)
static int	jtagmkI_open (PROGRAMMER *pgm, char *port)
static void	jtagmkI_close (PROGRAMMER *pgm)
static int	jtagmkI_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	jtagmkI_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static void	jtagmkI_display (PROGRAMMER *pgm, const char *p)
static void	jtagmkI_print_parms (PROGRAMMER *pgm)
void	jtagmkI_initpgm (PROGRAMMER *pgm)

Variables
struct {
long	baud
unsigned char	val
}	baudtab []
const char	jtagmkI_desc [] = "Atmel JTAG ICE mkI"

Macro Definition Documentation

MAXTRIES [1/2]

#define MAXTRIES   3

MAXTRIES [2/2]

#define MAXTRIES   3

OCDEN

#define OCDEN   (1 << 7)

PDATA

#define PDATA

(

pgm

)

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

Function Documentation

jtagmkI_chip_erase()

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

static

{
  unsigned char buf[1], resp[2];
 
  buf[0] = CMD_CHIP_ERASE;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_chip_erase(): Sending chip erase command: ",
      progname);
  jtagmkI_send(pgm, buf, 1);
  if (jtagmkI_recv(pgm, resp, 2) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_chip_erase(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  pgm->initialize(pgm, p);
 
  return 0;
}

References avrdude_message(), CMD_CHIP_ERASE, programmer_t::initialize, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_close()

static void jtagmkI_close ( PROGRAMMER *  pgm )

static

{
  unsigned char b;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_close()\n", progname);
 
  /*
   * Revert baud rate to what it used to be when we started.  This
   * appears to make AVR Studio happier when it is about to access the
   * ICE later on.
   */
  if ((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
    if ((b = jtagmkI_get_baud(PDATA(pgm)->initial_baudrate)) == 0) {
      avrdude_message(MSG_INFO, "%s: jtagmkI_close(): unsupported baudrate %d\n",
              progname, PDATA(pgm)->initial_baudrate);
    } else {
      avrdude_message(MSG_NOTICE2, "%s: jtagmkI_close(): "
                "trying to set baudrate to %d\n",
                progname, PDATA(pgm)->initial_baudrate);
      if (jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
        serial_setspeed(&pgm->fd, pgm->baudrate);
      }
    }
  }
 
  if (pgm->fd.ifd != -1) {
    serial_close(&pgm->fd);
  }
 
  pgm->fd.ifd = -1;
}

References avrdude_message(), programmer_t::baudrate, programmer_t::fd, serial_device::flags, filedescriptor::ifd, jtagmkI_get_baud(), jtagmkI_setparm(), MSG_INFO, MSG_NOTICE2, PARM_BITRATE, PDATA, pgm, progname, serdev, SERDEV_FL_CANSETSPEED, serial_close, and serial_setspeed.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_disable()

static void jtagmkI_disable ( PROGRAMMER *  pgm )

static

{
 
  free(PDATA(pgm)->flash_pagecache);
  PDATA(pgm)->flash_pagecache = NULL;
  free(PDATA(pgm)->eeprom_pagecache);
  PDATA(pgm)->eeprom_pagecache = NULL;
 
  (void)jtagmkI_program_disable(pgm);
}

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

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_display()

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

static

{
 
  unsigned char hw, fw;
 
  if (jtagmkI_getparm(pgm, PARM_HW_VERSION, &hw) < 0 ||
      jtagmkI_getparm(pgm, PARM_SW_VERSION, &fw) < 0)
    return;
 
  avrdude_message(MSG_INFO, "%sICE hardware version: 0x%02x\n", p, hw);
  avrdude_message(MSG_INFO, "%sICE firmware version: 0x%02x\n", p, fw);
 
  jtagmkI_print_parms1(pgm, p);
 
  return;
}

References avrdude_message(), jtagmkI_getparm(), jtagmkI_print_parms1(), MSG_INFO, PARM_HW_VERSION, PARM_SW_VERSION, and pgm.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_drain()

static int jtagmkI_drain ( PROGRAMMER *  pgm, int  display  )

static

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by jtagmkI_getsync(), jtagmkI_initialize(), jtagmkI_open(), and jtagmkI_resync().

Here is the caller graph for this function:

jtagmkI_enable()

static void jtagmkI_enable ( PROGRAMMER *  pgm )

static

{
  return;
}

Referenced by jtagmkI_initpgm().

Here is the caller graph for this function:

jtagmkI_get_baud()

static unsigned char jtagmkI_get_baud ( long  baud )

static

{
  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.

Referenced by jtagmkI_close(), and jtagmkI_initialize().

Here is the caller graph for this function:

jtagmkI_getparm()

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

static

{
  unsigned char buf[2], resp[3];
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getparm()\n", progname);
 
  buf[0] = CMD_GET_PARAM;
  buf[1] = parm;
  if (verbose >= 2)
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getparm(): "
      "Sending get parameter command (parm 0x%02x): ",
      progname, parm);
  jtagmkI_send(pgm, buf, 2);
 
  if (jtagmkI_recv(pgm, resp, 3) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_getparm(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else if (resp[2] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_getparm(): "
                    "unknown parameter 0x%02x\n",
                    progname, parm);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK, value 0x%02x\n", resp[1]);
  }
 
  *value = resp[1];
 
  return 0;
}

References avrdude_message(), CMD_GET_PARAM, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_display(), and jtagmkI_print_parms1().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_getsync()

static int jtagmkI_getsync ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[1], resp[9];
 
  if (jtagmkI_resync(pgm, 5, 1) < 0) {
    jtagmkI_drain(pgm, 0);
    return -1;
  }
 
  jtagmkI_drain(pgm, 0);
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getsync(): Sending sign-on command: ",
      progname);
 
  buf[0] = CMD_GET_SIGNON;
  jtagmkI_send(pgm, buf, 1);
  if (jtagmkI_recv(pgm, resp, 9) < 0)
    return -1;
  if (verbose >= 2) {
    resp[8] = '\0';
    avrdude_message(MSG_NOTICE2, "got %s\n", resp + 1);
  }
 
  return 0;
}

References avrdude_message(), CMD_GET_SIGNON, jtagmkI_drain(), jtagmkI_recv(), jtagmkI_resync(), jtagmkI_send(), MSG_NOTICE2, pgm, progname, and verbose.

Referenced by jtagmkI_open().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_initialize()

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

static

{
  AVRMEM hfuse;
  unsigned char cmd[1], resp[5];
  unsigned char b;
 
  if (!(p->flags & AVRPART_HAS_JTAG)) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): part %s has no JTAG interface\n",
      progname, p->desc);
    return -1;
  }
 
  jtagmkI_drain(pgm, 0);
 
  if ((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
    if ((b = jtagmkI_get_baud(pgm->baudrate)) == 0) {
      avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): unsupported baudrate %d\n",
              progname, pgm->baudrate);
    } else {
      avrdude_message(MSG_NOTICE2, "%s: jtagmkI_initialize(): "
        "trying to set baudrate to %d\n",
                progname, pgm->baudrate);
      if (jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
        PDATA(pgm)->initial_baudrate = pgm->baudrate; /* don't adjust again later */
        serial_setspeed(&pgm->fd, pgm->baudrate);
      }
    }
  }
 
  if (pgm->bitclock != 0.0) {
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_initialize(): "
        "trying to set JTAG clock period to %.1f us\n",
        progname, pgm->bitclock);
    if (jtagmkI_set_sck_period(pgm, pgm->bitclock) != 0)
      return -1;
  }
 
  cmd[0] = CMD_STOP;
  jtagmkI_send(pgm, cmd, 1);
  if (jtagmkI_recv(pgm, resp, 5) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  /*
   * Must set the device descriptor before entering programming mode.
   */
  jtagmkI_set_devdescr(pgm, p);
 
  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, PDATA(pgm)->flash_pagesize & 0xff);
  jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, PDATA(pgm)->flash_pagesize >> 8);
  jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, PDATA(pgm)->eeprom_pagesize & 0xff);
 
  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: jtagmkI_initialize(): Out of memory\n",
      progname);
    return -1;
  }
  if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_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 (jtagmkI_reset(pgm) < 0)
    return -1;
 
  strcpy(hfuse.desc, "hfuse");
  if (jtagmkI_read_byte(pgm, p, &hfuse, 1, &b) < 0)
    return -1;
  if ((b & OCDEN) != 0)
    avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): warning: OCDEN fuse not programmed, "
                    "single-byte EEPROM updates not possible\n",
                    progname);
 
  return 0;
}

References avrdude_message(), AVRPART_HAS_JTAG, programmer_t::baudrate, programmer_t::bitclock, cmd, CMD_STOP, avrpart::desc, avrmem::desc, programmer_t::fd, avrpart::flags, serial_device::flags, free(), jtagmkI_drain(), jtagmkI_get_baud(), jtagmkI_read_byte(), jtagmkI_recv(), jtagmkI_reset(), jtagmkI_send(), jtagmkI_set_devdescr(), jtagmkI_set_sck_period(), jtagmkI_setparm(), long, malloc(), MSG_INFO, MSG_NOTICE2, OCDEN, PARM_BITRATE, PARM_EEPROM_PAGESIZE, PARM_FLASH_PAGESIZE_HIGH, PARM_FLASH_PAGESIZE_LOW, PDATA, pgm, progname, RESP_OK, serdev, SERDEV_FL_CANSETSPEED, serial_setspeed, and verbose.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_initpgm()

void jtagmkI_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "JTAGMKI");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = jtagmkI_initialize;
  pgm->display        = jtagmkI_display;
  pgm->enable         = jtagmkI_enable;
  pgm->disable        = jtagmkI_disable;
  pgm->program_enable = jtagmkI_program_enable_dummy;
  pgm->chip_erase     = jtagmkI_chip_erase;
  pgm->open           = jtagmkI_open;
  pgm->close          = jtagmkI_close;
  pgm->read_byte      = jtagmkI_read_byte;
  pgm->write_byte     = jtagmkI_write_byte;
 
  /*
   * optional functions
   */
  pgm->paged_write    = jtagmkI_paged_write;
  pgm->paged_load     = jtagmkI_paged_load;
  pgm->print_parms    = jtagmkI_print_parms;
  pgm->set_sck_period = jtagmkI_set_sck_period;
  pgm->setup          = jtagmkI_setup;
  pgm->teardown       = jtagmkI_teardown;
  pgm->page_size      = 256;
}

References programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::initialize, jtagmkI_chip_erase(), jtagmkI_close(), jtagmkI_disable(), jtagmkI_display(), jtagmkI_enable(), jtagmkI_initialize(), jtagmkI_open(), jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_print_parms(), jtagmkI_program_enable_dummy(), jtagmkI_read_byte(), jtagmkI_set_sck_period(), jtagmkI_setup(), jtagmkI_teardown(), jtagmkI_write_byte(), programmer_t::open, programmer_t::page_size, programmer_t::paged_load, programmer_t::paged_write, pgm, programmer_t::print_parms, programmer_t::program_enable, programmer_t::read_byte, programmer_t::set_sck_period, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

jtagmkI_open()

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

static

{
  size_t i;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open()\n", progname);
 
  strcpy(pgm->port, port);
  PDATA(pgm)->initial_baudrate = -1L;
 
  for (i = 0; i < sizeof(baudtab) / sizeof(baudtab[0]); i++) {
    union pinfo pinfo;
    pinfo.baud = baudtab[i].baud;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open(): trying to sync at baud rate %ld:\n",
                      progname, pinfo.baud);
    if (serial_open(port, pinfo, &pgm->fd)==-1) {
      return -1;
    }
 
    /*
     * drain any extraneous input
     */
    jtagmkI_drain(pgm, 0);
 
    if (jtagmkI_getsync(pgm) == 0) {
      PDATA(pgm)->initial_baudrate = baudtab[i].baud;
      avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open(): succeeded\n", progname);
      return 0;
    }
 
    serial_close(&pgm->fd);
  }
 
  avrdude_message(MSG_INFO, "%s: jtagmkI_open(): failed to synchronize to ICE\n",
                  progname);
  pgm->fd.ifd = -1;
 
  return -1;
}

References avrdude_message(), pinfo::baud, baudtab, programmer_t::fd, filedescriptor::ifd, jtagmkI_drain(), jtagmkI_getsync(), MSG_INFO, MSG_NOTICE2, PDATA, pgm, programmer_t::port, progname, serial_close, and serial_open.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_paged_load()

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

static

{
  int block_size, read_size, is_flash = 0, tries;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char cmd[6], resp[256 * 2 + 3];
  long otimeout = serial_recv_timeout;
#define MAXTRIES 3
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_load(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (jtagmkI_program_enable(pgm) < 0)
    return -1;
 
  page_size = m->readsize;
 
  cmd[0] = CMD_READ_MEM;
  if (strcmp(m->desc, "flash") == 0) {
    cmd[1] = MTYPE_FLASH_PAGE;
    is_flash = 1;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[1] = MTYPE_EEPROM_PAGE;
  }
 
  if (page_size > (is_flash? 512: 256)) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): page size %d too large\n",
      progname, page_size);
    return -1;
  }
 
  serial_recv_timeout = 1000;
  for (; addr < maxaddr; addr += page_size) {
    tries = 0;
    again:
    if (tries != 0 && jtagmkI_resync(pgm, 2000, 0) < 0) {
      avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): sync loss, retries exhausted\n",
                      progname);
      return -1;
    }
 
    if (n_bytes < page_size)
      block_size = n_bytes;
    else
      block_size = page_size;
    avrdude_message(MSG_DEBUG, "%s: jtagmkI_paged_load(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    if (is_flash) {
      read_size = 2 * ((block_size + 1) / 2); /* round up */
      cmd[2] = read_size / 2 - 1;
      u32_to_b3(cmd + 3, addr / 2);
    } else {
      read_size = page_size;
      cmd[2] = page_size - 1;
      u32_to_b3(cmd + 3, addr);
    }
 
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_load(): Sending read memory command: ",
        progname);
 
    jtagmkI_send(pgm, cmd, 6);
    if (jtagmkI_recv(pgm, resp, read_size + 3) < 0)
      return -1;
 
    if (resp[read_size + 3 - 1] != RESP_OK) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): "
                      "timeout/error communicating with programmer (resp %c)\n",
                      progname, resp[read_size + 3 - 1]);
      if (tries++ < MAXTRIES)
  goto again;
 
      serial_recv_timeout = otimeout;
      return -1;
    } else {
      if (verbose == 2)
        avrdude_message(MSG_NOTICE2, "OK\n");
    }
 
    memcpy(m->buf + addr, resp + 1, block_size);
  }
  serial_recv_timeout = otimeout;
 
#undef MAXTRIES
  return n_bytes;
}

References avrdude_message(), avrmem::buf, cmd, CMD_READ_MEM, avrmem::desc, jtagmkI_program_enable(), jtagmkI_recv(), jtagmkI_resync(), jtagmkI_send(), MAXTRIES, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM_PAGE, MTYPE_FLASH_PAGE, pgm, progname, avrmem::readsize, RESP_OK, serial_recv_timeout, u32_to_b3(), and verbose.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_paged_write()

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

static

{
  int block_size, send_size, tries;
  unsigned int maxaddr = addr + n_bytes;
  unsigned char cmd[6], *datacmd;
  unsigned char resp[2];
  int is_flash = 0;
  long otimeout = serial_recv_timeout;
#define MAXTRIES 3
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_write(.., %s, %d, %d)\n",
      progname, m->desc, page_size, n_bytes);
 
  if (jtagmkI_program_enable(pgm) < 0)
    return -1;
 
  if (page_size == 0) page_size = 256;
 
  if (page_size > 256) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): page size %d too large\n",
      progname, page_size);
    return -1;
  }
 
  if ((datacmd = malloc(page_size + 1)) == NULL) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): Out of memory\n",
      progname);
    return -1;
  }
 
  cmd[0] = CMD_WRITE_MEM;
  if (strcmp(m->desc, "flash") == 0) {
    cmd[1] = MTYPE_FLASH_PAGE;
    PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
    page_size = PDATA(pgm)->flash_pagesize;
    is_flash = 1;
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[1] = MTYPE_EEPROM_PAGE;
    PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
    page_size = PDATA(pgm)->eeprom_pagesize;
  }
  datacmd[0] = CMD_DATA;
 
  serial_recv_timeout = 1000;
  for (; addr < maxaddr; addr += page_size) {
    tries = 0;
    again:
 
    if (tries != 0 && jtagmkI_resync(pgm, 2000, 0) < 0) {
      avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): sync loss, retries exhausted\n",
                      progname);
      return -1;
    }
 
    if (n_bytes < page_size)
      block_size = n_bytes;
    else
      block_size = page_size;
    avrdude_message(MSG_DEBUG, "%s: jtagmkI_paged_write(): "
        "block_size at addr %d is %d\n",
        progname, addr, block_size);
 
    /* We always write full pages. */
    send_size = page_size;
    if (is_flash) {
      cmd[2] = send_size / 2 - 1;
      u32_to_b3(cmd + 3, addr / 2);
    } else {
      cmd[2] = send_size - 1;
      u32_to_b3(cmd + 3, addr);
    }
 
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_write(): "
        "Sending write memory command: ",
        progname);
 
    /* First part, send the write command. */
    jtagmkI_send(pgm, cmd, 6);
    if (jtagmkI_recv(pgm, resp, 1) < 0)
      return -1;
    if (resp[0] != RESP_OK) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): "
                      "timeout/error communicating with programmer (resp %c)\n",
                      progname, resp[0]);
      if (tries++ < MAXTRIES)
  goto again;
      serial_recv_timeout = otimeout;
      return -1;
    } else {
      if (verbose == 2)
        avrdude_message(MSG_NOTICE2, "OK\n");
    }
 
    /*
     * 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(datacmd + 1, 0xff, page_size);
    memcpy(datacmd + 1, m->buf + addr, block_size);
 
    /* Second, send the data command. */
    jtagmkI_send(pgm, datacmd, send_size + 1);
    if (jtagmkI_recv(pgm, resp, 2) < 0)
      return -1;
    if (resp[1] != RESP_OK) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): "
                      "timeout/error communicating with programmer (resp %c)\n",
                      progname, resp[0]);
      if (tries++ < MAXTRIES)
  goto again;
      serial_recv_timeout = otimeout;
      return -1;
    } else {
      if (verbose == 2)
        avrdude_message(MSG_NOTICE2, "OK\n");
    }
  }
 
  free(datacmd);
  serial_recv_timeout = otimeout;
 
#undef MAXTRIES
  return n_bytes;
}

References avrdude_message(), avrmem::buf, cmd, CMD_DATA, CMD_WRITE_MEM, avrmem::desc, free(), jtagmkI_program_enable(), jtagmkI_recv(), jtagmkI_resync(), jtagmkI_send(), long, malloc(), MAXTRIES, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM_PAGE, MTYPE_FLASH_PAGE, PDATA, pgm, progname, RESP_OK, serial_recv_timeout, u32_to_b3(), and verbose.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_print_parms()

static void jtagmkI_print_parms ( PROGRAMMER *  pgm )

static

{
  jtagmkI_print_parms1(pgm, "");
}

References jtagmkI_print_parms1(), and pgm.

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_print_parms1()

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

static

{
  unsigned char vtarget, jtag_clock;
  const char *clkstr;
  double clk;
 
  if (jtagmkI_getparm(pgm, PARM_OCD_VTARGET, &vtarget) < 0 ||
      jtagmkI_getparm(pgm, PARM_CLOCK, &jtag_clock) < 0)
    return;
 
  switch ((unsigned)jtag_clock) {
  case JTAG_BITRATE_1_MHz:
    clkstr = "1 MHz";
    clk = 1e6;
    break;
 
  case JTAG_BITRATE_500_kHz:
    clkstr = "500 kHz";
    clk = 500e3;
    break;
 
  case JTAG_BITRATE_250_kHz:
    clkstr = "250 kHz";
    clk = 250e3;
    break;
 
  case JTAG_BITRATE_125_kHz:
    clkstr = "125 kHz";
    clk = 125e3;
    break;
 
  default:
    clkstr = "???";
    clk = 1e6;
  }
 
  avrdude_message(MSG_INFO, "%sVtarget         : %.1f V\n", p,
    6.25 * (unsigned)vtarget / 255.0);
  avrdude_message(MSG_INFO, "%sJTAG clock      : %s (%.1f us)\n", p, clkstr,
    1.0e6 / clk);
 
  return;
}

References avrdude_message(), JTAG_BITRATE_125_kHz, JTAG_BITRATE_1_MHz, JTAG_BITRATE_250_kHz, JTAG_BITRATE_500_kHz, jtagmkI_getparm(), MSG_INFO, PARM_CLOCK, PARM_OCD_VTARGET, and pgm.

Referenced by jtagmkI_display(), and jtagmkI_print_parms().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_prmsg()

static void jtagmkI_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 RESP_OK:
    avrdude_message(MSG_INFO, "OK\n");
    break;
 
  case RESP_FAILED:
    avrdude_message(MSG_INFO, "FAILED\n");
    break;
 
  case RESP_BREAK:
    avrdude_message(MSG_INFO, "breakpoint hit\n");
    break;
 
  case RESP_INFO:
    avrdude_message(MSG_INFO, "IDR dirty\n");
    break;
 
  case RESP_SYNC_ERROR:
    avrdude_message(MSG_INFO, "Synchronization lost\n");
    break;
 
  case RESP_SLEEP:
    avrdude_message(MSG_INFO, "sleep instruction hit\n");
    break;
 
  case RESP_POWER:
    avrdude_message(MSG_INFO, "target power lost\n");
 
  default:
    avrdude_message(MSG_INFO, "unknown message 0x%02x\n", data[0]);
  }
 
  putc('\n', stderr);
}

References avrdude_message(), MSG_INFO, MSG_TRACE, RESP_BREAK, RESP_FAILED, RESP_INFO, RESP_OK, RESP_POWER, RESP_SLEEP, RESP_SYNC_ERROR, and verbose.

Referenced by jtagmkI_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_program_disable()

static int jtagmkI_program_disable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[1], resp[2];
 
  if (!PDATA(pgm)->prog_enabled)
    return 0;
 
  if (pgm->fd.ifd != -1) {
    buf[0] = CMD_LEAVE_PROGMODE;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_program_disable(): "
              "Sending leave progmode command: ",
              progname);
    jtagmkI_send(pgm, buf, 1);
 
    if (jtagmkI_recv(pgm, resp, 2) < 0)
      return -1;
    if (resp[0] != RESP_OK) {
      if (verbose >= 2)
        putc('\n', stderr);
      avrdude_message(MSG_INFO, "%s: jtagmkI_program_disable(): "
                      "timeout/error communicating with programmer (resp %c)\n",
                      progname, resp[0]);
      return -1;
    } else {
      if (verbose == 2)
        avrdude_message(MSG_NOTICE2, "OK\n");
    }
  }
  PDATA(pgm)->prog_enabled = 0;
 
  return 0;
}

References avrdude_message(), CMD_LEAVE_PROGMODE, programmer_t::fd, filedescriptor::ifd, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, PDATA, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_disable(), and jtagmkI_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_program_enable()

static int jtagmkI_program_enable ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[1], resp[2];
 
  if (PDATA(pgm)->prog_enabled)
    return 0;
 
  buf[0] = CMD_ENTER_PROGMODE;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_program_enable(): "
      "Sending enter progmode command: ",
      progname);
  jtagmkI_send(pgm, buf, 1);
 
  if (jtagmkI_recv(pgm, resp, 2) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_program_enable(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  PDATA(pgm)->prog_enabled = 1;
 
  return 0;
}

References avrdude_message(), CMD_ENTER_PROGMODE, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, PDATA, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_read_byte(), and jtagmkI_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_program_enable_dummy()

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

static

{
 
  return 0;
}

Referenced by jtagmkI_initpgm().

Here is the caller graph for this function:

jtagmkI_read_byte()

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

static

{
  unsigned char cmd[6];
  unsigned char resp[256 * 2 + 3], *cache_ptr = NULL;
  unsigned long paddr = 0UL, *paddr_ptr = NULL;
  unsigned int pagesize = 0;
  int respsize = 3 + 1;
  int is_flash = 0;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_read_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  if (jtagmkI_program_enable(pgm) < 0)
    return -1;
 
  cmd[0] = CMD_READ_MEM;
 
  if (strcmp(mem->desc, "flash") == 0) {
    cmd[1] = MTYPE_FLASH_PAGE;
    pagesize = mem->page_size;
    paddr = addr & ~(pagesize - 1);
    paddr_ptr = &PDATA(pgm)->flash_pageaddr;
    cache_ptr = PDATA(pgm)->flash_pagecache;
    is_flash = 1;
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    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;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 2;
  } else if (strcmp(mem->desc, "lock") == 0) {
    cmd[1] = MTYPE_LOCK_BITS;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[1] = MTYPE_OSCCAL_BYTE;
  } else if (strcmp(mem->desc, "signature") == 0) {
    cmd[1] = MTYPE_SIGN_JTAG;
  }
 
  /*
   * 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) {
    if (is_flash) {
      cmd[2] = pagesize / 2 - 1;
      u32_to_b3(cmd + 3, paddr / 2);
    } else {
      cmd[2] = pagesize - 1;
      u32_to_b3(cmd + 3, paddr);
    }
    respsize = 3 + pagesize;
  } else {
    if (cmd[1] == MTYPE_FUSE_BITS) {
      /*
       * The mkI ICE has a bug where it doesn't read efuse correctly
       * when reading it as a single byte @offset 2, while reading all
       * fuses at once does work.
       */
      cmd[2] = 3 - 1;
      u32_to_b3(cmd + 3, 0);
      respsize = 3 + 3;
    } else {
      cmd[2] = 1 - 1;
      u32_to_b3(cmd + 3, addr);
    }
  }
 
  jtagmkI_send(pgm, cmd, 6);
  if (jtagmkI_recv(pgm, resp, respsize) < 0)
    return -1;
 
  if (resp[respsize - 1] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_read_byte(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[respsize - 1]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  if (pagesize) {
    *paddr_ptr = paddr;
    memcpy(cache_ptr, resp + 1, pagesize);
    *value = cache_ptr[addr & (pagesize - 1)];
  } else if (cmd[1] == MTYPE_FUSE_BITS) {
    /* extract the desired fuse */
    *value = resp[1 + addr];
  } else
    *value = resp[1];
 
  return 0;
}

References avrdude_message(), cmd, CMD_READ_MEM, avrmem::desc, jtagmkI_program_enable(), jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM_PAGE, MTYPE_FLASH_PAGE, MTYPE_FUSE_BITS, MTYPE_LOCK_BITS, MTYPE_OSCCAL_BYTE, MTYPE_SIGN_JTAG, avrmem::page_size, PDATA, pgm, progname, RESP_OK, u32_to_b3(), and verbose.

Referenced by jtagmkI_initialize(), and jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_recv()

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

static

{
  if (serial_recv(&pgm->fd, buf, len) != 0) {
    avrdude_message(MSG_INFO, "\n%s: jtagmkI_recv(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
  if (verbose >= 3) {
    putc('\n', stderr);
    jtagmkI_prmsg(pgm, buf, len);
  }
  return 0;
}

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

Referenced by jtagmkI_chip_erase(), jtagmkI_getparm(), jtagmkI_getsync(), jtagmkI_initialize(), jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_program_disable(), jtagmkI_program_enable(), jtagmkI_read_byte(), jtagmkI_reset(), jtagmkI_set_devdescr(), jtagmkI_setparm(), and jtagmkI_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_reset()

static int jtagmkI_reset ( PROGRAMMER *  pgm )

static

{
  unsigned char buf[1], resp[2];
 
  buf[0] = CMD_RESET;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_reset(): Sending reset command: ",
      progname);
  jtagmkI_send(pgm, buf, 1);
 
  if (jtagmkI_recv(pgm, resp, 2) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_reset(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  return 0;
}

References avrdude_message(), CMD_RESET, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_resync()

static int jtagmkI_resync ( PROGRAMMER *  pgm, int  maxtries, int  signon  )

static

{
  int tries;
  unsigned char buf[4], resp[9];
  long otimeout = serial_recv_timeout;
 
  serial_recv_timeout = 200;
 
  avrdude_message(MSG_TRACE, "%s: jtagmkI_resync()\n", progname);
 
  jtagmkI_drain(pgm, 0);
 
  for (tries = 0; tries < maxtries; tries++) {
 
    /* Get the sign-on information. */
    buf[0] = CMD_GET_SYNC;
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): Sending sync command: ",
        progname);
 
    if (serial_send(&pgm->fd, buf, 1) != 0) {
      avrdude_message(MSG_INFO, "\n%s: jtagmkI_resync(): failed to send command to serial port\n",
                      progname);
      serial_recv_timeout = otimeout;
      return -1;
    }
    if (serial_recv(&pgm->fd, resp, 1) == 0 && resp[0] == RESP_OK) {
      avrdude_message(MSG_NOTICE2, "got RESP_OK\n");
      break;
    }
 
    if (signon) {
      /*
       * The following is black magic, the idea has been taken from
       * AVaRICE.
       *
       * Apparently, the ICE behaves differently right after a
       * power-up vs. when reconnecting to an ICE that has already
       * been worked with.  The undocumented 'E' command (or
       * subcommand) occasionally helps in getting the connection into
       * sync.
       */
      buf[0] = CMD_GET_SIGNON;
      buf[1] = 'E';
      buf[2] = ' ';
      buf[3] = ' ';
      avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): Sending sign-on command: ",
    progname);
 
      if (serial_send(&pgm->fd, buf, 4) != 0) {
  avrdude_message(MSG_INFO, "\n%s: jtagmkI_resync(): failed to send command to serial port\n",
                        progname);
  serial_recv_timeout = otimeout;
  return -1;
      }
      if (serial_recv(&pgm->fd, resp, 9) == 0 && resp[0] == RESP_OK) {
        avrdude_message(MSG_NOTICE2, "got RESP_OK\n");
  break;
      }
    }
  }
  if (tries >= maxtries) {
    avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): "
                      "timeout/error communicating with programmer\n",
                      progname);
    serial_recv_timeout = otimeout;
    return -1;
  }
 
  serial_recv_timeout = otimeout;
  return 0;
}

References avrdude_message(), CMD_GET_SIGNON, CMD_GET_SYNC, programmer_t::fd, jtagmkI_drain(), MSG_INFO, MSG_NOTICE2, MSG_TRACE, pgm, progname, RESP_OK, serial_recv, serial_recv_timeout, and serial_send.

Referenced by jtagmkI_getsync(), jtagmkI_paged_load(), and jtagmkI_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_send()

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

static

{
  unsigned char *buf;
 
  avrdude_message(MSG_DEBUG, "\n%s: jtagmkI_send(): sending %u bytes\n",
      progname, (unsigned int)len);
 
  if ((buf = malloc(len + 2)) == NULL)
    {
      avrdude_message(MSG_INFO, "%s: jtagmkI_send(): out of memory",
        progname);
      exit(1);
    }
 
  memcpy(buf, data, len);
  buf[len] = ' ';   /* "CRC" */
  buf[len + 1] = ' ';   /* EOP */
 
  if (serial_send(&pgm->fd, buf, len + 2) != 0) {
    avrdude_message(MSG_INFO, "%s: jtagmkI_send(): failed to send command to serial port\n",
                    progname);
    return -1;
  }
 
  free(buf);
 
  return 0;
}

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

Referenced by jtagmkI_chip_erase(), jtagmkI_getparm(), jtagmkI_getsync(), jtagmkI_initialize(), jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_program_disable(), jtagmkI_program_enable(), jtagmkI_read_byte(), jtagmkI_reset(), jtagmkI_set_devdescr(), jtagmkI_setparm(), and jtagmkI_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_set_devdescr()

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

static

{
  unsigned char resp[2];
  LNODEID ln;
  AVRMEM * m;
  struct {
    unsigned char cmd;
    struct device_descriptor dd;
  } sendbuf;
 
  memset(&sendbuf, 0, sizeof sendbuf);
  sendbuf.cmd = CMD_SET_DEVICE_DESCRIPTOR;
  sendbuf.dd.ucSPMCRAddress = p->spmcr;
  sendbuf.dd.ucRAMPZAddress = p->rampz;
  sendbuf.dd.ucIDRAddress = p->idr;
  for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
    m = ldata(ln);
    if (strcmp(m->desc, "flash") == 0) {
      PDATA(pgm)->flash_pagesize = m->page_size;
      u16_to_b2(sendbuf.dd.uiFlashPageSize, PDATA(pgm)->flash_pagesize);
    } else if (strcmp(m->desc, "eeprom") == 0) {
      sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
    }
  }
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_set_devdescr(): "
      "Sending set device descriptor command: ",
      progname);
  jtagmkI_send(pgm, (unsigned char *)&sendbuf, sizeof(sendbuf));
 
  if (jtagmkI_recv(pgm, resp, 2) < 0)
    return;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_set_devdescr(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
}

References avrdude_message(), cmd, CMD_SET_DEVICE_DESCRIPTOR, avrmem::desc, avrpart::idr, jtagmkI_recv(), jtagmkI_send(), ldata(), lfirst(), lnext(), avrpart::mem, MSG_INFO, MSG_NOTICE2, avrmem::page_size, PDATA, pgm, progname, avrpart::rampz, RESP_OK, avrpart::spmcr, u16_to_b2(), and verbose.

Referenced by jtagmkI_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_set_sck_period()

static int jtagmkI_set_sck_period ( PROGRAMMER *  pgm, double  v  )

static

{
  unsigned char dur;
 
  v = 1 / v;      /* convert to frequency */
  if (v >= 1e6)
    dur = JTAG_BITRATE_1_MHz;
  else if (v >= 499e3)
    dur = JTAG_BITRATE_500_kHz;
  else if (v >= 249e3)
    dur = JTAG_BITRATE_250_kHz;
  else
    dur = JTAG_BITRATE_125_kHz;
 
  return jtagmkI_setparm(pgm, PARM_CLOCK, dur);
}

References JTAG_BITRATE_125_kHz, JTAG_BITRATE_1_MHz, JTAG_BITRATE_250_kHz, JTAG_BITRATE_500_kHz, jtagmkI_setparm(), PARM_CLOCK, and pgm.

Referenced by jtagmkI_initialize(), and jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_setparm()

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

static

{
  unsigned char buf[3], resp[2];
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_setparm()\n", progname);
 
  buf[0] = CMD_SET_PARAM;
  buf[1] = parm;
  buf[2] = value;
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_setparm(): "
      "Sending set parameter command (parm 0x%02x): ",
      progname, parm);
  jtagmkI_send(pgm, buf, 3);
  if (jtagmkI_recv(pgm, resp, 2) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_setparm(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  return 0;
}

References avrdude_message(), CMD_SET_PARAM, jtagmkI_recv(), jtagmkI_send(), MSG_INFO, MSG_NOTICE2, pgm, progname, RESP_OK, and verbose.

Referenced by jtagmkI_close(), jtagmkI_initialize(), and jtagmkI_set_sck_period().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_setup()

static void jtagmkI_setup ( PROGRAMMER *  pgm )

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_teardown()

static void jtagmkI_teardown ( PROGRAMMER *  pgm )

static

{
  free(pgm->cookie);
}

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

Referenced by jtagmkI_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

jtagmkI_write_byte()

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

static

{
  unsigned char cmd[6], datacmd[1 * 2 + 1];
  unsigned char resp[1], writedata;
  int len, need_progmode = 1;
 
  avrdude_message(MSG_NOTICE2, "%s: jtagmkI_write_byte(.., %s, 0x%lx, ...)\n",
      progname, mem->desc, addr);
 
  writedata = data;
  cmd[0] = CMD_WRITE_MEM;
  if (strcmp(mem->desc, "flash") == 0) {
    cmd[1] = MTYPE_SPM;
    need_progmode = 0;
    PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
  } else if (strcmp(mem->desc, "eeprom") == 0) {
    cmd[1] = 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;
  } else if (strcmp(mem->desc, "hfuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 1;
  } else if (strcmp(mem->desc, "efuse") == 0) {
    cmd[1] = MTYPE_FUSE_BITS;
    addr = 2;
  } else if (strcmp(mem->desc, "lock") == 0) {
    cmd[1] = MTYPE_LOCK_BITS;
  } else if (strcmp(mem->desc, "calibration") == 0) {
    cmd[1] = MTYPE_OSCCAL_BYTE;
  } else if (strcmp(mem->desc, "signature") == 0) {
    cmd[1] = MTYPE_SIGN_JTAG;
  }
 
  if (need_progmode) {
    if (jtagmkI_program_enable(pgm) < 0)
      return -1;
  } else {
    if (jtagmkI_program_disable(pgm) < 0)
      return -1;
  }
 
  cmd[2] = 1 - 1;
  if (cmd[1] == MTYPE_SPM) {
    /*
     * Flash is word-addressed, but we cannot handle flash anyway
     * here, as it needs to be written one page at a time...
     */
    u32_to_b3(cmd + 3, addr / 2);
  } else {
    u32_to_b3(cmd + 3, addr);
  }
  /* First part, send the write command. */
  jtagmkI_send(pgm, cmd, 6);
  if (jtagmkI_recv(pgm, resp, 1) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_write_byte(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  /* Now, send the data buffer. */
  datacmd[0] = CMD_DATA;
  if (cmd[1] == MTYPE_SPM) {
    len = 3;
    if ((addr & 1) != 0) {
      datacmd[1] = 0;
      datacmd[2] = writedata;
    } else {
      datacmd[1] = writedata;
      datacmd[2] = 0;
    }
  } else {
    len = 2;
    datacmd[1] = writedata;
  }
  jtagmkI_send(pgm, datacmd, len);
  if (jtagmkI_recv(pgm, resp, 1) < 0)
    return -1;
  if (resp[0] != RESP_OK) {
    if (verbose >= 2)
      putc('\n', stderr);
    avrdude_message(MSG_INFO, "%s: jtagmkI_write_byte(): "
                    "timeout/error communicating with programmer (resp %c)\n",
                    progname, resp[0]);
    return -1;
  } else {
    if (verbose == 2)
      avrdude_message(MSG_NOTICE2, "OK\n");
  }
 
  return 0;
}

References avrdude_message(), cmd, CMD_DATA, CMD_WRITE_MEM, avrmem::desc, jtagmkI_program_disable(), jtagmkI_program_enable(), jtagmkI_recv(), jtagmkI_send(), long, MSG_INFO, MSG_NOTICE2, MTYPE_EEPROM, MTYPE_FUSE_BITS, MTYPE_LOCK_BITS, MTYPE_OSCCAL_BYTE, MTYPE_SIGN_JTAG, MTYPE_SPM, PDATA, pgm, progname, RESP_OK, u32_to_b3(), and verbose.

Referenced by jtagmkI_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 jtagmkI_set_devdescr().

Here is the caller graph for this function:

u32_to_b3()

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

static

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

Referenced by jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_read_byte(), and jtagmkI_write_byte().

Here is the caller graph for this function:

Variable Documentation

[struct]

const struct { ... } baudtab[]

Initial value:

= {
  {  19200L, 0xfa },
  { 115200L, 0xff },
  {   9600L, 0xf4 },
  {  38400L, 0xfd },
  {  57600L, 0xfe },
 
}

Referenced by jtagmkI_get_baud(), jtagmkI_open(), and jtagmkII_get_baud().

jtagmkI_desc

const char jtagmkI_desc[] = "Atmel JTAG ICE mkI"