bitbang.c File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/time.h>
#include "avrdude.h"
#include "libavrdude.h"
#include "par.h"
#include "serbb.h"
#include "tpi.h"
#include "bitbang.h"

Include dependency graph for bitbang.c:

Go to the source code of this file.

Typedefs
typedef void(*	mysighandler_t) (int)

Functions
static void	alarmhandler (int signo)
static void	bitbang_calibrate_delay (void)
void	bitbang_delay (unsigned int us)
static unsigned char	bitbang_txrx (PROGRAMMER *pgm, unsigned char byte)
static int	bitbang_tpi_clk (PROGRAMMER *pgm)
void	bitbang_tpi_tx (PROGRAMMER *pgm, unsigned char byte)
int	bitbang_tpi_rx (PROGRAMMER *pgm)
int	bitbang_rdy_led (PROGRAMMER *pgm, int value)
int	bitbang_err_led (PROGRAMMER *pgm, int value)
int	bitbang_pgm_led (PROGRAMMER *pgm, int value)
int	bitbang_vfy_led (PROGRAMMER *pgm, int value)
int	bitbang_cmd (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res)
int	bitbang_cmd_tpi (PROGRAMMER *pgm, const unsigned char *cmd, int cmd_len, unsigned char *res, int res_len)
int	bitbang_spi (PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res, int count)
int	bitbang_chip_erase (PROGRAMMER *pgm, AVRPART *p)
int	bitbang_program_enable (PROGRAMMER *pgm, AVRPART *p)
int	bitbang_initialize (PROGRAMMER *pgm, AVRPART *p)
static int	verify_pin_assigned (PROGRAMMER *pgm, int pin, char *desc)
int	bitbang_check_prerequisites (PROGRAMMER *pgm)

Variables
static int	delay_decrement
static volatile int	done
static mysighandler_t	saved_alarmhandler

Typedef Documentation

mysighandler_t

typedef void(* mysighandler_t) (int)

Function Documentation

alarmhandler()

static void alarmhandler ( int  signo )

static

{
  done = 1;
  signal(SIGALRM, saved_alarmhandler);
}

References done, and saved_alarmhandler.

Referenced by bitbang_calibrate_delay().

Here is the caller graph for this function:

bitbang_calibrate_delay()

static void bitbang_calibrate_delay ( void  )

static

{
#if defined(WIN32NATIVE)
  /*
   * If the hardware supports a high-resolution performance counter,
   * we ultimately prefer that one, as it gives quite accurate delays
   * on modern high-speed CPUs.
   */
  if (QueryPerformanceFrequency(&freq))
  {
    has_perfcount = 1;
    avrdude_message(MSG_NOTICE2, "%s: Using performance counter for bitbang delays\n",
                    progname);
  }
  else
  {
    /*
     * If a high-resolution performance counter is not available, we
     * don't have any Win32 implementation for setting up the
     * per-microsecond delay count, so we can only run on a
     * preconfigured delay stepping there.  The figure below should at
     * least be correct within an order of magnitude, judging from the
     * auto-calibration figures seen on various Unix systems on
     * comparable hardware.
     */
    avrdude_message(MSG_NOTICE2, "%s: Using guessed per-microsecond delay count for bitbang delays\n",
                    progname);
    delay_decrement = 100;
  }
#else  /* !WIN32NATIVE */
  struct itimerval itv;
  volatile int i;
 
  avrdude_message(MSG_NOTICE2, "%s: Calibrating delay loop...",
                  progname);
  i = 0;
  done = 0;
  saved_alarmhandler = signal(SIGALRM, alarmhandler);
  /*
   * Set ITIMER_REAL to 100 ms.  All known systems have a timer
   * granularity of 10 ms or better, so counting the delay cycles
   * accumulating over 100 ms should give us a rather realistic
   * picture, without annoying the user by a lengthy startup time (as
   * an alarm(1) would do).  Of course, if heavy system activity
   * happens just during calibration but stops before the remaining
   * part of AVRDUDE runs, this will yield wrong values.  There's not
   * much we can do about this.
   */
  itv.it_value.tv_sec = 0;
  itv.it_value.tv_usec = 100000;
  itv.it_interval.tv_sec = itv.it_interval.tv_usec = 0;
  setitimer(ITIMER_REAL, &itv, 0);
  while (!done)
    i--;
  itv.it_value.tv_sec = itv.it_value.tv_usec = 0;
  setitimer(ITIMER_REAL, &itv, 0);
  /*
   * Calculate back from 100 ms to 1 us.
   */
  delay_decrement = -i / 100000;
  avrdude_message(MSG_NOTICE2, " calibrated to %d cycles per us\n",
                  delay_decrement);
#endif /* WIN32NATIVE */
}

