libavrdude.h File Reference

#include "ac_cfg.h"
#include <stdio.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <alloca.h>

Include dependency graph for libavrdude.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	cmdbit
struct	opcode
struct	avrpart
struct	avrmem
struct	pindef_t
struct	pin_checklist_t
union	filedescriptor
union	pinfo
struct	serial_device
struct	programmer_t
struct	fioparms
struct	update_t
struct	programmer_type_t
struct	filedescriptor.usb
struct	pinfo.usbinfo

Macros
#define	PATH_MAX   4096
#define	STACKID   LISTID
#define	SNODEID   LNODEID
#define	QUEUEID   LISTID
#define	QNODEID   LNODEID
#define	PUSH(s, d)   lins_n(s,d,1) /* push 'd' onto the stack */
#define	POP(s)   lrmv_n(s,1) /* pop the stack */
#define	LOOKSTACK(s)
#define	ENQUEUE(q, d)   lins_n(q,d,1) /* put 'd' on the end of the queue */
#define	DEQUEUE(q)
#define	REQUEUE(q, d)
#define	LOOKQUEUE(q)
#define	QUEUELEN(q)   lsize(q) /* length of the queue */
#define	LISTADD(l, d)   ladd(l,d) /* add to end of the list */
#define	LISTRMV(l, d)   lrmv_d(l,d) /* remove from end of the list */
#define	AVRPART_SERIALOK   0x0001 /* part supports serial programming */
#define	AVRPART_PARALLELOK   0x0002 /* part supports parallel programming */
#define	AVRPART_PSEUDOPARALLEL   0x0004 /* part has pseudo parallel support */
#define	AVRPART_HAS_JTAG   0x0008 /* part has a JTAG i/f */
#define	AVRPART_ALLOWFULLPAGEBITSTREAM   0x0010 /* JTAG ICE mkII param. */
#define	AVRPART_ENABLEPAGEPROGRAMMING   0x0020 /* JTAG ICE mkII param. */
#define	AVRPART_HAS_DW   0x0040 /* part has a debugWire i/f */
#define	AVRPART_HAS_PDI   0x0080 /* part has PDI i/f rather than ISP (ATxmega) */
#define	AVRPART_AVR32   0x0100 /* part is in AVR32 family */
#define	AVRPART_INIT_SMC   0x0200 /* part will undergo chip erase */
#define	AVRPART_WRITE   0x0400 /* at least one write operation specified */
#define	AVRPART_HAS_TPI   0x0800 /* part has TPI i/f rather than ISP (ATtiny4/5/9/10) */
#define	AVRPART_IS_AT90S1200   0x1000 /* part is an AT90S1200 (needs special treatment) */
#define	AVR_DESCLEN   64
#define	AVR_IDLEN   32
#define	CTL_STACK_SIZE   32
#define	FLASH_INSTR_SIZE   3
#define	EEPROM_INSTR_SIZE   20
#define	TAG_ALLOCATED   1 /* memory byte is allocated */
#define	AVR_MEMDESCLEN   64
#define	PIN_MASK   (UINT_MAX>>1)
#define	PIN_INVERSE   (~(PIN_MASK)) /* flag for inverted pin in serbb */
#define	PIN_MIN   0 /* smallest allowed pin number */
#define	PIN_MAX   31 /* largest allowed pin number */
#define	PIN_FIELD_ELEMENT_SIZE   (sizeof(pinmask_t) * 8)
#define	PIN_FIELD_SIZE   ((PIN_MAX + PIN_FIELD_ELEMENT_SIZE)/PIN_FIELD_ELEMENT_SIZE)
#define	SET_BITS_0(x, pgm, pinname, level)
#define	GET_BITS_0(x, pgm, pinname)   (((x) ^ (pgm)->pin[pinname].inverse[0]) & (pgm)->pin[pinname].mask[0])
#define	PINFO_FL_USEHID   0x0001
#define	PINFO_FL_SILENT   0x0002 /* don't complain if not found */
#define	SERDEV_FL_NONE   0x0000 /* no flags */
#define	SERDEV_FL_CANSETSPEED   0x0001 /* device can change speed */
#define	serial_open   (serdev->open)
#define	serial_setspeed   (serdev->setspeed)
#define	serial_close   (serdev->close)
#define	serial_send   (serdev->send)
#define	serial_recv   (serdev->recv)
#define	serial_drain   (serdev->drain)
#define	serial_set_dtr_rts   (serdev->set_dtr_rts)
#define	ON   1
#define	OFF   0
#define	PGM_DESCLEN   80
#define	PGM_PORTLEN   PATH_MAX
#define	PGM_TYPELEN   32
#define	PGM_USBSTRINGLEN   256
#define	SHOW_ALL_PINS   (~0u)
#define	SHOW_PPI_PINS   ((1<<PPI_AVR_VCC)|(1<<PPI_AVR_BUFF))
#define	SHOW_AVR_PINS   ((1<<PIN_AVR_RESET)|(1<<PIN_AVR_SCK)|(1<<PIN_AVR_MOSI)|(1<<PIN_AVR_MISO))
#define	SHOW_LED_PINS   ((1<<PIN_LED_ERR)|(1<<PIN_LED_RDY)|(1<<PIN_LED_PGM)|(1<<PIN_LED_VFY))
#define	RETURN_IF_CANCEL()
#define	DEFAULT_USB   "usb"

Typedefs
typedef uint32_t	pinmask_t
typedef void *	LISTID
typedef void *	LNODEID
typedef struct cmdbit	CMDBIT
typedef struct opcode	OPCODE
typedef struct avrpart	AVRPART
typedef struct avrmem	AVRMEM
typedef void(*	walk_avrparts_cb) (const char *name, const char *desc, const char *cfgname, int cfglineno, void *cookie)
typedef struct programmer_t	PROGRAMMER
typedef void(*	walk_programmers_cb) (const char *name, const char *desc, const char *cfgname, int cfglineno, void *cookie)
typedef void(*	FP_UpdateProgress) (int percent, double etime, char *hdr)
typedef struct update_t	UPDATE
typedef struct programmer_type_t	PROGRAMMER_TYPE
typedef void(*	walk_programmer_types_cb) (const char *id, const char *desc, void *cookie)

Enumerations
enum	{   AVR_OP_READ , AVR_OP_WRITE , AVR_OP_READ_LO , AVR_OP_READ_HI ,   AVR_OP_WRITE_LO , AVR_OP_WRITE_HI , AVR_OP_LOADPAGE_LO , AVR_OP_LOADPAGE_HI ,   AVR_OP_LOAD_EXT_ADDR , AVR_OP_WRITEPAGE , AVR_OP_CHIP_ERASE , AVR_OP_PGM_ENABLE ,   AVR_OP_MAX }
enum	{   AVR_CMDBIT_IGNORE , AVR_CMDBIT_VALUE , AVR_CMDBIT_ADDRESS , AVR_CMDBIT_INPUT ,   AVR_CMDBIT_OUTPUT }
enum	{ RESET_DEDICATED , RESET_IO }
enum	ctl_stack_t { CTL_STACK_NONE , CTL_STACK_PP , CTL_STACK_HVSP }
enum	{   PPI_AVR_VCC = 1 , PPI_AVR_BUFF , PIN_AVR_RESET , PIN_AVR_SCK ,   PIN_AVR_MOSI , PIN_AVR_MISO , PIN_LED_ERR , PIN_LED_RDY ,   PIN_LED_PGM , PIN_LED_VFY , N_PINS }
enum	exit_vcc_t { EXIT_VCC_UNSPEC , EXIT_VCC_ENABLED , EXIT_VCC_DISABLED }
enum	exit_reset_t { EXIT_RESET_UNSPEC , EXIT_RESET_ENABLED , EXIT_RESET_DISABLED }
enum	exit_datahigh_t { EXIT_DATAHIGH_UNSPEC , EXIT_DATAHIGH_ENABLED , EXIT_DATAHIGH_DISABLED }
enum	conntype_t { CONNTYPE_PARALLEL , CONNTYPE_SERIAL , CONNTYPE_USB }
enum	FILEFMT {   FMT_AUTO , FMT_SREC , FMT_IHEX , FMT_RBIN ,   FMT_IMM , FMT_HEX , FMT_DEC , FMT_OCT ,   FMT_BIN , FMT_ELF }
enum	{ FIO_READ , FIO_WRITE }
enum	{ DEVICE_READ , DEVICE_WRITE , DEVICE_VERIFY }
enum	updateflags { UF_NONE = 0 , UF_NOWRITE = 1 , UF_AUTO_ERASE = 2 }

Functions
LISTID	lcreat (void *liststruct, int poolsize)
void	ldestroy (LISTID lid)
void	ldestroy_cb (LISTID lid, void(*ucleanup)(void *data_ptr))
LNODEID	lfirst (LISTID)
LNODEID	llast (LISTID)
LNODEID	lnext (LNODEID)
LNODEID	lprev (LNODEID)
void *	ldata (LNODEID)
int	lsize (LISTID)
int	ladd (LISTID lid, void *p)
int	laddo (LISTID lid, void *p, int(*compare)(const void *p1, const void *p2), LNODEID *firstdup)
int	laddu (LISTID lid, void *p, int(*compare)(const void *p1, const void *p2))
int	lins_n (LISTID lid, void *d, unsigned int n)
int	lins_ln (LISTID lid, LNODEID lnid, void *data_ptr)
void *	lget (LISTID lid)
void *	lget_n (LISTID lid, unsigned int n)
LNODEID	lget_ln (LISTID lid, unsigned int n)
void *	lrmv (LISTID lid)
void *	lrmv_n (LISTID lid, unsigned int n)
void *	lrmv_ln (LISTID lid, LNODEID lnid)
void *	lrmv_d (LISTID lid, void *data_ptr)
LISTID	lcat (LISTID lid1, LISTID lid2)
void	lsort (LISTID lid, int(*compare)(void *p1, void *p2))
void *	lsrch (LISTID lid, void *p, int(*compare)(void *p1, void *p2))
int	lprint (FILE *f, LISTID lid)
OPCODE *	avr_new_opcode (void)
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)
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	avr_display (FILE *f, AVRPART *p, const char *prefix, int verbose)
void	walk_avrparts (LISTID avrparts, walk_avrparts_cb cb, void *cookie)
void	sort_avrparts (LISTID avrparts)
void	pin_set_value (struct pindef_t *const pindef, const int pin, const bool inverse)
void	pin_clear_all (struct pindef_t *const pindef)
int	pgm_fill_old_pins (struct programmer_t *const pgm)
int	pins_check (const struct programmer_t *const pgm, const struct pin_checklist_t *const checklist, const int size, const bool output)
const char *	avr_pin_name (int pinname)
const char *	pins_to_str (const struct pindef_t *const pindef)
const char *	pinmask_to_str (const pinmask_t *const pinmask)
PROGRAMMER *	pgm_new (void)
PROGRAMMER *	pgm_dup (const PROGRAMMER *const src)
void	pgm_free (PROGRAMMER *const p)
void	programmer_display (PROGRAMMER *pgm, const char *p)
void	pgm_display_generic_mask (PROGRAMMER *pgm, const char *p, unsigned int show)
void	pgm_display_generic (PROGRAMMER *pgm, const char *p)
PROGRAMMER *	locate_programmer (LISTID programmers, const char *configid)
void	walk_programmers (LISTID programmers, walk_programmers_cb cb, void *cookie)
void	sort_programmers (LISTID programmers)
int	avr_tpi_poll_nvmbsy (PROGRAMMER *pgm)
int	avr_tpi_chip_erase (PROGRAMMER *pgm, AVRPART *p)
int	avr_tpi_program_enable (PROGRAMMER *pgm, AVRPART *p, unsigned char guard_time)
int	avr_read_byte_default (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char *value)
int	avr_read (PROGRAMMER *pgm, AVRPART *p, char *memtype, AVRPART *v)
int	avr_write_page (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr)
int	avr_write_byte (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
int	avr_write_byte_default (PROGRAMMER *pgm, AVRPART *p, AVRMEM *mem, unsigned long addr, unsigned char data)
int	avr_write (PROGRAMMER *pgm, AVRPART *p, char *memtype, int size, int auto_erase)
int	avr_signature (PROGRAMMER *pgm, AVRPART *p)
int	avr_verify (AVRPART *p, AVRPART *v, char *memtype, int size)
int	avr_get_cycle_count (PROGRAMMER *pgm, AVRPART *p, int *cycles)
int	avr_put_cycle_count (PROGRAMMER *pgm, AVRPART *p, int cycles)
int	avr_mem_hiaddr (AVRMEM *mem)
int	avr_chip_erase (PROGRAMMER *pgm, AVRPART *p)
void	report_progress (int completed, int total, char *hdr)
char *	fmtstr (FILEFMT format)
FILE *	fopen_utf8 (const char *filename, const char *mode)
int	fileio (int op, char *filename, FILEFMT format, struct avrpart *p, char *memtype, int size, unsigned section)
int	safemode_writefuse (unsigned char fuse, char *fusename, PROGRAMMER *pgm, AVRPART *p, int tries)
int	safemode_readfuses (unsigned char *lfuse, unsigned char *hfuse, unsigned char *efuse, unsigned char *fuse, PROGRAMMER *pgm, AVRPART *p)
int	safemode_memfuses (int save, unsigned char *lfuse, unsigned char *hfuse, unsigned char *efuse, unsigned char *fuse)
UPDATE *	parse_op (char *s)
UPDATE *	dup_update (UPDATE *upd)
UPDATE *	new_update (int op, char *memtype, int filefmt, char *filename, unsigned section)
void	free_update (UPDATE *upd)
int	do_op (PROGRAMMER *pgm, struct avrpart *p, UPDATE *upd, enum updateflags flags)
const PROGRAMMER_TYPE *	locate_programmer_type (const char *id)
void	walk_programmer_types (walk_programmer_types_cb cb, void *cookie)
int	init_config (void)
void	cleanup_config (void)
int	read_config (const char *file)
int	read_config_builtin ()

Variables
long	serial_recv_timeout
struct serial_device *	serdev
struct serial_device	serial_serdev
struct serial_device	usb_serdev
struct serial_device	usb_serdev_frame
struct serial_device	avrdoper_serdev
struct serial_device	usbhid_serdev
struct avrpart	parts []
FP_UpdateProgress	update_progress
bool	cancel_flag
LISTID	part_list
LISTID	programmers
char	default_programmer []
char	default_parallel []
char	default_serial []
double	default_bitclock
int	default_safemode

---

Class Documentation

cmdbit

struct cmdbit

Class Members
int	bitno
int	type
int	value

opcode

struct opcode

Collaboration diagram for opcode:

Class Members
CMDBIT	bit[32]

avrpart

struct avrpart

Collaboration diagram for avrpart:

Class Members
int	avr910_devcode
unsigned char	bs2
int	bytedelay
int	chip_erase_delay
int	chiperasepolltimeout
int	chiperasepulsewidth
int	chiperasetime
int	cmdexedelay
char	config_file[PATH_MAX]
unsigned char	controlstack[CTL_STACK_SIZE]
enum ctl_stack_t	ctl_stack_type
char	desc[AVR_DESCLEN]
unsigned short	eecr
unsigned char	eeprom_instr[EEPROM_INSTR_SIZE]
unsigned	flags
unsigned char	flash_instr[FLASH_INSTR_SIZE]
int	hventerstabdelay
int	hvleavestabdelay
int	hvspcmdexedelay
char	id[AVR_IDLEN]
unsigned char	idr
int	latchcycles
int	lineno
unsigned int	mcu_base
LISTID	mem
unsigned int	nvm_base
int	ocdrev
OPCODE *	op[AVR_OP_MAX]
unsigned char	pagel
int	pollindex
int	pollmethod
unsigned char	pollvalue
int	postdelay
int	poweroffdelay
int	predelay
int	progmodedelay
int	programfusepolltimeout
int	programfusepulsewidth
int	programlockpolltimeout
int	programlockpulsewidth
unsigned char	rampz
int	reset_disposition
int	resetdelay
int	resetdelayms
int	resetdelayus
int	retry_pulse
unsigned char	signature[3]
unsigned char	spmcr
int	stabdelay
int	stk500_devcode
int	synchcycles
int	synchloops
int	timeout
int	togglevtg
unsigned short	usbpid

avrmem

struct avrmem

Collaboration diagram for avrmem:

Class Members
int	blocksize
unsigned char *	buf
int	delay
char	desc[AVR_MEMDESCLEN]
int	max_write_delay
int	min_write_delay
int	mode
int	num_pages
unsigned int	offset
OPCODE *	op[AVR_OP_MAX]
int	page_size
int	paged
int	pollindex
int	pwroff_after_write
unsigned char	readback[2]
int	readsize
int	size
unsigned char *	tags

pindef_t

struct pindef_t

Data structure to hold used pins by logical function (PIN_AVR_*, ...)

Class Members
pinmask_t	inverse[PIN_FIELD_SIZE]	bitfield of inverse/normal usage of used pins
pinmask_t	mask[PIN_FIELD_SIZE]	bitfield of used pins

pin_checklist_t

struct pin_checklist_t

Data structure to define a checklist of valid pins for each function.

Collaboration diagram for pin_checklist_t:

Class Members
int	mandatory	is this a mandatory pin
int	pinname	logical pinname eg. PIN_AVR_SCK
const struct pindef_t *	valid_pins	mask defines allowed pins, inverse define is they might be used inverted

filedescriptor

union filedescriptor

Class Members
int	ifd
void *	pfd
struct filedescriptor.usb	usb

pinfo

union pinfo

Class Members
long	baud
struct pinfo.usbinfo	usbinfo

fioparms

struct fioparms

Class Members
char *	dir
unsigned int	fileoffset
char *	iodesc
char *	mode
int	op
char *	rw

update_t

struct update_t

Class Members
char *	filename
int	format
char *	memtype
int	op
unsigned	section

filedescriptor.usb

struct filedescriptor.usb

Class Members
int	eep
void *	handle
int	max_xfer
int	rep
int	use_interrupt_xfer
int	wep

pinfo.usbinfo

struct pinfo.usbinfo

Class Members
unsigned short	flags
unsigned short	pid
unsigned short	vid

Macro Definition Documentation

AVR_DESCLEN

#define AVR_DESCLEN   64

AVR_IDLEN

#define AVR_IDLEN   32

AVR_MEMDESCLEN

#define AVR_MEMDESCLEN   64

AVRPART_ALLOWFULLPAGEBITSTREAM

#define AVRPART_ALLOWFULLPAGEBITSTREAM   0x0010 /* JTAG ICE mkII param. */

AVRPART_AVR32

#define AVRPART_AVR32   0x0100 /* part is in AVR32 family */

AVRPART_ENABLEPAGEPROGRAMMING

#define AVRPART_ENABLEPAGEPROGRAMMING   0x0020 /* JTAG ICE mkII param. */

AVRPART_HAS_DW

#define AVRPART_HAS_DW   0x0040 /* part has a debugWire i/f */

AVRPART_HAS_JTAG

#define AVRPART_HAS_JTAG   0x0008 /* part has a JTAG i/f */

AVRPART_HAS_PDI

#define AVRPART_HAS_PDI   0x0080 /* part has PDI i/f rather than ISP (ATxmega) */

AVRPART_HAS_TPI

#define AVRPART_HAS_TPI   0x0800 /* part has TPI i/f rather than ISP (ATtiny4/5/9/10) */

AVRPART_INIT_SMC

#define AVRPART_INIT_SMC   0x0200 /* part will undergo chip erase */

AVRPART_IS_AT90S1200

#define AVRPART_IS_AT90S1200   0x1000 /* part is an AT90S1200 (needs special treatment) */

AVRPART_PARALLELOK

#define AVRPART_PARALLELOK   0x0002 /* part supports parallel programming */

AVRPART_PSEUDOPARALLEL

#define AVRPART_PSEUDOPARALLEL   0x0004 /* part has pseudo parallel support */

AVRPART_SERIALOK

#define AVRPART_SERIALOK   0x0001 /* part supports serial programming */

AVRPART_WRITE

#define AVRPART_WRITE   0x0400 /* at least one write operation specified */

CTL_STACK_SIZE

#define CTL_STACK_SIZE   32

DEFAULT_USB

#define DEFAULT_USB   "usb"

DEQUEUE

#define DEQUEUE

(

q

)

Value:

          lrmv(q)         /* remove next item from the front of 
          the queue */

EEPROM_INSTR_SIZE

#define EEPROM_INSTR_SIZE   20

ENQUEUE

#define ENQUEUE	(		q,
			d
	)		lins_n(q,d,1) /* put 'd' on the end of the queue */

