buspirate.c File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "bitbang.h"
#include "buspirate.h"

Include dependency graph for buspirate.c:

Go to the source code of this file.

Classes
struct	pdata

Macros
#define	BP_RESET_CS   0x01
#define	BP_RESET_AUX   0x02
#define	BP_RESET_AUX2   0x04
#define	BP_FLAG_IN_BINMODE   (1<<0)
#define	BP_FLAG_XPARM_FORCE_ASCII   (1<<1)
#define	BP_FLAG_XPARM_RESET   (1<<2)
#define	BP_FLAG_XPARM_SPIFREQ   (1<<3)
#define	BP_FLAG_NOPAGEDWRITE   (1<<4)
#define	BP_FLAG_XPARM_CPUFREQ   (1<<5)
#define	BP_FLAG_XPARM_RAWFREQ   (1<<6)
#define	BP_FLAG_NOPAGEDREAD   (1<<7)
#define	PDATA(pgm)   ((struct pdata *)(pgm->cookie))

Functions
static int	buspirate_uses_ascii (struct programmer_t *pgm)
static void	dump_mem (const int msglvl, const unsigned char *buf, size_t len)
static int	buspirate_send_bin (struct programmer_t *pgm, const unsigned char *data, size_t len)
static int	buspirate_recv_bin (struct programmer_t *pgm, unsigned char *buf, size_t len)
static int	buspirate_expect_bin (struct programmer_t *pgm, unsigned char *send_data, size_t send_len, unsigned char *expect_data, size_t expect_len)
static int	buspirate_expect_bin_byte (struct programmer_t *pgm, unsigned char send_byte, unsigned char expect_byte)
static int	buspirate_getc (struct programmer_t *pgm)
static char *	buspirate_readline_noexit (struct programmer_t *pgm, char *buf, size_t len)
static char *	buspirate_readline (struct programmer_t *pgm, char *buf, size_t len)
static int	buspirate_send (struct programmer_t *pgm, const char *str)
static int	buspirate_is_prompt (const char *str)
static int	buspirate_expect (struct programmer_t *pgm, char *send, char *expect, int wait_for_prompt)
static void	buspirate_dummy_6 (struct programmer_t *pgm, const char *p)
static int	buspirate_parseextparms (struct programmer_t *pgm, LISTID extparms)
static int	buspirate_verifyconfig (struct programmer_t *pgm)
static int	buspirate_open (struct programmer_t *pgm, char *port)
static void	buspirate_close (struct programmer_t *pgm)
static void	buspirate_reset_from_binmode (struct programmer_t *pgm)
static int	buspirate_start_mode_bin (struct programmer_t *pgm)
static int	buspirate_start_spi_mode_ascii (struct programmer_t *pgm)
static void	buspirate_enable (struct programmer_t *pgm)
static void	buspirate_disable (struct programmer_t *pgm)
static int	buspirate_initialize (struct programmer_t *pgm, AVRPART *p)
static void	buspirate_powerup (struct programmer_t *pgm)
static void	buspirate_powerdown (struct programmer_t *pgm)
static int	buspirate_cmd_bin (struct programmer_t *pgm, const unsigned char *cmd, unsigned char *res)
static int	buspirate_cmd_ascii (struct programmer_t *pgm, const unsigned char *cmd, unsigned char *res)
static int	buspirate_cmd (struct programmer_t *pgm, const unsigned char *cmd, unsigned char *res)
static int	buspirate_paged_load (PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int address, unsigned int n_bytes)
static int	buspirate_paged_write (struct programmer_t *pgm, AVRPART *p, AVRMEM *m, unsigned int page_size, unsigned int base_addr, unsigned int n_data_bytes)
static int	buspirate_program_enable (struct programmer_t *pgm, AVRPART *p)
static int	buspirate_chip_erase (struct programmer_t *pgm, AVRPART *p)
static void	buspirate_setup (struct programmer_t *pgm)
static void	buspirate_teardown (struct programmer_t *pgm)
void	buspirate_initpgm (struct programmer_t *pgm)
static void	buspirate_bb_enable (struct programmer_t *pgm)
static int	buspirate_bb_getpin (struct programmer_t *pgm, int pinfunc)
static int	buspirate_bb_setpin_internal (struct programmer_t *pgm, int pin, int value)
static int	buspirate_bb_setpin (struct programmer_t *pgm, int pinfunc, int value)
static int	buspirate_bb_highpulsepin (struct programmer_t *pgm, int pinfunc)
static void	buspirate_bb_powerup (struct programmer_t *pgm)
static void	buspirate_bb_powerdown (struct programmer_t *pgm)
void	buspirate_bb_initpgm (struct programmer_t *pgm)

Variables
const char	buspirate_desc [] = "Using the Bus Pirate's SPI interface for programming"
const char	buspirate_bb_desc [] = "Using the Bus Pirate's bitbang interface for programming"

Macro Definition Documentation

BP_FLAG_IN_BINMODE

#define BP_FLAG_IN_BINMODE   (1<<0)

BP_FLAG_NOPAGEDREAD

#define BP_FLAG_NOPAGEDREAD   (1<<7)

BP_FLAG_NOPAGEDWRITE

#define BP_FLAG_NOPAGEDWRITE   (1<<4)

BP_FLAG_XPARM_CPUFREQ

#define BP_FLAG_XPARM_CPUFREQ   (1<<5)

BP_FLAG_XPARM_FORCE_ASCII

#define BP_FLAG_XPARM_FORCE_ASCII   (1<<1)

BP_FLAG_XPARM_RAWFREQ

#define BP_FLAG_XPARM_RAWFREQ   (1<<6)

BP_FLAG_XPARM_RESET

#define BP_FLAG_XPARM_RESET   (1<<2)

BP_FLAG_XPARM_SPIFREQ

#define BP_FLAG_XPARM_SPIFREQ   (1<<3)

BP_RESET_AUX

#define BP_RESET_AUX   0x02

BP_RESET_AUX2

#define BP_RESET_AUX2   0x04

BP_RESET_CS

#define BP_RESET_CS   0x01

PDATA

#define PDATA

(

pgm

)

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

Function Documentation

buspirate_bb_enable()

static void buspirate_bb_enable ( struct programmer_t *  pgm )

static