References alarmhandler(), avrdude_message(), delay_decrement, done, MSG_NOTICE2, progname, and saved_alarmhandler.

Referenced by bitbang_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_check_prerequisites()

int bitbang_check_prerequisites

(

PROGRAMMER *

pgm

)

{
 
  if (verify_pin_assigned(pgm, PIN_AVR_RESET, "AVR RESET") < 0)
    return -1;
  if (verify_pin_assigned(pgm, PIN_AVR_SCK,   "AVR SCK") < 0)
    return -1;
  if (verify_pin_assigned(pgm, PIN_AVR_MISO,  "AVR MISO") < 0)
    return -1;
  if (verify_pin_assigned(pgm, PIN_AVR_MOSI,  "AVR MOSI") < 0)
    return -1;
 
  if (pgm->cmd == NULL) {
    avrdude_message(MSG_INFO, "%s: error: no cmd() method defined for bitbang programmer\n",
            progname);
    return -1;
  }
  return 0;
}

References avrdude_message(), programmer_t::cmd, MSG_INFO, pgm, PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_RESET, PIN_AVR_SCK, progname, and verify_pin_assigned().

Referenced by buspirate_bb_enable(), and serbb_open().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_chip_erase()

int bitbang_chip_erase	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  unsigned char cmd[4];
  unsigned char res[4];
  AVRMEM *mem;
 
  if (p->flags & AVRPART_HAS_TPI) {
    pgm->pgm_led(pgm, ON);
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    /* NVMCMD <- CHIP_ERASE */
    bitbang_tpi_tx(pgm, TPI_CMD_SOUT | TPI_SIO_ADDR(TPI_IOREG_NVMCMD));
    bitbang_tpi_tx(pgm, TPI_NVMCMD_CHIP_ERASE); /* CHIP_ERASE */
 
    /* Set Pointer Register */
    mem = avr_locate_mem(p, "flash");
    if (mem == NULL) {
      avrdude_message(MSG_INFO, "No flash memory to erase for part %s\n",
          p->desc);
      return -1;
    }
    bitbang_tpi_tx(pgm, TPI_CMD_SSTPR | 0);
    bitbang_tpi_tx(pgm, (mem->offset & 0xFF) | 1);  /* high byte */
    bitbang_tpi_tx(pgm, TPI_CMD_SSTPR | 1);
    bitbang_tpi_tx(pgm, (mem->offset >> 8) & 0xFF);
 
    /* write dummy value to start erase */
    bitbang_tpi_tx(pgm, TPI_CMD_SST);
    bitbang_tpi_tx(pgm, 0xFF);
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    pgm->pgm_led(pgm, OFF);
 
    return 0;
  }
 
  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_locate_mem(), AVR_OP_CHIP_ERASE, avr_set_bits(), avr_tpi_poll_nvmbsy(), avrdude_message(), AVRPART_HAS_TPI, bitbang_tpi_tx(), avrpart::chip_erase_delay, programmer_t::cmd, cmd, avrpart::desc, avrpart::flags, programmer_t::initialize, MSG_INFO, OFF, avrmem::offset, ON, avrpart::op, pgm, programmer_t::pgm_led, TPI_CMD_SOUT, TPI_CMD_SST, TPI_CMD_SSTPR, TPI_IOREG_NVMCMD, TPI_NVMCMD_CHIP_ERASE, TPI_SIO_ADDR, and usleep().

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_cmd()

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

{
  int i;
 
  for (i=0; i<4; i++) {
    res[i] = bitbang_txrx(pgm, cmd[i]);
  }
 
    if(verbose >= 2)
  {
        avrdude_message(MSG_NOTICE2, "bitbang_cmd(): [ ");
        for(i = 0; i < 4; i++)
            avrdude_message(MSG_NOTICE2, "%02X ", cmd[i]);
        avrdude_message(MSG_NOTICE2, "] [ ");
        for(i = 0; i < 4; i++)
    {
            avrdude_message(MSG_NOTICE2, "%02X ", res[i]);
    }
        avrdude_message(MSG_NOTICE2, "]\n");
  }
 
  return 0;
}

