1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * LPC1700 support Copyright (C) 2009 by Audrius Urmanavicius *
6 * didele.deze@gmail.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
29 #include <helper/binarybuffer.h>
30 #include <target/algorithm.h>
31 #include <target/arm_opcodes.h>
32 #include <target/armv7m.h>
37 * flash programming support for NXP LPC17xx and LPC2xxx devices.
39 * @todo Provide a way to update CCLK after declaring the flash bank.
40 * The value which is correct after chip reset will rarely still work
41 * right after the clocks switch to use the PLL (e.g. 4MHz --> 100 MHz).
44 * currently supported devices:
45 * variant 1 (lpc2000_v1):
53 * variant 2 (lpc2000_v2):
62 * - 176x (tested with LPC1768)
72 struct lpc2000_flash_bank
74 lpc2000_variant variant
;
75 struct working_area
*iap_working_area
;
77 int cmd51_dst_boundary
;
81 uint32_t cmd51_max_buffer
;
85 enum lpc2000_status_codes
87 LPC2000_CMD_SUCCESS
= 0,
88 LPC2000_INVALID_COMMAND
= 1,
89 LPC2000_SRC_ADDR_ERROR
= 2,
90 LPC2000_DST_ADDR_ERROR
= 3,
91 LPC2000_SRC_ADDR_NOT_MAPPED
= 4,
92 LPC2000_DST_ADDR_NOT_MAPPED
= 5,
93 LPC2000_COUNT_ERROR
= 6,
94 LPC2000_INVALID_SECTOR
= 7,
95 LPC2000_SECTOR_NOT_BLANK
= 8,
96 LPC2000_SECTOR_NOT_PREPARED
= 9,
97 LPC2000_COMPARE_ERROR
= 10,
99 LPC2000_PARAM_ERROR
= 12,
100 LPC2000_ADDR_ERROR
= 13,
101 LPC2000_ADDR_NOT_MAPPED
= 14,
102 LPC2000_CMD_NOT_LOCKED
= 15,
103 LPC2000_INVALID_CODE
= 16,
104 LPC2000_INVALID_BAUD_RATE
= 17,
105 LPC2000_INVALID_STOP_BIT
= 18,
106 LPC2000_CRP_ENABLED
= 19
110 static int lpc2000_build_sector_list(struct flash_bank
*bank
)
112 struct lpc2000_flash_bank
*lpc2000_info
= bank
->driver_priv
;
116 /* default to a 4096 write buffer */
117 lpc2000_info
->cmd51_max_buffer
= 4096;
119 if (lpc2000_info
->variant
== lpc2000_v1
)
121 /* variant 1 has different layout for 128kb and 256kb flashes */
122 if (bank
->size
== 128 * 1024)
124 bank
->num_sectors
= 16;
125 bank
->sectors
= malloc(sizeof(struct flash_sector
) * 16);
126 for (i
= 0; i
< 16; i
++)
128 bank
->sectors
[i
].offset
= offset
;
129 bank
->sectors
[i
].size
= 8 * 1024;
130 offset
+= bank
->sectors
[i
].size
;
131 bank
->sectors
[i
].is_erased
= -1;
132 bank
->sectors
[i
].is_protected
= 1;
135 else if (bank
->size
== 256 * 1024)
137 bank
->num_sectors
= 18;
138 bank
->sectors
= malloc(sizeof(struct flash_sector
) * 18);
140 for (i
= 0; i
< 8; i
++)
142 bank
->sectors
[i
].offset
= offset
;
143 bank
->sectors
[i
].size
= 8 * 1024;
144 offset
+= bank
->sectors
[i
].size
;
145 bank
->sectors
[i
].is_erased
= -1;
146 bank
->sectors
[i
].is_protected
= 1;
148 for (i
= 8; i
< 10; i
++)
150 bank
->sectors
[i
].offset
= offset
;
151 bank
->sectors
[i
].size
= 64 * 1024;
152 offset
+= bank
->sectors
[i
].size
;
153 bank
->sectors
[i
].is_erased
= -1;
154 bank
->sectors
[i
].is_protected
= 1;
156 for (i
= 10; i
< 18; i
++)
158 bank
->sectors
[i
].offset
= offset
;
159 bank
->sectors
[i
].size
= 8 * 1024;
160 offset
+= bank
->sectors
[i
].size
;
161 bank
->sectors
[i
].is_erased
= -1;
162 bank
->sectors
[i
].is_protected
= 1;
167 LOG_ERROR("BUG: unknown bank->size encountered");
171 else if (lpc2000_info
->variant
== lpc2000_v2
)
173 /* variant 2 has a uniform layout, only number of sectors differs */
177 lpc2000_info
->cmd51_max_buffer
= 1024;
178 bank
->num_sectors
= 1;
181 lpc2000_info
->cmd51_max_buffer
= 1024;
182 bank
->num_sectors
= 2;
185 bank
->num_sectors
= 4;
188 bank
->num_sectors
= 8;
191 bank
->num_sectors
= 9;
194 bank
->num_sectors
= 11;
197 bank
->num_sectors
= 15;
200 bank
->num_sectors
= 27;
204 bank
->num_sectors
= 28;
207 LOG_ERROR("BUG: unknown bank->size encountered");
212 bank
->sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
214 for (i
= 0; i
< bank
->num_sectors
; i
++)
218 bank
->sectors
[i
].offset
= offset
;
219 bank
->sectors
[i
].size
= 4 * 1024;
220 offset
+= bank
->sectors
[i
].size
;
221 bank
->sectors
[i
].is_erased
= -1;
222 bank
->sectors
[i
].is_protected
= 1;
226 bank
->sectors
[i
].offset
= offset
;
227 bank
->sectors
[i
].size
= 32 * 1024;
228 offset
+= bank
->sectors
[i
].size
;
229 bank
->sectors
[i
].is_erased
= -1;
230 bank
->sectors
[i
].is_protected
= 1;
234 bank
->sectors
[i
].offset
= offset
;
235 bank
->sectors
[i
].size
= 4 * 1024;
236 offset
+= bank
->sectors
[i
].size
;
237 bank
->sectors
[i
].is_erased
= -1;
238 bank
->sectors
[i
].is_protected
= 1;
242 else if (lpc2000_info
->variant
== lpc1700
)
247 bank
->num_sectors
= 8;
250 bank
->num_sectors
= 16;
253 bank
->num_sectors
= 18;
256 bank
->num_sectors
= 22;
259 bank
->num_sectors
= 30;
262 LOG_ERROR("BUG: unknown bank->size encountered");
266 bank
->sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
268 for(i
= 0; i
< bank
->num_sectors
; i
++)
270 bank
->sectors
[i
].offset
= offset
;
271 /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx devices */
272 bank
->sectors
[i
].size
= (i
< 16)? 4 * 1024 : 32 * 1024;
273 offset
+= bank
->sectors
[i
].size
;
274 bank
->sectors
[i
].is_erased
= -1;
275 bank
->sectors
[i
].is_protected
= 1;
280 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
287 /* call LPC1700/LPC2000 IAP function
288 * uses 180 bytes working area
289 * 0x0 to 0x7: jump gate (BX to thumb state, b -2 to wait)
290 * 0x8 to 0x1f: command parameter table (1+5 words)
291 * 0x20 to 0x33: command result table (1+4 words)
292 * 0x34 to 0xb3: stack (only 128b needed)
294 static int lpc2000_iap_call(struct flash_bank
*bank
, int code
, uint32_t param_table
[5], uint32_t result_table
[4])
297 struct lpc2000_flash_bank
*lpc2000_info
= bank
->driver_priv
;
298 struct target
*target
= bank
->target
;
299 struct mem_param mem_params
[2];
300 struct reg_param reg_params
[5];
301 struct arm_algorithm armv4_5_info
; /* for LPC2000 */
302 struct armv7m_algorithm armv7m_info
; /* for LPC1700 */
303 uint32_t status_code
;
304 uint32_t iap_entry_point
= 0; /* to make compiler happier */
306 /* regrab previously allocated working_area, or allocate a new one */
307 if (!lpc2000_info
->iap_working_area
)
309 uint8_t jump_gate
[8];
311 /* make sure we have a working area */
312 if (target_alloc_working_area(target
, 180, &lpc2000_info
->iap_working_area
) != ERROR_OK
)
314 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
315 return ERROR_FLASH_OPERATION_FAILED
;
318 /* write IAP code to working area */
319 switch(lpc2000_info
->variant
)
322 target_buffer_set_u32(target
, jump_gate
,
324 target_buffer_set_u32(target
, jump_gate
+ 4,
329 target_buffer_set_u32(target
, jump_gate
, ARMV4_5_BX(12));
330 target_buffer_set_u32(target
, jump_gate
+ 4, ARMV4_5_B(0xfffffe, 0));
333 LOG_ERROR("BUG: unknown bank->size encountered");
337 if ((retval
= target_write_memory(target
, lpc2000_info
->iap_working_area
->address
, 4, 2, jump_gate
)) != ERROR_OK
)
339 LOG_ERROR("Write memory at address 0x%8.8" PRIx32
" failed (check work_area definition)", lpc2000_info
->iap_working_area
->address
);
344 switch(lpc2000_info
->variant
)
347 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
348 armv7m_info
.core_mode
= ARMV7M_MODE_ANY
;
349 iap_entry_point
= 0x1fff1ff1;
353 armv4_5_info
.common_magic
= ARM_COMMON_MAGIC
;
354 armv4_5_info
.core_mode
= ARM_MODE_SVC
;
355 armv4_5_info
.core_state
= ARM_STATE_ARM
;
356 iap_entry_point
= 0x7ffffff1;
359 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
363 /* command parameter table */
364 init_mem_param(&mem_params
[0], lpc2000_info
->iap_working_area
->address
+ 8, 6 * 4, PARAM_OUT
);
365 target_buffer_set_u32(target
, mem_params
[0].value
, code
);
366 target_buffer_set_u32(target
, mem_params
[0].value
+ 0x04, param_table
[0]);
367 target_buffer_set_u32(target
, mem_params
[0].value
+ 0x08, param_table
[1]);
368 target_buffer_set_u32(target
, mem_params
[0].value
+ 0x0c, param_table
[2]);
369 target_buffer_set_u32(target
, mem_params
[0].value
+ 0x10, param_table
[3]);
370 target_buffer_set_u32(target
, mem_params
[0].value
+ 0x14, param_table
[4]);
372 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
373 buf_set_u32(reg_params
[0].value
, 0, 32, lpc2000_info
->iap_working_area
->address
+ 0x08);
375 /* command result table */
376 init_mem_param(&mem_params
[1], lpc2000_info
->iap_working_area
->address
+ 0x20, 5 * 4, PARAM_IN
);
378 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
379 buf_set_u32(reg_params
[1].value
, 0, 32, lpc2000_info
->iap_working_area
->address
+ 0x20);
381 /* IAP entry point */
382 init_reg_param(®_params
[2], "r12", 32, PARAM_OUT
);
383 buf_set_u32(reg_params
[2].value
, 0, 32, iap_entry_point
);
385 switch(lpc2000_info
->variant
)
389 init_reg_param(®_params
[3], "sp", 32, PARAM_OUT
);
390 buf_set_u32(reg_params
[3].value
, 0, 32, lpc2000_info
->iap_working_area
->address
+ 0xb4);
393 init_reg_param(®_params
[4], "lr", 32, PARAM_OUT
);
394 buf_set_u32(reg_params
[4].value
, 0, 32, (lpc2000_info
->iap_working_area
->address
+ 0x04) | 1); /* bit0 of LR = 1 to return in Thumb mode */
396 target_run_algorithm(target
, 2, mem_params
, 5, reg_params
, lpc2000_info
->iap_working_area
->address
, 0, 10000, &armv7m_info
);
401 init_reg_param(®_params
[3], "sp_svc", 32, PARAM_OUT
);
402 buf_set_u32(reg_params
[3].value
, 0, 32, lpc2000_info
->iap_working_area
->address
+ 0xb4);
405 init_reg_param(®_params
[4], "lr_svc", 32, PARAM_OUT
);
406 buf_set_u32(reg_params
[4].value
, 0, 32, lpc2000_info
->iap_working_area
->address
+ 0x04);
408 target_run_algorithm(target
, 2, mem_params
, 5, reg_params
, lpc2000_info
->iap_working_area
->address
, lpc2000_info
->iap_working_area
->address
+ 0x4, 10000, &armv4_5_info
);
411 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
416 status_code
= target_buffer_get_u32(target
, mem_params
[1].value
);
417 result_table
[0] = target_buffer_get_u32(target
, mem_params
[1].value
+ 0x04);
418 result_table
[1] = target_buffer_get_u32(target
, mem_params
[1].value
+ 0x08);
419 result_table
[2] = target_buffer_get_u32(target
, mem_params
[1].value
+ 0x0c);
420 result_table
[3] = target_buffer_get_u32(target
, mem_params
[1].value
+ 0x10);
422 LOG_DEBUG("IAP command = %i (0x%8.8" PRIx32
", 0x%8.8" PRIx32
", 0x%8.8" PRIx32
", 0x%8.8" PRIx32
", 0x%8.8" PRIx32
") completed with result = %8.8" PRIx32
,
423 code
, param_table
[0], param_table
[1], param_table
[2], param_table
[3], param_table
[4], status_code
);
425 destroy_mem_param(&mem_params
[0]);
426 destroy_mem_param(&mem_params
[1]);
428 destroy_reg_param(®_params
[0]);
429 destroy_reg_param(®_params
[1]);
430 destroy_reg_param(®_params
[2]);
431 destroy_reg_param(®_params
[3]);
432 destroy_reg_param(®_params
[4]);
437 static int lpc2000_iap_blank_check(struct flash_bank
*bank
, int first
, int last
)
439 uint32_t param_table
[5];
440 uint32_t result_table
[4];
444 if ((first
< 0) || (last
>= bank
->num_sectors
))
445 return ERROR_FLASH_SECTOR_INVALID
;
447 for (i
= first
; i
<= last
; i
++)
449 /* check single sector */
450 param_table
[0] = param_table
[1] = i
;
451 status_code
= lpc2000_iap_call(bank
, 53, param_table
, result_table
);
455 case ERROR_FLASH_OPERATION_FAILED
:
456 return ERROR_FLASH_OPERATION_FAILED
;
457 case LPC2000_CMD_SUCCESS
:
458 bank
->sectors
[i
].is_erased
= 1;
460 case LPC2000_SECTOR_NOT_BLANK
:
461 bank
->sectors
[i
].is_erased
= 0;
463 case LPC2000_INVALID_SECTOR
:
464 bank
->sectors
[i
].is_erased
= 0;
467 return ERROR_FLASH_BUSY
;
470 LOG_ERROR("BUG: unknown LPC2000 status code %i", status_code
);
479 * flash bank lpc2000 <base> <size> 0 0 <target#> <lpc_variant> <cclk> [calc_checksum]
481 FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command
)
483 struct lpc2000_flash_bank
*lpc2000_info
;
487 LOG_WARNING("incomplete flash_bank lpc2000 configuration");
488 return ERROR_FLASH_BANK_INVALID
;
491 lpc2000_info
= malloc(sizeof(struct lpc2000_flash_bank
));
492 bank
->driver_priv
= lpc2000_info
;
494 if (strcmp(CMD_ARGV
[6], "lpc2000_v1") == 0)
496 lpc2000_info
->variant
= lpc2000_v1
;
497 lpc2000_info
->cmd51_dst_boundary
= 512;
498 lpc2000_info
->cmd51_can_256b
= 0;
499 lpc2000_info
->cmd51_can_8192b
= 1;
500 lpc2000_info
->checksum_vector
= 5;
502 else if (strcmp(CMD_ARGV
[6], "lpc2000_v2") == 0)
504 lpc2000_info
->variant
= lpc2000_v2
;
505 lpc2000_info
->cmd51_dst_boundary
= 256;
506 lpc2000_info
->cmd51_can_256b
= 1;
507 lpc2000_info
->cmd51_can_8192b
= 0;
508 lpc2000_info
->checksum_vector
= 5;
510 else if (strcmp(CMD_ARGV
[6], "lpc1700") == 0)
512 lpc2000_info
->variant
= lpc1700
;
513 lpc2000_info
->cmd51_dst_boundary
= 256;
514 lpc2000_info
->cmd51_can_256b
= 1;
515 lpc2000_info
->cmd51_can_8192b
= 0;
516 lpc2000_info
->checksum_vector
= 7;
520 LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV
[6]);
522 return ERROR_FLASH_BANK_INVALID
;
525 lpc2000_info
->iap_working_area
= NULL
;
526 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[7], lpc2000_info
->cclk
);
527 lpc2000_info
->calc_checksum
= 0;
528 lpc2000_build_sector_list(bank
);
532 if (strcmp(CMD_ARGV
[8], "calc_checksum") == 0)
533 lpc2000_info
->calc_checksum
= 1;
539 static int lpc2000_erase(struct flash_bank
*bank
, int first
, int last
)
541 struct lpc2000_flash_bank
*lpc2000_info
= bank
->driver_priv
;
542 uint32_t param_table
[5];
543 uint32_t result_table
[4];
546 if (bank
->target
->state
!= TARGET_HALTED
)
548 LOG_ERROR("Target not halted");
549 return ERROR_TARGET_NOT_HALTED
;
552 param_table
[0] = first
;
553 param_table
[1] = last
;
554 param_table
[2] = lpc2000_info
->cclk
;
556 /* Prepare sectors */
557 status_code
= lpc2000_iap_call(bank
, 50, param_table
, result_table
);
560 case ERROR_FLASH_OPERATION_FAILED
:
561 return ERROR_FLASH_OPERATION_FAILED
;
562 case LPC2000_CMD_SUCCESS
:
564 case LPC2000_INVALID_SECTOR
:
565 return ERROR_FLASH_SECTOR_INVALID
;
568 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code
);
569 return ERROR_FLASH_OPERATION_FAILED
;
573 status_code
= lpc2000_iap_call(bank
, 52, param_table
, result_table
);
576 case ERROR_FLASH_OPERATION_FAILED
:
577 return ERROR_FLASH_OPERATION_FAILED
;
578 case LPC2000_CMD_SUCCESS
:
580 case LPC2000_INVALID_SECTOR
:
581 return ERROR_FLASH_SECTOR_INVALID
;
584 LOG_WARNING("lpc2000 erase sectors returned %i", status_code
);
585 return ERROR_FLASH_OPERATION_FAILED
;
591 static int lpc2000_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
593 /* can't protect/unprotect on the lpc2000 */
597 static int lpc2000_write(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
599 struct lpc2000_flash_bank
*lpc2000_info
= bank
->driver_priv
;
600 struct target
*target
= bank
->target
;
601 uint32_t dst_min_alignment
;
602 uint32_t bytes_remaining
= count
;
603 uint32_t bytes_written
= 0;
604 int first_sector
= 0;
606 uint32_t param_table
[5];
607 uint32_t result_table
[4];
610 struct working_area
*download_area
;
611 int retval
= ERROR_OK
;
613 if (bank
->target
->state
!= TARGET_HALTED
)
615 LOG_ERROR("Target not halted");
616 return ERROR_TARGET_NOT_HALTED
;
619 if (offset
+ count
> bank
->size
)
620 return ERROR_FLASH_DST_OUT_OF_BANK
;
622 dst_min_alignment
= lpc2000_info
->cmd51_dst_boundary
;
624 if (offset
% dst_min_alignment
)
626 LOG_WARNING("offset 0x%" PRIx32
" breaks required alignment 0x%" PRIx32
, offset
, dst_min_alignment
);
627 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
630 for (i
= 0; i
< bank
->num_sectors
; i
++)
632 if (offset
>= bank
->sectors
[i
].offset
)
634 if (offset
+ DIV_ROUND_UP(count
, dst_min_alignment
) * dst_min_alignment
> bank
->sectors
[i
].offset
)
638 LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector
, last_sector
);
640 /* check if exception vectors should be flashed */
641 if ((offset
== 0) && (count
>= 0x20) && lpc2000_info
->calc_checksum
)
643 uint32_t checksum
= 0;
644 for (i
= 0; i
< 8; i
++)
646 LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32
, i
* 4, buf_get_u32(buffer
+ (i
* 4), 0, 32));
647 if (i
!= lpc2000_info
->checksum_vector
)
648 checksum
+= buf_get_u32(buffer
+ (i
* 4), 0, 32);
650 checksum
= 0 - checksum
;
651 LOG_DEBUG("checksum: 0x%8.8" PRIx32
, checksum
);
653 uint32_t original_value
= buf_get_u32(buffer
+ (lpc2000_info
->checksum_vector
* 4), 0, 32);
654 if (original_value
!= checksum
)
656 LOG_WARNING("Verification will fail since checksum in image (0x%8.8" PRIx32
") to be written to flash is different from calculated vector checksum (0x%8.8" PRIx32
").",
657 original_value
, checksum
);
658 LOG_WARNING("To remove this warning modify build tools on developer PC to inject correct LPC vector checksum.");
661 buf_set_u32(buffer
+ (lpc2000_info
->checksum_vector
* 4), 0, 32, checksum
);
664 /* allocate a working area */
665 if (target_alloc_working_area(target
, lpc2000_info
->cmd51_max_buffer
, &download_area
) != ERROR_OK
)
667 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
668 return ERROR_FLASH_OPERATION_FAILED
;
671 while (bytes_remaining
> 0)
673 uint32_t thisrun_bytes
;
674 if (bytes_remaining
>= lpc2000_info
->cmd51_max_buffer
)
675 thisrun_bytes
= lpc2000_info
->cmd51_max_buffer
;
676 else if (bytes_remaining
>= 1024)
677 thisrun_bytes
= 1024;
678 else if ((bytes_remaining
>= 512) || (!lpc2000_info
->cmd51_can_256b
))
683 /* Prepare sectors */
684 param_table
[0] = first_sector
;
685 param_table
[1] = last_sector
;
686 status_code
= lpc2000_iap_call(bank
, 50, param_table
, result_table
);
689 case ERROR_FLASH_OPERATION_FAILED
:
690 retval
= ERROR_FLASH_OPERATION_FAILED
;
692 case LPC2000_CMD_SUCCESS
:
694 case LPC2000_INVALID_SECTOR
:
695 retval
= ERROR_FLASH_SECTOR_INVALID
;
698 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code
);
699 retval
= ERROR_FLASH_OPERATION_FAILED
;
703 /* Exit if error occured */
704 if (retval
!= ERROR_OK
)
707 if (bytes_remaining
>= thisrun_bytes
)
709 if ((retval
= target_write_buffer(bank
->target
, download_area
->address
, thisrun_bytes
, buffer
+ bytes_written
)) != ERROR_OK
)
711 retval
= ERROR_FLASH_OPERATION_FAILED
;
717 uint8_t *last_buffer
= malloc(thisrun_bytes
);
718 memcpy(last_buffer
, buffer
+ bytes_written
, bytes_remaining
);
719 memset(last_buffer
+ bytes_remaining
, 0xff, thisrun_bytes
- bytes_remaining
);
720 target_write_buffer(bank
->target
, download_area
->address
, thisrun_bytes
, last_buffer
);
724 LOG_DEBUG("writing 0x%" PRIx32
" bytes to address 0x%" PRIx32
, thisrun_bytes
, bank
->base
+ offset
+ bytes_written
);
727 param_table
[0] = bank
->base
+ offset
+ bytes_written
;
728 param_table
[1] = download_area
->address
;
729 param_table
[2] = thisrun_bytes
;
730 param_table
[3] = lpc2000_info
->cclk
;
731 status_code
= lpc2000_iap_call(bank
, 51, param_table
, result_table
);
734 case ERROR_FLASH_OPERATION_FAILED
:
735 retval
= ERROR_FLASH_OPERATION_FAILED
;
737 case LPC2000_CMD_SUCCESS
:
739 case LPC2000_INVALID_SECTOR
:
740 retval
= ERROR_FLASH_SECTOR_INVALID
;
743 LOG_WARNING("lpc2000 returned %i", status_code
);
744 retval
= ERROR_FLASH_OPERATION_FAILED
;
748 /* Exit if error occured */
749 if (retval
!= ERROR_OK
)
752 if (bytes_remaining
> thisrun_bytes
)
753 bytes_remaining
-= thisrun_bytes
;
756 bytes_written
+= thisrun_bytes
;
759 target_free_working_area(target
, download_area
);
764 static int lpc2000_probe(struct flash_bank
*bank
)
766 /* we can't probe on an lpc2000
767 * if this is an lpc2xxx, it has the configured flash
772 static int lpc2000_erase_check(struct flash_bank
*bank
)
774 if (bank
->target
->state
!= TARGET_HALTED
)
776 LOG_ERROR("Target not halted");
777 return ERROR_TARGET_NOT_HALTED
;
780 return lpc2000_iap_blank_check(bank
, 0, bank
->num_sectors
- 1);
783 static int lpc2000_protect_check(struct flash_bank
*bank
)
785 /* sectors are always protected */
789 static int get_lpc2000_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
791 struct lpc2000_flash_bank
*lpc2000_info
= bank
->driver_priv
;
793 snprintf(buf
, buf_size
, "lpc2000 flash driver variant: %i, clk: %" PRIi32
"kHz" , lpc2000_info
->variant
, lpc2000_info
->cclk
);
798 COMMAND_HANDLER(lpc2000_handle_part_id_command
)
800 uint32_t param_table
[5];
801 uint32_t result_table
[4];
806 return ERROR_COMMAND_SYNTAX_ERROR
;
809 struct flash_bank
*bank
;
810 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
811 if (ERROR_OK
!= retval
)
814 if (bank
->target
->state
!= TARGET_HALTED
)
816 LOG_ERROR("Target not halted");
817 return ERROR_TARGET_NOT_HALTED
;
820 if ((status_code
= lpc2000_iap_call(bank
, 54, param_table
, result_table
)) != 0x0)
822 if (status_code
== ERROR_FLASH_OPERATION_FAILED
)
824 command_print(CMD_CTX
, "no sufficient working area specified, can't access LPC2000 IAP interface");
827 command_print(CMD_CTX
, "lpc2000 IAP returned status code %i", status_code
);
831 command_print(CMD_CTX
, "lpc2000 part id: 0x%8.8" PRIx32
, result_table
[0]);
837 static const struct command_registration lpc2000_exec_command_handlers
[] = {
840 .handler
= lpc2000_handle_part_id_command
,
841 .mode
= COMMAND_EXEC
,
842 .help
= "print part id of lpc2000 flash bank <num>",
844 COMMAND_REGISTRATION_DONE
846 static const struct command_registration lpc2000_command_handlers
[] = {
850 .help
= "lpc2000 flash command group",
851 .chain
= lpc2000_exec_command_handlers
,
853 COMMAND_REGISTRATION_DONE
856 struct flash_driver lpc2000_flash
= {
858 .commands
= lpc2000_command_handlers
,
859 .flash_bank_command
= lpc2000_flash_bank_command
,
860 .erase
= lpc2000_erase
,
861 .protect
= lpc2000_protect
,
862 .write
= lpc2000_write
,
863 .read
= default_flash_read
,
864 .probe
= lpc2000_probe
,
865 .auto_probe
= lpc2000_probe
,
866 .erase_check
= lpc2000_erase_check
,
867 .protect_check
= lpc2000_protect_check
,
868 .info
= get_lpc2000_info
,
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)