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