References avrdude_message(), bitbang_txrx(), cmd, MSG_NOTICE2, pgm, and verbose.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_cmd_tpi()

int bitbang_cmd_tpi	(	PROGRAMMER *	pgm,
		const unsigned char *	cmd,
		int	cmd_len,
		unsigned char *	res,
		int	res_len
	)

{
  int i, r;
 
  pgm->pgm_led(pgm, ON);
 
  for (i=0; i<cmd_len; i++) {
    bitbang_tpi_tx(pgm, cmd[i]);
  }
 
  r = 0;
  for (i=0; i<res_len; i++) {
    r = bitbang_tpi_rx(pgm);
    if (r == -1)
      break;
    res[i] = r;
  }
 
  if(verbose >= 2)
  {
    avrdude_message(MSG_NOTICE2, "bitbang_cmd_tpi(): [ ");
    for(i = 0; i < cmd_len; i++)
      avrdude_message(MSG_NOTICE2, "%02X ", cmd[i]);
    avrdude_message(MSG_NOTICE2, "] [ ");
    for(i = 0; i < res_len; i++)
    {
      avrdude_message(MSG_NOTICE2, "%02X ", res[i]);
    }
    avrdude_message(MSG_NOTICE2, "]\n");
  }
 
  pgm->pgm_led(pgm, OFF);
  if (r == -1)
    return -1;
  return 0;
}

References avrdude_message(), bitbang_tpi_rx(), bitbang_tpi_tx(), cmd, MSG_NOTICE2, OFF, ON, pgm, programmer_t::pgm_led, and verbose.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_delay()

void bitbang_delay

(

unsigned int

us

)

{
#if defined(WIN32NATIVE)
  LARGE_INTEGER countNow, countEnd;
 
  if (has_perfcount)
  {
    QueryPerformanceCounter(&countNow);
    countEnd.QuadPart = countNow.QuadPart + freq.QuadPart * us / 1000000ll;
 
    while (countNow.QuadPart < countEnd.QuadPart)
      QueryPerformanceCounter(&countNow);
  }
  else /* no performance counters -- run normal uncalibrated delay */
  {
#endif  /* WIN32NATIVE */
  volatile unsigned int del = us * delay_decrement;
 
  while (del > 0)
    del--;
#if defined(WIN32NATIVE)
  }
#endif /* WIN32NATIVE */
}

References delay_decrement.

Referenced by serbb_setpin().

Here is the caller graph for this function:

bitbang_err_led()

int bitbang_err_led	(	PROGRAMMER *	pgm,
		int	value
	)

{
  pgm->setpin(pgm, PIN_LED_ERR, !value);
  return 0;
}

References pgm, PIN_LED_ERR, and programmer_t::setpin.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the caller graph for this function:

bitbang_initialize()

