| blob | 4dd236cb6af348d0454914b2ae37e2e2240bde03 |
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
4 @@ -17,7 +17,7 @@
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 |
13 @@ -320,6 +320,37 @@
14 type = arduino;
15 ;
17 +#arduino duemilanove
18 +programmer
19 + id = "duemilanove";
20 + desc = "FT232R Synchronous BitBang";
21 + type = ft245r;
22 + miso = 3; # CTS X3(1)
23 + sck = 5; # DSR X3(2)
24 + mosi = 6; # DCD X3(3)
25 + reset = 7; # RI X3(4)
26 +;
27 +
28 +programmer
29 + id = "ft245r";
30 + desc = "FT245R Synchronous BitBang";
31 + type = ft245r;
32 + miso = 1; # D1
33 + sck = 0; # D0
34 + mosi = 2; # D2
35 + reset = 4; # D4
36 +;
37 +
38 +programmer
39 + id = "ft232r";
40 + desc = "FT232R Synchronous BitBang";
41 + type = ft245r;
42 + miso = 1; # RxD
43 + sck = 0; # RTS
44 + mosi = 2; # TxD
45 + reset = 4; # DTR
46 +;
47 +
48 programmer
49 id = "avrisp";
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
54 @@ -148,6 +148,7 @@
55 %token K_STK600HVSP
56 %token K_STK600PP
57 %token K_AVR910
58 +%token K_FT245R
59 %token K_USBASP
60 %token K_USBTINY
61 %token K_BUTTERFLY
62 @@ -462,6 +463,12 @@
63 }
64 } |
66 + K_TYPE TKN_EQUAL K_FT245R {
67 + {
68 + ft245r_initpgm(current_prog);
69 + }
70 + } |
71 +
72 K_TYPE TKN_EQUAL K_USBASP {
73 {
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)) {
81 fprintf(stderr,
82 "%s: error at line %d of %s: pin must be in the "
83 - "range 1-17\n",
84 + "range 0-17\n",
85 progname, lineno, infile);
86 exit(1);
87 }
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
91 @@ -172,6 +172,36 @@
92 esac],
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])
100 +
101 +AC_ARG_ENABLE(
102 + [ftdi-bitbang],
103 + AC_HELP_STRING(
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) ;;
110 + esac],
111 + [enabled_ftdi_bitbang=no])
112 +
113 +if test "$enabled_ftdi_bitbang" = "yes"; then
114 + PKG_CHECK_MODULES(LIBFTDI, [libftdi], [have_libftdi=yes], [have_libftdi=no])
115 +
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"
121 + fi
122 +fi
123 +#### FTDI BitBang: end ####
124 +
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 ; } ], [
131 no_pointer_sign=yes
132 - AC_MSG_RESULT([yes])
133 + AC_MSG_RESULT([yes])
134 ], [
135 no_pointer_sign=no
136 - AC_MSG_RESULT([no])
137 + AC_MSG_RESULT([no])
138 ])
139 CFLAGS=$safe_CFLAGS
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
144 @@ -0,0 +1,1201 @@
145 +/*
146 + * avrdude - A Downloader/Uploader for AVR device programmers
147 + * Copyright (C) 2003-2004 Theodore A. Roth <troth@openavr.org>
148 + *
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.
153 + *
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.
158 + *
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
162 + */
163 +
164 +/* $Id$ */
165 +
166 +/* ft245r -- FT245R/FT232R Synchronous BitBangMode Programmer
167 + default pin assign
168 + FT232R / FT245R
169 + miso = 1; # RxD / D1
170 + sck = 0; # RTS / D0
171 + mosi = 2; # TxD / D2
172 + reset = 4; # DTR / D4
173 +*/
174 +
175 +#include "ac_cfg.h"
176 +
177 +#include <stdio.h>
178 +#include <stdlib.h>
179 +#include <string.h>
180 +#include <errno.h>
181 +#include <sys/time.h>
182 +#include <unistd.h>
183 +
184 +#include <errno.h>
185 +#include <math.h>
186 +
187 +#include "config.h"
188 +#include "avr.h"
189 +#include "pindefs.h"
190 +#include "pgm.h"
191 +#include "bitbang.h"
192 +#include "ft245r.h"
193 +
194 +#define FT245R_DEBUG 0
195 +
196 +// Start DEBUG framework
197 +#if FT245R_DEBUG == 1
198 +static int _func_depth = 0;
199 +
200 +# define _PRINT_INDENT(depth) {int i; for(i = 0; i < 4 * depth; i++) fprintf(stderr, " ");}
201 +
202 +# define DATA_HEX_DUMP(str, buf, len) \
203 + { \
204 + int i, j; \
205 + printf("\n%s:\n ", str); \
206 + for (i = 0, j = 0; i < len; i++, j++) \
207 + { \
208 + if (j == 16) \
209 + { \
210 + j = 0; \
211 + printf("\n "); \
212 + } \
213 + if (buf[i] < 0x10) \
214 + {\
215 + printf("0x%.2x ", buf[i]); \
216 + } \
217 + else \
218 + { \
219 + printf("0x%.2x ", buf[i]); \
220 + } \
221 + } \
222 + printf("\n"); \
223 + }
224 +
225 +
226 +# define FUNC_BEGIN() \
227 + { \
228 + fprintf(stderr, "\n"); \
229 + _PRINT_INDENT(_func_depth); \
230 + fprintf(stderr, "%s(): being\n", __FUNCTION__); \
231 + _func_depth++; \
232 + }
233 +
234 +# define FUNC_END() \
235 + { \
236 + fprintf(stderr, "\n"); \
237 + _func_depth--; \
238 + _PRINT_INDENT(_func_depth); \
239 + fprintf(stderr, "%s(): end\n", __FUNCTION__); \
240 + }
241 +
242 +#else
243 +# define DATA_HEX_DUMP(str, buf, len) {}
244 +# define FUNC_BEGIN(name) {}
245 +# define FUNC_END() {}
246 +#endif
247 +
248 +// End DEBUG framework
249 +
250 +
251 +#if defined(_WIN32) || defined(SUPPORT_FT245R)
252 +
253 +#include <ftdi.h>
254 +
255 +struct device_info {
256 + int vendor_id;
257 + int product_id;
258 +};
259 +
260 +// Known devices for auto search and open
261 +static struct device_info devices[] = {
262 + // FT232R, FT232RL
263 + {
264 + .vendor_id = 0x0403,
265 + .product_id = 0x6001
266 + },
267 +
268 + // List end
269 + {
270 + .vendor_id = 0x00,
271 + .product_id = 0x00
272 + },
273 +};
274 +
275 +#define FT245R_CYCLES 2
276 +
277 +/*
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.
285 +*/
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)
289 +
290 +extern char * progname;
291 +extern int do_cycles;
292 +extern int ovsigck;
293 +extern int verbose;
294 +
295 +static struct ftdi_context *handle;
296 +static int max_packet_size;
297 +
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;
303 +
304 +static inline int packet_size()
305 +{
306 + int packet_size = 64;
307 + struct usb_device *dev;
308 +
309 + dev = usb_device(handle->usb_dev);
310 + if (dev == NULL)
311 + return packet_size;
312 +
313 + if (dev->descriptor.bNumConfigurations > 0 && dev->config)
314 + {
315 + struct usb_config_descriptor config = dev->config[0];
316 + if (handle->interface < config.bNumInterfaces)
317 + {
318 + struct usb_interface interface = config.interface[handle->interface];
319 + if (interface.num_altsetting > 0)
320 + {
321 + struct usb_interface_descriptor descriptor = interface.altsetting[0];
322 + // TODO: check for valid end-point
323 + if (descriptor.bNumEndpoints > 0)
324 + {
325 + packet_size = descriptor.endpoint[0].wMaxPacketSize;
326 + }
327 + }
328 + }
329 + }
330 +
331 + if (verbose)
332 + fprintf(stderr, " ft245r: max packet size = %d\n", packet_size);
333 +
334 + return packet_size;
335 +}
336 +
337 +static inline void setbit(unsigned char *data, int pinno, int v)
338 +{
339 + FUNC_BEGIN();
340 + if (v)
341 + {
342 + *data |= (1 << (pinno));
343 + }
344 + else
345 + {
346 + *data &= ~(1 <<(pinno));
347 + }
348 + FUNC_END();
349 +}
350 +
351 +static int ft245r_send(PROGRAMMER * pgm, char * buf, size_t len)
352 +{
353 + FUNC_BEGIN();
354 + int r = -1;
355 + int ret = 0;
356 + r = ftdi_write_data(handle, buf, len);
357 +
358 + DATA_HEX_DUMP("WRITED DATA", buf, r);
359 +
360 + if (r <= 0 || len != r)
361 + {
362 + fprintf(stderr,
363 + "%s: ft245r_send(): can't write data to programmer: writed = %d, asked = %d, error = %s, error2 = %s\n",
364 + progname,
365 + r,
366 + len,
367 + handle->error_str,
368 + strerror(errno));
369 + ret = -1;
370 + }
371 +
372 + FUNC_END();
373 + return ret;
374 +}
375 +
376 +
377 +static int ft245r_recv(PROGRAMMER * pgm, char * buf, size_t len)
378 +{
379 + int r;
380 + int ret = 0;
381 + FUNC_BEGIN();
382 +
383 + r = ftdi_read_data(handle, buf, len);
384 +
385 + DATA_HEX_DUMP("READED DATA", buf, r);
386 +
387 + if (r <= 0 || len != r )
388 + {
389 + fprintf(stderr,
390 + "%s: ft245r_recv(): programmer is not responding: readed = %d / asked = %d, error = %s\n",
391 + progname,
392 + r,
393 + len,
394 + handle->error_str);
395 + ret = -1;
396 + }
397 +
398 + FUNC_END();
399 + return ret;
400 +}
401 +
402 +
403 +static int ft245r_drain(PROGRAMMER * pgm, int display)
404 +{
405 + int r;
406 + int n;
407 +
408 + FUNC_BEGIN();
409 +
410 + r = ftdi_set_bitmode(handle, 0, BITMODE_RESET); // reset
411 + if (r != 0) {FUNC_END(); return -1;}
412 +
413 + r = ftdi_set_bitmode(handle, ft245r_ddr, BITMODE_SYNCBB); // set Synchronuse BitBang
414 + if (r != 0) {FUNC_END(); return -1;}
415 +
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;
420 + if (n)
421 + {
422 + fprintf(stderr, "ft245r_drain called but queue is not empty %d \n", n);
423 + }
424 +
425 + FUNC_END();
426 + return 0;
427 +}
428 +
429 +static inline int ft245r_sync(PROGRAMMER * pgm)
430 +{
431 + // TODO
432 + int r;
433 + unsigned char ch;
434 + //r = FT_GetBitMode(handle, &ch);
435 + r = ftdi_read_pins(handle, &ch);
436 + if (r != 0) return -1;
437 +
438 + fprintf(stderr, "ft245_sync: readed pins: %d, stored mode: %d\n", ch, handle->bitbang_mode);
439 +
440 + return 0;
441 +}
442 +
443 +static int ft245r_chip_erase(PROGRAMMER * pgm, AVRPART * p)
444 +{
445 + unsigned char cmd[4];
446 + unsigned char res[4];
447 +
448 + FUNC_BEGIN();
449 +
450 + if (p->op[AVR_OP_CHIP_ERASE] == NULL)
451 + {
452 + fprintf(stderr, "chip erase instruction not defined for part \"%s\"\n", p->desc);
453 + FUNC_END();
454 + return -1;
455 + }
456 +
457 + memset(cmd, 0, sizeof(cmd));
458 +
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);
463 +
464 + FUNC_END();
465 + return 0;
466 +}
467 +
468 +static unsigned char saved_signature[3];
469 +
470 +static int valid_rates[] = {
471 + 2400, 4800, 9600, 14400, 19200, 38400, 57600,
472 + 115200, 230400, 460800, 921600, 3000000
473 +};
474 +
475 +static void ft245r_set_bitclock(PROGRAMMER * pgm)
476 +{
477 + int r;
478 + int rate = 0;
479 + double tmp_rate = 0.0;
480 + int i;
481 +
482 + FUNC_BEGIN();
483 +
484 + if (pgm->bitclock == 0.0) // using default
485 + {
486 + tmp_rate = 235000.0 / 2.0;
487 + }
488 + else if (pgm->bitclock >= 0.50 )
489 + {
490 + tmp_rate = 500000.0 / 2.0;
491 + }
492 + else if (pgm->bitclock < 0.01)
493 + {
494 + tmp_rate = 1000.0 / 2.0;
495 + }
496 + else
497 + {
498 + tmp_rate = pgm->bitclock * 1000000.0 / 2.0;
499 + }
500 +
501 + rate = round(tmp_rate);
502 +
503 + for (i= sizeof(valid_rates) / sizeof(valid_rates[0]) - 1; i >= 0; --i)
504 + {
505 + if (valid_rates[i] <= rate)
506 + {
507 + rate = valid_rates[i];
508 + break;
509 + }
510 + }
511 +
512 + if (i<0) rate = valid_rates[0];
513 +
514 + r = ftdi_set_baudrate(handle, rate);
515 + if (r < 0)
516 + {
517 + fprintf(stderr, "ERROR: can't set bit clock to %d\n", rate * 2);
518 + }
519 + else if ((verbose>=1) || FT245R_DEBUG)
520 + {
521 + fprintf(stderr," ft245r: bitclk %d -> ft baud %d\n", rate * 2, rate);
522 + }
523 +
524 + FUNC_END();
525 +}
526 +
527 +static int set_reset(PROGRAMMER * pgm, int val)
528 +{
529 + unsigned char buf[1];
530 + FUNC_BEGIN();
531 +
532 + buf[0] = 0;
533 + if (val) buf[0] |= ft245r_reset;
534 +
535 + ft245r_send (pgm, buf, 1);
536 + ft245r_recv (pgm, buf, 1);
537 +
538 + FUNC_END();
539 + return 0;
540 +}
541 +
542 +static int ft245r_cmd(PROGRAMMER * pgm, unsigned char cmd[4], unsigned char res[4]);
543 +/*
544 + * issue the 'program enable' command to the AVR device
545 + */
546 +static int ft245r_program_enable(PROGRAMMER * pgm, AVRPART * p)
547 +{
548 + int retry_count = 0;
549 + int i;
550 + int reset_ok;
551 +
552 + unsigned char cmd[4];
553 + unsigned char res[4];
554 +
555 + FUNC_BEGIN();
556 +
557 + ft245r_set_bitclock(pgm);
558 +
559 +retry:
560 + reset_ok = 0;
561 + set_reset(pgm, 0);
562 + usleep(5000); // 5ms
563 + set_reset(pgm, 1);
564 + usleep(5000); // 5ms
565 + set_reset(pgm, 0);
566 + usleep(5000); // 5ms
567 +
568 + cmd[0] = 0xAC;
569 + cmd[1] = 0x53;
570 + cmd[2] = 0;
571 + cmd[3] = 0;
572 +
573 + ft245r_cmd(pgm, cmd, res);
574 +
575 + if (res[2] == 0x53 )
576 + reset_ok = 1;
577 +
578 + for (i = 0; i < 3; i++)
579 + {
580 + cmd[0] = 0x30;
581 + cmd[1] = 0;
582 + cmd[2] = i;
583 + cmd[3] = 0;
584 +
585 + ft245r_cmd(pgm, cmd, res);
586 + saved_signature[i] = res[3];
587 + }
588 +
589 + if (reset_ok && (saved_signature[0] == 0x1e)) // success
590 + {
591 + FUNC_END();
592 + return 0;
593 + }
594 +
595 + if (retry_count < 5)
596 + {
597 + retry_count++;
598 + goto retry;
599 + }
600 +
601 + if ((verbose>=1) || FT245R_DEBUG)
602 + {
603 + fprintf(stderr, "%s: ft245r_program_enable: failed\n", progname);
604 + fflush(stderr);
605 + }
606 +
607 + FUNC_END();
608 + return -1;
609 +}
610 +
611 +static int ft245r_read_sig_bytes(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m)
612 +{
613 + FUNC_BEGIN();
614 + m->buf[0] = saved_signature[0];
615 + m->buf[1] = saved_signature[1];
616 + m->buf[2] = saved_signature[2];
617 + FUNC_END();
618 + return 3;
619 +}
620 +
621 +/*
622 + * initialize the AVR device and prepare it to accept commands
623 + */
624 +static int ft245r_initialize(PROGRAMMER * pgm, AVRPART * p)
625 +{
626 + int r;
627 + FUNC_BEGIN();
628 + r = ft245r_program_enable(pgm, p);
629 + FUNC_END();
630 + return r;
631 +}
632 +
633 +static void ft245r_disable(PROGRAMMER * pgm)
634 +{
635 + FUNC_BEGIN();
636 + FUNC_END();
637 + return;
638 +}
639 +
640 +
641 +static void ft245r_enable(PROGRAMMER * pgm)
642 +{
643 + /* Do nothing. */
644 + FUNC_BEGIN();
645 + FUNC_END();
646 + return;
647 +}
648 +
649 +static inline int set_data(unsigned char *buf, unsigned char data)
650 +{
651 + int j;
652 + int buf_pos = 0x00;
653 + unsigned char bit = 0x80;
654 +
655 + FUNC_BEGIN();
656 +
657 + for (j = 0; j < 8; j++)
658 + {
659 + buf[buf_pos] = 0;
660 + if (data & bit)
661 + {
662 + buf[buf_pos] |= ft245r_mosi;
663 + }
664 +
665 + buf_pos++;
666 +
667 + buf[buf_pos] = 0;
668 +
669 + if (data & bit)
670 + {
671 + buf[buf_pos] |= ft245r_mosi;
672 + }
673 +
674 + buf[buf_pos] |= ft245r_sck;
675 + buf_pos++;
676 +
677 + bit >>= 1;
678 + }
679 +
680 + FUNC_END();
681 + return buf_pos;
682 +}
683 +
684 +static inline unsigned char extract_data(unsigned char *buf, int offset)
685 +{
686 + int j;
687 + int buf_pos = 1;
688 + unsigned char bit = 0x80;
689 + unsigned char r = 0;
690 +
691 + FUNC_BEGIN();
692 +
693 + buf += offset * (8 * FT245R_CYCLES);
694 + for (j = 0; j < 8; j++)
695 + {
696 + if (buf[buf_pos] & ft245r_miso)
697 + {
698 + r |= bit;
699 + }
700 + buf_pos += FT245R_CYCLES;
701 + bit >>= 1;
702 + }
703 +
704 + FUNC_END();
705 + return r;
706 +}
707 +
708 +/* to check data */
709 +static inline unsigned char extract_data_out(unsigned char *buf, int offset)
710 +{
711 + int j;
712 + int buf_pos = 1;
713 + unsigned char bit = 0x80;
714 + unsigned char r = 0;
715 +
716 + FUNC_BEGIN();
717 +
718 + buf += offset * (8 * FT245R_CYCLES);
719 + for (j=0; j<8; j++)
720 + {
721 + if (buf[buf_pos] & ft245r_mosi)
722 + {
723 + r |= bit;
724 + }
725 + buf_pos += FT245R_CYCLES;
726 + bit >>= 1;
727 + }
728 +
729 + FUNC_END();
730 + return r;
731 +}
732 +
733 +
734 +/*
735 + * transmit an AVR device command and return the results; 'cmd' and
736 + * 'res' must point to at least a 4 byte data buffer
737 + */
738 +static int ft245r_cmd(PROGRAMMER * pgm,
739 + unsigned char cmd[4],
740 + unsigned char res[4])
741 +{
742 + int i;
743 + int buf_pos;
744 + unsigned char buf[128];
745 +
746 + FUNC_BEGIN();
747 +
748 + buf_pos = 0;
749 + for (i = 0; i < 4; i++)
750 + {
751 + buf_pos += set_data(buf+buf_pos, cmd[i]);
752 + }
753 +
754 + buf[buf_pos] = 0;
755 + buf_pos++;
756 +
757 +
758 + ft245r_send (pgm, buf, buf_pos);
759 + ft245r_recv (pgm, buf, buf_pos);
760 +
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);
765 +
766 + FUNC_END();
767 + return 0;
768 +}
769 +
770 +static int ft245r_open(PROGRAMMER * pgm, char * port)
771 +{
772 + int r = -1;
773 + struct device_info *device = NULL;
774 + unsigned int chip_id;
775 +
776 + FUNC_BEGIN();
777 +
778 + strcpy(pgm->port, port);
779 +
780 + handle = ftdi_new();
781 + if (handle == NULL)
782 + {
783 + fprintf(stderr, "can't alloc data for ftdi context\n");
784 + FUNC_END();
785 + exit(1);
786 + }
787 +
788 + if (port != default_parallel)
789 + {
790 + // TODO: add support for Port by usb ID, like 003/001
791 + // or by chip id
792 + struct usb_bus *bus;
793 + struct usb_device *dev;
794 + char dev_string[PATH_MAX + 1];
795 + int min_size;
796 + char dev_found = 0;
797 +
798 + do
799 + {
800 + usb_init();
801 +
802 + r = usb_find_busses();
803 + if (r < 0) break;
804 +
805 + r = usb_find_devices();
806 + if (r < 0) break;
807 +
808 + for (bus = usb_get_busses(); bus; bus = bus->next)
809 + {
810 + for (dev = bus->devices; dev; dev = dev->next)
811 + {
812 + snprintf(dev_string,
813 + sizeof(dev_string),
814 + "%s/%s",
815 + bus->dirname,
816 + dev->filename);
817 +
818 + min_size = strlen(port) > strlen(dev_string) ? strlen(dev_string) : strlen(port);
819 +
820 + if (strncmp(port, dev_string, min_size) == 0)
821 + {
822 + r = ftdi_usb_open_dev(handle, dev);
823 + dev_found = 1;
824 + break;
825 + }
826 + }
827 +
828 + if (dev_found == 1)
829 + break;
830 + }
831 + }
832 + while(0);
833 + }
834 + else
835 + {
836 + // Search first avail device
837 + device = devices;
838 + while(device->vendor_id && device->product_id)
839 + {
840 + r = ftdi_usb_open(handle, device->vendor_id, device->product_id);
841 + if (r == 0)
842 + break;
843 + device++;
844 + }
845 + }
846 +
847 + if (r != 0)
848 + {
849 + fprintf(stderr, "%s: %s open failed \n", progname, port);
850 + FUNC_END();
851 + exit(1);
852 + }
853 +
854 + max_packet_size = packet_size();
855 +
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);
859 +
860 + ftdi_write_data_set_chunksize(handle, 128);
861 + ftdi_read_data_set_chunksize(handle, 128);
862 +
863 + r = ftdi_set_bitmode(handle, 0x00, BITMODE_SYNCBB); // set Synchronuse BitBang
864 + if (r != 0)
865 + {
866 + fprintf(stderr, "%s: Synchronuse BitBangMode is not supported\n", progname);
867 + FUNC_END();
868 + exit(1);
869 + }
870 +
871 + if (verbose || FT245R_DEBUG)
872 + {
873 + fprintf(stderr, "%s: BitBang OK \n", progname);
874 + fflush(stderr);
875 + }
876 +
877 + ft245r_ddr = 0;
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);
881 +
882 + ft245r_sck = 0;
883 + setbit(&ft245r_sck, pgm->pinno[PIN_AVR_SCK], 1);
884 +
885 + ft245r_mosi = 0;
886 + setbit(&ft245r_mosi, pgm->pinno[PIN_AVR_MOSI], 1);
887 +
888 + ft245r_reset = 0;
889 + setbit(&ft245r_reset, pgm->pinno[PIN_AVR_RESET], 1);
890 +
891 + ft245r_miso = 0;
892 + setbit(&ft245r_miso, pgm->pinno[PIN_AVR_MISO], 1);
893 +
894 + if ((verbose>=1) || FT245R_DEBUG)
895 + {
896 + fprintf(stderr,
897 + "%s: pin assign miso %d sck %d mosi %d reset %d\n",
898 + progname,
899 + pgm->pinno[PIN_AVR_MISO],
900 + pgm->pinno[PIN_AVR_SCK],
901 + pgm->pinno[PIN_AVR_MOSI],
902 + pgm->pinno[PIN_AVR_RESET]);
903 + }
904 +
905 + /*
906 + * drain any extraneous input
907 + */
908 + ft245r_drain (pgm, 0);
909 + if ((verbose>=1) || FT245R_DEBUG)
910 + {
911 + fprintf(stderr, "%s: drain OK \n", progname);
912 + fflush(stderr);
913 + }
914 +
915 + FUNC_END();
916 + return 0;
917 +}
918 +
919 +static void ft245r_close(PROGRAMMER * pgm)
920 +{
921 + FUNC_BEGIN();
922 +
923 + // Set RESET signal to HIGH, MCU should start work
924 + set_reset(pgm, 1);
925 +
926 + ftdi_usb_close(handle);
927 + ftdi_free(handle);
928 +
929 + FUNC_END();
930 +}
931 +
932 +static void ft245r_display(PROGRAMMER * pgm, const char * p)
933 +{
934 + FUNC_BEGIN();
935 + FUNC_END();
936 + return;
937 +}
938 +
939 +static int ft245r_paged_write_gen(PROGRAMMER * pgm,
940 + AVRPART * p,
941 + AVRMEM * m,
942 + int page_size,
943 + int n_bytes)
944 +{
945 + unsigned long i;
946 + int rc;
947 +
948 + FUNC_BEGIN();
949 +
950 + for (i = 0; i < n_bytes; i++)
951 + {
952 + report_progress(i, n_bytes, NULL);
953 +
954 + rc = avr_write_byte_default(pgm, p, m, i, m->buf[i]);
955 + if (rc != 0)
956 + {
957 + FUNC_END();
958 + return -2;
959 + }
960 +
961 + if (m->paged)
962 + {
963 + /*
964 + * check to see if it is time to flush the page with a page
965 + * write
966 + */
967 + if (((i % m->page_size) == m->page_size-1) || (i == n_bytes-1))
968 + {
969 + rc = avr_write_page(pgm, p, m, i);
970 + if (rc != 0)
971 + {
972 + FUNC_END();
973 + return -2;
974 + }
975 + }
976 + }
977 + }
978 +
979 + return i;
980 +}
981 +
982 +static struct ft245r_request {
983 + int addr;
984 + int bytes;
985 + int n;
986 + struct ft245r_request *next;
987 +} *req_head, *req_tail, *req_pool;
988 +
989 +static void put_request(int addr, int bytes, int n)
990 +{
991 + struct ft245r_request *p;
992 +
993 + FUNC_BEGIN();
994 +
995 + if (req_pool)
996 + {
997 + p = req_pool;
998 + req_pool = p->next;
999 + }
1000 + else
1001 + {
1002 + p = malloc(sizeof(struct ft245r_request));
1003 + if (!p)
1004 + {
1005 + fprintf(stderr, "can't alloc memory\n");
1006 + FUNC_END();
1007 + exit(1);
1008 + }
1009 + }
1010 +
1011 + memset(p, 0, sizeof(struct ft245r_request));
1012 + p->addr = addr;
1013 + p->bytes = bytes;
1014 + p->n = n;
1015 +
1016 + if (req_tail)
1017 + {
1018 + req_tail->next = p;
1019 + req_tail = p;
1020 + }
1021 + else
1022 + {
1023 + req_head = req_tail = p;
1024 + }
1025 +
1026 + FUNC_END();
1027 +}
1028 +
1029 +static int do_request(PROGRAMMER * pgm, AVRMEM *m)
1030 +{
1031 + struct ft245r_request * p;
1032 + int addr;
1033 + int bytes;
1034 + int j;
1035 + int n;
1036 + char buf[FT245R_FRAGMENT_SIZE + 1 + 128];
1037 +
1038 + FUNC_BEGIN();
1039 +
1040 + if (!req_head)
1041 + {
1042 + FUNC_END();
1043 + return 0;
1044 + }
1045 +
1046 + p = req_head;
1047 + req_head = p->next;
1048 + if (!req_head)
1049 + {
1050 + req_tail = req_head;
1051 + }
1052 +
1053 + addr = p->addr;
1054 + bytes = p->bytes;
1055 + n = p->n;
1056 + memset(p, 0, sizeof(struct ft245r_request));
1057 + p->next = req_pool;
1058 + req_pool = p;
1059 +
1060 + ft245r_recv(pgm, buf, bytes);
1061 + for (j = 0; j < n; j++)
1062 + {
1063 + m->buf[addr++] = extract_data(buf , (j * 4 + 3));
1064 + }
1065 +
1066 +#if 0
1067 +if (n == 0) // paged_write
1068 +fprintf(stderr, "recv addr 0x%04x buf size %d \n",addr, bytes);
1069 +#endif
1070 +
1071 + FUNC_END();
1072 + return 1;
1073 +}
1074 +
1075 +static int ft245r_paged_write_flash(PROGRAMMER * pgm,
1076 + AVRPART * p,
1077 + AVRMEM * m,
1078 + int page_size,
1079 + int n_bytes)
1080 +{
1081 + unsigned int i;
1082 + unsigned int j;
1083 + int addr;
1084 + int addr_save;
1085 + int buf_pos;
1086 + int do_page_write;
1087 + int req_count;
1088 + char buf[FT245R_FRAGMENT_SIZE + 1 + 128];
1089 +
1090 + FUNC_BEGIN();
1091 +
1092 + req_count = 0;
1093 + addr = 0;
1094 + for (i = 0; i < n_bytes; )
1095 + {
1096 + addr_save = addr;
1097 + buf_pos = 0;
1098 + do_page_write = 0;
1099 +
1100 + for (j = 0; j < FT245R_FRAGMENT_SIZE/8/FT245R_CYCLES/4; j++)
1101 + {
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]);
1106 +
1107 + addr++;
1108 + i++;
1109 +
1110 + if ( (m->paged) &&
1111 + (((i % m->page_size) == 0) || (i == n_bytes)))
1112 + {
1113 + do_page_write = 1;
1114 + break;
1115 + }
1116 + }
1117 +
1118 + if (i >= n_bytes)
1119 + {
1120 + buf[buf_pos++] = 0; // sck down
1121 + }
1122 +
1123 + ft245r_send(pgm, buf, buf_pos);
1124 + put_request(addr_save, buf_pos, 0);
1125 + //ft245r_sync(pgm);
1126 +
1127 + req_count++;
1128 + if (req_count >= REQ_OUTSTANDINGS)
1129 + do_request(pgm, m);
1130 +
1131 + if (do_page_write)
1132 + {
1133 + int addr_wk = addr_save - (addr_save % m->page_size);
1134 + int rc;
1135 +
1136 + while (do_request(pgm, m));
1137 +
1138 + rc = avr_write_page(pgm, p, m, addr_wk);
1139 + if (rc != 0)
1140 + {
1141 + FUNC_END();
1142 + return -2;
1143 + }
1144 +
1145 + req_count = 0;
1146 + }
1147 + report_progress(i, n_bytes, NULL);
1148 + }
1149 +
1150 + while (do_request(pgm, m));
1151 +
1152 + FUNC_END();
1153 + return i;
1154 +}
1155 +
1156 +
1157 +static int ft245r_paged_write(PROGRAMMER * pgm,
1158 + AVRPART * p,
1159 + AVRMEM * m,
1160 + int page_size,
1161 + int n_bytes)
1162 +{
1163 + FUNC_BEGIN();
1164 +
1165 + int r = -2;
1166 +
1167 + if (strcmp(m->desc, "flash") == 0)
1168 + {
1169 + r = ft245r_paged_write_flash(pgm, p, m, page_size, n_bytes);
1170 + }
1171 + else if (strcmp(m->desc, "eeprom") == 0)
1172 + {
1173 + r = ft245r_paged_write_gen(pgm, p, m, page_size, n_bytes);
1174 + }
1175 +
1176 + FUNC_END();
1177 + return r;
1178 +}
1179 +
1180 +static int ft245r_paged_load_gen(PROGRAMMER * pgm,
1181 + AVRPART * p,
1182 + AVRMEM * m,
1183 + int page_size,
1184 + int n_bytes)
1185 +{
1186 + unsigned char rbyte;
1187 + unsigned long i;
1188 + int rc;
1189 +
1190 + FUNC_BEGIN();
1191 +
1192 + for (i = 0; i < n_bytes; i++)
1193 + {
1194 + rc = avr_read_byte_default(pgm, p, m, i, &rbyte);
1195 + if (rc != 0)
1196 + {
1197 + FUNC_END();
1198 + return -2;
1199 + }
1200 + m->buf[i] = rbyte;
1201 + report_progress(i, n_bytes, NULL);
1202 + }
1203 +
1204 + FUNC_END();
1205 + return 0;
1206 +}
1207 +
1208 +
1209 +static int ft245r_paged_load_flash(PROGRAMMER * pgm,
1210 + AVRPART * p,
1211 + AVRMEM * m,
1212 + int page_size,
1213 + int n_bytes)
1214 +{
1215 + unsigned long i;
1216 + unsigned long j;
1217 + unsigned long n;
1218 + int addr;
1219 + int addr_save;
1220 + int buf_pos;
1221 + int req_count = 0;
1222 + char buf[FT245R_FRAGMENT_SIZE + 1];
1223 +
1224 + FUNC_BEGIN();
1225 +
1226 + addr = 0;
1227 + for (i = 0; i < n_bytes; )
1228 + {
1229 + buf_pos = 0;
1230 + addr_save = addr;
1231 + for (j = 0; j < FT245R_FRAGMENT_SIZE/8/FT245R_CYCLES/4; j++)
1232 + {
1233 + if (i >= n_bytes)
1234 + break;
1235 +
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);
1240 + addr++;
1241 + i++;
1242 + }
1243 +
1244 + if (i >= n_bytes)
1245 + {
1246 + buf[buf_pos++] = 0; // sck down
1247 + }
1248 +
1249 + n = j;
1250 + ft245r_send(pgm, buf, buf_pos);
1251 + put_request(addr_save, buf_pos, n);
1252 + req_count++;
1253 +
1254 + if (req_count >= REQ_OUTSTANDINGS)
1255 + do_request(pgm, m);
1256 +
1257 + report_progress(i, n_bytes, NULL);
1258 + }
1259 +
1260 + while (do_request(pgm, m)) {}
1261 +
1262 + FUNC_END();
1263 + return 0;
1264 +}
1265 +
1266 +static int ft245r_paged_load(PROGRAMMER * pgm,
1267 + AVRPART * p,
1268 + AVRMEM * m,
1269 + int page_size,
1270 + int n_bytes)
1271 +{
1272 + int r = -2;
1273 + FUNC_BEGIN();
1274 +
1275 + if (strcmp(m->desc, "flash") == 0)
1276 + {
1277 + r = ft245r_paged_load_flash(pgm, p, m, page_size, n_bytes);
1278 + }
1279 + else if (strcmp(m->desc, "eeprom") == 0)
1280 + {
1281 + r = ft245r_paged_load_gen(pgm, p, m, page_size, n_bytes);
1282 + }
1283 +
1284 + FUNC_END();
1285 + return r;
1286 +}
1287 +
1288 +void ft245r_initpgm(PROGRAMMER * pgm)
1289 +{
1290 + FUNC_BEGIN();
1291 + strcpy(pgm->type, "ft245r");
1292 +
1293 + /*
1294 + * mandatory functions
1295 + */
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;
1307 +
1308 + /*
1309 + * optional functions
1310 + */
1311 + pgm->paged_write = ft245r_paged_write;
1312 + pgm->paged_load = ft245r_paged_load;
1313 +
1314 + pgm->read_sig_bytes = ft245r_read_sig_bytes;
1315 +
1316 + FUNC_END();
1317 +}
1318 +#else // If FTDI support turned off
1319 +static int ft245r_turned_off()
1320 +{
1321 + FUNC_BEGIN();
1322 + fprintf(stderr, " ft245r: support for FTDI BitBang does not compiled in.\n");
1323 + FUNC_END();
1324 + return -1;
1325 +}
1326 +
1327 +static int ft245r_open(PROGRAMMER * pgm, char * port)
1328 +{
1329 + return ft245r_turned_off();
1330 +}
1331 +
1332 +static int ft245r_initialize(PROGRAMMER * pgm, AVRPART * p)
1333 +{
1334 + return ft245r_turned_off();;
1335 +}
1336 +
1337 +void ft245r_initpgm(PROGRAMMER * pgm)
1338 +{
1339 + FUNC_BEGIN();
1340 + strcpy(pgm->type, "ft245r");
1341 + pgm->initialize = ft245r_initialize;
1342 + pgm->open = ft245r_open;
1343 + FUNC_END();
1344 +}
1345 +#endif
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
1349 @@ -0,0 +1,8 @@
1350 +#ifndef ft245r_h
1351 +#define ft245r_h
1352 +
1353 +#include "avrpart.h"
1354 +
1355 +void ft245r_initpgm (PROGRAMMER * pgm);
1356 +
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
1361 @@ -120,6 +120,7 @@
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
1372 @@ -88,6 +88,8 @@
1373 avrpart.h \
1374 bitbang.c \
1375 bitbang.h \
1376 + ft245r.c \
1377 + ft245r.h \
1378 buspirate.c \
1379 buspirate.h \
1380 butterfly.c \