blob: b3661c13ddca0557d4a4ddfd37ecae4e228f2451 [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
Stefan Tauner20da4aa2014-05-07 22:07:23 +0000416/** Calls registered shutdown functions and resets internal programmer-related variables.
417 * Calling it is safe even without previous initialization, but further interactions with programmer support
418 * require a call to programmer_init() (afterwards).
419 *
420 * @return The OR-ed result values of all shutdown functions (i.e. 0 on success). */
Uwe Hermann09e04f72009-05-16 22:36:00 +0000421int programmer_shutdown(void)
422{
David Hendricks8bb20212011-06-14 01:35:36 +0000423 int ret = 0;
424
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000425 /* Registering shutdown functions is no longer allowed. */
426 may_register_shutdown = 0;
427 while (shutdown_fn_count > 0) {
428 int i = --shutdown_fn_count;
David Hendricks8bb20212011-06-14 01:35:36 +0000429 ret |= shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000430 }
Stefan Taunere34e3e82013-01-01 00:06:51 +0000431
Stefan Taunerb8911d62012-12-26 07:55:00 +0000432 programmer_param = NULL;
Stefan Taunere34e3e82013-01-01 00:06:51 +0000433 registered_programmer_count = 0;
434
David Hendricks8bb20212011-06-14 01:35:36 +0000435 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000436}
437
Stefan Tauner305e0b92013-07-17 23:46:44 +0000438void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000439{
Stefan Tauner26e7a152013-09-13 17:21:05 +0000440 void *ret = programmer_table[programmer].map_flash_region(descr, phys_addr, len);
441 msg_gspew("%s: mapping %s from 0x%0*" PRIxPTR " to 0x%0*" PRIxPTR "\n",
442 __func__, descr, PRIxPTR_WIDTH, phys_addr, PRIxPTR_WIDTH, (uintptr_t) ret);
443 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000444}
445
446void programmer_unmap_flash_region(void *virt_addr, size_t len)
447{
448 programmer_table[programmer].unmap_flash_region(virt_addr, len);
449}
450
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000451void chip_writeb(const struct flashctx *flash, uint8_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_writeb(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000454}
455
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000456void chip_writew(const struct flashctx *flash, uint16_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_writew(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000459}
460
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000461void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000462{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000463 flash->pgm->par.chip_writel(flash, val, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000464}
465
Mark Marshallf20b7be2014-05-09 21:16:21 +0000466void chip_writen(const struct flashctx *flash, const uint8_t *buf, chipaddr addr, size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000467{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000468 flash->pgm->par.chip_writen(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000469}
470
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000471uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000472{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000473 return flash->pgm->par.chip_readb(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000474}
475
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000476uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000477{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000478 return flash->pgm->par.chip_readw(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000479}
480
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000481uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000482{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000483 return flash->pgm->par.chip_readl(flash, addr);
Uwe Hermann09e04f72009-05-16 22:36:00 +0000484}
485
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000486void chip_readn(const struct flashctx *flash, uint8_t *buf, chipaddr addr,
487 size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000488{
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000489 flash->pgm->par.chip_readn(flash, buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000490}
491
Stefan Taunerf80419c2014-05-02 15:41:42 +0000492void programmer_delay(unsigned int usecs)
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000493{
Urja Rannikko8d7ec2a2013-10-21 21:49:08 +0000494 if (usecs > 0)
495 programmer_table[programmer].delay(usecs);
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000496}
497
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000498void map_flash_registers(struct flashctx *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000499{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000500 size_t size = flash->chip->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000501 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000502 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000503 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000504}
505
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000506int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
507 int unsigned len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000508{
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000509 chip_readn(flash, buf, flash->virtual_memory + start, len);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000510
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000511 return 0;
512}
513
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000514int min(int a, int b)
515{
516 return (a < b) ? a : b;
517}
518
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000519int max(int a, int b)
520{
521 return (a > b) ? a : b;
522}
523
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000524int bitcount(unsigned long a)
525{
526 int i = 0;
527 for (; a != 0; a >>= 1)
528 if (a & 1)
529 i++;
530 return i;
531}
532
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000533void tolower_string(char *str)
534{
535 for (; *str != '\0'; str++)
536 *str = (char)tolower((unsigned char)*str);
537}
538
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000539char *strcat_realloc(char *dest, const char *src)
540{
541 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000542 if (!dest) {
543 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000544 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000545 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000546 strcat(dest, src);
547 return dest;
548}
549
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000550/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000551 * It will look for needle with a subsequent '=' in haystack, return a copy of
552 * needle and remove everything from the first occurrence of needle to the next
553 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000554 */
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000555char *extract_param(const char *const *haystack, const char *needle, const char *delim)
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000556{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000557 char *param_pos, *opt_pos, *rest;
558 char *opt = NULL;
559 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000560 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000561
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000562 needlelen = strlen(needle);
563 if (!needlelen) {
564 msg_gerr("%s: empty needle! Please report a bug at "
565 "flashrom@flashrom.org\n", __func__);
566 return NULL;
567 }
568 /* No programmer parameters given. */
569 if (*haystack == NULL)
570 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000571 param_pos = strstr(*haystack, needle);
572 do {
573 if (!param_pos)
574 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000575 /* Needle followed by '='? */
576 if (param_pos[needlelen] == '=') {
577
578 /* Beginning of the string? */
579 if (param_pos == *haystack)
580 break;
581 /* After a delimiter? */
582 if (strchr(delim, *(param_pos - 1)))
583 break;
584 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000585 /* Continue searching. */
586 param_pos++;
587 param_pos = strstr(param_pos, needle);
588 } while (1);
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000589
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000590 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000591 /* Get the string after needle and '='. */
592 opt_pos = param_pos + needlelen + 1;
593 optlen = strcspn(opt_pos, delim);
594 /* Return an empty string if the parameter was empty. */
595 opt = malloc(optlen + 1);
596 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000597 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000598 exit(1);
599 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000600 strncpy(opt, opt_pos, optlen);
601 opt[optlen] = '\0';
602 rest = opt_pos + optlen;
603 /* Skip all delimiters after the current parameter. */
604 rest += strspn(rest, delim);
605 memmove(param_pos, rest, strlen(rest) + 1);
606 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000607 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000608
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000609 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000610}
611
Stefan Tauner66652442011-06-26 17:38:17 +0000612char *extract_programmer_param(const char *param_name)
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000613{
614 return extract_param(&programmer_param, param_name, ",");
615}
616
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +0000617/* Returns the number of well-defined erasers for a chip. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000618static unsigned int count_usable_erasers(const struct flashctx *flash)
Stefan Tauner5368dca2011-07-01 00:19:12 +0000619{
620 unsigned int usable_erasefunctions = 0;
621 int k;
622 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
623 if (!check_block_eraser(flash, k, 0))
624 usable_erasefunctions++;
625 }
626 return usable_erasefunctions;
627}
628
Mark Marshallf20b7be2014-05-09 21:16:21 +0000629static int compare_range(const uint8_t *wantbuf, const uint8_t *havebuf, unsigned int start, unsigned int len)
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000630{
631 int ret = 0, failcount = 0;
632 unsigned int i;
633 for (i = 0; i < len; i++) {
634 if (wantbuf[i] != havebuf[i]) {
635 /* Only print the first failure. */
636 if (!failcount++)
637 msg_cerr("FAILED at 0x%08x! Expected=0x%02x, Found=0x%02x,",
638 start + i, wantbuf[i], havebuf[i]);
639 }
640 }
641 if (failcount) {
642 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
643 start, start + len - 1, failcount);
644 ret = -1;
645 }
646 return ret;
647}
648
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000649/* start is an offset to the base address of the flash chip */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000650int check_erased_range(struct flashctx *flash, unsigned int start,
651 unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000652{
653 int ret;
654 uint8_t *cmpbuf = malloc(len);
655
656 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000657 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000658 exit(1);
659 }
660 memset(cmpbuf, 0xff, len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000661 ret = verify_range(flash, cmpbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000662 free(cmpbuf);
663 return ret;
664}
665
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000666/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000667 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000668 * flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000669 * @start offset to the base address of the flash chip
670 * @len length of the verified area
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000671 * @return 0 for success, -1 for failure
672 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000673int verify_range(struct flashctx *flash, const uint8_t *cmpbuf, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000674{
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000675 uint8_t *readbuf = malloc(len);
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000676 int ret = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000677
678 if (!len)
679 goto out_free;
680
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000681 if (!flash->chip->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000682 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000683 return 1;
684 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000685 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000686 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000687 exit(1);
688 }
689
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000690 if (start + len > flash->chip->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000691 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000692 " total_size 0x%x\n", __func__, start, len,
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000693 flash->chip->total_size * 1024);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000694 ret = -1;
695 goto out_free;
696 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000697
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000698 ret = flash->chip->read(flash, readbuf, start, len);
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000699 if (ret) {
700 msg_gerr("Verification impossible because read failed "
701 "at 0x%x (len 0x%x)\n", start, len);
702 return ret;
703 }
704
Stefan Tauner78ffbea2012-10-27 15:36:56 +0000705 ret = compare_range(cmpbuf, readbuf, start, len);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000706out_free:
707 free(readbuf);
708 return ret;
709}
710
Stefan Tauner02437452013-04-01 19:34:53 +0000711/* Helper function for need_erase() that focuses on granularities of gran bytes. */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000712static int need_erase_gran_bytes(const uint8_t *have, const uint8_t *want, unsigned int len, unsigned int gran)
Stefan Tauner02437452013-04-01 19:34:53 +0000713{
714 unsigned int i, j, limit;
715 for (j = 0; j < len / gran; j++) {
716 limit = min (gran, len - j * gran);
717 /* Are 'have' and 'want' identical? */
718 if (!memcmp(have + j * gran, want + j * gran, limit))
719 continue;
720 /* have needs to be in erased state. */
721 for (i = 0; i < limit; i++)
722 if (have[j * gran + i] != 0xff)
723 return 1;
724 }
725 return 0;
726}
727
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000728/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000729 * Check if the buffer @have can be programmed to the content of @want without
730 * erasing. This is only possible if all chunks of size @gran are either kept
731 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000732 *
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000733 * Warning: This function assumes that @have and @want point to naturally
734 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000735 *
736 * @have buffer with current content
737 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000738 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000739 * @gran write granularity (enum, not count)
740 * @return 0 if no erase is needed, 1 otherwise
741 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000742int need_erase(const uint8_t *have, const uint8_t *want, unsigned int len, enum write_granularity gran)
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000743{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000744 int result = 0;
Stefan Tauner02437452013-04-01 19:34:53 +0000745 unsigned int i;
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000746
747 switch (gran) {
748 case write_gran_1bit:
749 for (i = 0; i < len; i++)
750 if ((have[i] & want[i]) != want[i]) {
751 result = 1;
752 break;
753 }
754 break;
755 case write_gran_1byte:
756 for (i = 0; i < len; i++)
757 if ((have[i] != want[i]) && (have[i] != 0xff)) {
758 result = 1;
759 break;
760 }
761 break;
762 case write_gran_256bytes:
Stefan Tauner02437452013-04-01 19:34:53 +0000763 result = need_erase_gran_bytes(have, want, len, 256);
764 break;
765 case write_gran_264bytes:
766 result = need_erase_gran_bytes(have, want, len, 264);
767 break;
768 case write_gran_512bytes:
769 result = need_erase_gran_bytes(have, want, len, 512);
770 break;
771 case write_gran_528bytes:
772 result = need_erase_gran_bytes(have, want, len, 528);
773 break;
774 case write_gran_1024bytes:
775 result = need_erase_gran_bytes(have, want, len, 1024);
776 break;
777 case write_gran_1056bytes:
778 result = need_erase_gran_bytes(have, want, len, 1056);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000779 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000780 default:
781 msg_cerr("%s: Unsupported granularity! Please report a bug at "
782 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000783 }
784 return result;
785}
786
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000787/**
788 * Check if the buffer @have needs to be programmed to get the content of @want.
789 * If yes, return 1 and fill in first_start with the start address of the
790 * write operation and first_len with the length of the first to-be-written
791 * chunk. If not, return 0 and leave first_start and first_len undefined.
792 *
793 * Warning: This function assumes that @have and @want point to naturally
794 * aligned regions.
795 *
796 * @have buffer with current content
797 * @want buffer with desired content
798 * @len length of the checked area
799 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000800 * @first_start offset of the first byte which needs to be written (passed in
801 * value is increased by the offset of the first needed write
802 * relative to have/want or unchanged if no write is needed)
803 * @return length of the first contiguous area which needs to be written
804 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000805 *
806 * FIXME: This function needs a parameter which tells it about coalescing
807 * in relation to the max write length of the programmer and the max write
808 * length of the chip.
809 */
Mark Marshallf20b7be2014-05-09 21:16:21 +0000810static unsigned int get_next_write(const uint8_t *have, const uint8_t *want, unsigned int len,
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000811 unsigned int *first_start,
812 enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000813{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000814 int need_write = 0;
815 unsigned int rel_start = 0, first_len = 0;
816 unsigned int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000817
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000818 switch (gran) {
819 case write_gran_1bit:
820 case write_gran_1byte:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000821 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000822 break;
823 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000824 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000825 break;
Stefan Tauner02437452013-04-01 19:34:53 +0000826 case write_gran_264bytes:
827 stride = 264;
828 break;
829 case write_gran_512bytes:
830 stride = 512;
831 break;
832 case write_gran_528bytes:
833 stride = 528;
834 break;
835 case write_gran_1024bytes:
836 stride = 1024;
837 break;
838 case write_gran_1056bytes:
839 stride = 1056;
840 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000841 default:
842 msg_cerr("%s: Unsupported granularity! Please report a bug at "
843 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000844 /* Claim that no write was needed. A write with unknown
845 * granularity is too dangerous to try.
846 */
847 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000848 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000849 for (i = 0; i < len / stride; i++) {
850 limit = min(stride, len - i * stride);
851 /* Are 'have' and 'want' identical? */
852 if (memcmp(have + i * stride, want + i * stride, limit)) {
853 if (!need_write) {
854 /* First location where have and want differ. */
855 need_write = 1;
856 rel_start = i * stride;
857 }
858 } else {
859 if (need_write) {
860 /* First location where have and want
861 * do not differ anymore.
862 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000863 break;
864 }
865 }
866 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000867 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000868 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000869 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000870 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000871}
872
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000873/* This function generates various test patterns useful for testing controller
874 * and chip communication as well as chip behaviour.
875 *
876 * If a byte can be written multiple times, each time keeping 0-bits at 0
877 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
878 * is essentially an AND operation. That's also the reason why this function
879 * provides the result of AND between various patterns.
880 *
881 * Below is a list of patterns (and their block length).
882 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
883 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
884 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
885 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
886 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
887 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
888 * Pattern 6 is 00 (1 Byte)
889 * Pattern 7 is ff (1 Byte)
890 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
891 * byte block.
892 *
893 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
894 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
895 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
896 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
897 * Pattern 12 is 00 (1 Byte)
898 * Pattern 13 is ff (1 Byte)
899 * Patterns 8-13 have no block number.
900 *
901 * Patterns 0-3 are created to detect and efficiently diagnose communication
902 * slips like missed bits or bytes and their repetitive nature gives good visual
903 * cues to the person inspecting the results. In addition, the following holds:
904 * AND Pattern 0/1 == Pattern 4
905 * AND Pattern 2/3 == Pattern 5
906 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
907 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
908 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
909 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
910 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
911 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
912 * Besides that, they provide for bit testing of the last two bytes of every
913 * 256 byte block which contains the block number for patterns 0-6.
914 * Patterns 10-11 are special purpose for detecting subblock aliasing with
915 * block sizes >256 bytes (some Dataflash chips etc.)
916 * AND Pattern 8/9 == Pattern 12
917 * AND Pattern 10/11 == Pattern 12
918 * Pattern 13 is the completely erased state.
919 * None of the patterns can detect aliasing at boundaries which are a multiple
920 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
921 */
922int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
923{
924 int i;
925
926 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000927 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000928 return 1;
929 }
930
931 switch (variant) {
932 case 0:
933 for (i = 0; i < size; i++)
934 buf[i] = (i & 0xf) << 4 | 0x5;
935 break;
936 case 1:
937 for (i = 0; i < size; i++)
938 buf[i] = (i & 0xf) << 4 | 0xa;
939 break;
940 case 2:
941 for (i = 0; i < size; i++)
942 buf[i] = 0x50 | (i & 0xf);
943 break;
944 case 3:
945 for (i = 0; i < size; i++)
946 buf[i] = 0xa0 | (i & 0xf);
947 break;
948 case 4:
949 for (i = 0; i < size; i++)
950 buf[i] = (i & 0xf) << 4;
951 break;
952 case 5:
953 for (i = 0; i < size; i++)
954 buf[i] = i & 0xf;
955 break;
956 case 6:
957 memset(buf, 0x00, size);
958 break;
959 case 7:
960 memset(buf, 0xff, size);
961 break;
962 case 8:
963 for (i = 0; i < size; i++)
964 buf[i] = i & 0xff;
965 break;
966 case 9:
967 for (i = 0; i < size; i++)
968 buf[i] = ~(i & 0xff);
969 break;
970 case 10:
971 for (i = 0; i < size % 2; i++) {
972 buf[i * 2] = (i >> 8) & 0xff;
973 buf[i * 2 + 1] = i & 0xff;
974 }
975 if (size & 0x1)
976 buf[i * 2] = (i >> 8) & 0xff;
977 break;
978 case 11:
979 for (i = 0; i < size % 2; i++) {
980 buf[i * 2] = ~((i >> 8) & 0xff);
981 buf[i * 2 + 1] = ~(i & 0xff);
982 }
983 if (size & 0x1)
984 buf[i * 2] = ~((i >> 8) & 0xff);
985 break;
986 case 12:
987 memset(buf, 0x00, size);
988 break;
989 case 13:
990 memset(buf, 0xff, size);
991 break;
992 }
993
994 if ((variant >= 0) && (variant <= 7)) {
995 /* Write block number in the last two bytes of each 256-byte
996 * block, big endian for easier reading of the hexdump.
997 * Note that this wraps around for chips larger than 2^24 bytes
998 * (16 MB).
999 */
1000 for (i = 0; i < size / 256; i++) {
1001 buf[i * 256 + 254] = (i >> 8) & 0xff;
1002 buf[i * 256 + 255] = i & 0xff;
1003 }
1004 }
1005
1006 return 0;
1007}
1008
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001009int check_max_decode(enum chipbustype buses, uint32_t size)
1010{
1011 int limitexceeded = 0;
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001012
1013 if ((buses & BUS_PARALLEL) && (max_rom_decode.parallel < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001014 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001015 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001016 "size %u kB of chipset/board/programmer "
1017 "for %s interface, "
1018 "probe/read/erase/write may fail. ", size / 1024,
1019 max_rom_decode.parallel / 1024, "Parallel");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001020 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001021 if ((buses & BUS_LPC) && (max_rom_decode.lpc < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001022 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001023 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001024 "size %u kB of chipset/board/programmer "
1025 "for %s interface, "
1026 "probe/read/erase/write may fail. ", size / 1024,
1027 max_rom_decode.lpc / 1024, "LPC");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001028 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001029 if ((buses & BUS_FWH) && (max_rom_decode.fwh < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001030 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001031 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001032 "size %u kB of chipset/board/programmer "
1033 "for %s interface, "
1034 "probe/read/erase/write may fail. ", size / 1024,
1035 max_rom_decode.fwh / 1024, "FWH");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001036 }
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +00001037 if ((buses & BUS_SPI) && (max_rom_decode.spi < size)) {
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001038 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001039 msg_pdbg("Chip size %u kB is bigger than supported "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001040 "size %u kB of chipset/board/programmer "
1041 "for %s interface, "
1042 "probe/read/erase/write may fail. ", size / 1024,
1043 max_rom_decode.spi / 1024, "SPI");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001044 }
1045 if (!limitexceeded)
1046 return 0;
1047 /* Sometimes chip and programmer have more than one bus in common,
1048 * and the limit is not exceeded on all buses. Tell the user.
1049 */
1050 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001051 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +00001052 msg_pdbg("There is at least one common chip/programmer "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001053 "interface which can support a chip of this size. "
1054 "You can try --force at your own risk.\n");
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001055 return 1;
1056}
1057
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001058int probe_flash(struct registered_programmer *pgm, int startchip, struct flashctx *flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001059{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001060 const struct flashchip *chip;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001061 unsigned long base = 0;
Stefan Reinauer051e2362011-01-19 06:21:54 +00001062 char location[64];
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001063 uint32_t size;
1064 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001065 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001066
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001067 for (chip = flashchips + startchip; chip && chip->name; chip++) {
1068 if (chip_to_probe && strcmp(chip->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +00001069 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001070 buses_common = pgm->buses_supported & chip->bustype;
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +00001071 if (!buses_common)
Carl-Daniel Hailfinger6573b742011-06-17 22:38:53 +00001072 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001073 msg_gdbg("Probing for %s %s, %d kB: ", chip->vendor, chip->name, chip->total_size);
1074 if (!chip->probe && !force) {
1075 msg_gdbg("failed! flashrom has no probe function for this flash chip.\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001076 continue;
1077 }
Stefan Reinauer70385642007-04-06 11:58:03 +00001078
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001079 size = chip->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001080 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +00001081
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001082 /* Start filling in the dynamic data. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001083 flash->chip = calloc(1, sizeof(struct flashchip));
1084 if (!flash->chip) {
1085 msg_gerr("Out of memory!\n");
1086 exit(1);
1087 }
1088 memcpy(flash->chip, chip, sizeof(struct flashchip));
1089 flash->pgm = pgm;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001090
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +00001091 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001092 flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001093
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001094 /* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
1095 * is only called with force=1 after normal probing failed.
1096 */
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001097 if (force)
1098 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001099
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001100 if (flash->chip->probe(flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +00001101 goto notfound;
1102
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001103 /* If this is the first chip found, accept it.
1104 * If this is not the first chip found, accept it only if it is
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001105 * a non-generic match. SFDP and CFI are generic matches.
1106 * startchip==0 means this call to probe_flash() is the first
1107 * one for this programmer interface and thus no other chip has
1108 * been found on this interface.
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001109 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001110 if (startchip == 0 && flash->chip->model_id == SFDP_DEVICE_ID) {
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001111 msg_cinfo("===\n"
1112 "SFDP has autodetected a flash chip which is "
1113 "not natively supported by flashrom yet.\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001114 if (count_usable_erasers(flash) == 0)
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001115 msg_cinfo("The standard operations read and "
1116 "verify should work, but to support "
1117 "erase, write and all other "
1118 "possible features");
1119 else
1120 msg_cinfo("All standard operations (read, "
1121 "verify, erase and write) should "
1122 "work, but to support all possible "
1123 "features");
1124
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001125 msg_cinfo(" we need to add them manually.\n"
1126 "You can help us by mailing us the output of the following command to "
1127 "flashrom@flashrom.org:\n"
1128 "'flashrom -VV [plus the -p/--programmer parameter]'\n"
1129 "Thanks for your help!\n"
Stefan Taunerac1b4c82012-02-17 14:51:04 +00001130 "===\n");
1131 }
1132
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001133 /* First flash chip detected on this bus. */
1134 if (startchip == 0)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001135 break;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001136 /* Not the first flash chip detected on this bus, but not a generic match either. */
1137 if ((flash->chip->model_id != GENERIC_DEVICE_ID) && (flash->chip->model_id != SFDP_DEVICE_ID))
1138 break;
1139 /* 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 +00001140notfound:
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001141 programmer_unmap_flash_region((void *)flash->virtual_memory, size);
1142 flash->virtual_memory = (chipaddr)NULL;
1143 free(flash->chip);
1144 flash->chip = NULL;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001145 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001146
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001147 if (!flash->chip)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001148 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001149
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001150#if CONFIG_INTERNAL == 1
1151 if (programmer_table[programmer].map_flash_region == physmap)
Stefan Reinauer051e2362011-01-19 06:21:54 +00001152 snprintf(location, sizeof(location), "at physical address 0x%lx", base);
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001153 else
1154#endif
Stefan Reinauer051e2362011-01-19 06:21:54 +00001155 snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name);
Stefan Reinauer051e2362011-01-19 06:21:54 +00001156
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001157 tmp = flashbuses_to_text(flash->chip->bustype);
1158 msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) %s.\n", force ? "Assuming" : "Found",
1159 flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp, location);
Stefan Tauner00155492011-06-26 20:45:35 +00001160 free(tmp);
Uwe Hermann9899cad2009-06-28 21:47:57 +00001161
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +00001162 /* Flash registers will not be mapped if the chip was forced. Lock info
1163 * may be stored in registers, so avoid lock info printing.
1164 */
1165 if (!force)
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001166 if (flash->chip->printlock)
1167 flash->chip->printlock(flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +00001168
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001169 /* Return position of matching chip. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001170 return chip - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001171}
1172
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001173int read_buf_from_file(unsigned char *buf, unsigned long size,
1174 const char *filename)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001175{
Nico Huber7562f7d2013-08-30 21:29:45 +00001176#ifdef __LIBPAYLOAD__
1177 msg_gerr("Error: No file I/O support in libpayload\n");
1178 return 1;
1179#else
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001180 unsigned long numbytes;
1181 FILE *image;
1182 struct stat image_stat;
1183
1184 if ((image = fopen(filename, "rb")) == NULL) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001185 msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001186 return 1;
1187 }
1188 if (fstat(fileno(image), &image_stat) != 0) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001189 msg_gerr("Error: getting metadata of file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001190 fclose(image);
1191 return 1;
1192 }
1193 if (image_stat.st_size != size) {
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +00001194 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 +00001195 (intmax_t)image_stat.st_size, size);
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001196 fclose(image);
1197 return 1;
1198 }
1199 numbytes = fread(buf, 1, size, image);
1200 if (fclose(image)) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001201 msg_gerr("Error: closing file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001202 return 1;
1203 }
1204 if (numbytes != size) {
1205 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1206 "wanted %ld!\n", numbytes, size);
1207 return 1;
1208 }
1209 return 0;
Nico Huber7562f7d2013-08-30 21:29:45 +00001210#endif
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001211}
1212
Mark Marshallf20b7be2014-05-09 21:16:21 +00001213int write_buf_to_file(const unsigned char *buf, unsigned long size, const char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001214{
Nico Huber7562f7d2013-08-30 21:29:45 +00001215#ifdef __LIBPAYLOAD__
1216 msg_gerr("Error: No file I/O support in libpayload\n");
1217 return 1;
1218#else
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001219 unsigned long numbytes;
1220 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001221
1222 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001223 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001224 return 1;
1225 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001226 if ((image = fopen(filename, "wb")) == NULL) {
Stefan Tauner363fd7e2013-04-07 13:08:30 +00001227 msg_gerr("Error: opening file \"%s\" failed: %s\n", filename, strerror(errno));
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001228 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001229 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001230
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001231 numbytes = fwrite(buf, 1, size, image);
1232 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001233 if (numbytes != size) {
1234 msg_gerr("File %s could not be written completely.\n",
1235 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001236 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001237 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001238 return 0;
Nico Huber7562f7d2013-08-30 21:29:45 +00001239#endif
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001240}
1241
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001242int read_flash_to_file(struct flashctx *flash, const char *filename)
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001243{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001244 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001245 unsigned char *buf = calloc(size, sizeof(char));
1246 int ret = 0;
1247
1248 msg_cinfo("Reading flash... ");
1249 if (!buf) {
1250 msg_gerr("Memory allocation failed!\n");
1251 msg_cinfo("FAILED.\n");
1252 return 1;
1253 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001254 if (!flash->chip->read) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001255 msg_cerr("No read function available for this flash chip.\n");
1256 ret = 1;
1257 goto out_free;
1258 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001259 if (flash->chip->read(flash, buf, 0, size)) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001260 msg_cerr("Read operation failed!\n");
1261 ret = 1;
1262 goto out_free;
1263 }
1264
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001265 ret = write_buf_to_file(buf, size, filename);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001266out_free:
1267 free(buf);
1268 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1269 return ret;
1270}
1271
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001272/* This function shares a lot of its structure with erase_and_write_flash() and
1273 * walk_eraseregions().
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001274 * Even if an error is found, the function will keep going and check the rest.
1275 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001276static int selfcheck_eraseblocks(const struct flashchip *chip)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001277{
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001278 int i, j, k;
1279 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001280
1281 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1282 unsigned int done = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001283 struct block_eraser eraser = chip->block_erasers[k];
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001284
1285 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1286 /* Blocks with zero size are bugs in flashchips.c. */
1287 if (eraser.eraseblocks[i].count &&
1288 !eraser.eraseblocks[i].size) {
1289 msg_gerr("ERROR: Flash chip %s erase function "
1290 "%i region %i has size 0. Please report"
1291 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001292 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001293 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001294 }
1295 /* Blocks with zero count are bugs in flashchips.c. */
1296 if (!eraser.eraseblocks[i].count &&
1297 eraser.eraseblocks[i].size) {
1298 msg_gerr("ERROR: Flash chip %s erase function "
1299 "%i region %i has count 0. Please report"
1300 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001301 chip->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001302 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001303 }
1304 done += eraser.eraseblocks[i].count *
1305 eraser.eraseblocks[i].size;
1306 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001307 /* Empty eraseblock definition with erase function. */
1308 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001309 msg_gspew("Strange: Empty eraseblock definition with "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001310 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001311 if (!done)
1312 continue;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001313 if (done != chip->total_size * 1024) {
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001314 msg_gerr("ERROR: Flash chip %s erase function %i "
1315 "region walking resulted in 0x%06x bytes total,"
1316 " expected 0x%06x bytes. Please report a bug at"
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001317 " flashrom@flashrom.org\n", chip->name, k,
1318 done, chip->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001319 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001320 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001321 if (!eraser.block_erase)
1322 continue;
1323 /* Check if there are identical erase functions for different
1324 * layouts. That would imply "magic" erase functions. The
1325 * easiest way to check this is with function pointers.
1326 */
Uwe Hermann43959702010-03-13 17:28:29 +00001327 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001328 if (eraser.block_erase ==
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001329 chip->block_erasers[j].block_erase) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001330 msg_gerr("ERROR: Flash chip %s erase function "
1331 "%i and %i are identical. Please report"
1332 " a bug at flashrom@flashrom.org\n",
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001333 chip->name, k, j);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001334 ret = 1;
1335 }
Uwe Hermann43959702010-03-13 17:28:29 +00001336 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001337 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001338 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001339}
1340
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001341static int erase_and_write_block_helper(struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001342 unsigned int start, unsigned int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001343 uint8_t *curcontents,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001344 uint8_t *newcontents,
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001345 int (*erasefn) (struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001346 unsigned int addr,
1347 unsigned int len))
1348{
Stefan Taunerc69c9c82011-11-23 09:13:48 +00001349 unsigned int starthere = 0, lenhere = 0;
1350 int ret = 0, skip = 1, writecount = 0;
Stefan Tauner50d67aa2013-03-03 23:49:48 +00001351 enum write_granularity gran = flash->chip->gran;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001352
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001353 /* curcontents and newcontents are opaque to walk_eraseregions, and
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001354 * need to be adjusted here to keep the impression of proper abstraction
1355 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001356 curcontents += start;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001357 newcontents += start;
1358 msg_cdbg(":");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001359 if (need_erase(curcontents, newcontents, len, gran)) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001360 msg_cdbg("E");
1361 ret = erasefn(flash, start, len);
1362 if (ret)
1363 return ret;
Carl-Daniel Hailfingerb4061f62011-06-26 17:04:16 +00001364 if (check_erased_range(flash, start, len)) {
1365 msg_cerr("ERASE FAILED!\n");
1366 return -1;
1367 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001368 /* Erase was successful. Adjust curcontents. */
1369 memset(curcontents, 0xff, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001370 skip = 0;
1371 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001372 /* get_next_write() sets starthere to a new value after the call. */
1373 while ((lenhere = get_next_write(curcontents + starthere,
1374 newcontents + starthere,
1375 len - starthere, &starthere, gran))) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001376 if (!writecount++)
1377 msg_cdbg("W");
1378 /* Needs the partial write function signature. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001379 ret = flash->chip->write(flash, newcontents + starthere,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001380 start + starthere, lenhere);
1381 if (ret)
1382 return ret;
1383 starthere += lenhere;
1384 skip = 0;
1385 }
1386 if (skip)
1387 msg_cdbg("S");
Stefan Tauner682122b2013-06-23 22:15:39 +00001388 else
1389 all_skipped = false;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001390 return ret;
1391}
1392
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001393static int walk_eraseregions(struct flashctx *flash, int erasefunction,
1394 int (*do_something) (struct flashctx *flash,
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001395 unsigned int addr,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001396 unsigned int len,
1397 uint8_t *param1,
1398 uint8_t *param2,
1399 int (*erasefn) (
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001400 struct flashctx *flash,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001401 unsigned int addr,
1402 unsigned int len)),
1403 void *param1, void *param2)
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001404{
1405 int i, j;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001406 unsigned int start = 0;
1407 unsigned int len;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001408 struct block_eraser eraser = flash->chip->block_erasers[erasefunction];
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001409
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001410 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1411 /* count==0 for all automatically initialized array
1412 * members so the loop below won't be executed for them.
1413 */
1414 len = eraser.eraseblocks[i].size;
1415 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001416 /* Print this for every block except the first one. */
1417 if (i || j)
1418 msg_cdbg(", ");
1419 msg_cdbg("0x%06x-0x%06x", start,
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001420 start + len - 1);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001421 if (do_something(flash, start, len, param1, param2,
1422 eraser.block_erase)) {
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001423 return 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001424 }
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001425 start += len;
1426 }
1427 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001428 msg_cdbg("\n");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001429 return 0;
1430}
1431
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +00001432static int check_block_eraser(const struct flashctx *flash, int k, int log)
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001433{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001434 struct block_eraser eraser = flash->chip->block_erasers[k];
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001435
1436 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
1437 if (log)
1438 msg_cdbg("not defined. ");
1439 return 1;
1440 }
1441 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
1442 if (log)
1443 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001444 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001445 return 1;
1446 }
1447 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
1448 if (log)
1449 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001450 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001451 return 1;
1452 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001453 // TODO: Once erase functions are annotated with allowed buses, check that as well.
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001454 return 0;
1455}
1456
Mark Marshallf20b7be2014-05-09 21:16:21 +00001457int erase_and_write_flash(struct flashctx *flash, uint8_t *oldcontents, uint8_t *newcontents)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001458{
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001459 int k, ret = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001460 uint8_t *curcontents;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001461 unsigned long size = flash->chip->total_size * 1024;
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001462 unsigned int usable_erasefunctions = count_usable_erasers(flash);
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001463
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001464 msg_cinfo("Erasing and writing flash chip... ");
Stefan Tauner269de352011-07-12 22:35:21 +00001465 curcontents = malloc(size);
1466 if (!curcontents) {
1467 msg_gerr("Out of memory!\n");
1468 exit(1);
1469 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001470 /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1471 memcpy(curcontents, oldcontents, size);
1472
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001473 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001474 if (k != 0)
1475 msg_cdbg("Looking for another erase function.\n");
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001476 if (!usable_erasefunctions) {
1477 msg_cdbg("No usable erase functions left.\n");
1478 break;
1479 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001480 msg_cdbg("Trying erase function %i... ", k);
1481 if (check_block_eraser(flash, k, 1))
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001482 continue;
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001483 usable_erasefunctions--;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001484 ret = walk_eraseregions(flash, k, &erase_and_write_block_helper,
1485 curcontents, newcontents);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001486 /* If everything is OK, don't try another erase function. */
1487 if (!ret)
1488 break;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001489 /* Write/erase failed, so try to find out what the current chip
Carl-Daniel Hailfingerd8334db2011-07-21 21:21:04 +00001490 * contents are. If no usable erase functions remain, we can
1491 * skip this: the next iteration will break immediately anyway.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001492 */
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001493 if (!usable_erasefunctions)
1494 continue;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001495 /* Reading the whole chip may take a while, inform the user even
1496 * in non-verbose mode.
1497 */
1498 msg_cinfo("Reading current flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001499 if (flash->chip->read(flash, curcontents, 0, size)) {
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001500 /* Now we are truly screwed. Read failed as well. */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001501 msg_cerr("Can't read anymore! Aborting.\n");
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001502 /* We have no idea about the flash chip contents, so
1503 * retrying with another erase function is pointless.
1504 */
1505 break;
1506 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001507 msg_cinfo("done. ");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001508 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001509 /* Free the scratchpad. */
1510 free(curcontents);
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001511
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001512 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001513 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001514 } else {
Stefan Tauner682122b2013-06-23 22:15:39 +00001515 if (all_skipped)
1516 msg_cinfo("\nWarning: Chip content is identical to the requested image.\n");
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001517 msg_cinfo("Erase/write done.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001518 }
1519 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001520}
1521
Stefan Tauner136388f2013-07-15 10:47:53 +00001522static void nonfatal_help_message(void)
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001523{
Stefan Taunera58f6e92014-05-10 09:25:44 +00001524 msg_gerr("Good, writing to the flash chip apparently didn't do anything.\n");
Stefan Tauner136388f2013-07-15 10:47:53 +00001525#if CONFIG_INTERNAL == 1
1526 if (programmer == PROGRAMMER_INTERNAL)
1527 msg_gerr("This means we have to add special support for your board, programmer or flash\n"
1528 "chip. Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1529 "mail flashrom@flashrom.org, thanks!\n"
1530 "-------------------------------------------------------------------------------\n"
1531 "You may now reboot or simply leave the machine running.\n");
1532 else
1533#endif
1534 msg_gerr("Please check the connections (especially those to write protection pins) between\n"
1535 "the programmer and the flash chip. If you think the error is caused by flashrom\n"
1536 "please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1537 "mail flashrom@flashrom.org, thanks!\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001538}
1539
Stefan Tauner136388f2013-07-15 10:47:53 +00001540static void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001541{
Stefan Tauner136388f2013-07-15 10:47:53 +00001542 msg_gerr("Your flash chip is in an unknown state.\n");
1543#if CONFIG_INTERNAL == 1
1544 if (programmer == PROGRAMMER_INTERNAL)
1545 msg_gerr("Get help on IRC at chat.freenode.net (channel #flashrom) or\n"
1546 "mail flashrom@flashrom.org with the subject \"FAILED: <your board name>\"!\n"
1547 "-------------------------------------------------------------------------------\n"
1548 "DO NOT REBOOT OR POWEROFF!\n");
1549 else
1550#endif
1551 msg_gerr("Please report this on IRC at chat.freenode.net (channel #flashrom) or\n"
1552 "mail flashrom@flashrom.org, thanks!\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001553}
1554
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001555/* The way to go if you want a delimited list of programmers */
Stefan Tauner66652442011-06-26 17:38:17 +00001556void list_programmers(const char *delim)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001557{
1558 enum programmer p;
1559 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001560 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001561 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001562 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001563 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001564 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001565}
1566
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001567void list_programmers_linebreak(int startcol, int cols, int paren)
1568{
1569 const char *pname;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001570 int pnamelen;
1571 int remaining = 0, firstline = 1;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001572 enum programmer p;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001573 int i;
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001574
1575 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1576 pname = programmer_table[p].name;
1577 pnamelen = strlen(pname);
1578 if (remaining - pnamelen - 2 < 0) {
1579 if (firstline)
1580 firstline = 0;
1581 else
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001582 msg_ginfo("\n");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001583 for (i = 0; i < startcol; i++)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001584 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001585 remaining = cols - startcol;
1586 } else {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001587 msg_ginfo(" ");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001588 remaining--;
1589 }
1590 if (paren && (p == 0)) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001591 msg_ginfo("(");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001592 remaining--;
1593 }
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001594 msg_ginfo("%s", pname);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001595 remaining -= pnamelen;
1596 if (p < PROGRAMMER_INVALID - 1) {
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001597 msg_ginfo(",");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001598 remaining--;
1599 } else {
1600 if (paren)
Carl-Daniel Hailfinger901a3ba2012-05-14 22:54:58 +00001601 msg_ginfo(")");
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001602 }
1603 }
1604}
1605
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001606void print_sysinfo(void)
1607{
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001608#ifdef _WIN32
1609 SYSTEM_INFO si;
1610 OSVERSIONINFOEX osvi;
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001611
Carl-Daniel Hailfinger60d9bd22012-08-09 23:34:41 +00001612 memset(&si, 0, sizeof(SYSTEM_INFO));
1613 memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
1614 msg_ginfo(" on Windows");
1615 /* Tell Windows which version of the structure we want. */
1616 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1617 if (GetVersionEx((OSVERSIONINFO*) &osvi))
1618 msg_ginfo(" %lu.%lu", osvi.dwMajorVersion, osvi.dwMinorVersion);
1619 else
1620 msg_ginfo(" unknown version");
1621 GetSystemInfo(&si);
1622 switch (si.wProcessorArchitecture) {
1623 case PROCESSOR_ARCHITECTURE_AMD64:
1624 msg_ginfo(" (x86_64)");
1625 break;
1626 case PROCESSOR_ARCHITECTURE_INTEL:
1627 msg_ginfo(" (x86)");
1628 break;
1629 default:
1630 msg_ginfo(" (unknown arch)");
1631 break;
1632 }
1633#elif HAVE_UTSNAME == 1
1634 struct utsname osinfo;
1635
1636 uname(&osinfo);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001637 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1638 osinfo.machine);
1639#else
1640 msg_ginfo(" on unknown machine");
1641#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001642}
1643
1644void print_buildinfo(void)
1645{
1646 msg_gdbg("flashrom was built with");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001647#if NEED_PCI == 1
1648#ifdef PCILIB_VERSION
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001649 msg_gdbg(" libpci %s,", PCILIB_VERSION);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001650#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001651 msg_gdbg(" unknown PCI library,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001652#endif
1653#endif
1654#ifdef __clang__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001655 msg_gdbg(" LLVM Clang");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001656#ifdef __clang_version__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001657 msg_gdbg(" %s,", __clang_version__);
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001658#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001659 msg_gdbg(" unknown version (before r102686),");
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001660#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001661#elif defined(__GNUC__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001662 msg_gdbg(" GCC");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001663#ifdef __VERSION__
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001664 msg_gdbg(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001665#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001666 msg_gdbg(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001667#endif
1668#else
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001669 msg_gdbg(" unknown compiler,");
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001670#endif
1671#if defined (__FLASHROM_LITTLE_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001672 msg_gdbg(" little endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001673#elif defined (__FLASHROM_BIG_ENDIAN__)
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001674 msg_gdbg(" big endian");
Carl-Daniel Hailfinger06b9efa2012-08-07 11:59:59 +00001675#else
1676#error Endianness could not be determined
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001677#endif
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001678 msg_gdbg("\n");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001679}
1680
Bernhard Walle201bde32008-01-21 15:24:22 +00001681void print_version(void)
1682{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001683 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001684 print_sysinfo();
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +00001685 msg_ginfo("\n");
Bernhard Walle201bde32008-01-21 15:24:22 +00001686}
1687
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001688void print_banner(void)
1689{
1690 msg_ginfo("flashrom is free software, get the source code at "
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001691 "http://www.flashrom.org\n");
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001692 msg_ginfo("\n");
1693}
1694
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001695int selfcheck(void)
1696{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001697 const struct flashchip *chip;
Stefan Taunera6d96482012-12-26 19:51:23 +00001698 int i;
1699 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001700
1701 /* Safety check. Instead of aborting after the first error, check
1702 * if more errors exist.
1703 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001704 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001705 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001706 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001707 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001708 for (i = 0; i < PROGRAMMER_INVALID; i++) {
1709 const struct programmer_entry p = programmer_table[i];
1710 if (p.name == NULL) {
1711 msg_gerr("All programmers need a valid name, but the one with index %d does not!\n", i);
1712 ret = 1;
1713 /* This might hide other problems with this programmer, but allows for better error
1714 * messages below without jumping through hoops. */
1715 continue;
1716 }
Stefan Tauneraf358d62012-12-27 18:40:26 +00001717 switch (p.type) {
1718 case USB:
1719 case PCI:
1720 case OTHER:
1721 if (p.devs.note == NULL) {
1722 if (strcmp("internal", p.name) == 0)
1723 break; /* This one has its device list stored separately. */
1724 msg_gerr("Programmer %s has neither a device list nor a textual description!\n",
1725 p.name);
1726 ret = 1;
1727 }
1728 break;
1729 default:
1730 msg_gerr("Programmer %s does not have a valid type set!\n", p.name);
1731 ret = 1;
1732 break;
1733 }
Stefan Taunera6d96482012-12-26 19:51:23 +00001734 if (p.init == NULL) {
1735 msg_gerr("Programmer %s does not have a valid init function!\n", p.name);
1736 ret = 1;
1737 }
1738 if (p.delay == NULL) {
1739 msg_gerr("Programmer %s does not have a valid delay function!\n", p.name);
1740 ret = 1;
1741 }
1742 if (p.map_flash_region == NULL) {
1743 msg_gerr("Programmer %s does not have a valid map_flash_region function!\n", p.name);
1744 ret = 1;
1745 }
1746 if (p.unmap_flash_region == NULL) {
1747 msg_gerr("Programmer %s does not have a valid unmap_flash_region function!\n", p.name);
1748 ret = 1;
1749 }
1750 }
Stefan Tauner93f70232011-07-26 14:33:46 +00001751 /* It would be favorable if we could also check for correct termination
Stefan Tauner716e0982011-07-25 20:38:52 +00001752 * of the following arrays, but we don't know their sizes in here...
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001753 * For 'flashchips' we check the first element to be non-null. In the
1754 * other cases there exist use cases where the first element can be
1755 * null. */
1756 if (flashchips == NULL || flashchips[0].vendor == NULL) {
1757 msg_gerr("Flashchips table miscompilation!\n");
1758 ret = 1;
1759 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001760 for (chip = flashchips; chip && chip->name; chip++)
1761 if (selfcheck_eraseblocks(chip))
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001762 ret = 1;
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001763
1764#if CONFIG_INTERNAL == 1
1765 if (chipset_enables == NULL) {
1766 msg_gerr("Chipset enables table does not exist!\n");
1767 ret = 1;
1768 }
Carl-Daniel Hailfinger97d5b122011-08-31 16:19:50 +00001769 if (board_matches == NULL) {
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001770 msg_gerr("Board enables table does not exist!\n");
1771 ret = 1;
1772 }
1773 if (boards_known == NULL) {
1774 msg_gerr("Known boards table does not exist!\n");
1775 ret = 1;
1776 }
1777 if (laptops_known == NULL) {
1778 msg_gerr("Known laptops table does not exist!\n");
1779 ret = 1;
1780 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001781#endif
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001782 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001783}
1784
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001785void check_chip_supported(const struct flashchip *chip)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001786{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001787 if (chip->feature_bits & FEATURE_OTP) {
Daniel Lenski65922a32012-02-15 23:40:23 +00001788 msg_cdbg("This chip may contain one-time programmable memory. "
1789 "flashrom cannot read\nand may never be able to write "
1790 "it, hence it may not be able to completely\n"
1791 "clone the contents of this chip (see man page for "
1792 "details).\n");
1793 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001794 if (TEST_OK_MASK != (chip->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001795 msg_cinfo("===\n");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001796 if (chip->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001797 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001798 if (chip->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001799 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001800 if (chip->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001801 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001802 if (chip->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001803 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001804 if (chip->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001805 msg_cinfo(" WRITE");
1806 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001807 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001808 if ((!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE)) ||
1809 (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ)) ||
1810 (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE)) ||
1811 (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001812 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001813 if (!(chip->tested & TEST_BAD_PROBE) && !(chip->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001814 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001815 if (!(chip->tested & TEST_BAD_READ) && !(chip->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001816 msg_cinfo(" READ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001817 if (!(chip->tested & TEST_BAD_ERASE) && !(chip->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001818 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001819 if (!(chip->tested & TEST_BAD_WRITE) && !(chip->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001820 msg_cinfo(" WRITE");
1821 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001822 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001823 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001824 msg_cinfo("The test status of this chip may have been updated "
1825 "in the latest development\n"
1826 "version of flashrom. If you are running the latest "
1827 "development version,\n"
1828 "please email a report to flashrom@flashrom.org if "
1829 "any of the above operations\n"
1830 "work correctly for you with this flash part. Please "
1831 "include the flashrom\n"
1832 "output with the additional -V option for all "
1833 "operations you tested (-V, -Vr,\n"
Paul Menzele3800132012-01-12 13:58:43 +00001834 "-VE, -Vw), and mention which mainboard or "
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001835 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001836 "Please mention your board in the subject line. "
1837 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001838 }
1839}
1840
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001841/* FIXME: This function signature needs to be improved once doit() has a better
1842 * function signature.
1843 */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001844int chip_safety_check(const struct flashctx *flash, int force, int read_it, int write_it, int erase_it,
1845 int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001846{
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001847 const struct flashchip *chip = flash->chip;
1848
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001849 if (!programmer_may_write && (write_it || erase_it)) {
1850 msg_perr("Write/erase is not working yet on your programmer in "
1851 "its current configuration.\n");
1852 /* --force is the wrong approach, but it's the best we can do
1853 * until the generic programmer parameter parser is merged.
1854 */
1855 if (!force)
1856 return 1;
1857 msg_cerr("Continuing anyway.\n");
1858 }
1859
1860 if (read_it || erase_it || write_it || verify_it) {
1861 /* Everything needs read. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001862 if (chip->tested & TEST_BAD_READ) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001863 msg_cerr("Read is not working on this chip. ");
1864 if (!force)
1865 return 1;
1866 msg_cerr("Continuing anyway.\n");
1867 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001868 if (!chip->read) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001869 msg_cerr("flashrom has no read function for this "
1870 "flash chip.\n");
1871 return 1;
1872 }
1873 }
1874 if (erase_it || write_it) {
1875 /* Write needs erase. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001876 if (chip->tested & TEST_BAD_ERASE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001877 msg_cerr("Erase is not working on this chip. ");
1878 if (!force)
1879 return 1;
1880 msg_cerr("Continuing anyway.\n");
1881 }
Sylvain "ythier" Hitier9db45512011-07-04 07:27:17 +00001882 if(count_usable_erasers(flash) == 0) {
Stefan Tauner5368dca2011-07-01 00:19:12 +00001883 msg_cerr("flashrom has no erase function for this "
1884 "flash chip.\n");
1885 return 1;
1886 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001887 }
1888 if (write_it) {
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001889 if (chip->tested & TEST_BAD_WRITE) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001890 msg_cerr("Write is not working on this chip. ");
1891 if (!force)
1892 return 1;
1893 msg_cerr("Continuing anyway.\n");
1894 }
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001895 if (!chip->write) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001896 msg_cerr("flashrom has no write function for this "
1897 "flash chip.\n");
1898 return 1;
1899 }
1900 }
1901 return 0;
1902}
1903
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001904/* This function signature is horrible. We need to design a better interface,
1905 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001906 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001907 */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +00001908int doit(struct flashctx *flash, int force, const char *filename, int read_it,
1909 int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001910{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001911 uint8_t *oldcontents;
1912 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001913 int ret = 0;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001914 unsigned long size = flash->chip->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001915
David Hendricks77f931a2011-05-18 01:30:56 +00001916 if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001917 msg_cerr("Aborting.\n");
Stefan Tauner20da4aa2014-05-07 22:07:23 +00001918 return 1;
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001919 }
1920
Stefan Tauner8268fdb2013-09-23 14:21:06 +00001921 if (normalize_romentries(flash)) {
1922 msg_cerr("Requested regions can not be handled. Aborting.\n");
Stefan Tauner20da4aa2014-05-07 22:07:23 +00001923 return 1;
Stefan Tauner8268fdb2013-09-23 14:21:06 +00001924 }
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) {
Stefan Tauner20da4aa2014-05-07 22:07:23 +00001933 return read_flash_to_file(flash, filename);
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001934 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001935
Stefan Tauner269de352011-07-12 22:35:21 +00001936 oldcontents = malloc(size);
1937 if (!oldcontents) {
1938 msg_gerr("Out of memory!\n");
1939 exit(1);
1940 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001941 /* Assume worst case: All bits are 0. */
1942 memset(oldcontents, 0x00, size);
Stefan Tauner269de352011-07-12 22:35:21 +00001943 newcontents = malloc(size);
1944 if (!newcontents) {
1945 msg_gerr("Out of memory!\n");
1946 exit(1);
1947 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001948 /* Assume best case: All bits should be 1. */
1949 memset(newcontents, 0xff, size);
1950 /* Side effect of the assumptions above: Default write action is erase
1951 * because newcontents looks like a completely erased chip, and
1952 * oldcontents being completely 0x00 means we have to erase everything
1953 * before we can write.
1954 */
1955
Ollie Lhoefa28582004-12-08 20:10:01 +00001956 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001957 /* FIXME: Do we really want the scary warning if erase failed?
1958 * After all, after erase the chip is either blank or partially
1959 * blank or it has the old contents. A blank chip won't boot,
1960 * so if the user wanted erase and reboots afterwards, the user
1961 * knows very well that booting won't work.
1962 */
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001963 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001964 emergency_help_message();
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001965 ret = 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001966 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001967 goto out;
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001968 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001969
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001970 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001971 if (read_buf_from_file(newcontents, size, filename)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001972 ret = 1;
1973 goto out;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001974 }
1975
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001976#if CONFIG_INTERNAL == 1
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001977 if (programmer == PROGRAMMER_INTERNAL && cb_check_image(newcontents, size) < 0) {
1978 if (force_boardmismatch) {
1979 msg_pinfo("Proceeding anyway because user forced us to.\n");
1980 } else {
1981 msg_perr("Aborting. You can override this with "
1982 "-p internal:boardmismatch=force.\n");
Niklas Söderlund9e423762012-06-16 00:11:16 +00001983 ret = 1;
1984 goto out;
1985 }
Stefan Taunerb4e06bd2012-08-20 00:24:22 +00001986 }
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001987#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001988 }
1989
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001990 /* Read the whole chip to be able to check whether regions need to be
1991 * erased and to give better diagnostics in case write fails.
1992 * The alternative would be to read only the regions which are to be
1993 * preserved, but in that case we might perform unneeded erase which
1994 * takes time as well.
1995 */
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001996 msg_cinfo("Reading old flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00001997 if (flash->chip->read(flash, oldcontents, 0, size)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001998 ret = 1;
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00001999 msg_cinfo("FAILED.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002000 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002001 }
Carl-Daniel Hailfinger84d19682011-07-26 14:28:35 +00002002 msg_cinfo("done.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002003
Stefan Tauner8268fdb2013-09-23 14:21:06 +00002004 /* Build a new image taking the given layout into account. */
2005 build_new_image(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00002006
Ollie Lho184a4042005-11-26 21:55:36 +00002007 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00002008
Peter Stugef31104c2008-04-28 14:47:30 +00002009 if (write_it) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00002010 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Stefan Taunera58f6e92014-05-10 09:25:44 +00002011 msg_cerr("Uh oh. Erase/write failed. Checking if anything has changed.\n");
2012 msg_cinfo("Reading current flash chip contents... ");
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +00002013 if (!flash->chip->read(flash, newcontents, 0, size)) {
Stefan Taunera58f6e92014-05-10 09:25:44 +00002014 msg_cinfo("done.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002015 if (!memcmp(oldcontents, newcontents, size)) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002016 nonfatal_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002017 ret = 1;
2018 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00002019 }
Stefan Taunera58f6e92014-05-10 09:25:44 +00002020 msg_cerr("Apparently at least some data has changed.\n");
2021 } else
2022 msg_cerr("Can't even read anymore!\n");
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00002023 emergency_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002024 ret = 1;
2025 goto out;
Peter Stugef31104c2008-04-28 14:47:30 +00002026 }
Peter Stugef31104c2008-04-28 14:47:30 +00002027 }
Ollie Lho184a4042005-11-26 21:55:36 +00002028
Stefan Taunerc4f44df2013-08-12 22:58:43 +00002029 /* Verify only if we either did not try to write (verify operation) or actually changed something. */
2030 if (verify_it && (!write_it || !all_skipped)) {
Stefan Tauner78ffbea2012-10-27 15:36:56 +00002031 msg_cinfo("Verifying flash... ");
2032
2033 if (write_it) {
2034 /* Work around chips which need some time to calm down. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00002035 programmer_delay(1000*1000);
Stefan Tauner78ffbea2012-10-27 15:36:56 +00002036 ret = verify_range(flash, newcontents, 0, size);
2037 /* If we tried to write, and verification now fails, we
2038 * might have an emergency situation.
2039 */
2040 if (ret)
2041 emergency_help_message();
2042 } else {
2043 ret = compare_range(newcontents, oldcontents, 0, size);
2044 }
2045 if (!ret)
2046 msg_cinfo("VERIFIED.\n");
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00002047 }
Ollie Lho184a4042005-11-26 21:55:36 +00002048
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00002049out:
2050 free(oldcontents);
2051 free(newcontents);
Stefan Reinauer143da0b2006-01-04 16:42:57 +00002052 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00002053}