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 const 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 {"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_ProgrammingEnable_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_ProgrammingCommand_Len
);
111 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_ProgrammingCommand_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_ProgrammingEnable_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_ProgrammingCommand_Len
);
127 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len
);
128 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
129 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
133 avr_jtag_senddat(avr
->jtag_info
.tap
,
136 AVR_JTAG_REG_ProgrammingCommand_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 uint8_t *page_buf
,
151 uint32_t i
, poll_value
;
153 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
154 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len
);
156 /* load addr high byte */
157 avr_jtag_senddat(avr
->jtag_info
.tap
,
159 0x0700 | ((addr
>> 9) & 0xFF),
160 AVR_JTAG_REG_ProgrammingCommand_Len
);
162 /* load addr low byte */
163 avr_jtag_senddat(avr
->jtag_info
.tap
,
165 0x0300 | ((addr
>> 1) & 0xFF),
166 AVR_JTAG_REG_ProgrammingCommand_Len
);
168 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
170 for (i
= 0; i
< page_size
; i
++) {
172 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
174 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
177 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
179 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
180 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len
);
181 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
182 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
186 avr_jtag_senddat(avr
->jtag_info
.tap
,
189 AVR_JTAG_REG_ProgrammingCommand_Len
);
190 if (ERROR_OK
!= mcu_execute_queue())
192 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
193 } while (!(poll_value
& 0x0200));
198 FLASH_BANK_COMMAND_HANDLER(avrf_flash_bank_command
)
200 struct avrf_flash_bank
*avrf_info
;
203 return ERROR_COMMAND_SYNTAX_ERROR
;
205 avrf_info
= malloc(sizeof(struct avrf_flash_bank
));
206 bank
->driver_priv
= avrf_info
;
208 avrf_info
->probed
= 0;
213 static int avrf_erase(struct flash_bank
*bank
, int first
, int last
)
215 struct target
*target
= bank
->target
;
216 struct avr_common
*avr
= target
->arch_info
;
219 LOG_DEBUG("%s", __func__
);
221 if (target
->state
!= TARGET_HALTED
) {
222 LOG_ERROR("Target not halted");
223 return ERROR_TARGET_NOT_HALTED
;
226 status
= avr_jtagprg_enterprogmode(avr
);
227 if (status
!= ERROR_OK
)
230 status
= avr_jtagprg_chiperase(avr
);
231 if (status
!= ERROR_OK
)
234 return avr_jtagprg_leaveprogmode(avr
);
237 static int avrf_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
239 LOG_INFO("%s", __func__
);
243 static int avrf_write(struct flash_bank
*bank
, const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
245 struct target
*target
= bank
->target
;
246 struct avr_common
*avr
= target
->arch_info
;
247 uint32_t cur_size
, cur_buffer_size
, page_size
;
249 if (bank
->target
->state
!= TARGET_HALTED
) {
250 LOG_ERROR("Target not halted");
251 return ERROR_TARGET_NOT_HALTED
;
254 page_size
= bank
->sectors
[0].size
;
255 if ((offset
% page_size
) != 0) {
256 LOG_WARNING("offset 0x%" PRIx32
" breaks required %" PRIu32
"-byte alignment",
259 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
262 LOG_DEBUG("offset is 0x%08" PRIx32
"", offset
);
263 LOG_DEBUG("count is %" PRId32
"", count
);
265 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
270 if (count
> page_size
)
271 cur_buffer_size
= page_size
;
273 cur_buffer_size
= count
;
274 avr_jtagprg_writeflashpage(avr
,
279 count
-= cur_buffer_size
;
280 cur_size
+= cur_buffer_size
;
285 return avr_jtagprg_leaveprogmode(avr
);
288 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
289 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
290 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
292 static int avrf_probe(struct flash_bank
*bank
)
294 struct target
*target
= bank
->target
;
295 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
296 struct avr_common
*avr
= target
->arch_info
;
297 const struct avrf_type
*avr_info
= NULL
;
301 if (bank
->target
->state
!= TARGET_HALTED
) {
302 LOG_ERROR("Target not halted");
303 return ERROR_TARGET_NOT_HALTED
;
306 avrf_info
->probed
= 0;
308 avr_jtag_read_jtagid(avr
, &device_id
);
309 if (ERROR_OK
!= mcu_execute_queue())
312 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
313 if (EXTRACT_MFG(device_id
) != 0x1F)
314 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
315 EXTRACT_MFG(device_id
),
318 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
319 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
320 avr_info
= &avft_chips_info
[i
];
321 LOG_INFO("target device is %s", avr_info
->name
);
326 if (avr_info
!= NULL
) {
329 bank
->sectors
= NULL
;
333 bank
->base
= 0x00000000;
334 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
335 bank
->num_sectors
= avr_info
->flash_page_num
;
336 bank
->sectors
= malloc(sizeof(struct flash_sector
) * avr_info
->flash_page_num
);
338 for (i
= 0; i
< avr_info
->flash_page_num
; i
++) {
339 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
340 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
341 bank
->sectors
[i
].is_erased
= -1;
342 bank
->sectors
[i
].is_protected
= 1;
345 avrf_info
->probed
= 1;
348 /* chip not supported */
349 LOG_ERROR("0x%" PRIx32
" is not support for avr", EXTRACT_PART(device_id
));
351 avrf_info
->probed
= 1;
356 static int avrf_auto_probe(struct flash_bank
*bank
)
358 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
359 if (avrf_info
->probed
)
361 return avrf_probe(bank
);
364 static int avrf_protect_check(struct flash_bank
*bank
)
366 LOG_INFO("%s", __func__
);
370 static int avrf_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
372 struct target
*target
= bank
->target
;
373 struct avr_common
*avr
= target
->arch_info
;
374 const struct avrf_type
*avr_info
= NULL
;
378 if (bank
->target
->state
!= TARGET_HALTED
) {
379 LOG_ERROR("Target not halted");
380 return ERROR_TARGET_NOT_HALTED
;
383 avr_jtag_read_jtagid(avr
, &device_id
);
384 if (ERROR_OK
!= mcu_execute_queue())
387 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
388 if (EXTRACT_MFG(device_id
) != 0x1F)
389 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected",
390 EXTRACT_MFG(device_id
),
393 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++) {
394 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
)) {
395 avr_info
= &avft_chips_info
[i
];
396 LOG_INFO("target device is %s", avr_info
->name
);
402 if (avr_info
!= NULL
) {
404 snprintf(buf
, buf_size
, "%s - Rev: 0x%" PRIx32
"", avr_info
->name
,
405 EXTRACT_VER(device_id
));
408 /* chip not supported */
409 snprintf(buf
, buf_size
, "Cannot identify target as a avr\n");
410 return ERROR_FLASH_OPERATION_FAILED
;
414 static int avrf_mass_erase(struct flash_bank
*bank
)
416 struct target
*target
= bank
->target
;
417 struct avr_common
*avr
= target
->arch_info
;
419 if (target
->state
!= TARGET_HALTED
) {
420 LOG_ERROR("Target not halted");
421 return ERROR_TARGET_NOT_HALTED
;
424 if ((ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
425 || (ERROR_OK
!= avr_jtagprg_chiperase(avr
))
426 || (ERROR_OK
!= avr_jtagprg_leaveprogmode(avr
)))
432 COMMAND_HANDLER(avrf_handle_mass_erase_command
)
437 return ERROR_COMMAND_SYNTAX_ERROR
;
439 struct flash_bank
*bank
;
440 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
441 if (ERROR_OK
!= retval
)
444 if (avrf_mass_erase(bank
) == ERROR_OK
) {
445 /* set all sectors as erased */
446 for (i
= 0; i
< bank
->num_sectors
; i
++)
447 bank
->sectors
[i
].is_erased
= 1;
449 command_print(CMD_CTX
, "avr mass erase complete");
451 command_print(CMD_CTX
, "avr mass erase failed");
453 LOG_DEBUG("%s", __func__
);
457 static const struct command_registration avrf_exec_command_handlers
[] = {
459 .name
= "mass_erase",
461 .handler
= avrf_handle_mass_erase_command
,
462 .mode
= COMMAND_EXEC
,
463 .help
= "erase entire device",
465 COMMAND_REGISTRATION_DONE
467 static const struct command_registration avrf_command_handlers
[] = {
471 .help
= "AVR flash command group",
473 .chain
= avrf_exec_command_handlers
,
475 COMMAND_REGISTRATION_DONE
478 struct flash_driver avr_flash
= {
480 .commands
= avrf_command_handlers
,
481 .flash_bank_command
= avrf_flash_bank_command
,
483 .protect
= avrf_protect
,
485 .read
= default_flash_read
,
487 .auto_probe
= avrf_auto_probe
,
488 .erase_check
= default_flash_blank_check
,
489 .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)