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  <address@hidden>
+ * Copyright 2007 Joerg Wunsch <address@hidden>
+ * Copyright 2008 Klaus Leidinger <address@hidden>
+ * Copyright 2009 Sascha Warner <address@hidden>
+ * 
+ * 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  <address@hidden>
+ *
+ * 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@ @address@hidden/$(DEPDIR)/address@hidden@
 @AMDEP_TRUE@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
 @AMDEP_TRUE@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
address@hidden@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
 @AMDEP_TRUE@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
 @AMDEP_TRUE@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
 @AMDEP_TRUE@@am__include@ @address@hidden/$(DEPDIR)/address@hidden@
@@ -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
address@hidden@	$(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
address@hidden@	mv -f $(DEPDIR)/libavrdude_a-avrootloader.Tpo $(DEPDIR)/libavrdude_a-avrootloader.Po
address@hidden@@am__fastdepCC_FALSE@	source='avrootloader.c' object='libavrdude_a-avrootloader.o' libtool=no @AMDEPBACKSLASH@
address@hidden@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
address@hidden@	$(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
address@hidden@	$(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`
address@hidden@	mv -f $(DEPDIR)/libavrdude_a-avrootloader.Tpo $(DEPDIR)/libavrdude_a-avrootloader.Po
address@hidden@@am__fastdepCC_FALSE@	source='avrootloader.c' object='libavrdude_a-avrootloader.obj' libtool=no @AMDEPBACKSLASH@
address@hidden@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
address@hidden@	$(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;