FLASH_INSTR_SIZE

#define FLASH_INSTR_SIZE   3

GET_BITS_0

#define GET_BITS_0	(		x,
			pgm,
			pinname
	)		(((x) ^ (pgm)->pin[pinname].inverse[0]) & (pgm)->pin[pinname].mask[0])

Check if the corresponding bit is set (returns != 0) or cleared. The inverse mask is used, to invert the relevant bits. If the pin definition contains multiple pins, then a single set pin leads to return value != 0. Then you have to check the relevant bits of the returned value, if you need more information. It uses only the lowest element (index=0) of the bitfield, which should be enough for most programmers.

Parameters

[in]	x	input value
[in]	pgm	the programmer whose pin definitions to use
[in]	pinname	the logical name of the pin (PIN_AVR_*, ...)

Returns

the input value with only the relevant bits (which are already inverted, so you get always the logical level)

LISTADD

#define LISTADD	(		l,
			d
	)		ladd(l,d) /* add to end of the list */

LISTRMV

#define LISTRMV	(		l,
			d
	)		lrmv_d(l,d) /* remove from end of the list */

LOOKQUEUE

#define LOOKQUEUE

(

q

)

Value:

          lget(q)         /* return next item on the queue, 
          but don't dequeue */

LOOKSTACK

#define LOOKSTACK

(

s

)

Value:

          lget_n(s,1)     /* look at the top of the stack, 
          but don't pop */

OFF

#define OFF   0

ON

#define ON   1

PATH_MAX

#define PATH_MAX   4096

PGM_DESCLEN

#define PGM_DESCLEN   80

PGM_PORTLEN

#define PGM_PORTLEN   PATH_MAX

PGM_TYPELEN

#define PGM_TYPELEN   32

PGM_USBSTRINGLEN

#define PGM_USBSTRINGLEN   256

PIN_FIELD_ELEMENT_SIZE

#define PIN_FIELD_ELEMENT_SIZE   (sizeof(pinmask_t) * 8)

Number of pins in each element of the bitfield

PIN_FIELD_SIZE

#define PIN_FIELD_SIZE   ((PIN_MAX + PIN_FIELD_ELEMENT_SIZE)/PIN_FIELD_ELEMENT_SIZE)

Numer of elements to store the complete bitfield of all pins

PIN_INVERSE

#define PIN_INVERSE   (~(PIN_MASK)) /* flag for inverted pin in serbb */

PIN_MASK

#define PIN_MASK   (UINT_MAX>>1)

PIN_MAX

#define PIN_MAX   31 /* largest allowed pin number */

PIN_MIN

#define PIN_MIN   0 /* smallest allowed pin number */

PINFO_FL_SILENT

#define PINFO_FL_SILENT   0x0002 /* don't complain if not found */

PINFO_FL_USEHID

#define PINFO_FL_USEHID   0x0001

POP

#define POP

(

s

)

lrmv_n(s,1) /* pop the stack */

PUSH

#define PUSH	(		s,
			d
	)		lins_n(s,d,1) /* push 'd' onto the stack */

QNODEID

#define QNODEID   LNODEID

QUEUEID

#define QUEUEID   LISTID

QUEUELEN

#define QUEUELEN

(

q

)

lsize(q) /* length of the queue */

REQUEUE

#define REQUEUE	(		q,
			d
	)

Value:

          ladd(q,d)       /* re-insert (push) item back on the
          front of the queue */

RETURN_IF_CANCEL

#define RETURN_IF_CANCEL

(

)

Value:

  do { \
    if (cancel_flag) { \
      avrdude_message(MSG_INFO, "avrdude: %s(): Cancelled, exiting...\n", __func__); \
      return -99; \
    } \
  } while (0)

SERDEV_FL_CANSETSPEED

#define SERDEV_FL_CANSETSPEED   0x0001 /* device can change speed */

SERDEV_FL_NONE

#define SERDEV_FL_NONE   0x0000 /* no flags */

serial_close

#define serial_close   (serdev->close)

serial_drain

#define serial_drain   (serdev->drain)

serial_open

#define serial_open   (serdev->open)

serial_recv

#define serial_recv   (serdev->recv)

serial_send

#define serial_send   (serdev->send)

serial_set_dtr_rts

#define serial_set_dtr_rts   (serdev->set_dtr_rts)

serial_setspeed

#define serial_setspeed   (serdev->setspeed)

SET_BITS_0

#define SET_BITS_0	(		x,
			pgm,
			pinname,
			level
	)

Value:

    (((x) & ~(pgm)->pin[pinname].mask[0]) \
    | (\
        (pgm)->pin[pinname].mask[0] & ( \
             (level) \
             ?~((pgm)->pin[pinname].inverse[0]) \
             : ((pgm)->pin[pinname].inverse[0]) \
        ) \
    ) \
)

This sets the corresponding bits to 1 or 0, the inverse mask is used to invert the value in necessary. It uses only the lowest element (index=0) of the bitfield, which should be enough for most programmers.

Parameters

[in]	x	input value
[in]	pgm	the programmer whose pin definitions to use
[in]	pinname	the logical name of the pin (PIN_AVR_*, ...)
[in]	level	the logical level (level != 0 => 1, level == 0 => 0), if the pin is defined as inverted the resulting bit is also inverted

Returns

the input value with the relevant bits modified

SHOW_ALL_PINS

#define SHOW_ALL_PINS   (~0u)

SHOW_AVR_PINS

#define SHOW_AVR_PINS   ((1<<PIN_AVR_RESET)|(1<<PIN_AVR_SCK)|(1<<PIN_AVR_MOSI)|(1<<PIN_AVR_MISO))

SHOW_LED_PINS

#define SHOW_LED_PINS   ((1<<PIN_LED_ERR)|(1<<PIN_LED_RDY)|(1<<PIN_LED_PGM)|(1<<PIN_LED_VFY))

SHOW_PPI_PINS

#define SHOW_PPI_PINS   ((1<<PPI_AVR_VCC)|(1<<PPI_AVR_BUFF))

SNODEID

#define SNODEID   LNODEID

STACKID

#define STACKID   LISTID

TAG_ALLOCATED

#define TAG_ALLOCATED   1 /* memory byte is allocated */

Typedef Documentation

AVRMEM

typedef struct avrmem AVRMEM

AVRPART

typedef struct avrpart AVRPART

CMDBIT

typedef struct cmdbit CMDBIT

FP_UpdateProgress

typedef void(* FP_UpdateProgress) (int percent, double etime, char *hdr)

LISTID

typedef void* LISTID

LNODEID

typedef void* LNODEID

OPCODE

typedef struct opcode OPCODE

pinmask_t

typedef uint32_t pinmask_t

PROGRAMMER

typedef struct programmer_t PROGRAMMER

PROGRAMMER_TYPE

typedef struct programmer_type_t PROGRAMMER_TYPE

UPDATE

typedef struct update_t UPDATE

walk_avrparts_cb

typedef void(* walk_avrparts_cb) (const char *name, const char *desc, const char *cfgname, int cfglineno, void *cookie)

walk_programmer_types_cb

typedef void(* walk_programmer_types_cb) (const char *id, const char *desc, void *cookie)

walk_programmers_cb

typedef void(* walk_programmers_cb) (const char *name, const char *desc, const char *cfgname, int cfglineno, void *cookie)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
FIO_READ
FIO_WRITE

    {
  FIO_READ,
  FIO_WRITE
};
 
#ifdef __cplusplus
extern "C" {
#endif
 
char * fmtstr(FILEFMT format);
 
FILE *fopen_utf8(const char *filename, const char *mode);
 
int fileio(int op, char * filename, FILEFMT format,
           struct avrpart * p, char * memtype, int size, unsigned section);
 
#ifdef __cplusplus
}
#endif
 
 
/* formerly safemode.h */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Writes the specified fuse in fusename (can be "lfuse", "hfuse", or "efuse") and verifies it. Will try up to tries
amount of times before giving up */
int safemode_writefuse (unsigned char fuse, char * fusename, PROGRAMMER * pgm, AVRPART * p, int tries);
 
/* Reads the fuses three times, checking that all readings are the same. This will ensure that the before values aren't in error! */
int safemode_readfuses (unsigned char * lfuse, unsigned char * hfuse, unsigned char * efuse, unsigned char * fuse, PROGRAMMER * pgm, AVRPART * p);
  
/* This routine will store the current values pointed to by lfuse, hfuse, and efuse into an internal buffer in this routine
when save is set to 1. When save is 0 (or not 1 really) it will copy the values from the internal buffer into the locations
pointed to be lfuse, hfuse, and efuse. This allows you to change the fuse bits if needed from another routine (ie: have it so
if user requests fuse bits are changed, the requested value is now verified */
int safemode_memfuses (int save, unsigned char * lfuse, unsigned char * hfuse, unsigned char * efuse, unsigned char * fuse);
 
#ifdef __cplusplus
}
#endif
 
 
/* formerly update.h */
 
enum {
  DEVICE_READ,
  DEVICE_WRITE,
  DEVICE_VERIFY
};
 
enum updateflags {
  UF_NONE = 0,
  UF_NOWRITE = 1,
  UF_AUTO_ERASE = 2,
};
 
 
typedef struct update_t {
  char * memtype;
  int    op;
  unsigned section;
  char * filename;
  int    format;
} UPDATE;
 
#ifdef __cplusplus
extern "C" {
#endif
 
extern UPDATE * parse_op(char * s);
extern UPDATE * dup_update(UPDATE * upd);
extern UPDATE * new_update(int op, char * memtype, int filefmt,
         char * filename, unsigned section);
extern void free_update(UPDATE * upd);
extern int do_op(PROGRAMMER * pgm, struct avrpart * p, UPDATE * upd,
     enum updateflags flags);
 
#ifdef __cplusplus
}
#endif
 
 
/* formerly pgm_type.h */
 
/*LISTID programmer_types;*/
 
typedef struct programmer_type_t {
  const char * const id;
  void (*initpgm)(struct programmer_t * pgm);
  const char * const desc;
} PROGRAMMER_TYPE;
 
#ifdef __cplusplus
extern "C" {
#endif
 
const PROGRAMMER_TYPE * locate_programmer_type(/*LISTID programmer_types, */const char * id);
 
typedef void (*walk_programmer_types_cb)(const char *id, const char *desc,
                                    void *cookie);
void walk_programmer_types(/*LISTID programmer_types,*/ walk_programmer_types_cb cb, void *cookie);
 
#ifdef __cplusplus
}
#endif
 
/* formerly config.h */
 
extern LISTID       part_list;
extern LISTID       programmers;
extern char         default_programmer[];
extern char         default_parallel[];
extern char         default_serial[];
extern double       default_bitclock;
extern int          default_safemode;
 
/* This name is fixed, it's only here for symmetry with
 * default_parallel and default_serial. */
#define DEFAULT_USB "usb"
 
#ifdef __cplusplus
extern "C" {
#endif
 
int init_config(void);
 
void cleanup_config(void);
 
int read_config(const char * file);
int read_config_builtin();
 
#ifdef __cplusplus
}
#endif
 
// Header file for alloca()
#if defined(WIN32NATIVE)
#  include <malloc.h>
#else
#  include <alloca.h>
#endif
 
 
/* formerly confwin.h */
 
// #if defined(WIN32NATIVE)
 
// #ifdef __cplusplus
// extern "C" {
// #endif
 
// void win_sys_config_set(char sys_config[PATH_MAX]);
// void win_usr_config_set(char usr_config[PATH_MAX]);
 
// #ifdef __cplusplus
// }
// #endif
 
// #endif  /* WIN32NATIVE */
 
 
#endif  /* libavrdude_h */

anonymous enum

anonymous enum

