blob: 629cce29d38de159e2578f6d9601bea4b2343d7c [file] [log] [blame]
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001/*
Uwe Hermannd1107642007-08-29 17:52:32 +00002 * This file is part of the flashrom project.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00003 *
Uwe Hermannd22a1d42007-09-09 20:21:05 +00004 * Copyright (C) 2000 Silicon Integrated System Corporation
5 * Copyright (C) 2004 Tyan Corp <yhlu@tyan.com>
Uwe Hermannc7e8a0c2009-05-19 14:14:21 +00006 * Copyright (C) 2005-2008 coresystems GmbH
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00007 * Copyright (C) 2008,2009 Carl-Daniel Hailfinger
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00008 *
Uwe Hermannd1107642007-08-29 17:52:32 +00009 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000013 *
Uwe Hermannd1107642007-08-29 17:52:32 +000014 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000018 *
Uwe Hermannd1107642007-08-29 17:52:32 +000019 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000022 */
23
Carl-Daniel Hailfinger831e8f42010-05-30 22:24:40 +000024#include <stdio.h>
Stefan Reinauer018aca82006-11-21 23:48:51 +000025#include <sys/types.h>
Patrick Georgia9095a92010-09-30 17:03:32 +000026#ifndef __LIBPAYLOAD__
27#include <fcntl.h>
Stefan Reinauer018aca82006-11-21 23:48:51 +000028#include <sys/stat.h>
Patrick Georgia9095a92010-09-30 17:03:32 +000029#endif
Ronald G. Minnichceec4202003-07-25 04:37:41 +000030#include <string.h>
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +000031#include <stdlib.h>
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +000032#include <ctype.h>
Ollie Lho184a4042005-11-26 21:55:36 +000033#include <getopt.h>
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +000034#if HAVE_UTSNAME == 1
35#include <sys/utsname.h>
36#endif
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000037#include "flash.h"
Carl-Daniel Hailfinger08454642009-06-15 14:14:48 +000038#include "flashchips.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000039#include "programmer.h"
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +000040
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000041const char * const flashrom_version = FLASHROM_VERSION;
Ronald G. Minnichceec4202003-07-25 04:37:41 +000042char *chip_to_probe = NULL;
Peter Stuge7ffbc6f2008-06-18 02:08:40 +000043int verbose = 0;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000044
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000045#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +000046enum programmer programmer = PROGRAMMER_INTERNAL;
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000047#elif CONFIG_DUMMY == 1
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000048enum programmer programmer = PROGRAMMER_DUMMY;
49#else
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000050/* If neither internal nor dummy are selected, we must pick a sensible default.
51 * Since there is no reason to prefer a particular external programmer, we fail
52 * if more than one of them is selected. If only one is selected, it is clear
53 * that the user wants that one to become the default.
54 */
Idwer Vollering004f4b72010-09-03 18:21:21 +000055#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 +000056#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 +000057#endif
58enum programmer programmer =
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000059#if CONFIG_NIC3COM == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000060 PROGRAMMER_NIC3COM
61#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000062#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +000063 PROGRAMMER_NICREALTEK
64 PROGRAMMER_NICREALTEK2
65#endif
Andrew Morganc29c2e72010-06-07 22:37:54 +000066#if CONFIG_NICNATSEMI == 1
67 PROGRAMMER_NICNATSEMI
68#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000069#if CONFIG_GFXNVIDIA == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000070 PROGRAMMER_GFXNVIDIA
71#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000072#if CONFIG_DRKAISER == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000073 PROGRAMMER_DRKAISER
74#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000075#if CONFIG_SATASII == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000076 PROGRAMMER_SATASII
77#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000078#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +000079 PROGRAMMER_ATAHPT
80#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000081#if CONFIG_FT2232_SPI == 1
82 PROGRAMMER_FT2232_SPI
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000083#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000084#if CONFIG_SERPROG == 1
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000085 PROGRAMMER_SERPROG
86#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000087#if CONFIG_BUSPIRATE_SPI == 1
88 PROGRAMMER_BUSPIRATE_SPI
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000089#endif
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000090#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000091 PROGRAMMER_DEDIPROG
92#endif
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +000093#if CONFIG_RAYER_SPI == 1
94 PROGRAMMER_RAYER_SPI
95#endif
Idwer Vollering004f4b72010-09-03 18:21:21 +000096#if CONFIG_NICINTEL_SPI == 1
97 PROGRAMMER_NICINTEL_SPI
98#endif
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +000099;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000100#endif
101
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000102static char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +0000103
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000104/* Supported buses for the current programmer. */
105enum chipbustype buses_supported;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000106
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000107/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000108 * Programmers supporting multiple buses can have differing size limits on
109 * each bus. Store the limits for each bus in a common struct.
110 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000111struct decode_sizes max_rom_decode;
112
113/* If nonzero, used as the start address of bottom-aligned flash. */
114unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000115
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000116/* Is writing allowed with this programmer? */
117int programmer_may_write;
118
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000119const struct programmer_entry programmer_table[] = {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000120#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000121 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000122 .name = "internal",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000123 .init = internal_init,
124 .shutdown = internal_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000125 .map_flash_region = physmap,
126 .unmap_flash_region = physunmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000127 .chip_readb = internal_chip_readb,
128 .chip_readw = internal_chip_readw,
129 .chip_readl = internal_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000130 .chip_readn = internal_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000131 .chip_writeb = internal_chip_writeb,
132 .chip_writew = internal_chip_writew,
133 .chip_writel = internal_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000134 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000135 .delay = internal_delay,
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000136 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000137#endif
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000138
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000139#if CONFIG_DUMMY == 1
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000140 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000141 .name = "dummy",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000142 .init = dummy_init,
143 .shutdown = dummy_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000144 .map_flash_region = dummy_map,
145 .unmap_flash_region = dummy_unmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000146 .chip_readb = dummy_chip_readb,
147 .chip_readw = dummy_chip_readw,
148 .chip_readl = dummy_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000149 .chip_readn = dummy_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000150 .chip_writeb = dummy_chip_writeb,
151 .chip_writew = dummy_chip_writew,
152 .chip_writel = dummy_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000153 .chip_writen = dummy_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000154 .delay = internal_delay,
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000155 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000156#endif
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000157
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000158#if CONFIG_NIC3COM == 1
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000159 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000160 .name = "nic3com",
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000161 .init = nic3com_init,
162 .shutdown = nic3com_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000163 .map_flash_region = fallback_map,
164 .unmap_flash_region = fallback_unmap,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000165 .chip_readb = nic3com_chip_readb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000166 .chip_readw = fallback_chip_readw,
167 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000168 .chip_readn = fallback_chip_readn,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000169 .chip_writeb = nic3com_chip_writeb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000170 .chip_writew = fallback_chip_writew,
171 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000172 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000173 .delay = internal_delay,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000174 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000175#endif
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000176
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000177#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +0000178 {
179 .name = "nicrealtek",
180 .init = nicrealtek_init,
181 .shutdown = nicrealtek_shutdown,
182 .map_flash_region = fallback_map,
183 .unmap_flash_region = fallback_unmap,
184 .chip_readb = nicrealtek_chip_readb,
185 .chip_readw = fallback_chip_readw,
186 .chip_readl = fallback_chip_readl,
187 .chip_readn = fallback_chip_readn,
188 .chip_writeb = nicrealtek_chip_writeb,
189 .chip_writew = fallback_chip_writew,
190 .chip_writel = fallback_chip_writel,
191 .chip_writen = fallback_chip_writen,
192 .delay = internal_delay,
193 },
194 {
195 .name = "nicsmc1211",
196 .init = nicsmc1211_init,
197 .shutdown = nicrealtek_shutdown,
198 .map_flash_region = fallback_map,
199 .unmap_flash_region = fallback_unmap,
200 .chip_readb = nicrealtek_chip_readb,
201 .chip_readw = fallback_chip_readw,
202 .chip_readl = fallback_chip_readl,
203 .chip_readn = fallback_chip_readn,
204 .chip_writeb = nicrealtek_chip_writeb,
205 .chip_writew = fallback_chip_writew,
206 .chip_writel = fallback_chip_writel,
207 .chip_writen = fallback_chip_writen,
208 .delay = internal_delay,
209 },
210#endif
211
Andrew Morganc29c2e72010-06-07 22:37:54 +0000212#if CONFIG_NICNATSEMI == 1
213 {
214 .name = "nicnatsemi",
215 .init = nicnatsemi_init,
216 .shutdown = nicnatsemi_shutdown,
217 .map_flash_region = fallback_map,
218 .unmap_flash_region = fallback_unmap,
219 .chip_readb = nicnatsemi_chip_readb,
220 .chip_readw = fallback_chip_readw,
221 .chip_readl = fallback_chip_readl,
222 .chip_readn = fallback_chip_readn,
223 .chip_writeb = nicnatsemi_chip_writeb,
224 .chip_writew = fallback_chip_writew,
225 .chip_writel = fallback_chip_writel,
226 .chip_writen = fallback_chip_writen,
227 .delay = internal_delay,
228 },
229#endif
Joerg Fischer5665ef32010-05-21 21:54:07 +0000230
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000231#if CONFIG_GFXNVIDIA == 1
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000232 {
233 .name = "gfxnvidia",
234 .init = gfxnvidia_init,
235 .shutdown = gfxnvidia_shutdown,
236 .map_flash_region = fallback_map,
237 .unmap_flash_region = fallback_unmap,
238 .chip_readb = gfxnvidia_chip_readb,
239 .chip_readw = fallback_chip_readw,
240 .chip_readl = fallback_chip_readl,
241 .chip_readn = fallback_chip_readn,
242 .chip_writeb = gfxnvidia_chip_writeb,
243 .chip_writew = fallback_chip_writew,
244 .chip_writel = fallback_chip_writel,
245 .chip_writen = fallback_chip_writen,
246 .delay = internal_delay,
247 },
248#endif
249
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000250#if CONFIG_DRKAISER == 1
Rudolf Marek68720c72009-05-17 19:39:27 +0000251 {
TURBO Jb0912c02009-09-02 23:00:46 +0000252 .name = "drkaiser",
253 .init = drkaiser_init,
254 .shutdown = drkaiser_shutdown,
255 .map_flash_region = fallback_map,
256 .unmap_flash_region = fallback_unmap,
257 .chip_readb = drkaiser_chip_readb,
258 .chip_readw = fallback_chip_readw,
259 .chip_readl = fallback_chip_readl,
260 .chip_readn = fallback_chip_readn,
261 .chip_writeb = drkaiser_chip_writeb,
262 .chip_writew = fallback_chip_writew,
263 .chip_writel = fallback_chip_writel,
264 .chip_writen = fallback_chip_writen,
265 .delay = internal_delay,
266 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000267#endif
TURBO Jb0912c02009-09-02 23:00:46 +0000268
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000269#if CONFIG_SATASII == 1
TURBO Jb0912c02009-09-02 23:00:46 +0000270 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000271 .name = "satasii",
Rudolf Marek68720c72009-05-17 19:39:27 +0000272 .init = satasii_init,
273 .shutdown = satasii_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000274 .map_flash_region = fallback_map,
275 .unmap_flash_region = fallback_unmap,
Rudolf Marek68720c72009-05-17 19:39:27 +0000276 .chip_readb = satasii_chip_readb,
277 .chip_readw = fallback_chip_readw,
278 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000279 .chip_readn = fallback_chip_readn,
Rudolf Marek68720c72009-05-17 19:39:27 +0000280 .chip_writeb = satasii_chip_writeb,
281 .chip_writew = fallback_chip_writew,
282 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000283 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000284 .delay = internal_delay,
Rudolf Marek68720c72009-05-17 19:39:27 +0000285 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000286#endif
Rudolf Marek68720c72009-05-17 19:39:27 +0000287
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000288#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000289 {
290 .name = "atahpt",
291 .init = atahpt_init,
292 .shutdown = atahpt_shutdown,
293 .map_flash_region = fallback_map,
294 .unmap_flash_region = fallback_unmap,
295 .chip_readb = atahpt_chip_readb,
296 .chip_readw = fallback_chip_readw,
297 .chip_readl = fallback_chip_readl,
298 .chip_readn = fallback_chip_readn,
299 .chip_writeb = atahpt_chip_writeb,
300 .chip_writew = fallback_chip_writew,
301 .chip_writel = fallback_chip_writel,
302 .chip_writen = fallback_chip_writen,
303 .delay = internal_delay,
304 },
305#endif
306
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000307#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000308#if defined(__i386__) || defined(__x86_64__)
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000309 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000310 .name = "it87spi",
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000311 .init = it87spi_init,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000312 .shutdown = noop_shutdown,
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000313 .map_flash_region = fallback_map,
314 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000315 .chip_readb = noop_chip_readb,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000316 .chip_readw = fallback_chip_readw,
317 .chip_readl = fallback_chip_readl,
318 .chip_readn = fallback_chip_readn,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000319 .chip_writeb = noop_chip_writeb,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000320 .chip_writew = fallback_chip_writew,
321 .chip_writel = fallback_chip_writel,
322 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000323 .delay = internal_delay,
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000324 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000325#endif
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000326#endif
Carl-Daniel Hailfingerb8afecd2009-05-31 18:00:57 +0000327
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000328#if CONFIG_FT2232_SPI == 1
Paul Fox05dfbe62009-06-16 21:08:06 +0000329 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000330 .name = "ft2232_spi",
Paul Fox05dfbe62009-06-16 21:08:06 +0000331 .init = ft2232_spi_init,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000332 .shutdown = noop_shutdown, /* Missing shutdown */
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000333 .map_flash_region = fallback_map,
334 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000335 .chip_readb = noop_chip_readb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000336 .chip_readw = fallback_chip_readw,
337 .chip_readl = fallback_chip_readl,
338 .chip_readn = fallback_chip_readn,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000339 .chip_writeb = noop_chip_writeb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000340 .chip_writew = fallback_chip_writew,
341 .chip_writel = fallback_chip_writel,
342 .chip_writen = fallback_chip_writen,
343 .delay = internal_delay,
344 },
Carl-Daniel Hailfinger3426ef62009-08-19 13:27:58 +0000345#endif
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000346
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000347#if CONFIG_SERPROG == 1
Urja Rannikko22915352009-06-23 11:33:43 +0000348 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000349 .name = "serprog",
Urja Rannikko22915352009-06-23 11:33:43 +0000350 .init = serprog_init,
351 .shutdown = serprog_shutdown,
352 .map_flash_region = fallback_map,
353 .unmap_flash_region = fallback_unmap,
354 .chip_readb = serprog_chip_readb,
355 .chip_readw = fallback_chip_readw,
356 .chip_readl = fallback_chip_readl,
357 .chip_readn = serprog_chip_readn,
358 .chip_writeb = serprog_chip_writeb,
359 .chip_writew = fallback_chip_writew,
360 .chip_writel = fallback_chip_writel,
361 .chip_writen = fallback_chip_writen,
362 .delay = serprog_delay,
363 },
Carl-Daniel Hailfinger6be74112009-08-12 16:17:41 +0000364#endif
Paul Fox05dfbe62009-06-16 21:08:06 +0000365
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000366#if CONFIG_BUSPIRATE_SPI == 1
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000367 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000368 .name = "buspirate_spi",
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000369 .init = buspirate_spi_init,
370 .shutdown = buspirate_spi_shutdown,
371 .map_flash_region = fallback_map,
372 .unmap_flash_region = fallback_unmap,
373 .chip_readb = noop_chip_readb,
374 .chip_readw = fallback_chip_readw,
375 .chip_readl = fallback_chip_readl,
376 .chip_readn = fallback_chip_readn,
377 .chip_writeb = noop_chip_writeb,
378 .chip_writew = fallback_chip_writew,
379 .chip_writel = fallback_chip_writel,
380 .chip_writen = fallback_chip_writen,
381 .delay = internal_delay,
382 },
383#endif
384
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000385#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000386 {
387 .name = "dediprog",
388 .init = dediprog_init,
389 .shutdown = dediprog_shutdown,
390 .map_flash_region = fallback_map,
391 .unmap_flash_region = fallback_unmap,
392 .chip_readb = noop_chip_readb,
393 .chip_readw = fallback_chip_readw,
394 .chip_readl = fallback_chip_readl,
395 .chip_readn = fallback_chip_readn,
396 .chip_writeb = noop_chip_writeb,
397 .chip_writew = fallback_chip_writew,
398 .chip_writel = fallback_chip_writel,
399 .chip_writen = fallback_chip_writen,
400 .delay = internal_delay,
401 },
402#endif
403
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000404#if CONFIG_RAYER_SPI == 1
405 {
406 .name = "rayer_spi",
407 .init = rayer_spi_init,
408 .shutdown = noop_shutdown,
409 .map_flash_region = fallback_map,
410 .unmap_flash_region = fallback_unmap,
411 .chip_readb = noop_chip_readb,
412 .chip_readw = fallback_chip_readw,
413 .chip_readl = fallback_chip_readl,
414 .chip_readn = fallback_chip_readn,
415 .chip_writeb = noop_chip_writeb,
416 .chip_writew = fallback_chip_writew,
417 .chip_writel = fallback_chip_writel,
418 .chip_writen = fallback_chip_writen,
419 .delay = internal_delay,
420 },
421#endif
422
Idwer Vollering004f4b72010-09-03 18:21:21 +0000423#if CONFIG_NICINTEL_SPI == 1
424 {
425 .name = "nicintel_spi",
426 .init = nicintel_spi_init,
427 .shutdown = nicintel_spi_shutdown,
428 .map_flash_region = fallback_map,
429 .unmap_flash_region = fallback_unmap,
430 .chip_readb = noop_chip_readb,
431 .chip_readw = fallback_chip_readw,
432 .chip_readl = fallback_chip_readl,
433 .chip_readn = fallback_chip_readn,
434 .chip_writeb = noop_chip_writeb,
435 .chip_writew = fallback_chip_writew,
436 .chip_writel = fallback_chip_writel,
437 .chip_writen = fallback_chip_writen,
438 .delay = internal_delay,
439 },
440#endif
441
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000442 {}, /* This entry corresponds to PROGRAMMER_INVALID. */
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000443};
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000444
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000445#define SHUTDOWN_MAXFN 32
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000446static int shutdown_fn_count = 0;
447struct shutdown_func_data {
448 void (*func) (void *data);
449 void *data;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000450} static shutdown_fn[SHUTDOWN_MAXFN];
451/* Initialize to 0 to make sure nobody registers a shutdown function before
452 * programmer init.
453 */
454static int may_register_shutdown = 0;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000455
456/* Register a function to be executed on programmer shutdown.
457 * The advantage over atexit() is that you can supply a void pointer which will
458 * be used as parameter to the registered function upon programmer shutdown.
459 * This pointer can point to arbitrary data used by said function, e.g. undo
460 * information for GPIO settings etc. If unneeded, set data=NULL.
461 * Please note that the first (void *data) belongs to the function signature of
462 * the function passed as first parameter.
463 */
464int register_shutdown(void (*function) (void *data), void *data)
465{
466 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000467 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000468 SHUTDOWN_MAXFN);
469 return 1;
470 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000471 if (!may_register_shutdown) {
472 msg_perr("Tried to register a shutdown function before "
473 "programmer init.\n");
474 return 1;
475 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000476 shutdown_fn[shutdown_fn_count].func = function;
477 shutdown_fn[shutdown_fn_count].data = data;
478 shutdown_fn_count++;
479
480 return 0;
481}
482
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000483int programmer_init(char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000484{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000485 int ret;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000486 /* Initialize all programmer specific data. */
487 /* Default to unlimited decode sizes. */
488 max_rom_decode = (const struct decode_sizes) {
489 .parallel = 0xffffffff,
490 .lpc = 0xffffffff,
491 .fwh = 0xffffffff,
492 .spi = 0xffffffff
493 };
494 /* Default to Parallel/LPC/FWH flash devices. If a known host controller
495 * is found, the init routine sets the buses_supported bitfield.
496 */
497 buses_supported = CHIP_BUSTYPE_NONSPI;
498 /* Default to top aligned flash at 4 GB. */
499 flashbase = 0;
500 /* Registering shutdown functions is now allowed. */
501 may_register_shutdown = 1;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000502 /* Default to allowing writes. Broken programmers set this to 0. */
503 programmer_may_write = 1;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000504
505 programmer_param = param;
506 msg_pdbg("Initializing %s programmer\n",
507 programmer_table[programmer].name);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000508 ret = programmer_table[programmer].init();
509 if (programmer_param && strlen(programmer_param)) {
510 msg_perr("Unhandled programmer parameters: %s\n",
511 programmer_param);
512 /* Do not error out here, the init itself was successful. */
513 }
514 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000515}
516
517int programmer_shutdown(void)
518{
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000519 /* Registering shutdown functions is no longer allowed. */
520 may_register_shutdown = 0;
521 while (shutdown_fn_count > 0) {
522 int i = --shutdown_fn_count;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000523 shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000524 }
Uwe Hermann09e04f72009-05-16 22:36:00 +0000525 return programmer_table[programmer].shutdown();
526}
527
528void *programmer_map_flash_region(const char *descr, unsigned long phys_addr,
529 size_t len)
530{
531 return programmer_table[programmer].map_flash_region(descr,
532 phys_addr, len);
533}
534
535void programmer_unmap_flash_region(void *virt_addr, size_t len)
536{
537 programmer_table[programmer].unmap_flash_region(virt_addr, len);
538}
539
540void chip_writeb(uint8_t val, chipaddr addr)
541{
542 programmer_table[programmer].chip_writeb(val, addr);
543}
544
545void chip_writew(uint16_t val, chipaddr addr)
546{
547 programmer_table[programmer].chip_writew(val, addr);
548}
549
550void chip_writel(uint32_t val, chipaddr addr)
551{
552 programmer_table[programmer].chip_writel(val, addr);
553}
554
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000555void chip_writen(uint8_t *buf, chipaddr addr, size_t len)
556{
557 programmer_table[programmer].chip_writen(buf, addr, len);
558}
559
Uwe Hermann09e04f72009-05-16 22:36:00 +0000560uint8_t chip_readb(const chipaddr addr)
561{
562 return programmer_table[programmer].chip_readb(addr);
563}
564
565uint16_t chip_readw(const chipaddr addr)
566{
567 return programmer_table[programmer].chip_readw(addr);
568}
569
570uint32_t chip_readl(const chipaddr addr)
571{
572 return programmer_table[programmer].chip_readl(addr);
573}
574
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000575void chip_readn(uint8_t *buf, chipaddr addr, size_t len)
576{
577 programmer_table[programmer].chip_readn(buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000578}
579
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000580void programmer_delay(int usecs)
581{
582 programmer_table[programmer].delay(usecs);
583}
584
Peter Stuge776d2022009-01-26 00:39:57 +0000585void map_flash_registers(struct flashchip *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000586{
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000587 size_t size = flash->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000588 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000589 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000590 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000591}
592
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000593int read_memmapped(struct flashchip *flash, uint8_t *buf, int start, int len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000594{
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000595 chip_readn(buf, flash->virtual_memory + start, len);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000596
597 return 0;
598}
599
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000600int min(int a, int b)
601{
602 return (a < b) ? a : b;
603}
604
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000605int max(int a, int b)
606{
607 return (a > b) ? a : b;
608}
609
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000610int bitcount(unsigned long a)
611{
612 int i = 0;
613 for (; a != 0; a >>= 1)
614 if (a & 1)
615 i++;
616 return i;
617}
618
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000619void tolower_string(char *str)
620{
621 for (; *str != '\0'; str++)
622 *str = (char)tolower((unsigned char)*str);
623}
624
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000625char *strcat_realloc(char *dest, const char *src)
626{
627 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000628 if (!dest) {
629 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000630 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000631 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000632 strcat(dest, src);
633 return dest;
634}
635
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000636/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000637 * It will look for needle with a subsequent '=' in haystack, return a copy of
638 * needle and remove everything from the first occurrence of needle to the next
639 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000640 */
641char *extract_param(char **haystack, char *needle, char *delim)
642{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000643 char *param_pos, *opt_pos, *rest;
644 char *opt = NULL;
645 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000646 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000647
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000648 needlelen = strlen(needle);
649 if (!needlelen) {
650 msg_gerr("%s: empty needle! Please report a bug at "
651 "flashrom@flashrom.org\n", __func__);
652 return NULL;
653 }
654 /* No programmer parameters given. */
655 if (*haystack == NULL)
656 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000657 param_pos = strstr(*haystack, needle);
658 do {
659 if (!param_pos)
660 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000661 /* Needle followed by '='? */
662 if (param_pos[needlelen] == '=') {
663
664 /* Beginning of the string? */
665 if (param_pos == *haystack)
666 break;
667 /* After a delimiter? */
668 if (strchr(delim, *(param_pos - 1)))
669 break;
670 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000671 /* Continue searching. */
672 param_pos++;
673 param_pos = strstr(param_pos, needle);
674 } while (1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000675
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000676 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000677 /* Get the string after needle and '='. */
678 opt_pos = param_pos + needlelen + 1;
679 optlen = strcspn(opt_pos, delim);
680 /* Return an empty string if the parameter was empty. */
681 opt = malloc(optlen + 1);
682 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000683 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000684 exit(1);
685 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000686 strncpy(opt, opt_pos, optlen);
687 opt[optlen] = '\0';
688 rest = opt_pos + optlen;
689 /* Skip all delimiters after the current parameter. */
690 rest += strspn(rest, delim);
691 memmove(param_pos, rest, strlen(rest) + 1);
692 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000693 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000694
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000695 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000696}
697
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000698char *extract_programmer_param(char *param_name)
699{
700 return extract_param(&programmer_param, param_name, ",");
701}
702
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000703/* start is an offset to the base address of the flash chip */
704int check_erased_range(struct flashchip *flash, int start, int len)
705{
706 int ret;
707 uint8_t *cmpbuf = malloc(len);
708
709 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000710 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000711 exit(1);
712 }
713 memset(cmpbuf, 0xff, len);
714 ret = verify_range(flash, cmpbuf, start, len, "ERASE");
715 free(cmpbuf);
716 return ret;
717}
718
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000719/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000720 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
721 flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000722 * @start offset to the base address of the flash chip
723 * @len length of the verified area
724 * @message string to print in the "FAILED" message
725 * @return 0 for success, -1 for failure
726 */
727int verify_range(struct flashchip *flash, uint8_t *cmpbuf, int start, int len, char *message)
728{
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000729 int i, ret = 0;
730 uint8_t *readbuf = malloc(len);
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000731 int failcount = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000732
733 if (!len)
734 goto out_free;
735
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000736 if (!flash->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000737 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000738 return 1;
739 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000740 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000741 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000742 exit(1);
743 }
744
745 if (start + len > flash->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000746 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000747 " total_size 0x%x\n", __func__, start, len,
748 flash->total_size * 1024);
749 ret = -1;
750 goto out_free;
751 }
752 if (!message)
753 message = "VERIFY";
754
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000755 ret = flash->read(flash, readbuf, start, len);
756 if (ret) {
757 msg_gerr("Verification impossible because read failed "
758 "at 0x%x (len 0x%x)\n", start, len);
759 return ret;
760 }
761
762 for (i = 0; i < len; i++) {
763 if (cmpbuf[i] != readbuf[i]) {
764 /* Only print the first failure. */
765 if (!failcount++)
766 msg_cerr("%s FAILED at 0x%08x! "
767 "Expected=0x%02x, Read=0x%02x,",
768 message, start + i, cmpbuf[i],
769 readbuf[i]);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000770 }
771 }
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000772 if (failcount) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000773 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000774 start, start + len - 1, failcount);
775 ret = -1;
776 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000777
778out_free:
779 free(readbuf);
780 return ret;
781}
782
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000783/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000784 * Check if the buffer @have can be programmed to the content of @want without
785 * erasing. This is only possible if all chunks of size @gran are either kept
786 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000787 *
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000788 * The following write granularities (enum @gran) are known:
789 * - 1 bit. Each bit can be cleared individually.
790 * - 1 byte. A byte can be written once. Further writes to an already written
791 * byte cause the contents to be either undefined or to stay unchanged.
792 * - 128 bytes. If less than 128 bytes are written, the rest will be
793 * erased. Each write to a 128-byte region will trigger an automatic erase
794 * before anything is written. Very uncommon behaviour and unsupported by
795 * this function.
796 * - 256 bytes. If less than 256 bytes are written, the contents of the
797 * unwritten bytes are undefined.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000798 * Warning: This function assumes that @have and @want point to naturally
799 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000800 *
801 * @have buffer with current content
802 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000803 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000804 * @gran write granularity (enum, not count)
805 * @return 0 if no erase is needed, 1 otherwise
806 */
807int need_erase(uint8_t *have, uint8_t *want, int len, enum write_granularity gran)
808{
809 int result = 0;
810 int i, j, limit;
811
812 switch (gran) {
813 case write_gran_1bit:
814 for (i = 0; i < len; i++)
815 if ((have[i] & want[i]) != want[i]) {
816 result = 1;
817 break;
818 }
819 break;
820 case write_gran_1byte:
821 for (i = 0; i < len; i++)
822 if ((have[i] != want[i]) && (have[i] != 0xff)) {
823 result = 1;
824 break;
825 }
826 break;
827 case write_gran_256bytes:
828 for (j = 0; j < len / 256; j++) {
829 limit = min (256, len - j * 256);
Uwe Hermann43959702010-03-13 17:28:29 +0000830 /* Are 'have' and 'want' identical? */
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000831 if (!memcmp(have + j * 256, want + j * 256, limit))
832 continue;
833 /* have needs to be in erased state. */
834 for (i = 0; i < limit; i++)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000835 if (have[j * 256 + i] != 0xff) {
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000836 result = 1;
837 break;
838 }
839 if (result)
840 break;
841 }
842 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000843 default:
844 msg_cerr("%s: Unsupported granularity! Please report a bug at "
845 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000846 }
847 return result;
848}
849
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000850/**
851 * Check if the buffer @have needs to be programmed to get the content of @want.
852 * If yes, return 1 and fill in first_start with the start address of the
853 * write operation and first_len with the length of the first to-be-written
854 * chunk. If not, return 0 and leave first_start and first_len undefined.
855 *
856 * Warning: This function assumes that @have and @want point to naturally
857 * aligned regions.
858 *
859 * @have buffer with current content
860 * @want buffer with desired content
861 * @len length of the checked area
862 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000863 * @first_start offset of the first byte which needs to be written (passed in
864 * value is increased by the offset of the first needed write
865 * relative to have/want or unchanged if no write is needed)
866 * @return length of the first contiguous area which needs to be written
867 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000868 *
869 * FIXME: This function needs a parameter which tells it about coalescing
870 * in relation to the max write length of the programmer and the max write
871 * length of the chip.
872 */
873static int get_next_write(uint8_t *have, uint8_t *want, int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000874 int *first_start, enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000875{
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000876 int need_write = 0, rel_start = 0, first_len = 0;
877 int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000878
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000879 switch (gran) {
880 case write_gran_1bit:
881 case write_gran_1byte:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000882 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000883 break;
884 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000885 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000886 break;
887 default:
888 msg_cerr("%s: Unsupported granularity! Please report a bug at "
889 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000890 /* Claim that no write was needed. A write with unknown
891 * granularity is too dangerous to try.
892 */
893 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000894 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000895 for (i = 0; i < len / stride; i++) {
896 limit = min(stride, len - i * stride);
897 /* Are 'have' and 'want' identical? */
898 if (memcmp(have + i * stride, want + i * stride, limit)) {
899 if (!need_write) {
900 /* First location where have and want differ. */
901 need_write = 1;
902 rel_start = i * stride;
903 }
904 } else {
905 if (need_write) {
906 /* First location where have and want
907 * do not differ anymore.
908 */
909 first_len = i * stride - rel_start;
910 break;
911 }
912 }
913 }
914 /* Did the loop terminate without setting first_len? */
915 if (need_write && ! first_len)
916 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000917 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000918 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000919}
920
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000921/* This function generates various test patterns useful for testing controller
922 * and chip communication as well as chip behaviour.
923 *
924 * If a byte can be written multiple times, each time keeping 0-bits at 0
925 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
926 * is essentially an AND operation. That's also the reason why this function
927 * provides the result of AND between various patterns.
928 *
929 * Below is a list of patterns (and their block length).
930 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
931 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
932 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
933 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
934 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
935 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
936 * Pattern 6 is 00 (1 Byte)
937 * Pattern 7 is ff (1 Byte)
938 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
939 * byte block.
940 *
941 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
942 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
943 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
944 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
945 * Pattern 12 is 00 (1 Byte)
946 * Pattern 13 is ff (1 Byte)
947 * Patterns 8-13 have no block number.
948 *
949 * Patterns 0-3 are created to detect and efficiently diagnose communication
950 * slips like missed bits or bytes and their repetitive nature gives good visual
951 * cues to the person inspecting the results. In addition, the following holds:
952 * AND Pattern 0/1 == Pattern 4
953 * AND Pattern 2/3 == Pattern 5
954 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
955 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
956 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
957 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
958 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
959 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
960 * Besides that, they provide for bit testing of the last two bytes of every
961 * 256 byte block which contains the block number for patterns 0-6.
962 * Patterns 10-11 are special purpose for detecting subblock aliasing with
963 * block sizes >256 bytes (some Dataflash chips etc.)
964 * AND Pattern 8/9 == Pattern 12
965 * AND Pattern 10/11 == Pattern 12
966 * Pattern 13 is the completely erased state.
967 * None of the patterns can detect aliasing at boundaries which are a multiple
968 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
969 */
970int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
971{
972 int i;
973
974 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000975 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000976 return 1;
977 }
978
979 switch (variant) {
980 case 0:
981 for (i = 0; i < size; i++)
982 buf[i] = (i & 0xf) << 4 | 0x5;
983 break;
984 case 1:
985 for (i = 0; i < size; i++)
986 buf[i] = (i & 0xf) << 4 | 0xa;
987 break;
988 case 2:
989 for (i = 0; i < size; i++)
990 buf[i] = 0x50 | (i & 0xf);
991 break;
992 case 3:
993 for (i = 0; i < size; i++)
994 buf[i] = 0xa0 | (i & 0xf);
995 break;
996 case 4:
997 for (i = 0; i < size; i++)
998 buf[i] = (i & 0xf) << 4;
999 break;
1000 case 5:
1001 for (i = 0; i < size; i++)
1002 buf[i] = i & 0xf;
1003 break;
1004 case 6:
1005 memset(buf, 0x00, size);
1006 break;
1007 case 7:
1008 memset(buf, 0xff, size);
1009 break;
1010 case 8:
1011 for (i = 0; i < size; i++)
1012 buf[i] = i & 0xff;
1013 break;
1014 case 9:
1015 for (i = 0; i < size; i++)
1016 buf[i] = ~(i & 0xff);
1017 break;
1018 case 10:
1019 for (i = 0; i < size % 2; i++) {
1020 buf[i * 2] = (i >> 8) & 0xff;
1021 buf[i * 2 + 1] = i & 0xff;
1022 }
1023 if (size & 0x1)
1024 buf[i * 2] = (i >> 8) & 0xff;
1025 break;
1026 case 11:
1027 for (i = 0; i < size % 2; i++) {
1028 buf[i * 2] = ~((i >> 8) & 0xff);
1029 buf[i * 2 + 1] = ~(i & 0xff);
1030 }
1031 if (size & 0x1)
1032 buf[i * 2] = ~((i >> 8) & 0xff);
1033 break;
1034 case 12:
1035 memset(buf, 0x00, size);
1036 break;
1037 case 13:
1038 memset(buf, 0xff, size);
1039 break;
1040 }
1041
1042 if ((variant >= 0) && (variant <= 7)) {
1043 /* Write block number in the last two bytes of each 256-byte
1044 * block, big endian for easier reading of the hexdump.
1045 * Note that this wraps around for chips larger than 2^24 bytes
1046 * (16 MB).
1047 */
1048 for (i = 0; i < size / 256; i++) {
1049 buf[i * 256 + 254] = (i >> 8) & 0xff;
1050 buf[i * 256 + 255] = i & 0xff;
1051 }
1052 }
1053
1054 return 0;
1055}
1056
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001057int check_max_decode(enum chipbustype buses, uint32_t size)
1058{
1059 int limitexceeded = 0;
1060 if ((buses & CHIP_BUSTYPE_PARALLEL) &&
1061 (max_rom_decode.parallel < size)) {
1062 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001063 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001064 "size %u kB of chipset/board/programmer "
1065 "for %s interface, "
1066 "probe/read/erase/write may fail. ", size / 1024,
1067 max_rom_decode.parallel / 1024, "Parallel");
1068 }
1069 if ((buses & CHIP_BUSTYPE_LPC) && (max_rom_decode.lpc < size)) {
1070 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001071 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001072 "size %u kB of chipset/board/programmer "
1073 "for %s interface, "
1074 "probe/read/erase/write may fail. ", size / 1024,
1075 max_rom_decode.lpc / 1024, "LPC");
1076 }
1077 if ((buses & CHIP_BUSTYPE_FWH) && (max_rom_decode.fwh < size)) {
1078 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001079 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001080 "size %u kB of chipset/board/programmer "
1081 "for %s interface, "
1082 "probe/read/erase/write may fail. ", size / 1024,
1083 max_rom_decode.fwh / 1024, "FWH");
1084 }
1085 if ((buses & CHIP_BUSTYPE_SPI) && (max_rom_decode.spi < size)) {
1086 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001087 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001088 "size %u kB of chipset/board/programmer "
1089 "for %s interface, "
1090 "probe/read/erase/write may fail. ", size / 1024,
1091 max_rom_decode.spi / 1024, "SPI");
1092 }
1093 if (!limitexceeded)
1094 return 0;
1095 /* Sometimes chip and programmer have more than one bus in common,
1096 * and the limit is not exceeded on all buses. Tell the user.
1097 */
1098 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001099 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +00001100 msg_pdbg("There is at least one common chip/programmer "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001101 "interface which can support a chip of this size. "
1102 "You can try --force at your own risk.\n");
1103 return 1;
1104}
1105
Peter Stuge483b8f02008-09-03 23:10:05 +00001106struct flashchip *probe_flash(struct flashchip *first_flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001107{
Peter Stuge483b8f02008-09-03 23:10:05 +00001108 struct flashchip *flash;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001109 unsigned long base = 0;
1110 uint32_t size;
1111 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001112 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001113
Peter Stuge483b8f02008-09-03 23:10:05 +00001114 for (flash = first_flash; flash && flash->name; flash++) {
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001115 if (chip_to_probe && strcmp(flash->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +00001116 continue;
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001117 msg_gdbg("Probing for %s %s, %d KB: ",
Stefan Reinauerac378972008-03-17 22:59:40 +00001118 flash->vendor, flash->name, flash->total_size);
Peter Stuge7ffbc6f2008-06-18 02:08:40 +00001119 if (!flash->probe && !force) {
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001120 msg_gdbg("failed! flashrom has no probe function for "
1121 "this flash chip.\n");
Peter Stugef31104c2008-04-28 14:47:30 +00001122 continue;
1123 }
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001124 buses_common = buses_supported & flash->bustype;
1125 if (!buses_common) {
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001126 tmp = flashbuses_to_text(buses_supported);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001127 msg_gdbg("skipped.");
1128 msg_gspew(" Host bus type %s ", tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001129 free(tmp);
1130 tmp = flashbuses_to_text(flash->bustype);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001131 msg_gspew("and chip bus type %s are incompatible.",
1132 tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001133 free(tmp);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001134 msg_gdbg("\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001135 continue;
1136 }
Stefan Reinauer70385642007-04-06 11:58:03 +00001137
Ollie Lhocbbf1252004-03-17 22:22:08 +00001138 size = flash->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001139 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +00001140
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +00001141 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +00001142 flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001143
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001144 if (force)
1145 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001146
Peter Stuge483b8f02008-09-03 23:10:05 +00001147 if (flash->probe(flash) != 1)
1148 goto notfound;
1149
Uwe Hermann394131e2008-10-18 21:14:13 +00001150 if (first_flash == flashchips
1151 || flash->model_id != GENERIC_DEVICE_ID)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001152 break;
1153
Peter Stuge483b8f02008-09-03 23:10:05 +00001154notfound:
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +00001155 programmer_unmap_flash_region((void *)flash->virtual_memory, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001156 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001157
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001158 if (!flash || !flash->name)
1159 return NULL;
1160
Sean Nelson316a29f2010-05-07 20:09:04 +00001161 msg_cinfo("%s chip \"%s %s\" (%d KB, %s) at physical address 0x%lx.\n",
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +00001162 force ? "Assuming" : "Found",
Uwe Hermann9899cad2009-06-28 21:47:57 +00001163 flash->vendor, flash->name, flash->total_size,
1164 flashbuses_to_text(flash->bustype), base);
1165
Sean Nelson6e0b9122010-02-19 00:52:10 +00001166 if (flash->printlock)
1167 flash->printlock(flash);
1168
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001169 return flash;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001170}
1171
Stefan Reinauere3705282005-12-18 16:41:10 +00001172int verify_flash(struct flashchip *flash, uint8_t *buf)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001173{
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001174 int ret;
Ollie Lho761bf1b2004-03-20 16:46:10 +00001175 int total_size = flash->total_size * 1024;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001176
Sean Nelson316a29f2010-05-07 20:09:04 +00001177 msg_cinfo("Verifying flash... ");
Uwe Hermanna7e05482007-05-09 10:17:44 +00001178
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001179 ret = verify_range(flash, buf, 0, total_size, NULL);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001180
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001181 if (!ret)
Sean Nelson316a29f2010-05-07 20:09:04 +00001182 msg_cinfo("VERIFIED. \n");
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001183
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001184 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001185}
1186
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001187int read_buf_from_file(unsigned char *buf, unsigned long size, char *filename)
1188{
1189 unsigned long numbytes;
1190 FILE *image;
1191 struct stat image_stat;
1192
1193 if ((image = fopen(filename, "rb")) == NULL) {
1194 perror(filename);
1195 return 1;
1196 }
1197 if (fstat(fileno(image), &image_stat) != 0) {
1198 perror(filename);
1199 fclose(image);
1200 return 1;
1201 }
1202 if (image_stat.st_size != size) {
1203 msg_gerr("Error: Image size doesn't match\n");
1204 fclose(image);
1205 return 1;
1206 }
1207 numbytes = fread(buf, 1, size, image);
1208 if (fclose(image)) {
1209 perror(filename);
1210 return 1;
1211 }
1212 if (numbytes != size) {
1213 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1214 "wanted %ld!\n", numbytes, size);
1215 return 1;
1216 }
1217 return 0;
1218}
1219
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001220int write_buf_to_file(unsigned char *buf, unsigned long size, char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001221{
1222 unsigned long numbytes;
1223 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001224
1225 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001226 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001227 return 1;
1228 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001229 if ((image = fopen(filename, "wb")) == NULL) {
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001230 perror(filename);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001231 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001232 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001233
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001234 numbytes = fwrite(buf, 1, size, image);
1235 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001236 if (numbytes != size) {
1237 msg_gerr("File %s could not be written completely.\n",
1238 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001239 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001240 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001241 return 0;
1242}
1243
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001244int read_flash_to_file(struct flashchip *flash, char *filename)
1245{
1246 unsigned long size = flash->total_size * 1024;
1247 unsigned char *buf = calloc(size, sizeof(char));
1248 int ret = 0;
1249
1250 msg_cinfo("Reading flash... ");
1251 if (!buf) {
1252 msg_gerr("Memory allocation failed!\n");
1253 msg_cinfo("FAILED.\n");
1254 return 1;
1255 }
1256 if (!flash->read) {
1257 msg_cerr("No read function available for this flash chip.\n");
1258 ret = 1;
1259 goto out_free;
1260 }
1261 if (flash->read(flash, buf, 0, size)) {
1262 msg_cerr("Read operation failed!\n");
1263 ret = 1;
1264 goto out_free;
1265 }
1266
1267 ret = write_buf_to_file(buf, flash->total_size * 1024, filename);
1268out_free:
1269 free(buf);
1270 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1271 return ret;
1272}
1273
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001274/* This function shares a lot of its structure with erase_and_write_flash() and
1275 * walk_eraseregions().
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001276 * Even if an error is found, the function will keep going and check the rest.
1277 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +00001278static int selfcheck_eraseblocks(struct flashchip *flash)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001279{
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001280 int i, j, k;
1281 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001282
1283 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1284 unsigned int done = 0;
1285 struct block_eraser eraser = flash->block_erasers[k];
1286
1287 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1288 /* Blocks with zero size are bugs in flashchips.c. */
1289 if (eraser.eraseblocks[i].count &&
1290 !eraser.eraseblocks[i].size) {
1291 msg_gerr("ERROR: Flash chip %s erase function "
1292 "%i region %i has size 0. Please report"
1293 " a bug at flashrom@flashrom.org\n",
1294 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001295 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001296 }
1297 /* Blocks with zero count are bugs in flashchips.c. */
1298 if (!eraser.eraseblocks[i].count &&
1299 eraser.eraseblocks[i].size) {
1300 msg_gerr("ERROR: Flash chip %s erase function "
1301 "%i region %i has count 0. Please report"
1302 " a bug at flashrom@flashrom.org\n",
1303 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001304 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001305 }
1306 done += eraser.eraseblocks[i].count *
1307 eraser.eraseblocks[i].size;
1308 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001309 /* Empty eraseblock definition with erase function. */
1310 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001311 msg_gspew("Strange: Empty eraseblock definition with "
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001312 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001313 if (!done)
1314 continue;
1315 if (done != flash->total_size * 1024) {
1316 msg_gerr("ERROR: Flash chip %s erase function %i "
1317 "region walking resulted in 0x%06x bytes total,"
1318 " expected 0x%06x bytes. Please report a bug at"
1319 " flashrom@flashrom.org\n", flash->name, k,
1320 done, flash->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001321 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001322 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001323 if (!eraser.block_erase)
1324 continue;
1325 /* Check if there are identical erase functions for different
1326 * layouts. That would imply "magic" erase functions. The
1327 * easiest way to check this is with function pointers.
1328 */
Uwe Hermann43959702010-03-13 17:28:29 +00001329 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001330 if (eraser.block_erase ==
1331 flash->block_erasers[j].block_erase) {
1332 msg_gerr("ERROR: Flash chip %s erase function "
1333 "%i and %i are identical. Please report"
1334 " a bug at flashrom@flashrom.org\n",
1335 flash->name, k, j);
1336 ret = 1;
1337 }
Uwe Hermann43959702010-03-13 17:28:29 +00001338 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001339 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001340 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001341}
1342
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001343static int erase_and_write_block_helper(struct flashchip *flash,
1344 unsigned int start, unsigned int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001345 uint8_t *curcontents,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001346 uint8_t *newcontents,
1347 int (*erasefn) (struct flashchip *flash,
1348 unsigned int addr,
1349 unsigned int len))
1350{
1351 int starthere = 0;
1352 int lenhere = 0;
1353 int ret = 0;
1354 int skip = 1;
1355 int writecount = 0;
1356 enum write_granularity gran = write_gran_256bytes; /* FIXME */
1357
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001358 /* curcontents and newcontents are opaque to walk_eraseregions, and
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001359 * need to be adjusted here to keep the impression of proper abstraction
1360 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001361 curcontents += start;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001362 newcontents += start;
1363 msg_cdbg(":");
1364 /* FIXME: Assume 256 byte granularity for now to play it safe. */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001365 if (need_erase(curcontents, newcontents, len, gran)) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001366 msg_cdbg("E");
1367 ret = erasefn(flash, start, len);
1368 if (ret)
1369 return ret;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001370 /* Erase was successful. Adjust curcontents. */
1371 memset(curcontents, 0xff, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001372 skip = 0;
1373 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001374 /* get_next_write() sets starthere to a new value after the call. */
1375 while ((lenhere = get_next_write(curcontents + starthere,
1376 newcontents + starthere,
1377 len - starthere, &starthere, gran))) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001378 if (!writecount++)
1379 msg_cdbg("W");
1380 /* Needs the partial write function signature. */
1381 ret = flash->write(flash, newcontents + starthere,
1382 start + starthere, lenhere);
1383 if (ret)
1384 return ret;
1385 starthere += lenhere;
1386 skip = 0;
1387 }
1388 if (skip)
1389 msg_cdbg("S");
1390 return ret;
1391}
1392
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001393static int walk_eraseregions(struct flashchip *flash, int erasefunction,
1394 int (*do_something) (struct flashchip *flash,
1395 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) (
1400 struct flashchip *flash,
1401 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;
1406 unsigned int start = 0;
1407 unsigned int len;
1408 struct block_eraser eraser = flash->block_erasers[erasefunction];
1409 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1410 /* count==0 for all automatically initialized array
1411 * members so the loop below won't be executed for them.
1412 */
1413 len = eraser.eraseblocks[i].size;
1414 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001415 /* Print this for every block except the first one. */
1416 if (i || j)
1417 msg_cdbg(", ");
1418 msg_cdbg("0x%06x-0x%06x", start,
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001419 start + len - 1);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001420 if (do_something(flash, start, len, param1, param2,
1421 eraser.block_erase)) {
1422 msg_cdbg("\n");
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 Hailfinger6e2ea322010-11-04 01:04:27 +00001432int erase_and_write_flash(struct flashchip *flash, uint8_t *oldcontents, uint8_t *newcontents)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001433{
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001434 int k, ret = 0, found = 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001435 uint8_t *curcontents;
1436 unsigned long size = flash->total_size * 1024;
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001437
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001438 curcontents = (uint8_t *) malloc(size);
1439 /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1440 memcpy(curcontents, oldcontents, size);
1441
1442 msg_cinfo("Erasing and writing flash chip... ");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001443 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001444 struct block_eraser eraser = flash->block_erasers[k];
1445
Sean Nelson316a29f2010-05-07 20:09:04 +00001446 msg_cdbg("Looking at blockwise erase function %i... ", k);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001447 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001448 msg_cdbg("not defined. "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001449 "Looking for another erase function.\n");
1450 continue;
1451 }
1452 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001453 msg_cdbg("eraseblock layout is known, but no "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001454 "matching block erase function found. "
1455 "Looking for another erase function.\n");
1456 continue;
1457 }
1458 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001459 msg_cdbg("block erase function found, but "
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001460 "eraseblock layout is unknown. "
1461 "Looking for another erase function.\n");
1462 continue;
1463 }
1464 found = 1;
Sean Nelson316a29f2010-05-07 20:09:04 +00001465 msg_cdbg("trying... ");
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001466 ret = walk_eraseregions(flash, k, &erase_and_write_block_helper, curcontents, newcontents);
Sean Nelson316a29f2010-05-07 20:09:04 +00001467 msg_cdbg("\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001468 /* If everything is OK, don't try another erase function. */
1469 if (!ret)
1470 break;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001471 /* Write/erase failed, so try to find out what the current chip
1472 * contents are. If no usable erase functions remain, we could
1473 * abort the loop instead of continuing, the effect is the same.
1474 * The only difference is whether the reason for other unusable
1475 * functions is printed or not. If in doubt, verbosity wins.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001476 */
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001477 if (flash->read(flash, curcontents, 0, size)) {
1478 /* Now we are truly screwed. Read failed as well. */
1479 msg_cerr("Can't read anymore!\n");
1480 /* We have no idea about the flash chip contents, so
1481 * retrying with another erase function is pointless.
1482 */
1483 break;
1484 }
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001485 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001486 /* Free the scratchpad. */
1487 free(curcontents);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001488 if (!found) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001489 msg_cerr("ERROR: flashrom has no erase function for this flash chip.\n");
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001490 return 1;
1491 }
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001492
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001493 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001494 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001495 } else {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001496 msg_cinfo("Done.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001497 }
1498 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001499}
1500
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001501void nonfatal_help_message(void)
1502{
1503 msg_gerr("Writing to the flash chip apparently didn't do anything.\n"
1504 "This means we have to add special support for your board, "
1505 "programmer or flash chip.\n"
1506 "Please report this on IRC at irc.freenode.net (channel "
1507 "#flashrom) or\n"
1508 "mail flashrom@flashrom.org!\n"
1509 "-------------------------------------------------------------"
1510 "------------------\n"
1511 "You may now reboot or simply leave the machine running.\n");
1512}
1513
Uwe Hermannc67d0372009-10-01 18:40:02 +00001514void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001515{
Sean Nelson316a29f2010-05-07 20:09:04 +00001516 msg_gerr("Your flash chip is in an unknown state.\n"
Uwe Hermannc67d0372009-10-01 18:40:02 +00001517 "Get help on IRC at irc.freenode.net (channel #flashrom) or\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001518 "mail flashrom@flashrom.org with FAILED: your board name in "
1519 "the subject line!\n"
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001520 "-------------------------------------------------------------"
1521 "------------------\n"
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001522 "DO NOT REBOOT OR POWEROFF!\n");
1523}
1524
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001525/* The way to go if you want a delimited list of programmers*/
1526void list_programmers(char *delim)
1527{
1528 enum programmer p;
1529 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001530 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001531 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001532 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001533 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001534 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001535}
1536
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001537void list_programmers_linebreak(int startcol, int cols, int paren)
1538{
1539 const char *pname;
1540 int pnamelen;
1541 int remaining = 0;
1542 int firstline = 1;
1543 enum programmer p;
1544 int i;
1545
1546 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1547 pname = programmer_table[p].name;
1548 pnamelen = strlen(pname);
1549 if (remaining - pnamelen - 2 < 0) {
1550 if (firstline)
1551 firstline = 0;
1552 else
1553 printf("\n");
1554 for (i = 0; i < startcol; i++)
1555 printf(" ");
1556 remaining = cols - startcol;
1557 } else {
1558 printf(" ");
1559 remaining--;
1560 }
1561 if (paren && (p == 0)) {
1562 printf("(");
1563 remaining--;
1564 }
1565 printf("%s", pname);
1566 remaining -= pnamelen;
1567 if (p < PROGRAMMER_INVALID - 1) {
1568 printf(",");
1569 remaining--;
1570 } else {
1571 if (paren)
1572 printf(")");
1573 printf("\n");
1574 }
1575 }
1576}
1577
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001578void print_sysinfo(void)
1579{
1580#if HAVE_UTSNAME == 1
1581 struct utsname osinfo;
1582 uname(&osinfo);
1583
1584 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1585 osinfo.machine);
1586#else
1587 msg_ginfo(" on unknown machine");
1588#endif
1589 msg_ginfo(", built with");
1590#if NEED_PCI == 1
1591#ifdef PCILIB_VERSION
1592 msg_ginfo(" libpci %s,", PCILIB_VERSION);
1593#else
1594 msg_ginfo(" unknown PCI library,");
1595#endif
1596#endif
1597#ifdef __clang__
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001598 msg_ginfo(" LLVM Clang");
1599#ifdef __clang_version__
1600 msg_ginfo(" %s,", __clang_version__);
1601#else
1602 msg_ginfo(" unknown version (before r102686),");
1603#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001604#elif defined(__GNUC__)
1605 msg_ginfo(" GCC");
1606#ifdef __VERSION__
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001607 msg_ginfo(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001608#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001609 msg_ginfo(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001610#endif
1611#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001612 msg_ginfo(" unknown compiler,");
1613#endif
1614#if defined (__FLASHROM_LITTLE_ENDIAN__)
1615 msg_ginfo(" little endian");
1616#else
1617 msg_ginfo(" big endian");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001618#endif
1619 msg_ginfo("\n");
1620}
1621
Bernhard Walle201bde32008-01-21 15:24:22 +00001622void print_version(void)
1623{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001624 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001625 print_sysinfo();
Bernhard Walle201bde32008-01-21 15:24:22 +00001626}
1627
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001628void print_banner(void)
1629{
1630 msg_ginfo("flashrom is free software, get the source code at "
1631 "http://www.flashrom.org\n");
1632 msg_ginfo("\n");
1633}
1634
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001635int selfcheck(void)
1636{
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001637 int ret = 0;
1638 struct flashchip *flash;
1639
1640 /* Safety check. Instead of aborting after the first error, check
1641 * if more errors exist.
1642 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001643 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001644 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001645 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001646 }
1647 if (spi_programmer_count - 1 != SPI_CONTROLLER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001648 msg_gerr("SPI programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001649 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001650 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001651 for (flash = flashchips; flash && flash->name; flash++)
1652 if (selfcheck_eraseblocks(flash))
1653 ret = 1;
1654 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001655}
1656
1657void check_chip_supported(struct flashchip *flash)
1658{
1659 if (TEST_OK_MASK != (flash->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001660 msg_cinfo("===\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001661 if (flash->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001662 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001663 if (flash->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001664 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001665 if (flash->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001666 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001667 if (flash->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001668 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001669 if (flash->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001670 msg_cinfo(" WRITE");
1671 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001672 }
1673 if ((!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE)) ||
1674 (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ)) ||
1675 (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE)) ||
1676 (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001677 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001678 if (!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001679 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001680 if (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001681 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001682 if (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001683 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001684 if (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001685 msg_cinfo(" WRITE");
1686 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001687 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001688 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001689 msg_cinfo("The test status of this chip may have been updated "
1690 "in the latest development\n"
1691 "version of flashrom. If you are running the latest "
1692 "development version,\n"
1693 "please email a report to flashrom@flashrom.org if "
1694 "any of the above operations\n"
1695 "work correctly for you with this flash part. Please "
1696 "include the flashrom\n"
1697 "output with the additional -V option for all "
1698 "operations you tested (-V, -Vr,\n"
1699 "-Vw, -VE), and mention which mainboard or "
1700 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001701 "Please mention your board in the subject line. "
1702 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001703 }
1704}
1705
Ollie Lho761bf1b2004-03-20 16:46:10 +00001706int main(int argc, char *argv[])
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001707{
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001708 return cli_classic(argc, argv);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001709}
1710
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001711/* FIXME: This function signature needs to be improved once doit() has a better
1712 * function signature.
1713 */
1714int chip_safety_check(struct flashchip *flash, int force, char *filename, int read_it, int write_it, int erase_it, int verify_it)
1715{
1716 if (!programmer_may_write && (write_it || erase_it)) {
1717 msg_perr("Write/erase is not working yet on your programmer in "
1718 "its current configuration.\n");
1719 /* --force is the wrong approach, but it's the best we can do
1720 * until the generic programmer parameter parser is merged.
1721 */
1722 if (!force)
1723 return 1;
1724 msg_cerr("Continuing anyway.\n");
1725 }
1726
1727 if (read_it || erase_it || write_it || verify_it) {
1728 /* Everything needs read. */
1729 if (flash->tested & TEST_BAD_READ) {
1730 msg_cerr("Read is not working on this chip. ");
1731 if (!force)
1732 return 1;
1733 msg_cerr("Continuing anyway.\n");
1734 }
1735 if (!flash->read) {
1736 msg_cerr("flashrom has no read function for this "
1737 "flash chip.\n");
1738 return 1;
1739 }
1740 }
1741 if (erase_it || write_it) {
1742 /* Write needs erase. */
1743 if (flash->tested & TEST_BAD_ERASE) {
1744 msg_cerr("Erase is not working on this chip. ");
1745 if (!force)
1746 return 1;
1747 msg_cerr("Continuing anyway.\n");
1748 }
1749 /* FIXME: Check if at least one erase function exists. */
1750 }
1751 if (write_it) {
1752 if (flash->tested & TEST_BAD_WRITE) {
1753 msg_cerr("Write is not working on this chip. ");
1754 if (!force)
1755 return 1;
1756 msg_cerr("Continuing anyway.\n");
1757 }
1758 if (!flash->write) {
1759 msg_cerr("flashrom has no write function for this "
1760 "flash chip.\n");
1761 return 1;
1762 }
1763 }
1764 return 0;
1765}
1766
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001767/* This function signature is horrible. We need to design a better interface,
1768 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001769 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001770 */
1771int doit(struct flashchip *flash, int force, char *filename, int read_it, int write_it, int erase_it, int verify_it)
1772{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001773 uint8_t *oldcontents;
1774 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001775 int ret = 0;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001776 unsigned long size = flash->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001777
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001778 if (chip_safety_check(flash, force, filename, read_it, write_it, erase_it, verify_it)) {
1779 msg_cerr("Aborting.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001780 ret = 1;
1781 goto out_nofree;
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001782 }
1783
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001784 /* Given the existence of read locks, we want to unlock for read,
1785 * erase and write.
1786 */
1787 if (flash->unlock)
1788 flash->unlock(flash);
1789
1790 if (read_it) {
1791 ret = read_flash_to_file(flash, filename);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001792 goto out_nofree;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001793 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001794
1795 oldcontents = (uint8_t *) malloc(size);
1796 /* Assume worst case: All bits are 0. */
1797 memset(oldcontents, 0x00, size);
1798 newcontents = (uint8_t *) malloc(size);
1799 /* Assume best case: All bits should be 1. */
1800 memset(newcontents, 0xff, size);
1801 /* Side effect of the assumptions above: Default write action is erase
1802 * because newcontents looks like a completely erased chip, and
1803 * oldcontents being completely 0x00 means we have to erase everything
1804 * before we can write.
1805 */
1806
Ollie Lhoefa28582004-12-08 20:10:01 +00001807 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001808 /* FIXME: Do we really want the scary warning if erase failed?
1809 * After all, after erase the chip is either blank or partially
1810 * blank or it has the old contents. A blank chip won't boot,
1811 * so if the user wanted erase and reboots afterwards, the user
1812 * knows very well that booting won't work.
1813 */
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001814 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001815 emergency_help_message();
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001816 ret = 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001817 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001818 goto out;
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001819 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001820
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001821 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001822 if (read_buf_from_file(newcontents, size, filename)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001823 ret = 1;
1824 goto out;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001825 }
1826
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001827#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001828 if (programmer == PROGRAMMER_INTERNAL)
1829 show_id(newcontents, size, force);
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001830#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001831 }
1832
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001833 /* Read the whole chip to be able to check whether regions need to be
1834 * erased and to give better diagnostics in case write fails.
1835 * The alternative would be to read only the regions which are to be
1836 * preserved, but in that case we might perform unneeded erase which
1837 * takes time as well.
1838 */
1839 msg_cdbg("Reading old flash chip contents...\n");
1840 if (flash->read(flash, oldcontents, 0, size)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001841 ret = 1;
1842 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001843 }
1844
Ollie Lho184a4042005-11-26 21:55:36 +00001845 // This should be moved into each flash part's code to do it
1846 // cleanly. This does the job.
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001847 handle_romentries(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001848
Ollie Lho184a4042005-11-26 21:55:36 +00001849 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00001850
Peter Stugef31104c2008-04-28 14:47:30 +00001851 if (write_it) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001852 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
1853 msg_cerr("Uh oh. Erase/write failed. Checking if "
1854 "anything changed.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001855 if (!flash->read(flash, newcontents, 0, size)) {
1856 if (!memcmp(oldcontents, newcontents, size)) {
1857 msg_cinfo("Good. It seems nothing was "
1858 "changed.\n");
1859 nonfatal_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001860 ret = 1;
1861 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001862 }
1863 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001864 emergency_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001865 ret = 1;
1866 goto out;
Peter Stugef31104c2008-04-28 14:47:30 +00001867 }
Peter Stugef31104c2008-04-28 14:47:30 +00001868 }
Ollie Lho184a4042005-11-26 21:55:36 +00001869
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001870 if (verify_it) {
1871 /* Work around chips which need some time to calm down. */
1872 if (write_it)
1873 programmer_delay(1000*1000);
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001874 ret = verify_flash(flash, newcontents);
Carl-Daniel Hailfingerf5292052009-11-17 09:57:34 +00001875 /* If we tried to write, and verification now fails, we
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001876 * might have an emergency situation.
1877 */
1878 if (ret && write_it)
1879 emergency_help_message();
1880 }
Ollie Lho184a4042005-11-26 21:55:36 +00001881
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001882out:
1883 free(oldcontents);
1884 free(newcontents);
1885out_nofree:
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00001886 programmer_shutdown();
Stefan Reinauer143da0b2006-01-04 16:42:57 +00001887 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001888}