1 /*
2 * avrdude - A Downloader/Uploader for AVR device programmers
3 * Copyright (C) 2005, 2007 Joerg Wunsch <j@uriah.heep.sax.de>
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: jtagmkI.c 1345 2014-11-23 20:57:17Z joerg_wunsch $ */
20
21 /*
22 * avrdude interface for Atmel JTAG ICE (mkI) programmer
23 */
24
25 #include "ac_cfg.h"
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <unistd.h>
32 #include <sys/time.h>
33 #include <time.h>
34
35 #include "avrdude.h"
36 #include "libavrdude.h"
37
38 #include "crc16.h"
39 #include "jtagmkI.h"
40 #include "jtagmkI_private.h"
41
42 /*
43 * Private data for this programmer.
44 */
45 struct pdata
46 {
47 int initial_baudrate;
48
49 /*
50 * See jtagmkI_read_byte() for an explanation of the flash and
51 * EEPROM page caches.
52 */
53 unsigned char *flash_pagecache;
54 unsigned long flash_pageaddr;
55 unsigned int flash_pagesize;
56
57 unsigned char *eeprom_pagecache;
58 unsigned long eeprom_pageaddr;
59 unsigned int eeprom_pagesize;
60
61 int prog_enabled; /* Cached value of PROGRAMMING status. */
62 };
63
64 #define PDATA(pgm) ((struct pdata *)(pgm->cookie))
65
66 /*
67 * The OCDEN fuse is bit 7 of the high fuse (hfuse). In order to
68 * perform memory operations on MTYPE_SPM and MTYPE_EEPROM, OCDEN
69 * needs to be programmed.
70 *
71 * OCDEN should probably rather be defined via the configuration, but
72 * if this ever changes to a different fuse byte for one MCU, quite
73 * some code here needs to be generalized anyway.
74 */
75 #define OCDEN (1 << 7)
76
77 /*
78 * Table of baud rates supported by the mkI ICE, accompanied by their
79 * internal parameter value.
80 *
81 * 19200 is the initial value of the ICE after powerup, and virtually
82 * all connections then switch to 115200. As the table is also used
83 * to try connecting at startup, we keep these two entries on top to
84 * speedup the program start.
85 */
86 const static struct {
87 long baud;
88 unsigned char val;
89 } baudtab[] = {
90 { 19200L, 0xfa },
91 { 115200L, 0xff },
92 { 9600L, 0xf4 },
93 { 38400L, 0xfd },
94 { 57600L, 0xfe },
95 /* { 14400L, 0xf8 }, */ /* not supported by serial driver */
96 };
97
98 static int jtagmkI_read_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * mem,
99 unsigned long addr, unsigned char * value);
100 static int jtagmkI_write_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * mem,
101 unsigned long addr, unsigned char data);
102 static int jtagmkI_set_sck_period(PROGRAMMER * pgm, double v);
103 static int jtagmkI_getparm(PROGRAMMER * pgm, unsigned char parm,
104 unsigned char * value);
105 static int jtagmkI_setparm(PROGRAMMER * pgm, unsigned char parm,
106 unsigned char value);
107 static void jtagmkI_print_parms1(PROGRAMMER * pgm, const char * p);
108
109 static int jtagmkI_resync(PROGRAMMER *pgm, int maxtries, int signon);
110
jtagmkI_setup(PROGRAMMER * pgm)111 static void jtagmkI_setup(PROGRAMMER * pgm)
112 {
113 if ((pgm->cookie = malloc(sizeof(struct pdata))) == 0) {
114 avrdude_message(MSG_INFO, "%s: jtagmkI_setup(): Out of memory allocating private data\n",
115 progname);
116 exit(1);
117 }
118 memset(pgm->cookie, 0, sizeof(struct pdata));
119 }
120
jtagmkI_teardown(PROGRAMMER * pgm)121 static void jtagmkI_teardown(PROGRAMMER * pgm)
122 {
123 free(pgm->cookie);
124 }
125
126
127 static void
u32_to_b3(unsigned char * b,unsigned long l)128 u32_to_b3(unsigned char *b, unsigned long l)
129 {
130 b[2] = l & 0xff;
131 b[1] = (l >> 8) & 0xff;
132 b[0] = (l >> 16) & 0xff;
133 }
134
135 static void
u16_to_b2(unsigned char * b,unsigned short l)136 u16_to_b2(unsigned char *b, unsigned short l)
137 {
138 b[0] = l & 0xff;
139 b[1] = (l >> 8) & 0xff;
140 }
141
jtagmkI_prmsg(PROGRAMMER * pgm,unsigned char * data,size_t len)142 static void jtagmkI_prmsg(PROGRAMMER * pgm, unsigned char * data, size_t len)
143 {
144 int i;
145
146 if (verbose >= 4) {
147 avrdude_message(MSG_TRACE, "Raw message:\n");
148
149 for (i = 0; i < len; i++) {
150 avrdude_message(MSG_TRACE, "0x%02x ", data[i]);
151 if (i % 16 == 15)
152 putc('\n', stderr);
153 else
154 putc(' ', stderr);
155 }
156 if (i % 16 != 0)
157 putc('\n', stderr);
158 }
159
160 switch (data[0]) {
161 case RESP_OK:
162 avrdude_message(MSG_INFO, "OK\n");
163 break;
164
165 case RESP_FAILED:
166 avrdude_message(MSG_INFO, "FAILED\n");
167 break;
168
169 case RESP_BREAK:
170 avrdude_message(MSG_INFO, "breakpoint hit\n");
171 break;
172
173 case RESP_INFO:
174 avrdude_message(MSG_INFO, "IDR dirty\n");
175 break;
176
177 case RESP_SYNC_ERROR:
178 avrdude_message(MSG_INFO, "Synchronization lost\n");
179 break;
180
181 case RESP_SLEEP:
182 avrdude_message(MSG_INFO, "sleep instruction hit\n");
183 break;
184
185 case RESP_POWER:
186 avrdude_message(MSG_INFO, "target power lost\n");
187
188 default:
189 avrdude_message(MSG_INFO, "unknown message 0x%02x\n", data[0]);
190 }
191
192 putc('\n', stderr);
193 }
194
195
jtagmkI_send(PROGRAMMER * pgm,unsigned char * data,size_t len)196 static int jtagmkI_send(PROGRAMMER * pgm, unsigned char * data, size_t len)
197 {
198 unsigned char *buf;
199
200 avrdude_message(MSG_DEBUG, "\n%s: jtagmkI_send(): sending %u bytes\n",
201 progname, (unsigned int)len);
202
203 if ((buf = malloc(len + 2)) == NULL)
204 {
205 avrdude_message(MSG_INFO, "%s: jtagmkI_send(): out of memory",
206 progname);
207 exit(1);
208 }
209
210 memcpy(buf, data, len);
211 buf[len] = ' '; /* "CRC" */
212 buf[len + 1] = ' '; /* EOP */
213
214 if (serial_send(&pgm->fd, buf, len + 2) != 0) {
215 avrdude_message(MSG_INFO, "%s: jtagmkI_send(): failed to send command to serial port\n",
216 progname);
217 return -1;
218 }
219
220 free(buf);
221
222 return 0;
223 }
224
jtagmkI_recv(PROGRAMMER * pgm,unsigned char * buf,size_t len)225 static int jtagmkI_recv(PROGRAMMER * pgm, unsigned char * buf, size_t len)
226 {
227 if (serial_recv(&pgm->fd, buf, len) != 0) {
228 avrdude_message(MSG_INFO, "\n%s: jtagmkI_recv(): failed to send command to serial port\n",
229 progname);
230 return -1;
231 }
232 if (verbose >= 3) {
233 putc('\n', stderr);
234 jtagmkI_prmsg(pgm, buf, len);
235 }
236 return 0;
237 }
238
239
jtagmkI_drain(PROGRAMMER * pgm,int display)240 static int jtagmkI_drain(PROGRAMMER * pgm, int display)
241 {
242 return serial_drain(&pgm->fd, display);
243 }
244
245
jtagmkI_resync(PROGRAMMER * pgm,int maxtries,int signon)246 static int jtagmkI_resync(PROGRAMMER * pgm, int maxtries, int signon)
247 {
248 int tries;
249 unsigned char buf[4], resp[9];
250 long otimeout = serial_recv_timeout;
251
252 serial_recv_timeout = 200;
253
254 avrdude_message(MSG_TRACE, "%s: jtagmkI_resync()\n", progname);
255
256 jtagmkI_drain(pgm, 0);
257
258 for (tries = 0; tries < maxtries; tries++) {
259
260 /* Get the sign-on information. */
261 buf[0] = CMD_GET_SYNC;
262 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): Sending sync command: ",
263 progname);
264
265 if (serial_send(&pgm->fd, buf, 1) != 0) {
266 avrdude_message(MSG_INFO, "\n%s: jtagmkI_resync(): failed to send command to serial port\n",
267 progname);
268 serial_recv_timeout = otimeout;
269 return -1;
270 }
271 if (serial_recv(&pgm->fd, resp, 1) == 0 && resp[0] == RESP_OK) {
272 avrdude_message(MSG_NOTICE2, "got RESP_OK\n");
273 break;
274 }
275
276 if (signon) {
277 /*
278 * The following is black magic, the idea has been taken from
279 * AVaRICE.
280 *
281 * Apparently, the ICE behaves differently right after a
282 * power-up vs. when reconnecting to an ICE that has already
283 * been worked with. The undocumented 'E' command (or
284 * subcommand) occasionally helps in getting the connection into
285 * sync.
286 */
287 buf[0] = CMD_GET_SIGNON;
288 buf[1] = 'E';
289 buf[2] = ' ';
290 buf[3] = ' ';
291 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): Sending sign-on command: ",
292 progname);
293
294 if (serial_send(&pgm->fd, buf, 4) != 0) {
295 avrdude_message(MSG_INFO, "\n%s: jtagmkI_resync(): failed to send command to serial port\n",
296 progname);
297 serial_recv_timeout = otimeout;
298 return -1;
299 }
300 if (serial_recv(&pgm->fd, resp, 9) == 0 && resp[0] == RESP_OK) {
301 avrdude_message(MSG_NOTICE2, "got RESP_OK\n");
302 break;
303 }
304 }
305 }
306 if (tries >= maxtries) {
307 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_resync(): "
308 "timeout/error communicating with programmer\n",
309 progname);
310 serial_recv_timeout = otimeout;
311 return -1;
312 }
313
314 serial_recv_timeout = otimeout;
315 return 0;
316 }
317
jtagmkI_getsync(PROGRAMMER * pgm)318 static int jtagmkI_getsync(PROGRAMMER * pgm)
319 {
320 unsigned char buf[1], resp[9];
321
322 if (jtagmkI_resync(pgm, 5, 1) < 0) {
323 jtagmkI_drain(pgm, 0);
324 return -1;
325 }
326
327 jtagmkI_drain(pgm, 0);
328
329 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getsync(): Sending sign-on command: ",
330 progname);
331
332 buf[0] = CMD_GET_SIGNON;
333 jtagmkI_send(pgm, buf, 1);
334 if (jtagmkI_recv(pgm, resp, 9) < 0)
335 return -1;
336 if (verbose >= 2) {
337 resp[8] = '\0';
338 avrdude_message(MSG_NOTICE2, "got %s\n", resp + 1);
339 }
340
341 return 0;
342 }
343
344 /*
345 * issue the 'chip erase' command to the AVR device
346 */
jtagmkI_chip_erase(PROGRAMMER * pgm,AVRPART * p)347 static int jtagmkI_chip_erase(PROGRAMMER * pgm, AVRPART * p)
348 {
349 unsigned char buf[1], resp[2];
350
351 buf[0] = CMD_CHIP_ERASE;
352 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_chip_erase(): Sending chip erase command: ",
353 progname);
354 jtagmkI_send(pgm, buf, 1);
355 if (jtagmkI_recv(pgm, resp, 2) < 0)
356 return -1;
357 if (resp[0] != RESP_OK) {
358 if (verbose >= 2)
359 putc('\n', stderr);
360 avrdude_message(MSG_INFO, "%s: jtagmkI_chip_erase(): "
361 "timeout/error communicating with programmer (resp %c)\n",
362 progname, resp[0]);
363 return -1;
364 } else {
365 if (verbose == 2)
366 avrdude_message(MSG_NOTICE2, "OK\n");
367 }
368
369 pgm->initialize(pgm, p);
370
371 return 0;
372 }
373
jtagmkI_set_devdescr(PROGRAMMER * pgm,AVRPART * p)374 static void jtagmkI_set_devdescr(PROGRAMMER * pgm, AVRPART * p)
375 {
376 unsigned char resp[2];
377 LNODEID ln;
378 AVRMEM * m;
379 struct {
380 unsigned char cmd;
381 struct device_descriptor dd;
382 } sendbuf;
383
384 memset(&sendbuf, 0, sizeof sendbuf);
385 sendbuf.cmd = CMD_SET_DEVICE_DESCRIPTOR;
386 sendbuf.dd.ucSPMCRAddress = p->spmcr;
387 sendbuf.dd.ucRAMPZAddress = p->rampz;
388 sendbuf.dd.ucIDRAddress = p->idr;
389 for (ln = lfirst(p->mem); ln; ln = lnext(ln)) {
390 m = ldata(ln);
391 if (strcmp(m->desc, "flash") == 0) {
392 PDATA(pgm)->flash_pagesize = m->page_size;
393 u16_to_b2(sendbuf.dd.uiFlashPageSize, PDATA(pgm)->flash_pagesize);
394 } else if (strcmp(m->desc, "eeprom") == 0) {
395 sendbuf.dd.ucEepromPageSize = PDATA(pgm)->eeprom_pagesize = m->page_size;
396 }
397 }
398
399 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_set_devdescr(): "
400 "Sending set device descriptor command: ",
401 progname);
402 jtagmkI_send(pgm, (unsigned char *)&sendbuf, sizeof(sendbuf));
403
404 if (jtagmkI_recv(pgm, resp, 2) < 0)
405 return;
406 if (resp[0] != RESP_OK) {
407 if (verbose >= 2)
408 putc('\n', stderr);
409 avrdude_message(MSG_INFO, "%s: jtagmkI_set_devdescr(): "
410 "timeout/error communicating with programmer (resp %c)\n",
411 progname, resp[0]);
412 } else {
413 if (verbose == 2)
414 avrdude_message(MSG_NOTICE2, "OK\n");
415 }
416 }
417
418 /*
419 * Reset the target.
420 */
jtagmkI_reset(PROGRAMMER * pgm)421 static int jtagmkI_reset(PROGRAMMER * pgm)
422 {
423 unsigned char buf[1], resp[2];
424
425 buf[0] = CMD_RESET;
426 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_reset(): Sending reset command: ",
427 progname);
428 jtagmkI_send(pgm, buf, 1);
429
430 if (jtagmkI_recv(pgm, resp, 2) < 0)
431 return -1;
432 if (resp[0] != RESP_OK) {
433 if (verbose >= 2)
434 putc('\n', stderr);
435 avrdude_message(MSG_INFO, "%s: jtagmkI_reset(): "
436 "timeout/error communicating with programmer (resp %c)\n",
437 progname, resp[0]);
438 return -1;
439 } else {
440 if (verbose == 2)
441 avrdude_message(MSG_NOTICE2, "OK\n");
442 }
443
444 return 0;
445 }
446
jtagmkI_program_enable_dummy(PROGRAMMER * pgm,AVRPART * p)447 static int jtagmkI_program_enable_dummy(PROGRAMMER * pgm, AVRPART * p)
448 {
449
450 return 0;
451 }
452
jtagmkI_program_enable(PROGRAMMER * pgm)453 static int jtagmkI_program_enable(PROGRAMMER * pgm)
454 {
455 unsigned char buf[1], resp[2];
456
457 if (PDATA(pgm)->prog_enabled)
458 return 0;
459
460 buf[0] = CMD_ENTER_PROGMODE;
461 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_program_enable(): "
462 "Sending enter progmode command: ",
463 progname);
464 jtagmkI_send(pgm, buf, 1);
465
466 if (jtagmkI_recv(pgm, resp, 2) < 0)
467 return -1;
468 if (resp[0] != RESP_OK) {
469 if (verbose >= 2)
470 putc('\n', stderr);
471 avrdude_message(MSG_INFO, "%s: jtagmkI_program_enable(): "
472 "timeout/error communicating with programmer (resp %c)\n",
473 progname, resp[0]);
474 return -1;
475 } else {
476 if (verbose == 2)
477 avrdude_message(MSG_NOTICE2, "OK\n");
478 }
479
480 PDATA(pgm)->prog_enabled = 1;
481
482 return 0;
483 }
484
jtagmkI_program_disable(PROGRAMMER * pgm)485 static int jtagmkI_program_disable(PROGRAMMER * pgm)
486 {
487 unsigned char buf[1], resp[2];
488
489 if (!PDATA(pgm)->prog_enabled)
490 return 0;
491
492 if (pgm->fd.ifd != -1) {
493 buf[0] = CMD_LEAVE_PROGMODE;
494 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_program_disable(): "
495 "Sending leave progmode command: ",
496 progname);
497 jtagmkI_send(pgm, buf, 1);
498
499 if (jtagmkI_recv(pgm, resp, 2) < 0)
500 return -1;
501 if (resp[0] != RESP_OK) {
502 if (verbose >= 2)
503 putc('\n', stderr);
504 avrdude_message(MSG_INFO, "%s: jtagmkI_program_disable(): "
505 "timeout/error communicating with programmer (resp %c)\n",
506 progname, resp[0]);
507 return -1;
508 } else {
509 if (verbose == 2)
510 avrdude_message(MSG_NOTICE2, "OK\n");
511 }
512 }
513 PDATA(pgm)->prog_enabled = 0;
514
515 return 0;
516 }
517
jtagmkI_get_baud(long baud)518 static unsigned char jtagmkI_get_baud(long baud)
519 {
520 int i;
521
522 for (i = 0; i < sizeof baudtab / sizeof baudtab[0]; i++)
523 if (baud == baudtab[i].baud)
524 return baudtab[i].val;
525
526 return 0;
527 }
528
529 /*
530 * initialize the AVR device and prepare it to accept commands
531 */
jtagmkI_initialize(PROGRAMMER * pgm,AVRPART * p)532 static int jtagmkI_initialize(PROGRAMMER * pgm, AVRPART * p)
533 {
534 AVRMEM hfuse;
535 unsigned char cmd[1], resp[5];
536 unsigned char b;
537
538 if (!(p->flags & AVRPART_HAS_JTAG)) {
539 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): part %s has no JTAG interface\n",
540 progname, p->desc);
541 return -1;
542 }
543
544 jtagmkI_drain(pgm, 0);
545
546 if ((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
547 if ((b = jtagmkI_get_baud(pgm->baudrate)) == 0) {
548 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): unsupported baudrate %d\n",
549 progname, pgm->baudrate);
550 } else {
551 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_initialize(): "
552 "trying to set baudrate to %d\n",
553 progname, pgm->baudrate);
554 if (jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
555 PDATA(pgm)->initial_baudrate = pgm->baudrate; /* don't adjust again later */
556 serial_setspeed(&pgm->fd, pgm->baudrate);
557 }
558 }
559 }
560
561 if (pgm->bitclock != 0.0) {
562 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_initialize(): "
563 "trying to set JTAG clock period to %.1f us\n",
564 progname, pgm->bitclock);
565 if (jtagmkI_set_sck_period(pgm, pgm->bitclock) != 0)
566 return -1;
567 }
568
569 cmd[0] = CMD_STOP;
570 jtagmkI_send(pgm, cmd, 1);
571 if (jtagmkI_recv(pgm, resp, 5) < 0)
572 return -1;
573 if (resp[0] != RESP_OK) {
574 if (verbose >= 2)
575 putc('\n', stderr);
576 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): "
577 "timeout/error communicating with programmer (resp %c)\n",
578 progname, resp[0]);
579 } else {
580 if (verbose == 2)
581 avrdude_message(MSG_NOTICE2, "OK\n");
582 }
583
584 /*
585 * Must set the device descriptor before entering programming mode.
586 */
587 jtagmkI_set_devdescr(pgm, p);
588
589 jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_LOW, PDATA(pgm)->flash_pagesize & 0xff);
590 jtagmkI_setparm(pgm, PARM_FLASH_PAGESIZE_HIGH, PDATA(pgm)->flash_pagesize >> 8);
591 jtagmkI_setparm(pgm, PARM_EEPROM_PAGESIZE, PDATA(pgm)->eeprom_pagesize & 0xff);
592
593 free(PDATA(pgm)->flash_pagecache);
594 free(PDATA(pgm)->eeprom_pagecache);
595 if ((PDATA(pgm)->flash_pagecache = malloc(PDATA(pgm)->flash_pagesize)) == NULL) {
596 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): Out of memory\n",
597 progname);
598 return -1;
599 }
600 if ((PDATA(pgm)->eeprom_pagecache = malloc(PDATA(pgm)->eeprom_pagesize)) == NULL) {
601 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): Out of memory\n",
602 progname);
603 free(PDATA(pgm)->flash_pagecache);
604 return -1;
605 }
606 PDATA(pgm)->flash_pageaddr = PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
607
608 if (jtagmkI_reset(pgm) < 0)
609 return -1;
610
611 strcpy(hfuse.desc, "hfuse");
612 if (jtagmkI_read_byte(pgm, p, &hfuse, 1, &b) < 0)
613 return -1;
614 if ((b & OCDEN) != 0)
615 avrdude_message(MSG_INFO, "%s: jtagmkI_initialize(): warning: OCDEN fuse not programmed, "
616 "single-byte EEPROM updates not possible\n",
617 progname);
618
619 return 0;
620 }
621
622
jtagmkI_disable(PROGRAMMER * pgm)623 static void jtagmkI_disable(PROGRAMMER * pgm)
624 {
625
626 free(PDATA(pgm)->flash_pagecache);
627 PDATA(pgm)->flash_pagecache = NULL;
628 free(PDATA(pgm)->eeprom_pagecache);
629 PDATA(pgm)->eeprom_pagecache = NULL;
630
631 (void)jtagmkI_program_disable(pgm);
632 }
633
jtagmkI_enable(PROGRAMMER * pgm)634 static void jtagmkI_enable(PROGRAMMER * pgm)
635 {
636 return;
637 }
638
639
jtagmkI_open(PROGRAMMER * pgm,char * port)640 static int jtagmkI_open(PROGRAMMER * pgm, char * port)
641 {
642 size_t i;
643
644 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open()\n", progname);
645
646 strcpy(pgm->port, port);
647 PDATA(pgm)->initial_baudrate = -1L;
648
649 for (i = 0; i < sizeof(baudtab) / sizeof(baudtab[0]); i++) {
650 union pinfo pinfo;
651 pinfo.baud = baudtab[i].baud;
652 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open(): trying to sync at baud rate %ld:\n",
653 progname, pinfo.baud);
654 if (serial_open(port, pinfo, &pgm->fd)==-1) {
655 return -1;
656 }
657
658 /*
659 * drain any extraneous input
660 */
661 jtagmkI_drain(pgm, 0);
662
663 if (jtagmkI_getsync(pgm) == 0) {
664 PDATA(pgm)->initial_baudrate = baudtab[i].baud;
665 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_open(): succeeded\n", progname);
666 return 0;
667 }
668
669 serial_close(&pgm->fd);
670 }
671
672 avrdude_message(MSG_INFO, "%s: jtagmkI_open(): failed to synchronize to ICE\n",
673 progname);
674 pgm->fd.ifd = -1;
675
676 return -1;
677 }
678
679
jtagmkI_close(PROGRAMMER * pgm)680 static void jtagmkI_close(PROGRAMMER * pgm)
681 {
682 unsigned char b;
683
684 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_close()\n", progname);
685
686 /*
687 * Revert baud rate to what it used to be when we started. This
688 * appears to make AVR Studio happier when it is about to access the
689 * ICE later on.
690 */
691 if ((serdev->flags & SERDEV_FL_CANSETSPEED) && PDATA(pgm)->initial_baudrate != pgm->baudrate) {
692 if ((b = jtagmkI_get_baud(PDATA(pgm)->initial_baudrate)) == 0) {
693 avrdude_message(MSG_INFO, "%s: jtagmkI_close(): unsupported baudrate %d\n",
694 progname, PDATA(pgm)->initial_baudrate);
695 } else {
696 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_close(): "
697 "trying to set baudrate to %d\n",
698 progname, PDATA(pgm)->initial_baudrate);
699 if (jtagmkI_setparm(pgm, PARM_BITRATE, b) == 0) {
700 serial_setspeed(&pgm->fd, pgm->baudrate);
701 }
702 }
703 }
704
705 if (pgm->fd.ifd != -1) {
706 serial_close(&pgm->fd);
707 }
708
709 pgm->fd.ifd = -1;
710 }
711
712
jtagmkI_paged_write(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int n_bytes)713 static int jtagmkI_paged_write(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
714 unsigned int page_size,
715 unsigned int addr, unsigned int n_bytes)
716 {
717 int block_size, send_size, tries;
718 unsigned int maxaddr = addr + n_bytes;
719 unsigned char cmd[6], *datacmd;
720 unsigned char resp[2];
721 int is_flash = 0;
722 long otimeout = serial_recv_timeout;
723 #define MAXTRIES 3
724
725 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_write(.., %s, %d, %d)\n",
726 progname, m->desc, page_size, n_bytes);
727
728 if (jtagmkI_program_enable(pgm) < 0)
729 return -1;
730
731 if (page_size == 0) page_size = 256;
732
733 if (page_size > 256) {
734 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): page size %d too large\n",
735 progname, page_size);
736 return -1;
737 }
738
739 if ((datacmd = malloc(page_size + 1)) == NULL) {
740 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): Out of memory\n",
741 progname);
742 return -1;
743 }
744
745 cmd[0] = CMD_WRITE_MEM;
746 if (strcmp(m->desc, "flash") == 0) {
747 cmd[1] = MTYPE_FLASH_PAGE;
748 PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
749 page_size = PDATA(pgm)->flash_pagesize;
750 is_flash = 1;
751 } else if (strcmp(m->desc, "eeprom") == 0) {
752 cmd[1] = MTYPE_EEPROM_PAGE;
753 PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
754 page_size = PDATA(pgm)->eeprom_pagesize;
755 }
756 datacmd[0] = CMD_DATA;
757
758 serial_recv_timeout = 1000;
759 for (; addr < maxaddr; addr += page_size) {
760 tries = 0;
761 again:
762
763 if (tries != 0 && jtagmkI_resync(pgm, 2000, 0) < 0) {
764 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): sync loss, retries exhausted\n",
765 progname);
766 return -1;
767 }
768
769 if (n_bytes < page_size)
770 block_size = n_bytes;
771 else
772 block_size = page_size;
773 avrdude_message(MSG_DEBUG, "%s: jtagmkI_paged_write(): "
774 "block_size at addr %d is %d\n",
775 progname, addr, block_size);
776
777 /* We always write full pages. */
778 send_size = page_size;
779 if (is_flash) {
780 cmd[2] = send_size / 2 - 1;
781 u32_to_b3(cmd + 3, addr / 2);
782 } else {
783 cmd[2] = send_size - 1;
784 u32_to_b3(cmd + 3, addr);
785 }
786
787 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_write(): "
788 "Sending write memory command: ",
789 progname);
790
791 /* First part, send the write command. */
792 jtagmkI_send(pgm, cmd, 6);
793 if (jtagmkI_recv(pgm, resp, 1) < 0)
794 return -1;
795 if (resp[0] != RESP_OK) {
796 if (verbose >= 2)
797 putc('\n', stderr);
798 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): "
799 "timeout/error communicating with programmer (resp %c)\n",
800 progname, resp[0]);
801 if (tries++ < MAXTRIES)
802 goto again;
803 serial_recv_timeout = otimeout;
804 return -1;
805 } else {
806 if (verbose == 2)
807 avrdude_message(MSG_NOTICE2, "OK\n");
808 }
809
810 /*
811 * The JTAG ICE will refuse to write anything but a full page, at
812 * least for the flash ROM. If a partial page has been requested,
813 * set the remainder to 0xff. (Maybe we should rather read back
814 * the existing contents instead before? Doesn't matter much, as
815 * bits cannot be written to 1 anyway.)
816 */
817 memset(datacmd + 1, 0xff, page_size);
818 memcpy(datacmd + 1, m->buf + addr, block_size);
819
820 /* Second, send the data command. */
821 jtagmkI_send(pgm, datacmd, send_size + 1);
822 if (jtagmkI_recv(pgm, resp, 2) < 0)
823 return -1;
824 if (resp[1] != RESP_OK) {
825 if (verbose >= 2)
826 putc('\n', stderr);
827 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_write(): "
828 "timeout/error communicating with programmer (resp %c)\n",
829 progname, resp[0]);
830 if (tries++ < MAXTRIES)
831 goto again;
832 serial_recv_timeout = otimeout;
833 return -1;
834 } else {
835 if (verbose == 2)
836 avrdude_message(MSG_NOTICE2, "OK\n");
837 }
838 }
839
840 free(datacmd);
841 serial_recv_timeout = otimeout;
842
843 #undef MAXTRIES
844 return n_bytes;
845 }
846
jtagmkI_paged_load(PROGRAMMER * pgm,AVRPART * p,AVRMEM * m,unsigned int page_size,unsigned int addr,unsigned int n_bytes)847 static int jtagmkI_paged_load(PROGRAMMER * pgm, AVRPART * p, AVRMEM * m,
848 unsigned int page_size,
849 unsigned int addr, unsigned int n_bytes)
850 {
851 int block_size, read_size, is_flash = 0, tries;
852 unsigned int maxaddr = addr + n_bytes;
853 unsigned char cmd[6], resp[256 * 2 + 3];
854 long otimeout = serial_recv_timeout;
855 #define MAXTRIES 3
856
857 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_load(.., %s, %d, %d)\n",
858 progname, m->desc, page_size, n_bytes);
859
860 if (jtagmkI_program_enable(pgm) < 0)
861 return -1;
862
863 page_size = m->readsize;
864
865 cmd[0] = CMD_READ_MEM;
866 if (strcmp(m->desc, "flash") == 0) {
867 cmd[1] = MTYPE_FLASH_PAGE;
868 is_flash = 1;
869 } else if (strcmp(m->desc, "eeprom") == 0) {
870 cmd[1] = MTYPE_EEPROM_PAGE;
871 }
872
873 if (page_size > (is_flash? 512: 256)) {
874 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): page size %d too large\n",
875 progname, page_size);
876 return -1;
877 }
878
879 serial_recv_timeout = 1000;
880 for (; addr < maxaddr; addr += page_size) {
881 tries = 0;
882 again:
883 if (tries != 0 && jtagmkI_resync(pgm, 2000, 0) < 0) {
884 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): sync loss, retries exhausted\n",
885 progname);
886 return -1;
887 }
888
889 if (n_bytes < page_size)
890 block_size = n_bytes;
891 else
892 block_size = page_size;
893 avrdude_message(MSG_DEBUG, "%s: jtagmkI_paged_load(): "
894 "block_size at addr %d is %d\n",
895 progname, addr, block_size);
896
897 if (is_flash) {
898 read_size = 2 * ((block_size + 1) / 2); /* round up */
899 cmd[2] = read_size / 2 - 1;
900 u32_to_b3(cmd + 3, addr / 2);
901 } else {
902 read_size = page_size;
903 cmd[2] = page_size - 1;
904 u32_to_b3(cmd + 3, addr);
905 }
906
907 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_paged_load(): Sending read memory command: ",
908 progname);
909
910 jtagmkI_send(pgm, cmd, 6);
911 if (jtagmkI_recv(pgm, resp, read_size + 3) < 0)
912 return -1;
913
914 if (resp[read_size + 3 - 1] != RESP_OK) {
915 if (verbose >= 2)
916 putc('\n', stderr);
917 avrdude_message(MSG_INFO, "%s: jtagmkI_paged_load(): "
918 "timeout/error communicating with programmer (resp %c)\n",
919 progname, resp[read_size + 3 - 1]);
920 if (tries++ < MAXTRIES)
921 goto again;
922
923 serial_recv_timeout = otimeout;
924 return -1;
925 } else {
926 if (verbose == 2)
927 avrdude_message(MSG_NOTICE2, "OK\n");
928 }
929
930 memcpy(m->buf + addr, resp + 1, block_size);
931 }
932 serial_recv_timeout = otimeout;
933
934 #undef MAXTRIES
935 return n_bytes;
936 }
937
jtagmkI_read_byte(PROGRAMMER * pgm,AVRPART * p,AVRMEM * mem,unsigned long addr,unsigned char * value)938 static int jtagmkI_read_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * mem,
939 unsigned long addr, unsigned char * value)
940 {
941 unsigned char cmd[6];
942 unsigned char resp[256 * 2 + 3], *cache_ptr = NULL;
943 unsigned long paddr = 0UL, *paddr_ptr = NULL;
944 unsigned int pagesize = 0;
945 int respsize = 3 + 1;
946 int is_flash = 0;
947
948 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_read_byte(.., %s, 0x%lx, ...)\n",
949 progname, mem->desc, addr);
950
951 if (jtagmkI_program_enable(pgm) < 0)
952 return -1;
953
954 cmd[0] = CMD_READ_MEM;
955
956 if (strcmp(mem->desc, "flash") == 0) {
957 cmd[1] = MTYPE_FLASH_PAGE;
958 pagesize = mem->page_size;
959 paddr = addr & ~(pagesize - 1);
960 paddr_ptr = &PDATA(pgm)->flash_pageaddr;
961 cache_ptr = PDATA(pgm)->flash_pagecache;
962 is_flash = 1;
963 } else if (strcmp(mem->desc, "eeprom") == 0) {
964 cmd[1] = MTYPE_EEPROM_PAGE;
965 pagesize = mem->page_size;
966 paddr = addr & ~(pagesize - 1);
967 paddr_ptr = &PDATA(pgm)->eeprom_pageaddr;
968 cache_ptr = PDATA(pgm)->eeprom_pagecache;
969 } else if (strcmp(mem->desc, "lfuse") == 0) {
970 cmd[1] = MTYPE_FUSE_BITS;
971 addr = 0;
972 } else if (strcmp(mem->desc, "hfuse") == 0) {
973 cmd[1] = MTYPE_FUSE_BITS;
974 addr = 1;
975 } else if (strcmp(mem->desc, "efuse") == 0) {
976 cmd[1] = MTYPE_FUSE_BITS;
977 addr = 2;
978 } else if (strcmp(mem->desc, "lock") == 0) {
979 cmd[1] = MTYPE_LOCK_BITS;
980 } else if (strcmp(mem->desc, "calibration") == 0) {
981 cmd[1] = MTYPE_OSCCAL_BYTE;
982 } else if (strcmp(mem->desc, "signature") == 0) {
983 cmd[1] = MTYPE_SIGN_JTAG;
984 }
985
986 /*
987 * To improve the read speed, we used paged reads for flash and
988 * EEPROM, and cache the results in a page cache.
989 *
990 * Page cache validation is based on "{flash,eeprom}_pageaddr"
991 * (holding the base address of the most recent cache fill
992 * operation). This variable is set to (unsigned long)-1L when the
993 * cache needs to be invalidated.
994 */
995 if (pagesize && paddr == *paddr_ptr) {
996 *value = cache_ptr[addr & (pagesize - 1)];
997 return 0;
998 }
999
1000 if (pagesize) {
1001 if (is_flash) {
1002 cmd[2] = pagesize / 2 - 1;
1003 u32_to_b3(cmd + 3, paddr / 2);
1004 } else {
1005 cmd[2] = pagesize - 1;
1006 u32_to_b3(cmd + 3, paddr);
1007 }
1008 respsize = 3 + pagesize;
1009 } else {
1010 if (cmd[1] == MTYPE_FUSE_BITS) {
1011 /*
1012 * The mkI ICE has a bug where it doesn't read efuse correctly
1013 * when reading it as a single byte @offset 2, while reading all
1014 * fuses at once does work.
1015 */
1016 cmd[2] = 3 - 1;
1017 u32_to_b3(cmd + 3, 0);
1018 respsize = 3 + 3;
1019 } else {
1020 cmd[2] = 1 - 1;
1021 u32_to_b3(cmd + 3, addr);
1022 }
1023 }
1024
1025 jtagmkI_send(pgm, cmd, 6);
1026 if (jtagmkI_recv(pgm, resp, respsize) < 0)
1027 return -1;
1028
1029 if (resp[respsize - 1] != RESP_OK) {
1030 if (verbose >= 2)
1031 putc('\n', stderr);
1032 avrdude_message(MSG_INFO, "%s: jtagmkI_read_byte(): "
1033 "timeout/error communicating with programmer (resp %c)\n",
1034 progname, resp[respsize - 1]);
1035 return -1;
1036 } else {
1037 if (verbose == 2)
1038 avrdude_message(MSG_NOTICE2, "OK\n");
1039 }
1040
1041 if (pagesize) {
1042 *paddr_ptr = paddr;
1043 memcpy(cache_ptr, resp + 1, pagesize);
1044 *value = cache_ptr[addr & (pagesize - 1)];
1045 } else if (cmd[1] == MTYPE_FUSE_BITS) {
1046 /* extract the desired fuse */
1047 *value = resp[1 + addr];
1048 } else
1049 *value = resp[1];
1050
1051 return 0;
1052 }
1053
jtagmkI_write_byte(PROGRAMMER * pgm,AVRPART * p,AVRMEM * mem,unsigned long addr,unsigned char data)1054 static int jtagmkI_write_byte(PROGRAMMER * pgm, AVRPART * p, AVRMEM * mem,
1055 unsigned long addr, unsigned char data)
1056 {
1057 unsigned char cmd[6], datacmd[1 * 2 + 1];
1058 unsigned char resp[1], writedata;
1059 int len, need_progmode = 1;
1060
1061 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_write_byte(.., %s, 0x%lx, ...)\n",
1062 progname, mem->desc, addr);
1063
1064 writedata = data;
1065 cmd[0] = CMD_WRITE_MEM;
1066 if (strcmp(mem->desc, "flash") == 0) {
1067 cmd[1] = MTYPE_SPM;
1068 need_progmode = 0;
1069 PDATA(pgm)->flash_pageaddr = (unsigned long)-1L;
1070 } else if (strcmp(mem->desc, "eeprom") == 0) {
1071 cmd[1] = MTYPE_EEPROM;
1072 need_progmode = 0;
1073 PDATA(pgm)->eeprom_pageaddr = (unsigned long)-1L;
1074 } else if (strcmp(mem->desc, "lfuse") == 0) {
1075 cmd[1] = MTYPE_FUSE_BITS;
1076 addr = 0;
1077 } else if (strcmp(mem->desc, "hfuse") == 0) {
1078 cmd[1] = MTYPE_FUSE_BITS;
1079 addr = 1;
1080 } else if (strcmp(mem->desc, "efuse") == 0) {
1081 cmd[1] = MTYPE_FUSE_BITS;
1082 addr = 2;
1083 } else if (strcmp(mem->desc, "lock") == 0) {
1084 cmd[1] = MTYPE_LOCK_BITS;
1085 } else if (strcmp(mem->desc, "calibration") == 0) {
1086 cmd[1] = MTYPE_OSCCAL_BYTE;
1087 } else if (strcmp(mem->desc, "signature") == 0) {
1088 cmd[1] = MTYPE_SIGN_JTAG;
1089 }
1090
1091 if (need_progmode) {
1092 if (jtagmkI_program_enable(pgm) < 0)
1093 return -1;
1094 } else {
1095 if (jtagmkI_program_disable(pgm) < 0)
1096 return -1;
1097 }
1098
1099 cmd[2] = 1 - 1;
1100 if (cmd[1] == MTYPE_SPM) {
1101 /*
1102 * Flash is word-addressed, but we cannot handle flash anyway
1103 * here, as it needs to be written one page at a time...
1104 */
1105 u32_to_b3(cmd + 3, addr / 2);
1106 } else {
1107 u32_to_b3(cmd + 3, addr);
1108 }
1109 /* First part, send the write command. */
1110 jtagmkI_send(pgm, cmd, 6);
1111 if (jtagmkI_recv(pgm, resp, 1) < 0)
1112 return -1;
1113 if (resp[0] != RESP_OK) {
1114 if (verbose >= 2)
1115 putc('\n', stderr);
1116 avrdude_message(MSG_INFO, "%s: jtagmkI_write_byte(): "
1117 "timeout/error communicating with programmer (resp %c)\n",
1118 progname, resp[0]);
1119 return -1;
1120 } else {
1121 if (verbose == 2)
1122 avrdude_message(MSG_NOTICE2, "OK\n");
1123 }
1124
1125 /* Now, send the data buffer. */
1126 datacmd[0] = CMD_DATA;
1127 if (cmd[1] == MTYPE_SPM) {
1128 len = 3;
1129 if ((addr & 1) != 0) {
1130 datacmd[1] = 0;
1131 datacmd[2] = writedata;
1132 } else {
1133 datacmd[1] = writedata;
1134 datacmd[2] = 0;
1135 }
1136 } else {
1137 len = 2;
1138 datacmd[1] = writedata;
1139 }
1140 jtagmkI_send(pgm, datacmd, len);
1141 if (jtagmkI_recv(pgm, resp, 1) < 0)
1142 return -1;
1143 if (resp[0] != RESP_OK) {
1144 if (verbose >= 2)
1145 putc('\n', stderr);
1146 avrdude_message(MSG_INFO, "%s: jtagmkI_write_byte(): "
1147 "timeout/error communicating with programmer (resp %c)\n",
1148 progname, resp[0]);
1149 return -1;
1150 } else {
1151 if (verbose == 2)
1152 avrdude_message(MSG_NOTICE2, "OK\n");
1153 }
1154
1155 return 0;
1156 }
1157
1158
1159 /*
1160 * Set the JTAG clock. The actual frequency is quite a bit of
1161 * guesswork, based on the values claimed by AVR Studio. Inside the
1162 * JTAG ICE, the value is the delay count of a delay loop between the
1163 * JTAG clock edges. A count of 0 bypasses the delay loop.
1164 *
1165 * As the STK500 expresses it as a period length (and we actualy do
1166 * program a period length as well), we rather call it by that name.
1167 */
jtagmkI_set_sck_period(PROGRAMMER * pgm,double v)1168 static int jtagmkI_set_sck_period(PROGRAMMER * pgm, double v)
1169 {
1170 unsigned char dur;
1171
1172 v = 1 / v; /* convert to frequency */
1173 if (v >= 1e6)
1174 dur = JTAG_BITRATE_1_MHz;
1175 else if (v >= 499e3)
1176 dur = JTAG_BITRATE_500_kHz;
1177 else if (v >= 249e3)
1178 dur = JTAG_BITRATE_250_kHz;
1179 else
1180 dur = JTAG_BITRATE_125_kHz;
1181
1182 return jtagmkI_setparm(pgm, PARM_CLOCK, dur);
1183 }
1184
1185
1186 /*
1187 * Read an emulator parameter. The result is exactly one byte,
1188 * multi-byte parameters get two different parameter names for
1189 * their components.
1190 */
jtagmkI_getparm(PROGRAMMER * pgm,unsigned char parm,unsigned char * value)1191 static int jtagmkI_getparm(PROGRAMMER * pgm, unsigned char parm,
1192 unsigned char * value)
1193 {
1194 unsigned char buf[2], resp[3];
1195
1196 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getparm()\n", progname);
1197
1198 buf[0] = CMD_GET_PARAM;
1199 buf[1] = parm;
1200 if (verbose >= 2)
1201 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_getparm(): "
1202 "Sending get parameter command (parm 0x%02x): ",
1203 progname, parm);
1204 jtagmkI_send(pgm, buf, 2);
1205
1206 if (jtagmkI_recv(pgm, resp, 3) < 0)
1207 return -1;
1208 if (resp[0] != RESP_OK) {
1209 if (verbose >= 2)
1210 putc('\n', stderr);
1211 avrdude_message(MSG_INFO, "%s: jtagmkI_getparm(): "
1212 "timeout/error communicating with programmer (resp %c)\n",
1213 progname, resp[0]);
1214 return -1;
1215 } else if (resp[2] != RESP_OK) {
1216 if (verbose >= 2)
1217 putc('\n', stderr);
1218 avrdude_message(MSG_INFO, "%s: jtagmkI_getparm(): "
1219 "unknown parameter 0x%02x\n",
1220 progname, parm);
1221 return -1;
1222 } else {
1223 if (verbose == 2)
1224 avrdude_message(MSG_NOTICE2, "OK, value 0x%02x\n", resp[1]);
1225 }
1226
1227 *value = resp[1];
1228
1229 return 0;
1230 }
1231
1232 /*
1233 * Write an emulator parameter.
1234 */
jtagmkI_setparm(PROGRAMMER * pgm,unsigned char parm,unsigned char value)1235 static int jtagmkI_setparm(PROGRAMMER * pgm, unsigned char parm,
1236 unsigned char value)
1237 {
1238 unsigned char buf[3], resp[2];
1239
1240 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_setparm()\n", progname);
1241
1242 buf[0] = CMD_SET_PARAM;
1243 buf[1] = parm;
1244 buf[2] = value;
1245 avrdude_message(MSG_NOTICE2, "%s: jtagmkI_setparm(): "
1246 "Sending set parameter command (parm 0x%02x): ",
1247 progname, parm);
1248 jtagmkI_send(pgm, buf, 3);
1249 if (jtagmkI_recv(pgm, resp, 2) < 0)
1250 return -1;
1251 if (resp[0] != RESP_OK) {
1252 if (verbose >= 2)
1253 putc('\n', stderr);
1254 avrdude_message(MSG_INFO, "%s: jtagmkI_setparm(): "
1255 "timeout/error communicating with programmer (resp %c)\n",
1256 progname, resp[0]);
1257 return -1;
1258 } else {
1259 if (verbose == 2)
1260 avrdude_message(MSG_NOTICE2, "OK\n");
1261 }
1262
1263 return 0;
1264 }
1265
1266
jtagmkI_display(PROGRAMMER * pgm,const char * p)1267 static void jtagmkI_display(PROGRAMMER * pgm, const char * p)
1268 {
1269
1270 unsigned char hw, fw;
1271
1272 if (jtagmkI_getparm(pgm, PARM_HW_VERSION, &hw) < 0 ||
1273 jtagmkI_getparm(pgm, PARM_SW_VERSION, &fw) < 0)
1274 return;
1275
1276 avrdude_message(MSG_INFO, "%sICE hardware version: 0x%02x\n", p, hw);
1277 avrdude_message(MSG_INFO, "%sICE firmware version: 0x%02x\n", p, fw);
1278
1279 jtagmkI_print_parms1(pgm, p);
1280
1281 return;
1282 }
1283
1284
jtagmkI_print_parms1(PROGRAMMER * pgm,const char * p)1285 static void jtagmkI_print_parms1(PROGRAMMER * pgm, const char * p)
1286 {
1287 unsigned char vtarget, jtag_clock;
1288 const char *clkstr;
1289 double clk;
1290
1291 if (jtagmkI_getparm(pgm, PARM_OCD_VTARGET, &vtarget) < 0 ||
1292 jtagmkI_getparm(pgm, PARM_CLOCK, &jtag_clock) < 0)
1293 return;
1294
1295 switch ((unsigned)jtag_clock) {
1296 case JTAG_BITRATE_1_MHz:
1297 clkstr = "1 MHz";
1298 clk = 1e6;
1299 break;
1300
1301 case JTAG_BITRATE_500_kHz:
1302 clkstr = "500 kHz";
1303 clk = 500e3;
1304 break;
1305
1306 case JTAG_BITRATE_250_kHz:
1307 clkstr = "250 kHz";
1308 clk = 250e3;
1309 break;
1310
1311 case JTAG_BITRATE_125_kHz:
1312 clkstr = "125 kHz";
1313 clk = 125e3;
1314 break;
1315
1316 default:
1317 clkstr = "???";
1318 clk = 1e6;
1319 }
1320
1321 avrdude_message(MSG_INFO, "%sVtarget : %.1f V\n", p,
1322 6.25 * (unsigned)vtarget / 255.0);
1323 avrdude_message(MSG_INFO, "%sJTAG clock : %s (%.1f us)\n", p, clkstr,
1324 1.0e6 / clk);
1325
1326 return;
1327 }
1328
1329
jtagmkI_print_parms(PROGRAMMER * pgm)1330 static void jtagmkI_print_parms(PROGRAMMER * pgm)
1331 {
1332 jtagmkI_print_parms1(pgm, "");
1333 }
1334
1335 const char jtagmkI_desc[] = "Atmel JTAG ICE mkI";
1336
jtagmkI_initpgm(PROGRAMMER * pgm)1337 void jtagmkI_initpgm(PROGRAMMER * pgm)
1338 {
1339 strcpy(pgm->type, "JTAGMKI");
1340
1341 /*
1342 * mandatory functions
1343 */
1344 pgm->initialize = jtagmkI_initialize;
1345 pgm->display = jtagmkI_display;
1346 pgm->enable = jtagmkI_enable;
1347 pgm->disable = jtagmkI_disable;
1348 pgm->program_enable = jtagmkI_program_enable_dummy;
1349 pgm->chip_erase = jtagmkI_chip_erase;
1350 pgm->open = jtagmkI_open;
1351 pgm->close = jtagmkI_close;
1352 pgm->read_byte = jtagmkI_read_byte;
1353 pgm->write_byte = jtagmkI_write_byte;
1354
1355 /*
1356 * optional functions
1357 */
1358 pgm->paged_write = jtagmkI_paged_write;
1359 pgm->paged_load = jtagmkI_paged_load;
1360 pgm->print_parms = jtagmkI_print_parms;
1361 pgm->set_sck_period = jtagmkI_set_sck_period;
1362 pgm->setup = jtagmkI_setup;
1363 pgm->teardown = jtagmkI_teardown;
1364 pgm->page_size = 256;
1365 }
1366