Enumerator
DEVICE_READ
DEVICE_WRITE
DEVICE_VERIFY

     {

anonymous enum

anonymous enum

Enumerator
AVR_OP_READ
AVR_OP_WRITE
AVR_OP_READ_LO
AVR_OP_READ_HI
AVR_OP_WRITE_LO
AVR_OP_WRITE_HI
AVR_OP_LOADPAGE_LO
AVR_OP_LOADPAGE_HI
AVR_OP_LOAD_EXT_ADDR
AVR_OP_WRITEPAGE
AVR_OP_CHIP_ERASE
AVR_OP_PGM_ENABLE
AVR_OP_MAX

     {
  AVR_OP_READ,
  AVR_OP_WRITE,
  AVR_OP_READ_LO,
  AVR_OP_READ_HI,
  AVR_OP_WRITE_LO,
  AVR_OP_WRITE_HI,
  AVR_OP_LOADPAGE_LO,
  AVR_OP_LOADPAGE_HI,
  AVR_OP_LOAD_EXT_ADDR,
  AVR_OP_WRITEPAGE,

anonymous enum

anonymous enum

Enumerator
AVR_CMDBIT_IGNORE
AVR_CMDBIT_VALUE
AVR_CMDBIT_ADDRESS
AVR_CMDBIT_INPUT
AVR_CMDBIT_OUTPUT

     {
  AVR_CMDBIT_IGNORE,  /* bit is ignored on input and output */
  AVR_CMDBIT_VALUE,   /* bit is set to 0 or 1 for input or output */

anonymous enum

anonymous enum

Enumerator
RESET_DEDICATED
RESET_IO

anonymous enum

anonymous enum

Enumerator
PPI_AVR_VCC
PPI_AVR_BUFF
PIN_AVR_RESET
PIN_AVR_SCK
PIN_AVR_MOSI
PIN_AVR_MISO
PIN_LED_ERR
PIN_LED_RDY
PIN_LED_PGM
PIN_LED_VFY
N_PINS

     {
  PPI_AVR_VCC = 1,
  PPI_AVR_BUFF,
  PIN_AVR_RESET,
  PIN_AVR_SCK,
  PIN_AVR_MOSI,
  PIN_AVR_MISO,
  PIN_LED_ERR,
  PIN_LED_RDY,

conntype_t

enum conntype_t

Enumerator
CONNTYPE_PARALLEL
CONNTYPE_SERIAL
CONNTYPE_USB

             {

ctl_stack_t

enum ctl_stack_t

Enumerator
CTL_STACK_NONE
CTL_STACK_PP
CTL_STACK_HVSP

                 {

exit_datahigh_t

enum exit_datahigh_t

Enumerator
EXIT_DATAHIGH_UNSPEC
EXIT_DATAHIGH_ENABLED
EXIT_DATAHIGH_DISABLED

             {

exit_reset_t

enum exit_reset_t

Enumerator
EXIT_RESET_UNSPEC
EXIT_RESET_ENABLED
EXIT_RESET_DISABLED

             {

exit_vcc_t

enum exit_vcc_t

Enumerator
EXIT_VCC_UNSPEC
EXIT_VCC_ENABLED
EXIT_VCC_DISABLED

             {

FILEFMT

enum FILEFMT

Enumerator
FMT_AUTO
FMT_SREC
FMT_IHEX
FMT_RBIN
FMT_IMM
FMT_HEX
FMT_DEC
FMT_OCT
FMT_BIN
FMT_ELF

             {
  FMT_AUTO,
  FMT_SREC,
  FMT_IHEX,
  FMT_RBIN,
  FMT_IMM,
  FMT_HEX,
  FMT_DEC,

updateflags

enum updateflags

Enumerator
UF_NONE
UF_NOWRITE
UF_AUTO_ERASE

                 {

Function Documentation

avr_chip_erase()

int avr_chip_erase	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  int rc;
 
  rc = pgm->chip_erase(pgm, p);
 
  return rc;
}

References programmer_t::chip_erase, and pgm.

Referenced by avrdude_main().

Here is the caller graph for this function:

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_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_cycle_count()

int avr_get_cycle_count	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		int *	cycles
	)

{
  AVRMEM * a;
  unsigned int cycle_count = 0;
  unsigned char v1;
  int rc;
  int i;
 
  a = avr_locate_mem(p, "eeprom");
  if (a == NULL) {
    return -1;
  }
 
  for (i=4; i>0; i--) {
    rc = pgm->read_byte(pgm, p, a, a->size-i, &v1);
  if (rc < 0) {
    avrdude_message(MSG_INFO, "%s: WARNING: can't read memory for cycle count, rc=%d\n",
            progname, rc);
    return -1;
  }
    cycle_count = (cycle_count << 8) | v1;
  }
 
   /*
   * If the EEPROM is erased, the cycle count reads 0xffffffff.
   * In this case we return a cycle_count of zero.
   * So, the calling function don't have to care about whether or not
   * the cycle count was initialized.
   */
  if (cycle_count == 0xffffffff) {
    cycle_count = 0;
  }
 
  *cycles = (int) cycle_count;
 
  return 0;
}

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

Here is the call 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_mem_hiaddr()

int avr_mem_hiaddr

(

AVRMEM *

mem

)

{
  int i, n;
 
  /* return the highest non-0xff address regardless of how much
     memory was read */
  for (i=mem->size-1; i>0; i--) {
    if (mem->buf[i] != 0xff) {
      n = i+1;
      if (n & 0x01)
        return n+1;
      else
        return n;
    }
  }
 
  return 0;
}

References avrmem::buf, and avrmem::size.

Referenced by avr_read(), and fileio().

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_pin_name()

const char * avr_pin_name

(

int

pinname

)

Returns the name of the pin as string.

Parameters

pinname

the pinname which we want as string.

Returns

a string with the pinname, or <unknown> if pinname is invalid.

                                       {
  switch(pinname) {
  case PPI_AVR_VCC   : return "VCC";
  case PPI_AVR_BUFF  : return "BUFF";
  case PIN_AVR_RESET : return "RESET";
  case PIN_AVR_SCK   : return "SCK";
  case PIN_AVR_MOSI  : return "MOSI";
  case PIN_AVR_MISO  : return "MISO";
  case PIN_LED_ERR   : return "ERRLED";
  case PIN_LED_RDY   : return "RDYLED";
  case PIN_LED_PGM   : return "PGMLED";
  case PIN_LED_VFY   : return "VFYLED";
  default : return "<unknown>";
  }
}

References PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_RESET, PIN_AVR_SCK, PIN_LED_ERR, PIN_LED_PGM, PIN_LED_RDY, PIN_LED_VFY, PPI_AVR_BUFF, and PPI_AVR_VCC.

Referenced by avr_display(), and pins_check().

Here is the caller graph for this function:

avr_put_cycle_count()

int avr_put_cycle_count	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		int	cycles
	)

{
  AVRMEM * a;
  unsigned char v1;
  int rc;
  int i;
 
  a = avr_locate_mem(p, "eeprom");
  if (a == NULL) {
    return -1;
  }
 
  for (i=1; i<=4; i++) {
    v1 = cycles & 0xff;
    cycles = cycles >> 8;
 
    rc = avr_write_byte(pgm, p, a, a->size-i, v1);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: WARNING: can't write memory for cycle count, rc=%d\n",
              progname, rc);
      return -1;
    }
  }
 
  return 0;
  }

References avr_locate_mem(), avr_write_byte(), avrdude_message(), MSG_INFO, pgm, and progname.

Here is the call graph for this function:

avr_read()

int avr_read	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		char *	memtype,
		AVRPART *	v
	)

{
  unsigned long    i, lastaddr;
  unsigned char    cmd[4];
  AVRMEM * mem, * vmem = NULL;
  int rc;
 
  mem = avr_locate_mem(p, memtype);
  if (v != NULL)
      vmem = avr_locate_mem(v, memtype);
  if (mem == NULL) {
    avrdude_message(MSG_INFO, "No \"%s\" memory for part %s\n",
            memtype, p->desc);
    return -1;
  }
 
  /*
   * start with all 0xff
   */
  memset(mem->buf, 0xff, mem->size);
 
  /* supports "paged load" thru post-increment */
  if ((p->flags & AVRPART_HAS_TPI) && mem->page_size != 0 &&
      pgm->cmd_tpi != NULL) {
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    /* setup for read (NOOP) */
    avr_tpi_setup_rw(pgm, mem, 0, TPI_NVMCMD_NO_OPERATION);
 
    /* load bytes */
    for (lastaddr = i = 0; i < (unsigned)mem->size; i++) {
      RETURN_IF_CANCEL();
      if (vmem == NULL ||
          (vmem->tags[i] & TAG_ALLOCATED) != 0)
      {
        if (lastaddr != i) {
          /* need to setup new address */
          avr_tpi_setup_rw(pgm, mem, i, TPI_NVMCMD_NO_OPERATION);
          lastaddr = i;
        }
        cmd[0] = TPI_CMD_SLD_PI;
        rc = pgm->cmd_tpi(pgm, cmd, 1, mem->buf + i, 1);
        lastaddr++;
        if (rc == -1) {
          avrdude_message(MSG_INFO, "avr_read(): error reading address 0x%04lx\n", i);
          return -1;
        }
      }
      report_progress(i, mem->size, NULL);
    }
    return avr_mem_hiaddr(mem);
  }
 
  if (pgm->paged_load != NULL && mem->page_size != 0) {
    /*
     * the programmer supports a paged mode read
     */
    int need_read, failure;
    unsigned int pageaddr;
    unsigned int npages, nread;
 
    /* quickly scan number of pages to be written to first */
    for (pageaddr = 0, npages = 0;
         pageaddr < (unsigned)mem->size;
         pageaddr += mem->page_size) {
      /* check whether this page must be read */
      for (i = pageaddr;
           i < pageaddr + mem->page_size;
           i++)
        if (vmem == NULL /* no verify, read everything */ ||
            (mem->tags[i] & TAG_ALLOCATED) != 0 /* verify, do only
                                                    read pages that
                                                    are needed in
                                                    input file */) {
          npages++;
          break;
        }
    }
 
    for (pageaddr = 0, failure = 0, nread = 0;
         !failure && pageaddr < (unsigned)mem->size;
         pageaddr += mem->page_size) {
      RETURN_IF_CANCEL();
      /* check whether this page must be read */
      for (i = pageaddr, need_read = 0;
           i < pageaddr + mem->page_size;
           i++)
        if (vmem == NULL /* no verify, read everything */ ||
            (vmem->tags[i] & TAG_ALLOCATED) != 0 /* verify, do only
                                                    read pages that
                                                    are needed in
                                                    input file */) {
          need_read = 1;
          break;
        }
      if (need_read) {
        rc = pgm->paged_load(pgm, p, mem, mem->page_size,
                            pageaddr, mem->page_size);
        if (rc < 0)
          /* paged load failed, fall back to byte-at-a-time read below */
          failure = 1;
      } else {
        avrdude_message(MSG_DEBUG, "%s: avr_read(): skipping page %u: no interesting data\n",
                        progname, pageaddr / mem->page_size);
      }
      nread++;
      report_progress(nread, npages, NULL);
    }
    if (!failure) {
      if (strcasecmp(mem->desc, "flash") == 0 ||
          strcasecmp(mem->desc, "application") == 0 ||
          strcasecmp(mem->desc, "apptable") == 0 ||
          strcasecmp(mem->desc, "boot") == 0)
        return avr_mem_hiaddr(mem);
      else
        return mem->size;
    }
    /* else: fall back to byte-at-a-time write, for historical reasons */
  }
 
  if (strcmp(mem->desc, "signature") == 0) {
    if (pgm->read_sig_bytes) {
      return pgm->read_sig_bytes(pgm, p, mem);
    }
  }
 
  for (i = 0; i < (unsigned)mem->size; i++) {
    RETURN_IF_CANCEL();
    if (vmem == NULL ||
  (vmem->tags[i] & TAG_ALLOCATED) != 0)
    {
      rc = pgm->read_byte(pgm, p, mem, i, mem->buf + i);
      if (rc != 0) {
  avrdude_message(MSG_INFO, "avr_read(): error reading address 0x%04lx\n", i);
  if (rc == -1)
    avrdude_message(MSG_INFO, "    read operation not supported for memory \"%s\"\n",
                          memtype);
  return -2;
      }
    }
    report_progress(i, mem->size, NULL);
  }
 
  if (strcasecmp(mem->desc, "flash") == 0 ||
      strcasecmp(mem->desc, "application") == 0 ||
      strcasecmp(mem->desc, "apptable") == 0 ||
      strcasecmp(mem->desc, "boot") == 0)
    return avr_mem_hiaddr(mem);
  else
    return i;
}

References avr_locate_mem(), avr_mem_hiaddr(), avr_tpi_poll_nvmbsy(), avr_tpi_setup_rw(), avrdude_message(), AVRPART_HAS_TPI, avrmem::buf, cmd, programmer_t::cmd_tpi, avrpart::desc, avrmem::desc, avrpart::flags, MSG_DEBUG, MSG_INFO, avrmem::page_size, programmer_t::paged_load, pgm, progname, programmer_t::read_byte, programmer_t::read_sig_bytes, report_progress(), RETURN_IF_CANCEL, avrmem::size, strcasecmp, TAG_ALLOCATED, avrmem::tags, TPI_CMD_SLD_PI, and TPI_NVMCMD_NO_OPERATION.

Referenced by avr_signature(), and do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_read_byte_default()

int avr_read_byte_default	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		AVRMEM *	mem,
		unsigned long	addr,
		unsigned char *	value
	)

{
  unsigned char cmd[4];
  unsigned char res[4];
  unsigned char data;
  int r;
  OPCODE * readop, * lext;
 
  if (pgm->cmd == NULL) {
    avrdude_message(MSG_INFO, "%s: Error: %s programmer uses avr_read_byte_default() but does not\n"
                    "provide a cmd() method.\n",
                    progname, pgm->type);
    return -1;
  }
 
  pgm->pgm_led(pgm, ON);
  pgm->err_led(pgm, OFF);
 
  if (p->flags & AVRPART_HAS_TPI) {
    if (pgm->cmd_tpi == NULL) {
      avrdude_message(MSG_INFO, "%s: Error: %s programmer does not support TPI\n",
          progname, pgm->type);
      return -1;
    }
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    /* setup for read */
    avr_tpi_setup_rw(pgm, mem, addr, TPI_NVMCMD_NO_OPERATION);
 
    /* load byte */
    cmd[0] = TPI_CMD_SLD;
    r = pgm->cmd_tpi(pgm, cmd, 1, value, 1);
    if (r == -1) 
      return -1;
 
    return 0;
  }
 
  /*
   * figure out what opcode to use
   */
  if (mem->op[AVR_OP_READ_LO]) {
    if (addr & 0x00000001)
      readop = mem->op[AVR_OP_READ_HI];
    else
      readop = mem->op[AVR_OP_READ_LO];
    addr = addr / 2;
  }
  else {
    readop = mem->op[AVR_OP_READ];
  }
 
  if (readop == NULL) {
#if DEBUG
    avrdude_message(MSG_INFO, "avr_read_byte(): operation not supported on memory type \"%s\"\n",
                    mem->desc);
#endif
    return -1;
  }
 
  /*
   * If this device has a "load extended address" command, issue it.
   */
  lext = mem->op[AVR_OP_LOAD_EXT_ADDR];
  if (lext != NULL) {
    memset(cmd, 0, sizeof(cmd));
 
    avr_set_bits(lext, cmd);
    avr_set_addr(lext, cmd, addr);
    r = pgm->cmd(pgm, cmd, res);
    if (r < 0)
      return r;
  }
 
  memset(cmd, 0, sizeof(cmd));
 
  avr_set_bits(readop, cmd);
  avr_set_addr(readop, cmd, addr);
  r = pgm->cmd(pgm, cmd, res);
  if (r < 0)
    return r;
  data = 0;
  avr_get_output(readop, res, &data);
 
  pgm->pgm_led(pgm, OFF);
 
  *value = data;
 
  return 0;
}

References avr_get_output(), AVR_OP_LOAD_EXT_ADDR, AVR_OP_READ, AVR_OP_READ_HI, AVR_OP_READ_LO, avr_set_addr(), avr_set_bits(), avr_tpi_poll_nvmbsy(), avr_tpi_setup_rw(), avrdude_message(), AVRPART_HAS_TPI, programmer_t::cmd, cmd, programmer_t::cmd_tpi, avrmem::desc, programmer_t::err_led, avrpart::flags, MSG_INFO, OFF, ON, avrmem::op, pgm, programmer_t::pgm_led, progname, TPI_CMD_SLD, TPI_NVMCMD_NO_OPERATION, and programmer_t::type.

Referenced by avr910_read_byte(), buspirate_bb_initpgm(), buspirate_initpgm(), serbb_initpgm(), and stk500_initpgm().

Here is the call graph for this function:

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:

avr_signature()

int avr_signature	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  int rc;
 
  report_progress(0,1,"Reading");
  rc = avr_read(pgm, p, "signature", 0);
  if (rc < 0) {
    avrdude_message(MSG_INFO, "%s: error reading signature data for part \"%s\", rc=%d\n",
                    progname, p->desc, rc);
    return -1;
  }
  report_progress(1,1,NULL);
 
  return 0;
}

References avr_read(), avrdude_message(), avrpart::desc, MSG_INFO, pgm, progname, and report_progress().

Referenced by avrdude_main(), and cmd_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_tpi_chip_erase()

int avr_tpi_chip_erase	(	PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
  int err;
  AVRMEM *mem;
 
  if (p->flags & AVRPART_HAS_TPI) {
    pgm->pgm_led(pgm, ON);
 
    /* 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;
    }
 
    unsigned char cmd[] = {
      /* write pointer register high byte */
      (TPI_CMD_SSTPR | 0),
      ((mem->offset & 0xFF) | 1),
      /* and low byte */
      (TPI_CMD_SSTPR | 1),
      ((mem->offset >> 8) & 0xFF),
      /* write CHIP_ERASE command to NVMCMD register */
      (TPI_CMD_SOUT | TPI_SIO_ADDR(TPI_IOREG_NVMCMD)),
      TPI_NVMCMD_CHIP_ERASE,
      /* write dummy value to start erase */
      TPI_CMD_SST,
      0xFF
    };
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    err = pgm->cmd_tpi(pgm, cmd, sizeof(cmd), NULL, 0);
    if(err)
      return err;
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    pgm->pgm_led(pgm, OFF);
 
    return 0;
  } else {
    avrdude_message(MSG_INFO, "%s called for a part that has no TPI\n", __func__);
    return -1;
  }
}

References __func__, avr_locate_mem(), avr_tpi_poll_nvmbsy(), avrdude_message(), AVRPART_HAS_TPI, cmd, programmer_t::cmd_tpi, avrpart::desc, avrpart::flags, MSG_INFO, OFF, avrmem::offset, ON, pgm, programmer_t::pgm_led, TPI_CMD_SOUT, TPI_CMD_SST, TPI_CMD_SSTPR, TPI_IOREG_NVMCMD, TPI_NVMCMD_CHIP_ERASE, and TPI_SIO_ADDR.

Here is the call graph for this function:

avr_tpi_poll_nvmbsy()

int avr_tpi_poll_nvmbsy

(

PROGRAMMER *

pgm

)

{
  unsigned char cmd;
  unsigned char res;
 
  cmd = TPI_CMD_SIN | TPI_SIO_ADDR(TPI_IOREG_NVMCSR);
  (void)pgm->cmd_tpi(pgm, &cmd, 1, &res, 1);
  return (res & TPI_IOREG_NVMCSR_NVMBSY);
}

References cmd, programmer_t::cmd_tpi, pgm, TPI_CMD_SIN, TPI_IOREG_NVMCSR, TPI_IOREG_NVMCSR_NVMBSY, TPI_SIO_ADDR, and void().

Referenced by avr_read(), avr_read_byte_default(), avr_tpi_chip_erase(), avr_write(), avr_write_byte_default(), and bitbang_chip_erase().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_tpi_program_enable()

int avr_tpi_program_enable	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		unsigned char	guard_time
	)

{
  int err, retry;
  unsigned char cmd[2];
  unsigned char response;
 
  if(p->flags & AVRPART_HAS_TPI) {
    /* set guard time */
    cmd[0] = (TPI_CMD_SSTCS | TPI_REG_TPIPCR);
    cmd[1] = guard_time;
 
    err = pgm->cmd_tpi(pgm, cmd, sizeof(cmd), NULL, 0);
    if(err)
      return err;
 
    /* read TPI ident reg */
    cmd[0] = (TPI_CMD_SLDCS | TPI_REG_TPIIR);
    err = pgm->cmd_tpi(pgm, cmd, 1, &response, sizeof(response));
    if (err || response != TPI_IDENT_CODE) {
      avrdude_message(MSG_INFO, "TPIIR not correct\n");
      return -1;
    }
 
    /* send SKEY command + SKEY */
    err = pgm->cmd_tpi(pgm, tpi_skey_cmd, sizeof(tpi_skey_cmd), NULL, 0);
    if(err)
      return err;
 
    /* check if device is ready */
    for(retry = 0; retry < 10; retry++)
    {
      cmd[0] =  (TPI_CMD_SLDCS | TPI_REG_TPISR);
      err = pgm->cmd_tpi(pgm, cmd, 1, &response, sizeof(response));
      if(err || !(response & TPI_REG_TPISR_NVMEN))
        continue;
 
      return 0;
    }
 
    avrdude_message(MSG_INFO, "Error enabling TPI external programming mode:");
    avrdude_message(MSG_INFO, "Target does not reply\n");
    return -1;
 
  } else {
    avrdude_message(MSG_INFO, "%s called for a part that has no TPI\n", __func__);
    return -1;
  }
}

References __func__, avrdude_message(), AVRPART_HAS_TPI, cmd, programmer_t::cmd_tpi, avrpart::flags, MSG_INFO, pgm, TPI_CMD_SLDCS, TPI_CMD_SSTCS, TPI_IDENT_CODE, TPI_REG_TPIIR, TPI_REG_TPIPCR, TPI_REG_TPISR, TPI_REG_TPISR_NVMEN, and tpi_skey_cmd.

Here is the call graph for this function:

avr_verify()

int avr_verify	(	AVRPART *	p,
		AVRPART *	v,
		char *	memtype,
		int	size
	)

{
  int i;
  unsigned char * buf1, * buf2;
  int vsize;
  AVRMEM * a, * b;
 
  a = avr_locate_mem(p, memtype);
  if (a == NULL) {
    avrdude_message(MSG_INFO, "avr_verify(): memory type \"%s\" not defined for part %s\n",
                    memtype, p->desc);
    return -1;
  }
 
  b = avr_locate_mem(v, memtype);
  if (b == NULL) {
    avrdude_message(MSG_INFO, "avr_verify(): memory type \"%s\" not defined for part %s\n",
                    memtype, v->desc);
    return -1;
  }
 
  buf1  = a->buf;
  buf2  = b->buf;
  vsize = a->size;
 
  if (vsize < size) {
    avrdude_message(MSG_INFO, "%s: WARNING: requested verification for %d bytes\n"
                    "%s%s memory region only contains %d bytes\n"
                    "%sOnly %d bytes will be verified.\n",
                    progname, size,
                    progbuf, memtype, vsize,
                    progbuf, vsize);
    size = vsize;
  }
 
  for (i=0; i<size; i++) {
    RETURN_IF_CANCEL();
    if ((b->tags[i] & TAG_ALLOCATED) != 0 &&
        buf1[i] != buf2[i]) {
      avrdude_message(MSG_INFO, "%s: verification error, first mismatch at byte 0x%04x\n"
                      "%s0x%02x != 0x%02x\n",
                      progname, i,
                      progbuf, buf1[i], buf2[i]);
      return -1;
    }
  }
 
  return size;
}

References avr_locate_mem(), avrdude_message(), avrpart::desc, MSG_INFO, progbuf, progname, RETURN_IF_CANCEL, and TAG_ALLOCATED.

Referenced by do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_write()

int avr_write	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		char *	memtype,
		int	size,
		int	auto_erase
	)

