code:
/*
 *  gbe/gbe.h
 *  This file is part of the ich9deblob utility from the libreboot project
 *
 *  Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
 *                     Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * Purpose: provide struct representing gbe region.
 * Map actual buffers of this regions, directly to instances of these
 * structs. This makes working with gbe really easy.
 */

/*
 * bit fields used, corresponding to datasheet. See links to datasheets
 * and documentation in ich9deblob.c
 */

 /*
 * See docs/hcl/x200_remove_me.html for info plus links to datasheet (also linked below)
 *
 * Info about Gbe region (read whole datasheet):
 * http://www.intel.co.uk/content/dam/doc/application-note/i-o-controller-hub-9m-82567lf-lm-v-nvm-map-appl-note.pdf
 * https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums
 */

#ifndef GBESTRUCT_H
#define GBESTRUCT_H

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "../descriptor/descriptor.h"

/* Size of the full gbe region in bytes */
#define GBEREGIONSIZE_8K 0x2000
/*
 * Size of each sub-region in gbe.
 * gbe contains two regions which
 * can be identical: main and backup.
 * These are each half the size of the full region
 */
#define GBEREGIONSIZE_4K 0x1000

/*
 * When adding up the first 0x3F 16-bit words
 * in a 4KiB GBE region, it should be equal
 * to 0xBABA
 */
#define GBECHECKSUMTOTAL 0xBABA

/*
 * These will have a modified descriptor+gbe based on what's in the factory.rom
 * These will be joined into a single 12KiB buffer (descriptor, then gbe) and saved to a file
 * NOTE: The GBE region of 8K is actually 2x 4K regions in a single region; both 4K blocks can be identical (and by default, are)
 * The 2nd one is a "backup", but we don't know when it's used. perhaps it's used when the checksum on the first one does not match?
 */

/*
 * ---------------------------------------------------------------------
 * Gbe struct representing the data:
 * ---------------------------------------------------------------------
 */

struct GBE_RESERVED_WORD_03H {
	/* least significant bits */
	uint8_t reserved1_0                  : 8; /* bits should all be set to zero */
	uint8_t reserved1_1                  : 3;  /* ^ part of above. Separated so that the bitfields align */
	uint8_t ibaLom                       : 1;  /* set to 1 for intel boot agent to work (i.e. set it to 0) */
	uint8_t reserved2 		             : 4;  /* bits should all be set to zero */
	/* most significant bits */
};

/* Word 0A */
struct GBE_PCI_INITIALIZATION_CONTROL_WORD {
	/* least significant bits */
	uint8_t loadVendorDeviceId           : 1;  /* 1 = load from NVM. 0 = load from MAC fuses. It's 1 in my deblobbed_descriptor.bin */
	uint8_t loadSubsystemId              : 1;  /* 1 = load from NVM. 0 = load from MAC fuses. It's 1 in my deblobbed_descriptor.bin */
	uint8_t reserved1                    : 1;  /* Reserved. Set to 0 (according to datasheet). 0 in my deblobbed_descriptor.bin */
	uint8_t reserved2                    : 3;  /* Reserved. Set them to 0 (according to datasheet). 0 in my deblobbed_descriptor.bin */
	uint8_t pmEnable                     : 1;  /* Power Management Enable. 1=Enable. It's 1 in my deblobbed_descriptor.bin */
	uint8_t auxPwr                       : 1;  /* Auxiliary Power Indication. See datasheet. it's 1 in my deblobbed_descriptor.bin */
	uint8_t reserved3                    : 4;  /* Reserved. Set to 0000 (according to datasheet). */
	uint8_t reserved4                    : 4;  /* Reserved. Set to 0001 (according to datasheet). */
	/* most significant bits */
};

/* Word 10h. */
struct GBE_LAN_POWER_CONSUMPTION {
	/* least significant bits */
	uint8_t lanD3Power                   : 5;  /* It's 00001b (0x1) in deblobbed_descriptor.bin */
	uint8_t reserved                     : 3;  /* Reserved. These bits should all be 0. confirmed from deblobbed_descriptor.bin */
	uint8_t lanD0Power                   : 8;  /* default value: 0x0D (according to datasheet). confirmed from deblobbed_descriptor.bin */
	/* most significant bits */
};

/* Word 13h */
struct GBE_SHARED_INITIALIZATION_CONTROL_WORD {
	/* least significant bits */
	uint8_t reserved1                    : 3;  /* Reserved. These bits should be set to 101 (0x5) in binary (according to datasheet and deblobbed_descriptor.bin) */
	uint8_t forceDuplex                  : 1;  /* Hardware default is 0 according to datasheet and deblobbed_descriptor.bin. Presumably to set whether the chipset is to operate at full- or half-duplex */
	uint8_t forceSpeedEnable             : 1;  /* Hardware default is 0. Presumably to limited speed eg 10, 10/100, 10/100/1000 */
	uint8_t reserved2_0                  : 3;  /* Reserved. All bits should be set to 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t reserved2_1                  : 1;  /* ^ part of above. separated so that bitfields align */
	uint8_t phyPowerDownEnable           : 1;  /* PHY Power Down in D3/Dr (if WoL is disabled), 1 means Enable power down. deblobbed_descriptor.bin says 1 */
	uint8_t reserved3                    : 1;  /* Reserved. Should be set to 1 according to datasheet and deblobbed_descriptor.bin */
	uint8_t reserved4                    : 3;  /* Reserved. These bits should all be 0 according to datasheet and deblobbed_descriptor.bin */
	/* ^ reserved4: indicates whether a valid NVM is present. If invalid, MAC does not read NVM and uses default values. */
	/* 00 = invalid NVM, 01 = invalid NVM, 10 = valid NVM present, 11 = invalid NVM */
	/* Default should be 10 (binary) according to datasheet and deblobbed_descriptor.bin */
	uint8_t sign                         : 2;  /* Make sure to set this to 0x2 (10 in binary) */
	/* most significant bits */
};

/* Word 14h */
struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_1 {
	/* least significant bits */
	uint16_t extendedConfigurationPointer: 12; /* dword: base address of extended configuration area in NVM. should not be zero. Default is 020h according to datasheet and deblobbed_descriptor.bin */
	uint8_t oemWriteEnable               : 1;  /* 1=enable. if set, loads oem bits from phy_ctrl register to the 82567. loaded to EXTCNF_CTRL register. default is 1 according to datasheet and deblobbed_descriptor.bin */
	uint8_t reserved1                    : 1;  /* Reserved. default value 1 according to datasheet and deblobed_descriptor.bin */
	uint8_t reserved2                    : 1;  /* Reserved. default value 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t reserved3                    : 1;  /* Reserved. default value 0 according to datasheet and deblobbed_descriptor.bin */
	/* most significant bits */
};

/* Word 15h */
struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_2 {
	/* least significant bits */
	uint8_t reserved                     : 8;  /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t extendedPhyLength            : 8;  /* dword: size of extended phy configuration area. most be 0 if phy config area is disabled. default is 0000101 (binary) or 05 (hex) according to datasheet, but 00001010 (0A) according to deblobbed_descriptor.bin. Is 0000101 (in the datasheet) a typo that actually means 00001010? */
	/* most significant bits */
};

/*
 * Word 17h: LED 1 Configuration and Power Management
 *
 * Default values for LEDCTL register fields controlling LED1 (LINK_1000)
 * output behaviours and OEM fields that define PHY power management
 * parameters loaded to the PHY_CTRL register.
 */
struct LED_CTL_1 {
	/* least significant bits */

	/* See page 16 in the datasheet to show the different modes. deblobbed_descriptor.bin has "ACTIVITY" mode set */
	uint8_t led1Mode                     : 4;  /* Default value 0111 (bin) 7 (hex) says datasheet. 1011 (bin) B (hex) according to deblobbed_descriptor.bin */

	uint8_t reserved1                    : 1;  /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led1BlinkMode                : 1;  /* 0 = slow blink, 1 = fast blink. should be identical to led0 blink mode. Default is 0 according to datasheet and deblobbed_descriptor.bin */
	/* By setting this and led0 blink mode (see word 18h) to 1, you could enable a faster blinking on the LED's where the ethernet cable goes
	 * on the gigabit ethernet port. Not really useful. Slow blink is fine, and probably better (the LED will probably last longer) */

	uint8_t led1Invert                   : 1;  /* initial value of LED1_IVRT field. 0 = led1 has active low output, 1 is high active output. Default is 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led1Blink                    : 1;  /* 1 = led1 blinks, 0 = it does not. default 0 according to datasheet, but it's 1 in deblobbed_descriptor.bin */
	uint8_t reserved2                    : 1;  /* Reserved. should be 1 according to datasheet and deblobbed_descriptor.bin */
	uint8_t lpluEnable                   : 1;  /* Low Power Link Up. Enable links at lowest supported speed by both link partners in all power states. 1=enabled(all power states), 0=disabled. Default is 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t lpluEnableNonD0a             : 1;  /* Low Power Link up (non-D0a states). Same as above but only for non-D0a states. default is 1 according to and deblobbed_descriptor.bin */
	uint8_t gbeDisableNonD0a             : 1;  /* If set to 1, disable gigabit speeds in non-D0a power states. Must be 1 (according to datasheet) because GbE is not supported in Sx mode. It's also set to 1 in deblobbed_descriptor.bin */
	uint8_t reserved3                    : 2;  /* Reserved. Datasheet says both bits should be 0 (confirmed in deblobbed_descriptor.bin) */
	uint8_t gbeDisable                   : 1;  /* When 1, gigabit speeds are disabled in all power states including D0a. Default is 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t reserved4                    : 1;  /* Reserved. Should be 1, according to datasheet and deblobbed_descriptor.bin */
	/* most significant bits */
};

/*
 * Word 18: LED 0 and 2 Configuration Defaults
 *
 * Hardware defaults for LEDCTL register fields controlling LED0 (LINK/ACTIVITY)
 * and LED2 (LINK_100) output behaviours.
 */
struct LED_CTL_02 {
	/* least significant bits */

	/* see page 16 in datasheet to show the different modes. deblobbed_descriptor has "LINK-UP" mode set */
	uint8_t led0Mode                     : 4;  /* default value 0100 (bin) or 4 (hex) according to datasheet. It's 0010 (bin) or 2 (hex) according to deblobbed_descriptor.bin */

	uint8_t reserved1                    : 1;  /* Reserved. Should be set to 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led0BlinkMode                : 1;  /* This should be the same as led1BlinkMode (see word 17h). Default is 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led0Invert                   : 1;  /* initial value of LED0_IVRT field. 0 = led0 has active low output, 1 is high active output. Default is 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led0Blink                    : 1;  /* LED0_BLINK field. Should be 0 according to datasheet and deblobbed_descriptor.bin */

	/* see page 16 in datasheet to shew the different modes. deblobbed_descriptor has "LINK_100" mode set */
	uint8_t led2Mode                     : 4;  /* default value 0110 (bin) or 6 (hex) according to datasheet and deblobbed_descriptor.bin */

	uint8_t reserved2                    : 1;  /* Reserved. Should be 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led2BlinkMode                : 1;  /* 0 = slow blink. 1 = fast. default 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led2Invert                   : 1;  /* LED2_IVRT field. Should be 0 according to datasheet and deblobbed_descriptor.bin */
	uint8_t led2Blink                    : 1;  /* LED2_BLINK field. should be 0 according to datasheet and deblobbed_descriptor.bin */
	/* most significant bits */
};

