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 ***************************************************************************/
24 #include "replacements.h"
31 #include "algorithm.h"
32 #include "binarybuffer.h"
37 /* AVR_JTAG_Instructions */
38 #define AVR_JTAG_INS_LEN 4
39 // Public Instructions:
40 #define AVR_JTAG_INS_EXTEST 0x00
41 #define AVR_JTAG_INS_IDCODE 0x01
42 #define AVR_JTAG_INS_SAMPLE_PRELOAD 0x02
43 #define AVR_JTAG_INS_BYPASS 0x0F
44 // AVR Specified Public Instructions:
45 #define AVR_JTAG_INS_AVR_RESET 0x0C
46 #define AVR_JTAG_INS_PROG_ENABLE 0x04
47 #define AVR_JTAG_INS_PROG_COMMANDS 0x05
48 #define AVR_JTAG_INS_PROG_PAGELOAD 0x06
49 #define AVR_JTAG_INS_PROG_PAGEREAD 0x07
52 #define AVR_JTAG_REG_Bypass_Len 1
53 #define AVR_JTAG_REG_DeviceID_Len 32
55 #define AVR_JTAG_REG_Reset_Len 1
56 #define AVR_JTAG_REG_JTAGID_Len 32
57 #define AVR_JTAG_REG_ProgrammingEnable_Len 16
58 #define AVR_JTAG_REG_ProgrammingCommand_Len 15
59 #define AVR_JTAG_REG_FlashDataByte_Len 16
61 avrf_type_t avft_chips_info
[] =
63 // name, chip_id, flash_page_size, flash_page_num, eeprom_page_size, eeprom_page_num
64 {"atmega128", 0x9702, 256, 512, 8, 512},
67 static int avrf_register_commands(struct command_context_s
*cmd_ctx
);
68 static int avrf_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
);
69 static int avrf_erase(struct flash_bank_s
*bank
, int first
, int last
);
70 static int avrf_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
);
71 static int avrf_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
);
72 static int avrf_probe(struct flash_bank_s
*bank
);
73 static int avrf_auto_probe(struct flash_bank_s
*bank
);
74 //static int avrf_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 static int avrf_protect_check(struct flash_bank_s
*bank
);
76 static int avrf_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
);
78 static int avrf_handle_mass_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
80 extern int avr_jtag_sendinstr(jtag_tap_t
*tap
, u8
*ir_in
, u8 ir_out
);
81 extern int avr_jtag_senddat(jtag_tap_t
*tap
, u32
*dr_in
, u32 dr_out
, int len
);
83 extern int mcu_write_ir(jtag_tap_t
*tap
, u8
*ir_in
, u8
*ir_out
, int ir_len
, int rti
);
84 extern int mcu_write_dr(jtag_tap_t
*tap
, u8
*ir_in
, u8
*ir_out
, int dr_len
, int rti
);
85 extern int mcu_write_ir_u8(jtag_tap_t
*tap
, u8
*ir_in
, u8 ir_out
, int ir_len
, int rti
);
86 extern int mcu_write_dr_u8(jtag_tap_t
*tap
, u8
*ir_in
, u8 ir_out
, int dr_len
, int rti
);
87 extern int mcu_write_ir_u16(jtag_tap_t
*tap
, u16
*ir_in
, u16 ir_out
, int ir_len
, int rti
);
88 extern int mcu_write_dr_u16(jtag_tap_t
*tap
, u16
*ir_in
, u16 ir_out
, int dr_len
, int rti
);
89 extern int mcu_write_ir_u32(jtag_tap_t
*tap
, u32
*ir_in
, u32 ir_out
, int ir_len
, int rti
);
90 extern int mcu_write_dr_u32(jtag_tap_t
*tap
, u32
*ir_in
, u32 ir_out
, int dr_len
, int rti
);
91 extern int mcu_execute_queue(void);
93 flash_driver_t avr_flash
=
96 .register_commands
= avrf_register_commands
,
97 .flash_bank_command
= avrf_flash_bank_command
,
99 .protect
= avrf_protect
,
102 .auto_probe
= avrf_auto_probe
,
103 .erase_check
= default_flash_mem_blank_check
,
104 .protect_check
= avrf_protect_check
,
108 /* avr program functions */
109 static int avr_jtag_reset(avr_common_t
*avr
, u32 reset
)
111 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_AVR_RESET
);
112 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, reset
,AVR_JTAG_REG_Reset_Len
);
117 static int avr_jtag_read_jtagid(avr_common_t
*avr
, u32
*id
)
119 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_IDCODE
);
120 avr_jtag_senddat(avr
->jtag_info
.tap
, id
, 0, AVR_JTAG_REG_JTAGID_Len
);
125 static int avr_jtagprg_enterprogmode(avr_common_t
*avr
)
127 avr_jtag_reset(avr
, 1);
129 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
130 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xA370, AVR_JTAG_REG_ProgrammingEnable_Len
);
135 static int avr_jtagprg_leaveprogmode(avr_common_t
*avr
)
137 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
138 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2300, AVR_JTAG_REG_ProgrammingCommand_Len
);
139 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3300, AVR_JTAG_REG_ProgrammingCommand_Len
);
141 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_ENABLE
);
142 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0, AVR_JTAG_REG_ProgrammingEnable_Len
);
144 avr_jtag_reset(avr
, 0);
149 static int avr_jtagprg_chiperase(avr_common_t
*avr
)
153 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
154 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2380, AVR_JTAG_REG_ProgrammingCommand_Len
);
155 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len
);
156 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
157 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
161 avr_jtag_senddat(avr
->jtag_info
.tap
, &poll_value
, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len
);
162 if (ERROR_OK
!= mcu_execute_queue())
166 LOG_DEBUG("poll_value = 0x%04X", poll_value
);
167 }while(!(poll_value
& 0x0200));
172 static int avr_jtagprg_writeflashpage(avr_common_t
*avr
, u8
*page_buf
, u32 buf_size
, u32 addr
, u32 page_size
)
176 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
177 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len
);
179 // load addr high byte
180 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x0700 | ((addr
>> 9) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len
);
182 // load addr low byte
183 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x0300 | ((addr
>> 1) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len
);
185 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_PAGELOAD
);
187 for (i
= 0; i
< page_size
; i
++)
191 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, page_buf
[i
], 8);
195 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0xFF, 8);
199 avr_jtag_sendinstr(avr
->jtag_info
.tap
, NULL
, AVR_JTAG_INS_PROG_COMMANDS
);
201 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
202 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len
);
203 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
204 avr_jtag_senddat(avr
->jtag_info
.tap
, NULL
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
208 avr_jtag_senddat(avr
->jtag_info
.tap
, &poll_value
, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len
);
209 if (ERROR_OK
!= mcu_execute_queue())
213 LOG_DEBUG("poll_value = 0x%04X", poll_value
);
214 }while(!(poll_value
& 0x0200));
219 /* interface command */
220 static int avrf_register_commands(struct command_context_s
*cmd_ctx
)
222 command_t
*avr_cmd
= register_command(cmd_ctx
, NULL
, "avr", NULL
, COMMAND_ANY
, "avr flash specific commands");
224 register_command(cmd_ctx
, avr_cmd
, "mass_erase", avrf_handle_mass_erase_command
, COMMAND_EXEC
,
225 "mass erase device");
230 static int avrf_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
, struct flash_bank_s
*bank
)
232 avrf_flash_bank_t
*avrf_info
;
236 LOG_WARNING("incomplete flash_bank avr configuration");
237 return ERROR_FLASH_BANK_INVALID
;
240 avrf_info
= malloc(sizeof(avrf_flash_bank_t
));
241 bank
->driver_priv
= avrf_info
;
243 avrf_info
->probed
= 0;
248 static int avrf_erase(struct flash_bank_s
*bank
, int first
, int last
)
250 LOG_INFO("%s", __FUNCTION__
);
254 static int avrf_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
256 LOG_INFO("%s", __FUNCTION__
);
260 static int avrf_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
262 target_t
*target
= bank
->target
;
263 avr_common_t
*avr
= target
->arch_info
;
264 u32 cur_size
, cur_buffer_size
, page_size
;
266 if (bank
->target
->state
!= TARGET_HALTED
)
268 LOG_ERROR("Target not halted");
269 return ERROR_TARGET_NOT_HALTED
;
272 page_size
= bank
->sectors
[0].size
;
273 if ((offset
% page_size
) != 0)
275 LOG_WARNING("offset 0x%x breaks required %d-byte alignment", offset
, page_size
);
276 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
279 LOG_DEBUG("offset is 0x%08X", offset
);
280 LOG_DEBUG("count is %d", count
);
282 if (ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
290 if (count
> page_size
)
292 cur_buffer_size
= page_size
;
296 cur_buffer_size
= count
;
298 avr_jtagprg_writeflashpage(avr
, buffer
+ cur_size
, cur_buffer_size
, offset
+ cur_size
, page_size
);
299 count
-= cur_buffer_size
;
300 cur_size
+= cur_buffer_size
;
305 return avr_jtagprg_leaveprogmode(avr
);
308 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
309 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
310 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
311 static int avrf_probe(struct flash_bank_s
*bank
)
313 target_t
*target
= bank
->target
;
314 avrf_flash_bank_t
*avrf_info
= bank
->driver_priv
;
315 avr_common_t
*avr
= target
->arch_info
;
316 avrf_type_t
*avr_info
= NULL
;
320 if (bank
->target
->state
!= TARGET_HALTED
)
322 LOG_ERROR("Target not halted");
323 return ERROR_TARGET_NOT_HALTED
;
326 avrf_info
->probed
= 0;
328 avr_jtag_read_jtagid(avr
, &device_id
);
329 if (ERROR_OK
!= mcu_execute_queue())
334 LOG_INFO( "device id = 0x%08x", device_id
);
335 if (EXTRACT_MFG(device_id
) != 0x1F)
337 LOG_ERROR("0x%X is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id
), 0x1F);
340 for (i
= 0; i
< (int)(sizeof(avft_chips_info
) / sizeof(avft_chips_info
[0])); i
++)
342 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
))
344 avr_info
= &avft_chips_info
[i
];
345 LOG_INFO("target device is %s", avr_info
->name
);
350 if (avr_info
!= NULL
)
353 bank
->base
= 0x00000000;
354 bank
->size
= (avr_info
->flash_page_size
* avr_info
->flash_page_num
);
355 bank
->num_sectors
= avr_info
->flash_page_num
;
356 bank
->sectors
= malloc(sizeof(flash_sector_t
) * avr_info
->flash_page_num
);
358 for (i
= 0; i
< avr_info
->flash_page_num
; i
++)
360 bank
->sectors
[i
].offset
= i
* avr_info
->flash_page_size
;
361 bank
->sectors
[i
].size
= avr_info
->flash_page_size
;
362 bank
->sectors
[i
].is_erased
= -1;
363 bank
->sectors
[i
].is_protected
= 1;
366 avrf_info
->probed
= 1;
371 // chip not supported
372 LOG_ERROR("0x%X is not support for avr", EXTRACT_PART(device_id
));
374 avrf_info
->probed
= 1;
379 static int avrf_auto_probe(struct flash_bank_s
*bank
)
381 avrf_flash_bank_t
*avrf_info
= bank
->driver_priv
;
382 if (avrf_info
->probed
)
384 return avrf_probe(bank
);
387 static int avrf_protect_check(struct flash_bank_s
*bank
)
389 LOG_INFO("%s", __FUNCTION__
);
393 static int avrf_info(struct flash_bank_s
*bank
, char *buf
, int buf_size
)
395 target_t
*target
= bank
->target
;
396 avr_common_t
*avr
= target
->arch_info
;
397 avrf_type_t
*avr_info
= NULL
;
401 if (bank
->target
->state
!= TARGET_HALTED
)
403 LOG_ERROR("Target not halted");
404 return ERROR_TARGET_NOT_HALTED
;
407 avr_jtag_read_jtagid(avr
, &device_id
);
408 if (ERROR_OK
!= mcu_execute_queue())
413 LOG_INFO( "device id = 0x%08x", device_id
);
414 if (EXTRACT_MFG(device_id
) != 0x1F)
416 LOG_ERROR("0x%X is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id
), 0x1F);
419 for (i
= 0; i
< (int)(sizeof(avft_chips_info
) / sizeof(avft_chips_info
[0])); i
++)
421 if (avft_chips_info
[i
].chip_id
== EXTRACT_PART(device_id
))
423 avr_info
= &avft_chips_info
[i
];
424 LOG_INFO("target device is %s", avr_info
->name
);
430 if (avr_info
!= NULL
)
433 snprintf(buf
, buf_size
, "%s - Rev: 0x%X", avr_info
->name
, EXTRACT_VER(device_id
));
438 // chip not supported
439 snprintf(buf
, buf_size
, "Cannot identify target as a avr\n");
440 return ERROR_FLASH_OPERATION_FAILED
;
444 static int avrf_mass_erase(struct flash_bank_s
*bank
)
446 target_t
*target
= bank
->target
;
447 avr_common_t
*avr
= target
->arch_info
;
449 if (target
->state
!= TARGET_HALTED
)
451 LOG_ERROR("Target not halted");
452 return ERROR_TARGET_NOT_HALTED
;
455 if ((ERROR_OK
!= avr_jtagprg_enterprogmode(avr
))
456 || (ERROR_OK
!= avr_jtagprg_chiperase(avr
))
457 || (ERROR_OK
!= avr_jtagprg_leaveprogmode(avr
)))
465 static int avrf_handle_mass_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
472 command_print(cmd_ctx
, "avr mass_erase <bank>");
476 bank
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
479 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
483 if (avrf_mass_erase(bank
) == ERROR_OK
)
485 /* set all sectors as erased */
486 for (i
= 0; i
< bank
->num_sectors
; i
++)
488 bank
->sectors
[i
].is_erased
= 1;
491 command_print(cmd_ctx
, "avr mass erase complete");
495 command_print(cmd_ctx
, "avr mass erase failed");
498 LOG_DEBUG("%s", __FUNCTION__
);
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)