{
  int              rc;
  int              newpage, page_tainted, flush_page, do_write;
  int              wsize;
  unsigned int     i, lastaddr;
  unsigned char    data;
  int              werror;
  unsigned char    cmd[4];
  AVRMEM         * m;
 
  m = avr_locate_mem(p, memtype);
  if (m == NULL) {
    avrdude_message(MSG_INFO, "No \"%s\" memory for part %s\n",
            memtype, p->desc);
    return -1;
  }
 
  pgm->err_led(pgm, OFF);
 
  werror  = 0;
 
  wsize = m->size;
  if (size < wsize) {
    wsize = size;
  }
  else if (size > wsize) {
    avrdude_message(MSG_INFO, "%s: WARNING: %d bytes requested, but memory region is only %d"
                    "bytes\n"
                    "%sOnly %d bytes will actually be written\n",
                    progname, size, wsize,
                    progbuf, wsize);
  }
 
 
  if ((p->flags & AVRPART_HAS_TPI) && m->page_size != 0 &&
      pgm->cmd_tpi != NULL) {
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    /* setup for WORD_WRITE */
    avr_tpi_setup_rw(pgm, m, 0, TPI_NVMCMD_WORD_WRITE);
 
    /* make sure it's aligned to a word boundary */
    if (wsize & 0x1) {
      wsize++;
    }
 
    /* write words, low byte first */
    for (lastaddr = i = 0; i < (unsigned)wsize; i += 2) {
      RETURN_IF_CANCEL();
      if ((m->tags[i] & TAG_ALLOCATED) != 0 ||
          (m->tags[i + 1] & TAG_ALLOCATED) != 0) {
 
        if (lastaddr != i) {
          /* need to setup new address */
          avr_tpi_setup_rw(pgm, m, i, TPI_NVMCMD_WORD_WRITE);
          lastaddr = i;
        }
 
        cmd[0] = TPI_CMD_SST_PI;
        cmd[1] = m->buf[i];
        rc = pgm->cmd_tpi(pgm, cmd, 2, NULL, 0);
 
        cmd[1] = m->buf[i + 1];
        rc = pgm->cmd_tpi(pgm, cmd, 2, NULL, 0);
 
        lastaddr += 2;
 
        while (avr_tpi_poll_nvmbsy(pgm));
      }
      report_progress(i, wsize, NULL);
    }
    return i;
  }
 
  if (pgm->paged_write != NULL && m->page_size != 0) {
    /*
     * the programmer supports a paged mode write
     */
    int need_write, failure;
    unsigned int pageaddr;
    unsigned int npages, nwritten;
 
    /* quickly scan number of pages to be written to first */
    for (pageaddr = 0, npages = 0;
         pageaddr < (unsigned)wsize;
         pageaddr += m->page_size) {
      /* check whether this page must be written to */
      for (i = pageaddr;
           i < pageaddr + m->page_size;
           i++)
        if ((m->tags[i] & TAG_ALLOCATED) != 0) {
          npages++;
          break;
        }
    }
 
    for (pageaddr = 0, failure = 0, nwritten = 0;
         !failure && pageaddr < (unsigned)wsize;
         pageaddr += m->page_size) {
      RETURN_IF_CANCEL();
      /* check whether this page must be written to */
      for (i = pageaddr, need_write = 0;
           i < pageaddr + m->page_size;
           i++)
        if ((m->tags[i] & TAG_ALLOCATED) != 0) {
          need_write = 1;
          break;
        }
      if (need_write) {
        rc = 0;
        if (auto_erase)
          rc = pgm->page_erase(pgm, p, m, pageaddr);
        if (rc >= 0)
          rc = pgm->paged_write(pgm, p, m, m->page_size, pageaddr, m->page_size);
        if (rc < 0)
          /* paged write failed, fall back to byte-at-a-time write below */
          failure = 1;
      } else {
        avrdude_message(MSG_DEBUG, "%s: avr_write(): skipping page %u: no interesting data\n",
                        progname, pageaddr / m->page_size);
      }
      nwritten++;
      report_progress(nwritten, npages, NULL);
    }
    if (!failure)
      return wsize;
    /* else: fall back to byte-at-a-time write, for historical reasons */
  }
 
  if (pgm->write_setup) {
      pgm->write_setup(pgm, p, m);
  }
 
  newpage = 1;
  page_tainted = 0;
  flush_page = 0;
 
  for (i = 0; i < (unsigned)wsize; i++) {
    RETURN_IF_CANCEL();
    data = m->buf[i];
    report_progress(i, wsize, NULL);
 
    /*
     * Find out whether the write action must be invoked for this
     * byte.
     *
     * For non-paged memory, this only happens if TAG_ALLOCATED is
     * set for the byte.
     *
     * For paged memory, TAG_ALLOCATED also invokes the write
     * operation, which is actually a page buffer fill only.  This
     * "taints" the page, and upon encountering the last byte of each
     * tainted page, the write operation must also be invoked in order
     * to actually write the page buffer to memory.
     */
    do_write = (m->tags[i] & TAG_ALLOCATED) != 0;
    if (m->paged) {
      if (newpage) {
        page_tainted = do_write;
      } else {
        page_tainted |= do_write;
      }
      if (i % m->page_size == m->page_size - 1 ||
          i == wsize - 1) {
        /* last byte this page */
        flush_page = page_tainted;
        newpage = 1;
      } else {
        flush_page = newpage = 0;
      }
    }
 
    if (!do_write && !flush_page) {
      continue;
    }
 
    if (do_write) {
      rc = avr_write_byte(pgm, p, m, i, data);
      if (rc) {
        avrdude_message(MSG_INFO, " ***failed;  ");
        avrdude_message(MSG_INFO, "\n");
        pgm->err_led(pgm, ON);
        werror = 1;
      }
    }
 
    /*
     * check to see if it is time to flush the page with a page
     * write
     */
    if (flush_page) {
      rc = avr_write_page(pgm, p, m, i);
      if (rc) {
        avrdude_message(MSG_INFO, " *** page %d (addresses 0x%04x - 0x%04x) failed "
                        "to write\n",
                        i % m->page_size,
                        i - m->page_size + 1, i);
        avrdude_message(MSG_INFO, "\n");
        pgm->err_led(pgm, ON);
          werror = 1;
      }
    }
 
    if (werror) {
      /*
       * make sure the error led stay on if there was a previous write
       * error, otherwise it gets cleared in avr_write_byte()
       */
      pgm->err_led(pgm, ON);
      return -1;
    }
  }
 
  return i;
}

References avr_locate_mem(), avr_tpi_poll_nvmbsy(), avr_tpi_setup_rw(), avr_write_byte(), avr_write_page(), avrdude_message(), AVRPART_HAS_TPI, avrmem::buf, cmd, programmer_t::cmd_tpi, avrpart::desc, programmer_t::err_led, avrpart::flags, MSG_DEBUG, MSG_INFO, OFF, ON, programmer_t::page_erase, avrmem::page_size, avrmem::paged, programmer_t::paged_write, pgm, progbuf, progname, report_progress(), RETURN_IF_CANCEL, avrmem::size, TAG_ALLOCATED, avrmem::tags, TPI_CMD_SST_PI, TPI_NVMCMD_WORD_WRITE, and programmer_t::write_setup.

Referenced by do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_write_byte()

int avr_write_byte	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		AVRMEM *	mem,
		unsigned long	addr,
		unsigned char	data
	)

{
 
  unsigned char safemode_lfuse;
  unsigned char safemode_hfuse;
  unsigned char safemode_efuse;
  unsigned char safemode_fuse;
 
  /* If we write the fuses, then we need to tell safemode that they *should* change */
  safemode_memfuses(0, &safemode_lfuse, &safemode_hfuse, &safemode_efuse, &safemode_fuse);
 
  if (strcmp(mem->desc, "fuse")==0) {
      safemode_fuse = data;
  }
  if (strcmp(mem->desc, "lfuse")==0) {
      safemode_lfuse = data;
  }
  if (strcmp(mem->desc, "hfuse")==0) {
      safemode_hfuse = data;
  }
  if (strcmp(mem->desc, "efuse")==0) {
      safemode_efuse = data;
  }
  
  safemode_memfuses(1, &safemode_lfuse, &safemode_hfuse, &safemode_efuse, &safemode_fuse);
 
  return pgm->write_byte(pgm, p, mem, addr, data);
}

References avrmem::desc, pgm, safemode_memfuses(), and programmer_t::write_byte.

Referenced by avr_put_cycle_count(), avr_write(), cmd_write(), and safemode_writefuse().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_write_byte_default()

int avr_write_byte_default	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		AVRMEM *	mem,
		unsigned long	addr,
		unsigned char	data
	)

{
  unsigned char cmd[4];
  unsigned char res[4];
  unsigned char r;
  int ready;
  int tries;
  unsigned long start_time;
  unsigned long prog_time;
  unsigned char b;
  unsigned short caddr;
  OPCODE * writeop;
  int rc;
  int readok=0;
  struct timeval tv;
 
  if (pgm->cmd == NULL) {
    avrdude_message(MSG_INFO, "%s: Error: %s programmer uses avr_write_byte_default() but does not\n"
                    "provide a cmd() method.\n",
                    progname, pgm->type);
    return -1;
  }
 
  if (p->flags & AVRPART_HAS_TPI) {
    if (pgm->cmd_tpi == NULL) {
      avrdude_message(MSG_INFO, "%s: Error: %s programmer does not support TPI\n",
          progname, pgm->type);
      return -1;
    }
 
    if (strcmp(mem->desc, "flash") == 0) {
      avrdude_message(MSG_INFO, "Writing a byte to flash is not supported for %s\n", p->desc);
      return -1;
    } else if ((mem->offset + addr) & 1) {
      avrdude_message(MSG_INFO, "Writing a byte to an odd location is not supported for %s\n", p->desc);
      return -1;
    }
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    /* must erase fuse first */
    if (strcmp(mem->desc, "fuse") == 0) {
      /* setup for SECTION_ERASE (high byte) */
      avr_tpi_setup_rw(pgm, mem, addr | 1, TPI_NVMCMD_SECTION_ERASE);
 
      /* write dummy byte */
      cmd[0] = TPI_CMD_SST;
      cmd[1] = 0xFF;
      rc = pgm->cmd_tpi(pgm, cmd, 2, NULL, 0);
 
      while (avr_tpi_poll_nvmbsy(pgm));
    }
 
    /* setup for WORD_WRITE */
    avr_tpi_setup_rw(pgm, mem, addr, TPI_NVMCMD_WORD_WRITE);
 
    cmd[0] = TPI_CMD_SST_PI;
    cmd[1] = data;
    rc = pgm->cmd_tpi(pgm, cmd, 2, NULL, 0);
    /* dummy high byte to start WORD_WRITE */
    cmd[0] = TPI_CMD_SST_PI;
    cmd[1] = data;
    rc = pgm->cmd_tpi(pgm, cmd, 2, NULL, 0);
 
    while (avr_tpi_poll_nvmbsy(pgm));
 
    return 0;
  }
 
  if (!mem->paged &&
      (p->flags & AVRPART_IS_AT90S1200) == 0) {
    /* 
     * check to see if the write is necessary by reading the existing
     * value and only write if we are changing the value; we can't
     * use this optimization for paged addressing.
     *
     * For mysterious reasons, on the AT90S1200, this read operation
     * sometimes causes the high byte of the same word to be
     * programmed to the value of the low byte that has just been
     * programmed before.  Avoid that optimization on this device.
     */
    rc = pgm->read_byte(pgm, p, mem, addr, &b);
    if (rc != 0) {
      if (rc != -1) {
        return -2;
      }
      /*
       * the read operation is not support on this memory type
       */
    }
    else {
      readok = 1;
      if (b == data) {
        return 0;
      }
    }
  }
 
  /*
   * determine which memory opcode to use
   */
  if (mem->op[AVR_OP_WRITE_LO]) {
    if (addr & 0x01)
      writeop = mem->op[AVR_OP_WRITE_HI];
    else
      writeop = mem->op[AVR_OP_WRITE_LO];
    caddr = (unsigned short)(addr / 2);
  }
  else if (mem->paged && mem->op[AVR_OP_LOADPAGE_LO]) {
    if (addr & 0x01)
      writeop = mem->op[AVR_OP_LOADPAGE_HI];
    else
      writeop = mem->op[AVR_OP_LOADPAGE_LO];
    caddr = (unsigned short)(addr / 2);
  }
  else {
    writeop = mem->op[AVR_OP_WRITE];
    caddr = (unsigned short)addr;
  }
 
  if (writeop == NULL) {
#if DEBUG
    avrdude_message(MSG_INFO, "avr_write_byte(): write not supported for memory type \"%s\"\n",
                    mem->desc);
#endif
    return -1;
  }
 
 
  pgm->pgm_led(pgm, ON);
  pgm->err_led(pgm, OFF);
 
  memset(cmd, 0, sizeof(cmd));
 
  avr_set_bits(writeop, cmd);
  avr_set_addr(writeop, cmd, caddr);
  avr_set_input(writeop, cmd, data);
  pgm->cmd(pgm, cmd, res);
 
  if (mem->paged) {
    /*
     * in paged addressing, single bytes to be written to the memory
     * page complete immediately, we only need to delay when we commit
     * the whole page via the avr_write_page() routine.
     */
    pgm->pgm_led(pgm, OFF);
    return 0;
  }
 
  if (readok == 0) {
    /*
     * read operation not supported for this memory type, just wait
     * the max programming time and then return 
     */
    usleep(mem->max_write_delay); /* maximum write delay */
    pgm->pgm_led(pgm, OFF);
    return 0;
  }
 
  tries = 0;
  ready = 0;
  while (!ready) {
 
    if ((data == mem->readback[0]) ||
        (data == mem->readback[1])) {
      /* 
       * use an extra long delay when we happen to be writing values
       * used for polled data read-back.  In this case, polling
       * doesn't work, and we need to delay the worst case write time
       * specified for the chip.
       */
      usleep(mem->max_write_delay);
      rc = pgm->read_byte(pgm, p, mem, addr, &r);
      if (rc != 0) {
        pgm->pgm_led(pgm, OFF);
        pgm->err_led(pgm, OFF);
        return -5;
      }
    }
    else {
      gettimeofday (&tv, NULL);
      start_time = (tv.tv_sec * 1000000) + tv.tv_usec;
      do {
        /*
         * Do polling, but timeout after max_write_delay.
   */
        rc = pgm->read_byte(pgm, p, mem, addr, &r);
        if (rc != 0) {
          pgm->pgm_led(pgm, OFF);
          pgm->err_led(pgm, ON);
          return -4;
        }
        gettimeofday (&tv, NULL);
        prog_time = (tv.tv_sec * 1000000) + tv.tv_usec;
      } while ((r != data) &&
               ((prog_time - start_time) < (unsigned long)mem->max_write_delay));
    }
 
    /*
     * At this point we either have a valid readback or the
     * max_write_delay is expired.
     */
    
    if (r == data) {
      ready = 1;
    }
    else if (mem->pwroff_after_write) {
      /*
       * The device has been flagged as power-off after write to this
       * memory type.  The reason we don't just blindly follow the
       * flag is that the power-off advice may only apply to some
       * memory bits but not all.  We only actually power-off the
       * device if the data read back does not match what we wrote.
       */
      pgm->pgm_led(pgm, OFF);
      avrdude_message(MSG_INFO, "%s: this device must be powered off and back on to continue\n",
                      progname);
      if (pgm->pinno[PPI_AVR_VCC]) {
        avrdude_message(MSG_INFO, "%s: attempting to do this now ...\n", progname);
        pgm->powerdown(pgm);
        usleep(250000);
        rc = pgm->initialize(pgm, p);
        if (rc < 0) {
          avrdude_message(MSG_INFO, "%s: initialization failed, rc=%d\n", progname, rc);
          avrdude_message(MSG_INFO, "%s: can't re-initialize device after programming the "
                          "%s bits\n", progname, mem->desc);
          avrdude_message(MSG_INFO, "%s: you must manually power-down the device and restart\n"
                          "%s:   %s to continue.\n",
                          progname, progname, progname);
          return -3;
        }
        
        avrdude_message(MSG_INFO, "%s: device was successfully re-initialized\n",
                progname);
        return 0;
      }
    }
 
    tries++;
    if (!ready && tries > 5) {
      /*
       * we wrote the data, but after waiting for what should have
       * been plenty of time, the memory cell still doesn't match what
       * we wrote.  Indicate a write error.
       */
      pgm->pgm_led(pgm, OFF);
      pgm->err_led(pgm, ON);
      
      return -6;
    }
  }
 
  pgm->pgm_led(pgm, OFF);
  return 0;
}

References AVR_OP_LOADPAGE_HI, AVR_OP_LOADPAGE_LO, AVR_OP_WRITE, AVR_OP_WRITE_HI, AVR_OP_WRITE_LO, avr_set_addr(), avr_set_bits(), avr_set_input(), avr_tpi_poll_nvmbsy(), avr_tpi_setup_rw(), avrdude_message(), AVRPART_HAS_TPI, AVRPART_IS_AT90S1200, programmer_t::cmd, cmd, programmer_t::cmd_tpi, avrpart::desc, avrmem::desc, programmer_t::err_led, avrpart::flags, gettimeofday(), programmer_t::initialize, avrmem::max_write_delay, MSG_INFO, OFF, avrmem::offset, ON, avrmem::op, avrmem::paged, pgm, programmer_t::pgm_led, programmer_t::pinno, programmer_t::powerdown, PPI_AVR_VCC, progname, avrmem::pwroff_after_write, programmer_t::read_byte, avrmem::readback, TPI_CMD_SST, TPI_CMD_SST_PI, TPI_NVMCMD_SECTION_ERASE, TPI_NVMCMD_WORD_WRITE, programmer_t::type, and usleep().

Referenced by avr910_write_byte(), buspirate_bb_initpgm(), buspirate_initpgm(), serbb_initpgm(), and stk500_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

avr_write_page()

int avr_write_page	(	PROGRAMMER *	pgm,
		AVRPART *	p,
		AVRMEM *	mem,
		unsigned long	addr
	)

{
  unsigned char cmd[4];
  unsigned char res[4];
  OPCODE * wp, * lext;
 
  if (pgm->cmd == NULL) {
    avrdude_message(MSG_INFO, "%s: Error: %s programmer uses avr_write_page() but does not\n"
                    "provide a cmd() method.\n",
                    progname, pgm->type);
    return -1;
  }
 
  wp = mem->op[AVR_OP_WRITEPAGE];
  if (wp == NULL) {
    avrdude_message(MSG_INFO, "avr_write_page(): memory \"%s\" not configured for page writes\n",
                    mem->desc);
    return -1;
  }
 
  /*
   * if this memory is word-addressable, adjust the address
   * accordingly
   */
  if ((mem->op[AVR_OP_LOADPAGE_LO]) || (mem->op[AVR_OP_READ_LO]))
    addr = addr / 2;
 
  pgm->pgm_led(pgm, ON);
  pgm->err_led(pgm, OFF);
 
  /*
   * If this device has a "load extended address" command, issue it.
   */
  lext = mem->op[AVR_OP_LOAD_EXT_ADDR];
  if (lext != NULL) {
    memset(cmd, 0, sizeof(cmd));
 
    avr_set_bits(lext, cmd);
    avr_set_addr(lext, cmd, addr);
    pgm->cmd(pgm, cmd, res);
  }
 
  memset(cmd, 0, sizeof(cmd));
 
  avr_set_bits(wp, cmd);
  avr_set_addr(wp, cmd, addr);
  pgm->cmd(pgm, cmd, res);
 
  /*
   * since we don't know what voltage the target AVR is powered by, be
   * conservative and delay the max amount the spec says to wait
   */
  usleep(mem->max_write_delay);
 
  pgm->pgm_led(pgm, OFF);
  return 0;
}

