git.gag.com Git - fw/openocd/blob - src/flash/nor/msp432.c

   1 /***************************************************************************
   2  *   Copyright (C) 2018 by Texas Instruments, Inc.                         *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  16  ***************************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include "imp.h"
  23 #include "msp432.h"
  24 #include <helper/binarybuffer.h>
  25 #include <helper/time_support.h>
  26 #include <target/algorithm.h>
  27 #include <target/armv7m.h>
  28 #include <target/image.h>
  29
  30 /* MSP432P4 hardware registers */
  31 #define P4_FLASH_MAIN_SIZE_REG 0xE0043020
  32 #define P4_FLASH_INFO_SIZE_REG 0xE0043024
  33 #define P4_DEVICE_ID_REG       0x0020100C
  34 #define P4_HARDWARE_REV_REG    0x00201010
  35
  36 /* MSP432E4 hardware registers */
  37 #define E4_DID0_REG 0x400FE000
  38 #define E4_DID1_REG 0x400FE004
  39
  40 #define FLASH_TIMEOUT 8000
  41
  42 #define SUPPORT_MESSAGE \
  43         "Your pre-production MSP432P401x silicon is not fully supported\n" \
  44         "You can find more information at www.ti.com/product/MSP432P401R"
  45
  46 struct msp432_bank {
  47         uint32_t device_id;
  48         uint32_t hardware_rev;
  49         int family_type;
  50         int device_type;
  51         uint32_t sector_length;
  52         bool probed[2];
  53         bool unlock_bsl;
  54         struct working_area *working_area;
  55         struct armv7m_algorithm armv7m_info;
  56 };
  57
  58 static int msp432_auto_probe(struct flash_bank *bank);
  59
  60 static int msp432_device_type(uint32_t family_type, uint32_t device_id,
  61         uint32_t hardware_rev)
  62 {
  63         int device_type = MSP432_NO_TYPE;
  64
  65         if (MSP432E4 == family_type) {
  66                 /* MSP432E4 device family */
  67
  68                 if (device_id == 0x180C0002) {
  69                         if (hardware_rev == 0x102DC06E) {
  70                                 /* The 01Y variant */
  71                                 device_type = MSP432E401Y;
  72                         } else if (hardware_rev == 0x1032E076) {
  73                                 /* The 11Y variant */
  74                                 device_type = MSP432E411Y;
  75                         } else {
  76                                 /* Reasonable guess that this is a new variant */
  77                                 device_type = MSP432E4X_GUESS;
  78                         }
  79                 } else {
  80                         /* Wild guess that this is an MSP432E4 */
  81                         device_type = MSP432E4X_GUESS;
  82                 }
  83         } else {
  84                 /* MSP432P4 device family */
  85
  86                 /* Examine the device ID and hardware revision to get the device type */
  87                 switch (device_id) {
  88                         case 0xA000:
  89                         case 0xA001:
  90                         case 0xA002:
  91                         case 0xA003:
  92                         case 0xA004:
  93                         case 0xA005:
  94                                 /* Device is definitely MSP432P401x, check hardware revision */
  95                                 if (hardware_rev == 0x41 || hardware_rev == 0x42) {
  96                                         /* Rev A or B of the silicon has been deprecated */
  97                                         device_type = MSP432P401X_DEPR;
  98                                 } else if (hardware_rev >= 0x43 && hardware_rev <= 0x49) {
  99                                         /* Current and future revisions of the MSP432P401x device */
 100                                         device_type = MSP432P401X;
 101                                 } else {
 102                                         /* Unknown or unanticipated hardware revision */
 103                                         device_type = MSP432P401X_GUESS;
 104                                 }
 105                                 break;
 106                         case 0xA010:
 107                         case 0xA012:
 108                         case 0xA016:
 109                         case 0xA019:
 110                         case 0xA01F:
 111                         case 0xA020:
 112                         case 0xA022:
 113                         case 0xA026:
 114                         case 0xA029:
 115                         case 0xA02F:
 116                                 /* Device is definitely MSP432P411x, check hardware revision */
 117                                 if (hardware_rev >= 0x41 && hardware_rev <= 0x49) {
 118                                         /* Current and future revisions of the MSP432P411x device */
 119                                         device_type = MSP432P411X;
 120                                 } else {
 121                                         /* Unknown or unanticipated hardware revision */
 122                                         device_type = MSP432P411X_GUESS;
 123                                 }
 124                                 break;
 125                         case 0xFFFF:
 126                                 /* Device is very early silicon that has been deprecated */
 127                                 device_type = MSP432P401X_DEPR;
 128                                 break;
 129                         default:
 130                                 if (device_id < 0xA010) {
 131                                         /* Wild guess that this is an MSP432P401x */
 132                                         device_type = MSP432P401X_GUESS;
 133                                 } else {
 134                                         /* Reasonable guess that this is a new variant */
 135                                         device_type = MSP432P411X_GUESS;
 136                                 }
 137                                 break;
 138                 }
 139         }
 140
 141         return device_type;
 142 }
 143
 144 static const char *msp432_return_text(uint32_t return_code)
 145 {
 146         switch (return_code) {
 147                 case FLASH_BUSY:
 148                         return "FLASH_BUSY";
 149                 case FLASH_SUCCESS:
 150                         return "FLASH_SUCCESS";
 151                 case FLASH_ERROR:
 152                         return "FLASH_ERROR";
 153                 case FLASH_TIMEOUT_ERROR:
 154                         return "FLASH_TIMEOUT_ERROR";
 155                 case FLASH_VERIFY_ERROR:
 156                         return "FLASH_VERIFY_WRONG";
 157                 case FLASH_WRONG_COMMAND:
 158                         return "FLASH_WRONG_COMMAND";
 159                 case FLASH_POWER_ERROR:
 160                         return "FLASH_POWER_ERROR";
 161                 default:
 162                         return "UNDEFINED_RETURN_CODE";
 163         }
 164 }
 165
 166 static void msp432_init_params(struct msp432_algo_params *algo_params)
 167 {
 168         buf_set_u32(algo_params->flash_command, 0, 32, FLASH_NO_COMMAND);
 169         buf_set_u32(algo_params->return_code, 0, 32, 0);
 170         buf_set_u32(algo_params->_reserved0, 0, 32, 0);
 171         buf_set_u32(algo_params->address, 0, 32, 0);
 172         buf_set_u32(algo_params->length, 0, 32, 0);
 173         buf_set_u32(algo_params->buffer1_status, 0, 32, BUFFER_INACTIVE);
 174         buf_set_u32(algo_params->buffer2_status, 0, 32, BUFFER_INACTIVE);
 175         buf_set_u32(algo_params->erase_param, 0, 32, FLASH_ERASE_MAIN);
 176         buf_set_u32(algo_params->unlock_bsl, 0, 32, FLASH_LOCK_BSL);
 177 }
 178
 179 static int msp432_exec_cmd(struct target *target, struct msp432_algo_params
 180                         *algo_params, uint32_t command)
 181 {
 182         int retval;
 183
 184         /* Make sure the given params do not include the command */
 185         buf_set_u32(algo_params->flash_command, 0, 32, FLASH_NO_COMMAND);
 186         buf_set_u32(algo_params->return_code, 0, 32, 0);
 187         buf_set_u32(algo_params->buffer1_status, 0, 32, BUFFER_INACTIVE);
 188         buf_set_u32(algo_params->buffer2_status, 0, 32, BUFFER_INACTIVE);
 189
 190         /* Write out parameters to target memory */
 191         retval = target_write_buffer(target, ALGO_PARAMS_BASE_ADDR,
 192                                 sizeof(struct msp432_algo_params), (uint8_t *)algo_params);
 193         if (ERROR_OK != retval)
 194                 return retval;
 195
 196         /* Write out command to target memory */
 197         retval = target_write_buffer(target, ALGO_FLASH_COMMAND_ADDR,
 198                                 sizeof(command), (uint8_t *)&command);
 199
 200         return retval;
 201 }
 202
 203 static int msp432_wait_return_code(struct target *target)
 204 {
 205         uint32_t return_code = 0;
 206         long long start_ms;
 207         long long elapsed_ms;
 208
 209         int retval = ERROR_OK;
 210
 211         start_ms = timeval_ms();
 212         while ((0 == return_code) || (FLASH_BUSY == return_code)) {
 213                 retval = target_read_buffer(target, ALGO_RETURN_CODE_ADDR,
 214                                         sizeof(return_code), (uint8_t *)&return_code);
 215                 if (ERROR_OK != retval)
 216                         return retval;
 217
 218                 elapsed_ms = timeval_ms() - start_ms;
 219                 if (elapsed_ms > 500)
 220                         keep_alive();
 221                 if (elapsed_ms > FLASH_TIMEOUT)
 222                         break;
 223         };
 224
 225         if (FLASH_SUCCESS != return_code) {
 226                 LOG_ERROR("msp432: Flash operation failed: %s",
 227                         msp432_return_text(return_code));
 228                 return ERROR_FAIL;
 229         }
 230
 231         return ERROR_OK;
 232 }
 233
 234 static int msp432_wait_inactive(struct target *target, uint32_t buffer)
 235 {
 236         uint32_t status_code = BUFFER_ACTIVE;
 237         uint32_t status_addr;
 238         long long start_ms;
 239         long long elapsed_ms;
 240
 241         int retval;
 242
 243         switch (buffer) {
 244                 case 1: /* Buffer 1 */
 245                         status_addr = ALGO_BUFFER1_STATUS_ADDR;
 246                         break;
 247                 case 2: /* Buffer 2 */
 248                         status_addr = ALGO_BUFFER2_STATUS_ADDR;
 249                         break;
 250                 default:
 251                         return ERROR_FAIL;
 252         }
 253
 254         start_ms = timeval_ms();
 255         while (BUFFER_INACTIVE != status_code) {
 256                 retval = target_read_buffer(target, status_addr, sizeof(status_code),
 257                                         (uint8_t *)&status_code);
 258                 if (ERROR_OK != retval)
 259                         return retval;
 260
 261                 elapsed_ms = timeval_ms() - start_ms;
 262                 if (elapsed_ms > 500)
 263                         keep_alive();
 264                 if (elapsed_ms > FLASH_TIMEOUT)
 265                         break;
 266         };
 267
 268         if (BUFFER_INACTIVE != status_code) {
 269                 LOG_ERROR(
 270                         "msp432: Flash operation failed: buffer not written to flash");
 271                 return ERROR_FAIL;
 272         }
 273
 274         return ERROR_OK;
 275 }
 276
 277 static int msp432_init(struct flash_bank *bank)
 278 {
 279         struct target *target = bank->target;
 280         struct msp432_bank *msp432_bank = bank->driver_priv;
 281         struct msp432_algo_params algo_params;
 282         struct reg_param reg_params[1];
 283
 284         const uint8_t *loader_code;
 285         uint32_t loader_size;
 286         uint32_t algo_entry_addr;
 287         int retval;
 288
 289         /* Make sure we've probed the flash to get the device and size */
 290         retval = msp432_auto_probe(bank);
 291         if (ERROR_OK != retval)
 292                 return retval;
 293
 294         /* Choose appropriate flash helper algorithm */
 295         switch (msp432_bank->device_type) {
 296                 case MSP432P401X:
 297                 case MSP432P401X_DEPR:
 298                 case MSP432P401X_GUESS:
 299                 default:
 300                         loader_code = msp432p401x_algo;
 301                         loader_size = sizeof(msp432p401x_algo);
 302                         algo_entry_addr = P4_ALGO_ENTRY_ADDR;
 303                         break;
 304                 case MSP432P411X:
 305                 case MSP432P411X_GUESS:
 306                         loader_code = msp432p411x_algo;
 307                         loader_size = sizeof(msp432p411x_algo);
 308                         algo_entry_addr = P4_ALGO_ENTRY_ADDR;
 309                         break;
 310                 case MSP432E401Y:
 311                 case MSP432E411Y:
 312                 case MSP432E4X_GUESS:
 313                         loader_code = msp432e4x_algo;
 314                         loader_size = sizeof(msp432e4x_algo);
 315                         algo_entry_addr = E4_ALGO_ENTRY_ADDR;
 316                         break;
 317         }
 318
 319         /* Issue warnings if this is a device we may not be able to flash */
 320         if (MSP432P401X_GUESS == msp432_bank->device_type ||
 321                 MSP432P411X_GUESS == msp432_bank->device_type) {
 322                 /* Explicit device type check failed. Report this. */
 323                 LOG_WARNING(
 324                         "msp432: Unrecognized MSP432P4 Device ID and Hardware "
 325                         "Rev (%04X, %02X)", msp432_bank->device_id,
 326                         msp432_bank->hardware_rev);
 327         } else if (MSP432P401X_DEPR == msp432_bank->device_type) {
 328                 LOG_WARNING(
 329                         "msp432: MSP432P401x pre-production device (deprecated "
 330                         "silicon)\n" SUPPORT_MESSAGE);
 331         } else if (MSP432E4X_GUESS == msp432_bank->device_type) {
 332                 /* Explicit device type check failed. Report this. */
 333                 LOG_WARNING(
 334                         "msp432: Unrecognized MSP432E4 DID0 and DID1 values "
 335                         "(%08X, %08X)", msp432_bank->device_id,
 336                         msp432_bank->hardware_rev);
 337         }
 338
 339         /* Check for working area to use for flash helper algorithm */
 340         if (NULL != msp432_bank->working_area)
 341                 target_free_working_area(target, msp432_bank->working_area);
 342         retval = target_alloc_working_area(target, ALGO_WORKING_SIZE,
 343                                 &msp432_bank->working_area);
 344         if (ERROR_OK != retval)
 345                 return retval;
 346
 347         /* Confirm the defined working address is the area we need to use */
 348         if (ALGO_BASE_ADDR != msp432_bank->working_area->address)
 349                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 350
 351         /* Write flash helper algorithm into target memory */
 352         retval = target_write_buffer(target, ALGO_BASE_ADDR, loader_size,
 353                                 loader_code);
 354         if (ERROR_OK != retval)
 355                 return retval;
 356
 357         /* Initialize the ARMv7 specific info to run the algorithm */
 358         msp432_bank->armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
 359         msp432_bank->armv7m_info.core_mode = ARM_MODE_THREAD;
 360
 361         /* Initialize algorithm parameters to default values */
 362         msp432_init_params(&algo_params);
 363
 364         /* Write out parameters to target memory */
 365         retval = target_write_buffer(target, ALGO_PARAMS_BASE_ADDR,
 366                                 sizeof(algo_params), (uint8_t *)&algo_params);
 367         if (ERROR_OK != retval)
 368                 return retval;
 369
 370         /* Initialize stack pointer for flash helper algorithm */
 371         init_reg_param(&reg_params[0], "sp", 32, PARAM_OUT);
 372         buf_set_u32(reg_params[0].value, 0, 32, ALGO_STACK_POINTER_ADDR);
 373
 374         /* Begin executing the flash helper algorithm */
 375         retval = target_start_algorithm(target, 0, 0, 1, reg_params,
 376                                 algo_entry_addr, 0, &msp432_bank->armv7m_info);
 377         destroy_reg_param(&reg_params[0]);
 378         if (ERROR_OK != retval) {
 379                 LOG_ERROR("msp432: Failed to start flash helper algorithm");
 380                 return retval;
 381         }
 382
 383         /*
 384          * At this point, the algorithm is running on the target and
 385          * ready to receive commands and data to flash the target
 386          */
 387
 388         /* Issue the init command to the flash helper algorithm */
 389         retval = msp432_exec_cmd(target, &algo_params, FLASH_INIT);
 390         if (ERROR_OK != retval)
 391                 return retval;
 392
 393         retval = msp432_wait_return_code(target);
 394
 395         return retval;
 396 }
 397
 398 static int msp432_quit(struct flash_bank *bank)
 399 {
 400         struct target *target = bank->target;
 401         struct msp432_bank *msp432_bank = bank->driver_priv;
 402         struct msp432_algo_params algo_params;
 403
 404         int retval;
 405
 406         /* Initialize algorithm parameters to default values */
 407         msp432_init_params(&algo_params);
 408
 409         /* Issue the exit command to the flash helper algorithm */
 410         retval = msp432_exec_cmd(target, &algo_params, FLASH_EXIT);
 411         if (ERROR_OK != retval)
 412                 return retval;
 413
 414         (void)msp432_wait_return_code(target);
 415
 416         /* Regardless of the return code, attempt to halt the target */
 417         (void)target_halt(target);
 418
 419         /* Now confirm target halted and clean up from flash helper algorithm */
 420         retval = target_wait_algorithm(target, 0, NULL, 0, NULL, 0, FLASH_TIMEOUT,
 421                                 &msp432_bank->armv7m_info);
 422
 423         target_free_working_area(target, msp432_bank->working_area);
 424         msp432_bank->working_area = NULL;
 425
 426         return retval;
 427 }
 428
 429 static int msp432_mass_erase(struct flash_bank *bank, bool all)
 430 {
 431         struct target *target = bank->target;
 432         struct msp432_bank *msp432_bank = bank->driver_priv;
 433         struct msp432_algo_params algo_params;
 434
 435         int retval;
 436
 437         if (TARGET_HALTED != target->state) {
 438                 LOG_ERROR("Target not halted");
 439                 return ERROR_TARGET_NOT_HALTED;
 440         }
 441
 442         retval = msp432_init(bank);
 443         if (ERROR_OK != retval)
 444                 return retval;
 445
 446         /* Initialize algorithm parameters to default values */
 447         msp432_init_params(&algo_params);
 448         if (all) {
 449                 buf_set_u32(algo_params.erase_param, 0, 32,
 450                         FLASH_ERASE_MAIN | FLASH_ERASE_INFO);
 451                 if (msp432_bank->unlock_bsl)
 452                         buf_set_u32(algo_params.unlock_bsl, 0, 32, FLASH_UNLOCK_BSL);
 453         }
 454
 455         /* Issue the mass erase command to the flash helper algorithm */
 456         retval = msp432_exec_cmd(target, &algo_params, FLASH_MASS_ERASE);
 457         if (ERROR_OK != retval) {
 458                 (void)msp432_quit(bank);
 459                 return retval;
 460         }
 461
 462         retval = msp432_wait_return_code(target);
 463         if (ERROR_OK != retval) {
 464                 (void)msp432_quit(bank);
 465                 return retval;
 466         }
 467
 468         retval = msp432_quit(bank);
 469         if (ERROR_OK != retval)
 470                 return retval;
 471
 472         return retval;
 473 }
 474
 475 COMMAND_HANDLER(msp432_mass_erase_command)
 476 {
 477         struct flash_bank *bank;
 478         struct msp432_bank *msp432_bank;
 479         bool all;
 480         int retval;
 481
 482         if (0 == CMD_ARGC) {
 483                 all = false;
 484         } else if (1 == CMD_ARGC) {
 485                 /* Check argument for how much to erase */
 486                 if (0 == strcmp(CMD_ARGV[0], "main"))
 487                         all = false;
 488                 else if (0 == strcmp(CMD_ARGV[0], "all"))
 489                         all = true;
 490                 else
 491                         return ERROR_COMMAND_SYNTAX_ERROR;
 492         } else {
 493                 return ERROR_COMMAND_SYNTAX_ERROR;
 494         }
 495
 496         retval = get_flash_bank_by_num(0, &bank);
 497         if (ERROR_OK != retval)
 498                 return retval;
 499
 500         msp432_bank = bank->driver_priv;
 501
 502         if (MSP432E4 == msp432_bank->family_type) {
 503                 /* MSP432E4 does not have main vs info regions, ignore "all" */
 504                 all = false;
 505         }
 506
 507         retval = msp432_mass_erase(bank, all);
 508         if (ERROR_OK != retval)
 509                 return retval;
 510
 511         if (MSP432E4 == msp432_bank->family_type) {
 512                 /* MSP432E4 does not have main vs info regions */
 513                 LOG_INFO("msp432: Mass erase of flash is complete");
 514         } else {
 515                 LOG_INFO("msp432: Mass erase of %s is complete",
 516                         all ? "main + info flash" : "main flash");
 517         }
 518
 519         return ERROR_OK;
 520 }
 521
 522 COMMAND_HANDLER(msp432_bsl_command)
 523 {
 524         struct flash_bank *bank;
 525         struct msp432_bank *msp432_bank;
 526         int retval;
 527
 528         if (1 < CMD_ARGC)
 529                 return ERROR_COMMAND_SYNTAX_ERROR;
 530
 531         retval = get_flash_bank_by_num(0, &bank);
 532         if (ERROR_OK != retval)
 533                 return retval;
 534
 535         msp432_bank = bank->driver_priv;
 536
 537         if (MSP432E4 == msp432_bank->family_type) {
 538                 LOG_WARNING("msp432: MSP432E4 does not have a BSL region");
 539                 return ERROR_OK;
 540         }
 541
 542         if (1 == CMD_ARGC) {
 543                 if (0 == strcmp(CMD_ARGV[0], "lock"))
 544                         msp432_bank->unlock_bsl = false;
 545                 else if (0 == strcmp(CMD_ARGV[0], "unlock"))
 546                         msp432_bank->unlock_bsl = true;
 547                 else
 548                         return ERROR_COMMAND_SYNTAX_ERROR;
 549         }
 550
 551         LOG_INFO("msp432: BSL flash region is currently %slocked",
 552                 msp432_bank->unlock_bsl ? "un" : "");
 553
 554         return ERROR_OK;
 555 }
 556
 557 FLASH_BANK_COMMAND_HANDLER(msp432_flash_bank_command)
 558 {
 559         struct msp432_bank *msp432_bank;
 560
 561         if (CMD_ARGC < 6)
 562                 return ERROR_COMMAND_SYNTAX_ERROR;
 563
 564         msp432_bank = malloc(sizeof(struct msp432_bank));
 565         if (NULL == msp432_bank)
 566                 return ERROR_FAIL;
 567
 568         /* Initialize private flash information */
 569         msp432_bank->device_id = 0;
 570         msp432_bank->hardware_rev = 0;
 571         msp432_bank->family_type = MSP432_NO_FAMILY;
 572         msp432_bank->device_type = MSP432_NO_TYPE;
 573         msp432_bank->sector_length = 0x1000;
 574         msp432_bank->probed[0] = false;
 575         msp432_bank->probed[1] = false;
 576         msp432_bank->unlock_bsl = false;
 577         msp432_bank->working_area = NULL;
 578
 579         /* Finish initialization of bank 0 (main flash) */
 580         bank->driver_priv = msp432_bank;
 581         bank->next = NULL;
 582
 583         return ERROR_OK;
 584 }
 585
 586 static int msp432_erase(struct flash_bank *bank, int first, int last)
 587 {
 588         struct target *target = bank->target;
 589         struct msp432_bank *msp432_bank = bank->driver_priv;
 590         struct msp432_algo_params algo_params;
 591
 592         int retval;
 593
 594         if (TARGET_HALTED != target->state) {
 595                 LOG_ERROR("Target not halted");
 596                 return ERROR_TARGET_NOT_HALTED;
 597         }
 598
 599         /* Do a mass erase if user requested all sectors of main flash */
 600         if ((0 == bank->bank_number) && (first == 0) &&
 601                 (last == (bank->num_sectors - 1))) {
 602                 /* Request mass erase of main flash */
 603                 return msp432_mass_erase(bank, false);
 604         }
 605
 606         retval = msp432_init(bank);
 607         if (ERROR_OK != retval)
 608                 return retval;
 609
 610         /* Initialize algorithm parameters to default values */
 611         msp432_init_params(&algo_params);
 612
 613         /* Adjust params if this is the info bank */
 614         if (1 == bank->bank_number) {
 615                 buf_set_u32(algo_params.erase_param, 0, 32, FLASH_ERASE_INFO);
 616                 /* And flag if BSL is unlocked */
 617                 if (msp432_bank->unlock_bsl)
 618                         buf_set_u32(algo_params.unlock_bsl, 0, 32, FLASH_UNLOCK_BSL);
 619         }
 620
 621         /* Erase requested sectors one by one */
 622         for (int i = first; i <= last; i++) {
 623
 624                 /* Skip TVL (read-only) sector of the info bank */
 625                 if (1 == bank->bank_number && 1 == i)
 626                         continue;
 627
 628                 /* Skip BSL sectors of info bank if locked */
 629                 if (1 == bank->bank_number && (2 == i || 3 == i) &&
 630                         !msp432_bank->unlock_bsl)
 631                         continue;
 632
 633                 /* Convert sector number to starting address of sector */
 634                 buf_set_u32(algo_params.address, 0, 32, bank->base +
 635                         (i * msp432_bank->sector_length));
 636
 637                 /* Issue the sector erase command to the flash helper algorithm */
 638                 retval = msp432_exec_cmd(target, &algo_params, FLASH_SECTOR_ERASE);
 639                 if (ERROR_OK != retval) {
 640                         (void)msp432_quit(bank);
 641                         return retval;
 642                 }
 643
 644                 retval = msp432_wait_return_code(target);
 645                 if (ERROR_OK != retval) {
 646                         (void)msp432_quit(bank);
 647                         return retval;
 648                 }
 649         }
 650
 651         retval = msp432_quit(bank);
 652         if (ERROR_OK != retval)
 653                 return retval;
 654
 655         return retval;
 656 }
 657
 658 static int msp432_protect(struct flash_bank *bank, int set, int first,
 659         int last)
 660 {
 661         return ERROR_OK;
 662 }
 663
 664 static int msp432_write(struct flash_bank *bank, const uint8_t *buffer,
 665         uint32_t offset, uint32_t count)
 666 {
 667         struct target *target = bank->target;
 668         struct msp432_bank *msp432_bank = bank->driver_priv;
 669         struct msp432_algo_params algo_params;
 670         uint32_t size;
 671         uint32_t data_ready = BUFFER_DATA_READY;
 672         long long start_ms;
 673         long long elapsed_ms;
 674
 675         int retval;
 676
 677         if (TARGET_HALTED != target->state) {
 678                 LOG_ERROR("Target not halted");
 679                 return ERROR_TARGET_NOT_HALTED;
 680         }
 681
 682         /*
 683          * Block attempts to write to read-only sectors of flash
 684          * The TVL region in sector 1 of the info flash is always read-only
 685          * The BSL region in sectors 2 and 3 of the info flash may be unlocked
 686          * The helper algorithm will hang on attempts to write to TVL
 687          */
 688         if (1 == bank->bank_number) {
 689                 /* Set read-only start to TVL sector */
 690                 uint32_t start = 0x1000;
 691                 /* Set read-only end after BSL region if locked */
 692                 uint32_t end = (msp432_bank->unlock_bsl) ? 0x2000 : 0x4000;
 693                 /* Check if request includes anything in read-only sectors */
 694                 if ((offset + count - 1) < start || offset >= end) {
 695                         /* The request includes no bytes in read-only sectors */
 696                         /* Fall out and process the request normally */
 697                 } else {
 698                         /* Send a request for anything before read-only sectors */
 699                         if (offset < start) {
 700                                 uint32_t start_count = MIN(start - offset, count);
 701                                 retval = msp432_write(bank, buffer, offset, start_count);
 702                                 if (ERROR_OK != retval)
 703                                         return retval;
 704                         }
 705                         /* Send a request for anything after read-only sectors */
 706                         if ((offset + count - 1) >= end) {
 707                                 uint32_t skip = end - offset;
 708                                 count -= skip;
 709                                 offset += skip;
 710                                 buffer += skip;
 711                                 return msp432_write(bank, buffer, offset, count);
 712                         } else {
 713                                 /* Request is entirely in read-only sectors */
 714                                 return ERROR_OK;
 715                         }
 716                 }
 717         }
 718
 719         retval = msp432_init(bank);
 720         if (ERROR_OK != retval)
 721                 return retval;
 722
 723         /* Initialize algorithm parameters to default values */
 724         msp432_init_params(&algo_params);
 725
 726         /* Set up parameters for requested flash write operation */
 727         buf_set_u32(algo_params.address, 0, 32, bank->base + offset);
 728         buf_set_u32(algo_params.length, 0, 32, count);
 729
 730         /* Check if this is the info bank */
 731         if (1 == bank->bank_number) {
 732                 /* And flag if BSL is unlocked */
 733                 if (msp432_bank->unlock_bsl)
 734                         buf_set_u32(algo_params.unlock_bsl, 0, 32, FLASH_UNLOCK_BSL);
 735         }
 736
 737         /* Set up flash helper algorithm to continuous flash mode */
 738         retval = msp432_exec_cmd(target, &algo_params, FLASH_CONTINUOUS);
 739         if (ERROR_OK != retval) {
 740                 (void)msp432_quit(bank);
 741                 return retval;
 742         }
 743
 744         /* Write requested data, one buffer at a time */
 745         start_ms = timeval_ms();
 746         while (count > 0) {
 747
 748                 if (count > ALGO_BUFFER_SIZE)
 749                         size = ALGO_BUFFER_SIZE;
 750                 else
 751                         size = count;
 752
 753                 /* Put next block of data to flash into buffer */
 754                 retval = target_write_buffer(target, ALGO_BUFFER1_ADDR, size, buffer);
 755                 if (ERROR_OK != retval) {
 756                         LOG_ERROR("Unable to write data to target memory");
 757                         (void)msp432_quit(bank);
 758                         return ERROR_FLASH_OPERATION_FAILED;
 759                 }
 760
 761                 /* Signal the flash helper algorithm that data is ready to flash */
 762                 retval = target_write_buffer(target, ALGO_BUFFER1_STATUS_ADDR,
 763                                         sizeof(data_ready), (uint8_t *)&data_ready);
 764                 if (ERROR_OK != retval) {
 765                         (void)msp432_quit(bank);
 766                         return ERROR_FLASH_OPERATION_FAILED;
 767                 }
 768
 769                 retval = msp432_wait_inactive(target, 1);
 770                 if (ERROR_OK != retval) {
 771                         (void)msp432_quit(bank);
 772                         return retval;
 773                 }
 774
 775                 count -= size;
 776                 buffer += size;
 777
 778                 elapsed_ms = timeval_ms() - start_ms;
 779                 if (elapsed_ms > 500)
 780                         keep_alive();
 781         }
 782
 783         /* Confirm that the flash helper algorithm is finished */
 784         retval = msp432_wait_return_code(target);
 785         if (ERROR_OK != retval) {
 786                 (void)msp432_quit(bank);
 787                 return retval;
 788         }
 789
 790         retval = msp432_quit(bank);
 791         if (ERROR_OK != retval)
 792                 return retval;
 793
 794         return retval;
 795 }
 796
 797 static int msp432_probe(struct flash_bank *bank)
 798 {
 799         struct target *target = bank->target;
 800         struct msp432_bank *msp432_bank = bank->driver_priv;
 801
 802         char *name;
 803
 804         uint32_t device_id;
 805         uint32_t hardware_rev;
 806
 807         uint32_t base;
 808         uint32_t sector_length;
 809         uint32_t size;
 810         int num_sectors;
 811         int bank_id;
 812
 813         int retval;
 814
 815         bank_id = bank->bank_number;
 816
 817         /* Read the flash size register to determine this is a P4 or not */
 818         /* MSP432P4s will return the size of flash.  MSP432E4s will return zero */
 819         retval = target_read_u32(target, P4_FLASH_MAIN_SIZE_REG, &size);
 820         if (ERROR_OK != retval)
 821                 return retval;
 822
 823         if (0 == size) {
 824                 /* This is likely an MSP432E4 */
 825                 msp432_bank->family_type = MSP432E4;
 826
 827                 retval = target_read_u32(target, E4_DID0_REG, &device_id);
 828                 if (ERROR_OK != retval)
 829                         return retval;
 830
 831                 msp432_bank->device_id = device_id;
 832
 833                 retval = target_read_u32(target, E4_DID1_REG, &hardware_rev);
 834                 if (ERROR_OK != retval)
 835                         return retval;
 836
 837                 msp432_bank->hardware_rev = hardware_rev;
 838         } else {
 839                 /* This is likely an MSP432P4 */
 840                 msp432_bank->family_type = MSP432P4;
 841
 842                 retval = target_read_u32(target, P4_DEVICE_ID_REG, &device_id);
 843                 if (ERROR_OK != retval)
 844                         return retval;
 845
 846                 msp432_bank->device_id = device_id & 0xFFFF;
 847
 848                 retval = target_read_u32(target, P4_HARDWARE_REV_REG, &hardware_rev);
 849                 if (ERROR_OK != retval)
 850                         return retval;
 851
 852                 msp432_bank->hardware_rev = hardware_rev & 0xFF;
 853         }
 854
 855         msp432_bank->device_type = msp432_device_type(msp432_bank->family_type,
 856                 msp432_bank->device_id, msp432_bank->hardware_rev);
 857
 858         /* If not already allocated, create the info bank for MSP432P4 */
 859         /* We could not determine it was needed until device was probed */
 860         if (MSP432P4 == msp432_bank->family_type) {
 861                 /* If we've been given bank 1, then this was already done */
 862                 if (0 == bank_id) {
 863                         /* And only allocate it if it doesn't exist yet */
 864                         if (NULL == bank->next) {
 865                                 struct flash_bank *info_bank;
 866                                 info_bank = malloc(sizeof(struct flash_bank));
 867                                 if (NULL == info_bank)
 868                                         return ERROR_FAIL;
 869
 870                                 name = malloc(strlen(bank->name)+1);
 871                                 if (NULL == name) {
 872                                         free(info_bank);
 873                                         return ERROR_FAIL;
 874                                 }
 875                                 strcpy(name, bank->name);
 876
 877                                 /* Initialize bank 1 (info region) */
 878                                 info_bank->name = name;
 879                                 info_bank->target = bank->target;
 880                                 info_bank->driver = bank->driver;
 881                                 info_bank->driver_priv = bank->driver_priv;
 882                                 info_bank->bank_number = 1;
 883                                 info_bank->base = 0x00200000;
 884                                 info_bank->size = 0;
 885                                 info_bank->chip_width = 0;
 886                                 info_bank->bus_width = 0;
 887                                 info_bank->erased_value = 0xff;
 888                                 info_bank->default_padded_value = 0xff;
 889                                 info_bank->write_start_alignment = 0;
 890                                 info_bank->write_end_alignment = 0;
 891                                 info_bank->minimal_write_gap = FLASH_WRITE_GAP_SECTOR;
 892                                 info_bank->num_sectors = 0;
 893                                 info_bank->sectors = NULL;
 894                                 info_bank->num_prot_blocks = 0;
 895                                 info_bank->prot_blocks = NULL;
 896                                 info_bank->next = NULL;
 897
 898                                 /* Enable the new bank */
 899                                 bank->next = info_bank;
 900                         }
 901                 }
 902         }
 903
 904         if (MSP432P4 == msp432_bank->family_type) {
 905                 /* Set up MSP432P4 specific flash parameters */
 906                 if (0 == bank_id) {
 907                         retval = target_read_u32(target, P4_FLASH_MAIN_SIZE_REG, &size);
 908                         if (ERROR_OK != retval)
 909                                 return retval;
 910
 911                         base = P4_FLASH_MAIN_BASE;
 912                         sector_length = P4_SECTOR_LENGTH;
 913                         num_sectors = size / sector_length;
 914                 } else if (1 == bank_id) {
 915                         if (msp432_bank->device_type == MSP432P411X ||
 916                                 msp432_bank->device_type == MSP432P411X_GUESS) {
 917                                 /* MSP432P411x has an info size register, use that for size */
 918                                 retval = target_read_u32(target, P4_FLASH_INFO_SIZE_REG, &size);
 919                                 if (ERROR_OK != retval)
 920                                         return retval;
 921                         } else {
 922                                 /* All other MSP432P401x devices have fixed info region size */
 923                                 size = 0x4000; /* 16 KB info region */
 924                         }
 925                         base = P4_FLASH_INFO_BASE;
 926                         sector_length = P4_SECTOR_LENGTH;
 927                         num_sectors = size / sector_length;
 928                 } else {
 929                         /* Invalid bank number somehow */
 930                         return ERROR_FAIL;
 931                 }
 932         } else {
 933                 /* Set up MSP432E4 specific flash parameters */
 934                 base = E4_FLASH_BASE;
 935                 size = E4_FLASH_SIZE;
 936                 sector_length = E4_SECTOR_LENGTH;
 937                 num_sectors = size / sector_length;
 938         }
 939
 940         if (NULL != bank->sectors) {
 941                 free(bank->sectors);
 942                 bank->sectors = NULL;
 943         }
 944
 945         bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors);
 946         if (NULL == bank->sectors)
 947                 return ERROR_FAIL;
 948
 949         bank->base = base;
 950         bank->size = size;
 951         bank->write_start_alignment = 0;
 952         bank->write_end_alignment = 0;
 953         bank->num_sectors = num_sectors;
 954         msp432_bank->sector_length = sector_length;
 955
 956         for (int i = 0; i < num_sectors; i++) {
 957                 bank->sectors[i].offset = i * sector_length;
 958                 bank->sectors[i].size = sector_length;
 959                 bank->sectors[i].is_erased = -1;
 960                 bank->sectors[i].is_protected = 0;
 961         }
 962
 963         /* We've successfully determined the stats on this flash bank */
 964         msp432_bank->probed[bank_id] = true;
 965
 966         /* If we fall through to here, then all went well */
 967
 968         return ERROR_OK;
 969 }
 970
 971 static int msp432_auto_probe(struct flash_bank *bank)
 972 {
 973         struct msp432_bank *msp432_bank = bank->driver_priv;
 974
 975         int retval = ERROR_OK;
 976
 977         if (bank->bank_number < 0 || bank->bank_number > 1) {
 978                 /* Invalid bank number somehow */
 979                 return ERROR_FAIL;
 980         }
 981
 982         if (!msp432_bank->probed[bank->bank_number])
 983                 retval = msp432_probe(bank);
 984
 985         return retval;
 986 }
 987
 988 static int msp432_protect_check(struct flash_bank *bank)
 989 {
 990         return ERROR_OK;
 991 }
 992
 993 static int msp432_info(struct flash_bank *bank, char *buf, int buf_size)
 994 {
 995         struct msp432_bank *msp432_bank = bank->driver_priv;
 996         int printed = 0;
 997
 998         switch (msp432_bank->device_type) {
 999                 case MSP432P401X_DEPR:
1000                         if (0xFFFF == msp432_bank->device_id) {
1001                                 /* Very early pre-production silicon currently deprecated */
1002                                 printed = snprintf(buf, buf_size,
1003                                         "MSP432P401x pre-production device (deprecated silicon)\n"
1004                                         SUPPORT_MESSAGE);
1005                         } else {
1006                                 /* Revision A or B silicon, also deprecated */
1007                                 printed = snprintf(buf, buf_size,
1008                                         "MSP432P401x Device Rev %c (deprecated silicon)\n"
1009                                         SUPPORT_MESSAGE, (char)msp432_bank->hardware_rev);
1010                         }
1011                         break;
1012                 case MSP432P401X:
1013                         printed = snprintf(buf, buf_size,
1014                                 "MSP432P401x Device Rev %c\n",
1015                                 (char)msp432_bank->hardware_rev);
1016                         break;
1017                 case MSP432P411X:
1018                         printed = snprintf(buf, buf_size,
1019                                 "MSP432P411x Device Rev %c\n",
1020                                 (char)msp432_bank->hardware_rev);
1021                         break;
1022                 case MSP432E401Y:
1023                         printed = snprintf(buf, buf_size, "MSP432E401Y Device\n");
1024                         break;
1025                 case MSP432E411Y:
1026                         printed = snprintf(buf, buf_size, "MSP432E411Y Device\n");
1027                         break;
1028                 case MSP432E4X_GUESS:
1029                         printed = snprintf(buf, buf_size,
1030                                 "Unrecognized MSP432E4 DID0 and DID1 IDs (%08X, %08X)",
1031                                 msp432_bank->device_id, msp432_bank->hardware_rev);
1032                         break;
1033                 case MSP432P401X_GUESS:
1034                 case MSP432P411X_GUESS:
1035                 default:
1036                         printed = snprintf(buf, buf_size,
1037                                 "Unrecognized MSP432P4 Device ID and Hardware Rev (%04X, %02X)",
1038                                 msp432_bank->device_id, msp432_bank->hardware_rev);
1039                         break;
1040         }
1041
1042         buf_size -= printed;
1043
1044         if (0 > buf_size)
1045                 return ERROR_BUF_TOO_SMALL;
1046
1047         return ERROR_OK;
1048 }
1049
1050 static void msp432_flash_free_driver_priv(struct flash_bank *bank)
1051 {
1052         /* A single private struct is shared between main and info banks */
1053         /* Only free it on the call for main bank (#0) */
1054         if ((0 == bank->bank_number) && (NULL != bank->driver_priv))
1055                 free(bank->driver_priv);
1056         /* Forget about the private struct on both main and info banks */
1057         bank->driver_priv = NULL;
1058 }
1059
1060 static const struct command_registration msp432_exec_command_handlers[] = {
1061         {
1062                 .name = "mass_erase",
1063                 .handler = msp432_mass_erase_command,
1064                 .mode = COMMAND_EXEC,
1065                 .help = "Erase entire flash memory on device.",
1066                 .usage = "['main' | 'all']",
1067         },
1068         {
1069                 .name = "bsl",
1070                 .handler = msp432_bsl_command,
1071                 .mode = COMMAND_EXEC,
1072                 .help = "Allow BSL to be erased or written by flash commands.",
1073                 .usage = "['unlock' | 'lock']",
1074         },
1075         COMMAND_REGISTRATION_DONE
1076 };
1077
1078 static const struct command_registration msp432_command_handlers[] = {
1079         {
1080                 .name = "msp432",
1081                 .mode = COMMAND_EXEC,
1082                 .help = "MSP432 flash command group",
1083                 .usage = "",
1084                 .chain = msp432_exec_command_handlers,
1085         },
1086         COMMAND_REGISTRATION_DONE
1087 };
1088
1089 struct flash_driver msp432_flash = {
1090         .name = "msp432",
1091         .commands = msp432_command_handlers,
1092         .flash_bank_command = msp432_flash_bank_command,
1093         .erase = msp432_erase,
1094         .protect = msp432_protect,
1095         .write = msp432_write,
1096         .read = default_flash_read,
1097         .probe = msp432_probe,
1098         .auto_probe = msp432_auto_probe,
1099         .erase_check = default_flash_blank_check,
1100         .protect_check = msp432_protect_check,
1101         .info = msp432_info,
1102         .free_driver_priv = msp432_flash_free_driver_priv,
1103 };