{
  unsigned char buf[20] = { '\0' };
 
  if (bitbang_check_prerequisites(pgm) < 0)
    return;             /* XXX should treat as error */
 
  avrdude_message(MSG_INFO, "Attempting to initiate BusPirate bitbang binary mode...\n");
 
  /* Send two CRs to ensure we're not in a sub-menu of the UI if we're in ASCII mode: */
  buspirate_send_bin(pgm, (const unsigned char*)"\n\n", 2);
 
  /* Clear input buffer: */
  serial_drain(&pgm->fd, 0);
 
  /* == Switch to binmode - send 20x '\0' == */
  buspirate_send_bin(pgm, buf, sizeof(buf));
 
  /* Expecting 'BBIOx' reply */
  memset(buf, 0, sizeof(buf));
  buspirate_recv_bin(pgm, buf, 5);
  if (sscanf((char*)buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
    avrdude_message(MSG_INFO, "Binary mode not confirmed: '%s'\n", buf);
    buspirate_reset_from_binmode(pgm);
    return;
  }
  avrdude_message(MSG_INFO, "BusPirate binmode version: %d\n",
                  PDATA(pgm)->binmode_version);
 
  pgm->flag |= BP_FLAG_IN_BINMODE;
 
  /* Set pin directions and an initial pin status (all high) */
  PDATA(pgm)->pin_dir = 0x12;  /* AUX, MISO input; everything else output */
  buf[0] = PDATA(pgm)->pin_dir | 0x40;
  buspirate_send_bin(pgm, buf, 1);
  buspirate_recv_bin(pgm, buf, 1);
 
  PDATA(pgm)->pin_val = 0x3f; /* PULLUP, AUX, MOSI, CLK, MISO, CS high */
  buf[0] = PDATA(pgm)->pin_val | 0x80;
  buspirate_send_bin(pgm, buf, 1);
  buspirate_recv_bin(pgm, buf, 1);
 
  /* Done */
  return;
}

References avrdude_message(), bitbang_check_prerequisites(), BP_FLAG_IN_BINMODE, buspirate_recv_bin(), buspirate_reset_from_binmode(), buspirate_send_bin(), programmer_t::fd, programmer_t::flag, MSG_INFO, PDATA, pgm, and serial_drain.

Referenced by buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_getpin()

static int buspirate_bb_getpin ( struct programmer_t *  pgm, int  pinfunc  )

static

{
  unsigned char buf[10];
  int value = 0;
  int pin = pgm->pinno[pinfunc];
 
  if (pin & PIN_INVERSE) {
    pin &= PIN_MASK;
    value = 1;
  }
 
  if (pin < 1 || pin > 5)
    return -1;
 
  buf[0] = PDATA(pgm)->pin_dir | 0x40;
  if (buspirate_send_bin(pgm, buf, 1) < 0)
    return -1;
  /* Read all of the previously-expected-but-unread bytes */
  while (PDATA(pgm)->unread_bytes > 0) {
    if (buspirate_recv_bin(pgm, buf, 1) < 0)
      return -1;
    PDATA(pgm)->unread_bytes--;
  }
 
  /* Now read the actual response */
  if (buspirate_recv_bin(pgm, buf, 1) < 0)
    return -1;
 
  if (buf[0] & (1 << (pin - 1)))
    value ^= 1;
 
  avrdude_message(MSG_DEBUG, "get pin %d = %d\n", pin, value);
 
  return value;
}

References avrdude_message(), buspirate_recv_bin(), buspirate_send_bin(), MSG_DEBUG, PDATA, pgm, PIN_INVERSE, PIN_MASK, and programmer_t::pinno.

Referenced by buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_highpulsepin()

static int buspirate_bb_highpulsepin ( struct programmer_t *  pgm, int  pinfunc  )

static

{
  int ret;
  ret = buspirate_bb_setpin(pgm, pinfunc, 1);
  if (ret < 0)
    return ret;
  return buspirate_bb_setpin(pgm, pinfunc, 0);
}

References buspirate_bb_setpin(), and pgm.

Referenced by buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_initpgm()

void buspirate_bb_initpgm

(

struct programmer_t *

pgm

)

{
  strcpy(pgm->type, "BusPirate_BB");
 
  pgm_fill_old_pins(pgm); // TODO to be removed if old pin data no longer needed
 
  pgm->display        = buspirate_dummy_6;
 
  /* BusPirate itself related methods */
  pgm->setup          = buspirate_setup;
  pgm->teardown       = buspirate_teardown;
  pgm->open           = buspirate_open;
  pgm->close          = buspirate_close;
  pgm->enable         = buspirate_bb_enable;
  pgm->disable        = buspirate_disable;
 
  /* Chip related methods */
  pgm->initialize     = bitbang_initialize;
  pgm->rdy_led        = bitbang_rdy_led;
  pgm->err_led        = bitbang_err_led;
  pgm->pgm_led        = bitbang_pgm_led;
  pgm->vfy_led        = bitbang_vfy_led;
  pgm->program_enable = bitbang_program_enable;
  pgm->chip_erase     = bitbang_chip_erase;
  pgm->cmd            = bitbang_cmd;
  pgm->cmd_tpi        = bitbang_cmd_tpi;
  pgm->powerup        = buspirate_bb_powerup;
  pgm->powerdown      = buspirate_bb_powerdown;
  pgm->setpin         = buspirate_bb_setpin;
  pgm->getpin         = buspirate_bb_getpin;
  pgm->highpulsepin   = buspirate_bb_highpulsepin;
  pgm->read_byte      = avr_read_byte_default;
  pgm->write_byte     = avr_write_byte_default;
}

References avr_read_byte_default(), avr_write_byte_default(), bitbang_chip_erase(), bitbang_cmd(), bitbang_cmd_tpi(), bitbang_err_led(), bitbang_initialize(), bitbang_pgm_led(), bitbang_program_enable(), bitbang_rdy_led(), bitbang_vfy_led(), buspirate_bb_enable(), buspirate_bb_getpin(), buspirate_bb_highpulsepin(), buspirate_bb_powerdown(), buspirate_bb_powerup(), buspirate_bb_setpin(), buspirate_close(), buspirate_disable(), buspirate_dummy_6(), buspirate_open(), buspirate_setup(), buspirate_teardown(), programmer_t::chip_erase, programmer_t::close, programmer_t::cmd, programmer_t::cmd_tpi, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::err_led, programmer_t::getpin, programmer_t::highpulsepin, programmer_t::initialize, programmer_t::open, pgm, pgm_fill_old_pins(), programmer_t::pgm_led, programmer_t::powerdown, programmer_t::powerup, programmer_t::program_enable, programmer_t::rdy_led, programmer_t::read_byte, programmer_t::setpin, programmer_t::setup, programmer_t::teardown, programmer_t::type, programmer_t::vfy_led, and programmer_t::write_byte.

Here is the call graph for this function:

buspirate_bb_powerdown()

static void buspirate_bb_powerdown ( struct programmer_t *  pgm )

static

{
  buspirate_bb_setpin_internal(pgm, 7, 0);
}

References buspirate_bb_setpin_internal(), and pgm.

Referenced by buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_powerup()

static void buspirate_bb_powerup ( struct programmer_t *  pgm )

static

{
  buspirate_bb_setpin_internal(pgm, 7, 1);
}

References buspirate_bb_setpin_internal(), and pgm.

Referenced by buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_setpin()

static int buspirate_bb_setpin ( struct programmer_t *  pgm, int  pinfunc, int  value  )

static

{
  return buspirate_bb_setpin_internal(pgm, pgm->pinno[pinfunc], value);
}

References buspirate_bb_setpin_internal(), pgm, and programmer_t::pinno.

Referenced by buspirate_bb_highpulsepin(), and buspirate_bb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_bb_setpin_internal()

static int buspirate_bb_setpin_internal ( struct programmer_t *  pgm, int  pin, int  value  )

static

{
  unsigned char buf[10];
 
  if (pin & PIN_INVERSE) {
    value = !value;
    pin &= PIN_MASK;
  }
 
  if ((pin < 1 || pin > 5) && (pin != 7)) // 7 is POWER
    return -1;
 
  avrdude_message(MSG_DEBUG, "set pin %d = %d\n", pin, value);
 
  if (value)
    PDATA(pgm)->pin_val |= (1 << (pin - 1));
  else 
    PDATA(pgm)->pin_val &= ~(1 << (pin - 1));
 
  buf[0] = PDATA(pgm)->pin_val | 0x80;
  if (buspirate_send_bin(pgm, buf, 1) < 0)
    return -1;
  /* We'll get a byte back, but we don't need to read it now.
     This is just a quick optimization that saves some USB
     round trips, improving read times by a factor of 3. */
  PDATA(pgm)->unread_bytes++;
 
  return 0;
}

References avrdude_message(), buspirate_send_bin(), MSG_DEBUG, PDATA, pgm, PIN_INVERSE, and PIN_MASK.

Referenced by buspirate_bb_powerdown(), buspirate_bb_powerup(), and buspirate_bb_setpin().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_chip_erase()

static int buspirate_chip_erase ( struct programmer_t *  pgm, AVRPART *  p  )

static

{
  unsigned char cmd[4];
  unsigned char res[4];
 
  if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
    avrdude_message(MSG_INFO, "chip erase instruction not defined for part \"%s\"\n",
                    p->desc);
    return -1;
  }
 
  pgm->pgm_led(pgm, ON);
 
  memset(cmd, 0, sizeof(cmd));
 
  avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
  pgm->cmd(pgm, cmd, res);
  usleep(p->chip_erase_delay);
  pgm->initialize(pgm, p);
 
  pgm->pgm_led(pgm, OFF);
 
  return 0;
}

References AVR_OP_CHIP_ERASE, avr_set_bits(), avrdude_message(), avrpart::chip_erase_delay, programmer_t::cmd, cmd, avrpart::desc, programmer_t::initialize, MSG_INFO, OFF, ON, avrpart::op, pgm, programmer_t::pgm_led, and usleep().

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_close()

static void buspirate_close ( struct programmer_t *  pgm )

static

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

