blob: 01ff5cd6ccc52df026ee9150233c90f2916ba34d [file] [log] [blame]
Adam Kaufman064b1f22007-02-06 19:47:50 +00001/*
Uwe Hermannd1107642007-08-29 17:52:32 +00002 * This file is part of the flashrom project.
Adam Kaufman064b1f22007-02-06 19:47:50 +00003 *
Uwe Hermannd22a1d42007-09-09 20:21:05 +00004 * Copyright (C) 2000 Silicon Integrated System Corporation
5 * Copyright (C) 2000 Ronald G. Minnich <rminnich@gmail.com>
Stefan Reinauer8fa64812009-08-12 09:27:45 +00006 * Copyright (C) 2005-2009 coresystems GmbH
Carl-Daniel Hailfingera0a6ae92009-06-15 12:10:57 +00007 * Copyright (C) 2006-2009 Carl-Daniel Hailfinger
Adam Kaufman064b1f22007-02-06 19:47:50 +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.
Adam Kaufman064b1f22007-02-06 19:47:50 +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.
Adam Kaufman064b1f22007-02-06 19:47:50 +000018 */
19
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +000020#ifndef __FLASH_H__
21#define __FLASH_H__ 1
22
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000023#include "platform.h"
24
Stefan Tauner0466c812013-06-16 10:30:08 +000025#include <inttypes.h>
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +000026#include <stdio.h>
Ollie Lho184a4042005-11-26 21:55:36 +000027#include <stdint.h>
Carl-Daniel Hailfingerdd128c92010-06-03 00:49:50 +000028#include <stddef.h>
Nico Huber18781102012-12-10 13:34:12 +000029#include <stdarg.h>
Stefan Tauner682122b2013-06-23 22:15:39 +000030#include <stdbool.h>
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000031#if IS_WINDOWS
Patrick Georgie48654c2010-01-06 22:14:39 +000032#include <windows.h>
33#undef min
34#undef max
35#endif
Andriy Gapon65c1b862008-05-22 13:22:45 +000036
Nico Huberd152fb92017-06-19 12:57:10 +020037#include "libflashrom.h"
Nico Huber3a9939b2016-04-27 15:56:14 +020038#include "layout.h"
39
Patrick Georgied7a9642010-09-25 22:53:44 +000040#define ERROR_PTR ((void*)-1)
41
Carl-Daniel Hailfinger174f55b2010-10-08 00:37:55 +000042/* Error codes */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +000043#define ERROR_OOM -100
Carl-Daniel Hailfinger174f55b2010-10-08 00:37:55 +000044#define TIMEOUT_ERROR -101
45
Stefan Taunerc2333752013-07-13 23:31:37 +000046/* TODO: check using code for correct usage of types */
47typedef uintptr_t chipaddr;
Stefan Tauner305e0b92013-07-17 23:46:44 +000048#define PRIxPTR_WIDTH ((int)(sizeof(uintptr_t)*2))
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +000049
David Hendricks8bb20212011-06-14 01:35:36 +000050int register_shutdown(int (*function) (void *data), void *data);
Stefan Tauner2a1ed772014-08-31 00:09:21 +000051int shutdown_free(void *data);
Stefan Tauner305e0b92013-07-17 23:46:44 +000052void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len);
Uwe Hermann09e04f72009-05-16 22:36:00 +000053void programmer_unmap_flash_region(void *virt_addr, size_t len);
Stefan Taunerf80419c2014-05-02 15:41:42 +000054void programmer_delay(unsigned int usecs);
Carl-Daniel Hailfinger61a8bd22009-03-05 19:24:22 +000055
Uwe Hermanne5ac1642008-03-12 11:54:51 +000056#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
57
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +000058enum chipbustype {
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +000059 BUS_NONE = 0,
60 BUS_PARALLEL = 1 << 0,
61 BUS_LPC = 1 << 1,
62 BUS_FWH = 1 << 2,
63 BUS_SPI = 1 << 3,
Carl-Daniel Hailfinger532c7172011-11-04 21:35:26 +000064 BUS_PROG = 1 << 4,
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +000065 BUS_NONSPI = BUS_PARALLEL | BUS_LPC | BUS_FWH,
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +000066};
67
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +000068/*
Stefan Tauner02437452013-04-01 19:34:53 +000069 * The following enum defines possible write granularities of flash chips. These tend to reflect the properties
70 * of the actual hardware not necesserily the write function(s) defined by the respective struct flashchip.
71 * The latter might (and should) be more precisely specified, e.g. they might bail out early if their execution
72 * would result in undefined chip contents.
Stefan Taunereb582572012-09-21 12:52:50 +000073 */
74enum write_granularity {
Stefan Tauner02437452013-04-01 19:34:53 +000075 /* We assume 256 byte granularity by default. */
76 write_gran_256bytes = 0,/* If less than 256 bytes are written, the unwritten bytes are undefined. */
77 write_gran_1bit, /* Each bit can be cleared individually. */
78 write_gran_1byte, /* A byte can be written once. Further writes to an already written byte cause
79 * its contents to be either undefined or to stay unchanged. */
Paul Kocialkowskic8305e12015-10-16 02:16:20 +000080 write_gran_128bytes, /* If less than 128 bytes are written, the unwritten bytes are undefined. */
Stefan Tauner02437452013-04-01 19:34:53 +000081 write_gran_264bytes, /* If less than 264 bytes are written, the unwritten bytes are undefined. */
82 write_gran_512bytes, /* If less than 512 bytes are written, the unwritten bytes are undefined. */
83 write_gran_528bytes, /* If less than 528 bytes are written, the unwritten bytes are undefined. */
84 write_gran_1024bytes, /* If less than 1024 bytes are written, the unwritten bytes are undefined. */
85 write_gran_1056bytes, /* If less than 1056 bytes are written, the unwritten bytes are undefined. */
Carl-Daniel Hailfinger1b0e9fc2014-06-16 22:36:17 +000086 write_gran_1byte_implicit_erase, /* EEPROMs and other chips with implicit erase and 1-byte writes. */
Stefan Taunereb582572012-09-21 12:52:50 +000087};
88
89/*
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +000090 * How many different contiguous runs of erase blocks with one size each do
91 * we have for a given erase function?
92 */
93#define NUM_ERASEREGIONS 5
94
95/*
96 * How many different erase functions do we have per chip?
Nico Huberaac81422017-11-10 22:54:13 +010097 * Macronix MX25L25635F has 8 different functions.
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +000098 */
Nico Huberaac81422017-11-10 22:54:13 +010099#define NUM_ERASEFUNCTIONS 8
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000100
Stefan Tauner0554ca52013-07-25 22:54:25 +0000101/* Feature bits used for non-SPI only */
Carl-Daniel Hailfinger4bf4e792010-01-09 03:15:50 +0000102#define FEATURE_REGISTERMAP (1 << 0)
Sean Nelson35727f72010-01-28 23:55:12 +0000103#define FEATURE_LONG_RESET (0 << 4)
104#define FEATURE_SHORT_RESET (1 << 4)
105#define FEATURE_EITHER_RESET FEATURE_LONG_RESET
Sean Nelsonf59e2632010-10-20 21:13:19 +0000106#define FEATURE_RESET_MASK (FEATURE_LONG_RESET | FEATURE_SHORT_RESET)
Carl-Daniel Hailfinger4bf4e792010-01-09 03:15:50 +0000107#define FEATURE_ADDR_FULL (0 << 2)
108#define FEATURE_ADDR_MASK (3 << 2)
Sean Nelson35727f72010-01-28 23:55:12 +0000109#define FEATURE_ADDR_2AA (1 << 2)
110#define FEATURE_ADDR_AAA (2 << 2)
Michael Karcherad0010a2010-04-03 10:27:08 +0000111#define FEATURE_ADDR_SHIFTED (1 << 5)
Stefan Tauner0554ca52013-07-25 22:54:25 +0000112/* Feature bits used for SPI only */
Carl-Daniel Hailfingerfd7075a2010-07-29 13:09:18 +0000113#define FEATURE_WRSR_EWSR (1 << 6)
114#define FEATURE_WRSR_WREN (1 << 7)
Stefan Tauner0554ca52013-07-25 22:54:25 +0000115#define FEATURE_WRSR_EITHER (FEATURE_WRSR_EWSR | FEATURE_WRSR_WREN)
Daniel Lenski65922a32012-02-15 23:40:23 +0000116#define FEATURE_OTP (1 << 8)
Vincent Palatinf800f552013-03-15 02:03:16 +0000117#define FEATURE_QPI (1 << 9)
Nico Huberfe34d2a2017-11-10 21:10:20 +0100118#define FEATURE_4BA_ENTER (1 << 10) /**< Can enter/exit 4BA mode with instructions 0xb7/0xe9 w/o WREN */
119#define FEATURE_4BA_ENTER_WREN (1 << 11) /**< Can enter/exit 4BA mode with instructions 0xb7/0xe9 after WREN */
120#define FEATURE_4BA_EXT_ADDR (1 << 12) /**< Regular 3-byte operations can be used by writing the most
Nico Huberf43c6542017-10-14 17:47:28 +0200121 significant address byte into an extended address register. */
Nico Huberfe34d2a2017-11-10 21:10:20 +0100122#define FEATURE_4BA_READ (1 << 13) /**< Native 4BA read instruction (0x13) is supported. */
Nico Huberaac81422017-11-10 22:54:13 +0100123#define FEATURE_4BA_FAST_READ (1 << 14) /**< Native 4BA fast read instruction (0x0c) is supported. */
124#define FEATURE_4BA_WRITE (1 << 15) /**< Native 4BA byte program (0x12) is supported. */
125/* 4BA Shorthands */
126#define FEATURE_4BA_NATIVE (FEATURE_4BA_READ | FEATURE_4BA_FAST_READ | FEATURE_4BA_WRITE)
127#define FEATURE_4BA (FEATURE_4BA_ENTER | FEATURE_4BA_EXT_ADDR | FEATURE_4BA_NATIVE)
128#define FEATURE_4BA_WREN (FEATURE_4BA_ENTER_WREN | FEATURE_4BA_EXT_ADDR | FEATURE_4BA_NATIVE)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300129/*
130 * Most flash chips are erased to ones and programmed to zeros. However, some
131 * other flash chips, such as the ENE KB9012 internal flash, work the opposite way.
132 */
133#define FEATURE_ERASED_ZERO (1 << 16)
David Hendricksf9a30552015-05-23 20:30:30 -0700134#define FEATURE_NO_ERASE (1 << 17)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300135
136#define ERASED_VALUE(flash) (((flash)->chip->feature_bits & FEATURE_ERASED_ZERO) ? 0x00 : 0xff)
Sean Nelsonc57a9202010-01-04 17:15:23 +0000137
Stefan Tauner6455dff2014-05-26 00:36:24 +0000138enum test_state {
139 OK = 0,
140 NT = 1, /* Not tested */
141 BAD, /* Known to not work */
142 DEP, /* Support depends on configuration (e.g. Intel flash descriptor) */
143 NA, /* Not applicable (e.g. write support on ROM chips) */
144};
145
146#define TEST_UNTESTED (struct tested){ .probe = NT, .read = NT, .erase = NT, .write = NT }
147
148#define TEST_OK_PROBE (struct tested){ .probe = OK, .read = NT, .erase = NT, .write = NT }
149#define TEST_OK_PR (struct tested){ .probe = OK, .read = OK, .erase = NT, .write = NT }
150#define TEST_OK_PRE (struct tested){ .probe = OK, .read = OK, .erase = OK, .write = NT }
151#define TEST_OK_PREW (struct tested){ .probe = OK, .read = OK, .erase = OK, .write = OK }
152
153#define TEST_BAD_PROBE (struct tested){ .probe = BAD, .read = NT, .erase = NT, .write = NT }
154#define TEST_BAD_PR (struct tested){ .probe = BAD, .read = BAD, .erase = NT, .write = NT }
155#define TEST_BAD_PRE (struct tested){ .probe = BAD, .read = BAD, .erase = BAD, .write = NT }
156#define TEST_BAD_PREW (struct tested){ .probe = BAD, .read = BAD, .erase = BAD, .write = BAD }
157
Nico Huber454f6132012-12-10 13:34:10 +0000158struct flashrom_flashctx;
159#define flashctx flashrom_flashctx /* TODO: Agree on a name and convert all occurences. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000160typedef int (erasefunc_t)(struct flashctx *flash, unsigned int addr, unsigned int blocklen);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000161
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000162struct flashchip {
Uwe Hermann76158682008-03-14 23:55:58 +0000163 const char *vendor;
Uwe Hermann372eeb52007-12-04 21:49:06 +0000164 const char *name;
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +0000165
166 enum chipbustype bustype;
167
Uwe Hermann394131e2008-10-18 21:14:13 +0000168 /*
169 * With 32bit manufacture_id and model_id we can cover IDs up to
Carl-Daniel Hailfingerae8afa92007-12-31 01:49:00 +0000170 * (including) the 4th bank of JEDEC JEP106W Standard Manufacturer's
171 * Identification code.
172 */
173 uint32_t manufacture_id;
174 uint32_t model_id;
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000175
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000176 /* Total chip size in kilobytes */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000177 unsigned int total_size;
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000178 /* Chip page size in bytes */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000179 unsigned int page_size;
Sean Nelsonc57a9202010-01-04 17:15:23 +0000180 int feature_bits;
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000181
Stefan Tauner6455dff2014-05-26 00:36:24 +0000182 /* Indicate how well flashrom supports different operations of this flash chip. */
183 struct tested {
184 enum test_state probe;
185 enum test_state read;
186 enum test_state erase;
187 enum test_state write;
188 } tested;
Peter Stuge1159d582008-05-03 04:34:37 +0000189
Mike Banon31b5e3b2018-01-15 01:10:00 +0300190 /*
191 * Group chips that have common command sets. This should ensure that
192 * no chip gets confused by a probing command for a very different class
193 * of chips.
194 */
195 enum {
196 /* SPI25 is very common. Keep it at zero so we don't have
197 to specify it for each and every chip in the database.*/
198 SPI25 = 0,
Paul Kocialkowski80ae14e2018-01-15 01:07:46 +0300199 SPI_EDI = 1,
Mike Banon31b5e3b2018-01-15 01:10:00 +0300200 } spi_cmd_set;
201
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000202 int (*probe) (struct flashctx *flash);
Maciej Pijankac6e11112009-06-03 14:46:22 +0000203
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000204 /* Delay after "enter/exit ID mode" commands in microseconds.
205 * NB: negative values have special meanings, see TIMING_* below.
206 */
207 signed int probe_timing;
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000208
209 /*
Carl-Daniel Hailfinger63ce4bb2009-12-22 13:04:53 +0000210 * Erase blocks and associated erase function. Any chip erase function
211 * is stored as chip-sized virtual block together with said function.
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000212 * The first one that fits will be chosen. There is currently no way to
213 * influence that behaviour. For testing just comment out the other
214 * elements or set the function pointer to NULL.
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000215 */
216 struct block_eraser {
Stefan Tauner6697f712014-08-06 15:09:15 +0000217 struct eraseblock {
Stefan Taunerd06d9412011-06-12 19:47:55 +0000218 unsigned int size; /* Eraseblock size in bytes */
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000219 unsigned int count; /* Number of contiguous blocks with that size */
220 } eraseblocks[NUM_ERASEREGIONS];
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000221 /* a block_erase function should try to erase one block of size
222 * 'blocklen' at address 'blockaddr' and return 0 on success. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000223 int (*block_erase) (struct flashctx *flash, unsigned int blockaddr, unsigned int blocklen);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000224 } block_erasers[NUM_ERASEFUNCTIONS];
225
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000226 int (*printlock) (struct flashctx *flash);
227 int (*unlock) (struct flashctx *flash);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000228 int (*write) (struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000229 int (*read) (struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len);
230 struct voltage {
Steven Zakuleccbe370e2011-06-03 07:26:31 +0000231 uint16_t min;
232 uint16_t max;
233 } voltage;
Stefan Tauner50d67aa2013-03-03 23:49:48 +0000234 enum write_granularity gran;
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000235};
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +0000236
Nico Huber454f6132012-12-10 13:34:10 +0000237struct flashrom_flashctx {
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000238 struct flashchip *chip;
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000239 /* FIXME: The memory mappings should be saved in a more structured way. */
240 /* The physical_* fields store the respective addresses in the physical address space of the CPU. */
241 uintptr_t physical_memory;
242 /* The virtual_* fields store where the respective physical address is mapped into flashrom's address
243 * space. A value equivalent to (chipaddr)ERROR_PTR indicates an invalid mapping (or none at all). */
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000244 chipaddr virtual_memory;
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000245 /* Some flash devices have an additional register space; semantics are like above. */
246 uintptr_t physical_registers;
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000247 chipaddr virtual_registers;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000248 struct registered_master *mst;
Nico Huber7af0e792016-04-29 16:40:15 +0200249 const struct flashrom_layout *layout;
250 struct single_layout fallback_layout;
Nico Huber454f6132012-12-10 13:34:10 +0000251 struct {
252 bool force;
253 bool force_boardmismatch;
254 bool verify_after_write;
255 bool verify_whole_chip;
256 } flags;
Nico Huberf43c6542017-10-14 17:47:28 +0200257 /* We cache the state of the extended address register (highest byte
258 of a 4BA for 3BA instructions) and the state of the 4BA mode here.
259 If possible, we enter 4BA mode early. If that fails, we make use
260 of the extended address register. */
261 int address_high_byte;
262 bool in_4ba_mode;
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000263};
264
Maciej Pijankac6e11112009-06-03 14:46:22 +0000265/* Timing used in probe routines. ZERO is -2 to differentiate between an unset
266 * field and zero delay.
Paul Kocialkowski80ae14e2018-01-15 01:07:46 +0300267 *
Maciej Pijankac6e11112009-06-03 14:46:22 +0000268 * SPI devices will always have zero delay and ignore this field.
269 */
270#define TIMING_FIXME -1
271/* this is intentionally same value as fixme */
272#define TIMING_IGNORED -1
273#define TIMING_ZERO -2
274
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000275extern const struct flashchip flashchips[];
Stefan Tauner96658be2014-05-26 22:05:31 +0000276extern const unsigned int flashchips_size;
Ollie Lho184a4042005-11-26 21:55:36 +0000277
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000278void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr);
279void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr);
280void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000281void chip_writen(const struct flashctx *flash, const uint8_t *buf, chipaddr addr, size_t len);
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000282uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr);
283uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr);
284uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr);
285void chip_readn(const struct flashctx *flash, uint8_t *buf, const chipaddr addr, size_t len);
286
Uwe Hermannba290d12009-06-17 12:07:12 +0000287/* print.c */
Niklas Söderlundede2fa42012-10-23 13:06:46 +0000288int print_supported(void);
Carl-Daniel Hailfingerf5292052009-11-17 09:57:34 +0000289void print_supported_wiki(void);
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000290
Stefan Tauner6ad6e012014-06-12 00:04:32 +0000291/* helpers.c */
292uint32_t address_to_bits(uint32_t addr);
293int bitcount(unsigned long a);
294int max(int a, int b);
295int min(int a, int b);
296char *strcat_realloc(char *dest, const char *src);
297void tolower_string(char *str);
Marc Schink7ecfe482016-03-17 16:07:23 +0100298uint8_t reverse_byte(uint8_t x);
299void reverse_bytes(uint8_t *dst, const uint8_t *src, size_t length);
Stefan Taunerb41d8472014-11-01 22:56:06 +0000300#ifdef __MINGW32__
301char* strtok_r(char *str, const char *delim, char **nextp);
302#endif
Nico Huber2d625722016-05-03 10:48:02 +0200303#if defined(__DJGPP__) || (!defined(__LIBPAYLOAD__) && !defined(HAVE_STRNLEN))
Stefan Taunerdc627932015-01-27 18:07:50 +0000304size_t strnlen(const char *str, size_t n);
305#endif
Stefan Tauner6ad6e012014-06-12 00:04:32 +0000306
Uwe Hermann0846f892007-08-23 13:34:59 +0000307/* flashrom.c */
Mathias Krausea60faab2011-01-17 07:50:42 +0000308extern const char flashrom_version[];
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000309extern const char *chip_to_probe;
Nico Huber2d625722016-05-03 10:48:02 +0200310char *flashbuses_to_text(enum chipbustype bustype);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000311int map_flash(struct flashctx *flash);
312void unmap_flash(struct flashctx *flash);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000313int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len);
314int erase_flash(struct flashctx *flash);
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000315int probe_flash(struct registered_master *mst, int startchip, struct flashctx *fill_flash, int force);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000316int read_flash_to_file(struct flashctx *flash, const char *filename);
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000317char *extract_param(const char *const *haystack, const char *needle, const char *delim);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000318int verify_range(struct flashctx *flash, const uint8_t *cmpbuf, unsigned int start, unsigned int len);
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300319int need_erase(const uint8_t *have, const uint8_t *want, unsigned int len, enum write_granularity gran, const uint8_t erased_value);
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +0000320void print_version(void);
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +0000321void print_buildinfo(void);
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +0000322void print_banner(void);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +0000323void list_programmers_linebreak(int startcol, int cols, int paren);
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +0000324int selfcheck(void);
Stefan Tauner66652442011-06-26 17:38:17 +0000325int read_buf_from_file(unsigned char *buf, unsigned long size, const char *filename);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000326int write_buf_to_file(const unsigned char *buf, unsigned long size, const char *filename);
Nico Huber305f4172013-06-14 11:55:26 +0200327int prepare_flash_access(struct flashctx *, bool read_it, bool write_it, bool erase_it, bool verify_it);
328void finalize_flash_access(struct flashctx *);
Nico Huber899e4ec2016-04-29 18:39:01 +0200329int do_read(struct flashctx *, const char *filename);
330int do_erase(struct flashctx *);
Paul Kocialkowskif701f342018-01-15 01:10:36 +0300331int do_write(struct flashctx *, const char *const filename, const char *const referencefile);
Nico Huber899e4ec2016-04-29 18:39:01 +0200332int do_verify(struct flashctx *, const char *const filename);
Uwe Hermannba290d12009-06-17 12:07:12 +0000333
Tadas Slotkusad470342011-09-03 17:15:00 +0000334/* Something happened that shouldn't happen, but we can go on. */
Michael Karchera4448d92010-07-22 18:04:15 +0000335#define ERROR_NONFATAL 0x100
336
Tadas Slotkusad470342011-09-03 17:15:00 +0000337/* Something happened that shouldn't happen, we'll abort. */
338#define ERROR_FATAL -0xee
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000339#define ERROR_FLASHROM_BUG -200
340/* We reached one of the hardcoded limits of flashrom. This can be fixed by
341 * increasing the limit of a compile-time allocation or by switching to dynamic
342 * allocation.
343 * Note: If this warning is triggered, check first for runaway registrations.
344 */
345#define ERROR_FLASHROM_LIMIT -201
Tadas Slotkusad470342011-09-03 17:15:00 +0000346
Stefan Tauner9b32de92014-08-08 23:52:33 +0000347/* cli_common.c */
Stefan Tauner9b32de92014-08-08 23:52:33 +0000348void print_chip_support_status(const struct flashchip *chip);
349
Sean Nelson51e97d72010-01-07 20:09:33 +0000350/* cli_output.c */
Nico Huberd152fb92017-06-19 12:57:10 +0200351extern enum flashrom_log_level verbose_screen;
352extern enum flashrom_log_level verbose_logfile;
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +0000353#ifndef STANDALONE
354int open_logfile(const char * const filename);
355int close_logfile(void);
356void start_logging(void);
357#endif
Nico Huberd152fb92017-06-19 12:57:10 +0200358int flashrom_print_cb(enum flashrom_log_level level, const char *fmt, va_list ap);
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000359/* Let gcc and clang check for correct printf-style format strings. */
Nico Huberd152fb92017-06-19 12:57:10 +0200360int print(enum flashrom_log_level level, const char *fmt, ...)
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +0000361#ifdef __MINGW32__
Antonio Ospiteb6e3d252018-03-03 18:40:24 +0100362# ifndef __MINGW_PRINTF_FORMAT
363# define __MINGW_PRINTF_FORMAT gnu_printf
364# endif
Stefan Taunerf268d8b2017-10-26 18:45:00 +0200365__attribute__((format(__MINGW_PRINTF_FORMAT, 2, 3)));
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +0000366#else
367__attribute__((format(printf, 2, 3)));
368#endif
Nico Huberd152fb92017-06-19 12:57:10 +0200369#define msg_gerr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* general errors */
370#define msg_perr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* programmer errors */
371#define msg_cerr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* chip errors */
372#define msg_gwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* general warnings */
373#define msg_pwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* programmer warnings */
374#define msg_cwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* chip warnings */
375#define msg_ginfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* general info */
376#define msg_pinfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* programmer info */
377#define msg_cinfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* chip info */
378#define msg_gdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* general debug */
379#define msg_pdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* programmer debug */
380#define msg_cdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* chip debug */
381#define msg_gdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* general debug2 */
382#define msg_pdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* programmer debug2 */
383#define msg_cdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* chip debug2 */
384#define msg_gspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* general debug spew */
385#define msg_pspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* programmer debug spew */
386#define msg_cspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* chip debug spew */
Sean Nelson51e97d72010-01-07 20:09:33 +0000387
Uwe Hermann0846f892007-08-23 13:34:59 +0000388/* layout.c */
Louis Yung-Chieh Lo9bcf2682011-12-25 09:12:16 +0000389int register_include_arg(char *name);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000390int read_romlayout(const char *name);
Stefan Tauner8268fdb2013-09-23 14:21:06 +0000391int normalize_romentries(const struct flashctx *flash);
Stefan Tauner949ccc82013-09-15 14:01:06 +0000392void layout_cleanup(void);
Uwe Hermann0846f892007-08-23 13:34:59 +0000393
Carl-Daniel Hailfinger00f911e2007-10-15 21:44:47 +0000394/* spi.c */
Carl-Daniel Hailfingerd0478292009-07-10 21:08:55 +0000395struct spi_command {
396 unsigned int writecnt;
397 unsigned int readcnt;
398 const unsigned char *writearr;
399 unsigned char *readarr;
400};
Nico Hubera3140d02017-10-15 11:20:58 +0200401#define NULL_SPI_CMD { 0, 0, NULL, NULL, }
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000402int spi_send_command(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt, const unsigned char *writearr, unsigned char *readarr);
403int spi_send_multicommand(struct flashctx *flash, struct spi_command *cmds);
Mats Erik Andersson44e1a192008-09-26 13:19:02 +0000404
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000405enum chipbustype get_buses_supported(void);
Ollie Lho761bf1b2004-03-20 16:46:10 +0000406#endif /* !__FLASH_H__ */