int bitbang_initialize	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  int rc;
  int tries;
  int i;
 
  bitbang_calibrate_delay();
 
  pgm->powerup(pgm);
  usleep(20000);
 
  /* TPIDATA is a single line, so MISO & MOSI should be connected */
  if (p->flags & AVRPART_HAS_TPI) {
    /* make sure cmd_tpi() is defined */
    if (pgm->cmd_tpi == NULL) {
      avrdude_message(MSG_INFO, "%s: Error: %s programmer does not support TPI\n",
          progname, pgm->type);
      return -1;
    }
 
  /* bring RESET high first */
    pgm->setpin(pgm, PIN_AVR_RESET, 1);
  usleep(1000);
 
    avrdude_message(MSG_NOTICE2, "doing MOSI-MISO link check\n");
 
    pgm->setpin(pgm, PIN_AVR_MOSI, 0);
    if (pgm->getpin(pgm, PIN_AVR_MISO) != 0) {
      avrdude_message(MSG_INFO, "MOSI->MISO 0 failed\n");
      return -1;
    }
    pgm->setpin(pgm, PIN_AVR_MOSI, 1);
    if (pgm->getpin(pgm, PIN_AVR_MISO) != 1) {
      avrdude_message(MSG_INFO, "MOSI->MISO 1 failed\n");
      return -1;
    }
 
    avrdude_message(MSG_NOTICE2, "MOSI-MISO link present\n");
  }
 
  pgm->setpin(pgm, PIN_AVR_SCK, 0);
  pgm->setpin(pgm, PIN_AVR_RESET, 0);
  usleep(20000);
 
  if (p->flags & AVRPART_HAS_TPI) {
    /* keep TPIDATA high for 16 clock cycles */
    pgm->setpin(pgm, PIN_AVR_MOSI, 1);
    for (i = 0; i < 16; i++)
      pgm->highpulsepin(pgm, PIN_AVR_SCK);
 
    /* remove extra guard timing bits */
    bitbang_tpi_tx(pgm, TPI_CMD_SSTCS | TPI_REG_TPIPCR);
    bitbang_tpi_tx(pgm, 0x7);
 
    /* read TPI ident reg */
    bitbang_tpi_tx(pgm, TPI_CMD_SLDCS | TPI_REG_TPIIR);
    rc = bitbang_tpi_rx(pgm);
    if (rc != 0x80) {
      avrdude_message(MSG_INFO, "TPIIR not correct\n");
      return -1;
    }
  } else {
    pgm->highpulsepin(pgm, PIN_AVR_RESET);
  }
 
  usleep(20000); /* 20 ms XXX should be a per-chip parameter */
 
  /*
   * Enable programming mode.  If we are programming an AT90S1200, we
   * can only issue the command and hope it worked.  If we are using
   * one of the other chips, the chip will echo 0x53 when issuing the
   * third byte of the command.  In this case, try up to 32 times in
   * order to possibly get back into sync with the chip if we are out
   * of sync.
   */
  if (p->flags & AVRPART_IS_AT90S1200) {
    pgm->program_enable(pgm, p);
  }
  else {
    tries = 0;
    do {
      rc = pgm->program_enable(pgm, p);
      if ((rc == 0)||(rc == -1))
        break;
      pgm->highpulsepin(pgm, p->retry_pulse/*PIN_AVR_SCK*/);
      tries++;
    } while (tries < 65);
 
    /*
     * can't sync with the device, maybe it's not attached?
     */
    if (rc) {
      avrdude_message(MSG_INFO, "%s: AVR device not responding\n", progname);
      return -1;
    }
  }
 
  return 0;
}

References avrdude_message(), AVRPART_HAS_TPI, AVRPART_IS_AT90S1200, bitbang_calibrate_delay(), bitbang_tpi_rx(), bitbang_tpi_tx(), programmer_t::cmd_tpi, avrpart::flags, programmer_t::getpin, programmer_t::highpulsepin, MSG_INFO, MSG_NOTICE2, pgm, PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_RESET, PIN_AVR_SCK, programmer_t::powerup, progname, programmer_t::program_enable, avrpart::retry_pulse, programmer_t::setpin, TPI_CMD_SLDCS, TPI_CMD_SSTCS, TPI_REG_TPIIR, TPI_REG_TPIPCR, programmer_t::type, and usleep().

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_pgm_led()

int bitbang_pgm_led	(	PROGRAMMER *	pgm,
		int	value
	)

{
  pgm->setpin(pgm, PIN_LED_PGM, !value);
  return 0;
}

References pgm, PIN_LED_PGM, and programmer_t::setpin.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the caller graph for this function:

bitbang_program_enable()

int bitbang_program_enable	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  unsigned char cmd[4];
  unsigned char res[4];
  int i;
 
  if (p->flags & AVRPART_HAS_TPI) {
    /* enable NVM programming */
    bitbang_tpi_tx(pgm, TPI_CMD_SKEY);
    for (i = sizeof(tpi_skey) - 1; i >= 0; i--)
      bitbang_tpi_tx(pgm, tpi_skey[i]);
 
    /* check NVMEN bit */
    bitbang_tpi_tx(pgm, TPI_CMD_SLDCS | TPI_REG_TPISR);
    i = bitbang_tpi_rx(pgm);
    return (i != -1 && (i & TPI_REG_TPISR_NVMEN)) ? 0 : -2;
  }
 
  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(), AVRPART_HAS_TPI, bitbang_tpi_rx(), bitbang_tpi_tx(), programmer_t::cmd, cmd, avrpart::desc, avrpart::flags, MSG_INFO, avrpart::op, pgm, TPI_CMD_SKEY, TPI_CMD_SLDCS, TPI_REG_TPISR, TPI_REG_TPISR_NVMEN, and tpi_skey.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_rdy_led()

