77beac1ca1630650dea8f05f9943392abfb2c65f
[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, see <http://www.gnu.org/licenses/>. *
27 ***************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "imp.h"
34 #include <helper/binarybuffer.h>
35 #include <target/algorithm.h>
36 #include <target/arm_opcodes.h>
37 #include <target/armv7m.h>
38
39 /**
40 * @file
41 * flash programming support for NXP LPC8xx,LPC1xxx,LPC4xxx,LP5410x and LPC2xxx devices.
42 *
43 * @todo Provide a way to update CCLK after declaring the flash bank. The value which is correct after chip reset will
44 * rarely still work right after the clocks switch to use the PLL (e.g. 4MHz --> 100 MHz).
45 */
46 /*
47 * currently supported devices:
48 * variant 1 (lpc2000_v1):
49 * - 2104 | 5 | 6
50 * - 2114 | 9
51 * - 2124 | 9
52 * - 2194
53 * - 2212 | 4
54 * - 2292 | 4
55 *
56 * variant 2 (lpc2000_v2):
57 * - 213x
58 * - 214x
59 * - 2101 | 2 | 3
60 * - 2364 | 6 | 8
61 * - 2378
62 *
63 * lpc1700:
64 * - 175x
65 * - 176x (tested with LPC1768)
66 * - 177x
67 * - 178x (tested with LPC1788)
68 *
69 * lpc4000: (lpc1700's alias)
70 * - 407x
71 * - 408x (tested with LPC4088)
72 *
73 * lpc4300: (also available as lpc1800 - alias)
74 * - 43x2 | 3 | 5 | 7 (tested with LPC4337/LPC4357)
75 * - 18x2 | 3 | 5 | 7
76 *
77 * lpc800:
78 * - 810 | 1 | 2 (tested with LPC810/LPC811/LPC812)
79 * - 822 | 4 (tested with LPC824)
80 *
81 * lpc1100:
82 * - 11xx
83 * - 11Axx
84 * - 11Cxx
85 * - 11Dxx
86 * - 11Exx
87 * - 11Uxx (tested with LPC11U34)
88 * - 131x
89 * - 134x
90 *
91 * lpc1500:
92 * - 15x7 | 8 | 9 (tested with LPC1549)
93 *
94 * lpc54100:
95 * - 54101 | 2 (tested with LPC54102)
96 *
97 * The auto variant auto-detects parts from the following series:
98 * - 11xx
99 * - 11Axx
100 * - 11Cxx
101 * - 11Dxx
102 * - 11Exx
103 * - 11Uxx
104 * - 131x
105 * - 134x
106 * - 175x
107 * - 176x
108 * - 177x
109 * - 178x
110 * - 407x
111 * - 408x
112 * - 81x
113 * - 82x
114 */
115
116 /* Part IDs for autodetection */
117 /* A script which can automatically extract part ids from user manuals is available here:
118 * https://github.com/lgeek/lpc_part_ids
119 */
120 #define LPC1110_1 0x0A07102B
121 #define LPC1110_2 0x1A07102B
122 #define LPC1111_002_1 0x0A16D02B
123 #define LPC1111_002_2 0x1A16D02B
124 #define LPC1111_101_1 0x041E502B
125 #define LPC1111_101_2 0x2516D02B
126 #define LPC1111_103_1 0x00010013
127 #define LPC1111_201_1 0x0416502B
128 #define LPC1111_201_2 0x2516902B
129 #define LPC1111_203_1 0x00010012
130 #define LPC1112_101_1 0x042D502B
131 #define LPC1112_101_2 0x2524D02B
132 #define LPC1112_102_1 0x0A24902B
133 #define LPC1112_102_2 0x1A24902B
134 #define LPC1112_103_1 0x00020023
135 #define LPC1112_201_1 0x0425502B
136 #define LPC1112_201_2 0x2524902B
137 #define LPC1112_203_1 0x00020022
138 #define LPC1113_201_1 0x0434502B
139 #define LPC1113_201_2 0x2532902B
140 #define LPC1113_203_1 0x00030032
141 #define LPC1113_301_1 0x0434102B
142 #define LPC1113_301_2 0x2532102B
143 #define LPC1113_303_1 0x00030030
144 #define LPC1114_102_1 0x0A40902B
145 #define LPC1114_102_2 0x1A40902B
146 #define LPC1114_201_1 0x0444502B
147 #define LPC1114_201_2 0x2540902B
148 #define LPC1114_203_1 0x00040042
149 #define LPC1114_301_1 0x0444102B
150 #define LPC1114_301_2 0x2540102B
151 #define LPC1114_303_1 0x00040040
152 #define LPC1114_323_1 0x00040060
153 #define LPC1114_333_1 0x00040070
154 #define LPC1115_303_1 0x00050080
155
156 #define LPC11A02_1 0x4D4C802B
157 #define LPC11A04_1 0x4D80002B
158 #define LPC11A11_001_1 0x455EC02B
159 #define LPC11A12_101_1 0x4574802B
160 #define LPC11A13_201_1 0x458A402B
161 #define LPC11A14_301_1 0x35A0002B
162 #define LPC11A14_301_2 0x45A0002B
163
164 #define LPC11C12_301_1 0x1421102B
165 #define LPC11C14_301_1 0x1440102B
166 #define LPC11C22_301_1 0x1431102B
167 #define LPC11C24_301_1 0x1430102B
168
169 #define LPC11E11_101 0x293E902B
170 #define LPC11E12_201 0x2954502B
171 #define LPC11E13_301 0x296A102B
172 #define LPC11E14_401 0x2980102B
173 #define LPC11E36_501 0x00009C41
174 #define LPC11E37_401 0x00007C45
175 #define LPC11E37_501 0x00007C41
176
177 #define LPC11U12_201_1 0x095C802B
178 #define LPC11U12_201_2 0x295C802B
179 #define LPC11U13_201_1 0x097A802B
180 #define LPC11U13_201_2 0x297A802B
181 #define LPC11U14_201_1 0x0998802B
182 #define LPC11U14_201_2 0x2998802B
183 #define LPC11U23_301 0x2972402B
184 #define LPC11U24_301 0x2988402B
185 #define LPC11U24_401 0x2980002B
186 #define LPC11U34_311 0x0003D440
187 #define LPC11U34_421 0x0001CC40
188 #define LPC11U35_401 0x0001BC40
189 #define LPC11U35_501 0x0000BC40
190 #define LPC11U36_401 0x00019C40
191 #define LPC11U37_401 0x00017C40
192 #define LPC11U37H_401 0x00007C44
193 #define LPC11U37_501 0x00007C40
194
195 #define LPC11E66 0x0000DCC1
196 #define LPC11E67 0x0000BC81
197 #define LPC11E68 0x00007C01
198
199 #define LPC11U66 0x0000DCC8
200 #define LPC11U67_1 0x0000BC88
201 #define LPC11U67_2 0x0000BC80
202 #define LPC11U68_1 0x00007C08
203 #define LPC11U68_2 0x00007C00
204
205 #define LPC1311 0x2C42502B
206 #define LPC1311_1 0x1816902B
207 #define LPC1313 0x2C40102B
208 #define LPC1313_1 0x1830102B
209 #define LPC1315 0x3A010523
210 #define LPC1316 0x1A018524
211 #define LPC1317 0x1A020525
212 #define LPC1342 0x3D01402B
213 #define LPC1343 0x3D00002B
214 #define LPC1343_1 0x3000002B
215 #define LPC1345 0x28010541
216 #define LPC1346 0x08018542
217 #define LPC1347 0x08020543
218
219 #define LPC1751_1 0x25001110
220 #define LPC1751_2 0x25001118
221 #define LPC1752 0x25001121
222 #define LPC1754 0x25011722
223 #define LPC1756 0x25011723
224 #define LPC1758 0x25013F37
225 #define LPC1759 0x25113737
226 #define LPC1763 0x26012033
227 #define LPC1764 0x26011922
228 #define LPC1765 0x26013733
229 #define LPC1766 0x26013F33
230 #define LPC1767 0x26012837
231 #define LPC1768 0x26013F37
232 #define LPC1769 0x26113F37
233 #define LPC1774 0x27011132
234 #define LPC1776 0x27191F43
235 #define LPC1777 0x27193747
236 #define LPC1778 0x27193F47
237 #define LPC1785 0x281D1743
238 #define LPC1786 0x281D1F43
239 #define LPC1787 0x281D3747
240 #define LPC1788 0x281D3F47
241
242 #define LPC4072 0x47011121
243 #define LPC4074 0x47011132
244 #define LPC4076 0x47191F43
245 #define LPC4078 0x47193F47
246 #define LPC4088 0x481D3F47
247
248 #define LPC810_021 0x00008100
249 #define LPC811_001 0x00008110
250 #define LPC812_101 0x00008120
251 #define LPC812_101_1 0x00008121
252 #define LPC812_101_2 0x00008122
253 #define LPC812_101_3 0x00008123
254
255 #define LPC822_101 0x00008221
256 #define LPC822_101_1 0x00008222
257 #define LPC824_201 0x00008241
258 #define LPC824_201_1 0x00008242
259
260 #define IAP_CODE_LEN 0x34
261
262 #define LPC11xx_REG_SECTORS 24
263
264 typedef enum {
265 lpc2000_v1,
266 lpc2000_v2,
267 lpc1700,
268 lpc4300,
269 lpc800,
270 lpc1100,
271 lpc1500,
272 lpc54100,
273 lpc_auto,
274 } lpc2000_variant;
275
276 struct lpc2000_flash_bank {
277 lpc2000_variant variant;
278 uint32_t cclk;
279 int cmd51_dst_boundary;
280 int calc_checksum;
281 uint32_t cmd51_max_buffer;
282 int checksum_vector;
283 uint32_t iap_max_stack;
284 uint32_t lpc4300_bank;
285 bool probed;
286 };
287
288 enum lpc2000_status_codes {
289 LPC2000_CMD_SUCCESS = 0,
290 LPC2000_INVALID_COMMAND = 1,
291 LPC2000_SRC_ADDR_ERROR = 2,
292 LPC2000_DST_ADDR_ERROR = 3,
293 LPC2000_SRC_ADDR_NOT_MAPPED = 4,
294 LPC2000_DST_ADDR_NOT_MAPPED = 5,
295 LPC2000_COUNT_ERROR = 6,
296 LPC2000_INVALID_SECTOR = 7,
297 LPC2000_SECTOR_NOT_BLANK = 8,
298 LPC2000_SECTOR_NOT_PREPARED = 9,
299 LPC2000_COMPARE_ERROR = 10,
300 LPC2000_BUSY = 11,
301 LPC2000_PARAM_ERROR = 12,
302 LPC2000_ADDR_ERROR = 13,
303 LPC2000_ADDR_NOT_MAPPED = 14,
304 LPC2000_CMD_NOT_LOCKED = 15,
305 LPC2000_INVALID_CODE = 16,
306 LPC2000_INVALID_BAUD_RATE = 17,
307 LPC2000_INVALID_STOP_BIT = 18,
308 LPC2000_CRP_ENABLED = 19,
309 LPC2000_INVALID_FLASH_UNIT = 20,
310 LPC2000_USER_CODE_CHECKSUM = 21,
311 LCP2000_ERROR_SETTING_ACTIVE_PARTITION = 22,
312 };
313
314 static int lpc2000_build_sector_list(struct flash_bank *bank)
315 {
316 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
317 uint32_t offset = 0;
318
319 /* default to a 4096 write buffer */
320 lpc2000_info->cmd51_max_buffer = 4096;
321
322 if (lpc2000_info->variant == lpc2000_v1) {
323 lpc2000_info->cmd51_dst_boundary = 512;
324 lpc2000_info->checksum_vector = 5;
325 lpc2000_info->iap_max_stack = 128;
326
327 /* variant 1 has different layout for 128kb and 256kb flashes */
328 if (bank->size == 128 * 1024) {
329 bank->num_sectors = 16;
330 bank->sectors = malloc(sizeof(struct flash_sector) * 16);
331 for (int i = 0; i < 16; i++) {
332 bank->sectors[i].offset = offset;
333 bank->sectors[i].size = 8 * 1024;
334 offset += bank->sectors[i].size;
335 bank->sectors[i].is_erased = -1;
336 bank->sectors[i].is_protected = 1;
337 }
338 } else if (bank->size == 256 * 1024) {
339 bank->num_sectors = 18;
340 bank->sectors = malloc(sizeof(struct flash_sector) * 18);
341
342 for (int i = 0; i < 8; i++) {
343 bank->sectors[i].offset = offset;
344 bank->sectors[i].size = 8 * 1024;
345 offset += bank->sectors[i].size;
346 bank->sectors[i].is_erased = -1;
347 bank->sectors[i].is_protected = 1;
348 }
349 for (int i = 8; i < 10; i++) {
350 bank->sectors[i].offset = offset;
351 bank->sectors[i].size = 64 * 1024;
352 offset += bank->sectors[i].size;
353 bank->sectors[i].is_erased = -1;
354 bank->sectors[i].is_protected = 1;
355 }
356 for (int i = 10; i < 18; i++) {
357 bank->sectors[i].offset = offset;
358 bank->sectors[i].size = 8 * 1024;
359 offset += bank->sectors[i].size;
360 bank->sectors[i].is_erased = -1;
361 bank->sectors[i].is_protected = 1;
362 }
363 } else {
364 LOG_ERROR("BUG: unknown bank->size encountered");
365 exit(-1);
366 }
367 } else if (lpc2000_info->variant == lpc2000_v2) {
368 lpc2000_info->cmd51_dst_boundary = 256;
369 lpc2000_info->checksum_vector = 5;
370 lpc2000_info->iap_max_stack = 128;
371
372 /* variant 2 has a uniform layout, only number of sectors differs */
373 switch (bank->size) {
374 case 4 * 1024:
375 lpc2000_info->cmd51_max_buffer = 1024;
376 bank->num_sectors = 1;
377 break;
378 case 8 * 1024:
379 lpc2000_info->cmd51_max_buffer = 1024;
380 bank->num_sectors = 2;
381 break;
382 case 16 * 1024:
383 bank->num_sectors = 4;
384 break;
385 case 32 * 1024:
386 bank->num_sectors = 8;
387 break;
388 case 64 * 1024:
389 bank->num_sectors = 9;
390 break;
391 case 128 * 1024:
392 bank->num_sectors = 11;
393 break;
394 case 256 * 1024:
395 bank->num_sectors = 15;
396 break;
397 case 500 * 1024:
398 bank->num_sectors = 27;
399 break;
400 case 512 * 1024:
401 case 504 * 1024:
402 bank->num_sectors = 28;
403 break;
404 default:
405 LOG_ERROR("BUG: unknown bank->size encountered");
406 exit(-1);
407 break;
408 }
409
410 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
411
412 for (int i = 0; i < bank->num_sectors; i++) {
413 if (i < 8) {
414 bank->sectors[i].offset = offset;
415 bank->sectors[i].size = 4 * 1024;
416 offset += bank->sectors[i].size;
417 bank->sectors[i].is_erased = -1;
418 bank->sectors[i].is_protected = 1;
419 } else if (i < 22) {
420 bank->sectors[i].offset = offset;
421 bank->sectors[i].size = 32 * 1024;
422 offset += bank->sectors[i].size;
423 bank->sectors[i].is_erased = -1;
424 bank->sectors[i].is_protected = 1;
425 } else if (i < 28) {
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 }
432 }
433 } else if (lpc2000_info->variant == lpc1700) {
434 lpc2000_info->cmd51_dst_boundary = 256;
435 lpc2000_info->checksum_vector = 7;
436 lpc2000_info->iap_max_stack = 128;
437
438 switch (bank->size) {
439 case 4 * 1024:
440 lpc2000_info->cmd51_max_buffer = 256;
441 bank->num_sectors = 1;
442 break;
443 case 8 * 1024:
444 lpc2000_info->cmd51_max_buffer = 512;
445 bank->num_sectors = 2;
446 break;
447 case 16 * 1024:
448 lpc2000_info->cmd51_max_buffer = 512;
449 bank->num_sectors = 4;
450 break;
451 case 32 * 1024:
452 lpc2000_info->cmd51_max_buffer = 1024;
453 bank->num_sectors = 8;
454 break;
455 case 64 * 1024:
456 bank->num_sectors = 16;
457 break;
458 case 128 * 1024:
459 bank->num_sectors = 18;
460 break;
461 case 256 * 1024:
462 bank->num_sectors = 22;
463 break;
464 case 512 * 1024:
465 bank->num_sectors = 30;
466 break;
467 default:
468 LOG_ERROR("BUG: unknown bank->size encountered");
469 exit(-1);
470 }
471
472 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
473
474 for (int i = 0; i < bank->num_sectors; i++) {
475 bank->sectors[i].offset = offset;
476 /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx/LPC40xx devices */
477 bank->sectors[i].size = (i < 16) ? 4 * 1024 : 32 * 1024;
478 offset += bank->sectors[i].size;
479 bank->sectors[i].is_erased = -1;
480 bank->sectors[i].is_protected = 1;
481 }
482 } else if (lpc2000_info->variant == lpc4300) {
483 lpc2000_info->cmd51_dst_boundary = 512;
484 lpc2000_info->checksum_vector = 7;
485 lpc2000_info->iap_max_stack = 208;
486
487 switch (bank->size) {
488 case 256 * 1024:
489 bank->num_sectors = 11;
490 break;
491 case 384 * 1024:
492 bank->num_sectors = 13;
493 break;
494 case 512 * 1024:
495 bank->num_sectors = 15;
496 break;
497 default:
498 LOG_ERROR("BUG: unknown bank->size encountered");
499 exit(-1);
500 }
501
502 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
503
504 for (int i = 0; i < bank->num_sectors; i++) {
505 bank->sectors[i].offset = offset;
506 /* sectors 0-7 are 8kB-sized, 8 and above are 64kB-sized for LPC43xx devices */
507 bank->sectors[i].size = (i < 8) ? 8 * 1024 : 64 * 1024;
508 offset += bank->sectors[i].size;
509 bank->sectors[i].is_erased = -1;
510 bank->sectors[i].is_protected = 1;
511 }
512
513 } else if (lpc2000_info->variant == lpc800) {
514 lpc2000_info->cmd51_dst_boundary = 64;
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->checksum_vector = 7;
552 lpc2000_info->iap_max_stack = 128;
553
554 if ((bank->size % (4 * 1024)) != 0) {
555 LOG_ERROR("BUG: unknown bank->size encountered,\nLPC1100 flash size must be a multiple of 4096");
556 exit(-1);
557 }
558 lpc2000_info->cmd51_max_buffer = 512; /* smallest MCU in the series, LPC1110, has 1 kB of SRAM */
559 unsigned int large_sectors = 0;
560 unsigned int normal_sectors = bank->size / 4096;
561
562 if (normal_sectors > LPC11xx_REG_SECTORS) {
563 large_sectors = (normal_sectors - LPC11xx_REG_SECTORS) / 8;
564 normal_sectors = LPC11xx_REG_SECTORS;
565 }
566
567 bank->num_sectors = normal_sectors + large_sectors;
568
569 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
570
571 for (int i = 0; i < bank->num_sectors; i++) {
572 bank->sectors[i].offset = offset;
573 bank->sectors[i].size = (i < LPC11xx_REG_SECTORS ? 4 : 32) * 1024;
574 offset += bank->sectors[i].size;
575 bank->sectors[i].is_erased = -1;
576 bank->sectors[i].is_protected = 1;
577 }
578
579 } else if (lpc2000_info->variant == lpc1500) {
580 lpc2000_info->cmd51_dst_boundary = 256;
581 lpc2000_info->checksum_vector = 7;
582 lpc2000_info->iap_max_stack = 128;
583
584 switch (bank->size) {
585 case 64 * 1024:
586 bank->num_sectors = 16;
587 break;
588 case 128 * 1024:
589 bank->num_sectors = 32;
590 break;
591 case 256 * 1024:
592 bank->num_sectors = 64;
593 break;
594 default:
595 LOG_ERROR("BUG: unknown bank->size encountered");
596 exit(-1);
597 }
598
599 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
600
601 for (int i = 0; i < bank->num_sectors; i++) {
602 bank->sectors[i].offset = offset;
603 /* all sectors are 4kB-sized */
604 bank->sectors[i].size = 4 * 1024;
605 offset += bank->sectors[i].size;
606 bank->sectors[i].is_erased = -1;
607 bank->sectors[i].is_protected = 1;
608 }
609
610 } else if (lpc2000_info->variant == lpc54100) {
611 lpc2000_info->cmd51_dst_boundary = 256;
612 lpc2000_info->checksum_vector = 7;
613 lpc2000_info->iap_max_stack = 128;
614
615 switch (bank->size) {
616 case 256 * 1024:
617 bank->num_sectors = 8;
618 break;
619 case 512 * 1024:
620 bank->num_sectors = 16;
621 break;
622 default:
623 LOG_ERROR("BUG: unknown bank->size encountered");
624 exit(-1);
625 }
626
627 bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
628
629 for (int i = 0; i < bank->num_sectors; i++) {
630 bank->sectors[i].offset = offset;
631 /* all sectors are 32kB-sized */
632 bank->sectors[i].size = 32 * 1024;
633 offset += bank->sectors[i].size;
634 bank->sectors[i].is_erased = -1;
635 bank->sectors[i].is_protected = 1;
636 }
637
638 } else {
639 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
640 exit(-1);
641 }
642
643 return ERROR_OK;
644 }
645
646 /* this function allocates and initializes working area used for IAP algorithm
647 * uses 52 + max IAP stack bytes working area
648 * 0x0 to 0x7: jump gate (BX to thumb state, b -2 to wait)
649 * 0x8 to 0x1f: command parameter table (1+5 words)
650 * 0x20 to 0x33: command result table (1+4 words)
651 * 0x34 to 0xb3|0x104: stack
652 * (128b needed for lpc1xxx/2000/5410x, 208b for lpc43xx/lpc82x and 148b for lpc81x)
653 */
654
655 static int lpc2000_iap_working_area_init(struct flash_bank *bank, struct working_area **iap_working_area)
656 {
657 struct target *target = bank->target;
658 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
659
660 if (target_alloc_working_area(target, IAP_CODE_LEN + lpc2000_info->iap_max_stack, iap_working_area) != ERROR_OK) {
661 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
662 return ERROR_FLASH_OPERATION_FAILED;
663 }
664
665 uint8_t jump_gate[8];
666
667 /* write IAP code to working area */
668 switch (lpc2000_info->variant) {
669 case lpc800:
670 case lpc1100:
671 case lpc1500:
672 case lpc1700:
673 case lpc4300:
674 case lpc54100:
675 case lpc_auto:
676 target_buffer_set_u32(target, jump_gate, ARMV4_5_T_BX(12));
677 target_buffer_set_u32(target, jump_gate + 4, ARMV5_T_BKPT(0));
678 break;
679 case lpc2000_v1:
680 case lpc2000_v2:
681 target_buffer_set_u32(target, jump_gate, ARMV4_5_BX(12));
682 target_buffer_set_u32(target, jump_gate + 4, ARMV4_5_B(0xfffffe, 0));
683 break;
684 default:
685 LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
686 exit(-1);
687 }
688
689 int retval = target_write_memory(target, (*iap_working_area)->address, 4, 2, jump_gate);
690 if (retval != ERROR_OK) {
691 LOG_ERROR("Write memory at address 0x%8.8" TARGET_PRIxADDR " failed (check work_area definition)",
692 (*iap_working_area)->address);
693 target_free_working_area(target, *iap_working_area);
694 }
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 || strcmp(CMD_ARGV[6], "lpc4000") == 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_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
1022 {
1023 struct target *target = bank->target;
1024
1025 if (bank->target->state != TARGET_HALTED) {
1026 LOG_ERROR("Target not halted");
1027 return ERROR_TARGET_NOT_HALTED;
1028 }
1029
1030 if (offset + count > bank->size)
1031 return ERROR_FLASH_DST_OUT_OF_BANK;
1032
1033 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1034
1035 uint32_t dst_min_alignment = lpc2000_info->cmd51_dst_boundary;
1036
1037 if (offset % dst_min_alignment) {
1038 LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, offset, dst_min_alignment);
1039 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
1040 }
1041
1042 int first_sector = 0;
1043 int last_sector = 0;
1044
1045 for (int i = 0; i < bank->num_sectors; i++) {
1046 if (offset >= bank->sectors[i].offset)
1047 first_sector = i;
1048 if (offset + DIV_ROUND_UP(count, dst_min_alignment) * dst_min_alignment > bank->sectors[i].offset)
1049 last_sector = i;
1050 }
1051
1052 LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
1053
1054 /* check if exception vectors should be flashed */
1055 if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum) {
1056 assert(lpc2000_info->checksum_vector < 8);
1057 uint32_t checksum = 0;
1058 for (int i = 0; i < 8; i++) {
1059 LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32, i * 4, buf_get_u32(buffer + (i * 4), 0, 32));
1060 if (i != lpc2000_info->checksum_vector)
1061 checksum += buf_get_u32(buffer + (i * 4), 0, 32);
1062 }
1063 checksum = 0 - checksum;
1064 LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum);
1065
1066 uint32_t original_value = buf_get_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32);
1067 if (original_value != checksum) {
1068 LOG_WARNING("Verification will fail since checksum in image (0x%8.8" PRIx32 ") to be written to flash is "
1069 "different from calculated vector checksum (0x%8.8" PRIx32 ").", original_value, checksum);
1070 LOG_WARNING("To remove this warning modify build tools on developer PC to inject correct LPC vector "
1071 "checksum.");
1072 }
1073
1074 /* FIXME: WARNING! This code is broken because it modifies the callers buffer in place. */
1075 buf_set_u32((uint8_t *)buffer + (lpc2000_info->checksum_vector * 4), 0, 32, checksum);
1076 }
1077
1078 struct working_area *iap_working_area;
1079
1080 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
1081
1082 if (retval != ERROR_OK)
1083 return retval;
1084
1085 struct working_area *download_area;
1086
1087 /* allocate a working area */
1088 if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK) {
1089 LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
1090 target_free_working_area(target, iap_working_area);
1091 return ERROR_FLASH_OPERATION_FAILED;
1092 }
1093
1094 uint32_t bytes_remaining = count;
1095 uint32_t bytes_written = 0;
1096 uint32_t param_table[5] = {0};
1097 uint32_t result_table[4];
1098
1099 if (lpc2000_info->variant == lpc4300)
1100 /* Init IAP Anyway */
1101 lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
1102
1103 while (bytes_remaining > 0) {
1104 uint32_t thisrun_bytes;
1105 if (bytes_remaining >= lpc2000_info->cmd51_max_buffer)
1106 thisrun_bytes = lpc2000_info->cmd51_max_buffer;
1107 else
1108 thisrun_bytes = lpc2000_info->cmd51_dst_boundary;
1109
1110 /* Prepare sectors */
1111 param_table[0] = first_sector;
1112 param_table[1] = last_sector;
1113
1114 if (lpc2000_info->variant == lpc4300)
1115 param_table[2] = lpc2000_info->lpc4300_bank;
1116 else
1117 param_table[2] = lpc2000_info->cclk;
1118
1119 int status_code = lpc2000_iap_call(bank, iap_working_area, 50, param_table, result_table);
1120 switch (status_code) {
1121 case ERROR_FLASH_OPERATION_FAILED:
1122 retval = ERROR_FLASH_OPERATION_FAILED;
1123 break;
1124 case LPC2000_CMD_SUCCESS:
1125 break;
1126 case LPC2000_INVALID_SECTOR:
1127 retval = ERROR_FLASH_SECTOR_INVALID;
1128 break;
1129 default:
1130 LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
1131 retval = ERROR_FLASH_OPERATION_FAILED;
1132 break;
1133 }
1134
1135 /* Exit if error occured */
1136 if (retval != ERROR_OK)
1137 break;
1138
1139 if (bytes_remaining >= thisrun_bytes) {
1140 retval = target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written);
1141 if (retval != ERROR_OK) {
1142 retval = ERROR_FLASH_OPERATION_FAILED;
1143 break;
1144 }
1145 } else {
1146 uint8_t *last_buffer = malloc(thisrun_bytes);
1147 memcpy(last_buffer, buffer + bytes_written, bytes_remaining);
1148 memset(last_buffer + bytes_remaining, 0xff, thisrun_bytes - bytes_remaining);
1149 target_write_buffer(bank->target, download_area->address, thisrun_bytes, last_buffer);
1150 free(last_buffer);
1151 }
1152
1153 LOG_DEBUG("writing 0x%" PRIx32 " bytes to address 0x%" PRIx32, thisrun_bytes,
1154 bank->base + offset + bytes_written);
1155
1156 /* Write data */
1157 param_table[0] = bank->base + offset + bytes_written;
1158 param_table[1] = download_area->address;
1159 param_table[2] = thisrun_bytes;
1160 param_table[3] = lpc2000_info->cclk;
1161 status_code = lpc2000_iap_call(bank, iap_working_area, 51, param_table, result_table);
1162 switch (status_code) {
1163 case ERROR_FLASH_OPERATION_FAILED:
1164 retval = ERROR_FLASH_OPERATION_FAILED;
1165 break;
1166 case LPC2000_CMD_SUCCESS:
1167 break;
1168 case LPC2000_INVALID_SECTOR:
1169 retval = ERROR_FLASH_SECTOR_INVALID;
1170 break;
1171 default:
1172 LOG_WARNING("lpc2000 returned %i", status_code);
1173 retval = ERROR_FLASH_OPERATION_FAILED;
1174 break;
1175 }
1176
1177 /* Exit if error occured */
1178 if (retval != ERROR_OK)
1179 break;
1180
1181 if (bytes_remaining > thisrun_bytes)
1182 bytes_remaining -= thisrun_bytes;
1183 else
1184 bytes_remaining = 0;
1185 bytes_written += thisrun_bytes;
1186 }
1187
1188 target_free_working_area(target, iap_working_area);
1189 target_free_working_area(target, download_area);
1190
1191 return retval;
1192 }
1193
1194 static int get_lpc2000_part_id(struct flash_bank *bank, uint32_t *part_id)
1195 {
1196 if (bank->target->state != TARGET_HALTED) {
1197 LOG_ERROR("Target not halted");
1198 return ERROR_TARGET_NOT_HALTED;
1199 }
1200
1201 uint32_t param_table[5] = {0};
1202 uint32_t result_table[4];
1203 struct working_area *iap_working_area;
1204
1205 int retval = lpc2000_iap_working_area_init(bank, &iap_working_area);
1206
1207 if (retval != ERROR_OK)
1208 return retval;
1209
1210 /* The status seems to be bogus with the part ID command on some IAP
1211 firmwares, so ignore it. */
1212 lpc2000_iap_call(bank, iap_working_area, 54, param_table, result_table);
1213
1214 struct target *target = bank->target;
1215 target_free_working_area(target, iap_working_area);
1216
1217 /* If the result is zero, the command probably didn't work out. */
1218 if (result_table[0] == 0)
1219 return LPC2000_INVALID_COMMAND;
1220
1221 *part_id = result_table[0];
1222 return LPC2000_CMD_SUCCESS;
1223 }
1224
1225 static int lpc2000_auto_probe_flash(struct flash_bank *bank)
1226 {
1227 uint32_t part_id;
1228 int retval;
1229 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1230
1231 if (bank->target->state != TARGET_HALTED) {
1232 LOG_ERROR("Target not halted");
1233 return ERROR_TARGET_NOT_HALTED;
1234 }
1235
1236 retval = get_lpc2000_part_id(bank, &part_id);
1237 if (retval != LPC2000_CMD_SUCCESS) {
1238 LOG_ERROR("Could not get part ID");
1239 return retval;
1240 }
1241
1242 switch (part_id) {
1243 case LPC1110_1:
1244 case LPC1110_2:
1245 lpc2000_info->variant = lpc1100;
1246 bank->size = 4 * 1024;
1247 break;
1248
1249 case LPC1111_002_1:
1250 case LPC1111_002_2:
1251 case LPC1111_101_1:
1252 case LPC1111_101_2:
1253 case LPC1111_103_1:
1254 case LPC1111_201_1:
1255 case LPC1111_201_2:
1256 case LPC1111_203_1:
1257 case LPC11A11_001_1:
1258 case LPC11E11_101:
1259 case LPC1311:
1260 case LPC1311_1:
1261 lpc2000_info->variant = lpc1100;
1262 bank->size = 8 * 1024;
1263 break;
1264
1265 case LPC1112_101_1:
1266 case LPC1112_101_2:
1267 case LPC1112_102_1:
1268 case LPC1112_102_2:
1269 case LPC1112_103_1:
1270 case LPC1112_201_1:
1271 case LPC1112_201_2:
1272 case LPC1112_203_1:
1273 case LPC11A02_1:
1274 case LPC11C12_301_1:
1275 case LPC11C22_301_1:
1276 case LPC11A12_101_1:
1277 case LPC11E12_201:
1278 case LPC11U12_201_1:
1279 case LPC11U12_201_2:
1280 case LPC1342:
1281 lpc2000_info->variant = lpc1100;
1282 bank->size = 16 * 1024;
1283 break;
1284
1285 case LPC1113_201_1:
1286 case LPC1113_201_2:
1287 case LPC1113_203_1:
1288 case LPC1113_301_1:
1289 case LPC1113_301_2:
1290 case LPC1113_303_1:
1291 case LPC11A13_201_1:
1292 case LPC11E13_301:
1293 case LPC11U13_201_1:
1294 case LPC11U13_201_2:
1295 case LPC11U23_301:
1296 lpc2000_info->variant = lpc1100;
1297 bank->size = 24 * 1024;
1298 break;
1299
1300 case LPC1114_102_1:
1301 case LPC1114_102_2:
1302 case LPC1114_201_1:
1303 case LPC1114_201_2:
1304 case LPC1114_203_1:
1305 case LPC1114_301_1:
1306 case LPC1114_301_2:
1307 case LPC1114_303_1:
1308 case LPC11A04_1:
1309 case LPC11A14_301_1:
1310 case LPC11A14_301_2:
1311 case LPC11C14_301_1:
1312 case LPC11C24_301_1:
1313 case LPC11E14_401:
1314 case LPC11U14_201_1:
1315 case LPC11U14_201_2:
1316 case LPC11U24_301:
1317 case LPC11U24_401:
1318 case LPC1313:
1319 case LPC1313_1:
1320 case LPC1315:
1321 case LPC1343:
1322 case LPC1343_1:
1323 case LPC1345:
1324 lpc2000_info->variant = lpc1100;
1325 bank->size = 32 * 1024;
1326 break;
1327
1328 case LPC1751_1:
1329 case LPC1751_2:
1330 lpc2000_info->variant = lpc1700;
1331 bank->size = 32 * 1024;
1332 break;
1333
1334 case LPC11U34_311:
1335 lpc2000_info->variant = lpc1100;
1336 bank->size = 40 * 1024;
1337 break;
1338
1339 case LPC1114_323_1:
1340 case LPC11U34_421:
1341 case LPC1316:
1342 case LPC1346:
1343 lpc2000_info->variant = lpc1100;
1344 bank->size = 48 * 1024;
1345 break;
1346
1347 case LPC1114_333_1:
1348 lpc2000_info->variant = lpc1100;
1349 bank->size = 56 * 1024;
1350 break;
1351
1352 case LPC1115_303_1:
1353 case LPC11U35_401:
1354 case LPC11U35_501:
1355 case LPC11E66:
1356 case LPC11U66:
1357 case LPC1317:
1358 case LPC1347:
1359 lpc2000_info->variant = lpc1100;
1360 bank->size = 64 * 1024;
1361 break;
1362
1363 case LPC1752:
1364 case LPC4072:
1365 lpc2000_info->variant = lpc1700;
1366 bank->size = 64 * 1024;
1367 break;
1368
1369 case LPC11E36_501:
1370 case LPC11U36_401:
1371 lpc2000_info->variant = lpc1100;
1372 bank->size = 96 * 1024;
1373 break;
1374
1375 case LPC11E37_401:
1376 case LPC11E37_501:
1377 case LPC11U37_401:
1378 case LPC11U37H_401:
1379 case LPC11U37_501:
1380 case LPC11E67:
1381 case LPC11E68:
1382 case LPC11U67_1:
1383 case LPC11U67_2:
1384 lpc2000_info->variant = lpc1100;
1385 bank->size = 128 * 1024;
1386 break;
1387
1388 case LPC1754:
1389 case LPC1764:
1390 case LPC1774:
1391 case LPC4074:
1392 lpc2000_info->variant = lpc1700;
1393 bank->size = 128 * 1024;
1394 break;
1395
1396 case LPC11U68_1:
1397 case LPC11U68_2:
1398 lpc2000_info->variant = lpc1100;
1399 bank->size = 256 * 1024;
1400 break;
1401
1402 case LPC1756:
1403 case LPC1763:
1404 case LPC1765:
1405 case LPC1766:
1406 case LPC1776:
1407 case LPC1785:
1408 case LPC1786:
1409 case LPC4076:
1410 lpc2000_info->variant = lpc1700;
1411 bank->size = 256 * 1024;
1412 break;
1413
1414 case LPC1758:
1415 case LPC1759:
1416 case LPC1767:
1417 case LPC1768:
1418 case LPC1769:
1419 case LPC1777:
1420 case LPC1778:
1421 case LPC1787:
1422 case LPC1788:
1423 case LPC4078:
1424 case LPC4088:
1425 lpc2000_info->variant = lpc1700;
1426 bank->size = 512 * 1024;
1427 break;
1428
1429 case LPC810_021:
1430 lpc2000_info->variant = lpc800;
1431 bank->size = 4 * 1024;
1432 break;
1433
1434 case LPC811_001:
1435 lpc2000_info->variant = lpc800;
1436 bank->size = 8 * 1024;
1437 break;
1438
1439 case LPC812_101:
1440 case LPC812_101_1:
1441 case LPC812_101_2:
1442 case LPC812_101_3:
1443 case LPC822_101:
1444 case LPC822_101_1:
1445 lpc2000_info->variant = lpc800;
1446 bank->size = 16 * 1024;
1447 break;
1448
1449 case LPC824_201:
1450 case LPC824_201_1:
1451 lpc2000_info->variant = lpc800;
1452 bank->size = 32 * 1024;
1453 break;
1454
1455 default:
1456 LOG_ERROR("BUG: unknown Part ID encountered: 0x%" PRIx32, part_id);
1457 exit(-1);
1458 }
1459
1460 return ERROR_OK;
1461 }
1462
1463 static int lpc2000_probe(struct flash_bank *bank)
1464 {
1465 int status;
1466 uint32_t part_id;
1467 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1468
1469 if (!lpc2000_info->probed) {
1470 if (lpc2000_info->variant == lpc_auto) {
1471 status = lpc2000_auto_probe_flash(bank);
1472 if (status != ERROR_OK)
1473 return status;
1474 } else if (lpc2000_info->variant == lpc1100 || lpc2000_info->variant == lpc1700) {
1475 status = get_lpc2000_part_id(bank, &part_id);
1476 if (status == LPC2000_CMD_SUCCESS)
1477 LOG_INFO("If auto-detection fails for this part, please email "
1478 "openocd-devel@lists.sourceforge.net, citing part id 0x%" PRIx32 ".\n", part_id);
1479 }
1480
1481 lpc2000_build_sector_list(bank);
1482 lpc2000_info->probed = true;
1483 }
1484
1485 return ERROR_OK;
1486 }
1487
1488 static int lpc2000_erase_check(struct flash_bank *bank)
1489 {
1490 if (bank->target->state != TARGET_HALTED) {
1491 LOG_ERROR("Target not halted");
1492 return ERROR_TARGET_NOT_HALTED;
1493 }
1494
1495 return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
1496 }
1497
1498 static int get_lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
1499 {
1500 struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
1501
1502 snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIi32 "kHz", lpc2000_info->variant,
1503 lpc2000_info->cclk);
1504
1505 return ERROR_OK;
1506 }
1507
1508 COMMAND_HANDLER(lpc2000_handle_part_id_command)
1509 {
1510 if (CMD_ARGC < 1)
1511 return ERROR_COMMAND_SYNTAX_ERROR;
1512
1513 struct flash_bank *bank;
1514 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
1515 if (ERROR_OK != retval)
1516 return retval;
1517
1518 if (bank->target->state != TARGET_HALTED) {
1519 LOG_ERROR("Target not halted");
1520 return ERROR_TARGET_NOT_HALTED;
1521 }
1522
1523 uint32_t part_id;
1524 int status_code = get_lpc2000_part_id(bank, &part_id);
1525 if (status_code != 0x0) {
1526 if (status_code == ERROR_FLASH_OPERATION_FAILED) {
1527 command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface");
1528 } else
1529 command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
1530 } else
1531 command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
1532
1533 return retval;
1534 }
1535
1536 static const struct command_registration lpc2000_exec_command_handlers[] = {
1537 {
1538 .name = "part_id",
1539 .handler = lpc2000_handle_part_id_command,
1540 .mode = COMMAND_EXEC,
1541 .help = "print part id of lpc2000 flash bank <num>",
1542 .usage = "<bank>",
1543 },
1544 COMMAND_REGISTRATION_DONE
1545 };
1546 static const struct command_registration lpc2000_command_handlers[] = {
1547 {
1548 .name = "lpc2000",
1549 .mode = COMMAND_ANY,
1550 .help = "lpc2000 flash command group",
1551 .usage = "",
1552 .chain = lpc2000_exec_command_handlers,
1553 },
1554 COMMAND_REGISTRATION_DONE
1555 };
1556
1557 struct flash_driver lpc2000_flash = {
1558 .name = "lpc2000",
1559 .commands = lpc2000_command_handlers,
1560 .flash_bank_command = lpc2000_flash_bank_command,
1561 .erase = lpc2000_erase,
1562 .write = lpc2000_write,
1563 .read = default_flash_read,
1564 .probe = lpc2000_probe,
1565 .auto_probe = lpc2000_probe,
1566 .erase_check = lpc2000_erase_check,
1567 .info = get_lpc2000_info,
1568 .free_driver_priv = default_flash_free_driver_priv,
1569 };