util/flashrom/flashrom.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2000 Silicon Integrated System Corporation
   5  * Copyright (C) 2004 Tyan Corp <yhlu@tyan.com>
   6  * Copyright (C) 2005-2008 coresystems GmbH
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  21  */
  22
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <sys/mman.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <getopt.h>
  33 #include <pci/pci.h>
  34 /* for iopl */
  35 #if defined (__sun) && (defined(__i386) || defined(__amd64))
  36 #include <strings.h>
  37 #include <sys/sysi86.h>
  38 #include <sys/psw.h>
  39 #include <asm/sunddi.h>
  40 #endif
  41 #include "flash.h"
  42
  43 char *chip_to_probe = NULL;
  44 struct pci_access *pacc;        /* For board and chipset_enable */
  45 int exclude_start_page, exclude_end_page;
  46 int verbose = 0;
  47 int fd_mem;
  48
  49 struct pci_dev *pci_dev_find(uint16_t vendor, uint16_t device)
  50 {
  51         struct pci_dev *temp;
  52         struct pci_filter filter;
  53
  54         pci_filter_init(NULL, &filter);
  55         filter.vendor = vendor;
  56         filter.device = device;
  57
  58         for (temp = pacc->devices; temp; temp = temp->next)
  59                 if (pci_filter_match(&filter, temp))
  60                         return temp;
  61
  62         return NULL;
  63 }
  64
  65 struct pci_dev *pci_card_find(uint16_t vendor, uint16_t device,
  66                               uint16_t card_vendor, uint16_t card_device)
  67 {
  68         struct pci_dev *temp;
  69         struct pci_filter filter;
  70
  71         pci_filter_init(NULL, &filter);
  72         filter.vendor = vendor;
  73         filter.device = device;
  74
  75         for (temp = pacc->devices; temp; temp = temp->next)
  76                 if (pci_filter_match(&filter, temp)) {
  77                         if ((card_vendor ==
  78                              pci_read_word(temp, PCI_SUBSYSTEM_VENDOR_ID))
  79                             && (card_device ==
  80                                 pci_read_word(temp, PCI_SUBSYSTEM_ID)))
  81                                 return temp;
  82                 }
  83
  84         return NULL;
  85 }
  86
  87 void mmap_errmsg()
  88 {
  89         if (EINVAL == errno) {
  90                 fprintf(stderr, "In Linux this error can be caused by the CONFIG_NONPROMISC_DEVMEM (<2.6.27),\n");
  91                 fprintf(stderr, "CONFIG_STRICT_DEVMEM (>=2.6.27) and CONFIG_X86_PAT kernel options.\n");
  92                 fprintf(stderr, "Please check if either is enabled in your kernel before reporting a failure.\n");
  93                 fprintf(stderr, "You can override CONFIG_X86_PAT at boot with the nopat kernel parameter but\n");
  94                 fprintf(stderr, "disabling the other option unfortunately requires a kernel recompile. Sorry!\n");
  95         }
  96 }
  97
  98 int map_flash_registers(struct flashchip *flash)
  99 {
 100         volatile uint8_t *registers;
 101         size_t size = flash->total_size * 1024;
 102
 103         registers = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED,
 104                          fd_mem, (off_t) (0xFFFFFFFF - 0x400000 - size + 1));
 105
 106         if (registers == MAP_FAILED) {
 107                 perror("Can't mmap registers using " MEM_DEV);
 108                 mmap_errmsg();
 109                 exit(1);
 110         }
 111         flash->virtual_registers = registers;
 112
 113         return 0;
 114 }
 115
 116 struct flashchip *probe_flash(struct flashchip *first_flash, int force)
 117 {
 118         volatile uint8_t *bios;
 119         struct flashchip *flash;
 120         unsigned long base = 0, size;
 121
 122         for (flash = first_flash; flash && flash->name; flash++) {
 123                 if (chip_to_probe && strcmp(flash->name, chip_to_probe) != 0)
 124                         continue;
 125                 printf_debug("Probing for %s %s, %d KB: ",
 126                              flash->vendor, flash->name, flash->total_size);
 127                 if (!flash->probe && !force) {
 128                         printf_debug("failed! flashrom has no probe function for this flash chip.\n");
 129                         continue;
 130                 }
 131
 132                 size = flash->total_size * 1024;
 133
 134                 /* If getpagesize() > size ->
 135                  * "Can't mmap memory using /dev/mem: Invalid argument"
 136                  * This should never happen as we don't support any flash chips
 137                  * smaller than 4k or 8k (yet).
 138                  */
 139
 140                 if (getpagesize() > size) {
 141                         /*
 142                          * if a flash size of 0 is mapped, we map a single page
 143                          * so we can probe in that area whether we know the
 144                          * vendor at least.
 145                          */
 146                         size = getpagesize();
 147                 }
 148
 149                 base = flashbase ? flashbase : (0xffffffff - size + 1);
 150                 bios = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED,
 151                             fd_mem, (off_t) base);
 152                 if (bios == MAP_FAILED) {
 153                         perror("Can't mmap memory using " MEM_DEV);
 154                         mmap_errmsg();
 155                         exit(1);
 156                 }
 157                 flash->virtual_memory = bios;
 158
 159                 if (force)
 160                         break;
 161
 162                 if (flash->probe(flash) != 1)
 163                         goto notfound;
 164
 165                 if (first_flash == flashchips
 166                     || flash->model_id != GENERIC_DEVICE_ID)
 167                         break;
 168
 169 notfound:
 170                 munmap((void *)bios, size);
 171         }
 172
 173         if (!flash || !flash->name)
 174                 return NULL;
 175
 176         printf("Found chip \"%s %s\" (%d KB) at physical address 0x%lx.\n",
 177                flash->vendor, flash->name, flash->total_size, base);
 178         flashbase = base;
 179         return flash;
 180 }
 181
 182 int verify_flash(struct flashchip *flash, uint8_t *buf)
 183 {
 184         int idx;
 185         int total_size = flash->total_size * 1024;
 186         uint8_t *buf2 = (uint8_t *) calloc(total_size, sizeof(char));
 187         if (flash->read == NULL)
 188                 memcpy(buf2, (const char *)flash->virtual_memory, total_size);
 189         else
 190                 flash->read(flash, buf2);
 191
 192         printf("Verifying flash... ");
 193
 194         if (verbose)
 195                 printf("address: 0x00000000\b\b\b\b\b\b\b\b\b\b");
 196
 197         for (idx = 0; idx < total_size; idx++) {
 198                 if (verbose && ((idx & 0xfff) == 0xfff))
 199                         printf("0x%08x", idx);
 200
 201                 if (*(buf2 + idx) != *(buf + idx)) {
 202                         if (verbose)
 203                                 printf("0x%08x FAILED!", idx);
 204                         else
 205                                 printf("FAILED at 0x%08x!", idx);
 206                         printf("  Expected=0x%02x, Read=0x%02x\n",
 207                                *(buf + idx), *(buf2 + idx));
 208                         return 1;
 209                 }
 210
 211                 if (verbose && ((idx & 0xfff) == 0xfff))
 212                         printf("\b\b\b\b\b\b\b\b\b\b");
 213         }
 214         if (verbose)
 215                 printf("\b\b\b\b\b\b\b\b\b\b ");
 216
 217         printf("VERIFIED.          \n");
 218
 219         return 0;
 220 }
 221
 222 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 223 #define POS_PRINT(x) do { pos += strlen(x); printf(x); } while (0)
 224
 225 void print_supported_chips(void)
 226 {
 227         int okcol = 0, pos = 0;
 228         struct flashchip *f;
 229
 230         for (f = flashchips; f->name != NULL; f++) {
 231                 if (GENERIC_DEVICE_ID == f->model_id)
 232                         continue;
 233                 okcol = MAX(okcol, strlen(f->vendor) + 1 + strlen(f->name));
 234         }
 235         okcol = (okcol + 7) & ~7;
 236
 237         POS_PRINT("Supported flash chips:");
 238         while (pos < okcol) {
 239                 printf("\t");
 240                 pos += 8 - (pos % 8);
 241         }
 242         printf("Tested OK operations:\tKnown BAD operations:\n\n");
 243
 244         for (f = flashchips; f->name != NULL; f++) {
 245                 printf("%s %s", f->vendor, f->name);
 246                 pos = strlen(f->vendor) + 1 + strlen(f->name);
 247                 while (pos < okcol) {
 248                         printf("\t");
 249                         pos += 8 - (pos % 8);
 250                 }
 251                 if ((f->tested & TEST_OK_MASK)) {
 252                         if ((f->tested & TEST_OK_PROBE))
 253                                 POS_PRINT("PROBE ");
 254                         if ((f->tested & TEST_OK_READ))
 255                                 POS_PRINT("READ ");
 256                         if ((f->tested & TEST_OK_ERASE))
 257                                 POS_PRINT("ERASE ");
 258                         if ((f->tested & TEST_OK_WRITE))
 259                                 POS_PRINT("WRITE");
 260                 }
 261                 while (pos < okcol + 24) {
 262                         printf("\t");
 263                         pos += 8 - (pos % 8);
 264                 }
 265                 if ((f->tested & TEST_BAD_MASK)) {
 266                         if ((f->tested & TEST_BAD_PROBE))
 267                                 printf("PROBE ");
 268                         if ((f->tested & TEST_BAD_READ))
 269                                 printf("READ ");
 270                         if ((f->tested & TEST_BAD_ERASE))
 271                                 printf("ERASE ");
 272                         if ((f->tested & TEST_BAD_WRITE))
 273                                 printf("WRITE");
 274                 }
 275                 printf("\n");
 276         }
 277 }
 278
 279 void usage(const char *name)
 280 {
 281         printf("usage: %s [-rwvEVfLhR] [-c chipname] [-s exclude_start]\n",
 282                name);
 283         printf("       [-e exclude_end] [-m [vendor:]part] [-l file.layout] [-i imagename] [file]\n");
 284         printf
 285             ("   -r | --read:                      read flash and save into file\n"
 286              "   -w | --write:                     write file into flash\n"
 287              "   -v | --verify:                    verify flash against file\n"
 288              "   -E | --erase:                     erase flash device\n"
 289              "   -V | --verbose:                   more verbose output\n"
 290              "   -c | --chip <chipname>:           probe only for specified flash chip\n"
 291              "   -s | --estart <addr>:             exclude start position\n"
 292              "   -e | --eend <addr>:               exclude end postion\n"
 293              "   -m | --mainboard <[vendor:]part>: override mainboard settings\n"
 294              "   -f | --force:                     force write without checking image\n"
 295              "   -l | --layout <file.layout>:      read rom layout from file\n"
 296              "   -i | --image <name>:              only flash image name from flash layout\n"
 297              "   -L | --list-supported:            print supported devices\n"
 298              "   -h | --help:                      print this help text\n"
 299              "   -R | --version:                   print the version (release)\n"
 300              "\n" " If no file is specified, then all that happens"
 301              " is that flash info is dumped.\n\n");
 302         exit(1);
 303 }
 304
 305 void print_version(void)
 306 {
 307         printf("flashrom r%s\n", FLASHROM_VERSION);
 308 }
 309
 310 int main(int argc, char *argv[])
 311 {
 312         uint8_t *buf;
 313         unsigned long size, numbytes;
 314         uint32_t erasedbytes;
 315         FILE *image;
 316         /* Probe for up to three flash chips. */
 317         struct flashchip *flash, *flashes[3];
 318         int opt;
 319         int option_index = 0;
 320         int force = 0;
 321         int read_it = 0, write_it = 0, erase_it = 0, verify_it = 0;
 322         int ret = 0, i;
 323 #ifdef __FreeBSD__
 324         int io_fd;
 325 #endif
 326
 327         static struct option long_options[] = {
 328                 {"read", 0, 0, 'r'},
 329                 {"write", 0, 0, 'w'},
 330                 {"erase", 0, 0, 'E'},
 331                 {"verify", 0, 0, 'v'},
 332                 {"chip", 1, 0, 'c'},
 333                 {"estart", 1, 0, 's'},
 334                 {"eend", 1, 0, 'e'},
 335                 {"mainboard", 1, 0, 'm'},
 336                 {"verbose", 0, 0, 'V'},
 337                 {"force", 0, 0, 'f'},
 338                 {"layout", 1, 0, 'l'},
 339                 {"image", 1, 0, 'i'},
 340                 {"list-supported", 0, 0, 'L'},
 341                 {"help", 0, 0, 'h'},
 342                 {"version", 0, 0, 'R'},
 343                 {0, 0, 0, 0}
 344         };
 345
 346         char *filename = NULL;
 347
 348         unsigned int exclude_start_position = 0, exclude_end_position = 0;      // [x,y)
 349         char *tempstr = NULL, *tempstr2 = NULL;
 350
 351         if (argc > 1) {
 352                 /* Yes, print them. */
 353                 int i;
 354                 printf_debug("The arguments are:\n");
 355                 for (i = 1; i < argc; ++i)
 356                         printf_debug("%s\n", argv[i]);
 357         }
 358
 359         setbuf(stdout, NULL);
 360         while ((opt = getopt_long(argc, argv, "rRwvVEfc:s:e:m:l:i:Lh",
 361                                   long_options, &option_index)) != EOF) {
 362                 switch (opt) {
 363                 case 'r':
 364                         read_it = 1;
 365                         break;
 366                 case 'w':
 367                         write_it = 1;
 368                         break;
 369                 case 'v':
 370                         verify_it = 1;
 371                         break;
 372                 case 'c':
 373                         chip_to_probe = strdup(optarg);
 374                         break;
 375                 case 'V':
 376                         verbose = 1;
 377                         break;
 378                 case 'E':
 379                         erase_it = 1;
 380                         break;
 381                 case 's':
 382                         tempstr = strdup(optarg);
 383                         sscanf(tempstr, "%x", &exclude_start_position);
 384                         break;
 385                 case 'e':
 386                         tempstr = strdup(optarg);
 387                         sscanf(tempstr, "%x", &exclude_end_position);
 388                         break;
 389                 case 'm':
 390                         tempstr = strdup(optarg);
 391                         strtok(tempstr, ":");
 392                         tempstr2 = strtok(NULL, ":");
 393                         if (tempstr2) {
 394                                 lb_vendor = tempstr;
 395                                 lb_part = tempstr2;
 396                         } else {
 397                                 lb_vendor = NULL;
 398                                 lb_part = tempstr;
 399                         }
 400                         break;
 401                 case 'f':
 402                         force = 1;
 403                         break;
 404                 case 'l':
 405                         tempstr = strdup(optarg);
 406                         if (read_romlayout(tempstr))
 407                                 exit(1);
 408                         break;
 409                 case 'i':
 410                         tempstr = strdup(optarg);
 411                         find_romentry(tempstr);
 412                         break;
 413                 case 'L':
 414                         print_supported_chips();
 415                         print_supported_chipsets();
 416                         print_supported_boards();
 417                         exit(0);
 418                         break;
 419                 case 'R':
 420                         print_version();
 421                         exit(0);
 422                         break;
 423                 case 'h':
 424                 default:
 425                         usage(argv[0]);
 426                         break;
 427                 }
 428         }
 429
 430         if (read_it && write_it) {
 431                 printf("Error: -r and -w are mutually exclusive.\n");
 432                 usage(argv[0]);
 433         }
 434
 435         if (optind < argc)
 436                 filename = argv[optind++];
 437
 438         /* First get full io access */
 439 #if defined (__sun) && (defined(__i386) || defined(__amd64))
 440         if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) != 0) {
 441 #elif defined(__FreeBSD__)
 442         if ((io_fd = open("/dev/io", O_RDWR)) < 0) {
 443 #else
 444         if (iopl(3) != 0) {
 445 #endif
 446                 fprintf(stderr, "ERROR: Could not get IO privileges (%s).\nYou need to be root.\n", strerror(errno));
 447                 exit(1);
 448         }
 449
 450         /* Initialize PCI access for flash enables */
 451         pacc = pci_alloc();     /* Get the pci_access structure */
 452         /* Set all options you want -- here we stick with the defaults */
 453         pci_init(pacc);         /* Initialize the PCI library */
 454         pci_scan_bus(pacc);     /* We want to get the list of devices */
 455
 456         /* Open the memory device UNCACHED. That's important for MMIO. */
 457         if ((fd_mem = open(MEM_DEV, O_RDWR | O_SYNC)) < 0) {
 458                 perror("Error: Can not access memory using " MEM_DEV
 459                        ". You need to be root.");
 460                 exit(1);
 461         }
 462
 463         myusec_calibrate_delay();
 464
 465         /* We look at the lbtable first to see if we need a
 466          * mainboard specific flash enable sequence.
 467          */
 468         coreboot_init();
 469
 470         /* try to enable it. Failure IS an option, since not all motherboards
 471          * really need this to be done, etc., etc.
 472          */
 473         ret = chipset_flash_enable();
 474         if (ret == -2) {
 475                 printf("WARNING: No chipset found. Flash detection "
 476                        "will most likely fail.\n");
 477         }
 478
 479         board_flash_enable(lb_vendor, lb_part);
 480
 481         for (i = 0; i < ARRAY_SIZE(flashes); i++) {
 482                 flashes[i] =
 483                     probe_flash(i ? flashes[i - 1] + 1 : flashchips, 0);
 484                 if (!flashes[i])
 485                         for (i++; i < ARRAY_SIZE(flashes); i++)
 486                                 flashes[i] = NULL;
 487         }
 488
 489         if (flashes[1]) {
 490                 printf("Multiple flash chips were detected:");
 491                 for (i = 0; i < ARRAY_SIZE(flashes) && flashes[i]; i++)
 492                         printf(" %s", flashes[i]->name);
 493                 printf("\nPlease specify which chip to use with the -c <chipname> option.\n");
 494                 exit(1);
 495         } else if (!flashes[0]) {
 496                 printf("No EEPROM/flash device found.\n");
 497                 if (!force || !chip_to_probe) {
 498                         printf("If you know which flash chip you have, and if this version of flashrom\n");
 499                         printf("supports a similar flash chip, you can try to force read your chip. Run:\n");
 500                         printf("flashrom -f -r -c similar_supported_flash_chip filename\n");
 501                         printf("\n");
 502                         printf("Note: flashrom can never write when the flash chip isn't found automatically.\n");
 503                 }
 504                 if (force && read_it && chip_to_probe) {
 505                         printf("Force read (-f -r -c) requested, forcing chip probe success:\n");
 506                         flashes[0] = probe_flash(flashchips, 1);
 507                         if (!flashes[0]) {
 508                                 printf("flashrom does not support a flash chip named '%s'.\n", chip_to_probe);
 509                                 printf("Run flashrom -L to view the hardware supported in this flashrom version.\n");
 510                                 exit(1);
 511                         }
 512                         if (!filename) {
 513                                 printf("Error: No filename specified.\n");
 514                                 exit(1);
 515                         }
 516                         size = flashes[0]->total_size * 1024;
 517                         buf = (uint8_t *) calloc(size, sizeof(char));
 518
 519                         if ((image = fopen(filename, "w")) == NULL) {
 520                                 perror(filename);
 521                                 exit(1);
 522                         }
 523                         printf("Force reading flash... ");
 524                         if (!flashes[0]->read)
 525                                 memcpy(buf, (const char *)flashes[0]->virtual_memory, size);
 526                         else
 527                                 flashes[0]->read(flashes[0], buf);
 528
 529                         if (exclude_end_position - exclude_start_position > 0)
 530                                 memset(buf + exclude_start_position, 0,
 531                                        exclude_end_position -
 532                                        exclude_start_position);
 533
 534                         numbytes = fwrite(buf, 1, size, image);
 535                         fclose(image);
 536                         printf("%s.\n", numbytes == size ? "done" : "FAILED");
 537                         free(buf);
 538                         return numbytes != size;
 539                 }
 540                 // FIXME: flash writes stay enabled!
 541                 exit(1);
 542         }
 543
 544         flash = flashes[0];
 545
 546         if (TEST_OK_MASK != (flash->tested & TEST_OK_MASK)) {
 547                 printf("===\n");
 548                 if (flash->tested & TEST_BAD_MASK) {
 549                         printf("This flash part has status NOT WORKING for operations:");
 550                         if (flash->tested & TEST_BAD_PROBE)
 551                                 printf(" PROBE");
 552                         if (flash->tested & TEST_BAD_READ)
 553                                 printf(" READ");
 554                         if (flash->tested & TEST_BAD_ERASE)
 555                                 printf(" ERASE");
 556                         if (flash->tested & TEST_BAD_WRITE)
 557                                 printf(" WRITE");
 558                         printf("\n");
 559                 }
 560                 if ((!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE)) ||
 561                     (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ)) ||
 562                     (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE)) ||
 563                     (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))) {
 564                         printf("This flash part has status UNTESTED for operations:");
 565                         if (!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE))
 566                                 printf(" PROBE");
 567                         if (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ))
 568                                 printf(" READ");
 569                         if (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE))
 570                                 printf(" ERASE");
 571                         if (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))
 572                                 printf(" WRITE");
 573                         printf("\n");
 574                 }
 575                 printf("Please email a report to flashrom@coreboot.org if any of the above operations\n");
 576                 printf("work correctly for you with this flash part. Please include the full output\n");
 577                 printf("from the program, including chipset found. Thank you for your help!\n");
 578                 printf("===\n");
 579         }
 580
 581         if (!(read_it | write_it | verify_it | erase_it)) {
 582                 printf("No operations were specified.\n");
 583                 // FIXME: flash writes stay enabled!
 584                 exit(1);
 585         }
 586
 587         if (!filename && !erase_it) {
 588                 printf("Error: No filename specified.\n");
 589                 // FIXME: flash writes stay enabled!
 590                 exit(1);
 591         }
 592
 593         size = flash->total_size * 1024;
 594         buf = (uint8_t *) calloc(size, sizeof(char));
 595
 596         if (erase_it) {
 597                 printf("Erasing flash chip... ");
 598                 if (NULL == flash->erase) {
 599                         printf("FAILED!\n");
 600                         fprintf(stderr, "ERROR: flashrom has no erase function for this flash chip.\n");
 601                         return 1;
 602                 }
 603                 flash->erase(flash);
 604                 if (NULL == flash->read)
 605                         memcpy(buf, (const char *)flash->virtual_memory, size);
 606                 else
 607                         flash->read(flash, buf);
 608                 for (erasedbytes = 0; erasedbytes <= size; erasedbytes++)
 609                         if (0xff != buf[erasedbytes]) {
 610                                 printf("FAILED!\n");
 611                                 fprintf(stderr, "ERROR at 0x%08x: Expected=0xff, Read=0x%02x\n",
 612                                         erasedbytes, buf[erasedbytes]);
 613                                 return 1;
 614                         }
 615                 printf("SUCCESS.\n");
 616                 return 0;
 617         } else if (read_it) {
 618                 if ((image = fopen(filename, "w")) == NULL) {
 619                         perror(filename);
 620                         exit(1);
 621                 }
 622                 printf("Reading flash... ");
 623                 if (flash->read == NULL)
 624                         memcpy(buf, (const char *)flash->virtual_memory, size);
 625                 else
 626                         flash->read(flash, buf);
 627
 628                 if (exclude_end_position - exclude_start_position > 0)
 629                         memset(buf + exclude_start_position, 0,
 630                                exclude_end_position - exclude_start_position);
 631
 632                 numbytes = fwrite(buf, 1, size, image);
 633                 fclose(image);
 634                 printf("%s.\n", numbytes == size ? "done" : "FAILED");
 635                 if (numbytes != size)
 636                         return 1;
 637         } else {
 638                 struct stat image_stat;
 639
 640                 if ((image = fopen(filename, "r")) == NULL) {
 641                         perror(filename);
 642                         exit(1);
 643                 }
 644                 if (fstat(fileno(image), &image_stat) != 0) {
 645                         perror(filename);
 646                         exit(1);
 647                 }
 648                 if (image_stat.st_size != flash->total_size * 1024) {
 649                         fprintf(stderr, "Error: Image size doesn't match\n");
 650                         exit(1);
 651                 }
 652
 653                 numbytes = fread(buf, 1, size, image);
 654                 show_id(buf, size, force);
 655                 fclose(image);
 656                 if (numbytes != size) {
 657                         fprintf(stderr, "Error: Failed to read file. Got %ld bytes, wanted %ld!\n", numbytes, size);
 658                         return 1;
 659                 }
 660         }
 661
 662         /* exclude range stuff. Nice idea, but at the moment it is only
 663          * supported in hardware by the pm49fl004 chips.
 664          * Instead of implementing this for all chips I suggest advancing
 665          * it to the rom layout feature below and drop exclude range
 666          * completely once all flash chips can do rom layouts. stepan
 667          */
 668
 669         // ////////////////////////////////////////////////////////////
 670         if (exclude_end_position - exclude_start_position > 0)
 671                 memcpy(buf + exclude_start_position,
 672                        (const char *)flash->virtual_memory +
 673                        exclude_start_position,
 674                        exclude_end_position - exclude_start_position);
 675
 676         exclude_start_page = exclude_start_position / flash->page_size;
 677         if ((exclude_start_position % flash->page_size) != 0) {
 678                 exclude_start_page++;
 679         }
 680         exclude_end_page = exclude_end_position / flash->page_size;
 681         // ////////////////////////////////////////////////////////////
 682
 683         // This should be moved into each flash part's code to do it
 684         // cleanly. This does the job.
 685         handle_romentries(buf, (uint8_t *) flash->virtual_memory);
 686
 687         // ////////////////////////////////////////////////////////////
 688
 689         if (write_it) {
 690                 if (!flash->write) {
 691                         fprintf(stderr, "Error: flashrom has no write function for this flash chip.\n");
 692                         return 1;
 693                 }
 694                 ret |= flash->write(flash, buf);
 695         }
 696
 697         if (verify_it)
 698                 ret |= verify_flash(flash, buf);
 699
 700 #ifdef __FreeBSD__
 701         close(io_fd);
 702 #endif
 703         return ret;
 704 }