int bitbang_rdy_led	(	PROGRAMMER *	pgm,
		int	value
	)

{
  pgm->setpin(pgm, PIN_LED_RDY, !value);
  return 0;
}

References pgm, PIN_LED_RDY, and programmer_t::setpin.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the caller graph for this function:

bitbang_spi()

int bitbang_spi	(	PROGRAMMER *	pgm,
		const unsigned char *	cmd,
		unsigned char *	res,
		int	count
	)

{
  int i;
 
  pgm->setpin(pgm, PIN_LED_PGM, 0);
 
  for (i=0; i<count; i++) {
    res[i] = bitbang_txrx(pgm, cmd[i]);
  }
 
  pgm->setpin(pgm, PIN_LED_PGM, 1);
 
  if(verbose >= 2)
  {
        avrdude_message(MSG_NOTICE2, "bitbang_cmd(): [ ");
        for(i = 0; i < count; i++)
            avrdude_message(MSG_NOTICE2, "%02X ", cmd[i]);
        avrdude_message(MSG_NOTICE2, "] [ ");
        for(i = 0; i < count; i++)
    {
            avrdude_message(MSG_NOTICE2, "%02X ", res[i]);
    }
        avrdude_message(MSG_NOTICE2, "]\n");
  }
 
  return 0;
}

References avrdude_message(), bitbang_txrx(), cmd, MSG_NOTICE2, pgm, PIN_LED_PGM, programmer_t::setpin, and verbose.

Here is the call graph for this function:

bitbang_tpi_clk()

static int bitbang_tpi_clk ( PROGRAMMER *  pgm )

static

{
  unsigned char r = 0;
  pgm->setpin(pgm, PIN_AVR_SCK, 1);
 
  r = pgm->getpin(pgm, PIN_AVR_MISO);
 
  pgm->setpin(pgm, PIN_AVR_SCK, 0);
 
  return r;
}

References programmer_t::getpin, pgm, PIN_AVR_MISO, PIN_AVR_SCK, and programmer_t::setpin.

Referenced by bitbang_tpi_rx(), and bitbang_tpi_tx().

Here is the caller graph for this function:

bitbang_tpi_rx()

int bitbang_tpi_rx

(

PROGRAMMER *

pgm

)

{
  int i;
  unsigned char b, rbyte, parity;
 
  /* make sure pin is on for "pullup" */
  pgm->setpin(pgm, PIN_AVR_MOSI, 1);
 
  /* wait for start bit (up to 10 bits) */
  b = 1;
  for (i = 0; i < 10; i++) {
    b = bitbang_tpi_clk(pgm);
    if (b == 0)
      break;
  }
  if (b != 0) {
    avrdude_message(MSG_INFO, "bitbang_tpi_rx: start bit not received correctly\n");
    return -1;
  }
 
  rbyte = 0;
  parity = 0;
  for (i=0; i<=7; i++) {
    b = bitbang_tpi_clk(pgm);
    parity ^= b;
 
    rbyte |= b << i;
  }
 
  /* parity bit */
  if (bitbang_tpi_clk(pgm) != parity) {
    avrdude_message(MSG_INFO, "bitbang_tpi_rx: parity bit is wrong\n");
    return -1;
  }
 
  /* 2 stop bits */
  b = 1;
  b &= bitbang_tpi_clk(pgm);
  b &= bitbang_tpi_clk(pgm);
  if (b != 1) {
    avrdude_message(MSG_INFO, "bitbang_tpi_rx: stop bits not received correctly\n");
    return -1;
  }
  
  return rbyte;
}

References avrdude_message(), bitbang_tpi_clk(), MSG_INFO, pgm, PIN_AVR_MOSI, and programmer_t::setpin.

Referenced by bitbang_cmd_tpi(), bitbang_initialize(), and bitbang_program_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_tpi_tx()

void bitbang_tpi_tx	(	PROGRAMMER *	pgm,
		unsigned char	byte
	)

