Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jtag: linuxgpiod: drop extra parenthesis
[openocd.git] / src / flash / nor / lpc2000.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath *
5 * Dominic.Rath@gmx.de *
6 * *
7 * LPC1700 support Copyright (C) 2009 by Audrius Urmanavicius *
8 * didele.deze@gmail.com *
9 * *
10 * LPC1100 variant and auto-probing support Copyright (C) 2014 *
11 * by Cosmin Gorgovan cosmin [at] linux-geek [dot] org *
12 * *
13 * LPC800/LPC1500/LPC54100 support Copyright (C) 2013/2014 *
14 * by Nemui Trinomius *
15 * nemuisan_kawausogasuki@live.jp *
16 * *
17 * LPC8N04/HNS31xx support Copyright (C) 2018 *
18 * by Jean-Christian de Rivaz jcdr [at] innodelec [dot] ch *
19 ***************************************************************************/
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "imp.h"
26 #include <helper/binarybuffer.h>
27 #include <target/algorithm.h>
28 #include <target/arm_opcodes.h>
29 #include <target/armv7m.h>
30
31 /**
32 * @file
33 * flash programming support for NXP LPC8xx,LPC1xxx,LPC4xxx,LP5410x,LPC2xxx and NHS31xx devices.
34 *
35 * @todo Provide a way to update CCLK after declaring the flash bank. The value which is correct after chip reset will
36 * rarely still work right after the clocks switch to use the PLL (e.g. 4MHz --> 100 MHz).
37 */
38 /*
39 * currently supported devices:
40 * variant 1 (lpc2000_v1):
41 * - 2104 | 5 | 6
42 * - 2114 | 9
43 * - 2124 | 9
44 * - 2194
45 * - 2212 | 4
46 * - 2292 | 4
47 *
48 * variant 2 (lpc2000_v2):
49 * - 213x
50 * - 214x
51 * - 2101 | 2 | 3
52 * - 2364 | 6 | 8
53 * - 2378
54 *
55 * lpc1700:
56 * - 175x
57 * - 176x (tested with LPC1768)
58 * - 177x
59 * - 178x (tested with LPC1788)
60 *
61 * lpc4000: (lpc1700's alias)
62 * - 407x
63 * - 408x (tested with LPC4088)
64 *
65 * lpc4300: (also available as lpc1800 - alias)
66 * - 43x2 | 3 | 5 | 7 (tested with LPC4337/LPC4357)
67 * - 18x2 | 3 | 5 | 7
68 *
69 * lpc800:
70 * - 810 | 1 | 2 (tested with LPC810/LPC811/LPC812)
71 * - 822 | 4 (tested with LPC824)
72 * - 8N04
73 * - NHS31xx (tested with NHS3100)
74 * - 844 | 5 (tested with LPC845)
75 *
76 * lpc1100:
77 * - 11xx
78 * - 11Axx
79 * - 11Cxx
80 * - 11Dxx
81 * - 11Exx
82 * - 11Uxx (tested with LPC11U34)
83 * - 131x
84 * - 134x
85 *
86 * lpc1500:
87 * - 15x7 | 8 | 9 (tested with LPC1549)
88 *
89 * lpc54100:
90 * - 54101 | 2 (tested with LPC54102)
91 *
92 * The auto variant auto-detects parts from the following series:
93 * - 11xx
94 * - 11Axx
95 * - 11Cxx
96 * - 11Dxx
97 * - 11Exx
98 * - 11Uxx
99 * - 131x
100 * - 134x
101 * - 175x
102 * - 176x
103 * - 177x
104 * - 178x
105 * - 407x
106 * - 408x
107 * - 81x
108 * - 82x
109 * - 8N04
110 * - NHS31xx
111 */
112
113 /* Part IDs for autodetection */
114 /* A script which can automatically extract part ids from user manuals is available here:
115 * https://github.com/lgeek/lpc_part_ids
116 */
117 #define LPC1110_1 0x0A07102B
118 #define LPC1110_2 0x1A07102B
119 #define LPC1111_002_1 0x0A16D02B
120 #define LPC1111_002_2 0x1A16D02B
121 #define LPC1111_101_1 0x041E502B
122 #define LPC1111_101_2 0x2516D02B
123 #define LPC1111_103_1 0x00010013
124 #define LPC1111_201_1 0x0416502B
125 #define LPC1111_201_2 0x2516902B
126 #define LPC1111_203_1 0x00010012
127 #define LPC1112_101_1 0x042D502B
128 #define LPC1112_101_2 0x2524D02B
129 #define LPC1112_102_1 0x0A24902B
130 #define LPC1112_102_2 0x1A24902B
131 #define LPC1112_103_1 0x00020023
132 #define LPC1112_201_1 0x0425502B
133 #define LPC1112_201_2 0x2524902B
134 #define LPC1112_203_1 0x00020022
135 #define LPC1113_201_1 0x0434502B
136 #define LPC1113_201_2 0x2532902B
137 #define LPC1113_203_1 0x00030032
138 #define LPC1113_301_1 0x0434102B
139 #define LPC1113_301_2 0x2532102B
140 #define LPC1113_303_1 0x00030030
141 #define LPC1114_102_1 0x0A40902B
142 #define LPC1114_102_2 0x1A40902B
143 #define LPC1114_201_1 0x0444502B
144 #define LPC1114_201_2 0x2540902B
145 #define LPC1114_203_1 0x00040042
146 #define LPC1114_301_1 0x0444102B
147 #define LPC1114_301_2 0x2540102B
148 #define LPC1114_303_1 0x00040040
149 #define LPC1114_323_1 0x00040060
150 #define LPC1114_333_1 0x00040070
151 #define LPC1115_303_1 0x00050080
152
153 #define LPC11A02_1 0x4D4C802B
154 #define LPC11A04_1 0x4D80002B
155 #define LPC11A11_001_1 0x455EC02B
156 #define LPC11A12_101_1 0x4574802B
157 #define LPC11A13_201_1 0x458A402B
158 #define LPC11A14_301_1 0x35A0002B
159 #define LPC11A14_301_2 0x45A0002B
160
161 #define LPC11C12_301_1 0x1421102B
162 #define LPC11C14_301_1 0x1440102B
163 #define LPC11C22_301_1 0x1431102B
164 #define LPC11C24_301_1 0x1430102B
165
166 #define LPC11E11_101 0x293E902B
167 #define LPC11E12_201 0x2954502B
168 #define LPC11E13_301 0x296A102B
169 #define LPC11E14_401 0x2980102B
170 #define LPC11E36_501 0x00009C41
171 #define LPC11E37_401 0x00007C45
172 #define LPC11E37_501 0x00007C41
173
174 #define LPC11U12_201_1 0x095C802B
175 #define LPC11U12_201_2 0x295C802B
176 #define LPC11U13_201_1 0x097A802B
177 #define LPC11U13_201_2 0x297A802B
178 #define LPC11U14_201_1 0x0998802B
179 #define LPC11U14_201_2 0x2998802B
180 #define LPC11U23_301 0x2972402B
181 #define LPC11U24_301 0x2988402B
182 #define LPC11U24_401 0x2980002B
183 #define LPC11U34_311 0x0003D440
184 #define LPC11U34_421 0x0001CC40
185 #define LPC11U35_401 0x0001BC40
186 #define LPC11U35_501 0x0000BC40
187 #define LPC11U36_401 0x00019C40
188 #define LPC11U37_401 0x00017C40
189 #define LPC11U37H_401 0x00007C44
190 #define LPC11U37_501 0x00007C40
191
192 #define LPC11E66 0x0000DCC1
193 #define LPC11E67 0x0000BC81
194 #define LPC11E68 0x00007C01
195
196 #define LPC11U66 0x0000DCC8
197 #define LPC11U67_1 0x0000BC88
198 #define LPC11U67_2 0x0000BC80
199 #define LPC11U68_1 0x00007C08
200 #define LPC11U68_2 0x00007C00
201
202 #define LPC1311 0x2C42502B
203 #define LPC1311_1 0x1816902B
204 #define LPC1313 0x2C40102B
205 #define LPC1313_1 0x1830102B
206 #define LPC1315 0x3A010523
207 #define LPC1316 0x1A018524
208 #define LPC1317 0x1A020525
209 #define LPC1342 0x3D01402B
210 #define LPC1343 0x3D00002B
211 #define LPC1343_1 0x3000002B
212 #define LPC1345 0x28010541
213 #define LPC1346 0x08018542
214 #define LPC1347 0x08020543
215
216 #define LPC1751_1 0x25001110
217 #define LPC1751_2 0x25001118
218 #define LPC1752 0x25001121
219 #define LPC1754 0x25011722
220 #define LPC1756 0x25011723
221 #define LPC1758 0x25013F37
222 #define LPC1759 0x25113737
223 #define LPC1763 0x26012033
224 #define LPC1764 0x26011922
225 #define LPC1765 0x26013733
226 #define LPC1766 0x26013F33
227 #define LPC1767 0x26012837
228 #define LPC1768 0x26013F37
229 #define LPC1769 0x26113F37
230 #define LPC1774 0x27011132
231 #define LPC1776 0x27191F43
232 #define LPC1777 0x27193747
233 #define LPC1778 0x27193F47
234 #define LPC1785 0x281D1743
235 #define LPC1786 0x281D1F43
236 #define LPC1787 0x281D3747
237 #define LPC1788 0x281D3F47
238
239 #define LPC4072 0x47011121
240 #define LPC4074 0x47011132
241 #define LPC4076 0x47191F43
242 #define LPC4078 0x47193F47
243 #define LPC4088 0x481D3F47
244
245 #define LPC810_021 0x00008100
246 #define LPC811_001 0x00008110
247 #define LPC812_101 0x00008120
248 #define LPC812_101_1 0x00008121
249 #define LPC812_101_2 0x00008122
250 #define LPC812_101_3 0x00008123
251
252 #define LPC822_101 0x00008221
253 #define LPC822_101_1 0x00008222
254 #define LPC824_201 0x00008241
255 #define LPC824_201_1 0x00008242
256
257 #define LPC8N04 0x00008A04
258 #define NHS3100 0x4e310020
259 #define NHS3152 0x4e315220
260 #define NHS3153 0x4e315320 /* Only specified in Rev.1 of the datasheet */
261
262 #define LPC844_201 0x00008441
263 #define LPC844_201_1 0x00008442
264 #define LPC844_201_2 0x00008444
265
266 #define LPC845_301 0x00008451
267 #define LPC845_301_1 0x00008452
268 #define LPC845_301_2 0x00008453
269 #define LPC845_301_3 0x00008454
270
271 #define IAP_CODE_LEN 0x34
272
273 #define LPC11XX_REG_SECTORS 24
274
275 typedef enum {
276 LPC2000_V1,
277 LPC2000_V2,
278 LPC1700,
279 LPC4300,
280 LPC800,
281 LPC1100,
282 LPC1500,
283 LPC54100,
284 LPC_AUTO,
285 } lpc2000_variant;
286
287 struct lpc2000_flash_bank {
288 lpc2000_variant variant;
289 uint32_t cclk;
290 int cmd51_dst_boundary;
291 int calc_checksum;
292 uint32_t cmd51_max_buffer;
293 int checksum_vector;
294 uint32_t iap_max_stack;
295 uint32_t lpc4300_bank;
296 uint32_t iap_entry_alternative;
297 bool probed;
298 };
299
300 enum lpc2000_status_codes {
301 LPC2000_CMD_SUCCESS = 0,
302 LPC2000_INVALID_COMMAND = 1,
303 LPC2000_SRC_ADDR_ERROR = 2,
304 LPC2000_DST_ADDR_ERROR = 3,
305 LPC2000_SRC_ADDR_NOT_MAPPED = 4,
306 LPC2000_DST_ADDR_NOT_MAPPED = 5,
307 LPC2000_COUNT_ERROR = 6,
308 LPC2000_INVALID_SECTOR = 7,
309 LPC2000_SECTOR_NOT_BLANK = 8,
310 LPC2000_SECTOR_NOT_PREPARED = 9,
311 LPC2000_COMPARE_ERROR = 10,
312 LPC2000_BUSY = 11,
313 LPC2000_PARAM_ERROR = 12,
314 LPC2000_ADDR_ERROR = 13,
315 LPC2000_ADDR_NOT_MAPPED = 14,
316 LPC2000_CMD_NOT_LOCKED = 15,
317 LPC2000_INVALID_CODE = 16,
318 LPC2000_INVALID_BAUD_RATE = 17,
319 LPC2000_INVALID_STOP_BIT = 18,
320 LPC2000_CRP_ENABLED = 19,
321 LPC2000_INVALID_FLASH_UNIT = 20,
322 LPC2000_USER_CODE_CHECKSUM = 21,
323 LCP2000_ERROR_SETTING_ACTIVE_PARTITION = 22,
324 };
325
326 static int lpc2000_build_sector_list(struct flash_bank *bank)
327 {
328 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
329 uint32_t offset = 0;
330
331 /* default to a 4096 write buffer */
332 lpc2000_info->cmd51_max_buffer = 4096;
333
334 if (lpc2000_info->variant == LPC2000_V1) {
335 lpc2000_info->cmd51_dst_boundary = 512;
336 lpc2000_info->checksum_vector = 5;
337 lpc2000_info->iap_max_stack = 128;
338
339 /* variant 1 has different layout for 128kb and 256kb flashes */
340 if (bank->size == 128 * 1024) {
341 bank->num_sectors = 16;
342 bank->sectors = malloc(sizeof(struct flash_sector) * 16);
343 for (int i = 0; i < 16; i++) {
344 bank->sectors[i].offset = offset;
345 bank->sectors[i].size = 8 * 1024;
346 offset += bank->sectors[i].size;
347 bank->sectors[i].is_erased = -1;
348 bank->sectors[i].is_protected = 1;
349 }
350 } else if (bank->size == 256 * 1024) {
351 bank->num_sectors = 18;
352 bank->sectors = malloc(sizeof(struct flash_sector) * 18);
353
354 for (int i = 0; i < 8; i++) {
355 bank->sectors[i].offset = offset;
356 bank->sectors[i].size = 8 * 1024;
357 offset += bank->sectors[i].size;
358 bank->sectors[i].is_erased = -1;
359 bank->sectors[i].is_protected = 1;
360 }
361 for (int i = 8; i < 10; i++) {
362 bank->sectors[i].offset = offset;
363 bank->sectors[i].size = 64 * 1024;
364 offset += bank->sectors[i].size;
365 bank->sectors[i].is_erased = -1;
366 bank->sectors[i].is_protected = 1;
367 }
368 for (int i = 10; i < 18; i++) {
369 bank->sectors[i].offset = offset;
370 bank->sectors[i].size = 8 * 1024;
371 offset += bank->sectors[i].size;
372 bank->sectors[i].is_erased = -1;
373 bank->sectors[i].is_protected = 1;
374 }
375 } else {
376 LOG_ERROR("BUG: unknown bank->size encountered");
377 exit(-1);
378 }
379 } else if (lpc2000_info->variant == LPC2000_V2) {
380 lpc2000_info->cmd51_dst_boundary = 256;
381 lpc2000_info->checksum_vector = 5;
382 lpc2000_info->iap_max_stack = 128;
383
384 /* variant 2 has a uniform layout, only number of sectors differs */
385 switch (bank->size) {
386 case 4 * 1024:
387 lpc2000_info->cmd51_max_buffer = 1024;
388 bank->num_sectors = 1;
389 break;
390 case 8 * 1024:
391 lpc2000_info->cmd51_max_buffer = 1024;
392 bank->num_sectors = 2;
393 break;
394 case 16 * 1024:
395 bank->num_sectors = 4;
396 break;
397 case 32 * 1024:
398 bank->num_sectors = 8;
399 break;
400 case 64 * 1024:
401 bank->num_sectors = 9;
402 break;
403 case 128 * 1024:
404 bank->num_sectors = 11;
405 break;
406 case 256 * 1024:
407 bank->num_sectors = 15;
408 break;
409 case 500 * 1024:
410 bank->num_sectors = 27;
411 break;
412 case 512 * 1024:
413 case 504 * 1024:
414 bank->num_sectors = 28;
415 break;
416 default:
417 LOG_ERROR("BUG: unknown bank->size encountered");
418 exit(-1);
419 break;
420 }
421
422 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
423
424 for (unsigned int i = 0; i < bank->num_sectors; i++) {
425 if (i < 8) {
426 bank->sectors[i].offset = offset;
427 bank->sectors[i].size = 4 * 1024;
428 offset += bank->sectors[i].size;
429 bank->sectors[i].is_erased = -1;
430 bank->sectors[i].is_protected = 1;
431 } else if (i < 22) {
432 bank->sectors[i].offset = offset;
433 bank->sectors[i].size = 32 * 1024;
434 offset += bank->sectors[i].size;
435 bank->sectors[i].is_erased = -1;
436 bank->sectors[i].is_protected = 1;
437 } else if (i < 28) {
438 bank->sectors[i].offset = offset;
439 bank->sectors[i].size = 4 * 1024;
440 offset += bank->sectors[i].size;
441 bank->sectors[i].is_erased = -1;
442 bank->sectors[i].is_protected = 1;
443 }
444 }
445 } else if (lpc2000_info->variant == LPC1700) {
446 lpc2000_info->cmd51_dst_boundary = 256;
447 lpc2000_info->checksum_vector = 7;
448 lpc2000_info->iap_max_stack = 128;
449
450 switch (bank->size) {
451 case 4 * 1024:
452 lpc2000_info->cmd51_max_buffer = 256;
453 bank->num_sectors = 1;
454 break;
455 case 8 * 1024:
456 lpc2000_info->cmd51_max_buffer = 512;
457 bank->num_sectors = 2;
458 break;
459 case 16 * 1024:
460 lpc2000_info->cmd51_max_buffer = 512;
461 bank->num_sectors = 4;
462 break;
463 case 32 * 1024:
464 lpc2000_info->cmd51_max_buffer = 1024;
465 bank->num_sectors = 8;
466 break;
467 case 64 * 1024:
468 bank->num_sectors = 16;
469 break;
470 case 128 * 1024:
471 bank->num_sectors = 18;
472 break;
473 case 256 * 1024:
474 bank->num_sectors = 22;
475 break;
476 case 512 * 1024:
477 bank->num_sectors = 30;
478 break;
479 default:
480 LOG_ERROR("BUG: unknown bank->size encountered");
481 exit(-1);
482 }
483
484 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
485
486 for (unsigned int i = 0; i < bank->num_sectors; i++) {
487 bank->sectors[i].offset = offset;
488 /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx/LPC40xx devices */
489 bank->sectors[i].size = (i < 16) ? 4 * 1024 : 32 * 1024;
490 offset += bank->sectors[i].size;
491 bank->sectors[i].is_erased = -1;
492 bank->sectors[i].is_protected = 1;
493 }
494 } else if (lpc2000_info->variant == LPC4300) {
495 lpc2000_info->cmd51_dst_boundary = 512;
496 lpc2000_info->checksum_vector = 7;
497 lpc2000_info->iap_max_stack = 208;
498
499 switch (bank->size) {
500 case 256 * 1024:
501 bank->num_sectors = 11;
502 break;
503 case 384 * 1024:
504 bank->num_sectors = 13;
505 break;
506 case 512 * 1024:
507 bank->num_sectors = 15;
508 break;
509 default:
510 LOG_ERROR("BUG: unknown bank->size encountered");
511 exit(-1);
512 }
513
514 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
515
516 for (unsigned int i = 0; i < bank->num_sectors; i++) {
517 bank->sectors[i].offset = offset;
518 /* sectors 0-7 are 8kB-sized, 8 and above are 64kB-sized for LPC43xx devices */
519 bank->sectors[i].size = (i < 8) ? 8 * 1024 : 64 * 1024;
520 offset += bank->sectors[i].size;
521 bank->sectors[i].is_erased = -1;
522 bank->sectors[i].is_protected = 1;
523 }
524
525 } else if (lpc2000_info->variant == LPC800) {
526 lpc2000_info->cmd51_dst_boundary = 64;
527 lpc2000_info->checksum_vector = 7;
528 lpc2000_info->iap_max_stack = 208; /* 148byte for LPC81x,208byte for LPC82x. */
529 lpc2000_info->cmd51_max_buffer = 256; /* smallest MCU in the series, LPC810, has 1 kB of SRAM */
530
531 switch (bank->size) {
532 case 4 * 1024:
533 bank->num_sectors = 4;
534 break;
535 case 8 * 1024:
536 bank->num_sectors = 8;
537 break;
538 case 16 * 1024:
539 bank->num_sectors = 16;
540 break;
541 case 30 * 1024:
542 lpc2000_info->cmd51_max_buffer = 1024; /* For LPC8N04 and NHS31xx, have 8kB of SRAM */
543 bank->num_sectors = 30; /* There have only 30kB of writable Flash out of 32kB */
544 break;
545 case 32 * 1024:
546 lpc2000_info->cmd51_max_buffer = 1024; /* For LPC824, has 8kB of SRAM */
547 bank->num_sectors = 32;
548 break;
549 case 64 * 1024:
550 lpc2000_info->cmd51_max_buffer = 1024; /* For LPC844, has 8kB of SRAM */
551 bank->num_sectors = 64;
552 break;
553 default:
554 LOG_ERROR("BUG: unknown bank->size encountered");
555 exit(-1);
556 }
557
558 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
559
560 for (unsigned int i = 0; i < bank->num_sectors; i++) {
561 bank->sectors[i].offset = offset;
562 /* all sectors are 1kB-sized for LPC8xx devices */
563 bank->sectors[i].size = 1 * 1024;
564 offset += bank->sectors[i].size;
565 bank->sectors[i].is_erased = -1;
566 bank->sectors[i].is_protected = 1;
567 }
568
569 } else if (lpc2000_info->variant == LPC1100) {
570 lpc2000_info->cmd51_dst_boundary = 256;
571 lpc2000_info->checksum_vector = 7;
572 lpc2000_info->iap_max_stack = 128;
573
574 if ((bank->size % (4 * 1024)) != 0) {
575 LOG_ERROR("BUG: unknown bank->size encountered,\nLPC1100 flash size must be a multiple of 4096");
576 exit(-1);
577 }
578 lpc2000_info->cmd51_max_buffer = 512; /* smallest MCU in the series, LPC1110, has 1 kB of SRAM */
579 unsigned int large_sectors = 0;
580 unsigned int normal_sectors = bank->size / 4096;
581
582 if (normal_sectors > LPC11XX_REG_SECTORS) {
583 large_sectors = (normal_sectors - LPC11XX_REG_SECTORS) / 8;
584 normal_sectors = LPC11XX_REG_SECTORS;
585 }
586
587 bank->num_sectors = normal_sectors + large_sectors;
588
589 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
590
591 for (unsigned int i = 0; i < bank->num_sectors; i++) {
592 bank->sectors[i].offset = offset;
593 bank->sectors[i].size = (i < LPC11XX_REG_SECTORS ? 4 : 32) * 1024;
594 offset += bank->sectors[i].size;
595 bank->sectors[i].is_erased = -1;
596 bank->sectors[i].is_protected = 1;
597 }
598
599 } else if (lpc2000_info->variant == LPC1500) {
600 lpc2000_info->cmd51_dst_boundary = 256;
601 lpc2000_info->checksum_vector = 7;
602 lpc2000_info->iap_max_stack = 128;
603
604 switch (bank->size) {
605 case 64 * 1024:
606 bank->num_sectors = 16;
607 break;
608 case 128 * 1024:
609 bank->num_sectors = 32;
610 break;
611 case 256 * 1024:
612 bank->num_sectors = 64;
613 break;
614 default:
615 LOG_ERROR("BUG: unknown bank->size encountered");
616 exit(-1);
617 }
618
619 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
620
621 for (unsigned int i = 0; i < bank->num_sectors; i++) {
622 bank->sectors[i].offset = offset;
623 /* all sectors are 4kB-sized */
624 bank->sectors[i].size = 4 * 1024;
625 offset += bank->sectors[i].size;
626 bank->sectors[i].is_erased = -1;
627 bank->sectors[i].is_protected = 1;
628 }
629
630 } else if (lpc2000_info->variant == LPC54100) {
631 lpc2000_info->cmd51_dst_boundary = 256;
632 lpc2000_info->checksum_vector = 7;
633 lpc2000_info->iap_max_stack = 128;
634
635 switch (bank->size) {
636 case 256 * 1024:
637 bank->num_sectors = 8;
638 break;
639 case 512 * 1024:
640 bank->num_sectors = 16;
641 break;
642 default:
643 LOG_ERROR("BUG: unknown bank->size encountered");
644 exit(-1);
645 }
646
647 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
648
649 for (unsigned int i = 0; i < bank->num_sectors; i++) {
650 bank->sectors[i].offset = offset;
651 /* all sectors are 32kB-sized */
652 bank->sectors[i].size = 32 * 1024;
653 offset += bank->sectors[i].size;
654 bank->sectors[i].is_erased = -1;
655 bank->sectors[i].is_protected = 1;
656 }
657
658 } else {
659 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
660 exit(-1);
661 }
662
663 return ERROR_OK;
664 }
665
666 /* this function allocates and initializes working area used for IAP algorithm
667 * uses 52 + max IAP stack bytes working area
668 * 0x0 to 0x7: jump gate (BX to thumb state, b -2 to wait)
669 * 0x8 to 0x1f: command parameter table (1+5 words)
670 * 0x20 to 0x33: command result table (1+4 words)
671 * 0x34 to 0xb3|0x104: stack
672 * (128b needed for lpc1xxx/2000/5410x, 208b for lpc43xx/lpc82x and 148b for lpc81x)
673 */
674
675 static int lpc2000_iap_working_area_init(struct flash_bank *bank, struct working_area **iap_working_area)
676 {
677 struct target *target = bank->target;
678 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
679
680 if (target_alloc_working_area(target, IAP_CODE_LEN + lpc2000_info->iap_max_stack, iap_working_area) != ERROR_OK) {
681 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
682 return ERROR_FLASH_OPERATION_FAILED;
683 }
684
685 uint8_t jump_gate[8];
686
687 /* write IAP code to working area */
688 switch (lpc2000_info->variant) {
689 case LPC800:
690 case LPC1100:
691 case LPC1500:
692 case LPC1700:
693 case LPC4300:
694 case LPC54100:
695 case LPC_AUTO:
696 target_buffer_set_u32(target, jump_gate, ARMV4_5_T_BX(12));
697 target_buffer_set_u32(target, jump_gate + 4, ARMV5_T_BKPT(0));
698 break;
699 case LPC2000_V1:
700 case LPC2000_V2:
701 target_buffer_set_u32(target, jump_gate, ARMV4_5_BX(12));
702 target_buffer_set_u32(target, jump_gate + 4, ARMV4_5_B(0xfffffe, 0));
703 break;
704 default:
705 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
706 exit(-1);
707 }
708
709 int retval = target_write_memory(target, (*iap_working_area)->address, 4, 2, jump_gate);
710 if (retval != ERROR_OK) {
711 LOG_ERROR("Write memory at address " TARGET_ADDR_FMT " failed (check work_area definition)",
712 (*iap_working_area)->address);
713 target_free_working_area(target, *iap_working_area);
714 }
715
716 return retval;
717 }
718
719 /* call LPC8xx/LPC1xxx/LPC4xxx/LPC5410x/LPC2000 IAP function */
720
721 static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_working_area, int code,
722 uint32_t param_table[5], uint32_t result_table[4])
723 {
724 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
725 struct target *target = bank->target;
726
727 struct arm_algorithm arm_algo; /* for LPC2000 */
728 struct armv7m_algorithm armv7m_info; /* for LPC8xx/LPC1xxx/LPC4xxx/LPC5410x */
729 uint32_t iap_entry_point = 0; /* to make compiler happier */
730
731 switch (lpc2000_info->variant) {
732 case LPC800:
733 case LPC1100:
734 case LPC1700:
735 case LPC_AUTO:
736 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
737 armv7m_info.core_mode = ARM_MODE_THREAD;
738 iap_entry_point = 0x1fff1ff1;
739 break;
740 case LPC1500:
741 case LPC54100:
742 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
743 armv7m_info.core_mode = ARM_MODE_THREAD;
744 iap_entry_point = 0x03000205;
745 break;
746 case LPC2000_V1:
747 case LPC2000_V2:
748 arm_algo.common_magic = ARM_COMMON_MAGIC;
749 arm_algo.core_mode = ARM_MODE_SVC;
750 arm_algo.core_state = ARM_STATE_ARM;
751 iap_entry_point = 0x7ffffff1;
752 break;
753 case LPC4300:
754 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
755 armv7m_info.core_mode = ARM_MODE_THREAD;
756 /* read out IAP entry point from ROM driver table at 0x10400100 */
757 target_read_u32(target, 0x10400100, &iap_entry_point);
758 break;
759 default:
760 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
761 exit(-1);
762 }
763
764 if (lpc2000_info->iap_entry_alternative != 0x0)
765 iap_entry_point = lpc2000_info->iap_entry_alternative;
766
767 struct mem_param mem_params[2];
768
769 /* command parameter table */
770 init_mem_param(&mem_params[0], iap_working_area->address + 8, 6 * 4, PARAM_OUT);
771 target_buffer_set_u32(target, mem_params[0].value, code);
772 target_buffer_set_u32(target, mem_params[0].value + 0x04, param_table[0]);
773 target_buffer_set_u32(target, mem_params[0].value + 0x08, param_table[1]);
774 target_buffer_set_u32(target, mem_params[0].value + 0x0c, param_table[2]);
775 target_buffer_set_u32(target, mem_params[0].value + 0x10, param_table[3]);
776 target_buffer_set_u32(target, mem_params[0].value + 0x14, param_table[4]);
777
778 struct reg_param reg_params[5];
779
780 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
781 buf_set_u32(reg_params[0].value, 0, 32, iap_working_area->address + 0x08);
782
783 /* command result table */
784 init_mem_param(&mem_params[1], iap_working_area->address + 0x20, 5 * 4, PARAM_IN);
785
786 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
787 buf_set_u32(reg_params[1].value, 0, 32, iap_working_area->address + 0x20);
788
789 /* IAP entry point */
790 init_reg_param(&reg_params[2], "r12", 32, PARAM_OUT);
791 buf_set_u32(reg_params[2].value, 0, 32, iap_entry_point);
792
793 switch (lpc2000_info->variant) {
794 case LPC800:
795 case LPC1100:
796 case LPC1500:
797 case LPC1700:
798 case LPC4300:
799 case LPC54100:
800 case LPC_AUTO:
801 /* IAP stack */
802 init_reg_param(&reg_params[3], "sp", 32, PARAM_OUT);
803 buf_set_u32(reg_params[3].value, 0, 32,
804 iap_working_area->address + IAP_CODE_LEN + lpc2000_info->iap_max_stack);
805
806 /* return address */
807 init_reg_param(&reg_params[4], "lr", 32, PARAM_OUT);
808 buf_set_u32(reg_params[4].value, 0, 32, (iap_working_area->address + 0x04) | 1);
809 /* bit0 of LR = 1 to return in Thumb mode */
810
811 target_run_algorithm(target, 2, mem_params, 5, reg_params, iap_working_area->address, 0, 10000,
812 &armv7m_info);
813 break;
814 case LPC2000_V1:
815 case LPC2000_V2:
816 /* IAP stack */
817 init_reg_param(&reg_params[3], "sp_svc", 32, PARAM_OUT);
818 buf_set_u32(reg_params[3].value, 0, 32,
819 iap_working_area->address + IAP_CODE_LEN + lpc2000_info->iap_max_stack);
820
821 /* return address */
822 init_reg_param(&reg_params[4], "lr_svc", 32, PARAM_OUT);
823 buf_set_u32(reg_params[4].value, 0, 32, iap_working_area->address + 0x04);
824
825 target_run_algorithm(target, 2, mem_params, 5, reg_params, iap_working_area->address,
826 iap_working_area->address + 0x4, 10000, &arm_algo);
827 break;
828 default:
829 LOG_ERROR("BUG: unknown lpc2000->variant encountered");
830 exit(-1);
831 }
832
833 int status_code = target_buffer_get_u32(target, mem_params[1].value);
834 result_table[0] = target_buffer_get_u32(target, mem_params[1].value + 0x04);
835 result_table[1] = target_buffer_get_u32(target, mem_params[1].value + 0x08);
836 result_table[2] = target_buffer_get_u32(target, mem_params[1].value + 0x0c);
837 result_table[3] = target_buffer_get_u32(target, mem_params[1].value + 0x10);
838
839 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
840 ") completed with result = %8.8x",
841 code, param_table[0], param_table[1], param_table[2], param_table[3], param_table[4], status_code);
842
843 destroy_mem_param(&mem_params[0]);
844 destroy_mem_param(&mem_params[1]);
845
846 destroy_reg_param(&reg_params[0]);
847 destroy_reg_param(&reg_params[1]);
848 destroy_reg_param(&reg_params[2]);
849 destroy_reg_param(&reg_params[3]);
850 destroy_reg_param(&reg_params[4]);
851
852 return status_code;
853 }
854
855 static int lpc2000_iap_blank_check(struct flash_bank *bank, unsigned int first,
856 unsigned int last)
857 {
858 if (last >= bank->num_sectors)
859 return ERROR_FLASH_SECTOR_INVALID;
860
861 uint32_t param_table[5] = {0};
862 uint32_t result_table[4];
863 struct working_area *iap_working_area;
864
865 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
866
867 if (retval != ERROR_OK)
868 return retval;
869
870 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
871 if (lpc2000_info->variant == LPC4300)
872 param_table[2] = lpc2000_info->lpc4300_bank;
873
874 for (unsigned int i = first; i <= last && retval == ERROR_OK; i++) {
875 /* check single sector */
876 param_table[0] = param_table[1] = i;
877 int status_code = lpc2000_iap_call(bank, iap_working_area, 53, param_table, result_table);
878
879 switch (status_code) {
880 case ERROR_FLASH_OPERATION_FAILED:
881 retval = ERROR_FLASH_OPERATION_FAILED;
882 break;
883 case LPC2000_CMD_SUCCESS:
884 bank->sectors[i].is_erased = 1;
885 break;
886 case LPC2000_SECTOR_NOT_BLANK:
887 bank->sectors[i].is_erased = 0;
888 break;
889 case LPC2000_INVALID_SECTOR:
890 bank->sectors[i].is_erased = 0;
891 break;
892 case LPC2000_BUSY:
893 retval = ERROR_FLASH_BUSY;
894 break;
895 default:
896 LOG_ERROR("BUG: unknown LPC2000 status code %i", status_code);
897 exit(-1);
898 }
899 }
900
901 struct target *target = bank->target;
902 target_free_working_area(target, iap_working_area);
903
904 return retval;
905 }
906
907 /*
908 * flash bank lpc2000 <base> <size> 0 0 <target#> <lpc_variant> <cclk> [calc_checksum]
909 */
910 FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
911 {
912 if (CMD_ARGC < 8)
913 return ERROR_COMMAND_SYNTAX_ERROR;
914
915 struct lpc2000_flash_bank *lpc2000_info = calloc(1, sizeof(*lpc2000_info));
916 lpc2000_info->probed = false;
917
918 bank->driver_priv = lpc2000_info;
919
920 if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0) {
921 lpc2000_info->variant = LPC2000_V1;
922 } else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0) {
923 lpc2000_info->variant = LPC2000_V2;
924 } else if (strcmp(CMD_ARGV[6], "lpc1700") == 0 || strcmp(CMD_ARGV[6], "lpc4000") == 0) {
925 lpc2000_info->variant = LPC1700;
926 } else if (strcmp(CMD_ARGV[6], "lpc1800") == 0 || strcmp(CMD_ARGV[6], "lpc4300") == 0) {
927 lpc2000_info->variant = LPC4300;
928 } else if (strcmp(CMD_ARGV[6], "lpc800") == 0) {
929 lpc2000_info->variant = LPC800;
930 } else if (strcmp(CMD_ARGV[6], "lpc1100") == 0) {
931 lpc2000_info->variant = LPC1100;
932 } else if (strcmp(CMD_ARGV[6], "lpc1500") == 0) {
933 lpc2000_info->variant = LPC1500;
934 } else if (strcmp(CMD_ARGV[6], "lpc54100") == 0) {
935 lpc2000_info->variant = LPC54100;
936 } else if (strcmp(CMD_ARGV[6], "auto") == 0) {
937 lpc2000_info->variant = LPC_AUTO;
938 } else {
939 LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
940 free(lpc2000_info);
941 return ERROR_FLASH_BANK_INVALID;
942 }
943
944 /* Maximum size required for the IAP stack.
945 This value only gets used when probing, only for auto, lpc1100 and lpc1700.
946 We use the maximum size for any part supported by the driver(!) to be safe
947 in case the auto variant is mistakenly used on a MCU from one of the series
948 for which we don't support auto-probing. */
949 lpc2000_info->iap_max_stack = 208;
950
951 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[7], lpc2000_info->cclk);
952 lpc2000_info->calc_checksum = 0;
953
954 uint32_t temp_base = 0;
955 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], temp_base);
956 if (temp_base >= 0x1B000000)
957 lpc2000_info->lpc4300_bank = 1; /* bank B */
958 else
959 lpc2000_info->lpc4300_bank = 0; /* bank A */
960
961 if (CMD_ARGC >= 9) {
962 if (strcmp(CMD_ARGV[8], "calc_checksum") == 0)
963 lpc2000_info->calc_checksum = 1;
964 }
965 if (CMD_ARGC >= 10 && !lpc2000_info->iap_entry_alternative)
966 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[9], lpc2000_info->iap_entry_alternative);
967
968 return ERROR_OK;
969 }
970
971 static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
972 unsigned int last)
973 {
974 if (bank->target->state != TARGET_HALTED) {
975 LOG_ERROR("Target not halted");
976 return ERROR_TARGET_NOT_HALTED;
977 }
978
979 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
980 uint32_t param_table[5] = {0};
981
982 param_table[0] = first;
983 param_table[1] = last;
984
985 if (lpc2000_info->variant == LPC4300)
986 param_table[2] = lpc2000_info->lpc4300_bank;
987 else
988 param_table[2] = lpc2000_info->cclk;
989
990 uint32_t result_table[4];
991 struct working_area *iap_working_area;
992
993 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
994
995 if (retval != ERROR_OK)
996 return retval;
997
998 if (lpc2000_info->variant == LPC4300)
999 /* Init IAP Anyway */
1000 lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
1001
1002 /* Prepare sectors */
1003 int status_code = lpc2000_iap_call(bank, iap_working_area, 50, param_table, result_table);
1004 switch (status_code) {
1005 case ERROR_FLASH_OPERATION_FAILED:
1006 retval = ERROR_FLASH_OPERATION_FAILED;
1007 break;
1008 case LPC2000_CMD_SUCCESS:
1009 break;
1010 case LPC2000_INVALID_SECTOR:
1011 retval = ERROR_FLASH_SECTOR_INVALID;
1012 break;
1013 default:
1014 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
1015 retval = ERROR_FLASH_OPERATION_FAILED;
1016 break;
1017 }
1018
1019 if (retval == ERROR_OK) {
1020 /* Erase sectors */
1021 param_table[2] = lpc2000_info->cclk;
1022 if (lpc2000_info->variant == LPC4300)
1023 param_table[3] = lpc2000_info->lpc4300_bank;
1024
1025 status_code = lpc2000_iap_call(bank, iap_working_area, 52, param_table, result_table);
1026 switch (status_code) {
1027 case ERROR_FLASH_OPERATION_FAILED:
1028 retval = ERROR_FLASH_OPERATION_FAILED;
1029 break;
1030 case LPC2000_CMD_SUCCESS:
1031 break;
1032 case LPC2000_INVALID_SECTOR:
1033 retval = ERROR_FLASH_SECTOR_INVALID;
1034 break;
1035 default:
1036 LOG_WARNING("lpc2000 erase sectors returned %i", status_code);
1037 retval = ERROR_FLASH_OPERATION_FAILED;
1038 break;
1039 }
1040 }
1041
1042 struct target *target = bank->target;
1043 target_free_working_area(target, iap_working_area);
1044
1045 return retval;
1046 }
1047
1048 static int lpc2000_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
1049 {
1050 struct target *target = bank->target;
1051
1052 if (bank->target->state != TARGET_HALTED) {
1053 LOG_ERROR("Target not halted");
1054 return ERROR_TARGET_NOT_HALTED;
1055 }
1056
1057 if (offset + count > bank->size)
1058 return ERROR_FLASH_DST_OUT_OF_BANK;
1059
1060 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1061
1062 uint32_t dst_min_alignment = lpc2000_info->cmd51_dst_boundary;
1063
1064 if (offset % dst_min_alignment) {
1065 LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, offset, dst_min_alignment);
1066 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
1067 }
1068
1069 int first_sector = 0;
1070 int last_sector = 0;
1071
1072 for (unsigned int i = 0; i < bank->num_sectors; i++) {
1073 if (offset >= bank->sectors[i].offset)
1074 first_sector = i;
1075 if (offset + DIV_ROUND_UP(count, dst_min_alignment) * dst_min_alignment > bank->sectors[i].offset)
1076 last_sector = i;
1077 }
1078
1079 LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
1080
1081 /* check if exception vectors should be flashed */
1082 if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum) {
1083 assert(lpc2000_info->checksum_vector < 8);
1084 uint32_t checksum = 0;
1085 for (int i = 0; i < 8; i++) {
1086 LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32, i * 4, buf_get_u32(buffer + (i * 4), 0, 32));
1087 if (i != lpc2000_info->checksum_vector)
1088 checksum += buf_get_u32(buffer + (i * 4), 0, 32);
1089 }
1090 checksum = 0 - checksum;
1091 LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
1092
1093 uint32_t original_value = buf_get_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32);
1094 if (original_value != checksum) {
1095 LOG_WARNING("Boot verification checksum in image (0x%8.8" PRIx32 ") to be written to flash is "
1096 "different from calculated vector checksum (0x%8.8" PRIx32 ").", original_value, checksum);
1097 LOG_WARNING("OpenOCD will write the correct checksum. To remove this warning modify build tools on developer PC to inject correct LPC vector "
1098 "checksum.");
1099 }
1100
1101 /* FIXME: WARNING! This code is broken because it modifies the callers buffer in place. */
1102 buf_set_u32((uint8_t *)buffer + (lpc2000_info->checksum_vector * 4), 0, 32, checksum);
1103 }
1104
1105 struct working_area *iap_working_area;
1106
1107 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
1108
1109 if (retval != ERROR_OK)
1110 return retval;
1111
1112 struct working_area *download_area;
1113
1114 /* allocate a working area */
1115 if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK) {
1116 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
1117 target_free_working_area(target, iap_working_area);
1118 return ERROR_FLASH_OPERATION_FAILED;
1119 }
1120
1121 uint32_t bytes_remaining = count;
1122 uint32_t bytes_written = 0;
1123 uint32_t param_table[5] = {0};
1124 uint32_t result_table[4];
1125
1126 if (lpc2000_info->variant == LPC4300)
1127 /* Init IAP Anyway */
1128 lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
1129
1130 while (bytes_remaining > 0) {
1131 uint32_t thisrun_bytes;
1132 if (bytes_remaining >= lpc2000_info->cmd51_max_buffer)
1133 thisrun_bytes = lpc2000_info->cmd51_max_buffer;
1134 else
1135 thisrun_bytes = lpc2000_info->cmd51_dst_boundary;
1136
1137 /* Prepare sectors */
1138 param_table[0] = first_sector;
1139 param_table[1] = last_sector;
1140
1141 if (lpc2000_info->variant == LPC4300)
1142 param_table[2] = lpc2000_info->lpc4300_bank;
1143 else
1144 param_table[2] = lpc2000_info->cclk;
1145
1146 int status_code = lpc2000_iap_call(bank, iap_working_area, 50, param_table, result_table);
1147 switch (status_code) {
1148 case ERROR_FLASH_OPERATION_FAILED:
1149 retval = ERROR_FLASH_OPERATION_FAILED;
1150 break;
1151 case LPC2000_CMD_SUCCESS:
1152 break;
1153 case LPC2000_INVALID_SECTOR:
1154 retval = ERROR_FLASH_SECTOR_INVALID;
1155 break;
1156 default:
1157 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
1158 retval = ERROR_FLASH_OPERATION_FAILED;
1159 break;
1160 }
1161
1162 /* Exit if error occurred */
1163 if (retval != ERROR_OK)
1164 break;
1165
1166 if (bytes_remaining >= thisrun_bytes) {
1167 retval = target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written);
1168 if (retval != ERROR_OK) {
1169 retval = ERROR_FLASH_OPERATION_FAILED;
1170 break;
1171 }
1172 } else {
1173 uint8_t *last_buffer = malloc(thisrun_bytes);
1174 memcpy(last_buffer, buffer + bytes_written, bytes_remaining);
1175 memset(last_buffer + bytes_remaining, 0xff, thisrun_bytes - bytes_remaining);
1176 target_write_buffer(bank->target, download_area->address, thisrun_bytes, last_buffer);
1177 free(last_buffer);
1178 }
1179
1180 LOG_DEBUG("writing 0x%" PRIx32 " bytes to address " TARGET_ADDR_FMT,
1181 thisrun_bytes, bank->base + offset + bytes_written);
1182
1183 /* Write data */
1184 param_table[0] = bank->base + offset + bytes_written;
1185 param_table[1] = download_area->address;
1186 param_table[2] = thisrun_bytes;
1187 param_table[3] = lpc2000_info->cclk;
1188 status_code = lpc2000_iap_call(bank, iap_working_area, 51, param_table, result_table);
1189 switch (status_code) {
1190 case ERROR_FLASH_OPERATION_FAILED:
1191 retval = ERROR_FLASH_OPERATION_FAILED;
1192 break;
1193 case LPC2000_CMD_SUCCESS:
1194 break;
1195 case LPC2000_INVALID_SECTOR:
1196 retval = ERROR_FLASH_SECTOR_INVALID;
1197 break;
1198 default:
1199 LOG_WARNING("lpc2000 returned %i", status_code);
1200 retval = ERROR_FLASH_OPERATION_FAILED;
1201 break;
1202 }
1203
1204 /* Exit if error occurred */
1205 if (retval != ERROR_OK)
1206 break;
1207
1208 if (bytes_remaining > thisrun_bytes)
1209 bytes_remaining -= thisrun_bytes;
1210 else
1211 bytes_remaining = 0;
1212 bytes_written += thisrun_bytes;
1213 }
1214
1215 target_free_working_area(target, iap_working_area);
1216 target_free_working_area(target, download_area);
1217
1218 return retval;
1219 }
1220
1221 static int get_lpc2000_part_id(struct flash_bank *bank, uint32_t *part_id)
1222 {
1223 if (bank->target->state != TARGET_HALTED) {
1224 LOG_ERROR("Target not halted");
1225 return ERROR_TARGET_NOT_HALTED;
1226 }
1227
1228 uint32_t param_table[5] = {0};
1229 uint32_t result_table[4];
1230 struct working_area *iap_working_area;
1231
1232 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
1233
1234 if (retval != ERROR_OK)
1235 return retval;
1236
1237 /* The status seems to be bogus with the part ID command on some IAP
1238 firmwares, so ignore it. */
1239 lpc2000_iap_call(bank, iap_working_area, 54, param_table, result_table);
1240
1241 struct target *target = bank->target;
1242 target_free_working_area(target, iap_working_area);
1243
1244 /* If the result is zero, the command probably didn't work out. */
1245 if (result_table[0] == 0)
1246 return LPC2000_INVALID_COMMAND;
1247
1248 *part_id = result_table[0];
1249 return LPC2000_CMD_SUCCESS;
1250 }
1251
1252 static int lpc2000_auto_probe_flash(struct flash_bank *bank)
1253 {
1254 uint32_t part_id;
1255 int retval;
1256 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1257
1258 if (bank->target->state != TARGET_HALTED) {
1259 LOG_ERROR("Target not halted");
1260 return ERROR_TARGET_NOT_HALTED;
1261 }
1262
1263 retval = get_lpc2000_part_id(bank, &part_id);
1264 if (retval != LPC2000_CMD_SUCCESS) {
1265 LOG_ERROR("Could not get part ID");
1266 return retval;
1267 }
1268
1269 switch (part_id) {
1270 case LPC1110_1:
1271 case LPC1110_2:
1272 lpc2000_info->variant = LPC1100;
1273 bank->size = 4 * 1024;
1274 break;
1275
1276 case LPC1111_002_1:
1277 case LPC1111_002_2:
1278 case LPC1111_101_1:
1279 case LPC1111_101_2:
1280 case LPC1111_103_1:
1281 case LPC1111_201_1:
1282 case LPC1111_201_2:
1283 case LPC1111_203_1:
1284 case LPC11A11_001_1:
1285 case LPC11E11_101:
1286 case LPC1311:
1287 case LPC1311_1:
1288 lpc2000_info->variant = LPC1100;
1289 bank->size = 8 * 1024;
1290 break;
1291
1292 case LPC1112_101_1:
1293 case LPC1112_101_2:
1294 case LPC1112_102_1:
1295 case LPC1112_102_2:
1296 case LPC1112_103_1:
1297 case LPC1112_201_1:
1298 case LPC1112_201_2:
1299 case LPC1112_203_1:
1300 case LPC11A02_1:
1301 case LPC11C12_301_1:
1302 case LPC11C22_301_1:
1303 case LPC11A12_101_1:
1304 case LPC11E12_201:
1305 case LPC11U12_201_1:
1306 case LPC11U12_201_2:
1307 case LPC1342:
1308 lpc2000_info->variant = LPC1100;
1309 bank->size = 16 * 1024;
1310 break;
1311
1312 case LPC1113_201_1:
1313 case LPC1113_201_2:
1314 case LPC1113_203_1:
1315 case LPC1113_301_1:
1316 case LPC1113_301_2:
1317 case LPC1113_303_1:
1318 case LPC11A13_201_1:
1319 case LPC11E13_301:
1320 case LPC11U13_201_1:
1321 case LPC11U13_201_2:
1322 case LPC11U23_301:
1323 lpc2000_info->variant = LPC1100;
1324 bank->size = 24 * 1024;
1325 break;
1326
1327 case LPC1114_102_1:
1328 case LPC1114_102_2:
1329 case LPC1114_201_1:
1330 case LPC1114_201_2:
1331 case LPC1114_203_1:
1332 case LPC1114_301_1:
1333 case LPC1114_301_2:
1334 case LPC1114_303_1:
1335 case LPC11A04_1:
1336 case LPC11A14_301_1:
1337 case LPC11A14_301_2:
1338 case LPC11C14_301_1:
1339 case LPC11C24_301_1:
1340 case LPC11E14_401:
1341 case LPC11U14_201_1:
1342 case LPC11U14_201_2:
1343 case LPC11U24_301:
1344 case LPC11U24_401:
1345 case LPC1313:
1346 case LPC1313_1:
1347 case LPC1315:
1348 case LPC1343:
1349 case LPC1343_1:
1350 case LPC1345:
1351 lpc2000_info->variant = LPC1100;
1352 bank->size = 32 * 1024;
1353 break;
1354
1355 case LPC1751_1:
1356 case LPC1751_2:
1357 lpc2000_info->variant = LPC1700;
1358 bank->size = 32 * 1024;
1359 break;
1360
1361 case LPC11U34_311:
1362 lpc2000_info->variant = LPC1100;
1363 bank->size = 40 * 1024;
1364 break;
1365
1366 case LPC1114_323_1:
1367 case LPC11U34_421:
1368 case LPC1316:
1369 case LPC1346:
1370 lpc2000_info->variant = LPC1100;
1371 bank->size = 48 * 1024;
1372 break;
1373
1374 case LPC1114_333_1:
1375 lpc2000_info->variant = LPC1100;
1376 bank->size = 56 * 1024;
1377 break;
1378
1379 case LPC1115_303_1:
1380 case LPC11U35_401:
1381 case LPC11U35_501:
1382 case LPC11E66:
1383 case LPC11U66:
1384 case LPC1317:
1385 case LPC1347:
1386 lpc2000_info->variant = LPC1100;
1387 bank->size = 64 * 1024;
1388 break;
1389
1390 case LPC1752:
1391 case LPC4072:
1392 lpc2000_info->variant = LPC1700;
1393 bank->size = 64 * 1024;
1394 break;
1395
1396 case LPC11E36_501:
1397 case LPC11U36_401:
1398 lpc2000_info->variant = LPC1100;
1399 bank->size = 96 * 1024;
1400 break;
1401
1402 case LPC11E37_401:
1403 case LPC11E37_501:
1404 case LPC11U37_401:
1405 case LPC11U37H_401:
1406 case LPC11U37_501:
1407 case LPC11E67:
1408 case LPC11E68:
1409 case LPC11U67_1:
1410 case LPC11U67_2:
1411 lpc2000_info->variant = LPC1100;
1412 bank->size = 128 * 1024;
1413 break;
1414
1415 case LPC1754:
1416 case LPC1764:
1417 case LPC1774:
1418 case LPC4074:
1419 lpc2000_info->variant = LPC1700;
1420 bank->size = 128 * 1024;
1421 break;
1422
1423 case LPC11U68_1:
1424 case LPC11U68_2:
1425 lpc2000_info->variant = LPC1100;
1426 bank->size = 256 * 1024;
1427 break;
1428
1429 case LPC1756:
1430 case LPC1763:
1431 case LPC1765:
1432 case LPC1766:
1433 case LPC1776:
1434 case LPC1785:
1435 case LPC1786:
1436 case LPC4076:
1437 lpc2000_info->variant = LPC1700;
1438 bank->size = 256 * 1024;
1439 break;
1440
1441 case LPC1758:
1442 case LPC1759:
1443 case LPC1767:
1444 case LPC1768:
1445 case LPC1769:
1446 case LPC1777:
1447 case LPC1778:
1448 case LPC1787:
1449 case LPC1788:
1450 case LPC4078:
1451 case LPC4088:
1452 lpc2000_info->variant = LPC1700;
1453 bank->size = 512 * 1024;
1454 break;
1455
1456 case LPC810_021:
1457 lpc2000_info->variant = LPC800;
1458 bank->size = 4 * 1024;
1459 break;
1460
1461 case LPC811_001:
1462 lpc2000_info->variant = LPC800;
1463 bank->size = 8 * 1024;
1464 break;
1465
1466 case LPC812_101:
1467 case LPC812_101_1:
1468 case LPC812_101_2:
1469 case LPC812_101_3:
1470 case LPC822_101:
1471 case LPC822_101_1:
1472 lpc2000_info->variant = LPC800;
1473 bank->size = 16 * 1024;
1474 break;
1475
1476 case LPC824_201:
1477 case LPC824_201_1:
1478 lpc2000_info->variant = LPC800;
1479 bank->size = 32 * 1024;
1480 break;
1481
1482 case LPC8N04:
1483 case NHS3100:
1484 case NHS3152:
1485 case NHS3153:
1486 lpc2000_info->variant = LPC800;
1487 bank->size = 30 * 1024;
1488 break;
1489
1490 case LPC844_201:
1491 case LPC844_201_1:
1492 case LPC844_201_2:
1493 case LPC845_301:
1494 case LPC845_301_1:
1495 case LPC845_301_2:
1496 case LPC845_301_3:
1497 lpc2000_info->variant = LPC800;
1498 bank->size = 64 * 1024;
1499 break;
1500
1501 default:
1502 LOG_ERROR("BUG: unknown Part ID encountered: 0x%" PRIx32, part_id);
1503 exit(-1);
1504 }
1505
1506 return ERROR_OK;
1507 }
1508
1509 static int lpc2000_probe(struct flash_bank *bank)
1510 {
1511 int status;
1512 uint32_t part_id;
1513 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1514
1515 if (!lpc2000_info->probed) {
1516 if (lpc2000_info->variant == LPC_AUTO) {
1517 status = lpc2000_auto_probe_flash(bank);
1518 if (status != ERROR_OK)
1519 return status;
1520 } else if (lpc2000_info->variant == LPC1100 || lpc2000_info->variant == LPC1700) {
1521 status = get_lpc2000_part_id(bank, &part_id);
1522 if (status == LPC2000_CMD_SUCCESS)
1523 LOG_INFO("If auto-detection fails for this part, please email "
1524 "openocd-devel@lists.sourceforge.net, citing part id 0x%" PRIx32 ".\n", part_id);
1525 }
1526
1527 lpc2000_build_sector_list(bank);
1528 lpc2000_info->probed = true;
1529 }
1530
1531 return ERROR_OK;
1532 }
1533
1534 static int lpc2000_erase_check(struct flash_bank *bank)
1535 {
1536 if (bank->target->state != TARGET_HALTED) {
1537 LOG_ERROR("Target not halted");
1538 return ERROR_TARGET_NOT_HALTED;
1539 }
1540
1541 return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
1542 }
1543
1544 static int get_lpc2000_info(struct flash_bank *bank, struct command_invocation *cmd)
1545 {
1546 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1547
1548 command_print_sameline(cmd, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz",
1549 lpc2000_info->variant, lpc2000_info->cclk);
1550
1551 return ERROR_OK;
1552 }
1553
1554 COMMAND_HANDLER(lpc2000_handle_part_id_command)
1555 {
1556 if (CMD_ARGC < 1)
1557 return ERROR_COMMAND_SYNTAX_ERROR;
1558
1559 struct flash_bank *bank;
1560 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1561 if (retval != ERROR_OK)
1562 return retval;
1563
1564 if (bank->target->state != TARGET_HALTED) {
1565 LOG_ERROR("Target not halted");
1566 return ERROR_TARGET_NOT_HALTED;
1567 }
1568
1569 uint32_t part_id;
1570 int status_code = get_lpc2000_part_id(bank, &part_id);
1571 if (status_code != 0x0) {
1572 if (status_code == ERROR_FLASH_OPERATION_FAILED) {
1573 command_print(CMD, "no sufficient working area specified, can't access LPC2000 IAP interface");
1574 } else
1575 command_print(CMD, "lpc2000 IAP returned status code %i", status_code);
1576 } else
1577 command_print(CMD, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
1578
1579 return retval;
1580 }
1581
1582 static const struct command_registration lpc2000_exec_command_handlers[] = {
1583 {
1584 .name = "part_id",
1585 .handler = lpc2000_handle_part_id_command,
1586 .mode = COMMAND_EXEC,
1587 .help = "print part id of lpc2000 flash bank <num>",
1588 .usage = "<bank>",
1589 },
1590 COMMAND_REGISTRATION_DONE
1591 };
1592 static const struct command_registration lpc2000_command_handlers[] = {
1593 {
1594 .name = "lpc2000",
1595 .mode = COMMAND_ANY,
1596 .help = "lpc2000 flash command group",
1597 .usage = "",
1598 .chain = lpc2000_exec_command_handlers,
1599 },
1600 COMMAND_REGISTRATION_DONE
1601 };
1602
1603 const struct flash_driver lpc2000_flash = {
1604 .name = "lpc2000",
1605 .commands = lpc2000_command_handlers,
1606 .flash_bank_command = lpc2000_flash_bank_command,
1607 .erase = lpc2000_erase,
1608 .write = lpc2000_write,
1609 .read = default_flash_read,
1610 .probe = lpc2000_probe,
1611 .auto_probe = lpc2000_probe,
1612 .erase_check = lpc2000_erase_check,
1613 .info = get_lpc2000_info,
1614 .free_driver_priv = default_flash_free_driver_priv,
1615 };
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)