gpxe/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 }