ich9deblob: move x86 compatibility checks to a separate file

5 files changed, 171 insertions, 158 deletions

diff --git a/resources/utilities/ich9deblob/Makefile b/resources/utilities/ich9deblob/Makefile
index 5ef9587..656e2a1 100644
--- a/resources/utilities/ich9deblob/Makefile
+++ b/resources/utilities/ich9deblob/Makefile
@@ -20,8 +20,8 @@
 CC=gcc
 CFLAGS=-I.
 
-ich9deblob: ich9deblob.c ich9desc.c ich9gbe.c
-	$(CC) $(CFLAGS) ich9deblob.c ich9desc.c ich9gbe.c -o ich9deblob
+ich9deblob: ich9deblob.c ich9desc.h ich9gbe.h
+	$(CC) $(CFLAGS) ich9deblob.c ich9desc.h ich9gbe.h -o ich9deblob
 	
 clean:
 	rm -f ich9deblob *.o
diff --git a/resources/utilities/ich9deblob/ich9deblob.c b/resources/utilities/ich9deblob/ich9deblob.c
index 3630766..66b9c9b 100644
--- a/resources/utilities/ich9deblob/ich9deblob.c
+++ b/resources/utilities/ich9deblob/ich9deblob.c
@@ -1,5 +1,5 @@
 /*
- *  main.c
+ *  ich9deblob.c
  *  This file is part of the ich9deblob utility from the libreboot project
  * 
  * Purpose: disable and remove the ME from ich9m/gm45 machines in coreboot.
@@ -42,30 +42,15 @@
 
 #include <stdio.h>
 #include <string.h>
-#include "ich9desc.c" // structs describing what's in the descriptor region
-#include "ich9gbe.c" // structs describing what's in the gbe region
-
-#define DESCRIPTORREGIONSIZE 0x1000 // 4 KiB
-#define GBEREGIONSIZE 0x2000 // 8 KiB
-// 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?
-
-// Related to the flash descriptor
-#define FLREGIONBITSHIFT 0xC // bits 12(0xC)-24(0x18) are represented for words found in the flash descriptor
-												 // To manipulate these easily in C, we shift them by FLREGIONBITSHIFT and then shift them back when done
+#include "ich9desc.h" // structs describing what's in the descriptor region
+#include "ich9gbe.h" // structs describing what's in the gbe region
+#include "x86compatibility.c" // compatibility checks. this utility is not portable yet.
 
 unsigned short gbeGetChecksumFrom4kStruct(struct GBEREGIONRECORD_4K gbeStruct4k, unsigned short desiredValue);
 unsigned short gbeGetChecksumFrom8kBuffer(char* buffer, unsigned short desiredValue, char isBackup); // for GBe region (checksum calculation)
 unsigned short gbeGetRegionWordFrom8kBuffer(int i, char* buffer); // used for getting each word needed to calculate said checksum
 struct DESCRIPTORREGIONRECORD deblobbedDescriptorStructFromFactory(struct DESCRIPTORREGIONRECORD factoryDescriptorStruct, unsigned int factoryRomSize);
-int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy);
-int systemIsBigEndian();
-int structBitfieldWrongOrder();
-int structMembersWrongOrder();
 struct GBEREGIONRECORD_8K deblobbedGbeStructFromFactory(struct GBEREGIONRECORD_8K factoryGbeStruct8k);
-int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k);
 
 int main(int argc, char *argv[])
 {
@@ -371,138 +356,3 @@ unsigned short gbeGetRegionWordFrom8kBuffer(int index, char* regionData)
 	return *((unsigned short*)(regionData + (index * 2)));
 }
 
-// ---------------------------------------------------------------------
-// x86 compatibility checking:
-// ---------------------------------------------------------------------
-
-// Basically, this should only return true on non-x86 machines
-int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy) {
-	unsigned int descriptorRegionStructSize = sizeof(descriptorDummy);
-	unsigned int gbeRegion8kStructSize = sizeof(gbe8kDummy);
-	// check compiler bit-packs in a compatible way. basically, it is expected that this code will be used on x86
-	if (DESCRIPTORREGIONSIZE != descriptorRegionStructSize){
-		printf("\nerror: compiler incompatibility: descriptor struct length is %i bytes (should be %i)\n", descriptorRegionStructSize, DESCRIPTORREGIONSIZE);
-		return 1;
-	}
-	if (GBEREGIONSIZE != gbeRegion8kStructSize){
-		printf("\nerror: compiler incompatibility: gbe struct length is %i bytes (should be %i)\n", gbeRegion8kStructSize, GBEREGIONSIZE);
-		return 1;
-	}
-	return 0;
-}
-
-int systemIsBigEndian() {
-	// endianness check. big endian forced to fail
-	unsigned short steak = 0xBEEF;
-	unsigned char *grill = (unsigned char*)&steak;
-	if (*grill==0xBE) {
-		printf("\nunsigned short 0xBEEF: first byte should be EF, but it's BE. Your system is big endian, and unsupported (only little endian is tested)\n");
-		return 1;
-	}
-	return 0;
-}
-
-// fail if members are presented in the wrong order
-int structMembersWrongOrder()
-{
-	int i;
-	struct DESCRIPTORREGIONRECORD descriptorDummy;
-	unsigned char *meVsccTablePtr = (unsigned char*)&descriptorDummy.meVsccTable;
-	
-	// These do not use bitfields. 
-	descriptorDummy.meVsccTable.jid0 = 0x01020304;  // unsigned int 32-bit
-	descriptorDummy.meVsccTable.vscc0 = 0x10203040; // unsigned int 32-bit
-	descriptorDummy.meVsccTable.jid1 = 0x11223344;  // unsigned int 32-bit
-	descriptorDummy.meVsccTable.vscc1 = 0x05060708; // unsigned int 32-bit
-	descriptorDummy.meVsccTable.jid2 = 0x50607080;  // unsigned int 32-bit
-	descriptorDummy.meVsccTable.vscc2 = 0x55667788; // unsigned int 32-bit
-	descriptorDummy.meVsccTable.padding[0] = 0xAA;  // unsigned char 8-bit
-	descriptorDummy.meVsccTable.padding[1] = 0xBB;  // unsigned char 8-bit
-	descriptorDummy.meVsccTable.padding[2] = 0xCC;  // unsigned char 8-bit
-	descriptorDummy.meVsccTable.padding[3] = 0xDD;  // unsigned char 8-bit
-	
-	// Look from the top down, and concatenate the unsigned ints but
-	// with each unsigned in little endian order. 
-	// Then, concatenate the unsigned chars in big endian order. (in the padding array)
-	
-	// combined, these should become:
-	// 01020304 10203040 11223344 05060708 50607080 55667788 AA BB CC DD (ignore this. big endian. just working it out manually:)
-	// 04030201 40302010 44332211 08070605 80706050 88776655 AA BB CC DD (ignore this. not byte-separated, just working it out:)
-	// 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 AA BB CC DD <-- it should match this
-	
-	printf("\nStruct member order check (descriptorDummy.meVsccTable) with junk/dummy data:");
-	printf("\nShould be: 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 aa bb cc dd ");
-	printf("\nAnd it is: ");
-	
-	for (i = 0; i < 28; i++) {
-		printf("%02x ", *(meVsccTablePtr + i));	
-	}
-	printf("\n");
-	
-	if (
-			!
-			(
-				*meVsccTablePtr      == 0x04 && *(meVsccTablePtr+1)  == 0x03 && *(meVsccTablePtr+2)  == 0x02 && *(meVsccTablePtr+3)  == 0x01
-			&& *(meVsccTablePtr+4)  == 0x40 && *(meVsccTablePtr+5)  == 0x30 && *(meVsccTablePtr+6)  == 0x20 && *(meVsccTablePtr+7)  == 0x10
-			&& *(meVsccTablePtr+8)  == 0x44 && *(meVsccTablePtr+9)  == 0x33 && *(meVsccTablePtr+10) == 0x22 && *(meVsccTablePtr+11) == 0x11
-			&& *(meVsccTablePtr+12) == 0x08 && *(meVsccTablePtr+13) == 0x07 && *(meVsccTablePtr+14) == 0x06 && *(meVsccTablePtr+15) == 0x05
-			&& *(meVsccTablePtr+16) == 0x80 && *(meVsccTablePtr+17) == 0x70 && *(meVsccTablePtr+18) == 0x60 && *(meVsccTablePtr+19) == 0x50
-			&& *(meVsccTablePtr+20) == 0x88 && *(meVsccTablePtr+21) == 0x77 && *(meVsccTablePtr+22) == 0x66 && *(meVsccTablePtr+23) == 0x55
-			&& *(meVsccTablePtr+24) == 0xAA && *(meVsccTablePtr+25) == 0xBB && *(meVsccTablePtr+26) == 0xCC && *(meVsccTablePtr+27) == 0xDD
-	      )
-	   ) {
-		printf("Incorrect order.\n");
-		return 1;
-	}
-	printf("Correct order.\n");
-	return 0;
-}
-
-// fail if bit fields are presented in the wrong order
-int structBitfieldWrongOrder() 
-{
-	int i;
-	struct DESCRIPTORREGIONRECORD descriptorDummy;
-	unsigned char *flMap0Ptr = (unsigned char*)&descriptorDummy.flMaps.flMap0;
-	
-	descriptorDummy.flMaps.flMap0.FCBA = 0xA2;      // :8 --> 10100010
-	descriptorDummy.flMaps.flMap0.NC = 0x02;        // :2 --> 10
-	descriptorDummy.flMaps.flMap0.reserved1 = 0x38; // :6 --> 111000
-	descriptorDummy.flMaps.flMap0.FRBA = 0xD2;      // :8 --> 11010010
-	descriptorDummy.flMaps.flMap0.NR = 0x05;        // :3 --> 101
-	descriptorDummy.flMaps.flMap0.reserved2 = 0x1C; // :5 --> 11100
-	
-	// Look from the top bottom up, and concatenate the binary strings.
-	// Then, convert the 8-bit groups to hex and reverse the (8-bit)byte order
-	
-	// combined, these should become (in memory), in binary:
-	// 10100010 11100010 11010010 11100101
-	// or in hex:
-	// A2 E2 D2 E5
-	
-	printf("\nBitfield order check (descriptorDummy.flMaps.flMaps0) with junk/dummy data:");
-	printf("\nShould be: a2 e2 d2 e5 ");
-	printf("\nAnd it is: ");
-
-	for (i = 0; i < 4; i++) {
-		printf("%02x ", *(flMap0Ptr + i));	
-	}
-	printf("\n");
-	
-	if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) {
-		printf("Incorrect order.\n");
-		return 1;
-	}
-	printf("Correct order.\n");
-	return 0;
-}
-
-// Compatibility checks. This version of ich9deblob is not yet porable.
-int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) 
-{
-	if (structSizesIncorrect(descriptorStruct, gbeStruct8k)) return 1;
-	if (systemIsBigEndian()) return 1;
-	if (structBitfieldWrongOrder()) return 1;
-	if (structMembersWrongOrder()) return 1; 
-	return 0;
-}
diff --git a/resources/utilities/ich9deblob/ich9desc.c b/resources/utilities/ich9deblob/ich9desc.h
index 893b0fd..7463e5c 100644
--- a/resources/utilities/ich9deblob/ich9desc.c
+++ b/resources/utilities/ich9deblob/ich9desc.h
@@ -1,5 +1,5 @@
 /*
- *  ich9desc.c
+ *  ich9desc.h
  *  This file is part of the ich9deblob utility from the libreboot project
  *
  *  Copyright (C) 2014 Steve Shenton <sgsit@libreboot.org>
@@ -26,6 +26,15 @@
 // bit fields used, corresponding to datasheet. See links to datasheets
 // and documentation in ich9deblob.c
 
+#ifndef ICH9DESC_H
+#define ICH9DESC_H
+
+#define DESCRIPTORREGIONSIZE 0x1000 // 4 KiB
+
+// Related to the flash descriptor
+#define FLREGIONBITSHIFT 0xC // bits 12(0xC)-24(0x18) are represented for words found in the flash descriptor
+												 // To manipulate these easily in C, we shift them by FLREGIONBITSHIFT and then shift them back when done
+
 struct FLVALSIG{
 	unsigned int signature;
 };
@@ -215,3 +224,5 @@ struct DESCRIPTORREGIONRECORD {
 	struct DESCRIPTORMAP2RECORD descriptor2Map;
 	struct OEMSECTIONRECORD oemSection;
 };
+
+#endif
diff --git a/resources/utilities/ich9deblob/ich9gbe.c b/resources/utilities/ich9deblob/ich9gbe.h
index 1740dbd..26b125b 100644
--- a/resources/utilities/ich9deblob/ich9gbe.c
+++ b/resources/utilities/ich9deblob/ich9gbe.h
@@ -1,5 +1,5 @@
 /*
- *  ich9gbe.c
+ *  ich9gbe.h
  *  This file is part of the ich9deblob utility from the libreboot project
  *
  *  Copyright (C) 2014 Francis Rowe <info@gluglug.org.uk>
@@ -25,6 +25,15 @@
 // bit fields used, corresponding to datasheet. See links to datasheets
 // and documentation in ich9deblob.c
 
+#ifndef ICH9GBE_H
+#define ICH9GBE_H
+
+#define GBEREGIONSIZE 0x2000 // 8 KiB
+// 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?
+
 struct GBEREGIONRECORD_4K {
 	unsigned char macAddress[6]; // 0x03 words, or 0x06 bytes
 	unsigned char otherStuff[120];  // 0x3c words, or 0x7E bytes
@@ -41,3 +50,5 @@ struct GBEREGIONRECORD_8K {
 	// and other errors. You should do what you need on this one (if modifying
 	// lenovobios's gbe region) and then copy to main
 };
+
+#endif
diff --git a/resources/utilities/ich9deblob/x86compatibility.c b/resources/utilities/ich9deblob/x86compatibility.c
new file mode 100644
index 0000000..80aa062
--- /dev/null
+++ b/resources/utilities/ich9deblob/x86compatibility.c
@@ -0,0 +1,141 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "ich9desc.h" // structs describing what's in the descriptor region
+#include "ich9gbe.h" // structs describing what's in the gbe region
+
+// ---------------------------------------------------------------------
+// x86 compatibility checking:
+// ---------------------------------------------------------------------
+
+// Basically, this should only return true on non-x86 machines
+int structSizesIncorrect(struct DESCRIPTORREGIONRECORD descriptorDummy, struct GBEREGIONRECORD_8K gbe8kDummy) {
+	unsigned int descriptorRegionStructSize = sizeof(descriptorDummy);
+	unsigned int gbeRegion8kStructSize = sizeof(gbe8kDummy);
+	// check compiler bit-packs in a compatible way. basically, it is expected that this code will be used on x86
+	if (DESCRIPTORREGIONSIZE != descriptorRegionStructSize){
+		printf("\nerror: compiler incompatibility: descriptor struct length is %i bytes (should be %i)\n", descriptorRegionStructSize, DESCRIPTORREGIONSIZE);
+		return 1;
+	}
+	if (GBEREGIONSIZE != gbeRegion8kStructSize){
+		printf("\nerror: compiler incompatibility: gbe struct length is %i bytes (should be %i)\n", gbeRegion8kStructSize, GBEREGIONSIZE);
+		return 1;
+	}
+	return 0;
+}
+
+int systemIsBigEndian() {
+	// endianness check. big endian forced to fail
+	unsigned short steak = 0xBEEF;
+	unsigned char *grill = (unsigned char*)&steak;
+	if (*grill==0xBE) {
+		printf("\nunsigned short 0xBEEF: first byte should be EF, but it's BE. Your system is big endian, and unsupported (only little endian is tested)\n");
+		return 1;
+	}
+	return 0;
+}
+
+// fail if members are presented in the wrong order
+int structMembersWrongOrder()
+{
+	int i;
+	struct DESCRIPTORREGIONRECORD descriptorDummy;
+	unsigned char *meVsccTablePtr = (unsigned char*)&descriptorDummy.meVsccTable;
+	
+	// These do not use bitfields. 
+	descriptorDummy.meVsccTable.jid0 = 0x01020304;  // unsigned int 32-bit
+	descriptorDummy.meVsccTable.vscc0 = 0x10203040; // unsigned int 32-bit
+	descriptorDummy.meVsccTable.jid1 = 0x11223344;  // unsigned int 32-bit
+	descriptorDummy.meVsccTable.vscc1 = 0x05060708; // unsigned int 32-bit
+	descriptorDummy.meVsccTable.jid2 = 0x50607080;  // unsigned int 32-bit
+	descriptorDummy.meVsccTable.vscc2 = 0x55667788; // unsigned int 32-bit
+	descriptorDummy.meVsccTable.padding[0] = 0xAA;  // unsigned char 8-bit
+	descriptorDummy.meVsccTable.padding[1] = 0xBB;  // unsigned char 8-bit
+	descriptorDummy.meVsccTable.padding[2] = 0xCC;  // unsigned char 8-bit
+	descriptorDummy.meVsccTable.padding[3] = 0xDD;  // unsigned char 8-bit
+	
+	// Look from the top down, and concatenate the unsigned ints but
+	// with each unsigned in little endian order. 
+	// Then, concatenate the unsigned chars in big endian order. (in the padding array)
+	
+	// combined, these should become:
+	// 01020304 10203040 11223344 05060708 50607080 55667788 AA BB CC DD (ignore this. big endian. just working it out manually:)
+	// 04030201 40302010 44332211 08070605 80706050 88776655 AA BB CC DD (ignore this. not byte-separated, just working it out:)
+	// 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 AA BB CC DD <-- it should match this
+	
+	printf("\nStruct member order check (descriptorDummy.meVsccTable) with junk/dummy data:");
+	printf("\nShould be: 04 03 02 01 40 30 20 10 44 33 22 11 08 07 06 05 80 70 60 50 88 77 66 55 aa bb cc dd ");
+	printf("\nAnd it is: ");
+	
+	for (i = 0; i < 28; i++) {
+		printf("%02x ", *(meVsccTablePtr + i));	
+	}
+	printf("\n");
+	
+	if (
+			!
+			(
+				*meVsccTablePtr      == 0x04 && *(meVsccTablePtr+1)  == 0x03 && *(meVsccTablePtr+2)  == 0x02 && *(meVsccTablePtr+3)  == 0x01
+			&& *(meVsccTablePtr+4)  == 0x40 && *(meVsccTablePtr+5)  == 0x30 && *(meVsccTablePtr+6)  == 0x20 && *(meVsccTablePtr+7)  == 0x10
+			&& *(meVsccTablePtr+8)  == 0x44 && *(meVsccTablePtr+9)  == 0x33 && *(meVsccTablePtr+10) == 0x22 && *(meVsccTablePtr+11) == 0x11
+			&& *(meVsccTablePtr+12) == 0x08 && *(meVsccTablePtr+13) == 0x07 && *(meVsccTablePtr+14) == 0x06 && *(meVsccTablePtr+15) == 0x05
+			&& *(meVsccTablePtr+16) == 0x80 && *(meVsccTablePtr+17) == 0x70 && *(meVsccTablePtr+18) == 0x60 && *(meVsccTablePtr+19) == 0x50
+			&& *(meVsccTablePtr+20) == 0x88 && *(meVsccTablePtr+21) == 0x77 && *(meVsccTablePtr+22) == 0x66 && *(meVsccTablePtr+23) == 0x55
+			&& *(meVsccTablePtr+24) == 0xAA && *(meVsccTablePtr+25) == 0xBB && *(meVsccTablePtr+26) == 0xCC && *(meVsccTablePtr+27) == 0xDD
+	      )
+	   ) {
+		printf("Incorrect order.\n");
+		return 1;
+	}
+	printf("Correct order.\n");
+	return 0;
+}
+
+// fail if bit fields are presented in the wrong order
+int structBitfieldWrongOrder() 
+{
+	int i;
+	struct DESCRIPTORREGIONRECORD descriptorDummy;
+	unsigned char *flMap0Ptr = (unsigned char*)&descriptorDummy.flMaps.flMap0;
+	
+	descriptorDummy.flMaps.flMap0.FCBA = 0xA2;      // :8 --> 10100010
+	descriptorDummy.flMaps.flMap0.NC = 0x02;        // :2 --> 10
+	descriptorDummy.flMaps.flMap0.reserved1 = 0x38; // :6 --> 111000
+	descriptorDummy.flMaps.flMap0.FRBA = 0xD2;      // :8 --> 11010010
+	descriptorDummy.flMaps.flMap0.NR = 0x05;        // :3 --> 101
+	descriptorDummy.flMaps.flMap0.reserved2 = 0x1C; // :5 --> 11100
+	
+	// Look from the top bottom up, and concatenate the binary strings.
+	// Then, convert the 8-bit groups to hex and reverse the (8-bit)byte order
+	
+	// combined, these should become (in memory), in binary:
+	// 10100010 11100010 11010010 11100101
+	// or in hex:
+	// A2 E2 D2 E5
+	
+	printf("\nBitfield order check (descriptorDummy.flMaps.flMaps0) with junk/dummy data:");
+	printf("\nShould be: a2 e2 d2 e5 ");
+	printf("\nAnd it is: ");
+
+	for (i = 0; i < 4; i++) {
+		printf("%02x ", *(flMap0Ptr + i));	
+	}
+	printf("\n");
+	
+	if (!(*flMap0Ptr == 0xA2 && *(flMap0Ptr+1) == 0xE2 && *(flMap0Ptr+2) == 0xD2 && *(flMap0Ptr+3) == 0xE5)) {
+		printf("Incorrect order.\n");
+		return 1;
+	}
+	printf("Correct order.\n");
+	return 0;
+}
+
+// Compatibility checks. This version of ich9deblob is not yet porable.
+int systemOrCompilerIncompatible(struct DESCRIPTORREGIONRECORD descriptorStruct, struct GBEREGIONRECORD_8K gbeStruct8k) 
+{
+	if (structSizesIncorrect(descriptorStruct, gbeStruct8k)) return 1;
+	if (systemIsBigEndian()) return 1;
+	if (structBitfieldWrongOrder()) return 1;
+	if (structMembersWrongOrder()) return 1; 
+	return 0;
+}