References AVR_OP_LOAD_EXT_ADDR, AVR_OP_LOADPAGE_LO, AVR_OP_READ_LO, AVR_OP_WRITEPAGE, avr_set_addr(), avr_set_bits(), avrdude_message(), programmer_t::cmd, cmd, avrmem::desc, programmer_t::err_led, avrmem::max_write_delay, MSG_INFO, OFF, ON, avrmem::op, pgm, programmer_t::pgm_led, progname, programmer_t::type, and usleep().

Referenced by avr_write(), and buspirate_paged_write().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_config()

void cleanup_config

(

void

)

{
  ldestroy_cb(part_list, (void(*)(void*))avr_free_part);
  ldestroy_cb(programmers, (void(*)(void*))pgm_free);
  ldestroy_cb(string_list, (void(*)(void*))free_token);
  ldestroy_cb(number_list, (void(*)(void*))free_token);
}

References avr_free_part(), free_token(), ldestroy_cb(), number_list, part_list, pgm_free(), programmers, and string_list.

Referenced by cleanup_main().

Here is the call graph for this function:

Here is the caller graph for this function:

do_op()

int do_op	(	PROGRAMMER *	pgm,
		struct avrpart *	p,
		UPDATE *	upd,
		enum updateflags	flags
	)

{
  struct avrpart * v;
  AVRMEM * mem;
  int size, vsize;
  int rc;
 
  mem = avr_locate_mem(p, upd->memtype);
  if (mem == NULL) {
    avrdude_message(MSG_INFO, "\"%s\" memory type not defined for part \"%s\"\n",
            upd->memtype, p->desc);
    return -1;
  }
 
  if (upd->op == DEVICE_READ) {
    /*
     * read out the specified device memory and write it to a file
     */
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: reading %s memory:\n",
            progname, mem->desc);
    }
    report_progress(0,1,"Reading");
    rc = avr_read(pgm, p, upd->memtype, 0);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: failed to read all of %s memory, rc=%d\n",
              progname, mem->desc, rc);
      return -1;
    }
    report_progress(1,1,NULL);
    size = rc;
 
    if (quell_progress < 2) {
      if (rc == 0)
        avrdude_message(MSG_INFO, "%s: Flash is empty, resulting file has no contents.\n",
                        progname);
      avrdude_message(MSG_INFO, "%s: writing output file \"%s\"\n",
                      progname,
                      strcmp(upd->filename, "-")==0 ? "<stdout>" : upd->filename);
    }
    rc = fileio(FIO_WRITE, upd->filename, upd->format, p, upd->memtype, size, 0);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: write to file '%s' failed\n",
              progname, upd->filename);
      return -1;
    }
  }
  else if (upd->op == DEVICE_WRITE) {
    /*
     * write the selected device memory using data from a file; first
     * read the data from the specified file
     */
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: reading input file \"%s\"\n",
                      progname,
                      strcmp(upd->filename, "-")==0 ? "<stdin>" : upd->filename);
    }
    rc = fileio(FIO_READ, upd->filename, upd->format, p, upd->memtype, -1, upd->section);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: read from file '%s' failed\n",
              progname, upd->filename);
      return -1;
    }
    size = rc;
 
    /*
     * write the buffer contents to the selected memory type
     */
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: writing %s (%d bytes):\n",
            progname, mem->desc, size);
    }
 
  //Prusa3D bootloader progress on lcd
  if (strcmp(pgm->type, "Wiring") == 0)
  {
    if (pgm->set_upload_size != 0)
      pgm->set_upload_size(pgm, size);
  }
 
    if (!(flags & UF_NOWRITE)) {
      report_progress(0,1,"Writing");
      rc = avr_write(pgm, p, upd->memtype, size, (flags & UF_AUTO_ERASE) != 0);
      report_progress(1,1,NULL);
    }
    else {
      // /*
      //  * test mode, don't actually write to the chip, output the buffer
      //  * to stdout in intel hex instead
      //  */
      // rc = fileio(FIO_WRITE, "-", FMT_IHEX, p, upd->memtype, size, 0);
    }
 
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: failed to write %s memory, rc=%d\n",
              progname, mem->desc, rc);
      return -1;
    }
 
    vsize = rc;
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: %d bytes of %s written\n", progname,
            vsize, mem->desc);
    }
 
  }
  else if (upd->op == DEVICE_VERIFY) {
    /*
     * verify that the in memory file (p->mem[AVR_M_FLASH|AVR_M_EEPROM])
     * is the same as what is on the chip
     */
    pgm->vfy_led(pgm, ON);
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: verifying %s memory against %s:\n",
            progname, mem->desc, upd->filename);
 
      avrdude_message(MSG_INFO, "%s: load data %s data from input file %s:\n",
            progname, mem->desc, upd->filename);
    }
 
    rc = fileio(FIO_READ, upd->filename, upd->format, p, upd->memtype, -1, upd->section);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: read from file '%s' failed\n",
              progname, upd->filename);
      return -1;
    }
    v = avr_dup_part(p);
    size = rc;
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: input file %s contains %d bytes\n",
            progname, upd->filename, size);
      avrdude_message(MSG_INFO, "%s: reading on-chip %s data:\n",
            progname, mem->desc);
    }
 
    report_progress (0,1,"Reading");
    rc = avr_read(pgm, p, upd->memtype, v);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: failed to read all of %s memory, rc=%d\n",
              progname, mem->desc, rc);
      pgm->err_led(pgm, ON);
      return -1;
    }
    report_progress (1,1,NULL);
 
 
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: verifying ...\n", progname);
    }
    rc = avr_verify(p, v, upd->memtype, size);
    if (rc < 0) {
      avrdude_message(MSG_INFO, "%s: verification error; content mismatch\n",
              progname);
      pgm->err_led(pgm, ON);
      return -1;
    }
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: %d bytes of %s verified\n",
              progname, rc, mem->desc);
    }
 
    pgm->vfy_led(pgm, OFF);
  }
  else {
    avrdude_message(MSG_INFO, "%s: invalid update operation (%d) requested\n",
            progname, upd->op);
    return -1;
  }
 
  return 0;
}

References avr_dup_part(), avr_locate_mem(), avr_read(), avr_verify(), avr_write(), avrdude_message(), avrpart::desc, DEVICE_READ, DEVICE_VERIFY, DEVICE_WRITE, programmer_t::err_led, fileio(), update_t::filename, FIO_READ, FIO_WRITE, avrpart::flags, update_t::format, avrpart::mem, update_t::memtype, MSG_INFO, OFF, ON, update_t::op, pgm, progname, quell_progress, report_progress(), update_t::section, programmer_t::set_upload_size, programmer_t::type, UF_AUTO_ERASE, UF_NOWRITE, and programmer_t::vfy_led.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

dup_update()

UPDATE * dup_update

(

UPDATE *

upd

)

{
  UPDATE * u;
 
  u = (UPDATE *)malloc(sizeof(UPDATE));
  if (u == NULL) {
    // avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
    // exit(1);
    avrdude_oom("dup_update: out of memory\n");
  }
 
  memcpy(u, upd, sizeof(UPDATE));
 
  if (upd->memtype != NULL)
    u->memtype = strdup(upd->memtype);
  else
    u->memtype = NULL;
  u->filename = strdup(upd->filename);
 
  return u;
}

References avrdude_oom(), update_t::filename, malloc(), and update_t::memtype.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

fileio()

int fileio	(	int	op,
		char *	filename,
		FILEFMT	format,
		struct avrpart *	p,
		char *	memtype,
		int	size,
		unsigned	section
	)

{
  int rc;
  FILE * f;
  char * fname;
  struct fioparms fio;
  AVRMEM * mem;
  int using_stdio;
 
  mem = avr_locate_mem(p, memtype);
  if (mem == NULL) {
    avrdude_message(MSG_INFO, "fileio(): memory type \"%s\" not configured for device \"%s\"\n",
                    memtype, p->desc);
    return -1;
  }
 
  rc = fileio_setparms(op, &fio, p, mem);
  if (rc < 0)
    return -1;
 
  if (fio.op == FIO_READ)
    size = mem->size;
 
  if (fio.op == FIO_READ) {
    /* 0xff fill unspecified memory */
    memset(mem->buf, 0xff, size);
  }
  memset(mem->tags, 0, size);
 
  using_stdio = 0;
 
  if (strcmp(filename, "-")==0) {
    return -1;
    // Note: we don't want to read stdin or write to stdout as part of Slic3r
    // if (fio.op == FIO_READ) {
    //   fname = "<stdin>";
    //   f = stdin;
    // }
    // else {
    //   fname = "<stdout>";
    //   f = stdout;
    // }
    // using_stdio = 1;
  }
  else {
    fname = filename;
    f = NULL;
  }
 
  if (format == FMT_AUTO) {
    int format_detect;
 
    if (using_stdio) {
      avrdude_message(MSG_INFO, "%s: can't auto detect file format when using stdin/out.\n"
                      "%s  Please specify a file format and try again.\n",
                      progname, progbuf);
      return -1;
    }
 
    format_detect = fmt_autodetect(fname, section);
    if (format_detect < 0) {
      avrdude_message(MSG_INFO, "%s: can't determine file format for %s, specify explicitly\n",
                      progname, fname);
      return -1;
    }
    format = format_detect;
 
    if (quell_progress < 2) {
      avrdude_message(MSG_INFO, "%s: %s file %s auto detected as %s\n",
              progname, fio.iodesc, fname, fmtstr(format));
    }
  }
 
#if defined(WIN32NATIVE)
  /* Open Raw Binary and ELF format in binary mode on Windows.*/
  if(format == FMT_RBIN || format == FMT_ELF)
  {
      if(fio.op == FIO_READ)
      {
          fio.mode = "rb";
      }
      if(fio.op == FIO_WRITE)
      {
          fio.mode = "wb";
      }
  }
#endif
 
  if (format != FMT_IMM) {
    if (!using_stdio) {
      f = fopen_and_seek(fname, fio.mode, section);
      if (f == NULL) {
        avrdude_message(MSG_INFO, "%s: can't open %s file %s: %s\n",
                progname, fio.iodesc, fname, strerror(errno));
        return -1;
      }
    }
  }
 
  switch (format) {
    case FMT_IHEX:
      rc = fileio_ihex(&fio, fname, f, mem, size);
      break;
 
    case FMT_SREC:
      rc = fileio_srec(&fio, fname, f, mem, size);
      break;
 
    case FMT_RBIN:
      rc = fileio_rbin(&fio, fname, f, mem, size);
      break;
 
    case FMT_ELF:
#ifdef HAVE_LIBELF
      rc = fileio_elf(&fio, fname, f, mem, p, size);
#else
      avrdude_message(MSG_INFO, "%s: can't handle ELF file %s, "
                      "ELF file support was not compiled in\n",
                      progname, fname);
      rc = -1;
#endif
      break;
 
    case FMT_IMM:
      rc = fileio_imm(&fio, fname, f, mem, size);
      break;
 
    case FMT_HEX:
    case FMT_DEC:
    case FMT_OCT:
    case FMT_BIN:
      rc = fileio_num(&fio, fname, f, mem, size, format);
      break;
 
    default:
      avrdude_message(MSG_INFO, "%s: invalid %s file format: %d\n",
              progname, fio.iodesc, format);
      return -1;
  }
 
  if (rc > 0) {
    if ((op == FIO_READ) && (strcasecmp(mem->desc, "flash") == 0 ||
                             strcasecmp(mem->desc, "application") == 0 ||
                             strcasecmp(mem->desc, "apptable") == 0 ||
                             strcasecmp(mem->desc, "boot") == 0)) {
      /*
       * if we are reading flash, just mark the size as being the
       * highest non-0xff byte
       */
      rc = avr_mem_hiaddr(mem);
    }
  }
  if (format != FMT_IMM && !using_stdio) {
    fclose(f);
  }
 
  return rc;
}

References avr_locate_mem(), avr_mem_hiaddr(), avrdude_message(), avrpart::desc, fileio_ihex(), fileio_imm(), fileio_num(), fileio_rbin(), fileio_setparms(), fileio_srec(), FIO_READ, FIO_WRITE, FMT_AUTO, fmt_autodetect(), FMT_BIN, FMT_DEC, FMT_ELF, FMT_HEX, FMT_IHEX, FMT_IMM, FMT_OCT, FMT_RBIN, FMT_SREC, fmtstr(), fopen_and_seek(), fioparms::iodesc, fioparms::mode, MSG_INFO, fioparms::op, progbuf, progname, quell_progress, and strcasecmp.

Referenced by do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

fmtstr()

char * fmtstr

(

FILEFMT

format

)

{
  switch (format) {
    case FMT_AUTO : return "auto-detect"; break;
    case FMT_SREC : return "Motorola S-Record"; break;
    case FMT_IHEX : return "Intel Hex"; break;
    case FMT_RBIN : return "raw binary"; break;
    case FMT_ELF  : return "ELF"; break;
    default       : return "invalid format"; break;
  };
}

References FMT_AUTO, FMT_ELF, FMT_IHEX, FMT_RBIN, and FMT_SREC.

Referenced by fileio(), Slic3r::Utils::anonymous_namespace{Time.cpp}::process_format(), Slic3r::Utils::str2time(), and Slic3r::Utils::time2str().

Here is the caller graph for this function:

fopen_utf8()

FILE * fopen_utf8	(	const char *	filename,
		const char *	mode
	)

{
  // On Windows we need to convert the filename to UTF-16
#if defined(WIN32NATIVE)
  static wchar_t fname_buffer[PATH_MAX];
  static wchar_t mode_buffer[MAX_MODE_LEN];
 
  if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, fname_buffer, PATH_MAX) == 0) { return NULL; }
  if (MultiByteToWideChar(CP_UTF8, 0, mode, -1, mode_buffer, MAX_MODE_LEN) == 0) { return NULL; }
 
  return _wfopen(fname_buffer, mode_buffer);
#else
  return fopen(filename, mode);
#endif
}

References MAX_MODE_LEN, and PATH_MAX.

Referenced by fopen_and_seek(), and read_config().

Here is the caller graph for this function:

free_update()

void free_update

(

UPDATE *

upd

)

{
    if (u != NULL) {
  if(u->memtype != NULL) {
      free(u->memtype);
      u->memtype = NULL;
  }
  if(u->filename != NULL) {
      free(u->filename);
      u->filename = NULL;
  }
  free(u);
    }
}

References update_t::filename, free(), and update_t::memtype.

Referenced by cleanup_main().

Here is the call graph for this function:

Here is the caller graph for this function:

init_config()

int init_config

(

void

)

{
  string_list  = lcreat(NULL, 0);
  number_list  = lcreat(NULL, 0);
  current_prog = NULL;
  current_part = NULL;
  current_mem  = NULL;
  part_list    = lcreat(NULL, 0);
  programmers  = lcreat(NULL, 0);
 
  lineno       = 1;
  infile       = NULL;
 
  return 0;
}

References current_mem, current_part, current_prog, infile, lcreat(), lineno, number_list, part_list, programmers, and string_list.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

ladd()

int ladd	(	LISTID	lid,
		void *	p
	)

{
  LIST * l;
  LISTNODE *lnptr;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  lnptr = get_listnode(l);
  if (lnptr==NULL) {
#ifdef BOS
    breakpoint();
#endif
    return -1;
  }
 
  CKMAGIC(lnptr);
 
  lnptr->data = p;
 
  if (l->top == NULL) {
    l->top = lnptr;
    l->bottom = lnptr;
    lnptr->next = NULL;
    lnptr->prev = NULL;
  }
  else {
    lnptr->prev = l->bottom;
    lnptr->next = NULL;
    l->bottom->next = lnptr;
    l->bottom = lnptr;
  }
  l->num++;
 
  CKLMAGIC(l);
 
  return 0;
}

References LIST::bottom, CKLMAGIC, CKMAGIC, LISTNODE::data, get_listnode(), LISTNODE::next, LIST::num, LISTNODE::prev, and LIST::top.

