blob: f1edfca5987f5fabd6d70a8f4bbac0bdc3a240af [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>
Ollie Lho184a4042005-11-26 21:55:36 +000032#include <getopt.h>
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +000033#if HAVE_UTSNAME == 1
34#include <sys/utsname.h>
35#endif
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000036#include "flash.h"
Carl-Daniel Hailfinger08454642009-06-15 14:14:48 +000037#include "flashchips.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000038#include "programmer.h"
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000039
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000040const char * const flashrom_version = FLASHROM_VERSION;
Ronald G. Minnichceec4202003-07-25 04:37:41 +000041char *chip_to_probe = NULL;
Peter Stuge7ffbc6f2008-06-18 02:08:40 +000042int verbose = 0;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000043
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000044#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +000045enum programmer programmer = PROGRAMMER_INTERNAL;
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000046#elif CONFIG_DUMMY == 1
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000047enum programmer programmer = PROGRAMMER_DUMMY;
48#else
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000049/* If neither internal nor dummy are selected, we must pick a sensible default.
50 * Since there is no reason to prefer a particular external programmer, we fail
51 * if more than one of them is selected. If only one is selected, it is clear
52 * that the user wants that one to become the default.
53 */
Idwer Vollering004f4b72010-09-03 18:21:21 +000054#if CONFIG_NIC3COM+CONFIG_NICREALTEK+CONFIG_NICNATSEMI+CONFIG_GFXNVIDIA+CONFIG_DRKAISER+CONFIG_SATASII+CONFIG_ATAHPT+CONFIG_FT2232_SPI+CONFIG_SERPROG+CONFIG_BUSPIRATE_SPI+CONFIG_DEDIPROG+CONFIG_RAYER_SPI+CONFIG_NICINTEL_SPI > 1
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000055#error Please enable either CONFIG_DUMMY or CONFIG_INTERNAL or disable support for all programmers except one.
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000056#endif
57enum programmer programmer =
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000058#if CONFIG_NIC3COM == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000059 PROGRAMMER_NIC3COM
60#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000061#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +000062 PROGRAMMER_NICREALTEK
63 PROGRAMMER_NICREALTEK2
64#endif
Andrew Morganc29c2e72010-06-07 22:37:54 +000065#if CONFIG_NICNATSEMI == 1
66 PROGRAMMER_NICNATSEMI
67#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000068#if CONFIG_GFXNVIDIA == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000069 PROGRAMMER_GFXNVIDIA
70#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000071#if CONFIG_DRKAISER == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000072 PROGRAMMER_DRKAISER
73#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000074#if CONFIG_SATASII == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000075 PROGRAMMER_SATASII
76#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000077#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +000078 PROGRAMMER_ATAHPT
79#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000080#if CONFIG_FT2232_SPI == 1
81 PROGRAMMER_FT2232_SPI
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000082#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000083#if CONFIG_SERPROG == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000084 PROGRAMMER_SERPROG
85#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000086#if CONFIG_BUSPIRATE_SPI == 1
87 PROGRAMMER_BUSPIRATE_SPI
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000088#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000089#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000090 PROGRAMMER_DEDIPROG
91#endif
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +000092#if CONFIG_RAYER_SPI == 1
93 PROGRAMMER_RAYER_SPI
94#endif
Idwer Vollering004f4b72010-09-03 18:21:21 +000095#if CONFIG_NICINTEL_SPI == 1
96 PROGRAMMER_NICINTEL_SPI
97#endif
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000098;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000099#endif
100
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000101static char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +0000102
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000103/* Supported buses for the current programmer. */
104enum chipbustype buses_supported;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000105
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000106/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000107 * Programmers supporting multiple buses can have differing size limits on
108 * each bus. Store the limits for each bus in a common struct.
109 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000110struct decode_sizes max_rom_decode;
111
112/* If nonzero, used as the start address of bottom-aligned flash. */
113unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000114
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000115/* Is writing allowed with this programmer? */
116int programmer_may_write;
117
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000118const struct programmer_entry programmer_table[] = {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000119#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000120 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000121 .name = "internal",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000122 .init = internal_init,
123 .shutdown = internal_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000124 .map_flash_region = physmap,
125 .unmap_flash_region = physunmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000126 .chip_readb = internal_chip_readb,
127 .chip_readw = internal_chip_readw,
128 .chip_readl = internal_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000129 .chip_readn = internal_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000130 .chip_writeb = internal_chip_writeb,
131 .chip_writew = internal_chip_writew,
132 .chip_writel = internal_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000133 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000134 .delay = internal_delay,
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000135 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000136#endif
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000137
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000138#if CONFIG_DUMMY == 1
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000139 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000140 .name = "dummy",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000141 .init = dummy_init,
142 .shutdown = dummy_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000143 .map_flash_region = dummy_map,
144 .unmap_flash_region = dummy_unmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000145 .chip_readb = dummy_chip_readb,
146 .chip_readw = dummy_chip_readw,
147 .chip_readl = dummy_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000148 .chip_readn = dummy_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000149 .chip_writeb = dummy_chip_writeb,
150 .chip_writew = dummy_chip_writew,
151 .chip_writel = dummy_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000152 .chip_writen = dummy_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000153 .delay = internal_delay,
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000154 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000155#endif
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000156
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000157#if CONFIG_NIC3COM == 1
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000158 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000159 .name = "nic3com",
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000160 .init = nic3com_init,
161 .shutdown = nic3com_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000162 .map_flash_region = fallback_map,
163 .unmap_flash_region = fallback_unmap,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000164 .chip_readb = nic3com_chip_readb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000165 .chip_readw = fallback_chip_readw,
166 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000167 .chip_readn = fallback_chip_readn,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000168 .chip_writeb = nic3com_chip_writeb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000169 .chip_writew = fallback_chip_writew,
170 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000171 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000172 .delay = internal_delay,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000173 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000174#endif
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000175
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000176#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +0000177 {
178 .name = "nicrealtek",
179 .init = nicrealtek_init,
180 .shutdown = nicrealtek_shutdown,
181 .map_flash_region = fallback_map,
182 .unmap_flash_region = fallback_unmap,
183 .chip_readb = nicrealtek_chip_readb,
184 .chip_readw = fallback_chip_readw,
185 .chip_readl = fallback_chip_readl,
186 .chip_readn = fallback_chip_readn,
187 .chip_writeb = nicrealtek_chip_writeb,
188 .chip_writew = fallback_chip_writew,
189 .chip_writel = fallback_chip_writel,
190 .chip_writen = fallback_chip_writen,
191 .delay = internal_delay,
192 },
193 {
194 .name = "nicsmc1211",
195 .init = nicsmc1211_init,
196 .shutdown = nicrealtek_shutdown,
197 .map_flash_region = fallback_map,
198 .unmap_flash_region = fallback_unmap,
199 .chip_readb = nicrealtek_chip_readb,
200 .chip_readw = fallback_chip_readw,
201 .chip_readl = fallback_chip_readl,
202 .chip_readn = fallback_chip_readn,
203 .chip_writeb = nicrealtek_chip_writeb,
204 .chip_writew = fallback_chip_writew,
205 .chip_writel = fallback_chip_writel,
206 .chip_writen = fallback_chip_writen,
207 .delay = internal_delay,
208 },
209#endif
210
Andrew Morganc29c2e72010-06-07 22:37:54 +0000211#if CONFIG_NICNATSEMI == 1
212 {
213 .name = "nicnatsemi",
214 .init = nicnatsemi_init,
215 .shutdown = nicnatsemi_shutdown,
216 .map_flash_region = fallback_map,
217 .unmap_flash_region = fallback_unmap,
218 .chip_readb = nicnatsemi_chip_readb,
219 .chip_readw = fallback_chip_readw,
220 .chip_readl = fallback_chip_readl,
221 .chip_readn = fallback_chip_readn,
222 .chip_writeb = nicnatsemi_chip_writeb,
223 .chip_writew = fallback_chip_writew,
224 .chip_writel = fallback_chip_writel,
225 .chip_writen = fallback_chip_writen,
226 .delay = internal_delay,
227 },
228#endif
Joerg Fischer5665ef32010-05-21 21:54:07 +0000229
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000230#if CONFIG_GFXNVIDIA == 1
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000231 {
232 .name = "gfxnvidia",
233 .init = gfxnvidia_init,
234 .shutdown = gfxnvidia_shutdown,
235 .map_flash_region = fallback_map,
236 .unmap_flash_region = fallback_unmap,
237 .chip_readb = gfxnvidia_chip_readb,
238 .chip_readw = fallback_chip_readw,
239 .chip_readl = fallback_chip_readl,
240 .chip_readn = fallback_chip_readn,
241 .chip_writeb = gfxnvidia_chip_writeb,
242 .chip_writew = fallback_chip_writew,
243 .chip_writel = fallback_chip_writel,
244 .chip_writen = fallback_chip_writen,
245 .delay = internal_delay,
246 },
247#endif
248
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000249#if CONFIG_DRKAISER == 1
Rudolf Marek68720c72009-05-17 19:39:27 +0000250 {
TURBO Jb0912c02009-09-02 23:00:46 +0000251 .name = "drkaiser",
252 .init = drkaiser_init,
253 .shutdown = drkaiser_shutdown,
254 .map_flash_region = fallback_map,
255 .unmap_flash_region = fallback_unmap,
256 .chip_readb = drkaiser_chip_readb,
257 .chip_readw = fallback_chip_readw,
258 .chip_readl = fallback_chip_readl,
259 .chip_readn = fallback_chip_readn,
260 .chip_writeb = drkaiser_chip_writeb,
261 .chip_writew = fallback_chip_writew,
262 .chip_writel = fallback_chip_writel,
263 .chip_writen = fallback_chip_writen,
264 .delay = internal_delay,
265 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000266#endif
TURBO Jb0912c02009-09-02 23:00:46 +0000267
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000268#if CONFIG_SATASII == 1
TURBO Jb0912c02009-09-02 23:00:46 +0000269 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000270 .name = "satasii",
Rudolf Marek68720c72009-05-17 19:39:27 +0000271 .init = satasii_init,
272 .shutdown = satasii_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000273 .map_flash_region = fallback_map,
274 .unmap_flash_region = fallback_unmap,
Rudolf Marek68720c72009-05-17 19:39:27 +0000275 .chip_readb = satasii_chip_readb,
276 .chip_readw = fallback_chip_readw,
277 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000278 .chip_readn = fallback_chip_readn,
Rudolf Marek68720c72009-05-17 19:39:27 +0000279 .chip_writeb = satasii_chip_writeb,
280 .chip_writew = fallback_chip_writew,
281 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000282 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000283 .delay = internal_delay,
Rudolf Marek68720c72009-05-17 19:39:27 +0000284 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000285#endif
Rudolf Marek68720c72009-05-17 19:39:27 +0000286
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000287#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000288 {
289 .name = "atahpt",
290 .init = atahpt_init,
291 .shutdown = atahpt_shutdown,
292 .map_flash_region = fallback_map,
293 .unmap_flash_region = fallback_unmap,
294 .chip_readb = atahpt_chip_readb,
295 .chip_readw = fallback_chip_readw,
296 .chip_readl = fallback_chip_readl,
297 .chip_readn = fallback_chip_readn,
298 .chip_writeb = atahpt_chip_writeb,
299 .chip_writew = fallback_chip_writew,
300 .chip_writel = fallback_chip_writel,
301 .chip_writen = fallback_chip_writen,
302 .delay = internal_delay,
303 },
304#endif
305
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000306#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000307#if defined(__i386__) || defined(__x86_64__)
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000308 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000309 .name = "it87spi",
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000310 .init = it87spi_init,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000311 .shutdown = noop_shutdown,
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000312 .map_flash_region = fallback_map,
313 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000314 .chip_readb = noop_chip_readb,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000315 .chip_readw = fallback_chip_readw,
316 .chip_readl = fallback_chip_readl,
317 .chip_readn = fallback_chip_readn,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000318 .chip_writeb = noop_chip_writeb,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000319 .chip_writew = fallback_chip_writew,
320 .chip_writel = fallback_chip_writel,
321 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000322 .delay = internal_delay,
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000323 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000324#endif
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000325#endif
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000326
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000327#if CONFIG_FT2232_SPI == 1
Paul Fox05dfbe62009-06-16 21:08:06 +0000328 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000329 .name = "ft2232_spi",
Paul Fox05dfbe62009-06-16 21:08:06 +0000330 .init = ft2232_spi_init,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000331 .shutdown = noop_shutdown, /* Missing shutdown */
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000332 .map_flash_region = fallback_map,
333 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000334 .chip_readb = noop_chip_readb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000335 .chip_readw = fallback_chip_readw,
336 .chip_readl = fallback_chip_readl,
337 .chip_readn = fallback_chip_readn,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000338 .chip_writeb = noop_chip_writeb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000339 .chip_writew = fallback_chip_writew,
340 .chip_writel = fallback_chip_writel,
341 .chip_writen = fallback_chip_writen,
342 .delay = internal_delay,
343 },
Carl-Daniel Hailfinger3426ef62009-08-19 13:27:58 +0000344#endif
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000345
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000346#if CONFIG_SERPROG == 1
Urja Rannikko22915352009-06-23 11:33:43 +0000347 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000348 .name = "serprog",
Urja Rannikko22915352009-06-23 11:33:43 +0000349 .init = serprog_init,
350 .shutdown = serprog_shutdown,
351 .map_flash_region = fallback_map,
352 .unmap_flash_region = fallback_unmap,
353 .chip_readb = serprog_chip_readb,
354 .chip_readw = fallback_chip_readw,
355 .chip_readl = fallback_chip_readl,
356 .chip_readn = serprog_chip_readn,
357 .chip_writeb = serprog_chip_writeb,
358 .chip_writew = fallback_chip_writew,
359 .chip_writel = fallback_chip_writel,
360 .chip_writen = fallback_chip_writen,
361 .delay = serprog_delay,
362 },
Carl-Daniel Hailfinger6be74112009-08-12 16:17:41 +0000363#endif
Paul Fox05dfbe62009-06-16 21:08:06 +0000364
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000365#if CONFIG_BUSPIRATE_SPI == 1
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000366 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000367 .name = "buspirate_spi",
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000368 .init = buspirate_spi_init,
369 .shutdown = buspirate_spi_shutdown,
370 .map_flash_region = fallback_map,
371 .unmap_flash_region = fallback_unmap,
372 .chip_readb = noop_chip_readb,
373 .chip_readw = fallback_chip_readw,
374 .chip_readl = fallback_chip_readl,
375 .chip_readn = fallback_chip_readn,
376 .chip_writeb = noop_chip_writeb,
377 .chip_writew = fallback_chip_writew,
378 .chip_writel = fallback_chip_writel,
379 .chip_writen = fallback_chip_writen,
380 .delay = internal_delay,
381 },
382#endif
383
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000384#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000385 {
386 .name = "dediprog",
387 .init = dediprog_init,
388 .shutdown = dediprog_shutdown,
389 .map_flash_region = fallback_map,
390 .unmap_flash_region = fallback_unmap,
391 .chip_readb = noop_chip_readb,
392 .chip_readw = fallback_chip_readw,
393 .chip_readl = fallback_chip_readl,
394 .chip_readn = fallback_chip_readn,
395 .chip_writeb = noop_chip_writeb,
396 .chip_writew = fallback_chip_writew,
397 .chip_writel = fallback_chip_writel,
398 .chip_writen = fallback_chip_writen,
399 .delay = internal_delay,
400 },
401#endif
402
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000403#if CONFIG_RAYER_SPI == 1
404 {
405 .name = "rayer_spi",
406 .init = rayer_spi_init,
407 .shutdown = noop_shutdown,
408 .map_flash_region = fallback_map,
409 .unmap_flash_region = fallback_unmap,
410 .chip_readb = noop_chip_readb,
411 .chip_readw = fallback_chip_readw,
412 .chip_readl = fallback_chip_readl,
413 .chip_readn = fallback_chip_readn,
414 .chip_writeb = noop_chip_writeb,
415 .chip_writew = fallback_chip_writew,
416 .chip_writel = fallback_chip_writel,
417 .chip_writen = fallback_chip_writen,
418 .delay = internal_delay,
419 },
420#endif
421
Idwer Vollering004f4b72010-09-03 18:21:21 +0000422#if CONFIG_NICINTEL_SPI == 1
423 {
424 .name = "nicintel_spi",
425 .init = nicintel_spi_init,
426 .shutdown = nicintel_spi_shutdown,
427 .map_flash_region = fallback_map,
428 .unmap_flash_region = fallback_unmap,
429 .chip_readb = noop_chip_readb,
430 .chip_readw = fallback_chip_readw,
431 .chip_readl = fallback_chip_readl,
432 .chip_readn = fallback_chip_readn,
433 .chip_writeb = noop_chip_writeb,
434 .chip_writew = fallback_chip_writew,
435 .chip_writel = fallback_chip_writel,
436 .chip_writen = fallback_chip_writen,
437 .delay = internal_delay,
438 },
439#endif
440
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000441 {}, /* This entry corresponds to PROGRAMMER_INVALID. */
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000442};
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000443
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000444#define SHUTDOWN_MAXFN 4
445static int shutdown_fn_count = 0;
446struct shutdown_func_data {
447 void (*func) (void *data);
448 void *data;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000449} static shutdown_fn[SHUTDOWN_MAXFN];
450/* Initialize to 0 to make sure nobody registers a shutdown function before
451 * programmer init.
452 */
453static int may_register_shutdown = 0;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000454
455/* Register a function to be executed on programmer shutdown.
456 * The advantage over atexit() is that you can supply a void pointer which will
457 * be used as parameter to the registered function upon programmer shutdown.
458 * This pointer can point to arbitrary data used by said function, e.g. undo
459 * information for GPIO settings etc. If unneeded, set data=NULL.
460 * Please note that the first (void *data) belongs to the function signature of
461 * the function passed as first parameter.
462 */
463int register_shutdown(void (*function) (void *data), void *data)
464{
465 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000466 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000467 SHUTDOWN_MAXFN);
468 return 1;
469 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000470 if (!may_register_shutdown) {
471 msg_perr("Tried to register a shutdown function before "
472 "programmer init.\n");
473 return 1;
474 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000475 shutdown_fn[shutdown_fn_count].func = function;
476 shutdown_fn[shutdown_fn_count].data = data;
477 shutdown_fn_count++;
478
479 return 0;
480}
481
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000482int programmer_init(char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000483{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000484 int ret;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000485 /* Initialize all programmer specific data. */
486 /* Default to unlimited decode sizes. */
487 max_rom_decode = (const struct decode_sizes) {
488 .parallel = 0xffffffff,
489 .lpc = 0xffffffff,
490 .fwh = 0xffffffff,
491 .spi = 0xffffffff
492 };
493 /* Default to Parallel/LPC/FWH flash devices. If a known host controller
494 * is found, the init routine sets the buses_supported bitfield.
495 */
496 buses_supported = CHIP_BUSTYPE_NONSPI;
497 /* Default to top aligned flash at 4 GB. */
498 flashbase = 0;
499 /* Registering shutdown functions is now allowed. */
500 may_register_shutdown = 1;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000501 /* Default to allowing writes. Broken programmers set this to 0. */
502 programmer_may_write = 1;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000503
504 programmer_param = param;
505 msg_pdbg("Initializing %s programmer\n",
506 programmer_table[programmer].name);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000507 ret = programmer_table[programmer].init();
508 if (programmer_param && strlen(programmer_param)) {
509 msg_perr("Unhandled programmer parameters: %s\n",
510 programmer_param);
511 /* Do not error out here, the init itself was successful. */
512 }
513 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000514}
515
516int programmer_shutdown(void)
517{
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000518 /* Registering shutdown functions is no longer allowed. */
519 may_register_shutdown = 0;
520 while (shutdown_fn_count > 0) {
521 int i = --shutdown_fn_count;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000522 shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000523 }
Uwe Hermann09e04f72009-05-16 22:36:00 +0000524 return programmer_table[programmer].shutdown();
525}
526
527void *programmer_map_flash_region(const char *descr, unsigned long phys_addr,
528 size_t len)
529{
530 return programmer_table[programmer].map_flash_region(descr,
531 phys_addr, len);
532}
533
534void programmer_unmap_flash_region(void *virt_addr, size_t len)
535{
536 programmer_table[programmer].unmap_flash_region(virt_addr, len);
537}
538
539void chip_writeb(uint8_t val, chipaddr addr)
540{
541 programmer_table[programmer].chip_writeb(val, addr);
542}
543
544void chip_writew(uint16_t val, chipaddr addr)
545{
546 programmer_table[programmer].chip_writew(val, addr);
547}
548
549void chip_writel(uint32_t val, chipaddr addr)
550{
551 programmer_table[programmer].chip_writel(val, addr);
552}
553
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000554void chip_writen(uint8_t *buf, chipaddr addr, size_t len)
555{
556 programmer_table[programmer].chip_writen(buf, addr, len);
557}
558
Uwe Hermann09e04f72009-05-16 22:36:00 +0000559uint8_t chip_readb(const chipaddr addr)
560{
561 return programmer_table[programmer].chip_readb(addr);
562}
563
564uint16_t chip_readw(const chipaddr addr)
565{
566 return programmer_table[programmer].chip_readw(addr);
567}
568
569uint32_t chip_readl(const chipaddr addr)
570{
571 return programmer_table[programmer].chip_readl(addr);
572}
573
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000574void chip_readn(uint8_t *buf, chipaddr addr, size_t len)
575{
576 programmer_table[programmer].chip_readn(buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000577}
578
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000579void programmer_delay(int usecs)
580{
581 programmer_table[programmer].delay(usecs);
582}
583
Peter Stuge776d2022009-01-26 00:39:57 +0000584void map_flash_registers(struct flashchip *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000585{
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000586 size_t size = flash->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000587 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000588 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000589 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000590}
591
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000592int read_memmapped(struct flashchip *flash, uint8_t *buf, int start, int len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000593{
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000594 chip_readn(buf, flash->virtual_memory + start, len);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000595
596 return 0;
597}
598
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000599int min(int a, int b)
600{
601 return (a < b) ? a : b;
602}
603
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000604int max(int a, int b)
605{
606 return (a > b) ? a : b;
607}
608
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000609int bitcount(unsigned long a)
610{
611 int i = 0;
612 for (; a != 0; a >>= 1)
613 if (a & 1)
614 i++;
615 return i;
616}
617
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000618char *strcat_realloc(char *dest, const char *src)
619{
620 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000621 if (!dest) {
622 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000623 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000624 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000625 strcat(dest, src);
626 return dest;
627}
628
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000629/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000630 * It will look for needle with a subsequent '=' in haystack, return a copy of
631 * needle and remove everything from the first occurrence of needle to the next
632 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000633 */
634char *extract_param(char **haystack, char *needle, char *delim)
635{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000636 char *param_pos, *opt_pos, *rest;
637 char *opt = NULL;
638 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000639 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000640
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000641 needlelen = strlen(needle);
642 if (!needlelen) {
643 msg_gerr("%s: empty needle! Please report a bug at "
644 "flashrom@flashrom.org\n", __func__);
645 return NULL;
646 }
647 /* No programmer parameters given. */
648 if (*haystack == NULL)
649 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000650 param_pos = strstr(*haystack, needle);
651 do {
652 if (!param_pos)
653 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000654 /* Needle followed by '='? */
655 if (param_pos[needlelen] == '=') {
656
657 /* Beginning of the string? */
658 if (param_pos == *haystack)
659 break;
660 /* After a delimiter? */
661 if (strchr(delim, *(param_pos - 1)))
662 break;
663 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000664 /* Continue searching. */
665 param_pos++;
666 param_pos = strstr(param_pos, needle);
667 } while (1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000668
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000669 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000670 /* Get the string after needle and '='. */
671 opt_pos = param_pos + needlelen + 1;
672 optlen = strcspn(opt_pos, delim);
673 /* Return an empty string if the parameter was empty. */
674 opt = malloc(optlen + 1);
675 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000676 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000677 exit(1);
678 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000679 strncpy(opt, opt_pos, optlen);
680 opt[optlen] = '\0';
681 rest = opt_pos + optlen;
682 /* Skip all delimiters after the current parameter. */
683 rest += strspn(rest, delim);
684 memmove(param_pos, rest, strlen(rest) + 1);
685 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000686 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000687
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000688 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000689}
690
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000691char *extract_programmer_param(char *param_name)
692{
693 return extract_param(&programmer_param, param_name, ",");
694}
695
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000696/* start is an offset to the base address of the flash chip */
697int check_erased_range(struct flashchip *flash, int start, int len)
698{
699 int ret;
700 uint8_t *cmpbuf = malloc(len);
701
702 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000703 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000704 exit(1);
705 }
706 memset(cmpbuf, 0xff, len);
707 ret = verify_range(flash, cmpbuf, start, len, "ERASE");
708 free(cmpbuf);
709 return ret;
710}
711
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000712/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000713 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
714 flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000715 * @start offset to the base address of the flash chip
716 * @len length of the verified area
717 * @message string to print in the "FAILED" message
718 * @return 0 for success, -1 for failure
719 */
720int verify_range(struct flashchip *flash, uint8_t *cmpbuf, int start, int len, char *message)
721{
722 int i, j, starthere, lenhere, ret = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000723 int page_size = flash->page_size;
724 uint8_t *readbuf = malloc(page_size);
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000725 int failcount = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000726
727 if (!len)
728 goto out_free;
729
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000730 if (!flash->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000731 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000732 return 1;
733 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000734 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000735 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000736 exit(1);
737 }
738
739 if (start + len > flash->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000740 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000741 " total_size 0x%x\n", __func__, start, len,
742 flash->total_size * 1024);
743 ret = -1;
744 goto out_free;
745 }
746 if (!message)
747 message = "VERIFY";
748
749 /* Warning: This loop has a very unusual condition and body.
750 * The loop needs to go through each page with at least one affected
751 * byte. The lowest page number is (start / page_size) since that
752 * division rounds down. The highest page number we want is the page
753 * where the last byte of the range lives. That last byte has the
754 * address (start + len - 1), thus the highest page number is
755 * (start + len - 1) / page_size. Since we want to include that last
756 * page as well, the loop condition uses <=.
757 */
758 for (i = start / page_size; i <= (start + len - 1) / page_size; i++) {
759 /* Byte position of the first byte in the range in this page. */
760 starthere = max(start, i * page_size);
761 /* Length of bytes in the range in this page. */
762 lenhere = min(start + len, (i + 1) * page_size) - starthere;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +0000763 ret = flash->read(flash, readbuf, starthere, lenhere);
764 if (ret) {
765 msg_gerr("Verification impossible because read failed "
766 "at 0x%x (len 0x%x)\n", starthere, lenhere);
767 break;
768 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000769 for (j = 0; j < lenhere; j++) {
770 if (cmpbuf[starthere - start + j] != readbuf[j]) {
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000771 /* Only print the first failure. */
772 if (!failcount++)
Sean Nelson316a29f2010-05-07 20:09:04 +0000773 msg_cerr("%s FAILED at 0x%08x! "
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000774 "Expected=0x%02x, Read=0x%02x,",
775 message, starthere + j,
776 cmpbuf[starthere - start + j],
777 readbuf[j]);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000778 }
779 }
780 }
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000781 if (failcount) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000782 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000783 start, start + len - 1, failcount);
784 ret = -1;
785 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000786
787out_free:
788 free(readbuf);
789 return ret;
790}
791
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000792/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000793 * Check if the buffer @have can be programmed to the content of @want without
794 * erasing. This is only possible if all chunks of size @gran are either kept
795 * as-is or changed from an all-ones state to any other state.
796 * The following write granularities (enum @gran) are known:
797 * - 1 bit. Each bit can be cleared individually.
798 * - 1 byte. A byte can be written once. Further writes to an already written
799 * byte cause the contents to be either undefined or to stay unchanged.
800 * - 128 bytes. If less than 128 bytes are written, the rest will be
801 * erased. Each write to a 128-byte region will trigger an automatic erase
802 * before anything is written. Very uncommon behaviour and unsupported by
803 * this function.
804 * - 256 bytes. If less than 256 bytes are written, the contents of the
805 * unwritten bytes are undefined.
806 *
807 * @have buffer with current content
808 * @want buffer with desired content
809 * @len length of the verified area
810 * @gran write granularity (enum, not count)
811 * @return 0 if no erase is needed, 1 otherwise
812 */
813int need_erase(uint8_t *have, uint8_t *want, int len, enum write_granularity gran)
814{
815 int result = 0;
816 int i, j, limit;
817
818 switch (gran) {
819 case write_gran_1bit:
820 for (i = 0; i < len; i++)
821 if ((have[i] & want[i]) != want[i]) {
822 result = 1;
823 break;
824 }
825 break;
826 case write_gran_1byte:
827 for (i = 0; i < len; i++)
828 if ((have[i] != want[i]) && (have[i] != 0xff)) {
829 result = 1;
830 break;
831 }
832 break;
833 case write_gran_256bytes:
834 for (j = 0; j < len / 256; j++) {
835 limit = min (256, len - j * 256);
Uwe Hermann43959702010-03-13 17:28:29 +0000836 /* Are 'have' and 'want' identical? */
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000837 if (!memcmp(have + j * 256, want + j * 256, limit))
838 continue;
839 /* have needs to be in erased state. */
840 for (i = 0; i < limit; i++)
841 if (have[i] != 0xff) {
842 result = 1;
843 break;
844 }
845 if (result)
846 break;
847 }
848 break;
849 }
850 return result;
851}
852
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000853/* This function generates various test patterns useful for testing controller
854 * and chip communication as well as chip behaviour.
855 *
856 * If a byte can be written multiple times, each time keeping 0-bits at 0
857 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
858 * is essentially an AND operation. That's also the reason why this function
859 * provides the result of AND between various patterns.
860 *
861 * Below is a list of patterns (and their block length).
862 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
863 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
864 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
865 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
866 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
867 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
868 * Pattern 6 is 00 (1 Byte)
869 * Pattern 7 is ff (1 Byte)
870 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
871 * byte block.
872 *
873 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
874 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
875 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
876 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
877 * Pattern 12 is 00 (1 Byte)
878 * Pattern 13 is ff (1 Byte)
879 * Patterns 8-13 have no block number.
880 *
881 * Patterns 0-3 are created to detect and efficiently diagnose communication
882 * slips like missed bits or bytes and their repetitive nature gives good visual
883 * cues to the person inspecting the results. In addition, the following holds:
884 * AND Pattern 0/1 == Pattern 4
885 * AND Pattern 2/3 == Pattern 5
886 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
887 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
888 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
889 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
890 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
891 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
892 * Besides that, they provide for bit testing of the last two bytes of every
893 * 256 byte block which contains the block number for patterns 0-6.
894 * Patterns 10-11 are special purpose for detecting subblock aliasing with
895 * block sizes >256 bytes (some Dataflash chips etc.)
896 * AND Pattern 8/9 == Pattern 12
897 * AND Pattern 10/11 == Pattern 12
898 * Pattern 13 is the completely erased state.
899 * None of the patterns can detect aliasing at boundaries which are a multiple
900 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
901 */
902int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
903{
904 int i;
905
906 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000907 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000908 return 1;
909 }
910
911 switch (variant) {
912 case 0:
913 for (i = 0; i < size; i++)
914 buf[i] = (i & 0xf) << 4 | 0x5;
915 break;
916 case 1:
917 for (i = 0; i < size; i++)
918 buf[i] = (i & 0xf) << 4 | 0xa;
919 break;
920 case 2:
921 for (i = 0; i < size; i++)
922 buf[i] = 0x50 | (i & 0xf);
923 break;
924 case 3:
925 for (i = 0; i < size; i++)
926 buf[i] = 0xa0 | (i & 0xf);
927 break;
928 case 4:
929 for (i = 0; i < size; i++)
930 buf[i] = (i & 0xf) << 4;
931 break;
932 case 5:
933 for (i = 0; i < size; i++)
934 buf[i] = i & 0xf;
935 break;
936 case 6:
937 memset(buf, 0x00, size);
938 break;
939 case 7:
940 memset(buf, 0xff, size);
941 break;
942 case 8:
943 for (i = 0; i < size; i++)
944 buf[i] = i & 0xff;
945 break;
946 case 9:
947 for (i = 0; i < size; i++)
948 buf[i] = ~(i & 0xff);
949 break;
950 case 10:
951 for (i = 0; i < size % 2; i++) {
952 buf[i * 2] = (i >> 8) & 0xff;
953 buf[i * 2 + 1] = i & 0xff;
954 }
955 if (size & 0x1)
956 buf[i * 2] = (i >> 8) & 0xff;
957 break;
958 case 11:
959 for (i = 0; i < size % 2; i++) {
960 buf[i * 2] = ~((i >> 8) & 0xff);
961 buf[i * 2 + 1] = ~(i & 0xff);
962 }
963 if (size & 0x1)
964 buf[i * 2] = ~((i >> 8) & 0xff);
965 break;
966 case 12:
967 memset(buf, 0x00, size);
968 break;
969 case 13:
970 memset(buf, 0xff, size);
971 break;
972 }
973
974 if ((variant >= 0) && (variant <= 7)) {
975 /* Write block number in the last two bytes of each 256-byte
976 * block, big endian for easier reading of the hexdump.
977 * Note that this wraps around for chips larger than 2^24 bytes
978 * (16 MB).
979 */
980 for (i = 0; i < size / 256; i++) {
981 buf[i * 256 + 254] = (i >> 8) & 0xff;
982 buf[i * 256 + 255] = i & 0xff;
983 }
984 }
985
986 return 0;
987}
988
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000989int check_max_decode(enum chipbustype buses, uint32_t size)
990{
991 int limitexceeded = 0;
992 if ((buses & CHIP_BUSTYPE_PARALLEL) &&
993 (max_rom_decode.parallel < size)) {
994 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +0000995 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000996 "size %u kB of chipset/board/programmer "
997 "for %s interface, "
998 "probe/read/erase/write may fail. ", size / 1024,
999 max_rom_decode.parallel / 1024, "Parallel");
1000 }
1001 if ((buses & CHIP_BUSTYPE_LPC) && (max_rom_decode.lpc < size)) {
1002 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001003 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001004 "size %u kB of chipset/board/programmer "
1005 "for %s interface, "
1006 "probe/read/erase/write may fail. ", size / 1024,
1007 max_rom_decode.lpc / 1024, "LPC");
1008 }
1009 if ((buses & CHIP_BUSTYPE_FWH) && (max_rom_decode.fwh < size)) {
1010 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001011 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001012 "size %u kB of chipset/board/programmer "
1013 "for %s interface, "
1014 "probe/read/erase/write may fail. ", size / 1024,
1015 max_rom_decode.fwh / 1024, "FWH");
1016 }
1017 if ((buses & CHIP_BUSTYPE_SPI) && (max_rom_decode.spi < size)) {
1018 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001019 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001020 "size %u kB of chipset/board/programmer "
1021 "for %s interface, "
1022 "probe/read/erase/write may fail. ", size / 1024,
1023 max_rom_decode.spi / 1024, "SPI");
1024 }
1025 if (!limitexceeded)
1026 return 0;
1027 /* Sometimes chip and programmer have more than one bus in common,
1028 * and the limit is not exceeded on all buses. Tell the user.
1029 */
1030 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001031 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +00001032 msg_pdbg("There is at least one common chip/programmer "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001033 "interface which can support a chip of this size. "
1034 "You can try --force at your own risk.\n");
1035 return 1;
1036}
1037
Peter Stuge483b8f02008-09-03 23:10:05 +00001038struct flashchip *probe_flash(struct flashchip *first_flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001039{
Peter Stuge483b8f02008-09-03 23:10:05 +00001040 struct flashchip *flash;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001041 unsigned long base = 0;
1042 uint32_t size;
1043 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001044 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001045
Peter Stuge483b8f02008-09-03 23:10:05 +00001046 for (flash = first_flash; flash && flash->name; flash++) {
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001047 if (chip_to_probe && strcmp(flash->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +00001048 continue;
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001049 msg_gdbg("Probing for %s %s, %d KB: ",
Stefan Reinauerac378972008-03-17 22:59:40 +00001050 flash->vendor, flash->name, flash->total_size);
Peter Stuge7ffbc6f2008-06-18 02:08:40 +00001051 if (!flash->probe && !force) {
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001052 msg_gdbg("failed! flashrom has no probe function for "
1053 "this flash chip.\n");
Peter Stugef31104c2008-04-28 14:47:30 +00001054 continue;
1055 }
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001056 buses_common = buses_supported & flash->bustype;
1057 if (!buses_common) {
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001058 tmp = flashbuses_to_text(buses_supported);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001059 msg_gdbg("skipped.");
1060 msg_gspew(" Host bus type %s ", tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001061 free(tmp);
1062 tmp = flashbuses_to_text(flash->bustype);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001063 msg_gspew("and chip bus type %s are incompatible.",
1064 tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001065 free(tmp);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001066 msg_gdbg("\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001067 continue;
1068 }
Stefan Reinauer70385642007-04-06 11:58:03 +00001069
Ollie Lhocbbf1252004-03-17 22:22:08 +00001070 size = flash->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001071 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +00001072
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +00001073 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +00001074 flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001075
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001076 if (force)
1077 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001078
Peter Stuge483b8f02008-09-03 23:10:05 +00001079 if (flash->probe(flash) != 1)
1080 goto notfound;
1081
Uwe Hermann394131e2008-10-18 21:14:13 +00001082 if (first_flash == flashchips
1083 || flash->model_id != GENERIC_DEVICE_ID)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001084 break;
1085
Peter Stuge483b8f02008-09-03 23:10:05 +00001086notfound:
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +00001087 programmer_unmap_flash_region((void *)flash->virtual_memory, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001088 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001089
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001090 if (!flash || !flash->name)
1091 return NULL;
1092
Sean Nelson316a29f2010-05-07 20:09:04 +00001093 msg_cinfo("%s chip \"%s %s\" (%d KB, %s) at physical address 0x%lx.\n",
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +00001094 force ? "Assuming" : "Found",
Uwe Hermann9899cad2009-06-28 21:47:57 +00001095 flash->vendor, flash->name, flash->total_size,
1096 flashbuses_to_text(flash->bustype), base);
1097
Sean Nelson6e0b9122010-02-19 00:52:10 +00001098 if (flash->printlock)
1099 flash->printlock(flash);
1100
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001101 return flash;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001102}
1103
Stefan Reinauere3705282005-12-18 16:41:10 +00001104int verify_flash(struct flashchip *flash, uint8_t *buf)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001105{
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001106 int ret;
Ollie Lho761bf1b2004-03-20 16:46:10 +00001107 int total_size = flash->total_size * 1024;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001108
Sean Nelson316a29f2010-05-07 20:09:04 +00001109 msg_cinfo("Verifying flash... ");
Uwe Hermanna7e05482007-05-09 10:17:44 +00001110
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001111 ret = verify_range(flash, buf, 0, total_size, NULL);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001112
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001113 if (!ret)
Sean Nelson316a29f2010-05-07 20:09:04 +00001114 msg_cinfo("VERIFIED. \n");
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001115
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001116 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001117}
1118
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001119int read_buf_from_file(unsigned char *buf, unsigned long size, char *filename)
1120{
1121 unsigned long numbytes;
1122 FILE *image;
1123 struct stat image_stat;
1124
1125 if ((image = fopen(filename, "rb")) == NULL) {
1126 perror(filename);
1127 return 1;
1128 }
1129 if (fstat(fileno(image), &image_stat) != 0) {
1130 perror(filename);
1131 fclose(image);
1132 return 1;
1133 }
1134 if (image_stat.st_size != size) {
1135 msg_gerr("Error: Image size doesn't match\n");
1136 fclose(image);
1137 return 1;
1138 }
1139 numbytes = fread(buf, 1, size, image);
1140 if (fclose(image)) {
1141 perror(filename);
1142 return 1;
1143 }
1144 if (numbytes != size) {
1145 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1146 "wanted %ld!\n", numbytes, size);
1147 return 1;
1148 }
1149 return 0;
1150}
1151
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001152int write_buf_to_file(unsigned char *buf, unsigned long size, char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001153{
1154 unsigned long numbytes;
1155 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001156
1157 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001158 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001159 return 1;
1160 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001161 if ((image = fopen(filename, "wb")) == NULL) {
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001162 perror(filename);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001163 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001164 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001165
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001166 numbytes = fwrite(buf, 1, size, image);
1167 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001168 if (numbytes != size) {
1169 msg_gerr("File %s could not be written completely.\n",
1170 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001171 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001172 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001173 return 0;
1174}
1175
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001176int read_flash_to_file(struct flashchip *flash, char *filename)
1177{
1178 unsigned long size = flash->total_size * 1024;
1179 unsigned char *buf = calloc(size, sizeof(char));
1180 int ret = 0;
1181
1182 msg_cinfo("Reading flash... ");
1183 if (!buf) {
1184 msg_gerr("Memory allocation failed!\n");
1185 msg_cinfo("FAILED.\n");
1186 return 1;
1187 }
1188 if (!flash->read) {
1189 msg_cerr("No read function available for this flash chip.\n");
1190 ret = 1;
1191 goto out_free;
1192 }
1193 if (flash->read(flash, buf, 0, size)) {
1194 msg_cerr("Read operation failed!\n");
1195 ret = 1;
1196 goto out_free;
1197 }
1198
1199 ret = write_buf_to_file(buf, flash->total_size * 1024, filename);
1200out_free:
1201 free(buf);
1202 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1203 return ret;
1204}
1205
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001206/* This function shares a lot of its structure with erase_flash().
1207 * Even if an error is found, the function will keep going and check the rest.
1208 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +00001209static int selfcheck_eraseblocks(struct flashchip *flash)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001210{
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001211 int i, j, k;
1212 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001213
1214 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1215 unsigned int done = 0;
1216 struct block_eraser eraser = flash->block_erasers[k];
1217
1218 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1219 /* Blocks with zero size are bugs in flashchips.c. */
1220 if (eraser.eraseblocks[i].count &&
1221 !eraser.eraseblocks[i].size) {
1222 msg_gerr("ERROR: Flash chip %s erase function "
1223 "%i region %i has size 0. Please report"
1224 " a bug at flashrom@flashrom.org\n",
1225 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001226 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001227 }
1228 /* Blocks with zero count are bugs in flashchips.c. */
1229 if (!eraser.eraseblocks[i].count &&
1230 eraser.eraseblocks[i].size) {
1231 msg_gerr("ERROR: Flash chip %s erase function "
1232 "%i region %i has count 0. Please report"
1233 " a bug at flashrom@flashrom.org\n",
1234 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001235 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001236 }
1237 done += eraser.eraseblocks[i].count *
1238 eraser.eraseblocks[i].size;
1239 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001240 /* Empty eraseblock definition with erase function. */
1241 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001242 msg_gspew("Strange: Empty eraseblock definition with "
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001243 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001244 if (!done)
1245 continue;
1246 if (done != flash->total_size * 1024) {
1247 msg_gerr("ERROR: Flash chip %s erase function %i "
1248 "region walking resulted in 0x%06x bytes total,"
1249 " expected 0x%06x bytes. Please report a bug at"
1250 " flashrom@flashrom.org\n", flash->name, k,
1251 done, flash->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001252 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001253 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001254 if (!eraser.block_erase)
1255 continue;
1256 /* Check if there are identical erase functions for different
1257 * layouts. That would imply "magic" erase functions. The
1258 * easiest way to check this is with function pointers.
1259 */
Uwe Hermann43959702010-03-13 17:28:29 +00001260 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001261 if (eraser.block_erase ==
1262 flash->block_erasers[j].block_erase) {
1263 msg_gerr("ERROR: Flash chip %s erase function "
1264 "%i and %i are identical. Please report"
1265 " a bug at flashrom@flashrom.org\n",
1266 flash->name, k, j);
1267 ret = 1;
1268 }
Uwe Hermann43959702010-03-13 17:28:29 +00001269 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001270 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001271 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001272}
1273
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001274static int walk_eraseregions(struct flashchip *flash, int erasefunction,
1275 int (*do_something) (struct flashchip *flash,
1276 unsigned int addr,
1277 unsigned int len))
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001278{
1279 int i, j;
1280 unsigned int start = 0;
1281 unsigned int len;
1282 struct block_eraser eraser = flash->block_erasers[erasefunction];
1283 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1284 /* count==0 for all automatically initialized array
1285 * members so the loop below won't be executed for them.
1286 */
1287 len = eraser.eraseblocks[i].size;
1288 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
1289 msg_cdbg("0x%06x-0x%06x, ", start,
1290 start + len - 1);
1291 if (do_something(flash, start, len))
1292 return 1;
1293 start += len;
1294 }
1295 }
1296 return 0;
1297}
1298
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001299int erase_flash(struct flashchip *flash)
1300{
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001301 int k, ret = 0, found = 0;
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001302
Sean Nelson316a29f2010-05-07 20:09:04 +00001303 msg_cinfo("Erasing flash chip... ");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001304 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001305 struct block_eraser eraser = flash->block_erasers[k];
1306
Sean Nelson316a29f2010-05-07 20:09:04 +00001307 msg_cdbg("Looking at blockwise erase function %i... ", k);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001308 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001309 msg_cdbg("not defined. "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001310 "Looking for another erase function.\n");
1311 continue;
1312 }
1313 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001314 msg_cdbg("eraseblock layout is known, but no "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001315 "matching block erase function found. "
1316 "Looking for another erase function.\n");
1317 continue;
1318 }
1319 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001320 msg_cdbg("block erase function found, but "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001321 "eraseblock layout is unknown. "
1322 "Looking for another erase function.\n");
1323 continue;
1324 }
1325 found = 1;
Sean Nelson316a29f2010-05-07 20:09:04 +00001326 msg_cdbg("trying... ");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001327 ret = walk_eraseregions(flash, k, eraser.block_erase);
Sean Nelson316a29f2010-05-07 20:09:04 +00001328 msg_cdbg("\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001329 /* If everything is OK, don't try another erase function. */
1330 if (!ret)
1331 break;
1332 }
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001333 if (!found) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001334 msg_cerr("ERROR: flashrom has no erase function for this flash chip.\n");
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001335 return 1;
1336 }
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001337
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001338 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001339 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001340 } else {
Sean Nelson316a29f2010-05-07 20:09:04 +00001341 msg_cinfo("SUCCESS.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001342 }
1343 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001344}
1345
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001346void nonfatal_help_message(void)
1347{
1348 msg_gerr("Writing to the flash chip apparently didn't do anything.\n"
1349 "This means we have to add special support for your board, "
1350 "programmer or flash chip.\n"
1351 "Please report this on IRC at irc.freenode.net (channel "
1352 "#flashrom) or\n"
1353 "mail flashrom@flashrom.org!\n"
1354 "-------------------------------------------------------------"
1355 "------------------\n"
1356 "You may now reboot or simply leave the machine running.\n");
1357}
1358
Uwe Hermannc67d0372009-10-01 18:40:02 +00001359void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001360{
Sean Nelson316a29f2010-05-07 20:09:04 +00001361 msg_gerr("Your flash chip is in an unknown state.\n"
Uwe Hermannc67d0372009-10-01 18:40:02 +00001362 "Get help on IRC at irc.freenode.net (channel #flashrom) or\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001363 "mail flashrom@flashrom.org with FAILED: your board name in "
1364 "the subject line!\n"
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001365 "-------------------------------------------------------------"
1366 "------------------\n"
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001367 "DO NOT REBOOT OR POWEROFF!\n");
1368}
1369
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001370/* The way to go if you want a delimited list of programmers*/
1371void list_programmers(char *delim)
1372{
1373 enum programmer p;
1374 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001375 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001376 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001377 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001378 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001379 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001380}
1381
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001382void list_programmers_linebreak(int startcol, int cols, int paren)
1383{
1384 const char *pname;
1385 int pnamelen;
1386 int remaining = 0;
1387 int firstline = 1;
1388 enum programmer p;
1389 int i;
1390
1391 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1392 pname = programmer_table[p].name;
1393 pnamelen = strlen(pname);
1394 if (remaining - pnamelen - 2 < 0) {
1395 if (firstline)
1396 firstline = 0;
1397 else
1398 printf("\n");
1399 for (i = 0; i < startcol; i++)
1400 printf(" ");
1401 remaining = cols - startcol;
1402 } else {
1403 printf(" ");
1404 remaining--;
1405 }
1406 if (paren && (p == 0)) {
1407 printf("(");
1408 remaining--;
1409 }
1410 printf("%s", pname);
1411 remaining -= pnamelen;
1412 if (p < PROGRAMMER_INVALID - 1) {
1413 printf(",");
1414 remaining--;
1415 } else {
1416 if (paren)
1417 printf(")");
1418 printf("\n");
1419 }
1420 }
1421}
1422
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001423void print_sysinfo(void)
1424{
1425#if HAVE_UTSNAME == 1
1426 struct utsname osinfo;
1427 uname(&osinfo);
1428
1429 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1430 osinfo.machine);
1431#else
1432 msg_ginfo(" on unknown machine");
1433#endif
1434 msg_ginfo(", built with");
1435#if NEED_PCI == 1
1436#ifdef PCILIB_VERSION
1437 msg_ginfo(" libpci %s,", PCILIB_VERSION);
1438#else
1439 msg_ginfo(" unknown PCI library,");
1440#endif
1441#endif
1442#ifdef __clang__
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001443 msg_ginfo(" LLVM Clang");
1444#ifdef __clang_version__
1445 msg_ginfo(" %s,", __clang_version__);
1446#else
1447 msg_ginfo(" unknown version (before r102686),");
1448#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001449#elif defined(__GNUC__)
1450 msg_ginfo(" GCC");
1451#ifdef __VERSION__
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001452 msg_ginfo(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001453#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001454 msg_ginfo(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001455#endif
1456#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001457 msg_ginfo(" unknown compiler,");
1458#endif
1459#if defined (__FLASHROM_LITTLE_ENDIAN__)
1460 msg_ginfo(" little endian");
1461#else
1462 msg_ginfo(" big endian");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001463#endif
1464 msg_ginfo("\n");
1465}
1466
Bernhard Walle201bde32008-01-21 15:24:22 +00001467void print_version(void)
1468{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001469 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001470 print_sysinfo();
Bernhard Walle201bde32008-01-21 15:24:22 +00001471}
1472
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001473void print_banner(void)
1474{
1475 msg_ginfo("flashrom is free software, get the source code at "
1476 "http://www.flashrom.org\n");
1477 msg_ginfo("\n");
1478}
1479
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001480int selfcheck(void)
1481{
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001482 int ret = 0;
1483 struct flashchip *flash;
1484
1485 /* Safety check. Instead of aborting after the first error, check
1486 * if more errors exist.
1487 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001488 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001489 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001490 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001491 }
1492 if (spi_programmer_count - 1 != SPI_CONTROLLER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001493 msg_gerr("SPI programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001494 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001495 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001496 for (flash = flashchips; flash && flash->name; flash++)
1497 if (selfcheck_eraseblocks(flash))
1498 ret = 1;
1499 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001500}
1501
1502void check_chip_supported(struct flashchip *flash)
1503{
1504 if (TEST_OK_MASK != (flash->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001505 msg_cinfo("===\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001506 if (flash->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001507 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001508 if (flash->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001509 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001510 if (flash->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001511 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001512 if (flash->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001513 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001514 if (flash->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001515 msg_cinfo(" WRITE");
1516 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001517 }
1518 if ((!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE)) ||
1519 (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ)) ||
1520 (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE)) ||
1521 (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001522 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001523 if (!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001524 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001525 if (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001526 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001527 if (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001528 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001529 if (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001530 msg_cinfo(" WRITE");
1531 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001532 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001533 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001534 msg_cinfo("The test status of this chip may have been updated "
1535 "in the latest development\n"
1536 "version of flashrom. If you are running the latest "
1537 "development version,\n"
1538 "please email a report to flashrom@flashrom.org if "
1539 "any of the above operations\n"
1540 "work correctly for you with this flash part. Please "
1541 "include the flashrom\n"
1542 "output with the additional -V option for all "
1543 "operations you tested (-V, -Vr,\n"
1544 "-Vw, -VE), and mention which mainboard or "
1545 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001546 "Please mention your board in the subject line. "
1547 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001548 }
1549}
1550
Ollie Lho761bf1b2004-03-20 16:46:10 +00001551int main(int argc, char *argv[])
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001552{
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001553 return cli_classic(argc, argv);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001554}
1555
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001556/* FIXME: This function signature needs to be improved once doit() has a better
1557 * function signature.
1558 */
1559int chip_safety_check(struct flashchip *flash, int force, char *filename, int read_it, int write_it, int erase_it, int verify_it)
1560{
1561 if (!programmer_may_write && (write_it || erase_it)) {
1562 msg_perr("Write/erase is not working yet on your programmer in "
1563 "its current configuration.\n");
1564 /* --force is the wrong approach, but it's the best we can do
1565 * until the generic programmer parameter parser is merged.
1566 */
1567 if (!force)
1568 return 1;
1569 msg_cerr("Continuing anyway.\n");
1570 }
1571
1572 if (read_it || erase_it || write_it || verify_it) {
1573 /* Everything needs read. */
1574 if (flash->tested & TEST_BAD_READ) {
1575 msg_cerr("Read is not working on this chip. ");
1576 if (!force)
1577 return 1;
1578 msg_cerr("Continuing anyway.\n");
1579 }
1580 if (!flash->read) {
1581 msg_cerr("flashrom has no read function for this "
1582 "flash chip.\n");
1583 return 1;
1584 }
1585 }
1586 if (erase_it || write_it) {
1587 /* Write needs erase. */
1588 if (flash->tested & TEST_BAD_ERASE) {
1589 msg_cerr("Erase is not working on this chip. ");
1590 if (!force)
1591 return 1;
1592 msg_cerr("Continuing anyway.\n");
1593 }
1594 /* FIXME: Check if at least one erase function exists. */
1595 }
1596 if (write_it) {
1597 if (flash->tested & TEST_BAD_WRITE) {
1598 msg_cerr("Write is not working on this chip. ");
1599 if (!force)
1600 return 1;
1601 msg_cerr("Continuing anyway.\n");
1602 }
1603 if (!flash->write) {
1604 msg_cerr("flashrom has no write function for this "
1605 "flash chip.\n");
1606 return 1;
1607 }
1608 }
1609 return 0;
1610}
1611
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001612/* This function signature is horrible. We need to design a better interface,
1613 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001614 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001615 */
1616int doit(struct flashchip *flash, int force, char *filename, int read_it, int write_it, int erase_it, int verify_it)
1617{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001618 uint8_t *oldcontents;
1619 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001620 int ret = 0;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001621 unsigned long size = flash->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001622
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001623 if (chip_safety_check(flash, force, filename, read_it, write_it, erase_it, verify_it)) {
1624 msg_cerr("Aborting.\n");
1625 programmer_shutdown();
1626 return 1;
1627 }
1628
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001629 /* Given the existence of read locks, we want to unlock for read,
1630 * erase and write.
1631 */
1632 if (flash->unlock)
1633 flash->unlock(flash);
1634
1635 if (read_it) {
1636 ret = read_flash_to_file(flash, filename);
1637 programmer_shutdown();
1638 return ret;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001639 }
Ollie Lhoefa28582004-12-08 20:10:01 +00001640 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001641 /* FIXME: Do we really want the scary warning if erase failed?
1642 * After all, after erase the chip is either blank or partially
1643 * blank or it has the old contents. A blank chip won't boot,
1644 * so if the user wanted erase and reboots afterwards, the user
1645 * knows very well that booting won't work.
1646 */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001647 if (erase_flash(flash)) {
1648 emergency_help_message();
Uwe Hermann2bc98f62009-09-30 18:29:55 +00001649 programmer_shutdown();
Peter Stugef31104c2008-04-28 14:47:30 +00001650 return 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001651 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001652 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001653
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001654 newcontents = (uint8_t *) calloc(size, sizeof(char));
1655
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001656 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001657 if (read_buf_from_file(newcontents, size, filename)) {
Uwe Hermann2bc98f62009-09-30 18:29:55 +00001658 programmer_shutdown();
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001659 return 1;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001660 }
1661
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001662#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001663 if (programmer == PROGRAMMER_INTERNAL)
1664 show_id(newcontents, size, force);
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001665#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001666 }
1667
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001668 oldcontents = (uint8_t *) calloc(size, sizeof(char));
1669
1670 /* Read the whole chip to be able to check whether regions need to be
1671 * erased and to give better diagnostics in case write fails.
1672 * The alternative would be to read only the regions which are to be
1673 * preserved, but in that case we might perform unneeded erase which
1674 * takes time as well.
1675 */
1676 msg_cdbg("Reading old flash chip contents...\n");
1677 if (flash->read(flash, oldcontents, 0, size)) {
1678 programmer_shutdown();
1679 return 1;
1680 }
1681
Ollie Lho184a4042005-11-26 21:55:36 +00001682 // This should be moved into each flash part's code to do it
1683 // cleanly. This does the job.
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001684 handle_romentries(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001685
Ollie Lho184a4042005-11-26 21:55:36 +00001686 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00001687
Peter Stugef31104c2008-04-28 14:47:30 +00001688 if (write_it) {
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001689 if (erase_flash(flash)) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001690 msg_cerr("Uh oh. Erase failed. Checking if anything "
1691 "changed.\n");
1692 if (!flash->read(flash, newcontents, 0, size)) {
1693 if (!memcmp(oldcontents, newcontents, size)) {
1694 msg_cinfo("Good. It seems nothing was "
1695 "changed.\n");
1696 nonfatal_help_message();
1697 programmer_shutdown();
1698 return 1;
1699 }
1700 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001701 emergency_help_message();
Uwe Hermann2bc98f62009-09-30 18:29:55 +00001702 programmer_shutdown();
Peter Stugef31104c2008-04-28 14:47:30 +00001703 return 1;
1704 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001705 msg_cinfo("Writing flash chip... ");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001706 ret = flash->write(flash, newcontents, 0, size);
Carl-Daniel Hailfinger0a3e5ae2009-07-24 12:18:54 +00001707 if (ret) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001708 msg_cerr("Uh oh. Write failed. Checking if anything "
1709 "changed.\n");
1710 if (!flash->read(flash, newcontents, 0, size)) {
1711 if (!memcmp(oldcontents, newcontents, size)) {
1712 msg_cinfo("Good. It seems nothing was "
1713 "changed.\n");
1714 nonfatal_help_message();
1715 programmer_shutdown();
1716 return 1;
1717 }
1718 }
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001719 emergency_help_message();
Uwe Hermann2bc98f62009-09-30 18:29:55 +00001720 programmer_shutdown();
Carl-Daniel Hailfinger0a3e5ae2009-07-24 12:18:54 +00001721 return 1;
1722 } else {
Sean Nelson316a29f2010-05-07 20:09:04 +00001723 msg_cinfo("COMPLETE.\n");
Carl-Daniel Hailfinger0a3e5ae2009-07-24 12:18:54 +00001724 }
Peter Stugef31104c2008-04-28 14:47:30 +00001725 }
Ollie Lho184a4042005-11-26 21:55:36 +00001726
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001727 if (verify_it) {
1728 /* Work around chips which need some time to calm down. */
1729 if (write_it)
1730 programmer_delay(1000*1000);
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001731 ret = verify_flash(flash, newcontents);
Carl-Daniel Hailfingerf5292052009-11-17 09:57:34 +00001732 /* If we tried to write, and verification now fails, we
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001733 * might have an emergency situation.
1734 */
1735 if (ret && write_it)
1736 emergency_help_message();
1737 }
Ollie Lho184a4042005-11-26 21:55:36 +00001738
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00001739 programmer_shutdown();
1740
Stefan Reinauer143da0b2006-01-04 16:42:57 +00001741 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001742}