.TH FLASHROM 8 "April 11, 2009"
.SH NAME
flashrom \- read, write, and erase BIOS/ROM/flash chips
.SH SYNOPSIS
.B flashrom \fR[\fB\-rwvEVfLhR\fR] [\fB\-c\fR chipname] [\fB\-s\fR exclude_start] [\fB\-e\fR exclude_end]
         [\fB-m\fR vendor:part] [\fB-l\fR file.layout] [\fB-i\fR image_name] [file]
.SH DESCRIPTION
.B flashrom
is a utility for reading, writing, and erasing flash ROM chips.
It's often used to flash BIOS/coreboot/firmware images.
.PP
It supports a wide range of DIP32, PLCC32, DIP8, SO8/SOIC8, TSOP32, and
TSOP40 chips, which use various protocols such as LPC, FWH, parallel flash,
or SPI.
.PP
(see
.B http://coreboot.org
for details on coreboot)
.SH OPTIONS
Please note that the command line interface for flashrom will change before
flashrom 1.0. Do not use flashrom in scripts or other automated tools without
checking that your flashrom version won't interpret them in a totally different
way.
.PP
If no file is specified, then all that happens
is that flash info is dumped and the flash chip is set to writable.
.TP
.B "\-r, \-\-read <file>"
Read flash ROM contents and save them into the given
.BR <file> .
.TP
.B "\-w, \-\-write <file>"
Write file into flash ROM (default when
.B <file>
is specified).
.TP
.B "\-v, \-\-verify <file>"
Verify the flash ROM contents against the given
.BR <file> .
.TP
.B "\-E, \-\-erase"
Erase the flash ROM chip.
.TP
.B "\-V, \-\-verbose"
More verbose output.
.TP
.B "\-c, \-\-chip" <chipname>
Probe only for specified flash ROM chip.
.TP
.B "\-s, \-\-estart" <addr>
Exclude start position (obsolete).
.TP
.B "\-e, \-\-eend" <addr> 
Exclude end postion (obsolete).
.TP
.B "\-m, \-\-mainboard" <[vendor:]part>
Override mainboard settings. This option is needed for some mainboards,
see the
.B "flashrom \-\-list\-supported"
output for a list. The vendor is not required when the board name is unique.
.TP
.B "\-f, \-\-force"
Force write without checking whether the ROM image file is really meant
to be used on this board.
.sp
Note: This check only works while coreboot is running, and only for those
boards where the coreboot code supports it.
.TP
.B "\-l, \-\-layout <file>"
Read ROM layout from
.BR <file> .
.TP
.B "\-i, \-\-image <name>"
Only flash image
.B <name>
from flash layout.
.TP
.B "\-L, \-\-list\-supported"
List the ROM chips, chipsets, and mainboards supported by flashrom.
The list of mainboards consists of those boards which need a special
ROM write-enable function for flashrom to work.
.sp
There are many other boards which will work out of the box, without such
special support in flashrom. Some of the known-good/known-bad and tested ones
are listed at
.BR http://coreboot.org/Flashrom#Supported_mainboards ,
but the list is not exhaustive, of course.
.sp
Please let us know if you can verify other boards to work or not work out
of the box.
.TP
.B "\-h, \-\-help"
Show a help text and exit.
.TP
.B "\-R, \-\-version"
Show version information and exit.
.SH EXIT STATUS
flashrom exits with 0 on success, 1 on most failures but with 2 if /dev/mem
(/dev/xsvc on Solaris) can not be opened and with 3 if a call to mmap() fails.
.SH BUGS
Please report any bugs at
.BR http://tracker.coreboot.org/trac/coreboot/newticket ","
or on the coreboot mailing list
.RB "(" http://coreboot.org/Mailinglist ")."
.SH LICENCE
.B flashrom
is covered by the GNU General Public License (GPL), version 2. Some files are
additionally available under the GPL (version 2, or any later version).
.SH COPYRIGHT
.br
Please see the individual files.
.SH AUTHORS
Carl-Daniel Hailfinger
.br
Claus Gindhart <claus.gindhart@kontron.com>
.br
Dominik Geyer <dominik.geyer@kontron.com>
.br
Eric Biederman <ebiederman@lnxi.com>
.br
Giampiero Giancipoli <gianci@email.it>
.br
Joe Bao <Zheng.Bao@amd.com>
.br
Luc Verhaegen <libv@skynet.be>
.br
Li-Ta Lo
.br
Markus Boas <ryven@ryven.de>
.br
Nikolay Petukhov <nikolay.petukhov@gmail.com>
.br
Peter Stuge <peter@stuge.se>
.br
Reinder E.N. de Haan <lb_reha@mveas.com>
.br
Ronald G. Minnich <rminnich@gmail.com>
.br
Ronald Hoogenboom <ronald@zonnet.nl>
.br
Stefan Reinauer <stepan@coresystems.de>
.br
Stefan Wildemann <stefan.wildemann@kontron.com>
.br
Steven James <pyro@linuxlabs.com>
.br
Uwe Hermann <uwe@hermann-uwe.de>
.br
Wang Qingpei <Qingpei.Wang@amd.com>
.br
Yinghai Lu <yinghai.lu@amd.com>
.br
some others 
.PP
This manual page was written by Uwe Hermann <uwe@hermann-uwe.de>.
It is licensed under the terms of the GNU GPL (version 2 or later).
