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_PROGRAMMING_ENABLE_LEN 16
47 #define AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN 15
48 #define AVR_JTAG_REG_FLASH_DATA_BYTE_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 {"atmega128rfa1", 0xa701, 128, 512, 8, 512},
70 {"atmega256rfr2", 0xa802, 256, 1024, 8, 1024},
71 {"at90can128", 0x9781, 256, 512, 8, 512},
72 {"at90usb128", 0x9782, 256, 512, 8, 512},
73 {"atmega164p", 0x940a, 128, 128, 4, 128},
74 {"atmega324p", 0x9508, 128, 256, 4, 256},
75 {"atmega324pa", 0x9511, 128, 256, 4, 256},
76 {"atmega644p", 0x960a, 256, 256, 8, 256},
77 {"atmega1284p", 0x9705, 256, 512, 8, 512},
80 /* avr program functions */
81 static int avr_jtag_reset(struct avr_common
*avr
, uint32_t reset
)
83 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_AVR_RESET
);
84 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, reset
, AVR_JTAG_REG_RESET_LEN
);
89 static int avr_jtag_read_jtagid(struct avr_common
*avr
, uint32_t *id
)
91 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_IDCODE
);
92 avr_jtag_senddat(avr
->jtag_info
.tap
, id
, 0, AVR_JTAG_REG_JTAGID_LEN
);
97 static int avr_jtagprg_enterprogmode(struct avr_common
*avr
)
99 avr_jtag_reset(avr
, 1);
101 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
102 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xA370, AVR_JTAG_REG_PROGRAMMING_ENABLE_LEN
);
107 static int avr_jtagprg_leaveprogmode(struct avr_common
*avr
)
109 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
110 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2300, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
111 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
113 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
114 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0, AVR_JTAG_REG_PROGRAMMING_ENABLE_LEN
);
116 avr_jtag_reset(avr
, 0);
121 static int avr_jtagprg_chiperase(struct avr_common
*avr
)
125 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
126 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2380, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
127 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
128 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
129 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
133 avr_jtag_senddat(avr
->jtag_info
.tap
,
136 AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
137 if (ERROR_OK
!= mcu_execute_queue())
139 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
140 } while (!(poll_value
& 0x0200));
145 static int avr_jtagprg_writeflashpage(struct avr_common
*avr
,
146 const bool ext_addressing
,
147 const uint8_t *page_buf
,
154 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
155 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
157 /* load extended high byte */
159 avr_jtag_senddat(avr
->jtag_info
.tap
,
161 0x0b00 | ((addr
>> 17) & 0xFF),
162 AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
164 /* load addr high byte */
165 avr_jtag_senddat(avr
->jtag_info
.tap
,
167 0x0700 | ((addr
>> 9) & 0xFF),
168 AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
170 /* load addr low byte */
171 avr_jtag_senddat(avr
->jtag_info
.tap
,
173 0x0300 | ((addr
>> 1) & 0xFF),
174 AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
176 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
178 for (uint32_t i
= 0; i
< page_size
; i
++) {
180 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
182 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
185 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
187 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
188 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
189 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
190 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
194 avr_jtag_senddat(avr
->jtag_info
.tap
,
197 AVR_JTAG_REG_PROGRAMMING_COMMAND_LEN
);
198 if (ERROR_OK
!= mcu_execute_queue())
200 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
201 } while (!(poll_value
& 0x0200));
206 FLASH_BANK_COMMAND_HANDLER(avrf_flash_bank_command
)
208 struct avrf_flash_bank
*avrf_info
;
211 return ERROR_COMMAND_SYNTAX_ERROR
;
213 avrf_info
= malloc(sizeof(struct avrf_flash_bank
));
214 bank
->driver_priv
= avrf_info
;
216 avrf_info
->probed
= false;
221 static int avrf_erase(struct flash_bank
*bank
, unsigned int first
,
224 struct target
*target
= bank
->target
;
225 struct avr_common
*avr
= target
->arch_info
;
228 LOG_DEBUG("%s", __func__
);
230 if (target
->state
!= TARGET_HALTED
) {
231 LOG_ERROR("Target not halted");
232 return ERROR_TARGET_NOT_HALTED
;
235 status
= avr_jtagprg_enterprogmode(avr
);
236 if (status
!= ERROR_OK
)
239 status
= avr_jtagprg_chiperase(avr
);
240 if (status
!= ERROR_OK
)
243 return avr_jtagprg_leaveprogmode(avr
);
246 static int avrf_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
248 struct target
*target
= bank
->target
;
249 struct avr_common
*avr
= target
->arch_info
;
250 uint32_t cur_size
, cur_buffer_size
, page_size
;
253 if (bank
->target
->state
!= TARGET_HALTED
) {
254 LOG_ERROR("Target not halted");
255 return ERROR_TARGET_NOT_HALTED
;
258 page_size
= bank
->sectors
[0].size
;
259 if ((offset
% page_size
) != 0) {
260 LOG_WARNING("offset 0x%" PRIx32
" breaks required %" PRIu32
"-byte alignment",
263 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
266 LOG_DEBUG("offset is 0x%08" PRIx32
"", offset
);
267 LOG_DEBUG("count is %" PRIu32
"", count
);
269 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
272 if (bank
->size
> 0x20000)
273 ext_addressing
= true;
275 ext_addressing
= false;
279 if (count
> page_size
)
280 cur_buffer_size
= page_size
;
282 cur_buffer_size
= count
;
283 avr_jtagprg_writeflashpage(avr
,
289 count
-= cur_buffer_size
;
290 cur_size
+= cur_buffer_size
;
295 return avr_jtagprg_leaveprogmode(avr
);
298 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
299 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
300 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
302 static int avrf_probe(struct flash_bank
*bank
)
304 struct target
*target
= bank
->target
;
305 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
306 struct avr_common
*avr
= target
->arch_info
;
307 const struct avrf_type
*avr_info
= NULL
;
310 if (bank
->target
->state
!= TARGET_HALTED
) {
311 LOG_ERROR("Target not halted");
312 return ERROR_TARGET_NOT_HALTED
;
315 avrf_info
->probed
= false;
317 avr_jtag_read_jtagid(avr
, &device_id
);
318 if (ERROR_OK
!= mcu_execute_queue())
321 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
322 if (EXTRACT_MFG(device_id
) != 0x1F)
323 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
324 EXTRACT_MFG(device_id
),
327 for (size_t i
= 0; i
< ARRAY_SIZE(avft_chips_info
); i
++) {
328 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
329 avr_info
= &avft_chips_info
[i
];
330 LOG_INFO("target device is %s", avr_info
->name
);
335 if (avr_info
!= NULL
) {
339 bank
->base
= 0x00000000;
340 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
341 bank
->num_sectors
= avr_info
->flash_page_num
;
342 bank
->sectors
= malloc(sizeof(struct flash_sector
) * avr_info
->flash_page_num
);
344 for (int i
= 0; i
< avr_info
->flash_page_num
; i
++) {
345 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
346 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
347 bank
->sectors
[i
].is_erased
= -1;
348 bank
->sectors
[i
].is_protected
= -1;
351 avrf_info
->probed
= true;
354 /* chip not supported */
355 LOG_ERROR("0x%" PRIx32
" is not support for avr", EXTRACT_PART(device_id
));
357 avrf_info
->probed
= true;
362 static int avrf_auto_probe(struct flash_bank
*bank
)
364 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
365 if (avrf_info
->probed
)
367 return avrf_probe(bank
);
370 static int avrf_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
372 struct target
*target
= bank
->target
;
373 struct avr_common
*avr
= target
->arch_info
;
374 const 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 (size_t i
= 0; i
< 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 command_print_sameline(cmd
, "%s - Rev: 0x%" PRIx32
"", avr_info
->name
,
404 EXTRACT_VER(device_id
));
407 /* chip not supported */
408 command_print_sameline(cmd
, "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
)
434 return ERROR_COMMAND_SYNTAX_ERROR
;
436 struct flash_bank
*bank
;
437 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
438 if (retval
!= ERROR_OK
)
441 if (avrf_mass_erase(bank
) == ERROR_OK
) {
442 /* set all sectors as erased */
443 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++)
444 bank
->sectors
[i
].is_erased
= 1;
446 command_print(CMD
, "avr mass erase complete");
448 command_print(CMD
, "avr mass erase failed");
450 LOG_DEBUG("%s", __func__
);
454 static const struct command_registration avrf_exec_command_handlers
[] = {
456 .name
= "mass_erase",
458 .handler
= avrf_handle_mass_erase_command
,
459 .mode
= COMMAND_EXEC
,
460 .help
= "erase entire device",
462 COMMAND_REGISTRATION_DONE
464 static const struct command_registration avrf_command_handlers
[] = {
468 .help
= "AVR flash command group",
470 .chain
= avrf_exec_command_handlers
,
472 COMMAND_REGISTRATION_DONE
475 const struct flash_driver avr_flash
= {
477 .commands
= avrf_command_handlers
,
478 .flash_bank_command
= avrf_flash_bank_command
,
481 .read
= default_flash_read
,
483 .auto_probe
= avrf_auto_probe
,
484 .erase_check
= default_flash_blank_check
,
486 .free_driver_priv
= default_flash_free_driver_priv
,
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)