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=-10.0 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=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 2B9E5C433E1 for ; Thu, 14 May 2020 00:53:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 32C222065D for ; Thu, 14 May 2020 00:53:17 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="t10gRpKP" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732260AbgENAxQ (ORCPT ); Wed, 13 May 2020 20:53:16 -0400 Received: from mailout2.samsung.com ([203.254.224.25]:46047 "EHLO mailout2.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731339AbgENAxN (ORCPT ); Wed, 13 May 2020 20:53:13 -0400 Received: from epcas5p3.samsung.com (unknown [182.195.41.41]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20200514005308epoutp02af8a4aceaa947b84b39a81308e8c5d76~OvuAYtHvs1758217582epoutp021 for ; Thu, 14 May 2020 00:53:08 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20200514005308epoutp02af8a4aceaa947b84b39a81308e8c5d76~OvuAYtHvs1758217582epoutp021 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1589417588; bh=sK/hFncn11WBScvtcYDk7R7CcwFLxOCyulZMUjKu6sA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=t10gRpKPVa/eizfijPwR1lovg8TgYYNj3kaqBZvhwczwf/VydBezCnsYNGTwUhB9V RLugWBIjbf9AIIXmNC0x/leojFTVQ+xXdrCrQQIV8VqcN6jViP523tkaOljQ/56ZPf M3Mw3VCWXc08vVCXBqBHb4ZwtwyqC5qyYkbtGdT0= Received: from epsmges5p3new.samsung.com (unknown [182.195.42.75]) by epcas5p3.samsung.com (KnoxPortal) with ESMTP id 20200514005307epcas5p34683dbc6b3566a18b1b306efc6211843~Ovt-6Lbul1578415784epcas5p3B; Thu, 14 May 2020 00:53:07 +0000 (GMT) Received: from epcas5p3.samsung.com ( [182.195.41.41]) by epsmges5p3new.samsung.com (Symantec Messaging Gateway) with SMTP id 50.8E.23389.3769CBE5; Thu, 14 May 2020 09:53:07 +0900 (KST) Received: from epsmtrp1.samsung.com (unknown [182.195.40.13]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPA id 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4~Ovt-gnZAK1337613376epcas5p2A; Thu, 14 May 2020 00:53:07 +0000 (GMT) Received: from epsmgms1p2.samsung.com (unknown [182.195.42.42]) by epsmtrp1.samsung.com (KnoxPortal) with ESMTP id 20200514005307epsmtrp1494bd427208486b5d9b5ea0ad95071eb~Ovt-fuhs91129711297epsmtrp1h; Thu, 14 May 2020 00:53:07 +0000 (GMT) X-AuditID: b6c32a4b-797ff70000005b5d-04-5ebc9673da39 Received: from epsmtip2.samsung.com ( [182.195.34.31]) by epsmgms1p2.samsung.com (Symantec Messaging Gateway) with SMTP id 38.82.25866.3769CBE5; Thu, 14 May 2020 09:53:07 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip2.samsung.com (KnoxPortal) with ESMTPA id 20200514005304epsmtip26faba709658528a56c74fda8bb5a294e~Ovt9UJ1eR3265032650epsmtip2f; Thu, 14 May 2020 00:53:04 +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 v9 07/10] phy: samsung-ufs: add UFS PHY driver for samsung SoC Date: Thu, 14 May 2020 06:09:11 +0530 Message-Id: <20200514003914.26052-8-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200514003914.26052-1-alim.akhtar@samsung.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFjrAKsWRmVeSWpSXmKPExsWy7bCmpm7xtD1xBlMvKls8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJXxc9Jk5oI7cxgr5i15xNrA+LmJsYuRk0NCwETi3431zF2M XBxCArsZJZrffYVyPjFKrPk+A8r5zCgxad0FuJbdzbcYIRK7GCWWnvgMVdXCJDFj9UuwKjYB bYm707cwgdgiAsISR761gXUwCzQxS3xZ2sQGkhAWCJDY9/E3M4jNIqAqcWzTf7A4r4CNxO6L v9kg1slLrN5wAKyGU8BWYsuXY6wQNYISJ2c+YQGxmYFqmrfOBrtCQuAMh8SCg9uZIJpdJNr+ PWeFsIUlXh3fwg5hS0m87G8DsjmA7GyJnl3GEOEaiaXzjrFA2PYSB67MYQEpYRbQlFi/Sx9i FZ9E7+8nTBCdvBIdbUIQ1arAoLsK1SktMbG7G2qph8SPR1PArhcSmMAoMf1m7ARG+VlIHpiF 5IFZCMsWMDKvYpRMLSjOTU8tNi0wzkst1ytOzC0uzUvXS87P3cQITmRa3jsYHz34oHeIkYmD 8RCjBAezkgiv3/rdcUK8KYmVValF+fFFpTmpxYcYpTlYlMR5HzduiRMSSE8sSc1OTS1ILYLJ MnFwSjUwXUtrjX7kderIWYF7RtduiDlPWLq5N+uU7zJjkebjerohk/XWsrEoiHaKJfbN9DD5 l/M5+E2+/FLN2xFc36+HzGCw95gXaBYdejnaZrXU6bavk0I0etqsbyf+19hqFmBTHDxBLKLk yKzpYvMfr5I53nDrzmbt9MVyYvf+1N70/fRTXrhVln1reNHzDXo9Jxf/izPw91Dlay7yczhe PbtcUf2m4lI3txiNy71fGurs7jrs+rlZOCRsMatV96S6/1yyMiu+1aVybzznfcSA06DAdKXT sZ/ZlyqX1eQ5hTJP5Voi4qlm96DF1H/yKxdNWXGtMpO5PUvu8YhvzPLPj/kkfqP/zpP0bf2z WhvO2imxFGckGmoxFxUnAgDXFer/0wMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprKIsWRmVeSWpSXmKPExsWy7bCSvG7xtD1xBqumc1g8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJXxc9Jk5oI7cxgr5i15xNrA+LmJsYuRk0NCwERid/MtIJuL Q0hgB6NE3/+DTBAJaYnrGyewQ9jCEiv/PWeHKGpikjjU8ZAVJMEmoC1xd/oWsAYRoKIj39rA JjELTGCWWP7rG5DDwSEs4CfRd6MApIZFQFXi2Kb/bCA2r4CNxO6Lv9kgFshLrN5wgBnE5hSw ldjy5RjYfCGgmmVrljFC1AtKnJz5hAVkJLOAusT6eUIgYWag1uats5knMArOQlI1C6FqFpKq BYzMqxglUwuKc9Nziw0LjPJSy/WKE3OLS/PS9ZLzczcxgmNOS2sH455VH/QOMTJxMB5ilOBg VhLh9Vu/O06INyWxsiq1KD++qDQntfgQozQHi5I479dZC+OEBNITS1KzU1MLUotgskwcnFIN TLN1LXsEDfh8HFJFRVZ/vMW7aRFv34T6vN0z1b/1rXdsaPC6+sghI1vjqb5AYeuJEr3TQWWX rRU/xCx8vavKrK5E5WNHwCN9z1/HEuR3r3nQf0V78Y7301uvaAuJ3N/N6ObA29T3T2L/XQnb LH/J6V+3zZlhNFXq1OKTDW8PrP2R+yjJ6oGfndLf3j/s7vMWs3B4T/ILsnwY16bvLtZUL/zn bLLHjQ+q+WfUmQ0fz9it8mCJgPPVbGdB3i/LtKZuTr2+vDGxZdvxK3vvx7N6OXxYdd7fO1eX jeNCzxr9jox+Fc5Jh9R3L9EtOjjrpVNF28xSl/M5IpdWzJuzX63Z1pIvavWDxzMFXHy/qeu3 KrEUZyQaajEXFScCAHy6x0coAwAA X-CMS-MailID: 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" CMS-TYPE: 105P X-CMS-RootMailID: 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4 References: <20200514003914.26052-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 | 86 ++++++ drivers/phy/samsung/phy-samsung-ufs.c | 380 ++++++++++++++++++++++++++ drivers/phy/samsung/phy-samsung-ufs.h | 143 ++++++++++ 5 files changed, 619 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..c4aab792d30e --- /dev/null +++ b/drivers/phy/samsung/phy-exynos7-ufs.h @@ -0,0 +1,86 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * UFS PHY driver data for Samsung EXYNOS7 SoC + * + * Copyright (C) 2020 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, + }, + .has_symbol_clk = 1, +}; + +#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..be25617f622b --- /dev/null +++ b/drivers/phy/samsung/phy-samsung-ufs.c @@ -0,0 +1,380 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * UFS PHY driver for Samsung SoC + * + * Copyright (C) 2020 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) +{ + int ret = 0; + + phy->tx0_symbol_clk = devm_clk_get(phy->dev, "tx0_symbol_clk"); + if (IS_ERR(phy->tx0_symbol_clk)) { + dev_err(phy->dev, "failed to get tx0_symbol_clk clock\n"); + goto out; + } + + phy->rx0_symbol_clk = devm_clk_get(phy->dev, "rx0_symbol_clk"); + if (IS_ERR(phy->rx0_symbol_clk)) { + dev_err(phy->dev, "failed to get rx0_symbol_clk clock\n"); + goto out; + } + + phy->rx1_symbol_clk = devm_clk_get(phy->dev, "rx1_symbol_clk"); + if (IS_ERR(phy->rx0_symbol_clk)) { + dev_err(phy->dev, "failed to get rx1_symbol_clk clock\n"); + goto out; + } + + 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) +{ + 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"); + + 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; + + /** + * In ufs, PHY need to be calibrated at different stages / state + * mainly before Linkstartup, after Linkstartup, before power + * mode change and after power mode change. + * Below state machine initialize the initial state to handle + * PHY calibration at various stages of UFS initialization and power + * mode changes + */ + _phy->is_pre_init = true; + _phy->is_post_init = false; + _phy->is_pre_pmc = false; + _phy->is_post_pmc = false; + + + if (_phy->drvdata->has_symbol_clk) { + 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); + 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 int samsung_ufs_phy_exit(struct phy *phy) +{ + struct samsung_ufs_phy *_phy = get_samsung_ufs_phy(phy); + + clk_disable_unprepare(_phy->ref_clk); + + if (_phy->drvdata->has_symbol_clk) { + clk_disable_unprepare(_phy->tx0_symbol_clk); + clk_disable_unprepare(_phy->rx0_symbol_clk); + clk_disable_unprepare(_phy->rx1_symbol_clk); + } + + return 0; +} + +static struct phy_ops samsung_ufs_phy_ops = { + .init = samsung_ufs_phy_init, + .exit = samsung_ufs_phy_exit, + .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, + .owner = THIS_MODULE, +}; + +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; + 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; + } + + phy->reg_pma = devm_platform_ioremap_resource_byname(pdev, "phy-pma"); + 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..1cc814d972e8 --- /dev/null +++ b/drivers/phy/samsung/phy-samsung-ufs.h @@ -0,0 +1,143 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * UFS PHY driver for Samsung EXYNOS SoC + * + * Copyright (C) 2020 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; + bool has_symbol_clk; +}; + +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.9 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 011CAC433DF for ; Thu, 14 May 2020 00:55: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 016382054F for ; Thu, 14 May 2020 00:55:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="oUQcCLs/"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="t10gRpKP" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 016382054F 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=r4AEnWs4J+S7lBkdGGRo2wgFzjRW49odJCTMQTzUTas=; b=oUQcCLs/Z4uPEN 8N4sl5oLDkd/fbZYKDDZbSLqxdxpOA8Xec8xJf4+oHFHF1ViCt8NPgWcWp9hsGF/uZOaCiCbVqc5l DHSqEBSgkghRCzc9zGIbHvhesIJOO+WWHEyY4svXS99PRtyoXDBKGCMa/nR0GwFIoXayIJSSoGxD2 I5Vhgf25pivTFxmUe/StC0Jb2w2TYfq4WHxiyfAq1RFPe9ZB616h++RzL1duvV3S6ma2VqAA2Wb6+ RPa/VgAKVgjo6bmopzNdj0WEEs6FcGXgvodN5giZpwq+RWHNFd0jlWx7R90zqRjHJ0QFw6L+dSwp7 WyCgSXqAtK5n5GzOmziQ==; 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 1jZ29w-0005In-6x; Thu, 14 May 2020 00:55:36 +0000 Received: from mailout2.samsung.com ([203.254.224.25]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jZ27g-00010P-Ln for linux-arm-kernel@lists.infradead.org; Thu, 14 May 2020 00:53:24 +0000 Received: from epcas5p3.samsung.com (unknown [182.195.41.41]) by mailout2.samsung.com (KnoxPortal) with ESMTP id 20200514005308epoutp029b912067a6fb0ea90cf794c0ff95dbdc~OvuAOWHTD1752217522epoutp02A for ; Thu, 14 May 2020 00:53:08 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.samsung.com 20200514005308epoutp029b912067a6fb0ea90cf794c0ff95dbdc~OvuAOWHTD1752217522epoutp02A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1589417588; bh=sK/hFncn11WBScvtcYDk7R7CcwFLxOCyulZMUjKu6sA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=t10gRpKPVa/eizfijPwR1lovg8TgYYNj3kaqBZvhwczwf/VydBezCnsYNGTwUhB9V RLugWBIjbf9AIIXmNC0x/leojFTVQ+xXdrCrQQIV8VqcN6jViP523tkaOljQ/56ZPf M3Mw3VCWXc08vVCXBqBHb4ZwtwyqC5qyYkbtGdT0= Received: from epsmges5p3new.samsung.com (unknown [182.195.42.75]) by epcas5p3.samsung.com (KnoxPortal) with ESMTP id 20200514005307epcas5p34683dbc6b3566a18b1b306efc6211843~Ovt-6Lbul1578415784epcas5p3B; Thu, 14 May 2020 00:53:07 +0000 (GMT) Received: from epcas5p3.samsung.com ( [182.195.41.41]) by epsmges5p3new.samsung.com (Symantec Messaging Gateway) with SMTP id 50.8E.23389.3769CBE5; Thu, 14 May 2020 09:53:07 +0900 (KST) Received: from epsmtrp1.samsung.com (unknown [182.195.40.13]) by epcas5p2.samsung.com (KnoxPortal) with ESMTPA id 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4~Ovt-gnZAK1337613376epcas5p2A; Thu, 14 May 2020 00:53:07 +0000 (GMT) Received: from epsmgms1p2.samsung.com (unknown [182.195.42.42]) by epsmtrp1.samsung.com (KnoxPortal) with ESMTP id 20200514005307epsmtrp1494bd427208486b5d9b5ea0ad95071eb~Ovt-fuhs91129711297epsmtrp1h; Thu, 14 May 2020 00:53:07 +0000 (GMT) X-AuditID: b6c32a4b-797ff70000005b5d-04-5ebc9673da39 Received: from epsmtip2.samsung.com ( [182.195.34.31]) by epsmgms1p2.samsung.com (Symantec Messaging Gateway) with SMTP id 38.82.25866.3769CBE5; Thu, 14 May 2020 09:53:07 +0900 (KST) Received: from Jaguar.sa.corp.samsungelectronics.net (unknown [107.108.73.139]) by epsmtip2.samsung.com (KnoxPortal) with ESMTPA id 20200514005304epsmtip26faba709658528a56c74fda8bb5a294e~Ovt9UJ1eR3265032650epsmtip2f; Thu, 14 May 2020 00:53:04 +0000 (GMT) From: Alim Akhtar To: robh@kernel.org Subject: [PATCH v9 07/10] phy: samsung-ufs: add UFS PHY driver for samsung SoC Date: Thu, 14 May 2020 06:09:11 +0530 Message-Id: <20200514003914.26052-8-alim.akhtar@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200514003914.26052-1-alim.akhtar@samsung.com> MIME-Version: 1.0 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFjrAKsWRmVeSWpSXmKPExsWy7bCmpm7xtD1xBlMvKls8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJXxc9Jk5oI7cxgr5i15xNrA+LmJsYuRk0NCwETi3431zF2M XBxCArsZJZrffYVyPjFKrPk+A8r5zCgxad0FuJbdzbcYIRK7GCWWnvgMVdXCJDFj9UuwKjYB bYm707cwgdgiAsISR761gXUwCzQxS3xZ2sQGkhAWCJDY9/E3M4jNIqAqcWzTf7A4r4CNxO6L v9kg1slLrN5wAKyGU8BWYsuXY6wQNYISJ2c+YQGxmYFqmrfOBrtCQuAMh8SCg9uZIJpdJNr+ PWeFsIUlXh3fwg5hS0m87G8DsjmA7GyJnl3GEOEaiaXzjrFA2PYSB67MYQEpYRbQlFi/Sx9i FZ9E7+8nTBCdvBIdbUIQ1arAoLsK1SktMbG7G2qph8SPR1PArhcSmMAoMf1m7ARG+VlIHpiF 5IFZCMsWMDKvYpRMLSjOTU8tNi0wzkst1ytOzC0uzUvXS87P3cQITmRa3jsYHz34oHeIkYmD 8RCjBAezkgiv3/rdcUK8KYmVValF+fFFpTmpxYcYpTlYlMR5HzduiRMSSE8sSc1OTS1ILYLJ MnFwSjUwXUtrjX7kderIWYF7RtduiDlPWLq5N+uU7zJjkebjerohk/XWsrEoiHaKJfbN9DD5 l/M5+E2+/FLN2xFc36+HzGCw95gXaBYdejnaZrXU6bavk0I0etqsbyf+19hqFmBTHDxBLKLk yKzpYvMfr5I53nDrzmbt9MVyYvf+1N70/fRTXrhVln1reNHzDXo9Jxf/izPw91Dlay7yczhe PbtcUf2m4lI3txiNy71fGurs7jrs+rlZOCRsMatV96S6/1yyMiu+1aVybzznfcSA06DAdKXT sZ/ZlyqX1eQ5hTJP5Voi4qlm96DF1H/yKxdNWXGtMpO5PUvu8YhvzPLPj/kkfqP/zpP0bf2z WhvO2imxFGckGmoxFxUnAgDXFer/0wMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprKIsWRmVeSWpSXmKPExsWy7bCSvG7xtD1xBqumc1g8mLeNzeLlz6ts Fp/WL2O1mH/kHKvFhac9bBbnz29gt7i55SiLxabH11gtLu+aw2Yx4/w+Jovu6zvYLJYf/8dk 8X/PDnaLpVtvMjrweVzu62Xy2LSqk81j85J6j5aT+1k8Pj69xeLRt2UVo8fxG9uZPD5vkvNo P9DNFMAZxWWTkpqTWZZapG+XwJXxc9Jk5oI7cxgr5i15xNrA+LmJsYuRk0NCwERid/MtIJuL Q0hgB6NE3/+DTBAJaYnrGyewQ9jCEiv/PWeHKGpikjjU8ZAVJMEmoC1xd/oWsAYRoKIj39rA JjELTGCWWP7rG5DDwSEs4CfRd6MApIZFQFXi2Kb/bCA2r4CNxO6Lv9kgFshLrN5wgBnE5hSw ldjy5RjYfCGgmmVrljFC1AtKnJz5hAVkJLOAusT6eUIgYWag1uats5knMArOQlI1C6FqFpKq BYzMqxglUwuKc9Nziw0LjPJSy/WKE3OLS/PS9ZLzczcxgmNOS2sH455VH/QOMTJxMB5ilOBg VhLh9Vu/O06INyWxsiq1KD++qDQntfgQozQHi5I479dZC+OEBNITS1KzU1MLUotgskwcnFIN TLN1LXsEDfh8HFJFRVZ/vMW7aRFv34T6vN0z1b/1rXdsaPC6+sghI1vjqb5AYeuJEr3TQWWX rRU/xCx8vavKrK5E5WNHwCN9z1/HEuR3r3nQf0V78Y7301uvaAuJ3N/N6ObA29T3T2L/XQnb LH/J6V+3zZlhNFXq1OKTDW8PrP2R+yjJ6oGfndLf3j/s7vMWs3B4T/ILsnwY16bvLtZUL/zn bLLHjQ+q+WfUmQ0fz9it8mCJgPPVbGdB3i/LtKZuTr2+vDGxZdvxK3vvx7N6OXxYdd7fO1eX jeNCzxr9jox+Fc5Jh9R3L9EtOjjrpVNF28xSl/M5IpdWzJuzX63Z1pIvavWDxzMFXHy/qeu3 KrEUZyQaajEXFScCAHy6x0coAwAA X-CMS-MailID: 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4 X-Msg-Generator: CA CMS-TYPE: 105P X-CMS-RootMailID: 20200514005307epcas5p28b00e2fb5e9526c447927b52127480f4 References: <20200514003914.26052-1-alim.akhtar@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200513_175317_097802_7AF214F2 X-CRM114-Status: GOOD ( 22.80 ) 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 L3BoeS9zYW1zdW5nL3BoeS1leHlub3M3LXVmcy5oIHwgIDg2ICsrKysrKwogZHJpdmVycy9waHkv c2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuYyB8IDM4MCArKysrKysrKysrKysrKysrKysrKysrKysr KwogZHJpdmVycy9waHkvc2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuaCB8IDE0MyArKysrKysrKysr CiA1IGZpbGVzIGNoYW5nZWQsIDYxOSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQg 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 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5jNGFhYjc5MmQzMGUKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1leHlub3M3LXVmcy5oCkBAIC0w LDAgKzEsODYgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8K Ky8qCisgKiBVRlMgUEhZIGRyaXZlciBkYXRhIGZvciBTYW1zdW5nIEVYWU5PUzcgU29DCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDIwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKi8K 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 T1M3X0VNQkVEREVEX0NPTUJPX1BIWV9DVFJMX0VOLAorCX0sCisJLmhhc19zeW1ib2xfY2xrID0g MSwKK307CisKKyNlbmRpZiAvKiBfUEhZX0VYWU5PUzdfVUZTX0hfICovCmRpZmYgLS1naXQgYS9k cml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1zYW1zdW5nLXVmcy5jIGIvZHJpdmVycy9waHkvc2Ftc3Vu Zy9waHktc2Ftc3VuZy11ZnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLmJlMjU2MTdmNjIyYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGh5L3NhbXN1bmcv cGh5LXNhbXN1bmctdWZzLmMKQEAgLTAsMCArMSwzODAgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wLW9ubHkKKy8qCisgKiBVRlMgUEhZIGRyaXZlciBmb3IgU2Ftc3VuZyBT b0MKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3VuZyBFbGVjdHJvbmljcyBDby4sIEx0 ZC4KKyAqIEF1dGhvcjogU2V1bmd3b24gSmVvbiA8ZXNzdXVqQGdtYWlsLmNvbT4KKyAqIEF1dGhv cjogQWxpbSBBa2h0YXIgPGFsaW0uYWtodGFyQHNhbXN1bmcuY29tPgorICoKKyAqLworI2luY2x1 ZGUgPGxpbnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGlu dXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgor I2luY2x1ZGUgPGxpbnV4L2lvcG9sbC5oPgorI2luY2x1ZGUgPGxpbnV4L21mZC9zeXNjb24uaD4K KyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9waHkvcGh5Lmg+Cisj aW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFw Lmg+CisKKyNpbmNsdWRlICJwaHktc2Ftc3VuZy11ZnMuaCIKKworI2RlZmluZSBmb3JfZWFjaF9w aHlfbGFuZShwaHksIGkpIFwKKwlmb3IgKGkgPSAwOyBpIDwgKHBoeSktPmxhbmVfY250OyBpKysp CisjZGVmaW5lIGZvcl9lYWNoX3BoeV9jZmcoY2ZnKSBcCisJZm9yICg7IChjZmcpLT5pZDsgKGNm ZykrKykKKworI2RlZmluZSBQSFlfREVGX0xBTkVfQ05UCTEKKworc3RhdGljIHZvaWQgc2Ftc3Vu Z191ZnNfcGh5X2NvbmZpZyhzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpwaHksCisJCQljb25zdCBz dHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqY2ZnLCB1OCBsYW5lKQoreworCWVudW0ge0xBTkVf MCwgTEFORV8xfTsgLyogbGFuZSBpbmRleCAqLworCisJc3dpdGNoIChsYW5lKSB7CisJY2FzZSBM QU5FXzA6CisJCXdyaXRlbChjZmctPnZhbCwgKHBoeSktPnJlZ19wbWEgKyBjZmctPm9mZl8wKTsK KwkJYnJlYWs7CisJY2FzZSBMQU5FXzE6CisJCWlmIChjZmctPmlkID09IFBIWV9UUlNWX0JMSykK KwkJCXdyaXRlbChjZmctPnZhbCwgKHBoeSktPnJlZ19wbWEgKyBjZmctPm9mZl8xKTsKKwkJYnJl YWs7CisJfQorfQorCitpbnQgc2Ftc3VuZ191ZnNfcGh5X3dhaXRfZm9yX2xvY2tfYWNxKHN0cnVj dCBwaHkgKnBoeSkKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICp1ZnNfcGh5ID0gZ2V0X3Nh bXN1bmdfdWZzX3BoeShwaHkpOworCWNvbnN0IHVuc2lnbmVkIGludCB0aW1lb3V0X3VzID0gMTAw MDAwOworCWNvbnN0IHVuc2lnbmVkIGludCBzbGVlcF91cyA9IDEwOworCXUzMiB2YWw7CisJaW50 IGVycjsKKworCWVyciA9IHJlYWRsX3BvbGxfdGltZW91dCgKKwkJCXVmc19waHktPnJlZ19wbWEg KyBQSFlfQVBCX0FERFIoUEhZX1BMTF9MT0NLX1NUQVRVUyksCisJCQl2YWwsICh2YWwgJiBQSFlf UExMX0xPQ0tfQklUKSwgc2xlZXBfdXMsIHRpbWVvdXRfdXMpOworCWlmIChlcnIpIHsKKwkJZGV2 X2Vycih1ZnNfcGh5LT5kZXYsCisJCQkiZmFpbGVkIHRvIGdldCBwaHkgcGxsIGxvY2sgYWNxdWlz aXRpb24gJWRcbiIsIGVycik7CisJCWdvdG8gb3V0OworCX0KKworCWVyciA9IHJlYWRsX3BvbGxf dGltZW91dCgKKwkJCXVmc19waHktPnJlZ19wbWEgKyBQSFlfQVBCX0FERFIoUEhZX0NEUl9MT0NL X1NUQVRVUyksCisJCQl2YWwsICh2YWwgJiBQSFlfQ0RSX0xPQ0tfQklUKSwgc2xlZXBfdXMsIHRp bWVvdXRfdXMpOworCWlmIChlcnIpIHsKKwkJZGV2X2Vycih1ZnNfcGh5LT5kZXYsCisJCQkiZmFp bGVkIHRvIGdldCBwaHkgY2RyIGxvY2sgYWNxdWlzaXRpb24gJWRcbiIsIGVycik7CisJCWdvdG8g b3V0OworCX0KKworb3V0OgorCXJldHVybiBlcnI7Cit9CisKK2ludCBzYW1zdW5nX3Vmc19waHlf Y2FsaWJyYXRlKHN0cnVjdCBwaHkgKnBoeSkKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICp1 ZnNfcGh5ID0gZ2V0X3NhbXN1bmdfdWZzX3BoeShwaHkpOworCXN0cnVjdCBzYW1zdW5nX3Vmc19w aHlfY2ZnICoqY2ZncyA9IHVmc19waHktPmNmZzsKKwljb25zdCBzdHJ1Y3Qgc2Ftc3VuZ191ZnNf cGh5X2NmZyAqY2ZnOworCWludCBpOworCWludCBlcnIgPSAwOworCisJaWYgKHVubGlrZWx5KHVm c19waHktPnVmc19waHlfc3RhdGUgPCBDRkdfUFJFX0lOSVQgfHwKKwkJICAgICB1ZnNfcGh5LT51 ZnNfcGh5X3N0YXRlID49IENGR19UQUdfTUFYKSkgeworCQlkZXZfZXJyKHVmc19waHktPmRldiwg ImludmFsaWQgcGh5IGNvbmZpZyBpbmRleCAlZFxuIiwKKwkJCQkJCQl1ZnNfcGh5LT51ZnNfcGh5 X3N0YXRlKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKHVmc19waHktPmlzX3ByZV9p bml0KQorCQl1ZnNfcGh5LT5pc19wcmVfaW5pdCA9IGZhbHNlOworCWlmICh1ZnNfcGh5LT5pc19w b3N0X2luaXQpIHsKKwkJdWZzX3BoeS0+aXNfcG9zdF9pbml0ID0gZmFsc2U7CisJCXVmc19waHkt PnVmc19waHlfc3RhdGUgPSBDRkdfUE9TVF9JTklUOworCX0KKwlpZiAodWZzX3BoeS0+aXNfcHJl X3BtYykgeworCQl1ZnNfcGh5LT5pc19wcmVfcG1jID0gZmFsc2U7CisJCXVmc19waHktPnVmc19w aHlfc3RhdGUgPSBDRkdfUFJFX1BXUl9IUzsKKwl9CisJaWYgKHVmc19waHktPmlzX3Bvc3RfcG1j KSB7CisJCXVmc19waHktPmlzX3Bvc3RfcG1jID0gZmFsc2U7CisJCXVmc19waHktPnVmc19waHlf c3RhdGUgPSBDRkdfUE9TVF9QV1JfSFM7CisJfQorCisJc3dpdGNoICh1ZnNfcGh5LT51ZnNfcGh5 X3N0YXRlKSB7CisJY2FzZSBDRkdfUFJFX0lOSVQ6CisJCXVmc19waHktPmlzX3Bvc3RfaW5pdCA9 IHRydWU7CisJCWJyZWFrOworCWNhc2UgQ0ZHX1BPU1RfSU5JVDoKKwkJdWZzX3BoeS0+aXNfcHJl X3BtYyA9IHRydWU7CisJCWJyZWFrOworCWNhc2UgQ0ZHX1BSRV9QV1JfSFM6CisJCXVmc19waHkt PmlzX3Bvc3RfcG1jID0gdHJ1ZTsKKwkJYnJlYWs7CisJY2FzZSBDRkdfUE9TVF9QV1JfSFM6CisJ CWJyZWFrOworCWRlZmF1bHQ6CisJCWRldl9lcnIodWZzX3BoeS0+ZGV2LCAid3Jvbmcgc3RhdGUg Zm9yIHBoeSBjYWxpYnJhdGlvblxuIik7CisJfQorCisJY2ZnID0gY2Znc1t1ZnNfcGh5LT51ZnNf cGh5X3N0YXRlXTsKKwlpZiAoIWNmZykKKwkJZ290byBvdXQ7CisKKwlmb3JfZWFjaF9waHlfY2Zn KGNmZykgeworCQlmb3JfZWFjaF9waHlfbGFuZSh1ZnNfcGh5LCBpKSB7CisJCQlzYW1zdW5nX3Vm c19waHlfY29uZmlnKHVmc19waHksIGNmZywgaSk7CisJCX0KKwl9CisKKwlpZiAodWZzX3BoeS0+ dWZzX3BoeV9zdGF0ZSA9PSBDRkdfUE9TVF9QV1JfSFMpCisJCWVyciA9IHNhbXN1bmdfdWZzX3Bo eV93YWl0X2Zvcl9sb2NrX2FjcShwaHkpOworb3V0OgorCXJldHVybiBlcnI7Cit9CisKK3N0YXRp YyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3N5bWJvbF9jbGtfaW5pdChzdHJ1Y3Qgc2Ftc3VuZ191ZnNf cGh5ICpwaHkpCit7CisJaW50IHJldCA9IDA7CisKKwlwaHktPnR4MF9zeW1ib2xfY2xrID0gZGV2 bV9jbGtfZ2V0KHBoeS0+ZGV2LCAidHgwX3N5bWJvbF9jbGsiKTsKKwlpZiAoSVNfRVJSKHBoeS0+ dHgwX3N5bWJvbF9jbGspKSB7CisJCWRldl9lcnIocGh5LT5kZXYsICJmYWlsZWQgdG8gZ2V0IHR4 MF9zeW1ib2xfY2xrIGNsb2NrXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJcGh5LT5yeDBfc3lt Ym9sX2NsayA9IGRldm1fY2xrX2dldChwaHktPmRldiwgInJ4MF9zeW1ib2xfY2xrIik7CisJaWYg KElTX0VSUihwaHktPnJ4MF9zeW1ib2xfY2xrKSkgeworCQlkZXZfZXJyKHBoeS0+ZGV2LCAiZmFp bGVkIHRvIGdldCByeDBfc3ltYm9sX2NsayBjbG9ja1xuIik7CisJCWdvdG8gb3V0OworCX0KKwor CXBoeS0+cngxX3N5bWJvbF9jbGsgPSBkZXZtX2Nsa19nZXQocGh5LT5kZXYsICJyeDFfc3ltYm9s X2NsayIpOworCWlmIChJU19FUlIocGh5LT5yeDBfc3ltYm9sX2NsaykpIHsKKwkJZGV2X2Vycihw aHktPmRldiwgImZhaWxlZCB0byBnZXQgcngxX3N5bWJvbF9jbGsgY2xvY2tcbiIpOworCQlnb3Rv IG91dDsKKwl9CisKKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUocGh5LT50eDBfc3ltYm9sX2Ns ayk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKHBoeS0+ZGV2LCAiJXM6IHR4MF9zeW1ib2xfY2xr IGVuYWJsZSBmYWlsZWQgJWRcbiIsCisJCQkJX19mdW5jX18sIHJldCk7CisJCWdvdG8gb3V0Owor CX0KKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUocGh5LT5yeDBfc3ltYm9sX2Nsayk7CisJaWYg KHJldCkgeworCQlkZXZfZXJyKHBoeS0+ZGV2LCAiJXM6IHJ4MF9zeW1ib2xfY2xrIGVuYWJsZSBm YWlsZWQgJWRcbiIsCisJCQkJX19mdW5jX18sIHJldCk7CisJCWdvdG8gb3V0OworCX0KKwlyZXQg PSBjbGtfcHJlcGFyZV9lbmFibGUocGh5LT5yeDFfc3ltYm9sX2Nsayk7CisJaWYgKHJldCkgewor CQlkZXZfZXJyKHBoeS0+ZGV2LCAiJXM6IHJ4MV9zeW1ib2xfY2xrIGVuYWJsZSBmYWlsZWQgJWRc biIsCisJCQkJX19mdW5jX18sIHJldCk7CisJCWdvdG8gb3V0OworCX0KK291dDoKKwlyZXR1cm4g cmV0OworfQorCitzdGF0aWMgaW50IHNhbXN1bmdfdWZzX3BoeV9jbGtzX2luaXQoc3RydWN0IHNh bXN1bmdfdWZzX3BoeSAqcGh5KQoreworCWludCByZXQ7CisKKwlwaHktPnJlZl9jbGsgPSBkZXZt X2Nsa19nZXQocGh5LT5kZXYsICJyZWZfY2xrIik7CisJaWYgKElTX0VSUihwaHktPnJlZl9jbGsp KQorCQlkZXZfZXJyKHBoeS0+ZGV2LCAiZmFpbGVkIHRvIGdldCByZWZfY2xrIGNsb2NrXG4iKTsK KworCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShwaHktPnJlZl9jbGspOworCWlmIChyZXQpIHsK KwkJZGV2X2VycihwaHktPmRldiwgIiVzOiByZWZfY2xrIGVuYWJsZSBmYWlsZWQgJWRcbiIsCisJ CQkJX19mdW5jX18sIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJZGV2X2luZm8ocGh5LT5k ZXYsICJVRlMgTVBIWSByZWZfY2xrX3JhdGUgPSAlbGRcbiIsIGNsa19nZXRfcmF0ZShwaHktPnJl Zl9jbGspKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHNhbXN1bmdfdWZzX3BoeV9p bml0KHN0cnVjdCBwaHkgKnBoeSkKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpfcGh5ID0g Z2V0X3NhbXN1bmdfdWZzX3BoeShwaHkpOworCWludCByZXQ7CisKKwlfcGh5LT5sYW5lX2NudCA9 IHBoeS0+YXR0cnMuYnVzX3dpZHRoOworCV9waHktPnVmc19waHlfc3RhdGUgPSBDRkdfUFJFX0lO SVQ7CisKKwkvKioKKwkgKiBJbiB1ZnMsIFBIWSBuZWVkIHRvIGJlIGNhbGlicmF0ZWQgYXQgZGlm ZmVyZW50IHN0YWdlcyAvIHN0YXRlCisJICogbWFpbmx5IGJlZm9yZSBMaW5rc3RhcnR1cCwgYWZ0 ZXIgTGlua3N0YXJ0dXAsIGJlZm9yZSBwb3dlcgorCSAqIG1vZGUgY2hhbmdlIGFuZCBhZnRlciBw b3dlciBtb2RlIGNoYW5nZS4KKwkgKiBCZWxvdyBzdGF0ZSBtYWNoaW5lIGluaXRpYWxpemUgdGhl IGluaXRpYWwgc3RhdGUgdG8gaGFuZGxlCisJICogUEhZIGNhbGlicmF0aW9uIGF0IHZhcmlvdXMg c3RhZ2VzIG9mIFVGUyBpbml0aWFsaXphdGlvbiBhbmQgcG93ZXIKKwkgKiBtb2RlIGNoYW5nZXMK KwkgKi8KKwlfcGh5LT5pc19wcmVfaW5pdCA9IHRydWU7CisJX3BoeS0+aXNfcG9zdF9pbml0ID0g ZmFsc2U7CisJX3BoeS0+aXNfcHJlX3BtYyA9IGZhbHNlOworCV9waHktPmlzX3Bvc3RfcG1jID0g ZmFsc2U7CisKKworCWlmIChfcGh5LT5kcnZkYXRhLT5oYXNfc3ltYm9sX2NsaykgeworCQlyZXQg PSBzYW1zdW5nX3Vmc19waHlfc3ltYm9sX2Nsa19pbml0KF9waHkpOworCQlpZiAocmV0KQorCQkJ ZGV2X2VycihfcGh5LT5kZXYsCisJCQkJImZhaWxlZCB0byBzZXQgdWZzIHBoeSBzeW1ib2wgY2xv Y2tzXG4iKTsKKwl9CisKKwlyZXQgPSBzYW1zdW5nX3Vmc19waHlfY2xrc19pbml0KF9waHkpOwor CWlmIChyZXQpCisJCWRldl9lcnIoX3BoeS0+ZGV2LCAiZmFpbGVkIHRvIHNldCB1ZnMgcGh5ICBj bG9ja3NcbiIpOworCisJc2Ftc3VuZ191ZnNfcGh5X2NhbGlicmF0ZShwaHkpOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3Bvd2VyX29uKHN0cnVjdCBwaHkg KnBoeSkKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpfcGh5ID0gZ2V0X3NhbXN1bmdfdWZz X3BoeShwaHkpOworCisJc2Ftc3VuZ191ZnNfcGh5X2N0cmxfaXNvbChfcGh5LCBmYWxzZSk7CisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3Bvd2VyX29mZihzdHJ1 Y3QgcGh5ICpwaHkpCit7CisJc3RydWN0IHNhbXN1bmdfdWZzX3BoeSAqX3BoeSA9IGdldF9zYW1z dW5nX3Vmc19waHkocGh5KTsKKworCXNhbXN1bmdfdWZzX3BoeV9jdHJsX2lzb2woX3BoeSwgdHJ1 ZSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Ftc3VuZ191ZnNfcGh5X3NldF9tb2Rl KHN0cnVjdCBwaHkgKmdlbmVyaWNfcGh5LAorCQkJCQllbnVtIHBoeV9tb2RlIG1vZGUsIGludCBz dWJtb2RlKQoreworCXN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKl9waHkgPSBnZXRfc2Ftc3VuZ191 ZnNfcGh5KGdlbmVyaWNfcGh5KTsKKworCV9waHktPm1vZGUgPSBQSFlfTU9ERV9JTlZBTElEOwor CisJaWYgKG1vZGUgPiAwKQorCQlfcGh5LT5tb2RlID0gbW9kZTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgaW50IHNhbXN1bmdfdWZzX3BoeV9leGl0KHN0cnVjdCBwaHkgKnBoeSkKK3sKKwlz dHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpfcGh5ID0gZ2V0X3NhbXN1bmdfdWZzX3BoeShwaHkpOwor CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKF9waHktPnJlZl9jbGspOworCisJaWYgKF9waHktPmRy dmRhdGEtPmhhc19zeW1ib2xfY2xrKSB7CisJCWNsa19kaXNhYmxlX3VucHJlcGFyZShfcGh5LT50 eDBfc3ltYm9sX2Nsayk7CisJCWNsa19kaXNhYmxlX3VucHJlcGFyZShfcGh5LT5yeDBfc3ltYm9s X2Nsayk7CisJCWNsa19kaXNhYmxlX3VucHJlcGFyZShfcGh5LT5yeDFfc3ltYm9sX2Nsayk7CisJ fQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGh5X29wcyBzYW1zdW5nX3Vmc19w aHlfb3BzID0geworCS5pbml0CQk9IHNhbXN1bmdfdWZzX3BoeV9pbml0LAorCS5leGl0CQk9IHNh bXN1bmdfdWZzX3BoeV9leGl0LAorCS5wb3dlcl9vbgk9IHNhbXN1bmdfdWZzX3BoeV9wb3dlcl9v biwKKwkucG93ZXJfb2ZmCT0gc2Ftc3VuZ191ZnNfcGh5X3Bvd2VyX29mZiwKKwkuY2FsaWJyYXRl CT0gc2Ftc3VuZ191ZnNfcGh5X2NhbGlicmF0ZSwKKwkuc2V0X21vZGUJPSBzYW1zdW5nX3Vmc19w aHlfc2V0X21vZGUsCisJLm93bmVyICAgICAgICAgID0gVEhJU19NT0RVTEUsCit9OworCitzdGF0 aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBzYW1zdW5nX3Vmc19waHlfbWF0Y2hbXTsKKwor c3RhdGljIGludCBzYW1zdW5nX3Vmc19waHlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldikKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCWNvbnN0IHN0cnVj dCBvZl9kZXZpY2VfaWQgKm1hdGNoOworCXN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKnBoeTsKKwlz dHJ1Y3QgcGh5ICpnZW5fcGh5OworCXN0cnVjdCBwaHlfcHJvdmlkZXIgKnBoeV9wcm92aWRlcjsK Kwljb25zdCBzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2RydmRhdGEgKmRydmRhdGE7CisJaW50IGVy ciA9IDA7CisKKwltYXRjaCA9IG9mX21hdGNoX25vZGUoc2Ftc3VuZ191ZnNfcGh5X21hdGNoLCBk ZXYtPm9mX25vZGUpOworCWlmICghbWF0Y2gpIHsKKwkJZXJyID0gLUVJTlZBTDsKKwkJZGV2X2Vy cihkZXYsICJmYWlsZWQgdG8gZ2V0IG1hdGNoX25vZGVcbiIpOworCQlnb3RvIG91dDsKKwl9CisK KwlwaHkgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnBoeSksIEdGUF9LRVJORUwpOworCWlm ICghcGh5KSB7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gb3V0OworCX0KKworCXBoeS0+cmVn X3BtYSA9IGRldm1fcGxhdGZvcm1faW9yZW1hcF9yZXNvdXJjZV9ieW5hbWUocGRldiwgInBoeS1w bWEiKTsKKwlpZiAoSVNfRVJSKHBoeS0+cmVnX3BtYSkpIHsKKwkJZXJyID0gUFRSX0VSUihwaHkt PnJlZ19wbWEpOworCQlnb3RvIG91dDsKKwl9CisKKwlwaHktPnJlZ19wbXUgPSBzeXNjb25fcmVn bWFwX2xvb2t1cF9ieV9waGFuZGxlKAorCQkJCWRldi0+b2Zfbm9kZSwgInNhbXN1bmcscG11LXN5 c2NvbiIpOworCWlmIChJU19FUlIocGh5LT5yZWdfcG11KSkgeworCQllcnIgPSBQVFJfRVJSKHBo eS0+cmVnX3BtdSk7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHN5c2NvbiByZW1hcCBmb3IgcG11 XG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZ2VuX3BoeSA9IGRldm1fcGh5X2NyZWF0ZShkZXYs IE5VTEwsICZzYW1zdW5nX3Vmc19waHlfb3BzKTsKKwlpZiAoSVNfRVJSKGdlbl9waHkpKSB7CisJ CWVyciA9IFBUUl9FUlIoZ2VuX3BoeSk7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNyZWF0 ZSBQSFkgZm9yIHVmcy1waHlcbiIpOworCQlnb3RvIG91dDsKKwl9CisKKwlkcnZkYXRhID0gbWF0 Y2gtPmRhdGE7CisJcGh5LT5kZXYgPSBkZXY7CisJcGh5LT5kcnZkYXRhID0gZHJ2ZGF0YTsKKwlw aHktPmNmZyA9IChzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyAqKilkcnZkYXRhLT5jZmc7CisJ cGh5LT5pc29sID0gJmRydmRhdGEtPmlzb2w7CisJcGh5LT5sYW5lX2NudCA9IFBIWV9ERUZfTEFO RV9DTlQ7CisKKwlwaHlfc2V0X2RydmRhdGEoZ2VuX3BoeSwgcGh5KTsKKworCXBoeV9wcm92aWRl ciA9IGRldm1fb2ZfcGh5X3Byb3ZpZGVyX3JlZ2lzdGVyKGRldiwgb2ZfcGh5X3NpbXBsZV94bGF0 ZSk7CisJaWYgKElTX0VSUihwaHlfcHJvdmlkZXIpKSB7CisJCWVyciA9IFBUUl9FUlIocGh5X3By b3ZpZGVyKTsKKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgcGh5LXByb3ZpZGVy XG4iKTsKKwkJZ290byBvdXQ7CisJfQorb3V0OgorCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHNhbXN1bmdfdWZzX3BoeV9tYXRjaFtdID0geworCXsK KwkJLmNvbXBhdGlibGUgPSAic2Ftc3VuZyxleHlub3M3LXVmcy1waHkiLAorCQkuZGF0YSA9ICZl eHlub3M3X3Vmc19waHksCisJfSwKKwl7fSwKK307CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBz YW1zdW5nX3Vmc19waHlfbWF0Y2gpOworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBz YW1zdW5nX3Vmc19waHlfZHJpdmVyID0geworCS5wcm9iZSAgPSBzYW1zdW5nX3Vmc19waHlfcHJv YmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAic2Ftc3VuZy11ZnMtcGh5IiwKKwkJLm9mX21h dGNoX3RhYmxlID0gc2Ftc3VuZ191ZnNfcGh5X21hdGNoLAorCX0sCit9OworbW9kdWxlX3BsYXRm b3JtX2RyaXZlcihzYW1zdW5nX3Vmc19waHlfZHJpdmVyKTsKK01PRFVMRV9ERVNDUklQVElPTigi U2Ftc3VuZyBTb0MgVUZTIFBIWSBEcml2ZXIiKTsKK01PRFVMRV9BVVRIT1IoIlNldW5nd29uIEpl b24gPGVzc3V1akBnbWFpbC5jb20+Iik7CitNT0RVTEVfQVVUSE9SKCJBbGltIEFraHRhciA8YWxp bS5ha2h0YXJAc2Ftc3VuZy5jb20+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7CmRpZmYg LS1naXQgYS9kcml2ZXJzL3BoeS9zYW1zdW5nL3BoeS1zYW1zdW5nLXVmcy5oIGIvZHJpdmVycy9w aHkvc2Ftc3VuZy9waHktc2Ftc3VuZy11ZnMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLjFjYzgxNGQ5NzJlOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGh5 L3NhbXN1bmcvcGh5LXNhbXN1bmctdWZzLmgKQEAgLTAsMCArMSwxNDMgQEAKKy8qIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KKy8qCisgKiBVRlMgUEhZIGRyaXZlciBm b3IgU2Ftc3VuZyBFWFlOT1MgU29DCisgKgorICogQ29weXJpZ2h0IChDKSAyMDIwIFNhbXN1bmcg RWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKiBBdXRob3I6IFNldW5nd29uIEplb24gPGVzc3V1akBn bWFpbC5jb20+CisgKiBBdXRob3I6IEFsaW0gQWtodGFyIDxhbGltLmFraHRhckBzYW1zdW5nLmNv bT4KKyAqCisgKi8KKyNpZm5kZWYgX1BIWV9TQU1TVU5HX1VGU18KKyNkZWZpbmUgX1BIWV9TQU1T VU5HX1VGU18KKworI2RlZmluZSBQSFlfQ09NTl9CTEsJMQorI2RlZmluZSBQSFlfVFJTVl9CTEsJ MgorI2RlZmluZSBFTkRfVUZTX1BIWV9DRkcgeyAwIH0KKyNkZWZpbmUgUEhZX1RSU1ZfQ0hfT0ZG U0VUCTB4MzAKKyNkZWZpbmUgUEhZX0FQQl9BRERSKG9mZikJKChvZmYpIDw8IDIpCisKKyNkZWZp bmUgUEhZX0NPTU5fUkVHX0NGRyhvLCB2LCBkKSB7CVwKKwkub2ZmXzAgPSBQSFlfQVBCX0FERFIo KG8pKSwJXAorCS5vZmZfMSA9IDAsCQlcCisJLnZhbCA9ICh2KSwJCVwKKwkuZGVzYyA9IChkKSwJ CVwKKwkuaWQgPSBQSFlfQ09NTl9CTEssCVwKK30KKworI2RlZmluZSBQSFlfVFJTVl9SRUdfQ0ZH KG8sIHYsIGQpIHsJXAorCS5vZmZfMCA9IFBIWV9BUEJfQUREUigobykpLAlcCisJLm9mZl8xID0g UEhZX0FQQl9BRERSKChvKSArIFBIWV9UUlNWX0NIX09GRlNFVCksCVwKKwkudmFsID0gKHYpLAkJ XAorCS5kZXNjID0gKGQpLAkJXAorCS5pZCA9IFBIWV9UUlNWX0JMSywJXAorfQorCisvKiBVRlMg UEhZIHJlZ2lzdGVycyAqLworI2RlZmluZSBQSFlfUExMX0xPQ0tfU1RBVFVTCTB4MWUKKyNkZWZp bmUgUEhZX0NEUl9MT0NLX1NUQVRVUwkweDVlCisKKyNkZWZpbmUgUEhZX1BMTF9MT0NLX0JJVAlC SVQoNSkKKyNkZWZpbmUgUEhZX0NEUl9MT0NLX0JJVAlCSVQoNCkKKworLyogZGVzY3JpcHRpb24g Zm9yIFBIWSBjYWxpYnJhdGlvbiAqLworZW51bSB7CisJLyogYXBwbGljYWJsZSB0byBhbnkgKi8K KwlQV1JfREVTQ19BTlkJPSAwLAorCS8qIG1vZGUgKi8KKwlQV1JfREVTQ19QV00JPSAxLAorCVBX Ul9ERVNDX0hTCT0gMiwKKwkvKiBzZXJpZXMgKi8KKwlQV1JfREVTQ19TRVJfQQk9IDEsCisJUFdS X0RFU0NfU0VSX0IJPSAyLAorCS8qIGdlYXIgKi8KKwlQV1JfREVTQ19HMQk9IDEsCisJUFdSX0RF U0NfRzIJPSAyLAorCVBXUl9ERVNDX0czCT0gMywKKwkvKiBmaWVsZCBtYXNrICovCisJTURfTUFT SwkJPSAweDMsCisJU1JfTUFTSwkJPSAweDMsCisJR1JfTUFTSwkJPSAweDcsCit9OworCisjZGVm aW5lIFBXUl9NT0RFX0hTX0cxX0FOWQlQV1JfTU9ERV9IUyhQV1JfREVTQ19HMSwgUFdSX0RFU0Nf QU5ZKQorI2RlZmluZSBQV1JfTU9ERV9IU19HMV9TRVJfQQlQV1JfTU9ERV9IUyhQV1JfREVTQ19H MSwgUFdSX0RFU0NfU0VSX0EpCisjZGVmaW5lIFBXUl9NT0RFX0hTX0cxX1NFUl9CCVBXUl9NT0RF X0hTKFBXUl9ERVNDX0cxLCBQV1JfREVTQ19TRVJfQikKKyNkZWZpbmUgUFdSX01PREVfSFNfRzJf QU5ZCVBXUl9NT0RFX0hTKFBXUl9ERVNDX0cyLCBQV1JfREVTQ19BTlkpCisjZGVmaW5lIFBXUl9N T0RFX0hTX0cyX1NFUl9BCVBXUl9NT0RFX0hTKFBXUl9ERVNDX0cyLCBQV1JfREVTQ19TRVJfQSkK KyNkZWZpbmUgUFdSX01PREVfSFNfRzJfU0VSX0IJUFdSX01PREVfSFMoUFdSX0RFU0NfRzIsIFBX Ul9ERVNDX1NFUl9CKQorI2RlZmluZSBQV1JfTU9ERV9IU19HM19BTlkJUFdSX01PREVfSFMoUFdS X0RFU0NfRzMsIFBXUl9ERVNDX0FOWSkKKyNkZWZpbmUgUFdSX01PREVfSFNfRzNfU0VSX0EJUFdS X01PREVfSFMoUFdSX0RFU0NfRzMsIFBXUl9ERVNDX1NFUl9BKQorI2RlZmluZSBQV1JfTU9ERV9I U19HM19TRVJfQglQV1JfTU9ERV9IUyhQV1JfREVTQ19HMywgUFdSX0RFU0NfU0VSX0IpCisjZGVm aW5lIFBXUl9NT0RFKGcsIHMsIG0pCSgoKChnKSAmIEdSX01BU0spIDw8IDQpIHxcCisJCQkJICgo KHMpICYgU1JfTUFTSykgPDwgMikgfCAoKG0pICYgTURfTUFTSykpCisjZGVmaW5lIFBXUl9NT0RF X1BXTV9BTlkJUFdSX01PREUoUFdSX0RFU0NfQU5ZLFwKKwkJCQkJIFBXUl9ERVNDX0FOWSwgUFdS X0RFU0NfUFdNKQorI2RlZmluZSBQV1JfTU9ERV9IUyhnLCBzKQkoKCgoZykgJiBHUl9NQVNLKSA8 PCA0KSB8XAorCQkJCSAoKChzKSAmIFNSX01BU0spIDw8IDIpIHwgUFdSX0RFU0NfSFMpCisjZGVm aW5lIFBXUl9NT0RFX0hTX0FOWQkJUFdSX01PREUoUFdSX0RFU0NfQU5ZLFwKKwkJCQkJIFBXUl9E RVNDX0FOWSwgUFdSX0RFU0NfSFMpCisjZGVmaW5lIFBXUl9NT0RFX0FOWQkJUFdSX01PREUoUFdS X0RFU0NfQU5ZLFwKKwkJCQkJIFBXUl9ERVNDX0FOWSwgUFdSX0RFU0NfQU5ZKQorLyogUEhZIGNh bGlicmF0aW9uIHBvaW50L3N0YXRlICovCitlbnVtIHsKKwlDRkdfUFJFX0lOSVQsCisJQ0ZHX1BP U1RfSU5JVCwKKwlDRkdfUFJFX1BXUl9IUywKKwlDRkdfUE9TVF9QV1JfSFMsCisJQ0ZHX1RBR19N QVgsCit9OworCitzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2NmZyB7CisJdTMyIG9mZl8wOworCXUz MiBvZmZfMTsKKwl1MzIgdmFsOworCXU4IGRlc2M7CisJdTggaWQ7Cit9OworCitzdHJ1Y3Qgc2Ft c3VuZ191ZnNfcGh5X2RydmRhdGEgeworCWNvbnN0IHN0cnVjdCBzYW1zdW5nX3Vmc19waHlfY2Zn ICoqY2ZnOworCXN0cnVjdCBwbXVfaXNvbCB7CisJCXUzMiBvZmZzZXQ7CisJCXUzMiBtYXNrOwor CQl1MzIgZW47CisJfSBpc29sOworCWJvb2wgaGFzX3N5bWJvbF9jbGs7Cit9OworCitzdHJ1Y3Qg c2Ftc3VuZ191ZnNfcGh5IHsKKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisJdm9pZCBfX2lvbWVtICpy ZWdfcG1hOworCXN0cnVjdCByZWdtYXAgKnJlZ19wbXU7CisJc3RydWN0IGNsayAqcmVmX2NsazsK KwlzdHJ1Y3QgY2xrICpyZWZfY2xrX3BhcmVudDsKKwlzdHJ1Y3QgY2xrICp0eDBfc3ltYm9sX2Ns azsKKwlzdHJ1Y3QgY2xrICpyeDBfc3ltYm9sX2NsazsKKwlzdHJ1Y3QgY2xrICpyeDFfc3ltYm9s X2NsazsKKwljb25zdCBzdHJ1Y3Qgc2Ftc3VuZ191ZnNfcGh5X2RydmRhdGEgKmRydmRhdGE7CisJ c3RydWN0IHNhbXN1bmdfdWZzX3BoeV9jZmcgKipjZmc7CisJY29uc3Qgc3RydWN0IHBtdV9pc29s ICppc29sOworCXU4IGxhbmVfY250OworCWludCB1ZnNfcGh5X3N0YXRlOworCWVudW0gcGh5X21v ZGUgbW9kZTsKKwlib29sIGlzX3ByZV9pbml0OworCWJvb2wgaXNfcG9zdF9pbml0OworCWJvb2wg aXNfcHJlX3BtYzsKKwlib29sIGlzX3Bvc3RfcG1jOworfTsKKworc3RhdGljIGlubGluZSBzdHJ1 Y3Qgc2Ftc3VuZ191ZnNfcGh5ICpnZXRfc2Ftc3VuZ191ZnNfcGh5KHN0cnVjdCBwaHkgKnBoeSkK K3sKKwlyZXR1cm4gKHN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKilwaHlfZ2V0X2RydmRhdGEocGh5 KTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHNhbXN1bmdfdWZzX3BoeV9jdHJsX2lzb2woCisJ CXN0cnVjdCBzYW1zdW5nX3Vmc19waHkgKnBoeSwgdTMyIGlzb2wpCit7CisJcmVnbWFwX3VwZGF0 ZV9iaXRzKHBoeS0+cmVnX3BtdSwgcGh5LT5pc29sLT5vZmZzZXQsCisJCQlwaHktPmlzb2wtPm1h c2ssIGlzb2wgPyAwIDogcGh5LT5pc29sLT5lbik7Cit9CisKKyNpbmNsdWRlICJwaHktZXh5bm9z Ny11ZnMuaCIKKworI2VuZGlmIC8qIF9QSFlfU0FNU1VOR19VRlNfICovCi0tIAoyLjE3LjEKCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0t a2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcK aHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2Vy bmVsCg==