tpm: substitute deprecated uint<x>_t types with their u<x> equivalent

Fix following checkpatch.pl issues in TPM-related code:

    CHECK: Prefer kernel type 'u8' over 'uint8_t'
    CHECK: Prefer kernel type 'u16' over 'uint16_t'
    CHECK: Prefer kernel type 'u32' over 'uint32_t'

Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
Reviewed-by: Tom Rini <trini@konsulko.com>
Reviewed-by: Simon Glass <sjg@chromium.org>

cmd/tpm.c

@@ -24,7 +24,7 @@ enum {
  * @param data		byte string to be printed
  * @param count		number of bytes to be printed
  */
-static void print_byte_string(uint8_t *data, size_t count)
+static void print_byte_string(u8 *data, size_t count)
 {
 	int i, print_newline = 0;
 
@@ -51,7 +51,7 @@ static void print_byte_string(uint8_t *data, size_t count)
  * @param count_ptr	output variable for the length of byte string
  * @return pointer to output buffer
  */
-static void *parse_byte_string(char *bytes, uint8_t *data, size_t *count_ptr)
+static void *parse_byte_string(char *bytes, u8 *data, size_t *count_ptr)
 {
 	char byte[3];
 	size_t count, length;
@@ -71,7 +71,7 @@ static void *parse_byte_string(char *bytes, uint8_t *data, size_t *count_ptr)
 	for (i = 0; i < length; i += 2) {
 		byte[0] = bytes[i];
 		byte[1] = bytes[i + 1];
-		data[i / 2] = (uint8_t)simple_strtoul(byte, NULL, 16);
+		data[i / 2] = (u8)simple_strtoul(byte, NULL, 16);
 	}
 
 	if (count_ptr)
@@ -145,7 +145,7 @@ static size_t type_string_get_space_size(const char *type_str)
  * @param count		pointer for storing size of buffer
  * @return pointer to buffer or NULL on error
  */
-static void *type_string_alloc(const char *type_str, uint32_t *count)
+static void *type_string_alloc(const char *type_str, u32 *count)
 {
 	void *data;
 	size_t size;
@@ -170,10 +170,10 @@ static void *type_string_alloc(const char *type_str, uint32_t *count)
  * @return 0 on success, non-0 on error
  */
 static int type_string_pack(const char *type_str, char * const values[],
-		uint8_t *data)
+			    u8 *data)
 {
 	size_t offset;
-	uint32_t value;
+	u32 value;
 
 	for (offset = 0; *type_str; type_str++, values++) {
 		value = simple_strtoul(values[0], NULL, 0);
@@ -207,11 +207,11 @@ static int type_string_pack(const char *type_str, char * const values[],
  * @param vars		names of environment variables
  * @return 0 on success, non-0 on error
  */
-static int type_string_write_vars(const char *type_str, uint8_t *data,
-		char * const vars[])
+static int type_string_write_vars(const char *type_str, u8 *data,
+				  char * const vars[])
 {
 	size_t offset;
-	uint32_t value;
+	u32 value;
 
 	for (offset = 0; *type_str; type_str++, vars++) {
 		switch (*type_str) {
@@ -261,7 +261,7 @@ static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, perm, size;
+	u32 index, perm, size;
 
 	if (argc != 4)
 		return CMD_RET_USAGE;
@@ -275,7 +275,7 @@ static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, count, rc;
+	u32 index, count, rc;
 	void *data;
 
 	if (argc != 4)
@@ -296,7 +296,7 @@ static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, rc;
+	u32 index, rc;
 	size_t count;
 	void *data;
 
@@ -318,8 +318,8 @@ static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, rc;
-	uint8_t in_digest[20], out_digest[20];
+	u32 index, rc;
+	u8 in_digest[20], out_digest[20];
 
 	if (argc != 3)
 		return CMD_RET_USAGE;
@@ -341,7 +341,7 @@ static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, count, rc;
+	u32 index, count, rc;
 	void *data;
 
 	if (argc != 4)
@@ -362,11 +362,11 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint16_t presence;
+	u16 presence;
 
 	if (argc != 2)
 		return CMD_RET_USAGE;
-	presence = (uint16_t)simple_strtoul(argv[1], NULL, 0);
+	presence = (u16)simple_strtoul(argv[1], NULL, 0);
 
 	return report_return_code(tpm_tsc_physical_presence(presence));
 }
@@ -374,7 +374,7 @@ static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t count, rc;
+	u32 count, rc;
 	void *data;
 
 	if (argc != 3)
@@ -394,11 +394,11 @@ static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint8_t state;
+	u8 state;
 
 	if (argc != 2)
 		return CMD_RET_USAGE;
-	state = (uint8_t)simple_strtoul(argv[1], NULL, 0);
+	state = (u8)simple_strtoul(argv[1], NULL, 0);
 
 	return report_return_code(tpm_physical_set_deactivated(state));
 }
@@ -406,7 +406,7 @@ static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t cap_area, sub_cap, rc;
+	u32 cap_area, sub_cap, rc;
 	void *cap;
 	size_t count;
 
@@ -480,9 +480,9 @@ static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag,
 {
 	struct udevice *dev;
 	void *command;
-	uint8_t response[1024];
+	u8 response[1024];
 	size_t count, response_length = sizeof(response);
-	uint32_t rc;
+	u32 rc;
 
 	command = parse_byte_string(argv[1], NULL, &count);
 	if (!command) {
@@ -507,7 +507,7 @@ static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, perm, size;
+	u32 index, perm, size;
 
 	if (argc != 4)
 		return CMD_RET_USAGE;
@@ -525,7 +525,7 @@ static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, count, err;
+	u32 index, count, err;
 	void *data;
 
 	if (argc < 3)
@@ -554,7 +554,7 @@ static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t index, count, err;
+	u32 index, count, err;
 	void *data;
 
 	if (argc < 3)
@@ -584,7 +584,7 @@ static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t auth_handle, err;
+	u32 auth_handle, err;
 
 	err = tpm_oiap(&auth_handle);
 
@@ -595,10 +595,10 @@ static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char *
 				   const argv[])
 {
-	uint32_t parent_handle = 0;
-	uint32_t key_len, key_handle, err;
-	uint8_t usage_auth[DIGEST_LENGTH];
-	uint8_t parent_hash[DIGEST_LENGTH];
+	u32 parent_handle = 0;
+	u32 key_len, key_handle, err;
+	u8 usage_auth[DIGEST_LENGTH];
+	u8 parent_hash[DIGEST_LENGTH];
 	void *key;
 
 	if (argc < 5)
@@ -633,8 +633,8 @@ static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char *
 static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t parent_handle, key_len, key_handle, err;
-	uint8_t usage_auth[DIGEST_LENGTH];
+	u32 parent_handle, key_len, key_handle, err;
+	u8 usage_auth[DIGEST_LENGTH];
 	void *key;
 
 	if (argc < 5)
@@ -658,9 +658,9 @@ static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag,
 static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	uint32_t key_handle, err;
-	uint8_t usage_auth[DIGEST_LENGTH];
-	uint8_t pub_key_buffer[TPM_PUBKEY_MAX_LENGTH];
+	u32 key_handle, err;
+	u8 usage_auth[DIGEST_LENGTH];
+	u8 pub_key_buffer[TPM_PUBKEY_MAX_LENGTH];
 	size_t pub_key_len = sizeof(pub_key_buffer);
 
 	if (argc < 3)
@@ -720,9 +720,9 @@ static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc,
 	}
 
 	if (!strcasecmp(argv[2], "all")) {
-		uint16_t res_count;
-		uint8_t buf[288];
-		uint8_t *ptr;
+		u16 res_count;
+		u8 buf[288];
+		u8 *ptr;
 		int err;
 		uint i;
 
@@ -738,7 +738,7 @@ static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc,
 		for (i = 0; i < res_count; ++i, ptr += 4)
 			tpm_flush_specific(get_unaligned_be32(ptr), type);
 	} else {
-		uint32_t handle = simple_strtoul(argv[2], NULL, 0);
+		u32 handle = simple_strtoul(argv[2], NULL, 0);
 
 		if (!handle) {
 			printf("Illegal resource handle %s\n", argv[2]);
@@ -756,9 +756,9 @@ static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc,
 		       char * const argv[])
 {
 	int type = 0;
-	uint16_t res_count;
-	uint8_t buf[288];
-	uint8_t *ptr;
+	u16 res_count;
+	u8 buf[288];
+	u8 *ptr;
 	int err;
 	uint i;
 

include/tpm.h

@@ -308,8 +308,7 @@ struct tpm_ops {
 	 *
 	 * Returns 0 on success or -ve on failure.
 	 */
-	int (*send)(struct udevice *dev, const uint8_t *sendbuf,
-		    size_t send_size);
+	int (*send)(struct udevice *dev, const u8 *sendbuf, size_t send_size);
 
 	/**
 	 * recv() - receive a response from the TPM
@@ -322,7 +321,7 @@ struct tpm_ops {
 	 * response is not ready, -EINTR if cancelled, or other -ve value on
 	 * failure.
 	 */
-	int (*recv)(struct udevice *dev, uint8_t *recvbuf, size_t max_size);
+	int (*recv)(struct udevice *dev, u8 *recvbuf, size_t max_size);
 
 	/**
 	 * cleanup() - clean up after an operation in progress
@@ -351,8 +350,8 @@ struct tpm_ops {
 	 * Returns 0 on success (and places the number of response bytes at
 	 * recv_size) or -ve on failure.
 	 */
-	int (*xfer)(struct udevice *dev, const uint8_t *sendbuf,
-		    size_t send_size, uint8_t *recvbuf, size_t *recv_size);
+	int (*xfer)(struct udevice *dev, const u8 *sendbuf, size_t send_size,
+		    u8 *recvbuf, size_t *recv_size);
 };
 
 #define tpm_get_ops(dev)        ((struct tpm_ops *)device_get_ops(dev))
@@ -406,8 +405,8 @@ int tpm_get_desc(struct udevice *dev, char *buf, int size);
  * Returns 0 on success (and places the number of response bytes at
  * recv_len) or -ve on failure.
  */
-int tpm_xfer(struct udevice *dev, const uint8_t *sendbuf, size_t send_size,
-	     uint8_t *recvbuf, size_t *recv_size);
+int tpm_xfer(struct udevice *dev, const u8 *sendbuf, size_t send_size,
+	     u8 *recvbuf, size_t *recv_size);
 
 /**
  * Initialize TPM device.  It must be called before any TPM commands.
@@ -422,21 +421,21 @@ int tpm_init(void);
  * @param mode		TPM startup mode
  * @return return code of the operation
  */
-uint32_t tpm_startup(enum tpm_startup_type mode);
+u32 tpm_startup(enum tpm_startup_type mode);
 
 /**
  * Issue a TPM_SelfTestFull command.
  *
  * @return return code of the operation
  */
-uint32_t tpm_self_test_full(void);
+u32 tpm_self_test_full(void);
 
 /**
  * Issue a TPM_ContinueSelfTest command.
  *
  * @return return code of the operation
  */
-uint32_t tpm_continue_self_test(void);
+u32 tpm_continue_self_test(void);
 
 /**
  * Issue a TPM_NV_DefineSpace command.  The implementation is limited
@@ -448,7 +447,7 @@ uint32_t tpm_continue_self_test(void);
  * @param size		size of the area
  * @return return code of the operation
  */
-uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size);
+u32 tpm_nv_define_space(u32 index, u32 perm, u32 size);
 
 /**
  * Issue a TPM_NV_ReadValue command.  This implementation is limited
@@ -460,7 +459,7 @@ uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size);
  * @param count		size of output buffer
  * @return return code of the operation
  */
-uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count);
+u32 tpm_nv_read_value(u32 index, void *data, u32 count);
 
 /**
  * Issue a TPM_NV_WriteValue command.  This implementation is limited
@@ -472,7 +471,7 @@ uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count);
  * @param length	length of data bytes of input buffer
  * @return return code of the operation
  */
-uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length);
+u32 tpm_nv_write_value(u32 index, const void *data, u32 length);
 
 /**
  * Issue a TPM_Extend command.
@@ -484,7 +483,7 @@ uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length);
  *			command
  * @return return code of the operation
  */
-uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest);
+u32 tpm_extend(u32 index, const void *in_digest, void *out_digest);
 
 /**
  * Issue a TPM_PCRRead command.
@@ -494,7 +493,7 @@ uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest);
  * @param count		size of output buffer
  * @return return code of the operation
  */
-uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count);
+u32 tpm_pcr_read(u32 index, void *data, size_t count);
 
 /**
  * Issue a TSC_PhysicalPresence command.  TPM physical presence flag
@@ -503,7 +502,7 @@ uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count);
  * @param presence	TPM physical presence flag
  * @return return code of the operation
  */
-uint32_t tpm_tsc_physical_presence(uint16_t presence);
+u32 tpm_tsc_physical_presence(u16 presence);
 
 /**
  * Issue a TPM_ReadPubek command.
@@ -512,28 +511,28 @@ uint32_t tpm_tsc_physical_presence(uint16_t presence);
  * @param count		size of ouput buffer
  * @return return code of the operation
  */
-uint32_t tpm_read_pubek(void *data, size_t count);
+u32 tpm_read_pubek(void *data, size_t count);
 
 /**
  * Issue a TPM_ForceClear command.
  *
  * @return return code of the operation
  */
-uint32_t tpm_force_clear(void);
+u32 tpm_force_clear(void);
 
 /**
  * Issue a TPM_PhysicalEnable command.
  *
  * @return return code of the operation
  */
-uint32_t tpm_physical_enable(void);
+u32 tpm_physical_enable(void);
 
 /**
  * Issue a TPM_PhysicalDisable command.
  *
  * @return return code of the operation
  */
-uint32_t tpm_physical_disable(void);
+u32 tpm_physical_disable(void);
 
 /**
  * Issue a TPM_PhysicalSetDeactivated command.
@@ -541,7 +540,7 @@ uint32_t tpm_physical_disable(void);
  * @param state		boolean state of the deactivated flag
  * @return return code of the operation
  */
-uint32_t tpm_physical_set_deactivated(uint8_t state);
+u32 tpm_physical_set_deactivated(u8 state);
 
 /**
  * Issue a TPM_GetCapability command.  This implementation is limited
@@ -554,8 +553,7 @@ uint32_t tpm_physical_set_deactivated(uint8_t state);
  * @param count		size of ouput buffer
  * @return return code of the operation
  */
-uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
-		void *cap, size_t count);
+u32 tpm_get_capability(u32 cap_area, u32 sub_cap, void *cap, size_t count);
 
 /**
  * Issue a TPM_FlushSpecific command for a AUTH ressource.
@@ -563,7 +561,7 @@ uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
  * @param auth_handle	handle of the auth session
  * @return return code of the operation
  */
-uint32_t tpm_terminate_auth_session(uint32_t auth_handle);
+u32 tpm_terminate_auth_session(u32 auth_handle);
 
 /**
  * Issue a TPM_OIAP command to setup an object independant authorization
@@ -575,14 +573,14 @@ uint32_t tpm_terminate_auth_session(uint32_t auth_handle);
  * @param auth_handle	pointer to the (new) auth handle or NULL.
  * @return return code of the operation
  */
-uint32_t tpm_oiap(uint32_t *auth_handle);
+u32 tpm_oiap(u32 *auth_handle);
 
 /**
  * Ends an active OIAP session.
  *
  * @return return code of the operation
  */
-uint32_t tpm_end_oiap(void);
+u32 tpm_end_oiap(void);
 
 /**
  * Issue a TPM_LoadKey2 (Auth1) command using an OIAP session for authenticating
@@ -595,10 +593,8 @@ uint32_t tpm_end_oiap(void);
  * @param key_handle	pointer to the key handle
  * @return return code of the operation
  */
-uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
-		const void *key, size_t key_length,
-		const void *parent_key_usage_auth,
-		uint32_t *key_handle);
+u32 tpm_load_key2_oiap(u32 parent_handle, const void *key, size_t key_length,
+		       const void *parent_key_usage_auth, u32 *key_handle);
 
 /**
  * Issue a TPM_GetPubKey (Auth1) command using an OIAP session for
@@ -613,8 +609,8 @@ uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
  *			of the stored TPM_PUBKEY structure (iff pubkey != NULL).
  * @return return code of the operation
  */
-uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
-		void *pubkey, size_t *pubkey_len);
+u32 tpm_get_pub_key_oiap(u32 key_handle, const void *usage_auth, void *pubkey,
+			 size_t *pubkey_len);
 
 /**
  * Get the TPM permanent flags value
@@ -622,7 +618,7 @@ uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
  * @param pflags	Place to put permanent flags
  * @return return code of the operation
  */
-uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags);
+u32 tpm_get_permanent_flags(struct tpm_permanent_flags *pflags);
 
 /**
  * Get the TPM permissions
@@ -630,7 +626,7 @@ uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags);
  * @param perm		Returns permissions value
  * @return return code of the operation
  */
-uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm);
+u32 tpm_get_permissions(u32 index, u32 *perm);
 
 /**
  * Flush a resource with a given handle and type from the TPM
@@ -639,7 +635,7 @@ uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm);
  * @param resource_type                type of the resource
  * @return return code of the operation
  */
-uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type);
+u32 tpm_flush_specific(u32 key_handle, u32 resource_type);
 
 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
 /**
@@ -650,8 +646,8 @@ uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type);
  * @param[out] handle	The handle of the key (Non-null iff found)
  * @return 0 if key was found in TPM; != 0 if not.
  */
-uint32_t tpm_find_key_sha1(const uint8_t auth[20], const uint8_t
-			   pubkey_digest[20], uint32_t *handle);
+u32 tpm_find_key_sha1(const u8 auth[20], const u8 pubkey_digest[20],
+		      u32 *handle);
 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
 
 /**
@@ -663,6 +659,6 @@ uint32_t tpm_find_key_sha1(const uint8_t auth[20], const uint8_t
  * @param count		size of output buffer
  * @return return code of the operation
  */
-uint32_t tpm_get_random(void *data, uint32_t count);
+u32 tpm_get_random(void *data, u32 count);
 
 #endif /* __TPM_H */

lib/tpm.c

@@ -11,7 +11,7 @@
 #include <u-boot/sha1.h>
 
 /* Internal error of TPM command library */
-#define TPM_LIB_ERROR	((uint32_t)~0u)
+#define TPM_LIB_ERROR	((u32)~0u)
 
 /* Useful constants */
 enum {
@@ -35,9 +35,9 @@ enum {
 
 struct session_data {
 	int		valid;
-	uint32_t	handle;
-	uint8_t		nonce_even[DIGEST_LENGTH];
-	uint8_t		nonce_odd[DIGEST_LENGTH];
+	u32	handle;
+	u8		nonce_even[DIGEST_LENGTH];
+	u8		nonce_odd[DIGEST_LENGTH];
 };
 
 static struct session_data oiap_session = {0, };
@@ -59,12 +59,12 @@ static struct session_data oiap_session = {0, };
  * @param ...		data points
  * @return 0 on success, non-0 on error
  */
-int pack_byte_string(uint8_t *str, size_t size, const char *format, ...)
+int pack_byte_string(u8 *str, size_t size, const char *format, ...)
 {
 	va_list args;
 	size_t offset = 0, length = 0;
-	uint8_t *data = NULL;
-	uint32_t value = 0;
+	u8 *data = NULL;
+	u32 value = 0;
 
 	va_start(args, format);
 	for (; *format; format++) {
@@ -81,13 +81,13 @@ int pack_byte_string(uint8_t *str, size_t size, const char *format, ...)
 			break;
 		case 'd':
 			offset = va_arg(args, size_t);
-			value = va_arg(args, uint32_t);
+			value = va_arg(args, u32);
 			length = 4;
 			break;
 		case 's':
 			offset = va_arg(args, size_t);
-			data = va_arg(args, uint8_t *);
-			length = va_arg(args, uint32_t);
+			data = va_arg(args, u8 *);
+			length = va_arg(args, u32);
 			break;
 		default:
 			debug("Couldn't recognize format string\n");
@@ -133,36 +133,36 @@ int pack_byte_string(uint8_t *str, size_t size, const char *format, ...)
  * @param ...		data points
  * @return 0 on success, non-0 on error
  */
-int unpack_byte_string(const uint8_t *str, size_t size, const char *format, ...)
+int unpack_byte_string(const u8 *str, size_t size, const char *format, ...)
 {
 	va_list args;
 	size_t offset = 0, length = 0;
-	uint8_t *ptr8 = NULL;
-	uint16_t *ptr16 = NULL;
-	uint32_t *ptr32 = NULL;
+	u8 *ptr8 = NULL;
+	u16 *ptr16 = NULL;
+	u32 *ptr32 = NULL;
 
 	va_start(args, format);
 	for (; *format; format++) {
 		switch (*format) {
 		case 'b':
 			offset = va_arg(args, size_t);
-			ptr8 = va_arg(args, uint8_t *);
+			ptr8 = va_arg(args, u8 *);
 			length = 1;
 			break;
 		case 'w':
 			offset = va_arg(args, size_t);
-			ptr16 = va_arg(args, uint16_t *);
+			ptr16 = va_arg(args, u16 *);
 			length = 2;
 			break;
 		case 'd':
 			offset = va_arg(args, size_t);
-			ptr32 = va_arg(args, uint32_t *);
+			ptr32 = va_arg(args, u32 *);
 			length = 4;
 			break;
 		case 's':
 			offset = va_arg(args, size_t);
-			ptr8 = va_arg(args, uint8_t *);
-			length = va_arg(args, uint32_t);
+			ptr8 = va_arg(args, u8 *);
+			length = va_arg(args, u32);
 			break;
 		default:
 			va_end(args);
@@ -201,7 +201,7 @@ int unpack_byte_string(const uint8_t *str, size_t size, const char *format, ...)
  * @param command	byte string of TPM command
  * @return command size of the TPM command
  */
-static uint32_t tpm_command_size(const void *command)
+static u32 tpm_command_size(const void *command)
 {
 	const size_t command_size_offset = 2;
 	return get_unaligned_be32(command + command_size_offset);
@@ -213,7 +213,7 @@ static uint32_t tpm_command_size(const void *command)
  * @param response	byte string of TPM response
  * @return return code of the TPM response
  */
-static uint32_t tpm_return_code(const void *response)
+static u32 tpm_return_code(const void *response)
 {
 	const size_t return_code_offset = 6;
 	return get_unaligned_be32(response + return_code_offset);
@@ -231,12 +231,12 @@ static uint32_t tpm_return_code(const void *response)
  *			is a bidirectional
  * @return return code of the TPM response
  */
-static uint32_t tpm_sendrecv_command(const void *command,
-		void *response, size_t *size_ptr)
+static u32 tpm_sendrecv_command(const void *command, void *response,
+				size_t *size_ptr)
 {
 	struct udevice *dev;
 	int err, ret;
-	uint8_t response_buffer[COMMAND_BUFFER_SIZE];
+	u8 response_buffer[COMMAND_BUFFER_SIZE];
 	size_t response_length;
 
 	if (response) {
@@ -271,13 +271,13 @@ int tpm_init(void)
 	return tpm_open(dev);
 }
 
-uint32_t tpm_startup(enum tpm_startup_type mode)
+u32 tpm_startup(enum tpm_startup_type mode)
 {
-	const uint8_t command[12] = {
+	const u8 command[12] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x0,
 	};
 	const size_t mode_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE];
 
 	if (pack_byte_string(buf, sizeof(buf), "sw",
 				0, command, sizeof(command),
@@ -287,25 +287,25 @@ uint32_t tpm_startup(enum tpm_startup_type mode)
 	return tpm_sendrecv_command(buf, NULL, NULL);
 }
 
-uint32_t tpm_self_test_full(void)
+u32 tpm_self_test_full(void)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50,
 	};
 	return tpm_sendrecv_command(command, NULL, NULL);
 }
 
-uint32_t tpm_continue_self_test(void)
+u32 tpm_continue_self_test(void)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x53,
 	};
 	return tpm_sendrecv_command(command, NULL, NULL);
 }
 
-uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size)
+u32 tpm_nv_define_space(u32 index, u32 perm, u32 size)
 {
-	const uint8_t command[101] = {
+	const u8 command[101] = {
 		0x0, 0xc1,		/* TPM_TAG */
 		0x0, 0x0, 0x0, 0x65,	/* parameter size */
 		0x0, 0x0, 0x0, 0xcc,	/* TPM_COMMAND_CODE */
@@ -334,7 +334,7 @@ uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size)
 	const size_t index_offset = 12;
 	const size_t perm_offset = 70;
 	const size_t size_offset = 77;
-	uint8_t buf[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE];
 
 	if (pack_byte_string(buf, sizeof(buf), "sddd",
 				0, command, sizeof(command),
@@ -346,19 +346,19 @@ uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size)
 	return tpm_sendrecv_command(buf, NULL, NULL);
 }
 
-uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count)
+u32 tpm_nv_read_value(u32 index, void *data, u32 count)
 {
-	const uint8_t command[22] = {
+	const u8 command[22] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0xcf,
 	};
 	const size_t index_offset = 10;
 	const size_t length_offset = 18;
 	const size_t data_size_offset = 10;
 	const size_t data_offset = 14;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t data_size;
-	uint32_t err;
+	u32 data_size;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "sdd",
 				0, command, sizeof(command),
@@ -380,9 +380,9 @@ uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count)
 	return 0;
 }
 
-uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length)
+u32 tpm_nv_write_value(u32 index, const void *data, u32 length)
 {
-	const uint8_t command[256] = {
+	const u8 command[256] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcd,
 	};
 	const size_t command_size_offset = 2;
@@ -390,11 +390,11 @@ uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length)
 	const size_t length_offset = 18;
 	const size_t data_offset = 22;
 	const size_t write_info_size = 12;
-	const uint32_t total_length =
+	const u32 total_length =
 		TPM_REQUEST_HEADER_LENGTH + write_info_size + length;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "sddds",
 				0, command, sizeof(command),
@@ -410,18 +410,18 @@ uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length)
 	return 0;
 }
 
-uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest)
+u32 tpm_extend(u32 index, const void *in_digest, void *out_digest)
 {
-	const uint8_t command[34] = {
+	const u8 command[34] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x14,
 	};
 	const size_t index_offset = 10;
 	const size_t in_digest_offset = 14;
 	const size_t out_digest_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE];
-	uint8_t response[TPM_RESPONSE_HEADER_LENGTH + PCR_DIGEST_LENGTH];
+	u8 buf[COMMAND_BUFFER_SIZE];
+	u8 response[TPM_RESPONSE_HEADER_LENGTH + PCR_DIGEST_LENGTH];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "sds",
 				0, command, sizeof(command),
@@ -441,16 +441,16 @@ uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest)
 	return 0;
 }
 
-uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count)
+u32 tpm_pcr_read(u32 index, void *data, size_t count)
 {
-	const uint8_t command[14] = {
+	const u8 command[14] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x15,
 	};
 	const size_t index_offset = 10;
 	const size_t out_digest_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (count < PCR_DIGEST_LENGTH)
 		return TPM_LIB_ERROR;
@@ -469,13 +469,13 @@ uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count)
 	return 0;
 }
 
-uint32_t tpm_tsc_physical_presence(uint16_t presence)
+u32 tpm_tsc_physical_presence(u16 presence)
 {
-	const uint8_t command[12] = {
+	const u8 command[12] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x0,
 	};
 	const size_t presence_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE];
 
 	if (pack_byte_string(buf, sizeof(buf), "sw",
 				0, command, sizeof(command),
@@ -485,18 +485,18 @@ uint32_t tpm_tsc_physical_presence(uint16_t presence)
 	return tpm_sendrecv_command(buf, NULL, NULL);
 }
 
-uint32_t tpm_read_pubek(void *data, size_t count)
+u32 tpm_read_pubek(void *data, size_t count)
 {
-	const uint8_t command[30] = {
+	const u8 command[30] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0, 0x0, 0x7c,
 	};
 	const size_t response_size_offset = 2;
 	const size_t data_offset = 10;
 	const size_t header_and_checksum_size = TPM_RESPONSE_HEADER_LENGTH + 20;
-	uint8_t response[COMMAND_BUFFER_SIZE + TPM_PUBEK_SIZE];
+	u8 response[COMMAND_BUFFER_SIZE + TPM_PUBEK_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t data_size;
-	uint32_t err;
+	u32 data_size;
+	u32 err;
 
 	err = tpm_sendrecv_command(command, response, &response_length);
 	if (err)
@@ -516,40 +516,40 @@ uint32_t tpm_read_pubek(void *data, size_t count)
 	return 0;
 }
 
-uint32_t tpm_force_clear(void)
+u32 tpm_force_clear(void)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x5d,
 	};
 
 	return tpm_sendrecv_command(command, NULL, NULL);
 }
 