References programmer_t::fd, filedescriptor::ifd, pgm, and serial_close.

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the caller graph for this function:

buspirate_cmd()

static int buspirate_cmd ( struct programmer_t *  pgm, const unsigned char *  cmd, unsigned char *  res  )

static

{
  if (pgm->flag & BP_FLAG_IN_BINMODE)
    return buspirate_cmd_bin(pgm, cmd, res);
  else
    return buspirate_cmd_ascii(pgm, cmd, res);
}

References BP_FLAG_IN_BINMODE, buspirate_cmd_ascii(), buspirate_cmd_bin(), cmd, programmer_t::flag, and pgm.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_cmd_ascii()

static int buspirate_cmd_ascii ( struct programmer_t *  pgm, const unsigned char *  cmd, unsigned char *  res  )

static

{
  char buf[25];
  char *rcvd;
  int spi_write, spi_read, i = 0;
 
  snprintf(buf, sizeof(buf), "0x%02x 0x%02x 0x%02x 0x%02x\n",
    cmd[0], cmd[1], cmd[2], cmd[3]);
  buspirate_send(pgm, buf);
  while (i < 4) {
    rcvd = buspirate_readline(pgm, NULL, 0);
    if (rcvd == NULL) {
      return -1;
    }
    /* WRITE: 0xAC READ: 0x04 */
    if (sscanf(rcvd, "WRITE: 0x%2x READ: 0x%2x", &spi_write, &spi_read) == 2) {
      res[i++] = spi_read;
    }
    if (buspirate_is_prompt(rcvd))
      break;
  }
 
  if (i != 4) {
    avrdude_message(MSG_INFO, "%s: error: SPI has not read 4 bytes back\n", progname);
    return -1;
  }
 
  /* wait for prompt */
  while (buspirate_getc(pgm) != '>')
    /* do nothing */;
 
  return 0;
}

References avrdude_message(), buspirate_getc(), buspirate_is_prompt(), buspirate_readline(), buspirate_send(), cmd, MSG_INFO, pgm, progname, and snprintf.

Referenced by buspirate_cmd().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_cmd_bin()

static int buspirate_cmd_bin ( struct programmer_t *  pgm, const unsigned char *  cmd, unsigned char *  res  )

static

{
  /* 0001xxxx - Bulk transfer, send/read 1-16 bytes (0=1byte!)
   * we are sending 4 bytes -> 0x13 */
  int rv = buspirate_expect_bin_byte(pgm, 0x13, 0x01);
  if (rv < 0)
    return -1;
  if (rv == 0)
    return -1;
 
  buspirate_send_bin(pgm, cmd, 4);
  buspirate_recv_bin(pgm, res, 4);
 
  return 0;
}

References buspirate_expect_bin_byte(), buspirate_recv_bin(), buspirate_send_bin(), cmd, and pgm.

Referenced by buspirate_cmd().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_disable()

static void buspirate_disable ( struct programmer_t *  pgm )

static

{
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    serial_recv_timeout = 100;
    buspirate_reset_from_binmode(pgm);
  } else {
    buspirate_expect(pgm, "#\n", "RESET", 1);
  }
}

References BP_FLAG_IN_BINMODE, buspirate_expect(), buspirate_reset_from_binmode(), programmer_t::flag, pgm, and serial_recv_timeout.

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_dummy_6()

static void buspirate_dummy_6 ( struct programmer_t *  pgm, const char *  p  )

static

{
}

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the caller graph for this function:

buspirate_enable()

static void buspirate_enable ( struct programmer_t *  pgm )

static

{
  static const char *reset_str = "#\n";
  static const char *accept_str = "y\n";
  char *rcvd;
  int rc, print_banner = 0;
 
  /* Ensure configuration is self-consistant: */
  if (buspirate_verifyconfig(pgm)<0)
    return;         /* XXX should handle error */
 
  /* Attempt to start binary SPI mode unless explicitly told otherwise: */
  if (!buspirate_uses_ascii(pgm)) {
    avrdude_message(MSG_INFO, "Attempting to initiate BusPirate binary mode...\n");
 
    /* Send two CRs to ensure we're not in a sub-menu of the UI if we're in ASCII mode: */
    buspirate_send_bin(pgm, (const unsigned char*)"\n\n", 2);
 
    /* Clear input buffer: */
    serial_drain(&pgm->fd, 0);
 
    /* Attempt to enter binary mode: */
    if (buspirate_start_mode_bin(pgm) >= 0)
      return;
    else
      avrdude_message(MSG_INFO, "%s: Failed to start binary mode, falling back to ASCII...\n", progname);
  }
 
  avrdude_message(MSG_INFO, "Attempting to initiate BusPirate ASCII mode...\n");
 
  /* Call buspirate_send_bin() instead of buspirate_send() 
   * because we don't know if BP is in text or bin mode */
  rc = buspirate_send_bin(pgm, (const unsigned char*)reset_str, strlen(reset_str));
  if (rc) {
    avrdude_message(MSG_INFO, "BusPirate is not responding. Serial port error: %d\n", rc);
    return;
  }
 
  while(1) {
    rcvd = buspirate_readline_noexit(pgm, NULL, 0);
    if (! rcvd) {
      avrdude_message(MSG_INFO, "%s: Fatal: Programmer is not responding.\n", progname);
      return;
    }
    if (strncmp(rcvd, "Are you sure?", 13) == 0) {
      buspirate_send_bin(pgm, (const unsigned char*)accept_str, strlen(accept_str));
    }
    if (strncmp(rcvd, "RESET", 5) == 0) {
      print_banner = 1;
      continue;
    }
    if (buspirate_is_prompt(rcvd)) {
      avrdude_message(MSG_DEBUG, "**\n");
      break;
    }
    if (print_banner)
      avrdude_message(MSG_DEBUG, "**  %s", rcvd);
  }
 
  if (!(pgm->flag & BP_FLAG_IN_BINMODE)) {
    avrdude_message(MSG_INFO, "BusPirate: using ASCII mode\n");
    if (buspirate_start_spi_mode_ascii(pgm) < 0) {
      avrdude_message(MSG_INFO, "%s: Failed to start ascii SPI mode\n", progname);
      return;
    }
  }
}

References avrdude_message(), BP_FLAG_IN_BINMODE, buspirate_is_prompt(), buspirate_readline_noexit(), buspirate_send_bin(), buspirate_start_mode_bin(), buspirate_start_spi_mode_ascii(), buspirate_uses_ascii(), buspirate_verifyconfig(), programmer_t::fd, programmer_t::flag, MSG_DEBUG, MSG_INFO, pgm, progname, and serial_drain.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_expect()

static int buspirate_expect ( struct programmer_t *  pgm, char *  send, char *  expect, int  wait_for_prompt  )

static

{
  int got_it = 0;
  size_t expect_len = strlen(expect);
  char *rcvd;
 
  buspirate_send(pgm, send);
  while (1) {
    rcvd = buspirate_readline(pgm, NULL, 0);
    if (rcvd == NULL) {
      return -1;
    }
    if (strncmp(rcvd, expect, expect_len) == 0) {
      if (! wait_for_prompt) {
        serial_drain(&pgm->fd, 0);
        return 1;
      } else {
        got_it = 1;
      }
    }
 
    if (buspirate_is_prompt(rcvd))
      break;
  }
  return got_it;
}

References buspirate_is_prompt(), buspirate_readline(), buspirate_send(), programmer_t::fd, pgm, and serial_drain.

Referenced by buspirate_disable(), buspirate_powerdown(), buspirate_powerup(), and buspirate_program_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_expect_bin()

static int buspirate_expect_bin ( struct programmer_t *  pgm, unsigned char *  send_data, size_t  send_len, unsigned char *  expect_data, size_t  expect_len  )

static

{
  unsigned char *recv_buf = alloca(expect_len);
  if ((pgm->flag & BP_FLAG_IN_BINMODE) == 0) {
    avrdude_message(MSG_INFO, "BusPirate: Internal error: buspirate_send_bin() called from ascii mode\n");
    return -1;
  }
 
  buspirate_send_bin(pgm, send_data, send_len);
  buspirate_recv_bin(pgm, recv_buf, expect_len);
  if (memcmp(expect_data, recv_buf, expect_len) != 0)
    return 0;
  return 1;
}

