avr910.c File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/time.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "avr910.h"

Include dependency graph for avr910.c:

Go to the source code of this file.

Classes
struct	pdata

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

Functions
static void	avr910_setup (PROGRAMMER *pgm)
static void	avr910_teardown (PROGRAMMER *pgm)
static int	avr910_send (PROGRAMMER *pgm, char *buf, size_t len)
static int	avr910_recv (PROGRAMMER *pgm, char *buf, size_t len)
static int	avr910_drain (PROGRAMMER *pgm, int display)
static int	avr910_vfy_cmd_sent (PROGRAMMER *pgm, char *errmsg)
static int	avr910_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static int	avr910_enter_prog_mode (PROGRAMMER *pgm)
static int	avr910_leave_prog_mode (PROGRAMMER *pgm)
static int	avr910_program_enable (PROGRAMMER *pgm, AVRPART *p)
static int	avr910_initialize (PROGRAMMER *pgm, AVRPART *p)
static void	avr910_disable (PROGRAMMER *pgm)
static void	avr910_enable (PROGRAMMER *pgm)
static int	avr910_cmd (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res)
static int	avr910_parseextparms (PROGRAMMER *pgm, LISTID extparms)
static int	avr910_open (PROGRAMMER *pgm, char *port)
static void	avr910_close (PROGRAMMER *pgm)
static void	avr910_display (PROGRAMMER *pgm, const char *p)
static void	avr910_set_addr (PROGRAMMER *pgm, unsigned long addr)
static int	avr910_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char value)
static int	avr910_read_byte_flash (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	avr910_read_byte_eeprom (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	avr910_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	avr910_paged_write_flash (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	avr910_paged_write_eeprom (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	avr910_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	avr910_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	avr910_read_sig_bytes (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m)
void	avr910_initpgm (PROGRAMMER *pgm)

Variables
const char	avr910_desc [] = "Serial programmers using protocol described in application note AVR910"

Macro Definition Documentation

PDATA

#define PDATA

(

pgm

)

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

Function Documentation

avr910_chip_erase()

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

static

{
  avr910_send(pgm, "e", 1);
  if (avr910_vfy_cmd_sent(pgm, "chip erase") < 0)
    return -1;
 
  /*
   * avr910 firmware may not delay long enough
   */
  usleep (p->chip_erase_delay);
 
  return 0;
}

References avr910_send(), avr910_vfy_cmd_sent(), avrpart::chip_erase_delay, pgm, and usleep().

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_close()

static void avr910_close ( PROGRAMMER *  pgm )

static

{
  avr910_leave_prog_mode(pgm);
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

References avr910_leave_prog_mode(), programmer_t::fd, filedescriptor::ifd, pgm, and serial_close.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_cmd()

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

static

{
  char buf[5];
 
  /* FIXME: Insert version check here */
 
  buf[0] = '.';                 /* New Universal Command */
  buf[1] = cmd[0];
  buf[2] = cmd[1];
  buf[3] = cmd[2];
  buf[4] = cmd[3];
 
  avr910_send (pgm, buf, 5);
  avr910_recv (pgm, buf, 2);
 
  res[0] = 0x00;                /* Dummy value */
  res[1] = cmd[0];
  res[2] = cmd[1];
  res[3] = buf[0];
 
  return 0;
}

References avr910_recv(), avr910_send(), cmd, and pgm.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_disable()

static void avr910_disable ( PROGRAMMER *  pgm )

static

{
  /* Do nothing. */
 
  return;
}

Referenced by avr910_initpgm().

Here is the caller graph for this function:

avr910_display()

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

static

{
  return;
}

Referenced by avr910_initpgm().

Here is the caller graph for this function:

avr910_drain()

static int avr910_drain ( PROGRAMMER *  pgm, int  display  )

static

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by avr910_open().

Here is the caller graph for this function:

avr910_enable()

static void avr910_enable ( PROGRAMMER *  pgm )

static

{
  /* Do nothing. */
 
  return;
}

Referenced by avr910_initpgm().

Here is the caller graph for this function:

avr910_enter_prog_mode()

static int avr910_enter_prog_mode ( PROGRAMMER *  pgm )

static

{
  avr910_send(pgm, "P", 1);
  return avr910_vfy_cmd_sent(pgm, "enter prog mode");
}

References avr910_send(), avr910_vfy_cmd_sent(), and pgm.

Referenced by avr910_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_initialize()

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

static

{
  char id[8];
  char sw[2];
  char hw[2];
  char buf[10];
  char type;
  char c;
  AVRPART * part;
 
  /* Get the programmer identifier. Programmer returns exactly 7 chars
     _without_ the null.*/
 
  avr910_send(pgm, "S", 1);
  memset (id, 0, sizeof(id));
  avr910_recv(pgm, id, sizeof(id)-1);
 
  /* Get the HW and SW versions to see if the programmer is present. */
 
  avr910_send(pgm, "V", 1);
  avr910_recv(pgm, sw, sizeof(sw));
 
  avr910_send(pgm, "v", 1);
  avr910_recv(pgm, hw, sizeof(hw));
 
  /* Get the programmer type (serial or parallel). Expect serial. */
 
  avr910_send(pgm, "p", 1);
  avr910_recv(pgm, &type, 1);
 
  avrdude_message(MSG_INFO, "Found programmer: Id = \"%s\"; type = %c\n", id, type);
  avrdude_message(MSG_INFO, "    Software Version = %c.%c; ", sw[0], sw[1]);
  avrdude_message(MSG_INFO, "Hardware Version = %c.%c\n", hw[0], hw[1]);
 
  /* See if programmer supports autoincrement of address. */
 
  avr910_send(pgm, "a", 1);
  avr910_recv(pgm, &PDATA(pgm)->has_auto_incr_addr, 1);
  if (PDATA(pgm)->has_auto_incr_addr == 'Y')
      avrdude_message(MSG_INFO, "Programmer supports auto addr increment.\n");
 
  /* Check support for buffered memory access, ignore if not available */
 
  if (PDATA(pgm)->test_blockmode == 1) {
    avr910_send(pgm, "b", 1);
    avr910_recv(pgm, &c, 1);
    if (c == 'Y') {
      avr910_recv(pgm, &c, 1);
      PDATA(pgm)->buffersize = (unsigned int)(unsigned char)c<<8;
      avr910_recv(pgm, &c, 1);
      PDATA(pgm)->buffersize += (unsigned int)(unsigned char)c;
      avrdude_message(MSG_INFO, "Programmer supports buffered memory access with "
                      "buffersize = %u bytes.\n",
                      PDATA(pgm)->buffersize);
      PDATA(pgm)->use_blockmode = 1;
    } else {
      PDATA(pgm)->use_blockmode = 0;
    }
  } else {
    PDATA(pgm)->use_blockmode = 0;
  }
 
  if (PDATA(pgm)->devcode == 0) {
    char devtype_1st;
    int dev_supported = 0;
 
    /* Get list of devices that the programmer supports. */
 
    avr910_send(pgm, "t", 1);
    avrdude_message(MSG_INFO, "\nProgrammer supports the following devices:\n");
    devtype_1st = 0;
    while (1) {
      avr910_recv(pgm, &c, 1);
      if (devtype_1st == 0)
  devtype_1st = c;
      if (c == 0)
  break;
      part = locate_part_by_avr910_devcode(part_list, c);
 
      avrdude_message(MSG_INFO, "    Device code: 0x%02x = %s\n", c, part ?  part->desc : "(unknown)");
 
      /* FIXME: Need to lookup devcode and report the device. */
 
      if (p->avr910_devcode == c)
  dev_supported = 1;
    };
    avrdude_message(MSG_INFO, "\n");
 
    if (!dev_supported) {
      avrdude_message(MSG_INFO, "%s: %s: selected device is not supported by programmer: %s\n",
                      progname, ovsigck? "warning": "error", p->id);
      if (!ovsigck)
  return -1;
    }
    /* If the user forced the selection, use the first device
       type that is supported by the programmer. */
    buf[1] = ovsigck? devtype_1st: p->avr910_devcode;
  } else {
    /* devcode overridden by -x devcode= option */
    buf[1] = (char)(PDATA(pgm)->devcode);
  }
 
  /* Tell the programmer which part we selected. */
  buf[0] = 'T';
  /* buf[1] has been set up above */
 
  avr910_send(pgm, buf, 2);
  avr910_vfy_cmd_sent(pgm, "select device");
 
  avrdude_message(MSG_NOTICE, "%s: avr910_devcode selected: 0x%02x\n",
                  progname, (unsigned)buf[1]);
 
  avr910_enter_prog_mode(pgm);
 
  return 0;
}

References avrpart::avr910_devcode, avr910_enter_prog_mode(), avr910_recv(), avr910_send(), avr910_vfy_cmd_sent(), avrdude_message(), avrpart::desc, avrpart::id, locate_part_by_avr910_devcode(), MSG_INFO, MSG_NOTICE, ovsigck, part_list, PDATA, pgm, and progname.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_initpgm()

void avr910_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "avr910");
 
  /*
   * mandatory functions
   */
  pgm->initialize     = avr910_initialize;
  pgm->display        = avr910_display;
  pgm->enable         = avr910_enable;
  pgm->disable        = avr910_disable;
  pgm->program_enable = avr910_program_enable;
  pgm->chip_erase     = avr910_chip_erase;
  pgm->cmd            = avr910_cmd;
  pgm->open           = avr910_open;
  pgm->close          = avr910_close;
 
  /*
   * optional functions
   */
 
  pgm->write_byte = avr910_write_byte;
  pgm->read_byte = avr910_read_byte;
 
  pgm->paged_write = avr910_paged_write;
  pgm->paged_load = avr910_paged_load;
 
  pgm->read_sig_bytes = avr910_read_sig_bytes;
 
  pgm->parseextparams = avr910_parseextparms;
  pgm->setup          = avr910_setup;
  pgm->teardown       = avr910_teardown;
}

References avr910_chip_erase(), avr910_close(), avr910_cmd(), avr910_disable(), avr910_display(), avr910_enable(), avr910_initialize(), avr910_open(), avr910_paged_load(), avr910_paged_write(), avr910_parseextparms(), avr910_program_enable(), avr910_read_byte(), avr910_read_sig_bytes(), avr910_setup(), avr910_teardown(), avr910_write_byte(), programmer_t::chip_erase, programmer_t::close, programmer_t::cmd, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::initialize, programmer_t::open, programmer_t::paged_load, programmer_t::paged_write, programmer_t::parseextparams, pgm, programmer_t::program_enable, programmer_t::read_byte, programmer_t::read_sig_bytes, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

avr910_leave_prog_mode()

static int avr910_leave_prog_mode ( PROGRAMMER *  pgm )

static

{
  avr910_send(pgm, "L", 1);
  return avr910_vfy_cmd_sent(pgm, "leave prog mode");
}

References avr910_send(), avr910_vfy_cmd_sent(), and pgm.

Referenced by avr910_close().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_open()

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

static

{
  union pinfo pinfo;
  /*
   *  If baudrate was not specified use 19.200 Baud
   */
  if(pgm->baudrate == 0) {
    pgm->baudrate = 19200;
  }
 
  strcpy(pgm->port, port);
  pinfo.baud = pgm->baudrate;
  if (serial_open(port, pinfo, &pgm->fd)==-1) {
    return -1;
  }
 
  /*
   * drain any extraneous input
   */
  avr910_drain (pgm, 0);
  
  return 0;
}

References avr910_drain(), pinfo::baud, programmer_t::baudrate, programmer_t::fd, pgm, programmer_t::port, and serial_open.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_paged_load()

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

static

{
  char cmd[4];
  int rd_size;
  unsigned int max_addr;
  char buf[2];
  int rval=0;
 
  max_addr = addr + n_bytes;
 
  if (strcmp(m->desc, "flash") == 0) {
    cmd[0] = 'R';
    rd_size = 2;                /* read two bytes per addr */
  } else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[0] = 'd';
    rd_size = 1;
  } else {
    return -2;
  }
 
  if (PDATA(pgm)->use_blockmode) {
    /* use buffered mode */
    int blocksize = PDATA(pgm)->buffersize;
 
    cmd[0] = 'g';
    cmd[3] = toupper((int)(m->desc[0]));
 
    avr910_set_addr(pgm, addr / rd_size);
 
    while (addr < max_addr) {
      if ((max_addr - addr) < (unsigned)blocksize) {
        blocksize = max_addr - addr;
      }
      cmd[1] = (blocksize >> 8) & 0xff;
      cmd[2] = blocksize & 0xff;
 
      avr910_send(pgm, cmd, 4);
      avr910_recv(pgm, (char *)&m->buf[addr], blocksize);
 
      addr += blocksize;
    }
 
    rval = addr;
  } else {
 
    avr910_set_addr(pgm, addr / rd_size);
 
    while (addr < max_addr) {
      avr910_send(pgm, cmd, 1);
      if (rd_size == 2) {
        /* The 'R' command returns two bytes, MSB first, we need to put the data
           into the memory buffer LSB first. */
        avr910_recv(pgm, buf, 2);
        m->buf[addr]   = buf[1];  /* LSB */
        m->buf[addr + 1] = buf[0];  /* MSB */
      }
      else {
        avr910_recv(pgm, (char *)&m->buf[addr], 1);
      }
 
      addr += rd_size;
 
      if (PDATA(pgm)->has_auto_incr_addr != 'Y') {
        avr910_set_addr(pgm, addr / rd_size);
      }
    }
 
    rval = addr;
  }
 
  return rval;
}

References avr910_recv(), avr910_send(), avr910_set_addr(), avrmem::buf, cmd, avrmem::desc, PDATA, and pgm.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_paged_write()

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

static

{
  int rval = 0;
  if (PDATA(pgm)->use_blockmode == 0) {
    if (strcmp(m->desc, "flash") == 0) {
      rval = avr910_paged_write_flash(pgm, p, m, page_size, addr, n_bytes);
    } else if (strcmp(m->desc, "eeprom") == 0) {
      rval = avr910_paged_write_eeprom(pgm, p, m, page_size, addr, n_bytes);
    } else {
      rval = -2;
    }
  }
 
  if (PDATA(pgm)->use_blockmode == 1) {
    unsigned int max_addr = addr + n_bytes;
    char *cmd;
    unsigned int blocksize = PDATA(pgm)->buffersize;
    int wr_size;
 
    if (strcmp(m->desc, "flash") && strcmp(m->desc, "eeprom"))
      return -2;
 
    if (m->desc[0] == 'e') {
      blocksize = 1;    /* Write to eeprom single bytes only */
      wr_size = 1;
    } else {
      wr_size = 2;
    }
 
    avr910_set_addr(pgm, addr / wr_size);
 
    cmd = malloc(4 + blocksize);
    if (!cmd) return -1;
     
    cmd[0] = 'B';
    cmd[3] = toupper((int)(m->desc[0]));
 
    while (addr < max_addr) {
      if ((max_addr - addr) < blocksize) {
        blocksize = max_addr - addr;
      };
      memcpy(&cmd[4], &m->buf[addr], blocksize);
      cmd[1] = (blocksize >> 8) & 0xff;
      cmd[2] = blocksize & 0xff;
 
      avr910_send(pgm, cmd, 4 + blocksize);
      avr910_vfy_cmd_sent(pgm, "write block");
 
      addr += blocksize;
    } /* while */
    free(cmd);
 
    rval = addr;
  }
  return rval;
}

References avr910_paged_write_eeprom(), avr910_paged_write_flash(), avr910_send(), avr910_set_addr(), avr910_vfy_cmd_sent(), avrmem::buf, cmd, avrmem::desc, free(), malloc(), PDATA, and pgm.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_paged_write_eeprom()

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

static

{
  char cmd[2];
  unsigned int max_addr = addr + n_bytes;
 
  avr910_set_addr(pgm, addr);
 
  cmd[0] = 'D';
 
  while (addr < max_addr) {
    cmd[1] = m->buf[addr];
    avr910_send(pgm, cmd, sizeof(cmd));
    avr910_vfy_cmd_sent(pgm, "write byte");
    usleep(m->max_write_delay);
 
    addr++;
 
    if (PDATA(pgm)->has_auto_incr_addr != 'Y') {
      avr910_set_addr(pgm, addr);
    }
  }
 
  return addr;
}

References avr910_send(), avr910_set_addr(), avr910_vfy_cmd_sent(), avrmem::buf, cmd, avrmem::max_write_delay, PDATA, pgm, and usleep().

Referenced by avr910_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_paged_write_flash()

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

static

{
  unsigned char cmd[] = {'c', 'C'};
  char buf[2];
  unsigned int max_addr = addr + n_bytes;
  unsigned int page_addr;
  int page_bytes = page_size;
  int page_wr_cmd_pending = 0;
 
  page_addr = addr;
  avr910_set_addr(pgm, addr>>1);
 
  while (addr < max_addr) {
    page_wr_cmd_pending = 1;
    buf[0] = cmd[addr & 0x01];
    buf[1] = m->buf[addr];
    avr910_send(pgm, buf, sizeof(buf));
    avr910_vfy_cmd_sent(pgm, "write byte");
 
    addr++;
    page_bytes--;
 
    if (m->paged && (page_bytes == 0)) {
      /* Send the "Issue Page Write" if we have sent a whole page. */
 
      avr910_set_addr(pgm, page_addr>>1);
      avr910_send(pgm, "m", 1);
      avr910_vfy_cmd_sent(pgm, "flush page");
 
      page_wr_cmd_pending = 0;
      usleep(m->max_write_delay);
      avr910_set_addr(pgm, addr>>1);
 
      /* Set page address for next page. */
 
      page_addr = addr;
      page_bytes = page_size;
    }
    else if ((PDATA(pgm)->has_auto_incr_addr != 'Y') && ((addr & 0x01) == 0)) {
      avr910_set_addr(pgm, addr>>1);
    }
  }
 
  /* If we didn't send the page wr cmd after the last byte written in the
     loop, send it now. */
 
  if (page_wr_cmd_pending) {
    avr910_set_addr(pgm, page_addr>>1);
    avr910_send(pgm, "m", 1);
    avr910_vfy_cmd_sent(pgm, "flush final page");
    usleep(m->max_write_delay);
  }
 
  return addr;
}

References avr910_send(), avr910_set_addr(), avr910_vfy_cmd_sent(), avrmem::buf, cmd, avrmem::max_write_delay, avrmem::paged, PDATA, pgm, and usleep().

Referenced by avr910_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_parseextparms()

static int avr910_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, "devcode=", strlen("devcode=")) == 0) {
      int devcode;
      if (sscanf(extended_param, "devcode=%i", &devcode) != 1 ||
    devcode <= 0 || devcode > 255) {
        avrdude_message(MSG_INFO, "%s: avr910_parseextparms(): invalid devcode '%s'\n",
                        progname, extended_param);
        rv = -1;
        continue;
      }
      avrdude_message(MSG_NOTICE2, "%s: avr910_parseextparms(): devcode overwritten as 0x%02x\n",
                      progname, devcode);
      PDATA(pgm)->devcode = devcode;
 
      continue;
    }
    if (strncmp(extended_param, "no_blockmode", strlen("no_blockmode")) == 0) {
      avrdude_message(MSG_NOTICE2, "%s: avr910_parseextparms(-x): no testing for Blockmode\n",
                      progname);
      PDATA(pgm)->test_blockmode = 0;
 
      continue;
    }
 
    avrdude_message(MSG_INFO, "%s: avr910_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, and progname.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_program_enable()

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

static

{
  return -1;
}

Referenced by avr910_initpgm().

Here is the caller graph for this function:

avr910_read_byte()

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

static

{
  if (strcmp(m->desc, "flash") == 0) {
    return avr910_read_byte_flash(pgm, p, m, addr, value);
  }
 
  if (strcmp(m->desc, "eeprom") == 0) {
    return avr910_read_byte_eeprom(pgm, p, m, addr, value);
  }
 
  return avr_read_byte_default(pgm, p, m, addr, value);
}

References avr910_read_byte_eeprom(), avr910_read_byte_flash(), avr_read_byte_default(), avrmem::desc, and pgm.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_read_byte_eeprom()

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

static

{
  avr910_set_addr(pgm, addr);
  avr910_send(pgm, "d", 1);
  avr910_recv(pgm, (char *)value, 1);
 
  return 0;
}

References avr910_recv(), avr910_send(), avr910_set_addr(), and pgm.

Referenced by avr910_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_read_byte_flash()

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

static

{
  char buf[2];
 
  avr910_set_addr(pgm, addr >> 1);
 
  avr910_send(pgm, "R", 1);
 
  /* Read back the program mem word (MSB first) */
  avr910_recv(pgm, buf, sizeof(buf));
 
  if ((addr & 0x01) == 0) {
    *value = buf[1];
  }
  else {
    *value = buf[0];
  }
 
  return 0;
}

References avr910_recv(), avr910_send(), avr910_set_addr(), and pgm.

Referenced by avr910_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_read_sig_bytes()

static int avr910_read_sig_bytes ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m  )

