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 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
25 #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
62 struct avrf_flash_bank
68 static struct avrf_type avft_chips_info
[] =
70 /* name, chip_id, flash_page_size, flash_page_num,
71 * eeprom_page_size, eeprom_page_num
73 {"atmega128", 0x9702, 256, 512, 8, 512},
74 {"at90can128", 0x9781, 256, 512, 8, 512},
77 /* avr program functions */
78 static int avr_jtag_reset(struct avr_common
*avr
, uint32_t reset
)
80 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_AVR_RESET
);
81 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, reset
,AVR_JTAG_REG_Reset_Len
);
86 static int avr_jtag_read_jtagid(struct avr_common
*avr
, uint32_t *id
)
88 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_IDCODE
);
89 avr_jtag_senddat(avr
->jtag_info
.tap
, id
, 0, AVR_JTAG_REG_JTAGID_Len
);
94 static int avr_jtagprg_enterprogmode(struct avr_common
*avr
)
96 avr_jtag_reset(avr
, 1);
98 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
99 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xA370, AVR_JTAG_REG_ProgrammingEnable_Len
);
104 static int avr_jtagprg_leaveprogmode(struct avr_common
*avr
)
106 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
107 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2300, AVR_JTAG_REG_ProgrammingCommand_Len
);
108 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_ProgrammingCommand_Len
);
110 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
111 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0, AVR_JTAG_REG_ProgrammingEnable_Len
);
113 avr_jtag_reset(avr
, 0);
118 static int avr_jtagprg_chiperase(struct avr_common
*avr
)
122 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
123 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2380, AVR_JTAG_REG_ProgrammingCommand_Len
);
124 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len
);
125 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
126 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
130 avr_jtag_senddat(avr
->jtag_info
.tap
, &poll_value
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
131 if (ERROR_OK
!= mcu_execute_queue())
135 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
136 } while (!(poll_value
& 0x0200));
141 static int avr_jtagprg_writeflashpage(struct avr_common
*avr
, uint8_t *page_buf
, uint32_t buf_size
, uint32_t addr
, uint32_t page_size
)
143 uint32_t i
, poll_value
;
145 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
146 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len
);
148 // load addr high byte
149 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x0700 | ((addr
>> 9) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len
);
151 // load addr low byte
152 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x0300 | ((addr
>> 1) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len
);
154 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
156 for (i
= 0; i
< page_size
; i
++)
160 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
164 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
168 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
170 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
171 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len
);
172 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
173 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
177 avr_jtag_senddat(avr
->jtag_info
.tap
, &poll_value
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
178 if (ERROR_OK
!= mcu_execute_queue())
182 LOG_DEBUG("poll_value = 0x%04" PRIx32
"", poll_value
);
183 } while (!(poll_value
& 0x0200));
188 FLASH_BANK_COMMAND_HANDLER(avrf_flash_bank_command
)
190 struct avrf_flash_bank
*avrf_info
;
194 return ERROR_COMMAND_SYNTAX_ERROR
;
197 avrf_info
= malloc(sizeof(struct avrf_flash_bank
));
198 bank
->driver_priv
= avrf_info
;
200 avrf_info
->probed
= 0;
205 static int avrf_erase(struct flash_bank
*bank
, int first
, int last
)
207 struct target
*target
= bank
->target
;
208 struct avr_common
*avr
= target
->arch_info
;
211 LOG_DEBUG("%s", __FUNCTION__
);
213 if (target
->state
!= TARGET_HALTED
)
215 LOG_ERROR("Target not halted");
216 return ERROR_TARGET_NOT_HALTED
;
219 status
= avr_jtagprg_enterprogmode(avr
);
220 if (status
!= ERROR_OK
)
223 status
= avr_jtagprg_chiperase(avr
);
224 if (status
!= ERROR_OK
)
227 return avr_jtagprg_leaveprogmode(avr
);
230 static int avrf_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
232 LOG_INFO("%s", __FUNCTION__
);
236 static int avrf_write(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
238 struct target
*target
= bank
->target
;
239 struct avr_common
*avr
= target
->arch_info
;
240 uint32_t cur_size
, cur_buffer_size
, page_size
;
242 if (bank
->target
->state
!= TARGET_HALTED
)
244 LOG_ERROR("Target not halted");
245 return ERROR_TARGET_NOT_HALTED
;
248 page_size
= bank
->sectors
[0].size
;
249 if ((offset
% page_size
) != 0)
251 LOG_WARNING("offset 0x%" PRIx32
" breaks required %" PRIu32
"-byte alignment", offset
, page_size
);
252 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
255 LOG_DEBUG("offset is 0x%08" PRIx32
"", offset
);
256 LOG_DEBUG("count is %" PRId32
"", count
);
258 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
266 if (count
> page_size
)
268 cur_buffer_size
= page_size
;
272 cur_buffer_size
= count
;
274 avr_jtagprg_writeflashpage(avr
, buffer
+ cur_size
, cur_buffer_size
, offset
+ cur_size
, page_size
);
275 count
-= cur_buffer_size
;
276 cur_size
+= cur_buffer_size
;
281 return avr_jtagprg_leaveprogmode(avr
);
284 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
285 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
286 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
287 static int avrf_probe(struct flash_bank
*bank
)
289 struct target
*target
= bank
->target
;
290 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
291 struct avr_common
*avr
= target
->arch_info
;
292 struct avrf_type
*avr_info
= NULL
;
296 if (bank
->target
->state
!= TARGET_HALTED
)
298 LOG_ERROR("Target not halted");
299 return ERROR_TARGET_NOT_HALTED
;
302 avrf_info
->probed
= 0;
304 avr_jtag_read_jtagid(avr
, &device_id
);
305 if (ERROR_OK
!= mcu_execute_queue())
310 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
311 if (EXTRACT_MFG(device_id
) != 0x1F)
313 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id
), 0x1F);
316 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++)
318 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
)
331 bank
->sectors
= NULL
;
335 bank
->base
= 0x00000000;
336 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
337 bank
->num_sectors
= avr_info
->flash_page_num
;
338 bank
->sectors
= malloc(sizeof(struct flash_sector
) * avr_info
->flash_page_num
);
340 for (i
= 0; i
< avr_info
->flash_page_num
; i
++)
342 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
343 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
344 bank
->sectors
[i
].is_erased
= -1;
345 bank
->sectors
[i
].is_protected
= 1;
348 avrf_info
->probed
= 1;
353 // chip not supported
354 LOG_ERROR("0x%" PRIx32
" is not support for avr", EXTRACT_PART(device_id
));
356 avrf_info
->probed
= 1;
361 static int avrf_auto_probe(struct flash_bank
*bank
)
363 struct avrf_flash_bank
*avrf_info
= bank
->driver_priv
;
364 if (avrf_info
->probed
)
366 return avrf_probe(bank
);
369 static int avrf_protect_check(struct flash_bank
*bank
)
371 LOG_INFO("%s", __FUNCTION__
);
375 static int avrf_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
377 struct target
*target
= bank
->target
;
378 struct avr_common
*avr
= target
->arch_info
;
379 struct avrf_type
*avr_info
= NULL
;
383 if (bank
->target
->state
!= TARGET_HALTED
)
385 LOG_ERROR("Target not halted");
386 return ERROR_TARGET_NOT_HALTED
;
389 avr_jtag_read_jtagid(avr
, &device_id
);
390 if (ERROR_OK
!= mcu_execute_queue())
395 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
396 if (EXTRACT_MFG(device_id
) != 0x1F)
398 LOG_ERROR("0x%" PRIx32
" is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id
), 0x1F);
401 for (i
= 0; i
< (int)ARRAY_SIZE(avft_chips_info
); i
++)
403 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
))
405 avr_info
= &avft_chips_info
[i
];
406 LOG_INFO("target device is %s", avr_info
->name
);
412 if (avr_info
!= NULL
)
415 snprintf(buf
, buf_size
, "%s - Rev: 0x%" PRIx32
"", avr_info
->name
, EXTRACT_VER(device_id
));
420 // chip not supported
421 snprintf(buf
, buf_size
, "Cannot identify target as a avr\n");
422 return ERROR_FLASH_OPERATION_FAILED
;
426 static int avrf_mass_erase(struct flash_bank
*bank
)
428 struct target
*target
= bank
->target
;
429 struct avr_common
*avr
= target
->arch_info
;
431 if (target
->state
!= TARGET_HALTED
)
433 LOG_ERROR("Target not halted");
434 return ERROR_TARGET_NOT_HALTED
;
437 if ((ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
438 || (ERROR_OK
!= avr_jtagprg_chiperase(avr
))
439 || (ERROR_OK
!= avr_jtagprg_leaveprogmode(avr
)))
447 COMMAND_HANDLER(avrf_handle_mass_erase_command
)
453 return ERROR_COMMAND_SYNTAX_ERROR
;
456 struct flash_bank
*bank
;
457 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
458 if (ERROR_OK
!= retval
)
461 if (avrf_mass_erase(bank
) == ERROR_OK
)
463 /* set all sectors as erased */
464 for (i
= 0; i
< bank
->num_sectors
; i
++)
466 bank
->sectors
[i
].is_erased
= 1;
469 command_print(CMD_CTX
, "avr mass erase complete");
473 command_print(CMD_CTX
, "avr mass erase failed");
476 LOG_DEBUG("%s", __FUNCTION__
);
480 static const struct command_registration avrf_exec_command_handlers
[] = {
482 .name
= "mass_erase",
484 .handler
= avrf_handle_mass_erase_command
,
485 .mode
= COMMAND_EXEC
,
486 .help
= "erase entire device",
488 COMMAND_REGISTRATION_DONE
490 static const struct command_registration avrf_command_handlers
[] = {
494 .help
= "AVR flash command group",
495 .chain
= avrf_exec_command_handlers
,
497 COMMAND_REGISTRATION_DONE
500 struct flash_driver avr_flash
= {
502 .commands
= avrf_command_handlers
,
503 .flash_bank_command
= avrf_flash_bank_command
,
505 .protect
= avrf_protect
,
507 .read
= default_flash_read
,
509 .auto_probe
= avrf_auto_probe
,
510 .erase_check
= default_flash_mem_blank_check
,
511 .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)