avrpart.c File Reference

#include <stdlib.h>
#include <string.h>
#include "avrdude.h"
#include "libavrdude.h"

Include dependency graph for avrpart.c:

Go to the source code of this file.

Functions
OPCODE *	avr_new_opcode (void)
static OPCODE *	avr_dup_opcode (OPCODE *op)
void	avr_free_opcode (OPCODE *op)
int	avr_set_bits (OPCODE *op, unsigned char *cmd)
int	avr_set_addr (OPCODE *op, unsigned char *cmd, unsigned long addr)
int	avr_set_input (OPCODE *op, unsigned char *cmd, unsigned char data)
int	avr_get_output (OPCODE *op, unsigned char *res, unsigned char *data)
int	avr_get_output_index (OPCODE *op)
static char *	avr_op_str (int op)
static char *	bittype (int type)
AVRMEM *	avr_new_memtype (void)
int	avr_initmem (AVRPART *p)
AVRMEM *	avr_dup_mem (AVRMEM *m)
void	avr_free_mem (AVRMEM *m)
AVRMEM *	avr_locate_mem (AVRPART *p, char *desc)
void	avr_mem_display (const char *prefix, FILE *f, AVRMEM *m, int type, int verbose)
AVRPART *	avr_new_part (void)
AVRPART *	avr_dup_part (AVRPART *d)
void	avr_free_part (AVRPART *d)
AVRPART *	locate_part (LISTID parts, char *partdesc)
AVRPART *	locate_part_by_avr910_devcode (LISTID parts, int devcode)
AVRPART *	locate_part_by_signature (LISTID parts, unsigned char *sig, int sigsize)
void	walk_avrparts (LISTID avrparts, walk_avrparts_cb cb, void *cookie)
static int	sort_avrparts_compare (AVRPART *p1, AVRPART *p2)
void	sort_avrparts (LISTID avrparts)
static char *	reset_disp_str (int r)
void	avr_display (FILE *f, AVRPART *p, const char *prefix, int verbose)

Function Documentation

avr_display()

void avr_display	(	FILE *	f,
		AVRPART *	p,
		const char *	prefix,
		int	verbose
	)

{
  int i;
  char * buf;
  const char * px;
  LNODEID ln;
  AVRMEM * m;
 
  avrdude_message(MSG_INFO,
          "%sAVR Part                      : %s\n"
          "%sChip Erase delay              : %d us\n"
          "%sPAGEL                         : P%02X\n"
          "%sBS2                           : P%02X\n"
          "%sRESET disposition             : %s\n"
          "%sRETRY pulse                   : %s\n"
          "%sserial program mode           : %s\n"
          "%sparallel program mode         : %s\n"
          "%sTimeout                       : %d\n"
          "%sStabDelay                     : %d\n"
          "%sCmdexeDelay                   : %d\n"
          "%sSyncLoops                     : %d\n"
          "%sByteDelay                     : %d\n"
          "%sPollIndex                     : %d\n"
          "%sPollValue                     : 0x%02x\n"
          "%sMemory Detail                 :\n\n",
          prefix, p->desc,
          prefix, p->chip_erase_delay,
          prefix, p->pagel,
          prefix, p->bs2,
          prefix, reset_disp_str(p->reset_disposition),
          prefix, avr_pin_name(p->retry_pulse),
          prefix, (p->flags & AVRPART_SERIALOK) ? "yes" : "no",
          prefix, (p->flags & AVRPART_PARALLELOK) ?
            ((p->flags & AVRPART_PSEUDOPARALLEL) ? "psuedo" : "yes") : "no",
          prefix, p->timeout,
          prefix, p->stabdelay,
          prefix, p->cmdexedelay,
          prefix, p->synchloops,
          prefix, p->bytedelay,
          prefix, p->pollindex,
          prefix, p->pollvalue,
          prefix);
 
  px = prefix;
  i = (int)strlen(prefix) + 5;
  buf = (char *)malloc(i);
  if (buf == NULL) {
    /* ugh, this is not important enough to bail, just ignore it */
  }
  else {
    strcpy(buf, prefix);
    strcat(buf, "  ");
    px = buf;
  }
 
  if (verbose <= 2) {
    avr_mem_display(px, f, NULL, 0, verbose);
  }
  for (ln=lfirst(p->mem); ln; ln=lnext(ln)) {
    m = ldata(ln);
    avr_mem_display(px, f, m, i, verbose);
  }
 
  if (buf)
    free(buf);
}