/* Word 30h */
struct GBE_PXE_BOOT_AGENT_MAIN_SETUP_OPTIONS {
	/* least significant bits */
	uint8_t protocolSelect               : 2;  /* Default 00 binary (PXE) according to datasheet. 01 is reserved. 10/11 are undefined. deblobbed_descriptor.bin says 00 */
	uint8_t reserved1                    : 1;  /* Reserved. deblobbed_descriptor.bin says 0 */
	uint8_t defaultBootSelection         : 2;  /* deblobbed_descriptor.bin says 00 (binary). 00 is network boot, then local. 01 is local boot, then network. 10 is network boot only. 11 is local boot only */
	uint8_t reserved2                    : 1;  /* Reserved. deblobbed_descriptor.bin says 0. */
	uint8_t promptTime                   : 2;  /* deblobbed_descriptor.bin says 00. delay for how long "press ctrl-s" setup prompt message appears. 00 = 2 secs, 01 is 3 secs, 10 is 5 secs, 11 is 0 secs. */
	uint8_t displaySetupMessage          : 1;  /* default 1 says datasheet. deblobbed_descriptor.bin says 1. if 1, "ctrl-s" setup prompt message appears after the title message. */
	uint8_t reserved3                    : 1;  /* Datasheet says to set 0. deblobbed_descriptor.bin says 0. */
	uint8_t forceSpeed                   : 2;  /* deblobbed_descriptor.bin says 00. 00 = auto-negotiate, 01 = 10Mbps, 10 = 100Mbps, 11 = "not allowed" */
	uint8_t forceFullDuplex              : 1;  /* deblobbed_descriptor.bin says 0. Only relevant when bits 10/11 are set; if so, then: 0 = half duplex, 1 = full duplex */
	uint8_t reserved4                    : 1;  /* Reserved. deblobbed_descriptor.bin says 0. datasheet recommends 0. */
	uint8_t efiPresence                  : 1;  /* 1 means that an EFI image is present (0 means not present). deblobbed_descriptor.bin says 0. if 1, eeprom word 33h (efi version) becomes valid. if pxePresent is 1, that means EFI and PXE are both present.*/
	uint8_t pxePresence                  : 1;  /* 0 means that a PXE image is present. 1 means to pxe present. deblobbed_descriptor.bin says 0. if 0, then word 32h (PXE version) in eeprom becomes valid */
	/* most significant bits */

	/* This whole data structure is pointless, since libreboot doesn't (read: won't)
	 * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
};
/* Word 31h */
struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_31H {
	/* least significant bits */
	uint8_t disableSetupMenu             : 1;  /* 1 means invoking setup menu with ctrl-s won't work. deblobbed_descriptor.bin says 0 (as is default, per datasheet) */
	uint8_t disableTitleMessage          : 1;  /* 1 means that title in boot agent screen is suppressed, as is ctrl-s message. default is 0, and deblobbed_descriptor.bin says 0 */
	uint8_t disableProtocolSelect        : 1;  /* 1 means no changes to boot protocol are allowed. default is 0, and deblobbed_descriptor.bin says 0 */
	uint8_t disableBootSelection         : 1;  /* 1 means no changes in boot order option menu are allowed. default is 0, and deblobbed_descriptor.bin says 0 */
	uint8_t disableLegacyWakeupSupport   : 1;  /* 1 means no changes in legacy wakeup support menu is allowed. default is 0, and deblobbed_descriptor.bin says 0 */
	uint8_t disableFlashUpdate           : 1;  /* 1 means no changes to flash image using PROset is allowed. default is 0, and deblobbed_descriptor.bin says 0 */
	uint8_t reserved1                    : 2;  /* Reserved. Datasheet says these must be 0, and deblobbed_descriptor.bin sets them to 0. */

	/*
	 * deblobbed_descriptor says 000
	 * 000 = normal behaviour
	 * see datasheet (page 21) for other modes.
	 */
	uint8_t ibaBootOrderSetupMode        : 3;

	uint8_t reserved2                    : 3;  /* Reserved. Datasheet says these must be set to 0, and deblobbed_descriptor.bin sets them to 0. */
	uint8_t signature                    : 2;  /* Must be set to 01 to indicate that this whole word has been configured by the agent or other software. deblobbed_descriptor.bin says 01. */
	/* most significant bits */

	/* This whole data structure is pointless, since libreboot doesn't (read: won't)
	 * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
};
/* Word 32h */
struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_32H {
	/* least significant bits */
	uint8_t buildNumber                  : 8;  /* PXE boot agent build number. default is 28 (hex). deblobbed_descriptor.bin says 18 (hex) */
	uint8_t minorVersionNumber           : 4;  /* PXE boot agent minor number. default is 2 (hex). deblobbed_descriptor.bin says 3 (hex) */
	uint8_t majorVersionNumber           : 4;  /* PXE boot agent major number. default is F (hex). deblobbed_descriptor.bin says 1 (hex) */
	/* most significant bits */

	/* This whole data structure is pointless, since libreboot doesn't (read: won't)
	 * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
};
/* Word 33h */
struct GBE_PXE_IBA_CAPABILITIES {
	/* least significant bits */
	uint8_t baseCodePresent              : 1;  /* 0 means PXE base code is indicated as being present. 1 (default) means not. deblobbed_descriptor.bin says 1 */
	uint8_t undiCapabilityPresent        : 1;  /* 1 (default) means pxe/undi capability is indicated present. 0 means not present. deblobbed_descriptor.bin says 1 */
	uint8_t reserved1                    : 1;  /* Reserved. Must be 1. deblobbed_descriptor.bin says 1 */
	uint8_t efiUndiCapabilityPresent     : 1;  /* EFI UNDI capability present: 0 (default) means not present. 1 means present. deblobbed_descriptor.bin says 0 */
	uint8_t reserved2_0                  : 4;  /* reserved. all bits must be 0. deblobbed_descriptor.bin sets them to 0. */
	uint8_t reserved2_1                  : 6;  /* ^ part of reserved2_0. split this way so that the bitfields align */
	uint8_t signature                    : 2;  /* must be 01 to indicate that the word is configured by the agent or other software. deblobbed_descriptor.bin says 01 */
	/* most significant bits */

	/* This whole data structure is pointless, since libreboot doesn't (read: won't)
	 * include the proprietary intel boot agent. Struct exists here simply for documentations sake. */
};
/* Words 30h to 3Eh */
struct GBE_PXE_SOFTWARE_REGION {
	struct GBE_PXE_BOOT_AGENT_MAIN_SETUP_OPTIONS bootAgentMainSetupOptions;                                          /* Word 30h */
	struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_31H bootAgentConfigurationCustomizationOptions31h; /* Word 31h */
	struct GBE_PXE_BOOT_AGENT_CONFIGURATION_CUSTOMIZATION_OPTIONS_32H bootAgentConfigurationCustomizationOptions32h; /* Word 32h */
	struct GBE_PXE_IBA_CAPABILITIES ibaCapabilities;                                                                 /* Word 33h */

	/* Words 34h to 3Eh (padding). Set these to 0xFFFF (according to deblobbed_descriptor.bin) */
	uint16_t paddingWords34hTo3Eh[11];

	/*
	 * the pxe software region  is practically useless in libreboot, since
	 * libreboot does not include the intel boot agent (it's proprietary software).
	 *
	 * Having this struct in place is simply for documentations sake. It is completely
	 * irrelevant what you put here. filling it with 0xFFFF would probably be fine.
	 */
};

struct GBEREGIONRECORD_4K {
	uint8_t macAddress[6];                             /* Word 00 to 02 */
	struct GBE_RESERVED_WORD_03H reservedWord03h;            /* Reserved word 03. */
	uint16_t reservedWord04h;                          /* Reserved word 04: set it to 0xFFFF (according to datasheet and deblobbed_descriptor.bin) */
	uint16_t imageVersionInformation;                  /* Reserved word 05: 83 10 (little endian) in my deblobbed_descriptor.bin. Set this to 0x1083 (in C, assuming little endian byte order). "cannot be changed" according to datasheet */
	uint16_t reservedWords06h07h[2];                   /* Reserved words 06-07: set both to 0xFFFF (according to datasheet and deblobbed_descriptor.bin) */

	/*
	 * Word 08 and 09 (pba low and pba high):
	 *
	 * Both of these should be set to 0xFFFF by default, according to the datasheet.
	 * "nine digit printed board assembly (PBA) number" for intel cards to be stored
	 * in a 4 byte (read: 2 word) field.
	 *
	 * Example: if pba number is 123456-003, then word 08 should be 1234h and word 09 becomes 5603.
	 * Note: 1234 and 5603 above are big endian. In the image it would actually be 34 12 and 0356
	 *
	 * Example: in mine it was (in the image): 08 10 FF FF. That becomes 1008h and FFFFh, or
	 * basically: 1008FF-0FF. The same was observed in another.
	 *
	 * Setting it to FF FF FF FF should be fine, according to the datasheet.
	 */
	uint16_t pbaLow;												/* Word 08. Set it to 0x1008 (according to deblobbed_descriptor.bin). */
	uint16_t pbaHigh;												/* Word 09. Set it to 0xFFFF (according to deblobbed_descriptor.bin). */

	/* Word 0A */
	struct GBE_PCI_INITIALIZATION_CONTROL_WORD pciInitializationControlWord;

	/*
	 * Word 0B; subsystem ID
	 *
	 * If load subsystem ID bit of word 0A (pci init control word) is
	 * set to 1 (read: it is. in my deblobbed_descriptor.bin), store
	 * the subsystem id here. Datasheet says that the default value is
	 * 0000h, but you should set this to 20EEh (little endian: EE 20)
	 */
	uint16_t subsystemId; /* Set this to 0x20EE */

	/*
	 * Word 0C; subsystem vendor ID
	 *
	 * If load subsystem vendor ID bit of word 0A (pci init control word)
	 * is set to 1 (read: it is. in my deblobbed_descriptor.bin), store
	 * the subsystem vendor id here. Datasheet says that the default
	 * value is 8086h, but you should set this to 17AAh (lendian: AA 17).
	 */
	uint16_t subsystemVendorId; /* Set this to 0x17AA */

	/*
	 * Word 0D: device ID
	 *
	 * If load vendor/device ID in word 0A (pci init control word) is 1
	 * (it is) then this word is used to init device id using word 21h,
	 * 1Eh or 1Fh. In my case, deviceId is 0x10F5. Word 21h is set to
	 * 0x10CB, word 1Eh is 0x10F5 and 1Fh is 0x10BF
	 *
	 * The datasheet says that 10F5 is for Intel 82567LM gigabit ethernet
	 * controller; 10BF is for Intel 82567LF and 10CB is for Intel 82567V.
	 *
	 * Based on this, the X200 is shown to have the Intel 82567LM ethernet
	 * controller.
	 */
	uint16_t deviceId; /* Set this to 0x10F5. */
	/* It is important that this is correct, for the linux kernel driver */

	/*
	 * Word 0E: vendor ID
	 *
	 * If load vendor/device ID in word 0A (pci init control) is 1 (it is),
	 * then this word used read to initialize the PCI vendor ID. Default
	 * value is 8086 according to datasheets, and deblobbed_descriptor.bin.
	 *
	 * Intel is often 8086 as a PCI vendor ID. Because 8086. As in the CPU architecture.
	 */
	uint16_t vendorId;

	uint16_t deviceRevId;                              /* Word 0F: reserved bits. Set all bits to 0. */
	struct GBE_LAN_POWER_CONSUMPTION lanPowerConsumption;    /* Word 10: LAN Power Consumption (see struct definition) */
	uint16_t reservedWords11h12h[2];							/* Words 11-12: Reserved. Set both of them to 0x0000 (according to datasheet). */

	/* Word 13: Shared Initialization Control Word */
	struct GBE_SHARED_INITIALIZATION_CONTROL_WORD sharedInitializationControlWord;

	/* Word 14: Extended Configuration Control Word 1 */
	struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_1 extendedConfigurationControlWord1;

	/* Word 15: Extended Configuration Control Word 2 */
	struct GBE_EXTENDED_CONFIGURATION_CONTROL_WORD_2 extendedConfigurationControlWord2;

	/* Word 16: Extended Configuration Control Word 3 */
	/* All bits reserved. Datasheet and deblobbed_descriptor.bin say to set it to zero */
	uint16_t extendedConfigurationControlWord3;

	struct LED_CTL_1 ledCtl1;                                /* Word 17: LED 1 Configuration and Power Management */
	struct LED_CTL_02 ledCtl02;                              /* Word 18: LED 0 and 2 Configuration Defaults */
	uint16_t reservedWord19h;                          /* Word 19: Reserved. Default is 0x2B00 according to datasheet, but in deblobbed_descriptor.bin it is 0x2B40 */
	uint16_t reservedWord1Ah;                          /* Word 1A: Reserved. Default is 0x0043 according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord1Bh;                          /* Word 1B: Reserved. Should be 0x0000 according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord1Ch;                          /* Word 1C: Reserved. Should be 0x10F5 according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord1Dh;                          /* Word 1D: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
	uint16_t _82567lmDeviceId;                         /* Word 1E: Device ID for Intel 82567LM gigabit ethernet controller (note: X200 uses this). Should be 0x10F5 according to datasheet and deblobbed_descriptor.bin*/
	uint16_t _82567lfDeviceId;                         /* Word 1F: Device ID for Intel 82567LF gigabit ethernet controller. Should be 0x10BF according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord20h;									/* Word 20: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
	uint16_t _82567vDeviceId;                          /* Word 21: Device ID for Intel 82567V gigabit ethernet controller. Should be 0x10CB according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord22h;                          /* Word 22: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWord23h;                          /* Word 23: Reserved. Should be 0xBAAD according to datasheet and deblobbed_descriptor.bin */
	uint16_t reservedWords24to2Fh[12];                 /* Words 24-2F: Reserved. These should all be 0x0000 according to datasheet and deblobbed_descriptor.bin */
	struct GBE_PXE_SOFTWARE_REGION pxeSoftwareRegion;        /* Words 30-3E: PXE Software Region */
	uint16_t checkSum; /* when added to the sum of all words above, this should match GBECHECKSUMTOTAL */

	/* set all bytes in here to 0xFF */
	uint8_t padding[3968];
};

/*  main and backup region in gbe */
struct GBEREGIONRECORD_8K {
	struct GBEREGIONRECORD_4K main;
	struct GBEREGIONRECORD_4K backup;
	/*
	 * Backup region:
	 * This is actually "main" on X200, since the real main has a bad checksum
	 * and other errors. You should do what you need on this one (if modifying
	 * lenovobios's gbe region) and then copy to main
	 */
};

/*
 * ---------------------------------------------------------------------
 * Function declarations (keep gcc/make happy. check them in gbe.c)
 * ---------------------------------------------------------------------
 */

uint16_t gbeGetChecksumFrom4kBuffer(uint16_t* gbeWord, uint16_t desiredValue, int gbeRegionBase);
uint16_t gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, uint16_t desiredValue);
struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K factoryGbeStruct8k);
int notCreatedHFileForGbeCFile(char* outFileName, char* cFileName);
int notCreatedCFileFromGbeStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* outFileName, char* headerFileName);
void printGbeChecksumDataFromStruct4k(struct GBEREGIONRECORD_4K gbeStruct4k, char* romName, char* regionName);
void printGbeChecksumDataFromStruct8k(struct GBEREGIONRECORD_8K gbeStruct8k, char* romName);