Referenced by avr_dup_part(), avrdude_main(), insert_ln(), jtag3_open_common(), laddo(), laddu(), lcat(), lins_n(), pgm_dup(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

laddo()

int laddo	(	LISTID	lid,
		void *	p,
		int(*)(const void *p1, const void *p2)	compare,
		LNODEID *	firstdup
	)

{
  LIST * l;
  LISTNODE * ln;
  int dup, cmp;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  dup = 0;
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    cmp = compare(p,ln->data);
    if (cmp == 0) {
      dup = 1;
      if (firstdup)
  *firstdup = ln;
    }
    if (cmp < 0) {
      insert_ln(l,ln,p);
      CKLMAGIC(l);
      return dup;
    }
    else {
      ln = ln->next;
    }
  }
 
  ladd(l,p);
 
  CKLMAGIC(l);
 
  return dup;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, insert_ln(), ladd(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

laddu()

int laddu	(	LISTID	lid,
		void *	p,
		int(*)(const void *p1, const void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * ln;
  int cmp;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    cmp = compare(p,ln->data);
    if (cmp == 0) {
      CKLMAGIC(l);
      return 0;
    }
    if (cmp < 0) {
      insert_ln(l,ln,p);
      CKLMAGIC(l);
      return 1;
    }
    else {
      ln = ln->next;
    }
  }
 
  ladd(l,p);
 
  CKLMAGIC(l);
 
  return 1;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, insert_ln(), ladd(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lcat()

LISTID lcat	(	LISTID	lid1,
		LISTID	lid2
	)

{
  CKLMAGIC(((LIST *)lid1));
  CKLMAGIC(((LIST *)lid2));
  while (lsize(lid2)) {
    ladd ( lid1, lrmv_n(lid2,1) );
  }
 
  CKLMAGIC(((LIST *)lid1));
  CKLMAGIC(((LIST *)lid2));
 
  return lid1;
}

References CKLMAGIC, ladd(), lrmv_n(), and lsize().

Here is the call graph for this function:

lcreat()

LISTID lcreat	(	void *	liststruct,
		int	poolsize
	)

{
  LIST * l;
 
  if (liststruct == NULL) {
    /*--------------------------------------------------
      allocate memory for the list itself
      --------------------------------------------------*/
    l = (LIST *) MALLOC ( sizeof(LIST), "list struct" );
    if (l == NULL) {
      return NULL;
    }
    l->free_on_close = 1;
  }
  else {
    /*-----------------------------------------------------------------
      use the memory given to us for the list structure
      -----------------------------------------------------------------*/
    l = liststruct;
    l->free_on_close = 0;
  }
 
  /*--------------------------------------------------
  |  initialize the list
   --------------------------------------------------*/
#if CHECK_MAGIC
  l->magic1 = MAGIC;
  l->magic2 = MAGIC;
#endif
  l->top = NULL;
  l->bottom = NULL;
  l->num = 0;
 
  if (elements == 0) {
    l->poolsize = DEFAULT_POOLSIZE;
  }
  else {
    l->poolsize = (short)(elements*sizeof(LISTNODE)+sizeof(NODEPOOL));
  }
 
  l->n_ln_pool = (l->poolsize-sizeof(NODEPOOL))/sizeof(LISTNODE);
 
  if (l->n_ln_pool < 5) {
    if (!liststruct) {
      FREE(l);
    }
    return NULL;
  }
 
  l->np_top = NULL;
  l->np_bottom = NULL;
  l->next_ln = NULL;
 
  CKLMAGIC(l);
 
  return (LISTID)l;
}

References LIST::bottom, CKLMAGIC, DEFAULT_POOLSIZE, FREE, LIST::free_on_close, MAGIC, MALLOC, LIST::n_ln_pool, LIST::next_ln, LIST::np_bottom, LIST::np_top, LIST::num, LIST::poolsize, and LIST::top.

Referenced by avr_new_part(), avrdude_main(), init_config(), pgm_dup(), pgm_new(), and yyparse().

Here is the caller graph for this function:

ldata()

void * ldata

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->data;
}

References CKMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), pgm_dup(), sort_programmer_compare(), stk500_close(), stk500_initialize(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

Here is the caller graph for this function:

ldestroy()

void ldestroy

(

LISTID

lid

)

{
  LIST * l;
  NODEPOOL * p1, * p2;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  /*--------------------------------------------------
  |  free each node pool - start at the first node
  |  pool and free each successive until there are
  |  no more.
   --------------------------------------------------*/
  p1 = l->np_top;
  while (p1 != NULL) {
    p2 = p1->chain_next;
    FREE(p1);
    p1 = p2;
  }
 
  /*--------------------------------------------------
  |  now free the memory occupied by the list itself
   --------------------------------------------------*/
  if (l->free_on_close) {
    FREE ( l );
  }
}

References NODEPOOL::chain_next, CKLMAGIC, FREE, LIST::free_on_close, and LIST::np_top.

Referenced by cleanup_main(), and ldestroy_cb().

Here is the caller graph for this function:

ldestroy_cb()

void ldestroy_cb	(	LISTID	lid,
		void(*)(void *data_ptr)	ucleanup
	)

{
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
  while (ln != NULL) {
    ucleanup ( ln->data );
    ln = ln->next;
  }
 
  ldestroy ( l );
}

References CKLMAGIC, LISTNODE::data, ldestroy(), LISTNODE::next, and LIST::top.

Referenced by avr_free_part(), cleanup_config(), cleanup_main(), pgm_free(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lfirst()

LNODEID lfirst

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->top;
}

References CKLMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), pgm_dup(), sort_programmer_compare(), stk500_close(), stk500_initialize(), stk500_open(), stk500_paged_load(), stk500_paged_write(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

Here is the caller graph for this function:

lget()

void * lget

(

LISTID

lid

)

{
  LIST * l;
  LISTNODE * p;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  p = l->bottom;
 
  if (p == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return p->data;
  }
}

References LIST::bottom, CKLMAGIC, and LISTNODE::data.

lget_ln()

LNODEID lget_ln	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)lsize(l))) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (i!=n) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  CKLMAGIC(l);
  return (LNODEID)ln;
}

References CKLMAGIC, CKMAGIC, lsize(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lget_n()

void * lget_n	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)lsize(l))) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (ln) {
    CKLMAGIC(l);
    return ln->data;
  }
  else {
    CKLMAGIC(l);
    return NULL;
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, lsize(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lins_ln()

int lins_ln	(	LISTID	lid,
		LNODEID	lnid,
		void *	data_ptr
	)

{
  LIST * l;
  LISTNODE * ln;
  LISTNODE * ln_ptr;
 
  l = (LIST *)lid;
  ln = (LISTNODE *)lnid;
 
  CKLMAGIC(l);
 
  CKMAGIC(ln);
 
  /*-----------------------------------------
  |  validate that ln is indeed in the list
   -----------------------------------------*/
  ln_ptr = l->top;
  while ((ln_ptr!=NULL)&&(ln_ptr!=ln)) {
    CKMAGIC(ln_ptr);
    ln_ptr = ln_ptr->next;
  }
 
  if (ln_ptr == NULL) {
    CKLMAGIC(l);
    return -1;
  }
 
  CKLMAGIC(l);
 
  /*--------------------------------
  |  insert the data into the list
   --------------------------------*/
  return insert_ln ( l, ln, data_ptr );
}

References CKLMAGIC, CKMAGIC, insert_ln(), LISTNODE::next, and LIST::top.

Here is the call graph for this function:

lins_n()

int lins_n	(	LISTID	lid,
		void *	d,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)(l->num+1))) {
    return -1;
  }
 
  if (l->num == 0) {
    return ladd ( lid, data_ptr );
  }
 
  /*----------------------------------
  |  locate the nth item in the list
   ----------------------------------*/
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (!ln) {
    CKLMAGIC(l);
    return -1;
  }
 
  CKLMAGIC(l);
 
  /*-----------------------------------------
  |  insert before the nth item in the list
   -----------------------------------------*/
  return insert_ln ( l, ln, data_ptr );
}

References CKLMAGIC, CKMAGIC, insert_ln(), ladd(), LISTNODE::next, LIST::num, and LIST::top.

Here is the call graph for this function:

llast()

LNODEID llast

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->bottom;
}

References CKLMAGIC.

lnext()

LNODEID lnext

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->next;
}

References CKMAGIC.

Referenced by avr910_parseextparms(), avr_display(), avr_dup_part(), avr_initmem(), avr_locate_mem(), avrdude_main(), buspirate_parseextparms(), Slic3r::connect_monotonic_regions(), jtag3_initialize(), jtag3_open_common(), jtag3_parseextparms(), jtagmkI_set_devdescr(), jtagmkII_parseextparms(), jtagmkII_set_devdescr(), jtagmkII_set_xmega_params(), locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), locate_programmer(), lprint(), pgm_dup(), Slic3r::smooth_compensation_banded(), stk500hv_initialize(), stk500v2_initialize(), walk_avrparts(), walk_programmers(), wiring_parseextparms(), and yyparse().

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:

locate_programmer()

PROGRAMMER * locate_programmer	(	LISTID	programmers,
		const char *	configid
	)

{
  LNODEID ln1, ln2;
  PROGRAMMER * p = NULL;
  const char * id;
  int found;
 
  found = 0;
 
  for (ln1=lfirst(programmers); ln1 && !found; ln1=lnext(ln1)) {
    p = ldata(ln1);
    for (ln2=lfirst(p->id); ln2 && !found; ln2=lnext(ln2)) {
      id = ldata(ln2);
      if (strcasecmp(configid, id) == 0)
        found = 1;
    }
  }
 
  if (found)
    return p;
 
  return NULL;
}

References programmer_t::id, ldata(), lfirst(), lnext(), programmers, 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_programmer_type()

const PROGRAMMER_TYPE * locate_programmer_type

(

const char *

id

)

{
  const PROGRAMMER_TYPE * p = NULL;
  int i;
  int found;
 
  found = 0;
 
  for (i = 0; i < sizeof(programmers_types)/sizeof(programmers_types[0]) && !found; i++) {
    p = &(programmers_types[i]);
    if (strcasecmp(id, p->id) == 0)
        found = 1;
  }
 
  if (found)
    return p;
 
  return NULL;
}

References programmer_type_t::id, programmers_types, and strcasecmp.

Referenced by yyparse().

Here is the caller graph for this function:

lprev()

LNODEID lprev

(

LNODEID

lnid

)

{
  CKMAGIC(((LISTNODE *)lnid));
  return ((LISTNODE *)lnid)->prev;
}

References CKMAGIC.

Referenced by Slic3r::take_ccw_limited(), and Slic3r::take_cw_limited().

Here is the caller graph for this function:

lprint()

int lprint	(	FILE *	f,
		LISTID	lid
	)

{
  LIST * l;
  LISTNODE * ln;
  NODEPOOL * np;
  int count;
 
  l = (LIST *)lid;
 
  fprintf ( f, "list id %p internal data structures:\n", 
            lid );
#if CHECK_MAGIC
  if ((l->magic1 != MAGIC) || (l->magic2 != MAGIC)) {
    fprintf ( f, "  *** WARNING: LIST MAGIC IS CORRUPT ***\n" );
  }
  fprintf ( f, 
            "  magic1=0x%08x\n"
            "  magic2=0x%08x\n",
            l->magic1, l->magic2 );
#endif
  fprintf ( f, "   num f pool n_ln        top     bottom    next_ln     np_top  np_bottom\n" );
  fprintf ( f, "  ---- - ---- ---- ---------- ---------- ---------- ---------- ----------\n" );
  fprintf ( f, "  %4d %1d %4d %4d %10p %10p %10p %10p %10p\n",
            l->num, l->free_on_close, l->poolsize, l->n_ln_pool, 
            l->top, l->bottom,
            l->next_ln, l->np_top, l->np_bottom );
  
 
  fprintf ( f, 
            "  node pools:\n"
            "     idx         np     magic1       next       prev     magic2\n"
            "    ---- ---------- ---------- ---------- ---------- ----------\n" );
  count = 0;
  np = l->np_top;
  while (np != NULL) {
    count++;
    fprintf ( f, "    %4d %10p 0x%08x %10p %10p 0x%08x\n", 
              count, np, 
#if CHECK_MAGIC
              np->magic1, 
#else
              0,
#endif
              np->chain_next, np->chain_prev, 
#if CHECK_MAGIC
              np->magic2
#else
              0
#endif
      );
    np = np->chain_next;
  }
 
  if (f) {
    fprintf ( f, 
              "  list elements:\n"
              "       n         ln     magic1       next       prev       data     magic2\n"
              "    ---- ---------- ---------- ---------- ---------- ---------- ----------\n" );
    count = 0;
    ln = l->top;
    while (ln != NULL) {
      count++;
      fprintf ( f, "    %4d %10p %10x %10p %10p %10p %10x\n", 
                count, ln, 
#if CHECK_MAGIC
                ln->magic1,
#else
                0,
#endif
                ln->next, ln->prev, ln->data, 
#if CHECK_MAGIC
                ln->magic2
#else
                0
#endif
        );
      ln = lnext(ln);
    }
    if (count != l->num) {
      fprintf ( f, 
                "  *** list count is not correct\n"
                "  *** list id indicates %d, counted items = %d\n", 
                l->num, count );
    }
  }
 
  return 0;
}

References LIST::bottom, NODEPOOL::chain_next, NODEPOOL::chain_prev, CHECK_MAGIC, LISTNODE::data, LIST::free_on_close, lnext(), MAGIC, LIST::n_ln_pool, LISTNODE::next, LIST::next_ln, LIST::np_bottom, LIST::np_top, LIST::num, LIST::poolsize, LISTNODE::prev, and LIST::top.

Here is the call graph for this function:

lrmv()

void * lrmv

(

LISTID

lid

)

{
  LIST * l;
  LISTNODE * p;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  p = l->bottom;
 
  if (p == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, p );
  }
}

References LIST::bottom, CKLMAGIC, and remove_ln().

Here is the call graph for this function:

lrmv_d()

void * lrmv_d	(	LISTID	lid,
		void *	data_ptr
	)

{
  LIST * l;
  LISTNODE * ln;
  int i;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  i = 0;
  ln = l->top;
  while (ln && (ln->data != data_ptr)) {
    i++;
    CKMAGIC(ln);
    ln = ln->next;
  }
 
  if (ln == NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, ln );
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, remove_ln(), and LIST::top.

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lrmv_ln()

void * lrmv_ln	(	LISTID	lid,
		LNODEID	lnid
	)

{
  LIST * l;
  LISTNODE * ln;
  LISTNODE * p;
 
  l = (LIST *)lid;
  ln = (LISTNODE *)lnid;
 
  CKLMAGIC(l);
 
  CKMAGIC(ln);
 
  p = l->top;
  while ((p!=NULL)&&(p!=ln)) {
    CKMAGIC(p);
    p = p->next;
  }
  
  if (p==NULL) {
    CKLMAGIC(l);
    return NULL;
  }
  else {
    CKLMAGIC(l);
    return remove_ln ( l, p );
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::next, remove_ln(), and LIST::top.

Here is the call graph for this function:

lrmv_n()

void * lrmv_n	(	LISTID	lid,
		unsigned int	n
	)

{
  int i;
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  if ((n < 1) || (n > (unsigned)l->num)) {
    return NULL;
  }
 
  ln = l->top;
  i = 1;
  while (ln && (i!=n)) {
    CKMAGIC(ln);
    ln = ln->next;
    i++;
  }
 
  if (ln) {
    CKLMAGIC(l);
    return remove_ln ( l, ln );
  }
  else {
    CKLMAGIC(l);
    return NULL;
  }
}

References CKLMAGIC, CKMAGIC, LISTNODE::next, LIST::num, remove_ln(), and LIST::top.

Referenced by assign_pin_list(), lcat(), parse_cmdbits(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

lsize()

int lsize

(

LISTID

lid

)

{
  CKLMAGIC(((LIST *)lid));
  return ((LIST *)lid)->num;
}

References CKLMAGIC.

Referenced by assign_pin_list(), avrdude_main(), lcat(), lget_ln(), lget_n(), parse_cmdbits(), and yyparse().

Here is the caller graph for this function:

lsort()

void lsort	(	LISTID	lid,
		int(*)(void *p1, void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * lt; /* this */
  LISTNODE * ln; /* next */
  int unsorted = 1;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  while(unsorted){
    lt = l->top;
    unsorted = 0;
    while (lt!=NULL) {
      CKMAGIC(lt);
      ln = lt->next;
      if (ln!= NULL && compare(lt->data,ln->data) > 0) {
        void * p = ln->data;
        ln->data = lt->data;
        lt->data = p;
        unsorted = 1;
      }
      lt = ln;
    }
  }
 
  CKLMAGIC(l);
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, and LIST::top.

Referenced by sort_avrparts(), and sort_programmers().

Here is the caller graph for this function:

lsrch()

void * lsrch	(	LISTID	lid,
		void *	p,
		int(*)(void *p1, void *p2)	compare
	)

{
  LIST * l;
  LISTNODE * ln;
 
  l = (LIST *)lid;
 
  CKLMAGIC(l);
 
  ln = l->top;
 
  while (ln!=NULL) {
    CKMAGIC(ln);
    if (compare(p,ln->data) == 0) {
      CKLMAGIC(l);
      return ln->data;
    }
    else {
      ln = ln->next;
    }
  }
 
  CKLMAGIC(l);
  return NULL;
}

References CKLMAGIC, CKMAGIC, LISTNODE::data, LISTNODE::next, and LIST::top.

new_update()

UPDATE * new_update	(	int	op,
		char *	memtype,
		int	filefmt,
		char *	filename,
		unsigned	section
	)

{
  UPDATE * u;
 
  u = (UPDATE *)malloc(sizeof(UPDATE));
  if (u == NULL) {
    // avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
    // exit(1);
    avrdude_oom("new_update: out of memory\n");
  }
 
  u->memtype = strdup(memtype);
  u->filename = strdup(filename);
  u->op = op;
  u->format = filefmt;
  u->section = section;
 
  return u;
}

References avrdude_oom(), update_t::filename, update_t::format, malloc(), update_t::memtype, update_t::op, and update_t::section.

Referenced by Slic3r::PresetUpdater::priv::get_config_updates().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_op()

UPDATE * parse_op

(

char *

s

)

{
  char buf[1024];
  char * p, * cp, c;
  UPDATE * upd;
  int i;
  size_t fnlen;
 
  upd = (UPDATE *)malloc(sizeof(UPDATE));
  if (upd == NULL) {
    // avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
    // exit(1);
    avrdude_oom("parse_op: out of memory\n");
  }
 
  i = 0;
  p = s;
  while ((i < (sizeof(buf)-1) && *p && (*p != ':')))
    buf[i++] = *p++;
  buf[i] = 0;
 
  if (*p != ':') {
    upd->memtype = NULL;        /* default memtype, "flash", or "application" */
    upd->op = DEVICE_WRITE;
    upd->filename = (char *)malloc(strlen(buf) + 1);
    if (upd->filename == NULL) {
        // avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
        // exit(1);
        avrdude_oom("parse_op: out of memory\n");
    }
    strcpy(upd->filename, buf);
    upd->format = FMT_AUTO;
    return upd;
  }
 
  upd->memtype = (char *)malloc(strlen(buf)+1);
  if (upd->memtype == NULL) {
    // avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
    // exit(1);
    avrdude_oom("parse_op: out of memory\n");
  }
  strcpy(upd->memtype, buf);
 
  p++;
  if (*p == 'r') {
    upd->op = DEVICE_READ;
  }
  else if (*p == 'w') {
    upd->op = DEVICE_WRITE;
  }
  else if (*p == 'v') {
    upd->op = DEVICE_VERIFY;
  }
  else {
    avrdude_message(MSG_INFO, "%s: invalid I/O mode '%c' in update specification\n",
            progname, *p);
    avrdude_message(MSG_INFO, "  allowed values are:\n"
                    "    r = read device\n"
                    "    w = write device\n"
                    "    v = verify device\n");
    free(upd->memtype);
    free(upd);
    return NULL;
  }
 
  p++;
 
  if (*p != ':') {
    avrdude_message(MSG_INFO, "%s: invalid update specification\n", progname);
    free(upd->memtype);
    free(upd);
    return NULL;
  }
 
  p++;
 
  // Extension: Parse file section number
  unsigned section = 0;
 
  for (; *p != ':'; p++) {
    if (*p >= '0' && *p <= '9') {
      section *= 10;
      section += *p - 0x30;
    } else {
      avrdude_message(MSG_INFO, "%s: invalid update specification: <section> is not a number\n", progname);
      free(upd->memtype);
      free(upd);
      return NULL;
    }
  }
 
  upd->section = section;
  p++;
 
  /*
   * Now, parse the filename component.  Instead of looking for the
   * leftmost possible colon delimiter, we look for the rightmost one.
   * If we found one, we do have a trailing :format specifier, and
   * process it.  Otherwise, the remainder of the string is our file
   * name component.  That way, the file name itself is allowed to
   * contain a colon itself (e. g. C:/some/file.hex), except the
   * optional format specifier becomes mandatory then.
   */
  cp = p;
  p = strrchr(cp, ':');
  if (p == NULL) {
    upd->format = FMT_AUTO;
    fnlen = strlen(cp);
    upd->filename = (char *)malloc(fnlen + 1);
  } else {
    fnlen = p - cp;
    upd->filename = (char *)malloc(fnlen +1);
    c = *++p;
    if (c && p[1])
      /* More than one char - force failure below. */
      c = '?';
    switch (c) {
      case 'a': upd->format = FMT_AUTO; break;
      case 's': upd->format = FMT_SREC; break;
      case 'i': upd->format = FMT_IHEX; break;
      case 'r': upd->format = FMT_RBIN; break;
      case 'e': upd->format = FMT_ELF; break;
      case 'm': upd->format = FMT_IMM; break;
      case 'b': upd->format = FMT_BIN; break;
      case 'd': upd->format = FMT_DEC; break;
      case 'h': upd->format = FMT_HEX; break;
      case 'o': upd->format = FMT_OCT; break;
      default:
        avrdude_message(MSG_INFO, "%s: invalid file format '%s' in update specifier\n",
                progname, p);
        free(upd->memtype);
        free(upd);
        return NULL;
    }
  }
 
  if (upd->filename == NULL) {
    avrdude_message(MSG_INFO, "%s: out of memory\n", progname);
    free(upd->memtype);
    free(upd);
    return NULL;
  }
  memcpy(upd->filename, cp, fnlen);
  upd->filename[fnlen] = 0;
 
  return upd;
}

References avrdude_message(), avrdude_oom(), DEVICE_READ, DEVICE_VERIFY, DEVICE_WRITE, update_t::filename, FMT_AUTO, FMT_BIN, FMT_DEC, FMT_ELF, FMT_HEX, FMT_IHEX, FMT_IMM, FMT_OCT, FMT_RBIN, FMT_SREC, update_t::format, free(), malloc(), update_t::memtype, MSG_INFO, update_t::op, progname, and update_t::section.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

pgm_display_generic()

void pgm_display_generic	(	PROGRAMMER *	pgm,
		const char *	p
	)

{
  pgm_display_generic_mask(pgm, p, SHOW_ALL_PINS);
}

References pgm, pgm_display_generic_mask(), and SHOW_ALL_PINS.

Here is the call graph for this function:

pgm_display_generic_mask()

void pgm_display_generic_mask	(	PROGRAMMER *	pgm,
		const char *	p,
		unsigned int	show
	)

{
  if(show & (1<<PPI_AVR_VCC)) 
    avrdude_message(MSG_INFO, "%s  VCC     = %s\n", p, pins_to_str(&pgm->pin[PPI_AVR_VCC]));
  if(show & (1<<PPI_AVR_BUFF))
    avrdude_message(MSG_INFO, "%s  BUFF    = %s\n", p, pins_to_str(&pgm->pin[PPI_AVR_BUFF]));
  if(show & (1<<PIN_AVR_RESET))
    avrdude_message(MSG_INFO, "%s  RESET   = %s\n", p, pins_to_str(&pgm->pin[PIN_AVR_RESET]));
  if(show & (1<<PIN_AVR_SCK))
    avrdude_message(MSG_INFO, "%s  SCK     = %s\n", p, pins_to_str(&pgm->pin[PIN_AVR_SCK]));
  if(show & (1<<PIN_AVR_MOSI))
    avrdude_message(MSG_INFO, "%s  MOSI    = %s\n", p, pins_to_str(&pgm->pin[PIN_AVR_MOSI]));
  if(show & (1<<PIN_AVR_MISO))
    avrdude_message(MSG_INFO, "%s  MISO    = %s\n", p, pins_to_str(&pgm->pin[PIN_AVR_MISO]));
  if(show & (1<<PIN_LED_ERR))
    avrdude_message(MSG_INFO, "%s  ERR LED = %s\n", p, pins_to_str(&pgm->pin[PIN_LED_ERR]));
  if(show & (1<<PIN_LED_RDY))
    avrdude_message(MSG_INFO, "%s  RDY LED = %s\n", p, pins_to_str(&pgm->pin[PIN_LED_RDY]));
  if(show & (1<<PIN_LED_PGM))
    avrdude_message(MSG_INFO, "%s  PGM LED = %s\n", p, pins_to_str(&pgm->pin[PIN_LED_PGM]));
  if(show & (1<<PIN_LED_VFY))
    avrdude_message(MSG_INFO, "%s  VFY LED = %s\n", p, pins_to_str(&pgm->pin[PIN_LED_VFY]));
}

References avrdude_message(), MSG_INFO, pgm, programmer_t::pin, PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_RESET, PIN_AVR_SCK, PIN_LED_ERR, PIN_LED_PGM, PIN_LED_RDY, PIN_LED_VFY, pins_to_str(), PPI_AVR_BUFF, and PPI_AVR_VCC.

Referenced by pgm_display_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

pgm_dup()

PROGRAMMER * pgm_dup

(

const PROGRAMMER *const

src

)

{
  PROGRAMMER * pgm;
  LNODEID ln;
 
  pgm = (PROGRAMMER *)malloc(sizeof(*pgm));
  if (pgm == NULL) {
    avrdude_message(MSG_INFO, "%s: out of memory allocating programmer structure\n",
            progname);
    return NULL;
  }
 
  memcpy(pgm, src, sizeof(*pgm));
 
  pgm->id = lcreat(NULL, 0);
  pgm->usbpid = lcreat(NULL, 0);
 
  for (ln = lfirst(src->usbpid); ln; ln = lnext(ln)) {
    int *ip = malloc(sizeof(int));
    if (ip == NULL) {
      // avrdude_message(MSG_INFO, "%s: out of memory allocating programmer structure\n",
      //         progname);
      // exit(1);
      avrdude_oom("out of memory allocating programmer structure\n");
    }
    *ip = *(int *) ldata(ln);
    ladd(pgm->usbpid, ip);
  }
 
  return pgm;
}

References avrdude_message(), avrdude_oom(), programmer_t::id, ladd(), lcreat(), ldata(), lfirst(), lnext(), malloc(), MSG_INFO, pgm, progname, and programmer_t::usbpid.

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

pgm_fill_old_pins()

int pgm_fill_old_pins

(

struct programmer_t *const

pgm

)

Convert for given programmer new pin definitions to old pin definitions.

Parameters

[in,out]

pgm

programmer whose pins shall be converted.

                                                       {
 
  if (pin_fill_old_pinlist(&(pgm->pin[PPI_AVR_VCC]),  &(pgm->pinno[PPI_AVR_VCC])) < 0)
    return -1;
  if (pin_fill_old_pinlist(&(pgm->pin[PPI_AVR_BUFF]), &(pgm->pinno[PPI_AVR_BUFF])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_AVR_RESET]), &(pgm->pinno[PIN_AVR_RESET])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_AVR_SCK]),  &(pgm->pinno[PIN_AVR_SCK])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_AVR_MOSI]), &(pgm->pinno[PIN_AVR_MOSI])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_AVR_MISO]), &(pgm->pinno[PIN_AVR_MISO])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_LED_ERR]),  &(pgm->pinno[PIN_LED_ERR])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_LED_RDY]),  &(pgm->pinno[PIN_LED_RDY])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_LED_PGM]),  &(pgm->pinno[PIN_LED_PGM])) < 0)
    return -1;
  if (pin_fill_old_pinno(&(pgm->pin[PIN_LED_VFY]),  &(pgm->pinno[PIN_LED_VFY])) < 0)
    return -1;
 
  return 0;
}

