1 /***************************************************************************
2 * Copyright (C) 2009 by Simon Qian *
3 * SimonQian@SimonQian.com *
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. *
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. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
26 #include <target/avrt.h>
28 /* AVR_JTAG_Instructions */
29 #define AVR_JTAG_INS_LEN 4
30 /* Public Instructions: */
31 #define AVR_JTAG_INS_EXTEST 0x00
32 #define AVR_JTAG_INS_IDCODE 0x01
33 #define AVR_JTAG_INS_SAMPLE_PRELOAD 0x02
34 #define AVR_JTAG_INS_BYPASS 0x0F
35 /* AVR Specified Public Instructions: */
36 #define AVR_JTAG_INS_AVR_RESET 0x0C
37 #define AVR_JTAG_INS_PROG_ENABLE 0x04
38 #define AVR_JTAG_INS_PROG_COMMANDS 0x05
39 #define AVR_JTAG_INS_PROG_PAGELOAD 0x06
40 #define AVR_JTAG_INS_PROG_PAGEREAD 0x07
43 #define AVR_JTAG_REG_Bypass_Len 1
44 #define AVR_JTAG_REG_DeviceID_Len 32
46 #define AVR_JTAG_REG_Reset_Len 1
47 #define AVR_JTAG_REG_JTAGID_Len 32
48 #define AVR_JTAG_REG_ProgrammingEnable_Len 16
49 #define AVR_JTAG_REG_ProgrammingCommand_Len 15
50 #define AVR_JTAG_REG_FlashDataByte_Len 16
61 struct avrf_flash_bank
{
66 static struct avrf_type avft_chips_info
[] = {
67 /* name, chip_id, flash_page_size, flash_page_num,
68 * eeprom_page_size, eeprom_page_num
70 {"atmega128", 0x9702, 256, 512, 8, 512},
71 {"at90can128", 0x9781, 256, 512, 8, 512},
72 {"atmega164p", 0x940a, 128, 128, 4, 128},
73 {"atmega324p", 0x9508, 128, 256, 4, 256},
74 {"atmega324pa", 0x9511, 128, 256, 4, 256},
75 {"atmega644p", 0x960a, 256, 256, 8, 256},
76 {"atmega1284p", 0x9705, 256, 512, 8, 512},
79 /* avr program functions */
80 static int avr_jtag_reset(struct avr_common
*avr
, uint32_t reset
)
82 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_AVR_RESET
);
83 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, reset
, AVR_JTAG_REG_Reset_Len
);
88 static int avr_jtag_read_jtagid(struct avr_common
*avr
, uint32_t *id
)
90 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_IDCODE
);
91 avr_jtag_senddat(avr
->jtag_info
.tap
, id
, 0, AVR_JTAG_REG_JTAGID_Len
);
96 static int avr_jtagprg_enterprogmode(struct avr_common
*avr
)
98 avr_jtag_reset(avr
, 1);
100 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
101 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xA370, AVR_JTAG_REG_ProgrammingEnable_Len
);
106 static int avr_jtagprg_leaveprogmode(struct avr_common
*avr
)
108 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
109 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2300, AVR_JTAG_REG_ProgrammingCommand_Len
);
110 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_ProgrammingCommand_Len
);
112 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
113 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0, AVR_JTAG_REG_ProgrammingEnable_Len
);
115 avr_jtag_reset(avr
, 0);
120 static int avr_jtagprg_chiperase(struct avr_common
*avr
)
124 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
125 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2380, AVR_JTAG_REG_ProgrammingCommand_Len
);
126 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len
);
127 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
128 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
132 avr_jtag_senddat(avr
->jtag_info
.tap
,
135 AVR_JTAG_REG_ProgrammingCommand_Len
);
136 if (ERROR_OK
!= mcu_execute_queue())
138 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
139 } while (!(poll_value
& 0x0200));
144 static int avr_jtagprg_writeflashpage(struct avr_common
*avr
,
150 uint32_t i
, poll_value
;
152 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
153 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len
);
155 /* load addr high byte */
156 avr_jtag_senddat(avr
->jtag_info
.tap
,
158 0x0700 | ((addr
>> 9) & 0xFF),
159 AVR_JTAG_REG_ProgrammingCommand_Len
);
161 /* load addr low byte */
162 avr_jtag_senddat(avr
->jtag_info
.tap
,
164 0x0300 | ((addr
>> 1) & 0xFF),
165 AVR_JTAG_REG_ProgrammingCommand_Len
);
167 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
169 for (i
= 0; i
< page_size
; i
++) {
171 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
173 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
176 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
178 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
179 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len
);
180 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
181 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
185 avr_jtag_senddat(avr
->jtag_info
.tap
,
188 AVR_JTAG_REG_ProgrammingCommand_Len
);
189 if (ERROR_OK
!= mcu_execute_queue())
191 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
192 } while (!(poll_value
& 0x0200));
197 FLASH_BANK_COMMAND_HANDLER(avrf_flash_bank_command
)
199 struct avrf_flash_bank
*avrf_info
;
202 return ERROR_COMMAND_SYNTAX_ERROR
;
204 avrf_info
= malloc(sizeof(struct avrf_flash_bank
));
205 bank
->driver_priv
= avrf_info
;
207 avrf_info
->probed
= 0;
212 static int avrf_erase(struct flash_bank
*bank
, int first
, int last
)
214 struct target
*target
= bank
->target
;
215 struct avr_common
*avr
= target
->arch_info
;
218 LOG_DEBUG("%s", __func__
);
220 if (target
->state
!= TARGET_HALTED
) {
221 LOG_ERROR("Target not halted");
222 return ERROR_TARGET_NOT_HALTED
;
225 status
= avr_jtagprg_enterprogmode(avr
);
226 if (status
!= ERROR_OK
)
229 status
= avr_jtagprg_chiperase(avr
);
230 if (status
!= ERROR_OK
)
233 return avr_jtagprg_leaveprogmode(avr
);
236 static int avrf_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
238 LOG_INFO("%s", __func__
);
242 static int avrf_write(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
244 struct target
*target
= bank
->target
;
245 struct avr_common
*avr
= target
->arch_info
;
246 uint32_t cur_size
, cur_buffer_size
, page_size
;
248 if (bank
->target
->state
!= TARGET_HALTED
) {
249 LOG_ERROR("Target not halted");
250 return ERROR_TARGET_NOT_HALTED
;
253 page_size
= bank
->sectors
[0].size
;
254 if ((offset
% page_size
) != 0) {
255 LOG_WARNING("offset 0x%" PRIx32
" breaks required %" PRIu32
"-byte alignment",
258 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
261 LOG_DEBUG("offset is 0x%08" PRIx32
"", offset
);
262 LOG_DEBUG("count is %" PRId32
"", count
);
264 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
269 if (count
> page_size
)
270 cur_buffer_size
= page_size
;
272 cur_buffer_size
= count
;
273 avr_jtagprg_writeflashpage(avr
,
278 count
-= cur_buffer_size
;
279 cur_size
+= cur_buffer_size
;
284 return avr_jtagprg_leaveprogmode(avr
);
287 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
288 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
289 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
291 static int avrf_probe(struct flash_bank
*bank
)
293 struct target
*target
= bank
->target
;
294 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
295 struct avr_common
*avr
= target
->arch_info
;
296 struct avrf_type
*avr_info
= NULL
;
300 if (bank
->target
->state
!= TARGET_HALTED
) {
301 LOG_ERROR("Target not halted");
302 return ERROR_TARGET_NOT_HALTED
;
305 avrf_info
->probed
= 0;
307 avr_jtag_read_jtagid(avr
, &device_id
);
308 if (ERROR_OK
!= mcu_execute_queue())
311 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
312 if (EXTRACT_MFG(device_id
) != 0x1F)
313 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
314 EXTRACT_MFG(device_id
),
317 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
318 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
319 avr_info
= &avft_chips_info
[i
];
320 LOG_INFO("target device is %s", avr_info
->name
);
325 if (avr_info
!= NULL
) {
328 bank
->sectors
= NULL
;
332 bank
->base
= 0x00000000;
333 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
334 bank
->num_sectors
= avr_info
->flash_page_num
;
335 bank
->sectors
= malloc(sizeof(struct flash_sector
) * avr_info
->flash_page_num
);
337 for (i
= 0; i
< avr_info
->flash_page_num
; i
++) {
338 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
339 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
340 bank
->sectors
[i
].is_erased
= -1;
341 bank
->sectors
[i
].is_protected
= 1;
344 avrf_info
->probed
= 1;
347 /* chip not supported */
348 LOG_ERROR("0x%" PRIx32
" is not support for avr", EXTRACT_PART(device_id
));
350 avrf_info
->probed
= 1;
355 static int avrf_auto_probe(struct flash_bank
*bank
)
357 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
358 if (avrf_info
->probed
)
360 return avrf_probe(bank
);
363 static int avrf_protect_check(struct flash_bank
*bank
)
365 LOG_INFO("%s", __func__
);
369 static int avrf_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
371 struct target
*target
= bank
->target
;
372 struct avr_common
*avr
= target
->arch_info
;
373 struct avrf_type
*avr_info
= NULL
;
377 if (bank
->target
->state
!= TARGET_HALTED
) {
378 LOG_ERROR("Target not halted");
379 return ERROR_TARGET_NOT_HALTED
;
382 avr_jtag_read_jtagid(avr
, &device_id
);
383 if (ERROR_OK
!= mcu_execute_queue())
386 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
387 if (EXTRACT_MFG(device_id
) != 0x1F)
388 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
389 EXTRACT_MFG(device_id
),
392 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
393 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
394 avr_info
= &avft_chips_info
[i
];
395 LOG_INFO("target device is %s", avr_info
->name
);
401 if (avr_info
!= NULL
) {
403 snprintf(buf
, buf_size
, "%s - Rev: 0x%" PRIx32
"", avr_info
->name
,
404 EXTRACT_VER(device_id
));
407 /* chip not supported */
408 snprintf(buf
, buf_size
, "Cannot identify target as a avr\n");
409 return ERROR_FLASH_OPERATION_FAILED
;
413 static int avrf_mass_erase(struct flash_bank
*bank
)
415 struct target
*target
= bank
->target
;
416 struct avr_common
*avr
= target
->arch_info
;
418 if (target
->state
!= TARGET_HALTED
) {
419 LOG_ERROR("Target not halted");
420 return ERROR_TARGET_NOT_HALTED
;
423 if ((ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
424 || (ERROR_OK
!= avr_jtagprg_chiperase(avr
))
425 || (ERROR_OK
!= avr_jtagprg_leaveprogmode(avr
)))
431 COMMAND_HANDLER(avrf_handle_mass_erase_command
)
436 return ERROR_COMMAND_SYNTAX_ERROR
;
438 struct flash_bank
*bank
;
439 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
440 if (ERROR_OK
!= retval
)
443 if (avrf_mass_erase(bank
) == ERROR_OK
) {
444 /* set all sectors as erased */
445 for (i
= 0; i
< bank
->num_sectors
; i
++)
446 bank
->sectors
[i
].is_erased
= 1;
448 command_print(CMD_CTX
, "avr mass erase complete");
450 command_print(CMD_CTX
, "avr mass erase failed");
452 LOG_DEBUG("%s", __func__
);
456 static const struct command_registration avrf_exec_command_handlers
[] = {
458 .name
= "mass_erase",
460 .handler
= avrf_handle_mass_erase_command
,
461 .mode
= COMMAND_EXEC
,
462 .help
= "erase entire device",
464 COMMAND_REGISTRATION_DONE
466 static const struct command_registration avrf_command_handlers
[] = {
470 .help
= "AVR flash command group",
472 .chain
= avrf_exec_command_handlers
,
474 COMMAND_REGISTRATION_DONE
477 struct flash_driver avr_flash
= {
479 .commands
= avrf_command_handlers
,
480 .flash_bank_command
= avrf_flash_bank_command
,
482 .protect
= avrf_protect
,
484 .read
= default_flash_read
,
486 .auto_probe
= avrf_auto_probe
,
487 .erase_check
= default_flash_blank_check
,
488 .protect_check
= avrf_protect_check
,
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)