| /* |
| * This file is part of the flashrom project. |
| * |
| * Copyright (C) 2000 Silicon Integrated System Corporation |
| * Copyright (C) 2004 Tyan Corp <yhlu@tyan.com> |
| * Copyright (C) 2005-2008 coresystems GmbH |
| * Copyright (C) 2008,2009 Carl-Daniel Hailfinger |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <sys/types.h> |
| #ifndef __LIBPAYLOAD__ |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #endif |
| #include <string.h> |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include <getopt.h> |
| #if HAVE_UTSNAME == 1 |
| #include <sys/utsname.h> |
| #endif |
| #include <unistd.h> |
| |
| #include "action_descriptor.h" |
| #include "flash.h" |
| #include "flashchips.h" |
| #include "layout.h" |
| #include "programmer.h" |
| #include "spi.h" |
| |
| const char flashrom_version[] = FLASHROM_VERSION; |
| char *chip_to_probe = NULL; |
| |
| /* Set if any erase/write operation is to be done. This will be used to |
| * decide if final verification is needed. */ |
| static int content_has_changed = 0; |
| |
| /* error handling stuff */ |
| enum error_action access_denied_action = error_ignore; |
| |
| int ignore_error(int err) { |
| int rc = 0; |
| |
| switch(err) { |
| case ACCESS_DENIED: |
| if (access_denied_action == error_ignore) |
| rc = 1; |
| break; |
| default: |
| break; |
| } |
| |
| return rc; |
| } |
| |
| static enum programmer programmer = PROGRAMMER_INVALID; |
| static char *programmer_param = NULL; |
| |
| /* Supported buses for the current programmer. */ |
| enum chipbustype buses_supported; |
| |
| /* |
| * Programmers supporting multiple buses can have differing size limits on |
| * each bus. Store the limits for each bus in a common struct. |
| */ |
| struct decode_sizes max_rom_decode; |
| |
| /* If nonzero, used as the start address of bottom-aligned flash. */ |
| unsigned long flashbase; |
| |
| /* Is writing allowed with this programmer? */ |
| int programmer_may_write; |
| |
| const struct programmer_entry programmer_table[] = { |
| #if CONFIG_INTERNAL == 1 |
| { |
| .name = "internal", |
| .init = internal_init, |
| .map_flash_region = physmap, |
| .unmap_flash_region = physunmap, |
| .delay = internal_delay, |
| |
| /* |
| * "Internal" implies in-system programming on a live system, so |
| * handle with paranoia to catch errors early. If something goes |
| * wrong then hopefully the system will still be recoverable. |
| */ |
| .paranoid = 1, |
| }, |
| #endif |
| |
| #if CONFIG_DUMMY == 1 |
| { |
| .name = "dummy", |
| .init = dummy_init, |
| .map_flash_region = dummy_map, |
| .unmap_flash_region = dummy_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_NIC3COM == 1 |
| { |
| .name = "nic3com", |
| .init = nic3com_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_NICREALTEK == 1 |
| { |
| /* This programmer works for Realtek RTL8139 and SMC 1211. */ |
| .name = "nicrealtek", |
| //.name = "nicsmc1211", |
| .init = nicrealtek_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_NICNATSEMI == 1 |
| { |
| .name = "nicnatsemi", |
| .init = nicnatsemi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_GFXNVIDIA == 1 |
| { |
| .name = "gfxnvidia", |
| .init = gfxnvidia_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_DRKAISER == 1 |
| { |
| .name = "drkaiser", |
| .init = drkaiser_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_SATASII == 1 |
| { |
| .name = "satasii", |
| .init = satasii_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_ATAHPT == 1 |
| { |
| .name = "atahpt", |
| .init = atahpt_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_FT2232_SPI == 1 |
| { |
| .name = "ft2232_spi", |
| .init = ft2232_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_SERPROG == 1 |
| { |
| .name = "serprog", |
| .init = serprog_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = serprog_delay, |
| }, |
| #endif |
| |
| #if CONFIG_BUSPIRATE_SPI == 1 |
| { |
| .name = "buspirate_spi", |
| .init = buspirate_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_RAIDEN_DEBUG_SPI == 1 |
| { |
| .name = "raiden_debug_spi", |
| .init = raiden_debug_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_DEDIPROG == 1 |
| { |
| .name = "dediprog", |
| .init = dediprog_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_RAYER_SPI == 1 |
| { |
| .name = "rayer_spi", |
| .init = rayer_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_NICINTEL == 1 |
| { |
| .name = "nicintel", |
| .init = nicintel_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_NICINTEL_SPI == 1 |
| { |
| .name = "nicintel_spi", |
| .init = nicintel_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_OGP_SPI == 1 |
| { |
| .name = "ogp_spi", |
| .init = ogp_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_SATAMV == 1 |
| { |
| .name = "satamv", |
| .init = satamv_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_LINUX_MTD == 1 |
| { |
| .name = "linux_mtd", |
| .init = linux_mtd_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| #if CONFIG_LINUX_SPI == 1 |
| { |
| .name = "linux_spi", |
| .init = linux_spi_init, |
| .map_flash_region = fallback_map, |
| .unmap_flash_region = fallback_unmap, |
| .delay = internal_delay, |
| }, |
| #endif |
| |
| {0}, /* This entry corresponds to PROGRAMMER_INVALID. */ |
| }; |
| |
| #define CHIP_RESTORE_MAXFN 4 |
| static int chip_restore_fn_count = 0; |
| struct chip_restore_func_data { |
| CHIP_RESTORE_CALLBACK; |
| struct flashctx *flash; |
| uint8_t status; |
| } static chip_restore_fn[CHIP_RESTORE_MAXFN]; |
| |
| |
| #define SHUTDOWN_MAXFN 32 |
| static int shutdown_fn_count = 0; |
| struct shutdown_func_data { |
| int (*func) (void *data); |
| void *data; |
| } static shutdown_fn[SHUTDOWN_MAXFN]; |
| /* Initialize to 0 to make sure nobody registers a shutdown function before |
| * programmer init. |
| */ |
| static int may_register_shutdown = 0; |
| |
| static int check_block_eraser(const struct flashctx *flash, int k, int log); |
| |
| /* Register a function to be executed on programmer shutdown. |
| * The advantage over atexit() is that you can supply a void pointer which will |
| * be used as parameter to the registered function upon programmer shutdown. |
| * This pointer can point to arbitrary data used by said function, e.g. undo |
| * information for GPIO settings etc. If unneeded, set data=NULL. |
| * Please note that the first (void *data) belongs to the function signature of |
| * the function passed as first parameter. |
| */ |
| int register_shutdown(int (*function) (void *data), void *data) |
| { |
| if (shutdown_fn_count >= SHUTDOWN_MAXFN) { |
| msg_perr("Tried to register more than %i shutdown functions.\n", |
| SHUTDOWN_MAXFN); |
| return 1; |
| } |
| if (!may_register_shutdown) { |
| msg_perr("Tried to register a shutdown function before " |
| "programmer init.\n"); |
| return 1; |
| } |
| shutdown_fn[shutdown_fn_count].func = function; |
| shutdown_fn[shutdown_fn_count].data = data; |
| shutdown_fn_count++; |
| |
| return 0; |
| } |
| |
| //int register_chip_restore(int (*function) (void *data), void *data) |
| int register_chip_restore(CHIP_RESTORE_CALLBACK, |
| struct flashctx *flash, uint8_t status) |
| { |
| if (chip_restore_fn_count >= CHIP_RESTORE_MAXFN) { |
| msg_perr("Tried to register more than %i chip restore" |
| " functions.\n", CHIP_RESTORE_MAXFN); |
| return 1; |
| } |
| chip_restore_fn[chip_restore_fn_count].func = func; /* from macro */ |
| chip_restore_fn[chip_restore_fn_count].flash = flash; |
| chip_restore_fn[chip_restore_fn_count].status = status; |
| chip_restore_fn_count++; |
| |
| return 0; |
| } |
| |
| int programmer_init(enum programmer prog, char *param) |
| { |
| int ret; |
| |
| if (prog >= PROGRAMMER_INVALID) { |
| msg_perr("Invalid programmer specified!\n"); |
| return -1; |
| } |
| programmer = prog; |
| /* Initialize all programmer specific data. */ |
| /* Default to unlimited decode sizes. */ |
| max_rom_decode = (const struct decode_sizes) { |
| .parallel = 0xffffffff, |
| .lpc = 0xffffffff, |
| .fwh = 0xffffffff, |
| .spi = 0xffffffff, |
| }; |
| buses_supported = BUS_NONE; |
| /* Default to top aligned flash at 4 GB. */ |
| flashbase = 0; |
| /* Registering shutdown functions is now allowed. */ |
| may_register_shutdown = 1; |
| /* Default to allowing writes. Broken programmers set this to 0. */ |
| programmer_may_write = 1; |
| |
| programmer_param = param; |
| msg_pdbg("Initializing %s programmer\n", |
| programmer_table[programmer].name); |
| ret = programmer_table[programmer].init(); |
| return ret; |
| } |
| |
| int chip_restore() |
| { |
| int rc = 0; |
| |
| while (chip_restore_fn_count > 0) { |
| int i = --chip_restore_fn_count; |
| rc |= chip_restore_fn[i].func(chip_restore_fn[i].flash, |
| chip_restore_fn[i].status); |
| } |
| |
| return rc; |
| } |
| |
| int programmer_shutdown(void) |
| { |
| int ret = 0; |
| |
| /* Registering shutdown functions is no longer allowed. */ |
| may_register_shutdown = 0; |
| while (shutdown_fn_count > 0) { |
| int i = --shutdown_fn_count; |
| ret |= shutdown_fn[i].func(shutdown_fn[i].data); |
| } |
| return ret; |
| } |
| |
| void *programmer_map_flash_region(const char *descr, unsigned long phys_addr, |
| size_t len) |
| { |
| return programmer_table[programmer].map_flash_region(descr, |
| phys_addr, len); |
| } |
| |
| void programmer_unmap_flash_region(void *virt_addr, size_t len) |
| { |
| programmer_table[programmer].unmap_flash_region(virt_addr, len); |
| } |
| |
| void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr) |
| { |
| par_master->chip_writeb(flash, val, addr); |
| } |
| |
| void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr) |
| { |
| par_master->chip_writew(flash, val, addr); |
| } |
| |
| void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr) |
| { |
| par_master->chip_writel(flash, val, addr); |
| } |
| |
| void chip_writen(const struct flashctx *flash, uint8_t *buf, chipaddr addr, size_t len) |
| { |
| par_master->chip_writen(flash, buf, addr, len); |
| } |
| |
| uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr) |
| { |
| return par_master->chip_readb(flash, addr); |
| } |
| |
| uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr) |
| { |
| return par_master->chip_readw(flash, addr); |
| } |
| |
| uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr) |
| { |
| return par_master->chip_readl(flash, addr); |
| } |
| |
| void chip_readn(const struct flashctx *flash, uint8_t *buf, chipaddr addr, size_t len) |
| { |
| par_master->chip_readn(flash, buf, addr, len); |
| } |
| |
| void programmer_delay(int usecs) |
| { |
| programmer_table[programmer].delay(usecs); |
| } |
| |
| void map_flash_registers(struct flashctx *flash) |
| { |
| size_t size = flash->chip->total_size * 1024; |
| /* Flash registers live 4 MByte below the flash. */ |
| /* FIXME: This is incorrect for nonstandard flashbase. */ |
| flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size); |
| } |
| |
| int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start, int unsigned len) |
| { |
| chip_readn(flash, buf, flash->virtual_memory + start, len); |
| |
| return 0; |
| } |
| |
| /* This is a somewhat hacked function similar in some ways to strtok(). It will |
| * look for needle with a subsequent '=' in haystack, return a copy of needle. |
| */ |
| char *extract_param(char **haystack, const char *needle, const char *delim) |
| { |
| char *param_pos, *opt_pos; |
| char *opt = NULL; |
| int optlen; |
| int needlelen; |
| |
| needlelen = strlen(needle); |
| if (!needlelen) { |
| msg_gerr("%s: empty needle! Please report a bug at " |
| "flashrom@flashrom.org\n", __func__); |
| return NULL; |
| } |
| /* No programmer parameters given. */ |
| if (*haystack == NULL) |
| return NULL; |
| param_pos = strstr(*haystack, needle); |
| do { |
| if (!param_pos) |
| return NULL; |
| /* Needle followed by '='? */ |
| if (param_pos[needlelen] == '=') { |
| |
| /* Beginning of the string? */ |
| if (param_pos == *haystack) |
| break; |
| /* After a delimiter? */ |
| if (strchr(delim, *(param_pos - 1))) |
| break; |
| } |
| /* Continue searching. */ |
| param_pos++; |
| param_pos = strstr(param_pos, needle); |
| } while (1); |
| |
| if (param_pos) { |
| /* Get the string after needle and '='. */ |
| opt_pos = param_pos + needlelen + 1; |
| optlen = strcspn(opt_pos, delim); |
| /* Return an empty string if the parameter was empty. */ |
| opt = malloc(optlen + 1); |
| if (!opt) { |
| msg_gerr("Out of memory!\n"); |
| exit(1); |
| } |
| strncpy(opt, opt_pos, optlen); |
| opt[optlen] = '\0'; |
| } |
| |
| return opt; |
| } |
| |
| char *extract_programmer_param(const char *param_name) |
| { |
| return extract_param(&programmer_param, param_name, ","); |
| } |
| |
| /* Returns the number of well-defined erasers for a chip. */ |
| static unsigned int count_usable_erasers(const struct flashctx *flash) |
| { |
| unsigned int usable_erasefunctions = 0; |
| int k; |
| for (k = 0; k < NUM_ERASEFUNCTIONS; k++) { |
| if (!check_block_eraser(flash, k, 0)) |
| usable_erasefunctions++; |
| } |
| return usable_erasefunctions; |
| } |
| |
| /* start is an offset to the base address of the flash chip */ |
| int check_erased_range(struct flashctx *flash, unsigned int start, unsigned int len) |
| { |
| int ret; |
| uint8_t *cmpbuf = malloc(len); |
| |
| if (!cmpbuf) { |
| msg_gerr("Could not allocate memory!\n"); |
| exit(1); |
| } |
| memset(cmpbuf, flash_erase_value(flash), len); |
| ret = verify_range(flash, cmpbuf, start, len, "ERASE"); |
| free(cmpbuf); |
| return ret; |
| } |
| |
| static int compare_chunk(uint8_t *readbuf, uint8_t *cmpbuf, unsigned int start, |
| unsigned int len, const char *message) |
| { |
| int failcount = 0, i; |
| |
| for (i = 0; i < len; i++) { |
| if (cmpbuf[i] != readbuf[i]) { |
| if (!failcount) { |
| msg_cerr("%s FAILED at 0x%08x! " |
| "Expected=0x%02x, Read=0x%02x,", |
| message, start + i, |
| cmpbuf[i], readbuf[i]); |
| } |
| failcount++; |
| } |
| } |
| |
| return failcount; |
| } |
| |
| /* |
| * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the |
| * flash content at location start |
| * @start offset to the base address of the flash chip |
| * @len length of the verified area |
| * @message string to print in the "FAILED" message |
| * @return 0 for success, -1 for failure |
| */ |
| int verify_range(struct flashctx *flash, uint8_t *cmpbuf, unsigned int start, unsigned int len, |
| const char *message) |
| { |
| uint8_t *readbuf = malloc(len); |
| int ret = 0, failcount = 0; |
| |
| if (!len) |
| goto out_free; |
| |
| if (!flash->chip->read) { |
| msg_cerr("ERROR: flashrom has no read function for this flash chip.\n"); |
| return 1; |
| } |
| if (!readbuf) { |
| msg_gerr("Could not allocate memory!\n"); |
| exit(1); |
| } |
| |
| if (start + len > flash->chip->total_size * 1024) { |
| msg_gerr("Error: %s called with start 0x%x + len 0x%x >" |
| " total_size 0x%x\n", __func__, start, len, |
| flash->chip->total_size * 1024); |
| ret = -1; |
| goto out_free; |
| } |
| if (!message) |
| message = "VERIFY"; |
| msg_gdbg("%#06x..%#06x ", start, start + len -1); |
| if (programmer_table[programmer].paranoid) { |
| unsigned int i, chunksize; |
| |
| /* limit chunksize in order to catch errors early */ |
| for (i = 0, chunksize = 0; i < len; i += chunksize) { |
| int tmp; |
| |
| chunksize = min(flash->chip->page_size, len - i); |
| tmp = flash->chip->read(flash, readbuf + i, start + i, chunksize); |
| if (tmp) { |
| ret = tmp; |
| if (ignore_error(tmp)) |
| continue; |
| else |
| goto out_free; |
| } |
| |
| /* |
| * Check write access permission and do not compare chunks |
| * where flashrom does not have write access to the region. |
| */ |
| if (flash->chip->check_access) { |
| tmp = flash->chip->check_access(flash, start + i, chunksize, 0); |
| if (tmp && ignore_error(tmp)) |
| continue; |
| } |
| |
| failcount = compare_chunk(readbuf + i, cmpbuf + i, start + i, |
| chunksize, message); |
| if (failcount) |
| break; |
| } |
| } else { |
| int tmp; |
| |
| /* read as much as we can to reduce transaction overhead */ |
| tmp = flash->chip->read(flash, readbuf, start, len); |
| if (tmp && !ignore_error(tmp)) { |
| ret = tmp; |
| goto out_free; |
| } |
| |
| failcount = compare_chunk(readbuf, cmpbuf, start, len, message); |
| } |
| |
| if (failcount) { |
| msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n", |
| start, start + len - 1, failcount); |
| ret = -1; |
| } |
| |
| out_free: |
| free(readbuf); |
| return ret; |
| } |
| |
| /* Helper function for need_erase() that focuses on granularities of gran bytes. */ |
| static int need_erase_gran_bytes(const uint8_t *have, const uint8_t *want, unsigned int len, |
| unsigned int gran) |
| { |
| unsigned int i, j, limit; |
| for (j = 0; j < len / gran; j++) { |
| limit = min (gran, len - j * gran); |
| /* Are 'have' and 'want' identical? */ |
| if (!memcmp(have + j * gran, want + j * gran, limit)) |
| continue; |
| /* have needs to be in erased state. */ |
| for (i = 0; i < limit; i++) |
| if (have[j * gran + i] != 0xff) |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* |
| * Check if the buffer @have can be programmed to the content of @want without |
| * erasing. This is only possible if all chunks of size @gran are either kept |
| * as-is or changed from an all-ones state to any other state. |
| * |
| * The following write granularities (enum @gran) are known: |
| * - 1 bit. Each bit can be cleared individually. |
| * - 1 byte. A byte can be written once. Further writes to an already written |
| * byte cause the contents to be either undefined or to stay unchanged. |
| * - 128 bytes. If less than 128 bytes are written, the rest will be |
| * erased. Each write to a 128-byte region will trigger an automatic erase |
| * before anything is written. Very uncommon behaviour and unsupported by |
| * this function. |
| * - 256 bytes. If less than 256 bytes are written, the contents of the |
| * unwritten bytes are undefined. |
| * Warning: This function assumes that @have and @want point to naturally |
| * aligned regions. |
| * |
| * @have buffer with current content |
| * @want buffer with desired content |
| * @len length of the checked area |
| * @gran write granularity (enum, not count) |
| * @return 0 if no erase is needed, 1 otherwise |
| */ |
| static int need_erase(struct flashctx *flash, uint8_t *have, uint8_t *want, |
| unsigned int len, enum write_granularity gran) |
| { |
| int result = 0; |
| unsigned int i; |
| |
| switch (gran) { |
| case write_gran_1bit: |
| for (i = 0; i < len; i++) |
| if ((have[i] & want[i]) != want[i]) { |
| result = 1; |
| break; |
| } |
| break; |
| case write_gran_1byte: |
| for (i = 0; i < len; i++) |
| if ((have[i] != want[i]) && (have[i] != 0xff)) { |
| result = 1; |
| break; |
| } |
| break; |
| case write_gran_128bytes: |
| result = need_erase_gran_bytes(have, want, len, 128); |
| break; |
| case write_gran_256bytes: |
| result = need_erase_gran_bytes(have, want, len, 256); |
| break; |
| case write_gran_264bytes: |
| result = need_erase_gran_bytes(have, want, len, 264); |
| break; |
| case write_gran_512bytes: |
| result = need_erase_gran_bytes(have, want, len, 512); |
| break; |
| case write_gran_528bytes: |
| result = need_erase_gran_bytes(have, want, len, 528); |
| break; |
| case write_gran_1024bytes: |
| result = need_erase_gran_bytes(have, want, len, 1024); |
| break; |
| case write_gran_1056bytes: |
| result = need_erase_gran_bytes(have, want, len, 1056); |
| break; |
| case write_gran_1byte_implicit_erase: |
| /* Do not erase, handle content changes from anything->0xff by writing 0xff. */ |
| result = 0; |
| break; |
| default: |
| msg_cerr("%s: Unsupported granularity! Please report a bug at " |
| "flashrom@flashrom.org\n", __func__); |
| } |
| return result; |
| } |
| |
| /** |
| * Check if the buffer @have needs to be programmed to get the content of @want. |
| * If yes, return 1 and fill in first_start with the start address of the |
| * write operation and first_len with the length of the first to-be-written |
| * chunk. If not, return 0 and leave first_start and first_len undefined. |
| * |
| * Warning: This function assumes that @have and @want point to naturally |
| * aligned regions. |
| * |
| * @have buffer with current content |
| * @want buffer with desired content |
| * @len length of the checked area |
| * @gran write granularity (enum, not count) |
| * @first_start offset of the first byte which needs to be written (passed in |
| * value is increased by the offset of the first needed write |
| * relative to have/want or unchanged if no write is needed) |
| * @return length of the first contiguous area which needs to be written |
| * 0 if no write is needed |
| * |
| * FIXME: This function needs a parameter which tells it about coalescing |
| * in relation to the max write length of the programmer and the max write |
| * length of the chip. |
| */ |
| static unsigned int get_next_write(uint8_t *have, uint8_t *want, unsigned int len, |
| unsigned int *first_start, |
| enum write_granularity gran) |
| { |
| int need_write = 0; |
| unsigned int rel_start = 0, first_len = 0; |
| unsigned int i, limit, stride; |
| |
| switch (gran) { |
| case write_gran_1bit: |
| case write_gran_1byte: |
| case write_gran_1byte_implicit_erase: |
| stride = 1; |
| break; |
| case write_gran_128bytes: |
| stride = 128; |
| break; |
| case write_gran_256bytes: |
| stride = 256; |
| break; |
| case write_gran_264bytes: |
| stride = 264; |
| break; |
| case write_gran_512bytes: |
| stride = 512; |
| break; |
| case write_gran_528bytes: |
| stride = 528; |
| break; |
| case write_gran_1024bytes: |
| stride = 1024; |
| break; |
| case write_gran_1056bytes: |
| stride = 1056; |
| break; |
| default: |
| msg_cerr("%s: Unsupported granularity! Please report a bug at " |
| "flashrom@flashrom.org\n", __func__); |
| /* Claim that no write was needed. A write with unknown |
| * granularity is too dangerous to try. |
| */ |
| return 0; |
| } |
| for (i = 0; i < len / stride; i++) { |
| limit = min(stride, len - i * stride); |
| /* Are 'have' and 'want' identical? */ |
| if (memcmp(have + i * stride, want + i * stride, limit)) { |
| if (!need_write) { |
| /* First location where have and want differ. */ |
| need_write = 1; |
| rel_start = i * stride; |
| } |
| } else { |
| if (need_write) { |
| /* First location where have and want |
| * do not differ anymore. |
| */ |
| break; |
| } |
| } |
| } |
| if (need_write) |
| first_len = min(i * stride - rel_start, len); |
| *first_start += rel_start; |
| return first_len; |
| } |
| |
| /* This function generates various test patterns useful for testing controller |
| * and chip communication as well as chip behaviour. |
| * |
| * If a byte can be written multiple times, each time keeping 0-bits at 0 |
| * and changing 1-bits to 0 if the new value for that bit is 0, the effect |
| * is essentially an AND operation. That's also the reason why this function |
| * provides the result of AND between various patterns. |
| * |
| * Below is a list of patterns (and their block length). |
| * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes) |
| * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes) |
| * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes) |
| * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes) |
| * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes) |
| * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes) |
| * Pattern 6 is 00 (1 Byte) |
| * Pattern 7 is ff (1 Byte) |
| * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256 |
| * byte block. |
| * |
| * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B) |
| * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B) |
| * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter) |
| * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards) |
| * Pattern 12 is 00 (1 Byte) |
| * Pattern 13 is ff (1 Byte) |
| * Patterns 8-13 have no block number. |
| * |
| * Patterns 0-3 are created to detect and efficiently diagnose communication |
| * slips like missed bits or bytes and their repetitive nature gives good visual |
| * cues to the person inspecting the results. In addition, the following holds: |
| * AND Pattern 0/1 == Pattern 4 |
| * AND Pattern 2/3 == Pattern 5 |
| * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6 |
| * A weakness of pattern 0-5 is the inability to detect swaps/copies between |
| * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc. |
| * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes. |
| * 0x5 and 0xa were picked because they are 0101 and 1010 binary. |
| * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes. |
| * Besides that, they provide for bit testing of the last two bytes of every |
| * 256 byte block which contains the block number for patterns 0-6. |
| * Patterns 10-11 are special purpose for detecting subblock aliasing with |
| * block sizes >256 bytes (some Dataflash chips etc.) |
| * AND Pattern 8/9 == Pattern 12 |
| * AND Pattern 10/11 == Pattern 12 |
| * Pattern 13 is the completely erased state. |
| * None of the patterns can detect aliasing at boundaries which are a multiple |
| * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI). |
| */ |
| int generate_testpattern(uint8_t *buf, uint32_t size, int variant) |
| { |
| int i; |
| |
| if (!buf) { |
| msg_gerr("Invalid buffer!\n"); |
| return 1; |
| } |
| |
| switch (variant) { |
| case 0: |
| for (i = 0; i < size; i++) |
| buf[i] = (i & 0xf) << 4 | 0x5; |
| break; |
| case 1: |
| for (i = 0; i < size; i++) |
| buf[i] = (i & 0xf) << 4 | 0xa; |
| break; |
| case 2: |
| for (i = 0; i < size; i++) |
| buf[i] = 0x50 | (i & 0xf); |
| break; |
| case 3: |
| for (i = 0; i < size; i++) |
| buf[i] = 0xa0 | (i & 0xf); |
| break; |
| case 4: |
| for (i = 0; i < size; i++) |
| buf[i] = (i & 0xf) << 4; |
| break; |
| case 5: |
| for (i = 0; i < size; i++) |
| buf[i] = i & 0xf; |
| break; |
| case 6: |
| memset(buf, 0x00, size); |
| break; |
| case 7: |
| memset(buf, 0xff, size); |
| break; |
| case 8: |
| for (i = 0; i < size; i++) |
| buf[i] = i & 0xff; |
| break; |
| case 9: |
| for (i = 0; i < size; i++) |
| buf[i] = ~(i & 0xff); |
| break; |
| case 10: |
| for (i = 0; i < size % 2; i++) { |
| buf[i * 2] = (i >> 8) & 0xff; |
| buf[i * 2 + 1] = i & 0xff; |
| } |
| if (size & 0x1) |
| buf[i * 2] = (i >> 8) & 0xff; |
| break; |
| case 11: |
| for (i = 0; i < size % 2; i++) { |
| buf[i * 2] = ~((i >> 8) & 0xff); |
| buf[i * 2 + 1] = ~(i & 0xff); |
| } |
| if (size & 0x1) |
| buf[i * 2] = ~((i >> 8) & 0xff); |
| break; |
| case 12: |
| memset(buf, 0x00, size); |
| break; |
| case 13: |
| memset(buf, 0xff, size); |
| break; |
| } |
| |
| if ((variant >= 0) && (variant <= 7)) { |
| /* Write block number in the last two bytes of each 256-byte |
| * block, big endian for easier reading of the hexdump. |
| * Note that this wraps around for chips larger than 2^24 bytes |
| * (16 MB). |
| */ |
| for (i = 0; i < size / 256; i++) { |
| buf[i * 256 + 254] = (i >> 8) & 0xff; |
| buf[i * 256 + 255] = i & 0xff; |
| } |
| } |
| |
| return 0; |
| } |
| |
| int check_max_decode(enum chipbustype buses, uint32_t size) |
| { |
| int limitexceeded = 0; |
| |
| if ((buses & BUS_PARALLEL) && (max_rom_decode.parallel < size)) { |
| limitexceeded++; |
| msg_pdbg("Chip size %u kB is bigger than supported " |
| "size %u kB of chipset/board/programmer " |
| "for %s interface, " |
| "probe/read/erase/write may fail. ", size / 1024, |
| max_rom_decode.parallel / 1024, "Parallel"); |
| } |
| if ((buses & BUS_LPC) && (max_rom_decode.lpc < size)) { |
| limitexceeded++; |
| msg_pdbg("Chip size %u kB is bigger than supported " |
| "size %u kB of chipset/board/programmer " |
| "for %s interface, " |
| "probe/read/erase/write may fail. ", size / 1024, |
| max_rom_decode.lpc / 1024, "LPC"); |
| } |
| if ((buses & BUS_FWH) && (max_rom_decode.fwh < size)) { |
| limitexceeded++; |
| msg_pdbg("Chip size %u kB is bigger than supported " |
| "size %u kB of chipset/board/programmer " |
| "for %s interface, " |
| "probe/read/erase/write may fail. ", size / 1024, |
| max_rom_decode.fwh / 1024, "FWH"); |
| } |
| if ((buses & BUS_SPI) && (max_rom_decode.spi < size)) { |
| limitexceeded++; |
| msg_pdbg("Chip size %u kB is bigger than supported " |
| "size %u kB of chipset/board/programmer " |
| "for %s interface, " |
| "probe/read/erase/write may fail. ", size / 1024, |
| max_rom_decode.spi / 1024, "SPI"); |
| } |
| if (!limitexceeded) |
| return 0; |
| /* Sometimes chip and programmer have more than one bus in common, |
| * and the limit is not exceeded on all buses. Tell the user. |
| */ |
| if (bitcount(buses) > limitexceeded) |
| /* FIXME: This message is designed towards CLI users. */ |
| msg_pdbg("There is at least one common chip/programmer " |
| "interface which can support a chip of this size. " |
| "You can try --force at your own risk.\n"); |
| return 1; |
| } |
| |
| /* |
| * Return a string corresponding to the bustype parameter. |
| * Memory is obtained with malloc() and must be freed with free() by the caller. |
| */ |
| char *flashbuses_to_text(enum chipbustype bustype) |
| { |
| char *ret = calloc(1, 1); |
| /* |
| * FIXME: Once all chipsets and flash chips have been updated, NONSPI |
| * will cease to exist and should be eliminated here as well. |
| */ |
| if (bustype == BUS_NONSPI) { |
| ret = strcat_realloc(ret, "Non-SPI, "); |
| } else { |
| if (bustype & BUS_PARALLEL) |
| ret = strcat_realloc(ret, "Parallel, "); |
| if (bustype & BUS_LPC) |
| ret = strcat_realloc(ret, "LPC, "); |
| if (bustype & BUS_FWH) |
| ret = strcat_realloc(ret, "FWH, "); |
| if (bustype & BUS_SPI) |
| ret = strcat_realloc(ret, "SPI, "); |
| if (bustype & BUS_PROG) |
| ret = strcat_realloc(ret, "Programmer-specific, "); |
| if (bustype == BUS_NONE) |
| ret = strcat_realloc(ret, "None, "); |
| } |
| /* Kill last comma. */ |
| ret[strlen(ret) - 2] = '\0'; |
| ret = realloc(ret, strlen(ret) + 1); |
| return ret; |
| } |
| |
| int probe_flash(struct registered_master *mst, int startchip, |
| struct flashctx *flash, int force) |
| { |
| const struct flashchip *chip, *flash_list; |
| unsigned long base = 0; |
| char location[64]; |
| uint32_t size; |
| enum chipbustype buses_common; |
| char *tmp; |
| |
| /* Based on the host controller interface that a platform |
| * needs to use (hwseq or swseq), |
| * set the flashchips list here. |
| */ |
| switch (ich_generation) { |
| case CHIPSET_100_SERIES_SUNRISE_POINT: |
| case CHIPSET_APL: |
| flash_list = flashchips_hwseq; |
| break; |
| default: |
| flash_list = flashchips; |
| break; |
| } |
| |
| for (chip = flash_list + startchip; chip && chip->name; chip++) { |
| if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0) |
| continue; |
| buses_common = buses_supported & chip->bustype; |
| if (!buses_common) { |
| msg_gspew("Probing for %s %s, %d kB: skipped. ", |
| chip->vendor, chip->name, chip->total_size); |
| tmp = flashbuses_to_text(buses_supported); |
| msg_gspew("Host bus type %s ", tmp); |
| free(tmp); |
| tmp = flashbuses_to_text(chip->bustype); |
| msg_gspew("and chip bus type %s are incompatible.", |
| tmp); |
| free(tmp); |
| msg_gspew("\n"); |
| continue; |
| } |
| /* Only probe for SPI25 chips by default. */ |
| if (chip->bustype == BUS_SPI && !chip_to_probe && chip->spi_cmd_set != SPI25) |
| continue; |
| msg_gdbg("Probing for %s %s, %d kB: ", |
| chip->vendor, chip->name, chip->total_size); |
| if (!chip->probe && !force) { |
| msg_gdbg("failed! flashrom has no probe function for " |
| "this flash chip.\n"); |
| continue; |
| } |
| |
| size = chip->total_size * 1024; |
| check_max_decode(buses_common, size); |
| |
| /* Start filling in the dynamic data. */ |
| flash->chip = calloc(1, sizeof(struct flashchip)); |
| if (!flash->chip) { |
| msg_gerr("Out of memory!\n"); |
| exit(1); |
| } |
| memcpy(flash->chip, chip, sizeof(struct flashchip)); |
| flash->mst = mst; |
| |
| base = flashbase ? flashbase : (0xffffffff - size + 1); |
| flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size); |
| |
| if (force) |
| break; |
| |
| if (flash->chip->probe(flash) != 1) |
| goto notfound; |
| |
| /* If this is the first chip found, accept it. |
| * If this is not the first chip found, accept it only if it is |
| * a non-generic match. |
| * We could either make chipcount global or provide it as |
| * parameter, or we assume that startchip==0 means this call to |
| * probe_flash() is the first one and thus no chip has been |
| * found before. |
| */ |
| if (startchip == 0 || flash->chip->model_id != GENERIC_DEVICE_ID) |
| break; |
| |
| notfound: |
| programmer_unmap_flash_region((void *)flash->virtual_memory, size); |
| free(flash->chip); |
| flash->chip = NULL; |
| } |
| |
| if (!chip || !chip->name) |
| return -1; |
| |
| #if CONFIG_INTERNAL == 1 |
| if (programmer_table[programmer].map_flash_region == physmap) |
| snprintf(location, sizeof(location), "at physical address 0x%lx", base); |
| else |
| #endif |
| snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name); |
| |
| tmp = flashbuses_to_text(chip->bustype); |
| msg_cdbg("%s %s flash chip \"%s\" (%d kB, %s) %s.\n", |
| force ? "Assuming" : "Found", flash->chip->vendor, |
| flash->chip->name, flash->chip->total_size, tmp, |
| location); |
| free(tmp); |
| |
| /* Flash registers will not be mapped if the chip was forced. Lock info |
| * may be stored in registers, so avoid lock info printing. |
| */ |
| if (!force) |
| if (flash->chip->printlock) |
| flash->chip->printlock(flash); |
| |
| /* Return position of matching chip. */ |
| return chip - flash_list; |
| } |
| |
| static int verify_flash(struct flashctx *flash, |
| struct action_descriptor *descriptor, |
| int verify_it) |
| { |
| int ret; |
| unsigned int total_size = flash->chip->total_size * 1024; |
| uint8_t *buf = descriptor->newcontents; |
| |
| msg_cinfo("Verifying flash... "); |
| |
| if (verify_it == VERIFY_PARTIAL) { |
| struct processing_unit *pu = descriptor->processing_units; |
| |
| /* Verify only areas which were written. */ |
| while (pu->num_blocks) { |
| ret = verify_range(flash, buf + pu->offset, pu->offset, |
| pu->block_size * pu->num_blocks, |
| NULL); |
| if (ret) |
| break; |
| pu++; |
| } |
| } else { |
| ret = verify_range(flash, buf, 0, total_size, NULL); |
| } |
| |
| if (ret == ACCESS_DENIED) { |
| msg_gdbg("Could not fully verify due to access error, "); |
| if (access_denied_action == error_ignore) { |
| msg_gdbg("ignoring\n"); |
| ret = 0; |
| } else { |
| msg_gdbg("aborting\n"); |
| } |
| } |
| |
| if (!ret) |
| msg_cinfo("VERIFIED. \n"); |
| |
| return ret; |
| } |
| |
| int read_buf_from_file(unsigned char *buf, unsigned long size, |
| const char *filename) |
| { |
| unsigned long numbytes; |
| FILE *image; |
| struct stat image_stat; |
| |
| if (!strncmp(filename, "-", sizeof("-"))) |
| image = fdopen(STDIN_FILENO, "rb"); |
| else |
| image = fopen(filename, "rb"); |
| if (image == NULL) { |
| perror(filename); |
| return 1; |
| } |
| if (fstat(fileno(image), &image_stat) != 0) { |
| perror(filename); |
| fclose(image); |
| return 1; |
| } |
| if ((image_stat.st_size != size) && |
| (strncmp(filename, "-", sizeof("-")))) { |
| msg_gerr("Error: Image size doesn't match: stat %jd bytes, " |
| "wanted %ld!\n", (intmax_t)image_stat.st_size, size); |
| fclose(image); |
| return 1; |
| } |
| numbytes = fread(buf, 1, size, image); |
| if (fclose(image)) { |
| perror(filename); |
| return 1; |
| } |
| if (numbytes != size) { |
| msg_gerr("Error: Failed to read complete file. Got %ld bytes, " |
| "wanted %ld!\n", numbytes, size); |
| return 1; |
| } |
| return 0; |
| } |
| |
| int write_buf_to_file(unsigned char *buf, unsigned long size, |
| const char *filename) |
| { |
| unsigned long numbytes; |
| FILE *image; |
| |
| if (!filename) { |
| msg_gerr("No filename specified.\n"); |
| return 1; |
| } |
| if (!strncmp(filename, "-", sizeof("-"))) |
| image = fdopen(STDOUT_FILENO, "wb"); |
| else |
| image = fopen(filename, "wb"); |
| if (image == NULL) { |
| perror(filename); |
| return 1; |
| } |
| |
| numbytes = fwrite(buf, 1, size, image); |
| fclose(image); |
| if (numbytes != size) { |
| msg_gerr("File %s could not be written completely.\n", |
| filename); |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* |
| * read_flash - wrapper for flash->read() with additional high-level policy |
| * |
| * @flash flash chip |
| * @buf buffer to store data in |
| * @start start address |
| * @len number of bytes to read |
| * |
| * This wrapper simplifies most cases when the flash chip needs to be read |
| * since policy decisions such as non-fatal error handling is centralized. |
| */ |
| int read_flash(struct flashctx *flash, uint8_t *buf, |
| unsigned int start, unsigned int len) |
| { |
| int ret; |
| |
| if (!flash || !flash->chip->read) |
| return -1; |
| |
| msg_cdbg("%#06x-%#06x:R ", start, start + len - 1); |
| |
| ret = flash->chip->read(flash, buf, start, len); |
| if (ret) { |
| if (ignore_error(ret)) { |
| msg_gdbg("ignoring error when reading 0x%x-0x%x\n", |
| start, start + len - 1); |
| ret = 0; |
| } else { |
| msg_gdbg("failed to read 0x%x-0x%x\n", |
| start, start + len - 1); |
| } |
| } |
| |
| return ret; |
| } |
| |
| /* |
| * write_flash - wrapper for flash->write() with additional high-level policy |
| * |
| * @flash flash chip |
| * @buf buffer to write to flash |
| * @start start address in flash |
| * @len number of bytes to write |
| * |
| * TODO: Look up regions that are write-protected and avoid attempt to write |
| * to them at all. |
| */ |
| int write_flash(struct flashctx *flash, uint8_t *buf, |
| unsigned int start, unsigned int len) |
| { |
| if (!flash || !flash->chip->write) |
| return -1; |
| |
| return flash->chip->write(flash, buf, start, len); |
| } |
| |
| int read_flash_to_file(struct flashctx *flash, const char *filename) |
| { |
| unsigned long size = flash->chip->total_size * 1024; |
| unsigned char *buf = calloc(size, sizeof(char)); |
| int ret = 0; |
| |
| msg_cinfo("Reading flash... "); |
| if (!buf) { |
| msg_gerr("Memory allocation failed!\n"); |
| msg_cinfo("FAILED.\n"); |
| return 1; |
| } |
| |
| /* To support partial read, fill buffer to all 0xFF at beginning to make |
| * debug easier. */ |
| memset(buf, flash_erase_value(flash), size); |
| |
| if (!flash->chip->read) { |
| msg_cerr("No read function available for this flash chip.\n"); |
| ret = 1; |
| goto out_free; |
| } |
| |
| /* First try to handle partial read case, rather than read the whole |
| * flash, which is slow. */ |
| ret = handle_partial_read(flash, buf, read_flash, 1); |
| if (ret < 0) { |
| msg_cerr("Partial read operation failed!\n"); |
| ret = 1; |
| goto out_free; |
| } else if (ret > 0) { |
| int num_regions = get_num_include_args(); |
| |
| if (ret != num_regions) { |
| msg_cerr("Requested %d regions, but only read %d\n", |
| num_regions, ret); |
| ret = 1; |
| goto out_free; |
| } |
| |
| ret = 0; |
| } else { |
| if (read_flash(flash, buf, 0, size)) { |
| msg_cerr("Read operation failed!\n"); |
| ret = 1; |
| goto out_free; |
| } |
| } |
| |
| if (filename) |
| ret = write_buf_to_file(buf, size, filename); |
| |
| out_free: |
| free(buf); |
| if (ret) |
| msg_cerr("FAILED."); |
| else |
| msg_cdbg("done."); |
| return ret; |
| } |
| |
| /* This function shares a lot of its structure with erase_and_write_flash() and |
| * walk_eraseregions(). |
| * Even if an error is found, the function will keep going and check the rest. |
| */ |
| static int selfcheck_eraseblocks(const struct flashchip *chip) |
| { |
| int i, j, k; |
| int ret = 0; |
| |
| for (k = 0; k < NUM_ERASEFUNCTIONS; k++) { |
| unsigned int done = 0; |
| struct block_eraser eraser = chip->block_erasers[k]; |
| |
| for (i = 0; i < NUM_ERASEREGIONS; i++) { |
| /* Blocks with zero size are bugs in flashchips.c. */ |
| if (eraser.eraseblocks[i].count && |
| !eraser.eraseblocks[i].size) { |
| msg_gerr("ERROR: Flash chip %s erase function " |
| "%i region %i has size 0. Please report" |
| " a bug at flashrom@flashrom.org\n", |
| chip->name, k, i); |
| ret = 1; |
| } |
| /* Blocks with zero count are bugs in flashchips.c. */ |
| if (!eraser.eraseblocks[i].count && |
| eraser.eraseblocks[i].size) { |
| msg_gerr("ERROR: Flash chip %s erase function " |
| "%i region %i has count 0. Please report" |
| " a bug at flashrom@flashrom.org\n", |
| chip->name, k, i); |
| ret = 1; |
| } |
| done += eraser.eraseblocks[i].count * |
| eraser.eraseblocks[i].size; |
| } |
| /* Empty eraseblock definition with erase function. */ |
| if (!done && eraser.block_erase) |
| msg_gspew("Strange: Empty eraseblock definition with " |
| "non-empty erase function. Not an error.\n"); |
| if (!done) |
| continue; |
| if (done != chip->total_size * 1024) { |
| msg_gerr("ERROR: Flash chip %s erase function %i " |
| "region walking resulted in 0x%06x bytes total," |
| " expected 0x%06x bytes. Please report a bug at" |
| " flashrom@flashrom.org\n", chip->name, k, |
| done, chip->total_size * 1024); |
| ret = 1; |
| } |
| if (!eraser.block_erase) |
| continue; |
| /* Check if there are identical erase functions for different |
| * layouts. That would imply "magic" erase functions. The |
| * easiest way to check this is with function pointers. |
| */ |
| for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) { |
| if (eraser.block_erase == |
| chip->block_erasers[j].block_erase) { |
| msg_gerr("ERROR: Flash chip %s erase function " |
| "%i and %i are identical. Please report" |
| " a bug at flashrom@flashrom.org\n", |
| chip->name, k, j); |
| ret = 1; |
| } |
| } |
| } |
| return ret; |
| } |
| |
| static int erase_and_write_block_helper(struct flashctx *flash, |
| unsigned int start, unsigned int len, |
| uint8_t *curcontents, |
| uint8_t *newcontents, |
| int (*erasefn) (struct flashctx *flash, |
| unsigned int addr, |
| unsigned int len)) |
| { |
| unsigned int starthere = 0, lenhere = 0; |
| int ret = 0, skip = 1, writecount = 0; |
| int block_was_erased = 0; |
| enum write_granularity gran = flash->chip->gran; |
| |
| /* |
| * curcontents and newcontents are opaque to walk_eraseregions, and |
| * need to be adjusted here to keep the impression of proper |
| * abstraction |
| */ |
| |
| curcontents += start; |
| |
| newcontents += start; |
| |
| msg_cdbg(":"); |
| if (need_erase(flash, curcontents, newcontents, len, gran)) { |
| content_has_changed |= 1; |
| msg_cdbg(" E"); |
| ret = erasefn(flash, start, len); |
| if (ret) { |
| if (ret == ACCESS_DENIED) |
| msg_cdbg(" DENIED"); |
| else |
| msg_cerr(" ERASE_FAILED\n"); |
| return ret; |
| } |
| |
| if (programmer_table[programmer].paranoid) { |
| if (check_erased_range(flash, start, len)) { |
| msg_cerr(" ERASE_FAILED\n"); |
| return -1; |
| } |
| } |
| |
| /* Erase was successful. Adjust curcontents. */ |
| memset(curcontents, flash_erase_value(flash), len); |
| skip = 0; |
| block_was_erased = 1; |
| } |
| /* get_next_write() sets starthere to a new value after the call. */ |
| while ((lenhere = get_next_write(curcontents + starthere, |
| newcontents + starthere, |
| len - starthere, &starthere, gran))) { |
| content_has_changed |= 1; |
| if (!writecount++) |
| msg_cdbg(" W"); |
| /* Needs the partial write function signature. */ |
| ret = write_flash(flash, newcontents + starthere, |
| start + starthere, lenhere); |
| if (ret) { |
| if (ret == ACCESS_DENIED) |
| msg_cdbg(" DENIED"); |
| return ret; |
| } |
| |
| /* |
| * If the block needed to be erased and was erased successfully |
| * then we can assume that we didn't run into any write- |
| * protected areas. Otherwise, we need to verify each page to |
| * ensure it was successfully written and abort if we encounter |
| * any errors. |
| */ |
| if (programmer_table[programmer].paranoid && !block_was_erased) { |
| if (verify_range(flash, newcontents + starthere, |
| start + starthere, lenhere, "WRITE")) |
| return -1; |
| } |
| |
| starthere += lenhere; |
| skip = 0; |
| } |
| if (skip) |
| msg_cdbg(" SKIP"); |
| return ret; |
| } |
| |
| /* |
| * Function to process processing units accumulated in the action descriptor. |
| * |
| * @flash pointer to the flash context to operate on |
| * @do_something helper function which can erase and program a section of the |
| * flash chip. It receives the flash context, offset and length |
| * of the area to erase/program, before and after contents (to |
| * decide what exactly needs to be erased and or programmed) |
| * and a pointer to the erase function which can operate on the |
| * proper granularity. |
| * @descriptor action descriptor including pointers to before and after |
| * contents and an array of processing actions to take. |
| * |
| * Returns zero on success or an error code. |
| */ |
| static int walk_eraseregions(struct flashctx *flash, |
| int (*do_something) (struct flashctx *flash, |
| unsigned int addr, |
| unsigned int len, |
| uint8_t *param1, |
| uint8_t *param2, |
| int (*erasefn) ( |
| struct flashctx *flash, |
| unsigned int addr, |
| unsigned int len)), |
| struct action_descriptor *descriptor) |
| { |
| struct processing_unit *pu; |
| int rc = 0; |
| static int print_comma; |
| |
| for (pu = descriptor->processing_units; pu->num_blocks; pu++) { |
| unsigned base = pu->offset; |
| unsigned top = pu->offset + pu->block_size * pu->num_blocks; |
| |
| while (base < top) { |
| |
| if (print_comma) |
| msg_cdbg(", "); |
| else |
| print_comma = 1; |
| |
| msg_cdbg("0x%06x-0x%06zx", base, base + pu->block_size - 1); |
| |
| rc = do_something(flash, base, |
| pu->block_size, |
| descriptor->oldcontents, |
| descriptor->newcontents, |
| flash->chip->block_erasers[pu->block_eraser_index].block_erase); |
| |
| if (rc) { |
| if (ignore_error(rc)) |
| rc = 0; |
| else |
| return rc; |
| } |
| base += pu->block_size; |
| } |
| } |
| msg_cdbg("\n"); |
| return rc; |
| } |
| |
| static int check_block_eraser(const struct flashctx *flash, int k, int log) |
| { |
| struct block_eraser eraser = flash->chip->block_erasers[k]; |
| |
| if (!eraser.block_erase && !eraser.eraseblocks[0].count) { |
| if (log) |
| msg_cdbg("not defined. "); |
| return 1; |
| } |
| if (!eraser.block_erase && eraser.eraseblocks[0].count) { |
| if (log) |
| msg_cdbg("eraseblock layout is known, but matching " |
| "block erase function is not implemented. "); |
| return 1; |
| } |
| if (eraser.block_erase && !eraser.eraseblocks[0].count) { |
| if (log) |
| msg_cdbg("block erase function found, but " |
| "eraseblock layout is not defined. "); |
| return 1; |
| } |
| return 0; |
| } |
| |
| int erase_and_write_flash(struct flashctx *flash, |
| struct action_descriptor *descriptor) |
| { |
| int ret = 1; |
| |
| msg_cinfo("Erasing and writing flash chip... "); |
| |
| ret = walk_eraseregions(flash, &erase_and_write_block_helper, descriptor); |
| |
| if (ret) { |
| msg_cerr("FAILED!\n"); |
| } else { |
| msg_cdbg("SUCCESS.\n"); |
| } |
| return ret; |
| } |
| |
| void nonfatal_help_message(void) |
| { |
| msg_gerr("Writing to the flash chip apparently didn't do anything.\n" |
| "This means we have to add special support for your board, " |
| "programmer or flash chip.\n" |
| "Please report this on IRC at irc.freenode.net (channel " |
| "#flashrom) or\n" |
| "mail flashrom@flashrom.org!\n" |
| "-------------------------------------------------------------" |
| "------------------\n" |
| "You may now reboot or simply leave the machine running.\n"); |
| } |
| |
| void emergency_help_message(void) |
| { |
| msg_gerr("Your flash chip is in an unknown state.\n" |
| "Get help on IRC at irc.freenode.net (channel #flashrom) or\n" |
| "mail flashrom@flashrom.org with FAILED: your board name in " |
| "the subject line!\n" |
| "-------------------------------------------------------------" |
| "------------------\n" |
| "DO NOT REBOOT OR POWEROFF!\n"); |
| } |
| |
| /* The way to go if you want a delimited list of programmers */ |
| void list_programmers(const char *delim) |
| { |
| enum programmer p; |
| for (p = 0; p < PROGRAMMER_INVALID; p++) { |
| msg_ginfo("%s", programmer_table[p].name); |
| if (p < PROGRAMMER_INVALID - 1) |
| msg_ginfo("%s", delim); |
| } |
| msg_ginfo("\n"); |
| } |
| |
| void list_programmers_linebreak(int startcol, int cols, int paren) |
| { |
| const char *pname; |
| int pnamelen; |
| int remaining = 0, firstline = 1; |
| enum programmer p; |
| int i; |
| |
| for (p = 0; p < PROGRAMMER_INVALID; p++) { |
| pname = programmer_table[p].name; |
| pnamelen = strlen(pname); |
| if (remaining - pnamelen - 2 < 0) { |
| if (firstline) |
| firstline = 0; |
| else |
| msg_ginfo("\n"); |
| for (i = 0; i < startcol; i++) |
| msg_ginfo(" "); |
| remaining = cols - startcol; |
| } else { |
| msg_ginfo(" "); |
| remaining--; |
| } |
| if (paren && (p == 0)) { |
| msg_ginfo("("); |
| remaining--; |
| } |
| msg_ginfo("%s", pname); |
| remaining -= pnamelen; |
| if (p < PROGRAMMER_INVALID - 1) { |
| msg_ginfo(","); |
| remaining--; |
| } else { |
| if (paren) |
| msg_ginfo(")"); |
| msg_ginfo("\n"); |
| } |
| } |
| } |
| |
| void print_sysinfo(void) |
| { |
| /* send to stderr for chromium os */ |
| #if HAVE_UTSNAME == 1 |
| struct utsname osinfo; |
| uname(&osinfo); |
| |
| msg_gerr(" on %s %s (%s)", osinfo.sysname, osinfo.release, |
| osinfo.machine); |
| #else |
| msg_gerr(" on unknown machine"); |
| #endif |
| } |
| |
| void print_buildinfo(void) |
| { |
| msg_gdbg("flashrom was built with"); |
| #if NEED_PCI == 1 |
| #ifdef PCILIB_VERSION |
| msg_gdbg(" libpci %s,", PCILIB_VERSION); |
| #else |
| msg_gdbg(" unknown PCI library,"); |
| #endif |
| #endif |
| #ifdef __clang__ |
| msg_gdbg(" LLVM Clang"); |
| #ifdef __clang_version__ |
| msg_gdbg(" %s,", __clang_version__); |
| #else |
| msg_gdbg(" unknown version (before r102686),"); |
| #endif |
| #elif defined(__GNUC__) |
| msg_gdbg(" GCC"); |
| #ifdef __VERSION__ |
| msg_gdbg(" %s,", __VERSION__); |
| #else |
| msg_gdbg(" unknown version,"); |
| #endif |
| #else |
| msg_gdbg(" unknown compiler,"); |
| #endif |
| #if defined (__FLASHROM_LITTLE_ENDIAN__) |
| msg_gdbg(" little endian"); |
| #else |
| msg_gdbg(" big endian"); |
| #endif |
| msg_gdbg("\n"); |
| } |
| |
| void print_version(void) |
| { |
| /* send to stderr for chromium os */ |
| msg_gerr("flashrom v%s", flashrom_version); |
| print_sysinfo(); |
| msg_gerr("\n"); |
| } |
| |
| void print_banner(void) |
| { |
| msg_ginfo("flashrom is free software, get the source code at " |
| "http://www.flashrom.org\n"); |
| msg_ginfo("\n"); |
| } |
| |
| int selfcheck(void) |
| { |
| int ret = 0; |
| const struct flashchip *flash; |
| |
| /* Safety check. Instead of aborting after the first error, check |
| * if more errors exist. |
| */ |
| if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) { |
| msg_gerr("Programmer table miscompilation!\n"); |
| ret = 1; |
| } |
| /* It would be favorable if we could also check for correct termination |
| * of the following arrays, but we don't know their sizes in here... |
| * For 'flashchips' we check the first element to be non-null. In the |
| * other cases there exist use cases where the first element can be |
| * null. */ |
| if (flashchips[0].vendor == NULL) { |
| msg_gerr("Flashchips table miscompilation!\n"); |
| ret = 1; |
| } |
| for (flash = flashchips; flash && flash->name; flash++) |
| if (selfcheck_eraseblocks(flash)) |
| ret = 1; |
| |
| return ret; |
| } |
| |
| /* FIXME: This function signature needs to be improved once doit() has a better |
| * function signature. |
| */ |
| int chip_safety_check(const struct flashctx *flash, int force, int read_it, int write_it, int erase_it, int verify_it) |
| { |
| const struct flashchip *chip = flash->chip; |
| |
| if (!programmer_may_write && (write_it || erase_it)) { |
| msg_perr("Write/erase is not working yet on your programmer in " |
| "its current configuration.\n"); |
| /* --force is the wrong approach, but it's the best we can do |
| * until the generic programmer parameter parser is merged. |
| */ |
| if (!force) |
| return 1; |
| msg_cerr("Continuing anyway.\n"); |
| } |
| |
| if (read_it || erase_it || write_it || verify_it) { |
| /* Everything needs read. */ |
| if (chip->tested.read == BAD) { |
| msg_cerr("Read is not working on this chip. "); |
| if (!force) |
| return 1; |
| msg_cerr("Continuing anyway.\n"); |
| } |
| if (!chip->read) { |
| msg_cerr("flashrom has no read function for this " |
| "flash chip.\n"); |
| return 1; |
| } |
| } |
| if (erase_it || write_it) { |
| /* Write needs erase. */ |
| if (chip->tested.erase == NA) { |
| msg_cerr("Erase is not possible on this chip.\n"); |
| return 1; |
| } |
| if (chip->tested.erase == BAD) { |
| msg_cerr("Erase is not working on this chip. "); |
| if (!force) |
| return 1; |
| msg_cerr("Continuing anyway.\n"); |
| } |
| if(count_usable_erasers(flash) == 0) { |
| msg_cerr("flashrom has no erase function for this " |
| "flash chip.\n"); |
| return 1; |
| } |
| } |
| if (write_it) { |
| if (chip->tested.write == NA) { |
| msg_cerr("Write is not possible on this chip.\n"); |
| return 1; |
| } |
| if (chip->tested.write == BAD) { |
| msg_cerr("Write is not working on this chip. "); |
| if (!force) |
| return 1; |
| msg_cerr("Continuing anyway.\n"); |
| } |
| if (!chip->write) { |
| msg_cerr("flashrom has no write function for this " |
| "flash chip.\n"); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| * Function to erase entire flash chip. |
| * |
| * @flashctx pointer to the flash context to use |
| * @oldcontents pointer to the buffer including current chip contents, to |
| * decide which areas do in fact need to be erased |
| * @size the size of the flash chip, in bytes. |
| * |
| * Returns zero on success or an error code. |
| */ |
| static int erase_chip(struct flashctx *flash, void *oldcontents, |
| void *newcontents, size_t size) |
| { |
| /* |
| * To make sure that the chip is fully erased, let's cheat and create |
| * a descriptor where the new contents are all erased. |
| */ |
| struct action_descriptor *fake_descriptor; |
| int ret = 0; |
| |
| fake_descriptor = prepare_action_descriptor(flash, oldcontents, |
| newcontents, 1); |
| /* FIXME: Do we really want the scary warning if erase failed? After |
| * all, after erase the chip is either blank or partially blank or it |
| * has the old contents. A blank chip won't boot, so if the user |
| * wanted erase and reboots afterwards, the user knows very well that |
| * booting won't work. |
| */ |
| if (erase_and_write_flash(flash, fake_descriptor)) { |
| emergency_help_message(); |
| ret = 1; |
| } |
| |
| free(fake_descriptor); |
| |
| return ret; |
| } |
| |
| static int read_dest_content(struct flashctx *flash, int verify_it, |
| uint8_t *dest, unsigned long size) |
| { |
| if (((verify_it == VERIFY_OFF) || (verify_it == VERIFY_PARTIAL)) |
| && get_num_include_args()) { |
| /* |
| * If no full verification is required and not |
| * the entire chip is about to be programmed, |
| * read only the areas which might change. |
| */ |
| if (handle_partial_read(flash, dest, read_flash, 0) < 0) |
| return 1; |
| } else { |
| if (read_flash(flash, dest, 0, size)) |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* This function signature is horrible. We need to design a better interface, |
| * but right now it allows us to split off the CLI code. |
| * Besides that, the function itself is a textbook example of abysmal code flow. |
| */ |
| int doit(struct flashctx *flash, int force, const char *filename, int read_it, |
| int write_it, int erase_it, int verify_it, int extract_it, |
| const char *diff_file, int do_diff) |
| { |
| uint8_t *oldcontents; |
| uint8_t *newcontents; |
| int ret = 0; |
| unsigned long size = flash->chip->total_size * 1024; |
| struct action_descriptor *descriptor = NULL; |
| |
| if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) { |
| msg_cerr("Aborting.\n"); |
| ret = 1; |
| goto out_nofree; |
| } |
| |
| /* Given the existence of read locks, we want to unlock for read, |
| * erase and write. |
| */ |
| if (flash->chip->unlock) |
| flash->chip->unlock(flash); |
| |
| /* Enable/disable 4-byte addressing mode if flash chip supports it */ |
| if ((flash->chip->feature_bits & FEATURE_4BA_SUPPORT) && |
| flash->chip->four_bytes_addr_funcs.set_4ba) { |
| if (flash->chip->four_bytes_addr_funcs.set_4ba(flash)) { |
| msg_cerr("Enabling/disabling 4-byte addressing mode failed!\n"); |
| return 1; |
| } |
| } |
| |
| if (extract_it) { |
| ret = extract_regions(flash); |
| goto out_nofree; |
| } |
| |
| /* mark entries included using -i argument as "included" if they are |
| found in the master rom_entries list */ |
| if (process_include_args() < 0) { |
| ret = 1; |
| goto out_nofree; |
| } |
| |
| if (read_it) { |
| ret = read_flash_to_file(flash, filename); |
| goto out_nofree; |
| } |
| |
| oldcontents = malloc(size); |
| if (!oldcontents) { |
| msg_gerr("Out of memory!\n"); |
| exit(1); |
| } |
| /* Assume worst case: All blocks are not erased. */ |
| memset(oldcontents, flash_unerased_value(flash), size); |
| newcontents = malloc(size); |
| if (!newcontents) { |
| msg_gerr("Out of memory!\n"); |
| exit(1); |
| } |
| /* Assume best case: All blocks are erased. */ |
| memset(newcontents, flash_erase_value(flash), size); |
| /* Side effect of the assumptions above: Default write action is erase |
| * because newcontents looks like a completely erased chip, and |
| * oldcontents being completely unerased means we have to erase |
| * everything before we can write. |
| */ |
| |
| if (write_it || verify_it) { |
| /* |
| * Note: This must be done before any files specified by -i |
| * arguments are processed merged into the newcontents since |
| * -i files take priority. See http://crbug.com/263495. |
| */ |
| if (filename) { |
| if (read_buf_from_file(newcontents, size, filename)) { |
| ret = 1; |
| goto out; |
| } |
| } else { |
| /* Content will be read from -i args, so they must |
| * not overlap. */ |
| if (included_regions_overlap()) { |
| msg_gerr("Error: Included regions must " |
| "not overlap.\n"); |
| ret = 1; |
| goto out; |
| } |
| } |
| |
| #if 0 |
| /* |
| * FIXME: show_id() causes failure if vendor:mainboard do not |
| * match. This may happen if codenames are in flux. |
| * See chrome-os-partner:10414. |
| */ |
| #if CONFIG_INTERNAL == 1 |
| if (programmer == PROGRAMMER_INTERNAL) |
| show_id(newcontents, size, force); |
| #endif |
| #endif |
| } |
| |
| if (do_diff) { |
| /* |
| * Obtain a reference image so that we can check whether |
| * regions need to be erased and to give better diagnostics in |
| * case write fails. If --fast-verify is used then only the |
| * regions which are included using -i will be read. |
| */ |
| if (diff_file) { |
| msg_cdbg("Reading old contents from file... "); |
| if (read_buf_from_file(oldcontents, size, diff_file)) { |
| ret = 1; |
| msg_cdbg("FAILED.\n"); |
| goto out; |
| } |
| } else { |
| msg_cdbg("Reading old contents from flash chip... "); |
| ret = read_dest_content(flash, verify_it, |
| oldcontents, size); |
| if (ret) { |
| msg_cdbg("FAILED.\n"); |
| goto out; |
| } |
| } |
| msg_cdbg("done.\n"); |
| } else if (!erase_it) { |
| msg_pinfo("No diff performed, considering the chip erased.\n"); |
| memset(oldcontents, flash_erase_value(flash), size); |
| } |
| |
| |
| /* |
| * Note: This must be done after reading the file specified for the |
| * -w/-v argument, if any, so that files specified using -i end up |
| * in the "newcontents" buffer before being written. |
| * See http://crbug.com/263495. |
| */ |
| if (handle_romentries(flash, oldcontents, newcontents, erase_it)) { |
| ret = 1; |
| msg_cerr("Error handling ROM entries.\n"); |
| goto out; |
| } |
| |
| if (erase_it) { |
| erase_chip(flash, oldcontents, newcontents, size); |
| goto verify; |
| } |
| |
| descriptor = prepare_action_descriptor(flash, oldcontents, |
| newcontents, do_diff); |
| if (write_it) { |
| // parse the new fmap and disable soft WP if necessary |
| if ((ret = cros_ec_prepare(newcontents, size))) { |
| msg_cerr("CROS_EC prepare failed, ret=%d.\n", ret); |
| goto out; |
| } |
| |
| if (erase_and_write_flash(flash, descriptor)) { |
| msg_cerr("Uh oh. Erase/write failed. Checking if " |
| "anything changed.\n"); |
| if (!read_flash(flash, newcontents, 0, size)) { |
| if (!memcmp(oldcontents, newcontents, size)) { |
| msg_cinfo("Good. It seems nothing was " |
| "changed.\n"); |
| nonfatal_help_message(); |
| ret = 1; |
| goto out; |
| } |
| } |
| emergency_help_message(); |
| ret = 1; |
| goto out; |
| } |
| |
| ret = cros_ec_need_2nd_pass(); |
| if (ret < 0) { |
| // Jump failed |
| msg_cerr("cros_ec_need_2nd_pass() failed. Stop.\n"); |
| emergency_help_message(); |
| ret = 1; |
| goto out; |
| } else if (ret > 0) { |
| // Need 2nd pass. Get the just written content. |
| msg_pdbg("CROS_EC needs 2nd pass.\n"); |
| ret = read_dest_content(flash, verify_it, |
| oldcontents, size); |
| if (ret) { |
| emergency_help_message(); |
| goto out; |
| } |
| |
| /* Get a new descriptor. */ |
| free(descriptor); |
| descriptor = prepare_action_descriptor(flash, |
| oldcontents, |
| newcontents, |
| do_diff); |
| // write 2nd pass |
| if (erase_and_write_flash(flash, descriptor)) { |
| msg_cerr("Uh oh. CROS_EC 2nd pass failed.\n"); |
| emergency_help_message(); |
| ret = 1; |
| goto out; |
| } |
| ret = 0; |
| } |
| |
| if (cros_ec_finish() < 0) { |
| msg_cerr("cros_ec_finish() failed. Stop.\n"); |
| emergency_help_message(); |
| ret = 1; |
| goto out; |
| } |
| } |
| |
| verify: |
| if (verify_it) { |
| if ((write_it || erase_it) && !content_has_changed) { |
| msg_gdbg("Nothing was erased or written, skipping " |
| "verification\n"); |
| } else { |
| /* Work around chips which need some time to calm down. */ |
| if (write_it && verify_it != VERIFY_PARTIAL) |
| programmer_delay(1000*1000); |
| |
| ret = verify_flash(flash, descriptor, verify_it); |
| |
| /* If we tried to write, and verification now fails, we |
| * might have an emergency situation. |
| */ |
| if (ret && write_it) |
| emergency_help_message(); |
| } |
| } |
| |
| out: |
| if (descriptor) |
| free(descriptor); |
| |
| free(oldcontents); |
| free(newcontents); |
| out_nofree: |
| chip_restore(); /* must be done before programmer_shutdown() */ |
| /* |
| * programmer_shutdown() call is moved to cli_classic() in chromium os |
| * tree. This is because some operations, such as write protection, |
| * requires programmer_shutdown() but does not call doit(). |
| */ |
| // programmer_shutdown(); |
| return ret; |
| } |