lib: uuid: code refactor for proper maintain between uuid bin and string

Changes in lib/uuid.c to:
- uuid_str_to_bin()
- uuid_bin_to_str()

New parameter is added to specify input/output string format in listed functions
This change allows easy recognize which UUID type is or should be stored in given
string array. Binary data of UUID and GUID is always stored in big endian, only
string representations are different as follows.

String byte: 0                                  36
String char: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
string UUID:    be     be   be   be       be
string GUID:    le     le   le   be       be

This patch also updates functions calls and declarations in a whole code.

Signed-off-by: Przemyslaw Marczak <p.marczak@samsung.com>
Cc: Stephen Warren <swarren@nvidia.com>
Cc: Lukasz Majewski <l.majewski@samsung.com>
Cc: trini@ti.com

1 files changed, 59 insertions, 24 deletions

diff --git a/lib/uuid.c b/lib/uuid.c
index 3af3a7dfaec..8db865fc694 100644
--- a/lib/uuid.c
+++ b/lib/uuid.c
@@ -7,8 +7,9 @@
 #include <linux/ctype.h>
 #include <errno.h>
 #include <common.h>
-
-#define UUID_STR_LEN		36
+#include <asm/io.h>
+#include <part_efi.h>
+#include <malloc.h>
 
 /*
  * UUID - Universally Unique IDentifier - 128 bits unique number.
@@ -40,7 +41,6 @@
  *
  * GUID is used e.g. in GPT (GUID Partition Table) as a partiions unique id.
  */
-
 int uuid_str_valid(const char *uuid)
 {
 	int i, valid;
@@ -59,57 +59,92 @@ int uuid_str_valid(const char *uuid)
 		}
 	}
 
-	if (i != 36 || !valid)
+	if (i != UUID_STR_LEN || !valid)
 		return 0;
 
 	return 1;
 }
 
-int uuid_str_to_bin(char *uuid, unsigned char *out)
+/*
+ * uuid_str_to_bin() - convert string UUID or GUID to big endian binary data.
+ *
+ * @param uuid_str - pointer to UUID or GUID string [37B]
+ * @param uuid_bin - pointer to allocated array for big endian output [16B]
+ * @str_format     - UUID string format: 0 - UUID; 1 - GUID
+ */
+int uuid_str_to_bin(char *uuid_str, unsigned char *uuid_bin, int str_format)
 {
 	uint16_t tmp16;
 	uint32_t tmp32;
 	uint64_t tmp64;
 
-	if (!uuid || !out)
+	if (!uuid_str_valid(uuid_str))
 		return -EINVAL;
 
-	if (strlen(uuid) != UUID_STR_LEN)
-		return -EINVAL;
+	if (str_format == UUID_STR_FORMAT_STD) {
+		tmp32 = cpu_to_be32(simple_strtoul(uuid_str, NULL, 16));
+		memcpy(uuid_bin, &tmp32, 4);
 
-	tmp32 = cpu_to_le32(simple_strtoul(uuid, NULL, 16));
-	memcpy(out, &tmp32, 4);
+		tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 9, NULL, 16));
+		memcpy(uuid_bin + 4, &tmp16, 2);
 
-	tmp16 = cpu_to_le16(simple_strtoul(uuid + 9, NULL, 16));
-	memcpy(out + 4, &tmp16, 2);
+		tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 14, NULL, 16));
+		memcpy(uuid_bin + 6, &tmp16, 2);
+	} else {
+		tmp32 = cpu_to_le32(simple_strtoul(uuid_str, NULL, 16));
+		memcpy(uuid_bin, &tmp32, 4);
 
-	tmp16 = cpu_to_le16(simple_strtoul(uuid + 14, NULL, 16));
-	memcpy(out + 6, &tmp16, 2);
+		tmp16 = cpu_to_le16(simple_strtoul(uuid_str + 9, NULL, 16));
+		memcpy(uuid_bin + 4, &tmp16, 2);
 
-	tmp16 = cpu_to_be16(simple_strtoul(uuid + 19, NULL, 16));
-	memcpy(out + 8, &tmp16, 2);
+		tmp16 = cpu_to_le16(simple_strtoul(uuid_str + 14, NULL, 16));
+		memcpy(uuid_bin + 6, &tmp16, 2);
+	}
+
+	tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 19, NULL, 16));
+	memcpy(uuid_bin + 8, &tmp16, 2);
 
-	tmp64 = cpu_to_be64(simple_strtoull(uuid + 24, NULL, 16));
-	memcpy(out + 10, (char *)&tmp64 + 2, 6);
+	tmp64 = cpu_to_be64(simple_strtoull(uuid_str + 24, NULL, 16));
+	memcpy(uuid_bin + 10, (char *)&tmp64 + 2, 6);
 
 	return 0;
 }
 
-void uuid_bin_to_str(unsigned char *uuid, char *str)
+/*
+ * uuid_bin_to_str() - convert big endian binary data to string UUID or GUID.
+ *
+ * @param uuid_bin - pointer to binary data of UUID (big endian) [16B]
+ * @param uuid_str - pointer to allocated array for output string [37B]
+ * @str_format     - UUID string format: 0 - UUID; 1 - GUID
+ */
+void uuid_bin_to_str(unsigned char *uuid_bin, char *uuid_str, int str_format)
 {
-	static const u8 le[16] = {3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11,
-				  12, 13, 14, 15};
+	const u8 uuid_char_order[UUID_BIN_LEN] = {0, 1, 2, 3, 4, 5, 6, 7, 8,
+						  9, 10, 11, 12, 13, 14, 15};
+	const u8 guid_char_order[UUID_BIN_LEN] = {3, 2, 1, 0, 5, 4, 7, 6, 8,
+						  9, 10, 11, 12, 13, 14, 15};
+	const u8 *char_order;
 	int i;
 
+	/*
+	 * UUID and GUID bin data - always in big endian:
+	 * 4B-2B-2B-2B-6B
+	 * be be be be be
+	 */
+	if (str_format == UUID_STR_FORMAT_STD)
+		char_order = uuid_char_order;
+	else
+		char_order = guid_char_order;
+
 	for (i = 0; i < 16; i++) {
-		sprintf(str, "%02x", uuid[le[i]]);
-		str += 2;
+		sprintf(uuid_str, "%02x", uuid_bin[char_order[i]]);
+		uuid_str += 2;
 		switch (i) {
 		case 3:
 		case 5:
 		case 7:
 		case 9:
-			*str++ = '-';
+			*uuid_str++ = '-';
 			break;
 		}
 	}