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