static

{
  unsigned char tmp;
 
  if (m->size < 3) {
    avrdude_message(MSG_INFO, "%s: memsize too small for sig byte read", progname);
    return -1;
  }
 
  avr910_send(pgm, "s", 1);
  avr910_recv(pgm, (char *)m->buf, 3);
  /* Returned signature has wrong order. */
  tmp = m->buf[2];
  m->buf[2] = m->buf[0];
  m->buf[0] = tmp;
 
  return 3;
}

References avr910_recv(), avr910_send(), avrdude_message(), avrmem::buf, MSG_INFO, pgm, progname, and avrmem::size.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_recv()

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

static

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

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

Referenced by avr910_cmd(), avr910_initialize(), avr910_paged_load(), avr910_read_byte_eeprom(), avr910_read_byte_flash(), avr910_read_sig_bytes(), and avr910_vfy_cmd_sent().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_send()

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

static

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

References programmer_t::fd, pgm, and serial_send.

Referenced by avr910_chip_erase(), avr910_cmd(), avr910_enter_prog_mode(), avr910_initialize(), avr910_leave_prog_mode(), avr910_paged_load(), avr910_paged_write(), avr910_paged_write_eeprom(), avr910_paged_write_flash(), avr910_read_byte_eeprom(), avr910_read_byte_flash(), avr910_read_sig_bytes(), avr910_set_addr(), and avr910_write_byte().

