blob: e9e6a775121ca5bac8c5065548b35371a140cadc [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
Mathias Krausea60faab2011-01-17 07:50:42 +000041const char 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 */
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +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+CONFIG_NICINTEL_SPI+CONFIG_OGP_SPI+CONFIG_SATAMV > 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
Joerg Fischer5665ef32010-05-21 21:54:07 +000064#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
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +000095#if CONFIG_NICINTEL == 1
96 PROGRAMMER_NICINTEL
97#endif
Idwer Vollering004f4b72010-09-03 18:21:21 +000098#if CONFIG_NICINTEL_SPI == 1
99 PROGRAMMER_NICINTEL_SPI
100#endif
Mark Marshall90021f22010-12-03 14:48:11 +0000101#if CONFIG_OGP_SPI == 1
102 PROGRAMMER_OGP_SPI
103#endif
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000104#if CONFIG_SATAMV == 1
105 PROGRAMMER_SATAMV
106#endif
Carl-Daniel Hailfinger1a1415c2010-01-10 13:28:48 +0000107;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000108#endif
109
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000110static char *programmer_param = NULL;
Stefan Reinauer70385642007-04-06 11:58:03 +0000111
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000112/* Supported buses for the current programmer. */
113enum chipbustype buses_supported;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000114
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000115/*
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000116 * Programmers supporting multiple buses can have differing size limits on
117 * each bus. Store the limits for each bus in a common struct.
118 */
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000119struct decode_sizes max_rom_decode;
120
121/* If nonzero, used as the start address of bottom-aligned flash. */
122unsigned long flashbase;
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000123
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000124/* Is writing allowed with this programmer? */
125int programmer_may_write;
126
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000127const struct programmer_entry programmer_table[] = {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000128#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000129 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000130 .name = "internal",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000131 .init = internal_init,
132 .shutdown = internal_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000133 .map_flash_region = physmap,
134 .unmap_flash_region = physunmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000135 .chip_readb = internal_chip_readb,
136 .chip_readw = internal_chip_readw,
137 .chip_readl = internal_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000138 .chip_readn = internal_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000139 .chip_writeb = internal_chip_writeb,
140 .chip_writew = internal_chip_writew,
141 .chip_writel = internal_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000142 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000143 .delay = internal_delay,
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000144 },
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000145#endif
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000146
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000147#if CONFIG_DUMMY == 1
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000148 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000149 .name = "dummy",
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000150 .init = dummy_init,
151 .shutdown = dummy_shutdown,
Carl-Daniel Hailfinger1455b2b2009-05-11 14:13:25 +0000152 .map_flash_region = dummy_map,
153 .unmap_flash_region = dummy_unmap,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000154 .chip_readb = dummy_chip_readb,
155 .chip_readw = dummy_chip_readw,
156 .chip_readl = dummy_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000157 .chip_readn = dummy_chip_readn,
Carl-Daniel Hailfinger1e334e62009-05-11 15:46:43 +0000158 .chip_writeb = dummy_chip_writeb,
159 .chip_writew = dummy_chip_writew,
160 .chip_writel = dummy_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000161 .chip_writen = dummy_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000162 .delay = internal_delay,
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000163 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000164#endif
Carl-Daniel Hailfingerc3129202009-05-09 00:54:55 +0000165
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000166#if CONFIG_NIC3COM == 1
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000167 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000168 .name = "nic3com",
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000169 .init = nic3com_init,
170 .shutdown = nic3com_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000171 .map_flash_region = fallback_map,
172 .unmap_flash_region = fallback_unmap,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000173 .chip_readb = nic3com_chip_readb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000174 .chip_readw = fallback_chip_readw,
175 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000176 .chip_readn = fallback_chip_readn,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000177 .chip_writeb = nic3com_chip_writeb,
Carl-Daniel Hailfinger9ee10772009-05-16 01:23:55 +0000178 .chip_writew = fallback_chip_writew,
179 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000180 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000181 .delay = internal_delay,
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000182 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000183#endif
Uwe Hermannb4dcb712009-05-13 11:36:06 +0000184
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000185#if CONFIG_NICREALTEK == 1
Joerg Fischer5665ef32010-05-21 21:54:07 +0000186 {
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000187 /* This programmer works for Realtek RTL8139 and SMC 1211. */
Joerg Fischer5665ef32010-05-21 21:54:07 +0000188 .name = "nicrealtek",
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000189 //.name = "nicsmc1211",
Joerg Fischer5665ef32010-05-21 21:54:07 +0000190 .init = nicrealtek_init,
191 .shutdown = nicrealtek_shutdown,
192 .map_flash_region = fallback_map,
193 .unmap_flash_region = fallback_unmap,
194 .chip_readb = nicrealtek_chip_readb,
195 .chip_readw = fallback_chip_readw,
196 .chip_readl = fallback_chip_readl,
197 .chip_readn = fallback_chip_readn,
198 .chip_writeb = nicrealtek_chip_writeb,
199 .chip_writew = fallback_chip_writew,
200 .chip_writel = fallback_chip_writel,
201 .chip_writen = fallback_chip_writen,
202 .delay = internal_delay,
203 },
Joerg Fischer5665ef32010-05-21 21:54:07 +0000204#endif
205
Andrew Morganc29c2e72010-06-07 22:37:54 +0000206#if CONFIG_NICNATSEMI == 1
207 {
208 .name = "nicnatsemi",
209 .init = nicnatsemi_init,
210 .shutdown = nicnatsemi_shutdown,
211 .map_flash_region = fallback_map,
212 .unmap_flash_region = fallback_unmap,
213 .chip_readb = nicnatsemi_chip_readb,
214 .chip_readw = fallback_chip_readw,
215 .chip_readl = fallback_chip_readl,
216 .chip_readn = fallback_chip_readn,
217 .chip_writeb = nicnatsemi_chip_writeb,
218 .chip_writew = fallback_chip_writew,
219 .chip_writel = fallback_chip_writel,
220 .chip_writen = fallback_chip_writen,
221 .delay = internal_delay,
222 },
223#endif
Joerg Fischer5665ef32010-05-21 21:54:07 +0000224
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000225#if CONFIG_GFXNVIDIA == 1
Uwe Hermann2bc98f62009-09-30 18:29:55 +0000226 {
227 .name = "gfxnvidia",
228 .init = gfxnvidia_init,
229 .shutdown = gfxnvidia_shutdown,
230 .map_flash_region = fallback_map,
231 .unmap_flash_region = fallback_unmap,
232 .chip_readb = gfxnvidia_chip_readb,
233 .chip_readw = fallback_chip_readw,
234 .chip_readl = fallback_chip_readl,
235 .chip_readn = fallback_chip_readn,
236 .chip_writeb = gfxnvidia_chip_writeb,
237 .chip_writew = fallback_chip_writew,
238 .chip_writel = fallback_chip_writel,
239 .chip_writen = fallback_chip_writen,
240 .delay = internal_delay,
241 },
242#endif
243
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000244#if CONFIG_DRKAISER == 1
Rudolf Marek68720c72009-05-17 19:39:27 +0000245 {
TURBO Jb0912c02009-09-02 23:00:46 +0000246 .name = "drkaiser",
247 .init = drkaiser_init,
248 .shutdown = drkaiser_shutdown,
249 .map_flash_region = fallback_map,
250 .unmap_flash_region = fallback_unmap,
251 .chip_readb = drkaiser_chip_readb,
252 .chip_readw = fallback_chip_readw,
253 .chip_readl = fallback_chip_readl,
254 .chip_readn = fallback_chip_readn,
255 .chip_writeb = drkaiser_chip_writeb,
256 .chip_writew = fallback_chip_writew,
257 .chip_writel = fallback_chip_writel,
258 .chip_writen = fallback_chip_writen,
259 .delay = internal_delay,
260 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000261#endif
TURBO Jb0912c02009-09-02 23:00:46 +0000262
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000263#if CONFIG_SATASII == 1
TURBO Jb0912c02009-09-02 23:00:46 +0000264 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000265 .name = "satasii",
Rudolf Marek68720c72009-05-17 19:39:27 +0000266 .init = satasii_init,
267 .shutdown = satasii_shutdown,
Uwe Hermannc6915932009-05-17 23:12:17 +0000268 .map_flash_region = fallback_map,
269 .unmap_flash_region = fallback_unmap,
Rudolf Marek68720c72009-05-17 19:39:27 +0000270 .chip_readb = satasii_chip_readb,
271 .chip_readw = fallback_chip_readw,
272 .chip_readl = fallback_chip_readl,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000273 .chip_readn = fallback_chip_readn,
Rudolf Marek68720c72009-05-17 19:39:27 +0000274 .chip_writeb = satasii_chip_writeb,
275 .chip_writew = fallback_chip_writew,
276 .chip_writel = fallback_chip_writel,
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000277 .chip_writen = fallback_chip_writen,
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000278 .delay = internal_delay,
Rudolf Marek68720c72009-05-17 19:39:27 +0000279 },
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000280#endif
Rudolf Marek68720c72009-05-17 19:39:27 +0000281
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000282#if CONFIG_ATAHPT == 1
Uwe Hermannddd5c9e2010-02-21 21:17:00 +0000283 {
284 .name = "atahpt",
285 .init = atahpt_init,
286 .shutdown = atahpt_shutdown,
287 .map_flash_region = fallback_map,
288 .unmap_flash_region = fallback_unmap,
289 .chip_readb = atahpt_chip_readb,
290 .chip_readw = fallback_chip_readw,
291 .chip_readl = fallback_chip_readl,
292 .chip_readn = fallback_chip_readn,
293 .chip_writeb = atahpt_chip_writeb,
294 .chip_writew = fallback_chip_writew,
295 .chip_writel = fallback_chip_writel,
296 .chip_writen = fallback_chip_writen,
297 .delay = internal_delay,
298 },
299#endif
300
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000301#if CONFIG_FT2232_SPI == 1
Paul Fox05dfbe62009-06-16 21:08:06 +0000302 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000303 .name = "ft2232_spi",
Paul Fox05dfbe62009-06-16 21:08:06 +0000304 .init = ft2232_spi_init,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000305 .shutdown = noop_shutdown, /* Missing shutdown */
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000306 .map_flash_region = fallback_map,
307 .unmap_flash_region = fallback_unmap,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000308 .chip_readb = noop_chip_readb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000309 .chip_readw = fallback_chip_readw,
310 .chip_readl = fallback_chip_readl,
311 .chip_readn = fallback_chip_readn,
Carl-Daniel Hailfinger4740c6f2009-09-16 10:09:21 +0000312 .chip_writeb = noop_chip_writeb,
Paul Fox05dfbe62009-06-16 21:08:06 +0000313 .chip_writew = fallback_chip_writew,
314 .chip_writel = fallback_chip_writel,
315 .chip_writen = fallback_chip_writen,
316 .delay = internal_delay,
317 },
Carl-Daniel Hailfinger3426ef62009-08-19 13:27:58 +0000318#endif
Carl-Daniel Hailfinger415e5132009-08-12 11:39:29 +0000319
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000320#if CONFIG_SERPROG == 1
Urja Rannikko22915352009-06-23 11:33:43 +0000321 {
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000322 .name = "serprog",
Urja Rannikko22915352009-06-23 11:33:43 +0000323 .init = serprog_init,
324 .shutdown = serprog_shutdown,
325 .map_flash_region = fallback_map,
326 .unmap_flash_region = fallback_unmap,
327 .chip_readb = serprog_chip_readb,
328 .chip_readw = fallback_chip_readw,
329 .chip_readl = fallback_chip_readl,
330 .chip_readn = serprog_chip_readn,
331 .chip_writeb = serprog_chip_writeb,
332 .chip_writew = fallback_chip_writew,
333 .chip_writel = fallback_chip_writel,
334 .chip_writen = fallback_chip_writen,
335 .delay = serprog_delay,
336 },
Carl-Daniel Hailfinger6be74112009-08-12 16:17:41 +0000337#endif
Paul Fox05dfbe62009-06-16 21:08:06 +0000338
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000339#if CONFIG_BUSPIRATE_SPI == 1
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000340 {
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000341 .name = "buspirate_spi",
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000342 .init = buspirate_spi_init,
343 .shutdown = buspirate_spi_shutdown,
344 .map_flash_region = fallback_map,
345 .unmap_flash_region = fallback_unmap,
346 .chip_readb = noop_chip_readb,
347 .chip_readw = fallback_chip_readw,
348 .chip_readl = fallback_chip_readl,
349 .chip_readn = fallback_chip_readn,
350 .chip_writeb = noop_chip_writeb,
351 .chip_writew = fallback_chip_writew,
352 .chip_writel = fallback_chip_writel,
353 .chip_writen = fallback_chip_writen,
354 .delay = internal_delay,
355 },
356#endif
357
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +0000358#if CONFIG_DEDIPROG == 1
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000359 {
360 .name = "dediprog",
361 .init = dediprog_init,
362 .shutdown = dediprog_shutdown,
363 .map_flash_region = fallback_map,
364 .unmap_flash_region = fallback_unmap,
365 .chip_readb = noop_chip_readb,
366 .chip_readw = fallback_chip_readw,
367 .chip_readl = fallback_chip_readl,
368 .chip_readn = fallback_chip_readn,
369 .chip_writeb = noop_chip_writeb,
370 .chip_writew = fallback_chip_writew,
371 .chip_writel = fallback_chip_writel,
372 .chip_writen = fallback_chip_writen,
373 .delay = internal_delay,
374 },
375#endif
376
Carl-Daniel Hailfingere7fdd6e2010-07-21 10:26:01 +0000377#if CONFIG_RAYER_SPI == 1
378 {
379 .name = "rayer_spi",
380 .init = rayer_spi_init,
381 .shutdown = noop_shutdown,
382 .map_flash_region = fallback_map,
383 .unmap_flash_region = fallback_unmap,
384 .chip_readb = noop_chip_readb,
385 .chip_readw = fallback_chip_readw,
386 .chip_readl = fallback_chip_readl,
387 .chip_readn = fallback_chip_readn,
388 .chip_writeb = noop_chip_writeb,
389 .chip_writew = fallback_chip_writew,
390 .chip_writel = fallback_chip_writel,
391 .chip_writen = fallback_chip_writen,
392 .delay = internal_delay,
393 },
394#endif
395
Carl-Daniel Hailfingerb713d2e2011-05-08 00:24:18 +0000396#if CONFIG_NICINTEL == 1
397 {
398 .name = "nicintel",
399 .init = nicintel_init,
400 .shutdown = nicintel_shutdown,
401 .map_flash_region = fallback_map,
402 .unmap_flash_region = fallback_unmap,
403 .chip_readb = nicintel_chip_readb,
404 .chip_readw = fallback_chip_readw,
405 .chip_readl = fallback_chip_readl,
406 .chip_readn = fallback_chip_readn,
407 .chip_writeb = nicintel_chip_writeb,
408 .chip_writew = fallback_chip_writew,
409 .chip_writel = fallback_chip_writel,
410 .chip_writen = fallback_chip_writen,
411 .delay = internal_delay,
412 },
413#endif
414
Idwer Vollering004f4b72010-09-03 18:21:21 +0000415#if CONFIG_NICINTEL_SPI == 1
416 {
417 .name = "nicintel_spi",
418 .init = nicintel_spi_init,
419 .shutdown = nicintel_spi_shutdown,
420 .map_flash_region = fallback_map,
421 .unmap_flash_region = fallback_unmap,
422 .chip_readb = noop_chip_readb,
423 .chip_readw = fallback_chip_readw,
424 .chip_readl = fallback_chip_readl,
425 .chip_readn = fallback_chip_readn,
426 .chip_writeb = noop_chip_writeb,
427 .chip_writew = fallback_chip_writew,
428 .chip_writel = fallback_chip_writel,
429 .chip_writen = fallback_chip_writen,
430 .delay = internal_delay,
431 },
432#endif
433
Mark Marshall90021f22010-12-03 14:48:11 +0000434#if CONFIG_OGP_SPI == 1
435 {
436 .name = "ogp_spi",
437 .init = ogp_spi_init,
438 .shutdown = ogp_spi_shutdown,
439 .map_flash_region = fallback_map,
440 .unmap_flash_region = fallback_unmap,
441 .chip_readb = noop_chip_readb,
442 .chip_readw = fallback_chip_readw,
443 .chip_readl = fallback_chip_readl,
444 .chip_readn = fallback_chip_readn,
445 .chip_writeb = noop_chip_writeb,
446 .chip_writew = fallback_chip_writew,
447 .chip_writel = fallback_chip_writel,
448 .chip_writen = fallback_chip_writen,
449 .delay = internal_delay,
450 },
451#endif
452
Carl-Daniel Hailfinger9a1105c2011-02-04 21:37:59 +0000453#if CONFIG_SATAMV == 1
454 {
455 .name = "satamv",
456 .init = satamv_init,
457 .shutdown = satamv_shutdown,
458 .map_flash_region = fallback_map,
459 .unmap_flash_region = fallback_unmap,
460 .chip_readb = satamv_chip_readb,
461 .chip_readw = fallback_chip_readw,
462 .chip_readl = fallback_chip_readl,
463 .chip_readn = fallback_chip_readn,
464 .chip_writeb = satamv_chip_writeb,
465 .chip_writew = fallback_chip_writew,
466 .chip_writel = fallback_chip_writel,
467 .chip_writen = fallback_chip_writen,
468 .delay = internal_delay,
469 },
470#endif
471
Carl-Daniel Hailfinger37fc4692009-08-12 14:34:35 +0000472 {}, /* This entry corresponds to PROGRAMMER_INVALID. */
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000473};
Luc Verhaegen8e3a6002007-04-04 22:45:58 +0000474
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000475#define SHUTDOWN_MAXFN 32
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000476static int shutdown_fn_count = 0;
477struct shutdown_func_data {
478 void (*func) (void *data);
479 void *data;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000480} static shutdown_fn[SHUTDOWN_MAXFN];
481/* Initialize to 0 to make sure nobody registers a shutdown function before
482 * programmer init.
483 */
484static int may_register_shutdown = 0;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000485
486/* Register a function to be executed on programmer shutdown.
487 * The advantage over atexit() is that you can supply a void pointer which will
488 * be used as parameter to the registered function upon programmer shutdown.
489 * This pointer can point to arbitrary data used by said function, e.g. undo
490 * information for GPIO settings etc. If unneeded, set data=NULL.
491 * Please note that the first (void *data) belongs to the function signature of
492 * the function passed as first parameter.
493 */
494int register_shutdown(void (*function) (void *data), void *data)
495{
496 if (shutdown_fn_count >= SHUTDOWN_MAXFN) {
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000497 msg_perr("Tried to register more than %i shutdown functions.\n",
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000498 SHUTDOWN_MAXFN);
499 return 1;
500 }
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000501 if (!may_register_shutdown) {
502 msg_perr("Tried to register a shutdown function before "
503 "programmer init.\n");
504 return 1;
505 }
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000506 shutdown_fn[shutdown_fn_count].func = function;
507 shutdown_fn[shutdown_fn_count].data = data;
508 shutdown_fn_count++;
509
510 return 0;
511}
512
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000513int programmer_init(char *param)
Uwe Hermann09e04f72009-05-16 22:36:00 +0000514{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000515 int ret;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000516 /* Initialize all programmer specific data. */
517 /* Default to unlimited decode sizes. */
518 max_rom_decode = (const struct decode_sizes) {
519 .parallel = 0xffffffff,
520 .lpc = 0xffffffff,
521 .fwh = 0xffffffff,
522 .spi = 0xffffffff
523 };
Michael Karcherb9dbe482011-05-11 17:07:07 +0000524 buses_supported = CHIP_BUSTYPE_NONE;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000525 /* Default to top aligned flash at 4 GB. */
526 flashbase = 0;
527 /* Registering shutdown functions is now allowed. */
528 may_register_shutdown = 1;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +0000529 /* Default to allowing writes. Broken programmers set this to 0. */
530 programmer_may_write = 1;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000531
532 programmer_param = param;
533 msg_pdbg("Initializing %s programmer\n",
534 programmer_table[programmer].name);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000535 ret = programmer_table[programmer].init();
536 if (programmer_param && strlen(programmer_param)) {
537 msg_perr("Unhandled programmer parameters: %s\n",
538 programmer_param);
539 /* Do not error out here, the init itself was successful. */
540 }
541 return ret;
Uwe Hermann09e04f72009-05-16 22:36:00 +0000542}
543
544int programmer_shutdown(void)
545{
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000546 /* Registering shutdown functions is no longer allowed. */
547 may_register_shutdown = 0;
548 while (shutdown_fn_count > 0) {
549 int i = --shutdown_fn_count;
Carl-Daniel Hailfingercc389fc2010-02-14 01:20:28 +0000550 shutdown_fn[i].func(shutdown_fn[i].data);
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000551 }
Uwe Hermann09e04f72009-05-16 22:36:00 +0000552 return programmer_table[programmer].shutdown();
553}
554
555void *programmer_map_flash_region(const char *descr, unsigned long phys_addr,
556 size_t len)
557{
558 return programmer_table[programmer].map_flash_region(descr,
559 phys_addr, len);
560}
561
562void programmer_unmap_flash_region(void *virt_addr, size_t len)
563{
564 programmer_table[programmer].unmap_flash_region(virt_addr, len);
565}
566
567void chip_writeb(uint8_t val, chipaddr addr)
568{
569 programmer_table[programmer].chip_writeb(val, addr);
570}
571
572void chip_writew(uint16_t val, chipaddr addr)
573{
574 programmer_table[programmer].chip_writew(val, addr);
575}
576
577void chip_writel(uint32_t val, chipaddr addr)
578{
579 programmer_table[programmer].chip_writel(val, addr);
580}
581
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000582void chip_writen(uint8_t *buf, chipaddr addr, size_t len)
583{
584 programmer_table[programmer].chip_writen(buf, addr, len);
585}
586
Uwe Hermann09e04f72009-05-16 22:36:00 +0000587uint8_t chip_readb(const chipaddr addr)
588{
589 return programmer_table[programmer].chip_readb(addr);
590}
591
592uint16_t chip_readw(const chipaddr addr)
593{
594 return programmer_table[programmer].chip_readw(addr);
595}
596
597uint32_t chip_readl(const chipaddr addr)
598{
599 return programmer_table[programmer].chip_readl(addr);
600}
601
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000602void chip_readn(uint8_t *buf, chipaddr addr, size_t len)
603{
604 programmer_table[programmer].chip_readn(buf, addr, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000605}
606
Carl-Daniel Hailfingerca8bfc62009-06-05 17:48:08 +0000607void programmer_delay(int usecs)
608{
609 programmer_table[programmer].delay(usecs);
610}
611
Peter Stuge776d2022009-01-26 00:39:57 +0000612void map_flash_registers(struct flashchip *flash)
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000613{
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000614 size_t size = flash->total_size * 1024;
Carl-Daniel Hailfingerd0fc9462009-05-11 14:01:17 +0000615 /* Flash registers live 4 MByte below the flash. */
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +0000616 /* FIXME: This is incorrect for nonstandard flashbase. */
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000617 flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
Stefan Reinauerff4f1972007-05-24 08:48:10 +0000618}
619
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000620int read_memmapped(struct flashchip *flash, uint8_t *buf, int start, int len)
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000621{
Carl-Daniel Hailfingercbf563c2009-06-16 08:55:44 +0000622 chip_readn(buf, flash->virtual_memory + start, len);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +0000623
624 return 0;
625}
626
Carl-Daniel Hailfinger38a059d2009-06-13 12:04:03 +0000627int min(int a, int b)
628{
629 return (a < b) ? a : b;
630}
631
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000632int max(int a, int b)
633{
634 return (a > b) ? a : b;
635}
636
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +0000637int bitcount(unsigned long a)
638{
639 int i = 0;
640 for (; a != 0; a >>= 1)
641 if (a & 1)
642 i++;
643 return i;
644}
645
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000646void tolower_string(char *str)
647{
648 for (; *str != '\0'; str++)
649 *str = (char)tolower((unsigned char)*str);
650}
651
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000652char *strcat_realloc(char *dest, const char *src)
653{
654 dest = realloc(dest, strlen(dest) + strlen(src) + 1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000655 if (!dest) {
656 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000657 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000658 }
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +0000659 strcat(dest, src);
660 return dest;
661}
662
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000663/* This is a somewhat hacked function similar in some ways to strtok().
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000664 * It will look for needle with a subsequent '=' in haystack, return a copy of
665 * needle and remove everything from the first occurrence of needle to the next
666 * delimiter from haystack.
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000667 */
668char *extract_param(char **haystack, char *needle, char *delim)
669{
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000670 char *param_pos, *opt_pos, *rest;
671 char *opt = NULL;
672 int optlen;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000673 int needlelen;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000674
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000675 needlelen = strlen(needle);
676 if (!needlelen) {
677 msg_gerr("%s: empty needle! Please report a bug at "
678 "flashrom@flashrom.org\n", __func__);
679 return NULL;
680 }
681 /* No programmer parameters given. */
682 if (*haystack == NULL)
683 return NULL;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000684 param_pos = strstr(*haystack, needle);
685 do {
686 if (!param_pos)
687 return NULL;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000688 /* Needle followed by '='? */
689 if (param_pos[needlelen] == '=') {
690
691 /* Beginning of the string? */
692 if (param_pos == *haystack)
693 break;
694 /* After a delimiter? */
695 if (strchr(delim, *(param_pos - 1)))
696 break;
697 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000698 /* Continue searching. */
699 param_pos++;
700 param_pos = strstr(param_pos, needle);
701 } while (1);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000702
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000703 if (param_pos) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000704 /* Get the string after needle and '='. */
705 opt_pos = param_pos + needlelen + 1;
706 optlen = strcspn(opt_pos, delim);
707 /* Return an empty string if the parameter was empty. */
708 opt = malloc(optlen + 1);
709 if (!opt) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000710 msg_gerr("Out of memory!\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000711 exit(1);
712 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000713 strncpy(opt, opt_pos, optlen);
714 opt[optlen] = '\0';
715 rest = opt_pos + optlen;
716 /* Skip all delimiters after the current parameter. */
717 rest += strspn(rest, delim);
718 memmove(param_pos, rest, strlen(rest) + 1);
719 /* We could shrink haystack, but the effort is not worth it. */
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000720 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000721
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000722 return opt;
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000723}
724
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000725char *extract_programmer_param(char *param_name)
726{
727 return extract_param(&programmer_param, param_name, ",");
728}
729
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000730/* start is an offset to the base address of the flash chip */
731int check_erased_range(struct flashchip *flash, int start, int len)
732{
733 int ret;
734 uint8_t *cmpbuf = malloc(len);
735
736 if (!cmpbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000737 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000738 exit(1);
739 }
740 memset(cmpbuf, 0xff, len);
741 ret = verify_range(flash, cmpbuf, start, len, "ERASE");
742 free(cmpbuf);
743 return ret;
744}
745
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000746/*
Carl-Daniel Hailfingerd0250a32009-11-25 17:05:52 +0000747 * @cmpbuf buffer to compare against, cmpbuf[0] is expected to match the
748 flash content at location start
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000749 * @start offset to the base address of the flash chip
750 * @len length of the verified area
751 * @message string to print in the "FAILED" message
752 * @return 0 for success, -1 for failure
753 */
754int verify_range(struct flashchip *flash, uint8_t *cmpbuf, int start, int len, char *message)
755{
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000756 int i, ret = 0;
757 uint8_t *readbuf = malloc(len);
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000758 int failcount = 0;
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000759
760 if (!len)
761 goto out_free;
762
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000763 if (!flash->read) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000764 msg_cerr("ERROR: flashrom has no read function for this flash chip.\n");
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +0000765 return 1;
766 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000767 if (!readbuf) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000768 msg_gerr("Could not allocate memory!\n");
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000769 exit(1);
770 }
771
772 if (start + len > flash->total_size * 1024) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000773 msg_gerr("Error: %s called with start 0x%x + len 0x%x >"
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000774 " total_size 0x%x\n", __func__, start, len,
775 flash->total_size * 1024);
776 ret = -1;
777 goto out_free;
778 }
779 if (!message)
780 message = "VERIFY";
781
Carl-Daniel Hailfingerd8369412010-11-16 17:21:58 +0000782 ret = flash->read(flash, readbuf, start, len);
783 if (ret) {
784 msg_gerr("Verification impossible because read failed "
785 "at 0x%x (len 0x%x)\n", start, len);
786 return ret;
787 }
788
789 for (i = 0; i < len; i++) {
790 if (cmpbuf[i] != readbuf[i]) {
791 /* Only print the first failure. */
792 if (!failcount++)
793 msg_cerr("%s FAILED at 0x%08x! "
794 "Expected=0x%02x, Read=0x%02x,",
795 message, start + i, cmpbuf[i],
796 readbuf[i]);
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000797 }
798 }
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000799 if (failcount) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000800 msg_cerr(" failed byte count from 0x%08x-0x%08x: 0x%x\n",
Carl-Daniel Hailfinger49b9cab2009-07-23 01:42:56 +0000801 start, start + len - 1, failcount);
802 ret = -1;
803 }
Carl-Daniel Hailfinger30f7cb22009-06-15 17:23:36 +0000804
805out_free:
806 free(readbuf);
807 return ret;
808}
809
Uwe Hermann48ec1b12010-08-08 17:01:18 +0000810/*
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000811 * Check if the buffer @have can be programmed to the content of @want without
812 * erasing. This is only possible if all chunks of size @gran are either kept
813 * as-is or changed from an all-ones state to any other state.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000814 *
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000815 * The following write granularities (enum @gran) are known:
816 * - 1 bit. Each bit can be cleared individually.
817 * - 1 byte. A byte can be written once. Further writes to an already written
818 * byte cause the contents to be either undefined or to stay unchanged.
819 * - 128 bytes. If less than 128 bytes are written, the rest will be
820 * erased. Each write to a 128-byte region will trigger an automatic erase
821 * before anything is written. Very uncommon behaviour and unsupported by
822 * this function.
823 * - 256 bytes. If less than 256 bytes are written, the contents of the
824 * unwritten bytes are undefined.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000825 * Warning: This function assumes that @have and @want point to naturally
826 * aligned regions.
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000827 *
828 * @have buffer with current content
829 * @want buffer with desired content
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000830 * @len length of the checked area
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000831 * @gran write granularity (enum, not count)
832 * @return 0 if no erase is needed, 1 otherwise
833 */
834int need_erase(uint8_t *have, uint8_t *want, int len, enum write_granularity gran)
835{
836 int result = 0;
837 int i, j, limit;
838
839 switch (gran) {
840 case write_gran_1bit:
841 for (i = 0; i < len; i++)
842 if ((have[i] & want[i]) != want[i]) {
843 result = 1;
844 break;
845 }
846 break;
847 case write_gran_1byte:
848 for (i = 0; i < len; i++)
849 if ((have[i] != want[i]) && (have[i] != 0xff)) {
850 result = 1;
851 break;
852 }
853 break;
854 case write_gran_256bytes:
855 for (j = 0; j < len / 256; j++) {
856 limit = min (256, len - j * 256);
Uwe Hermann43959702010-03-13 17:28:29 +0000857 /* Are 'have' and 'want' identical? */
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000858 if (!memcmp(have + j * 256, want + j * 256, limit))
859 continue;
860 /* have needs to be in erased state. */
861 for (i = 0; i < limit; i++)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000862 if (have[j * 256 + i] != 0xff) {
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000863 result = 1;
864 break;
865 }
866 if (result)
867 break;
868 }
869 break;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000870 default:
871 msg_cerr("%s: Unsupported granularity! Please report a bug at "
872 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfingere8e369f2010-03-08 00:42:32 +0000873 }
874 return result;
875}
876
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000877/**
878 * Check if the buffer @have needs to be programmed to get the content of @want.
879 * If yes, return 1 and fill in first_start with the start address of the
880 * write operation and first_len with the length of the first to-be-written
881 * chunk. If not, return 0 and leave first_start and first_len undefined.
882 *
883 * Warning: This function assumes that @have and @want point to naturally
884 * aligned regions.
885 *
886 * @have buffer with current content
887 * @want buffer with desired content
888 * @len length of the checked area
889 * @gran write granularity (enum, not count)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000890 * @first_start offset of the first byte which needs to be written (passed in
891 * value is increased by the offset of the first needed write
892 * relative to have/want or unchanged if no write is needed)
893 * @return length of the first contiguous area which needs to be written
894 * 0 if no write is needed
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000895 *
896 * FIXME: This function needs a parameter which tells it about coalescing
897 * in relation to the max write length of the programmer and the max write
898 * length of the chip.
899 */
900static int get_next_write(uint8_t *have, uint8_t *want, int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000901 int *first_start, enum write_granularity gran)
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000902{
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000903 int need_write = 0, rel_start = 0, first_len = 0;
904 int i, limit, stride;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000905
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000906 switch (gran) {
907 case write_gran_1bit:
908 case write_gran_1byte:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000909 stride = 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000910 break;
911 case write_gran_256bytes:
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000912 stride = 256;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000913 break;
914 default:
915 msg_cerr("%s: Unsupported granularity! Please report a bug at "
916 "flashrom@flashrom.org\n", __func__);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000917 /* Claim that no write was needed. A write with unknown
918 * granularity is too dangerous to try.
919 */
920 return 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000921 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000922 for (i = 0; i < len / stride; i++) {
923 limit = min(stride, len - i * stride);
924 /* Are 'have' and 'want' identical? */
925 if (memcmp(have + i * stride, want + i * stride, limit)) {
926 if (!need_write) {
927 /* First location where have and want differ. */
928 need_write = 1;
929 rel_start = i * stride;
930 }
931 } else {
932 if (need_write) {
933 /* First location where have and want
934 * do not differ anymore.
935 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000936 break;
937 }
938 }
939 }
Carl-Daniel Hailfinger202bf532010-12-06 13:05:44 +0000940 if (need_write)
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000941 first_len = min(i * stride - rel_start, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000942 *first_start += rel_start;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +0000943 return first_len;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +0000944}
945
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +0000946/* This function generates various test patterns useful for testing controller
947 * and chip communication as well as chip behaviour.
948 *
949 * If a byte can be written multiple times, each time keeping 0-bits at 0
950 * and changing 1-bits to 0 if the new value for that bit is 0, the effect
951 * is essentially an AND operation. That's also the reason why this function
952 * provides the result of AND between various patterns.
953 *
954 * Below is a list of patterns (and their block length).
955 * Pattern 0 is 05 15 25 35 45 55 65 75 85 95 a5 b5 c5 d5 e5 f5 (16 Bytes)
956 * Pattern 1 is 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a aa ba ca da ea fa (16 Bytes)
957 * Pattern 2 is 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f (16 Bytes)
958 * Pattern 3 is a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af (16 Bytes)
959 * Pattern 4 is 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0 (16 Bytes)
960 * Pattern 5 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f (16 Bytes)
961 * Pattern 6 is 00 (1 Byte)
962 * Pattern 7 is ff (1 Byte)
963 * Patterns 0-7 have a big-endian block number in the last 2 bytes of each 256
964 * byte block.
965 *
966 * Pattern 8 is 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11... (256 B)
967 * Pattern 9 is ff fe fd fc fb fa f9 f8 f7 f6 f5 f4 f3 f2 f1 f0 ef ee... (256 B)
968 * Pattern 10 is 00 00 00 01 00 02 00 03 00 04... (128 kB big-endian counter)
969 * Pattern 11 is ff ff ff fe ff fd ff fc ff fb... (128 kB big-endian downwards)
970 * Pattern 12 is 00 (1 Byte)
971 * Pattern 13 is ff (1 Byte)
972 * Patterns 8-13 have no block number.
973 *
974 * Patterns 0-3 are created to detect and efficiently diagnose communication
975 * slips like missed bits or bytes and their repetitive nature gives good visual
976 * cues to the person inspecting the results. In addition, the following holds:
977 * AND Pattern 0/1 == Pattern 4
978 * AND Pattern 2/3 == Pattern 5
979 * AND Pattern 0/1/2/3 == AND Pattern 4/5 == Pattern 6
980 * A weakness of pattern 0-5 is the inability to detect swaps/copies between
981 * any two 16-byte blocks except for the last 16-byte block in a 256-byte bloc.
982 * They work perfectly for detecting any swaps/aliasing of blocks >= 256 bytes.
983 * 0x5 and 0xa were picked because they are 0101 and 1010 binary.
984 * Patterns 8-9 are best for detecting swaps/aliasing of blocks < 256 bytes.
985 * Besides that, they provide for bit testing of the last two bytes of every
986 * 256 byte block which contains the block number for patterns 0-6.
987 * Patterns 10-11 are special purpose for detecting subblock aliasing with
988 * block sizes >256 bytes (some Dataflash chips etc.)
989 * AND Pattern 8/9 == Pattern 12
990 * AND Pattern 10/11 == Pattern 12
991 * Pattern 13 is the completely erased state.
992 * None of the patterns can detect aliasing at boundaries which are a multiple
993 * of 16 MBytes (but such chips do not exist anyway for Parallel/LPC/FWH/SPI).
994 */
995int generate_testpattern(uint8_t *buf, uint32_t size, int variant)
996{
997 int i;
998
999 if (!buf) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001000 msg_gerr("Invalid buffer!\n");
Carl-Daniel Hailfingereaac68b2009-11-23 12:55:31 +00001001 return 1;
1002 }
1003
1004 switch (variant) {
1005 case 0:
1006 for (i = 0; i < size; i++)
1007 buf[i] = (i & 0xf) << 4 | 0x5;
1008 break;
1009 case 1:
1010 for (i = 0; i < size; i++)
1011 buf[i] = (i & 0xf) << 4 | 0xa;
1012 break;
1013 case 2:
1014 for (i = 0; i < size; i++)
1015 buf[i] = 0x50 | (i & 0xf);
1016 break;
1017 case 3:
1018 for (i = 0; i < size; i++)
1019 buf[i] = 0xa0 | (i & 0xf);
1020 break;
1021 case 4:
1022 for (i = 0; i < size; i++)
1023 buf[i] = (i & 0xf) << 4;
1024 break;
1025 case 5:
1026 for (i = 0; i < size; i++)
1027 buf[i] = i & 0xf;
1028 break;
1029 case 6:
1030 memset(buf, 0x00, size);
1031 break;
1032 case 7:
1033 memset(buf, 0xff, size);
1034 break;
1035 case 8:
1036 for (i = 0; i < size; i++)
1037 buf[i] = i & 0xff;
1038 break;
1039 case 9:
1040 for (i = 0; i < size; i++)
1041 buf[i] = ~(i & 0xff);
1042 break;
1043 case 10:
1044 for (i = 0; i < size % 2; i++) {
1045 buf[i * 2] = (i >> 8) & 0xff;
1046 buf[i * 2 + 1] = i & 0xff;
1047 }
1048 if (size & 0x1)
1049 buf[i * 2] = (i >> 8) & 0xff;
1050 break;
1051 case 11:
1052 for (i = 0; i < size % 2; i++) {
1053 buf[i * 2] = ~((i >> 8) & 0xff);
1054 buf[i * 2 + 1] = ~(i & 0xff);
1055 }
1056 if (size & 0x1)
1057 buf[i * 2] = ~((i >> 8) & 0xff);
1058 break;
1059 case 12:
1060 memset(buf, 0x00, size);
1061 break;
1062 case 13:
1063 memset(buf, 0xff, size);
1064 break;
1065 }
1066
1067 if ((variant >= 0) && (variant <= 7)) {
1068 /* Write block number in the last two bytes of each 256-byte
1069 * block, big endian for easier reading of the hexdump.
1070 * Note that this wraps around for chips larger than 2^24 bytes
1071 * (16 MB).
1072 */
1073 for (i = 0; i < size / 256; i++) {
1074 buf[i * 256 + 254] = (i >> 8) & 0xff;
1075 buf[i * 256 + 255] = i & 0xff;
1076 }
1077 }
1078
1079 return 0;
1080}
1081
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001082int check_max_decode(enum chipbustype buses, uint32_t size)
1083{
1084 int limitexceeded = 0;
1085 if ((buses & CHIP_BUSTYPE_PARALLEL) &&
1086 (max_rom_decode.parallel < size)) {
1087 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001088 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001089 "size %u kB of chipset/board/programmer "
1090 "for %s interface, "
1091 "probe/read/erase/write may fail. ", size / 1024,
1092 max_rom_decode.parallel / 1024, "Parallel");
1093 }
1094 if ((buses & CHIP_BUSTYPE_LPC) && (max_rom_decode.lpc < size)) {
1095 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001096 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001097 "size %u kB of chipset/board/programmer "
1098 "for %s interface, "
1099 "probe/read/erase/write may fail. ", size / 1024,
1100 max_rom_decode.lpc / 1024, "LPC");
1101 }
1102 if ((buses & CHIP_BUSTYPE_FWH) && (max_rom_decode.fwh < size)) {
1103 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001104 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001105 "size %u kB of chipset/board/programmer "
1106 "for %s interface, "
1107 "probe/read/erase/write may fail. ", size / 1024,
1108 max_rom_decode.fwh / 1024, "FWH");
1109 }
1110 if ((buses & CHIP_BUSTYPE_SPI) && (max_rom_decode.spi < size)) {
1111 limitexceeded++;
Sean Nelson316a29f2010-05-07 20:09:04 +00001112 msg_pdbg("Chip size %u kB is bigger than supported "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001113 "size %u kB of chipset/board/programmer "
1114 "for %s interface, "
1115 "probe/read/erase/write may fail. ", size / 1024,
1116 max_rom_decode.spi / 1024, "SPI");
1117 }
1118 if (!limitexceeded)
1119 return 0;
1120 /* Sometimes chip and programmer have more than one bus in common,
1121 * and the limit is not exceeded on all buses. Tell the user.
1122 */
1123 if (bitcount(buses) > limitexceeded)
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001124 /* FIXME: This message is designed towards CLI users. */
Sean Nelson316a29f2010-05-07 20:09:04 +00001125 msg_pdbg("There is at least one common chip/programmer "
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001126 "interface which can support a chip of this size. "
1127 "You can try --force at your own risk.\n");
1128 return 1;
1129}
1130
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001131int probe_flash(int startchip, struct flashchip *fill_flash, int force)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001132{
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001133 const struct flashchip *flash;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001134 unsigned long base = 0;
Stefan Reinauer051e2362011-01-19 06:21:54 +00001135 char location[64];
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001136 uint32_t size;
1137 enum chipbustype buses_common;
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001138 char *tmp;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001139
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001140 for (flash = flashchips + startchip; flash && flash->name; flash++) {
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001141 if (chip_to_probe && strcmp(flash->name, chip_to_probe) != 0)
Ollie Lhocbbf1252004-03-17 22:22:08 +00001142 continue;
Stefan Taunerc0aaf952011-05-19 02:58:17 +00001143 msg_gdbg("Probing for %s %s, %d kB: ",
Stefan Reinauerac378972008-03-17 22:59:40 +00001144 flash->vendor, flash->name, flash->total_size);
Peter Stuge7ffbc6f2008-06-18 02:08:40 +00001145 if (!flash->probe && !force) {
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001146 msg_gdbg("failed! flashrom has no probe function for "
1147 "this flash chip.\n");
Peter Stugef31104c2008-04-28 14:47:30 +00001148 continue;
1149 }
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001150 buses_common = buses_supported & flash->bustype;
1151 if (!buses_common) {
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001152 tmp = flashbuses_to_text(buses_supported);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001153 msg_gdbg("skipped.");
1154 msg_gspew(" Host bus type %s ", tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001155 free(tmp);
1156 tmp = flashbuses_to_text(flash->bustype);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001157 msg_gspew("and chip bus type %s are incompatible.",
1158 tmp);
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001159 free(tmp);
Carl-Daniel Hailfinger12575e52010-03-22 23:43:51 +00001160 msg_gdbg("\n");
Carl-Daniel Hailfingerb22918c2009-06-01 02:08:58 +00001161 continue;
1162 }
Stefan Reinauer70385642007-04-06 11:58:03 +00001163
Ollie Lhocbbf1252004-03-17 22:22:08 +00001164 size = flash->total_size * 1024;
Carl-Daniel Hailfinger115d3902009-10-31 01:53:09 +00001165 check_max_decode(buses_common, size);
Stefan Reinauer70385642007-04-06 11:58:03 +00001166
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001167 /* Start filling in the dynamic data. */
1168 *fill_flash = *flash;
1169
Carl-Daniel Hailfinger97d6b092009-05-09 07:27:23 +00001170 base = flashbase ? flashbase : (0xffffffff - size + 1);
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001171 fill_flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001172
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001173 if (force)
1174 break;
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001175
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001176 if (fill_flash->probe(fill_flash) != 1)
Peter Stuge483b8f02008-09-03 23:10:05 +00001177 goto notfound;
1178
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001179 /* If this is the first chip found, accept it.
1180 * If this is not the first chip found, accept it only if it is
1181 * a non-generic match.
1182 * We could either make chipcount global or provide it as
1183 * parameter, or we assume that startchip==0 means this call to
1184 * probe_flash() is the first one and thus no chip has been
1185 * found before.
1186 */
1187 if (startchip == 0 || fill_flash->model_id != GENERIC_DEVICE_ID)
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001188 break;
1189
Peter Stuge483b8f02008-09-03 23:10:05 +00001190notfound:
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001191 programmer_unmap_flash_region((void *)fill_flash->virtual_memory, size);
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001192 }
Uwe Hermannffec5f32007-08-23 16:08:21 +00001193
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001194 if (!flash || !flash->name)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001195 return -1;
Peter Stuge27c3e2d2008-07-02 17:15:47 +00001196
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001197#if CONFIG_INTERNAL == 1
1198 if (programmer_table[programmer].map_flash_region == physmap)
Stefan Reinauer051e2362011-01-19 06:21:54 +00001199 snprintf(location, sizeof(location), "at physical address 0x%lx", base);
Carl-Daniel Hailfingerd9535582011-03-08 00:09:11 +00001200 else
1201#endif
Stefan Reinauer051e2362011-01-19 06:21:54 +00001202 snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name);
Stefan Reinauer051e2362011-01-19 06:21:54 +00001203
Stefan Taunerc0aaf952011-05-19 02:58:17 +00001204 msg_cinfo("%s chip \"%s %s\" (%d kB, %s) %s.\n",
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +00001205 force ? "Assuming" : "Found",
Uwe Hermann9899cad2009-06-28 21:47:57 +00001206 flash->vendor, flash->name, flash->total_size,
Stefan Reinauer051e2362011-01-19 06:21:54 +00001207 flashbuses_to_text(flash->bustype), location);
Uwe Hermann9899cad2009-06-28 21:47:57 +00001208
Carl-Daniel Hailfinger859f3f02010-12-02 21:59:42 +00001209 /* Flash registers will not be mapped if the chip was forced. Lock info
1210 * may be stored in registers, so avoid lock info printing.
1211 */
1212 if (!force)
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001213 if (fill_flash->printlock)
1214 fill_flash->printlock(fill_flash);
Sean Nelson6e0b9122010-02-19 00:52:10 +00001215
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001216 /* Return position of matching chip. */
1217 return flash - flashchips;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001218}
1219
Stefan Reinauere3705282005-12-18 16:41:10 +00001220int verify_flash(struct flashchip *flash, uint8_t *buf)
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001221{
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001222 int ret;
Ollie Lho761bf1b2004-03-20 16:46:10 +00001223 int total_size = flash->total_size * 1024;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001224
Sean Nelson316a29f2010-05-07 20:09:04 +00001225 msg_cinfo("Verifying flash... ");
Uwe Hermanna7e05482007-05-09 10:17:44 +00001226
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001227 ret = verify_range(flash, buf, 0, total_size, NULL);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001228
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001229 if (!ret)
Sean Nelson316a29f2010-05-07 20:09:04 +00001230 msg_cinfo("VERIFIED. \n");
Stefan Reinauerfcb63682006-03-16 16:57:41 +00001231
Carl-Daniel Hailfinger23290662009-06-24 08:20:45 +00001232 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001233}
1234
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001235int read_buf_from_file(unsigned char *buf, unsigned long size, char *filename)
1236{
1237 unsigned long numbytes;
1238 FILE *image;
1239 struct stat image_stat;
1240
1241 if ((image = fopen(filename, "rb")) == NULL) {
1242 perror(filename);
1243 return 1;
1244 }
1245 if (fstat(fileno(image), &image_stat) != 0) {
1246 perror(filename);
1247 fclose(image);
1248 return 1;
1249 }
1250 if (image_stat.st_size != size) {
1251 msg_gerr("Error: Image size doesn't match\n");
1252 fclose(image);
1253 return 1;
1254 }
1255 numbytes = fread(buf, 1, size, image);
1256 if (fclose(image)) {
1257 perror(filename);
1258 return 1;
1259 }
1260 if (numbytes != size) {
1261 msg_gerr("Error: Failed to read complete file. Got %ld bytes, "
1262 "wanted %ld!\n", numbytes, size);
1263 return 1;
1264 }
1265 return 0;
1266}
1267
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001268int write_buf_to_file(unsigned char *buf, unsigned long size, char *filename)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001269{
1270 unsigned long numbytes;
1271 FILE *image;
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001272
1273 if (!filename) {
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001274 msg_gerr("No filename specified.\n");
Stephan Guilloux21dd55b2009-06-01 22:07:52 +00001275 return 1;
1276 }
Patrick Georgi0bf842d2010-01-25 22:55:33 +00001277 if ((image = fopen(filename, "wb")) == NULL) {
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001278 perror(filename);
Carl-Daniel Hailfinger03b4e712009-05-08 12:49:03 +00001279 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001280 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001281
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001282 numbytes = fwrite(buf, 1, size, image);
1283 fclose(image);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001284 if (numbytes != size) {
1285 msg_gerr("File %s could not be written completely.\n",
1286 filename);
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001287 return 1;
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001288 }
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001289 return 0;
1290}
1291
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001292int read_flash_to_file(struct flashchip *flash, char *filename)
1293{
1294 unsigned long size = flash->total_size * 1024;
1295 unsigned char *buf = calloc(size, sizeof(char));
1296 int ret = 0;
1297
1298 msg_cinfo("Reading flash... ");
1299 if (!buf) {
1300 msg_gerr("Memory allocation failed!\n");
1301 msg_cinfo("FAILED.\n");
1302 return 1;
1303 }
1304 if (!flash->read) {
1305 msg_cerr("No read function available for this flash chip.\n");
1306 ret = 1;
1307 goto out_free;
1308 }
1309 if (flash->read(flash, buf, 0, size)) {
1310 msg_cerr("Read operation failed!\n");
1311 ret = 1;
1312 goto out_free;
1313 }
1314
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001315 ret = write_buf_to_file(buf, size, filename);
Carl-Daniel Hailfinger1748c572010-07-13 23:56:13 +00001316out_free:
1317 free(buf);
1318 msg_cinfo("%s.\n", ret ? "FAILED" : "done");
1319 return ret;
1320}
1321
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001322/* This function shares a lot of its structure with erase_and_write_flash() and
1323 * walk_eraseregions().
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001324 * Even if an error is found, the function will keep going and check the rest.
1325 */
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001326static int selfcheck_eraseblocks(const struct flashchip *flash)
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001327{
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001328 int i, j, k;
1329 int ret = 0;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001330
1331 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
1332 unsigned int done = 0;
1333 struct block_eraser eraser = flash->block_erasers[k];
1334
1335 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1336 /* Blocks with zero size are bugs in flashchips.c. */
1337 if (eraser.eraseblocks[i].count &&
1338 !eraser.eraseblocks[i].size) {
1339 msg_gerr("ERROR: Flash chip %s erase function "
1340 "%i region %i has size 0. Please report"
1341 " a bug at flashrom@flashrom.org\n",
1342 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001343 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001344 }
1345 /* Blocks with zero count are bugs in flashchips.c. */
1346 if (!eraser.eraseblocks[i].count &&
1347 eraser.eraseblocks[i].size) {
1348 msg_gerr("ERROR: Flash chip %s erase function "
1349 "%i region %i has count 0. Please report"
1350 " a bug at flashrom@flashrom.org\n",
1351 flash->name, k, i);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001352 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001353 }
1354 done += eraser.eraseblocks[i].count *
1355 eraser.eraseblocks[i].size;
1356 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001357 /* Empty eraseblock definition with erase function. */
1358 if (!done && eraser.block_erase)
Sean Nelson316a29f2010-05-07 20:09:04 +00001359 msg_gspew("Strange: Empty eraseblock definition with "
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001360 "non-empty erase function. Not an error.\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001361 if (!done)
1362 continue;
1363 if (done != flash->total_size * 1024) {
1364 msg_gerr("ERROR: Flash chip %s erase function %i "
1365 "region walking resulted in 0x%06x bytes total,"
1366 " expected 0x%06x bytes. Please report a bug at"
1367 " flashrom@flashrom.org\n", flash->name, k,
1368 done, flash->total_size * 1024);
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001369 ret = 1;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001370 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001371 if (!eraser.block_erase)
1372 continue;
1373 /* Check if there are identical erase functions for different
1374 * layouts. That would imply "magic" erase functions. The
1375 * easiest way to check this is with function pointers.
1376 */
Uwe Hermann43959702010-03-13 17:28:29 +00001377 for (j = k + 1; j < NUM_ERASEFUNCTIONS; j++) {
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001378 if (eraser.block_erase ==
1379 flash->block_erasers[j].block_erase) {
1380 msg_gerr("ERROR: Flash chip %s erase function "
1381 "%i and %i are identical. Please report"
1382 " a bug at flashrom@flashrom.org\n",
1383 flash->name, k, j);
1384 ret = 1;
1385 }
Uwe Hermann43959702010-03-13 17:28:29 +00001386 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001387 }
Carl-Daniel Hailfinger415afcf2010-01-19 06:42:46 +00001388 return ret;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001389}
1390
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001391static int erase_and_write_block_helper(struct flashchip *flash,
1392 unsigned int start, unsigned int len,
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001393 uint8_t *curcontents,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001394 uint8_t *newcontents,
1395 int (*erasefn) (struct flashchip *flash,
1396 unsigned int addr,
1397 unsigned int len))
1398{
1399 int starthere = 0;
1400 int lenhere = 0;
1401 int ret = 0;
1402 int skip = 1;
1403 int writecount = 0;
1404 enum write_granularity gran = write_gran_256bytes; /* FIXME */
1405
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001406 /* curcontents and newcontents are opaque to walk_eraseregions, and
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001407 * need to be adjusted here to keep the impression of proper abstraction
1408 */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001409 curcontents += start;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001410 newcontents += start;
1411 msg_cdbg(":");
1412 /* FIXME: Assume 256 byte granularity for now to play it safe. */
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001413 if (need_erase(curcontents, newcontents, len, gran)) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001414 msg_cdbg("E");
1415 ret = erasefn(flash, start, len);
1416 if (ret)
1417 return ret;
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001418 /* Erase was successful. Adjust curcontents. */
1419 memset(curcontents, 0xff, len);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001420 skip = 0;
1421 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001422 /* get_next_write() sets starthere to a new value after the call. */
1423 while ((lenhere = get_next_write(curcontents + starthere,
1424 newcontents + starthere,
1425 len - starthere, &starthere, gran))) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001426 if (!writecount++)
1427 msg_cdbg("W");
1428 /* Needs the partial write function signature. */
1429 ret = flash->write(flash, newcontents + starthere,
1430 start + starthere, lenhere);
1431 if (ret)
1432 return ret;
1433 starthere += lenhere;
1434 skip = 0;
1435 }
1436 if (skip)
1437 msg_cdbg("S");
1438 return ret;
1439}
1440
Carl-Daniel Hailfinger4d3e9ca2010-07-13 00:42:00 +00001441static int walk_eraseregions(struct flashchip *flash, int erasefunction,
1442 int (*do_something) (struct flashchip *flash,
1443 unsigned int addr,
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001444 unsigned int len,
1445 uint8_t *param1,
1446 uint8_t *param2,
1447 int (*erasefn) (
1448 struct flashchip *flash,
1449 unsigned int addr,
1450 unsigned int len)),
1451 void *param1, void *param2)
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001452{
1453 int i, j;
1454 unsigned int start = 0;
1455 unsigned int len;
1456 struct block_eraser eraser = flash->block_erasers[erasefunction];
1457 for (i = 0; i < NUM_ERASEREGIONS; i++) {
1458 /* count==0 for all automatically initialized array
1459 * members so the loop below won't be executed for them.
1460 */
1461 len = eraser.eraseblocks[i].size;
1462 for (j = 0; j < eraser.eraseblocks[i].count; j++) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001463 /* Print this for every block except the first one. */
1464 if (i || j)
1465 msg_cdbg(", ");
1466 msg_cdbg("0x%06x-0x%06x", start,
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001467 start + len - 1);
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001468 if (do_something(flash, start, len, param1, param2,
1469 eraser.block_erase)) {
1470 msg_cdbg("\n");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001471 return 1;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001472 }
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001473 start += len;
1474 }
1475 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001476 msg_cdbg("\n");
Carl-Daniel Hailfingera1223412010-07-13 00:37:19 +00001477 return 0;
1478}
1479
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001480static int check_block_eraser(struct flashchip *flash, int k, int log)
1481{
1482 struct block_eraser eraser = flash->block_erasers[k];
1483
1484 if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
1485 if (log)
1486 msg_cdbg("not defined. ");
1487 return 1;
1488 }
1489 if (!eraser.block_erase && eraser.eraseblocks[0].count) {
1490 if (log)
1491 msg_cdbg("eraseblock layout is known, but matching "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001492 "block erase function is not implemented. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001493 return 1;
1494 }
1495 if (eraser.block_erase && !eraser.eraseblocks[0].count) {
1496 if (log)
1497 msg_cdbg("block erase function found, but "
Stefan Tauner355cbfd2011-05-28 02:37:14 +00001498 "eraseblock layout is not defined. ");
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001499 return 1;
1500 }
1501 return 0;
1502}
1503
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001504int erase_and_write_flash(struct flashchip *flash, uint8_t *oldcontents, uint8_t *newcontents)
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001505{
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001506 int k, ret = 0;
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001507 uint8_t *curcontents;
1508 unsigned long size = flash->total_size * 1024;
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001509 int usable_erasefunctions = 0;
1510
1511 for (k = 0; k < NUM_ERASEFUNCTIONS; k++)
1512 if (!check_block_eraser(flash, k, 0))
1513 usable_erasefunctions++;
1514 msg_cinfo("Erasing and writing flash chip... ");
1515 if (!usable_erasefunctions) {
1516 msg_cerr("ERROR: flashrom has no erase function for this flash "
1517 "chip.\n");
1518 return 1;
1519 }
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001520
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001521 curcontents = (uint8_t *) malloc(size);
1522 /* Copy oldcontents to curcontents to avoid clobbering oldcontents. */
1523 memcpy(curcontents, oldcontents, size);
1524
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001525 for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001526 msg_cdbg("Looking at blockwise erase function %i... ", k);
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001527 if (check_block_eraser(flash, k, 1) && usable_erasefunctions) {
1528 msg_cdbg("Looking for another erase function.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001529 continue;
1530 }
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001531 usable_erasefunctions--;
Sean Nelson316a29f2010-05-07 20:09:04 +00001532 msg_cdbg("trying... ");
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001533 ret = walk_eraseregions(flash, k, &erase_and_write_block_helper, curcontents, newcontents);
Sean Nelson316a29f2010-05-07 20:09:04 +00001534 msg_cdbg("\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001535 /* If everything is OK, don't try another erase function. */
1536 if (!ret)
1537 break;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001538 /* Write/erase failed, so try to find out what the current chip
1539 * contents are. If no usable erase functions remain, we could
1540 * abort the loop instead of continuing, the effect is the same.
1541 * The only difference is whether the reason for other unusable
1542 * functions is printed or not. If in doubt, verbosity wins.
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001543 */
Carl-Daniel Hailfingerdce73ae2010-12-05 15:14:44 +00001544 if (!usable_erasefunctions)
1545 continue;
Carl-Daniel Hailfingerb23b1eb2010-12-02 02:41:55 +00001546 if (flash->read(flash, curcontents, 0, size)) {
1547 /* Now we are truly screwed. Read failed as well. */
1548 msg_cerr("Can't read anymore!\n");
1549 /* We have no idea about the flash chip contents, so
1550 * retrying with another erase function is pointless.
1551 */
1552 break;
1553 }
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001554 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001555 /* Free the scratchpad. */
1556 free(curcontents);
Carl-Daniel Hailfingerf160a122009-05-08 17:15:15 +00001557
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001558 if (ret) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001559 msg_cerr("FAILED!\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001560 } else {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001561 msg_cinfo("Done.\n");
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +00001562 }
1563 return ret;
Carl-Daniel Hailfinger7314cc32009-01-28 00:27:54 +00001564}
1565
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001566void nonfatal_help_message(void)
1567{
1568 msg_gerr("Writing to the flash chip apparently didn't do anything.\n"
1569 "This means we have to add special support for your board, "
1570 "programmer or flash chip.\n"
1571 "Please report this on IRC at irc.freenode.net (channel "
1572 "#flashrom) or\n"
1573 "mail flashrom@flashrom.org!\n"
1574 "-------------------------------------------------------------"
1575 "------------------\n"
1576 "You may now reboot or simply leave the machine running.\n");
1577}
1578
Uwe Hermannc67d0372009-10-01 18:40:02 +00001579void emergency_help_message(void)
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001580{
Sean Nelson316a29f2010-05-07 20:09:04 +00001581 msg_gerr("Your flash chip is in an unknown state.\n"
Uwe Hermannc67d0372009-10-01 18:40:02 +00001582 "Get help on IRC at irc.freenode.net (channel #flashrom) or\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001583 "mail flashrom@flashrom.org with FAILED: your board name in "
1584 "the subject line!\n"
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001585 "-------------------------------------------------------------"
1586 "------------------\n"
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001587 "DO NOT REBOOT OR POWEROFF!\n");
1588}
1589
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001590/* The way to go if you want a delimited list of programmers*/
1591void list_programmers(char *delim)
1592{
1593 enum programmer p;
1594 for (p = 0; p < PROGRAMMER_INVALID; p++) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001595 msg_ginfo("%s", programmer_table[p].name);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001596 if (p < PROGRAMMER_INVALID - 1)
Sean Nelson316a29f2010-05-07 20:09:04 +00001597 msg_ginfo("%s", delim);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001598 }
Sean Nelson316a29f2010-05-07 20:09:04 +00001599 msg_ginfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001600}
1601
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +00001602void list_programmers_linebreak(int startcol, int cols, int paren)
1603{
1604 const char *pname;
1605 int pnamelen;
1606 int remaining = 0;
1607 int firstline = 1;
1608 enum programmer p;
1609 int i;
1610
1611 for (p = 0; p < PROGRAMMER_INVALID; p++) {
1612 pname = programmer_table[p].name;
1613 pnamelen = strlen(pname);
1614 if (remaining - pnamelen - 2 < 0) {
1615 if (firstline)
1616 firstline = 0;
1617 else
1618 printf("\n");
1619 for (i = 0; i < startcol; i++)
1620 printf(" ");
1621 remaining = cols - startcol;
1622 } else {
1623 printf(" ");
1624 remaining--;
1625 }
1626 if (paren && (p == 0)) {
1627 printf("(");
1628 remaining--;
1629 }
1630 printf("%s", pname);
1631 remaining -= pnamelen;
1632 if (p < PROGRAMMER_INVALID - 1) {
1633 printf(",");
1634 remaining--;
1635 } else {
1636 if (paren)
1637 printf(")");
1638 printf("\n");
1639 }
1640 }
1641}
1642
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001643void print_sysinfo(void)
1644{
1645#if HAVE_UTSNAME == 1
1646 struct utsname osinfo;
1647 uname(&osinfo);
1648
1649 msg_ginfo(" on %s %s (%s)", osinfo.sysname, osinfo.release,
1650 osinfo.machine);
1651#else
1652 msg_ginfo(" on unknown machine");
1653#endif
1654 msg_ginfo(", built with");
1655#if NEED_PCI == 1
1656#ifdef PCILIB_VERSION
1657 msg_ginfo(" libpci %s,", PCILIB_VERSION);
1658#else
1659 msg_ginfo(" unknown PCI library,");
1660#endif
1661#endif
1662#ifdef __clang__
Carl-Daniel Hailfingerb51e58e2010-07-17 14:49:30 +00001663 msg_ginfo(" LLVM Clang");
1664#ifdef __clang_version__
1665 msg_ginfo(" %s,", __clang_version__);
1666#else
1667 msg_ginfo(" unknown version (before r102686),");
1668#endif
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001669#elif defined(__GNUC__)
1670 msg_ginfo(" GCC");
1671#ifdef __VERSION__
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001672 msg_ginfo(" %s,", __VERSION__);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001673#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001674 msg_ginfo(" unknown version,");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001675#endif
1676#else
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +00001677 msg_ginfo(" unknown compiler,");
1678#endif
1679#if defined (__FLASHROM_LITTLE_ENDIAN__)
1680 msg_ginfo(" little endian");
1681#else
1682 msg_ginfo(" big endian");
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001683#endif
1684 msg_ginfo("\n");
1685}
1686
Bernhard Walle201bde32008-01-21 15:24:22 +00001687void print_version(void)
1688{
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001689 msg_ginfo("flashrom v%s", flashrom_version);
Carl-Daniel Hailfinger132e2ec2010-03-27 16:36:40 +00001690 print_sysinfo();
Bernhard Walle201bde32008-01-21 15:24:22 +00001691}
1692
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001693void print_banner(void)
1694{
1695 msg_ginfo("flashrom is free software, get the source code at "
1696 "http://www.flashrom.org\n");
1697 msg_ginfo("\n");
1698}
1699
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001700int selfcheck(void)
1701{
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001702 int ret = 0;
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001703 const struct flashchip *flash;
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001704
1705 /* Safety check. Instead of aborting after the first error, check
1706 * if more errors exist.
1707 */
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001708 if (ARRAY_SIZE(programmer_table) - 1 != PROGRAMMER_INVALID) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001709 msg_gerr("Programmer table miscompilation!\n");
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001710 ret = 1;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001711 }
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001712 /* It would be favorable if we could also check for correct terminaion
1713 * of the follwing arrays, but we don't know their size in here...
1714 * For 'flashchips' we check the first element to be non-null. In the
1715 * other cases there exist use cases where the first element can be
1716 * null. */
1717 if (flashchips == NULL || flashchips[0].vendor == NULL) {
1718 msg_gerr("Flashchips table miscompilation!\n");
1719 ret = 1;
1720 }
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001721 for (flash = flashchips; flash && flash->name; flash++)
1722 if (selfcheck_eraseblocks(flash))
1723 ret = 1;
Stefan Tauner7bcacb12011-05-26 01:35:19 +00001724
1725#if CONFIG_INTERNAL == 1
1726 if (chipset_enables == NULL) {
1727 msg_gerr("Chipset enables table does not exist!\n");
1728 ret = 1;
1729 }
1730 if (board_pciid_enables == NULL) {
1731 msg_gerr("Board enables table does not exist!\n");
1732 ret = 1;
1733 }
1734 if (boards_known == NULL) {
1735 msg_gerr("Known boards table does not exist!\n");
1736 ret = 1;
1737 }
1738 if (laptops_known == NULL) {
1739 msg_gerr("Known laptops table does not exist!\n");
1740 ret = 1;
1741 }
1742#endif // CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger293adf02010-01-18 08:14:43 +00001743 return ret;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001744}
1745
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +00001746void check_chip_supported(const struct flashchip *flash)
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001747{
1748 if (TEST_OK_MASK != (flash->tested & TEST_OK_MASK)) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001749 msg_cinfo("===\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001750 if (flash->tested & TEST_BAD_MASK) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001751 msg_cinfo("This flash part has status NOT WORKING for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001752 if (flash->tested & TEST_BAD_PROBE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001753 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001754 if (flash->tested & TEST_BAD_READ)
Sean Nelson316a29f2010-05-07 20:09:04 +00001755 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001756 if (flash->tested & TEST_BAD_ERASE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001757 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001758 if (flash->tested & TEST_BAD_WRITE)
Sean Nelson316a29f2010-05-07 20:09:04 +00001759 msg_cinfo(" WRITE");
1760 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001761 }
1762 if ((!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE)) ||
1763 (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ)) ||
1764 (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE)) ||
1765 (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))) {
Sean Nelson316a29f2010-05-07 20:09:04 +00001766 msg_cinfo("This flash part has status UNTESTED for operations:");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001767 if (!(flash->tested & TEST_BAD_PROBE) && !(flash->tested & TEST_OK_PROBE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001768 msg_cinfo(" PROBE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001769 if (!(flash->tested & TEST_BAD_READ) && !(flash->tested & TEST_OK_READ))
Sean Nelson316a29f2010-05-07 20:09:04 +00001770 msg_cinfo(" READ");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001771 if (!(flash->tested & TEST_BAD_ERASE) && !(flash->tested & TEST_OK_ERASE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001772 msg_cinfo(" ERASE");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001773 if (!(flash->tested & TEST_BAD_WRITE) && !(flash->tested & TEST_OK_WRITE))
Sean Nelson316a29f2010-05-07 20:09:04 +00001774 msg_cinfo(" WRITE");
1775 msg_cinfo("\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001776 }
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001777 /* FIXME: This message is designed towards CLI users. */
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +00001778 msg_cinfo("The test status of this chip may have been updated "
1779 "in the latest development\n"
1780 "version of flashrom. If you are running the latest "
1781 "development version,\n"
1782 "please email a report to flashrom@flashrom.org if "
1783 "any of the above operations\n"
1784 "work correctly for you with this flash part. Please "
1785 "include the flashrom\n"
1786 "output with the additional -V option for all "
1787 "operations you tested (-V, -Vr,\n"
1788 "-Vw, -VE), and mention which mainboard or "
1789 "programmer you tested.\n"
Paul Menzelab6328f2010-10-08 11:03:02 +00001790 "Please mention your board in the subject line. "
1791 "Thanks for your help!\n");
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001792 }
1793}
1794
Ollie Lho761bf1b2004-03-20 16:46:10 +00001795int main(int argc, char *argv[])
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001796{
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +00001797 return cli_classic(argc, argv);
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001798}
1799
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001800/* FIXME: This function signature needs to be improved once doit() has a better
1801 * function signature.
1802 */
David Hendricks77f931a2011-05-18 01:30:56 +00001803int chip_safety_check(struct flashchip *flash, int force, int read_it, int write_it, int erase_it, int verify_it)
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001804{
1805 if (!programmer_may_write && (write_it || erase_it)) {
1806 msg_perr("Write/erase is not working yet on your programmer in "
1807 "its current configuration.\n");
1808 /* --force is the wrong approach, but it's the best we can do
1809 * until the generic programmer parameter parser is merged.
1810 */
1811 if (!force)
1812 return 1;
1813 msg_cerr("Continuing anyway.\n");
1814 }
1815
1816 if (read_it || erase_it || write_it || verify_it) {
1817 /* Everything needs read. */
1818 if (flash->tested & TEST_BAD_READ) {
1819 msg_cerr("Read is not working on this chip. ");
1820 if (!force)
1821 return 1;
1822 msg_cerr("Continuing anyway.\n");
1823 }
1824 if (!flash->read) {
1825 msg_cerr("flashrom has no read function for this "
1826 "flash chip.\n");
1827 return 1;
1828 }
1829 }
1830 if (erase_it || write_it) {
1831 /* Write needs erase. */
1832 if (flash->tested & TEST_BAD_ERASE) {
1833 msg_cerr("Erase is not working on this chip. ");
1834 if (!force)
1835 return 1;
1836 msg_cerr("Continuing anyway.\n");
1837 }
1838 /* FIXME: Check if at least one erase function exists. */
1839 }
1840 if (write_it) {
1841 if (flash->tested & TEST_BAD_WRITE) {
1842 msg_cerr("Write is not working on this chip. ");
1843 if (!force)
1844 return 1;
1845 msg_cerr("Continuing anyway.\n");
1846 }
1847 if (!flash->write) {
1848 msg_cerr("flashrom has no write function for this "
1849 "flash chip.\n");
1850 return 1;
1851 }
1852 }
1853 return 0;
1854}
1855
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001856/* This function signature is horrible. We need to design a better interface,
1857 * but right now it allows us to split off the CLI code.
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001858 * Besides that, the function itself is a textbook example of abysmal code flow.
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001859 */
1860int doit(struct flashchip *flash, int force, char *filename, int read_it, int write_it, int erase_it, int verify_it)
1861{
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001862 uint8_t *oldcontents;
1863 uint8_t *newcontents;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001864 int ret = 0;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001865 unsigned long size = flash->total_size * 1024;
Carl-Daniel Hailfinger552420b2009-12-24 02:15:55 +00001866
David Hendricks77f931a2011-05-18 01:30:56 +00001867 if (chip_safety_check(flash, force, read_it, write_it, erase_it, verify_it)) {
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001868 msg_cerr("Aborting.\n");
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001869 ret = 1;
1870 goto out_nofree;
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001871 }
1872
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001873 /* Given the existence of read locks, we want to unlock for read,
1874 * erase and write.
1875 */
1876 if (flash->unlock)
1877 flash->unlock(flash);
1878
1879 if (read_it) {
1880 ret = read_flash_to_file(flash, filename);
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001881 goto out_nofree;
Carl-Daniel Hailfingerd1be52d2010-07-03 12:14:25 +00001882 }
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001883
1884 oldcontents = (uint8_t *) malloc(size);
1885 /* Assume worst case: All bits are 0. */
1886 memset(oldcontents, 0x00, size);
1887 newcontents = (uint8_t *) malloc(size);
1888 /* Assume best case: All bits should be 1. */
1889 memset(newcontents, 0xff, size);
1890 /* Side effect of the assumptions above: Default write action is erase
1891 * because newcontents looks like a completely erased chip, and
1892 * oldcontents being completely 0x00 means we have to erase everything
1893 * before we can write.
1894 */
1895
Ollie Lhoefa28582004-12-08 20:10:01 +00001896 if (erase_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001897 /* FIXME: Do we really want the scary warning if erase failed?
1898 * After all, after erase the chip is either blank or partially
1899 * blank or it has the old contents. A blank chip won't boot,
1900 * so if the user wanted erase and reboots afterwards, the user
1901 * knows very well that booting won't work.
1902 */
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001903 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001904 emergency_help_message();
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001905 ret = 1;
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001906 }
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001907 goto out;
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001908 }
Carl-Daniel Hailfinger43069442010-10-15 00:01:14 +00001909
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001910 if (write_it || verify_it) {
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001911 if (read_buf_from_file(newcontents, size, filename)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001912 ret = 1;
1913 goto out;
Stefan Reinauer018aca82006-11-21 23:48:51 +00001914 }
1915
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +00001916#if CONFIG_INTERNAL == 1
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001917 if (programmer == PROGRAMMER_INTERNAL)
1918 show_id(newcontents, size, force);
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +00001919#endif
Ollie Lhocbbf1252004-03-17 22:22:08 +00001920 }
1921
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001922 /* Read the whole chip to be able to check whether regions need to be
1923 * erased and to give better diagnostics in case write fails.
1924 * The alternative would be to read only the regions which are to be
1925 * preserved, but in that case we might perform unneeded erase which
1926 * takes time as well.
1927 */
1928 msg_cdbg("Reading old flash chip contents...\n");
1929 if (flash->read(flash, oldcontents, 0, size)) {
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001930 ret = 1;
1931 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001932 }
1933
Ollie Lho184a4042005-11-26 21:55:36 +00001934 // This should be moved into each flash part's code to do it
1935 // cleanly. This does the job.
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001936 handle_romentries(flash, oldcontents, newcontents);
Uwe Hermanna7e05482007-05-09 10:17:44 +00001937
Ollie Lho184a4042005-11-26 21:55:36 +00001938 // ////////////////////////////////////////////////////////////
Uwe Hermanna7e05482007-05-09 10:17:44 +00001939
Peter Stugef31104c2008-04-28 14:47:30 +00001940 if (write_it) {
Carl-Daniel Hailfinger6e2ea322010-11-04 01:04:27 +00001941 if (erase_and_write_flash(flash, oldcontents, newcontents)) {
1942 msg_cerr("Uh oh. Erase/write failed. Checking if "
1943 "anything changed.\n");
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001944 if (!flash->read(flash, newcontents, 0, size)) {
1945 if (!memcmp(oldcontents, newcontents, size)) {
1946 msg_cinfo("Good. It seems nothing was "
1947 "changed.\n");
1948 nonfatal_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001949 ret = 1;
1950 goto out;
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001951 }
1952 }
Carl-Daniel Hailfingerf52f7842010-10-08 18:52:29 +00001953 emergency_help_message();
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001954 ret = 1;
1955 goto out;
Peter Stugef31104c2008-04-28 14:47:30 +00001956 }
Peter Stugef31104c2008-04-28 14:47:30 +00001957 }
Ollie Lho184a4042005-11-26 21:55:36 +00001958
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001959 if (verify_it) {
1960 /* Work around chips which need some time to calm down. */
1961 if (write_it)
1962 programmer_delay(1000*1000);
Carl-Daniel Hailfinger42d38a92010-10-19 22:06:20 +00001963 ret = verify_flash(flash, newcontents);
Carl-Daniel Hailfingerf5292052009-11-17 09:57:34 +00001964 /* If we tried to write, and verification now fails, we
Carl-Daniel Hailfinger8ab49e72009-08-19 13:55:34 +00001965 * might have an emergency situation.
1966 */
1967 if (ret && write_it)
1968 emergency_help_message();
1969 }
Ollie Lho184a4042005-11-26 21:55:36 +00001970
Carl-Daniel Hailfinger12d6d822010-11-05 14:51:59 +00001971out:
1972 free(oldcontents);
1973 free(newcontents);
1974out_nofree:
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00001975 programmer_shutdown();
Stefan Reinauer143da0b2006-01-04 16:42:57 +00001976 return ret;
Ronald G. Minnichf4cf2ba2002-01-29 18:26:26 +00001977}