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