Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

tpm: align arguments with open parenthesis

Browse Source 
Fix following checkpatch.pl issue in TPM-related code:

    CHECK: Alignment should match open parenthesis

Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
Reviewed-by: Tom Rini <trini@konsulko.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
lime2-spi
Miquel Raynal 6 years ago committed by Tom Rini
parent b9804e5bf3
commit c617918764
2 changed files with 110 additions and 110 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 120
      cmd/tpm.c
  2. 100
      lib/tpm.c

120
cmd/tpm.c
Unescape View File

@ -237,8 +237,8 @@ static int type_string_write_vars(const char *type_str, u8 *data,
return 0;
}
static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
enum tpm_startup_type mode;
@ -258,8 +258,8 @@ static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag,
return report_return_code(tpm_startup(mode));
}
static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, perm, size;
@ -272,8 +272,8 @@ static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag,
return report_return_code(tpm_nv_define_space(index, perm, size));
}
static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, count, rc;
void *data;
@ -293,8 +293,8 @@ static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, rc;
size_t count;
@ -315,8 +315,8 @@ static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, rc;
u8 in_digest[20], out_digest[20];
@ -338,8 +338,8 @@ static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, count, rc;
void *data;
@ -359,8 +359,8 @@ static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u16 presence;
@ -371,8 +371,8 @@ static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag,
return report_return_code(tpm_tsc_physical_presence(presence));
}
static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 count, rc;
void *data;
@ -391,8 +391,8 @@ static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u8 state;
@ -403,8 +403,8 @@ static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag,
return report_return_code(tpm_physical_set_deactivated(state));
}
static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 cap_area, sub_cap, rc;
void *cap;
@ -428,7 +428,7 @@ static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag,
#define TPM_COMMAND_NO_ARG(cmd) \
static int do_##cmd(cmd_tbl_t *cmdtp, int flag, \
int argc, char * const argv[]) \
int argc, char * const argv[]) \
{ \
if (argc != 1) \
return CMD_RET_USAGE; \
@ -455,8 +455,7 @@ static int get_tpm(struct udevice **devp)
return 0;
}
static int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc,
char *const argv[])
static int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *dev;
char buf[80];
@ -475,8 +474,8 @@ static int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc,
return 0;
}
static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
struct udevice *dev;
void *command;
@ -504,8 +503,8 @@ static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag,
return report_return_code(rc);
}
static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, perm, size;
@ -522,8 +521,8 @@ static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag,
return report_return_code(tpm_nv_define_space(index, perm, size));
}
static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, count, err;
void *data;
@ -551,8 +550,8 @@ static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag,
return report_return_code(err);
}
static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 index, count, err;
void *data;
@ -581,8 +580,8 @@ static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag,
#ifdef CONFIG_TPM_AUTH_SESSIONS
static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 auth_handle, err;
@ -630,8 +629,8 @@ static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char *
}
#endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 parent_handle, key_len, key_handle, err;
u8 usage_auth[DIGEST_LENGTH];
@ -648,15 +647,15 @@ static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag,
parse_byte_string(argv[4], usage_auth, NULL);
err = tpm_load_key2_oiap(parent_handle, key, key_len, usage_auth,
&key_handle);
&key_handle);
if (!err)
printf("Key handle is 0x%x\n", key_handle);
return report_return_code(err);
}
static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
u32 key_handle, err;
u8 usage_auth[DIGEST_LENGTH];
@ -671,8 +670,8 @@ static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag,
return CMD_RET_FAILURE;
parse_byte_string(argv[2], usage_auth, NULL);
err = tpm_get_pub_key_oiap(key_handle, usage_auth,
pub_key_buffer, &pub_key_len);
err = tpm_get_pub_key_oiap(key_handle, usage_auth, pub_key_buffer,
&pub_key_len);
if (!err) {
printf("dump of received pub key structure:\n");
print_byte_string(pub_key_buffer, pub_key_len);
@ -818,46 +817,45 @@ static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc,
static cmd_tbl_t tpm_commands[] = {
U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
U_BOOT_CMD_MKENT(init, 0, 1,
do_tpm_init, "", ""),
U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
U_BOOT_CMD_MKENT(startup, 0, 1,
do_tpm_startup, "", ""),
do_tpm_startup, "", ""),
U_BOOT_CMD_MKENT(self_test_full, 0, 1,
do_tpm_self_test_full, "", ""),
do_tpm_self_test_full, "", ""),
U_BOOT_CMD_MKENT(continue_self_test, 0, 1,
do_tpm_continue_self_test, "", ""),
do_tpm_continue_self_test, "", ""),
U_BOOT_CMD_MKENT(force_clear, 0, 1,
do_tpm_force_clear, "", ""),
do_tpm_force_clear, "", ""),
U_BOOT_CMD_MKENT(physical_enable, 0, 1,
do_tpm_physical_enable, "", ""),
do_tpm_physical_enable, "", ""),
U_BOOT_CMD_MKENT(physical_disable, 0, 1,
do_tpm_physical_disable, "", ""),
do_tpm_physical_disable, "", ""),
U_BOOT_CMD_MKENT(nv_define_space, 0, 1,
do_tpm_nv_define_space, "", ""),
do_tpm_nv_define_space, "", ""),
U_BOOT_CMD_MKENT(nv_read_value, 0, 1,
do_tpm_nv_read_value, "", ""),
do_tpm_nv_read_value, "", ""),
U_BOOT_CMD_MKENT(nv_write_value, 0, 1,
do_tpm_nv_write_value, "", ""),
do_tpm_nv_write_value, "", ""),
U_BOOT_CMD_MKENT(extend, 0, 1,
do_tpm_extend, "", ""),
do_tpm_extend, "", ""),
U_BOOT_CMD_MKENT(pcr_read, 0, 1,
do_tpm_pcr_read, "", ""),
do_tpm_pcr_read, "", ""),
U_BOOT_CMD_MKENT(tsc_physical_presence, 0, 1,
do_tpm_tsc_physical_presence, "", ""),
do_tpm_tsc_physical_presence, "", ""),
U_BOOT_CMD_MKENT(read_pubek, 0, 1,
do_tpm_read_pubek, "", ""),
do_tpm_read_pubek, "", ""),
U_BOOT_CMD_MKENT(physical_set_deactivated, 0, 1,
do_tpm_physical_set_deactivated, "", ""),
do_tpm_physical_set_deactivated, "", ""),
U_BOOT_CMD_MKENT(get_capability, 0, 1,
do_tpm_get_capability, "", ""),
do_tpm_get_capability, "", ""),
U_BOOT_CMD_MKENT(raw_transfer, 0, 1,
do_tpm_raw_transfer, "", ""),
do_tpm_raw_transfer, "", ""),
U_BOOT_CMD_MKENT(nv_define, 0, 1,
do_tpm_nv_define, "", ""),
do_tpm_nv_define, "", ""),
U_BOOT_CMD_MKENT(nv_read, 0, 1,
do_tpm_nv_read, "", ""),
do_tpm_nv_read, "", ""),
U_BOOT_CMD_MKENT(nv_write, 0, 1,
do_tpm_nv_write, "", ""),
do_tpm_nv_write, "", ""),
#ifdef CONFIG_TPM_AUTH_SESSIONS
U_BOOT_CMD_MKENT(oiap, 0, 1,
do_tpm_oiap, "", ""),