#endif


code:
/*
 *  ich9deblob.c
 *  This file is part of the ich9deblob utility from the libreboot project
 *
 * Purpose: disable and remove the ME from ich9m/gm45 systems in coreboot.
 *
 *  Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
 *  Copyright (C) 2014,2015 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/* Initially based on proof of concept by Steve Shenton. */
/* Original utility can be found at https://gitorious.org/ich9descriptortool */

/*
 * Read a factory.rom dump (ich9m/gm45 systems) and
 * modify the flash descriptor to remove all regions except descriptor,
 * Gbe and BIOS. Set BIOS region to full size of the ROM image (after
 * the flash descriptor and gbe). Basically, deblob the descriptor.
 *
 * This will will generate a concatenated descriptor+gbe dump suitable
 * for use in libreboot. Currently tested: ThinkPad X200 (coreboot/libreboot)
 */

/*
 * See docs/hcl/x200_remove_me.html for info plus links to datasheet (also linked below)
 *
 * Info about flash descriptor (read page 845 onwards):
 * http://www.intel.co.uk/content/dam/doc/datasheet/io-controller-hub-9-datasheet.pdf
 *
 * Info about Gbe region (read whole datasheet):
 * http://www.intel.co.uk/content/dam/doc/application-note/i-o-controller-hub-9m-82567lf-lm-v-nvm-map-appl-note.pdf
 * https://communities.intel.com/community/wired/blog/2010/10/14/how-to-basic-eeprom-checksums
 */

#include "ich9deblob.h"

int main()
{
	struct DESCRIPTORREGIONRECORD descriptorStruct;
	uint8_t* descriptorBuffer = (uint8_t*)&descriptorStruct;

	struct GBEREGIONRECORD_8K gbeStruct8k;
	uint8_t* gbeBuffer8k = (uint8_t*)&gbeStruct8k;
	uint32_t gbeRegionStart;

	char* romFilename = "factory.rom";
	char* descriptorGbeFilename = "deblobbed_descriptor.bin";
	char* descriptorNoGbeFilename = "deblobbed_4kdescriptor.bin";

	unsigned int bufferLength;
	unsigned int romSize;

	/*
	 * ------------------------------------------------------------------
	 * Compatibility checks. This version of ich9deblob is not yet portable.
	 * ------------------------------------------------------------------
	 */

	if (systemOrCompilerIncompatible(descriptorStruct, gbeStruct8k)) return 1;
	/* If true, fail with error message */

	/*
	 * ------------------------------------------------------------------
	 * Extract the descriptor and gbe regions from the factory.rom dump
	 * ------------------------------------------------------------------
	 */
	FILE* fp = NULL;
	fp = fopen(romFilename, "rb"); /* open factory.rom */
	if (NULL == fp)
	{
		printf("\nerror: could not open %s\n", romFilename);
		fclose(fp);
		return 1;
	}
	printf("\n%s opened successfully\n", romFilename);

	/*
	 * Get the descriptor region dump from the factory.rom
	 * (goes in factoryDescriptorBuffer variable)
	 */
	bufferLength = fread(descriptorBuffer, 1, DESCRIPTORREGIONSIZE, fp);
	if (DESCRIPTORREGIONSIZE != bufferLength) //
	{
		printf("\nerror: could not read descriptor from %s (%i) bytes read\n", romFilename, bufferLength);
		fclose(fp);
		return 1;
	}
	printf("\ndescriptor region read successfully\n");

	if (descriptorDefinesGbeRegion(descriptorStruct))
	{
		gbeRegionStart = descriptorStruct.regionSection.flReg3.BASE << FLREGIONBITSHIFT;

		/*
		 * Set offset so that we can read the data from
		 * the gbe region
		 */
		fseek(fp, gbeRegionStart, SEEK_SET);
		/* Read the gbe data from the factory.rom and put it in factoryGbeBuffer8k */
		bufferLength = fread(gbeBuffer8k, 1, GBEREGIONSIZE_8K, fp);
		if (GBEREGIONSIZE_8K != bufferLength)
		{
			printf("\nerror: could not read GBe region from %s (%i) bytes read\n", romFilename, bufferLength);
			fclose(fp);
			return 1;
		}
		printf("\ngbe (8KiB) region read successfully\n");
	}

	fseek(fp, 0L, SEEK_END);
	romSize = ftell(fp);
	printf("\n%s size: [%i] bytes\n", romFilename, romSize);

	fclose(fp);

	/* Debugging (before modification) */
	printDescriptorRegionLocations(descriptorStruct, "Original");
	if (descriptorDefinesGbeRegion(descriptorStruct))
		printGbeChecksumDataFromStruct8k(gbeStruct8k, "Original");
	else printf("NO GBE REGION\n");

	/*
	 * ------------------------------------------------------------------
	 * Modify the descriptor and gbe regions, ready to go in libreboot.rom
	 * ------------------------------------------------------------------
	 */

	/* Delete the ME/Platform regions, place Gbe after the descriptor, resize BIOS region to fill the gap */
	descriptorStruct = librebootDescriptorStructFromFactory(descriptorStruct, romSize);

	/* The ME is disallowed read-write access to all regions
	 * (this is probably redundant, since the ME firmware is already removed from libreboot) */
	descriptorStruct = descriptorMeRegionsForbidden(descriptorStruct);
	/* Host/CPU is allowed to read/write all regions.
	 * This makes flashrom -p internal work */
	descriptorStruct = descriptorHostRegionsUnlocked(descriptorStruct);

	/* Set OEM string */
	descriptorStruct = descriptorOemString(descriptorStruct);

	/* Modify the Gbe region (see function for details) */
	if (descriptorDefinesGbeRegion(descriptorStruct))
		gbeStruct8k = deblobbedGbeStructFromFactory(gbeStruct8k);

	/* Debugging (after modifying the descriptor and gbe regions) */
	printDescriptorRegionLocations(descriptorStruct, "Modified");
	if (descriptorDefinesGbeRegion(descriptorStruct))
		printGbeChecksumDataFromStruct8k(gbeStruct8k, "Modified");
	else printf("NO GBE REGION\n");

	/*
	 * ------------------------------------------------------------------
	 * Create the file with the modified descriptor and gbe inside
	 * ------------------------------------------------------------------
	 */
	printf("\n");
	if (descriptorDefinesGbeRegion(descriptorStruct))
	{
		if (notCreatedDescriptorGbeFile(descriptorStruct, gbeStruct8k, descriptorGbeFilename)) {
			return 1;
		}
	}
	else
	{
		if (notCreated4kDescriptorFile(descriptorStruct, descriptorNoGbeFilename)) {
			return 1;
		}
	}

	/*
	 * ------------------------------------------------------------------
	 * Generate ich9gen data (C code that will recreate the deblobbed descriptor+gbe from scratch)
	 * ------------------------------------------------------------------
	 */
	/* Code for generating the Descriptor struct */
	/* mkdescriptor.h */
	if (notCreatedHFileForDescriptorCFile("mkdescriptor.h", "mkdescriptor.c")) {
		return 1;
	} /* and now mkdescriptor.c */
	if (notCreatedCFileFromDescriptorStruct(descriptorStruct, "mkdescriptor.c", "mkdescriptor.h")) {
		return 1;
	}

	if (descriptorDefinesGbeRegion(descriptorStruct))
	{
		/* Code for generating the Gbe struct */
		/* mkgbe.h */
		if (notCreatedHFileForGbeCFile("mkgbe.h", "mkgbe.c")) {
			return 1;
		} /* and now mkgbe.c */
		if (notCreatedCFileFromGbeStruct4k(gbeStruct8k.backup, "mkgbe.c", "mkgbe.h")) {
			return 1;
		}
	}

	if (descriptorDefinesGbeRegion(descriptorStruct))
	{
		printf("The modified descriptor and gbe regions have also been dumped as src files: mkdescriptor.c, mkdescriptor.h, mkgbe.c, mkgbe.h\n");
		printf("To use these in ich9gen, place them in src/ich9gen/ and re-build ich9gen.\n\n");
	}
	else
	{
		printf("The modified descriptor region have also been dumped as src files: mkdescriptor.c, mkdescriptor.h\n");
		printf("To use these in ich9gen, place them in src/ich9gen/ and re-build ich9gen.\n\n");
	}

	return 0;
}

repo_name: Amlouden/libreboot

license: mit


