1 /* Microsoft Reference Implementation for TPM 2.0 2 * 3 * The copyright in this software is being made available under the BSD License, 4 * included below. This software may be subject to other third party and 5 * contributor rights, including patent rights, and no such rights are granted 6 * under this license. 7 * 8 * Copyright (c) Microsoft Corporation 9 * 10 * All rights reserved. 11 * 12 * BSD License 13 * 14 * Redistribution and use in source and binary forms, with or without modification, 15 * are permitted provided that the following conditions are met: 16 * 17 * Redistributions of source code must retain the above copyright notice, this list 18 * of conditions and the following disclaimer. 19 * 20 * Redistributions in binary form must reproduce the above copyright notice, this 21 * list of conditions and the following disclaimer in the documentation and/or 22 * other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 28 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 31 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /*(Auto-generated) 36 * Created by TpmStructures; Version 4.4 Mar 26, 2019 37 * Date: Mar 6, 2020 Time: 01:50:09PM 38 */ 39 40 // This file should only be included by CommandCodeAttibutes.c 41 #ifdef _COMMAND_TABLE_DISPATCH_ 42 43 44 // Define the stop value 45 #define END_OF_LIST 0xff 46 #define ADD_FLAG 0x80 47 48 // These macros provide some variability in how the data is encoded. They also make 49 // the lines a little shorter. ;-) 50 #if TABLE_DRIVEN_MARSHAL 51 # define UNMARSHAL_DISPATCH(name) (marshalIndex_t)name##_MARSHAL_REF 52 # define MARSHAL_DISPATCH(name) (marshalIndex_t)name##_MARSHAL_REF 53 # define _UNMARSHAL_T_ marshalIndex_t 54 # define _MARSHAL_T_ marshalIndex_t 55 #else 56 # define UNMARSHAL_DISPATCH(name) (UNMARSHAL_t)name##_Unmarshal 57 # define MARSHAL_DISPATCH(name) (MARSHAL_t)name##_Marshal 58 # define _UNMARSHAL_T_ UNMARSHAL_t 59 # define _MARSHAL_T_ MARSHAL_t 60 #endif 61 62 63 // The unmarshalArray contains the dispatch functions for the unmarshaling code. 64 // The defines in this array are used to make it easier to cross reference the 65 // unmarshaling values in the types array of each command 66 67 const _UNMARSHAL_T_ unmarshalArray[] = { 68 #define TPMI_DH_CONTEXT_H_UNMARSHAL 0 69 UNMARSHAL_DISPATCH(TPMI_DH_CONTEXT), 70 #define TPMI_RH_AC_H_UNMARSHAL (TPMI_DH_CONTEXT_H_UNMARSHAL + 1) 71 UNMARSHAL_DISPATCH(TPMI_RH_AC), 72 #define TPMI_RH_ACT_H_UNMARSHAL (TPMI_RH_AC_H_UNMARSHAL + 1) 73 UNMARSHAL_DISPATCH(TPMI_RH_ACT), 74 #define TPMI_RH_CLEAR_H_UNMARSHAL (TPMI_RH_ACT_H_UNMARSHAL + 1) 75 UNMARSHAL_DISPATCH(TPMI_RH_CLEAR), 76 #define TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL (TPMI_RH_CLEAR_H_UNMARSHAL + 1) 77 UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY_AUTH), 78 #define TPMI_RH_HIERARCHY_POLICY_H_UNMARSHAL \ 79 (TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL + 1) 80 UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY_POLICY), 81 #define TPMI_RH_LOCKOUT_H_UNMARSHAL \ 82 (TPMI_RH_HIERARCHY_POLICY_H_UNMARSHAL + 1) 83 UNMARSHAL_DISPATCH(TPMI_RH_LOCKOUT), 84 #define TPMI_RH_NV_AUTH_H_UNMARSHAL (TPMI_RH_LOCKOUT_H_UNMARSHAL + 1) 85 UNMARSHAL_DISPATCH(TPMI_RH_NV_AUTH), 86 #define TPMI_RH_NV_INDEX_H_UNMARSHAL (TPMI_RH_NV_AUTH_H_UNMARSHAL + 1) 87 UNMARSHAL_DISPATCH(TPMI_RH_NV_INDEX), 88 #define TPMI_RH_PLATFORM_H_UNMARSHAL (TPMI_RH_NV_INDEX_H_UNMARSHAL + 1) 89 UNMARSHAL_DISPATCH(TPMI_RH_PLATFORM), 90 #define TPMI_RH_PROVISION_H_UNMARSHAL (TPMI_RH_PLATFORM_H_UNMARSHAL + 1) 91 UNMARSHAL_DISPATCH(TPMI_RH_PROVISION), 92 #define TPMI_SH_HMAC_H_UNMARSHAL (TPMI_RH_PROVISION_H_UNMARSHAL + 1) 93 UNMARSHAL_DISPATCH(TPMI_SH_HMAC), 94 #define TPMI_SH_POLICY_H_UNMARSHAL (TPMI_SH_HMAC_H_UNMARSHAL + 1) 95 UNMARSHAL_DISPATCH(TPMI_SH_POLICY), 96 // HANDLE_FIRST_FLAG_TYPE is the first handle that needs a flag when called. 97 #define HANDLE_FIRST_FLAG_TYPE (TPMI_SH_POLICY_H_UNMARSHAL + 1) 98 #define TPMI_DH_ENTITY_H_UNMARSHAL (TPMI_SH_POLICY_H_UNMARSHAL + 1) 99 UNMARSHAL_DISPATCH(TPMI_DH_ENTITY), 100 #define TPMI_DH_OBJECT_H_UNMARSHAL (TPMI_DH_ENTITY_H_UNMARSHAL + 1) 101 UNMARSHAL_DISPATCH(TPMI_DH_OBJECT), 102 #define TPMI_DH_PARENT_H_UNMARSHAL (TPMI_DH_OBJECT_H_UNMARSHAL + 1) 103 UNMARSHAL_DISPATCH(TPMI_DH_PARENT), 104 #define TPMI_DH_PCR_H_UNMARSHAL (TPMI_DH_PARENT_H_UNMARSHAL + 1) 105 UNMARSHAL_DISPATCH(TPMI_DH_PCR), 106 #define TPMI_RH_ENDORSEMENT_H_UNMARSHAL (TPMI_DH_PCR_H_UNMARSHAL + 1) 107 UNMARSHAL_DISPATCH(TPMI_RH_ENDORSEMENT), 108 #define TPMI_RH_HIERARCHY_H_UNMARSHAL \ 109 (TPMI_RH_ENDORSEMENT_H_UNMARSHAL + 1) 110 UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY), 111 // PARAMETER_FIRST_TYPE marks the end of the handle list. 112 #define PARAMETER_FIRST_TYPE (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1) 113 #define TPM2B_DATA_P_UNMARSHAL (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1) 114 UNMARSHAL_DISPATCH(TPM2B_DATA), 115 #define TPM2B_DIGEST_P_UNMARSHAL (TPM2B_DATA_P_UNMARSHAL + 1) 116 UNMARSHAL_DISPATCH(TPM2B_DIGEST), 117 #define TPM2B_ECC_PARAMETER_P_UNMARSHAL (TPM2B_DIGEST_P_UNMARSHAL + 1) 118 UNMARSHAL_DISPATCH(TPM2B_ECC_PARAMETER), 119 #define TPM2B_ECC_POINT_P_UNMARSHAL \ 120 (TPM2B_ECC_PARAMETER_P_UNMARSHAL + 1) 121 UNMARSHAL_DISPATCH(TPM2B_ECC_POINT), 122 #define TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL (TPM2B_ECC_POINT_P_UNMARSHAL + 1) 123 UNMARSHAL_DISPATCH(TPM2B_ENCRYPTED_SECRET), 124 #define TPM2B_EVENT_P_UNMARSHAL \ 125 (TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL + 1) 126 UNMARSHAL_DISPATCH(TPM2B_EVENT), 127 #define TPM2B_ID_OBJECT_P_UNMARSHAL (TPM2B_EVENT_P_UNMARSHAL + 1) 128 UNMARSHAL_DISPATCH(TPM2B_ID_OBJECT), 129 #define TPM2B_IV_P_UNMARSHAL (TPM2B_ID_OBJECT_P_UNMARSHAL + 1) 130 UNMARSHAL_DISPATCH(TPM2B_IV), 131 #define TPM2B_MAX_BUFFER_P_UNMARSHAL (TPM2B_IV_P_UNMARSHAL + 1) 132 UNMARSHAL_DISPATCH(TPM2B_MAX_BUFFER), 133 #define TPM2B_MAX_NV_BUFFER_P_UNMARSHAL (TPM2B_MAX_BUFFER_P_UNMARSHAL + 1) 134 UNMARSHAL_DISPATCH(TPM2B_MAX_NV_BUFFER), 135 #define TPM2B_NAME_P_UNMARSHAL \ 136 (TPM2B_MAX_NV_BUFFER_P_UNMARSHAL + 1) 137 UNMARSHAL_DISPATCH(TPM2B_NAME), 138 #define TPM2B_NV_PUBLIC_P_UNMARSHAL (TPM2B_NAME_P_UNMARSHAL + 1) 139 UNMARSHAL_DISPATCH(TPM2B_NV_PUBLIC), 140 #define TPM2B_PRIVATE_P_UNMARSHAL (TPM2B_NV_PUBLIC_P_UNMARSHAL + 1) 141 UNMARSHAL_DISPATCH(TPM2B_PRIVATE), 142 #define TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL (TPM2B_PRIVATE_P_UNMARSHAL + 1) 143 UNMARSHAL_DISPATCH(TPM2B_PUBLIC_KEY_RSA), 144 #define TPM2B_SENSITIVE_P_UNMARSHAL \ 145 (TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL + 1) 146 UNMARSHAL_DISPATCH(TPM2B_SENSITIVE), 147 #define TPM2B_SENSITIVE_CREATE_P_UNMARSHAL (TPM2B_SENSITIVE_P_UNMARSHAL + 1) 148 UNMARSHAL_DISPATCH(TPM2B_SENSITIVE_CREATE), 149 #define TPM2B_SENSITIVE_DATA_P_UNMARSHAL \ 150 (TPM2B_SENSITIVE_CREATE_P_UNMARSHAL + 1) 151 UNMARSHAL_DISPATCH(TPM2B_SENSITIVE_DATA), 152 #define TPM2B_TEMPLATE_P_UNMARSHAL \ 153 (TPM2B_SENSITIVE_DATA_P_UNMARSHAL + 1) 154 UNMARSHAL_DISPATCH(TPM2B_TEMPLATE), 155 #define TPM2B_TIMEOUT_P_UNMARSHAL (TPM2B_TEMPLATE_P_UNMARSHAL + 1) 156 UNMARSHAL_DISPATCH(TPM2B_TIMEOUT), 157 #define TPMI_DH_CONTEXT_P_UNMARSHAL (TPM2B_TIMEOUT_P_UNMARSHAL + 1) 158 UNMARSHAL_DISPATCH(TPMI_DH_CONTEXT), 159 #define TPMI_DH_PERSISTENT_P_UNMARSHAL (TPMI_DH_CONTEXT_P_UNMARSHAL + 1) 160 UNMARSHAL_DISPATCH(TPMI_DH_PERSISTENT), 161 #define TPMI_ECC_CURVE_P_UNMARSHAL (TPMI_DH_PERSISTENT_P_UNMARSHAL + 1) 162 UNMARSHAL_DISPATCH(TPMI_ECC_CURVE), 163 #define TPMI_YES_NO_P_UNMARSHAL (TPMI_ECC_CURVE_P_UNMARSHAL + 1) 164 UNMARSHAL_DISPATCH(TPMI_YES_NO), 165 #define TPML_ALG_P_UNMARSHAL (TPMI_YES_NO_P_UNMARSHAL + 1) 166 UNMARSHAL_DISPATCH(TPML_ALG), 167 #define TPML_CC_P_UNMARSHAL (TPML_ALG_P_UNMARSHAL + 1) 168 UNMARSHAL_DISPATCH(TPML_CC), 169 #define TPML_DIGEST_P_UNMARSHAL (TPML_CC_P_UNMARSHAL + 1) 170 UNMARSHAL_DISPATCH(TPML_DIGEST), 171 #define TPML_DIGEST_VALUES_P_UNMARSHAL (TPML_DIGEST_P_UNMARSHAL + 1) 172 UNMARSHAL_DISPATCH(TPML_DIGEST_VALUES), 173 #define TPML_PCR_SELECTION_P_UNMARSHAL (TPML_DIGEST_VALUES_P_UNMARSHAL + 1) 174 UNMARSHAL_DISPATCH(TPML_PCR_SELECTION), 175 #define TPMS_CONTEXT_P_UNMARSHAL (TPML_PCR_SELECTION_P_UNMARSHAL + 1) 176 UNMARSHAL_DISPATCH(TPMS_CONTEXT), 177 #define TPMT_PUBLIC_PARMS_P_UNMARSHAL (TPMS_CONTEXT_P_UNMARSHAL + 1) 178 UNMARSHAL_DISPATCH(TPMT_PUBLIC_PARMS), 179 #define TPMT_TK_AUTH_P_UNMARSHAL (TPMT_PUBLIC_PARMS_P_UNMARSHAL + 1) 180 UNMARSHAL_DISPATCH(TPMT_TK_AUTH), 181 #define TPMT_TK_CREATION_P_UNMARSHAL (TPMT_TK_AUTH_P_UNMARSHAL + 1) 182 UNMARSHAL_DISPATCH(TPMT_TK_CREATION), 183 #define TPMT_TK_HASHCHECK_P_UNMARSHAL (TPMT_TK_CREATION_P_UNMARSHAL + 1) 184 UNMARSHAL_DISPATCH(TPMT_TK_HASHCHECK), 185 #define TPMT_TK_VERIFIED_P_UNMARSHAL (TPMT_TK_HASHCHECK_P_UNMARSHAL + 1) 186 UNMARSHAL_DISPATCH(TPMT_TK_VERIFIED), 187 #define TPM_AT_P_UNMARSHAL (TPMT_TK_VERIFIED_P_UNMARSHAL + 1) 188 UNMARSHAL_DISPATCH(TPM_AT), 189 #define TPM_CAP_P_UNMARSHAL (TPM_AT_P_UNMARSHAL + 1) 190 UNMARSHAL_DISPATCH(TPM_CAP), 191 #define TPM_CLOCK_ADJUST_P_UNMARSHAL (TPM_CAP_P_UNMARSHAL + 1) 192 UNMARSHAL_DISPATCH(TPM_CLOCK_ADJUST), 193 #define TPM_EO_P_UNMARSHAL (TPM_CLOCK_ADJUST_P_UNMARSHAL + 1) 194 UNMARSHAL_DISPATCH(TPM_EO), 195 #define TPM_SE_P_UNMARSHAL (TPM_EO_P_UNMARSHAL + 1) 196 UNMARSHAL_DISPATCH(TPM_SE), 197 #define TPM_SU_P_UNMARSHAL (TPM_SE_P_UNMARSHAL + 1) 198 UNMARSHAL_DISPATCH(TPM_SU), 199 #define UINT16_P_UNMARSHAL (TPM_SU_P_UNMARSHAL + 1) 200 UNMARSHAL_DISPATCH(UINT16), 201 #define UINT32_P_UNMARSHAL (UINT16_P_UNMARSHAL + 1) 202 UNMARSHAL_DISPATCH(UINT32), 203 #define UINT64_P_UNMARSHAL (UINT32_P_UNMARSHAL + 1) 204 UNMARSHAL_DISPATCH(UINT64), 205 #define UINT8_P_UNMARSHAL (UINT64_P_UNMARSHAL + 1) 206 UNMARSHAL_DISPATCH(UINT8), 207 // PARAMETER_FIRST_FLAG_TYPE is the first parameter to need a flag. 208 #define PARAMETER_FIRST_FLAG_TYPE (UINT8_P_UNMARSHAL + 1) 209 #define TPM2B_PUBLIC_P_UNMARSHAL (UINT8_P_UNMARSHAL + 1) 210 UNMARSHAL_DISPATCH(TPM2B_PUBLIC), 211 #define TPMI_ALG_CIPHER_MODE_P_UNMARSHAL (TPM2B_PUBLIC_P_UNMARSHAL + 1) 212 UNMARSHAL_DISPATCH(TPMI_ALG_CIPHER_MODE), 213 #define TPMI_ALG_HASH_P_UNMARSHAL \ 214 (TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + 1) 215 UNMARSHAL_DISPATCH(TPMI_ALG_HASH), 216 #define TPMI_ALG_MAC_SCHEME_P_UNMARSHAL (TPMI_ALG_HASH_P_UNMARSHAL + 1) 217 UNMARSHAL_DISPATCH(TPMI_ALG_MAC_SCHEME), 218 #define TPMI_DH_PCR_P_UNMARSHAL \ 219 (TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + 1) 220 UNMARSHAL_DISPATCH(TPMI_DH_PCR), 221 #define TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL (TPMI_DH_PCR_P_UNMARSHAL + 1) 222 UNMARSHAL_DISPATCH(TPMI_ECC_KEY_EXCHANGE), 223 #define TPMI_RH_ENABLES_P_UNMARSHAL \ 224 (TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL + 1) 225 UNMARSHAL_DISPATCH(TPMI_RH_ENABLES), 226 #define TPMI_RH_HIERARCHY_P_UNMARSHAL (TPMI_RH_ENABLES_P_UNMARSHAL + 1) 227 UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY), 228 #define TPMT_KDF_SCHEME_P_UNMARSHAL (TPMI_RH_HIERARCHY_P_UNMARSHAL + 1) 229 UNMARSHAL_DISPATCH(TPMT_KDF_SCHEME), 230 #define TPMT_RSA_DECRYPT_P_UNMARSHAL (TPMT_KDF_SCHEME_P_UNMARSHAL + 1) 231 UNMARSHAL_DISPATCH(TPMT_RSA_DECRYPT), 232 #define TPMT_SIGNATURE_P_UNMARSHAL (TPMT_RSA_DECRYPT_P_UNMARSHAL + 1) 233 UNMARSHAL_DISPATCH(TPMT_SIGNATURE), 234 #define TPMT_SIG_SCHEME_P_UNMARSHAL (TPMT_SIGNATURE_P_UNMARSHAL + 1) 235 UNMARSHAL_DISPATCH(TPMT_SIG_SCHEME), 236 #define TPMT_SYM_DEF_P_UNMARSHAL (TPMT_SIG_SCHEME_P_UNMARSHAL + 1) 237 UNMARSHAL_DISPATCH(TPMT_SYM_DEF), 238 #define TPMT_SYM_DEF_OBJECT_P_UNMARSHAL (TPMT_SYM_DEF_P_UNMARSHAL + 1) 239 UNMARSHAL_DISPATCH(TPMT_SYM_DEF_OBJECT) 240 // PARAMETER_LAST_TYPE is the end of the command parameter list. 241 #define PARAMETER_LAST_TYPE (TPMT_SYM_DEF_OBJECT_P_UNMARSHAL) 242 }; 243 244 // The marshalArray contains the dispatch functions for the marshaling code. 245 // The defines in this array are used to make it easier to cross reference the 246 // marshaling values in the types array of each command 247 const _MARSHAL_T_ marshalArray[] = { 248 249 #define UINT32_H_MARSHAL 0 250 MARSHAL_DISPATCH(UINT32), 251 // RESPONSE_PARAMETER_FIRST_TYPE marks the end of the response handles. 252 #define RESPONSE_PARAMETER_FIRST_TYPE (UINT32_H_MARSHAL + 1) 253 #define TPM2B_ATTEST_P_MARSHAL (UINT32_H_MARSHAL + 1) 254 MARSHAL_DISPATCH(TPM2B_ATTEST), 255 #define TPM2B_CREATION_DATA_P_MARSHAL (TPM2B_ATTEST_P_MARSHAL + 1) 256 MARSHAL_DISPATCH(TPM2B_CREATION_DATA), 257 #define TPM2B_DATA_P_MARSHAL (TPM2B_CREATION_DATA_P_MARSHAL + 1) 258 MARSHAL_DISPATCH(TPM2B_DATA), 259 #define TPM2B_DIGEST_P_MARSHAL (TPM2B_DATA_P_MARSHAL + 1) 260 MARSHAL_DISPATCH(TPM2B_DIGEST), 261 #define TPM2B_ECC_POINT_P_MARSHAL (TPM2B_DIGEST_P_MARSHAL + 1) 262 MARSHAL_DISPATCH(TPM2B_ECC_POINT), 263 #define TPM2B_ENCRYPTED_SECRET_P_MARSHAL (TPM2B_ECC_POINT_P_MARSHAL + 1) 264 MARSHAL_DISPATCH(TPM2B_ENCRYPTED_SECRET), 265 #define TPM2B_ID_OBJECT_P_MARSHAL \ 266 (TPM2B_ENCRYPTED_SECRET_P_MARSHAL + 1) 267 MARSHAL_DISPATCH(TPM2B_ID_OBJECT), 268 #define TPM2B_IV_P_MARSHAL (TPM2B_ID_OBJECT_P_MARSHAL + 1) 269 MARSHAL_DISPATCH(TPM2B_IV), 270 #define TPM2B_MAX_BUFFER_P_MARSHAL (TPM2B_IV_P_MARSHAL + 1) 271 MARSHAL_DISPATCH(TPM2B_MAX_BUFFER), 272 #define TPM2B_MAX_NV_BUFFER_P_MARSHAL (TPM2B_MAX_BUFFER_P_MARSHAL + 1) 273 MARSHAL_DISPATCH(TPM2B_MAX_NV_BUFFER), 274 #define TPM2B_NAME_P_MARSHAL (TPM2B_MAX_NV_BUFFER_P_MARSHAL + 1) 275 MARSHAL_DISPATCH(TPM2B_NAME), 276 #define TPM2B_NV_PUBLIC_P_MARSHAL (TPM2B_NAME_P_MARSHAL + 1) 277 MARSHAL_DISPATCH(TPM2B_NV_PUBLIC), 278 #define TPM2B_PRIVATE_P_MARSHAL (TPM2B_NV_PUBLIC_P_MARSHAL + 1) 279 MARSHAL_DISPATCH(TPM2B_PRIVATE), 280 #define TPM2B_PUBLIC_P_MARSHAL (TPM2B_PRIVATE_P_MARSHAL + 1) 281 MARSHAL_DISPATCH(TPM2B_PUBLIC), 282 #define TPM2B_PUBLIC_KEY_RSA_P_MARSHAL (TPM2B_PUBLIC_P_MARSHAL + 1) 283 MARSHAL_DISPATCH(TPM2B_PUBLIC_KEY_RSA), 284 #define TPM2B_SENSITIVE_DATA_P_MARSHAL (TPM2B_PUBLIC_KEY_RSA_P_MARSHAL + 1) 285 MARSHAL_DISPATCH(TPM2B_SENSITIVE_DATA), 286 #define TPM2B_TIMEOUT_P_MARSHAL (TPM2B_SENSITIVE_DATA_P_MARSHAL + 1) 287 MARSHAL_DISPATCH(TPM2B_TIMEOUT), 288 #define UINT8_P_MARSHAL (TPM2B_TIMEOUT_P_MARSHAL + 1) 289 MARSHAL_DISPATCH(UINT8), 290 #define TPML_AC_CAPABILITIES_P_MARSHAL (UINT8_P_MARSHAL + 1) 291 MARSHAL_DISPATCH(TPML_AC_CAPABILITIES), 292 #define TPML_ALG_P_MARSHAL (TPML_AC_CAPABILITIES_P_MARSHAL + 1) 293 MARSHAL_DISPATCH(TPML_ALG), 294 #define TPML_DIGEST_P_MARSHAL (TPML_ALG_P_MARSHAL + 1) 295 MARSHAL_DISPATCH(TPML_DIGEST), 296 #define TPML_DIGEST_VALUES_P_MARSHAL (TPML_DIGEST_P_MARSHAL + 1) 297 MARSHAL_DISPATCH(TPML_DIGEST_VALUES), 298 #define TPML_PCR_SELECTION_P_MARSHAL (TPML_DIGEST_VALUES_P_MARSHAL + 1) 299 MARSHAL_DISPATCH(TPML_PCR_SELECTION), 300 #define TPMS_AC_OUTPUT_P_MARSHAL (TPML_PCR_SELECTION_P_MARSHAL + 1) 301 MARSHAL_DISPATCH(TPMS_AC_OUTPUT), 302 #define TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL (TPMS_AC_OUTPUT_P_MARSHAL + 1) 303 MARSHAL_DISPATCH(TPMS_ALGORITHM_DETAIL_ECC), 304 #define TPMS_CAPABILITY_DATA_P_MARSHAL \ 305 (TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL + 1) 306 MARSHAL_DISPATCH(TPMS_CAPABILITY_DATA), 307 #define TPMS_CONTEXT_P_MARSHAL (TPMS_CAPABILITY_DATA_P_MARSHAL + 1) 308 MARSHAL_DISPATCH(TPMS_CONTEXT), 309 #define TPMS_TIME_INFO_P_MARSHAL (TPMS_CONTEXT_P_MARSHAL + 1) 310 MARSHAL_DISPATCH(TPMS_TIME_INFO), 311 #define TPMT_HA_P_MARSHAL (TPMS_TIME_INFO_P_MARSHAL + 1) 312 MARSHAL_DISPATCH(TPMT_HA), 313 #define TPMT_SIGNATURE_P_MARSHAL (TPMT_HA_P_MARSHAL + 1) 314 MARSHAL_DISPATCH(TPMT_SIGNATURE), 315 #define TPMT_TK_AUTH_P_MARSHAL (TPMT_SIGNATURE_P_MARSHAL + 1) 316 MARSHAL_DISPATCH(TPMT_TK_AUTH), 317 #define TPMT_TK_CREATION_P_MARSHAL (TPMT_TK_AUTH_P_MARSHAL + 1) 318 MARSHAL_DISPATCH(TPMT_TK_CREATION), 319 #define TPMT_TK_HASHCHECK_P_MARSHAL (TPMT_TK_CREATION_P_MARSHAL + 1) 320 MARSHAL_DISPATCH(TPMT_TK_HASHCHECK), 321 #define TPMT_TK_VERIFIED_P_MARSHAL (TPMT_TK_HASHCHECK_P_MARSHAL + 1) 322 MARSHAL_DISPATCH(TPMT_TK_VERIFIED), 323 #define UINT32_P_MARSHAL (TPMT_TK_VERIFIED_P_MARSHAL + 1) 324 MARSHAL_DISPATCH(UINT32), 325 #define UINT16_P_MARSHAL (UINT32_P_MARSHAL + 1) 326 MARSHAL_DISPATCH(UINT16) 327 // RESPONSE_PARAMETER_LAST_TYPE is the end of the response parameter list. 328 #define RESPONSE_PARAMETER_LAST_TYPE (UINT16_P_MARSHAL) 329 }; 330 331 // This list of aliases allows the types in the _COMMAND_DESCRIPTOR_T to match the 332 // types in the command/response templates of part 3. 333 #define INT32_P_UNMARSHAL UINT32_P_UNMARSHAL 334 #define TPM2B_AUTH_P_UNMARSHAL TPM2B_DIGEST_P_UNMARSHAL 335 #define TPM2B_NONCE_P_UNMARSHAL TPM2B_DIGEST_P_UNMARSHAL 336 #define TPM2B_OPERAND_P_UNMARSHAL TPM2B_DIGEST_P_UNMARSHAL 337 #define TPMA_LOCALITY_P_UNMARSHAL UINT8_P_UNMARSHAL 338 #define TPM_CC_P_UNMARSHAL UINT32_P_UNMARSHAL 339 #define TPMI_DH_CONTEXT_H_MARSHAL UINT32_H_MARSHAL 340 #define TPMI_DH_OBJECT_H_MARSHAL UINT32_H_MARSHAL 341 #define TPMI_SH_AUTH_SESSION_H_MARSHAL UINT32_H_MARSHAL 342 #define TPM_HANDLE_H_MARSHAL UINT32_H_MARSHAL 343 #define TPM2B_NONCE_P_MARSHAL TPM2B_DIGEST_P_MARSHAL 344 #define TPMI_YES_NO_P_MARSHAL UINT8_P_MARSHAL 345 #define TPM_RC_P_MARSHAL UINT32_P_MARSHAL 346 347 348 #if CC_Startup 349 350 #include "Startup_fp.h" 351 352 typedef TPM_RC (Startup_Entry)( 353 Startup_In *in 354 ); 355 356 typedef const struct { 357 Startup_Entry *entry; 358 UINT16 inSize; 359 UINT16 outSize; 360 UINT16 offsetOfTypes; 361 BYTE types[3]; 362 } Startup_COMMAND_DESCRIPTOR_t; 363 364 Startup_COMMAND_DESCRIPTOR_t _StartupData = { 365 /* entry */ &TPM2_Startup, 366 /* inSize */ (UINT16)(sizeof(Startup_In)), 367 /* outSize */ 0, 368 /* offsetOfTypes */ offsetof(Startup_COMMAND_DESCRIPTOR_t, types), 369 /* offsets */ // No parameter offsets; 370 /* types */ {TPM_SU_P_UNMARSHAL, 371 END_OF_LIST, 372 END_OF_LIST} 373 }; 374 375 #define _StartupDataAddress (&_StartupData) 376 #else 377 #define _StartupDataAddress 0 378 #endif // CC_Startup 379 380 #if CC_Shutdown 381 382 #include "Shutdown_fp.h" 383 384 typedef TPM_RC (Shutdown_Entry)( 385 Shutdown_In *in 386 ); 387 388 typedef const struct { 389 Shutdown_Entry *entry; 390 UINT16 inSize; 391 UINT16 outSize; 392 UINT16 offsetOfTypes; 393 BYTE types[3]; 394 } Shutdown_COMMAND_DESCRIPTOR_t; 395 396 Shutdown_COMMAND_DESCRIPTOR_t _ShutdownData = { 397 /* entry */ &TPM2_Shutdown, 398 /* inSize */ (UINT16)(sizeof(Shutdown_In)), 399 /* outSize */ 0, 400 /* offsetOfTypes */ offsetof(Shutdown_COMMAND_DESCRIPTOR_t, types), 401 /* offsets */ // No parameter offsets; 402 /* types */ {TPM_SU_P_UNMARSHAL, 403 END_OF_LIST, 404 END_OF_LIST} 405 }; 406 407 #define _ShutdownDataAddress (&_ShutdownData) 408 #else 409 #define _ShutdownDataAddress 0 410 #endif // CC_Shutdown 411 412 #if CC_SelfTest 413 414 #include "SelfTest_fp.h" 415 416 typedef TPM_RC (SelfTest_Entry)( 417 SelfTest_In *in 418 ); 419 420 typedef const struct { 421 SelfTest_Entry *entry; 422 UINT16 inSize; 423 UINT16 outSize; 424 UINT16 offsetOfTypes; 425 BYTE types[3]; 426 } SelfTest_COMMAND_DESCRIPTOR_t; 427 428 SelfTest_COMMAND_DESCRIPTOR_t _SelfTestData = { 429 /* entry */ &TPM2_SelfTest, 430 /* inSize */ (UINT16)(sizeof(SelfTest_In)), 431 /* outSize */ 0, 432 /* offsetOfTypes */ offsetof(SelfTest_COMMAND_DESCRIPTOR_t, types), 433 /* offsets */ // No parameter offsets; 434 /* types */ {TPMI_YES_NO_P_UNMARSHAL, 435 END_OF_LIST, 436 END_OF_LIST} 437 }; 438 439 #define _SelfTestDataAddress (&_SelfTestData) 440 #else 441 #define _SelfTestDataAddress 0 442 #endif // CC_SelfTest 443 444 #if CC_IncrementalSelfTest 445 446 #include "IncrementalSelfTest_fp.h" 447 448 typedef TPM_RC (IncrementalSelfTest_Entry)( 449 IncrementalSelfTest_In *in, 450 IncrementalSelfTest_Out *out 451 ); 452 453 typedef const struct { 454 IncrementalSelfTest_Entry *entry; 455 UINT16 inSize; 456 UINT16 outSize; 457 UINT16 offsetOfTypes; 458 BYTE types[4]; 459 } IncrementalSelfTest_COMMAND_DESCRIPTOR_t; 460 461 IncrementalSelfTest_COMMAND_DESCRIPTOR_t _IncrementalSelfTestData = { 462 /* entry */ &TPM2_IncrementalSelfTest, 463 /* inSize */ (UINT16)(sizeof(IncrementalSelfTest_In)), 464 /* outSize */ (UINT16)(sizeof(IncrementalSelfTest_Out)), 465 /* offsetOfTypes */ offsetof(IncrementalSelfTest_COMMAND_DESCRIPTOR_t, types), 466 /* offsets */ // No parameter offsets; 467 /* types */ {TPML_ALG_P_UNMARSHAL, 468 END_OF_LIST, 469 TPML_ALG_P_MARSHAL, 470 END_OF_LIST} 471 }; 472 473 #define _IncrementalSelfTestDataAddress (&_IncrementalSelfTestData) 474 #else 475 #define _IncrementalSelfTestDataAddress 0 476 #endif // CC_IncrementalSelfTest 477 478 #if CC_GetTestResult 479 480 #include "GetTestResult_fp.h" 481 482 typedef TPM_RC (GetTestResult_Entry)( 483 GetTestResult_Out *out 484 ); 485 486 typedef const struct { 487 GetTestResult_Entry *entry; 488 UINT16 inSize; 489 UINT16 outSize; 490 UINT16 offsetOfTypes; 491 UINT16 paramOffsets[1]; 492 BYTE types[4]; 493 } GetTestResult_COMMAND_DESCRIPTOR_t; 494 495 GetTestResult_COMMAND_DESCRIPTOR_t _GetTestResultData = { 496 /* entry */ &TPM2_GetTestResult, 497 /* inSize */ 0, 498 /* outSize */ (UINT16)(sizeof(GetTestResult_Out)), 499 /* offsetOfTypes */ offsetof(GetTestResult_COMMAND_DESCRIPTOR_t, types), 500 /* offsets */ {(UINT16)(offsetof(GetTestResult_Out, testResult))}, 501 /* types */ {END_OF_LIST, 502 TPM2B_MAX_BUFFER_P_MARSHAL, 503 TPM_RC_P_MARSHAL, 504 END_OF_LIST} 505 }; 506 507 #define _GetTestResultDataAddress (&_GetTestResultData) 508 #else 509 #define _GetTestResultDataAddress 0 510 #endif // CC_GetTestResult 511 512 #if CC_StartAuthSession 513 514 #include "StartAuthSession_fp.h" 515 516 typedef TPM_RC (StartAuthSession_Entry)( 517 StartAuthSession_In *in, 518 StartAuthSession_Out *out 519 ); 520 521 typedef const struct { 522 StartAuthSession_Entry *entry; 523 UINT16 inSize; 524 UINT16 outSize; 525 UINT16 offsetOfTypes; 526 UINT16 paramOffsets[7]; 527 BYTE types[11]; 528 } StartAuthSession_COMMAND_DESCRIPTOR_t; 529 530 StartAuthSession_COMMAND_DESCRIPTOR_t _StartAuthSessionData = { 531 /* entry */ &TPM2_StartAuthSession, 532 /* inSize */ (UINT16)(sizeof(StartAuthSession_In)), 533 /* outSize */ (UINT16)(sizeof(StartAuthSession_Out)), 534 /* offsetOfTypes */ offsetof(StartAuthSession_COMMAND_DESCRIPTOR_t, types), 535 /* offsets */ {(UINT16)(offsetof(StartAuthSession_In, bind)), 536 (UINT16)(offsetof(StartAuthSession_In, nonceCaller)), 537 (UINT16)(offsetof(StartAuthSession_In, encryptedSalt)), 538 (UINT16)(offsetof(StartAuthSession_In, sessionType)), 539 (UINT16)(offsetof(StartAuthSession_In, symmetric)), 540 (UINT16)(offsetof(StartAuthSession_In, authHash)), 541 (UINT16)(offsetof(StartAuthSession_Out, nonceTPM))}, 542 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 543 TPMI_DH_ENTITY_H_UNMARSHAL + ADD_FLAG, 544 TPM2B_NONCE_P_UNMARSHAL, 545 TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL, 546 TPM_SE_P_UNMARSHAL, 547 TPMT_SYM_DEF_P_UNMARSHAL + ADD_FLAG, 548 TPMI_ALG_HASH_P_UNMARSHAL, 549 END_OF_LIST, 550 TPMI_SH_AUTH_SESSION_H_MARSHAL, 551 TPM2B_NONCE_P_MARSHAL, 552 END_OF_LIST} 553 }; 554 555 #define _StartAuthSessionDataAddress (&_StartAuthSessionData) 556 #else 557 #define _StartAuthSessionDataAddress 0 558 #endif // CC_StartAuthSession 559 560 #if CC_PolicyRestart 561 562 #include "PolicyRestart_fp.h" 563 564 typedef TPM_RC (PolicyRestart_Entry)( 565 PolicyRestart_In *in 566 ); 567 568 typedef const struct { 569 PolicyRestart_Entry *entry; 570 UINT16 inSize; 571 UINT16 outSize; 572 UINT16 offsetOfTypes; 573 BYTE types[3]; 574 } PolicyRestart_COMMAND_DESCRIPTOR_t; 575 576 PolicyRestart_COMMAND_DESCRIPTOR_t _PolicyRestartData = { 577 /* entry */ &TPM2_PolicyRestart, 578 /* inSize */ (UINT16)(sizeof(PolicyRestart_In)), 579 /* outSize */ 0, 580 /* offsetOfTypes */ offsetof(PolicyRestart_COMMAND_DESCRIPTOR_t, types), 581 /* offsets */ // No parameter offsets; 582 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 583 END_OF_LIST, 584 END_OF_LIST} 585 }; 586 587 #define _PolicyRestartDataAddress (&_PolicyRestartData) 588 #else 589 #define _PolicyRestartDataAddress 0 590 #endif // CC_PolicyRestart 591 592 #if CC_Create 593 594 #include "Create_fp.h" 595 596 typedef TPM_RC (Create_Entry)( 597 Create_In *in, 598 Create_Out *out 599 ); 600 601 typedef const struct { 602 Create_Entry *entry; 603 UINT16 inSize; 604 UINT16 outSize; 605 UINT16 offsetOfTypes; 606 UINT16 paramOffsets[8]; 607 BYTE types[12]; 608 } Create_COMMAND_DESCRIPTOR_t; 609 610 Create_COMMAND_DESCRIPTOR_t _CreateData = { 611 /* entry */ &TPM2_Create, 612 /* inSize */ (UINT16)(sizeof(Create_In)), 613 /* outSize */ (UINT16)(sizeof(Create_Out)), 614 /* offsetOfTypes */ offsetof(Create_COMMAND_DESCRIPTOR_t, types), 615 /* offsets */ {(UINT16)(offsetof(Create_In, inSensitive)), 616 (UINT16)(offsetof(Create_In, inPublic)), 617 (UINT16)(offsetof(Create_In, outsideInfo)), 618 (UINT16)(offsetof(Create_In, creationPCR)), 619 (UINT16)(offsetof(Create_Out, outPublic)), 620 (UINT16)(offsetof(Create_Out, creationData)), 621 (UINT16)(offsetof(Create_Out, creationHash)), 622 (UINT16)(offsetof(Create_Out, creationTicket))}, 623 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 624 TPM2B_SENSITIVE_CREATE_P_UNMARSHAL, 625 TPM2B_PUBLIC_P_UNMARSHAL, 626 TPM2B_DATA_P_UNMARSHAL, 627 TPML_PCR_SELECTION_P_UNMARSHAL, 628 END_OF_LIST, 629 TPM2B_PRIVATE_P_MARSHAL, 630 TPM2B_PUBLIC_P_MARSHAL, 631 TPM2B_CREATION_DATA_P_MARSHAL, 632 TPM2B_DIGEST_P_MARSHAL, 633 TPMT_TK_CREATION_P_MARSHAL, 634 END_OF_LIST} 635 }; 636 637 #define _CreateDataAddress (&_CreateData) 638 #else 639 #define _CreateDataAddress 0 640 #endif // CC_Create 641 642 #if CC_Load 643 644 #include "Load_fp.h" 645 646 typedef TPM_RC (Load_Entry)( 647 Load_In *in, 648 Load_Out *out 649 ); 650 651 typedef const struct { 652 Load_Entry *entry; 653 UINT16 inSize; 654 UINT16 outSize; 655 UINT16 offsetOfTypes; 656 UINT16 paramOffsets[3]; 657 BYTE types[7]; 658 } Load_COMMAND_DESCRIPTOR_t; 659 660 Load_COMMAND_DESCRIPTOR_t _LoadData = { 661 /* entry */ &TPM2_Load, 662 /* inSize */ (UINT16)(sizeof(Load_In)), 663 /* outSize */ (UINT16)(sizeof(Load_Out)), 664 /* offsetOfTypes */ offsetof(Load_COMMAND_DESCRIPTOR_t, types), 665 /* offsets */ {(UINT16)(offsetof(Load_In, inPrivate)), 666 (UINT16)(offsetof(Load_In, inPublic)), 667 (UINT16)(offsetof(Load_Out, name))}, 668 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 669 TPM2B_PRIVATE_P_UNMARSHAL, 670 TPM2B_PUBLIC_P_UNMARSHAL, 671 END_OF_LIST, 672 TPM_HANDLE_H_MARSHAL, 673 TPM2B_NAME_P_MARSHAL, 674 END_OF_LIST} 675 }; 676 677 #define _LoadDataAddress (&_LoadData) 678 #else 679 #define _LoadDataAddress 0 680 #endif // CC_Load 681 682 #if CC_LoadExternal 683 684 #include "LoadExternal_fp.h" 685 686 typedef TPM_RC (LoadExternal_Entry)( 687 LoadExternal_In *in, 688 LoadExternal_Out *out 689 ); 690 691 typedef const struct { 692 LoadExternal_Entry *entry; 693 UINT16 inSize; 694 UINT16 outSize; 695 UINT16 offsetOfTypes; 696 UINT16 paramOffsets[3]; 697 BYTE types[7]; 698 } LoadExternal_COMMAND_DESCRIPTOR_t; 699 700 LoadExternal_COMMAND_DESCRIPTOR_t _LoadExternalData = { 701 /* entry */ &TPM2_LoadExternal, 702 /* inSize */ (UINT16)(sizeof(LoadExternal_In)), 703 /* outSize */ (UINT16)(sizeof(LoadExternal_Out)), 704 /* offsetOfTypes */ offsetof(LoadExternal_COMMAND_DESCRIPTOR_t, types), 705 /* offsets */ {(UINT16)(offsetof(LoadExternal_In, inPublic)), 706 (UINT16)(offsetof(LoadExternal_In, hierarchy)), 707 (UINT16)(offsetof(LoadExternal_Out, name))}, 708 /* types */ {TPM2B_SENSITIVE_P_UNMARSHAL, 709 TPM2B_PUBLIC_P_UNMARSHAL + ADD_FLAG, 710 TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG, 711 END_OF_LIST, 712 TPM_HANDLE_H_MARSHAL, 713 TPM2B_NAME_P_MARSHAL, 714 END_OF_LIST} 715 }; 716 717 #define _LoadExternalDataAddress (&_LoadExternalData) 718 #else 719 #define _LoadExternalDataAddress 0 720 #endif // CC_LoadExternal 721 722 #if CC_ReadPublic 723 724 #include "ReadPublic_fp.h" 725 726 typedef TPM_RC (ReadPublic_Entry)( 727 ReadPublic_In *in, 728 ReadPublic_Out *out 729 ); 730 731 typedef const struct { 732 ReadPublic_Entry *entry; 733 UINT16 inSize; 734 UINT16 outSize; 735 UINT16 offsetOfTypes; 736 UINT16 paramOffsets[2]; 737 BYTE types[6]; 738 } ReadPublic_COMMAND_DESCRIPTOR_t; 739 740 ReadPublic_COMMAND_DESCRIPTOR_t _ReadPublicData = { 741 /* entry */ &TPM2_ReadPublic, 742 /* inSize */ (UINT16)(sizeof(ReadPublic_In)), 743 /* outSize */ (UINT16)(sizeof(ReadPublic_Out)), 744 /* offsetOfTypes */ offsetof(ReadPublic_COMMAND_DESCRIPTOR_t, types), 745 /* offsets */ {(UINT16)(offsetof(ReadPublic_Out, name)), 746 (UINT16)(offsetof(ReadPublic_Out, qualifiedName))}, 747 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 748 END_OF_LIST, 749 TPM2B_PUBLIC_P_MARSHAL, 750 TPM2B_NAME_P_MARSHAL, 751 TPM2B_NAME_P_MARSHAL, 752 END_OF_LIST} 753 }; 754 755 #define _ReadPublicDataAddress (&_ReadPublicData) 756 #else 757 #define _ReadPublicDataAddress 0 758 #endif // CC_ReadPublic 759 760 #if CC_ActivateCredential 761 762 #include "ActivateCredential_fp.h" 763 764 typedef TPM_RC (ActivateCredential_Entry)( 765 ActivateCredential_In *in, 766 ActivateCredential_Out *out 767 ); 768 769 typedef const struct { 770 ActivateCredential_Entry *entry; 771 UINT16 inSize; 772 UINT16 outSize; 773 UINT16 offsetOfTypes; 774 UINT16 paramOffsets[3]; 775 BYTE types[7]; 776 } ActivateCredential_COMMAND_DESCRIPTOR_t; 777 778 ActivateCredential_COMMAND_DESCRIPTOR_t _ActivateCredentialData = { 779 /* entry */ &TPM2_ActivateCredential, 780 /* inSize */ (UINT16)(sizeof(ActivateCredential_In)), 781 /* outSize */ (UINT16)(sizeof(ActivateCredential_Out)), 782 /* offsetOfTypes */ offsetof(ActivateCredential_COMMAND_DESCRIPTOR_t, types), 783 /* offsets */ {(UINT16)(offsetof(ActivateCredential_In, keyHandle)), 784 (UINT16)(offsetof(ActivateCredential_In, credentialBlob)), 785 (UINT16)(offsetof(ActivateCredential_In, secret))}, 786 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 787 TPMI_DH_OBJECT_H_UNMARSHAL, 788 TPM2B_ID_OBJECT_P_UNMARSHAL, 789 TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL, 790 END_OF_LIST, 791 TPM2B_DIGEST_P_MARSHAL, 792 END_OF_LIST} 793 }; 794 795 #define _ActivateCredentialDataAddress (&_ActivateCredentialData) 796 #else 797 #define _ActivateCredentialDataAddress 0 798 #endif // CC_ActivateCredential 799 800 #if CC_MakeCredential 801 802 #include "MakeCredential_fp.h" 803 804 typedef TPM_RC (MakeCredential_Entry)( 805 MakeCredential_In *in, 806 MakeCredential_Out *out 807 ); 808 809 typedef const struct { 810 MakeCredential_Entry *entry; 811 UINT16 inSize; 812 UINT16 outSize; 813 UINT16 offsetOfTypes; 814 UINT16 paramOffsets[3]; 815 BYTE types[7]; 816 } MakeCredential_COMMAND_DESCRIPTOR_t; 817 818 MakeCredential_COMMAND_DESCRIPTOR_t _MakeCredentialData = { 819 /* entry */ &TPM2_MakeCredential, 820 /* inSize */ (UINT16)(sizeof(MakeCredential_In)), 821 /* outSize */ (UINT16)(sizeof(MakeCredential_Out)), 822 /* offsetOfTypes */ offsetof(MakeCredential_COMMAND_DESCRIPTOR_t, types), 823 /* offsets */ {(UINT16)(offsetof(MakeCredential_In, credential)), 824 (UINT16)(offsetof(MakeCredential_In, objectName)), 825 (UINT16)(offsetof(MakeCredential_Out, secret))}, 826 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 827 TPM2B_DIGEST_P_UNMARSHAL, 828 TPM2B_NAME_P_UNMARSHAL, 829 END_OF_LIST, 830 TPM2B_ID_OBJECT_P_MARSHAL, 831 TPM2B_ENCRYPTED_SECRET_P_MARSHAL, 832 END_OF_LIST} 833 }; 834 835 #define _MakeCredentialDataAddress (&_MakeCredentialData) 836 #else 837 #define _MakeCredentialDataAddress 0 838 #endif // CC_MakeCredential 839 840 #if CC_Unseal 841 842 #include "Unseal_fp.h" 843 844 typedef TPM_RC (Unseal_Entry)( 845 Unseal_In *in, 846 Unseal_Out *out 847 ); 848 849 typedef const struct { 850 Unseal_Entry *entry; 851 UINT16 inSize; 852 UINT16 outSize; 853 UINT16 offsetOfTypes; 854 BYTE types[4]; 855 } Unseal_COMMAND_DESCRIPTOR_t; 856 857 Unseal_COMMAND_DESCRIPTOR_t _UnsealData = { 858 /* entry */ &TPM2_Unseal, 859 /* inSize */ (UINT16)(sizeof(Unseal_In)), 860 /* outSize */ (UINT16)(sizeof(Unseal_Out)), 861 /* offsetOfTypes */ offsetof(Unseal_COMMAND_DESCRIPTOR_t, types), 862 /* offsets */ // No parameter offsets; 863 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 864 END_OF_LIST, 865 TPM2B_SENSITIVE_DATA_P_MARSHAL, 866 END_OF_LIST} 867 }; 868 869 #define _UnsealDataAddress (&_UnsealData) 870 #else 871 #define _UnsealDataAddress 0 872 #endif // CC_Unseal 873 874 #if CC_ObjectChangeAuth 875 876 #include "ObjectChangeAuth_fp.h" 877 878 typedef TPM_RC (ObjectChangeAuth_Entry)( 879 ObjectChangeAuth_In *in, 880 ObjectChangeAuth_Out *out 881 ); 882 883 typedef const struct { 884 ObjectChangeAuth_Entry *entry; 885 UINT16 inSize; 886 UINT16 outSize; 887 UINT16 offsetOfTypes; 888 UINT16 paramOffsets[2]; 889 BYTE types[6]; 890 } ObjectChangeAuth_COMMAND_DESCRIPTOR_t; 891 892 ObjectChangeAuth_COMMAND_DESCRIPTOR_t _ObjectChangeAuthData = { 893 /* entry */ &TPM2_ObjectChangeAuth, 894 /* inSize */ (UINT16)(sizeof(ObjectChangeAuth_In)), 895 /* outSize */ (UINT16)(sizeof(ObjectChangeAuth_Out)), 896 /* offsetOfTypes */ offsetof(ObjectChangeAuth_COMMAND_DESCRIPTOR_t, types), 897 /* offsets */ {(UINT16)(offsetof(ObjectChangeAuth_In, parentHandle)), 898 (UINT16)(offsetof(ObjectChangeAuth_In, newAuth))}, 899 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 900 TPMI_DH_OBJECT_H_UNMARSHAL, 901 TPM2B_AUTH_P_UNMARSHAL, 902 END_OF_LIST, 903 TPM2B_PRIVATE_P_MARSHAL, 904 END_OF_LIST} 905 }; 906 907 #define _ObjectChangeAuthDataAddress (&_ObjectChangeAuthData) 908 #else 909 #define _ObjectChangeAuthDataAddress 0 910 #endif // CC_ObjectChangeAuth 911 912 #if CC_CreateLoaded 913 914 #include "CreateLoaded_fp.h" 915 916 typedef TPM_RC (CreateLoaded_Entry)( 917 CreateLoaded_In *in, 918 CreateLoaded_Out *out 919 ); 920 921 typedef const struct { 922 CreateLoaded_Entry *entry; 923 UINT16 inSize; 924 UINT16 outSize; 925 UINT16 offsetOfTypes; 926 UINT16 paramOffsets[5]; 927 BYTE types[9]; 928 } CreateLoaded_COMMAND_DESCRIPTOR_t; 929 930 CreateLoaded_COMMAND_DESCRIPTOR_t _CreateLoadedData = { 931 /* entry */ &TPM2_CreateLoaded, 932 /* inSize */ (UINT16)(sizeof(CreateLoaded_In)), 933 /* outSize */ (UINT16)(sizeof(CreateLoaded_Out)), 934 /* offsetOfTypes */ offsetof(CreateLoaded_COMMAND_DESCRIPTOR_t, types), 935 /* offsets */ {(UINT16)(offsetof(CreateLoaded_In, inSensitive)), 936 (UINT16)(offsetof(CreateLoaded_In, inPublic)), 937 (UINT16)(offsetof(CreateLoaded_Out, outPrivate)), 938 (UINT16)(offsetof(CreateLoaded_Out, outPublic)), 939 (UINT16)(offsetof(CreateLoaded_Out, name))}, 940 /* types */ {TPMI_DH_PARENT_H_UNMARSHAL + ADD_FLAG, 941 TPM2B_SENSITIVE_CREATE_P_UNMARSHAL, 942 TPM2B_TEMPLATE_P_UNMARSHAL, 943 END_OF_LIST, 944 TPM_HANDLE_H_MARSHAL, 945 TPM2B_PRIVATE_P_MARSHAL, 946 TPM2B_PUBLIC_P_MARSHAL, 947 TPM2B_NAME_P_MARSHAL, 948 END_OF_LIST} 949 }; 950 951 #define _CreateLoadedDataAddress (&_CreateLoadedData) 952 #else 953 #define _CreateLoadedDataAddress 0 954 #endif // CC_CreateLoaded 955 956 #if CC_Duplicate 957 958 #include "Duplicate_fp.h" 959 960 typedef TPM_RC (Duplicate_Entry)( 961 Duplicate_In *in, 962 Duplicate_Out *out 963 ); 964 965 typedef const struct { 966 Duplicate_Entry *entry; 967 UINT16 inSize; 968 UINT16 outSize; 969 UINT16 offsetOfTypes; 970 UINT16 paramOffsets[5]; 971 BYTE types[9]; 972 } Duplicate_COMMAND_DESCRIPTOR_t; 973 974 Duplicate_COMMAND_DESCRIPTOR_t _DuplicateData = { 975 /* entry */ &TPM2_Duplicate, 976 /* inSize */ (UINT16)(sizeof(Duplicate_In)), 977 /* outSize */ (UINT16)(sizeof(Duplicate_Out)), 978 /* offsetOfTypes */ offsetof(Duplicate_COMMAND_DESCRIPTOR_t, types), 979 /* offsets */ {(UINT16)(offsetof(Duplicate_In, newParentHandle)), 980 (UINT16)(offsetof(Duplicate_In, encryptionKeyIn)), 981 (UINT16)(offsetof(Duplicate_In, symmetricAlg)), 982 (UINT16)(offsetof(Duplicate_Out, duplicate)), 983 (UINT16)(offsetof(Duplicate_Out, outSymSeed))}, 984 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 985 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 986 TPM2B_DATA_P_UNMARSHAL, 987 TPMT_SYM_DEF_OBJECT_P_UNMARSHAL + ADD_FLAG, 988 END_OF_LIST, 989 TPM2B_DATA_P_MARSHAL, 990 TPM2B_PRIVATE_P_MARSHAL, 991 TPM2B_ENCRYPTED_SECRET_P_MARSHAL, 992 END_OF_LIST} 993 }; 994 995 #define _DuplicateDataAddress (&_DuplicateData) 996 #else 997 #define _DuplicateDataAddress 0 998 #endif // CC_Duplicate 999 1000 #if CC_Rewrap 1001 1002 #include "Rewrap_fp.h" 1003 1004 typedef TPM_RC (Rewrap_Entry)( 1005 Rewrap_In *in, 1006 Rewrap_Out *out 1007 ); 1008 1009 typedef const struct { 1010 Rewrap_Entry *entry; 1011 UINT16 inSize; 1012 UINT16 outSize; 1013 UINT16 offsetOfTypes; 1014 UINT16 paramOffsets[5]; 1015 BYTE types[9]; 1016 } Rewrap_COMMAND_DESCRIPTOR_t; 1017 1018 Rewrap_COMMAND_DESCRIPTOR_t _RewrapData = { 1019 /* entry */ &TPM2_Rewrap, 1020 /* inSize */ (UINT16)(sizeof(Rewrap_In)), 1021 /* outSize */ (UINT16)(sizeof(Rewrap_Out)), 1022 /* offsetOfTypes */ offsetof(Rewrap_COMMAND_DESCRIPTOR_t, types), 1023 /* offsets */ {(UINT16)(offsetof(Rewrap_In, newParent)), 1024 (UINT16)(offsetof(Rewrap_In, inDuplicate)), 1025 (UINT16)(offsetof(Rewrap_In, name)), 1026 (UINT16)(offsetof(Rewrap_In, inSymSeed)), 1027 (UINT16)(offsetof(Rewrap_Out, outSymSeed))}, 1028 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 1029 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 1030 TPM2B_PRIVATE_P_UNMARSHAL, 1031 TPM2B_NAME_P_UNMARSHAL, 1032 TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL, 1033 END_OF_LIST, 1034 TPM2B_PRIVATE_P_MARSHAL, 1035 TPM2B_ENCRYPTED_SECRET_P_MARSHAL, 1036 END_OF_LIST} 1037 }; 1038 1039 #define _RewrapDataAddress (&_RewrapData) 1040 #else 1041 #define _RewrapDataAddress 0 1042 #endif // CC_Rewrap 1043 1044 #if CC_Import 1045 1046 #include "Import_fp.h" 1047 1048 typedef TPM_RC (Import_Entry)( 1049 Import_In *in, 1050 Import_Out *out 1051 ); 1052 1053 typedef const struct { 1054 Import_Entry *entry; 1055 UINT16 inSize; 1056 UINT16 outSize; 1057 UINT16 offsetOfTypes; 1058 UINT16 paramOffsets[5]; 1059 BYTE types[9]; 1060 } Import_COMMAND_DESCRIPTOR_t; 1061 1062 Import_COMMAND_DESCRIPTOR_t _ImportData = { 1063 /* entry */ &TPM2_Import, 1064 /* inSize */ (UINT16)(sizeof(Import_In)), 1065 /* outSize */ (UINT16)(sizeof(Import_Out)), 1066 /* offsetOfTypes */ offsetof(Import_COMMAND_DESCRIPTOR_t, types), 1067 /* offsets */ {(UINT16)(offsetof(Import_In, encryptionKey)), 1068 (UINT16)(offsetof(Import_In, objectPublic)), 1069 (UINT16)(offsetof(Import_In, duplicate)), 1070 (UINT16)(offsetof(Import_In, inSymSeed)), 1071 (UINT16)(offsetof(Import_In, symmetricAlg))}, 1072 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1073 TPM2B_DATA_P_UNMARSHAL, 1074 TPM2B_PUBLIC_P_UNMARSHAL, 1075 TPM2B_PRIVATE_P_UNMARSHAL, 1076 TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL, 1077 TPMT_SYM_DEF_OBJECT_P_UNMARSHAL + ADD_FLAG, 1078 END_OF_LIST, 1079 TPM2B_PRIVATE_P_MARSHAL, 1080 END_OF_LIST} 1081 }; 1082 1083 #define _ImportDataAddress (&_ImportData) 1084 #else 1085 #define _ImportDataAddress 0 1086 #endif // CC_Import 1087 1088 #if CC_RSA_Encrypt 1089 1090 #include "RSA_Encrypt_fp.h" 1091 1092 typedef TPM_RC (RSA_Encrypt_Entry)( 1093 RSA_Encrypt_In *in, 1094 RSA_Encrypt_Out *out 1095 ); 1096 1097 typedef const struct { 1098 RSA_Encrypt_Entry *entry; 1099 UINT16 inSize; 1100 UINT16 outSize; 1101 UINT16 offsetOfTypes; 1102 UINT16 paramOffsets[3]; 1103 BYTE types[7]; 1104 } RSA_Encrypt_COMMAND_DESCRIPTOR_t; 1105 1106 RSA_Encrypt_COMMAND_DESCRIPTOR_t _RSA_EncryptData = { 1107 /* entry */ &TPM2_RSA_Encrypt, 1108 /* inSize */ (UINT16)(sizeof(RSA_Encrypt_In)), 1109 /* outSize */ (UINT16)(sizeof(RSA_Encrypt_Out)), 1110 /* offsetOfTypes */ offsetof(RSA_Encrypt_COMMAND_DESCRIPTOR_t, types), 1111 /* offsets */ {(UINT16)(offsetof(RSA_Encrypt_In, message)), 1112 (UINT16)(offsetof(RSA_Encrypt_In, inScheme)), 1113 (UINT16)(offsetof(RSA_Encrypt_In, label))}, 1114 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1115 TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL, 1116 TPMT_RSA_DECRYPT_P_UNMARSHAL + ADD_FLAG, 1117 TPM2B_DATA_P_UNMARSHAL, 1118 END_OF_LIST, 1119 TPM2B_PUBLIC_KEY_RSA_P_MARSHAL, 1120 END_OF_LIST} 1121 }; 1122 1123 #define _RSA_EncryptDataAddress (&_RSA_EncryptData) 1124 #else 1125 #define _RSA_EncryptDataAddress 0 1126 #endif // CC_RSA_Encrypt 1127 1128 #if CC_RSA_Decrypt 1129 1130 #include "RSA_Decrypt_fp.h" 1131 1132 typedef TPM_RC (RSA_Decrypt_Entry)( 1133 RSA_Decrypt_In *in, 1134 RSA_Decrypt_Out *out 1135 ); 1136 1137 typedef const struct { 1138 RSA_Decrypt_Entry *entry; 1139 UINT16 inSize; 1140 UINT16 outSize; 1141 UINT16 offsetOfTypes; 1142 UINT16 paramOffsets[3]; 1143 BYTE types[7]; 1144 } RSA_Decrypt_COMMAND_DESCRIPTOR_t; 1145 1146 RSA_Decrypt_COMMAND_DESCRIPTOR_t _RSA_DecryptData = { 1147 /* entry */ &TPM2_RSA_Decrypt, 1148 /* inSize */ (UINT16)(sizeof(RSA_Decrypt_In)), 1149 /* outSize */ (UINT16)(sizeof(RSA_Decrypt_Out)), 1150 /* offsetOfTypes */ offsetof(RSA_Decrypt_COMMAND_DESCRIPTOR_t, types), 1151 /* offsets */ {(UINT16)(offsetof(RSA_Decrypt_In, cipherText)), 1152 (UINT16)(offsetof(RSA_Decrypt_In, inScheme)), 1153 (UINT16)(offsetof(RSA_Decrypt_In, label))}, 1154 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1155 TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL, 1156 TPMT_RSA_DECRYPT_P_UNMARSHAL + ADD_FLAG, 1157 TPM2B_DATA_P_UNMARSHAL, 1158 END_OF_LIST, 1159 TPM2B_PUBLIC_KEY_RSA_P_MARSHAL, 1160 END_OF_LIST} 1161 }; 1162 1163 #define _RSA_DecryptDataAddress (&_RSA_DecryptData) 1164 #else 1165 #define _RSA_DecryptDataAddress 0 1166 #endif // CC_RSA_Decrypt 1167 1168 #if CC_ECDH_KeyGen 1169 1170 #include "ECDH_KeyGen_fp.h" 1171 1172 typedef TPM_RC (ECDH_KeyGen_Entry)( 1173 ECDH_KeyGen_In *in, 1174 ECDH_KeyGen_Out *out 1175 ); 1176 1177 typedef const struct { 1178 ECDH_KeyGen_Entry *entry; 1179 UINT16 inSize; 1180 UINT16 outSize; 1181 UINT16 offsetOfTypes; 1182 UINT16 paramOffsets[1]; 1183 BYTE types[5]; 1184 } ECDH_KeyGen_COMMAND_DESCRIPTOR_t; 1185 1186 ECDH_KeyGen_COMMAND_DESCRIPTOR_t _ECDH_KeyGenData = { 1187 /* entry */ &TPM2_ECDH_KeyGen, 1188 /* inSize */ (UINT16)(sizeof(ECDH_KeyGen_In)), 1189 /* outSize */ (UINT16)(sizeof(ECDH_KeyGen_Out)), 1190 /* offsetOfTypes */ offsetof(ECDH_KeyGen_COMMAND_DESCRIPTOR_t, types), 1191 /* offsets */ {(UINT16)(offsetof(ECDH_KeyGen_Out, pubPoint))}, 1192 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1193 END_OF_LIST, 1194 TPM2B_ECC_POINT_P_MARSHAL, 1195 TPM2B_ECC_POINT_P_MARSHAL, 1196 END_OF_LIST} 1197 }; 1198 1199 #define _ECDH_KeyGenDataAddress (&_ECDH_KeyGenData) 1200 #else 1201 #define _ECDH_KeyGenDataAddress 0 1202 #endif // CC_ECDH_KeyGen 1203 1204 #if CC_ECDH_ZGen 1205 1206 #include "ECDH_ZGen_fp.h" 1207 1208 typedef TPM_RC (ECDH_ZGen_Entry)( 1209 ECDH_ZGen_In *in, 1210 ECDH_ZGen_Out *out 1211 ); 1212 1213 typedef const struct { 1214 ECDH_ZGen_Entry *entry; 1215 UINT16 inSize; 1216 UINT16 outSize; 1217 UINT16 offsetOfTypes; 1218 UINT16 paramOffsets[1]; 1219 BYTE types[5]; 1220 } ECDH_ZGen_COMMAND_DESCRIPTOR_t; 1221 1222 ECDH_ZGen_COMMAND_DESCRIPTOR_t _ECDH_ZGenData = { 1223 /* entry */ &TPM2_ECDH_ZGen, 1224 /* inSize */ (UINT16)(sizeof(ECDH_ZGen_In)), 1225 /* outSize */ (UINT16)(sizeof(ECDH_ZGen_Out)), 1226 /* offsetOfTypes */ offsetof(ECDH_ZGen_COMMAND_DESCRIPTOR_t, types), 1227 /* offsets */ {(UINT16)(offsetof(ECDH_ZGen_In, inPoint))}, 1228 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1229 TPM2B_ECC_POINT_P_UNMARSHAL, 1230 END_OF_LIST, 1231 TPM2B_ECC_POINT_P_MARSHAL, 1232 END_OF_LIST} 1233 }; 1234 1235 #define _ECDH_ZGenDataAddress (&_ECDH_ZGenData) 1236 #else 1237 #define _ECDH_ZGenDataAddress 0 1238 #endif // CC_ECDH_ZGen 1239 1240 #if CC_ECC_Parameters 1241 1242 #include "ECC_Parameters_fp.h" 1243 1244 typedef TPM_RC (ECC_Parameters_Entry)( 1245 ECC_Parameters_In *in, 1246 ECC_Parameters_Out *out 1247 ); 1248 1249 typedef const struct { 1250 ECC_Parameters_Entry *entry; 1251 UINT16 inSize; 1252 UINT16 outSize; 1253 UINT16 offsetOfTypes; 1254 BYTE types[4]; 1255 } ECC_Parameters_COMMAND_DESCRIPTOR_t; 1256 1257 ECC_Parameters_COMMAND_DESCRIPTOR_t _ECC_ParametersData = { 1258 /* entry */ &TPM2_ECC_Parameters, 1259 /* inSize */ (UINT16)(sizeof(ECC_Parameters_In)), 1260 /* outSize */ (UINT16)(sizeof(ECC_Parameters_Out)), 1261 /* offsetOfTypes */ offsetof(ECC_Parameters_COMMAND_DESCRIPTOR_t, types), 1262 /* offsets */ // No parameter offsets; 1263 /* types */ {TPMI_ECC_CURVE_P_UNMARSHAL, 1264 END_OF_LIST, 1265 TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL, 1266 END_OF_LIST} 1267 }; 1268 1269 #define _ECC_ParametersDataAddress (&_ECC_ParametersData) 1270 #else 1271 #define _ECC_ParametersDataAddress 0 1272 #endif // CC_ECC_Parameters 1273 1274 #if CC_ZGen_2Phase 1275 1276 #include "ZGen_2Phase_fp.h" 1277 1278 typedef TPM_RC (ZGen_2Phase_Entry)( 1279 ZGen_2Phase_In *in, 1280 ZGen_2Phase_Out *out 1281 ); 1282 1283 typedef const struct { 1284 ZGen_2Phase_Entry *entry; 1285 UINT16 inSize; 1286 UINT16 outSize; 1287 UINT16 offsetOfTypes; 1288 UINT16 paramOffsets[5]; 1289 BYTE types[9]; 1290 } ZGen_2Phase_COMMAND_DESCRIPTOR_t; 1291 1292 ZGen_2Phase_COMMAND_DESCRIPTOR_t _ZGen_2PhaseData = { 1293 /* entry */ &TPM2_ZGen_2Phase, 1294 /* inSize */ (UINT16)(sizeof(ZGen_2Phase_In)), 1295 /* outSize */ (UINT16)(sizeof(ZGen_2Phase_Out)), 1296 /* offsetOfTypes */ offsetof(ZGen_2Phase_COMMAND_DESCRIPTOR_t, types), 1297 /* offsets */ {(UINT16)(offsetof(ZGen_2Phase_In, inQsB)), 1298 (UINT16)(offsetof(ZGen_2Phase_In, inQeB)), 1299 (UINT16)(offsetof(ZGen_2Phase_In, inScheme)), 1300 (UINT16)(offsetof(ZGen_2Phase_In, counter)), 1301 (UINT16)(offsetof(ZGen_2Phase_Out, outZ2))}, 1302 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1303 TPM2B_ECC_POINT_P_UNMARSHAL, 1304 TPM2B_ECC_POINT_P_UNMARSHAL, 1305 TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL, 1306 UINT16_P_UNMARSHAL, 1307 END_OF_LIST, 1308 TPM2B_ECC_POINT_P_MARSHAL, 1309 TPM2B_ECC_POINT_P_MARSHAL, 1310 END_OF_LIST} 1311 }; 1312 1313 #define _ZGen_2PhaseDataAddress (&_ZGen_2PhaseData) 1314 #else 1315 #define _ZGen_2PhaseDataAddress 0 1316 #endif // CC_ZGen_2Phase 1317 1318 #if CC_ECC_Encrypt 1319 1320 #include "ECC_Encrypt_fp.h" 1321 1322 typedef TPM_RC (ECC_Encrypt_Entry)( 1323 ECC_Encrypt_In *in, 1324 ECC_Encrypt_Out *out 1325 ); 1326 1327 typedef const struct { 1328 ECC_Encrypt_Entry *entry; 1329 UINT16 inSize; 1330 UINT16 outSize; 1331 UINT16 offsetOfTypes; 1332 UINT16 paramOffsets[4]; 1333 BYTE types[8]; 1334 } ECC_Encrypt_COMMAND_DESCRIPTOR_t; 1335 1336 ECC_Encrypt_COMMAND_DESCRIPTOR_t _ECC_EncryptData = { 1337 /* entry */ &TPM2_ECC_Encrypt, 1338 /* inSize */ (UINT16)(sizeof(ECC_Encrypt_In)), 1339 /* outSize */ (UINT16)(sizeof(ECC_Encrypt_Out)), 1340 /* offsetOfTypes */ offsetof(ECC_Encrypt_COMMAND_DESCRIPTOR_t, types), 1341 /* offsets */ {(UINT16)(offsetof(ECC_Encrypt_In, plainText)), 1342 (UINT16)(offsetof(ECC_Encrypt_In, inScheme)), 1343 (UINT16)(offsetof(ECC_Encrypt_Out, C2)), 1344 (UINT16)(offsetof(ECC_Encrypt_Out, C3))}, 1345 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1346 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1347 TPMT_KDF_SCHEME_P_UNMARSHAL + ADD_FLAG, 1348 END_OF_LIST, 1349 TPM2B_ECC_POINT_P_MARSHAL, 1350 TPM2B_MAX_BUFFER_P_MARSHAL, 1351 TPM2B_DIGEST_P_MARSHAL, 1352 END_OF_LIST} 1353 }; 1354 1355 #define _ECC_EncryptDataAddress (&_ECC_EncryptData) 1356 #else 1357 #define _ECC_EncryptDataAddress 0 1358 #endif // CC_ECC_Encrypt 1359 1360 #if CC_ECC_Decrypt 1361 1362 #include "ECC_Decrypt_fp.h" 1363 1364 typedef TPM_RC (ECC_Decrypt_Entry)( 1365 ECC_Decrypt_In *in, 1366 ECC_Decrypt_Out *out 1367 ); 1368 1369 typedef const struct { 1370 ECC_Decrypt_Entry *entry; 1371 UINT16 inSize; 1372 UINT16 outSize; 1373 UINT16 offsetOfTypes; 1374 UINT16 paramOffsets[4]; 1375 BYTE types[8]; 1376 } ECC_Decrypt_COMMAND_DESCRIPTOR_t; 1377 1378 ECC_Decrypt_COMMAND_DESCRIPTOR_t _ECC_DecryptData = { 1379 /* entry */ &TPM2_ECC_Decrypt, 1380 /* inSize */ (UINT16)(sizeof(ECC_Decrypt_In)), 1381 /* outSize */ (UINT16)(sizeof(ECC_Decrypt_Out)), 1382 /* offsetOfTypes */ offsetof(ECC_Decrypt_COMMAND_DESCRIPTOR_t, types), 1383 /* offsets */ {(UINT16)(offsetof(ECC_Decrypt_In, C1)), 1384 (UINT16)(offsetof(ECC_Decrypt_In, C2)), 1385 (UINT16)(offsetof(ECC_Decrypt_In, C3)), 1386 (UINT16)(offsetof(ECC_Decrypt_In, inScheme))}, 1387 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1388 TPM2B_ECC_POINT_P_UNMARSHAL, 1389 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1390 TPM2B_DIGEST_P_UNMARSHAL, 1391 TPMT_KDF_SCHEME_P_UNMARSHAL + ADD_FLAG, 1392 END_OF_LIST, 1393 TPM2B_MAX_BUFFER_P_MARSHAL, 1394 END_OF_LIST} 1395 }; 1396 1397 #define _ECC_DecryptDataAddress (&_ECC_DecryptData) 1398 #else 1399 #define _ECC_DecryptDataAddress 0 1400 #endif // CC_ECC_Decrypt 1401 1402 #if CC_EncryptDecrypt 1403 1404 #include "EncryptDecrypt_fp.h" 1405 1406 typedef TPM_RC (EncryptDecrypt_Entry)( 1407 EncryptDecrypt_In *in, 1408 EncryptDecrypt_Out *out 1409 ); 1410 1411 typedef const struct { 1412 EncryptDecrypt_Entry *entry; 1413 UINT16 inSize; 1414 UINT16 outSize; 1415 UINT16 offsetOfTypes; 1416 UINT16 paramOffsets[5]; 1417 BYTE types[9]; 1418 } EncryptDecrypt_COMMAND_DESCRIPTOR_t; 1419 1420 EncryptDecrypt_COMMAND_DESCRIPTOR_t _EncryptDecryptData = { 1421 /* entry */ &TPM2_EncryptDecrypt, 1422 /* inSize */ (UINT16)(sizeof(EncryptDecrypt_In)), 1423 /* outSize */ (UINT16)(sizeof(EncryptDecrypt_Out)), 1424 /* offsetOfTypes */ offsetof(EncryptDecrypt_COMMAND_DESCRIPTOR_t, types), 1425 /* offsets */ {(UINT16)(offsetof(EncryptDecrypt_In, decrypt)), 1426 (UINT16)(offsetof(EncryptDecrypt_In, mode)), 1427 (UINT16)(offsetof(EncryptDecrypt_In, ivIn)), 1428 (UINT16)(offsetof(EncryptDecrypt_In, inData)), 1429 (UINT16)(offsetof(EncryptDecrypt_Out, ivOut))}, 1430 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1431 TPMI_YES_NO_P_UNMARSHAL, 1432 TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + ADD_FLAG, 1433 TPM2B_IV_P_UNMARSHAL, 1434 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1435 END_OF_LIST, 1436 TPM2B_MAX_BUFFER_P_MARSHAL, 1437 TPM2B_IV_P_MARSHAL, 1438 END_OF_LIST} 1439 }; 1440 1441 #define _EncryptDecryptDataAddress (&_EncryptDecryptData) 1442 #else 1443 #define _EncryptDecryptDataAddress 0 1444 #endif // CC_EncryptDecrypt 1445 1446 #if CC_EncryptDecrypt2 1447 1448 #include "EncryptDecrypt2_fp.h" 1449 1450 typedef TPM_RC (EncryptDecrypt2_Entry)( 1451 EncryptDecrypt2_In *in, 1452 EncryptDecrypt2_Out *out 1453 ); 1454 1455 typedef const struct { 1456 EncryptDecrypt2_Entry *entry; 1457 UINT16 inSize; 1458 UINT16 outSize; 1459 UINT16 offsetOfTypes; 1460 UINT16 paramOffsets[5]; 1461 BYTE types[9]; 1462 } EncryptDecrypt2_COMMAND_DESCRIPTOR_t; 1463 1464 EncryptDecrypt2_COMMAND_DESCRIPTOR_t _EncryptDecrypt2Data = { 1465 /* entry */ &TPM2_EncryptDecrypt2, 1466 /* inSize */ (UINT16)(sizeof(EncryptDecrypt2_In)), 1467 /* outSize */ (UINT16)(sizeof(EncryptDecrypt2_Out)), 1468 /* offsetOfTypes */ offsetof(EncryptDecrypt2_COMMAND_DESCRIPTOR_t, types), 1469 /* offsets */ {(UINT16)(offsetof(EncryptDecrypt2_In, inData)), 1470 (UINT16)(offsetof(EncryptDecrypt2_In, decrypt)), 1471 (UINT16)(offsetof(EncryptDecrypt2_In, mode)), 1472 (UINT16)(offsetof(EncryptDecrypt2_In, ivIn)), 1473 (UINT16)(offsetof(EncryptDecrypt2_Out, ivOut))}, 1474 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1475 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1476 TPMI_YES_NO_P_UNMARSHAL, 1477 TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + ADD_FLAG, 1478 TPM2B_IV_P_UNMARSHAL, 1479 END_OF_LIST, 1480 TPM2B_MAX_BUFFER_P_MARSHAL, 1481 TPM2B_IV_P_MARSHAL, 1482 END_OF_LIST} 1483 }; 1484 1485 #define _EncryptDecrypt2DataAddress (&_EncryptDecrypt2Data) 1486 #else 1487 #define _EncryptDecrypt2DataAddress 0 1488 #endif // CC_EncryptDecrypt2 1489 1490 #if CC_Hash 1491 1492 #include "Hash_fp.h" 1493 1494 typedef TPM_RC (Hash_Entry)( 1495 Hash_In *in, 1496 Hash_Out *out 1497 ); 1498 1499 typedef const struct { 1500 Hash_Entry *entry; 1501 UINT16 inSize; 1502 UINT16 outSize; 1503 UINT16 offsetOfTypes; 1504 UINT16 paramOffsets[3]; 1505 BYTE types[7]; 1506 } Hash_COMMAND_DESCRIPTOR_t; 1507 1508 Hash_COMMAND_DESCRIPTOR_t _HashData = { 1509 /* entry */ &TPM2_Hash, 1510 /* inSize */ (UINT16)(sizeof(Hash_In)), 1511 /* outSize */ (UINT16)(sizeof(Hash_Out)), 1512 /* offsetOfTypes */ offsetof(Hash_COMMAND_DESCRIPTOR_t, types), 1513 /* offsets */ {(UINT16)(offsetof(Hash_In, hashAlg)), 1514 (UINT16)(offsetof(Hash_In, hierarchy)), 1515 (UINT16)(offsetof(Hash_Out, validation))}, 1516 /* types */ {TPM2B_MAX_BUFFER_P_UNMARSHAL, 1517 TPMI_ALG_HASH_P_UNMARSHAL, 1518 TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG, 1519 END_OF_LIST, 1520 TPM2B_DIGEST_P_MARSHAL, 1521 TPMT_TK_HASHCHECK_P_MARSHAL, 1522 END_OF_LIST} 1523 }; 1524 1525 #define _HashDataAddress (&_HashData) 1526 #else 1527 #define _HashDataAddress 0 1528 #endif // CC_Hash 1529 1530 #if CC_HMAC 1531 1532 #include "HMAC_fp.h" 1533 1534 typedef TPM_RC (HMAC_Entry)( 1535 HMAC_In *in, 1536 HMAC_Out *out 1537 ); 1538 1539 typedef const struct { 1540 HMAC_Entry *entry; 1541 UINT16 inSize; 1542 UINT16 outSize; 1543 UINT16 offsetOfTypes; 1544 UINT16 paramOffsets[2]; 1545 BYTE types[6]; 1546 } HMAC_COMMAND_DESCRIPTOR_t; 1547 1548 HMAC_COMMAND_DESCRIPTOR_t _HMACData = { 1549 /* entry */ &TPM2_HMAC, 1550 /* inSize */ (UINT16)(sizeof(HMAC_In)), 1551 /* outSize */ (UINT16)(sizeof(HMAC_Out)), 1552 /* offsetOfTypes */ offsetof(HMAC_COMMAND_DESCRIPTOR_t, types), 1553 /* offsets */ {(UINT16)(offsetof(HMAC_In, buffer)), 1554 (UINT16)(offsetof(HMAC_In, hashAlg))}, 1555 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1556 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1557 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 1558 END_OF_LIST, 1559 TPM2B_DIGEST_P_MARSHAL, 1560 END_OF_LIST} 1561 }; 1562 1563 #define _HMACDataAddress (&_HMACData) 1564 #else 1565 #define _HMACDataAddress 0 1566 #endif // CC_HMAC 1567 1568 #if CC_MAC 1569 1570 #include "MAC_fp.h" 1571 1572 typedef TPM_RC (MAC_Entry)( 1573 MAC_In *in, 1574 MAC_Out *out 1575 ); 1576 1577 typedef const struct { 1578 MAC_Entry *entry; 1579 UINT16 inSize; 1580 UINT16 outSize; 1581 UINT16 offsetOfTypes; 1582 UINT16 paramOffsets[2]; 1583 BYTE types[6]; 1584 } MAC_COMMAND_DESCRIPTOR_t; 1585 1586 MAC_COMMAND_DESCRIPTOR_t _MACData = { 1587 /* entry */ &TPM2_MAC, 1588 /* inSize */ (UINT16)(sizeof(MAC_In)), 1589 /* outSize */ (UINT16)(sizeof(MAC_Out)), 1590 /* offsetOfTypes */ offsetof(MAC_COMMAND_DESCRIPTOR_t, types), 1591 /* offsets */ {(UINT16)(offsetof(MAC_In, buffer)), 1592 (UINT16)(offsetof(MAC_In, inScheme))}, 1593 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1594 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1595 TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + ADD_FLAG, 1596 END_OF_LIST, 1597 TPM2B_DIGEST_P_MARSHAL, 1598 END_OF_LIST} 1599 }; 1600 1601 #define _MACDataAddress (&_MACData) 1602 #else 1603 #define _MACDataAddress 0 1604 #endif // CC_MAC 1605 1606 #if CC_GetRandom 1607 1608 #include "GetRandom_fp.h" 1609 1610 typedef TPM_RC (GetRandom_Entry)( 1611 GetRandom_In *in, 1612 GetRandom_Out *out 1613 ); 1614 1615 typedef const struct { 1616 GetRandom_Entry *entry; 1617 UINT16 inSize; 1618 UINT16 outSize; 1619 UINT16 offsetOfTypes; 1620 BYTE types[4]; 1621 } GetRandom_COMMAND_DESCRIPTOR_t; 1622 1623 GetRandom_COMMAND_DESCRIPTOR_t _GetRandomData = { 1624 /* entry */ &TPM2_GetRandom, 1625 /* inSize */ (UINT16)(sizeof(GetRandom_In)), 1626 /* outSize */ (UINT16)(sizeof(GetRandom_Out)), 1627 /* offsetOfTypes */ offsetof(GetRandom_COMMAND_DESCRIPTOR_t, types), 1628 /* offsets */ // No parameter offsets; 1629 /* types */ {UINT16_P_UNMARSHAL, 1630 END_OF_LIST, 1631 TPM2B_DIGEST_P_MARSHAL, 1632 END_OF_LIST} 1633 }; 1634 1635 #define _GetRandomDataAddress (&_GetRandomData) 1636 #else 1637 #define _GetRandomDataAddress 0 1638 #endif // CC_GetRandom 1639 1640 #if CC_StirRandom 1641 1642 #include "StirRandom_fp.h" 1643 1644 typedef TPM_RC (StirRandom_Entry)( 1645 StirRandom_In *in 1646 ); 1647 1648 typedef const struct { 1649 StirRandom_Entry *entry; 1650 UINT16 inSize; 1651 UINT16 outSize; 1652 UINT16 offsetOfTypes; 1653 BYTE types[3]; 1654 } StirRandom_COMMAND_DESCRIPTOR_t; 1655 1656 StirRandom_COMMAND_DESCRIPTOR_t _StirRandomData = { 1657 /* entry */ &TPM2_StirRandom, 1658 /* inSize */ (UINT16)(sizeof(StirRandom_In)), 1659 /* outSize */ 0, 1660 /* offsetOfTypes */ offsetof(StirRandom_COMMAND_DESCRIPTOR_t, types), 1661 /* offsets */ // No parameter offsets; 1662 /* types */ {TPM2B_SENSITIVE_DATA_P_UNMARSHAL, 1663 END_OF_LIST, 1664 END_OF_LIST} 1665 }; 1666 1667 #define _StirRandomDataAddress (&_StirRandomData) 1668 #else 1669 #define _StirRandomDataAddress 0 1670 #endif // CC_StirRandom 1671 1672 #if CC_HMAC_Start 1673 1674 #include "HMAC_Start_fp.h" 1675 1676 typedef TPM_RC (HMAC_Start_Entry)( 1677 HMAC_Start_In *in, 1678 HMAC_Start_Out *out 1679 ); 1680 1681 typedef const struct { 1682 HMAC_Start_Entry *entry; 1683 UINT16 inSize; 1684 UINT16 outSize; 1685 UINT16 offsetOfTypes; 1686 UINT16 paramOffsets[2]; 1687 BYTE types[6]; 1688 } HMAC_Start_COMMAND_DESCRIPTOR_t; 1689 1690 HMAC_Start_COMMAND_DESCRIPTOR_t _HMAC_StartData = { 1691 /* entry */ &TPM2_HMAC_Start, 1692 /* inSize */ (UINT16)(sizeof(HMAC_Start_In)), 1693 /* outSize */ (UINT16)(sizeof(HMAC_Start_Out)), 1694 /* offsetOfTypes */ offsetof(HMAC_Start_COMMAND_DESCRIPTOR_t, types), 1695 /* offsets */ {(UINT16)(offsetof(HMAC_Start_In, auth)), 1696 (UINT16)(offsetof(HMAC_Start_In, hashAlg))}, 1697 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1698 TPM2B_AUTH_P_UNMARSHAL, 1699 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 1700 END_OF_LIST, 1701 TPMI_DH_OBJECT_H_MARSHAL, 1702 END_OF_LIST} 1703 }; 1704 1705 #define _HMAC_StartDataAddress (&_HMAC_StartData) 1706 #else 1707 #define _HMAC_StartDataAddress 0 1708 #endif // CC_HMAC_Start 1709 1710 #if CC_MAC_Start 1711 1712 #include "MAC_Start_fp.h" 1713 1714 typedef TPM_RC (MAC_Start_Entry)( 1715 MAC_Start_In *in, 1716 MAC_Start_Out *out 1717 ); 1718 1719 typedef const struct { 1720 MAC_Start_Entry *entry; 1721 UINT16 inSize; 1722 UINT16 outSize; 1723 UINT16 offsetOfTypes; 1724 UINT16 paramOffsets[2]; 1725 BYTE types[6]; 1726 } MAC_Start_COMMAND_DESCRIPTOR_t; 1727 1728 MAC_Start_COMMAND_DESCRIPTOR_t _MAC_StartData = { 1729 /* entry */ &TPM2_MAC_Start, 1730 /* inSize */ (UINT16)(sizeof(MAC_Start_In)), 1731 /* outSize */ (UINT16)(sizeof(MAC_Start_Out)), 1732 /* offsetOfTypes */ offsetof(MAC_Start_COMMAND_DESCRIPTOR_t, types), 1733 /* offsets */ {(UINT16)(offsetof(MAC_Start_In, auth)), 1734 (UINT16)(offsetof(MAC_Start_In, inScheme))}, 1735 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1736 TPM2B_AUTH_P_UNMARSHAL, 1737 TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + ADD_FLAG, 1738 END_OF_LIST, 1739 TPMI_DH_OBJECT_H_MARSHAL, 1740 END_OF_LIST} 1741 }; 1742 1743 #define _MAC_StartDataAddress (&_MAC_StartData) 1744 #else 1745 #define _MAC_StartDataAddress 0 1746 #endif // CC_MAC_Start 1747 1748 #if CC_HashSequenceStart 1749 1750 #include "HashSequenceStart_fp.h" 1751 1752 typedef TPM_RC (HashSequenceStart_Entry)( 1753 HashSequenceStart_In *in, 1754 HashSequenceStart_Out *out 1755 ); 1756 1757 typedef const struct { 1758 HashSequenceStart_Entry *entry; 1759 UINT16 inSize; 1760 UINT16 outSize; 1761 UINT16 offsetOfTypes; 1762 UINT16 paramOffsets[1]; 1763 BYTE types[5]; 1764 } HashSequenceStart_COMMAND_DESCRIPTOR_t; 1765 1766 HashSequenceStart_COMMAND_DESCRIPTOR_t _HashSequenceStartData = { 1767 /* entry */ &TPM2_HashSequenceStart, 1768 /* inSize */ (UINT16)(sizeof(HashSequenceStart_In)), 1769 /* outSize */ (UINT16)(sizeof(HashSequenceStart_Out)), 1770 /* offsetOfTypes */ offsetof(HashSequenceStart_COMMAND_DESCRIPTOR_t, types), 1771 /* offsets */ {(UINT16)(offsetof(HashSequenceStart_In, hashAlg))}, 1772 /* types */ {TPM2B_AUTH_P_UNMARSHAL, 1773 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 1774 END_OF_LIST, 1775 TPMI_DH_OBJECT_H_MARSHAL, 1776 END_OF_LIST} 1777 }; 1778 1779 #define _HashSequenceStartDataAddress (&_HashSequenceStartData) 1780 #else 1781 #define _HashSequenceStartDataAddress 0 1782 #endif // CC_HashSequenceStart 1783 1784 #if CC_SequenceUpdate 1785 1786 #include "SequenceUpdate_fp.h" 1787 1788 typedef TPM_RC (SequenceUpdate_Entry)( 1789 SequenceUpdate_In *in 1790 ); 1791 1792 typedef const struct { 1793 SequenceUpdate_Entry *entry; 1794 UINT16 inSize; 1795 UINT16 outSize; 1796 UINT16 offsetOfTypes; 1797 UINT16 paramOffsets[1]; 1798 BYTE types[4]; 1799 } SequenceUpdate_COMMAND_DESCRIPTOR_t; 1800 1801 SequenceUpdate_COMMAND_DESCRIPTOR_t _SequenceUpdateData = { 1802 /* entry */ &TPM2_SequenceUpdate, 1803 /* inSize */ (UINT16)(sizeof(SequenceUpdate_In)), 1804 /* outSize */ 0, 1805 /* offsetOfTypes */ offsetof(SequenceUpdate_COMMAND_DESCRIPTOR_t, types), 1806 /* offsets */ {(UINT16)(offsetof(SequenceUpdate_In, buffer))}, 1807 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1808 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1809 END_OF_LIST, 1810 END_OF_LIST} 1811 }; 1812 1813 #define _SequenceUpdateDataAddress (&_SequenceUpdateData) 1814 #else 1815 #define _SequenceUpdateDataAddress 0 1816 #endif // CC_SequenceUpdate 1817 1818 #if CC_SequenceComplete 1819 1820 #include "SequenceComplete_fp.h" 1821 1822 typedef TPM_RC (SequenceComplete_Entry)( 1823 SequenceComplete_In *in, 1824 SequenceComplete_Out *out 1825 ); 1826 1827 typedef const struct { 1828 SequenceComplete_Entry *entry; 1829 UINT16 inSize; 1830 UINT16 outSize; 1831 UINT16 offsetOfTypes; 1832 UINT16 paramOffsets[3]; 1833 BYTE types[7]; 1834 } SequenceComplete_COMMAND_DESCRIPTOR_t; 1835 1836 SequenceComplete_COMMAND_DESCRIPTOR_t _SequenceCompleteData = { 1837 /* entry */ &TPM2_SequenceComplete, 1838 /* inSize */ (UINT16)(sizeof(SequenceComplete_In)), 1839 /* outSize */ (UINT16)(sizeof(SequenceComplete_Out)), 1840 /* offsetOfTypes */ offsetof(SequenceComplete_COMMAND_DESCRIPTOR_t, types), 1841 /* offsets */ {(UINT16)(offsetof(SequenceComplete_In, buffer)), 1842 (UINT16)(offsetof(SequenceComplete_In, hierarchy)), 1843 (UINT16)(offsetof(SequenceComplete_Out, validation))}, 1844 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1845 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1846 TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG, 1847 END_OF_LIST, 1848 TPM2B_DIGEST_P_MARSHAL, 1849 TPMT_TK_HASHCHECK_P_MARSHAL, 1850 END_OF_LIST} 1851 }; 1852 1853 #define _SequenceCompleteDataAddress (&_SequenceCompleteData) 1854 #else 1855 #define _SequenceCompleteDataAddress 0 1856 #endif // CC_SequenceComplete 1857 1858 #if CC_EventSequenceComplete 1859 1860 #include "EventSequenceComplete_fp.h" 1861 1862 typedef TPM_RC (EventSequenceComplete_Entry)( 1863 EventSequenceComplete_In *in, 1864 EventSequenceComplete_Out *out 1865 ); 1866 1867 typedef const struct { 1868 EventSequenceComplete_Entry *entry; 1869 UINT16 inSize; 1870 UINT16 outSize; 1871 UINT16 offsetOfTypes; 1872 UINT16 paramOffsets[2]; 1873 BYTE types[6]; 1874 } EventSequenceComplete_COMMAND_DESCRIPTOR_t; 1875 1876 EventSequenceComplete_COMMAND_DESCRIPTOR_t _EventSequenceCompleteData = { 1877 /* entry */ &TPM2_EventSequenceComplete, 1878 /* inSize */ (UINT16)(sizeof(EventSequenceComplete_In)), 1879 /* outSize */ (UINT16)(sizeof(EventSequenceComplete_Out)), 1880 /* offsetOfTypes */ offsetof(EventSequenceComplete_COMMAND_DESCRIPTOR_t, types), 1881 /* offsets */ {(UINT16)(offsetof(EventSequenceComplete_In, sequenceHandle)), 1882 (UINT16)(offsetof(EventSequenceComplete_In, buffer))}, 1883 /* types */ {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG, 1884 TPMI_DH_OBJECT_H_UNMARSHAL, 1885 TPM2B_MAX_BUFFER_P_UNMARSHAL, 1886 END_OF_LIST, 1887 TPML_DIGEST_VALUES_P_MARSHAL, 1888 END_OF_LIST} 1889 }; 1890 1891 #define _EventSequenceCompleteDataAddress (&_EventSequenceCompleteData) 1892 #else 1893 #define _EventSequenceCompleteDataAddress 0 1894 #endif // CC_EventSequenceComplete 1895 1896 #if CC_Certify 1897 1898 #include "Certify_fp.h" 1899 1900 typedef TPM_RC (Certify_Entry)( 1901 Certify_In *in, 1902 Certify_Out *out 1903 ); 1904 1905 typedef const struct { 1906 Certify_Entry *entry; 1907 UINT16 inSize; 1908 UINT16 outSize; 1909 UINT16 offsetOfTypes; 1910 UINT16 paramOffsets[4]; 1911 BYTE types[8]; 1912 } Certify_COMMAND_DESCRIPTOR_t; 1913 1914 Certify_COMMAND_DESCRIPTOR_t _CertifyData = { 1915 /* entry */ &TPM2_Certify, 1916 /* inSize */ (UINT16)(sizeof(Certify_In)), 1917 /* outSize */ (UINT16)(sizeof(Certify_Out)), 1918 /* offsetOfTypes */ offsetof(Certify_COMMAND_DESCRIPTOR_t, types), 1919 /* offsets */ {(UINT16)(offsetof(Certify_In, signHandle)), 1920 (UINT16)(offsetof(Certify_In, qualifyingData)), 1921 (UINT16)(offsetof(Certify_In, inScheme)), 1922 (UINT16)(offsetof(Certify_Out, signature))}, 1923 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 1924 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 1925 TPM2B_DATA_P_UNMARSHAL, 1926 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 1927 END_OF_LIST, 1928 TPM2B_ATTEST_P_MARSHAL, 1929 TPMT_SIGNATURE_P_MARSHAL, 1930 END_OF_LIST} 1931 }; 1932 1933 #define _CertifyDataAddress (&_CertifyData) 1934 #else 1935 #define _CertifyDataAddress 0 1936 #endif // CC_Certify 1937 1938 #if CC_CertifyCreation 1939 1940 #include "CertifyCreation_fp.h" 1941 1942 typedef TPM_RC (CertifyCreation_Entry)( 1943 CertifyCreation_In *in, 1944 CertifyCreation_Out *out 1945 ); 1946 1947 typedef const struct { 1948 CertifyCreation_Entry *entry; 1949 UINT16 inSize; 1950 UINT16 outSize; 1951 UINT16 offsetOfTypes; 1952 UINT16 paramOffsets[6]; 1953 BYTE types[10]; 1954 } CertifyCreation_COMMAND_DESCRIPTOR_t; 1955 1956 CertifyCreation_COMMAND_DESCRIPTOR_t _CertifyCreationData = { 1957 /* entry */ &TPM2_CertifyCreation, 1958 /* inSize */ (UINT16)(sizeof(CertifyCreation_In)), 1959 /* outSize */ (UINT16)(sizeof(CertifyCreation_Out)), 1960 /* offsetOfTypes */ offsetof(CertifyCreation_COMMAND_DESCRIPTOR_t, types), 1961 /* offsets */ {(UINT16)(offsetof(CertifyCreation_In, objectHandle)), 1962 (UINT16)(offsetof(CertifyCreation_In, qualifyingData)), 1963 (UINT16)(offsetof(CertifyCreation_In, creationHash)), 1964 (UINT16)(offsetof(CertifyCreation_In, inScheme)), 1965 (UINT16)(offsetof(CertifyCreation_In, creationTicket)), 1966 (UINT16)(offsetof(CertifyCreation_Out, signature))}, 1967 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 1968 TPMI_DH_OBJECT_H_UNMARSHAL, 1969 TPM2B_DATA_P_UNMARSHAL, 1970 TPM2B_DIGEST_P_UNMARSHAL, 1971 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 1972 TPMT_TK_CREATION_P_UNMARSHAL, 1973 END_OF_LIST, 1974 TPM2B_ATTEST_P_MARSHAL, 1975 TPMT_SIGNATURE_P_MARSHAL, 1976 END_OF_LIST} 1977 }; 1978 1979 #define _CertifyCreationDataAddress (&_CertifyCreationData) 1980 #else 1981 #define _CertifyCreationDataAddress 0 1982 #endif // CC_CertifyCreation 1983 1984 #if CC_Quote 1985 1986 #include "Quote_fp.h" 1987 1988 typedef TPM_RC (Quote_Entry)( 1989 Quote_In *in, 1990 Quote_Out *out 1991 ); 1992 1993 typedef const struct { 1994 Quote_Entry *entry; 1995 UINT16 inSize; 1996 UINT16 outSize; 1997 UINT16 offsetOfTypes; 1998 UINT16 paramOffsets[4]; 1999 BYTE types[8]; 2000 } Quote_COMMAND_DESCRIPTOR_t; 2001 2002 Quote_COMMAND_DESCRIPTOR_t _QuoteData = { 2003 /* entry */ &TPM2_Quote, 2004 /* inSize */ (UINT16)(sizeof(Quote_In)), 2005 /* outSize */ (UINT16)(sizeof(Quote_Out)), 2006 /* offsetOfTypes */ offsetof(Quote_COMMAND_DESCRIPTOR_t, types), 2007 /* offsets */ {(UINT16)(offsetof(Quote_In, qualifyingData)), 2008 (UINT16)(offsetof(Quote_In, inScheme)), 2009 (UINT16)(offsetof(Quote_In, PCRselect)), 2010 (UINT16)(offsetof(Quote_Out, signature))}, 2011 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 2012 TPM2B_DATA_P_UNMARSHAL, 2013 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2014 TPML_PCR_SELECTION_P_UNMARSHAL, 2015 END_OF_LIST, 2016 TPM2B_ATTEST_P_MARSHAL, 2017 TPMT_SIGNATURE_P_MARSHAL, 2018 END_OF_LIST} 2019 }; 2020 2021 #define _QuoteDataAddress (&_QuoteData) 2022 #else 2023 #define _QuoteDataAddress 0 2024 #endif // CC_Quote 2025 2026 #if CC_GetSessionAuditDigest 2027 2028 #include "GetSessionAuditDigest_fp.h" 2029 2030 typedef TPM_RC (GetSessionAuditDigest_Entry)( 2031 GetSessionAuditDigest_In *in, 2032 GetSessionAuditDigest_Out *out 2033 ); 2034 2035 typedef const struct { 2036 GetSessionAuditDigest_Entry *entry; 2037 UINT16 inSize; 2038 UINT16 outSize; 2039 UINT16 offsetOfTypes; 2040 UINT16 paramOffsets[5]; 2041 BYTE types[9]; 2042 } GetSessionAuditDigest_COMMAND_DESCRIPTOR_t; 2043 2044 GetSessionAuditDigest_COMMAND_DESCRIPTOR_t _GetSessionAuditDigestData = { 2045 /* entry */ &TPM2_GetSessionAuditDigest, 2046 /* inSize */ (UINT16)(sizeof(GetSessionAuditDigest_In)), 2047 /* outSize */ (UINT16)(sizeof(GetSessionAuditDigest_Out)), 2048 /* offsetOfTypes */ offsetof(GetSessionAuditDigest_COMMAND_DESCRIPTOR_t, types), 2049 /* offsets */ {(UINT16)(offsetof(GetSessionAuditDigest_In, signHandle)), 2050 (UINT16)(offsetof(GetSessionAuditDigest_In, sessionHandle)), 2051 (UINT16)(offsetof(GetSessionAuditDigest_In, qualifyingData)), 2052 (UINT16)(offsetof(GetSessionAuditDigest_In, inScheme)), 2053 (UINT16)(offsetof(GetSessionAuditDigest_Out, signature))}, 2054 /* types */ {TPMI_RH_ENDORSEMENT_H_UNMARSHAL, 2055 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 2056 TPMI_SH_HMAC_H_UNMARSHAL, 2057 TPM2B_DATA_P_UNMARSHAL, 2058 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2059 END_OF_LIST, 2060 TPM2B_ATTEST_P_MARSHAL, 2061 TPMT_SIGNATURE_P_MARSHAL, 2062 END_OF_LIST} 2063 }; 2064 2065 #define _GetSessionAuditDigestDataAddress (&_GetSessionAuditDigestData) 2066 #else 2067 #define _GetSessionAuditDigestDataAddress 0 2068 #endif // CC_GetSessionAuditDigest 2069 2070 #if CC_GetCommandAuditDigest 2071 2072 #include "GetCommandAuditDigest_fp.h" 2073 2074 typedef TPM_RC (GetCommandAuditDigest_Entry)( 2075 GetCommandAuditDigest_In *in, 2076 GetCommandAuditDigest_Out *out 2077 ); 2078 2079 typedef const struct { 2080 GetCommandAuditDigest_Entry *entry; 2081 UINT16 inSize; 2082 UINT16 outSize; 2083 UINT16 offsetOfTypes; 2084 UINT16 paramOffsets[4]; 2085 BYTE types[8]; 2086 } GetCommandAuditDigest_COMMAND_DESCRIPTOR_t; 2087 2088 GetCommandAuditDigest_COMMAND_DESCRIPTOR_t _GetCommandAuditDigestData = { 2089 /* entry */ &TPM2_GetCommandAuditDigest, 2090 /* inSize */ (UINT16)(sizeof(GetCommandAuditDigest_In)), 2091 /* outSize */ (UINT16)(sizeof(GetCommandAuditDigest_Out)), 2092 /* offsetOfTypes */ offsetof(GetCommandAuditDigest_COMMAND_DESCRIPTOR_t, types), 2093 /* offsets */ {(UINT16)(offsetof(GetCommandAuditDigest_In, signHandle)), 2094 (UINT16)(offsetof(GetCommandAuditDigest_In, qualifyingData)), 2095 (UINT16)(offsetof(GetCommandAuditDigest_In, inScheme)), 2096 (UINT16)(offsetof(GetCommandAuditDigest_Out, signature))}, 2097 /* types */ {TPMI_RH_ENDORSEMENT_H_UNMARSHAL, 2098 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 2099 TPM2B_DATA_P_UNMARSHAL, 2100 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2101 END_OF_LIST, 2102 TPM2B_ATTEST_P_MARSHAL, 2103 TPMT_SIGNATURE_P_MARSHAL, 2104 END_OF_LIST} 2105 }; 2106 2107 #define _GetCommandAuditDigestDataAddress (&_GetCommandAuditDigestData) 2108 #else 2109 #define _GetCommandAuditDigestDataAddress 0 2110 #endif // CC_GetCommandAuditDigest 2111 2112 #if CC_GetTime 2113 2114 #include "GetTime_fp.h" 2115 2116 typedef TPM_RC (GetTime_Entry)( 2117 GetTime_In *in, 2118 GetTime_Out *out 2119 ); 2120 2121 typedef const struct { 2122 GetTime_Entry *entry; 2123 UINT16 inSize; 2124 UINT16 outSize; 2125 UINT16 offsetOfTypes; 2126 UINT16 paramOffsets[4]; 2127 BYTE types[8]; 2128 } GetTime_COMMAND_DESCRIPTOR_t; 2129 2130 GetTime_COMMAND_DESCRIPTOR_t _GetTimeData = { 2131 /* entry */ &TPM2_GetTime, 2132 /* inSize */ (UINT16)(sizeof(GetTime_In)), 2133 /* outSize */ (UINT16)(sizeof(GetTime_Out)), 2134 /* offsetOfTypes */ offsetof(GetTime_COMMAND_DESCRIPTOR_t, types), 2135 /* offsets */ {(UINT16)(offsetof(GetTime_In, signHandle)), 2136 (UINT16)(offsetof(GetTime_In, qualifyingData)), 2137 (UINT16)(offsetof(GetTime_In, inScheme)), 2138 (UINT16)(offsetof(GetTime_Out, signature))}, 2139 /* types */ {TPMI_RH_ENDORSEMENT_H_UNMARSHAL, 2140 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 2141 TPM2B_DATA_P_UNMARSHAL, 2142 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2143 END_OF_LIST, 2144 TPM2B_ATTEST_P_MARSHAL, 2145 TPMT_SIGNATURE_P_MARSHAL, 2146 END_OF_LIST} 2147 }; 2148 2149 #define _GetTimeDataAddress (&_GetTimeData) 2150 #else 2151 #define _GetTimeDataAddress 0 2152 #endif // CC_GetTime 2153 2154 #if CC_CertifyX509 2155 2156 #include "CertifyX509_fp.h" 2157 2158 typedef TPM_RC (CertifyX509_Entry)( 2159 CertifyX509_In *in, 2160 CertifyX509_Out *out 2161 ); 2162 2163 typedef const struct { 2164 CertifyX509_Entry *entry; 2165 UINT16 inSize; 2166 UINT16 outSize; 2167 UINT16 offsetOfTypes; 2168 UINT16 paramOffsets[6]; 2169 BYTE types[10]; 2170 } CertifyX509_COMMAND_DESCRIPTOR_t; 2171 2172 CertifyX509_COMMAND_DESCRIPTOR_t _CertifyX509Data = { 2173 /* entry */ &TPM2_CertifyX509, 2174 /* inSize */ (UINT16)(sizeof(CertifyX509_In)), 2175 /* outSize */ (UINT16)(sizeof(CertifyX509_Out)), 2176 /* offsetOfTypes */ offsetof(CertifyX509_COMMAND_DESCRIPTOR_t, types), 2177 /* offsets */ {(UINT16)(offsetof(CertifyX509_In, signHandle)), 2178 (UINT16)(offsetof(CertifyX509_In, reserved)), 2179 (UINT16)(offsetof(CertifyX509_In, inScheme)), 2180 (UINT16)(offsetof(CertifyX509_In, partialCertificate)), 2181 (UINT16)(offsetof(CertifyX509_Out, tbsDigest)), 2182 (UINT16)(offsetof(CertifyX509_Out, signature))}, 2183 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 2184 TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 2185 TPM2B_DATA_P_UNMARSHAL, 2186 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2187 TPM2B_MAX_BUFFER_P_UNMARSHAL, 2188 END_OF_LIST, 2189 TPM2B_MAX_BUFFER_P_MARSHAL, 2190 TPM2B_DIGEST_P_MARSHAL, 2191 TPMT_SIGNATURE_P_MARSHAL, 2192 END_OF_LIST} 2193 }; 2194 2195 #define _CertifyX509DataAddress (&_CertifyX509Data) 2196 #else 2197 #define _CertifyX509DataAddress 0 2198 #endif // CC_CertifyX509 2199 2200 #if CC_Commit 2201 2202 #include "Commit_fp.h" 2203 2204 typedef TPM_RC (Commit_Entry)( 2205 Commit_In *in, 2206 Commit_Out *out 2207 ); 2208 2209 typedef const struct { 2210 Commit_Entry *entry; 2211 UINT16 inSize; 2212 UINT16 outSize; 2213 UINT16 offsetOfTypes; 2214 UINT16 paramOffsets[6]; 2215 BYTE types[10]; 2216 } Commit_COMMAND_DESCRIPTOR_t; 2217 2218 Commit_COMMAND_DESCRIPTOR_t _CommitData = { 2219 /* entry */ &TPM2_Commit, 2220 /* inSize */ (UINT16)(sizeof(Commit_In)), 2221 /* outSize */ (UINT16)(sizeof(Commit_Out)), 2222 /* offsetOfTypes */ offsetof(Commit_COMMAND_DESCRIPTOR_t, types), 2223 /* offsets */ {(UINT16)(offsetof(Commit_In, P1)), 2224 (UINT16)(offsetof(Commit_In, s2)), 2225 (UINT16)(offsetof(Commit_In, y2)), 2226 (UINT16)(offsetof(Commit_Out, L)), 2227 (UINT16)(offsetof(Commit_Out, E)), 2228 (UINT16)(offsetof(Commit_Out, counter))}, 2229 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 2230 TPM2B_ECC_POINT_P_UNMARSHAL, 2231 TPM2B_SENSITIVE_DATA_P_UNMARSHAL, 2232 TPM2B_ECC_PARAMETER_P_UNMARSHAL, 2233 END_OF_LIST, 2234 TPM2B_ECC_POINT_P_MARSHAL, 2235 TPM2B_ECC_POINT_P_MARSHAL, 2236 TPM2B_ECC_POINT_P_MARSHAL, 2237 UINT16_P_MARSHAL, 2238 END_OF_LIST} 2239 }; 2240 2241 #define _CommitDataAddress (&_CommitData) 2242 #else 2243 #define _CommitDataAddress 0 2244 #endif // CC_Commit 2245 2246 #if CC_EC_Ephemeral 2247 2248 #include "EC_Ephemeral_fp.h" 2249 2250 typedef TPM_RC (EC_Ephemeral_Entry)( 2251 EC_Ephemeral_In *in, 2252 EC_Ephemeral_Out *out 2253 ); 2254 2255 typedef const struct { 2256 EC_Ephemeral_Entry *entry; 2257 UINT16 inSize; 2258 UINT16 outSize; 2259 UINT16 offsetOfTypes; 2260 UINT16 paramOffsets[1]; 2261 BYTE types[5]; 2262 } EC_Ephemeral_COMMAND_DESCRIPTOR_t; 2263 2264 EC_Ephemeral_COMMAND_DESCRIPTOR_t _EC_EphemeralData = { 2265 /* entry */ &TPM2_EC_Ephemeral, 2266 /* inSize */ (UINT16)(sizeof(EC_Ephemeral_In)), 2267 /* outSize */ (UINT16)(sizeof(EC_Ephemeral_Out)), 2268 /* offsetOfTypes */ offsetof(EC_Ephemeral_COMMAND_DESCRIPTOR_t, types), 2269 /* offsets */ {(UINT16)(offsetof(EC_Ephemeral_Out, counter))}, 2270 /* types */ {TPMI_ECC_CURVE_P_UNMARSHAL, 2271 END_OF_LIST, 2272 TPM2B_ECC_POINT_P_MARSHAL, 2273 UINT16_P_MARSHAL, 2274 END_OF_LIST} 2275 }; 2276 2277 #define _EC_EphemeralDataAddress (&_EC_EphemeralData) 2278 #else 2279 #define _EC_EphemeralDataAddress 0 2280 #endif // CC_EC_Ephemeral 2281 2282 #if CC_VerifySignature 2283 2284 #include "VerifySignature_fp.h" 2285 2286 typedef TPM_RC (VerifySignature_Entry)( 2287 VerifySignature_In *in, 2288 VerifySignature_Out *out 2289 ); 2290 2291 typedef const struct { 2292 VerifySignature_Entry *entry; 2293 UINT16 inSize; 2294 UINT16 outSize; 2295 UINT16 offsetOfTypes; 2296 UINT16 paramOffsets[2]; 2297 BYTE types[6]; 2298 } VerifySignature_COMMAND_DESCRIPTOR_t; 2299 2300 VerifySignature_COMMAND_DESCRIPTOR_t _VerifySignatureData = { 2301 /* entry */ &TPM2_VerifySignature, 2302 /* inSize */ (UINT16)(sizeof(VerifySignature_In)), 2303 /* outSize */ (UINT16)(sizeof(VerifySignature_Out)), 2304 /* offsetOfTypes */ offsetof(VerifySignature_COMMAND_DESCRIPTOR_t, types), 2305 /* offsets */ {(UINT16)(offsetof(VerifySignature_In, digest)), 2306 (UINT16)(offsetof(VerifySignature_In, signature))}, 2307 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 2308 TPM2B_DIGEST_P_UNMARSHAL, 2309 TPMT_SIGNATURE_P_UNMARSHAL, 2310 END_OF_LIST, 2311 TPMT_TK_VERIFIED_P_MARSHAL, 2312 END_OF_LIST} 2313 }; 2314 2315 #define _VerifySignatureDataAddress (&_VerifySignatureData) 2316 #else 2317 #define _VerifySignatureDataAddress 0 2318 #endif // CC_VerifySignature 2319 2320 #if CC_Sign 2321 2322 #include "Sign_fp.h" 2323 2324 typedef TPM_RC (Sign_Entry)( 2325 Sign_In *in, 2326 Sign_Out *out 2327 ); 2328 2329 typedef const struct { 2330 Sign_Entry *entry; 2331 UINT16 inSize; 2332 UINT16 outSize; 2333 UINT16 offsetOfTypes; 2334 UINT16 paramOffsets[3]; 2335 BYTE types[7]; 2336 } Sign_COMMAND_DESCRIPTOR_t; 2337 2338 Sign_COMMAND_DESCRIPTOR_t _SignData = { 2339 /* entry */ &TPM2_Sign, 2340 /* inSize */ (UINT16)(sizeof(Sign_In)), 2341 /* outSize */ (UINT16)(sizeof(Sign_Out)), 2342 /* offsetOfTypes */ offsetof(Sign_COMMAND_DESCRIPTOR_t, types), 2343 /* offsets */ {(UINT16)(offsetof(Sign_In, digest)), 2344 (UINT16)(offsetof(Sign_In, inScheme)), 2345 (UINT16)(offsetof(Sign_In, validation))}, 2346 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 2347 TPM2B_DIGEST_P_UNMARSHAL, 2348 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 2349 TPMT_TK_HASHCHECK_P_UNMARSHAL, 2350 END_OF_LIST, 2351 TPMT_SIGNATURE_P_MARSHAL, 2352 END_OF_LIST} 2353 }; 2354 2355 #define _SignDataAddress (&_SignData) 2356 #else 2357 #define _SignDataAddress 0 2358 #endif // CC_Sign 2359 2360 #if CC_SetCommandCodeAuditStatus 2361 2362 #include "SetCommandCodeAuditStatus_fp.h" 2363 2364 typedef TPM_RC (SetCommandCodeAuditStatus_Entry)( 2365 SetCommandCodeAuditStatus_In *in 2366 ); 2367 2368 typedef const struct { 2369 SetCommandCodeAuditStatus_Entry *entry; 2370 UINT16 inSize; 2371 UINT16 outSize; 2372 UINT16 offsetOfTypes; 2373 UINT16 paramOffsets[3]; 2374 BYTE types[6]; 2375 } SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t; 2376 2377 SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t _SetCommandCodeAuditStatusData = { 2378 /* entry */ &TPM2_SetCommandCodeAuditStatus, 2379 /* inSize */ (UINT16)(sizeof(SetCommandCodeAuditStatus_In)), 2380 /* outSize */ 0, 2381 /* offsetOfTypes */ offsetof(SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t, types), 2382 /* offsets */ {(UINT16)(offsetof(SetCommandCodeAuditStatus_In, auditAlg)), 2383 (UINT16)(offsetof(SetCommandCodeAuditStatus_In, setList)), 2384 (UINT16)(offsetof(SetCommandCodeAuditStatus_In, clearList))}, 2385 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 2386 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 2387 TPML_CC_P_UNMARSHAL, 2388 TPML_CC_P_UNMARSHAL, 2389 END_OF_LIST, 2390 END_OF_LIST} 2391 }; 2392 2393 #define _SetCommandCodeAuditStatusDataAddress (&_SetCommandCodeAuditStatusData) 2394 #else 2395 #define _SetCommandCodeAuditStatusDataAddress 0 2396 #endif // CC_SetCommandCodeAuditStatus 2397 2398 #if CC_PCR_Extend 2399 2400 #include "PCR_Extend_fp.h" 2401 2402 typedef TPM_RC (PCR_Extend_Entry)( 2403 PCR_Extend_In *in 2404 ); 2405 2406 typedef const struct { 2407 PCR_Extend_Entry *entry; 2408 UINT16 inSize; 2409 UINT16 outSize; 2410 UINT16 offsetOfTypes; 2411 UINT16 paramOffsets[1]; 2412 BYTE types[4]; 2413 } PCR_Extend_COMMAND_DESCRIPTOR_t; 2414 2415 PCR_Extend_COMMAND_DESCRIPTOR_t _PCR_ExtendData = { 2416 /* entry */ &TPM2_PCR_Extend, 2417 /* inSize */ (UINT16)(sizeof(PCR_Extend_In)), 2418 /* outSize */ 0, 2419 /* offsetOfTypes */ offsetof(PCR_Extend_COMMAND_DESCRIPTOR_t, types), 2420 /* offsets */ {(UINT16)(offsetof(PCR_Extend_In, digests))}, 2421 /* types */ {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG, 2422 TPML_DIGEST_VALUES_P_UNMARSHAL, 2423 END_OF_LIST, 2424 END_OF_LIST} 2425 }; 2426 2427 #define _PCR_ExtendDataAddress (&_PCR_ExtendData) 2428 #else 2429 #define _PCR_ExtendDataAddress 0 2430 #endif // CC_PCR_Extend 2431 2432 #if CC_PCR_Event 2433 2434 #include "PCR_Event_fp.h" 2435 2436 typedef TPM_RC (PCR_Event_Entry)( 2437 PCR_Event_In *in, 2438 PCR_Event_Out *out 2439 ); 2440 2441 typedef const struct { 2442 PCR_Event_Entry *entry; 2443 UINT16 inSize; 2444 UINT16 outSize; 2445 UINT16 offsetOfTypes; 2446 UINT16 paramOffsets[1]; 2447 BYTE types[5]; 2448 } PCR_Event_COMMAND_DESCRIPTOR_t; 2449 2450 PCR_Event_COMMAND_DESCRIPTOR_t _PCR_EventData = { 2451 /* entry */ &TPM2_PCR_Event, 2452 /* inSize */ (UINT16)(sizeof(PCR_Event_In)), 2453 /* outSize */ (UINT16)(sizeof(PCR_Event_Out)), 2454 /* offsetOfTypes */ offsetof(PCR_Event_COMMAND_DESCRIPTOR_t, types), 2455 /* offsets */ {(UINT16)(offsetof(PCR_Event_In, eventData))}, 2456 /* types */ {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG, 2457 TPM2B_EVENT_P_UNMARSHAL, 2458 END_OF_LIST, 2459 TPML_DIGEST_VALUES_P_MARSHAL, 2460 END_OF_LIST} 2461 }; 2462 2463 #define _PCR_EventDataAddress (&_PCR_EventData) 2464 #else 2465 #define _PCR_EventDataAddress 0 2466 #endif // CC_PCR_Event 2467 2468 #if CC_PCR_Read 2469 2470 #include "PCR_Read_fp.h" 2471 2472 typedef TPM_RC (PCR_Read_Entry)( 2473 PCR_Read_In *in, 2474 PCR_Read_Out *out 2475 ); 2476 2477 typedef const struct { 2478 PCR_Read_Entry *entry; 2479 UINT16 inSize; 2480 UINT16 outSize; 2481 UINT16 offsetOfTypes; 2482 UINT16 paramOffsets[2]; 2483 BYTE types[6]; 2484 } PCR_Read_COMMAND_DESCRIPTOR_t; 2485 2486 PCR_Read_COMMAND_DESCRIPTOR_t _PCR_ReadData = { 2487 /* entry */ &TPM2_PCR_Read, 2488 /* inSize */ (UINT16)(sizeof(PCR_Read_In)), 2489 /* outSize */ (UINT16)(sizeof(PCR_Read_Out)), 2490 /* offsetOfTypes */ offsetof(PCR_Read_COMMAND_DESCRIPTOR_t, types), 2491 /* offsets */ {(UINT16)(offsetof(PCR_Read_Out, pcrSelectionOut)), 2492 (UINT16)(offsetof(PCR_Read_Out, pcrValues))}, 2493 /* types */ {TPML_PCR_SELECTION_P_UNMARSHAL, 2494 END_OF_LIST, 2495 UINT32_P_MARSHAL, 2496 TPML_PCR_SELECTION_P_MARSHAL, 2497 TPML_DIGEST_P_MARSHAL, 2498 END_OF_LIST} 2499 }; 2500 2501 #define _PCR_ReadDataAddress (&_PCR_ReadData) 2502 #else 2503 #define _PCR_ReadDataAddress 0 2504 #endif // CC_PCR_Read 2505 2506 #if CC_PCR_Allocate 2507 2508 #include "PCR_Allocate_fp.h" 2509 2510 typedef TPM_RC (PCR_Allocate_Entry)( 2511 PCR_Allocate_In *in, 2512 PCR_Allocate_Out *out 2513 ); 2514 2515 typedef const struct { 2516 PCR_Allocate_Entry *entry; 2517 UINT16 inSize; 2518 UINT16 outSize; 2519 UINT16 offsetOfTypes; 2520 UINT16 paramOffsets[4]; 2521 BYTE types[8]; 2522 } PCR_Allocate_COMMAND_DESCRIPTOR_t; 2523 2524 PCR_Allocate_COMMAND_DESCRIPTOR_t _PCR_AllocateData = { 2525 /* entry */ &TPM2_PCR_Allocate, 2526 /* inSize */ (UINT16)(sizeof(PCR_Allocate_In)), 2527 /* outSize */ (UINT16)(sizeof(PCR_Allocate_Out)), 2528 /* offsetOfTypes */ offsetof(PCR_Allocate_COMMAND_DESCRIPTOR_t, types), 2529 /* offsets */ {(UINT16)(offsetof(PCR_Allocate_In, pcrAllocation)), 2530 (UINT16)(offsetof(PCR_Allocate_Out, maxPCR)), 2531 (UINT16)(offsetof(PCR_Allocate_Out, sizeNeeded)), 2532 (UINT16)(offsetof(PCR_Allocate_Out, sizeAvailable))}, 2533 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 2534 TPML_PCR_SELECTION_P_UNMARSHAL, 2535 END_OF_LIST, 2536 TPMI_YES_NO_P_MARSHAL, 2537 UINT32_P_MARSHAL, 2538 UINT32_P_MARSHAL, 2539 UINT32_P_MARSHAL, 2540 END_OF_LIST} 2541 }; 2542 2543 #define _PCR_AllocateDataAddress (&_PCR_AllocateData) 2544 #else 2545 #define _PCR_AllocateDataAddress 0 2546 #endif // CC_PCR_Allocate 2547 2548 #if CC_PCR_SetAuthPolicy 2549 2550 #include "PCR_SetAuthPolicy_fp.h" 2551 2552 typedef TPM_RC (PCR_SetAuthPolicy_Entry)( 2553 PCR_SetAuthPolicy_In *in 2554 ); 2555 2556 typedef const struct { 2557 PCR_SetAuthPolicy_Entry *entry; 2558 UINT16 inSize; 2559 UINT16 outSize; 2560 UINT16 offsetOfTypes; 2561 UINT16 paramOffsets[3]; 2562 BYTE types[6]; 2563 } PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t; 2564 2565 PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t _PCR_SetAuthPolicyData = { 2566 /* entry */ &TPM2_PCR_SetAuthPolicy, 2567 /* inSize */ (UINT16)(sizeof(PCR_SetAuthPolicy_In)), 2568 /* outSize */ 0, 2569 /* offsetOfTypes */ offsetof(PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t, types), 2570 /* offsets */ {(UINT16)(offsetof(PCR_SetAuthPolicy_In, authPolicy)), 2571 (UINT16)(offsetof(PCR_SetAuthPolicy_In, hashAlg)), 2572 (UINT16)(offsetof(PCR_SetAuthPolicy_In, pcrNum))}, 2573 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 2574 TPM2B_DIGEST_P_UNMARSHAL, 2575 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 2576 TPMI_DH_PCR_P_UNMARSHAL, 2577 END_OF_LIST, 2578 END_OF_LIST} 2579 }; 2580 2581 #define _PCR_SetAuthPolicyDataAddress (&_PCR_SetAuthPolicyData) 2582 #else 2583 #define _PCR_SetAuthPolicyDataAddress 0 2584 #endif // CC_PCR_SetAuthPolicy 2585 2586 #if CC_PCR_SetAuthValue 2587 2588 #include "PCR_SetAuthValue_fp.h" 2589 2590 typedef TPM_RC (PCR_SetAuthValue_Entry)( 2591 PCR_SetAuthValue_In *in 2592 ); 2593 2594 typedef const struct { 2595 PCR_SetAuthValue_Entry *entry; 2596 UINT16 inSize; 2597 UINT16 outSize; 2598 UINT16 offsetOfTypes; 2599 UINT16 paramOffsets[1]; 2600 BYTE types[4]; 2601 } PCR_SetAuthValue_COMMAND_DESCRIPTOR_t; 2602 2603 PCR_SetAuthValue_COMMAND_DESCRIPTOR_t _PCR_SetAuthValueData = { 2604 /* entry */ &TPM2_PCR_SetAuthValue, 2605 /* inSize */ (UINT16)(sizeof(PCR_SetAuthValue_In)), 2606 /* outSize */ 0, 2607 /* offsetOfTypes */ offsetof(PCR_SetAuthValue_COMMAND_DESCRIPTOR_t, types), 2608 /* offsets */ {(UINT16)(offsetof(PCR_SetAuthValue_In, auth))}, 2609 /* types */ {TPMI_DH_PCR_H_UNMARSHAL, 2610 TPM2B_DIGEST_P_UNMARSHAL, 2611 END_OF_LIST, 2612 END_OF_LIST} 2613 }; 2614 2615 #define _PCR_SetAuthValueDataAddress (&_PCR_SetAuthValueData) 2616 #else 2617 #define _PCR_SetAuthValueDataAddress 0 2618 #endif // CC_PCR_SetAuthValue 2619 2620 #if CC_PCR_Reset 2621 2622 #include "PCR_Reset_fp.h" 2623 2624 typedef TPM_RC (PCR_Reset_Entry)( 2625 PCR_Reset_In *in 2626 ); 2627 2628 typedef const struct { 2629 PCR_Reset_Entry *entry; 2630 UINT16 inSize; 2631 UINT16 outSize; 2632 UINT16 offsetOfTypes; 2633 BYTE types[3]; 2634 } PCR_Reset_COMMAND_DESCRIPTOR_t; 2635 2636 PCR_Reset_COMMAND_DESCRIPTOR_t _PCR_ResetData = { 2637 /* entry */ &TPM2_PCR_Reset, 2638 /* inSize */ (UINT16)(sizeof(PCR_Reset_In)), 2639 /* outSize */ 0, 2640 /* offsetOfTypes */ offsetof(PCR_Reset_COMMAND_DESCRIPTOR_t, types), 2641 /* offsets */ // No parameter offsets; 2642 /* types */ {TPMI_DH_PCR_H_UNMARSHAL, 2643 END_OF_LIST, 2644 END_OF_LIST} 2645 }; 2646 2647 #define _PCR_ResetDataAddress (&_PCR_ResetData) 2648 #else 2649 #define _PCR_ResetDataAddress 0 2650 #endif // CC_PCR_Reset 2651 2652 #if CC_PolicySigned 2653 2654 #include "PolicySigned_fp.h" 2655 2656 typedef TPM_RC (PolicySigned_Entry)( 2657 PolicySigned_In *in, 2658 PolicySigned_Out *out 2659 ); 2660 2661 typedef const struct { 2662 PolicySigned_Entry *entry; 2663 UINT16 inSize; 2664 UINT16 outSize; 2665 UINT16 offsetOfTypes; 2666 UINT16 paramOffsets[7]; 2667 BYTE types[11]; 2668 } PolicySigned_COMMAND_DESCRIPTOR_t; 2669 2670 PolicySigned_COMMAND_DESCRIPTOR_t _PolicySignedData = { 2671 /* entry */ &TPM2_PolicySigned, 2672 /* inSize */ (UINT16)(sizeof(PolicySigned_In)), 2673 /* outSize */ (UINT16)(sizeof(PolicySigned_Out)), 2674 /* offsetOfTypes */ offsetof(PolicySigned_COMMAND_DESCRIPTOR_t, types), 2675 /* offsets */ {(UINT16)(offsetof(PolicySigned_In, policySession)), 2676 (UINT16)(offsetof(PolicySigned_In, nonceTPM)), 2677 (UINT16)(offsetof(PolicySigned_In, cpHashA)), 2678 (UINT16)(offsetof(PolicySigned_In, policyRef)), 2679 (UINT16)(offsetof(PolicySigned_In, expiration)), 2680 (UINT16)(offsetof(PolicySigned_In, auth)), 2681 (UINT16)(offsetof(PolicySigned_Out, policyTicket))}, 2682 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 2683 TPMI_SH_POLICY_H_UNMARSHAL, 2684 TPM2B_NONCE_P_UNMARSHAL, 2685 TPM2B_DIGEST_P_UNMARSHAL, 2686 TPM2B_NONCE_P_UNMARSHAL, 2687 INT32_P_UNMARSHAL, 2688 TPMT_SIGNATURE_P_UNMARSHAL, 2689 END_OF_LIST, 2690 TPM2B_TIMEOUT_P_MARSHAL, 2691 TPMT_TK_AUTH_P_MARSHAL, 2692 END_OF_LIST} 2693 }; 2694 2695 #define _PolicySignedDataAddress (&_PolicySignedData) 2696 #else 2697 #define _PolicySignedDataAddress 0 2698 #endif // CC_PolicySigned 2699 2700 #if CC_PolicySecret 2701 2702 #include "PolicySecret_fp.h" 2703 2704 typedef TPM_RC (PolicySecret_Entry)( 2705 PolicySecret_In *in, 2706 PolicySecret_Out *out 2707 ); 2708 2709 typedef const struct { 2710 PolicySecret_Entry *entry; 2711 UINT16 inSize; 2712 UINT16 outSize; 2713 UINT16 offsetOfTypes; 2714 UINT16 paramOffsets[6]; 2715 BYTE types[10]; 2716 } PolicySecret_COMMAND_DESCRIPTOR_t; 2717 2718 PolicySecret_COMMAND_DESCRIPTOR_t _PolicySecretData = { 2719 /* entry */ &TPM2_PolicySecret, 2720 /* inSize */ (UINT16)(sizeof(PolicySecret_In)), 2721 /* outSize */ (UINT16)(sizeof(PolicySecret_Out)), 2722 /* offsetOfTypes */ offsetof(PolicySecret_COMMAND_DESCRIPTOR_t, types), 2723 /* offsets */ {(UINT16)(offsetof(PolicySecret_In, policySession)), 2724 (UINT16)(offsetof(PolicySecret_In, nonceTPM)), 2725 (UINT16)(offsetof(PolicySecret_In, cpHashA)), 2726 (UINT16)(offsetof(PolicySecret_In, policyRef)), 2727 (UINT16)(offsetof(PolicySecret_In, expiration)), 2728 (UINT16)(offsetof(PolicySecret_Out, policyTicket))}, 2729 /* types */ {TPMI_DH_ENTITY_H_UNMARSHAL, 2730 TPMI_SH_POLICY_H_UNMARSHAL, 2731 TPM2B_NONCE_P_UNMARSHAL, 2732 TPM2B_DIGEST_P_UNMARSHAL, 2733 TPM2B_NONCE_P_UNMARSHAL, 2734 INT32_P_UNMARSHAL, 2735 END_OF_LIST, 2736 TPM2B_TIMEOUT_P_MARSHAL, 2737 TPMT_TK_AUTH_P_MARSHAL, 2738 END_OF_LIST} 2739 }; 2740 2741 #define _PolicySecretDataAddress (&_PolicySecretData) 2742 #else 2743 #define _PolicySecretDataAddress 0 2744 #endif // CC_PolicySecret 2745 2746 #if CC_PolicyTicket 2747 2748 #include "PolicyTicket_fp.h" 2749 2750 typedef TPM_RC (PolicyTicket_Entry)( 2751 PolicyTicket_In *in 2752 ); 2753 2754 typedef const struct { 2755 PolicyTicket_Entry *entry; 2756 UINT16 inSize; 2757 UINT16 outSize; 2758 UINT16 offsetOfTypes; 2759 UINT16 paramOffsets[5]; 2760 BYTE types[8]; 2761 } PolicyTicket_COMMAND_DESCRIPTOR_t; 2762 2763 PolicyTicket_COMMAND_DESCRIPTOR_t _PolicyTicketData = { 2764 /* entry */ &TPM2_PolicyTicket, 2765 /* inSize */ (UINT16)(sizeof(PolicyTicket_In)), 2766 /* outSize */ 0, 2767 /* offsetOfTypes */ offsetof(PolicyTicket_COMMAND_DESCRIPTOR_t, types), 2768 /* offsets */ {(UINT16)(offsetof(PolicyTicket_In, timeout)), 2769 (UINT16)(offsetof(PolicyTicket_In, cpHashA)), 2770 (UINT16)(offsetof(PolicyTicket_In, policyRef)), 2771 (UINT16)(offsetof(PolicyTicket_In, authName)), 2772 (UINT16)(offsetof(PolicyTicket_In, ticket))}, 2773 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2774 TPM2B_TIMEOUT_P_UNMARSHAL, 2775 TPM2B_DIGEST_P_UNMARSHAL, 2776 TPM2B_NONCE_P_UNMARSHAL, 2777 TPM2B_NAME_P_UNMARSHAL, 2778 TPMT_TK_AUTH_P_UNMARSHAL, 2779 END_OF_LIST, 2780 END_OF_LIST} 2781 }; 2782 2783 #define _PolicyTicketDataAddress (&_PolicyTicketData) 2784 #else 2785 #define _PolicyTicketDataAddress 0 2786 #endif // CC_PolicyTicket 2787 2788 #if CC_PolicyOR 2789 2790 #include "PolicyOR_fp.h" 2791 2792 typedef TPM_RC (PolicyOR_Entry)( 2793 PolicyOR_In *in 2794 ); 2795 2796 typedef const struct { 2797 PolicyOR_Entry *entry; 2798 UINT16 inSize; 2799 UINT16 outSize; 2800 UINT16 offsetOfTypes; 2801 UINT16 paramOffsets[1]; 2802 BYTE types[4]; 2803 } PolicyOR_COMMAND_DESCRIPTOR_t; 2804 2805 PolicyOR_COMMAND_DESCRIPTOR_t _PolicyORData = { 2806 /* entry */ &TPM2_PolicyOR, 2807 /* inSize */ (UINT16)(sizeof(PolicyOR_In)), 2808 /* outSize */ 0, 2809 /* offsetOfTypes */ offsetof(PolicyOR_COMMAND_DESCRIPTOR_t, types), 2810 /* offsets */ {(UINT16)(offsetof(PolicyOR_In, pHashList))}, 2811 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2812 TPML_DIGEST_P_UNMARSHAL, 2813 END_OF_LIST, 2814 END_OF_LIST} 2815 }; 2816 2817 #define _PolicyORDataAddress (&_PolicyORData) 2818 #else 2819 #define _PolicyORDataAddress 0 2820 #endif // CC_PolicyOR 2821 2822 #if CC_PolicyPCR 2823 2824 #include "PolicyPCR_fp.h" 2825 2826 typedef TPM_RC (PolicyPCR_Entry)( 2827 PolicyPCR_In *in 2828 ); 2829 2830 typedef const struct { 2831 PolicyPCR_Entry *entry; 2832 UINT16 inSize; 2833 UINT16 outSize; 2834 UINT16 offsetOfTypes; 2835 UINT16 paramOffsets[2]; 2836 BYTE types[5]; 2837 } PolicyPCR_COMMAND_DESCRIPTOR_t; 2838 2839 PolicyPCR_COMMAND_DESCRIPTOR_t _PolicyPCRData = { 2840 /* entry */ &TPM2_PolicyPCR, 2841 /* inSize */ (UINT16)(sizeof(PolicyPCR_In)), 2842 /* outSize */ 0, 2843 /* offsetOfTypes */ offsetof(PolicyPCR_COMMAND_DESCRIPTOR_t, types), 2844 /* offsets */ {(UINT16)(offsetof(PolicyPCR_In, pcrDigest)), 2845 (UINT16)(offsetof(PolicyPCR_In, pcrs))}, 2846 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2847 TPM2B_DIGEST_P_UNMARSHAL, 2848 TPML_PCR_SELECTION_P_UNMARSHAL, 2849 END_OF_LIST, 2850 END_OF_LIST} 2851 }; 2852 2853 #define _PolicyPCRDataAddress (&_PolicyPCRData) 2854 #else 2855 #define _PolicyPCRDataAddress 0 2856 #endif // CC_PolicyPCR 2857 2858 #if CC_PolicyLocality 2859 2860 #include "PolicyLocality_fp.h" 2861 2862 typedef TPM_RC (PolicyLocality_Entry)( 2863 PolicyLocality_In *in 2864 ); 2865 2866 typedef const struct { 2867 PolicyLocality_Entry *entry; 2868 UINT16 inSize; 2869 UINT16 outSize; 2870 UINT16 offsetOfTypes; 2871 UINT16 paramOffsets[1]; 2872 BYTE types[4]; 2873 } PolicyLocality_COMMAND_DESCRIPTOR_t; 2874 2875 PolicyLocality_COMMAND_DESCRIPTOR_t _PolicyLocalityData = { 2876 /* entry */ &TPM2_PolicyLocality, 2877 /* inSize */ (UINT16)(sizeof(PolicyLocality_In)), 2878 /* outSize */ 0, 2879 /* offsetOfTypes */ offsetof(PolicyLocality_COMMAND_DESCRIPTOR_t, types), 2880 /* offsets */ {(UINT16)(offsetof(PolicyLocality_In, locality))}, 2881 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2882 TPMA_LOCALITY_P_UNMARSHAL, 2883 END_OF_LIST, 2884 END_OF_LIST} 2885 }; 2886 2887 #define _PolicyLocalityDataAddress (&_PolicyLocalityData) 2888 #else 2889 #define _PolicyLocalityDataAddress 0 2890 #endif // CC_PolicyLocality 2891 2892 #if CC_PolicyNV 2893 2894 #include "PolicyNV_fp.h" 2895 2896 typedef TPM_RC (PolicyNV_Entry)( 2897 PolicyNV_In *in 2898 ); 2899 2900 typedef const struct { 2901 PolicyNV_Entry *entry; 2902 UINT16 inSize; 2903 UINT16 outSize; 2904 UINT16 offsetOfTypes; 2905 UINT16 paramOffsets[5]; 2906 BYTE types[8]; 2907 } PolicyNV_COMMAND_DESCRIPTOR_t; 2908 2909 PolicyNV_COMMAND_DESCRIPTOR_t _PolicyNVData = { 2910 /* entry */ &TPM2_PolicyNV, 2911 /* inSize */ (UINT16)(sizeof(PolicyNV_In)), 2912 /* outSize */ 0, 2913 /* offsetOfTypes */ offsetof(PolicyNV_COMMAND_DESCRIPTOR_t, types), 2914 /* offsets */ {(UINT16)(offsetof(PolicyNV_In, nvIndex)), 2915 (UINT16)(offsetof(PolicyNV_In, policySession)), 2916 (UINT16)(offsetof(PolicyNV_In, operandB)), 2917 (UINT16)(offsetof(PolicyNV_In, offset)), 2918 (UINT16)(offsetof(PolicyNV_In, operation))}, 2919 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 2920 TPMI_RH_NV_INDEX_H_UNMARSHAL, 2921 TPMI_SH_POLICY_H_UNMARSHAL, 2922 TPM2B_OPERAND_P_UNMARSHAL, 2923 UINT16_P_UNMARSHAL, 2924 TPM_EO_P_UNMARSHAL, 2925 END_OF_LIST, 2926 END_OF_LIST} 2927 }; 2928 2929 #define _PolicyNVDataAddress (&_PolicyNVData) 2930 #else 2931 #define _PolicyNVDataAddress 0 2932 #endif // CC_PolicyNV 2933 2934 #if CC_PolicyCounterTimer 2935 2936 #include "PolicyCounterTimer_fp.h" 2937 2938 typedef TPM_RC (PolicyCounterTimer_Entry)( 2939 PolicyCounterTimer_In *in 2940 ); 2941 2942 typedef const struct { 2943 PolicyCounterTimer_Entry *entry; 2944 UINT16 inSize; 2945 UINT16 outSize; 2946 UINT16 offsetOfTypes; 2947 UINT16 paramOffsets[3]; 2948 BYTE types[6]; 2949 } PolicyCounterTimer_COMMAND_DESCRIPTOR_t; 2950 2951 PolicyCounterTimer_COMMAND_DESCRIPTOR_t _PolicyCounterTimerData = { 2952 /* entry */ &TPM2_PolicyCounterTimer, 2953 /* inSize */ (UINT16)(sizeof(PolicyCounterTimer_In)), 2954 /* outSize */ 0, 2955 /* offsetOfTypes */ offsetof(PolicyCounterTimer_COMMAND_DESCRIPTOR_t, types), 2956 /* offsets */ {(UINT16)(offsetof(PolicyCounterTimer_In, operandB)), 2957 (UINT16)(offsetof(PolicyCounterTimer_In, offset)), 2958 (UINT16)(offsetof(PolicyCounterTimer_In, operation))}, 2959 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2960 TPM2B_OPERAND_P_UNMARSHAL, 2961 UINT16_P_UNMARSHAL, 2962 TPM_EO_P_UNMARSHAL, 2963 END_OF_LIST, 2964 END_OF_LIST} 2965 }; 2966 2967 #define _PolicyCounterTimerDataAddress (&_PolicyCounterTimerData) 2968 #else 2969 #define _PolicyCounterTimerDataAddress 0 2970 #endif // CC_PolicyCounterTimer 2971 2972 #if CC_PolicyCommandCode 2973 2974 #include "PolicyCommandCode_fp.h" 2975 2976 typedef TPM_RC (PolicyCommandCode_Entry)( 2977 PolicyCommandCode_In *in 2978 ); 2979 2980 typedef const struct { 2981 PolicyCommandCode_Entry *entry; 2982 UINT16 inSize; 2983 UINT16 outSize; 2984 UINT16 offsetOfTypes; 2985 UINT16 paramOffsets[1]; 2986 BYTE types[4]; 2987 } PolicyCommandCode_COMMAND_DESCRIPTOR_t; 2988 2989 PolicyCommandCode_COMMAND_DESCRIPTOR_t _PolicyCommandCodeData = { 2990 /* entry */ &TPM2_PolicyCommandCode, 2991 /* inSize */ (UINT16)(sizeof(PolicyCommandCode_In)), 2992 /* outSize */ 0, 2993 /* offsetOfTypes */ offsetof(PolicyCommandCode_COMMAND_DESCRIPTOR_t, types), 2994 /* offsets */ {(UINT16)(offsetof(PolicyCommandCode_In, code))}, 2995 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 2996 TPM_CC_P_UNMARSHAL, 2997 END_OF_LIST, 2998 END_OF_LIST} 2999 }; 3000 3001 #define _PolicyCommandCodeDataAddress (&_PolicyCommandCodeData) 3002 #else 3003 #define _PolicyCommandCodeDataAddress 0 3004 #endif // CC_PolicyCommandCode 3005 3006 #if CC_PolicyPhysicalPresence 3007 3008 #include "PolicyPhysicalPresence_fp.h" 3009 3010 typedef TPM_RC (PolicyPhysicalPresence_Entry)( 3011 PolicyPhysicalPresence_In *in 3012 ); 3013 3014 typedef const struct { 3015 PolicyPhysicalPresence_Entry *entry; 3016 UINT16 inSize; 3017 UINT16 outSize; 3018 UINT16 offsetOfTypes; 3019 BYTE types[3]; 3020 } PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t; 3021 3022 PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t _PolicyPhysicalPresenceData = { 3023 /* entry */ &TPM2_PolicyPhysicalPresence, 3024 /* inSize */ (UINT16)(sizeof(PolicyPhysicalPresence_In)), 3025 /* outSize */ 0, 3026 /* offsetOfTypes */ offsetof(PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t, types), 3027 /* offsets */ // No parameter offsets; 3028 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3029 END_OF_LIST, 3030 END_OF_LIST} 3031 }; 3032 3033 #define _PolicyPhysicalPresenceDataAddress (&_PolicyPhysicalPresenceData) 3034 #else 3035 #define _PolicyPhysicalPresenceDataAddress 0 3036 #endif // CC_PolicyPhysicalPresence 3037 3038 #if CC_PolicyCpHash 3039 3040 #include "PolicyCpHash_fp.h" 3041 3042 typedef TPM_RC (PolicyCpHash_Entry)( 3043 PolicyCpHash_In *in 3044 ); 3045 3046 typedef const struct { 3047 PolicyCpHash_Entry *entry; 3048 UINT16 inSize; 3049 UINT16 outSize; 3050 UINT16 offsetOfTypes; 3051 UINT16 paramOffsets[1]; 3052 BYTE types[4]; 3053 } PolicyCpHash_COMMAND_DESCRIPTOR_t; 3054 3055 PolicyCpHash_COMMAND_DESCRIPTOR_t _PolicyCpHashData = { 3056 /* entry */ &TPM2_PolicyCpHash, 3057 /* inSize */ (UINT16)(sizeof(PolicyCpHash_In)), 3058 /* outSize */ 0, 3059 /* offsetOfTypes */ offsetof(PolicyCpHash_COMMAND_DESCRIPTOR_t, types), 3060 /* offsets */ {(UINT16)(offsetof(PolicyCpHash_In, cpHashA))}, 3061 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3062 TPM2B_DIGEST_P_UNMARSHAL, 3063 END_OF_LIST, 3064 END_OF_LIST} 3065 }; 3066 3067 #define _PolicyCpHashDataAddress (&_PolicyCpHashData) 3068 #else 3069 #define _PolicyCpHashDataAddress 0 3070 #endif // CC_PolicyCpHash 3071 3072 #if CC_PolicyNameHash 3073 3074 #include "PolicyNameHash_fp.h" 3075 3076 typedef TPM_RC (PolicyNameHash_Entry)( 3077 PolicyNameHash_In *in 3078 ); 3079 3080 typedef const struct { 3081 PolicyNameHash_Entry *entry; 3082 UINT16 inSize; 3083 UINT16 outSize; 3084 UINT16 offsetOfTypes; 3085 UINT16 paramOffsets[1]; 3086 BYTE types[4]; 3087 } PolicyNameHash_COMMAND_DESCRIPTOR_t; 3088 3089 PolicyNameHash_COMMAND_DESCRIPTOR_t _PolicyNameHashData = { 3090 /* entry */ &TPM2_PolicyNameHash, 3091 /* inSize */ (UINT16)(sizeof(PolicyNameHash_In)), 3092 /* outSize */ 0, 3093 /* offsetOfTypes */ offsetof(PolicyNameHash_COMMAND_DESCRIPTOR_t, types), 3094 /* offsets */ {(UINT16)(offsetof(PolicyNameHash_In, nameHash))}, 3095 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3096 TPM2B_DIGEST_P_UNMARSHAL, 3097 END_OF_LIST, 3098 END_OF_LIST} 3099 }; 3100 3101 #define _PolicyNameHashDataAddress (&_PolicyNameHashData) 3102 #else 3103 #define _PolicyNameHashDataAddress 0 3104 #endif // CC_PolicyNameHash 3105 3106 #if CC_PolicyDuplicationSelect 3107 3108 #include "PolicyDuplicationSelect_fp.h" 3109 3110 typedef TPM_RC (PolicyDuplicationSelect_Entry)( 3111 PolicyDuplicationSelect_In *in 3112 ); 3113 3114 typedef const struct { 3115 PolicyDuplicationSelect_Entry *entry; 3116 UINT16 inSize; 3117 UINT16 outSize; 3118 UINT16 offsetOfTypes; 3119 UINT16 paramOffsets[3]; 3120 BYTE types[6]; 3121 } PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t; 3122 3123 PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t _PolicyDuplicationSelectData = { 3124 /* entry */ &TPM2_PolicyDuplicationSelect, 3125 /* inSize */ (UINT16)(sizeof(PolicyDuplicationSelect_In)), 3126 /* outSize */ 0, 3127 /* offsetOfTypes */ offsetof(PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t, types), 3128 /* offsets */ {(UINT16)(offsetof(PolicyDuplicationSelect_In, objectName)), 3129 (UINT16)(offsetof(PolicyDuplicationSelect_In, newParentName)), 3130 (UINT16)(offsetof(PolicyDuplicationSelect_In, includeObject))}, 3131 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3132 TPM2B_NAME_P_UNMARSHAL, 3133 TPM2B_NAME_P_UNMARSHAL, 3134 TPMI_YES_NO_P_UNMARSHAL, 3135 END_OF_LIST, 3136 END_OF_LIST} 3137 }; 3138 3139 #define _PolicyDuplicationSelectDataAddress (&_PolicyDuplicationSelectData) 3140 #else 3141 #define _PolicyDuplicationSelectDataAddress 0 3142 #endif // CC_PolicyDuplicationSelect 3143 3144 #if CC_PolicyAuthorize 3145 3146 #include "PolicyAuthorize_fp.h" 3147 3148 typedef TPM_RC (PolicyAuthorize_Entry)( 3149 PolicyAuthorize_In *in 3150 ); 3151 3152 typedef const struct { 3153 PolicyAuthorize_Entry *entry; 3154 UINT16 inSize; 3155 UINT16 outSize; 3156 UINT16 offsetOfTypes; 3157 UINT16 paramOffsets[4]; 3158 BYTE types[7]; 3159 } PolicyAuthorize_COMMAND_DESCRIPTOR_t; 3160 3161 PolicyAuthorize_COMMAND_DESCRIPTOR_t _PolicyAuthorizeData = { 3162 /* entry */ &TPM2_PolicyAuthorize, 3163 /* inSize */ (UINT16)(sizeof(PolicyAuthorize_In)), 3164 /* outSize */ 0, 3165 /* offsetOfTypes */ offsetof(PolicyAuthorize_COMMAND_DESCRIPTOR_t, types), 3166 /* offsets */ {(UINT16)(offsetof(PolicyAuthorize_In, approvedPolicy)), 3167 (UINT16)(offsetof(PolicyAuthorize_In, policyRef)), 3168 (UINT16)(offsetof(PolicyAuthorize_In, keySign)), 3169 (UINT16)(offsetof(PolicyAuthorize_In, checkTicket))}, 3170 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3171 TPM2B_DIGEST_P_UNMARSHAL, 3172 TPM2B_NONCE_P_UNMARSHAL, 3173 TPM2B_NAME_P_UNMARSHAL, 3174 TPMT_TK_VERIFIED_P_UNMARSHAL, 3175 END_OF_LIST, 3176 END_OF_LIST} 3177 }; 3178 3179 #define _PolicyAuthorizeDataAddress (&_PolicyAuthorizeData) 3180 #else 3181 #define _PolicyAuthorizeDataAddress 0 3182 #endif // CC_PolicyAuthorize 3183 3184 #if CC_PolicyAuthValue 3185 3186 #include "PolicyAuthValue_fp.h" 3187 3188 typedef TPM_RC (PolicyAuthValue_Entry)( 3189 PolicyAuthValue_In *in 3190 ); 3191 3192 typedef const struct { 3193 PolicyAuthValue_Entry *entry; 3194 UINT16 inSize; 3195 UINT16 outSize; 3196 UINT16 offsetOfTypes; 3197 BYTE types[3]; 3198 } PolicyAuthValue_COMMAND_DESCRIPTOR_t; 3199 3200 PolicyAuthValue_COMMAND_DESCRIPTOR_t _PolicyAuthValueData = { 3201 /* entry */ &TPM2_PolicyAuthValue, 3202 /* inSize */ (UINT16)(sizeof(PolicyAuthValue_In)), 3203 /* outSize */ 0, 3204 /* offsetOfTypes */ offsetof(PolicyAuthValue_COMMAND_DESCRIPTOR_t, types), 3205 /* offsets */ // No parameter offsets; 3206 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3207 END_OF_LIST, 3208 END_OF_LIST} 3209 }; 3210 3211 #define _PolicyAuthValueDataAddress (&_PolicyAuthValueData) 3212 #else 3213 #define _PolicyAuthValueDataAddress 0 3214 #endif // CC_PolicyAuthValue 3215 3216 #if CC_PolicyPassword 3217 3218 #include "PolicyPassword_fp.h" 3219 3220 typedef TPM_RC (PolicyPassword_Entry)( 3221 PolicyPassword_In *in 3222 ); 3223 3224 typedef const struct { 3225 PolicyPassword_Entry *entry; 3226 UINT16 inSize; 3227 UINT16 outSize; 3228 UINT16 offsetOfTypes; 3229 BYTE types[3]; 3230 } PolicyPassword_COMMAND_DESCRIPTOR_t; 3231 3232 PolicyPassword_COMMAND_DESCRIPTOR_t _PolicyPasswordData = { 3233 /* entry */ &TPM2_PolicyPassword, 3234 /* inSize */ (UINT16)(sizeof(PolicyPassword_In)), 3235 /* outSize */ 0, 3236 /* offsetOfTypes */ offsetof(PolicyPassword_COMMAND_DESCRIPTOR_t, types), 3237 /* offsets */ // No parameter offsets; 3238 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3239 END_OF_LIST, 3240 END_OF_LIST} 3241 }; 3242 3243 #define _PolicyPasswordDataAddress (&_PolicyPasswordData) 3244 #else 3245 #define _PolicyPasswordDataAddress 0 3246 #endif // CC_PolicyPassword 3247 3248 #if CC_PolicyGetDigest 3249 3250 #include "PolicyGetDigest_fp.h" 3251 3252 typedef TPM_RC (PolicyGetDigest_Entry)( 3253 PolicyGetDigest_In *in, 3254 PolicyGetDigest_Out *out 3255 ); 3256 3257 typedef const struct { 3258 PolicyGetDigest_Entry *entry; 3259 UINT16 inSize; 3260 UINT16 outSize; 3261 UINT16 offsetOfTypes; 3262 BYTE types[4]; 3263 } PolicyGetDigest_COMMAND_DESCRIPTOR_t; 3264 3265 PolicyGetDigest_COMMAND_DESCRIPTOR_t _PolicyGetDigestData = { 3266 /* entry */ &TPM2_PolicyGetDigest, 3267 /* inSize */ (UINT16)(sizeof(PolicyGetDigest_In)), 3268 /* outSize */ (UINT16)(sizeof(PolicyGetDigest_Out)), 3269 /* offsetOfTypes */ offsetof(PolicyGetDigest_COMMAND_DESCRIPTOR_t, types), 3270 /* offsets */ // No parameter offsets; 3271 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3272 END_OF_LIST, 3273 TPM2B_DIGEST_P_MARSHAL, 3274 END_OF_LIST} 3275 }; 3276 3277 #define _PolicyGetDigestDataAddress (&_PolicyGetDigestData) 3278 #else 3279 #define _PolicyGetDigestDataAddress 0 3280 #endif // CC_PolicyGetDigest 3281 3282 #if CC_PolicyNvWritten 3283 3284 #include "PolicyNvWritten_fp.h" 3285 3286 typedef TPM_RC (PolicyNvWritten_Entry)( 3287 PolicyNvWritten_In *in 3288 ); 3289 3290 typedef const struct { 3291 PolicyNvWritten_Entry *entry; 3292 UINT16 inSize; 3293 UINT16 outSize; 3294 UINT16 offsetOfTypes; 3295 UINT16 paramOffsets[1]; 3296 BYTE types[4]; 3297 } PolicyNvWritten_COMMAND_DESCRIPTOR_t; 3298 3299 PolicyNvWritten_COMMAND_DESCRIPTOR_t _PolicyNvWrittenData = { 3300 /* entry */ &TPM2_PolicyNvWritten, 3301 /* inSize */ (UINT16)(sizeof(PolicyNvWritten_In)), 3302 /* outSize */ 0, 3303 /* offsetOfTypes */ offsetof(PolicyNvWritten_COMMAND_DESCRIPTOR_t, types), 3304 /* offsets */ {(UINT16)(offsetof(PolicyNvWritten_In, writtenSet))}, 3305 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3306 TPMI_YES_NO_P_UNMARSHAL, 3307 END_OF_LIST, 3308 END_OF_LIST} 3309 }; 3310 3311 #define _PolicyNvWrittenDataAddress (&_PolicyNvWrittenData) 3312 #else 3313 #define _PolicyNvWrittenDataAddress 0 3314 #endif // CC_PolicyNvWritten 3315 3316 #if CC_PolicyTemplate 3317 3318 #include "PolicyTemplate_fp.h" 3319 3320 typedef TPM_RC (PolicyTemplate_Entry)( 3321 PolicyTemplate_In *in 3322 ); 3323 3324 typedef const struct { 3325 PolicyTemplate_Entry *entry; 3326 UINT16 inSize; 3327 UINT16 outSize; 3328 UINT16 offsetOfTypes; 3329 UINT16 paramOffsets[1]; 3330 BYTE types[4]; 3331 } PolicyTemplate_COMMAND_DESCRIPTOR_t; 3332 3333 PolicyTemplate_COMMAND_DESCRIPTOR_t _PolicyTemplateData = { 3334 /* entry */ &TPM2_PolicyTemplate, 3335 /* inSize */ (UINT16)(sizeof(PolicyTemplate_In)), 3336 /* outSize */ 0, 3337 /* offsetOfTypes */ offsetof(PolicyTemplate_COMMAND_DESCRIPTOR_t, types), 3338 /* offsets */ {(UINT16)(offsetof(PolicyTemplate_In, templateHash))}, 3339 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 3340 TPM2B_DIGEST_P_UNMARSHAL, 3341 END_OF_LIST, 3342 END_OF_LIST} 3343 }; 3344 3345 #define _PolicyTemplateDataAddress (&_PolicyTemplateData) 3346 #else 3347 #define _PolicyTemplateDataAddress 0 3348 #endif // CC_PolicyTemplate 3349 3350 #if CC_PolicyAuthorizeNV 3351 3352 #include "PolicyAuthorizeNV_fp.h" 3353 3354 typedef TPM_RC (PolicyAuthorizeNV_Entry)( 3355 PolicyAuthorizeNV_In *in 3356 ); 3357 3358 typedef const struct { 3359 PolicyAuthorizeNV_Entry *entry; 3360 UINT16 inSize; 3361 UINT16 outSize; 3362 UINT16 offsetOfTypes; 3363 UINT16 paramOffsets[2]; 3364 BYTE types[5]; 3365 } PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t; 3366 3367 PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t _PolicyAuthorizeNVData = { 3368 /* entry */ &TPM2_PolicyAuthorizeNV, 3369 /* inSize */ (UINT16)(sizeof(PolicyAuthorizeNV_In)), 3370 /* outSize */ 0, 3371 /* offsetOfTypes */ offsetof(PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t, types), 3372 /* offsets */ {(UINT16)(offsetof(PolicyAuthorizeNV_In, nvIndex)), 3373 (UINT16)(offsetof(PolicyAuthorizeNV_In, policySession))}, 3374 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 3375 TPMI_RH_NV_INDEX_H_UNMARSHAL, 3376 TPMI_SH_POLICY_H_UNMARSHAL, 3377 END_OF_LIST, 3378 END_OF_LIST} 3379 }; 3380 3381 #define _PolicyAuthorizeNVDataAddress (&_PolicyAuthorizeNVData) 3382 #else 3383 #define _PolicyAuthorizeNVDataAddress 0 3384 #endif // CC_PolicyAuthorizeNV 3385 3386 #if CC_CreatePrimary 3387 3388 #include "CreatePrimary_fp.h" 3389 3390 typedef TPM_RC (CreatePrimary_Entry)( 3391 CreatePrimary_In *in, 3392 CreatePrimary_Out *out 3393 ); 3394 3395 typedef const struct { 3396 CreatePrimary_Entry *entry; 3397 UINT16 inSize; 3398 UINT16 outSize; 3399 UINT16 offsetOfTypes; 3400 UINT16 paramOffsets[9]; 3401 BYTE types[13]; 3402 } CreatePrimary_COMMAND_DESCRIPTOR_t; 3403 3404 CreatePrimary_COMMAND_DESCRIPTOR_t _CreatePrimaryData = { 3405 /* entry */ &TPM2_CreatePrimary, 3406 /* inSize */ (UINT16)(sizeof(CreatePrimary_In)), 3407 /* outSize */ (UINT16)(sizeof(CreatePrimary_Out)), 3408 /* offsetOfTypes */ offsetof(CreatePrimary_COMMAND_DESCRIPTOR_t, types), 3409 /* offsets */ {(UINT16)(offsetof(CreatePrimary_In, inSensitive)), 3410 (UINT16)(offsetof(CreatePrimary_In, inPublic)), 3411 (UINT16)(offsetof(CreatePrimary_In, outsideInfo)), 3412 (UINT16)(offsetof(CreatePrimary_In, creationPCR)), 3413 (UINT16)(offsetof(CreatePrimary_Out, outPublic)), 3414 (UINT16)(offsetof(CreatePrimary_Out, creationData)), 3415 (UINT16)(offsetof(CreatePrimary_Out, creationHash)), 3416 (UINT16)(offsetof(CreatePrimary_Out, creationTicket)), 3417 (UINT16)(offsetof(CreatePrimary_Out, name))}, 3418 /* types */ {TPMI_RH_HIERARCHY_H_UNMARSHAL + ADD_FLAG, 3419 TPM2B_SENSITIVE_CREATE_P_UNMARSHAL, 3420 TPM2B_PUBLIC_P_UNMARSHAL, 3421 TPM2B_DATA_P_UNMARSHAL, 3422 TPML_PCR_SELECTION_P_UNMARSHAL, 3423 END_OF_LIST, 3424 TPM_HANDLE_H_MARSHAL, 3425 TPM2B_PUBLIC_P_MARSHAL, 3426 TPM2B_CREATION_DATA_P_MARSHAL, 3427 TPM2B_DIGEST_P_MARSHAL, 3428 TPMT_TK_CREATION_P_MARSHAL, 3429 TPM2B_NAME_P_MARSHAL, 3430 END_OF_LIST} 3431 }; 3432 3433 #define _CreatePrimaryDataAddress (&_CreatePrimaryData) 3434 #else 3435 #define _CreatePrimaryDataAddress 0 3436 #endif // CC_CreatePrimary 3437 3438 #if CC_HierarchyControl 3439 3440 #include "HierarchyControl_fp.h" 3441 3442 typedef TPM_RC (HierarchyControl_Entry)( 3443 HierarchyControl_In *in 3444 ); 3445 3446 typedef const struct { 3447 HierarchyControl_Entry *entry; 3448 UINT16 inSize; 3449 UINT16 outSize; 3450 UINT16 offsetOfTypes; 3451 UINT16 paramOffsets[2]; 3452 BYTE types[5]; 3453 } HierarchyControl_COMMAND_DESCRIPTOR_t; 3454 3455 HierarchyControl_COMMAND_DESCRIPTOR_t _HierarchyControlData = { 3456 /* entry */ &TPM2_HierarchyControl, 3457 /* inSize */ (UINT16)(sizeof(HierarchyControl_In)), 3458 /* outSize */ 0, 3459 /* offsetOfTypes */ offsetof(HierarchyControl_COMMAND_DESCRIPTOR_t, types), 3460 /* offsets */ {(UINT16)(offsetof(HierarchyControl_In, enable)), 3461 (UINT16)(offsetof(HierarchyControl_In, state))}, 3462 /* types */ {TPMI_RH_HIERARCHY_H_UNMARSHAL, 3463 TPMI_RH_ENABLES_P_UNMARSHAL, 3464 TPMI_YES_NO_P_UNMARSHAL, 3465 END_OF_LIST, 3466 END_OF_LIST} 3467 }; 3468 3469 #define _HierarchyControlDataAddress (&_HierarchyControlData) 3470 #else 3471 #define _HierarchyControlDataAddress 0 3472 #endif // CC_HierarchyControl 3473 3474 #if CC_SetPrimaryPolicy 3475 3476 #include "SetPrimaryPolicy_fp.h" 3477 3478 typedef TPM_RC (SetPrimaryPolicy_Entry)( 3479 SetPrimaryPolicy_In *in 3480 ); 3481 3482 typedef const struct { 3483 SetPrimaryPolicy_Entry *entry; 3484 UINT16 inSize; 3485 UINT16 outSize; 3486 UINT16 offsetOfTypes; 3487 UINT16 paramOffsets[2]; 3488 BYTE types[5]; 3489 } SetPrimaryPolicy_COMMAND_DESCRIPTOR_t; 3490 3491 SetPrimaryPolicy_COMMAND_DESCRIPTOR_t _SetPrimaryPolicyData = { 3492 /* entry */ &TPM2_SetPrimaryPolicy, 3493 /* inSize */ (UINT16)(sizeof(SetPrimaryPolicy_In)), 3494 /* outSize */ 0, 3495 /* offsetOfTypes */ offsetof(SetPrimaryPolicy_COMMAND_DESCRIPTOR_t, types), 3496 /* offsets */ {(UINT16)(offsetof(SetPrimaryPolicy_In, authPolicy)), 3497 (UINT16)(offsetof(SetPrimaryPolicy_In, hashAlg))}, 3498 /* types */ {TPMI_RH_HIERARCHY_POLICY_H_UNMARSHAL, 3499 TPM2B_DIGEST_P_UNMARSHAL, 3500 TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG, 3501 END_OF_LIST, 3502 END_OF_LIST} 3503 }; 3504 3505 #define _SetPrimaryPolicyDataAddress (&_SetPrimaryPolicyData) 3506 #else 3507 #define _SetPrimaryPolicyDataAddress 0 3508 #endif // CC_SetPrimaryPolicy 3509 3510 #if CC_ChangePPS 3511 3512 #include "ChangePPS_fp.h" 3513 3514 typedef TPM_RC (ChangePPS_Entry)( 3515 ChangePPS_In *in 3516 ); 3517 3518 typedef const struct { 3519 ChangePPS_Entry *entry; 3520 UINT16 inSize; 3521 UINT16 outSize; 3522 UINT16 offsetOfTypes; 3523 BYTE types[3]; 3524 } ChangePPS_COMMAND_DESCRIPTOR_t; 3525 3526 ChangePPS_COMMAND_DESCRIPTOR_t _ChangePPSData = { 3527 /* entry */ &TPM2_ChangePPS, 3528 /* inSize */ (UINT16)(sizeof(ChangePPS_In)), 3529 /* outSize */ 0, 3530 /* offsetOfTypes */ offsetof(ChangePPS_COMMAND_DESCRIPTOR_t, types), 3531 /* offsets */ // No parameter offsets; 3532 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 3533 END_OF_LIST, 3534 END_OF_LIST} 3535 }; 3536 3537 #define _ChangePPSDataAddress (&_ChangePPSData) 3538 #else 3539 #define _ChangePPSDataAddress 0 3540 #endif // CC_ChangePPS 3541 3542 #if CC_ChangeEPS 3543 3544 #include "ChangeEPS_fp.h" 3545 3546 typedef TPM_RC (ChangeEPS_Entry)( 3547 ChangeEPS_In *in 3548 ); 3549 3550 typedef const struct { 3551 ChangeEPS_Entry *entry; 3552 UINT16 inSize; 3553 UINT16 outSize; 3554 UINT16 offsetOfTypes; 3555 BYTE types[3]; 3556 } ChangeEPS_COMMAND_DESCRIPTOR_t; 3557 3558 ChangeEPS_COMMAND_DESCRIPTOR_t _ChangeEPSData = { 3559 /* entry */ &TPM2_ChangeEPS, 3560 /* inSize */ (UINT16)(sizeof(ChangeEPS_In)), 3561 /* outSize */ 0, 3562 /* offsetOfTypes */ offsetof(ChangeEPS_COMMAND_DESCRIPTOR_t, types), 3563 /* offsets */ // No parameter offsets; 3564 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 3565 END_OF_LIST, 3566 END_OF_LIST} 3567 }; 3568 3569 #define _ChangeEPSDataAddress (&_ChangeEPSData) 3570 #else 3571 #define _ChangeEPSDataAddress 0 3572 #endif // CC_ChangeEPS 3573 3574 #if CC_Clear 3575 3576 #include "Clear_fp.h" 3577 3578 typedef TPM_RC (Clear_Entry)( 3579 Clear_In *in 3580 ); 3581 3582 typedef const struct { 3583 Clear_Entry *entry; 3584 UINT16 inSize; 3585 UINT16 outSize; 3586 UINT16 offsetOfTypes; 3587 BYTE types[3]; 3588 } Clear_COMMAND_DESCRIPTOR_t; 3589 3590 Clear_COMMAND_DESCRIPTOR_t _ClearData = { 3591 /* entry */ &TPM2_Clear, 3592 /* inSize */ (UINT16)(sizeof(Clear_In)), 3593 /* outSize */ 0, 3594 /* offsetOfTypes */ offsetof(Clear_COMMAND_DESCRIPTOR_t, types), 3595 /* offsets */ // No parameter offsets; 3596 /* types */ {TPMI_RH_CLEAR_H_UNMARSHAL, 3597 END_OF_LIST, 3598 END_OF_LIST} 3599 }; 3600 3601 #define _ClearDataAddress (&_ClearData) 3602 #else 3603 #define _ClearDataAddress 0 3604 #endif // CC_Clear 3605 3606 #if CC_ClearControl 3607 3608 #include "ClearControl_fp.h" 3609 3610 typedef TPM_RC (ClearControl_Entry)( 3611 ClearControl_In *in 3612 ); 3613 3614 typedef const struct { 3615 ClearControl_Entry *entry; 3616 UINT16 inSize; 3617 UINT16 outSize; 3618 UINT16 offsetOfTypes; 3619 UINT16 paramOffsets[1]; 3620 BYTE types[4]; 3621 } ClearControl_COMMAND_DESCRIPTOR_t; 3622 3623 ClearControl_COMMAND_DESCRIPTOR_t _ClearControlData = { 3624 /* entry */ &TPM2_ClearControl, 3625 /* inSize */ (UINT16)(sizeof(ClearControl_In)), 3626 /* outSize */ 0, 3627 /* offsetOfTypes */ offsetof(ClearControl_COMMAND_DESCRIPTOR_t, types), 3628 /* offsets */ {(UINT16)(offsetof(ClearControl_In, disable))}, 3629 /* types */ {TPMI_RH_CLEAR_H_UNMARSHAL, 3630 TPMI_YES_NO_P_UNMARSHAL, 3631 END_OF_LIST, 3632 END_OF_LIST} 3633 }; 3634 3635 #define _ClearControlDataAddress (&_ClearControlData) 3636 #else 3637 #define _ClearControlDataAddress 0 3638 #endif // CC_ClearControl 3639 3640 #if CC_HierarchyChangeAuth 3641 3642 #include "HierarchyChangeAuth_fp.h" 3643 3644 typedef TPM_RC (HierarchyChangeAuth_Entry)( 3645 HierarchyChangeAuth_In *in 3646 ); 3647 3648 typedef const struct { 3649 HierarchyChangeAuth_Entry *entry; 3650 UINT16 inSize; 3651 UINT16 outSize; 3652 UINT16 offsetOfTypes; 3653 UINT16 paramOffsets[1]; 3654 BYTE types[4]; 3655 } HierarchyChangeAuth_COMMAND_DESCRIPTOR_t; 3656 3657 HierarchyChangeAuth_COMMAND_DESCRIPTOR_t _HierarchyChangeAuthData = { 3658 /* entry */ &TPM2_HierarchyChangeAuth, 3659 /* inSize */ (UINT16)(sizeof(HierarchyChangeAuth_In)), 3660 /* outSize */ 0, 3661 /* offsetOfTypes */ offsetof(HierarchyChangeAuth_COMMAND_DESCRIPTOR_t, types), 3662 /* offsets */ {(UINT16)(offsetof(HierarchyChangeAuth_In, newAuth))}, 3663 /* types */ {TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL, 3664 TPM2B_AUTH_P_UNMARSHAL, 3665 END_OF_LIST, 3666 END_OF_LIST} 3667 }; 3668 3669 #define _HierarchyChangeAuthDataAddress (&_HierarchyChangeAuthData) 3670 #else 3671 #define _HierarchyChangeAuthDataAddress 0 3672 #endif // CC_HierarchyChangeAuth 3673 3674 #if CC_DictionaryAttackLockReset 3675 3676 #include "DictionaryAttackLockReset_fp.h" 3677 3678 typedef TPM_RC (DictionaryAttackLockReset_Entry)( 3679 DictionaryAttackLockReset_In *in 3680 ); 3681 3682 typedef const struct { 3683 DictionaryAttackLockReset_Entry *entry; 3684 UINT16 inSize; 3685 UINT16 outSize; 3686 UINT16 offsetOfTypes; 3687 BYTE types[3]; 3688 } DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t; 3689 3690 DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t _DictionaryAttackLockResetData = { 3691 /* entry */ &TPM2_DictionaryAttackLockReset, 3692 /* inSize */ (UINT16)(sizeof(DictionaryAttackLockReset_In)), 3693 /* outSize */ 0, 3694 /* offsetOfTypes */ offsetof(DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t, types), 3695 /* offsets */ // No parameter offsets; 3696 /* types */ {TPMI_RH_LOCKOUT_H_UNMARSHAL, 3697 END_OF_LIST, 3698 END_OF_LIST} 3699 }; 3700 3701 #define _DictionaryAttackLockResetDataAddress (&_DictionaryAttackLockResetData) 3702 #else 3703 #define _DictionaryAttackLockResetDataAddress 0 3704 #endif // CC_DictionaryAttackLockReset 3705 3706 #if CC_DictionaryAttackParameters 3707 3708 #include "DictionaryAttackParameters_fp.h" 3709 3710 typedef TPM_RC (DictionaryAttackParameters_Entry)( 3711 DictionaryAttackParameters_In *in 3712 ); 3713 3714 typedef const struct { 3715 DictionaryAttackParameters_Entry *entry; 3716 UINT16 inSize; 3717 UINT16 outSize; 3718 UINT16 offsetOfTypes; 3719 UINT16 paramOffsets[3]; 3720 BYTE types[6]; 3721 } DictionaryAttackParameters_COMMAND_DESCRIPTOR_t; 3722 3723 DictionaryAttackParameters_COMMAND_DESCRIPTOR_t _DictionaryAttackParametersData = { 3724 /* entry */ &TPM2_DictionaryAttackParameters, 3725 /* inSize */ (UINT16)(sizeof(DictionaryAttackParameters_In)), 3726 /* outSize */ 0, 3727 /* offsetOfTypes */ offsetof(DictionaryAttackParameters_COMMAND_DESCRIPTOR_t, types), 3728 /* offsets */ {(UINT16)(offsetof(DictionaryAttackParameters_In, newMaxTries)), 3729 (UINT16)(offsetof(DictionaryAttackParameters_In, newRecoveryTime)), 3730 (UINT16)(offsetof(DictionaryAttackParameters_In, lockoutRecovery))}, 3731 /* types */ {TPMI_RH_LOCKOUT_H_UNMARSHAL, 3732 UINT32_P_UNMARSHAL, 3733 UINT32_P_UNMARSHAL, 3734 UINT32_P_UNMARSHAL, 3735 END_OF_LIST, 3736 END_OF_LIST} 3737 }; 3738 3739 #define _DictionaryAttackParametersDataAddress (&_DictionaryAttackParametersData) 3740 #else 3741 #define _DictionaryAttackParametersDataAddress 0 3742 #endif // CC_DictionaryAttackParameters 3743 3744 #if CC_PP_Commands 3745 3746 #include "PP_Commands_fp.h" 3747 3748 typedef TPM_RC (PP_Commands_Entry)( 3749 PP_Commands_In *in 3750 ); 3751 3752 typedef const struct { 3753 PP_Commands_Entry *entry; 3754 UINT16 inSize; 3755 UINT16 outSize; 3756 UINT16 offsetOfTypes; 3757 UINT16 paramOffsets[2]; 3758 BYTE types[5]; 3759 } PP_Commands_COMMAND_DESCRIPTOR_t; 3760 3761 PP_Commands_COMMAND_DESCRIPTOR_t _PP_CommandsData = { 3762 /* entry */ &TPM2_PP_Commands, 3763 /* inSize */ (UINT16)(sizeof(PP_Commands_In)), 3764 /* outSize */ 0, 3765 /* offsetOfTypes */ offsetof(PP_Commands_COMMAND_DESCRIPTOR_t, types), 3766 /* offsets */ {(UINT16)(offsetof(PP_Commands_In, setList)), 3767 (UINT16)(offsetof(PP_Commands_In, clearList))}, 3768 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 3769 TPML_CC_P_UNMARSHAL, 3770 TPML_CC_P_UNMARSHAL, 3771 END_OF_LIST, 3772 END_OF_LIST} 3773 }; 3774 3775 #define _PP_CommandsDataAddress (&_PP_CommandsData) 3776 #else 3777 #define _PP_CommandsDataAddress 0 3778 #endif // CC_PP_Commands 3779 3780 #if CC_SetAlgorithmSet 3781 3782 #include "SetAlgorithmSet_fp.h" 3783 3784 typedef TPM_RC (SetAlgorithmSet_Entry)( 3785 SetAlgorithmSet_In *in 3786 ); 3787 3788 typedef const struct { 3789 SetAlgorithmSet_Entry *entry; 3790 UINT16 inSize; 3791 UINT16 outSize; 3792 UINT16 offsetOfTypes; 3793 UINT16 paramOffsets[1]; 3794 BYTE types[4]; 3795 } SetAlgorithmSet_COMMAND_DESCRIPTOR_t; 3796 3797 SetAlgorithmSet_COMMAND_DESCRIPTOR_t _SetAlgorithmSetData = { 3798 /* entry */ &TPM2_SetAlgorithmSet, 3799 /* inSize */ (UINT16)(sizeof(SetAlgorithmSet_In)), 3800 /* outSize */ 0, 3801 /* offsetOfTypes */ offsetof(SetAlgorithmSet_COMMAND_DESCRIPTOR_t, types), 3802 /* offsets */ {(UINT16)(offsetof(SetAlgorithmSet_In, algorithmSet))}, 3803 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 3804 UINT32_P_UNMARSHAL, 3805 END_OF_LIST, 3806 END_OF_LIST} 3807 }; 3808 3809 #define _SetAlgorithmSetDataAddress (&_SetAlgorithmSetData) 3810 #else 3811 #define _SetAlgorithmSetDataAddress 0 3812 #endif // CC_SetAlgorithmSet 3813 3814 #if CC_FieldUpgradeStart 3815 3816 #include "FieldUpgradeStart_fp.h" 3817 3818 typedef TPM_RC (FieldUpgradeStart_Entry)( 3819 FieldUpgradeStart_In *in 3820 ); 3821 3822 typedef const struct { 3823 FieldUpgradeStart_Entry *entry; 3824 UINT16 inSize; 3825 UINT16 outSize; 3826 UINT16 offsetOfTypes; 3827 UINT16 paramOffsets[3]; 3828 BYTE types[6]; 3829 } FieldUpgradeStart_COMMAND_DESCRIPTOR_t; 3830 3831 FieldUpgradeStart_COMMAND_DESCRIPTOR_t _FieldUpgradeStartData = { 3832 /* entry */ &TPM2_FieldUpgradeStart, 3833 /* inSize */ (UINT16)(sizeof(FieldUpgradeStart_In)), 3834 /* outSize */ 0, 3835 /* offsetOfTypes */ offsetof(FieldUpgradeStart_COMMAND_DESCRIPTOR_t, types), 3836 /* offsets */ {(UINT16)(offsetof(FieldUpgradeStart_In, keyHandle)), 3837 (UINT16)(offsetof(FieldUpgradeStart_In, fuDigest)), 3838 (UINT16)(offsetof(FieldUpgradeStart_In, manifestSignature))}, 3839 /* types */ {TPMI_RH_PLATFORM_H_UNMARSHAL, 3840 TPMI_DH_OBJECT_H_UNMARSHAL, 3841 TPM2B_DIGEST_P_UNMARSHAL, 3842 TPMT_SIGNATURE_P_UNMARSHAL, 3843 END_OF_LIST, 3844 END_OF_LIST} 3845 }; 3846 3847 #define _FieldUpgradeStartDataAddress (&_FieldUpgradeStartData) 3848 #else 3849 #define _FieldUpgradeStartDataAddress 0 3850 #endif // CC_FieldUpgradeStart 3851 3852 #if CC_FieldUpgradeData 3853 3854 #include "FieldUpgradeData_fp.h" 3855 3856 typedef TPM_RC (FieldUpgradeData_Entry)( 3857 FieldUpgradeData_In *in, 3858 FieldUpgradeData_Out *out 3859 ); 3860 3861 typedef const struct { 3862 FieldUpgradeData_Entry *entry; 3863 UINT16 inSize; 3864 UINT16 outSize; 3865 UINT16 offsetOfTypes; 3866 UINT16 paramOffsets[1]; 3867 BYTE types[5]; 3868 } FieldUpgradeData_COMMAND_DESCRIPTOR_t; 3869 3870 FieldUpgradeData_COMMAND_DESCRIPTOR_t _FieldUpgradeDataData = { 3871 /* entry */ &TPM2_FieldUpgradeData, 3872 /* inSize */ (UINT16)(sizeof(FieldUpgradeData_In)), 3873 /* outSize */ (UINT16)(sizeof(FieldUpgradeData_Out)), 3874 /* offsetOfTypes */ offsetof(FieldUpgradeData_COMMAND_DESCRIPTOR_t, types), 3875 /* offsets */ {(UINT16)(offsetof(FieldUpgradeData_Out, firstDigest))}, 3876 /* types */ {TPM2B_MAX_BUFFER_P_UNMARSHAL, 3877 END_OF_LIST, 3878 TPMT_HA_P_MARSHAL, 3879 TPMT_HA_P_MARSHAL, 3880 END_OF_LIST} 3881 }; 3882 3883 #define _FieldUpgradeDataDataAddress (&_FieldUpgradeDataData) 3884 #else 3885 #define _FieldUpgradeDataDataAddress 0 3886 #endif // CC_FieldUpgradeData 3887 3888 #if CC_FirmwareRead 3889 3890 #include "FirmwareRead_fp.h" 3891 3892 typedef TPM_RC (FirmwareRead_Entry)( 3893 FirmwareRead_In *in, 3894 FirmwareRead_Out *out 3895 ); 3896 3897 typedef const struct { 3898 FirmwareRead_Entry *entry; 3899 UINT16 inSize; 3900 UINT16 outSize; 3901 UINT16 offsetOfTypes; 3902 BYTE types[4]; 3903 } FirmwareRead_COMMAND_DESCRIPTOR_t; 3904 3905 FirmwareRead_COMMAND_DESCRIPTOR_t _FirmwareReadData = { 3906 /* entry */ &TPM2_FirmwareRead, 3907 /* inSize */ (UINT16)(sizeof(FirmwareRead_In)), 3908 /* outSize */ (UINT16)(sizeof(FirmwareRead_Out)), 3909 /* offsetOfTypes */ offsetof(FirmwareRead_COMMAND_DESCRIPTOR_t, types), 3910 /* offsets */ // No parameter offsets; 3911 /* types */ {UINT32_P_UNMARSHAL, 3912 END_OF_LIST, 3913 TPM2B_MAX_BUFFER_P_MARSHAL, 3914 END_OF_LIST} 3915 }; 3916 3917 #define _FirmwareReadDataAddress (&_FirmwareReadData) 3918 #else 3919 #define _FirmwareReadDataAddress 0 3920 #endif // CC_FirmwareRead 3921 3922 #if CC_ContextSave 3923 3924 #include "ContextSave_fp.h" 3925 3926 typedef TPM_RC (ContextSave_Entry)( 3927 ContextSave_In *in, 3928 ContextSave_Out *out 3929 ); 3930 3931 typedef const struct { 3932 ContextSave_Entry *entry; 3933 UINT16 inSize; 3934 UINT16 outSize; 3935 UINT16 offsetOfTypes; 3936 BYTE types[4]; 3937 } ContextSave_COMMAND_DESCRIPTOR_t; 3938 3939 ContextSave_COMMAND_DESCRIPTOR_t _ContextSaveData = { 3940 /* entry */ &TPM2_ContextSave, 3941 /* inSize */ (UINT16)(sizeof(ContextSave_In)), 3942 /* outSize */ (UINT16)(sizeof(ContextSave_Out)), 3943 /* offsetOfTypes */ offsetof(ContextSave_COMMAND_DESCRIPTOR_t, types), 3944 /* offsets */ // No parameter offsets; 3945 /* types */ {TPMI_DH_CONTEXT_H_UNMARSHAL, 3946 END_OF_LIST, 3947 TPMS_CONTEXT_P_MARSHAL, 3948 END_OF_LIST} 3949 }; 3950 3951 #define _ContextSaveDataAddress (&_ContextSaveData) 3952 #else 3953 #define _ContextSaveDataAddress 0 3954 #endif // CC_ContextSave 3955 3956 #if CC_ContextLoad 3957 3958 #include "ContextLoad_fp.h" 3959 3960 typedef TPM_RC (ContextLoad_Entry)( 3961 ContextLoad_In *in, 3962 ContextLoad_Out *out 3963 ); 3964 3965 typedef const struct { 3966 ContextLoad_Entry *entry; 3967 UINT16 inSize; 3968 UINT16 outSize; 3969 UINT16 offsetOfTypes; 3970 BYTE types[4]; 3971 } ContextLoad_COMMAND_DESCRIPTOR_t; 3972 3973 ContextLoad_COMMAND_DESCRIPTOR_t _ContextLoadData = { 3974 /* entry */ &TPM2_ContextLoad, 3975 /* inSize */ (UINT16)(sizeof(ContextLoad_In)), 3976 /* outSize */ (UINT16)(sizeof(ContextLoad_Out)), 3977 /* offsetOfTypes */ offsetof(ContextLoad_COMMAND_DESCRIPTOR_t, types), 3978 /* offsets */ // No parameter offsets; 3979 /* types */ {TPMS_CONTEXT_P_UNMARSHAL, 3980 END_OF_LIST, 3981 TPMI_DH_CONTEXT_H_MARSHAL, 3982 END_OF_LIST} 3983 }; 3984 3985 #define _ContextLoadDataAddress (&_ContextLoadData) 3986 #else 3987 #define _ContextLoadDataAddress 0 3988 #endif // CC_ContextLoad 3989 3990 #if CC_FlushContext 3991 3992 #include "FlushContext_fp.h" 3993 3994 typedef TPM_RC (FlushContext_Entry)( 3995 FlushContext_In *in 3996 ); 3997 3998 typedef const struct { 3999 FlushContext_Entry *entry; 4000 UINT16 inSize; 4001 UINT16 outSize; 4002 UINT16 offsetOfTypes; 4003 BYTE types[3]; 4004 } FlushContext_COMMAND_DESCRIPTOR_t; 4005 4006 FlushContext_COMMAND_DESCRIPTOR_t _FlushContextData = { 4007 /* entry */ &TPM2_FlushContext, 4008 /* inSize */ (UINT16)(sizeof(FlushContext_In)), 4009 /* outSize */ 0, 4010 /* offsetOfTypes */ offsetof(FlushContext_COMMAND_DESCRIPTOR_t, types), 4011 /* offsets */ // No parameter offsets; 4012 /* types */ {TPMI_DH_CONTEXT_P_UNMARSHAL, 4013 END_OF_LIST, 4014 END_OF_LIST} 4015 }; 4016 4017 #define _FlushContextDataAddress (&_FlushContextData) 4018 #else 4019 #define _FlushContextDataAddress 0 4020 #endif // CC_FlushContext 4021 4022 #if CC_EvictControl 4023 4024 #include "EvictControl_fp.h" 4025 4026 typedef TPM_RC (EvictControl_Entry)( 4027 EvictControl_In *in 4028 ); 4029 4030 typedef const struct { 4031 EvictControl_Entry *entry; 4032 UINT16 inSize; 4033 UINT16 outSize; 4034 UINT16 offsetOfTypes; 4035 UINT16 paramOffsets[2]; 4036 BYTE types[5]; 4037 } EvictControl_COMMAND_DESCRIPTOR_t; 4038 4039 EvictControl_COMMAND_DESCRIPTOR_t _EvictControlData = { 4040 /* entry */ &TPM2_EvictControl, 4041 /* inSize */ (UINT16)(sizeof(EvictControl_In)), 4042 /* outSize */ 0, 4043 /* offsetOfTypes */ offsetof(EvictControl_COMMAND_DESCRIPTOR_t, types), 4044 /* offsets */ {(UINT16)(offsetof(EvictControl_In, objectHandle)), 4045 (UINT16)(offsetof(EvictControl_In, persistentHandle))}, 4046 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4047 TPMI_DH_OBJECT_H_UNMARSHAL, 4048 TPMI_DH_PERSISTENT_P_UNMARSHAL, 4049 END_OF_LIST, 4050 END_OF_LIST} 4051 }; 4052 4053 #define _EvictControlDataAddress (&_EvictControlData) 4054 #else 4055 #define _EvictControlDataAddress 0 4056 #endif // CC_EvictControl 4057 4058 #if CC_ReadClock 4059 4060 #include "ReadClock_fp.h" 4061 4062 typedef TPM_RC (ReadClock_Entry)( 4063 ReadClock_Out *out 4064 ); 4065 4066 typedef const struct { 4067 ReadClock_Entry *entry; 4068 UINT16 inSize; 4069 UINT16 outSize; 4070 UINT16 offsetOfTypes; 4071 BYTE types[3]; 4072 } ReadClock_COMMAND_DESCRIPTOR_t; 4073 4074 ReadClock_COMMAND_DESCRIPTOR_t _ReadClockData = { 4075 /* entry */ &TPM2_ReadClock, 4076 /* inSize */ 0, 4077 /* outSize */ (UINT16)(sizeof(ReadClock_Out)), 4078 /* offsetOfTypes */ offsetof(ReadClock_COMMAND_DESCRIPTOR_t, types), 4079 /* offsets */ // No parameter offsets; 4080 /* types */ {END_OF_LIST, 4081 TPMS_TIME_INFO_P_MARSHAL, 4082 END_OF_LIST} 4083 }; 4084 4085 #define _ReadClockDataAddress (&_ReadClockData) 4086 #else 4087 #define _ReadClockDataAddress 0 4088 #endif // CC_ReadClock 4089 4090 #if CC_ClockSet 4091 4092 #include "ClockSet_fp.h" 4093 4094 typedef TPM_RC (ClockSet_Entry)( 4095 ClockSet_In *in 4096 ); 4097 4098 typedef const struct { 4099 ClockSet_Entry *entry; 4100 UINT16 inSize; 4101 UINT16 outSize; 4102 UINT16 offsetOfTypes; 4103 UINT16 paramOffsets[1]; 4104 BYTE types[4]; 4105 } ClockSet_COMMAND_DESCRIPTOR_t; 4106 4107 ClockSet_COMMAND_DESCRIPTOR_t _ClockSetData = { 4108 /* entry */ &TPM2_ClockSet, 4109 /* inSize */ (UINT16)(sizeof(ClockSet_In)), 4110 /* outSize */ 0, 4111 /* offsetOfTypes */ offsetof(ClockSet_COMMAND_DESCRIPTOR_t, types), 4112 /* offsets */ {(UINT16)(offsetof(ClockSet_In, newTime))}, 4113 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4114 UINT64_P_UNMARSHAL, 4115 END_OF_LIST, 4116 END_OF_LIST} 4117 }; 4118 4119 #define _ClockSetDataAddress (&_ClockSetData) 4120 #else 4121 #define _ClockSetDataAddress 0 4122 #endif // CC_ClockSet 4123 4124 #if CC_ClockRateAdjust 4125 4126 #include "ClockRateAdjust_fp.h" 4127 4128 typedef TPM_RC (ClockRateAdjust_Entry)( 4129 ClockRateAdjust_In *in 4130 ); 4131 4132 typedef const struct { 4133 ClockRateAdjust_Entry *entry; 4134 UINT16 inSize; 4135 UINT16 outSize; 4136 UINT16 offsetOfTypes; 4137 UINT16 paramOffsets[1]; 4138 BYTE types[4]; 4139 } ClockRateAdjust_COMMAND_DESCRIPTOR_t; 4140 4141 ClockRateAdjust_COMMAND_DESCRIPTOR_t _ClockRateAdjustData = { 4142 /* entry */ &TPM2_ClockRateAdjust, 4143 /* inSize */ (UINT16)(sizeof(ClockRateAdjust_In)), 4144 /* outSize */ 0, 4145 /* offsetOfTypes */ offsetof(ClockRateAdjust_COMMAND_DESCRIPTOR_t, types), 4146 /* offsets */ {(UINT16)(offsetof(ClockRateAdjust_In, rateAdjust))}, 4147 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4148 TPM_CLOCK_ADJUST_P_UNMARSHAL, 4149 END_OF_LIST, 4150 END_OF_LIST} 4151 }; 4152 4153 #define _ClockRateAdjustDataAddress (&_ClockRateAdjustData) 4154 #else 4155 #define _ClockRateAdjustDataAddress 0 4156 #endif // CC_ClockRateAdjust 4157 4158 #if CC_GetCapability 4159 4160 #include "GetCapability_fp.h" 4161 4162 typedef TPM_RC (GetCapability_Entry)( 4163 GetCapability_In *in, 4164 GetCapability_Out *out 4165 ); 4166 4167 typedef const struct { 4168 GetCapability_Entry *entry; 4169 UINT16 inSize; 4170 UINT16 outSize; 4171 UINT16 offsetOfTypes; 4172 UINT16 paramOffsets[3]; 4173 BYTE types[7]; 4174 } GetCapability_COMMAND_DESCRIPTOR_t; 4175 4176 GetCapability_COMMAND_DESCRIPTOR_t _GetCapabilityData = { 4177 /* entry */ &TPM2_GetCapability, 4178 /* inSize */ (UINT16)(sizeof(GetCapability_In)), 4179 /* outSize */ (UINT16)(sizeof(GetCapability_Out)), 4180 /* offsetOfTypes */ offsetof(GetCapability_COMMAND_DESCRIPTOR_t, types), 4181 /* offsets */ {(UINT16)(offsetof(GetCapability_In, property)), 4182 (UINT16)(offsetof(GetCapability_In, propertyCount)), 4183 (UINT16)(offsetof(GetCapability_Out, capabilityData))}, 4184 /* types */ {TPM_CAP_P_UNMARSHAL, 4185 UINT32_P_UNMARSHAL, 4186 UINT32_P_UNMARSHAL, 4187 END_OF_LIST, 4188 TPMI_YES_NO_P_MARSHAL, 4189 TPMS_CAPABILITY_DATA_P_MARSHAL, 4190 END_OF_LIST} 4191 }; 4192 4193 #define _GetCapabilityDataAddress (&_GetCapabilityData) 4194 #else 4195 #define _GetCapabilityDataAddress 0 4196 #endif // CC_GetCapability 4197 4198 #if CC_TestParms 4199 4200 #include "TestParms_fp.h" 4201 4202 typedef TPM_RC (TestParms_Entry)( 4203 TestParms_In *in 4204 ); 4205 4206 typedef const struct { 4207 TestParms_Entry *entry; 4208 UINT16 inSize; 4209 UINT16 outSize; 4210 UINT16 offsetOfTypes; 4211 BYTE types[3]; 4212 } TestParms_COMMAND_DESCRIPTOR_t; 4213 4214 TestParms_COMMAND_DESCRIPTOR_t _TestParmsData = { 4215 /* entry */ &TPM2_TestParms, 4216 /* inSize */ (UINT16)(sizeof(TestParms_In)), 4217 /* outSize */ 0, 4218 /* offsetOfTypes */ offsetof(TestParms_COMMAND_DESCRIPTOR_t, types), 4219 /* offsets */ // No parameter offsets; 4220 /* types */ {TPMT_PUBLIC_PARMS_P_UNMARSHAL, 4221 END_OF_LIST, 4222 END_OF_LIST} 4223 }; 4224 4225 #define _TestParmsDataAddress (&_TestParmsData) 4226 #else 4227 #define _TestParmsDataAddress 0 4228 #endif // CC_TestParms 4229 4230 #if CC_NV_DefineSpace 4231 4232 #include "NV_DefineSpace_fp.h" 4233 4234 typedef TPM_RC (NV_DefineSpace_Entry)( 4235 NV_DefineSpace_In *in 4236 ); 4237 4238 typedef const struct { 4239 NV_DefineSpace_Entry *entry; 4240 UINT16 inSize; 4241 UINT16 outSize; 4242 UINT16 offsetOfTypes; 4243 UINT16 paramOffsets[2]; 4244 BYTE types[5]; 4245 } NV_DefineSpace_COMMAND_DESCRIPTOR_t; 4246 4247 NV_DefineSpace_COMMAND_DESCRIPTOR_t _NV_DefineSpaceData = { 4248 /* entry */ &TPM2_NV_DefineSpace, 4249 /* inSize */ (UINT16)(sizeof(NV_DefineSpace_In)), 4250 /* outSize */ 0, 4251 /* offsetOfTypes */ offsetof(NV_DefineSpace_COMMAND_DESCRIPTOR_t, types), 4252 /* offsets */ {(UINT16)(offsetof(NV_DefineSpace_In, auth)), 4253 (UINT16)(offsetof(NV_DefineSpace_In, publicInfo))}, 4254 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4255 TPM2B_AUTH_P_UNMARSHAL, 4256 TPM2B_NV_PUBLIC_P_UNMARSHAL, 4257 END_OF_LIST, 4258 END_OF_LIST} 4259 }; 4260 4261 #define _NV_DefineSpaceDataAddress (&_NV_DefineSpaceData) 4262 #else 4263 #define _NV_DefineSpaceDataAddress 0 4264 #endif // CC_NV_DefineSpace 4265 4266 #if CC_NV_UndefineSpace 4267 4268 #include "NV_UndefineSpace_fp.h" 4269 4270 typedef TPM_RC (NV_UndefineSpace_Entry)( 4271 NV_UndefineSpace_In *in 4272 ); 4273 4274 typedef const struct { 4275 NV_UndefineSpace_Entry *entry; 4276 UINT16 inSize; 4277 UINT16 outSize; 4278 UINT16 offsetOfTypes; 4279 UINT16 paramOffsets[1]; 4280 BYTE types[4]; 4281 } NV_UndefineSpace_COMMAND_DESCRIPTOR_t; 4282 4283 NV_UndefineSpace_COMMAND_DESCRIPTOR_t _NV_UndefineSpaceData = { 4284 /* entry */ &TPM2_NV_UndefineSpace, 4285 /* inSize */ (UINT16)(sizeof(NV_UndefineSpace_In)), 4286 /* outSize */ 0, 4287 /* offsetOfTypes */ offsetof(NV_UndefineSpace_COMMAND_DESCRIPTOR_t, types), 4288 /* offsets */ {(UINT16)(offsetof(NV_UndefineSpace_In, nvIndex))}, 4289 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4290 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4291 END_OF_LIST, 4292 END_OF_LIST} 4293 }; 4294 4295 #define _NV_UndefineSpaceDataAddress (&_NV_UndefineSpaceData) 4296 #else 4297 #define _NV_UndefineSpaceDataAddress 0 4298 #endif // CC_NV_UndefineSpace 4299 4300 #if CC_NV_UndefineSpaceSpecial 4301 4302 #include "NV_UndefineSpaceSpecial_fp.h" 4303 4304 typedef TPM_RC (NV_UndefineSpaceSpecial_Entry)( 4305 NV_UndefineSpaceSpecial_In *in 4306 ); 4307 4308 typedef const struct { 4309 NV_UndefineSpaceSpecial_Entry *entry; 4310 UINT16 inSize; 4311 UINT16 outSize; 4312 UINT16 offsetOfTypes; 4313 UINT16 paramOffsets[1]; 4314 BYTE types[4]; 4315 } NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t; 4316 4317 NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t _NV_UndefineSpaceSpecialData = { 4318 /* entry */ &TPM2_NV_UndefineSpaceSpecial, 4319 /* inSize */ (UINT16)(sizeof(NV_UndefineSpaceSpecial_In)), 4320 /* outSize */ 0, 4321 /* offsetOfTypes */ offsetof(NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t, types), 4322 /* offsets */ {(UINT16)(offsetof(NV_UndefineSpaceSpecial_In, platform))}, 4323 /* types */ {TPMI_RH_NV_INDEX_H_UNMARSHAL, 4324 TPMI_RH_PLATFORM_H_UNMARSHAL, 4325 END_OF_LIST, 4326 END_OF_LIST} 4327 }; 4328 4329 #define _NV_UndefineSpaceSpecialDataAddress (&_NV_UndefineSpaceSpecialData) 4330 #else 4331 #define _NV_UndefineSpaceSpecialDataAddress 0 4332 #endif // CC_NV_UndefineSpaceSpecial 4333 4334 #if CC_NV_ReadPublic 4335 4336 #include "NV_ReadPublic_fp.h" 4337 4338 typedef TPM_RC (NV_ReadPublic_Entry)( 4339 NV_ReadPublic_In *in, 4340 NV_ReadPublic_Out *out 4341 ); 4342 4343 typedef const struct { 4344 NV_ReadPublic_Entry *entry; 4345 UINT16 inSize; 4346 UINT16 outSize; 4347 UINT16 offsetOfTypes; 4348 UINT16 paramOffsets[1]; 4349 BYTE types[5]; 4350 } NV_ReadPublic_COMMAND_DESCRIPTOR_t; 4351 4352 NV_ReadPublic_COMMAND_DESCRIPTOR_t _NV_ReadPublicData = { 4353 /* entry */ &TPM2_NV_ReadPublic, 4354 /* inSize */ (UINT16)(sizeof(NV_ReadPublic_In)), 4355 /* outSize */ (UINT16)(sizeof(NV_ReadPublic_Out)), 4356 /* offsetOfTypes */ offsetof(NV_ReadPublic_COMMAND_DESCRIPTOR_t, types), 4357 /* offsets */ {(UINT16)(offsetof(NV_ReadPublic_Out, nvName))}, 4358 /* types */ {TPMI_RH_NV_INDEX_H_UNMARSHAL, 4359 END_OF_LIST, 4360 TPM2B_NV_PUBLIC_P_MARSHAL, 4361 TPM2B_NAME_P_MARSHAL, 4362 END_OF_LIST} 4363 }; 4364 4365 #define _NV_ReadPublicDataAddress (&_NV_ReadPublicData) 4366 #else 4367 #define _NV_ReadPublicDataAddress 0 4368 #endif // CC_NV_ReadPublic 4369 4370 #if CC_NV_Write 4371 4372 #include "NV_Write_fp.h" 4373 4374 typedef TPM_RC (NV_Write_Entry)( 4375 NV_Write_In *in 4376 ); 4377 4378 typedef const struct { 4379 NV_Write_Entry *entry; 4380 UINT16 inSize; 4381 UINT16 outSize; 4382 UINT16 offsetOfTypes; 4383 UINT16 paramOffsets[3]; 4384 BYTE types[6]; 4385 } NV_Write_COMMAND_DESCRIPTOR_t; 4386 4387 NV_Write_COMMAND_DESCRIPTOR_t _NV_WriteData = { 4388 /* entry */ &TPM2_NV_Write, 4389 /* inSize */ (UINT16)(sizeof(NV_Write_In)), 4390 /* outSize */ 0, 4391 /* offsetOfTypes */ offsetof(NV_Write_COMMAND_DESCRIPTOR_t, types), 4392 /* offsets */ {(UINT16)(offsetof(NV_Write_In, nvIndex)), 4393 (UINT16)(offsetof(NV_Write_In, data)), 4394 (UINT16)(offsetof(NV_Write_In, offset))}, 4395 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4396 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4397 TPM2B_MAX_NV_BUFFER_P_UNMARSHAL, 4398 UINT16_P_UNMARSHAL, 4399 END_OF_LIST, 4400 END_OF_LIST} 4401 }; 4402 4403 #define _NV_WriteDataAddress (&_NV_WriteData) 4404 #else 4405 #define _NV_WriteDataAddress 0 4406 #endif // CC_NV_Write 4407 4408 #if CC_NV_Increment 4409 4410 #include "NV_Increment_fp.h" 4411 4412 typedef TPM_RC (NV_Increment_Entry)( 4413 NV_Increment_In *in 4414 ); 4415 4416 typedef const struct { 4417 NV_Increment_Entry *entry; 4418 UINT16 inSize; 4419 UINT16 outSize; 4420 UINT16 offsetOfTypes; 4421 UINT16 paramOffsets[1]; 4422 BYTE types[4]; 4423 } NV_Increment_COMMAND_DESCRIPTOR_t; 4424 4425 NV_Increment_COMMAND_DESCRIPTOR_t _NV_IncrementData = { 4426 /* entry */ &TPM2_NV_Increment, 4427 /* inSize */ (UINT16)(sizeof(NV_Increment_In)), 4428 /* outSize */ 0, 4429 /* offsetOfTypes */ offsetof(NV_Increment_COMMAND_DESCRIPTOR_t, types), 4430 /* offsets */ {(UINT16)(offsetof(NV_Increment_In, nvIndex))}, 4431 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4432 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4433 END_OF_LIST, 4434 END_OF_LIST} 4435 }; 4436 4437 #define _NV_IncrementDataAddress (&_NV_IncrementData) 4438 #else 4439 #define _NV_IncrementDataAddress 0 4440 #endif // CC_NV_Increment 4441 4442 #if CC_NV_Extend 4443 4444 #include "NV_Extend_fp.h" 4445 4446 typedef TPM_RC (NV_Extend_Entry)( 4447 NV_Extend_In *in 4448 ); 4449 4450 typedef const struct { 4451 NV_Extend_Entry *entry; 4452 UINT16 inSize; 4453 UINT16 outSize; 4454 UINT16 offsetOfTypes; 4455 UINT16 paramOffsets[2]; 4456 BYTE types[5]; 4457 } NV_Extend_COMMAND_DESCRIPTOR_t; 4458 4459 NV_Extend_COMMAND_DESCRIPTOR_t _NV_ExtendData = { 4460 /* entry */ &TPM2_NV_Extend, 4461 /* inSize */ (UINT16)(sizeof(NV_Extend_In)), 4462 /* outSize */ 0, 4463 /* offsetOfTypes */ offsetof(NV_Extend_COMMAND_DESCRIPTOR_t, types), 4464 /* offsets */ {(UINT16)(offsetof(NV_Extend_In, nvIndex)), 4465 (UINT16)(offsetof(NV_Extend_In, data))}, 4466 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4467 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4468 TPM2B_MAX_NV_BUFFER_P_UNMARSHAL, 4469 END_OF_LIST, 4470 END_OF_LIST} 4471 }; 4472 4473 #define _NV_ExtendDataAddress (&_NV_ExtendData) 4474 #else 4475 #define _NV_ExtendDataAddress 0 4476 #endif // CC_NV_Extend 4477 4478 #if CC_NV_SetBits 4479 4480 #include "NV_SetBits_fp.h" 4481 4482 typedef TPM_RC (NV_SetBits_Entry)( 4483 NV_SetBits_In *in 4484 ); 4485 4486 typedef const struct { 4487 NV_SetBits_Entry *entry; 4488 UINT16 inSize; 4489 UINT16 outSize; 4490 UINT16 offsetOfTypes; 4491 UINT16 paramOffsets[2]; 4492 BYTE types[5]; 4493 } NV_SetBits_COMMAND_DESCRIPTOR_t; 4494 4495 NV_SetBits_COMMAND_DESCRIPTOR_t _NV_SetBitsData = { 4496 /* entry */ &TPM2_NV_SetBits, 4497 /* inSize */ (UINT16)(sizeof(NV_SetBits_In)), 4498 /* outSize */ 0, 4499 /* offsetOfTypes */ offsetof(NV_SetBits_COMMAND_DESCRIPTOR_t, types), 4500 /* offsets */ {(UINT16)(offsetof(NV_SetBits_In, nvIndex)), 4501 (UINT16)(offsetof(NV_SetBits_In, bits))}, 4502 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4503 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4504 UINT64_P_UNMARSHAL, 4505 END_OF_LIST, 4506 END_OF_LIST} 4507 }; 4508 4509 #define _NV_SetBitsDataAddress (&_NV_SetBitsData) 4510 #else 4511 #define _NV_SetBitsDataAddress 0 4512 #endif // CC_NV_SetBits 4513 4514 #if CC_NV_WriteLock 4515 4516 #include "NV_WriteLock_fp.h" 4517 4518 typedef TPM_RC (NV_WriteLock_Entry)( 4519 NV_WriteLock_In *in 4520 ); 4521 4522 typedef const struct { 4523 NV_WriteLock_Entry *entry; 4524 UINT16 inSize; 4525 UINT16 outSize; 4526 UINT16 offsetOfTypes; 4527 UINT16 paramOffsets[1]; 4528 BYTE types[4]; 4529 } NV_WriteLock_COMMAND_DESCRIPTOR_t; 4530 4531 NV_WriteLock_COMMAND_DESCRIPTOR_t _NV_WriteLockData = { 4532 /* entry */ &TPM2_NV_WriteLock, 4533 /* inSize */ (UINT16)(sizeof(NV_WriteLock_In)), 4534 /* outSize */ 0, 4535 /* offsetOfTypes */ offsetof(NV_WriteLock_COMMAND_DESCRIPTOR_t, types), 4536 /* offsets */ {(UINT16)(offsetof(NV_WriteLock_In, nvIndex))}, 4537 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4538 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4539 END_OF_LIST, 4540 END_OF_LIST} 4541 }; 4542 4543 #define _NV_WriteLockDataAddress (&_NV_WriteLockData) 4544 #else 4545 #define _NV_WriteLockDataAddress 0 4546 #endif // CC_NV_WriteLock 4547 4548 #if CC_NV_GlobalWriteLock 4549 4550 #include "NV_GlobalWriteLock_fp.h" 4551 4552 typedef TPM_RC (NV_GlobalWriteLock_Entry)( 4553 NV_GlobalWriteLock_In *in 4554 ); 4555 4556 typedef const struct { 4557 NV_GlobalWriteLock_Entry *entry; 4558 UINT16 inSize; 4559 UINT16 outSize; 4560 UINT16 offsetOfTypes; 4561 BYTE types[3]; 4562 } NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t; 4563 4564 NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t _NV_GlobalWriteLockData = { 4565 /* entry */ &TPM2_NV_GlobalWriteLock, 4566 /* inSize */ (UINT16)(sizeof(NV_GlobalWriteLock_In)), 4567 /* outSize */ 0, 4568 /* offsetOfTypes */ offsetof(NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t, types), 4569 /* offsets */ // No parameter offsets; 4570 /* types */ {TPMI_RH_PROVISION_H_UNMARSHAL, 4571 END_OF_LIST, 4572 END_OF_LIST} 4573 }; 4574 4575 #define _NV_GlobalWriteLockDataAddress (&_NV_GlobalWriteLockData) 4576 #else 4577 #define _NV_GlobalWriteLockDataAddress 0 4578 #endif // CC_NV_GlobalWriteLock 4579 4580 #if CC_NV_Read 4581 4582 #include "NV_Read_fp.h" 4583 4584 typedef TPM_RC (NV_Read_Entry)( 4585 NV_Read_In *in, 4586 NV_Read_Out *out 4587 ); 4588 4589 typedef const struct { 4590 NV_Read_Entry *entry; 4591 UINT16 inSize; 4592 UINT16 outSize; 4593 UINT16 offsetOfTypes; 4594 UINT16 paramOffsets[3]; 4595 BYTE types[7]; 4596 } NV_Read_COMMAND_DESCRIPTOR_t; 4597 4598 NV_Read_COMMAND_DESCRIPTOR_t _NV_ReadData = { 4599 /* entry */ &TPM2_NV_Read, 4600 /* inSize */ (UINT16)(sizeof(NV_Read_In)), 4601 /* outSize */ (UINT16)(sizeof(NV_Read_Out)), 4602 /* offsetOfTypes */ offsetof(NV_Read_COMMAND_DESCRIPTOR_t, types), 4603 /* offsets */ {(UINT16)(offsetof(NV_Read_In, nvIndex)), 4604 (UINT16)(offsetof(NV_Read_In, size)), 4605 (UINT16)(offsetof(NV_Read_In, offset))}, 4606 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4607 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4608 UINT16_P_UNMARSHAL, 4609 UINT16_P_UNMARSHAL, 4610 END_OF_LIST, 4611 TPM2B_MAX_NV_BUFFER_P_MARSHAL, 4612 END_OF_LIST} 4613 }; 4614 4615 #define _NV_ReadDataAddress (&_NV_ReadData) 4616 #else 4617 #define _NV_ReadDataAddress 0 4618 #endif // CC_NV_Read 4619 4620 #if CC_NV_ReadLock 4621 4622 #include "NV_ReadLock_fp.h" 4623 4624 typedef TPM_RC (NV_ReadLock_Entry)( 4625 NV_ReadLock_In *in 4626 ); 4627 4628 typedef const struct { 4629 NV_ReadLock_Entry *entry; 4630 UINT16 inSize; 4631 UINT16 outSize; 4632 UINT16 offsetOfTypes; 4633 UINT16 paramOffsets[1]; 4634 BYTE types[4]; 4635 } NV_ReadLock_COMMAND_DESCRIPTOR_t; 4636 4637 NV_ReadLock_COMMAND_DESCRIPTOR_t _NV_ReadLockData = { 4638 /* entry */ &TPM2_NV_ReadLock, 4639 /* inSize */ (UINT16)(sizeof(NV_ReadLock_In)), 4640 /* outSize */ 0, 4641 /* offsetOfTypes */ offsetof(NV_ReadLock_COMMAND_DESCRIPTOR_t, types), 4642 /* offsets */ {(UINT16)(offsetof(NV_ReadLock_In, nvIndex))}, 4643 /* types */ {TPMI_RH_NV_AUTH_H_UNMARSHAL, 4644 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4645 END_OF_LIST, 4646 END_OF_LIST} 4647 }; 4648 4649 #define _NV_ReadLockDataAddress (&_NV_ReadLockData) 4650 #else 4651 #define _NV_ReadLockDataAddress 0 4652 #endif // CC_NV_ReadLock 4653 4654 #if CC_NV_ChangeAuth 4655 4656 #include "NV_ChangeAuth_fp.h" 4657 4658 typedef TPM_RC (NV_ChangeAuth_Entry)( 4659 NV_ChangeAuth_In *in 4660 ); 4661 4662 typedef const struct { 4663 NV_ChangeAuth_Entry *entry; 4664 UINT16 inSize; 4665 UINT16 outSize; 4666 UINT16 offsetOfTypes; 4667 UINT16 paramOffsets[1]; 4668 BYTE types[4]; 4669 } NV_ChangeAuth_COMMAND_DESCRIPTOR_t; 4670 4671 NV_ChangeAuth_COMMAND_DESCRIPTOR_t _NV_ChangeAuthData = { 4672 /* entry */ &TPM2_NV_ChangeAuth, 4673 /* inSize */ (UINT16)(sizeof(NV_ChangeAuth_In)), 4674 /* outSize */ 0, 4675 /* offsetOfTypes */ offsetof(NV_ChangeAuth_COMMAND_DESCRIPTOR_t, types), 4676 /* offsets */ {(UINT16)(offsetof(NV_ChangeAuth_In, newAuth))}, 4677 /* types */ {TPMI_RH_NV_INDEX_H_UNMARSHAL, 4678 TPM2B_AUTH_P_UNMARSHAL, 4679 END_OF_LIST, 4680 END_OF_LIST} 4681 }; 4682 4683 #define _NV_ChangeAuthDataAddress (&_NV_ChangeAuthData) 4684 #else 4685 #define _NV_ChangeAuthDataAddress 0 4686 #endif // CC_NV_ChangeAuth 4687 4688 #if CC_NV_Certify 4689 4690 #include "NV_Certify_fp.h" 4691 4692 typedef TPM_RC (NV_Certify_Entry)( 4693 NV_Certify_In *in, 4694 NV_Certify_Out *out 4695 ); 4696 4697 typedef const struct { 4698 NV_Certify_Entry *entry; 4699 UINT16 inSize; 4700 UINT16 outSize; 4701 UINT16 offsetOfTypes; 4702 UINT16 paramOffsets[7]; 4703 BYTE types[11]; 4704 } NV_Certify_COMMAND_DESCRIPTOR_t; 4705 4706 NV_Certify_COMMAND_DESCRIPTOR_t _NV_CertifyData = { 4707 /* entry */ &TPM2_NV_Certify, 4708 /* inSize */ (UINT16)(sizeof(NV_Certify_In)), 4709 /* outSize */ (UINT16)(sizeof(NV_Certify_Out)), 4710 /* offsetOfTypes */ offsetof(NV_Certify_COMMAND_DESCRIPTOR_t, types), 4711 /* offsets */ {(UINT16)(offsetof(NV_Certify_In, authHandle)), 4712 (UINT16)(offsetof(NV_Certify_In, nvIndex)), 4713 (UINT16)(offsetof(NV_Certify_In, qualifyingData)), 4714 (UINT16)(offsetof(NV_Certify_In, inScheme)), 4715 (UINT16)(offsetof(NV_Certify_In, size)), 4716 (UINT16)(offsetof(NV_Certify_In, offset)), 4717 (UINT16)(offsetof(NV_Certify_Out, signature))}, 4718 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG, 4719 TPMI_RH_NV_AUTH_H_UNMARSHAL, 4720 TPMI_RH_NV_INDEX_H_UNMARSHAL, 4721 TPM2B_DATA_P_UNMARSHAL, 4722 TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG, 4723 UINT16_P_UNMARSHAL, 4724 UINT16_P_UNMARSHAL, 4725 END_OF_LIST, 4726 TPM2B_ATTEST_P_MARSHAL, 4727 TPMT_SIGNATURE_P_MARSHAL, 4728 END_OF_LIST} 4729 }; 4730 4731 #define _NV_CertifyDataAddress (&_NV_CertifyData) 4732 #else 4733 #define _NV_CertifyDataAddress 0 4734 #endif // CC_NV_Certify 4735 4736 #if CC_AC_GetCapability 4737 4738 #include "AC_GetCapability_fp.h" 4739 4740 typedef TPM_RC (AC_GetCapability_Entry)( 4741 AC_GetCapability_In *in, 4742 AC_GetCapability_Out *out 4743 ); 4744 4745 typedef const struct { 4746 AC_GetCapability_Entry *entry; 4747 UINT16 inSize; 4748 UINT16 outSize; 4749 UINT16 offsetOfTypes; 4750 UINT16 paramOffsets[3]; 4751 BYTE types[7]; 4752 } AC_GetCapability_COMMAND_DESCRIPTOR_t; 4753 4754 AC_GetCapability_COMMAND_DESCRIPTOR_t _AC_GetCapabilityData = { 4755 /* entry */ &TPM2_AC_GetCapability, 4756 /* inSize */ (UINT16)(sizeof(AC_GetCapability_In)), 4757 /* outSize */ (UINT16)(sizeof(AC_GetCapability_Out)), 4758 /* offsetOfTypes */ offsetof(AC_GetCapability_COMMAND_DESCRIPTOR_t, types), 4759 /* offsets */ {(UINT16)(offsetof(AC_GetCapability_In, capability)), 4760 (UINT16)(offsetof(AC_GetCapability_In, count)), 4761 (UINT16)(offsetof(AC_GetCapability_Out, capabilitiesData))}, 4762 /* types */ {TPMI_RH_AC_H_UNMARSHAL, 4763 TPM_AT_P_UNMARSHAL, 4764 UINT32_P_UNMARSHAL, 4765 END_OF_LIST, 4766 TPMI_YES_NO_P_MARSHAL, 4767 TPML_AC_CAPABILITIES_P_MARSHAL, 4768 END_OF_LIST} 4769 }; 4770 4771 #define _AC_GetCapabilityDataAddress (&_AC_GetCapabilityData) 4772 #else 4773 #define _AC_GetCapabilityDataAddress 0 4774 #endif // CC_AC_GetCapability 4775 4776 #if CC_AC_Send 4777 4778 #include "AC_Send_fp.h" 4779 4780 typedef TPM_RC (AC_Send_Entry)( 4781 AC_Send_In *in, 4782 AC_Send_Out *out 4783 ); 4784 4785 typedef const struct { 4786 AC_Send_Entry *entry; 4787 UINT16 inSize; 4788 UINT16 outSize; 4789 UINT16 offsetOfTypes; 4790 UINT16 paramOffsets[3]; 4791 BYTE types[7]; 4792 } AC_Send_COMMAND_DESCRIPTOR_t; 4793 4794 AC_Send_COMMAND_DESCRIPTOR_t _AC_SendData = { 4795 /* entry */ &TPM2_AC_Send, 4796 /* inSize */ (UINT16)(sizeof(AC_Send_In)), 4797 /* outSize */ (UINT16)(sizeof(AC_Send_Out)), 4798 /* offsetOfTypes */ offsetof(AC_Send_COMMAND_DESCRIPTOR_t, types), 4799 /* offsets */ {(UINT16)(offsetof(AC_Send_In, authHandle)), 4800 (UINT16)(offsetof(AC_Send_In, ac)), 4801 (UINT16)(offsetof(AC_Send_In, acDataIn))}, 4802 /* types */ {TPMI_DH_OBJECT_H_UNMARSHAL, 4803 TPMI_RH_NV_AUTH_H_UNMARSHAL, 4804 TPMI_RH_AC_H_UNMARSHAL, 4805 TPM2B_MAX_BUFFER_P_UNMARSHAL, 4806 END_OF_LIST, 4807 TPMS_AC_OUTPUT_P_MARSHAL, 4808 END_OF_LIST} 4809 }; 4810 4811 #define _AC_SendDataAddress (&_AC_SendData) 4812 #else 4813 #define _AC_SendDataAddress 0 4814 #endif // CC_AC_Send 4815 4816 #if CC_Policy_AC_SendSelect 4817 4818 #include "Policy_AC_SendSelect_fp.h" 4819 4820 typedef TPM_RC (Policy_AC_SendSelect_Entry)( 4821 Policy_AC_SendSelect_In *in 4822 ); 4823 4824 typedef const struct { 4825 Policy_AC_SendSelect_Entry *entry; 4826 UINT16 inSize; 4827 UINT16 outSize; 4828 UINT16 offsetOfTypes; 4829 UINT16 paramOffsets[4]; 4830 BYTE types[7]; 4831 } Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t; 4832 4833 Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t _Policy_AC_SendSelectData = { 4834 /* entry */ &TPM2_Policy_AC_SendSelect, 4835 /* inSize */ (UINT16)(sizeof(Policy_AC_SendSelect_In)), 4836 /* outSize */ 0, 4837 /* offsetOfTypes */ offsetof(Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t, types), 4838 /* offsets */ {(UINT16)(offsetof(Policy_AC_SendSelect_In, objectName)), 4839 (UINT16)(offsetof(Policy_AC_SendSelect_In, authHandleName)), 4840 (UINT16)(offsetof(Policy_AC_SendSelect_In, acName)), 4841 (UINT16)(offsetof(Policy_AC_SendSelect_In, includeObject))}, 4842 /* types */ {TPMI_SH_POLICY_H_UNMARSHAL, 4843 TPM2B_NAME_P_UNMARSHAL, 4844 TPM2B_NAME_P_UNMARSHAL, 4845 TPM2B_NAME_P_UNMARSHAL, 4846 TPMI_YES_NO_P_UNMARSHAL, 4847 END_OF_LIST, 4848 END_OF_LIST} 4849 }; 4850 4851 #define _Policy_AC_SendSelectDataAddress (&_Policy_AC_SendSelectData) 4852 #else 4853 #define _Policy_AC_SendSelectDataAddress 0 4854 #endif // CC_Policy_AC_SendSelect 4855 4856 #if CC_ACT_SetTimeout 4857 4858 #include "ACT_SetTimeout_fp.h" 4859 4860 typedef TPM_RC (ACT_SetTimeout_Entry)( 4861 ACT_SetTimeout_In *in 4862 ); 4863 4864 typedef const struct { 4865 ACT_SetTimeout_Entry *entry; 4866 UINT16 inSize; 4867 UINT16 outSize; 4868 UINT16 offsetOfTypes; 4869 UINT16 paramOffsets[1]; 4870 BYTE types[4]; 4871 } ACT_SetTimeout_COMMAND_DESCRIPTOR_t; 4872 4873 ACT_SetTimeout_COMMAND_DESCRIPTOR_t _ACT_SetTimeoutData = { 4874 /* entry */ &TPM2_ACT_SetTimeout, 4875 /* inSize */ (UINT16)(sizeof(ACT_SetTimeout_In)), 4876 /* outSize */ 0, 4877 /* offsetOfTypes */ offsetof(ACT_SetTimeout_COMMAND_DESCRIPTOR_t, types), 4878 /* offsets */ {(UINT16)(offsetof(ACT_SetTimeout_In, startTimeout))}, 4879 /* types */ {TPMI_RH_ACT_H_UNMARSHAL, 4880 UINT32_P_UNMARSHAL, 4881 END_OF_LIST, 4882 END_OF_LIST} 4883 }; 4884 4885 #define _ACT_SetTimeoutDataAddress (&_ACT_SetTimeoutData) 4886 #else 4887 #define _ACT_SetTimeoutDataAddress 0 4888 #endif // CC_ACT_SetTimeout 4889 4890 #if CC_Vendor_TCG_Test 4891 4892 #include "Vendor_TCG_Test_fp.h" 4893 4894 typedef TPM_RC (Vendor_TCG_Test_Entry)( 4895 Vendor_TCG_Test_In *in, 4896 Vendor_TCG_Test_Out *out 4897 ); 4898 4899 typedef const struct { 4900 Vendor_TCG_Test_Entry *entry; 4901 UINT16 inSize; 4902 UINT16 outSize; 4903 UINT16 offsetOfTypes; 4904 BYTE types[4]; 4905 } Vendor_TCG_Test_COMMAND_DESCRIPTOR_t; 4906 4907 Vendor_TCG_Test_COMMAND_DESCRIPTOR_t _Vendor_TCG_TestData = { 4908 /* entry */ &TPM2_Vendor_TCG_Test, 4909 /* inSize */ (UINT16)(sizeof(Vendor_TCG_Test_In)), 4910 /* outSize */ (UINT16)(sizeof(Vendor_TCG_Test_Out)), 4911 /* offsetOfTypes */ offsetof(Vendor_TCG_Test_COMMAND_DESCRIPTOR_t, types), 4912 /* offsets */ // No parameter offsets; 4913 /* types */ {TPM2B_DATA_P_UNMARSHAL, 4914 END_OF_LIST, 4915 TPM2B_DATA_P_MARSHAL, 4916 END_OF_LIST} 4917 }; 4918 4919 #define _Vendor_TCG_TestDataAddress (&_Vendor_TCG_TestData) 4920 #else 4921 #define _Vendor_TCG_TestDataAddress 0 4922 #endif // CC_Vendor_TCG_Test 4923 4924 COMMAND_DESCRIPTOR_t *s_CommandDataArray[] = { 4925 #if (PAD_LIST || CC_NV_UndefineSpaceSpecial) 4926 (COMMAND_DESCRIPTOR_t *)_NV_UndefineSpaceSpecialDataAddress, 4927 #endif // CC_NV_UndefineSpaceSpecial 4928 #if (PAD_LIST || CC_EvictControl) 4929 (COMMAND_DESCRIPTOR_t *)_EvictControlDataAddress, 4930 #endif // CC_EvictControl 4931 #if (PAD_LIST || CC_HierarchyControl) 4932 (COMMAND_DESCRIPTOR_t *)_HierarchyControlDataAddress, 4933 #endif // CC_HierarchyControl 4934 #if (PAD_LIST || CC_NV_UndefineSpace) 4935 (COMMAND_DESCRIPTOR_t *)_NV_UndefineSpaceDataAddress, 4936 #endif // CC_NV_UndefineSpace 4937 #if (PAD_LIST) 4938 (COMMAND_DESCRIPTOR_t *)0, 4939 #endif // 4940 #if (PAD_LIST || CC_ChangeEPS) 4941 (COMMAND_DESCRIPTOR_t *)_ChangeEPSDataAddress, 4942 #endif // CC_ChangeEPS 4943 #if (PAD_LIST || CC_ChangePPS) 4944 (COMMAND_DESCRIPTOR_t *)_ChangePPSDataAddress, 4945 #endif // CC_ChangePPS 4946 #if (PAD_LIST || CC_Clear) 4947 (COMMAND_DESCRIPTOR_t *)_ClearDataAddress, 4948 #endif // CC_Clear 4949 #if (PAD_LIST || CC_ClearControl) 4950 (COMMAND_DESCRIPTOR_t *)_ClearControlDataAddress, 4951 #endif // CC_ClearControl 4952 #if (PAD_LIST || CC_ClockSet) 4953 (COMMAND_DESCRIPTOR_t *)_ClockSetDataAddress, 4954 #endif // CC_ClockSet 4955 #if (PAD_LIST || CC_HierarchyChangeAuth) 4956 (COMMAND_DESCRIPTOR_t *)_HierarchyChangeAuthDataAddress, 4957 #endif // CC_HierarchyChangeAuth 4958 #if (PAD_LIST || CC_NV_DefineSpace) 4959 (COMMAND_DESCRIPTOR_t *)_NV_DefineSpaceDataAddress, 4960 #endif // CC_NV_DefineSpace 4961 #if (PAD_LIST || CC_PCR_Allocate) 4962 (COMMAND_DESCRIPTOR_t *)_PCR_AllocateDataAddress, 4963 #endif // CC_PCR_Allocate 4964 #if (PAD_LIST || CC_PCR_SetAuthPolicy) 4965 (COMMAND_DESCRIPTOR_t *)_PCR_SetAuthPolicyDataAddress, 4966 #endif // CC_PCR_SetAuthPolicy 4967 #if (PAD_LIST || CC_PP_Commands) 4968 (COMMAND_DESCRIPTOR_t *)_PP_CommandsDataAddress, 4969 #endif // CC_PP_Commands 4970 #if (PAD_LIST || CC_SetPrimaryPolicy) 4971 (COMMAND_DESCRIPTOR_t *)_SetPrimaryPolicyDataAddress, 4972 #endif // CC_SetPrimaryPolicy 4973 #if (PAD_LIST || CC_FieldUpgradeStart) 4974 (COMMAND_DESCRIPTOR_t *)_FieldUpgradeStartDataAddress, 4975 #endif // CC_FieldUpgradeStart 4976 #if (PAD_LIST || CC_ClockRateAdjust) 4977 (COMMAND_DESCRIPTOR_t *)_ClockRateAdjustDataAddress, 4978 #endif // CC_ClockRateAdjust 4979 #if (PAD_LIST || CC_CreatePrimary) 4980 (COMMAND_DESCRIPTOR_t *)_CreatePrimaryDataAddress, 4981 #endif // CC_CreatePrimary 4982 #if (PAD_LIST || CC_NV_GlobalWriteLock) 4983 (COMMAND_DESCRIPTOR_t *)_NV_GlobalWriteLockDataAddress, 4984 #endif // CC_NV_GlobalWriteLock 4985 #if (PAD_LIST || CC_GetCommandAuditDigest) 4986 (COMMAND_DESCRIPTOR_t *)_GetCommandAuditDigestDataAddress, 4987 #endif // CC_GetCommandAuditDigest 4988 #if (PAD_LIST || CC_NV_Increment) 4989 (COMMAND_DESCRIPTOR_t *)_NV_IncrementDataAddress, 4990 #endif // CC_NV_Increment 4991 #if (PAD_LIST || CC_NV_SetBits) 4992 (COMMAND_DESCRIPTOR_t *)_NV_SetBitsDataAddress, 4993 #endif // CC_NV_SetBits 4994 #if (PAD_LIST || CC_NV_Extend) 4995 (COMMAND_DESCRIPTOR_t *)_NV_ExtendDataAddress, 4996 #endif // CC_NV_Extend 4997 #if (PAD_LIST || CC_NV_Write) 4998 (COMMAND_DESCRIPTOR_t *)_NV_WriteDataAddress, 4999 #endif // CC_NV_Write 5000 #if (PAD_LIST || CC_NV_WriteLock) 5001 (COMMAND_DESCRIPTOR_t *)_NV_WriteLockDataAddress, 5002 #endif // CC_NV_WriteLock 5003 #if (PAD_LIST || CC_DictionaryAttackLockReset) 5004 (COMMAND_DESCRIPTOR_t *)_DictionaryAttackLockResetDataAddress, 5005 #endif // CC_DictionaryAttackLockReset 5006 #if (PAD_LIST || CC_DictionaryAttackParameters) 5007 (COMMAND_DESCRIPTOR_t *)_DictionaryAttackParametersDataAddress, 5008 #endif // CC_DictionaryAttackParameters 5009 #if (PAD_LIST || CC_NV_ChangeAuth) 5010 (COMMAND_DESCRIPTOR_t *)_NV_ChangeAuthDataAddress, 5011 #endif // CC_NV_ChangeAuth 5012 #if (PAD_LIST || CC_PCR_Event) 5013 (COMMAND_DESCRIPTOR_t *)_PCR_EventDataAddress, 5014 #endif // CC_PCR_Event 5015 #if (PAD_LIST || CC_PCR_Reset) 5016 (COMMAND_DESCRIPTOR_t *)_PCR_ResetDataAddress, 5017 #endif // CC_PCR_Reset 5018 #if (PAD_LIST || CC_SequenceComplete) 5019 (COMMAND_DESCRIPTOR_t *)_SequenceCompleteDataAddress, 5020 #endif // CC_SequenceComplete 5021 #if (PAD_LIST || CC_SetAlgorithmSet) 5022 (COMMAND_DESCRIPTOR_t *)_SetAlgorithmSetDataAddress, 5023 #endif // CC_SetAlgorithmSet 5024 #if (PAD_LIST || CC_SetCommandCodeAuditStatus) 5025 (COMMAND_DESCRIPTOR_t *)_SetCommandCodeAuditStatusDataAddress, 5026 #endif // CC_SetCommandCodeAuditStatus 5027 #if (PAD_LIST || CC_FieldUpgradeData) 5028 (COMMAND_DESCRIPTOR_t *)_FieldUpgradeDataDataAddress, 5029 #endif // CC_FieldUpgradeData 5030 #if (PAD_LIST || CC_IncrementalSelfTest) 5031 (COMMAND_DESCRIPTOR_t *)_IncrementalSelfTestDataAddress, 5032 #endif // CC_IncrementalSelfTest 5033 #if (PAD_LIST || CC_SelfTest) 5034 (COMMAND_DESCRIPTOR_t *)_SelfTestDataAddress, 5035 #endif // CC_SelfTest 5036 #if (PAD_LIST || CC_Startup) 5037 (COMMAND_DESCRIPTOR_t *)_StartupDataAddress, 5038 #endif // CC_Startup 5039 #if (PAD_LIST || CC_Shutdown) 5040 (COMMAND_DESCRIPTOR_t *)_ShutdownDataAddress, 5041 #endif // CC_Shutdown 5042 #if (PAD_LIST || CC_StirRandom) 5043 (COMMAND_DESCRIPTOR_t *)_StirRandomDataAddress, 5044 #endif // CC_StirRandom 5045 #if (PAD_LIST || CC_ActivateCredential) 5046 (COMMAND_DESCRIPTOR_t *)_ActivateCredentialDataAddress, 5047 #endif // CC_ActivateCredential 5048 #if (PAD_LIST || CC_Certify) 5049 (COMMAND_DESCRIPTOR_t *)_CertifyDataAddress, 5050 #endif // CC_Certify 5051 #if (PAD_LIST || CC_PolicyNV) 5052 (COMMAND_DESCRIPTOR_t *)_PolicyNVDataAddress, 5053 #endif // CC_PolicyNV 5054 #if (PAD_LIST || CC_CertifyCreation) 5055 (COMMAND_DESCRIPTOR_t *)_CertifyCreationDataAddress, 5056 #endif // CC_CertifyCreation 5057 #if (PAD_LIST || CC_Duplicate) 5058 (COMMAND_DESCRIPTOR_t *)_DuplicateDataAddress, 5059 #endif // CC_Duplicate 5060 #if (PAD_LIST || CC_GetTime) 5061 (COMMAND_DESCRIPTOR_t *)_GetTimeDataAddress, 5062 #endif // CC_GetTime 5063 #if (PAD_LIST || CC_GetSessionAuditDigest) 5064 (COMMAND_DESCRIPTOR_t *)_GetSessionAuditDigestDataAddress, 5065 #endif // CC_GetSessionAuditDigest 5066 #if (PAD_LIST || CC_NV_Read) 5067 (COMMAND_DESCRIPTOR_t *)_NV_ReadDataAddress, 5068 #endif // CC_NV_Read 5069 #if (PAD_LIST || CC_NV_ReadLock) 5070 (COMMAND_DESCRIPTOR_t *)_NV_ReadLockDataAddress, 5071 #endif // CC_NV_ReadLock 5072 #if (PAD_LIST || CC_ObjectChangeAuth) 5073 (COMMAND_DESCRIPTOR_t *)_ObjectChangeAuthDataAddress, 5074 #endif // CC_ObjectChangeAuth 5075 #if (PAD_LIST || CC_PolicySecret) 5076 (COMMAND_DESCRIPTOR_t *)_PolicySecretDataAddress, 5077 #endif // CC_PolicySecret 5078 #if (PAD_LIST || CC_Rewrap) 5079 (COMMAND_DESCRIPTOR_t *)_RewrapDataAddress, 5080 #endif // CC_Rewrap 5081 #if (PAD_LIST || CC_Create) 5082 (COMMAND_DESCRIPTOR_t *)_CreateDataAddress, 5083 #endif // CC_Create 5084 #if (PAD_LIST || CC_ECDH_ZGen) 5085 (COMMAND_DESCRIPTOR_t *)_ECDH_ZGenDataAddress, 5086 #endif // CC_ECDH_ZGen 5087 #if (PAD_LIST || (CC_HMAC || CC_MAC)) 5088 # if CC_HMAC 5089 (COMMAND_DESCRIPTOR_t *)_HMACDataAddress, 5090 # endif 5091 # if CC_MAC 5092 (COMMAND_DESCRIPTOR_t *)_MACDataAddress, 5093 # endif 5094 # if (CC_HMAC || CC_MAC) > 1 5095 # error "More than one aliased command defined" 5096 # endif 5097 #endif // CC_HMAC CC_MAC 5098 #if (PAD_LIST || CC_Import) 5099 (COMMAND_DESCRIPTOR_t *)_ImportDataAddress, 5100 #endif // CC_Import 5101 #if (PAD_LIST || CC_Load) 5102 (COMMAND_DESCRIPTOR_t *)_LoadDataAddress, 5103 #endif // CC_Load 5104 #if (PAD_LIST || CC_Quote) 5105 (COMMAND_DESCRIPTOR_t *)_QuoteDataAddress, 5106 #endif // CC_Quote 5107 #if (PAD_LIST || CC_RSA_Decrypt) 5108 (COMMAND_DESCRIPTOR_t *)_RSA_DecryptDataAddress, 5109 #endif // CC_RSA_Decrypt 5110 #if (PAD_LIST) 5111 (COMMAND_DESCRIPTOR_t *)0, 5112 #endif // 5113 #if (PAD_LIST || (CC_HMAC_Start || CC_MAC_Start)) 5114 # if CC_HMAC_Start 5115 (COMMAND_DESCRIPTOR_t *)_HMAC_StartDataAddress, 5116 # endif 5117 # if CC_MAC_Start 5118 (COMMAND_DESCRIPTOR_t *)_MAC_StartDataAddress, 5119 # endif 5120 # if (CC_HMAC_Start || CC_MAC_Start) > 1 5121 # error "More than one aliased command defined" 5122 # endif 5123 #endif // CC_HMAC_Start CC_MAC_Start 5124 #if (PAD_LIST || CC_SequenceUpdate) 5125 (COMMAND_DESCRIPTOR_t *)_SequenceUpdateDataAddress, 5126 #endif // CC_SequenceUpdate 5127 #if (PAD_LIST || CC_Sign) 5128 (COMMAND_DESCRIPTOR_t *)_SignDataAddress, 5129 #endif // CC_Sign 5130 #if (PAD_LIST || CC_Unseal) 5131 (COMMAND_DESCRIPTOR_t *)_UnsealDataAddress, 5132 #endif // CC_Unseal 5133 #if (PAD_LIST) 5134 (COMMAND_DESCRIPTOR_t *)0, 5135 #endif // 5136 #if (PAD_LIST || CC_PolicySigned) 5137 (COMMAND_DESCRIPTOR_t *)_PolicySignedDataAddress, 5138 #endif // CC_PolicySigned 5139 #if (PAD_LIST || CC_ContextLoad) 5140 (COMMAND_DESCRIPTOR_t *)_ContextLoadDataAddress, 5141 #endif // CC_ContextLoad 5142 #if (PAD_LIST || CC_ContextSave) 5143 (COMMAND_DESCRIPTOR_t *)_ContextSaveDataAddress, 5144 #endif // CC_ContextSave 5145 #if (PAD_LIST || CC_ECDH_KeyGen) 5146 (COMMAND_DESCRIPTOR_t *)_ECDH_KeyGenDataAddress, 5147 #endif // CC_ECDH_KeyGen 5148 #if (PAD_LIST || CC_EncryptDecrypt) 5149 (COMMAND_DESCRIPTOR_t *)_EncryptDecryptDataAddress, 5150 #endif // CC_EncryptDecrypt 5151 #if (PAD_LIST || CC_FlushContext) 5152 (COMMAND_DESCRIPTOR_t *)_FlushContextDataAddress, 5153 #endif // CC_FlushContext 5154 #if (PAD_LIST) 5155 (COMMAND_DESCRIPTOR_t *)0, 5156 #endif // 5157 #if (PAD_LIST || CC_LoadExternal) 5158 (COMMAND_DESCRIPTOR_t *)_LoadExternalDataAddress, 5159 #endif // CC_LoadExternal 5160 #if (PAD_LIST || CC_MakeCredential) 5161 (COMMAND_DESCRIPTOR_t *)_MakeCredentialDataAddress, 5162 #endif // CC_MakeCredential 5163 #if (PAD_LIST || CC_NV_ReadPublic) 5164 (COMMAND_DESCRIPTOR_t *)_NV_ReadPublicDataAddress, 5165 #endif // CC_NV_ReadPublic 5166 #if (PAD_LIST || CC_PolicyAuthorize) 5167 (COMMAND_DESCRIPTOR_t *)_PolicyAuthorizeDataAddress, 5168 #endif // CC_PolicyAuthorize 5169 #if (PAD_LIST || CC_PolicyAuthValue) 5170 (COMMAND_DESCRIPTOR_t *)_PolicyAuthValueDataAddress, 5171 #endif // CC_PolicyAuthValue 5172 #if (PAD_LIST || CC_PolicyCommandCode) 5173 (COMMAND_DESCRIPTOR_t *)_PolicyCommandCodeDataAddress, 5174 #endif // CC_PolicyCommandCode 5175 #if (PAD_LIST || CC_PolicyCounterTimer) 5176 (COMMAND_DESCRIPTOR_t *)_PolicyCounterTimerDataAddress, 5177 #endif // CC_PolicyCounterTimer 5178 #if (PAD_LIST || CC_PolicyCpHash) 5179 (COMMAND_DESCRIPTOR_t *)_PolicyCpHashDataAddress, 5180 #endif // CC_PolicyCpHash 5181 #if (PAD_LIST || CC_PolicyLocality) 5182 (COMMAND_DESCRIPTOR_t *)_PolicyLocalityDataAddress, 5183 #endif // CC_PolicyLocality 5184 #if (PAD_LIST || CC_PolicyNameHash) 5185 (COMMAND_DESCRIPTOR_t *)_PolicyNameHashDataAddress, 5186 #endif // CC_PolicyNameHash 5187 #if (PAD_LIST || CC_PolicyOR) 5188 (COMMAND_DESCRIPTOR_t *)_PolicyORDataAddress, 5189 #endif // CC_PolicyOR 5190 #if (PAD_LIST || CC_PolicyTicket) 5191 (COMMAND_DESCRIPTOR_t *)_PolicyTicketDataAddress, 5192 #endif // CC_PolicyTicket 5193 #if (PAD_LIST || CC_ReadPublic) 5194 (COMMAND_DESCRIPTOR_t *)_ReadPublicDataAddress, 5195 #endif // CC_ReadPublic 5196 #if (PAD_LIST || CC_RSA_Encrypt) 5197 (COMMAND_DESCRIPTOR_t *)_RSA_EncryptDataAddress, 5198 #endif // CC_RSA_Encrypt 5199 #if (PAD_LIST) 5200 (COMMAND_DESCRIPTOR_t *)0, 5201 #endif // 5202 #if (PAD_LIST || CC_StartAuthSession) 5203 (COMMAND_DESCRIPTOR_t *)_StartAuthSessionDataAddress, 5204 #endif // CC_StartAuthSession 5205 #if (PAD_LIST || CC_VerifySignature) 5206 (COMMAND_DESCRIPTOR_t *)_VerifySignatureDataAddress, 5207 #endif // CC_VerifySignature 5208 #if (PAD_LIST || CC_ECC_Parameters) 5209 (COMMAND_DESCRIPTOR_t *)_ECC_ParametersDataAddress, 5210 #endif // CC_ECC_Parameters 5211 #if (PAD_LIST || CC_FirmwareRead) 5212 (COMMAND_DESCRIPTOR_t *)_FirmwareReadDataAddress, 5213 #endif // CC_FirmwareRead 5214 #if (PAD_LIST || CC_GetCapability) 5215 (COMMAND_DESCRIPTOR_t *)_GetCapabilityDataAddress, 5216 #endif // CC_GetCapability 5217 #if (PAD_LIST || CC_GetRandom) 5218 (COMMAND_DESCRIPTOR_t *)_GetRandomDataAddress, 5219 #endif // CC_GetRandom 5220 #if (PAD_LIST || CC_GetTestResult) 5221 (COMMAND_DESCRIPTOR_t *)_GetTestResultDataAddress, 5222 #endif // CC_GetTestResult 5223 #if (PAD_LIST || CC_Hash) 5224 (COMMAND_DESCRIPTOR_t *)_HashDataAddress, 5225 #endif // CC_Hash 5226 #if (PAD_LIST || CC_PCR_Read) 5227 (COMMAND_DESCRIPTOR_t *)_PCR_ReadDataAddress, 5228 #endif // CC_PCR_Read 5229 #if (PAD_LIST || CC_PolicyPCR) 5230 (COMMAND_DESCRIPTOR_t *)_PolicyPCRDataAddress, 5231 #endif // CC_PolicyPCR 5232 #if (PAD_LIST || CC_PolicyRestart) 5233 (COMMAND_DESCRIPTOR_t *)_PolicyRestartDataAddress, 5234 #endif // CC_PolicyRestart 5235 #if (PAD_LIST || CC_ReadClock) 5236 (COMMAND_DESCRIPTOR_t *)_ReadClockDataAddress, 5237 #endif // CC_ReadClock 5238 #if (PAD_LIST || CC_PCR_Extend) 5239 (COMMAND_DESCRIPTOR_t *)_PCR_ExtendDataAddress, 5240 #endif // CC_PCR_Extend 5241 #if (PAD_LIST || CC_PCR_SetAuthValue) 5242 (COMMAND_DESCRIPTOR_t *)_PCR_SetAuthValueDataAddress, 5243 #endif // CC_PCR_SetAuthValue 5244 #if (PAD_LIST || CC_NV_Certify) 5245 (COMMAND_DESCRIPTOR_t *)_NV_CertifyDataAddress, 5246 #endif // CC_NV_Certify 5247 #if (PAD_LIST || CC_EventSequenceComplete) 5248 (COMMAND_DESCRIPTOR_t *)_EventSequenceCompleteDataAddress, 5249 #endif // CC_EventSequenceComplete 5250 #if (PAD_LIST || CC_HashSequenceStart) 5251 (COMMAND_DESCRIPTOR_t *)_HashSequenceStartDataAddress, 5252 #endif // CC_HashSequenceStart 5253 #if (PAD_LIST || CC_PolicyPhysicalPresence) 5254 (COMMAND_DESCRIPTOR_t *)_PolicyPhysicalPresenceDataAddress, 5255 #endif // CC_PolicyPhysicalPresence 5256 #if (PAD_LIST || CC_PolicyDuplicationSelect) 5257 (COMMAND_DESCRIPTOR_t *)_PolicyDuplicationSelectDataAddress, 5258 #endif // CC_PolicyDuplicationSelect 5259 #if (PAD_LIST || CC_PolicyGetDigest) 5260 (COMMAND_DESCRIPTOR_t *)_PolicyGetDigestDataAddress, 5261 #endif // CC_PolicyGetDigest 5262 #if (PAD_LIST || CC_TestParms) 5263 (COMMAND_DESCRIPTOR_t *)_TestParmsDataAddress, 5264 #endif // CC_TestParms 5265 #if (PAD_LIST || CC_Commit) 5266 (COMMAND_DESCRIPTOR_t *)_CommitDataAddress, 5267 #endif // CC_Commit 5268 #if (PAD_LIST || CC_PolicyPassword) 5269 (COMMAND_DESCRIPTOR_t *)_PolicyPasswordDataAddress, 5270 #endif // CC_PolicyPassword 5271 #if (PAD_LIST || CC_ZGen_2Phase) 5272 (COMMAND_DESCRIPTOR_t *)_ZGen_2PhaseDataAddress, 5273 #endif // CC_ZGen_2Phase 5274 #if (PAD_LIST || CC_EC_Ephemeral) 5275 (COMMAND_DESCRIPTOR_t *)_EC_EphemeralDataAddress, 5276 #endif // CC_EC_Ephemeral 5277 #if (PAD_LIST || CC_PolicyNvWritten) 5278 (COMMAND_DESCRIPTOR_t *)_PolicyNvWrittenDataAddress, 5279 #endif // CC_PolicyNvWritten 5280 #if (PAD_LIST || CC_PolicyTemplate) 5281 (COMMAND_DESCRIPTOR_t *)_PolicyTemplateDataAddress, 5282 #endif // CC_PolicyTemplate 5283 #if (PAD_LIST || CC_CreateLoaded) 5284 (COMMAND_DESCRIPTOR_t *)_CreateLoadedDataAddress, 5285 #endif // CC_CreateLoaded 5286 #if (PAD_LIST || CC_PolicyAuthorizeNV) 5287 (COMMAND_DESCRIPTOR_t *)_PolicyAuthorizeNVDataAddress, 5288 #endif // CC_PolicyAuthorizeNV 5289 #if (PAD_LIST || CC_EncryptDecrypt2) 5290 (COMMAND_DESCRIPTOR_t *)_EncryptDecrypt2DataAddress, 5291 #endif // CC_EncryptDecrypt2 5292 #if (PAD_LIST || CC_AC_GetCapability) 5293 (COMMAND_DESCRIPTOR_t *)_AC_GetCapabilityDataAddress, 5294 #endif // CC_AC_GetCapability 5295 #if (PAD_LIST || CC_AC_Send) 5296 (COMMAND_DESCRIPTOR_t *)_AC_SendDataAddress, 5297 #endif // CC_AC_Send 5298 #if (PAD_LIST || CC_Policy_AC_SendSelect) 5299 (COMMAND_DESCRIPTOR_t *)_Policy_AC_SendSelectDataAddress, 5300 #endif // CC_Policy_AC_SendSelect 5301 #if (PAD_LIST || CC_CertifyX509) 5302 (COMMAND_DESCRIPTOR_t *)_CertifyX509DataAddress, 5303 #endif // CC_CertifyX509 5304 #if (PAD_LIST || CC_ACT_SetTimeout) 5305 (COMMAND_DESCRIPTOR_t *)_ACT_SetTimeoutDataAddress, 5306 #endif // CC_ACT_SetTimeout 5307 #if (PAD_LIST || CC_ECC_Encrypt) 5308 (COMMAND_DESCRIPTOR_t *)_ECC_EncryptDataAddress, 5309 #endif // CC_ECC_Encrypt 5310 #if (PAD_LIST || CC_ECC_Decrypt) 5311 (COMMAND_DESCRIPTOR_t *)_ECC_DecryptDataAddress, 5312 #endif // CC_ECC_Decrypt 5313 #if (PAD_LIST || CC_Vendor_TCG_Test) 5314 (COMMAND_DESCRIPTOR_t *)_Vendor_TCG_TestDataAddress, 5315 #endif // CC_Vendor_TCG_Test 5316 0 5317 }; 5318 5319 5320 #endif // _COMMAND_TABLE_DISPATCH_ 5321