References pgm, programmer_t::pin, PIN_AVR_MISO, PIN_AVR_MOSI, PIN_AVR_RESET, PIN_AVR_SCK, pin_fill_old_pinlist(), pin_fill_old_pinno(), PIN_LED_ERR, PIN_LED_PGM, PIN_LED_RDY, PIN_LED_VFY, programmer_t::pinno, PPI_AVR_BUFF, and PPI_AVR_VCC.

Referenced by buspirate_bb_initpgm(), and serbb_initpgm().

Here is the call graph for this function:

Here is the caller graph for this function:

pgm_free()

void pgm_free

(

PROGRAMMER *const

p

)

{
  ldestroy_cb(p->id, free);
  ldestroy_cb(p->usbpid, free);
  p->id = NULL;
  p->usbpid = NULL;
  /* this is done by pgm_teardown, but usually cookie is not set to NULL */
  /* if (p->cookie !=NULL) {
    free(p->cookie);
    p->cookie = NULL;
  }*/
  free(p);
}

References free(), programmer_t::id, ldestroy_cb(), and programmer_t::usbpid.

Referenced by cleanup_config(), and yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

pgm_new()

PROGRAMMER * pgm_new

(

void

)

{
  int i;
  PROGRAMMER * pgm;
 
  pgm = (PROGRAMMER *)malloc(sizeof(*pgm));
  if (pgm == NULL) {
    avrdude_message(MSG_INFO, "%s: out of memory allocating programmer structure\n",
            progname);
    return NULL;
  }
 
  memset(pgm, 0, sizeof(*pgm));
 
  pgm->id = lcreat(NULL, 0);
  pgm->usbpid = lcreat(NULL, 0);
  pgm->desc[0] = 0;
  pgm->type[0] = 0;
  pgm->config_file[0] = 0;
  pgm->lineno = 0;
  pgm->baudrate = 0;
  pgm->initpgm = NULL;
 
  for (i=0; i<N_PINS; i++) {
    pgm->pinno[i] = 0;
    pin_clear_all(&(pgm->pin[i]));
  }
 
  /*
   * mandatory functions - these are called without checking to see
   * whether they are assigned or not
   */
  pgm->initialize     = pgm_default_2;
  pgm->display        = pgm_default_6;
  pgm->enable         = pgm_default_4;
  pgm->disable        = pgm_default_4;
  pgm->powerup        = pgm_default_powerup_powerdown;
  pgm->powerdown      = pgm_default_powerup_powerdown;
  pgm->program_enable = pgm_default_2;
  pgm->chip_erase     = pgm_default_2;
  pgm->open           = pgm_default_open;
  pgm->close          = pgm_default_4;
  pgm->read_byte      = pgm_default_3;
  pgm->write_byte     = pgm_default_5;
 
  /*
   * predefined functions - these functions have a valid default
   * implementation. Hence, they don't need to be defined in
   * the programmer.
   */
  pgm->rdy_led        = pgm_default_led;
  pgm->err_led        = pgm_default_led;
  pgm->pgm_led        = pgm_default_led;
  pgm->vfy_led        = pgm_default_led;
 
  /*
   * optional functions - these are checked to make sure they are
   * assigned before they are called
   */
  pgm->cmd            = NULL;
  pgm->cmd_tpi        = NULL;
  pgm->spi            = NULL;
  pgm->paged_write    = NULL;
  pgm->paged_load     = NULL;
  pgm->write_setup    = NULL;
  pgm->read_sig_bytes = NULL;
  pgm->set_vtarget    = NULL;
  pgm->set_varef      = NULL;
  pgm->set_fosc       = NULL;
  pgm->perform_osccal = NULL;
  pgm->parseextparams = NULL;
  pgm->setup          = NULL;
  pgm->teardown       = NULL;
 
  return pgm;
}

References avrdude_message(), programmer_t::baudrate, programmer_t::chip_erase, programmer_t::close, programmer_t::cmd, programmer_t::cmd_tpi, programmer_t::config_file, programmer_t::desc, programmer_t::disable, programmer_t::display, programmer_t::enable, programmer_t::err_led, programmer_t::id, programmer_t::initialize, programmer_t::initpgm, lcreat(), programmer_t::lineno, malloc(), MSG_INFO, N_PINS, programmer_t::open, programmer_t::paged_load, programmer_t::paged_write, programmer_t::parseextparams, programmer_t::perform_osccal, pgm, pgm_default_2(), pgm_default_3(), pgm_default_4(), pgm_default_5(), pgm_default_6(), pgm_default_led(), pgm_default_open(), pgm_default_powerup_powerdown(), programmer_t::pgm_led, programmer_t::pin, pin_clear_all(), programmer_t::pinno, programmer_t::powerdown, programmer_t::powerup, progname, programmer_t::program_enable, programmer_t::rdy_led, programmer_t::read_byte, programmer_t::read_sig_bytes, programmer_t::set_fosc, programmer_t::set_varef, programmer_t::set_vtarget, programmer_t::setup, programmer_t::spi, programmer_t::teardown, programmer_t::type, programmer_t::usbpid, programmer_t::vfy_led, programmer_t::write_byte, and programmer_t::write_setup.

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

pin_clear_all()

void pin_clear_all

(

struct pindef_t *const

pindef

)

Clear all defined pins in pindef.

Parameters

[out]

pindef

pin definition to clear

                                                   {
  memset(pindef, 0, sizeof(struct pindef_t));
}

Referenced by pgm_new(), and yyparse().

Here is the caller graph for this function:

pin_set_value()

void pin_set_value	(	struct pindef_t *const	pindef,
		const int	pin,
		const bool	inverse
	)

Adds a pin in the pin definition as normal or inverse pin.

Parameters

[out]	pindef	pin definition to update
[in]	pin	number of pin [0..PIN_MAX]
[in]	inverse	inverse (true) or normal (false) pin

                                                                                      {
 
  pindef->mask[pin / PIN_FIELD_ELEMENT_SIZE] |= 1 << (pin % PIN_FIELD_ELEMENT_SIZE);
  if(inverse) {
    pindef->inverse[pin / PIN_FIELD_ELEMENT_SIZE] |= (1 << (pin % PIN_FIELD_ELEMENT_SIZE));
  } else {
    pindef->inverse[pin / PIN_FIELD_ELEMENT_SIZE] &= ~(1 << (pin % PIN_FIELD_ELEMENT_SIZE));
  }
}

References inverse(), pindef_t::inverse, pindef_t::mask, and PIN_FIELD_ELEMENT_SIZE.

Referenced by assign_pin(), and assign_pin_list().

Here is the call graph for this function:

Here is the caller graph for this function:

pinmask_to_str()

const char * pinmask_to_str

(

const pinmask_t *const

pinmask

)

This function returns a string representation of pins in the mask eg. 1,3,5-7,9,12 Another execution of this function will overwrite the previous result in the static buffer. Consecutive pin number are representated as start-end.

Parameters

[in]

pinmask

the pin mask for which we want the string representation

Returns

pointer to a static string.

                                                             {
  static char buf[(PIN_MAX + 1) * 5]; // should be enough for PIN_MAX=255
  char *p = buf;
  int n;
  int pin;
  const char * fmt;
  int start = -1;
  int end = -1;
 
  buf[0] = 0;
  for(pin = PIN_MIN; pin <= PIN_MAX; pin++) {
    int index = pin / PIN_FIELD_ELEMENT_SIZE;
    int bit = pin % PIN_FIELD_ELEMENT_SIZE;
    if(pinmask[index] & (1 << bit)) {
      bool output = false;
      if(start == -1) {
        output = true;
        start = pin;
        end = start;
      } else if(pin == end + 1) {
        end = pin;
      } else {
        if(start != end) {
          n = sprintf(p, "-%d", end);
          p += n;
        }
        output = true;
        start = pin;
        end = start;
      }
      if(output) {
        fmt = (buf[0] == 0) ? "%d" : ",%d";
        n = sprintf(p, fmt, pin);
        p += n;
      }
    }
  }
  if(start != end) {
    n = sprintf(p, "-%d", end);
    p += n;
  }
 
  if(buf[0] == 0)
    return  "(no pins)";
 
  return buf;
}

References PIN_FIELD_ELEMENT_SIZE, PIN_MAX, and PIN_MIN.

Referenced by pins_check().

Here is the caller graph for this function:

pins_check()

int pins_check	(	const struct programmer_t *const	pgm,
		const struct pin_checklist_t *const	checklist,
		const int	size,
		const bool	output
	)

This function checks all pin of pgm against the constraints given in the checklist. It checks if

• any invalid pins are used
• valid pins are used inverted when not allowed
• any pins are used by more than one function
• any mandatory pin is not set all.

In case of any error it report the wrong function and the pin numbers. For verbose >= 2 it also reports the possible correct values. For verbose >=3 it shows also which pins were ok.

Parameters

[in]	pgm	the programmer to check
[in]	checklist	the constraint for the pins
[in]	size	the number of entries in checklist
[in]	output	false suppresses error messages to the user

Returns

0 if all pin definitions are valid, -1 otherwise

This function checks all pin of pgm against the constraints given in the checklist. It checks if

• any invalid pins are used
• valid pins are used inverted when not allowed
• any pins are used by more than one function
• any mandatory pin is not set all.

In case of any error it report the wrong function and the pin numbers. For verbose >= 2 it also reports the possible correct values. For verbose >=3 it shows also which pins were ok.

Parameters

[in]	pgm	the programmer to check
[in]	checklist	the constraint for the pins
[in]	size	the number of entries in checklist

Returns

0 if all pin definitions are valid, -1 otherwise

                                                                                                                                       {
  static const struct pindef_t no_valid_pins = {{0}, {0}}; // default value if check list does not contain anything else
  int rv = 0; // return value
  int pinname; // loop counter through pinnames
  pinmask_t already_used_all[PIN_FIELD_SIZE] = {0}; // collect pin definitions of all pin names for check of double use
  // loop over all possible pinnames
  for(pinname = 0; pinname < N_PINS; pinname++) {
    bool used = false;
    bool invalid = false;
    bool inverse = false;
    int index;
    int segment;
    bool mandatory_used = false;
    pinmask_t invalid_used[PIN_FIELD_SIZE] = {0};
    pinmask_t inverse_used[PIN_FIELD_SIZE] = {0};
    pinmask_t already_used[PIN_FIELD_SIZE] = {0};
    const struct pindef_t * valid_pins = &no_valid_pins;
    bool is_mandatory = false;
    bool is_ok = true;
    //find corresponding check pattern
    for(index = 0; index < size; index++) {
      if(checklist[index].pinname == pinname) {
        valid_pins = checklist[index].valid_pins;
        is_mandatory = checklist[index].mandatory;
        break;
      }
    }
 
    for(segment = 0; segment < PIN_FIELD_SIZE; segment++) {
      // check if for mandatory any pin is defined
      invalid_used[segment] = pgm->pin[pinname].mask[segment] & ~valid_pins->mask[segment];
      if(is_mandatory && (0 != (pgm->pin[pinname].mask[segment] & valid_pins->mask[segment]))) {
        mandatory_used = true;
      }
      // check if it does not use any non valid pins
      invalid_used[segment] = pgm->pin[pinname].mask[segment] & ~valid_pins->mask[segment];
      if(invalid_used[segment]) {
        invalid = true;
      }
      // check if it does not use any valid pins as inverse if not allowed
      inverse_used[segment] = pgm->pin[pinname].inverse[segment] & valid_pins->mask[segment] & ~valid_pins->inverse[segment];
      if(inverse_used[segment]) {
        inverse = true;
      }
      // check if it does not use same pins as other function
      already_used[segment] = pgm->pin[pinname].mask[segment] & already_used_all[segment];
      if(already_used[segment]) {
        used = true;
      }
      already_used_all[segment] |= pgm->pin[pinname].mask[segment];
    }
    if(invalid) {
      if(output) {
        avrdude_message(MSG_INFO, "%s: %s: Following pins are not valid pins for this function: %s\n",
                        progname, avr_pin_name(pinname), pinmask_to_str(invalid_used));
        avrdude_message(MSG_NOTICE2, "%s: %s: Valid pins for this function are: %s\n",
                  progname, avr_pin_name(pinname), pinmask_to_str(valid_pins->mask));
      }
      is_ok = false;
    }
    if(inverse) {
      if(output) {
        avrdude_message(MSG_INFO, "%s: %s: Following pins are not usable as inverse pins for this function: %s\n",
                        progname, avr_pin_name(pinname), pinmask_to_str(inverse_used));
        avrdude_message(MSG_NOTICE2, "%s: %s: Valid inverse pins for this function are: %s\n",
                          progname, avr_pin_name(pinname), pinmask_to_str(valid_pins->inverse));
      }
      is_ok = false;
    }
    if(used) {
      if(output) {
        avrdude_message(MSG_INFO, "%s: %s: Following pins are set for other functions too: %s\n",
                        progname, avr_pin_name(pinname), pinmask_to_str(already_used));
        is_ok = false;
      }
    }
    if(!mandatory_used && is_mandatory && !invalid) {
      if(output) {
        avrdude_message(MSG_INFO, "%s: %s: Mandatory pin is not defined.\n",
                        progname, avr_pin_name(pinname));
      }
      is_ok = false;
    }
    if(!is_ok) {
      rv = -1;
    } else if(output) {
      avrdude_message(MSG_DEBUG, "%s: %s: Pin is ok.\n",
                      progname, avr_pin_name(pinname));
    }
  }
  return rv;
}