Here is the caller graph for this function:

avr910_set_addr()

static void avr910_set_addr ( PROGRAMMER *  pgm, unsigned long  addr  )

static

{
  char cmd[3];
 
  cmd[0] = 'A';
  cmd[1] = (addr >> 8) & 0xff;
  cmd[2] = addr & 0xff;
  
  avr910_send(pgm, cmd, sizeof(cmd));
  avr910_vfy_cmd_sent(pgm, "set addr");
}

References avr910_send(), avr910_vfy_cmd_sent(), cmd, and pgm.

Referenced by avr910_paged_load(), avr910_paged_write(), avr910_paged_write_eeprom(), avr910_paged_write_flash(), avr910_read_byte_eeprom(), avr910_read_byte_flash(), and avr910_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_setup()

static void avr910_setup ( PROGRAMMER *  pgm )

static

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

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

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_teardown()

static void avr910_teardown ( PROGRAMMER *  pgm )

static

{
  free(pgm->cookie);
}

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

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_vfy_cmd_sent()

static int avr910_vfy_cmd_sent ( PROGRAMMER *  pgm, char *  errmsg  )

static

{
  char c;
 
  avr910_recv(pgm, &c, 1);
  if (c != '\r') {
    avrdude_message(MSG_INFO, "%s: error: programmer did not respond to command: %s\n",
            progname, errmsg);
    return 1;
  }
  return 0;
}

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

