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