blob: dd8e156553933201c11362fc4a6ee56be3ebb003 [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
Nico Huberd8b2e802019-06-18 23:39:56 +020040#define KiB (1024)
41#define MiB (1024 * KiB)
42
43/* Assumes `n` and `a` are at most 64-bit wide (to avoid typeof() operator). */
44#define ALIGN_DOWN(n, a) ((n) & ~((uint64_t)(a) - 1))
45
Patrick Georgied7a9642010-09-25 22:53:44 +000046#define ERROR_PTR ((void*)-1)
47
Carl-Daniel Hailfinger174f55b2010-10-08 00:37:55 +000048/* Error codes */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +000049#define ERROR_OOM -100
Carl-Daniel Hailfinger174f55b2010-10-08 00:37:55 +000050#define TIMEOUT_ERROR -101
51
Stefan Taunerc2333752013-07-13 23:31:37 +000052/* TODO: check using code for correct usage of types */
53typedef uintptr_t chipaddr;
Stefan Tauner305e0b92013-07-17 23:46:44 +000054#define PRIxPTR_WIDTH ((int)(sizeof(uintptr_t)*2))
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +000055
David Hendricks8bb20212011-06-14 01:35:36 +000056int register_shutdown(int (*function) (void *data), void *data);
Stefan Tauner305e0b92013-07-17 23:46:44 +000057void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t len);
Uwe Hermann09e04f72009-05-16 22:36:00 +000058void programmer_unmap_flash_region(void *virt_addr, size_t len);
Stefan Taunerf80419c2014-05-02 15:41:42 +000059void programmer_delay(unsigned int usecs);
Carl-Daniel Hailfinger61a8bd22009-03-05 19:24:22 +000060
Uwe Hermanne5ac1642008-03-12 11:54:51 +000061#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
62
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +000063enum chipbustype {
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +000064 BUS_NONE = 0,
65 BUS_PARALLEL = 1 << 0,
66 BUS_LPC = 1 << 1,
67 BUS_FWH = 1 << 2,
68 BUS_SPI = 1 << 3,
Carl-Daniel Hailfinger532c7172011-11-04 21:35:26 +000069 BUS_PROG = 1 << 4,
Carl-Daniel Hailfinger1a227952011-07-27 07:13:06 +000070 BUS_NONSPI = BUS_PARALLEL | BUS_LPC | BUS_FWH,
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +000071};
72
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +000073/*
Stefan Tauner02437452013-04-01 19:34:53 +000074 * The following enum defines possible write granularities of flash chips. These tend to reflect the properties
75 * of the actual hardware not necesserily the write function(s) defined by the respective struct flashchip.
76 * The latter might (and should) be more precisely specified, e.g. they might bail out early if their execution
77 * would result in undefined chip contents.
Stefan Taunereb582572012-09-21 12:52:50 +000078 */
79enum write_granularity {
Stefan Tauner02437452013-04-01 19:34:53 +000080 /* We assume 256 byte granularity by default. */
81 write_gran_256bytes = 0,/* If less than 256 bytes are written, the unwritten bytes are undefined. */
82 write_gran_1bit, /* Each bit can be cleared individually. */
83 write_gran_1byte, /* A byte can be written once. Further writes to an already written byte cause
84 * its contents to be either undefined or to stay unchanged. */
Paul Kocialkowskic8305e12015-10-16 02:16:20 +000085 write_gran_128bytes, /* If less than 128 bytes are written, the unwritten bytes are undefined. */
Stefan Tauner02437452013-04-01 19:34:53 +000086 write_gran_264bytes, /* If less than 264 bytes are written, the unwritten bytes are undefined. */
87 write_gran_512bytes, /* If less than 512 bytes are written, the unwritten bytes are undefined. */
88 write_gran_528bytes, /* If less than 528 bytes are written, the unwritten bytes are undefined. */
89 write_gran_1024bytes, /* If less than 1024 bytes are written, the unwritten bytes are undefined. */
90 write_gran_1056bytes, /* If less than 1056 bytes are written, the unwritten bytes are undefined. */
Carl-Daniel Hailfinger1b0e9fc2014-06-16 22:36:17 +000091 write_gran_1byte_implicit_erase, /* EEPROMs and other chips with implicit erase and 1-byte writes. */
Stefan Taunereb582572012-09-21 12:52:50 +000092};
93
94/*
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +000095 * How many different contiguous runs of erase blocks with one size each do
96 * we have for a given erase function?
97 */
98#define NUM_ERASEREGIONS 5
99
100/*
101 * How many different erase functions do we have per chip?
Nico Huberaac81422017-11-10 22:54:13 +0100102 * Macronix MX25L25635F has 8 different functions.
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000103 */
Nico Huberaac81422017-11-10 22:54:13 +0100104#define NUM_ERASEFUNCTIONS 8
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000105
Nikolai Artemievf745d0e2020-11-05 13:54:27 +1100106#define MAX_CHIP_RESTORE_FUNCTIONS 4
107
Stefan Tauner0554ca52013-07-25 22:54:25 +0000108/* Feature bits used for non-SPI only */
Carl-Daniel Hailfinger4bf4e792010-01-09 03:15:50 +0000109#define FEATURE_REGISTERMAP (1 << 0)
Sean Nelson35727f72010-01-28 23:55:12 +0000110#define FEATURE_LONG_RESET (0 << 4)
111#define FEATURE_SHORT_RESET (1 << 4)
112#define FEATURE_EITHER_RESET FEATURE_LONG_RESET
Sean Nelsonf59e2632010-10-20 21:13:19 +0000113#define FEATURE_RESET_MASK (FEATURE_LONG_RESET | FEATURE_SHORT_RESET)
Carl-Daniel Hailfinger4bf4e792010-01-09 03:15:50 +0000114#define FEATURE_ADDR_FULL (0 << 2)
115#define FEATURE_ADDR_MASK (3 << 2)
Sean Nelson35727f72010-01-28 23:55:12 +0000116#define FEATURE_ADDR_2AA (1 << 2)
117#define FEATURE_ADDR_AAA (2 << 2)
Michael Karcherad0010a2010-04-03 10:27:08 +0000118#define FEATURE_ADDR_SHIFTED (1 << 5)
Stefan Tauner0554ca52013-07-25 22:54:25 +0000119/* Feature bits used for SPI only */
Carl-Daniel Hailfingerfd7075a2010-07-29 13:09:18 +0000120#define FEATURE_WRSR_EWSR (1 << 6)
121#define FEATURE_WRSR_WREN (1 << 7)
Stefan Tauner0554ca52013-07-25 22:54:25 +0000122#define FEATURE_WRSR_EITHER (FEATURE_WRSR_EWSR | FEATURE_WRSR_WREN)
Daniel Lenski65922a32012-02-15 23:40:23 +0000123#define FEATURE_OTP (1 << 8)
Vincent Palatinf800f552013-03-15 02:03:16 +0000124#define FEATURE_QPI (1 << 9)
Nico Huberfe34d2a2017-11-10 21:10:20 +0100125#define FEATURE_4BA_ENTER (1 << 10) /**< Can enter/exit 4BA mode with instructions 0xb7/0xe9 w/o WREN */
126#define FEATURE_4BA_ENTER_WREN (1 << 11) /**< Can enter/exit 4BA mode with instructions 0xb7/0xe9 after WREN */
Nico Huber86bddb52018-03-13 18:14:52 +0100127#define FEATURE_4BA_ENTER_EAR7 (1 << 12) /**< Can enter/exit 4BA mode by setting bit7 of the ext addr reg */
128#define FEATURE_4BA_EXT_ADDR (1 << 13) /**< Regular 3-byte operations can be used by writing the most
Nico Huberf43c6542017-10-14 17:47:28 +0200129 significant address byte into an extended address register. */
Nico Huber86bddb52018-03-13 18:14:52 +0100130#define FEATURE_4BA_READ (1 << 14) /**< Native 4BA read instruction (0x13) is supported. */
131#define FEATURE_4BA_FAST_READ (1 << 15) /**< Native 4BA fast read instruction (0x0c) is supported. */
132#define FEATURE_4BA_WRITE (1 << 16) /**< Native 4BA byte program (0x12) is supported. */
Nico Huberaac81422017-11-10 22:54:13 +0100133/* 4BA Shorthands */
134#define FEATURE_4BA_NATIVE (FEATURE_4BA_READ | FEATURE_4BA_FAST_READ | FEATURE_4BA_WRITE)
135#define FEATURE_4BA (FEATURE_4BA_ENTER | FEATURE_4BA_EXT_ADDR | FEATURE_4BA_NATIVE)
136#define FEATURE_4BA_WREN (FEATURE_4BA_ENTER_WREN | FEATURE_4BA_EXT_ADDR | FEATURE_4BA_NATIVE)
Nico Huber86bddb52018-03-13 18:14:52 +0100137#define FEATURE_4BA_EAR7 (FEATURE_4BA_ENTER_EAR7 | FEATURE_4BA_EXT_ADDR | FEATURE_4BA_NATIVE)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300138/*
139 * Most flash chips are erased to ones and programmed to zeros. However, some
140 * other flash chips, such as the ENE KB9012 internal flash, work the opposite way.
141 */
Nico Huber86bddb52018-03-13 18:14:52 +0100142#define FEATURE_ERASED_ZERO (1 << 17)
143#define FEATURE_NO_ERASE (1 << 18)
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300144
145#define ERASED_VALUE(flash) (((flash)->chip->feature_bits & FEATURE_ERASED_ZERO) ? 0x00 : 0xff)
Sean Nelsonc57a9202010-01-04 17:15:23 +0000146
Stefan Tauner6455dff2014-05-26 00:36:24 +0000147enum test_state {
148 OK = 0,
149 NT = 1, /* Not tested */
150 BAD, /* Known to not work */
151 DEP, /* Support depends on configuration (e.g. Intel flash descriptor) */
152 NA, /* Not applicable (e.g. write support on ROM chips) */
153};
154
155#define TEST_UNTESTED (struct tested){ .probe = NT, .read = NT, .erase = NT, .write = NT }
156
157#define TEST_OK_PROBE (struct tested){ .probe = OK, .read = NT, .erase = NT, .write = NT }
158#define TEST_OK_PR (struct tested){ .probe = OK, .read = OK, .erase = NT, .write = NT }
159#define TEST_OK_PRE (struct tested){ .probe = OK, .read = OK, .erase = OK, .write = NT }
160#define TEST_OK_PREW (struct tested){ .probe = OK, .read = OK, .erase = OK, .write = OK }
161
162#define TEST_BAD_PROBE (struct tested){ .probe = BAD, .read = NT, .erase = NT, .write = NT }
163#define TEST_BAD_PR (struct tested){ .probe = BAD, .read = BAD, .erase = NT, .write = NT }
164#define TEST_BAD_PRE (struct tested){ .probe = BAD, .read = BAD, .erase = BAD, .write = NT }
165#define TEST_BAD_PREW (struct tested){ .probe = BAD, .read = BAD, .erase = BAD, .write = BAD }
166
Nico Huber454f6132012-12-10 13:34:10 +0000167struct flashrom_flashctx;
168#define flashctx flashrom_flashctx /* TODO: Agree on a name and convert all occurences. */
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000169typedef int (erasefunc_t)(struct flashctx *flash, unsigned int addr, unsigned int blocklen);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000170
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000171struct flashchip {
Uwe Hermann76158682008-03-14 23:55:58 +0000172 const char *vendor;
Uwe Hermann372eeb52007-12-04 21:49:06 +0000173 const char *name;
Carl-Daniel Hailfinger1dfe0ff2009-05-31 17:57:34 +0000174
175 enum chipbustype bustype;
176
Uwe Hermann394131e2008-10-18 21:14:13 +0000177 /*
178 * With 32bit manufacture_id and model_id we can cover IDs up to
Carl-Daniel Hailfingerae8afa92007-12-31 01:49:00 +0000179 * (including) the 4th bank of JEDEC JEP106W Standard Manufacturer's
180 * Identification code.
181 */
182 uint32_t manufacture_id;
183 uint32_t model_id;
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000184
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000185 /* Total chip size in kilobytes */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000186 unsigned int total_size;
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000187 /* Chip page size in bytes */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000188 unsigned int page_size;
Sean Nelsonc57a9202010-01-04 17:15:23 +0000189 int feature_bits;
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000190
Stefan Tauner6455dff2014-05-26 00:36:24 +0000191 /* Indicate how well flashrom supports different operations of this flash chip. */
192 struct tested {
193 enum test_state probe;
194 enum test_state read;
195 enum test_state erase;
196 enum test_state write;
197 } tested;
Peter Stuge1159d582008-05-03 04:34:37 +0000198
Mike Banon31b5e3b2018-01-15 01:10:00 +0300199 /*
200 * Group chips that have common command sets. This should ensure that
201 * no chip gets confused by a probing command for a very different class
202 * of chips.
203 */
204 enum {
205 /* SPI25 is very common. Keep it at zero so we don't have
206 to specify it for each and every chip in the database.*/
207 SPI25 = 0,
Paul Kocialkowski80ae14e2018-01-15 01:07:46 +0300208 SPI_EDI = 1,
Mike Banon31b5e3b2018-01-15 01:10:00 +0300209 } spi_cmd_set;
210
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000211 int (*probe) (struct flashctx *flash);
Maciej Pijankac6e11112009-06-03 14:46:22 +0000212
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000213 /* Delay after "enter/exit ID mode" commands in microseconds.
214 * NB: negative values have special meanings, see TIMING_* below.
215 */
216 signed int probe_timing;
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000217
218 /*
Carl-Daniel Hailfinger63ce4bb2009-12-22 13:04:53 +0000219 * Erase blocks and associated erase function. Any chip erase function
220 * is stored as chip-sized virtual block together with said function.
Stefan Taunerc0aaf952011-05-19 02:58:17 +0000221 * The first one that fits will be chosen. There is currently no way to
222 * influence that behaviour. For testing just comment out the other
223 * elements or set the function pointer to NULL.
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000224 */
225 struct block_eraser {
Stefan Tauner6697f712014-08-06 15:09:15 +0000226 struct eraseblock {
Stefan Taunerd06d9412011-06-12 19:47:55 +0000227 unsigned int size; /* Eraseblock size in bytes */
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000228 unsigned int count; /* Number of contiguous blocks with that size */
229 } eraseblocks[NUM_ERASEREGIONS];
Stefan Tauner355cbfd2011-05-28 02:37:14 +0000230 /* a block_erase function should try to erase one block of size
231 * 'blocklen' at address 'blockaddr' and return 0 on success. */
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000232 int (*block_erase) (struct flashctx *flash, unsigned int blockaddr, unsigned int blocklen);
Carl-Daniel Hailfingerf38431a2009-09-05 02:30:58 +0000233 } block_erasers[NUM_ERASEFUNCTIONS];
234
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000235 int (*printlock) (struct flashctx *flash);
236 int (*unlock) (struct flashctx *flash);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000237 int (*write) (struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000238 int (*read) (struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len);
Edward O'Callaghand3b6acf2020-09-21 17:10:21 +1000239 uint8_t (*read_status) (const struct flashctx *flash);
240 int (*write_status) (const struct flashctx *flash, int status);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000241 struct voltage {
Steven Zakuleccbe370e2011-06-03 07:26:31 +0000242 uint16_t min;
243 uint16_t max;
244 } voltage;
Stefan Tauner50d67aa2013-03-03 23:49:48 +0000245 enum write_granularity gran;
Nico Huber57dbd642018-03-13 18:01:05 +0100246
247 /* SPI specific options (TODO: Make it a union in case other bustypes get specific options.) */
248 uint8_t wrea_override; /**< override opcode for write extended address register */
Edward O'Callaghand3b6acf2020-09-21 17:10:21 +1000249
250 struct wp *wp;
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000251};
Ronald G. Minnicheaab50b2003-09-12 22:41:53 +0000252
Nikolai Artemievf745d0e2020-11-05 13:54:27 +1100253typedef int (*chip_restore_fn_cb_t)(struct flashctx *flash, uint8_t status);
254
Nico Huber454f6132012-12-10 13:34:10 +0000255struct flashrom_flashctx {
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000256 struct flashchip *chip;
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000257 /* FIXME: The memory mappings should be saved in a more structured way. */
258 /* The physical_* fields store the respective addresses in the physical address space of the CPU. */
259 uintptr_t physical_memory;
260 /* The virtual_* fields store where the respective physical address is mapped into flashrom's address
261 * space. A value equivalent to (chipaddr)ERROR_PTR indicates an invalid mapping (or none at all). */
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000262 chipaddr virtual_memory;
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000263 /* Some flash devices have an additional register space; semantics are like above. */
264 uintptr_t physical_registers;
Carl-Daniel Hailfinger5820f422009-05-16 21:22:56 +0000265 chipaddr virtual_registers;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000266 struct registered_master *mst;
Nico Huber7af0e792016-04-29 16:40:15 +0200267 const struct flashrom_layout *layout;
268 struct single_layout fallback_layout;
Nico Huber454f6132012-12-10 13:34:10 +0000269 struct {
270 bool force;
271 bool force_boardmismatch;
272 bool verify_after_write;
273 bool verify_whole_chip;
274 } flags;
Nico Huberf43c6542017-10-14 17:47:28 +0200275 /* We cache the state of the extended address register (highest byte
Edward O'Callaghanb1e61bc2020-12-01 21:00:42 +1100276 * of a 4BA for 3BA instructions) and the state of the 4BA mode here.
277 * If possible, we enter 4BA mode early. If that fails, we make use
278 * of the extended address register.
279 */
Nico Huberf43c6542017-10-14 17:47:28 +0200280 int address_high_byte;
281 bool in_4ba_mode;
Nikolai Artemievf745d0e2020-11-05 13:54:27 +1100282
283 int chip_restore_fn_count;
284 struct chip_restore_func_data {
285 chip_restore_fn_cb_t func;
286 uint8_t status;
287 } chip_restore_fn[MAX_CHIP_RESTORE_FUNCTIONS];
Ronald G. Minnich5e5f75e2002-01-29 18:21:41 +0000288};
289
Maciej Pijankac6e11112009-06-03 14:46:22 +0000290/* Timing used in probe routines. ZERO is -2 to differentiate between an unset
291 * field and zero delay.
Paul Kocialkowski80ae14e2018-01-15 01:07:46 +0300292 *
Maciej Pijankac6e11112009-06-03 14:46:22 +0000293 * SPI devices will always have zero delay and ignore this field.
294 */
295#define TIMING_FIXME -1
296/* this is intentionally same value as fixme */
297#define TIMING_IGNORED -1
298#define TIMING_ZERO -2
299
Carl-Daniel Hailfinger4c823182011-05-04 00:39:50 +0000300extern const struct flashchip flashchips[];
Stefan Tauner96658be2014-05-26 22:05:31 +0000301extern const unsigned int flashchips_size;
Ollie Lho184a4042005-11-26 21:55:36 +0000302
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000303void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr);
304void chip_writew(const struct flashctx *flash, uint16_t val, chipaddr addr);
305void chip_writel(const struct flashctx *flash, uint32_t val, chipaddr addr);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000306void chip_writen(const struct flashctx *flash, const uint8_t *buf, chipaddr addr, size_t len);
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000307uint8_t chip_readb(const struct flashctx *flash, const chipaddr addr);
308uint16_t chip_readw(const struct flashctx *flash, const chipaddr addr);
309uint32_t chip_readl(const struct flashctx *flash, const chipaddr addr);
310void chip_readn(const struct flashctx *flash, uint8_t *buf, const chipaddr addr, size_t len);
311
Uwe Hermannba290d12009-06-17 12:07:12 +0000312/* print.c */
Niklas Söderlundede2fa42012-10-23 13:06:46 +0000313int print_supported(void);
Carl-Daniel Hailfingerf5292052009-11-17 09:57:34 +0000314void print_supported_wiki(void);
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000315
Stefan Tauner6ad6e012014-06-12 00:04:32 +0000316/* helpers.c */
317uint32_t address_to_bits(uint32_t addr);
Nico Huber519be662018-12-23 20:03:35 +0100318unsigned int bitcount(unsigned long a);
319#undef MIN
320#define MIN(a, b) ((a) < (b) ? (a) : (b))
321#undef MAX
322#define MAX(a, b) ((a) > (b) ? (a) : (b))
Stefan Tauner6ad6e012014-06-12 00:04:32 +0000323int max(int a, int b);
324int min(int a, int b);
325char *strcat_realloc(char *dest, const char *src);
326void tolower_string(char *str);
Marc Schink7ecfe482016-03-17 16:07:23 +0100327uint8_t reverse_byte(uint8_t x);
328void reverse_bytes(uint8_t *dst, const uint8_t *src, size_t length);
Stefan Taunerb41d8472014-11-01 22:56:06 +0000329#ifdef __MINGW32__
330char* strtok_r(char *str, const char *delim, char **nextp);
Miklós Márton8900d6c2019-07-30 00:03:22 +0200331char *strndup(const char *str, size_t size);
Stefan Taunerb41d8472014-11-01 22:56:06 +0000332#endif
Nico Huber2d625722016-05-03 10:48:02 +0200333#if defined(__DJGPP__) || (!defined(__LIBPAYLOAD__) && !defined(HAVE_STRNLEN))
Stefan Taunerdc627932015-01-27 18:07:50 +0000334size_t strnlen(const char *str, size_t n);
335#endif
Stefan Tauner6ad6e012014-06-12 00:04:32 +0000336
Uwe Hermann0846f892007-08-23 13:34:59 +0000337/* flashrom.c */
Mathias Krausea60faab2011-01-17 07:50:42 +0000338extern const char flashrom_version[];
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000339extern const char *chip_to_probe;
Nico Huber2d625722016-05-03 10:48:02 +0200340char *flashbuses_to_text(enum chipbustype bustype);
Stefan Tauner4e32ec12014-08-30 23:39:51 +0000341int map_flash(struct flashctx *flash);
342void unmap_flash(struct flashctx *flash);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000343int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len);
344int erase_flash(struct flashctx *flash);
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000345int probe_flash(struct registered_master *mst, int startchip, struct flashctx *fill_flash, int force);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000346int read_flash_to_file(struct flashctx *flash, const char *filename);
Nico Huberbcb2e5a2012-12-30 01:23:17 +0000347char *extract_param(const char *const *haystack, const char *needle, const char *delim);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000348int verify_range(struct flashctx *flash, const uint8_t *cmpbuf, unsigned int start, unsigned int len);
Paul Kocialkowski995f7552018-01-15 01:06:09 +0300349int 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 +0000350void print_version(void);
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +0000351void print_buildinfo(void);
Carl-Daniel Hailfinger8841d3e2010-05-15 15:04:37 +0000352void print_banner(void);
Carl-Daniel Hailfingera73fb492010-10-06 23:48:34 +0000353void list_programmers_linebreak(int startcol, int cols, int paren);
Carl-Daniel Hailfingera84835a2010-01-07 03:24:05 +0000354int selfcheck(void);
Stefan Tauner66652442011-06-26 17:38:17 +0000355int read_buf_from_file(unsigned char *buf, unsigned long size, const char *filename);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000356int write_buf_to_file(const unsigned char *buf, unsigned long size, const char *filename);
Nico Huber305f4172013-06-14 11:55:26 +0200357int prepare_flash_access(struct flashctx *, bool read_it, bool write_it, bool erase_it, bool verify_it);
358void finalize_flash_access(struct flashctx *);
Nico Huber899e4ec2016-04-29 18:39:01 +0200359int do_read(struct flashctx *, const char *filename);
Daniel Campelloce983bc2021-04-16 15:26:42 -0600360int do_extract(struct flashctx *);
Nico Huber899e4ec2016-04-29 18:39:01 +0200361int do_erase(struct flashctx *);
Paul Kocialkowskif701f342018-01-15 01:10:36 +0300362int do_write(struct flashctx *, const char *const filename, const char *const referencefile);
Nico Huber899e4ec2016-04-29 18:39:01 +0200363int do_verify(struct flashctx *, const char *const filename);
Nikolai Artemievf745d0e2020-11-05 13:54:27 +1100364int register_chip_restore(chip_restore_fn_cb_t func, struct flashctx *flash, uint8_t status);
Uwe Hermannba290d12009-06-17 12:07:12 +0000365
Tadas Slotkusad470342011-09-03 17:15:00 +0000366/* Something happened that shouldn't happen, but we can go on. */
Michael Karchera4448d92010-07-22 18:04:15 +0000367#define ERROR_NONFATAL 0x100
368
Tadas Slotkusad470342011-09-03 17:15:00 +0000369/* Something happened that shouldn't happen, we'll abort. */
370#define ERROR_FATAL -0xee
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000371#define ERROR_FLASHROM_BUG -200
372/* We reached one of the hardcoded limits of flashrom. This can be fixed by
373 * increasing the limit of a compile-time allocation or by switching to dynamic
374 * allocation.
375 * Note: If this warning is triggered, check first for runaway registrations.
376 */
377#define ERROR_FLASHROM_LIMIT -201
Tadas Slotkusad470342011-09-03 17:15:00 +0000378
Stefan Tauner9b32de92014-08-08 23:52:33 +0000379/* cli_common.c */
Stefan Tauner9b32de92014-08-08 23:52:33 +0000380void print_chip_support_status(const struct flashchip *chip);
381
Sean Nelson51e97d72010-01-07 20:09:33 +0000382/* cli_output.c */
Nico Huberd152fb92017-06-19 12:57:10 +0200383extern enum flashrom_log_level verbose_screen;
384extern enum flashrom_log_level verbose_logfile;
Carl-Daniel Hailfinger1c155482012-06-06 09:17:06 +0000385#ifndef STANDALONE
386int open_logfile(const char * const filename);
387int close_logfile(void);
388void start_logging(void);
389#endif
Nico Huberd152fb92017-06-19 12:57:10 +0200390int flashrom_print_cb(enum flashrom_log_level level, const char *fmt, va_list ap);
Carl-Daniel Hailfinger9f5f2152010-06-04 23:20:21 +0000391/* Let gcc and clang check for correct printf-style format strings. */
Nico Huberd152fb92017-06-19 12:57:10 +0200392int print(enum flashrom_log_level level, const char *fmt, ...)
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +0000393#ifdef __MINGW32__
Antonio Ospiteb6e3d252018-03-03 18:40:24 +0100394# ifndef __MINGW_PRINTF_FORMAT
395# define __MINGW_PRINTF_FORMAT gnu_printf
396# endif
Stefan Taunerf268d8b2017-10-26 18:45:00 +0200397__attribute__((format(__MINGW_PRINTF_FORMAT, 2, 3)));
Carl-Daniel Hailfinger11990da2013-07-13 23:21:05 +0000398#else
399__attribute__((format(printf, 2, 3)));
400#endif
Nico Huberd152fb92017-06-19 12:57:10 +0200401#define msg_gerr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* general errors */
402#define msg_perr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* programmer errors */
403#define msg_cerr(...) print(FLASHROM_MSG_ERROR, __VA_ARGS__) /* chip errors */
404#define msg_gwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* general warnings */
405#define msg_pwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* programmer warnings */
406#define msg_cwarn(...) print(FLASHROM_MSG_WARN, __VA_ARGS__) /* chip warnings */
407#define msg_ginfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* general info */
408#define msg_pinfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* programmer info */
409#define msg_cinfo(...) print(FLASHROM_MSG_INFO, __VA_ARGS__) /* chip info */
410#define msg_gdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* general debug */
411#define msg_pdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* programmer debug */
412#define msg_cdbg(...) print(FLASHROM_MSG_DEBUG, __VA_ARGS__) /* chip debug */
413#define msg_gdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* general debug2 */
414#define msg_pdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* programmer debug2 */
415#define msg_cdbg2(...) print(FLASHROM_MSG_DEBUG2, __VA_ARGS__) /* chip debug2 */
416#define msg_gspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* general debug spew */
417#define msg_pspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* programmer debug spew */
418#define msg_cspew(...) print(FLASHROM_MSG_SPEW, __VA_ARGS__) /* chip debug spew */
Sean Nelson51e97d72010-01-07 20:09:33 +0000419
Uwe Hermann0846f892007-08-23 13:34:59 +0000420/* layout.c */
Daniel Campello45d50a12021-04-13 10:47:25 -0600421int register_include_arg(struct layout_include_args **args, const char *arg);
Mark Marshallf20b7be2014-05-09 21:16:21 +0000422int read_romlayout(const char *name);
Stefan Tauner8268fdb2013-09-23 14:21:06 +0000423int normalize_romentries(const struct flashctx *flash);
Arthur Heymansb04fef92019-02-05 17:35:05 +0100424void layout_cleanup(struct layout_include_args **args);
Uwe Hermann0846f892007-08-23 13:34:59 +0000425
Carl-Daniel Hailfinger00f911e2007-10-15 21:44:47 +0000426/* spi.c */
Carl-Daniel Hailfingerd0478292009-07-10 21:08:55 +0000427struct spi_command {
428 unsigned int writecnt;
429 unsigned int readcnt;
430 const unsigned char *writearr;
431 unsigned char *readarr;
432};
Nico Hubera3140d02017-10-15 11:20:58 +0200433#define NULL_SPI_CMD { 0, 0, NULL, NULL, }
Edward O'Callaghane4ddc362020-04-12 17:27:53 +1000434int spi_send_command(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt, const unsigned char *writearr, unsigned char *readarr);
435int spi_send_multicommand(const struct flashctx *flash, struct spi_command *cmds);
Mats Erik Andersson44e1a192008-09-26 13:19:02 +0000436
Carl-Daniel Hailfingerc40cff72011-12-20 00:19:29 +0000437enum chipbustype get_buses_supported(void);
Ollie Lho761bf1b2004-03-20 16:46:10 +0000438#endif /* !__FLASH_H__ */