You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1574 lines
44 KiB

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