Hi,
i am currently implementing a programmer for Hagen Reddmanns
AVRootloader (http://www.mikrocontroller.net/topic/95839#1195903).
This patch is meant as a RFC. Please tell me what there is still to improve.
I added "sram" to avrdude.conf so i can use big buffers (improves speed
very well, you don't want to miss this).
I also added a select function to the serial core, so the initial search
for the programmer is not only done with one message, but as long as the
final timeout is not over, using many messages. I don't know if this is
acceptable. I added select only to the unix part as I don't know how to
handle windows.
Attached patch is against v5.10.
Kind regards,
Sascha Warner
diff -Nu avrdude-5.10/avrdude.conf.in avrdude-5.10_avrootloader/avrdude.conf.in
--- avrdude-5.10/avrdude.conf.in 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/avrdude.conf.in 2010-02-22 15:49:03.000000000
+0100
@@ -1,4 +1,4 @@
-# $Id: avrdude.conf.in 916 2010-01-15 16:36:13Z joerg_wunsch $
+# $Id: avrdude.conf.in,v 1.4 2010/02/22 14:49:03 alexn Exp $
#
# AVRDUDE Configuration File
#
@@ -17,12 +17,12 @@
# desc = <description> ; # quoted string
# type = par | stk500 | stk500v2 | stk500pp | stk500hvsp |
stk500generic |
# stk600 | stk600pp | stk600hvsp |
-# avr910 | butterfly | usbasp |
+# avr910 | avrootloader | butterfly | usbasp |
# jtagmki | jtagmkii | jtagmkii_isp | jtagmkii_dw |
# jtagmkII_avr32 | jtagmkii_pdi |
# dragon_dw | dragon_jtag | dragon_isp | dragon_pp |
# dragon_hvsp | dragon_pdi | arduino; # programmer type
-# baudrate = <num> ; # baudrate for
avr910-programmer
+# baudrate = <num> ; # baudrate for
avr910-programmer / avrootloader-programmer
# vcc = <num1> [, <num2> ... ] ; # pin number(s)
# reset = <num> ; # pin number
# sck = <num> ; # pin number
@@ -415,6 +415,12 @@
;
programmer
+ id = "avrootloader";
+ desc = "Hagen Reddmanns extended capabilities serial programmer";
+ type = avrootloader;
+;
+
+programmer
id = "usbasp";
desc = "USBasp, http://www.fischl.de/usbasp/";;
type = usbasp;
@@ -2751,6 +2757,188 @@
#------------------------------------------------------------
+# ATmega64M1
+#------------------------------------------------------------
+
+part
+ id = "m64M1";
+ desc = "ATMEGA64M1";
+ has_jtag = yes;
+ stk500_devcode = 0xA0;
+ avr910_devcode = 0x45;
+ signature = 0x1e 0x96 0x84;
+ chip_erase_delay = 9000;
+ pagel = 0xD7;
+ bs2 = 0xA0;
+ reset = dedicated;
+ pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
+ "x x x x x x x x x x x x x x x x";
+
+ chip_erase = "1 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0",
+ "x x x x x x x x x x x x x x x x";
+
+ timeout = 200;
+ stabdelay = 100;
+ cmdexedelay = 25;
+ synchloops = 32;
+ bytedelay = 0;
+ pollindex = 3;
+ pollvalue = 0x53;
+ predelay = 1;
+ postdelay = 1;
+ pollmethod = 0;
+
+ pp_controlstack =
+ 0x0E, 0x1E, 0x0F, 0x1F, 0x2E, 0x3E, 0x2F, 0x3F,
+ 0x4E, 0x5E, 0x4F, 0x5F, 0x6E, 0x7E, 0x6F, 0x7F,
+ 0x66, 0x76, 0x67, 0x77, 0x6A, 0x7A, 0x6B, 0x7B,
+ 0xBE, 0xFD, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00;
+ hventerstabdelay = 100;
+ progmodedelay = 0;
+ latchcycles = 6;
+ togglevtg = 0;
+ poweroffdelay = 0;
+ resetdelayms = 0;
+ resetdelayus = 0;
+ hvleavestabdelay = 15;
+ chiperasepulsewidth = 0;
+ chiperasepolltimeout = 10;
+ programfusepulsewidth = 0;
+ programfusepolltimeout = 5;
+ programlockpulsewidth = 0;
+ programlockpolltimeout = 5;
+
+ idr = 0x22;
+ spmcr = 0x68;
+ allowfullpagebitstream = yes;
+
+ memory "eeprom"
+ paged = no; /* leave this "no" */
+ page_size = 8; /* for parallel programming */
+ size = 2048;
+ min_write_delay = 9000;
+ max_write_delay = 9000;
+ readback_p1 = 0xff;
+ readback_p2 = 0xff;
+ read = " 1 0 1 0 0 0 0 0",
+ " x x x x a11 a10 a9 a8",
+ " a7 a6 a5 a4 a3 a2 a1 a0",
+ " o o o o o o o o";
+
+ write = " 1 1 0 0 0 0 0 0",
+ " x x x x a11 a10 a9 a8",
+ " a7 a6 a5 a4 a3 a2 a1 a0",
+ " i i i i i i i i";
+
+ mode = 0x04;
+ delay = 20;
+ blocksize = 64;
+ readsize = 256;
+ ;
+
+ memory "flash"
+ paged = yes;
+ size = 65536;
+ page_size = 256;
+ num_pages = 256;
+ min_write_delay = 4500;
+ max_write_delay = 4500;
+ readback_p1 = 0xff;
+ readback_p2 = 0xff;
+ read_lo = " 0 0 1 0 0 0 0 0",
+ " x a14 a13 a12 a11 a10 a9 a8",
+ " a7 a6 a5 a4 a3 a2 a1 a0",
+ " o o o o o o o o";
+
+ read_hi = " 0 0 1 0 1 0 0 0",
+ " x a14 a13 a12 a11 a10 a9 a8",
+ " a7 a6 a5 a4 a3 a2 a1 a0",
+ " o o o o o o o o";
+
+
+ loadpage_lo = " 0 1 0 0 0 0 0 0",
+ " x x x x x x x x",
+ " x a6 a5 a4 a3 a2 a1 a0",
+ " i i i i i i i i";
+
+ loadpage_hi = " 0 1 0 0 1 0 0 0",
+ " x x x x x x x x",
+ " x a6 a5 a4 a3 a2 a1 a0",
+ " i i i i i i i i";
+
+ writepage = " 0 1 0 0 1 1 0 0",
+ " x a14 a13 a12 a11 a10 a9 a8",
+ " a7 x x x x x x x",
+ " x x x x x x x x";
+
+ mode = 0x21;
+ delay = 6;
+ blocksize = 128;
+ readsize = 256;
+ ;
+
+ memory "lfuse"
+ size = 1;
+ write = "1 0 1 0 1 1 0 0 1 0 1 0 0 0 0 0",
+ "x x x x x x x x i i i i i i i i";
+
+ read = "0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0",
+ "x x x x x x x x o o o o o o o o";
+ min_write_delay = 9000;
+ max_write_delay = 9000;
+ ;
+
+ memory "hfuse"
+ size = 1;
+ write = "1 0 1 0 1 1 0 0 1 0 1 0 1 0 0 0",
+ "x x x x x x x x i i i i i i i i";
+
+ read = "0 1 0 1 1 0 0 0 0 0 0 0 1 0 0 0",
+ "x x x x x x x x o o o o o o o o";
+ min_write_delay = 9000;
+ max_write_delay = 9000;
+ ;
+
+ memory "efuse"
+ size = 1;
+ write = "1 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0",
+ "x x x x x x x x x x x x x x i i";
+
+ read = "0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0",
+ "x x x x x x x x o o o o o o o o";
+ min_write_delay = 9000;
+ max_write_delay = 9000;
+ ;
+
+ memory "lock"
+ size = 1;
+ read = "0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0",
+ "x x x x x x x x x x o o o o o o";
+
+ write = "1 0 1 0 1 1 0 0 1 1 1 x x x x x",
+ "x x x x x x x x 1 1 i i i i i i";
+ min_write_delay = 9000;
+ max_write_delay = 9000;
+ ;
+
+ memory "calibration"
+ size = 4;
+ read = "0 0 1 1 1 0 0 0 x x x x x x x x",
+ "0 0 0 0 0 0 a1 a0 o o o o o o o o";
+ ;
+
+ memory "signature"
+ size = 3;
+ read = "0 0 1 1 0 0 0 0 x x x x x x x x",
+ "x x x x x x a1 a0 o o o o o o o o";
+ ;
+ ;
+
+
+
+
+
+#------------------------------------------------------------
# ATmega128
#------------------------------------------------------------
@@ -6287,7 +6475,8 @@
part
id = "m32";
desc = "ATMEGA32";
- has_jtag = yes;
+ sram = 2048;
+ has_jtag = yes;
stk500_devcode = 0x91;
avr910_devcode = 0x72;
signature = 0x1e 0x95 0x02;
diff -Nu avrdude-5.10/avrootloader.c avrdude-5.10_avrootloader/avrootloader.c
--- avrdude-5.10/avrootloader.c 1970-01-01 01:00:00.000000000 +0100
+++ avrdude-5.10_avrootloader/avrootloader.c 2010-02-24 12:41:22.000000000
+0100
@@ -0,0 +1,1069 @@
+/*
+ * avrdude - A Downloader/Uploader for AVR device programmers
+ * Copyright (C) 2003-2004 Theodore A. Roth <[email protected]>
+ * Copyright 2007 Joerg Wunsch <[email protected]>
+ * Copyright 2008 Klaus Leidinger <[email protected]>
+ * Copyright 2009 Sascha Warner <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* avrootloader.c 814 2009-09-23 sascha_warner - Not a real ID, just for
reference FIXME */
+
+/*
+ * avrdude interface for the very nice and feature-rich bootloader avrootloader
+ * by Hagen Reddmann.
+ * TODO: Encryption, versioning
+ */
+
+#include "ac_cfg.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "avrdude.h"
+#include "avr.h"
+#include "config.h"
+#include "crc16.h"
+#include "pgm.h"
+#include "avrootloader.h"
+#include "serial.h"
+
+#define VERSION_OFFSET_FROM_END 3 // position of the
bottloader version in the first reply
+#define SIG_OFFSET_FROM_END 4 // ...chip signature...
+#define BOOTPAGES_OFFSET_FROM_END 1 // ...reserved pages...
+#define SPAMDELAY 20 * 1000 // how long do
we wait before sending another INIT message
+#define SELECTDELAY 50 // how long do
we wait for an answer if we tried to INIT
+#define INIT_TRIALS 100 // how
often do we try to contact the bootloader before giving up
+#define CMD_INIT 1
+#define CMD_WRITEFLASH 2
+#define CMD_ERASEPAGES 3
+#define CMD_SENDBUF 4
+#define CMD_VERIFYFLASH 5
+#define CMD_WRITEE 6
+
+
+#define CRYPT 1
+#define CRYPTFLASH 2
+#define CRYPTEE 4
+#define VERSIONING 8
+
+/*
+ * Private data for this programmer.
+ */
+struct pdata
+{
+ unsigned char sigbytes[3];
+ char has_auto_incr_addr;
+ unsigned char devcode;
+ unsigned int buffersize;
+ unsigned char test_blockmode;
+ unsigned char use_blockmode;
+ unsigned char * internalbuf;
+ unsigned char * internaleeprombuf;
+ unsigned int eeprompos;
+ unsigned int eepromaddr;
+ unsigned int maxdelay;
+ unsigned int page_size;
+ unsigned int bootpages;
+ unsigned int current_page_vrfy;
+ unsigned int nbytes;
+ unsigned char features;
+ unsigned char trig[255];
+ unsigned char key[255];
+ unsigned char * eeprom;
+};
+
+#define PDATA(pgm) ((struct pdata *)(pgm->cookie))
+
+static void avrootloader_setup(PROGRAMMER * pgm)
+{
+ if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_setup(): Out of memory allocating
private data\n",
+ progname);
+ exit(1);
+ }
+ memset(pgm->cookie, 0, sizeof(struct pdata));
+ PDATA(pgm)->test_blockmode = 1;
+}
+
+static void avrootloader_teardown(PROGRAMMER * pgm)
+{
+ if (PDATA(pgm)->eeprom != 0)
+ free(PDATA(pgm)->eeprom);
+
+ if (PDATA(pgm)->internalbuf != 0)
+ free(PDATA(pgm)->internalbuf);
+
+ free(pgm->cookie);
+}
+
+
+static int avrootloader_send(PROGRAMMER * pgm, char * buf, size_t len)
+{
+ return serial_send(&pgm->fd, (unsigned char *)buf, len);
+}
+
+
+static int avrootloader_recv(PROGRAMMER * pgm, char * buf, size_t len)
+{
+ int rv;
+
+ if (serial_probe(&pgm->fd, PDATA(pgm)->maxdelay) > 0)
+ {
+ rv = serial_recv(&pgm->fd, (unsigned char *)buf, len);
+ if (rv < 0)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_recv(): programmer is not
responding\n",
+ progname);
+ exit(1);
+ }
+ }
+ else
+ {
+ fprintf(stderr,
+ "%s: avrootloader_recv(): programmer is not responding,
select timed out\n",
+ progname);
+ exit(1);
+ }
+ return rv;
+}
+
+
+static int avrootloader_drain(PROGRAMMER * pgm, int display)
+{
+ return serial_drain(&pgm->fd, display);
+}
+
+static void avrootloader_vfy_cmd_sent(PROGRAMMER * pgm, char * errmsg)
+{
+ unsigned char c = 0;
+
+ avrootloader_recv(pgm, &c, 1);
+
+ switch (c)
+ {
+ case 0xc0:
+ fprintf(stderr, "%s: Verification error: %s\n",
progname, errmsg);
+ exit(-1);
+ break;
+
+ case 0xc1:
+ fprintf(stderr, "%s: Unknown command error: %s\n",
progname, errmsg);
+ exit(-1);
+ break;
+
+ case 0xc2:
+ fprintf(stderr, "%s: CRC error: %s\n", progname,
errmsg);
+ exit(-1);
+ break;
+
+ case 0xc3:
+ fprintf(stderr, "%s: Boundary error: %s\n", progname,
errmsg);
+ exit(-1);
+ break;
+
+ case 0xc4:
+ fprintf(stderr, "%s: Decryption error: %s\n", progname,
errmsg);
+ exit(-1);
+ break;
+
+ case 0xc5:
+ fprintf(stderr, "%s: Programming error: %s\n",
progname, errmsg);
+ exit(-1);
+ break;
+
+ case 0xc6:
+ fprintf(stderr, "%s: Wrong version error: %s\n",
progname, errmsg);
+ exit(-1);
+ break;
+
+ case 0x30:
+ return;
+ break;
+
+ default:
+ fprintf(stderr, "%s: Unknown error: %s, Code 0x%x\n",
progname, errmsg, c & 0xff);
+ exit(-1);
+ }
+ }
+
+
+
+/*
+ * issue the 'chip erase' command to the AVR device
+ */
+static int avrootloader_chip_erase(PROGRAMMER * pgm, AVRPART * p)
+{
+ //avrootloader_send(pgm, "e", 1);
+ //avrootloader_vfy_cmd_sent(pgm, "chip erase");
+
+ /*
+ * avrootloader firmware may not delay long enough SW FIXME needed for
avrootloader? I dont think so...
+ */
+ //usleep (p->chip_erase_delay);
+/*
+ fprintf(stderr, "\n AVR CHIP_ERASE\n");
+ erase[1] = (m->size - BootPages) / page_size; // 'FIXME static FLASH
and bootloader sizes
+ crc = 0;
+ for (i = 0; i < sizeof(erase) - 2; i++)
+ crc = calcCRC16r(crc, erase[i], 0xa001);
+
+ erase[2] = (crc & 0xff);
+ erase[3] = (crc >> 8);
+
+ avrootloader_send(pgm, erase, sizeof(erase));
+ avrootloader_vfy_cmd_sent(pgm, "Erase remaining chip");
+*/
+ return 0;
+}
+
+static void avrootloader_leave_prog_mode(PROGRAMMER * pgm)
+{}
+
+/*
+ * issue the 'program enable' command to the AVR device
+ */
+static int avrootloader_program_enable(PROGRAMMER * pgm, AVRPART * p)
+{
+ return -1;
+}
+
+/*
+ * transmit an AVR device command and return the results; 'cmd' and
+ * 'res' must point to at least a 4 byte data buffer
+ */
+static int avrootloader_cmd(PROGRAMMER * pgm, unsigned char cmd[4],
+ unsigned char res[4])
+{
+ return 0; // FIXME
+ char buf[5];
+
+ /* FIXME: Insert version check here */
+
+ buf[0] = '.'; /* New Universal Command */
+ buf[1] = cmd[0];
+ buf[2] = cmd[1];
+ buf[3] = cmd[2];
+ buf[4] = cmd[3];
+
+ avrootloader_send (pgm, buf, 5);
+ avrootloader_recv (pgm, buf, 2);
+
+ res[0] = 0x00; /* Dummy value */
+ res[1] = cmd[0];
+ res[2] = cmd[1];
+ res[3] = buf[0];
+
+ return 0;
+}
+
+static int avrootloader_send_cmd(PROGRAMMER * pgm, unsigned char cmd, unsigned
int parambytes ,char * params)
+{
+char helo[10] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d};
+char writeflash[4] = {0x01, 0x01, 0xc0, 0x50};
+char setbuf[6] = {0xfe, 0x00, 0x0f, 0x00, 0x34, 0x18};
+char erase[4] = {0x02, 0x76, 0x80, 0x86};
+char writeeeprom[4] = {0x05, 0x01, 0xc2, 0x90};
+char vrfyflash[4] = {0x03, 0x01, 0xc1, 0x30};
+
+unsigned int i = 0;
+unsigned short tmp = 0;
+unsigned char crc[2] = {0, 0};
+
+ switch (cmd)
+ {
+ case CMD_INIT:
+ tmp = 0;
+ for (i = 0; i < strlen(helo); i++)
+ tmp = calcCRC16r(tmp, helo[i], 0xa001);
+ for (i = 0; i < strlen(PDATA(pgm)->key); i++)
+ tmp = calcCRC16r(tmp, PDATA(pgm)->key[i],
0xa001);
+
+ crc[0] = tmp & 0xff;
+ crc[1] = (tmp >> 8) & 0xff;
+
+ avrootloader_send(pgm, helo, sizeof(helo));
+ avrootloader_send(pgm, PDATA(pgm)->key,
strlen(PDATA(pgm)->key));
+ avrootloader_send(pgm, crc, sizeof(crc));
+ break;
+
+ case CMD_WRITEFLASH:
+ avrootloader_send_cmd(pgm, CMD_SENDBUF, parambytes,
params);
+ avrootloader_send(pgm, writeflash, sizeof(writeflash));
+ avrootloader_vfy_cmd_sent(pgm, "WRITE FLASH");
+ break;
+
+ case CMD_WRITEE:
+
+ avrootloader_send_cmd(pgm, CMD_SENDBUF, parambytes,
params);
+ avrootloader_send(pgm, writeeeprom,
sizeof(writeeeprom));
+ avrootloader_vfy_cmd_sent(pgm, "WRITE EEPROM");
+ break;
+
+ case CMD_ERASEPAGES:
+ erase[1] = *params;
+ tmp = 0;
+ for (i = 0; i < sizeof(erase) - 2; i++)
+ tmp = calcCRC16r(tmp, erase[i], 0xa001);
+
+ erase[2] = tmp & 0xff;
+ erase[3] = tmp >> 8;
+
+ avrootloader_send(pgm, erase, sizeof(erase));
+ avrootloader_vfy_cmd_sent(pgm, "ERASE REMAINING FLASH");
+ break;
+
+ case CMD_VERIFYFLASH:
+ avrootloader_send_cmd(pgm, CMD_SENDBUF, parambytes,
params);
+ avrootloader_send(pgm, vrfyflash, sizeof(vrfyflash));
+ avrootloader_vfy_cmd_sent(pgm, "VERIFY FLASH");
+ break;
+
+ case CMD_SENDBUF:
+ setbuf[3] = (parambytes - 2) & 0xff;
+ setbuf[2] = (parambytes - 2) >> 8;
+ tmp = 0;
+ for (i = 0; i < (sizeof(setbuf) - 2); i++)
+ tmp = calcCRC16r(tmp, setbuf[i], 0xa001);
+ setbuf[4] = tmp & 0xff;
+ setbuf[5] = (tmp >> 8) & 0xff;
+
+ tmp = 0;
+ for (i = 0; i < parambytes - 2; i++)
+ tmp = calcCRC16r(tmp, params[i], 0xa001);
+
+ params[parambytes - 2] = tmp & 0xff;
+ params[parambytes - 1] = (tmp >> 8) & 0xff;
+
+ avrootloader_send(pgm, setbuf, sizeof(setbuf));
+ avrootloader_send(pgm, params, parambytes);
+ avrootloader_vfy_cmd_sent(pgm, "FILL BUFFER");
+ break;
+
+ default:
+ return -1;
+ break;
+ }
+return 0;
+}
+
+
+
+/*
+ * initialize the AVR device and prepare it to accept commands
+ */
+static int avrootloader_initialize(PROGRAMMER * pgm, AVRPART * p)
+{
+ char rcv[265];
+ char tmp;
+ unsigned int i = 0;
+ unsigned int errcnt = 0;
+
+ memset(rcv, 0, sizeof(rcv));
+
+ while (((tmp != '0') || (i == 0)) && (i < sizeof(rcv)))
+ {
+ if (i == 0)
+ {
+ usleep(SPAMDELAY);
+ avrootloader_send_cmd(pgm, CMD_INIT, 0, &tmp);
+ }
+
+ if (serial_probe(&pgm->fd, SELECTDELAY) > 0)
+ {
+ avrootloader_recv(pgm, &tmp, 1); // this damn
thing blocks us 5s!
+ rcv[i] = tmp;
// thats why we introduced serial_probe
+
+ if (i < strlen(PDATA(pgm)->trig))
+ {
+ if (rcv[i] == PDATA(pgm)->trig[i])
+ i++;
+ else
+ {
+ i = 0;
+ errcnt++;
+ }
+ }
+ else
+ i++;
+ }
+ else
+ errcnt++;
+
+ if (errcnt > INIT_TRIALS)
+ {
+ fprintf(stderr, " %s: avrootloader_initialize()
timeout while contacting bootloader \n", progname);
+ exit(-1);
+ }
+ }
+
+ if ((rcv[i - 1] & 0xf0) != 0x30)
+ {
+ fprintf(stderr, " %s: avrootloader_initialize() unexpected
bootloader response 0x%x\n", progname, rcv[i - 1]);
+ exit(-1);
+ }
+
+ if (rcv[i - VERSION_OFFSET_FROM_END] != 5)
+ {
+ fprintf(stderr, " %s: avrootloader_initialize() unexpected
bootloader version %u\n", progname, rcv[i - VERSION_OFFSET_FROM_END]);
+ //exit(-1);
+ }
+
+ PDATA(pgm)->features = rcv[i] & 0x0f;
+ PDATA(pgm)->bootpages = rcv[i - BOOTPAGES_OFFSET_FROM_END];
+ PDATA(pgm)->sigbytes[0] = 0x1e;
+ PDATA(pgm)->sigbytes[1] = rcv[i - (SIG_OFFSET_FROM_END + 1)];
+ PDATA(pgm)->sigbytes[2] = rcv[i - SIG_OFFSET_FROM_END];
+
+ printf("\nEntering programming mode...\n");
+
+ return 0;
+}
+
+
+static void avrootloader_disable(PROGRAMMER * pgm)
+{}
+
+
+static void avrootloader_enable(PROGRAMMER * pgm)
+{}
+
+static int avrootloader_parseextparms(PROGRAMMER * pgm, LISTID extparms)
+{
+ LNODEID ln;
+ const char *extended_param;
+ int rv = 0;
+ char loader[11] = { 'B', 'O', 'O', 'T', 'L', 'O', 'A', 'D', 'E', 'R' , 0x00};
+ char back[12] = { '(', 'c', ')', ' ', '2', '0', '0', '9', ' ', 'H' ,'R' ,
0x00};
+ unsigned int i;
+
+ for (i = 0; i < sizeof(loader); i++)
+ PDATA(pgm)->key[i] = loader[i];
+
+ for (i = 0; i < sizeof(back); i++)
+ PDATA(pgm)->trig[i] = back[i];
+
+ for (ln = lfirst(extparms); ln; ln = lnext(ln))
+ {
+ extended_param = ldata(ln);
+
+ if (strncmp(extended_param, "bootid=", strlen("bootid=")) == 0)
+ {
+ char bootid[255] = {0};
+ if (sscanf(extended_param, "bootid=%s", bootid) != 1)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms():
invalid devcode '%s'\n",
+ progname, extended_param);
+ rv = -1;
+ continue;
+ }
+ else
+ fprintf(stderr,
+ "%s: set bootloader signature to
'%s'\n",
+ progname, bootid);
+
+ if (verbose >= 2)
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms():
devcode overwritten as %s\n",
+ progname, bootid);
+ //PDATA(pgm)->devcode = devcode;
+
+ continue;
+ }
+
+ if (strncmp(extended_param, "no_blockmode",
strlen("no_blockmode")) == 0)
+ {
+ if (verbose >= 2)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms(-x): no
testing for Blockmode\n",
+ progname);
+ }
+
+ PDATA(pgm)->test_blockmode = 0;
+ continue;
+ }
+
+ if (strncmp(extended_param, "trig=", strlen("trig=")) == 0)
+ {
+ sscanf(extended_param, "trig=%s", PDATA(pgm)->trig);
+
+ if (verbose >= 2)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms(-x):
triggering on %s\n",
+ progname, PDATA(pgm)->trig);
+ }
+ continue;
+ }
+
+ if (strncmp(extended_param, "key=", strlen("key=")) == 0)
+ {
+ sscanf(extended_param, "key=%s", PDATA(pgm)->key);
+
+ if (verbose >= 2)
+ {
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms(-x):
sending key '%s'\n",
+ progname, PDATA(pgm)->key);
+ }
+ continue;
+ }
+
+ fprintf(stderr,
+ "%s: avrootloader_parseextparms(): invalid extended
parameter '%s'\n",
+ progname, extended_param);
+ rv = -1;
+ }
+ return rv;
+}
+
+
+static int avrootloader_open(PROGRAMMER * pgm, char * port)
+{
+ /*
+ * If baudrate was not specified use 115.200 Baud so we might flash fast
+ */
+ if(pgm->baudrate == 0)
+ pgm->baudrate = 115200; // SW: was 19200
+
+ strcpy(pgm->port, port);
+ serial_open(port, pgm->baudrate, &pgm->fd);
+
+ /*
+ * drain any extraneous input
+ */
+ avrootloader_drain (pgm, 0);
+
+ return 0;
+}
+
+static void avrootloader_close(PROGRAMMER * pgm)
+{
+ avrootloader_leave_prog_mode(pgm);
+
+ serial_close(&pgm->fd);
+ pgm->fd.ifd = -1;
+}
+
+
+static void avrootloader_display(PROGRAMMER * pgm, const char * p)
+{
+ return;
+}
+
+
+static void avrootloader_set_addr(PROGRAMMER * pgm, unsigned long addr)
+{
+ unsigned char cmd[6];
+ unsigned short crcx = 0;
+ unsigned int i;
+
+ cmd[0] = 0xff;
+ cmd[1] = (addr >> 16) & 0xff;
+ cmd[2] = (addr >> 8 ) & 0xff;
+ cmd[3] = addr & 0xff;
+
+ for (i = 0; i < sizeof(cmd) - 2; i++)
+ crcx = calcCRC16r(crcx, cmd[i], 0xa001);
+
+ cmd[4] = (unsigned char) crcx & 0xff;
+ cmd[5] = (unsigned char) (crcx >> 8) & 0xff;
+
+ avrootloader_send(pgm, cmd, sizeof(cmd));
+ avrootloader_vfy_cmd_sent(pgm, "SET ADDRESS");
+}
+
+
+static int avrootloader_write_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
+ unsigned long addr, unsigned char value)
+{
+ if (strcmp(m->desc, "flash") == 0)
+ return -2; // not supported, why do you think we have
paged_write?
+ // we need to fill at least one
flashpage anyway and we are
+ // not going to rewrite the same page
for each byte we get.
+
+ else if (strcmp(m->desc, "eeprom") == 0)
+ {
+ unsigned char buf[m->page_size];
+
+ memset(buf, 0xff, m->page_size);
+
+ // buffer is page aligned
+ buf[addr % m->page_size] = value;
+
+ // we need to align here cause we are going to write one whole
page
+ avrootloader_set_addr(pgm, (addr / m->page_size) *
m->page_size);
+ //avrootloader_vfy_cmd_sent(pgm, "SET ADDRESS");
+
+ avrootloader_send_cmd(pgm, CMD_WRITEE, m->page_size, buf);
+ }
+ else
+ return avr_write_byte_default(pgm, p, m, addr, value);
+
+ return 0;
+}
+
+static int avrootloader_read_byte_flash(PROGRAMMER * pgm, AVRPART * p, AVRMEM
* m,
+ unsigned long addr, unsigned char * value)
+{
+ unsigned int i;
+ unsigned short crc = 0;
+ unsigned int written = 0;
+ char setbuf[6] = {0xfe, 0x00, 0x0f, 0x00, 0x34, 0x18};
+ char vrfyflash[4] = {0x03, 0x01, 0xc1, 0x30};
+ unsigned int bufsize = 0;
+
+ if (PDATA(pgm)->internalbuf == 0)
+ {
+ fprintf(stderr, " %s: avrootloader_read_byte_flash() Reading is
not supported by this bootloader - only verify works\n", progname);
+ exit(-1);
+ }
+
+ bufsize = (p->sram - m->page_size);
+
+ if (bufsize == 0)
+ bufsize = m->page_size;
+
+ char buf[bufsize + 2];
+
+ if (PDATA(pgm)->current_page_vrfy != (addr / m->page_size))
+ {
+ avrootloader_set_addr(pgm, addr >> 1);
+ PDATA(pgm)->current_page_vrfy = addr / m->page_size;
+
+ for (i = 0; i < 4; i++)
+ crc = calcCRC16r(crc, setbuf[i], 0xa001);
+ setbuf[4] = crc & 0xff;
+ setbuf[5] = crc >> 8;
+
+ while (written < PDATA(pgm)->nbytes)
+ {
+ if ((written + bufsize) > PDATA(pgm)->nbytes)
+ {
+ memset(buf, 0xff, bufsize);
+ memcpy(buf, m->buf + written,
PDATA(pgm)->nbytes - written);
+ }
+ else
+ memcpy(buf, m->buf + written, bufsize);
+
+ crc = 0;
+ for (i = 0; i < bufsize; i++)
+ crc = calcCRC16r(crc, buf[i], 0xa001);
+
+ buf[bufsize] = (crc & 0xff);
+ buf[(bufsize + 1)] = (crc >> 8);
+
+ PDATA(pgm)->maxdelay = 5000;
+ avrootloader_send(pgm, setbuf, sizeof(setbuf));
+ avrootloader_send(pgm, buf, sizeof(buf));
+ avrootloader_vfy_cmd_sent(pgm, "FILL BUFFER");
+
+ avrootloader_send(pgm, vrfyflash, sizeof(vrfyflash));
+ avrootloader_vfy_cmd_sent(pgm, "VERIFY FLASH");
+
+ written += bufsize;
+ report_progress (written, PDATA(pgm)->nbytes, NULL);
+ }
+ }
+ return (buf[addr % PDATA(pgm)->page_size]);
+}
+
+
+static int avrootloader_read_byte_eeprom(PROGRAMMER * pgm, AVRPART * p, AVRMEM
* m,
+ unsigned long addr, unsigned char * value)
+{
+ char readeeprom[4] = {0x04, 0x00, 0x02, 0xc0};
+ unsigned int i;
+ unsigned short tmp;
+ unsigned char crc[2] = {0, 0};
+ unsigned int bytesread = 0;
+ unsigned int bufsize = 0;
+
+ bufsize = avr_locate_mem(p, "flash")->page_size * 2;
+
+ if (PDATA(pgm)->eeprom == 0)
+ {
+ PDATA(pgm)->eeprom = malloc(m->size);
+ if (PDATA(pgm)->eeprom == 0)
+ {
+ fprintf(stderr,"\nError allocating memory:
avrootloader_read_byte_eeprom\n");
+ exit(-1);
+ }
+ memset(PDATA(pgm)->eeprom, 0xff, m->size);
+
+ PDATA(pgm)->maxdelay = 5000;
+
+ while (bytesread < m->size)
+ {
+ avrootloader_send(pgm, readeeprom, sizeof(readeeprom));
+ avrootloader_recv(pgm, PDATA(pgm)->eeprom + bytesread,
bufsize);
+ avrootloader_recv(pgm, crc, sizeof(crc));
+
+ tmp = 0;
+ for (i = 0; i < bufsize; i++)
+ tmp = calcCRC16r(tmp, PDATA(pgm)->eeprom[i +
bytesread], 0xa001);
+
+
+ if (((tmp & 0xff) != crc[0]) || ((tmp >> 8) != crc[1]))
+ {
+ fprintf(stderr, "\navrootloader: Error in
EEPROM CRC - please retry\n");
+ exit(-1);
+ }
+
+ avrootloader_vfy_cmd_sent(pgm, "READ EEPROM");
+ bytesread += bufsize;
+ }
+ }
+ *value = PDATA(pgm)->eeprom[addr - m->offset];
+// free(PDATA(pgm)->eeprom);
+
+ return 1;
+}
+
+
+static int avrootloader_read_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
+ unsigned long addr, unsigned char * value)
+{
+ if (strcmp(m->desc, "flash") == 0)
+ return avrootloader_read_byte_flash(pgm, p, m, addr, value);
+
+ if (strcmp(m->desc, "eeprom") == 0)
+ return avrootloader_read_byte_eeprom(pgm, p, m, addr, value);
+
+ // This bootloader cannot read any fuses (no bootloader can set at all)
+
+ *value = 1;
+ return 1;
+ }
+
+static int avrootloader_paged_write_flash(PROGRAMMER * pgm, AVRPART * p,
AVRMEM * m,
+ int page_size, int n_bytes)
+{
+ unsigned int addr = 0;
+ unsigned int bufsize = 0;
+ unsigned int written = 0;
+ unsigned char param_eraseprog = 1;
+ unsigned int tmp = 0;
+
+ if (n_bytes < (p->sram - page_size))
+ while (bufsize < n_bytes)
+ bufsize += page_size;
+ else
+ bufsize = (p->sram - page_size);
+
+ if (bufsize == 0)
+ bufsize = page_size;
+
+ char buf[bufsize + 2];
+
+ PDATA(pgm)->page_size = page_size;
+ PDATA(pgm)->nbytes = n_bytes;
+
+ if ((PDATA(pgm)->internalbuf = malloc(n_bytes + page_size)) == 0)
+ {
+ fprintf(stderr,
+ "%s: avrootloader__paged_write_flash(): Out of memory allocating
verify buffer\n",
+ progname);
+ exit(1);
+ }
+ memset(PDATA(pgm)->internalbuf, 0xff, n_bytes + page_size);
+ memcpy(PDATA(pgm)->internalbuf, m->buf, n_bytes);
+
+ avrootloader_set_addr(pgm, addr >> 1); // fixme REALLY DIV2?
+
+ PDATA(pgm)->maxdelay = m->max_write_delay * bufsize;
+ while (written < n_bytes)
+ {
+ if ((written + bufsize) > n_bytes)
+ {
+ memset(buf, 0xff, bufsize);
+ memcpy(buf, m->buf + written, n_bytes - written);
+ }
+ else
+ memcpy(buf, m->buf + written, bufsize);
+
+ avrootloader_send_cmd(pgm, CMD_WRITEFLASH, sizeof(buf), buf);
+
+ written += bufsize;
+ report_progress (written, n_bytes, NULL);
+ }
+// free(PDATA(pgm)->internalbuf);
+
+
+// The erase command 0x02 takes one parameter, which describes the num of
+// pages to be erased, beginning at the address we currently are at.
+// (i.e. the program end after flashing)
+// But keep the reserved space for the bootloader in mind. Page size is the
real
+// pagesize of the chip.
+// pages_to_be_erased = (chipsize - totally_written - bootloadersize) /
page_size
+
+ if (param_eraseprog > 0)
+ {
+ tmp = (m->size - written - (PDATA(pgm)->bootpages * page_size))
/ page_size;
+ PDATA(pgm)->maxdelay = m->max_write_delay * tmp * page_size;
+ avrootloader_send_cmd(pgm, CMD_ERASEPAGES, sizeof(tmp),
(unsigned char *) &tmp);
+ }
+ return n_bytes;
+}
+
+static int avrootloader_paged_write_eeprom(PROGRAMMER * pgm, AVRPART * p,
+ AVRMEM * m, int page_size, int n_bytes)
+{
+ unsigned int written = 0;
+ unsigned int bufsize = 0;
+
+ if (n_bytes < (p->sram - page_size))
+ while (bufsize < n_bytes)
+ bufsize += page_size;
+ else
+ bufsize = (p->sram - page_size);
+
+ if (bufsize == 0)
+ bufsize = page_size;
+
+ char buf[bufsize + 2];
+
+ avrootloader_set_addr(pgm, m->offset); // fixme REALLY DIV2?
+ PDATA(pgm)->maxdelay = (m->max_write_delay * n_bytes);
+
+ while (written < n_bytes)
+ {
+ if ((written + bufsize) > n_bytes)
+ {
+ memset(buf, 0xff, bufsize);
+ memcpy(buf, m->buf + written, n_bytes - written);
+ }
+ else
+ memcpy(buf, m->buf + written, bufsize);
+
+ avrootloader_send_cmd(pgm, CMD_WRITEE, sizeof(buf), buf);
+ written += bufsize;
+ report_progress (written, n_bytes, NULL);
+ }
+
+ return n_bytes;
+}
+
+
+static int avrootloader_paged_write(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
+ int page_size, int n_bytes)
+{
+ int rval = 0;
+
+ if (PDATA(pgm)->use_blockmode == 0)
+ {
+ if (strcmp(m->desc, "flash") == 0)
+ rval = avrootloader_paged_write_flash(pgm, p, m,
page_size, n_bytes);
+ else if (strcmp(m->desc, "eeprom") == 0)
+ rval = avrootloader_paged_write_eeprom(pgm, p, m,
page_size, n_bytes);
+ else
+ rval = -2;
+ }
+
+/* if (PDATA(pgm)->use_blockmode == 1)
+ {
+ unsigned int addr = 0;
+ unsigned int max_addr = n_bytes;
+ char *cmd;
+ unsigned int blocksize = PDATA(pgm)->buffersize;
+
+ if (strcmp(m->desc, "flash") && strcmp(m->desc, "eeprom"))
+ rval = -2;
+
+ if (m->desc[0] == 'e')
+ blocksize = 1; // Write to eeprom single bytes
only
+
+ avrootloader_set_addr(pgm, addr);
+
+ cmd = malloc(4 + blocksize);
+ if (!cmd)
+ rval = -1;
+
+ cmd[0] = 'B';
+ cmd[3] = toupper(m->desc[0]);
+
+ while (addr < max_addr)
+ {
+ if ((max_addr - addr) < blocksize)
+ blocksize = max_addr - addr;
+
+ memcpy(&cmd[4], &m->buf[addr], blocksize);
+ cmd[1] = (blocksize >> 8) & 0xff;
+ cmd[2] = blocksize & 0xff;
+
+ avrootloader_send(pgm, cmd, 4 + blocksize);
+ // avrootloader_vfy_cmd_sent(pgm, "write block");
+
+ addr += blocksize;
+
+ report_progress (addr, max_addr, NULL);
+ }
+
+ free(cmd);
+ rval = addr;
+ }
+ */
+ return rval;
+}
+
+
+static int avrootloader_paged_load(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
+ int page_size, int n_bytes)
+{
+ unsigned int addr = 0;
+ unsigned int written = 0;
+ unsigned int bufsize = 0;
+ char readeeprom[4] = {0x04, 0x00, 0x02, 0xc0};
+ unsigned int i;
+ unsigned short tmp;
+ unsigned char crc[2] = {0, 0};
+
+
+ if (strcmp(m->desc, "flash") == 0)
+ {
+ if (PDATA(pgm)->internalbuf == 0)
+ {
+ fprintf(stderr, " %s: avrootloader_read_byte_flash()
Reading is not supported by this bootloader - only verify works\n", progname);
+ exit(-1);
+ }
+
+ if (n_bytes < (p->sram - page_size))
+ while (bufsize < n_bytes)
+ bufsize += page_size;
+ else
+ bufsize = (p->sram - page_size);
+
+ if (bufsize == 0)
+ bufsize = page_size;
+
+ char buf[bufsize + 2];
+
+ avrootloader_set_addr(pgm, addr >> 1);
+
+ memcpy(m->buf, PDATA(pgm)->internalbuf, n_bytes);
+
+ PDATA(pgm)->maxdelay = 5000;
+
+ while (written < n_bytes)
+ {
+ if ((written + bufsize) > n_bytes)
+ {
+ memset(buf, 0xff, bufsize);
+ memcpy(buf, PDATA(pgm)->internalbuf +
written, n_bytes - written);
+ }
+ else
+ memcpy(buf, PDATA(pgm)->internalbuf +
written, bufsize);
+
+ avrootloader_send_cmd(pgm, CMD_VERIFYFLASH,
sizeof(buf), buf);
+
+ written += bufsize;
+ report_progress (written, n_bytes, NULL);
+ }
+ return n_bytes;
+ }
+ else if (strcmp(m->desc, "eeprom") == 0)
+ {
+
+ bufsize = avr_locate_mem(p, "flash")->page_size * 2;
+
+ PDATA(pgm)->maxdelay = 5000;
+
+ while (written < n_bytes)
+ {
+ avrootloader_send(pgm, readeeprom, sizeof(readeeprom));
+ avrootloader_recv(pgm, m->buf + written, bufsize);
+ avrootloader_recv(pgm, crc, sizeof(crc));
+
+ tmp = 0;
+ for (i = 0; i < bufsize; i++)
+ tmp = calcCRC16r(tmp, m->buf[i + written],
0xa001);
+
+
+ if (((tmp & 0xff) != crc[0]) || ((tmp >> 8) != crc[1]))
+ {
+ fprintf(stderr, "\navrootloader: Error in
EEPROM CRC - please retry\n");
+ exit(-1);
+ }
+
+ avrootloader_vfy_cmd_sent(pgm, "READ EEPROM");
+ written += bufsize;
+ }
+ }
+ return n_bytes;
+}
+
+
+/* Signature byte reads are always 3 bytes. */
+
+static int avrootloader_read_sig_bytes(PROGRAMMER * pgm, AVRPART * p, AVRMEM *
m)
+{
+ if (m->size < 3)
+ {
+ fprintf(stderr, "%s: memsize too small for sig byte read",
progname);
+ return -1;
+ }
+
+ m->buf[0] = PDATA(pgm)->sigbytes[0];
+ m->buf[1] = PDATA(pgm)->sigbytes[1];
+ m->buf[2] = PDATA(pgm)->sigbytes[2];
+
+ return 3;
+}
+
+
+void avrootloader_initpgm(PROGRAMMER * pgm)
+{
+ strcpy(pgm->type, "avrootloader");
+
+ /*
+ * mandatory functions
+ */
+ pgm->initialize = avrootloader_initialize;
+ pgm->display = avrootloader_display;
+ pgm->enable = avrootloader_enable;
+ pgm->disable = avrootloader_disable;
+ pgm->program_enable = avrootloader_program_enable;
+ pgm->chip_erase = avrootloader_chip_erase;
+ pgm->cmd = avrootloader_cmd;
+ pgm->open = avrootloader_open;
+ pgm->close = avrootloader_close;
+
+ /*
+ * optional functions
+ */
+
+ pgm->write_byte = avrootloader_write_byte;
+ pgm->read_byte = avrootloader_read_byte;
+
+ pgm->paged_write = avrootloader_paged_write;
+ pgm->paged_load = avrootloader_paged_load;
+
+ pgm->read_sig_bytes = avrootloader_read_sig_bytes;
+
+ pgm->parseextparams = avrootloader_parseextparms;
+ pgm->setup = avrootloader_setup;
+ pgm->teardown = avrootloader_teardown;
+}
diff -Nu avrdude-5.10/avrootloader.h avrdude-5.10_avrootloader/avrootloader.h
--- avrdude-5.10/avrootloader.h 1970-01-01 01:00:00.000000000 +0100
+++ avrdude-5.10_avrootloader/avrootloader.h 2010-02-17 08:40:57.000000000
+0100
@@ -0,0 +1,37 @@
+/*
+ * avrdude - A Downloader/Uploader for AVR device programmers
+ * Copyright (C) 2003-2004 Theodore A. Roth <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* $Id: avrootloader.h,v 1.1 2010/02/17 07:40:57 alexn Exp $ */
+
+#ifndef avrootloader_h
+#define avrootloader_h
+
+#include "avrpart.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void avrootloader_initpgm (PROGRAMMER * pgm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* avrootloader_h */
diff -Nu avrdude-5.10/AVRootloader_README.txt
avrdude-5.10_avrootloader/AVRootloader_README.txt
--- avrdude-5.10/AVRootloader_README.txt 1970-01-01 01:00:00.000000000
+0100
+++ avrdude-5.10_avrootloader/AVRootloader_README.txt 2010-02-17
11:56:01.000000000 +0100
@@ -0,0 +1,20 @@
+This patch implements support for Hagen Reddmanns bootloader into
+avrdude. Currently, writing to EEPROM, encryption and versioning
+is not supported.
+
+This is an example of how to flash something using this bootloader:
+
+./avrdude -C avrdude.conf -c avrootloader -P /dev/ttyUSB0 -p m32 \
+-U flash:w:../OilquickBagger.hex \
+-x key=BOOTLOADER -x trig=MIS Bootloader
+
+The option -x key=BOOTLOADER sets the helo message to start
+the bootloader. It can be seen as a hidden key neccessary to gain
+bootloader functionality. However, remember this can easily be sniffed.
+
+The option -x trig=MIS Bootloader is what is to be expected from
+the bootloader when everything is fine and we gained bootloader
+access.
+
+If these options with their according parameter are not used, the
+default values as per bootloader version 6 are used.
diff -Nu avrdude-5.10/avrpart.h avrdude-5.10_avrootloader/avrpart.h
--- avrdude-5.10/avrpart.h 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/avrpart.h 2010-02-17 14:29:51.000000000 +0100
@@ -102,6 +102,7 @@
typedef struct avrpart {
char desc[AVR_DESCLEN]; /* long part name */
char id[AVR_IDLEN]; /* short part name */
+ unsigned int sram; /* SRAM size in bytes */
int stk500_devcode; /* stk500 device code */
int avr910_devcode; /* avr910 device code */
int chip_erase_delay; /* microseconds */
diff -Nu avrdude-5.10/config_gram.y avrdude-5.10_avrootloader/config_gram.y
--- avrdude-5.10/config_gram.y 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/config_gram.y 2010-02-17 14:29:51.000000000
+0100
@@ -42,6 +42,7 @@
#include "stk500v2.h"
#include "stk500generic.h"
#include "avr910.h"
+#include "avrootloader.h"
#include "butterfly.h"
#include "usbasp.h"
#include "usbtiny.h"
@@ -78,6 +79,7 @@
%token K_MEMORY
+%token K_SRAM
%token K_PAGE_SIZE
%token K_PAGED
@@ -148,6 +150,7 @@
%token K_STK600HVSP
%token K_STK600PP
%token K_AVR910
+%token K_AVROOTLOADER
%token K_USBASP
%token K_USBTINY
%token K_BUTTERFLY
@@ -462,6 +465,12 @@
}
} |
+ K_TYPE TKN_EQUAL K_AVROOTLOADER {
+ {
+ avrootloader_initpgm(current_prog);
+ }
+ } |
+
K_TYPE TKN_EQUAL K_USBASP {
{
usbasp_initpgm(current_prog);
@@ -687,6 +696,13 @@
}
} |
+ K_SRAM TKN_EQUAL TKN_NUMBER {
+ {
+ current_part->sram = $3->value.number;
+ free_token($3);
+ }
+ } |
+
K_AVR910_DEVCODE TKN_EQUAL TKN_NUMBER {
{
current_part->avr910_devcode = $3->value.number;
diff -Nu avrdude-5.10/crc16.c avrdude-5.10_avrootloader/crc16.c
--- avrdude-5.10/crc16.c 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/crc16.c 2010-02-17 08:16:07.000000000 +0100
@@ -40,10 +40,26 @@
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
+unsigned int calcCRC16r(unsigned int crc, unsigned int c, unsigned int
+mask)
+{
+ unsigned char i;
+ for(i=0;i<8;i++)
+ {
+ if((crc ^ c) & 1) { crc=(crc>>1)^mask; }
+ else crc>>=1;
+ c>>=1;
+ }
+ return (crc);
+}
+
/* CRC calculation macros */
#define CRC_INIT 0xFFFF
-#define CRC(crcval,newchar) crcval = (crcval >> 8) ^ \
- crc_table[(crcval ^ newchar) & 0x00ff]
+
+unsigned short CRC(unsigned short crcval, unsigned char newchar)
+{
+ return ((crcval >> 8) ^ crc_table[(crcval ^ newchar) & 0x00ff]);
+}
unsigned short
crcsum(const unsigned char* message, unsigned long length,
@@ -53,7 +69,7 @@
for(i = 0; i < length; i++)
{
- CRC(crc, message[i]);
+ crc = CRC(crc, message[i]);
}
return crc;
}
diff -Nu avrdude-5.10/crc16.h avrdude-5.10_avrootloader/crc16.h
--- avrdude-5.10/crc16.h 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/crc16.h 2010-02-17 08:16:07.000000000 +0100
@@ -5,10 +5,16 @@
extern "C" {
#endif
+extern unsigned int calcCRC16r(unsigned int crc, unsigned int c, unsigned int
+mask);
+
+
/*
* Derived from CRC algorithm for JTAG ICE mkII, published in Atmel
* Appnote AVR067. Converted from C++ to C.
*/
+extern unsigned short CRC(unsigned short crcval, unsigned char newchar);
+
extern unsigned short crcsum(const unsigned char* message,
unsigned long length,
Common subdirectories: avrdude-5.10/CVS and avrdude-5.10_avrootloader/CVS
Common subdirectories: avrdude-5.10/doc and avrdude-5.10_avrootloader/doc
diff -Nu avrdude-5.10/lexer.l avrdude-5.10_avrootloader/lexer.l
--- avrdude-5.10/lexer.l 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/lexer.l 2010-02-17 14:29:51.000000000 +0100
@@ -120,6 +120,8 @@
arduino { yylval=NULL; return K_ARDUINO; }
avr910 { yylval=NULL; return K_AVR910; }
avr910_devcode { yylval=NULL; return K_AVR910_DEVCODE; }
+avrootloader { yylval=NULL; return K_AVROOTLOADER; }
+sram { yylval=NULL; return K_SRAM; }
usbasp { yylval=NULL; return K_USBASP; }
usbtiny { yylval=NULL; return K_USBTINY; }
bank_size { yylval=NULL; return K_PAGE_SIZE; }
diff -Nu avrdude-5.10/Makefile.am avrdude-5.10_avrootloader/Makefile.am
--- avrdude-5.10/Makefile.am 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/Makefile.am 2010-02-17 08:16:07.000000000
+0100
@@ -83,6 +83,8 @@
avr.h \
avr910.c \
avr910.h \
+ avrootloader.c \
+ avrootloader.h \
avrdude.h \
avrpart.c \
avrpart.h \
diff -Nu avrdude-5.10/Makefile.in avrdude-5.10_avrootloader/Makefile.in
--- avrdude-5.10/Makefile.in 2010-01-19 11:42:18.000000000 +0100
+++ avrdude-5.10_avrootloader/Makefile.in 2010-02-17 08:28:43.000000000
+0100
@@ -83,6 +83,7 @@
am_libavrdude_a_OBJECTS = libavrdude_a-config_gram.$(OBJEXT) \
libavrdude_a-lexer.$(OBJEXT) libavrdude_a-arduino.$(OBJEXT) \
libavrdude_a-avr.$(OBJEXT) libavrdude_a-avr910.$(OBJEXT) \
+ libavrdude_a-avrootloader.$(OBJEXT) \
libavrdude_a-avrpart.$(OBJEXT) libavrdude_a-bitbang.$(OBJEXT) \
libavrdude_a-buspirate.$(OBJEXT) \
libavrdude_a-butterfly.$(OBJEXT) libavrdude_a-config.$(OBJEXT) \
@@ -305,6 +306,8 @@
avr.h \
avr910.c \
avr910.h \
+ avrootloader.c \
+ avrootloader.h \
avrdude.h \
avrpart.c \
avrpart.h \
@@ -484,6 +487,7 @@
@AMDEP_TRUE@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-arduino...@am__quote@
@AMDEP_TRUE@@am__include@ @am__qu...@./$(DEPDIR)/libavrdude_a-avr...@am__quote@
@AMDEP_TRUE@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-avr910...@am__quote@
+...@amdep_true@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-avrootloader...@am__quote@
@AMDEP_TRUE@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-avrpart...@am__quote@
@AMDEP_TRUE@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-bitbang...@am__quote@
@AMDEP_TRUE@@am__include@
@am__qu...@./$(DEPDIR)/libavrdude_a-buspirate...@am__quote@
@@ -599,6 +603,20 @@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE)
$(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -c -o
libavrdude_a-avr910.obj `if test -f 'avr910.c'; then $(CYGPATH_W) 'avr910.c';
else $(CYGPATH_W) '$(srcdir)/avr910.c'; fi`
+libavrdude_a-avrootloader.o: avrootloader.c
+...@am__fastdepcc_true@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -MT
libavrdude_a-avrootloader.o -MD -MP -MF $(DEPDIR)/libavrdude_a-avrootloader.Tpo
-c -o libavrdude_a-avrootloader.o `test -f 'avrootloader.c' || echo
'$(srcdir)/'`avrootloader.c
+...@am__fastdepcc_true@ mv -f $(DEPDIR)/libavrdude_a-avrootloader.Tpo
$(DEPDIR)/libavrdude_a-avrootloader.Po
+...@amdep_true@@am__fastdepCC_FALSE@ source='avrootloader.c'
object='libavrdude_a-avrootloader.o' libtool=no @AMDEPBACKSLASH@
+...@amdep_true@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE)
$(depcomp) @AMDEPBACKSLASH@
+...@am__fastdepcc_false@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -c -o
libavrdude_a-avrootloader.o `test -f 'avrootloader.c' || echo
'$(srcdir)/'`avrootloader.c
+
+libavrdude_a-avrootloader.obj: avrootloader.c
+...@am__fastdepcc_true@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -MT
libavrdude_a-avrootloader.obj -MD -MP -MF
$(DEPDIR)/libavrdude_a-avrootloader.Tpo -c -o libavrdude_a-avrootloader.obj `if
test -f 'avrootloader.c'; then $(CYGPATH_W) 'avrootloader.c'; else $(CYGPATH_W)
'$(srcdir)/avrootloader.c'; fi`
+...@am__fastdepcc_true@ mv -f $(DEPDIR)/libavrdude_a-avrootloader.Tpo
$(DEPDIR)/libavrdude_a-avrootloader.Po
+...@amdep_true@@am__fastdepCC_FALSE@ source='avrootloader.c'
object='libavrdude_a-avrootloader.obj' libtool=no @AMDEPBACKSLASH@
+...@amdep_true@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE)
$(depcomp) @AMDEPBACKSLASH@
+...@am__fastdepcc_false@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -c -o
libavrdude_a-avrootloader.obj `if test -f 'avrootloader.c'; then $(CYGPATH_W)
'avrootloader.c'; else $(CYGPATH_W) '$(srcdir)/avrootloader.c'; fi`
+
libavrdude_a-avrpart.o: avrpart.c
@am__fastdepCC_TRUE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
$(libavrdude_a_CPPFLAGS) $(CPPFLAGS) $(libavrdude_a_CFLAGS) $(CFLAGS) -MT
libavrdude_a-avrpart.o -MD -MP -MF $(DEPDIR)/libavrdude_a-avrpart.Tpo -c -o
libavrdude_a-avrpart.o `test -f 'avrpart.c' || echo '$(srcdir)/'`avrpart.c
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/libavrdude_a-avrpart.Tpo
$(DEPDIR)/libavrdude_a-avrpart.Po
diff -Nu avrdude-5.10/serial.h avrdude-5.10_avrootloader/serial.h
--- avrdude-5.10/serial.h 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/serial.h 2010-02-17 10:05:27.000000000 +0100
@@ -53,6 +53,7 @@
int (*drain)(union filedescriptor *fd, int display);
int (*set_dtr_rts)(union filedescriptor *fd, int is_on);
+ int (*probe)(union filedescriptor *fd, long serial_sel_timeout);
int flags;
#define SERDEV_FL_NONE 0x0000 /* no flags */
@@ -72,5 +73,6 @@
#define serial_recv (serdev->recv)
#define serial_drain (serdev->drain)
#define serial_set_dtr_rts (serdev->set_dtr_rts)
+#define serial_probe (serdev->probe)
#endif /* serial_h */
diff -Nu avrdude-5.10/ser_posix.c avrdude-5.10_avrootloader/ser_posix.c
--- avrdude-5.10/ser_posix.c 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/ser_posix.c 2010-02-17 10:05:27.000000000
+0100
@@ -354,6 +354,20 @@
return 0;
}
+static int ser_probe(union filedescriptor *fd, long serial_sel_timeout)
+{
+ struct timeval timeout, to2;
+ fd_set rfds;
+
+ timeout.tv_sec = serial_sel_timeout / 1000L;
+ timeout.tv_usec = (serial_sel_timeout % 1000L) * 1000;
+ to2 = timeout;
+
+ FD_ZERO(&rfds);
+ FD_SET(fd->ifd, &rfds);
+
+ return select(fd->ifd + 1, &rfds, NULL, NULL, &to2);
+}
static int ser_recv(union filedescriptor *fd, unsigned char * buf, size_t
buflen)
{
@@ -493,6 +507,7 @@
.recv = ser_recv,
.drain = ser_drain,
.set_dtr_rts = ser_set_dtr_rts,
+ .probe = ser_probe,
.flags = SERDEV_FL_CANSETSPEED,
};
diff -Nu avrdude-5.10/ser_win32.c avrdude-5.10_avrootloader/ser_win32.c
--- avrdude-5.10/ser_win32.c 2010-01-19 11:39:11.000000000 +0100
+++ avrdude-5.10_avrootloader/ser_win32.c 2010-02-17 10:05:27.000000000
+0100
@@ -277,8 +277,10 @@
return 0;
}
-
-
+static int ser_probe(union filedescriptor *fd, long serial_sel_timeout)
+{
+ return 0; // is there something like select for win?
+}
static int ser_recv(union filedescriptor *fd, unsigned char * buf, size_t
buflen)
{
unsigned char c;
_______________________________________________
avrdude-dev mailing list
[email protected]
http://lists.nongnu.org/mailman/listinfo/avrdude-dev
