blob: 23728f635a634a3a58b83bcd844a686aa9b9c43e [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>
Stefan Tauner363fd7e2013-04-07 13:08:30 +000032#include <errno.h>
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +000033#include <ctype.h>
Ollie Lho184a4042005-11-26 21:55:36 +000034#include <getopt.h>
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +000035#if HAVE_UTSNAME == 1
36#include <sys/utsname.h>
37#endif
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000038#include "flash.h"
Carl-Daniel Hailfinger08454642009-06-15 14:14:48 +000039#include "flashchips.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000040#include "programmer.h"
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +000041#include "hwaccess.h"
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000042
Mathias Krausea60faab2011-01-17 07:50:42 +000043const char flashrom_version[] = FLASHROM_VERSION;
Nico Huberbcb2e5a2012-12-30 01:23:17 +000044const char *chip_to_probe = NULL;
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +000045int verbose_screen = MSG_INFO;
46int verbose_logfile = MSG_DEBUG2;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000047
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +000048static enum programmer programmer = PROGRAMMER_INVALID;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000049
Nico Huberbcb2e5a2012-12-30 01:23:17 +000050static const char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +000051
Uwe Hermann48ec1b12010-08-08 17:01:18 +000052/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000053 * Programmers supporting multiple buses can have differing size limits on
54 * each bus. Store the limits for each bus in a common struct.
55 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000056struct decode_sizes max_rom_decode;
57
58/* If nonzero, used as the start address of bottom-aligned flash. */
59unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000060
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +000061/* Is writing allowed with this programmer? */
62int programmer_may_write;
63
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000064const struct programmer_entry programmer_table[] = {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000065#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000066 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000067 .name = "internal",
Stefan Tauneraf358d62012-12-27 18:40:26 +000068 .type = OTHER,
69 .devs.note = NULL,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +000070 .init = internal_init,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +000071 .map_flash_region = physmap,
72 .unmap_flash_region = physunmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000073 .delay = internal_delay,
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000074 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000075#endif
Luc Verhaegen8e3a6002007-04-04 22:45:58 +000076
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000077#if CONFIG_DUMMY == 1
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000078 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000079 .name = "dummy",
Stefan Tauneraf358d62012-12-27 18:40:26 +000080 .type = OTHER,
81 /* FIXME */
82 .devs.note = "Dummy device, does nothing and logs all accesses\n",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +000083 .init = dummy_init,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +000084 .map_flash_region = dummy_map,
85 .unmap_flash_region = dummy_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000086 .delay = internal_delay,
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000087 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +000088#endif
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +000089
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000090#if CONFIG_NIC3COM == 1
Uwe Hermannb4dcb712009-05-13 11:36:06 +000091 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +000092 .name = "nic3com",
Stefan Tauneraf358d62012-12-27 18:40:26 +000093 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +000094 .devs.dev = nics_3com,
Uwe Hermannb4dcb712009-05-13 11:36:06 +000095 .init = nic3com_init,
Uwe Hermannc6915932009-05-17 23:12:17 +000096 .map_flash_region = fallback_map,
97 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +000098 .delay = internal_delay,
Uwe Hermannb4dcb712009-05-13 11:36:06 +000099 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000100#endif
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000101
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000102#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +0000103 {
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000104 /* This programmer works for Realtek RTL8139 and SMC 1211. */
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000105 .name = "nicrealtek",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000106 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000107 .devs.dev = nics_realtek,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000108 .init = nicrealtek_init,
109 .map_flash_region = fallback_map,
110 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000111 .delay = internal_delay,
Joerg Fischer5665ef32010-05-21 21:54:07 +0000112 },
Joerg Fischer5665ef32010-05-21 21:54:07 +0000113#endif
114
Andrew Morganc29c2e72010-06-07 22:37:54 +0000115#if CONFIG_NICNATSEMI == 1
116 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000117 .name = "nicnatsemi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000118 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000119 .devs.dev = nics_natsemi,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000120 .init = nicnatsemi_init,
121 .map_flash_region = fallback_map,
122 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000123 .delay = internal_delay,
Andrew Morganc29c2e72010-06-07 22:37:54 +0000124 },
125#endif
Joerg Fischer5665ef32010-05-21 21:54:07 +0000126
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000127#if CONFIG_GFXNVIDIA == 1
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000128 {
129 .name = "gfxnvidia",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000130 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000131 .devs.dev = gfx_nvidia,
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000132 .init = gfxnvidia_init,
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000133 .map_flash_region = fallback_map,
134 .unmap_flash_region = fallback_unmap,
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000135 .delay = internal_delay,
136 },
137#endif
138
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000139#if CONFIG_DRKAISER == 1
Rudolf Marek68720c72009-05-17 19:39:27 +0000140 {
TURBO Jb0912c02009-09-02 23:00:46 +0000141 .name = "drkaiser",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000142 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000143 .devs.dev = drkaiser_pcidev,
TURBO Jb0912c02009-09-02 23:00:46 +0000144 .init = drkaiser_init,
TURBO Jb0912c02009-09-02 23:00:46 +0000145 .map_flash_region = fallback_map,
146 .unmap_flash_region = fallback_unmap,
TURBO Jb0912c02009-09-02 23:00:46 +0000147 .delay = internal_delay,
148 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000149#endif
TURBO Jb0912c02009-09-02 23:00:46 +0000150
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000151#if CONFIG_SATASII == 1
TURBO Jb0912c02009-09-02 23:00:46 +0000152 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000153 .name = "satasii",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000154 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000155 .devs.dev = satas_sii,
Rudolf Marek68720c72009-05-17 19:39:27 +0000156 .init = satasii_init,
Uwe Hermannc6915932009-05-17 23:12:17 +0000157 .map_flash_region = fallback_map,
158 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000159 .delay = internal_delay,
Rudolf Marek68720c72009-05-17 19:39:27 +0000160 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000161#endif
Rudolf Marek68720c72009-05-17 19:39:27 +0000162
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000163#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000164 {
165 .name = "atahpt",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000166 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000167 .devs.dev = ata_hpt,
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000168 .init = atahpt_init,
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000169 .map_flash_region = fallback_map,
170 .unmap_flash_region = fallback_unmap,
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000171 .delay = internal_delay,
172 },
173#endif
174
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000175#if CONFIG_FT2232_SPI == 1
Paul Fox05dfbe62009-06-16 21:08:06 +0000176 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000177 .name = "ft2232_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000178 .type = USB,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000179 .devs.dev = devs_ft2232spi,
Paul Fox05dfbe62009-06-16 21:08:06 +0000180 .init = ft2232_spi_init,
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000181 .map_flash_region = fallback_map,
182 .unmap_flash_region = fallback_unmap,
Paul Fox05dfbe62009-06-16 21:08:06 +0000183 .delay = internal_delay,
184 },
Carl-Daniel Hailfinger3426ef62009-08-19 13:27:58 +0000185#endif
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000186
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000187#if CONFIG_SERPROG == 1
Urja Rannikko22915352009-06-23 11:33:43 +0000188 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000189 .name = "serprog",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000190 .type = OTHER,
191 /* FIXME */
192 .devs.note = "All programmer devices speaking the serprog protocol\n",
Urja Rannikko22915352009-06-23 11:33:43 +0000193 .init = serprog_init,
Urja Rannikko22915352009-06-23 11:33:43 +0000194 .map_flash_region = fallback_map,
195 .unmap_flash_region = fallback_unmap,
Urja Rannikko22915352009-06-23 11:33:43 +0000196 .delay = serprog_delay,
197 },
Carl-Daniel Hailfinger6be74112009-08-12 16:17:41 +0000198#endif
Paul Fox05dfbe62009-06-16 21:08:06 +0000199
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000200#if CONFIG_BUSPIRATE_SPI == 1
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000201 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000202 .name = "buspirate_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000203 .type = OTHER,
204 /* FIXME */
205 .devs.note = "Dangerous Prototypes Bus Pirate\n",
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000206 .init = buspirate_spi_init,
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000207 .map_flash_region = fallback_map,
208 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000209 .delay = internal_delay,
210 },
211#endif
212
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000213#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000214 {
215 .name = "dediprog",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000216 .type = OTHER,
217 /* FIXME */
218 .devs.note = "Dediprog SF100\n",
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000219 .init = dediprog_init,
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000220 .map_flash_region = fallback_map,
221 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000222 .delay = internal_delay,
223 },
224#endif
225
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000226#if CONFIG_RAYER_SPI == 1
227 {
228 .name = "rayer_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000229 .type = OTHER,
230 /* FIXME */
231 .devs.note = "RayeR parallel port programmer\n",
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000232 .init = rayer_spi_init,
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000233 .map_flash_region = fallback_map,
234 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000235 .delay = internal_delay,
236 },
237#endif
238
Virgil-Adrian Teacada7c5452012-04-30 23:11:06 +0000239#if CONFIG_PONY_SPI == 1
240 {
241 .name = "pony_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000242 .type = OTHER,
243 /* FIXME */
244 .devs.note = "Programmers compatible with SI-Prog, serbang or AJAWe\n",
Virgil-Adrian Teacada7c5452012-04-30 23:11:06 +0000245 .init = pony_spi_init,
246 .map_flash_region = fallback_map,
247 .unmap_flash_region = fallback_unmap,
248 .delay = internal_delay,
Stefan Tauneraf358d62012-12-27 18:40:26 +0000249 },
Virgil-Adrian Teacada7c5452012-04-30 23:11:06 +0000250#endif
251
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000252#if CONFIG_NICINTEL == 1
253 {
254 .name = "nicintel",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000255 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000256 .devs.dev = nics_intel,
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000257 .init = nicintel_init,
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000258 .map_flash_region = fallback_map,
259 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000260 .delay = internal_delay,
261 },
262#endif
263
Idwer Vollering004f4b72010-09-03 18:21:21 +0000264#if CONFIG_NICINTEL_SPI == 1
265 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000266 .name = "nicintel_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000267 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000268 .devs.dev = nics_intel_spi,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000269 .init = nicintel_spi_init,
270 .map_flash_region = fallback_map,
271 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000272 .delay = internal_delay,
Idwer Vollering004f4b72010-09-03 18:21:21 +0000273 },
274#endif
275
Mark Marshall90021f22010-12-03 14:48:11 +0000276#if CONFIG_OGP_SPI == 1
277 {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000278 .name = "ogp_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000279 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000280 .devs.dev = ogp_spi,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000281 .init = ogp_spi_init,
282 .map_flash_region = fallback_map,
283 .unmap_flash_region = fallback_unmap,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000284 .delay = internal_delay,
Mark Marshall90021f22010-12-03 14:48:11 +0000285 },
286#endif
287
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000288#if CONFIG_SATAMV == 1
289 {
290 .name = "satamv",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000291 .type = PCI,
Stefan Tauner4b24a2d2012-12-27 18:40:36 +0000292 .devs.dev = satas_mv,
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000293 .init = satamv_init,
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000294 .map_flash_region = fallback_map,
295 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000296 .delay = internal_delay,
297 },
298#endif
299
Sven Schnelle5ce5f702011-09-03 18:37:52 +0000300#if CONFIG_LINUX_SPI == 1
301 {
302 .name = "linux_spi",
Stefan Tauneraf358d62012-12-27 18:40:26 +0000303 .type = OTHER,
304 .devs.note = "Device files /dev/spidev*.*\n",
Sven Schnelle5ce5f702011-09-03 18:37:52 +0000305 .init = linux_spi_init,
306 .map_flash_region = fallback_map,
307 .unmap_flash_region = fallback_unmap,
Sven Schnelle5ce5f702011-09-03 18:37:52 +0000308 .delay = internal_delay,
309 },
310#endif
311
James Lairdc60de0e2013-03-27 13:00:23 +0000312#if CONFIG_USBBLASTER_SPI == 1
313 {
314 .name = "usbblaster_spi",
315 .type = USB,
316 .devs.dev = devs_usbblasterspi,
317 .init = usbblaster_spi_init,
318 .map_flash_region = fallback_map,
319 .unmap_flash_region = fallback_unmap,
320 .delay = internal_delay,
321 },
322#endif
323
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +0000324 {0}, /* This entry corresponds to PROGRAMMER_INVALID. */
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000325};
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000326
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000327#define SHUTDOWN_MAXFN 32
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000328static int shutdown_fn_count = 0;
329struct shutdown_func_data {
David Hendricks8bb20212011-06-14 01:35:36 +0000330 int (*func) (void *data);
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000331 void *data;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000332} static shutdown_fn[SHUTDOWN_MAXFN];
333/* Initialize to 0 to make sure nobody registers a shutdown function before
334 * programmer init.
335 */
336static int may_register_shutdown = 0;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000337
Stefan Taunerc4f44df2013-08-12 22:58:43 +0000338/* Did we change something or was every erase/write skipped (if any)? */
339static bool all_skipped = true;
340
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000341static int check_block_eraser(const struct flashctx *flash, int k, int log);
Stefan Tauner5368dca2011-07-01 00:19:12 +0000342
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000343/* Register a function to be executed on programmer shutdown.
344 * The advantage over atexit() is that you can supply a void pointer which will
345 * be used as parameter to the registered function upon programmer shutdown.
346 * This pointer can point to arbitrary data used by said function, e.g. undo
347 * information for GPIO settings etc. If unneeded, set data=NULL.
348 * Please note that the first (void *data) belongs to the function signature of
349 * the function passed as first parameter.
350 */
David Hendricks8bb20212011-06-14 01:35:36 +0000351int register_shutdown(int (*function) (void *data), void *data)
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000352{
353 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000354 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000355 SHUTDOWN_MAXFN);
356 return 1;
357 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000358 if (!may_register_shutdown) {
359 msg_perr("Tried to register a shutdown function before "
360 "programmer init.\n");
361 return 1;
362 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000363 shutdown_fn[shutdown_fn_count].func = function;
364 shutdown_fn[shutdown_fn_count].data = data;
365 shutdown_fn_count++;
366
367 return 0;
368}
369
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000370int programmer_init(enum programmer prog, const char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000371{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000372 int ret;
Carl-Daniel Hailfinger2e681602011-09-08 00:00:29 +0000373
374 if (prog >= PROGRAMMER_INVALID) {
375 msg_perr("Invalid programmer specified!\n");
376 return -1;
377 }
378 programmer = prog;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000379 /* Initialize all programmer specific data. */
380 /* Default to unlimited decode sizes. */
381 max_rom_decode = (const struct decode_sizes) {
382 .parallel = 0xffffffff,
383 .lpc = 0xffffffff,
384 .fwh = 0xffffffff,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000385 .spi = 0xffffffff,
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000386 };
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000387 /* Default to top aligned flash at 4 GB. */
388 flashbase = 0;
389 /* Registering shutdown functions is now allowed. */
390 may_register_shutdown = 1;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000391 /* Default to allowing writes. Broken programmers set this to 0. */
392 programmer_may_write = 1;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000393
394 programmer_param = param;
Carl-Daniel Hailfinger20a36ba2013-08-13 07:09:57 +0000395 msg_pdbg("Initializing %s programmer\n", programmer_table[programmer].name);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000396 ret = programmer_table[programmer].init();
397 if (programmer_param && strlen(programmer_param)) {
Carl-Daniel Hailfinger20a36ba2013-08-13 07:09:57 +0000398 if (ret != 0) {
399 /* It is quite possible that any unhandled programmer parameter would have been valid,
400 * but an error in actual programmer init happened before the parameter was evaluated.
401 */
402 msg_pwarn("Unhandled programmer parameters (possibly due to another failure): %s\n",
403 programmer_param);
404 } else {
405 /* Actual programmer init was successful, but the user specified an invalid or unusable
406 * (for the current programmer configuration) parameter.
407 */
408 msg_perr("Unhandled programmer parameters: %s\n", programmer_param);
409 msg_perr("Aborting.\n");
410 ret = ERROR_FATAL;
411 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000412 }
413 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000414}
415
416int programmer_shutdown(void)
417{
David Hendricks8bb20212011-06-14 01:35:36 +0000418 int ret = 0;
419
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000420 /* Registering shutdown functions is no longer allowed. */
421 may_register_shutdown = 0;
422 while (shutdown_fn_count > 0) {
423 int i = --shutdown_fn_count;
David Hendricks8bb20212011-06-14 01:35:36 +0000424 ret |= shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000425 }
Stefan Taunere34e3e82013-01-01 00:06:51 +0000426
Stefan Taunerb8911d62012-12-26 07:55:00 +0000427 programmer_param = NULL;
Stefan Taunere34e3e82013-01-01 00:06:51 +0000428 registered_programmer_count = 0;
429
David Hendricks8bb20212011-06-14 01:35:36 +0000430 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000431}
432
Stefan Tauner305e0b92013-07-17 23:46:44 +0000433void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000434{
Stefan Tauner26e7a152013-09-13 17:21:05 +0000435 void *ret = programmer_table[programmer].map_flash_region(descr, phys_addr, len);
436 msg_gspew("%s: mapping %s from 0x%0*" PRIxPTR " to 0x%0*" PRIxPTR "\n",
437 __func__, descr, PRIxPTR_WIDTH, phys_addr, PRIxPTR_WIDTH, (uintptr_t) ret);
438 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000439}
440
441void programmer_unmap_flash_region(void *virt_addr, size_t len)
442{
443 programmer_table[programmer].unmap_flash_region(virt_addr, len);
444}
445
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000446void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000447{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000448 flash->pgm->par.chip_writeb(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000449}
450
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000451void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000452{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000453 flash->pgm->par.chip_writew(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000454}
455
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000456void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000457{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000458 flash->pgm->par.chip_writel(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000459}
460
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000461void chip_writen(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
462 size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000463{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000464 flash->pgm->par.chip_writen(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000465}
466
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000467uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000468{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000469 return flash->pgm->par.chip_readb(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000470}
471
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000472uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000473{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000474 return flash->pgm->par.chip_readw(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000475}
476
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000477uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000478{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000479 return flash->pgm->par.chip_readl(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000480}
481
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000482void chip_readn(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
483 size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000484{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000485 flash->pgm->par.chip_readn(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000486}
487
Stefan Taunerf80419c2014-05-02 15:41:42 +0000488void programmer_delay(unsigned int usecs)
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000489{
Urja Rannikko8d7ec2a2013-10-21 21:49:08 +0000490 if (usecs > 0)
491 programmer_table[programmer].delay(usecs);
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000492}
493
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000494void map_flash_registers(struct flashctx *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000495{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000496 size_t size = flash->chip->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000497 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000498 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000499 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000500}
501
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000502int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
503 int unsigned len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000504{
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000505 chip_readn(flash, buf, flash->virtual_memory + start, len);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000506
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000507 return 0;
508}
509
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000510int min(int a, int b)
511{
512 return (a < b) ? a : b;
513}
514
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000515int max(int a, int b)
516{
517 return (a > b) ? a : b;
518}
519
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000520int bitcount(unsigned long a)
521{
522 int i = 0;
523 for (; a != 0; a >>= 1)
524 if (a & 1)
525 i++;
526 return i;
527}
528
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000529void tolower_string(char *str)
530{
531 for (; *str != '\0'; str++)
532 *str = (char)tolower((unsigned char)*str);
533}
534
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000535char *strcat_realloc(char *dest, const char *src)
536{
537 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000538 if (!dest) {
539 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000540 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000541 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000542 strcat(dest, src);
543 return dest;
544}
545
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000546/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000547 * It will look for needle with a subsequent '=' in haystack, return a copy of
548 * needle and remove everything from the first occurrence of needle to the next
549 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000550 */
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000551char *extract_param(const char *const *haystack, const char *needle, const char *delim)
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000552{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000553 char *param_pos, *opt_pos, *rest;
554 char *opt = NULL;
555 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000556 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000557
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000558 needlelen = strlen(needle);
559 if (!needlelen) {
560 msg_gerr("%s: empty needle! Please report a bug at "
561 "flashrom@flashrom.org\n", __func__);
562 return NULL;
563 }
564 /* No programmer parameters given. */
565 if (*haystack == NULL)
566 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000567 param_pos = strstr(*haystack, needle);
568 do {
569 if (!param_pos)
570 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000571 /* Needle followed by '='? */
572 if (param_pos[needlelen] == '=') {
573
574 /* Beginning of the string? */
575 if (param_pos == *haystack)
576 break;
577 /* After a delimiter? */
578 if (strchr(delim, *(param_pos - 1)))
579 break;
580 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000581 /* Continue searching. */
582 param_pos++;
583 param_pos = strstr(param_pos, needle);
584 } while (1);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000585
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000586 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000587 /* Get the string after needle and '='. */
588 opt_pos = param_pos + needlelen + 1;
589 optlen = strcspn(opt_pos, delim);
590 /* Return an empty string if the parameter was empty. */
591 opt = malloc(optlen + 1);
592 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000593 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000594 exit(1);
595 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000596 strncpy(opt, opt_pos, optlen);
597 opt[optlen] = '\0';
598 rest = opt_pos + optlen;
599 /* Skip all delimiters after the current parameter. */
600 rest += strspn(rest, delim);
601 memmove(param_pos, rest, strlen(rest) + 1);
602 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000603 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000604
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000605 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000606}
607
Stefan Tauner66652442011-06-26 17:38:17 +0000608char *extract_programmer_param(const char *param_name)
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000609{
610 return extract_param(&programmer_param, param_name, ",");
611}
612
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +0000613/* Returns the number of well-defined erasers for a chip. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000614static unsigned int count_usable_erasers(const struct flashctx *flash)
Stefan Tauner5368dca2011-07-01 00:19:12 +0000615{
616 unsigned int usable_erasefunctions = 0;
617 int k;
618 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
619 if (!check_block_eraser(flash, k, 0))
620 usable_erasefunctions++;
621 }
622 return usable_erasefunctions;
623}
624
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000625int compare_range(uint8_t *wantbuf, uint8_t *havebuf, unsigned int start, unsigned int len)
626{
627 int ret = 0, failcount = 0;
628 unsigned int i;
629 for (i = 0; i < len; i++) {
630 if (wantbuf[i] != havebuf[i]) {
631 /* Only print the first failure. */
632 if (!failcount++)
633 msg_cerr("FAILED at 0x%08x! Expected=0x%02x, Found=0x%02x,",
634 start + i, wantbuf[i], havebuf[i]);
635 }
636 }
637 if (failcount) {
638 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
639 start, start + len - 1, failcount);
640 ret = -1;
641 }
642 return ret;
643}
644
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000645/* start is an offset to the base address of the flash chip */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000646int check_erased_range(struct flashctx *flash, unsigned int start,
647 unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000648{
649 int ret;
650 uint8_t *cmpbuf = malloc(len);
651
652 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000653 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000654 exit(1);
655 }
656 memset(cmpbuf, 0xff, len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000657 ret = verify_range(flash, cmpbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000658 free(cmpbuf);
659 return ret;
660}
661
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000662/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000663 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000664 * flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000665 * @start offset to the base address of the flash chip
666 * @len length of the verified area
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000667 * @return 0 for success, -1 for failure
668 */
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000669int verify_range(struct flashctx *flash, uint8_t *cmpbuf, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000670{
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000671 uint8_t *readbuf = malloc(len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000672 int ret = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000673
674 if (!len)
675 goto out_free;
676
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000677 if (!flash->chip->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000678 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000679 return 1;
680 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000681 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000682 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000683 exit(1);
684 }
685
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000686 if (start + len > flash->chip->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000687 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000688 " total_size 0x%x\n", __func__, start, len,
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000689 flash->chip->total_size * 1024);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000690 ret = -1;
691 goto out_free;
692 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000693
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000694 ret = flash->chip->read(flash, readbuf, start, len);
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000695 if (ret) {
696 msg_gerr("Verification impossible because read failed "
697 "at 0x%x (len 0x%x)\n", start, len);
698 return ret;
699 }
700
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000701 ret = compare_range(cmpbuf, readbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000702out_free:
703 free(readbuf);
704 return ret;
705}
706
Stefan Tauner02437452013-04-01 19:34:53 +0000707/* Helper function for need_erase() that focuses on granularities of gran bytes. */
708static int need_erase_gran_bytes(uint8_t *have, uint8_t *want, unsigned int len, unsigned int gran)
709{
710 unsigned int i, j, limit;
711 for (j = 0; j < len / gran; j++) {
712 limit = min (gran, len - j * gran);
713 /* Are 'have' and 'want' identical? */
714 if (!memcmp(have + j * gran, want + j * gran, limit))
715 continue;
716 /* have needs to be in erased state. */
717 for (i = 0; i < limit; i++)
718 if (have[j * gran + i] != 0xff)
719 return 1;
720 }
721 return 0;
722}
723
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000724/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000725 * Check if the buffer @have can be programmed to the content of @want without
726 * erasing. This is only possible if all chunks of size @gran are either kept
727 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000728 *
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000729 * Warning: This function assumes that @have and @want point to naturally
730 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000731 *
732 * @have buffer with current content
733 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000734 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000735 * @gran write granularity (enum, not count)
736 * @return 0 if no erase is needed, 1 otherwise
737 */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000738int need_erase(uint8_t *have, uint8_t *want, unsigned int len, enum write_granularity gran)
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000739{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000740 int result = 0;
Stefan Tauner02437452013-04-01 19:34:53 +0000741 unsigned int i;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000742
743 switch (gran) {
744 case write_gran_1bit:
745 for (i = 0; i < len; i++)
746 if ((have[i] & want[i]) != want[i]) {
747 result = 1;
748 break;
749 }
750 break;
751 case write_gran_1byte:
752 for (i = 0; i < len; i++)
753 if ((have[i] != want[i]) && (have[i] != 0xff)) {
754 result = 1;
755 break;
756 }
757 break;
758 case write_gran_256bytes:
Stefan Tauner02437452013-04-01 19:34:53 +0000759 result = need_erase_gran_bytes(have, want, len, 256);
760 break;
761 case write_gran_264bytes:
762 result = need_erase_gran_bytes(have, want, len, 264);
763 break;
764 case write_gran_512bytes:
765 result = need_erase_gran_bytes(have, want, len, 512);
766 break;
767 case write_gran_528bytes:
768 result = need_erase_gran_bytes(have, want, len, 528);
769 break;
770 case write_gran_1024bytes:
771 result = need_erase_gran_bytes(have, want, len, 1024);
772 break;
773 case write_gran_1056bytes:
774 result = need_erase_gran_bytes(have, want, len, 1056);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000775 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000776 default:
777 msg_cerr("%s: Unsupported granularity! Please report a bug at "
778 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000779 }
780 return result;
781}
782
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000783/**
784 * Check if the buffer @have needs to be programmed to get the content of @want.
785 * If yes, return 1 and fill in first_start with the start address of the
786 * write operation and first_len with the length of the first to-be-written
787 * chunk. If not, return 0 and leave first_start and first_len undefined.
788 *
789 * Warning: This function assumes that @have and @want point to naturally
790 * aligned regions.
791 *
792 * @have buffer with current content
793 * @want buffer with desired content
794 * @len length of the checked area
795 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000796 * @first_start offset of the first byte which needs to be written (passed in
797 * value is increased by the offset of the first needed write
798 * relative to have/want or unchanged if no write is needed)
799 * @return length of the first contiguous area which needs to be written
800 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000801 *
802 * FIXME: This function needs a parameter which tells it about coalescing
803 * in relation to the max write length of the programmer and the max write
804 * length of the chip.
805 */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000806static unsigned int get_next_write(uint8_t *have, uint8_t *want, unsigned int len,
807 unsigned int *first_start,
808 enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000809{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000810 int need_write = 0;
811 unsigned int rel_start = 0, first_len = 0;
812 unsigned int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000813
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000814 switch (gran) {
815 case write_gran_1bit:
816 case write_gran_1byte:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000817 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000818 break;
819 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000820 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000821 break;
Stefan Tauner02437452013-04-01 19:34:53 +0000822 case write_gran_264bytes:
823 stride = 264;
824 break;
825 case write_gran_512bytes:
826 stride = 512;
827 break;
828 case write_gran_528bytes:
829 stride = 528;
830 break;
831 case write_gran_1024bytes:
832 stride = 1024;
833 break;
834 case write_gran_1056bytes:
835 stride = 1056;
836 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000837 default:
838 msg_cerr("%s: Unsupported granularity! Please report a bug at "
839 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000840 /* Claim that no write was needed. A write with unknown
841 * granularity is too dangerous to try.
842 */
843 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000844 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000845 for (i = 0; i < len / stride; i++) {
846 limit = min(stride, len - i * stride);
847 /* Are 'have' and 'want' identical? */
848 if (memcmp(have + i * stride, want + i * stride, limit)) {
849 if (!need_write) {
850 /* First location where have and want differ. */
851 need_write = 1;
852 rel_start = i * stride;
853 }
854 } else {
855 if (need_write) {
856 /* First location where have and want
857 * do not differ anymore.
858 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000859 break;
860 }
861 }
862 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000863 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000864 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000865 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000866 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000867}
868
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000869/* This function generates various test patterns useful for testing controller
870 * and chip communication as well as chip behaviour.
871 *
872 * If a byte can be written multiple times, each time keeping 0-bits at 0
873 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
874 * is essentially an AND operation. That's also the reason why this function
875 * provides the result of AND between various patterns.
876 *
877 * Below is a list of patterns (and their block length).
878 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
879 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
880 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
881 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
882 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
883 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
884 * Pattern 6 is 00 (1 Byte)
885 * Pattern 7 is ff (1 Byte)
886 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
887 * byte block.
888 *
889 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
890 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
891 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
892 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
893 * Pattern 12 is 00 (1 Byte)
894 * Pattern 13 is ff (1 Byte)
895 * Patterns 8-13 have no block number.
896 *
897 * Patterns 0-3 are created to detect and efficiently diagnose communication
898 * slips like missed bits or bytes and their repetitive nature gives good visual
899 * cues to the person inspecting the results. In addition, the following holds:
900 * AND Pattern 0/1 == Pattern 4
901 * AND Pattern 2/3 == Pattern 5
902 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
903 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
904 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
905 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
906 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
907 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
908 * Besides that, they provide for bit testing of the last two bytes of every
909 * 256 byte block which contains the block number for patterns 0-6.
910 * Patterns 10-11 are special purpose for detecting subblock aliasing with
911 * block sizes >256 bytes (some Dataflash chips etc.)
912 * AND Pattern 8/9 == Pattern 12
913 * AND Pattern 10/11 == Pattern 12
914 * Pattern 13 is the completely erased state.
915 * None of the patterns can detect aliasing at boundaries which are a multiple
916 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
917 */
918int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
919{
920 int i;
921
922 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000923 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000924 return 1;
925 }
926
927 switch (variant) {
928 case 0:
929 for (i = 0; i < size; i++)
930 buf[i] = (i & 0xf) << 4 | 0x5;
931 break;
932 case 1:
933 for (i = 0; i < size; i++)
934 buf[i] = (i & 0xf) << 4 | 0xa;
935 break;
936 case 2:
937 for (i = 0; i < size; i++)
938 buf[i] = 0x50 | (i & 0xf);
939 break;
940 case 3:
941 for (i = 0; i < size; i++)
942 buf[i] = 0xa0 | (i & 0xf);
943 break;
944 case 4:
945 for (i = 0; i < size; i++)
946 buf[i] = (i & 0xf) << 4;
947 break;
948 case 5:
949 for (i = 0; i < size; i++)
950 buf[i] = i & 0xf;
951 break;
952 case 6:
953 memset(buf, 0x00, size);
954 break;
955 case 7:
956 memset(buf, 0xff, size);
957 break;
958 case 8:
959 for (i = 0; i < size; i++)
960 buf[i] = i & 0xff;
961 break;
962 case 9:
963 for (i = 0; i < size; i++)
964 buf[i] = ~(i & 0xff);
965 break;
966 case 10:
967 for (i = 0; i < size % 2; i++) {
968 buf[i * 2] = (i >> 8) & 0xff;
969 buf[i * 2 + 1] = i & 0xff;
970 }
971 if (size & 0x1)
972 buf[i * 2] = (i >> 8) & 0xff;
973 break;
974 case 11:
975 for (i = 0; i < size % 2; i++) {
976 buf[i * 2] = ~((i >> 8) & 0xff);
977 buf[i * 2 + 1] = ~(i & 0xff);
978 }
979 if (size & 0x1)
980 buf[i * 2] = ~((i >> 8) & 0xff);
981 break;
982 case 12:
983 memset(buf, 0x00, size);
984 break;
985 case 13:
986 memset(buf, 0xff, size);
987 break;
988 }
989
990 if ((variant >= 0) && (variant <= 7)) {
991 /* Write block number in the last two bytes of each 256-byte
992 * block, big endian for easier reading of the hexdump.
993 * Note that this wraps around for chips larger than 2^24 bytes
994 * (16 MB).
995 */
996 for (i = 0; i < size / 256; i++) {
997 buf[i * 256 + 254] = (i >> 8) & 0xff;
998 buf[i * 256 + 255] = i & 0xff;
999 }
1000 }
1001
1002 return 0;
1003}
1004
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001005int check_max_decode(enum chipbustype buses, uint32_t size)
1006{
1007 int limitexceeded = 0;
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001008
1009 if ((buses & BUS_PARALLEL) && (max_rom_decode.parallel < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001010 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001011 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001012 "size %u kB of chipset/board/programmer "
1013 "for %s interface, "
1014 "probe/read/erase/write may fail. ", size / 1024,
1015 max_rom_decode.parallel / 1024, "Parallel");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001016 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001017 if ((buses & BUS_LPC) && (max_rom_decode.lpc < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001018 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001019 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001020 "size %u kB of chipset/board/programmer "
1021 "for %s interface, "
1022 "probe/read/erase/write may fail. ", size / 1024,
1023 max_rom_decode.lpc / 1024, "LPC");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001024 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001025 if ((buses & BUS_FWH) && (max_rom_decode.fwh < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001026 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001027 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001028 "size %u kB of chipset/board/programmer "
1029 "for %s interface, "
1030 "probe/read/erase/write may fail. ", size / 1024,
1031 max_rom_decode.fwh / 1024, "FWH");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001032 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001033 if ((buses & BUS_SPI) && (max_rom_decode.spi < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001034 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001035 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001036 "size %u kB of chipset/board/programmer "
1037 "for %s interface, "
1038 "probe/read/erase/write may fail. ", size / 1024,
1039 max_rom_decode.spi / 1024, "SPI");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001040 }
1041 if (!limitexceeded)
1042 return 0;
1043 /* Sometimes chip and programmer have more than one bus in common,
1044 * and the limit is not exceeded on all buses. Tell the user.
1045 */
1046 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001047 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +00001048 msg_pdbg("There is at least one common chip/programmer "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001049 "interface which can support a chip of this size. "
1050 "You can try --force at your own risk.\n");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001051 return 1;
1052}
1053
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001054int probe_flash(struct registered_programmer *pgm, int startchip, struct flashctx *flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001055{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001056 const struct flashchip *chip;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001057 unsigned long base = 0;
Stefan Reinauer051e2362011-01-19 06:21:54 +00001058 char location[64];
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001059 uint32_t size;
1060 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001061 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001062
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001063 for (chip = flashchips + startchip; chip && chip->name; chip++) {
1064 if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +00001065 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001066 buses_common = pgm->buses_supported & chip->bustype;
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +00001067 if (!buses_common)
Carl-Daniel Hailfinger6573b742011-06-17 22:38:53 +00001068 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001069 msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
1070 if (!chip->probe && !force) {
1071 msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001072 continue;
1073 }
Stefan Reinauer70385642007-04-06 11:58:03 +00001074
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001075 size = chip->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001076 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +00001077
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001078 /* Start filling in the dynamic data. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001079 flash->chip = calloc(1, sizeof(struct flashchip));
1080 if (!flash->chip) {
1081 msg_gerr("Out of memory!\n");
1082 exit(1);
1083 }
1084 memcpy(flash->chip, chip, sizeof(struct flashchip));
1085 flash->pgm = pgm;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001086
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +00001087 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001088 flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001089
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001090 /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
1091 * is only called with force=1 after normal probing failed.
1092 */
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001093 if (force)
1094 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001095
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001096 if (flash->chip->probe(flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +00001097 goto notfound;
1098
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001099 /* If this is the first chip found, accept it.
1100 * If this is not the first chip found, accept it only if it is
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001101 * a non-generic match. SFDP and CFI are generic matches.
1102 * startchip==0 means this call to probe_flash() is the first
1103 * one for this programmer interface and thus no other chip has
1104 * been found on this interface.
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001105 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001106 if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001107 msg_cinfo("===\n"
1108 "SFDP has autodetected a flash chip which is "
1109 "not natively supported by flashrom yet.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001110 if (count_usable_erasers(flash) == 0)
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001111 msg_cinfo("The standard operations read and "
1112 "verify should work, but to support "
1113 "erase, write and all other "
1114 "possible features");
1115 else
1116 msg_cinfo("All standard operations (read, "
1117 "verify, erase and write) should "
1118 "work, but to support all possible "
1119 "features");
1120
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001121 msg_cinfo(" we need to add them manually.\n"
1122 "You can help us by mailing us the output of the following command to "
1123 "flashrom@flashrom.org:\n"
1124 "'flashrom -VV [plus the -p/--programmer parameter]'\n"
1125 "Thanks for your help!\n"
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001126 "===\n");
1127 }
1128
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001129 /* First flash chip detected on this bus. */
1130 if (startchip == 0)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001131 break;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001132 /* Not the first flash chip detected on this bus, but not a generic match either. */
1133 if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
1134 break;
1135 /* 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 +00001136notfound:
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001137 programmer_unmap_flash_region((void *)flash->virtual_memory, size);
1138 flash->virtual_memory = (chipaddr)NULL;
1139 free(flash->chip);
1140 flash->chip = NULL;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001141 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001142
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001143 if (!flash->chip)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001144 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001145
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001146#if CONFIG_INTERNAL == 1
1147 if (programmer_table[programmer].map_flash_region == physmap)
Stefan Reinauer051e2362011-01-19 06:21:54 +00001148 snprintf(location, sizeof(location), "at physical address 0x%lx", base);
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001149 else
1150#endif
Stefan Reinauer051e2362011-01-19 06:21:54 +00001151 snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name);
Stefan Reinauer051e2362011-01-19 06:21:54 +00001152
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001153 tmp = flashbuses_to_text(flash->chip->bustype);
1154 msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) %s.\n", force ? "Assuming" : "Found",
1155 flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp, location);
Stefan Tauner00155492011-06-26 20:45:35 +00001156 free(tmp);
Uwe Hermann9899cad2009-06-28 21:47:57 +00001157
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +00001158 /* Flash registers will not be mapped if the chip was forced. Lock info
1159 * may be stored in registers, so avoid lock info printing.
1160 */
1161 if (!force)
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001162 if (flash->chip->printlock)
1163 flash->chip->printlock(flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +00001164
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001165 /* Return position of matching chip. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001166 return chip - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001167}
1168
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001169int read_buf_from_file(unsigned char *buf, unsigned long size,
1170 const char *filename)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001171{
Nico Huber7562f7d2013-08-30 21:29:45 +00001172#ifdef __LIBPAYLOAD__
1173 msg_gerr("Error: No file I/O support in libpayload\n");
1174 return 1;
1175#else
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001176 unsigned long numbytes;
1177 FILE *image;
1178 struct stat image_stat;
1179
1180 if ((image = fopen(filename, "rb")) == NULL) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001181 msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001182 return 1;
1183 }
1184 if (fstat(fileno(image), &image_stat) != 0) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001185 msg_gerr("Error: getting metadata of file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001186 fclose(image);
1187 return 1;
1188 }
1189 if (image_stat.st_size != size) {
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +00001190 msg_gerr("Error: Image size (%jd B) doesn't match the flash chip's size (%lu B)!\n",
Stefan Taunere038e902013-02-04 04:38:42 +00001191 (intmax_t)image_stat.st_size, size);
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001192 fclose(image);
1193 return 1;
1194 }
1195 numbytes = fread(buf, 1, size, image);
1196 if (fclose(image)) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001197 msg_gerr("Error: closing file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001198 return 1;
1199 }
1200 if (numbytes != size) {
1201 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1202 "wanted %ld!\n", numbytes, size);
1203 return 1;
1204 }
1205 return 0;
Nico Huber7562f7d2013-08-30 21:29:45 +00001206#endif
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001207}
1208
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001209int write_buf_to_file(unsigned char *buf, unsigned long size,
1210 const char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001211{
Nico Huber7562f7d2013-08-30 21:29:45 +00001212#ifdef __LIBPAYLOAD__
1213 msg_gerr("Error: No file I/O support in libpayload\n");
1214 return 1;
1215#else
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001216 unsigned long numbytes;
1217 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001218
1219 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001220 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001221 return 1;
1222 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001223 if ((image = fopen(filename, "wb")) == NULL) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001224 msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001225 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001226 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001227
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001228 numbytes = fwrite(buf, 1, size, image);
1229 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001230 if (numbytes != size) {
1231 msg_gerr("File %s could not be written completely.\n",
1232 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001233 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001234 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001235 return 0;
Nico Huber7562f7d2013-08-30 21:29:45 +00001236#endif
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001237}
1238
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001239int read_flash_to_file(struct flashctx *flash, const char *filename)
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001240{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001241 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001242 unsigned char *buf = calloc(size, sizeof(char));
1243 int ret = 0;
1244
1245 msg_cinfo("Reading flash... ");
1246 if (!buf) {
1247 msg_gerr("Memory allocation failed!\n");
1248 msg_cinfo("FAILED.\n");
1249 return 1;
1250 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001251 if (!flash->chip->read) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001252 msg_cerr("No read function available for this flash chip.\n");
1253 ret = 1;
1254 goto out_free;
1255 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001256 if (flash->chip->read(flash, buf, 0, size)) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001257 msg_cerr("Read operation failed!\n");
1258 ret = 1;
1259 goto out_free;
1260 }
1261
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001262 ret = write_buf_to_file(buf, size, filename);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001263out_free:
1264 free(buf);
1265 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1266 return ret;
1267}
1268
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001269/* This function shares a lot of its structure with erase_and_write_flash() and
1270 * walk_eraseregions().
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001271 * Even if an error is found, the function will keep going and check the rest.
1272 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001273static int selfcheck_eraseblocks(const struct flashchip *chip)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001274{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001275 int i, j, k;
1276 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001277
1278 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1279 unsigned int done = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001280 struct block_eraser eraser = chip->block_erasers[k];
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001281
1282 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1283 /* Blocks with zero size are bugs in flashchips.c. */
1284 if (eraser.eraseblocks[i].count &&
1285 !eraser.eraseblocks[i].size) {
1286 msg_gerr("ERROR: Flash chip %s erase function "
1287 "%i region %i has size 0. Please report"
1288 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001289 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001290 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001291 }
1292 /* Blocks with zero count are bugs in flashchips.c. */
1293 if (!eraser.eraseblocks[i].count &&
1294 eraser.eraseblocks[i].size) {
1295 msg_gerr("ERROR: Flash chip %s erase function "
1296 "%i region %i has count 0. Please report"
1297 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001298 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001299 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001300 }
1301 done += eraser.eraseblocks[i].count *
1302 eraser.eraseblocks[i].size;
1303 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001304 /* Empty eraseblock definition with erase function. */
1305 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001306 msg_gspew("Strange: Empty eraseblock definition with "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001307 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001308 if (!done)
1309 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001310 if (done != chip->total_size * 1024) {
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001311 msg_gerr("ERROR: Flash chip %s erase function %i "
1312 "region walking resulted in 0x%06x bytes total,"
1313 " expected 0x%06x bytes. Please report a bug at"
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001314 " flashrom@flashrom.org\n", chip->name, k,
1315 done, chip->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001316 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001317 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001318 if (!eraser.block_erase)
1319 continue;
1320 /* Check if there are identical erase functions for different
1321 * layouts. That would imply "magic" erase functions. The
1322 * easiest way to check this is with function pointers.
1323 */
Uwe Hermann43959702010-03-13 17:28:29 +00001324 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001325 if (eraser.block_erase ==
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001326 chip->block_erasers[j].block_erase) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001327 msg_gerr("ERROR: Flash chip %s erase function "
1328 "%i and %i are identical. Please report"
1329 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001330 chip->name, k, j);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001331 ret = 1;
1332 }
Uwe Hermann43959702010-03-13 17:28:29 +00001333 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001334 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001335 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001336}
1337
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001338static int erase_and_write_block_helper(struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001339 unsigned int start, unsigned int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001340 uint8_t *curcontents,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001341 uint8_t *newcontents,
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001342 int (*erasefn) (struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001343 unsigned int addr,
1344 unsigned int len))
1345{
Stefan Taunerc69c9c82011-11-23 09:13:48 +00001346 unsigned int starthere = 0, lenhere = 0;
1347 int ret = 0, skip = 1, writecount = 0;
Stefan Tauner50d67aa2013-03-03 23:49:48 +00001348 enum write_granularity gran = flash->chip->gran;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001349
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001350 /* curcontents and newcontents are opaque to walk_eraseregions, and
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001351 * need to be adjusted here to keep the impression of proper abstraction
1352 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001353 curcontents += start;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001354 newcontents += start;
1355 msg_cdbg(":");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001356 if (need_erase(curcontents, newcontents, len, gran)) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001357 msg_cdbg("E");
1358 ret = erasefn(flash, start, len);
1359 if (ret)
1360 return ret;
Carl-Daniel Hailfingerb4061f62011-06-26 17:04:16 +00001361 if (check_erased_range(flash, start, len)) {
1362 msg_cerr("ERASE FAILED!\n");
1363 return -1;
1364 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001365 /* Erase was successful. Adjust curcontents. */
1366 memset(curcontents, 0xff, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001367 skip = 0;
1368 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001369 /* get_next_write() sets starthere to a new value after the call. */
1370 while ((lenhere = get_next_write(curcontents + starthere,
1371 newcontents + starthere,
1372 len - starthere, &starthere, gran))) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001373 if (!writecount++)
1374 msg_cdbg("W");
1375 /* Needs the partial write function signature. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001376 ret = flash->chip->write(flash, newcontents + starthere,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001377 start + starthere, lenhere);
1378 if (ret)
1379 return ret;
1380 starthere += lenhere;
1381 skip = 0;
1382 }
1383 if (skip)
1384 msg_cdbg("S");
Stefan Tauner682122b2013-06-23 22:15:39 +00001385 else
1386 all_skipped = false;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001387 return ret;
1388}
1389
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001390static int walk_eraseregions(struct flashctx *flash, int erasefunction,
1391 int (*do_something) (struct flashctx *flash,
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001392 unsigned int addr,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001393 unsigned int len,
1394 uint8_t *param1,
1395 uint8_t *param2,
1396 int (*erasefn) (
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001397 struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001398 unsigned int addr,
1399 unsigned int len)),
1400 void *param1, void *param2)
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001401{
1402 int i, j;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001403 unsigned int start = 0;
1404 unsigned int len;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001405 struct block_eraser eraser = flash->chip->block_erasers[erasefunction];
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001406
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001407 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1408 /* count==0 for all automatically initialized array
1409 * members so the loop below won't be executed for them.
1410 */
1411 len = eraser.eraseblocks[i].size;
1412 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001413 /* Print this for every block except the first one. */
1414 if (i || j)
1415 msg_cdbg(", ");
1416 msg_cdbg("0x%06x-0x%06x", start,
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001417 start + len - 1);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001418 if (do_something(flash, start, len, param1, param2,
1419 eraser.block_erase)) {
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001420 return 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001421 }
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001422 start += len;
1423 }
1424 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001425 msg_cdbg("\n");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001426 return 0;
1427}
1428
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001429static int check_block_eraser(const struct flashctx *flash, int k, int log)
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001430{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001431 struct block_eraser eraser = flash->chip->block_erasers[k];
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001432
1433 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
1434 if (log)
1435 msg_cdbg("not defined. ");
1436 return 1;
1437 }
1438 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
1439 if (log)
1440 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001441 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001442 return 1;
1443 }
1444 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
1445 if (log)
1446 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001447 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001448 return 1;
1449 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001450 // TODO: Once erase functions are annotated with allowed buses, check that as well.
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001451 return 0;
1452}
1453
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001454int erase_and_write_flash(struct flashctx *flash, uint8_t *oldcontents,
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001455 uint8_t *newcontents)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001456{
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001457 int k, ret = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001458 uint8_t *curcontents;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001459 unsigned long size = flash->chip->total_size * 1024;
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001460 unsigned int usable_erasefunctions = count_usable_erasers(flash);
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001461
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001462 msg_cinfo("Erasing and writing flash chip... ");
Stefan Tauner269de352011-07-12 22:35:21 +00001463 curcontents = malloc(size);
1464 if (!curcontents) {
1465 msg_gerr("Out of memory!\n");
1466 exit(1);
1467 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001468 /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1469 memcpy(curcontents, oldcontents, size);
1470
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001471 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001472 if (k != 0)
1473 msg_cdbg("Looking for another erase function.\n");
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001474 if (!usable_erasefunctions) {
1475 msg_cdbg("No usable erase functions left.\n");
1476 break;
1477 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001478 msg_cdbg("Trying erase function %i... ", k);
1479 if (check_block_eraser(flash, k, 1))
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001480 continue;
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001481 usable_erasefunctions--;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001482 ret = walk_eraseregions(flash, k, &erase_and_write_block_helper,
1483 curcontents, newcontents);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001484 /* If everything is OK, don't try another erase function. */
1485 if (!ret)
1486 break;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001487 /* Write/erase failed, so try to find out what the current chip
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001488 * contents are. If no usable erase functions remain, we can
1489 * skip this: the next iteration will break immediately anyway.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001490 */
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001491 if (!usable_erasefunctions)
1492 continue;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001493 /* Reading the whole chip may take a while, inform the user even
1494 * in non-verbose mode.
1495 */
1496 msg_cinfo("Reading current flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001497 if (flash->chip->read(flash, curcontents, 0, size)) {
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001498 /* Now we are truly screwed. Read failed as well. */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001499 msg_cerr("Can't read anymore! Aborting.\n");
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001500 /* We have no idea about the flash chip contents, so
1501 * retrying with another erase function is pointless.
1502 */
1503 break;
1504 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001505 msg_cinfo("done. ");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001506 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001507 /* Free the scratchpad. */
1508 free(curcontents);
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001509
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001510 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001511 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001512 } else {
Stefan Tauner682122b2013-06-23 22:15:39 +00001513 if (all_skipped)
1514 msg_cinfo("\nWarning: Chip content is identical to the requested image.\n");
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001515 msg_cinfo("Erase/write done.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001516 }
1517 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001518}
1519
Stefan Tauner136388f2013-07-15 10:47:53 +00001520static void nonfatal_help_message(void)
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001521{
Stefan Tauner136388f2013-07-15 10:47:53 +00001522 msg_gerr("Writing to the flash chip apparently didn't do anything.\n");
1523#if CONFIG_INTERNAL == 1
1524 if (programmer == PROGRAMMER_INTERNAL)
1525 msg_gerr("This means we have to add special support for your board, programmer or flash\n"
1526 "chip. Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1527 "mail flashrom@flashrom.org, thanks!\n"
1528 "-------------------------------------------------------------------------------\n"
1529 "You may now reboot or simply leave the machine running.\n");
1530 else
1531#endif
1532 msg_gerr("Please check the connections (especially those to write protection pins) between\n"
1533 "the programmer and the flash chip. If you think the error is caused by flashrom\n"
1534 "please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1535 "mail flashrom@flashrom.org, thanks!\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001536}
1537
Stefan Tauner136388f2013-07-15 10:47:53 +00001538static void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001539{
Stefan Tauner136388f2013-07-15 10:47:53 +00001540 msg_gerr("Your flash chip is in an unknown state.\n");
1541#if CONFIG_INTERNAL == 1
1542 if (programmer == PROGRAMMER_INTERNAL)
1543 msg_gerr("Get help on IRC at chat.freenode.net (channel #flashrom) or\n"
1544 "mail flashrom@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
1545 "-------------------------------------------------------------------------------\n"
1546 "DO NOT REBOOT OR POWEROFF!\n");
1547 else
1548#endif
1549 msg_gerr("Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1550 "mail flashrom@flashrom.org, thanks!\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001551}
1552
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001553/* The way to go if you want a delimited list of programmers */
Stefan Tauner66652442011-06-26 17:38:17 +00001554void list_programmers(const char *delim)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001555{
1556 enum programmer p;
1557 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001558 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001559 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001560 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001561 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001562 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001563}
1564
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001565void list_programmers_linebreak(int startcol, int cols, int paren)
1566{
1567 const char *pname;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001568 int pnamelen;
1569 int remaining = 0, firstline = 1;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001570 enum programmer p;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001571 int i;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001572
1573 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1574 pname = programmer_table[p].name;
1575 pnamelen = strlen(pname);
1576 if (remaining - pnamelen - 2 < 0) {
1577 if (firstline)
1578 firstline = 0;
1579 else
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001580 msg_ginfo("\n");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001581 for (i = 0; i < startcol; i++)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001582 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001583 remaining = cols - startcol;
1584 } else {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001585 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001586 remaining--;
1587 }
1588 if (paren && (p == 0)) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001589 msg_ginfo("(");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001590 remaining--;
1591 }
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001592 msg_ginfo("%s", pname);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001593 remaining -= pnamelen;
1594 if (p < PROGRAMMER_INVALID - 1) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001595 msg_ginfo(",");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001596 remaining--;
1597 } else {
1598 if (paren)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001599 msg_ginfo(")");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001600 }
1601 }
1602}
1603
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001604void print_sysinfo(void)
1605{
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001606#ifdef _WIN32
1607 SYSTEM_INFO si;
1608 OSVERSIONINFOEX osvi;
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001609
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001610 memset(&si, 0, sizeof(SYSTEM_INFO));
1611 memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
1612 msg_ginfo(" on Windows");
1613 /* Tell Windows which version of the structure we want. */
1614 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1615 if (GetVersionEx((OSVERSIONINFO*) &osvi))
1616 msg_ginfo(" %lu.%lu", osvi.dwMajorVersion, osvi.dwMinorVersion);
1617 else
1618 msg_ginfo(" unknown version");
1619 GetSystemInfo(&si);
1620 switch (si.wProcessorArchitecture) {
1621 case PROCESSOR_ARCHITECTURE_AMD64:
1622 msg_ginfo(" (x86_64)");
1623 break;
1624 case PROCESSOR_ARCHITECTURE_INTEL:
1625 msg_ginfo(" (x86)");
1626 break;
1627 default:
1628 msg_ginfo(" (unknown arch)");
1629 break;
1630 }
1631#elif HAVE_UTSNAME == 1
1632 struct utsname osinfo;
1633
1634 uname(&osinfo);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001635 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1636 osinfo.machine);
1637#else
1638 msg_ginfo(" on unknown machine");
1639#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001640}
1641
1642void print_buildinfo(void)
1643{
1644 msg_gdbg("flashrom was built with");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001645#if NEED_PCI == 1
1646#ifdef PCILIB_VERSION
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001647 msg_gdbg(" libpci %s,", PCILIB_VERSION);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001648#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001649 msg_gdbg(" unknown PCI library,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001650#endif
1651#endif
1652#ifdef __clang__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001653 msg_gdbg(" LLVM Clang");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001654#ifdef __clang_version__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001655 msg_gdbg(" %s,", __clang_version__);
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001656#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001657 msg_gdbg(" unknown version (before r102686),");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001658#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001659#elif defined(__GNUC__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001660 msg_gdbg(" GCC");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001661#ifdef __VERSION__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001662 msg_gdbg(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001663#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001664 msg_gdbg(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001665#endif
1666#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001667 msg_gdbg(" unknown compiler,");
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001668#endif
1669#if defined (__FLASHROM_LITTLE_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001670 msg_gdbg(" little endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001671#elif defined (__FLASHROM_BIG_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001672 msg_gdbg(" big endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001673#else
1674#error Endianness could not be determined
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001675#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001676 msg_gdbg("\n");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001677}
1678
Bernhard Walle201bde32008-01-21 15:24:22 +00001679void print_version(void)
1680{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001681 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001682 print_sysinfo();
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001683 msg_ginfo("\n");
Bernhard Walle201bde32008-01-21 15:24:22 +00001684}
1685
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001686void print_banner(void)
1687{
1688 msg_ginfo("flashrom is free software, get the source code at "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001689 "http://www.flashrom.org\n");
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001690 msg_ginfo("\n");
1691}
1692
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001693int selfcheck(void)
1694{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001695 const struct flashchip *chip;
Stefan Taunera6d96482012-12-26 19:51:23 +00001696 int i;
1697 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001698
1699 /* Safety check. Instead of aborting after the first error, check
1700 * if more errors exist.
1701 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001702 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001703 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001704 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001705 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001706 for (i = 0; i < PROGRAMMER_INVALID; i++) {
1707 const struct programmer_entry p = programmer_table[i];
1708 if (p.name == NULL) {
1709 msg_gerr("All programmers need a valid name, but the one with index %d does not!\n", i);
1710 ret = 1;
1711 /* This might hide other problems with this programmer, but allows for better error
1712 * messages below without jumping through hoops. */
1713 continue;
1714 }
Stefan Tauneraf358d62012-12-27 18:40:26 +00001715 switch (p.type) {
1716 case USB:
1717 case PCI:
1718 case OTHER:
1719 if (p.devs.note == NULL) {
1720 if (strcmp("internal", p.name) == 0)
1721 break; /* This one has its device list stored separately. */
1722 msg_gerr("Programmer %s has neither a device list nor a textual description!\n",
1723 p.name);
1724 ret = 1;
1725 }
1726 break;
1727 default:
1728 msg_gerr("Programmer %s does not have a valid type set!\n", p.name);
1729 ret = 1;
1730 break;
1731 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001732 if (p.init == NULL) {
1733 msg_gerr("Programmer %s does not have a valid init function!\n", p.name);
1734 ret = 1;
1735 }
1736 if (p.delay == NULL) {
1737 msg_gerr("Programmer %s does not have a valid delay function!\n", p.name);
1738 ret = 1;
1739 }
1740 if (p.map_flash_region == NULL) {
1741 msg_gerr("Programmer %s does not have a valid map_flash_region function!\n", p.name);
1742 ret = 1;
1743 }
1744 if (p.unmap_flash_region == NULL) {
1745 msg_gerr("Programmer %s does not have a valid unmap_flash_region function!\n", p.name);
1746 ret = 1;
1747 }
1748 }
Stefan Tauner93f70232011-07-26 14:33:46 +00001749 /* It would be favorable if we could also check for correct termination
Stefan Tauner716e0982011-07-25 20:38:52 +00001750 * of the following arrays, but we don't know their sizes in here...
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001751 * For 'flashchips' we check the first element to be non-null. In the
1752 * other cases there exist use cases where the first element can be
1753 * null. */
1754 if (flashchips == NULL || flashchips[0].vendor == NULL) {
1755 msg_gerr("Flashchips table miscompilation!\n");
1756 ret = 1;
1757 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001758 for (chip = flashchips; chip && chip->name; chip++)
1759 if (selfcheck_eraseblocks(chip))
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001760 ret = 1;
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001761
1762#if CONFIG_INTERNAL == 1
1763 if (chipset_enables == NULL) {
1764 msg_gerr("Chipset enables table does not exist!\n");
1765 ret = 1;
1766 }
Carl-Daniel Hailfinger97d5b122011-08-31 16:19:50 +00001767 if (board_matches == NULL) {
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001768 msg_gerr("Board enables table does not exist!\n");
1769 ret = 1;
1770 }
1771 if (boards_known == NULL) {
1772 msg_gerr("Known boards table does not exist!\n");
1773 ret = 1;
1774 }
1775 if (laptops_known == NULL) {
1776 msg_gerr("Known laptops table does not exist!\n");
1777 ret = 1;
1778 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001779#endif
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001780 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001781}
1782
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001783void check_chip_supported(const struct flashchip *chip)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001784{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001785 if (chip->feature_bits & FEATURE_OTP) {
Daniel Lenski65922a32012-02-15 23:40:23 +00001786 msg_cdbg("This chip may contain one-time programmable memory. "
1787 "flashrom cannot read\nand may never be able to write "
1788 "it, hence it may not be able to completely\n"
1789 "clone the contents of this chip (see man page for "
1790 "details).\n");
1791 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001792 if (TEST_OK_MASK != (chip->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001793 msg_cinfo("===\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001794 if (chip->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001795 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001796 if (chip->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001797 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001798 if (chip->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001799 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001800 if (chip->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001801 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001802 if (chip->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001803 msg_cinfo(" WRITE");
1804 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001805 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001806 if ((!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE)) ||
1807 (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ)) ||
1808 (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE)) ||
1809 (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001810 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001811 if (!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001812 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001813 if (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001814 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001815 if (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001816 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001817 if (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001818 msg_cinfo(" WRITE");
1819 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001820 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001821 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001822 msg_cinfo("The test status of this chip may have been updated "
1823 "in the latest development\n"
1824 "version of flashrom. If you are running the latest "
1825 "development version,\n"
1826 "please email a report to flashrom@flashrom.org if "
1827 "any of the above operations\n"
1828 "work correctly for you with this flash part. Please "
1829 "include the flashrom\n"
1830 "output with the additional -V option for all "
1831 "operations you tested (-V, -Vr,\n"
Paul Menzele3800132012-01-12 13:58:43 +00001832 "-VE, -Vw), and mention which mainboard or "
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001833 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001834 "Please mention your board in the subject line. "
1835 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001836 }
1837}
1838
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001839/* FIXME: This function signature needs to be improved once doit() has a better
1840 * function signature.
1841 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001842int chip_safety_check(const struct flashctx *flash, int force, int read_it, int write_it, int erase_it,
1843 int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001844{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001845 const struct flashchip *chip = flash->chip;
1846
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001847 if (!programmer_may_write && (write_it || erase_it)) {
1848 msg_perr("Write/erase is not working yet on your programmer in "
1849 "its current configuration.\n");
1850 /* --force is the wrong approach, but it's the best we can do
1851 * until the generic programmer parameter parser is merged.
1852 */
1853 if (!force)
1854 return 1;
1855 msg_cerr("Continuing anyway.\n");
1856 }
1857
1858 if (read_it || erase_it || write_it || verify_it) {
1859 /* Everything needs read. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001860 if (chip->tested & TEST_BAD_READ) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001861 msg_cerr("Read is not working on this chip. ");
1862 if (!force)
1863 return 1;
1864 msg_cerr("Continuing anyway.\n");
1865 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001866 if (!chip->read) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001867 msg_cerr("flashrom has no read function for this "
1868 "flash chip.\n");
1869 return 1;
1870 }
1871 }
1872 if (erase_it || write_it) {
1873 /* Write needs erase. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001874 if (chip->tested & TEST_BAD_ERASE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001875 msg_cerr("Erase is not working on this chip. ");
1876 if (!force)
1877 return 1;
1878 msg_cerr("Continuing anyway.\n");
1879 }
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001880 if(count_usable_erasers(flash) == 0) {
Stefan Tauner5368dca2011-07-01 00:19:12 +00001881 msg_cerr("flashrom has no erase function for this "
1882 "flash chip.\n");
1883 return 1;
1884 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001885 }
1886 if (write_it) {
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001887 if (chip->tested & TEST_BAD_WRITE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001888 msg_cerr("Write is not working on this chip. ");
1889 if (!force)
1890 return 1;
1891 msg_cerr("Continuing anyway.\n");
1892 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001893 if (!chip->write) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001894 msg_cerr("flashrom has no write function for this "
1895 "flash chip.\n");
1896 return 1;
1897 }
1898 }
1899 return 0;
1900}
1901
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001902/* This function signature is horrible. We need to design a better interface,
1903 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001904 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001905 */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +00001906int doit(struct flashctx *flash, int force, const char *filename, int read_it,
1907 int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001908{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001909 uint8_t *oldcontents;
1910 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001911 int ret = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001912 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001913
David Hendricks77f931a2011-05-18 01:30:56 +00001914 if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001915 msg_cerr("Aborting.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001916 ret = 1;
1917 goto out_nofree;
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001918 }
1919
Stefan Tauner8268fdb2013-09-23 14:21:06 +00001920 if (normalize_romentries(flash)) {
1921 msg_cerr("Requested regions can not be handled. Aborting.\n");
1922 ret = 1;
1923 goto out_nofree;
1924 }
1925
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001926 /* Given the existence of read locks, we want to unlock for read,
1927 * erase and write.
1928 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001929 if (flash->chip->unlock)
1930 flash->chip->unlock(flash);
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001931
1932 if (read_it) {
1933 ret = read_flash_to_file(flash, filename);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001934 goto out_nofree;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001935 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001936
Stefan Tauner269de352011-07-12 22:35:21 +00001937 oldcontents = malloc(size);
1938 if (!oldcontents) {
1939 msg_gerr("Out of memory!\n");
1940 exit(1);
1941 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001942 /* Assume worst case: All bits are 0. */
1943 memset(oldcontents, 0x00, size);
Stefan Tauner269de352011-07-12 22:35:21 +00001944 newcontents = malloc(size);
1945 if (!newcontents) {
1946 msg_gerr("Out of memory!\n");
1947 exit(1);
1948 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001949 /* Assume best case: All bits should be 1. */
1950 memset(newcontents, 0xff, size);
1951 /* Side effect of the assumptions above: Default write action is erase
1952 * because newcontents looks like a completely erased chip, and
1953 * oldcontents being completely 0x00 means we have to erase everything
1954 * before we can write.
1955 */
1956
Ollie Lhoefa28582004-12-08 20:10:01 +00001957 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001958 /* FIXME: Do we really want the scary warning if erase failed?
1959 * After all, after erase the chip is either blank or partially
1960 * blank or it has the old contents. A blank chip won't boot,
1961 * so if the user wanted erase and reboots afterwards, the user
1962 * knows very well that booting won't work.
1963 */
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001964 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001965 emergency_help_message();
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001966 ret = 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001967 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001968 goto out;
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001969 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001970
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001971 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001972 if (read_buf_from_file(newcontents, size, filename)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001973 ret = 1;
1974 goto out;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001975 }
1976
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001977#if CONFIG_INTERNAL == 1
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001978 if (programmer == PROGRAMMER_INTERNAL && cb_check_image(newcontents, size) < 0) {
1979 if (force_boardmismatch) {
1980 msg_pinfo("Proceeding anyway because user forced us to.\n");
1981 } else {
1982 msg_perr("Aborting. You can override this with "
1983 "-p internal:boardmismatch=force.\n");
Niklas Söderlund9e423762012-06-16 00:11:16 +00001984 ret = 1;
1985 goto out;
1986 }
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001987 }
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001988#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001989 }
1990
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001991 /* Read the whole chip to be able to check whether regions need to be
1992 * erased and to give better diagnostics in case write fails.
1993 * The alternative would be to read only the regions which are to be
1994 * preserved, but in that case we might perform unneeded erase which
1995 * takes time as well.
1996 */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001997 msg_cinfo("Reading old flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001998 if (flash->chip->read(flash, oldcontents, 0, size)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001999 ret = 1;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00002000 msg_cinfo("FAILED.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002001 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002002 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00002003 msg_cinfo("done.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002004
Stefan Tauner8268fdb2013-09-23 14:21:06 +00002005 /* Build a new image taking the given layout into account. */
2006 build_new_image(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00002007
Ollie Lho184a4042005-11-26 21:55:36 +00002008 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00002009
Peter Stugef31104c2008-04-28 14:47:30 +00002010 if (write_it) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00002011 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
2012 msg_cerr("Uh oh. Erase/write failed. Checking if "
2013 "anything changed.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00002014 if (!flash->chip->read(flash, newcontents, 0, size)) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002015 if (!memcmp(oldcontents, newcontents, size)) {
Stefan Tauner136388f2013-07-15 10:47:53 +00002016 msg_cinfo("Good. It seems nothing was changed.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002017 nonfatal_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002018 ret = 1;
2019 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002020 }
2021 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00002022 emergency_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002023 ret = 1;
2024 goto out;
Peter Stugef31104c2008-04-28 14:47:30 +00002025 }
Peter Stugef31104c2008-04-28 14:47:30 +00002026 }
Ollie Lho184a4042005-11-26 21:55:36 +00002027
Stefan Taunerc4f44df2013-08-12 22:58:43 +00002028 /* Verify only if we either did not try to write (verify operation) or actually changed something. */
2029 if (verify_it && (!write_it || !all_skipped)) {
Stefan Tauner78ffbea2012-10-27 15:36:56 +00002030 msg_cinfo("Verifying flash... ");
2031
2032 if (write_it) {
2033 /* Work around chips which need some time to calm down. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00002034 programmer_delay(1000*1000);
Stefan Tauner78ffbea2012-10-27 15:36:56 +00002035 ret = verify_range(flash, newcontents, 0, size);
2036 /* If we tried to write, and verification now fails, we
2037 * might have an emergency situation.
2038 */
2039 if (ret)
2040 emergency_help_message();
2041 } else {
2042 ret = compare_range(newcontents, oldcontents, 0, size);
2043 }
2044 if (!ret)
2045 msg_cinfo("VERIFIED.\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00002046 }
Ollie Lho184a4042005-11-26 21:55:36 +00002047
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002048out:
2049 free(oldcontents);
2050 free(newcontents);
2051out_nofree:
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00002052 programmer_shutdown();
Stefan Reinauer143da0b2006-01-04 16:42:57 +00002053 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00002054}