blob: e2ad170398ee7c41e36e4fe3ad8a347ff4734b3a [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
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00008 *
Uwe Hermannd1107642007-08-29 17:52:32 +00009 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000013 *
Uwe Hermannd1107642007-08-29 17:52:32 +000014 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000018 *
Uwe Hermannd1107642007-08-29 17:52:32 +000019 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000022 */
23
Carl-Daniel Hailfinger831e8f42010-05-30 22:24:40 +000024#include <stdio.h>
Stefan Reinauer018aca82006-11-21 23:48:51 +000025#include <sys/types.h>
Patrick Georgia9095a92010-09-30 17:03:32 +000026#ifndef __LIBPAYLOAD__
27#include <fcntl.h>
Stefan Reinauer018aca82006-11-21 23:48:51 +000028#include <sys/stat.h>
Patrick Georgia9095a92010-09-30 17:03:32 +000029#endif
Ronald G. Minnichceec4202003-07-25 04:37:41 +000030#include <string.h>
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +000031#include <stdlib.h>
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +000032#include <ctype.h>
Ollie Lho184a4042005-11-26 21:55:36 +000033#include <getopt.h>
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +000034#if HAVE_UTSNAME == 1
35#include <sys/utsname.h>
36#endif
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000037#include "flash.h"
Carl-Daniel Hailfinger08454642009-06-15 14:14:48 +000038#include "flashchips.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000039#include "programmer.h"
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +000040#include "hwaccess.h"
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000041
Mathias Krausea60faab2011-01-17 07:50:42 +000042const char flashrom_version[] = FLASHROM_VERSION;
Ronald G. Minnichceec4202003-07-25 04:37:41 +000043char *chip_to_probe = NULL;
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +000044int verbose_screen = MSG_INFO;
45int verbose_logfile = MSG_DEBUG2;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000046
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +000047static enum programmer programmer = PROGRAMMER_INVALID;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000048
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +000049static char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +000050
Uwe Hermann48ec1b12010-08-08 17:01:18 +000051/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000052 * Programmers supporting multiple buses can have differing size limits on
53 * each bus. Store the limits for each bus in a common struct.
54 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000055struct decode_sizes max_rom_decode;
56
57/* If nonzero, used as the start address of bottom-aligned flash. */
58unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000059
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +000060/* Is writing allowed with this programmer? */
61int programmer_may_write;
62
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000063const struct programmer_entry programmer_table[] = {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000064#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000065 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000066 .name = "internal",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +000067 .init = internal_init,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +000068 .map_flash_region = physmap,
69 .unmap_flash_region = physunmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000070 .delay = internal_delay,
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000071 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000072#endif
Luc Verhaegen8e3a6002007-04-04 22:45:58 +000073
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000074#if CONFIG_DUMMY == 1
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000075 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000076 .name = "dummy",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +000077 .init = dummy_init,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +000078 .map_flash_region = dummy_map,
79 .unmap_flash_region = dummy_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000080 .delay = internal_delay,
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000081 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +000082#endif
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000083
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000084#if CONFIG_NIC3COM == 1
Uwe Hermannb4dcb712009-05-13 11:36:06 +000085 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000086 .name = "nic3com",
Uwe Hermannb4dcb712009-05-13 11:36:06 +000087 .init = nic3com_init,
Uwe Hermannc6915932009-05-17 23:12:17 +000088 .map_flash_region = fallback_map,
89 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000090 .delay = internal_delay,
Uwe Hermannb4dcb712009-05-13 11:36:06 +000091 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +000092#endif
Uwe Hermannb4dcb712009-05-13 11:36:06 +000093
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000094#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +000095 {
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +000096 /* This programmer works for Realtek RTL8139 and SMC 1211. */
Uwe Hermann91f4afa2011-07-28 08:13:25 +000097 .name = "nicrealtek",
Uwe Hermann91f4afa2011-07-28 08:13:25 +000098 .init = nicrealtek_init,
99 .map_flash_region = fallback_map,
100 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000101 .delay = internal_delay,
Joerg Fischer5665ef32010-05-21 21:54:07 +0000102 },
Joerg Fischer5665ef32010-05-21 21:54:07 +0000103#endif
104
Andrew Morganc29c2e72010-06-07 22:37:54 +0000105#if CONFIG_NICNATSEMI == 1
106 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000107 .name = "nicnatsemi",
108 .init = nicnatsemi_init,
109 .map_flash_region = fallback_map,
110 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000111 .delay = internal_delay,
Andrew Morganc29c2e72010-06-07 22:37:54 +0000112 },
113#endif
Joerg Fischer5665ef32010-05-21 21:54:07 +0000114
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000115#if CONFIG_GFXNVIDIA == 1
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000116 {
117 .name = "gfxnvidia",
118 .init = gfxnvidia_init,
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000119 .map_flash_region = fallback_map,
120 .unmap_flash_region = fallback_unmap,
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000121 .delay = internal_delay,
122 },
123#endif
124
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000125#if CONFIG_DRKAISER == 1
Rudolf Marek68720c72009-05-17 19:39:27 +0000126 {
TURBO Jb0912c02009-09-02 23:00:46 +0000127 .name = "drkaiser",
128 .init = drkaiser_init,
TURBO Jb0912c02009-09-02 23:00:46 +0000129 .map_flash_region = fallback_map,
130 .unmap_flash_region = fallback_unmap,
TURBO Jb0912c02009-09-02 23:00:46 +0000131 .delay = internal_delay,
132 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000133#endif
TURBO Jb0912c02009-09-02 23:00:46 +0000134
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000135#if CONFIG_SATASII == 1
TURBO Jb0912c02009-09-02 23:00:46 +0000136 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000137 .name = "satasii",
Rudolf Marek68720c72009-05-17 19:39:27 +0000138 .init = satasii_init,
Uwe Hermannc6915932009-05-17 23:12:17 +0000139 .map_flash_region = fallback_map,
140 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000141 .delay = internal_delay,
Rudolf Marek68720c72009-05-17 19:39:27 +0000142 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000143#endif
Rudolf Marek68720c72009-05-17 19:39:27 +0000144
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000145#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000146 {
147 .name = "atahpt",
148 .init = atahpt_init,
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000149 .map_flash_region = fallback_map,
150 .unmap_flash_region = fallback_unmap,
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000151 .delay = internal_delay,
152 },
153#endif
154
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000155#if CONFIG_FT2232_SPI == 1
Paul Fox05dfbe62009-06-16 21:08:06 +0000156 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000157 .name = "ft2232_spi",
Paul Fox05dfbe62009-06-16 21:08:06 +0000158 .init = ft2232_spi_init,
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000159 .map_flash_region = fallback_map,
160 .unmap_flash_region = fallback_unmap,
Paul Fox05dfbe62009-06-16 21:08:06 +0000161 .delay = internal_delay,
162 },
Carl-Daniel Hailfinger3426ef62009-08-19 13:27:58 +0000163#endif
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000164
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000165#if CONFIG_SERPROG == 1
Urja Rannikko22915352009-06-23 11:33:43 +0000166 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000167 .name = "serprog",
Urja Rannikko22915352009-06-23 11:33:43 +0000168 .init = serprog_init,
Urja Rannikko22915352009-06-23 11:33:43 +0000169 .map_flash_region = fallback_map,
170 .unmap_flash_region = fallback_unmap,
Urja Rannikko22915352009-06-23 11:33:43 +0000171 .delay = serprog_delay,
172 },
Carl-Daniel Hailfinger6be74112009-08-12 16:17:41 +0000173#endif
Paul Fox05dfbe62009-06-16 21:08:06 +0000174
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000175#if CONFIG_BUSPIRATE_SPI == 1
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000176 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000177 .name = "buspirate_spi",
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000178 .init = buspirate_spi_init,
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000179 .map_flash_region = fallback_map,
180 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000181 .delay = internal_delay,
182 },
183#endif
184
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000185#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000186 {
187 .name = "dediprog",
188 .init = dediprog_init,
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000189 .map_flash_region = fallback_map,
190 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000191 .delay = internal_delay,
192 },
193#endif
194
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000195#if CONFIG_RAYER_SPI == 1
196 {
197 .name = "rayer_spi",
198 .init = rayer_spi_init,
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000199 .map_flash_region = fallback_map,
200 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000201 .delay = internal_delay,
202 },
203#endif
204
Virgil-Adrian Teacada7c5452012-04-30 23:11:06 +0000205#if CONFIG_PONY_SPI == 1
206 {
207 .name = "pony_spi",
208 .init = pony_spi_init,
209 .map_flash_region = fallback_map,
210 .unmap_flash_region = fallback_unmap,
211 .delay = internal_delay,
212},
213#endif
214
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000215#if CONFIG_NICINTEL == 1
216 {
217 .name = "nicintel",
218 .init = nicintel_init,
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000219 .map_flash_region = fallback_map,
220 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000221 .delay = internal_delay,
222 },
223#endif
224
Idwer Vollering004f4b72010-09-03 18:21:21 +0000225#if CONFIG_NICINTEL_SPI == 1
226 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000227 .name = "nicintel_spi",
228 .init = nicintel_spi_init,
229 .map_flash_region = fallback_map,
230 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000231 .delay = internal_delay,
Idwer Vollering004f4b72010-09-03 18:21:21 +0000232 },
233#endif
234
Mark Marshall90021f22010-12-03 14:48:11 +0000235#if CONFIG_OGP_SPI == 1
236 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000237 .name = "ogp_spi",
238 .init = ogp_spi_init,
239 .map_flash_region = fallback_map,
240 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000241 .delay = internal_delay,
Mark Marshall90021f22010-12-03 14:48:11 +0000242 },
243#endif
244
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000245#if CONFIG_SATAMV == 1
246 {
247 .name = "satamv",
248 .init = satamv_init,
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000249 .map_flash_region = fallback_map,
250 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000251 .delay = internal_delay,
252 },
253#endif
254
Sven Schnelle5ce5f702011-09-03 18:37:52 +0000255#if CONFIG_LINUX_SPI == 1
256 {
257 .name = "linux_spi",
258 .init = linux_spi_init,
259 .map_flash_region = fallback_map,
260 .unmap_flash_region = fallback_unmap,
Sven Schnelle5ce5f702011-09-03 18:37:52 +0000261 .delay = internal_delay,
262 },
263#endif
264
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +0000265 {0}, /* This entry corresponds to PROGRAMMER_INVALID. */
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000266};
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000267
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000268#define SHUTDOWN_MAXFN 32
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000269static int shutdown_fn_count = 0;
270struct shutdown_func_data {
David Hendricks8bb20212011-06-14 01:35:36 +0000271 int (*func) (void *data);
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000272 void *data;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000273} static shutdown_fn[SHUTDOWN_MAXFN];
274/* Initialize to 0 to make sure nobody registers a shutdown function before
275 * programmer init.
276 */
277static int may_register_shutdown = 0;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000278
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000279static int check_block_eraser(const struct flashctx *flash, int k, int log);
Stefan Tauner5368dca2011-07-01 00:19:12 +0000280
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000281/* Register a function to be executed on programmer shutdown.
282 * The advantage over atexit() is that you can supply a void pointer which will
283 * be used as parameter to the registered function upon programmer shutdown.
284 * This pointer can point to arbitrary data used by said function, e.g. undo
285 * information for GPIO settings etc. If unneeded, set data=NULL.
286 * Please note that the first (void *data) belongs to the function signature of
287 * the function passed as first parameter.
288 */
David Hendricks8bb20212011-06-14 01:35:36 +0000289int register_shutdown(int (*function) (void *data), void *data)
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000290{
291 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000292 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000293 SHUTDOWN_MAXFN);
294 return 1;
295 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000296 if (!may_register_shutdown) {
297 msg_perr("Tried to register a shutdown function before "
298 "programmer init.\n");
299 return 1;
300 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000301 shutdown_fn[shutdown_fn_count].func = function;
302 shutdown_fn[shutdown_fn_count].data = data;
303 shutdown_fn_count++;
304
305 return 0;
306}
307
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +0000308int programmer_init(enum programmer prog, char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000309{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000310 int ret;
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +0000311
312 if (prog >= PROGRAMMER_INVALID) {
313 msg_perr("Invalid programmer specified!\n");
314 return -1;
315 }
316 programmer = prog;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000317 /* Initialize all programmer specific data. */
318 /* Default to unlimited decode sizes. */
319 max_rom_decode = (const struct decode_sizes) {
320 .parallel = 0xffffffff,
321 .lpc = 0xffffffff,
322 .fwh = 0xffffffff,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000323 .spi = 0xffffffff,
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000324 };
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000325 /* Default to top aligned flash at 4 GB. */
326 flashbase = 0;
327 /* Registering shutdown functions is now allowed. */
328 may_register_shutdown = 1;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000329 /* Default to allowing writes. Broken programmers set this to 0. */
330 programmer_may_write = 1;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000331
332 programmer_param = param;
333 msg_pdbg("Initializing %s programmer\n",
334 programmer_table[programmer].name);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000335 ret = programmer_table[programmer].init();
336 if (programmer_param && strlen(programmer_param)) {
337 msg_perr("Unhandled programmer parameters: %s\n",
338 programmer_param);
339 /* Do not error out here, the init itself was successful. */
340 }
341 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000342}
343
344int programmer_shutdown(void)
345{
David Hendricks8bb20212011-06-14 01:35:36 +0000346 int ret = 0;
347
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000348 /* Registering shutdown functions is no longer allowed. */
349 may_register_shutdown = 0;
350 while (shutdown_fn_count > 0) {
351 int i = --shutdown_fn_count;
David Hendricks8bb20212011-06-14 01:35:36 +0000352 ret |= shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000353 }
David Hendricks8bb20212011-06-14 01:35:36 +0000354 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000355}
356
357void *programmer_map_flash_region(const char *descr, unsigned long phys_addr,
358 size_t len)
359{
360 return programmer_table[programmer].map_flash_region(descr,
361 phys_addr, len);
362}
363
364void programmer_unmap_flash_region(void *virt_addr, size_t len)
365{
366 programmer_table[programmer].unmap_flash_region(virt_addr, len);
367}
368
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000369void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000370{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000371 flash->pgm->par.chip_writeb(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000372}
373
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000374void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000375{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000376 flash->pgm->par.chip_writew(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000377}
378
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000379void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000380{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000381 flash->pgm->par.chip_writel(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000382}
383
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000384void chip_writen(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
385 size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000386{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000387 flash->pgm->par.chip_writen(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000388}
389
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000390uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000391{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000392 return flash->pgm->par.chip_readb(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000393}
394
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000395uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000396{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000397 return flash->pgm->par.chip_readw(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000398}
399
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000400uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000401{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000402 return flash->pgm->par.chip_readl(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000403}
404
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000405void chip_readn(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
406 size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000407{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000408 flash->pgm->par.chip_readn(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000409}
410
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000411void programmer_delay(int usecs)
412{
413 programmer_table[programmer].delay(usecs);
414}
415
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000416void map_flash_registers(struct flashctx *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000417{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000418 size_t size = flash->chip->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000419 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000420 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000421 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000422}
423
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000424int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
425 int unsigned len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000426{
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000427 chip_readn(flash, buf, flash->virtual_memory + start, len);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000428
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000429 return 0;
430}
431
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000432int min(int a, int b)
433{
434 return (a < b) ? a : b;
435}
436
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000437int max(int a, int b)
438{
439 return (a > b) ? a : b;
440}
441
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000442int bitcount(unsigned long a)
443{
444 int i = 0;
445 for (; a != 0; a >>= 1)
446 if (a & 1)
447 i++;
448 return i;
449}
450
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000451void tolower_string(char *str)
452{
453 for (; *str != '\0'; str++)
454 *str = (char)tolower((unsigned char)*str);
455}
456
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000457char *strcat_realloc(char *dest, const char *src)
458{
459 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000460 if (!dest) {
461 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000462 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000463 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000464 strcat(dest, src);
465 return dest;
466}
467
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000468/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000469 * It will look for needle with a subsequent '=' in haystack, return a copy of
470 * needle and remove everything from the first occurrence of needle to the next
471 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000472 */
Stefan Tauner66652442011-06-26 17:38:17 +0000473char *extract_param(char **haystack, const char *needle, const char *delim)
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000474{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000475 char *param_pos, *opt_pos, *rest;
476 char *opt = NULL;
477 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000478 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000479
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000480 needlelen = strlen(needle);
481 if (!needlelen) {
482 msg_gerr("%s: empty needle! Please report a bug at "
483 "flashrom@flashrom.org\n", __func__);
484 return NULL;
485 }
486 /* No programmer parameters given. */
487 if (*haystack == NULL)
488 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000489 param_pos = strstr(*haystack, needle);
490 do {
491 if (!param_pos)
492 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000493 /* Needle followed by '='? */
494 if (param_pos[needlelen] == '=') {
495
496 /* Beginning of the string? */
497 if (param_pos == *haystack)
498 break;
499 /* After a delimiter? */
500 if (strchr(delim, *(param_pos - 1)))
501 break;
502 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000503 /* Continue searching. */
504 param_pos++;
505 param_pos = strstr(param_pos, needle);
506 } while (1);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000507
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000508 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000509 /* Get the string after needle and '='. */
510 opt_pos = param_pos + needlelen + 1;
511 optlen = strcspn(opt_pos, delim);
512 /* Return an empty string if the parameter was empty. */
513 opt = malloc(optlen + 1);
514 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000515 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000516 exit(1);
517 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000518 strncpy(opt, opt_pos, optlen);
519 opt[optlen] = '\0';
520 rest = opt_pos + optlen;
521 /* Skip all delimiters after the current parameter. */
522 rest += strspn(rest, delim);
523 memmove(param_pos, rest, strlen(rest) + 1);
524 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000525 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000526
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000527 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000528}
529
Stefan Tauner66652442011-06-26 17:38:17 +0000530char *extract_programmer_param(const char *param_name)
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000531{
532 return extract_param(&programmer_param, param_name, ",");
533}
534
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +0000535/* Returns the number of well-defined erasers for a chip. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000536static unsigned int count_usable_erasers(const struct flashctx *flash)
Stefan Tauner5368dca2011-07-01 00:19:12 +0000537{
538 unsigned int usable_erasefunctions = 0;
539 int k;
540 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
541 if (!check_block_eraser(flash, k, 0))
542 usable_erasefunctions++;
543 }
544 return usable_erasefunctions;
545}
546
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000547int compare_range(uint8_t *wantbuf, uint8_t *havebuf, unsigned int start, unsigned int len)
548{
549 int ret = 0, failcount = 0;
550 unsigned int i;
551 for (i = 0; i < len; i++) {
552 if (wantbuf[i] != havebuf[i]) {
553 /* Only print the first failure. */
554 if (!failcount++)
555 msg_cerr("FAILED at 0x%08x! Expected=0x%02x, Found=0x%02x,",
556 start + i, wantbuf[i], havebuf[i]);
557 }
558 }
559 if (failcount) {
560 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
561 start, start + len - 1, failcount);
562 ret = -1;
563 }
564 return ret;
565}
566
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000567/* start is an offset to the base address of the flash chip */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000568int check_erased_range(struct flashctx *flash, unsigned int start,
569 unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000570{
571 int ret;
572 uint8_t *cmpbuf = malloc(len);
573
574 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000575 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000576 exit(1);
577 }
578 memset(cmpbuf, 0xff, len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000579 ret = verify_range(flash, cmpbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000580 free(cmpbuf);
581 return ret;
582}
583
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000584/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000585 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000586 * flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000587 * @start offset to the base address of the flash chip
588 * @len length of the verified area
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000589 * @return 0 for success, -1 for failure
590 */
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000591int verify_range(struct flashctx *flash, uint8_t *cmpbuf, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000592{
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000593 uint8_t *readbuf = malloc(len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000594 int ret = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000595
596 if (!len)
597 goto out_free;
598
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000599 if (!flash->chip->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000600 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000601 return 1;
602 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000603 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000604 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000605 exit(1);
606 }
607
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000608 if (start + len > flash->chip->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000609 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000610 " total_size 0x%x\n", __func__, start, len,
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000611 flash->chip->total_size * 1024);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000612 ret = -1;
613 goto out_free;
614 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000615
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000616 ret = flash->chip->read(flash, readbuf, start, len);
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000617 if (ret) {
618 msg_gerr("Verification impossible because read failed "
619 "at 0x%x (len 0x%x)\n", start, len);
620 return ret;
621 }
622
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000623 ret = compare_range(cmpbuf, readbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000624out_free:
625 free(readbuf);
626 return ret;
627}
628
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000629/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000630 * Check if the buffer @have can be programmed to the content of @want without
631 * erasing. This is only possible if all chunks of size @gran are either kept
632 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000633 *
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000634 * Warning: This function assumes that @have and @want point to naturally
635 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000636 *
637 * @have buffer with current content
638 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000639 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000640 * @gran write granularity (enum, not count)
641 * @return 0 if no erase is needed, 1 otherwise
642 */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000643int need_erase(uint8_t *have, uint8_t *want, unsigned int len, enum write_granularity gran)
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000644{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000645 int result = 0;
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000646 unsigned int i, j, limit;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000647
648 switch (gran) {
649 case write_gran_1bit:
650 for (i = 0; i < len; i++)
651 if ((have[i] & want[i]) != want[i]) {
652 result = 1;
653 break;
654 }
655 break;
656 case write_gran_1byte:
657 for (i = 0; i < len; i++)
658 if ((have[i] != want[i]) && (have[i] != 0xff)) {
659 result = 1;
660 break;
661 }
662 break;
663 case write_gran_256bytes:
664 for (j = 0; j < len / 256; j++) {
665 limit = min (256, len - j * 256);
Uwe Hermann43959702010-03-13 17:28:29 +0000666 /* Are 'have' and 'want' identical? */
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000667 if (!memcmp(have + j * 256, want + j * 256, limit))
668 continue;
669 /* have needs to be in erased state. */
670 for (i = 0; i < limit; i++)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000671 if (have[j * 256 + i] != 0xff) {
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000672 result = 1;
673 break;
674 }
675 if (result)
676 break;
677 }
678 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000679 default:
680 msg_cerr("%s: Unsupported granularity! Please report a bug at "
681 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000682 }
683 return result;
684}
685
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000686/**
687 * Check if the buffer @have needs to be programmed to get the content of @want.
688 * If yes, return 1 and fill in first_start with the start address of the
689 * write operation and first_len with the length of the first to-be-written
690 * chunk. If not, return 0 and leave first_start and first_len undefined.
691 *
692 * Warning: This function assumes that @have and @want point to naturally
693 * aligned regions.
694 *
695 * @have buffer with current content
696 * @want buffer with desired content
697 * @len length of the checked area
698 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000699 * @first_start offset of the first byte which needs to be written (passed in
700 * value is increased by the offset of the first needed write
701 * relative to have/want or unchanged if no write is needed)
702 * @return length of the first contiguous area which needs to be written
703 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000704 *
705 * FIXME: This function needs a parameter which tells it about coalescing
706 * in relation to the max write length of the programmer and the max write
707 * length of the chip.
708 */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000709static unsigned int get_next_write(uint8_t *have, uint8_t *want, unsigned int len,
710 unsigned int *first_start,
711 enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000712{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000713 int need_write = 0;
714 unsigned int rel_start = 0, first_len = 0;
715 unsigned int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000716
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000717 switch (gran) {
718 case write_gran_1bit:
719 case write_gran_1byte:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000720 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000721 break;
722 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000723 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000724 break;
725 default:
726 msg_cerr("%s: Unsupported granularity! Please report a bug at "
727 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000728 /* Claim that no write was needed. A write with unknown
729 * granularity is too dangerous to try.
730 */
731 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000732 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000733 for (i = 0; i < len / stride; i++) {
734 limit = min(stride, len - i * stride);
735 /* Are 'have' and 'want' identical? */
736 if (memcmp(have + i * stride, want + i * stride, limit)) {
737 if (!need_write) {
738 /* First location where have and want differ. */
739 need_write = 1;
740 rel_start = i * stride;
741 }
742 } else {
743 if (need_write) {
744 /* First location where have and want
745 * do not differ anymore.
746 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000747 break;
748 }
749 }
750 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000751 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000752 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000753 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000754 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000755}
756
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000757/* This function generates various test patterns useful for testing controller
758 * and chip communication as well as chip behaviour.
759 *
760 * If a byte can be written multiple times, each time keeping 0-bits at 0
761 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
762 * is essentially an AND operation. That's also the reason why this function
763 * provides the result of AND between various patterns.
764 *
765 * Below is a list of patterns (and their block length).
766 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
767 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
768 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
769 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
770 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
771 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
772 * Pattern 6 is 00 (1 Byte)
773 * Pattern 7 is ff (1 Byte)
774 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
775 * byte block.
776 *
777 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
778 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
779 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
780 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
781 * Pattern 12 is 00 (1 Byte)
782 * Pattern 13 is ff (1 Byte)
783 * Patterns 8-13 have no block number.
784 *
785 * Patterns 0-3 are created to detect and efficiently diagnose communication
786 * slips like missed bits or bytes and their repetitive nature gives good visual
787 * cues to the person inspecting the results. In addition, the following holds:
788 * AND Pattern 0/1 == Pattern 4
789 * AND Pattern 2/3 == Pattern 5
790 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
791 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
792 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
793 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
794 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
795 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
796 * Besides that, they provide for bit testing of the last two bytes of every
797 * 256 byte block which contains the block number for patterns 0-6.
798 * Patterns 10-11 are special purpose for detecting subblock aliasing with
799 * block sizes >256 bytes (some Dataflash chips etc.)
800 * AND Pattern 8/9 == Pattern 12
801 * AND Pattern 10/11 == Pattern 12
802 * Pattern 13 is the completely erased state.
803 * None of the patterns can detect aliasing at boundaries which are a multiple
804 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
805 */
806int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
807{
808 int i;
809
810 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000811 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000812 return 1;
813 }
814
815 switch (variant) {
816 case 0:
817 for (i = 0; i < size; i++)
818 buf[i] = (i & 0xf) << 4 | 0x5;
819 break;
820 case 1:
821 for (i = 0; i < size; i++)
822 buf[i] = (i & 0xf) << 4 | 0xa;
823 break;
824 case 2:
825 for (i = 0; i < size; i++)
826 buf[i] = 0x50 | (i & 0xf);
827 break;
828 case 3:
829 for (i = 0; i < size; i++)
830 buf[i] = 0xa0 | (i & 0xf);
831 break;
832 case 4:
833 for (i = 0; i < size; i++)
834 buf[i] = (i & 0xf) << 4;
835 break;
836 case 5:
837 for (i = 0; i < size; i++)
838 buf[i] = i & 0xf;
839 break;
840 case 6:
841 memset(buf, 0x00, size);
842 break;
843 case 7:
844 memset(buf, 0xff, size);
845 break;
846 case 8:
847 for (i = 0; i < size; i++)
848 buf[i] = i & 0xff;
849 break;
850 case 9:
851 for (i = 0; i < size; i++)
852 buf[i] = ~(i & 0xff);
853 break;
854 case 10:
855 for (i = 0; i < size % 2; i++) {
856 buf[i * 2] = (i >> 8) & 0xff;
857 buf[i * 2 + 1] = i & 0xff;
858 }
859 if (size & 0x1)
860 buf[i * 2] = (i >> 8) & 0xff;
861 break;
862 case 11:
863 for (i = 0; i < size % 2; i++) {
864 buf[i * 2] = ~((i >> 8) & 0xff);
865 buf[i * 2 + 1] = ~(i & 0xff);
866 }
867 if (size & 0x1)
868 buf[i * 2] = ~((i >> 8) & 0xff);
869 break;
870 case 12:
871 memset(buf, 0x00, size);
872 break;
873 case 13:
874 memset(buf, 0xff, size);
875 break;
876 }
877
878 if ((variant >= 0) && (variant <= 7)) {
879 /* Write block number in the last two bytes of each 256-byte
880 * block, big endian for easier reading of the hexdump.
881 * Note that this wraps around for chips larger than 2^24 bytes
882 * (16 MB).
883 */
884 for (i = 0; i < size / 256; i++) {
885 buf[i * 256 + 254] = (i >> 8) & 0xff;
886 buf[i * 256 + 255] = i & 0xff;
887 }
888 }
889
890 return 0;
891}
892
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000893int check_max_decode(enum chipbustype buses, uint32_t size)
894{
895 int limitexceeded = 0;
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000896
897 if ((buses & BUS_PARALLEL) && (max_rom_decode.parallel < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000898 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +0000899 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000900 "size %u kB of chipset/board/programmer "
901 "for %s interface, "
902 "probe/read/erase/write may fail. ", size / 1024,
903 max_rom_decode.parallel / 1024, "Parallel");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000904 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +0000905 if ((buses & BUS_LPC) && (max_rom_decode.lpc < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000906 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +0000907 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000908 "size %u kB of chipset/board/programmer "
909 "for %s interface, "
910 "probe/read/erase/write may fail. ", size / 1024,
911 max_rom_decode.lpc / 1024, "LPC");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000912 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +0000913 if ((buses & BUS_FWH) && (max_rom_decode.fwh < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000914 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +0000915 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000916 "size %u kB of chipset/board/programmer "
917 "for %s interface, "
918 "probe/read/erase/write may fail. ", size / 1024,
919 max_rom_decode.fwh / 1024, "FWH");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000920 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +0000921 if ((buses & BUS_SPI) && (max_rom_decode.spi < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000922 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +0000923 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000924 "size %u kB of chipset/board/programmer "
925 "for %s interface, "
926 "probe/read/erase/write may fail. ", size / 1024,
927 max_rom_decode.spi / 1024, "SPI");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000928 }
929 if (!limitexceeded)
930 return 0;
931 /* Sometimes chip and programmer have more than one bus in common,
932 * and the limit is not exceeded on all buses. Tell the user.
933 */
934 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +0000935 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +0000936 msg_pdbg("There is at least one common chip/programmer "
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000937 "interface which can support a chip of this size. "
938 "You can try --force at your own risk.\n");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000939 return 1;
940}
941
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000942int probe_flash(struct registered_programmer *pgm, int startchip, struct flashctx *flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000943{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000944 const struct flashchip *chip;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000945 unsigned long base = 0;
Stefan Reinauer051e2362011-01-19 06:21:54 +0000946 char location[64];
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000947 uint32_t size;
948 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000949 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000950
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000951 for (chip = flashchips + startchip; chip && chip->name; chip++) {
952 if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +0000953 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000954 buses_common = pgm->buses_supported & chip->bustype;
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000955 if (!buses_common)
Carl-Daniel Hailfinger6573b742011-06-17 22:38:53 +0000956 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000957 msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
958 if (!chip->probe && !force) {
959 msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000960 continue;
961 }
Stefan Reinauer70385642007-04-06 11:58:03 +0000962
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000963 size = chip->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000964 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +0000965
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000966 /* Start filling in the dynamic data. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000967 flash->chip = calloc(1, sizeof(struct flashchip));
968 if (!flash->chip) {
969 msg_gerr("Out of memory!\n");
970 exit(1);
971 }
972 memcpy(flash->chip, chip, sizeof(struct flashchip));
973 flash->pgm = pgm;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000974
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +0000975 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000976 flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +0000977
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000978 /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
979 * is only called with force=1 after normal probing failed.
980 */
Peter Stuge27c3e2d2008-07-02 17:15:47 +0000981 if (force)
982 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +0000983
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000984 if (flash->chip->probe(flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +0000985 goto notfound;
986
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000987 /* If this is the first chip found, accept it.
988 * If this is not the first chip found, accept it only if it is
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000989 * a non-generic match. SFDP and CFI are generic matches.
990 * startchip==0 means this call to probe_flash() is the first
991 * one for this programmer interface and thus no other chip has
992 * been found on this interface.
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000993 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000994 if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000995 msg_cinfo("===\n"
996 "SFDP has autodetected a flash chip which is "
997 "not natively supported by flashrom yet.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000998 if (count_usable_erasers(flash) == 0)
Stefan Taunerac1b4c82012-02-17 14:51:04 +0000999 msg_cinfo("The standard operations read and "
1000 "verify should work, but to support "
1001 "erase, write and all other "
1002 "possible features");
1003 else
1004 msg_cinfo("All standard operations (read, "
1005 "verify, erase and write) should "
1006 "work, but to support all possible "
1007 "features");
1008
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001009 msg_cinfo(" we need to add them manually.\n"
1010 "You can help us by mailing us the output of the following command to "
1011 "flashrom@flashrom.org:\n"
1012 "'flashrom -VV [plus the -p/--programmer parameter]'\n"
1013 "Thanks for your help!\n"
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001014 "===\n");
1015 }
1016
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001017 /* First flash chip detected on this bus. */
1018 if (startchip == 0)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001019 break;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001020 /* Not the first flash chip detected on this bus, but not a generic match either. */
1021 if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
1022 break;
1023 /* 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 +00001024notfound:
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001025 programmer_unmap_flash_region((void *)flash->virtual_memory, size);
1026 flash->virtual_memory = (chipaddr)NULL;
1027 free(flash->chip);
1028 flash->chip = NULL;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001029 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001030
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001031 if (!flash->chip)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001032 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001033
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001034#if CONFIG_INTERNAL == 1
1035 if (programmer_table[programmer].map_flash_region == physmap)
Stefan Reinauer051e2362011-01-19 06:21:54 +00001036 snprintf(location, sizeof(location), "at physical address 0x%lx", base);
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001037 else
1038#endif
Stefan Reinauer051e2362011-01-19 06:21:54 +00001039 snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name);
Stefan Reinauer051e2362011-01-19 06:21:54 +00001040
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001041 tmp = flashbuses_to_text(flash->chip->bustype);
1042 msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) %s.\n", force ? "Assuming" : "Found",
1043 flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp, location);
Stefan Tauner00155492011-06-26 20:45:35 +00001044 free(tmp);
Uwe Hermann9899cad2009-06-28 21:47:57 +00001045
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +00001046 /* Flash registers will not be mapped if the chip was forced. Lock info
1047 * may be stored in registers, so avoid lock info printing.
1048 */
1049 if (!force)
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001050 if (flash->chip->printlock)
1051 flash->chip->printlock(flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +00001052
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001053 /* Return position of matching chip. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001054 return chip - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001055}
1056
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001057int read_buf_from_file(unsigned char *buf, unsigned long size,
1058 const char *filename)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001059{
1060 unsigned long numbytes;
1061 FILE *image;
1062 struct stat image_stat;
1063
1064 if ((image = fopen(filename, "rb")) == NULL) {
1065 perror(filename);
1066 return 1;
1067 }
1068 if (fstat(fileno(image), &image_stat) != 0) {
1069 perror(filename);
1070 fclose(image);
1071 return 1;
1072 }
1073 if (image_stat.st_size != size) {
Stefan Taunerd7d423b2012-10-20 09:13:16 +00001074 msg_gerr("Error: Image size (%ld B) doesn't match the flash chip's size (%ld B)!\n",
1075 image_stat.st_size, size);
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001076 fclose(image);
1077 return 1;
1078 }
1079 numbytes = fread(buf, 1, size, image);
1080 if (fclose(image)) {
1081 perror(filename);
1082 return 1;
1083 }
1084 if (numbytes != size) {
1085 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1086 "wanted %ld!\n", numbytes, size);
1087 return 1;
1088 }
1089 return 0;
1090}
1091
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001092int write_buf_to_file(unsigned char *buf, unsigned long size,
1093 const char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001094{
1095 unsigned long numbytes;
1096 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001097
1098 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001099 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001100 return 1;
1101 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001102 if ((image = fopen(filename, "wb")) == NULL) {
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001103 perror(filename);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001104 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001105 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001106
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001107 numbytes = fwrite(buf, 1, size, image);
1108 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001109 if (numbytes != size) {
1110 msg_gerr("File %s could not be written completely.\n",
1111 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001112 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001113 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001114 return 0;
1115}
1116
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001117int read_flash_to_file(struct flashctx *flash, const char *filename)
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001118{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001119 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001120 unsigned char *buf = calloc(size, sizeof(char));
1121 int ret = 0;
1122
1123 msg_cinfo("Reading flash... ");
1124 if (!buf) {
1125 msg_gerr("Memory allocation failed!\n");
1126 msg_cinfo("FAILED.\n");
1127 return 1;
1128 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001129 if (!flash->chip->read) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001130 msg_cerr("No read function available for this flash chip.\n");
1131 ret = 1;
1132 goto out_free;
1133 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001134 if (flash->chip->read(flash, buf, 0, size)) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001135 msg_cerr("Read operation failed!\n");
1136 ret = 1;
1137 goto out_free;
1138 }
1139
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001140 ret = write_buf_to_file(buf, size, filename);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001141out_free:
1142 free(buf);
1143 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1144 return ret;
1145}
1146
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001147/* This function shares a lot of its structure with erase_and_write_flash() and
1148 * walk_eraseregions().
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001149 * Even if an error is found, the function will keep going and check the rest.
1150 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001151static int selfcheck_eraseblocks(const struct flashchip *chip)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001152{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001153 int i, j, k;
1154 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001155
1156 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1157 unsigned int done = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001158 struct block_eraser eraser = chip->block_erasers[k];
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001159
1160 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1161 /* Blocks with zero size are bugs in flashchips.c. */
1162 if (eraser.eraseblocks[i].count &&
1163 !eraser.eraseblocks[i].size) {
1164 msg_gerr("ERROR: Flash chip %s erase function "
1165 "%i region %i has size 0. Please report"
1166 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001167 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001168 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001169 }
1170 /* Blocks with zero count are bugs in flashchips.c. */
1171 if (!eraser.eraseblocks[i].count &&
1172 eraser.eraseblocks[i].size) {
1173 msg_gerr("ERROR: Flash chip %s erase function "
1174 "%i region %i has count 0. Please report"
1175 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001176 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001177 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001178 }
1179 done += eraser.eraseblocks[i].count *
1180 eraser.eraseblocks[i].size;
1181 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001182 /* Empty eraseblock definition with erase function. */
1183 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001184 msg_gspew("Strange: Empty eraseblock definition with "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001185 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001186 if (!done)
1187 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001188 if (done != chip->total_size * 1024) {
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001189 msg_gerr("ERROR: Flash chip %s erase function %i "
1190 "region walking resulted in 0x%06x bytes total,"
1191 " expected 0x%06x bytes. Please report a bug at"
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001192 " flashrom@flashrom.org\n", chip->name, k,
1193 done, chip->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001194 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001195 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001196 if (!eraser.block_erase)
1197 continue;
1198 /* Check if there are identical erase functions for different
1199 * layouts. That would imply "magic" erase functions. The
1200 * easiest way to check this is with function pointers.
1201 */
Uwe Hermann43959702010-03-13 17:28:29 +00001202 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001203 if (eraser.block_erase ==
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001204 chip->block_erasers[j].block_erase) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001205 msg_gerr("ERROR: Flash chip %s erase function "
1206 "%i and %i are identical. Please report"
1207 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001208 chip->name, k, j);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001209 ret = 1;
1210 }
Uwe Hermann43959702010-03-13 17:28:29 +00001211 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001212 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001213 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001214}
1215
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001216static int erase_and_write_block_helper(struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001217 unsigned int start, unsigned int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001218 uint8_t *curcontents,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001219 uint8_t *newcontents,
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001220 int (*erasefn) (struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001221 unsigned int addr,
1222 unsigned int len))
1223{
Stefan Taunerc69c9c82011-11-23 09:13:48 +00001224 unsigned int starthere = 0, lenhere = 0;
1225 int ret = 0, skip = 1, writecount = 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001226 enum write_granularity gran = write_gran_256bytes; /* FIXME */
1227
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001228 /* curcontents and newcontents are opaque to walk_eraseregions, and
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001229 * need to be adjusted here to keep the impression of proper abstraction
1230 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001231 curcontents += start;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001232 newcontents += start;
1233 msg_cdbg(":");
1234 /* FIXME: Assume 256 byte granularity for now to play it safe. */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001235 if (need_erase(curcontents, newcontents, len, gran)) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001236 msg_cdbg("E");
1237 ret = erasefn(flash, start, len);
1238 if (ret)
1239 return ret;
Carl-Daniel Hailfingerb4061f62011-06-26 17:04:16 +00001240 if (check_erased_range(flash, start, len)) {
1241 msg_cerr("ERASE FAILED!\n");
1242 return -1;
1243 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001244 /* Erase was successful. Adjust curcontents. */
1245 memset(curcontents, 0xff, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001246 skip = 0;
1247 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001248 /* get_next_write() sets starthere to a new value after the call. */
1249 while ((lenhere = get_next_write(curcontents + starthere,
1250 newcontents + starthere,
1251 len - starthere, &starthere, gran))) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001252 if (!writecount++)
1253 msg_cdbg("W");
1254 /* Needs the partial write function signature. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001255 ret = flash->chip->write(flash, newcontents + starthere,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001256 start + starthere, lenhere);
1257 if (ret)
1258 return ret;
1259 starthere += lenhere;
1260 skip = 0;
1261 }
1262 if (skip)
1263 msg_cdbg("S");
1264 return ret;
1265}
1266
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001267static int walk_eraseregions(struct flashctx *flash, int erasefunction,
1268 int (*do_something) (struct flashctx *flash,
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001269 unsigned int addr,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001270 unsigned int len,
1271 uint8_t *param1,
1272 uint8_t *param2,
1273 int (*erasefn) (
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001274 struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001275 unsigned int addr,
1276 unsigned int len)),
1277 void *param1, void *param2)
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001278{
1279 int i, j;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001280 unsigned int start = 0;
1281 unsigned int len;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001282 struct block_eraser eraser = flash->chip->block_erasers[erasefunction];
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001283
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001284 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1285 /* count==0 for all automatically initialized array
1286 * members so the loop below won't be executed for them.
1287 */
1288 len = eraser.eraseblocks[i].size;
1289 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001290 /* Print this for every block except the first one. */
1291 if (i || j)
1292 msg_cdbg(", ");
1293 msg_cdbg("0x%06x-0x%06x", start,
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001294 start + len - 1);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001295 if (do_something(flash, start, len, param1, param2,
1296 eraser.block_erase)) {
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001297 return 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001298 }
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001299 start += len;
1300 }
1301 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001302 msg_cdbg("\n");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001303 return 0;
1304}
1305
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001306static int check_block_eraser(const struct flashctx *flash, int k, int log)
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001307{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001308 struct block_eraser eraser = flash->chip->block_erasers[k];
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001309
1310 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
1311 if (log)
1312 msg_cdbg("not defined. ");
1313 return 1;
1314 }
1315 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
1316 if (log)
1317 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001318 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001319 return 1;
1320 }
1321 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
1322 if (log)
1323 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001324 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001325 return 1;
1326 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001327 // TODO: Once erase functions are annotated with allowed buses, check that as well.
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001328 return 0;
1329}
1330
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001331int erase_and_write_flash(struct flashctx *flash, uint8_t *oldcontents,
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001332 uint8_t *newcontents)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001333{
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001334 int k, ret = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001335 uint8_t *curcontents;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001336 unsigned long size = flash->chip->total_size * 1024;
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001337 unsigned int usable_erasefunctions = count_usable_erasers(flash);
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001338
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001339 msg_cinfo("Erasing and writing flash chip... ");
Stefan Tauner269de352011-07-12 22:35:21 +00001340 curcontents = malloc(size);
1341 if (!curcontents) {
1342 msg_gerr("Out of memory!\n");
1343 exit(1);
1344 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001345 /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1346 memcpy(curcontents, oldcontents, size);
1347
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001348 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001349 if (k != 0)
1350 msg_cdbg("Looking for another erase function.\n");
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001351 if (!usable_erasefunctions) {
1352 msg_cdbg("No usable erase functions left.\n");
1353 break;
1354 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001355 msg_cdbg("Trying erase function %i... ", k);
1356 if (check_block_eraser(flash, k, 1))
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001357 continue;
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001358 usable_erasefunctions--;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001359 ret = walk_eraseregions(flash, k, &erase_and_write_block_helper,
1360 curcontents, newcontents);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001361 /* If everything is OK, don't try another erase function. */
1362 if (!ret)
1363 break;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001364 /* Write/erase failed, so try to find out what the current chip
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001365 * contents are. If no usable erase functions remain, we can
1366 * skip this: the next iteration will break immediately anyway.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001367 */
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001368 if (!usable_erasefunctions)
1369 continue;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001370 /* Reading the whole chip may take a while, inform the user even
1371 * in non-verbose mode.
1372 */
1373 msg_cinfo("Reading current flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001374 if (flash->chip->read(flash, curcontents, 0, size)) {
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001375 /* Now we are truly screwed. Read failed as well. */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001376 msg_cerr("Can't read anymore! Aborting.\n");
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001377 /* We have no idea about the flash chip contents, so
1378 * retrying with another erase function is pointless.
1379 */
1380 break;
1381 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001382 msg_cinfo("done. ");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001383 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001384 /* Free the scratchpad. */
1385 free(curcontents);
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001386
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001387 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001388 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001389 } else {
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001390 msg_cinfo("Erase/write done.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001391 }
1392 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001393}
1394
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001395void nonfatal_help_message(void)
1396{
1397 msg_gerr("Writing to the flash chip apparently didn't do anything.\n"
1398 "This means we have to add special support for your board, "
1399 "programmer or flash chip.\n"
1400 "Please report this on IRC at irc.freenode.net (channel "
1401 "#flashrom) or\n"
1402 "mail flashrom@flashrom.org!\n"
1403 "-------------------------------------------------------------"
1404 "------------------\n"
1405 "You may now reboot or simply leave the machine running.\n");
1406}
1407
Uwe Hermannc67d0372009-10-01 18:40:02 +00001408void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001409{
Sean Nelson316a29f2010-05-07 20:09:04 +00001410 msg_gerr("Your flash chip is in an unknown state.\n"
Stefan Tauner2abab942012-04-27 20:41:23 +00001411 "Get help on IRC at chat.freenode.net (channel #flashrom) or\n"
Stefan Tauner78ffbea2012-10-27 15:36:56 +00001412 "mail flashrom@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
1413 "-------------------------------------------------------------------------------\n"
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001414 "DO NOT REBOOT OR POWEROFF!\n");
1415}
1416
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001417/* The way to go if you want a delimited list of programmers */
Stefan Tauner66652442011-06-26 17:38:17 +00001418void list_programmers(const char *delim)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001419{
1420 enum programmer p;
1421 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001422 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001423 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001424 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001425 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001426 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001427}
1428
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001429void list_programmers_linebreak(int startcol, int cols, int paren)
1430{
1431 const char *pname;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001432 int pnamelen;
1433 int remaining = 0, firstline = 1;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001434 enum programmer p;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001435 int i;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001436
1437 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1438 pname = programmer_table[p].name;
1439 pnamelen = strlen(pname);
1440 if (remaining - pnamelen - 2 < 0) {
1441 if (firstline)
1442 firstline = 0;
1443 else
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001444 msg_ginfo("\n");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001445 for (i = 0; i < startcol; i++)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001446 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001447 remaining = cols - startcol;
1448 } else {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001449 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001450 remaining--;
1451 }
1452 if (paren && (p == 0)) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001453 msg_ginfo("(");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001454 remaining--;
1455 }
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001456 msg_ginfo("%s", pname);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001457 remaining -= pnamelen;
1458 if (p < PROGRAMMER_INVALID - 1) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001459 msg_ginfo(",");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001460 remaining--;
1461 } else {
1462 if (paren)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001463 msg_ginfo(")");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001464 }
1465 }
1466}
1467
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001468void print_sysinfo(void)
1469{
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001470#ifdef _WIN32
1471 SYSTEM_INFO si;
1472 OSVERSIONINFOEX osvi;
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001473
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001474 memset(&si, 0, sizeof(SYSTEM_INFO));
1475 memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
1476 msg_ginfo(" on Windows");
1477 /* Tell Windows which version of the structure we want. */
1478 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1479 if (GetVersionEx((OSVERSIONINFO*) &osvi))
1480 msg_ginfo(" %lu.%lu", osvi.dwMajorVersion, osvi.dwMinorVersion);
1481 else
1482 msg_ginfo(" unknown version");
1483 GetSystemInfo(&si);
1484 switch (si.wProcessorArchitecture) {
1485 case PROCESSOR_ARCHITECTURE_AMD64:
1486 msg_ginfo(" (x86_64)");
1487 break;
1488 case PROCESSOR_ARCHITECTURE_INTEL:
1489 msg_ginfo(" (x86)");
1490 break;
1491 default:
1492 msg_ginfo(" (unknown arch)");
1493 break;
1494 }
1495#elif HAVE_UTSNAME == 1
1496 struct utsname osinfo;
1497
1498 uname(&osinfo);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001499 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1500 osinfo.machine);
1501#else
1502 msg_ginfo(" on unknown machine");
1503#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001504}
1505
1506void print_buildinfo(void)
1507{
1508 msg_gdbg("flashrom was built with");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001509#if NEED_PCI == 1
1510#ifdef PCILIB_VERSION
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001511 msg_gdbg(" libpci %s,", PCILIB_VERSION);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001512#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001513 msg_gdbg(" unknown PCI library,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001514#endif
1515#endif
1516#ifdef __clang__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001517 msg_gdbg(" LLVM Clang");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001518#ifdef __clang_version__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001519 msg_gdbg(" %s,", __clang_version__);
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001520#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001521 msg_gdbg(" unknown version (before r102686),");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001522#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001523#elif defined(__GNUC__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001524 msg_gdbg(" GCC");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001525#ifdef __VERSION__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001526 msg_gdbg(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001527#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001528 msg_gdbg(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001529#endif
1530#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001531 msg_gdbg(" unknown compiler,");
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001532#endif
1533#if defined (__FLASHROM_LITTLE_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001534 msg_gdbg(" little endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001535#elif defined (__FLASHROM_BIG_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001536 msg_gdbg(" big endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001537#else
1538#error Endianness could not be determined
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001539#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001540 msg_gdbg("\n");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001541}
1542
Bernhard Walle201bde32008-01-21 15:24:22 +00001543void print_version(void)
1544{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001545 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001546 print_sysinfo();
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001547 msg_ginfo("\n");
Bernhard Walle201bde32008-01-21 15:24:22 +00001548}
1549
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001550void print_banner(void)
1551{
1552 msg_ginfo("flashrom is free software, get the source code at "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001553 "http://www.flashrom.org\n");
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001554 msg_ginfo("\n");
1555}
1556
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001557int selfcheck(void)
1558{
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001559 int ret = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001560 const struct flashchip *chip;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001561
1562 /* Safety check. Instead of aborting after the first error, check
1563 * if more errors exist.
1564 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001565 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001566 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001567 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001568 }
Stefan Tauner93f70232011-07-26 14:33:46 +00001569 /* It would be favorable if we could also check for correct termination
Stefan Tauner716e0982011-07-25 20:38:52 +00001570 * of the following arrays, but we don't know their sizes in here...
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001571 * For 'flashchips' we check the first element to be non-null. In the
1572 * other cases there exist use cases where the first element can be
1573 * null. */
1574 if (flashchips == NULL || flashchips[0].vendor == NULL) {
1575 msg_gerr("Flashchips table miscompilation!\n");
1576 ret = 1;
1577 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001578 for (chip = flashchips; chip && chip->name; chip++)
1579 if (selfcheck_eraseblocks(chip))
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001580 ret = 1;
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001581
1582#if CONFIG_INTERNAL == 1
1583 if (chipset_enables == NULL) {
1584 msg_gerr("Chipset enables table does not exist!\n");
1585 ret = 1;
1586 }
Carl-Daniel Hailfinger97d5b122011-08-31 16:19:50 +00001587 if (board_matches == NULL) {
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001588 msg_gerr("Board enables table does not exist!\n");
1589 ret = 1;
1590 }
1591 if (boards_known == NULL) {
1592 msg_gerr("Known boards table does not exist!\n");
1593 ret = 1;
1594 }
1595 if (laptops_known == NULL) {
1596 msg_gerr("Known laptops table does not exist!\n");
1597 ret = 1;
1598 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001599#endif
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001600 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001601}
1602
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001603void check_chip_supported(const struct flashchip *chip)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001604{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001605 if (chip->feature_bits & FEATURE_OTP) {
Daniel Lenski65922a32012-02-15 23:40:23 +00001606 msg_cdbg("This chip may contain one-time programmable memory. "
1607 "flashrom cannot read\nand may never be able to write "
1608 "it, hence it may not be able to completely\n"
1609 "clone the contents of this chip (see man page for "
1610 "details).\n");
1611 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001612 if (TEST_OK_MASK != (chip->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001613 msg_cinfo("===\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001614 if (chip->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001615 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001616 if (chip->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001617 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001618 if (chip->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001619 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001620 if (chip->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001621 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001622 if (chip->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001623 msg_cinfo(" WRITE");
1624 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001625 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001626 if ((!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE)) ||
1627 (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ)) ||
1628 (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE)) ||
1629 (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001630 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001631 if (!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001632 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001633 if (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001634 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001635 if (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001636 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001637 if (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001638 msg_cinfo(" WRITE");
1639 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001640 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001641 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001642 msg_cinfo("The test status of this chip may have been updated "
1643 "in the latest development\n"
1644 "version of flashrom. If you are running the latest "
1645 "development version,\n"
1646 "please email a report to flashrom@flashrom.org if "
1647 "any of the above operations\n"
1648 "work correctly for you with this flash part. Please "
1649 "include the flashrom\n"
1650 "output with the additional -V option for all "
1651 "operations you tested (-V, -Vr,\n"
Paul Menzele3800132012-01-12 13:58:43 +00001652 "-VE, -Vw), and mention which mainboard or "
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001653 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001654 "Please mention your board in the subject line. "
1655 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001656 }
1657}
1658
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001659/* FIXME: This function signature needs to be improved once doit() has a better
1660 * function signature.
1661 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001662int chip_safety_check(const struct flashctx *flash, int force, int read_it, int write_it, int erase_it,
1663 int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001664{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001665 const struct flashchip *chip = flash->chip;
1666
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001667 if (!programmer_may_write && (write_it || erase_it)) {
1668 msg_perr("Write/erase is not working yet on your programmer in "
1669 "its current configuration.\n");
1670 /* --force is the wrong approach, but it's the best we can do
1671 * until the generic programmer parameter parser is merged.
1672 */
1673 if (!force)
1674 return 1;
1675 msg_cerr("Continuing anyway.\n");
1676 }
1677
1678 if (read_it || erase_it || write_it || verify_it) {
1679 /* Everything needs read. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001680 if (chip->tested & TEST_BAD_READ) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001681 msg_cerr("Read is not working on this chip. ");
1682 if (!force)
1683 return 1;
1684 msg_cerr("Continuing anyway.\n");
1685 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001686 if (!chip->read) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001687 msg_cerr("flashrom has no read function for this "
1688 "flash chip.\n");
1689 return 1;
1690 }
1691 }
1692 if (erase_it || write_it) {
1693 /* Write needs erase. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001694 if (chip->tested & TEST_BAD_ERASE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001695 msg_cerr("Erase is not working on this chip. ");
1696 if (!force)
1697 return 1;
1698 msg_cerr("Continuing anyway.\n");
1699 }
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001700 if(count_usable_erasers(flash) == 0) {
Stefan Tauner5368dca2011-07-01 00:19:12 +00001701 msg_cerr("flashrom has no erase function for this "
1702 "flash chip.\n");
1703 return 1;
1704 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001705 }
1706 if (write_it) {
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001707 if (chip->tested & TEST_BAD_WRITE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001708 msg_cerr("Write is not working on this chip. ");
1709 if (!force)
1710 return 1;
1711 msg_cerr("Continuing anyway.\n");
1712 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001713 if (!chip->write) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001714 msg_cerr("flashrom has no write function for this "
1715 "flash chip.\n");
1716 return 1;
1717 }
1718 }
1719 return 0;
1720}
1721
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001722/* This function signature is horrible. We need to design a better interface,
1723 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001724 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001725 */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +00001726int doit(struct flashctx *flash, int force, const char *filename, int read_it,
1727 int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001728{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001729 uint8_t *oldcontents;
1730 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001731 int ret = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001732 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001733
David Hendricks77f931a2011-05-18 01:30:56 +00001734 if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001735 msg_cerr("Aborting.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001736 ret = 1;
1737 goto out_nofree;
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001738 }
1739
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001740 /* Given the existence of read locks, we want to unlock for read,
1741 * erase and write.
1742 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001743 if (flash->chip->unlock)
1744 flash->chip->unlock(flash);
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001745
1746 if (read_it) {
1747 ret = read_flash_to_file(flash, filename);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001748 goto out_nofree;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001749 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001750
Stefan Tauner269de352011-07-12 22:35:21 +00001751 oldcontents = malloc(size);
1752 if (!oldcontents) {
1753 msg_gerr("Out of memory!\n");
1754 exit(1);
1755 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001756 /* Assume worst case: All bits are 0. */
1757 memset(oldcontents, 0x00, size);
Stefan Tauner269de352011-07-12 22:35:21 +00001758 newcontents = malloc(size);
1759 if (!newcontents) {
1760 msg_gerr("Out of memory!\n");
1761 exit(1);
1762 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001763 /* Assume best case: All bits should be 1. */
1764 memset(newcontents, 0xff, size);
1765 /* Side effect of the assumptions above: Default write action is erase
1766 * because newcontents looks like a completely erased chip, and
1767 * oldcontents being completely 0x00 means we have to erase everything
1768 * before we can write.
1769 */
1770
Ollie Lhoefa28582004-12-08 20:10:01 +00001771 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001772 /* FIXME: Do we really want the scary warning if erase failed?
1773 * After all, after erase the chip is either blank or partially
1774 * blank or it has the old contents. A blank chip won't boot,
1775 * so if the user wanted erase and reboots afterwards, the user
1776 * knows very well that booting won't work.
1777 */
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001778 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001779 emergency_help_message();
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001780 ret = 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001781 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001782 goto out;
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001783 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001784
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001785 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001786 if (read_buf_from_file(newcontents, size, filename)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001787 ret = 1;
1788 goto out;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001789 }
1790
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001791#if CONFIG_INTERNAL == 1
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001792 if (programmer == PROGRAMMER_INTERNAL && cb_check_image(newcontents, size) < 0) {
1793 if (force_boardmismatch) {
1794 msg_pinfo("Proceeding anyway because user forced us to.\n");
1795 } else {
1796 msg_perr("Aborting. You can override this with "
1797 "-p internal:boardmismatch=force.\n");
Niklas Söderlund9e423762012-06-16 00:11:16 +00001798 ret = 1;
1799 goto out;
1800 }
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001801 }
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001802#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001803 }
1804
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001805 /* Read the whole chip to be able to check whether regions need to be
1806 * erased and to give better diagnostics in case write fails.
1807 * The alternative would be to read only the regions which are to be
1808 * preserved, but in that case we might perform unneeded erase which
1809 * takes time as well.
1810 */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001811 msg_cinfo("Reading old flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001812 if (flash->chip->read(flash, oldcontents, 0, size)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001813 ret = 1;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001814 msg_cinfo("FAILED.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001815 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001816 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001817 msg_cinfo("done.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001818
Ollie Lho184a4042005-11-26 21:55:36 +00001819 // This should be moved into each flash part's code to do it
1820 // cleanly. This does the job.
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001821 handle_romentries(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001822
Ollie Lho184a4042005-11-26 21:55:36 +00001823 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00001824
Peter Stugef31104c2008-04-28 14:47:30 +00001825 if (write_it) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001826 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
1827 msg_cerr("Uh oh. Erase/write failed. Checking if "
1828 "anything changed.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001829 if (!flash->chip->read(flash, newcontents, 0, size)) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001830 if (!memcmp(oldcontents, newcontents, size)) {
1831 msg_cinfo("Good. It seems nothing was "
1832 "changed.\n");
1833 nonfatal_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001834 ret = 1;
1835 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001836 }
1837 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001838 emergency_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001839 ret = 1;
1840 goto out;
Peter Stugef31104c2008-04-28 14:47:30 +00001841 }
Peter Stugef31104c2008-04-28 14:47:30 +00001842 }
Ollie Lho184a4042005-11-26 21:55:36 +00001843
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001844 if (verify_it) {
Stefan Tauner78ffbea2012-10-27 15:36:56 +00001845 msg_cinfo("Verifying flash... ");
1846
1847 if (write_it) {
1848 /* Work around chips which need some time to calm down. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001849 programmer_delay(1000*1000);
Stefan Tauner78ffbea2012-10-27 15:36:56 +00001850 ret = verify_range(flash, newcontents, 0, size);
1851 /* If we tried to write, and verification now fails, we
1852 * might have an emergency situation.
1853 */
1854 if (ret)
1855 emergency_help_message();
1856 } else {
1857 ret = compare_range(newcontents, oldcontents, 0, size);
1858 }
1859 if (!ret)
1860 msg_cinfo("VERIFIED.\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001861 }
Ollie Lho184a4042005-11-26 21:55:36 +00001862
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001863out:
1864 free(oldcontents);
1865 free(newcontents);
1866out_nofree:
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00001867 programmer_shutdown();
Stefan Reinauer143da0b2006-01-04 16:42:57 +00001868 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001869}