References avrdude_message(), BP_FLAG_IN_BINMODE, buspirate_recv_bin(), buspirate_send_bin(), programmer_t::flag, MSG_INFO, and pgm.

Referenced by buspirate_expect_bin_byte().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_expect_bin_byte()

static int buspirate_expect_bin_byte ( struct programmer_t *  pgm, unsigned char  send_byte, unsigned char  expect_byte  )

static

{
  return buspirate_expect_bin(pgm, &send_byte, 1, &expect_byte, 1);
}

References buspirate_expect_bin(), and pgm.

Referenced by buspirate_cmd_bin(), buspirate_program_enable(), buspirate_reset_from_binmode(), and buspirate_start_mode_bin().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_getc()

static int buspirate_getc ( struct programmer_t *  pgm )

static

{
  int rc;
  unsigned char ch = 0;
 
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    avrdude_message(MSG_INFO, "BusPirate: Internal error: buspirate_getc() called from binmode\n");
    return EOF;
  }
 
  rc = serial_recv(&pgm->fd, &ch, 1);
  if (rc < 0)
    return EOF;
  return ch;
}

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

Referenced by buspirate_cmd_ascii(), and buspirate_readline_noexit().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_initialize()

static int buspirate_initialize ( struct programmer_t *  pgm, AVRPART *  p  )

static

{
  pgm->powerup(pgm);
 
  return pgm->program_enable(pgm, p);
}

References pgm, programmer_t::powerup, and programmer_t::program_enable.

Referenced by buspirate_initpgm().

Here is the caller graph for this function:

buspirate_initpgm()

void buspirate_initpgm

(

struct programmer_t *

pgm

)

{
  strcpy(pgm->type, "BusPirate");
 
  pgm->display        = buspirate_dummy_6;
 
  /* BusPirate itself related methods */
  pgm->open           = buspirate_open;
  pgm->close          = buspirate_close;
  pgm->enable         = buspirate_enable;
  pgm->disable        = buspirate_disable;
  pgm->initialize     = buspirate_initialize;
 
  /* Chip related methods */
  pgm->powerup        = buspirate_powerup;
  pgm->powerdown      = buspirate_powerdown;
  pgm->program_enable = buspirate_program_enable;
  pgm->chip_erase     = buspirate_chip_erase;
  pgm->cmd            = buspirate_cmd;
  pgm->read_byte      = avr_read_byte_default;
  pgm->write_byte     = avr_write_byte_default;
 
  pgm->paged_write    = buspirate_paged_write;
  pgm->paged_load     = buspirate_paged_load;
 
  /* Support functions */
  pgm->parseextparams = buspirate_parseextparms;
 
  pgm->setup          = buspirate_setup;
  pgm->teardown       = buspirate_teardown;
}

References avr_read_byte_default(), avr_write_byte_default(), buspirate_chip_erase(), buspirate_close(), buspirate_cmd(), buspirate_disable(), buspirate_dummy_6(), buspirate_enable(), buspirate_initialize(), buspirate_open(), buspirate_paged_load(), buspirate_paged_write(), buspirate_parseextparms(), buspirate_powerdown(), buspirate_powerup(), buspirate_program_enable(), buspirate_setup(), buspirate_teardown(), 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::powerdown, programmer_t::powerup, programmer_t::program_enable, programmer_t::read_byte, programmer_t::setup, programmer_t::teardown, programmer_t::type, and programmer_t::write_byte.

Here is the call graph for this function:

buspirate_is_prompt()

static int buspirate_is_prompt ( const char *  str )

static

{
  int strlen_str = (int)strlen(str);
  /* Prompt ends with '>' or '> '
   * all other input probably ends with '\n' */
  return (str[strlen_str - 1] == '>' || str[strlen_str - 2] == '>');
}

Referenced by buspirate_cmd_ascii(), buspirate_enable(), buspirate_expect(), buspirate_reset_from_binmode(), and buspirate_start_spi_mode_ascii().

Here is the caller graph for this function:

buspirate_open()

static int buspirate_open ( struct programmer_t *  pgm, char *  port  )

static

{
  union pinfo pinfo;
  /* BusPirate runs at 115200 by default */
  if(pgm->baudrate == 0)
    pgm->baudrate = 115200;
 
  pinfo.baud = pgm->baudrate;
  strcpy(pgm->port, port);
  if (serial_open(port, pinfo, &pgm->fd)==-1) {
    return -1;
  }
 
  /* drain any extraneous input */
  serial_drain(&pgm->fd, 0);
 
  return 0;
}

References pinfo::baud, programmer_t::baudrate, programmer_t::fd, pgm, programmer_t::port, serial_drain, and serial_open.

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the caller graph for this function:

buspirate_paged_load()

static int buspirate_paged_load ( PROGRAMMER *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  address, unsigned int  n_bytes  )

static

{
  unsigned char commandbuf[10];
  unsigned char buf[275];
  unsigned int addr = 0;
 
  avrdude_message(MSG_NOTICE, "BusPirate: buspirate_paged_load(..,%s,%d,%d,%d)\n",m->desc,m->page_size,address,n_bytes);
 
  // This should never happen, but still...
  if (pgm->flag & BP_FLAG_NOPAGEDREAD) {
    avrdude_message(MSG_INFO, "BusPirate: buspirate_paged_load() called while in nopagedread mode!\n");
    return -1;
  }
 
  // determine what type of memory to read, only flash is supported
  if (strcmp(m->desc, "flash") != 0) {
    return -1;
  }
 
  // send command to read data
  commandbuf[0] = 6;
  commandbuf[1] = 2;
 
  // send start address (in WORDS, not bytes!)
  commandbuf[2] = (address >> 1 >> 24) & 0xff;
  commandbuf[3] = (address >> 1>> 16) & 0xff;
  commandbuf[4] = (address >> 1 >> 8) & 0xff;
  commandbuf[5] = (address >> 1) & 0xff;
 
  // send number of bytes to fetch (in BYTES)
  commandbuf[6] = (n_bytes >> 24) & 0xff;
  commandbuf[7] = (n_bytes >> 16) & 0xff;
  commandbuf[8] = (n_bytes >> 8) & 0xff;
  commandbuf[9] = (n_bytes) & 0xff;
 
  buspirate_send_bin(pgm, commandbuf, 10);
  buspirate_recv_bin(pgm, buf, 1);
  buspirate_recv_bin(pgm, buf, 1);
 
  if (buf[0] != 0x01) {
    avrdude_message(MSG_INFO, "BusPirate: Paged Read command returned zero.\n");
    return -1;
  }
 
  for (addr = 0; addr < n_bytes; addr++) {
    buspirate_recv_bin(pgm, &m->buf[addr+address], 1);
  }
 
  return n_bytes;
}

References avrdude_message(), BP_FLAG_NOPAGEDREAD, avrmem::buf, buspirate_recv_bin(), buspirate_send_bin(), avrmem::desc, programmer_t::flag, MSG_INFO, MSG_NOTICE, avrmem::page_size, and pgm.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_paged_write()

static int buspirate_paged_write ( struct programmer_t *  pgm, AVRPART *  p, AVRMEM *  m, unsigned int  page_size, unsigned int  base_addr, unsigned int  n_data_bytes  )

static

