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