1 diff -Nur avrdude-5.10.orig/avrdude.conf.in avrdude-5.10.ftdi.new/avrdude.conf.in
2 --- avrdude-5.10.orig/avrdude.conf.in 2010-01-19 20:39:11.000000000 +1000
3 +++ avrdude-5.10.ftdi.new/avrdude.conf.in 2010-06-26 15:21:03.000000000 +1100
5 # desc = <description> ; # quoted string
6 # type = par | stk500 | stk500v2 | stk500pp | stk500hvsp | stk500generic |
7 # stk600 | stk600pp | stk600hvsp |
8 -# avr910 | butterfly | usbasp |
9 +# avr910 | butterfly | usbasp | ft245r |
10 # jtagmki | jtagmkii | jtagmkii_isp | jtagmkii_dw |
11 # jtagmkII_avr32 | jtagmkii_pdi |
12 # dragon_dw | dragon_jtag | dragon_isp | dragon_pp |
20 + desc = "FT232R Synchronous BitBang";
22 + miso = 3; # CTS X3(1)
23 + sck = 5; # DSR X3(2)
24 + mosi = 6; # DCD X3(3)
25 + reset = 7; # RI X3(4)
30 + desc = "FT245R Synchronous BitBang";
40 + desc = "FT232R Synchronous BitBang";
50 desc = "Atmel AVR ISP";
51 diff -Nur avrdude-5.10.orig/config_gram.y avrdude-5.10.ftdi.new/config_gram.y
52 --- avrdude-5.10.orig/config_gram.y 2010-01-19 20:39:11.000000000 +1000
53 +++ avrdude-5.10.ftdi.new/config_gram.y 2010-06-26 15:24:05.000000000 +1100
66 + K_TYPE TKN_EQUAL K_FT245R {
68 + ft245r_initpgm(current_prog);
72 K_TYPE TKN_EQUAL K_USBASP {
74 usbasp_initpgm(current_prog);
75 @@ -1371,10 +1378,10 @@
77 value = v->value.number;
79 - if ((value <= 0) || (value >= 18)) {
80 + if ((value < 0) || (value >= 18)) {
82 "%s: error at line %d of %s: pin must be in the "
85 progname, lineno, infile);
88 diff -Nur avrdude-5.10.orig/configure.ac avrdude-5.10.ftdi.new/configure.ac
89 --- avrdude-5.10.orig/configure.ac 2010-01-19 20:39:11.000000000 +1000
90 +++ avrdude-5.10.ftdi.new/configure.ac 2010-06-27 15:35:38.000000000 +1100
93 [enabled_parport=yes])
95 +#### FTDI BitBang: start ####
96 +AH_TEMPLATE([HAVE_LIBFTDI],
97 + [Define if libftdi is present in system])
98 +AH_TEMPLATE([SUPPORT_FT245R],
99 + [There is FTDI BitBang programming mode])
104 + [--enable-ftdi-bitbang],
105 + [enable FTDI bitbang programming mode (needs libftdi library)]),
106 + [case "${enableval}" in
107 + yes) enabled_ftdi_bitbang=yes ;;
108 + no) enabled_ftdi_bitbang=no ;;
109 + *) AC_MSG_ERROR(bad value ${enableval} for enable-ftdi-bitbang option) ;;
111 + [enabled_ftdi_bitbang=no])
113 +if test "$enabled_ftdi_bitbang" = "yes"; then
114 + PKG_CHECK_MODULES(LIBFTDI, [libftdi], [have_libftdi=yes], [have_libftdi=no])
116 + if test "$have_libftdi" = "yes"; then
117 + AC_DEFINE([HAVE_LIBFTDI])
118 + AC_DEFINE([SUPPORT_FT245R])
119 + CFLAGS="$CFLAGS $LIBFTDI_CFLAGS "
120 + LIBS="$LIBS $LIBFTDI_LIBS"
123 +#### FTDI BitBang: end ####
125 DIST_SUBDIRS_AC='doc windows'
127 if test "$enabled_doc" = "yes"; then
128 @@ -253,10 +283,10 @@
130 AC_TRY_COMPILE(, [ int main () { return 0 ; } ], [
132 - AC_MSG_RESULT([yes])
133 + AC_MSG_RESULT([yes])
136 - AC_MSG_RESULT([no])
137 + AC_MSG_RESULT([no])
141 diff -Nur avrdude-5.10.orig/ft245r.c avrdude-5.10.ftdi.new/ft245r.c
142 --- avrdude-5.10.orig/ft245r.c 1970-01-01 10:00:00.000000000 +1000
143 +++ avrdude-5.10.ftdi.new/ft245r.c 2010-06-27 15:56:20.000000000 +1100
146 + * avrdude - A Downloader/Uploader for AVR device programmers
147 + * Copyright (C) 2003-2004 Theodore A. Roth <troth@openavr.org>
149 + * This program is free software; you can redistribute it and/or modify
150 + * it under the terms of the GNU General Public License as published by
151 + * the Free Software Foundation; either version 2 of the License, or
152 + * (at your option) any later version.
154 + * This program is distributed in the hope that it will be useful,
155 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
156 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
157 + * GNU General Public License for more details.
159 + * You should have received a copy of the GNU General Public License
160 + * along with this program; if not, write to the Free Software
161 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
166 +/* ft245r -- FT245R/FT232R Synchronous BitBangMode Programmer
169 + miso = 1; # RxD / D1
170 + sck = 0; # RTS / D0
171 + mosi = 2; # TxD / D2
172 + reset = 4; # DTR / D4
181 +#include <sys/time.h>
189 +#include "pindefs.h"
191 +#include "bitbang.h"
194 +#define FT245R_DEBUG 0
196 +// Start DEBUG framework
197 +#if FT245R_DEBUG == 1
198 +static int _func_depth = 0;
200 +# define _PRINT_INDENT(depth) {int i; for(i = 0; i < 4 * depth; i++) fprintf(stderr, " ");}
202 +# define DATA_HEX_DUMP(str, buf, len) \
205 + printf("\n%s:\n ", str); \
206 + for (i = 0, j = 0; i < len; i++, j++) \
213 + if (buf[i] < 0x10) \
215 + printf("0x%.2x ", buf[i]); \
219 + printf("0x%.2x ", buf[i]); \
226 +# define FUNC_BEGIN() \
228 + fprintf(stderr, "\n"); \
229 + _PRINT_INDENT(_func_depth); \
230 + fprintf(stderr, "%s(): being\n", __FUNCTION__); \
234 +# define FUNC_END() \
236 + fprintf(stderr, "\n"); \
238 + _PRINT_INDENT(_func_depth); \
239 + fprintf(stderr, "%s(): end\n", __FUNCTION__); \
243 +# define DATA_HEX_DUMP(str, buf, len) {}
244 +# define FUNC_BEGIN(name) {}
245 +# define FUNC_END() {}
248 +// End DEBUG framework
251 +#if defined(_WIN32) || defined(SUPPORT_FT245R)
255 +struct device_info {
260 +// Known devices for auto search and open
261 +static struct device_info devices[] = {
264 + .vendor_id = 0x0403,
265 + .product_id = 0x6001
275 +#define FT245R_CYCLES 2
278 + With big Fragment Size and a lot of REQ_OUTSTANDINGS programmer fail.
279 + Experementaly established that at one time amount of data greated then 384 bytes
280 + can't be writed/readed.
281 + I can't found any documented description for this behaviour.
282 + In any case multiplication
283 + FT245R_FRAGMENT_SIZE*REQ_OUTSTANDINGS
284 + can't be greated then 384. Now I take size information from device info.
286 +//#define FT245R_FRAGMENT_SIZE 512
287 +#define FT245R_FRAGMENT_SIZE (max_packet_size)
288 +#define REQ_OUTSTANDINGS (max_packet_size < 128 ? 2 : max_packet_size / 64)
290 +extern char * progname;
291 +extern int do_cycles;
295 +static struct ftdi_context *handle;
296 +static int max_packet_size;
298 +static unsigned char ft245r_ddr;
299 +static unsigned char ft245r_sck;
300 +static unsigned char ft245r_mosi;
301 +static unsigned char ft245r_reset;
302 +static unsigned char ft245r_miso;
304 +static inline int packet_size()
306 + int packet_size = 64;
307 + struct usb_device *dev;
309 + dev = usb_device(handle->usb_dev);
311 + return packet_size;
313 + if (dev->descriptor.bNumConfigurations > 0 && dev->config)
315 + struct usb_config_descriptor config = dev->config[0];
316 + if (handle->interface < config.bNumInterfaces)
318 + struct usb_interface interface = config.interface[handle->interface];
319 + if (interface.num_altsetting > 0)
321 + struct usb_interface_descriptor descriptor = interface.altsetting[0];
322 + // TODO: check for valid end-point
323 + if (descriptor.bNumEndpoints > 0)
325 + packet_size = descriptor.endpoint[0].wMaxPacketSize;
332 + fprintf(stderr, " ft245r: max packet size = %d\n", packet_size);
334 + return packet_size;
337 +static inline void setbit(unsigned char *data, int pinno, int v)
342 + *data |= (1 << (pinno));
346 + *data &= ~(1 <<(pinno));
351 +static int ft245r_send(PROGRAMMER * pgm, char * buf, size_t len)
356 + r = ftdi_write_data(handle, buf, len);
358 + DATA_HEX_DUMP("WRITED DATA", buf, r);
360 + if (r <= 0 || len != r)
363 + "%s: ft245r_send(): can't write data to programmer: writed = %d, asked = %d, error = %s, error2 = %s\n",
377 +static int ft245r_recv(PROGRAMMER * pgm, char * buf, size_t len)
383 + r = ftdi_read_data(handle, buf, len);
385 + DATA_HEX_DUMP("READED DATA", buf, r);
387 + if (r <= 0 || len != r )
390 + "%s: ft245r_recv(): programmer is not responding: readed = %d / asked = %d, error = %s\n",
394 + handle->error_str);
403 +static int ft245r_drain(PROGRAMMER * pgm, int display)
410 + r = ftdi_set_bitmode(handle, 0, BITMODE_RESET); // reset
411 + if (r != 0) {FUNC_END(); return -1;}
413 + r = ftdi_set_bitmode(handle, ft245r_ddr, BITMODE_SYNCBB); // set Synchronuse BitBang
414 + if (r != 0) {FUNC_END(); return -1;}
416 + // TODO: investigate: how to take amount of bytes in input buffer
417 + //r = FT_GetQueueStatus(handle, &n);
418 + //if (r != FT_OK) return -1;
419 + n = handle->readbuffer_remaining;
422 + fprintf(stderr, "ft245r_drain called but queue is not empty %d \n", n);
429 +static inline int ft245r_sync(PROGRAMMER * pgm)
434 + //r = FT_GetBitMode(handle, &ch);
435 + r = ftdi_read_pins(handle, &ch);
436 + if (r != 0) return -1;
438 + fprintf(stderr, "ft245_sync: readed pins: %d, stored mode: %d\n", ch, handle->bitbang_mode);
443 +static int ft245r_chip_erase(PROGRAMMER * pgm, AVRPART * p)
445 + unsigned char cmd[4];
446 + unsigned char res[4];
450 + if (p->op[AVR_OP_CHIP_ERASE] == NULL)
452 + fprintf(stderr, "chip erase instruction not defined for part \"%s\"\n", p->desc);
457 + memset(cmd, 0, sizeof(cmd));
459 + avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
460 + pgm->cmd(pgm, cmd, res);
461 + usleep(p->chip_erase_delay);
462 + pgm->initialize(pgm, p);
468 +static unsigned char saved_signature[3];
470 +static int valid_rates[] = {
471 + 2400, 4800, 9600, 14400, 19200, 38400, 57600,
472 + 115200, 230400, 460800, 921600, 3000000
475 +static void ft245r_set_bitclock(PROGRAMMER * pgm)
479 + double tmp_rate = 0.0;
484 + if (pgm->bitclock == 0.0) // using default
486 + tmp_rate = 235000.0 / 2.0;
488 + else if (pgm->bitclock >= 0.50 )
490 + tmp_rate = 500000.0 / 2.0;
492 + else if (pgm->bitclock < 0.01)
494 + tmp_rate = 1000.0 / 2.0;
498 + tmp_rate = pgm->bitclock * 1000000.0 / 2.0;
501 + rate = round(tmp_rate);
503 + for (i= sizeof(valid_rates) / sizeof(valid_rates[0]) - 1; i >= 0; --i)
505 + if (valid_rates[i] <= rate)
507 + rate = valid_rates[i];
512 + if (i<0) rate = valid_rates[0];
514 + r = ftdi_set_baudrate(handle, rate);
517 + fprintf(stderr, "ERROR: can't set bit clock to %d\n", rate * 2);
519 + else if ((verbose>=1) || FT245R_DEBUG)
521 + fprintf(stderr," ft245r: bitclk %d -> ft baud %d\n", rate * 2, rate);
527 +static int set_reset(PROGRAMMER * pgm, int val)
529 + unsigned char buf[1];
533 + if (val) buf[0] |= ft245r_reset;
535 + ft245r_send (pgm, buf, 1);
536 + ft245r_recv (pgm, buf, 1);
542 +static int ft245r_cmd(PROGRAMMER * pgm, unsigned char cmd[4], unsigned char res[4]);
544 + * issue the 'program enable' command to the AVR device
546 +static int ft245r_program_enable(PROGRAMMER * pgm, AVRPART * p)
548 + int retry_count = 0;
552 + unsigned char cmd[4];
553 + unsigned char res[4];
557 + ft245r_set_bitclock(pgm);
562 + usleep(5000); // 5ms
564 + usleep(5000); // 5ms
566 + usleep(5000); // 5ms
573 + ft245r_cmd(pgm, cmd, res);
575 + if (res[2] == 0x53 )
578 + for (i = 0; i < 3; i++)
585 + ft245r_cmd(pgm, cmd, res);
586 + saved_signature[i] = res[3];
589 + if (reset_ok && (saved_signature[0] == 0x1e)) // success
595 + if (retry_count < 5)
601 + if ((verbose>=1) || FT245R_DEBUG)
603 + fprintf(stderr, "%s: ft245r_program_enable: failed\n", progname);
611 +static int ft245r_read_sig_bytes(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m)
614 + m->buf[0] = saved_signature[0];
615 + m->buf[1] = saved_signature[1];
616 + m->buf[2] = saved_signature[2];
622 + * initialize the AVR device and prepare it to accept commands
624 +static int ft245r_initialize(PROGRAMMER * pgm, AVRPART * p)
628 + r = ft245r_program_enable(pgm, p);
633 +static void ft245r_disable(PROGRAMMER * pgm)
641 +static void ft245r_enable(PROGRAMMER * pgm)
649 +static inline int set_data(unsigned char *buf, unsigned char data)
652 + int buf_pos = 0x00;
653 + unsigned char bit = 0x80;
657 + for (j = 0; j < 8; j++)
662 + buf[buf_pos] |= ft245r_mosi;
671 + buf[buf_pos] |= ft245r_mosi;
674 + buf[buf_pos] |= ft245r_sck;
684 +static inline unsigned char extract_data(unsigned char *buf, int offset)
688 + unsigned char bit = 0x80;
689 + unsigned char r = 0;
693 + buf += offset * (8 * FT245R_CYCLES);
694 + for (j = 0; j < 8; j++)
696 + if (buf[buf_pos] & ft245r_miso)
700 + buf_pos += FT245R_CYCLES;
709 +static inline unsigned char extract_data_out(unsigned char *buf, int offset)
713 + unsigned char bit = 0x80;
714 + unsigned char r = 0;
718 + buf += offset * (8 * FT245R_CYCLES);
719 + for (j=0; j<8; j++)
721 + if (buf[buf_pos] & ft245r_mosi)
725 + buf_pos += FT245R_CYCLES;
735 + * transmit an AVR device command and return the results; 'cmd' and
736 + * 'res' must point to at least a 4 byte data buffer
738 +static int ft245r_cmd(PROGRAMMER * pgm,
739 + unsigned char cmd[4],
740 + unsigned char res[4])
744 + unsigned char buf[128];
749 + for (i = 0; i < 4; i++)
751 + buf_pos += set_data(buf+buf_pos, cmd[i]);
758 + ft245r_send (pgm, buf, buf_pos);
759 + ft245r_recv (pgm, buf, buf_pos);
761 + res[0] = extract_data(buf, 0);
762 + res[1] = extract_data(buf, 1);
763 + res[2] = extract_data(buf, 2);
764 + res[3] = extract_data(buf, 3);
770 +static int ft245r_open(PROGRAMMER * pgm, char * port)
773 + struct device_info *device = NULL;
774 + unsigned int chip_id;
778 + strcpy(pgm->port, port);
780 + handle = ftdi_new();
781 + if (handle == NULL)
783 + fprintf(stderr, "can't alloc data for ftdi context\n");
788 + if (port != default_parallel)
790 + // TODO: add support for Port by usb ID, like 003/001
792 + struct usb_bus *bus;
793 + struct usb_device *dev;
794 + char dev_string[PATH_MAX + 1];
796 + char dev_found = 0;
802 + r = usb_find_busses();
805 + r = usb_find_devices();
808 + for (bus = usb_get_busses(); bus; bus = bus->next)
810 + for (dev = bus->devices; dev; dev = dev->next)
812 + snprintf(dev_string,
813 + sizeof(dev_string),
818 + min_size = strlen(port) > strlen(dev_string) ? strlen(dev_string) : strlen(port);
820 + if (strncmp(port, dev_string, min_size) == 0)
822 + r = ftdi_usb_open_dev(handle, dev);
828 + if (dev_found == 1)
836 + // Search first avail device
838 + while(device->vendor_id && device->product_id)
840 + r = ftdi_usb_open(handle, device->vendor_id, device->product_id);
849 + fprintf(stderr, "%s: %s open failed \n", progname, port);
854 + max_packet_size = packet_size();
856 + fprintf(stderr, "Chip type: %d\n", handle->type);
857 + ftdi_read_chipid(handle, &chip_id);
858 + fprintf(stderr, "Chip ID: %X\n", chip_id);
860 + ftdi_write_data_set_chunksize(handle, 128);
861 + ftdi_read_data_set_chunksize(handle, 128);
863 + r = ftdi_set_bitmode(handle, 0x00, BITMODE_SYNCBB); // set Synchronuse BitBang
866 + fprintf(stderr, "%s: Synchronuse BitBangMode is not supported\n", progname);
871 + if (verbose || FT245R_DEBUG)
873 + fprintf(stderr, "%s: BitBang OK \n", progname);
878 + setbit(&ft245r_ddr, pgm->pinno[PIN_AVR_SCK], 1);
879 + setbit(&ft245r_ddr, pgm->pinno[PIN_AVR_MOSI], 1);
880 + setbit(&ft245r_ddr, pgm->pinno[PIN_AVR_RESET], 1);
883 + setbit(&ft245r_sck, pgm->pinno[PIN_AVR_SCK], 1);
886 + setbit(&ft245r_mosi, pgm->pinno[PIN_AVR_MOSI], 1);
889 + setbit(&ft245r_reset, pgm->pinno[PIN_AVR_RESET], 1);
892 + setbit(&ft245r_miso, pgm->pinno[PIN_AVR_MISO], 1);
894 + if ((verbose>=1) || FT245R_DEBUG)
897 + "%s: pin assign miso %d sck %d mosi %d reset %d\n",
899 + pgm->pinno[PIN_AVR_MISO],
900 + pgm->pinno[PIN_AVR_SCK],
901 + pgm->pinno[PIN_AVR_MOSI],
902 + pgm->pinno[PIN_AVR_RESET]);
906 + * drain any extraneous input
908 + ft245r_drain (pgm, 0);
909 + if ((verbose>=1) || FT245R_DEBUG)
911 + fprintf(stderr, "%s: drain OK \n", progname);
919 +static void ft245r_close(PROGRAMMER * pgm)
923 + // Set RESET signal to HIGH, MCU should start work
926 + ftdi_usb_close(handle);
932 +static void ft245r_display(PROGRAMMER * pgm, const char * p)
939 +static int ft245r_paged_write_gen(PROGRAMMER * pgm,
950 + for (i = 0; i < n_bytes; i++)
952 + report_progress(i, n_bytes, NULL);
954 + rc = avr_write_byte_default(pgm, p, m, i, m->buf[i]);
964 + * check to see if it is time to flush the page with a page
967 + if (((i % m->page_size) == m->page_size-1) || (i == n_bytes-1))
969 + rc = avr_write_page(pgm, p, m, i);
982 +static struct ft245r_request {
986 + struct ft245r_request *next;
987 +} *req_head, *req_tail, *req_pool;
989 +static void put_request(int addr, int bytes, int n)
991 + struct ft245r_request *p;
998 + req_pool = p->next;
1002 + p = malloc(sizeof(struct ft245r_request));
1005 + fprintf(stderr, "can't alloc memory\n");
1011 + memset(p, 0, sizeof(struct ft245r_request));
1018 + req_tail->next = p;
1023 + req_head = req_tail = p;
1029 +static int do_request(PROGRAMMER * pgm, AVRMEM *m)
1031 + struct ft245r_request * p;
1036 + char buf[FT245R_FRAGMENT_SIZE + 1 + 128];
1047 + req_head = p->next;
1050 + req_tail = req_head;
1056 + memset(p, 0, sizeof(struct ft245r_request));
1057 + p->next = req_pool;
1060 + ft245r_recv(pgm, buf, bytes);
1061 + for (j = 0; j < n; j++)
1063 + m->buf[addr++] = extract_data(buf , (j * 4 + 3));
1067 +if (n == 0) // paged_write
1068 +fprintf(stderr, "recv addr 0x%04x buf size %d \n",addr, bytes);
1075 +static int ft245r_paged_write_flash(PROGRAMMER * pgm,
1086 + int do_page_write;
1088 + char buf[FT245R_FRAGMENT_SIZE + 1 + 128];
1094 + for (i = 0; i < n_bytes; )
1098 + do_page_write = 0;
1100 + for (j = 0; j < FT245R_FRAGMENT_SIZE/8/FT245R_CYCLES/4; j++)
1102 + buf_pos += set_data(buf+buf_pos, (addr & 1) ? 0x48 : 0x40);
1103 + buf_pos += set_data(buf+buf_pos, (addr >> 9) & 0xff );
1104 + buf_pos += set_data(buf+buf_pos, (addr >> 1) & 0xff );
1105 + buf_pos += set_data(buf+buf_pos, m->buf[i]);
1110 + if ( (m->paged) &&
1111 + (((i % m->page_size) == 0) || (i == n_bytes)))
1113 + do_page_write = 1;
1120 + buf[buf_pos++] = 0; // sck down
1123 + ft245r_send(pgm, buf, buf_pos);
1124 + put_request(addr_save, buf_pos, 0);
1125 + //ft245r_sync(pgm);
1128 + if (req_count >= REQ_OUTSTANDINGS)
1129 + do_request(pgm, m);
1131 + if (do_page_write)
1133 + int addr_wk = addr_save - (addr_save % m->page_size);
1136 + while (do_request(pgm, m));
1138 + rc = avr_write_page(pgm, p, m, addr_wk);
1147 + report_progress(i, n_bytes, NULL);
1150 + while (do_request(pgm, m));
1157 +static int ft245r_paged_write(PROGRAMMER * pgm,
1167 + if (strcmp(m->desc, "flash") == 0)
1169 + r = ft245r_paged_write_flash(pgm, p, m, page_size, n_bytes);
1171 + else if (strcmp(m->desc, "eeprom") == 0)
1173 + r = ft245r_paged_write_gen(pgm, p, m, page_size, n_bytes);
1180 +static int ft245r_paged_load_gen(PROGRAMMER * pgm,
1186 + unsigned char rbyte;
1192 + for (i = 0; i < n_bytes; i++)
1194 + rc = avr_read_byte_default(pgm, p, m, i, &rbyte);
1200 + m->buf[i] = rbyte;
1201 + report_progress(i, n_bytes, NULL);
1209 +static int ft245r_paged_load_flash(PROGRAMMER * pgm,
1221 + int req_count = 0;
1222 + char buf[FT245R_FRAGMENT_SIZE + 1];
1227 + for (i = 0; i < n_bytes; )
1231 + for (j = 0; j < FT245R_FRAGMENT_SIZE/8/FT245R_CYCLES/4; j++)
1236 + buf_pos += set_data(buf+buf_pos, (addr & 1)?0x28:0x20 );
1237 + buf_pos += set_data(buf+buf_pos, (addr >> 9) & 0xff );
1238 + buf_pos += set_data(buf+buf_pos, (addr >> 1) & 0xff );
1239 + buf_pos += set_data(buf+buf_pos, 0);
1246 + buf[buf_pos++] = 0; // sck down
1250 + ft245r_send(pgm, buf, buf_pos);
1251 + put_request(addr_save, buf_pos, n);
1254 + if (req_count >= REQ_OUTSTANDINGS)
1255 + do_request(pgm, m);
1257 + report_progress(i, n_bytes, NULL);
1260 + while (do_request(pgm, m)) {}
1266 +static int ft245r_paged_load(PROGRAMMER * pgm,
1275 + if (strcmp(m->desc, "flash") == 0)
1277 + r = ft245r_paged_load_flash(pgm, p, m, page_size, n_bytes);
1279 + else if (strcmp(m->desc, "eeprom") == 0)
1281 + r = ft245r_paged_load_gen(pgm, p, m, page_size, n_bytes);
1288 +void ft245r_initpgm(PROGRAMMER * pgm)
1291 + strcpy(pgm->type, "ft245r");
1294 + * mandatory functions
1296 + pgm->initialize = ft245r_initialize;
1297 + pgm->display = ft245r_display;
1298 + pgm->enable = ft245r_enable;
1299 + pgm->disable = ft245r_disable;
1300 + pgm->program_enable = ft245r_program_enable;
1301 + pgm->chip_erase = ft245r_chip_erase;
1302 + pgm->cmd = ft245r_cmd;
1303 + pgm->open = ft245r_open;
1304 + pgm->close = ft245r_close;
1305 + pgm->read_byte = avr_read_byte_default;
1306 + pgm->write_byte = avr_write_byte_default;
1309 + * optional functions
1311 + pgm->paged_write = ft245r_paged_write;
1312 + pgm->paged_load = ft245r_paged_load;
1314 + pgm->read_sig_bytes = ft245r_read_sig_bytes;
1318 +#else // If FTDI support turned off
1319 +static int ft245r_turned_off()
1322 + fprintf(stderr, " ft245r: support for FTDI BitBang does not compiled in.\n");
1327 +static int ft245r_open(PROGRAMMER * pgm, char * port)
1329 + return ft245r_turned_off();
1332 +static int ft245r_initialize(PROGRAMMER * pgm, AVRPART * p)
1334 + return ft245r_turned_off();;
1337 +void ft245r_initpgm(PROGRAMMER * pgm)
1340 + strcpy(pgm->type, "ft245r");
1341 + pgm->initialize = ft245r_initialize;
1342 + pgm->open = ft245r_open;
1346 diff -Nur avrdude-5.10.orig/ft245r.h avrdude-5.10.ftdi.new/ft245r.h
1347 --- avrdude-5.10.orig/ft245r.h 1970-01-01 10:00:00.000000000 +1000
1348 +++ avrdude-5.10.ftdi.new/ft245r.h 2010-06-26 15:12:58.000000000 +1100
1353 +#include "avrpart.h"
1355 +void ft245r_initpgm (PROGRAMMER * pgm);
1357 +#endif /* ft245r_h */
1358 diff -Nur avrdude-5.10.orig/lexer.l avrdude-5.10.ftdi.new/lexer.l
1359 --- avrdude-5.10.orig/lexer.l 2010-01-19 20:39:11.000000000 +1000
1360 +++ avrdude-5.10.ftdi.new/lexer.l 2010-06-26 15:24:45.000000000 +1100
1362 arduino { yylval=NULL; return K_ARDUINO; }
1363 avr910 { yylval=NULL; return K_AVR910; }
1364 avr910_devcode { yylval=NULL; return K_AVR910_DEVCODE; }
1365 +ft245r { yylval=NULL; return K_FT245R; }
1366 usbasp { yylval=NULL; return K_USBASP; }
1367 usbtiny { yylval=NULL; return K_USBTINY; }
1368 bank_size { yylval=NULL; return K_PAGE_SIZE; }
1369 diff -Nur avrdude-5.10.orig/Makefile.am avrdude-5.10.ftdi.new/Makefile.am
1370 --- avrdude-5.10.orig/Makefile.am 2010-01-19 20:39:11.000000000 +1000
1371 +++ avrdude-5.10.ftdi.new/Makefile.am 2010-06-27 15:41:50.000000000 +1100