code:
/*
 *  ich9deblob.h
 *  This file is part of the ich9deblob utility from the libreboot project
 *
 * Purpose: header file for ich9deblob.c
 *
 *  Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
 *                     Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ICH9DEBLOB_H
#define ICH9DEBLOB_H

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#include "common/descriptor_gbe.h"   /* common descriptor/gbe functions used by ich9deblob */
#include "common/x86compatibility.h" /* system/compiler compatibility checks. This code is not portable. */
#include "descriptor/descriptor.h"   /* structs describing what's in the descriptor region */
#include "gbe/gbe.h"                 /* structs describing what's in the gbe region */

int main();

#endif


code:
/*
 *  Copyright (C) 2014, 2015 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/* Generate deblobbed descriptor and gbe 12KiB file from scratch
 * without relying on a factory.rom dump */

#include "ich9gen.h"

int main(int argc, char *argv[])
{
	int i, j;

	struct GBEREGIONRECORD_8K gbeStruct8k = generatedGbeStruct8k();
	struct DESCRIPTORREGIONRECORD descriptorStruct4M = generatedDescriptorStruct(ROMSIZE_4MB, WITHGBE);
	struct DESCRIPTORREGIONRECORD descriptorStruct8M = generatedDescriptorStruct(ROMSIZE_8MB, WITHGBE);
	struct DESCRIPTORREGIONRECORD descriptorStructNoGbe4M = generatedDescriptorStruct(ROMSIZE_4MB, WITHOUTGBE);
	struct DESCRIPTORREGIONRECORD descriptorStructNoGbe8M = generatedDescriptorStruct(ROMSIZE_8MB, WITHOUTGBE);

	/* Only for the compatibility checks */
	struct DESCRIPTORREGIONRECORD dummyDescriptorStruct;
	struct GBEREGIONRECORD_8K dummyGbeStruct8k;

	/*
	 * ------------------------------------------------------------------
	 * Compatibility checks. This version of ich9deblob is not yet portable.
	 * ------------------------------------------------------------------
	 */

	if (systemOrCompilerIncompatible(dummyDescriptorStruct, dummyGbeStruct8k)) return 1;
	/* If true, fail with error message */

	/*
	 * ------------------------------------------------------------------
	 * Arguments given on the terminal
	 * ------------------------------------------------------------------
	 */

	if(argc==3) {

		/* If user provides their own MAC address, it will be used.
		 * Otherwise, ich9gen will simply use the default one.
		 *
		 * However, if the user provides an invalid MAC address, then ich9gen
		 * will exit. */
		if(0==strcmp(argv[1],"--macaddress")) {
			/* 6 hex chars format (example): AA:BB:CC:DD:EE:FF */
			if (strlen(argv[2]) != 17) {
				printf("ich9gen: invalid mac address format (wrong length)\n");
				return 1;
			}
			for(i=2; i<14; i+=3) {
				if(argv[2][i]!=':') {
					printf("ich9gen: invalid mac address format (non-colon characters used as spacing)\n");
					return 1;
				}
			}
			for(i=0; i<6; i++) {
				gbeStruct8k.main.macAddress[i] = 0;

				/* Go through each nibble of the byte */
				for(j=0; j<2; j++) {
					if(argv[2][(i*3)+j]>='a' && argv[2][(i*3)+j]<='f')
						gbeStruct8k.main.macAddress[i] |= (uint8_t)((argv[2][(i*3)+j] - 87) << ((j^1) << 2));
					else if(argv[2][(i*3)+j]>='A' && argv[2][(i*3)+j]<='F')
						gbeStruct8k.main.macAddress[i] |= (uint8_t)((argv[2][(i*3)+j] - 55) << ((j^1) << 2));
					else if(argv[2][(i*3)+j]>='0' && argv[2][(i*3)+j]<='9')
						gbeStruct8k.main.macAddress[i] |= (uint8_t)((argv[2][(i*3)+j] - 48) << ((j^1) << 2));
					else {
						printf("ich9gen: invalid mac address format (non-hex characters)\n");
						return 1;
					}
				}
			}

			gbeStruct8k.main.checkSum = gbeGetChecksumFrom4kStruct(gbeStruct8k.main, GBECHECKSUMTOTAL); /* Fix the checksum */
			memcpy(&gbeStruct8k.backup, &gbeStruct8k.main, GBEREGIONSIZE_4K); /* Copy to the backup */

			/* Generate ich9gen data (C code for Gbe region): */

			/* mkgbe.h */
			if (notCreatedHFileForGbeCFile("mkgbe.h", "mkgbe.c")) {
				return 1;
			} /* and now mkgbe.c */
			if (notCreatedCFileFromGbeStruct4k(gbeStruct8k.backup, "mkgbe.c", "mkgbe.h")) {
				return 1;
			}

			printf("You selected to change the MAC address in the Gbe section. This has been done.\n\n");

			printf("The modified gbe region has also been dumped as src files: mkgbe.c, mkgbe.h\n");
			printf("To use these in ich9gen, place them in src/ich9gen/ and re-build ich9gen.\n\n");
		}

	}

	/*
	 * ------------------------------------------------------------------
	 * Generate the 12KiB files, ready to be used in a libreboot image
	 * ------------------------------------------------------------------
	 */

	if (notCreatedDescriptorGbeFile(descriptorStruct4M, gbeStruct8k, "ich9fdgbe_4m.bin")) {
		return 1;
	}

	if (notCreatedDescriptorGbeFile(descriptorStruct8M, gbeStruct8k, "ich9fdgbe_8m.bin")) {
		return 1;
	}

	/*
	 * ------------------------------------------------------------------
	 * Generate the 4KiB files (descriptors without GbE), ready to be used in a libreboot image
	 * In these descriptors, the onboard Intel GbE NIC is disabled; a discrete one is used instead
	 * ------------------------------------------------------------------
	 */

	if (notCreated4kDescriptorFile(descriptorStructNoGbe4M, "ich9fdnogbe_4m.bin")) {
		return 1;
	}

	if (notCreated4kDescriptorFile(descriptorStructNoGbe8M, "ich9fdnogbe_8m.bin")) {
		return 1;
	}

	return 0;
}


code:
/*
 *  Copyright (C) 2014 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/* Header file for ich9gen.c */

#ifndef ICH9GEN_H
#define ICH9GEN_H

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#include "ich9gen/mkdescriptor.h"
#include "ich9gen/mkgbe.h"
#include "common/descriptor_gbe.h"   /* common descriptor/gbe functions used by ich9deblob */
#include "common/x86compatibility.h" /* system/compiler compatibility checks. This code is not portable. */
#include "descriptor/descriptor.h"   /* structs describing what's in the descriptor region */
#include "gbe/gbe.h"                 /* structs describing what's in the gbe region */

#define WITHGBE 1
#define WITHOUTGBE 0

int main(int argc, char *argv[]);

#endif


code:
/*
 *  Copyright (C) 2014, 2015 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "mkdescriptor.h"

/* Generate a 4KiB Descriptor struct, with default values. */
/* Read ../descriptor/descriptor.h for an explanation of the default values used here */

struct DESCRIPTORREGIONRECORD generatedDescriptorStruct(unsigned int romSize, int hasGbe)
{
    int i;
    struct DESCRIPTORREGIONRECORD descriptorStruct;

    /* Flash Valid Signature Register */
    descriptorStruct.flValSig.signature = 0x0ff0a55a;

    /* Flash Map Registers */
    /* FLMAP0 */
    descriptorStruct.flMaps.flMap0.FCBA = 0x01;
    descriptorStruct.flMaps.flMap0.NC = 0x0;
    descriptorStruct.flMaps.flMap0.reserved1 = 0x00;
    descriptorStruct.flMaps.flMap0.FRBA = 0x04;
    descriptorStruct.flMaps.flMap0.NR = hasGbe ? 0x2 : 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.flMaps.flMap0.reserved2 = 0x00;
    /* FLMAP1 */
    descriptorStruct.flMaps.flMap1.FMBA = 0x06;
    descriptorStruct.flMaps.flMap1.NM = 0x2;
    descriptorStruct.flMaps.flMap1.reserved = 0x00;
    descriptorStruct.flMaps.flMap1.FISBA = 0x10;
    descriptorStruct.flMaps.flMap1.ISL = 0x02;
    /* FLMAP2 */
    descriptorStruct.flMaps.flMap2.FMSBA = 0x20;
    descriptorStruct.flMaps.flMap2.MSL = 0x01;
    descriptorStruct.flMaps.flMap2.reserved = 0x0000;

    /* Component Section Record */
    /* FLCOMP */
    descriptorStruct.componentSection.flcomp.component1Density = componentDensity(romSize);
    descriptorStruct.componentSection.flcomp.component2Density = componentDensity(romSize);
    descriptorStruct.componentSection.flcomp.reserved1 = 0x0;
    descriptorStruct.componentSection.flcomp.reserved2 = 0x00;
    descriptorStruct.componentSection.flcomp.reserved3 = 0x0;
    descriptorStruct.componentSection.flcomp.readClockFrequency = 0x0;
    descriptorStruct.componentSection.flcomp.fastReadSupport = 0x1;
    descriptorStruct.componentSection.flcomp.fastreadClockFrequency = 0x1;
    descriptorStruct.componentSection.flcomp.writeEraseClockFrequency = 0x0;
    descriptorStruct.componentSection.flcomp.readStatusClockFrequency = 0x0;
    descriptorStruct.componentSection.flcomp.reserved4 = 0x0;
    /* FLILL */
    descriptorStruct.componentSection.flill = 0x00000000;
    /* FLPB */
    descriptorStruct.componentSection.flpb = 0x00000000;
    /* Padding */
    for (i = 0; i < 36; i++) {
        descriptorStruct.componentSection.padding[i] = 0xFF;
    }

    /* Flash Descriptor Region Section */
    /* FLREG0 (Descriptor) */
    descriptorStruct.regionSection.flReg0.BASE = 0x0000;
    descriptorStruct.regionSection.flReg0.reserved1 = 0x0;
    descriptorStruct.regionSection.flReg0.LIMIT = 0x0000;
    descriptorStruct.regionSection.flReg0.reserved2 = 0x0;
    /* FLREG1 (BIOS) */
    descriptorStruct.regionSection.flReg1.BASE = (DESCRIPTORREGIONSIZE + (hasGbe ? GBEREGIONSIZE_8K : 0)) >> FLREGIONBITSHIFT; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg1.reserved1 = 0x0;
    descriptorStruct.regionSection.flReg1.LIMIT = ((romSize >> FLREGIONBITSHIFT) - 1); /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg1.reserved2 = 0x0;
    /* FLREG2 (ME) */
    descriptorStruct.regionSection.flReg2.BASE = 0x1fff; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg2.reserved1 = 0x0;
    descriptorStruct.regionSection.flReg2.LIMIT = 0x0000; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg2.reserved2 = 0x0;
    /* FLREG3 (Gbe) */
    descriptorStruct.regionSection.flReg3.BASE = hasGbe ? (DESCRIPTORREGIONSIZE >> FLREGIONBITSHIFT) : 0x1fff; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg3.reserved1 = 0x0;
    descriptorStruct.regionSection.flReg3.LIMIT = hasGbe ? (GBEREGIONSIZE_8K >> FLREGIONBITSHIFT) : 0x0000; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg3.reserved2 = 0x0;
    /* FLREG4 (Platform) */
    descriptorStruct.regionSection.flReg4.BASE = 0x1fff; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg4.reserved1 = 0x0;
    descriptorStruct.regionSection.flReg4.LIMIT = 0x0000; /* see ../descriptor/descriptor.c */
    descriptorStruct.regionSection.flReg4.reserved2 = 0x0;
    /* Padding */
    for (i = 0; i < 12; i++) {
        descriptorStruct.regionSection.padding[i] = 0xFF;
    }

