butterfly.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 "avrdude.h"
#include "libavrdude.h"
#include "butterfly.h"

Include dependency graph for butterfly.c:

Go to the source code of this file.

Classes
struct	pdata

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

Functions
static void	butterfly_setup (PROGRAMMER *pgm)
static void	butterfly_teardown (PROGRAMMER *pgm)
static int	butterfly_send (PROGRAMMER *pgm, char *buf, size_t len)
static int	butterfly_recv (PROGRAMMER *pgm, char *buf, size_t len)
static int	butterfly_drain (PROGRAMMER *pgm, int display)
static int	butterfly_vfy_cmd_sent (PROGRAMMER *pgm, char *errmsg)
static int	butterfly_rdy_led (PROGRAMMER *pgm, int value)
static int	butterfly_err_led (PROGRAMMER *pgm, int value)
static int	butterfly_pgm_led (PROGRAMMER *pgm, int value)
static int	butterfly_vfy_led (PROGRAMMER *pgm, int value)
static int	butterfly_chip_erase (PROGRAMMER *pgm, AVRPART *p)
static void	butterfly_enter_prog_mode (PROGRAMMER *pgm)
static void	butterfly_leave_prog_mode (PROGRAMMER *pgm)
static int	butterfly_program_enable (PROGRAMMER *pgm, AVRPART *p)
static void	butterfly_powerup (PROGRAMMER *pgm)
static void	butterfly_powerdown (PROGRAMMER *pgm)
static int	butterfly_initialize (PROGRAMMER *pgm, AVRPART *p)
static void	butterfly_disable (PROGRAMMER *pgm)
static void	butterfly_enable (PROGRAMMER *pgm)
static int	butterfly_open (PROGRAMMER *pgm, char *port)
static void	butterfly_close (PROGRAMMER *pgm)
static void	butterfly_display (PROGRAMMER *pgm, const char *p)
static void	butterfly_set_addr (PROGRAMMER *pgm, unsigned long addr)
static void	butterfly_set_extaddr (PROGRAMMER *pgm, unsigned long addr)
static int	butterfly_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char value)
static int	butterfly_read_byte_flash (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	butterfly_read_byte_eeprom (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	butterfly_page_erase (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int addr)
static int	butterfly_read_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned long addr, unsigned char *value)
static int	butterfly_paged_write (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	butterfly_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int addr, unsigned int n_bytes)
static int	butterfly_read_sig_bytes (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m)
void	butterfly_initpgm (PROGRAMMER *pgm)
void	butterfly_mk_initpgm (PROGRAMMER *pgm)

Variables
const char	butterfly_desc [] = "Atmel Butterfly evaluation board; Atmel AppNotes AVR109, AVR911"
const char	butterfly_mk_desc [] = "Mikrokopter.de Butterfly"

Macro Definition Documentation

IS_BUTTERFLY_MK

#define IS_BUTTERFLY_MK   0x0001

PDATA

#define PDATA

(

pgm

)

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

Function Documentation

butterfly_chip_erase()

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

static

{
  butterfly_send(pgm, "e", 1);
  if (butterfly_vfy_cmd_sent(pgm, "chip erase") < 0)
      return -1;
 
  return 0;
}

References butterfly_send(), butterfly_vfy_cmd_sent(), and pgm.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_close()

static void butterfly_close ( PROGRAMMER *  pgm )

static

{
  /* "exit programmer" */
  butterfly_send(pgm, "E", 1);
  butterfly_vfy_cmd_sent(pgm, "exit bootloader");
 
  serial_close(&pgm->fd);
  pgm->fd.ifd = -1;
}

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

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_disable()

static void butterfly_disable ( PROGRAMMER *  pgm )

static

{
  butterfly_leave_prog_mode(pgm);
 
  return;
}

References butterfly_leave_prog_mode(), and pgm.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_display()

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

static

{
  return;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_drain()

static int butterfly_drain ( PROGRAMMER *  pgm, int  display  )

static

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

References programmer_t::fd, pgm, and serial_drain.

Referenced by butterfly_initialize(), and butterfly_open().

Here is the caller graph for this function:

butterfly_enable()

static void butterfly_enable ( PROGRAMMER *  pgm )

static

{
  return;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_enter_prog_mode()

static void butterfly_enter_prog_mode ( PROGRAMMER *  pgm )

static

{
  butterfly_send(pgm, "P", 1);
  butterfly_vfy_cmd_sent(pgm, "enter prog mode");
}

References butterfly_send(), butterfly_vfy_cmd_sent(), and pgm.

Referenced by butterfly_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_err_led()

static int butterfly_err_led ( PROGRAMMER *  pgm, int  value  )

static

{
  /* Do nothing. */
 
  return 0;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_initialize()

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

static

{
  char id[8];
  char sw[2];
  char hw[2];
  char buf[10];
  char type;
  char c, devtype_1st;
 
  /*
   * Send some ESC to activate butterfly bootloader.  This is not needed
   * for plain avr109 bootloaders but does not harm there either.
   */
  avrdude_message(MSG_INFO, "Connecting to programmer: ");
  if (pgm->flag & IS_BUTTERFLY_MK)
    {
      char mk_reset_cmd[6] = {"#aR@S\r"};
      unsigned char mk_timeout = 0;
 
      putc('.', stderr);
      butterfly_send(pgm, mk_reset_cmd, sizeof(mk_reset_cmd));
      usleep(20000); 
 
      do
  {
    c = 27; 
    butterfly_send(pgm, &c, 1);
    usleep(20000);
    c = 0xaa;
    usleep(80000);
    butterfly_send(pgm, &c, 1);
    if (mk_timeout % 10 == 0) putc('.', stderr);
  } while (mk_timeout++ < 10);
 
      butterfly_recv(pgm, &c, 1);
      if ( c != 'M' && c != '?')
        {
          avrdude_message(MSG_INFO, "\nConnection FAILED.");
          return -1;
        }
      else
        {
    id[0] = 'M'; id[1] = 'K'; id[2] = '2'; id[3] = 0;
  }
    }
  else
    {
      do {
  putc('.', stderr);
  butterfly_send(pgm, "\033", 1);
  butterfly_drain(pgm, 0);
  butterfly_send(pgm, "S", 1);
  butterfly_recv(pgm, &c, 1);
  if (c != '?') {
      putc('\n', stderr);
      /*
       * Got a useful response, continue getting the programmer
       * identifier. Programmer returns exactly 7 chars _without_
       * the null.
       */
    id[0] = c;
    butterfly_recv(pgm, &id[1], sizeof(id)-2);
    id[sizeof(id)-1] = '\0';
  }
      } while (c == '?');
    }
 
  /* Get the HW and SW versions to see if the programmer is present. */
  butterfly_drain(pgm, 0);
 
  butterfly_send(pgm, "V", 1);
  butterfly_recv(pgm, sw, sizeof(sw));
 
  butterfly_send(pgm, "v", 1);
  butterfly_recv(pgm, hw, 1); /* first, read only _one_ byte */
  if (hw[0]!='?') {
    butterfly_recv(pgm, &hw[1], 1);/* now, read second byte */
  };
 
  /* Get the programmer type (serial or parallel). Expect serial. */
 
  butterfly_send(pgm, "p", 1);
  butterfly_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]);
  if (hw[0]=='?') {
    avrdude_message(MSG_INFO, "No Hardware Version given.\n");
  } else {
    avrdude_message(MSG_INFO, "Hardware Version = %c.%c\n", hw[0], hw[1]);
  };
 
  /* See if programmer supports autoincrement of address. */
 
  butterfly_send(pgm, "a", 1);
  butterfly_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, abort if not available */
 
  butterfly_send(pgm, "b", 1);
  butterfly_recv(pgm, &c, 1);
  if (c != 'Y') {
    avrdude_message(MSG_INFO, "%s: error: buffered memory access not supported. Maybe it isn't\n"\
                    "a butterfly/AVR109 but a AVR910 device?\n", progname);
    return -1;
  };
  butterfly_recv(pgm, &c, 1);
  PDATA(pgm)->buffersize = (unsigned int)(unsigned char)c<<8;
  butterfly_recv(pgm, &c, 1);
  PDATA(pgm)->buffersize += (unsigned int)(unsigned char)c;
  avrdude_message(MSG_INFO, "Programmer supports buffered memory access with buffersize=%i bytes.\n",
                  PDATA(pgm)->buffersize);
 
  /* Get list of devices that the programmer supports. */
 
  butterfly_send(pgm, "t", 1);
  avrdude_message(MSG_INFO, "\nProgrammer supports the following devices:\n");
  devtype_1st = 0;
  while (1) {
    butterfly_recv(pgm, &c, 1);
    if (devtype_1st == 0)
      devtype_1st = c;
 
    if (c == 0)
      break;
    avrdude_message(MSG_INFO, "    Device code: 0x%02x\n", (unsigned int)(unsigned char)c);
  };
  avrdude_message(MSG_INFO, "\n");
 
  /* Tell the programmer which part we selected.
     According to the AVR109 code, this is ignored by the bootloader.  As
     some early versions might not properly ignore it, rather pick up the
     first device type as reported above than anything out of avrdude.conf,
     so to avoid a potential conflict.  There appears to be no general
     agreement on AVR910 device IDs beyond the ones from the original
     appnote 910. */
 
  buf[0] = 'T';
  buf[1] = devtype_1st;
 
  butterfly_send(pgm, buf, 2);
  if (butterfly_vfy_cmd_sent(pgm, "select device") < 0)
      return -1;
 
  if (verbose)
    avrdude_message(MSG_INFO, "%s: devcode selected: 0x%02x\n",
                    progname, (unsigned)buf[1]);
 
  butterfly_enter_prog_mode(pgm);
  butterfly_drain(pgm, 0);
 
  return 0;
}

References avrdude_message(), butterfly_drain(), butterfly_enter_prog_mode(), butterfly_recv(), butterfly_send(), butterfly_vfy_cmd_sent(), programmer_t::flag, IS_BUTTERFLY_MK, MSG_INFO, PDATA, pgm, progname, usleep(), and verbose.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_initpgm()

void butterfly_initpgm

(

PROGRAMMER *

pgm

)

{
  strcpy(pgm->type, "butterfly");
 
  /*
   * mandatory functions
   */
  pgm->rdy_led        = butterfly_rdy_led;
  pgm->err_led        = butterfly_err_led;
  pgm->pgm_led        = butterfly_pgm_led;
  pgm->vfy_led        = butterfly_vfy_led;
  pgm->initialize     = butterfly_initialize;
  pgm->display        = butterfly_display;
  pgm->enable         = butterfly_enable;
  pgm->disable        = butterfly_disable;
  pgm->powerup        = butterfly_powerup;
  pgm->powerdown      = butterfly_powerdown;
  pgm->program_enable = butterfly_program_enable;
  pgm->chip_erase     = butterfly_chip_erase;
  pgm->open           = butterfly_open;
  pgm->close          = butterfly_close;
  pgm->read_byte      = butterfly_read_byte;
  pgm->write_byte     = butterfly_write_byte;
 
  /*
   * optional functions
   */
 
  pgm->page_erase = butterfly_page_erase;
  pgm->paged_write = butterfly_paged_write;
  pgm->paged_load = butterfly_paged_load;
 
  pgm->read_sig_bytes = butterfly_read_sig_bytes;
 
  pgm->setup          = butterfly_setup;
  pgm->teardown       = butterfly_teardown;
  pgm->flag = 0;
}

References butterfly_chip_erase(), butterfly_close(), butterfly_disable(), butterfly_display(), butterfly_enable(), butterfly_err_led(), butterfly_initialize(), butterfly_open(), butterfly_page_erase(), butterfly_paged_load(), butterfly_paged_write(), butterfly_pgm_led(), butterfly_powerdown(), butterfly_powerup(), butterfly_program_enable(), butterfly_rdy_led(), butterfly_read_byte(), butterfly_read_sig_bytes(), butterfly_setup(), butterfly_teardown(), butterfly_vfy_led(), butterfly_write_byte(), programmer_t::chip_erase, programmer_t::close, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::err_led, programmer_t::flag, programmer_t::initialize, programmer_t::open, programmer_t::page_erase, programmer_t::paged_load, programmer_t::paged_write, pgm, programmer_t::pgm_led, programmer_t::powerdown, programmer_t::powerup, programmer_t::program_enable, programmer_t::rdy_led, programmer_t::read_byte, programmer_t::read_sig_bytes, programmer_t::setup, programmer_t::teardown, programmer_t::type, programmer_t::vfy_led, and programmer_t::write_byte.

Referenced by butterfly_mk_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_leave_prog_mode()

static void butterfly_leave_prog_mode ( PROGRAMMER *  pgm )

static

{
  butterfly_send(pgm, "L", 1);
  butterfly_vfy_cmd_sent(pgm, "leave prog mode");
}

References butterfly_send(), butterfly_vfy_cmd_sent(), and pgm.

Referenced by butterfly_disable().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_mk_initpgm()

void butterfly_mk_initpgm

(

PROGRAMMER *

pgm

)

{
  butterfly_initpgm(pgm);
  strcpy(pgm->type, "butterfly_mk");
  pgm->flag = IS_BUTTERFLY_MK;
}

References butterfly_initpgm(), programmer_t::flag, IS_BUTTERFLY_MK, pgm, and programmer_t::type.

Here is the call graph for this function:

butterfly_open()

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

static

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

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

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_page_erase()

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

static

{
  if (strcmp(m->desc, "flash") == 0)
    return -1;            /* not supported */
  if (strcmp(m->desc, "eeprom") == 0)
    return 0;             /* nothing to do */
  avrdude_message(MSG_INFO, "%s: butterfly_page_erase() called on memory type \"%s\"\n",
                  progname, m->desc);
  return -1;
}

References avrdude_message(), avrmem::desc, MSG_INFO, and progname.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_paged_load()

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

static

{
  unsigned int max_addr = addr + n_bytes;
  int rd_size = 2;
  int blocksize = PDATA(pgm)->buffersize;
  int use_ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
 
  /* check parameter syntax: only "flash" or "eeprom" is allowed */
  if (strcmp(m->desc, "flash") && strcmp(m->desc, "eeprom"))
    return -2;
 
  if (m->desc[0] == 'e')
    rd_size = blocksize = 1;    /* Read from eeprom single bytes only */
 
  {   /* use buffered mode */
    char cmd[4];
 
    cmd[0] = 'g';
    cmd[3] = toupper((int)(m->desc[0]));
 
    if (use_ext_addr) {
      butterfly_set_extaddr(pgm, addr / rd_size);
    } else {
      butterfly_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;
 
      butterfly_send(pgm, cmd, 4);
      butterfly_recv(pgm, (char *)&m->buf[addr], blocksize);
 
      addr += blocksize;
    } /* while */
  }
 
  return addr * rd_size;
}

References AVR_OP_LOAD_EXT_ADDR, avrmem::buf, butterfly_recv(), butterfly_send(), butterfly_set_addr(), butterfly_set_extaddr(), cmd, avrmem::desc, avrmem::op, PDATA, and pgm.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_paged_write()

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

static

{
  unsigned int max_addr = addr + n_bytes;
  char *cmd;
  unsigned int blocksize = PDATA(pgm)->buffersize;
  int use_ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
  unsigned int wr_size = 2;
 
  if (strcmp(m->desc, "flash") && strcmp(m->desc, "eeprom"))
    return -2;
 
  if (m->desc[0] == 'e')
    wr_size = blocksize = 1;    /* Write to eeprom single bytes only */
 
  if (use_ext_addr) {
    butterfly_set_extaddr(pgm, addr / wr_size);
  } else {
    butterfly_set_addr(pgm, addr / wr_size);
  }
 
#if 0
  usleep(1000000);
  butterfly_send(pgm, "y", 1);
  if (butterfly_vfy_cmd_sent(pgm, "clear LED") < 0)
    return -1;
#endif
 
  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;
 
    butterfly_send(pgm, cmd, 4+blocksize);
    if (butterfly_vfy_cmd_sent(pgm, "write block") < 0)
      return -1;
 
    addr += blocksize;
  } /* while */
  free(cmd);
 
  return addr;
}

References AVR_OP_LOAD_EXT_ADDR, avrmem::buf, butterfly_send(), butterfly_set_addr(), butterfly_set_extaddr(), butterfly_vfy_cmd_sent(), cmd, avrmem::desc, free(), malloc(), avrmem::op, PDATA, pgm, and usleep().

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_pgm_led()

static int butterfly_pgm_led ( PROGRAMMER *  pgm, int  value  )

static

{
  /* Do nothing. */
 
  return 0;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_powerdown()

static void butterfly_powerdown ( PROGRAMMER *  pgm )

static

{
  /* Do nothing. */
 
  return;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_powerup()

static void butterfly_powerup ( PROGRAMMER *  pgm )

static

{
  /* Do nothing. */
 
  return;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_program_enable()

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

static

{
  return -1;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_rdy_led()

static int butterfly_rdy_led ( PROGRAMMER *  pgm, int  value  )

static

{
  /* Do nothing. */
 
  return 0;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_read_byte()

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

static

{
  char cmd;
 
  if (strcmp(m->desc, "flash") == 0) {
    return butterfly_read_byte_flash(pgm, p, m, addr, value);
  }
 
  if (strcmp(m->desc, "eeprom") == 0) {
    return butterfly_read_byte_eeprom(pgm, p, m, addr, value);
  }
 
  if (strcmp(m->desc, "lfuse") == 0) {
    cmd = 'F';
  }
  else if (strcmp(m->desc, "hfuse") == 0) {
    cmd = 'N';
  }
  else if (strcmp(m->desc, "efuse") == 0) {
    cmd = 'Q';
  }
  else if (strcmp(m->desc, "lock") == 0) {
    cmd = 'r';
  }
  else
    return -1;
 
  butterfly_send(pgm, &cmd, 1);
  butterfly_recv(pgm, (char *)value, 1);
 
  return *value == '?'? -1: 0;
}

References butterfly_read_byte_eeprom(), butterfly_read_byte_flash(), butterfly_recv(), butterfly_send(), cmd, avrmem::desc, and pgm.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_read_byte_eeprom()

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

static

{
  butterfly_set_addr(pgm, addr);
  butterfly_send(pgm, "g\000\001E", 4);
  butterfly_recv(pgm, (char *)value, 1);
  return 0;
}

References butterfly_recv(), butterfly_send(), butterfly_set_addr(), and pgm.

Referenced by butterfly_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_read_byte_flash()

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

static

{
  static int cached = 0;
  static unsigned char cvalue;
  static unsigned long caddr;
  int use_ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
 
  if (cached && ((caddr + 1) == addr)) {
    *value = cvalue;
    cached = 0;
  }
  else {
    char buf[2];
 
    if (use_ext_addr) {
      butterfly_set_extaddr(pgm, addr >> 1);
    } else {
      butterfly_set_addr(pgm, addr >> 1);
    }
 
    butterfly_send(pgm, "g\000\002F", 4);
 
    /* Read back the program mem word (MSB first) */
    butterfly_recv(pgm, buf, sizeof(buf));
 
    if ((addr & 0x01) == 0) {
      *value = buf[0];
      cached = 1;
      cvalue = buf[1];
      caddr = addr;
    }
    else {
      *value = buf[1];
    }
  }
 
  return 0;
}

References AVR_OP_LOAD_EXT_ADDR, butterfly_recv(), butterfly_send(), butterfly_set_addr(), butterfly_set_extaddr(), avrmem::op, and pgm.

Referenced by butterfly_read_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_read_sig_bytes()

static int butterfly_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;
  }
 
  butterfly_send(pgm, "s", 1);
  butterfly_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 avrdude_message(), avrmem::buf, butterfly_recv(), butterfly_send(), MSG_INFO, pgm, progname, and avrmem::size.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_recv()

static int butterfly_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: butterfly_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 butterfly_initialize(), butterfly_paged_load(), butterfly_read_byte(), butterfly_read_byte_eeprom(), butterfly_read_byte_flash(), butterfly_read_sig_bytes(), and butterfly_vfy_cmd_sent().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_send()

static int butterfly_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 butterfly_chip_erase(), butterfly_close(), butterfly_enter_prog_mode(), butterfly_initialize(), butterfly_leave_prog_mode(), butterfly_paged_load(), butterfly_paged_write(), butterfly_read_byte(), butterfly_read_byte_eeprom(), butterfly_read_byte_flash(), butterfly_read_sig_bytes(), butterfly_set_addr(), butterfly_set_extaddr(), and butterfly_write_byte().

Here is the caller graph for this function:

butterfly_set_addr()

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

static

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

References butterfly_send(), butterfly_vfy_cmd_sent(), cmd, and pgm.

Referenced by butterfly_paged_load(), butterfly_paged_write(), butterfly_read_byte_eeprom(), butterfly_read_byte_flash(), and butterfly_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_set_extaddr()

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

static

{
  char cmd[4];
 
  cmd[0] = 'H';
  cmd[1] = (addr >> 16) & 0xff;
  cmd[2] = (addr >> 8) & 0xff;
  cmd[3] = addr & 0xff;
 
  butterfly_send(pgm, cmd, sizeof(cmd));
  butterfly_vfy_cmd_sent(pgm, "set extaddr");
}

References butterfly_send(), butterfly_vfy_cmd_sent(), cmd, and pgm.

Referenced by butterfly_paged_load(), butterfly_paged_write(), butterfly_read_byte_flash(), and butterfly_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_setup()

static void butterfly_setup ( PROGRAMMER *  pgm )

static

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

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

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_teardown()

static void butterfly_teardown ( PROGRAMMER *  pgm )

static

{
  free(pgm->cookie);
}

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

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_vfy_cmd_sent()

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

static

{
  char c;
 
  butterfly_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 avrdude_message(), butterfly_recv(), MSG_INFO, pgm, and progname.

Referenced by butterfly_chip_erase(), butterfly_close(), butterfly_enter_prog_mode(), butterfly_initialize(), butterfly_leave_prog_mode(), butterfly_paged_write(), butterfly_set_addr(), butterfly_set_extaddr(), and butterfly_write_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

butterfly_vfy_led()

static int butterfly_vfy_led ( PROGRAMMER *  pgm, int  value  )

static

{
  /* Do nothing. */
 
  return 0;
}

Referenced by butterfly_initpgm().

Here is the caller graph for this function:

butterfly_write_byte()

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

static

{
  char cmd[6];
  int size;
  int use_ext_addr = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
 
  if ((strcmp(m->desc, "flash") == 0) || (strcmp(m->desc, "eeprom") == 0))
  {
    cmd[0] = 'B';
    cmd[1] = 0;
    if ((cmd[3] = toupper((int)(m->desc[0]))) == 'E') { /* write to eeprom */
      cmd[2] = 1;
      cmd[4] = value;
      size = 5;
    } else {            /* write to flash */
      /* @@@ not yet implemented */
      cmd[2] = 2;
      size = 6;
      return -1;
    }
    if (use_ext_addr) {
      butterfly_set_extaddr(pgm, addr);
    } else {
      butterfly_set_addr(pgm, addr);
    }
  }
  else if (strcmp(m->desc, "lock") == 0)
  {
    cmd[0] = 'l';
    cmd[1] = value;
    size = 2;
  }
  else
    return -1;
 
  butterfly_send(pgm, cmd, size);
  if (butterfly_vfy_cmd_sent(pgm, "write byte") < 0)
      return -1;
 
  return 0;
}

References AVR_OP_LOAD_EXT_ADDR, butterfly_send(), butterfly_set_addr(), butterfly_set_extaddr(), butterfly_vfy_cmd_sent(), cmd, avrmem::desc, avrmem::op, and pgm.

Referenced by butterfly_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

butterfly_desc

const char butterfly_desc[] = "Atmel Butterfly evaluation board; Atmel AppNotes AVR109, AVR911"

butterfly_mk_desc

const char butterfly_mk_desc[] = "Mikrokopter.de Butterfly"