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

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de>              *
   3  *   Copyright (C) 2007,2008 Øyvind Harboe <oyvind.harboe@zylin.com>       *
   4  *   Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk>           *
   5  *   Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net>             *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  21  ***************************************************************************/
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include "imp.h"
  26 #include <helper/time_support.h>
  27 #include <target/image.h>
  28
  29 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
  30                 struct flash_bank **bank)
  31 {
  32         const char *name = CMD_ARGV[name_index];
  33         *bank = get_flash_bank_by_name(name);
  34         if (*bank)
  35                 return ERROR_OK;
  36
  37         unsigned bank_num;
  38         COMMAND_PARSE_NUMBER(uint, name, bank_num);
  39
  40         *bank = get_flash_bank_by_num(bank_num);
  41         if (!*bank)
  42         {
  43                 command_print(CMD_CTX, "flash bank '%s' not found", name);
  44                 return ERROR_INVALID_ARGUMENTS;
  45         }
  46         return ERROR_OK;
  47 }
  48
  49
  50 COMMAND_HANDLER(handle_flash_info_command)
  51 {
  52         struct flash_bank *p;
  53         uint32_t i = 0;
  54         int j = 0;
  55         int retval;
  56
  57         if (CMD_ARGC != 1)
  58                 return ERROR_COMMAND_SYNTAX_ERROR;
  59
  60         unsigned bank_nr;
  61         COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
  62
  63         for (p = flash_bank_list(); p; p = p->next, i++)
  64         {
  65                 if (i != bank_nr)
  66                         continue;
  67
  68                 char buf[1024];
  69
  70                 /* attempt auto probe */
  71                 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
  72                         return retval;
  73
  74                 command_print(CMD_CTX,
  75                               "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
  76                               i,
  77                               p->driver->name,
  78                               p->base,
  79                               p->size,
  80                               p->bus_width,
  81                               p->chip_width);
  82                 for (j = 0; j < p->num_sectors; j++)
  83                 {
  84                         char *protect_state;
  85
  86                         if (p->sectors[j].is_protected == 0)
  87                                 protect_state = "not protected";
  88                         else if (p->sectors[j].is_protected == 1)
  89                                 protect_state = "protected";
  90                         else
  91                                 protect_state = "protection state unknown";
  92
  93                         command_print(CMD_CTX,
  94                                       "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
  95                                       j,
  96                                       p->sectors[j].offset,
  97                                       p->sectors[j].size,
  98                                       p->sectors[j].size >> 10,
  99                                       protect_state);
 100                 }
 101
 102                 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
 103                 retval = p->driver->info(p, buf, sizeof(buf));
 104                 command_print(CMD_CTX, "%s", buf);
 105                 if (retval != ERROR_OK)
 106                         LOG_ERROR("error retrieving flash info (%d)", retval);
 107         }
 108
 109         return ERROR_OK;
 110 }
 111
 112 COMMAND_HANDLER(handle_flash_probe_command)
 113 {
 114         int retval;
 115
 116         if (CMD_ARGC != 1)
 117         {
 118                 return ERROR_COMMAND_SYNTAX_ERROR;
 119         }
 120
 121         unsigned bank_nr;
 122         COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
 123         struct flash_bank *p = get_flash_bank_by_num_noprobe(bank_nr);
 124         if (p)
 125         {
 126                 if ((retval = p->driver->probe(p)) == ERROR_OK)
 127                 {
 128                         command_print(CMD_CTX, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
 129                 }
 130                 else if (retval == ERROR_FLASH_BANK_INVALID)
 131                 {
 132                         command_print(CMD_CTX, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
 133                                                   CMD_ARGV[0], p->base);
 134                 }
 135                 else
 136                 {
 137                         command_print(CMD_CTX, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
 138                                                   CMD_ARGV[0], p->base);
 139                 }
 140         }
 141         else
 142         {
 143                 command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
 144         }
 145
 146         return ERROR_OK;
 147 }
 148
 149 COMMAND_HANDLER(handle_flash_erase_check_command)
 150 {
 151         if (CMD_ARGC != 1)
 152         {
 153                 return ERROR_COMMAND_SYNTAX_ERROR;
 154         }
 155
 156         struct flash_bank *p;
 157         int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 158         if (ERROR_OK != retval)
 159                 return retval;
 160
 161         int j;
 162         if ((retval = p->driver->erase_check(p)) == ERROR_OK)
 163         {
 164                 command_print(CMD_CTX, "successfully checked erase state");
 165         }
 166         else
 167         {
 168                 command_print(CMD_CTX, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
 169                         CMD_ARGV[0], p->base);
 170         }
 171
 172         for (j = 0; j < p->num_sectors; j++)
 173         {
 174                 char *erase_state;
 175
 176                 if (p->sectors[j].is_erased == 0)
 177                         erase_state = "not erased";
 178                 else if (p->sectors[j].is_erased == 1)
 179                         erase_state = "erased";
 180                 else
 181                         erase_state = "erase state unknown";
 182
 183                 command_print(CMD_CTX,
 184                               "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
 185                               j,
 186                               p->sectors[j].offset,
 187                               p->sectors[j].size,
 188                               p->sectors[j].size >> 10,
 189                               erase_state);
 190         }
 191
 192         return ERROR_OK;
 193 }
 194
 195 COMMAND_HANDLER(handle_flash_erase_address_command)
 196 {
 197         struct flash_bank *p;
 198         int retval;
 199         int address;
 200         int length;
 201
 202         struct target *target = get_current_target(CMD_CTX);
 203
 204         if (CMD_ARGC != 2)
 205                 return ERROR_COMMAND_SYNTAX_ERROR;
 206
 207         COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], address);
 208         COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], length);
 209         if (length <= 0)
 210         {
 211                 command_print(CMD_CTX, "Length must be >0");
 212                 return ERROR_COMMAND_SYNTAX_ERROR;
 213         }
 214
 215         p = get_flash_bank_by_addr(target, address);
 216         if (p == NULL)
 217         {
 218                 return ERROR_FAIL;
 219         }
 220
 221         /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
 222         flash_set_dirty();
 223
 224         struct duration bench;
 225         duration_start(&bench);
 226
 227         retval = flash_erase_address_range(target, address, length);
 228
 229         if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 230         {
 231                 command_print(CMD_CTX, "erased address 0x%8.8x (length %i)"
 232                                 " in %fs (%0.3f kb/s)", address, length,
 233                                 duration_elapsed(&bench), duration_kbps(&bench, length));
 234         }
 235
 236         return retval;
 237 }
 238
 239 COMMAND_HANDLER(handle_flash_protect_check_command)
 240 {
 241         if (CMD_ARGC != 1)
 242                 return ERROR_COMMAND_SYNTAX_ERROR;
 243
 244         struct flash_bank *p;
 245         int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 246         if (ERROR_OK != retval)
 247                 return retval;
 248
 249         if ((retval = p->driver->protect_check(p)) == ERROR_OK)
 250         {
 251                 command_print(CMD_CTX, "successfully checked protect state");
 252         }
 253         else if (retval == ERROR_FLASH_OPERATION_FAILED)
 254         {
 255                 command_print(CMD_CTX, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
 256         }
 257         else
 258         {
 259                 command_print(CMD_CTX, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
 260         }
 261
 262         return ERROR_OK;
 263 }
 264
 265 static int flash_check_sector_parameters(struct command_context *cmd_ctx,
 266                 uint32_t first, uint32_t last, uint32_t num_sectors)
 267 {
 268         if (!(first <= last)) {
 269                 command_print(cmd_ctx, "ERROR: "
 270                                 "first sector must be <= last sector");
 271                 return ERROR_FAIL;
 272         }
 273
 274         if (!(last <= (num_sectors - 1))) {
 275                 command_print(cmd_ctx, "ERROR: last sector must be <= %d",
 276                                 (int) num_sectors - 1);
 277                 return ERROR_FAIL;
 278         }
 279
 280         return ERROR_OK;
 281 }
 282
 283 COMMAND_HANDLER(handle_flash_erase_command)
 284 {
 285         if (CMD_ARGC != 3)
 286                 return ERROR_COMMAND_SYNTAX_ERROR;
 287
 288         uint32_t bank_nr;
 289         uint32_t first;
 290         uint32_t last;
 291
 292         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
 293         struct flash_bank *p = get_flash_bank_by_num(bank_nr);
 294         if (!p)
 295                 return ERROR_OK;
 296
 297         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
 298         if (strcmp(CMD_ARGV[2], "last") == 0)
 299                 last = p->num_sectors - 1;
 300         else
 301                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
 302
 303         int retval;
 304         if ((retval = flash_check_sector_parameters(CMD_CTX,
 305                         first, last, p->num_sectors)) != ERROR_OK)
 306                 return retval;
 307
 308         struct duration bench;
 309         duration_start(&bench);
 310
 311         retval = flash_driver_erase(p, first, last);
 312
 313         if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 314         {
 315                 command_print(CMD_CTX, "erased sectors %" PRIu32 " "
 316                                 "through %" PRIu32" on flash bank %" PRIu32 " "
 317                                 "in %fs", first, last, bank_nr, duration_elapsed(&bench));
 318         }
 319
 320         return ERROR_OK;
 321 }
 322
 323 COMMAND_HANDLER(handle_flash_protect_command)
 324 {
 325         if (CMD_ARGC != 4)
 326                 return ERROR_COMMAND_SYNTAX_ERROR;
 327
 328         uint32_t bank_nr;
 329         uint32_t first;
 330         uint32_t last;
 331
 332         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
 333         struct flash_bank *p = get_flash_bank_by_num(bank_nr);
 334         if (!p)
 335                 return ERROR_OK;
 336
 337         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
 338         if (strcmp(CMD_ARGV[2], "last") == 0)
 339                 last = p->num_sectors - 1;
 340         else
 341                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
 342
 343         bool set;
 344         COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
 345
 346         int retval;
 347         if ((retval = flash_check_sector_parameters(CMD_CTX,
 348                         first, last, p->num_sectors)) != ERROR_OK)
 349                 return retval;
 350
 351         retval = flash_driver_protect(p, set, first, last);
 352         if (retval == ERROR_OK) {
 353                 command_print(CMD_CTX, "%s protection for sectors %i "
 354                                 "through %i on flash bank %i",
 355                         (set) ? "set" : "cleared", (int) first,
 356                         (int) last, (int) bank_nr);
 357         }
 358
 359         return ERROR_OK;
 360 }
 361
 362 COMMAND_HANDLER(handle_flash_write_image_command)
 363 {
 364         struct target *target = get_current_target(CMD_CTX);
 365
 366         struct image image;
 367         uint32_t written;
 368
 369         int retval;
 370
 371         if (CMD_ARGC < 1)
 372         {
 373                 return ERROR_COMMAND_SYNTAX_ERROR;
 374         }
 375
 376         /* flash auto-erase is disabled by default*/
 377         int auto_erase = 0;
 378         bool auto_unlock = false;
 379
 380         for (;;)
 381         {
 382                 if (strcmp(CMD_ARGV[0], "erase") == 0)
 383                 {
 384                         auto_erase = 1;
 385                         CMD_ARGV++;
 386                         CMD_ARGC--;
 387                         command_print(CMD_CTX, "auto erase enabled");
 388                 } else if (strcmp(CMD_ARGV[0], "unlock") == 0)
 389                 {
 390                         auto_unlock = true;
 391                         CMD_ARGV++;
 392                         CMD_ARGC--;
 393                         command_print(CMD_CTX, "auto unlock enabled");
 394                 } else
 395                 {
 396                         break;
 397                 }
 398         }
 399
 400         if (CMD_ARGC < 1)
 401         {
 402                 return ERROR_COMMAND_SYNTAX_ERROR;
 403         }
 404
 405         if (!target)
 406         {
 407                 LOG_ERROR("no target selected");
 408                 return ERROR_FAIL;
 409         }
 410
 411         struct duration bench;
 412         duration_start(&bench);
 413
 414         if (CMD_ARGC >= 2)
 415         {
 416                 image.base_address_set = 1;
 417                 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], image.base_address);
 418         }
 419         else
 420         {
 421                 image.base_address_set = 0;
 422                 image.base_address = 0x0;
 423         }
 424
 425         image.start_address_set = 0;
 426
 427         retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
 428         if (retval != ERROR_OK)
 429         {
 430                 return retval;
 431         }
 432
 433         retval = flash_write_unlock(target, &image, &written, auto_erase, auto_unlock);
 434         if (retval != ERROR_OK)
 435         {
 436                 image_close(&image);
 437                 return retval;
 438         }
 439
 440         if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 441         {
 442                 command_print(CMD_CTX, "wrote %" PRIu32 " byte from file %s "
 443                                 "in %fs (%0.3f kb/s)", written, CMD_ARGV[0],
 444                                 duration_elapsed(&bench), duration_kbps(&bench, written));
 445         }
 446
 447         image_close(&image);
 448
 449         return retval;
 450 }
 451
 452 COMMAND_HANDLER(handle_flash_fill_command)
 453 {
 454         int err = ERROR_OK;
 455         uint32_t address;
 456         uint32_t pattern;
 457         uint32_t count;
 458         uint32_t wrote = 0;
 459         uint32_t cur_size = 0;
 460         uint32_t chunk_count;
 461         struct target *target = get_current_target(CMD_CTX);
 462         uint32_t i;
 463         uint32_t wordsize;
 464         int retval = ERROR_OK;
 465
 466         static size_t const chunksize = 1024;
 467         uint8_t *chunk = malloc(chunksize);
 468         if (chunk == NULL)
 469                 return ERROR_FAIL;
 470
 471         uint8_t *readback = malloc(chunksize);
 472         if (readback == NULL)
 473         {
 474                 free(chunk);
 475                 return ERROR_FAIL;
 476         }
 477
 478
 479         if (CMD_ARGC != 3)
 480         {
 481                 retval = ERROR_COMMAND_SYNTAX_ERROR;
 482                 goto done;
 483         }
 484
 485
 486         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
 487         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern);
 488         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
 489
 490         if (count == 0)
 491                 goto done;
 492
 493         switch (CMD_NAME[4])
 494         {
 495         case 'w':
 496                 wordsize = 4;
 497                 break;
 498         case 'h':
 499                 wordsize = 2;
 500                 break;
 501         case 'b':
 502                 wordsize = 1;
 503                 break;
 504         default:
 505                 retval = ERROR_COMMAND_SYNTAX_ERROR;
 506                 goto done;
 507         }
 508
 509         chunk_count = MIN(count, (chunksize / wordsize));
 510         switch (wordsize)
 511         {
 512         case 4:
 513                 for (i = 0; i < chunk_count; i++)
 514                 {
 515                         target_buffer_set_u32(target, chunk + i * wordsize, pattern);
 516                 }
 517                 break;
 518         case 2:
 519                 for (i = 0; i < chunk_count; i++)
 520                 {
 521                         target_buffer_set_u16(target, chunk + i * wordsize, pattern);
 522                 }
 523                 break;
 524         case 1:
 525                 memset(chunk, pattern, chunk_count);
 526                 break;
 527         default:
 528                 LOG_ERROR("BUG: can't happen");
 529                 exit(-1);
 530         }
 531
 532         struct duration bench;
 533         duration_start(&bench);
 534
 535         for (wrote = 0; wrote < (count*wordsize); wrote += cur_size)
 536         {
 537                 struct flash_bank *bank;
 538
 539                 bank = get_flash_bank_by_addr(target, address);
 540                 if (bank == NULL)
 541                 {
 542                         retval = ERROR_FAIL;
 543                         goto done;
 544                 }
 545
 546                 cur_size = MIN((count * wordsize - wrote), chunksize);
 547                 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
 548                 if (err != ERROR_OK)
 549                 {
 550                         retval = err;
 551                         goto done;
 552                 }
 553
 554                 err = target_read_buffer(target, address + wrote, cur_size, readback);
 555                 if (err != ERROR_OK)
 556                 {
 557                         retval = err;
 558                         goto done;
 559                 }
 560
 561                 unsigned i;
 562                 for (i = 0; i < cur_size; i++)
 563                 {
 564                         if (readback[i]!=chunk[i])
 565                         {
 566                                 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
 567                                                   address + wrote + i, readback[i], chunk[i]);
 568                                 retval = ERROR_FAIL;
 569                                 goto done;
 570                         }
 571                 }
 572         }
 573
 574         if (duration_measure(&bench) == ERROR_OK)
 575         {
 576                 command_print(CMD_CTX, "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32
 577                                 " in %fs (%0.3f kb/s)", wrote, address,
 578                                 duration_elapsed(&bench), duration_kbps(&bench, wrote));
 579         }
 580
 581 done:
 582         free(readback);
 583         free(chunk);
 584
 585         return retval;
 586 }
 587
 588 COMMAND_HANDLER(handle_flash_write_bank_command)
 589 {
 590         uint32_t offset;
 591         uint8_t *buffer;
 592         struct fileio fileio;
 593
 594         if (CMD_ARGC != 3)
 595                 return ERROR_COMMAND_SYNTAX_ERROR;
 596
 597         struct duration bench;
 598         duration_start(&bench);
 599
 600         struct flash_bank *p;
 601         int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 602         if (ERROR_OK != retval)
 603                 return retval;
 604
 605         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
 606
 607         if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
 608         {
 609                 return ERROR_OK;
 610         }
 611
 612         buffer = malloc(fileio.size);
 613         size_t buf_cnt;
 614         if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
 615         {
 616                 free(buffer);
 617                 fileio_close(&fileio);
 618                 return ERROR_OK;
 619         }
 620
 621         retval = flash_driver_write(p, buffer, offset, buf_cnt);
 622
 623         free(buffer);
 624         buffer = NULL;
 625
 626         if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
 627         {
 628                 command_print(CMD_CTX, "wrote %zu byte from file %s to flash bank %u"
 629                                 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f kb/s)",
 630                                 fileio.size, CMD_ARGV[1], p->bank_number, offset,
 631                                 duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
 632         }
 633
 634         fileio_close(&fileio);
 635
 636         return retval;
 637 }
 638
 639 void flash_set_dirty(void)
 640 {
 641         struct flash_bank *c;
 642         int i;
 643
 644         /* set all flash to require erasing */
 645         for (c = flash_bank_list(); c; c = c->next)
 646         {
 647                 for (i = 0; i < c->num_sectors; i++)
 648                 {
 649                         c->sectors[i].is_erased = 0;
 650                 }
 651         }
 652 }
 653
 654 static const struct command_registration flash_exec_command_handlers[] = {
 655         {
 656                 .name = "probe",
 657                 .handler = &handle_flash_probe_command,
 658                 .mode = COMMAND_EXEC,
 659                 .usage = "<bank>",
 660                 .help = "identify flash bank",
 661         },
 662         {
 663                 .name = "info",
 664                 .handler = &handle_flash_info_command,
 665                 .mode = COMMAND_EXEC,
 666                 .usage = "<bank>",
 667                 .help = "print bank information",
 668         },
 669         {
 670                 .name = "erase_check",
 671                 .handler = &handle_flash_erase_check_command,
 672                 .mode = COMMAND_EXEC,
 673                 .usage = "<bank>",
 674                 .help = "check erase state of sectors",
 675         },
 676         {
 677                 .name = "protect_check",
 678                 .handler = &handle_flash_protect_check_command,
 679                 .mode = COMMAND_EXEC,
 680                 .usage = "<bank>",
 681                 .help = "check protection state of sectors",
 682         },
 683         {
 684                 .name = "erase_sector",
 685                 .handler = &handle_flash_erase_command,
 686                 .mode = COMMAND_EXEC,
 687                 .usage = "<bank> <first> <last>",
 688                 .help = "erase sectors",
 689         },
 690         {
 691                 .name = "erase_address",
 692                 .handler = &handle_flash_erase_address_command,
 693                 .mode = COMMAND_EXEC,
 694                 .usage = "<address> <length>",
 695                 .help = "erase address range",
 696
 697         },
 698         {
 699                 .name = "fillw",
 700                 .handler = &handle_flash_fill_command,
 701                 .mode = COMMAND_EXEC,
 702                 .usage = "<address> <word_pattern> <count>",
 703                 .help = "fill with pattern (no autoerase)",
 704         },
 705         {
 706                 .name = "fillh",
 707                 .handler = &handle_flash_fill_command,
 708                 .mode = COMMAND_EXEC,
 709                 .usage = "<address> <halfword_pattern> <count>",
 710                 .help = "fill with pattern",
 711         },
 712         {
 713                 .name = "fillb",
 714                 .handler = &handle_flash_fill_command,
 715                 .mode = COMMAND_EXEC,
 716                 .usage = "<address> <byte_pattern> <count>",
 717                 .help = "fill with pattern",
 718
 719         },
 720         {
 721                 .name = "write_bank",
 722                 .handler = &handle_flash_write_bank_command,
 723                 .mode = COMMAND_EXEC,
 724                 .usage = "<bank> <file> <offset>",
 725                 .help = "write binary data",
 726         },
 727         {
 728                 .name = "write_image",
 729                 .handler = &handle_flash_write_image_command,
 730                 .mode = COMMAND_EXEC,
 731                 .usage = "[erase] [unlock] <file> [offset] [type]",
 732                 .help = "write an image to flash"
 733         },
 734         {
 735                 .name = "protect",
 736                 .handler = &handle_flash_protect_command,
 737                 .mode = COMMAND_EXEC,
 738                 .usage = "<bank> <first> <last> <on | off>",
 739                 .help = "set protection of sectors",
 740         },
 741         COMMAND_REGISTRATION_DONE
 742 };
 743
 744 int flash_init_drivers(struct command_context *cmd_ctx)
 745 {
 746         if (!flash_bank_list())
 747                 return ERROR_OK;
 748
 749         struct command *parent = command_find_in_context(cmd_ctx, "flash");
 750         return register_commands(cmd_ctx, parent, flash_exec_command_handlers);
 751 }
 752
 753
 754 COMMAND_HANDLER(handle_flash_bank_command)
 755 {
 756         if (CMD_ARGC < 7)
 757         {
 758                 LOG_ERROR("usage: flash bank <name> <driver> "
 759                                 "<base> <size> <chip_width> <bus_width>");
 760                 return ERROR_COMMAND_SYNTAX_ERROR;
 761         }
 762         // save bank name and advance arguments for compatibility
 763         const char *bank_name = *CMD_ARGV++;
 764         CMD_ARGC--;
 765
 766         struct target *target;
 767         if ((target = get_target(CMD_ARGV[5])) == NULL)
 768         {
 769                 LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
 770                 return ERROR_FAIL;
 771         }
 772
 773         const char *driver_name = CMD_ARGV[0];
 774         struct flash_driver *driver = flash_driver_find_by_name(driver_name);
 775         if (NULL == driver)
 776         {
 777                 /* no matching flash driver found */
 778                 LOG_ERROR("flash driver '%s' not found", driver_name);
 779                 return ERROR_FAIL;
 780         }
 781
 782         /* register flash specific commands */
 783         if (NULL != driver->commands)
 784         {
 785                 int retval = register_commands(CMD_CTX, NULL,
 786                                 driver->commands);
 787                 if (ERROR_OK != retval)
 788                 {
 789                         LOG_ERROR("couldn't register '%s' commands",
 790                                         driver_name);
 791                         return ERROR_FAIL;
 792                 }
 793         }
 794
 795         struct flash_bank *c = malloc(sizeof(*c));
 796         c->name = strdup(bank_name);
 797         c->target = target;
 798         c->driver = driver;
 799         c->driver_priv = NULL;
 800         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], c->base);
 801         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
 802         COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], c->chip_width);
 803         COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], c->bus_width);
 804         c->num_sectors = 0;
 805         c->sectors = NULL;
 806         c->next = NULL;
 807
 808         int retval;
 809         retval = CALL_COMMAND_HANDLER(driver->flash_bank_command, c);
 810         if (ERROR_OK != retval)
 811         {
 812                 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32,
 813                                 driver_name, c->base);
 814                 free(c);
 815                 return retval;
 816         }
 817
 818         flash_bank_add(c);
 819
 820         return ERROR_OK;
 821 }
 822
 823 COMMAND_HANDLER(handle_flash_banks_command)
 824 {
 825         if (CMD_ARGC != 0)
 826                 return ERROR_INVALID_ARGUMENTS;
 827
 828         unsigned n = 0;
 829         for (struct flash_bank *p = flash_bank_list(); p; p = p->next, n++)
 830         {
 831                 LOG_USER("#%u: %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", "
 832                         "buswidth %u, chipwidth %u", n,
 833                         p->driver->name, p->base, p->size,
 834                         p->bus_width, p->chip_width);
 835         }
 836         return ERROR_OK;
 837 }
 838
 839 static int jim_flash_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 840 {
 841         if (argc != 1)
 842         {
 843                 Jim_WrongNumArgs(interp, 1, argv,
 844                                 "no arguments to 'flash list' command");
 845                 return JIM_ERR;
 846         }
 847
 848         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
 849
 850         for (struct flash_bank *p = flash_bank_list(); p; p = p->next)
 851         {
 852                 Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
 853
 854                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
 855                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
 856                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
 857                 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
 858                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
 859                 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
 860                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
 861                 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
 862                 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
 863                 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
 864
 865                 Jim_ListAppendElement(interp, list, elem);
 866         }
 867
 868         Jim_SetResult(interp, list);
 869
 870         return JIM_OK;
 871 }
 872
 873
 874 COMMAND_HANDLER(handle_flash_init_command)
 875 {
 876         if (CMD_ARGC != 0)
 877                 return ERROR_COMMAND_SYNTAX_ERROR;
 878
 879         static bool flash_initialized = false;
 880         if (flash_initialized)
 881         {
 882                 LOG_INFO("'flash init' has already been called");
 883                 return ERROR_OK;
 884         }
 885         flash_initialized = true;
 886
 887         LOG_DEBUG("Initializing flash devices...");
 888         return flash_init_drivers(CMD_CTX);
 889 }
 890
 891 static const struct command_registration flash_config_command_handlers[] = {
 892         {
 893                 .name = "bank",
 894                 .handler = &handle_flash_bank_command,
 895                 .mode = COMMAND_CONFIG,
 896                 .usage = "<name> <driver> <base> <size> "
 897                         "<chip_width> <bus_width> <target> "
 898                         "[driver_options ...]",
 899                 .help = "Define a new bank with the given name, "
 900                         "using the specified NOR flash driver.",
 901         },
 902         {
 903                 .name = "init",
 904                 .mode = COMMAND_CONFIG,
 905                 .handler = &handle_flash_init_command,
 906                 .help = "initialize flash devices",
 907         },
 908         {
 909                 .name = "banks",
 910                 .mode = COMMAND_ANY,
 911                 .handler = &handle_flash_banks_command,
 912                 .help = "return readable information about the flash banks",
 913         },
 914         {
 915                 .name = "list",
 916                 .mode = COMMAND_ANY,
 917                 .jim_handler = &jim_flash_list,
 918                 .help = "returns a list of details about the flash banks",
 919         },
 920         COMMAND_REGISTRATION_DONE
 921 };
 922 static const struct command_registration flash_command_handlers[] = {
 923         {
 924                 .name = "flash",
 925                 .mode = COMMAND_ANY,
 926                 .help = "NOR flash command group",
 927                 .chain = flash_config_command_handlers,
 928         },
 929         COMMAND_REGISTRATION_DONE
 930 };
 931
 932 int flash_register_commands(struct command_context *cmd_ctx)
 933 {
 934         return register_commands(cmd_ctx, NULL, flash_command_handlers);
 935 }