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> 2131eca697SSimon Glass #include <libfdt.h> 22cd392fe8SSimon Glass #include "ifdtool.h" 23cd392fe8SSimon Glass 24cd392fe8SSimon Glass #undef DEBUG 25cd392fe8SSimon Glass 26cd392fe8SSimon Glass #ifdef DEBUG 27cd392fe8SSimon Glass #define debug(fmt, args...) printf(fmt, ##args) 28cd392fe8SSimon Glass #else 29cd392fe8SSimon Glass #define debug(fmt, args...) 30cd392fe8SSimon Glass #endif 31cd392fe8SSimon Glass 32cd392fe8SSimon Glass #define FD_SIGNATURE 0x0FF0A55A 33cd392fe8SSimon Glass #define FLREG_BASE(reg) ((reg & 0x00000fff) << 12); 34cd392fe8SSimon Glass #define FLREG_LIMIT(reg) (((reg & 0x0fff0000) >> 4) | 0xfff); 35cd392fe8SSimon Glass 3665851fceSSimon Glass enum input_file_type_t { 3765851fceSSimon Glass IF_normal, 3831eca697SSimon Glass IF_fdt, 3931eca697SSimon Glass IF_uboot, 4065851fceSSimon Glass }; 4165851fceSSimon Glass 4265851fceSSimon Glass struct input_file { 4365851fceSSimon Glass char *fname; 4465851fceSSimon Glass unsigned int addr; 4565851fceSSimon Glass enum input_file_type_t type; 4665851fceSSimon Glass }; 4765851fceSSimon Glass 48cd392fe8SSimon Glass /** 49cd392fe8SSimon Glass * find_fd() - Find the flash description in the ROM image 50cd392fe8SSimon Glass * 51cd392fe8SSimon Glass * @image: Pointer to image 52cd392fe8SSimon Glass * @size: Size of image in bytes 53cd392fe8SSimon Glass * @return pointer to structure, or NULL if not found 54cd392fe8SSimon Glass */ 55cd392fe8SSimon Glass static struct fdbar_t *find_fd(char *image, int size) 56cd392fe8SSimon Glass { 57cd392fe8SSimon Glass uint32_t *ptr, *end; 58cd392fe8SSimon Glass 59cd392fe8SSimon Glass /* Scan for FD signature */ 60cd392fe8SSimon Glass for (ptr = (uint32_t *)image, end = ptr + size / 4; ptr < end; ptr++) { 61cd392fe8SSimon Glass if (*ptr == FD_SIGNATURE) 62cd392fe8SSimon Glass break; 63cd392fe8SSimon Glass } 64cd392fe8SSimon Glass 65cd392fe8SSimon Glass if (ptr == end) { 66cd392fe8SSimon Glass printf("No Flash Descriptor found in this image\n"); 67cd392fe8SSimon Glass return NULL; 68cd392fe8SSimon Glass } 69cd392fe8SSimon Glass 707e8ffa4eSSimon Glass debug("Found Flash Descriptor signature at 0x%08lx\n", 717e8ffa4eSSimon Glass (char *)ptr - image); 72cd392fe8SSimon Glass 73cd392fe8SSimon Glass return (struct fdbar_t *)ptr; 74cd392fe8SSimon Glass } 75cd392fe8SSimon Glass 76cd392fe8SSimon Glass /** 77cd392fe8SSimon Glass * get_region() - Get information about the selected region 78cd392fe8SSimon Glass * 79cd392fe8SSimon Glass * @frba: Flash region list 80cd392fe8SSimon Glass * @region_type: Type of region (0..MAX_REGIONS-1) 81cd392fe8SSimon Glass * @region: Region information is written here 82cd392fe8SSimon Glass * @return 0 if OK, else -ve 83cd392fe8SSimon Glass */ 84cd392fe8SSimon Glass static int get_region(struct frba_t *frba, int region_type, 85cd392fe8SSimon Glass struct region_t *region) 86cd392fe8SSimon Glass { 87cd392fe8SSimon Glass if (region_type >= MAX_REGIONS) { 88cd392fe8SSimon Glass fprintf(stderr, "Invalid region type.\n"); 89cd392fe8SSimon Glass return -1; 90cd392fe8SSimon Glass } 91cd392fe8SSimon Glass 92cd392fe8SSimon Glass region->base = FLREG_BASE(frba->flreg[region_type]); 93cd392fe8SSimon Glass region->limit = FLREG_LIMIT(frba->flreg[region_type]); 94cd392fe8SSimon Glass region->size = region->limit - region->base + 1; 95cd392fe8SSimon Glass 96cd392fe8SSimon Glass return 0; 97cd392fe8SSimon Glass } 98cd392fe8SSimon Glass 99cd392fe8SSimon Glass static const char *region_name(int region_type) 100cd392fe8SSimon Glass { 101cd392fe8SSimon Glass static const char *const regions[] = { 102cd392fe8SSimon Glass "Flash Descriptor", 103cd392fe8SSimon Glass "BIOS", 104cd392fe8SSimon Glass "Intel ME", 105cd392fe8SSimon Glass "GbE", 106cd392fe8SSimon Glass "Platform Data" 107cd392fe8SSimon Glass }; 108cd392fe8SSimon Glass 109cd392fe8SSimon Glass assert(region_type < MAX_REGIONS); 110cd392fe8SSimon Glass 111cd392fe8SSimon Glass return regions[region_type]; 112cd392fe8SSimon Glass } 113cd392fe8SSimon Glass 114cd392fe8SSimon Glass static const char *region_filename(int region_type) 115cd392fe8SSimon Glass { 116cd392fe8SSimon Glass static const char *const region_filenames[] = { 117cd392fe8SSimon Glass "flashregion_0_flashdescriptor.bin", 118cd392fe8SSimon Glass "flashregion_1_bios.bin", 119cd392fe8SSimon Glass "flashregion_2_intel_me.bin", 120cd392fe8SSimon Glass "flashregion_3_gbe.bin", 121cd392fe8SSimon Glass "flashregion_4_platform_data.bin" 122cd392fe8SSimon Glass }; 123cd392fe8SSimon Glass 124cd392fe8SSimon Glass assert(region_type < MAX_REGIONS); 125cd392fe8SSimon Glass 126cd392fe8SSimon Glass return region_filenames[region_type]; 127cd392fe8SSimon Glass } 128cd392fe8SSimon Glass 129cd392fe8SSimon Glass static int dump_region(int num, struct frba_t *frba) 130cd392fe8SSimon Glass { 131cd392fe8SSimon Glass struct region_t region; 132cd392fe8SSimon Glass int ret; 133cd392fe8SSimon Glass 134cd392fe8SSimon Glass ret = get_region(frba, num, ®ion); 135cd392fe8SSimon Glass if (ret) 136cd392fe8SSimon Glass return ret; 137cd392fe8SSimon Glass 138cd392fe8SSimon Glass printf(" Flash Region %d (%s): %08x - %08x %s\n", 139cd392fe8SSimon Glass num, region_name(num), region.base, region.limit, 140cd392fe8SSimon Glass region.size < 1 ? "(unused)" : ""); 141cd392fe8SSimon Glass 142cd392fe8SSimon Glass return ret; 143cd392fe8SSimon Glass } 144cd392fe8SSimon Glass 145cd392fe8SSimon Glass static void dump_frba(struct frba_t *frba) 146cd392fe8SSimon Glass { 147cd392fe8SSimon Glass int i; 148cd392fe8SSimon Glass 149cd392fe8SSimon Glass printf("Found Region Section\n"); 150cd392fe8SSimon Glass for (i = 0; i < MAX_REGIONS; i++) { 151cd392fe8SSimon Glass printf("FLREG%d: 0x%08x\n", i, frba->flreg[i]); 152cd392fe8SSimon Glass dump_region(i, frba); 153cd392fe8SSimon Glass } 154cd392fe8SSimon Glass } 155cd392fe8SSimon Glass 156cd392fe8SSimon Glass static void decode_spi_frequency(unsigned int freq) 157cd392fe8SSimon Glass { 158cd392fe8SSimon Glass switch (freq) { 159cd392fe8SSimon Glass case SPI_FREQUENCY_20MHZ: 160cd392fe8SSimon Glass printf("20MHz"); 161cd392fe8SSimon Glass break; 162cd392fe8SSimon Glass case SPI_FREQUENCY_33MHZ: 163cd392fe8SSimon Glass printf("33MHz"); 164cd392fe8SSimon Glass break; 165cd392fe8SSimon Glass case SPI_FREQUENCY_50MHZ: 166cd392fe8SSimon Glass printf("50MHz"); 167cd392fe8SSimon Glass break; 168cd392fe8SSimon Glass default: 169cd392fe8SSimon Glass printf("unknown<%x>MHz", freq); 170cd392fe8SSimon Glass } 171cd392fe8SSimon Glass } 172cd392fe8SSimon Glass 173cd392fe8SSimon Glass static void decode_component_density(unsigned int density) 174cd392fe8SSimon Glass { 175cd392fe8SSimon Glass switch (density) { 176cd392fe8SSimon Glass case COMPONENT_DENSITY_512KB: 177cd392fe8SSimon Glass printf("512KiB"); 178cd392fe8SSimon Glass break; 179cd392fe8SSimon Glass case COMPONENT_DENSITY_1MB: 180cd392fe8SSimon Glass printf("1MiB"); 181cd392fe8SSimon Glass break; 182cd392fe8SSimon Glass case COMPONENT_DENSITY_2MB: 183cd392fe8SSimon Glass printf("2MiB"); 184cd392fe8SSimon Glass break; 185cd392fe8SSimon Glass case COMPONENT_DENSITY_4MB: 186cd392fe8SSimon Glass printf("4MiB"); 187cd392fe8SSimon Glass break; 188cd392fe8SSimon Glass case COMPONENT_DENSITY_8MB: 189cd392fe8SSimon Glass printf("8MiB"); 190cd392fe8SSimon Glass break; 191cd392fe8SSimon Glass case COMPONENT_DENSITY_16MB: 192cd392fe8SSimon Glass printf("16MiB"); 193cd392fe8SSimon Glass break; 194cd392fe8SSimon Glass default: 195cd392fe8SSimon Glass printf("unknown<%x>MiB", density); 196cd392fe8SSimon Glass } 197cd392fe8SSimon Glass } 198cd392fe8SSimon Glass 199cd392fe8SSimon Glass static void dump_fcba(struct fcba_t *fcba) 200cd392fe8SSimon Glass { 201cd392fe8SSimon Glass printf("\nFound Component Section\n"); 202cd392fe8SSimon Glass printf("FLCOMP 0x%08x\n", fcba->flcomp); 203cd392fe8SSimon Glass printf(" Dual Output Fast Read Support: %ssupported\n", 204cd392fe8SSimon Glass (fcba->flcomp & (1 << 30)) ? "" : "not "); 205cd392fe8SSimon Glass printf(" Read ID/Read Status Clock Frequency: "); 206cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 27) & 7); 207cd392fe8SSimon Glass printf("\n Write/Erase Clock Frequency: "); 208cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 24) & 7); 209cd392fe8SSimon Glass printf("\n Fast Read Clock Frequency: "); 210cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 21) & 7); 211cd392fe8SSimon Glass printf("\n Fast Read Support: %ssupported", 212cd392fe8SSimon Glass (fcba->flcomp & (1 << 20)) ? "" : "not "); 213cd392fe8SSimon Glass printf("\n Read Clock Frequency: "); 214cd392fe8SSimon Glass decode_spi_frequency((fcba->flcomp >> 17) & 7); 215cd392fe8SSimon Glass printf("\n Component 2 Density: "); 216cd392fe8SSimon Glass decode_component_density((fcba->flcomp >> 3) & 7); 217cd392fe8SSimon Glass printf("\n Component 1 Density: "); 218cd392fe8SSimon Glass decode_component_density(fcba->flcomp & 7); 219cd392fe8SSimon Glass printf("\n"); 220cd392fe8SSimon Glass printf("FLILL 0x%08x\n", fcba->flill); 221cd392fe8SSimon Glass printf(" Invalid Instruction 3: 0x%02x\n", 222cd392fe8SSimon Glass (fcba->flill >> 24) & 0xff); 223cd392fe8SSimon Glass printf(" Invalid Instruction 2: 0x%02x\n", 224cd392fe8SSimon Glass (fcba->flill >> 16) & 0xff); 225cd392fe8SSimon Glass printf(" Invalid Instruction 1: 0x%02x\n", 226cd392fe8SSimon Glass (fcba->flill >> 8) & 0xff); 227cd392fe8SSimon Glass printf(" Invalid Instruction 0: 0x%02x\n", 228cd392fe8SSimon Glass fcba->flill & 0xff); 229cd392fe8SSimon Glass printf("FLPB 0x%08x\n", fcba->flpb); 230cd392fe8SSimon Glass printf(" Flash Partition Boundary Address: 0x%06x\n\n", 231cd392fe8SSimon Glass (fcba->flpb & 0xfff) << 12); 232cd392fe8SSimon Glass } 233cd392fe8SSimon Glass 234cd392fe8SSimon Glass static void dump_fpsba(struct fpsba_t *fpsba) 235cd392fe8SSimon Glass { 236cd392fe8SSimon Glass int i; 237cd392fe8SSimon Glass 238cd392fe8SSimon Glass printf("Found PCH Strap Section\n"); 239cd392fe8SSimon Glass for (i = 0; i < MAX_STRAPS; i++) 240cd392fe8SSimon Glass printf("PCHSTRP%-2d: 0x%08x\n", i, fpsba->pchstrp[i]); 241cd392fe8SSimon Glass } 242cd392fe8SSimon Glass 243cd392fe8SSimon Glass static const char *get_enabled(int flag) 244cd392fe8SSimon Glass { 245cd392fe8SSimon Glass return flag ? "enabled" : "disabled"; 246cd392fe8SSimon Glass } 247cd392fe8SSimon Glass 248cd392fe8SSimon Glass static void decode_flmstr(uint32_t flmstr) 249cd392fe8SSimon Glass { 250cd392fe8SSimon Glass printf(" Platform Data Region Write Access: %s\n", 251cd392fe8SSimon Glass get_enabled(flmstr & (1 << 28))); 252cd392fe8SSimon Glass printf(" GbE Region Write Access: %s\n", 253cd392fe8SSimon Glass get_enabled(flmstr & (1 << 27))); 254cd392fe8SSimon Glass printf(" Intel ME Region Write Access: %s\n", 255cd392fe8SSimon Glass get_enabled(flmstr & (1 << 26))); 256cd392fe8SSimon Glass printf(" Host CPU/BIOS Region Write Access: %s\n", 257cd392fe8SSimon Glass get_enabled(flmstr & (1 << 25))); 258cd392fe8SSimon Glass printf(" Flash Descriptor Write Access: %s\n", 259cd392fe8SSimon Glass get_enabled(flmstr & (1 << 24))); 260cd392fe8SSimon Glass 261cd392fe8SSimon Glass printf(" Platform Data Region Read Access: %s\n", 262cd392fe8SSimon Glass get_enabled(flmstr & (1 << 20))); 263cd392fe8SSimon Glass printf(" GbE Region Read Access: %s\n", 264cd392fe8SSimon Glass get_enabled(flmstr & (1 << 19))); 265cd392fe8SSimon Glass printf(" Intel ME Region Read Access: %s\n", 266cd392fe8SSimon Glass get_enabled(flmstr & (1 << 18))); 267cd392fe8SSimon Glass printf(" Host CPU/BIOS Region Read Access: %s\n", 268cd392fe8SSimon Glass get_enabled(flmstr & (1 << 17))); 269cd392fe8SSimon Glass printf(" Flash Descriptor Read Access: %s\n", 270cd392fe8SSimon Glass get_enabled(flmstr & (1 << 16))); 271cd392fe8SSimon Glass 272cd392fe8SSimon Glass printf(" Requester ID: 0x%04x\n\n", 273cd392fe8SSimon Glass flmstr & 0xffff); 274cd392fe8SSimon Glass } 275cd392fe8SSimon Glass 276cd392fe8SSimon Glass static void dump_fmba(struct fmba_t *fmba) 277cd392fe8SSimon Glass { 278cd392fe8SSimon Glass printf("Found Master Section\n"); 279cd392fe8SSimon Glass printf("FLMSTR1: 0x%08x (Host CPU/BIOS)\n", fmba->flmstr1); 280cd392fe8SSimon Glass decode_flmstr(fmba->flmstr1); 281cd392fe8SSimon Glass printf("FLMSTR2: 0x%08x (Intel ME)\n", fmba->flmstr2); 282cd392fe8SSimon Glass decode_flmstr(fmba->flmstr2); 283cd392fe8SSimon Glass printf("FLMSTR3: 0x%08x (GbE)\n", fmba->flmstr3); 284cd392fe8SSimon Glass decode_flmstr(fmba->flmstr3); 285cd392fe8SSimon Glass } 286cd392fe8SSimon Glass 287cd392fe8SSimon Glass static void dump_fmsba(struct fmsba_t *fmsba) 288cd392fe8SSimon Glass { 289cd392fe8SSimon Glass int i; 290cd392fe8SSimon Glass 291cd392fe8SSimon Glass printf("Found Processor Strap Section\n"); 292cd392fe8SSimon Glass for (i = 0; i < 4; i++) 293cd392fe8SSimon Glass printf("????: 0x%08x\n", fmsba->data[0]); 294cd392fe8SSimon Glass } 295cd392fe8SSimon Glass 296cd392fe8SSimon Glass static void dump_jid(uint32_t jid) 297cd392fe8SSimon Glass { 298cd392fe8SSimon Glass printf(" SPI Component Device ID 1: 0x%02x\n", 299cd392fe8SSimon Glass (jid >> 16) & 0xff); 300cd392fe8SSimon Glass printf(" SPI Component Device ID 0: 0x%02x\n", 301cd392fe8SSimon Glass (jid >> 8) & 0xff); 302cd392fe8SSimon Glass printf(" SPI Component Vendor ID: 0x%02x\n", 303cd392fe8SSimon Glass jid & 0xff); 304cd392fe8SSimon Glass } 305cd392fe8SSimon Glass 306cd392fe8SSimon Glass static void dump_vscc(uint32_t vscc) 307cd392fe8SSimon Glass { 308cd392fe8SSimon Glass printf(" Lower Erase Opcode: 0x%02x\n", 309cd392fe8SSimon Glass vscc >> 24); 310cd392fe8SSimon Glass printf(" Lower Write Enable on Write Status: 0x%02x\n", 311cd392fe8SSimon Glass vscc & (1 << 20) ? 0x06 : 0x50); 312cd392fe8SSimon Glass printf(" Lower Write Status Required: %s\n", 313cd392fe8SSimon Glass vscc & (1 << 19) ? "Yes" : "No"); 314cd392fe8SSimon Glass printf(" Lower Write Granularity: %d bytes\n", 315cd392fe8SSimon Glass vscc & (1 << 18) ? 64 : 1); 316cd392fe8SSimon Glass printf(" Lower Block / Sector Erase Size: "); 317cd392fe8SSimon Glass switch ((vscc >> 16) & 0x3) { 318cd392fe8SSimon Glass case 0: 319cd392fe8SSimon Glass printf("256 Byte\n"); 320cd392fe8SSimon Glass break; 321cd392fe8SSimon Glass case 1: 322cd392fe8SSimon Glass printf("4KB\n"); 323cd392fe8SSimon Glass break; 324cd392fe8SSimon Glass case 2: 325cd392fe8SSimon Glass printf("8KB\n"); 326cd392fe8SSimon Glass break; 327cd392fe8SSimon Glass case 3: 328cd392fe8SSimon Glass printf("64KB\n"); 329cd392fe8SSimon Glass break; 330cd392fe8SSimon Glass } 331cd392fe8SSimon Glass 332cd392fe8SSimon Glass printf(" Upper Erase Opcode: 0x%02x\n", 333cd392fe8SSimon Glass (vscc >> 8) & 0xff); 334cd392fe8SSimon Glass printf(" Upper Write Enable on Write Status: 0x%02x\n", 335cd392fe8SSimon Glass vscc & (1 << 4) ? 0x06 : 0x50); 336cd392fe8SSimon Glass printf(" Upper Write Status Required: %s\n", 337cd392fe8SSimon Glass vscc & (1 << 3) ? "Yes" : "No"); 338cd392fe8SSimon Glass printf(" Upper Write Granularity: %d bytes\n", 339cd392fe8SSimon Glass vscc & (1 << 2) ? 64 : 1); 340cd392fe8SSimon Glass printf(" Upper Block / Sector Erase Size: "); 341cd392fe8SSimon Glass switch (vscc & 0x3) { 342cd392fe8SSimon Glass case 0: 343cd392fe8SSimon Glass printf("256 Byte\n"); 344cd392fe8SSimon Glass break; 345cd392fe8SSimon Glass case 1: 346cd392fe8SSimon Glass printf("4KB\n"); 347cd392fe8SSimon Glass break; 348cd392fe8SSimon Glass case 2: 349cd392fe8SSimon Glass printf("8KB\n"); 350cd392fe8SSimon Glass break; 351cd392fe8SSimon Glass case 3: 352cd392fe8SSimon Glass printf("64KB\n"); 353cd392fe8SSimon Glass break; 354cd392fe8SSimon Glass } 355cd392fe8SSimon Glass } 356cd392fe8SSimon Glass 357cd392fe8SSimon Glass static void dump_vtba(struct vtba_t *vtba, int vtl) 358cd392fe8SSimon Glass { 359cd392fe8SSimon Glass int i; 360cd392fe8SSimon Glass int num = (vtl >> 1) < 8 ? (vtl >> 1) : 8; 361cd392fe8SSimon Glass 362cd392fe8SSimon Glass printf("ME VSCC table:\n"); 363cd392fe8SSimon Glass for (i = 0; i < num; i++) { 364cd392fe8SSimon Glass printf(" JID%d: 0x%08x\n", i, vtba->entry[i].jid); 365cd392fe8SSimon Glass dump_jid(vtba->entry[i].jid); 366cd392fe8SSimon Glass printf(" VSCC%d: 0x%08x\n", i, vtba->entry[i].vscc); 367cd392fe8SSimon Glass dump_vscc(vtba->entry[i].vscc); 368cd392fe8SSimon Glass } 369cd392fe8SSimon Glass printf("\n"); 370cd392fe8SSimon Glass } 371cd392fe8SSimon Glass 372cd392fe8SSimon Glass static void dump_oem(uint8_t *oem) 373cd392fe8SSimon Glass { 374cd392fe8SSimon Glass int i, j; 375cd392fe8SSimon Glass printf("OEM Section:\n"); 376cd392fe8SSimon Glass for (i = 0; i < 4; i++) { 377cd392fe8SSimon Glass printf("%02x:", i << 4); 378cd392fe8SSimon Glass for (j = 0; j < 16; j++) 379cd392fe8SSimon Glass printf(" %02x", oem[(i<<4)+j]); 380cd392fe8SSimon Glass printf("\n"); 381cd392fe8SSimon Glass } 382cd392fe8SSimon Glass printf("\n"); 383cd392fe8SSimon Glass } 384cd392fe8SSimon Glass 385cd392fe8SSimon Glass /** 386cd392fe8SSimon Glass * dump_fd() - Display a dump of the full flash description 387cd392fe8SSimon Glass * 388cd392fe8SSimon Glass * @image: Pointer to image 389cd392fe8SSimon Glass * @size: Size of image in bytes 390cd392fe8SSimon Glass * @return 0 if OK, -1 on error 391cd392fe8SSimon Glass */ 392cd392fe8SSimon Glass static int dump_fd(char *image, int size) 393cd392fe8SSimon Glass { 394cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 395cd392fe8SSimon Glass 396cd392fe8SSimon Glass if (!fdb) 397cd392fe8SSimon Glass return -1; 398cd392fe8SSimon Glass 399cd392fe8SSimon Glass printf("FLMAP0: 0x%08x\n", fdb->flmap0); 400cd392fe8SSimon Glass printf(" NR: %d\n", (fdb->flmap0 >> 24) & 7); 401cd392fe8SSimon Glass printf(" FRBA: 0x%x\n", ((fdb->flmap0 >> 16) & 0xff) << 4); 402cd392fe8SSimon Glass printf(" NC: %d\n", ((fdb->flmap0 >> 8) & 3) + 1); 403cd392fe8SSimon Glass printf(" FCBA: 0x%x\n", ((fdb->flmap0) & 0xff) << 4); 404cd392fe8SSimon Glass 405cd392fe8SSimon Glass printf("FLMAP1: 0x%08x\n", fdb->flmap1); 406cd392fe8SSimon Glass printf(" ISL: 0x%02x\n", (fdb->flmap1 >> 24) & 0xff); 407cd392fe8SSimon Glass printf(" FPSBA: 0x%x\n", ((fdb->flmap1 >> 16) & 0xff) << 4); 408cd392fe8SSimon Glass printf(" NM: %d\n", (fdb->flmap1 >> 8) & 3); 409cd392fe8SSimon Glass printf(" FMBA: 0x%x\n", ((fdb->flmap1) & 0xff) << 4); 410cd392fe8SSimon Glass 411cd392fe8SSimon Glass printf("FLMAP2: 0x%08x\n", fdb->flmap2); 412cd392fe8SSimon Glass printf(" PSL: 0x%04x\n", (fdb->flmap2 >> 8) & 0xffff); 413cd392fe8SSimon Glass printf(" FMSBA: 0x%x\n", ((fdb->flmap2) & 0xff) << 4); 414cd392fe8SSimon Glass 415cd392fe8SSimon Glass printf("FLUMAP1: 0x%08x\n", fdb->flumap1); 416cd392fe8SSimon Glass printf(" Intel ME VSCC Table Length (VTL): %d\n", 417cd392fe8SSimon Glass (fdb->flumap1 >> 8) & 0xff); 418cd392fe8SSimon Glass printf(" Intel ME VSCC Table Base Address (VTBA): 0x%06x\n\n", 419cd392fe8SSimon Glass (fdb->flumap1 & 0xff) << 4); 420cd392fe8SSimon Glass dump_vtba((struct vtba_t *) 421cd392fe8SSimon Glass (image + ((fdb->flumap1 & 0xff) << 4)), 422cd392fe8SSimon Glass (fdb->flumap1 >> 8) & 0xff); 423cd392fe8SSimon Glass dump_oem((uint8_t *)image + 0xf00); 424cd392fe8SSimon Glass dump_frba((struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) 425cd392fe8SSimon Glass << 4))); 426cd392fe8SSimon Glass dump_fcba((struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4))); 427cd392fe8SSimon Glass dump_fpsba((struct fpsba_t *) 428cd392fe8SSimon Glass (image + (((fdb->flmap1 >> 16) & 0xff) << 4))); 429cd392fe8SSimon Glass dump_fmba((struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4))); 430cd392fe8SSimon Glass dump_fmsba((struct fmsba_t *)(image + (((fdb->flmap2) & 0xff) << 4))); 431cd392fe8SSimon Glass 432cd392fe8SSimon Glass return 0; 433cd392fe8SSimon Glass } 434cd392fe8SSimon Glass 435cd392fe8SSimon Glass /** 436cd392fe8SSimon Glass * write_regions() - Write each region from an image to its own file 437cd392fe8SSimon Glass * 438cd392fe8SSimon Glass * The filename to use in each case is fixed - see region_filename() 439cd392fe8SSimon Glass * 440cd392fe8SSimon Glass * @image: Pointer to image 441cd392fe8SSimon Glass * @size: Size of image in bytes 442cd392fe8SSimon Glass * @return 0 if OK, -ve on error 443cd392fe8SSimon Glass */ 444cd392fe8SSimon Glass static int write_regions(char *image, int size) 445cd392fe8SSimon Glass { 446cd392fe8SSimon Glass struct fdbar_t *fdb; 447cd392fe8SSimon Glass struct frba_t *frba; 448cd392fe8SSimon Glass int ret = 0; 449cd392fe8SSimon Glass int i; 450cd392fe8SSimon Glass 451cd392fe8SSimon Glass fdb = find_fd(image, size); 452cd392fe8SSimon Glass if (!fdb) 453cd392fe8SSimon Glass return -1; 454cd392fe8SSimon Glass 455cd392fe8SSimon Glass frba = (struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) << 4)); 456cd392fe8SSimon Glass 457cd392fe8SSimon Glass for (i = 0; i < MAX_REGIONS; i++) { 458cd392fe8SSimon Glass struct region_t region; 459cd392fe8SSimon Glass int region_fd; 460cd392fe8SSimon Glass 461cd392fe8SSimon Glass ret = get_region(frba, i, ®ion); 462cd392fe8SSimon Glass if (ret) 463cd392fe8SSimon Glass return ret; 464cd392fe8SSimon Glass dump_region(i, frba); 4656c4247e9SBin Meng if (region.size <= 0) 466cd392fe8SSimon Glass continue; 467cd392fe8SSimon Glass region_fd = open(region_filename(i), 468cd392fe8SSimon Glass O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | 469cd392fe8SSimon Glass S_IWUSR | S_IRGRP | S_IROTH); 470cd392fe8SSimon Glass if (write(region_fd, image + region.base, region.size) != 471cd392fe8SSimon Glass region.size) { 472cd392fe8SSimon Glass perror("Error while writing"); 473cd392fe8SSimon Glass ret = -1; 474cd392fe8SSimon Glass } 475cd392fe8SSimon Glass close(region_fd); 476cd392fe8SSimon Glass } 477cd392fe8SSimon Glass 478cd392fe8SSimon Glass return ret; 479cd392fe8SSimon Glass } 480cd392fe8SSimon Glass 481fa8d3b00SSimon Glass static int perror_fname(const char *fmt, const char *fname) 482fa8d3b00SSimon Glass { 483fa8d3b00SSimon Glass char msg[strlen(fmt) + strlen(fname) + 1]; 484fa8d3b00SSimon Glass 485fa8d3b00SSimon Glass sprintf(msg, fmt, fname); 486fa8d3b00SSimon Glass perror(msg); 487fa8d3b00SSimon Glass 488fa8d3b00SSimon Glass return -1; 489fa8d3b00SSimon Glass } 490fa8d3b00SSimon Glass 491cd392fe8SSimon Glass /** 492cd392fe8SSimon Glass * write_image() - Write the image to a file 493cd392fe8SSimon Glass * 494cd392fe8SSimon Glass * @filename: Filename to use for the image 495cd392fe8SSimon Glass * @image: Pointer to image 496cd392fe8SSimon Glass * @size: Size of image in bytes 497cd392fe8SSimon Glass * @return 0 if OK, -ve on error 498cd392fe8SSimon Glass */ 499cd392fe8SSimon Glass static int write_image(char *filename, char *image, int size) 500cd392fe8SSimon Glass { 501cd392fe8SSimon Glass int new_fd; 502cd392fe8SSimon Glass 503cd392fe8SSimon Glass debug("Writing new image to %s\n", filename); 504cd392fe8SSimon Glass 505cd392fe8SSimon Glass new_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | 506cd392fe8SSimon Glass S_IWUSR | S_IRGRP | S_IROTH); 507fa8d3b00SSimon Glass if (new_fd < 0) 508fa8d3b00SSimon Glass return perror_fname("Could not open file '%s'", filename); 509fa8d3b00SSimon Glass if (write(new_fd, image, size) != size) 510fa8d3b00SSimon Glass return perror_fname("Could not write file '%s'", filename); 511cd392fe8SSimon Glass close(new_fd); 512cd392fe8SSimon Glass 513cd392fe8SSimon Glass return 0; 514cd392fe8SSimon Glass } 515cd392fe8SSimon Glass 516cd392fe8SSimon Glass /** 517cd392fe8SSimon Glass * set_spi_frequency() - Set the SPI frequency to use when booting 518cd392fe8SSimon Glass * 519cd392fe8SSimon Glass * Several frequencies are supported, some of which work with fast devices. 520cd392fe8SSimon Glass * For SPI emulators, the slowest (SPI_FREQUENCY_20MHZ) is often used. The 521cd392fe8SSimon Glass * Intel boot system uses this information somehow on boot. 522cd392fe8SSimon Glass * 523cd392fe8SSimon Glass * The image is updated with the supplied value 524cd392fe8SSimon Glass * 525cd392fe8SSimon Glass * @image: Pointer to image 526cd392fe8SSimon Glass * @size: Size of image in bytes 527cd392fe8SSimon Glass * @freq: SPI frequency to use 528cd392fe8SSimon Glass */ 529cd392fe8SSimon Glass static void set_spi_frequency(char *image, int size, enum spi_frequency freq) 530cd392fe8SSimon Glass { 531cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 532cd392fe8SSimon Glass struct fcba_t *fcba; 533cd392fe8SSimon Glass 534cd392fe8SSimon Glass fcba = (struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4)); 535cd392fe8SSimon Glass 536cd392fe8SSimon Glass /* clear bits 21-29 */ 537cd392fe8SSimon Glass fcba->flcomp &= ~0x3fe00000; 538cd392fe8SSimon Glass /* Read ID and Read Status Clock Frequency */ 539cd392fe8SSimon Glass fcba->flcomp |= freq << 27; 540cd392fe8SSimon Glass /* Write and Erase Clock Frequency */ 541cd392fe8SSimon Glass fcba->flcomp |= freq << 24; 542cd392fe8SSimon Glass /* Fast Read Clock Frequency */ 543cd392fe8SSimon Glass fcba->flcomp |= freq << 21; 544cd392fe8SSimon Glass } 545cd392fe8SSimon Glass 546cd392fe8SSimon Glass /** 547cd392fe8SSimon Glass * set_em100_mode() - Set a SPI frequency that will work with Dediprog EM100 548cd392fe8SSimon Glass * 549cd392fe8SSimon Glass * @image: Pointer to image 550cd392fe8SSimon Glass * @size: Size of image in bytes 551cd392fe8SSimon Glass */ 552cd392fe8SSimon Glass static void set_em100_mode(char *image, int size) 553cd392fe8SSimon Glass { 554cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 555cd392fe8SSimon Glass struct fcba_t *fcba; 556cd392fe8SSimon Glass 557cd392fe8SSimon Glass fcba = (struct fcba_t *)(image + (((fdb->flmap0) & 0xff) << 4)); 558cd392fe8SSimon Glass fcba->flcomp &= ~(1 << 30); 559cd392fe8SSimon Glass set_spi_frequency(image, size, SPI_FREQUENCY_20MHZ); 560cd392fe8SSimon Glass } 561cd392fe8SSimon Glass 562cd392fe8SSimon Glass /** 563cd392fe8SSimon Glass * lock_descriptor() - Lock the NE descriptor so it cannot be updated 564cd392fe8SSimon Glass * 565cd392fe8SSimon Glass * @image: Pointer to image 566cd392fe8SSimon Glass * @size: Size of image in bytes 567cd392fe8SSimon Glass */ 568cd392fe8SSimon Glass static void lock_descriptor(char *image, int size) 569cd392fe8SSimon Glass { 570cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 571cd392fe8SSimon Glass struct fmba_t *fmba; 572cd392fe8SSimon Glass 573cd392fe8SSimon Glass /* 574cd392fe8SSimon Glass * TODO: Dynamically take Platform Data Region and GbE Region into 575cd392fe8SSimon Glass * account. 576cd392fe8SSimon Glass */ 577cd392fe8SSimon Glass fmba = (struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4)); 578cd392fe8SSimon Glass fmba->flmstr1 = 0x0a0b0000; 579cd392fe8SSimon Glass fmba->flmstr2 = 0x0c0d0000; 580cd392fe8SSimon Glass fmba->flmstr3 = 0x08080118; 581cd392fe8SSimon Glass } 582cd392fe8SSimon Glass 583cd392fe8SSimon Glass /** 584cd392fe8SSimon Glass * unlock_descriptor() - Lock the NE descriptor so it can be updated 585cd392fe8SSimon Glass * 586cd392fe8SSimon Glass * @image: Pointer to image 587cd392fe8SSimon Glass * @size: Size of image in bytes 588cd392fe8SSimon Glass */ 589cd392fe8SSimon Glass static void unlock_descriptor(char *image, int size) 590cd392fe8SSimon Glass { 591cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 592cd392fe8SSimon Glass struct fmba_t *fmba; 593cd392fe8SSimon Glass 594cd392fe8SSimon Glass fmba = (struct fmba_t *)(image + (((fdb->flmap1) & 0xff) << 4)); 595cd392fe8SSimon Glass fmba->flmstr1 = 0xffff0000; 596cd392fe8SSimon Glass fmba->flmstr2 = 0xffff0000; 597cd392fe8SSimon Glass fmba->flmstr3 = 0x08080118; 598cd392fe8SSimon Glass } 599cd392fe8SSimon Glass 600cd392fe8SSimon Glass /** 601cd392fe8SSimon Glass * open_for_read() - Open a file for reading 602cd392fe8SSimon Glass * 603cd392fe8SSimon Glass * @fname: Filename to open 604cd392fe8SSimon Glass * @sizep: Returns file size in bytes 605cd392fe8SSimon Glass * @return 0 if OK, -1 on error 606cd392fe8SSimon Glass */ 607cd392fe8SSimon Glass int open_for_read(const char *fname, int *sizep) 608cd392fe8SSimon Glass { 609cd392fe8SSimon Glass int fd = open(fname, O_RDONLY); 610cd392fe8SSimon Glass struct stat buf; 611cd392fe8SSimon Glass 612fa8d3b00SSimon Glass if (fd == -1) 613fa8d3b00SSimon Glass return perror_fname("Could not open file '%s'", fname); 614fa8d3b00SSimon Glass if (fstat(fd, &buf) == -1) 615fa8d3b00SSimon Glass return perror_fname("Could not stat file '%s'", fname); 616cd392fe8SSimon Glass *sizep = buf.st_size; 617cd392fe8SSimon Glass debug("File %s is %d bytes\n", fname, *sizep); 618cd392fe8SSimon Glass 619cd392fe8SSimon Glass return fd; 620cd392fe8SSimon Glass } 621cd392fe8SSimon Glass 622cd392fe8SSimon Glass /** 623cd392fe8SSimon Glass * inject_region() - Add a file to an image region 624cd392fe8SSimon Glass * 625cd392fe8SSimon Glass * This puts a file into a particular region of the flash. Several pre-defined 626cd392fe8SSimon Glass * regions are used. 627cd392fe8SSimon Glass * 628cd392fe8SSimon Glass * @image: Pointer to image 629cd392fe8SSimon Glass * @size: Size of image in bytes 630cd392fe8SSimon Glass * @region_type: Region where the file should be added 631cd392fe8SSimon Glass * @region_fname: Filename to add to the image 632cd392fe8SSimon Glass * @return 0 if OK, -ve on error 633cd392fe8SSimon Glass */ 634cd392fe8SSimon Glass int inject_region(char *image, int size, int region_type, char *region_fname) 635cd392fe8SSimon Glass { 636cd392fe8SSimon Glass struct fdbar_t *fdb = find_fd(image, size); 637cd392fe8SSimon Glass struct region_t region; 638cd392fe8SSimon Glass struct frba_t *frba; 639cd392fe8SSimon Glass int region_size; 640cd392fe8SSimon Glass int offset = 0; 641cd392fe8SSimon Glass int region_fd; 642cd392fe8SSimon Glass int ret; 643cd392fe8SSimon Glass 644cd392fe8SSimon Glass if (!fdb) 645cd392fe8SSimon Glass exit(EXIT_FAILURE); 646cd392fe8SSimon Glass frba = (struct frba_t *)(image + (((fdb->flmap0 >> 16) & 0xff) << 4)); 647cd392fe8SSimon Glass 648cd392fe8SSimon Glass ret = get_region(frba, region_type, ®ion); 649cd392fe8SSimon Glass if (ret) 650cd392fe8SSimon Glass return -1; 651cd392fe8SSimon Glass if (region.size <= 0xfff) { 652cd392fe8SSimon Glass fprintf(stderr, "Region %s is disabled in target. Not injecting.\n", 653cd392fe8SSimon Glass region_name(region_type)); 654cd392fe8SSimon Glass return -1; 655cd392fe8SSimon Glass } 656cd392fe8SSimon Glass 657cd392fe8SSimon Glass region_fd = open_for_read(region_fname, ®ion_size); 658cd392fe8SSimon Glass if (region_fd < 0) 659cd392fe8SSimon Glass return region_fd; 660cd392fe8SSimon Glass 661cd392fe8SSimon Glass if ((region_size > region.size) || 662cd392fe8SSimon Glass ((region_type != 1) && (region_size > region.size))) { 663cd392fe8SSimon Glass fprintf(stderr, "Region %s is %d(0x%x) bytes. File is %d(0x%x) bytes. Not injecting.\n", 664cd392fe8SSimon Glass region_name(region_type), region.size, 665cd392fe8SSimon Glass region.size, region_size, region_size); 666cd392fe8SSimon Glass return -1; 667cd392fe8SSimon Glass } 668cd392fe8SSimon Glass 669cd392fe8SSimon Glass if ((region_type == 1) && (region_size < region.size)) { 670cd392fe8SSimon Glass fprintf(stderr, "Region %s is %d(0x%x) bytes. File is %d(0x%x) bytes. Padding before injecting.\n", 671cd392fe8SSimon Glass region_name(region_type), region.size, 672cd392fe8SSimon Glass region.size, region_size, region_size); 673cd392fe8SSimon Glass offset = region.size - region_size; 674cd392fe8SSimon Glass memset(image + region.base, 0xff, offset); 675cd392fe8SSimon Glass } 676cd392fe8SSimon Glass 677cd392fe8SSimon Glass if (size < region.base + offset + region_size) { 678cd392fe8SSimon Glass fprintf(stderr, "Output file is too small. (%d < %d)\n", 679cd392fe8SSimon Glass size, region.base + offset + region_size); 680cd392fe8SSimon Glass return -1; 681cd392fe8SSimon Glass } 682cd392fe8SSimon Glass 683cd392fe8SSimon Glass if (read(region_fd, image + region.base + offset, region_size) 684cd392fe8SSimon Glass != region_size) { 685cd392fe8SSimon Glass perror("Could not read file"); 686cd392fe8SSimon Glass return -1; 687cd392fe8SSimon Glass } 688cd392fe8SSimon Glass 689cd392fe8SSimon Glass close(region_fd); 690cd392fe8SSimon Glass 691cd392fe8SSimon Glass debug("Adding %s as the %s section\n", region_fname, 692cd392fe8SSimon Glass region_name(region_type)); 693cd392fe8SSimon Glass 694cd392fe8SSimon Glass return 0; 695cd392fe8SSimon Glass } 696cd392fe8SSimon Glass 697cd392fe8SSimon Glass /** 698cd392fe8SSimon Glass * write_data() - Write some raw data into a region 699cd392fe8SSimon Glass * 700cd392fe8SSimon Glass * This puts a file into a particular place in the flash, ignoring the 701cd392fe8SSimon Glass * regions. Be careful not to overwrite something important. 702cd392fe8SSimon Glass * 703cd392fe8SSimon Glass * @image: Pointer to image 704cd392fe8SSimon Glass * @size: Size of image in bytes 705cd392fe8SSimon Glass * @addr: x86 ROM address to put file. The ROM ends at 706cd392fe8SSimon Glass * 0xffffffff so use an address relative to that. For an 707cd392fe8SSimon Glass * 8MB ROM the start address is 0xfff80000. 708cd392fe8SSimon Glass * @write_fname: Filename to add to the image 709*3c7aab23SSimon Glass * @offset_uboot_top: Offset of the top of U-Boot 71031eca697SSimon Glass * @return number of bytes written if OK, -ve on error 711cd392fe8SSimon Glass */ 712cd392fe8SSimon Glass static int write_data(char *image, int size, unsigned int addr, 713*3c7aab23SSimon Glass const char *write_fname, int offset_uboot_top) 714cd392fe8SSimon Glass { 715cd392fe8SSimon Glass int write_fd, write_size; 716cd392fe8SSimon Glass int offset; 717cd392fe8SSimon Glass 718cd392fe8SSimon Glass write_fd = open_for_read(write_fname, &write_size); 719cd392fe8SSimon Glass if (write_fd < 0) 720cd392fe8SSimon Glass return write_fd; 721cd392fe8SSimon Glass 72231eca697SSimon Glass offset = (uint32_t)(addr + size); 723*3c7aab23SSimon Glass if (offset_uboot_top && offset_uboot_top >= offset) { 724*3c7aab23SSimon Glass fprintf(stderr, "U-Boot image overlaps with region '%s'\n", 725*3c7aab23SSimon Glass write_fname); 726*3c7aab23SSimon Glass fprintf(stderr, 727*3c7aab23SSimon Glass "U-Boot finishes at offset %x, file starts at %x\n", 728*3c7aab23SSimon Glass offset_uboot_top, offset); 729*3c7aab23SSimon Glass return -EXDEV; 730*3c7aab23SSimon Glass } 731cd392fe8SSimon Glass debug("Writing %s to offset %#x\n", write_fname, offset); 732cd392fe8SSimon Glass 733cd392fe8SSimon Glass if (offset < 0 || offset + write_size > size) { 734cd392fe8SSimon Glass fprintf(stderr, "Output file is too small. (%d < %d)\n", 735cd392fe8SSimon Glass size, offset + write_size); 736cd392fe8SSimon Glass return -1; 737cd392fe8SSimon Glass } 738cd392fe8SSimon Glass 739cd392fe8SSimon Glass if (read(write_fd, image + offset, write_size) != write_size) { 740cd392fe8SSimon Glass perror("Could not read file"); 741cd392fe8SSimon Glass return -1; 742cd392fe8SSimon Glass } 743cd392fe8SSimon Glass 744cd392fe8SSimon Glass close(write_fd); 745cd392fe8SSimon Glass 74631eca697SSimon Glass return write_size; 74731eca697SSimon Glass } 74831eca697SSimon Glass 74931eca697SSimon Glass /** 75031eca697SSimon Glass * write_uboot() - Write U-Boot, device tree and microcode pointer 75131eca697SSimon Glass * 75231eca697SSimon Glass * This writes U-Boot into a place in the flash, followed by its device tree. 75331eca697SSimon Glass * The microcode pointer is written so that U-Boot can find the microcode in 75431eca697SSimon Glass * the device tree very early in boot. 75531eca697SSimon Glass * 75631eca697SSimon Glass * @image: Pointer to image 75731eca697SSimon Glass * @size: Size of image in bytes 75831eca697SSimon Glass * @uboot: Input file information for u-boot.bin 75931eca697SSimon Glass * @fdt: Input file information for u-boot.dtb 76031eca697SSimon Glass * @ucode_ptr: Address in U-Boot where the microcode pointer should be placed 76131eca697SSimon Glass * @return 0 if OK, -ve on error 76231eca697SSimon Glass */ 76331eca697SSimon Glass static int write_uboot(char *image, int size, struct input_file *uboot, 76431eca697SSimon Glass struct input_file *fdt, unsigned int ucode_ptr) 76531eca697SSimon Glass { 76631eca697SSimon Glass const void *blob; 76731eca697SSimon Glass const char *data; 768*3c7aab23SSimon Glass int uboot_size, fdt_size; 76931eca697SSimon Glass uint32_t *ptr; 77031eca697SSimon Glass int data_size; 77131eca697SSimon Glass int offset; 77231eca697SSimon Glass int node; 77331eca697SSimon Glass 774*3c7aab23SSimon Glass uboot_size = write_data(image, size, uboot->addr, uboot->fname, 0); 77531eca697SSimon Glass if (uboot_size < 0) 77631eca697SSimon Glass return uboot_size; 77731eca697SSimon Glass fdt->addr = uboot->addr + uboot_size; 77831eca697SSimon Glass debug("U-Boot size %#x, FDT at %#x\n", uboot_size, fdt->addr); 779*3c7aab23SSimon Glass fdt_size = write_data(image, size, fdt->addr, fdt->fname, 0); 780*3c7aab23SSimon Glass if (fdt_size < 0) 781*3c7aab23SSimon Glass return fdt_size; 782*3c7aab23SSimon Glass blob = (void *)image + (uint32_t)(fdt->addr + size); 78331eca697SSimon Glass 78431eca697SSimon Glass if (ucode_ptr) { 78531eca697SSimon Glass debug("DTB at %lx\n", (char *)blob - image); 78631eca697SSimon Glass node = fdt_node_offset_by_compatible(blob, 0, 78731eca697SSimon Glass "intel,microcode"); 78831eca697SSimon Glass if (node < 0) { 78931eca697SSimon Glass debug("No microcode found in FDT: %s\n", 79031eca697SSimon Glass fdt_strerror(node)); 79131eca697SSimon Glass return -ENOENT; 79231eca697SSimon Glass } 79331eca697SSimon Glass data = fdt_getprop(blob, node, "data", &data_size); 79431eca697SSimon Glass if (!data) { 79531eca697SSimon Glass debug("No microcode data found in FDT: %s\n", 79631eca697SSimon Glass fdt_strerror(data_size)); 79731eca697SSimon Glass return -ENOENT; 79831eca697SSimon Glass } 7998a388085SSimon Glass offset = (uint32_t)(ucode_ptr + size); 80031eca697SSimon Glass ptr = (void *)image + offset; 8018a388085SSimon Glass ptr[0] = (data - image) - size; 80231eca697SSimon Glass ptr[1] = data_size; 80331eca697SSimon Glass debug("Wrote microcode pointer at %x: addr=%x, size=%x\n", 80431eca697SSimon Glass ucode_ptr, ptr[0], ptr[1]); 80531eca697SSimon Glass } 80631eca697SSimon Glass 807*3c7aab23SSimon Glass return ((char *)blob + fdt_size) - image; 808cd392fe8SSimon Glass } 809cd392fe8SSimon Glass 810cd392fe8SSimon Glass static void print_version(void) 811cd392fe8SSimon Glass { 812cd392fe8SSimon Glass printf("ifdtool v%s -- ", IFDTOOL_VERSION); 813cd392fe8SSimon Glass printf("Copyright (C) 2014 Google Inc.\n\n"); 814cd392fe8SSimon Glass printf("SPDX-License-Identifier: GPL-2.0+\n"); 815cd392fe8SSimon Glass } 816cd392fe8SSimon Glass 817cd392fe8SSimon Glass static void print_usage(const char *name) 818cd392fe8SSimon Glass { 819cd392fe8SSimon Glass printf("usage: %s [-vhdix?] <filename> [<outfile>]\n", name); 820cd392fe8SSimon Glass printf("\n" 821cd392fe8SSimon Glass " -d | --dump: dump intel firmware descriptor\n" 822cd392fe8SSimon Glass " -x | --extract: extract intel fd modules\n" 823cd392fe8SSimon Glass " -i | --inject <region>:<module> inject file <module> into region <region>\n" 824cd392fe8SSimon Glass " -w | --write <addr>:<file> write file to appear at memory address <addr>\n" 825673ed2f8SBin Meng " multiple files can be written simultaneously\n" 826cd392fe8SSimon Glass " -s | --spifreq <20|33|50> set the SPI frequency\n" 827cd392fe8SSimon Glass " -e | --em100 set SPI frequency to 20MHz and disable\n" 828cd392fe8SSimon Glass " Dual Output Fast Read Support\n" 829cd392fe8SSimon Glass " -l | --lock Lock firmware descriptor and ME region\n" 830cd392fe8SSimon Glass " -u | --unlock Unlock firmware descriptor and ME region\n" 831cd392fe8SSimon Glass " -r | --romsize Specify ROM size\n" 832cd392fe8SSimon Glass " -D | --write-descriptor <file> Write descriptor at base\n" 833cd392fe8SSimon Glass " -c | --create Create a new empty image\n" 834cd392fe8SSimon Glass " -v | --version: print the version\n" 835cd392fe8SSimon Glass " -h | --help: print this help\n\n" 836cd392fe8SSimon Glass "<region> is one of Descriptor, BIOS, ME, GbE, Platform\n" 837cd392fe8SSimon Glass "\n"); 838cd392fe8SSimon Glass } 839cd392fe8SSimon Glass 840cd392fe8SSimon Glass /** 841cd392fe8SSimon Glass * get_two_words() - Convert a string into two words separated by : 842cd392fe8SSimon Glass * 843cd392fe8SSimon Glass * The supplied string is split at ':', two substrings are allocated and 844cd392fe8SSimon Glass * returned. 845cd392fe8SSimon Glass * 846cd392fe8SSimon Glass * @str: String to split 847cd392fe8SSimon Glass * @firstp: Returns first string 848cd392fe8SSimon Glass * @secondp: Returns second string 849cd392fe8SSimon Glass * @return 0 if OK, -ve if @str does not have a : 850cd392fe8SSimon Glass */ 851cd392fe8SSimon Glass static int get_two_words(const char *str, char **firstp, char **secondp) 852cd392fe8SSimon Glass { 853cd392fe8SSimon Glass const char *p; 854cd392fe8SSimon Glass 855cd392fe8SSimon Glass p = strchr(str, ':'); 856cd392fe8SSimon Glass if (!p) 857cd392fe8SSimon Glass return -1; 858cd392fe8SSimon Glass *firstp = strdup(str); 859cd392fe8SSimon Glass (*firstp)[p - str] = '\0'; 860cd392fe8SSimon Glass *secondp = strdup(p + 1); 861cd392fe8SSimon Glass 862cd392fe8SSimon Glass return 0; 863cd392fe8SSimon Glass } 864cd392fe8SSimon Glass 865cd392fe8SSimon Glass int main(int argc, char *argv[]) 866cd392fe8SSimon Glass { 867cd392fe8SSimon Glass int opt, option_index = 0; 868cd392fe8SSimon Glass int mode_dump = 0, mode_extract = 0, mode_inject = 0; 869cd392fe8SSimon Glass int mode_spifreq = 0, mode_em100 = 0, mode_locked = 0; 870cd392fe8SSimon Glass int mode_unlocked = 0, mode_write = 0, mode_write_descriptor = 0; 871cd392fe8SSimon Glass int create = 0; 8727dfb172dSSimon Glass char *region_type_string = NULL, *inject_fname = NULL; 8737dfb172dSSimon Glass char *desc_fname = NULL, *addr_str = NULL; 874cd392fe8SSimon Glass int region_type = -1, inputfreq = 0; 875cd392fe8SSimon Glass enum spi_frequency spifreq = SPI_FREQUENCY_20MHZ; 87631eca697SSimon Glass struct input_file input_file[WRITE_MAX], *ifile, *fdt = NULL; 877673ed2f8SBin Meng unsigned char wr_idx, wr_num = 0; 878cd392fe8SSimon Glass int rom_size = -1; 879cd392fe8SSimon Glass bool write_it; 880cd392fe8SSimon Glass char *filename; 881cd392fe8SSimon Glass char *outfile = NULL; 882cd392fe8SSimon Glass struct stat buf; 883cd392fe8SSimon Glass int size = 0; 88431eca697SSimon Glass unsigned int ucode_ptr = 0; 88531eca697SSimon Glass bool have_uboot = false; 886cd392fe8SSimon Glass int bios_fd; 887cd392fe8SSimon Glass char *image; 888cd392fe8SSimon Glass int ret; 889cd392fe8SSimon Glass static struct option long_options[] = { 890cd392fe8SSimon Glass {"create", 0, NULL, 'c'}, 891cd392fe8SSimon Glass {"dump", 0, NULL, 'd'}, 892cd392fe8SSimon Glass {"descriptor", 1, NULL, 'D'}, 893cd392fe8SSimon Glass {"em100", 0, NULL, 'e'}, 894cd392fe8SSimon Glass {"extract", 0, NULL, 'x'}, 89531eca697SSimon Glass {"fdt", 1, NULL, 'f'}, 896cd392fe8SSimon Glass {"inject", 1, NULL, 'i'}, 897cd392fe8SSimon Glass {"lock", 0, NULL, 'l'}, 89831eca697SSimon Glass {"microcode", 1, NULL, 'm'}, 899cd392fe8SSimon Glass {"romsize", 1, NULL, 'r'}, 900cd392fe8SSimon Glass {"spifreq", 1, NULL, 's'}, 901cd392fe8SSimon Glass {"unlock", 0, NULL, 'u'}, 90231eca697SSimon Glass {"uboot", 1, NULL, 'U'}, 903cd392fe8SSimon Glass {"write", 1, NULL, 'w'}, 904cd392fe8SSimon Glass {"version", 0, NULL, 'v'}, 905cd392fe8SSimon Glass {"help", 0, NULL, 'h'}, 906cd392fe8SSimon Glass {0, 0, 0, 0} 907cd392fe8SSimon Glass }; 908cd392fe8SSimon Glass 90931eca697SSimon Glass while ((opt = getopt_long(argc, argv, "cdD:ef:hi:lm:r:s:uU:vw:x?", 910cd392fe8SSimon Glass long_options, &option_index)) != EOF) { 911cd392fe8SSimon Glass switch (opt) { 912cd392fe8SSimon Glass case 'c': 913cd392fe8SSimon Glass create = 1; 914cd392fe8SSimon Glass break; 915cd392fe8SSimon Glass case 'd': 916cd392fe8SSimon Glass mode_dump = 1; 917cd392fe8SSimon Glass break; 918cd392fe8SSimon Glass case 'D': 919cd392fe8SSimon Glass mode_write_descriptor = 1; 9207dfb172dSSimon Glass desc_fname = optarg; 921cd392fe8SSimon Glass break; 922cd392fe8SSimon Glass case 'e': 923cd392fe8SSimon Glass mode_em100 = 1; 924cd392fe8SSimon Glass break; 925cd392fe8SSimon Glass case 'i': 926cd392fe8SSimon Glass if (get_two_words(optarg, ®ion_type_string, 9277dfb172dSSimon Glass &inject_fname)) { 928cd392fe8SSimon Glass print_usage(argv[0]); 929cd392fe8SSimon Glass exit(EXIT_FAILURE); 930cd392fe8SSimon Glass } 931cd392fe8SSimon Glass if (!strcasecmp("Descriptor", region_type_string)) 932cd392fe8SSimon Glass region_type = 0; 933cd392fe8SSimon Glass else if (!strcasecmp("BIOS", region_type_string)) 934cd392fe8SSimon Glass region_type = 1; 935cd392fe8SSimon Glass else if (!strcasecmp("ME", region_type_string)) 936cd392fe8SSimon Glass region_type = 2; 937cd392fe8SSimon Glass else if (!strcasecmp("GbE", region_type_string)) 938cd392fe8SSimon Glass region_type = 3; 939cd392fe8SSimon Glass else if (!strcasecmp("Platform", region_type_string)) 940cd392fe8SSimon Glass region_type = 4; 941cd392fe8SSimon Glass if (region_type == -1) { 942cd392fe8SSimon Glass fprintf(stderr, "No such region type: '%s'\n\n", 943cd392fe8SSimon Glass region_type_string); 944cd392fe8SSimon Glass print_usage(argv[0]); 945cd392fe8SSimon Glass exit(EXIT_FAILURE); 946cd392fe8SSimon Glass } 947cd392fe8SSimon Glass mode_inject = 1; 948cd392fe8SSimon Glass break; 949cd392fe8SSimon Glass case 'l': 950cd392fe8SSimon Glass mode_locked = 1; 951cd392fe8SSimon Glass break; 95231eca697SSimon Glass case 'm': 95331eca697SSimon Glass ucode_ptr = strtoul(optarg, NULL, 0); 95431eca697SSimon Glass break; 955cd392fe8SSimon Glass case 'r': 956cd392fe8SSimon Glass rom_size = strtol(optarg, NULL, 0); 957cd392fe8SSimon Glass debug("ROM size %d\n", rom_size); 958cd392fe8SSimon Glass break; 959cd392fe8SSimon Glass case 's': 960cd392fe8SSimon Glass /* Parse the requested SPI frequency */ 961cd392fe8SSimon Glass inputfreq = strtol(optarg, NULL, 0); 962cd392fe8SSimon Glass switch (inputfreq) { 963cd392fe8SSimon Glass case 20: 964cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_20MHZ; 965cd392fe8SSimon Glass break; 966cd392fe8SSimon Glass case 33: 967cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_33MHZ; 968cd392fe8SSimon Glass break; 969cd392fe8SSimon Glass case 50: 970cd392fe8SSimon Glass spifreq = SPI_FREQUENCY_50MHZ; 971cd392fe8SSimon Glass break; 972cd392fe8SSimon Glass default: 973cd392fe8SSimon Glass fprintf(stderr, "Invalid SPI Frequency: %d\n", 974cd392fe8SSimon Glass inputfreq); 975cd392fe8SSimon Glass print_usage(argv[0]); 976cd392fe8SSimon Glass exit(EXIT_FAILURE); 977cd392fe8SSimon Glass } 978cd392fe8SSimon Glass mode_spifreq = 1; 979cd392fe8SSimon Glass break; 980cd392fe8SSimon Glass case 'u': 981cd392fe8SSimon Glass mode_unlocked = 1; 982cd392fe8SSimon Glass break; 983cd392fe8SSimon Glass case 'v': 984cd392fe8SSimon Glass print_version(); 985cd392fe8SSimon Glass exit(EXIT_SUCCESS); 986cd392fe8SSimon Glass break; 987cd392fe8SSimon Glass case 'w': 98831eca697SSimon Glass case 'U': 98931eca697SSimon Glass case 'f': 99065851fceSSimon Glass ifile = &input_file[wr_num]; 991cd392fe8SSimon Glass mode_write = 1; 992673ed2f8SBin Meng if (wr_num < WRITE_MAX) { 993673ed2f8SBin Meng if (get_two_words(optarg, &addr_str, 99465851fceSSimon Glass &ifile->fname)) { 995cd392fe8SSimon Glass print_usage(argv[0]); 996cd392fe8SSimon Glass exit(EXIT_FAILURE); 997cd392fe8SSimon Glass } 99850e8a6bbSBin Meng ifile->addr = strtoll(optarg, NULL, 0); 99931eca697SSimon Glass ifile->type = opt == 'f' ? IF_fdt : 100031eca697SSimon Glass opt == 'U' ? IF_uboot : IF_normal; 100131eca697SSimon Glass if (ifile->type == IF_fdt) 100231eca697SSimon Glass fdt = ifile; 100331eca697SSimon Glass else if (ifile->type == IF_uboot) 100431eca697SSimon Glass have_uboot = true; 1005673ed2f8SBin Meng wr_num++; 1006673ed2f8SBin Meng } else { 1007673ed2f8SBin Meng fprintf(stderr, 1008673ed2f8SBin Meng "The number of files to write simultaneously exceeds the limitation (%d)\n", 1009673ed2f8SBin Meng WRITE_MAX); 1010673ed2f8SBin Meng } 1011cd392fe8SSimon Glass break; 1012cd392fe8SSimon Glass case 'x': 1013cd392fe8SSimon Glass mode_extract = 1; 1014cd392fe8SSimon Glass break; 1015cd392fe8SSimon Glass case 'h': 1016cd392fe8SSimon Glass case '?': 1017cd392fe8SSimon Glass default: 1018cd392fe8SSimon Glass print_usage(argv[0]); 1019cd392fe8SSimon Glass exit(EXIT_SUCCESS); 1020cd392fe8SSimon Glass break; 1021cd392fe8SSimon Glass } 1022cd392fe8SSimon Glass } 1023cd392fe8SSimon Glass 1024cd392fe8SSimon Glass if (mode_locked == 1 && mode_unlocked == 1) { 1025cd392fe8SSimon Glass fprintf(stderr, "Locking/Unlocking FD and ME are mutually exclusive\n"); 1026cd392fe8SSimon Glass exit(EXIT_FAILURE); 1027cd392fe8SSimon Glass } 1028cd392fe8SSimon Glass 1029cd392fe8SSimon Glass if (mode_inject == 1 && mode_write == 1) { 1030cd392fe8SSimon Glass fprintf(stderr, "Inject/Write are mutually exclusive\n"); 1031cd392fe8SSimon Glass exit(EXIT_FAILURE); 1032cd392fe8SSimon Glass } 1033cd392fe8SSimon Glass 1034cd392fe8SSimon Glass if ((mode_dump + mode_extract + mode_inject + 1035cd392fe8SSimon Glass (mode_spifreq | mode_em100 | mode_unlocked | 1036cd392fe8SSimon Glass mode_locked)) > 1) { 1037cd392fe8SSimon Glass fprintf(stderr, "You may not specify more than one mode.\n\n"); 1038cd392fe8SSimon Glass print_usage(argv[0]); 1039cd392fe8SSimon Glass exit(EXIT_FAILURE); 1040cd392fe8SSimon Glass } 1041cd392fe8SSimon Glass 1042cd392fe8SSimon Glass if ((mode_dump + mode_extract + mode_inject + mode_spifreq + 1043cd392fe8SSimon Glass mode_em100 + mode_locked + mode_unlocked + mode_write + 1044c03c951bSSimon Glass mode_write_descriptor) == 0 && !create) { 1045cd392fe8SSimon Glass fprintf(stderr, "You need to specify a mode.\n\n"); 1046cd392fe8SSimon Glass print_usage(argv[0]); 1047cd392fe8SSimon Glass exit(EXIT_FAILURE); 1048cd392fe8SSimon Glass } 1049cd392fe8SSimon Glass 1050cd392fe8SSimon Glass if (create && rom_size == -1) { 1051cd392fe8SSimon Glass fprintf(stderr, "You need to specify a rom size when creating.\n\n"); 1052cd392fe8SSimon Glass exit(EXIT_FAILURE); 1053cd392fe8SSimon Glass } 1054cd392fe8SSimon Glass 1055cd392fe8SSimon Glass if (optind + 1 != argc) { 1056cd392fe8SSimon Glass fprintf(stderr, "You need to specify a file.\n\n"); 1057cd392fe8SSimon Glass print_usage(argv[0]); 1058cd392fe8SSimon Glass exit(EXIT_FAILURE); 1059cd392fe8SSimon Glass } 1060cd392fe8SSimon Glass 106131eca697SSimon Glass if (have_uboot && !fdt) { 106231eca697SSimon Glass fprintf(stderr, 106331eca697SSimon Glass "You must supply a device tree file for U-Boot\n\n"); 106431eca697SSimon Glass print_usage(argv[0]); 106531eca697SSimon Glass exit(EXIT_FAILURE); 106631eca697SSimon Glass } 106731eca697SSimon Glass 1068cd392fe8SSimon Glass filename = argv[optind]; 1069cd392fe8SSimon Glass if (optind + 2 != argc) 1070cd392fe8SSimon Glass outfile = argv[optind + 1]; 1071cd392fe8SSimon Glass 1072cd392fe8SSimon Glass if (create) 1073cd392fe8SSimon Glass bios_fd = open(filename, O_WRONLY | O_CREAT, 0666); 1074cd392fe8SSimon Glass else 1075cd392fe8SSimon Glass bios_fd = open(filename, outfile ? O_RDONLY : O_RDWR); 1076cd392fe8SSimon Glass 1077cd392fe8SSimon Glass if (bios_fd == -1) { 1078cd392fe8SSimon Glass perror("Could not open file"); 1079cd392fe8SSimon Glass exit(EXIT_FAILURE); 1080cd392fe8SSimon Glass } 1081cd392fe8SSimon Glass 1082cd392fe8SSimon Glass if (!create) { 1083cd392fe8SSimon Glass if (fstat(bios_fd, &buf) == -1) { 1084cd392fe8SSimon Glass perror("Could not stat file"); 1085cd392fe8SSimon Glass exit(EXIT_FAILURE); 1086cd392fe8SSimon Glass } 1087cd392fe8SSimon Glass size = buf.st_size; 1088cd392fe8SSimon Glass } 1089cd392fe8SSimon Glass 1090cd392fe8SSimon Glass debug("File %s is %d bytes\n", filename, size); 1091cd392fe8SSimon Glass 1092cd392fe8SSimon Glass if (rom_size == -1) 1093cd392fe8SSimon Glass rom_size = size; 1094cd392fe8SSimon Glass 1095cd392fe8SSimon Glass image = malloc(rom_size); 1096cd392fe8SSimon Glass if (!image) { 1097cd392fe8SSimon Glass printf("Out of memory.\n"); 1098cd392fe8SSimon Glass exit(EXIT_FAILURE); 1099cd392fe8SSimon Glass } 1100cd392fe8SSimon Glass 1101cd392fe8SSimon Glass memset(image, '\xff', rom_size); 1102cd392fe8SSimon Glass if (!create && read(bios_fd, image, size) != size) { 1103cd392fe8SSimon Glass perror("Could not read file"); 1104cd392fe8SSimon Glass exit(EXIT_FAILURE); 1105cd392fe8SSimon Glass } 1106cd392fe8SSimon Glass if (size != rom_size) { 1107cd392fe8SSimon Glass debug("ROM size changed to %d bytes\n", rom_size); 1108cd392fe8SSimon Glass size = rom_size; 1109cd392fe8SSimon Glass } 1110cd392fe8SSimon Glass 1111cd392fe8SSimon Glass write_it = true; 1112cd392fe8SSimon Glass ret = 0; 1113cd392fe8SSimon Glass if (mode_dump) { 1114cd392fe8SSimon Glass ret = dump_fd(image, size); 1115cd392fe8SSimon Glass write_it = false; 1116cd392fe8SSimon Glass } 1117cd392fe8SSimon Glass 1118cd392fe8SSimon Glass if (mode_extract) { 1119cd392fe8SSimon Glass ret = write_regions(image, size); 1120cd392fe8SSimon Glass write_it = false; 1121cd392fe8SSimon Glass } 1122cd392fe8SSimon Glass 1123cd392fe8SSimon Glass if (mode_write_descriptor) 1124*3c7aab23SSimon Glass ret = write_data(image, size, -size, desc_fname, 0); 1125cd392fe8SSimon Glass 1126cd392fe8SSimon Glass if (mode_inject) 11277dfb172dSSimon Glass ret = inject_region(image, size, region_type, inject_fname); 1128cd392fe8SSimon Glass 1129673ed2f8SBin Meng if (mode_write) { 1130*3c7aab23SSimon Glass int offset_uboot_top = 0; 1131*3c7aab23SSimon Glass 1132673ed2f8SBin Meng for (wr_idx = 0; wr_idx < wr_num; wr_idx++) { 113365851fceSSimon Glass ifile = &input_file[wr_idx]; 113431eca697SSimon Glass if (ifile->type == IF_fdt) { 113531eca697SSimon Glass continue; 113631eca697SSimon Glass } else if (ifile->type == IF_uboot) { 113731eca697SSimon Glass ret = write_uboot(image, size, ifile, fdt, 113831eca697SSimon Glass ucode_ptr); 1139*3c7aab23SSimon Glass offset_uboot_top = ret; 114031eca697SSimon Glass } else { 114165851fceSSimon Glass ret = write_data(image, size, ifile->addr, 1142*3c7aab23SSimon Glass ifile->fname, offset_uboot_top); 114331eca697SSimon Glass } 114431eca697SSimon Glass if (ret < 0) 1145673ed2f8SBin Meng break; 1146673ed2f8SBin Meng } 1147673ed2f8SBin Meng } 1148cd392fe8SSimon Glass 1149cd392fe8SSimon Glass if (mode_spifreq) 1150cd392fe8SSimon Glass set_spi_frequency(image, size, spifreq); 1151cd392fe8SSimon Glass 1152cd392fe8SSimon Glass if (mode_em100) 1153cd392fe8SSimon Glass set_em100_mode(image, size); 1154cd392fe8SSimon Glass 1155cd392fe8SSimon Glass if (mode_locked) 1156cd392fe8SSimon Glass lock_descriptor(image, size); 1157cd392fe8SSimon Glass 1158cd392fe8SSimon Glass if (mode_unlocked) 1159cd392fe8SSimon Glass unlock_descriptor(image, size); 1160cd392fe8SSimon Glass 1161cd392fe8SSimon Glass if (write_it) { 1162cd392fe8SSimon Glass if (outfile) { 1163cd392fe8SSimon Glass ret = write_image(outfile, image, size); 1164cd392fe8SSimon Glass } else { 1165cd392fe8SSimon Glass if (lseek(bios_fd, 0, SEEK_SET)) { 1166cd392fe8SSimon Glass perror("Error while seeking"); 1167cd392fe8SSimon Glass ret = -1; 1168cd392fe8SSimon Glass } 1169cd392fe8SSimon Glass if (write(bios_fd, image, size) != size) { 1170cd392fe8SSimon Glass perror("Error while writing"); 1171cd392fe8SSimon Glass ret = -1; 1172cd392fe8SSimon Glass } 1173cd392fe8SSimon Glass } 1174cd392fe8SSimon Glass } 1175cd392fe8SSimon Glass 1176cd392fe8SSimon Glass free(image); 1177cd392fe8SSimon Glass close(bios_fd); 1178cd392fe8SSimon Glass 117931eca697SSimon Glass return ret < 0 ? 1 : 0; 1180cd392fe8SSimon Glass } 1181