References avr_mem_display(), avr_pin_name(), avrdude_message(), AVRPART_PARALLELOK, AVRPART_PSEUDOPARALLEL, AVRPART_SERIALOK, avrpart::bs2, avrpart::bytedelay, avrpart::chip_erase_delay, avrpart::cmdexedelay, avrpart::desc, avrpart::flags, free(), ldata(), lfirst(), lnext(), malloc(), avrpart::mem, MSG_INFO, avrpart::pagel, avrpart::pollindex, avrpart::pollvalue, reset_disp_str(), avrpart::reset_disposition, avrpart::retry_pulse, avrpart::stabdelay, avrpart::synchloops, avrpart::timeout, and verbose.

Referenced by avrdude_main(), and cmd_part().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_dup_mem()

AVRMEM * avr_dup_mem

(

AVRMEM *

m

)

{
  AVRMEM * n;
  int i;
 
  n = avr_new_memtype();
 
  *n = *m;
 
  if (m->buf != NULL) {
    n->buf = (unsigned char *)malloc(n->size);
    if (n->buf == NULL) {
      // avrdude_message(MSG_INFO, "avr_dup_mem(): out of memory (memsize=%d)\n",
      //                 n->size);
      // exit(1);
      avrdude_oom("avr_dup_mem(): out of memory");
    }
    memcpy(n->buf, m->buf, n->size);
  }
 
  if (m->tags != NULL) {
    n->tags = (unsigned char *)malloc(n->size);
    if (n->tags == NULL) {
      // avrdude_message(MSG_INFO, "avr_dup_mem(): out of memory (memsize=%d)\n",
      //                 n->size);
      // exit(1);
      avrdude_oom("avr_dup_mem(): out of memory");
    }
    memcpy(n->tags, m->tags, n->size);
  }
 
  for (i = 0; i < AVR_OP_MAX; i++) {
    n->op[i] = avr_dup_opcode(n->op[i]);
  }
 
  return n;
}

References avr_dup_opcode(), avr_new_memtype(), AVR_OP_MAX, avrdude_oom(), avrmem::buf, malloc(), avrmem::op, avrmem::size, and avrmem::tags.

Referenced by avr_dup_part().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_dup_opcode()

static OPCODE * avr_dup_opcode ( OPCODE *  op )

static

{
  OPCODE * m;
  
  /* this makes life easier */
  if (op == NULL) {
    return NULL;
  }
 
  m = (OPCODE *)malloc(sizeof(*m));
  if (m == NULL) {
    // avrdude_message(MSG_INFO, "avr_dup_opcode(): out of memory\n");
    // exit(1);
    avrdude_oom("avr_dup_opcode(): out of memory\n");
  }
 
  memcpy(m, op, sizeof(*m));
 
  return m;
}

References avrdude_oom(), and malloc().

Referenced by avr_dup_mem(), and avr_dup_part().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_dup_part()

AVRPART * avr_dup_part

(

AVRPART *

d

)

{
  AVRPART * p;
  LISTID save;
  LNODEID ln;
  int i;
 
  p = avr_new_part();
  save = p->mem;
 
  *p = *d;
 
  p->mem = save;
 
  for (ln=lfirst(d->mem); ln; ln=lnext(ln)) {
    ladd(p->mem, avr_dup_mem(ldata(ln)));
  }
 
  for (i = 0; i < AVR_OP_MAX; i++) {
    p->op[i] = avr_dup_opcode(p->op[i]);
  }
 
  return p;
}

