[efi] Ensure EFI ROM checksum is zero
[people/mcb30/gpxe.git] / src / util / efirom.c
1 /*
2  * Copyright (C) 2009 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <stddef.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <getopt.h>
29 #include <gpxe/efi/efi.h>
30 #include <gpxe/efi/IndustryStandard/PeImage.h>
31 #include <gpxe/efi/IndustryStandard/Pci22.h>
32
33 #define eprintf(...) fprintf ( stderr, __VA_ARGS__ )
34
35 /** Command-line options */
36 struct options {
37         uint16_t vendor;
38         uint16_t device;
39 };
40
41 /**
42  * Allocate memory
43  *
44  * @v len               Length of memory to allocate
45  * @ret ptr             Pointer to allocated memory
46  */
47 static void * xmalloc ( size_t len ) {
48         void *ptr;
49
50         ptr = malloc ( len );
51         if ( ! ptr ) {
52                 eprintf ( "Could not allocate %zd bytes\n", len );
53                 exit ( 1 );
54         }
55
56         return ptr;
57 }
58
59 /**
60  * Get file size
61  *
62  * @v file              File
63  * @v len               File size
64  */
65 static size_t file_size ( FILE *file ) {
66         ssize_t len;
67
68         return len;
69 }
70
71 /**
72  * Read information from PE headers
73  *
74  * @v pe                PE file
75  * @ret machine         Machine type
76  * @ret subsystem       EFI subsystem
77  */
78 static void read_pe_info ( void *pe, uint16_t *machine,
79                            uint16_t *subsystem ) {
80         EFI_IMAGE_DOS_HEADER *dos;
81         union {
82                 EFI_IMAGE_NT_HEADERS32 nt32;
83                 EFI_IMAGE_NT_HEADERS64 nt64;
84         } *nt;
85
86         /* Locate NT header */
87         dos = pe;
88         nt = ( pe + dos->e_lfanew );
89
90         /* Parse out PE information */
91         *machine = nt->nt32.FileHeader.Machine;
92         switch ( *machine ) {
93         case EFI_IMAGE_MACHINE_IA32:
94                 *subsystem = nt->nt32.OptionalHeader.Subsystem;
95                 break;
96         case EFI_IMAGE_MACHINE_X64:
97                 *subsystem = nt->nt64.OptionalHeader.Subsystem;
98                 break;
99         default:
100                 eprintf ( "Unrecognised machine type %04x\n", *machine );
101                 exit ( 1 );
102         }
103 }
104
105 /**
106  * Convert EFI image to ROM image
107  *
108  * @v pe                EFI file
109  * @v rom               ROM file
110  */
111 static void make_efi_rom ( FILE *pe, FILE *rom, struct options *opts ) {
112         struct {
113                 EFI_PCI_EXPANSION_ROM_HEADER rom;
114                 PCI_DATA_STRUCTURE pci __attribute__ (( aligned ( 4 ) ));
115                 uint8_t checksum;
116         } *headers;
117         struct stat pe_stat;
118         size_t pe_size;
119         size_t rom_size;
120         void *buf;
121         void *payload;
122         unsigned int i;
123         uint8_t checksum;
124
125         /* Determine PE file size */
126         if ( fstat ( fileno ( pe ), &pe_stat ) != 0 ) {
127                 eprintf ( "Could not stat PE file: %s\n",
128                           strerror ( errno ) );
129                 exit ( 1 );
130         }
131         pe_size = pe_stat.st_size;
132
133         /* Determine ROM file size */
134         rom_size = ( ( pe_size + sizeof ( *headers ) + 511 ) & ~511 );
135
136         /* Allocate ROM buffer and read in PE file */
137         buf = xmalloc ( rom_size );
138         memset ( buf, 0, rom_size );
139         headers = buf;
140         payload = ( buf + sizeof ( *headers ) );
141         if ( fread ( payload, pe_size, 1, pe ) != 1 ) {
142                 eprintf ( "Could not read PE file: %s\n",
143                           strerror ( errno ) );
144                 exit ( 1 );
145         }
146
147         /* Construct ROM header */
148         headers->rom.Signature = PCI_EXPANSION_ROM_HEADER_SIGNATURE;
149         headers->rom.InitializationSize = ( rom_size / 512 );
150         headers->rom.EfiSignature = EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE;
151         read_pe_info ( payload, &headers->rom.EfiMachineType,
152                        &headers->rom.EfiSubsystem );
153         headers->rom.EfiImageHeaderOffset = sizeof ( *headers );
154         headers->rom.PcirOffset =
155                 offsetof ( typeof ( *headers ), pci );
156         headers->pci.Signature = PCI_DATA_STRUCTURE_SIGNATURE;
157         headers->pci.VendorId = opts->vendor;
158         headers->pci.DeviceId = opts->device;
159         headers->pci.Length = sizeof ( headers->pci );
160         headers->pci.ClassCode[0] = PCI_CLASS_NETWORK;
161         headers->pci.ImageLength = ( rom_size / 512 );
162         headers->pci.CodeType = 0x03; /* No constant in EFI headers? */
163         headers->pci.Indicator = 0x80; /* No constant in EFI headers? */
164
165         /* Fix image checksum */
166         for ( i = 0, checksum = 0 ; i < rom_size ; i++ )
167                 checksum += *( ( uint8_t * ) buf + i );
168         headers->checksum -= checksum;
169
170         /* Write out ROM */
171         if ( fwrite ( buf, rom_size, 1, rom ) != 1 ) {
172                 eprintf ( "Could not write ROM file: %s\n",
173                           strerror ( errno ) );
174                 exit ( 1 );
175         }
176 }
177
178 /**
179  * Print help
180  *
181  * @v program_name      Program name
182  */
183 static void print_help ( const char *program_name ) {
184         eprintf ( "Syntax: %s [--vendor=VVVV] [--device=DDDD] "
185                   "infile outfile\n", program_name );
186 }
187
188 /**
189  * Parse command-line options
190  *
191  * @v argc              Argument count
192  * @v argv              Argument list
193  * @v opts              Options structure to populate
194  */
195 static int parse_options ( const int argc, char **argv,
196                            struct options *opts ) {
197         char *end;
198         int c;
199
200         while (1) {
201                 int option_index = 0;
202                 static struct option long_options[] = {
203                         { "vendor", required_argument, NULL, 'v' },
204                         { "device", required_argument, NULL, 'd' },
205                         { "help", 0, NULL, 'h' },
206                         { 0, 0, 0, 0 }
207                 };
208
209                 if ( ( c = getopt_long ( argc, argv, "v:d:h",
210                                          long_options,
211                                          &option_index ) ) == -1 ) {
212                         break;
213                 }
214
215                 switch ( c ) {
216                 case 'v':
217                         opts->vendor = strtoul ( optarg, &end, 16 );
218                         if ( *end ) {
219                                 eprintf ( "Invalid vendor \"%s\"\n", optarg );
220                                 exit ( 2 );
221                         }
222                         break;
223                 case 'd':
224                         opts->device = strtoul ( optarg, &end, 16 );
225                         if ( *end ) {
226                                 eprintf ( "Invalid device \"%s\"\n", optarg );
227                                 exit ( 2 );
228                         }
229                         break;
230                 case 'h':
231                         print_help ( argv[0] );
232                         exit ( 0 );
233                 case '?':
234                 default:
235                         exit ( 2 );
236                 }
237         }
238         return optind;
239 }
240
241 int main ( int argc, char **argv ) {
242         struct options opts = {
243         };
244         unsigned int infile_index;
245         const char *infile_name;
246         const char *outfile_name;
247         FILE *infile;
248         FILE *outfile;
249
250         /* Parse command-line arguments */
251         infile_index = parse_options ( argc, argv, &opts );
252         if ( argc != ( infile_index + 2 ) ) {
253                 print_help ( argv[0] );
254                 exit ( 2 );
255         }
256         infile_name = argv[infile_index];
257         outfile_name = argv[infile_index + 1];
258
259         /* Open input and output files */
260         infile = fopen ( infile_name, "r" );
261         if ( ! infile ) {
262                 eprintf ( "Could not open %s for reading: %s\n",
263                           infile_name, strerror ( errno ) );
264                 exit ( 1 );
265         }
266         outfile = fopen ( outfile_name, "w" );
267         if ( ! outfile ) {
268                 eprintf ( "Could not open %s for writing: %s\n",
269                           outfile_name, strerror ( errno ) );
270                 exit ( 1 );
271         }
272
273         /* Convert file */
274         make_efi_rom ( infile, outfile, &opts );
275
276         fclose ( outfile );
277         fclose ( infile );
278
279         return 0;
280 }