    /* Master Access Section */
    /* FLMSTR1 (Host CPU / BIOS) */
    descriptorStruct.masterAccessSection.flMstr1.requesterId = 0x0000;
    descriptorStruct.masterAccessSection.flMstr1.fdRegionReadAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.biosRegionReadAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.meRegionReadAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.gbeRegionReadAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.pdRegionReadAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.reserved1 = 0x0;
    descriptorStruct.masterAccessSection.flMstr1.fdRegionWriteAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.biosRegionWriteAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.meRegionWriteAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.gbeRegionWriteAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.pdRegionWriteAccess = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr1.reserved2 = 0x0;
    /* FLMSTR2 (ME) */
    descriptorStruct.masterAccessSection.flMstr2.requesterId = 0x0000;
    descriptorStruct.masterAccessSection.flMstr2.fdRegionReadAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.biosRegionReadAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.meRegionReadAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.gbeRegionReadAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.pdRegionReadAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.reserved1 = 0x0;
    descriptorStruct.masterAccessSection.flMstr2.fdRegionWriteAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.biosRegionWriteAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.meRegionWriteAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.gbeRegionWriteAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.pdRegionWriteAccess = 0x0; /* see ../descriptor/descriptor.c */
    descriptorStruct.masterAccessSection.flMstr2.reserved2 = 0x0;
    /* FLMSTR3 (Gbe) */
    descriptorStruct.masterAccessSection.flMstr3.requesterId = 0x0218;
    descriptorStruct.masterAccessSection.flMstr3.fdRegionReadAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.biosRegionReadAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.meRegionReadAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.gbeRegionReadAccess = 0x1;
    descriptorStruct.masterAccessSection.flMstr3.pdRegionReadAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.reserved1 = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.fdRegionWriteAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.biosRegionWriteAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.meRegionWriteAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.gbeRegionWriteAccess = 0x1;
    descriptorStruct.masterAccessSection.flMstr3.pdRegionWriteAccess = 0x0;
    descriptorStruct.masterAccessSection.flMstr3.reserved2 = 0x0;
    /* Padding */
    for (i = 0; i < 148; i++) {
        descriptorStruct.masterAccessSection.padding[i] = 0xFF;
    }

    /* ICH straps */
    /* ICHSTRAP0 */
    descriptorStruct.ichStraps.ichStrap0.meDisable = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.ichStraps.ichStrap0.reserved1 = 0x04;
    descriptorStruct.ichStraps.ichStrap0.tcoMode = 0x1;
    descriptorStruct.ichStraps.ichStrap0.smBusAddress = 0x64;
    descriptorStruct.ichStraps.ichStrap0.bmcMode = 0x0;
    descriptorStruct.ichStraps.ichStrap0.tripPointSelect = 0x0;
    descriptorStruct.ichStraps.ichStrap0.reserved2 = 0x0;
    descriptorStruct.ichStraps.ichStrap0.integratedGbe = hasGbe ? 0x1 : 0x0;
    descriptorStruct.ichStraps.ichStrap0.lanPhy = hasGbe ? 0x1 : 0x0;
    descriptorStruct.ichStraps.ichStrap0.reserved3 = 0x0;
    descriptorStruct.ichStraps.ichStrap0.dmiRequesterId = 0x0;
    descriptorStruct.ichStraps.ichStrap0.smBus2Address = 0x00;
    /* ICHSTRAP1 */
    descriptorStruct.ichStraps.ichStrap1.northMlink = 0x1;
    descriptorStruct.ichStraps.ichStrap1.southMlink = 0x1;
    descriptorStruct.ichStraps.ichStrap1.meSmbus = 0x1;
    descriptorStruct.ichStraps.ichStrap1.sstDynamic = 0x1;
    descriptorStruct.ichStraps.ichStrap1.reserved1 = 0x0;
    descriptorStruct.ichStraps.ichStrap1.northMlink2 = 0x1;
    descriptorStruct.ichStraps.ichStrap1.reserved2 = 0x00;
    descriptorStruct.ichStraps.ichStrap1.reserved3 = 0x0000;
    /* Padding */
    for (i = 0; i < 248; i++) {
        descriptorStruct.ichStraps.padding[i] = 0xFF;
    }

    /* MCH straps */
    /* MCHSTRAP0 */
    descriptorStruct.mchStraps.mchStrap0.meDisable = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.mchStraps.mchStrap0.meBootFromFlash = 0x0;
    descriptorStruct.mchStraps.mchStrap0.tpmDisable = 0x1; /* see ../descriptor/descriptor.c */
    descriptorStruct.mchStraps.mchStrap0.reserved1 = 0x7;
    descriptorStruct.mchStraps.mchStrap0.spiFingerprint = 0x1;
    descriptorStruct.mchStraps.mchStrap0.meAlternateDisable = 0x0;
    descriptorStruct.mchStraps.mchStrap0.reserved2 = 0xff;
    descriptorStruct.mchStraps.mchStrap0.reserved3 = 0xffff;
    /* Padding */
    for (i = 0; i < 3292; i++) {
        descriptorStruct.mchStraps.padding[i] = 0xFF;
    }

    /* ME VSCC Table */
    descriptorStruct.meVsccTable.jid0 = 0x001720c2;
    descriptorStruct.meVsccTable.vscc0 = 0x20052005;
    descriptorStruct.meVsccTable.jid1 = 0x001730ef;
    descriptorStruct.meVsccTable.vscc1 = 0x20052005;
    descriptorStruct.meVsccTable.jid2 = 0x0000481f;
    descriptorStruct.meVsccTable.vscc2 = 0x20152015;
    /* Padding */
    for (i = 0; i < 4; i++) {
        descriptorStruct.meVsccTable.padding[i] = 0xFF;
    }

    /* Descriptor Map 2 Record */
    descriptorStruct.descriptor2Map.meVsccTableBaseAddress = 0xee;
    descriptorStruct.descriptor2Map.meVsccTableLength = 0x06;
    descriptorStruct.descriptor2Map.reserved = 0x0000;

    /* OEM section */
    /* see ../descriptor/descriptor.c */
    /* Magic String (ascii characters) */
    descriptorStruct.oemSection.magicString[0] = 0x4c;
    descriptorStruct.oemSection.magicString[1] = 0x49;
    descriptorStruct.oemSection.magicString[2] = 0x42;
    descriptorStruct.oemSection.magicString[3] = 0x45;
    descriptorStruct.oemSection.magicString[4] = 0x52;
    descriptorStruct.oemSection.magicString[5] = 0x41;
    descriptorStruct.oemSection.magicString[6] = 0x54;
    descriptorStruct.oemSection.magicString[7] = 0x45;
    /* Padding */
    for (i = 0; i < 248; i++) {
        descriptorStruct.oemSection.padding[i] = 0xFF;
    }

    return descriptorStruct;
}


code:
/*
 *  Copyright (C) 2014 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ICH9GEN_MKDESCRIPTOR_H
#define ICH9GEN_MKDESCRIPTOR_H

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "../descriptor/descriptor.h"

struct DESCRIPTORREGIONRECORD generatedDescriptorStruct(unsigned int romSize, int hasGbe);
#endif


code:
/*
 *  Copyright (C) 2014 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "mkgbe.h"

/* Generate a 4KiB Gbe struct, with default values. */
/* Read ../gbe/gbe.h for an explanation of the default values used here */

struct GBEREGIONRECORD_4K generatedGbeStruct4k()
{
    int i;
    struct GBEREGIONRECORD_4K gbeStruct4k;

    /* MAC address (words 00h to 02h) */
    /* see ../gbe/gbe.c */
    gbeStruct4k.macAddress[0] = 0x00;
    gbeStruct4k.macAddress[1] = 0xf5;
    gbeStruct4k.macAddress[2] = 0xf0;
    gbeStruct4k.macAddress[3] = 0x40;
    gbeStruct4k.macAddress[4] = 0x71;
    gbeStruct4k.macAddress[5] = 0xfe;

    /* Word 03h (Reserved) */
    gbeStruct4k.reservedWord03h.reserved1_0 = 0x00;
    gbeStruct4k.reservedWord03h.reserved1_1 = 0x0;
    gbeStruct4k.reservedWord03h.ibaLom = 0x1;
    gbeStruct4k.reservedWord03h.reserved2 = 0x0;

    /* Word 04h (Reserved) */
    gbeStruct4k.reservedWord04h = 0xffff;

    /* Word 05h (Image Version Information) */
    gbeStruct4k.imageVersionInformation = 0x1083;

    /* Words 06h and 07h (Reserved) */
    gbeStruct4k.reservedWords06h07h[0] = 0xffff;
    gbeStruct4k.reservedWords06h07h[1] = 0xffff;

    /* Word 08h and 09h (PBA Low and PBA High) */
    gbeStruct4k.pbaLow = 0x1008;
    gbeStruct4k.pbaHigh = 0xffff;

    /* Word 0Ah (PCI Initialization Control Word) */
    gbeStruct4k.pciInitializationControlWord.loadVendorDeviceId = 0x1;
    gbeStruct4k.pciInitializationControlWord.loadSubsystemId = 0x1;
    gbeStruct4k.pciInitializationControlWord.reserved1 = 0x0;
    gbeStruct4k.pciInitializationControlWord.reserved2 = 0x0;
    gbeStruct4k.pciInitializationControlWord.pmEnable = 0x1;
    gbeStruct4k.pciInitializationControlWord.auxPwr = 0x1;
    gbeStruct4k.pciInitializationControlWord.reserved3 = 0x0;
    gbeStruct4k.pciInitializationControlWord.reserved4 = 0x1;

    /* Word 0Bh (Subsystem ID) */
    gbeStruct4k.subsystemId = 0x20ee;

    /* Word 0Ch (Subsystem Vendor ID) */
    gbeStruct4k.subsystemVendorId = 0x17aa;

    /* Word 0Dh (Device ID) */
    gbeStruct4k.deviceId = 0x10f5;

    /* Word 0Eh (Vendor ID) */
    gbeStruct4k.vendorId = 0x8086;

    /* Word 0Fh (Device Revision ID) */
    gbeStruct4k.deviceRevId = 0x0000;

    /* Word 10h (LAN Power Consumption) */
    gbeStruct4k.lanPowerConsumption.lanD3Power = 0x01;
    gbeStruct4k.lanPowerConsumption.reserved = 0x0;
    gbeStruct4k.lanPowerConsumption.lanD0Power = 0x0d;

    /* Words 11h and 12h (Reserved) */
    gbeStruct4k.reservedWords11h12h[0] = 0x0000;
    gbeStruct4k.reservedWords11h12h[1] = 0x0000;

    /* Word 13h (Shared Initialization Control Word) */
    gbeStruct4k.sharedInitializationControlWord.reserved1 = 0x5;
    gbeStruct4k.sharedInitializationControlWord.forceDuplex = 0x0;
    gbeStruct4k.sharedInitializationControlWord.forceSpeedEnable = 0x0;
    gbeStruct4k.sharedInitializationControlWord.reserved2_0 = 0x0;
    gbeStruct4k.sharedInitializationControlWord.reserved2_1 = 0x0;
    gbeStruct4k.sharedInitializationControlWord.phyPowerDownEnable = 0x1;
    gbeStruct4k.sharedInitializationControlWord.reserved3 = 0x1;
    gbeStruct4k.sharedInitializationControlWord.reserved4 = 0x0;
    gbeStruct4k.sharedInitializationControlWord.sign = 0x2;

    /* Word 14h (Extended Configuration Control Word 1) */
    gbeStruct4k.extendedConfigurationControlWord1.extendedConfigurationPointer = 0x020;
    gbeStruct4k.extendedConfigurationControlWord1.oemWriteEnable = 0x1;
    gbeStruct4k.extendedConfigurationControlWord1.reserved1 = 0x1;
    gbeStruct4k.extendedConfigurationControlWord1.reserved2 = 0x0;
    gbeStruct4k.extendedConfigurationControlWord1.reserved3 = 0x0;

