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.9 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,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 50A79C38A30 for ; Fri, 17 Apr 2020 18:10:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2937B22201 for ; Fri, 17 Apr 2020 18:10:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="ogSixwMi" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730662AbgDQSKb (ORCPT ); Fri, 17 Apr 2020 14:10:31 -0400 Received: from mailout2.samsung.com ([203.254.224.25]:52590 "EHLO mailout2.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730592AbgDQSK2 (ORCPT ); Fri, 17 Apr 2020 14:10:28 -0400 Received: from epcas5p1.samsung.com (unknown [182.195.41.39]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20200417181022epoutp0200bf0bd0e8cd6dd4cae0a276c3a0a3af~Grc7M5Bhn0378603786epoutp02f for ; Fri, 17 Apr 2020 18:10:22 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20200417181022epoutp0200bf0bd0e8cd6dd4cae0a276c3a0a3af~Grc7M5Bhn0378603786epoutp02f DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1587147022; bh=jkpBVnMapPYgnP/AWNxgzOKgM7k0/ctDUDDMnmkJf0Y=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ogSixwMicbpj3On0Lg7BAPygqq71fc7ybsS7Aa8skmNawGkYkIjTZQR0IcA+rCQOF OsrfOSqsODleHddXFc4qVCBrnzGDtM9bzE9iGJVfAB2liDhCYqoaBPYICTMK+Cve2o eoJHdOirTqIi9be2uovjWRCOqoOCPe8tmoFFOh4Q= Received: from epsmges5p3new.samsung.com (unknown [182.195.42.75]) by epcas5p4.samsung.com (KnoxPortal) with ESMTP id 20200417181021epcas5p40d9ecc4dcce9e61c2311c405bb21ec0e~Grc5-XugE1060310603epcas5p4w; Fri, 17 Apr 2020 18:10:21 +0000 (GMT) Received: from epcas5p1.samsung.com ( [182.195.41.39]) by epsmges5p3new.samsung.com (Symantec Messaging Gateway) with SMTP id EA.0B.04736.C01F99E5; Sat, 18 Apr 2020 03:10:20 +0900 (KST) Received: from epsmtrp2.samsung.com (unknown [182.195.40.14]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPA id 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249~Grc5guiL-0105401054epcas5p27; Fri, 17 Apr 2020 18:10:20 +0000 (GMT) Received: from epsmgms1p2new.samsung.com (unknown [182.195.42.42]) by epsmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200417181020epsmtrp289b5431e6fd5038d86523130fde4f591~Grc5f20PN1925319253epsmtrp2F; Fri, 17 Apr 2020 18:10:20 +0000 (GMT) X-AuditID: b6c32a4b-acbff70000001280-5f-5e99f10c7fdb Received: from epsmtip1.samsung.com ( [182.195.34.30]) by epsmgms1p2new.samsung.com (Symantec Messaging Gateway) with SMTP id 75.DE.04158.C01F99E5; Sat, 18 Apr 2020 03:10:20 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200417181018epsmtip12fc8c1b67707d31f014a9344e5966bda~Grc3igwYb2251122511epsmtip1n; Fri, 17 Apr 2020 18:10:18 +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 , Kishon Vijay Abraham I Subject: [PATCH v6 07/10] phy: samsung-ufs: add UFS PHY driver for samsung SoC Date: Fri, 17 Apr 2020 23:29:41 +0530 Message-Id: <20200417175944.47189-8-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200417175944.47189-1-alim.akhtar@samsung.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Brightmail-Tracker: H4sIAAAAAAAAA01Se0hTURzm3NfuVovbLDwpGIyiXKRJWfcPs6Cy2wMq+icqqlve1Nyr3bSM oKFDzfkqwtzyEdYMjVLm1DF7rGWKGE7IqQuiRUm5bKSuZUWv7S7qv+/7ft93fuc7HBKVPcPj yBz1GU6nZpVyQoJ1PUlcsXr+tOnImhl/Gu1r6CLoya8egp5pa8bpxt4hnB6eKCdot7tdRHtt TzHa+mYUp5876gi61v0QoY1jdoK+3f8ToX/dt4toS6cXbF7APK+sQBhr6yWC6bh1kTEMPMKY 6YkXGFNpawVM/3g3wsxaE5gSpxHZKz4oScvklDn5nC45/Zgke3DOj2pbasE5/bcuQg9qLpYB MQmpddDc3ISWAQkpo3oArDcFEIHMAPjD1xslIQBNHidWBshI5ObtDEF/AODwl9e4QAwI7Pj0 GQufS1Cr4MtrNiSMF1ExsDdUDMImlCpEYdBSSIQHMdRe6A3N4WGMUcvhuMUSCUupNPgxZESF Cy6Fd9qdESymNsJigwURPAvhgOltxI/+8RR1Xo+UgFSzCHrK+0RCeCv0eXsQAcdAf78tqsfB 2cADQqiTC8sdawX5ArQ09GEC3gSdI3WRxiiVCNscycKqBbDi+1tESEphabFMcC+HRQFPNBkP LxuNuIAZ+N5UFX2fagBdBj1WDZaa/2tg/q+B+d+2GwBtBUs4La/K4vhU7Vo1dzaJZ1V8njor 6YRGZQWRP6bYZQfWod0uQJFAPl9aWmk6IsPZfL5A5QKQROWLpI8z/kjSTLbgPKfTHNXlKTne BeJJTB4rvYJ7DsuoLPYMl8txWk73d4qQ4jg9SK9us9+r2N4e3NaxONNxV/mjez9ftPJVYKTF F1vvuj8T9F/e42Vt7hT7L1YzmXra/LqgpnbLBvP0uakDipKTNe41SVO04k1qU/zBq46dx7dO bughSn2HQuuXyYeD74hTo5oPhzadLJ2XXDVLtljmdjyMza1ff7ZROzaYOJGSsC9fjvHZbIoC 1fHsb81YsDNfAwAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprPIsWRmVeSWpSXmKPExsWy7bCSnC7Px5lxBnevy1o8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJVx+scr5oKVMxgrGn5tY2tgnFbfxcjBISFgIrF4uVsXIxeH kMBuRokdy9vZuhg5geLSEtc3TmCHsIUlVv57DmYLCTQxSbzbYA5iswloS9ydvoUJxBYBqjny rY0RZBCzwARmieW/vjGCJIQF/CS+L7jJAmKzCKhK3Fi6FMzmFbCRePutmxligbzE6g0HwGxO AVuJtpalTCDHCQHVbHgSA1EuKHFy5hMWkDCzgLrE+nlCIGFmoM7mrbOZJzAKzkJSNQuhahaS qgWMzKsYJVMLinPTc4sNC4zyUsv1ihNzi0vz0vWS83M3MYKjTUtrB+OJE/GHGAU4GJV4eDv6 ZsYJsSaWFVfmHmKU4GBWEuE96AYU4k1JrKxKLcqPLyrNSS0+xCjNwaIkziuffyxSSCA9sSQ1 OzW1ILUIJsvEwSnVwDjhLl/grcWHjZeu3XU06vTssxzH2t0a62pm7vqfmSLY7Vf4bZWua+uX L5+vPc4+KsVi1Lq24NyPoI0da9vfSs3LreApPucm3Lln2axmp4/3IxfO4V60v8NHyWTVxfVi DxcuSZII0WI/u0TzrXvunPVV/ctW3pLlEZMR07oSt/SNoewbTVkHmddKLMUZiYZazEXFiQCQ vv3NsgIAAA== X-CMS-MailID: 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" CMS-TYPE: 105P X-CMS-RootMailID: 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249 References: <20200417175944.47189-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 Samsung UFS PHY driver. This driver supports to deal with phy calibration and power control according to UFS host driver's behavior. Reviewed-by: Kiwoong Kim Signed-off-by: Seungwon Jeon Signed-off-by: Alim Akhtar Cc: Kishon Vijay Abraham I Tested-by: Paweł Chmiel --- drivers/phy/samsung/Kconfig | 9 + drivers/phy/samsung/Makefile | 1 + drivers/phy/samsung/phy-exynos7-ufs.h | 85 ++++++ drivers/phy/samsung/phy-samsung-ufs.c | 369 ++++++++++++++++++++++++++ drivers/phy/samsung/phy-samsung-ufs.h | 142 ++++++++++ 5 files changed, 606 insertions(+) create mode 100644 drivers/phy/samsung/phy-exynos7-ufs.h create mode 100644 drivers/phy/samsung/phy-samsung-ufs.c create mode 100644 drivers/phy/samsung/phy-samsung-ufs.h diff --git a/drivers/phy/samsung/Kconfig b/drivers/phy/samsung/Kconfig index 9e483d1fdaf2..fc1e3c17f842 100644 --- a/drivers/phy/samsung/Kconfig +++ b/drivers/phy/samsung/Kconfig @@ -29,6 +29,15 @@ config PHY_EXYNOS_PCIE Enable PCIe PHY support for Exynos SoC series. This driver provides PHY interface for Exynos PCIe controller. +config PHY_SAMSUNG_UFS + tristate "SAMSUNG SoC series UFS PHY driver" + depends on OF && (ARCH_EXYNOS || COMPILE_TEST) + select GENERIC_PHY + help + Enable this to support the Samsung UFS PHY driver for + Samsung SoCs. This driver provides the interface for UFS + host controller to do PHY related programming. + config PHY_SAMSUNG_USB2 tristate "Samsung USB 2.0 PHY driver" depends on HAS_IOMEM diff --git a/drivers/phy/samsung/Makefile b/drivers/phy/samsung/Makefile index db9b1aa0de6e..3959100fe8a2 100644 --- a/drivers/phy/samsung/Makefile +++ b/drivers/phy/samsung/Makefile @@ -2,6 +2,7 @@ obj-$(CONFIG_PHY_EXYNOS_DP_VIDEO) += phy-exynos-dp-video.o obj-$(CONFIG_PHY_EXYNOS_MIPI_VIDEO) += phy-exynos-mipi-video.o obj-$(CONFIG_PHY_EXYNOS_PCIE) += phy-exynos-pcie.o +obj-$(CONFIG_PHY_SAMSUNG_UFS) += phy-samsung-ufs.o obj-$(CONFIG_PHY_SAMSUNG_USB2) += phy-exynos-usb2.o phy-exynos-usb2-y += phy-samsung-usb2.o phy-exynos-usb2-$(CONFIG_PHY_EXYNOS4210_USB2) += phy-exynos4210-usb2.o diff --git a/drivers/phy/samsung/phy-exynos7-ufs.h b/drivers/phy/samsung/phy-exynos7-ufs.h new file mode 100644 index 000000000000..da981c1ac040 --- /dev/null +++ b/drivers/phy/samsung/phy-exynos7-ufs.h @@ -0,0 +1,85 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * UFS PHY driver data for Samsung EXYNOS7 SoC + * + * Copyright (C) 2015 Samsung Electronics Co., Ltd. + */ +#ifndef _PHY_EXYNOS7_UFS_H_ +#define _PHY_EXYNOS7_UFS_H_ + +#include "phy-samsung-ufs.h" + +#define EXYNOS7_EMBEDDED_COMBO_PHY_CTRL 0x720 +#define EXYNOS7_EMBEDDED_COMBO_PHY_CTRL_MASK 0x1 +#define EXYNOS7_EMBEDDED_COMBO_PHY_CTRL_EN BIT(0) + +/* Calibration for phy initialization */ +static const struct samsung_ufs_phy_cfg exynos7_pre_init_cfg[] = { + PHY_COMN_REG_CFG(0x00f, 0xfa, PWR_MODE_ANY), + PHY_COMN_REG_CFG(0x010, 0x82, PWR_MODE_ANY), + PHY_COMN_REG_CFG(0x011, 0x1e, PWR_MODE_ANY), + PHY_COMN_REG_CFG(0x017, 0x84, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x035, 0x58, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x036, 0x32, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x037, 0x40, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x03b, 0x83, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x042, 0x88, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x043, 0xa6, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x048, 0x74, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x04c, 0x5b, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x04d, 0x83, PWR_MODE_ANY), + PHY_TRSV_REG_CFG(0x05c, 0x14, PWR_MODE_ANY), + END_UFS_PHY_CFG +}; + +static const struct samsung_ufs_phy_cfg exynos7_post_init_cfg[] = { + END_UFS_PHY_CFG +}; + +/* Calibration for HS mode series A/B */ +static const struct samsung_ufs_phy_cfg exynos7_pre_pwr_hs_cfg[] = { + PHY_COMN_REG_CFG(0x00f, 0xfa, PWR_MODE_HS_ANY), + PHY_COMN_REG_CFG(0x010, 0x82, PWR_MODE_HS_ANY), + PHY_COMN_REG_CFG(0x011, 0x1e, PWR_MODE_HS_ANY), + /* Setting order: 1st(0x16, 2nd(0x15) */ + PHY_COMN_REG_CFG(0x016, 0xff, PWR_MODE_HS_ANY), + PHY_COMN_REG_CFG(0x015, 0x80, PWR_MODE_HS_ANY), + PHY_COMN_REG_CFG(0x017, 0x94, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x036, 0x32, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x037, 0x43, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x038, 0x3f, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x042, 0x88, PWR_MODE_HS_G2_SER_A), + PHY_TRSV_REG_CFG(0x042, 0xbb, PWR_MODE_HS_G2_SER_B), + PHY_TRSV_REG_CFG(0x043, 0xa6, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x048, 0x74, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x034, 0x35, PWR_MODE_HS_G2_SER_A), + PHY_TRSV_REG_CFG(0x034, 0x36, PWR_MODE_HS_G2_SER_B), + PHY_TRSV_REG_CFG(0x035, 0x5b, PWR_MODE_HS_G2_SER_A), + PHY_TRSV_REG_CFG(0x035, 0x5c, PWR_MODE_HS_G2_SER_B), + END_UFS_PHY_CFG +}; + +/* Calibration for HS mode series A/B atfer PMC */ +static const struct samsung_ufs_phy_cfg exynos7_post_pwr_hs_cfg[] = { + PHY_COMN_REG_CFG(0x015, 0x00, PWR_MODE_HS_ANY), + PHY_TRSV_REG_CFG(0x04d, 0x83, PWR_MODE_HS_ANY), + END_UFS_PHY_CFG +}; + +static const struct samsung_ufs_phy_cfg *exynos7_ufs_phy_cfgs[CFG_TAG_MAX] = { + [CFG_PRE_INIT] = exynos7_pre_init_cfg, + [CFG_POST_INIT] = exynos7_post_init_cfg, + [CFG_PRE_PWR_HS] = exynos7_pre_pwr_hs_cfg, + [CFG_POST_PWR_HS] = exynos7_post_pwr_hs_cfg, +}; + +static struct samsung_ufs_phy_drvdata exynos7_ufs_phy = { + .cfg = exynos7_ufs_phy_cfgs, + .isol = { + .offset = EXYNOS7_EMBEDDED_COMBO_PHY_CTRL, + .mask = EXYNOS7_EMBEDDED_COMBO_PHY_CTRL_MASK, + .en = EXYNOS7_EMBEDDED_COMBO_PHY_CTRL_EN, + }, +}; + +#endif /* _PHY_EXYNOS7_UFS_H_ */ diff --git a/drivers/phy/samsung/phy-samsung-ufs.c b/drivers/phy/samsung/phy-samsung-ufs.c new file mode 100644 index 000000000000..4c8334bba3e9 --- /dev/null +++ b/drivers/phy/samsung/phy-samsung-ufs.c @@ -0,0 +1,369 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * UFS PHY driver for Samsung SoC + * + * Copyright (C) 2015 Samsung Electronics Co., Ltd. + * Author: Seungwon Jeon + * Author: Alim Akhtar + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "phy-samsung-ufs.h" + +#define for_each_phy_lane(phy, i) \ + for (i = 0; i < (phy)->lane_cnt; i++) +#define for_each_phy_cfg(cfg) \ + for (; (cfg)->id; (cfg)++) + +#define PHY_DEF_LANE_CNT 1 + +static void samsung_ufs_phy_config(struct samsung_ufs_phy *phy, + const struct samsung_ufs_phy_cfg *cfg, u8 lane) +{ + enum {LANE_0, LANE_1}; /* lane index */ + + switch (lane) { + case LANE_0: + writel(cfg->val, (phy)->reg_pma + cfg->off_0); + break; + case LANE_1: + if (cfg->id == PHY_TRSV_BLK) + writel(cfg->val, (phy)->reg_pma + cfg->off_1); + break; + } +} + +int samsung_ufs_phy_wait_for_lock_acq(struct phy *phy) +{ + struct samsung_ufs_phy *ufs_phy = get_samsung_ufs_phy(phy); + const unsigned int timeout_us = 100000; + const unsigned int sleep_us = 10; + u32 val; + int err; + + err = readl_poll_timeout( + ufs_phy->reg_pma + PHY_APB_ADDR(PHY_PLL_LOCK_STATUS), + val, (val & PHY_PLL_LOCK_BIT), sleep_us, timeout_us); + if (err) { + dev_err(ufs_phy->dev, + "failed to get phy pll lock acquisition %d\n", err); + goto out; + } + + err = readl_poll_timeout( + ufs_phy->reg_pma + PHY_APB_ADDR(PHY_CDR_LOCK_STATUS), + val, (val & PHY_CDR_LOCK_BIT), sleep_us, timeout_us); + if (err) { + dev_err(ufs_phy->dev, + "failed to get phy cdr lock acquisition %d\n", err); + goto out; + } + +out: + return err; +} + +int samsung_ufs_phy_calibrate(struct phy *phy) +{ + struct samsung_ufs_phy *ufs_phy = get_samsung_ufs_phy(phy); + struct samsung_ufs_phy_cfg **cfgs = ufs_phy->cfg; + const struct samsung_ufs_phy_cfg *cfg; + int i; + int err = 0; + + if (unlikely(ufs_phy->ufs_phy_state < CFG_PRE_INIT || + ufs_phy->ufs_phy_state >= CFG_TAG_MAX)) { + dev_err(ufs_phy->dev, "invalid phy config index %d\n", + ufs_phy->ufs_phy_state); + return -EINVAL; + } + + if (ufs_phy->is_pre_init) + ufs_phy->is_pre_init = false; + if (ufs_phy->is_post_init) { + ufs_phy->is_post_init = false; + ufs_phy->ufs_phy_state = CFG_POST_INIT; + } + if (ufs_phy->is_pre_pmc) { + ufs_phy->is_pre_pmc = false; + ufs_phy->ufs_phy_state = CFG_PRE_PWR_HS; + } + if (ufs_phy->is_post_pmc) { + ufs_phy->is_post_pmc = false; + ufs_phy->ufs_phy_state = CFG_POST_PWR_HS; + } + + switch (ufs_phy->ufs_phy_state) { + case CFG_PRE_INIT: + ufs_phy->is_post_init = true; + break; + case CFG_POST_INIT: + ufs_phy->is_pre_pmc = true; + break; + case CFG_PRE_PWR_HS: + ufs_phy->is_post_pmc = true; + break; + case CFG_POST_PWR_HS: + break; + default: + dev_err(ufs_phy->dev, "wrong state for phy calibration\n"); + } + + cfg = cfgs[ufs_phy->ufs_phy_state]; + if (!cfg) + goto out; + + for_each_phy_cfg(cfg) { + for_each_phy_lane(ufs_phy, i) { + samsung_ufs_phy_config(ufs_phy, cfg, i); + } + } + + if (ufs_phy->ufs_phy_state == CFG_POST_PWR_HS) + err = samsung_ufs_phy_wait_for_lock_acq(phy); +out: + return err; +} + +static int samsung_ufs_phy_symbol_clk_init(struct samsung_ufs_phy *phy) +{ + struct clk *clk; + int ret = 0; + + clk = devm_clk_get(phy->dev, "tx0_symbol_clk"); + if (IS_ERR(clk)) { + dev_err(phy->dev, "failed to get tx0_symbol_clk clock\n"); + goto out; + } else { + phy->tx0_symbol_clk = clk; + } + + clk = devm_clk_get(phy->dev, "rx0_symbol_clk"); + if (IS_ERR(clk)) { + dev_err(phy->dev, "failed to get rx0_symbol_clk clock\n"); + goto out; + } else { + phy->rx0_symbol_clk = clk; + } + + clk = devm_clk_get(phy->dev, "rx1_symbol_clk"); + if (IS_ERR(clk)) { + dev_err(phy->dev, "failed to get rx1_symbol_clk clock\n"); + goto out; + } else { + phy->rx1_symbol_clk = clk; + } + + ret = clk_prepare_enable(phy->tx0_symbol_clk); + if (ret) { + dev_err(phy->dev, "%s: tx0_symbol_clk enable failed %d\n", + __func__, ret); + goto out; + } + ret = clk_prepare_enable(phy->rx0_symbol_clk); + if (ret) { + dev_err(phy->dev, "%s: rx0_symbol_clk enable failed %d\n", + __func__, ret); + goto out; + } + ret = clk_prepare_enable(phy->rx1_symbol_clk); + if (ret) { + dev_err(phy->dev, "%s: rx1_symbol_clk enable failed %d\n", + __func__, ret); + goto out; + } +out: + return ret; +} + +static int samsung_ufs_phy_clks_init(struct samsung_ufs_phy *phy) +{ + struct clk *phy_ref_clk; + int ret; + + phy_ref_clk = devm_clk_get(phy->dev, "ref_clk"); + if (IS_ERR(phy_ref_clk)) + dev_err(phy->dev, "failed to get ref_clk clock\n"); + else + phy->ref_clk = phy_ref_clk; + + ret = clk_prepare_enable(phy->ref_clk); + if (ret) { + dev_err(phy->dev, "%s: ref_clk enable failed %d\n", + __func__, ret); + return ret; + } + + dev_info(phy->dev, "UFS MPHY ref_clk_rate = %ld\n", clk_get_rate(phy_ref_clk)); + + return 0; +} + +static int samsung_ufs_phy_init(struct phy *phy) +{ + struct samsung_ufs_phy *_phy = get_samsung_ufs_phy(phy); + int ret; + + _phy->lane_cnt = phy->attrs.bus_width; + _phy->ufs_phy_state = CFG_PRE_INIT; + + _phy->is_pre_init = true; + _phy->is_post_init = false; + _phy->is_pre_pmc = false; + _phy->is_post_pmc = false; + + + if (of_device_is_compatible(_phy->dev->of_node, + "samsung,exynos7-ufs-phy")) { + ret = samsung_ufs_phy_symbol_clk_init(_phy); + if (ret) + dev_err(_phy->dev, + "failed to set ufs phy symbol clocks\n"); + } + + ret = samsung_ufs_phy_clks_init(_phy); + if (ret) + dev_err(_phy->dev, "failed to set ufs phy clocks\n"); + + samsung_ufs_phy_calibrate(phy); + + return 0; +} + +static int samsung_ufs_phy_power_on(struct phy *phy) +{ + struct samsung_ufs_phy *_phy = get_samsung_ufs_phy(phy); + + samsung_ufs_phy_ctrl_isol(_phy, false); + return 0; +} + +static int samsung_ufs_phy_power_off(struct phy *phy) +{ + struct samsung_ufs_phy *_phy = get_samsung_ufs_phy(phy); + + samsung_ufs_phy_ctrl_isol(_phy, true); + clk_disable_unprepare(_phy->ref_clk); + return 0; +} + +static int samsung_ufs_phy_set_mode(struct phy *generic_phy, + enum phy_mode mode, int submode) +{ + struct samsung_ufs_phy *_phy = get_samsung_ufs_phy(generic_phy); + + _phy->mode = PHY_MODE_INVALID; + + if (mode > 0) + _phy->mode = mode; + + return 0; +} + +static struct phy_ops samsung_ufs_phy_ops = { + .init = samsung_ufs_phy_init, + .power_on = samsung_ufs_phy_power_on, + .power_off = samsung_ufs_phy_power_off, + .calibrate = samsung_ufs_phy_calibrate, + .set_mode = samsung_ufs_phy_set_mode, +} +; +static const struct of_device_id samsung_ufs_phy_match[]; + +static int samsung_ufs_phy_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct resource *res; + const struct of_device_id *match; + struct samsung_ufs_phy *phy; + struct phy *gen_phy; + struct phy_provider *phy_provider; + const struct samsung_ufs_phy_drvdata *drvdata; + int err = 0; + + match = of_match_node(samsung_ufs_phy_match, dev->of_node); + if (!match) { + err = -EINVAL; + dev_err(dev, "failed to get match_node\n"); + goto out; + } + + phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL); + if (!phy) { + err = -ENOMEM; + goto out; + } + + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phy-pma"); + phy->reg_pma = devm_ioremap_resource(dev, res); + if (IS_ERR(phy->reg_pma)) { + err = PTR_ERR(phy->reg_pma); + goto out; + } + + phy->reg_pmu = syscon_regmap_lookup_by_phandle( + dev->of_node, "samsung,pmu-syscon"); + if (IS_ERR(phy->reg_pmu)) { + err = PTR_ERR(phy->reg_pmu); + dev_err(dev, "failed syscon remap for pmu\n"); + goto out; + } + + gen_phy = devm_phy_create(dev, NULL, &samsung_ufs_phy_ops); + if (IS_ERR(gen_phy)) { + err = PTR_ERR(gen_phy); + dev_err(dev, "failed to create PHY for ufs-phy\n"); + goto out; + } + + drvdata = match->data; + phy->dev = dev; + phy->drvdata = drvdata; + phy->cfg = (struct samsung_ufs_phy_cfg **)drvdata->cfg; + phy->isol = &drvdata->isol; + phy->lane_cnt = PHY_DEF_LANE_CNT; + + phy_set_drvdata(gen_phy, phy); + + phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); + if (IS_ERR(phy_provider)) { + err = PTR_ERR(phy_provider); + dev_err(dev, "failed to register phy-provider\n"); + goto out; + } +out: + return err; +} + +static const struct of_device_id samsung_ufs_phy_match[] = { + { + .compatible = "samsung,exynos7-ufs-phy", + .data = &exynos7_ufs_phy, + }, + {}, +}; +MODULE_DEVICE_TABLE(of, samsung_ufs_phy_match); + +static struct platform_driver samsung_ufs_phy_driver = { + .probe = samsung_ufs_phy_probe, + .driver = { + .name = "samsung-ufs-phy", + .of_match_table = samsung_ufs_phy_match, + }, +}; +module_platform_driver(samsung_ufs_phy_driver); +MODULE_DESCRIPTION("Samsung SoC UFS PHY Driver"); +MODULE_AUTHOR("Seungwon Jeon "); +MODULE_AUTHOR("Alim Akhtar "); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/phy/samsung/phy-samsung-ufs.h b/drivers/phy/samsung/phy-samsung-ufs.h new file mode 100644 index 000000000000..27dc1b573469 --- /dev/null +++ b/drivers/phy/samsung/phy-samsung-ufs.h @@ -0,0 +1,142 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * UFS PHY driver for Samsung EXYNOS SoC + * + * Copyright (C) 2015 Samsung Electronics Co., Ltd. + * Author: Seungwon Jeon + * Author: Alim Akhtar + * + */ +#ifndef _PHY_SAMSUNG_UFS_ +#define _PHY_SAMSUNG_UFS_ + +#define PHY_COMN_BLK 1 +#define PHY_TRSV_BLK 2 +#define END_UFS_PHY_CFG { 0 } +#define PHY_TRSV_CH_OFFSET 0x30 +#define PHY_APB_ADDR(off) ((off) << 2) + +#define PHY_COMN_REG_CFG(o, v, d) { \ + .off_0 = PHY_APB_ADDR((o)), \ + .off_1 = 0, \ + .val = (v), \ + .desc = (d), \ + .id = PHY_COMN_BLK, \ +} + +#define PHY_TRSV_REG_CFG(o, v, d) { \ + .off_0 = PHY_APB_ADDR((o)), \ + .off_1 = PHY_APB_ADDR((o) + PHY_TRSV_CH_OFFSET), \ + .val = (v), \ + .desc = (d), \ + .id = PHY_TRSV_BLK, \ +} + +/* UFS PHY registers */ +#define PHY_PLL_LOCK_STATUS 0x1e +#define PHY_CDR_LOCK_STATUS 0x5e + +#define PHY_PLL_LOCK_BIT BIT(5) +#define PHY_CDR_LOCK_BIT BIT(4) + +/* description for PHY calibration */ +enum { + /* applicable to any */ + PWR_DESC_ANY = 0, + /* mode */ + PWR_DESC_PWM = 1, + PWR_DESC_HS = 2, + /* series */ + PWR_DESC_SER_A = 1, + PWR_DESC_SER_B = 2, + /* gear */ + PWR_DESC_G1 = 1, + PWR_DESC_G2 = 2, + PWR_DESC_G3 = 3, + /* field mask */ + MD_MASK = 0x3, + SR_MASK = 0x3, + GR_MASK = 0x7, +}; + +#define PWR_MODE_HS_G1_ANY PWR_MODE_HS(PWR_DESC_G1, PWR_DESC_ANY) +#define PWR_MODE_HS_G1_SER_A PWR_MODE_HS(PWR_DESC_G1, PWR_DESC_SER_A) +#define PWR_MODE_HS_G1_SER_B PWR_MODE_HS(PWR_DESC_G1, PWR_DESC_SER_B) +#define PWR_MODE_HS_G2_ANY PWR_MODE_HS(PWR_DESC_G2, PWR_DESC_ANY) +#define PWR_MODE_HS_G2_SER_A PWR_MODE_HS(PWR_DESC_G2, PWR_DESC_SER_A) +#define PWR_MODE_HS_G2_SER_B PWR_MODE_HS(PWR_DESC_G2, PWR_DESC_SER_B) +#define PWR_MODE_HS_G3_ANY PWR_MODE_HS(PWR_DESC_G3, PWR_DESC_ANY) +#define PWR_MODE_HS_G3_SER_A PWR_MODE_HS(PWR_DESC_G3, PWR_DESC_SER_A) +#define PWR_MODE_HS_G3_SER_B PWR_MODE_HS(PWR_DESC_G3, PWR_DESC_SER_B) +#define PWR_MODE(g, s, m) ((((g) & GR_MASK) << 4) |\ + (((s) & SR_MASK) << 2) | ((m) & MD_MASK)) +#define PWR_MODE_PWM_ANY PWR_MODE(PWR_DESC_ANY,\ + PWR_DESC_ANY, PWR_DESC_PWM) +#define PWR_MODE_HS(g, s) ((((g) & GR_MASK) << 4) |\ + (((s) & SR_MASK) << 2) | PWR_DESC_HS) +#define PWR_MODE_HS_ANY PWR_MODE(PWR_DESC_ANY,\ + PWR_DESC_ANY, PWR_DESC_HS) +#define PWR_MODE_ANY PWR_MODE(PWR_DESC_ANY,\ + PWR_DESC_ANY, PWR_DESC_ANY) +/* PHY calibration point/state */ +enum { + CFG_PRE_INIT, + CFG_POST_INIT, + CFG_PRE_PWR_HS, + CFG_POST_PWR_HS, + CFG_TAG_MAX, +}; + +struct samsung_ufs_phy_cfg { + u32 off_0; + u32 off_1; + u32 val; + u8 desc; + u8 id; +}; + +struct samsung_ufs_phy_drvdata { + const struct samsung_ufs_phy_cfg **cfg; + struct pmu_isol { + u32 offset; + u32 mask; + u32 en; + } isol; +}; + +struct samsung_ufs_phy { + struct device *dev; + void __iomem *reg_pma; + struct regmap *reg_pmu; + struct clk *ref_clk; + struct clk *ref_clk_parent; + struct clk *tx0_symbol_clk; + struct clk *rx0_symbol_clk; + struct clk *rx1_symbol_clk; + const struct samsung_ufs_phy_drvdata *drvdata; + struct samsung_ufs_phy_cfg **cfg; + const struct pmu_isol *isol; + u8 lane_cnt; + int ufs_phy_state; + enum phy_mode mode; + bool is_pre_init; + bool is_post_init; + bool is_pre_pmc; + bool is_post_pmc; +}; + +static inline struct samsung_ufs_phy *get_samsung_ufs_phy(struct phy *phy) +{ + return (struct samsung_ufs_phy *)phy_get_drvdata(phy); +} + +static inline void samsung_ufs_phy_ctrl_isol( + struct samsung_ufs_phy *phy, u32 isol) +{ + regmap_update_bits(phy->reg_pmu, phy->isol->offset, + phy->isol->mask, isol ? 0 : phy->isol->en); +} + +#include "phy-exynos7-ufs.h" + +#endif /* _PHY_SAMSUNG_UFS_ */ -- 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 9A5C3C2D0EF for ; Fri, 17 Apr 2020 18:12:37 +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 5514422202 for ; Fri, 17 Apr 2020 18:12: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="QcX/VW2i"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="ogSixwMi" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5514422202 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=ATIVBgddX7G1/pep9EidnWUHA9HWmgV3Xqj6uY9fheE=; b=QcX/VW2iTMjxR5 Ux1laJN8QDPE665BdO21/kVrNA1wb7m9Hi5hZGOW62RqMaNpei6KM3LRQqJvaX6y0CWaG00UEwLxG JdkiUgVYzQzG7D+EYLfQAm3QFz7wWVKS4kLS39eGq+wt2IDKpUkZPji0kj3LptT47vPkGRBiYZdFd EjD/s6tZdrVou31n2PfA55Ni8R7VN2zkZuzywBBX+/fyeWXmLit+J51+om7upxODzIhvQn4ijedAB up+EhqklJ/Tz8kMrOEqNPQhRMXzLMneqLQwmdbq0dGxoFyreaERUxRHVF+Fpd66tf4l5VohtF4Ff6 eljKX2xezS0w9kSJ6sCQ==; 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 1jPVTe-00030M-RV; Fri, 17 Apr 2020 18:12:34 +0000 Received: from mailout4.samsung.com ([203.254.224.34]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jPVRY-00014o-RU for linux-arm-kernel@lists.infradead.org; Fri, 17 Apr 2020 18:10:28 +0000 Received: from epcas5p1.samsung.com (unknown [182.195.41.39]) by mailout4.samsung.com (KnoxPortal) with ESMTP id 20200417181022epoutp0438776c4dbe0de0212525af12ef4ec7cd~Grc7ERFqz1452214522epoutp04R for ; Fri, 17 Apr 2020 18:10:22 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout4.samsung.com 20200417181022epoutp0438776c4dbe0de0212525af12ef4ec7cd~Grc7ERFqz1452214522epoutp04R DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1587147022; bh=jkpBVnMapPYgnP/AWNxgzOKgM7k0/ctDUDDMnmkJf0Y=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ogSixwMicbpj3On0Lg7BAPygqq71fc7ybsS7Aa8skmNawGkYkIjTZQR0IcA+rCQOF OsrfOSqsODleHddXFc4qVCBrnzGDtM9bzE9iGJVfAB2liDhCYqoaBPYICTMK+Cve2o eoJHdOirTqIi9be2uovjWRCOqoOCPe8tmoFFOh4Q= Received: from epsmges5p3new.samsung.com (unknown [182.195.42.75]) by epcas5p4.samsung.com (KnoxPortal) with ESMTP id 20200417181021epcas5p40d9ecc4dcce9e61c2311c405bb21ec0e~Grc5-XugE1060310603epcas5p4w; Fri, 17 Apr 2020 18:10:21 +0000 (GMT) Received: from epcas5p1.samsung.com ( [182.195.41.39]) by epsmges5p3new.samsung.com (Symantec Messaging Gateway) with SMTP id EA.0B.04736.C01F99E5; Sat, 18 Apr 2020 03:10:20 +0900 (KST) Received: from epsmtrp2.samsung.com (unknown [182.195.40.14]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPA id 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249~Grc5guiL-0105401054epcas5p27; Fri, 17 Apr 2020 18:10:20 +0000 (GMT) Received: from epsmgms1p2new.samsung.com (unknown [182.195.42.42]) by epsmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200417181020epsmtrp289b5431e6fd5038d86523130fde4f591~Grc5f20PN1925319253epsmtrp2F; Fri, 17 Apr 2020 18:10:20 +0000 (GMT) X-AuditID: b6c32a4b-acbff70000001280-5f-5e99f10c7fdb Received: from epsmtip1.samsung.com ( [182.195.34.30]) by epsmgms1p2new.samsung.com (Symantec Messaging Gateway) with SMTP id 75.DE.04158.C01F99E5; Sat, 18 Apr 2020 03:10:20 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200417181018epsmtip12fc8c1b67707d31f014a9344e5966bda~Grc3igwYb2251122511epsmtip1n; Fri, 17 Apr 2020 18:10:18 +0000 (GMT) From: Alim Akhtar To: robh@kernel.org Subject: [PATCH v6 07/10] phy: samsung-ufs: add UFS PHY driver for samsung SoC Date: Fri, 17 Apr 2020 23:29:41 +0530 Message-Id: <20200417175944.47189-8-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200417175944.47189-1-alim.akhtar@samsung.com> MIME-Version: 1.0 X-Brightmail-Tracker: H4sIAAAAAAAAA01Se0hTURzm3NfuVovbLDwpGIyiXKRJWfcPs6Cy2wMq+icqqlve1Nyr3bSM oKFDzfkqwtzyEdYMjVLm1DF7rGWKGE7IqQuiRUm5bKSuZUWv7S7qv+/7ft93fuc7HBKVPcPj yBz1GU6nZpVyQoJ1PUlcsXr+tOnImhl/Gu1r6CLoya8egp5pa8bpxt4hnB6eKCdot7tdRHtt TzHa+mYUp5876gi61v0QoY1jdoK+3f8ToX/dt4toS6cXbF7APK+sQBhr6yWC6bh1kTEMPMKY 6YkXGFNpawVM/3g3wsxaE5gSpxHZKz4oScvklDn5nC45/Zgke3DOj2pbasE5/bcuQg9qLpYB MQmpddDc3ISWAQkpo3oArDcFEIHMAPjD1xslIQBNHidWBshI5ObtDEF/AODwl9e4QAwI7Pj0 GQufS1Cr4MtrNiSMF1ExsDdUDMImlCpEYdBSSIQHMdRe6A3N4WGMUcvhuMUSCUupNPgxZESF Cy6Fd9qdESymNsJigwURPAvhgOltxI/+8RR1Xo+UgFSzCHrK+0RCeCv0eXsQAcdAf78tqsfB 2cADQqiTC8sdawX5ArQ09GEC3gSdI3WRxiiVCNscycKqBbDi+1tESEphabFMcC+HRQFPNBkP LxuNuIAZ+N5UFX2fagBdBj1WDZaa/2tg/q+B+d+2GwBtBUs4La/K4vhU7Vo1dzaJZ1V8njor 6YRGZQWRP6bYZQfWod0uQJFAPl9aWmk6IsPZfL5A5QKQROWLpI8z/kjSTLbgPKfTHNXlKTne BeJJTB4rvYJ7DsuoLPYMl8txWk73d4qQ4jg9SK9us9+r2N4e3NaxONNxV/mjez9ftPJVYKTF F1vvuj8T9F/e42Vt7hT7L1YzmXra/LqgpnbLBvP0uakDipKTNe41SVO04k1qU/zBq46dx7dO bughSn2HQuuXyYeD74hTo5oPhzadLJ2XXDVLtljmdjyMza1ff7ZROzaYOJGSsC9fjvHZbIoC 1fHsb81YsDNfAwAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprPIsWRmVeSWpSXmKPExsWy7bCSnC7Px5lxBnevy1o8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJVx+scr5oKVMxgrGn5tY2tgnFbfxcjBISFgIrF4uVsXIxeH kMBuRokdy9vZuhg5geLSEtc3TmCHsIUlVv57DmYLCTQxSbzbYA5iswloS9ydvoUJxBYBqjny rY0RZBCzwARmieW/vjGCJIQF/CS+L7jJAmKzCKhK3Fi6FMzmFbCRePutmxligbzE6g0HwGxO AVuJtpalTCDHCQHVbHgSA1EuKHFy5hMWkDCzgLrE+nlCIGFmoM7mrbOZJzAKzkJSNQuhahaS qgWMzKsYJVMLinPTc4sNC4zyUsv1ihNzi0vz0vWS83M3MYKjTUtrB+OJE/GHGAU4GJV4eDv6 ZsYJsSaWFVfmHmKU4GBWEuE96AYU4k1JrKxKLcqPLyrNSS0+xCjNwaIkziuffyxSSCA9sSQ1 OzW1ILUIJsvEwSnVwDjhLl/grcWHjZeu3XU06vTssxzH2t0a62pm7vqfmSLY7Vf4bZWua+uX L5+vPc4+KsVi1Lq24NyPoI0da9vfSs3LreApPucm3Lln2axmp4/3IxfO4V60v8NHyWTVxfVi DxcuSZII0WI/u0TzrXvunPVV/ctW3pLlEZMR07oSt/SNoewbTVkHmddKLMUZiYZazEXFiQCQ vv3NsgIAAA== X-CMS-MailID: 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249 X-Msg-Generator: CA CMS-TYPE: 105P X-CMS-RootMailID: 20200417181020epcas5p2121f17c89634d6ad8f30258339a6b249 References: <20200417175944.47189-1-alim.akhtar@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200417_111025_272170_9484481A X-CRM114-Status: GOOD ( 22.07 ) 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, Kishon Vijay Abraham I , 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 VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIFNhbXN1bmcgVUZTIFBIWSBkcml2ZXIuIFRoaXMgZHJpdmVy CnN1cHBvcnRzIHRvIGRlYWwgd2l0aCBwaHkgY2FsaWJyYXRpb24gYW5kIHBvd2VyIGNvbnRyb2wK YWNjb3JkaW5nIHRvIFVGUyBob3N0IGRyaXZlcidzIGJlaGF2aW9yLgoKUmV2aWV3ZWQtYnk6IEtp d29vbmcgS2ltIDxrd21hZC5raW1Ac2Ftc3VuZy5jb20+ClNpZ25lZC1vZmYtYnk6IFNldW5nd29u IEplb24gPGVzc3V1akBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IEFsaW0gQWtodGFyIDxhbGlt LmFraHRhckBzYW1zdW5nLmNvbT4KQ2M6IEtpc2hvbiBWaWpheSBBYnJhaGFtIEkgPGtpc2hvbkB0 aS5jb20+ClRlc3RlZC1ieTogUGF3ZcWCIENobWllbCA8cGF3ZWwubWlrb2xhai5jaG1pZWxAZ21h aWwuY29tPgotLS0KIGRyaXZlcnMvcGh5L3NhbXN1bmcvS2NvbmZpZyAgICAgICAgICAgfCAgIDkg KwogZHJpdmVycy9waHkvc2Ftc3VuZy9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJz L3BoeS9zYW1zdW5nL3BoeS1leHlub3M3LXVmcy5oIHwgIDg1ICsrKysrKwogZHJpdmVycy9waHkv c2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuYyB8IDM2OSArKysrKysrKysrKysrKysrKysrKysrKysr KwogZHJpdmVycy9waHkvc2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuaCB8IDE0MiArKysrKysrKysr CiA1IGZpbGVzIGNoYW5nZWQsIDYwNiBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9waHkvc2Ftc3VuZy9waHktZXh5bm9zNy11ZnMuaAogY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvcGh5L3NhbXN1bmcvcGh5LXNhbXN1bmctdWZzLmMKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1zYW1zdW5nLXVmcy5oCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9waHkvc2Ftc3VuZy9LY29uZmlnIGIvZHJpdmVycy9waHkvc2Ftc3VuZy9LY29uZmlnCmlu ZGV4IDllNDgzZDFmZGFmMi4uZmMxZTNjMTdmODQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BoeS9z YW1zdW5nL0tjb25maWcKKysrIGIvZHJpdmVycy9waHkvc2Ftc3VuZy9LY29uZmlnCkBAIC0yOSw2 ICsyOSwxNSBAQCBjb25maWcgUEhZX0VYWU5PU19QQ0lFCiAJICBFbmFibGUgUENJZSBQSFkgc3Vw cG9ydCBmb3IgRXh5bm9zIFNvQyBzZXJpZXMuCiAJICBUaGlzIGRyaXZlciBwcm92aWRlcyBQSFkg aW50ZXJmYWNlIGZvciBFeHlub3MgUENJZSBjb250cm9sbGVyLgogCitjb25maWcgUEhZX1NBTVNV TkdfVUZTCisJdHJpc3RhdGUgIlNBTVNVTkcgU29DIHNlcmllcyBVRlMgUEhZIGRyaXZlciIKKwlk ZXBlbmRzIG9uIE9GICYmIChBUkNIX0VYWU5PUyB8fCBDT01QSUxFX1RFU1QpCisJc2VsZWN0IEdF TkVSSUNfUEhZCisJaGVscAorCSAgRW5hYmxlIHRoaXMgdG8gc3VwcG9ydCB0aGUgU2Ftc3VuZyBV RlMgUEhZIGRyaXZlciBmb3IKKwkgIFNhbXN1bmcgU29Dcy4gVGhpcyBkcml2ZXIgcHJvdmlkZXMg dGhlIGludGVyZmFjZSBmb3IgVUZTCisJICBob3N0IGNvbnRyb2xsZXIgdG8gZG8gUEhZIHJlbGF0 ZWQgcHJvZ3JhbW1pbmcuCisKIGNvbmZpZyBQSFlfU0FNU1VOR19VU0IyCiAJdHJpc3RhdGUgIlNh bXN1bmcgVVNCIDIuMCBQSFkgZHJpdmVyIgogCWRlcGVuZHMgb24gSEFTX0lPTUVNCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3BoeS9zYW1zdW5nL01ha2VmaWxlIGIvZHJpdmVycy9waHkvc2Ftc3VuZy9N YWtlZmlsZQppbmRleCBkYjliMWFhMGRlNmUuLjM5NTkxMDBmZThhMiAxMDA2NDQKLS0tIGEvZHJp dmVycy9waHkvc2Ftc3VuZy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3BoeS9zYW1zdW5nL01ha2Vm aWxlCkBAIC0yLDYgKzIsNyBAQAogb2JqLSQoQ09ORklHX1BIWV9FWFlOT1NfRFBfVklERU8pCSs9 IHBoeS1leHlub3MtZHAtdmlkZW8ubwogb2JqLSQoQ09ORklHX1BIWV9FWFlOT1NfTUlQSV9WSURF TykJKz0gcGh5LWV4eW5vcy1taXBpLXZpZGVvLm8KIG9iai0kKENPTkZJR19QSFlfRVhZTk9TX1BD SUUpCQkrPSBwaHktZXh5bm9zLXBjaWUubworb2JqLSQoQ09ORklHX1BIWV9TQU1TVU5HX1VGUykJ CSs9IHBoeS1zYW1zdW5nLXVmcy5vCiBvYmotJChDT05GSUdfUEhZX1NBTVNVTkdfVVNCMikJCSs9 IHBoeS1leHlub3MtdXNiMi5vCiBwaHktZXh5bm9zLXVzYjIteQkJCSs9IHBoeS1zYW1zdW5nLXVz YjIubwogcGh5LWV4eW5vcy11c2IyLSQoQ09ORklHX1BIWV9FWFlOT1M0MjEwX1VTQjIpCSs9IHBo eS1leHlub3M0MjEwLXVzYjIubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvc2Ftc3VuZy9waHkt ZXh5bm9zNy11ZnMuaCBiL2RyaXZlcnMvcGh5L3NhbXN1bmcvcGh5LWV4eW5vczctdWZzLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5kYTk4MWMxYWMwNDAKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1leHlub3M3LXVmcy5oCkBAIC0w LDAgKzEsODUgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8K Ky8qCisgKiBVRlMgUEhZIGRyaXZlciBkYXRhIGZvciBTYW1zdW5nIEVYWU5PUzcgU29DCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDE1IFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKi8K KyNpZm5kZWYgX1BIWV9FWFlOT1M3X1VGU19IXworI2RlZmluZSBfUEhZX0VYWU5PUzdfVUZTX0hf CisKKyNpbmNsdWRlICJwaHktc2Ftc3VuZy11ZnMuaCIKKworI2RlZmluZSBFWFlOT1M3X0VNQkVE REVEX0NPTUJPX1BIWV9DVFJMCTB4NzIwCisjZGVmaW5lIEVYWU5PUzdfRU1CRURERURfQ09NQk9f UEhZX0NUUkxfTUFTSwkweDEKKyNkZWZpbmUgRVhZTk9TN19FTUJFRERFRF9DT01CT19QSFlfQ1RS TF9FTglCSVQoMCkKKworLyogQ2FsaWJyYXRpb24gZm9yIHBoeSBpbml0aWFsaXphdGlvbiAqLwor c3RhdGljIGNvbnN0IHN0cnVjdCBzYW1zdW5nX3Vmc19waHlfY2ZnIGV4eW5vczdfcHJlX2luaXRf Y2ZnW10gPSB7CisJUEhZX0NPTU5fUkVHX0NGRygweDAwZiwgMHhmYSwgUFdSX01PREVfQU5ZKSwK KwlQSFlfQ09NTl9SRUdfQ0ZHKDB4MDEwLCAweDgyLCBQV1JfTU9ERV9BTlkpLAorCVBIWV9DT01O X1JFR19DRkcoMHgwMTEsIDB4MWUsIFBXUl9NT0RFX0FOWSksCisJUEhZX0NPTU5fUkVHX0NGRygw eDAxNywgMHg4NCwgUFdSX01PREVfQU5ZKSwKKwlQSFlfVFJTVl9SRUdfQ0ZHKDB4MDM1LCAweDU4 LCBQV1JfTU9ERV9BTlkpLAorCVBIWV9UUlNWX1JFR19DRkcoMHgwMzYsIDB4MzIsIFBXUl9NT0RF X0FOWSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDAzNywgMHg0MCwgUFdSX01PREVfQU5ZKSwKKwlQ SFlfVFJTVl9SRUdfQ0ZHKDB4MDNiLCAweDgzLCBQV1JfTU9ERV9BTlkpLAorCVBIWV9UUlNWX1JF R19DRkcoMHgwNDIsIDB4ODgsIFBXUl9NT0RFX0FOWSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDA0 MywgMHhhNiwgUFdSX01PREVfQU5ZKSwKKwlQSFlfVFJTVl9SRUdfQ0ZHKDB4MDQ4LCAweDc0LCBQ V1JfTU9ERV9BTlkpLAorCVBIWV9UUlNWX1JFR19DRkcoMHgwNGMsIDB4NWIsIFBXUl9NT0RFX0FO WSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDA0ZCwgMHg4MywgUFdSX01PREVfQU5ZKSwKKwlQSFlf VFJTVl9SRUdfQ0ZHKDB4MDVjLCAweDE0LCBQV1JfTU9ERV9BTlkpLAorCUVORF9VRlNfUEhZX0NG RworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBzYW1zdW5nX3Vmc19waHlfY2ZnIGV4eW5vczdf cG9zdF9pbml0X2NmZ1tdID0geworCUVORF9VRlNfUEhZX0NGRworfTsKKworLyogQ2FsaWJyYXRp b24gZm9yIEhTIG1vZGUgc2VyaWVzIEEvQiAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBzYW1zdW5n X3Vmc19waHlfY2ZnIGV4eW5vczdfcHJlX3B3cl9oc19jZmdbXSA9IHsKKwlQSFlfQ09NTl9SRUdf Q0ZHKDB4MDBmLCAweGZhLCBQV1JfTU9ERV9IU19BTlkpLAorCVBIWV9DT01OX1JFR19DRkcoMHgw MTAsIDB4ODIsIFBXUl9NT0RFX0hTX0FOWSksCisJUEhZX0NPTU5fUkVHX0NGRygweDAxMSwgMHgx ZSwgUFdSX01PREVfSFNfQU5ZKSwKKwkvKiBTZXR0aW5nIG9yZGVyOiAxc3QoMHgxNiwgMm5kKDB4 MTUpICovCisJUEhZX0NPTU5fUkVHX0NGRygweDAxNiwgMHhmZiwgUFdSX01PREVfSFNfQU5ZKSwK KwlQSFlfQ09NTl9SRUdfQ0ZHKDB4MDE1LCAweDgwLCBQV1JfTU9ERV9IU19BTlkpLAorCVBIWV9D T01OX1JFR19DRkcoMHgwMTcsIDB4OTQsIFBXUl9NT0RFX0hTX0FOWSksCisJUEhZX1RSU1ZfUkVH X0NGRygweDAzNiwgMHgzMiwgUFdSX01PREVfSFNfQU5ZKSwKKwlQSFlfVFJTVl9SRUdfQ0ZHKDB4 MDM3LCAweDQzLCBQV1JfTU9ERV9IU19BTlkpLAorCVBIWV9UUlNWX1JFR19DRkcoMHgwMzgsIDB4 M2YsIFBXUl9NT0RFX0hTX0FOWSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDA0MiwgMHg4OCwgUFdS X01PREVfSFNfRzJfU0VSX0EpLAorCVBIWV9UUlNWX1JFR19DRkcoMHgwNDIsIDB4YmIsIFBXUl9N T0RFX0hTX0cyX1NFUl9CKSwKKwlQSFlfVFJTVl9SRUdfQ0ZHKDB4MDQzLCAweGE2LCBQV1JfTU9E RV9IU19BTlkpLAorCVBIWV9UUlNWX1JFR19DRkcoMHgwNDgsIDB4NzQsIFBXUl9NT0RFX0hTX0FO WSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDAzNCwgMHgzNSwgUFdSX01PREVfSFNfRzJfU0VSX0Ep LAorCVBIWV9UUlNWX1JFR19DRkcoMHgwMzQsIDB4MzYsIFBXUl9NT0RFX0hTX0cyX1NFUl9CKSwK KwlQSFlfVFJTVl9SRUdfQ0ZHKDB4MDM1LCAweDViLCBQV1JfTU9ERV9IU19HMl9TRVJfQSksCisJ UEhZX1RSU1ZfUkVHX0NGRygweDAzNSwgMHg1YywgUFdSX01PREVfSFNfRzJfU0VSX0IpLAorCUVO RF9VRlNfUEhZX0NGRworfTsKKworLyogQ2FsaWJyYXRpb24gZm9yIEhTIG1vZGUgc2VyaWVzIEEv QiBhdGZlciBQTUMgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyBl eHlub3M3X3Bvc3RfcHdyX2hzX2NmZ1tdID0geworCVBIWV9DT01OX1JFR19DRkcoMHgwMTUsIDB4 MDAsIFBXUl9NT0RFX0hTX0FOWSksCisJUEhZX1RSU1ZfUkVHX0NGRygweDA0ZCwgMHg4MywgUFdS X01PREVfSFNfQU5ZKSwKKwlFTkRfVUZTX1BIWV9DRkcKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqZXh5bm9zN191ZnNfcGh5X2NmZ3NbQ0ZHX1RBR19NQVhd ID0geworCVtDRkdfUFJFX0lOSVRdCQk9IGV4eW5vczdfcHJlX2luaXRfY2ZnLAorCVtDRkdfUE9T VF9JTklUXQkJPSBleHlub3M3X3Bvc3RfaW5pdF9jZmcsCisJW0NGR19QUkVfUFdSX0hTXQk9IGV4 eW5vczdfcHJlX3B3cl9oc19jZmcsCisJW0NGR19QT1NUX1BXUl9IU10JPSBleHlub3M3X3Bvc3Rf cHdyX2hzX2NmZywKK307CisKK3N0YXRpYyBzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2RydmRhdGEg ZXh5bm9zN191ZnNfcGh5ID0geworCS5jZmcgPSBleHlub3M3X3Vmc19waHlfY2ZncywKKwkuaXNv bCA9IHsKKwkJLm9mZnNldCA9IEVYWU5PUzdfRU1CRURERURfQ09NQk9fUEhZX0NUUkwsCisJCS5t YXNrID0gRVhZTk9TN19FTUJFRERFRF9DT01CT19QSFlfQ1RSTF9NQVNLLAorCQkuZW4gPSBFWFlO T1M3X0VNQkVEREVEX0NPTUJPX1BIWV9DVFJMX0VOLAorCX0sCit9OworCisjZW5kaWYgLyogX1BI WV9FWFlOT1M3X1VGU19IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvc2Ftc3VuZy9waHkt c2Ftc3VuZy11ZnMuYyBiL2RyaXZlcnMvcGh5L3NhbXN1bmcvcGh5LXNhbXN1bmctdWZzLmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40YzgzMzRiYmEzZTkKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1zYW1zdW5nLXVmcy5jCkBAIC0w LDAgKzEsMzY5IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cisv KgorICogVUZTIFBIWSBkcml2ZXIgZm9yIFNhbXN1bmcgU29DCisgKgorICogQ29weXJpZ2h0IChD KSAyMDE1IFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKiBBdXRob3I6IFNldW5nd29u IEplb24gPGVzc3V1akBnbWFpbC5jb20+CisgKiBBdXRob3I6IEFsaW0gQWtodGFyIDxhbGltLmFr aHRhckBzYW1zdW5nLmNvbT4KKyAqCisgKi8KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNs dWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxp bnV4L29mLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwu aD4KKyNpbmNsdWRlIDxsaW51eC9tZmQvc3lzY29uLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxl Lmg+CisjaW5jbHVkZSA8bGludXgvcGh5L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3Jt X2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAicGh5LXNh bXN1bmctdWZzLmgiCisKKyNkZWZpbmUgZm9yX2VhY2hfcGh5X2xhbmUocGh5LCBpKSBcCisJZm9y IChpID0gMDsgaSA8IChwaHkpLT5sYW5lX2NudDsgaSsrKQorI2RlZmluZSBmb3JfZWFjaF9waHlf Y2ZnKGNmZykgXAorCWZvciAoOyAoY2ZnKS0+aWQ7IChjZmcpKyspCisKKyNkZWZpbmUgUEhZX0RF Rl9MQU5FX0NOVAkxCisKK3N0YXRpYyB2b2lkIHNhbXN1bmdfdWZzX3BoeV9jb25maWcoc3RydWN0 IHNhbXN1bmdfdWZzX3BoeSAqcGh5LAorCQkJY29uc3Qgc3RydWN0IHNhbXN1bmdfdWZzX3BoeV9j ZmcgKmNmZywgdTggbGFuZSkKK3sKKwllbnVtIHtMQU5FXzAsIExBTkVfMX07IC8qIGxhbmUgaW5k ZXggKi8KKworCXN3aXRjaCAobGFuZSkgeworCWNhc2UgTEFORV8wOgorCQl3cml0ZWwoY2ZnLT52 YWwsIChwaHkpLT5yZWdfcG1hICsgY2ZnLT5vZmZfMCk7CisJCWJyZWFrOworCWNhc2UgTEFORV8x OgorCQlpZiAoY2ZnLT5pZCA9PSBQSFlfVFJTVl9CTEspCisJCQl3cml0ZWwoY2ZnLT52YWwsIChw aHkpLT5yZWdfcG1hICsgY2ZnLT5vZmZfMSk7CisJCWJyZWFrOworCX0KK30KKworaW50IHNhbXN1 bmdfdWZzX3BoeV93YWl0X2Zvcl9sb2NrX2FjcShzdHJ1Y3QgcGh5ICpwaHkpCit7CisJc3RydWN0 IHNhbXN1bmdfdWZzX3BoeSAqdWZzX3BoeSA9IGdldF9zYW1zdW5nX3Vmc19waHkocGh5KTsKKwlj b25zdCB1bnNpZ25lZCBpbnQgdGltZW91dF91cyA9IDEwMDAwMDsKKwljb25zdCB1bnNpZ25lZCBp bnQgc2xlZXBfdXMgPSAxMDsKKwl1MzIgdmFsOworCWludCBlcnI7CisKKwllcnIgPSByZWFkbF9w b2xsX3RpbWVvdXQoCisJCQl1ZnNfcGh5LT5yZWdfcG1hICsgUEhZX0FQQl9BRERSKFBIWV9QTExf TE9DS19TVEFUVVMpLAorCQkJdmFsLCAodmFsICYgUEhZX1BMTF9MT0NLX0JJVCksIHNsZWVwX3Vz LCB0aW1lb3V0X3VzKTsKKwlpZiAoZXJyKSB7CisJCWRldl9lcnIodWZzX3BoeS0+ZGV2LAorCQkJ ImZhaWxlZCB0byBnZXQgcGh5IHBsbCBsb2NrIGFjcXVpc2l0aW9uICVkXG4iLCBlcnIpOworCQln b3RvIG91dDsKKwl9CisKKwllcnIgPSByZWFkbF9wb2xsX3RpbWVvdXQoCisJCQl1ZnNfcGh5LT5y ZWdfcG1hICsgUEhZX0FQQl9BRERSKFBIWV9DRFJfTE9DS19TVEFUVVMpLAorCQkJdmFsLCAodmFs ICYgUEhZX0NEUl9MT0NLX0JJVCksIHNsZWVwX3VzLCB0aW1lb3V0X3VzKTsKKwlpZiAoZXJyKSB7 CisJCWRldl9lcnIodWZzX3BoeS0+ZGV2LAorCQkJImZhaWxlZCB0byBnZXQgcGh5IGNkciBsb2Nr IGFjcXVpc2l0aW9uICVkXG4iLCBlcnIpOworCQlnb3RvIG91dDsKKwl9CisKK291dDoKKwlyZXR1 cm4gZXJyOworfQorCitpbnQgc2Ftc3VuZ191ZnNfcGh5X2NhbGlicmF0ZShzdHJ1Y3QgcGh5ICpw aHkpCit7CisJc3RydWN0IHNhbXN1bmdfdWZzX3BoeSAqdWZzX3BoeSA9IGdldF9zYW1zdW5nX3Vm c19waHkocGh5KTsKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqKmNmZ3MgPSB1ZnNfcGh5 LT5jZmc7CisJY29uc3Qgc3RydWN0IHNhbXN1bmdfdWZzX3BoeV9jZmcgKmNmZzsKKwlpbnQgaTsK KwlpbnQgZXJyID0gMDsKKworCWlmICh1bmxpa2VseSh1ZnNfcGh5LT51ZnNfcGh5X3N0YXRlIDwg Q0ZHX1BSRV9JTklUIHx8CisJCSAgICAgdWZzX3BoeS0+dWZzX3BoeV9zdGF0ZSA+PSBDRkdfVEFH X01BWCkpIHsKKwkJZGV2X2Vycih1ZnNfcGh5LT5kZXYsICJpbnZhbGlkIHBoeSBjb25maWcgaW5k ZXggJWRcbiIsCisJCQkJCQkJdWZzX3BoeS0+dWZzX3BoeV9zdGF0ZSk7CisJCXJldHVybiAtRUlO VkFMOworCX0KKworCWlmICh1ZnNfcGh5LT5pc19wcmVfaW5pdCkKKwkJdWZzX3BoeS0+aXNfcHJl X2luaXQgPSBmYWxzZTsKKwlpZiAodWZzX3BoeS0+aXNfcG9zdF9pbml0KSB7CisJCXVmc19waHkt PmlzX3Bvc3RfaW5pdCA9IGZhbHNlOworCQl1ZnNfcGh5LT51ZnNfcGh5X3N0YXRlID0gQ0ZHX1BP U1RfSU5JVDsKKwl9CisJaWYgKHVmc19waHktPmlzX3ByZV9wbWMpIHsKKwkJdWZzX3BoeS0+aXNf cHJlX3BtYyA9IGZhbHNlOworCQl1ZnNfcGh5LT51ZnNfcGh5X3N0YXRlID0gQ0ZHX1BSRV9QV1Jf SFM7CisJfQorCWlmICh1ZnNfcGh5LT5pc19wb3N0X3BtYykgeworCQl1ZnNfcGh5LT5pc19wb3N0 X3BtYyA9IGZhbHNlOworCQl1ZnNfcGh5LT51ZnNfcGh5X3N0YXRlID0gQ0ZHX1BPU1RfUFdSX0hT OworCX0KKworCXN3aXRjaCAodWZzX3BoeS0+dWZzX3BoeV9zdGF0ZSkgeworCWNhc2UgQ0ZHX1BS RV9JTklUOgorCQl1ZnNfcGh5LT5pc19wb3N0X2luaXQgPSB0cnVlOworCQlicmVhazsKKwljYXNl IENGR19QT1NUX0lOSVQ6CisJCXVmc19waHktPmlzX3ByZV9wbWMgPSB0cnVlOworCQlicmVhazsK KwljYXNlIENGR19QUkVfUFdSX0hTOgorCQl1ZnNfcGh5LT5pc19wb3N0X3BtYyA9IHRydWU7CisJ CWJyZWFrOworCWNhc2UgQ0ZHX1BPU1RfUFdSX0hTOgorCQlicmVhazsKKwlkZWZhdWx0OgorCQlk ZXZfZXJyKHVmc19waHktPmRldiwgIndyb25nIHN0YXRlIGZvciBwaHkgY2FsaWJyYXRpb25cbiIp OworCX0KKworCWNmZyA9IGNmZ3NbdWZzX3BoeS0+dWZzX3BoeV9zdGF0ZV07CisJaWYgKCFjZmcp CisJCWdvdG8gb3V0OworCisJZm9yX2VhY2hfcGh5X2NmZyhjZmcpIHsKKwkJZm9yX2VhY2hfcGh5 X2xhbmUodWZzX3BoeSwgaSkgeworCQkJc2Ftc3VuZ191ZnNfcGh5X2NvbmZpZyh1ZnNfcGh5LCBj ZmcsIGkpOworCQl9CisJfQorCisJaWYgKHVmc19waHktPnVmc19waHlfc3RhdGUgPT0gQ0ZHX1BP U1RfUFdSX0hTKQorCQllcnIgPSBzYW1zdW5nX3Vmc19waHlfd2FpdF9mb3JfbG9ja19hY3EocGh5 KTsKK291dDoKKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgaW50IHNhbXN1bmdfdWZzX3BoeV9z eW1ib2xfY2xrX2luaXQoc3RydWN0IHNhbXN1bmdfdWZzX3BoeSAqcGh5KQoreworCXN0cnVjdCBj bGsgKmNsazsKKwlpbnQgcmV0ID0gMDsKKworCWNsayA9IGRldm1fY2xrX2dldChwaHktPmRldiwg InR4MF9zeW1ib2xfY2xrIik7CisJaWYgKElTX0VSUihjbGspKSB7CisJCWRldl9lcnIocGh5LT5k ZXYsICJmYWlsZWQgdG8gZ2V0IHR4MF9zeW1ib2xfY2xrIGNsb2NrXG4iKTsKKwkJZ290byBvdXQ7 CisJfSBlbHNlIHsKKwkJcGh5LT50eDBfc3ltYm9sX2NsayA9IGNsazsKKwl9CisKKwljbGsgPSBk ZXZtX2Nsa19nZXQocGh5LT5kZXYsICJyeDBfc3ltYm9sX2NsayIpOworCWlmIChJU19FUlIoY2xr KSkgeworCQlkZXZfZXJyKHBoeS0+ZGV2LCAiZmFpbGVkIHRvIGdldCByeDBfc3ltYm9sX2NsayBj bG9ja1xuIik7CisJCWdvdG8gb3V0OworCX0gZWxzZSB7CisJCXBoeS0+cngwX3N5bWJvbF9jbGsg PSBjbGs7CisJfQorCisJY2xrID0gZGV2bV9jbGtfZ2V0KHBoeS0+ZGV2LCAicngxX3N5bWJvbF9j bGsiKTsKKwlpZiAoSVNfRVJSKGNsaykpIHsKKwkJZGV2X2VycihwaHktPmRldiwgImZhaWxlZCB0 byBnZXQgcngxX3N5bWJvbF9jbGsgY2xvY2tcbiIpOworCQlnb3RvIG91dDsKKwl9IGVsc2Ugewor CQlwaHktPnJ4MV9zeW1ib2xfY2xrID0gY2xrOworCX0KKworCXJldCA9IGNsa19wcmVwYXJlX2Vu YWJsZShwaHktPnR4MF9zeW1ib2xfY2xrKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIocGh5LT5k ZXYsICIlczogdHgwX3N5bWJvbF9jbGsgZW5hYmxlIGZhaWxlZCAlZFxuIiwKKwkJCQlfX2Z1bmNf XywgcmV0KTsKKwkJZ290byBvdXQ7CisJfQorCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShwaHkt PnJ4MF9zeW1ib2xfY2xrKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIocGh5LT5kZXYsICIlczog cngwX3N5bWJvbF9jbGsgZW5hYmxlIGZhaWxlZCAlZFxuIiwKKwkJCQlfX2Z1bmNfXywgcmV0KTsK KwkJZ290byBvdXQ7CisJfQorCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShwaHktPnJ4MV9zeW1i b2xfY2xrKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIocGh5LT5kZXYsICIlczogcngxX3N5bWJv bF9jbGsgZW5hYmxlIGZhaWxlZCAlZFxuIiwKKwkJCQlfX2Z1bmNfXywgcmV0KTsKKwkJZ290byBv dXQ7CisJfQorb3V0OgorCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNf cGh5X2Nsa3NfaW5pdChzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpwaHkpCit7CisJc3RydWN0IGNs ayAqcGh5X3JlZl9jbGs7CisJaW50IHJldDsKKworCXBoeV9yZWZfY2xrID0gZGV2bV9jbGtfZ2V0 KHBoeS0+ZGV2LCAicmVmX2NsayIpOworCWlmIChJU19FUlIocGh5X3JlZl9jbGspKQorCQlkZXZf ZXJyKHBoeS0+ZGV2LCAiZmFpbGVkIHRvIGdldCByZWZfY2xrIGNsb2NrXG4iKTsKKwllbHNlCisJ CXBoeS0+cmVmX2NsayA9IHBoeV9yZWZfY2xrOworCisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxl KHBoeS0+cmVmX2Nsayk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKHBoeS0+ZGV2LCAiJXM6IHJl Zl9jbGsgZW5hYmxlIGZhaWxlZCAlZFxuIiwKKwkJCQlfX2Z1bmNfXywgcmV0KTsKKwkJcmV0dXJu IHJldDsKKwl9CisKKwlkZXZfaW5mbyhwaHktPmRldiwgIlVGUyBNUEhZIHJlZl9jbGtfcmF0ZSA9 ICVsZFxuIiwgY2xrX2dldF9yYXRlKHBoeV9yZWZfY2xrKSk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBzYW1zdW5nX3Vmc19waHlfaW5pdChzdHJ1Y3QgcGh5ICpwaHkpCit7CisJc3Ry dWN0IHNhbXN1bmdfdWZzX3BoeSAqX3BoeSA9IGdldF9zYW1zdW5nX3Vmc19waHkocGh5KTsKKwlp bnQgcmV0OworCisJX3BoeS0+bGFuZV9jbnQgPSBwaHktPmF0dHJzLmJ1c193aWR0aDsKKwlfcGh5 LT51ZnNfcGh5X3N0YXRlID0gQ0ZHX1BSRV9JTklUOworCisJX3BoeS0+aXNfcHJlX2luaXQgPSB0 cnVlOworCV9waHktPmlzX3Bvc3RfaW5pdCA9IGZhbHNlOworCV9waHktPmlzX3ByZV9wbWMgPSBm YWxzZTsKKwlfcGh5LT5pc19wb3N0X3BtYyA9IGZhbHNlOworCisKKwlpZiAob2ZfZGV2aWNlX2lz X2NvbXBhdGlibGUoX3BoeS0+ZGV2LT5vZl9ub2RlLAorCQkJCSJzYW1zdW5nLGV4eW5vczctdWZz LXBoeSIpKSB7CisJCXJldCA9IHNhbXN1bmdfdWZzX3BoeV9zeW1ib2xfY2xrX2luaXQoX3BoeSk7 CisJCWlmIChyZXQpCisJCQlkZXZfZXJyKF9waHktPmRldiwKKwkJCQkiZmFpbGVkIHRvIHNldCB1 ZnMgcGh5IHN5bWJvbCBjbG9ja3NcbiIpOworCX0KKworCXJldCA9IHNhbXN1bmdfdWZzX3BoeV9j bGtzX2luaXQoX3BoeSk7CisJaWYgKHJldCkKKwkJZGV2X2VycihfcGh5LT5kZXYsICJmYWlsZWQg dG8gc2V0IHVmcyBwaHkgIGNsb2Nrc1xuIik7CisKKwlzYW1zdW5nX3Vmc19waHlfY2FsaWJyYXRl KHBoeSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYW1zdW5nX3Vmc19waHlfcG93 ZXJfb24oc3RydWN0IHBoeSAqcGh5KQoreworCXN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKl9waHkg PSBnZXRfc2Ftc3VuZ191ZnNfcGh5KHBoeSk7CisKKwlzYW1zdW5nX3Vmc19waHlfY3RybF9pc29s KF9waHksIGZhbHNlKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzYW1zdW5nX3Vmc19w aHlfcG93ZXJfb2ZmKHN0cnVjdCBwaHkgKnBoeSkKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5 ICpfcGh5ID0gZ2V0X3NhbXN1bmdfdWZzX3BoeShwaHkpOworCisJc2Ftc3VuZ191ZnNfcGh5X2N0 cmxfaXNvbChfcGh5LCB0cnVlKTsKKwljbGtfZGlzYWJsZV91bnByZXBhcmUoX3BoeS0+cmVmX2Ns ayk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3NldF9tb2Rl KHN0cnVjdCBwaHkgKmdlbmVyaWNfcGh5LAorCQkJCQllbnVtIHBoeV9tb2RlIG1vZGUsIGludCBz dWJtb2RlKQoreworCXN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKl9waHkgPSBnZXRfc2Ftc3VuZ191 ZnNfcGh5KGdlbmVyaWNfcGh5KTsKKworCV9waHktPm1vZGUgPSBQSFlfTU9ERV9JTlZBTElEOwor CisJaWYgKG1vZGUgPiAwKQorCQlfcGh5LT5tb2RlID0gbW9kZTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgc3RydWN0IHBoeV9vcHMgc2Ftc3VuZ191ZnNfcGh5X29wcyA9IHsKKwkuaW5pdAkJ PSBzYW1zdW5nX3Vmc19waHlfaW5pdCwKKwkucG93ZXJfb24JPSBzYW1zdW5nX3Vmc19waHlfcG93 ZXJfb24sCisJLnBvd2VyX29mZgk9IHNhbXN1bmdfdWZzX3BoeV9wb3dlcl9vZmYsCisJLmNhbGli cmF0ZQk9IHNhbXN1bmdfdWZzX3BoeV9jYWxpYnJhdGUsCisJLnNldF9tb2RlCT0gc2Ftc3VuZ191 ZnNfcGh5X3NldF9tb2RlLAorfQorOworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg c2Ftc3VuZ191ZnNfcGh5X21hdGNoW107CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGRldmljZSAqZGV2 ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwljb25zdCBzdHJ1Y3Qgb2Zf ZGV2aWNlX2lkICptYXRjaDsKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpwaHk7CisJc3RydWN0 IHBoeSAqZ2VuX3BoeTsKKwlzdHJ1Y3QgcGh5X3Byb3ZpZGVyICpwaHlfcHJvdmlkZXI7CisJY29u c3Qgc3RydWN0IHNhbXN1bmdfdWZzX3BoeV9kcnZkYXRhICpkcnZkYXRhOworCWludCBlcnIgPSAw OworCisJbWF0Y2ggPSBvZl9tYXRjaF9ub2RlKHNhbXN1bmdfdWZzX3BoeV9tYXRjaCwgZGV2LT5v Zl9ub2RlKTsKKwlpZiAoIW1hdGNoKSB7CisJCWVyciA9IC1FSU5WQUw7CisJCWRldl9lcnIoZGV2 LCAiZmFpbGVkIHRvIGdldCBtYXRjaF9ub2RlXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJcGh5 ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpwaHkpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXBo eSkgeworCQllcnIgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9CisKKwlyZXMgPSBwbGF0Zm9y bV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAicGh5LXBtYSIpOwor CXBoeS0+cmVnX3BtYSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7CisJaWYgKElT X0VSUihwaHktPnJlZ19wbWEpKSB7CisJCWVyciA9IFBUUl9FUlIocGh5LT5yZWdfcG1hKTsKKwkJ Z290byBvdXQ7CisJfQorCisJcGh5LT5yZWdfcG11ID0gc3lzY29uX3JlZ21hcF9sb29rdXBfYnlf cGhhbmRsZSgKKwkJCQlkZXYtPm9mX25vZGUsICJzYW1zdW5nLHBtdS1zeXNjb24iKTsKKwlpZiAo SVNfRVJSKHBoeS0+cmVnX3BtdSkpIHsKKwkJZXJyID0gUFRSX0VSUihwaHktPnJlZ19wbXUpOwor CQlkZXZfZXJyKGRldiwgImZhaWxlZCBzeXNjb24gcmVtYXAgZm9yIHBtdVxuIik7CisJCWdvdG8g b3V0OworCX0KKworCWdlbl9waHkgPSBkZXZtX3BoeV9jcmVhdGUoZGV2LCBOVUxMLCAmc2Ftc3Vu Z191ZnNfcGh5X29wcyk7CisJaWYgKElTX0VSUihnZW5fcGh5KSkgeworCQllcnIgPSBQVFJfRVJS KGdlbl9waHkpOworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBjcmVhdGUgUEhZIGZvciB1ZnMt cGh5XG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZHJ2ZGF0YSA9IG1hdGNoLT5kYXRhOworCXBo eS0+ZGV2ID0gZGV2OworCXBoeS0+ZHJ2ZGF0YSA9IGRydmRhdGE7CisJcGh5LT5jZmcgPSAoc3Ry dWN0IHNhbXN1bmdfdWZzX3BoeV9jZmcgKiopZHJ2ZGF0YS0+Y2ZnOworCXBoeS0+aXNvbCA9ICZk cnZkYXRhLT5pc29sOworCXBoeS0+bGFuZV9jbnQgPSBQSFlfREVGX0xBTkVfQ05UOworCisJcGh5 X3NldF9kcnZkYXRhKGdlbl9waHksIHBoeSk7CisKKwlwaHlfcHJvdmlkZXIgPSBkZXZtX29mX3Bo eV9wcm92aWRlcl9yZWdpc3RlcihkZXYsIG9mX3BoeV9zaW1wbGVfeGxhdGUpOworCWlmIChJU19F UlIocGh5X3Byb3ZpZGVyKSkgeworCQllcnIgPSBQVFJfRVJSKHBoeV9wcm92aWRlcik7CisJCWRl dl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIHBoeS1wcm92aWRlclxuIik7CisJCWdvdG8g b3V0OworCX0KK291dDoKKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCBzYW1zdW5nX3Vmc19waHlfbWF0Y2hbXSA9IHsKKwl7CisJCS5jb21wYXRpYmxl ID0gInNhbXN1bmcsZXh5bm9zNy11ZnMtcGh5IiwKKwkJLmRhdGEgPSAmZXh5bm9zN191ZnNfcGh5 LAorCX0sCisJe30sCit9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgc2Ftc3VuZ191ZnNfcGh5 X21hdGNoKTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc2Ftc3VuZ191ZnNfcGh5 X2RyaXZlciA9IHsKKwkucHJvYmUgID0gc2Ftc3VuZ191ZnNfcGh5X3Byb2JlLAorCS5kcml2ZXIg PSB7CisJCS5uYW1lID0gInNhbXN1bmctdWZzLXBoeSIsCisJCS5vZl9tYXRjaF90YWJsZSA9IHNh bXN1bmdfdWZzX3BoeV9tYXRjaCwKKwl9LAorfTsKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoc2Ft c3VuZ191ZnNfcGh5X2RyaXZlcik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlNhbXN1bmcgU29DIFVG UyBQSFkgRHJpdmVyIik7CitNT0RVTEVfQVVUSE9SKCJTZXVuZ3dvbiBKZW9uIDxlc3N1dWpAZ21h aWwuY29tPiIpOworTU9EVUxFX0FVVEhPUigiQWxpbSBBa2h0YXIgPGFsaW0uYWtodGFyQHNhbXN1 bmcuY29tPiIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9waHkvc2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuaCBiL2RyaXZlcnMvcGh5L3NhbXN1bmcvcGh5 LXNhbXN1bmctdWZzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4y N2RjMWI1NzM0NjkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1z YW1zdW5nLXVmcy5oCkBAIC0wLDAgKzEsMTQyIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMC1vbmx5ICovCisvKgorICogVUZTIFBIWSBkcml2ZXIgZm9yIFNhbXN1bmcgRVhZ Tk9TIFNvQworICoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBTYW1zdW5nIEVsZWN0cm9uaWNzIENv LiwgTHRkLgorICogQXV0aG9yOiBTZXVuZ3dvbiBKZW9uIDxlc3N1dWpAZ21haWwuY29tPgorICog QXV0aG9yOiBBbGltIEFraHRhciA8YWxpbS5ha2h0YXJAc2Ftc3VuZy5jb20+CisgKgorICovCisj aWZuZGVmIF9QSFlfU0FNU1VOR19VRlNfCisjZGVmaW5lIF9QSFlfU0FNU1VOR19VRlNfCisKKyNk ZWZpbmUgUEhZX0NPTU5fQkxLCTEKKyNkZWZpbmUgUEhZX1RSU1ZfQkxLCTIKKyNkZWZpbmUgRU5E X1VGU19QSFlfQ0ZHIHsgMCB9CisjZGVmaW5lIFBIWV9UUlNWX0NIX09GRlNFVAkweDMwCisjZGVm aW5lIFBIWV9BUEJfQUREUihvZmYpCSgob2ZmKSA8PCAyKQorCisjZGVmaW5lIFBIWV9DT01OX1JF R19DRkcobywgdiwgZCkgewlcCisJLm9mZl8wID0gUEhZX0FQQl9BRERSKChvKSksCVwKKwkub2Zm XzEgPSAwLAkJXAorCS52YWwgPSAodiksCQlcCisJLmRlc2MgPSAoZCksCQlcCisJLmlkID0gUEhZ X0NPTU5fQkxLLAlcCit9CisKKyNkZWZpbmUgUEhZX1RSU1ZfUkVHX0NGRyhvLCB2LCBkKSB7CVwK Kwkub2ZmXzAgPSBQSFlfQVBCX0FERFIoKG8pKSwJXAorCS5vZmZfMSA9IFBIWV9BUEJfQUREUigo bykgKyBQSFlfVFJTVl9DSF9PRkZTRVQpLAlcCisJLnZhbCA9ICh2KSwJCVwKKwkuZGVzYyA9IChk KSwJCVwKKwkuaWQgPSBQSFlfVFJTVl9CTEssCVwKK30KKworLyogVUZTIFBIWSByZWdpc3RlcnMg Ki8KKyNkZWZpbmUgUEhZX1BMTF9MT0NLX1NUQVRVUwkweDFlCisjZGVmaW5lIFBIWV9DRFJfTE9D S19TVEFUVVMJMHg1ZQorCisjZGVmaW5lIFBIWV9QTExfTE9DS19CSVQJQklUKDUpCisjZGVmaW5l IFBIWV9DRFJfTE9DS19CSVQJQklUKDQpCisKKy8qIGRlc2NyaXB0aW9uIGZvciBQSFkgY2FsaWJy YXRpb24gKi8KK2VudW0geworCS8qIGFwcGxpY2FibGUgdG8gYW55ICovCisJUFdSX0RFU0NfQU5Z CT0gMCwKKwkvKiBtb2RlICovCisJUFdSX0RFU0NfUFdNCT0gMSwKKwlQV1JfREVTQ19IUwk9IDIs CisJLyogc2VyaWVzICovCisJUFdSX0RFU0NfU0VSX0EJPSAxLAorCVBXUl9ERVNDX1NFUl9CCT0g MiwKKwkvKiBnZWFyICovCisJUFdSX0RFU0NfRzEJPSAxLAorCVBXUl9ERVNDX0cyCT0gMiwKKwlQ V1JfREVTQ19HMwk9IDMsCisJLyogZmllbGQgbWFzayAqLworCU1EX01BU0sJCT0gMHgzLAorCVNS X01BU0sJCT0gMHgzLAorCUdSX01BU0sJCT0gMHg3LAorfTsKKworI2RlZmluZSBQV1JfTU9ERV9I U19HMV9BTlkJUFdSX01PREVfSFMoUFdSX0RFU0NfRzEsIFBXUl9ERVNDX0FOWSkKKyNkZWZpbmUg UFdSX01PREVfSFNfRzFfU0VSX0EJUFdSX01PREVfSFMoUFdSX0RFU0NfRzEsIFBXUl9ERVNDX1NF Ul9BKQorI2RlZmluZSBQV1JfTU9ERV9IU19HMV9TRVJfQglQV1JfTU9ERV9IUyhQV1JfREVTQ19H MSwgUFdSX0RFU0NfU0VSX0IpCisjZGVmaW5lIFBXUl9NT0RFX0hTX0cyX0FOWQlQV1JfTU9ERV9I UyhQV1JfREVTQ19HMiwgUFdSX0RFU0NfQU5ZKQorI2RlZmluZSBQV1JfTU9ERV9IU19HMl9TRVJf QQlQV1JfTU9ERV9IUyhQV1JfREVTQ19HMiwgUFdSX0RFU0NfU0VSX0EpCisjZGVmaW5lIFBXUl9N T0RFX0hTX0cyX1NFUl9CCVBXUl9NT0RFX0hTKFBXUl9ERVNDX0cyLCBQV1JfREVTQ19TRVJfQikK KyNkZWZpbmUgUFdSX01PREVfSFNfRzNfQU5ZCVBXUl9NT0RFX0hTKFBXUl9ERVNDX0czLCBQV1Jf REVTQ19BTlkpCisjZGVmaW5lIFBXUl9NT0RFX0hTX0czX1NFUl9BCVBXUl9NT0RFX0hTKFBXUl9E RVNDX0czLCBQV1JfREVTQ19TRVJfQSkKKyNkZWZpbmUgUFdSX01PREVfSFNfRzNfU0VSX0IJUFdS X01PREVfSFMoUFdSX0RFU0NfRzMsIFBXUl9ERVNDX1NFUl9CKQorI2RlZmluZSBQV1JfTU9ERShn LCBzLCBtKQkoKCgoZykgJiBHUl9NQVNLKSA8PCA0KSB8XAorCQkJCSAoKChzKSAmIFNSX01BU0sp IDw8IDIpIHwgKChtKSAmIE1EX01BU0spKQorI2RlZmluZSBQV1JfTU9ERV9QV01fQU5ZCVBXUl9N T0RFKFBXUl9ERVNDX0FOWSxcCisJCQkJCSBQV1JfREVTQ19BTlksIFBXUl9ERVNDX1BXTSkKKyNk ZWZpbmUgUFdSX01PREVfSFMoZywgcykJKCgoKGcpICYgR1JfTUFTSykgPDwgNCkgfFwKKwkJCQkg KCgocykgJiBTUl9NQVNLKSA8PCAyKSB8IFBXUl9ERVNDX0hTKQorI2RlZmluZSBQV1JfTU9ERV9I U19BTlkJCVBXUl9NT0RFKFBXUl9ERVNDX0FOWSxcCisJCQkJCSBQV1JfREVTQ19BTlksIFBXUl9E RVNDX0hTKQorI2RlZmluZSBQV1JfTU9ERV9BTlkJCVBXUl9NT0RFKFBXUl9ERVNDX0FOWSxcCisJ CQkJCSBQV1JfREVTQ19BTlksIFBXUl9ERVNDX0FOWSkKKy8qIFBIWSBjYWxpYnJhdGlvbiBwb2lu dC9zdGF0ZSAqLworZW51bSB7CisJQ0ZHX1BSRV9JTklULAorCUNGR19QT1NUX0lOSVQsCisJQ0ZH X1BSRV9QV1JfSFMsCisJQ0ZHX1BPU1RfUFdSX0hTLAorCUNGR19UQUdfTUFYLAorfTsKKworc3Ry dWN0IHNhbXN1bmdfdWZzX3BoeV9jZmcgeworCXUzMiBvZmZfMDsKKwl1MzIgb2ZmXzE7CisJdTMy IHZhbDsKKwl1OCBkZXNjOworCXU4IGlkOworfTsKKworc3RydWN0IHNhbXN1bmdfdWZzX3BoeV9k cnZkYXRhIHsKKwljb25zdCBzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqKmNmZzsKKwlzdHJ1 Y3QgcG11X2lzb2wgeworCQl1MzIgb2Zmc2V0OworCQl1MzIgbWFzazsKKwkJdTMyIGVuOworCX0g aXNvbDsKK307CisKK3N0cnVjdCBzYW1zdW5nX3Vmc19waHkgeworCXN0cnVjdCBkZXZpY2UgKmRl djsKKwl2b2lkIF9faW9tZW0gKnJlZ19wbWE7CisJc3RydWN0IHJlZ21hcCAqcmVnX3BtdTsKKwlz dHJ1Y3QgY2xrICpyZWZfY2xrOworCXN0cnVjdCBjbGsgKnJlZl9jbGtfcGFyZW50OworCXN0cnVj dCBjbGsgKnR4MF9zeW1ib2xfY2xrOworCXN0cnVjdCBjbGsgKnJ4MF9zeW1ib2xfY2xrOworCXN0 cnVjdCBjbGsgKnJ4MV9zeW1ib2xfY2xrOworCWNvbnN0IHN0cnVjdCBzYW1zdW5nX3Vmc19waHlf ZHJ2ZGF0YSAqZHJ2ZGF0YTsKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqKmNmZzsKKwlj b25zdCBzdHJ1Y3QgcG11X2lzb2wgKmlzb2w7CisJdTggbGFuZV9jbnQ7CisJaW50IHVmc19waHlf c3RhdGU7CisJZW51bSBwaHlfbW9kZSBtb2RlOworCWJvb2wgaXNfcHJlX2luaXQ7CisJYm9vbCBp c19wb3N0X2luaXQ7CisJYm9vbCBpc19wcmVfcG1jOworCWJvb2wgaXNfcG9zdF9wbWM7Cit9Owor CitzdGF0aWMgaW5saW5lIHN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKmdldF9zYW1zdW5nX3Vmc19w aHkoc3RydWN0IHBoeSAqcGh5KQoreworCXJldHVybiAoc3RydWN0IHNhbXN1bmdfdWZzX3BoeSAq KXBoeV9nZXRfZHJ2ZGF0YShwaHkpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc2Ftc3VuZ191 ZnNfcGh5X2N0cmxfaXNvbCgKKwkJc3RydWN0IHNhbXN1bmdfdWZzX3BoeSAqcGh5LCB1MzIgaXNv bCkKK3sKKwlyZWdtYXBfdXBkYXRlX2JpdHMocGh5LT5yZWdfcG11LCBwaHktPmlzb2wtPm9mZnNl dCwKKwkJCXBoeS0+aXNvbC0+bWFzaywgaXNvbCA/IDAgOiBwaHktPmlzb2wtPmVuKTsKK30KKwor I2luY2x1ZGUgInBoeS1leHlub3M3LXVmcy5oIgorCisjZW5kaWYgLyogX1BIWV9TQU1TVU5HX1VG U18gKi8KLS0gCjIuMTcuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK