git.gag.com Git - fw/openocd/blob - src/flash/nor/core.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
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26 #include <flash/common.h>
  27 #include <flash/nor/core.h>
  28 #include <flash/nor/imp.h>
  29 #include <target/image.h>
  30
  31
  32 struct flash_bank *flash_banks;
  33
  34 int flash_driver_erase(struct flash_bank *bank, int first, int last)
  35 {
  36         int retval;
  37
  38         retval = bank->driver->erase(bank, first, last);
  39         if (retval != ERROR_OK)
  40         {
  41                 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
  42         }
  43
  44         return retval;
  45 }
  46
  47 int flash_driver_protect(struct flash_bank *bank, int set, int first, int last)
  48 {
  49         int retval;
  50
  51         retval = bank->driver->protect(bank, set, first, last);
  52         if (retval != ERROR_OK)
  53         {
  54                 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
  55         }
  56
  57         return retval;
  58 }
  59
  60 int flash_driver_write(struct flash_bank *bank,
  61                 uint8_t *buffer, uint32_t offset, uint32_t count)
  62 {
  63         int retval;
  64
  65         retval = bank->driver->write(bank, buffer, offset, count);
  66         if (retval != ERROR_OK)
  67         {
  68                 LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
  69                           bank->base, offset, retval);
  70         }
  71
  72         return retval;
  73 }
  74
  75 void flash_bank_add(struct flash_bank *bank)
  76 {
  77         /* put flash bank in linked list */
  78         unsigned bank_num = 0;
  79         if (flash_banks)
  80         {
  81                 /* find last flash bank */
  82                 struct flash_bank *p = flash_banks;
  83                 while (NULL != p->next)
  84                 {
  85                         bank_num += 1;
  86                         p = p->next;
  87                 }
  88                 p->next = bank;
  89                 bank_num += 1;
  90         }
  91         else
  92                 flash_banks = bank;
  93
  94         bank->bank_number = bank_num;
  95 }
  96
  97 struct flash_bank *flash_bank_list(void)
  98 {
  99         return flash_banks;
 100 }
 101
 102 struct flash_bank *get_flash_bank_by_num_noprobe(int num)
 103 {
 104         struct flash_bank *p;
 105         int i = 0;
 106
 107         for (p = flash_banks; p; p = p->next)
 108         {
 109                 if (i++ == num)
 110                 {
 111                         return p;
 112                 }
 113         }
 114         LOG_ERROR("flash bank %d does not exist", num);
 115         return NULL;
 116 }
 117
 118 int flash_get_bank_count(void)
 119 {
 120         struct flash_bank *p;
 121         int i = 0;
 122         for (p = flash_banks; p; p = p->next)
 123         {
 124                 i++;
 125         }
 126         return i;
 127 }
 128
 129 struct flash_bank *get_flash_bank_by_name(const char *name)
 130 {
 131         unsigned requested = get_flash_name_index(name);
 132         unsigned found = 0;
 133
 134         struct flash_bank *bank;
 135         for (bank = flash_banks; NULL != bank; bank = bank->next)
 136         {
 137                 if (strcmp(bank->name, name) == 0)
 138                         return bank;
 139                 if (!flash_driver_name_matches(bank->driver->name, name))
 140                         continue;
 141                 if (++found < requested)
 142                         continue;
 143                 return bank;
 144         }
 145         return NULL;
 146 }
 147
 148 struct flash_bank *get_flash_bank_by_num(int num)
 149 {
 150         struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
 151         int retval;
 152
 153         if (p == NULL)
 154                 return NULL;
 155
 156         retval = p->driver->auto_probe(p);
 157
 158         if (retval != ERROR_OK)
 159         {
 160                 LOG_ERROR("auto_probe failed %d\n", retval);
 161                 return NULL;
 162         }
 163         return p;
 164 }
 165
 166 /* lookup flash bank by address */
 167 struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr)
 168 {
 169         struct flash_bank *c;
 170
 171         /* cycle through bank list */
 172         for (c = flash_banks; c; c = c->next)
 173         {
 174                 int retval;
 175                 retval = c->driver->auto_probe(c);
 176
 177                 if (retval != ERROR_OK)
 178                 {
 179                         LOG_ERROR("auto_probe failed %d\n", retval);
 180                         return NULL;
 181                 }
 182                 /* check whether address belongs to this flash bank */
 183                 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
 184                         return c;
 185         }
 186         LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
 187         return NULL;
 188 }
 189
 190 int default_flash_mem_blank_check(struct flash_bank *bank)
 191 {
 192         struct target *target = bank->target;
 193         const int buffer_size = 1024;
 194         int i;
 195         uint32_t nBytes;
 196         int retval = ERROR_OK;
 197
 198         if (bank->target->state != TARGET_HALTED)
 199         {
 200                 LOG_ERROR("Target not halted");
 201                 return ERROR_TARGET_NOT_HALTED;
 202         }
 203
 204         uint8_t *buffer = malloc(buffer_size);
 205
 206         for (i = 0; i < bank->num_sectors; i++)
 207         {
 208                 uint32_t j;
 209                 bank->sectors[i].is_erased = 1;
 210
 211                 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
 212                 {
 213                         uint32_t chunk;
 214                         chunk = buffer_size;
 215                         if (chunk > (j - bank->sectors[i].size))
 216                         {
 217                                 chunk = (j - bank->sectors[i].size);
 218                         }
 219
 220                         retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
 221                         if (retval != ERROR_OK)
 222                         {
 223                                 goto done;
 224                         }
 225
 226                         for (nBytes = 0; nBytes < chunk; nBytes++)
 227                         {
 228                                 if (buffer[nBytes] != 0xFF)
 229                                 {
 230                                         bank->sectors[i].is_erased = 0;
 231                                         break;
 232                                 }
 233                         }
 234                 }
 235         }
 236
 237         done:
 238         free(buffer);
 239
 240         return retval;
 241 }
 242
 243 int default_flash_blank_check(struct flash_bank *bank)
 244 {
 245         struct target *target = bank->target;
 246         int i;
 247         int retval;
 248         int fast_check = 0;
 249         uint32_t blank;
 250
 251         if (bank->target->state != TARGET_HALTED)
 252         {
 253                 LOG_ERROR("Target not halted");
 254                 return ERROR_TARGET_NOT_HALTED;
 255         }
 256
 257         for (i = 0; i < bank->num_sectors; i++)
 258         {
 259                 uint32_t address = bank->base + bank->sectors[i].offset;
 260                 uint32_t size = bank->sectors[i].size;
 261
 262                 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
 263                 {
 264                         fast_check = 0;
 265                         break;
 266                 }
 267                 if (blank == 0xFF)
 268                         bank->sectors[i].is_erased = 1;
 269                 else
 270                         bank->sectors[i].is_erased = 0;
 271                 fast_check = 1;
 272         }
 273
 274         if (!fast_check)
 275         {
 276                 LOG_USER("Running slow fallback erase check - add working memory");
 277                 return default_flash_mem_blank_check(bank);
 278         }
 279
 280         return ERROR_OK;
 281 }
 282
 283 /* erase given flash region, selects proper bank according to target and address */
 284 static int flash_iterate_address_range(struct target *target,
 285                 uint32_t addr, uint32_t length,
 286                 int (*callback)(struct flash_bank *bank, int first, int last))
 287 {
 288         struct flash_bank *c;
 289         uint32_t last_addr = addr + length;     /* first address AFTER end */
 290         int first = -1;
 291         int last = -1;
 292         int i;
 293
 294         if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
 295                 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
 296
 297         if (c->size == 0 || c->num_sectors == 0)
 298         {
 299                 LOG_ERROR("Bank is invalid");
 300                 return ERROR_FLASH_BANK_INVALID;
 301         }
 302
 303         if (length == 0)
 304         {
 305                 /* special case, erase whole bank when length is zero */
 306                 if (addr != c->base)
 307                         return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 308
 309                 return callback(c, 0, c->num_sectors - 1);
 310         }
 311
 312         /* check whether it all fits in this bank */
 313         if (addr + length - 1 > c->base + c->size - 1)
 314                 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 315
 316         /** @todo: handle erasures that cross into adjacent banks */
 317
 318         addr -= c->base;
 319
 320         for (i = 0; i < c->num_sectors; i++)
 321         {
 322                 struct flash_sector *f = c->sectors + i;
 323
 324                 /* start only on a sector boundary */
 325                 if (first < 0) {
 326                         /* is this the first sector? */
 327                         if (addr == f->offset)
 328                                 first = i;
 329                         else if (addr < f->offset)
 330                                 break;
 331                 }
 332
 333                 /* is this (also?) the last sector? */
 334                 if (last_addr == f->offset + f->size) {
 335                         last = i;
 336                         break;
 337                 }
 338
 339                 /* MUST finish on a sector boundary */
 340                 if (last_addr <= f->offset)
 341                         break;
 342         }
 343
 344         /* invalid start or end address? */
 345         if (first == -1 || last == -1) {
 346                 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
 347                                 "is not sector-aligned",
 348                                 (unsigned) (c->base + addr),
 349                                 (unsigned) (last_addr - 1));
 350                 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 351         }
 352
 353         /* The NOR driver may trim this range down, based on
 354          * whether or not a given sector is already erased.
 355          *
 356          * REVISIT should *we* trim it... ?
 357          */
 358         return callback(c, first, last);
 359 }
 360
 361 int flash_erase_address_range(struct target *target,
 362                 uint32_t addr, uint32_t length)
 363 {
 364         return flash_iterate_address_range(target,
 365                         addr, length, &flash_driver_erase);
 366 }
 367
 368 static int flash_driver_unprotect(struct flash_bank *bank, int first, int last)
 369 {
 370         return flash_driver_protect(bank, 0, first, last);
 371 }
 372
 373 static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length)
 374 {
 375         return flash_iterate_address_range(target,
 376                         addr, length, &flash_driver_unprotect);
 377 }
 378
 379 int flash_write_unlock(struct target *target, struct image *image,
 380                 uint32_t *written, int erase, bool unlock)
 381 {
 382         int retval = ERROR_OK;
 383
 384         int section;
 385         uint32_t section_offset;
 386         struct flash_bank *c;
 387         int *padding;
 388
 389         section = 0;
 390         section_offset = 0;
 391
 392         if (written)
 393                 *written = 0;
 394
 395         if (erase)
 396         {
 397                 /* assume all sectors need erasing - stops any problems
 398                  * when flash_write is called multiple times */
 399
 400                 flash_set_dirty();
 401         }
 402
 403         /* allocate padding array */
 404         padding = calloc(image->num_sections, sizeof(*padding));
 405
 406         /* loop until we reach end of the image */
 407         while (section < image->num_sections)
 408         {
 409                 uint32_t buffer_size;
 410                 uint8_t *buffer;
 411                 int section_first;
 412                 int section_last;
 413                 uint32_t run_address = image->sections[section].base_address + section_offset;
 414                 uint32_t run_size = image->sections[section].size - section_offset;
 415                 int pad_bytes = 0;
 416
 417                 if (image->sections[section].size ==  0)
 418                 {
 419                         LOG_WARNING("empty section %d", section);
 420                         section++;
 421                         section_offset = 0;
 422                         continue;
 423                 }
 424
 425                 /* find the corresponding flash bank */
 426                 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
 427                 {
 428                         section++; /* and skip it */
 429                         section_offset = 0;
 430                         continue;
 431                 }
 432
 433                 /* collect consecutive sections which fall into the same bank */
 434                 section_first = section;
 435                 section_last = section;
 436                 padding[section] = 0;
 437                 while ((run_address + run_size - 1 < c->base + c->size - 1)
 438                                 && (section_last + 1 < image->num_sections))
 439                 {
 440                         if (image->sections[section_last + 1].base_address < (run_address + run_size))
 441                         {
 442                                 LOG_DEBUG("section %d out of order "
 443                                                 "(surprising, but supported)",
 444                                                 section_last + 1);
 445                                 /* REVISIT this can break with autoerase ...
 446                                  * clobbering data after it's written.
 447                                  */
 448                                 break;
 449                         }
 450
 451                         /* REVISIT This needlessly touches sectors BETWEEN the
 452                          * sections it's writing.  Without auto erase, it just
 453                          * writes ones; unlikely to destroy data.
 454                          *
 455                          * With auto erase enabled, data in those sectors will
 456                          * be needlessly destroyed; and some of the limited
 457                          * number of flash erase cycles will be wasted...
 458                          *
 459                          * In both cases, the extra writes slow things down.
 460                          */
 461
 462                         /* if we have multiple sections within our image, flash programming could fail due to alignment issues
 463                          * attempt to rebuild a consecutive buffer for the flash loader */
 464                         pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
 465                         if ((run_address + run_size + pad_bytes) > (c->base + c->size))
 466                                 break;
 467                         padding[section_last] = pad_bytes;
 468                         run_size += image->sections[++section_last].size;
 469                         run_size += pad_bytes;
 470
 471                         LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
 472                 }
 473
 474                 /* fit the run into bank constraints */
 475                 if (run_address + run_size - 1 > c->base + c->size - 1)
 476                 {
 477                         /* REVISIT isn't this superfluous, given the while()
 478                          * loop conditions above??
 479                          */
 480                         LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
 481                                     (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
 482                         run_size = c->base + c->size - run_address;
 483                 }
 484
 485                 /* If we're applying any sector automagic, then pad this
 486                  * (maybe-combined) segment to the end of its last sector.
 487                  */
 488                 if (unlock || erase) {
 489                         int sector;
 490                         uint32_t offset_start = run_address - c->base;
 491                         uint32_t offset_end = offset_start + run_size;
 492                         uint32_t end = offset_end, delta;
 493
 494                         for (sector = 0; sector < c->num_sectors; sector++) {
 495                                 end = c->sectors[sector].offset
 496                                                 + c->sectors[sector].size;
 497                                 if (offset_end <= end)
 498                                         break;
 499                         }
 500
 501                         delta = end - offset_end;
 502                         padding[section_last] += delta;
 503                         run_size += delta;
 504                 }
 505
 506                 /* allocate buffer */
 507                 buffer = malloc(run_size);
 508                 buffer_size = 0;
 509
 510                 /* read sections to the buffer */
 511                 while (buffer_size < run_size)
 512                 {
 513                         size_t size_read;
 514
 515                         size_read = run_size - buffer_size;
 516                         if (size_read > image->sections[section].size - section_offset)
 517                             size_read = image->sections[section].size - section_offset;
 518
 519                         if ((retval = image_read_section(image, section, section_offset,
 520                                         size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
 521                         {
 522                                 free(buffer);
 523                                 free(padding);
 524                                 return retval;
 525                         }
 526
 527                         /* see if we need to pad the section */
 528                         while (padding[section]--)
 529                                  (buffer + buffer_size)[size_read++] = 0xff;
 530
 531                         buffer_size += size_read;
 532                         section_offset += size_read;
 533
 534                         if (section_offset >= image->sections[section].size)
 535                         {
 536                                 section++;
 537                                 section_offset = 0;
 538                         }
 539                 }
 540
 541                 retval = ERROR_OK;
 542
 543                 if (unlock)
 544                 {
 545                         retval = flash_unlock_address_range(target, run_address, run_size);
 546                 }
 547                 if (retval == ERROR_OK)
 548                 {
 549                         if (erase)
 550                         {
 551                                 /* calculate and erase sectors */
 552                                 retval = flash_erase_address_range(target, run_address, run_size);
 553                         }
 554                 }
 555
 556                 if (retval == ERROR_OK)
 557                 {
 558                         /* write flash sectors */
 559                         retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
 560                 }
 561
 562                 free(buffer);
 563
 564                 if (retval != ERROR_OK)
 565                 {
 566                         free(padding);
 567                         return retval; /* abort operation */
 568                 }
 569
 570                 if (written != NULL)
 571                         *written += run_size; /* add run size to total written counter */
 572         }
 573
 574         free(padding);
 575
 576         return retval;
 577 }
 578
 579 int flash_write(struct target *target, struct image *image,
 580                 uint32_t *written, int erase)
 581 {
 582         return flash_write_unlock(target, image, written, erase, false);
 583 }