    /* Word 15h (Extended Configuration Control Word 2) */
    gbeStruct4k.extendedConfigurationControlWord2.reserved = 0x00;
    gbeStruct4k.extendedConfigurationControlWord2.extendedPhyLength = 0x0a;

    /* Word 16h (Extended Configuration Control Word 3) */
    gbeStruct4k.extendedConfigurationControlWord3 = 0x0000;

    /* Word 17h (LED 1 Configuration and Power Management) */
    gbeStruct4k.ledCtl1.led1Mode = 0xb;
    gbeStruct4k.ledCtl1.reserved1 = 0x0;
    gbeStruct4k.ledCtl1.led1BlinkMode = 0x0;
    gbeStruct4k.ledCtl1.led1Invert = 0x0;
    gbeStruct4k.ledCtl1.led1Blink = 0x1;
    gbeStruct4k.ledCtl1.reserved2 = 0x1;
    gbeStruct4k.ledCtl1.lpluEnable = 0x0;
    gbeStruct4k.ledCtl1.lpluEnableNonD0a = 0x1;
    gbeStruct4k.ledCtl1.gbeDisableNonD0a = 0x1;
    gbeStruct4k.ledCtl1.reserved3 = 0x0;
    gbeStruct4k.ledCtl1.gbeDisable = 0x0;
    gbeStruct4k.ledCtl1.reserved4 = 0x1;

    /* Word 18h (LED 0 and 2 Configuration Defaults) */
    gbeStruct4k.ledCtl02.led0Mode = 0x2;
    gbeStruct4k.ledCtl02.reserved1 = 0x0;
    gbeStruct4k.ledCtl02.led0BlinkMode = 0x0;
    gbeStruct4k.ledCtl02.led0Invert = 0x0;
    gbeStruct4k.ledCtl02.led0Blink = 0x0;
    gbeStruct4k.ledCtl02.led2Mode = 0x6;
    gbeStruct4k.ledCtl02.reserved2 = 0x0;
    gbeStruct4k.ledCtl02.led2BlinkMode = 0x0;
    gbeStruct4k.ledCtl02.led2Invert = 0x0;
    gbeStruct4k.ledCtl02.led2Blink = 0x0;

    /* Word 19h (Reserved) */
    gbeStruct4k.reservedWord19h = 0x2b40;

    /* Word 1Ah (Reserved) */
    gbeStruct4k.reservedWord1Ah = 0x0043;

    /* Word 1Bh (Reserved) */
    gbeStruct4k.reservedWord1Bh = 0x0000;

    /* Word 1Ch (Reserved) */
    gbeStruct4k.reservedWord1Ch = 0x10f5;

    /* Word 1Dh (Reserved) */
    gbeStruct4k.reservedWord1Dh = 0xbaad;

    /* Word 1Eh (Device ID for Intel 82567LM gigabit ethernet controller) */
    gbeStruct4k._82567lmDeviceId = 0x10f5;

    /* Word 1Fh (Device ID for Intel 82567LF gigabit ethernet controller) */
    gbeStruct4k._82567lfDeviceId = 0x10bf;

    /* Word 20h (Reserved) */
    gbeStruct4k.reservedWord20h = 0xbaad;

    /* Word 21h (Device ID for Intel 82567V gigabit ethernet controller) */
    gbeStruct4k._82567vDeviceId = 0x10cb;

    /* Word 22h (Reserved) */
    gbeStruct4k.reservedWord22h = 0xbaad;

    /* Word 23h (Reserved) */
    gbeStruct4k.reservedWord23h = 0xbaad;

    /* Words 24h to 2Fh (Reserved) */
    gbeStruct4k.reservedWords24to2Fh[0] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[1] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[2] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[3] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[4] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[5] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[6] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[7] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[8] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[9] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[10] = 0x0000;
    gbeStruct4k.reservedWords24to2Fh[11] = 0x0000;

    /* Words 30h to 3Eh (PXE Software Region) */
    /* Boot Agent Main Setup Options (Word 30h) */
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.protocolSelect = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved1 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.defaultBootSelection = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved2 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.promptTime = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.displaySetupMessage = 0x1;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved3 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceSpeed = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.forceFullDuplex = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.reserved4 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.efiPresence = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentMainSetupOptions.pxePresence = 0x0;
    /* Boot Agent Configuration Customization Options (Word 31h) */
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableSetupMenu = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableTitleMessage = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableProtocolSelect = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableBootSelection = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableLegacyWakeupSupport = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.disableFlashUpdate = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved1 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.ibaBootOrderSetupMode = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.reserved2 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions31h.signature = 0x1;
    /* Boot Agent Configuration Customization Options (Word 32h) */
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.buildNumber = 0x18;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.minorVersionNumber = 0x3;
    gbeStruct4k.pxeSoftwareRegion.bootAgentConfigurationCustomizationOptions32h.majorVersionNumber = 0x1;
    /* IBA Capabilities (Word 33h) */
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.baseCodePresent = 0x1;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.undiCapabilityPresent = 0x1;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved1 = 0x1;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.efiUndiCapabilityPresent = 0x0;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_0 = 0x0;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.reserved2_1 = 0x00;
    gbeStruct4k.pxeSoftwareRegion.ibaCapabilities.signature = 0x1;
    /* Padding (Words 34h to 3Eh) */
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[0] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[1] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[2] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[3] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[4] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[5] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[6] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[7] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[8] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[9] = 0xffff;
    gbeStruct4k.pxeSoftwareRegion.paddingWords34hTo3Eh[10] = 0xffff;

    /* Word 3Fh (Checksum) */
    gbeStruct4k.checkSum = 0x348a;

    /* The rest of Gbe (word 40h or byte 80h onwards) is just padding (0xFF) */
    for (i = 0; i < 3968; i++) {
        gbeStruct4k.padding[i] = 0xFF;
    }

    return gbeStruct4k;
}

struct GBEREGIONRECORD_8K generatedGbeStruct8k()
{
    struct GBEREGIONRECORD_8K gbeStruct8k;
    gbeStruct8k.main = generatedGbeStruct4k();
    memcpy(&gbeStruct8k.backup, &gbeStruct8k.main, GBEREGIONSIZE_4K);
    return gbeStruct8k;
}


code:
/*
 *  Copyright (C) 2014 Francis Rowe <info@gluglug.org.uk>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ICH9GEN_MKGBE_H
#define ICH9GEN_MKGBE_H

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "../gbe/gbe.h"

struct GBEREGIONRECORD_4K generatedGbeStruct4k();
struct GBEREGIONRECORD_8K generatedGbeStruct8k();

#endif


code:
java.lib.path=
main.file=pygl.py
platform.active=Python_2.6.4
python.lib.path=
src.dir=src

repo_name: snapshot/gltoolkit

license: unknown


code:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.python.project</type>
    <configuration>
        <data xmlns="http://nbpython.dev.java.net/ns/php-project/1">
            <name>pygl</name>
            <sources>
                <root id="src.dir"/>
            </sources>
            <tests/>
        </data>
    </configuration>
</project>


code:
"""
This file is part of GlToolkit project https://code.google.com/p/gltoolkit/

Copyright (C) 2009-2010 Synble Ltd.
All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
"""
from optparse import OptionParser
from glapi import *

class CliMain():
    silent = False

    def cprint(self, s):
        if not self.silent:
            print s;

    def error(self, s):
        print "error: %s" % s;

    def cli(self, args, opts):
        glApi = GLApi()

        username = opts.get('username')
        password = opts.get('password')
        silent = opts.get('verbose')

        glApi.setUsername(username)
        glApi.setPassword(password)

        if args[0] == "upload":
            if len(args) < 2:
                self.error("Please specify the file you want to upload.")
                return
            if len(args) < 3:
                self.error("Can't upload to unknown product. It's your GL product name, same as in URL.")
                return
            if len(args) < 4:
                self.error("Language is missing. It should be standard IANA code e.g. en, en-US or fi. If you are uploading master strings, use master.")
                return

            component = "default"

            if len(args) > 4:
                component = args[4]

            glApi.uploadFile(args[1], args[2], args[3], component)

        if args[0] == "get":
            if len(args) < 2:
                self.error("Can't download from unknown product. It's your GL product name, same as in URL.")
                return
            if len(args) < 3:
                self.error("Language is missing. It should be standard IANA code e.g. en, en-US or fi. If you are uploading master strings, use master.")
                return
            component = "default"

            if len(args) > 3:
                component = args[3]
            glApi.getFile(args[1], args[2], component)

        return None


code:
"""
This file is part of GlToolkit project https://code.google.com/p/gltoolkit/

Copyright (C) 2009-2010 Synble Ltd.
All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
"""
import urllib
import urllib2
import base64
import itertools, mimetools, mimetypes

class MultiPartForm(object):
    """Accumulate the data to be used when posting a form."""

    def __init__(self):
        self.formFields = []
        self.files = []
        self.boundary = mimetools.choose_boundary()

    def getContentType(self):
        return 'multipart/form-data; boundary=%s' % self.boundary

    def addField(self, name, value):
        """Add a form field to the form data."""
        self.formFields.append((name, value))

    def addFile(self, fieldname, filename, fileHandle, mimetype=None):
        body = fileHandle.read()
        if mimetype is None:
            mimetype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'

        self.files.append((fieldname, filename, mimetype, body))

    def __str__(self):
        parts = []
        partBoundary = '--' + self.boundary

        # Add the form fields

        parts.extend([ partBoundary,'Content-Disposition: form-data; name="%s"' % name,
        '', value,] for name, value in self.formFields)

        # Add the files to upload
        # Amazon S3 expects file data to be 'Content-Disposition:
        # form-data' instead of "file"

        parts.extend([ partBoundary,'Content-Disposition: form-data; name="%s"; filename="%s"' % \
        (fieldName, filename),'Content-Type: %s' % contentType,'',body,]
        for fieldName, filename, contentType, body in self.files)

        # Flatten the list and add closing boundary marker,
        # then return \r\n separated data
        flattened = list(itertools.chain(*parts))
        flattened.append('--' + self.boundary + '--')
        flattened.append('')
        return '\r\n'.join(flattened)

class GLApi:
    def setUsername(self, username):
        self.username = username

    def setPassword(self, password):
        self.password = password

    def uploadFile(self, file, product, language, component):
        params = urllib.urlencode({'product': product,
                                   'language': language,
                                   'component': component})

        f = open(file)
        form = MultiPartForm()
        form.addFile('file', file, f)

        url = 'http://www.getlocalization.com/ajax/uploadLanguageFile/?%s' % params;

        if language=='master':
            url = 'http://www.getlocalization.com/ajax/commitStrings/?%s' % params;

        req = urllib2.Request(url)
        base64string = base64.encodestring('%s:%s' % (self.username, self.password))[:-1]
        authheader =  "Basic %s" % base64string
        req.add_header("Content-Type", form.getContentType());
        req.add_header("Authorization", authheader)
        req.add_data(str(form))
        urlObj = urllib2.urlopen(req)

        print urlObj.read()
        pass

    def getFile(self, product, language, component):
        params = urllib.urlencode({'product': product,
                                   'language': language,
                                   'component': component})

        url = 'http://www.getlocalization.com/component/export/?%s' % params
        req = urllib2.Request(url)
        base64string = base64.encodestring('%s:%s' % (self.username, self.password))[:-1]
        authheader =  "Basic %s" % base64string
        req.add_header("Authorization", authheader)

        urlObj = urllib2.urlopen(req)
        response = urlObj.read()

        print response


code:
"""
This file is part of GlToolkit project https://code.google.com/p/gltoolkit/

Copyright (C) 2009-2010 Synble Ltd.
All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
"""
import parser
from climain import *
from optparse import OptionParser

if __name__ == "__main__":
    parser = OptionParser()

    parser.add_option("-u", "--username", dest="username",
                      help="GetLocalization.com Username")

    parser.add_option("-p", "--password", dest="password",
                      help="GetLocalization.com Password")

    parser.add_option("-q", "--quiet",
                      action="store_false", dest="verbose", default=True,
                      help="don't print status messages to stdout")

    (options, args) = parser.parse_args()

    main = CliMain()
    main.cli(args, vars(options))


code:
/**
 *  This file is part of GlToolkit project https://code.google.com/p/gltoolkit/
 *
 *  Copyright (C) 2010 Synble Ltd.
 *  All rights reserved.
 *
 *  This library is provided 'as-is', without any express or implied
 *  warranty. In no event will the authors be held liable for any damages
 *  arising from the use of this software.
 *
 *  Permission to use and alter this library requires a valid agreement
 *  with Synble Ltd and GetLocalization.com.
 *
 *  You can use (including commercial applications) and alter this
 *  library freely under the GetLocalization.com terms of service.
 *  Altered parts should be clearly marked as such.
 *
 */