{
  int page, i;
  int addr = base_addr;
  int n_page_writes;
  int this_page_size;
  unsigned char cmd_buf[4096] = {'\0'};
  unsigned char send_byte, recv_byte;
 
  if (!(pgm->flag & BP_FLAG_IN_BINMODE)) {
    /* Return if we are not in binary mode. */
    return -1;
  }
 
  if (pgm->flag & BP_FLAG_NOPAGEDWRITE) {
    /* Return if we've nominated not to use paged writes. */
    return -1;
  }
 
  if (page_size>1024) {
    /* Page sizes greater than 1kB not yet supported. */
    return -1;
  }
 
  if (strcmp(m->desc,"flash") != 0) {
    /* Only flash memory currently supported. */
    return -1;
  }
 
  /* pre-check opcodes */
  if (m->op[AVR_OP_LOADPAGE_LO] == NULL) {
    avrdude_message(MSG_INFO, "%s failure: %s command not defined for %s\n",
                    progname, "AVR_OP_LOADPAGE_LO", p->desc);
    return -1;
  }
  if (m->op[AVR_OP_LOADPAGE_HI] == NULL) {
    avrdude_message(MSG_INFO, "%s failure: %s command not defined for %s\n",
                    progname, "AVR_OP_LOADPAGE_HI", p->desc);
    return -1;
  }
 
  /* Calculate total number of page writes needed: */
  n_page_writes = n_data_bytes/page_size;
  if (n_data_bytes%page_size >0)
    n_page_writes++;
 
  /* Ensure error LED is off: */
  pgm->err_led(pgm, OFF);
 
  /* Loop over pages: */
  for (page=0; page<n_page_writes; page++) {
 
    /* Determine bytes to write in this page: */
    this_page_size = page_size;
    if (page == n_page_writes-1)
      this_page_size = n_data_bytes - page_size*page;
 
    /* Set up command buffer: */
    memset(cmd_buf, 0, 4*this_page_size);
    for (i=0; i<this_page_size; i++) {
 
      addr = base_addr + page*page_size + i;
 
      if (i%2 == 0) {
        avr_set_bits(m->op[AVR_OP_LOADPAGE_LO], &(cmd_buf[4*i]));
        avr_set_addr(m->op[AVR_OP_LOADPAGE_LO], &(cmd_buf[4*i]), addr/2);
        avr_set_input(m->op[AVR_OP_LOADPAGE_LO], &(cmd_buf[4*i]), m->buf[addr]);
      } else {
        avr_set_bits(m->op[AVR_OP_LOADPAGE_HI], &(cmd_buf[4*i]));
        avr_set_addr(m->op[AVR_OP_LOADPAGE_HI], &(cmd_buf[4*i]), addr/2);
        avr_set_input(m->op[AVR_OP_LOADPAGE_HI], &(cmd_buf[4*i]), m->buf[addr]);
      }
    }
 
    /* 00000100 - Write then read */
    send_byte = 0x05;
    buspirate_send_bin(pgm, &send_byte, 1);
 
    /* Number of bytes to write: */
    send_byte = (4*this_page_size)/0x100;
    buspirate_send_bin(pgm, &send_byte, 1); /* High byte */
    send_byte = (4*this_page_size)%0x100;
    buspirate_send_bin(pgm, &send_byte, 1); /* Low byte */
 
    /* Number of bytes to read: */
    send_byte = 0x0;
    buspirate_send_bin(pgm, &send_byte, 1); /* High byte */
    buspirate_send_bin(pgm, &send_byte, 1); /* Low byte */
 
    /* Set programming LED: */
    pgm->pgm_led(pgm, ON);
 
    /* Send command buffer: */
    buspirate_send_bin(pgm, cmd_buf, 4*this_page_size);
 
    /* Check for write failure: */
    if ((buspirate_recv_bin(pgm, &recv_byte, 1) == EOF) || (recv_byte != 0x01)) {
      avrdude_message(MSG_INFO, "BusPirate: Fatal error: Write Then Read did not succeed.\n");
      pgm->pgm_led(pgm, OFF);
      pgm->err_led(pgm, ON);
      return -1;
    }
 
    /* Unset programming LED: */
    pgm->pgm_led(pgm, OFF);
 
    /* Write loaded page to flash: */
    avr_write_page(pgm, p, m, addr);
  }
 
  return n_data_bytes;
}

References AVR_OP_LOADPAGE_HI, AVR_OP_LOADPAGE_LO, avr_set_addr(), avr_set_bits(), avr_set_input(), avr_write_page(), avrdude_message(), BP_FLAG_IN_BINMODE, BP_FLAG_NOPAGEDWRITE, avrmem::buf, buspirate_recv_bin(), buspirate_send_bin(), avrpart::desc, avrmem::desc, programmer_t::err_led, programmer_t::flag, MSG_INFO, OFF, ON, avrmem::op, pgm, programmer_t::pgm_led, and progname.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_parseextparms()

static int buspirate_parseextparms ( struct programmer_t *  pgm, LISTID  extparms  )

static

{
  LNODEID ln;
  const char *extended_param;
  char reset[10];
  char *preset = reset; /* for strtok() */
  unsigned int spifreq;
  unsigned int rawfreq;
  unsigned int cpufreq;
  int serial_recv_timeout;
 
  for (ln = lfirst(extparms); ln; ln = lnext(ln)) {
    extended_param = ldata(ln);
    if (strcmp(extended_param, "ascii") == 0) {
      pgm->flag |= BP_FLAG_XPARM_FORCE_ASCII;
      continue;
    }
 
    if (sscanf(extended_param, "spifreq=%u", &spifreq) == 1) {
      if (spifreq & (~0x07)) {
        avrdude_message(MSG_INFO, "BusPirate: spifreq must be between 0 and 7.\n");
        avrdude_message(MSG_INFO, "BusPirate: see BusPirate manual for details.\n");
        return -1;
      }
      if (pgm->flag & BP_FLAG_XPARM_RAWFREQ) {
        avrdude_message(MSG_INFO, "BusPirate: set either spifreq or rawfreq\n");
        return -1;
      }
      pgm->flag |=  BP_FLAG_XPARM_SPIFREQ;
      PDATA(pgm)->spifreq = spifreq;
      continue;
    }
 
    if (sscanf(extended_param, "rawfreq=%u", &rawfreq) == 1) {
      if (rawfreq >= 4) {
        avrdude_message(MSG_INFO, "BusPirate: rawfreq must be "
                        "between 0 and 3.\n");
        return -1;
      }
      if (pgm->flag & BP_FLAG_XPARM_SPIFREQ) {
        avrdude_message(MSG_INFO, "BusPirate: set either spifreq or rawfreq\n");
        return -1;
      }
      pgm->flag |=  BP_FLAG_XPARM_RAWFREQ;
      PDATA(pgm)->spifreq = rawfreq;
      continue;
    }
 
    if (sscanf(extended_param, "cpufreq=%u", &cpufreq) == 1) {
      /* lower limit comes from 'cpufreq > 4 * spifreq', spifreq in ascii mode is 30kHz. */
      if (cpufreq < 125 || cpufreq > 4000) {
        avrdude_message(MSG_INFO, "BusPirate: cpufreq must be between 125 and 4000 kHz.\n");
        avrdude_message(MSG_INFO, "BusPirate: see BusPirate manual for details.\n");
        return -1;
      }
      PDATA(pgm)->cpufreq = cpufreq;
      pgm->flag |= BP_FLAG_XPARM_CPUFREQ;
      continue;
    }
 
    if (sscanf(extended_param, "reset=%9s", reset) == 1) {
      char *resetpin;
      while ((resetpin = strtok(preset, ","))) {
        preset = NULL; /* for subsequent strtok() calls */
        if (strcasecmp(resetpin, "cs") == 0)
          PDATA(pgm)->reset |= BP_RESET_CS;
        else if (strcasecmp(resetpin, "aux") == 0 || strcasecmp(reset, "aux1") == 0)
          PDATA(pgm)->reset |= BP_RESET_AUX;
        else if (strcasecmp(resetpin, "aux2") == 0)
          PDATA(pgm)->reset |= BP_RESET_AUX2;
        else {
          avrdude_message(MSG_INFO, "BusPirate: reset must be either CS or AUX.\n");
          return -1;
        }
      }
      pgm->flag |= BP_FLAG_XPARM_RESET;
      continue;
    }
 
    if (strcmp(extended_param, "nopagedwrite") == 0) {
      pgm->flag |= BP_FLAG_NOPAGEDWRITE;
      continue;
    }
 
    if (strcmp(extended_param, "nopagedread") == 0) {
      pgm->flag |= BP_FLAG_NOPAGEDREAD;
      continue;
    }
 
    if (sscanf(extended_param, "serial_recv_timeout=%d", &serial_recv_timeout) == 1) {
      if (serial_recv_timeout < 1) {
        avrdude_message(MSG_INFO, "BusPirate: serial_recv_timeout must be greater 0.\n");
        return -1;
      }
      PDATA(pgm)->serial_recv_timeout = serial_recv_timeout;
      continue;
    }
 
    avrdude_message(MSG_INFO, "BusPirate: do not understand extended param '%s'.\n", extended_param);
    return -1;
  }
 
  return 0;
}

