1 /*
2 * avrftdi - extension for avrdude, Wolfgang Moser, Ville Voipio
3 * Copyright (C) 2011 Hannes Weisbach, Doug Springer
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 /* $Id$ */
20 /*
21 * Interface to the MPSSE Engine of FTDI Chips using libftdi.
22 */
23 #include "ac_cfg.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <ctype.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <sys/time.h>
31 #include <sys/types.h>
32 #include <unistd.h>
33 #include <stdint.h>
34 #include <stdarg.h>
35
36 #include "avrdude.h"
37 #include "libavrdude.h"
38
39 #include "avrftdi.h"
40 #include "avrftdi_tpi.h"
41 #include "avrftdi_private.h"
42 #include "usbdevs.h"
43
44 #ifndef MAX
45 #define MAX(a,b) ((a)>(b)?(a):(b))
46 #endif
47 #ifndef MIN
48 #define MIN(a,b) ((a)<(b)?(a):(b))
49 #endif
50
51 #ifdef DO_NOT_BUILD_AVRFTDI
52
avrftdi_noftdi_open(struct programmer_t * pgm,char * name)53 static int avrftdi_noftdi_open (struct programmer_t *pgm, char * name)
54 {
55 avrdude_message(MSG_INFO, "%s: Error: no libftdi or libusb support. Install libftdi1/libusb-1.0 or libftdi/libusb and run configure/make again.\n",
56 progname);
57
58 return -1;
59 }
60
avrftdi_initpgm(PROGRAMMER * pgm)61 void avrftdi_initpgm(PROGRAMMER * pgm)
62 {
63 strcpy(pgm->type, "avrftdi");
64 pgm->open = avrftdi_noftdi_open;
65 }
66
67 #else
68
69 enum { FTDI_SCK = 0, FTDI_MOSI, FTDI_MISO, FTDI_RESET };
70
71 static int write_flush(avrftdi_t *);
72
73 /*
74 * returns a human-readable name for a pin number. the name should match with
75 * the pin names used in FTDI datasheets.
76 */
77 static char*
ftdi_pin_name(avrftdi_t * pdata,struct pindef_t pin)78 ftdi_pin_name(avrftdi_t* pdata, struct pindef_t pin)
79 {
80 static char str[128];
81
82 char interface = '@';
83
84 /* INTERFACE_ANY is zero, so @ is used
85 * INTERFACE_A is one, so '@' + 1 = 'A'
86 * and so forth ...
87 * be aware, there is an 'interface' member in ftdi_context,
88 * however, we really want the 'index' member here.
89 */
90 interface += pdata->ftdic->index;
91
92 int pinno;
93 int n = 0;
94 int mask = pin.mask[0];
95
96 const char * fmt;
97
98 str[0] = 0;
99
100 for(pinno = 0; mask; mask >>= 1, pinno++) {
101 if(!(mask & 1))
102 continue;
103
104 int chars = 0;
105
106 char port;
107 /* This is FTDI's naming scheme.
108 * probably 'D' is for data and 'C' for control
109 */
110 if(pinno < 8)
111 port = 'D';
112 else
113 port = 'C';
114
115 if(str[0] == 0)
116 fmt = "%c%cBUS%d%n";
117 else
118 fmt = ", %c%cBUS%d%n";
119
120 snprintf(&str[n], sizeof(str) - n, fmt, interface, port, pinno, &chars);
121 n += chars;
122 }
123
124 return str;
125 }
126
127 /*
128 * output function, to save if(vebose>level)-constructs. also prefixes output
129 * with "avrftdi function-name(line-number):" to identify were messages came
130 * from.
131 * This function is the backend of the log_*-macros, but it can be used
132 * directly.
133 */
avrftdi_log(int level,const char * func,int line,const char * fmt,...)134 void avrftdi_log(int level, const char * func, int line,
135 const char * fmt, ...) {
136 static int skip_prefix = 0;
137 const char *p = fmt;
138 va_list ap;
139
140 if(verbose >= level)
141 {
142 if(!skip_prefix)
143 {
144 switch(level) {
145 case ERR: avrdude_message(MSG_INFO, "E "); break;
146 case WARN: avrdude_message(MSG_INFO, "W "); break;
147 case INFO: avrdude_message(MSG_INFO, "I "); break;
148 case DEBUG: avrdude_message(MSG_INFO, "D "); break;
149 case TRACE: avrdude_message(MSG_INFO, "T "); break;
150 default: avrdude_message(MSG_INFO, " "); break;
151 }
152 avrdude_message(MSG_INFO, "%s(%d): ", func, line);
153 }
154 va_start(ap, fmt);
155 vfprintf(stderr, fmt, ap);
156 va_end(ap);
157 }
158
159 skip_prefix = 1;
160 while(*p++)
161 if(*p == '\n' && !(*(p+1)))
162 skip_prefix = 0;
163 }
164
165 /*
166 * helper function to print a binary buffer *buf of size len. begin and end of
167 * the dump are enclosed in the string contained in *desc. offset denotes the
168 * number of bytes which are printed on the first line (may be 0). after that
169 * width bytes are printed on each line
170 */
buf_dump(const unsigned char * buf,int len,char * desc,int offset,int width)171 static void buf_dump(const unsigned char *buf, int len, char *desc,
172 int offset, int width)
173 {
174 int i;
175 avrdude_message(MSG_INFO, "%s begin:\n", desc);
176 for (i = 0; i < offset; i++)
177 avrdude_message(MSG_INFO, "%02x ", buf[i]);
178 avrdude_message(MSG_INFO, "\n");
179 for (i++; i <= len; i++) {
180 avrdude_message(MSG_INFO, "%02x ", buf[i-1]);
181 if((i-offset) != 0 && (i-offset)%width == 0)
182 avrdude_message(MSG_INFO, "\n");
183 }
184 avrdude_message(MSG_INFO, "%s end\n", desc);
185 }
186
187 /*
188 * calculates the so-called 'divisor'-value from a given frequency.
189 * the divisor is sent to the chip.
190 */
set_frequency(avrftdi_t * ftdi,uint32_t freq)191 static int set_frequency(avrftdi_t* ftdi, uint32_t freq)
192 {
193 int32_t divisor;
194 uint8_t buf[3];
195
196 /* divisor on 6000000 / freq - 1 */
197 divisor = (6000000 / freq) - 1;
198 if (divisor < 0) {
199 log_warn("Frequency too high (%u > 6 MHz)\n", freq);
200 log_warn("Resetting Frequency to 6MHz\n");
201 divisor = 0;
202 }
203
204 if (divisor > 65535) {
205 log_warn("Frequency too low (%u < 91.553 Hz)\n", freq);
206 log_warn("Resetting Frequency to 91.553Hz\n");
207 divisor = 65535;
208 }
209
210 log_info("Using frequency: %d\n", 6000000/(divisor+1));
211 log_info("Clock divisor: 0x%04x\n", divisor);
212
213 buf[0] = TCK_DIVISOR;
214 buf[1] = (uint8_t)(divisor & 0xff);
215 buf[2] = (uint8_t)((divisor >> 8) & 0xff);
216
217 E(ftdi_write_data(ftdi->ftdic, buf, 3) < 0, ftdi->ftdic);
218
219 return 0;
220 }
221
222 /*
223 * This function sets or clears any pin, except SCK, MISO and MOSI. Depending
224 * on the pin configuration, a non-zero value sets the pin in the 'active'
225 * state (high active, low active) and a zero value sets the pin in the
226 * inactive state.
227 * Because we configured the pin direction mask earlier, nothing bad can happen
228 * here.
229 */
set_pin(PROGRAMMER * pgm,int pinfunc,int value)230 static int set_pin(PROGRAMMER * pgm, int pinfunc, int value)
231 {
232 avrftdi_t* pdata = to_pdata(pgm);
233 struct pindef_t pin = pgm->pin[pinfunc];
234
235 if (pin.mask[0] == 0) {
236 // ignore not defined pins (might be the led or vcc or buff if not needed)
237 return 0;
238 }
239
240 log_debug("Setting pin %s (%s) as %s: %s (%s active)\n",
241 pinmask_to_str(pin.mask), ftdi_pin_name(pdata, pin),
242 avr_pin_name(pinfunc),
243 (value) ? "high" : "low", (pin.inverse[0]) ? "low" : "high");
244
245 pdata->pin_value = SET_BITS_0(pdata->pin_value, pgm, pinfunc, value);
246
247 return write_flush(pdata);
248 }
249
250 /*
251 * Mandatory callbacks which boil down to GPIO.
252 */
set_led_pgm(struct programmer_t * pgm,int value)253 static int set_led_pgm(struct programmer_t * pgm, int value)
254 {
255 return set_pin(pgm, PIN_LED_PGM, value);
256 }
257
set_led_rdy(struct programmer_t * pgm,int value)258 static int set_led_rdy(struct programmer_t * pgm, int value)
259 {
260 return set_pin(pgm, PIN_LED_RDY, value);
261 }
262
set_led_err(struct programmer_t * pgm,int value)263 static int set_led_err(struct programmer_t * pgm, int value)
264 {
265 return set_pin(pgm, PIN_LED_ERR, value);
266 }
267
set_led_vfy(struct programmer_t * pgm,int value)268 static int set_led_vfy(struct programmer_t * pgm, int value)
269 {
270 return set_pin(pgm, PIN_LED_VFY, value);
271 }
272
avrftdi_enable(PROGRAMMER * pgm)273 static void avrftdi_enable(PROGRAMMER * pgm)
274 {
275 set_pin(pgm, PPI_AVR_BUFF, ON);
276 }
277
avrftdi_disable(PROGRAMMER * pgm)278 static void avrftdi_disable(PROGRAMMER * pgm)
279 {
280 set_pin(pgm, PPI_AVR_BUFF, OFF);
281 }
282
avrftdi_powerup(PROGRAMMER * pgm)283 static void avrftdi_powerup(PROGRAMMER * pgm)
284 {
285 set_pin(pgm, PPI_AVR_VCC, ON);
286 }
287
avrftdi_powerdown(PROGRAMMER * pgm)288 static void avrftdi_powerdown(PROGRAMMER * pgm)
289 {
290 set_pin(pgm, PPI_AVR_VCC, OFF);
291 }
292
set_data(PROGRAMMER * pgm,unsigned char * buf,unsigned char data,bool read_data)293 static inline int set_data(PROGRAMMER * pgm, unsigned char *buf, unsigned char data, bool read_data) {
294 int j;
295 int buf_pos = 0;
296 unsigned char bit = 0x80;
297 avrftdi_t* pdata = to_pdata(pgm);
298
299 for (j=0; j<8; j++) {
300 pdata->pin_value = SET_BITS_0(pdata->pin_value,pgm,PIN_AVR_MOSI,data & bit);
301 pdata->pin_value = SET_BITS_0(pdata->pin_value,pgm,PIN_AVR_SCK,0);
302 buf[buf_pos++] = SET_BITS_LOW;
303 buf[buf_pos++] = (pdata->pin_value) & 0xff;
304 buf[buf_pos++] = (pdata->pin_direction) & 0xff;
305 buf[buf_pos++] = SET_BITS_HIGH;
306 buf[buf_pos++] = ((pdata->pin_value) >> 8) & 0xff;
307 buf[buf_pos++] = ((pdata->pin_direction) >> 8) & 0xff;
308
309 pdata->pin_value = SET_BITS_0(pdata->pin_value,pgm,PIN_AVR_SCK,1);
310 buf[buf_pos++] = SET_BITS_LOW;
311 buf[buf_pos++] = (pdata->pin_value) & 0xff;
312 buf[buf_pos++] = (pdata->pin_direction) & 0xff;
313 buf[buf_pos++] = SET_BITS_HIGH;
314 buf[buf_pos++] = ((pdata->pin_value) >> 8) & 0xff;
315 buf[buf_pos++] = ((pdata->pin_direction) >> 8) & 0xff;
316
317 if (read_data) {
318 buf[buf_pos++] = GET_BITS_LOW;
319 buf[buf_pos++] = GET_BITS_HIGH;
320 }
321
322 bit >>= 1;
323 }
324 return buf_pos;
325 }
326
extract_data(PROGRAMMER * pgm,unsigned char * buf,int offset)327 static inline unsigned char extract_data(PROGRAMMER * pgm, unsigned char *buf, int offset) {
328 int j;
329 unsigned char bit = 0x80;
330 unsigned char r = 0;
331
332 buf += offset * 16; // 2 bytes per bit, 8 bits
333 for (j=0; j<8; j++) {
334 uint16_t in = buf[0] | (buf[1] << 8);
335 if (GET_BITS_0(in,pgm,PIN_AVR_MISO)) {
336 r |= bit;
337 }
338 buf += 2; // 2 bytes per input
339 bit >>= 1;
340 }
341 return r;
342 }
343
344
avrftdi_transmit_bb(PROGRAMMER * pgm,unsigned char mode,const unsigned char * buf,unsigned char * data,int buf_size)345 static int avrftdi_transmit_bb(PROGRAMMER * pgm, unsigned char mode, const unsigned char *buf,
346 unsigned char *data, int buf_size)
347 {
348 size_t remaining = buf_size;
349 size_t written = 0;
350 avrftdi_t* pdata = to_pdata(pgm);
351 size_t blocksize = pdata->rx_buffer_size/2; // we are reading 2 bytes per data byte
352
353 // determine a maximum size of data block
354 size_t max_size = MIN(pdata->ftdic->max_packet_size,pdata->tx_buffer_size);
355 // select block size so that resulting commands does not exceed max_size if possible
356 blocksize = MAX(1,(max_size-7)/((8*2*6)+(8*1*2)));
357 //avrdude_message(MSG_INFO, "blocksize %d \n",blocksize);
358
359 while(remaining)
360 {
361
362 size_t transfer_size = (remaining > blocksize) ? blocksize : remaining;
363
364 // (8*2) outputs per data byte, 6 transmit bytes per output (SET_BITS_LOW/HIGH),
365 // (8*1) inputs per data byte, 2 transmit bytes per input (GET_BITS_LOW/HIGH),
366 // 1x SEND_IMMEDIATE
367 unsigned char send_buffer[(8*2*6)*transfer_size+(8*1*2)*transfer_size+7];
368 int len = 0;
369 int i;
370
371 for(i = 0 ; i< transfer_size; i++) {
372 len += set_data(pgm, send_buffer + len, buf[written+i], (mode & MPSSE_DO_READ) != 0);
373 }
374
375 pdata->pin_value = SET_BITS_0(pdata->pin_value,pgm,PIN_AVR_SCK,0);
376 send_buffer[len++] = SET_BITS_LOW;
377 send_buffer[len++] = (pdata->pin_value) & 0xff;
378 send_buffer[len++] = (pdata->pin_direction) & 0xff;
379 send_buffer[len++] = SET_BITS_HIGH;
380 send_buffer[len++] = ((pdata->pin_value) >> 8) & 0xff;
381 send_buffer[len++] = ((pdata->pin_direction) >> 8) & 0xff;
382
383 send_buffer[len++] = SEND_IMMEDIATE;
384
385 E(ftdi_write_data(pdata->ftdic, send_buffer, len) != len, pdata->ftdic);
386 if (mode & MPSSE_DO_READ) {
387 unsigned char recv_buffer[2*16*transfer_size];
388 int n;
389 int k = 0;
390 do {
391 n = ftdi_read_data(pdata->ftdic, &recv_buffer[k], 2*16*transfer_size - k);
392 E(n < 0, pdata->ftdic);
393 k += n;
394 } while (k < transfer_size);
395
396 for(i = 0 ; i< transfer_size; i++) {
397 data[written + i] = extract_data(pgm, recv_buffer, i);
398 }
399 }
400
401 written += transfer_size;
402 remaining -= transfer_size;
403 }
404
405 return written;
406 }
407
408 /* Send 'buf_size' bytes from 'cmd' to device and return data from device in
409 * buffer 'data'.
410 * Write is only performed when mode contains MPSSE_DO_WRITE.
411 * Read is only performed when mode contains MPSSE_DO_WRITE and MPSSE_DO_READ.
412 */
avrftdi_transmit_mpsse(avrftdi_t * pdata,unsigned char mode,const unsigned char * buf,unsigned char * data,int buf_size)413 static int avrftdi_transmit_mpsse(avrftdi_t* pdata, unsigned char mode, const unsigned char *buf,
414 unsigned char *data, int buf_size)
415 {
416 size_t blocksize;
417 size_t remaining = buf_size;
418 size_t written = 0;
419
420 unsigned char cmd[3];
421 // unsigned char si = SEND_IMMEDIATE;
422
423 cmd[0] = mode | MPSSE_WRITE_NEG;
424 cmd[1] = ((buf_size - 1) & 0xff);
425 cmd[2] = (((buf_size - 1) >> 8) & 0xff);
426
427 //if we are not reading back, we can just write the data out
428 if(!(mode & MPSSE_DO_READ))
429 blocksize = buf_size;
430 else
431 blocksize = pdata->rx_buffer_size;
432
433 E(ftdi_write_data(pdata->ftdic, cmd, sizeof(cmd)) != sizeof(cmd), pdata->ftdic);
434
435 while(remaining)
436 {
437 size_t transfer_size = (remaining > blocksize) ? blocksize : remaining;
438
439 E(ftdi_write_data(pdata->ftdic, (unsigned char*)&buf[written], transfer_size) != transfer_size, pdata->ftdic);
440 #if 0
441 if(remaining < blocksize)
442 E(ftdi_write_data(pdata->ftdic, &si, sizeof(si)) != sizeof(si), pdata->ftdic);
443 #endif
444
445 if (mode & MPSSE_DO_READ) {
446 int n;
447 int k = 0;
448 do {
449 n = ftdi_read_data(pdata->ftdic, &data[written + k], transfer_size - k);
450 E(n < 0, pdata->ftdic);
451 k += n;
452 } while (k < transfer_size);
453
454 }
455
456 written += transfer_size;
457 remaining -= transfer_size;
458 }
459
460 return written;
461 }
462
avrftdi_transmit(PROGRAMMER * pgm,unsigned char mode,const unsigned char * buf,unsigned char * data,int buf_size)463 static inline int avrftdi_transmit(PROGRAMMER * pgm, unsigned char mode, const unsigned char *buf,
464 unsigned char *data, int buf_size)
465 {
466 avrftdi_t* pdata = to_pdata(pgm);
467 if (pdata->use_bitbanging)
468 return avrftdi_transmit_bb(pgm, mode, buf, data, buf_size);
469 else
470 return avrftdi_transmit_mpsse(pdata, mode, buf, data, buf_size);
471 }
472
write_flush(avrftdi_t * pdata)473 static int write_flush(avrftdi_t* pdata)
474 {
475 unsigned char buf[6];
476
477 log_debug("Setting pin direction (0x%04x) and value (0x%04x)\n",
478 pdata->pin_direction, pdata->pin_value);
479
480 buf[0] = SET_BITS_LOW;
481 buf[1] = (pdata->pin_value) & 0xff;
482 buf[2] = (pdata->pin_direction) & 0xff;
483 buf[3] = SET_BITS_HIGH;
484 buf[4] = ((pdata->pin_value) >> 8) & 0xff;
485 buf[5] = ((pdata->pin_direction) >> 8) & 0xff;
486
487 E(ftdi_write_data(pdata->ftdic, buf, 6) != 6, pdata->ftdic);
488
489 log_trace("Set pins command: %02x %02x %02x %02x %02x %02x\n",
490 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
491
492 /* we need to flush here, because set_pin is used as reset.
493 * if we want to sleep reset periods, we must be certain the
494 * avr has got the reset signal when we start sleeping.
495 * (it may be stuck in the USB stack or some USB hub)
496 *
497 * Add.: purge does NOT flush. It clears. Also, it is unknown, when the purge
498 * command actually arrives at the chip.
499 * Use read pin status command as sync.
500 */
501 //E(ftdi_usb_purge_buffers(pdata->ftdic), pdata->ftdic);
502
503 unsigned char cmd[] = { GET_BITS_LOW, SEND_IMMEDIATE };
504 E(ftdi_write_data(pdata->ftdic, cmd, sizeof(cmd)) != sizeof(cmd), pdata->ftdic);
505
506 int num = 0;
507 do
508 {
509 int n = ftdi_read_data(pdata->ftdic, buf, sizeof(buf));
510 if(n > 0)
511 num += n;
512 E(n < 0, pdata->ftdic);
513 } while(num < 1);
514
515 if(num > 1)
516 log_warn("Read %d extra bytes\n", num-1);
517
518 return 0;
519
520 }
521
avrftdi_check_pins_bb(PROGRAMMER * pgm,bool output)522 static int avrftdi_check_pins_bb(PROGRAMMER * pgm, bool output)
523 {
524 int pin;
525
526 /* pin checklist. */
527 struct pin_checklist_t pin_checklist[N_PINS];
528
529 avrftdi_t* pdata = to_pdata(pgm);
530
531 /* value for 8/12/16 bit wide interface */
532 int valid_mask = ((1 << pdata->pin_limit) - 1);
533
534 log_debug("Using valid mask bibanging: 0x%08x\n", valid_mask);
535 static struct pindef_t valid_pins;
536 valid_pins.mask[0] = valid_mask;
537 valid_pins.inverse[0] = valid_mask ;
538
539 /* build pin checklist */
540 for(pin = 0; pin < N_PINS; ++pin) {
541 pin_checklist[pin].pinname = pin;
542 pin_checklist[pin].mandatory = 0;
543 pin_checklist[pin].valid_pins = &valid_pins;
544 }
545
546 /* assumes all checklists above have same number of entries */
547 return pins_check(pgm, pin_checklist, N_PINS, output);
548 }
549
avrftdi_check_pins_mpsse(PROGRAMMER * pgm,bool output)550 static int avrftdi_check_pins_mpsse(PROGRAMMER * pgm, bool output)
551 {
552 int pin;
553
554 /* pin checklist. */
555 struct pin_checklist_t pin_checklist[N_PINS];
556
557 avrftdi_t* pdata = to_pdata(pgm);
558
559 /* SCK/MOSI/MISO are fixed and not invertable?*/
560 /* TODO: inverted SCK/MISO/MOSI */
561 static const struct pindef_t valid_pins_SCK = {{0x01},{0x00}} ;
562 static const struct pindef_t valid_pins_MOSI = {{0x02},{0x00}} ;
563 static const struct pindef_t valid_pins_MISO = {{0x04},{0x00}} ;
564
565 /* value for 8/12/16 bit wide interface for other pins */
566 int valid_mask = ((1 << pdata->pin_limit) - 1);
567 /* mask out SCK/MISO/MOSI */
568 valid_mask &= ~((1 << FTDI_SCK) | (1 << FTDI_MOSI) | (1 << FTDI_MISO));
569
570 log_debug("Using valid mask mpsse: 0x%08x\n", valid_mask);
571 static struct pindef_t valid_pins_others;
572 valid_pins_others.mask[0] = valid_mask;
573 valid_pins_others.inverse[0] = valid_mask ;
574
575 /* build pin checklist */
576 for(pin = 0; pin < N_PINS; ++pin) {
577 pin_checklist[pin].pinname = pin;
578 pin_checklist[pin].mandatory = 0;
579 pin_checklist[pin].valid_pins = &valid_pins_others;
580 }
581
582 /* now set mpsse specific pins */
583 pin_checklist[PIN_AVR_SCK].mandatory = 1;
584 pin_checklist[PIN_AVR_SCK].valid_pins = &valid_pins_SCK;
585 pin_checklist[PIN_AVR_MOSI].mandatory = 1;
586 pin_checklist[PIN_AVR_MOSI].valid_pins = &valid_pins_MOSI;
587 pin_checklist[PIN_AVR_MISO].mandatory = 1;
588 pin_checklist[PIN_AVR_MISO].valid_pins = &valid_pins_MISO;
589 pin_checklist[PIN_AVR_RESET].mandatory = 1;
590
591 /* assumes all checklists above have same number of entries */
592 return pins_check(pgm, pin_checklist, N_PINS, output);
593 }
594
avrftdi_pin_setup(PROGRAMMER * pgm)595 static int avrftdi_pin_setup(PROGRAMMER * pgm)
596 {
597 int pin;
598
599 /*************
600 * pin setup *
601 *************/
602
603 avrftdi_t* pdata = to_pdata(pgm);
604
605 bool pin_check_mpsse = (0 == avrftdi_check_pins_mpsse(pgm, verbose>3));
606
607 bool pin_check_bitbanging = (0 == avrftdi_check_pins_bb(pgm, verbose>3));
608
609 if (!pin_check_mpsse && !pin_check_bitbanging) {
610 log_err("No valid pin configuration found.\n");
611 avrftdi_check_pins_bb(pgm, true);
612 log_err("Pin configuration for FTDI MPSSE must be:\n");
613 log_err("%s: 0, %s: 1, %s: 2 (is: %s, %s, %s)\n", avr_pin_name(PIN_AVR_SCK),
614 avr_pin_name(PIN_AVR_MOSI), avr_pin_name(PIN_AVR_MISO),
615 pins_to_str(&pgm->pin[PIN_AVR_SCK]),
616 pins_to_str(&pgm->pin[PIN_AVR_MOSI]),
617 pins_to_str(&pgm->pin[PIN_AVR_MISO]));
618 log_err("If other pin configuration is used, fallback to slower bitbanging mode is used.\n");
619
620 return -1;
621 }
622
623 pdata->use_bitbanging = !pin_check_mpsse;
624 if (pdata->use_bitbanging) log_info("Because of pin configuration fallback to bitbanging mode.\n");
625
626 /*
627 * TODO: No need to fail for a wrongly configured led or something.
628 * Maybe we should only fail for SCK; MISO, MOSI, RST (and probably
629 * VCC and BUFF).
630 */
631
632 /* everything is an output, except MISO */
633 for(pin = 0; pin < N_PINS; ++pin) {
634 pdata->pin_direction |= pgm->pin[pin].mask[0];
635 pdata->pin_value = SET_BITS_0(pdata->pin_value, pgm, pin, OFF);
636 }
637 pdata->pin_direction &= ~pgm->pin[PIN_AVR_MISO].mask[0];
638
639 for(pin = PIN_LED_ERR; pin < N_PINS; ++pin) {
640 pdata->led_mask |= pgm->pin[pin].mask[0];
641 }
642
643
644 log_info("Pin direction mask: %04x\n", pdata->pin_direction);
645 log_info("Pin value mask: %04x\n", pdata->pin_value);
646
647 return 0;
648 }
649
avrftdi_open(PROGRAMMER * pgm,char * port)650 static int avrftdi_open(PROGRAMMER * pgm, char *port)
651 {
652 int vid, pid, interface, index, err;
653 char * serial, *desc;
654
655 avrftdi_t* pdata = to_pdata(pgm);
656
657 /************************
658 * parameter validation *
659 ************************/
660
661 /* use vid/pid in following priority: config,
662 * defaults. cmd-line is currently not supported */
663
664 if (pgm->usbvid)
665 vid = pgm->usbvid;
666 else
667 vid = USB_VENDOR_FTDI;
668
669 LNODEID usbpid = lfirst(pgm->usbpid);
670 if (usbpid) {
671 pid = *(int *)(ldata(usbpid));
672 if (lnext(usbpid))
673 avrdude_message(MSG_INFO, "%s: Warning: using PID 0x%04x, ignoring remaining PIDs in list\n",
674 progname, pid);
675 } else
676 pid = USB_DEVICE_FT2232;
677
678 if (0 == pgm->usbsn[0]) /* we don't care about SN. Use first avail. */
679 serial = NULL;
680 else
681 serial = pgm->usbsn;
682
683 /* not used yet, but i put them here, just in case someone does needs or
684 * wants to implement this.
685 */
686 desc = NULL;
687 index = 0;
688
689 if (pgm->usbdev[0] == 'a' || pgm->usbdev[0] == 'A')
690 interface = INTERFACE_A;
691 else if (pgm->usbdev[0] == 'b' || pgm->usbdev[0] == 'B')
692 interface = INTERFACE_B;
693 else {
694 log_warn("Invalid interface '%s'. Setting to Interface A\n", pgm->usbdev);
695 interface = INTERFACE_A;
696 }
697
698 /****************
699 * Device setup *
700 ****************/
701
702 E(ftdi_set_interface(pdata->ftdic, interface) < 0, pdata->ftdic);
703
704 err = ftdi_usb_open_desc_index(pdata->ftdic, vid, pid, desc, serial, index);
705 if(err) {
706 log_err("Error %d occurred: %s\n", err, ftdi_get_error_string(pdata->ftdic));
707 //stupid hack, because avrdude calls pgm->close() even when pgm->open() fails
708 //and usb_dev is intialized to the last usb device from probing
709 pdata->ftdic->usb_dev = NULL;
710 return err;
711 } else {
712 log_info("Using device VID:PID %04x:%04x and SN '%s' on interface %c.\n",
713 vid, pid, serial, INTERFACE_A == interface? 'A': 'B');
714 }
715
716 ftdi_set_latency_timer(pdata->ftdic, 1);
717 //ftdi_write_data_set_chunksize(pdata->ftdic, 16);
718 //ftdi_read_data_set_chunksize(pdata->ftdic, 16);
719
720 /* set SPI mode */
721 E(ftdi_set_bitmode(pdata->ftdic, 0, BITMODE_RESET) < 0, pdata->ftdic);
722 E(ftdi_set_bitmode(pdata->ftdic, pdata->pin_direction & 0xff, BITMODE_MPSSE) < 0, pdata->ftdic);
723 E(ftdi_usb_purge_buffers(pdata->ftdic), pdata->ftdic);
724
725 write_flush(pdata);
726
727 if (pgm->baudrate) {
728 set_frequency(pdata, pgm->baudrate);
729 } else if(pgm->bitclock) {
730 set_frequency(pdata, (uint32_t)(1.0f/pgm->bitclock));
731 } else {
732 set_frequency(pdata, pgm->baudrate ? pgm->baudrate : 150000);
733 }
734
735 /* set pin limit depending on chip type */
736 switch(pdata->ftdic->type) {
737 case TYPE_AM:
738 case TYPE_BM:
739 case TYPE_R:
740 log_err("Found unsupported device type AM, BM or R. avrftdi ");
741 log_err("cannot work with your chip. Try the 'synbb' programmer.\n");
742 return -1;
743 case TYPE_2232C:
744 pdata->pin_limit = 12;
745 pdata->rx_buffer_size = 384;
746 pdata->tx_buffer_size = 128;
747 break;
748 case TYPE_2232H:
749 pdata->pin_limit = 16;
750 pdata->rx_buffer_size = 4096;
751 pdata->tx_buffer_size = 4096;
752 break;
753 #ifdef HAVE_LIBFTDI_TYPE_232H
754 case TYPE_232H:
755 pdata->pin_limit = 16;
756 pdata->rx_buffer_size = 1024;
757 pdata->tx_buffer_size = 1024;
758 break;
759 #else
760 #warning No support for 232H, use a newer libftdi, version >= 0.20
761 #endif
762 case TYPE_4232H:
763 pdata->pin_limit = 8;
764 pdata->rx_buffer_size = 2048;
765 pdata->tx_buffer_size = 2048;
766 break;
767 default:
768 log_warn("Found unknown device %x. I will do my ", pdata->ftdic->type);
769 log_warn("best to work with it, but no guarantees ...\n");
770 pdata->pin_limit = 8;
771 pdata->rx_buffer_size = pdata->ftdic->max_packet_size;
772 pdata->tx_buffer_size = pdata->ftdic->max_packet_size;
773 break;
774 }
775
776 if(avrftdi_pin_setup(pgm))
777 return -1;
778
779 /**********************************************
780 * set the ready LED and set our direction up *
781 **********************************************/
782
783 set_led_rdy(pgm,0);
784 set_led_pgm(pgm,1);
785
786 return 0;
787 }
788
avrftdi_close(PROGRAMMER * pgm)789 static void avrftdi_close(PROGRAMMER * pgm)
790 {
791 avrftdi_t* pdata = to_pdata(pgm);
792
793 if(pdata->ftdic->usb_dev) {
794 set_pin(pgm, PIN_AVR_RESET, ON);
795
796 /* Stop driving the pins - except for the LEDs */
797 log_info("LED Mask=0x%04x value =0x%04x &=0x%04x\n",
798 pdata->led_mask, pdata->pin_value, pdata->led_mask & pdata->pin_value);
799
800 pdata->pin_direction = pdata->led_mask;
801 pdata->pin_value &= pdata->led_mask;
802 write_flush(pdata);
803 /* reset state recommended by FTDI */
804 ftdi_set_bitmode(pdata->ftdic, 0, BITMODE_RESET);
805 E_VOID(ftdi_usb_close(pdata->ftdic), pdata->ftdic);
806 }
807
808 return;
809 }
810
avrftdi_initialize(PROGRAMMER * pgm,AVRPART * p)811 static int avrftdi_initialize(PROGRAMMER * pgm, AVRPART * p)
812 {
813 avrftdi_powerup(pgm);
814
815 if(p->flags & AVRPART_HAS_TPI)
816 {
817 /* see avrftdi_tpi.c */
818 avrftdi_tpi_initialize(pgm, p);
819 }
820 else
821 {
822 set_pin(pgm, PIN_AVR_RESET, OFF);
823 set_pin(pgm, PIN_AVR_SCK, OFF);
824 /*use speed optimization with CAUTION*/
825 usleep(20 * 1000);
826
827 /* giving rst-pulse of at least 2 avr-clock-cycles, for
828 * security (2us @ 1MHz) */
829 set_pin(pgm, PIN_AVR_RESET, ON);
830 usleep(20 * 1000);
831
832 /*setting rst back to 0 */
833 set_pin(pgm, PIN_AVR_RESET, OFF);
834 /*wait at least 20ms bevor issuing spi commands to avr */
835 usleep(20 * 1000);
836 }
837
838 return pgm->program_enable(pgm, p);
839 }
840
avrftdi_display(PROGRAMMER * pgm,const char * p)841 static void avrftdi_display(PROGRAMMER * pgm, const char *p)
842 {
843 // print the full pin definitiions as in ft245r ?
844 return;
845 }
846
847
avrftdi_cmd(PROGRAMMER * pgm,const unsigned char * cmd,unsigned char * res)848 static int avrftdi_cmd(PROGRAMMER * pgm, const unsigned char *cmd, unsigned char *res)
849 {
850 return avrftdi_transmit(pgm, MPSSE_DO_READ | MPSSE_DO_WRITE, cmd, res, 4);
851 }
852
853
avrftdi_program_enable(PROGRAMMER * pgm,AVRPART * p)854 static int avrftdi_program_enable(PROGRAMMER * pgm, AVRPART * p)
855 {
856 int i;
857 unsigned char buf[4];
858
859 memset(buf, 0, sizeof(buf));
860
861 if (p->op[AVR_OP_PGM_ENABLE] == NULL) {
862 log_err("AVR_OP_PGM_ENABLE command not defined for %s\n", p->desc);
863 return -1;
864 }
865
866 avr_set_bits(p->op[AVR_OP_PGM_ENABLE], buf);
867
868 for(i = 0; i < 4; i++) {
869 pgm->cmd(pgm, buf, buf);
870 if (buf[p->pollindex-1] != p->pollvalue) {
871 log_warn("Program enable command not successful. Retrying.\n");
872 set_pin(pgm, PIN_AVR_RESET, ON);
873 usleep(20);
874 set_pin(pgm, PIN_AVR_RESET, OFF);
875 avr_set_bits(p->op[AVR_OP_PGM_ENABLE], buf);
876 } else
877 return 0;
878 }
879
880 log_err("Device is not responding to program enable. Check connection.\n");
881
882 return -1;
883 }
884
885
avrftdi_chip_erase(PROGRAMMER * pgm,AVRPART * p)886 static int avrftdi_chip_erase(PROGRAMMER * pgm, AVRPART * p)
887 {
888 unsigned char cmd[4];
889 unsigned char res[4];
890
891 if (p->op[AVR_OP_CHIP_ERASE] == NULL) {
892 log_err("AVR_OP_CHIP_ERASE command not defined for %s\n", p->desc);
893 return -1;
894 }
895
896 memset(cmd, 0, sizeof(cmd));
897
898 avr_set_bits(p->op[AVR_OP_CHIP_ERASE], cmd);
899 pgm->cmd(pgm, cmd, res);
900 usleep(p->chip_erase_delay);
901 pgm->initialize(pgm, p);
902
903 return 0;
904 }
905
906
907 /* Load extended address byte command */
908 static int
avrftdi_lext(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int address)909 avrftdi_lext(PROGRAMMER *pgm, AVRPART *p, AVRMEM *m, unsigned int address)
910 {
911 unsigned char buf[] = { 0x00, 0x00, 0x00, 0x00 };
912
913 avr_set_bits(m->op[AVR_OP_LOAD_EXT_ADDR], buf);
914 avr_set_addr(m->op[AVR_OP_LOAD_EXT_ADDR], buf, address);
915
916 if(verbose > TRACE)
917 buf_dump(buf, sizeof(buf),
918 "load extended address command", 0, 16 * 3);
919
920 if (0 > avrftdi_transmit(pgm, MPSSE_DO_WRITE, buf, buf, 4))
921 return -1;
922
923 return 0;
924 }
925
avrftdi_eeprom_write(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int len)926 static int avrftdi_eeprom_write(PROGRAMMER *pgm, AVRPART *p, AVRMEM *m,
927 unsigned int page_size, unsigned int addr, unsigned int len)
928 {
929 unsigned char cmd[] = { 0x00, 0x00, 0x00, 0x00 };
930 unsigned char *data = &m->buf[addr];
931 unsigned int add;
932
933 avr_set_bits(m->op[AVR_OP_WRITE], cmd);
934
935 for (add = addr; add < addr + len; add++)
936 {
937 avr_set_addr(m->op[AVR_OP_WRITE], cmd, add);
938 avr_set_input(m->op[AVR_OP_WRITE], cmd, *data++);
939
940 if (0 > avrftdi_transmit(pgm, MPSSE_DO_WRITE, cmd, cmd, 4))
941 return -1;
942 usleep((m->max_write_delay));
943
944 }
945 return len;
946 }
947
avrftdi_eeprom_read(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int len)948 static int avrftdi_eeprom_read(PROGRAMMER *pgm, AVRPART *p, AVRMEM *m,
949 unsigned int page_size, unsigned int addr, unsigned int len)
950 {
951 unsigned char cmd[4];
952 unsigned char buffer[len], *bufptr = buffer;
953 unsigned int add;
954
955 memset(buffer, 0, sizeof(buffer));
956 for (add = addr; add < addr + len; add++)
957 {
958 memset(cmd, 0, sizeof(cmd));
959 avr_set_bits(m->op[AVR_OP_READ], cmd);
960 avr_set_addr(m->op[AVR_OP_READ], cmd, add);
961
962 if (0 > avrftdi_transmit(pgm, MPSSE_DO_READ | MPSSE_DO_WRITE, cmd, cmd, 4))
963 return -1;
964
965 avr_get_output(m->op[AVR_OP_READ], cmd, bufptr++);
966 }
967
968 memcpy(m->buf + addr, buffer, len);
969 return len;
970 }
971
avrftdi_flash_write(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int len)972 static int avrftdi_flash_write(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
973 unsigned int page_size, unsigned int addr, unsigned int len)
974 {
975 int use_lext_address = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
976
977 unsigned int word;
978 unsigned int poll_index;
979 unsigned int buf_size;
980
981 unsigned char poll_byte;
982 unsigned char *buffer = &m->buf[addr];
983 unsigned char buf[4*len+4], *bufptr = buf;
984
985 memset(buf, 0, sizeof(buf));
986
987 /* pre-check opcodes */
988 if (m->op[AVR_OP_LOADPAGE_LO] == NULL) {
989 log_err("AVR_OP_LOADPAGE_LO command not defined for %s\n", p->desc);
990 return -1;
991 }
992 if (m->op[AVR_OP_LOADPAGE_HI] == NULL) {
993 log_err("AVR_OP_LOADPAGE_HI command not defined for %s\n", p->desc);
994 return -1;
995 }
996
997 if(page_size != m->page_size) {
998 log_warn("Parameter page_size is %d, ", page_size);
999 log_warn("but m->page_size is %d. Using the latter.\n", m->page_size);
1000 }
1001
1002 page_size = m->page_size;
1003
1004 /* if we do cross a 64k word boundary (or write the
1005 * first page), we need to issue a 'load extended
1006 * address byte' command, which is defined as 0x4d
1007 * 0x00 <address byte> 0x00. As far as i know, this
1008 * is only available on 256k parts. 64k word is 128k
1009 * bytes.
1010 * write the command only once.
1011 */
1012 if(use_lext_address && (((addr/2) & 0xffff0000))) {
1013 if (0 > avrftdi_lext(pgm, p, m, addr/2))
1014 return -1;
1015 }
1016
1017 /* prepare the command stream for the whole page */
1018 /* addr is in bytes, but we program in words. addr/2 should be something
1019 * like addr >> WORD_SHIFT, though */
1020 for(word = addr/2; word < (len + addr)/2; word++)
1021 {
1022 log_debug("-< bytes = %d of %d\n", word * 2, len + addr);
1023
1024 /*setting word*/
1025 avr_set_bits(m->op[AVR_OP_LOADPAGE_LO], bufptr);
1026 /* here is the second byte increment, just if you're wondering */
1027 avr_set_addr(m->op[AVR_OP_LOADPAGE_LO], bufptr, word);
1028 avr_set_input(m->op[AVR_OP_LOADPAGE_LO], bufptr, *buffer++);
1029 bufptr += 4;
1030 avr_set_bits(m->op[AVR_OP_LOADPAGE_HI], bufptr);
1031 avr_set_addr(m->op[AVR_OP_LOADPAGE_HI], bufptr, word);
1032 avr_set_input(m->op[AVR_OP_LOADPAGE_HI], bufptr, *buffer++);
1033 bufptr += 4;
1034 }
1035
1036 /* issue write page command, if available */
1037 if (m->op[AVR_OP_WRITEPAGE] == NULL) {
1038 log_err("AVR_OP_WRITEPAGE command not defined for %s\n", p->desc);
1039 return -1;
1040 } else {
1041 avr_set_bits(m->op[AVR_OP_WRITEPAGE], bufptr);
1042 /* setting page address highbyte */
1043 avr_set_addr(m->op[AVR_OP_WRITEPAGE],
1044 bufptr, addr/2);
1045 bufptr += 4;
1046 }
1047
1048 buf_size = bufptr - buf;
1049
1050 if(verbose > TRACE)
1051 buf_dump(buf, buf_size, "command buffer", 0, 16*2);
1052
1053 log_info("Transmitting buffer of size: %d\n", buf_size);
1054 if (0 > avrftdi_transmit(pgm, MPSSE_DO_WRITE, buf, buf, buf_size))
1055 return -1;
1056
1057 bufptr = buf;
1058 /* find a poll byte. we cannot poll a value of 0xff, so look
1059 * for a value != 0xff
1060 */
1061 for(poll_index = addr+len-1; poll_index > addr-1; poll_index--)
1062 if(m->buf[poll_index] != 0xff)
1063 break;
1064
1065 if((poll_index < addr + len) && m->buf[poll_index] != 0xff)
1066 {
1067 log_info("Using m->buf[%d] = 0x%02x as polling value ", poll_index,
1068 m->buf[poll_index]);
1069 /* poll page write ready */
1070 do {
1071 log_info(".");
1072
1073 pgm->read_byte(pgm, p, m, poll_index, &poll_byte);
1074 } while (m->buf[poll_index] != poll_byte);
1075
1076 log_info("\n");
1077 }
1078 else
1079 {
1080 log_warn("No suitable byte (!=0xff) for polling found.\n");
1081 log_warn("Trying to sleep instead, but programming errors may occur.\n");
1082 log_warn("Be sure to verify programmed memory (no -V option)\n");
1083 /* TODO sync write */
1084 /* sleep */
1085 usleep((m->max_write_delay));
1086 }
1087
1088 return len;
1089 }
1090
1091 /*
1092 *Reading from flash
1093 */
avrftdi_flash_read(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int len)1094 static int avrftdi_flash_read(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
1095 unsigned int page_size, unsigned int addr, unsigned int len)
1096 {
1097 OPCODE * readop;
1098 int byte, word;
1099 int use_lext_address = m->op[AVR_OP_LOAD_EXT_ADDR] != NULL;
1100 unsigned int address = addr/2;
1101
1102 unsigned char o_buf[4*len+4];
1103 unsigned char i_buf[4*len+4];
1104 unsigned int index;
1105
1106
1107 memset(o_buf, 0, sizeof(o_buf));
1108 memset(i_buf, 0, sizeof(i_buf));
1109
1110 /* pre-check opcodes */
1111 if (m->op[AVR_OP_READ_LO] == NULL) {
1112 log_err("AVR_OP_READ_LO command not defined for %s\n", p->desc);
1113 return -1;
1114 }
1115 if (m->op[AVR_OP_READ_HI] == NULL) {
1116 log_err("AVR_OP_READ_HI command not defined for %s\n", p->desc);
1117 return -1;
1118 }
1119
1120 if(use_lext_address && ((address & 0xffff0000))) {
1121 if (0 > avrftdi_lext(pgm, p, m, address))
1122 return -1;
1123 }
1124
1125 /* word addressing! */
1126 for(word = addr/2, index = 0; word < (addr + len)/2; word++)
1127 {
1128 /* one byte is transferred via a 4-byte opcode.
1129 * TODO: reduce magic numbers
1130 */
1131 avr_set_bits(m->op[AVR_OP_READ_LO], &o_buf[index*4]);
1132 avr_set_addr(m->op[AVR_OP_READ_LO], &o_buf[index*4], word);
1133 index++;
1134 avr_set_bits(m->op[AVR_OP_READ_HI], &o_buf[index*4]);
1135 avr_set_addr(m->op[AVR_OP_READ_HI], &o_buf[index*4], word);
1136 index++;
1137 }
1138
1139 /* transmit,
1140 * if there was an error, we did not see, memory validation will
1141 * subsequently fail.
1142 */
1143 if(verbose > TRACE) {
1144 buf_dump(o_buf, sizeof(o_buf), "o_buf", 0, 32);
1145 }
1146
1147 if (0 > avrftdi_transmit(pgm, MPSSE_DO_READ | MPSSE_DO_WRITE, o_buf, i_buf, len * 4))
1148 return -1;
1149
1150 if(verbose > TRACE) {
1151 buf_dump(i_buf, sizeof(i_buf), "i_buf", 0, 32);
1152 }
1153
1154 memset(&m->buf[addr], 0, page_size);
1155
1156 /* every (read) op is 4 bytes in size and yields one byte of memory data */
1157 for(byte = 0; byte < page_size; byte++) {
1158 if(byte & 1)
1159 readop = m->op[AVR_OP_READ_HI];
1160 else
1161 readop = m->op[AVR_OP_READ_LO];
1162
1163 /* take 4 bytes and put the memory byte in the buffer at
1164 * offset addr + offset of the current byte
1165 */
1166 avr_get_output(readop, &i_buf[byte*4], &m->buf[addr+byte]);
1167 }
1168
1169 if(verbose > TRACE)
1170 buf_dump(&m->buf[addr], page_size, "page:", 0, 32);
1171
1172 return len;
1173 }
1174
avrftdi_paged_write(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int n_bytes)1175 static int avrftdi_paged_write(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
1176 unsigned int page_size, unsigned int addr, unsigned int n_bytes)
1177 {
1178 if (strcmp(m->desc, "flash") == 0)
1179 return avrftdi_flash_write(pgm, p, m, page_size, addr, n_bytes);
1180 else if (strcmp(m->desc, "eeprom") == 0)
1181 return avrftdi_eeprom_write(pgm, p, m, page_size, addr, n_bytes);
1182 else
1183 return -2;
1184 }
1185
avrftdi_paged_load(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int n_bytes)1186 static int avrftdi_paged_load(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
1187 unsigned int page_size, unsigned int addr, unsigned int n_bytes)
1188 {
1189 if (strcmp(m->desc, "flash") == 0)
1190 return avrftdi_flash_read(pgm, p, m, page_size, addr, n_bytes);
1191 else if(strcmp(m->desc, "eeprom") == 0)
1192 return avrftdi_eeprom_read(pgm, p, m, page_size, addr, n_bytes);
1193 else
1194 return -2;
1195 }
1196
1197 static void
avrftdi_setup(PROGRAMMER * pgm)1198 avrftdi_setup(PROGRAMMER * pgm)
1199 {
1200 avrftdi_t* pdata;
1201
1202 pgm->cookie = malloc(sizeof(avrftdi_t));
1203 pdata = to_pdata(pgm);
1204
1205 pdata->ftdic = ftdi_new();
1206 if(!pdata->ftdic)
1207 {
1208 log_err("Error allocating memory.\n");
1209 exit(1);
1210 }
1211 E_VOID(ftdi_init(pdata->ftdic), pdata->ftdic);
1212
1213 pdata->pin_value = 0;
1214 pdata->pin_direction = 0;
1215 pdata->led_mask = 0;
1216 }
1217
1218 static void
avrftdi_teardown(PROGRAMMER * pgm)1219 avrftdi_teardown(PROGRAMMER * pgm)
1220 {
1221 avrftdi_t* pdata = to_pdata(pgm);
1222
1223 if(pdata) {
1224 ftdi_deinit(pdata->ftdic);
1225 ftdi_free(pdata->ftdic);
1226 free(pdata);
1227 }
1228 }
1229
avrftdi_initpgm(PROGRAMMER * pgm)1230 void avrftdi_initpgm(PROGRAMMER * pgm)
1231 {
1232
1233 strcpy(pgm->type, "avrftdi");
1234
1235 /*
1236 * mandatory functions
1237 */
1238
1239 pgm->initialize = avrftdi_initialize;
1240 pgm->display = avrftdi_display;
1241 pgm->enable = avrftdi_enable;
1242 pgm->disable = avrftdi_disable;
1243 pgm->powerup = avrftdi_powerup;
1244 pgm->powerdown = avrftdi_powerdown;
1245 pgm->program_enable = avrftdi_program_enable;
1246 pgm->chip_erase = avrftdi_chip_erase;
1247 pgm->cmd = avrftdi_cmd;
1248 pgm->open = avrftdi_open;
1249 pgm->close = avrftdi_close;
1250 pgm->read_byte = avr_read_byte_default;
1251 pgm->write_byte = avr_write_byte_default;
1252
1253 /*
1254 * optional functions
1255 */
1256
1257 pgm->paged_write = avrftdi_paged_write;
1258 pgm->paged_load = avrftdi_paged_load;
1259
1260 pgm->setpin = set_pin;
1261
1262 pgm->setup = avrftdi_setup;
1263 pgm->teardown = avrftdi_teardown;
1264
1265 pgm->rdy_led = set_led_rdy;
1266 pgm->err_led = set_led_err;
1267 pgm->pgm_led = set_led_pgm;
1268 pgm->vfy_led = set_led_vfy;
1269 }
1270
1271 #endif /* DO_NOT_BUILD_AVRFTDI */
1272
1273
1274 const char avrftdi_desc[] = "Interface to the MPSSE Engine of FTDI Chips using libftdi.";
1275
1276