#include <s32file.h>
#include <HttpStringConstants.h>
#include <http\RHTTPTransaction.h>
#include <http\RHTTPSession.h>
#include <http\RHTTPHeaders.h>
#include <commdbconnpref.h>
#include <aknnotewrappers.h>
#include <AknListQueryDialog.h>
#include <aknwaitdialog.h>
#include <avkon.rsg>
#include <utf.h>
#include <eikmenup.h>
#include <aknsettingitemlist.h>
#include <S32MEM.H>
#include "LocEnv.h"
#include "log.h"

#include <GoogaSync_0x20023FCD.rsg>

CLocEnv::CLocEnv() :
	CCoeStatic(KEnvUid, CCoeStatic::EApp)
	{
	// No implementation required
	}

CLocEnv::~CLocEnv()
	{
	iCache.ResetAndDestroy();
	}

EXPORT_C CLocEnv* CLocEnv::Static()
	{
	CLocEnv* self = static_cast<CLocEnv*> (CCoeEnv::Static()->FindStatic(
			KEnvUid));

	if (!self)
		{
		CLocEnv* self = new (ELeave) CLocEnv();
		TRAPD(err, self->ConstructL());
		__ASSERT_ALWAYS(!err,Panic(KEnvPanicInitFailed));
		}

	return self;
	}

void CLocEnv::ConstructL()
	{
	}

void CLocEnv::GetLanguageFile(TDes& aPathAndName)
	{
	_LIT(KFileName, "gl.loc");

	TBuf<255> privatePath;
	if (CEikonEnv::Static()->FsSession().PrivatePath(privatePath) == KErrNone)
		{
		TParse p;

#ifdef __WINSCW__
		TPtrC processName = _L("C:\\");
#else
		TPtrC processName = RProcess().FileName();
#endif

		p.Set(privatePath, &processName, NULL );
		aPathAndName.Copy(p.DriveAndPath());
		aPathAndName.Append(KFileName);
		}
	}

void CLocEnv::InitLanguageL()
	{
	RFs fs = CCoeEnv::Static()->FsSession();
	RFileReadStream locFile;

	TBuf<255> langFile;
	GetLanguageFile(langFile);

	User::LeaveIfError(locFile.Open(fs, langFile, EFileRead));
	CleanupClosePushL(locFile);

	TInt err = KErrNone;
	while (err == KErrNone)
		{
		TRAP(err,
					{
					// Read original string, i.e. the source of translation.
					RBuf8 origString;
					CleanupClosePushL(origString);
					TInt32 origStrLen = locFile.ReadInt32L();
					origString.CreateMax(origStrLen+1);
					locFile.ReadL(origString, origStrLen);

					// Convert utf8 string to unicode so we can calculate
					// hash.
					HBufC* os = CnvUtfConverter::ConvertToUnicodeFromUtf8L(origString);
					CleanupStack::PushL(os);
					TUint32 checkSum = 0;
					checkSum = HashPJW(os->Des());
					CleanupStack::PopAndDestroy(2); // origString, os

					// Read the translation
					TInt32 strLen = locFile.ReadInt32L();
					RBuf8 string;
					CleanupClosePushL(string);
					string.CreateMax(strLen);
					locFile.ReadL(string, strLen);

					// Cache the hash and translation.
					HBufC* ts = CnvUtfConverter::ConvertToUnicodeFromUtf8L(string);
					iCache.Append(new(ELeave)CLocString(checkSum,ts));
					CleanupStack::PopAndDestroy(); // string
					});
		}

	// Sort everything based on checksums so it's faster to find them.
	TLinearOrder<CLocString> order(CLocString::Compare);
	iCache.Sort(order);

	CleanupStack::PopAndDestroy(); // locFile
	}

void CLocEnv::DynInitMenuPaneL(TInt /*aResourceId*/, CEikMenuPane* aMenuPane)
	{
	if (iCache.Count() > 0)
		{
		for (TInt i = 0; i < aMenuPane->NumberOfItemsInPane(); i++)
			{
			CEikMenuPaneItem::SData& item = aMenuPane->ItemDataByIndexL(i);
			aMenuPane->SetItemTextL(item.iCommandId, LS(item.iText));
			}
		}
	}

void CLocEnv::ConstructSettingItemListL(CAknSettingItemList* aList, TInt aResId)
	{
	TResourceReader reader;
	CCoeEnv::Static()->CreateResourceReaderLC(reader, aResId);

	CBufFlat* resData = CBufFlat::NewL(1024);
	CleanupStack::PushL(resData);

	RBufWriteStream ws(*resData);
	CleanupClosePushL(ws);

	TInt16 flags = reader.ReadInt16();
	ws.WriteInt16L(flags);

	TPtrC settingListTitle = LS(reader.ReadTPtrC());
	ws.WriteInt8L(settingListTitle.Length());
	ws.WriteInt8L(0xAB);
	ws.WriteL(settingListTitle);

	TInt16 initialOrdinal = reader.ReadInt16();
	ws.WriteInt16L(initialOrdinal);

	TInt16 numberOfItems = reader.ReadInt16();
	ws.WriteInt16L(numberOfItems);
	TInt id;

	for (TInt ii = 0; ii < numberOfItems; ++ii)
		{
		id = reader.ReadInt16();
		ws.WriteInt16L(id);

		TPtrC settingName = LS(reader.ReadTPtrC());
		ws.WriteInt8L(settingName.Length());
		if (settingName != KNullDesC)
			{
			ws.WriteInt8L(0xAB);
			ws.WriteL(settingName);
			}

		TInt settingPageResourceId = reader.ReadInt32();
		ws.WriteInt32L(settingPageResourceId);

		TInt editorControlType = reader.ReadInt16();
		ws.WriteInt16L(editorControlType);

		TInt settingEditorResourceId = reader.ReadInt32();
		ws.WriteInt32L(settingEditorResourceId);

		TInt associatedResourceId = reader.ReadInt32();
		ws.WriteInt32L(associatedResourceId);

		TPtrC emptyText = LS(reader.ReadTPtrC());
		ws.WriteInt8L(emptyText.Length());
		if (emptyText != KNullDesC)
			{
			ws.WriteInt8L(0xAB);
			ws.WriteL(emptyText);
			}

		TPtrC compulsoryText = LS(reader.ReadTPtrC());
		ws.WriteInt8L(compulsoryText.Length());
		if (compulsoryText != KNullDesC)
			{
			ws.WriteInt8L(0xAB);
			ws.WriteL(compulsoryText);
			}

		TInt reserved = reader.ReadInt32();
		ws.WriteInt32L(reserved);
		}

	HBufC8* buff = resData->Ptr(0).AllocLC();
	TResourceReader reader2;
	reader2.SetBuffer(buff);
	aList->ConstructFromResourceL(reader2);
	CleanupStack::PopAndDestroy(3); // resData, wc, buff
	}

void CLocEnv::TranslateEnumeratedTextPopupSettingItem(
		CAknEnumeratedTextPopupSettingItem* item)
	{
	CArrayPtr<CAknEnumeratedText>* enumTexts = item->EnumeratedTextArray();

	for (TInt i = 0; i < enumTexts->Count(); i++)
		{
		CAknEnumeratedText* text = (*enumTexts)[i];
		HBufC* orig = text->Value();
		HBufC* ls = LS(*orig).AllocL();
		delete orig;
		text->SetValue(ls);
		}
	item->LoadL();
	item->UpdateListBoxTextL();
	}

TUint32 CLocEnv::HashPJW(const TDesC& aString)
	{
	/* Peter Weinberger's */
	TUint32 h = 0, g = 0;

	for (TInt i = 0; i < aString.Length(); i++)
		{
		h = (h << 4) + aString[i];
		if ((g = h & 0xF0000000))
			{
			h ^= g >> 24;
			h ^= g;
			}
		}

	return h;
	}

TPtrC CLocEnv::GetString(const TDesC& aString)
	{
	// Calculate checksum for the string.
	TUint32 checkSum = 0;
	checkSum = HashPJW(aString);

	// Look the translation for this string from our cache.
	TInt index =
			iCache.FindInOrder<TUint32> (checkSum, CLocString::FastCompare);

	if (index >= 0)
		return iCache[index]->iData->Des();
	else
		return aString;
	}

TBool CLocString::IsEqual(const CLocString& aLeft, const CLocString& aRight)
	{
	return aLeft.iCheckSum == aRight.iCheckSum;
	}

TInt CLocString::Compare(const CLocString& aLeft, const CLocString& aRight)
	{
	return aLeft.iCheckSum - aRight.iCheckSum;
	}

TInt CLocString::FastCompare(const TUint32* aCheckSum, const CLocString& aItem)
	{
	return (*aCheckSum) - aItem.iCheckSum;
	}

/*****************************************************************************
 * CGLClientUI
 *
 * Simple dialog based UI to select & download selected language.
 *****************************************************************************/