References avr_pin_name(), avrdude_message(), inverse(), pindef_t::inverse, pin_checklist_t::mandatory, pindef_t::mask, MSG_DEBUG, MSG_INFO, MSG_NOTICE2, N_PINS, pgm, programmer_t::pin, PIN_FIELD_SIZE, pinmask_to_str(), progname, segment(), and pin_checklist_t::valid_pins.

Here is the call graph for this function:

pins_to_str()

const char * pins_to_str

(

const struct pindef_t *const

pindef

)

This function returns a string representation of defined pins eg. ~1,2,~4,~5,7 Another execution of this function will overwrite the previous result in the static buffer.

Parameters

[in]

pindef

the pin definition for which we want the string representation

Returns

pointer to a static string.

                                                               {
  static char buf[(PIN_MAX + 1) * 5]; // should be enough for PIN_MAX=255
  char *p = buf;
  int n;
  int pin;
  const char * fmt;
 
  buf[0] = 0;
  for(pin = PIN_MIN; pin <= PIN_MAX; pin++) {
    int index = pin / PIN_FIELD_ELEMENT_SIZE;
    int bit = pin % PIN_FIELD_ELEMENT_SIZE;
    if(pindef->mask[index] & (1 << bit)) {
      if(pindef->inverse[index] & (1 << bit)) {
        fmt = (buf[0] == 0) ? "~%d" : ",~%d";
      } else {
        fmt = (buf[0] == 0) ? " %d" : ",%d";
      }
      n = sprintf(p, fmt, pin);
      p += n;
    }
  }
 
  if(buf[0] == 0)
    return " (not used)";
 
  return buf;
}

References pindef_t::inverse, pindef_t::mask, PIN_FIELD_ELEMENT_SIZE, PIN_MAX, and PIN_MIN.

Referenced by pgm_display_generic_mask().

Here is the caller graph for this function:

programmer_display()

void programmer_display	(	PROGRAMMER *	pgm,
		const char *	p
	)

{
  avrdude_message(MSG_INFO, "%sProgrammer Type : %s\n", p, pgm->type);
  avrdude_message(MSG_INFO, "%sDescription     : %s\n", p, pgm->desc);
 
  pgm->display(pgm, p);
}

References avrdude_message(), programmer_t::desc, programmer_t::display, MSG_INFO, pgm, and programmer_t::type.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

read_config()

int read_config

(

const char *

file

)

{
  FILE * f;
  int r;
 
  f = fopen_utf8(file, "r");
  if (f == NULL) {
    avrdude_message(MSG_INFO, "%s: can't open config file \"%s\": %s\n",
            progname, file, strerror(errno));
    return -1;
  }
 
  lineno = 1;
  infile = file;
  yyin   = f;
 
  r = yyparse();
 
#ifdef HAVE_YYLEX_DESTROY
  /* reset lexer and free any allocated memory */
  yylex_destroy();
#endif
 
  fclose(f);
 
  return r;
}

References avrdude_message(), fopen_utf8(), infile, lineno, MSG_INFO, progname, yyin, yylex_destroy(), and yyparse().

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

read_config_builtin()

int read_config_builtin

(

)

{
  int r;
 
  lineno = 1;
  infile = "(builtin)";
 
  // Note: Can't use yy_scan_buffer, it's buggy (?), leads to fread from a null FILE*
  // and so unfortunatelly we have to use the copying variant here
  YY_BUFFER_STATE buffer = yy_scan_bytes((const char *)avrdude_slic3r_conf, avrdude_slic3r_conf_SIZE);
  if (buffer == NULL) {
    avrdude_message(MSG_INFO, "%s: read_config_builtin: Failed to initialize parsing buffer\n", progname);
    return -1;
  }
 
  r = yyparse();
  yy_delete_buffer(buffer);
 
#ifdef HAVE_YYLEX_DESTROY
  /* reset lexer and free any allocated memory */
  yylex_destroy();
#endif
 
  return r;
}

References avrdude_message(), infile, lineno, MSG_INFO, progname, yy_delete_buffer(), yy_scan_bytes(), yylex_destroy(), and yyparse().

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

report_progress()

void report_progress	(	int	completed,
		int	total,
		char *	hdr
	)

{
  static int last = 0;
  static double start_time;
  int percent = (total > 0) ? ((completed * 100) / total) : 100;
  struct timeval tv;
  double t;
 
  if (update_progress == NULL)
    return;
 
  gettimeofday(&tv, NULL);
  t = tv.tv_sec + ((double)tv.tv_usec)/1000000;
 
  if (hdr) {
    last = 0;
    start_time = t;
    update_progress (percent, t - start_time, hdr);
  }
 
  if (percent > 100)
    percent = 100;
 
  if (percent > last) {
    last = percent;
    update_progress (percent, t - start_time, hdr);
  }
 
  if (percent == 100)
    last = 0;                   /* Get ready for next time. */
}

References gettimeofday(), and update_progress.

Referenced by avr_read(), avr_signature(), avr_write(), and do_op().

Here is the call graph for this function:

Here is the caller graph for this function:

safemode_memfuses()

int safemode_memfuses	(	int	save,
		unsigned char *	lfuse,
		unsigned char *	hfuse,
		unsigned char *	efuse,
		unsigned char *	fuse
	)

{
  static unsigned char safemode_lfuse = 0xff;
  static unsigned char safemode_hfuse = 0xff;
  static unsigned char safemode_efuse = 0xff;
  static unsigned char safemode_fuse = 0xff;
 
  switch (save) {
 
    /* Save the fuses as safemode setting */
    case 1:
        safemode_lfuse = *lfuse;
        safemode_hfuse = *hfuse;
        safemode_efuse = *efuse;
        safemode_fuse  = *fuse;
 
        break;
    /* Read back the fuses */
    default:
        *lfuse = safemode_lfuse;
        *hfuse = safemode_hfuse;
        *efuse = safemode_efuse;
        *fuse  = safemode_fuse;
        break;
  }
 
  return 0;
}

References save().

Referenced by avr_write_byte(), and avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

safemode_readfuses()

int safemode_readfuses	(	unsigned char *	lfuse,
		unsigned char *	hfuse,
		unsigned char *	efuse,
		unsigned char *	fuse,
		PROGRAMMER *	pgm,
		AVRPART *	p
	)

{
 
  unsigned char value;
  unsigned char fusegood = 0;
  unsigned char allowfuseread = 1;
  unsigned char safemode_lfuse;
  unsigned char safemode_hfuse;
  unsigned char safemode_efuse;
  unsigned char safemode_fuse;
  AVRMEM * m;
 
  safemode_lfuse = *lfuse;
  safemode_hfuse = *hfuse;
  safemode_efuse = *efuse;
  safemode_fuse  = *fuse;
 
 
  /* Read fuse three times */
  fusegood = 2; /* If AVR device doesn't support this fuse, don't want
                   to generate a verify error */
  m = avr_locate_mem(p, "fuse");
  if (m != NULL) {
    fusegood = 0; /* By default fuse is a failure */
    if(pgm->read_byte(pgm, p, m, 0, &safemode_fuse) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 1, fuse value: %x\n",progname, safemode_fuse);
    if(pgm->read_byte(pgm, p, m, 0, &value) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 2, fuse value: %x\n",progname,  value);
    if (value == safemode_fuse) {
        if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
            {
            allowfuseread = 0;
            }
            avrdude_message(MSG_DEBUG, "%s: safemode read 3, fuse value: %x\n",progname,  value);
        if (value == safemode_fuse)
            {
            fusegood = 1; /* Fuse read OK three times */
            }
    }
  }
 
    //Programmer does not allow fuse reading.... no point trying anymore
    if (allowfuseread == 0)
        {
        return -5;
        }
 
    if (fusegood == 0) {
        avrdude_message(MSG_INFO, "%s: safemode: Verify error - unable to read fuse properly. "
                        "Programmer may not be reliable.\n", progname);
        return -1;
    }
    else if (fusegood == 1) {
        avrdude_message(MSG_NOTICE, "%s: safemode: fuse reads as %X\n", progname, safemode_fuse);
    }
 
 
  /* Read lfuse three times */
  fusegood = 2; /* If AVR device doesn't support this fuse, don't want
                   to generate a verify error */
  m = avr_locate_mem(p, "lfuse");
  if (m != NULL) {
    fusegood = 0; /* By default fuse is a failure */
    if (pgm->read_byte(pgm, p, m, 0, &safemode_lfuse) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 1, lfuse value: %x\n",progname,  safemode_lfuse);
    if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 2, lfuse value: %x\n",progname,  value);
    if (value == safemode_lfuse) {
        if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
            {
            allowfuseread = 0;
            }
            avrdude_message(MSG_DEBUG, "%s: safemode read 3, lfuse value: %x\n",progname,  value);
        if (value == safemode_lfuse){
        fusegood = 1; /* Fuse read OK three times */
        }
    }
  }
 
    //Programmer does not allow fuse reading.... no point trying anymore
    if (allowfuseread == 0)
        {
        return -5;
        }
 
 
    if (fusegood == 0) {
        avrdude_message(MSG_INFO, "%s: safemode: Verify error - unable to read lfuse properly. "
                        "Programmer may not be reliable.\n", progname);
        return -1;
    }
    else if (fusegood == 1) {
        avrdude_message(MSG_DEBUG, "%s: safemode: lfuse reads as %X\n", progname, safemode_lfuse);
    }
 
  /* Read hfuse three times */
  fusegood = 2; /* If AVR device doesn't support this fuse, don't want
                   to generate a verify error */
  m = avr_locate_mem(p, "hfuse");
  if (m != NULL) {
    fusegood = 0; /* By default fuse is a failure */
    if (pgm->read_byte(pgm, p, m, 0, &safemode_hfuse) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 1, hfuse value: %x\n",progname,  safemode_hfuse);
    if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 2, hfuse value: %x\n",progname,  value);
    if (value == safemode_hfuse) {
        if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
            {
            allowfuseread = 0;
            }
            avrdude_message(MSG_DEBUG, "%s: safemode read 3, hfuse value: %x\n",progname, value);
        if (value == safemode_hfuse){
             fusegood = 1; /* Fuse read OK three times */
        }
    }
  }
 
    //Programmer does not allow fuse reading.... no point trying anymore
    if (allowfuseread == 0)
        {
        return -5;
        }
 
    if (fusegood == 0)   {
            avrdude_message(MSG_INFO, "%s: safemode: Verify error - unable to read hfuse properly. "
                            "Programmer may not be reliable.\n", progname);
       return -2;
    }
    else if (fusegood == 1){
        avrdude_message(MSG_NOTICE, "%s: safemode: hfuse reads as %X\n", progname, safemode_hfuse);
    }
 
  /* Read efuse three times */
  fusegood = 2; /* If AVR device doesn't support this fuse, don't want
                   to generate a verify error */
  m = avr_locate_mem(p, "efuse");
  if (m != NULL) {
    fusegood = 0; /* By default fuse is a failure */
    if (pgm->read_byte(pgm, p, m, 0, &safemode_efuse) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 1, efuse value: %x\n",progname, safemode_efuse);
    if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
        {
        allowfuseread = 0;
        }
        avrdude_message(MSG_DEBUG, "%s: safemode read 2, efuse value: %x\n",progname,  value);
    if (value == safemode_efuse) {
        if (pgm->read_byte(pgm, p, m, 0, &value) != 0)
            {
            allowfuseread = 0;
            }
            avrdude_message(MSG_DEBUG, "%s: safemode read 3, efuse value: %x\n",progname, value);
        if (value == safemode_efuse){
             fusegood = 1; /* Fuse read OK three times */
        }
    }
  }
 
    //Programmer does not allow fuse reading.... no point trying anymore
    if (allowfuseread == 0)
        {
        return -5;
        }
 
    if (fusegood == 0) {
        avrdude_message(MSG_INFO, "%s: safemode: Verify error - unable to read efuse properly. "
                        "Programmer may not be reliable.\n", progname);
        return -3;
        }
    else if (fusegood == 1) {
        avrdude_message(MSG_NOTICE, "%s: safemode: efuse reads as %X\n", progname, safemode_efuse);
        }
 
  *lfuse = safemode_lfuse;
  *hfuse = safemode_hfuse;
  *efuse = safemode_efuse;
  *fuse  = safemode_fuse;
 
  return 0;
}

References avr_locate_mem(), avrdude_message(), MSG_DEBUG, MSG_INFO, MSG_NOTICE, pgm, progname, and programmer_t::read_byte.

Referenced by avrdude_main().

Here is the call graph for this function:

Here is the caller graph for this function:

safemode_writefuse()

int safemode_writefuse	(	unsigned char	fuse,
		char *	fusename,
		PROGRAMMER *	pgm,
		AVRPART *	p,
		int	tries
	)

{
  AVRMEM * m;
  unsigned char fuseread;
  int returnvalue = -1;
 
  m = avr_locate_mem(p, fusename);
  if (m == NULL) {
    return -1;
    }
 
  /* Keep trying to write then read back the fuse values */
  while (tries > 0) {
    if (avr_write_byte(pgm, p, m, 0, fuse) != 0)
        {
        continue;
        }
    if (pgm->read_byte(pgm, p, m, 0, &fuseread) != 0)
        {
        continue;
        }
 
    /* Report information to user if needed */
    avrdude_message(MSG_NOTICE, "%s: safemode: Wrote %s to %x, read as %x. %d attempts left\n",
                      progname, fusename, fuse, fuseread, tries-1);
 
    /* If fuse wrote OK, no need to keep going */
    if (fuse == fuseread) {
       tries = 0;
       returnvalue = 0;
    }
    tries--;
  }
 
  return returnvalue;
}

References avr_locate_mem(), avr_write_byte(), avrdude_message(), MSG_NOTICE, pgm, progname, and programmer_t::read_byte.

Referenced by avrdude_main().

Here is the call graph for this function:

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_programmers()

void sort_programmers

(

LISTID

programmers

)

{
  lsort(programmers,(int (*)(void*, void*)) sort_programmer_compare);
}

References lsort(), programmers, and sort_programmer_compare().

Referenced by list_programmers().

Here is the call graph for this function:

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:

walk_programmer_types()

void walk_programmer_types	(	walk_programmer_types_cb	cb,
		void *	cookie
	)

{
  const PROGRAMMER_TYPE * p;
  int i;
 
  for (i = 0; i < sizeof(programmers_types)/sizeof(programmers_types[0]); i++) {
    p = &(programmers_types[i]);
    cb(p->id, p->desc, cookie);
  }
}

References programmer_type_t::desc, programmer_type_t::id, and programmers_types.

Referenced by list_programmer_types().

Here is the caller graph for this function:

walk_programmers()

void walk_programmers	(	LISTID	programmers,
		walk_programmers_cb	cb,
		void *	cookie
	)

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

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

Referenced by list_programmers().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

avrdoper_serdev

struct serial_device avrdoper_serdev

extern

Referenced by stk500v2_open().

cancel_flag

bool cancel_flag

extern

Referenced by avrdude_cancel(), and avrdude_main().

default_bitclock

double default_bitclock

extern

Referenced by avrdude_main(), and yyparse().

default_parallel

char default_parallel[]

extern

Referenced by avrdude_main(), and yyparse().

default_programmer

char default_programmer[]

extern

Referenced by avrdude_main(), and yyparse().

default_safemode

int default_safemode

extern

Referenced by avrdude_main(), and yyparse().

default_serial

char default_serial[]

extern

Referenced by avrdude_main(), and yyparse().

part_list

LISTID part_list

extern

Referenced by avr910_initialize(), avrdude_main(), cleanup_config(), init_config(), and yyparse().

parts

struct avrpart parts[]

extern

Referenced by locate_part(), locate_part_by_avr910_devcode(), locate_part_by_signature(), and Slic3r::sla::anonymous_namespace{Pad.cpp}::_AroundPadSkeleton< _Intersector >::remove_redundant_parts().

programmers

LISTID programmers

extern

Referenced by avrdude_main(), cleanup_config(), init_config(), list_programmers(), locate_programmer(), sort_programmers(), walk_programmers(), and yyparse().

serdev

struct serial_device* serdev

extern

Referenced by jtag3_open_common(), jtagmkI_close(), jtagmkI_initialize(), jtagmkII_dragon_open(), jtagmkII_dragon_open_dw(), jtagmkII_dragon_open_pdi(), jtagmkII_initialize(), jtagmkII_open(), jtagmkII_open32(), jtagmkII_open_dw(), jtagmkII_open_pdi(), stk500v2_open(), and stk600_open().

serial_recv_timeout

long serial_recv_timeout

extern

Referenced by buspirate_disable(), buspirate_parseextparms(), buspirate_readline_noexit(), jtag3_paged_load(), jtag3_paged_write(), jtagmkI_paged_load(), jtagmkI_paged_write(), jtagmkI_resync(), jtagmkII_page_erase(), jtagmkII_paged_load(), jtagmkII_paged_load32(), jtagmkII_paged_write(), jtagmkII_paged_write32(), jtagmkII_read_SABaddr(), ser_recv(), and ser_send().

serial_serdev

struct serial_device serial_serdev

extern

update_progress

FP_UpdateProgress update_progress

extern

Referenced by avrdude_main(), and report_progress().

usb_serdev

struct serial_device usb_serdev

extern

Referenced by jtagmkII_dragon_open(), jtagmkII_dragon_open_dw(), jtagmkII_dragon_open_pdi(), jtagmkII_open(), jtagmkII_open32(), jtagmkII_open_dw(), and jtagmkII_open_pdi().

usb_serdev_frame

struct serial_device usb_serdev_frame

extern

Referenced by jtag3_open_common(), stk500v2_open(), and stk600_open().

usbhid_serdev

struct serial_device usbhid_serdev

extern

Referenced by jtag3_open_common().