References avrdude_message(), BP_FLAG_NOPAGEDREAD, BP_FLAG_NOPAGEDWRITE, BP_FLAG_XPARM_CPUFREQ, BP_FLAG_XPARM_FORCE_ASCII, BP_FLAG_XPARM_RAWFREQ, BP_FLAG_XPARM_RESET, BP_FLAG_XPARM_SPIFREQ, BP_RESET_AUX, BP_RESET_AUX2, BP_RESET_CS, programmer_t::flag, ldata(), lfirst(), lnext(), MSG_INFO, PDATA, pgm, serial_recv_timeout, and strcasecmp.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_powerdown()

static void buspirate_powerdown ( struct programmer_t *  pgm )

static

{
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    /* Powerdown in BinMode is handled in binary mode init */
    return;
  } else {
    if (pgm->flag & BP_FLAG_XPARM_CPUFREQ) {
      if (!buspirate_expect(pgm, "g\n", "PWM disabled", 1)) {
        avrdude_message(MSG_INFO, "%s: warning: did not get a response to stop PWM command.\n", progname);
      }
    }
    if (buspirate_expect(pgm, "w\n", "POWER SUPPLIES OFF", 1))
      return;
  }
 
  avrdude_message(MSG_INFO, "%s: warning: did not get a response to PowerDown command.\n", progname);
}

References avrdude_message(), BP_FLAG_IN_BINMODE, BP_FLAG_XPARM_CPUFREQ, buspirate_expect(), programmer_t::flag, MSG_INFO, pgm, and progname.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_powerup()

static void buspirate_powerup ( struct programmer_t *  pgm )

static

{
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    /* Powerup in BinMode is handled in binary mode init */
    return;
  } else {
    if (buspirate_expect(pgm, "W\n", "POWER SUPPLIES ON", 1)) {
      if (pgm->flag & BP_FLAG_XPARM_CPUFREQ) {
        char buf[25];
        int ok = 0;
        snprintf(buf, sizeof(buf), "%d\n", PDATA(pgm)->cpufreq);
        if (buspirate_expect(pgm, "g\n", "Frequency in KHz", 1)) {
          if (buspirate_expect(pgm, buf, "Duty cycle in %", 1)) {
            if (buspirate_expect(pgm, "50\n", "PWM active", 1)) {
              ok = 1;
            }
          }
        }
        if(!ok) {
          avrdude_message(MSG_INFO, "%s: warning: did not get a response to start PWM command.\n", progname);
        }
      }
      return;
    }
  }
 
  avrdude_message(MSG_INFO, "%s: warning: did not get a response to PowerUp command.\n", progname);
  avrdude_message(MSG_INFO, "%s: warning: Trying to continue anyway...\n", progname);
}

References avrdude_message(), BP_FLAG_IN_BINMODE, BP_FLAG_XPARM_CPUFREQ, buspirate_expect(), programmer_t::flag, MSG_INFO, PDATA, pgm, progname, and snprintf.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_program_enable()

static int buspirate_program_enable ( struct programmer_t *  pgm, AVRPART *  p  )

static

{
  unsigned char cmd[4];
  unsigned char res[4];
 
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    /* Clear configured reset pin(s): CS and/or AUX and/or AUX2 */
    PDATA(pgm)->current_peripherals_config &= ~PDATA(pgm)->reset;
    if (buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
      return -1;
  }
  else
    buspirate_expect(pgm, "{\n", "CS ENABLED", 1);
 
  if (p->op[AVR_OP_PGM_ENABLE] == NULL) {
    avrdude_message(MSG_INFO, "program enable instruction not defined for part \"%s\"\n",
                    p->desc);
    return -1;
  }
 
  memset(cmd, 0, sizeof(cmd));
  avr_set_bits(p->op[AVR_OP_PGM_ENABLE], cmd);
  pgm->cmd(pgm, cmd, res);
 
  if (res[2] != cmd[1])
    return -2;
 
  return 0;
}

References AVR_OP_PGM_ENABLE, avr_set_bits(), avrdude_message(), BP_FLAG_IN_BINMODE, buspirate_expect(), buspirate_expect_bin_byte(), programmer_t::cmd, cmd, avrpart::desc, programmer_t::flag, MSG_INFO, avrpart::op, PDATA, and pgm.

Referenced by buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_readline()

static char * buspirate_readline ( struct programmer_t *  pgm, char *  buf, size_t  len  )

static

{
  char *ret;
 
  ret = buspirate_readline_noexit(pgm, buf, len);
  if (! ret) {
    avrdude_message(MSG_INFO, "%s: buspirate_readline(): programmer is not responding\n",
                                progname);
    return NULL;
  }
  return ret;
}

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

Referenced by buspirate_cmd_ascii(), buspirate_expect(), buspirate_send(), and buspirate_start_spi_mode_ascii().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_readline_noexit()

static char * buspirate_readline_noexit ( struct programmer_t *  pgm, char *  buf, size_t  len  )

static

{
  char *buf_p;
  long orig_serial_recv_timeout = serial_recv_timeout;
 
  /* Static local buffer - this may come handy at times */
  static char buf_local[100];
 
  if (buf == NULL) {
    buf = buf_local;
    len = sizeof(buf_local);
  }
  buf_p = buf;
  memset(buf, 0, len);
  while (buf_p < (buf + len - 1)) { /* keep the very last byte == 0 */
    *buf_p = buspirate_getc(pgm);
    if (*buf_p == '\r')
      continue;
    if (*buf_p == '\n')
      break;
    if (*buf_p == EOF) {
      *buf_p = '\0';
      break;
    }
    buf_p++;
    serial_recv_timeout = PDATA(pgm)->serial_recv_timeout;
  }
  serial_recv_timeout = orig_serial_recv_timeout;
  avrdude_message(MSG_DEBUG, "%s: buspirate_readline(): %s%s",
                  progname, buf,
                  buf[strlen(buf) - 1] == '\n' ? "" : "\n");
  if (! buf[0])
    return NULL;
 
  return buf;
}

References avrdude_message(), buspirate_getc(), MSG_DEBUG, PDATA, pgm, progname, and serial_recv_timeout.

Referenced by buspirate_enable(), and buspirate_readline().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_recv_bin()

static int buspirate_recv_bin ( struct programmer_t *  pgm, unsigned char *  buf, size_t  len  )

static

{
  int rc;
 
  rc = serial_recv(&pgm->fd, buf, len);
  if (rc < 0)
    return EOF;
 
  avrdude_message(MSG_DEBUG, "%s: buspirate_recv_bin():\n", progname);
  dump_mem(MSG_DEBUG, buf, len);
 
  return (int)len;
}

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

Referenced by buspirate_bb_enable(), buspirate_bb_getpin(), buspirate_cmd_bin(), buspirate_expect_bin(), buspirate_paged_load(), buspirate_paged_write(), buspirate_reset_from_binmode(), and buspirate_start_mode_bin().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_reset_from_binmode()

static void buspirate_reset_from_binmode ( struct programmer_t *  pgm )

static

{
  unsigned char buf[10];
 
  buf[0] = 0x00;  /* BinMode: revert to raw bitbang mode */
  buspirate_send_bin(pgm, buf, 1);
  buspirate_recv_bin(pgm, buf, 5);
 
  if (pgm->flag & BP_FLAG_XPARM_CPUFREQ) {
    /* disable pwm */
    if (buspirate_expect_bin_byte(pgm, 0x13, 0x01) != 1) {
      avrdude_message(MSG_INFO, "%s: warning: did not get a response to stop PWM command.\n", progname);
    }
  }
  /* 0b0100wxyz - Configure peripherals w=power, x=pull-ups, y=AUX, z=CS
   * we want everything off -- 0b01000000 = 0x40 */
  if (buspirate_expect_bin_byte(pgm, 0x40, 0x00) == 1) {
    avrdude_message(MSG_INFO, "%s: warning: did not get a response to power off command.\n", progname);
  }
 
  buf[0] = 0x0F;  /* BinMode: reset */
  buspirate_send_bin(pgm, buf, 1);
 
  /* read back all output */
  memset(buf, '\0', sizeof(buf));
  for (;;) {
    int rc;
    rc = buspirate_recv_bin(pgm, buf, sizeof(buf) - 1);
 
    if (buspirate_is_prompt((const char*)buf)) {
      pgm->flag &= ~BP_FLAG_IN_BINMODE;
      break;
    }
    if (rc == EOF)
      break;
    memset(buf, '\0', sizeof(buf));
  }
 
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    avrdude_message(MSG_INFO, "BusPirate reset failed. You may need to powercycle it.\n");
    return;
  }
 
  avrdude_message(MSG_NOTICE, "BusPirate is back in the text mode\n");
}