CGLClientUI* CGLClientUI::NewL()
	{
	DBG;
	CGLClientUI* self = new (ELeave) CGLClientUI();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CGLClientUI::CGLClientUI()
	{
	}

void CGLClientUI::ConstructL()
	{
	DBG;
	iClient = CGLClient::NewL(*this);
	}

CGLClientUI::~CGLClientUI()
	{
	delete iClient;
	}

void CGLClientUI::ChangeLanguageL()
	{
	DBG;
	iClient->StartConnectionL();
	iWaitDialog = new (ELeave) CAknWaitDialog(
			(REINTERPRET_CAST(CEikDialog**,&iWaitDialog)), ETrue);
	iWaitDialog->SetCallback(this);

	iWaitDialog->ExecuteLD(R_WAIT_NOTE);
	iWaitDialog->SetTextL(_LL("Connecting..."));
	}

void CGLClientUI::GLClientEvent(TInt aEventType)
	{
	DBG;
	if (aEventType == EGLConnectionUp)
		{
		iClient->GetLanguagesL();
		}
	else if (aEventType == EGLGetLanguagesCompleted)
		{
		if (iWaitDialog)
			{
			iWaitDialog->ProcessFinishedL();
			iWaitDialog = NULL;
			}

		TInt selectedLang;
		CAknListQueryDialog* dialog = new (ELeave) CAknListQueryDialog(
				&selectedLang);

		CDesCArray* languages = new (ELeave) CDesCArrayFlat(1);
		CleanupStack::PushL(languages);
		CDesC8Array* languageCodes = new (ELeave) CDesC8ArrayFlat(1);
		CleanupStack::PushL(languageCodes);

		languages->AppendL(_LL("Original language"));
		languageCodes->AppendL(_L8("None"));

		ParseLanguageList(iClient->BufferPtrL(), *languages, *languageCodes);

		dialog->PrepareLC(R_LANGUAGE_QUERY);
		dialog->SetItemTextArray(languages);
		dialog->SetOwnershipType(ELbmDoesNotOwnItemArray);
		dialog->SetHeaderTextL(_LL("Select language"));

		if (dialog->RunLD() == EAknSoftkeyOk)
			{
			if (selectedLang == 0)
				{
				RFs fs = CCoeEnv::Static()->FsSession();
				TBuf<255> langFile;
				CLocEnv::Static()->GetLanguageFile(langFile);
				fs.Delete(langFile); // Delete existing translation, omit the error.

				CAknInformationNote* note = new (ELeave) CAknInformationNote(
						ETrue);
				note->ExecuteLD(
						_LL("Language was successfully installed. Application needs to be restarted."));
				}
			else
				{
				iClient->GetTranslationL((*languageCodes)[selectedLang]);
				iWaitDialog = new (ELeave) CAknWaitDialog(
						(REINTERPRET_CAST(CEikDialog**,&iWaitDialog)), ETrue);
				iWaitDialog->SetCallback(this);
				iWaitDialog->ExecuteLD(R_WAIT_NOTE);
				iWaitDialog->SetTextL(_LL("Downloading..."));
				}
			}

		CleanupStack::PopAndDestroy(); // languages
		}
	if (aEventType == EGLGetTranslationCompleted)
		{
		if (iWaitDialog)
			{
			iWaitDialog->ProcessFinishedL();
			iWaitDialog = NULL;
			}
		RFs fs = CCoeEnv::Static()->FsSession();
		RFileWriteStream locFile;

		TBuf<255> langFile;
		CLocEnv::Static()->GetLanguageFile(langFile);
		TInt err = fs.Delete(langFile); // Delete existing translation, omit the error.

		if (locFile.Create(fs, langFile, EFileWrite) == KErrNone)
			{
			CleanupClosePushL(locFile);
			locFile.WriteL(iClient->BufferPtrL()->Des());
			locFile.CommitL();

			CAknInformationNote* note = new (ELeave) CAknInformationNote(ETrue);
			note->ExecuteLD(_LL("Language was successfully installed. Application needs to be restarted."));
			CleanupStack::PopAndDestroy();
			}
		else
			{
			CAknInformationNote* note = new (ELeave) CAknInformationNote(ETrue);
			note->ExecuteLD(_LL("Language installation failed."));
			}
		}
	if (aEventType == EGLServerError)
		{
		if (iWaitDialog)
			{
			iWaitDialog->ProcessFinishedL();
			iWaitDialog = NULL;
			}

		#ifdef _DEBUG
		RFs fs = CCoeEnv::Static()->FsSession();
		RFileWriteStream locFile;
		_LIT(KFileName, "error.html");
		locFile.Create(fs, KFileName, EFileWrite);
		CleanupClosePushL(locFile);
		locFile.WriteL(iClient->BufferPtrL()->Des());
		locFile.CommitL();
		CleanupStack::PopAndDestroy();
		#endif

		}
	}

void CGLClientUI::DialogDismissedL(TInt aButtonId)
	{
	DBG;
	LOG_INT(aButtonId);
	if (aButtonId == -1)
		{
		iClient->CancelGet();
		}
	}
void CGLClientUI::ParseLanguageList(HBufC8* aData, CDesCArray& aLanguages,
		CDesC8Array& aLanguageCodes)
	{
	TPtrC8 data = aData->Des();
	TInt si = 0;

	for (TInt i = 0; i < data.Length(); i++)
		{
		switch (data[i])
			{
			case '\t':
				{
				HBufC* lang = CnvUtfConverter::ConvertToUnicodeFromUtf8L(
						data.Mid(si, i - si));
				CleanupStack::PushL(lang);
				aLanguages.AppendL(lang->Des());
				CleanupStack::PopAndDestroy(); //lang
				si = i + 1;
				break;
				}
			case '\r':
				{
				TPtrC8 languageCode = data.Mid(si, i - si);
				aLanguageCodes.AppendL(languageCode);
				break;
				}
			case '\n':
				{
				si = i + 1;
				break;
				}
			}
		}
	}

/*****************************************************************************
 * CGLClient
 *
 * Downloads languages & localization strings from Get Localization servers.
 *
 *****************************************************************************/
CGLClient* CGLClient::NewL(MGLClientObserver& aObserver)
	{
	DBG;
	CGLClient* self = new (ELeave) CGLClient(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CGLClient::CGLClient(MGLClientObserver& aObserver) :
	CActive(EPriorityStandard), iObserver(aObserver), iIapID(KErrNotFound)
	{
	}

void CGLClient::ConstructL()
	{
	DBG;
	CActiveScheduler::Add(this);
	User::LeaveIfError(iSocketServ.Connect());
	User::LeaveIfError(iConnection.Open(iSocketServ));
	iSession.OpenL();
	RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();
	RStringPool stringPool = iSession.StringPool();
	connInfo.SetPropertyL(stringPool.StringF(HTTP::EHttpSocketServ,
			RHTTPSession::GetTable()), THTTPHdrVal(iSocketServ.Handle()));
	connInfo.SetPropertyL(stringPool.StringF(HTTP::EHttpSocketConnection,
			RHTTPSession::GetTable()), THTTPHdrVal(
			reinterpret_cast<TInt> (&iConnection)));
	}

CGLClient::~CGLClient()
	{
	DBG;
	iSession.Close();
	iConnection.Close();
	iSocketServ.Close();
	delete iBuffer;
	}

/**
 *	Set access point. KErrNotFound means that it is asked from the user.
 */
void CGLClient::SetAccessPoint(TInt aIapID)
	{
	DBG;
	iIapID = aIapID;
	}

/**
 *	Start connection.
 */
void CGLClient::StartConnectionL()
	{
	DBG;
	iCancelled = EFalse;
	if (!iConnUp)
		{
		if (iIapID != KErrNotFound)
			{
			TCommDbConnPref pref;
			pref.SetIapId(iIapID);
			pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
			iConnection.Start(pref, iStatus);
			SetActive();
			}
		else
			{
			iConnection.Start(iStatus);
			SetActive();
			}
		}
	else
		{
		iObserver.GLClientEvent(EGLConnectionUp);
		}
	}

void CGLClient::GetL(const TDesC8& aUrl)
	{
	DBG;
	if (!iConnUp)
		{
		User::LeaveIfError(iConnection.Start());
		iConnUp = ETrue;
		}

	if (iBuffer)
		{
		delete iBuffer;
		iBuffer = NULL;
		}

	iBuffer = HBufC8::NewL(1);
	RStringF method = iSession.StringPool().StringF(HTTP::EGET,
			RHTTPSession::GetTable());
	TUriParser8 parser;
	parser.Parse(aUrl);
	iTransaction = iSession.OpenTransactionL(parser, *this, method);

	RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();
	SetHeaderL(hdr, HTTP::EUserAgent, KUserAgent);

	iTransaction.SubmitL();
	iActiveTransaction = ETrue;
	}

/**
 *	Start a download.
 */
void CGLClient::GetLanguagesL()
	{
	DBG;
	GetL(
			_L8("http://www.getlocalization.com/api/languages/?type=text&product=GoogaSync"));
	iObserver.GLClientEvent(EGLConnecting);
	iState = EGLGetLanguages;
	}

/**
 *	Start a download.
 */
void CGLClient::GetTranslationL(const TDesC8& aLanguageCode)
	{
	DBG;
	_LIT8(KUrl, "http://www.getlocalization.com/api/translations/?type=bin&product=GoogaSync&iana=%S");
	RBuf8 url;
	url.Create(KUrl().Length() + aLanguageCode.Length());
	url.AppendFormat(KUrl, &aLanguageCode);
	CleanupClosePushL(url);
	GetL(url);
	CleanupStack::PopAndDestroy(); // url

	iObserver.GLClientEvent(EGLGetTranslation);
	iState = EGLGetTranslation;
	}

HBufC8* CGLClient::BufferPtrL()
	{
	DBG;
	return iBuffer;
	}

void CGLClient::CancelGet()
	{
	iCancelled = ETrue;
	if (iActiveTransaction)
		{
		iTransaction.Cancel();
		iTransaction.Close();
		}
	}

void CGLClient::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField,
		const TDesC8& aHdrValue)
	{
	DBG;
	RStringF valStr = iSession.StringPool().OpenFStringL(aHdrValue);
	CleanupClosePushL(valStr);
	THTTPHdrVal val(valStr);
	aHeaders.SetFieldL(iSession.StringPool().StringF(aHdrField,
			RHTTPSession::GetTable()), val);
	CleanupStack::PopAndDestroy();
	}

void CGLClient::SetHeaderL(RHTTPHeaders aHeaders, const TDesC8& aKey,
		const TDesC8& aHdrValue)
	{
	DBG;
	RStringF keyStr = iSession.StringPool().OpenFStringL(aKey);
	CleanupClosePushL(keyStr);

	RStringF valStr = iSession.StringPool().OpenFStringL(aHdrValue);
	CleanupClosePushL(valStr);

	THTTPHdrVal val(valStr);
	aHeaders.SetFieldL(keyStr, val);

	CleanupStack::PopAndDestroy(2);
	}

void CGLClient::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
	{
	DBG;
	switch (aEvent.iStatus)
		{
		case THTTPEvent::EGotResponseHeaders:
			{
			//RHTTPResponse resp = aTransaction.Response();
			//TInt status = resp.StatusCode();
			break;
			}
		case THTTPEvent::EGotResponseBodyData:
			{
			MHTTPDataSupplier* body = aTransaction.Response().Body();

			TPtrC8 dataChunk;
			body->GetNextDataPart(dataChunk);

			iBuffer = iBuffer->ReAlloc(iBuffer->Size() + dataChunk.Length());

			if (iBuffer)
				{
				iBuffer->Des().Append(dataChunk);
				}
			else
				{
				iObserver.GLClientEvent(KErrNoMemory);
				aTransaction.Close();
				}

			body->ReleaseData();

			break;
			}
		case THTTPEvent::EResponseComplete:
			{
			break;
			}

		case THTTPEvent::ESucceeded:
			{
			if (iState == EGLGetLanguages)
				{
				iObserver.GLClientEvent(EGLGetLanguagesCompleted);
				}
			else if (iState == EGLGetTranslation)
				{
				iObserver.GLClientEvent(EGLGetTranslationCompleted);
				}

			aTransaction.Close();
			iActiveTransaction = EFalse;
			}
			break;

		case THTTPEvent::EFailed:
			{
			iObserver.GLClientEvent(EGLServerError);
			aTransaction.Close();
			iActiveTransaction = EFalse;
			}
			break;

		default:
			{
			iObserver.GLClientEvent(aEvent.iStatus);
			aTransaction.Close();
			iActiveTransaction = EFalse;
			iObserver.GLClientEvent(aEvent.iStatus);
			break;
			}
		}
	}

TInt CGLClient::MHFRunError(TInt /*aError*/, RHTTPTransaction /*aTransaction*/,
		const THTTPEvent& /*aEvent*/)
	{
	DBG;
	return 0;
	}

void CGLClient::RunL()
	{
	DBG;
	if (iCancelled)
		{
		iConnUp = EFalse;
		}
	else if (iStatus.Int() == KErrNone || iStatus.Int() == KErrAlreadyExists)
		{
		iConnUp = ETrue;
		iObserver.GLClientEvent(EGLConnectionUp);
		}
	else
		{
		iObserver.GLClientEvent(EGLConnectionError);
		}
	}

void CGLClient::DoCancel()
	{
	DBG;
	CancelGet();
	}