source: trunk/flashrom.c

Last change on this file was 1851, checked in by stefanct, 12 days ago

Make read before write configurable (infrastructure part).

  • Introduce a variable in doit() that allows to influence read-before-write and its consequences.
  • Modify build_new_image so that it still works even if the old content is not read before.
  • Add copy_old_content() to ease the pain for future patches.

Signed-off-by: Stefan Tauner <stefan.tauner@…>
Signed-off-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006@…>
Acked-by: Stefan Tauner <stefan.tauner@…>

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 57.2 KB
Line 
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 * Copyright (C) 2008,2009 Carl-Daniel Hailfinger
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
22 */
23
24#include <stdio.h>
25#include <sys/types.h>
26#ifndef __LIBPAYLOAD__
27#include <fcntl.h>
28#include <sys/stat.h>
29#endif
30#include <string.h>
31#include <stdlib.h>
32#include <errno.h>
33#include <ctype.h>
34#include <getopt.h>
35#if HAVE_UTSNAME == 1
36#include <sys/utsname.h>
37#endif
38#include "flash.h"
39#include "flashchips.h"
40#include "programmer.h"
41#include "hwaccess.h"
42
43const char flashrom_version[] = FLASHROM_VERSION;
44const char *chip_to_probe = NULL;
45
46static enum programmer programmer = PROGRAMMER_INVALID;
47static const char *programmer_param = NULL;
48
49/*
50 * Programmers supporting multiple buses can have differing size limits on
51 * each bus. Store the limits for each bus in a common struct.
52 */
53struct decode_sizes max_rom_decode;
54
55/* If nonzero, used as the start address of bottom-aligned flash. */
56unsigned long flashbase;
57
58/* Is writing allowed with this programmer? */
59int programmer_may_write;
60
61const struct programmer_entry programmer_table[] = {
62#if CONFIG_INTERNAL == 1
63        {
64                .name                   = "internal",
65                .type                   = OTHER,
66                .devs.note              = NULL,
67                .init                   = internal_init,
68                .map_flash_region       = physmap,
69                .unmap_flash_region     = physunmap,
70                .delay                  = internal_delay,
71        },
72#endif
73
74#if CONFIG_DUMMY == 1
75        {
76                .name                   = "dummy",
77                .type                   = OTHER,
78                                        /* FIXME */
79                .devs.note              = "Dummy device, does nothing and logs all accesses\n",
80                .init                   = dummy_init,
81                .map_flash_region       = dummy_map,
82                .unmap_flash_region     = dummy_unmap,
83                .delay                  = internal_delay,
84        },
85#endif
86
87#if CONFIG_NIC3COM == 1
88        {
89                .name                   = "nic3com",
90                .type                   = PCI,
91                .devs.dev               = nics_3com,
92                .init                   = nic3com_init,
93                .map_flash_region       = fallback_map,
94                .unmap_flash_region     = fallback_unmap,
95                .delay                  = internal_delay,
96        },
97#endif
98
99#if CONFIG_NICREALTEK == 1
100        {
101                /* This programmer works for Realtek RTL8139 and SMC 1211. */
102                .name                   = "nicrealtek",
103                .type                   = PCI,
104                .devs.dev               = nics_realtek,
105                .init                   = nicrealtek_init,
106                .map_flash_region       = fallback_map,
107                .unmap_flash_region     = fallback_unmap,
108                .delay                  = internal_delay,
109        },
110#endif
111
112#if CONFIG_NICNATSEMI == 1
113        {
114                .name                   = "nicnatsemi",
115                .type                   = PCI,
116                .devs.dev               = nics_natsemi,
117                .init                   = nicnatsemi_init,
118                .map_flash_region       = fallback_map,
119                .unmap_flash_region     = fallback_unmap,
120                .delay                  = internal_delay,
121        },
122#endif
123
124#if CONFIG_GFXNVIDIA == 1
125        {
126                .name                   = "gfxnvidia",
127                .type                   = PCI,
128                .devs.dev               = gfx_nvidia,
129                .init                   = gfxnvidia_init,
130                .map_flash_region       = fallback_map,
131                .unmap_flash_region     = fallback_unmap,
132                .delay                  = internal_delay,
133        },
134#endif
135
136#if CONFIG_DRKAISER == 1
137        {
138                .name                   = "drkaiser",
139                .type                   = PCI,
140                .devs.dev               = drkaiser_pcidev,
141                .init                   = drkaiser_init,
142                .map_flash_region       = fallback_map,
143                .unmap_flash_region     = fallback_unmap,
144                .delay                  = internal_delay,
145        },
146#endif
147
148#if CONFIG_SATASII == 1
149        {
150                .name                   = "satasii",
151                .type                   = PCI,
152                .devs.dev               = satas_sii,
153                .init                   = satasii_init,
154                .map_flash_region       = fallback_map,
155                .unmap_flash_region     = fallback_unmap,
156                .delay                  = internal_delay,
157        },
158#endif
159
160#if CONFIG_ATAHPT == 1
161        {
162                .name                   = "atahpt",
163                .type                   = PCI,
164                .devs.dev               = ata_hpt,
165                .init                   = atahpt_init,
166                .map_flash_region       = fallback_map,
167                .unmap_flash_region     = fallback_unmap,
168                .delay                  = internal_delay,
169        },
170#endif
171
172#if CONFIG_ATAVIA == 1
173        {
174                .name                   = "atavia",
175                .type                   = PCI,
176                .devs.dev               = ata_via,
177                .init                   = atavia_init,
178                .map_flash_region       = atavia_map,
179                .unmap_flash_region     = fallback_unmap,
180                .delay                  = internal_delay,
181        },
182#endif
183
184#if CONFIG_IT8212 == 1
185        {
186                .name                   = "it8212",
187                .type                   = PCI,
188                .devs.dev               = devs_it8212,
189                .init                   = it8212_init,
190                .map_flash_region       = fallback_map,
191                .unmap_flash_region     = fallback_unmap,
192                .delay                  = internal_delay,
193        },
194#endif
195
196#if CONFIG_FT2232_SPI == 1
197        {
198                .name                   = "ft2232_spi",
199                .type                   = USB,
200                .devs.dev               = devs_ft2232spi,
201                .init                   = ft2232_spi_init,
202                .map_flash_region       = fallback_map,
203                .unmap_flash_region     = fallback_unmap,
204                .delay                  = internal_delay,
205        },
206#endif
207
208#if CONFIG_SERPROG == 1
209        {
210                .name                   = "serprog",
211                .type                   = OTHER,
212                                        /* FIXME */
213                .devs.note              = "All programmer devices speaking the serprog protocol\n",
214                .init                   = serprog_init,
215                .map_flash_region       = fallback_map,
216                .unmap_flash_region     = fallback_unmap,
217                .delay                  = serprog_delay,
218        },
219#endif
220
221#if CONFIG_BUSPIRATE_SPI == 1
222        {
223                .name                   = "buspirate_spi",
224                .type                   = OTHER,
225                                        /* FIXME */
226                .devs.note              = "Dangerous Prototypes Bus Pirate\n",
227                .init                   = buspirate_spi_init,
228                .map_flash_region       = fallback_map,
229                .unmap_flash_region     = fallback_unmap,
230                .delay                  = internal_delay,
231        },
232#endif
233
234#if CONFIG_DEDIPROG == 1
235        {
236                .name                   = "dediprog",
237                .type                   = OTHER,
238                                        /* FIXME */
239                .devs.note              = "Dediprog SF100\n",
240                .init                   = dediprog_init,
241                .map_flash_region       = fallback_map,
242                .unmap_flash_region     = fallback_unmap,
243                .delay                  = internal_delay,
244        },
245#endif
246
247#if CONFIG_RAYER_SPI == 1
248        {
249                .name                   = "rayer_spi",
250                .type                   = OTHER,
251                                        /* FIXME */
252                .devs.note              = "RayeR parallel port programmer\n",
253                .init                   = rayer_spi_init,
254                .map_flash_region       = fallback_map,
255                .unmap_flash_region     = fallback_unmap,
256                .delay                  = internal_delay,
257        },
258#endif
259
260#if CONFIG_PONY_SPI == 1
261        {
262                .name                   = "pony_spi",
263                .type                   = OTHER,
264                                        /* FIXME */
265                .devs.note              = "Programmers compatible with SI-Prog, serbang or AJAWe\n",
266                .init                   = pony_spi_init,
267                .map_flash_region       = fallback_map,
268                .unmap_flash_region     = fallback_unmap,
269                .delay                  = internal_delay,
270        },
271#endif
272
273#if CONFIG_NICINTEL == 1
274        {
275                .name                   = "nicintel",
276                .type                   = PCI,
277                .devs.dev               = nics_intel,
278                .init                   = nicintel_init,
279                .map_flash_region       = fallback_map,
280                .unmap_flash_region     = fallback_unmap,
281                .delay                  = internal_delay,
282        },
283#endif
284
285#if CONFIG_NICINTEL_SPI == 1
286        {
287                .name                   = "nicintel_spi",
288                .type                   = PCI,
289                .devs.dev               = nics_intel_spi,
290                .init                   = nicintel_spi_init,
291                .map_flash_region       = fallback_map,
292                .unmap_flash_region     = fallback_unmap,
293                .delay                  = internal_delay,
294        },
295#endif
296
297#if CONFIG_NICINTEL_EEPROM == 1
298        {
299                .name                   = "nicintel_eeprom",
300                .type                   = PCI,
301                .devs.dev               = nics_intel_ee,
302                .init                   = nicintel_ee_init,
303                .map_flash_region       = fallback_map,
304                .unmap_flash_region     = fallback_unmap,
305                .delay                  = internal_delay,
306        },
307#endif
308
309#if CONFIG_OGP_SPI == 1
310        {
311                .name                   = "ogp_spi",
312                .type                   = PCI,
313                .devs.dev               = ogp_spi,
314                .init                   = ogp_spi_init,
315                .map_flash_region       = fallback_map,
316                .unmap_flash_region     = fallback_unmap,
317                .delay                  = internal_delay,
318        },
319#endif
320
321#if CONFIG_SATAMV == 1
322        {
323                .name                   = "satamv",
324                .type                   = PCI,
325                .devs.dev               = satas_mv,
326                .init                   = satamv_init,
327                .map_flash_region       = fallback_map,
328                .unmap_flash_region     = fallback_unmap,
329                .delay                  = internal_delay,
330        },
331#endif
332
333#if CONFIG_LINUX_SPI == 1
334        {
335                .name                   = "linux_spi",
336                .type                   = OTHER,
337                .devs.note              = "Device files /dev/spidev*.*\n",
338                .init                   = linux_spi_init,
339                .map_flash_region       = fallback_map,
340                .unmap_flash_region     = fallback_unmap,
341                .delay                  = internal_delay,
342        },
343#endif
344
345#if CONFIG_USBBLASTER_SPI == 1
346        {
347                .name                   = "usbblaster_spi",
348                .type                   = USB,
349                .devs.dev               = devs_usbblasterspi,
350                .init                   = usbblaster_spi_init,
351                .map_flash_region       = fallback_map,
352                .unmap_flash_region     = fallback_unmap,
353                .delay                  = internal_delay,
354        },
355#endif
356
357        {0}, /* This entry corresponds to PROGRAMMER_INVALID. */
358};
359
360#define SHUTDOWN_MAXFN 32
361static int shutdown_fn_count = 0;
362struct shutdown_func_data {
363        int (*func) (void *data);
364        void *data;
365} static shutdown_fn[SHUTDOWN_MAXFN];
366/* Initialize to 0 to make sure nobody registers a shutdown function before
367 * programmer init.
368 */
369static int may_register_shutdown = 0;
370
371/* Did we change something or was every erase/write skipped (if any)? */
372static bool all_skipped = true;
373
374static int check_block_eraser(const struct flashctx *flash, int k, int log);
375
376int shutdown_free(void *data)
377{
378        free(data);
379        return 0;
380}
381
382/* Register a function to be executed on programmer shutdown.
383 * The advantage over atexit() is that you can supply a void pointer which will
384 * be used as parameter to the registered function upon programmer shutdown.
385 * This pointer can point to arbitrary data used by said function, e.g. undo
386 * information for GPIO settings etc. If unneeded, set data=NULL.
387 * Please note that the first (void *data) belongs to the function signature of
388 * the function passed as first parameter.
389 */
390int register_shutdown(int (*function) (void *data), void *data)
391{
392        if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
393                msg_perr("Tried to register more than %i shutdown functions.\n",
394                         SHUTDOWN_MAXFN);
395                return 1;
396        }
397        if (!may_register_shutdown) {
398                msg_perr("Tried to register a shutdown function before "
399                         "programmer init.\n");
400                return 1;
401        }
402        shutdown_fn[shutdown_fn_count].func = function;
403        shutdown_fn[shutdown_fn_count].data = data;
404        shutdown_fn_count++;
405
406        return 0;
407}
408
409int programmer_init(enum programmer prog, const char *param)
410{
411        int ret;
412
413        if (prog >= PROGRAMMER_INVALID) {
414                msg_perr("Invalid programmer specified!\n");
415                return -1;
416        }
417        programmer = prog;
418        /* Initialize all programmer specific data. */
419        /* Default to unlimited decode sizes. */
420        max_rom_decode = (const struct decode_sizes) {
421                .parallel       = 0xffffffff,
422                .lpc            = 0xffffffff,
423                .fwh            = 0xffffffff,
424                .spi            = 0xffffffff,
425        };
426        /* Default to top aligned flash at 4 GB. */
427        flashbase = 0;
428        /* Registering shutdown functions is now allowed. */
429        may_register_shutdown = 1;
430        /* Default to allowing writes. Broken programmers set this to 0. */
431        programmer_may_write = 1;
432
433        programmer_param = param;
434        msg_pdbg("Initializing %s programmer\n", programmer_table[programmer].name);
435        ret = programmer_table[programmer].init();
436        if (programmer_param && strlen(programmer_param)) {
437                if (ret != 0) {
438                        /* It is quite possible that any unhandled programmer parameter would have been valid,
439                         * but an error in actual programmer init happened before the parameter was evaluated.
440                         */
441                        msg_pwarn("Unhandled programmer parameters (possibly due to another failure): %s\n",
442                                  programmer_param);
443                } else {
444                        /* Actual programmer init was successful, but the user specified an invalid or unusable
445                         * (for the current programmer configuration) parameter.
446                         */
447                        msg_perr("Unhandled programmer parameters: %s\n", programmer_param);
448                        msg_perr("Aborting.\n");
449                        ret = ERROR_FATAL;
450                }
451        }
452        return ret;
453}
454
455/** Calls registered shutdown functions and resets internal programmer-related variables.
456 * Calling it is safe even without previous initialization, but further interactions with programmer support
457 * require a call to programmer_init() (afterwards).
458 *
459 * @return The OR-ed result values of all shutdown functions (i.e. 0 on success). */
460int programmer_shutdown(void)
461{
462        int ret = 0;
463
464        /* Registering shutdown functions is no longer allowed. */
465        may_register_shutdown = 0;
466        while (shutdown_fn_count > 0) {
467                int i = --shutdown_fn_count;
468                ret |= shutdown_fn[i].func(shutdown_fn[i].data);
469        }
470
471        programmer_param = NULL;
472        registered_master_count = 0;
473
474        return ret;
475}
476
477void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len)
478{
479        void *ret = programmer_table[programmer].map_flash_region(descr, phys_addr, len);
480        msg_gspew("%s: mapping %s from 0x%0*" PRIxPTR " to 0x%0*" PRIxPTR "\n",
481                  __func__, descr, PRIxPTR_WIDTH, phys_addr, PRIxPTR_WIDTH, (uintptr_t) ret);
482        return ret;
483}
484
485void programmer_unmap_flash_region(void *virt_addr, size_t len)
486{
487        programmer_table[programmer].unmap_flash_region(virt_addr, len);
488        msg_gspew("%s: unmapped 0x%0*" PRIxPTR "\n", __func__, PRIxPTR_WIDTH, (uintptr_t)virt_addr);
489}
490
491void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr)
492{
493        flash->mst->par.chip_writeb(flash, val, addr);
494}
495
496void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr)
497{
498        flash->mst->par.chip_writew(flash, val, addr);
499}
500
501void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr)
502{
503        flash->mst->par.chip_writel(flash, val, addr);
504}
505
506void chip_writen(const struct flashctx *flash, const uint8_t *buf, chipaddr addr, size_t len)
507{
508        flash->mst->par.chip_writen(flash, buf, addr, len);
509}
510
511uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr)
512{
513        return flash->mst->par.chip_readb(flash, addr);
514}
515
516uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr)
517{
518        return flash->mst->par.chip_readw(flash, addr);
519}
520
521uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr)
522{
523        return flash->mst->par.chip_readl(flash, addr);
524}
525
526void chip_readn(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
527                size_t len)
528{
529        flash->mst->par.chip_readn(flash, buf, addr, len);
530}
531
532void programmer_delay(unsigned int usecs)
533{
534        if (usecs > 0)
535                programmer_table[programmer].delay(usecs);
536}
537
538int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
539                   int unsigned len)
540{
541        chip_readn(flash, buf, flash->virtual_memory + start, len);
542
543        return 0;
544}
545
546/* This is a somewhat hacked function similar in some ways to strtok().
547 * It will look for needle with a subsequent '=' in haystack, return a copy of
548 * needle and remove everything from the first occurrence of needle to the next
549 * delimiter from haystack.
550 */
551char *extract_param(const char *const *haystack, const char *needle, const char *delim)
552{
553        char *param_pos, *opt_pos, *rest;
554        char *opt = NULL;
555        int optlen;
556        int needlelen;
557
558        needlelen = strlen(needle);
559        if (!needlelen) {
560                msg_gerr("%s: empty needle! Please report a bug at "
561                         "flashrom@flashrom.org\n", __func__);
562                return NULL;
563        }
564        /* No programmer parameters given. */
565        if (*haystack == NULL)
566                return NULL;
567        param_pos = strstr(*haystack, needle);
568        do {
569                if (!param_pos)
570                        return NULL;
571                /* Needle followed by '='? */
572                if (param_pos[needlelen] == '=') {
573                       
574                        /* Beginning of the string? */
575                        if (param_pos == *haystack)
576                                break;
577                        /* After a delimiter? */
578                        if (strchr(delim, *(param_pos - 1)))
579                                break;
580                }
581                /* Continue searching. */
582                param_pos++;
583                param_pos = strstr(param_pos, needle);
584        } while (1);
585
586        if (param_pos) {
587                /* Get the string after needle and '='. */
588                opt_pos = param_pos + needlelen + 1;
589                optlen = strcspn(opt_pos, delim);
590                /* Return an empty string if the parameter was empty. */
591                opt = malloc(optlen + 1);
592                if (!opt) {
593                        msg_gerr("Out of memory!\n");
594                        exit(1);
595                }
596                strncpy(opt, opt_pos, optlen);
597                opt[optlen] = '\0';
598                rest = opt_pos + optlen;
599                /* Skip all delimiters after the current parameter. */
600                rest += strspn(rest, delim);
601                memmove(param_pos, rest, strlen(rest) + 1);
602                /* We could shrink haystack, but the effort is not worth it. */
603        }
604
605        return opt;
606}
607
608char *extract_programmer_param(const char *param_name)
609{
610        return extract_param(&programmer_param, param_name, ",");
611}
612
613/* Returns the number of well-defined erasers for a chip. */
614static unsigned int count_usable_erasers(const struct flashctx *flash)
615{
616        unsigned int usable_erasefunctions = 0;
617        int k;
618        for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
619                if (!check_block_eraser(flash, k, 0))
620                        usable_erasefunctions++;
621        }
622        return usable_erasefunctions;
623}
624
625static int compare_range(const uint8_t *wantbuf, const uint8_t *havebuf, unsigned int start, unsigned int len)
626{
627        int ret = 0, failcount = 0;
628        unsigned int i;
629        for (i = 0; i < len; i++) {
630                if (wantbuf[i] != havebuf[i]) {
631                        /* Only print the first failure. */
632                        if (!failcount++)
633                                msg_cerr("FAILED at 0x%08x! Expected=0x%02x, Found=0x%02x,",
634                                         start + i, wantbuf[i], havebuf[i]);
635                }
636        }
637        if (failcount) {
638                msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
639                         start, start + len - 1, failcount);
640                ret = -1;
641        }
642        return ret;
643}
644
645/* start is an offset to the base address of the flash chip */
646int check_erased_range(struct flashctx *flash, unsigned int start,
647                       unsigned int len)
648{
649        int ret;
650        uint8_t *cmpbuf = malloc(len);
651
652        if (!cmpbuf) {
653                msg_gerr("Could not allocate memory!\n");
654                exit(1);
655        }
656        memset(cmpbuf, 0xff, len);
657        ret = verify_range(flash, cmpbuf, start, len);
658        free(cmpbuf);
659        return ret;
660}
661
662/*
663 * @cmpbuf      buffer to compare against, cmpbuf[0] is expected to match the
664 *              flash content at location start
665 * @start       offset to the base address of the flash chip
666 * @len         length of the verified area
667 * @return      0 for success, -1 for failure
668 */
669int verify_range(struct flashctx *flash, const uint8_t *cmpbuf, unsigned int start, unsigned int len)
670{
671        if (!len)
672                return -1;
673
674        if (!flash->chip->read) {
675                msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
676                return -1;
677        }
678
679        uint8_t *readbuf = malloc(len);
680        if (!readbuf) {
681                msg_gerr("Could not allocate memory!\n");
682                return -1;
683        }
684        int ret = 0;
685
686        if (start + len > flash->chip->total_size * 1024) {
687                msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
688                        " total_size 0x%x\n", __func__, start, len,
689                        flash->chip->total_size * 1024);
690                ret = -1;
691                goto out_free;
692        }
693
694        ret = flash->chip->read(flash, readbuf, start, len);
695        if (ret) {
696                msg_gerr("Verification impossible because read failed "
697                         "at 0x%x (len 0x%x)\n", start, len);
698                ret = -1;
699                goto out_free;
700        }
701
702        ret = compare_range(cmpbuf, readbuf, start, len);
703out_free:
704        free(readbuf);
705        return ret;
706}
707
708/* Helper function for need_erase() that focuses on granularities of gran bytes. */
709static int need_erase_gran_bytes(const uint8_t *have, const uint8_t *want, unsigned int len, unsigned int gran)
710{
711        unsigned int i, j, limit;
712        for (j = 0; j < len / gran; j++) {
713                limit = min (gran, len - j * gran);
714                /* Are 'have' and 'want' identical? */
715                if (!memcmp(have + j * gran, want + j * gran, limit))
716                        continue;
717                /* have needs to be in erased state. */
718                for (i = 0; i < limit; i++)
719                        if (have[j * gran + i] != 0xff)
720                                return 1;
721        }
722        return 0;
723}
724
725/*
726 * Check if the buffer @have can be programmed to the content of @want without
727 * erasing. This is only possible if all chunks of size @gran are either kept
728 * as-is or changed from an all-ones state to any other state.
729 *
730 * Warning: This function assumes that @have and @want point to naturally
731 * aligned regions.
732 *
733 * @have        buffer with current content
734 * @want        buffer with desired content
735 * @len         length of the checked area
736 * @gran        write granularity (enum, not count)
737 * @return      0 if no erase is needed, 1 otherwise
738 */
739int need_erase(const uint8_t *have, const uint8_t *want, unsigned int len, enum write_granularity gran)
740{
741        int result = 0;
742        unsigned int i;
743
744        switch (gran) {
745        case write_gran_1bit:
746                for (i = 0; i < len; i++)
747                        if ((have[i] & want[i]) != want[i]) {
748                                result = 1;
749                                break;
750                        }
751                break;
752        case write_gran_1byte:
753                for (i = 0; i < len; i++)
754                        if ((have[i] != want[i]) && (have[i] != 0xff)) {
755                                result = 1;
756                                break;
757                        }
758                break;
759        case write_gran_256bytes:
760                result = need_erase_gran_bytes(have, want, len, 256);
761                break;
762        case write_gran_264bytes:
763                result = need_erase_gran_bytes(have, want, len, 264);
764                break;
765        case write_gran_512bytes:
766                result = need_erase_gran_bytes(have, want, len, 512);
767                break;
768        case write_gran_528bytes:
769                result = need_erase_gran_bytes(have, want, len, 528);
770                break;
771        case write_gran_1024bytes:
772                result = need_erase_gran_bytes(have, want, len, 1024);
773                break;
774        case write_gran_1056bytes:
775                result = need_erase_gran_bytes(have, want, len, 1056);
776                break;
777        case write_gran_1byte_implicit_erase:
778                /* Do not erase, handle content changes from anything->0xff by writing 0xff. */
779                result = 0;
780                break;
781        default:
782                msg_cerr("%s: Unsupported granularity! Please report a bug at "
783                         "flashrom@flashrom.org\n", __func__);
784        }
785        return result;
786}
787
788/**
789 * Check if the buffer @have needs to be programmed to get the content of @want.
790 * If yes, return 1 and fill in first_start with the start address of the
791 * write operation and first_len with the length of the first to-be-written
792 * chunk. If not, return 0 and leave first_start and first_len undefined.
793 *
794 * Warning: This function assumes that @have and @want point to naturally
795 * aligned regions.
796 *
797 * @have        buffer with current content
798 * @want        buffer with desired content
799 * @len         length of the checked area
800 * @gran        write granularity (enum, not count)
801 * @first_start offset of the first byte which needs to be written (passed in
802 *              value is increased by the offset of the first needed write
803 *              relative to have/want or unchanged if no write is needed)
804 * @return      length of the first contiguous area which needs to be written
805 *              0 if no write is needed
806 *
807 * FIXME: This function needs a parameter which tells it about coalescing
808 * in relation to the max write length of the programmer and the max write
809 * length of the chip.
810 */
811static unsigned int get_next_write(const uint8_t *have, const uint8_t *want, unsigned int len,
812                          unsigned int *first_start,
813                          enum write_granularity gran)
814{
815        int need_write = 0;
816        unsigned int rel_start = 0, first_len = 0;
817        unsigned int i, limit, stride;
818
819        switch (gran) {
820        case write_gran_1bit:
821        case write_gran_1byte:
822        case write_gran_1byte_implicit_erase:
823                stride = 1;
824                break;
825        case write_gran_256bytes:
826                stride = 256;
827                break;
828        case write_gran_264bytes:
829                stride = 264;
830                break;
831        case write_gran_512bytes:
832                stride = 512;
833                break;
834        case write_gran_528bytes:
835                stride = 528;
836                break;
837        case write_gran_1024bytes:
838                stride = 1024;
839                break;
840        case write_gran_1056bytes:
841                stride = 1056;
842                break;
843        default:
844                msg_cerr("%s: Unsupported granularity! Please report a bug at "
845                         "flashrom@flashrom.org\n", __func__);
846                /* Claim that no write was needed. A write with unknown
847                 * granularity is too dangerous to try.
848                 */
849                return 0;
850        }
851        for (i = 0; i < len / stride; i++) {
852                limit = min(stride, len - i * stride);
853                /* Are 'have' and 'want' identical? */
854                if (memcmp(have + i * stride, want + i * stride, limit)) {
855                        if (!need_write) {
856                                /* First location where have and want differ. */
857                                need_write = 1;
858                                rel_start = i * stride;
859                        }
860                } else {
861                        if (need_write) {
862                                /* First location where have and want
863                                 * do not differ anymore.
864                                 */
865                                break;
866                        }
867                }
868        }
869        if (need_write)
870                first_len = min(i * stride - rel_start, len);
871        *first_start += rel_start;
872        return first_len;
873}
874
875/* This function generates various test patterns useful for testing controller
876 * and chip communication as well as chip behaviour.
877 *
878 * If a byte can be written multiple times, each time keeping 0-bits at 0
879 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
880 * is essentially an AND operation. That's also the reason why this function
881 * provides the result of AND between various patterns.
882 *
883 * Below is a list of patterns (and their block length).
884 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
885 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
886 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
887 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
888 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
889 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
890 * Pattern 6 is 00 (1 Byte)
891 * Pattern 7 is ff (1 Byte)
892 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
893 * byte block.
894 *
895 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
896 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
897 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
898 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
899 * Pattern 12 is 00 (1 Byte)
900 * Pattern 13 is ff (1 Byte)
901 * Patterns 8-13 have no block number.
902 *
903 * Patterns 0-3 are created to detect and efficiently diagnose communication
904 * slips like missed bits or bytes and their repetitive nature gives good visual
905 * cues to the person inspecting the results. In addition, the following holds:
906 * AND Pattern 0/1 == Pattern 4
907 * AND Pattern 2/3 == Pattern 5
908 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
909 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
910 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
911 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
912 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
913 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
914 * Besides that, they provide for bit testing of the last two bytes of every
915 * 256 byte block which contains the block number for patterns 0-6.
916 * Patterns 10-11 are special purpose for detecting subblock aliasing with
917 * block sizes >256 bytes (some Dataflash chips etc.)
918 * AND Pattern 8/9 == Pattern 12
919 * AND Pattern 10/11 == Pattern 12
920 * Pattern 13 is the completely erased state.
921 * None of the patterns can detect aliasing at boundaries which are a multiple
922 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
923 */
924int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
925{
926        int i;
927
928        if (!buf) {
929                msg_gerr("Invalid buffer!\n");
930                return 1;
931        }
932
933        switch (variant) {
934        case 0:
935                for (i = 0; i < size; i++)
936                        buf[i] = (i & 0xf) << 4 | 0x5;
937                break;
938        case 1:
939                for (i = 0; i < size; i++)
940                        buf[i] = (i & 0xf) << 4 | 0xa;
941                break;
942        case 2:
943                for (i = 0; i < size; i++)
944                        buf[i] = 0x50 | (i & 0xf);
945                break;
946        case 3:
947                for (i = 0; i < size; i++)
948                        buf[i] = 0xa0 | (i & 0xf);
949                break;
950        case 4:
951                for (i = 0; i < size; i++)
952                        buf[i] = (i & 0xf) << 4;
953                break;
954        case 5:
955                for (i = 0; i < size; i++)
956                        buf[i] = i & 0xf;
957                break;
958        case 6:
959                memset(buf, 0x00, size);
960                break;
961        case 7:
962                memset(buf, 0xff, size);
963                break;
964        case 8:
965                for (i = 0; i < size; i++)
966                        buf[i] = i & 0xff;
967                break;
968        case 9:
969                for (i = 0; i < size; i++)
970                        buf[i] = ~(i & 0xff);
971                break;
972        case 10:
973                for (i = 0; i < size % 2; i++) {
974                        buf[i * 2] = (i >> 8) & 0xff;
975                        buf[i * 2 + 1] = i & 0xff;
976                }
977                if (size & 0x1)
978                        buf[i * 2] = (i >> 8) & 0xff;
979                break;
980        case 11:
981                for (i = 0; i < size % 2; i++) {
982                        buf[i * 2] = ~((i >> 8) & 0xff);
983                        buf[i * 2 + 1] = ~(i & 0xff);
984                }
985                if (size & 0x1)
986                        buf[i * 2] = ~((i >> 8) & 0xff);
987                break;
988        case 12:
989                memset(buf, 0x00, size);
990                break;
991        case 13:
992                memset(buf, 0xff, size);
993                break;
994        }
995
996        if ((variant >= 0) && (variant <= 7)) {
997                /* Write block number in the last two bytes of each 256-byte
998                 * block, big endian for easier reading of the hexdump.
999                 * Note that this wraps around for chips larger than 2^24 bytes
1000                 * (16 MB).
1001                 */
1002                for (i = 0; i < size / 256; i++) {
1003                        buf[i * 256 + 254] = (i >> 8) & 0xff;
1004                        buf[i * 256 + 255] = i & 0xff;
1005                }
1006        }
1007
1008        return 0;
1009}
1010
1011/* Returns the number of busses commonly supported by the current programmer and flash chip where the latter
1012 * can not be completely accessed due to size/address limits of the programmer. */
1013unsigned int count_max_decode_exceedings(const struct flashctx *flash)
1014{
1015        unsigned int limitexceeded = 0;
1016        uint32_t size = flash->chip->total_size * 1024;
1017        enum chipbustype buses = flash->mst->buses_supported & flash->chip->bustype;
1018
1019        if ((buses & BUS_PARALLEL) && (max_rom_decode.parallel < size)) {
1020                limitexceeded++;
1021                msg_pdbg("Chip size %u kB is bigger than supported "
1022                         "size %u kB of chipset/board/programmer "
1023                         "for %s interface, "
1024                         "probe/read/erase/write may fail. ", size / 1024,
1025                         max_rom_decode.parallel / 1024, "Parallel");
1026        }
1027        if ((buses & BUS_LPC) && (max_rom_decode.lpc < size)) {
1028                limitexceeded++;
1029                msg_pdbg("Chip size %u kB is bigger than supported "
1030                         "size %u kB of chipset/board/programmer "
1031                         "for %s interface, "
1032                         "probe/read/erase/write may fail. ", size / 1024,
1033                         max_rom_decode.lpc / 1024, "LPC");
1034        }
1035        if ((buses & BUS_FWH) && (max_rom_decode.fwh < size)) {
1036                limitexceeded++;
1037                msg_pdbg("Chip size %u kB is bigger than supported "
1038                         "size %u kB of chipset/board/programmer "
1039                         "for %s interface, "
1040                         "probe/read/erase/write may fail. ", size / 1024,
1041                         max_rom_decode.fwh / 1024, "FWH");
1042        }
1043        if ((buses & BUS_SPI) && (max_rom_decode.spi < size)) {
1044                limitexceeded++;
1045                msg_pdbg("Chip size %u kB is bigger than supported "
1046                         "size %u kB of chipset/board/programmer "
1047                         "for %s interface, "
1048                         "probe/read/erase/write may fail. ", size / 1024,
1049                         max_rom_decode.spi / 1024, "SPI");
1050        }
1051        return limitexceeded;
1052}
1053
1054void unmap_flash(struct flashctx *flash)
1055{
1056        if (flash->virtual_registers != (chipaddr)ERROR_PTR) {
1057                programmer_unmap_flash_region((void *)flash->virtual_registers, flash->chip->total_size * 1024);
1058                flash->physical_registers = 0;
1059                flash->virtual_registers = (chipaddr)ERROR_PTR;
1060        }
1061
1062        if (flash->virtual_memory != (chipaddr)ERROR_PTR) {
1063                programmer_unmap_flash_region((void *)flash->virtual_memory, flash->chip->total_size * 1024);
1064                flash->physical_memory = 0;
1065                flash->virtual_memory = (chipaddr)ERROR_PTR;
1066        }
1067}
1068
1069int map_flash(struct flashctx *flash)
1070{
1071        /* Init pointers to the fail-safe state to distinguish them later from legit values. */
1072        flash->virtual_memory = (chipaddr)ERROR_PTR;
1073        flash->virtual_registers = (chipaddr)ERROR_PTR;
1074
1075        /* FIXME: This avoids mapping (and unmapping) of flash chip definitions with size 0.
1076         * These are used for various probing-related hacks that would not map successfully anyway and should be
1077         * removed ASAP. */
1078        if (flash->chip->total_size == 0)
1079                return 0;
1080
1081        const chipsize_t size = flash->chip->total_size * 1024;
1082        uintptr_t base = flashbase ? flashbase : (0xffffffff - size + 1);
1083        void *addr = programmer_map_flash_region(flash->chip->name, base, size);
1084        if (addr == ERROR_PTR) {
1085                msg_perr("Could not map flash chip %s at 0x%0*" PRIxPTR ".\n",
1086                         flash->chip->name, PRIxPTR_WIDTH, base);
1087                return 1;
1088        }
1089        flash->physical_memory = base;
1090        flash->virtual_memory = (chipaddr)addr;
1091
1092        /* FIXME: Special function registers normally live 4 MByte below flash space, but it might be somewhere
1093         * completely different on some chips and programmers, or not mappable at all.
1094         * Ignore these problems for now and always report success. */
1095        if (flash->chip->feature_bits & FEATURE_REGISTERMAP) {
1096                base = 0xffffffff - size - 0x400000 + 1;
1097                addr = programmer_map_flash_region("flash chip registers", base, size);
1098                if (addr == ERROR_PTR) {
1099                        msg_pdbg2("Could not map flash chip registers %s at 0x%0*" PRIxPTR ".\n",
1100                                 flash->chip->name, PRIxPTR_WIDTH, base);
1101                        return 0;
1102                }
1103                flash->physical_registers = base;
1104                flash->virtual_registers = (chipaddr)addr;
1105        }
1106        return 0;
1107}
1108
1109int probe_flash(struct registered_master *mst, int startchip, struct flashctx *flash, int force)
1110{
1111        const struct flashchip *chip;
1112        enum chipbustype buses_common;
1113        char *tmp;
1114
1115        for (chip = flashchips + startchip; chip && chip->name; chip++) {
1116                if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
1117                        continue;
1118                buses_common = mst->buses_supported & chip->bustype;
1119                if (!buses_common)
1120                        continue;
1121                msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
1122                if (!chip->probe && !force) {
1123                        msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
1124                        continue;
1125                }
1126
1127                /* Start filling in the dynamic data. */
1128                flash->chip = calloc(1, sizeof(struct flashchip));
1129                if (!flash->chip) {
1130                        msg_gerr("Out of memory!\n");
1131                        exit(1);
1132                }
1133                memcpy(flash->chip, chip, sizeof(struct flashchip));
1134                flash->mst = mst;
1135
1136                if (map_flash(flash) != 0)
1137                        return -1;
1138
1139                /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
1140                 * is only called with force=1 after normal probing failed.
1141                 */
1142                if (force)
1143                        break;
1144
1145                if (flash->chip->probe(flash) != 1)
1146                        goto notfound;
1147
1148                /* If this is the first chip found, accept it.
1149                 * If this is not the first chip found, accept it only if it is
1150                 * a non-generic match. SFDP and CFI are generic matches.
1151                 * startchip==0 means this call to probe_flash() is the first
1152                 * one for this programmer interface (master) and thus no other chip has
1153                 * been found on this interface.
1154                 */
1155                if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
1156                        msg_cinfo("===\n"
1157                                  "SFDP has autodetected a flash chip which is "
1158                                  "not natively supported by flashrom yet.\n");
1159                        if (count_usable_erasers(flash) == 0)
1160                                msg_cinfo("The standard operations read and "
1161                                          "verify should work, but to support "
1162                                          "erase, write and all other "
1163                                          "possible features");
1164                        else
1165                                msg_cinfo("All standard operations (read, "
1166                                          "verify, erase and write) should "
1167                                          "work, but to support all possible "
1168                                          "features");
1169
1170                        msg_cinfo(" we need to add them manually.\n"
1171                                  "You can help us by mailing us the output of the following command to "
1172                                  "flashrom@flashrom.org:\n"
1173                                  "'flashrom -VV [plus the -p/--programmer parameter]'\n"
1174                                  "Thanks for your help!\n"
1175                                  "===\n");
1176                }
1177
1178                /* First flash chip detected on this bus. */
1179                if (startchip == 0)
1180                        break;
1181                /* Not the first flash chip detected on this bus, but not a generic match either. */
1182                if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
1183                        break;
1184                /* Not the first flash chip detected on this bus, and it's just a generic match. Ignore it. */
1185notfound:
1186                unmap_flash(flash);
1187                free(flash->chip);
1188                flash->chip = NULL;
1189        }
1190
1191        if (!flash->chip)
1192                return -1;
1193
1194
1195        tmp = flashbuses_to_text(flash->chip->bustype);
1196        msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) ", force ? "Assuming" : "Found",
1197                  flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp);
1198        free(tmp);
1199#if CONFIG_INTERNAL == 1
1200        if (programmer_table[programmer].map_flash_region == physmap)
1201                msg_cinfo("mapped at physical address 0x%0*" PRIxPTR ".\n",
1202                          PRIxPTR_WIDTH, flash->physical_memory);
1203        else
1204#endif
1205                msg_cinfo("on %s.\n", programmer_table[programmer].name);
1206
1207        /* Flash registers may more likely not be mapped if the chip was forced.
1208         * Lock info may be stored in registers, so avoid lock info printing. */
1209        if (!force)
1210                if (flash->chip->printlock)
1211                        flash->chip->printlock(flash);
1212
1213        /* Get out of the way for later runs. */
1214        unmap_flash(flash);
1215
1216        /* Return position of matching chip. */
1217        return chip - flashchips;
1218}
1219
1220int read_buf_from_file(unsigned char *buf, unsigned long size,
1221                       const char *filename)
1222{
1223#ifdef __LIBPAYLOAD__
1224        msg_gerr("Error: No file I/O support in libpayload\n");
1225        return 1;
1226#else
1227        unsigned long numbytes;
1228        FILE *image;
1229        struct stat image_stat;
1230
1231        if ((image = fopen(filename, "rb")) == NULL) {
1232                msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
1233                return 1;
1234        }
1235        if (fstat(fileno(image), &image_stat) != 0) {
1236                msg_gerr("Error: getting metadata of file \"%s\" failed: %s\n", filename, strerror(errno));
1237                fclose(image);
1238                return 1;
1239        }
1240        if (image_stat.st_size != size) {
1241                msg_gerr("Error: Image size (%jd B) doesn't match the flash chip's size (%lu B)!\n",
1242                         (intmax_t)image_stat.st_size, size);
1243                fclose(image);
1244                return 1;
1245        }
1246        numbytes = fread(buf, 1, size, image);
1247        if (fclose(image)) {
1248                msg_gerr("Error: closing file \"%s\" failed: %s\n", filename, strerror(errno));
1249                return 1;
1250        }
1251        if (numbytes != size) {
1252                msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1253                         "wanted %ld!\n", numbytes, size);
1254                return 1;
1255        }
1256        return 0;
1257#endif
1258}
1259
1260int write_buf_to_file(const unsigned char *buf, unsigned long size, const char *filename)
1261{
1262#ifdef __LIBPAYLOAD__
1263        msg_gerr("Error: No file I/O support in libpayload\n");
1264        return 1;
1265#else
1266        unsigned long numbytes;
1267        FILE *image;
1268
1269        if (!filename) {
1270                msg_gerr("No filename specified.\n");
1271                return 1;
1272        }
1273        if ((image = fopen(filename, "wb")) == NULL) {
1274                msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
1275                return 1;
1276        }
1277
1278        numbytes = fwrite(buf, 1, size, image);
1279        fclose(image);
1280        if (numbytes != size) {
1281                msg_gerr("File %s could not be written completely.\n",
1282                         filename);
1283                return 1;
1284        }
1285        return 0;
1286#endif
1287}
1288
1289int read_flash_to_file(struct flashctx *flash, const char *filename)
1290{
1291        unsigned long size = flash->chip->total_size * 1024;
1292        unsigned char *buf = calloc(size, sizeof(char));
1293        int ret = 0;
1294
1295        msg_cinfo("Reading flash... ");
1296        if (!buf) {
1297                msg_gerr("Memory allocation failed!\n");
1298                msg_cinfo("FAILED.\n");
1299                return 1;
1300        }
1301        if (!flash->chip->read) {
1302                msg_cerr("No read function available for this flash chip.\n");
1303                ret = 1;
1304                goto out_free;
1305        }
1306        if (flash->chip->read(flash, buf, 0, size)) {
1307                msg_cerr("Read operation failed!\n");
1308                ret = 1;
1309                goto out_free;
1310        }
1311
1312        ret = write_buf_to_file(buf, size, filename);
1313out_free:
1314        free(buf);
1315        msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1316        return ret;
1317}
1318
1319/* Even if an error is found, the function will keep going and check the rest. */
1320static int selfcheck_eraseblocks(const struct flashchip *chip)
1321{
1322        int i, j, k;
1323        int ret = 0;
1324
1325        for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1326                unsigned int done = 0;
1327                struct block_eraser eraser = chip->block_erasers[k];
1328
1329                for (i = 0; i < NUM_ERASEREGIONS; i++) {
1330                        /* Blocks with zero size are bugs in flashchips.c. */
1331                        if (eraser.eraseblocks[i].count &&
1332                            !eraser.eraseblocks[i].size) {
1333                                msg_gerr("ERROR: Flash chip %s erase function "
1334                                        "%i region %i has size 0. Please report"
1335                                        " a bug at flashrom@flashrom.org\n",
1336                                        chip->name, k, i);
1337                                ret = 1;
1338                        }
1339                        /* Blocks with zero count are bugs in flashchips.c. */
1340                        if (!eraser.eraseblocks[i].count &&
1341                            eraser.eraseblocks[i].size) {
1342                                msg_gerr("ERROR: Flash chip %s erase function "
1343                                        "%i region %i has count 0. Please report"
1344                                        " a bug at flashrom@flashrom.org\n",
1345                                        chip->name, k, i);
1346                                ret = 1;
1347                        }
1348                        done += eraser.eraseblocks[i].count *
1349                                eraser.eraseblocks[i].size;
1350                }
1351                /* Empty eraseblock definition with erase function.  */
1352                if (!done && eraser.block_erase)
1353                        msg_gspew("Strange: Empty eraseblock definition with "
1354                                  "non-empty erase function. Not an error.\n");
1355                if (!done)
1356                        continue;
1357                if (done != chip->total_size * 1024) {
1358                        msg_gerr("ERROR: Flash chip %s erase function %i "
1359                                "region walking resulted in 0x%06x bytes total,"
1360                                " expected 0x%06x bytes. Please report a bug at"
1361                                " flashrom@flashrom.org\n", chip->name, k,
1362                                done, chip->total_size * 1024);
1363                        ret = 1;
1364                }
1365                if (!eraser.block_erase)
1366                        continue;
1367                /* Check if there are identical erase functions for different
1368                 * layouts. That would imply "magic" erase functions. The
1369                 * easiest way to check this is with function pointers.
1370                 */
1371                for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
1372                        if (eraser.block_erase ==
1373                            chip->block_erasers[j].block_erase) {
1374                                msg_gerr("ERROR: Flash chip %s erase function "
1375                                        "%i and %i are identical. Please report"
1376                                        " a bug at flashrom@flashrom.org\n",
1377                                        chip->name, k, j);
1378                                ret = 1;
1379                        }
1380                }
1381        }
1382        return ret;
1383}
1384
1385static int erase_and_write_block_helper(struct flashctx *flash,
1386                                        unsigned int start, unsigned int len,
1387                                        uint8_t *curcontents,
1388                                        uint8_t *newcontents,
1389                                        int (*erasefn) (struct flashctx *flash,
1390                                                        unsigned int addr,
1391                                                        unsigned int len))
1392{
1393        unsigned int starthere = 0, lenhere = 0;
1394        int ret = 0, skip = 1, writecount = 0;
1395        enum write_granularity gran = flash->chip->gran;
1396
1397        /* curcontents and newcontents are opaque to walk_eraseregions, and
1398         * need to be adjusted here to keep the impression of proper abstraction
1399         */
1400        curcontents += start;
1401        newcontents += start;
1402        msg_cdbg(":");
1403        if (need_erase(curcontents, newcontents, len, gran)) {
1404                msg_cdbg("E");
1405                ret = erasefn(flash, start, len);
1406                if (ret)
1407                        return ret;
1408                if (check_erased_range(flash, start, len)) {
1409                        msg_cerr("ERASE FAILED!\n");
1410                        return -1;
1411                }
1412                /* Erase was successful. Adjust curcontents. */
1413                memset(curcontents, 0xff, len);
1414                skip = 0;
1415        }
1416        /* get_next_write() sets starthere to a new value after the call. */
1417        while ((lenhere = get_next_write(curcontents + starthere,
1418                                         newcontents + starthere,
1419                                         len - starthere, &starthere, gran))) {
1420                if (!writecount++)
1421                        msg_cdbg("W");
1422                /* Needs the partial write function signature. */
1423                ret = flash->chip->write(flash, newcontents + starthere,
1424                                   start + starthere, lenhere);
1425                if (ret)
1426                        return ret;
1427                starthere += lenhere;
1428                skip = 0;
1429        }
1430        if (skip)
1431                msg_cdbg("S");
1432        else
1433                all_skipped = false;
1434        return ret;
1435}
1436
1437static int walk_eraseregions(struct flashctx *flash, int erasefunction,
1438                             int (*do_something) (struct flashctx *flash,
1439                                                  unsigned int addr,
1440                                                  unsigned int len,
1441                                                  uint8_t *param1,
1442                                                  uint8_t *param2,
1443                                                  int (*erasefn) (
1444                                                        struct flashctx *flash,
1445                                                        unsigned int addr,
1446                                                        unsigned int len)),
1447                             void *param1, void *param2)
1448{
1449        int i, j;
1450        unsigned int start = 0;
1451        unsigned int len;
1452        struct block_eraser eraser = flash->chip->block_erasers[erasefunction];
1453
1454        for (i = 0; i < NUM_ERASEREGIONS; i++) {
1455                /* count==0 for all automatically initialized array
1456                 * members so the loop below won't be executed for them.
1457                 */
1458                len = eraser.eraseblocks[i].size;
1459                for (j = 0; j < eraser.eraseblocks[i].count; j++) {
1460                        /* Print this for every block except the first one. */
1461                        if (i || j)
1462                                msg_cdbg(", ");
1463                        msg_cdbg("0x%06x-0x%06x", start,
1464                                     start + len - 1);
1465                        if (do_something(flash, start, len, param1, param2,
1466                                         eraser.block_erase)) {
1467                                return 1;
1468                        }
1469                        start += len;
1470                }
1471        }
1472        msg_cdbg("\n");
1473        return 0;
1474}
1475
1476static int check_block_eraser(const struct flashctx *flash, int k, int log)
1477{
1478        struct block_eraser eraser = flash->chip->block_erasers[k];
1479
1480        if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
1481                if (log)
1482                        msg_cdbg("not defined. ");
1483                return 1;
1484        }
1485        if (!eraser.block_erase && eraser.eraseblocks[0].count) {
1486                if (log)
1487                        msg_cdbg("eraseblock layout is known, but matching "
1488                                 "block erase function is not implemented. ");
1489                return 1;
1490        }
1491        if (eraser.block_erase && !eraser.eraseblocks[0].count) {
1492                if (log)
1493                        msg_cdbg("block erase function found, but "
1494                                 "eraseblock layout is not defined. ");
1495                return 1;
1496        }
1497        // TODO: Once erase functions are annotated with allowed buses, check that as well.
1498        return 0;
1499}
1500
1501int erase_and_write_flash(struct flashctx *flash, uint8_t *oldcontents, uint8_t *newcontents)
1502{
1503        int k, ret = 1;
1504        uint8_t *curcontents;
1505        unsigned long size = flash->chip->total_size * 1024;
1506        unsigned int usable_erasefunctions = count_usable_erasers(flash);
1507
1508        msg_cinfo("Erasing and writing flash chip... ");
1509        curcontents = malloc(size);
1510        if (!curcontents) {
1511                msg_gerr("Out of memory!\n");
1512                exit(1);
1513        }
1514        /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1515        memcpy(curcontents, oldcontents, size);
1516
1517        for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1518                if (k != 0)
1519                        msg_cinfo("Looking for another erase function.\n");
1520                if (!usable_erasefunctions) {
1521                        msg_cinfo("No usable erase functions left.\n");
1522                        break;
1523                }
1524                msg_cdbg("Trying erase function %i... ", k);
1525                if (check_block_eraser(flash, k, 1))
1526                        continue;
1527                usable_erasefunctions--;
1528                ret = walk_eraseregions(flash, k, &erase_and_write_block_helper,
1529                                        curcontents, newcontents);
1530                /* If everything is OK, don't try another erase function. */
1531                if (!ret)
1532                        break;
1533                /* Write/erase failed, so try to find out what the current chip
1534                 * contents are. If no usable erase functions remain, we can
1535                 * skip this: the next iteration will break immediately anyway.
1536                 */
1537                if (!usable_erasefunctions)
1538                        continue;
1539                /* Reading the whole chip may take a while, inform the user even
1540                 * in non-verbose mode.
1541                 */
1542                msg_cinfo("Reading current flash chip contents... ");
1543                if (flash->chip->read(flash, curcontents, 0, size)) {
1544                        /* Now we are truly screwed. Read failed as well. */
1545                        msg_cerr("Can't read anymore! Aborting.\n");
1546                        /* We have no idea about the flash chip contents, so
1547                         * retrying with another erase function is pointless.
1548                         */
1549                        break;
1550                }
1551                msg_cinfo("done. ");
1552        }
1553        /* Free the scratchpad. */
1554        free(curcontents);
1555
1556        if (ret) {
1557                msg_cerr("FAILED!\n");
1558        } else {
1559                if (all_skipped)
1560                        msg_cinfo("\nWarning: Chip content is identical to the requested image.\n");
1561                msg_cinfo("Erase/write done.\n");
1562        }
1563        return ret;
1564}
1565
1566static void nonfatal_help_message(void)
1567{
1568        msg_gerr("Good, writing to the flash chip apparently didn't do anything.\n");
1569#if CONFIG_INTERNAL == 1
1570        if (programmer == PROGRAMMER_INTERNAL)
1571                msg_gerr("This means we have to add special support for your board, programmer or flash\n"
1572                         "chip. Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1573                         "mail flashrom@flashrom.org, thanks!\n"
1574                         "-------------------------------------------------------------------------------\n"
1575                         "You may now reboot or simply leave the machine running.\n");
1576        else
1577#endif
1578                msg_gerr("Please check the connections (especially those to write protection pins) between\n"
1579                         "the programmer and the flash chip. If you think the error is caused by flashrom\n"
1580                         "please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1581                         "mail flashrom@flashrom.org, thanks!\n");
1582}
1583
1584static void emergency_help_message(void)
1585{
1586        msg_gerr("Your flash chip is in an unknown state.\n");
1587#if CONFIG_INTERNAL == 1
1588        if (programmer == PROGRAMMER_INTERNAL)
1589                msg_gerr("Get help on IRC at chat.freenode.net (channel #flashrom) or\n"
1590                        "mail flashrom@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
1591                        "-------------------------------------------------------------------------------\n"
1592                        "DO NOT REBOOT OR POWEROFF!\n");
1593        else
1594#endif
1595                msg_gerr("Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1596                         "mail flashrom@flashrom.org, thanks!\n");
1597}
1598
1599/* The way to go if you want a delimited list of programmers */
1600void list_programmers(const char *delim)
1601{
1602        enum programmer p;
1603        for (p = 0; p < PROGRAMMER_INVALID; p++) {
1604                msg_ginfo("%s", programmer_table[p].name);
1605                if (p < PROGRAMMER_INVALID - 1)
1606                        msg_ginfo("%s", delim);
1607        }
1608        msg_ginfo("\n");       
1609}
1610
1611void list_programmers_linebreak(int startcol, int cols, int paren)
1612{
1613        const char *pname;
1614        int pnamelen;
1615        int remaining = 0, firstline = 1;
1616        enum programmer p;
1617        int i;
1618
1619        for (p = 0; p < PROGRAMMER_INVALID; p++) {
1620                pname = programmer_table[p].name;
1621                pnamelen = strlen(pname);
1622                if (remaining - pnamelen - 2 < 0) {
1623                        if (firstline)
1624                                firstline = 0;
1625                        else
1626                                msg_ginfo("\n");
1627                        for (i = 0; i < startcol; i++)
1628                                msg_ginfo(" ");
1629                        remaining = cols - startcol;
1630                } else {
1631                        msg_ginfo(" ");
1632                        remaining--;
1633                }
1634                if (paren && (p == 0)) {
1635                        msg_ginfo("(");
1636                        remaining--;
1637                }
1638                msg_ginfo("%s", pname);
1639                remaining -= pnamelen;
1640                if (p < PROGRAMMER_INVALID - 1) {
1641                        msg_ginfo(",");
1642                        remaining--;
1643                } else {
1644                        if (paren)
1645                                msg_ginfo(")");
1646                }
1647        }
1648}
1649
1650void print_sysinfo(void)
1651{
1652#ifdef _WIN32
1653        SYSTEM_INFO si;
1654        OSVERSIONINFOEX osvi;
1655
1656        memset(&si, 0, sizeof(SYSTEM_INFO));
1657        memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
1658        msg_ginfo(" on Windows");
1659        /* Tell Windows which version of the structure we want. */
1660        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1661        if (GetVersionEx((OSVERSIONINFO*) &osvi))
1662                msg_ginfo(" %lu.%lu", osvi.dwMajorVersion, osvi.dwMinorVersion);
1663        else
1664                msg_ginfo(" unknown version");
1665        GetSystemInfo(&si);
1666        switch (si.wProcessorArchitecture) {
1667        case PROCESSOR_ARCHITECTURE_AMD64:
1668                msg_ginfo(" (x86_64)");
1669                break;
1670        case PROCESSOR_ARCHITECTURE_INTEL:
1671                msg_ginfo(" (x86)");
1672                break;
1673        default:
1674                msg_ginfo(" (unknown arch)");
1675                break;
1676        }
1677#elif HAVE_UTSNAME == 1
1678        struct utsname osinfo;
1679
1680        uname(&osinfo);
1681        msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1682                  osinfo.machine);
1683#else
1684        msg_ginfo(" on unknown machine");
1685#endif
1686}
1687
1688void print_buildinfo(void)
1689{
1690        msg_gdbg("flashrom was built with");
1691#if NEED_PCI == 1
1692#ifdef PCILIB_VERSION
1693        msg_gdbg(" libpci %s,", PCILIB_VERSION);
1694#else
1695        msg_gdbg(" unknown PCI library,");
1696#endif
1697#endif
1698#ifdef __clang__
1699        msg_gdbg(" LLVM Clang");
1700#ifdef __clang_version__
1701        msg_gdbg(" %s,", __clang_version__);
1702#else
1703        msg_gdbg(" unknown version (before r102686),");
1704#endif
1705#elif defined(__GNUC__)
1706        msg_gdbg(" GCC");
1707#ifdef __VERSION__
1708        msg_gdbg(" %s,", __VERSION__);
1709#else
1710        msg_gdbg(" unknown version,");
1711#endif
1712#else
1713        msg_gdbg(" unknown compiler,");
1714#endif
1715#if defined (__FLASHROM_LITTLE_ENDIAN__)
1716        msg_gdbg(" little endian");
1717#elif defined (__FLASHROM_BIG_ENDIAN__)
1718        msg_gdbg(" big endian");
1719#else
1720#error Endianness could not be determined
1721#endif
1722        msg_gdbg("\n");
1723}
1724
1725void print_version(void)
1726{
1727        msg_ginfo("flashrom v%s", flashrom_version);
1728        print_sysinfo();
1729        msg_ginfo("\n");
1730}
1731
1732void print_banner(void)
1733{
1734        msg_ginfo("flashrom is free software, get the source code at "
1735                  "http://www.flashrom.org\n");
1736        msg_ginfo("\n");
1737}
1738
1739int selfcheck(void)
1740{
1741        unsigned int i;
1742        int ret = 0;
1743
1744        /* Safety check. Instead of aborting after the first error, check
1745         * if more errors exist.
1746         */
1747        if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
1748                msg_gerr("Programmer table miscompilation!\n");
1749                ret = 1;
1750        }
1751        for (i = 0; i < PROGRAMMER_INVALID; i++) {
1752                const struct programmer_entry p = programmer_table[i];
1753                if (p.name == NULL) {
1754                        msg_gerr("All programmers need a valid name, but the one with index %d does not!\n", i);
1755                        ret = 1;
1756                        /* This might hide other problems with this programmer, but allows for better error
1757                         * messages below without jumping through hoops. */
1758                        continue;
1759                }
1760                switch (p.type) {
1761                case USB:
1762                case PCI:
1763                case OTHER:
1764                        if (p.devs.note == NULL) {
1765                                if (strcmp("internal", p.name) == 0)
1766                                        break; /* This one has its device list stored separately. */
1767                                msg_gerr("Programmer %s has neither a device list nor a textual description!\n",
1768                                         p.name);
1769                                ret = 1;
1770                        }
1771                        break;
1772                default:
1773                        msg_gerr("Programmer %s does not have a valid type set!\n", p.name);
1774                        ret = 1;
1775                        break;
1776                }
1777                if (p.init == NULL) {
1778                        msg_gerr("Programmer %s does not have a valid init function!\n", p.name);
1779                        ret = 1;
1780                }
1781                if (p.delay == NULL) {
1782                        msg_gerr("Programmer %s does not have a valid delay function!\n", p.name);
1783                        ret = 1;
1784                }
1785                if (p.map_flash_region == NULL) {
1786                        msg_gerr("Programmer %s does not have a valid map_flash_region function!\n", p.name);
1787                        ret = 1;
1788                }
1789                if (p.unmap_flash_region == NULL) {
1790                        msg_gerr("Programmer %s does not have a valid unmap_flash_region function!\n", p.name);
1791                        ret = 1;
1792                }
1793        }
1794
1795        /* It would be favorable if we could check for the correct layout (especially termination) of various
1796         * constant arrays: flashchips, chipset_enables, board_matches, boards_known, laptops_known.
1797         * They are all defined as externs in this compilation unit so we don't know their sizes which vary
1798         * depending on compiler flags, e.g. the target architecture, and can sometimes be 0.
1799         * For 'flashchips' we export the size explicitly to work around this and to be able to implement the
1800         * checks below. */
1801        if (flashchips_size <= 1 || flashchips[flashchips_size - 1].name != NULL) {
1802                msg_gerr("Flashchips table miscompilation!\n");
1803                ret = 1;
1804        } else {
1805                for (i = 0; i < flashchips_size - 1; i++) {
1806                        const struct flashchip *chip = &flashchips[i];
1807                        if (chip->vendor == NULL || chip->name == NULL || chip->bustype == BUS_NONE) {
1808                                ret = 1;
1809                                msg_gerr("ERROR: Some field of flash chip #%d (%s) is misconfigured.\n"
1810                                         "Please report a bug at flashrom@flashrom.org\n", i,
1811                                         chip->name == NULL ? "unnamed" : chip->name);
1812                        }
1813                        if (selfcheck_eraseblocks(chip)) {
1814                                ret = 1;
1815                        }
1816                }
1817        }
1818
1819#if CONFIG_INTERNAL == 1
1820        ret |= selfcheck_board_enables();
1821#endif
1822
1823        /* TODO: implement similar sanity checks for other arrays where deemed necessary. */
1824        return ret;
1825}
1826
1827/* FIXME: This function signature needs to be improved once doit() has a better
1828 * function signature.
1829 */
1830int chip_safety_check(const struct flashctx *flash, int force, int read_it, int write_it, int erase_it,
1831                      int verify_it)
1832{
1833        const struct flashchip *chip = flash->chip;
1834
1835        if (!programmer_may_write && (write_it || erase_it)) {
1836                msg_perr("Write/erase is not working yet on your programmer in "
1837                         "its current configuration.\n");
1838                /* --force is the wrong approach, but it's the best we can do
1839                 * until the generic programmer parameter parser is merged.
1840                 */
1841                if (!force)
1842                        return 1;
1843                msg_cerr("Continuing anyway.\n");
1844        }
1845
1846        if (read_it || erase_it || write_it || verify_it) {
1847                /* Everything needs read. */
1848                if (chip->tested.read == BAD) {
1849                        msg_cerr("Read is not working on this chip. ");
1850                        if (!force)
1851                                return 1;
1852                        msg_cerr("Continuing anyway.\n");
1853                }
1854                if (!chip->read) {
1855                        msg_cerr("flashrom has no read function for this "
1856                                 "flash chip.\n");
1857                        return 1;
1858                }
1859        }
1860        if (erase_it || write_it) {
1861                /* Write needs erase. */
1862                if (chip->tested.erase == NA) {
1863                        msg_cerr("Erase is not possible on this chip.\n");
1864                        return 1;
1865                }
1866                if (chip->tested.erase == BAD) {
1867                        msg_cerr("Erase is not working on this chip. ");
1868                        if (!force)
1869                                return 1;
1870                        msg_cerr("Continuing anyway.\n");
1871                }
1872                if(count_usable_erasers(flash) == 0) {
1873                        msg_cerr("flashrom has no erase function for this "
1874                                 "flash chip.\n");
1875                        return 1;
1876                }
1877        }
1878        if (write_it) {
1879                if (chip->tested.write == NA) {
1880                        msg_cerr("Write is not possible on this chip.\n");
1881                        return 1;
1882                }
1883                if (chip->tested.write == BAD) {
1884                        msg_cerr("Write is not working on this chip. ");
1885                        if (!force)
1886                                return 1;
1887                        msg_cerr("Continuing anyway.\n");
1888                }
1889                if (!chip->write) {
1890                        msg_cerr("flashrom has no write function for this "
1891                                 "flash chip.\n");
1892                        return 1;
1893                }
1894        }
1895        return 0;
1896}
1897
1898/* This function signature is horrible. We need to design a better interface,
1899 * but right now it allows us to split off the CLI code.
1900 * Besides that, the function itself is a textbook example of abysmal code flow.
1901 */
1902int doit(struct flashctx *flash, int force, const char *filename, int read_it,
1903         int write_it, int erase_it, int verify_it)
1904{
1905        uint8_t *oldcontents;
1906        uint8_t *newcontents;
1907        int ret = 0;
1908        unsigned long size = flash->chip->total_size * 1024;
1909        int read_all_first = 1; /* FIXME: Make this configurable. */
1910
1911        if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) {
1912                msg_cerr("Aborting.\n");
1913                return 1;
1914        }
1915
1916        if (normalize_romentries(flash)) {
1917                msg_cerr("Requested regions can not be handled. Aborting.\n");
1918                return 1;
1919        }
1920
1921        /* Given the existence of read locks, we want to unlock for read,
1922         * erase and write.
1923         */
1924        if (flash->chip->unlock)
1925                flash->chip->unlock(flash);
1926
1927        if (read_it) {
1928                return read_flash_to_file(flash, filename);
1929        }
1930
1931        oldcontents = malloc(size);
1932        if (!oldcontents) {
1933                msg_gerr("Out of memory!\n");
1934                exit(1);
1935        }
1936        /* Assume worst case: All bits are 0. */
1937        memset(oldcontents, 0x00, size);
1938        newcontents = malloc(size);
1939        if (!newcontents) {
1940                msg_gerr("Out of memory!\n");
1941                exit(1);
1942        }
1943        /* Assume best case: All bits should be 1. */
1944        memset(newcontents, 0xff, size);
1945        /* Side effect of the assumptions above: Default write action is erase
1946         * because newcontents looks like a completely erased chip, and
1947         * oldcontents being completely 0x00 means we have to erase everything
1948         * before we can write.
1949         */
1950
1951        if (erase_it) {
1952                /* FIXME: Do we really want the scary warning if erase failed?
1953                 * After all, after erase the chip is either blank or partially
1954                 * blank or it has the old contents. A blank chip won't boot,
1955                 * so if the user wanted erase and reboots afterwards, the user
1956                 * knows very well that booting won't work.
1957                 */
1958                if (erase_and_write_flash(flash, oldcontents, newcontents)) {
1959                        emergency_help_message();
1960                        ret = 1;
1961                }
1962                goto out;
1963        }
1964
1965        if (write_it || verify_it) {
1966                if (read_buf_from_file(newcontents, size, filename)) {
1967                        ret = 1;
1968                        goto out;
1969                }
1970
1971#if CONFIG_INTERNAL == 1
1972                if (programmer == PROGRAMMER_INTERNAL && cb_check_image(newcontents, size) < 0) {
1973                        if (force_boardmismatch) {
1974                                msg_pinfo("Proceeding anyway because user forced us to.\n");
1975                        } else {
1976                                msg_perr("Aborting. You can override this with "
1977                                         "-p internal:boardmismatch=force.\n");
1978                                ret = 1;
1979                                goto out;
1980                        }
1981                }
1982#endif
1983        }
1984
1985        /* Read the whole chip to be able to check whether regions need to be
1986         * erased and to give better diagnostics in case write fails.
1987         * The alternative is to read only the regions which are to be
1988         * preserved, but in that case we might perform unneeded erase which
1989         * takes time as well.
1990         */
1991        if (read_all_first) {
1992                msg_cinfo("Reading old flash chip contents... ");
1993                if (flash->chip->read(flash, oldcontents, 0, size)) {
1994                        ret = 1;
1995                        msg_cinfo("FAILED.\n");
1996                        goto out;
1997                }
1998        }
1999        msg_cinfo("done.\n");
2000
2001        /* Build a new image taking the given layout into account. */
2002        if (build_new_image(flash, read_all_first, oldcontents, newcontents)) {
2003                msg_gerr("Could not prepare the data to be written, aborting.\n");
2004                ret = 1;
2005                goto out;
2006        }
2007
2008        // ////////////////////////////////////////////////////////////
2009
2010        if (write_it && erase_and_write_flash(flash, oldcontents, newcontents)) {
2011                msg_cerr("Uh oh. Erase/write failed.");
2012                if (read_all_first) {
2013                        msg_cerr("Checking if anything has changed.\n");
2014                        msg_cinfo("Reading current flash chip contents... ");
2015                        if (!flash->chip->read(flash, newcontents, 0, size)) {
2016                                msg_cinfo("done.\n");
2017                                if (!memcmp(oldcontents, newcontents, size)) {
2018                                        nonfatal_help_message();
2019                                        ret = 1;
2020                                        goto out;
2021                                }
2022                                msg_cerr("Apparently at least some data has changed.\n");
2023                        } else
2024                                msg_cerr("Can't even read anymore!\n");
2025                        emergency_help_message();
2026                        ret = 1;
2027                        goto out;
2028                } else
2029                        msg_cerr("\n");
2030                emergency_help_message();
2031                ret = 1;
2032                goto out;
2033        }
2034
2035        /* Verify only if we either did not try to write (verify operation) or actually changed something. */
2036        if (verify_it && (!write_it || !all_skipped)) {
2037                msg_cinfo("Verifying flash... ");
2038
2039                if (write_it) {
2040                        /* Work around chips which need some time to calm down. */
2041                        programmer_delay(1000*1000);
2042                        ret = verify_range(flash, newcontents, 0, size);
2043                        /* If we tried to write, and verification now fails, we
2044                         * might have an emergency situation.
2045                         */
2046                        if (ret)
2047                                emergency_help_message();
2048                } else {
2049                        ret = compare_range(newcontents, oldcontents, 0, size);
2050                }
2051                if (!ret)
2052                        msg_cinfo("VERIFIED.\n");
2053        }
2054
2055out:
2056        free(oldcontents);
2057        free(newcontents);
2058        return ret;
2059}
Note: See TracBrowser for help on using the repository browser.