tpm: align arguments with open parenthesis

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>

diff --git a/cmd/tpm.c b/cmd/tpm.c
index a8d6607f33bc23eedd7e6e81b11c6b25752f573d..e0cd8410f5367a9501608892e7bf4377e3c0b92d 100644 (file)
--- a/cmd/tpm.c
+++ b/cmd/tpm.c
@@ -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, "", ""),

diff --git a/lib/tpm.c b/lib/tpm.c
index 172541effbca5a6dc0bea56b74710b30ff3955b8..931b45301d6e9ffde82b29beb4eba7e223a60ca5 100644 (file)
--- a/lib/tpm.c
+++ b/lib/tpm.c
@@ -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;