References avr_dup_mem(), avr_dup_opcode(), avr_new_part(), AVR_OP_MAX, ladd(), ldata(), lfirst(), lnext(), avrpart::mem, avrpart::op, and save().

Referenced by do_op(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_free_mem()

void avr_free_mem

(

AVRMEM *

m

)

{
    int i;
    if (m->buf != NULL) {
      free(m->buf);
      m->buf = NULL;
    }
    if (m->tags != NULL) {
      free(m->tags);
      m->tags = NULL;
    }
    for(i=0;i<sizeof(m->op)/sizeof(m->op[0]);i++)
    {
      if (m->op[i] != NULL)
      {
        avr_free_opcode(m->op[i]);
        m->op[i] = NULL;
      }
    }
    free(m);
}

References avr_free_opcode(), avrmem::buf, free(), avrmem::op, and avrmem::tags.

Referenced by avr_free_part(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_free_opcode()

void avr_free_opcode

(

OPCODE *

op

)

{
  free(op);
}

References free().

Referenced by avr_free_mem(), avr_free_part(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_free_part()

void avr_free_part

(

AVRPART *

d

)

{
int i;
  ldestroy_cb(d->mem, (void(*)(void *))avr_free_mem);
  d->mem = NULL;
    for(i=0;i<sizeof(d->op)/sizeof(d->op[0]);i++)
    {
      if (d->op[i] != NULL)
      {
        avr_free_opcode(d->op[i]);
        d->op[i] = NULL;
      }
    }
  free(d);
}

References avr_free_mem(), avr_free_opcode(), free(), and ldestroy_cb().

Referenced by cleanup_config(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_get_output()

int avr_get_output	(	OPCODE *	op,
		unsigned char *	res,
		unsigned char *	data
	)

{
  int i, j, bit;
  unsigned char value;
  unsigned char mask;
 
  for (i=0; i<32; i++) {
    if (op->bit[i].type == AVR_CMDBIT_OUTPUT) {
      j = 3 - i / 8;
      bit = i % 8;
      mask = 1 << bit;
      value = ((res[j] & mask) >> bit) & 0x01;
      value = value << op->bit[i].bitno;
      if (value)
        *data = *data | value;
      else
        *data = *data & ~value;
    }
  }
 
  return 0;
}

References AVR_CMDBIT_OUTPUT, opcode::bit, cmdbit::bitno, and cmdbit::type.

Referenced by avr_read_byte_default().

Here is the caller graph for this function:

avr_get_output_index()

int avr_get_output_index

(

OPCODE *

op

)

{
  int i, j;
 
  for (i=0; i<32; i++) {
    if (op->bit[i].type == AVR_CMDBIT_OUTPUT) {
      j = 3 - i / 8;
      return j;
    }
  }
 
  return -1;
}

References AVR_CMDBIT_OUTPUT, opcode::bit, and cmdbit::type.

Referenced by stk500isp_read_byte().

Here is the caller graph for this function:

avr_initmem()

int avr_initmem

(

AVRPART *

p

)

{
  LNODEID ln;
  AVRMEM * m;
 
  for (ln=lfirst(p->mem); ln; ln=lnext(ln)) {
    m = ldata(ln);
    m->buf = (unsigned char *) malloc(m->size);
    if (m->buf == NULL) {
      avrdude_message(MSG_INFO, "%s: can't alloc buffer for %s size of %d bytes\n",
              progname, m->desc, m->size);
      return -1;
    }
    m->tags = (unsigned char *) malloc(m->size);
    if (m->tags == NULL) {
      avrdude_message(MSG_INFO, "%s: can't alloc buffer for %s size of %d bytes\n",
              progname, m->desc, m->size);
      return -1;
    }
  }
 
  return 0;
}

References avrdude_message(), avrmem::buf, avrmem::desc, ldata(), lfirst(), lnext(), malloc(), avrpart::mem, MSG_INFO, progname, avrmem::size, and avrmem::tags.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_locate_mem()

AVRMEM * avr_locate_mem	(	AVRPART *	p,
		char *	desc
	)

{
  AVRMEM * m, * match;
  LNODEID ln;
  int matches;
  int l;
 
  l = (int)strlen(desc);
  matches = 0;
  match = NULL;
  for (ln=lfirst(p->mem); ln; ln=lnext(ln)) {
    m = ldata(ln);
    if (strncmp(desc, m->desc, l) == 0) {
      match = m;
      matches++;
    }
  }
 
  if (matches == 1)
    return match;
 
  return NULL;
}

References avrmem::desc, ldata(), lfirst(), lnext(), and avrpart::mem.

Referenced by avr_get_cycle_count(), avr_put_cycle_count(), avr_read(), avr_tpi_chip_erase(), avr_verify(), avr_write(), avrdude_main(), bitbang_chip_erase(), cmd_dump(), cmd_sig(), cmd_write(), do_op(), fileio(), jtag3_initialize(), jtagmkII_initialize(), safemode_readfuses(), safemode_writefuse(), stk500_initialize(), stk500v2_initialize(), stk600_xprog_chip_erase(), stk600_xprog_program_enable(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_mem_display()

void avr_mem_display	(	const char *	prefix,
		FILE *	f,
		AVRMEM *	m,
		int	type,
		int	verbose
	)

{
  int i, j;
  char * optr;
 
  if (m == NULL) {
      avrdude_message(MSG_INFO,
              "%s                       Block Poll               Page                       Polled\n"
              "%sMemory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack\n"
              "%s----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------\n",
            prefix, prefix, prefix);
  }
  else {
    if (verbose > 2) {
      avrdude_message(MSG_INFO,
              "%s                       Block Poll               Page                       Polled\n"
              "%sMemory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack\n"
              "%s----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------\n",
              prefix, prefix, prefix);
    }
    avrdude_message(MSG_INFO,
            "%s%-11s %4d %5d %5d %4d %-6s %6d %4d %6d %5d %5d 0x%02x 0x%02x\n",
            prefix, m->desc, m->mode, m->delay, m->blocksize, m->pollindex,
            m->paged ? "yes" : "no",
            m->size,
            m->page_size,
            m->num_pages,
            m->min_write_delay,
            m->max_write_delay,
            m->readback[0],
            m->readback[1]);
    if (verbose > 4) {
      avrdude_message(MSG_TRACE2, "%s  Memory Ops:\n"
                      "%s    Oeration     Inst Bit  Bit Type  Bitno  Value\n"
                      "%s    -----------  --------  --------  -----  -----\n",
                      prefix, prefix, prefix);
      for (i=0; i<AVR_OP_MAX; i++) {
        if (m->op[i]) {
          for (j=31; j>=0; j--) {
            if (j==31)
              optr = avr_op_str(i);
            else
              optr = " ";
          avrdude_message(MSG_INFO,
                  "%s    %-11s  %8d  %8s  %5d  %5d\n",
                  prefix, optr, j,
                  bittype(m->op[i]->bit[j].type),
                  m->op[i]->bit[j].bitno,
                  m->op[i]->bit[j].value);
          }
        }
      }
    }
  }
}

References AVR_OP_MAX, avr_op_str(), avrdude_message(), opcode::bit, cmdbit::bitno, bittype(), avrmem::blocksize, avrmem::delay, avrmem::desc, avrmem::max_write_delay, avrmem::min_write_delay, avrmem::mode, MSG_INFO, MSG_TRACE2, avrmem::num_pages, avrmem::op, avrmem::page_size, avrmem::paged, avrmem::pollindex, avrmem::readback, avrmem::size, cmdbit::type, cmdbit::value, and verbose.

Referenced by avr_display().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_new_memtype()

AVRMEM * avr_new_memtype

(

void

)

{
  AVRMEM * m;
 
  m = (AVRMEM *)malloc(sizeof(*m));
  if (m == NULL) {
    // avrdude_message(MSG_INFO, "avr_new_memtype(): out of memory\n");
    // exit(1);
    avrdude_oom("avr_new_memtype(): out of memory\n");
  }
 
  memset(m, 0, sizeof(*m));
 
  return m;
}

References avrdude_oom(), and malloc().

Referenced by avr_dup_mem(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_new_opcode()

OPCODE * avr_new_opcode

(

void

)

{
  OPCODE * m;
 
  m = (OPCODE *)malloc(sizeof(*m));
  if (m == NULL) {
    // avrdude_message(MSG_INFO, "avr_new_opcode(): out of memory\n");
    // exit(1);
    avrdude_oom("avr_new_opcode(): out of memory\n");
  }
 
  memset(m, 0, sizeof(*m));
 
  return m;
}

References avrdude_oom(), and malloc().

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_new_part()

AVRPART * avr_new_part

(

void

)

{
  AVRPART * p;
 
  p = (AVRPART *)malloc(sizeof(AVRPART));
  if (p == NULL) {
    // avrdude_message(MSG_INFO, "new_part(): out of memory\n");
    // exit(1);
    avrdude_oom("new_part(): out of memory\n");
  }
 
  memset(p, 0, sizeof(*p));
 
  p->id[0]   = 0;
  p->desc[0] = 0;
  p->reset_disposition = RESET_DEDICATED;
  p->retry_pulse = PIN_AVR_SCK;
  p->flags = AVRPART_SERIALOK | AVRPART_PARALLELOK | AVRPART_ENABLEPAGEPROGRAMMING;
  p->config_file[0] = 0;
  p->lineno = 0;
  memset(p->signature, 0xFF, 3);
  p->ctl_stack_type = CTL_STACK_NONE;
  p->ocdrev = -1;
 
  p->mem = lcreat(NULL, 0);
 
  return p;
}

References avrdude_oom(), AVRPART_ENABLEPAGEPROGRAMMING, AVRPART_PARALLELOK, AVRPART_SERIALOK, avrpart::config_file, CTL_STACK_NONE, avrpart::ctl_stack_type, avrpart::desc, avrpart::flags, avrpart::id, lcreat(), avrpart::lineno, malloc(), avrpart::mem, avrpart::ocdrev, PIN_AVR_SCK, RESET_DEDICATED, avrpart::reset_disposition, avrpart::retry_pulse, and avrpart::signature.

Referenced by avr_dup_part(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_op_str()

static char * avr_op_str ( int  op )

static

{
  switch (op) {
    case AVR_OP_READ        : return "READ"; break;
    case AVR_OP_WRITE       : return "WRITE"; break;
    case AVR_OP_READ_LO     : return "READ_LO"; break;
    case AVR_OP_READ_HI     : return "READ_HI"; break;
    case AVR_OP_WRITE_LO    : return "WRITE_LO"; break;
    case AVR_OP_WRITE_HI    : return "WRITE_HI"; break;
    case AVR_OP_LOADPAGE_LO : return "LOADPAGE_LO"; break;
    case AVR_OP_LOADPAGE_HI : return "LOADPAGE_HI"; break;
    case AVR_OP_LOAD_EXT_ADDR : return "LOAD_EXT_ADDR"; break;
    case AVR_OP_WRITEPAGE   : return "WRITEPAGE"; break;
    case AVR_OP_CHIP_ERASE  : return "CHIP_ERASE"; break;
    case AVR_OP_PGM_ENABLE  : return "PGM_ENABLE"; break;
    default : return "<unknown opcode>"; break;
  }
}

References AVR_OP_CHIP_ERASE, AVR_OP_LOAD_EXT_ADDR, AVR_OP_LOADPAGE_HI, AVR_OP_LOADPAGE_LO, AVR_OP_PGM_ENABLE, AVR_OP_READ, AVR_OP_READ_HI, AVR_OP_READ_LO, AVR_OP_WRITE, AVR_OP_WRITE_HI, AVR_OP_WRITE_LO, and AVR_OP_WRITEPAGE.

Referenced by avr_mem_display().

Here is the caller graph for this function:

avr_set_addr()

int avr_set_addr	(	OPCODE *	op,
		unsigned char *	cmd,
		unsigned long	addr
	)

{
  int i, j, bit;
  unsigned long value;
  unsigned char mask;
 
  for (i=0; i<32; i++) {
    if (op->bit[i].type == AVR_CMDBIT_ADDRESS) {
      j = 3 - i / 8;
      bit = i % 8;
      mask = 1 << bit;
      value = addr >> op->bit[i].bitno & 0x01;
      if (value)
        cmd[j] = cmd[j] | mask;
      else
        cmd[j] = cmd[j] & ~mask;
    }
  }
 
  return 0;
}

References AVR_CMDBIT_ADDRESS, opcode::bit, cmdbit::bitno, cmd, and cmdbit::type.

Referenced by avr_read_byte_default(), avr_write_byte_default(), avr_write_page(), buspirate_paged_write(), stk500_loadaddr(), stk500isp_read_byte(), and stk500isp_write_byte().

Here is the caller graph for this function:

avr_set_bits()

int avr_set_bits	(	OPCODE *	op,
		unsigned char *	cmd
	)

{
  int i, j, bit;
  unsigned char mask;
 
  for (i=0; i<32; i++) {
    if (op->bit[i].type == AVR_CMDBIT_VALUE) {
      j = 3 - i / 8;
      bit = i % 8;
      mask = 1 << bit;
      if (op->bit[i].value)
        cmd[j] = cmd[j] | mask;
      else
        cmd[j] = cmd[j] & ~mask;
    }
  }
 
  return 0;
}

References AVR_CMDBIT_VALUE, opcode::bit, cmd, cmdbit::type, and cmdbit::value.

Referenced by avr_read_byte_default(), avr_write_byte_default(), avr_write_page(), bitbang_chip_erase(), bitbang_program_enable(), buspirate_chip_erase(), buspirate_paged_write(), buspirate_program_enable(), stk500_chip_erase(), stk500_loadaddr(), stk500isp_read_byte(), stk500isp_write_byte(), stk500v2_chip_erase(), stk500v2_paged_load(), stk500v2_paged_write(), and stk500v2_program_enable().

Here is the caller graph for this function:

avr_set_input()

int avr_set_input	(	OPCODE *	op,
		unsigned char *	cmd,
		unsigned char	data
	)

{
  int i, j, bit;
  unsigned char value;
  unsigned char mask;
 
  for (i=0; i<32; i++) {
    if (op->bit[i].type == AVR_CMDBIT_INPUT) {
      j = 3 - i / 8;
      bit = i % 8;
      mask = 1 << bit;
      value = data >> op->bit[i].bitno & 0x01;
      if (value)
        cmd[j] = cmd[j] | mask;
      else
        cmd[j] = cmd[j] & ~mask;
    }
  }
 
  return 0;
}

References AVR_CMDBIT_INPUT, opcode::bit, cmdbit::bitno, cmd, and cmdbit::type.

Referenced by avr_write_byte_default(), buspirate_paged_write(), and stk500isp_write_byte().

Here is the caller graph for this function:

bittype()

static char * bittype ( int  type )

static

{
  switch (type) {
    case AVR_CMDBIT_IGNORE  : return "IGNORE"; break;
    case AVR_CMDBIT_VALUE   : return "VALUE"; break;
    case AVR_CMDBIT_ADDRESS : return "ADDRESS"; break;
    case AVR_CMDBIT_INPUT   : return "INPUT"; break;
    case AVR_CMDBIT_OUTPUT  : return "OUTPUT"; break;
    default : return "<unknown bit type>"; break;
  }
}

References AVR_CMDBIT_ADDRESS, AVR_CMDBIT_IGNORE, AVR_CMDBIT_INPUT, AVR_CMDBIT_OUTPUT, and AVR_CMDBIT_VALUE.

Referenced by avr_mem_display().

Here is the caller graph for this function:

locate_part()

AVRPART * locate_part	(	LISTID	parts,
		char *	partdesc
	)

{
  LNODEID ln1;
  AVRPART * p = NULL;
  int found;
 
  found = 0;
 
  for (ln1=lfirst(parts); ln1 && !found; ln1=lnext(ln1)) {
    p = ldata(ln1);
    if ((strcasecmp(partdesc, p->id) == 0) ||
        (strcasecmp(partdesc, p->desc) == 0))
      found = 1;
  }
 
  if (found)
    return p;
 
  return NULL;
}

References avrpart::desc, avrpart::id, ldata(), lfirst(), lnext(), parts, and strcasecmp.

Referenced by avrdude_main(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

locate_part_by_avr910_devcode()

AVRPART * locate_part_by_avr910_devcode	(	LISTID	parts,
		int	devcode
	)

{
  LNODEID ln1;
  AVRPART * p = NULL;
 
  for (ln1=lfirst(parts); ln1; ln1=lnext(ln1)) {
    p = ldata(ln1);
    if (p->avr910_devcode == devcode)
      return p;
  }
 
  return NULL;
}

References avrpart::avr910_devcode, ldata(), lfirst(), lnext(), and parts.

Referenced by avr910_initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

locate_part_by_signature()

AVRPART * locate_part_by_signature	(	LISTID	parts,
		unsigned char *	sig,
		int	sigsize
	)

{
  LNODEID ln1;
  AVRPART * p = NULL;
  int i;
 
  if (sigsize == 3) {
    for (ln1=lfirst(parts); ln1; ln1=lnext(ln1)) {
      p = ldata(ln1);
      for (i=0; i<3; i++)
        if (p->signature[i] != sig[i])
          break;
      if (i == 3)
        return p;
    }
  }
 
  return NULL;
}

References ldata(), lfirst(), lnext(), parts, and avrpart::signature.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_disp_str()

static char * reset_disp_str ( int  r )

static

{
  switch (r) {
    case RESET_DEDICATED : return "dedicated";
    case RESET_IO        : return "possible i/o";
    default              : return "<invalid>";
  }
}

References RESET_DEDICATED, and RESET_IO.

Referenced by avr_display().

Here is the caller graph for this function:

sort_avrparts()

void sort_avrparts

(

LISTID

avrparts

)

{
  lsort(avrparts,(int (*)(void*, void*)) sort_avrparts_compare);
}

References lsort(), and sort_avrparts_compare().

Referenced by list_parts().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_avrparts_compare()

static int sort_avrparts_compare ( AVRPART *  p1, AVRPART *  p2  )

static

{
  if(p1 == NULL || p2 == NULL) {
    return 0;
  }
  return strncasecmp(p1->desc,p2->desc,AVR_DESCLEN);
}

References AVR_DESCLEN, avrpart::desc, and strncasecmp.

Referenced by sort_avrparts().

Here is the caller graph for this function:

walk_avrparts()

void walk_avrparts	(	LISTID	avrparts,
		walk_avrparts_cb	cb,
		void *	cookie
	)

{
  LNODEID ln1;
  AVRPART * p;
 
  for (ln1 = lfirst(avrparts); ln1; ln1 = lnext(ln1)) {
    p = ldata(ln1);
    cb(p->id, p->desc, p->config_file, p->lineno, cookie);
  }
}

References avrpart::config_file, avrpart::desc, avrpart::id, ldata(), lfirst(), avrpart::lineno, and lnext().

Referenced by list_parts().

Here is the call graph for this function:

Here is the caller graph for this function: