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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
24 #include <target/avrt.h>
26 /* AVR_JTAG_Instructions */
27 #define AVR_JTAG_INS_LEN 4
28 /* Public Instructions: */
29 #define AVR_JTAG_INS_EXTEST 0x00
30 #define AVR_JTAG_INS_IDCODE 0x01
31 #define AVR_JTAG_INS_SAMPLE_PRELOAD 0x02
32 #define AVR_JTAG_INS_BYPASS 0x0F
33 /* AVR Specified Public Instructions: */
34 #define AVR_JTAG_INS_AVR_RESET 0x0C
35 #define AVR_JTAG_INS_PROG_ENABLE 0x04
36 #define AVR_JTAG_INS_PROG_COMMANDS 0x05
37 #define AVR_JTAG_INS_PROG_PAGELOAD 0x06
38 #define AVR_JTAG_INS_PROG_PAGEREAD 0x07
41 #define AVR_JTAG_REG_Bypass_Len 1
42 #define AVR_JTAG_REG_DeviceID_Len 32
44 #define AVR_JTAG_REG_Reset_Len 1
45 #define AVR_JTAG_REG_JTAGID_Len 32
46 #define AVR_JTAG_REG_ProgrammingEnable_Len 16
47 #define AVR_JTAG_REG_ProgrammingCommand_Len 15
48 #define AVR_JTAG_REG_FlashDataByte_Len 16
59 struct avrf_flash_bank
{
64 static const struct avrf_type avft_chips_info
[] = {
65 /* name, chip_id, flash_page_size, flash_page_num,
66 * eeprom_page_size, eeprom_page_num
68 {"atmega128", 0x9702, 256, 512, 8, 512},
69 {"at90can128", 0x9781, 256, 512, 8, 512},
70 {"at90usb128", 0x9782, 256, 512, 8, 512},
71 {"atmega164p", 0x940a, 128, 128, 4, 128},
72 {"atmega324p", 0x9508, 128, 256, 4, 256},
73 {"atmega324pa", 0x9511, 128, 256, 4, 256},
74 {"atmega644p", 0x960a, 256, 256, 8, 256},
75 {"atmega1284p", 0x9705, 256, 512, 8, 512},
78 /* avr program functions */
79 static int avr_jtag_reset(struct avr_common
*avr
, uint32_t reset
)
81 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_AVR_RESET
);
82 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, reset
, AVR_JTAG_REG_Reset_Len
);
87 static int avr_jtag_read_jtagid(struct avr_common
*avr
, uint32_t *id
)
89 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_IDCODE
);
90 avr_jtag_senddat(avr
->jtag_info
.tap
, id
, 0, AVR_JTAG_REG_JTAGID_Len
);
95 static int avr_jtagprg_enterprogmode(struct avr_common
*avr
)
97 avr_jtag_reset(avr
, 1);
99 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
100 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xA370, AVR_JTAG_REG_ProgrammingEnable_Len
);
105 static int avr_jtagprg_leaveprogmode(struct avr_common
*avr
)
107 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
108 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2300, AVR_JTAG_REG_ProgrammingCommand_Len
);
109 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_ProgrammingCommand_Len
);
111 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
112 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0, AVR_JTAG_REG_ProgrammingEnable_Len
);
114 avr_jtag_reset(avr
, 0);
119 static int avr_jtagprg_chiperase(struct avr_common
*avr
)
123 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
124 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2380, AVR_JTAG_REG_ProgrammingCommand_Len
);
125 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len
);
126 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
127 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
131 avr_jtag_senddat(avr
->jtag_info
.tap
,
134 AVR_JTAG_REG_ProgrammingCommand_Len
);
135 if (ERROR_OK
!= mcu_execute_queue())
137 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
138 } while (!(poll_value
& 0x0200));
143 static int avr_jtagprg_writeflashpage(struct avr_common
*avr
,
144 const uint8_t *page_buf
,
149 uint32_t i
, poll_value
;
151 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
152 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len
);
154 /* load addr high byte */
155 avr_jtag_senddat(avr
->jtag_info
.tap
,
157 0x0700 | ((addr
>> 9) & 0xFF),
158 AVR_JTAG_REG_ProgrammingCommand_Len
);
160 /* load addr low byte */
161 avr_jtag_senddat(avr
->jtag_info
.tap
,
163 0x0300 | ((addr
>> 1) & 0xFF),
164 AVR_JTAG_REG_ProgrammingCommand_Len
);
166 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
168 for (i
= 0; i
< page_size
; i
++) {
170 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
172 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
175 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
177 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
178 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len
);
179 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
180 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
184 avr_jtag_senddat(avr
->jtag_info
.tap
,
187 AVR_JTAG_REG_ProgrammingCommand_Len
);
188 if (ERROR_OK
!= mcu_execute_queue())
190 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
191 } while (!(poll_value
& 0x0200));
196 FLASH_BANK_COMMAND_HANDLER(avrf_flash_bank_command
)
198 struct avrf_flash_bank
*avrf_info
;
201 return ERROR_COMMAND_SYNTAX_ERROR
;
203 avrf_info
= malloc(sizeof(struct avrf_flash_bank
));
204 bank
->driver_priv
= avrf_info
;
206 avrf_info
->probed
= 0;
211 static int avrf_erase(struct flash_bank
*bank
, int first
, int last
)
213 struct target
*target
= bank
->target
;
214 struct avr_common
*avr
= target
->arch_info
;
217 LOG_DEBUG("%s", __func__
);
219 if (target
->state
!= TARGET_HALTED
) {
220 LOG_ERROR("Target not halted");
221 return ERROR_TARGET_NOT_HALTED
;
224 status
= avr_jtagprg_enterprogmode(avr
);
225 if (status
!= ERROR_OK
)
228 status
= avr_jtagprg_chiperase(avr
);
229 if (status
!= ERROR_OK
)
232 return avr_jtagprg_leaveprogmode(avr
);
235 static int avrf_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
237 LOG_INFO("%s", __func__
);
241 static int avrf_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
243 struct target
*target
= bank
->target
;
244 struct avr_common
*avr
= target
->arch_info
;
245 uint32_t cur_size
, cur_buffer_size
, page_size
;
247 if (bank
->target
->state
!= TARGET_HALTED
) {
248 LOG_ERROR("Target not halted");
249 return ERROR_TARGET_NOT_HALTED
;
252 page_size
= bank
->sectors
[0].size
;
253 if ((offset
% page_size
) != 0) {
254 LOG_WARNING("offset 0x%" PRIx32
" breaks required %" PRIu32
"-byte alignment",
257 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
260 LOG_DEBUG("offset is 0x%08" PRIx32
"", offset
);
261 LOG_DEBUG("count is %" PRId32
"", count
);
263 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
268 if (count
> page_size
)
269 cur_buffer_size
= page_size
;
271 cur_buffer_size
= count
;
272 avr_jtagprg_writeflashpage(avr
,
277 count
-= cur_buffer_size
;
278 cur_size
+= cur_buffer_size
;
283 return avr_jtagprg_leaveprogmode(avr
);
286 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
287 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
288 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
290 static int avrf_probe(struct flash_bank
*bank
)
292 struct target
*target
= bank
->target
;
293 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
294 struct avr_common
*avr
= target
->arch_info
;
295 const struct avrf_type
*avr_info
= NULL
;
299 if (bank
->target
->state
!= TARGET_HALTED
) {
300 LOG_ERROR("Target not halted");
301 return ERROR_TARGET_NOT_HALTED
;
304 avrf_info
->probed
= 0;
306 avr_jtag_read_jtagid(avr
, &device_id
);
307 if (ERROR_OK
!= mcu_execute_queue())
310 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
311 if (EXTRACT_MFG(device_id
) != 0x1F)
312 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
313 EXTRACT_MFG(device_id
),
316 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
317 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
318 avr_info
= &avft_chips_info
[i
];
319 LOG_INFO("target device is %s", avr_info
->name
);
324 if (avr_info
!= NULL
) {
327 bank
->sectors
= NULL
;
331 bank
->base
= 0x00000000;
332 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
333 bank
->num_sectors
= avr_info
->flash_page_num
;
334 bank
->sectors
= malloc(sizeof(struct flash_sector
) * avr_info
->flash_page_num
);
336 for (i
= 0; i
< avr_info
->flash_page_num
; i
++) {
337 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
338 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
339 bank
->sectors
[i
].is_erased
= -1;
340 bank
->sectors
[i
].is_protected
= 1;
343 avrf_info
->probed
= 1;
346 /* chip not supported */
347 LOG_ERROR("0x%" PRIx32
" is not support for avr", EXTRACT_PART(device_id
));
349 avrf_info
->probed
= 1;
354 static int avrf_auto_probe(struct flash_bank
*bank
)
356 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
357 if (avrf_info
->probed
)
359 return avrf_probe(bank
);
362 static int avrf_protect_check(struct flash_bank
*bank
)
364 LOG_INFO("%s", __func__
);
368 static int avrf_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
370 struct target
*target
= bank
->target
;
371 struct avr_common
*avr
= target
->arch_info
;
372 const struct avrf_type
*avr_info
= NULL
;
376 if (bank
->target
->state
!= TARGET_HALTED
) {
377 LOG_ERROR("Target not halted");
378 return ERROR_TARGET_NOT_HALTED
;
381 avr_jtag_read_jtagid(avr
, &device_id
);
382 if (ERROR_OK
!= mcu_execute_queue())
385 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
386 if (EXTRACT_MFG(device_id
) != 0x1F)
387 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
388 EXTRACT_MFG(device_id
),
391 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
392 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
393 avr_info
= &avft_chips_info
[i
];
394 LOG_INFO("target device is %s", avr_info
->name
);
400 if (avr_info
!= NULL
) {
402 snprintf(buf
, buf_size
, "%s - Rev: 0x%" PRIx32
"", avr_info
->name
,
403 EXTRACT_VER(device_id
));
406 /* chip not supported */
407 snprintf(buf
, buf_size
, "Cannot identify target as a avr\n");
408 return ERROR_FLASH_OPERATION_FAILED
;
412 static int avrf_mass_erase(struct flash_bank
*bank
)
414 struct target
*target
= bank
->target
;
415 struct avr_common
*avr
= target
->arch_info
;
417 if (target
->state
!= TARGET_HALTED
) {
418 LOG_ERROR("Target not halted");
419 return ERROR_TARGET_NOT_HALTED
;
422 if ((ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
423 || (ERROR_OK
!= avr_jtagprg_chiperase(avr
))
424 || (ERROR_OK
!= avr_jtagprg_leaveprogmode(avr
)))
430 COMMAND_HANDLER(avrf_handle_mass_erase_command
)
435 return ERROR_COMMAND_SYNTAX_ERROR
;
437 struct flash_bank
*bank
;
438 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
439 if (ERROR_OK
!= retval
)
442 if (avrf_mass_erase(bank
) == ERROR_OK
) {
443 /* set all sectors as erased */
444 for (i
= 0; i
< bank
->num_sectors
; i
++)
445 bank
->sectors
[i
].is_erased
= 1;
447 command_print(CMD_CTX
, "avr mass erase complete");
449 command_print(CMD_CTX
, "avr mass erase failed");
451 LOG_DEBUG("%s", __func__
);
455 static const struct command_registration avrf_exec_command_handlers
[] = {
457 .name
= "mass_erase",
459 .handler
= avrf_handle_mass_erase_command
,
460 .mode
= COMMAND_EXEC
,
461 .help
= "erase entire device",
463 COMMAND_REGISTRATION_DONE
465 static const struct command_registration avrf_command_handlers
[] = {
469 .help
= "AVR flash command group",
471 .chain
= avrf_exec_command_handlers
,
473 COMMAND_REGISTRATION_DONE
476 struct flash_driver avr_flash
= {
478 .commands
= avrf_command_handlers
,
479 .flash_bank_command
= avrf_flash_bank_command
,
481 .protect
= avrf_protect
,
483 .read
= default_flash_read
,
485 .auto_probe
= avrf_auto_probe
,
486 .erase_check
= default_flash_blank_check
,
487 .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)