-uint32_t tpm_physical_enable(void)
+u32 tpm_physical_enable(void)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x6f,
 	};
 
 	return tpm_sendrecv_command(command, NULL, NULL);
 }
 
-uint32_t tpm_physical_disable(void)
+u32 tpm_physical_disable(void)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x70,
 	};
 
 	return tpm_sendrecv_command(command, NULL, NULL);
 }
 
-uint32_t tpm_physical_set_deactivated(uint8_t state)
+u32 tpm_physical_set_deactivated(u8 state)
 {
-	const uint8_t command[11] = {
+	const u8 command[11] = {
 		0x0, 0xc1, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x72,
 	};
 	const size_t state_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE];
 
 	if (pack_byte_string(buf, sizeof(buf), "sb",
 				0, command, sizeof(command),
@@ -559,10 +559,9 @@ uint32_t tpm_physical_set_deactivated(uint8_t state)
 	return tpm_sendrecv_command(buf, NULL, NULL);
 }
 
-uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
-		void *cap, size_t count)
+u32 tpm_get_capability(u32 cap_area, u32 sub_cap, void *cap, size_t count)
 {
-	const uint8_t command[22] = {
+	const u8 command[22] = {
 		0x0, 0xc1,		/* TPM_TAG */
 		0x0, 0x0, 0x0, 0x16,	/* parameter size */
 		0x0, 0x0, 0x0, 0x65,	/* TPM_COMMAND_CODE */
@@ -574,10 +573,10 @@ uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
 	const size_t sub_cap_offset = 18;
 	const size_t cap_offset = 14;
 	const size_t cap_size_offset = 10;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t cap_size;
-	uint32_t err;
+	u32 cap_size;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "sdd",
 				0, command, sizeof(command),
@@ -599,9 +598,9 @@ uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
 	return 0;
 }
 
-uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
+u32 tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
 {
-	const uint8_t command[22] = {
+	const u8 command[22] = {
 		0x0, 0xc1,		/* TPM_TAG */
 		0x0, 0x0, 0x0, 0x16,	/* parameter size */
 		0x0, 0x0, 0x0, 0x65,	/* TPM_COMMAND_CODE */
@@ -610,11 +609,11 @@ uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
 		0x0, 0x0, 0x1, 0x8,	/* subcap value */
 	};
 	const size_t data_size_offset = TPM_HEADER_SIZE;
-	const size_t data_offset = TPM_HEADER_SIZE + sizeof(uint32_t);
-	uint8_t response[COMMAND_BUFFER_SIZE];
+	const size_t data_offset = TPM_HEADER_SIZE + sizeof(u32);
+	u8 response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
-	uint32_t data_size;
+	u32 err;
+	u32 data_size;
 
 	err = tpm_sendrecv_command(command, response, &response_length);
 	if (err)
@@ -631,9 +630,9 @@ uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
 	return 0;
 }
 
-uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm)
+u32 tpm_get_permissions(u32 index, u32 *perm)
 {
-	const uint8_t command[22] = {
+	const u8 command[22] = {
 		0x0, 0xc1,		/* TPM_TAG */
 		0x0, 0x0, 0x0, 0x16,	/* parameter size */
 		0x0, 0x0, 0x0, 0x65,	/* TPM_COMMAND_CODE */
@@ -642,9 +641,9 @@ uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm)
 	};
 	const size_t index_offset = 18;
 	const size_t perm_offset = 60;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "d", 0, command, sizeof(command),
 			     index_offset, index))
@@ -660,9 +659,9 @@ uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm)
 }
 
 #ifdef CONFIG_TPM_FLUSH_RESOURCES
-uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type)
+u32 tpm_flush_specific(u32 key_handle, u32 resource_type)
 {
-	const uint8_t command[18] = {
+	const u8 command[18] = {
 		0x00, 0xc1,             /* TPM_TAG */
 		0x00, 0x00, 0x00, 0x12, /* parameter size */
 		0x00, 0x00, 0x00, 0xba, /* TPM_COMMAND_CODE */
@@ -671,9 +670,9 @@ uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type)
 	};
 	const size_t key_handle_offset = 10;
 	const size_t resource_type_offset = 14;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (pack_byte_string(buf, sizeof(buf), "sdd",
 			     0, command, sizeof(command),
@@ -702,12 +701,12 @@ uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type)
  * @param request_auth	pointer to the auth block of the request to be filled
  * @param auth		authentication data (HMAC key)
  */
-static uint32_t create_request_auth(const void *request, size_t request_len0,
-	size_t handles_len,
-	struct session_data *auth_session,
-	void *request_auth, const void *auth)
+static u32 create_request_auth(const void *request, size_t request_len0,
+			       size_t handles_len,
+			       struct session_data *auth_session,
+			       void *request_auth, const void *auth)
 {
-	uint8_t hmac_data[DIGEST_LENGTH * 3 + 1];
+	u8 hmac_data[DIGEST_LENGTH * 3 + 1];
 	sha1_context hash_ctx;
 	const size_t command_code_offset = 6;
 	const size_t auth_nonce_odd_offset = 4;
@@ -765,19 +764,18 @@ static uint32_t create_request_auth(const void *request, size_t request_len0,
  * @param response_auth	pointer to the auth block of the response to be verified
  * @param auth		authentication data (HMAC key)
  */
-static uint32_t verify_response_auth(uint32_t command_code,
-	const void *response, size_t response_len0,
-	size_t handles_len,
-	struct session_data *auth_session,
-	const void *response_auth, const void *auth)
+static u32 verify_response_auth(u32 command_code, const void *response,
+				size_t response_len0, size_t handles_len,
+				struct session_data *auth_session,
+				const void *response_auth, const void *auth)
 {
-	uint8_t hmac_data[DIGEST_LENGTH * 3 + 1];
-	uint8_t computed_auth[DIGEST_LENGTH];
+	u8 hmac_data[DIGEST_LENGTH * 3 + 1];
+	u8 computed_auth[DIGEST_LENGTH];
 	sha1_context hash_ctx;
 	const size_t return_code_offset = 6;
 	const size_t auth_continue_offset = 20;
 	const size_t auth_auth_offset = 21;
-	uint8_t auth_continue;
+	u8 auth_continue;
 
 	if (!auth_session || !auth_session->valid)
 		return TPM_AUTHFAIL;
@@ -798,7 +796,7 @@ static uint32_t verify_response_auth(uint32_t command_code,
 	sha1_finish(&hash_ctx, hmac_data);
 
 	memcpy(auth_session->nonce_even, response_auth, DIGEST_LENGTH);
-	auth_continue = ((uint8_t *)response_auth)[auth_continue_offset];
+	auth_continue = ((u8 *)response_auth)[auth_continue_offset];
 	if (pack_byte_string(hmac_data, sizeof(hmac_data), "ssb",
 			     DIGEST_LENGTH,
 			     response_auth,
@@ -820,9 +818,9 @@ static uint32_t verify_response_auth(uint32_t command_code,
 	return TPM_SUCCESS;
 }
 
-uint32_t tpm_terminate_auth_session(uint32_t auth_handle)
+u32 tpm_terminate_auth_session(u32 auth_handle)
 {
-	const uint8_t command[18] = {
+	const u8 command[18] = {
 		0x00, 0xc1,		/* TPM_TAG */
 		0x00, 0x00, 0x00, 0x00,	/* parameter size */
 		0x00, 0x00, 0x00, 0xba,	/* TPM_COMMAND_CODE */
@@ -830,7 +828,7 @@ uint32_t tpm_terminate_auth_session(uint32_t auth_handle)
 		0x00, 0x00, 0x00, 0x02,	/* TPM_RESSOURCE_TYPE */
 	};
 	const size_t req_handle_offset = TPM_REQUEST_HEADER_LENGTH;
-	uint8_t request[COMMAND_BUFFER_SIZE];
+	u8 request[COMMAND_BUFFER_SIZE];
 
 	if (pack_byte_string(request, sizeof(request), "sd",
 			     0, command, sizeof(command),
@@ -842,26 +840,26 @@ uint32_t tpm_terminate_auth_session(uint32_t auth_handle)
 	return tpm_sendrecv_command(request, NULL, NULL);
 }
 
-uint32_t tpm_end_oiap(void)
+u32 tpm_end_oiap(void)
 {
-	uint32_t err = TPM_SUCCESS;
+	u32 err = TPM_SUCCESS;
 	if (oiap_session.valid)
 		err = tpm_terminate_auth_session(oiap_session.handle);
 	return err;
 }
 
-uint32_t tpm_oiap(uint32_t *auth_handle)
+u32 tpm_oiap(u32 *auth_handle)
 {
-	const uint8_t command[10] = {
+	const u8 command[10] = {
 		0x00, 0xc1,		/* TPM_TAG */
 		0x00, 0x00, 0x00, 0x0a,	/* parameter size */
 		0x00, 0x00, 0x00, 0x0a,	/* TPM_COMMAND_CODE */
 	};
 	const size_t res_auth_handle_offset = TPM_RESPONSE_HEADER_LENGTH;
 	const size_t res_nonce_even_offset = TPM_RESPONSE_HEADER_LENGTH + 4;
-	uint8_t response[COMMAND_BUFFER_SIZE];
+	u8 response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (oiap_session.valid)
 		tpm_terminate_auth_session(oiap_session.handle);
@@ -872,7 +870,7 @@ uint32_t tpm_oiap(uint32_t *auth_handle)
 	if (unpack_byte_string(response, response_length, "ds",
 			       res_auth_handle_offset, &oiap_session.handle,
 			       res_nonce_even_offset, &oiap_session.nonce_even,
-			       (uint32_t)DIGEST_LENGTH))
+			       (u32)DIGEST_LENGTH))
 		return TPM_LIB_ERROR;
 	oiap_session.valid = 1;
 	if (auth_handle)
@@ -880,12 +878,10 @@ uint32_t tpm_oiap(uint32_t *auth_handle)
 	return 0;
 }
 
-uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
-		const void *key, size_t key_length,
-		const void *parent_key_usage_auth,
-		uint32_t *key_handle)
+u32 tpm_load_key2_oiap(u32 parent_handle, const void *key, size_t key_length,
+		       const void *parent_key_usage_auth, u32 *key_handle)
 {
-	const uint8_t command[14] = {
+	const u8 command[14] = {
 		0x00, 0xc2,		/* TPM_TAG */
 		0x00, 0x00, 0x00, 0x00,	/* parameter size */
 		0x00, 0x00, 0x00, 0x41,	/* TPM_COMMAND_CODE */
@@ -895,11 +891,11 @@ uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
 	const size_t req_parent_handle_offset = TPM_REQUEST_HEADER_LENGTH;
 	const size_t req_key_offset = TPM_REQUEST_HEADER_LENGTH + 4;
 	const size_t res_handle_offset = TPM_RESPONSE_HEADER_LENGTH;
-	uint8_t request[sizeof(command) + TPM_KEY12_MAX_LENGTH
-			+ TPM_REQUEST_AUTH_LENGTH];
-	uint8_t response[COMMAND_BUFFER_SIZE];
+	u8 request[sizeof(command) + TPM_KEY12_MAX_LENGTH +
+		   TPM_REQUEST_AUTH_LENGTH];
+	u8 response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (!oiap_session.valid) {
 		err = tpm_oiap(NULL);
@@ -946,10 +942,10 @@ uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
 	return 0;
 }
 
-uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
-			void *pubkey, size_t *pubkey_len)
+u32 tpm_get_pub_key_oiap(u32 key_handle, const void *usage_auth, void *pubkey,
+			 size_t *pubkey_len)
 {
-	const uint8_t command[14] = {
+	const u8 command[14] = {
 		0x00, 0xc2,		/* TPM_TAG */
 		0x00, 0x00, 0x00, 0x00,	/* parameter size */
 		0x00, 0x00, 0x00, 0x21,	/* TPM_COMMAND_CODE */
@@ -958,11 +954,11 @@ uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
 	const size_t req_size_offset = 2;
 	const size_t req_key_handle_offset = TPM_REQUEST_HEADER_LENGTH;
 	const size_t res_pubkey_offset = TPM_RESPONSE_HEADER_LENGTH;
-	uint8_t request[sizeof(command) + TPM_REQUEST_AUTH_LENGTH];
-	uint8_t response[TPM_RESPONSE_HEADER_LENGTH + TPM_PUBKEY_MAX_LENGTH
-			+ TPM_RESPONSE_AUTH_LENGTH];
+	u8 request[sizeof(command) + TPM_REQUEST_AUTH_LENGTH];
+	u8 response[TPM_RESPONSE_HEADER_LENGTH + TPM_PUBKEY_MAX_LENGTH +
+		    TPM_RESPONSE_AUTH_LENGTH];
 	size_t response_length = sizeof(response);
-	uint32_t err;
+	u32 err;
 
 	if (!oiap_session.valid) {
 		err = tpm_oiap(NULL);
@@ -972,7 +968,7 @@ uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
 	if (pack_byte_string(request, sizeof(request), "sdd",
 			     0, command, sizeof(command),
 			     req_size_offset,
-			     (uint32_t)(sizeof(command)
+			     (u32)(sizeof(command)
 			     + TPM_REQUEST_AUTH_LENGTH),
 			     req_key_handle_offset, key_handle
 		))
@@ -1010,15 +1006,15 @@ uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
 }
 
 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
-uint32_t tpm_find_key_sha1(const uint8_t auth[20], const uint8_t
-			   pubkey_digest[20], uint32_t *handle)
+u32 tpm_find_key_sha1(const u8 auth[20], const u8 pubkey_digest[20],
+		      u32 *handle)
 {
-	uint16_t key_count;
-	uint32_t key_handles[10];
-	uint8_t buf[288];
-	uint8_t *ptr;
-	uint32_t err;
-	uint8_t digest[20];
+	u16 key_count;
+	u32 key_handles[10];
+	u8 buf[288];
+	u8 *ptr;
+	u32 err;
+	u8 digest[20];
 	size_t buf_len;
 	unsigned int i;
 
@@ -1051,9 +1047,9 @@ uint32_t tpm_find_key_sha1(const uint8_t auth[20], const uint8_t
 
 #endif /* CONFIG_TPM_AUTH_SESSIONS */
 
-uint32_t tpm_get_random(void *data, uint32_t count)
+u32 tpm_get_random(void *data, u32 count)
 {
-	const uint8_t command[14] = {
+	const u8 command[14] = {
 		0x0, 0xc1,		/* TPM_TAG */
 		0x0, 0x0, 0x0, 0xe,	/* parameter size */
 		0x0, 0x0, 0x0, 0x46,	/* TPM_COMMAND_CODE */
@@ -1061,15 +1057,15 @@ uint32_t tpm_get_random(void *data, uint32_t count)
 	const size_t length_offset = 10;
 	const size_t data_size_offset = 10;
 	const size_t data_offset = 14;
-	uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
+	u8 buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 	size_t response_length = sizeof(response);
-	uint32_t data_size;
-	uint8_t *out = data;
+	u32 data_size;
+	u8 *out = data;
 
 	while (count > 0) {
-		uint32_t this_bytes = min((size_t)count,
-					  sizeof(response) - data_offset);
-		uint32_t err;
+		u32 this_bytes = min((size_t)count,
+				     sizeof(response) - data_offset);
+		u32 err;
 
 		if (pack_byte_string(buf, sizeof(buf), "sd",
 				     0, command, sizeof(command),