1cd392fe8SSimon Glass /* 2cd392fe8SSimon Glass * ifdtool - Manage Intel Firmware Descriptor information 3cd392fe8SSimon Glass * 4cd392fe8SSimon Glass * Copyright 2014 Google, Inc 5cd392fe8SSimon Glass * 6cd392fe8SSimon Glass * SPDX-License-Identifier: GPL-2.0 7cd392fe8SSimon Glass * 8cd392fe8SSimon Glass * From Coreboot project, but it got a serious code clean-up 9cd392fe8SSimon Glass * and a few new features 10cd392fe8SSimon Glass */ 11cd392fe8SSimon Glass 12cd392fe8SSimon Glass #include <assert.h> 13cd392fe8SSimon Glass #include <fcntl.h> 14cd392fe8SSimon Glass #include <getopt.h> 15cd392fe8SSimon Glass #include <stdlib.h> 16cd392fe8SSimon Glass #include <stdio.h> 17cd392fe8SSimon Glass #include <string.h> 18cd392fe8SSimon Glass #include <unistd.h> 19cd392fe8SSimon Glass #include <sys/types.h> 20cd392fe8SSimon Glass #include <sys/stat.h> 21cd392fe8SSimon Glass #include "ifdtool.h" 22cd392fe8SSimon Glass 23cd392fe8SSimon Glass #undef DEBUG 24cd392fe8SSimon Glass 25cd392fe8SSimon Glass #ifdef DEBUG 26cd392fe8SSimon Glass #define debug(fmt, args...) printf(fmt, ##args) 27cd392fe8SSimon Glass #else 28cd392fe8SSimon Glass #define debug(fmt, args...) 29cd392fe8SSimon Glass #endif 30cd392fe8SSimon Glass 31cd392fe8SSimon Glass #define FD_SIGNATURE 0x0FF0A55A 32cd392fe8SSimon Glass #define FLREG_BASE(reg) ((reg & 0x00000fff) << 12); 33cd392fe8SSimon Glass #define FLREG_LIMIT(reg) (((reg & 0x0fff0000) >> 4) | 0xfff); 34cd392fe8SSimon Glass 35cd392fe8SSimon Glass /** 36cd392fe8SSimon Glass * find_fd() - Find the flash description in the ROM image 37cd392fe8SSimon Glass * 38cd392fe8SSimon Glass * @image: Pointer to image 39cd392fe8SSimon Glass * @size: Size of image in bytes 40cd392fe8SSimon Glass * @return pointer to structure, or NULL if not found 41cd392fe8SSimon Glass */ 42cd392fe8SSimon Glass static struct fdbar_t *find_fd(char *image, int size) 43cd392fe8SSimon Glass { 44cd392fe8SSimon Glass uint32_t *ptr, *end; 45cd392fe8SSimon Glass 46cd392fe8SSimon Glass /* Scan for FD signature */ 47cd392fe8SSimon Glass for (ptr = (uint32_t *)image, end = ptr + size / 4; ptr < end; ptr++) { 48cd392fe8SSimon Glass if (*ptr == FD_SIGNATURE) 49cd392fe8SSimon Glass break; 50cd392fe8SSimon Glass } 51cd392fe8SSimon Glass 52cd392fe8SSimon Glass if (ptr == end) { 53cd392fe8SSimon Glass printf("No Flash Descriptor found in this image\n"); 54cd392fe8SSimon Glass return NULL; 55cd392fe8SSimon Glass } 56cd392fe8SSimon Glass 57cd392fe8SSimon Glass debug("Found Flash Descriptor signature at 0x%08x\n", i); 58cd392fe8SSimon Glass 59cd392fe8SSimon Glass return (struct fdbar_t *)ptr; 60cd392fe8SSimon Glass } 61cd392fe8SSimon Glass 62cd392fe8SSimon Glass /** 63cd392fe8SSimon Glass * get_region() - Get information about the selected region 64cd392fe8SSimon Glass * 65cd392fe8SSimon Glass * @frba: Flash region list 66cd392fe8SSimon Glass * @region_type: Type of region (0..MAX_REGIONS-1) 67cd392fe8SSimon Glass * @region: Region information is written here 68cd392fe8SSimon Glass * @return 0 if OK, else -ve 69cd392fe8SSimon Glass */ 70cd392fe8SSimon Glass static int get_region(struct frba_t *frba, int region_type, 71cd392fe8SSimon Glass struct region_t *region) 72cd392fe8SSimon Glass { 73cd392fe8SSimon Glass if (region_type >= MAX_REGIONS) { 74cd392fe8SSimon Glass fprintf(stderr, "Invalid region type.\n"); 75cd392fe8SSimon Glass return -1; 76cd392fe8SSimon Glass } 77cd392fe8SSimon Glass 78cd392fe8SSimon Glass region->base = FLREG_BASE(frba->flreg[region_type]); 79cd392fe8SSimon Glass region->limit = FLREG_LIMIT(frba->flreg[region_type]); 80cd392fe8SSimon Glass region->size = region->limit - region->base + 1; 81cd392fe8SSimon Glass 82cd392fe8SSimon Glass return 0; 83cd392fe8SSimon Glass } 84cd392fe8SSimon Glass 85cd392fe8SSimon Glass static const char *region_name(int region_type) 86cd392fe8SSimon Glass { 87cd392fe8SSimon Glass static const char *const regions[] = { 88cd392fe8SSimon Glass "Flash Descriptor", 89cd392fe8SSimon Glass "BIOS", 90cd392fe8SSimon Glass "Intel ME", 91cd392fe8SSimon Glass "GbE", 92cd392fe8SSimon Glass "Platform Data" 93cd392fe8SSimon Glass }; 94cd392fe8SSimon Glass 95cd392fe8SSimon Glass assert(region_type < MAX_REGIONS); 96cd392fe8SSimon Glass 97cd392fe8SSimon Glass return regions[region_type]; 98cd392fe8SSimon Glass } 99cd392fe8SSimon Glass 100cd392fe8SSimon Glass static const char *region_filename(int region_type) 101cd392fe8SSimon Glass { 102cd392fe8SSimon Glass static const char *const region_filenames[] = { 103cd392fe8SSimon Glass "flashregion_0_flashdescriptor.bin", 104cd392fe8SSimon Glass "flashregion_1_bios.bin", 105cd392fe8SSimon Glass "flashregion_2_intel_me.bin", 106cd392fe8SSimon Glass "flashregion_3_gbe.bin", 107cd392fe8SSimon Glass "flashregion_4_platform_data.bin" 108cd392fe8SSimon Glass }; 109cd392fe8SSimon Glass 110cd392fe8SSimon Glass assert(region_type < MAX_REGIONS); 111cd392fe8SSimon Glass 112cd392fe8SSimon Glass return region_filenames[region_type]; 113cd392fe8SSimon Glass } 114cd392fe8SSimon Glass 115cd392fe8SSimon Glass static int dump_region(int num, struct frba_t *frba) 116cd392fe8SSimon Glass { 117cd392fe8SSimon Glass struct region_t region; 118cd392fe8SSimon Glass int ret; 119cd392fe8SSimon Glass 120cd392fe8SSimon Glass ret = get_region(frba, num, ®ion); 121cd392fe8SSimon Glass if (ret) 122cd392fe8SSimon Glass return ret; 123cd392fe8SSimon Glass 124cd392fe8SSimon Glass printf(" Flash Region %d (%s): %08x - %08x %s\n", 125cd392fe8SSimon Glass num, region_name(num), region.base, region.limit, 126cd392fe8SSimon Glass region.size < 1 ? "(unused)" : ""); 127cd392fe8SSimon Glass 128cd392fe8SSimon Glass return ret; 129cd392fe8SSimon Glass } 130cd392fe8SSimon Glass 131cd392fe8SSimon Glass static void dump_frba(struct frba_t *frba) 132cd392fe8SSimon Glass { 133cd392fe8SSimon Glass int i; 134cd392fe8SSimon Glass 135cd392fe8SSimon Glass printf("Found Region Section\n"); 136cd392fe8SSimon Glass for (i = 0; i < MAX_REGIONS; i++) { 137cd392fe8SSimon Glass printf("FLREG%d: 0x%08x\n", i, frba->flreg[i]); 138cd392fe8SSimon Glass dump_region(i, frba); 139cd392fe8SSimon Glass } 140cd392fe8SSimon Glass } 141cd392fe8SSimon Glass 142cd392fe8SSimon Glass static void decode_spi_frequency(unsigned int freq) 143cd392fe8SSimon Glass { 144cd392fe8SSimon Glass switch (freq) { 145cd392fe8SSimon Glass case SPI_FREQUENCY_20MHZ: 146cd392fe8SSimon Glass printf("20MHz"); 147cd392fe8SSimon Glass break; 148cd392fe8SSimon Glass case SPI_FREQUENCY_33MHZ: 149cd392fe8SSimon Glass printf("33MHz"); 150cd392fe8SSimon Glass break; 151cd392fe8SSimon Glass case SPI_FREQUENCY_50MHZ: 152cd392fe8SSimon Glass printf("50MHz"); 153cd392fe8SSimon Glass break; 154cd392fe8SSimon Glass default: 155cd392fe8SSimon Glass printf("unknown<%x>MHz", freq); 156cd392fe8SSimon Glass } 157cd392fe8SSimon Glass } 158cd392fe8SSimon Glass 159cd392fe8SSimon Glass static void decode_component_density(unsigned int density) 160cd392fe8SSimon Glass { 161cd392fe8SSimon Glass switch (density) { 162cd392fe8SSimon Glass case COMPONENT_DENSITY_512KB: 163cd392fe8SSimon Glass printf("512KiB"); 164cd392fe8SSimon Glass break; 165cd392fe8SSimon Glass case COMPONENT_DENSITY_1MB: 166cd392fe8SSimon Glass printf("1MiB"); 167cd392fe8SSimon Glass break; 168cd392fe8SSimon Glass case COMPONENT_DENSITY_2MB: 169cd392fe8SSimon Glass printf("2MiB"); 170cd392fe8SSimon Glass break; 171cd392fe8SSimon Glass case COMPONENT_DENSITY_4MB: 172cd392fe8SSimon Glass printf("4MiB"); 173cd392fe8SSimon Glass break; 174cd392fe8SSimon Glass case COMPONENT_DENSITY_8MB: 175cd392fe8SSimon Glass printf("8MiB"); 176cd392fe8SSimon Glass break; 177cd392fe8SSimon Glass case COMPONENT_DENSITY_16MB: 178cd392fe8SSimon Glass printf("16MiB"); 179cd392fe8SSimon Glass break; 180cd392fe8SSimon Glass default: 181cd392fe8SSimon Glass printf("unknown<%x>MiB", density); 182cd392fe8SSimon Glass } 183cd392fe8SSimon Glass } 184cd392fe8SSimon Glass 185cd392fe8SSimon Glass static void dump_fcba(struct fcba_t *fcba) 186cd392fe8SSimon Glass { 187cd392fe8SSimon Glass printf("\nFound Component Section\n"); 188cd392fe8SSimon Glass printf("FLCOMP 0x%08x\n", fcba->flcomp); 189cd392fe8SSimon Glass printf(" Dual Output Fast Read Support: %ssupported\n", 190cd392fe8SSimon Glass (fcba->flcomp & (1 << 30)) ? "" : "not "); 191cd392fe8SSimon Glass printf(" Read ID/Read Status Clock Frequency: "); 192cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 27) & 7); 193cd392fe8SSimon Glass printf("\n Write/Erase Clock Frequency: "); 194cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 24) & 7); 195cd392fe8SSimon Glass printf("\n Fast Read Clock Frequency: "); 196cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 21) & 7); 197cd392fe8SSimon Glass printf("\n Fast Read Support: %ssupported", 198cd392fe8SSimon Glass (fcba->flcomp & (1 << 20)) ? "" : "not "); 199cd392fe8SSimon Glass printf("\n Read Clock Frequency: "); 200cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 17) & 7); 201cd392fe8SSimon Glass printf("\n Component 2 Density: "); 202cd392fe8SSimon Glass decode_component_density((fcba->flcomp >> 3) & 7); 203cd392fe8SSimon Glass printf("\n Component 1 Density: "); 204cd392fe8SSimon Glass decode_component_density(fcba->flcomp & 7); 205cd392fe8SSimon Glass printf("\n"); 206cd392fe8SSimon Glass printf("FLILL 0x%08x\n", fcba->flill); 207cd392fe8SSimon Glass printf(" Invalid Instruction 3: 0x%02x\n", 208cd392fe8SSimon Glass (fcba->flill >> 24) & 0xff); 209cd392fe8SSimon Glass printf(" Invalid Instruction 2: 0x%02x\n", 210cd392fe8SSimon Glass (fcba->flill >> 16) & 0xff); 211cd392fe8SSimon Glass printf(" Invalid Instruction 1: 0x%02x\n", 212cd392fe8SSimon Glass (fcba->flill >> 8) & 0xff); 213cd392fe8SSimon Glass printf(" Invalid Instruction 0: 0x%02x\n", 214cd392fe8SSimon Glass fcba->flill & 0xff); 215cd392fe8SSimon Glass printf("FLPB 0x%08x\n", fcba->flpb); 216cd392fe8SSimon Glass printf(" Flash Partition Boundary Address: 0x%06x\n\n", 217cd392fe8SSimon Glass (fcba->flpb & 0xfff) << 12); 218cd392fe8SSimon Glass } 219cd392fe8SSimon Glass 220cd392fe8SSimon Glass static void dump_fpsba(struct fpsba_t *fpsba) 221cd392fe8SSimon Glass { 222cd392fe8SSimon Glass int i; 223cd392fe8SSimon Glass 224cd392fe8SSimon Glass printf("Found PCH Strap Section\n"); 225cd392fe8SSimon Glass for (i = 0; i < MAX_STRAPS; i++) 226cd392fe8SSimon Glass printf("PCHSTRP%-2d: 0x%08x\n", i, fpsba->pchstrp[i]); 227cd392fe8SSimon Glass } 228cd392fe8SSimon Glass 229cd392fe8SSimon Glass static const char *get_enabled(int flag) 230cd392fe8SSimon Glass { 231cd392fe8SSimon Glass return flag ? "enabled" : "disabled"; 232cd392fe8SSimon Glass } 233cd392fe8SSimon Glass 234cd392fe8SSimon Glass static void decode_flmstr(uint32_t flmstr) 235cd392fe8SSimon Glass { 236cd392fe8SSimon Glass printf(" Platform Data Region Write Access: %s\n", 237cd392fe8SSimon Glass get_enabled(flmstr & (1 << 28))); 238cd392fe8SSimon Glass printf(" GbE Region Write Access: %s\n", 239cd392fe8SSimon Glass get_enabled(flmstr & (1 << 27))); 240cd392fe8SSimon Glass printf(" Intel ME Region Write Access: %s\n", 241cd392fe8SSimon Glass get_enabled(flmstr & (1 << 26))); 242cd392fe8SSimon Glass printf(" Host CPU/BIOS Region Write Access: %s\n", 243cd392fe8SSimon Glass get_enabled(flmstr & (1 << 25))); 244cd392fe8SSimon Glass printf(" Flash Descriptor Write Access: %s\n", 245cd392fe8SSimon Glass get_enabled(flmstr & (1 << 24))); 246cd392fe8SSimon Glass 247cd392fe8SSimon Glass printf(" Platform Data Region Read Access: %s\n", 248cd392fe8SSimon Glass get_enabled(flmstr & (1 << 20))); 249cd392fe8SSimon Glass printf(" GbE Region Read Access: %s\n", 250cd392fe8SSimon Glass get_enabled(flmstr & (1 << 19))); 251cd392fe8SSimon Glass printf(" Intel ME Region Read Access: %s\n", 252cd392fe8SSimon Glass get_enabled(flmstr & (1 << 18))); 253cd392fe8SSimon Glass printf(" Host CPU/BIOS Region Read Access: %s\n", 254cd392fe8SSimon Glass get_enabled(flmstr & (1 << 17))); 255cd392fe8SSimon Glass printf(" Flash Descriptor Read Access: %s\n", 256cd392fe8SSimon Glass get_enabled(flmstr & (1 << 16))); 257cd392fe8SSimon Glass 258cd392fe8SSimon Glass printf(" Requester ID: 0x%04x\n\n", 259cd392fe8SSimon Glass flmstr & 0xffff); 260cd392fe8SSimon Glass } 261cd392fe8SSimon Glass 262cd392fe8SSimon Glass static void dump_fmba(struct fmba_t *fmba) 263cd392fe8SSimon Glass { 264cd392fe8SSimon Glass printf("Found Master Section\n"); 265cd392fe8SSimon Glass printf("FLMSTR1: 0x%08x (Host CPU/BIOS)\n", fmba->flmstr1); 266cd392fe8SSimon Glass decode_flmstr(fmba->flmstr1); 267cd392fe8SSimon Glass printf("FLMSTR2: 0x%08x (Intel ME)\n", fmba->flmstr2); 268cd392fe8SSimon Glass decode_flmstr(fmba->flmstr2); 269cd392fe8SSimon Glass printf("FLMSTR3: 0x%08x (GbE)\n", fmba->flmstr3); 270cd392fe8SSimon Glass decode_flmstr(fmba->flmstr3); 271cd392fe8SSimon Glass } 272cd392fe8SSimon Glass 273cd392fe8SSimon Glass static void dump_fmsba(struct fmsba_t *fmsba) 274cd392fe8SSimon Glass { 275cd392fe8SSimon Glass int i; 276cd392fe8SSimon Glass 277cd392fe8SSimon Glass printf("Found Processor Strap Section\n"); 278cd392fe8SSimon Glass for (i = 0; i < 4; i++) 279cd392fe8SSimon Glass printf("????: 0x%08x\n", fmsba->data[0]); 280cd392fe8SSimon Glass } 281cd392fe8SSimon Glass 282cd392fe8SSimon Glass static void dump_jid(uint32_t jid) 283cd392fe8SSimon Glass { 284cd392fe8SSimon Glass printf(" SPI Component Device ID 1: 0x%02x\n", 285cd392fe8SSimon Glass (jid >> 16) & 0xff); 286cd392fe8SSimon Glass printf(" SPI Component Device ID 0: 0x%02x\n", 287cd392fe8SSimon Glass (jid >> 8) & 0xff); 288cd392fe8SSimon Glass printf(" SPI Component Vendor ID: 0x%02x\n", 289cd392fe8SSimon Glass jid & 0xff); 290cd392fe8SSimon Glass } 291cd392fe8SSimon Glass 292cd392fe8SSimon Glass static void dump_vscc(uint32_t vscc) 293cd392fe8SSimon Glass { 294cd392fe8SSimon Glass printf(" Lower Erase Opcode: 0x%02x\n", 295cd392fe8SSimon Glass vscc >> 24); 296cd392fe8SSimon Glass printf(" Lower Write Enable on Write Status: 0x%02x\n", 297cd392fe8SSimon Glass vscc & (1 << 20) ? 0x06 : 0x50); 298cd392fe8SSimon Glass printf(" Lower Write Status Required: %s\n", 299cd392fe8SSimon Glass vscc & (1 << 19) ? "Yes" : "No"); 300cd392fe8SSimon Glass printf(" Lower Write Granularity: %d bytes\n", 301cd392fe8SSimon Glass vscc & (1 << 18) ? 64 : 1); 302cd392fe8SSimon Glass printf(" Lower Block / Sector Erase Size: "); 303cd392fe8SSimon Glass switch ((vscc >> 16) & 0x3) { 304cd392fe8SSimon Glass case 0: 305cd392fe8SSimon Glass printf("256 Byte\n"); 306cd392fe8SSimon Glass break; 307cd392fe8SSimon Glass case 1: 308cd392fe8SSimon Glass printf("4KB\n"); 309cd392fe8SSimon Glass break; 310cd392fe8SSimon Glass case 2: 311cd392fe8SSimon Glass printf("8KB\n"); 312cd392fe8SSimon Glass break; 313cd392fe8SSimon Glass case 3: 314cd392fe8SSimon Glass printf("64KB\n"); 315cd392fe8SSimon Glass break; 316cd392fe8SSimon Glass } 317cd392fe8SSimon Glass 318cd392fe8SSimon Glass printf(" Upper Erase Opcode: 0x%02x\n", 319cd392fe8SSimon Glass (vscc >> 8) & 0xff); 320cd392fe8SSimon Glass printf(" Upper Write Enable on Write Status: 0x%02x\n", 321cd392fe8SSimon Glass vscc & (1 << 4) ? 0x06 : 0x50); 322cd392fe8SSimon Glass printf(" Upper Write Status Required: %s\n", 323cd392fe8SSimon Glass vscc & (1 << 3) ? "Yes" : "No"); 324cd392fe8SSimon Glass printf(" Upper Write Granularity: %d bytes\n", 325cd392fe8SSimon Glass vscc & (1 << 2) ? 64 : 1); 326cd392fe8SSimon Glass printf(" Upper Block / Sector Erase Size: "); 327cd392fe8SSimon Glass switch (vscc & 0x3) { 328cd392fe8SSimon Glass case 0: 329cd392fe8SSimon Glass printf("256 Byte\n"); 330cd392fe8SSimon Glass break; 331cd392fe8SSimon Glass case 1: 332cd392fe8SSimon Glass printf("4KB\n"); 333cd392fe8SSimon Glass break; 334cd392fe8SSimon Glass case 2: 335cd392fe8SSimon Glass printf("8KB\n"); 336cd392fe8SSimon Glass break; 337cd392fe8SSimon Glass case 3: 338cd392fe8SSimon Glass printf("64KB\n"); 339cd392fe8SSimon Glass break; 340cd392fe8SSimon Glass } 341cd392fe8SSimon Glass } 342cd392fe8SSimon Glass 343cd392fe8SSimon Glass static void dump_vtba(struct vtba_t *vtba, int vtl) 344cd392fe8SSimon Glass { 345cd392fe8SSimon Glass int i; 346cd392fe8SSimon Glass int num = (vtl >> 1) < 8 ? (vtl >> 1) : 8; 347cd392fe8SSimon Glass 348cd392fe8SSimon Glass printf("ME VSCC table:\n"); 349cd392fe8SSimon Glass for (i = 0; i < num; i++) { 350cd392fe8SSimon Glass printf(" JID%d: 0x%08x\n", i, vtba->entry[i].jid); 351cd392fe8SSimon Glass dump_jid(vtba->entry[i].jid); 352cd392fe8SSimon Glass printf(" VSCC%d: 0x%08x\n", i, vtba->entry[i].vscc); 353cd392fe8SSimon Glass dump_vscc(vtba->entry[i].vscc); 354cd392fe8SSimon Glass } 355cd392fe8SSimon Glass printf("\n"); 356cd392fe8SSimon Glass } 357cd392fe8SSimon Glass 358cd392fe8SSimon Glass static void dump_oem(uint8_t *oem) 359cd392fe8SSimon Glass { 360cd392fe8SSimon Glass int i, j; 361cd392fe8SSimon Glass printf("OEM Section:\n"); 362cd392fe8SSimon Glass for (i = 0; i < 4; i++) { 363cd392fe8SSimon Glass printf("%02x:", i << 4); 364cd392fe8SSimon Glass for (j = 0; j < 16; j++) 365cd392fe8SSimon Glass printf(" %02x", oem[(i<<4)+j]); 366cd392fe8SSimon Glass printf("\n"); 367cd392fe8SSimon Glass } 368cd392fe8SSimon Glass printf("\n"); 369cd392fe8SSimon Glass } 370cd392fe8SSimon Glass 371cd392fe8SSimon Glass /** 372cd392fe8SSimon Glass * dump_fd() - Display a dump of the full flash description 373cd392fe8SSimon Glass * 374cd392fe8SSimon Glass * @image: Pointer to image 375cd392fe8SSimon Glass * @size: Size of image in bytes 376cd392fe8SSimon Glass * @return 0 if OK, -1 on error 377cd392fe8SSimon Glass */ 378cd392fe8SSimon Glass static int dump_fd(char *image, int size) 379cd392fe8SSimon Glass { 380cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 381cd392fe8SSimon Glass 382cd392fe8SSimon Glass if (!fdb) 383cd392fe8SSimon Glass return -1; 384cd392fe8SSimon Glass 385cd392fe8SSimon Glass printf("FLMAP0: 0x%08x\n", fdb->flmap0); 386cd392fe8SSimon Glass printf(" NR: %d\n", (fdb->flmap0 >> 24) & 7); 387cd392fe8SSimon Glass printf(" FRBA: 0x%x\n", ((fdb->flmap0 >> 16) & 0xff) << 4); 388cd392fe8SSimon Glass printf(" NC: %d\n", ((fdb->flmap0 >> 8) & 3) + 1); 389cd392fe8SSimon Glass printf(" FCBA: 0x%x\n", ((fdb->flmap0) & 0xff) << 4); 390cd392fe8SSimon Glass 391cd392fe8SSimon Glass printf("FLMAP1: 0x%08x\n", fdb->flmap1); 392cd392fe8SSimon Glass printf(" ISL: 0x%02x\n", (fdb->flmap1 >> 24) & 0xff); 393cd392fe8SSimon Glass printf(" FPSBA: 0x%x\n", ((fdb->flmap1 >> 16) & 0xff) << 4); 394cd392fe8SSimon Glass printf(" NM: %d\n", (fdb->flmap1 >> 8) & 3); 395cd392fe8SSimon Glass printf(" FMBA: 0x%x\n", ((fdb->flmap1) & 0xff) << 4); 396cd392fe8SSimon Glass 397cd392fe8SSimon Glass printf("FLMAP2: 0x%08x\n", fdb->flmap2); 398cd392fe8SSimon Glass printf(" PSL: 0x%04x\n", (fdb->flmap2 >> 8) & 0xffff); 399cd392fe8SSimon Glass printf(" FMSBA: 0x%x\n", ((fdb->flmap2) & 0xff) << 4); 400cd392fe8SSimon Glass 401cd392fe8SSimon Glass printf("FLUMAP1: 0x%08x\n", fdb->flumap1); 402cd392fe8SSimon Glass printf(" Intel ME VSCC Table Length (VTL): %d\n", 403cd392fe8SSimon Glass (fdb->flumap1 >> 8) & 0xff); 404cd392fe8SSimon Glass printf(" Intel ME VSCC Table Base Address (VTBA): 0x%06x\n\n", 405cd392fe8SSimon Glass (fdb->flumap1 & 0xff) << 4); 406cd392fe8SSimon Glass dump_vtba((struct vtba_t *) 407cd392fe8SSimon Glass (image + ((fdb->flumap1 & 0xff) << 4)), 408cd392fe8SSimon Glass (fdb->flumap1 >> 8) & 0xff); 409cd392fe8SSimon Glass dump_oem((uint8_t *)image + 0xf00); 410cd392fe8SSimon Glass dump_frba((struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) 411cd392fe8SSimon Glass << 4))); 412cd392fe8SSimon Glass dump_fcba((struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4))); 413cd392fe8SSimon Glass dump_fpsba((struct fpsba_t *) 414cd392fe8SSimon Glass (image + (((fdb->flmap1 >> 16) & 0xff) << 4))); 415cd392fe8SSimon Glass dump_fmba((struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4))); 416cd392fe8SSimon Glass dump_fmsba((struct fmsba_t *)(image + (((fdb->flmap2) & 0xff) << 4))); 417cd392fe8SSimon Glass 418cd392fe8SSimon Glass return 0; 419cd392fe8SSimon Glass } 420cd392fe8SSimon Glass 421cd392fe8SSimon Glass /** 422cd392fe8SSimon Glass * write_regions() - Write each region from an image to its own file 423cd392fe8SSimon Glass * 424cd392fe8SSimon Glass * The filename to use in each case is fixed - see region_filename() 425cd392fe8SSimon Glass * 426cd392fe8SSimon Glass * @image: Pointer to image 427cd392fe8SSimon Glass * @size: Size of image in bytes 428cd392fe8SSimon Glass * @return 0 if OK, -ve on error 429cd392fe8SSimon Glass */ 430cd392fe8SSimon Glass static int write_regions(char *image, int size) 431cd392fe8SSimon Glass { 432cd392fe8SSimon Glass struct fdbar_t *fdb; 433cd392fe8SSimon Glass struct frba_t *frba; 434cd392fe8SSimon Glass int ret = 0; 435cd392fe8SSimon Glass int i; 436cd392fe8SSimon Glass 437cd392fe8SSimon Glass fdb = find_fd(image, size); 438cd392fe8SSimon Glass if (!fdb) 439cd392fe8SSimon Glass return -1; 440cd392fe8SSimon Glass 441cd392fe8SSimon Glass frba = (struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) << 4)); 442cd392fe8SSimon Glass 443cd392fe8SSimon Glass for (i = 0; i < MAX_REGIONS; i++) { 444cd392fe8SSimon Glass struct region_t region; 445cd392fe8SSimon Glass int region_fd; 446cd392fe8SSimon Glass 447cd392fe8SSimon Glass ret = get_region(frba, i, ®ion); 448cd392fe8SSimon Glass if (ret) 449cd392fe8SSimon Glass return ret; 450cd392fe8SSimon Glass dump_region(i, frba); 451cd392fe8SSimon Glass if (region.size == 0) 452cd392fe8SSimon Glass continue; 453cd392fe8SSimon Glass region_fd = open(region_filename(i), 454cd392fe8SSimon Glass O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | 455cd392fe8SSimon Glass S_IWUSR | S_IRGRP | S_IROTH); 456cd392fe8SSimon Glass if (write(region_fd, image + region.base, region.size) != 457cd392fe8SSimon Glass region.size) { 458cd392fe8SSimon Glass perror("Error while writing"); 459cd392fe8SSimon Glass ret = -1; 460cd392fe8SSimon Glass } 461cd392fe8SSimon Glass close(region_fd); 462cd392fe8SSimon Glass } 463cd392fe8SSimon Glass 464cd392fe8SSimon Glass return ret; 465cd392fe8SSimon Glass } 466cd392fe8SSimon Glass 467cd392fe8SSimon Glass /** 468cd392fe8SSimon Glass * write_image() - Write the image to a file 469cd392fe8SSimon Glass * 470cd392fe8SSimon Glass * @filename: Filename to use for the image 471cd392fe8SSimon Glass * @image: Pointer to image 472cd392fe8SSimon Glass * @size: Size of image in bytes 473cd392fe8SSimon Glass * @return 0 if OK, -ve on error 474cd392fe8SSimon Glass */ 475cd392fe8SSimon Glass static int write_image(char *filename, char *image, int size) 476cd392fe8SSimon Glass { 477cd392fe8SSimon Glass int new_fd; 478cd392fe8SSimon Glass 479cd392fe8SSimon Glass debug("Writing new image to %s\n", filename); 480cd392fe8SSimon Glass 481cd392fe8SSimon Glass new_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | 482cd392fe8SSimon Glass S_IWUSR | S_IRGRP | S_IROTH); 483cd392fe8SSimon Glass if (write(new_fd, image, size) != size) { 484cd392fe8SSimon Glass perror("Error while writing"); 485cd392fe8SSimon Glass return -1; 486cd392fe8SSimon Glass } 487cd392fe8SSimon Glass close(new_fd); 488cd392fe8SSimon Glass 489cd392fe8SSimon Glass return 0; 490cd392fe8SSimon Glass } 491cd392fe8SSimon Glass 492cd392fe8SSimon Glass /** 493cd392fe8SSimon Glass * set_spi_frequency() - Set the SPI frequency to use when booting 494cd392fe8SSimon Glass * 495cd392fe8SSimon Glass * Several frequencies are supported, some of which work with fast devices. 496cd392fe8SSimon Glass * For SPI emulators, the slowest (SPI_FREQUENCY_20MHZ) is often used. The 497cd392fe8SSimon Glass * Intel boot system uses this information somehow on boot. 498cd392fe8SSimon Glass * 499cd392fe8SSimon Glass * The image is updated with the supplied value 500cd392fe8SSimon Glass * 501cd392fe8SSimon Glass * @image: Pointer to image 502cd392fe8SSimon Glass * @size: Size of image in bytes 503cd392fe8SSimon Glass * @freq: SPI frequency to use 504cd392fe8SSimon Glass */ 505cd392fe8SSimon Glass static void set_spi_frequency(char *image, int size, enum spi_frequency freq) 506cd392fe8SSimon Glass { 507cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 508cd392fe8SSimon Glass struct fcba_t *fcba; 509cd392fe8SSimon Glass 510cd392fe8SSimon Glass fcba = (struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4)); 511cd392fe8SSimon Glass 512cd392fe8SSimon Glass /* clear bits 21-29 */ 513cd392fe8SSimon Glass fcba->flcomp &= ~0x3fe00000; 514cd392fe8SSimon Glass /* Read ID and Read Status Clock Frequency */ 515cd392fe8SSimon Glass fcba->flcomp |= freq << 27; 516cd392fe8SSimon Glass /* Write and Erase Clock Frequency */ 517cd392fe8SSimon Glass fcba->flcomp |= freq << 24; 518cd392fe8SSimon Glass /* Fast Read Clock Frequency */ 519cd392fe8SSimon Glass fcba->flcomp |= freq << 21; 520cd392fe8SSimon Glass } 521cd392fe8SSimon Glass 522cd392fe8SSimon Glass /** 523cd392fe8SSimon Glass * set_em100_mode() - Set a SPI frequency that will work with Dediprog EM100 524cd392fe8SSimon Glass * 525cd392fe8SSimon Glass * @image: Pointer to image 526cd392fe8SSimon Glass * @size: Size of image in bytes 527cd392fe8SSimon Glass */ 528cd392fe8SSimon Glass static void set_em100_mode(char *image, int size) 529cd392fe8SSimon Glass { 530cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 531cd392fe8SSimon Glass struct fcba_t *fcba; 532cd392fe8SSimon Glass 533cd392fe8SSimon Glass fcba = (struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4)); 534cd392fe8SSimon Glass fcba->flcomp &= ~(1 << 30); 535cd392fe8SSimon Glass set_spi_frequency(image, size, SPI_FREQUENCY_20MHZ); 536cd392fe8SSimon Glass } 537cd392fe8SSimon Glass 538cd392fe8SSimon Glass /** 539cd392fe8SSimon Glass * lock_descriptor() - Lock the NE descriptor so it cannot be updated 540cd392fe8SSimon Glass * 541cd392fe8SSimon Glass * @image: Pointer to image 542cd392fe8SSimon Glass * @size: Size of image in bytes 543cd392fe8SSimon Glass */ 544cd392fe8SSimon Glass static void lock_descriptor(char *image, int size) 545cd392fe8SSimon Glass { 546cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 547cd392fe8SSimon Glass struct fmba_t *fmba; 548cd392fe8SSimon Glass 549cd392fe8SSimon Glass /* 550cd392fe8SSimon Glass * TODO: Dynamically take Platform Data Region and GbE Region into 551cd392fe8SSimon Glass * account. 552cd392fe8SSimon Glass */ 553cd392fe8SSimon Glass fmba = (struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4)); 554cd392fe8SSimon Glass fmba->flmstr1 = 0x0a0b0000; 555cd392fe8SSimon Glass fmba->flmstr2 = 0x0c0d0000; 556cd392fe8SSimon Glass fmba->flmstr3 = 0x08080118; 557cd392fe8SSimon Glass } 558cd392fe8SSimon Glass 559cd392fe8SSimon Glass /** 560cd392fe8SSimon Glass * unlock_descriptor() - Lock the NE descriptor so it can be updated 561cd392fe8SSimon Glass * 562cd392fe8SSimon Glass * @image: Pointer to image 563cd392fe8SSimon Glass * @size: Size of image in bytes 564cd392fe8SSimon Glass */ 565cd392fe8SSimon Glass static void unlock_descriptor(char *image, int size) 566cd392fe8SSimon Glass { 567cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 568cd392fe8SSimon Glass struct fmba_t *fmba; 569cd392fe8SSimon Glass 570cd392fe8SSimon Glass fmba = (struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4)); 571cd392fe8SSimon Glass fmba->flmstr1 = 0xffff0000; 572cd392fe8SSimon Glass fmba->flmstr2 = 0xffff0000; 573cd392fe8SSimon Glass fmba->flmstr3 = 0x08080118; 574cd392fe8SSimon Glass } 575cd392fe8SSimon Glass 576cd392fe8SSimon Glass /** 577cd392fe8SSimon Glass * open_for_read() - Open a file for reading 578cd392fe8SSimon Glass * 579cd392fe8SSimon Glass * @fname: Filename to open 580cd392fe8SSimon Glass * @sizep: Returns file size in bytes 581cd392fe8SSimon Glass * @return 0 if OK, -1 on error 582cd392fe8SSimon Glass */ 583cd392fe8SSimon Glass int open_for_read(const char *fname, int *sizep) 584cd392fe8SSimon Glass { 585cd392fe8SSimon Glass int fd = open(fname, O_RDONLY); 586cd392fe8SSimon Glass struct stat buf; 587cd392fe8SSimon Glass 588cd392fe8SSimon Glass if (fd == -1) { 589cd392fe8SSimon Glass perror("Could not open file"); 590cd392fe8SSimon Glass return -1; 591cd392fe8SSimon Glass } 592cd392fe8SSimon Glass if (fstat(fd, &buf) == -1) { 593cd392fe8SSimon Glass perror("Could not stat file"); 594cd392fe8SSimon Glass return -1; 595cd392fe8SSimon Glass } 596cd392fe8SSimon Glass *sizep = buf.st_size; 597cd392fe8SSimon Glass debug("File %s is %d bytes\n", fname, *sizep); 598cd392fe8SSimon Glass 599cd392fe8SSimon Glass return fd; 600cd392fe8SSimon Glass } 601cd392fe8SSimon Glass 602cd392fe8SSimon Glass /** 603cd392fe8SSimon Glass * inject_region() - Add a file to an image region 604cd392fe8SSimon Glass * 605cd392fe8SSimon Glass * This puts a file into a particular region of the flash. Several pre-defined 606cd392fe8SSimon Glass * regions are used. 607cd392fe8SSimon Glass * 608cd392fe8SSimon Glass * @image: Pointer to image 609cd392fe8SSimon Glass * @size: Size of image in bytes 610cd392fe8SSimon Glass * @region_type: Region where the file should be added 611cd392fe8SSimon Glass * @region_fname: Filename to add to the image 612cd392fe8SSimon Glass * @return 0 if OK, -ve on error 613cd392fe8SSimon Glass */ 614cd392fe8SSimon Glass int inject_region(char *image, int size, int region_type, char *region_fname) 615cd392fe8SSimon Glass { 616cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 617cd392fe8SSimon Glass struct region_t region; 618cd392fe8SSimon Glass struct frba_t *frba; 619cd392fe8SSimon Glass int region_size; 620cd392fe8SSimon Glass int offset = 0; 621cd392fe8SSimon Glass int region_fd; 622cd392fe8SSimon Glass int ret; 623cd392fe8SSimon Glass 624cd392fe8SSimon Glass if (!fdb) 625cd392fe8SSimon Glass exit(EXIT_FAILURE); 626cd392fe8SSimon Glass frba = (struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) << 4)); 627cd392fe8SSimon Glass 628cd392fe8SSimon Glass ret = get_region(frba, region_type, ®ion); 629cd392fe8SSimon Glass if (ret) 630cd392fe8SSimon Glass return -1; 631cd392fe8SSimon Glass if (region.size <= 0xfff) { 632cd392fe8SSimon Glass fprintf(stderr, "Region %s is disabled in target. Not injecting.\n", 633cd392fe8SSimon Glass region_name(region_type)); 634cd392fe8SSimon Glass return -1; 635cd392fe8SSimon Glass } 636cd392fe8SSimon Glass 637cd392fe8SSimon Glass region_fd = open_for_read(region_fname, ®ion_size); 638cd392fe8SSimon Glass if (region_fd < 0) 639cd392fe8SSimon Glass return region_fd; 640cd392fe8SSimon Glass 641cd392fe8SSimon Glass if ((region_size > region.size) || 642cd392fe8SSimon Glass ((region_type != 1) && (region_size > region.size))) { 643cd392fe8SSimon Glass fprintf(stderr, "Region %s is %d(0x%x) bytes. File is %d(0x%x) bytes. Not injecting.\n", 644cd392fe8SSimon Glass region_name(region_type), region.size, 645cd392fe8SSimon Glass region.size, region_size, region_size); 646cd392fe8SSimon Glass return -1; 647cd392fe8SSimon Glass } 648cd392fe8SSimon Glass 649cd392fe8SSimon Glass if ((region_type == 1) && (region_size < region.size)) { 650cd392fe8SSimon Glass fprintf(stderr, "Region %s is %d(0x%x) bytes. File is %d(0x%x) bytes. Padding before injecting.\n", 651cd392fe8SSimon Glass region_name(region_type), region.size, 652cd392fe8SSimon Glass region.size, region_size, region_size); 653cd392fe8SSimon Glass offset = region.size - region_size; 654cd392fe8SSimon Glass memset(image + region.base, 0xff, offset); 655cd392fe8SSimon Glass } 656cd392fe8SSimon Glass 657cd392fe8SSimon Glass if (size < region.base + offset + region_size) { 658cd392fe8SSimon Glass fprintf(stderr, "Output file is too small. (%d < %d)\n", 659cd392fe8SSimon Glass size, region.base + offset + region_size); 660cd392fe8SSimon Glass return -1; 661cd392fe8SSimon Glass } 662cd392fe8SSimon Glass 663cd392fe8SSimon Glass if (read(region_fd, image + region.base + offset, region_size) 664cd392fe8SSimon Glass != region_size) { 665cd392fe8SSimon Glass perror("Could not read file"); 666cd392fe8SSimon Glass return -1; 667cd392fe8SSimon Glass } 668cd392fe8SSimon Glass 669cd392fe8SSimon Glass close(region_fd); 670cd392fe8SSimon Glass 671cd392fe8SSimon Glass debug("Adding %s as the %s section\n", region_fname, 672cd392fe8SSimon Glass region_name(region_type)); 673cd392fe8SSimon Glass 674cd392fe8SSimon Glass return 0; 675cd392fe8SSimon Glass } 676cd392fe8SSimon Glass 677cd392fe8SSimon Glass /** 678cd392fe8SSimon Glass * write_data() - Write some raw data into a region 679cd392fe8SSimon Glass * 680cd392fe8SSimon Glass * This puts a file into a particular place in the flash, ignoring the 681cd392fe8SSimon Glass * regions. Be careful not to overwrite something important. 682cd392fe8SSimon Glass * 683cd392fe8SSimon Glass * @image: Pointer to image 684cd392fe8SSimon Glass * @size: Size of image in bytes 685cd392fe8SSimon Glass * @addr: x86 ROM address to put file. The ROM ends at 686cd392fe8SSimon Glass * 0xffffffff so use an address relative to that. For an 687cd392fe8SSimon Glass * 8MB ROM the start address is 0xfff80000. 688cd392fe8SSimon Glass * @write_fname: Filename to add to the image 689cd392fe8SSimon Glass * @return 0 if OK, -ve on error 690cd392fe8SSimon Glass */ 691cd392fe8SSimon Glass static int write_data(char *image, int size, unsigned int addr, 692cd392fe8SSimon Glass const char *write_fname) 693cd392fe8SSimon Glass { 694cd392fe8SSimon Glass int write_fd, write_size; 695cd392fe8SSimon Glass int offset; 696cd392fe8SSimon Glass 697cd392fe8SSimon Glass write_fd = open_for_read(write_fname, &write_size); 698cd392fe8SSimon Glass if (write_fd < 0) 699cd392fe8SSimon Glass return write_fd; 700cd392fe8SSimon Glass 701cd392fe8SSimon Glass offset = addr + size; 702cd392fe8SSimon Glass debug("Writing %s to offset %#x\n", write_fname, offset); 703cd392fe8SSimon Glass 704cd392fe8SSimon Glass if (offset < 0 || offset + write_size > size) { 705cd392fe8SSimon Glass fprintf(stderr, "Output file is too small. (%d < %d)\n", 706cd392fe8SSimon Glass size, offset + write_size); 707cd392fe8SSimon Glass return -1; 708cd392fe8SSimon Glass } 709cd392fe8SSimon Glass 710cd392fe8SSimon Glass if (read(write_fd, image + offset, write_size) != write_size) { 711cd392fe8SSimon Glass perror("Could not read file"); 712cd392fe8SSimon Glass return -1; 713cd392fe8SSimon Glass } 714cd392fe8SSimon Glass 715cd392fe8SSimon Glass close(write_fd); 716cd392fe8SSimon Glass 717cd392fe8SSimon Glass return 0; 718cd392fe8SSimon Glass } 719cd392fe8SSimon Glass 720cd392fe8SSimon Glass static void print_version(void) 721cd392fe8SSimon Glass { 722cd392fe8SSimon Glass printf("ifdtool v%s -- ", IFDTOOL_VERSION); 723cd392fe8SSimon Glass printf("Copyright (C) 2014 Google Inc.\n\n"); 724cd392fe8SSimon Glass printf("SPDX-License-Identifier: GPL-2.0+\n"); 725cd392fe8SSimon Glass } 726cd392fe8SSimon Glass 727cd392fe8SSimon Glass static void print_usage(const char *name) 728cd392fe8SSimon Glass { 729cd392fe8SSimon Glass printf("usage: %s [-vhdix?] <filename> [<outfile>]\n", name); 730cd392fe8SSimon Glass printf("\n" 731cd392fe8SSimon Glass " -d | --dump: dump intel firmware descriptor\n" 732cd392fe8SSimon Glass " -x | --extract: extract intel fd modules\n" 733cd392fe8SSimon Glass " -i | --inject <region>:<module> inject file <module> into region <region>\n" 734cd392fe8SSimon Glass " -w | --write <addr>:<file> write file to appear at memory address <addr>\n" 735*673ed2f8SBin Meng " multiple files can be written simultaneously\n" 736cd392fe8SSimon Glass " -s | --spifreq <20|33|50> set the SPI frequency\n" 737cd392fe8SSimon Glass " -e | --em100 set SPI frequency to 20MHz and disable\n" 738cd392fe8SSimon Glass " Dual Output Fast Read Support\n" 739cd392fe8SSimon Glass " -l | --lock Lock firmware descriptor and ME region\n" 740cd392fe8SSimon Glass " -u | --unlock Unlock firmware descriptor and ME region\n" 741cd392fe8SSimon Glass " -r | --romsize Specify ROM size\n" 742cd392fe8SSimon Glass " -D | --write-descriptor <file> Write descriptor at base\n" 743cd392fe8SSimon Glass " -c | --create Create a new empty image\n" 744cd392fe8SSimon Glass " -v | --version: print the version\n" 745cd392fe8SSimon Glass " -h | --help: print this help\n\n" 746cd392fe8SSimon Glass "<region> is one of Descriptor, BIOS, ME, GbE, Platform\n" 747cd392fe8SSimon Glass "\n"); 748cd392fe8SSimon Glass } 749cd392fe8SSimon Glass 750cd392fe8SSimon Glass /** 751cd392fe8SSimon Glass * get_two_words() - Convert a string into two words separated by : 752cd392fe8SSimon Glass * 753cd392fe8SSimon Glass * The supplied string is split at ':', two substrings are allocated and 754cd392fe8SSimon Glass * returned. 755cd392fe8SSimon Glass * 756cd392fe8SSimon Glass * @str: String to split 757cd392fe8SSimon Glass * @firstp: Returns first string 758cd392fe8SSimon Glass * @secondp: Returns second string 759cd392fe8SSimon Glass * @return 0 if OK, -ve if @str does not have a : 760cd392fe8SSimon Glass */ 761cd392fe8SSimon Glass static int get_two_words(const char *str, char **firstp, char **secondp) 762cd392fe8SSimon Glass { 763cd392fe8SSimon Glass const char *p; 764cd392fe8SSimon Glass 765cd392fe8SSimon Glass p = strchr(str, ':'); 766cd392fe8SSimon Glass if (!p) 767cd392fe8SSimon Glass return -1; 768cd392fe8SSimon Glass *firstp = strdup(str); 769cd392fe8SSimon Glass (*firstp)[p - str] = '\0'; 770cd392fe8SSimon Glass *secondp = strdup(p + 1); 771cd392fe8SSimon Glass 772cd392fe8SSimon Glass return 0; 773cd392fe8SSimon Glass } 774cd392fe8SSimon Glass 775cd392fe8SSimon Glass int main(int argc, char *argv[]) 776cd392fe8SSimon Glass { 777cd392fe8SSimon Glass int opt, option_index = 0; 778cd392fe8SSimon Glass int mode_dump = 0, mode_extract = 0, mode_inject = 0; 779cd392fe8SSimon Glass int mode_spifreq = 0, mode_em100 = 0, mode_locked = 0; 780cd392fe8SSimon Glass int mode_unlocked = 0, mode_write = 0, mode_write_descriptor = 0; 781cd392fe8SSimon Glass int create = 0; 782cd392fe8SSimon Glass char *region_type_string = NULL, *src_fname = NULL; 783cd392fe8SSimon Glass char *addr_str = NULL; 784cd392fe8SSimon Glass int region_type = -1, inputfreq = 0; 785cd392fe8SSimon Glass enum spi_frequency spifreq = SPI_FREQUENCY_20MHZ; 786*673ed2f8SBin Meng unsigned int addr[WRITE_MAX]; 787*673ed2f8SBin Meng char *wr_fname[WRITE_MAX]; 788*673ed2f8SBin Meng unsigned char wr_idx, wr_num = 0; 789cd392fe8SSimon Glass int rom_size = -1; 790cd392fe8SSimon Glass bool write_it; 791cd392fe8SSimon Glass char *filename; 792cd392fe8SSimon Glass char *outfile = NULL; 793cd392fe8SSimon Glass struct stat buf; 794cd392fe8SSimon Glass int size = 0; 795cd392fe8SSimon Glass int bios_fd; 796cd392fe8SSimon Glass char *image; 797cd392fe8SSimon Glass int ret; 798cd392fe8SSimon Glass static struct option long_options[] = { 799cd392fe8SSimon Glass {"create", 0, NULL, 'c'}, 800cd392fe8SSimon Glass {"dump", 0, NULL, 'd'}, 801cd392fe8SSimon Glass {"descriptor", 1, NULL, 'D'}, 802cd392fe8SSimon Glass {"em100", 0, NULL, 'e'}, 803cd392fe8SSimon Glass {"extract", 0, NULL, 'x'}, 804cd392fe8SSimon Glass {"inject", 1, NULL, 'i'}, 805cd392fe8SSimon Glass {"lock", 0, NULL, 'l'}, 806cd392fe8SSimon Glass {"romsize", 1, NULL, 'r'}, 807cd392fe8SSimon Glass {"spifreq", 1, NULL, 's'}, 808cd392fe8SSimon Glass {"unlock", 0, NULL, 'u'}, 809cd392fe8SSimon Glass {"write", 1, NULL, 'w'}, 810cd392fe8SSimon Glass {"version", 0, NULL, 'v'}, 811cd392fe8SSimon Glass {"help", 0, NULL, 'h'}, 812cd392fe8SSimon Glass {0, 0, 0, 0} 813cd392fe8SSimon Glass }; 814cd392fe8SSimon Glass 815cd392fe8SSimon Glass while ((opt = getopt_long(argc, argv, "cdD:ehi:lr:s:uvw:x?", 816cd392fe8SSimon Glass long_options, &option_index)) != EOF) { 817cd392fe8SSimon Glass switch (opt) { 818cd392fe8SSimon Glass case 'c': 819cd392fe8SSimon Glass create = 1; 820cd392fe8SSimon Glass break; 821cd392fe8SSimon Glass case 'd': 822cd392fe8SSimon Glass mode_dump = 1; 823cd392fe8SSimon Glass break; 824cd392fe8SSimon Glass case 'D': 825cd392fe8SSimon Glass mode_write_descriptor = 1; 826cd392fe8SSimon Glass src_fname = optarg; 827cd392fe8SSimon Glass break; 828cd392fe8SSimon Glass case 'e': 829cd392fe8SSimon Glass mode_em100 = 1; 830cd392fe8SSimon Glass break; 831cd392fe8SSimon Glass case 'i': 832cd392fe8SSimon Glass if (get_two_words(optarg, ®ion_type_string, 833cd392fe8SSimon Glass &src_fname)) { 834cd392fe8SSimon Glass print_usage(argv[0]); 835cd392fe8SSimon Glass exit(EXIT_FAILURE); 836cd392fe8SSimon Glass } 837cd392fe8SSimon Glass if (!strcasecmp("Descriptor", region_type_string)) 838cd392fe8SSimon Glass region_type = 0; 839cd392fe8SSimon Glass else if (!strcasecmp("BIOS", region_type_string)) 840cd392fe8SSimon Glass region_type = 1; 841cd392fe8SSimon Glass else if (!strcasecmp("ME", region_type_string)) 842cd392fe8SSimon Glass region_type = 2; 843cd392fe8SSimon Glass else if (!strcasecmp("GbE", region_type_string)) 844cd392fe8SSimon Glass region_type = 3; 845cd392fe8SSimon Glass else if (!strcasecmp("Platform", region_type_string)) 846cd392fe8SSimon Glass region_type = 4; 847cd392fe8SSimon Glass if (region_type == -1) { 848cd392fe8SSimon Glass fprintf(stderr, "No such region type: '%s'\n\n", 849cd392fe8SSimon Glass region_type_string); 850cd392fe8SSimon Glass print_usage(argv[0]); 851cd392fe8SSimon Glass exit(EXIT_FAILURE); 852cd392fe8SSimon Glass } 853cd392fe8SSimon Glass mode_inject = 1; 854cd392fe8SSimon Glass break; 855cd392fe8SSimon Glass case 'l': 856cd392fe8SSimon Glass mode_locked = 1; 857cd392fe8SSimon Glass break; 858cd392fe8SSimon Glass case 'r': 859cd392fe8SSimon Glass rom_size = strtol(optarg, NULL, 0); 860cd392fe8SSimon Glass debug("ROM size %d\n", rom_size); 861cd392fe8SSimon Glass break; 862cd392fe8SSimon Glass case 's': 863cd392fe8SSimon Glass /* Parse the requested SPI frequency */ 864cd392fe8SSimon Glass inputfreq = strtol(optarg, NULL, 0); 865cd392fe8SSimon Glass switch (inputfreq) { 866cd392fe8SSimon Glass case 20: 867cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_20MHZ; 868cd392fe8SSimon Glass break; 869cd392fe8SSimon Glass case 33: 870cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_33MHZ; 871cd392fe8SSimon Glass break; 872cd392fe8SSimon Glass case 50: 873cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_50MHZ; 874cd392fe8SSimon Glass break; 875cd392fe8SSimon Glass default: 876cd392fe8SSimon Glass fprintf(stderr, "Invalid SPI Frequency: %d\n", 877cd392fe8SSimon Glass inputfreq); 878cd392fe8SSimon Glass print_usage(argv[0]); 879cd392fe8SSimon Glass exit(EXIT_FAILURE); 880cd392fe8SSimon Glass } 881cd392fe8SSimon Glass mode_spifreq = 1; 882cd392fe8SSimon Glass break; 883cd392fe8SSimon Glass case 'u': 884cd392fe8SSimon Glass mode_unlocked = 1; 885cd392fe8SSimon Glass break; 886cd392fe8SSimon Glass case 'v': 887cd392fe8SSimon Glass print_version(); 888cd392fe8SSimon Glass exit(EXIT_SUCCESS); 889cd392fe8SSimon Glass break; 890cd392fe8SSimon Glass case 'w': 891cd392fe8SSimon Glass mode_write = 1; 892*673ed2f8SBin Meng if (wr_num < WRITE_MAX) { 893*673ed2f8SBin Meng if (get_two_words(optarg, &addr_str, 894*673ed2f8SBin Meng &wr_fname[wr_num])) { 895cd392fe8SSimon Glass print_usage(argv[0]); 896cd392fe8SSimon Glass exit(EXIT_FAILURE); 897cd392fe8SSimon Glass } 898*673ed2f8SBin Meng addr[wr_num] = strtol(optarg, NULL, 0); 899*673ed2f8SBin Meng wr_num++; 900*673ed2f8SBin Meng } else { 901*673ed2f8SBin Meng fprintf(stderr, 902*673ed2f8SBin Meng "The number of files to write simultaneously exceeds the limitation (%d)\n", 903*673ed2f8SBin Meng WRITE_MAX); 904*673ed2f8SBin Meng } 905cd392fe8SSimon Glass break; 906cd392fe8SSimon Glass case 'x': 907cd392fe8SSimon Glass mode_extract = 1; 908cd392fe8SSimon Glass break; 909cd392fe8SSimon Glass case 'h': 910cd392fe8SSimon Glass case '?': 911cd392fe8SSimon Glass default: 912cd392fe8SSimon Glass print_usage(argv[0]); 913cd392fe8SSimon Glass exit(EXIT_SUCCESS); 914cd392fe8SSimon Glass break; 915cd392fe8SSimon Glass } 916cd392fe8SSimon Glass } 917cd392fe8SSimon Glass 918cd392fe8SSimon Glass if (mode_locked == 1 && mode_unlocked == 1) { 919cd392fe8SSimon Glass fprintf(stderr, "Locking/Unlocking FD and ME are mutually exclusive\n"); 920cd392fe8SSimon Glass exit(EXIT_FAILURE); 921cd392fe8SSimon Glass } 922cd392fe8SSimon Glass 923cd392fe8SSimon Glass if (mode_inject == 1 && mode_write == 1) { 924cd392fe8SSimon Glass fprintf(stderr, "Inject/Write are mutually exclusive\n"); 925cd392fe8SSimon Glass exit(EXIT_FAILURE); 926cd392fe8SSimon Glass } 927cd392fe8SSimon Glass 928cd392fe8SSimon Glass if ((mode_dump + mode_extract + mode_inject + 929cd392fe8SSimon Glass (mode_spifreq | mode_em100 | mode_unlocked | 930cd392fe8SSimon Glass mode_locked)) > 1) { 931cd392fe8SSimon Glass fprintf(stderr, "You may not specify more than one mode.\n\n"); 932cd392fe8SSimon Glass print_usage(argv[0]); 933cd392fe8SSimon Glass exit(EXIT_FAILURE); 934cd392fe8SSimon Glass } 935cd392fe8SSimon Glass 936cd392fe8SSimon Glass if ((mode_dump + mode_extract + mode_inject + mode_spifreq + 937cd392fe8SSimon Glass mode_em100 + mode_locked + mode_unlocked + mode_write + 938c03c951bSSimon Glass mode_write_descriptor) == 0 && !create) { 939cd392fe8SSimon Glass fprintf(stderr, "You need to specify a mode.\n\n"); 940cd392fe8SSimon Glass print_usage(argv[0]); 941cd392fe8SSimon Glass exit(EXIT_FAILURE); 942cd392fe8SSimon Glass } 943cd392fe8SSimon Glass 944cd392fe8SSimon Glass if (create && rom_size == -1) { 945cd392fe8SSimon Glass fprintf(stderr, "You need to specify a rom size when creating.\n\n"); 946cd392fe8SSimon Glass exit(EXIT_FAILURE); 947cd392fe8SSimon Glass } 948cd392fe8SSimon Glass 949cd392fe8SSimon Glass if (optind + 1 != argc) { 950cd392fe8SSimon Glass fprintf(stderr, "You need to specify a file.\n\n"); 951cd392fe8SSimon Glass print_usage(argv[0]); 952cd392fe8SSimon Glass exit(EXIT_FAILURE); 953cd392fe8SSimon Glass } 954cd392fe8SSimon Glass 955cd392fe8SSimon Glass filename = argv[optind]; 956cd392fe8SSimon Glass if (optind + 2 != argc) 957cd392fe8SSimon Glass outfile = argv[optind + 1]; 958cd392fe8SSimon Glass 959cd392fe8SSimon Glass if (create) 960cd392fe8SSimon Glass bios_fd = open(filename, O_WRONLY | O_CREAT, 0666); 961cd392fe8SSimon Glass else 962cd392fe8SSimon Glass bios_fd = open(filename, outfile ? O_RDONLY : O_RDWR); 963cd392fe8SSimon Glass 964cd392fe8SSimon Glass if (bios_fd == -1) { 965cd392fe8SSimon Glass perror("Could not open file"); 966cd392fe8SSimon Glass exit(EXIT_FAILURE); 967cd392fe8SSimon Glass } 968cd392fe8SSimon Glass 969cd392fe8SSimon Glass if (!create) { 970cd392fe8SSimon Glass if (fstat(bios_fd, &buf) == -1) { 971cd392fe8SSimon Glass perror("Could not stat file"); 972cd392fe8SSimon Glass exit(EXIT_FAILURE); 973cd392fe8SSimon Glass } 974cd392fe8SSimon Glass size = buf.st_size; 975cd392fe8SSimon Glass } 976cd392fe8SSimon Glass 977cd392fe8SSimon Glass debug("File %s is %d bytes\n", filename, size); 978cd392fe8SSimon Glass 979cd392fe8SSimon Glass if (rom_size == -1) 980cd392fe8SSimon Glass rom_size = size; 981cd392fe8SSimon Glass 982cd392fe8SSimon Glass image = malloc(rom_size); 983cd392fe8SSimon Glass if (!image) { 984cd392fe8SSimon Glass printf("Out of memory.\n"); 985cd392fe8SSimon Glass exit(EXIT_FAILURE); 986cd392fe8SSimon Glass } 987cd392fe8SSimon Glass 988cd392fe8SSimon Glass memset(image, '\xff', rom_size); 989cd392fe8SSimon Glass if (!create && read(bios_fd, image, size) != size) { 990cd392fe8SSimon Glass perror("Could not read file"); 991cd392fe8SSimon Glass exit(EXIT_FAILURE); 992cd392fe8SSimon Glass } 993cd392fe8SSimon Glass if (size != rom_size) { 994cd392fe8SSimon Glass debug("ROM size changed to %d bytes\n", rom_size); 995cd392fe8SSimon Glass size = rom_size; 996cd392fe8SSimon Glass } 997cd392fe8SSimon Glass 998cd392fe8SSimon Glass write_it = true; 999cd392fe8SSimon Glass ret = 0; 1000cd392fe8SSimon Glass if (mode_dump) { 1001cd392fe8SSimon Glass ret = dump_fd(image, size); 1002cd392fe8SSimon Glass write_it = false; 1003cd392fe8SSimon Glass } 1004cd392fe8SSimon Glass 1005cd392fe8SSimon Glass if (mode_extract) { 1006cd392fe8SSimon Glass ret = write_regions(image, size); 1007cd392fe8SSimon Glass write_it = false; 1008cd392fe8SSimon Glass } 1009cd392fe8SSimon Glass 1010cd392fe8SSimon Glass if (mode_write_descriptor) 1011cd392fe8SSimon Glass ret = write_data(image, size, -size, src_fname); 1012cd392fe8SSimon Glass 1013cd392fe8SSimon Glass if (mode_inject) 1014cd392fe8SSimon Glass ret = inject_region(image, size, region_type, src_fname); 1015cd392fe8SSimon Glass 1016*673ed2f8SBin Meng if (mode_write) { 1017*673ed2f8SBin Meng for (wr_idx = 0; wr_idx < wr_num; wr_idx++) { 1018*673ed2f8SBin Meng ret = write_data(image, size, 1019*673ed2f8SBin Meng addr[wr_idx], wr_fname[wr_idx]); 1020*673ed2f8SBin Meng if (ret) 1021*673ed2f8SBin Meng break; 1022*673ed2f8SBin Meng } 1023*673ed2f8SBin Meng } 1024cd392fe8SSimon Glass 1025cd392fe8SSimon Glass if (mode_spifreq) 1026cd392fe8SSimon Glass set_spi_frequency(image, size, spifreq); 1027cd392fe8SSimon Glass 1028cd392fe8SSimon Glass if (mode_em100) 1029cd392fe8SSimon Glass set_em100_mode(image, size); 1030cd392fe8SSimon Glass 1031cd392fe8SSimon Glass if (mode_locked) 1032cd392fe8SSimon Glass lock_descriptor(image, size); 1033cd392fe8SSimon Glass 1034cd392fe8SSimon Glass if (mode_unlocked) 1035cd392fe8SSimon Glass unlock_descriptor(image, size); 1036cd392fe8SSimon Glass 1037cd392fe8SSimon Glass if (write_it) { 1038cd392fe8SSimon Glass if (outfile) { 1039cd392fe8SSimon Glass ret = write_image(outfile, image, size); 1040cd392fe8SSimon Glass } else { 1041cd392fe8SSimon Glass if (lseek(bios_fd, 0, SEEK_SET)) { 1042cd392fe8SSimon Glass perror("Error while seeking"); 1043cd392fe8SSimon Glass ret = -1; 1044cd392fe8SSimon Glass } 1045cd392fe8SSimon Glass if (write(bios_fd, image, size) != size) { 1046cd392fe8SSimon Glass perror("Error while writing"); 1047cd392fe8SSimon Glass ret = -1; 1048cd392fe8SSimon Glass } 1049cd392fe8SSimon Glass } 1050cd392fe8SSimon Glass } 1051cd392fe8SSimon Glass 1052cd392fe8SSimon Glass free(image); 1053cd392fe8SSimon Glass close(bios_fd); 1054cd392fe8SSimon Glass 1055cd392fe8SSimon Glass return ret ? 1 : 0; 1056cd392fe8SSimon Glass } 1057