References avrdude_message(), BP_FLAG_IN_BINMODE, BP_FLAG_XPARM_CPUFREQ, buspirate_expect_bin_byte(), buspirate_is_prompt(), buspirate_recv_bin(), buspirate_send_bin(), programmer_t::flag, MSG_INFO, MSG_NOTICE, pgm, and progname.

Referenced by buspirate_bb_enable(), buspirate_disable(), and buspirate_start_mode_bin().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_send()

static int buspirate_send ( struct programmer_t *  pgm, const char *  str  )

static

{
  int rc;
  const char * readline;
 
  avrdude_message(MSG_DEBUG, "%s: buspirate_send(): %s", progname, str);
 
  if (pgm->flag & BP_FLAG_IN_BINMODE) {
    avrdude_message(MSG_INFO, "BusPirate: Internal error: buspirate_send() called from binmode\n");
    return -1;
  }
 
  rc = serial_send(&pgm->fd, (const unsigned char*)str, strlen(str));
  if (rc)
    return rc;
  do {
    readline = buspirate_readline(pgm, NULL, 0);
    if (readline == NULL)
      return -1;
  /* keep reading until we get what we sent there */
  } while (strcmp(readline, str) != 0);
 
  /* by now we should be in sync */
  return 0;
}

References avrdude_message(), BP_FLAG_IN_BINMODE, buspirate_readline(), programmer_t::fd, programmer_t::flag, MSG_DEBUG, MSG_INFO, pgm, progname, and serial_send.

Referenced by buspirate_cmd_ascii(), buspirate_expect(), and buspirate_start_spi_mode_ascii().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_send_bin()

static int buspirate_send_bin ( struct programmer_t *  pgm, const unsigned char *  data, size_t  len  )

static

{
  int rc;
 
  avrdude_message(MSG_DEBUG, "%s: buspirate_send_bin():\n", progname);
  dump_mem(MSG_DEBUG, data, len);
 
  rc = serial_send(&pgm->fd, data, len);
 
  return rc;
}

References avrdude_message(), dump_mem(), programmer_t::fd, MSG_DEBUG, pgm, progname, and serial_send.

Referenced by buspirate_bb_enable(), buspirate_bb_getpin(), buspirate_bb_setpin_internal(), buspirate_cmd_bin(), buspirate_enable(), buspirate_expect_bin(), buspirate_paged_load(), buspirate_paged_write(), buspirate_reset_from_binmode(), and buspirate_start_mode_bin().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_setup()

static void buspirate_setup ( struct programmer_t *  pgm )

static

{
  /* Allocate private data */
  if ((pgm->cookie = calloc(1, sizeof(struct pdata))) == 0) {
    // avrdude_message(MSG_INFO, "%s: buspirate_initpgm(): Out of memory allocating private data\n",
    //                 progname);
    // exit(1);
    avrdude_oom("buspirate_initpgm(): Out of memory allocating private data\n");
  }
  PDATA(pgm)->serial_recv_timeout = 100;
}

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

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_start_mode_bin()

static int buspirate_start_mode_bin ( struct programmer_t *  pgm )

static

{
  const struct submode {
    const char *name;  /* Name of mode for user messages */
    char enter;  /* Command to enter from base binary mode */
    const char *entered_format;  /* Response, for "scanf" */
    char config;  /* Command to setup submode parameters */
  } *submode;
 
  if (pgm->flag & BP_FLAG_XPARM_RAWFREQ) {
    submode = &(const struct submode){
      .name = "Raw-wire",
      .enter = 0x05,
      .entered_format = "RAW%1d",
      .config = 0x8C,
    };
    pgm->flag |= BP_FLAG_NOPAGEDWRITE;
    pgm->flag |= BP_FLAG_NOPAGEDREAD;
  } else {
    submode = &(const struct submode){
      .name = "SPI",
      .enter = 0x01,
      .entered_format = "SPI%1d",
      
      /* 1000wxyz - SPI config, w=HiZ(0)/3.3v(1), x=CLK idle, y=CLK edge, z=SMP sample
       * we want: 3.3V(1), idle low(0), data change on
       *          trailing edge (1), sample in the middle
       *          of the pulse (0)
       *       => 0b10001010 = 0x8a */
      .config = 0x8A,
    };
  }
 
  unsigned char buf[20] = { '\0' };
 
  /* == Switch to binmode - send 20x '\0' == */
  buspirate_send_bin(pgm, buf, sizeof(buf));
 
  /* Expecting 'BBIOx' reply */
  memset(buf, 0, sizeof(buf));
  buspirate_recv_bin(pgm, buf, 5);
  if (sscanf((const char*)buf, "BBIO%1d", &PDATA(pgm)->binmode_version) != 1) {
    avrdude_message(MSG_INFO, "Binary mode not confirmed: '%s'\n", buf);
    buspirate_reset_from_binmode(pgm);
    return -1;
  }
  avrdude_message(MSG_NOTICE, "BusPirate binmode version: %d\n",
                PDATA(pgm)->binmode_version);
 
  pgm->flag |= BP_FLAG_IN_BINMODE;
 
  if (pgm->flag & BP_FLAG_XPARM_CPUFREQ) {
    unsigned short pwm_duty;
    unsigned short pwm_period;
 
    pwm_period = 16000/(PDATA(pgm)->cpufreq) - 1; // oscillator runs at 32MHz, we don't use a prescaler
    pwm_duty = pwm_period/2; // 50% duty cycle
 
    avrdude_message(MSG_NOTICE, "Setting up PWM for cpufreq\n");
    avrdude_message(MSG_DEBUG, "PWM settings: Prescaler=1, Duty Cycle=%hd, Period=%hd\n", pwm_duty, pwm_period);
 
    buf[0] = 0x12; // pwm setup
    buf[1] = 0; // prescaler 1
    buf[2] = (char) ((pwm_duty >> 8) & 0xff); // duty cycle register, high byte
    buf[3] = (char) pwm_duty & 0xff; // duty cycle register, low byte
    buf[4] = (char) ((pwm_period >> 8) & 0xff); // period register, high byte
    buf[5] = (char) pwm_period & 0xff; // period register, low byte
    buspirate_send_bin(pgm, buf, 6);
 
    buspirate_recv_bin(pgm, buf, 1);
    if (buf[0] != 0x01)
      avrdude_message(MSG_INFO, "cpufreq (PWM) setup failed\n");
  }
 
  /* == Set protocol sub-mode of binary mode == */
  buf[0] = submode->enter;
  buspirate_send_bin(pgm, buf, 1);
  memset(buf, 0, sizeof(buf));
  buspirate_recv_bin(pgm, buf, 4);
  if (sscanf((const char*)buf, submode->entered_format, &PDATA(pgm)->submode_version) != 1) {
    avrdude_message(MSG_INFO, "%s mode not confirmed: '%s'\n",
                    submode->name, buf);
    buspirate_reset_from_binmode(pgm);
    return -1;
  }
  avrdude_message(MSG_NOTICE, "BusPirate %s version: %d\n", 
                  submode->name, PDATA(pgm)->submode_version);
 
  if (pgm->flag & BP_FLAG_NOPAGEDWRITE) {
                avrdude_message(MSG_NOTICE, "%s: Paged flash write disabled.\n", progname);
    pgm->paged_write = NULL;
  } else {
    /* Check for write-then-read without !CS/CS and disable paged_write if absent: */
    static const unsigned char buf2[] = {5,0,0,0,0};
    buspirate_send_bin(pgm, buf2, sizeof(buf2));
    buspirate_recv_bin(pgm, buf, 1);
    if (buf[0] != 0x01) {
 
      /* Disable paged write: */
      pgm->flag |= BP_FLAG_NOPAGEDWRITE;
      pgm->paged_write = NULL;
 
      /* Return to SPI mode (0x00s have landed us back in binary bitbang mode): */
      buf[0] = 0x1;
      buspirate_send_bin(pgm, buf, 1);
 
      avrdude_message(MSG_NOTICE, "%s: Disabling paged flash write. (Need BusPirate firmware >=v5.10.)\n", progname);
 
      /* Flush serial buffer: */
      serial_drain(&pgm->fd, 0);
    } else {
      avrdude_message(MSG_INFO, "%s: Paged flash write enabled.\n", progname);
    }
  }
 
  /* 0b0100wxyz - Configure peripherals w=power, x=pull-ups/aux2, y=AUX, z=CS
   * we want power (0x48) and all reset pins high. */
  PDATA(pgm)->current_peripherals_config  = 0x48 | PDATA(pgm)->reset;
  if (buspirate_expect_bin_byte(pgm, PDATA(pgm)->current_peripherals_config, 0x01) < 0)
    return -1;
  usleep(50000); // sleep for 50ms after power up
 
  /* 01100xxx -  Set speed */
  if (buspirate_expect_bin_byte(pgm, 0x60 | PDATA(pgm)->spifreq, 0x01) < 0)
    return -1;
 
  /* Submode config */
  if (buspirate_expect_bin_byte(pgm, submode->config, 0x01) < 0)
    return -1;
 
  /* AVR Extended Commands - test for existence */
  if (pgm->flag & BP_FLAG_NOPAGEDREAD) {
                avrdude_message(MSG_NOTICE, "%s: Paged flash read disabled.\n", progname);
    pgm->paged_load = NULL;
  } else {
    int rv = buspirate_expect_bin_byte(pgm, 0x06, 0x01);
    if (rv < 0)
      return -1;
    if (rv) {
      unsigned int ver = 0;
      static const unsigned char buf2[] = {1};
      buspirate_send_bin(pgm, buf2, sizeof(buf2));
      buspirate_recv_bin(pgm, buf, 3);
      ver = buf[1] << 8 | buf[2];
      avrdude_message(MSG_NOTICE, "AVR Extended Commands version %d\n", ver);
    } else {
      avrdude_message(MSG_NOTICE, "AVR Extended Commands not found.\n");
      pgm->flag |= BP_FLAG_NOPAGEDREAD;
      pgm->paged_load = NULL;
    }
  }
 
  return 0;
}