100
lib/tpm.c
Unescape View File

@ -280,8 +280,8 @@ u32 tpm_startup(enum tpm_startup_type mode)
u8 buf[COMMAND_BUFFER_SIZE];
if (pack_byte_string(buf, sizeof(buf), "sw",
0, command, sizeof(command),
mode_offset, mode))
0, command, sizeof(command),
mode_offset, mode))
return TPM_LIB_ERROR;
return tpm_sendrecv_command(buf, NULL, NULL);
@ -337,10 +337,10 @@ u32 tpm_nv_define_space(u32 index, u32 perm, u32 size)
u8 buf[COMMAND_BUFFER_SIZE];
if (pack_byte_string(buf, sizeof(buf), "sddd",
0, command, sizeof(command),
index_offset, index,
perm_offset, perm,
size_offset, size))
0, command, sizeof(command),
index_offset, index,
perm_offset, perm,
size_offset, size))
return TPM_LIB_ERROR;
return tpm_sendrecv_command(buf, NULL, NULL);
@ -361,20 +361,20 @@ u32 tpm_nv_read_value(u32 index, void *data, u32 count)
u32 err;
if (pack_byte_string(buf, sizeof(buf), "sdd",
0, command, sizeof(command),
index_offset, index,
length_offset, count))
0, command, sizeof(command),
index_offset, index,
length_offset, count))
return TPM_LIB_ERROR;
err = tpm_sendrecv_command(buf, response, &response_length);
if (err)
return err;
if (unpack_byte_string(response, response_length, "d",
data_size_offset, &data_size))
data_size_offset, &data_size))
return TPM_LIB_ERROR;
if (data_size > count)
return TPM_LIB_ERROR;
if (unpack_byte_string(response, response_length, "s",
data_offset, data, data_size))
data_offset, data, data_size))
return TPM_LIB_ERROR;
return 0;
@ -397,11 +397,11 @@ u32 tpm_nv_write_value(u32 index, const void *data, u32 length)
u32 err;
if (pack_byte_string(buf, sizeof(buf), "sddds",
0, command, sizeof(command),
command_size_offset, total_length,
index_offset, index,
length_offset, length,
data_offset, data, length))
0, command, sizeof(command),
command_size_offset, total_length,
index_offset, index,
length_offset, length,
data_offset, data, length))
return TPM_LIB_ERROR;
err = tpm_sendrecv_command(buf, response, &response_length);
if (err)
@ -424,18 +424,18 @@ u32 tpm_extend(u32 index, const void *in_digest, void *out_digest)
u32 err;
if (pack_byte_string(buf, sizeof(buf), "sds",
0, command, sizeof(command),
index_offset, index,
in_digest_offset, in_digest,
PCR_DIGEST_LENGTH))
0, command, sizeof(command),
index_offset, index,
in_digest_offset, in_digest,
PCR_DIGEST_LENGTH))
return TPM_LIB_ERROR;
err = tpm_sendrecv_command(buf, response, &response_length);
if (err)
return err;
if (unpack_byte_string(response, response_length, "s",
out_digest_offset, out_digest,
PCR_DIGEST_LENGTH))
out_digest_offset, out_digest,
PCR_DIGEST_LENGTH))
return TPM_LIB_ERROR;
return 0;
@ -456,14 +456,14 @@ u32 tpm_pcr_read(u32 index, void *data, size_t count)
return TPM_LIB_ERROR;
if (pack_byte_string(buf, sizeof(buf), "sd",
0, command, sizeof(command),
index_offset, index))
0, command, sizeof(command),
index_offset, index))
return TPM_LIB_ERROR;
err = tpm_sendrecv_command(buf, response, &response_length);
if (err)
return err;
if (unpack_byte_string(response, response_length, "s",
out_digest_offset, data, PCR_DIGEST_LENGTH))
out_digest_offset, data, PCR_DIGEST_LENGTH))
return TPM_LIB_ERROR;
return 0;
@ -478,8 +478,8 @@ u32 tpm_tsc_physical_presence(u16 presence)
u8 buf[COMMAND_BUFFER_SIZE];
if (pack_byte_string(buf, sizeof(buf), "sw",
0, command, sizeof(command),
presence_offset, presence))
0, command, sizeof(command),
presence_offset, presence))
return TPM_LIB_ERROR;
return tpm_sendrecv_command(buf, NULL, NULL);
@ -502,7 +502,7 @@ u32 tpm_read_pubek(void *data, size_t count)
if (err)
return err;
if (unpack_byte_string(response, response_length, "d",
response_size_offset, &data_size))
response_size_offset, &data_size))
return TPM_LIB_ERROR;
if (data_size < header_and_checksum_size)
return TPM_LIB_ERROR;
@ -510,7 +510,7 @@ u32 tpm_read_pubek(void *data, size_t count)
if (data_size > count)
return TPM_LIB_ERROR;
if (unpack_byte_string(response, response_length, "s",
data_offset, data, data_size))
data_offset, data, data_size))
return TPM_LIB_ERROR;
return 0;
@ -552,8 +552,8 @@ u32 tpm_physical_set_deactivated(u8 state)
u8 buf[COMMAND_BUFFER_SIZE];
if (pack_byte_string(buf, sizeof(buf), "sb",
0, command, sizeof(command),
state_offset, state))
0, command, sizeof(command),
state_offset, state))
return TPM_LIB_ERROR;
return tpm_sendrecv_command(buf, NULL, NULL);
@ -579,20 +579,20 @@ u32 tpm_get_capability(u32 cap_area, u32 sub_cap, void *cap, size_t count)
u32 err;
if (pack_byte_string(buf, sizeof(buf), "sdd",
0, command, sizeof(command),
cap_area_offset, cap_area,
sub_cap_offset, sub_cap))
0, command, sizeof(command),
cap_area_offset, cap_area,
sub_cap_offset, sub_cap))
return TPM_LIB_ERROR;
err = tpm_sendrecv_command(buf, response, &response_length);
if (err)
return err;
if (unpack_byte_string(response, response_length, "d",
cap_size_offset, &cap_size))
cap_size_offset, &cap_size))
return TPM_LIB_ERROR;
if (cap_size > response_length || cap_size > count)
return TPM_LIB_ERROR;
if (unpack_byte_string(response, response_length, "s",
cap_offset, cap, cap_size))
cap_offset, cap, cap_size))
return TPM_LIB_ERROR;
return 0;
@ -913,9 +913,9 @@ u32 tpm_load_key2_oiap(u32 parent_handle, const void *key, size_t key_length,
return TPM_LIB_ERROR;
err = create_request_auth(request, sizeof(command) + key_length, 4,
&oiap_session,
request + sizeof(command) + key_length,
parent_key_usage_auth);
&oiap_session,
request + sizeof(command) + key_length,
parent_key_usage_auth);
if (err)
return err;
err = tpm_sendrecv_command(request, response, &response_length);
@ -926,10 +926,11 @@ u32 tpm_load_key2_oiap(u32 parent_handle, const void *key, size_t key_length,
}
err = verify_response_auth(0x00000041, response,
response_length - TPM_RESPONSE_AUTH_LENGTH,
4, &oiap_session,
response + response_length - TPM_RESPONSE_AUTH_LENGTH,
parent_key_usage_auth);
response_length - TPM_RESPONSE_AUTH_LENGTH,
4, &oiap_session,
response + response_length -
TPM_RESPONSE_AUTH_LENGTH,
parent_key_usage_auth);
if (err)
return err;
@ -974,7 +975,7 @@ u32 tpm_get_pub_key_oiap(u32 key_handle, const void *usage_auth, void *pubkey,
))
return TPM_LIB_ERROR;
err = create_request_auth(request, sizeof(command), 4, &oiap_session,
request + sizeof(command), usage_auth);
request + sizeof(command), usage_auth);
if (err)
return err;
err = tpm_sendrecv_command(request, response, &response_length);
@ -984,16 +985,17 @@ u32 tpm_get_pub_key_oiap(u32 key_handle, const void *usage_auth, void *pubkey,
return err;
}
err = verify_response_auth(0x00000021, response,
response_length - TPM_RESPONSE_AUTH_LENGTH,
0, &oiap_session,
response + response_length - TPM_RESPONSE_AUTH_LENGTH,
usage_auth);
response_length - TPM_RESPONSE_AUTH_LENGTH,
0, &oiap_session,
response + response_length -
TPM_RESPONSE_AUTH_LENGTH,
usage_auth);
if (err)
return err;
if (pubkey) {
if ((response_length - TPM_RESPONSE_HEADER_LENGTH
- TPM_RESPONSE_AUTH_LENGTH) > *pubkey_len)
- TPM_RESPONSE_AUTH_LENGTH) > *pubkey_len)
return TPM_LIB_ERROR;
*pubkey_len = response_length - TPM_RESPONSE_HEADER_LENGTH
- TPM_RESPONSE_AUTH_LENGTH;

Write Preview
Loading…
Cancel
Save