From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 129A3C4321A for ; Fri, 28 Jun 2019 04:28:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B69B820659 for ; Fri, 28 Jun 2019 04:28:27 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ti.com header.i=@ti.com header.b="a99iszDj" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726716AbfF1E1o (ORCPT ); Fri, 28 Jun 2019 00:27:44 -0400 Received: from lelv0142.ext.ti.com ([198.47.23.249]:58824 "EHLO lelv0142.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726240AbfF1E1l (ORCPT ); Fri, 28 Jun 2019 00:27:41 -0400 Received: from fllv0034.itg.ti.com ([10.64.40.246]) by lelv0142.ext.ti.com (8.15.2/8.15.2) with ESMTP id x5S4RUoR020827; Thu, 27 Jun 2019 23:27:30 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1561696050; bh=FehHwOOdVMctdOago5xa8n5T2ZOnQCMHDR1SFCGPe6U=; h=From:To:CC:Subject:Date:In-Reply-To:References; b=a99iszDjM67s5LcpsnEV5HQzZGo2Awhb7LASw1uJ5Eklo22iBhlFYBYUnCLDjCR/h WOwkFLWU1GSTesWhbD8CV530riWCrDTvITmMjGwBwP+/yspQRQAhr80dm4sDkA0pl5 NKDHDbjAjz4WWqGQjYalGTujg0wZIUccrkAN7oNQ= Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by fllv0034.itg.ti.com (8.15.2/8.15.2) with ESMTPS id x5S4RUYK021516 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Thu, 27 Jun 2019 23:27:30 -0500 Received: from DFLE109.ent.ti.com (10.64.6.30) by DFLE102.ent.ti.com (10.64.6.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1713.5; Thu, 27 Jun 2019 23:27:29 -0500 Received: from fllv0040.itg.ti.com (10.64.41.20) by DFLE109.ent.ti.com (10.64.6.30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1713.5 via Frontend Transport; Thu, 27 Jun 2019 23:27:29 -0500 Received: from a0393675ula.india.ti.com (ileax41-snat.itg.ti.com [10.172.224.153]) by fllv0040.itg.ti.com (8.15.2/8.15.2) with ESMTP id x5S4RKPM062595; Thu, 27 Jun 2019 23:27:27 -0500 From: Keerthy To: , , CC: , , , , , , Subject: [RESEND PATCH 02/10] crypto: sa2ul: Add crypto driver Date: Fri, 28 Jun 2019 09:57:37 +0530 Message-ID: <20190628042745.28455-3-j-keerthy@ti.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190628042745.28455-1-j-keerthy@ti.com> References: <20190628042745.28455-1-j-keerthy@ti.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 Sender: linux-crypto-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org The Security Accelerator (SA2_UL) subsystem provides hardware cryptographic acceleration for the following use cases: • Encryption and authentication for secure boot • Encryption and authentication of content in applications requiring DRM (digital rights management) and content/asset protection The device includes one instantiation of SA2_UL named SA2_UL0 SA2_UL supports the following cryptographic industry standards to enable data authentication, data integrity and data confidentiality. Crypto function library for software acceleration o AES operation o 3DES operation o SHA1 operation o MD5 operation o SHA2 – 224, 256, 384, 512 operation Authentication supported via following hardware cores o SHA1 o MD5 o SHA2 -224 o SHA2-256 o SHA2-384 o SHA2-512 Patch adds a basic crypto driver and currently supports AES in cbc mode for both encryption and decryption. Signed-off-by: Keerthy --- drivers/crypto/Kconfig | 17 + drivers/crypto/Makefile | 1 + drivers/crypto/sa2ul.c | 1151 +++++++++++++++++++++++++++++++++++++++ drivers/crypto/sa2ul.h | 384 +++++++++++++ 4 files changed, 1553 insertions(+) create mode 100644 drivers/crypto/sa2ul.c create mode 100644 drivers/crypto/sa2ul.h diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig index 603413f28fa3..b9a3fa026c74 100644 --- a/drivers/crypto/Kconfig +++ b/drivers/crypto/Kconfig @@ -785,4 +785,21 @@ config CRYPTO_DEV_CCREE source "drivers/crypto/hisilicon/Kconfig" +config CRYPTO_DEV_SA2UL + tristate "Support for TI security accelerator" + depends on ARCH_K3 || COMPILE_TEST + select ARM64_CRYPTO + select CRYPTO_AES + select CRYPTO_AES_ARM64 + select CRYPTO_SHA1 + select CRYPTO_MD5 + select CRYPTO_ALGAPI + select CRYPTO_AUTHENC + select HW_RANDOM + default m if ARCH_K3 + help + Keystone devices include a security accelerator engine that may be + used for crypto offload. Select this if you want to use hardware + acceleration for cryptographic algorithms on these devices. + endif # CRYPTO_HW diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile index afc4753b5d28..300d31fd24db 100644 --- a/drivers/crypto/Makefile +++ b/drivers/crypto/Makefile @@ -47,4 +47,5 @@ obj-$(CONFIG_CRYPTO_DEV_VMX) += vmx/ obj-$(CONFIG_CRYPTO_DEV_BCM_SPU) += bcm/ obj-$(CONFIG_CRYPTO_DEV_SAFEXCEL) += inside-secure/ obj-$(CONFIG_CRYPTO_DEV_ARTPEC6) += axis/ +obj-$(CONFIG_CRYPTO_DEV_SA2UL) += sa2ul.o obj-y += hisilicon/ diff --git a/drivers/crypto/sa2ul.c b/drivers/crypto/sa2ul.c new file mode 100644 index 000000000000..64bdf6b2b879 --- /dev/null +++ b/drivers/crypto/sa2ul.c @@ -0,0 +1,1151 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * AM6 SA2UL crypto accelerator driver + * + * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com + * + * Authors: Keerthy + * Vitaly Andrianov + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "sa2ul.h" + +/* Byte offset for key in encryption security context */ +#define SC_ENC_KEY_OFFSET (1 + 27 + 4) +/* Byte offset for Aux-1 in encryption security context */ +#define SC_ENC_AUX1_OFFSET (1 + 27 + 4 + 32) + +#define SA_CMDL_UPD_ENC 0x0001 +#define SA_CMDL_UPD_AUTH 0x0002 +#define SA_CMDL_UPD_ENC_IV 0x0004 +#define SA_CMDL_UPD_AUTH_IV 0x0008 +#define SA_CMDL_UPD_AUX_KEY 0x0010 + +#define SA_AUTH_SUBKEY_LEN 16 +#define SA_CMDL_PAYLOAD_LENGTH_MASK 0xFFFF +#define SA_CMDL_SOP_BYPASS_LEN_MASK 0xFF000000 + +#define MODE_CONTROL_BYTES 27 +#define SA_HASH_PROCESSING 0 +#define SA_CRYPTO_PROCESSING 0 +#define SA_UPLOAD_HASH_TO_TLR BIT(6) + +#define SA_SW0_FLAGS_MASK 0xF0000 +#define SA_SW0_CMDL_INFO_MASK 0x1F00000 +#define SA_SW0_CMDL_PRESENT BIT(4) +#define SA_SW0_ENG_ID_MASK 0x3E000000 +#define SA_SW0_DEST_INFO_PRESENT BIT(30) +#define SA_SW2_EGRESS_LENGTH 0xFF000000 + +#define SHA256_DIGEST_WORDS 8 +/* Make 32-bit word from 4 bytes */ +#define SA_MK_U32(b0, b1, b2, b3) (((b0) << 24) | ((b1) << 16) | \ + ((b2) << 8) | (b3)) + +/* size of SCCTL structure in bytes */ +#define SA_SCCTL_SZ 16 + +/* Max Authentication tag size */ +#define SA_MAX_AUTH_TAG_SZ 64 + +#define PRIV_ID 0x1 +#define PRIV 0x1 + +static struct device *sa_k3_dev; + +/** + * struct sa_cmdl_cfg - Command label configuration descriptor + * @enc1st: If the iteration needs encryption before authentication + * @aalg: authentication algorithm ID + * @enc_eng_id: Encryption Engine ID supported by the SA hardware + * @auth_eng_id: authentication Engine ID + * @iv_size: Initialization Vector size + * @akey: Authentication key + * @akey_len: Authentication key length + */ +struct sa_cmdl_cfg { + int enc1st; + int aalg; + u8 enc_eng_id; + u8 auth_eng_id; + u8 iv_size; + const u8 *akey; + u16 akey_len; + u16 auth_subkey_len; +}; + +/** + * struct algo_data - Crypto algorithm specific data + * @enc_eng: Encryption engine info structure + * @auth_eng: Authentication engine info structure + * @auth_ctrl: Authentication control word + * @hash_size: Size of Digest + * @ealg_id: Encryption Algorithm ID + * @aalg_id: Authentication algorithm ID + * @mci_enc: Mode Control Instruction for Encryption algorithm + * @mci_dec: Mode Control Instruction for Decryption + * @inv_key: Whether the encryption algorithm demands key inversion + * @keyed_mac: Whether the Authentication algorithm has Key + * @prep_iopad: Function pointer to generate intermediate ipad/opad + */ +struct algo_data { + struct sa_eng_info enc_eng; + struct sa_eng_info auth_eng; + u8 auth_ctrl; + u8 hash_size; + u8 ealg_id; + u8 aalg_id; + u8 *mci_enc; + u8 *mci_dec; + bool inv_key; + bool keyed_mac; + void (*prep_iopad)(const u8 *key, u16 key_sz, u32 *ipad, u32 *opad); +}; + +/** + * struct sa_alg_tmpl: A generic template encompassing crypto/aead algorithms + * @alg: A union of aead/crypto algorithm type. + * @registered: Flag indicating if the crypto algorithm is already registered + */ +struct sa_alg_tmpl { + u32 type; /* CRYPTO_ALG_TYPE from */ + union { + struct crypto_alg crypto; + struct aead_alg aead; + } alg; + int registered; +}; + +/** + * struct sa_rx_data: RX Packet miscellaneous data place holder + * @req: crypto request data pointer + * @ddev: DMA device pointer + * @tx_in: dma_async_tx_descriptor pointer for rx channel + * @enc: Flag indicating either encryption or decryption + */ +struct sa_rx_data { + void *req; + struct device *ddev; + struct dma_async_tx_descriptor *tx_in; + u8 enc; +}; + +/* + * Mode Control Instructions for various Key lengths 128, 192, 256 + * For CBC (Cipher Block Chaining) mode for encryption + */ +static u8 mci_cbc_enc_array[3][MODE_CONTROL_BYTES] = { + { 0x21, 0x00, 0x00, 0x18, 0x88, 0x0a, 0xaa, 0x4b, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + { 0x21, 0x00, 0x00, 0x18, 0x88, 0x4a, 0xaa, 0x4b, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + { 0x21, 0x00, 0x00, 0x18, 0x88, 0x8a, 0xaa, 0x4b, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, +}; + +/* + * Mode Control Instructions for various Key lengths 128, 192, 256 + * For CBC (Cipher Block Chaining) mode for decryption + */ +static u8 mci_cbc_dec_array[3][MODE_CONTROL_BYTES] = { + { 0x31, 0x00, 0x00, 0x80, 0x8a, 0xca, 0x98, 0xf4, 0x40, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + { 0x31, 0x00, 0x00, 0x84, 0x8a, 0xca, 0x98, 0xf4, 0x40, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + { 0x31, 0x00, 0x00, 0x88, 0x8a, 0xca, 0x98, 0xf4, 0x40, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, +}; + +/* + * Perform 16 byte or 128 bit swizzling + * The SA2UL Expects the security context to + * be in little Endian and the bus width is 128 bits or 16 bytes + * Hence swap 16 bytes at a time from higher to lower address + */ +static void sa_swiz_128(u8 *in, u16 len) +{ + u8 data[16]; + int i, j; + + for (i = 0; i < len; i += 16) { + memcpy(data, &in[i], 16); + for (j = 0; j < 16; j++) + in[i + j] = data[15 - j]; + } +} + +/* Derive the inverse key used in AES-CBC decryption operation */ +static inline int sa_aes_inv_key(u8 *inv_key, const u8 *key, u16 key_sz) +{ + struct crypto_aes_ctx ctx; + int key_pos; + + if (crypto_aes_expand_key(&ctx, key, key_sz)) { + pr_err("%s: bad key len(%d)\n", __func__, key_sz); + return -EINVAL; + } + + /* Based crypto_aes_expand_key logic */ + switch (key_sz) { + case AES_KEYSIZE_128: + case AES_KEYSIZE_192: + key_pos = key_sz + 24; + break; + + case AES_KEYSIZE_256: + key_pos = key_sz + 24 - 4; + break; + + default: + pr_err("%s: bad key len(%d)\n", __func__, key_sz); + return -EINVAL; + } + + memcpy(inv_key, &ctx.key_enc[key_pos], key_sz); + return 0; +} + +/* Set Security context for the encryption engine */ +static int sa_set_sc_enc(struct algo_data *ad, const u8 *key, u16 key_sz, + u16 aad_len, u8 enc, u8 *sc_buf) +{ + const u8 *mci = NULL; + + /* Set Encryption mode selector to crypto processing */ + sc_buf[0] = SA_CRYPTO_PROCESSING; + + if (enc) + mci = ad->mci_enc; + else + mci = ad->mci_dec; + /* Set the mode control instructions in security context */ + if (mci) + memcpy(&sc_buf[1], mci, MODE_CONTROL_BYTES); + + /* For AES-CBC decryption get the inverse key */ + if (ad->inv_key && !enc) { + if (sa_aes_inv_key(&sc_buf[SC_ENC_KEY_OFFSET], key, key_sz)) + return -EINVAL; + /* For all other cases: key is used */ + } else { + memcpy(&sc_buf[SC_ENC_KEY_OFFSET], key, key_sz); + } + + return 0; +} + +/* Set Security context for the authentication engine */ +static void sa_set_sc_auth(struct algo_data *ad, const u8 *key, u16 key_sz, + u8 *sc_buf) +{ + u32 ipad[64], opad[64]; + + /* Set Authentication mode selector to hash processing */ + sc_buf[0] = SA_HASH_PROCESSING; + /* Auth SW ctrl word: bit[6]=1 (upload computed hash to TLR section) */ + sc_buf[1] = SA_UPLOAD_HASH_TO_TLR; + sc_buf[1] |= ad->auth_ctrl; + + /* Copy the keys or ipad/opad */ + if (ad->keyed_mac) { + ad->prep_iopad(key, key_sz, ipad, opad); + /* Copy ipad to AuthKey */ + memcpy(&sc_buf[32], ipad, ad->hash_size); + /* Copy opad to Aux-1 */ + memcpy(&sc_buf[64], opad, ad->hash_size); + } +} + +static inline void sa_copy_iv(u32 *out, const u8 *iv, bool size16) +{ + int j; + + for (j = 0; j < ((size16) ? 4 : 2); j++) { + *out = cpu_to_be32(*((u32 *)iv)); + iv += 4; + out++; + } +} + +/* Format general command label */ +static int sa_format_cmdl_gen(struct sa_cmdl_cfg *cfg, u8 *cmdl, + struct sa_cmdl_upd_info *upd_info) +{ + u8 enc_offset = 0, auth_offset = 0, total = 0; + u8 enc_next_eng = SA_ENG_ID_OUTPORT2; + u8 auth_next_eng = SA_ENG_ID_OUTPORT2; + u32 *word_ptr = (u32 *)cmdl; + int i; + + /* Clear the command label */ + memzero_explicit(cmdl, (SA_MAX_CMDL_WORDS * sizeof(u32))); + + /* Iniialize the command update structure */ + memzero_explicit(upd_info, sizeof(*upd_info)); + + if (cfg->enc1st) { + if (cfg->enc_eng_id != SA_ENG_ID_NONE) + auth_offset = SA_CMDL_HEADER_SIZE_BYTES; + + if (cfg->iv_size) + auth_offset += cfg->iv_size; + + if (cfg->auth_eng_id != SA_ENG_ID_NONE) + enc_next_eng = cfg->auth_eng_id; + else + enc_next_eng = SA_ENG_ID_OUTPORT2; + } else { + if (cfg->auth_eng_id != SA_ENG_ID_NONE) + enc_offset = SA_CMDL_HEADER_SIZE_BYTES; + + if (cfg->auth_subkey_len) + enc_offset += cfg->auth_subkey_len; + + if (cfg->enc_eng_id != SA_ENG_ID_NONE) + auth_next_eng = cfg->enc_eng_id; + else + auth_next_eng = SA_ENG_ID_OUTPORT2; + } + + if (cfg->enc_eng_id != SA_ENG_ID_NONE) { + upd_info->flags |= SA_CMDL_UPD_ENC; + upd_info->enc_size.index = enc_offset >> 2; + upd_info->enc_offset.index = upd_info->enc_size.index + 1; + /* Encryption command label */ + cmdl[enc_offset + SA_CMDL_OFFSET_NESC] = enc_next_eng; + + /* Encryption modes requiring IV */ + if (cfg->iv_size) { + upd_info->flags |= SA_CMDL_UPD_ENC_IV; + upd_info->enc_iv.index = + (enc_offset + SA_CMDL_HEADER_SIZE_BYTES) >> 2; + upd_info->enc_iv.size = cfg->iv_size; + + cmdl[enc_offset + SA_CMDL_OFFSET_LABEL_LEN] = + SA_CMDL_HEADER_SIZE_BYTES + cfg->iv_size; + + cmdl[enc_offset + SA_CMDL_OFFSET_OPTION_CTRL1] = + (SA_CTX_ENC_AUX2_OFFSET | (cfg->iv_size >> 3)); + enc_offset += SA_CMDL_HEADER_SIZE_BYTES + cfg->iv_size; + } else { + cmdl[enc_offset + SA_CMDL_OFFSET_LABEL_LEN] = + SA_CMDL_HEADER_SIZE_BYTES; + enc_offset += SA_CMDL_HEADER_SIZE_BYTES; + } + } + + if (cfg->auth_eng_id != SA_ENG_ID_NONE) { + upd_info->flags |= SA_CMDL_UPD_AUTH; + upd_info->auth_size.index = auth_offset >> 2; + upd_info->auth_offset.index = upd_info->auth_size.index + 1; + cmdl[auth_offset + SA_CMDL_OFFSET_NESC] = auth_next_eng; + + /* Algorithm with subkeys */ + if (cfg->aalg == SA_AALG_ID_AES_XCBC || + cfg->aalg == SA_AALG_ID_CMAC) { + upd_info->flags |= SA_CMDL_UPD_AUX_KEY; + upd_info->aux_key_info.index = + (auth_offset + SA_CMDL_HEADER_SIZE_BYTES) >> 2; + cmdl[auth_offset + SA_CMDL_OFFSET_LABEL_LEN] = + SA_CMDL_HEADER_SIZE_BYTES + + cfg->auth_subkey_len; + cmdl[auth_offset + SA_CMDL_OFFSET_OPTION_CTRL1] = + (SA_CTX_ENC_AUX1_OFFSET | + (cfg->auth_subkey_len >> 3)); + + auth_offset += SA_CMDL_HEADER_SIZE_BYTES + + cfg->auth_subkey_len; + } else { + cmdl[auth_offset + SA_CMDL_OFFSET_LABEL_LEN] = + SA_CMDL_HEADER_SIZE_BYTES; + auth_offset += SA_CMDL_HEADER_SIZE_BYTES; + } + } + + if (cfg->enc1st) + total = auth_offset; + else + total = enc_offset; + + total = roundup(total, 8); + + for (i = 0; i < total / 4; i++) + word_ptr[i] = be32_to_cpu(word_ptr[i]); + + return total; +} + +/* Update Command label */ +static inline void +sa_update_cmdl(struct device *dev, u8 enc_offset, u16 enc_size, u8 *enc_iv, + u8 auth_offset, u16 auth_size, u8 *auth_iv, u8 aad_size, + u8 *aad, struct sa_cmdl_upd_info *upd_info, u32 *cmdl) +{ + int i = 0, j; + + if (upd_info->submode != SA_MODE_GEN) { + dev_err(dev, "unsupported mode(%d)\n", upd_info->submode); + return; + } + + if (likely(upd_info->flags & SA_CMDL_UPD_ENC)) { + cmdl[upd_info->enc_size.index] &= ~SA_CMDL_PAYLOAD_LENGTH_MASK; + cmdl[upd_info->enc_size.index] |= enc_size; + cmdl[upd_info->enc_offset.index] &= + ~SA_CMDL_SOP_BYPASS_LEN_MASK; + cmdl[upd_info->enc_offset.index] |= + ((u32)enc_offset << __ffs(SA_CMDL_SOP_BYPASS_LEN_MASK)); + + if (likely(upd_info->flags & SA_CMDL_UPD_ENC_IV)) { + u32 *data = &cmdl[upd_info->enc_iv.index]; + + for (j = 0; i < upd_info->enc_iv.size; i += 4, j++) { + data[j] = cpu_to_be32(*((u32 *)enc_iv)); + enc_iv += 4; + } + } + } + + if (likely(upd_info->flags & SA_CMDL_UPD_AUTH)) { + cmdl[upd_info->auth_size.index] &= ~SA_CMDL_PAYLOAD_LENGTH_MASK; + cmdl[upd_info->auth_size.index] |= auth_size; + cmdl[upd_info->auth_offset.index] &= + ~SA_CMDL_SOP_BYPASS_LEN_MASK; + cmdl[upd_info->auth_offset.index] |= ((u32)auth_offset << + __ffs(SA_CMDL_SOP_BYPASS_LEN_MASK)); + if (upd_info->flags & SA_CMDL_UPD_AUTH_IV) { + sa_copy_iv(&cmdl[upd_info->auth_iv.index], auth_iv, + (upd_info->auth_iv.size > 8)); + } + + if (upd_info->flags & SA_CMDL_UPD_AUX_KEY) { + int offset = (auth_size & 0xF) ? 4 : 0; + + memcpy(&cmdl[upd_info->aux_key_info.index], + &upd_info->aux_key[offset], 16); + } + } +} + +/* Format SWINFO words to be sent to SA */ +static +void sa_set_swinfo(u8 eng_id, u16 sc_id, dma_addr_t sc_phys, + u8 cmdl_present, u8 cmdl_offset, u8 flags, + u8 hash_size, u32 *swinfo) +{ + swinfo[0] = sc_id; + swinfo[0] |= (flags << __ffs(SA_SW0_FLAGS_MASK)); + if (likely(cmdl_present)) + swinfo[0] |= ((cmdl_offset | SA_SW0_CMDL_PRESENT) << + __ffs(SA_SW0_CMDL_INFO_MASK)); + swinfo[0] |= (eng_id << __ffs(SA_SW0_ENG_ID_MASK)); + + swinfo[0] |= SA_SW0_DEST_INFO_PRESENT; + swinfo[1] = (u32)(sc_phys & 0xFFFFFFFFULL); + swinfo[2] = (u32)((sc_phys & 0xFFFFFFFF00000000ULL) >> 32); + swinfo[2] |= (hash_size << __ffs(SA_SW2_EGRESS_LENGTH)); +} + +/* Dump the security context */ +static void sa_dump_sc(u8 *buf, dma_addr_t dma_addr) +{ +#ifdef DEBUG + dev_info(sa_k3_dev, "Security context dump:: 0x%pad\n", &dma_addr); + print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, + 16, 1, buf, SA_CTX_MAX_SZ, false); +#endif +} + +static +int sa_init_sc(struct sa_ctx_info *ctx, const u8 *enc_key, + u16 enc_key_sz, const u8 *auth_key, u16 auth_key_sz, + struct algo_data *ad, u8 enc, u32 *swinfo, bool auth_req) +{ + int use_enc = 0; + int enc_sc_offset, auth_sc_offset; + u8 *sc_buf = ctx->sc; + u16 sc_id = ctx->sc_id; + u16 aad_len = 0; /* Currently not supporting AEAD algo */ + u8 first_engine; + + memzero_explicit(sc_buf, SA_CTX_MAX_SZ); + + if (ad->auth_eng.eng_id <= SA_ENG_ID_EM2 || !auth_req) + use_enc = 1; + + /* Determine the order of encryption & Authentication contexts */ + if (enc || !use_enc) { + if (auth_req) { + enc_sc_offset = SA_CTX_PHP_PE_CTX_SZ; + auth_sc_offset = enc_sc_offset + ad->enc_eng.sc_size; + } else { + enc_sc_offset = SA_CTX_PHP_PE_CTX_SZ; + } + } else { + auth_sc_offset = SA_CTX_PHP_PE_CTX_SZ; + enc_sc_offset = auth_sc_offset + ad->auth_eng.sc_size; + } + + /* SCCTL Owner info: 0=host, 1=CP_ACE */ + sc_buf[SA_CTX_SCCTL_OWNER_OFFSET] = 0; + /* SCCTL F/E control */ + if (auth_req) + sc_buf[1] = SA_SCCTL_FE_AUTH_ENC; + else + sc_buf[1] = SA_SCCTL_FE_ENC; + memcpy(&sc_buf[2], &sc_id, 2); + sc_buf[4] = 0x0; + sc_buf[5] = PRIV_ID; + sc_buf[6] = PRIV; + sc_buf[7] = 0x0; + + /* Initialize the rest of PHP context */ + memzero_explicit(sc_buf + SA_SCCTL_SZ, SA_CTX_PHP_PE_CTX_SZ - + SA_SCCTL_SZ); + + /* Prepare context for encryption engine */ + if (ad->enc_eng.sc_size) { + if (sa_set_sc_enc(ad, enc_key, enc_key_sz, aad_len, + enc, &sc_buf[enc_sc_offset])) + return -EINVAL; + } + + /* Prepare context for authentication engine */ + if (ad->auth_eng.sc_size) { + if (use_enc) { + if (sa_set_sc_enc(ad, auth_key, auth_key_sz, + aad_len, 0, &sc_buf[auth_sc_offset])) + return -EINVAL; + } else { + sa_set_sc_auth(ad, auth_key, auth_key_sz, + &sc_buf[auth_sc_offset]); + } + } + + /* Set the ownership of context to CP_ACE */ + sc_buf[SA_CTX_SCCTL_OWNER_OFFSET] = 0x80; + + /* swizzle the security context */ + sa_swiz_128(sc_buf, SA_CTX_MAX_SZ); + /* Setup SWINFO */ + if (!auth_req) + first_engine = ad->enc_eng.eng_id; + else + first_engine = enc ? ad->enc_eng.eng_id : ad->auth_eng.eng_id; + + if (auth_req) { + if (!ad->hash_size) + return -EINVAL; + /* Round up the tag size to multiple of 4 */ + ad->hash_size = roundup(ad->hash_size, 8); + } + + sa_set_swinfo(first_engine, ctx->sc_id, ctx->sc_phys, 1, 0, + SA_SW_INFO_FLAG_EVICT, ad->hash_size, swinfo); + + sa_dump_sc(sc_buf, ctx->sc_phys); + + return 0; +} + +/* Free the per direction context memory */ +static void sa_free_ctx_info(struct sa_ctx_info *ctx, + struct sa_crypto_data *data) +{ + unsigned long bn; + + bn = ctx->sc_id - data->sc_id_start; + spin_lock(&data->scid_lock); + __clear_bit(bn, data->ctx_bm); + data->sc_id--; + spin_unlock(&data->scid_lock); + + if (ctx->sc) { + dma_pool_free(data->sc_pool, ctx->sc, ctx->sc_phys); + ctx->sc = NULL; + } +} + +static int sa_init_ctx_info(struct sa_ctx_info *ctx, + struct sa_crypto_data *data) +{ + unsigned long bn; + int err; + + spin_lock(&data->scid_lock); + bn = find_first_zero_bit(data->ctx_bm, SA_MAX_NUM_CTX); + __set_bit(bn, data->ctx_bm); + data->sc_id++; + spin_unlock(&data->scid_lock); + + ctx->sc_id = (u16)(data->sc_id_start + bn); + + ctx->sc = dma_pool_alloc(data->sc_pool, GFP_KERNEL, &ctx->sc_phys); + if (!ctx->sc) { + dev_err(&data->pdev->dev, "Failed to allocate SC memory\n"); + err = -ENOMEM; + goto scid_rollback; + } + + return 0; + +scid_rollback: + spin_lock(&data->scid_lock); + __clear_bit(bn, data->ctx_bm); + data->sc_id--; + spin_unlock(&data->scid_lock); + + return err; +} + +static void sa_aes_cra_exit(struct crypto_tfm *tfm) +{ + struct crypto_alg *alg = tfm->__crt_alg; + struct sa_tfm_ctx *ctx = crypto_tfm_ctx(tfm); + struct sa_crypto_data *data = dev_get_drvdata(sa_k3_dev); + + dev_dbg(sa_k3_dev, "%s(0x%p) sc-ids(0x%x(0x%pad), 0x%x(0x%pad))\n", + __func__, tfm, ctx->enc.sc_id, &ctx->enc.sc_phys, + ctx->dec.sc_id, &ctx->dec.sc_phys); + + if ((alg->cra_flags & CRYPTO_ALG_TYPE_ABLKCIPHER) + == CRYPTO_ALG_TYPE_ABLKCIPHER) { + sa_free_ctx_info(&ctx->enc, data); + sa_free_ctx_info(&ctx->dec, data); + } +} + +static int sa_aes_cra_init(struct crypto_tfm *tfm) +{ + struct sa_tfm_ctx *ctx = crypto_tfm_ctx(tfm); + struct crypto_alg *alg = tfm->__crt_alg; + struct sa_crypto_data *data = dev_get_drvdata(sa_k3_dev); + int ret; + + if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == + CRYPTO_ALG_TYPE_ABLKCIPHER) { + memzero_explicit(ctx, sizeof(*ctx)); + ctx->dev_data = data; + + ret = sa_init_ctx_info(&ctx->enc, data); + if (ret) + return ret; + ret = sa_init_ctx_info(&ctx->dec, data); + if (ret) { + sa_free_ctx_info(&ctx->enc, data); + return ret; + } + } + + dev_dbg(sa_k3_dev, "%s(0x%p) sc-ids(0x%x(0x%pad), 0x%x(0x%pad))\n", + __func__, tfm, ctx->enc.sc_id, &ctx->enc.sc_phys, + ctx->dec.sc_id, &ctx->dec.sc_phys); + return 0; +} + +static int sa_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, + unsigned int keylen, struct algo_data *ad) +{ + struct sa_tfm_ctx *ctx = crypto_ablkcipher_ctx(tfm); + + const char *cra_name; + int cmdl_len; + struct sa_cmdl_cfg cfg; + + if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 && + keylen != AES_KEYSIZE_256) + return -EINVAL; + + cra_name = crypto_tfm_alg_name(&tfm->base); + + memzero_explicit(&cfg, sizeof(cfg)); + cfg.enc1st = 1; + cfg.enc_eng_id = ad->enc_eng.eng_id; + cfg.iv_size = crypto_ablkcipher_ivsize(tfm); + cfg.auth_eng_id = SA_ENG_ID_NONE; + cfg.auth_subkey_len = 0; + + /* Setup Encryption Security Context & Command label template */ + if (sa_init_sc(&ctx->enc, key, keylen, + NULL, 0, ad, 1, &ctx->enc.epib[1], false)) + goto badkey; + + cmdl_len = sa_format_cmdl_gen(&cfg, + (u8 *)ctx->enc.cmdl, + &ctx->enc.cmdl_upd_info); + if (cmdl_len <= 0 || (cmdl_len > SA_MAX_CMDL_WORDS * sizeof(u32))) + goto badkey; + + ctx->enc.cmdl_size = cmdl_len; + + /* Setup Decryption Security Context & Command label template */ + if (sa_init_sc(&ctx->dec, key, keylen, + NULL, 0, ad, 0, &ctx->dec.epib[1], false)) + goto badkey; + + cfg.enc1st = 0; + cfg.enc_eng_id = ad->enc_eng.eng_id; + cfg.auth_eng_id = SA_ENG_ID_NONE; + cfg.auth_subkey_len = 0; + cmdl_len = sa_format_cmdl_gen(&cfg, (u8 *)ctx->dec.cmdl, + &ctx->dec.cmdl_upd_info); + + if (cmdl_len <= 0 || (cmdl_len > SA_MAX_CMDL_WORDS * sizeof(u32))) + goto badkey; + + ctx->dec.cmdl_size = cmdl_len; + + kfree(ad); + + return 0; + +badkey: + dev_err(sa_k3_dev, "%s: badkey\n", __func__); + return -EINVAL; +} + +static int sa_aes_cbc_setkey(struct crypto_ablkcipher *tfm, const u8 *key, + unsigned int keylen) +{ + struct algo_data *ad = kzalloc(sizeof(*ad), GFP_KERNEL); + /* Convert the key size (16/24/32) to the key size index (0/1/2) */ + int key_idx = (keylen >> 3) - 2; + + ad->enc_eng.eng_id = SA_ENG_ID_EM1; + ad->enc_eng.sc_size = SA_CTX_ENC_TYPE1_SZ; + ad->auth_eng.eng_id = SA_ENG_ID_NONE; + ad->auth_eng.sc_size = 0; + ad->mci_enc = mci_cbc_enc_array[key_idx]; + ad->mci_dec = mci_cbc_dec_array[key_idx]; + ad->inv_key = true; + ad->ealg_id = SA_EALG_ID_AES_CBC; + ad->aalg_id = SA_AALG_ID_NONE; + + return sa_aes_setkey(tfm, key, keylen, ad); +} + +static void sa_aes_dma_in_callback(void *data) +{ + struct sa_rx_data *rxd = (struct sa_rx_data *)data; + struct ablkcipher_request *req = (struct ablkcipher_request *)rxd->req; + + int sglen = sg_nents_for_len(req->dst, req->nbytes); + + kfree(rxd); + + dma_unmap_sg(sa_k3_dev, req->src, sglen, DMA_TO_DEVICE); + if (req->src != req->dst) + dma_unmap_sg(rxd->ddev, req->dst, sglen, DMA_FROM_DEVICE); + + ablkcipher_request_complete(req, 0); +} + +static void +sa_prepare_tx_desc(u32 *mdptr, u32 pslen, u32 *psdata, u32 epiblen, u32 *epib) +{ + u32 *out, *in; + int i; + + for (out = mdptr, in = epib, i = 0; i < epiblen / sizeof(u32); i++) + *out++ = *in++; + + mdptr[4] = (0xFFFF << 16); + for (out = &mdptr[5], in = psdata, i = 0; + i < pslen / sizeof(u32); i++) + *out++ = *in++; +} + +static int sa_aes_run(struct ablkcipher_request *req, u8 *iv, int enc) +{ + struct sa_tfm_ctx *ctx = + crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req)); + struct sa_ctx_info *sa_ctx = enc ? &ctx->enc : &ctx->dec; + struct sa_crypto_data *pdata = dev_get_drvdata(sa_k3_dev); + struct sa_dma_req_ctx req_ctx; + struct dma_async_tx_descriptor *tx_in, *tx_out; + struct sa_rx_data *rxd; + u8 enc_offset; + int sg_nents, dst_nents; + int psdata_offset; + u8 auth_offset = 0; + u8 *auth_iv = NULL; + u8 *aad = NULL; + u8 aad_len = 0; + u16 enc_len; + u16 auth_len = 0; + u32 req_type; + u32 *mdptr; + size_t pl, ml; + + struct device *ddev; + struct dma_chan *dma_rx; + gfp_t flags; + + flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? + GFP_KERNEL : GFP_ATOMIC; + + enc_offset = 0x0; + enc_len = req->nbytes; + + if (enc_len >= 256) + dma_rx = pdata->dma_rx2; + else + dma_rx = pdata->dma_rx1; + + /* Allocate descriptor & submit packet */ + sg_nents = sg_nents_for_len(req->src, enc_len); + dst_nents = sg_nents_for_len(req->dst, enc_len); + + memcpy(req_ctx.cmdl, sa_ctx->cmdl, sa_ctx->cmdl_size); + + /* Update Command Label */ + sa_update_cmdl(sa_k3_dev, enc_offset, enc_len, + iv, auth_offset, auth_len, + auth_iv, aad_len, aad, + &sa_ctx->cmdl_upd_info, req_ctx.cmdl); + + /* + * Last 2 words in PSDATA will have the crypto alg type & + * crypto request pointer + */ + req_type = CRYPTO_ALG_TYPE_ABLKCIPHER; + if (enc) + req_type |= (SA_REQ_SUBTYPE_ENC << SA_REQ_SUBTYPE_SHIFT); + else + req_type |= (SA_REQ_SUBTYPE_DEC << SA_REQ_SUBTYPE_SHIFT); + + psdata_offset = sa_ctx->cmdl_size / sizeof(u32); + req_ctx.cmdl[psdata_offset++] = req_type; + + ddev = dma_rx->device->dev; + /* map the packet */ + req_ctx.src = req->src; + req_ctx.src_nents = dma_map_sg(sa_k3_dev, req->src, sg_nents, + DMA_TO_DEVICE); + if (req->src != req->dst) + dst_nents = dma_map_sg(ddev, req->dst, sg_nents, + DMA_FROM_DEVICE); + else + dst_nents = req_ctx.src_nents; + + if (unlikely(req_ctx.src_nents != sg_nents)) { + dev_warn_ratelimited(sa_k3_dev, "failed to map tx pkt\n"); + return -EIO; + } + + req_ctx.dev_data = pdata; + req_ctx.pkt = true; + + dma_sync_sg_for_device(pdata->dev, req->src, req_ctx.src_nents, + DMA_TO_DEVICE); + + tx_in = dmaengine_prep_slave_sg(dma_rx, req->dst, dst_nents, + DMA_DEV_TO_MEM, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + if (!tx_in) { + dev_err(pdata->dev, "IN prep_slave_sg() failed\n"); + return -EINVAL; + } + + rxd = kzalloc(sizeof(*rxd), GFP_KERNEL); + rxd->req = (void *)req; + rxd->ddev = ddev; + + /* IN */ + tx_in->callback = sa_aes_dma_in_callback; + tx_in->callback_param = rxd; + + tx_out = dmaengine_prep_slave_sg(pdata->dma_tx, req->src, + req_ctx.src_nents, DMA_MEM_TO_DEV, + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); + if (!tx_out) { + dev_err(pdata->dev, "OUT prep_slave_sg() failed\n"); + return -EINVAL; + } + + mdptr = (u32 *)dmaengine_desc_get_metadata_ptr(tx_out, &pl, &ml); + + sa_prepare_tx_desc(mdptr, (sa_ctx->cmdl_size + (SA_PSDATA_CTX_WORDS * + sizeof(u32))), req_ctx.cmdl, + sizeof(sa_ctx->epib), sa_ctx->epib); + + ml = sa_ctx->cmdl_size + (SA_PSDATA_CTX_WORDS * sizeof(u32)); + dmaengine_desc_set_metadata_len(tx_out, 44); + + dmaengine_submit(tx_out); + dmaengine_submit(tx_in); + + dma_async_issue_pending(dma_rx); + dma_async_issue_pending(pdata->dma_tx); + + return -EINPROGRESS; +} + +static int sa_aes_cbc_encrypt(struct ablkcipher_request *req) +{ + return sa_aes_run(req, req->info, 1); +} + +static int sa_aes_cbc_decrypt(struct ablkcipher_request *req) +{ + return sa_aes_run(req, req->info, 0); +} + +static struct sa_alg_tmpl sa_algs[] = { + {.type = CRYPTO_ALG_TYPE_ABLKCIPHER, + .alg.crypto = { + .cra_name = "cbc(aes)", + .cra_driver_name = "cbc-aes-sa2ul", + .cra_priority = 30000, + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | + CRYPTO_ALG_KERN_DRIVER_ONLY | + CRYPTO_ALG_ASYNC | + CRYPTO_ALG_NEED_FALLBACK, + .cra_blocksize = AES_BLOCK_SIZE, + .cra_ctxsize = sizeof(struct sa_tfm_ctx), + .cra_alignmask = 0, + .cra_type = &crypto_ablkcipher_type, + .cra_module = THIS_MODULE, + .cra_init = sa_aes_cra_init, + .cra_exit = sa_aes_cra_exit, + .cra_u.ablkcipher = { + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = sa_aes_cbc_setkey, + .encrypt = sa_aes_cbc_encrypt, + .decrypt = sa_aes_cbc_decrypt, + } + } + }, +}; + +/* Register the algorithms in crypto framework */ +void sa_register_algos(const struct device *dev) +{ + char *alg_name; + u32 type; + int i, err, num_algs = ARRAY_SIZE(sa_algs); + + for (i = 0; i < num_algs; i++) { + type = sa_algs[i].type; + if (type == CRYPTO_ALG_TYPE_AEAD) { + alg_name = sa_algs[i].alg.aead.base.cra_name; + err = crypto_register_aead(&sa_algs[i].alg.aead); + } else if (type == CRYPTO_ALG_TYPE_ABLKCIPHER) { + alg_name = sa_algs[i].alg.crypto.cra_name; + err = crypto_register_alg(&sa_algs[i].alg.crypto); + } else { + dev_err(dev, + "un-supported crypto algorithm (%d)", + sa_algs[i].type); + continue; + } + + if (err) + dev_err(dev, "Failed to register '%s'\n", alg_name); + else + sa_algs[i].registered = 1; + } +} + +/* Unregister the algorithms in crypto framework */ +void sa_unregister_algos(const struct device *dev) +{ + char *alg_name; + u32 type; + int i, err = 0, num_algs = ARRAY_SIZE(sa_algs); + + for (i = 0; i < num_algs; i++) { + type = sa_algs[i].type; + if (type == CRYPTO_ALG_TYPE_AEAD) { + alg_name = sa_algs[i].alg.aead.base.cra_name; + crypto_unregister_aead(&sa_algs[i].alg.aead); + } else { + alg_name = sa_algs[i].alg.crypto.cra_name; + err = crypto_unregister_alg(&sa_algs[i].alg.crypto); + } + + sa_algs[i].registered = 0; + } +} + +static int sa_init_mem(struct sa_crypto_data *dev_data) +{ + struct device *dev = &dev_data->pdev->dev; + /* Setup dma pool for security context buffers */ + dev_data->sc_pool = dma_pool_create("keystone-sc", dev, + SA_CTX_MAX_SZ, 64, 0); + if (!dev_data->sc_pool) { + dev_err(dev, "Failed to create dma pool"); + return -ENOMEM; + } + + return 0; +} + +static int sa_dma_init(struct sa_crypto_data *dd) +{ + int ret; + struct dma_slave_config cfg; + + dd->dma_rx1 = NULL; + dd->dma_tx = NULL; + dd->dma_rx2 = NULL; + + ret = dma_coerce_mask_and_coherent(dd->dev, DMA_BIT_MASK(48)); + if (ret) + return ret; + + dd->dma_rx1 = dma_request_chan(dd->dev, "rx1"); + if (IS_ERR(dd->dma_rx1)) { + if (PTR_ERR(dd->dma_rx1) != -EPROBE_DEFER) + dev_err(dd->dev, "Unable to request rx1 DMA channel\n"); + return PTR_ERR(dd->dma_rx1); + } + + dd->dma_rx2 = dma_request_chan(dd->dev, "rx2"); + if (IS_ERR(dd->dma_rx2)) { + dma_release_channel(dd->dma_rx1); + if (PTR_ERR(dd->dma_rx1) != -EPROBE_DEFER) + dev_err(dd->dev, "Unable to request rx2 DMA channel\n"); + return PTR_ERR(dd->dma_rx2); + } + + dd->dma_tx = dma_request_chan(dd->dev, "tx"); + if (IS_ERR(dd->dma_tx)) { + if (PTR_ERR(dd->dma_rx1) != -EPROBE_DEFER) + dev_err(dd->dev, "Unable to request tx DMA channel\n"); + ret = PTR_ERR(dd->dma_tx); + goto err_dma_tx; + } + + memzero_explicit(&cfg, sizeof(cfg)); + + cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; + cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; + cfg.src_maxburst = 4; + cfg.dst_maxburst = 4; + + ret = dmaengine_slave_config(dd->dma_rx1, &cfg); + if (ret) { + dev_err(dd->dev, "can't configure IN dmaengine slave: %d\n", + ret); + return ret; + } + + ret = dmaengine_slave_config(dd->dma_rx2, &cfg); + if (ret) { + dev_err(dd->dev, "can't configure IN dmaengine slave: %d\n", + ret); + return ret; + } + + ret = dmaengine_slave_config(dd->dma_tx, &cfg); + if (ret) { + dev_err(dd->dev, "can't configure OUT dmaengine slave: %d\n", + ret); + return ret; + } + + return 0; + +err_dma_tx: + dma_release_channel(dd->dma_rx1); + dma_release_channel(dd->dma_rx2); + + return ret; +} + +static int sa_ul_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct resource *res; + static void __iomem *saul_base; + struct sa_crypto_data *dev_data; + u32 val; + int ret; + + dev_data = devm_kzalloc(dev, sizeof(*dev_data), GFP_KERNEL); + if (!dev_data) + return -ENOMEM; + + sa_k3_dev = dev; + dev_data->dev = dev; + dev_data->pdev = pdev; + platform_set_drvdata(pdev, dev_data); + dev_set_drvdata(sa_k3_dev, dev_data); + + sa_init_mem(dev_data); + ret = sa_dma_init(dev_data); + if (ret) + return ret; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + saul_base = devm_ioremap_resource(dev, res); + + val = SA_EEC_ENCSS_EN | SA_EEC_AUTHSS_EN | SA_EEC_CTXCACH_EN | + SA_EEC_CPPI_PORT_IN_EN | SA_EEC_CPPI_PORT_OUT_EN | SA_EEC_TRNG_EN; + + writel_relaxed(val, saul_base + SA_ENGINE_ENABLE_CONTROL); + + sa_register_algos(dev); + + return 0; +} + +static int sa_ul_remove(struct platform_device *pdev) +{ + struct sa_crypto_data *dev_data = platform_get_drvdata(pdev); + + sa_unregister_algos(&pdev->dev); + + dma_release_channel(dev_data->dma_rx2); + dma_release_channel(dev_data->dma_rx1); + dma_release_channel(dev_data->dma_tx); + + dma_pool_destroy(dev_data->sc_pool); + + platform_set_drvdata(pdev, NULL); + + return 0; +} + +static const struct of_device_id of_match[] = { + {.compatible = "ti,sa2ul-crypto",}, + {}, +}; +MODULE_DEVICE_TABLE(of, of_match); + +static struct platform_driver sa_ul_driver = { + .probe = sa_ul_probe, + .remove = sa_ul_remove, + .driver = { + .name = "saul-crypto", + .of_match_table = of_match, + }, +}; +module_platform_driver(sa_ul_driver); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/crypto/sa2ul.h b/drivers/crypto/sa2ul.h new file mode 100644 index 000000000000..caf3c88dcf2b --- /dev/null +++ b/drivers/crypto/sa2ul.h @@ -0,0 +1,384 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * AM6 SA2UL crypto accelerator driver + * + * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com + * + * Authors: Keerthy + * Vitaly Andrianov + */ + +#ifndef _K3_SA2UL_ +#define _K3_SA2UL_ + +#include +#include +#include +#include + +#define SA_ENGINE_ENABLE_CONTROL 0x1000 + +struct sa_tfm_ctx; +/* + * SA_ENGINE_ENABLE_CONTROL register bits + */ +#define SA_EEC_ENCSS_EN 0x00000001 +#define SA_EEC_AUTHSS_EN 0x00000002 +#define SA_EEC_TRNG_EN 0x00000008 +#define SA_EEC_PKA_EN 0x00000010 +#define SA_EEC_CTXCACH_EN 0x00000080 +#define SA_EEC_CPPI_PORT_IN_EN 0x00000200 +#define SA_EEC_CPPI_PORT_OUT_EN 0x00000800 + +/* + * Encoding used to identify the typo of crypto operation + * performed on the packet when the packet is returned + * by SA + */ +#define SA_REQ_SUBTYPE_ENC 0x0001 +#define SA_REQ_SUBTYPE_DEC 0x0002 +#define SA_REQ_SUBTYPE_SHIFT 16 +#define SA_REQ_SUBTYPE_MASK 0xffff + +/* Number of 32 bit words in EPIB */ +#define SA_DMA_NUM_EPIB_WORDS 4 + +/* Number of 32 bit words in PS data */ +#define SA_DMA_NUM_PS_WORDS 16 +#define NKEY_SZ 3 +#define MCI_SZ 27 + +/* + * Maximum number of simultaeneous security contexts + * supported by the driver + */ +#define SA_MAX_NUM_CTX 512 + +/* + * Assumption: CTX size is multiple of 32 + */ +#define SA_CTX_SIZE_TO_DMA_SIZE(ctx_sz) \ + ((ctx_sz) ? ((ctx_sz) / 32 - 1) : 0) + +#define SA_CTX_ENC_KEY_OFFSET 32 +#define SA_CTX_ENC_AUX1_OFFSET 64 +#define SA_CTX_ENC_AUX2_OFFSET 96 +#define SA_CTX_ENC_AUX3_OFFSET 112 +#define SA_CTX_ENC_AUX4_OFFSET 128 + +/* Next Engine Select code in CP_ACE */ +#define SA_ENG_ID_EM1 2 /* Enc/Dec engine with AES/DEC core */ +#define SA_ENG_ID_EM2 3 /* Encryption/Decryption enginefor pass 2 */ +#define SA_ENG_ID_AM1 4 /* Auth. engine with SHA1/MD5/SHA2 core */ +#define SA_ENG_ID_AM2 5 /* Authentication engine for pass 2 */ +#define SA_ENG_ID_OUTPORT2 20 /* Egress module 2 */ +#define SA_ENG_ID_NONE 0xff + +/* + * Command Label Definitions + */ +#define SA_CMDL_OFFSET_NESC 0 /* Next Engine Select Code */ +#define SA_CMDL_OFFSET_LABEL_LEN 1 /* Engine Command Label Length */ +/* 16-bit Length of Data to be processed */ +#define SA_CMDL_OFFSET_DATA_LEN 2 +#define SA_CMDL_OFFSET_DATA_OFFSET 4 /* Stat Data Offset */ +#define SA_CMDL_OFFSET_OPTION_CTRL1 5 /* Option Control Byte 1 */ +#define SA_CMDL_OFFSET_OPTION_CTRL2 6 /* Option Control Byte 2 */ +#define SA_CMDL_OFFSET_OPTION_CTRL3 7 /* Option Control Byte 3 */ +#define SA_CMDL_OFFSET_OPTION_BYTE 8 + +#define SA_CMDL_HEADER_SIZE_BYTES 8 + +#define SA_CMDL_OPTION_BYTES_MAX_SIZE 72 +#define SA_CMDL_MAX_SIZE_BYTES (SA_CMDL_HEADER_SIZE_BYTES + \ + SA_CMDL_OPTION_BYTES_MAX_SIZE) + +/* SWINFO word-0 flags */ +#define SA_SW_INFO_FLAG_EVICT 0x0001 +#define SA_SW_INFO_FLAG_TEAR 0x0002 +#define SA_SW_INFO_FLAG_NOPD 0x0004 + +/* + * This type represents the various packet types to be processed + * by the PHP engine in SA. + * It is used to identify the corresponding PHP processing function. + */ +#define SA_CTX_PE_PKT_TYPE_3GPP_AIR 0 /* 3GPP Air Cipher */ +#define SA_CTX_PE_PKT_TYPE_SRTP 1 /* SRTP */ +#define SA_CTX_PE_PKT_TYPE_IPSEC_AH 2 /* IPSec Authentication Header */ +/* IPSec Encapsulating Security Payload */ +#define SA_CTX_PE_PKT_TYPE_IPSEC_ESP 3 +/* Indicates that it is in data mode, It may not be used by PHP */ +#define SA_CTX_PE_PKT_TYPE_NONE 4 +#define SA_CTX_ENC_TYPE1_SZ 64 /* Encryption SC with Key only */ +#define SA_CTX_ENC_TYPE2_SZ 96 /* Encryption SC with Key and Aux1 */ + +#define SA_CTX_AUTH_TYPE1_SZ 64 /* Auth SC with Key only */ +#define SA_CTX_AUTH_TYPE2_SZ 96 /* Auth SC with Key and Aux1 */ +/* Size of security context for PHP engine */ +#define SA_CTX_PHP_PE_CTX_SZ 64 + +#define SA_CTX_MAX_SZ (64 + SA_CTX_ENC_TYPE2_SZ + SA_CTX_AUTH_TYPE2_SZ) + +/* + * Encoding of F/E control in SCCTL + * Bit 0-1: Fetch PHP Bytes + * Bit 2-3: Fetch Encryption/Air Ciphering Bytes + * Bit 4-5: Fetch Authentication Bytes or Encr pass 2 + * Bit 6-7: Evict PHP Bytes + * + * where 00 = 0 bytes + * 01 = 64 bytes + * 10 = 96 bytes + * 11 = 128 bytes + */ +#define SA_CTX_DMA_SIZE_0 0 +#define SA_CTX_DMA_SIZE_64 1 +#define SA_CTX_DMA_SIZE_96 2 +#define SA_CTX_DMA_SIZE_128 3 + +/* + * Byte offset of the owner word in SCCTL + * in the security context + */ +#define SA_CTX_SCCTL_OWNER_OFFSET 0 + +#define SA_CTX_ENC_KEY_OFFSET 32 +#define SA_CTX_ENC_AUX1_OFFSET 64 +#define SA_CTX_ENC_AUX2_OFFSET 96 +#define SA_CTX_ENC_AUX3_OFFSET 112 +#define SA_CTX_ENC_AUX4_OFFSET 128 + +#define SA_SCCTL_FE_AUTH_ENC 0x65 +#define SA_SCCTL_FE_ENC 0x8D + +#define SA_ALIGN_MASK (sizeof(u32) - 1) +#define SA_ALIGNED __aligned(32) + +/** + * struct sa_crypto_data - Crypto driver instance data + * @pdev: Platform device pointer + * @sc_pool: security context pool + * @dev: Device pointer + * @scid_lock: secure context ID lock + * @sc_id_start: starting index for SC ID + * @sc_id_end: Ending index for SC ID + * @sc_id: Security Context ID + * @ctx_bm: Bitmap to keep track of Security context ID's + * @ctx: SA tfm context pointer + * @dma_rx1: Pointer to DMA rx channel for sizes < 256 Bytes + * @dma_rx2: Pointer to DMA rx channel for sizes > 256 Bytes + * @dma_tx: Pointer to DMA TX channel + */ +struct sa_crypto_data { + struct platform_device *pdev; + struct dma_pool *sc_pool; + struct device *dev; + spinlock_t scid_lock; /* lock for SC-ID allocation */ + /* Security context data */ + u16 sc_id_start; + u16 sc_id_end; + u16 sc_id; + unsigned long ctx_bm[DIV_ROUND_UP(SA_MAX_NUM_CTX, + BITS_PER_LONG)]; + struct sa_tfm_ctx *ctx; + struct dma_chan *dma_rx1; + struct dma_chan *dma_rx2; + struct dma_chan *dma_tx; +}; + +/** + * struct sa_cmdl_param_info: Command label parameters info + * @index: Index of the parameter in the command label format + * @offset: the offset of the parameter + * @size: Size of the parameter + */ +struct sa_cmdl_param_info { + u16 index; + u16 offset; + u16 size; +}; + +/* Maximum length of Auxiliary data in 32bit words */ +#define SA_MAX_AUX_DATA_WORDS 8 + +/** + * struct sa_cmdl_upd_info: Command label updation info + * @flags: flags in command label + * @submode: Encryption submodes + * @enc_size: Size of first pass encryption size + * @enc_size2: Size of second pass encryption size + * @enc_offset: Encryption payload offset in the packet + * @enc_iv: Encryption initialization vector for pass2 + * @enc_iv2: Encryption initialization vector for pass2 + * @aad: Associated data + * @payload: Payload info + * @auth_size: Authentication size for pass 1 + * @auth_size2: Authentication size for pass 2 + * @auth_offset: Authentication payload offset + * @auth_iv: Authentication initialization vector + * @aux_key_info: Authentication aux key information + * @aux_key: Aux key for authentication + */ +struct sa_cmdl_upd_info { + u16 flags; + u16 submode; + struct sa_cmdl_param_info enc_size; + struct sa_cmdl_param_info enc_size2; + struct sa_cmdl_param_info enc_offset; + struct sa_cmdl_param_info enc_iv; + struct sa_cmdl_param_info enc_iv2; + struct sa_cmdl_param_info aad; + struct sa_cmdl_param_info payload; + struct sa_cmdl_param_info auth_size; + struct sa_cmdl_param_info auth_size2; + struct sa_cmdl_param_info auth_offset; + struct sa_cmdl_param_info auth_iv; + struct sa_cmdl_param_info aux_key_info; + u32 aux_key[SA_MAX_AUX_DATA_WORDS]; +}; + +/* + * Number of 32bit words appended after the command label + * in PSDATA to identify the crypto request context. + * word-0: Request type + * word-1: pointer to request + */ +#define SA_PSDATA_CTX_WORDS 4 + +/* Maximum size of Command label in 32 words */ +#define SA_MAX_CMDL_WORDS (SA_DMA_NUM_PS_WORDS - SA_PSDATA_CTX_WORDS) + +/** + * struct sa_ctx_info: SA context information + * @sc: Pointer to security context + * @sc_phys: Security context physical address that is passed on to SA2UL + * @cmdl_size: Command label size + * @cmdl: Command label for a particular iteration + * @cmdl_upd_info: structure holding command label updation info + * @epib: Extended protocol information block words + */ +struct sa_ctx_info { + u8 *sc; + dma_addr_t sc_phys; + u16 sc_id; + u16 cmdl_size; + u32 cmdl[SA_MAX_CMDL_WORDS]; + struct sa_cmdl_upd_info cmdl_upd_info; + /* Store Auxiliary data such as K2/K3 subkeys in AES-XCBC */ + u32 epib[SA_DMA_NUM_EPIB_WORDS]; +}; + +struct sa_sham_hmac_ctx { + struct crypto_shash *shash; + u8 ipad[SHA512_BLOCK_SIZE] SA_ALIGNED; + u8 opad[SHA512_BLOCK_SIZE] SA_ALIGNED; +}; + +/** + * struct sa_tfm_ctx: TFM context structure + * @dev_data: struct sa_crypto_data pointer + * @enc: struct sa_ctx_info for encryption + * @dec: struct sa_ctx_info for decryption + * @auth: struct sa_ctx_info for authentication + * @keylen: encrption/decryption keylength + * @key: encryption key + * @shash: software hash crypto_hash + * @authkey: authentication key + */ +struct sa_tfm_ctx { + struct sa_crypto_data *dev_data; + struct sa_ctx_info enc; + struct sa_ctx_info dec; + struct sa_ctx_info auth; + int keylen; + u32 key[AES_KEYSIZE_256 / sizeof(u32)]; + struct sa_sham_hmac_ctx base[0]; + struct crypto_shash *shash; + u8 authkey[SHA512_BLOCK_SIZE]; +}; + +/** + * struct sa_dma_req_ctx: Structure used for tx dma request + * @dev_data: struct sa_crypto_data pointer + * @cmdl: Complete command label with psdata and epib included + * @src: source payload scatterlist pointer + * @src_nents: Number of nodes in source scatterlist + * @pkt: packet dma + */ +struct sa_dma_req_ctx { + struct sa_crypto_data *dev_data; + u32 cmdl[SA_MAX_CMDL_WORDS + SA_PSDATA_CTX_WORDS]; + struct scatterlist *src; + unsigned int src_nents; + bool pkt; +}; + +enum sa_submode { + SA_MODE_GEN = 0, + SA_MODE_CCM, + SA_MODE_GCM, + SA_MODE_GMAC +}; + +/* Encryption algorithms */ +enum sa_ealg_id { + SA_EALG_ID_NONE = 0, /* No encryption */ + SA_EALG_ID_NULL, /* NULL encryption */ + SA_EALG_ID_AES_CTR, /* AES Counter mode */ + SA_EALG_ID_AES_F8, /* AES F8 mode */ + SA_EALG_ID_AES_CBC, /* AES CBC mode */ + SA_EALG_ID_DES_CBC, /* DES CBC mode */ + SA_EALG_ID_3DES_CBC, /* 3DES CBC mode */ + SA_EALG_ID_CCM, /* Counter with CBC-MAC mode */ + SA_EALG_ID_GCM, /* Galois Counter mode */ + SA_EALG_ID_AES_ECB, + SA_EALG_ID_LAST +}; + +/* Authentication algorithms */ +enum sa_aalg_id { + SA_AALG_ID_NONE = 0, /* No Authentication */ + SA_AALG_ID_NULL = SA_EALG_ID_LAST, /* NULL Authentication */ + SA_AALG_ID_MD5, /* MD5 mode */ + SA_AALG_ID_SHA1, /* SHA1 mode */ + SA_AALG_ID_SHA2_224, /* 224-bit SHA2 mode */ + SA_AALG_ID_SHA2_256, /* 256-bit SHA2 mode */ + SA_AALG_ID_HMAC_MD5, /* HMAC with MD5 mode */ + SA_AALG_ID_HMAC_SHA1, /* HMAC with SHA1 mode */ + SA_AALG_ID_HMAC_SHA2_224, /* HMAC with 224-bit SHA2 mode */ + SA_AALG_ID_HMAC_SHA2_256, /* HMAC with 256-bit SHA2 mode */ + SA_AALG_ID_GMAC, /* Galois Message Auth. Code mode */ + SA_AALG_ID_CMAC, /* Cipher-based Mes. Auth. Code mode */ + SA_AALG_ID_CBC_MAC, /* Cipher Block Chaining */ + SA_AALG_ID_AES_XCBC /* AES Extended Cipher Block Chaining */ +}; + +/* + * Mode control engine algorithms used to index the + * mode control instruction tables + */ +enum sa_eng_algo_id { + SA_ENG_ALGO_ECB = 0, + SA_ENG_ALGO_CBC, + SA_ENG_ALGO_CFB, + SA_ENG_ALGO_OFB, + SA_ENG_ALGO_CTR, + SA_ENG_ALGO_F8, + SA_ENG_ALGO_F8F9, + SA_ENG_ALGO_GCM, + SA_ENG_ALGO_GMAC, + SA_ENG_ALGO_CCM, + SA_ENG_ALGO_CMAC, + SA_ENG_ALGO_CBCMAC, + SA_NUM_ENG_ALGOS +}; + +struct sa_eng_info { + u8 eng_id; + u16 sc_size; +}; + +extern struct device *sa_ks2_dev; + +#endif /* _K3_SA2UL_ */ -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D9C7DC5B578 for ; Fri, 28 Jun 2019 04:28:20 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9FE2B20644 for ; Fri, 28 Jun 2019 04:28:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="FFoJZLw9"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ti.com header.i=@ti.com header.b="a99iszDj" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9FE2B20644 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=ti.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ByZ1Q1n6gPRg1TqIXUOM2262U9XYK/t7r5Bu/f+c8XI=; b=FFoJZLw9gq8PsQ Rqr1iI5lv7tymSTs0TtK3WfxXNmZz88381/zT90qHPiUqx4vADdWp5JxKu7dsRjjju4hZcKlJP4Tx Kps98mLbJJxMgId1lHhJX6T5qUfJeb35OyfL64wpGv4V0v4YTQzUDEFmfMofnSEFC68m5XV4UPKBv OqyMqZk1BHTMzUzZGTUwI2HK4jjGVTOyXQLDLl0j4rHhGIddYGBZAukwJscXW5sZSW2/qPhV16Vhk 0dCiMJtaVdqLHcPEt5t4FFw4myfB2WiR2fa5p7MRsdFtrYSua+jQcEVoa75nfBlKIPmBqHgOXXh7X xNrCKxrRuUfDP3y30TPw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1hgiUi-0004vt-9M; Fri, 28 Jun 2019 04:28:16 +0000 Received: from lelv0142.ext.ti.com ([198.47.23.249]) by bombadil.infradead.org with esmtps (Exim 4.92 #3 (Red Hat Linux)) id 1hgiU2-0004QF-Vm for linux-arm-kernel@lists.infradead.org; Fri, 28 Jun 2019 04:27:39 +0000 Received: from fllv0034.itg.ti.com ([10.64.40.246]) by lelv0142.ext.ti.com (8.15.2/8.15.2) with ESMTP id x5S4RUoR020827; Thu, 27 Jun 2019 23:27:30 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1561696050; bh=FehHwOOdVMctdOago5xa8n5T2ZOnQCMHDR1SFCGPe6U=; h=From:To:CC:Subject:Date:In-Reply-To:References; b=a99iszDjM67s5LcpsnEV5HQzZGo2Awhb7LASw1uJ5Eklo22iBhlFYBYUnCLDjCR/h WOwkFLWU1GSTesWhbD8CV530riWCrDTvITmMjGwBwP+/yspQRQAhr80dm4sDkA0pl5 NKDHDbjAjz4WWqGQjYalGTujg0wZIUccrkAN7oNQ= Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by fllv0034.itg.ti.com (8.15.2/8.15.2) with ESMTPS id x5S4RUYK021516 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Thu, 27 Jun 2019 23:27:30 -0500 Received: from DFLE109.ent.ti.com (10.64.6.30) by DFLE102.ent.ti.com (10.64.6.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1713.5; Thu, 27 Jun 2019 23:27:29 -0500 Received: from fllv0040.itg.ti.com (10.64.41.20) by DFLE109.ent.ti.com (10.64.6.30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1713.5 via Frontend Transport; Thu, 27 Jun 2019 23:27:29 -0500 Received: from a0393675ula.india.ti.com (ileax41-snat.itg.ti.com [10.172.224.153]) by fllv0040.itg.ti.com (8.15.2/8.15.2) with ESMTP id x5S4RKPM062595; Thu, 27 Jun 2019 23:27:27 -0500 From: Keerthy To: , , Subject: [RESEND PATCH 02/10] crypto: sa2ul: Add crypto driver Date: Fri, 28 Jun 2019 09:57:37 +0530 Message-ID: <20190628042745.28455-3-j-keerthy@ti.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190628042745.28455-1-j-keerthy@ti.com> References: <20190628042745.28455-1-j-keerthy@ti.com> MIME-Version: 1.0 X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190627_212735_204827_60EE34B0 X-CRM114-Status: GOOD ( 21.17 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: nm@ti.com, devicetree@vger.kernel.org, j-keerthy@ti.com, linux-kernel@vger.kernel.org, t-kristo@ti.com, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhlIFNlY3VyaXR5IEFjY2VsZXJhdG9yIChTQTJfVUwpIHN1YnN5c3RlbSBwcm92aWRlcyBoYXJk d2FyZQpjcnlwdG9ncmFwaGljIGFjY2VsZXJhdGlvbiBmb3IgdGhlIGZvbGxvd2luZyB1c2UgY2Fz ZXM6CuKAoiBFbmNyeXB0aW9uIGFuZCBhdXRoZW50aWNhdGlvbiBmb3Igc2VjdXJlIGJvb3QK4oCi IEVuY3J5cHRpb24gYW5kIGF1dGhlbnRpY2F0aW9uIG9mIGNvbnRlbnQgaW4gYXBwbGljYXRpb25z CiAgcmVxdWlyaW5nIERSTSAoZGlnaXRhbCByaWdodHMgbWFuYWdlbWVudCkgYW5kCiAgY29udGVu dC9hc3NldCBwcm90ZWN0aW9uClRoZSBkZXZpY2UgaW5jbHVkZXMgb25lIGluc3RhbnRpYXRpb24g b2YgU0EyX1VMIG5hbWVkIFNBMl9VTDAKClNBMl9VTCBzdXBwb3J0cyB0aGUgZm9sbG93aW5nIGNy eXB0b2dyYXBoaWMgaW5kdXN0cnkgc3RhbmRhcmRzIHRvIGVuYWJsZSBkYXRhIGF1dGhlbnRpY2F0 aW9uLCBkYXRhCmludGVncml0eSBhbmQgZGF0YSBjb25maWRlbnRpYWxpdHkuCgpDcnlwdG8gZnVu Y3Rpb24gbGlicmFyeSBmb3Igc29mdHdhcmUgYWNjZWxlcmF0aW9uCm8gQUVTIG9wZXJhdGlvbgpv IDNERVMgb3BlcmF0aW9uCm8gU0hBMSBvcGVyYXRpb24KbyBNRDUgb3BlcmF0aW9uCm8gU0hBMiDi gJMgMjI0LCAyNTYsIDM4NCwgNTEyIG9wZXJhdGlvbgoKQXV0aGVudGljYXRpb24gc3VwcG9ydGVk IHZpYSBmb2xsb3dpbmcgaGFyZHdhcmUgY29yZXMKbyBTSEExCm8gTUQ1Cm8gU0hBMiAtMjI0Cm8g U0hBMi0yNTYKbyBTSEEyLTM4NApvIFNIQTItNTEyCgpQYXRjaCBhZGRzIGEgYmFzaWMgY3J5cHRv IGRyaXZlciBhbmQgY3VycmVudGx5IHN1cHBvcnRzIEFFUwppbiBjYmMgbW9kZSBmb3IgYm90aCBl bmNyeXB0aW9uIGFuZCBkZWNyeXB0aW9uLgoKU2lnbmVkLW9mZi1ieTogS2VlcnRoeSA8ai1rZWVy dGh5QHRpLmNvbT4KLS0tCiBkcml2ZXJzL2NyeXB0by9LY29uZmlnICB8ICAgMTcgKwogZHJpdmVy cy9jcnlwdG8vTWFrZWZpbGUgfCAgICAxICsKIGRyaXZlcnMvY3J5cHRvL3NhMnVsLmMgIHwgMTE1 MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvY3J5cHRv L3NhMnVsLmggIHwgIDM4NCArKysrKysrKysrKysrCiA0IGZpbGVzIGNoYW5nZWQsIDE1NTMgaW5z ZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY3J5cHRvL3NhMnVsLmMKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2NyeXB0by9zYTJ1bC5oCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9jcnlwdG8vS2NvbmZpZyBiL2RyaXZlcnMvY3J5cHRvL0tjb25maWcKaW5kZXggNjAzNDEz ZjI4ZmEzLi5iOWEzZmEwMjZjNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL0tjb25maWcK KysrIGIvZHJpdmVycy9jcnlwdG8vS2NvbmZpZwpAQCAtNzg1LDQgKzc4NSwyMSBAQCBjb25maWcg Q1JZUFRPX0RFVl9DQ1JFRQogCiBzb3VyY2UgImRyaXZlcnMvY3J5cHRvL2hpc2lsaWNvbi9LY29u ZmlnIgogCitjb25maWcgQ1JZUFRPX0RFVl9TQTJVTAorCXRyaXN0YXRlICJTdXBwb3J0IGZvciBU SSBzZWN1cml0eSBhY2NlbGVyYXRvciIKKwlkZXBlbmRzIG9uIEFSQ0hfSzMgfHwgQ09NUElMRV9U RVNUCisJc2VsZWN0IEFSTTY0X0NSWVBUTworCXNlbGVjdCBDUllQVE9fQUVTCisJc2VsZWN0IENS WVBUT19BRVNfQVJNNjQKKwlzZWxlY3QgQ1JZUFRPX1NIQTEKKwlzZWxlY3QgQ1JZUFRPX01ENQor CXNlbGVjdCBDUllQVE9fQUxHQVBJCisJc2VsZWN0IENSWVBUT19BVVRIRU5DCisJc2VsZWN0IEhX X1JBTkRPTQorCWRlZmF1bHQgbSBpZiBBUkNIX0szCisJaGVscAorCSAgS2V5c3RvbmUgZGV2aWNl cyBpbmNsdWRlIGEgc2VjdXJpdHkgYWNjZWxlcmF0b3IgZW5naW5lIHRoYXQgbWF5IGJlCisJICB1 c2VkIGZvciBjcnlwdG8gb2ZmbG9hZC4gIFNlbGVjdCB0aGlzIGlmIHlvdSB3YW50IHRvIHVzZSBo YXJkd2FyZQorCSAgYWNjZWxlcmF0aW9uIGZvciBjcnlwdG9ncmFwaGljIGFsZ29yaXRobXMgb24g dGhlc2UgZGV2aWNlcy4KKwogZW5kaWYgIyBDUllQVE9fSFcKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Y3J5cHRvL01ha2VmaWxlIGIvZHJpdmVycy9jcnlwdG8vTWFrZWZpbGUKaW5kZXggYWZjNDc1M2I1 ZDI4Li4zMDBkMzFmZDI0ZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL01ha2VmaWxlCisr KyBiL2RyaXZlcnMvY3J5cHRvL01ha2VmaWxlCkBAIC00Nyw0ICs0Nyw1IEBAIG9iai0kKENPTkZJ R19DUllQVE9fREVWX1ZNWCkgKz0gdm14Lwogb2JqLSQoQ09ORklHX0NSWVBUT19ERVZfQkNNX1NQ VSkgKz0gYmNtLwogb2JqLSQoQ09ORklHX0NSWVBUT19ERVZfU0FGRVhDRUwpICs9IGluc2lkZS1z ZWN1cmUvCiBvYmotJChDT05GSUdfQ1JZUFRPX0RFVl9BUlRQRUM2KSArPSBheGlzLworb2JqLSQo Q09ORklHX0NSWVBUT19ERVZfU0EyVUwpICs9IHNhMnVsLm8KIG9iai15ICs9IGhpc2lsaWNvbi8K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL3NhMnVsLmMgYi9kcml2ZXJzL2NyeXB0by9zYTJ1 bC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNjRiZGY2YjJiODc5 Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9jcnlwdG8vc2EydWwuYwpAQCAtMCwwICsxLDEx NTEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQU02IFNB MlVMIGNyeXB0byBhY2NlbGVyYXRvciBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTgg VGV4YXMgSW5zdHJ1bWVudHMgSW5jb3Jwb3JhdGVkIC0gaHR0cDovL3d3dy50aS5jb20KKyAqCisg KiBBdXRob3JzOglLZWVydGh5CisgKiAgICAgICAgICAgICAgVml0YWx5IEFuZHJpYW5vdgorICov CisjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5j bHVkZSA8bGludXgvZG1hcG9vbC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWFlbmdp bmUuaD4KKyNpbmNsdWRlIDxsaW51eC9jcnlwdG9oYXNoLmg+CisjaW5jbHVkZSA8bGludXgvbW9k X2RldmljZXRhYmxlLmg+CisKKyNpbmNsdWRlIDxjcnlwdG8vYXV0aGVuYy5oPgorI2luY2x1ZGUg PGNyeXB0by9kZXMuaD4KKyNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvYWVhZC5oPgorI2luY2x1 ZGUgPGNyeXB0by9pbnRlcm5hbC9za2NpcGhlci5oPgorI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5h bC9oYXNoLmg+CisjaW5jbHVkZSA8Y3J5cHRvL3NjYXR0ZXJ3YWxrLmg+CisjaW5jbHVkZSA8Y3J5 cHRvL3NoYS5oPgorCisjaW5jbHVkZSAic2EydWwuaCIKKworLyogQnl0ZSBvZmZzZXQgZm9yIGtl eSBpbiBlbmNyeXB0aW9uIHNlY3VyaXR5IGNvbnRleHQgKi8KKyNkZWZpbmUgU0NfRU5DX0tFWV9P RkZTRVQgKDEgKyAyNyArIDQpCisvKiBCeXRlIG9mZnNldCBmb3IgQXV4LTEgaW4gZW5jcnlwdGlv biBzZWN1cml0eSBjb250ZXh0ICovCisjZGVmaW5lIFNDX0VOQ19BVVgxX09GRlNFVCAoMSArIDI3 ICsgNCArIDMyKQorCisjZGVmaW5lIFNBX0NNRExfVVBEX0VOQyAgICAgICAgIDB4MDAwMQorI2Rl ZmluZSBTQV9DTURMX1VQRF9BVVRIICAgICAgICAweDAwMDIKKyNkZWZpbmUgU0FfQ01ETF9VUERf RU5DX0lWICAgICAgMHgwMDA0CisjZGVmaW5lIFNBX0NNRExfVVBEX0FVVEhfSVYgICAgIDB4MDAw OAorI2RlZmluZSBTQV9DTURMX1VQRF9BVVhfS0VZICAgICAweDAwMTAKKworI2RlZmluZSBTQV9B VVRIX1NVQktFWV9MRU4JMTYKKyNkZWZpbmUgU0FfQ01ETF9QQVlMT0FEX0xFTkdUSF9NQVNLCTB4 RkZGRgorI2RlZmluZSBTQV9DTURMX1NPUF9CWVBBU1NfTEVOX01BU0sJMHhGRjAwMDAwMAorCisj ZGVmaW5lIE1PREVfQ09OVFJPTF9CWVRFUwkyNworI2RlZmluZSBTQV9IQVNIX1BST0NFU1NJTkcJ MAorI2RlZmluZSBTQV9DUllQVE9fUFJPQ0VTU0lORwkwCisjZGVmaW5lIFNBX1VQTE9BRF9IQVNI X1RPX1RMUglCSVQoNikKKworI2RlZmluZSBTQV9TVzBfRkxBR1NfTUFTSwkweEYwMDAwCisjZGVm aW5lIFNBX1NXMF9DTURMX0lORk9fTUFTSwkweDFGMDAwMDAKKyNkZWZpbmUgU0FfU1cwX0NNRExf UFJFU0VOVAlCSVQoNCkKKyNkZWZpbmUgU0FfU1cwX0VOR19JRF9NQVNLCTB4M0UwMDAwMDAKKyNk ZWZpbmUgU0FfU1cwX0RFU1RfSU5GT19QUkVTRU5UCUJJVCgzMCkKKyNkZWZpbmUgU0FfU1cyX0VH UkVTU19MRU5HVEgJCTB4RkYwMDAwMDAKKworI2RlZmluZSBTSEEyNTZfRElHRVNUX1dPUkRTICAg IDgKKy8qIE1ha2UgMzItYml0IHdvcmQgZnJvbSA0IGJ5dGVzICovCisjZGVmaW5lIFNBX01LX1Uz MihiMCwgYjEsIGIyLCBiMykgKCgoYjApIDw8IDI0KSB8ICgoYjEpIDw8IDE2KSB8IFwKKwkJCQkg ICAoKGIyKSA8PCA4KSB8IChiMykpCisKKy8qIHNpemUgb2YgU0NDVEwgc3RydWN0dXJlIGluIGJ5 dGVzICovCisjZGVmaW5lIFNBX1NDQ1RMX1NaIDE2CisKKy8qIE1heCBBdXRoZW50aWNhdGlvbiB0 YWcgc2l6ZSAqLworI2RlZmluZSBTQV9NQVhfQVVUSF9UQUdfU1ogNjQKKworI2RlZmluZSBQUklW X0lECTB4MQorI2RlZmluZSBQUklWCTB4MQorCitzdGF0aWMgc3RydWN0IGRldmljZSAqc2FfazNf ZGV2OworCisvKioKKyAqIHN0cnVjdCBzYV9jbWRsX2NmZyAtIENvbW1hbmQgbGFiZWwgY29uZmln dXJhdGlvbiBkZXNjcmlwdG9yCisgKiBAZW5jMXN0OiBJZiB0aGUgaXRlcmF0aW9uIG5lZWRzIGVu Y3J5cHRpb24gYmVmb3JlIGF1dGhlbnRpY2F0aW9uCisgKiBAYWFsZzogYXV0aGVudGljYXRpb24g YWxnb3JpdGhtIElECisgKiBAZW5jX2VuZ19pZDogRW5jcnlwdGlvbiBFbmdpbmUgSUQgc3VwcG9y dGVkIGJ5IHRoZSBTQSBoYXJkd2FyZQorICogQGF1dGhfZW5nX2lkOiBhdXRoZW50aWNhdGlvbiBF bmdpbmUgSUQKKyAqIEBpdl9zaXplOiBJbml0aWFsaXphdGlvbiBWZWN0b3Igc2l6ZQorICogQGFr ZXk6IEF1dGhlbnRpY2F0aW9uIGtleQorICogQGFrZXlfbGVuOiBBdXRoZW50aWNhdGlvbiBrZXkg bGVuZ3RoCisgKi8KK3N0cnVjdCBzYV9jbWRsX2NmZyB7CisJaW50IGVuYzFzdDsKKwlpbnQgYWFs ZzsKKwl1OCBlbmNfZW5nX2lkOworCXU4IGF1dGhfZW5nX2lkOworCXU4IGl2X3NpemU7CisJY29u c3QgdTggKmFrZXk7CisJdTE2IGFrZXlfbGVuOworCXUxNiBhdXRoX3N1YmtleV9sZW47Cit9Owor CisvKioKKyAqIHN0cnVjdCBhbGdvX2RhdGEgLSBDcnlwdG8gYWxnb3JpdGhtIHNwZWNpZmljIGRh dGEKKyAqIEBlbmNfZW5nOiBFbmNyeXB0aW9uIGVuZ2luZSBpbmZvIHN0cnVjdHVyZQorICogQGF1 dGhfZW5nOiBBdXRoZW50aWNhdGlvbiBlbmdpbmUgaW5mbyBzdHJ1Y3R1cmUKKyAqIEBhdXRoX2N0 cmw6IEF1dGhlbnRpY2F0aW9uIGNvbnRyb2wgd29yZAorICogQGhhc2hfc2l6ZTogU2l6ZSBvZiBE aWdlc3QKKyAqIEBlYWxnX2lkOiBFbmNyeXB0aW9uIEFsZ29yaXRobSBJRAorICogQGFhbGdfaWQ6 IEF1dGhlbnRpY2F0aW9uIGFsZ29yaXRobSBJRAorICogQG1jaV9lbmM6IE1vZGUgQ29udHJvbCBJ bnN0cnVjdGlvbiBmb3IgRW5jcnlwdGlvbiBhbGdvcml0aG0KKyAqIEBtY2lfZGVjOiBNb2RlIENv bnRyb2wgSW5zdHJ1Y3Rpb24gZm9yIERlY3J5cHRpb24KKyAqIEBpbnZfa2V5OiBXaGV0aGVyIHRo ZSBlbmNyeXB0aW9uIGFsZ29yaXRobSBkZW1hbmRzIGtleSBpbnZlcnNpb24KKyAqIEBrZXllZF9t YWM6IFdoZXRoZXIgdGhlIEF1dGhlbnRpY2F0aW9uIGFsZ29yaXRobSBoYXMgS2V5CisgKiBAcHJl cF9pb3BhZDogRnVuY3Rpb24gcG9pbnRlciB0byBnZW5lcmF0ZSBpbnRlcm1lZGlhdGUgaXBhZC9v cGFkCisgKi8KK3N0cnVjdCBhbGdvX2RhdGEgeworCXN0cnVjdCBzYV9lbmdfaW5mbyBlbmNfZW5n OworCXN0cnVjdCBzYV9lbmdfaW5mbyBhdXRoX2VuZzsKKwl1OCBhdXRoX2N0cmw7CisJdTggaGFz aF9zaXplOworCXU4IGVhbGdfaWQ7CisJdTggYWFsZ19pZDsKKwl1OCAqbWNpX2VuYzsKKwl1OCAq bWNpX2RlYzsKKwlib29sIGludl9rZXk7CisJYm9vbCBrZXllZF9tYWM7CisJdm9pZCAoKnByZXBf aW9wYWQpKGNvbnN0IHU4ICprZXksIHUxNiBrZXlfc3osIHUzMiAqaXBhZCwgdTMyICpvcGFkKTsK K307CisKKy8qKgorICogc3RydWN0IHNhX2FsZ190bXBsOiBBIGdlbmVyaWMgdGVtcGxhdGUgZW5j b21wYXNzaW5nIGNyeXB0by9hZWFkIGFsZ29yaXRobXMKKyAqIEBhbGc6IEEgdW5pb24gb2YgYWVh ZC9jcnlwdG8gYWxnb3JpdGhtIHR5cGUuCisgKiBAcmVnaXN0ZXJlZDogRmxhZyBpbmRpY2F0aW5n IGlmIHRoZSBjcnlwdG8gYWxnb3JpdGhtIGlzIGFscmVhZHkgcmVnaXN0ZXJlZAorICovCitzdHJ1 Y3Qgc2FfYWxnX3RtcGwgeworCXUzMiB0eXBlOwkJLyogQ1JZUFRPX0FMR19UWVBFIGZyb20gPGxp bnV4L2NyeXB0by5oPiAqLworCXVuaW9uIHsKKwkJc3RydWN0IGNyeXB0b19hbGcgY3J5cHRvOwor CQlzdHJ1Y3QgYWVhZF9hbGcgYWVhZDsKKwl9IGFsZzsKKwlpbnQgcmVnaXN0ZXJlZDsKK307CisK Ky8qKgorICogc3RydWN0IHNhX3J4X2RhdGE6IFJYIFBhY2tldCBtaXNjZWxsYW5lb3VzIGRhdGEg cGxhY2UgaG9sZGVyCisgKiBAcmVxOiBjcnlwdG8gcmVxdWVzdCBkYXRhIHBvaW50ZXIKKyAqIEBk ZGV2OiBETUEgZGV2aWNlIHBvaW50ZXIKKyAqIEB0eF9pbjogZG1hX2FzeW5jX3R4X2Rlc2NyaXB0 b3IgcG9pbnRlciBmb3IgcnggY2hhbm5lbAorICogQGVuYzogRmxhZyBpbmRpY2F0aW5nIGVpdGhl ciBlbmNyeXB0aW9uIG9yIGRlY3J5cHRpb24KKyAqLworc3RydWN0IHNhX3J4X2RhdGEgeworCXZv aWQgKnJlcTsKKwlzdHJ1Y3QgZGV2aWNlICpkZGV2OworCXN0cnVjdCBkbWFfYXN5bmNfdHhfZGVz Y3JpcHRvciAqdHhfaW47CisJdTggZW5jOworfTsKKworLyoKKyAqIE1vZGUgQ29udHJvbCBJbnN0 cnVjdGlvbnMgZm9yIHZhcmlvdXMgS2V5IGxlbmd0aHMgMTI4LCAxOTIsIDI1NgorICogRm9yIENC QyAoQ2lwaGVyIEJsb2NrIENoYWluaW5nKSBtb2RlIGZvciBlbmNyeXB0aW9uCisgKi8KK3N0YXRp YyB1OCBtY2lfY2JjX2VuY19hcnJheVszXVtNT0RFX0NPTlRST0xfQllURVNdID0geworCXsJMHgy MSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHgwYSwgMHhhYSwgMHg0YiwgMHg3ZSwgMHgwMCwK KwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJ MHgyMSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHg0YSwgMHhhYSwgMHg0YiwgMHg3ZSwgMHgw MCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAor CXsJMHgyMSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHg4YSwgMHhhYSwgMHg0YiwgMHg3ZSwg MHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9 LAorfTsKKworLyoKKyAqIE1vZGUgQ29udHJvbCBJbnN0cnVjdGlvbnMgZm9yIHZhcmlvdXMgS2V5 IGxlbmd0aHMgMTI4LCAxOTIsIDI1NgorICogRm9yIENCQyAoQ2lwaGVyIEJsb2NrIENoYWluaW5n KSBtb2RlIGZvciBkZWNyeXB0aW9uCisgKi8KK3N0YXRpYyB1OCBtY2lfY2JjX2RlY19hcnJheVsz XVtNT0RFX0NPTlRST0xfQllURVNdID0geworCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4MCwgMHg4 YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4NCwg MHg4YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4 OCwgMHg4YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorfTsKKworLyoKKyAqIFBlcmZvcm0g MTYgYnl0ZSBvciAxMjggYml0IHN3aXp6bGluZworICogVGhlIFNBMlVMIEV4cGVjdHMgdGhlIHNl Y3VyaXR5IGNvbnRleHQgdG8KKyAqIGJlIGluIGxpdHRsZSBFbmRpYW4gYW5kIHRoZSBidXMgd2lk dGggaXMgMTI4IGJpdHMgb3IgMTYgYnl0ZXMKKyAqIEhlbmNlIHN3YXAgMTYgYnl0ZXMgYXQgYSB0 aW1lIGZyb20gaGlnaGVyIHRvIGxvd2VyIGFkZHJlc3MKKyAqLworc3RhdGljIHZvaWQgc2Ffc3dp el8xMjgodTggKmluLCB1MTYgbGVuKQoreworCXU4IGRhdGFbMTZdOworCWludCBpLCBqOworCisJ Zm9yIChpID0gMDsgaSA8IGxlbjsgaSArPSAxNikgeworCQltZW1jcHkoZGF0YSwgJmluW2ldLCAx Nik7CisJCWZvciAoaiA9IDA7IGogPCAxNjsgaisrKQorCQkJaW5baSArIGpdID0gZGF0YVsxNSAt IGpdOworCX0KK30KKworLyogRGVyaXZlIHRoZSBpbnZlcnNlIGtleSB1c2VkIGluIEFFUy1DQkMg ZGVjcnlwdGlvbiBvcGVyYXRpb24gKi8KK3N0YXRpYyBpbmxpbmUgaW50IHNhX2Flc19pbnZfa2V5 KHU4ICppbnZfa2V5LCBjb25zdCB1OCAqa2V5LCB1MTYga2V5X3N6KQoreworCXN0cnVjdCBjcnlw dG9fYWVzX2N0eCBjdHg7CisJaW50IGtleV9wb3M7CisKKwlpZiAoY3J5cHRvX2Flc19leHBhbmRf a2V5KCZjdHgsIGtleSwga2V5X3N6KSkgeworCQlwcl9lcnIoIiVzOiBiYWQga2V5IGxlbiglZClc biIsIF9fZnVuY19fLCBrZXlfc3opOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBCYXNl ZCBjcnlwdG9fYWVzX2V4cGFuZF9rZXkgbG9naWMgKi8KKwlzd2l0Y2ggKGtleV9zeikgeworCWNh c2UgQUVTX0tFWVNJWkVfMTI4OgorCWNhc2UgQUVTX0tFWVNJWkVfMTkyOgorCQlrZXlfcG9zID0g a2V5X3N6ICsgMjQ7CisJCWJyZWFrOworCisJY2FzZSBBRVNfS0VZU0laRV8yNTY6CisJCWtleV9w b3MgPSBrZXlfc3ogKyAyNCAtIDQ7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcHJfZXJyKCIl czogYmFkIGtleSBsZW4oJWQpXG4iLCBfX2Z1bmNfXywga2V5X3N6KTsKKwkJcmV0dXJuIC1FSU5W QUw7CisJfQorCisJbWVtY3B5KGludl9rZXksICZjdHgua2V5X2VuY1trZXlfcG9zXSwga2V5X3N6 KTsKKwlyZXR1cm4gMDsKK30KKworLyogU2V0IFNlY3VyaXR5IGNvbnRleHQgZm9yIHRoZSBlbmNy eXB0aW9uIGVuZ2luZSAqLworc3RhdGljIGludCBzYV9zZXRfc2NfZW5jKHN0cnVjdCBhbGdvX2Rh dGEgKmFkLCBjb25zdCB1OCAqa2V5LCB1MTYga2V5X3N6LAorCQkJIHUxNiBhYWRfbGVuLCB1OCBl bmMsIHU4ICpzY19idWYpCit7CisJY29uc3QgdTggKm1jaSA9IE5VTEw7CisKKwkvKiBTZXQgRW5j cnlwdGlvbiBtb2RlIHNlbGVjdG9yIHRvIGNyeXB0byBwcm9jZXNzaW5nICovCisJc2NfYnVmWzBd ID0gU0FfQ1JZUFRPX1BST0NFU1NJTkc7CisKKwlpZiAoZW5jKQorCQltY2kgPSBhZC0+bWNpX2Vu YzsKKwllbHNlCisJCW1jaSA9IGFkLT5tY2lfZGVjOworCS8qIFNldCB0aGUgbW9kZSBjb250cm9s IGluc3RydWN0aW9ucyBpbiBzZWN1cml0eSBjb250ZXh0ICovCisJaWYgKG1jaSkKKwkJbWVtY3B5 KCZzY19idWZbMV0sIG1jaSwgTU9ERV9DT05UUk9MX0JZVEVTKTsKKworCS8qIEZvciBBRVMtQ0JD IGRlY3J5cHRpb24gZ2V0IHRoZSBpbnZlcnNlIGtleSAqLworCWlmIChhZC0+aW52X2tleSAmJiAh ZW5jKSB7CisJCWlmIChzYV9hZXNfaW52X2tleSgmc2NfYnVmW1NDX0VOQ19LRVlfT0ZGU0VUXSwg a2V5LCBrZXlfc3opKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJLyogRm9yIGFsbCBvdGhlciBjYXNl czoga2V5IGlzIHVzZWQgKi8KKwl9IGVsc2UgeworCQltZW1jcHkoJnNjX2J1ZltTQ19FTkNfS0VZ X09GRlNFVF0sIGtleSwga2V5X3N6KTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyogU2V0IFNl Y3VyaXR5IGNvbnRleHQgZm9yIHRoZSBhdXRoZW50aWNhdGlvbiBlbmdpbmUgKi8KK3N0YXRpYyB2 b2lkIHNhX3NldF9zY19hdXRoKHN0cnVjdCBhbGdvX2RhdGEgKmFkLCBjb25zdCB1OCAqa2V5LCB1 MTYga2V5X3N6LAorCQkJICAgdTggKnNjX2J1ZikKK3sKKwl1MzIgaXBhZFs2NF0sIG9wYWRbNjRd OworCisJLyogU2V0IEF1dGhlbnRpY2F0aW9uIG1vZGUgc2VsZWN0b3IgdG8gaGFzaCBwcm9jZXNz aW5nICovCisJc2NfYnVmWzBdID0gU0FfSEFTSF9QUk9DRVNTSU5HOworCS8qIEF1dGggU1cgY3Ry bCB3b3JkOiBiaXRbNl09MSAodXBsb2FkIGNvbXB1dGVkIGhhc2ggdG8gVExSIHNlY3Rpb24pICov CisJc2NfYnVmWzFdID0gU0FfVVBMT0FEX0hBU0hfVE9fVExSOworCXNjX2J1ZlsxXSB8PSBhZC0+ YXV0aF9jdHJsOworCisJLyogQ29weSB0aGUga2V5cyBvciBpcGFkL29wYWQgKi8KKwlpZiAoYWQt PmtleWVkX21hYykgeworCQlhZC0+cHJlcF9pb3BhZChrZXksIGtleV9zeiwgaXBhZCwgb3BhZCk7 CisJCS8qIENvcHkgaXBhZCB0byBBdXRoS2V5ICovCisJCW1lbWNweSgmc2NfYnVmWzMyXSwgaXBh ZCwgYWQtPmhhc2hfc2l6ZSk7CisJCS8qIENvcHkgb3BhZCB0byBBdXgtMSAqLworCQltZW1jcHko JnNjX2J1Zls2NF0sIG9wYWQsIGFkLT5oYXNoX3NpemUpOworCX0KK30KKworc3RhdGljIGlubGlu ZSB2b2lkIHNhX2NvcHlfaXYodTMyICpvdXQsIGNvbnN0IHU4ICppdiwgYm9vbCBzaXplMTYpCit7 CisJaW50IGo7CisKKwlmb3IgKGogPSAwOyBqIDwgKChzaXplMTYpID8gNCA6IDIpOyBqKyspIHsK KwkJKm91dCA9IGNwdV90b19iZTMyKCooKHUzMiAqKWl2KSk7CisJCWl2ICs9IDQ7CisJCW91dCsr OworCX0KK30KKworLyogRm9ybWF0IGdlbmVyYWwgY29tbWFuZCBsYWJlbCAqLworc3RhdGljIGlu dCBzYV9mb3JtYXRfY21kbF9nZW4oc3RydWN0IHNhX2NtZGxfY2ZnICpjZmcsIHU4ICpjbWRsLAor CQkJICAgICAgc3RydWN0IHNhX2NtZGxfdXBkX2luZm8gKnVwZF9pbmZvKQoreworCXU4IGVuY19v ZmZzZXQgPSAwLCBhdXRoX29mZnNldCA9IDAsIHRvdGFsID0gMDsKKwl1OCBlbmNfbmV4dF9lbmcg PSBTQV9FTkdfSURfT1VUUE9SVDI7CisJdTggYXV0aF9uZXh0X2VuZyA9IFNBX0VOR19JRF9PVVRQ T1JUMjsKKwl1MzIgKndvcmRfcHRyID0gKHUzMiAqKWNtZGw7CisJaW50IGk7CisKKwkvKiBDbGVh ciB0aGUgY29tbWFuZCBsYWJlbCAqLworCW1lbXplcm9fZXhwbGljaXQoY21kbCwgKFNBX01BWF9D TURMX1dPUkRTICogc2l6ZW9mKHUzMikpKTsKKworCS8qIEluaWlhbGl6ZSB0aGUgY29tbWFuZCB1 cGRhdGUgc3RydWN0dXJlICovCisJbWVtemVyb19leHBsaWNpdCh1cGRfaW5mbywgc2l6ZW9mKCp1 cGRfaW5mbykpOworCisJaWYgKGNmZy0+ZW5jMXN0KSB7CisJCWlmIChjZmctPmVuY19lbmdfaWQg IT0gU0FfRU5HX0lEX05PTkUpCisJCQlhdXRoX29mZnNldCA9IFNBX0NNRExfSEVBREVSX1NJWkVf QllURVM7CisKKwkJaWYgKGNmZy0+aXZfc2l6ZSkKKwkJCWF1dGhfb2Zmc2V0ICs9IGNmZy0+aXZf c2l6ZTsKKworCQlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAhPSBTQV9FTkdfSURfTk9ORSkKKwkJCWVu Y19uZXh0X2VuZyA9IGNmZy0+YXV0aF9lbmdfaWQ7CisJCWVsc2UKKwkJCWVuY19uZXh0X2VuZyA9 IFNBX0VOR19JRF9PVVRQT1JUMjsKKwl9IGVsc2UgeworCQlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAh PSBTQV9FTkdfSURfTk9ORSkKKwkJCWVuY19vZmZzZXQgPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZ VEVTOworCisJCWlmIChjZmctPmF1dGhfc3Via2V5X2xlbikKKwkJCWVuY19vZmZzZXQgKz0gY2Zn LT5hdXRoX3N1YmtleV9sZW47CisKKwkJaWYgKGNmZy0+ZW5jX2VuZ19pZCAhPSBTQV9FTkdfSURf Tk9ORSkKKwkJCWF1dGhfbmV4dF9lbmcgPSBjZmctPmVuY19lbmdfaWQ7CisJCWVsc2UKKwkJCWF1 dGhfbmV4dF9lbmcgPSBTQV9FTkdfSURfT1VUUE9SVDI7CisJfQorCisJaWYgKGNmZy0+ZW5jX2Vu Z19pZCAhPSBTQV9FTkdfSURfTk9ORSkgeworCQl1cGRfaW5mby0+ZmxhZ3MgfD0gU0FfQ01ETF9V UERfRU5DOworCQl1cGRfaW5mby0+ZW5jX3NpemUuaW5kZXggPSBlbmNfb2Zmc2V0ID4+IDI7CisJ CXVwZF9pbmZvLT5lbmNfb2Zmc2V0LmluZGV4ID0gdXBkX2luZm8tPmVuY19zaXplLmluZGV4ICsg MTsKKwkJLyogRW5jcnlwdGlvbiBjb21tYW5kIGxhYmVsICovCisJCWNtZGxbZW5jX29mZnNldCAr IFNBX0NNRExfT0ZGU0VUX05FU0NdID0gZW5jX25leHRfZW5nOworCisJCS8qIEVuY3J5cHRpb24g bW9kZXMgcmVxdWlyaW5nIElWICovCisJCWlmIChjZmctPml2X3NpemUpIHsKKwkJCXVwZF9pbmZv LT5mbGFncyB8PSBTQV9DTURMX1VQRF9FTkNfSVY7CisJCQl1cGRfaW5mby0+ZW5jX2l2LmluZGV4 ID0KKwkJCQkoZW5jX29mZnNldCArIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMpID4+IDI7CisJ CQl1cGRfaW5mby0+ZW5jX2l2LnNpemUgPSBjZmctPml2X3NpemU7CisKKwkJCWNtZGxbZW5jX29m ZnNldCArIFNBX0NNRExfT0ZGU0VUX0xBQkVMX0xFTl0gPQorCQkJCVNBX0NNRExfSEVBREVSX1NJ WkVfQllURVMgKyBjZmctPml2X3NpemU7CisKKwkJCWNtZGxbZW5jX29mZnNldCArIFNBX0NNRExf T0ZGU0VUX09QVElPTl9DVFJMMV0gPQorCQkJCShTQV9DVFhfRU5DX0FVWDJfT0ZGU0VUIHwgKGNm Zy0+aXZfc2l6ZSA+PiAzKSk7CisJCQllbmNfb2Zmc2V0ICs9IFNBX0NNRExfSEVBREVSX1NJWkVf QllURVMgKyBjZmctPml2X3NpemU7CisJCX0gZWxzZSB7CisJCQljbWRsW2VuY19vZmZzZXQgKyBT QV9DTURMX09GRlNFVF9MQUJFTF9MRU5dID0KKwkJCQkJCVNBX0NNRExfSEVBREVSX1NJWkVfQllU RVM7CisJCQllbmNfb2Zmc2V0ICs9IFNBX0NNRExfSEVBREVSX1NJWkVfQllURVM7CisJCX0KKwl9 CisKKwlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAhPSBTQV9FTkdfSURfTk9ORSkgeworCQl1cGRfaW5m by0+ZmxhZ3MgfD0gU0FfQ01ETF9VUERfQVVUSDsKKwkJdXBkX2luZm8tPmF1dGhfc2l6ZS5pbmRl eCA9IGF1dGhfb2Zmc2V0ID4+IDI7CisJCXVwZF9pbmZvLT5hdXRoX29mZnNldC5pbmRleCA9IHVw ZF9pbmZvLT5hdXRoX3NpemUuaW5kZXggKyAxOworCQljbWRsW2F1dGhfb2Zmc2V0ICsgU0FfQ01E TF9PRkZTRVRfTkVTQ10gPSBhdXRoX25leHRfZW5nOworCisJCS8qIEFsZ29yaXRobSB3aXRoIHN1 YmtleXMgKi8KKwkJaWYgKGNmZy0+YWFsZyA9PSBTQV9BQUxHX0lEX0FFU19YQ0JDIHx8CisJCSAg ICBjZmctPmFhbGcgPT0gU0FfQUFMR19JRF9DTUFDKSB7CisJCQl1cGRfaW5mby0+ZmxhZ3MgfD0g U0FfQ01ETF9VUERfQVVYX0tFWTsKKwkJCXVwZF9pbmZvLT5hdXhfa2V5X2luZm8uaW5kZXggPQor CQkJCShhdXRoX29mZnNldCArIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMpID4+IDI7CisJCQlj bWRsW2F1dGhfb2Zmc2V0ICsgU0FfQ01ETF9PRkZTRVRfTEFCRUxfTEVOXSA9CisJCQkJCQlTQV9D TURMX0hFQURFUl9TSVpFX0JZVEVTICsKKwkJCQkJCQljZmctPmF1dGhfc3Via2V5X2xlbjsKKwkJ CWNtZGxbYXV0aF9vZmZzZXQgKyBTQV9DTURMX09GRlNFVF9PUFRJT05fQ1RSTDFdID0KKwkJCQkJ CShTQV9DVFhfRU5DX0FVWDFfT0ZGU0VUIHwKKwkJCQkJCShjZmctPmF1dGhfc3Via2V5X2xlbiAg Pj4gMykpOworCisJCQlhdXRoX29mZnNldCArPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVTICsK KwkJCQkJCQljZmctPmF1dGhfc3Via2V5X2xlbjsKKwkJfSBlbHNlIHsKKwkJCWNtZGxbYXV0aF9v ZmZzZXQgKyBTQV9DTURMX09GRlNFVF9MQUJFTF9MRU5dID0KKwkJCQkJCVNBX0NNRExfSEVBREVS X1NJWkVfQllURVM7CisJCQlhdXRoX29mZnNldCArPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVT OworCQl9CisJfQorCisJaWYgKGNmZy0+ZW5jMXN0KQorCQl0b3RhbCA9IGF1dGhfb2Zmc2V0Owor CWVsc2UKKwkJdG90YWwgPSBlbmNfb2Zmc2V0OworCisJdG90YWwgPSByb3VuZHVwKHRvdGFsLCA4 KTsKKworCWZvciAoaSA9IDA7IGkgPCB0b3RhbCAvIDQ7IGkrKykKKwkJd29yZF9wdHJbaV0gPSBi ZTMyX3RvX2NwdSh3b3JkX3B0cltpXSk7CisKKwlyZXR1cm4gdG90YWw7Cit9CisKKy8qIFVwZGF0 ZSBDb21tYW5kIGxhYmVsICovCitzdGF0aWMgaW5saW5lIHZvaWQKK3NhX3VwZGF0ZV9jbWRsKHN0 cnVjdCBkZXZpY2UgKmRldiwgdTggZW5jX29mZnNldCwgdTE2IGVuY19zaXplLCB1OCAqZW5jX2l2 LAorCSAgICAgICB1OCBhdXRoX29mZnNldCwgdTE2IGF1dGhfc2l6ZSwgdTggKmF1dGhfaXYsIHU4 IGFhZF9zaXplLAorCSAgICAgICB1OCAqYWFkLCBzdHJ1Y3Qgc2FfY21kbF91cGRfaW5mbyAqdXBk X2luZm8sIHUzMiAqY21kbCkKK3sKKwlpbnQgaSA9IDAsIGo7CisKKwlpZiAodXBkX2luZm8tPnN1 Ym1vZGUgIT0gU0FfTU9ERV9HRU4pIHsKKwkJZGV2X2VycihkZXYsICJ1bnN1cHBvcnRlZCBtb2Rl KCVkKVxuIiwgdXBkX2luZm8tPnN1Ym1vZGUpOworCQlyZXR1cm47CisJfQorCisJaWYgKGxpa2Vs eSh1cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9FTkMpKSB7CisJCWNtZGxbdXBkX2luZm8t PmVuY19zaXplLmluZGV4XSAmPSB+U0FfQ01ETF9QQVlMT0FEX0xFTkdUSF9NQVNLOworCQljbWRs W3VwZF9pbmZvLT5lbmNfc2l6ZS5pbmRleF0gfD0gZW5jX3NpemU7CisJCWNtZGxbdXBkX2luZm8t PmVuY19vZmZzZXQuaW5kZXhdICY9CisJCQkJCQl+U0FfQ01ETF9TT1BfQllQQVNTX0xFTl9NQVNL OworCQljbWRsW3VwZF9pbmZvLT5lbmNfb2Zmc2V0LmluZGV4XSB8PQorCQkJKCh1MzIpZW5jX29m ZnNldCA8PCBfX2ZmcyhTQV9DTURMX1NPUF9CWVBBU1NfTEVOX01BU0spKTsKKworCQlpZiAobGlr ZWx5KHVwZF9pbmZvLT5mbGFncyAmIFNBX0NNRExfVVBEX0VOQ19JVikpIHsKKwkJCXUzMiAqZGF0 YSA9ICZjbWRsW3VwZF9pbmZvLT5lbmNfaXYuaW5kZXhdOworCisJCQlmb3IgKGogPSAwOyBpIDwg dXBkX2luZm8tPmVuY19pdi5zaXplOyBpICs9IDQsIGorKykgeworCQkJCWRhdGFbal0gPSBjcHVf dG9fYmUzMigqKCh1MzIgKillbmNfaXYpKTsKKwkJCQllbmNfaXYgKz0gNDsKKwkJCX0KKwkJfQor CX0KKworCWlmIChsaWtlbHkodXBkX2luZm8tPmZsYWdzICYgU0FfQ01ETF9VUERfQVVUSCkpIHsK KwkJY21kbFt1cGRfaW5mby0+YXV0aF9zaXplLmluZGV4XSAmPSB+U0FfQ01ETF9QQVlMT0FEX0xF TkdUSF9NQVNLOworCQljbWRsW3VwZF9pbmZvLT5hdXRoX3NpemUuaW5kZXhdIHw9IGF1dGhfc2l6 ZTsKKwkJY21kbFt1cGRfaW5mby0+YXV0aF9vZmZzZXQuaW5kZXhdICY9CisJCQkJCQl+U0FfQ01E TF9TT1BfQllQQVNTX0xFTl9NQVNLOworCQljbWRsW3VwZF9pbmZvLT5hdXRoX29mZnNldC5pbmRl eF0gfD0gKCh1MzIpYXV0aF9vZmZzZXQgPDwKKwkJCQkJX19mZnMoU0FfQ01ETF9TT1BfQllQQVNT X0xFTl9NQVNLKSk7CisJCWlmICh1cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9BVVRIX0lW KSB7CisJCQlzYV9jb3B5X2l2KCZjbWRsW3VwZF9pbmZvLT5hdXRoX2l2LmluZGV4XSwgYXV0aF9p diwKKwkJCQkgICAodXBkX2luZm8tPmF1dGhfaXYuc2l6ZSA+IDgpKTsKKwkJfQorCisJCWlmICh1 cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9BVVhfS0VZKSB7CisJCQlpbnQgb2Zmc2V0ID0g KGF1dGhfc2l6ZSAmIDB4RikgPyA0IDogMDsKKworCQkJbWVtY3B5KCZjbWRsW3VwZF9pbmZvLT5h dXhfa2V5X2luZm8uaW5kZXhdLAorCQkJICAgICAgICZ1cGRfaW5mby0+YXV4X2tleVtvZmZzZXRd LCAxNik7CisJCX0KKwl9Cit9CisKKy8qIEZvcm1hdCBTV0lORk8gd29yZHMgdG8gYmUgc2VudCB0 byBTQSAqLworc3RhdGljCit2b2lkIHNhX3NldF9zd2luZm8odTggZW5nX2lkLCB1MTYgc2NfaWQs IGRtYV9hZGRyX3Qgc2NfcGh5cywKKwkJICAgdTggY21kbF9wcmVzZW50LCB1OCBjbWRsX29mZnNl dCwgdTggZmxhZ3MsCisJCSAgIHU4IGhhc2hfc2l6ZSwgdTMyICpzd2luZm8pCit7CisJc3dpbmZv WzBdID0gc2NfaWQ7CisJc3dpbmZvWzBdIHw9IChmbGFncyA8PCBfX2ZmcyhTQV9TVzBfRkxBR1Nf TUFTSykpOworCWlmIChsaWtlbHkoY21kbF9wcmVzZW50KSkKKwkJc3dpbmZvWzBdIHw9ICgoY21k bF9vZmZzZXQgfCBTQV9TVzBfQ01ETF9QUkVTRU5UKSA8PAorCQkJCQkJX19mZnMoU0FfU1cwX0NN RExfSU5GT19NQVNLKSk7CisJc3dpbmZvWzBdIHw9IChlbmdfaWQgPDwgX19mZnMoU0FfU1cwX0VO R19JRF9NQVNLKSk7CisKKwlzd2luZm9bMF0gfD0gU0FfU1cwX0RFU1RfSU5GT19QUkVTRU5UOwor CXN3aW5mb1sxXSA9ICh1MzIpKHNjX3BoeXMgJiAweEZGRkZGRkZGVUxMKTsKKwlzd2luZm9bMl0g PSAodTMyKSgoc2NfcGh5cyAmIDB4RkZGRkZGRkYwMDAwMDAwMFVMTCkgPj4gMzIpOworCXN3aW5m b1syXSB8PSAoaGFzaF9zaXplIDw8IF9fZmZzKFNBX1NXMl9FR1JFU1NfTEVOR1RIKSk7Cit9CisK Ky8qIER1bXAgdGhlIHNlY3VyaXR5IGNvbnRleHQgKi8KK3N0YXRpYyB2b2lkIHNhX2R1bXBfc2Mo dTggKmJ1ZiwgZG1hX2FkZHJfdCBkbWFfYWRkcikKK3sKKyNpZmRlZiBERUJVRworCWRldl9pbmZv KHNhX2szX2RldiwgIlNlY3VyaXR5IGNvbnRleHQgZHVtcDo6IDB4JXBhZFxuIiwgJmRtYV9hZGRy KTsKKwlwcmludF9oZXhfZHVtcChLRVJOX0NPTlQsICIiLCBEVU1QX1BSRUZJWF9PRkZTRVQsCisJ CSAgICAgICAxNiwgMSwgYnVmLCBTQV9DVFhfTUFYX1NaLCBmYWxzZSk7CisjZW5kaWYKK30KKwor c3RhdGljCitpbnQgc2FfaW5pdF9zYyhzdHJ1Y3Qgc2FfY3R4X2luZm8gKmN0eCwgY29uc3QgdTgg KmVuY19rZXksCisJICAgICAgIHUxNiBlbmNfa2V5X3N6LCBjb25zdCB1OCAqYXV0aF9rZXksIHUx NiBhdXRoX2tleV9zeiwKKwkgICAgICAgc3RydWN0IGFsZ29fZGF0YSAqYWQsIHU4IGVuYywgdTMy ICpzd2luZm8sIGJvb2wgYXV0aF9yZXEpCit7CisJaW50IHVzZV9lbmMgPSAwOworCWludCBlbmNf c2Nfb2Zmc2V0LCBhdXRoX3NjX29mZnNldDsKKwl1OCAqc2NfYnVmID0gY3R4LT5zYzsKKwl1MTYg c2NfaWQgPSBjdHgtPnNjX2lkOworCXUxNiBhYWRfbGVuID0gMDsJLyogQ3VycmVudGx5IG5vdCBz dXBwb3J0aW5nIEFFQUQgYWxnbyAqLworCXU4IGZpcnN0X2VuZ2luZTsKKworCW1lbXplcm9fZXhw bGljaXQoc2NfYnVmLCBTQV9DVFhfTUFYX1NaKTsKKworCWlmIChhZC0+YXV0aF9lbmcuZW5nX2lk IDw9IFNBX0VOR19JRF9FTTIgfHwgIWF1dGhfcmVxKQorCQl1c2VfZW5jID0gMTsKKworCS8qIERl dGVybWluZSB0aGUgb3JkZXIgb2YgZW5jcnlwdGlvbiAmIEF1dGhlbnRpY2F0aW9uIGNvbnRleHRz ICovCisJaWYgKGVuYyB8fCAhdXNlX2VuYykgeworCQlpZiAoYXV0aF9yZXEpIHsKKwkJCWVuY19z Y19vZmZzZXQgPSBTQV9DVFhfUEhQX1BFX0NUWF9TWjsKKwkJCWF1dGhfc2Nfb2Zmc2V0ID0gZW5j X3NjX29mZnNldCArIGFkLT5lbmNfZW5nLnNjX3NpemU7CisJCX0gZWxzZSB7CisJCQllbmNfc2Nf b2Zmc2V0ID0gU0FfQ1RYX1BIUF9QRV9DVFhfU1o7CisJCX0KKwl9IGVsc2UgeworCQlhdXRoX3Nj X29mZnNldCA9IFNBX0NUWF9QSFBfUEVfQ1RYX1NaOworCQllbmNfc2Nfb2Zmc2V0ID0gYXV0aF9z Y19vZmZzZXQgKyBhZC0+YXV0aF9lbmcuc2Nfc2l6ZTsKKwl9CisKKwkvKiBTQ0NUTCBPd25lciBp bmZvOiAwPWhvc3QsIDE9Q1BfQUNFICovCisJc2NfYnVmW1NBX0NUWF9TQ0NUTF9PV05FUl9PRkZT RVRdID0gMDsKKwkvKiBTQ0NUTCBGL0UgY29udHJvbCAqLworCWlmIChhdXRoX3JlcSkKKwkJc2Nf YnVmWzFdID0gU0FfU0NDVExfRkVfQVVUSF9FTkM7CisJZWxzZQorCQlzY19idWZbMV0gPSBTQV9T Q0NUTF9GRV9FTkM7CisJbWVtY3B5KCZzY19idWZbMl0sICZzY19pZCwgMik7CisJc2NfYnVmWzRd ID0gMHgwOworCXNjX2J1Zls1XSA9IFBSSVZfSUQ7CisJc2NfYnVmWzZdID0gUFJJVjsKKwlzY19i dWZbN10gPSAweDA7CisKKwkvKiBJbml0aWFsaXplIHRoZSByZXN0IG9mIFBIUCBjb250ZXh0ICov CisJbWVtemVyb19leHBsaWNpdChzY19idWYgKyBTQV9TQ0NUTF9TWiwgU0FfQ1RYX1BIUF9QRV9D VFhfU1ogLQorCQkJIFNBX1NDQ1RMX1NaKTsKKworCS8qIFByZXBhcmUgY29udGV4dCBmb3IgZW5j cnlwdGlvbiBlbmdpbmUgKi8KKwlpZiAoYWQtPmVuY19lbmcuc2Nfc2l6ZSkgeworCQlpZiAoc2Ff c2V0X3NjX2VuYyhhZCwgZW5jX2tleSwgZW5jX2tleV9zeiwgYWFkX2xlbiwKKwkJCQkgIGVuYywg JnNjX2J1ZltlbmNfc2Nfb2Zmc2V0XSkpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBQ cmVwYXJlIGNvbnRleHQgZm9yIGF1dGhlbnRpY2F0aW9uIGVuZ2luZSAqLworCWlmIChhZC0+YXV0 aF9lbmcuc2Nfc2l6ZSkgeworCQlpZiAodXNlX2VuYykgeworCQkJaWYgKHNhX3NldF9zY19lbmMo YWQsIGF1dGhfa2V5LCBhdXRoX2tleV9zeiwKKwkJCQkJICBhYWRfbGVuLCAwLCAmc2NfYnVmW2F1 dGhfc2Nfb2Zmc2V0XSkpCisJCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0gZWxzZSB7CisJCQlzYV9z ZXRfc2NfYXV0aChhZCwgYXV0aF9rZXksIGF1dGhfa2V5X3N6LAorCQkJCSAgICAgICAmc2NfYnVm W2F1dGhfc2Nfb2Zmc2V0XSk7CisJCX0KKwl9CisKKwkvKiBTZXQgdGhlIG93bmVyc2hpcCBvZiBj b250ZXh0IHRvIENQX0FDRSAqLworCXNjX2J1ZltTQV9DVFhfU0NDVExfT1dORVJfT0ZGU0VUXSA9 IDB4ODA7CisKKwkvKiBzd2l6emxlIHRoZSBzZWN1cml0eSBjb250ZXh0ICovCisJc2Ffc3dpel8x Mjgoc2NfYnVmLCBTQV9DVFhfTUFYX1NaKTsKKwkvKiBTZXR1cCBTV0lORk8gKi8KKwlpZiAoIWF1 dGhfcmVxKQorCQlmaXJzdF9lbmdpbmUgPSBhZC0+ZW5jX2VuZy5lbmdfaWQ7CisJZWxzZQorCQlm aXJzdF9lbmdpbmUgPSBlbmMgPyBhZC0+ZW5jX2VuZy5lbmdfaWQgOiBhZC0+YXV0aF9lbmcuZW5n X2lkOworCisJaWYgKGF1dGhfcmVxKSB7CisJCWlmICghYWQtPmhhc2hfc2l6ZSkKKwkJCXJldHVy biAtRUlOVkFMOworCQkvKiBSb3VuZCB1cCB0aGUgdGFnIHNpemUgdG8gbXVsdGlwbGUgb2YgNCAq LworCQlhZC0+aGFzaF9zaXplID0gcm91bmR1cChhZC0+aGFzaF9zaXplLCA4KTsKKwl9CisKKwlz YV9zZXRfc3dpbmZvKGZpcnN0X2VuZ2luZSwgY3R4LT5zY19pZCwgY3R4LT5zY19waHlzLCAxLCAw LAorCQkgICAgICBTQV9TV19JTkZPX0ZMQUdfRVZJQ1QsIGFkLT5oYXNoX3NpemUsIHN3aW5mbyk7 CisKKwlzYV9kdW1wX3NjKHNjX2J1ZiwgY3R4LT5zY19waHlzKTsKKworCXJldHVybiAwOworfQor CisvKiBGcmVlIHRoZSBwZXIgZGlyZWN0aW9uIGNvbnRleHQgbWVtb3J5ICovCitzdGF0aWMgdm9p ZCBzYV9mcmVlX2N0eF9pbmZvKHN0cnVjdCBzYV9jdHhfaW5mbyAqY3R4LAorCQkJICAgICBzdHJ1 Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEpCit7CisJdW5zaWduZWQgbG9uZyBibjsKKworCWJuID0g Y3R4LT5zY19pZCAtIGRhdGEtPnNjX2lkX3N0YXJ0OworCXNwaW5fbG9jaygmZGF0YS0+c2NpZF9s b2NrKTsKKwlfX2NsZWFyX2JpdChibiwgZGF0YS0+Y3R4X2JtKTsKKwlkYXRhLT5zY19pZC0tOwor CXNwaW5fdW5sb2NrKCZkYXRhLT5zY2lkX2xvY2spOworCisJaWYgKGN0eC0+c2MpIHsKKwkJZG1h X3Bvb2xfZnJlZShkYXRhLT5zY19wb29sLCBjdHgtPnNjLCBjdHgtPnNjX3BoeXMpOworCQljdHgt PnNjID0gTlVMTDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgc2FfaW5pdF9jdHhfaW5mbyhzdHJ1Y3Qg c2FfY3R4X2luZm8gKmN0eCwKKwkJCSAgICBzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEpCit7 CisJdW5zaWduZWQgbG9uZyBibjsKKwlpbnQgZXJyOworCisJc3Bpbl9sb2NrKCZkYXRhLT5zY2lk X2xvY2spOworCWJuID0gZmluZF9maXJzdF96ZXJvX2JpdChkYXRhLT5jdHhfYm0sIFNBX01BWF9O VU1fQ1RYKTsKKwlfX3NldF9iaXQoYm4sIGRhdGEtPmN0eF9ibSk7CisJZGF0YS0+c2NfaWQrKzsK KwlzcGluX3VubG9jaygmZGF0YS0+c2NpZF9sb2NrKTsKKworCWN0eC0+c2NfaWQgPSAodTE2KShk YXRhLT5zY19pZF9zdGFydCArIGJuKTsKKworCWN0eC0+c2MgPSBkbWFfcG9vbF9hbGxvYyhkYXRh LT5zY19wb29sLCBHRlBfS0VSTkVMLCAmY3R4LT5zY19waHlzKTsKKwlpZiAoIWN0eC0+c2MpIHsK KwkJZGV2X2VycigmZGF0YS0+cGRldi0+ZGV2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIFNDIG1lbW9y eVxuIik7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gc2NpZF9yb2xsYmFjazsKKwl9CisKKwly ZXR1cm4gMDsKKworc2NpZF9yb2xsYmFjazoKKwlzcGluX2xvY2soJmRhdGEtPnNjaWRfbG9jayk7 CisJX19jbGVhcl9iaXQoYm4sIGRhdGEtPmN0eF9ibSk7CisJZGF0YS0+c2NfaWQtLTsKKwlzcGlu X3VubG9jaygmZGF0YS0+c2NpZF9sb2NrKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB2 b2lkIHNhX2Flc19jcmFfZXhpdChzdHJ1Y3QgY3J5cHRvX3RmbSAqdGZtKQoreworCXN0cnVjdCBj cnlwdG9fYWxnICphbGcgPSB0Zm0tPl9fY3J0X2FsZzsKKwlzdHJ1Y3Qgc2FfdGZtX2N0eCAqY3R4 ID0gY3J5cHRvX3RmbV9jdHgodGZtKTsKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEgPSBk ZXZfZ2V0X2RydmRhdGEoc2FfazNfZGV2KTsKKworCWRldl9kYmcoc2FfazNfZGV2LCAiJXMoMHgl cCkgc2MtaWRzKDB4JXgoMHglcGFkKSwgMHgleCgweCVwYWQpKVxuIiwKKwkJX19mdW5jX18sIHRm bSwgY3R4LT5lbmMuc2NfaWQsICZjdHgtPmVuYy5zY19waHlzLAorCQljdHgtPmRlYy5zY19pZCwg JmN0eC0+ZGVjLnNjX3BoeXMpOworCisJaWYgKChhbGctPmNyYV9mbGFncyAmIENSWVBUT19BTEdf VFlQRV9BQkxLQ0lQSEVSKQorCSAgICA9PSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUikgewor CQlzYV9mcmVlX2N0eF9pbmZvKCZjdHgtPmVuYywgZGF0YSk7CisJCXNhX2ZyZWVfY3R4X2luZm8o JmN0eC0+ZGVjLCBkYXRhKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgc2FfYWVzX2NyYV9pbml0KHN0 cnVjdCBjcnlwdG9fdGZtICp0Zm0pCit7CisJc3RydWN0IHNhX3RmbV9jdHggKmN0eCA9IGNyeXB0 b190Zm1fY3R4KHRmbSk7CisJc3RydWN0IGNyeXB0b19hbGcgKmFsZyA9IHRmbS0+X19jcnRfYWxn OworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShzYV9rM19k ZXYpOworCWludCByZXQ7CisKKwlpZiAoKGFsZy0+Y3JhX2ZsYWdzICYgQ1JZUFRPX0FMR19UWVBF X01BU0spID09CisJICAgIENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSKSB7CisJCW1lbXplcm9f ZXhwbGljaXQoY3R4LCBzaXplb2YoKmN0eCkpOworCQljdHgtPmRldl9kYXRhID0gZGF0YTsKKwor CQlyZXQgPSBzYV9pbml0X2N0eF9pbmZvKCZjdHgtPmVuYywgZGF0YSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQlyZXQgPSBzYV9pbml0X2N0eF9pbmZvKCZjdHgtPmRlYywgZGF0YSk7 CisJCWlmIChyZXQpIHsKKwkJCXNhX2ZyZWVfY3R4X2luZm8oJmN0eC0+ZW5jLCBkYXRhKTsKKwkJ CXJldHVybiByZXQ7CisJCX0KKwl9CisKKwlkZXZfZGJnKHNhX2szX2RldiwgIiVzKDB4JXApIHNj LWlkcygweCV4KDB4JXBhZCksIDB4JXgoMHglcGFkKSlcbiIsCisJCV9fZnVuY19fLCB0Zm0sIGN0 eC0+ZW5jLnNjX2lkLCAmY3R4LT5lbmMuc2NfcGh5cywKKwkJY3R4LT5kZWMuc2NfaWQsICZjdHgt PmRlYy5zY19waHlzKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV9hZXNfc2V0a2V5 KHN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAqdGZtLCBjb25zdCB1OCAqa2V5LAorCQkJIHVuc2ln bmVkIGludCBrZXlsZW4sIHN0cnVjdCBhbGdvX2RhdGEgKmFkKQoreworCXN0cnVjdCBzYV90Zm1f Y3R4ICpjdHggPSBjcnlwdG9fYWJsa2NpcGhlcl9jdHgodGZtKTsKKworCWNvbnN0IGNoYXIgKmNy YV9uYW1lOworCWludCBjbWRsX2xlbjsKKwlzdHJ1Y3Qgc2FfY21kbF9jZmcgY2ZnOworCisJaWYg KGtleWxlbiAhPSBBRVNfS0VZU0laRV8xMjggJiYga2V5bGVuICE9IEFFU19LRVlTSVpFXzE5MiAm JgorCSAgICBrZXlsZW4gIT0gQUVTX0tFWVNJWkVfMjU2KQorCQlyZXR1cm4gLUVJTlZBTDsKKwor CWNyYV9uYW1lID0gY3J5cHRvX3RmbV9hbGdfbmFtZSgmdGZtLT5iYXNlKTsKKworCW1lbXplcm9f ZXhwbGljaXQoJmNmZywgc2l6ZW9mKGNmZykpOworCWNmZy5lbmMxc3QgPSAxOworCWNmZy5lbmNf ZW5nX2lkID0gYWQtPmVuY19lbmcuZW5nX2lkOworCWNmZy5pdl9zaXplID0gY3J5cHRvX2FibGtj aXBoZXJfaXZzaXplKHRmbSk7CisJY2ZnLmF1dGhfZW5nX2lkID0gU0FfRU5HX0lEX05PTkU7CisJ Y2ZnLmF1dGhfc3Via2V5X2xlbiA9IDA7CisKKwkvKiBTZXR1cCBFbmNyeXB0aW9uIFNlY3VyaXR5 IENvbnRleHQgJiBDb21tYW5kIGxhYmVsIHRlbXBsYXRlICovCisJaWYgKHNhX2luaXRfc2MoJmN0 eC0+ZW5jLCBrZXksIGtleWxlbiwKKwkJICAgICAgIE5VTEwsIDAsIGFkLCAxLCAmY3R4LT5lbmMu ZXBpYlsxXSwgZmFsc2UpKQorCQlnb3RvIGJhZGtleTsKKworCWNtZGxfbGVuID0gc2FfZm9ybWF0 X2NtZGxfZ2VuKCZjZmcsCisJCQkJICAgICAgKHU4ICopY3R4LT5lbmMuY21kbCwKKwkJCQkgICAg ICAmY3R4LT5lbmMuY21kbF91cGRfaW5mbyk7CisJaWYgKGNtZGxfbGVuIDw9IDAgfHwgKGNtZGxf bGVuID4gU0FfTUFYX0NNRExfV09SRFMgKiBzaXplb2YodTMyKSkpCisJCWdvdG8gYmFka2V5Owor CisJY3R4LT5lbmMuY21kbF9zaXplID0gY21kbF9sZW47CisKKwkvKiBTZXR1cCBEZWNyeXB0aW9u IFNlY3VyaXR5IENvbnRleHQgJiBDb21tYW5kIGxhYmVsIHRlbXBsYXRlICovCisJaWYgKHNhX2lu aXRfc2MoJmN0eC0+ZGVjLCBrZXksIGtleWxlbiwKKwkJICAgICAgIE5VTEwsIDAsIGFkLCAwLCAm Y3R4LT5kZWMuZXBpYlsxXSwgZmFsc2UpKQorCQlnb3RvIGJhZGtleTsKKworCWNmZy5lbmMxc3Qg PSAwOworCWNmZy5lbmNfZW5nX2lkID0gYWQtPmVuY19lbmcuZW5nX2lkOworCWNmZy5hdXRoX2Vu Z19pZCA9IFNBX0VOR19JRF9OT05FOworCWNmZy5hdXRoX3N1YmtleV9sZW4gPSAwOworCWNtZGxf bGVuID0gc2FfZm9ybWF0X2NtZGxfZ2VuKCZjZmcsICh1OCAqKWN0eC0+ZGVjLmNtZGwsCisJCQkJ ICAgICAgJmN0eC0+ZGVjLmNtZGxfdXBkX2luZm8pOworCisJaWYgKGNtZGxfbGVuIDw9IDAgfHwg KGNtZGxfbGVuID4gU0FfTUFYX0NNRExfV09SRFMgKiBzaXplb2YodTMyKSkpCisJCWdvdG8gYmFk a2V5OworCisJY3R4LT5kZWMuY21kbF9zaXplID0gY21kbF9sZW47CisKKwlrZnJlZShhZCk7CisK KwlyZXR1cm4gMDsKKworYmFka2V5OgorCWRldl9lcnIoc2FfazNfZGV2LCAiJXM6IGJhZGtleVxu IiwgX19mdW5jX18pOworCXJldHVybiAtRUlOVkFMOworfQorCitzdGF0aWMgaW50IHNhX2Flc19j YmNfc2V0a2V5KHN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAqdGZtLCBjb25zdCB1OCAqa2V5LAor CQkJICAgICB1bnNpZ25lZCBpbnQga2V5bGVuKQoreworCXN0cnVjdCBhbGdvX2RhdGEgKmFkID0g a3phbGxvYyhzaXplb2YoKmFkKSwgR0ZQX0tFUk5FTCk7CisJLyogQ29udmVydCB0aGUga2V5IHNp emUgKDE2LzI0LzMyKSB0byB0aGUga2V5IHNpemUgaW5kZXggKDAvMS8yKSAqLworCWludCBrZXlf aWR4ID0gKGtleWxlbiA+PiAzKSAtIDI7CisKKwlhZC0+ZW5jX2VuZy5lbmdfaWQgPSBTQV9FTkdf SURfRU0xOworCWFkLT5lbmNfZW5nLnNjX3NpemUgPSBTQV9DVFhfRU5DX1RZUEUxX1NaOworCWFk LT5hdXRoX2VuZy5lbmdfaWQgPSBTQV9FTkdfSURfTk9ORTsKKwlhZC0+YXV0aF9lbmcuc2Nfc2l6 ZSA9IDA7CisJYWQtPm1jaV9lbmMgPSBtY2lfY2JjX2VuY19hcnJheVtrZXlfaWR4XTsKKwlhZC0+ bWNpX2RlYyA9IG1jaV9jYmNfZGVjX2FycmF5W2tleV9pZHhdOworCWFkLT5pbnZfa2V5ID0gdHJ1 ZTsKKwlhZC0+ZWFsZ19pZCA9IFNBX0VBTEdfSURfQUVTX0NCQzsKKwlhZC0+YWFsZ19pZCA9IFNB X0FBTEdfSURfTk9ORTsKKworCXJldHVybiBzYV9hZXNfc2V0a2V5KHRmbSwga2V5LCBrZXlsZW4s IGFkKTsKK30KKworc3RhdGljIHZvaWQgc2FfYWVzX2RtYV9pbl9jYWxsYmFjayh2b2lkICpkYXRh KQoreworCXN0cnVjdCBzYV9yeF9kYXRhICpyeGQgPSAoc3RydWN0IHNhX3J4X2RhdGEgKilkYXRh OworCXN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSA9IChzdHJ1Y3QgYWJsa2NpcGhlcl9y ZXF1ZXN0ICopcnhkLT5yZXE7CisKKwlpbnQgc2dsZW4gPSBzZ19uZW50c19mb3JfbGVuKHJlcS0+ ZHN0LCByZXEtPm5ieXRlcyk7CisKKwlrZnJlZShyeGQpOworCisJZG1hX3VubWFwX3NnKHNhX2sz X2RldiwgcmVxLT5zcmMsIHNnbGVuLCBETUFfVE9fREVWSUNFKTsKKwlpZiAocmVxLT5zcmMgIT0g cmVxLT5kc3QpCisJCWRtYV91bm1hcF9zZyhyeGQtPmRkZXYsIHJlcS0+ZHN0LCBzZ2xlbiwgRE1B X0ZST01fREVWSUNFKTsKKworCWFibGtjaXBoZXJfcmVxdWVzdF9jb21wbGV0ZShyZXEsIDApOwor fQorCitzdGF0aWMgdm9pZAorc2FfcHJlcGFyZV90eF9kZXNjKHUzMiAqbWRwdHIsIHUzMiBwc2xl biwgdTMyICpwc2RhdGEsIHUzMiBlcGlibGVuLCB1MzIgKmVwaWIpCit7CisJdTMyICpvdXQsICpp bjsKKwlpbnQgaTsKKworCWZvciAob3V0ID0gbWRwdHIsIGluID0gZXBpYiwgaSA9IDA7IGkgPCBl cGlibGVuIC8gc2l6ZW9mKHUzMik7IGkrKykKKwkJKm91dCsrID0gKmluKys7CisKKwltZHB0cls0 XSA9ICgweEZGRkYgPDwgMTYpOworCWZvciAob3V0ID0gJm1kcHRyWzVdLCBpbiA9IHBzZGF0YSwg aSA9IDA7CisJICAgICBpIDwgcHNsZW4gLyBzaXplb2YodTMyKTsgaSsrKQorCQkqb3V0KysgPSAq aW4rKzsKK30KKworc3RhdGljIGludCBzYV9hZXNfcnVuKHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVl c3QgKnJlcSwgdTggKml2LCBpbnQgZW5jKQoreworCXN0cnVjdCBzYV90Zm1fY3R4ICpjdHggPQor CSAgICBjcnlwdG9fYWJsa2NpcGhlcl9jdHgoY3J5cHRvX2FibGtjaXBoZXJfcmVxdGZtKHJlcSkp OworCXN0cnVjdCBzYV9jdHhfaW5mbyAqc2FfY3R4ID0gZW5jID8gJmN0eC0+ZW5jIDogJmN0eC0+ ZGVjOworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqcGRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoc2Ff azNfZGV2KTsKKwlzdHJ1Y3Qgc2FfZG1hX3JlcV9jdHggcmVxX2N0eDsKKwlzdHJ1Y3QgZG1hX2Fz eW5jX3R4X2Rlc2NyaXB0b3IgKnR4X2luLCAqdHhfb3V0OworCXN0cnVjdCBzYV9yeF9kYXRhICpy eGQ7CisJdTggZW5jX29mZnNldDsKKwlpbnQgc2dfbmVudHMsIGRzdF9uZW50czsKKwlpbnQgcHNk YXRhX29mZnNldDsKKwl1OCBhdXRoX29mZnNldCA9IDA7CisJdTggKmF1dGhfaXYgPSBOVUxMOwor CXU4ICphYWQgPSBOVUxMOworCXU4IGFhZF9sZW4gPSAwOworCXUxNiBlbmNfbGVuOworCXUxNiBh dXRoX2xlbiA9IDA7CisJdTMyIHJlcV90eXBlOworCXUzMiAqbWRwdHI7CisJc2l6ZV90IHBsLCBt bDsKKworCXN0cnVjdCBkZXZpY2UgKmRkZXY7CisJc3RydWN0IGRtYV9jaGFuICpkbWFfcng7CisJ Z2ZwX3QgZmxhZ3M7CisKKwlmbGFncyA9IHJlcS0+YmFzZS5mbGFncyAmIENSWVBUT19URk1fUkVR X01BWV9TTEVFUCA/CisJCUdGUF9LRVJORUwgOiBHRlBfQVRPTUlDOworCisJZW5jX29mZnNldCA9 IDB4MDsKKwllbmNfbGVuID0gcmVxLT5uYnl0ZXM7CisKKwlpZiAoZW5jX2xlbiA+PSAyNTYpCisJ CWRtYV9yeCA9IHBkYXRhLT5kbWFfcngyOworCWVsc2UKKwkJZG1hX3J4ID0gcGRhdGEtPmRtYV9y eDE7CisKKwkvKiBBbGxvY2F0ZSBkZXNjcmlwdG9yICYgc3VibWl0IHBhY2tldCAqLworCXNnX25l bnRzID0gc2dfbmVudHNfZm9yX2xlbihyZXEtPnNyYywgZW5jX2xlbik7CisJZHN0X25lbnRzID0g c2dfbmVudHNfZm9yX2xlbihyZXEtPmRzdCwgZW5jX2xlbik7CisKKwltZW1jcHkocmVxX2N0eC5j bWRsLCBzYV9jdHgtPmNtZGwsIHNhX2N0eC0+Y21kbF9zaXplKTsKKworCS8qIFVwZGF0ZSBDb21t YW5kIExhYmVsICovCisJc2FfdXBkYXRlX2NtZGwoc2FfazNfZGV2LCBlbmNfb2Zmc2V0LCBlbmNf bGVuLAorCQkgICAgICAgaXYsIGF1dGhfb2Zmc2V0LCBhdXRoX2xlbiwKKwkJICAgICAgIGF1dGhf aXYsIGFhZF9sZW4sIGFhZCwKKwkJICAgICAgICZzYV9jdHgtPmNtZGxfdXBkX2luZm8sIHJlcV9j dHguY21kbCk7CisKKwkvKgorCSAqIExhc3QgMiB3b3JkcyBpbiBQU0RBVEEgd2lsbCBoYXZlIHRo ZSBjcnlwdG8gYWxnIHR5cGUgJgorCSAqIGNyeXB0byByZXF1ZXN0IHBvaW50ZXIKKwkgKi8KKwly ZXFfdHlwZSA9IENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSOworCWlmIChlbmMpCisJCXJlcV90 eXBlIHw9IChTQV9SRVFfU1VCVFlQRV9FTkMgPDwgU0FfUkVRX1NVQlRZUEVfU0hJRlQpOworCWVs c2UKKwkJcmVxX3R5cGUgfD0gKFNBX1JFUV9TVUJUWVBFX0RFQyA8PCBTQV9SRVFfU1VCVFlQRV9T SElGVCk7CisKKwlwc2RhdGFfb2Zmc2V0ID0gc2FfY3R4LT5jbWRsX3NpemUgLyBzaXplb2YodTMy KTsKKwlyZXFfY3R4LmNtZGxbcHNkYXRhX29mZnNldCsrXSA9IHJlcV90eXBlOworCisJZGRldiA9 IGRtYV9yeC0+ZGV2aWNlLT5kZXY7CisJLyogbWFwIHRoZSBwYWNrZXQgKi8KKwlyZXFfY3R4LnNy YyA9IHJlcS0+c3JjOworCXJlcV9jdHguc3JjX25lbnRzID0gZG1hX21hcF9zZyhzYV9rM19kZXYs IHJlcS0+c3JjLCBzZ19uZW50cywKKwkJCQkgICAgICAgRE1BX1RPX0RFVklDRSk7CisJaWYgKHJl cS0+c3JjICE9IHJlcS0+ZHN0KQorCQlkc3RfbmVudHMgPSBkbWFfbWFwX3NnKGRkZXYsIHJlcS0+ ZHN0LCBzZ19uZW50cywKKwkJCQkgICAgICAgRE1BX0ZST01fREVWSUNFKTsKKwllbHNlCisJCWRz dF9uZW50cyA9IHJlcV9jdHguc3JjX25lbnRzOworCisJaWYgKHVubGlrZWx5KHJlcV9jdHguc3Jj X25lbnRzICE9IHNnX25lbnRzKSkgeworCQlkZXZfd2Fybl9yYXRlbGltaXRlZChzYV9rM19kZXYs ICJmYWlsZWQgdG8gbWFwIHR4IHBrdFxuIik7CisJCXJldHVybiAtRUlPOworCX0KKworCXJlcV9j dHguZGV2X2RhdGEgPSBwZGF0YTsKKwlyZXFfY3R4LnBrdCA9IHRydWU7CisKKwlkbWFfc3luY19z Z19mb3JfZGV2aWNlKHBkYXRhLT5kZXYsIHJlcS0+c3JjLCByZXFfY3R4LnNyY19uZW50cywKKwkJ CSAgICAgICBETUFfVE9fREVWSUNFKTsKKworCXR4X2luID0gZG1hZW5naW5lX3ByZXBfc2xhdmVf c2coZG1hX3J4LCByZXEtPmRzdCwgZHN0X25lbnRzLAorCQkJCQlETUFfREVWX1RPX01FTSwKKwkJ CQkJRE1BX1BSRVBfSU5URVJSVVBUIHwgRE1BX0NUUkxfQUNLKTsKKwlpZiAoIXR4X2luKSB7CisJ CWRldl9lcnIocGRhdGEtPmRldiwgIklOIHByZXBfc2xhdmVfc2coKSBmYWlsZWRcbiIpOworCQly ZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyeGQgPSBremFsbG9jKHNpemVvZigqcnhkKSwgR0ZQX0tF Uk5FTCk7CisJcnhkLT5yZXEgPSAodm9pZCAqKXJlcTsKKwlyeGQtPmRkZXYgPSBkZGV2OworCisJ LyogSU4gKi8KKwl0eF9pbi0+Y2FsbGJhY2sgPSBzYV9hZXNfZG1hX2luX2NhbGxiYWNrOworCXR4 X2luLT5jYWxsYmFja19wYXJhbSA9IHJ4ZDsKKworCXR4X291dCA9IGRtYWVuZ2luZV9wcmVwX3Ns YXZlX3NnKHBkYXRhLT5kbWFfdHgsIHJlcS0+c3JjLAorCQkJCQkgcmVxX2N0eC5zcmNfbmVudHMs IERNQV9NRU1fVE9fREVWLAorCQkJCQlETUFfUFJFUF9JTlRFUlJVUFQgfCBETUFfQ1RSTF9BQ0sp OworCWlmICghdHhfb3V0KSB7CisJCWRldl9lcnIocGRhdGEtPmRldiwgIk9VVCBwcmVwX3NsYXZl X3NnKCkgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJbWRwdHIgPSAodTMy ICopZG1hZW5naW5lX2Rlc2NfZ2V0X21ldGFkYXRhX3B0cih0eF9vdXQsICZwbCwgJm1sKTsKKwor CXNhX3ByZXBhcmVfdHhfZGVzYyhtZHB0ciwgKHNhX2N0eC0+Y21kbF9zaXplICsgKFNBX1BTREFU QV9DVFhfV09SRFMgKgorCQkJICAgc2l6ZW9mKHUzMikpKSwgcmVxX2N0eC5jbWRsLAorCQkJICAg c2l6ZW9mKHNhX2N0eC0+ZXBpYiksIHNhX2N0eC0+ZXBpYik7CisKKwltbCA9IHNhX2N0eC0+Y21k bF9zaXplICsgKFNBX1BTREFUQV9DVFhfV09SRFMgKiBzaXplb2YodTMyKSk7CisJZG1hZW5naW5l X2Rlc2Nfc2V0X21ldGFkYXRhX2xlbih0eF9vdXQsIDQ0KTsKKworCWRtYWVuZ2luZV9zdWJtaXQo dHhfb3V0KTsKKwlkbWFlbmdpbmVfc3VibWl0KHR4X2luKTsKKworCWRtYV9hc3luY19pc3N1ZV9w ZW5kaW5nKGRtYV9yeCk7CisJZG1hX2FzeW5jX2lzc3VlX3BlbmRpbmcocGRhdGEtPmRtYV90eCk7 CisKKwlyZXR1cm4gLUVJTlBST0dSRVNTOworfQorCitzdGF0aWMgaW50IHNhX2Flc19jYmNfZW5j cnlwdChzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEpCit7CisJcmV0dXJuIHNhX2Flc19y dW4ocmVxLCByZXEtPmluZm8sIDEpOworfQorCitzdGF0aWMgaW50IHNhX2Flc19jYmNfZGVjcnlw dChzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEpCit7CisJcmV0dXJuIHNhX2Flc19ydW4o cmVxLCByZXEtPmluZm8sIDApOworfQorCitzdGF0aWMgc3RydWN0IHNhX2FsZ190bXBsIHNhX2Fs Z3NbXSA9IHsKKwl7LnR5cGUgPSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUiwKKwkgLmFsZy5j cnlwdG8gPSB7CisJCQkuY3JhX25hbWUgPSAiY2JjKGFlcykiLAorCQkJLmNyYV9kcml2ZXJfbmFt ZSA9ICJjYmMtYWVzLXNhMnVsIiwKKwkJCS5jcmFfcHJpb3JpdHkgPSAzMDAwMCwKKwkJCS5jcmFf ZmxhZ3MgPSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUiB8CisJCQkJICAgICBDUllQVE9fQUxH X0tFUk5fRFJJVkVSX09OTFkgfAorCQkJCSAgICAgQ1JZUFRPX0FMR19BU1lOQyB8CisJCQkJICAg ICBDUllQVE9fQUxHX05FRURfRkFMTEJBQ0ssCisJCQkuY3JhX2Jsb2Nrc2l6ZSA9IEFFU19CTE9D S19TSVpFLAorCQkJLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBzYV90Zm1fY3R4KSwKKwkJ CS5jcmFfYWxpZ25tYXNrID0gMCwKKwkJCS5jcmFfdHlwZSA9ICZjcnlwdG9fYWJsa2NpcGhlcl90 eXBlLAorCQkJLmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwKKwkJCS5jcmFfaW5pdCA9IHNhX2Fl c19jcmFfaW5pdCwKKwkJCS5jcmFfZXhpdCA9IHNhX2Flc19jcmFfZXhpdCwKKwkJCS5jcmFfdS5h YmxrY2lwaGVyID0geworCQkJCQkgICAgIC5taW5fa2V5c2l6ZSA9IEFFU19NSU5fS0VZX1NJWkUs CisJCQkJCSAgICAgLm1heF9rZXlzaXplID0gQUVTX01BWF9LRVlfU0laRSwKKwkJCQkJICAgICAu aXZzaXplID0gQUVTX0JMT0NLX1NJWkUsCisJCQkJCSAgICAgLnNldGtleSA9IHNhX2Flc19jYmNf c2V0a2V5LAorCQkJCQkgICAgIC5lbmNyeXB0ID0gc2FfYWVzX2NiY19lbmNyeXB0LAorCQkJCQkg ICAgIC5kZWNyeXB0ID0gc2FfYWVzX2NiY19kZWNyeXB0LAorCQkJCQl9CisJCQl9CisJfSwKK307 CisKKy8qIFJlZ2lzdGVyIHRoZSBhbGdvcml0aG1zIGluIGNyeXB0byBmcmFtZXdvcmsgKi8KK3Zv aWQgc2FfcmVnaXN0ZXJfYWxnb3MoY29uc3Qgc3RydWN0IGRldmljZSAqZGV2KQoreworCWNoYXIg KmFsZ19uYW1lOworCXUzMiB0eXBlOworCWludCBpLCBlcnIsIG51bV9hbGdzID0gQVJSQVlfU0la RShzYV9hbGdzKTsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fYWxnczsgaSsrKSB7CisJCXR5cGUg PSBzYV9hbGdzW2ldLnR5cGU7CisJCWlmICh0eXBlID09IENSWVBUT19BTEdfVFlQRV9BRUFEKSB7 CisJCQlhbGdfbmFtZSA9IHNhX2FsZ3NbaV0uYWxnLmFlYWQuYmFzZS5jcmFfbmFtZTsKKwkJCWVy ciA9IGNyeXB0b19yZWdpc3Rlcl9hZWFkKCZzYV9hbGdzW2ldLmFsZy5hZWFkKTsKKwkJfSBlbHNl IGlmICh0eXBlID09IENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSKSB7CisJCQlhbGdfbmFtZSA9 IHNhX2FsZ3NbaV0uYWxnLmNyeXB0by5jcmFfbmFtZTsKKwkJCWVyciA9IGNyeXB0b19yZWdpc3Rl cl9hbGcoJnNhX2FsZ3NbaV0uYWxnLmNyeXB0byk7CisJCX0gZWxzZSB7CisJCQlkZXZfZXJyKGRl diwKKwkJCQkidW4tc3VwcG9ydGVkIGNyeXB0byBhbGdvcml0aG0gKCVkKSIsCisJCQkJc2FfYWxn c1tpXS50eXBlKTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKGVycikKKwkJCWRldl9lcnIo ZGV2LCAiRmFpbGVkIHRvIHJlZ2lzdGVyICclcydcbiIsIGFsZ19uYW1lKTsKKwkJZWxzZQorCQkJ c2FfYWxnc1tpXS5yZWdpc3RlcmVkID0gMTsKKwl9Cit9CisKKy8qIFVucmVnaXN0ZXIgdGhlIGFs Z29yaXRobXMgaW4gY3J5cHRvIGZyYW1ld29yayAqLwordm9pZCBzYV91bnJlZ2lzdGVyX2FsZ29z KGNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwljaGFyICphbGdfbmFtZTsKKwl1MzIgdHlw ZTsKKwlpbnQgaSwgZXJyID0gMCwgbnVtX2FsZ3MgPSBBUlJBWV9TSVpFKHNhX2FsZ3MpOworCisJ Zm9yIChpID0gMDsgaSA8IG51bV9hbGdzOyBpKyspIHsKKwkJdHlwZSA9IHNhX2FsZ3NbaV0udHlw ZTsKKwkJaWYgKHR5cGUgPT0gQ1JZUFRPX0FMR19UWVBFX0FFQUQpIHsKKwkJCWFsZ19uYW1lID0g c2FfYWxnc1tpXS5hbGcuYWVhZC5iYXNlLmNyYV9uYW1lOworCQkJY3J5cHRvX3VucmVnaXN0ZXJf YWVhZCgmc2FfYWxnc1tpXS5hbGcuYWVhZCk7CisJCX0gZWxzZSB7CisJCQlhbGdfbmFtZSA9IHNh X2FsZ3NbaV0uYWxnLmNyeXB0by5jcmFfbmFtZTsKKwkJCWVyciA9IGNyeXB0b191bnJlZ2lzdGVy X2FsZygmc2FfYWxnc1tpXS5hbGcuY3J5cHRvKTsKKwkJfQorCisJCXNhX2FsZ3NbaV0ucmVnaXN0 ZXJlZCA9IDA7CisJfQorfQorCitzdGF0aWMgaW50IHNhX2luaXRfbWVtKHN0cnVjdCBzYV9jcnlw dG9fZGF0YSAqZGV2X2RhdGEpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmRldl9kYXRhLT5w ZGV2LT5kZXY7CisJLyogU2V0dXAgZG1hIHBvb2wgZm9yIHNlY3VyaXR5IGNvbnRleHQgYnVmZmVy cyAqLworCWRldl9kYXRhLT5zY19wb29sID0gZG1hX3Bvb2xfY3JlYXRlKCJrZXlzdG9uZS1zYyIs IGRldiwKKwkJCQkJICAgIFNBX0NUWF9NQVhfU1osIDY0LCAwKTsKKwlpZiAoIWRldl9kYXRhLT5z Y19wb29sKSB7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGNyZWF0ZSBkbWEgcG9vbCIpOwor CQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV9k bWFfaW5pdChzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRkKQoreworCWludCByZXQ7CisJc3RydWN0 IGRtYV9zbGF2ZV9jb25maWcgY2ZnOworCisJZGQtPmRtYV9yeDEgPSBOVUxMOworCWRkLT5kbWFf dHggPSBOVUxMOworCWRkLT5kbWFfcngyID0gTlVMTDsKKworCXJldCA9IGRtYV9jb2VyY2VfbWFz a19hbmRfY29oZXJlbnQoZGQtPmRldiwgRE1BX0JJVF9NQVNLKDQ4KSk7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCWRkLT5kbWFfcngxID0gZG1hX3JlcXVlc3RfY2hhbihkZC0+ZGV2LCAi cngxIik7CisJaWYgKElTX0VSUihkZC0+ZG1hX3J4MSkpIHsKKwkJaWYgKFBUUl9FUlIoZGQtPmRt YV9yeDEpICE9IC1FUFJPQkVfREVGRVIpCisJCQlkZXZfZXJyKGRkLT5kZXYsICJVbmFibGUgdG8g cmVxdWVzdCByeDEgRE1BIGNoYW5uZWxcbiIpOworCQlyZXR1cm4gUFRSX0VSUihkZC0+ZG1hX3J4 MSk7CisJfQorCisJZGQtPmRtYV9yeDIgPSBkbWFfcmVxdWVzdF9jaGFuKGRkLT5kZXYsICJyeDIi KTsKKwlpZiAoSVNfRVJSKGRkLT5kbWFfcngyKSkgeworCQlkbWFfcmVsZWFzZV9jaGFubmVsKGRk LT5kbWFfcngxKTsKKwkJaWYgKFBUUl9FUlIoZGQtPmRtYV9yeDEpICE9IC1FUFJPQkVfREVGRVIp CisJCQlkZXZfZXJyKGRkLT5kZXYsICJVbmFibGUgdG8gcmVxdWVzdCByeDIgRE1BIGNoYW5uZWxc biIpOworCQlyZXR1cm4gUFRSX0VSUihkZC0+ZG1hX3J4Mik7CisJfQorCisJZGQtPmRtYV90eCA9 IGRtYV9yZXF1ZXN0X2NoYW4oZGQtPmRldiwgInR4Iik7CisJaWYgKElTX0VSUihkZC0+ZG1hX3R4 KSkgeworCQlpZiAoUFRSX0VSUihkZC0+ZG1hX3J4MSkgIT0gLUVQUk9CRV9ERUZFUikKKwkJCWRl dl9lcnIoZGQtPmRldiwgIlVuYWJsZSB0byByZXF1ZXN0IHR4IERNQSBjaGFubmVsXG4iKTsKKwkJ cmV0ID0gUFRSX0VSUihkZC0+ZG1hX3R4KTsKKwkJZ290byBlcnJfZG1hX3R4OworCX0KKworCW1l bXplcm9fZXhwbGljaXQoJmNmZywgc2l6ZW9mKGNmZykpOworCisJY2ZnLnNyY19hZGRyX3dpZHRo ID0gRE1BX1NMQVZFX0JVU1dJRFRIXzRfQllURVM7CisJY2ZnLmRzdF9hZGRyX3dpZHRoID0gRE1B X1NMQVZFX0JVU1dJRFRIXzRfQllURVM7CisJY2ZnLnNyY19tYXhidXJzdCA9IDQ7CisJY2ZnLmRz dF9tYXhidXJzdCA9IDQ7CisKKwlyZXQgPSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFf cngxLCAmY2ZnKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGQtPmRldiwgImNhbid0IGNvbmZp Z3VyZSBJTiBkbWFlbmdpbmUgc2xhdmU6ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwlyZXQgPSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFfcngyLCAmY2ZnKTsK KwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGQtPmRldiwgImNhbid0IGNvbmZpZ3VyZSBJTiBkbWFl bmdpbmUgc2xhdmU6ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQg PSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFfdHgsICZjZmcpOworCWlmIChyZXQpIHsK KwkJZGV2X2VycihkZC0+ZGV2LCAiY2FuJ3QgY29uZmlndXJlIE9VVCBkbWFlbmdpbmUgc2xhdmU6 ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKKworZXJy X2RtYV90eDoKKwlkbWFfcmVsZWFzZV9jaGFubmVsKGRkLT5kbWFfcngxKTsKKwlkbWFfcmVsZWFz ZV9jaGFubmVsKGRkLT5kbWFfcngyKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQg c2FfdWxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgZGV2 aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCXN0YXRpYyB2 b2lkIF9faW9tZW0gKnNhdWxfYmFzZTsKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRldl9kYXRh OworCXUzMiB2YWw7CisJaW50IHJldDsKKworCWRldl9kYXRhID0gZGV2bV9remFsbG9jKGRldiwg c2l6ZW9mKCpkZXZfZGF0YSksIEdGUF9LRVJORUwpOworCWlmICghZGV2X2RhdGEpCisJCXJldHVy biAtRU5PTUVNOworCisJc2FfazNfZGV2ID0gZGV2OworCWRldl9kYXRhLT5kZXYgPSBkZXY7CisJ ZGV2X2RhdGEtPnBkZXYgPSBwZGV2OworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGRldl9k YXRhKTsKKwlkZXZfc2V0X2RydmRhdGEoc2FfazNfZGV2LCBkZXZfZGF0YSk7CisKKwlzYV9pbml0 X21lbShkZXZfZGF0YSk7CisJcmV0ID0gc2FfZG1hX2luaXQoZGV2X2RhdGEpOworCWlmIChyZXQp CisJCXJldHVybiByZXQ7CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9S RVNPVVJDRV9NRU0sIDApOworCXNhdWxfYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYs IHJlcyk7CisKKwl2YWwgPSBTQV9FRUNfRU5DU1NfRU4gfCBTQV9FRUNfQVVUSFNTX0VOIHwgU0Ff RUVDX0NUWENBQ0hfRU4gfAorCSAgICBTQV9FRUNfQ1BQSV9QT1JUX0lOX0VOIHwgU0FfRUVDX0NQ UElfUE9SVF9PVVRfRU4gfCBTQV9FRUNfVFJOR19FTjsKKworCXdyaXRlbF9yZWxheGVkKHZhbCwg c2F1bF9iYXNlICsgU0FfRU5HSU5FX0VOQUJMRV9DT05UUk9MKTsKKworCXNhX3JlZ2lzdGVyX2Fs Z29zKGRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV91bF9yZW1vdmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRl dl9kYXRhID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisKKwlzYV91bnJlZ2lzdGVyX2Fs Z29zKCZwZGV2LT5kZXYpOworCisJZG1hX3JlbGVhc2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3J4 Mik7CisJZG1hX3JlbGVhc2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3J4MSk7CisJZG1hX3JlbGVh c2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3R4KTsKKworCWRtYV9wb29sX2Rlc3Ryb3koZGV2X2Rh dGEtPnNjX3Bvb2wpOworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgb2ZfbWF0Y2hb XSA9IHsKKwl7LmNvbXBhdGlibGUgPSAidGksc2EydWwtY3J5cHRvIix9LAorCXt9LAorfTsKK01P RFVMRV9ERVZJQ0VfVEFCTEUob2YsIG9mX21hdGNoKTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9y bV9kcml2ZXIgc2FfdWxfZHJpdmVyID0geworCS5wcm9iZSA9IHNhX3VsX3Byb2JlLAorCS5yZW1v dmUgPSBzYV91bF9yZW1vdmUsCisJLmRyaXZlciA9IHsKKwkJICAgLm5hbWUgPSAic2F1bC1jcnlw dG8iLAorCQkgICAub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaCwKKwkJICAgfSwKK307Cittb2R1 bGVfcGxhdGZvcm1fZHJpdmVyKHNhX3VsX2RyaXZlcik7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYy Iik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by9zYTJ1bC5oIGIvZHJpdmVycy9jcnlwdG8v c2EydWwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmNhZjNjODhk Y2YyYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvY3J5cHRvL3NhMnVsLmgKQEAgLTAsMCAr MSwzODQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQU02 IFNBMlVMIGNyeXB0byBhY2NlbGVyYXRvciBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTggVGV4YXMgSW5zdHJ1bWVudHMgSW5jb3Jwb3JhdGVkIC0gaHR0cDovL3d3dy50aS5jb20KKyAq CisgKiBBdXRob3JzOglLZWVydGh5CisgKiAgICAgICAgICAgICAgVml0YWx5IEFuZHJpYW5vdgor ICovCisKKyNpZm5kZWYgX0szX1NBMlVMXworI2RlZmluZSBfSzNfU0EyVUxfCisKKyNpbmNsdWRl IDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KKyNpbmNsdWRl IDxsaW51eC9od19yYW5kb20uaD4KKyNpbmNsdWRlIDxjcnlwdG8vYWVzLmg+CisKKyNkZWZpbmUg U0FfRU5HSU5FX0VOQUJMRV9DT05UUk9MCTB4MTAwMAorCitzdHJ1Y3Qgc2FfdGZtX2N0eDsKKy8q CisgKiBTQV9FTkdJTkVfRU5BQkxFX0NPTlRST0wgcmVnaXN0ZXIgYml0cworICovCisjZGVmaW5l IFNBX0VFQ19FTkNTU19FTgkJCTB4MDAwMDAwMDEKKyNkZWZpbmUgU0FfRUVDX0FVVEhTU19FTgkJ MHgwMDAwMDAwMgorI2RlZmluZSBTQV9FRUNfVFJOR19FTgkJCTB4MDAwMDAwMDgKKyNkZWZpbmUg U0FfRUVDX1BLQV9FTgkJCTB4MDAwMDAwMTAKKyNkZWZpbmUgU0FfRUVDX0NUWENBQ0hfRU4JCTB4 MDAwMDAwODAKKyNkZWZpbmUgU0FfRUVDX0NQUElfUE9SVF9JTl9FTgkJMHgwMDAwMDIwMAorI2Rl ZmluZSBTQV9FRUNfQ1BQSV9QT1JUX09VVF9FTgkJMHgwMDAwMDgwMAorCisvKgorICogRW5jb2Rp bmcgdXNlZCB0byBpZGVudGlmeSB0aGUgdHlwbyBvZiBjcnlwdG8gb3BlcmF0aW9uCisgKiBwZXJm b3JtZWQgb24gdGhlIHBhY2tldCB3aGVuIHRoZSBwYWNrZXQgaXMgcmV0dXJuZWQKKyAqIGJ5IFNB CisgKi8KKyNkZWZpbmUgU0FfUkVRX1NVQlRZUEVfRU5DCTB4MDAwMQorI2RlZmluZSBTQV9SRVFf U1VCVFlQRV9ERUMJMHgwMDAyCisjZGVmaW5lIFNBX1JFUV9TVUJUWVBFX1NISUZUCTE2CisjZGVm aW5lIFNBX1JFUV9TVUJUWVBFX01BU0sJMHhmZmZmCisKKy8qIE51bWJlciBvZiAzMiBiaXQgd29y ZHMgaW4gRVBJQiAgKi8KKyNkZWZpbmUgU0FfRE1BX05VTV9FUElCX1dPUkRTICAgNAorCisvKiBO dW1iZXIgb2YgMzIgYml0IHdvcmRzIGluIFBTIGRhdGEgICovCisjZGVmaW5lIFNBX0RNQV9OVU1f UFNfV09SRFMgICAgIDE2CisjZGVmaW5lIE5LRVlfU1oJCQkzCisjZGVmaW5lIE1DSV9TWgkJCTI3 CisKKy8qCisgKiBNYXhpbXVtIG51bWJlciBvZiBzaW11bHRhZW5lb3VzIHNlY3VyaXR5IGNvbnRl eHRzCisgKiBzdXBwb3J0ZWQgYnkgdGhlIGRyaXZlcgorICovCisjZGVmaW5lIFNBX01BWF9OVU1f Q1RYCTUxMgorCisvKgorICogQXNzdW1wdGlvbjogQ1RYIHNpemUgaXMgbXVsdGlwbGUgb2YgMzIK KyAqLworI2RlZmluZSBTQV9DVFhfU0laRV9UT19ETUFfU0laRShjdHhfc3opIFwKKwkJKChjdHhf c3opID8gKChjdHhfc3opIC8gMzIgLSAxKSA6IDApCisKKyNkZWZpbmUgU0FfQ1RYX0VOQ19LRVlf T0ZGU0VUICAgMzIKKyNkZWZpbmUgU0FfQ1RYX0VOQ19BVVgxX09GRlNFVCAgNjQKKyNkZWZpbmUg U0FfQ1RYX0VOQ19BVVgyX09GRlNFVCAgOTYKKyNkZWZpbmUgU0FfQ1RYX0VOQ19BVVgzX09GRlNF VCAgMTEyCisjZGVmaW5lIFNBX0NUWF9FTkNfQVVYNF9PRkZTRVQgIDEyOAorCisvKiBOZXh0IEVu Z2luZSBTZWxlY3QgY29kZSBpbiBDUF9BQ0UgKi8KKyNkZWZpbmUgU0FfRU5HX0lEX0VNMSAgIDIg ICAgICAgLyogRW5jL0RlYyBlbmdpbmUgd2l0aCBBRVMvREVDIGNvcmUgKi8KKyNkZWZpbmUgU0Ff RU5HX0lEX0VNMiAgIDMgICAgICAgLyogRW5jcnlwdGlvbi9EZWNyeXB0aW9uIGVuZ2luZWZvciBw YXNzIDIgKi8KKyNkZWZpbmUgU0FfRU5HX0lEX0FNMSAgIDQgICAgICAgLyogQXV0aC4gZW5naW5l IHdpdGggU0hBMS9NRDUvU0hBMiBjb3JlICovCisjZGVmaW5lIFNBX0VOR19JRF9BTTIgICA1ICAg ICAgIC8qICBBdXRoZW50aWNhdGlvbiBlbmdpbmUgZm9yIHBhc3MgMiAqLworI2RlZmluZSBTQV9F TkdfSURfT1VUUE9SVDIgMjAgICAvKiAgRWdyZXNzIG1vZHVsZSAyICAqLworI2RlZmluZSBTQV9F TkdfSURfTk9ORSAgMHhmZgorCisvKgorICogQ29tbWFuZCBMYWJlbCBEZWZpbml0aW9ucworICov CisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX05FU0MgICAgICAgICAgIDAgICAgICAvKiBOZXh0IEVu Z2luZSBTZWxlY3QgQ29kZSAqLworI2RlZmluZSBTQV9DTURMX09GRlNFVF9MQUJFTF9MRU4gICAg ICAxICAgICAgLyogRW5naW5lIENvbW1hbmQgTGFiZWwgTGVuZ3RoICovCisvKiAxNi1iaXQgTGVu Z3RoIG9mIERhdGEgdG8gYmUgcHJvY2Vzc2VkICovCisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX0RB VEFfTEVOICAgICAgIDIKKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfREFUQV9PRkZTRVQgICAgNCAg ICAgIC8qIFN0YXQgRGF0YSBPZmZzZXQgKi8KKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfT1BUSU9O X0NUUkwxICAgNSAgICAgIC8qIE9wdGlvbiBDb250cm9sIEJ5dGUgMSAqLworI2RlZmluZSBTQV9D TURMX09GRlNFVF9PUFRJT05fQ1RSTDIgICA2ICAgICAgLyogT3B0aW9uIENvbnRyb2wgQnl0ZSAy ICovCisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX09QVElPTl9DVFJMMyAgIDcgICAgICAvKiBPcHRp b24gQ29udHJvbCBCeXRlIDMgKi8KKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfT1BUSU9OX0JZVEUg ICAgOAorCisjZGVmaW5lIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMJOAorCisjZGVmaW5lIFNB X0NNRExfT1BUSU9OX0JZVEVTX01BWF9TSVpFICAgICA3MgorI2RlZmluZSBTQV9DTURMX01BWF9T SVpFX0JZVEVTIChTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVTICsgXAorCQkJCVNBX0NNRExfT1BU SU9OX0JZVEVTX01BWF9TSVpFKQorCisvKiBTV0lORk8gd29yZC0wIGZsYWdzICovCisjZGVmaW5l IFNBX1NXX0lORk9fRkxBR19FVklDVCAgIDB4MDAwMQorI2RlZmluZSBTQV9TV19JTkZPX0ZMQUdf VEVBUiAgICAweDAwMDIKKyNkZWZpbmUgU0FfU1dfSU5GT19GTEFHX05PUEQgICAgMHgwMDA0CisK Ky8qCisgKiBUaGlzIHR5cGUgcmVwcmVzZW50cyB0aGUgdmFyaW91cyBwYWNrZXQgdHlwZXMgdG8g YmUgcHJvY2Vzc2VkCisgKiBieSB0aGUgUEhQIGVuZ2luZSBpbiBTQS4KKyAqIEl0IGlzIHVzZWQg dG8gaWRlbnRpZnkgdGhlIGNvcnJlc3BvbmRpbmcgUEhQIHByb2Nlc3NpbmcgZnVuY3Rpb24uCisg Ki8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFXzNHUFBfQUlSICAgIDAgICAgLyogM0dQUCBB aXIgQ2lwaGVyICovCisjZGVmaW5lIFNBX0NUWF9QRV9QS1RfVFlQRV9TUlRQICAgICAgICAxICAg IC8qIFNSVFAgKi8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFX0lQU0VDX0FIICAgIDIgICAg LyogSVBTZWMgQXV0aGVudGljYXRpb24gSGVhZGVyICovCisvKiBJUFNlYyBFbmNhcHN1bGF0aW5n IFNlY3VyaXR5IFBheWxvYWQgKi8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFX0lQU0VDX0VT UCAgIDMKKy8qIEluZGljYXRlcyB0aGF0IGl0IGlzIGluIGRhdGEgbW9kZSwgSXQgbWF5IG5vdCBi ZSB1c2VkIGJ5IFBIUCAqLworI2RlZmluZSBTQV9DVFhfUEVfUEtUX1RZUEVfTk9ORSAgICAgICAg NAorI2RlZmluZSBTQV9DVFhfRU5DX1RZUEUxX1NaICAgICA2NCAgICAgIC8qIEVuY3J5cHRpb24g U0Mgd2l0aCBLZXkgb25seSAqLworI2RlZmluZSBTQV9DVFhfRU5DX1RZUEUyX1NaICAgICA5NiAg ICAgIC8qIEVuY3J5cHRpb24gU0Mgd2l0aCBLZXkgYW5kIEF1eDEgKi8KKworI2RlZmluZSBTQV9D VFhfQVVUSF9UWVBFMV9TWiAgICA2NCAgICAgIC8qIEF1dGggU0Mgd2l0aCBLZXkgb25seSAqLwor I2RlZmluZSBTQV9DVFhfQVVUSF9UWVBFMl9TWiAgICA5NiAgICAgIC8qIEF1dGggU0Mgd2l0aCBL ZXkgYW5kIEF1eDEgKi8KKy8qIFNpemUgb2Ygc2VjdXJpdHkgY29udGV4dCBmb3IgUEhQIGVuZ2lu ZSAqLworI2RlZmluZSBTQV9DVFhfUEhQX1BFX0NUWF9TWiAgICA2NAorCisjZGVmaW5lIFNBX0NU WF9NQVhfU1ogKDY0ICsgU0FfQ1RYX0VOQ19UWVBFMl9TWiArIFNBX0NUWF9BVVRIX1RZUEUyX1Na KQorCisvKgorICogRW5jb2Rpbmcgb2YgRi9FIGNvbnRyb2wgaW4gU0NDVEwKKyAqICBCaXQgMC0x OiBGZXRjaCBQSFAgQnl0ZXMKKyAqICBCaXQgMi0zOiBGZXRjaCBFbmNyeXB0aW9uL0FpciBDaXBo ZXJpbmcgQnl0ZXMKKyAqICBCaXQgNC01OiBGZXRjaCBBdXRoZW50aWNhdGlvbiBCeXRlcyBvciBF bmNyIHBhc3MgMgorICogIEJpdCA2LTc6IEV2aWN0IFBIUCBCeXRlcworICoKKyAqICB3aGVyZSAg IDAwID0gMCBieXRlcworICogICAgICAgICAgMDEgPSA2NCBieXRlcworICogICAgICAgICAgMTAg PSA5NiBieXRlcworICogICAgICAgICAgMTEgPSAxMjggYnl0ZXMKKyAqLworI2RlZmluZSBTQV9D VFhfRE1BX1NJWkVfMCAgICAgICAwCisjZGVmaW5lIFNBX0NUWF9ETUFfU0laRV82NCAgICAgIDEK KyNkZWZpbmUgU0FfQ1RYX0RNQV9TSVpFXzk2ICAgICAgMgorI2RlZmluZSBTQV9DVFhfRE1BX1NJ WkVfMTI4ICAgICAzCisKKy8qCisgKiBCeXRlIG9mZnNldCBvZiB0aGUgb3duZXIgd29yZCBpbiBT Q0NUTAorICogaW4gdGhlIHNlY3VyaXR5IGNvbnRleHQKKyAqLworI2RlZmluZSBTQV9DVFhfU0ND VExfT1dORVJfT0ZGU0VUIDAKKworI2RlZmluZSBTQV9DVFhfRU5DX0tFWV9PRkZTRVQgICAzMgor I2RlZmluZSBTQV9DVFhfRU5DX0FVWDFfT0ZGU0VUICA2NAorI2RlZmluZSBTQV9DVFhfRU5DX0FV WDJfT0ZGU0VUICA5NgorI2RlZmluZSBTQV9DVFhfRU5DX0FVWDNfT0ZGU0VUICAxMTIKKyNkZWZp bmUgU0FfQ1RYX0VOQ19BVVg0X09GRlNFVCAgMTI4CisKKyNkZWZpbmUgU0FfU0NDVExfRkVfQVVU SF9FTkMJMHg2NQorI2RlZmluZSBTQV9TQ0NUTF9GRV9FTkMJCTB4OEQKKworI2RlZmluZSBTQV9B TElHTl9NQVNLCQkoc2l6ZW9mKHUzMikgLSAxKQorI2RlZmluZSBTQV9BTElHTkVECQlfX2FsaWdu ZWQoMzIpCisKKy8qKgorICogc3RydWN0IHNhX2NyeXB0b19kYXRhIC0gQ3J5cHRvIGRyaXZlciBp bnN0YW5jZSBkYXRhCisgKiBAcGRldjogUGxhdGZvcm0gZGV2aWNlIHBvaW50ZXIKKyAqIEBzY19w b29sOiBzZWN1cml0eSBjb250ZXh0IHBvb2wKKyAqIEBkZXY6IERldmljZSBwb2ludGVyCisgKiBA c2NpZF9sb2NrOiBzZWN1cmUgY29udGV4dCBJRCBsb2NrCisgKiBAc2NfaWRfc3RhcnQ6IHN0YXJ0 aW5nIGluZGV4IGZvciBTQyBJRAorICogQHNjX2lkX2VuZDogRW5kaW5nIGluZGV4IGZvciBTQyBJ RAorICogQHNjX2lkOiBTZWN1cml0eSBDb250ZXh0IElECisgKiBAY3R4X2JtOiBCaXRtYXAgdG8g a2VlcCB0cmFjayBvZiBTZWN1cml0eSBjb250ZXh0IElEJ3MKKyAqIEBjdHg6IFNBIHRmbSBjb250 ZXh0IHBvaW50ZXIKKyAqIEBkbWFfcngxOiBQb2ludGVyIHRvIERNQSByeCBjaGFubmVsIGZvciBz aXplcyA8IDI1NiBCeXRlcworICogQGRtYV9yeDI6IFBvaW50ZXIgdG8gRE1BIHJ4IGNoYW5uZWwg Zm9yIHNpemVzID4gMjU2IEJ5dGVzCisgKiBAZG1hX3R4OiBQb2ludGVyIHRvIERNQSBUWCBjaGFu bmVsCisgKi8KK3N0cnVjdCBzYV9jcnlwdG9fZGF0YSB7CisJc3RydWN0IHBsYXRmb3JtX2Rldmlj ZQkqcGRldjsKKwlzdHJ1Y3QgZG1hX3Bvb2wJCSpzY19wb29sOworCXN0cnVjdCBkZXZpY2UgKmRl djsKKwlzcGlubG9ja190CXNjaWRfbG9jazsgLyogbG9jayBmb3IgU0MtSUQgYWxsb2NhdGlvbiAq LworCS8qIFNlY3VyaXR5IGNvbnRleHQgZGF0YSAqLworCXUxNgkJc2NfaWRfc3RhcnQ7CisJdTE2 CQlzY19pZF9lbmQ7CisJdTE2CQlzY19pZDsKKwl1bnNpZ25lZCBsb25nCWN0eF9ibVtESVZfUk9V TkRfVVAoU0FfTUFYX05VTV9DVFgsCisJCQkJQklUU19QRVJfTE9ORyldOworCXN0cnVjdCBzYV90 Zm1fY3R4CSpjdHg7CisJc3RydWN0IGRtYV9jaGFuCQkqZG1hX3J4MTsKKwlzdHJ1Y3QgZG1hX2No YW4JCSpkbWFfcngyOworCXN0cnVjdCBkbWFfY2hhbgkJKmRtYV90eDsKK307CisKKy8qKgorICog c3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbzogQ29tbWFuZCBsYWJlbCBwYXJhbWV0ZXJzIGluZm8K KyAqIEBpbmRleDogSW5kZXggb2YgdGhlIHBhcmFtZXRlciBpbiB0aGUgY29tbWFuZCBsYWJlbCBm b3JtYXQKKyAqIEBvZmZzZXQ6IHRoZSBvZmZzZXQgb2YgdGhlIHBhcmFtZXRlcgorICogQHNpemU6 IFNpemUgb2YgdGhlIHBhcmFtZXRlcgorICovCitzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvIHsK Kwl1MTYJaW5kZXg7CisJdTE2CW9mZnNldDsKKwl1MTYJc2l6ZTsKK307CisKKy8qIE1heGltdW0g bGVuZ3RoIG9mIEF1eGlsaWFyeSBkYXRhIGluIDMyYml0IHdvcmRzICovCisjZGVmaW5lIFNBX01B WF9BVVhfREFUQV9XT1JEUwk4CisKKy8qKgorICogc3RydWN0IHNhX2NtZGxfdXBkX2luZm86IENv bW1hbmQgbGFiZWwgdXBkYXRpb24gaW5mbworICogQGZsYWdzOiBmbGFncyBpbiBjb21tYW5kIGxh YmVsCisgKiBAc3VibW9kZTogRW5jcnlwdGlvbiBzdWJtb2RlcworICogQGVuY19zaXplOiBTaXpl IG9mIGZpcnN0IHBhc3MgZW5jcnlwdGlvbiBzaXplCisgKiBAZW5jX3NpemUyOiBTaXplIG9mIHNl Y29uZCBwYXNzIGVuY3J5cHRpb24gc2l6ZQorICogQGVuY19vZmZzZXQ6IEVuY3J5cHRpb24gcGF5 bG9hZCBvZmZzZXQgaW4gdGhlIHBhY2tldAorICogQGVuY19pdjogRW5jcnlwdGlvbiBpbml0aWFs aXphdGlvbiB2ZWN0b3IgZm9yIHBhc3MyCisgKiBAZW5jX2l2MjogRW5jcnlwdGlvbiBpbml0aWFs aXphdGlvbiB2ZWN0b3IgZm9yIHBhc3MyCisgKiBAYWFkOiBBc3NvY2lhdGVkIGRhdGEKKyAqIEBw YXlsb2FkOiBQYXlsb2FkIGluZm8KKyAqIEBhdXRoX3NpemU6IEF1dGhlbnRpY2F0aW9uIHNpemUg Zm9yIHBhc3MgMQorICogQGF1dGhfc2l6ZTI6IEF1dGhlbnRpY2F0aW9uIHNpemUgZm9yIHBhc3Mg MgorICogQGF1dGhfb2Zmc2V0OiBBdXRoZW50aWNhdGlvbiBwYXlsb2FkIG9mZnNldAorICogQGF1 dGhfaXY6IEF1dGhlbnRpY2F0aW9uIGluaXRpYWxpemF0aW9uIHZlY3RvcgorICogQGF1eF9rZXlf aW5mbzogQXV0aGVudGljYXRpb24gYXV4IGtleSBpbmZvcm1hdGlvbgorICogQGF1eF9rZXk6IEF1 eCBrZXkgZm9yIGF1dGhlbnRpY2F0aW9uCisgKi8KK3N0cnVjdCBzYV9jbWRsX3VwZF9pbmZvIHsK Kwl1MTYJZmxhZ3M7CisJdTE2CXN1Ym1vZGU7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwll bmNfc2l6ZTsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWVuY19zaXplMjsKKwlzdHJ1Y3Qg c2FfY21kbF9wYXJhbV9pbmZvCWVuY19vZmZzZXQ7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5m bwllbmNfaXY7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwllbmNfaXYyOworCXN0cnVjdCBz YV9jbWRsX3BhcmFtX2luZm8JYWFkOworCXN0cnVjdCBzYV9jbWRsX3BhcmFtX2luZm8JcGF5bG9h ZDsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWF1dGhfc2l6ZTsKKwlzdHJ1Y3Qgc2FfY21k bF9wYXJhbV9pbmZvCWF1dGhfc2l6ZTI7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwlhdXRo X29mZnNldDsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWF1dGhfaXY7CisJc3RydWN0IHNh X2NtZGxfcGFyYW1faW5mbwlhdXhfa2V5X2luZm87CisJdTMyCQkJCWF1eF9rZXlbU0FfTUFYX0FV WF9EQVRBX1dPUkRTXTsKK307CisKKy8qCisgKiBOdW1iZXIgb2YgMzJiaXQgd29yZHMgYXBwZW5k ZWQgYWZ0ZXIgdGhlIGNvbW1hbmQgbGFiZWwKKyAqIGluIFBTREFUQSB0byBpZGVudGlmeSB0aGUg Y3J5cHRvIHJlcXVlc3QgY29udGV4dC4KKyAqIHdvcmQtMDogUmVxdWVzdCB0eXBlCisgKiB3b3Jk LTE6IHBvaW50ZXIgdG8gcmVxdWVzdAorICovCisjZGVmaW5lIFNBX1BTREFUQV9DVFhfV09SRFMg NAorCisvKiBNYXhpbXVtIHNpemUgb2YgQ29tbWFuZCBsYWJlbCBpbiAzMiB3b3JkcyAqLworI2Rl ZmluZSBTQV9NQVhfQ01ETF9XT1JEUyAoU0FfRE1BX05VTV9QU19XT1JEUyAtIFNBX1BTREFUQV9D VFhfV09SRFMpCisKKy8qKgorICogc3RydWN0IHNhX2N0eF9pbmZvOiBTQSBjb250ZXh0IGluZm9y bWF0aW9uCisgKiBAc2M6IFBvaW50ZXIgdG8gc2VjdXJpdHkgY29udGV4dAorICogQHNjX3BoeXM6 IFNlY3VyaXR5IGNvbnRleHQgcGh5c2ljYWwgYWRkcmVzcyB0aGF0IGlzIHBhc3NlZCBvbiB0byBT QTJVTAorICogQGNtZGxfc2l6ZTogQ29tbWFuZCBsYWJlbCBzaXplCisgKiBAY21kbDogQ29tbWFu ZCBsYWJlbCBmb3IgYSBwYXJ0aWN1bGFyIGl0ZXJhdGlvbgorICogQGNtZGxfdXBkX2luZm86IHN0 cnVjdHVyZSBob2xkaW5nIGNvbW1hbmQgbGFiZWwgdXBkYXRpb24gaW5mbworICogQGVwaWI6IEV4 dGVuZGVkIHByb3RvY29sIGluZm9ybWF0aW9uIGJsb2NrIHdvcmRzCisgKi8KK3N0cnVjdCBzYV9j dHhfaW5mbyB7CisJdTgJCSpzYzsKKwlkbWFfYWRkcl90CXNjX3BoeXM7CisJdTE2CQlzY19pZDsK Kwl1MTYJCWNtZGxfc2l6ZTsKKwl1MzIJCWNtZGxbU0FfTUFYX0NNRExfV09SRFNdOworCXN0cnVj dCBzYV9jbWRsX3VwZF9pbmZvIGNtZGxfdXBkX2luZm87CisJLyogU3RvcmUgQXV4aWxpYXJ5IGRh dGEgc3VjaCBhcyBLMi9LMyBzdWJrZXlzIGluIEFFUy1YQ0JDICovCisJdTMyCQllcGliW1NBX0RN QV9OVU1fRVBJQl9XT1JEU107Cit9OworCitzdHJ1Y3Qgc2Ffc2hhbV9obWFjX2N0eCB7CisJc3Ry dWN0IGNyeXB0b19zaGFzaAkqc2hhc2g7CisJdTgJCQlpcGFkW1NIQTUxMl9CTE9DS19TSVpFXSBT QV9BTElHTkVEOworCXU4CQkJb3BhZFtTSEE1MTJfQkxPQ0tfU0laRV0gU0FfQUxJR05FRDsKK307 CisKKy8qKgorICogc3RydWN0IHNhX3RmbV9jdHg6IFRGTSBjb250ZXh0IHN0cnVjdHVyZQorICog QGRldl9kYXRhOiBzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgcG9pbnRlcgorICogQGVuYzogc3RydWN0 IHNhX2N0eF9pbmZvIGZvciBlbmNyeXB0aW9uCisgKiBAZGVjOiBzdHJ1Y3Qgc2FfY3R4X2luZm8g Zm9yIGRlY3J5cHRpb24KKyAqIEBhdXRoOiBzdHJ1Y3Qgc2FfY3R4X2luZm8gZm9yIGF1dGhlbnRp Y2F0aW9uCisgKiBAa2V5bGVuOiBlbmNycHRpb24vZGVjcnlwdGlvbiBrZXlsZW5ndGgKKyAqIEBr ZXk6IGVuY3J5cHRpb24ga2V5CisgKiBAc2hhc2g6IHNvZnR3YXJlIGhhc2ggY3J5cHRvX2hhc2gK KyAqIEBhdXRoa2V5OiBhdXRoZW50aWNhdGlvbiBrZXkKKyAqLworc3RydWN0IHNhX3RmbV9jdHgg eworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqZGV2X2RhdGE7CisJc3RydWN0IHNhX2N0eF9pbmZv IGVuYzsKKwlzdHJ1Y3Qgc2FfY3R4X2luZm8gZGVjOworCXN0cnVjdCBzYV9jdHhfaW5mbyBhdXRo OworCWludCBrZXlsZW47CisJdTMyIGtleVtBRVNfS0VZU0laRV8yNTYgLyBzaXplb2YodTMyKV07 CisJc3RydWN0IHNhX3NoYW1faG1hY19jdHggYmFzZVswXTsKKwlzdHJ1Y3QgY3J5cHRvX3NoYXNo CSpzaGFzaDsKKwl1OCBhdXRoa2V5W1NIQTUxMl9CTE9DS19TSVpFXTsKK307CisKKy8qKgorICog c3RydWN0IHNhX2RtYV9yZXFfY3R4OiBTdHJ1Y3R1cmUgdXNlZCBmb3IgdHggZG1hIHJlcXVlc3QK KyAqIEBkZXZfZGF0YTogc3RydWN0IHNhX2NyeXB0b19kYXRhIHBvaW50ZXIKKyAqIEBjbWRsOiBD b21wbGV0ZSBjb21tYW5kIGxhYmVsIHdpdGggcHNkYXRhIGFuZCBlcGliIGluY2x1ZGVkCisgKiBA c3JjOiBzb3VyY2UgcGF5bG9hZCBzY2F0dGVybGlzdCBwb2ludGVyCisgKiBAc3JjX25lbnRzOiBO dW1iZXIgb2Ygbm9kZXMgaW4gc291cmNlIHNjYXR0ZXJsaXN0CisgKiBAcGt0OiBwYWNrZXQgZG1h CisgKi8KK3N0cnVjdCBzYV9kbWFfcmVxX2N0eCB7CisJc3RydWN0IHNhX2NyeXB0b19kYXRhICpk ZXZfZGF0YTsKKwl1MzIJCWNtZGxbU0FfTUFYX0NNRExfV09SRFMgKyBTQV9QU0RBVEFfQ1RYX1dP UkRTXTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNyYzsKKwl1bnNpZ25lZCBpbnQJc3JjX25lbnRz OworCWJvb2wJCXBrdDsKK307CisKK2VudW0gc2Ffc3VibW9kZSB7CisJU0FfTU9ERV9HRU4gPSAw LAorCVNBX01PREVfQ0NNLAorCVNBX01PREVfR0NNLAorCVNBX01PREVfR01BQworfTsKKworLyog RW5jcnlwdGlvbiBhbGdvcml0aG1zICovCitlbnVtIHNhX2VhbGdfaWQgeworCVNBX0VBTEdfSURf Tk9ORSA9IDAsICAgICAgICAvKiBObyBlbmNyeXB0aW9uICovCisJU0FfRUFMR19JRF9OVUxMLCAg ICAgICAgICAgIC8qIE5VTEwgZW5jcnlwdGlvbiAqLworCVNBX0VBTEdfSURfQUVTX0NUUiwgICAg ICAgICAvKiBBRVMgQ291bnRlciBtb2RlICovCisJU0FfRUFMR19JRF9BRVNfRjgsICAgICAgICAg IC8qIEFFUyBGOCBtb2RlICovCisJU0FfRUFMR19JRF9BRVNfQ0JDLCAgICAgICAgIC8qIEFFUyBD QkMgbW9kZSAqLworCVNBX0VBTEdfSURfREVTX0NCQywgICAgICAgICAvKiBERVMgQ0JDIG1vZGUg Ki8KKwlTQV9FQUxHX0lEXzNERVNfQ0JDLCAgICAgICAgLyogM0RFUyBDQkMgbW9kZSAqLworCVNB X0VBTEdfSURfQ0NNLCAgICAgICAgICAgICAvKiBDb3VudGVyIHdpdGggQ0JDLU1BQyBtb2RlICov CisJU0FfRUFMR19JRF9HQ00sICAgICAgICAgICAgIC8qIEdhbG9pcyBDb3VudGVyIG1vZGUgKi8K KwlTQV9FQUxHX0lEX0FFU19FQ0IsCisJU0FfRUFMR19JRF9MQVNUCit9OworCisvKiBBdXRoZW50 aWNhdGlvbiBhbGdvcml0aG1zICovCitlbnVtIHNhX2FhbGdfaWQgeworCVNBX0FBTEdfSURfTk9O RSA9IDAsICAgICAgLyogTm8gQXV0aGVudGljYXRpb24gICovCisJU0FfQUFMR19JRF9OVUxMID0g U0FfRUFMR19JRF9MQVNULCAvKiBOVUxMIEF1dGhlbnRpY2F0aW9uICAqLworCVNBX0FBTEdfSURf TUQ1LCAgICAgICAgICAgLyogTUQ1IG1vZGUgKi8KKwlTQV9BQUxHX0lEX1NIQTEsICAgICAgICAg IC8qIFNIQTEgbW9kZSAqLworCVNBX0FBTEdfSURfU0hBMl8yMjQsICAgICAgLyogMjI0LWJpdCBT SEEyIG1vZGUgKi8KKwlTQV9BQUxHX0lEX1NIQTJfMjU2LCAgICAgIC8qIDI1Ni1iaXQgU0hBMiBt b2RlICovCisJU0FfQUFMR19JRF9ITUFDX01ENSwgICAgICAvKiBITUFDIHdpdGggTUQ1IG1vZGUg Ki8KKwlTQV9BQUxHX0lEX0hNQUNfU0hBMSwgICAgIC8qIEhNQUMgd2l0aCBTSEExIG1vZGUgKi8K KwlTQV9BQUxHX0lEX0hNQUNfU0hBMl8yMjQsIC8qIEhNQUMgd2l0aCAyMjQtYml0IFNIQTIgbW9k ZSAqLworCVNBX0FBTEdfSURfSE1BQ19TSEEyXzI1NiwgLyogSE1BQyB3aXRoIDI1Ni1iaXQgU0hB MiBtb2RlICovCisJU0FfQUFMR19JRF9HTUFDLCAgICAgICAgICAvKiBHYWxvaXMgTWVzc2FnZSBB dXRoLiBDb2RlIG1vZGUgKi8KKwlTQV9BQUxHX0lEX0NNQUMsICAgICAgICAgIC8qIENpcGhlci1i YXNlZCBNZXMuIEF1dGguIENvZGUgbW9kZSAqLworCVNBX0FBTEdfSURfQ0JDX01BQywgICAgICAg LyogQ2lwaGVyIEJsb2NrIENoYWluaW5nICovCisJU0FfQUFMR19JRF9BRVNfWENCQyAgICAgICAv KiBBRVMgRXh0ZW5kZWQgQ2lwaGVyIEJsb2NrIENoYWluaW5nICovCit9OworCisvKgorICogTW9k ZSBjb250cm9sIGVuZ2luZSBhbGdvcml0aG1zIHVzZWQgdG8gaW5kZXggdGhlCisgKiBtb2RlIGNv bnRyb2wgaW5zdHJ1Y3Rpb24gdGFibGVzCisgKi8KK2VudW0gc2FfZW5nX2FsZ29faWQgeworCVNB X0VOR19BTEdPX0VDQiA9IDAsCisJU0FfRU5HX0FMR09fQ0JDLAorCVNBX0VOR19BTEdPX0NGQiwK KwlTQV9FTkdfQUxHT19PRkIsCisJU0FfRU5HX0FMR09fQ1RSLAorCVNBX0VOR19BTEdPX0Y4LAor CVNBX0VOR19BTEdPX0Y4RjksCisJU0FfRU5HX0FMR09fR0NNLAorCVNBX0VOR19BTEdPX0dNQUMs CisJU0FfRU5HX0FMR09fQ0NNLAorCVNBX0VOR19BTEdPX0NNQUMsCisJU0FfRU5HX0FMR09fQ0JD TUFDLAorCVNBX05VTV9FTkdfQUxHT1MKK307CisKK3N0cnVjdCBzYV9lbmdfaW5mbyB7CisJdTgJ ZW5nX2lkOworCXUxNglzY19zaXplOworfTsKKworZXh0ZXJuIHN0cnVjdCBkZXZpY2UgKnNhX2tz Ml9kZXY7CisKKyNlbmRpZiAvKiBfSzNfU0EyVUxfICovCi0tIAoyLjE3LjEKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1h aWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: Keerthy Subject: [RESEND PATCH 02/10] crypto: sa2ul: Add crypto driver Date: Fri, 28 Jun 2019 09:57:37 +0530 Message-ID: <20190628042745.28455-3-j-keerthy@ti.com> References: <20190628042745.28455-1-j-keerthy@ti.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190628042745.28455-1-j-keerthy@ti.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: herbert@gondor.apana.org.au, davem@davemloft.net, robh+dt@kernel.org Cc: nm@ti.com, devicetree@vger.kernel.org, j-keerthy@ti.com, linux-kernel@vger.kernel.org, t-kristo@ti.com, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org VGhlIFNlY3VyaXR5IEFjY2VsZXJhdG9yIChTQTJfVUwpIHN1YnN5c3RlbSBwcm92aWRlcyBoYXJk d2FyZQpjcnlwdG9ncmFwaGljIGFjY2VsZXJhdGlvbiBmb3IgdGhlIGZvbGxvd2luZyB1c2UgY2Fz ZXM6CuKAoiBFbmNyeXB0aW9uIGFuZCBhdXRoZW50aWNhdGlvbiBmb3Igc2VjdXJlIGJvb3QK4oCi IEVuY3J5cHRpb24gYW5kIGF1dGhlbnRpY2F0aW9uIG9mIGNvbnRlbnQgaW4gYXBwbGljYXRpb25z CiAgcmVxdWlyaW5nIERSTSAoZGlnaXRhbCByaWdodHMgbWFuYWdlbWVudCkgYW5kCiAgY29udGVu dC9hc3NldCBwcm90ZWN0aW9uClRoZSBkZXZpY2UgaW5jbHVkZXMgb25lIGluc3RhbnRpYXRpb24g b2YgU0EyX1VMIG5hbWVkIFNBMl9VTDAKClNBMl9VTCBzdXBwb3J0cyB0aGUgZm9sbG93aW5nIGNy eXB0b2dyYXBoaWMgaW5kdXN0cnkgc3RhbmRhcmRzIHRvIGVuYWJsZSBkYXRhIGF1dGhlbnRpY2F0 aW9uLCBkYXRhCmludGVncml0eSBhbmQgZGF0YSBjb25maWRlbnRpYWxpdHkuCgpDcnlwdG8gZnVu Y3Rpb24gbGlicmFyeSBmb3Igc29mdHdhcmUgYWNjZWxlcmF0aW9uCm8gQUVTIG9wZXJhdGlvbgpv IDNERVMgb3BlcmF0aW9uCm8gU0hBMSBvcGVyYXRpb24KbyBNRDUgb3BlcmF0aW9uCm8gU0hBMiDi gJMgMjI0LCAyNTYsIDM4NCwgNTEyIG9wZXJhdGlvbgoKQXV0aGVudGljYXRpb24gc3VwcG9ydGVk IHZpYSBmb2xsb3dpbmcgaGFyZHdhcmUgY29yZXMKbyBTSEExCm8gTUQ1Cm8gU0hBMiAtMjI0Cm8g U0hBMi0yNTYKbyBTSEEyLTM4NApvIFNIQTItNTEyCgpQYXRjaCBhZGRzIGEgYmFzaWMgY3J5cHRv IGRyaXZlciBhbmQgY3VycmVudGx5IHN1cHBvcnRzIEFFUwppbiBjYmMgbW9kZSBmb3IgYm90aCBl bmNyeXB0aW9uIGFuZCBkZWNyeXB0aW9uLgoKU2lnbmVkLW9mZi1ieTogS2VlcnRoeSA8ai1rZWVy dGh5QHRpLmNvbT4KLS0tCiBkcml2ZXJzL2NyeXB0by9LY29uZmlnICB8ICAgMTcgKwogZHJpdmVy cy9jcnlwdG8vTWFrZWZpbGUgfCAgICAxICsKIGRyaXZlcnMvY3J5cHRvL3NhMnVsLmMgIHwgMTE1 MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvY3J5cHRv L3NhMnVsLmggIHwgIDM4NCArKysrKysrKysrKysrCiA0IGZpbGVzIGNoYW5nZWQsIDE1NTMgaW5z ZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY3J5cHRvL3NhMnVsLmMKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2NyeXB0by9zYTJ1bC5oCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9jcnlwdG8vS2NvbmZpZyBiL2RyaXZlcnMvY3J5cHRvL0tjb25maWcKaW5kZXggNjAzNDEz ZjI4ZmEzLi5iOWEzZmEwMjZjNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL0tjb25maWcK KysrIGIvZHJpdmVycy9jcnlwdG8vS2NvbmZpZwpAQCAtNzg1LDQgKzc4NSwyMSBAQCBjb25maWcg Q1JZUFRPX0RFVl9DQ1JFRQogCiBzb3VyY2UgImRyaXZlcnMvY3J5cHRvL2hpc2lsaWNvbi9LY29u ZmlnIgogCitjb25maWcgQ1JZUFRPX0RFVl9TQTJVTAorCXRyaXN0YXRlICJTdXBwb3J0IGZvciBU SSBzZWN1cml0eSBhY2NlbGVyYXRvciIKKwlkZXBlbmRzIG9uIEFSQ0hfSzMgfHwgQ09NUElMRV9U RVNUCisJc2VsZWN0IEFSTTY0X0NSWVBUTworCXNlbGVjdCBDUllQVE9fQUVTCisJc2VsZWN0IENS WVBUT19BRVNfQVJNNjQKKwlzZWxlY3QgQ1JZUFRPX1NIQTEKKwlzZWxlY3QgQ1JZUFRPX01ENQor CXNlbGVjdCBDUllQVE9fQUxHQVBJCisJc2VsZWN0IENSWVBUT19BVVRIRU5DCisJc2VsZWN0IEhX X1JBTkRPTQorCWRlZmF1bHQgbSBpZiBBUkNIX0szCisJaGVscAorCSAgS2V5c3RvbmUgZGV2aWNl cyBpbmNsdWRlIGEgc2VjdXJpdHkgYWNjZWxlcmF0b3IgZW5naW5lIHRoYXQgbWF5IGJlCisJICB1 c2VkIGZvciBjcnlwdG8gb2ZmbG9hZC4gIFNlbGVjdCB0aGlzIGlmIHlvdSB3YW50IHRvIHVzZSBo YXJkd2FyZQorCSAgYWNjZWxlcmF0aW9uIGZvciBjcnlwdG9ncmFwaGljIGFsZ29yaXRobXMgb24g dGhlc2UgZGV2aWNlcy4KKwogZW5kaWYgIyBDUllQVE9fSFcKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Y3J5cHRvL01ha2VmaWxlIGIvZHJpdmVycy9jcnlwdG8vTWFrZWZpbGUKaW5kZXggYWZjNDc1M2I1 ZDI4Li4zMDBkMzFmZDI0ZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3J5cHRvL01ha2VmaWxlCisr KyBiL2RyaXZlcnMvY3J5cHRvL01ha2VmaWxlCkBAIC00Nyw0ICs0Nyw1IEBAIG9iai0kKENPTkZJ R19DUllQVE9fREVWX1ZNWCkgKz0gdm14Lwogb2JqLSQoQ09ORklHX0NSWVBUT19ERVZfQkNNX1NQ VSkgKz0gYmNtLwogb2JqLSQoQ09ORklHX0NSWVBUT19ERVZfU0FGRVhDRUwpICs9IGluc2lkZS1z ZWN1cmUvCiBvYmotJChDT05GSUdfQ1JZUFRPX0RFVl9BUlRQRUM2KSArPSBheGlzLworb2JqLSQo Q09ORklHX0NSWVBUT19ERVZfU0EyVUwpICs9IHNhMnVsLm8KIG9iai15ICs9IGhpc2lsaWNvbi8K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL3NhMnVsLmMgYi9kcml2ZXJzL2NyeXB0by9zYTJ1 bC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNjRiZGY2YjJiODc5 Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9jcnlwdG8vc2EydWwuYwpAQCAtMCwwICsxLDEx NTEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQU02IFNB MlVMIGNyeXB0byBhY2NlbGVyYXRvciBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTgg VGV4YXMgSW5zdHJ1bWVudHMgSW5jb3Jwb3JhdGVkIC0gaHR0cDovL3d3dy50aS5jb20KKyAqCisg KiBBdXRob3JzOglLZWVydGh5CisgKiAgICAgICAgICAgICAgVml0YWx5IEFuZHJpYW5vdgorICov CisjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5j bHVkZSA8bGludXgvZG1hcG9vbC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWFlbmdp bmUuaD4KKyNpbmNsdWRlIDxsaW51eC9jcnlwdG9oYXNoLmg+CisjaW5jbHVkZSA8bGludXgvbW9k X2RldmljZXRhYmxlLmg+CisKKyNpbmNsdWRlIDxjcnlwdG8vYXV0aGVuYy5oPgorI2luY2x1ZGUg PGNyeXB0by9kZXMuaD4KKyNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvYWVhZC5oPgorI2luY2x1 ZGUgPGNyeXB0by9pbnRlcm5hbC9za2NpcGhlci5oPgorI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5h bC9oYXNoLmg+CisjaW5jbHVkZSA8Y3J5cHRvL3NjYXR0ZXJ3YWxrLmg+CisjaW5jbHVkZSA8Y3J5 cHRvL3NoYS5oPgorCisjaW5jbHVkZSAic2EydWwuaCIKKworLyogQnl0ZSBvZmZzZXQgZm9yIGtl eSBpbiBlbmNyeXB0aW9uIHNlY3VyaXR5IGNvbnRleHQgKi8KKyNkZWZpbmUgU0NfRU5DX0tFWV9P RkZTRVQgKDEgKyAyNyArIDQpCisvKiBCeXRlIG9mZnNldCBmb3IgQXV4LTEgaW4gZW5jcnlwdGlv biBzZWN1cml0eSBjb250ZXh0ICovCisjZGVmaW5lIFNDX0VOQ19BVVgxX09GRlNFVCAoMSArIDI3 ICsgNCArIDMyKQorCisjZGVmaW5lIFNBX0NNRExfVVBEX0VOQyAgICAgICAgIDB4MDAwMQorI2Rl ZmluZSBTQV9DTURMX1VQRF9BVVRIICAgICAgICAweDAwMDIKKyNkZWZpbmUgU0FfQ01ETF9VUERf RU5DX0lWICAgICAgMHgwMDA0CisjZGVmaW5lIFNBX0NNRExfVVBEX0FVVEhfSVYgICAgIDB4MDAw OAorI2RlZmluZSBTQV9DTURMX1VQRF9BVVhfS0VZICAgICAweDAwMTAKKworI2RlZmluZSBTQV9B VVRIX1NVQktFWV9MRU4JMTYKKyNkZWZpbmUgU0FfQ01ETF9QQVlMT0FEX0xFTkdUSF9NQVNLCTB4 RkZGRgorI2RlZmluZSBTQV9DTURMX1NPUF9CWVBBU1NfTEVOX01BU0sJMHhGRjAwMDAwMAorCisj ZGVmaW5lIE1PREVfQ09OVFJPTF9CWVRFUwkyNworI2RlZmluZSBTQV9IQVNIX1BST0NFU1NJTkcJ MAorI2RlZmluZSBTQV9DUllQVE9fUFJPQ0VTU0lORwkwCisjZGVmaW5lIFNBX1VQTE9BRF9IQVNI X1RPX1RMUglCSVQoNikKKworI2RlZmluZSBTQV9TVzBfRkxBR1NfTUFTSwkweEYwMDAwCisjZGVm aW5lIFNBX1NXMF9DTURMX0lORk9fTUFTSwkweDFGMDAwMDAKKyNkZWZpbmUgU0FfU1cwX0NNRExf UFJFU0VOVAlCSVQoNCkKKyNkZWZpbmUgU0FfU1cwX0VOR19JRF9NQVNLCTB4M0UwMDAwMDAKKyNk ZWZpbmUgU0FfU1cwX0RFU1RfSU5GT19QUkVTRU5UCUJJVCgzMCkKKyNkZWZpbmUgU0FfU1cyX0VH UkVTU19MRU5HVEgJCTB4RkYwMDAwMDAKKworI2RlZmluZSBTSEEyNTZfRElHRVNUX1dPUkRTICAg IDgKKy8qIE1ha2UgMzItYml0IHdvcmQgZnJvbSA0IGJ5dGVzICovCisjZGVmaW5lIFNBX01LX1Uz MihiMCwgYjEsIGIyLCBiMykgKCgoYjApIDw8IDI0KSB8ICgoYjEpIDw8IDE2KSB8IFwKKwkJCQkg ICAoKGIyKSA8PCA4KSB8IChiMykpCisKKy8qIHNpemUgb2YgU0NDVEwgc3RydWN0dXJlIGluIGJ5 dGVzICovCisjZGVmaW5lIFNBX1NDQ1RMX1NaIDE2CisKKy8qIE1heCBBdXRoZW50aWNhdGlvbiB0 YWcgc2l6ZSAqLworI2RlZmluZSBTQV9NQVhfQVVUSF9UQUdfU1ogNjQKKworI2RlZmluZSBQUklW X0lECTB4MQorI2RlZmluZSBQUklWCTB4MQorCitzdGF0aWMgc3RydWN0IGRldmljZSAqc2FfazNf ZGV2OworCisvKioKKyAqIHN0cnVjdCBzYV9jbWRsX2NmZyAtIENvbW1hbmQgbGFiZWwgY29uZmln dXJhdGlvbiBkZXNjcmlwdG9yCisgKiBAZW5jMXN0OiBJZiB0aGUgaXRlcmF0aW9uIG5lZWRzIGVu Y3J5cHRpb24gYmVmb3JlIGF1dGhlbnRpY2F0aW9uCisgKiBAYWFsZzogYXV0aGVudGljYXRpb24g YWxnb3JpdGhtIElECisgKiBAZW5jX2VuZ19pZDogRW5jcnlwdGlvbiBFbmdpbmUgSUQgc3VwcG9y dGVkIGJ5IHRoZSBTQSBoYXJkd2FyZQorICogQGF1dGhfZW5nX2lkOiBhdXRoZW50aWNhdGlvbiBF bmdpbmUgSUQKKyAqIEBpdl9zaXplOiBJbml0aWFsaXphdGlvbiBWZWN0b3Igc2l6ZQorICogQGFr ZXk6IEF1dGhlbnRpY2F0aW9uIGtleQorICogQGFrZXlfbGVuOiBBdXRoZW50aWNhdGlvbiBrZXkg bGVuZ3RoCisgKi8KK3N0cnVjdCBzYV9jbWRsX2NmZyB7CisJaW50IGVuYzFzdDsKKwlpbnQgYWFs ZzsKKwl1OCBlbmNfZW5nX2lkOworCXU4IGF1dGhfZW5nX2lkOworCXU4IGl2X3NpemU7CisJY29u c3QgdTggKmFrZXk7CisJdTE2IGFrZXlfbGVuOworCXUxNiBhdXRoX3N1YmtleV9sZW47Cit9Owor CisvKioKKyAqIHN0cnVjdCBhbGdvX2RhdGEgLSBDcnlwdG8gYWxnb3JpdGhtIHNwZWNpZmljIGRh dGEKKyAqIEBlbmNfZW5nOiBFbmNyeXB0aW9uIGVuZ2luZSBpbmZvIHN0cnVjdHVyZQorICogQGF1 dGhfZW5nOiBBdXRoZW50aWNhdGlvbiBlbmdpbmUgaW5mbyBzdHJ1Y3R1cmUKKyAqIEBhdXRoX2N0 cmw6IEF1dGhlbnRpY2F0aW9uIGNvbnRyb2wgd29yZAorICogQGhhc2hfc2l6ZTogU2l6ZSBvZiBE aWdlc3QKKyAqIEBlYWxnX2lkOiBFbmNyeXB0aW9uIEFsZ29yaXRobSBJRAorICogQGFhbGdfaWQ6 IEF1dGhlbnRpY2F0aW9uIGFsZ29yaXRobSBJRAorICogQG1jaV9lbmM6IE1vZGUgQ29udHJvbCBJ bnN0cnVjdGlvbiBmb3IgRW5jcnlwdGlvbiBhbGdvcml0aG0KKyAqIEBtY2lfZGVjOiBNb2RlIENv bnRyb2wgSW5zdHJ1Y3Rpb24gZm9yIERlY3J5cHRpb24KKyAqIEBpbnZfa2V5OiBXaGV0aGVyIHRo ZSBlbmNyeXB0aW9uIGFsZ29yaXRobSBkZW1hbmRzIGtleSBpbnZlcnNpb24KKyAqIEBrZXllZF9t YWM6IFdoZXRoZXIgdGhlIEF1dGhlbnRpY2F0aW9uIGFsZ29yaXRobSBoYXMgS2V5CisgKiBAcHJl cF9pb3BhZDogRnVuY3Rpb24gcG9pbnRlciB0byBnZW5lcmF0ZSBpbnRlcm1lZGlhdGUgaXBhZC9v cGFkCisgKi8KK3N0cnVjdCBhbGdvX2RhdGEgeworCXN0cnVjdCBzYV9lbmdfaW5mbyBlbmNfZW5n OworCXN0cnVjdCBzYV9lbmdfaW5mbyBhdXRoX2VuZzsKKwl1OCBhdXRoX2N0cmw7CisJdTggaGFz aF9zaXplOworCXU4IGVhbGdfaWQ7CisJdTggYWFsZ19pZDsKKwl1OCAqbWNpX2VuYzsKKwl1OCAq bWNpX2RlYzsKKwlib29sIGludl9rZXk7CisJYm9vbCBrZXllZF9tYWM7CisJdm9pZCAoKnByZXBf aW9wYWQpKGNvbnN0IHU4ICprZXksIHUxNiBrZXlfc3osIHUzMiAqaXBhZCwgdTMyICpvcGFkKTsK K307CisKKy8qKgorICogc3RydWN0IHNhX2FsZ190bXBsOiBBIGdlbmVyaWMgdGVtcGxhdGUgZW5j b21wYXNzaW5nIGNyeXB0by9hZWFkIGFsZ29yaXRobXMKKyAqIEBhbGc6IEEgdW5pb24gb2YgYWVh ZC9jcnlwdG8gYWxnb3JpdGhtIHR5cGUuCisgKiBAcmVnaXN0ZXJlZDogRmxhZyBpbmRpY2F0aW5n IGlmIHRoZSBjcnlwdG8gYWxnb3JpdGhtIGlzIGFscmVhZHkgcmVnaXN0ZXJlZAorICovCitzdHJ1 Y3Qgc2FfYWxnX3RtcGwgeworCXUzMiB0eXBlOwkJLyogQ1JZUFRPX0FMR19UWVBFIGZyb20gPGxp bnV4L2NyeXB0by5oPiAqLworCXVuaW9uIHsKKwkJc3RydWN0IGNyeXB0b19hbGcgY3J5cHRvOwor CQlzdHJ1Y3QgYWVhZF9hbGcgYWVhZDsKKwl9IGFsZzsKKwlpbnQgcmVnaXN0ZXJlZDsKK307CisK Ky8qKgorICogc3RydWN0IHNhX3J4X2RhdGE6IFJYIFBhY2tldCBtaXNjZWxsYW5lb3VzIGRhdGEg cGxhY2UgaG9sZGVyCisgKiBAcmVxOiBjcnlwdG8gcmVxdWVzdCBkYXRhIHBvaW50ZXIKKyAqIEBk ZGV2OiBETUEgZGV2aWNlIHBvaW50ZXIKKyAqIEB0eF9pbjogZG1hX2FzeW5jX3R4X2Rlc2NyaXB0 b3IgcG9pbnRlciBmb3IgcnggY2hhbm5lbAorICogQGVuYzogRmxhZyBpbmRpY2F0aW5nIGVpdGhl ciBlbmNyeXB0aW9uIG9yIGRlY3J5cHRpb24KKyAqLworc3RydWN0IHNhX3J4X2RhdGEgeworCXZv aWQgKnJlcTsKKwlzdHJ1Y3QgZGV2aWNlICpkZGV2OworCXN0cnVjdCBkbWFfYXN5bmNfdHhfZGVz Y3JpcHRvciAqdHhfaW47CisJdTggZW5jOworfTsKKworLyoKKyAqIE1vZGUgQ29udHJvbCBJbnN0 cnVjdGlvbnMgZm9yIHZhcmlvdXMgS2V5IGxlbmd0aHMgMTI4LCAxOTIsIDI1NgorICogRm9yIENC QyAoQ2lwaGVyIEJsb2NrIENoYWluaW5nKSBtb2RlIGZvciBlbmNyeXB0aW9uCisgKi8KK3N0YXRp YyB1OCBtY2lfY2JjX2VuY19hcnJheVszXVtNT0RFX0NPTlRST0xfQllURVNdID0geworCXsJMHgy MSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHgwYSwgMHhhYSwgMHg0YiwgMHg3ZSwgMHgwMCwK KwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJ MHgyMSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHg0YSwgMHhhYSwgMHg0YiwgMHg3ZSwgMHgw MCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAor CXsJMHgyMSwgMHgwMCwgMHgwMCwgMHgxOCwgMHg4OCwgMHg4YSwgMHhhYSwgMHg0YiwgMHg3ZSwg MHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9 LAorfTsKKworLyoKKyAqIE1vZGUgQ29udHJvbCBJbnN0cnVjdGlvbnMgZm9yIHZhcmlvdXMgS2V5 IGxlbmd0aHMgMTI4LCAxOTIsIDI1NgorICogRm9yIENCQyAoQ2lwaGVyIEJsb2NrIENoYWluaW5n KSBtb2RlIGZvciBkZWNyeXB0aW9uCisgKi8KK3N0YXRpYyB1OCBtY2lfY2JjX2RlY19hcnJheVsz XVtNT0RFX0NPTlRST0xfQllURVNdID0geworCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4MCwgMHg4 YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4NCwg MHg4YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgwMCwg MHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorCXsJMHgzMSwgMHgwMCwgMHgwMCwgMHg4 OCwgMHg4YSwgMHhjYSwgMHg5OCwgMHhmNCwgMHg0MCwgMHhjMCwKKwkJMHgwMCwgMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKKwkJMHgwMCwgMHgw MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMAl9LAorfTsKKworLyoKKyAqIFBlcmZvcm0g MTYgYnl0ZSBvciAxMjggYml0IHN3aXp6bGluZworICogVGhlIFNBMlVMIEV4cGVjdHMgdGhlIHNl Y3VyaXR5IGNvbnRleHQgdG8KKyAqIGJlIGluIGxpdHRsZSBFbmRpYW4gYW5kIHRoZSBidXMgd2lk dGggaXMgMTI4IGJpdHMgb3IgMTYgYnl0ZXMKKyAqIEhlbmNlIHN3YXAgMTYgYnl0ZXMgYXQgYSB0 aW1lIGZyb20gaGlnaGVyIHRvIGxvd2VyIGFkZHJlc3MKKyAqLworc3RhdGljIHZvaWQgc2Ffc3dp el8xMjgodTggKmluLCB1MTYgbGVuKQoreworCXU4IGRhdGFbMTZdOworCWludCBpLCBqOworCisJ Zm9yIChpID0gMDsgaSA8IGxlbjsgaSArPSAxNikgeworCQltZW1jcHkoZGF0YSwgJmluW2ldLCAx Nik7CisJCWZvciAoaiA9IDA7IGogPCAxNjsgaisrKQorCQkJaW5baSArIGpdID0gZGF0YVsxNSAt IGpdOworCX0KK30KKworLyogRGVyaXZlIHRoZSBpbnZlcnNlIGtleSB1c2VkIGluIEFFUy1DQkMg ZGVjcnlwdGlvbiBvcGVyYXRpb24gKi8KK3N0YXRpYyBpbmxpbmUgaW50IHNhX2Flc19pbnZfa2V5 KHU4ICppbnZfa2V5LCBjb25zdCB1OCAqa2V5LCB1MTYga2V5X3N6KQoreworCXN0cnVjdCBjcnlw dG9fYWVzX2N0eCBjdHg7CisJaW50IGtleV9wb3M7CisKKwlpZiAoY3J5cHRvX2Flc19leHBhbmRf a2V5KCZjdHgsIGtleSwga2V5X3N6KSkgeworCQlwcl9lcnIoIiVzOiBiYWQga2V5IGxlbiglZClc biIsIF9fZnVuY19fLCBrZXlfc3opOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBCYXNl ZCBjcnlwdG9fYWVzX2V4cGFuZF9rZXkgbG9naWMgKi8KKwlzd2l0Y2ggKGtleV9zeikgeworCWNh c2UgQUVTX0tFWVNJWkVfMTI4OgorCWNhc2UgQUVTX0tFWVNJWkVfMTkyOgorCQlrZXlfcG9zID0g a2V5X3N6ICsgMjQ7CisJCWJyZWFrOworCisJY2FzZSBBRVNfS0VZU0laRV8yNTY6CisJCWtleV9w b3MgPSBrZXlfc3ogKyAyNCAtIDQ7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcHJfZXJyKCIl czogYmFkIGtleSBsZW4oJWQpXG4iLCBfX2Z1bmNfXywga2V5X3N6KTsKKwkJcmV0dXJuIC1FSU5W QUw7CisJfQorCisJbWVtY3B5KGludl9rZXksICZjdHgua2V5X2VuY1trZXlfcG9zXSwga2V5X3N6 KTsKKwlyZXR1cm4gMDsKK30KKworLyogU2V0IFNlY3VyaXR5IGNvbnRleHQgZm9yIHRoZSBlbmNy eXB0aW9uIGVuZ2luZSAqLworc3RhdGljIGludCBzYV9zZXRfc2NfZW5jKHN0cnVjdCBhbGdvX2Rh dGEgKmFkLCBjb25zdCB1OCAqa2V5LCB1MTYga2V5X3N6LAorCQkJIHUxNiBhYWRfbGVuLCB1OCBl bmMsIHU4ICpzY19idWYpCit7CisJY29uc3QgdTggKm1jaSA9IE5VTEw7CisKKwkvKiBTZXQgRW5j cnlwdGlvbiBtb2RlIHNlbGVjdG9yIHRvIGNyeXB0byBwcm9jZXNzaW5nICovCisJc2NfYnVmWzBd ID0gU0FfQ1JZUFRPX1BST0NFU1NJTkc7CisKKwlpZiAoZW5jKQorCQltY2kgPSBhZC0+bWNpX2Vu YzsKKwllbHNlCisJCW1jaSA9IGFkLT5tY2lfZGVjOworCS8qIFNldCB0aGUgbW9kZSBjb250cm9s IGluc3RydWN0aW9ucyBpbiBzZWN1cml0eSBjb250ZXh0ICovCisJaWYgKG1jaSkKKwkJbWVtY3B5 KCZzY19idWZbMV0sIG1jaSwgTU9ERV9DT05UUk9MX0JZVEVTKTsKKworCS8qIEZvciBBRVMtQ0JD IGRlY3J5cHRpb24gZ2V0IHRoZSBpbnZlcnNlIGtleSAqLworCWlmIChhZC0+aW52X2tleSAmJiAh ZW5jKSB7CisJCWlmIChzYV9hZXNfaW52X2tleSgmc2NfYnVmW1NDX0VOQ19LRVlfT0ZGU0VUXSwg a2V5LCBrZXlfc3opKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJLyogRm9yIGFsbCBvdGhlciBjYXNl czoga2V5IGlzIHVzZWQgKi8KKwl9IGVsc2UgeworCQltZW1jcHkoJnNjX2J1ZltTQ19FTkNfS0VZ X09GRlNFVF0sIGtleSwga2V5X3N6KTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyogU2V0IFNl Y3VyaXR5IGNvbnRleHQgZm9yIHRoZSBhdXRoZW50aWNhdGlvbiBlbmdpbmUgKi8KK3N0YXRpYyB2 b2lkIHNhX3NldF9zY19hdXRoKHN0cnVjdCBhbGdvX2RhdGEgKmFkLCBjb25zdCB1OCAqa2V5LCB1 MTYga2V5X3N6LAorCQkJICAgdTggKnNjX2J1ZikKK3sKKwl1MzIgaXBhZFs2NF0sIG9wYWRbNjRd OworCisJLyogU2V0IEF1dGhlbnRpY2F0aW9uIG1vZGUgc2VsZWN0b3IgdG8gaGFzaCBwcm9jZXNz aW5nICovCisJc2NfYnVmWzBdID0gU0FfSEFTSF9QUk9DRVNTSU5HOworCS8qIEF1dGggU1cgY3Ry bCB3b3JkOiBiaXRbNl09MSAodXBsb2FkIGNvbXB1dGVkIGhhc2ggdG8gVExSIHNlY3Rpb24pICov CisJc2NfYnVmWzFdID0gU0FfVVBMT0FEX0hBU0hfVE9fVExSOworCXNjX2J1ZlsxXSB8PSBhZC0+ YXV0aF9jdHJsOworCisJLyogQ29weSB0aGUga2V5cyBvciBpcGFkL29wYWQgKi8KKwlpZiAoYWQt PmtleWVkX21hYykgeworCQlhZC0+cHJlcF9pb3BhZChrZXksIGtleV9zeiwgaXBhZCwgb3BhZCk7 CisJCS8qIENvcHkgaXBhZCB0byBBdXRoS2V5ICovCisJCW1lbWNweSgmc2NfYnVmWzMyXSwgaXBh ZCwgYWQtPmhhc2hfc2l6ZSk7CisJCS8qIENvcHkgb3BhZCB0byBBdXgtMSAqLworCQltZW1jcHko JnNjX2J1Zls2NF0sIG9wYWQsIGFkLT5oYXNoX3NpemUpOworCX0KK30KKworc3RhdGljIGlubGlu ZSB2b2lkIHNhX2NvcHlfaXYodTMyICpvdXQsIGNvbnN0IHU4ICppdiwgYm9vbCBzaXplMTYpCit7 CisJaW50IGo7CisKKwlmb3IgKGogPSAwOyBqIDwgKChzaXplMTYpID8gNCA6IDIpOyBqKyspIHsK KwkJKm91dCA9IGNwdV90b19iZTMyKCooKHUzMiAqKWl2KSk7CisJCWl2ICs9IDQ7CisJCW91dCsr OworCX0KK30KKworLyogRm9ybWF0IGdlbmVyYWwgY29tbWFuZCBsYWJlbCAqLworc3RhdGljIGlu dCBzYV9mb3JtYXRfY21kbF9nZW4oc3RydWN0IHNhX2NtZGxfY2ZnICpjZmcsIHU4ICpjbWRsLAor CQkJICAgICAgc3RydWN0IHNhX2NtZGxfdXBkX2luZm8gKnVwZF9pbmZvKQoreworCXU4IGVuY19v ZmZzZXQgPSAwLCBhdXRoX29mZnNldCA9IDAsIHRvdGFsID0gMDsKKwl1OCBlbmNfbmV4dF9lbmcg PSBTQV9FTkdfSURfT1VUUE9SVDI7CisJdTggYXV0aF9uZXh0X2VuZyA9IFNBX0VOR19JRF9PVVRQ T1JUMjsKKwl1MzIgKndvcmRfcHRyID0gKHUzMiAqKWNtZGw7CisJaW50IGk7CisKKwkvKiBDbGVh ciB0aGUgY29tbWFuZCBsYWJlbCAqLworCW1lbXplcm9fZXhwbGljaXQoY21kbCwgKFNBX01BWF9D TURMX1dPUkRTICogc2l6ZW9mKHUzMikpKTsKKworCS8qIEluaWlhbGl6ZSB0aGUgY29tbWFuZCB1 cGRhdGUgc3RydWN0dXJlICovCisJbWVtemVyb19leHBsaWNpdCh1cGRfaW5mbywgc2l6ZW9mKCp1 cGRfaW5mbykpOworCisJaWYgKGNmZy0+ZW5jMXN0KSB7CisJCWlmIChjZmctPmVuY19lbmdfaWQg IT0gU0FfRU5HX0lEX05PTkUpCisJCQlhdXRoX29mZnNldCA9IFNBX0NNRExfSEVBREVSX1NJWkVf QllURVM7CisKKwkJaWYgKGNmZy0+aXZfc2l6ZSkKKwkJCWF1dGhfb2Zmc2V0ICs9IGNmZy0+aXZf c2l6ZTsKKworCQlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAhPSBTQV9FTkdfSURfTk9ORSkKKwkJCWVu Y19uZXh0X2VuZyA9IGNmZy0+YXV0aF9lbmdfaWQ7CisJCWVsc2UKKwkJCWVuY19uZXh0X2VuZyA9 IFNBX0VOR19JRF9PVVRQT1JUMjsKKwl9IGVsc2UgeworCQlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAh PSBTQV9FTkdfSURfTk9ORSkKKwkJCWVuY19vZmZzZXQgPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZ VEVTOworCisJCWlmIChjZmctPmF1dGhfc3Via2V5X2xlbikKKwkJCWVuY19vZmZzZXQgKz0gY2Zn LT5hdXRoX3N1YmtleV9sZW47CisKKwkJaWYgKGNmZy0+ZW5jX2VuZ19pZCAhPSBTQV9FTkdfSURf Tk9ORSkKKwkJCWF1dGhfbmV4dF9lbmcgPSBjZmctPmVuY19lbmdfaWQ7CisJCWVsc2UKKwkJCWF1 dGhfbmV4dF9lbmcgPSBTQV9FTkdfSURfT1VUUE9SVDI7CisJfQorCisJaWYgKGNmZy0+ZW5jX2Vu Z19pZCAhPSBTQV9FTkdfSURfTk9ORSkgeworCQl1cGRfaW5mby0+ZmxhZ3MgfD0gU0FfQ01ETF9V UERfRU5DOworCQl1cGRfaW5mby0+ZW5jX3NpemUuaW5kZXggPSBlbmNfb2Zmc2V0ID4+IDI7CisJ CXVwZF9pbmZvLT5lbmNfb2Zmc2V0LmluZGV4ID0gdXBkX2luZm8tPmVuY19zaXplLmluZGV4ICsg MTsKKwkJLyogRW5jcnlwdGlvbiBjb21tYW5kIGxhYmVsICovCisJCWNtZGxbZW5jX29mZnNldCAr IFNBX0NNRExfT0ZGU0VUX05FU0NdID0gZW5jX25leHRfZW5nOworCisJCS8qIEVuY3J5cHRpb24g bW9kZXMgcmVxdWlyaW5nIElWICovCisJCWlmIChjZmctPml2X3NpemUpIHsKKwkJCXVwZF9pbmZv LT5mbGFncyB8PSBTQV9DTURMX1VQRF9FTkNfSVY7CisJCQl1cGRfaW5mby0+ZW5jX2l2LmluZGV4 ID0KKwkJCQkoZW5jX29mZnNldCArIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMpID4+IDI7CisJ CQl1cGRfaW5mby0+ZW5jX2l2LnNpemUgPSBjZmctPml2X3NpemU7CisKKwkJCWNtZGxbZW5jX29m ZnNldCArIFNBX0NNRExfT0ZGU0VUX0xBQkVMX0xFTl0gPQorCQkJCVNBX0NNRExfSEVBREVSX1NJ WkVfQllURVMgKyBjZmctPml2X3NpemU7CisKKwkJCWNtZGxbZW5jX29mZnNldCArIFNBX0NNRExf T0ZGU0VUX09QVElPTl9DVFJMMV0gPQorCQkJCShTQV9DVFhfRU5DX0FVWDJfT0ZGU0VUIHwgKGNm Zy0+aXZfc2l6ZSA+PiAzKSk7CisJCQllbmNfb2Zmc2V0ICs9IFNBX0NNRExfSEVBREVSX1NJWkVf QllURVMgKyBjZmctPml2X3NpemU7CisJCX0gZWxzZSB7CisJCQljbWRsW2VuY19vZmZzZXQgKyBT QV9DTURMX09GRlNFVF9MQUJFTF9MRU5dID0KKwkJCQkJCVNBX0NNRExfSEVBREVSX1NJWkVfQllU RVM7CisJCQllbmNfb2Zmc2V0ICs9IFNBX0NNRExfSEVBREVSX1NJWkVfQllURVM7CisJCX0KKwl9 CisKKwlpZiAoY2ZnLT5hdXRoX2VuZ19pZCAhPSBTQV9FTkdfSURfTk9ORSkgeworCQl1cGRfaW5m by0+ZmxhZ3MgfD0gU0FfQ01ETF9VUERfQVVUSDsKKwkJdXBkX2luZm8tPmF1dGhfc2l6ZS5pbmRl eCA9IGF1dGhfb2Zmc2V0ID4+IDI7CisJCXVwZF9pbmZvLT5hdXRoX29mZnNldC5pbmRleCA9IHVw ZF9pbmZvLT5hdXRoX3NpemUuaW5kZXggKyAxOworCQljbWRsW2F1dGhfb2Zmc2V0ICsgU0FfQ01E TF9PRkZTRVRfTkVTQ10gPSBhdXRoX25leHRfZW5nOworCisJCS8qIEFsZ29yaXRobSB3aXRoIHN1 YmtleXMgKi8KKwkJaWYgKGNmZy0+YWFsZyA9PSBTQV9BQUxHX0lEX0FFU19YQ0JDIHx8CisJCSAg ICBjZmctPmFhbGcgPT0gU0FfQUFMR19JRF9DTUFDKSB7CisJCQl1cGRfaW5mby0+ZmxhZ3MgfD0g U0FfQ01ETF9VUERfQVVYX0tFWTsKKwkJCXVwZF9pbmZvLT5hdXhfa2V5X2luZm8uaW5kZXggPQor CQkJCShhdXRoX29mZnNldCArIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMpID4+IDI7CisJCQlj bWRsW2F1dGhfb2Zmc2V0ICsgU0FfQ01ETF9PRkZTRVRfTEFCRUxfTEVOXSA9CisJCQkJCQlTQV9D TURMX0hFQURFUl9TSVpFX0JZVEVTICsKKwkJCQkJCQljZmctPmF1dGhfc3Via2V5X2xlbjsKKwkJ CWNtZGxbYXV0aF9vZmZzZXQgKyBTQV9DTURMX09GRlNFVF9PUFRJT05fQ1RSTDFdID0KKwkJCQkJ CShTQV9DVFhfRU5DX0FVWDFfT0ZGU0VUIHwKKwkJCQkJCShjZmctPmF1dGhfc3Via2V5X2xlbiAg Pj4gMykpOworCisJCQlhdXRoX29mZnNldCArPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVTICsK KwkJCQkJCQljZmctPmF1dGhfc3Via2V5X2xlbjsKKwkJfSBlbHNlIHsKKwkJCWNtZGxbYXV0aF9v ZmZzZXQgKyBTQV9DTURMX09GRlNFVF9MQUJFTF9MRU5dID0KKwkJCQkJCVNBX0NNRExfSEVBREVS X1NJWkVfQllURVM7CisJCQlhdXRoX29mZnNldCArPSBTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVT OworCQl9CisJfQorCisJaWYgKGNmZy0+ZW5jMXN0KQorCQl0b3RhbCA9IGF1dGhfb2Zmc2V0Owor CWVsc2UKKwkJdG90YWwgPSBlbmNfb2Zmc2V0OworCisJdG90YWwgPSByb3VuZHVwKHRvdGFsLCA4 KTsKKworCWZvciAoaSA9IDA7IGkgPCB0b3RhbCAvIDQ7IGkrKykKKwkJd29yZF9wdHJbaV0gPSBi ZTMyX3RvX2NwdSh3b3JkX3B0cltpXSk7CisKKwlyZXR1cm4gdG90YWw7Cit9CisKKy8qIFVwZGF0 ZSBDb21tYW5kIGxhYmVsICovCitzdGF0aWMgaW5saW5lIHZvaWQKK3NhX3VwZGF0ZV9jbWRsKHN0 cnVjdCBkZXZpY2UgKmRldiwgdTggZW5jX29mZnNldCwgdTE2IGVuY19zaXplLCB1OCAqZW5jX2l2 LAorCSAgICAgICB1OCBhdXRoX29mZnNldCwgdTE2IGF1dGhfc2l6ZSwgdTggKmF1dGhfaXYsIHU4 IGFhZF9zaXplLAorCSAgICAgICB1OCAqYWFkLCBzdHJ1Y3Qgc2FfY21kbF91cGRfaW5mbyAqdXBk X2luZm8sIHUzMiAqY21kbCkKK3sKKwlpbnQgaSA9IDAsIGo7CisKKwlpZiAodXBkX2luZm8tPnN1 Ym1vZGUgIT0gU0FfTU9ERV9HRU4pIHsKKwkJZGV2X2VycihkZXYsICJ1bnN1cHBvcnRlZCBtb2Rl KCVkKVxuIiwgdXBkX2luZm8tPnN1Ym1vZGUpOworCQlyZXR1cm47CisJfQorCisJaWYgKGxpa2Vs eSh1cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9FTkMpKSB7CisJCWNtZGxbdXBkX2luZm8t PmVuY19zaXplLmluZGV4XSAmPSB+U0FfQ01ETF9QQVlMT0FEX0xFTkdUSF9NQVNLOworCQljbWRs W3VwZF9pbmZvLT5lbmNfc2l6ZS5pbmRleF0gfD0gZW5jX3NpemU7CisJCWNtZGxbdXBkX2luZm8t PmVuY19vZmZzZXQuaW5kZXhdICY9CisJCQkJCQl+U0FfQ01ETF9TT1BfQllQQVNTX0xFTl9NQVNL OworCQljbWRsW3VwZF9pbmZvLT5lbmNfb2Zmc2V0LmluZGV4XSB8PQorCQkJKCh1MzIpZW5jX29m ZnNldCA8PCBfX2ZmcyhTQV9DTURMX1NPUF9CWVBBU1NfTEVOX01BU0spKTsKKworCQlpZiAobGlr ZWx5KHVwZF9pbmZvLT5mbGFncyAmIFNBX0NNRExfVVBEX0VOQ19JVikpIHsKKwkJCXUzMiAqZGF0 YSA9ICZjbWRsW3VwZF9pbmZvLT5lbmNfaXYuaW5kZXhdOworCisJCQlmb3IgKGogPSAwOyBpIDwg dXBkX2luZm8tPmVuY19pdi5zaXplOyBpICs9IDQsIGorKykgeworCQkJCWRhdGFbal0gPSBjcHVf dG9fYmUzMigqKCh1MzIgKillbmNfaXYpKTsKKwkJCQllbmNfaXYgKz0gNDsKKwkJCX0KKwkJfQor CX0KKworCWlmIChsaWtlbHkodXBkX2luZm8tPmZsYWdzICYgU0FfQ01ETF9VUERfQVVUSCkpIHsK KwkJY21kbFt1cGRfaW5mby0+YXV0aF9zaXplLmluZGV4XSAmPSB+U0FfQ01ETF9QQVlMT0FEX0xF TkdUSF9NQVNLOworCQljbWRsW3VwZF9pbmZvLT5hdXRoX3NpemUuaW5kZXhdIHw9IGF1dGhfc2l6 ZTsKKwkJY21kbFt1cGRfaW5mby0+YXV0aF9vZmZzZXQuaW5kZXhdICY9CisJCQkJCQl+U0FfQ01E TF9TT1BfQllQQVNTX0xFTl9NQVNLOworCQljbWRsW3VwZF9pbmZvLT5hdXRoX29mZnNldC5pbmRl eF0gfD0gKCh1MzIpYXV0aF9vZmZzZXQgPDwKKwkJCQkJX19mZnMoU0FfQ01ETF9TT1BfQllQQVNT X0xFTl9NQVNLKSk7CisJCWlmICh1cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9BVVRIX0lW KSB7CisJCQlzYV9jb3B5X2l2KCZjbWRsW3VwZF9pbmZvLT5hdXRoX2l2LmluZGV4XSwgYXV0aF9p diwKKwkJCQkgICAodXBkX2luZm8tPmF1dGhfaXYuc2l6ZSA+IDgpKTsKKwkJfQorCisJCWlmICh1 cGRfaW5mby0+ZmxhZ3MgJiBTQV9DTURMX1VQRF9BVVhfS0VZKSB7CisJCQlpbnQgb2Zmc2V0ID0g KGF1dGhfc2l6ZSAmIDB4RikgPyA0IDogMDsKKworCQkJbWVtY3B5KCZjbWRsW3VwZF9pbmZvLT5h dXhfa2V5X2luZm8uaW5kZXhdLAorCQkJICAgICAgICZ1cGRfaW5mby0+YXV4X2tleVtvZmZzZXRd LCAxNik7CisJCX0KKwl9Cit9CisKKy8qIEZvcm1hdCBTV0lORk8gd29yZHMgdG8gYmUgc2VudCB0 byBTQSAqLworc3RhdGljCit2b2lkIHNhX3NldF9zd2luZm8odTggZW5nX2lkLCB1MTYgc2NfaWQs IGRtYV9hZGRyX3Qgc2NfcGh5cywKKwkJICAgdTggY21kbF9wcmVzZW50LCB1OCBjbWRsX29mZnNl dCwgdTggZmxhZ3MsCisJCSAgIHU4IGhhc2hfc2l6ZSwgdTMyICpzd2luZm8pCit7CisJc3dpbmZv WzBdID0gc2NfaWQ7CisJc3dpbmZvWzBdIHw9IChmbGFncyA8PCBfX2ZmcyhTQV9TVzBfRkxBR1Nf TUFTSykpOworCWlmIChsaWtlbHkoY21kbF9wcmVzZW50KSkKKwkJc3dpbmZvWzBdIHw9ICgoY21k bF9vZmZzZXQgfCBTQV9TVzBfQ01ETF9QUkVTRU5UKSA8PAorCQkJCQkJX19mZnMoU0FfU1cwX0NN RExfSU5GT19NQVNLKSk7CisJc3dpbmZvWzBdIHw9IChlbmdfaWQgPDwgX19mZnMoU0FfU1cwX0VO R19JRF9NQVNLKSk7CisKKwlzd2luZm9bMF0gfD0gU0FfU1cwX0RFU1RfSU5GT19QUkVTRU5UOwor CXN3aW5mb1sxXSA9ICh1MzIpKHNjX3BoeXMgJiAweEZGRkZGRkZGVUxMKTsKKwlzd2luZm9bMl0g PSAodTMyKSgoc2NfcGh5cyAmIDB4RkZGRkZGRkYwMDAwMDAwMFVMTCkgPj4gMzIpOworCXN3aW5m b1syXSB8PSAoaGFzaF9zaXplIDw8IF9fZmZzKFNBX1NXMl9FR1JFU1NfTEVOR1RIKSk7Cit9CisK Ky8qIER1bXAgdGhlIHNlY3VyaXR5IGNvbnRleHQgKi8KK3N0YXRpYyB2b2lkIHNhX2R1bXBfc2Mo dTggKmJ1ZiwgZG1hX2FkZHJfdCBkbWFfYWRkcikKK3sKKyNpZmRlZiBERUJVRworCWRldl9pbmZv KHNhX2szX2RldiwgIlNlY3VyaXR5IGNvbnRleHQgZHVtcDo6IDB4JXBhZFxuIiwgJmRtYV9hZGRy KTsKKwlwcmludF9oZXhfZHVtcChLRVJOX0NPTlQsICIiLCBEVU1QX1BSRUZJWF9PRkZTRVQsCisJ CSAgICAgICAxNiwgMSwgYnVmLCBTQV9DVFhfTUFYX1NaLCBmYWxzZSk7CisjZW5kaWYKK30KKwor c3RhdGljCitpbnQgc2FfaW5pdF9zYyhzdHJ1Y3Qgc2FfY3R4X2luZm8gKmN0eCwgY29uc3QgdTgg KmVuY19rZXksCisJICAgICAgIHUxNiBlbmNfa2V5X3N6LCBjb25zdCB1OCAqYXV0aF9rZXksIHUx NiBhdXRoX2tleV9zeiwKKwkgICAgICAgc3RydWN0IGFsZ29fZGF0YSAqYWQsIHU4IGVuYywgdTMy ICpzd2luZm8sIGJvb2wgYXV0aF9yZXEpCit7CisJaW50IHVzZV9lbmMgPSAwOworCWludCBlbmNf c2Nfb2Zmc2V0LCBhdXRoX3NjX29mZnNldDsKKwl1OCAqc2NfYnVmID0gY3R4LT5zYzsKKwl1MTYg c2NfaWQgPSBjdHgtPnNjX2lkOworCXUxNiBhYWRfbGVuID0gMDsJLyogQ3VycmVudGx5IG5vdCBz dXBwb3J0aW5nIEFFQUQgYWxnbyAqLworCXU4IGZpcnN0X2VuZ2luZTsKKworCW1lbXplcm9fZXhw bGljaXQoc2NfYnVmLCBTQV9DVFhfTUFYX1NaKTsKKworCWlmIChhZC0+YXV0aF9lbmcuZW5nX2lk IDw9IFNBX0VOR19JRF9FTTIgfHwgIWF1dGhfcmVxKQorCQl1c2VfZW5jID0gMTsKKworCS8qIERl dGVybWluZSB0aGUgb3JkZXIgb2YgZW5jcnlwdGlvbiAmIEF1dGhlbnRpY2F0aW9uIGNvbnRleHRz ICovCisJaWYgKGVuYyB8fCAhdXNlX2VuYykgeworCQlpZiAoYXV0aF9yZXEpIHsKKwkJCWVuY19z Y19vZmZzZXQgPSBTQV9DVFhfUEhQX1BFX0NUWF9TWjsKKwkJCWF1dGhfc2Nfb2Zmc2V0ID0gZW5j X3NjX29mZnNldCArIGFkLT5lbmNfZW5nLnNjX3NpemU7CisJCX0gZWxzZSB7CisJCQllbmNfc2Nf b2Zmc2V0ID0gU0FfQ1RYX1BIUF9QRV9DVFhfU1o7CisJCX0KKwl9IGVsc2UgeworCQlhdXRoX3Nj X29mZnNldCA9IFNBX0NUWF9QSFBfUEVfQ1RYX1NaOworCQllbmNfc2Nfb2Zmc2V0ID0gYXV0aF9z Y19vZmZzZXQgKyBhZC0+YXV0aF9lbmcuc2Nfc2l6ZTsKKwl9CisKKwkvKiBTQ0NUTCBPd25lciBp bmZvOiAwPWhvc3QsIDE9Q1BfQUNFICovCisJc2NfYnVmW1NBX0NUWF9TQ0NUTF9PV05FUl9PRkZT RVRdID0gMDsKKwkvKiBTQ0NUTCBGL0UgY29udHJvbCAqLworCWlmIChhdXRoX3JlcSkKKwkJc2Nf YnVmWzFdID0gU0FfU0NDVExfRkVfQVVUSF9FTkM7CisJZWxzZQorCQlzY19idWZbMV0gPSBTQV9T Q0NUTF9GRV9FTkM7CisJbWVtY3B5KCZzY19idWZbMl0sICZzY19pZCwgMik7CisJc2NfYnVmWzRd ID0gMHgwOworCXNjX2J1Zls1XSA9IFBSSVZfSUQ7CisJc2NfYnVmWzZdID0gUFJJVjsKKwlzY19i dWZbN10gPSAweDA7CisKKwkvKiBJbml0aWFsaXplIHRoZSByZXN0IG9mIFBIUCBjb250ZXh0ICov CisJbWVtemVyb19leHBsaWNpdChzY19idWYgKyBTQV9TQ0NUTF9TWiwgU0FfQ1RYX1BIUF9QRV9D VFhfU1ogLQorCQkJIFNBX1NDQ1RMX1NaKTsKKworCS8qIFByZXBhcmUgY29udGV4dCBmb3IgZW5j cnlwdGlvbiBlbmdpbmUgKi8KKwlpZiAoYWQtPmVuY19lbmcuc2Nfc2l6ZSkgeworCQlpZiAoc2Ff c2V0X3NjX2VuYyhhZCwgZW5jX2tleSwgZW5jX2tleV9zeiwgYWFkX2xlbiwKKwkJCQkgIGVuYywg JnNjX2J1ZltlbmNfc2Nfb2Zmc2V0XSkpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBQ cmVwYXJlIGNvbnRleHQgZm9yIGF1dGhlbnRpY2F0aW9uIGVuZ2luZSAqLworCWlmIChhZC0+YXV0 aF9lbmcuc2Nfc2l6ZSkgeworCQlpZiAodXNlX2VuYykgeworCQkJaWYgKHNhX3NldF9zY19lbmMo YWQsIGF1dGhfa2V5LCBhdXRoX2tleV9zeiwKKwkJCQkJICBhYWRfbGVuLCAwLCAmc2NfYnVmW2F1 dGhfc2Nfb2Zmc2V0XSkpCisJCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0gZWxzZSB7CisJCQlzYV9z ZXRfc2NfYXV0aChhZCwgYXV0aF9rZXksIGF1dGhfa2V5X3N6LAorCQkJCSAgICAgICAmc2NfYnVm W2F1dGhfc2Nfb2Zmc2V0XSk7CisJCX0KKwl9CisKKwkvKiBTZXQgdGhlIG93bmVyc2hpcCBvZiBj b250ZXh0IHRvIENQX0FDRSAqLworCXNjX2J1ZltTQV9DVFhfU0NDVExfT1dORVJfT0ZGU0VUXSA9 IDB4ODA7CisKKwkvKiBzd2l6emxlIHRoZSBzZWN1cml0eSBjb250ZXh0ICovCisJc2Ffc3dpel8x Mjgoc2NfYnVmLCBTQV9DVFhfTUFYX1NaKTsKKwkvKiBTZXR1cCBTV0lORk8gKi8KKwlpZiAoIWF1 dGhfcmVxKQorCQlmaXJzdF9lbmdpbmUgPSBhZC0+ZW5jX2VuZy5lbmdfaWQ7CisJZWxzZQorCQlm aXJzdF9lbmdpbmUgPSBlbmMgPyBhZC0+ZW5jX2VuZy5lbmdfaWQgOiBhZC0+YXV0aF9lbmcuZW5n X2lkOworCisJaWYgKGF1dGhfcmVxKSB7CisJCWlmICghYWQtPmhhc2hfc2l6ZSkKKwkJCXJldHVy biAtRUlOVkFMOworCQkvKiBSb3VuZCB1cCB0aGUgdGFnIHNpemUgdG8gbXVsdGlwbGUgb2YgNCAq LworCQlhZC0+aGFzaF9zaXplID0gcm91bmR1cChhZC0+aGFzaF9zaXplLCA4KTsKKwl9CisKKwlz YV9zZXRfc3dpbmZvKGZpcnN0X2VuZ2luZSwgY3R4LT5zY19pZCwgY3R4LT5zY19waHlzLCAxLCAw LAorCQkgICAgICBTQV9TV19JTkZPX0ZMQUdfRVZJQ1QsIGFkLT5oYXNoX3NpemUsIHN3aW5mbyk7 CisKKwlzYV9kdW1wX3NjKHNjX2J1ZiwgY3R4LT5zY19waHlzKTsKKworCXJldHVybiAwOworfQor CisvKiBGcmVlIHRoZSBwZXIgZGlyZWN0aW9uIGNvbnRleHQgbWVtb3J5ICovCitzdGF0aWMgdm9p ZCBzYV9mcmVlX2N0eF9pbmZvKHN0cnVjdCBzYV9jdHhfaW5mbyAqY3R4LAorCQkJICAgICBzdHJ1 Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEpCit7CisJdW5zaWduZWQgbG9uZyBibjsKKworCWJuID0g Y3R4LT5zY19pZCAtIGRhdGEtPnNjX2lkX3N0YXJ0OworCXNwaW5fbG9jaygmZGF0YS0+c2NpZF9s b2NrKTsKKwlfX2NsZWFyX2JpdChibiwgZGF0YS0+Y3R4X2JtKTsKKwlkYXRhLT5zY19pZC0tOwor CXNwaW5fdW5sb2NrKCZkYXRhLT5zY2lkX2xvY2spOworCisJaWYgKGN0eC0+c2MpIHsKKwkJZG1h X3Bvb2xfZnJlZShkYXRhLT5zY19wb29sLCBjdHgtPnNjLCBjdHgtPnNjX3BoeXMpOworCQljdHgt PnNjID0gTlVMTDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgc2FfaW5pdF9jdHhfaW5mbyhzdHJ1Y3Qg c2FfY3R4X2luZm8gKmN0eCwKKwkJCSAgICBzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEpCit7 CisJdW5zaWduZWQgbG9uZyBibjsKKwlpbnQgZXJyOworCisJc3Bpbl9sb2NrKCZkYXRhLT5zY2lk X2xvY2spOworCWJuID0gZmluZF9maXJzdF96ZXJvX2JpdChkYXRhLT5jdHhfYm0sIFNBX01BWF9O VU1fQ1RYKTsKKwlfX3NldF9iaXQoYm4sIGRhdGEtPmN0eF9ibSk7CisJZGF0YS0+c2NfaWQrKzsK KwlzcGluX3VubG9jaygmZGF0YS0+c2NpZF9sb2NrKTsKKworCWN0eC0+c2NfaWQgPSAodTE2KShk YXRhLT5zY19pZF9zdGFydCArIGJuKTsKKworCWN0eC0+c2MgPSBkbWFfcG9vbF9hbGxvYyhkYXRh LT5zY19wb29sLCBHRlBfS0VSTkVMLCAmY3R4LT5zY19waHlzKTsKKwlpZiAoIWN0eC0+c2MpIHsK KwkJZGV2X2VycigmZGF0YS0+cGRldi0+ZGV2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIFNDIG1lbW9y eVxuIik7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gc2NpZF9yb2xsYmFjazsKKwl9CisKKwly ZXR1cm4gMDsKKworc2NpZF9yb2xsYmFjazoKKwlzcGluX2xvY2soJmRhdGEtPnNjaWRfbG9jayk7 CisJX19jbGVhcl9iaXQoYm4sIGRhdGEtPmN0eF9ibSk7CisJZGF0YS0+c2NfaWQtLTsKKwlzcGlu X3VubG9jaygmZGF0YS0+c2NpZF9sb2NrKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB2 b2lkIHNhX2Flc19jcmFfZXhpdChzdHJ1Y3QgY3J5cHRvX3RmbSAqdGZtKQoreworCXN0cnVjdCBj cnlwdG9fYWxnICphbGcgPSB0Zm0tPl9fY3J0X2FsZzsKKwlzdHJ1Y3Qgc2FfdGZtX2N0eCAqY3R4 ID0gY3J5cHRvX3RmbV9jdHgodGZtKTsKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRhdGEgPSBk ZXZfZ2V0X2RydmRhdGEoc2FfazNfZGV2KTsKKworCWRldl9kYmcoc2FfazNfZGV2LCAiJXMoMHgl cCkgc2MtaWRzKDB4JXgoMHglcGFkKSwgMHgleCgweCVwYWQpKVxuIiwKKwkJX19mdW5jX18sIHRm bSwgY3R4LT5lbmMuc2NfaWQsICZjdHgtPmVuYy5zY19waHlzLAorCQljdHgtPmRlYy5zY19pZCwg JmN0eC0+ZGVjLnNjX3BoeXMpOworCisJaWYgKChhbGctPmNyYV9mbGFncyAmIENSWVBUT19BTEdf VFlQRV9BQkxLQ0lQSEVSKQorCSAgICA9PSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUikgewor CQlzYV9mcmVlX2N0eF9pbmZvKCZjdHgtPmVuYywgZGF0YSk7CisJCXNhX2ZyZWVfY3R4X2luZm8o JmN0eC0+ZGVjLCBkYXRhKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgc2FfYWVzX2NyYV9pbml0KHN0 cnVjdCBjcnlwdG9fdGZtICp0Zm0pCit7CisJc3RydWN0IHNhX3RmbV9jdHggKmN0eCA9IGNyeXB0 b190Zm1fY3R4KHRmbSk7CisJc3RydWN0IGNyeXB0b19hbGcgKmFsZyA9IHRmbS0+X19jcnRfYWxn OworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShzYV9rM19k ZXYpOworCWludCByZXQ7CisKKwlpZiAoKGFsZy0+Y3JhX2ZsYWdzICYgQ1JZUFRPX0FMR19UWVBF X01BU0spID09CisJICAgIENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSKSB7CisJCW1lbXplcm9f ZXhwbGljaXQoY3R4LCBzaXplb2YoKmN0eCkpOworCQljdHgtPmRldl9kYXRhID0gZGF0YTsKKwor CQlyZXQgPSBzYV9pbml0X2N0eF9pbmZvKCZjdHgtPmVuYywgZGF0YSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQlyZXQgPSBzYV9pbml0X2N0eF9pbmZvKCZjdHgtPmRlYywgZGF0YSk7 CisJCWlmIChyZXQpIHsKKwkJCXNhX2ZyZWVfY3R4X2luZm8oJmN0eC0+ZW5jLCBkYXRhKTsKKwkJ CXJldHVybiByZXQ7CisJCX0KKwl9CisKKwlkZXZfZGJnKHNhX2szX2RldiwgIiVzKDB4JXApIHNj LWlkcygweCV4KDB4JXBhZCksIDB4JXgoMHglcGFkKSlcbiIsCisJCV9fZnVuY19fLCB0Zm0sIGN0 eC0+ZW5jLnNjX2lkLCAmY3R4LT5lbmMuc2NfcGh5cywKKwkJY3R4LT5kZWMuc2NfaWQsICZjdHgt PmRlYy5zY19waHlzKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV9hZXNfc2V0a2V5 KHN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAqdGZtLCBjb25zdCB1OCAqa2V5LAorCQkJIHVuc2ln bmVkIGludCBrZXlsZW4sIHN0cnVjdCBhbGdvX2RhdGEgKmFkKQoreworCXN0cnVjdCBzYV90Zm1f Y3R4ICpjdHggPSBjcnlwdG9fYWJsa2NpcGhlcl9jdHgodGZtKTsKKworCWNvbnN0IGNoYXIgKmNy YV9uYW1lOworCWludCBjbWRsX2xlbjsKKwlzdHJ1Y3Qgc2FfY21kbF9jZmcgY2ZnOworCisJaWYg KGtleWxlbiAhPSBBRVNfS0VZU0laRV8xMjggJiYga2V5bGVuICE9IEFFU19LRVlTSVpFXzE5MiAm JgorCSAgICBrZXlsZW4gIT0gQUVTX0tFWVNJWkVfMjU2KQorCQlyZXR1cm4gLUVJTlZBTDsKKwor CWNyYV9uYW1lID0gY3J5cHRvX3RmbV9hbGdfbmFtZSgmdGZtLT5iYXNlKTsKKworCW1lbXplcm9f ZXhwbGljaXQoJmNmZywgc2l6ZW9mKGNmZykpOworCWNmZy5lbmMxc3QgPSAxOworCWNmZy5lbmNf ZW5nX2lkID0gYWQtPmVuY19lbmcuZW5nX2lkOworCWNmZy5pdl9zaXplID0gY3J5cHRvX2FibGtj aXBoZXJfaXZzaXplKHRmbSk7CisJY2ZnLmF1dGhfZW5nX2lkID0gU0FfRU5HX0lEX05PTkU7CisJ Y2ZnLmF1dGhfc3Via2V5X2xlbiA9IDA7CisKKwkvKiBTZXR1cCBFbmNyeXB0aW9uIFNlY3VyaXR5 IENvbnRleHQgJiBDb21tYW5kIGxhYmVsIHRlbXBsYXRlICovCisJaWYgKHNhX2luaXRfc2MoJmN0 eC0+ZW5jLCBrZXksIGtleWxlbiwKKwkJICAgICAgIE5VTEwsIDAsIGFkLCAxLCAmY3R4LT5lbmMu ZXBpYlsxXSwgZmFsc2UpKQorCQlnb3RvIGJhZGtleTsKKworCWNtZGxfbGVuID0gc2FfZm9ybWF0 X2NtZGxfZ2VuKCZjZmcsCisJCQkJICAgICAgKHU4ICopY3R4LT5lbmMuY21kbCwKKwkJCQkgICAg ICAmY3R4LT5lbmMuY21kbF91cGRfaW5mbyk7CisJaWYgKGNtZGxfbGVuIDw9IDAgfHwgKGNtZGxf bGVuID4gU0FfTUFYX0NNRExfV09SRFMgKiBzaXplb2YodTMyKSkpCisJCWdvdG8gYmFka2V5Owor CisJY3R4LT5lbmMuY21kbF9zaXplID0gY21kbF9sZW47CisKKwkvKiBTZXR1cCBEZWNyeXB0aW9u IFNlY3VyaXR5IENvbnRleHQgJiBDb21tYW5kIGxhYmVsIHRlbXBsYXRlICovCisJaWYgKHNhX2lu aXRfc2MoJmN0eC0+ZGVjLCBrZXksIGtleWxlbiwKKwkJICAgICAgIE5VTEwsIDAsIGFkLCAwLCAm Y3R4LT5kZWMuZXBpYlsxXSwgZmFsc2UpKQorCQlnb3RvIGJhZGtleTsKKworCWNmZy5lbmMxc3Qg PSAwOworCWNmZy5lbmNfZW5nX2lkID0gYWQtPmVuY19lbmcuZW5nX2lkOworCWNmZy5hdXRoX2Vu Z19pZCA9IFNBX0VOR19JRF9OT05FOworCWNmZy5hdXRoX3N1YmtleV9sZW4gPSAwOworCWNtZGxf bGVuID0gc2FfZm9ybWF0X2NtZGxfZ2VuKCZjZmcsICh1OCAqKWN0eC0+ZGVjLmNtZGwsCisJCQkJ ICAgICAgJmN0eC0+ZGVjLmNtZGxfdXBkX2luZm8pOworCisJaWYgKGNtZGxfbGVuIDw9IDAgfHwg KGNtZGxfbGVuID4gU0FfTUFYX0NNRExfV09SRFMgKiBzaXplb2YodTMyKSkpCisJCWdvdG8gYmFk a2V5OworCisJY3R4LT5kZWMuY21kbF9zaXplID0gY21kbF9sZW47CisKKwlrZnJlZShhZCk7CisK KwlyZXR1cm4gMDsKKworYmFka2V5OgorCWRldl9lcnIoc2FfazNfZGV2LCAiJXM6IGJhZGtleVxu IiwgX19mdW5jX18pOworCXJldHVybiAtRUlOVkFMOworfQorCitzdGF0aWMgaW50IHNhX2Flc19j YmNfc2V0a2V5KHN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAqdGZtLCBjb25zdCB1OCAqa2V5LAor CQkJICAgICB1bnNpZ25lZCBpbnQga2V5bGVuKQoreworCXN0cnVjdCBhbGdvX2RhdGEgKmFkID0g a3phbGxvYyhzaXplb2YoKmFkKSwgR0ZQX0tFUk5FTCk7CisJLyogQ29udmVydCB0aGUga2V5IHNp emUgKDE2LzI0LzMyKSB0byB0aGUga2V5IHNpemUgaW5kZXggKDAvMS8yKSAqLworCWludCBrZXlf aWR4ID0gKGtleWxlbiA+PiAzKSAtIDI7CisKKwlhZC0+ZW5jX2VuZy5lbmdfaWQgPSBTQV9FTkdf SURfRU0xOworCWFkLT5lbmNfZW5nLnNjX3NpemUgPSBTQV9DVFhfRU5DX1RZUEUxX1NaOworCWFk LT5hdXRoX2VuZy5lbmdfaWQgPSBTQV9FTkdfSURfTk9ORTsKKwlhZC0+YXV0aF9lbmcuc2Nfc2l6 ZSA9IDA7CisJYWQtPm1jaV9lbmMgPSBtY2lfY2JjX2VuY19hcnJheVtrZXlfaWR4XTsKKwlhZC0+ bWNpX2RlYyA9IG1jaV9jYmNfZGVjX2FycmF5W2tleV9pZHhdOworCWFkLT5pbnZfa2V5ID0gdHJ1 ZTsKKwlhZC0+ZWFsZ19pZCA9IFNBX0VBTEdfSURfQUVTX0NCQzsKKwlhZC0+YWFsZ19pZCA9IFNB X0FBTEdfSURfTk9ORTsKKworCXJldHVybiBzYV9hZXNfc2V0a2V5KHRmbSwga2V5LCBrZXlsZW4s IGFkKTsKK30KKworc3RhdGljIHZvaWQgc2FfYWVzX2RtYV9pbl9jYWxsYmFjayh2b2lkICpkYXRh KQoreworCXN0cnVjdCBzYV9yeF9kYXRhICpyeGQgPSAoc3RydWN0IHNhX3J4X2RhdGEgKilkYXRh OworCXN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSA9IChzdHJ1Y3QgYWJsa2NpcGhlcl9y ZXF1ZXN0ICopcnhkLT5yZXE7CisKKwlpbnQgc2dsZW4gPSBzZ19uZW50c19mb3JfbGVuKHJlcS0+ ZHN0LCByZXEtPm5ieXRlcyk7CisKKwlrZnJlZShyeGQpOworCisJZG1hX3VubWFwX3NnKHNhX2sz X2RldiwgcmVxLT5zcmMsIHNnbGVuLCBETUFfVE9fREVWSUNFKTsKKwlpZiAocmVxLT5zcmMgIT0g cmVxLT5kc3QpCisJCWRtYV91bm1hcF9zZyhyeGQtPmRkZXYsIHJlcS0+ZHN0LCBzZ2xlbiwgRE1B X0ZST01fREVWSUNFKTsKKworCWFibGtjaXBoZXJfcmVxdWVzdF9jb21wbGV0ZShyZXEsIDApOwor fQorCitzdGF0aWMgdm9pZAorc2FfcHJlcGFyZV90eF9kZXNjKHUzMiAqbWRwdHIsIHUzMiBwc2xl biwgdTMyICpwc2RhdGEsIHUzMiBlcGlibGVuLCB1MzIgKmVwaWIpCit7CisJdTMyICpvdXQsICpp bjsKKwlpbnQgaTsKKworCWZvciAob3V0ID0gbWRwdHIsIGluID0gZXBpYiwgaSA9IDA7IGkgPCBl cGlibGVuIC8gc2l6ZW9mKHUzMik7IGkrKykKKwkJKm91dCsrID0gKmluKys7CisKKwltZHB0cls0 XSA9ICgweEZGRkYgPDwgMTYpOworCWZvciAob3V0ID0gJm1kcHRyWzVdLCBpbiA9IHBzZGF0YSwg aSA9IDA7CisJICAgICBpIDwgcHNsZW4gLyBzaXplb2YodTMyKTsgaSsrKQorCQkqb3V0KysgPSAq aW4rKzsKK30KKworc3RhdGljIGludCBzYV9hZXNfcnVuKHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVl c3QgKnJlcSwgdTggKml2LCBpbnQgZW5jKQoreworCXN0cnVjdCBzYV90Zm1fY3R4ICpjdHggPQor CSAgICBjcnlwdG9fYWJsa2NpcGhlcl9jdHgoY3J5cHRvX2FibGtjaXBoZXJfcmVxdGZtKHJlcSkp OworCXN0cnVjdCBzYV9jdHhfaW5mbyAqc2FfY3R4ID0gZW5jID8gJmN0eC0+ZW5jIDogJmN0eC0+ ZGVjOworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqcGRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoc2Ff azNfZGV2KTsKKwlzdHJ1Y3Qgc2FfZG1hX3JlcV9jdHggcmVxX2N0eDsKKwlzdHJ1Y3QgZG1hX2Fz eW5jX3R4X2Rlc2NyaXB0b3IgKnR4X2luLCAqdHhfb3V0OworCXN0cnVjdCBzYV9yeF9kYXRhICpy eGQ7CisJdTggZW5jX29mZnNldDsKKwlpbnQgc2dfbmVudHMsIGRzdF9uZW50czsKKwlpbnQgcHNk YXRhX29mZnNldDsKKwl1OCBhdXRoX29mZnNldCA9IDA7CisJdTggKmF1dGhfaXYgPSBOVUxMOwor CXU4ICphYWQgPSBOVUxMOworCXU4IGFhZF9sZW4gPSAwOworCXUxNiBlbmNfbGVuOworCXUxNiBh dXRoX2xlbiA9IDA7CisJdTMyIHJlcV90eXBlOworCXUzMiAqbWRwdHI7CisJc2l6ZV90IHBsLCBt bDsKKworCXN0cnVjdCBkZXZpY2UgKmRkZXY7CisJc3RydWN0IGRtYV9jaGFuICpkbWFfcng7CisJ Z2ZwX3QgZmxhZ3M7CisKKwlmbGFncyA9IHJlcS0+YmFzZS5mbGFncyAmIENSWVBUT19URk1fUkVR X01BWV9TTEVFUCA/CisJCUdGUF9LRVJORUwgOiBHRlBfQVRPTUlDOworCisJZW5jX29mZnNldCA9 IDB4MDsKKwllbmNfbGVuID0gcmVxLT5uYnl0ZXM7CisKKwlpZiAoZW5jX2xlbiA+PSAyNTYpCisJ CWRtYV9yeCA9IHBkYXRhLT5kbWFfcngyOworCWVsc2UKKwkJZG1hX3J4ID0gcGRhdGEtPmRtYV9y eDE7CisKKwkvKiBBbGxvY2F0ZSBkZXNjcmlwdG9yICYgc3VibWl0IHBhY2tldCAqLworCXNnX25l bnRzID0gc2dfbmVudHNfZm9yX2xlbihyZXEtPnNyYywgZW5jX2xlbik7CisJZHN0X25lbnRzID0g c2dfbmVudHNfZm9yX2xlbihyZXEtPmRzdCwgZW5jX2xlbik7CisKKwltZW1jcHkocmVxX2N0eC5j bWRsLCBzYV9jdHgtPmNtZGwsIHNhX2N0eC0+Y21kbF9zaXplKTsKKworCS8qIFVwZGF0ZSBDb21t YW5kIExhYmVsICovCisJc2FfdXBkYXRlX2NtZGwoc2FfazNfZGV2LCBlbmNfb2Zmc2V0LCBlbmNf bGVuLAorCQkgICAgICAgaXYsIGF1dGhfb2Zmc2V0LCBhdXRoX2xlbiwKKwkJICAgICAgIGF1dGhf aXYsIGFhZF9sZW4sIGFhZCwKKwkJICAgICAgICZzYV9jdHgtPmNtZGxfdXBkX2luZm8sIHJlcV9j dHguY21kbCk7CisKKwkvKgorCSAqIExhc3QgMiB3b3JkcyBpbiBQU0RBVEEgd2lsbCBoYXZlIHRo ZSBjcnlwdG8gYWxnIHR5cGUgJgorCSAqIGNyeXB0byByZXF1ZXN0IHBvaW50ZXIKKwkgKi8KKwly ZXFfdHlwZSA9IENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSOworCWlmIChlbmMpCisJCXJlcV90 eXBlIHw9IChTQV9SRVFfU1VCVFlQRV9FTkMgPDwgU0FfUkVRX1NVQlRZUEVfU0hJRlQpOworCWVs c2UKKwkJcmVxX3R5cGUgfD0gKFNBX1JFUV9TVUJUWVBFX0RFQyA8PCBTQV9SRVFfU1VCVFlQRV9T SElGVCk7CisKKwlwc2RhdGFfb2Zmc2V0ID0gc2FfY3R4LT5jbWRsX3NpemUgLyBzaXplb2YodTMy KTsKKwlyZXFfY3R4LmNtZGxbcHNkYXRhX29mZnNldCsrXSA9IHJlcV90eXBlOworCisJZGRldiA9 IGRtYV9yeC0+ZGV2aWNlLT5kZXY7CisJLyogbWFwIHRoZSBwYWNrZXQgKi8KKwlyZXFfY3R4LnNy YyA9IHJlcS0+c3JjOworCXJlcV9jdHguc3JjX25lbnRzID0gZG1hX21hcF9zZyhzYV9rM19kZXYs IHJlcS0+c3JjLCBzZ19uZW50cywKKwkJCQkgICAgICAgRE1BX1RPX0RFVklDRSk7CisJaWYgKHJl cS0+c3JjICE9IHJlcS0+ZHN0KQorCQlkc3RfbmVudHMgPSBkbWFfbWFwX3NnKGRkZXYsIHJlcS0+ ZHN0LCBzZ19uZW50cywKKwkJCQkgICAgICAgRE1BX0ZST01fREVWSUNFKTsKKwllbHNlCisJCWRz dF9uZW50cyA9IHJlcV9jdHguc3JjX25lbnRzOworCisJaWYgKHVubGlrZWx5KHJlcV9jdHguc3Jj X25lbnRzICE9IHNnX25lbnRzKSkgeworCQlkZXZfd2Fybl9yYXRlbGltaXRlZChzYV9rM19kZXYs ICJmYWlsZWQgdG8gbWFwIHR4IHBrdFxuIik7CisJCXJldHVybiAtRUlPOworCX0KKworCXJlcV9j dHguZGV2X2RhdGEgPSBwZGF0YTsKKwlyZXFfY3R4LnBrdCA9IHRydWU7CisKKwlkbWFfc3luY19z Z19mb3JfZGV2aWNlKHBkYXRhLT5kZXYsIHJlcS0+c3JjLCByZXFfY3R4LnNyY19uZW50cywKKwkJ CSAgICAgICBETUFfVE9fREVWSUNFKTsKKworCXR4X2luID0gZG1hZW5naW5lX3ByZXBfc2xhdmVf c2coZG1hX3J4LCByZXEtPmRzdCwgZHN0X25lbnRzLAorCQkJCQlETUFfREVWX1RPX01FTSwKKwkJ CQkJRE1BX1BSRVBfSU5URVJSVVBUIHwgRE1BX0NUUkxfQUNLKTsKKwlpZiAoIXR4X2luKSB7CisJ CWRldl9lcnIocGRhdGEtPmRldiwgIklOIHByZXBfc2xhdmVfc2coKSBmYWlsZWRcbiIpOworCQly ZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyeGQgPSBremFsbG9jKHNpemVvZigqcnhkKSwgR0ZQX0tF Uk5FTCk7CisJcnhkLT5yZXEgPSAodm9pZCAqKXJlcTsKKwlyeGQtPmRkZXYgPSBkZGV2OworCisJ LyogSU4gKi8KKwl0eF9pbi0+Y2FsbGJhY2sgPSBzYV9hZXNfZG1hX2luX2NhbGxiYWNrOworCXR4 X2luLT5jYWxsYmFja19wYXJhbSA9IHJ4ZDsKKworCXR4X291dCA9IGRtYWVuZ2luZV9wcmVwX3Ns YXZlX3NnKHBkYXRhLT5kbWFfdHgsIHJlcS0+c3JjLAorCQkJCQkgcmVxX2N0eC5zcmNfbmVudHMs IERNQV9NRU1fVE9fREVWLAorCQkJCQlETUFfUFJFUF9JTlRFUlJVUFQgfCBETUFfQ1RSTF9BQ0sp OworCWlmICghdHhfb3V0KSB7CisJCWRldl9lcnIocGRhdGEtPmRldiwgIk9VVCBwcmVwX3NsYXZl X3NnKCkgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJbWRwdHIgPSAodTMy ICopZG1hZW5naW5lX2Rlc2NfZ2V0X21ldGFkYXRhX3B0cih0eF9vdXQsICZwbCwgJm1sKTsKKwor CXNhX3ByZXBhcmVfdHhfZGVzYyhtZHB0ciwgKHNhX2N0eC0+Y21kbF9zaXplICsgKFNBX1BTREFU QV9DVFhfV09SRFMgKgorCQkJICAgc2l6ZW9mKHUzMikpKSwgcmVxX2N0eC5jbWRsLAorCQkJICAg c2l6ZW9mKHNhX2N0eC0+ZXBpYiksIHNhX2N0eC0+ZXBpYik7CisKKwltbCA9IHNhX2N0eC0+Y21k bF9zaXplICsgKFNBX1BTREFUQV9DVFhfV09SRFMgKiBzaXplb2YodTMyKSk7CisJZG1hZW5naW5l X2Rlc2Nfc2V0X21ldGFkYXRhX2xlbih0eF9vdXQsIDQ0KTsKKworCWRtYWVuZ2luZV9zdWJtaXQo dHhfb3V0KTsKKwlkbWFlbmdpbmVfc3VibWl0KHR4X2luKTsKKworCWRtYV9hc3luY19pc3N1ZV9w ZW5kaW5nKGRtYV9yeCk7CisJZG1hX2FzeW5jX2lzc3VlX3BlbmRpbmcocGRhdGEtPmRtYV90eCk7 CisKKwlyZXR1cm4gLUVJTlBST0dSRVNTOworfQorCitzdGF0aWMgaW50IHNhX2Flc19jYmNfZW5j cnlwdChzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEpCit7CisJcmV0dXJuIHNhX2Flc19y dW4ocmVxLCByZXEtPmluZm8sIDEpOworfQorCitzdGF0aWMgaW50IHNhX2Flc19jYmNfZGVjcnlw dChzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEpCit7CisJcmV0dXJuIHNhX2Flc19ydW4o cmVxLCByZXEtPmluZm8sIDApOworfQorCitzdGF0aWMgc3RydWN0IHNhX2FsZ190bXBsIHNhX2Fs Z3NbXSA9IHsKKwl7LnR5cGUgPSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUiwKKwkgLmFsZy5j cnlwdG8gPSB7CisJCQkuY3JhX25hbWUgPSAiY2JjKGFlcykiLAorCQkJLmNyYV9kcml2ZXJfbmFt ZSA9ICJjYmMtYWVzLXNhMnVsIiwKKwkJCS5jcmFfcHJpb3JpdHkgPSAzMDAwMCwKKwkJCS5jcmFf ZmxhZ3MgPSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUiB8CisJCQkJICAgICBDUllQVE9fQUxH X0tFUk5fRFJJVkVSX09OTFkgfAorCQkJCSAgICAgQ1JZUFRPX0FMR19BU1lOQyB8CisJCQkJICAg ICBDUllQVE9fQUxHX05FRURfRkFMTEJBQ0ssCisJCQkuY3JhX2Jsb2Nrc2l6ZSA9IEFFU19CTE9D S19TSVpFLAorCQkJLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBzYV90Zm1fY3R4KSwKKwkJ CS5jcmFfYWxpZ25tYXNrID0gMCwKKwkJCS5jcmFfdHlwZSA9ICZjcnlwdG9fYWJsa2NpcGhlcl90 eXBlLAorCQkJLmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwKKwkJCS5jcmFfaW5pdCA9IHNhX2Fl c19jcmFfaW5pdCwKKwkJCS5jcmFfZXhpdCA9IHNhX2Flc19jcmFfZXhpdCwKKwkJCS5jcmFfdS5h YmxrY2lwaGVyID0geworCQkJCQkgICAgIC5taW5fa2V5c2l6ZSA9IEFFU19NSU5fS0VZX1NJWkUs CisJCQkJCSAgICAgLm1heF9rZXlzaXplID0gQUVTX01BWF9LRVlfU0laRSwKKwkJCQkJICAgICAu aXZzaXplID0gQUVTX0JMT0NLX1NJWkUsCisJCQkJCSAgICAgLnNldGtleSA9IHNhX2Flc19jYmNf c2V0a2V5LAorCQkJCQkgICAgIC5lbmNyeXB0ID0gc2FfYWVzX2NiY19lbmNyeXB0LAorCQkJCQkg ICAgIC5kZWNyeXB0ID0gc2FfYWVzX2NiY19kZWNyeXB0LAorCQkJCQl9CisJCQl9CisJfSwKK307 CisKKy8qIFJlZ2lzdGVyIHRoZSBhbGdvcml0aG1zIGluIGNyeXB0byBmcmFtZXdvcmsgKi8KK3Zv aWQgc2FfcmVnaXN0ZXJfYWxnb3MoY29uc3Qgc3RydWN0IGRldmljZSAqZGV2KQoreworCWNoYXIg KmFsZ19uYW1lOworCXUzMiB0eXBlOworCWludCBpLCBlcnIsIG51bV9hbGdzID0gQVJSQVlfU0la RShzYV9hbGdzKTsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fYWxnczsgaSsrKSB7CisJCXR5cGUg PSBzYV9hbGdzW2ldLnR5cGU7CisJCWlmICh0eXBlID09IENSWVBUT19BTEdfVFlQRV9BRUFEKSB7 CisJCQlhbGdfbmFtZSA9IHNhX2FsZ3NbaV0uYWxnLmFlYWQuYmFzZS5jcmFfbmFtZTsKKwkJCWVy ciA9IGNyeXB0b19yZWdpc3Rlcl9hZWFkKCZzYV9hbGdzW2ldLmFsZy5hZWFkKTsKKwkJfSBlbHNl IGlmICh0eXBlID09IENSWVBUT19BTEdfVFlQRV9BQkxLQ0lQSEVSKSB7CisJCQlhbGdfbmFtZSA9 IHNhX2FsZ3NbaV0uYWxnLmNyeXB0by5jcmFfbmFtZTsKKwkJCWVyciA9IGNyeXB0b19yZWdpc3Rl cl9hbGcoJnNhX2FsZ3NbaV0uYWxnLmNyeXB0byk7CisJCX0gZWxzZSB7CisJCQlkZXZfZXJyKGRl diwKKwkJCQkidW4tc3VwcG9ydGVkIGNyeXB0byBhbGdvcml0aG0gKCVkKSIsCisJCQkJc2FfYWxn c1tpXS50eXBlKTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKGVycikKKwkJCWRldl9lcnIo ZGV2LCAiRmFpbGVkIHRvIHJlZ2lzdGVyICclcydcbiIsIGFsZ19uYW1lKTsKKwkJZWxzZQorCQkJ c2FfYWxnc1tpXS5yZWdpc3RlcmVkID0gMTsKKwl9Cit9CisKKy8qIFVucmVnaXN0ZXIgdGhlIGFs Z29yaXRobXMgaW4gY3J5cHRvIGZyYW1ld29yayAqLwordm9pZCBzYV91bnJlZ2lzdGVyX2FsZ29z KGNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwljaGFyICphbGdfbmFtZTsKKwl1MzIgdHlw ZTsKKwlpbnQgaSwgZXJyID0gMCwgbnVtX2FsZ3MgPSBBUlJBWV9TSVpFKHNhX2FsZ3MpOworCisJ Zm9yIChpID0gMDsgaSA8IG51bV9hbGdzOyBpKyspIHsKKwkJdHlwZSA9IHNhX2FsZ3NbaV0udHlw ZTsKKwkJaWYgKHR5cGUgPT0gQ1JZUFRPX0FMR19UWVBFX0FFQUQpIHsKKwkJCWFsZ19uYW1lID0g c2FfYWxnc1tpXS5hbGcuYWVhZC5iYXNlLmNyYV9uYW1lOworCQkJY3J5cHRvX3VucmVnaXN0ZXJf YWVhZCgmc2FfYWxnc1tpXS5hbGcuYWVhZCk7CisJCX0gZWxzZSB7CisJCQlhbGdfbmFtZSA9IHNh X2FsZ3NbaV0uYWxnLmNyeXB0by5jcmFfbmFtZTsKKwkJCWVyciA9IGNyeXB0b191bnJlZ2lzdGVy X2FsZygmc2FfYWxnc1tpXS5hbGcuY3J5cHRvKTsKKwkJfQorCisJCXNhX2FsZ3NbaV0ucmVnaXN0 ZXJlZCA9IDA7CisJfQorfQorCitzdGF0aWMgaW50IHNhX2luaXRfbWVtKHN0cnVjdCBzYV9jcnlw dG9fZGF0YSAqZGV2X2RhdGEpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmRldl9kYXRhLT5w ZGV2LT5kZXY7CisJLyogU2V0dXAgZG1hIHBvb2wgZm9yIHNlY3VyaXR5IGNvbnRleHQgYnVmZmVy cyAqLworCWRldl9kYXRhLT5zY19wb29sID0gZG1hX3Bvb2xfY3JlYXRlKCJrZXlzdG9uZS1zYyIs IGRldiwKKwkJCQkJICAgIFNBX0NUWF9NQVhfU1osIDY0LCAwKTsKKwlpZiAoIWRldl9kYXRhLT5z Y19wb29sKSB7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGNyZWF0ZSBkbWEgcG9vbCIpOwor CQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV9k bWFfaW5pdChzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRkKQoreworCWludCByZXQ7CisJc3RydWN0 IGRtYV9zbGF2ZV9jb25maWcgY2ZnOworCisJZGQtPmRtYV9yeDEgPSBOVUxMOworCWRkLT5kbWFf dHggPSBOVUxMOworCWRkLT5kbWFfcngyID0gTlVMTDsKKworCXJldCA9IGRtYV9jb2VyY2VfbWFz a19hbmRfY29oZXJlbnQoZGQtPmRldiwgRE1BX0JJVF9NQVNLKDQ4KSk7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCWRkLT5kbWFfcngxID0gZG1hX3JlcXVlc3RfY2hhbihkZC0+ZGV2LCAi cngxIik7CisJaWYgKElTX0VSUihkZC0+ZG1hX3J4MSkpIHsKKwkJaWYgKFBUUl9FUlIoZGQtPmRt YV9yeDEpICE9IC1FUFJPQkVfREVGRVIpCisJCQlkZXZfZXJyKGRkLT5kZXYsICJVbmFibGUgdG8g cmVxdWVzdCByeDEgRE1BIGNoYW5uZWxcbiIpOworCQlyZXR1cm4gUFRSX0VSUihkZC0+ZG1hX3J4 MSk7CisJfQorCisJZGQtPmRtYV9yeDIgPSBkbWFfcmVxdWVzdF9jaGFuKGRkLT5kZXYsICJyeDIi KTsKKwlpZiAoSVNfRVJSKGRkLT5kbWFfcngyKSkgeworCQlkbWFfcmVsZWFzZV9jaGFubmVsKGRk LT5kbWFfcngxKTsKKwkJaWYgKFBUUl9FUlIoZGQtPmRtYV9yeDEpICE9IC1FUFJPQkVfREVGRVIp CisJCQlkZXZfZXJyKGRkLT5kZXYsICJVbmFibGUgdG8gcmVxdWVzdCByeDIgRE1BIGNoYW5uZWxc biIpOworCQlyZXR1cm4gUFRSX0VSUihkZC0+ZG1hX3J4Mik7CisJfQorCisJZGQtPmRtYV90eCA9 IGRtYV9yZXF1ZXN0X2NoYW4oZGQtPmRldiwgInR4Iik7CisJaWYgKElTX0VSUihkZC0+ZG1hX3R4 KSkgeworCQlpZiAoUFRSX0VSUihkZC0+ZG1hX3J4MSkgIT0gLUVQUk9CRV9ERUZFUikKKwkJCWRl dl9lcnIoZGQtPmRldiwgIlVuYWJsZSB0byByZXF1ZXN0IHR4IERNQSBjaGFubmVsXG4iKTsKKwkJ cmV0ID0gUFRSX0VSUihkZC0+ZG1hX3R4KTsKKwkJZ290byBlcnJfZG1hX3R4OworCX0KKworCW1l bXplcm9fZXhwbGljaXQoJmNmZywgc2l6ZW9mKGNmZykpOworCisJY2ZnLnNyY19hZGRyX3dpZHRo ID0gRE1BX1NMQVZFX0JVU1dJRFRIXzRfQllURVM7CisJY2ZnLmRzdF9hZGRyX3dpZHRoID0gRE1B X1NMQVZFX0JVU1dJRFRIXzRfQllURVM7CisJY2ZnLnNyY19tYXhidXJzdCA9IDQ7CisJY2ZnLmRz dF9tYXhidXJzdCA9IDQ7CisKKwlyZXQgPSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFf cngxLCAmY2ZnKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGQtPmRldiwgImNhbid0IGNvbmZp Z3VyZSBJTiBkbWFlbmdpbmUgc2xhdmU6ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwlyZXQgPSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFfcngyLCAmY2ZnKTsK KwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGQtPmRldiwgImNhbid0IGNvbmZpZ3VyZSBJTiBkbWFl bmdpbmUgc2xhdmU6ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQg PSBkbWFlbmdpbmVfc2xhdmVfY29uZmlnKGRkLT5kbWFfdHgsICZjZmcpOworCWlmIChyZXQpIHsK KwkJZGV2X2VycihkZC0+ZGV2LCAiY2FuJ3QgY29uZmlndXJlIE9VVCBkbWFlbmdpbmUgc2xhdmU6 ICVkXG4iLAorCQkJcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKKworZXJy X2RtYV90eDoKKwlkbWFfcmVsZWFzZV9jaGFubmVsKGRkLT5kbWFfcngxKTsKKwlkbWFfcmVsZWFz ZV9jaGFubmVsKGRkLT5kbWFfcngyKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQg c2FfdWxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgZGV2 aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCXN0YXRpYyB2 b2lkIF9faW9tZW0gKnNhdWxfYmFzZTsKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRldl9kYXRh OworCXUzMiB2YWw7CisJaW50IHJldDsKKworCWRldl9kYXRhID0gZGV2bV9remFsbG9jKGRldiwg c2l6ZW9mKCpkZXZfZGF0YSksIEdGUF9LRVJORUwpOworCWlmICghZGV2X2RhdGEpCisJCXJldHVy biAtRU5PTUVNOworCisJc2FfazNfZGV2ID0gZGV2OworCWRldl9kYXRhLT5kZXYgPSBkZXY7CisJ ZGV2X2RhdGEtPnBkZXYgPSBwZGV2OworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGRldl9k YXRhKTsKKwlkZXZfc2V0X2RydmRhdGEoc2FfazNfZGV2LCBkZXZfZGF0YSk7CisKKwlzYV9pbml0 X21lbShkZXZfZGF0YSk7CisJcmV0ID0gc2FfZG1hX2luaXQoZGV2X2RhdGEpOworCWlmIChyZXQp CisJCXJldHVybiByZXQ7CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9S RVNPVVJDRV9NRU0sIDApOworCXNhdWxfYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYs IHJlcyk7CisKKwl2YWwgPSBTQV9FRUNfRU5DU1NfRU4gfCBTQV9FRUNfQVVUSFNTX0VOIHwgU0Ff RUVDX0NUWENBQ0hfRU4gfAorCSAgICBTQV9FRUNfQ1BQSV9QT1JUX0lOX0VOIHwgU0FfRUVDX0NQ UElfUE9SVF9PVVRfRU4gfCBTQV9FRUNfVFJOR19FTjsKKworCXdyaXRlbF9yZWxheGVkKHZhbCwg c2F1bF9iYXNlICsgU0FfRU5HSU5FX0VOQUJMRV9DT05UUk9MKTsKKworCXNhX3JlZ2lzdGVyX2Fs Z29zKGRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYV91bF9yZW1vdmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgKmRl dl9kYXRhID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisKKwlzYV91bnJlZ2lzdGVyX2Fs Z29zKCZwZGV2LT5kZXYpOworCisJZG1hX3JlbGVhc2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3J4 Mik7CisJZG1hX3JlbGVhc2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3J4MSk7CisJZG1hX3JlbGVh c2VfY2hhbm5lbChkZXZfZGF0YS0+ZG1hX3R4KTsKKworCWRtYV9wb29sX2Rlc3Ryb3koZGV2X2Rh dGEtPnNjX3Bvb2wpOworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgb2ZfbWF0Y2hb XSA9IHsKKwl7LmNvbXBhdGlibGUgPSAidGksc2EydWwtY3J5cHRvIix9LAorCXt9LAorfTsKK01P RFVMRV9ERVZJQ0VfVEFCTEUob2YsIG9mX21hdGNoKTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9y bV9kcml2ZXIgc2FfdWxfZHJpdmVyID0geworCS5wcm9iZSA9IHNhX3VsX3Byb2JlLAorCS5yZW1v dmUgPSBzYV91bF9yZW1vdmUsCisJLmRyaXZlciA9IHsKKwkJICAgLm5hbWUgPSAic2F1bC1jcnlw dG8iLAorCQkgICAub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaCwKKwkJICAgfSwKK307Cittb2R1 bGVfcGxhdGZvcm1fZHJpdmVyKHNhX3VsX2RyaXZlcik7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYy Iik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by9zYTJ1bC5oIGIvZHJpdmVycy9jcnlwdG8v c2EydWwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmNhZjNjODhk Y2YyYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvY3J5cHRvL3NhMnVsLmgKQEAgLTAsMCAr MSwzODQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQU02 IFNBMlVMIGNyeXB0byBhY2NlbGVyYXRvciBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTggVGV4YXMgSW5zdHJ1bWVudHMgSW5jb3Jwb3JhdGVkIC0gaHR0cDovL3d3dy50aS5jb20KKyAq CisgKiBBdXRob3JzOglLZWVydGh5CisgKiAgICAgICAgICAgICAgVml0YWx5IEFuZHJpYW5vdgor ICovCisKKyNpZm5kZWYgX0szX1NBMlVMXworI2RlZmluZSBfSzNfU0EyVUxfCisKKyNpbmNsdWRl IDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KKyNpbmNsdWRl IDxsaW51eC9od19yYW5kb20uaD4KKyNpbmNsdWRlIDxjcnlwdG8vYWVzLmg+CisKKyNkZWZpbmUg U0FfRU5HSU5FX0VOQUJMRV9DT05UUk9MCTB4MTAwMAorCitzdHJ1Y3Qgc2FfdGZtX2N0eDsKKy8q CisgKiBTQV9FTkdJTkVfRU5BQkxFX0NPTlRST0wgcmVnaXN0ZXIgYml0cworICovCisjZGVmaW5l IFNBX0VFQ19FTkNTU19FTgkJCTB4MDAwMDAwMDEKKyNkZWZpbmUgU0FfRUVDX0FVVEhTU19FTgkJ MHgwMDAwMDAwMgorI2RlZmluZSBTQV9FRUNfVFJOR19FTgkJCTB4MDAwMDAwMDgKKyNkZWZpbmUg U0FfRUVDX1BLQV9FTgkJCTB4MDAwMDAwMTAKKyNkZWZpbmUgU0FfRUVDX0NUWENBQ0hfRU4JCTB4 MDAwMDAwODAKKyNkZWZpbmUgU0FfRUVDX0NQUElfUE9SVF9JTl9FTgkJMHgwMDAwMDIwMAorI2Rl ZmluZSBTQV9FRUNfQ1BQSV9QT1JUX09VVF9FTgkJMHgwMDAwMDgwMAorCisvKgorICogRW5jb2Rp bmcgdXNlZCB0byBpZGVudGlmeSB0aGUgdHlwbyBvZiBjcnlwdG8gb3BlcmF0aW9uCisgKiBwZXJm b3JtZWQgb24gdGhlIHBhY2tldCB3aGVuIHRoZSBwYWNrZXQgaXMgcmV0dXJuZWQKKyAqIGJ5IFNB CisgKi8KKyNkZWZpbmUgU0FfUkVRX1NVQlRZUEVfRU5DCTB4MDAwMQorI2RlZmluZSBTQV9SRVFf U1VCVFlQRV9ERUMJMHgwMDAyCisjZGVmaW5lIFNBX1JFUV9TVUJUWVBFX1NISUZUCTE2CisjZGVm aW5lIFNBX1JFUV9TVUJUWVBFX01BU0sJMHhmZmZmCisKKy8qIE51bWJlciBvZiAzMiBiaXQgd29y ZHMgaW4gRVBJQiAgKi8KKyNkZWZpbmUgU0FfRE1BX05VTV9FUElCX1dPUkRTICAgNAorCisvKiBO dW1iZXIgb2YgMzIgYml0IHdvcmRzIGluIFBTIGRhdGEgICovCisjZGVmaW5lIFNBX0RNQV9OVU1f UFNfV09SRFMgICAgIDE2CisjZGVmaW5lIE5LRVlfU1oJCQkzCisjZGVmaW5lIE1DSV9TWgkJCTI3 CisKKy8qCisgKiBNYXhpbXVtIG51bWJlciBvZiBzaW11bHRhZW5lb3VzIHNlY3VyaXR5IGNvbnRl eHRzCisgKiBzdXBwb3J0ZWQgYnkgdGhlIGRyaXZlcgorICovCisjZGVmaW5lIFNBX01BWF9OVU1f Q1RYCTUxMgorCisvKgorICogQXNzdW1wdGlvbjogQ1RYIHNpemUgaXMgbXVsdGlwbGUgb2YgMzIK KyAqLworI2RlZmluZSBTQV9DVFhfU0laRV9UT19ETUFfU0laRShjdHhfc3opIFwKKwkJKChjdHhf c3opID8gKChjdHhfc3opIC8gMzIgLSAxKSA6IDApCisKKyNkZWZpbmUgU0FfQ1RYX0VOQ19LRVlf T0ZGU0VUICAgMzIKKyNkZWZpbmUgU0FfQ1RYX0VOQ19BVVgxX09GRlNFVCAgNjQKKyNkZWZpbmUg U0FfQ1RYX0VOQ19BVVgyX09GRlNFVCAgOTYKKyNkZWZpbmUgU0FfQ1RYX0VOQ19BVVgzX09GRlNF VCAgMTEyCisjZGVmaW5lIFNBX0NUWF9FTkNfQVVYNF9PRkZTRVQgIDEyOAorCisvKiBOZXh0IEVu Z2luZSBTZWxlY3QgY29kZSBpbiBDUF9BQ0UgKi8KKyNkZWZpbmUgU0FfRU5HX0lEX0VNMSAgIDIg ICAgICAgLyogRW5jL0RlYyBlbmdpbmUgd2l0aCBBRVMvREVDIGNvcmUgKi8KKyNkZWZpbmUgU0Ff RU5HX0lEX0VNMiAgIDMgICAgICAgLyogRW5jcnlwdGlvbi9EZWNyeXB0aW9uIGVuZ2luZWZvciBw YXNzIDIgKi8KKyNkZWZpbmUgU0FfRU5HX0lEX0FNMSAgIDQgICAgICAgLyogQXV0aC4gZW5naW5l IHdpdGggU0hBMS9NRDUvU0hBMiBjb3JlICovCisjZGVmaW5lIFNBX0VOR19JRF9BTTIgICA1ICAg ICAgIC8qICBBdXRoZW50aWNhdGlvbiBlbmdpbmUgZm9yIHBhc3MgMiAqLworI2RlZmluZSBTQV9F TkdfSURfT1VUUE9SVDIgMjAgICAvKiAgRWdyZXNzIG1vZHVsZSAyICAqLworI2RlZmluZSBTQV9F TkdfSURfTk9ORSAgMHhmZgorCisvKgorICogQ29tbWFuZCBMYWJlbCBEZWZpbml0aW9ucworICov CisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX05FU0MgICAgICAgICAgIDAgICAgICAvKiBOZXh0IEVu Z2luZSBTZWxlY3QgQ29kZSAqLworI2RlZmluZSBTQV9DTURMX09GRlNFVF9MQUJFTF9MRU4gICAg ICAxICAgICAgLyogRW5naW5lIENvbW1hbmQgTGFiZWwgTGVuZ3RoICovCisvKiAxNi1iaXQgTGVu Z3RoIG9mIERhdGEgdG8gYmUgcHJvY2Vzc2VkICovCisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX0RB VEFfTEVOICAgICAgIDIKKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfREFUQV9PRkZTRVQgICAgNCAg ICAgIC8qIFN0YXQgRGF0YSBPZmZzZXQgKi8KKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfT1BUSU9O X0NUUkwxICAgNSAgICAgIC8qIE9wdGlvbiBDb250cm9sIEJ5dGUgMSAqLworI2RlZmluZSBTQV9D TURMX09GRlNFVF9PUFRJT05fQ1RSTDIgICA2ICAgICAgLyogT3B0aW9uIENvbnRyb2wgQnl0ZSAy ICovCisjZGVmaW5lIFNBX0NNRExfT0ZGU0VUX09QVElPTl9DVFJMMyAgIDcgICAgICAvKiBPcHRp b24gQ29udHJvbCBCeXRlIDMgKi8KKyNkZWZpbmUgU0FfQ01ETF9PRkZTRVRfT1BUSU9OX0JZVEUg ICAgOAorCisjZGVmaW5lIFNBX0NNRExfSEVBREVSX1NJWkVfQllURVMJOAorCisjZGVmaW5lIFNB X0NNRExfT1BUSU9OX0JZVEVTX01BWF9TSVpFICAgICA3MgorI2RlZmluZSBTQV9DTURMX01BWF9T SVpFX0JZVEVTIChTQV9DTURMX0hFQURFUl9TSVpFX0JZVEVTICsgXAorCQkJCVNBX0NNRExfT1BU SU9OX0JZVEVTX01BWF9TSVpFKQorCisvKiBTV0lORk8gd29yZC0wIGZsYWdzICovCisjZGVmaW5l IFNBX1NXX0lORk9fRkxBR19FVklDVCAgIDB4MDAwMQorI2RlZmluZSBTQV9TV19JTkZPX0ZMQUdf VEVBUiAgICAweDAwMDIKKyNkZWZpbmUgU0FfU1dfSU5GT19GTEFHX05PUEQgICAgMHgwMDA0CisK Ky8qCisgKiBUaGlzIHR5cGUgcmVwcmVzZW50cyB0aGUgdmFyaW91cyBwYWNrZXQgdHlwZXMgdG8g YmUgcHJvY2Vzc2VkCisgKiBieSB0aGUgUEhQIGVuZ2luZSBpbiBTQS4KKyAqIEl0IGlzIHVzZWQg dG8gaWRlbnRpZnkgdGhlIGNvcnJlc3BvbmRpbmcgUEhQIHByb2Nlc3NpbmcgZnVuY3Rpb24uCisg Ki8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFXzNHUFBfQUlSICAgIDAgICAgLyogM0dQUCBB aXIgQ2lwaGVyICovCisjZGVmaW5lIFNBX0NUWF9QRV9QS1RfVFlQRV9TUlRQICAgICAgICAxICAg IC8qIFNSVFAgKi8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFX0lQU0VDX0FIICAgIDIgICAg LyogSVBTZWMgQXV0aGVudGljYXRpb24gSGVhZGVyICovCisvKiBJUFNlYyBFbmNhcHN1bGF0aW5n IFNlY3VyaXR5IFBheWxvYWQgKi8KKyNkZWZpbmUgU0FfQ1RYX1BFX1BLVF9UWVBFX0lQU0VDX0VT UCAgIDMKKy8qIEluZGljYXRlcyB0aGF0IGl0IGlzIGluIGRhdGEgbW9kZSwgSXQgbWF5IG5vdCBi ZSB1c2VkIGJ5IFBIUCAqLworI2RlZmluZSBTQV9DVFhfUEVfUEtUX1RZUEVfTk9ORSAgICAgICAg NAorI2RlZmluZSBTQV9DVFhfRU5DX1RZUEUxX1NaICAgICA2NCAgICAgIC8qIEVuY3J5cHRpb24g U0Mgd2l0aCBLZXkgb25seSAqLworI2RlZmluZSBTQV9DVFhfRU5DX1RZUEUyX1NaICAgICA5NiAg ICAgIC8qIEVuY3J5cHRpb24gU0Mgd2l0aCBLZXkgYW5kIEF1eDEgKi8KKworI2RlZmluZSBTQV9D VFhfQVVUSF9UWVBFMV9TWiAgICA2NCAgICAgIC8qIEF1dGggU0Mgd2l0aCBLZXkgb25seSAqLwor I2RlZmluZSBTQV9DVFhfQVVUSF9UWVBFMl9TWiAgICA5NiAgICAgIC8qIEF1dGggU0Mgd2l0aCBL ZXkgYW5kIEF1eDEgKi8KKy8qIFNpemUgb2Ygc2VjdXJpdHkgY29udGV4dCBmb3IgUEhQIGVuZ2lu ZSAqLworI2RlZmluZSBTQV9DVFhfUEhQX1BFX0NUWF9TWiAgICA2NAorCisjZGVmaW5lIFNBX0NU WF9NQVhfU1ogKDY0ICsgU0FfQ1RYX0VOQ19UWVBFMl9TWiArIFNBX0NUWF9BVVRIX1RZUEUyX1Na KQorCisvKgorICogRW5jb2Rpbmcgb2YgRi9FIGNvbnRyb2wgaW4gU0NDVEwKKyAqICBCaXQgMC0x OiBGZXRjaCBQSFAgQnl0ZXMKKyAqICBCaXQgMi0zOiBGZXRjaCBFbmNyeXB0aW9uL0FpciBDaXBo ZXJpbmcgQnl0ZXMKKyAqICBCaXQgNC01OiBGZXRjaCBBdXRoZW50aWNhdGlvbiBCeXRlcyBvciBF bmNyIHBhc3MgMgorICogIEJpdCA2LTc6IEV2aWN0IFBIUCBCeXRlcworICoKKyAqICB3aGVyZSAg IDAwID0gMCBieXRlcworICogICAgICAgICAgMDEgPSA2NCBieXRlcworICogICAgICAgICAgMTAg PSA5NiBieXRlcworICogICAgICAgICAgMTEgPSAxMjggYnl0ZXMKKyAqLworI2RlZmluZSBTQV9D VFhfRE1BX1NJWkVfMCAgICAgICAwCisjZGVmaW5lIFNBX0NUWF9ETUFfU0laRV82NCAgICAgIDEK KyNkZWZpbmUgU0FfQ1RYX0RNQV9TSVpFXzk2ICAgICAgMgorI2RlZmluZSBTQV9DVFhfRE1BX1NJ WkVfMTI4ICAgICAzCisKKy8qCisgKiBCeXRlIG9mZnNldCBvZiB0aGUgb3duZXIgd29yZCBpbiBT Q0NUTAorICogaW4gdGhlIHNlY3VyaXR5IGNvbnRleHQKKyAqLworI2RlZmluZSBTQV9DVFhfU0ND VExfT1dORVJfT0ZGU0VUIDAKKworI2RlZmluZSBTQV9DVFhfRU5DX0tFWV9PRkZTRVQgICAzMgor I2RlZmluZSBTQV9DVFhfRU5DX0FVWDFfT0ZGU0VUICA2NAorI2RlZmluZSBTQV9DVFhfRU5DX0FV WDJfT0ZGU0VUICA5NgorI2RlZmluZSBTQV9DVFhfRU5DX0FVWDNfT0ZGU0VUICAxMTIKKyNkZWZp bmUgU0FfQ1RYX0VOQ19BVVg0X09GRlNFVCAgMTI4CisKKyNkZWZpbmUgU0FfU0NDVExfRkVfQVVU SF9FTkMJMHg2NQorI2RlZmluZSBTQV9TQ0NUTF9GRV9FTkMJCTB4OEQKKworI2RlZmluZSBTQV9B TElHTl9NQVNLCQkoc2l6ZW9mKHUzMikgLSAxKQorI2RlZmluZSBTQV9BTElHTkVECQlfX2FsaWdu ZWQoMzIpCisKKy8qKgorICogc3RydWN0IHNhX2NyeXB0b19kYXRhIC0gQ3J5cHRvIGRyaXZlciBp bnN0YW5jZSBkYXRhCisgKiBAcGRldjogUGxhdGZvcm0gZGV2aWNlIHBvaW50ZXIKKyAqIEBzY19w b29sOiBzZWN1cml0eSBjb250ZXh0IHBvb2wKKyAqIEBkZXY6IERldmljZSBwb2ludGVyCisgKiBA c2NpZF9sb2NrOiBzZWN1cmUgY29udGV4dCBJRCBsb2NrCisgKiBAc2NfaWRfc3RhcnQ6IHN0YXJ0 aW5nIGluZGV4IGZvciBTQyBJRAorICogQHNjX2lkX2VuZDogRW5kaW5nIGluZGV4IGZvciBTQyBJ RAorICogQHNjX2lkOiBTZWN1cml0eSBDb250ZXh0IElECisgKiBAY3R4X2JtOiBCaXRtYXAgdG8g a2VlcCB0cmFjayBvZiBTZWN1cml0eSBjb250ZXh0IElEJ3MKKyAqIEBjdHg6IFNBIHRmbSBjb250 ZXh0IHBvaW50ZXIKKyAqIEBkbWFfcngxOiBQb2ludGVyIHRvIERNQSByeCBjaGFubmVsIGZvciBz aXplcyA8IDI1NiBCeXRlcworICogQGRtYV9yeDI6IFBvaW50ZXIgdG8gRE1BIHJ4IGNoYW5uZWwg Zm9yIHNpemVzID4gMjU2IEJ5dGVzCisgKiBAZG1hX3R4OiBQb2ludGVyIHRvIERNQSBUWCBjaGFu bmVsCisgKi8KK3N0cnVjdCBzYV9jcnlwdG9fZGF0YSB7CisJc3RydWN0IHBsYXRmb3JtX2Rldmlj ZQkqcGRldjsKKwlzdHJ1Y3QgZG1hX3Bvb2wJCSpzY19wb29sOworCXN0cnVjdCBkZXZpY2UgKmRl djsKKwlzcGlubG9ja190CXNjaWRfbG9jazsgLyogbG9jayBmb3IgU0MtSUQgYWxsb2NhdGlvbiAq LworCS8qIFNlY3VyaXR5IGNvbnRleHQgZGF0YSAqLworCXUxNgkJc2NfaWRfc3RhcnQ7CisJdTE2 CQlzY19pZF9lbmQ7CisJdTE2CQlzY19pZDsKKwl1bnNpZ25lZCBsb25nCWN0eF9ibVtESVZfUk9V TkRfVVAoU0FfTUFYX05VTV9DVFgsCisJCQkJQklUU19QRVJfTE9ORyldOworCXN0cnVjdCBzYV90 Zm1fY3R4CSpjdHg7CisJc3RydWN0IGRtYV9jaGFuCQkqZG1hX3J4MTsKKwlzdHJ1Y3QgZG1hX2No YW4JCSpkbWFfcngyOworCXN0cnVjdCBkbWFfY2hhbgkJKmRtYV90eDsKK307CisKKy8qKgorICog c3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbzogQ29tbWFuZCBsYWJlbCBwYXJhbWV0ZXJzIGluZm8K KyAqIEBpbmRleDogSW5kZXggb2YgdGhlIHBhcmFtZXRlciBpbiB0aGUgY29tbWFuZCBsYWJlbCBm b3JtYXQKKyAqIEBvZmZzZXQ6IHRoZSBvZmZzZXQgb2YgdGhlIHBhcmFtZXRlcgorICogQHNpemU6 IFNpemUgb2YgdGhlIHBhcmFtZXRlcgorICovCitzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvIHsK Kwl1MTYJaW5kZXg7CisJdTE2CW9mZnNldDsKKwl1MTYJc2l6ZTsKK307CisKKy8qIE1heGltdW0g bGVuZ3RoIG9mIEF1eGlsaWFyeSBkYXRhIGluIDMyYml0IHdvcmRzICovCisjZGVmaW5lIFNBX01B WF9BVVhfREFUQV9XT1JEUwk4CisKKy8qKgorICogc3RydWN0IHNhX2NtZGxfdXBkX2luZm86IENv bW1hbmQgbGFiZWwgdXBkYXRpb24gaW5mbworICogQGZsYWdzOiBmbGFncyBpbiBjb21tYW5kIGxh YmVsCisgKiBAc3VibW9kZTogRW5jcnlwdGlvbiBzdWJtb2RlcworICogQGVuY19zaXplOiBTaXpl IG9mIGZpcnN0IHBhc3MgZW5jcnlwdGlvbiBzaXplCisgKiBAZW5jX3NpemUyOiBTaXplIG9mIHNl Y29uZCBwYXNzIGVuY3J5cHRpb24gc2l6ZQorICogQGVuY19vZmZzZXQ6IEVuY3J5cHRpb24gcGF5 bG9hZCBvZmZzZXQgaW4gdGhlIHBhY2tldAorICogQGVuY19pdjogRW5jcnlwdGlvbiBpbml0aWFs aXphdGlvbiB2ZWN0b3IgZm9yIHBhc3MyCisgKiBAZW5jX2l2MjogRW5jcnlwdGlvbiBpbml0aWFs aXphdGlvbiB2ZWN0b3IgZm9yIHBhc3MyCisgKiBAYWFkOiBBc3NvY2lhdGVkIGRhdGEKKyAqIEBw YXlsb2FkOiBQYXlsb2FkIGluZm8KKyAqIEBhdXRoX3NpemU6IEF1dGhlbnRpY2F0aW9uIHNpemUg Zm9yIHBhc3MgMQorICogQGF1dGhfc2l6ZTI6IEF1dGhlbnRpY2F0aW9uIHNpemUgZm9yIHBhc3Mg MgorICogQGF1dGhfb2Zmc2V0OiBBdXRoZW50aWNhdGlvbiBwYXlsb2FkIG9mZnNldAorICogQGF1 dGhfaXY6IEF1dGhlbnRpY2F0aW9uIGluaXRpYWxpemF0aW9uIHZlY3RvcgorICogQGF1eF9rZXlf aW5mbzogQXV0aGVudGljYXRpb24gYXV4IGtleSBpbmZvcm1hdGlvbgorICogQGF1eF9rZXk6IEF1 eCBrZXkgZm9yIGF1dGhlbnRpY2F0aW9uCisgKi8KK3N0cnVjdCBzYV9jbWRsX3VwZF9pbmZvIHsK Kwl1MTYJZmxhZ3M7CisJdTE2CXN1Ym1vZGU7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwll bmNfc2l6ZTsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWVuY19zaXplMjsKKwlzdHJ1Y3Qg c2FfY21kbF9wYXJhbV9pbmZvCWVuY19vZmZzZXQ7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5m bwllbmNfaXY7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwllbmNfaXYyOworCXN0cnVjdCBz YV9jbWRsX3BhcmFtX2luZm8JYWFkOworCXN0cnVjdCBzYV9jbWRsX3BhcmFtX2luZm8JcGF5bG9h ZDsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWF1dGhfc2l6ZTsKKwlzdHJ1Y3Qgc2FfY21k bF9wYXJhbV9pbmZvCWF1dGhfc2l6ZTI7CisJc3RydWN0IHNhX2NtZGxfcGFyYW1faW5mbwlhdXRo X29mZnNldDsKKwlzdHJ1Y3Qgc2FfY21kbF9wYXJhbV9pbmZvCWF1dGhfaXY7CisJc3RydWN0IHNh X2NtZGxfcGFyYW1faW5mbwlhdXhfa2V5X2luZm87CisJdTMyCQkJCWF1eF9rZXlbU0FfTUFYX0FV WF9EQVRBX1dPUkRTXTsKK307CisKKy8qCisgKiBOdW1iZXIgb2YgMzJiaXQgd29yZHMgYXBwZW5k ZWQgYWZ0ZXIgdGhlIGNvbW1hbmQgbGFiZWwKKyAqIGluIFBTREFUQSB0byBpZGVudGlmeSB0aGUg Y3J5cHRvIHJlcXVlc3QgY29udGV4dC4KKyAqIHdvcmQtMDogUmVxdWVzdCB0eXBlCisgKiB3b3Jk LTE6IHBvaW50ZXIgdG8gcmVxdWVzdAorICovCisjZGVmaW5lIFNBX1BTREFUQV9DVFhfV09SRFMg NAorCisvKiBNYXhpbXVtIHNpemUgb2YgQ29tbWFuZCBsYWJlbCBpbiAzMiB3b3JkcyAqLworI2Rl ZmluZSBTQV9NQVhfQ01ETF9XT1JEUyAoU0FfRE1BX05VTV9QU19XT1JEUyAtIFNBX1BTREFUQV9D VFhfV09SRFMpCisKKy8qKgorICogc3RydWN0IHNhX2N0eF9pbmZvOiBTQSBjb250ZXh0IGluZm9y bWF0aW9uCisgKiBAc2M6IFBvaW50ZXIgdG8gc2VjdXJpdHkgY29udGV4dAorICogQHNjX3BoeXM6 IFNlY3VyaXR5IGNvbnRleHQgcGh5c2ljYWwgYWRkcmVzcyB0aGF0IGlzIHBhc3NlZCBvbiB0byBT QTJVTAorICogQGNtZGxfc2l6ZTogQ29tbWFuZCBsYWJlbCBzaXplCisgKiBAY21kbDogQ29tbWFu ZCBsYWJlbCBmb3IgYSBwYXJ0aWN1bGFyIGl0ZXJhdGlvbgorICogQGNtZGxfdXBkX2luZm86IHN0 cnVjdHVyZSBob2xkaW5nIGNvbW1hbmQgbGFiZWwgdXBkYXRpb24gaW5mbworICogQGVwaWI6IEV4 dGVuZGVkIHByb3RvY29sIGluZm9ybWF0aW9uIGJsb2NrIHdvcmRzCisgKi8KK3N0cnVjdCBzYV9j dHhfaW5mbyB7CisJdTgJCSpzYzsKKwlkbWFfYWRkcl90CXNjX3BoeXM7CisJdTE2CQlzY19pZDsK Kwl1MTYJCWNtZGxfc2l6ZTsKKwl1MzIJCWNtZGxbU0FfTUFYX0NNRExfV09SRFNdOworCXN0cnVj dCBzYV9jbWRsX3VwZF9pbmZvIGNtZGxfdXBkX2luZm87CisJLyogU3RvcmUgQXV4aWxpYXJ5IGRh dGEgc3VjaCBhcyBLMi9LMyBzdWJrZXlzIGluIEFFUy1YQ0JDICovCisJdTMyCQllcGliW1NBX0RN QV9OVU1fRVBJQl9XT1JEU107Cit9OworCitzdHJ1Y3Qgc2Ffc2hhbV9obWFjX2N0eCB7CisJc3Ry dWN0IGNyeXB0b19zaGFzaAkqc2hhc2g7CisJdTgJCQlpcGFkW1NIQTUxMl9CTE9DS19TSVpFXSBT QV9BTElHTkVEOworCXU4CQkJb3BhZFtTSEE1MTJfQkxPQ0tfU0laRV0gU0FfQUxJR05FRDsKK307 CisKKy8qKgorICogc3RydWN0IHNhX3RmbV9jdHg6IFRGTSBjb250ZXh0IHN0cnVjdHVyZQorICog QGRldl9kYXRhOiBzdHJ1Y3Qgc2FfY3J5cHRvX2RhdGEgcG9pbnRlcgorICogQGVuYzogc3RydWN0 IHNhX2N0eF9pbmZvIGZvciBlbmNyeXB0aW9uCisgKiBAZGVjOiBzdHJ1Y3Qgc2FfY3R4X2luZm8g Zm9yIGRlY3J5cHRpb24KKyAqIEBhdXRoOiBzdHJ1Y3Qgc2FfY3R4X2luZm8gZm9yIGF1dGhlbnRp Y2F0aW9uCisgKiBAa2V5bGVuOiBlbmNycHRpb24vZGVjcnlwdGlvbiBrZXlsZW5ndGgKKyAqIEBr ZXk6IGVuY3J5cHRpb24ga2V5CisgKiBAc2hhc2g6IHNvZnR3YXJlIGhhc2ggY3J5cHRvX2hhc2gK KyAqIEBhdXRoa2V5OiBhdXRoZW50aWNhdGlvbiBrZXkKKyAqLworc3RydWN0IHNhX3RmbV9jdHgg eworCXN0cnVjdCBzYV9jcnlwdG9fZGF0YSAqZGV2X2RhdGE7CisJc3RydWN0IHNhX2N0eF9pbmZv IGVuYzsKKwlzdHJ1Y3Qgc2FfY3R4X2luZm8gZGVjOworCXN0cnVjdCBzYV9jdHhfaW5mbyBhdXRo OworCWludCBrZXlsZW47CisJdTMyIGtleVtBRVNfS0VZU0laRV8yNTYgLyBzaXplb2YodTMyKV07 CisJc3RydWN0IHNhX3NoYW1faG1hY19jdHggYmFzZVswXTsKKwlzdHJ1Y3QgY3J5cHRvX3NoYXNo CSpzaGFzaDsKKwl1OCBhdXRoa2V5W1NIQTUxMl9CTE9DS19TSVpFXTsKK307CisKKy8qKgorICog c3RydWN0IHNhX2RtYV9yZXFfY3R4OiBTdHJ1Y3R1cmUgdXNlZCBmb3IgdHggZG1hIHJlcXVlc3QK KyAqIEBkZXZfZGF0YTogc3RydWN0IHNhX2NyeXB0b19kYXRhIHBvaW50ZXIKKyAqIEBjbWRsOiBD b21wbGV0ZSBjb21tYW5kIGxhYmVsIHdpdGggcHNkYXRhIGFuZCBlcGliIGluY2x1ZGVkCisgKiBA c3JjOiBzb3VyY2UgcGF5bG9hZCBzY2F0dGVybGlzdCBwb2ludGVyCisgKiBAc3JjX25lbnRzOiBO dW1iZXIgb2Ygbm9kZXMgaW4gc291cmNlIHNjYXR0ZXJsaXN0CisgKiBAcGt0OiBwYWNrZXQgZG1h CisgKi8KK3N0cnVjdCBzYV9kbWFfcmVxX2N0eCB7CisJc3RydWN0IHNhX2NyeXB0b19kYXRhICpk ZXZfZGF0YTsKKwl1MzIJCWNtZGxbU0FfTUFYX0NNRExfV09SRFMgKyBTQV9QU0RBVEFfQ1RYX1dP UkRTXTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNyYzsKKwl1bnNpZ25lZCBpbnQJc3JjX25lbnRz OworCWJvb2wJCXBrdDsKK307CisKK2VudW0gc2Ffc3VibW9kZSB7CisJU0FfTU9ERV9HRU4gPSAw LAorCVNBX01PREVfQ0NNLAorCVNBX01PREVfR0NNLAorCVNBX01PREVfR01BQworfTsKKworLyog RW5jcnlwdGlvbiBhbGdvcml0aG1zICovCitlbnVtIHNhX2VhbGdfaWQgeworCVNBX0VBTEdfSURf Tk9ORSA9IDAsICAgICAgICAvKiBObyBlbmNyeXB0aW9uICovCisJU0FfRUFMR19JRF9OVUxMLCAg ICAgICAgICAgIC8qIE5VTEwgZW5jcnlwdGlvbiAqLworCVNBX0VBTEdfSURfQUVTX0NUUiwgICAg ICAgICAvKiBBRVMgQ291bnRlciBtb2RlICovCisJU0FfRUFMR19JRF9BRVNfRjgsICAgICAgICAg IC8qIEFFUyBGOCBtb2RlICovCisJU0FfRUFMR19JRF9BRVNfQ0JDLCAgICAgICAgIC8qIEFFUyBD QkMgbW9kZSAqLworCVNBX0VBTEdfSURfREVTX0NCQywgICAgICAgICAvKiBERVMgQ0JDIG1vZGUg Ki8KKwlTQV9FQUxHX0lEXzNERVNfQ0JDLCAgICAgICAgLyogM0RFUyBDQkMgbW9kZSAqLworCVNB X0VBTEdfSURfQ0NNLCAgICAgICAgICAgICAvKiBDb3VudGVyIHdpdGggQ0JDLU1BQyBtb2RlICov CisJU0FfRUFMR19JRF9HQ00sICAgICAgICAgICAgIC8qIEdhbG9pcyBDb3VudGVyIG1vZGUgKi8K KwlTQV9FQUxHX0lEX0FFU19FQ0IsCisJU0FfRUFMR19JRF9MQVNUCit9OworCisvKiBBdXRoZW50 aWNhdGlvbiBhbGdvcml0aG1zICovCitlbnVtIHNhX2FhbGdfaWQgeworCVNBX0FBTEdfSURfTk9O RSA9IDAsICAgICAgLyogTm8gQXV0aGVudGljYXRpb24gICovCisJU0FfQUFMR19JRF9OVUxMID0g U0FfRUFMR19JRF9MQVNULCAvKiBOVUxMIEF1dGhlbnRpY2F0aW9uICAqLworCVNBX0FBTEdfSURf TUQ1LCAgICAgICAgICAgLyogTUQ1IG1vZGUgKi8KKwlTQV9BQUxHX0lEX1NIQTEsICAgICAgICAg IC8qIFNIQTEgbW9kZSAqLworCVNBX0FBTEdfSURfU0hBMl8yMjQsICAgICAgLyogMjI0LWJpdCBT SEEyIG1vZGUgKi8KKwlTQV9BQUxHX0lEX1NIQTJfMjU2LCAgICAgIC8qIDI1Ni1iaXQgU0hBMiBt b2RlICovCisJU0FfQUFMR19JRF9ITUFDX01ENSwgICAgICAvKiBITUFDIHdpdGggTUQ1IG1vZGUg Ki8KKwlTQV9BQUxHX0lEX0hNQUNfU0hBMSwgICAgIC8qIEhNQUMgd2l0aCBTSEExIG1vZGUgKi8K KwlTQV9BQUxHX0lEX0hNQUNfU0hBMl8yMjQsIC8qIEhNQUMgd2l0aCAyMjQtYml0IFNIQTIgbW9k ZSAqLworCVNBX0FBTEdfSURfSE1BQ19TSEEyXzI1NiwgLyogSE1BQyB3aXRoIDI1Ni1iaXQgU0hB MiBtb2RlICovCisJU0FfQUFMR19JRF9HTUFDLCAgICAgICAgICAvKiBHYWxvaXMgTWVzc2FnZSBB dXRoLiBDb2RlIG1vZGUgKi8KKwlTQV9BQUxHX0lEX0NNQUMsICAgICAgICAgIC8qIENpcGhlci1i YXNlZCBNZXMuIEF1dGguIENvZGUgbW9kZSAqLworCVNBX0FBTEdfSURfQ0JDX01BQywgICAgICAg LyogQ2lwaGVyIEJsb2NrIENoYWluaW5nICovCisJU0FfQUFMR19JRF9BRVNfWENCQyAgICAgICAv KiBBRVMgRXh0ZW5kZWQgQ2lwaGVyIEJsb2NrIENoYWluaW5nICovCit9OworCisvKgorICogTW9k ZSBjb250cm9sIGVuZ2luZSBhbGdvcml0aG1zIHVzZWQgdG8gaW5kZXggdGhlCisgKiBtb2RlIGNv bnRyb2wgaW5zdHJ1Y3Rpb24gdGFibGVzCisgKi8KK2VudW0gc2FfZW5nX2FsZ29faWQgeworCVNB X0VOR19BTEdPX0VDQiA9IDAsCisJU0FfRU5HX0FMR09fQ0JDLAorCVNBX0VOR19BTEdPX0NGQiwK KwlTQV9FTkdfQUxHT19PRkIsCisJU0FfRU5HX0FMR09fQ1RSLAorCVNBX0VOR19BTEdPX0Y4LAor CVNBX0VOR19BTEdPX0Y4RjksCisJU0FfRU5HX0FMR09fR0NNLAorCVNBX0VOR19BTEdPX0dNQUMs CisJU0FfRU5HX0FMR09fQ0NNLAorCVNBX0VOR19BTEdPX0NNQUMsCisJU0FfRU5HX0FMR09fQ0JD TUFDLAorCVNBX05VTV9FTkdfQUxHT1MKK307CisKK3N0cnVjdCBzYV9lbmdfaW5mbyB7CisJdTgJ ZW5nX2lkOworCXUxNglzY19zaXplOworfTsKKworZXh0ZXJuIHN0cnVjdCBkZXZpY2UgKnNhX2tz Ml9kZXY7CisKKyNlbmRpZiAvKiBfSzNfU0EyVUxfICovCi0tIAoyLjE3LjEKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1h aWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==