{
  int i;
  unsigned char b, parity;
 
  /* start bit */
  pgm->setpin(pgm, PIN_AVR_MOSI, 0);
  bitbang_tpi_clk(pgm);
 
  parity = 0;
  for (i = 0; i <= 7; i++) {
    b = (byte >> i) & 0x01;
    parity ^= b;
 
    /* set the data input line as desired */
    pgm->setpin(pgm, PIN_AVR_MOSI, b);
    bitbang_tpi_clk(pgm);
  }
  
  /* parity bit */
  pgm->setpin(pgm, PIN_AVR_MOSI, parity);
  bitbang_tpi_clk(pgm);
 
  /* 2 stop bits */
  pgm->setpin(pgm, PIN_AVR_MOSI, 1);
  bitbang_tpi_clk(pgm);
  bitbang_tpi_clk(pgm);
}

References bitbang_tpi_clk(), pgm, PIN_AVR_MOSI, and programmer_t::setpin.

Referenced by bitbang_chip_erase(), bitbang_cmd_tpi(), bitbang_initialize(), and bitbang_program_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

bitbang_txrx()

static unsigned char bitbang_txrx ( PROGRAMMER *  pgm, unsigned char  byte  )

static

{
  int i;
  unsigned char r, b, rbyte;
 
  rbyte = 0;
  for (i=7; i>=0; i--) {
    /*
     * Write and read one bit on SPI.
     * Some notes on timing: Let T be the time it takes to do
     * one pgm->setpin()-call resp. par clrpin()-call, then
     * - SCK is high for 2T
     * - SCK is low for 2T
     * - MOSI setuptime is 1T
     * - MOSI holdtime is 3T
     * - SCK low to MISO read is 2T to 3T
     * So we are within programming specs (expect for AT90S1200),
     * if and only if T>t_CLCL (t_CLCL=clock period of target system).
     *
     * Due to the delay introduced by "IN" and "OUT"-commands,
     * T is greater than 1us (more like 2us) on x86-architectures.
     * So programming works safely down to 1MHz target clock.
    */
 
    b = (byte >> i) & 0x01;
 
    /* set the data input line as desired */
    pgm->setpin(pgm, PIN_AVR_MOSI, b);
 
    pgm->setpin(pgm, PIN_AVR_SCK, 1);
 
    /*
     * read the result bit (it is either valid from a previous falling
     * edge or it is ignored in the current context)
     */
    r = pgm->getpin(pgm, PIN_AVR_MISO);
 
    pgm->setpin(pgm, PIN_AVR_SCK, 0);
 
    rbyte |= r << i;
  }
 
  return rbyte;
}

References programmer_t::getpin, pgm, PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_SCK, and programmer_t::setpin.

Referenced by bitbang_cmd(), and bitbang_spi().

Here is the caller graph for this function:

bitbang_vfy_led()

int bitbang_vfy_led	(	PROGRAMMER *	pgm,
		int	value
	)

{
  pgm->setpin(pgm, PIN_LED_VFY, !value);
  return 0;
}

References pgm, PIN_LED_VFY, and programmer_t::setpin.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the caller graph for this function:

verify_pin_assigned()

static int verify_pin_assigned ( PROGRAMMER *  pgm, int  pin, char *  desc  )

static

{
  if (pgm->pinno[pin] == 0) {
    avrdude_message(MSG_INFO, "%s: error: no pin has been assigned for %s\n",
            progname, desc);
    return -1;
  }
  return 0;
}

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

Referenced by bitbang_check_prerequisites().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

delay_decrement

int delay_decrement

static

Referenced by bitbang_calibrate_delay(), and bitbang_delay().

done

volatile int done

static

Referenced by alarmhandler(), bitbang_calibrate_delay(), igl::boundary_loop(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::Voronoi::edge_offset_contour_intersections(), Slic3r::Measure::MeasuringImpl::extract_features(), Slic3r::extruder_range_slow_down_non_proportional(), Slic3r::GUI::GLGizmoFdmSupports::has_backend_supports(), Slic3r::load_amf_file(), Slic3r::Layer::make_perimeters(), Slic3r::GUI::MeshClipper::point_per_contour(), igl::straighten_seams(), Slic3r::GUI::Selection::synchronize_unselected_instances(), Slic3r::GUI::Selection::translate(), update_progress_no_tty(), and Slic3r::Wipe::wipe().

saved_alarmhandler

mysighandler_t saved_alarmhandler

static

Referenced by alarmhandler(), and bitbang_calibrate_delay().