blob: 2b5c571aaf23961241e8a4cbcad2a155ec962926 [file] [log] [blame]
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001/*
Uwe Hermannd1107642007-08-29 17:52:32 +00002 * This file is part of the flashrom project.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00003 *
Uwe Hermannd22a1d42007-09-09 20:21:05 +00004 * Copyright (C) 2000 Silicon Integrated System Corporation
5 * Copyright (C) 2004 Tyan Corp <yhlu@tyan.com>
Uwe Hermannc7e8a0c2009-05-19 14:14:21 +00006 * Copyright (C) 2005-2008 coresystems GmbH
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00007 * Copyright (C) 2008,2009 Carl-Daniel Hailfinger
Nico Huber7af0e792016-04-29 16:40:15 +02008 * Copyright (C) 2016 secunet Security Networks AG
9 * (Written by Nico Huber <nico.huber@secunet.com> for secunet)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000010 *
Uwe Hermannd1107642007-08-29 17:52:32 +000011 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000015 *
Uwe Hermannd1107642007-08-29 17:52:32 +000016 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000020 */
21
Felix Singerf25447e2022-08-19 02:44:28 +020022#include <stdbool.h>
Carl-Daniel Hailfinger831e8f42010-05-30 22:24:40 +000023#include <stdio.h>
Stefan Reinauer018aca82006-11-21 23:48:51 +000024#include <sys/types.h>
Ronald G. Minnichceec4202003-07-25 04:37:41 +000025#include <string.h>
Stefan Tauner16687702015-12-25 21:59:45 +000026#include <unistd.h>
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +000027#include <stdlib.h>
Stefan Tauner363fd7e2013-04-07 13:08:30 +000028#include <errno.h>
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +000029#include <ctype.h>
Edward O'Callaghan3b64d812022-08-12 13:07:51 +100030
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000031#include "flash.h"
Carl-Daniel Hailfinger08454642009-06-15 14:14:48 +000032#include "flashchips.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000033#include "programmer.h"
Thomas Heijligen74b4aa02021-12-14 17:52:30 +010034#include "hwaccess_physmap.h"
Nico Huberfe34d2a2017-11-10 21:10:20 +010035#include "chipdrivers.h"
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000036
Mathias Krausea60faab2011-01-17 07:50:42 +000037const char flashrom_version[] = FLASHROM_VERSION;
Nico Huberbcb2e5a2012-12-30 01:23:17 +000038const char *chip_to_probe = NULL;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000039
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +020040static const struct programmer_entry *programmer = NULL;
Nico Huber6a2ebeb2022-08-26 11:36:48 +020041static char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +000042
Uwe Hermann48ec1b12010-08-08 17:01:18 +000043/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000044 * Programmers supporting multiple buses can have differing size limits on
45 * each bus. Store the limits for each bus in a common struct.
46 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000047struct decode_sizes max_rom_decode;
48
49/* If nonzero, used as the start address of bottom-aligned flash. */
50unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000051
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +000052/* Is writing allowed with this programmer? */
Felix Singer980d6b82022-08-19 02:48:15 +020053bool programmer_may_write;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +000054
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +000055#define SHUTDOWN_MAXFN 32
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000056static int shutdown_fn_count = 0;
Nico Huber454f6132012-12-10 13:34:10 +000057/** @private */
Richard Hughes93e16252018-12-19 11:54:47 +000058static struct shutdown_func_data {
David Hendricks8bb20212011-06-14 01:35:36 +000059 int (*func) (void *data);
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000060 void *data;
Richard Hughes93e16252018-12-19 11:54:47 +000061} shutdown_fn[SHUTDOWN_MAXFN];
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000062/* Initialize to 0 to make sure nobody registers a shutdown function before
63 * programmer init.
64 */
Felix Singerf25447e2022-08-19 02:44:28 +020065static bool may_register_shutdown = false;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000066
Stefan Taunerc4f44df2013-08-12 22:58:43 +000067/* Did we change something or was every erase/write skipped (if any)? */
68static bool all_skipped = true;
69
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +000070static int check_block_eraser(const struct flashctx *flash, int k, int log);
Stefan Tauner5368dca2011-07-01 00:19:12 +000071
Stefan Tauner2a1ed772014-08-31 00:09:21 +000072int shutdown_free(void *data)
73{
74 free(data);
75 return 0;
76}
77
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000078/* Register a function to be executed on programmer shutdown.
79 * The advantage over atexit() is that you can supply a void pointer which will
80 * be used as parameter to the registered function upon programmer shutdown.
81 * This pointer can point to arbitrary data used by said function, e.g. undo
82 * information for GPIO settings etc. If unneeded, set data=NULL.
83 * Please note that the first (void *data) belongs to the function signature of
84 * the function passed as first parameter.
85 */
David Hendricks8bb20212011-06-14 01:35:36 +000086int register_shutdown(int (*function) (void *data), void *data)
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000087{
88 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +000089 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000090 SHUTDOWN_MAXFN);
91 return 1;
92 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000093 if (!may_register_shutdown) {
94 msg_perr("Tried to register a shutdown function before "
95 "programmer init.\n");
96 return 1;
97 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +000098 shutdown_fn[shutdown_fn_count].func = function;
99 shutdown_fn[shutdown_fn_count].data = data;
100 shutdown_fn_count++;
101
102 return 0;
103}
104
Nikolai Artemiev4ad48642020-11-05 13:54:27 +1100105int register_chip_restore(chip_restore_fn_cb_t func,
106 struct flashctx *flash, uint8_t status)
107{
108 if (flash->chip_restore_fn_count >= MAX_CHIP_RESTORE_FUNCTIONS) {
109 msg_perr("Tried to register more than %i chip restore"
110 " functions.\n", MAX_CHIP_RESTORE_FUNCTIONS);
111 return 1;
112 }
113 flash->chip_restore_fn[flash->chip_restore_fn_count].func = func;
114 flash->chip_restore_fn[flash->chip_restore_fn_count].status = status;
115 flash->chip_restore_fn_count++;
116
117 return 0;
118}
119
120static int deregister_chip_restore(struct flashctx *flash)
121{
122 int rc = 0;
123
124 while (flash->chip_restore_fn_count > 0) {
125 int i = --flash->chip_restore_fn_count;
126 rc |= flash->chip_restore_fn[i].func(
127 flash, flash->chip_restore_fn[i].status);
128 }
129
130 return rc;
131}
132
Thomas Heijligene0e93cf2021-06-01 14:37:12 +0200133int programmer_init(const struct programmer_entry *prog, const char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000134{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000135 int ret;
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +0000136
Thomas Heijligene0e93cf2021-06-01 14:37:12 +0200137 if (prog == NULL) {
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +0000138 msg_perr("Invalid programmer specified!\n");
139 return -1;
140 }
Thomas Heijligene0e93cf2021-06-01 14:37:12 +0200141 programmer = prog;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000142 /* Initialize all programmer specific data. */
143 /* Default to unlimited decode sizes. */
144 max_rom_decode = (const struct decode_sizes) {
145 .parallel = 0xffffffff,
146 .lpc = 0xffffffff,
147 .fwh = 0xffffffff,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000148 .spi = 0xffffffff,
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000149 };
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000150 /* Default to top aligned flash at 4 GB. */
151 flashbase = 0;
152 /* Registering shutdown functions is now allowed. */
Felix Singerf25447e2022-08-19 02:44:28 +0200153 may_register_shutdown = true;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000154 /* Default to allowing writes. Broken programmers set this to 0. */
Felix Singer980d6b82022-08-19 02:48:15 +0200155 programmer_may_write = true;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000156
Nico Huber6a2ebeb2022-08-26 11:36:48 +0200157 if (param) {
158 programmer_param = strdup(param);
159 if (!programmer_param) {
160 msg_perr("Out of memory!\n");
161 return ERROR_FATAL;
162 }
163 } else {
164 programmer_param = NULL;
165 }
166
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +0200167 msg_pdbg("Initializing %s programmer\n", programmer->name);
168 ret = programmer->init();
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000169 if (programmer_param && strlen(programmer_param)) {
Carl-Daniel Hailfinger20a36ba2013-08-13 07:09:57 +0000170 if (ret != 0) {
171 /* It is quite possible that any unhandled programmer parameter would have been valid,
172 * but an error in actual programmer init happened before the parameter was evaluated.
173 */
174 msg_pwarn("Unhandled programmer parameters (possibly due to another failure): %s\n",
175 programmer_param);
176 } else {
177 /* Actual programmer init was successful, but the user specified an invalid or unusable
178 * (for the current programmer configuration) parameter.
179 */
180 msg_perr("Unhandled programmer parameters: %s\n", programmer_param);
181 msg_perr("Aborting.\n");
182 ret = ERROR_FATAL;
183 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000184 }
Nico Huber6a2ebeb2022-08-26 11:36:48 +0200185 free(programmer_param);
186 programmer_param = NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000187 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000188}
189
Stefan Tauner20da4aa2014-05-07 22:07:23 +0000190/** Calls registered shutdown functions and resets internal programmer-related variables.
191 * Calling it is safe even without previous initialization, but further interactions with programmer support
192 * require a call to programmer_init() (afterwards).
193 *
194 * @return The OR-ed result values of all shutdown functions (i.e. 0 on success). */
Uwe Hermann09e04f72009-05-16 22:36:00 +0000195int programmer_shutdown(void)
196{
David Hendricks8bb20212011-06-14 01:35:36 +0000197 int ret = 0;
198
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000199 /* Registering shutdown functions is no longer allowed. */
Felix Singerf25447e2022-08-19 02:44:28 +0200200 may_register_shutdown = false;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000201 while (shutdown_fn_count > 0) {
202 int i = --shutdown_fn_count;
David Hendricks8bb20212011-06-14 01:35:36 +0000203 ret |= shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000204 }
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000205 registered_master_count = 0;
Stefan Taunere34e3e82013-01-01 00:06:51 +0000206
David Hendricks8bb20212011-06-14 01:35:36 +0000207 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000208}
209
Stefan Tauner305e0b92013-07-17 23:46:44 +0000210void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000211{
Edward O'Callaghan621208c2022-09-07 22:21:39 +1000212 void *ret;
213 if (programmer->map_flash_region)
214 ret = programmer->map_flash_region(descr, phys_addr, len);
215 else
216 ret = fallback_map(descr, phys_addr, len);
Stefan Tauner26e7a152013-09-13 17:21:05 +0000217 msg_gspew("%s: mapping %s from 0x%0*" PRIxPTR " to 0x%0*" PRIxPTR "\n",
218 __func__, descr, PRIxPTR_WIDTH, phys_addr, PRIxPTR_WIDTH, (uintptr_t) ret);
219 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000220}
221
222void programmer_unmap_flash_region(void *virt_addr, size_t len)
223{
Edward O'Callaghan621208c2022-09-07 22:21:39 +1000224 if (programmer->unmap_flash_region)
225 programmer->unmap_flash_region(virt_addr, len);
226 else
227 fallback_unmap(virt_addr, len);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000228 msg_gspew("%s: unmapped 0x%0*" PRIxPTR "\n", __func__, PRIxPTR_WIDTH, (uintptr_t)virt_addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000229}
230
Stefan Taunerf80419c2014-05-02 15:41:42 +0000231void programmer_delay(unsigned int usecs)
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000232{
Edward O'Callaghan56684d92022-09-07 10:47:45 +1000233 if (usecs > 0) {
234 if (programmer->delay)
235 programmer->delay(usecs);
236 else
237 internal_delay(usecs);
238 }
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000239}
240
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000241int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
242 int unsigned len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000243{
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000244 chip_readn(flash, buf, flash->virtual_memory + start, len);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000245
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000246 return 0;
247}
248
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000249/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000250 * It will look for needle with a subsequent '=' in haystack, return a copy of
251 * needle and remove everything from the first occurrence of needle to the next
252 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000253 */
Nico Huber6a2ebeb2022-08-26 11:36:48 +0200254static char *extract_param(char *const *haystack, const char *needle, const char *delim)
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000255{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000256 char *param_pos, *opt_pos, *rest;
257 char *opt = NULL;
258 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000259 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000260
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000261 needlelen = strlen(needle);
262 if (!needlelen) {
263 msg_gerr("%s: empty needle! Please report a bug at "
Nico Huberac90af62022-12-18 00:22:47 +0000264 "flashrom-stable@flashrom.org\n", __func__);
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000265 return NULL;
266 }
267 /* No programmer parameters given. */
268 if (*haystack == NULL)
269 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000270 param_pos = strstr(*haystack, needle);
271 do {
272 if (!param_pos)
273 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000274 /* Needle followed by '='? */
275 if (param_pos[needlelen] == '=') {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000276 /* Beginning of the string? */
277 if (param_pos == *haystack)
278 break;
279 /* After a delimiter? */
280 if (strchr(delim, *(param_pos - 1)))
281 break;
282 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000283 /* Continue searching. */
284 param_pos++;
285 param_pos = strstr(param_pos, needle);
286 } while (1);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000287
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000288 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000289 /* Get the string after needle and '='. */
290 opt_pos = param_pos + needlelen + 1;
291 optlen = strcspn(opt_pos, delim);
292 /* Return an empty string if the parameter was empty. */
293 opt = malloc(optlen + 1);
294 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000295 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000296 exit(1);
297 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000298 strncpy(opt, opt_pos, optlen);
299 opt[optlen] = '\0';
300 rest = opt_pos + optlen;
301 /* Skip all delimiters after the current parameter. */
302 rest += strspn(rest, delim);
303 memmove(param_pos, rest, strlen(rest) + 1);
304 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000305 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000306
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000307 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000308}
309
Stefan Tauner66652442011-06-26 17:38:17 +0000310char *extract_programmer_param(const char *param_name)
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000311{
312 return extract_param(&programmer_param, param_name, ",");
313}
314
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +0000315/* Returns the number of well-defined erasers for a chip. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000316static unsigned int count_usable_erasers(const struct flashctx *flash)
Stefan Tauner5368dca2011-07-01 00:19:12 +0000317{
318 unsigned int usable_erasefunctions = 0;
319 int k;
320 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
321 if (!check_block_eraser(flash, k, 0))
322 usable_erasefunctions++;
323 }
324 return usable_erasefunctions;
325}
326
Mark Marshallf20b7be2014-05-09 21:16:21 +0000327static int compare_range(const uint8_t *wantbuf, const uint8_t *havebuf, unsigned int start, unsigned int len)
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000328{
329 int ret = 0, failcount = 0;
330 unsigned int i;
331 for (i = 0; i < len; i++) {
332 if (wantbuf[i] != havebuf[i]) {
333 /* Only print the first failure. */
334 if (!failcount++)
335 msg_cerr("FAILED at 0x%08x! Expected=0x%02x, Found=0x%02x,",
336 start + i, wantbuf[i], havebuf[i]);
337 }
338 }
339 if (failcount) {
340 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
341 start, start + len - 1, failcount);
342 ret = -1;
343 }
344 return ret;
345}
346
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000347/* start is an offset to the base address of the flash chip */
Jacob Garberbeeb8bc2019-06-21 15:24:17 -0600348static int check_erased_range(struct flashctx *flash, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000349{
350 int ret;
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300351 const uint8_t erased_value = ERASED_VALUE(flash);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000352
Edward O'Callaghanf60f64f2022-11-12 12:08:01 +1100353 uint8_t *cmpbuf = malloc(len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000354 if (!cmpbuf) {
Edward O'Callaghana31a5722022-11-12 12:05:36 +1100355 msg_gerr("Out of memory!\n");
Edward O'Callaghan6edf9f82022-11-12 12:08:46 +1100356 return -1;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000357 }
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300358 memset(cmpbuf, erased_value, len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000359 ret = verify_range(flash, cmpbuf, start, len);
Edward O'Callaghanf60f64f2022-11-12 12:08:01 +1100360
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000361 free(cmpbuf);
362 return ret;
363}
364
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000365/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000366 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000367 * flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000368 * @start offset to the base address of the flash chip
369 * @len length of the verified area
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000370 * @return 0 for success, -1 for failure
371 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000372int verify_range(struct flashctx *flash, const uint8_t *cmpbuf, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000373{
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000374 if (!len)
Stefan Taunerdf64a422014-05-27 00:06:14 +0000375 return -1;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000376
Edward O'Callaghan6ae640b2021-11-17 14:24:04 +1100377 if (start + len > flash->chip->total_size * 1024) {
378 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
379 " total_size 0x%x\n", __func__, start, len,
380 flash->chip->total_size * 1024);
381 return -1;
382 }
383
Stefan Taunerdf64a422014-05-27 00:06:14 +0000384 uint8_t *readbuf = malloc(len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000385 if (!readbuf) {
Edward O'Callaghana31a5722022-11-12 12:05:36 +1100386 msg_gerr("Out of memory!\n");
Stefan Taunerdf64a422014-05-27 00:06:14 +0000387 return -1;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000388 }
389
Edward O'Callaghan6ae640b2021-11-17 14:24:04 +1100390 int ret = flash->chip->read(flash, readbuf, start, len);
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000391 if (ret) {
392 msg_gerr("Verification impossible because read failed "
393 "at 0x%x (len 0x%x)\n", start, len);
Stefan Taunerdf64a422014-05-27 00:06:14 +0000394 ret = -1;
395 goto out_free;
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000396 }
397
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000398 ret = compare_range(cmpbuf, readbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000399out_free:
400 free(readbuf);
401 return ret;
402}
403
Nico Huber3ac761c2023-01-16 02:43:17 +0100404size_t gran_to_bytes(const enum write_granularity gran)
Nico Huberb77607f2023-01-16 02:25:45 +0100405{
406 switch (gran) {
407 case write_gran_1bit: return 1;
408 case write_gran_1byte: return 1;
409 case write_gran_1byte_implicit_erase: return 1;
410 case write_gran_128bytes: return 128;
411 case write_gran_256bytes: return 256;
412 case write_gran_264bytes: return 264;
413 case write_gran_512bytes: return 512;
414 case write_gran_528bytes: return 528;
415 case write_gran_1024bytes: return 1024;
416 case write_gran_1056bytes: return 1056;
417 default: return 0;
418 }
419}
420
Stefan Tauner02437452013-04-01 19:34:53 +0000421/* Helper function for need_erase() that focuses on granularities of gran bytes. */
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300422static int need_erase_gran_bytes(const uint8_t *have, const uint8_t *want, unsigned int len,
423 unsigned int gran, const uint8_t erased_value)
Stefan Tauner02437452013-04-01 19:34:53 +0000424{
425 unsigned int i, j, limit;
426 for (j = 0; j < len / gran; j++) {
427 limit = min (gran, len - j * gran);
428 /* Are 'have' and 'want' identical? */
429 if (!memcmp(have + j * gran, want + j * gran, limit))
430 continue;
431 /* have needs to be in erased state. */
432 for (i = 0; i < limit; i++)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300433 if (have[j * gran + i] != erased_value)
Stefan Tauner02437452013-04-01 19:34:53 +0000434 return 1;
435 }
436 return 0;
437}
438
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000439/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000440 * Check if the buffer @have can be programmed to the content of @want without
441 * erasing. This is only possible if all chunks of size @gran are either kept
442 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000443 *
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000444 * Warning: This function assumes that @have and @want point to naturally
445 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000446 *
447 * @have buffer with current content
448 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000449 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000450 * @gran write granularity (enum, not count)
451 * @return 0 if no erase is needed, 1 otherwise
452 */
Edward O'Callaghana1805092022-05-16 11:10:36 +1000453static int need_erase(const uint8_t *have, const uint8_t *want, unsigned int len,
454 enum write_granularity gran, const uint8_t erased_value)
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000455{
Stefan Tauner02437452013-04-01 19:34:53 +0000456 unsigned int i;
Nico Huberb77607f2023-01-16 02:25:45 +0100457 size_t stride;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000458
459 switch (gran) {
460 case write_gran_1bit:
Nico Huberb77607f2023-01-16 02:25:45 +0100461 for (i = 0; i < len; i++) {
462 if ((have[i] & want[i]) != want[i])
463 return 1;
464 }
465 return 0;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000466 case write_gran_1byte:
Nico Huberb77607f2023-01-16 02:25:45 +0100467 for (i = 0; i < len; i++) {
468 if ((have[i] != want[i]) && (have[i] != erased_value))
469 return 1;
470 }
471 return 0;
Carl-Daniel Hailfinger1b0e9fc2014-06-16 22:36:17 +0000472 case write_gran_1byte_implicit_erase:
473 /* Do not erase, handle content changes from anything->0xff by writing 0xff. */
Nico Huberb77607f2023-01-16 02:25:45 +0100474 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000475 default:
Nico Huberb77607f2023-01-16 02:25:45 +0100476 stride = gran_to_bytes(gran);
477 if (stride) {
478 return need_erase_gran_bytes(have, want, len, stride, erased_value);
479 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000480 msg_cerr("%s: Unsupported granularity! Please report a bug at "
Nico Huberac90af62022-12-18 00:22:47 +0000481 "flashrom-stable@flashrom.org\n", __func__);
Nico Huberb77607f2023-01-16 02:25:45 +0100482 return 0;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000483 }
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000484}
485
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000486/**
487 * Check if the buffer @have needs to be programmed to get the content of @want.
488 * If yes, return 1 and fill in first_start with the start address of the
489 * write operation and first_len with the length of the first to-be-written
490 * chunk. If not, return 0 and leave first_start and first_len undefined.
491 *
492 * Warning: This function assumes that @have and @want point to naturally
493 * aligned regions.
494 *
495 * @have buffer with current content
496 * @want buffer with desired content
497 * @len length of the checked area
498 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000499 * @first_start offset of the first byte which needs to be written (passed in
500 * value is increased by the offset of the first needed write
501 * relative to have/want or unchanged if no write is needed)
502 * @return length of the first contiguous area which needs to be written
503 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000504 *
505 * FIXME: This function needs a parameter which tells it about coalescing
506 * in relation to the max write length of the programmer and the max write
507 * length of the chip.
508 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000509static unsigned int get_next_write(const uint8_t *have, const uint8_t *want, unsigned int len,
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000510 unsigned int *first_start,
511 enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000512{
Felix Singerf25447e2022-08-19 02:44:28 +0200513 bool need_write = false;
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000514 unsigned int rel_start = 0, first_len = 0;
Nico Huberb77607f2023-01-16 02:25:45 +0100515 unsigned int i, limit;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000516
Nico Huberb77607f2023-01-16 02:25:45 +0100517 const size_t stride = gran_to_bytes(gran);
518 if (!stride) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000519 msg_cerr("%s: Unsupported granularity! Please report a bug at "
Nico Huberac90af62022-12-18 00:22:47 +0000520 "flashrom-stable@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000521 /* Claim that no write was needed. A write with unknown
522 * granularity is too dangerous to try.
523 */
524 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000525 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000526 for (i = 0; i < len / stride; i++) {
527 limit = min(stride, len - i * stride);
528 /* Are 'have' and 'want' identical? */
529 if (memcmp(have + i * stride, want + i * stride, limit)) {
530 if (!need_write) {
531 /* First location where have and want differ. */
Felix Singerf25447e2022-08-19 02:44:28 +0200532 need_write = true;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000533 rel_start = i * stride;
534 }
535 } else {
536 if (need_write) {
537 /* First location where have and want
538 * do not differ anymore.
539 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000540 break;
541 }
542 }
543 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000544 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000545 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000546 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000547 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000548}
549
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000550void unmap_flash(struct flashctx *flash)
551{
552 if (flash->virtual_registers != (chipaddr)ERROR_PTR) {
553 programmer_unmap_flash_region((void *)flash->virtual_registers, flash->chip->total_size * 1024);
554 flash->physical_registers = 0;
555 flash->virtual_registers = (chipaddr)ERROR_PTR;
556 }
557
558 if (flash->virtual_memory != (chipaddr)ERROR_PTR) {
559 programmer_unmap_flash_region((void *)flash->virtual_memory, flash->chip->total_size * 1024);
560 flash->physical_memory = 0;
561 flash->virtual_memory = (chipaddr)ERROR_PTR;
562 }
563}
564
565int map_flash(struct flashctx *flash)
566{
567 /* Init pointers to the fail-safe state to distinguish them later from legit values. */
568 flash->virtual_memory = (chipaddr)ERROR_PTR;
569 flash->virtual_registers = (chipaddr)ERROR_PTR;
570
571 /* FIXME: This avoids mapping (and unmapping) of flash chip definitions with size 0.
572 * These are used for various probing-related hacks that would not map successfully anyway and should be
573 * removed ASAP. */
574 if (flash->chip->total_size == 0)
575 return 0;
576
577 const chipsize_t size = flash->chip->total_size * 1024;
578 uintptr_t base = flashbase ? flashbase : (0xffffffff - size + 1);
579 void *addr = programmer_map_flash_region(flash->chip->name, base, size);
580 if (addr == ERROR_PTR) {
581 msg_perr("Could not map flash chip %s at 0x%0*" PRIxPTR ".\n",
582 flash->chip->name, PRIxPTR_WIDTH, base);
583 return 1;
584 }
585 flash->physical_memory = base;
586 flash->virtual_memory = (chipaddr)addr;
587
588 /* FIXME: Special function registers normally live 4 MByte below flash space, but it might be somewhere
589 * completely different on some chips and programmers, or not mappable at all.
590 * Ignore these problems for now and always report success. */
591 if (flash->chip->feature_bits & FEATURE_REGISTERMAP) {
592 base = 0xffffffff - size - 0x400000 + 1;
593 addr = programmer_map_flash_region("flash chip registers", base, size);
594 if (addr == ERROR_PTR) {
595 msg_pdbg2("Could not map flash chip registers %s at 0x%0*" PRIxPTR ".\n",
596 flash->chip->name, PRIxPTR_WIDTH, base);
597 return 0;
598 }
599 flash->physical_registers = base;
600 flash->virtual_registers = (chipaddr)addr;
601 }
602 return 0;
603}
604
Nico Huber2d625722016-05-03 10:48:02 +0200605/*
606 * Return a string corresponding to the bustype parameter.
607 * Memory is obtained with malloc() and must be freed with free() by the caller.
608 */
609char *flashbuses_to_text(enum chipbustype bustype)
610{
611 char *ret = calloc(1, 1);
612 /*
613 * FIXME: Once all chipsets and flash chips have been updated, NONSPI
614 * will cease to exist and should be eliminated here as well.
615 */
616 if (bustype == BUS_NONSPI) {
617 ret = strcat_realloc(ret, "Non-SPI, ");
618 } else {
619 if (bustype & BUS_PARALLEL)
620 ret = strcat_realloc(ret, "Parallel, ");
621 if (bustype & BUS_LPC)
622 ret = strcat_realloc(ret, "LPC, ");
623 if (bustype & BUS_FWH)
624 ret = strcat_realloc(ret, "FWH, ");
625 if (bustype & BUS_SPI)
626 ret = strcat_realloc(ret, "SPI, ");
627 if (bustype & BUS_PROG)
628 ret = strcat_realloc(ret, "Programmer-specific, ");
629 if (bustype == BUS_NONE)
630 ret = strcat_realloc(ret, "None, ");
631 }
632 /* Kill last comma. */
633 ret[strlen(ret) - 2] = '\0';
634 ret = realloc(ret, strlen(ret) + 1);
635 return ret;
636}
637
Edward O'Callaghan00ea3892022-10-11 21:27:37 +1100638static int init_default_layout(struct flashctx *flash)
639{
640 /* Fill default layout covering the whole chip. */
641 if (flashrom_layout_new(&flash->default_layout) ||
642 flashrom_layout_add_region(flash->default_layout,
643 0, flash->chip->total_size * 1024 - 1, "complete flash") ||
644 flashrom_layout_include_region(flash->default_layout, "complete flash"))
645 return -1;
646 return 0;
647}
648
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000649int probe_flash(struct registered_master *mst, int startchip, struct flashctx *flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000650{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000651 const struct flashchip *chip;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000652 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000653 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000654
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000655 for (chip = flashchips + startchip; chip && chip->name; chip++) {
656 if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +0000657 continue;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000658 buses_common = mst->buses_supported & chip->bustype;
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000659 if (!buses_common)
Carl-Daniel Hailfinger6573b742011-06-17 22:38:53 +0000660 continue;
Mike Banon31b5e3b2018-01-15 01:10:00 +0300661 /* Only probe for SPI25 chips by default. */
662 if (chip->bustype == BUS_SPI && !chip_to_probe && chip->spi_cmd_set != SPI25)
663 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000664 msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
665 if (!chip->probe && !force) {
666 msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000667 continue;
668 }
Stefan Reinauer70385642007-04-06 11:58:03 +0000669
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000670 /* Start filling in the dynamic data. */
Angel Pons690a9442021-06-07 12:33:53 +0200671 flash->chip = calloc(1, sizeof(*flash->chip));
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000672 if (!flash->chip) {
673 msg_gerr("Out of memory!\n");
Edward O'Callaghan6edf9f82022-11-12 12:08:46 +1100674 return -1;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000675 }
Angel Pons7e134562021-06-07 13:29:13 +0200676 *flash->chip = *chip;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000677 flash->mst = mst;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000678
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000679 if (map_flash(flash) != 0)
Martin Schiller57a3b732017-11-23 06:24:57 +0100680 goto notfound;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000681
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000682 /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
683 * is only called with force=1 after normal probing failed.
684 */
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000685 if (force)
686 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +0000687
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000688 if (flash->chip->probe(flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +0000689 goto notfound;
690
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000691 /* If this is the first chip found, accept it.
692 * If this is not the first chip found, accept it only if it is
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000693 * a non-generic match. SFDP and CFI are generic matches.
694 * startchip==0 means this call to probe_flash() is the first
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000695 * one for this programmer interface (master) and thus no other chip has
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000696 * been found on this interface.
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000697 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000698 if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000699 msg_cinfo("===\n"
700 "SFDP has autodetected a flash chip which is "
701 "not natively supported by flashrom yet.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000702 if (count_usable_erasers(flash) == 0)
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000703 msg_cinfo("The standard operations read and "
704 "verify should work, but to support "
705 "erase, write and all other "
706 "possible features");
707 else
708 msg_cinfo("All standard operations (read, "
709 "verify, erase and write) should "
710 "work, but to support all possible "
711 "features");
712
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000713 msg_cinfo(" we need to add them manually.\n"
714 "You can help us by mailing us the output of the following command to "
Nico Huberac90af62022-12-18 00:22:47 +0000715 "flashrom-stable@flashrom.org:\n"
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000716 "'flashrom -VV [plus the -p/--programmer parameter]'\n"
717 "Thanks for your help!\n"
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000718 "===\n");
719 }
720
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000721 /* First flash chip detected on this bus. */
722 if (startchip == 0)
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000723 break;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000724 /* Not the first flash chip detected on this bus, but not a generic match either. */
725 if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
726 break;
727 /* Not the first flash chip detected on this bus, and it's just a generic match. Ignore it. */
Peter Stuge483b8f02008-09-03 23:10:05 +0000728notfound:
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000729 unmap_flash(flash);
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000730 free(flash->chip);
731 flash->chip = NULL;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000732 }
Uwe Hermannffec5f32007-08-23 16:08:21 +0000733
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000734 if (!flash->chip)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000735 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000736
Edward O'Callaghan00ea3892022-10-11 21:27:37 +1100737 if (init_default_layout(flash) < 0)
738 return -1;
Stefan Reinauer051e2362011-01-19 06:21:54 +0000739
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000740 tmp = flashbuses_to_text(flash->chip->bustype);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000741 msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) ", force ? "Assuming" : "Found",
742 flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp);
Stefan Tauner00155492011-06-26 20:45:35 +0000743 free(tmp);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000744#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +0200745 if (programmer->map_flash_region == physmap)
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000746 msg_cinfo("mapped at physical address 0x%0*" PRIxPTR ".\n",
747 PRIxPTR_WIDTH, flash->physical_memory);
748 else
749#endif
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +0200750 msg_cinfo("on %s.\n", programmer->name);
Uwe Hermann9899cad2009-06-28 21:47:57 +0000751
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000752 /* Flash registers may more likely not be mapped if the chip was forced.
753 * Lock info may be stored in registers, so avoid lock info printing. */
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +0000754 if (!force)
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000755 if (flash->chip->printlock)
756 flash->chip->printlock(flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +0000757
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000758 /* Get out of the way for later runs. */
759 unmap_flash(flash);
760
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000761 /* Return position of matching chip. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000762 return chip - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000763}
764
Stefan Tauner96658be2014-05-26 22:05:31 +0000765/* Even if an error is found, the function will keep going and check the rest. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000766static int selfcheck_eraseblocks(const struct flashchip *chip)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000767{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000768 int i, j, k;
769 int ret = 0;
Aarya Chaumal478e1792022-06-04 01:34:44 +0530770 unsigned int prev_eraseblock_count = chip->total_size * 1024;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000771
772 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
773 unsigned int done = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000774 struct block_eraser eraser = chip->block_erasers[k];
Aarya Chaumal478e1792022-06-04 01:34:44 +0530775 unsigned int curr_eraseblock_count = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000776
777 for (i = 0; i < NUM_ERASEREGIONS; i++) {
778 /* Blocks with zero size are bugs in flashchips.c. */
779 if (eraser.eraseblocks[i].count &&
780 !eraser.eraseblocks[i].size) {
Nico Huberac90af62022-12-18 00:22:47 +0000781 msg_gerr("ERROR: Flash chip %s erase function %i region %i has size 0.\n"
782 "Please report a bug at flashrom-stable@flashrom.org\n",
783 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000784 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000785 }
786 /* Blocks with zero count are bugs in flashchips.c. */
787 if (!eraser.eraseblocks[i].count &&
788 eraser.eraseblocks[i].size) {
Nico Huberac90af62022-12-18 00:22:47 +0000789 msg_gerr("ERROR: Flash chip %s erase function %i region %i has count 0.\n"
790 "Please report a bug at flashrom-stable@flashrom.org\n",
791 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000792 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000793 }
794 done += eraser.eraseblocks[i].count *
795 eraser.eraseblocks[i].size;
Aarya Chaumal478e1792022-06-04 01:34:44 +0530796 curr_eraseblock_count += eraser.eraseblocks[i].count;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000797 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000798 /* Empty eraseblock definition with erase function. */
799 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +0000800 msg_gspew("Strange: Empty eraseblock definition with "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000801 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000802 if (!done)
803 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000804 if (done != chip->total_size * 1024) {
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000805 msg_gerr("ERROR: Flash chip %s erase function %i "
806 "region walking resulted in 0x%06x bytes total,"
Nico Huberac90af62022-12-18 00:22:47 +0000807 " expected 0x%06x bytes.\n"
808 "Please report a bug at flashrom-stable@flashrom.org\n",
809 chip->name, k, done, chip->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000810 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000811 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000812 if (!eraser.block_erase)
813 continue;
814 /* Check if there are identical erase functions for different
815 * layouts. That would imply "magic" erase functions. The
816 * easiest way to check this is with function pointers.
817 */
Uwe Hermann43959702010-03-13 17:28:29 +0000818 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000819 if (eraser.block_erase ==
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000820 chip->block_erasers[j].block_erase) {
Nico Huberac90af62022-12-18 00:22:47 +0000821 msg_gerr("ERROR: Flash chip %s erase function %i and %i are identical.\n"
822 "Please report a bug at flashrom-stable@flashrom.org\n",
823 chip->name, k, j);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000824 ret = 1;
825 }
Uwe Hermann43959702010-03-13 17:28:29 +0000826 }
Aarya Chaumal478e1792022-06-04 01:34:44 +0530827 if(curr_eraseblock_count > prev_eraseblock_count)
828 {
Nico Huberac90af62022-12-18 00:22:47 +0000829 msg_gerr("ERROR: Flash chip %s erase function %i is not in order.\n"
830 "Please report a bug at flashrom-stable@flashrom.org\n",
831 chip->name, k);
Aarya Chaumal478e1792022-06-04 01:34:44 +0530832 ret = 1;
833 }
834 prev_eraseblock_count = curr_eraseblock_count;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000835 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000836 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000837}
838
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000839static int check_block_eraser(const struct flashctx *flash, int k, int log)
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000840{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000841 struct block_eraser eraser = flash->chip->block_erasers[k];
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000842
843 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
844 if (log)
845 msg_cdbg("not defined. ");
846 return 1;
847 }
848 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
849 if (log)
850 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000851 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000852 return 1;
853 }
854 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
855 if (log)
856 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000857 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000858 return 1;
859 }
Aarya Chaumal6d98aec2022-08-14 23:16:44 +0530860
861 if (flash->chip->bustype == BUS_SPI) {
862 const uint8_t *opcode = spi_get_opcode_from_erasefn(eraser.block_erase);
863 for (int i = 0; opcode[i]; i++) {
864 if (!flash->mst->spi.probe_opcode(flash, opcode[i])) {
865 if (log)
866 msg_cdbg("block erase function and layout found "
867 "but SPI master doesn't support the function. ");
868 return 1;
869 }
870 }
871 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000872 // TODO: Once erase functions are annotated with allowed buses, check that as well.
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000873 return 0;
874}
875
Nico Huber7af0e792016-04-29 16:40:15 +0200876/**
877 * @brief Reads the included layout regions into a buffer.
878 *
879 * If there is no layout set in the given flash context, the whole chip will
880 * be read.
881 *
882 * @param flashctx Flash context to be used.
883 * @param buffer Buffer of full chip size to read into.
884 * @return 0 on success,
885 * 1 if any read fails.
886 */
887static int read_by_layout(struct flashctx *const flashctx, uint8_t *const buffer)
888{
889 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber5ca55232019-06-15 22:29:08 +0200890 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +0200891
Nico Huber5ca55232019-06-15 22:29:08 +0200892 while ((entry = layout_next_included(layout, entry))) {
893 const chipoff_t region_start = entry->start;
894 const chipsize_t region_len = entry->end - entry->start + 1;
Nico Huber7af0e792016-04-29 16:40:15 +0200895
896 if (flashctx->chip->read(flashctx, buffer + region_start, region_start, region_len))
897 return 1;
898 }
899 return 0;
900}
901
902typedef int (*erasefn_t)(struct flashctx *, unsigned int addr, unsigned int len);
903/**
904 * @private
905 *
906 * For read-erase-write, `curcontents` and `newcontents` shall point
907 * to buffers of the chip's size. Both are supposed to be prefilled
908 * with at least the included layout regions of the current flash
909 * contents (`curcontents`) and the data to be written to the flash
910 * (`newcontents`).
911 *
912 * For erase, `curcontents` and `newcontents` shall be NULL-pointers.
913 *
914 * The `chipoff_t` values are used internally by `walk_by_layout()`.
915 */
916struct walk_info {
917 uint8_t *curcontents;
918 const uint8_t *newcontents;
919 chipoff_t region_start;
920 chipoff_t region_end;
921 chipoff_t erase_start;
922 chipoff_t erase_end;
923};
924/* returns 0 on success, 1 to retry with another erase function, 2 for immediate abort */
925typedef int (*per_blockfn_t)(struct flashctx *, const struct walk_info *, erasefn_t);
926
927static int walk_eraseblocks(struct flashctx *const flashctx,
928 struct walk_info *const info,
929 const size_t erasefunction, const per_blockfn_t per_blockfn)
930{
931 int ret;
932 size_t i, j;
933 bool first = true;
934 struct block_eraser *const eraser = &flashctx->chip->block_erasers[erasefunction];
935
936 info->erase_start = 0;
937 for (i = 0; i < NUM_ERASEREGIONS; ++i) {
938 /* count==0 for all automatically initialized array
939 members so the loop below won't be executed for them. */
940 for (j = 0; j < eraser->eraseblocks[i].count; ++j, info->erase_start = info->erase_end + 1) {
941 info->erase_end = info->erase_start + eraser->eraseblocks[i].size - 1;
942
943 /* Skip any eraseblock that is completely outside the current region. */
944 if (info->erase_end < info->region_start)
945 continue;
946 if (info->region_end < info->erase_start)
947 break;
948
949 /* Print this for every block except the first one. */
950 if (first)
951 first = false;
952 else
953 msg_cdbg(", ");
954 msg_cdbg("0x%06x-0x%06x:", info->erase_start, info->erase_end);
955
956 ret = per_blockfn(flashctx, info, eraser->block_erase);
957 if (ret)
958 return ret;
959 }
960 if (info->region_end < info->erase_start)
961 break;
962 }
963 msg_cdbg("\n");
964 return 0;
965}
966
967static int walk_by_layout(struct flashctx *const flashctx, struct walk_info *const info,
968 const per_blockfn_t per_blockfn)
969{
970 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber5ca55232019-06-15 22:29:08 +0200971 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +0200972
973 all_skipped = true;
974 msg_cinfo("Erasing and writing flash chip... ");
975
Nico Huber5ca55232019-06-15 22:29:08 +0200976 while ((entry = layout_next_included(layout, entry))) {
977 info->region_start = entry->start;
978 info->region_end = entry->end;
Nico Huber7af0e792016-04-29 16:40:15 +0200979
980 size_t j;
981 int error = 1; /* retry as long as it's 1 */
982 for (j = 0; j < NUM_ERASEFUNCTIONS; ++j) {
983 if (j != 0)
984 msg_cinfo("Looking for another erase function.\n");
985 msg_cdbg("Trying erase function %zi... ", j);
986 if (check_block_eraser(flashctx, j, 1))
987 continue;
988
989 error = walk_eraseblocks(flashctx, info, j, per_blockfn);
990 if (error != 1)
991 break;
992
993 if (info->curcontents) {
994 msg_cinfo("Reading current flash chip contents... ");
995 if (read_by_layout(flashctx, info->curcontents)) {
996 /* Now we are truly screwed. Read failed as well. */
997 msg_cerr("Can't read anymore! Aborting.\n");
998 /* We have no idea about the flash chip contents, so
999 retrying with another erase function is pointless. */
1000 error = 2;
1001 break;
1002 }
1003 msg_cinfo("done. ");
1004 }
1005 }
1006 if (error == 1)
1007 msg_cinfo("No usable erase functions left.\n");
1008 if (error) {
1009 msg_cerr("FAILED!\n");
1010 return 1;
1011 }
1012 }
1013 if (all_skipped)
1014 msg_cinfo("\nWarning: Chip content is identical to the requested image.\n");
1015 msg_cinfo("Erase/write done.\n");
1016 return 0;
1017}
1018
1019static int erase_block(struct flashctx *const flashctx,
1020 const struct walk_info *const info, const erasefn_t erasefn)
1021{
1022 const unsigned int erase_len = info->erase_end + 1 - info->erase_start;
Nico Huber6e61e0c2019-01-23 17:07:49 +01001023 const bool region_unaligned = info->region_start > info->erase_start ||
1024 info->erase_end > info->region_end;
1025 uint8_t *backup_contents = NULL, *erased_contents = NULL;
1026 int ret = 2;
Nico Huber7af0e792016-04-29 16:40:15 +02001027
Nico Huber6e61e0c2019-01-23 17:07:49 +01001028 /*
1029 * If the region is not erase-block aligned, merge current flash con-
1030 * tents into a new buffer `backup_contents`.
1031 */
1032 if (region_unaligned) {
1033 backup_contents = malloc(erase_len);
1034 erased_contents = malloc(erase_len);
1035 if (!backup_contents || !erased_contents) {
1036 msg_cerr("Out of memory!\n");
1037 ret = 1;
1038 goto _free_ret;
1039 }
1040 memset(backup_contents, ERASED_VALUE(flashctx), erase_len);
1041 memset(erased_contents, ERASED_VALUE(flashctx), erase_len);
1042
1043 msg_cdbg("R");
1044 /* Merge data preceding the current region. */
1045 if (info->region_start > info->erase_start) {
1046 const chipoff_t start = info->erase_start;
1047 const chipsize_t len = info->region_start - info->erase_start;
1048 if (flashctx->chip->read(flashctx, backup_contents, start, len)) {
1049 msg_cerr("Can't read! Aborting.\n");
1050 goto _free_ret;
1051 }
1052 }
1053 /* Merge data following the current region. */
1054 if (info->erase_end > info->region_end) {
1055 const chipoff_t start = info->region_end + 1;
1056 const chipoff_t rel_start = start - info->erase_start; /* within this erase block */
1057 const chipsize_t len = info->erase_end - info->region_end;
1058 if (flashctx->chip->read(flashctx, backup_contents + rel_start, start, len)) {
1059 msg_cerr("Can't read! Aborting.\n");
1060 goto _free_ret;
1061 }
1062 }
1063 }
1064
1065 ret = 1;
Nico Huber7af0e792016-04-29 16:40:15 +02001066 all_skipped = false;
1067
1068 msg_cdbg("E");
1069 if (erasefn(flashctx, info->erase_start, erase_len))
Nico Huber6e61e0c2019-01-23 17:07:49 +01001070 goto _free_ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001071 if (check_erased_range(flashctx, info->erase_start, erase_len)) {
1072 msg_cerr("ERASE FAILED!\n");
Nico Huber6e61e0c2019-01-23 17:07:49 +01001073 goto _free_ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001074 }
Nico Huber6e61e0c2019-01-23 17:07:49 +01001075
1076 if (region_unaligned) {
1077 unsigned int starthere = 0, lenhere = 0, writecount = 0;
1078 /* get_next_write() sets starthere to a new value after the call. */
1079 while ((lenhere = get_next_write(erased_contents + starthere, backup_contents + starthere,
1080 erase_len - starthere, &starthere, flashctx->chip->gran))) {
1081 if (!writecount++)
1082 msg_cdbg("W");
1083 /* Needs the partial write function signature. */
1084 if (flashctx->chip->write(flashctx, backup_contents + starthere,
1085 info->erase_start + starthere, lenhere))
1086 goto _free_ret;
1087 starthere += lenhere;
1088 }
1089 }
1090
1091 ret = 0;
1092
1093_free_ret:
1094 free(erased_contents);
1095 free(backup_contents);
1096 return ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001097}
1098
1099/**
1100 * @brief Erases the included layout regions.
1101 *
1102 * If there is no layout set in the given flash context, the whole chip will
1103 * be erased.
1104 *
1105 * @param flashctx Flash context to be used.
Nico Huber7af0e792016-04-29 16:40:15 +02001106 * @return 0 on success,
1107 * 1 if all available erase functions failed.
1108 */
Nico Huber454f6132012-12-10 13:34:10 +00001109static int erase_by_layout(struct flashctx *const flashctx)
Nico Huber7af0e792016-04-29 16:40:15 +02001110{
1111 struct walk_info info = { 0 };
1112 return walk_by_layout(flashctx, &info, &erase_block);
1113}
1114
1115static int read_erase_write_block(struct flashctx *const flashctx,
1116 const struct walk_info *const info, const erasefn_t erasefn)
1117{
1118 const chipsize_t erase_len = info->erase_end + 1 - info->erase_start;
1119 const bool region_unaligned = info->region_start > info->erase_start ||
1120 info->erase_end > info->region_end;
1121 const uint8_t *newcontents = NULL;
1122 int ret = 2;
1123
1124 /*
1125 * If the region is not erase-block aligned, merge current flash con-
1126 * tents into `info->curcontents` and a new buffer `newc`. The former
1127 * is necessary since we have no guarantee that the full erase block
1128 * was already read into `info->curcontents`. For the latter a new
1129 * buffer is used since `info->newcontents` might contain data for
1130 * other unaligned regions that touch this erase block too.
1131 */
1132 if (region_unaligned) {
1133 msg_cdbg("R");
1134 uint8_t *const newc = malloc(erase_len);
1135 if (!newc) {
1136 msg_cerr("Out of memory!\n");
1137 return 1;
1138 }
1139 memcpy(newc, info->newcontents + info->erase_start, erase_len);
1140
1141 /* Merge data preceding the current region. */
1142 if (info->region_start > info->erase_start) {
1143 const chipoff_t start = info->erase_start;
1144 const chipsize_t len = info->region_start - info->erase_start;
1145 if (flashctx->chip->read(flashctx, newc, start, len)) {
1146 msg_cerr("Can't read! Aborting.\n");
1147 goto _free_ret;
1148 }
1149 memcpy(info->curcontents + start, newc, len);
1150 }
1151 /* Merge data following the current region. */
1152 if (info->erase_end > info->region_end) {
1153 const chipoff_t start = info->region_end + 1;
1154 const chipoff_t rel_start = start - info->erase_start; /* within this erase block */
1155 const chipsize_t len = info->erase_end - info->region_end;
1156 if (flashctx->chip->read(flashctx, newc + rel_start, start, len)) {
1157 msg_cerr("Can't read! Aborting.\n");
1158 goto _free_ret;
1159 }
1160 memcpy(info->curcontents + start, newc + rel_start, len);
1161 }
1162
1163 newcontents = newc;
1164 } else {
1165 newcontents = info->newcontents + info->erase_start;
1166 }
1167
1168 ret = 1;
1169 bool skipped = true;
1170 uint8_t *const curcontents = info->curcontents + info->erase_start;
Paul Kocialkowski995f7552018-01-15 01:06:09 +03001171 const uint8_t erased_value = ERASED_VALUE(flashctx);
David Hendricksf9a30552015-05-23 20:30:30 -07001172 if (!(flashctx->chip->feature_bits & FEATURE_NO_ERASE) &&
1173 need_erase(curcontents, newcontents, erase_len, flashctx->chip->gran, erased_value)) {
Nico Huber7af0e792016-04-29 16:40:15 +02001174 if (erase_block(flashctx, info, erasefn))
1175 goto _free_ret;
1176 /* Erase was successful. Adjust curcontents. */
Paul Kocialkowski995f7552018-01-15 01:06:09 +03001177 memset(curcontents, erased_value, erase_len);
Nico Huber7af0e792016-04-29 16:40:15 +02001178 skipped = false;
1179 }
1180
1181 unsigned int starthere = 0, lenhere = 0, writecount = 0;
1182 /* get_next_write() sets starthere to a new value after the call. */
1183 while ((lenhere = get_next_write(curcontents + starthere, newcontents + starthere,
1184 erase_len - starthere, &starthere, flashctx->chip->gran))) {
1185 if (!writecount++)
1186 msg_cdbg("W");
1187 /* Needs the partial write function signature. */
1188 if (flashctx->chip->write(flashctx, newcontents + starthere,
1189 info->erase_start + starthere, lenhere))
1190 goto _free_ret;
1191 starthere += lenhere;
1192 skipped = false;
1193 }
1194 if (skipped)
1195 msg_cdbg("S");
1196 else
1197 all_skipped = false;
1198
1199 /* Update curcontents, other regions with overlapping erase blocks
1200 might rely on this. */
1201 memcpy(curcontents, newcontents, erase_len);
1202 ret = 0;
1203
1204_free_ret:
1205 if (region_unaligned)
1206 free((void *)newcontents);
1207 return ret;
1208}
1209
1210/**
1211 * @brief Writes the included layout regions from a given image.
1212 *
1213 * If there is no layout set in the given flash context, the whole image
1214 * will be written.
1215 *
1216 * @param flashctx Flash context to be used.
1217 * @param curcontents A buffer of full chip size with current chip contents of included regions.
1218 * @param newcontents The new image to be written.
1219 * @return 0 on success,
1220 * 1 if anything has gone wrong.
1221 */
Nico Huber454f6132012-12-10 13:34:10 +00001222static int write_by_layout(struct flashctx *const flashctx,
1223 void *const curcontents, const void *const newcontents)
Nico Huber7af0e792016-04-29 16:40:15 +02001224{
1225 struct walk_info info;
1226 info.curcontents = curcontents;
1227 info.newcontents = newcontents;
1228 return walk_by_layout(flashctx, &info, read_erase_write_block);
1229}
1230
1231/**
1232 * @brief Compares the included layout regions with content from a buffer.
1233 *
1234 * If there is no layout set in the given flash context, the whole chip's
1235 * contents will be compared.
1236 *
1237 * @param flashctx Flash context to be used.
Nico Huber74d09d42019-06-16 03:27:26 +02001238 * @param layout Flash layout information.
Nico Huber7af0e792016-04-29 16:40:15 +02001239 * @param curcontents A buffer of full chip size to read current chip contents into.
1240 * @param newcontents The new image to compare to.
1241 * @return 0 on success,
1242 * 1 if reading failed,
1243 * 3 if the contents don't match.
1244 */
Nico Huber74d09d42019-06-16 03:27:26 +02001245static int verify_by_layout(
1246 struct flashctx *const flashctx,
1247 const struct flashrom_layout *const layout,
1248 void *const curcontents, const uint8_t *const newcontents)
Nico Huber7af0e792016-04-29 16:40:15 +02001249{
Nico Huber5ca55232019-06-15 22:29:08 +02001250 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +02001251
Nico Huber5ca55232019-06-15 22:29:08 +02001252 while ((entry = layout_next_included(layout, entry))) {
1253 const chipoff_t region_start = entry->start;
1254 const chipsize_t region_len = entry->end - entry->start + 1;
Nico Huber7af0e792016-04-29 16:40:15 +02001255
1256 if (flashctx->chip->read(flashctx, curcontents + region_start, region_start, region_len))
1257 return 1;
1258 if (compare_range(newcontents + region_start, curcontents + region_start,
1259 region_start, region_len))
1260 return 3;
1261 }
1262 return 0;
1263}
1264
Stefan Tauner136388f2013-07-15 10:47:53 +00001265static void nonfatal_help_message(void)
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001266{
Stefan Taunera58f6e92014-05-10 09:25:44 +00001267 msg_gerr("Good, writing to the flash chip apparently didn't do anything.\n");
Stefan Tauner136388f2013-07-15 10:47:53 +00001268#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001269 if (programmer == &programmer_internal)
Stefan Tauner136388f2013-07-15 10:47:53 +00001270 msg_gerr("This means we have to add special support for your board, programmer or flash\n"
Nico Huberac90af62022-12-18 00:22:47 +00001271 "chip. Please report this to the mailing list at flashrom-stable@flashrom.org or\n"
1272 "on IRC (see https://www.flashrom.org/Contact for details), thanks!\n"
Stefan Tauner136388f2013-07-15 10:47:53 +00001273 "-------------------------------------------------------------------------------\n"
1274 "You may now reboot or simply leave the machine running.\n");
1275 else
1276#endif
1277 msg_gerr("Please check the connections (especially those to write protection pins) between\n"
1278 "the programmer and the flash chip. If you think the error is caused by flashrom\n"
Nico Huberac90af62022-12-18 00:22:47 +00001279 "please report this to the mailing list at flashrom-stable@flashrom.org or on IRC\n"
1280 "(see https://www.flashrom.org/Contact for details), thanks!\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001281}
1282
Edward O'Callaghanc72d20a2021-12-13 12:30:03 +11001283void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001284{
Stefan Tauner136388f2013-07-15 10:47:53 +00001285 msg_gerr("Your flash chip is in an unknown state.\n");
1286#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001287 if (programmer == &programmer_internal)
Angel Pons1900e1d2021-07-02 12:42:23 +02001288 msg_gerr("Get help on IRC (see https://www.flashrom.org/Contact) or mail\n"
Nico Huberac90af62022-12-18 00:22:47 +00001289 "flashrom-stable@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
Stefan Tauner136388f2013-07-15 10:47:53 +00001290 "-------------------------------------------------------------------------------\n"
1291 "DO NOT REBOOT OR POWEROFF!\n");
1292 else
1293#endif
Nico Huberac90af62022-12-18 00:22:47 +00001294 msg_gerr("Please report this to the mailing list at flashrom-stable@flashrom.org\n"
1295 "or on IRC (see https://www.flashrom.org/Contact for details), thanks!\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001296}
1297
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001298void list_programmers_linebreak(int startcol, int cols, int paren)
1299{
1300 const char *pname;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001301 int pnamelen;
1302 int remaining = 0, firstline = 1;
Thomas Heijligen9163b812021-06-01 14:25:01 +02001303 size_t p;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001304 int i;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001305
Thomas Heijligend45cb592021-05-19 14:12:18 +02001306 for (p = 0; p < programmer_table_size; p++) {
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001307 pname = programmer_table[p]->name;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001308 pnamelen = strlen(pname);
1309 if (remaining - pnamelen - 2 < 0) {
1310 if (firstline)
1311 firstline = 0;
1312 else
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001313 msg_ginfo("\n");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001314 for (i = 0; i < startcol; i++)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001315 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001316 remaining = cols - startcol;
1317 } else {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001318 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001319 remaining--;
1320 }
1321 if (paren && (p == 0)) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001322 msg_ginfo("(");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001323 remaining--;
1324 }
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001325 msg_ginfo("%s", pname);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001326 remaining -= pnamelen;
Thomas Heijligend45cb592021-05-19 14:12:18 +02001327 if (p < programmer_table_size - 1) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001328 msg_ginfo(",");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001329 remaining--;
1330 } else {
1331 if (paren)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001332 msg_ginfo(")");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001333 }
1334 }
1335}
1336
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001337int selfcheck(void)
1338{
Stefan Tauner96658be2014-05-26 22:05:31 +00001339 unsigned int i;
Stefan Taunera6d96482012-12-26 19:51:23 +00001340 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001341
Thomas Heijligend45cb592021-05-19 14:12:18 +02001342 for (i = 0; i < programmer_table_size; i++) {
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001343 const struct programmer_entry *const p = programmer_table[i];
1344 if (p == NULL) {
1345 msg_gerr("Programmer with index %d is NULL instead of a valid pointer!\n", i);
1346 ret = 1;
1347 continue;
1348 }
1349 if (p->name == NULL) {
Stefan Taunera6d96482012-12-26 19:51:23 +00001350 msg_gerr("All programmers need a valid name, but the one with index %d does not!\n", i);
1351 ret = 1;
1352 /* This might hide other problems with this programmer, but allows for better error
1353 * messages below without jumping through hoops. */
1354 continue;
1355 }
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001356 switch (p->type) {
Stefan Tauneraf358d62012-12-27 18:40:26 +00001357 case USB:
1358 case PCI:
1359 case OTHER:
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001360 if (p->devs.note == NULL) {
1361 if (strcmp("internal", p->name) == 0)
Stefan Tauneraf358d62012-12-27 18:40:26 +00001362 break; /* This one has its device list stored separately. */
1363 msg_gerr("Programmer %s has neither a device list nor a textual description!\n",
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001364 p->name);
Stefan Tauneraf358d62012-12-27 18:40:26 +00001365 ret = 1;
1366 }
1367 break;
1368 default:
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001369 msg_gerr("Programmer %s does not have a valid type set!\n", p->name);
Stefan Tauneraf358d62012-12-27 18:40:26 +00001370 ret = 1;
1371 break;
1372 }
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001373 if (p->init == NULL) {
1374 msg_gerr("Programmer %s does not have a valid init function!\n", p->name);
Stefan Taunera6d96482012-12-26 19:51:23 +00001375 ret = 1;
1376 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001377 }
Stefan Tauner96658be2014-05-26 22:05:31 +00001378
1379 /* It would be favorable if we could check for the correct layout (especially termination) of various
1380 * constant arrays: flashchips, chipset_enables, board_matches, boards_known, laptops_known.
1381 * They are all defined as externs in this compilation unit so we don't know their sizes which vary
1382 * depending on compiler flags, e.g. the target architecture, and can sometimes be 0.
1383 * For 'flashchips' we export the size explicitly to work around this and to be able to implement the
1384 * checks below. */
Stefan Tauner6697f712014-08-06 15:09:15 +00001385 if (flashchips_size <= 1 || flashchips[flashchips_size - 1].name != NULL) {
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001386 msg_gerr("Flashchips table miscompilation!\n");
1387 ret = 1;
Stefan Tauner96658be2014-05-26 22:05:31 +00001388 } else {
1389 for (i = 0; i < flashchips_size - 1; i++) {
1390 const struct flashchip *chip = &flashchips[i];
1391 if (chip->vendor == NULL || chip->name == NULL || chip->bustype == BUS_NONE) {
1392 ret = 1;
1393 msg_gerr("ERROR: Some field of flash chip #%d (%s) is misconfigured.\n"
Nico Huberac90af62022-12-18 00:22:47 +00001394 "Please report a bug at flashrom-stable@flashrom.org\n", i,
Stefan Tauner96658be2014-05-26 22:05:31 +00001395 chip->name == NULL ? "unnamed" : chip->name);
1396 }
1397 if (selfcheck_eraseblocks(chip)) {
1398 ret = 1;
1399 }
1400 }
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001401 }
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001402
Stefan Tauner600576b2014-06-12 22:57:36 +00001403#if CONFIG_INTERNAL == 1
1404 ret |= selfcheck_board_enables();
1405#endif
1406
Stefan Tauner96658be2014-05-26 22:05:31 +00001407 /* TODO: implement similar sanity checks for other arrays where deemed necessary. */
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001408 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001409}
1410
Edward O'Callaghanacb24d42021-04-15 13:44:39 +10001411/* FIXME: This function signature needs to be improved once prepare_flash_access()
1412 * has a better function signature.
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001413 */
Jacob Garberbeeb8bc2019-06-21 15:24:17 -06001414static int chip_safety_check(const struct flashctx *flash, int force,
1415 int read_it, int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001416{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001417 const struct flashchip *chip = flash->chip;
1418
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001419 if (!programmer_may_write && (write_it || erase_it)) {
1420 msg_perr("Write/erase is not working yet on your programmer in "
1421 "its current configuration.\n");
1422 /* --force is the wrong approach, but it's the best we can do
1423 * until the generic programmer parameter parser is merged.
1424 */
1425 if (!force)
1426 return 1;
1427 msg_cerr("Continuing anyway.\n");
1428 }
1429
1430 if (read_it || erase_it || write_it || verify_it) {
1431 /* Everything needs read. */
Stefan Tauner6455dff2014-05-26 00:36:24 +00001432 if (chip->tested.read == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001433 msg_cerr("Read is not working on this chip. ");
1434 if (!force)
1435 return 1;
1436 msg_cerr("Continuing anyway.\n");
1437 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001438 if (!chip->read) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001439 msg_cerr("flashrom has no read function for this "
1440 "flash chip.\n");
1441 return 1;
1442 }
1443 }
1444 if (erase_it || write_it) {
1445 /* Write needs erase. */
Stefan Tauner6455dff2014-05-26 00:36:24 +00001446 if (chip->tested.erase == NA) {
1447 msg_cerr("Erase is not possible on this chip.\n");
1448 return 1;
1449 }
1450 if (chip->tested.erase == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001451 msg_cerr("Erase is not working on this chip. ");
1452 if (!force)
1453 return 1;
1454 msg_cerr("Continuing anyway.\n");
1455 }
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001456 if(count_usable_erasers(flash) == 0) {
Stefan Tauner5368dca2011-07-01 00:19:12 +00001457 msg_cerr("flashrom has no erase function for this "
1458 "flash chip.\n");
1459 return 1;
1460 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001461 }
1462 if (write_it) {
Stefan Tauner6455dff2014-05-26 00:36:24 +00001463 if (chip->tested.write == NA) {
1464 msg_cerr("Write is not possible on this chip.\n");
1465 return 1;
1466 }
1467 if (chip->tested.write == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001468 msg_cerr("Write is not working on this chip. ");
1469 if (!force)
1470 return 1;
1471 msg_cerr("Continuing anyway.\n");
1472 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001473 if (!chip->write) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001474 msg_cerr("flashrom has no write function for this "
1475 "flash chip.\n");
1476 return 1;
1477 }
1478 }
1479 return 0;
1480}
1481
Nico Huber305f4172013-06-14 11:55:26 +02001482int prepare_flash_access(struct flashctx *const flash,
1483 const bool read_it, const bool write_it,
1484 const bool erase_it, const bool verify_it)
Nico Huber454f6132012-12-10 13:34:10 +00001485{
1486 if (chip_safety_check(flash, flash->flags.force, read_it, write_it, erase_it, verify_it)) {
1487 msg_cerr("Aborting.\n");
1488 return 1;
1489 }
1490
Nico Huber3ac761c2023-01-16 02:43:17 +01001491 if (layout_sanity_checks(flash, write_it)) {
Nico Huber454f6132012-12-10 13:34:10 +00001492 msg_cerr("Requested regions can not be handled. Aborting.\n");
1493 return 1;
1494 }
1495
1496 if (map_flash(flash) != 0)
1497 return 1;
1498
Nikolai Artemiev4ad48642020-11-05 13:54:27 +11001499 /* Initialize chip_restore_fn_count before chip unlock calls. */
1500 flash->chip_restore_fn_count = 0;
1501
Nico Huber454f6132012-12-10 13:34:10 +00001502 /* Given the existence of read locks, we want to unlock for read,
1503 erase and write. */
1504 if (flash->chip->unlock)
1505 flash->chip->unlock(flash);
1506
Nico Huberf43c6542017-10-14 17:47:28 +02001507 flash->address_high_byte = -1;
1508 flash->in_4ba_mode = false;
1509
Nico Huberdc5af542018-12-22 16:54:59 +01001510 /* Be careful about 4BA chips and broken masters */
1511 if (flash->chip->total_size > 16 * 1024 && spi_master_no_4ba_modes(flash)) {
1512 /* If we can't use native instructions, bail out */
1513 if ((flash->chip->feature_bits & FEATURE_4BA_NATIVE) != FEATURE_4BA_NATIVE
1514 || !spi_master_4ba(flash)) {
1515 msg_cerr("Programmer doesn't support this chip. Aborting.\n");
1516 return 1;
1517 }
1518 }
1519
Ed Swierkcc20a9b2017-07-03 13:17:18 -07001520 /* Enable/disable 4-byte addressing mode if flash chip supports it */
Nico Huber86bddb52018-03-13 18:14:52 +01001521 if (flash->chip->feature_bits & (FEATURE_4BA_ENTER | FEATURE_4BA_ENTER_WREN | FEATURE_4BA_ENTER_EAR7)) {
Nico Huberfe34d2a2017-11-10 21:10:20 +01001522 int ret;
1523 if (spi_master_4ba(flash))
1524 ret = spi_enter_4ba(flash);
1525 else
1526 ret = spi_exit_4ba(flash);
1527 if (ret) {
1528 msg_cerr("Failed to set correct 4BA mode! Aborting.\n");
Ed Swierkcc20a9b2017-07-03 13:17:18 -07001529 return 1;
Boris Baykov7fe85692016-06-11 18:29:03 +02001530 }
Boris Baykov99127182016-06-11 18:29:00 +02001531 }
1532
Nico Huber454f6132012-12-10 13:34:10 +00001533 return 0;
1534}
1535
Nico Huber305f4172013-06-14 11:55:26 +02001536void finalize_flash_access(struct flashctx *const flash)
Nico Huber454f6132012-12-10 13:34:10 +00001537{
Nikolai Artemiev4ad48642020-11-05 13:54:27 +11001538 deregister_chip_restore(flash);
Nico Huber454f6132012-12-10 13:34:10 +00001539 unmap_flash(flash);
1540}
1541
1542/**
1543 * @addtogroup flashrom-flash
1544 * @{
1545 */
1546
1547/**
1548 * @brief Erase the specified ROM chip.
1549 *
1550 * If a layout is set in the given flash context, only included regions
1551 * will be erased.
1552 *
1553 * @param flashctx The context of the flash chip to erase.
1554 * @return 0 on success.
1555 */
1556int flashrom_flash_erase(struct flashctx *const flashctx)
1557{
1558 if (prepare_flash_access(flashctx, false, false, true, false))
1559 return 1;
1560
1561 const int ret = erase_by_layout(flashctx);
1562
1563 finalize_flash_access(flashctx);
1564
1565 return ret;
1566}
1567
1568/** @} */ /* end flashrom-flash */
1569
1570/**
1571 * @defgroup flashrom-ops Operations
1572 * @{
1573 */
1574
1575/**
1576 * @brief Read the current image from the specified ROM chip.
1577 *
1578 * If a layout is set in the specified flash context, only included regions
1579 * will be read.
1580 *
1581 * @param flashctx The context of the flash chip.
1582 * @param buffer Target buffer to write image to.
1583 * @param buffer_len Size of target buffer in bytes.
1584 * @return 0 on success,
1585 * 2 if buffer_len is too short for the flash chip's contents,
1586 * or 1 on any other failure.
1587 */
1588int flashrom_image_read(struct flashctx *const flashctx, void *const buffer, const size_t buffer_len)
1589{
1590 const size_t flash_size = flashctx->chip->total_size * 1024;
1591
1592 if (flash_size > buffer_len)
1593 return 2;
1594
1595 if (prepare_flash_access(flashctx, true, false, false, false))
1596 return 1;
1597
1598 msg_cinfo("Reading flash... ");
1599
1600 int ret = 1;
1601 if (read_by_layout(flashctx, buffer)) {
1602 msg_cerr("Read operation failed!\n");
1603 msg_cinfo("FAILED.\n");
1604 goto _finalize_ret;
1605 }
1606 msg_cinfo("done.\n");
1607 ret = 0;
1608
1609_finalize_ret:
1610 finalize_flash_access(flashctx);
1611 return ret;
1612}
1613
1614static void combine_image_by_layout(const struct flashctx *const flashctx,
1615 uint8_t *const newcontents, const uint8_t *const oldcontents)
1616{
1617 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber3d7b1e32018-12-22 00:53:14 +01001618 const struct romentry *included;
1619 chipoff_t start = 0;
Nico Huber454f6132012-12-10 13:34:10 +00001620
Nico Huber3d7b1e32018-12-22 00:53:14 +01001621 while ((included = layout_next_included_region(layout, start))) {
1622 if (included->start > start) {
1623 /* copy everything up to the start of this included region */
1624 memcpy(newcontents + start, oldcontents + start, included->start - start);
1625 }
1626 /* skip this included region */
1627 start = included->end + 1;
1628 if (start == 0)
1629 return;
Nico Huber454f6132012-12-10 13:34:10 +00001630 }
Nico Huber3d7b1e32018-12-22 00:53:14 +01001631
1632 /* copy the rest of the chip */
1633 const chipsize_t copy_len = flashctx->chip->total_size * 1024 - start;
1634 memcpy(newcontents + start, oldcontents + start, copy_len);
Nico Huber454f6132012-12-10 13:34:10 +00001635}
1636
1637/**
1638 * @brief Write the specified image to the ROM chip.
1639 *
1640 * If a layout is set in the specified flash context, only erase blocks
1641 * containing included regions will be touched.
1642 *
1643 * @param flashctx The context of the flash chip.
Nico Huber1b172f22017-06-19 12:35:24 +02001644 * @param buffer Source buffer to read image from (may be altered for full verification).
Nico Huber454f6132012-12-10 13:34:10 +00001645 * @param buffer_len Size of source buffer in bytes.
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001646 * @param refbuffer If given, assume flash chip contains same data as `refbuffer`.
Nico Huber454f6132012-12-10 13:34:10 +00001647 * @return 0 on success,
1648 * 4 if buffer_len doesn't match the size of the flash chip,
1649 * 3 if write was tried but nothing has changed,
1650 * 2 if write failed and flash contents changed,
1651 * or 1 on any other failure.
1652 */
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001653int flashrom_image_write(struct flashctx *const flashctx, void *const buffer, const size_t buffer_len,
1654 const void *const refbuffer)
Nico Huber454f6132012-12-10 13:34:10 +00001655{
1656 const size_t flash_size = flashctx->chip->total_size * 1024;
1657 const bool verify_all = flashctx->flags.verify_whole_chip;
1658 const bool verify = flashctx->flags.verify_after_write;
Nico Huber74d09d42019-06-16 03:27:26 +02001659 const struct flashrom_layout *const verify_layout =
1660 verify_all ? get_default_layout(flashctx) : get_layout(flashctx);
Nico Huber454f6132012-12-10 13:34:10 +00001661
1662 if (buffer_len != flash_size)
1663 return 4;
1664
1665 int ret = 1;
1666
1667 uint8_t *const newcontents = buffer;
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001668 const uint8_t *const refcontents = refbuffer;
Nico Huber454f6132012-12-10 13:34:10 +00001669 uint8_t *const curcontents = malloc(flash_size);
1670 uint8_t *oldcontents = NULL;
1671 if (verify_all)
1672 oldcontents = malloc(flash_size);
1673 if (!curcontents || (verify_all && !oldcontents)) {
1674 msg_gerr("Out of memory!\n");
1675 goto _free_ret;
1676 }
1677
1678#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001679 if (programmer == &programmer_internal && cb_check_image(newcontents, flash_size) < 0) {
Nico Huber454f6132012-12-10 13:34:10 +00001680 if (flashctx->flags.force_boardmismatch) {
1681 msg_pinfo("Proceeding anyway because user forced us to.\n");
1682 } else {
1683 msg_perr("Aborting. You can override this with "
1684 "-p internal:boardmismatch=force.\n");
1685 goto _free_ret;
1686 }
1687 }
1688#endif
1689
1690 if (prepare_flash_access(flashctx, false, true, false, verify))
1691 goto _free_ret;
1692
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001693 /* If given, assume flash chip contains same data as `refcontents`. */
1694 if (refcontents) {
1695 msg_cinfo("Assuming old flash chip contents as ref-file...\n");
1696 memcpy(curcontents, refcontents, flash_size);
1697 if (oldcontents)
1698 memcpy(oldcontents, refcontents, flash_size);
Nico Huber454f6132012-12-10 13:34:10 +00001699 } else {
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001700 /*
1701 * Read the whole chip to be able to check whether regions need to be
1702 * erased and to give better diagnostics in case write fails.
1703 * The alternative is to read only the regions which are to be
1704 * preserved, but in that case we might perform unneeded erase which
1705 * takes time as well.
1706 */
1707 msg_cinfo("Reading old flash chip contents... ");
1708 if (verify_all) {
1709 if (flashctx->chip->read(flashctx, oldcontents, 0, flash_size)) {
1710 msg_cinfo("FAILED.\n");
1711 goto _finalize_ret;
1712 }
1713 memcpy(curcontents, oldcontents, flash_size);
1714 } else {
1715 if (read_by_layout(flashctx, curcontents)) {
1716 msg_cinfo("FAILED.\n");
1717 goto _finalize_ret;
1718 }
Nico Huber454f6132012-12-10 13:34:10 +00001719 }
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001720 msg_cinfo("done.\n");
Nico Huber454f6132012-12-10 13:34:10 +00001721 }
Nico Huber454f6132012-12-10 13:34:10 +00001722
1723 if (write_by_layout(flashctx, curcontents, newcontents)) {
1724 msg_cerr("Uh oh. Erase/write failed. ");
1725 ret = 2;
1726 if (verify_all) {
1727 msg_cerr("Checking if anything has changed.\n");
1728 msg_cinfo("Reading current flash chip contents... ");
1729 if (!flashctx->chip->read(flashctx, curcontents, 0, flash_size)) {
1730 msg_cinfo("done.\n");
1731 if (!memcmp(oldcontents, curcontents, flash_size)) {
1732 nonfatal_help_message();
1733 goto _finalize_ret;
1734 }
1735 msg_cerr("Apparently at least some data has changed.\n");
1736 } else
1737 msg_cerr("Can't even read anymore!\n");
1738 emergency_help_message();
1739 goto _finalize_ret;
1740 } else {
1741 msg_cerr("\n");
1742 }
1743 emergency_help_message();
1744 goto _finalize_ret;
1745 }
1746
1747 /* Verify only if we actually changed something. */
1748 if (verify && !all_skipped) {
Nico Huber454f6132012-12-10 13:34:10 +00001749 msg_cinfo("Verifying flash... ");
1750
1751 /* Work around chips which need some time to calm down. */
1752 programmer_delay(1000*1000);
1753
Nico Huber74d09d42019-06-16 03:27:26 +02001754 if (verify_all)
Nico Huber454f6132012-12-10 13:34:10 +00001755 combine_image_by_layout(flashctx, newcontents, oldcontents);
Nico Huber74d09d42019-06-16 03:27:26 +02001756 ret = verify_by_layout(flashctx, verify_layout, curcontents, newcontents);
Nico Huber454f6132012-12-10 13:34:10 +00001757 /* If we tried to write, and verification now fails, we
1758 might have an emergency situation. */
1759 if (ret)
1760 emergency_help_message();
1761 else
1762 msg_cinfo("VERIFIED.\n");
1763 } else {
1764 /* We didn't change anything. */
1765 ret = 0;
1766 }
1767
1768_finalize_ret:
1769 finalize_flash_access(flashctx);
1770_free_ret:
1771 free(oldcontents);
1772 free(curcontents);
1773 return ret;
1774}
1775
1776/**
1777 * @brief Verify the ROM chip's contents with the specified image.
1778 *
1779 * If a layout is set in the specified flash context, only included regions
1780 * will be verified.
1781 *
1782 * @param flashctx The context of the flash chip.
1783 * @param buffer Source buffer to verify with.
1784 * @param buffer_len Size of source buffer in bytes.
1785 * @return 0 on success,
1786 * 3 if the chip's contents don't match,
1787 * 2 if buffer_len doesn't match the size of the flash chip,
1788 * or 1 on any other failure.
1789 */
1790int flashrom_image_verify(struct flashctx *const flashctx, const void *const buffer, const size_t buffer_len)
1791{
Nico Huber74d09d42019-06-16 03:27:26 +02001792 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber454f6132012-12-10 13:34:10 +00001793 const size_t flash_size = flashctx->chip->total_size * 1024;
1794
1795 if (buffer_len != flash_size)
1796 return 2;
1797
1798 const uint8_t *const newcontents = buffer;
1799 uint8_t *const curcontents = malloc(flash_size);
1800 if (!curcontents) {
1801 msg_gerr("Out of memory!\n");
1802 return 1;
1803 }
1804
1805 int ret = 1;
1806
1807 if (prepare_flash_access(flashctx, false, false, false, true))
1808 goto _free_ret;
1809
1810 msg_cinfo("Verifying flash... ");
Nico Huber74d09d42019-06-16 03:27:26 +02001811 ret = verify_by_layout(flashctx, layout, curcontents, newcontents);
Nico Huber454f6132012-12-10 13:34:10 +00001812 if (!ret)
1813 msg_cinfo("VERIFIED.\n");
1814
1815 finalize_flash_access(flashctx);
1816_free_ret:
1817 free(curcontents);
1818 return ret;
1819}
1820
1821/** @} */ /* end flashrom-ops */