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 681DCC433E2 for ; Thu, 28 May 2020 01:33:00 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2CCA520FC3 for ; Thu, 28 May 2020 01:33:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="EkQupREW" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726866AbgE1Bc7 (ORCPT ); Wed, 27 May 2020 21:32:59 -0400 Received: from mailout3.samsung.com ([203.254.224.33]:50270 "EHLO mailout3.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726793AbgE1Bcz (ORCPT ); Wed, 27 May 2020 21:32:55 -0400 Received: from epcas5p4.samsung.com (unknown [182.195.41.42]) by mailout3.samsung.com (KnoxPortal) with ESMTP id 20200528013243epoutp03d88f167d3a66b138b0c7373d6a82ebfa~TDSkwwCiN0197901979epoutp03a for ; Thu, 28 May 2020 01:32:43 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout3.samsung.com 20200528013243epoutp03d88f167d3a66b138b0c7373d6a82ebfa~TDSkwwCiN0197901979epoutp03a DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1590629563; bh=PDMiJY/am/0bhgJyyZVMhqytx7f8PSCHMTlceMBvDDU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EkQupREWZZsZTh6A0Zsaet337cGcFGDg42iHmgB5hX5vCs6gwdHAS1SvxqeZCXc9v Xel8g3L/nMXzFEZ9q61KMIfXWljmSSoPPQib3ux8MCeRzdjIlyJCMCnyPpVdrWuVOX oVVigE7qMOnROOuMLPAaU0LIa5oFFCc6boP5Mr7I= Received: from epsmges5p2new.samsung.com (unknown [182.195.42.74]) by epcas5p1.samsung.com (KnoxPortal) with ESMTP id 20200528013243epcas5p1a4e0a58b7ed7a9915b91030607b0e5d6~TDSkVUGCX1882918829epcas5p1V; Thu, 28 May 2020 01:32:43 +0000 (GMT) Received: from epcas5p2.samsung.com ( [182.195.41.40]) by epsmges5p2new.samsung.com (Symantec Messaging Gateway) with SMTP id 73.68.09703.BB41FCE5; Thu, 28 May 2020 10:32:43 +0900 (KST) Received: from epsmtrp2.samsung.com (unknown [182.195.40.14]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPA id 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0~TDSj8dFkd2994029940epcas5p4U; Thu, 28 May 2020 01:32:43 +0000 (GMT) Received: from epsmgms1p2.samsung.com (unknown [182.195.42.42]) by epsmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200528013243epsmtrp22f1e8612d450e4afae9efda48913d1fb~TDSj7ivMr2193121931epsmtrp2P; Thu, 28 May 2020 01:32:43 +0000 (GMT) X-AuditID: b6c32a4a-4b5ff700000025e7-fc-5ecf14bb5db6 Received: from epsmtip1.samsung.com ( [182.195.34.30]) by epsmgms1p2.samsung.com (Symantec Messaging Gateway) with SMTP id EF.77.08303.AB41FCE5; Thu, 28 May 2020 10:32:42 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200528013240epsmtip12b2a9f167665fc9fd805b7c77a2c2310~TDSh5ygIt1669416694epsmtip1m; Thu, 28 May 2020 01:32:40 +0000 (GMT) From: Alim Akhtar To: robh@kernel.org Cc: devicetree@vger.kernel.org, linux-scsi@vger.kernel.org, krzk@kernel.org, avri.altman@wdc.com, martin.petersen@oracle.com, kwmad.kim@samsung.com, stanley.chu@mediatek.com, cang@codeaurora.org, linux-samsung-soc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Alim Akhtar Subject: [PATCH v10 09/10] scsi: ufs-exynos: add UFS host support for Exynos SoCs Date: Thu, 28 May 2020 06:46:57 +0530 Message-Id: <20200528011658.71590-10-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200528011658.71590-1-alim.akhtar@samsung.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFtrCKsWRmVeSWpSXmKPExsWy7bCmhu5ukfNxBn8miVo8mLeNzeLlz6ts Fp/WL2O1mH/kHKvF+fMb2C1ubjnKYrHp8TVWi8u75rBZzDi/j8mi+/oONovlx/8xWfzfs4Pd YunWm4wOvB6X+3qZPDat6mTz2Lyk3qPl5H4Wj49Pb7F49G1ZxejxeZOcR/uBbqYAjigum5TU nMyy1CJ9uwSujFcbp7EW9E5kruhpe8PewPjxHFMXIyeHhICJxO+lHSxdjFwcQgK7GSVOL73H DOF8YpRYvKgXyvnMKPHk+yJ2mJaNDxugErsYJS7eOw/ltDBJNN19xAZSxSagLXF3+hawJSIC whJHvrUxgtjMAjeYJB6sdOli5OAQFgiWeL1UBCTMIqAqcXJNKwuIzStgK3Fu5y5WiGXyEqs3 HGAGKecEiu+d4ABRIihxcuYTFoiJ8hLNW2eDnSAhcIBDYtf2SVC/uUhM23cf6mhhiVfHt0DZ UhKf3+1lA5kpIZAt0bPLGCJcI7F03jEWCNte4sCVOSwgJcwCmhLrd+lDrOKT6P39hAmik1ei o00IolpVovndVahOaYmJ3d1Qx3tIzP4ziRUSOBMYJXqaV7JOYJSfheSDWUg+mIWwbQEj8ypG ydSC4tz01GLTAqO81HK94sTc4tK8dL3k/NxNjOCEpeW1g/Hhgw96hxiZOBgPMUpwMCuJ8Dqd PR0nxJuSWFmVWpQfX1Sak1p8iFGag0VJnFfpx5k4IYH0xJLU7NTUgtQimCwTB6dUA5ODU0+q luvt+p7jGRLzWEuUtjKeyPo+O+yskXJ642xnWZfYwO+KZvtWvDW+fHuFDndF4vkDMld3BU7c vkpUQdaftS8psf22zIw/k8vkU17Fr6y7U3lNmSVGZEpLWVgXi9fEhzt4D83Jjb5bL35sLu/b lr1fY1qdFX7eC3lu/2oby+Vrh57Lvapmv6qedqbwwsY939/Gyenkyx10XRmkUV4wff8GE+7M K5vLle5vXDxpX63as5lTVx3rajTb2LqoNOWHhK3cjCRmLeXWL+f6U+9Z+7t2leuZ/WbvPGl3 +VoOc9/Uld1HD6xcue5l7wMGXVvzqCZBZtETKk4e74+mXKiUy7K6uYOrS0z2x77FCkosxRmJ hlrMRcWJAGDuF7DHAwAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFupkkeLIzCtJLcpLzFFi42LZdlhJTneXyPk4g64vZhYP5m1js3j58yqb xaf1y1gt5h85x2px/vwGdoubW46yWGx6fI3V4vKuOWwWM87vY7Lovr6DzWL58X9MFv/37GC3 WLr1JqMDr8flvl4mj02rOtk8Ni+p92g5uZ/F4+PTWywefVtWMXp83iTn0X6gmymAI4rLJiU1 J7MstUjfLoEr49XGaawFvROZK3ra3rA3MH48x9TFyMkhIWAisfFhA3MXIxeHkMAORolLf1dB JaQlrm+cwA5hC0us/PecHaKoiUni2e1JbCAJNgFtibvTt4A1iAAVHfnWxghiMws8Y5I49bC0 i5GDQ1ggUOLIc7ASFgFViZNrWllAbF4BW4lzO3exQsyXl1i94QAzSDknUHzvBAeQsJCAjcSE VXsZIcoFJU7OfMICUsIsoC6xfp4QxCJ5ieats5knMArOQlI1C6FqFpKqBYzMqxglUwuKc9Nz iw0LjPJSy/WKE3OLS/PS9ZLzczcxgmNLS2sH455VH/QOMTJxMB5ilOBgVhLhdTp7Ok6INyWx siq1KD++qDQntfgQozQHi5I479dZC+OEBNITS1KzU1MLUotgskwcnFINTGH7Hp/0sV6fX9Cw PCezrXd5yK5P11hTJGNjV585nG5eJS71MuTtJoHnG3zZ3LecDQnka/ppcjKmmHelyasdcd8t 5QXXmT20v3Tt7caLJWcqcnwKN/puZk97yiTNkJf25svikIj3QmeM9T0yw69VeIXmHPjz4O4W eVc+sx8xXD82qgVsvSa8L2ul6qYTfxfcE7h49di6dkP/FA7tv01N0yatru/XErOfmXbnZ4qx XvC9k5+OdF1pexbYWP43Pfxb3fQVR564OP19wHP/w60ca+miZ+fn6u9cHaZVfYj/bfH2mC8+ /R//WwicL1vFn77/wsePoYWTFt1uZv96XCxqgxO7s1RHltxHdqltL3U9/imxFGckGmoxFxUn AgAETKL3HAMAAA== X-CMS-MailID: 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" CMS-TYPE: 105P X-CMS-RootMailID: 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0 References: <20200528011658.71590-1-alim.akhtar@samsung.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch introduces Exynos UFS host controller driver, which mainly handles vendor-specific operations including link startup, power mode change and hibernation/unhibernation. Reported-by: kbuild test robot Reported-by: Julia Lawall [robot: drivers/scsi/ufs/ufs-exynos.c:931:8-10: WARNING: possible condition with no effect (if == else) ] Reviewed-by: Kiwoong Kim Reviewed-by: Avri Altman Signed-off-by: Seungwon Jeon Signed-off-by: Alim Akhtar Tested-by: Paweł Chmiel --- drivers/scsi/ufs/Kconfig | 12 + drivers/scsi/ufs/Makefile | 1 + drivers/scsi/ufs/ufs-exynos.c | 1292 +++++++++++++++++++++++++++++++++ drivers/scsi/ufs/ufs-exynos.h | 287 ++++++++ drivers/scsi/ufs/unipro.h | 33 + 5 files changed, 1625 insertions(+) create mode 100644 drivers/scsi/ufs/ufs-exynos.c create mode 100644 drivers/scsi/ufs/ufs-exynos.h diff --git a/drivers/scsi/ufs/Kconfig b/drivers/scsi/ufs/Kconfig index e2005aeddc2d..7da886d3c323 100644 --- a/drivers/scsi/ufs/Kconfig +++ b/drivers/scsi/ufs/Kconfig @@ -160,3 +160,15 @@ config SCSI_UFS_BSG Select this if you need a bsg device node for your UFS controller. If unsure, say N. + +config SCSI_UFS_EXYNOS + bool "EXYNOS specific hooks to UFS controller platform driver" + depends on SCSI_UFSHCD_PLATFORM && (ARCH_EXYNOS || COMPILE_TEST) + select PHY_SAMSUNG_UFS + help + This selects the EXYNOS specific additions to UFSHCD platform driver. + UFS host on EXYNOS includes HCI and UNIPRO layer, and associates with + UFS-PHY driver. + + Select this if you have UFS host controller on EXYNOS chipset. + If unsure, say N. diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile index 94c6c5d7334b..f0c5b95ec9cc 100644 --- a/drivers/scsi/ufs/Makefile +++ b/drivers/scsi/ufs/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_SCSI_UFS_DWC_TC_PCI) += tc-dwc-g210-pci.o ufshcd-dwc.o tc-dwc-g210. obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-g210-pltfrm.o ufshcd-dwc.o tc-dwc-g210.o obj-$(CONFIG_SCSI_UFS_CDNS_PLATFORM) += cdns-pltfrm.o obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o +obj-$(CONFIG_SCSI_UFS_EXYNOS) += ufs-exynos.o obj-$(CONFIG_SCSI_UFSHCD) += ufshcd-core.o ufshcd-core-y += ufshcd.o ufs-sysfs.o ufshcd-core-$(CONFIG_SCSI_UFS_BSG) += ufs_bsg.o diff --git a/drivers/scsi/ufs/ufs-exynos.c b/drivers/scsi/ufs/ufs-exynos.c new file mode 100644 index 000000000000..440f2af83d9c --- /dev/null +++ b/drivers/scsi/ufs/ufs-exynos.c @@ -0,0 +1,1292 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * UFS Host Controller driver for Exynos specific extensions + * + * Copyright (C) 2014-2015 Samsung Electronics Co., Ltd. + * Author: Seungwon Jeon + * Author: Alim Akhtar + * + */ + +#include +#include +#include +#include +#include +#include + +#include "ufshcd.h" +#include "ufshcd-pltfrm.h" +#include "ufshci.h" +#include "unipro.h" + +#include "ufs-exynos.h" + +/* + * Exynos's Vendor specific registers for UFSHCI + */ +#define HCI_TXPRDT_ENTRY_SIZE 0x00 +#define PRDT_PREFECT_EN BIT(31) +#define PRDT_SET_SIZE(x) ((x) & 0x1F) +#define HCI_RXPRDT_ENTRY_SIZE 0x04 +#define HCI_1US_TO_CNT_VAL 0x0C +#define CNT_VAL_1US_MASK 0x3FF +#define HCI_UTRL_NEXUS_TYPE 0x40 +#define HCI_UTMRL_NEXUS_TYPE 0x44 +#define HCI_SW_RST 0x50 +#define UFS_LINK_SW_RST BIT(0) +#define UFS_UNIPRO_SW_RST BIT(1) +#define UFS_SW_RST_MASK (UFS_UNIPRO_SW_RST | UFS_LINK_SW_RST) +#define HCI_DATA_REORDER 0x60 +#define HCI_UNIPRO_APB_CLK_CTRL 0x68 +#define UNIPRO_APB_CLK(v, x) (((v) & ~0xF) | ((x) & 0xF)) +#define HCI_AXIDMA_RWDATA_BURST_LEN 0x6C +#define HCI_GPIO_OUT 0x70 +#define HCI_ERR_EN_PA_LAYER 0x78 +#define HCI_ERR_EN_DL_LAYER 0x7C +#define HCI_ERR_EN_N_LAYER 0x80 +#define HCI_ERR_EN_T_LAYER 0x84 +#define HCI_ERR_EN_DME_LAYER 0x88 +#define HCI_CLKSTOP_CTRL 0xB0 +#define REFCLK_STOP BIT(2) +#define UNIPRO_MCLK_STOP BIT(1) +#define UNIPRO_PCLK_STOP BIT(0) +#define CLK_STOP_MASK (REFCLK_STOP |\ + UNIPRO_MCLK_STOP |\ + UNIPRO_PCLK_STOP) +#define HCI_MISC 0xB4 +#define REFCLK_CTRL_EN BIT(7) +#define UNIPRO_PCLK_CTRL_EN BIT(6) +#define UNIPRO_MCLK_CTRL_EN BIT(5) +#define HCI_CORECLK_CTRL_EN BIT(4) +#define CLK_CTRL_EN_MASK (REFCLK_CTRL_EN |\ + UNIPRO_PCLK_CTRL_EN |\ + UNIPRO_MCLK_CTRL_EN) +/* Device fatal error */ +#define DFES_ERR_EN BIT(31) +#define DFES_DEF_L2_ERRS (UIC_DATA_LINK_LAYER_ERROR_RX_BUF_OF |\ + UIC_DATA_LINK_LAYER_ERROR_PA_INIT) +#define DFES_DEF_L3_ERRS (UIC_NETWORK_UNSUPPORTED_HEADER_TYPE |\ + UIC_NETWORK_BAD_DEVICEID_ENC |\ + UIC_NETWORK_LHDR_TRAP_PACKET_DROPPING) +#define DFES_DEF_L4_ERRS (UIC_TRANSPORT_UNSUPPORTED_HEADER_TYPE |\ + UIC_TRANSPORT_UNKNOWN_CPORTID |\ + UIC_TRANSPORT_NO_CONNECTION_RX |\ + UIC_TRANSPORT_BAD_TC) + +enum { + UNIPRO_L1_5 = 0,/* PHY Adapter */ + UNIPRO_L2, /* Data Link */ + UNIPRO_L3, /* Network */ + UNIPRO_L4, /* Transport */ + UNIPRO_DME, /* DME */ +}; + +/* + * UNIPRO registers + */ +#define UNIPRO_COMP_VERSION 0x000 +#define UNIPRO_DME_PWR_REQ 0x090 +#define UNIPRO_DME_PWR_REQ_POWERMODE 0x094 +#define UNIPRO_DME_PWR_REQ_LOCALL2TIMER0 0x098 +#define UNIPRO_DME_PWR_REQ_LOCALL2TIMER1 0x09C +#define UNIPRO_DME_PWR_REQ_LOCALL2TIMER2 0x0A0 +#define UNIPRO_DME_PWR_REQ_REMOTEL2TIMER0 0x0A4 +#define UNIPRO_DME_PWR_REQ_REMOTEL2TIMER1 0x0A8 +#define UNIPRO_DME_PWR_REQ_REMOTEL2TIMER2 0x0AC + +/* + * UFS Protector registers + */ +#define UFSPRSECURITY 0x010 +#define NSSMU BIT(14) +#define UFSPSBEGIN0 0x200 +#define UFSPSEND0 0x204 +#define UFSPSLUN0 0x208 +#define UFSPSCTRL0 0x20C + +#define CNTR_DIV_VAL 40 + +static void exynos_ufs_auto_ctrl_hcc(struct exynos_ufs *ufs, bool en); +static void exynos_ufs_ctrl_clkstop(struct exynos_ufs *ufs, bool en); + +static inline void exynos_ufs_enable_auto_ctrl_hcc(struct exynos_ufs *ufs) +{ + exynos_ufs_auto_ctrl_hcc(ufs, true); +} + +static inline void exynos_ufs_disable_auto_ctrl_hcc(struct exynos_ufs *ufs) +{ + exynos_ufs_auto_ctrl_hcc(ufs, false); +} + +static inline void exynos_ufs_disable_auto_ctrl_hcc_save( + struct exynos_ufs *ufs, u32 *val) +{ + *val = hci_readl(ufs, HCI_MISC); + exynos_ufs_auto_ctrl_hcc(ufs, false); +} + +static inline void exynos_ufs_auto_ctrl_hcc_restore( + struct exynos_ufs *ufs, u32 *val) +{ + hci_writel(ufs, *val, HCI_MISC); +} + +static inline void exynos_ufs_gate_clks(struct exynos_ufs *ufs) +{ + exynos_ufs_ctrl_clkstop(ufs, true); +} + +static inline void exynos_ufs_ungate_clks(struct exynos_ufs *ufs) +{ + exynos_ufs_ctrl_clkstop(ufs, false); +} + +static int exynos7_ufs_drv_init(struct device *dev, struct exynos_ufs *ufs) +{ + return 0; +} + +static int exynos7_ufs_pre_link(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + u32 val = ufs->drv_data->uic_attr->pa_dbg_option_suite; + int i; + + exynos_ufs_enable_ov_tm(hba); + for_each_ufs_tx_lane(ufs, i) + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x297, i), 0x17); + for_each_ufs_rx_lane(ufs, i) { + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x362, i), 0xff); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x363, i), 0x00); + } + exynos_ufs_disable_ov_tm(hba); + + for_each_ufs_tx_lane(ufs, i) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(TX_HIBERN8_CONTROL, i), 0x0); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_TXPHY_CFGUPDT), 0x1); + udelay(1); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_OPTION_SUITE), val | (1 << 12)); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_SKIP_RESET_PHY), 0x1); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_SKIP_LINE_RESET), 0x1); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_LINE_RESET_REQ), 0x1); + udelay(1600); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_OPTION_SUITE), val); + + return 0; +} + +static int exynos7_ufs_post_link(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + int i; + + exynos_ufs_enable_ov_tm(hba); + for_each_ufs_tx_lane(ufs, i) { + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x28b, i), 0x83); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x29a, i), 0x07); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x277, i), + TX_LINERESET_N(exynos_ufs_calc_time_cntr(ufs, 200000))); + } + exynos_ufs_disable_ov_tm(hba); + + exynos_ufs_enable_dbg_mode(hba); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_SAVECONFIGTIME), 0xbb8); + exynos_ufs_disable_dbg_mode(hba); + + return 0; +} + +static int exynos7_ufs_pre_pwr_change(struct exynos_ufs *ufs, + struct ufs_pa_layer_attr *pwr) +{ + unipro_writel(ufs, 0x22, UNIPRO_DBG_FORCE_DME_CTRL_STATE); + + return 0; +} + +static int exynos7_ufs_post_pwr_change(struct exynos_ufs *ufs, + struct ufs_pa_layer_attr *pwr) +{ + struct ufs_hba *hba = ufs->hba; + int lanes = max_t(u32, pwr->lane_rx, pwr->lane_tx); + + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_RXPHY_CFGUPDT), 0x1); + + if (lanes == 1) { + exynos_ufs_enable_dbg_mode(hba); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES), 0x1); + exynos_ufs_disable_dbg_mode(hba); + } + + return 0; +} + +/** + * exynos_ufs_auto_ctrl_hcc - HCI core clock control by h/w + * Control should be disabled in the below cases + * - Before host controller S/W reset + * - Access to UFS protector's register + */ +static void exynos_ufs_auto_ctrl_hcc(struct exynos_ufs *ufs, bool en) +{ + u32 misc = hci_readl(ufs, HCI_MISC); + + if (en) + hci_writel(ufs, misc | HCI_CORECLK_CTRL_EN, HCI_MISC); + else + hci_writel(ufs, misc & ~HCI_CORECLK_CTRL_EN, HCI_MISC); +} + +static void exynos_ufs_ctrl_clkstop(struct exynos_ufs *ufs, bool en) +{ + u32 ctrl = hci_readl(ufs, HCI_CLKSTOP_CTRL); + u32 misc = hci_readl(ufs, HCI_MISC); + + if (en) { + hci_writel(ufs, misc | CLK_CTRL_EN_MASK, HCI_MISC); + hci_writel(ufs, ctrl | CLK_STOP_MASK, HCI_CLKSTOP_CTRL); + } else { + hci_writel(ufs, ctrl & ~CLK_STOP_MASK, HCI_CLKSTOP_CTRL); + hci_writel(ufs, misc & ~CLK_CTRL_EN_MASK, HCI_MISC); + } +} + +static int exynos_ufs_get_clk_info(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct list_head *head = &hba->clk_list_head; + struct ufs_clk_info *clki; + u32 pclk_rate; + u32 f_min, f_max; + u8 div = 0; + int ret = 0; + + if (!head || list_empty(head)) + goto out; + + list_for_each_entry(clki, head, list) { + if (!IS_ERR(clki->clk)) { + if (!strcmp(clki->name, "core_clk")) + ufs->clk_hci_core = clki->clk; + else if (!strcmp(clki->name, "sclk_unipro_main")) + ufs->clk_unipro_main = clki->clk; + } + } + + if (!ufs->clk_hci_core || !ufs->clk_unipro_main) { + dev_err(hba->dev, "failed to get clk info\n"); + ret = -EINVAL; + goto out; + } + + ufs->mclk_rate = clk_get_rate(ufs->clk_unipro_main); + pclk_rate = clk_get_rate(ufs->clk_hci_core); + f_min = ufs->pclk_avail_min; + f_max = ufs->pclk_avail_max; + + if (ufs->opts & EXYNOS_UFS_OPT_HAS_APB_CLK_CTRL) { + do { + pclk_rate /= (div + 1); + + if (pclk_rate <= f_max) + break; + div++; + } while (pclk_rate >= f_min); + } + + if (unlikely(pclk_rate < f_min || pclk_rate > f_max)) { + dev_err(hba->dev, "not available pclk range %d\n", pclk_rate); + ret = -EINVAL; + goto out; + } + + ufs->pclk_rate = pclk_rate; + ufs->pclk_div = div; + +out: + return ret; +} + +static void exynos_ufs_set_unipro_pclk_div(struct exynos_ufs *ufs) +{ + if (ufs->opts & EXYNOS_UFS_OPT_HAS_APB_CLK_CTRL) { + u32 val; + + val = hci_readl(ufs, HCI_UNIPRO_APB_CLK_CTRL); + hci_writel(ufs, UNIPRO_APB_CLK(val, ufs->pclk_div), + HCI_UNIPRO_APB_CLK_CTRL); + } +} + +static void exynos_ufs_set_pwm_clk_div(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + + ufshcd_dme_set(hba, + UIC_ARG_MIB(CMN_PWM_CLK_CTRL), attr->cmn_pwm_clk_ctrl); +} + +static void exynos_ufs_calc_pwm_clk_div(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + const unsigned int div = 30, mult = 20; + const unsigned long pwm_min = 3 * 1000 * 1000; + const unsigned long pwm_max = 9 * 1000 * 1000; + const int divs[] = {32, 16, 8, 4}; + unsigned long clk = 0, _clk, clk_period; + int i = 0, clk_idx = -1; + + clk_period = UNIPRO_PCLK_PERIOD(ufs); + for (i = 0; i < ARRAY_SIZE(divs); i++) { + _clk = NSEC_PER_SEC * mult / (clk_period * divs[i] * div); + if (_clk >= pwm_min && _clk <= pwm_max) { + if (_clk > clk) { + clk_idx = i; + clk = _clk; + } + } + } + + if (clk_idx == -1) { + ufshcd_dme_get(hba, UIC_ARG_MIB(CMN_PWM_CLK_CTRL), &clk_idx); + dev_err(hba->dev, + "failed to decide pwm clock divider, will not change\n"); + } + + attr->cmn_pwm_clk_ctrl = clk_idx & PWM_CLK_CTRL_MASK; +} + +long exynos_ufs_calc_time_cntr(struct exynos_ufs *ufs, long period) +{ + const int precise = 10; + long pclk_rate = ufs->pclk_rate; + long clk_period, fraction; + + clk_period = UNIPRO_PCLK_PERIOD(ufs); + fraction = ((NSEC_PER_SEC % pclk_rate) * precise) / pclk_rate; + + return (period * precise) / ((clk_period * precise) + fraction); +} + +static void exynos_ufs_specify_phy_time_attr(struct exynos_ufs *ufs) +{ + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + struct ufs_phy_time_cfg *t_cfg = &ufs->t_cfg; + + t_cfg->tx_linereset_p = + exynos_ufs_calc_time_cntr(ufs, attr->tx_dif_p_nsec); + t_cfg->tx_linereset_n = + exynos_ufs_calc_time_cntr(ufs, attr->tx_dif_n_nsec); + t_cfg->tx_high_z_cnt = + exynos_ufs_calc_time_cntr(ufs, attr->tx_high_z_cnt_nsec); + t_cfg->tx_base_n_val = + exynos_ufs_calc_time_cntr(ufs, attr->tx_base_unit_nsec); + t_cfg->tx_gran_n_val = + exynos_ufs_calc_time_cntr(ufs, attr->tx_gran_unit_nsec); + t_cfg->tx_sleep_cnt = + exynos_ufs_calc_time_cntr(ufs, attr->tx_sleep_cnt); + + t_cfg->rx_linereset = + exynos_ufs_calc_time_cntr(ufs, attr->rx_dif_p_nsec); + t_cfg->rx_hibern8_wait = + exynos_ufs_calc_time_cntr(ufs, attr->rx_hibern8_wait_nsec); + t_cfg->rx_base_n_val = + exynos_ufs_calc_time_cntr(ufs, attr->rx_base_unit_nsec); + t_cfg->rx_gran_n_val = + exynos_ufs_calc_time_cntr(ufs, attr->rx_gran_unit_nsec); + t_cfg->rx_sleep_cnt = + exynos_ufs_calc_time_cntr(ufs, attr->rx_sleep_cnt); + t_cfg->rx_stall_cnt = + exynos_ufs_calc_time_cntr(ufs, attr->rx_stall_cnt); +} + +static void exynos_ufs_config_phy_time_attr(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct ufs_phy_time_cfg *t_cfg = &ufs->t_cfg; + int i; + + exynos_ufs_set_pwm_clk_div(ufs); + + exynos_ufs_enable_ov_tm(hba); + + for_each_ufs_rx_lane(ufs, i) { + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_FILLER_ENABLE, i), + ufs->drv_data->uic_attr->rx_filler_enable); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_LINERESET_VAL, i), + RX_LINERESET(t_cfg->rx_linereset)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_BASE_NVAL_07_00, i), + RX_BASE_NVAL_L(t_cfg->rx_base_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_BASE_NVAL_15_08, i), + RX_BASE_NVAL_H(t_cfg->rx_base_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_GRAN_NVAL_07_00, i), + RX_GRAN_NVAL_L(t_cfg->rx_gran_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_GRAN_NVAL_10_08, i), + RX_GRAN_NVAL_H(t_cfg->rx_gran_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_OV_SLEEP_CNT_TIMER, i), + RX_OV_SLEEP_CNT(t_cfg->rx_sleep_cnt)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(RX_OV_STALL_CNT_TIMER, i), + RX_OV_STALL_CNT(t_cfg->rx_stall_cnt)); + } + + for_each_ufs_tx_lane(ufs, i) { + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_LINERESET_P_VAL, i), + TX_LINERESET_P(t_cfg->tx_linereset_p)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_HIGH_Z_CNT_07_00, i), + TX_HIGH_Z_CNT_L(t_cfg->tx_high_z_cnt)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_HIGH_Z_CNT_11_08, i), + TX_HIGH_Z_CNT_H(t_cfg->tx_high_z_cnt)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_BASE_NVAL_07_00, i), + TX_BASE_NVAL_L(t_cfg->tx_base_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_BASE_NVAL_15_08, i), + TX_BASE_NVAL_H(t_cfg->tx_base_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_GRAN_NVAL_07_00, i), + TX_GRAN_NVAL_L(t_cfg->tx_gran_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_GRAN_NVAL_10_08, i), + TX_GRAN_NVAL_H(t_cfg->tx_gran_n_val)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_OV_SLEEP_CNT_TIMER, i), + TX_OV_H8_ENTER_EN | + TX_OV_SLEEP_CNT(t_cfg->tx_sleep_cnt)); + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(TX_MIN_ACTIVATETIME, i), + ufs->drv_data->uic_attr->tx_min_activatetime); + } + + exynos_ufs_disable_ov_tm(hba); +} + +static void exynos_ufs_config_phy_cap_attr(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + int i; + + exynos_ufs_enable_ov_tm(hba); + + for_each_ufs_rx_lane(ufs, i) { + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G1_SYNC_LENGTH_CAP, i), + attr->rx_hs_g1_sync_len_cap); + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G2_SYNC_LENGTH_CAP, i), + attr->rx_hs_g2_sync_len_cap); + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G3_SYNC_LENGTH_CAP, i), + attr->rx_hs_g3_sync_len_cap); + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G1_PREP_LENGTH_CAP, i), + attr->rx_hs_g1_prep_sync_len_cap); + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G2_PREP_LENGTH_CAP, i), + attr->rx_hs_g2_prep_sync_len_cap); + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HS_G3_PREP_LENGTH_CAP, i), + attr->rx_hs_g3_prep_sync_len_cap); + } + + if (attr->rx_adv_fine_gran_sup_en == 0) { + for_each_ufs_rx_lane(ufs, i) { + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_ADV_GRANULARITY_CAP, i), 0); + + if (attr->rx_min_actv_time_cap) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_MIN_ACTIVATETIME_CAP, + i), attr->rx_min_actv_time_cap); + + if (attr->rx_hibern8_time_cap) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_HIBERN8TIME_CAP, i), + attr->rx_hibern8_time_cap); + } + } else if (attr->rx_adv_fine_gran_sup_en == 1) { + for_each_ufs_rx_lane(ufs, i) { + if (attr->rx_adv_fine_gran_step) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_ADV_GRANULARITY_CAP, + i), RX_ADV_FINE_GRAN_STEP( + attr->rx_adv_fine_gran_step)); + + if (attr->rx_adv_min_actv_time_cap) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL( + RX_ADV_MIN_ACTIVATETIME_CAP, i), + attr->rx_adv_min_actv_time_cap); + + if (attr->rx_adv_hibern8_time_cap) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_ADV_HIBERN8TIME_CAP, + i), + attr->rx_adv_hibern8_time_cap); + } + } + + exynos_ufs_disable_ov_tm(hba); +} + +static void exynos_ufs_establish_connt(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + enum { + DEV_ID = 0x00, + PEER_DEV_ID = 0x01, + PEER_CPORT_ID = 0x00, + TRAFFIC_CLASS = 0x00, + }; + + /* allow cport attributes to be set */ + ufshcd_dme_set(hba, UIC_ARG_MIB(T_CONNECTIONSTATE), CPORT_IDLE); + + /* local unipro attributes */ + ufshcd_dme_set(hba, UIC_ARG_MIB(N_DEVICEID), DEV_ID); + ufshcd_dme_set(hba, UIC_ARG_MIB(N_DEVICEID_VALID), TRUE); + ufshcd_dme_set(hba, UIC_ARG_MIB(T_PEERDEVICEID), PEER_DEV_ID); + ufshcd_dme_set(hba, UIC_ARG_MIB(T_PEERCPORTID), PEER_CPORT_ID); + ufshcd_dme_set(hba, UIC_ARG_MIB(T_CPORTFLAGS), CPORT_DEF_FLAGS); + ufshcd_dme_set(hba, UIC_ARG_MIB(T_TRAFFICCLASS), TRAFFIC_CLASS); + ufshcd_dme_set(hba, UIC_ARG_MIB(T_CONNECTIONSTATE), CPORT_CONNECTED); +} + +static void exynos_ufs_config_smu(struct exynos_ufs *ufs) +{ + u32 reg, val; + + exynos_ufs_disable_auto_ctrl_hcc_save(ufs, &val); + + /* make encryption disabled by default */ + reg = ufsp_readl(ufs, UFSPRSECURITY); + ufsp_writel(ufs, reg | NSSMU, UFSPRSECURITY); + ufsp_writel(ufs, 0x0, UFSPSBEGIN0); + ufsp_writel(ufs, 0xffffffff, UFSPSEND0); + ufsp_writel(ufs, 0xff, UFSPSLUN0); + ufsp_writel(ufs, 0xf1, UFSPSCTRL0); + + exynos_ufs_auto_ctrl_hcc_restore(ufs, &val); +} + +static void exynos_ufs_config_sync_pattern_mask(struct exynos_ufs *ufs, + struct ufs_pa_layer_attr *pwr) +{ + struct ufs_hba *hba = ufs->hba; + u8 g = max_t(u32, pwr->gear_rx, pwr->gear_tx); + u32 mask, sync_len; + enum { + SYNC_LEN_G1 = 80 * 1000, /* 80us */ + SYNC_LEN_G2 = 40 * 1000, /* 44us */ + SYNC_LEN_G3 = 20 * 1000, /* 20us */ + }; + int i; + + if (g == 1) + sync_len = SYNC_LEN_G1; + else if (g == 2) + sync_len = SYNC_LEN_G2; + else if (g == 3) + sync_len = SYNC_LEN_G3; + else + return; + + mask = exynos_ufs_calc_time_cntr(ufs, sync_len); + mask = (mask >> 8) & 0xff; + + exynos_ufs_enable_ov_tm(hba); + + for_each_ufs_rx_lane(ufs, i) + ufshcd_dme_set(hba, + UIC_ARG_MIB_SEL(RX_SYNC_MASK_LENGTH, i), mask); + + exynos_ufs_disable_ov_tm(hba); +} + +static int exynos_ufs_pre_pwr_mode(struct ufs_hba *hba, + struct ufs_pa_layer_attr *dev_max_params, + struct ufs_pa_layer_attr *dev_req_params) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + struct phy *generic_phy = ufs->phy; + struct ufs_dev_params ufs_exynos_cap; + int ret; + + if (!dev_req_params) { + pr_err("%s: incoming dev_req_params is NULL\n", __func__); + ret = -EINVAL; + goto out; + } + + + ufs_exynos_cap.tx_lanes = UFS_EXYNOS_LIMIT_NUM_LANES_TX; + ufs_exynos_cap.rx_lanes = UFS_EXYNOS_LIMIT_NUM_LANES_RX; + ufs_exynos_cap.hs_rx_gear = UFS_EXYNOS_LIMIT_HSGEAR_RX; + ufs_exynos_cap.hs_tx_gear = UFS_EXYNOS_LIMIT_HSGEAR_TX; + ufs_exynos_cap.pwm_rx_gear = UFS_EXYNOS_LIMIT_PWMGEAR_RX; + ufs_exynos_cap.pwm_tx_gear = UFS_EXYNOS_LIMIT_PWMGEAR_TX; + ufs_exynos_cap.rx_pwr_pwm = UFS_EXYNOS_LIMIT_RX_PWR_PWM; + ufs_exynos_cap.tx_pwr_pwm = UFS_EXYNOS_LIMIT_TX_PWR_PWM; + ufs_exynos_cap.rx_pwr_hs = UFS_EXYNOS_LIMIT_RX_PWR_HS; + ufs_exynos_cap.tx_pwr_hs = UFS_EXYNOS_LIMIT_TX_PWR_HS; + ufs_exynos_cap.hs_rate = UFS_EXYNOS_LIMIT_HS_RATE; + ufs_exynos_cap.desired_working_mode = + UFS_EXYNOS_LIMIT_DESIRED_MODE; + + ret = ufshcd_get_pwr_dev_param(&ufs_exynos_cap, + dev_max_params, dev_req_params); + if (ret) { + pr_err("%s: failed to determine capabilities\n", __func__); + goto out; + } + + if (ufs->drv_data->pre_pwr_change) + ufs->drv_data->pre_pwr_change(ufs, dev_req_params); + + if (ufshcd_is_hs_mode(dev_req_params)) { + exynos_ufs_config_sync_pattern_mask(ufs, dev_req_params); + + switch (dev_req_params->hs_rate) { + case PA_HS_MODE_A: + case PA_HS_MODE_B: + phy_calibrate(generic_phy); + break; + } + } + + return 0; +out: + return ret; +} + +#define PWR_MODE_STR_LEN 64 +static int exynos_ufs_post_pwr_mode(struct ufs_hba *hba, + struct ufs_pa_layer_attr *pwr_max, + struct ufs_pa_layer_attr *pwr_req) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + struct phy *generic_phy = ufs->phy; + int gear = max_t(u32, pwr_req->gear_rx, pwr_req->gear_tx); + int lanes = max_t(u32, pwr_req->lane_rx, pwr_req->lane_tx); + char pwr_str[PWR_MODE_STR_LEN] = ""; + + /* let default be PWM Gear 1, Lane 1 */ + if (!gear) + gear = 1; + + if (!lanes) + lanes = 1; + + if (ufs->drv_data->post_pwr_change) + ufs->drv_data->post_pwr_change(ufs, pwr_req); + + if ((ufshcd_is_hs_mode(pwr_req))) { + switch (pwr_req->hs_rate) { + case PA_HS_MODE_A: + case PA_HS_MODE_B: + phy_calibrate(generic_phy); + break; + } + + snprintf(pwr_str, PWR_MODE_STR_LEN, "%s series_%s G_%d L_%d", + "FAST", pwr_req->hs_rate == PA_HS_MODE_A ? "A" : "B", + gear, lanes); + } else { + snprintf(pwr_str, PWR_MODE_STR_LEN, "%s G_%d L_%d", + "SLOW", gear, lanes); + } + + dev_info(hba->dev, "Power mode changed to : %s\n", pwr_str); + + return 0; +} + +static void exynos_ufs_specify_nexus_t_xfer_req(struct ufs_hba *hba, + int tag, bool op) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + u32 type; + + type = hci_readl(ufs, HCI_UTRL_NEXUS_TYPE); + + if (op) + hci_writel(ufs, type | (1 << tag), HCI_UTRL_NEXUS_TYPE); + else + hci_writel(ufs, type & ~(1 << tag), HCI_UTRL_NEXUS_TYPE); +} + +static void exynos_ufs_specify_nexus_t_tm_req(struct ufs_hba *hba, + int tag, u8 func) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + u32 type; + + type = hci_readl(ufs, HCI_UTMRL_NEXUS_TYPE); + + switch (func) { + case UFS_ABORT_TASK: + case UFS_QUERY_TASK: + hci_writel(ufs, type | (1 << tag), HCI_UTMRL_NEXUS_TYPE); + break; + case UFS_ABORT_TASK_SET: + case UFS_CLEAR_TASK_SET: + case UFS_LOGICAL_RESET: + case UFS_QUERY_TASK_SET: + hci_writel(ufs, type & ~(1 << tag), HCI_UTMRL_NEXUS_TYPE); + break; + } +} + +static int exynos_ufs_phy_init(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + struct phy *generic_phy = ufs->phy; + int ret = 0; + + if (ufs->avail_ln_rx == 0 || ufs->avail_ln_tx == 0) { + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_AVAILRXDATALANES), + &ufs->avail_ln_rx); + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_AVAILTXDATALANES), + &ufs->avail_ln_tx); + WARN(ufs->avail_ln_rx != ufs->avail_ln_tx, + "available data lane is not equal(rx:%d, tx:%d)\n", + ufs->avail_ln_rx, ufs->avail_ln_tx); + } + + phy_set_bus_width(generic_phy, ufs->avail_ln_rx); + ret = phy_init(generic_phy); + if (ret) { + dev_err(hba->dev, "%s: phy init failed, ret = %d\n", + __func__, ret); + goto out_exit_phy; + } + + return 0; + +out_exit_phy: + phy_exit(generic_phy); + + return ret; +} + +static void exynos_ufs_config_unipro(struct exynos_ufs *ufs) +{ + struct ufs_hba *hba = ufs->hba; + + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_CLK_PERIOD), + DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate)); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TXTRAILINGCLOCKS), + ufs->drv_data->uic_attr->tx_trailingclks); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_OPTION_SUITE), + ufs->drv_data->uic_attr->pa_dbg_option_suite); +} + +static void exynos_ufs_config_intr(struct exynos_ufs *ufs, u32 errs, u8 index) +{ + switch (index) { + case UNIPRO_L1_5: + hci_writel(ufs, DFES_ERR_EN | errs, HCI_ERR_EN_PA_LAYER); + break; + case UNIPRO_L2: + hci_writel(ufs, DFES_ERR_EN | errs, HCI_ERR_EN_DL_LAYER); + break; + case UNIPRO_L3: + hci_writel(ufs, DFES_ERR_EN | errs, HCI_ERR_EN_N_LAYER); + break; + case UNIPRO_L4: + hci_writel(ufs, DFES_ERR_EN | errs, HCI_ERR_EN_T_LAYER); + break; + case UNIPRO_DME: + hci_writel(ufs, DFES_ERR_EN | errs, HCI_ERR_EN_DME_LAYER); + break; + } +} + +static int exynos_ufs_pre_link(struct ufs_hba *hba) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + + /* hci */ + exynos_ufs_config_intr(ufs, DFES_DEF_L2_ERRS, UNIPRO_L2); + exynos_ufs_config_intr(ufs, DFES_DEF_L3_ERRS, UNIPRO_L3); + exynos_ufs_config_intr(ufs, DFES_DEF_L4_ERRS, UNIPRO_L4); + exynos_ufs_set_unipro_pclk_div(ufs); + + /* unipro */ + exynos_ufs_config_unipro(ufs); + + /* m-phy */ + exynos_ufs_phy_init(ufs); + exynos_ufs_config_phy_time_attr(ufs); + exynos_ufs_config_phy_cap_attr(ufs); + + if (ufs->drv_data->pre_link) + ufs->drv_data->pre_link(ufs); + + return 0; +} + +static void exynos_ufs_fit_aggr_timeout(struct exynos_ufs *ufs) +{ + u32 val; + + val = exynos_ufs_calc_time_cntr(ufs, IATOVAL_NSEC / CNTR_DIV_VAL); + hci_writel(ufs, val & CNT_VAL_1US_MASK, HCI_1US_TO_CNT_VAL); +} + +static int exynos_ufs_post_link(struct ufs_hba *hba) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + struct phy *generic_phy = ufs->phy; + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + + exynos_ufs_establish_connt(ufs); + exynos_ufs_fit_aggr_timeout(ufs); + + hci_writel(ufs, 0xa, HCI_DATA_REORDER); + hci_writel(ufs, PRDT_SET_SIZE(12), HCI_TXPRDT_ENTRY_SIZE); + hci_writel(ufs, PRDT_SET_SIZE(12), HCI_RXPRDT_ENTRY_SIZE); + hci_writel(ufs, (1 << hba->nutrs) - 1, HCI_UTRL_NEXUS_TYPE); + hci_writel(ufs, (1 << hba->nutmrs) - 1, HCI_UTMRL_NEXUS_TYPE); + hci_writel(ufs, 0xf, HCI_AXIDMA_RWDATA_BURST_LEN); + + if (ufs->opts & EXYNOS_UFS_OPT_SKIP_CONNECTION_ESTAB) + ufshcd_dme_set(hba, + UIC_ARG_MIB(T_DBG_SKIP_INIT_HIBERN8_EXIT), TRUE); + + if (attr->pa_granularity) { + exynos_ufs_enable_dbg_mode(hba); + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_GRANULARITY), + attr->pa_granularity); + exynos_ufs_disable_dbg_mode(hba); + + if (attr->pa_tactivate) + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TACTIVATE), + attr->pa_tactivate); + if (attr->pa_hibern8time && + !(ufs->opts & EXYNOS_UFS_OPT_USE_SW_HIBERN8_TIMER)) + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_HIBERN8TIME), + attr->pa_hibern8time); + } + + if (ufs->opts & EXYNOS_UFS_OPT_USE_SW_HIBERN8_TIMER) { + if (!attr->pa_granularity) + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_GRANULARITY), + &attr->pa_granularity); + if (!attr->pa_hibern8time) + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_HIBERN8TIME), + &attr->pa_hibern8time); + /* + * not wait for HIBERN8 time to exit hibernation + */ + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_HIBERN8TIME), 0); + + if (attr->pa_granularity < 1 || attr->pa_granularity > 6) { + /* Valid range for granularity: 1 ~ 6 */ + dev_warn(hba->dev, + "%s: pa_granularty %d is invalid, assuming backwards compatibility\n", + __func__, + attr->pa_granularity); + attr->pa_granularity = 6; + } + } + + phy_calibrate(generic_phy); + + if (ufs->drv_data->post_link) + ufs->drv_data->post_link(ufs); + + return 0; +} + +static int exynos_ufs_parse_dt(struct device *dev, struct exynos_ufs *ufs) +{ + struct device_node *np = dev->of_node; + struct exynos_ufs_drv_data *drv_data = &exynos_ufs_drvs; + struct exynos_ufs_uic_attr *attr; + int ret = 0; + + while (drv_data->compatible) { + if (of_device_is_compatible(np, drv_data->compatible)) { + ufs->drv_data = drv_data; + break; + } + drv_data++; + } + + if (ufs->drv_data && ufs->drv_data->uic_attr) { + attr = ufs->drv_data->uic_attr; + } else { + dev_err(dev, "failed to get uic attributes\n"); + ret = -EINVAL; + goto out; + } + + ufs->pclk_avail_min = PCLK_AVAIL_MIN; + ufs->pclk_avail_max = PCLK_AVAIL_MAX; + + attr->rx_adv_fine_gran_sup_en = RX_ADV_FINE_GRAN_SUP_EN; + attr->rx_adv_fine_gran_step = RX_ADV_FINE_GRAN_STEP_VAL; + attr->rx_adv_min_actv_time_cap = RX_ADV_MIN_ACTV_TIME_CAP; + attr->pa_granularity = PA_GRANULARITY_VAL; + attr->pa_tactivate = PA_TACTIVATE_VAL; + attr->pa_hibern8time = PA_HIBERN8TIME_VAL; + +out: + return ret; +} + +static int exynos_ufs_init(struct ufs_hba *hba) +{ + struct device *dev = hba->dev; + struct platform_device *pdev = to_platform_device(dev); + struct exynos_ufs *ufs; + struct resource *res; + int ret; + + ufs = devm_kzalloc(dev, sizeof(*ufs), GFP_KERNEL); + if (!ufs) + return -ENOMEM; + + /* exynos-specific hci */ + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vs_hci"); + ufs->reg_hci = devm_ioremap_resource(dev, res); + if (!ufs->reg_hci) { + dev_err(dev, "cannot ioremap for hci vendor register\n"); + return -ENOMEM; + } + + /* unipro */ + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "unipro"); + ufs->reg_unipro = devm_ioremap_resource(dev, res); + if (!ufs->reg_unipro) { + dev_err(dev, "cannot ioremap for unipro register\n"); + return -ENOMEM; + } + + /* ufs protector */ + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ufsp"); + ufs->reg_ufsp = devm_ioremap_resource(dev, res); + if (!ufs->reg_ufsp) { + dev_err(dev, "cannot ioremap for ufs protector register\n"); + return -ENOMEM; + } + + ret = exynos_ufs_parse_dt(dev, ufs); + if (ret) { + dev_err(dev, "failed to get dt info.\n"); + goto out; + } + + ufs->phy = devm_phy_get(dev, "ufs-phy"); + if (IS_ERR(ufs->phy)) { + ret = PTR_ERR(ufs->phy); + dev_err(dev, "failed to get ufs-phy\n"); + goto out; + } + + ret = phy_power_on(ufs->phy); + if (ret) + goto phy_off; + + ufs->hba = hba; + ufs->opts = ufs->drv_data->opts; + ufs->rx_sel_idx = PA_MAXDATALANES; + if (ufs->opts & EXYNOS_UFS_OPT_BROKEN_RX_SEL_IDX) + ufs->rx_sel_idx = 0; + hba->priv = (void *)ufs; + hba->quirks = ufs->drv_data->quirks; + if (ufs->drv_data->drv_init) { + ret = ufs->drv_data->drv_init(dev, ufs); + if (ret) { + dev_err(dev, "failed to init drv-data\n"); + goto out; + } + } + + ret = exynos_ufs_get_clk_info(ufs); + if (ret) + goto out; + exynos_ufs_specify_phy_time_attr(ufs); + exynos_ufs_config_smu(ufs); + return 0; + +phy_off: + phy_power_off(ufs->phy); +out: + hba->priv = NULL; + return ret; +} + +static int exynos_ufs_host_reset(struct ufs_hba *hba) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + unsigned long timeout = jiffies + msecs_to_jiffies(1); + u32 val; + int ret = 0; + + exynos_ufs_disable_auto_ctrl_hcc_save(ufs, &val); + + hci_writel(ufs, UFS_SW_RST_MASK, HCI_SW_RST); + + do { + if (!(hci_readl(ufs, HCI_SW_RST) & UFS_SW_RST_MASK)) + goto out; + } while (time_before(jiffies, timeout)); + + dev_err(hba->dev, "timeout host sw-reset\n"); + ret = -ETIMEDOUT; + +out: + exynos_ufs_auto_ctrl_hcc_restore(ufs, &val); + return ret; +} + +static void exynos_ufs_dev_hw_reset(struct ufs_hba *hba) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + + hci_writel(ufs, 0 << 0, HCI_GPIO_OUT); + udelay(5); + hci_writel(ufs, 1 << 0, HCI_GPIO_OUT); +} + +static void exynos_ufs_pre_hibern8(struct ufs_hba *hba, u8 enter) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + struct exynos_ufs_uic_attr *attr = ufs->drv_data->uic_attr; + + if (!enter) { + if (ufs->opts & EXYNOS_UFS_OPT_BROKEN_AUTO_CLK_CTRL) + exynos_ufs_disable_auto_ctrl_hcc(ufs); + exynos_ufs_ungate_clks(ufs); + + if (ufs->opts & EXYNOS_UFS_OPT_USE_SW_HIBERN8_TIMER) { + const unsigned int granularity_tbl[] = { + 1, 4, 8, 16, 32, 100 + }; + int h8_time = attr->pa_hibern8time * + granularity_tbl[attr->pa_granularity - 1]; + unsigned long us; + s64 delta; + + do { + delta = h8_time - ktime_us_delta(ktime_get(), + ufs->entry_hibern8_t); + if (delta <= 0) + break; + + us = min_t(s64, delta, USEC_PER_MSEC); + if (us >= 10) + usleep_range(us, us + 10); + } while (1); + } + } +} + +static void exynos_ufs_post_hibern8(struct ufs_hba *hba, u8 enter) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + + if (!enter) { + u32 cur_mode = 0; + u32 pwrmode; + + if (ufshcd_is_hs_mode(&ufs->dev_req_params)) + pwrmode = FAST_MODE; + else + pwrmode = SLOW_MODE; + + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_PWRMODE), &cur_mode); + if (cur_mode != (pwrmode << 4 | pwrmode)) { + dev_warn(hba->dev, "%s: power mode change\n", __func__); + hba->pwr_info.pwr_rx = (cur_mode >> 4) & 0xf; + hba->pwr_info.pwr_tx = cur_mode & 0xf; + ufshcd_config_pwr_mode(hba, &hba->max_pwr_info.info); + } + + if (!(ufs->opts & EXYNOS_UFS_OPT_SKIP_CONNECTION_ESTAB)) + exynos_ufs_establish_connt(ufs); + } else { + ufs->entry_hibern8_t = ktime_get(); + exynos_ufs_gate_clks(ufs); + if (ufs->opts & EXYNOS_UFS_OPT_BROKEN_AUTO_CLK_CTRL) + exynos_ufs_enable_auto_ctrl_hcc(ufs); + } +} + +static int exynos_ufs_hce_enable_notify(struct ufs_hba *hba, + enum ufs_notify_change_status status) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + int ret = 0; + + switch (status) { + case PRE_CHANGE: + ret = exynos_ufs_host_reset(hba); + if (ret) + return ret; + exynos_ufs_dev_hw_reset(hba); + break; + case POST_CHANGE: + exynos_ufs_calc_pwm_clk_div(ufs); + if (!(ufs->opts & EXYNOS_UFS_OPT_BROKEN_AUTO_CLK_CTRL)) + exynos_ufs_enable_auto_ctrl_hcc(ufs); + break; + } + + return ret; +} + +static int exynos_ufs_link_startup_notify(struct ufs_hba *hba, + enum ufs_notify_change_status status) +{ + int ret = 0; + + switch (status) { + case PRE_CHANGE: + ret = exynos_ufs_pre_link(hba); + break; + case POST_CHANGE: + ret = exynos_ufs_post_link(hba); + break; + } + + return ret; +} + +static int exynos_ufs_pwr_change_notify(struct ufs_hba *hba, + enum ufs_notify_change_status status, + struct ufs_pa_layer_attr *dev_max_params, + struct ufs_pa_layer_attr *dev_req_params) +{ + int ret = 0; + + switch (status) { + case PRE_CHANGE: + ret = exynos_ufs_pre_pwr_mode(hba, dev_max_params, + dev_req_params); + break; + case POST_CHANGE: + ret = exynos_ufs_post_pwr_mode(hba, NULL, dev_req_params); + break; + } + + return ret; +} + +static void exynos_ufs_hibern8_notify(struct ufs_hba *hba, + enum uic_cmd_dme enter, + enum ufs_notify_change_status notify) +{ + switch ((u8)notify) { + case PRE_CHANGE: + exynos_ufs_pre_hibern8(hba, enter); + break; + case POST_CHANGE: + exynos_ufs_post_hibern8(hba, enter); + break; + } +} + +static int exynos_ufs_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + + if (!ufshcd_is_link_active(hba)) + phy_power_off(ufs->phy); + + return 0; +} + +static int exynos_ufs_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op) +{ + struct exynos_ufs *ufs = ufshcd_get_variant(hba); + + if (!ufshcd_is_link_active(hba)) + phy_power_on(ufs->phy); + + exynos_ufs_config_smu(ufs); + + return 0; +} + +static struct ufs_hba_variant_ops ufs_hba_exynos_ops = { + .name = "exynos_ufs", + .init = exynos_ufs_init, + .hce_enable_notify = exynos_ufs_hce_enable_notify, + .link_startup_notify = exynos_ufs_link_startup_notify, + .pwr_change_notify = exynos_ufs_pwr_change_notify, + .setup_xfer_req = exynos_ufs_specify_nexus_t_xfer_req, + .setup_task_mgmt = exynos_ufs_specify_nexus_t_tm_req, + .hibern8_notify = exynos_ufs_hibern8_notify, + .suspend = exynos_ufs_suspend, + .resume = exynos_ufs_resume, +}; + +static int exynos_ufs_probe(struct platform_device *pdev) +{ + int err; + struct device *dev = &pdev->dev; + + err = ufshcd_pltfrm_init(pdev, &ufs_hba_exynos_ops); + if (err) + dev_err(dev, "ufshcd_pltfrm_init() failed %d\n", err); + + return err; +} + +static int exynos_ufs_remove(struct platform_device *pdev) +{ + struct ufs_hba *hba = platform_get_drvdata(pdev); + + pm_runtime_get_sync(&(pdev)->dev); + ufshcd_remove(hba); + return 0; +} + +struct exynos_ufs_drv_data exynos_ufs_drvs = { + + .compatible = "samsung,exynos7-ufs", + .uic_attr = &exynos7_uic_attr, + .quirks = UFSHCD_QUIRK_PRDT_BYTE_GRAN | + UFSHCI_QUIRK_BROKEN_REQ_LIST_CLR | + UFSHCI_QUIRK_BROKEN_HCE | + UFSHCI_QUIRK_SKIP_RESET_INTR_AGGR | + UFSHCD_QUIRK_BROKEN_OCS_FATAL_ERROR, + .opts = EXYNOS_UFS_OPT_HAS_APB_CLK_CTRL | + EXYNOS_UFS_OPT_BROKEN_AUTO_CLK_CTRL | + EXYNOS_UFS_OPT_BROKEN_RX_SEL_IDX | + EXYNOS_UFS_OPT_SKIP_CONNECTION_ESTAB | + EXYNOS_UFS_OPT_USE_SW_HIBERN8_TIMER, + .drv_init = exynos7_ufs_drv_init, + .pre_link = exynos7_ufs_pre_link, + .post_link = exynos7_ufs_post_link, + .pre_pwr_change = exynos7_ufs_pre_pwr_change, + .post_pwr_change = exynos7_ufs_post_pwr_change, +}; + +static const struct of_device_id exynos_ufs_of_match[] = { + { .compatible = "samsung,exynos7-ufs", + .data = &exynos_ufs_drvs }, + {}, +}; + +static const struct dev_pm_ops exynos_ufs_pm_ops = { + .suspend = ufshcd_pltfrm_suspend, + .resume = ufshcd_pltfrm_resume, + .runtime_suspend = ufshcd_pltfrm_runtime_suspend, + .runtime_resume = ufshcd_pltfrm_runtime_resume, + .runtime_idle = ufshcd_pltfrm_runtime_idle, +}; + +static struct platform_driver exynos_ufs_pltform = { + .probe = exynos_ufs_probe, + .remove = exynos_ufs_remove, + .shutdown = ufshcd_pltfrm_shutdown, + .driver = { + .name = "exynos-ufshc", + .pm = &exynos_ufs_pm_ops, + .of_match_table = of_match_ptr(exynos_ufs_of_match), + }, +}; +module_platform_driver(exynos_ufs_pltform); diff --git a/drivers/scsi/ufs/ufs-exynos.h b/drivers/scsi/ufs/ufs-exynos.h new file mode 100644 index 000000000000..76d6e39efb2f --- /dev/null +++ b/drivers/scsi/ufs/ufs-exynos.h @@ -0,0 +1,287 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * UFS Host Controller driver for Exynos specific extensions + * + * Copyright (C) 2014-2015 Samsung Electronics Co., Ltd. + * + */ + +#ifndef _UFS_EXYNOS_H_ +#define _UFS_EXYNOS_H_ + +/* + * UNIPRO registers + */ +#define UNIPRO_DBG_FORCE_DME_CTRL_STATE 0x150 + +/* + * MIBs for PA debug registers + */ +#define PA_DBG_CLK_PERIOD 0x9514 +#define PA_DBG_TXPHY_CFGUPDT 0x9518 +#define PA_DBG_RXPHY_CFGUPDT 0x9519 +#define PA_DBG_MODE 0x9529 +#define PA_DBG_SKIP_RESET_PHY 0x9539 +#define PA_DBG_OV_TM 0x9540 +#define PA_DBG_SKIP_LINE_RESET 0x9541 +#define PA_DBG_LINE_RESET_REQ 0x9543 +#define PA_DBG_OPTION_SUITE 0x9564 +#define PA_DBG_OPTION_SUITE_DYN 0x9565 + +/* + * MIBs for Transport Layer debug registers + */ +#define T_DBG_SKIP_INIT_HIBERN8_EXIT 0xc001 + +/* + * Exynos MPHY attributes + */ +#define TX_LINERESET_N_VAL 0x0277 +#define TX_LINERESET_N(v) (((v) >> 10) & 0xFF) +#define TX_LINERESET_P_VAL 0x027D +#define TX_LINERESET_P(v) (((v) >> 12) & 0xFF) +#define TX_OV_SLEEP_CNT_TIMER 0x028E +#define TX_OV_H8_ENTER_EN (1 << 7) +#define TX_OV_SLEEP_CNT(v) (((v) >> 5) & 0x7F) +#define TX_HIGH_Z_CNT_11_08 0x028C +#define TX_HIGH_Z_CNT_H(v) (((v) >> 8) & 0xF) +#define TX_HIGH_Z_CNT_07_00 0x028D +#define TX_HIGH_Z_CNT_L(v) ((v) & 0xFF) +#define TX_BASE_NVAL_07_00 0x0293 +#define TX_BASE_NVAL_L(v) ((v) & 0xFF) +#define TX_BASE_NVAL_15_08 0x0294 +#define TX_BASE_NVAL_H(v) (((v) >> 8) & 0xFF) +#define TX_GRAN_NVAL_07_00 0x0295 +#define TX_GRAN_NVAL_L(v) ((v) & 0xFF) +#define TX_GRAN_NVAL_10_08 0x0296 +#define TX_GRAN_NVAL_H(v) (((v) >> 8) & 0x3) + +#define RX_FILLER_ENABLE 0x0316 +#define RX_FILLER_EN (1 << 1) +#define RX_LINERESET_VAL 0x0317 +#define RX_LINERESET(v) (((v) >> 12) & 0xFF) +#define RX_LCC_IGNORE 0x0318 +#define RX_SYNC_MASK_LENGTH 0x0321 +#define RX_HIBERN8_WAIT_VAL_BIT_20_16 0x0331 +#define RX_HIBERN8_WAIT_VAL_BIT_15_08 0x0332 +#define RX_HIBERN8_WAIT_VAL_BIT_07_00 0x0333 +#define RX_OV_SLEEP_CNT_TIMER 0x0340 +#define RX_OV_SLEEP_CNT(v) (((v) >> 6) & 0x1F) +#define RX_OV_STALL_CNT_TIMER 0x0341 +#define RX_OV_STALL_CNT(v) (((v) >> 4) & 0xFF) +#define RX_BASE_NVAL_07_00 0x0355 +#define RX_BASE_NVAL_L(v) ((v) & 0xFF) +#define RX_BASE_NVAL_15_08 0x0354 +#define RX_BASE_NVAL_H(v) (((v) >> 8) & 0xFF) +#define RX_GRAN_NVAL_07_00 0x0353 +#define RX_GRAN_NVAL_L(v) ((v) & 0xFF) +#define RX_GRAN_NVAL_10_08 0x0352 +#define RX_GRAN_NVAL_H(v) (((v) >> 8) & 0x3) + +#define CMN_PWM_CLK_CTRL 0x0402 +#define PWM_CLK_CTRL_MASK 0x3 + +#define IATOVAL_NSEC 20000 /* unit: ns */ +#define UNIPRO_PCLK_PERIOD(ufs) (NSEC_PER_SEC / ufs->pclk_rate) + +struct exynos_ufs; + +/* vendor specific pre-defined parameters */ +#define SLOW 1 +#define FAST 2 + +#define UFS_EXYNOS_LIMIT_NUM_LANES_RX 2 +#define UFS_EXYNOS_LIMIT_NUM_LANES_TX 2 +#define UFS_EXYNOS_LIMIT_HSGEAR_RX UFS_HS_G3 +#define UFS_EXYNOS_LIMIT_HSGEAR_TX UFS_HS_G3 +#define UFS_EXYNOS_LIMIT_PWMGEAR_RX UFS_PWM_G4 +#define UFS_EXYNOS_LIMIT_PWMGEAR_TX UFS_PWM_G4 +#define UFS_EXYNOS_LIMIT_RX_PWR_PWM SLOW_MODE +#define UFS_EXYNOS_LIMIT_TX_PWR_PWM SLOW_MODE +#define UFS_EXYNOS_LIMIT_RX_PWR_HS FAST_MODE +#define UFS_EXYNOS_LIMIT_TX_PWR_HS FAST_MODE +#define UFS_EXYNOS_LIMIT_HS_RATE PA_HS_MODE_B +#define UFS_EXYNOS_LIMIT_DESIRED_MODE FAST + +#define RX_ADV_FINE_GRAN_SUP_EN 0x1 +#define RX_ADV_FINE_GRAN_STEP_VAL 0x3 +#define RX_ADV_MIN_ACTV_TIME_CAP 0x9 + +#define PA_GRANULARITY_VAL 0x6 +#define PA_TACTIVATE_VAL 0x3 +#define PA_HIBERN8TIME_VAL 0x20 + +#define PCLK_AVAIL_MIN 70000000 +#define PCLK_AVAIL_MAX 133000000 + +struct exynos_ufs_uic_attr { + /* TX Attributes */ + unsigned int tx_trailingclks; + unsigned int tx_dif_p_nsec; + unsigned int tx_dif_n_nsec; + unsigned int tx_high_z_cnt_nsec; + unsigned int tx_base_unit_nsec; + unsigned int tx_gran_unit_nsec; + unsigned int tx_sleep_cnt; + unsigned int tx_min_activatetime; + /* RX Attributes */ + unsigned int rx_filler_enable; + unsigned int rx_dif_p_nsec; + unsigned int rx_hibern8_wait_nsec; + unsigned int rx_base_unit_nsec; + unsigned int rx_gran_unit_nsec; + unsigned int rx_sleep_cnt; + unsigned int rx_stall_cnt; + unsigned int rx_hs_g1_sync_len_cap; + unsigned int rx_hs_g2_sync_len_cap; + unsigned int rx_hs_g3_sync_len_cap; + unsigned int rx_hs_g1_prep_sync_len_cap; + unsigned int rx_hs_g2_prep_sync_len_cap; + unsigned int rx_hs_g3_prep_sync_len_cap; + /* Common Attributes */ + unsigned int cmn_pwm_clk_ctrl; + /* Internal Attributes */ + unsigned int pa_dbg_option_suite; + /* Changeable Attributes */ + unsigned int rx_adv_fine_gran_sup_en; + unsigned int rx_adv_fine_gran_step; + unsigned int rx_min_actv_time_cap; + unsigned int rx_hibern8_time_cap; + unsigned int rx_adv_min_actv_time_cap; + unsigned int rx_adv_hibern8_time_cap; + unsigned int pa_granularity; + unsigned int pa_tactivate; + unsigned int pa_hibern8time; +}; + +struct exynos_ufs_drv_data { + char *compatible; + struct exynos_ufs_uic_attr *uic_attr; + unsigned int quirks; + unsigned int opts; + /* SoC's specific operations */ + int (*drv_init)(struct device *dev, struct exynos_ufs *ufs); + int (*pre_link)(struct exynos_ufs *ufs); + int (*post_link)(struct exynos_ufs *ufs); + int (*pre_pwr_change)(struct exynos_ufs *ufs, + struct ufs_pa_layer_attr *pwr); + int (*post_pwr_change)(struct exynos_ufs *ufs, + struct ufs_pa_layer_attr *pwr); +}; + +struct ufs_phy_time_cfg { + u32 tx_linereset_p; + u32 tx_linereset_n; + u32 tx_high_z_cnt; + u32 tx_base_n_val; + u32 tx_gran_n_val; + u32 tx_sleep_cnt; + u32 rx_linereset; + u32 rx_hibern8_wait; + u32 rx_base_n_val; + u32 rx_gran_n_val; + u32 rx_sleep_cnt; + u32 rx_stall_cnt; +}; + +struct exynos_ufs { + struct ufs_hba *hba; + struct phy *phy; + void __iomem *reg_hci; + void __iomem *reg_unipro; + void __iomem *reg_ufsp; + struct clk *clk_hci_core; + struct clk *clk_unipro_main; + struct clk *clk_apb; + u32 pclk_rate; + u32 pclk_div; + u32 pclk_avail_min; + u32 pclk_avail_max; + u32 mclk_rate; + int avail_ln_rx; + int avail_ln_tx; + int rx_sel_idx; + struct ufs_pa_layer_attr dev_req_params; + struct ufs_phy_time_cfg t_cfg; + ktime_t entry_hibern8_t; + struct exynos_ufs_drv_data *drv_data; + + u32 opts; +#define EXYNOS_UFS_OPT_HAS_APB_CLK_CTRL BIT(0) +#define EXYNOS_UFS_OPT_SKIP_CONNECTION_ESTAB BIT(1) +#define EXYNOS_UFS_OPT_BROKEN_AUTO_CLK_CTRL BIT(2) +#define EXYNOS_UFS_OPT_BROKEN_RX_SEL_IDX BIT(3) +#define EXYNOS_UFS_OPT_USE_SW_HIBERN8_TIMER BIT(4) +}; + +#define for_each_ufs_rx_lane(ufs, i) \ + for (i = (ufs)->rx_sel_idx; \ + i < (ufs)->rx_sel_idx + (ufs)->avail_ln_rx; i++) +#define for_each_ufs_tx_lane(ufs, i) \ + for (i = 0; i < (ufs)->avail_ln_tx; i++) + +#define EXYNOS_UFS_MMIO_FUNC(name) \ +static inline void name##_writel(struct exynos_ufs *ufs, u32 val, u32 reg)\ +{ \ + writel(val, ufs->reg_##name + reg); \ +} \ + \ +static inline u32 name##_readl(struct exynos_ufs *ufs, u32 reg) \ +{ \ + return readl(ufs->reg_##name + reg); \ +} + +EXYNOS_UFS_MMIO_FUNC(hci); +EXYNOS_UFS_MMIO_FUNC(unipro); +EXYNOS_UFS_MMIO_FUNC(ufsp); +#undef EXYNOS_UFS_MMIO_FUNC + +long exynos_ufs_calc_time_cntr(struct exynos_ufs *, long); + +static inline void exynos_ufs_enable_ov_tm(struct ufs_hba *hba) +{ + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_OV_TM), TRUE); +} + +static inline void exynos_ufs_disable_ov_tm(struct ufs_hba *hba) +{ + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_OV_TM), FALSE); +} + +static inline void exynos_ufs_enable_dbg_mode(struct ufs_hba *hba) +{ + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_MODE), TRUE); +} + +static inline void exynos_ufs_disable_dbg_mode(struct ufs_hba *hba) +{ + ufshcd_dme_set(hba, UIC_ARG_MIB(PA_DBG_MODE), FALSE); +} + +struct exynos_ufs_drv_data exynos_ufs_drvs; + +struct exynos_ufs_uic_attr exynos7_uic_attr = { + .tx_trailingclks = 0x10, + .tx_dif_p_nsec = 3000000, /* unit: ns */ + .tx_dif_n_nsec = 1000000, /* unit: ns */ + .tx_high_z_cnt_nsec = 20000, /* unit: ns */ + .tx_base_unit_nsec = 100000, /* unit: ns */ + .tx_gran_unit_nsec = 4000, /* unit: ns */ + .tx_sleep_cnt = 1000, /* unit: ns */ + .tx_min_activatetime = 0xa, + .rx_filler_enable = 0x2, + .rx_dif_p_nsec = 1000000, /* unit: ns */ + .rx_hibern8_wait_nsec = 4000000, /* unit: ns */ + .rx_base_unit_nsec = 100000, /* unit: ns */ + .rx_gran_unit_nsec = 4000, /* unit: ns */ + .rx_sleep_cnt = 1280, /* unit: ns */ + .rx_stall_cnt = 320, /* unit: ns */ + .rx_hs_g1_sync_len_cap = SYNC_LEN_COARSE(0xf), + .rx_hs_g2_sync_len_cap = SYNC_LEN_COARSE(0xf), + .rx_hs_g3_sync_len_cap = SYNC_LEN_COARSE(0xf), + .rx_hs_g1_prep_sync_len_cap = PREP_LEN(0xf), + .rx_hs_g2_prep_sync_len_cap = PREP_LEN(0xf), + .rx_hs_g3_prep_sync_len_cap = PREP_LEN(0xf), + .pa_dbg_option_suite = 0x30103, +}; +#endif /* _UFS_EXYNOS_H_ */ diff --git a/drivers/scsi/ufs/unipro.h b/drivers/scsi/ufs/unipro.h index 766d551df3fc..4ee64782fd48 100644 --- a/drivers/scsi/ufs/unipro.h +++ b/drivers/scsi/ufs/unipro.h @@ -64,8 +64,25 @@ #define CFGRXOVR4 0x00E9 #define RXSQCTRL 0x00B5 #define CFGRXOVR6 0x00BF +#define RX_HS_G1_SYNC_LENGTH_CAP 0x008B +#define RX_HS_G1_PREP_LENGTH_CAP 0x008C +#define RX_HS_G2_SYNC_LENGTH_CAP 0x0094 +#define RX_HS_G3_SYNC_LENGTH_CAP 0x0095 +#define RX_HS_G2_PREP_LENGTH_CAP 0x0096 +#define RX_HS_G3_PREP_LENGTH_CAP 0x0097 +#define RX_ADV_GRANULARITY_CAP 0x0098 +#define RX_MIN_ACTIVATETIME_CAP 0x008F +#define RX_HIBERN8TIME_CAP 0x0092 +#define RX_ADV_HIBERN8TIME_CAP 0x0099 +#define RX_ADV_MIN_ACTIVATETIME_CAP 0x009A + #define is_mphy_tx_attr(attr) (attr < RX_MODE) +#define RX_ADV_FINE_GRAN_STEP(x) ((((x) & 0x3) << 1) | 0x1) +#define SYNC_LEN_FINE(x) ((x) & 0x3F) +#define SYNC_LEN_COARSE(x) ((1 << 6) | ((x) & 0x3F)) +#define PREP_LEN(x) ((x) & 0xF) + #define RX_MIN_ACTIVATETIME_UNIT_US 100 #define HIBERN8TIME_UNIT_US 100 @@ -124,6 +141,7 @@ #define PA_PACPREQEOBTIMEOUT 0x1591 #define PA_HIBERN8TIME 0x15A7 #define PA_LOCALVERINFO 0x15A9 +#define PA_GRANULARITY 0x15AA #define PA_TACTIVATE 0x15A8 #define PA_PACPFRAMECOUNT 0x15C0 #define PA_PACPERRORCOUNT 0x15C1 @@ -291,4 +309,19 @@ enum { TRUE, }; +/* CPort setting */ +#define E2EFC_ON (1 << 0) +#define E2EFC_OFF (0 << 0) +#define CSD_N_ON (0 << 1) +#define CSD_N_OFF (1 << 1) +#define CSV_N_ON (0 << 2) +#define CSV_N_OFF (1 << 2) +#define CPORT_DEF_FLAGS (CSV_N_OFF | CSD_N_OFF | E2EFC_OFF) + +/* CPort connection state */ +enum { + CPORT_IDLE = 0, + CPORT_CONNECTED, +}; + #endif /* _UNIPRO_H_ */ -- 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 50ACAC433DF for ; Thu, 28 May 2020 01:36:38 +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 C8EE4207BC for ; Thu, 28 May 2020 01:36:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Hukl3Y+G"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="EkQupREW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C8EE4207BC Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=samsung.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:References:MIME-Version: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=TAa3Krk7t6N9ZBbMnU3yw1dxXH6ph9sglO4J/3KrBKc=; b=Hukl3Y+GGyBy/x WMkZQ8r4MMAB/tGJTEpG8V3gv0I5WIg9v6e6nofTMdUos5uPbogU1jD6p0Bl2YKZiGAx1lhl6NRnr cxRSsiTmKhr0ggkyyHiLRbgT/xDEdu2hDzkR+OpVTyvRQf829s9I1j7XoUhXJ/rMp62LwwaoDOkkO B9fBbZLFeQHAToV8U/4UowUsybfh1qflsGc4Zdz+Mw3b4Yaw72aA4/JlrENdrhGeyswC2klkBrypG KL1n+kNuuQrEexXCu4ksp3OeTc18Vm3KNwRLpCuO/H131K7WQY1qrbMMOn7MaFO3iFghuiYo4tQOz LE1i21mUFI/exXiwXGHQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1je7TI-0008Ke-Qz; Thu, 28 May 2020 01:36:36 +0000 Received: from mailout3.samsung.com ([203.254.224.33]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1je7Pa-0003NI-98 for linux-arm-kernel@lists.infradead.org; Thu, 28 May 2020 01:32:56 +0000 Received: from epcas5p4.samsung.com (unknown [182.195.41.42]) by mailout3.samsung.com (KnoxPortal) with ESMTP id 20200528013243epoutp03fa7df12de0c1a3849e53fd5b8b901d16~TDSkkhuRV0284902849epoutp03Z for ; Thu, 28 May 2020 01:32:43 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout3.samsung.com 20200528013243epoutp03fa7df12de0c1a3849e53fd5b8b901d16~TDSkkhuRV0284902849epoutp03Z DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1590629563; bh=PDMiJY/am/0bhgJyyZVMhqytx7f8PSCHMTlceMBvDDU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EkQupREWZZsZTh6A0Zsaet337cGcFGDg42iHmgB5hX5vCs6gwdHAS1SvxqeZCXc9v Xel8g3L/nMXzFEZ9q61KMIfXWljmSSoPPQib3ux8MCeRzdjIlyJCMCnyPpVdrWuVOX oVVigE7qMOnROOuMLPAaU0LIa5oFFCc6boP5Mr7I= Received: from epsmges5p2new.samsung.com (unknown [182.195.42.74]) by epcas5p1.samsung.com (KnoxPortal) with ESMTP id 20200528013243epcas5p1a4e0a58b7ed7a9915b91030607b0e5d6~TDSkVUGCX1882918829epcas5p1V; Thu, 28 May 2020 01:32:43 +0000 (GMT) Received: from epcas5p2.samsung.com ( [182.195.41.40]) by epsmges5p2new.samsung.com (Symantec Messaging Gateway) with SMTP id 73.68.09703.BB41FCE5; Thu, 28 May 2020 10:32:43 +0900 (KST) Received: from epsmtrp2.samsung.com (unknown [182.195.40.14]) by epcas5p4.samsung.com (KnoxPortal) with ESMTPA id 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0~TDSj8dFkd2994029940epcas5p4U; Thu, 28 May 2020 01:32:43 +0000 (GMT) Received: from epsmgms1p2.samsung.com (unknown [182.195.42.42]) by epsmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200528013243epsmtrp22f1e8612d450e4afae9efda48913d1fb~TDSj7ivMr2193121931epsmtrp2P; Thu, 28 May 2020 01:32:43 +0000 (GMT) X-AuditID: b6c32a4a-4b5ff700000025e7-fc-5ecf14bb5db6 Received: from epsmtip1.samsung.com ( [182.195.34.30]) by epsmgms1p2.samsung.com (Symantec Messaging Gateway) with SMTP id EF.77.08303.AB41FCE5; Thu, 28 May 2020 10:32:42 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200528013240epsmtip12b2a9f167665fc9fd805b7c77a2c2310~TDSh5ygIt1669416694epsmtip1m; Thu, 28 May 2020 01:32:40 +0000 (GMT) From: Alim Akhtar To: robh@kernel.org Subject: [PATCH v10 09/10] scsi: ufs-exynos: add UFS host support for Exynos SoCs Date: Thu, 28 May 2020 06:46:57 +0530 Message-Id: <20200528011658.71590-10-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200528011658.71590-1-alim.akhtar@samsung.com> MIME-Version: 1.0 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFtrCKsWRmVeSWpSXmKPExsWy7bCmhu5ukfNxBn8miVo8mLeNzeLlz6ts Fp/WL2O1mH/kHKvF+fMb2C1ubjnKYrHp8TVWi8u75rBZzDi/j8mi+/oONovlx/8xWfzfs4Pd YunWm4wOvB6X+3qZPDat6mTz2Lyk3qPl5H4Wj49Pb7F49G1ZxejxeZOcR/uBbqYAjigum5TU nMyy1CJ9uwSujFcbp7EW9E5kruhpe8PewPjxHFMXIyeHhICJxO+lHSxdjFwcQgK7GSVOL73H DOF8YpRYvKgXyvnMKPHk+yJ2mJaNDxugErsYJS7eOw/ltDBJNN19xAZSxSagLXF3+hawJSIC whJHvrUxgtjMAjeYJB6sdOli5OAQFgiWeL1UBCTMIqAqcXJNKwuIzStgK3Fu5y5WiGXyEqs3 HGAGKecEiu+d4ABRIihxcuYTFoiJ8hLNW2eDnSAhcIBDYtf2SVC/uUhM23cf6mhhiVfHt0DZ UhKf3+1lA5kpIZAt0bPLGCJcI7F03jEWCNte4sCVOSwgJcwCmhLrd+lDrOKT6P39hAmik1ei o00IolpVovndVahOaYmJ3d1Qx3tIzP4ziRUSOBMYJXqaV7JOYJSfheSDWUg+mIWwbQEj8ypG ydSC4tz01GLTAqO81HK94sTc4tK8dL3k/NxNjOCEpeW1g/Hhgw96hxiZOBgPMUpwMCuJ8Dqd PR0nxJuSWFmVWpQfX1Sak1p8iFGag0VJnFfpx5k4IYH0xJLU7NTUgtQimCwTB6dUA5ODU0+q luvt+p7jGRLzWEuUtjKeyPo+O+yskXJ642xnWZfYwO+KZvtWvDW+fHuFDndF4vkDMld3BU7c vkpUQdaftS8psf22zIw/k8vkU17Fr6y7U3lNmSVGZEpLWVgXi9fEhzt4D83Jjb5bL35sLu/b lr1fY1qdFX7eC3lu/2oby+Vrh57Lvapmv6qedqbwwsY939/Gyenkyx10XRmkUV4wff8GE+7M K5vLle5vXDxpX63as5lTVx3rajTb2LqoNOWHhK3cjCRmLeXWL+f6U+9Z+7t2leuZ/WbvPGl3 +VoOc9/Uld1HD6xcue5l7wMGXVvzqCZBZtETKk4e74+mXKiUy7K6uYOrS0z2x77FCkosxRmJ hlrMRcWJAGDuF7DHAwAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFupkkeLIzCtJLcpLzFFi42LZdlhJTneXyPk4g64vZhYP5m1js3j58yqb xaf1y1gt5h85x2px/vwGdoubW46yWGx6fI3V4vKuOWwWM87vY7Lovr6DzWL58X9MFv/37GC3 WLr1JqMDr8flvl4mj02rOtk8Ni+p92g5uZ/F4+PTWywefVtWMXp83iTn0X6gmymAI4rLJiU1 J7MstUjfLoEr49XGaawFvROZK3ra3rA3MH48x9TFyMkhIWAisfFhA3MXIxeHkMAORolLf1dB JaQlrm+cwA5hC0us/PecHaKoiUni2e1JbCAJNgFtibvTt4A1iAAVHfnWxghiMws8Y5I49bC0 i5GDQ1ggUOLIc7ASFgFViZNrWllAbF4BW4lzO3exQsyXl1i94QAzSDknUHzvBAeQsJCAjcSE VXsZIcoFJU7OfMICUsIsoC6xfp4QxCJ5ieats5knMArOQlI1C6FqFpKqBYzMqxglUwuKc9Nz iw0LjPJSy/WKE3OLS/PS9ZLzczcxgmNLS2sH455VH/QOMTJxMB5ilOBgVhLhdTp7Ok6INyWx siq1KD++qDQntfgQozQHi5I479dZC+OEBNITS1KzU1MLUotgskwcnFINTGH7Hp/0sV6fX9Cw PCezrXd5yK5P11hTJGNjV585nG5eJS71MuTtJoHnG3zZ3LecDQnka/ppcjKmmHelyasdcd8t 5QXXmT20v3Tt7caLJWcqcnwKN/puZk97yiTNkJf25svikIj3QmeM9T0yw69VeIXmHPjz4O4W eVc+sx8xXD82qgVsvSa8L2ul6qYTfxfcE7h49di6dkP/FA7tv01N0yatru/XErOfmXbnZ4qx XvC9k5+OdF1pexbYWP43Pfxb3fQVR564OP19wHP/w60ca+miZ+fn6u9cHaZVfYj/bfH2mC8+ /R//WwicL1vFn77/wsePoYWTFt1uZv96XCxqgxO7s1RHltxHdqltL3U9/imxFGckGmoxFxUn AgAETKL3HAMAAA== X-CMS-MailID: 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0 X-Msg-Generator: CA CMS-TYPE: 105P X-CMS-RootMailID: 20200528013243epcas5p460a041d543b9acfbaa923f38709740b0 References: <20200528011658.71590-1-alim.akhtar@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200527_183247_008957_495E37B3 X-CRM114-Status: GOOD ( 21.60 ) 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: devicetree@vger.kernel.org, linux-samsung-soc@vger.kernel.org, linux-scsi@vger.kernel.org, martin.petersen@oracle.com, linux-kernel@vger.kernel.org, krzk@kernel.org, kwmad.kim@samsung.com, avri.altman@wdc.com, cang@codeaurora.org, Alim Akhtar , stanley.chu@mediatek.com, 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 VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIEV4eW5vcyBVRlMgaG9zdCBjb250cm9sbGVyIGRyaXZlciwK d2hpY2ggbWFpbmx5IGhhbmRsZXMgdmVuZG9yLXNwZWNpZmljIG9wZXJhdGlvbnMgaW5jbHVkaW5n Cmxpbmsgc3RhcnR1cCwgcG93ZXIgbW9kZSBjaGFuZ2UgYW5kIGhpYmVybmF0aW9uL3VuaGliZXJu YXRpb24uCgpSZXBvcnRlZC1ieToga2J1aWxkIHRlc3Qgcm9ib3QgPGxrcEBpbnRlbC5jb20+ClJl cG9ydGVkLWJ5OiBKdWxpYSBMYXdhbGwgPGp1bGlhLmxhd2FsbEBsaXA2LmZyPgpbcm9ib3Q6IGRy aXZlcnMvc2NzaS91ZnMvdWZzLWV4eW5vcy5jOjkzMTo4LTEwOgogV0FSTklORzogcG9zc2libGUg Y29uZGl0aW9uIHdpdGggbm8gZWZmZWN0IChpZiA9PSBlbHNlKQpdClJldmlld2VkLWJ5OiBLaXdv b25nIEtpbSA8a3dtYWQua2ltQHNhbXN1bmcuY29tPgpSZXZpZXdlZC1ieTogQXZyaSBBbHRtYW4g PGF2cmkuYWx0bWFuQHdkYy5jb20+ClNpZ25lZC1vZmYtYnk6IFNldW5nd29uIEplb24gPGVzc3V1 akBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IEFsaW0gQWtodGFyIDxhbGltLmFraHRhckBzYW1z dW5nLmNvbT4KVGVzdGVkLWJ5OiBQYXdlxYIgQ2htaWVsIDxwYXdlbC5taWtvbGFqLmNobWllbEBn bWFpbC5jb20+Ci0tLQogZHJpdmVycy9zY3NpL3Vmcy9LY29uZmlnICAgICAgfCAgIDEyICsKIGRy aXZlcnMvc2NzaS91ZnMvTWFrZWZpbGUgICAgIHwgICAgMSArCiBkcml2ZXJzL3Njc2kvdWZzL3Vm cy1leHlub3MuYyB8IDEyOTIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2 ZXJzL3Njc2kvdWZzL3Vmcy1leHlub3MuaCB8ICAyODcgKysrKysrKysKIGRyaXZlcnMvc2NzaS91 ZnMvdW5pcHJvLmggICAgIHwgICAzMyArCiA1IGZpbGVzIGNoYW5nZWQsIDE2MjUgaW5zZXJ0aW9u cygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc2NzaS91ZnMvdWZzLWV4eW5vcy5jCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9zY3NpL3Vmcy91ZnMtZXh5bm9zLmgKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3Njc2kvdWZzL0tjb25maWcgYi9kcml2ZXJzL3Njc2kvdWZzL0tjb25maWcK aW5kZXggZTIwMDVhZWRkYzJkLi43ZGE4ODZkM2MzMjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2Nz aS91ZnMvS2NvbmZpZworKysgYi9kcml2ZXJzL3Njc2kvdWZzL0tjb25maWcKQEAgLTE2MCwzICsx NjAsMTUgQEAgY29uZmlnIFNDU0lfVUZTX0JTRwogCiAJICBTZWxlY3QgdGhpcyBpZiB5b3UgbmVl ZCBhIGJzZyBkZXZpY2Ugbm9kZSBmb3IgeW91ciBVRlMgY29udHJvbGxlci4KIAkgIElmIHVuc3Vy ZSwgc2F5IE4uCisKK2NvbmZpZyBTQ1NJX1VGU19FWFlOT1MKKwlib29sICJFWFlOT1Mgc3BlY2lm aWMgaG9va3MgdG8gVUZTIGNvbnRyb2xsZXIgcGxhdGZvcm0gZHJpdmVyIgorCWRlcGVuZHMgb24g U0NTSV9VRlNIQ0RfUExBVEZPUk0gJiYgKEFSQ0hfRVhZTk9TIHx8IENPTVBJTEVfVEVTVCkKKwlz ZWxlY3QgUEhZX1NBTVNVTkdfVUZTCisJaGVscAorCSAgVGhpcyBzZWxlY3RzIHRoZSBFWFlOT1Mg c3BlY2lmaWMgYWRkaXRpb25zIHRvIFVGU0hDRCBwbGF0Zm9ybSBkcml2ZXIuCisJICBVRlMgaG9z dCBvbiBFWFlOT1MgaW5jbHVkZXMgSENJIGFuZCBVTklQUk8gbGF5ZXIsIGFuZCBhc3NvY2lhdGVz IHdpdGgKKwkgIFVGUy1QSFkgZHJpdmVyLgorCisJICBTZWxlY3QgdGhpcyBpZiB5b3UgaGF2ZSBV RlMgaG9zdCBjb250cm9sbGVyIG9uIEVYWU5PUyBjaGlwc2V0LgorCSAgSWYgdW5zdXJlLCBzYXkg Ti4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS91ZnMvTWFrZWZpbGUgYi9kcml2ZXJzL3Njc2kv dWZzL01ha2VmaWxlCmluZGV4IDk0YzZjNWQ3MzM0Yi4uZjBjNWI5NWVjOWNjIDEwMDY0NAotLS0g YS9kcml2ZXJzL3Njc2kvdWZzL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvc2NzaS91ZnMvTWFrZWZp bGUKQEAgLTQsNiArNCw3IEBAIG9iai0kKENPTkZJR19TQ1NJX1VGU19EV0NfVENfUENJKSArPSB0 Yy1kd2MtZzIxMC1wY2kubyB1ZnNoY2QtZHdjLm8gdGMtZHdjLWcyMTAuCiBvYmotJChDT05GSUdf U0NTSV9VRlNfRFdDX1RDX1BMQVRGT1JNKSArPSB0Yy1kd2MtZzIxMC1wbHRmcm0ubyB1ZnNoY2Qt ZHdjLm8gdGMtZHdjLWcyMTAubwogb2JqLSQoQ09ORklHX1NDU0lfVUZTX0NETlNfUExBVEZPUk0p ICs9IGNkbnMtcGx0ZnJtLm8KIG9iai0kKENPTkZJR19TQ1NJX1VGU19RQ09NKSArPSB1ZnMtcWNv bS5vCitvYmotJChDT05GSUdfU0NTSV9VRlNfRVhZTk9TKSArPSB1ZnMtZXh5bm9zLm8KIG9iai0k KENPTkZJR19TQ1NJX1VGU0hDRCkgKz0gdWZzaGNkLWNvcmUubwogdWZzaGNkLWNvcmUteQkJCQkr PSB1ZnNoY2QubyB1ZnMtc3lzZnMubwogdWZzaGNkLWNvcmUtJChDT05GSUdfU0NTSV9VRlNfQlNH KQkrPSB1ZnNfYnNnLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS91ZnMvdWZzLWV4eW5vcy5j IGIvZHJpdmVycy9zY3NpL3Vmcy91ZnMtZXh5bm9zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi40NDBmMmFmODNkOWMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L3Njc2kvdWZzL3Vmcy1leHlub3MuYwpAQCAtMCwwICsxLDEyOTIgQEAKKy8vIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKKy8qCisgKiBVRlMgSG9zdCBDb250cm9sbGVyIGRy aXZlciBmb3IgRXh5bm9zIHNwZWNpZmljIGV4dGVuc2lvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMp IDIwMTQtMjAxNSBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICogQXV0aG9yOiBTZXVu Z3dvbiBKZW9uICA8ZXNzdXVqQGdtYWlsLmNvbT4KKyAqIEF1dGhvcjogQWxpbSBBa2h0YXIgPGFs aW0uYWtodGFyQHNhbXN1bmcuY29tPgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvY2xrLmg+ CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNs dWRlIDxsaW51eC9vZl9hZGRyZXNzLmg+CisjaW5jbHVkZSA8bGludXgvcGh5L3BoeS5oPgorI2lu Y2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorCisjaW5jbHVkZSAidWZzaGNkLmgiCisj aW5jbHVkZSAidWZzaGNkLXBsdGZybS5oIgorI2luY2x1ZGUgInVmc2hjaS5oIgorI2luY2x1ZGUg InVuaXByby5oIgorCisjaW5jbHVkZSAidWZzLWV4eW5vcy5oIgorCisvKgorICogRXh5bm9zJ3Mg VmVuZG9yIHNwZWNpZmljIHJlZ2lzdGVycyBmb3IgVUZTSENJCisgKi8KKyNkZWZpbmUgSENJX1RY UFJEVF9FTlRSWV9TSVpFCTB4MDAKKyNkZWZpbmUgUFJEVF9QUkVGRUNUX0VOCQlCSVQoMzEpCisj ZGVmaW5lIFBSRFRfU0VUX1NJWkUoeCkJKCh4KSAmIDB4MUYpCisjZGVmaW5lIEhDSV9SWFBSRFRf RU5UUllfU0laRQkweDA0CisjZGVmaW5lIEhDSV8xVVNfVE9fQ05UX1ZBTAkweDBDCisjZGVmaW5l IENOVF9WQUxfMVVTX01BU0sJMHgzRkYKKyNkZWZpbmUgSENJX1VUUkxfTkVYVVNfVFlQRQkweDQw CisjZGVmaW5lIEhDSV9VVE1STF9ORVhVU19UWVBFCTB4NDQKKyNkZWZpbmUgSENJX1NXX1JTVAkJ MHg1MAorI2RlZmluZSBVRlNfTElOS19TV19SU1QJCUJJVCgwKQorI2RlZmluZSBVRlNfVU5JUFJP X1NXX1JTVAlCSVQoMSkKKyNkZWZpbmUgVUZTX1NXX1JTVF9NQVNLCQkoVUZTX1VOSVBST19TV19S U1QgfCBVRlNfTElOS19TV19SU1QpCisjZGVmaW5lIEhDSV9EQVRBX1JFT1JERVIJMHg2MAorI2Rl ZmluZSBIQ0lfVU5JUFJPX0FQQl9DTEtfQ1RSTAkweDY4CisjZGVmaW5lIFVOSVBST19BUEJfQ0xL KHYsIHgpCSgoKHYpICYgfjB4RikgfCAoKHgpICYgMHhGKSkKKyNkZWZpbmUgSENJX0FYSURNQV9S V0RBVEFfQlVSU1RfTEVOCTB4NkMKKyNkZWZpbmUgSENJX0dQSU9fT1VUCQkweDcwCisjZGVmaW5l IEhDSV9FUlJfRU5fUEFfTEFZRVIJMHg3OAorI2RlZmluZSBIQ0lfRVJSX0VOX0RMX0xBWUVSCTB4 N0MKKyNkZWZpbmUgSENJX0VSUl9FTl9OX0xBWUVSCTB4ODAKKyNkZWZpbmUgSENJX0VSUl9FTl9U X0xBWUVSCTB4ODQKKyNkZWZpbmUgSENJX0VSUl9FTl9ETUVfTEFZRVIJMHg4OAorI2RlZmluZSBI Q0lfQ0xLU1RPUF9DVFJMCTB4QjAKKyNkZWZpbmUgUkVGQ0xLX1NUT1AJCUJJVCgyKQorI2RlZmlu ZSBVTklQUk9fTUNMS19TVE9QCUJJVCgxKQorI2RlZmluZSBVTklQUk9fUENMS19TVE9QCUJJVCgw KQorI2RlZmluZSBDTEtfU1RPUF9NQVNLCQkoUkVGQ0xLX1NUT1AgfFwKKwkJCQkgVU5JUFJPX01D TEtfU1RPUCB8XAorCQkJCSBVTklQUk9fUENMS19TVE9QKQorI2RlZmluZSBIQ0lfTUlTQwkJMHhC NAorI2RlZmluZSBSRUZDTEtfQ1RSTF9FTgkJQklUKDcpCisjZGVmaW5lIFVOSVBST19QQ0xLX0NU UkxfRU4JQklUKDYpCisjZGVmaW5lIFVOSVBST19NQ0xLX0NUUkxfRU4JQklUKDUpCisjZGVmaW5l IEhDSV9DT1JFQ0xLX0NUUkxfRU4JQklUKDQpCisjZGVmaW5lIENMS19DVFJMX0VOX01BU0sJKFJF RkNMS19DVFJMX0VOIHxcCisJCQkJIFVOSVBST19QQ0xLX0NUUkxfRU4gfFwKKwkJCQkgVU5JUFJP X01DTEtfQ1RSTF9FTikKKy8qIERldmljZSBmYXRhbCBlcnJvciAqLworI2RlZmluZSBERkVTX0VS Ul9FTgkJQklUKDMxKQorI2RlZmluZSBERkVTX0RFRl9MMl9FUlJTCShVSUNfREFUQV9MSU5LX0xB WUVSX0VSUk9SX1JYX0JVRl9PRiB8XAorCQkJCSBVSUNfREFUQV9MSU5LX0xBWUVSX0VSUk9SX1BB X0lOSVQpCisjZGVmaW5lIERGRVNfREVGX0wzX0VSUlMJKFVJQ19ORVRXT1JLX1VOU1VQUE9SVEVE X0hFQURFUl9UWVBFIHxcCisJCQkJIFVJQ19ORVRXT1JLX0JBRF9ERVZJQ0VJRF9FTkMgfFwKKwkJ CQkgVUlDX05FVFdPUktfTEhEUl9UUkFQX1BBQ0tFVF9EUk9QUElORykKKyNkZWZpbmUgREZFU19E RUZfTDRfRVJSUwkoVUlDX1RSQU5TUE9SVF9VTlNVUFBPUlRFRF9IRUFERVJfVFlQRSB8XAorCQkJ CSBVSUNfVFJBTlNQT1JUX1VOS05PV05fQ1BPUlRJRCB8XAorCQkJCSBVSUNfVFJBTlNQT1JUX05P X0NPTk5FQ1RJT05fUlggfFwKKwkJCQkgVUlDX1RSQU5TUE9SVF9CQURfVEMpCisKK2VudW0gewor CVVOSVBST19MMV81ID0gMCwvKiBQSFkgQWRhcHRlciAqLworCVVOSVBST19MMiwJLyogRGF0YSBM aW5rICovCisJVU5JUFJPX0wzLAkvKiBOZXR3b3JrICovCisJVU5JUFJPX0w0LAkvKiBUcmFuc3Bv cnQgKi8KKwlVTklQUk9fRE1FLAkvKiBETUUgKi8KK307CisKKy8qCisgKiBVTklQUk8gcmVnaXN0 ZXJzCisgKi8KKyNkZWZpbmUgVU5JUFJPX0NPTVBfVkVSU0lPTgkJCTB4MDAwCisjZGVmaW5lIFVO SVBST19ETUVfUFdSX1JFUQkJCTB4MDkwCisjZGVmaW5lIFVOSVBST19ETUVfUFdSX1JFUV9QT1dF Uk1PREUJCTB4MDk0CisjZGVmaW5lIFVOSVBST19ETUVfUFdSX1JFUV9MT0NBTEwyVElNRVIwCTB4 MDk4CisjZGVmaW5lIFVOSVBST19ETUVfUFdSX1JFUV9MT0NBTEwyVElNRVIxCTB4MDlDCisjZGVm aW5lIFVOSVBST19ETUVfUFdSX1JFUV9MT0NBTEwyVElNRVIyCTB4MEEwCisjZGVmaW5lIFVOSVBS T19ETUVfUFdSX1JFUV9SRU1PVEVMMlRJTUVSMAkweDBBNAorI2RlZmluZSBVTklQUk9fRE1FX1BX Ul9SRVFfUkVNT1RFTDJUSU1FUjEJMHgwQTgKKyNkZWZpbmUgVU5JUFJPX0RNRV9QV1JfUkVRX1JF TU9URUwyVElNRVIyCTB4MEFDCisKKy8qCisgKiBVRlMgUHJvdGVjdG9yIHJlZ2lzdGVycworICov CisjZGVmaW5lIFVGU1BSU0VDVVJJVFkJMHgwMTAKKyNkZWZpbmUgTlNTTVUJCUJJVCgxNCkKKyNk ZWZpbmUgVUZTUFNCRUdJTjAJMHgyMDAKKyNkZWZpbmUgVUZTUFNFTkQwCTB4MjA0CisjZGVmaW5l IFVGU1BTTFVOMAkweDIwOAorI2RlZmluZSBVRlNQU0NUUkwwCTB4MjBDCisKKyNkZWZpbmUgQ05U Ul9ESVZfVkFMIDQwCisKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfYXV0b19jdHJsX2hjYyhzdHJ1 Y3QgZXh5bm9zX3VmcyAqdWZzLCBib29sIGVuKTsKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfY3Ry bF9jbGtzdG9wKHN0cnVjdCBleHlub3NfdWZzICp1ZnMsIGJvb2wgZW4pOworCitzdGF0aWMgaW5s aW5lIHZvaWQgZXh5bm9zX3Vmc19lbmFibGVfYXV0b19jdHJsX2hjYyhzdHJ1Y3QgZXh5bm9zX3Vm cyAqdWZzKQoreworCWV4eW5vc191ZnNfYXV0b19jdHJsX2hjYyh1ZnMsIHRydWUpOworfQorCitz dGF0aWMgaW5saW5lIHZvaWQgZXh5bm9zX3Vmc19kaXNhYmxlX2F1dG9fY3RybF9oY2Moc3RydWN0 IGV4eW5vc191ZnMgKnVmcykKK3sKKwlleHlub3NfdWZzX2F1dG9fY3RybF9oY2ModWZzLCBmYWxz ZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBleHlub3NfdWZzX2Rpc2FibGVfYXV0b19jdHJs X2hjY19zYXZlKAorCQkJCQlzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLCB1MzIgKnZhbCkKK3sKKwkq dmFsID0gaGNpX3JlYWRsKHVmcywgSENJX01JU0MpOworCWV4eW5vc191ZnNfYXV0b19jdHJsX2hj Yyh1ZnMsIGZhbHNlKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGV4eW5vc191ZnNfYXV0b19j dHJsX2hjY19yZXN0b3JlKAorCQkJCQlzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLCB1MzIgKnZhbCkK K3sKKwloY2lfd3JpdGVsKHVmcywgKnZhbCwgSENJX01JU0MpOworfQorCitzdGF0aWMgaW5saW5l IHZvaWQgZXh5bm9zX3Vmc19nYXRlX2Nsa3Moc3RydWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwll eHlub3NfdWZzX2N0cmxfY2xrc3RvcCh1ZnMsIHRydWUpOworfQorCitzdGF0aWMgaW5saW5lIHZv aWQgZXh5bm9zX3Vmc191bmdhdGVfY2xrcyhzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzKQoreworCWV4 eW5vc191ZnNfY3RybF9jbGtzdG9wKHVmcywgZmFsc2UpOworfQorCitzdGF0aWMgaW50IGV4eW5v czdfdWZzX2Rydl9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGV4eW5vc191ZnMgKnVm cykKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBleHlub3M3X3Vmc19wcmVfbGluayhz dHJ1Y3QgZXh5bm9zX3VmcyAqdWZzKQoreworCXN0cnVjdCB1ZnNfaGJhICpoYmEgPSB1ZnMtPmhi YTsKKwl1MzIgdmFsID0gdWZzLT5kcnZfZGF0YS0+dWljX2F0dHItPnBhX2RiZ19vcHRpb25fc3Vp dGU7CisJaW50IGk7CisKKwlleHlub3NfdWZzX2VuYWJsZV9vdl90bShoYmEpOworCWZvcl9lYWNo X3Vmc190eF9sYW5lKHVmcywgaSkKKwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9T RUwoMHgyOTcsIGkpLCAweDE3KTsKKwlmb3JfZWFjaF91ZnNfcnhfbGFuZSh1ZnMsIGkpIHsKKwkJ dWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHgzNjIsIGkpLCAweGZmKTsKKwkJ dWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHgzNjMsIGkpLCAweDAwKTsKKwl9 CisJZXh5bm9zX3Vmc19kaXNhYmxlX292X3RtKGhiYSk7CisKKwlmb3JfZWFjaF91ZnNfdHhfbGFu ZSh1ZnMsIGkpCisJCXVmc2hjZF9kbWVfc2V0KGhiYSwKKwkJCVVJQ19BUkdfTUlCX1NFTChUWF9I SUJFUk44X0NPTlRST0wsIGkpLCAweDApOworCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19N SUIoUEFfREJHX1RYUEhZX0NGR1VQRFQpLCAweDEpOworCXVkZWxheSgxKTsKKwl1ZnNoY2RfZG1l X3NldChoYmEsIFVJQ19BUkdfTUlCKFBBX0RCR19PUFRJT05fU1VJVEUpLCB2YWwgfCAoMSA8PCAx MikpOworCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoUEFfREJHX1NLSVBfUkVTRVRf UEhZKSwgMHgxKTsKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBBX0RCR19TS0lQ X0xJTkVfUkVTRVQpLCAweDEpOworCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoUEFf REJHX0xJTkVfUkVTRVRfUkVRKSwgMHgxKTsKKwl1ZGVsYXkoMTYwMCk7CisJdWZzaGNkX2RtZV9z ZXQoaGJhLCBVSUNfQVJHX01JQihQQV9EQkdfT1BUSU9OX1NVSVRFKSwgdmFsKTsKKworCXJldHVy biAwOworfQorCitzdGF0aWMgaW50IGV4eW5vczdfdWZzX3Bvc3RfbGluayhzdHJ1Y3QgZXh5bm9z X3VmcyAqdWZzKQoreworCXN0cnVjdCB1ZnNfaGJhICpoYmEgPSB1ZnMtPmhiYTsKKwlpbnQgaTsK KworCWV4eW5vc191ZnNfZW5hYmxlX292X3RtKGhiYSk7CisJZm9yX2VhY2hfdWZzX3R4X2xhbmUo dWZzLCBpKSB7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4MjhiLCBp KSwgMHg4Myk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4MjlhLCBp KSwgMHgwNyk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4Mjc3LCBp KSwKKwkJCVRYX0xJTkVSRVNFVF9OKGV4eW5vc191ZnNfY2FsY190aW1lX2NudHIodWZzLCAyMDAw MDApKSk7CisJfQorCWV4eW5vc191ZnNfZGlzYWJsZV9vdl90bShoYmEpOworCisJZXh5bm9zX3Vm c19lbmFibGVfZGJnX21vZGUoaGJhKTsKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlC KFBBX1NBVkVDT05GSUdUSU1FKSwgMHhiYjgpOworCWV4eW5vc191ZnNfZGlzYWJsZV9kYmdfbW9k ZShoYmEpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZXh5bm9zN191ZnNfcHJlX3B3 cl9jaGFuZ2Uoc3RydWN0IGV4eW5vc191ZnMgKnVmcywKKwkJCQkJCXN0cnVjdCB1ZnNfcGFfbGF5 ZXJfYXR0ciAqcHdyKQoreworCXVuaXByb193cml0ZWwodWZzLCAweDIyLCBVTklQUk9fREJHX0ZP UkNFX0RNRV9DVFJMX1NUQVRFKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGV4eW5v czdfdWZzX3Bvc3RfcHdyX2NoYW5nZShzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLAorCQkJCQkJc3Ry dWN0IHVmc19wYV9sYXllcl9hdHRyICpwd3IpCit7CisJc3RydWN0IHVmc19oYmEgKmhiYSA9IHVm cy0+aGJhOworCWludCBsYW5lcyA9IG1heF90KHUzMiwgcHdyLT5sYW5lX3J4LCBwd3ItPmxhbmVf dHgpOworCisJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQihQQV9EQkdfUlhQSFlfQ0ZH VVBEVCksIDB4MSk7CisKKwlpZiAobGFuZXMgPT0gMSkgeworCQlleHlub3NfdWZzX2VuYWJsZV9k YmdfbW9kZShoYmEpOworCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBBX0NPTk5F Q1RFRFRYREFUQUxBTkVTKSwgMHgxKTsKKwkJZXh5bm9zX3Vmc19kaXNhYmxlX2RiZ19tb2RlKGhi YSk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogZXh5bm9zX3Vmc19hdXRvX2N0cmxf aGNjIC0gSENJIGNvcmUgY2xvY2sgY29udHJvbCBieSBoL3cKKyAqIENvbnRyb2wgc2hvdWxkIGJl IGRpc2FibGVkIGluIHRoZSBiZWxvdyBjYXNlcworICogLSBCZWZvcmUgaG9zdCBjb250cm9sbGVy IFMvVyByZXNldAorICogLSBBY2Nlc3MgdG8gVUZTIHByb3RlY3RvcidzIHJlZ2lzdGVyCisgKi8K K3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfYXV0b19jdHJsX2hjYyhzdHJ1Y3QgZXh5bm9zX3VmcyAq dWZzLCBib29sIGVuKQoreworCXUzMiBtaXNjID0gaGNpX3JlYWRsKHVmcywgSENJX01JU0MpOwor CisJaWYgKGVuKQorCQloY2lfd3JpdGVsKHVmcywgbWlzYyB8IEhDSV9DT1JFQ0xLX0NUUkxfRU4s IEhDSV9NSVNDKTsKKwllbHNlCisJCWhjaV93cml0ZWwodWZzLCBtaXNjICYgfkhDSV9DT1JFQ0xL X0NUUkxfRU4sIEhDSV9NSVNDKTsKK30KKworc3RhdGljIHZvaWQgZXh5bm9zX3Vmc19jdHJsX2Ns a3N0b3Aoc3RydWN0IGV4eW5vc191ZnMgKnVmcywgYm9vbCBlbikKK3sKKwl1MzIgY3RybCA9IGhj aV9yZWFkbCh1ZnMsIEhDSV9DTEtTVE9QX0NUUkwpOworCXUzMiBtaXNjID0gaGNpX3JlYWRsKHVm cywgSENJX01JU0MpOworCisJaWYgKGVuKSB7CisJCWhjaV93cml0ZWwodWZzLCBtaXNjIHwgQ0xL X0NUUkxfRU5fTUFTSywgSENJX01JU0MpOworCQloY2lfd3JpdGVsKHVmcywgY3RybCB8IENMS19T VE9QX01BU0ssIEhDSV9DTEtTVE9QX0NUUkwpOworCX0gZWxzZSB7CisJCWhjaV93cml0ZWwodWZz LCBjdHJsICYgfkNMS19TVE9QX01BU0ssIEhDSV9DTEtTVE9QX0NUUkwpOworCQloY2lfd3JpdGVs KHVmcywgbWlzYyAmIH5DTEtfQ1RSTF9FTl9NQVNLLCBIQ0lfTUlTQyk7CisJfQorfQorCitzdGF0 aWMgaW50IGV4eW5vc191ZnNfZ2V0X2Nsa19pbmZvKHN0cnVjdCBleHlub3NfdWZzICp1ZnMpCit7 CisJc3RydWN0IHVmc19oYmEgKmhiYSA9IHVmcy0+aGJhOworCXN0cnVjdCBsaXN0X2hlYWQgKmhl YWQgPSAmaGJhLT5jbGtfbGlzdF9oZWFkOworCXN0cnVjdCB1ZnNfY2xrX2luZm8gKmNsa2k7CisJ dTMyIHBjbGtfcmF0ZTsKKwl1MzIgZl9taW4sIGZfbWF4OworCXU4IGRpdiA9IDA7CisJaW50IHJl dCA9IDA7CisKKwlpZiAoIWhlYWQgfHwgbGlzdF9lbXB0eShoZWFkKSkKKwkJZ290byBvdXQ7CisK KwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNsa2ksIGhlYWQsIGxpc3QpIHsKKwkJaWYgKCFJU19FUlIo Y2xraS0+Y2xrKSkgeworCQkJaWYgKCFzdHJjbXAoY2xraS0+bmFtZSwgImNvcmVfY2xrIikpCisJ CQkJdWZzLT5jbGtfaGNpX2NvcmUgPSBjbGtpLT5jbGs7CisJCQllbHNlIGlmICghc3RyY21wKGNs a2ktPm5hbWUsICJzY2xrX3VuaXByb19tYWluIikpCisJCQkJdWZzLT5jbGtfdW5pcHJvX21haW4g PSBjbGtpLT5jbGs7CisJCX0KKwl9CisKKwlpZiAoIXVmcy0+Y2xrX2hjaV9jb3JlIHx8ICF1ZnMt PmNsa191bmlwcm9fbWFpbikgeworCQlkZXZfZXJyKGhiYS0+ZGV2LCAiZmFpbGVkIHRvIGdldCBj bGsgaW5mb1xuIik7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKworCXVmcy0+ bWNsa19yYXRlID0gY2xrX2dldF9yYXRlKHVmcy0+Y2xrX3VuaXByb19tYWluKTsKKwlwY2xrX3Jh dGUgPSBjbGtfZ2V0X3JhdGUodWZzLT5jbGtfaGNpX2NvcmUpOworCWZfbWluID0gdWZzLT5wY2xr X2F2YWlsX21pbjsKKwlmX21heCA9IHVmcy0+cGNsa19hdmFpbF9tYXg7CisKKwlpZiAodWZzLT5v cHRzICYgRVhZTk9TX1VGU19PUFRfSEFTX0FQQl9DTEtfQ1RSTCkgeworCQlkbyB7CisJCQlwY2xr X3JhdGUgLz0gKGRpdiArIDEpOworCisJCQlpZiAocGNsa19yYXRlIDw9IGZfbWF4KQorCQkJCWJy ZWFrOworCQkJZGl2Kys7CisJCX0gd2hpbGUgKHBjbGtfcmF0ZSA+PSBmX21pbik7CisJfQorCisJ aWYgKHVubGlrZWx5KHBjbGtfcmF0ZSA8IGZfbWluIHx8IHBjbGtfcmF0ZSA+IGZfbWF4KSkgewor CQlkZXZfZXJyKGhiYS0+ZGV2LCAibm90IGF2YWlsYWJsZSBwY2xrIHJhbmdlICVkXG4iLCBwY2xr X3JhdGUpOworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIG91dDsKKwl9CisKKwl1ZnMtPnBjbGtf cmF0ZSA9IHBjbGtfcmF0ZTsKKwl1ZnMtPnBjbGtfZGl2ID0gZGl2OworCitvdXQ6CisJcmV0dXJu IHJldDsKK30KKworc3RhdGljIHZvaWQgZXh5bm9zX3Vmc19zZXRfdW5pcHJvX3BjbGtfZGl2KHN0 cnVjdCBleHlub3NfdWZzICp1ZnMpCit7CisJaWYgKHVmcy0+b3B0cyAmIEVYWU5PU19VRlNfT1BU X0hBU19BUEJfQ0xLX0NUUkwpIHsKKwkJdTMyIHZhbDsKKworCQl2YWwgPSBoY2lfcmVhZGwodWZz LCBIQ0lfVU5JUFJPX0FQQl9DTEtfQ1RSTCk7CisJCWhjaV93cml0ZWwodWZzLCBVTklQUk9fQVBC X0NMSyh2YWwsIHVmcy0+cGNsa19kaXYpLAorCQkJICAgSENJX1VOSVBST19BUEJfQ0xLX0NUUkwp OworCX0KK30KKworc3RhdGljIHZvaWQgZXh5bm9zX3Vmc19zZXRfcHdtX2Nsa19kaXYoc3RydWN0 IGV4eW5vc191ZnMgKnVmcykKK3sKKwlzdHJ1Y3QgdWZzX2hiYSAqaGJhID0gdWZzLT5oYmE7CisJ c3RydWN0IGV4eW5vc191ZnNfdWljX2F0dHIgKmF0dHIgPSB1ZnMtPmRydl9kYXRhLT51aWNfYXR0 cjsKKworCXVmc2hjZF9kbWVfc2V0KGhiYSwKKwkJVUlDX0FSR19NSUIoQ01OX1BXTV9DTEtfQ1RS TCksIGF0dHItPmNtbl9wd21fY2xrX2N0cmwpOworfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZz X2NhbGNfcHdtX2Nsa19kaXYoc3RydWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwlzdHJ1Y3QgdWZz X2hiYSAqaGJhID0gdWZzLT5oYmE7CisJc3RydWN0IGV4eW5vc191ZnNfdWljX2F0dHIgKmF0dHIg PSB1ZnMtPmRydl9kYXRhLT51aWNfYXR0cjsKKwljb25zdCB1bnNpZ25lZCBpbnQgZGl2ID0gMzAs IG11bHQgPSAyMDsKKwljb25zdCB1bnNpZ25lZCBsb25nIHB3bV9taW4gPSAzICogMTAwMCAqIDEw MDA7CisJY29uc3QgdW5zaWduZWQgbG9uZyBwd21fbWF4ID0gOSAqIDEwMDAgKiAxMDAwOworCWNv bnN0IGludCBkaXZzW10gPSB7MzIsIDE2LCA4LCA0fTsKKwl1bnNpZ25lZCBsb25nIGNsayA9IDAs IF9jbGssIGNsa19wZXJpb2Q7CisJaW50IGkgPSAwLCBjbGtfaWR4ID0gLTE7CisKKwljbGtfcGVy aW9kID0gVU5JUFJPX1BDTEtfUEVSSU9EKHVmcyk7CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJ WkUoZGl2cyk7IGkrKykgeworCQlfY2xrID0gTlNFQ19QRVJfU0VDICogbXVsdCAvIChjbGtfcGVy aW9kICogZGl2c1tpXSAqIGRpdik7CisJCWlmIChfY2xrID49IHB3bV9taW4gJiYgX2NsayA8PSBw d21fbWF4KSB7CisJCQlpZiAoX2NsayA+IGNsaykgeworCQkJCWNsa19pZHggPSBpOworCQkJCWNs ayA9IF9jbGs7CisJCQl9CisJCX0KKwl9CisKKwlpZiAoY2xrX2lkeCA9PSAtMSkgeworCQl1ZnNo Y2RfZG1lX2dldChoYmEsIFVJQ19BUkdfTUlCKENNTl9QV01fQ0xLX0NUUkwpLCAmY2xrX2lkeCk7 CisJCWRldl9lcnIoaGJhLT5kZXYsCisJCQkiZmFpbGVkIHRvIGRlY2lkZSBwd20gY2xvY2sgZGl2 aWRlciwgd2lsbCBub3QgY2hhbmdlXG4iKTsKKwl9CisKKwlhdHRyLT5jbW5fcHdtX2Nsa19jdHJs ID0gY2xrX2lkeCAmIFBXTV9DTEtfQ1RSTF9NQVNLOworfQorCitsb25nIGV4eW5vc191ZnNfY2Fs Y190aW1lX2NudHIoc3RydWN0IGV4eW5vc191ZnMgKnVmcywgbG9uZyBwZXJpb2QpCit7CisJY29u c3QgaW50IHByZWNpc2UgPSAxMDsKKwlsb25nIHBjbGtfcmF0ZSA9IHVmcy0+cGNsa19yYXRlOwor CWxvbmcgY2xrX3BlcmlvZCwgZnJhY3Rpb247CisKKwljbGtfcGVyaW9kID0gVU5JUFJPX1BDTEtf UEVSSU9EKHVmcyk7CisJZnJhY3Rpb24gPSAoKE5TRUNfUEVSX1NFQyAlIHBjbGtfcmF0ZSkgKiBw cmVjaXNlKSAvIHBjbGtfcmF0ZTsKKworCXJldHVybiAocGVyaW9kICogcHJlY2lzZSkgLyAoKGNs a19wZXJpb2QgKiBwcmVjaXNlKSArIGZyYWN0aW9uKTsKK30KKworc3RhdGljIHZvaWQgZXh5bm9z X3Vmc19zcGVjaWZ5X3BoeV90aW1lX2F0dHIoc3RydWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwlz dHJ1Y3QgZXh5bm9zX3Vmc191aWNfYXR0ciAqYXR0ciA9IHVmcy0+ZHJ2X2RhdGEtPnVpY19hdHRy OworCXN0cnVjdCB1ZnNfcGh5X3RpbWVfY2ZnICp0X2NmZyA9ICZ1ZnMtPnRfY2ZnOworCisJdF9j ZmctPnR4X2xpbmVyZXNldF9wID0KKwkJZXh5bm9zX3Vmc19jYWxjX3RpbWVfY250cih1ZnMsIGF0 dHItPnR4X2RpZl9wX25zZWMpOworCXRfY2ZnLT50eF9saW5lcmVzZXRfbiA9CisJCWV4eW5vc191 ZnNfY2FsY190aW1lX2NudHIodWZzLCBhdHRyLT50eF9kaWZfbl9uc2VjKTsKKwl0X2NmZy0+dHhf aGlnaF96X2NudCA9CisJCWV4eW5vc191ZnNfY2FsY190aW1lX2NudHIodWZzLCBhdHRyLT50eF9o aWdoX3pfY250X25zZWMpOworCXRfY2ZnLT50eF9iYXNlX25fdmFsID0KKwkJZXh5bm9zX3Vmc19j YWxjX3RpbWVfY250cih1ZnMsIGF0dHItPnR4X2Jhc2VfdW5pdF9uc2VjKTsKKwl0X2NmZy0+dHhf Z3Jhbl9uX3ZhbCA9CisJCWV4eW5vc191ZnNfY2FsY190aW1lX2NudHIodWZzLCBhdHRyLT50eF9n cmFuX3VuaXRfbnNlYyk7CisJdF9jZmctPnR4X3NsZWVwX2NudCA9CisJCWV4eW5vc191ZnNfY2Fs Y190aW1lX2NudHIodWZzLCBhdHRyLT50eF9zbGVlcF9jbnQpOworCisJdF9jZmctPnJ4X2xpbmVy ZXNldCA9CisJCWV4eW5vc191ZnNfY2FsY190aW1lX2NudHIodWZzLCBhdHRyLT5yeF9kaWZfcF9u c2VjKTsKKwl0X2NmZy0+cnhfaGliZXJuOF93YWl0ID0KKwkJZXh5bm9zX3Vmc19jYWxjX3RpbWVf Y250cih1ZnMsIGF0dHItPnJ4X2hpYmVybjhfd2FpdF9uc2VjKTsKKwl0X2NmZy0+cnhfYmFzZV9u X3ZhbCA9CisJCWV4eW5vc191ZnNfY2FsY190aW1lX2NudHIodWZzLCBhdHRyLT5yeF9iYXNlX3Vu aXRfbnNlYyk7CisJdF9jZmctPnJ4X2dyYW5fbl92YWwgPQorCQlleHlub3NfdWZzX2NhbGNfdGlt ZV9jbnRyKHVmcywgYXR0ci0+cnhfZ3Jhbl91bml0X25zZWMpOworCXRfY2ZnLT5yeF9zbGVlcF9j bnQgPQorCQlleHlub3NfdWZzX2NhbGNfdGltZV9jbnRyKHVmcywgYXR0ci0+cnhfc2xlZXBfY250 KTsKKwl0X2NmZy0+cnhfc3RhbGxfY250ID0KKwkJZXh5bm9zX3Vmc19jYWxjX3RpbWVfY250cih1 ZnMsIGF0dHItPnJ4X3N0YWxsX2NudCk7Cit9CisKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfY29u ZmlnX3BoeV90aW1lX2F0dHIoc3RydWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwlzdHJ1Y3QgdWZz X2hiYSAqaGJhID0gdWZzLT5oYmE7CisJc3RydWN0IHVmc19waHlfdGltZV9jZmcgKnRfY2ZnID0g JnVmcy0+dF9jZmc7CisJaW50IGk7CisKKwlleHlub3NfdWZzX3NldF9wd21fY2xrX2Rpdih1ZnMp OworCisJZXh5bm9zX3Vmc19lbmFibGVfb3ZfdG0oaGJhKTsKKworCWZvcl9lYWNoX3Vmc19yeF9s YW5lKHVmcywgaSkgeworCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCX1NFTChSWF9G SUxMRVJfRU5BQkxFLCBpKSwKKwkJCQl1ZnMtPmRydl9kYXRhLT51aWNfYXR0ci0+cnhfZmlsbGVy X2VuYWJsZSk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKFJYX0xJTkVS RVNFVF9WQUwsIGkpLAorCQkJCVJYX0xJTkVSRVNFVCh0X2NmZy0+cnhfbGluZXJlc2V0KSk7CisJ CXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKFJYX0JBU0VfTlZBTF8wN18wMCwg aSksCisJCQkJUlhfQkFTRV9OVkFMX0wodF9jZmctPnJ4X2Jhc2Vfbl92YWwpKTsKKwkJdWZzaGNk X2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoUlhfQkFTRV9OVkFMXzE1XzA4LCBpKSwKKwkJ CQlSWF9CQVNFX05WQUxfSCh0X2NmZy0+cnhfYmFzZV9uX3ZhbCkpOworCQl1ZnNoY2RfZG1lX3Nl dChoYmEsIFVJQ19BUkdfTUlCX1NFTChSWF9HUkFOX05WQUxfMDdfMDAsIGkpLAorCQkJCVJYX0dS QU5fTlZBTF9MKHRfY2ZnLT5yeF9ncmFuX25fdmFsKSk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwg VUlDX0FSR19NSUJfU0VMKFJYX0dSQU5fTlZBTF8xMF8wOCwgaSksCisJCQkJUlhfR1JBTl9OVkFM X0godF9jZmctPnJ4X2dyYW5fbl92YWwpKTsKKwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJH X01JQl9TRUwoUlhfT1ZfU0xFRVBfQ05UX1RJTUVSLCBpKSwKKwkJCQlSWF9PVl9TTEVFUF9DTlQo dF9jZmctPnJ4X3NsZWVwX2NudCkpOworCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlC X1NFTChSWF9PVl9TVEFMTF9DTlRfVElNRVIsIGkpLAorCQkJCVJYX09WX1NUQUxMX0NOVCh0X2Nm Zy0+cnhfc3RhbGxfY250KSk7CisJfQorCisJZm9yX2VhY2hfdWZzX3R4X2xhbmUodWZzLCBpKSB7 CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKFRYX0xJTkVSRVNFVF9QX1ZB TCwgaSksCisJCQkJVFhfTElORVJFU0VUX1AodF9jZmctPnR4X2xpbmVyZXNldF9wKSk7CisJCXVm c2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKFRYX0hJR0hfWl9DTlRfMDdfMDAsIGkp LAorCQkJCVRYX0hJR0hfWl9DTlRfTCh0X2NmZy0+dHhfaGlnaF96X2NudCkpOworCQl1ZnNoY2Rf ZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCX1NFTChUWF9ISUdIX1pfQ05UXzExXzA4LCBpKSwKKwkJ CQlUWF9ISUdIX1pfQ05UX0godF9jZmctPnR4X2hpZ2hfel9jbnQpKTsKKwkJdWZzaGNkX2RtZV9z ZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoVFhfQkFTRV9OVkFMXzA3XzAwLCBpKSwKKwkJCQlUWF9C QVNFX05WQUxfTCh0X2NmZy0+dHhfYmFzZV9uX3ZhbCkpOworCQl1ZnNoY2RfZG1lX3NldChoYmEs IFVJQ19BUkdfTUlCX1NFTChUWF9CQVNFX05WQUxfMTVfMDgsIGkpLAorCQkJCVRYX0JBU0VfTlZB TF9IKHRfY2ZnLT50eF9iYXNlX25fdmFsKSk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FS R19NSUJfU0VMKFRYX0dSQU5fTlZBTF8wN18wMCwgaSksCisJCQkJVFhfR1JBTl9OVkFMX0wodF9j ZmctPnR4X2dyYW5fbl92YWwpKTsKKwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9T RUwoVFhfR1JBTl9OVkFMXzEwXzA4LCBpKSwKKwkJCQlUWF9HUkFOX05WQUxfSCh0X2NmZy0+dHhf Z3Jhbl9uX3ZhbCkpOworCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCX1NFTChUWF9P Vl9TTEVFUF9DTlRfVElNRVIsIGkpLAorCQkJCVRYX09WX0g4X0VOVEVSX0VOIHwKKwkJCQlUWF9P Vl9TTEVFUF9DTlQodF9jZmctPnR4X3NsZWVwX2NudCkpOworCQl1ZnNoY2RfZG1lX3NldChoYmEs IFVJQ19BUkdfTUlCX1NFTChUWF9NSU5fQUNUSVZBVEVUSU1FLCBpKSwKKwkJCQl1ZnMtPmRydl9k YXRhLT51aWNfYXR0ci0+dHhfbWluX2FjdGl2YXRldGltZSk7CisJfQorCisJZXh5bm9zX3Vmc19k aXNhYmxlX292X3RtKGhiYSk7Cit9CisKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfY29uZmlnX3Bo eV9jYXBfYXR0cihzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzKQoreworCXN0cnVjdCB1ZnNfaGJhICpo YmEgPSB1ZnMtPmhiYTsKKwlzdHJ1Y3QgZXh5bm9zX3Vmc191aWNfYXR0ciAqYXR0ciA9IHVmcy0+ ZHJ2X2RhdGEtPnVpY19hdHRyOworCWludCBpOworCisJZXh5bm9zX3Vmc19lbmFibGVfb3ZfdG0o aGJhKTsKKworCWZvcl9lYWNoX3Vmc19yeF9sYW5lKHVmcywgaSkgeworCQl1ZnNoY2RfZG1lX3Nl dChoYmEsCisJCQkJVUlDX0FSR19NSUJfU0VMKFJYX0hTX0cxX1NZTkNfTEVOR1RIX0NBUCwgaSks CisJCQkJYXR0ci0+cnhfaHNfZzFfc3luY19sZW5fY2FwKTsKKwkJdWZzaGNkX2RtZV9zZXQoaGJh LAorCQkJCVVJQ19BUkdfTUlCX1NFTChSWF9IU19HMl9TWU5DX0xFTkdUSF9DQVAsIGkpLAorCQkJ CWF0dHItPnJ4X2hzX2cyX3N5bmNfbGVuX2NhcCk7CisJCXVmc2hjZF9kbWVfc2V0KGhiYSwKKwkJ CQlVSUNfQVJHX01JQl9TRUwoUlhfSFNfRzNfU1lOQ19MRU5HVEhfQ0FQLCBpKSwKKwkJCQlhdHRy LT5yeF9oc19nM19zeW5jX2xlbl9jYXApOworCQl1ZnNoY2RfZG1lX3NldChoYmEsCisJCQkJVUlD X0FSR19NSUJfU0VMKFJYX0hTX0cxX1BSRVBfTEVOR1RIX0NBUCwgaSksCisJCQkJYXR0ci0+cnhf aHNfZzFfcHJlcF9zeW5jX2xlbl9jYXApOworCQl1ZnNoY2RfZG1lX3NldChoYmEsCisJCQkJVUlD X0FSR19NSUJfU0VMKFJYX0hTX0cyX1BSRVBfTEVOR1RIX0NBUCwgaSksCisJCQkJYXR0ci0+cnhf aHNfZzJfcHJlcF9zeW5jX2xlbl9jYXApOworCQl1ZnNoY2RfZG1lX3NldChoYmEsCisJCQkJVUlD X0FSR19NSUJfU0VMKFJYX0hTX0czX1BSRVBfTEVOR1RIX0NBUCwgaSksCisJCQkJYXR0ci0+cnhf aHNfZzNfcHJlcF9zeW5jX2xlbl9jYXApOworCX0KKworCWlmIChhdHRyLT5yeF9hZHZfZmluZV9n cmFuX3N1cF9lbiA9PSAwKSB7CisJCWZvcl9lYWNoX3Vmc19yeF9sYW5lKHVmcywgaSkgeworCQkJ dWZzaGNkX2RtZV9zZXQoaGJhLAorCQkJCVVJQ19BUkdfTUlCX1NFTChSWF9BRFZfR1JBTlVMQVJJ VFlfQ0FQLCBpKSwgMCk7CisKKwkJCWlmIChhdHRyLT5yeF9taW5fYWN0dl90aW1lX2NhcCkKKwkJ CQl1ZnNoY2RfZG1lX3NldChoYmEsCisJCQkJCVVJQ19BUkdfTUlCX1NFTChSWF9NSU5fQUNUSVZB VEVUSU1FX0NBUCwKKwkJCQkJCWkpLCBhdHRyLT5yeF9taW5fYWN0dl90aW1lX2NhcCk7CisKKwkJ CWlmIChhdHRyLT5yeF9oaWJlcm44X3RpbWVfY2FwKQorCQkJCXVmc2hjZF9kbWVfc2V0KGhiYSwK KwkJCQkJVUlDX0FSR19NSUJfU0VMKFJYX0hJQkVSTjhUSU1FX0NBUCwgaSksCisJCQkJCQlhdHRy LT5yeF9oaWJlcm44X3RpbWVfY2FwKTsKKwkJfQorCX0gZWxzZSBpZiAoYXR0ci0+cnhfYWR2X2Zp bmVfZ3Jhbl9zdXBfZW4gPT0gMSkgeworCQlmb3JfZWFjaF91ZnNfcnhfbGFuZSh1ZnMsIGkpIHsK KwkJCWlmIChhdHRyLT5yeF9hZHZfZmluZV9ncmFuX3N0ZXApCisJCQkJdWZzaGNkX2RtZV9zZXQo aGJhLAorCQkJCQlVSUNfQVJHX01JQl9TRUwoUlhfQURWX0dSQU5VTEFSSVRZX0NBUCwKKwkJCQkJ CWkpLCBSWF9BRFZfRklORV9HUkFOX1NURVAoCisJCQkJCQlhdHRyLT5yeF9hZHZfZmluZV9ncmFu X3N0ZXApKTsKKworCQkJaWYgKGF0dHItPnJ4X2Fkdl9taW5fYWN0dl90aW1lX2NhcCkKKwkJCQl1 ZnNoY2RfZG1lX3NldChoYmEsCisJCQkJCVVJQ19BUkdfTUlCX1NFTCgKKwkJCQkJCVJYX0FEVl9N SU5fQUNUSVZBVEVUSU1FX0NBUCwgaSksCisJCQkJCQlhdHRyLT5yeF9hZHZfbWluX2FjdHZfdGlt ZV9jYXApOworCisJCQlpZiAoYXR0ci0+cnhfYWR2X2hpYmVybjhfdGltZV9jYXApCisJCQkJdWZz aGNkX2RtZV9zZXQoaGJhLAorCQkJCQlVSUNfQVJHX01JQl9TRUwoUlhfQURWX0hJQkVSTjhUSU1F X0NBUCwKKwkJCQkJCWkpLAorCQkJCQkJYXR0ci0+cnhfYWR2X2hpYmVybjhfdGltZV9jYXApOwor CQl9CisJfQorCisJZXh5bm9zX3Vmc19kaXNhYmxlX292X3RtKGhiYSk7Cit9CisKK3N0YXRpYyB2 b2lkIGV4eW5vc191ZnNfZXN0YWJsaXNoX2Nvbm50KHN0cnVjdCBleHlub3NfdWZzICp1ZnMpCit7 CisJc3RydWN0IHVmc19oYmEgKmhiYSA9IHVmcy0+aGJhOworCWVudW0geworCQlERVZfSUQJCT0g MHgwMCwKKwkJUEVFUl9ERVZfSUQJPSAweDAxLAorCQlQRUVSX0NQT1JUX0lECT0gMHgwMCwKKwkJ VFJBRkZJQ19DTEFTUwk9IDB4MDAsCisJfTsKKworCS8qIGFsbG93IGNwb3J0IGF0dHJpYnV0ZXMg dG8gYmUgc2V0ICovCisJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQihUX0NPTk5FQ1RJ T05TVEFURSksIENQT1JUX0lETEUpOworCisJLyogbG9jYWwgdW5pcHJvIGF0dHJpYnV0ZXMgKi8K Kwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKE5fREVWSUNFSUQpLCBERVZfSUQpOwor CXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoTl9ERVZJQ0VJRF9WQUxJRCksIFRSVUUp OworCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoVF9QRUVSREVWSUNFSUQpLCBQRUVS X0RFVl9JRCk7CisJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQihUX1BFRVJDUE9SVElE KSwgUEVFUl9DUE9SVF9JRCk7CisJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQihUX0NQ T1JURkxBR1MpLCBDUE9SVF9ERUZfRkxBR1MpOworCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FS R19NSUIoVF9UUkFGRklDQ0xBU1MpLCBUUkFGRklDX0NMQVNTKTsKKwl1ZnNoY2RfZG1lX3NldCho YmEsIFVJQ19BUkdfTUlCKFRfQ09OTkVDVElPTlNUQVRFKSwgQ1BPUlRfQ09OTkVDVEVEKTsKK30K Kworc3RhdGljIHZvaWQgZXh5bm9zX3Vmc19jb25maWdfc211KHN0cnVjdCBleHlub3NfdWZzICp1 ZnMpCit7CisJdTMyIHJlZywgdmFsOworCisJZXh5bm9zX3Vmc19kaXNhYmxlX2F1dG9fY3RybF9o Y2Nfc2F2ZSh1ZnMsICZ2YWwpOworCisJLyogbWFrZSBlbmNyeXB0aW9uIGRpc2FibGVkIGJ5IGRl ZmF1bHQgKi8KKwlyZWcgPSB1ZnNwX3JlYWRsKHVmcywgVUZTUFJTRUNVUklUWSk7CisJdWZzcF93 cml0ZWwodWZzLCByZWcgfCBOU1NNVSwgVUZTUFJTRUNVUklUWSk7CisJdWZzcF93cml0ZWwodWZz LCAweDAsIFVGU1BTQkVHSU4wKTsKKwl1ZnNwX3dyaXRlbCh1ZnMsIDB4ZmZmZmZmZmYsIFVGU1BT RU5EMCk7CisJdWZzcF93cml0ZWwodWZzLCAweGZmLCBVRlNQU0xVTjApOworCXVmc3Bfd3JpdGVs KHVmcywgMHhmMSwgVUZTUFNDVFJMMCk7CisKKwlleHlub3NfdWZzX2F1dG9fY3RybF9oY2NfcmVz dG9yZSh1ZnMsICZ2YWwpOworfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZzX2NvbmZpZ19zeW5j X3BhdHRlcm5fbWFzayhzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLAorCQkJCQlzdHJ1Y3QgdWZzX3Bh X2xheWVyX2F0dHIgKnB3cikKK3sKKwlzdHJ1Y3QgdWZzX2hiYSAqaGJhID0gdWZzLT5oYmE7CisJ dTggZyA9IG1heF90KHUzMiwgcHdyLT5nZWFyX3J4LCBwd3ItPmdlYXJfdHgpOworCXUzMiBtYXNr LCBzeW5jX2xlbjsKKwllbnVtIHsKKwkJU1lOQ19MRU5fRzEgPSA4MCAqIDEwMDAsIC8qIDgwdXMg Ki8KKwkJU1lOQ19MRU5fRzIgPSA0MCAqIDEwMDAsIC8qIDQ0dXMgKi8KKwkJU1lOQ19MRU5fRzMg PSAyMCAqIDEwMDAsIC8qIDIwdXMgKi8KKwl9OworCWludCBpOworCisJaWYgKGcgPT0gMSkKKwkJ c3luY19sZW4gPSBTWU5DX0xFTl9HMTsKKwllbHNlIGlmIChnID09IDIpCisJCXN5bmNfbGVuID0g U1lOQ19MRU5fRzI7CisJZWxzZSBpZiAoZyA9PSAzKQorCQlzeW5jX2xlbiA9IFNZTkNfTEVOX0cz OworCWVsc2UKKwkJcmV0dXJuOworCisJbWFzayA9IGV4eW5vc191ZnNfY2FsY190aW1lX2NudHIo dWZzLCBzeW5jX2xlbik7CisJbWFzayA9IChtYXNrID4+IDgpICYgMHhmZjsKKworCWV4eW5vc191 ZnNfZW5hYmxlX292X3RtKGhiYSk7CisKKwlmb3JfZWFjaF91ZnNfcnhfbGFuZSh1ZnMsIGkpCisJ CXVmc2hjZF9kbWVfc2V0KGhiYSwKKwkJCVVJQ19BUkdfTUlCX1NFTChSWF9TWU5DX01BU0tfTEVO R1RILCBpKSwgbWFzayk7CisKKwlleHlub3NfdWZzX2Rpc2FibGVfb3ZfdG0oaGJhKTsKK30KKwor c3RhdGljIGludCBleHlub3NfdWZzX3ByZV9wd3JfbW9kZShzdHJ1Y3QgdWZzX2hiYSAqaGJhLAor CQkJCXN0cnVjdCB1ZnNfcGFfbGF5ZXJfYXR0ciAqZGV2X21heF9wYXJhbXMsCisJCQkJc3RydWN0 IHVmc19wYV9sYXllcl9hdHRyICpkZXZfcmVxX3BhcmFtcykKK3sKKwlzdHJ1Y3QgZXh5bm9zX3Vm cyAqdWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisJc3RydWN0IHBoeSAqZ2VuZXJpY19w aHkgPSB1ZnMtPnBoeTsKKwlzdHJ1Y3QgdWZzX2Rldl9wYXJhbXMgdWZzX2V4eW5vc19jYXA7CisJ aW50IHJldDsKKworCWlmICghZGV2X3JlcV9wYXJhbXMpIHsKKwkJcHJfZXJyKCIlczogaW5jb21p bmcgZGV2X3JlcV9wYXJhbXMgaXMgTlVMTFxuIiwgX19mdW5jX18pOworCQlyZXQgPSAtRUlOVkFM OworCQlnb3RvIG91dDsKKwl9CisKKworCXVmc19leHlub3NfY2FwLnR4X2xhbmVzID0gVUZTX0VY WU5PU19MSU1JVF9OVU1fTEFORVNfVFg7CisJdWZzX2V4eW5vc19jYXAucnhfbGFuZXMgPSBVRlNf RVhZTk9TX0xJTUlUX05VTV9MQU5FU19SWDsKKwl1ZnNfZXh5bm9zX2NhcC5oc19yeF9nZWFyID0g VUZTX0VYWU5PU19MSU1JVF9IU0dFQVJfUlg7CisJdWZzX2V4eW5vc19jYXAuaHNfdHhfZ2VhciA9 IFVGU19FWFlOT1NfTElNSVRfSFNHRUFSX1RYOworCXVmc19leHlub3NfY2FwLnB3bV9yeF9nZWFy ID0gVUZTX0VYWU5PU19MSU1JVF9QV01HRUFSX1JYOworCXVmc19leHlub3NfY2FwLnB3bV90eF9n ZWFyID0gVUZTX0VYWU5PU19MSU1JVF9QV01HRUFSX1RYOworCXVmc19leHlub3NfY2FwLnJ4X3B3 cl9wd20gPSBVRlNfRVhZTk9TX0xJTUlUX1JYX1BXUl9QV007CisJdWZzX2V4eW5vc19jYXAudHhf cHdyX3B3bSA9IFVGU19FWFlOT1NfTElNSVRfVFhfUFdSX1BXTTsKKwl1ZnNfZXh5bm9zX2NhcC5y eF9wd3JfaHMgPSBVRlNfRVhZTk9TX0xJTUlUX1JYX1BXUl9IUzsKKwl1ZnNfZXh5bm9zX2NhcC50 eF9wd3JfaHMgPSBVRlNfRVhZTk9TX0xJTUlUX1RYX1BXUl9IUzsKKwl1ZnNfZXh5bm9zX2NhcC5o c19yYXRlID0gVUZTX0VYWU5PU19MSU1JVF9IU19SQVRFOworCXVmc19leHlub3NfY2FwLmRlc2ly ZWRfd29ya2luZ19tb2RlID0KKwkJCQlVRlNfRVhZTk9TX0xJTUlUX0RFU0lSRURfTU9ERTsKKwor CXJldCA9IHVmc2hjZF9nZXRfcHdyX2Rldl9wYXJhbSgmdWZzX2V4eW5vc19jYXAsCisJCQkJICAg ICAgIGRldl9tYXhfcGFyYW1zLCBkZXZfcmVxX3BhcmFtcyk7CisJaWYgKHJldCkgeworCQlwcl9l cnIoIiVzOiBmYWlsZWQgdG8gZGV0ZXJtaW5lIGNhcGFiaWxpdGllc1xuIiwgX19mdW5jX18pOwor CQlnb3RvIG91dDsKKwl9CisKKwlpZiAodWZzLT5kcnZfZGF0YS0+cHJlX3B3cl9jaGFuZ2UpCisJ CXVmcy0+ZHJ2X2RhdGEtPnByZV9wd3JfY2hhbmdlKHVmcywgZGV2X3JlcV9wYXJhbXMpOworCisJ aWYgKHVmc2hjZF9pc19oc19tb2RlKGRldl9yZXFfcGFyYW1zKSkgeworCQlleHlub3NfdWZzX2Nv bmZpZ19zeW5jX3BhdHRlcm5fbWFzayh1ZnMsIGRldl9yZXFfcGFyYW1zKTsKKworCQlzd2l0Y2gg KGRldl9yZXFfcGFyYW1zLT5oc19yYXRlKSB7CisJCWNhc2UgUEFfSFNfTU9ERV9BOgorCQljYXNl IFBBX0hTX01PREVfQjoKKwkJCXBoeV9jYWxpYnJhdGUoZ2VuZXJpY19waHkpOworCQkJYnJlYWs7 CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCisjZGVmaW5l IFBXUl9NT0RFX1NUUl9MRU4JNjQKK3N0YXRpYyBpbnQgZXh5bm9zX3Vmc19wb3N0X3B3cl9tb2Rl KHN0cnVjdCB1ZnNfaGJhICpoYmEsCisJCQkJc3RydWN0IHVmc19wYV9sYXllcl9hdHRyICpwd3Jf bWF4LAorCQkJCXN0cnVjdCB1ZnNfcGFfbGF5ZXJfYXR0ciAqcHdyX3JlcSkKK3sKKwlzdHJ1Y3Qg ZXh5bm9zX3VmcyAqdWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisJc3RydWN0IHBoeSAq Z2VuZXJpY19waHkgPSB1ZnMtPnBoeTsKKwlpbnQgZ2VhciA9IG1heF90KHUzMiwgcHdyX3JlcS0+ Z2Vhcl9yeCwgcHdyX3JlcS0+Z2Vhcl90eCk7CisJaW50IGxhbmVzID0gbWF4X3QodTMyLCBwd3Jf cmVxLT5sYW5lX3J4LCBwd3JfcmVxLT5sYW5lX3R4KTsKKwljaGFyIHB3cl9zdHJbUFdSX01PREVf U1RSX0xFTl0gPSAiIjsKKworCS8qIGxldCBkZWZhdWx0IGJlIFBXTSBHZWFyIDEsIExhbmUgMSAq LworCWlmICghZ2VhcikKKwkJZ2VhciA9IDE7CisKKwlpZiAoIWxhbmVzKQorCQlsYW5lcyA9IDE7 CisKKwlpZiAodWZzLT5kcnZfZGF0YS0+cG9zdF9wd3JfY2hhbmdlKQorCQl1ZnMtPmRydl9kYXRh LT5wb3N0X3B3cl9jaGFuZ2UodWZzLCBwd3JfcmVxKTsKKworCWlmICgodWZzaGNkX2lzX2hzX21v ZGUocHdyX3JlcSkpKSB7CisJCXN3aXRjaCAocHdyX3JlcS0+aHNfcmF0ZSkgeworCQljYXNlIFBB X0hTX01PREVfQToKKwkJY2FzZSBQQV9IU19NT0RFX0I6CisJCQlwaHlfY2FsaWJyYXRlKGdlbmVy aWNfcGh5KTsKKwkJCWJyZWFrOworCQl9CisKKwkJc25wcmludGYocHdyX3N0ciwgUFdSX01PREVf U1RSX0xFTiwgIiVzIHNlcmllc18lcyBHXyVkIExfJWQiLAorCQkJIkZBU1QiLAlwd3JfcmVxLT5o c19yYXRlID09IFBBX0hTX01PREVfQSA/ICJBIiA6ICJCIiwKKwkJCWdlYXIsIGxhbmVzKTsKKwl9 IGVsc2UgeworCQlzbnByaW50Zihwd3Jfc3RyLCBQV1JfTU9ERV9TVFJfTEVOLCAiJXMgR18lZCBM XyVkIiwKKwkJCSJTTE9XIiwgZ2VhciwgbGFuZXMpOworCX0KKworCWRldl9pbmZvKGhiYS0+ZGV2 LCAiUG93ZXIgbW9kZSBjaGFuZ2VkIHRvIDogJXNcbiIsIHB3cl9zdHIpOworCisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfc3BlY2lmeV9uZXh1c190X3hmZXJfcmVxKHN0 cnVjdCB1ZnNfaGJhICpoYmEsCisJCQkJCQlpbnQgdGFnLCBib29sIG9wKQoreworCXN0cnVjdCBl eHlub3NfdWZzICp1ZnMgPSB1ZnNoY2RfZ2V0X3ZhcmlhbnQoaGJhKTsKKwl1MzIgdHlwZTsKKwor CXR5cGUgPSAgaGNpX3JlYWRsKHVmcywgSENJX1VUUkxfTkVYVVNfVFlQRSk7CisKKwlpZiAob3Ap CisJCWhjaV93cml0ZWwodWZzLCB0eXBlIHwgKDEgPDwgdGFnKSwgSENJX1VUUkxfTkVYVVNfVFlQ RSk7CisJZWxzZQorCQloY2lfd3JpdGVsKHVmcywgdHlwZSAmIH4oMSA8PCB0YWcpLCBIQ0lfVVRS TF9ORVhVU19UWVBFKTsKK30KKworc3RhdGljIHZvaWQgZXh5bm9zX3Vmc19zcGVjaWZ5X25leHVz X3RfdG1fcmVxKHN0cnVjdCB1ZnNfaGJhICpoYmEsCisJCQkJCQlpbnQgdGFnLCB1OCBmdW5jKQor eworCXN0cnVjdCBleHlub3NfdWZzICp1ZnMgPSB1ZnNoY2RfZ2V0X3ZhcmlhbnQoaGJhKTsKKwl1 MzIgdHlwZTsKKworCXR5cGUgPSAgaGNpX3JlYWRsKHVmcywgSENJX1VUTVJMX05FWFVTX1RZUEUp OworCisJc3dpdGNoIChmdW5jKSB7CisJY2FzZSBVRlNfQUJPUlRfVEFTSzoKKwljYXNlIFVGU19R VUVSWV9UQVNLOgorCQloY2lfd3JpdGVsKHVmcywgdHlwZSB8ICgxIDw8IHRhZyksIEhDSV9VVE1S TF9ORVhVU19UWVBFKTsKKwkJYnJlYWs7CisJY2FzZSBVRlNfQUJPUlRfVEFTS19TRVQ6CisJY2Fz ZSBVRlNfQ0xFQVJfVEFTS19TRVQ6CisJY2FzZSBVRlNfTE9HSUNBTF9SRVNFVDoKKwljYXNlIFVG U19RVUVSWV9UQVNLX1NFVDoKKwkJaGNpX3dyaXRlbCh1ZnMsIHR5cGUgJiB+KDEgPDwgdGFnKSwg SENJX1VUTVJMX05FWFVTX1RZUEUpOworCQlicmVhazsKKwl9Cit9CisKK3N0YXRpYyBpbnQgZXh5 bm9zX3Vmc19waHlfaW5pdChzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzKQoreworCXN0cnVjdCB1ZnNf aGJhICpoYmEgPSB1ZnMtPmhiYTsKKwlzdHJ1Y3QgcGh5ICpnZW5lcmljX3BoeSA9IHVmcy0+cGh5 OworCWludCByZXQgPSAwOworCisJaWYgKHVmcy0+YXZhaWxfbG5fcnggPT0gMCB8fCB1ZnMtPmF2 YWlsX2xuX3R4ID09IDApIHsKKwkJdWZzaGNkX2RtZV9nZXQoaGJhLCBVSUNfQVJHX01JQihQQV9B VkFJTFJYREFUQUxBTkVTKSwKKwkJCSZ1ZnMtPmF2YWlsX2xuX3J4KTsKKwkJdWZzaGNkX2RtZV9n ZXQoaGJhLCBVSUNfQVJHX01JQihQQV9BVkFJTFRYREFUQUxBTkVTKSwKKwkJCSZ1ZnMtPmF2YWls X2xuX3R4KTsKKwkJV0FSTih1ZnMtPmF2YWlsX2xuX3J4ICE9IHVmcy0+YXZhaWxfbG5fdHgsCisJ CQkiYXZhaWxhYmxlIGRhdGEgbGFuZSBpcyBub3QgZXF1YWwocng6JWQsIHR4OiVkKVxuIiwKKwkJ CXVmcy0+YXZhaWxfbG5fcngsIHVmcy0+YXZhaWxfbG5fdHgpOworCX0KKworCXBoeV9zZXRfYnVz X3dpZHRoKGdlbmVyaWNfcGh5LCB1ZnMtPmF2YWlsX2xuX3J4KTsKKwlyZXQgPSBwaHlfaW5pdChn ZW5lcmljX3BoeSk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGhiYS0+ZGV2LCAiJXM6IHBoeSBp bml0IGZhaWxlZCwgcmV0ID0gJWRcbiIsCisJCQlfX2Z1bmNfXywgcmV0KTsKKwkJZ290byBvdXRf ZXhpdF9waHk7CisJfQorCisJcmV0dXJuIDA7CisKK291dF9leGl0X3BoeToKKwlwaHlfZXhpdChn ZW5lcmljX3BoeSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZz X2NvbmZpZ191bmlwcm8oc3RydWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwlzdHJ1Y3QgdWZzX2hi YSAqaGJhID0gdWZzLT5oYmE7CisKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBB X0RCR19DTEtfUEVSSU9EKSwKKwkJRElWX1JPVU5EX1VQKE5TRUNfUEVSX1NFQywgdWZzLT5tY2xr X3JhdGUpKTsKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBBX1RYVFJBSUxJTkdD TE9DS1MpLAorCQkJdWZzLT5kcnZfZGF0YS0+dWljX2F0dHItPnR4X3RyYWlsaW5nY2xrcyk7CisJ dWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQihQQV9EQkdfT1BUSU9OX1NVSVRFKSwKKwkJ CXVmcy0+ZHJ2X2RhdGEtPnVpY19hdHRyLT5wYV9kYmdfb3B0aW9uX3N1aXRlKTsKK30KKworc3Rh dGljIHZvaWQgZXh5bm9zX3Vmc19jb25maWdfaW50cihzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLCB1 MzIgZXJycywgdTggaW5kZXgpCit7CisJc3dpdGNoIChpbmRleCkgeworCWNhc2UgVU5JUFJPX0wx XzU6CisJCWhjaV93cml0ZWwodWZzLCBERkVTX0VSUl9FTiB8IGVycnMsIEhDSV9FUlJfRU5fUEFf TEFZRVIpOworCQlicmVhazsKKwljYXNlIFVOSVBST19MMjoKKwkJaGNpX3dyaXRlbCh1ZnMsIERG RVNfRVJSX0VOIHwgZXJycywgSENJX0VSUl9FTl9ETF9MQVlFUik7CisJCWJyZWFrOworCWNhc2Ug VU5JUFJPX0wzOgorCQloY2lfd3JpdGVsKHVmcywgREZFU19FUlJfRU4gfCBlcnJzLCBIQ0lfRVJS X0VOX05fTEFZRVIpOworCQlicmVhazsKKwljYXNlIFVOSVBST19MNDoKKwkJaGNpX3dyaXRlbCh1 ZnMsIERGRVNfRVJSX0VOIHwgZXJycywgSENJX0VSUl9FTl9UX0xBWUVSKTsKKwkJYnJlYWs7CisJ Y2FzZSBVTklQUk9fRE1FOgorCQloY2lfd3JpdGVsKHVmcywgREZFU19FUlJfRU4gfCBlcnJzLCBI Q0lfRVJSX0VOX0RNRV9MQVlFUik7CisJCWJyZWFrOworCX0KK30KKworc3RhdGljIGludCBleHlu b3NfdWZzX3ByZV9saW5rKHN0cnVjdCB1ZnNfaGJhICpoYmEpCit7CisJc3RydWN0IGV4eW5vc191 ZnMgKnVmcyA9IHVmc2hjZF9nZXRfdmFyaWFudChoYmEpOworCisJLyogaGNpICovCisJZXh5bm9z X3Vmc19jb25maWdfaW50cih1ZnMsIERGRVNfREVGX0wyX0VSUlMsIFVOSVBST19MMik7CisJZXh5 bm9zX3Vmc19jb25maWdfaW50cih1ZnMsIERGRVNfREVGX0wzX0VSUlMsIFVOSVBST19MMyk7CisJ ZXh5bm9zX3Vmc19jb25maWdfaW50cih1ZnMsIERGRVNfREVGX0w0X0VSUlMsIFVOSVBST19MNCk7 CisJZXh5bm9zX3Vmc19zZXRfdW5pcHJvX3BjbGtfZGl2KHVmcyk7CisKKwkvKiB1bmlwcm8gKi8K KwlleHlub3NfdWZzX2NvbmZpZ191bmlwcm8odWZzKTsKKworCS8qIG0tcGh5ICovCisJZXh5bm9z X3Vmc19waHlfaW5pdCh1ZnMpOworCWV4eW5vc191ZnNfY29uZmlnX3BoeV90aW1lX2F0dHIodWZz KTsKKwlleHlub3NfdWZzX2NvbmZpZ19waHlfY2FwX2F0dHIodWZzKTsKKworCWlmICh1ZnMtPmRy dl9kYXRhLT5wcmVfbGluaykKKwkJdWZzLT5kcnZfZGF0YS0+cHJlX2xpbmsodWZzKTsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZzX2ZpdF9hZ2dyX3RpbWVvdXQoc3Ry dWN0IGV4eW5vc191ZnMgKnVmcykKK3sKKwl1MzIgdmFsOworCisJdmFsID0gZXh5bm9zX3Vmc19j YWxjX3RpbWVfY250cih1ZnMsIElBVE9WQUxfTlNFQyAvIENOVFJfRElWX1ZBTCk7CisJaGNpX3dy aXRlbCh1ZnMsIHZhbCAmIENOVF9WQUxfMVVTX01BU0ssIEhDSV8xVVNfVE9fQ05UX1ZBTCk7Cit9 CisKK3N0YXRpYyBpbnQgZXh5bm9zX3Vmc19wb3N0X2xpbmsoc3RydWN0IHVmc19oYmEgKmhiYSkK K3sKKwlzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisJ c3RydWN0IHBoeSAqZ2VuZXJpY19waHkgPSB1ZnMtPnBoeTsKKwlzdHJ1Y3QgZXh5bm9zX3Vmc191 aWNfYXR0ciAqYXR0ciA9IHVmcy0+ZHJ2X2RhdGEtPnVpY19hdHRyOworCisJZXh5bm9zX3Vmc19l c3RhYmxpc2hfY29ubnQodWZzKTsKKwlleHlub3NfdWZzX2ZpdF9hZ2dyX3RpbWVvdXQodWZzKTsK KworCWhjaV93cml0ZWwodWZzLCAweGEsIEhDSV9EQVRBX1JFT1JERVIpOworCWhjaV93cml0ZWwo dWZzLCBQUkRUX1NFVF9TSVpFKDEyKSwgSENJX1RYUFJEVF9FTlRSWV9TSVpFKTsKKwloY2lfd3Jp dGVsKHVmcywgUFJEVF9TRVRfU0laRSgxMiksIEhDSV9SWFBSRFRfRU5UUllfU0laRSk7CisJaGNp X3dyaXRlbCh1ZnMsICgxIDw8IGhiYS0+bnV0cnMpIC0gMSwgSENJX1VUUkxfTkVYVVNfVFlQRSk7 CisJaGNpX3dyaXRlbCh1ZnMsICgxIDw8IGhiYS0+bnV0bXJzKSAtIDEsIEhDSV9VVE1STF9ORVhV U19UWVBFKTsKKwloY2lfd3JpdGVsKHVmcywgMHhmLCBIQ0lfQVhJRE1BX1JXREFUQV9CVVJTVF9M RU4pOworCisJaWYgKHVmcy0+b3B0cyAmIEVYWU5PU19VRlNfT1BUX1NLSVBfQ09OTkVDVElPTl9F U1RBQikKKwkJdWZzaGNkX2RtZV9zZXQoaGJhLAorCQkJVUlDX0FSR19NSUIoVF9EQkdfU0tJUF9J TklUX0hJQkVSTjhfRVhJVCksIFRSVUUpOworCisJaWYgKGF0dHItPnBhX2dyYW51bGFyaXR5KSB7 CisJCWV4eW5vc191ZnNfZW5hYmxlX2RiZ19tb2RlKGhiYSk7CisJCXVmc2hjZF9kbWVfc2V0KGhi YSwgVUlDX0FSR19NSUIoUEFfR1JBTlVMQVJJVFkpLAorCQkJCWF0dHItPnBhX2dyYW51bGFyaXR5 KTsKKwkJZXh5bm9zX3Vmc19kaXNhYmxlX2RiZ19tb2RlKGhiYSk7CisKKwkJaWYgKGF0dHItPnBh X3RhY3RpdmF0ZSkKKwkJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoUEFfVEFDVElW QVRFKSwKKwkJCQkJYXR0ci0+cGFfdGFjdGl2YXRlKTsKKwkJaWYgKGF0dHItPnBhX2hpYmVybjh0 aW1lICYmCisJCSAgICAhKHVmcy0+b3B0cyAmIEVYWU5PU19VRlNfT1BUX1VTRV9TV19ISUJFUk44 X1RJTUVSKSkKKwkJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoUEFfSElCRVJOOFRJ TUUpLAorCQkJCQlhdHRyLT5wYV9oaWJlcm44dGltZSk7CisJfQorCisJaWYgKHVmcy0+b3B0cyAm IEVYWU5PU19VRlNfT1BUX1VTRV9TV19ISUJFUk44X1RJTUVSKSB7CisJCWlmICghYXR0ci0+cGFf Z3JhbnVsYXJpdHkpCisJCQl1ZnNoY2RfZG1lX2dldChoYmEsIFVJQ19BUkdfTUlCKFBBX0dSQU5V TEFSSVRZKSwKKwkJCQkJJmF0dHItPnBhX2dyYW51bGFyaXR5KTsKKwkJaWYgKCFhdHRyLT5wYV9o aWJlcm44dGltZSkKKwkJCXVmc2hjZF9kbWVfZ2V0KGhiYSwgVUlDX0FSR19NSUIoUEFfSElCRVJO OFRJTUUpLAorCQkJCQkmYXR0ci0+cGFfaGliZXJuOHRpbWUpOworCQkvKgorCQkgKiBub3Qgd2Fp dCBmb3IgSElCRVJOOCB0aW1lIHRvIGV4aXQgaGliZXJuYXRpb24KKwkJICovCisJCXVmc2hjZF9k bWVfc2V0KGhiYSwgVUlDX0FSR19NSUIoUEFfSElCRVJOOFRJTUUpLCAwKTsKKworCQlpZiAoYXR0 ci0+cGFfZ3JhbnVsYXJpdHkgPCAxIHx8IGF0dHItPnBhX2dyYW51bGFyaXR5ID4gNikgeworCQkJ LyogVmFsaWQgcmFuZ2UgZm9yIGdyYW51bGFyaXR5OiAxIH4gNiAqLworCQkJZGV2X3dhcm4oaGJh LT5kZXYsCisJCQkJIiVzOiBwYV9ncmFudWxhcnR5ICVkIGlzIGludmFsaWQsIGFzc3VtaW5nIGJh Y2t3YXJkcyBjb21wYXRpYmlsaXR5XG4iLAorCQkJCV9fZnVuY19fLAorCQkJCWF0dHItPnBhX2dy YW51bGFyaXR5KTsKKwkJCWF0dHItPnBhX2dyYW51bGFyaXR5ID0gNjsKKwkJfQorCX0KKworCXBo eV9jYWxpYnJhdGUoZ2VuZXJpY19waHkpOworCisJaWYgKHVmcy0+ZHJ2X2RhdGEtPnBvc3RfbGlu aykKKwkJdWZzLT5kcnZfZGF0YS0+cG9zdF9saW5rKHVmcyk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBleHlub3NfdWZzX3BhcnNlX2R0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IGV4eW5vc191ZnMgKnVmcykKK3sKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wID0gZGV2LT5vZl9u b2RlOworCXN0cnVjdCBleHlub3NfdWZzX2Rydl9kYXRhICpkcnZfZGF0YSA9ICZleHlub3NfdWZz X2RydnM7CisJc3RydWN0IGV4eW5vc191ZnNfdWljX2F0dHIgKmF0dHI7CisJaW50IHJldCA9IDA7 CisKKwl3aGlsZSAoZHJ2X2RhdGEtPmNvbXBhdGlibGUpIHsKKwkJaWYgKG9mX2RldmljZV9pc19j b21wYXRpYmxlKG5wLCBkcnZfZGF0YS0+Y29tcGF0aWJsZSkpIHsKKwkJCXVmcy0+ZHJ2X2RhdGEg PSBkcnZfZGF0YTsKKwkJCWJyZWFrOworCQl9CisJCWRydl9kYXRhKys7CisJfQorCisJaWYgKHVm cy0+ZHJ2X2RhdGEgJiYgdWZzLT5kcnZfZGF0YS0+dWljX2F0dHIpIHsKKwkJYXR0ciA9IHVmcy0+ ZHJ2X2RhdGEtPnVpY19hdHRyOworCX0gZWxzZSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRv IGdldCB1aWMgYXR0cmlidXRlc1xuIik7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0Owor CX0KKworCXVmcy0+cGNsa19hdmFpbF9taW4gPSBQQ0xLX0FWQUlMX01JTjsKKwl1ZnMtPnBjbGtf YXZhaWxfbWF4ID0gUENMS19BVkFJTF9NQVg7CisKKwlhdHRyLT5yeF9hZHZfZmluZV9ncmFuX3N1 cF9lbiA9IFJYX0FEVl9GSU5FX0dSQU5fU1VQX0VOOworCWF0dHItPnJ4X2Fkdl9maW5lX2dyYW5f c3RlcCA9IFJYX0FEVl9GSU5FX0dSQU5fU1RFUF9WQUw7CisJYXR0ci0+cnhfYWR2X21pbl9hY3R2 X3RpbWVfY2FwID0gUlhfQURWX01JTl9BQ1RWX1RJTUVfQ0FQOworCWF0dHItPnBhX2dyYW51bGFy aXR5ID0gUEFfR1JBTlVMQVJJVFlfVkFMOworCWF0dHItPnBhX3RhY3RpdmF0ZSA9IFBBX1RBQ1RJ VkFURV9WQUw7CisJYXR0ci0+cGFfaGliZXJuOHRpbWUgPSBQQV9ISUJFUk44VElNRV9WQUw7CisK K291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGV4eW5vc191ZnNfaW5pdChzdHJ1 Y3QgdWZzX2hiYSAqaGJhKQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9IGhiYS0+ZGV2OworCXN0 cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYgPSB0b19wbGF0Zm9ybV9kZXZpY2UoZGV2KTsKKwlz dHJ1Y3QgZXh5bm9zX3VmcyAqdWZzOworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCWludCByZXQ7 CisKKwl1ZnMgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnVmcyksIEdGUF9LRVJORUwpOwor CWlmICghdWZzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCS8qIGV4eW5vcy1zcGVjaWZpYyBoY2kg Ki8KKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVTT1VSQ0Vf TUVNLCAidnNfaGNpIik7CisJdWZzLT5yZWdfaGNpID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRl diwgcmVzKTsKKwlpZiAoIXVmcy0+cmVnX2hjaSkgeworCQlkZXZfZXJyKGRldiwgImNhbm5vdCBp b3JlbWFwIGZvciBoY2kgdmVuZG9yIHJlZ2lzdGVyXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJ fQorCisJLyogdW5pcHJvICovCisJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlX2J5bmFtZShw ZGV2LCBJT1JFU09VUkNFX01FTSwgInVuaXBybyIpOworCXVmcy0+cmVnX3VuaXBybyA9IGRldm1f aW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7CisJaWYgKCF1ZnMtPnJlZ191bmlwcm8pIHsKKwkJ ZGV2X2VycihkZXYsICJjYW5ub3QgaW9yZW1hcCBmb3IgdW5pcHJvIHJlZ2lzdGVyXG4iKTsKKwkJ cmV0dXJuIC1FTk9NRU07CisJfQorCisJLyogdWZzIHByb3RlY3RvciAqLworCXJlcyA9IHBsYXRm b3JtX2dldF9yZXNvdXJjZV9ieW5hbWUocGRldiwgSU9SRVNPVVJDRV9NRU0sICJ1ZnNwIik7CisJ dWZzLT5yZWdfdWZzcCA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7CisJaWYgKCF1 ZnMtPnJlZ191ZnNwKSB7CisJCWRldl9lcnIoZGV2LCAiY2Fubm90IGlvcmVtYXAgZm9yIHVmcyBw cm90ZWN0b3IgcmVnaXN0ZXJcbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlyZXQgPSBl eHlub3NfdWZzX3BhcnNlX2R0KGRldiwgdWZzKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2 LCAiZmFpbGVkIHRvIGdldCBkdCBpbmZvLlxuIik7CisJCWdvdG8gb3V0OworCX0KKworCXVmcy0+ cGh5ID0gZGV2bV9waHlfZ2V0KGRldiwgInVmcy1waHkiKTsKKwlpZiAoSVNfRVJSKHVmcy0+cGh5 KSkgeworCQlyZXQgPSBQVFJfRVJSKHVmcy0+cGh5KTsKKwkJZGV2X2VycihkZXYsICJmYWlsZWQg dG8gZ2V0IHVmcy1waHlcbiIpOworCQlnb3RvIG91dDsKKwl9CisKKwlyZXQgPSBwaHlfcG93ZXJf b24odWZzLT5waHkpOworCWlmIChyZXQpCisJCWdvdG8gcGh5X29mZjsKKworCXVmcy0+aGJhID0g aGJhOworCXVmcy0+b3B0cyA9IHVmcy0+ZHJ2X2RhdGEtPm9wdHM7CisJdWZzLT5yeF9zZWxfaWR4 ID0gUEFfTUFYREFUQUxBTkVTOworCWlmICh1ZnMtPm9wdHMgJiBFWFlOT1NfVUZTX09QVF9CUk9L RU5fUlhfU0VMX0lEWCkKKwkJdWZzLT5yeF9zZWxfaWR4ID0gMDsKKwloYmEtPnByaXYgPSAodm9p ZCAqKXVmczsKKwloYmEtPnF1aXJrcyA9IHVmcy0+ZHJ2X2RhdGEtPnF1aXJrczsKKwlpZiAodWZz LT5kcnZfZGF0YS0+ZHJ2X2luaXQpIHsKKwkJcmV0ID0gdWZzLT5kcnZfZGF0YS0+ZHJ2X2luaXQo ZGV2LCB1ZnMpOworCQlpZiAocmV0KSB7CisJCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbml0 IGRydi1kYXRhXG4iKTsKKwkJCWdvdG8gb3V0OworCQl9CisJfQorCisJcmV0ID0gZXh5bm9zX3Vm c19nZXRfY2xrX2luZm8odWZzKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKKwlleHlub3NfdWZz X3NwZWNpZnlfcGh5X3RpbWVfYXR0cih1ZnMpOworCWV4eW5vc191ZnNfY29uZmlnX3NtdSh1ZnMp OworCXJldHVybiAwOworCitwaHlfb2ZmOgorCXBoeV9wb3dlcl9vZmYodWZzLT5waHkpOworb3V0 OgorCWhiYS0+cHJpdiA9IE5VTEw7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBleHlu b3NfdWZzX2hvc3RfcmVzZXQoc3RydWN0IHVmc19oYmEgKmhiYSkKK3sKKwlzdHJ1Y3QgZXh5bm9z X3VmcyAqdWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisJdW5zaWduZWQgbG9uZyB0aW1l b3V0ID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoMSk7CisJdTMyIHZhbDsKKwlpbnQgcmV0 ID0gMDsKKworCWV4eW5vc191ZnNfZGlzYWJsZV9hdXRvX2N0cmxfaGNjX3NhdmUodWZzLCAmdmFs KTsKKworCWhjaV93cml0ZWwodWZzLCBVRlNfU1dfUlNUX01BU0ssIEhDSV9TV19SU1QpOworCisJ ZG8geworCQlpZiAoIShoY2lfcmVhZGwodWZzLCBIQ0lfU1dfUlNUKSAmIFVGU19TV19SU1RfTUFT SykpCisJCQlnb3RvIG91dDsKKwl9IHdoaWxlICh0aW1lX2JlZm9yZShqaWZmaWVzLCB0aW1lb3V0 KSk7CisKKwlkZXZfZXJyKGhiYS0+ZGV2LCAidGltZW91dCBob3N0IHN3LXJlc2V0XG4iKTsKKwly ZXQgPSAtRVRJTUVET1VUOworCitvdXQ6CisJZXh5bm9zX3Vmc19hdXRvX2N0cmxfaGNjX3Jlc3Rv cmUodWZzLCAmdmFsKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZz X2Rldl9od19yZXNldChzdHJ1Y3QgdWZzX2hiYSAqaGJhKQoreworCXN0cnVjdCBleHlub3NfdWZz ICp1ZnMgPSB1ZnNoY2RfZ2V0X3ZhcmlhbnQoaGJhKTsKKworCWhjaV93cml0ZWwodWZzLCAwIDw8 IDAsIEhDSV9HUElPX09VVCk7CisJdWRlbGF5KDUpOworCWhjaV93cml0ZWwodWZzLCAxIDw8IDAs IEhDSV9HUElPX09VVCk7Cit9CisKK3N0YXRpYyB2b2lkIGV4eW5vc191ZnNfcHJlX2hpYmVybjgo c3RydWN0IHVmc19oYmEgKmhiYSwgdTggZW50ZXIpCit7CisJc3RydWN0IGV4eW5vc191ZnMgKnVm cyA9IHVmc2hjZF9nZXRfdmFyaWFudChoYmEpOworCXN0cnVjdCBleHlub3NfdWZzX3VpY19hdHRy ICphdHRyID0gdWZzLT5kcnZfZGF0YS0+dWljX2F0dHI7CisKKwlpZiAoIWVudGVyKSB7CisJCWlm ICh1ZnMtPm9wdHMgJiBFWFlOT1NfVUZTX09QVF9CUk9LRU5fQVVUT19DTEtfQ1RSTCkKKwkJCWV4 eW5vc191ZnNfZGlzYWJsZV9hdXRvX2N0cmxfaGNjKHVmcyk7CisJCWV4eW5vc191ZnNfdW5nYXRl X2Nsa3ModWZzKTsKKworCQlpZiAodWZzLT5vcHRzICYgRVhZTk9TX1VGU19PUFRfVVNFX1NXX0hJ QkVSTjhfVElNRVIpIHsKKwkJCWNvbnN0IHVuc2lnbmVkIGludCBncmFudWxhcml0eV90YmxbXSA9 IHsKKwkJCQkxLCA0LCA4LCAxNiwgMzIsIDEwMAorCQkJfTsKKwkJCWludCBoOF90aW1lID0gYXR0 ci0+cGFfaGliZXJuOHRpbWUgKgorCQkJCWdyYW51bGFyaXR5X3RibFthdHRyLT5wYV9ncmFudWxh cml0eSAtIDFdOworCQkJdW5zaWduZWQgbG9uZyB1czsKKwkJCXM2NCBkZWx0YTsKKworCQkJZG8g eworCQkJCWRlbHRhID0gaDhfdGltZSAtIGt0aW1lX3VzX2RlbHRhKGt0aW1lX2dldCgpLAorCQkJ CQkJCXVmcy0+ZW50cnlfaGliZXJuOF90KTsKKwkJCQlpZiAoZGVsdGEgPD0gMCkKKwkJCQkJYnJl YWs7CisKKwkJCQl1cyA9IG1pbl90KHM2NCwgZGVsdGEsIFVTRUNfUEVSX01TRUMpOworCQkJCWlm ICh1cyA+PSAxMCkKKwkJCQkJdXNsZWVwX3JhbmdlKHVzLCB1cyArIDEwKTsKKwkJCX0gd2hpbGUg KDEpOworCQl9CisJfQorfQorCitzdGF0aWMgdm9pZCBleHlub3NfdWZzX3Bvc3RfaGliZXJuOChz dHJ1Y3QgdWZzX2hiYSAqaGJhLCB1OCBlbnRlcikKK3sKKwlzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZz ID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisKKwlpZiAoIWVudGVyKSB7CisJCXUzMiBjdXJf bW9kZSA9IDA7CisJCXUzMiBwd3Jtb2RlOworCisJCWlmICh1ZnNoY2RfaXNfaHNfbW9kZSgmdWZz LT5kZXZfcmVxX3BhcmFtcykpCisJCQlwd3Jtb2RlID0gRkFTVF9NT0RFOworCQllbHNlCisJCQlw d3Jtb2RlID0gU0xPV19NT0RFOworCisJCXVmc2hjZF9kbWVfZ2V0KGhiYSwgVUlDX0FSR19NSUIo UEFfUFdSTU9ERSksICZjdXJfbW9kZSk7CisJCWlmIChjdXJfbW9kZSAhPSAocHdybW9kZSA8PCA0 IHwgcHdybW9kZSkpIHsKKwkJCWRldl93YXJuKGhiYS0+ZGV2LCAiJXM6IHBvd2VyIG1vZGUgY2hh bmdlXG4iLCBfX2Z1bmNfXyk7CisJCQloYmEtPnB3cl9pbmZvLnB3cl9yeCA9IChjdXJfbW9kZSA+ PiA0KSAmIDB4ZjsKKwkJCWhiYS0+cHdyX2luZm8ucHdyX3R4ID0gY3VyX21vZGUgJiAweGY7CisJ CQl1ZnNoY2RfY29uZmlnX3B3cl9tb2RlKGhiYSwgJmhiYS0+bWF4X3B3cl9pbmZvLmluZm8pOwor CQl9CisKKwkJaWYgKCEodWZzLT5vcHRzICYgRVhZTk9TX1VGU19PUFRfU0tJUF9DT05ORUNUSU9O X0VTVEFCKSkKKwkJCWV4eW5vc191ZnNfZXN0YWJsaXNoX2Nvbm50KHVmcyk7CisJfSBlbHNlIHsK KwkJdWZzLT5lbnRyeV9oaWJlcm44X3QgPSBrdGltZV9nZXQoKTsKKwkJZXh5bm9zX3Vmc19nYXRl X2Nsa3ModWZzKTsKKwkJaWYgKHVmcy0+b3B0cyAmIEVYWU5PU19VRlNfT1BUX0JST0tFTl9BVVRP X0NMS19DVFJMKQorCQkJZXh5bm9zX3Vmc19lbmFibGVfYXV0b19jdHJsX2hjYyh1ZnMpOworCX0K K30KKworc3RhdGljIGludCBleHlub3NfdWZzX2hjZV9lbmFibGVfbm90aWZ5KHN0cnVjdCB1ZnNf aGJhICpoYmEsCisJCQkJCWVudW0gdWZzX25vdGlmeV9jaGFuZ2Vfc3RhdHVzIHN0YXR1cykKK3sK KwlzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisJaW50 IHJldCA9IDA7CisKKwlzd2l0Y2ggKHN0YXR1cykgeworCWNhc2UgUFJFX0NIQU5HRToKKwkJcmV0 ID0gZXh5bm9zX3Vmc19ob3N0X3Jlc2V0KGhiYSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0 OworCQlleHlub3NfdWZzX2Rldl9od19yZXNldChoYmEpOworCQlicmVhazsKKwljYXNlIFBPU1Rf Q0hBTkdFOgorCQlleHlub3NfdWZzX2NhbGNfcHdtX2Nsa19kaXYodWZzKTsKKwkJaWYgKCEodWZz LT5vcHRzICYgRVhZTk9TX1VGU19PUFRfQlJPS0VOX0FVVE9fQ0xLX0NUUkwpKQorCQkJZXh5bm9z X3Vmc19lbmFibGVfYXV0b19jdHJsX2hjYyh1ZnMpOworCQlicmVhazsKKwl9CisKKwlyZXR1cm4g cmV0OworfQorCitzdGF0aWMgaW50IGV4eW5vc191ZnNfbGlua19zdGFydHVwX25vdGlmeShzdHJ1 Y3QgdWZzX2hiYSAqaGJhLAorCQkJCQkgIGVudW0gdWZzX25vdGlmeV9jaGFuZ2Vfc3RhdHVzIHN0 YXR1cykKK3sKKwlpbnQgcmV0ID0gMDsKKworCXN3aXRjaCAoc3RhdHVzKSB7CisJY2FzZSBQUkVf Q0hBTkdFOgorCQlyZXQgPSBleHlub3NfdWZzX3ByZV9saW5rKGhiYSk7CisJCWJyZWFrOworCWNh c2UgUE9TVF9DSEFOR0U6CisJCXJldCA9IGV4eW5vc191ZnNfcG9zdF9saW5rKGhiYSk7CisJCWJy ZWFrOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgZXh5bm9zX3Vmc19wd3Jf Y2hhbmdlX25vdGlmeShzdHJ1Y3QgdWZzX2hiYSAqaGJhLAorCQkJCWVudW0gdWZzX25vdGlmeV9j aGFuZ2Vfc3RhdHVzIHN0YXR1cywKKwkJCQlzdHJ1Y3QgdWZzX3BhX2xheWVyX2F0dHIgKmRldl9t YXhfcGFyYW1zLAorCQkJCXN0cnVjdCB1ZnNfcGFfbGF5ZXJfYXR0ciAqZGV2X3JlcV9wYXJhbXMp Cit7CisJaW50IHJldCA9IDA7CisKKwlzd2l0Y2ggKHN0YXR1cykgeworCWNhc2UgUFJFX0NIQU5H RToKKwkJcmV0ID0gZXh5bm9zX3Vmc19wcmVfcHdyX21vZGUoaGJhLCBkZXZfbWF4X3BhcmFtcywK KwkJCQkJICAgICAgZGV2X3JlcV9wYXJhbXMpOworCQlicmVhazsKKwljYXNlIFBPU1RfQ0hBTkdF OgorCQlyZXQgPSBleHlub3NfdWZzX3Bvc3RfcHdyX21vZGUoaGJhLCBOVUxMLCBkZXZfcmVxX3Bh cmFtcyk7CisJCWJyZWFrOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGV4 eW5vc191ZnNfaGliZXJuOF9ub3RpZnkoc3RydWN0IHVmc19oYmEgKmhiYSwKKwkJCQkgICAgIGVu dW0gdWljX2NtZF9kbWUgZW50ZXIsCisJCQkJICAgICBlbnVtIHVmc19ub3RpZnlfY2hhbmdlX3N0 YXR1cyBub3RpZnkpCit7CisJc3dpdGNoICgodTgpbm90aWZ5KSB7CisJY2FzZSBQUkVfQ0hBTkdF OgorCQlleHlub3NfdWZzX3ByZV9oaWJlcm44KGhiYSwgZW50ZXIpOworCQlicmVhazsKKwljYXNl IFBPU1RfQ0hBTkdFOgorCQlleHlub3NfdWZzX3Bvc3RfaGliZXJuOChoYmEsIGVudGVyKTsKKwkJ YnJlYWs7CisJfQorfQorCitzdGF0aWMgaW50IGV4eW5vc191ZnNfc3VzcGVuZChzdHJ1Y3QgdWZz X2hiYSAqaGJhLCBlbnVtIHVmc19wbV9vcCBwbV9vcCkKK3sKKwlzdHJ1Y3QgZXh5bm9zX3VmcyAq dWZzID0gdWZzaGNkX2dldF92YXJpYW50KGhiYSk7CisKKwlpZiAoIXVmc2hjZF9pc19saW5rX2Fj dGl2ZShoYmEpKQorCQlwaHlfcG93ZXJfb2ZmKHVmcy0+cGh5KTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgaW50IGV4eW5vc191ZnNfcmVzdW1lKHN0cnVjdCB1ZnNfaGJhICpoYmEsIGVudW0g dWZzX3BtX29wIHBtX29wKQoreworCXN0cnVjdCBleHlub3NfdWZzICp1ZnMgPSB1ZnNoY2RfZ2V0 X3ZhcmlhbnQoaGJhKTsKKworCWlmICghdWZzaGNkX2lzX2xpbmtfYWN0aXZlKGhiYSkpCisJCXBo eV9wb3dlcl9vbih1ZnMtPnBoeSk7CisKKwlleHlub3NfdWZzX2NvbmZpZ19zbXUodWZzKTsKKwor CXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHVmc19oYmFfdmFyaWFudF9vcHMgdWZzX2hi YV9leHlub3Nfb3BzID0geworCS5uYW1lCQkJCT0gImV4eW5vc191ZnMiLAorCS5pbml0CQkJCT0g ZXh5bm9zX3Vmc19pbml0LAorCS5oY2VfZW5hYmxlX25vdGlmeQkJPSBleHlub3NfdWZzX2hjZV9l bmFibGVfbm90aWZ5LAorCS5saW5rX3N0YXJ0dXBfbm90aWZ5CQk9IGV4eW5vc191ZnNfbGlua19z dGFydHVwX25vdGlmeSwKKwkucHdyX2NoYW5nZV9ub3RpZnkJCT0gZXh5bm9zX3Vmc19wd3JfY2hh bmdlX25vdGlmeSwKKwkuc2V0dXBfeGZlcl9yZXEJCQk9IGV4eW5vc191ZnNfc3BlY2lmeV9uZXh1 c190X3hmZXJfcmVxLAorCS5zZXR1cF90YXNrX21nbXQJCT0gZXh5bm9zX3Vmc19zcGVjaWZ5X25l eHVzX3RfdG1fcmVxLAorCS5oaWJlcm44X25vdGlmeQkJCT0gZXh5bm9zX3Vmc19oaWJlcm44X25v dGlmeSwKKwkuc3VzcGVuZAkJCT0gZXh5bm9zX3Vmc19zdXNwZW5kLAorCS5yZXN1bWUJCQkJPSBl eHlub3NfdWZzX3Jlc3VtZSwKK307CisKK3N0YXRpYyBpbnQgZXh5bm9zX3Vmc19wcm9iZShzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCWludCBlcnI7CisJc3RydWN0IGRldmljZSAq ZGV2ID0gJnBkZXYtPmRldjsKKworCWVyciA9IHVmc2hjZF9wbHRmcm1faW5pdChwZGV2LCAmdWZz X2hiYV9leHlub3Nfb3BzKTsKKwlpZiAoZXJyKQorCQlkZXZfZXJyKGRldiwgInVmc2hjZF9wbHRm cm1faW5pdCgpIGZhaWxlZCAlZFxuIiwgZXJyKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRp YyBpbnQgZXh5bm9zX3Vmc19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sK KwlzdHJ1Y3QgdWZzX2hiYSAqaGJhID0gIHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJ cG1fcnVudGltZV9nZXRfc3luYygmKHBkZXYpLT5kZXYpOworCXVmc2hjZF9yZW1vdmUoaGJhKTsK KwlyZXR1cm4gMDsKK30KKworc3RydWN0IGV4eW5vc191ZnNfZHJ2X2RhdGEgZXh5bm9zX3Vmc19k cnZzID0geworCisJLmNvbXBhdGlibGUJCT0gInNhbXN1bmcsZXh5bm9zNy11ZnMiLAorCS51aWNf YXR0cgkJPSAmZXh5bm9zN191aWNfYXR0ciwKKwkucXVpcmtzCQkJPSBVRlNIQ0RfUVVJUktfUFJE VF9CWVRFX0dSQU4gfAorCQkJCSAgVUZTSENJX1FVSVJLX0JST0tFTl9SRVFfTElTVF9DTFIgfAor CQkJCSAgVUZTSENJX1FVSVJLX0JST0tFTl9IQ0UgfAorCQkJCSAgVUZTSENJX1FVSVJLX1NLSVBf UkVTRVRfSU5UUl9BR0dSIHwKKwkJCQkgIFVGU0hDRF9RVUlSS19CUk9LRU5fT0NTX0ZBVEFMX0VS Uk9SLAorCS5vcHRzCQkJPSBFWFlOT1NfVUZTX09QVF9IQVNfQVBCX0NMS19DVFJMIHwKKwkJCQkg IEVYWU5PU19VRlNfT1BUX0JST0tFTl9BVVRPX0NMS19DVFJMIHwKKwkJCQkgIEVYWU5PU19VRlNf T1BUX0JST0tFTl9SWF9TRUxfSURYIHwKKwkJCQkgIEVYWU5PU19VRlNfT1BUX1NLSVBfQ09OTkVD VElPTl9FU1RBQiB8CisJCQkJICBFWFlOT1NfVUZTX09QVF9VU0VfU1dfSElCRVJOOF9USU1FUiwK KwkuZHJ2X2luaXQJCT0gZXh5bm9zN191ZnNfZHJ2X2luaXQsCisJLnByZV9saW5rCQk9IGV4eW5v czdfdWZzX3ByZV9saW5rLAorCS5wb3N0X2xpbmsJCT0gZXh5bm9zN191ZnNfcG9zdF9saW5rLAor CS5wcmVfcHdyX2NoYW5nZQkJPSBleHlub3M3X3Vmc19wcmVfcHdyX2NoYW5nZSwKKwkucG9zdF9w d3JfY2hhbmdlCT0gZXh5bm9zN191ZnNfcG9zdF9wd3JfY2hhbmdlLAorfTsKKworc3RhdGljIGNv bnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgZXh5bm9zX3Vmc19vZl9tYXRjaFtdID0geworCXsgLmNv bXBhdGlibGUgPSAic2Ftc3VuZyxleHlub3M3LXVmcyIsCisJICAuZGF0YQkgICAgICA9ICZleHlu b3NfdWZzX2RydnMgfSwKKwl7fSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29w cyBleHlub3NfdWZzX3BtX29wcyA9IHsKKwkuc3VzcGVuZAk9IHVmc2hjZF9wbHRmcm1fc3VzcGVu ZCwKKwkucmVzdW1lCQk9IHVmc2hjZF9wbHRmcm1fcmVzdW1lLAorCS5ydW50aW1lX3N1c3BlbmQg PSB1ZnNoY2RfcGx0ZnJtX3J1bnRpbWVfc3VzcGVuZCwKKwkucnVudGltZV9yZXN1bWUgID0gdWZz aGNkX3BsdGZybV9ydW50aW1lX3Jlc3VtZSwKKwkucnVudGltZV9pZGxlICAgID0gdWZzaGNkX3Bs dGZybV9ydW50aW1lX2lkbGUsCit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBl eHlub3NfdWZzX3BsdGZvcm0gPSB7CisJLnByb2JlCT0gZXh5bm9zX3Vmc19wcm9iZSwKKwkucmVt b3ZlCT0gZXh5bm9zX3Vmc19yZW1vdmUsCisJLnNodXRkb3duID0gdWZzaGNkX3BsdGZybV9zaHV0 ZG93biwKKwkuZHJpdmVyCT0geworCQkubmFtZQk9ICJleHlub3MtdWZzaGMiLAorCQkucG0JPSAm ZXh5bm9zX3Vmc19wbV9vcHMsCisJCS5vZl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cihleHlu b3NfdWZzX29mX21hdGNoKSwKKwl9LAorfTsKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoZXh5bm9z X3Vmc19wbHRmb3JtKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS91ZnMvdWZzLWV4eW5vcy5o IGIvZHJpdmVycy9zY3NpL3Vmcy91ZnMtZXh5bm9zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi43NmQ2ZTM5ZWZiMmYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L3Njc2kvdWZzL3Vmcy1leHlub3MuaApAQCAtMCwwICsxLDI4NyBAQAorLyogU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAtb25seSAqLworLyoKKyAqIFVGUyBIb3N0IENvbnRyb2xsZXIg ZHJpdmVyIGZvciBFeHlub3Mgc3BlY2lmaWMgZXh0ZW5zaW9ucworICoKKyAqIENvcHlyaWdodCAo QykgMjAxNC0yMDE1IFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgorICovCisKKyNp Zm5kZWYgX1VGU19FWFlOT1NfSF8KKyNkZWZpbmUgX1VGU19FWFlOT1NfSF8KKworLyoKKyAqIFVO SVBSTyByZWdpc3RlcnMKKyAqLworI2RlZmluZSBVTklQUk9fREJHX0ZPUkNFX0RNRV9DVFJMX1NU QVRFCQkweDE1MAorCisvKgorICogTUlCcyBmb3IgUEEgZGVidWcgcmVnaXN0ZXJzCisgKi8KKyNk ZWZpbmUgUEFfREJHX0NMS19QRVJJT0QJMHg5NTE0CisjZGVmaW5lIFBBX0RCR19UWFBIWV9DRkdV UERUCTB4OTUxOAorI2RlZmluZSBQQV9EQkdfUlhQSFlfQ0ZHVVBEVAkweDk1MTkKKyNkZWZpbmUg UEFfREJHX01PREUJCTB4OTUyOQorI2RlZmluZSBQQV9EQkdfU0tJUF9SRVNFVF9QSFkJMHg5NTM5 CisjZGVmaW5lIFBBX0RCR19PVl9UTQkJMHg5NTQwCisjZGVmaW5lIFBBX0RCR19TS0lQX0xJTkVf UkVTRVQJMHg5NTQxCisjZGVmaW5lIFBBX0RCR19MSU5FX1JFU0VUX1JFUQkweDk1NDMKKyNkZWZp bmUgUEFfREJHX09QVElPTl9TVUlURQkweDk1NjQKKyNkZWZpbmUgUEFfREJHX09QVElPTl9TVUlU RV9EWU4JMHg5NTY1CisKKy8qCisgKiBNSUJzIGZvciBUcmFuc3BvcnQgTGF5ZXIgZGVidWcgcmVn aXN0ZXJzCisgKi8KKyNkZWZpbmUgVF9EQkdfU0tJUF9JTklUX0hJQkVSTjhfRVhJVAkweGMwMDEK KworLyoKKyAqIEV4eW5vcyBNUEhZIGF0dHJpYnV0ZXMKKyAqLworI2RlZmluZSBUWF9MSU5FUkVT RVRfTl9WQUwJMHgwMjc3CisjZGVmaW5lIFRYX0xJTkVSRVNFVF9OKHYpCSgoKHYpID4+IDEwKSAm IDB4RkYpCisjZGVmaW5lIFRYX0xJTkVSRVNFVF9QX1ZBTAkweDAyN0QKKyNkZWZpbmUgVFhfTElO RVJFU0VUX1AodikJKCgodikgPj4gMTIpICYgMHhGRikKKyNkZWZpbmUgVFhfT1ZfU0xFRVBfQ05U X1RJTUVSCTB4MDI4RQorI2RlZmluZSBUWF9PVl9IOF9FTlRFUl9FTgkoMSA8PCA3KQorI2RlZmlu ZSBUWF9PVl9TTEVFUF9DTlQodikJKCgodikgPj4gNSkgJiAweDdGKQorI2RlZmluZSBUWF9ISUdI X1pfQ05UXzExXzA4CTB4MDI4QworI2RlZmluZSBUWF9ISUdIX1pfQ05UX0godikJKCgodikgPj4g OCkgJiAweEYpCisjZGVmaW5lIFRYX0hJR0hfWl9DTlRfMDdfMDAJMHgwMjhECisjZGVmaW5lIFRY X0hJR0hfWl9DTlRfTCh2KQkoKHYpICYgMHhGRikKKyNkZWZpbmUgVFhfQkFTRV9OVkFMXzA3XzAw CTB4MDI5MworI2RlZmluZSBUWF9CQVNFX05WQUxfTCh2KQkoKHYpICYgMHhGRikKKyNkZWZpbmUg VFhfQkFTRV9OVkFMXzE1XzA4CTB4MDI5NAorI2RlZmluZSBUWF9CQVNFX05WQUxfSCh2KQkoKCh2 KSA+PiA4KSAmIDB4RkYpCisjZGVmaW5lIFRYX0dSQU5fTlZBTF8wN18wMAkweDAyOTUKKyNkZWZp bmUgVFhfR1JBTl9OVkFMX0wodikJKCh2KSAmIDB4RkYpCisjZGVmaW5lIFRYX0dSQU5fTlZBTF8x MF8wOAkweDAyOTYKKyNkZWZpbmUgVFhfR1JBTl9OVkFMX0godikJKCgodikgPj4gOCkgJiAweDMp CisKKyNkZWZpbmUgUlhfRklMTEVSX0VOQUJMRQkweDAzMTYKKyNkZWZpbmUgUlhfRklMTEVSX0VO CQkoMSA8PCAxKQorI2RlZmluZSBSWF9MSU5FUkVTRVRfVkFMCTB4MDMxNworI2RlZmluZSBSWF9M SU5FUkVTRVQodikJKCgodikgPj4gMTIpICYgMHhGRikKKyNkZWZpbmUgUlhfTENDX0lHTk9SRQkJ MHgwMzE4CisjZGVmaW5lIFJYX1NZTkNfTUFTS19MRU5HVEgJMHgwMzIxCisjZGVmaW5lIFJYX0hJ QkVSTjhfV0FJVF9WQUxfQklUXzIwXzE2CTB4MDMzMQorI2RlZmluZSBSWF9ISUJFUk44X1dBSVRf VkFMX0JJVF8xNV8wOAkweDAzMzIKKyNkZWZpbmUgUlhfSElCRVJOOF9XQUlUX1ZBTF9CSVRfMDdf MDAJMHgwMzMzCisjZGVmaW5lIFJYX09WX1NMRUVQX0NOVF9USU1FUgkweDAzNDAKKyNkZWZpbmUg UlhfT1ZfU0xFRVBfQ05UKHYpCSgoKHYpID4+IDYpICYgMHgxRikKKyNkZWZpbmUgUlhfT1ZfU1RB TExfQ05UX1RJTUVSCTB4MDM0MQorI2RlZmluZSBSWF9PVl9TVEFMTF9DTlQodikJKCgodikgPj4g NCkgJiAweEZGKQorI2RlZmluZSBSWF9CQVNFX05WQUxfMDdfMDAJMHgwMzU1CisjZGVmaW5lIFJY X0JBU0VfTlZBTF9MKHYpCSgodikgJiAweEZGKQorI2RlZmluZSBSWF9CQVNFX05WQUxfMTVfMDgJ MHgwMzU0CisjZGVmaW5lIFJYX0JBU0VfTlZBTF9IKHYpCSgoKHYpID4+IDgpICYgMHhGRikKKyNk ZWZpbmUgUlhfR1JBTl9OVkFMXzA3XzAwCTB4MDM1MworI2RlZmluZSBSWF9HUkFOX05WQUxfTCh2 KQkoKHYpICYgMHhGRikKKyNkZWZpbmUgUlhfR1JBTl9OVkFMXzEwXzA4CTB4MDM1MgorI2RlZmlu ZSBSWF9HUkFOX05WQUxfSCh2KQkoKCh2KSA+PiA4KSAmIDB4MykKKworI2RlZmluZSBDTU5fUFdN X0NMS19DVFJMCTB4MDQwMgorI2RlZmluZSBQV01fQ0xLX0NUUkxfTUFTSwkweDMKKworI2RlZmlu ZSBJQVRPVkFMX05TRUMJCTIwMDAwCS8qIHVuaXQ6IG5zICovCisjZGVmaW5lIFVOSVBST19QQ0xL X1BFUklPRCh1ZnMpIChOU0VDX1BFUl9TRUMgLyB1ZnMtPnBjbGtfcmF0ZSkKKworc3RydWN0IGV4 eW5vc191ZnM7CisKKy8qIHZlbmRvciBzcGVjaWZpYyBwcmUtZGVmaW5lZCBwYXJhbWV0ZXJzICov CisjZGVmaW5lIFNMT1cgMQorI2RlZmluZSBGQVNUIDIKKworI2RlZmluZSBVRlNfRVhZTk9TX0xJ TUlUX05VTV9MQU5FU19SWAkyCisjZGVmaW5lIFVGU19FWFlOT1NfTElNSVRfTlVNX0xBTkVTX1RY CTIKKyNkZWZpbmUgVUZTX0VYWU5PU19MSU1JVF9IU0dFQVJfUlgJVUZTX0hTX0czCisjZGVmaW5l IFVGU19FWFlOT1NfTElNSVRfSFNHRUFSX1RYCVVGU19IU19HMworI2RlZmluZSBVRlNfRVhZTk9T X0xJTUlUX1BXTUdFQVJfUlgJVUZTX1BXTV9HNAorI2RlZmluZSBVRlNfRVhZTk9TX0xJTUlUX1BX TUdFQVJfVFgJVUZTX1BXTV9HNAorI2RlZmluZSBVRlNfRVhZTk9TX0xJTUlUX1JYX1BXUl9QV00J U0xPV19NT0RFCisjZGVmaW5lIFVGU19FWFlOT1NfTElNSVRfVFhfUFdSX1BXTQlTTE9XX01PREUK KyNkZWZpbmUgVUZTX0VYWU5PU19MSU1JVF9SWF9QV1JfSFMJRkFTVF9NT0RFCisjZGVmaW5lIFVG U19FWFlOT1NfTElNSVRfVFhfUFdSX0hTCUZBU1RfTU9ERQorI2RlZmluZSBVRlNfRVhZTk9TX0xJ TUlUX0hTX1JBVEUJCVBBX0hTX01PREVfQgorI2RlZmluZSBVRlNfRVhZTk9TX0xJTUlUX0RFU0lS RURfTU9ERQlGQVNUCisKKyNkZWZpbmUgUlhfQURWX0ZJTkVfR1JBTl9TVVBfRU4JMHgxCisjZGVm aW5lIFJYX0FEVl9GSU5FX0dSQU5fU1RFUF9WQUwJMHgzCisjZGVmaW5lIFJYX0FEVl9NSU5fQUNU Vl9USU1FX0NBUAkweDkKKworI2RlZmluZSBQQV9HUkFOVUxBUklUWV9WQUwJMHg2CisjZGVmaW5l IFBBX1RBQ1RJVkFURV9WQUwJMHgzCisjZGVmaW5lIFBBX0hJQkVSTjhUSU1FX1ZBTAkweDIwCisK KyNkZWZpbmUgUENMS19BVkFJTF9NSU4JNzAwMDAwMDAKKyNkZWZpbmUgUENMS19BVkFJTF9NQVgJ MTMzMDAwMDAwCisKK3N0cnVjdCBleHlub3NfdWZzX3VpY19hdHRyIHsKKwkvKiBUWCBBdHRyaWJ1 dGVzICovCisJdW5zaWduZWQgaW50IHR4X3RyYWlsaW5nY2xrczsKKwl1bnNpZ25lZCBpbnQgdHhf ZGlmX3BfbnNlYzsKKwl1bnNpZ25lZCBpbnQgdHhfZGlmX25fbnNlYzsKKwl1bnNpZ25lZCBpbnQg dHhfaGlnaF96X2NudF9uc2VjOworCXVuc2lnbmVkIGludCB0eF9iYXNlX3VuaXRfbnNlYzsKKwl1 bnNpZ25lZCBpbnQgdHhfZ3Jhbl91bml0X25zZWM7CisJdW5zaWduZWQgaW50IHR4X3NsZWVwX2Nu dDsKKwl1bnNpZ25lZCBpbnQgdHhfbWluX2FjdGl2YXRldGltZTsKKwkvKiBSWCBBdHRyaWJ1dGVz ICovCisJdW5zaWduZWQgaW50IHJ4X2ZpbGxlcl9lbmFibGU7CisJdW5zaWduZWQgaW50IHJ4X2Rp Zl9wX25zZWM7CisJdW5zaWduZWQgaW50IHJ4X2hpYmVybjhfd2FpdF9uc2VjOworCXVuc2lnbmVk IGludCByeF9iYXNlX3VuaXRfbnNlYzsKKwl1bnNpZ25lZCBpbnQgcnhfZ3Jhbl91bml0X25zZWM7 CisJdW5zaWduZWQgaW50IHJ4X3NsZWVwX2NudDsKKwl1bnNpZ25lZCBpbnQgcnhfc3RhbGxfY250 OworCXVuc2lnbmVkIGludCByeF9oc19nMV9zeW5jX2xlbl9jYXA7CisJdW5zaWduZWQgaW50IHJ4 X2hzX2cyX3N5bmNfbGVuX2NhcDsKKwl1bnNpZ25lZCBpbnQgcnhfaHNfZzNfc3luY19sZW5fY2Fw OworCXVuc2lnbmVkIGludCByeF9oc19nMV9wcmVwX3N5bmNfbGVuX2NhcDsKKwl1bnNpZ25lZCBp bnQgcnhfaHNfZzJfcHJlcF9zeW5jX2xlbl9jYXA7CisJdW5zaWduZWQgaW50IHJ4X2hzX2czX3By ZXBfc3luY19sZW5fY2FwOworCS8qIENvbW1vbiBBdHRyaWJ1dGVzICovCisJdW5zaWduZWQgaW50 IGNtbl9wd21fY2xrX2N0cmw7CisJLyogSW50ZXJuYWwgQXR0cmlidXRlcyAqLworCXVuc2lnbmVk IGludCBwYV9kYmdfb3B0aW9uX3N1aXRlOworCS8qIENoYW5nZWFibGUgQXR0cmlidXRlcyAqLwor CXVuc2lnbmVkIGludCByeF9hZHZfZmluZV9ncmFuX3N1cF9lbjsKKwl1bnNpZ25lZCBpbnQgcnhf YWR2X2ZpbmVfZ3Jhbl9zdGVwOworCXVuc2lnbmVkIGludCByeF9taW5fYWN0dl90aW1lX2NhcDsK Kwl1bnNpZ25lZCBpbnQgcnhfaGliZXJuOF90aW1lX2NhcDsKKwl1bnNpZ25lZCBpbnQgcnhfYWR2 X21pbl9hY3R2X3RpbWVfY2FwOworCXVuc2lnbmVkIGludCByeF9hZHZfaGliZXJuOF90aW1lX2Nh cDsKKwl1bnNpZ25lZCBpbnQgcGFfZ3JhbnVsYXJpdHk7CisJdW5zaWduZWQgaW50IHBhX3RhY3Rp dmF0ZTsKKwl1bnNpZ25lZCBpbnQgcGFfaGliZXJuOHRpbWU7Cit9OworCitzdHJ1Y3QgZXh5bm9z X3Vmc19kcnZfZGF0YSB7CisJY2hhciAqY29tcGF0aWJsZTsKKwlzdHJ1Y3QgZXh5bm9zX3Vmc191 aWNfYXR0ciAqdWljX2F0dHI7CisJdW5zaWduZWQgaW50IHF1aXJrczsKKwl1bnNpZ25lZCBpbnQg b3B0czsKKwkvKiBTb0MncyBzcGVjaWZpYyBvcGVyYXRpb25zICovCisJaW50ICgqZHJ2X2luaXQp KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGV4eW5vc191ZnMgKnVmcyk7CisJaW50ICgqcHJl X2xpbmspKHN0cnVjdCBleHlub3NfdWZzICp1ZnMpOworCWludCAoKnBvc3RfbGluaykoc3RydWN0 IGV4eW5vc191ZnMgKnVmcyk7CisJaW50ICgqcHJlX3B3cl9jaGFuZ2UpKHN0cnVjdCBleHlub3Nf dWZzICp1ZnMsCisJCQkJc3RydWN0IHVmc19wYV9sYXllcl9hdHRyICpwd3IpOworCWludCAoKnBv c3RfcHdyX2NoYW5nZSkoc3RydWN0IGV4eW5vc191ZnMgKnVmcywKKwkJCQlzdHJ1Y3QgdWZzX3Bh X2xheWVyX2F0dHIgKnB3cik7Cit9OworCitzdHJ1Y3QgdWZzX3BoeV90aW1lX2NmZyB7CisJdTMy IHR4X2xpbmVyZXNldF9wOworCXUzMiB0eF9saW5lcmVzZXRfbjsKKwl1MzIgdHhfaGlnaF96X2Nu dDsKKwl1MzIgdHhfYmFzZV9uX3ZhbDsKKwl1MzIgdHhfZ3Jhbl9uX3ZhbDsKKwl1MzIgdHhfc2xl ZXBfY250OworCXUzMiByeF9saW5lcmVzZXQ7CisJdTMyIHJ4X2hpYmVybjhfd2FpdDsKKwl1MzIg cnhfYmFzZV9uX3ZhbDsKKwl1MzIgcnhfZ3Jhbl9uX3ZhbDsKKwl1MzIgcnhfc2xlZXBfY250Owor CXUzMiByeF9zdGFsbF9jbnQ7Cit9OworCitzdHJ1Y3QgZXh5bm9zX3VmcyB7CisJc3RydWN0IHVm c19oYmEgKmhiYTsKKwlzdHJ1Y3QgcGh5ICpwaHk7CisJdm9pZCBfX2lvbWVtICpyZWdfaGNpOwor CXZvaWQgX19pb21lbSAqcmVnX3VuaXBybzsKKwl2b2lkIF9faW9tZW0gKnJlZ191ZnNwOworCXN0 cnVjdCBjbGsgKmNsa19oY2lfY29yZTsKKwlzdHJ1Y3QgY2xrICpjbGtfdW5pcHJvX21haW47CisJ c3RydWN0IGNsayAqY2xrX2FwYjsKKwl1MzIgcGNsa19yYXRlOworCXUzMiBwY2xrX2RpdjsKKwl1 MzIgcGNsa19hdmFpbF9taW47CisJdTMyIHBjbGtfYXZhaWxfbWF4OworCXUzMiBtY2xrX3JhdGU7 CisJaW50IGF2YWlsX2xuX3J4OworCWludCBhdmFpbF9sbl90eDsKKwlpbnQgcnhfc2VsX2lkeDsK KwlzdHJ1Y3QgdWZzX3BhX2xheWVyX2F0dHIgZGV2X3JlcV9wYXJhbXM7CisJc3RydWN0IHVmc19w aHlfdGltZV9jZmcgdF9jZmc7CisJa3RpbWVfdCBlbnRyeV9oaWJlcm44X3Q7CisJc3RydWN0IGV4 eW5vc191ZnNfZHJ2X2RhdGEgKmRydl9kYXRhOworCisJdTMyIG9wdHM7CisjZGVmaW5lIEVYWU5P U19VRlNfT1BUX0hBU19BUEJfQ0xLX0NUUkwJCUJJVCgwKQorI2RlZmluZSBFWFlOT1NfVUZTX09Q VF9TS0lQX0NPTk5FQ1RJT05fRVNUQUIJQklUKDEpCisjZGVmaW5lIEVYWU5PU19VRlNfT1BUX0JS T0tFTl9BVVRPX0NMS19DVFJMCUJJVCgyKQorI2RlZmluZSBFWFlOT1NfVUZTX09QVF9CUk9LRU5f UlhfU0VMX0lEWAlCSVQoMykKKyNkZWZpbmUgRVhZTk9TX1VGU19PUFRfVVNFX1NXX0hJQkVSTjhf VElNRVIJQklUKDQpCit9OworCisjZGVmaW5lIGZvcl9lYWNoX3Vmc19yeF9sYW5lKHVmcywgaSkg XAorCWZvciAoaSA9ICh1ZnMpLT5yeF9zZWxfaWR4OyBcCisJCWkgPCAodWZzKS0+cnhfc2VsX2lk eCArICh1ZnMpLT5hdmFpbF9sbl9yeDsgaSsrKQorI2RlZmluZSBmb3JfZWFjaF91ZnNfdHhfbGFu ZSh1ZnMsIGkpIFwKKwlmb3IgKGkgPSAwOyBpIDwgKHVmcyktPmF2YWlsX2xuX3R4OyBpKyspCisK KyNkZWZpbmUgRVhZTk9TX1VGU19NTUlPX0ZVTkMobmFtZSkJCQkJCSAgXAorc3RhdGljIGlubGlu ZSB2b2lkIG5hbWUjI193cml0ZWwoc3RydWN0IGV4eW5vc191ZnMgKnVmcywgdTMyIHZhbCwgdTMy IHJlZylcCit7CQkJCQkJCQkJICBcCisJd3JpdGVsKHZhbCwgdWZzLT5yZWdfIyNuYW1lICsgcmVn KTsJCQkJICBcCit9CQkJCQkJCQkJICBcCisJCQkJCQkJCQkgIFwKK3N0YXRpYyBpbmxpbmUgdTMy IG5hbWUjI19yZWFkbChzdHJ1Y3QgZXh5bm9zX3VmcyAqdWZzLCB1MzIgcmVnKQkJICBcCit7CQkJ CQkJCQkJICBcCisJcmV0dXJuIHJlYWRsKHVmcy0+cmVnXyMjbmFtZSArIHJlZyk7CQkJCSAgXAor fQorCitFWFlOT1NfVUZTX01NSU9fRlVOQyhoY2kpOworRVhZTk9TX1VGU19NTUlPX0ZVTkModW5p cHJvKTsKK0VYWU5PU19VRlNfTU1JT19GVU5DKHVmc3ApOworI3VuZGVmIEVYWU5PU19VRlNfTU1J T19GVU5DCisKK2xvbmcgZXh5bm9zX3Vmc19jYWxjX3RpbWVfY250cihzdHJ1Y3QgZXh5bm9zX3Vm cyAqLCBsb25nKTsKKworc3RhdGljIGlubGluZSB2b2lkIGV4eW5vc191ZnNfZW5hYmxlX292X3Rt KHN0cnVjdCB1ZnNfaGJhICpoYmEpCit7CisJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01J QihQQV9EQkdfT1ZfVE0pLCBUUlVFKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGV4eW5vc191 ZnNfZGlzYWJsZV9vdl90bShzdHJ1Y3QgdWZzX2hiYSAqaGJhKQoreworCXVmc2hjZF9kbWVfc2V0 KGhiYSwgVUlDX0FSR19NSUIoUEFfREJHX09WX1RNKSwgRkFMU0UpOworfQorCitzdGF0aWMgaW5s aW5lIHZvaWQgZXh5bm9zX3Vmc19lbmFibGVfZGJnX21vZGUoc3RydWN0IHVmc19oYmEgKmhiYSkK K3sKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBBX0RCR19NT0RFKSwgVFJVRSk7 Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBleHlub3NfdWZzX2Rpc2FibGVfZGJnX21vZGUoc3Ry dWN0IHVmc19oYmEgKmhiYSkKK3sKKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCKFBB X0RCR19NT0RFKSwgRkFMU0UpOworfQorCitzdHJ1Y3QgZXh5bm9zX3Vmc19kcnZfZGF0YSBleHlu b3NfdWZzX2RydnM7CisKK3N0cnVjdCBleHlub3NfdWZzX3VpY19hdHRyIGV4eW5vczdfdWljX2F0 dHIgPSB7CisJLnR4X3RyYWlsaW5nY2xrcwkJPSAweDEwLAorCS50eF9kaWZfcF9uc2VjCQkJPSAz MDAwMDAwLAkvKiB1bml0OiBucyAqLworCS50eF9kaWZfbl9uc2VjCQkJPSAxMDAwMDAwLAkvKiB1 bml0OiBucyAqLworCS50eF9oaWdoX3pfY250X25zZWMJCT0gMjAwMDAsCS8qIHVuaXQ6IG5zICov CisJLnR4X2Jhc2VfdW5pdF9uc2VjCQk9IDEwMDAwMCwJLyogdW5pdDogbnMgKi8KKwkudHhfZ3Jh bl91bml0X25zZWMJCT0gNDAwMCwJCS8qIHVuaXQ6IG5zICovCisJLnR4X3NsZWVwX2NudAkJCT0g MTAwMCwJCS8qIHVuaXQ6IG5zICovCisJLnR4X21pbl9hY3RpdmF0ZXRpbWUJCT0gMHhhLAorCS5y eF9maWxsZXJfZW5hYmxlCQk9IDB4MiwKKwkucnhfZGlmX3BfbnNlYwkJCT0gMTAwMDAwMCwJLyog dW5pdDogbnMgKi8KKwkucnhfaGliZXJuOF93YWl0X25zZWMJCT0gNDAwMDAwMCwJLyogdW5pdDog bnMgKi8KKwkucnhfYmFzZV91bml0X25zZWMJCT0gMTAwMDAwLAkvKiB1bml0OiBucyAqLworCS5y eF9ncmFuX3VuaXRfbnNlYwkJPSA0MDAwLAkJLyogdW5pdDogbnMgKi8KKwkucnhfc2xlZXBfY250 CQkJPSAxMjgwLAkJLyogdW5pdDogbnMgKi8KKwkucnhfc3RhbGxfY250CQkJPSAzMjAsCQkvKiB1 bml0OiBucyAqLworCS5yeF9oc19nMV9zeW5jX2xlbl9jYXAJCT0gU1lOQ19MRU5fQ09BUlNFKDB4 ZiksCisJLnJ4X2hzX2cyX3N5bmNfbGVuX2NhcAkJPSBTWU5DX0xFTl9DT0FSU0UoMHhmKSwKKwku cnhfaHNfZzNfc3luY19sZW5fY2FwCQk9IFNZTkNfTEVOX0NPQVJTRSgweGYpLAorCS5yeF9oc19n MV9wcmVwX3N5bmNfbGVuX2NhcAk9IFBSRVBfTEVOKDB4ZiksCisJLnJ4X2hzX2cyX3ByZXBfc3lu Y19sZW5fY2FwCT0gUFJFUF9MRU4oMHhmKSwKKwkucnhfaHNfZzNfcHJlcF9zeW5jX2xlbl9jYXAJ PSBQUkVQX0xFTigweGYpLAorCS5wYV9kYmdfb3B0aW9uX3N1aXRlCQk9IDB4MzAxMDMsCit9Owor I2VuZGlmIC8qIF9VRlNfRVhZTk9TX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvdWZz L3VuaXByby5oIGIvZHJpdmVycy9zY3NpL3Vmcy91bmlwcm8uaAppbmRleCA3NjZkNTUxZGYzZmMu LjRlZTY0NzgyZmQ0OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3Vmcy91bmlwcm8uaAorKysg Yi9kcml2ZXJzL3Njc2kvdWZzL3VuaXByby5oCkBAIC02NCw4ICs2NCwyNSBAQAogI2RlZmluZSBD RkdSWE9WUjQJCQkJMHgwMEU5CiAjZGVmaW5lIFJYU1FDVFJMCQkJCTB4MDBCNQogI2RlZmluZSBD RkdSWE9WUjYJCQkJMHgwMEJGCisjZGVmaW5lIFJYX0hTX0cxX1NZTkNfTEVOR1RIX0NBUAkJMHgw MDhCCisjZGVmaW5lIFJYX0hTX0cxX1BSRVBfTEVOR1RIX0NBUAkJMHgwMDhDCisjZGVmaW5lIFJY X0hTX0cyX1NZTkNfTEVOR1RIX0NBUAkJMHgwMDk0CisjZGVmaW5lIFJYX0hTX0czX1NZTkNfTEVO R1RIX0NBUAkJMHgwMDk1CisjZGVmaW5lIFJYX0hTX0cyX1BSRVBfTEVOR1RIX0NBUAkJMHgwMDk2 CisjZGVmaW5lIFJYX0hTX0czX1BSRVBfTEVOR1RIX0NBUAkJMHgwMDk3CisjZGVmaW5lIFJYX0FE Vl9HUkFOVUxBUklUWV9DQVAJCQkweDAwOTgKKyNkZWZpbmUgUlhfTUlOX0FDVElWQVRFVElNRV9D QVAJCQkweDAwOEYKKyNkZWZpbmUgUlhfSElCRVJOOFRJTUVfQ0FQCQkJMHgwMDkyCisjZGVmaW5l IFJYX0FEVl9ISUJFUk44VElNRV9DQVAJCQkweDAwOTkKKyNkZWZpbmUgUlhfQURWX01JTl9BQ1RJ VkFURVRJTUVfQ0FQCQkweDAwOUEKKwogCiAjZGVmaW5lIGlzX21waHlfdHhfYXR0cihhdHRyKQkJ CShhdHRyIDwgUlhfTU9ERSkKKyNkZWZpbmUgUlhfQURWX0ZJTkVfR1JBTl9TVEVQKHgpCQkoKCgo eCkgJiAweDMpIDw8IDEpIHwgMHgxKQorI2RlZmluZSBTWU5DX0xFTl9GSU5FKHgpCQkJKCh4KSAm IDB4M0YpCisjZGVmaW5lIFNZTkNfTEVOX0NPQVJTRSh4KQkJCSgoMSA8PCA2KSB8ICgoeCkgJiAw eDNGKSkKKyNkZWZpbmUgUFJFUF9MRU4oeCkJCQkJKCh4KSAmIDB4RikKKwogI2RlZmluZSBSWF9N SU5fQUNUSVZBVEVUSU1FX1VOSVRfVVMJCTEwMAogI2RlZmluZSBISUJFUk44VElNRV9VTklUX1VT CQkJMTAwCiAKQEAgLTEyNCw2ICsxNDEsNyBAQAogI2RlZmluZSBQQV9QQUNQUkVRRU9CVElNRU9V VAkweDE1OTEKICNkZWZpbmUgUEFfSElCRVJOOFRJTUUJCTB4MTVBNwogI2RlZmluZSBQQV9MT0NB TFZFUklORk8JCTB4MTVBOQorI2RlZmluZSBQQV9HUkFOVUxBUklUWQkJMHgxNUFBCiAjZGVmaW5l IFBBX1RBQ1RJVkFURQkJMHgxNUE4CiAjZGVmaW5lIFBBX1BBQ1BGUkFNRUNPVU5UCTB4MTVDMAog I2RlZmluZSBQQV9QQUNQRVJST1JDT1VOVAkweDE1QzEKQEAgLTI5MSw0ICszMDksMTkgQEAgZW51 bSB7CiAJVFJVRSwKIH07CiAKKy8qIENQb3J0IHNldHRpbmcgKi8KKyNkZWZpbmUgRTJFRkNfT04J KDEgPDwgMCkKKyNkZWZpbmUgRTJFRkNfT0ZGCSgwIDw8IDApCisjZGVmaW5lIENTRF9OX09OCSgw IDw8IDEpCisjZGVmaW5lIENTRF9OX09GRgkoMSA8PCAxKQorI2RlZmluZSBDU1ZfTl9PTgkoMCA8 PCAyKQorI2RlZmluZSBDU1ZfTl9PRkYJKDEgPDwgMikKKyNkZWZpbmUgQ1BPUlRfREVGX0ZMQUdT CShDU1ZfTl9PRkYgfCBDU0RfTl9PRkYgfCBFMkVGQ19PRkYpCisKKy8qIENQb3J0IGNvbm5lY3Rp b24gc3RhdGUgKi8KK2VudW0geworCUNQT1JUX0lETEUgPSAwLAorCUNQT1JUX0NPTk5FQ1RFRCwK K307CisKICNlbmRpZiAvKiBfVU5JUFJPX0hfICovCi0tIAoyLjE3LjEKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxp bmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3Rz LmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==