Referenced by avr910_chip_erase(), avr910_enter_prog_mode(), avr910_initialize(), avr910_leave_prog_mode(), avr910_paged_write(), avr910_paged_write_eeprom(), avr910_paged_write_flash(), avr910_set_addr(), and avr910_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

avr910_write_byte()

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

static

{
  char cmd[2];
 
  if (strcmp(m->desc, "flash") == 0) {
    if (addr & 0x01) {
      cmd[0] = 'C';             /* Write Program Mem high byte */
    }
    else {
      cmd[0] = 'c';
    }
 
    addr >>= 1;
  }
  else if (strcmp(m->desc, "eeprom") == 0) {
    cmd[0] = 'D';
  }
  else {
    return avr_write_byte_default(pgm, p, m, addr, value);
  }
 
  cmd[1] = value;
 
  avr910_set_addr(pgm, addr);
 
  avr910_send(pgm, cmd, sizeof(cmd));
  avr910_vfy_cmd_sent(pgm, "write byte");
 
  return 0;
}

References avr910_send(), avr910_set_addr(), avr910_vfy_cmd_sent(), avr_write_byte_default(), cmd, avrmem::desc, and pgm.

Referenced by avr910_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

avr910_desc

const char avr910_desc[] = "Serial programmers using protocol described in application note AVR910"