blob: d65cf9f328cb493985e7dc2a8023f4d6b1ab303e [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
Stefan Tauner02437452013-04-01 19:34:53 +0000404/* Helper function for need_erase() that focuses on granularities of gran bytes. */
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300405static int need_erase_gran_bytes(const uint8_t *have, const uint8_t *want, unsigned int len,
406 unsigned int gran, const uint8_t erased_value)
Stefan Tauner02437452013-04-01 19:34:53 +0000407{
408 unsigned int i, j, limit;
409 for (j = 0; j < len / gran; j++) {
410 limit = min (gran, len - j * gran);
411 /* Are 'have' and 'want' identical? */
412 if (!memcmp(have + j * gran, want + j * gran, limit))
413 continue;
414 /* have needs to be in erased state. */
415 for (i = 0; i < limit; i++)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300416 if (have[j * gran + i] != erased_value)
Stefan Tauner02437452013-04-01 19:34:53 +0000417 return 1;
418 }
419 return 0;
420}
421
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000422/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000423 * Check if the buffer @have can be programmed to the content of @want without
424 * erasing. This is only possible if all chunks of size @gran are either kept
425 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000426 *
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000427 * Warning: This function assumes that @have and @want point to naturally
428 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000429 *
430 * @have buffer with current content
431 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000432 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000433 * @gran write granularity (enum, not count)
434 * @return 0 if no erase is needed, 1 otherwise
435 */
Edward O'Callaghana1805092022-05-16 11:10:36 +1000436static int need_erase(const uint8_t *have, const uint8_t *want, unsigned int len,
437 enum write_granularity gran, const uint8_t erased_value)
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000438{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000439 int result = 0;
Stefan Tauner02437452013-04-01 19:34:53 +0000440 unsigned int i;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000441
442 switch (gran) {
443 case write_gran_1bit:
444 for (i = 0; i < len; i++)
445 if ((have[i] & want[i]) != want[i]) {
446 result = 1;
447 break;
448 }
449 break;
450 case write_gran_1byte:
451 for (i = 0; i < len; i++)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300452 if ((have[i] != want[i]) && (have[i] != erased_value)) {
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000453 result = 1;
454 break;
455 }
456 break;
Paul Kocialkowskic8305e12015-10-16 02:16:20 +0000457 case write_gran_128bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300458 result = need_erase_gran_bytes(have, want, len, 128, erased_value);
Paul Kocialkowskic8305e12015-10-16 02:16:20 +0000459 break;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000460 case write_gran_256bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300461 result = need_erase_gran_bytes(have, want, len, 256, erased_value);
Stefan Tauner02437452013-04-01 19:34:53 +0000462 break;
463 case write_gran_264bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300464 result = need_erase_gran_bytes(have, want, len, 264, erased_value);
Stefan Tauner02437452013-04-01 19:34:53 +0000465 break;
466 case write_gran_512bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300467 result = need_erase_gran_bytes(have, want, len, 512, erased_value);
Stefan Tauner02437452013-04-01 19:34:53 +0000468 break;
469 case write_gran_528bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300470 result = need_erase_gran_bytes(have, want, len, 528, erased_value);
Stefan Tauner02437452013-04-01 19:34:53 +0000471 break;
472 case write_gran_1024bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300473 result = need_erase_gran_bytes(have, want, len, 1024, erased_value);
Stefan Tauner02437452013-04-01 19:34:53 +0000474 break;
475 case write_gran_1056bytes:
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300476 result = need_erase_gran_bytes(have, want, len, 1056, erased_value);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000477 break;
Carl-Daniel Hailfinger1b0e9fc2014-06-16 22:36:17 +0000478 case write_gran_1byte_implicit_erase:
479 /* Do not erase, handle content changes from anything->0xff by writing 0xff. */
480 result = 0;
481 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000482 default:
483 msg_cerr("%s: Unsupported granularity! Please report a bug at "
Nico Huberac90af62022-12-18 00:22:47 +0000484 "flashrom-stable@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000485 }
486 return result;
487}
488
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000489/**
490 * Check if the buffer @have needs to be programmed to get the content of @want.
491 * If yes, return 1 and fill in first_start with the start address of the
492 * write operation and first_len with the length of the first to-be-written
493 * chunk. If not, return 0 and leave first_start and first_len undefined.
494 *
495 * Warning: This function assumes that @have and @want point to naturally
496 * aligned regions.
497 *
498 * @have buffer with current content
499 * @want buffer with desired content
500 * @len length of the checked area
501 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000502 * @first_start offset of the first byte which needs to be written (passed in
503 * value is increased by the offset of the first needed write
504 * relative to have/want or unchanged if no write is needed)
505 * @return length of the first contiguous area which needs to be written
506 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000507 *
508 * FIXME: This function needs a parameter which tells it about coalescing
509 * in relation to the max write length of the programmer and the max write
510 * length of the chip.
511 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000512static unsigned int get_next_write(const uint8_t *have, const uint8_t *want, unsigned int len,
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000513 unsigned int *first_start,
514 enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000515{
Felix Singerf25447e2022-08-19 02:44:28 +0200516 bool need_write = false;
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000517 unsigned int rel_start = 0, first_len = 0;
518 unsigned int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000519
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000520 switch (gran) {
521 case write_gran_1bit:
522 case write_gran_1byte:
Carl-Daniel Hailfinger1b0e9fc2014-06-16 22:36:17 +0000523 case write_gran_1byte_implicit_erase:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000524 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000525 break;
Paul Kocialkowskic8305e12015-10-16 02:16:20 +0000526 case write_gran_128bytes:
527 stride = 128;
528 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000529 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000530 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000531 break;
Stefan Tauner02437452013-04-01 19:34:53 +0000532 case write_gran_264bytes:
533 stride = 264;
534 break;
535 case write_gran_512bytes:
536 stride = 512;
537 break;
538 case write_gran_528bytes:
539 stride = 528;
540 break;
541 case write_gran_1024bytes:
542 stride = 1024;
543 break;
544 case write_gran_1056bytes:
545 stride = 1056;
546 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000547 default:
548 msg_cerr("%s: Unsupported granularity! Please report a bug at "
Nico Huberac90af62022-12-18 00:22:47 +0000549 "flashrom-stable@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000550 /* Claim that no write was needed. A write with unknown
551 * granularity is too dangerous to try.
552 */
553 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000554 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000555 for (i = 0; i < len / stride; i++) {
556 limit = min(stride, len - i * stride);
557 /* Are 'have' and 'want' identical? */
558 if (memcmp(have + i * stride, want + i * stride, limit)) {
559 if (!need_write) {
560 /* First location where have and want differ. */
Felix Singerf25447e2022-08-19 02:44:28 +0200561 need_write = true;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000562 rel_start = i * stride;
563 }
564 } else {
565 if (need_write) {
566 /* First location where have and want
567 * do not differ anymore.
568 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000569 break;
570 }
571 }
572 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000573 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000574 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000575 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000576 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000577}
578
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000579void unmap_flash(struct flashctx *flash)
580{
581 if (flash->virtual_registers != (chipaddr)ERROR_PTR) {
582 programmer_unmap_flash_region((void *)flash->virtual_registers, flash->chip->total_size * 1024);
583 flash->physical_registers = 0;
584 flash->virtual_registers = (chipaddr)ERROR_PTR;
585 }
586
587 if (flash->virtual_memory != (chipaddr)ERROR_PTR) {
588 programmer_unmap_flash_region((void *)flash->virtual_memory, flash->chip->total_size * 1024);
589 flash->physical_memory = 0;
590 flash->virtual_memory = (chipaddr)ERROR_PTR;
591 }
592}
593
594int map_flash(struct flashctx *flash)
595{
596 /* Init pointers to the fail-safe state to distinguish them later from legit values. */
597 flash->virtual_memory = (chipaddr)ERROR_PTR;
598 flash->virtual_registers = (chipaddr)ERROR_PTR;
599
600 /* FIXME: This avoids mapping (and unmapping) of flash chip definitions with size 0.
601 * These are used for various probing-related hacks that would not map successfully anyway and should be
602 * removed ASAP. */
603 if (flash->chip->total_size == 0)
604 return 0;
605
606 const chipsize_t size = flash->chip->total_size * 1024;
607 uintptr_t base = flashbase ? flashbase : (0xffffffff - size + 1);
608 void *addr = programmer_map_flash_region(flash->chip->name, base, size);
609 if (addr == ERROR_PTR) {
610 msg_perr("Could not map flash chip %s at 0x%0*" PRIxPTR ".\n",
611 flash->chip->name, PRIxPTR_WIDTH, base);
612 return 1;
613 }
614 flash->physical_memory = base;
615 flash->virtual_memory = (chipaddr)addr;
616
617 /* FIXME: Special function registers normally live 4 MByte below flash space, but it might be somewhere
618 * completely different on some chips and programmers, or not mappable at all.
619 * Ignore these problems for now and always report success. */
620 if (flash->chip->feature_bits & FEATURE_REGISTERMAP) {
621 base = 0xffffffff - size - 0x400000 + 1;
622 addr = programmer_map_flash_region("flash chip registers", base, size);
623 if (addr == ERROR_PTR) {
624 msg_pdbg2("Could not map flash chip registers %s at 0x%0*" PRIxPTR ".\n",
625 flash->chip->name, PRIxPTR_WIDTH, base);
626 return 0;
627 }
628 flash->physical_registers = base;
629 flash->virtual_registers = (chipaddr)addr;
630 }
631 return 0;
632}
633
Nico Huber2d625722016-05-03 10:48:02 +0200634/*
635 * Return a string corresponding to the bustype parameter.
636 * Memory is obtained with malloc() and must be freed with free() by the caller.
637 */
638char *flashbuses_to_text(enum chipbustype bustype)
639{
640 char *ret = calloc(1, 1);
641 /*
642 * FIXME: Once all chipsets and flash chips have been updated, NONSPI
643 * will cease to exist and should be eliminated here as well.
644 */
645 if (bustype == BUS_NONSPI) {
646 ret = strcat_realloc(ret, "Non-SPI, ");
647 } else {
648 if (bustype & BUS_PARALLEL)
649 ret = strcat_realloc(ret, "Parallel, ");
650 if (bustype & BUS_LPC)
651 ret = strcat_realloc(ret, "LPC, ");
652 if (bustype & BUS_FWH)
653 ret = strcat_realloc(ret, "FWH, ");
654 if (bustype & BUS_SPI)
655 ret = strcat_realloc(ret, "SPI, ");
656 if (bustype & BUS_PROG)
657 ret = strcat_realloc(ret, "Programmer-specific, ");
658 if (bustype == BUS_NONE)
659 ret = strcat_realloc(ret, "None, ");
660 }
661 /* Kill last comma. */
662 ret[strlen(ret) - 2] = '\0';
663 ret = realloc(ret, strlen(ret) + 1);
664 return ret;
665}
666
Edward O'Callaghan00ea3892022-10-11 21:27:37 +1100667static int init_default_layout(struct flashctx *flash)
668{
669 /* Fill default layout covering the whole chip. */
670 if (flashrom_layout_new(&flash->default_layout) ||
671 flashrom_layout_add_region(flash->default_layout,
672 0, flash->chip->total_size * 1024 - 1, "complete flash") ||
673 flashrom_layout_include_region(flash->default_layout, "complete flash"))
674 return -1;
675 return 0;
676}
677
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000678int probe_flash(struct registered_master *mst, int startchip, struct flashctx *flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000679{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000680 const struct flashchip *chip;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000681 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000682 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000683
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000684 for (chip = flashchips + startchip; chip && chip->name; chip++) {
685 if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +0000686 continue;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000687 buses_common = mst->buses_supported & chip->bustype;
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000688 if (!buses_common)
Carl-Daniel Hailfinger6573b742011-06-17 22:38:53 +0000689 continue;
Mike Banon31b5e3b2018-01-15 01:10:00 +0300690 /* Only probe for SPI25 chips by default. */
691 if (chip->bustype == BUS_SPI && !chip_to_probe && chip->spi_cmd_set != SPI25)
692 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000693 msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
694 if (!chip->probe && !force) {
695 msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000696 continue;
697 }
Stefan Reinauer70385642007-04-06 11:58:03 +0000698
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000699 /* Start filling in the dynamic data. */
Angel Pons690a9442021-06-07 12:33:53 +0200700 flash->chip = calloc(1, sizeof(*flash->chip));
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000701 if (!flash->chip) {
702 msg_gerr("Out of memory!\n");
Edward O'Callaghan6edf9f82022-11-12 12:08:46 +1100703 return -1;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000704 }
Angel Pons7e134562021-06-07 13:29:13 +0200705 *flash->chip = *chip;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000706 flash->mst = mst;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000707
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000708 if (map_flash(flash) != 0)
Martin Schiller57a3b732017-11-23 06:24:57 +0100709 goto notfound;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000710
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000711 /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
712 * is only called with force=1 after normal probing failed.
713 */
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000714 if (force)
715 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +0000716
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000717 if (flash->chip->probe(flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +0000718 goto notfound;
719
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000720 /* If this is the first chip found, accept it.
721 * If this is not the first chip found, accept it only if it is
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000722 * a non-generic match. SFDP and CFI are generic matches.
723 * startchip==0 means this call to probe_flash() is the first
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000724 * one for this programmer interface (master) and thus no other chip has
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000725 * been found on this interface.
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000726 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000727 if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000728 msg_cinfo("===\n"
729 "SFDP has autodetected a flash chip which is "
730 "not natively supported by flashrom yet.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000731 if (count_usable_erasers(flash) == 0)
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000732 msg_cinfo("The standard operations read and "
733 "verify should work, but to support "
734 "erase, write and all other "
735 "possible features");
736 else
737 msg_cinfo("All standard operations (read, "
738 "verify, erase and write) should "
739 "work, but to support all possible "
740 "features");
741
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000742 msg_cinfo(" we need to add them manually.\n"
743 "You can help us by mailing us the output of the following command to "
Nico Huberac90af62022-12-18 00:22:47 +0000744 "flashrom-stable@flashrom.org:\n"
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000745 "'flashrom -VV [plus the -p/--programmer parameter]'\n"
746 "Thanks for your help!\n"
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000747 "===\n");
748 }
749
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000750 /* First flash chip detected on this bus. */
751 if (startchip == 0)
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000752 break;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000753 /* Not the first flash chip detected on this bus, but not a generic match either. */
754 if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
755 break;
756 /* 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 +0000757notfound:
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000758 unmap_flash(flash);
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000759 free(flash->chip);
760 flash->chip = NULL;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000761 }
Uwe Hermannffec5f32007-08-23 16:08:21 +0000762
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000763 if (!flash->chip)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000764 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000765
Edward O'Callaghan00ea3892022-10-11 21:27:37 +1100766 if (init_default_layout(flash) < 0)
767 return -1;
Stefan Reinauer051e2362011-01-19 06:21:54 +0000768
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000769 tmp = flashbuses_to_text(flash->chip->bustype);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000770 msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) ", force ? "Assuming" : "Found",
771 flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp);
Stefan Tauner00155492011-06-26 20:45:35 +0000772 free(tmp);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000773#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +0200774 if (programmer->map_flash_region == physmap)
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000775 msg_cinfo("mapped at physical address 0x%0*" PRIxPTR ".\n",
776 PRIxPTR_WIDTH, flash->physical_memory);
777 else
778#endif
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +0200779 msg_cinfo("on %s.\n", programmer->name);
Uwe Hermann9899cad2009-06-28 21:47:57 +0000780
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000781 /* Flash registers may more likely not be mapped if the chip was forced.
782 * Lock info may be stored in registers, so avoid lock info printing. */
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +0000783 if (!force)
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000784 if (flash->chip->printlock)
785 flash->chip->printlock(flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +0000786
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000787 /* Get out of the way for later runs. */
788 unmap_flash(flash);
789
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000790 /* Return position of matching chip. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000791 return chip - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000792}
793
Stefan Tauner96658be2014-05-26 22:05:31 +0000794/* Even if an error is found, the function will keep going and check the rest. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000795static int selfcheck_eraseblocks(const struct flashchip *chip)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000796{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000797 int i, j, k;
798 int ret = 0;
Aarya Chaumal478e1792022-06-04 01:34:44 +0530799 unsigned int prev_eraseblock_count = chip->total_size * 1024;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000800
801 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
802 unsigned int done = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000803 struct block_eraser eraser = chip->block_erasers[k];
Aarya Chaumal478e1792022-06-04 01:34:44 +0530804 unsigned int curr_eraseblock_count = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000805
806 for (i = 0; i < NUM_ERASEREGIONS; i++) {
807 /* Blocks with zero size are bugs in flashchips.c. */
808 if (eraser.eraseblocks[i].count &&
809 !eraser.eraseblocks[i].size) {
Nico Huberac90af62022-12-18 00:22:47 +0000810 msg_gerr("ERROR: Flash chip %s erase function %i region %i has size 0.\n"
811 "Please report a bug at flashrom-stable@flashrom.org\n",
812 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000813 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000814 }
815 /* Blocks with zero count are bugs in flashchips.c. */
816 if (!eraser.eraseblocks[i].count &&
817 eraser.eraseblocks[i].size) {
Nico Huberac90af62022-12-18 00:22:47 +0000818 msg_gerr("ERROR: Flash chip %s erase function %i region %i has count 0.\n"
819 "Please report a bug at flashrom-stable@flashrom.org\n",
820 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000821 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000822 }
823 done += eraser.eraseblocks[i].count *
824 eraser.eraseblocks[i].size;
Aarya Chaumal478e1792022-06-04 01:34:44 +0530825 curr_eraseblock_count += eraser.eraseblocks[i].count;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000826 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000827 /* Empty eraseblock definition with erase function. */
828 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +0000829 msg_gspew("Strange: Empty eraseblock definition with "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000830 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000831 if (!done)
832 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000833 if (done != chip->total_size * 1024) {
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000834 msg_gerr("ERROR: Flash chip %s erase function %i "
835 "region walking resulted in 0x%06x bytes total,"
Nico Huberac90af62022-12-18 00:22:47 +0000836 " expected 0x%06x bytes.\n"
837 "Please report a bug at flashrom-stable@flashrom.org\n",
838 chip->name, k, done, chip->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000839 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000840 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000841 if (!eraser.block_erase)
842 continue;
843 /* Check if there are identical erase functions for different
844 * layouts. That would imply "magic" erase functions. The
845 * easiest way to check this is with function pointers.
846 */
Uwe Hermann43959702010-03-13 17:28:29 +0000847 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000848 if (eraser.block_erase ==
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000849 chip->block_erasers[j].block_erase) {
Nico Huberac90af62022-12-18 00:22:47 +0000850 msg_gerr("ERROR: Flash chip %s erase function %i and %i are identical.\n"
851 "Please report a bug at flashrom-stable@flashrom.org\n",
852 chip->name, k, j);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000853 ret = 1;
854 }
Uwe Hermann43959702010-03-13 17:28:29 +0000855 }
Aarya Chaumal478e1792022-06-04 01:34:44 +0530856 if(curr_eraseblock_count > prev_eraseblock_count)
857 {
Nico Huberac90af62022-12-18 00:22:47 +0000858 msg_gerr("ERROR: Flash chip %s erase function %i is not in order.\n"
859 "Please report a bug at flashrom-stable@flashrom.org\n",
860 chip->name, k);
Aarya Chaumal478e1792022-06-04 01:34:44 +0530861 ret = 1;
862 }
863 prev_eraseblock_count = curr_eraseblock_count;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000864 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +0000865 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +0000866}
867
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000868static int check_block_eraser(const struct flashctx *flash, int k, int log)
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000869{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000870 struct block_eraser eraser = flash->chip->block_erasers[k];
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000871
872 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
873 if (log)
874 msg_cdbg("not defined. ");
875 return 1;
876 }
877 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
878 if (log)
879 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000880 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000881 return 1;
882 }
883 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
884 if (log)
885 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000886 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000887 return 1;
888 }
Aarya Chaumal6d98aec2022-08-14 23:16:44 +0530889
890 if (flash->chip->bustype == BUS_SPI) {
891 const uint8_t *opcode = spi_get_opcode_from_erasefn(eraser.block_erase);
892 for (int i = 0; opcode[i]; i++) {
893 if (!flash->mst->spi.probe_opcode(flash, opcode[i])) {
894 if (log)
895 msg_cdbg("block erase function and layout found "
896 "but SPI master doesn't support the function. ");
897 return 1;
898 }
899 }
900 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000901 // TODO: Once erase functions are annotated with allowed buses, check that as well.
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +0000902 return 0;
903}
904
Nico Huber7af0e792016-04-29 16:40:15 +0200905/**
906 * @brief Reads the included layout regions into a buffer.
907 *
908 * If there is no layout set in the given flash context, the whole chip will
909 * be read.
910 *
911 * @param flashctx Flash context to be used.
912 * @param buffer Buffer of full chip size to read into.
913 * @return 0 on success,
914 * 1 if any read fails.
915 */
916static int read_by_layout(struct flashctx *const flashctx, uint8_t *const buffer)
917{
918 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber5ca55232019-06-15 22:29:08 +0200919 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +0200920
Nico Huber5ca55232019-06-15 22:29:08 +0200921 while ((entry = layout_next_included(layout, entry))) {
922 const chipoff_t region_start = entry->start;
923 const chipsize_t region_len = entry->end - entry->start + 1;
Nico Huber7af0e792016-04-29 16:40:15 +0200924
925 if (flashctx->chip->read(flashctx, buffer + region_start, region_start, region_len))
926 return 1;
927 }
928 return 0;
929}
930
931typedef int (*erasefn_t)(struct flashctx *, unsigned int addr, unsigned int len);
932/**
933 * @private
934 *
935 * For read-erase-write, `curcontents` and `newcontents` shall point
936 * to buffers of the chip's size. Both are supposed to be prefilled
937 * with at least the included layout regions of the current flash
938 * contents (`curcontents`) and the data to be written to the flash
939 * (`newcontents`).
940 *
941 * For erase, `curcontents` and `newcontents` shall be NULL-pointers.
942 *
943 * The `chipoff_t` values are used internally by `walk_by_layout()`.
944 */
945struct walk_info {
946 uint8_t *curcontents;
947 const uint8_t *newcontents;
948 chipoff_t region_start;
949 chipoff_t region_end;
950 chipoff_t erase_start;
951 chipoff_t erase_end;
952};
953/* returns 0 on success, 1 to retry with another erase function, 2 for immediate abort */
954typedef int (*per_blockfn_t)(struct flashctx *, const struct walk_info *, erasefn_t);
955
956static int walk_eraseblocks(struct flashctx *const flashctx,
957 struct walk_info *const info,
958 const size_t erasefunction, const per_blockfn_t per_blockfn)
959{
960 int ret;
961 size_t i, j;
962 bool first = true;
963 struct block_eraser *const eraser = &flashctx->chip->block_erasers[erasefunction];
964
965 info->erase_start = 0;
966 for (i = 0; i < NUM_ERASEREGIONS; ++i) {
967 /* count==0 for all automatically initialized array
968 members so the loop below won't be executed for them. */
969 for (j = 0; j < eraser->eraseblocks[i].count; ++j, info->erase_start = info->erase_end + 1) {
970 info->erase_end = info->erase_start + eraser->eraseblocks[i].size - 1;
971
972 /* Skip any eraseblock that is completely outside the current region. */
973 if (info->erase_end < info->region_start)
974 continue;
975 if (info->region_end < info->erase_start)
976 break;
977
978 /* Print this for every block except the first one. */
979 if (first)
980 first = false;
981 else
982 msg_cdbg(", ");
983 msg_cdbg("0x%06x-0x%06x:", info->erase_start, info->erase_end);
984
985 ret = per_blockfn(flashctx, info, eraser->block_erase);
986 if (ret)
987 return ret;
988 }
989 if (info->region_end < info->erase_start)
990 break;
991 }
992 msg_cdbg("\n");
993 return 0;
994}
995
996static int walk_by_layout(struct flashctx *const flashctx, struct walk_info *const info,
997 const per_blockfn_t per_blockfn)
998{
999 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber5ca55232019-06-15 22:29:08 +02001000 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +02001001
1002 all_skipped = true;
1003 msg_cinfo("Erasing and writing flash chip... ");
1004
Nico Huber5ca55232019-06-15 22:29:08 +02001005 while ((entry = layout_next_included(layout, entry))) {
1006 info->region_start = entry->start;
1007 info->region_end = entry->end;
Nico Huber7af0e792016-04-29 16:40:15 +02001008
1009 size_t j;
1010 int error = 1; /* retry as long as it's 1 */
1011 for (j = 0; j < NUM_ERASEFUNCTIONS; ++j) {
1012 if (j != 0)
1013 msg_cinfo("Looking for another erase function.\n");
1014 msg_cdbg("Trying erase function %zi... ", j);
1015 if (check_block_eraser(flashctx, j, 1))
1016 continue;
1017
1018 error = walk_eraseblocks(flashctx, info, j, per_blockfn);
1019 if (error != 1)
1020 break;
1021
1022 if (info->curcontents) {
1023 msg_cinfo("Reading current flash chip contents... ");
1024 if (read_by_layout(flashctx, info->curcontents)) {
1025 /* Now we are truly screwed. Read failed as well. */
1026 msg_cerr("Can't read anymore! Aborting.\n");
1027 /* We have no idea about the flash chip contents, so
1028 retrying with another erase function is pointless. */
1029 error = 2;
1030 break;
1031 }
1032 msg_cinfo("done. ");
1033 }
1034 }
1035 if (error == 1)
1036 msg_cinfo("No usable erase functions left.\n");
1037 if (error) {
1038 msg_cerr("FAILED!\n");
1039 return 1;
1040 }
1041 }
1042 if (all_skipped)
1043 msg_cinfo("\nWarning: Chip content is identical to the requested image.\n");
1044 msg_cinfo("Erase/write done.\n");
1045 return 0;
1046}
1047
1048static int erase_block(struct flashctx *const flashctx,
1049 const struct walk_info *const info, const erasefn_t erasefn)
1050{
1051 const unsigned int erase_len = info->erase_end + 1 - info->erase_start;
Nico Huber6e61e0c2019-01-23 17:07:49 +01001052 const bool region_unaligned = info->region_start > info->erase_start ||
1053 info->erase_end > info->region_end;
1054 uint8_t *backup_contents = NULL, *erased_contents = NULL;
1055 int ret = 2;
Nico Huber7af0e792016-04-29 16:40:15 +02001056
Nico Huber6e61e0c2019-01-23 17:07:49 +01001057 /*
1058 * If the region is not erase-block aligned, merge current flash con-
1059 * tents into a new buffer `backup_contents`.
1060 */
1061 if (region_unaligned) {
1062 backup_contents = malloc(erase_len);
1063 erased_contents = malloc(erase_len);
1064 if (!backup_contents || !erased_contents) {
1065 msg_cerr("Out of memory!\n");
1066 ret = 1;
1067 goto _free_ret;
1068 }
1069 memset(backup_contents, ERASED_VALUE(flashctx), erase_len);
1070 memset(erased_contents, ERASED_VALUE(flashctx), erase_len);
1071
1072 msg_cdbg("R");
1073 /* Merge data preceding the current region. */
1074 if (info->region_start > info->erase_start) {
1075 const chipoff_t start = info->erase_start;
1076 const chipsize_t len = info->region_start - info->erase_start;
1077 if (flashctx->chip->read(flashctx, backup_contents, start, len)) {
1078 msg_cerr("Can't read! Aborting.\n");
1079 goto _free_ret;
1080 }
1081 }
1082 /* Merge data following the current region. */
1083 if (info->erase_end > info->region_end) {
1084 const chipoff_t start = info->region_end + 1;
1085 const chipoff_t rel_start = start - info->erase_start; /* within this erase block */
1086 const chipsize_t len = info->erase_end - info->region_end;
1087 if (flashctx->chip->read(flashctx, backup_contents + rel_start, start, len)) {
1088 msg_cerr("Can't read! Aborting.\n");
1089 goto _free_ret;
1090 }
1091 }
1092 }
1093
1094 ret = 1;
Nico Huber7af0e792016-04-29 16:40:15 +02001095 all_skipped = false;
1096
1097 msg_cdbg("E");
1098 if (erasefn(flashctx, info->erase_start, erase_len))
Nico Huber6e61e0c2019-01-23 17:07:49 +01001099 goto _free_ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001100 if (check_erased_range(flashctx, info->erase_start, erase_len)) {
1101 msg_cerr("ERASE FAILED!\n");
Nico Huber6e61e0c2019-01-23 17:07:49 +01001102 goto _free_ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001103 }
Nico Huber6e61e0c2019-01-23 17:07:49 +01001104
1105 if (region_unaligned) {
1106 unsigned int starthere = 0, lenhere = 0, writecount = 0;
1107 /* get_next_write() sets starthere to a new value after the call. */
1108 while ((lenhere = get_next_write(erased_contents + starthere, backup_contents + starthere,
1109 erase_len - starthere, &starthere, flashctx->chip->gran))) {
1110 if (!writecount++)
1111 msg_cdbg("W");
1112 /* Needs the partial write function signature. */
1113 if (flashctx->chip->write(flashctx, backup_contents + starthere,
1114 info->erase_start + starthere, lenhere))
1115 goto _free_ret;
1116 starthere += lenhere;
1117 }
1118 }
1119
1120 ret = 0;
1121
1122_free_ret:
1123 free(erased_contents);
1124 free(backup_contents);
1125 return ret;
Nico Huber7af0e792016-04-29 16:40:15 +02001126}
1127
1128/**
1129 * @brief Erases the included layout regions.
1130 *
1131 * If there is no layout set in the given flash context, the whole chip will
1132 * be erased.
1133 *
1134 * @param flashctx Flash context to be used.
Nico Huber7af0e792016-04-29 16:40:15 +02001135 * @return 0 on success,
1136 * 1 if all available erase functions failed.
1137 */
Nico Huber454f6132012-12-10 13:34:10 +00001138static int erase_by_layout(struct flashctx *const flashctx)
Nico Huber7af0e792016-04-29 16:40:15 +02001139{
1140 struct walk_info info = { 0 };
1141 return walk_by_layout(flashctx, &info, &erase_block);
1142}
1143
1144static int read_erase_write_block(struct flashctx *const flashctx,
1145 const struct walk_info *const info, const erasefn_t erasefn)
1146{
1147 const chipsize_t erase_len = info->erase_end + 1 - info->erase_start;
1148 const bool region_unaligned = info->region_start > info->erase_start ||
1149 info->erase_end > info->region_end;
1150 const uint8_t *newcontents = NULL;
1151 int ret = 2;
1152
1153 /*
1154 * If the region is not erase-block aligned, merge current flash con-
1155 * tents into `info->curcontents` and a new buffer `newc`. The former
1156 * is necessary since we have no guarantee that the full erase block
1157 * was already read into `info->curcontents`. For the latter a new
1158 * buffer is used since `info->newcontents` might contain data for
1159 * other unaligned regions that touch this erase block too.
1160 */
1161 if (region_unaligned) {
1162 msg_cdbg("R");
1163 uint8_t *const newc = malloc(erase_len);
1164 if (!newc) {
1165 msg_cerr("Out of memory!\n");
1166 return 1;
1167 }
1168 memcpy(newc, info->newcontents + info->erase_start, erase_len);
1169
1170 /* Merge data preceding the current region. */
1171 if (info->region_start > info->erase_start) {
1172 const chipoff_t start = info->erase_start;
1173 const chipsize_t len = info->region_start - info->erase_start;
1174 if (flashctx->chip->read(flashctx, newc, start, len)) {
1175 msg_cerr("Can't read! Aborting.\n");
1176 goto _free_ret;
1177 }
1178 memcpy(info->curcontents + start, newc, len);
1179 }
1180 /* Merge data following the current region. */
1181 if (info->erase_end > info->region_end) {
1182 const chipoff_t start = info->region_end + 1;
1183 const chipoff_t rel_start = start - info->erase_start; /* within this erase block */
1184 const chipsize_t len = info->erase_end - info->region_end;
1185 if (flashctx->chip->read(flashctx, newc + rel_start, start, len)) {
1186 msg_cerr("Can't read! Aborting.\n");
1187 goto _free_ret;
1188 }
1189 memcpy(info->curcontents + start, newc + rel_start, len);
1190 }
1191
1192 newcontents = newc;
1193 } else {
1194 newcontents = info->newcontents + info->erase_start;
1195 }
1196
1197 ret = 1;
1198 bool skipped = true;
1199 uint8_t *const curcontents = info->curcontents + info->erase_start;
Paul Kocialkowski995f7552018-01-15 01:06:09 +03001200 const uint8_t erased_value = ERASED_VALUE(flashctx);
David Hendricksf9a30552015-05-23 20:30:30 -07001201 if (!(flashctx->chip->feature_bits & FEATURE_NO_ERASE) &&
1202 need_erase(curcontents, newcontents, erase_len, flashctx->chip->gran, erased_value)) {
Nico Huber7af0e792016-04-29 16:40:15 +02001203 if (erase_block(flashctx, info, erasefn))
1204 goto _free_ret;
1205 /* Erase was successful. Adjust curcontents. */
Paul Kocialkowski995f7552018-01-15 01:06:09 +03001206 memset(curcontents, erased_value, erase_len);
Nico Huber7af0e792016-04-29 16:40:15 +02001207 skipped = false;
1208 }
1209
1210 unsigned int starthere = 0, lenhere = 0, writecount = 0;
1211 /* get_next_write() sets starthere to a new value after the call. */
1212 while ((lenhere = get_next_write(curcontents + starthere, newcontents + starthere,
1213 erase_len - starthere, &starthere, flashctx->chip->gran))) {
1214 if (!writecount++)
1215 msg_cdbg("W");
1216 /* Needs the partial write function signature. */
1217 if (flashctx->chip->write(flashctx, newcontents + starthere,
1218 info->erase_start + starthere, lenhere))
1219 goto _free_ret;
1220 starthere += lenhere;
1221 skipped = false;
1222 }
1223 if (skipped)
1224 msg_cdbg("S");
1225 else
1226 all_skipped = false;
1227
1228 /* Update curcontents, other regions with overlapping erase blocks
1229 might rely on this. */
1230 memcpy(curcontents, newcontents, erase_len);
1231 ret = 0;
1232
1233_free_ret:
1234 if (region_unaligned)
1235 free((void *)newcontents);
1236 return ret;
1237}
1238
1239/**
1240 * @brief Writes the included layout regions from a given image.
1241 *
1242 * If there is no layout set in the given flash context, the whole image
1243 * will be written.
1244 *
1245 * @param flashctx Flash context to be used.
1246 * @param curcontents A buffer of full chip size with current chip contents of included regions.
1247 * @param newcontents The new image to be written.
1248 * @return 0 on success,
1249 * 1 if anything has gone wrong.
1250 */
Nico Huber454f6132012-12-10 13:34:10 +00001251static int write_by_layout(struct flashctx *const flashctx,
1252 void *const curcontents, const void *const newcontents)
Nico Huber7af0e792016-04-29 16:40:15 +02001253{
1254 struct walk_info info;
1255 info.curcontents = curcontents;
1256 info.newcontents = newcontents;
1257 return walk_by_layout(flashctx, &info, read_erase_write_block);
1258}
1259
1260/**
1261 * @brief Compares the included layout regions with content from a buffer.
1262 *
1263 * If there is no layout set in the given flash context, the whole chip's
1264 * contents will be compared.
1265 *
1266 * @param flashctx Flash context to be used.
Nico Huber74d09d42019-06-16 03:27:26 +02001267 * @param layout Flash layout information.
Nico Huber7af0e792016-04-29 16:40:15 +02001268 * @param curcontents A buffer of full chip size to read current chip contents into.
1269 * @param newcontents The new image to compare to.
1270 * @return 0 on success,
1271 * 1 if reading failed,
1272 * 3 if the contents don't match.
1273 */
Nico Huber74d09d42019-06-16 03:27:26 +02001274static int verify_by_layout(
1275 struct flashctx *const flashctx,
1276 const struct flashrom_layout *const layout,
1277 void *const curcontents, const uint8_t *const newcontents)
Nico Huber7af0e792016-04-29 16:40:15 +02001278{
Nico Huber5ca55232019-06-15 22:29:08 +02001279 const struct romentry *entry = NULL;
Nico Huber7af0e792016-04-29 16:40:15 +02001280
Nico Huber5ca55232019-06-15 22:29:08 +02001281 while ((entry = layout_next_included(layout, entry))) {
1282 const chipoff_t region_start = entry->start;
1283 const chipsize_t region_len = entry->end - entry->start + 1;
Nico Huber7af0e792016-04-29 16:40:15 +02001284
1285 if (flashctx->chip->read(flashctx, curcontents + region_start, region_start, region_len))
1286 return 1;
1287 if (compare_range(newcontents + region_start, curcontents + region_start,
1288 region_start, region_len))
1289 return 3;
1290 }
1291 return 0;
1292}
1293
Stefan Tauner136388f2013-07-15 10:47:53 +00001294static void nonfatal_help_message(void)
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001295{
Stefan Taunera58f6e92014-05-10 09:25:44 +00001296 msg_gerr("Good, writing to the flash chip apparently didn't do anything.\n");
Stefan Tauner136388f2013-07-15 10:47:53 +00001297#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001298 if (programmer == &programmer_internal)
Stefan Tauner136388f2013-07-15 10:47:53 +00001299 msg_gerr("This means we have to add special support for your board, programmer or flash\n"
Nico Huberac90af62022-12-18 00:22:47 +00001300 "chip. Please report this to the mailing list at flashrom-stable@flashrom.org or\n"
1301 "on IRC (see https://www.flashrom.org/Contact for details), thanks!\n"
Stefan Tauner136388f2013-07-15 10:47:53 +00001302 "-------------------------------------------------------------------------------\n"
1303 "You may now reboot or simply leave the machine running.\n");
1304 else
1305#endif
1306 msg_gerr("Please check the connections (especially those to write protection pins) between\n"
1307 "the programmer and the flash chip. If you think the error is caused by flashrom\n"
Nico Huberac90af62022-12-18 00:22:47 +00001308 "please report this to the mailing list at flashrom-stable@flashrom.org or on IRC\n"
1309 "(see https://www.flashrom.org/Contact for details), thanks!\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001310}
1311
Edward O'Callaghanc72d20a2021-12-13 12:30:03 +11001312void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001313{
Stefan Tauner136388f2013-07-15 10:47:53 +00001314 msg_gerr("Your flash chip is in an unknown state.\n");
1315#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001316 if (programmer == &programmer_internal)
Angel Pons1900e1d2021-07-02 12:42:23 +02001317 msg_gerr("Get help on IRC (see https://www.flashrom.org/Contact) or mail\n"
Nico Huberac90af62022-12-18 00:22:47 +00001318 "flashrom-stable@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
Stefan Tauner136388f2013-07-15 10:47:53 +00001319 "-------------------------------------------------------------------------------\n"
1320 "DO NOT REBOOT OR POWEROFF!\n");
1321 else
1322#endif
Nico Huberac90af62022-12-18 00:22:47 +00001323 msg_gerr("Please report this to the mailing list at flashrom-stable@flashrom.org\n"
1324 "or on IRC (see https://www.flashrom.org/Contact for details), thanks!\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001325}
1326
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001327void list_programmers_linebreak(int startcol, int cols, int paren)
1328{
1329 const char *pname;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001330 int pnamelen;
1331 int remaining = 0, firstline = 1;
Thomas Heijligen9163b812021-06-01 14:25:01 +02001332 size_t p;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001333 int i;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001334
Thomas Heijligend45cb592021-05-19 14:12:18 +02001335 for (p = 0; p < programmer_table_size; p++) {
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001336 pname = programmer_table[p]->name;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001337 pnamelen = strlen(pname);
1338 if (remaining - pnamelen - 2 < 0) {
1339 if (firstline)
1340 firstline = 0;
1341 else
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001342 msg_ginfo("\n");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001343 for (i = 0; i < startcol; i++)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001344 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001345 remaining = cols - startcol;
1346 } else {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001347 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001348 remaining--;
1349 }
1350 if (paren && (p == 0)) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001351 msg_ginfo("(");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001352 remaining--;
1353 }
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001354 msg_ginfo("%s", pname);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001355 remaining -= pnamelen;
Thomas Heijligend45cb592021-05-19 14:12:18 +02001356 if (p < programmer_table_size - 1) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001357 msg_ginfo(",");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001358 remaining--;
1359 } else {
1360 if (paren)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001361 msg_ginfo(")");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001362 }
1363 }
1364}
1365
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001366int selfcheck(void)
1367{
Stefan Tauner96658be2014-05-26 22:05:31 +00001368 unsigned int i;
Stefan Taunera6d96482012-12-26 19:51:23 +00001369 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001370
Thomas Heijligend45cb592021-05-19 14:12:18 +02001371 for (i = 0; i < programmer_table_size; i++) {
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001372 const struct programmer_entry *const p = programmer_table[i];
1373 if (p == NULL) {
1374 msg_gerr("Programmer with index %d is NULL instead of a valid pointer!\n", i);
1375 ret = 1;
1376 continue;
1377 }
1378 if (p->name == NULL) {
Stefan Taunera6d96482012-12-26 19:51:23 +00001379 msg_gerr("All programmers need a valid name, but the one with index %d does not!\n", i);
1380 ret = 1;
1381 /* This might hide other problems with this programmer, but allows for better error
1382 * messages below without jumping through hoops. */
1383 continue;
1384 }
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001385 switch (p->type) {
Stefan Tauneraf358d62012-12-27 18:40:26 +00001386 case USB:
1387 case PCI:
1388 case OTHER:
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001389 if (p->devs.note == NULL) {
1390 if (strcmp("internal", p->name) == 0)
Stefan Tauneraf358d62012-12-27 18:40:26 +00001391 break; /* This one has its device list stored separately. */
1392 msg_gerr("Programmer %s has neither a device list nor a textual description!\n",
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001393 p->name);
Stefan Tauneraf358d62012-12-27 18:40:26 +00001394 ret = 1;
1395 }
1396 break;
1397 default:
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001398 msg_gerr("Programmer %s does not have a valid type set!\n", p->name);
Stefan Tauneraf358d62012-12-27 18:40:26 +00001399 ret = 1;
1400 break;
1401 }
Thomas Heijligen633d6db2021-03-31 19:09:44 +02001402 if (p->init == NULL) {
1403 msg_gerr("Programmer %s does not have a valid init function!\n", p->name);
Stefan Taunera6d96482012-12-26 19:51:23 +00001404 ret = 1;
1405 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001406 }
Stefan Tauner96658be2014-05-26 22:05:31 +00001407
1408 /* It would be favorable if we could check for the correct layout (especially termination) of various
1409 * constant arrays: flashchips, chipset_enables, board_matches, boards_known, laptops_known.
1410 * They are all defined as externs in this compilation unit so we don't know their sizes which vary
1411 * depending on compiler flags, e.g. the target architecture, and can sometimes be 0.
1412 * For 'flashchips' we export the size explicitly to work around this and to be able to implement the
1413 * checks below. */
Stefan Tauner6697f712014-08-06 15:09:15 +00001414 if (flashchips_size <= 1 || flashchips[flashchips_size - 1].name != NULL) {
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001415 msg_gerr("Flashchips table miscompilation!\n");
1416 ret = 1;
Stefan Tauner96658be2014-05-26 22:05:31 +00001417 } else {
1418 for (i = 0; i < flashchips_size - 1; i++) {
1419 const struct flashchip *chip = &flashchips[i];
1420 if (chip->vendor == NULL || chip->name == NULL || chip->bustype == BUS_NONE) {
1421 ret = 1;
1422 msg_gerr("ERROR: Some field of flash chip #%d (%s) is misconfigured.\n"
Nico Huberac90af62022-12-18 00:22:47 +00001423 "Please report a bug at flashrom-stable@flashrom.org\n", i,
Stefan Tauner96658be2014-05-26 22:05:31 +00001424 chip->name == NULL ? "unnamed" : chip->name);
1425 }
1426 if (selfcheck_eraseblocks(chip)) {
1427 ret = 1;
1428 }
1429 }
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001430 }
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001431
Stefan Tauner600576b2014-06-12 22:57:36 +00001432#if CONFIG_INTERNAL == 1
1433 ret |= selfcheck_board_enables();
1434#endif
1435
Stefan Tauner96658be2014-05-26 22:05:31 +00001436 /* TODO: implement similar sanity checks for other arrays where deemed necessary. */
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001437 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001438}
1439
Edward O'Callaghanacb24d42021-04-15 13:44:39 +10001440/* FIXME: This function signature needs to be improved once prepare_flash_access()
1441 * has a better function signature.
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001442 */
Jacob Garberbeeb8bc2019-06-21 15:24:17 -06001443static int chip_safety_check(const struct flashctx *flash, int force,
1444 int read_it, int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001445{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001446 const struct flashchip *chip = flash->chip;
1447
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001448 if (!programmer_may_write && (write_it || erase_it)) {
1449 msg_perr("Write/erase is not working yet on your programmer in "
1450 "its current configuration.\n");
1451 /* --force is the wrong approach, but it's the best we can do
1452 * until the generic programmer parameter parser is merged.
1453 */
1454 if (!force)
1455 return 1;
1456 msg_cerr("Continuing anyway.\n");
1457 }
1458
1459 if (read_it || erase_it || write_it || verify_it) {
1460 /* Everything needs read. */
Stefan Tauner6455dff2014-05-26 00:36:24 +00001461 if (chip->tested.read == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001462 msg_cerr("Read is not working on this chip. ");
1463 if (!force)
1464 return 1;
1465 msg_cerr("Continuing anyway.\n");
1466 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001467 if (!chip->read) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001468 msg_cerr("flashrom has no read function for this "
1469 "flash chip.\n");
1470 return 1;
1471 }
1472 }
1473 if (erase_it || write_it) {
1474 /* Write needs erase. */
Stefan Tauner6455dff2014-05-26 00:36:24 +00001475 if (chip->tested.erase == NA) {
1476 msg_cerr("Erase is not possible on this chip.\n");
1477 return 1;
1478 }
1479 if (chip->tested.erase == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001480 msg_cerr("Erase is not working on this chip. ");
1481 if (!force)
1482 return 1;
1483 msg_cerr("Continuing anyway.\n");
1484 }
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001485 if(count_usable_erasers(flash) == 0) {
Stefan Tauner5368dca2011-07-01 00:19:12 +00001486 msg_cerr("flashrom has no erase function for this "
1487 "flash chip.\n");
1488 return 1;
1489 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001490 }
1491 if (write_it) {
Stefan Tauner6455dff2014-05-26 00:36:24 +00001492 if (chip->tested.write == NA) {
1493 msg_cerr("Write is not possible on this chip.\n");
1494 return 1;
1495 }
1496 if (chip->tested.write == BAD) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001497 msg_cerr("Write is not working on this chip. ");
1498 if (!force)
1499 return 1;
1500 msg_cerr("Continuing anyway.\n");
1501 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001502 if (!chip->write) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001503 msg_cerr("flashrom has no write function for this "
1504 "flash chip.\n");
1505 return 1;
1506 }
1507 }
1508 return 0;
1509}
1510
Nico Huber305f4172013-06-14 11:55:26 +02001511int prepare_flash_access(struct flashctx *const flash,
1512 const bool read_it, const bool write_it,
1513 const bool erase_it, const bool verify_it)
Nico Huber454f6132012-12-10 13:34:10 +00001514{
1515 if (chip_safety_check(flash, flash->flags.force, read_it, write_it, erase_it, verify_it)) {
1516 msg_cerr("Aborting.\n");
1517 return 1;
1518 }
1519
Nico Hubere0ed4122021-05-14 00:48:28 +02001520 if (layout_sanity_checks(flash)) {
Nico Huber454f6132012-12-10 13:34:10 +00001521 msg_cerr("Requested regions can not be handled. Aborting.\n");
1522 return 1;
1523 }
1524
1525 if (map_flash(flash) != 0)
1526 return 1;
1527
Nikolai Artemiev4ad48642020-11-05 13:54:27 +11001528 /* Initialize chip_restore_fn_count before chip unlock calls. */
1529 flash->chip_restore_fn_count = 0;
1530
Nico Huber454f6132012-12-10 13:34:10 +00001531 /* Given the existence of read locks, we want to unlock for read,
1532 erase and write. */
1533 if (flash->chip->unlock)
1534 flash->chip->unlock(flash);
1535
Nico Huberf43c6542017-10-14 17:47:28 +02001536 flash->address_high_byte = -1;
1537 flash->in_4ba_mode = false;
1538
Nico Huberdc5af542018-12-22 16:54:59 +01001539 /* Be careful about 4BA chips and broken masters */
1540 if (flash->chip->total_size > 16 * 1024 && spi_master_no_4ba_modes(flash)) {
1541 /* If we can't use native instructions, bail out */
1542 if ((flash->chip->feature_bits & FEATURE_4BA_NATIVE) != FEATURE_4BA_NATIVE
1543 || !spi_master_4ba(flash)) {
1544 msg_cerr("Programmer doesn't support this chip. Aborting.\n");
1545 return 1;
1546 }
1547 }
1548
Ed Swierkcc20a9b2017-07-03 13:17:18 -07001549 /* Enable/disable 4-byte addressing mode if flash chip supports it */
Nico Huber86bddb52018-03-13 18:14:52 +01001550 if (flash->chip->feature_bits & (FEATURE_4BA_ENTER | FEATURE_4BA_ENTER_WREN | FEATURE_4BA_ENTER_EAR7)) {
Nico Huberfe34d2a2017-11-10 21:10:20 +01001551 int ret;
1552 if (spi_master_4ba(flash))
1553 ret = spi_enter_4ba(flash);
1554 else
1555 ret = spi_exit_4ba(flash);
1556 if (ret) {
1557 msg_cerr("Failed to set correct 4BA mode! Aborting.\n");
Ed Swierkcc20a9b2017-07-03 13:17:18 -07001558 return 1;
Boris Baykov7fe85692016-06-11 18:29:03 +02001559 }
Boris Baykov99127182016-06-11 18:29:00 +02001560 }
1561
Nico Huber454f6132012-12-10 13:34:10 +00001562 return 0;
1563}
1564
Nico Huber305f4172013-06-14 11:55:26 +02001565void finalize_flash_access(struct flashctx *const flash)
Nico Huber454f6132012-12-10 13:34:10 +00001566{
Nikolai Artemiev4ad48642020-11-05 13:54:27 +11001567 deregister_chip_restore(flash);
Nico Huber454f6132012-12-10 13:34:10 +00001568 unmap_flash(flash);
1569}
1570
1571/**
1572 * @addtogroup flashrom-flash
1573 * @{
1574 */
1575
1576/**
1577 * @brief Erase the specified ROM chip.
1578 *
1579 * If a layout is set in the given flash context, only included regions
1580 * will be erased.
1581 *
1582 * @param flashctx The context of the flash chip to erase.
1583 * @return 0 on success.
1584 */
1585int flashrom_flash_erase(struct flashctx *const flashctx)
1586{
1587 if (prepare_flash_access(flashctx, false, false, true, false))
1588 return 1;
1589
1590 const int ret = erase_by_layout(flashctx);
1591
1592 finalize_flash_access(flashctx);
1593
1594 return ret;
1595}
1596
1597/** @} */ /* end flashrom-flash */
1598
1599/**
1600 * @defgroup flashrom-ops Operations
1601 * @{
1602 */
1603
1604/**
1605 * @brief Read the current image from the specified ROM chip.
1606 *
1607 * If a layout is set in the specified flash context, only included regions
1608 * will be read.
1609 *
1610 * @param flashctx The context of the flash chip.
1611 * @param buffer Target buffer to write image to.
1612 * @param buffer_len Size of target buffer in bytes.
1613 * @return 0 on success,
1614 * 2 if buffer_len is too short for the flash chip's contents,
1615 * or 1 on any other failure.
1616 */
1617int flashrom_image_read(struct flashctx *const flashctx, void *const buffer, const size_t buffer_len)
1618{
1619 const size_t flash_size = flashctx->chip->total_size * 1024;
1620
1621 if (flash_size > buffer_len)
1622 return 2;
1623
1624 if (prepare_flash_access(flashctx, true, false, false, false))
1625 return 1;
1626
1627 msg_cinfo("Reading flash... ");
1628
1629 int ret = 1;
1630 if (read_by_layout(flashctx, buffer)) {
1631 msg_cerr("Read operation failed!\n");
1632 msg_cinfo("FAILED.\n");
1633 goto _finalize_ret;
1634 }
1635 msg_cinfo("done.\n");
1636 ret = 0;
1637
1638_finalize_ret:
1639 finalize_flash_access(flashctx);
1640 return ret;
1641}
1642
1643static void combine_image_by_layout(const struct flashctx *const flashctx,
1644 uint8_t *const newcontents, const uint8_t *const oldcontents)
1645{
1646 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber3d7b1e32018-12-22 00:53:14 +01001647 const struct romentry *included;
1648 chipoff_t start = 0;
Nico Huber454f6132012-12-10 13:34:10 +00001649
Nico Huber3d7b1e32018-12-22 00:53:14 +01001650 while ((included = layout_next_included_region(layout, start))) {
1651 if (included->start > start) {
1652 /* copy everything up to the start of this included region */
1653 memcpy(newcontents + start, oldcontents + start, included->start - start);
1654 }
1655 /* skip this included region */
1656 start = included->end + 1;
1657 if (start == 0)
1658 return;
Nico Huber454f6132012-12-10 13:34:10 +00001659 }
Nico Huber3d7b1e32018-12-22 00:53:14 +01001660
1661 /* copy the rest of the chip */
1662 const chipsize_t copy_len = flashctx->chip->total_size * 1024 - start;
1663 memcpy(newcontents + start, oldcontents + start, copy_len);
Nico Huber454f6132012-12-10 13:34:10 +00001664}
1665
1666/**
1667 * @brief Write the specified image to the ROM chip.
1668 *
1669 * If a layout is set in the specified flash context, only erase blocks
1670 * containing included regions will be touched.
1671 *
1672 * @param flashctx The context of the flash chip.
Nico Huber1b172f22017-06-19 12:35:24 +02001673 * @param buffer Source buffer to read image from (may be altered for full verification).
Nico Huber454f6132012-12-10 13:34:10 +00001674 * @param buffer_len Size of source buffer in bytes.
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001675 * @param refbuffer If given, assume flash chip contains same data as `refbuffer`.
Nico Huber454f6132012-12-10 13:34:10 +00001676 * @return 0 on success,
1677 * 4 if buffer_len doesn't match the size of the flash chip,
1678 * 3 if write was tried but nothing has changed,
1679 * 2 if write failed and flash contents changed,
1680 * or 1 on any other failure.
1681 */
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001682int flashrom_image_write(struct flashctx *const flashctx, void *const buffer, const size_t buffer_len,
1683 const void *const refbuffer)
Nico Huber454f6132012-12-10 13:34:10 +00001684{
1685 const size_t flash_size = flashctx->chip->total_size * 1024;
1686 const bool verify_all = flashctx->flags.verify_whole_chip;
1687 const bool verify = flashctx->flags.verify_after_write;
Nico Huber74d09d42019-06-16 03:27:26 +02001688 const struct flashrom_layout *const verify_layout =
1689 verify_all ? get_default_layout(flashctx) : get_layout(flashctx);
Nico Huber454f6132012-12-10 13:34:10 +00001690
1691 if (buffer_len != flash_size)
1692 return 4;
1693
1694 int ret = 1;
1695
1696 uint8_t *const newcontents = buffer;
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001697 const uint8_t *const refcontents = refbuffer;
Nico Huber454f6132012-12-10 13:34:10 +00001698 uint8_t *const curcontents = malloc(flash_size);
1699 uint8_t *oldcontents = NULL;
1700 if (verify_all)
1701 oldcontents = malloc(flash_size);
1702 if (!curcontents || (verify_all && !oldcontents)) {
1703 msg_gerr("Out of memory!\n");
1704 goto _free_ret;
1705 }
1706
1707#if CONFIG_INTERNAL == 1
Thomas Heijligenc7e5b8b2021-06-01 14:21:41 +02001708 if (programmer == &programmer_internal && cb_check_image(newcontents, flash_size) < 0) {
Nico Huber454f6132012-12-10 13:34:10 +00001709 if (flashctx->flags.force_boardmismatch) {
1710 msg_pinfo("Proceeding anyway because user forced us to.\n");
1711 } else {
1712 msg_perr("Aborting. You can override this with "
1713 "-p internal:boardmismatch=force.\n");
1714 goto _free_ret;
1715 }
1716 }
1717#endif
1718
1719 if (prepare_flash_access(flashctx, false, true, false, verify))
1720 goto _free_ret;
1721
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001722 /* If given, assume flash chip contains same data as `refcontents`. */
1723 if (refcontents) {
1724 msg_cinfo("Assuming old flash chip contents as ref-file...\n");
1725 memcpy(curcontents, refcontents, flash_size);
1726 if (oldcontents)
1727 memcpy(oldcontents, refcontents, flash_size);
Nico Huber454f6132012-12-10 13:34:10 +00001728 } else {
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001729 /*
1730 * Read the whole chip to be able to check whether regions need to be
1731 * erased and to give better diagnostics in case write fails.
1732 * The alternative is to read only the regions which are to be
1733 * preserved, but in that case we might perform unneeded erase which
1734 * takes time as well.
1735 */
1736 msg_cinfo("Reading old flash chip contents... ");
1737 if (verify_all) {
1738 if (flashctx->chip->read(flashctx, oldcontents, 0, flash_size)) {
1739 msg_cinfo("FAILED.\n");
1740 goto _finalize_ret;
1741 }
1742 memcpy(curcontents, oldcontents, flash_size);
1743 } else {
1744 if (read_by_layout(flashctx, curcontents)) {
1745 msg_cinfo("FAILED.\n");
1746 goto _finalize_ret;
1747 }
Nico Huber454f6132012-12-10 13:34:10 +00001748 }
Paul Kocialkowskif701f342018-01-15 01:10:36 +03001749 msg_cinfo("done.\n");
Nico Huber454f6132012-12-10 13:34:10 +00001750 }
Nico Huber454f6132012-12-10 13:34:10 +00001751
1752 if (write_by_layout(flashctx, curcontents, newcontents)) {
1753 msg_cerr("Uh oh. Erase/write failed. ");
1754 ret = 2;
1755 if (verify_all) {
1756 msg_cerr("Checking if anything has changed.\n");
1757 msg_cinfo("Reading current flash chip contents... ");
1758 if (!flashctx->chip->read(flashctx, curcontents, 0, flash_size)) {
1759 msg_cinfo("done.\n");
1760 if (!memcmp(oldcontents, curcontents, flash_size)) {
1761 nonfatal_help_message();
1762 goto _finalize_ret;
1763 }
1764 msg_cerr("Apparently at least some data has changed.\n");
1765 } else
1766 msg_cerr("Can't even read anymore!\n");
1767 emergency_help_message();
1768 goto _finalize_ret;
1769 } else {
1770 msg_cerr("\n");
1771 }
1772 emergency_help_message();
1773 goto _finalize_ret;
1774 }
1775
1776 /* Verify only if we actually changed something. */
1777 if (verify && !all_skipped) {
Nico Huber454f6132012-12-10 13:34:10 +00001778 msg_cinfo("Verifying flash... ");
1779
1780 /* Work around chips which need some time to calm down. */
1781 programmer_delay(1000*1000);
1782
Nico Huber74d09d42019-06-16 03:27:26 +02001783 if (verify_all)
Nico Huber454f6132012-12-10 13:34:10 +00001784 combine_image_by_layout(flashctx, newcontents, oldcontents);
Nico Huber74d09d42019-06-16 03:27:26 +02001785 ret = verify_by_layout(flashctx, verify_layout, curcontents, newcontents);
Nico Huber454f6132012-12-10 13:34:10 +00001786 /* If we tried to write, and verification now fails, we
1787 might have an emergency situation. */
1788 if (ret)
1789 emergency_help_message();
1790 else
1791 msg_cinfo("VERIFIED.\n");
1792 } else {
1793 /* We didn't change anything. */
1794 ret = 0;
1795 }
1796
1797_finalize_ret:
1798 finalize_flash_access(flashctx);
1799_free_ret:
1800 free(oldcontents);
1801 free(curcontents);
1802 return ret;
1803}
1804
1805/**
1806 * @brief Verify the ROM chip's contents with the specified image.
1807 *
1808 * If a layout is set in the specified flash context, only included regions
1809 * will be verified.
1810 *
1811 * @param flashctx The context of the flash chip.
1812 * @param buffer Source buffer to verify with.
1813 * @param buffer_len Size of source buffer in bytes.
1814 * @return 0 on success,
1815 * 3 if the chip's contents don't match,
1816 * 2 if buffer_len doesn't match the size of the flash chip,
1817 * or 1 on any other failure.
1818 */
1819int flashrom_image_verify(struct flashctx *const flashctx, const void *const buffer, const size_t buffer_len)
1820{
Nico Huber74d09d42019-06-16 03:27:26 +02001821 const struct flashrom_layout *const layout = get_layout(flashctx);
Nico Huber454f6132012-12-10 13:34:10 +00001822 const size_t flash_size = flashctx->chip->total_size * 1024;
1823
1824 if (buffer_len != flash_size)
1825 return 2;
1826
1827 const uint8_t *const newcontents = buffer;
1828 uint8_t *const curcontents = malloc(flash_size);
1829 if (!curcontents) {
1830 msg_gerr("Out of memory!\n");
1831 return 1;
1832 }
1833
1834 int ret = 1;
1835
1836 if (prepare_flash_access(flashctx, false, false, false, true))
1837 goto _free_ret;
1838
1839 msg_cinfo("Verifying flash... ");
Nico Huber74d09d42019-06-16 03:27:26 +02001840 ret = verify_by_layout(flashctx, layout, curcontents, newcontents);
Nico Huber454f6132012-12-10 13:34:10 +00001841 if (!ret)
1842 msg_cinfo("VERIFIED.\n");
1843
1844 finalize_flash_access(flashctx);
1845_free_ret:
1846 free(curcontents);
1847 return ret;
1848}
1849
1850/** @} */ /* end flashrom-ops */