Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Fix sector layout for 504-KiB LPC2000 devices
[openocd.git] / src / flash / nor / lpc2000.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * LPC1700 support Copyright (C) 2009 by Audrius Urmanavicius *
6 * didele.deze@gmail.com *
7 * *
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. *
12 * *
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. *
17 * *
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 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "imp.h"
29 #include <helper/binarybuffer.h>
30 #include <target/algorithm.h>
31 #include <target/arm_opcodes.h>
32 #include <target/armv7m.h>
33
34
35 /**
36 * @file
37 * flash programming support for NXP LPC17xx and LPC2xxx devices.
38 *
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).
42 */
43 /*
44 * currently supported devices:
45 * variant 1 (lpc2000_v1):
46 * - 2104 | 5 | 6
47 * - 2114 | 9
48 * - 2124 | 9
49 * - 2194
50 * - 2212 | 4
51 * - 2292 | 4
52 *
53 * variant 2 (lpc2000_v2):
54 * - 213x
55 * - 214x
56 * - 2101 | 2 | 3
57 * - 2364 | 6 | 8
58 * - 2378
59 *
60 * lpc1700:
61 * - 175x
62 * - 176x (tested with LPC1768)
63 */
64
65 typedef enum
66 {
67 lpc2000_v1,
68 lpc2000_v2,
69 lpc1700
70 } lpc2000_variant;
71
72 struct lpc2000_flash_bank
73 {
74 lpc2000_variant variant;
75 struct working_area *iap_working_area;
76 uint32_t cclk;
77 int cmd51_dst_boundary;
78 int cmd51_can_256b;
79 int cmd51_can_8192b;
80 int calc_checksum;
81 uint32_t cmd51_max_buffer;
82 int checksum_vector;
83 };
84
85 enum lpc2000_status_codes
86 {
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,
98 LPC2000_BUSY = 11,
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
107
108 };
109
110 static int lpc2000_build_sector_list(struct flash_bank *bank)
111 {
112 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
113 int i;
114 uint32_t offset = 0;
115
116 /* default to a 4096 write buffer */
117 lpc2000_info->cmd51_max_buffer = 4096;
118
119 if (lpc2000_info->variant == lpc2000_v1)
120 {
121 /* variant 1 has different layout for 128kb and 256kb flashes */
122 if (bank->size == 128 * 1024)
123 {
124 bank->num_sectors = 16;
125 bank->sectors = malloc(sizeof(struct flash_sector) * 16);
126 for (i = 0; i < 16; i++)
127 {
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;
133 }
134 }
135 else if (bank->size == 256 * 1024)
136 {
137 bank->num_sectors = 18;
138 bank->sectors = malloc(sizeof(struct flash_sector) * 18);
139
140 for (i = 0; i < 8; i++)
141 {
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;
147 }
148 for (i = 8; i < 10; i++)
149 {
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;
155 }
156 for (i = 10; i < 18; i++)
157 {
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;
163 }
164 }
165 else
166 {
167 LOG_ERROR("BUG: unknown bank->size encountered");
168 exit(-1);
169 }
170 }
171 else if (lpc2000_info->variant == lpc2000_v2)
172 {
173 /* variant 2 has a uniform layout, only number of sectors differs */
174 switch (bank->size)
175 {
176 case 4 * 1024:
177 lpc2000_info->cmd51_max_buffer = 1024;
178 bank->num_sectors = 1;
179 break;
180 case 8 * 1024:
181 lpc2000_info->cmd51_max_buffer = 1024;
182 bank->num_sectors = 2;
183 break;
184 case 16 * 1024:
185 bank->num_sectors = 4;
186 break;
187 case 32 * 1024:
188 bank->num_sectors = 8;
189 break;
190 case 64 * 1024:
191 bank->num_sectors = 9;
192 break;
193 case 128 * 1024:
194 bank->num_sectors = 11;
195 break;
196 case 256 * 1024:
197 bank->num_sectors = 15;
198 break;
199 case 500 * 1024:
200 bank->num_sectors = 27;
201 break;
202 case 512 * 1024:
203 case 504 * 1024:
204 bank->num_sectors = 28;
205 break;
206 default:
207 LOG_ERROR("BUG: unknown bank->size encountered");
208 exit(-1);
209 break;
210 }
211
212 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
213
214 for (i = 0; i < bank->num_sectors; i++)
215 {
216 if (i < 8)
217 {
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;
223 }
224 else if (i < 22)
225 {
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;
231 }
232 else if (i < 28)
233 {
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;
239 }
240 }
241 }
242 else if (lpc2000_info->variant == lpc1700)
243 {
244 switch(bank->size)
245 {
246 case 32 * 1024:
247 bank->num_sectors = 8;
248 break;
249 case 64 * 1024:
250 bank->num_sectors = 16;
251 break;
252 case 128 * 1024:
253 bank->num_sectors = 18;
254 break;
255 case 256 * 1024:
256 bank->num_sectors = 22;
257 break;
258 case 512 * 1024:
259 bank->num_sectors = 30;
260 break;
261 default:
262 LOG_ERROR("BUG: unknown bank->size encountered");
263 exit(-1);
264 }
265
266 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
267
268 for(i = 0; i < bank->num_sectors; i++)
269 {
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;
276 }
277 }
278 else
279 {
280 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
281 exit(-1);
282 }
283
284 return ERROR_OK;
285 }
286
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)
293 */
294 static int lpc2000_iap_call(struct flash_bank *bank, int code, uint32_t param_table[5], uint32_t result_table[4])
295 {
296 int retval;
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 */
305
306 /* regrab previously allocated working_area, or allocate a new one */
307 if (!lpc2000_info->iap_working_area)
308 {
309 uint8_t jump_gate[8];
310
311 /* make sure we have a working area */
312 if (target_alloc_working_area(target, 180, &lpc2000_info->iap_working_area) != ERROR_OK)
313 {
314 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
315 return ERROR_FLASH_OPERATION_FAILED;
316 }
317
318 /* write IAP code to working area */
319 switch(lpc2000_info->variant)
320 {
321 case lpc1700:
322 target_buffer_set_u32(target, jump_gate,
323 ARMV4_5_T_BX(12));
324 target_buffer_set_u32(target, jump_gate + 4,
325 ARMV5_T_BKPT(0));
326 break;
327 case lpc2000_v1:
328 case lpc2000_v2:
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));
331 break;
332 default:
333 LOG_ERROR("BUG: unknown bank->size encountered");
334 exit(-1);
335 }
336
337 if ((retval = target_write_memory(target, lpc2000_info->iap_working_area->address, 4, 2, jump_gate)) != ERROR_OK)
338 {
339 LOG_ERROR("Write memory at address 0x%8.8" PRIx32 " failed (check work_area definition)", lpc2000_info->iap_working_area->address);
340 return retval;
341 }
342 }
343
344 switch(lpc2000_info->variant)
345 {
346 case lpc1700:
347 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
348 armv7m_info.core_mode = ARMV7M_MODE_ANY;
349 iap_entry_point = 0x1fff1ff1;
350 break;
351 case lpc2000_v1:
352 case lpc2000_v2:
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;
357 break;
358 default:
359 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
360 exit(-1);
361 }
362
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]);
371
372 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
373 buf_set_u32(reg_params[0].value, 0, 32, lpc2000_info->iap_working_area->address + 0x08);
374
375 /* command result table */
376 init_mem_param(&mem_params[1], lpc2000_info->iap_working_area->address + 0x20, 5 * 4, PARAM_IN);
377
378 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
379 buf_set_u32(reg_params[1].value, 0, 32, lpc2000_info->iap_working_area->address + 0x20);
380
381 /* IAP entry point */
382 init_reg_param(&reg_params[2], "r12", 32, PARAM_OUT);
383 buf_set_u32(reg_params[2].value, 0, 32, iap_entry_point);
384
385 switch(lpc2000_info->variant)
386 {
387 case lpc1700:
388 /* IAP stack */
389 init_reg_param(&reg_params[3], "sp", 32, PARAM_OUT);
390 buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4);
391
392 /* return address */
393 init_reg_param(&reg_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 */
395
396 target_run_algorithm(target, 2, mem_params, 5, reg_params, lpc2000_info->iap_working_area->address, 0, 10000, &armv7m_info);
397 break;
398 case lpc2000_v1:
399 case lpc2000_v2:
400 /* IAP stack */
401 init_reg_param(&reg_params[3], "sp_svc", 32, PARAM_OUT);
402 buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4);
403
404 /* return address */
405 init_reg_param(&reg_params[4], "lr_svc", 32, PARAM_OUT);
406 buf_set_u32(reg_params[4].value, 0, 32, lpc2000_info->iap_working_area->address + 0x04);
407
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);
409 break;
410 default:
411 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
412 exit(-1);
413 }
414
415
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);
421
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);
424
425 destroy_mem_param(&mem_params[0]);
426 destroy_mem_param(&mem_params[1]);
427
428 destroy_reg_param(&reg_params[0]);
429 destroy_reg_param(&reg_params[1]);
430 destroy_reg_param(&reg_params[2]);
431 destroy_reg_param(&reg_params[3]);
432 destroy_reg_param(&reg_params[4]);
433
434 return status_code;
435 }
436
437 static int lpc2000_iap_blank_check(struct flash_bank *bank, int first, int last)
438 {
439 uint32_t param_table[5];
440 uint32_t result_table[4];
441 int status_code;
442 int i;
443
444 if ((first < 0) || (last >= bank->num_sectors))
445 return ERROR_FLASH_SECTOR_INVALID;
446
447 for (i = first; i <= last; i++)
448 {
449 /* check single sector */
450 param_table[0] = param_table[1] = i;
451 status_code = lpc2000_iap_call(bank, 53, param_table, result_table);
452
453 switch (status_code)
454 {
455 case ERROR_FLASH_OPERATION_FAILED:
456 return ERROR_FLASH_OPERATION_FAILED;
457 case LPC2000_CMD_SUCCESS:
458 bank->sectors[i].is_erased = 1;
459 break;
460 case LPC2000_SECTOR_NOT_BLANK:
461 bank->sectors[i].is_erased = 0;
462 break;
463 case LPC2000_INVALID_SECTOR:
464 bank->sectors[i].is_erased = 0;
465 break;
466 case LPC2000_BUSY:
467 return ERROR_FLASH_BUSY;
468 break;
469 default:
470 LOG_ERROR("BUG: unknown LPC2000 status code %i", status_code);
471 exit(-1);
472 }
473 }
474
475 return ERROR_OK;
476 }
477
478 /*
479 * flash bank lpc2000 <base> <size> 0 0 <target#> <lpc_variant> <cclk> [calc_checksum]
480 */
481 FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
482 {
483 struct lpc2000_flash_bank *lpc2000_info;
484
485 if (CMD_ARGC < 8)
486 {
487 LOG_WARNING("incomplete flash_bank lpc2000 configuration");
488 return ERROR_FLASH_BANK_INVALID;
489 }
490
491 lpc2000_info = malloc(sizeof(struct lpc2000_flash_bank));
492 bank->driver_priv = lpc2000_info;
493
494 if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0)
495 {
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;
501 }
502 else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0)
503 {
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;
509 }
510 else if (strcmp(CMD_ARGV[6], "lpc1700") == 0)
511 {
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;
517 }
518 else
519 {
520 LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
521 free(lpc2000_info);
522 return ERROR_FLASH_BANK_INVALID;
523 }
524
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);
529
530 if (CMD_ARGC >= 9)
531 {
532 if (strcmp(CMD_ARGV[8], "calc_checksum") == 0)
533 lpc2000_info->calc_checksum = 1;
534 }
535
536 return ERROR_OK;
537 }
538
539 static int lpc2000_erase(struct flash_bank *bank, int first, int last)
540 {
541 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
542 uint32_t param_table[5];
543 uint32_t result_table[4];
544 int status_code;
545
546 if (bank->target->state != TARGET_HALTED)
547 {
548 LOG_ERROR("Target not halted");
549 return ERROR_TARGET_NOT_HALTED;
550 }
551
552 param_table[0] = first;
553 param_table[1] = last;
554 param_table[2] = lpc2000_info->cclk;
555
556 /* Prepare sectors */
557 status_code = lpc2000_iap_call(bank, 50, param_table, result_table);
558 switch (status_code)
559 {
560 case ERROR_FLASH_OPERATION_FAILED:
561 return ERROR_FLASH_OPERATION_FAILED;
562 case LPC2000_CMD_SUCCESS:
563 break;
564 case LPC2000_INVALID_SECTOR:
565 return ERROR_FLASH_SECTOR_INVALID;
566 break;
567 default:
568 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
569 return ERROR_FLASH_OPERATION_FAILED;
570 }
571
572 /* Erase sectors */
573 status_code = lpc2000_iap_call(bank, 52, param_table, result_table);
574 switch (status_code)
575 {
576 case ERROR_FLASH_OPERATION_FAILED:
577 return ERROR_FLASH_OPERATION_FAILED;
578 case LPC2000_CMD_SUCCESS:
579 break;
580 case LPC2000_INVALID_SECTOR:
581 return ERROR_FLASH_SECTOR_INVALID;
582 break;
583 default:
584 LOG_WARNING("lpc2000 erase sectors returned %i", status_code);
585 return ERROR_FLASH_OPERATION_FAILED;
586 }
587
588 return ERROR_OK;
589 }
590
591 static int lpc2000_protect(struct flash_bank *bank, int set, int first, int last)
592 {
593 /* can't protect/unprotect on the lpc2000 */
594 return ERROR_OK;
595 }
596
597 static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
598 {
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;
605 int last_sector = 0;
606 uint32_t param_table[5];
607 uint32_t result_table[4];
608 int status_code;
609 int i;
610 struct working_area *download_area;
611 int retval = ERROR_OK;
612
613 if (bank->target->state != TARGET_HALTED)
614 {
615 LOG_ERROR("Target not halted");
616 return ERROR_TARGET_NOT_HALTED;
617 }
618
619 if (offset + count > bank->size)
620 return ERROR_FLASH_DST_OUT_OF_BANK;
621
622 dst_min_alignment = lpc2000_info->cmd51_dst_boundary;
623
624 if (offset % dst_min_alignment)
625 {
626 LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, offset, dst_min_alignment);
627 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
628 }
629
630 for (i = 0; i < bank->num_sectors; i++)
631 {
632 if (offset >= bank->sectors[i].offset)
633 first_sector = i;
634 if (offset + DIV_ROUND_UP(count, dst_min_alignment) * dst_min_alignment > bank->sectors[i].offset)
635 last_sector = i;
636 }
637
638 LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
639
640 /* check if exception vectors should be flashed */
641 if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum)
642 {
643 uint32_t checksum = 0;
644 for (i = 0; i < 8; i++)
645 {
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);
649 }
650 checksum = 0 - checksum;
651 LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
652
653 uint32_t original_value = buf_get_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32);
654 if (original_value != checksum)
655 {
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.");
659 }
660
661 buf_set_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32, checksum);
662 }
663
664 /* allocate a working area */
665 if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK)
666 {
667 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
668 return ERROR_FLASH_OPERATION_FAILED;
669 }
670
671 while (bytes_remaining > 0)
672 {
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))
679 thisrun_bytes = 512;
680 else
681 thisrun_bytes = 256;
682
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);
687 switch (status_code)
688 {
689 case ERROR_FLASH_OPERATION_FAILED:
690 retval = ERROR_FLASH_OPERATION_FAILED;
691 break;
692 case LPC2000_CMD_SUCCESS:
693 break;
694 case LPC2000_INVALID_SECTOR:
695 retval = ERROR_FLASH_SECTOR_INVALID;
696 break;
697 default:
698 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
699 retval = ERROR_FLASH_OPERATION_FAILED;
700 break;
701 }
702
703 /* Exit if error occured */
704 if (retval != ERROR_OK)
705 break;
706
707 if (bytes_remaining >= thisrun_bytes)
708 {
709 if ((retval = target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written)) != ERROR_OK)
710 {
711 retval = ERROR_FLASH_OPERATION_FAILED;
712 break;
713 }
714 }
715 else
716 {
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);
721 free(last_buffer);
722 }
723
724 LOG_DEBUG("writing 0x%" PRIx32 " bytes to address 0x%" PRIx32 , thisrun_bytes, bank->base + offset + bytes_written);
725
726 /* Write data */
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);
732 switch (status_code)
733 {
734 case ERROR_FLASH_OPERATION_FAILED:
735 retval = ERROR_FLASH_OPERATION_FAILED;
736 break;
737 case LPC2000_CMD_SUCCESS:
738 break;
739 case LPC2000_INVALID_SECTOR:
740 retval = ERROR_FLASH_SECTOR_INVALID;
741 break;
742 default:
743 LOG_WARNING("lpc2000 returned %i", status_code);
744 retval = ERROR_FLASH_OPERATION_FAILED;
745 break;
746 }
747
748 /* Exit if error occured */
749 if (retval != ERROR_OK)
750 break;
751
752 if (bytes_remaining > thisrun_bytes)
753 bytes_remaining -= thisrun_bytes;
754 else
755 bytes_remaining = 0;
756 bytes_written += thisrun_bytes;
757 }
758
759 target_free_working_area(target, download_area);
760
761 return retval;
762 }
763
764 static int lpc2000_probe(struct flash_bank *bank)
765 {
766 /* we can't probe on an lpc2000
767 * if this is an lpc2xxx, it has the configured flash
768 */
769 return ERROR_OK;
770 }
771
772 static int lpc2000_erase_check(struct flash_bank *bank)
773 {
774 if (bank->target->state != TARGET_HALTED)
775 {
776 LOG_ERROR("Target not halted");
777 return ERROR_TARGET_NOT_HALTED;
778 }
779
780 return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
781 }
782
783 static int lpc2000_protect_check(struct flash_bank *bank)
784 {
785 /* sectors are always protected */
786 return ERROR_OK;
787 }
788
789 static int get_lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
790 {
791 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
792
793 snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIi32 "kHz" , lpc2000_info->variant, lpc2000_info->cclk);
794
795 return ERROR_OK;
796 }
797
798 COMMAND_HANDLER(lpc2000_handle_part_id_command)
799 {
800 uint32_t param_table[5];
801 uint32_t result_table[4];
802 int status_code;
803
804 if (CMD_ARGC < 1)
805 {
806 return ERROR_COMMAND_SYNTAX_ERROR;
807 }
808
809 struct flash_bank *bank;
810 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
811 if (ERROR_OK != retval)
812 return retval;
813
814 if (bank->target->state != TARGET_HALTED)
815 {
816 LOG_ERROR("Target not halted");
817 return ERROR_TARGET_NOT_HALTED;
818 }
819
820 if ((status_code = lpc2000_iap_call(bank, 54, param_table, result_table)) != 0x0)
821 {
822 if (status_code == ERROR_FLASH_OPERATION_FAILED)
823 {
824 command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface");
825 return ERROR_OK;
826 }
827 command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
828 }
829 else
830 {
831 command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32 , result_table[0]);
832 }
833
834 return ERROR_OK;
835 }
836
837 static const struct command_registration lpc2000_exec_command_handlers[] = {
838 {
839 .name = "part_id",
840 .handler = lpc2000_handle_part_id_command,
841 .mode = COMMAND_EXEC,
842 .help = "print part id of lpc2000 flash bank <num>",
843 },
844 COMMAND_REGISTRATION_DONE
845 };
846 static const struct command_registration lpc2000_command_handlers[] = {
847 {
848 .name = "lpc2000",
849 .mode = COMMAND_ANY,
850 .help = "lpc2000 flash command group",
851 .chain = lpc2000_exec_command_handlers,
852 },
853 COMMAND_REGISTRATION_DONE
854 };
855
856 struct flash_driver lpc2000_flash = {
857 .name = "lpc2000",
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,
869 };
Open On-Chip Debugger

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)