References avrdude_message(), BP_FLAG_IN_BINMODE, BP_FLAG_NOPAGEDREAD, BP_FLAG_NOPAGEDWRITE, BP_FLAG_XPARM_CPUFREQ, BP_FLAG_XPARM_RAWFREQ, buspirate_expect_bin_byte(), buspirate_recv_bin(), buspirate_reset_from_binmode(), buspirate_send_bin(), programmer_t::fd, programmer_t::flag, MSG_DEBUG, MSG_INFO, MSG_NOTICE, programmer_t::paged_load, programmer_t::paged_write, PDATA, pgm, progname, serial_drain, and usleep().

Referenced by buspirate_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_start_spi_mode_ascii()

static int buspirate_start_spi_mode_ascii ( struct programmer_t *  pgm )

static

{
  int spi_cmd = -1;
  int cmd;
  char *rcvd;
  char buf[5];
  char mode[11];
 
  buspirate_send(pgm, "m\n");
  while(1) {
    rcvd = buspirate_readline(pgm, NULL, 0);
    if (rcvd == NULL) {
      return -1;
    }
    if (spi_cmd == -1 && sscanf(rcvd, "%2d. %10s", &cmd, mode)) {
      if (strcmp(mode, "SPI") == 0)
        spi_cmd = cmd;
    }
    if (buspirate_is_prompt(rcvd))
      break;
  }
  if (spi_cmd == -1) {
    avrdude_message(MSG_INFO, "%s: SPI mode number not found. Does your BusPirate support SPI?\n",
        progname);
    avrdude_message(MSG_INFO, "%s: Try powercycling your BusPirate and try again.\n",
        progname);
    return -1;
  }
  snprintf(buf, sizeof(buf), "%d\n", spi_cmd);
  buspirate_send(pgm, buf);
  buf[0] = '\0';
  while (1) {
    rcvd = buspirate_readline(pgm, NULL, 0);
    if (rcvd == NULL) {
      return -1;
    }
    if (strstr(rcvd, "Normal (H=3.3V, L=GND)")) {
      /* BP firmware 2.1 defaults to Open-drain output.
       * That doesn't work on my board, even with pull-up
       * resistors. Select 3.3V output mode instead. */
      sscanf(rcvd, " %2d.", &cmd);
      snprintf(buf, sizeof(buf), "%d\n", cmd);
    }
    if (buspirate_is_prompt(rcvd)) {
      if (strncmp(rcvd, "SPI>", 4) == 0) {
        avrdude_message(MSG_INFO, "BusPirate is now configured for SPI\n");
        break;
      }
      /* Not yet 'SPI>' prompt */
      if (buf[0]) {
        buspirate_send(pgm, buf);
        buf[0] = '\0';
      } else
        buspirate_send(pgm, "\n");
    }
  }
  return 0;
}

References avrdude_message(), buspirate_is_prompt(), buspirate_readline(), buspirate_send(), cmd, MSG_INFO, pgm, progname, and snprintf.

Referenced by buspirate_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_teardown()

static void buspirate_teardown ( struct programmer_t *  pgm )

static

{
  free(pgm->cookie);
}

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

Referenced by buspirate_bb_initpgm(), and buspirate_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

buspirate_uses_ascii()

static int buspirate_uses_ascii ( struct programmer_t *  pgm )

inlinestatic

{
  return (pgm->flag & BP_FLAG_XPARM_FORCE_ASCII);
}

References BP_FLAG_XPARM_FORCE_ASCII, programmer_t::flag, and pgm.

Referenced by buspirate_enable(), and buspirate_verifyconfig().

Here is the caller graph for this function:

buspirate_verifyconfig()

static int buspirate_verifyconfig ( struct programmer_t *  pgm )

static

{
  /* Default reset pin is CS */
  if (PDATA(pgm)->reset == 0x00)
    PDATA(pgm)->reset |= BP_RESET_CS;
 
  if ((PDATA(pgm)->reset != BP_RESET_CS) && buspirate_uses_ascii(pgm)) {
    avrdude_message(MSG_INFO, "BusPirate: RESET pin other than CS is not supported in ASCII mode\n");
    return -1;
  }
 
  if (  ((pgm->flag & BP_FLAG_XPARM_SPIFREQ) || (pgm->flag & BP_FLAG_XPARM_RAWFREQ))
     && buspirate_uses_ascii(pgm)) {
    avrdude_message(MSG_INFO, "BusPirate: SPI speed selection is not supported in ASCII mode\n");
    return -1;
  }
 
  return 0;
}

References avrdude_message(), BP_FLAG_XPARM_RAWFREQ, BP_FLAG_XPARM_SPIFREQ, BP_RESET_CS, buspirate_uses_ascii(), programmer_t::flag, MSG_INFO, PDATA, and pgm.

Referenced by buspirate_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_mem()

static void dump_mem ( const int  msglvl, const unsigned char *  buf, size_t  len  )

static

{
  size_t i;
 
  for (i = 0; i<len; i++) {
    if (i % 8 == 0)
      avrdude_message(msglvl, "\t");
    avrdude_message(msglvl, "0x%02x ", buf[i]);
    if (i % 8 == 3)
      avrdude_message(msglvl, "  ");
    else if (i % 8 == 7)
      avrdude_message(msglvl, "\n");
  }
  if (i % 8 != 7)
    avrdude_message(msglvl, "\n");
}

References avrdude_message().

Referenced by buspirate_recv_bin(), and buspirate_send_bin().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

buspirate_bb_desc

const char buspirate_bb_desc[] = "Using the Bus Pirate's bitbang interface for programming"

buspirate_desc

const char buspirate_desc[] = "Using the Bus Pirate's SPI interface for programming"