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=-8.3 required=3.0 tests=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_SANE_1 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 051EBC2D0BF for ; Mon, 16 Dec 2019 16:01:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id CF57D2072D for ; Mon, 16 Dec 2019 16:01:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="bi6Ncj3c" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725805AbfLPQB5 (ORCPT ); Mon, 16 Dec 2019 11:01:57 -0500 Received: from mail-wr1-f65.google.com ([209.85.221.65]:33204 "EHLO mail-wr1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726133AbfLPQB5 (ORCPT ); Mon, 16 Dec 2019 11:01:57 -0500 Received: by mail-wr1-f65.google.com with SMTP id b6so7947591wrq.0 for ; Mon, 16 Dec 2019 08:01:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=iVi4d1hXj9sCF/T+xKr7+t6XuBrWW4vQrD/W9yh8xMk=; b=bi6Ncj3c4LKJV+oZP7eVxd3CacAlmEyPBDJuq4m8qlPBdTy0zZI7+74QNJ08kvSy1z 4qs4Z0khCO0gBJtczslIPTQe3kDQ3D/dXE6BAYYLen6zqKjdEV6oJjVWE3mWoLWWsUaH StxNh+MRsCAiRENpHEqpZpa6Q9Dzs31FPKCFQLy/Ub2MlOt9ElBeoKlYSyOpWil290Vn jHkyMt73D/TLxc5hhe2+TqV1gYGaiRnJR6e9gc3Ip9DVjyBfaqhnKFWQs/0pSamhdM1N Qeoa59w3J6tWG30OQ2dycrrNHjXvqXOTLwRGxuc+rpyN4yuXfmcdv58PKNsNc/ypE4HQ m5DA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=iVi4d1hXj9sCF/T+xKr7+t6XuBrWW4vQrD/W9yh8xMk=; b=je88l/PjD/x/E9DNhgCfB5THrjxqdxbi/ZCE/UAQ1K+W90mTl2meALpqX/9L7I6JnL pDY4+0xQvhJaD2kLeL5ltleEMEnUYTynWtS+OD4I0cR+LgwrfvtX/hv/i39QEQqAcEqu fztX0QwVbjzOoRxmkQnQxfdm9+a2n0KpQU9Gdaz2vPkxMc8Lcr5omSjokdk9pxn639mF 2V/R7wjBI9UFS6+CdP0b98pJoF92NcJCmFpl4Ghu3bwxtfnvrJELCfQUDVyQ6MJyqFYw WAhvAfnpOIO1ubo7g4r95ejpx/vqL4Bnfm1OXbcQi/xy8JfGtCM/3ZV3Uhg6Jt3ZD14R +76w== X-Gm-Message-State: APjAAAWaOOUN14QQfSjWYvyB0QNS8XLHGrPuyAhTVsaAp+tVK3Fma2Zj 194zKPGg+BQrEJg4vUhb4bGJWw== X-Google-Smtp-Source: APXvYqzS//inX4T6XOJButeH/xgQHuUYoLLDVn3hiYsKGFpbfOiZsVcbDBgmj292KCOcdA/mH5Tqkg== X-Received: by 2002:adf:a141:: with SMTP id r1mr31625583wrr.285.1576512112855; Mon, 16 Dec 2019 08:01:52 -0800 (PST) Received: from dell ([185.17.149.202]) by smtp.gmail.com with ESMTPSA id k19sm19756354wmi.42.2019.12.16.08.01.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Dec 2019 08:01:51 -0800 (PST) Date: Mon, 16 Dec 2019 16:01:45 +0000 From: Lee Jones To: Jae Hyun Yoo Cc: Rob Herring , Greg Kroah-Hartman , Jean Delvare , Guenter Roeck , Mark Rutland , Joel Stanley , Andrew Jeffery , Jonathan Corbet , Gustavo Pimentel , Kishon Vijay Abraham I , Lorenzo Pieralisi , "Darrick J . Wong" , Eric Sandeen , Arnd Bergmann , Wu Hao , Tomohiro Kusumi , "Bryant G . Ly" , Frederic Barrat , "David S . Miller" , Mauro Carvalho Chehab , Andrew Morton , Randy Dunlap , Philippe Ombredanne , Vinod Koul , Stephen Boyd , David Kershner , Uwe Kleine-Konig , Sagar Dharia , Johan Hovold , Thomas Gleixner , Juergen Gross , Cyrille Pitchen , Tomer Maimon , linux-hwmon@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, openbmc@lists.ozlabs.org, James Feist , Jason M Biils , Vernon Mauery Subject: Re: [PATCH v11 11/14] mfd: intel-peci-client: Add Intel PECI client driver Message-ID: <20191216160145.GL2369@dell> References: <20191211194624.2872-1-jae.hyun.yoo@linux.intel.com> <20191211194624.2872-12-jae.hyun.yoo@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20191211194624.2872-12-jae.hyun.yoo@linux.intel.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-doc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-doc@vger.kernel.org On Wed, 11 Dec 2019, Jae Hyun Yoo wrote: > This commit adds Intel PECI client driver. > > Cc: Lee Jones > Cc: Randy Dunlap > Cc: Rob Herring > Cc: Andrew Jeffery > Cc: James Feist > Cc: Jason M Biils > Cc: Joel Stanley > Cc: Vernon Mauery > Signed-off-by: Jae Hyun Yoo > --- > Changes since v10: > - Fixed minor style issues. > > drivers/mfd/Kconfig | 17 +++ > drivers/mfd/Makefile | 1 + > drivers/mfd/intel-peci-client.c | 149 ++++++++++++++++++++++++++ > include/linux/mfd/intel-peci-client.h | 117 ++++++++++++++++++++ > 4 files changed, 284 insertions(+) > create mode 100644 drivers/mfd/intel-peci-client.c > create mode 100644 include/linux/mfd/intel-peci-client.h > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index 420900852166..7022e54a4703 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -632,6 +632,23 @@ config MFD_INTEL_MSIC > Passage) chip. This chip embeds audio, battery, GPIO, etc. > devices used in Intel Medfield platforms. > > +config MFD_INTEL_PECI_CLIENT > + tristate "Intel PECI client" > + depends on (PECI || COMPILE_TEST) > + select MFD_CORE > + help > + If you say yes to this option, support will be included for the > + Intel PECI (Platform Environment Control Interface) client. PECI is a > + one-wire bus interface that provides a communication channel from PECI > + clients in Intel processors and chipset components to external > + monitoring or control devices. > + > + Additional drivers must be enabled in order to use the functionality > + of the device. > + > + This driver can also be built as a module. If so, the module > + will be called intel-peci-client. > + > config MFD_IPAQ_MICRO > bool "Atmel Micro ASIC (iPAQ h3100/h3600/h3700) Support" > depends on SA1100_H3100 || SA1100_H3600 > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index aed99f08739f..91c6fda5cec6 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -211,6 +211,7 @@ obj-$(CONFIG_MFD_INTEL_LPSS) += intel-lpss.o > obj-$(CONFIG_MFD_INTEL_LPSS_PCI) += intel-lpss-pci.o > obj-$(CONFIG_MFD_INTEL_LPSS_ACPI) += intel-lpss-acpi.o > obj-$(CONFIG_MFD_INTEL_MSIC) += intel_msic.o > +obj-$(CONFIG_MFD_INTEL_PECI_CLIENT) += intel-peci-client.o > obj-$(CONFIG_MFD_PALMAS) += palmas.o > obj-$(CONFIG_MFD_VIPERBOARD) += viperboard.o > obj-$(CONFIG_MFD_RC5T583) += rc5t583.o rc5t583-irq.o > diff --git a/drivers/mfd/intel-peci-client.c b/drivers/mfd/intel-peci-client.c > new file mode 100644 > index 000000000000..18bf0af0e09e > --- /dev/null > +++ b/drivers/mfd/intel-peci-client.c > @@ -0,0 +1,149 @@ > +// SPDX-License-Identifier: GPL-2.0 > +// Copyright (c) 2018-2019 Intel Corporation > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#define CPU_ID_MODEL_MASK GENMASK(7, 4) > +#define CPU_ID_FAMILY_MASK GENMASK(11, 8) > +#define CPU_ID_EXT_MODEL_MASK GENMASK(19, 16) > +#define CPU_ID_EXT_FAMILY_MASK GENMASK(27, 20) > + > +#define LOWER_NIBBLE_MASK GENMASK(3, 0) > +#define UPPER_NIBBLE_MASK GENMASK(7, 4) > +#define LOWER_BYTE_MASK GENMASK(7, 0) > +#define UPPER_BYTE_MASK GENMASK(16, 8) > + > +static struct mfd_cell peci_functions[] = { > + { .name = "peci-cputemp", }, > + { .name = "peci-dimmtemp", }, > + /* TODO: Add additional PECI sideband functions into here */ No need for this comment. It's implied. > +}; > + > +static const struct cpu_gen_info cpu_gen_info_table[] = { > + { /* Haswell Xeon */ > + .family = 6, /* Family code */ Nit: Why don't you just define the number, instead of feeling the need to further clarify by providing a comment? > + .model = INTEL_FAM6_HASWELL_X, > + .core_max = CORE_MAX_ON_HSX, > + .chan_rank_max = CHAN_RANK_MAX_ON_HSX, > + .dimm_idx_max = DIMM_IDX_MAX_ON_HSX }, > + { /* Broadwell Xeon */ > + .family = 6, /* Family code */ > + .model = INTEL_FAM6_BROADWELL_X, > + .core_max = CORE_MAX_ON_BDX, > + .chan_rank_max = CHAN_RANK_MAX_ON_BDX, > + .dimm_idx_max = DIMM_IDX_MAX_ON_BDX }, > + { /* Skylake Xeon */ > + .family = 6, /* Family code */ > + .model = INTEL_FAM6_SKYLAKE_X, > + .core_max = CORE_MAX_ON_SKX, > + .chan_rank_max = CHAN_RANK_MAX_ON_SKX, > + .dimm_idx_max = DIMM_IDX_MAX_ON_SKX }, > + { /* Skylake Xeon D */ > + .family = 6, /* Family code */ > + .model = INTEL_FAM6_SKYLAKE_XD, > + .core_max = CORE_MAX_ON_SKXD, > + .chan_rank_max = CHAN_RANK_MAX_ON_SKXD, > + .dimm_idx_max = DIMM_IDX_MAX_ON_SKXD }, > +}; > + > +static int peci_client_get_cpu_gen_info(struct peci_client_manager *priv) > +{ > + struct device *dev = &priv->client->dev; > + u32 cpu_id; > + u16 family; > + u8 model; > + int ret; > + int i; > + > + ret = peci_get_cpu_id(priv->client->adapter, priv->client->addr, > + &cpu_id); > + if (ret) > + return ret; > + > + family = FIELD_PREP(LOWER_BYTE_MASK, > + FIELD_GET(CPU_ID_FAMILY_MASK, cpu_id)) | > + FIELD_PREP(UPPER_BYTE_MASK, > + FIELD_GET(CPU_ID_EXT_FAMILY_MASK, cpu_id)); > + model = FIELD_PREP(LOWER_NIBBLE_MASK, > + FIELD_GET(CPU_ID_MODEL_MASK, cpu_id)) | > + FIELD_PREP(UPPER_NIBBLE_MASK, > + FIELD_GET(CPU_ID_EXT_MODEL_MASK, cpu_id)); > + > + for (i = 0; i < ARRAY_SIZE(cpu_gen_info_table); i++) { > + const struct cpu_gen_info *cpu_info = &cpu_gen_info_table[i]; > + > + if (family == cpu_info->family && model == cpu_info->model) { > + priv->gen_info = cpu_info; > + break; > + } > + } > + > + if (!priv->gen_info) { > + dev_err(dev, "Can't support this CPU: 0x%x\n", cpu_id); > + ret = -ENODEV; > + } > + > + return ret; > +} > + > +static int peci_client_probe(struct peci_client *client) > +{ > + struct device *dev = &client->dev; > + struct peci_client_manager *priv; > + uint cpu_no; > + int ret; > + > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + dev_set_drvdata(dev, priv); > + priv->client = client; > + cpu_no = client->addr - PECI_BASE_ADDR; > + > + ret = peci_client_get_cpu_gen_info(priv); > + if (ret) > + return ret; > + > + ret = devm_mfd_add_devices(dev, cpu_no, peci_functions, > + ARRAY_SIZE(peci_functions), NULL, 0, NULL); > + if (ret < 0) { > + dev_err(dev, "Failed to register child devices: %d\n", ret); > + return ret; > + } > + > + return 0; > +} > + > +#if IS_ENABLED(CONFIG_OF) #ifdef CONFIG_OF > +static const struct of_device_id peci_client_of_table[] = { > + { .compatible = "intel,peci-client" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, peci_client_of_table); > +#endif /* CONFIG_OF */ Please remove this comment. It doesn't provide anything here. > +static const struct peci_device_id peci_client_ids[] = { > + { .name = "peci-client" }, > + { } > +}; > +MODULE_DEVICE_TABLE(peci, peci_client_ids); Is this a requirement? If so, why? We're trying to get rid of unnecessary tables. Please grep for "probe_new". > +static struct peci_driver peci_client_driver = { > + .probe = peci_client_probe, > + .id_table = peci_client_ids, > + .driver = { > + .name = KBUILD_MODNAME, > + .of_match_table = of_match_ptr(peci_client_of_table), > + }, > +}; > +module_peci_driver(peci_client_driver); > + > +MODULE_AUTHOR("Jae Hyun Yoo "); > +MODULE_DESCRIPTION("PECI client driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/include/linux/mfd/intel-peci-client.h b/include/linux/mfd/intel-peci-client.h > new file mode 100644 > index 000000000000..9854303bbc26 > --- /dev/null > +++ b/include/linux/mfd/intel-peci-client.h > @@ -0,0 +1,117 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* Copyright (c) 2018-2019 Intel Corporation */ > + > +#ifndef __LINUX_MFD_INTEL_PECI_CLIENT_H > +#define __LINUX_MFD_INTEL_PECI_CLIENT_H > + > +#include > + > +#if IS_ENABLED(CONFIG_X86) > +#include > +#else > +/* > + * Architectures other than x86 cannot include the header file so define these > + * at here. These are needed for detecting type of client x86 CPUs behind a PECI > + * connection. > + */ > +#define INTEL_FAM6_HASWELL_X 0x3F > +#define INTEL_FAM6_BROADWELL_X 0x4F > +#define INTEL_FAM6_SKYLAKE_X 0x55 > +#define INTEL_FAM6_SKYLAKE_XD 0x56 > +#endif > + > +#define CORE_MAX_ON_HSX 18 /* Max number of cores on Haswell */ > +#define CHAN_RANK_MAX_ON_HSX 8 /* Max number of channel ranks on Haswell */ > +#define DIMM_IDX_MAX_ON_HSX 3 /* Max DIMM index per channel on Haswell */ > + > +#define CORE_MAX_ON_BDX 24 /* Max number of cores on Broadwell */ > +#define CHAN_RANK_MAX_ON_BDX 4 /* Max number of channel ranks on Broadwell */ > +#define DIMM_IDX_MAX_ON_BDX 3 /* Max DIMM index per channel on Broadwell */ > + > +#define CORE_MAX_ON_SKX 28 /* Max number of cores on Skylake */ > +#define CHAN_RANK_MAX_ON_SKX 6 /* Max number of channel ranks on Skylake */ > +#define DIMM_IDX_MAX_ON_SKX 2 /* Max DIMM index per channel on Skylake */ > + > +#define CORE_MAX_ON_SKXD 16 /* Max number of cores on Skylake D */ > +#define CHAN_RANK_MAX_ON_SKXD 2 /* Max number of channel ranks on Skylake D */ > +#define DIMM_IDX_MAX_ON_SKXD 2 /* Max DIMM index per channel on Skylake D */ > + > +#define CORE_NUMS_MAX CORE_MAX_ON_SKX > +#define CHAN_RANK_MAX CHAN_RANK_MAX_ON_HSX > +#define DIMM_IDX_MAX DIMM_IDX_MAX_ON_HSX > +#define DIMM_NUMS_MAX (CHAN_RANK_MAX * DIMM_IDX_MAX) > + > +/** > + * struct cpu_gen_info - CPU generation specific information > + * @family: CPU family ID > + * @model: CPU model > + * @core_max: max number of cores > + * @chan_rank_max: max number of channel ranks > + * @dimm_idx_max: max number of DIMM indices > + * > + * CPU generation specific information to identify maximum number of cores and > + * DIMM slots. > + */ > +struct cpu_gen_info { > + u16 family; > + u8 model; > + uint core_max; > + uint chan_rank_max; > + uint dimm_idx_max; > +}; > + > +/** > + * struct peci_client_manager - PECI client manager information > + * @client; pointer to the PECI client > + * @name: PECI client manager name > + * @gen_info: CPU generation info of the detected CPU > + * > + * PECI client manager information for managing PECI sideband functions on a CPU > + * client. > + */ > +struct peci_client_manager { > + struct peci_client *client; > + char name[PECI_NAME_SIZE]; > + const struct cpu_gen_info *gen_info; > +}; > + > +/** > + * peci_client_read_package_config - read from the Package Configuration Space > + * @priv: driver private data structure > + * @index: encoding index for the requested service > + * @param: parameter to specify the exact data being requested > + * @data: data buffer to store the result > + * Context: can sleep > + * > + * A generic PECI command that provides read access to the > + * "Package Configuration Space" that is maintained by the PCU, including > + * various power and thermal management functions. Typical PCS read services > + * supported by the processor may include access to temperature data, energy > + * status, run time information, DIMM temperatures and so on. > + * > + * Return: zero on success, else a negative error code. > + */ > +static inline int > +peci_client_read_package_config(struct peci_client_manager *priv, > + u8 index, u16 param, u8 *data) > +{ > + struct peci_rd_pkg_cfg_msg msg; > + int ret; > + > + msg.addr = priv->client->addr; > + msg.index = index; > + msg.param = param; > + msg.rx_len = 4; > + > + ret = peci_command(priv->client->adapter, PECI_CMD_RD_PKG_CFG, &msg); > + if (msg.cc != PECI_DEV_CC_SUCCESS) > + ret = -EAGAIN; > + if (ret) > + return ret; > + > + memcpy(data, msg.pkg_config, 4); > + > + return 0; > +} Where is this function used? > +#endif /* __LINUX_MFD_INTEL_PECI_CLIENT_H */ -- Lee Jones [李琼斯] Linaro Services Technical Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog 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=-8.3 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,USER_AGENT_SANE_1 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 75A94C43603 for ; Mon, 16 Dec 2019 16:02:19 +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 441DD2067C for ; Mon, 16 Dec 2019 16:02:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="mmqkbmwC"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="bi6Ncj3c" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 441DD2067C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org 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:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=7x2nqnhe5mYcAWLMI1R4i+YvUXDDfPIC4C14Qifqp9k=; b=mmqkbmwCaNGhM8 xumpbfnBOUzEJki4inYv7xYdClUaUm1xg+H4UUeuJ7YiMO8XIvmYKJRhvo5pw0SqVfiyRXOSal+LX EsJX9Ejf9Jb21ASAaIaz3Xafh0i++P3U9388wFwyR4SOI1Y57LrjRyepV/GACC6uXY3fqnxg4wqee MyZjMPE71PH2qwwgIrgt8i8ubEvIEtVEFWo3VZAPHlNE9l35Tflr3AMjrGy7jTtcKymnBjbwgRuWK Hcy9gIspPxXDlN/kyVDmryUvFUXBsZd5kX80l+zZBWnbLCygnI1rsyOxl5/9M1CKIbEVyDNIMSJ/u 0IKzjC+hMCuKFuc5kzKQ==; 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 1igsop-0007Pz-4t; Mon, 16 Dec 2019 16:01:59 +0000 Received: from mail-wr1-x441.google.com ([2a00:1450:4864:20::441]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1igsok-0007PB-Bv for linux-arm-kernel@lists.infradead.org; Mon, 16 Dec 2019 16:01:57 +0000 Received: by mail-wr1-x441.google.com with SMTP id c9so7915557wrw.8 for ; Mon, 16 Dec 2019 08:01:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=iVi4d1hXj9sCF/T+xKr7+t6XuBrWW4vQrD/W9yh8xMk=; b=bi6Ncj3c4LKJV+oZP7eVxd3CacAlmEyPBDJuq4m8qlPBdTy0zZI7+74QNJ08kvSy1z 4qs4Z0khCO0gBJtczslIPTQe3kDQ3D/dXE6BAYYLen6zqKjdEV6oJjVWE3mWoLWWsUaH StxNh+MRsCAiRENpHEqpZpa6Q9Dzs31FPKCFQLy/Ub2MlOt9ElBeoKlYSyOpWil290Vn jHkyMt73D/TLxc5hhe2+TqV1gYGaiRnJR6e9gc3Ip9DVjyBfaqhnKFWQs/0pSamhdM1N Qeoa59w3J6tWG30OQ2dycrrNHjXvqXOTLwRGxuc+rpyN4yuXfmcdv58PKNsNc/ypE4HQ m5DA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=iVi4d1hXj9sCF/T+xKr7+t6XuBrWW4vQrD/W9yh8xMk=; b=WxpteDCX5JPQW+LLDLZ3bwiXyCKkzBY1MU9C8AW6h8IbnFKXW+QxWguC7FGGVglCtF uZ1rif2jC+WmAVPjIuZNodw4YB5sQzbVM7L4r4y/8yg651DwBNImjaKylmSSMtt3INmV WAKbnzWi1AaERDI/UPySkAwJ+RasMmzDm8qKG2JpbrWKleRZKCSWYJUUDrbYSPSREdmu OgAWDJu74q5kqAHc18xvYpbIeunQpndsVADFGV7KxXX/MeVkpbkXzD2X93Mt0uXrxw1W A2CwGQUmRYn7GFn7RY7AfSvntxjSO45ehqA9ozyooa8wNGSTpimeceHq7o0PZ9gpOrrG 4wLA== X-Gm-Message-State: APjAAAXWMe85TUMMerJgapo9uZr2JDDqLHvpo3zXd2HmVJaUpnHjgCjH lwQN3lQv8luU4D6HQX/yZjA5IA== X-Google-Smtp-Source: APXvYqzS//inX4T6XOJButeH/xgQHuUYoLLDVn3hiYsKGFpbfOiZsVcbDBgmj292KCOcdA/mH5Tqkg== X-Received: by 2002:adf:a141:: with SMTP id r1mr31625583wrr.285.1576512112855; Mon, 16 Dec 2019 08:01:52 -0800 (PST) Received: from dell ([185.17.149.202]) by smtp.gmail.com with ESMTPSA id k19sm19756354wmi.42.2019.12.16.08.01.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Dec 2019 08:01:51 -0800 (PST) Date: Mon, 16 Dec 2019 16:01:45 +0000 From: Lee Jones To: Jae Hyun Yoo Subject: Re: [PATCH v11 11/14] mfd: intel-peci-client: Add Intel PECI client driver Message-ID: <20191216160145.GL2369@dell> References: <20191211194624.2872-1-jae.hyun.yoo@linux.intel.com> <20191211194624.2872-12-jae.hyun.yoo@linux.intel.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20191211194624.2872-12-jae.hyun.yoo@linux.intel.com> User-Agent: Mutt/1.10.1 (2018-07-13) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191216_080154_453939_D96AD3CA X-CRM114-Status: GOOD ( 31.13 ) 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: Mark Rutland , Randy Dunlap , Tomer Maimon , devicetree@vger.kernel.org, Vernon Mauery , Frederic Barrat , Mauro Carvalho Chehab , Jason M Biils , Eric Sandeen , Lorenzo Pieralisi , Jonathan Corbet , openbmc@lists.ozlabs.org, linux-doc@vger.kernel.org, Kishon Vijay Abraham I , Joel Stanley , "Bryant G . Ly" , Uwe Kleine-Konig , David Kershner , Guenter Roeck , Wu Hao , linux-hwmon@vger.kernel.org, Jean Delvare , Arnd Bergmann , Philippe Ombredanne , Johan Hovold , Tomohiro Kusumi , Rob Herring , Thomas Gleixner , Sagar Dharia , linux-arm-kernel@lists.infradead.org, Juergen Gross , Cyrille Pitchen , Andrew Jeffery , Greg Kroah-Hartman , "Darrick J . Wong" , Stephen Boyd , Vinod Koul , James Feist , Gustavo Pimentel , Andrew Morton , "David S . Miller" 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 T24gV2VkLCAxMSBEZWMgMjAxOSwgSmFlIEh5dW4gWW9vIHdyb3RlOgoKPiBUaGlzIGNvbW1pdCBh ZGRzIEludGVsIFBFQ0kgY2xpZW50IGRyaXZlci4KPiAKPiBDYzogTGVlIEpvbmVzIDxsZWUuam9u ZXNAbGluYXJvLm9yZz4KPiBDYzogUmFuZHkgRHVubGFwIDxyZHVubGFwQGluZnJhZGVhZC5vcmc+ Cj4gQ2M6IFJvYiBIZXJyaW5nIDxyb2JoK2R0QGtlcm5lbC5vcmc+Cj4gQ2M6IEFuZHJldyBKZWZm ZXJ5IDxhbmRyZXdAYWouaWQuYXU+Cj4gQ2M6IEphbWVzIEZlaXN0IDxqYW1lcy5mZWlzdEBsaW51 eC5pbnRlbC5jb20+Cj4gQ2M6IEphc29uIE0gQmlpbHMgPGphc29uLm0uYmlsbHNAbGludXguaW50 ZWwuY29tPgo+IENjOiBKb2VsIFN0YW5sZXkgPGpvZWxAam1zLmlkLmF1Pgo+IENjOiBWZXJub24g TWF1ZXJ5IDx2ZXJub24ubWF1ZXJ5QGxpbnV4LmludGVsLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBK YWUgSHl1biBZb28gPGphZS5oeXVuLnlvb0BsaW51eC5pbnRlbC5jb20+Cj4gLS0tCj4gQ2hhbmdl cyBzaW5jZSB2MTA6Cj4gLSBGaXhlZCBtaW5vciBzdHlsZSBpc3N1ZXMuCj4gCj4gIGRyaXZlcnMv bWZkL0tjb25maWcgICAgICAgICAgICAgICAgICAgfCAgMTcgKysrCj4gIGRyaXZlcnMvbWZkL01h a2VmaWxlICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL21mZC9pbnRlbC1wZWNp LWNsaWVudC5jICAgICAgIHwgMTQ5ICsrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGluY2x1 ZGUvbGludXgvbWZkL2ludGVsLXBlY2ktY2xpZW50LmggfCAxMTcgKysrKysrKysrKysrKysrKysr KysKPiAgNCBmaWxlcyBjaGFuZ2VkLCAyODQgaW5zZXJ0aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9tZmQvaW50ZWwtcGVjaS1jbGllbnQuYwo+ICBjcmVhdGUgbW9kZSAxMDA2 NDQgaW5jbHVkZS9saW51eC9tZmQvaW50ZWwtcGVjaS1jbGllbnQuaAo+IAo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL21mZC9LY29uZmlnIGIvZHJpdmVycy9tZmQvS2NvbmZpZwo+IGluZGV4IDQyMDkw MDg1MjE2Ni4uNzAyMmU1NGE0NzAzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL0tjb25maWcK PiArKysgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gQEAgLTYzMiw2ICs2MzIsMjMgQEAgY29uZmln IE1GRF9JTlRFTF9NU0lDCj4gIAkgIFBhc3NhZ2UpIGNoaXAuIFRoaXMgY2hpcCBlbWJlZHMgYXVk aW8sIGJhdHRlcnksIEdQSU8sIGV0Yy4KPiAgCSAgZGV2aWNlcyB1c2VkIGluIEludGVsIE1lZGZp ZWxkIHBsYXRmb3Jtcy4KPiAgCj4gK2NvbmZpZyBNRkRfSU5URUxfUEVDSV9DTElFTlQKPiArCXRy aXN0YXRlICJJbnRlbCBQRUNJIGNsaWVudCIKPiArCWRlcGVuZHMgb24gKFBFQ0kgfHwgQ09NUElM RV9URVNUKQo+ICsJc2VsZWN0IE1GRF9DT1JFCj4gKwloZWxwCj4gKwkgIElmIHlvdSBzYXkgeWVz IHRvIHRoaXMgb3B0aW9uLCBzdXBwb3J0IHdpbGwgYmUgaW5jbHVkZWQgZm9yIHRoZQo+ICsJICBJ bnRlbCBQRUNJIChQbGF0Zm9ybSBFbnZpcm9ubWVudCBDb250cm9sIEludGVyZmFjZSkgY2xpZW50 LiBQRUNJIGlzIGEKPiArCSAgb25lLXdpcmUgYnVzIGludGVyZmFjZSB0aGF0IHByb3ZpZGVzIGEg Y29tbXVuaWNhdGlvbiBjaGFubmVsIGZyb20gUEVDSQo+ICsJICBjbGllbnRzIGluIEludGVsIHBy b2Nlc3NvcnMgYW5kIGNoaXBzZXQgY29tcG9uZW50cyB0byBleHRlcm5hbAo+ICsJICBtb25pdG9y aW5nIG9yIGNvbnRyb2wgZGV2aWNlcy4KPiArCj4gKwkgIEFkZGl0aW9uYWwgZHJpdmVycyBtdXN0 IGJlIGVuYWJsZWQgaW4gb3JkZXIgdG8gdXNlIHRoZSBmdW5jdGlvbmFsaXR5Cj4gKwkgIG9mIHRo ZSBkZXZpY2UuCj4gKwo+ICsJICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1v ZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgaW50ZWwtcGVjaS1j bGllbnQuCj4gKwo+ICBjb25maWcgTUZEX0lQQVFfTUlDUk8KPiAgCWJvb2wgIkF0bWVsIE1pY3Jv IEFTSUMgKGlQQVEgaDMxMDAvaDM2MDAvaDM3MDApIFN1cHBvcnQiCj4gIAlkZXBlbmRzIG9uIFNB MTEwMF9IMzEwMCB8fCBTQTExMDBfSDM2MDAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvTWFr ZWZpbGUgYi9kcml2ZXJzL21mZC9NYWtlZmlsZQo+IGluZGV4IGFlZDk5ZjA4NzM5Zi4uOTFjNmZk YTVjZWM2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL01ha2VmaWxlCj4gKysrIGIvZHJpdmVy cy9tZmQvTWFrZWZpbGUKPiBAQCAtMjExLDYgKzIxMSw3IEBAIG9iai0kKENPTkZJR19NRkRfSU5U RUxfTFBTUykJKz0gaW50ZWwtbHBzcy5vCj4gIG9iai0kKENPTkZJR19NRkRfSU5URUxfTFBTU19Q Q0kpCSs9IGludGVsLWxwc3MtcGNpLm8KPiAgb2JqLSQoQ09ORklHX01GRF9JTlRFTF9MUFNTX0FD UEkpCSs9IGludGVsLWxwc3MtYWNwaS5vCj4gIG9iai0kKENPTkZJR19NRkRfSU5URUxfTVNJQykJ Kz0gaW50ZWxfbXNpYy5vCj4gK29iai0kKENPTkZJR19NRkRfSU5URUxfUEVDSV9DTElFTlQpCSs9 IGludGVsLXBlY2ktY2xpZW50Lm8KPiAgb2JqLSQoQ09ORklHX01GRF9QQUxNQVMpCSs9IHBhbG1h cy5vCj4gIG9iai0kKENPTkZJR19NRkRfVklQRVJCT0FSRCkgICAgKz0gdmlwZXJib2FyZC5vCj4g IG9iai0kKENPTkZJR19NRkRfUkM1VDU4MykJKz0gcmM1dDU4My5vIHJjNXQ1ODMtaXJxLm8KPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvaW50ZWwtcGVjaS1jbGllbnQuYyBiL2RyaXZlcnMvbWZk L2ludGVsLXBlY2ktY2xpZW50LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAw MDAwMDAwMC4uMThiZjBhZjBlMDllCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbWZk L2ludGVsLXBlY2ktY2xpZW50LmMKPiBAQCAtMCwwICsxLDE0OSBAQAo+ICsvLyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICsvLyBDb3B5cmlnaHQgKGMpIDIwMTgtMjAxOSBJbnRl bCBDb3Jwb3JhdGlvbgo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2JpdGZpZWxkLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tZmQvY29yZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvbWZkL2ludGVsLXBlY2kt Y2xpZW50Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L29mX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcGVjaS5oPgo+ICsKPiArI2RlZmluZSBD UFVfSURfTU9ERUxfTUFTSyAgICAgIEdFTk1BU0soNywgNCkKPiArI2RlZmluZSBDUFVfSURfRkFN SUxZX01BU0sgICAgIEdFTk1BU0soMTEsIDgpCj4gKyNkZWZpbmUgQ1BVX0lEX0VYVF9NT0RFTF9N QVNLICBHRU5NQVNLKDE5LCAxNikKPiArI2RlZmluZSBDUFVfSURfRVhUX0ZBTUlMWV9NQVNLIEdF Tk1BU0soMjcsIDIwKQo+ICsKPiArI2RlZmluZSBMT1dFUl9OSUJCTEVfTUFTSyAgICAgIEdFTk1B U0soMywgMCkKPiArI2RlZmluZSBVUFBFUl9OSUJCTEVfTUFTSyAgICAgIEdFTk1BU0soNywgNCkK PiArI2RlZmluZSBMT1dFUl9CWVRFX01BU0sgICAgICAgIEdFTk1BU0soNywgMCkKPiArI2RlZmlu ZSBVUFBFUl9CWVRFX01BU0sgICAgICAgIEdFTk1BU0soMTYsIDgpCj4gKwo+ICtzdGF0aWMgc3Ry dWN0IG1mZF9jZWxsIHBlY2lfZnVuY3Rpb25zW10gPSB7Cj4gKwl7IC5uYW1lID0gInBlY2ktY3B1 dGVtcCIsIH0sCj4gKwl7IC5uYW1lID0gInBlY2ktZGltbXRlbXAiLCB9LAo+ICsJLyogVE9ETzog QWRkIGFkZGl0aW9uYWwgUEVDSSBzaWRlYmFuZCBmdW5jdGlvbnMgaW50byBoZXJlICovCgpObyBu ZWVkIGZvciB0aGlzIGNvbW1lbnQuICBJdCdzIGltcGxpZWQuCgo+ICt9Owo+ICsKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBjcHVfZ2VuX2luZm8gY3B1X2dlbl9pbmZvX3RhYmxlW10gPSB7Cj4gKwl7 IC8qIEhhc3dlbGwgWGVvbiAqLwo+ICsJCS5mYW1pbHkgICAgICAgID0gNiwgLyogRmFtaWx5IGNv ZGUgKi8KCk5pdDogV2h5IGRvbid0IHlvdSBqdXN0IGRlZmluZSB0aGUgbnVtYmVyLCBpbnN0ZWFk IG9mIGZlZWxpbmcgdGhlIG5lZWQKdG8gZnVydGhlciBjbGFyaWZ5IGJ5IHByb3ZpZGluZyBhIGNv bW1lbnQ/Cgo+ICsJCS5tb2RlbCAgICAgICAgID0gSU5URUxfRkFNNl9IQVNXRUxMX1gsCj4gKwkJ LmNvcmVfbWF4ICAgICAgPSBDT1JFX01BWF9PTl9IU1gsCj4gKwkJLmNoYW5fcmFua19tYXggPSBD SEFOX1JBTktfTUFYX09OX0hTWCwKPiArCQkuZGltbV9pZHhfbWF4ICA9IERJTU1fSURYX01BWF9P Tl9IU1ggfSwKPiArCXsgLyogQnJvYWR3ZWxsIFhlb24gKi8KPiArCQkuZmFtaWx5ICAgICAgICA9 IDYsIC8qIEZhbWlseSBjb2RlICovCj4gKwkJLm1vZGVsICAgICAgICAgPSBJTlRFTF9GQU02X0JS T0FEV0VMTF9YLAo+ICsJCS5jb3JlX21heCAgICAgID0gQ09SRV9NQVhfT05fQkRYLAo+ICsJCS5j aGFuX3JhbmtfbWF4ID0gQ0hBTl9SQU5LX01BWF9PTl9CRFgsCj4gKwkJLmRpbW1faWR4X21heCAg PSBESU1NX0lEWF9NQVhfT05fQkRYIH0sCj4gKwl7IC8qIFNreWxha2UgWGVvbiAqLwo+ICsJCS5m YW1pbHkgICAgICAgID0gNiwgLyogRmFtaWx5IGNvZGUgKi8KPiArCQkubW9kZWwgICAgICAgICA9 IElOVEVMX0ZBTTZfU0tZTEFLRV9YLAo+ICsJCS5jb3JlX21heCAgICAgID0gQ09SRV9NQVhfT05f U0tYLAo+ICsJCS5jaGFuX3JhbmtfbWF4ID0gQ0hBTl9SQU5LX01BWF9PTl9TS1gsCj4gKwkJLmRp bW1faWR4X21heCAgPSBESU1NX0lEWF9NQVhfT05fU0tYIH0sCj4gKwl7IC8qIFNreWxha2UgWGVv biBEICovCj4gKwkJLmZhbWlseSAgICAgICAgPSA2LCAvKiBGYW1pbHkgY29kZSAqLwo+ICsJCS5t b2RlbCAgICAgICAgID0gSU5URUxfRkFNNl9TS1lMQUtFX1hELAo+ICsJCS5jb3JlX21heCAgICAg ID0gQ09SRV9NQVhfT05fU0tYRCwKPiArCQkuY2hhbl9yYW5rX21heCA9IENIQU5fUkFOS19NQVhf T05fU0tYRCwKPiArCQkuZGltbV9pZHhfbWF4ICA9IERJTU1fSURYX01BWF9PTl9TS1hEIH0sCj4g K307Cj4gKwo+ICtzdGF0aWMgaW50IHBlY2lfY2xpZW50X2dldF9jcHVfZ2VuX2luZm8oc3RydWN0 IHBlY2lfY2xpZW50X21hbmFnZXIgKnByaXYpCj4gK3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9 ICZwcml2LT5jbGllbnQtPmRldjsKPiArCXUzMiBjcHVfaWQ7Cj4gKwl1MTYgZmFtaWx5Owo+ICsJ dTggbW9kZWw7Cj4gKwlpbnQgcmV0Owo+ICsJaW50IGk7Cj4gKwo+ICsJcmV0ID0gcGVjaV9nZXRf Y3B1X2lkKHByaXYtPmNsaWVudC0+YWRhcHRlciwgcHJpdi0+Y2xpZW50LT5hZGRyLAo+ICsJCQkg ICAgICAmY3B1X2lkKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlmYW1p bHkgPSBGSUVMRF9QUkVQKExPV0VSX0JZVEVfTUFTSywKPiArCQkJICAgIEZJRUxEX0dFVChDUFVf SURfRkFNSUxZX01BU0ssIGNwdV9pZCkpIHwKPiArCQkgRklFTERfUFJFUChVUFBFUl9CWVRFX01B U0ssCj4gKwkJCSAgICBGSUVMRF9HRVQoQ1BVX0lEX0VYVF9GQU1JTFlfTUFTSywgY3B1X2lkKSk7 Cj4gKwltb2RlbCA9IEZJRUxEX1BSRVAoTE9XRVJfTklCQkxFX01BU0ssCj4gKwkJCSAgIEZJRUxE X0dFVChDUFVfSURfTU9ERUxfTUFTSywgY3B1X2lkKSkgfAo+ICsJCUZJRUxEX1BSRVAoVVBQRVJf TklCQkxFX01BU0ssCj4gKwkJCSAgIEZJRUxEX0dFVChDUFVfSURfRVhUX01PREVMX01BU0ssIGNw dV9pZCkpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNwdV9nZW5faW5mb190 YWJsZSk7IGkrKykgewo+ICsJCWNvbnN0IHN0cnVjdCBjcHVfZ2VuX2luZm8gKmNwdV9pbmZvID0g JmNwdV9nZW5faW5mb190YWJsZVtpXTsKPiArCj4gKwkJaWYgKGZhbWlseSA9PSBjcHVfaW5mby0+ ZmFtaWx5ICYmIG1vZGVsID09IGNwdV9pbmZvLT5tb2RlbCkgewo+ICsJCQlwcml2LT5nZW5faW5m byA9IGNwdV9pbmZvOwo+ICsJCQlicmVhazsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJaWYgKCFwcml2 LT5nZW5faW5mbykgewo+ICsJCWRldl9lcnIoZGV2LCAiQ2FuJ3Qgc3VwcG9ydCB0aGlzIENQVTog MHgleFxuIiwgY3B1X2lkKTsKPiArCQlyZXQgPSAtRU5PREVWOwo+ICsJfQo+ICsKPiArCXJldHVy biByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcGVjaV9jbGllbnRfcHJvYmUoc3RydWN0IHBl Y2lfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjbGllbnQt PmRldjsKPiArCXN0cnVjdCBwZWNpX2NsaWVudF9tYW5hZ2VyICpwcml2Owo+ICsJdWludCBjcHVf bm87Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXByaXYgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2Yo KnByaXYpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghcHJpdikKPiArCQlyZXR1cm4gLUVOT01FTTsK PiArCj4gKwlkZXZfc2V0X2RydmRhdGEoZGV2LCBwcml2KTsKPiArCXByaXYtPmNsaWVudCA9IGNs aWVudDsKPiArCWNwdV9ubyA9IGNsaWVudC0+YWRkciAtIFBFQ0lfQkFTRV9BRERSOwo+ICsKPiAr CXJldCA9IHBlY2lfY2xpZW50X2dldF9jcHVfZ2VuX2luZm8ocHJpdik7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gZGV2bV9tZmRfYWRkX2RldmljZXMoZGV2LCBj cHVfbm8sIHBlY2lfZnVuY3Rpb25zLAo+ICsJCQkJICAgQVJSQVlfU0laRShwZWNpX2Z1bmN0aW9u cyksIE5VTEwsIDAsIE5VTEwpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKGRldiwg IkZhaWxlZCB0byByZWdpc3RlciBjaGlsZCBkZXZpY2VzOiAlZFxuIiwgcmV0KTsKPiArCQlyZXR1 cm4gcmV0Owo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICsjaWYgSVNfRU5BQkxF RChDT05GSUdfT0YpCgojaWZkZWYgQ09ORklHX09GCgo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCBwZWNpX2NsaWVudF9vZl90YWJsZVtdID0gewo+ICsJeyAuY29tcGF0aWJsZSA9 ICJpbnRlbCxwZWNpLWNsaWVudCIgfSwKPiArCXsgfQo+ICt9Owo+ICtNT0RVTEVfREVWSUNFX1RB QkxFKG9mLCBwZWNpX2NsaWVudF9vZl90YWJsZSk7Cj4gKyNlbmRpZiAvKiBDT05GSUdfT0YgKi8K ClBsZWFzZSByZW1vdmUgdGhpcyBjb21tZW50LiAgSXQgZG9lc24ndCBwcm92aWRlIGFueXRoaW5n IGhlcmUuCgo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHBlY2lfZGV2aWNlX2lkIHBlY2lfY2xpZW50 X2lkc1tdID0gewo+ICsJeyAubmFtZSA9ICJwZWNpLWNsaWVudCIgfSwKPiArCXsgfQo+ICt9Owo+ ICtNT0RVTEVfREVWSUNFX1RBQkxFKHBlY2ksIHBlY2lfY2xpZW50X2lkcyk7CgpJcyB0aGlzIGEg cmVxdWlyZW1lbnQ/ICBJZiBzbywgd2h5PwoKV2UncmUgdHJ5aW5nIHRvIGdldCByaWQgb2YgdW5u ZWNlc3NhcnkgdGFibGVzLgoKUGxlYXNlIGdyZXAgZm9yICJwcm9iZV9uZXciLgoKPiArc3RhdGlj IHN0cnVjdCBwZWNpX2RyaXZlciBwZWNpX2NsaWVudF9kcml2ZXIgPSB7Cj4gKwkucHJvYmUgICAg PSBwZWNpX2NsaWVudF9wcm9iZSwKPiArCS5pZF90YWJsZSA9IHBlY2lfY2xpZW50X2lkcywKPiAr CS5kcml2ZXIgICA9IHsKPiArCQkubmFtZSAgICAgICAgICAgPSBLQlVJTERfTU9ETkFNRSwKPiAr CQkub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9wdHIocGVjaV9jbGllbnRfb2ZfdGFibGUpLAo+ ICsJfSwKPiArfTsKPiArbW9kdWxlX3BlY2lfZHJpdmVyKHBlY2lfY2xpZW50X2RyaXZlcik7Cj4g Kwo+ICtNT0RVTEVfQVVUSE9SKCJKYWUgSHl1biBZb28gPGphZS5oeXVuLnlvb0BsaW51eC5pbnRl bC5jb20+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiUEVDSSBjbGllbnQgZHJpdmVyIik7Cj4g K01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9t ZmQvaW50ZWwtcGVjaS1jbGllbnQuaCBiL2luY2x1ZGUvbGludXgvbWZkL2ludGVsLXBlY2ktY2xp ZW50LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uOTg1NDMw M2JiYzI2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUvbGludXgvbWZkL2ludGVsLXBl Y2ktY2xpZW50LmgKPiBAQCAtMCwwICsxLDExNyBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRp ZmllcjogR1BMLTIuMCAqLwo+ICsvKiBDb3B5cmlnaHQgKGMpIDIwMTgtMjAxOSBJbnRlbCBDb3Jw b3JhdGlvbiAqLwo+ICsKPiArI2lmbmRlZiBfX0xJTlVYX01GRF9JTlRFTF9QRUNJX0NMSUVOVF9I Cj4gKyNkZWZpbmUgX19MSU5VWF9NRkRfSU5URUxfUEVDSV9DTElFTlRfSAo+ICsKPiArI2luY2x1 ZGUgPGxpbnV4L3BlY2kuaD4KPiArCj4gKyNpZiBJU19FTkFCTEVEKENPTkZJR19YODYpCj4gKyNp bmNsdWRlIDxhc20vaW50ZWwtZmFtaWx5Lmg+Cj4gKyNlbHNlCj4gKy8qCj4gKyAqIEFyY2hpdGVj dHVyZXMgb3RoZXIgdGhhbiB4ODYgY2Fubm90IGluY2x1ZGUgdGhlIGhlYWRlciBmaWxlIHNvIGRl ZmluZSB0aGVzZQo+ICsgKiBhdCBoZXJlLiBUaGVzZSBhcmUgbmVlZGVkIGZvciBkZXRlY3Rpbmcg dHlwZSBvZiBjbGllbnQgeDg2IENQVXMgYmVoaW5kIGEgUEVDSQo+ICsgKiBjb25uZWN0aW9uLgo+ ICsgKi8KPiArI2RlZmluZSBJTlRFTF9GQU02X0hBU1dFTExfWAkJMHgzRgo+ICsjZGVmaW5lIElO VEVMX0ZBTTZfQlJPQURXRUxMX1gJCTB4NEYKPiArI2RlZmluZSBJTlRFTF9GQU02X1NLWUxBS0Vf WAkJMHg1NQo+ICsjZGVmaW5lIElOVEVMX0ZBTTZfU0tZTEFLRV9YRAkJMHg1Ngo+ICsjZW5kaWYK PiArCj4gKyNkZWZpbmUgQ09SRV9NQVhfT05fSFNYICAgICAgICAxOCAvKiBNYXggbnVtYmVyIG9m IGNvcmVzIG9uIEhhc3dlbGwgKi8KPiArI2RlZmluZSBDSEFOX1JBTktfTUFYX09OX0hTWCAgIDgg IC8qIE1heCBudW1iZXIgb2YgY2hhbm5lbCByYW5rcyBvbiBIYXN3ZWxsICovCj4gKyNkZWZpbmUg RElNTV9JRFhfTUFYX09OX0hTWCAgICAzICAvKiBNYXggRElNTSBpbmRleCBwZXIgY2hhbm5lbCBv biBIYXN3ZWxsICovCj4gKwo+ICsjZGVmaW5lIENPUkVfTUFYX09OX0JEWCAgICAgICAgMjQgLyog TWF4IG51bWJlciBvZiBjb3JlcyBvbiBCcm9hZHdlbGwgKi8KPiArI2RlZmluZSBDSEFOX1JBTktf TUFYX09OX0JEWCAgIDQgIC8qIE1heCBudW1iZXIgb2YgY2hhbm5lbCByYW5rcyBvbiBCcm9hZHdl bGwgKi8KPiArI2RlZmluZSBESU1NX0lEWF9NQVhfT05fQkRYICAgIDMgIC8qIE1heCBESU1NIGlu ZGV4IHBlciBjaGFubmVsIG9uIEJyb2Fkd2VsbCAqLwo+ICsKPiArI2RlZmluZSBDT1JFX01BWF9P Tl9TS1ggICAgICAgIDI4IC8qIE1heCBudW1iZXIgb2YgY29yZXMgb24gU2t5bGFrZSAqLwo+ICsj ZGVmaW5lIENIQU5fUkFOS19NQVhfT05fU0tYICAgNiAgLyogTWF4IG51bWJlciBvZiBjaGFubmVs IHJhbmtzIG9uIFNreWxha2UgKi8KPiArI2RlZmluZSBESU1NX0lEWF9NQVhfT05fU0tYICAgIDIg IC8qIE1heCBESU1NIGluZGV4IHBlciBjaGFubmVsIG9uIFNreWxha2UgKi8KPiArCj4gKyNkZWZp bmUgQ09SRV9NQVhfT05fU0tYRCAgICAgICAxNiAvKiBNYXggbnVtYmVyIG9mIGNvcmVzIG9uIFNr eWxha2UgRCAqLwo+ICsjZGVmaW5lIENIQU5fUkFOS19NQVhfT05fU0tYRCAgMiAgLyogTWF4IG51 bWJlciBvZiBjaGFubmVsIHJhbmtzIG9uIFNreWxha2UgRCAqLwo+ICsjZGVmaW5lIERJTU1fSURY X01BWF9PTl9TS1hEICAgMiAgLyogTWF4IERJTU0gaW5kZXggcGVyIGNoYW5uZWwgb24gU2t5bGFr ZSBEICovCj4gKwo+ICsjZGVmaW5lIENPUkVfTlVNU19NQVggICAgICAgICAgQ09SRV9NQVhfT05f U0tYCj4gKyNkZWZpbmUgQ0hBTl9SQU5LX01BWCAgICAgICAgICBDSEFOX1JBTktfTUFYX09OX0hT WAo+ICsjZGVmaW5lIERJTU1fSURYX01BWCAgICAgICAgICAgRElNTV9JRFhfTUFYX09OX0hTWAo+ ICsjZGVmaW5lIERJTU1fTlVNU19NQVggICAgICAgICAgKENIQU5fUkFOS19NQVggKiBESU1NX0lE WF9NQVgpCj4gKwo+ICsvKioKPiArICogc3RydWN0IGNwdV9nZW5faW5mbyAtIENQVSBnZW5lcmF0 aW9uIHNwZWNpZmljIGluZm9ybWF0aW9uCj4gKyAqIEBmYW1pbHk6IENQVSBmYW1pbHkgSUQKPiAr ICogQG1vZGVsOiBDUFUgbW9kZWwKPiArICogQGNvcmVfbWF4OiBtYXggbnVtYmVyIG9mIGNvcmVz Cj4gKyAqIEBjaGFuX3JhbmtfbWF4OiBtYXggbnVtYmVyIG9mIGNoYW5uZWwgcmFua3MKPiArICog QGRpbW1faWR4X21heDogbWF4IG51bWJlciBvZiBESU1NIGluZGljZXMKPiArICoKPiArICogQ1BV IGdlbmVyYXRpb24gc3BlY2lmaWMgaW5mb3JtYXRpb24gdG8gaWRlbnRpZnkgbWF4aW11bSBudW1i ZXIgb2YgY29yZXMgYW5kCj4gKyAqIERJTU0gc2xvdHMuCj4gKyAqLwo+ICtzdHJ1Y3QgY3B1X2dl bl9pbmZvIHsKPiArCXUxNiAgZmFtaWx5Owo+ICsJdTggICBtb2RlbDsKPiArCXVpbnQgY29yZV9t YXg7Cj4gKwl1aW50IGNoYW5fcmFua19tYXg7Cj4gKwl1aW50IGRpbW1faWR4X21heDsKPiArfTsK PiArCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgcGVjaV9jbGllbnRfbWFuYWdlciAtIFBFQ0kgY2xpZW50 IG1hbmFnZXIgaW5mb3JtYXRpb24KPiArICogQGNsaWVudDsgcG9pbnRlciB0byB0aGUgUEVDSSBj bGllbnQKPiArICogQG5hbWU6IFBFQ0kgY2xpZW50IG1hbmFnZXIgbmFtZQo+ICsgKiBAZ2VuX2lu Zm86IENQVSBnZW5lcmF0aW9uIGluZm8gb2YgdGhlIGRldGVjdGVkIENQVQo+ICsgKgo+ICsgKiBQ RUNJIGNsaWVudCBtYW5hZ2VyIGluZm9ybWF0aW9uIGZvciBtYW5hZ2luZyBQRUNJIHNpZGViYW5k IGZ1bmN0aW9ucyBvbiBhIENQVQo+ICsgKiBjbGllbnQuCj4gKyAqLwo+ICtzdHJ1Y3QgcGVjaV9j bGllbnRfbWFuYWdlciB7Cj4gKwlzdHJ1Y3QgcGVjaV9jbGllbnQgKmNsaWVudDsKPiArCWNoYXIg bmFtZVtQRUNJX05BTUVfU0laRV07Cj4gKwljb25zdCBzdHJ1Y3QgY3B1X2dlbl9pbmZvICpnZW5f aW5mbzsKPiArfTsKPiArCj4gKy8qKgo+ICsgKiBwZWNpX2NsaWVudF9yZWFkX3BhY2thZ2VfY29u ZmlnIC0gcmVhZCBmcm9tIHRoZSBQYWNrYWdlIENvbmZpZ3VyYXRpb24gU3BhY2UKPiArICogQHBy aXY6IGRyaXZlciBwcml2YXRlIGRhdGEgc3RydWN0dXJlCj4gKyAqIEBpbmRleDogZW5jb2Rpbmcg aW5kZXggZm9yIHRoZSByZXF1ZXN0ZWQgc2VydmljZQo+ICsgKiBAcGFyYW06IHBhcmFtZXRlciB0 byBzcGVjaWZ5IHRoZSBleGFjdCBkYXRhIGJlaW5nIHJlcXVlc3RlZAo+ICsgKiBAZGF0YTogZGF0 YSBidWZmZXIgdG8gc3RvcmUgdGhlIHJlc3VsdAo+ICsgKiBDb250ZXh0OiBjYW4gc2xlZXAKPiAr ICoKPiArICogQSBnZW5lcmljIFBFQ0kgY29tbWFuZCB0aGF0IHByb3ZpZGVzIHJlYWQgYWNjZXNz IHRvIHRoZQo+ICsgKiAiUGFja2FnZSBDb25maWd1cmF0aW9uIFNwYWNlIiB0aGF0IGlzIG1haW50 YWluZWQgYnkgdGhlIFBDVSwgaW5jbHVkaW5nCj4gKyAqIHZhcmlvdXMgcG93ZXIgYW5kIHRoZXJt YWwgbWFuYWdlbWVudCBmdW5jdGlvbnMuIFR5cGljYWwgUENTIHJlYWQgc2VydmljZXMKPiArICog c3VwcG9ydGVkIGJ5IHRoZSBwcm9jZXNzb3IgbWF5IGluY2x1ZGUgYWNjZXNzIHRvIHRlbXBlcmF0 dXJlIGRhdGEsIGVuZXJneQo+ICsgKiBzdGF0dXMsIHJ1biB0aW1lIGluZm9ybWF0aW9uLCBESU1N IHRlbXBlcmF0dXJlcyBhbmQgc28gb24uCj4gKyAqCj4gKyAqIFJldHVybjogemVybyBvbiBzdWNj ZXNzLCBlbHNlIGEgbmVnYXRpdmUgZXJyb3IgY29kZS4KPiArICovCj4gK3N0YXRpYyBpbmxpbmUg aW50Cj4gK3BlY2lfY2xpZW50X3JlYWRfcGFja2FnZV9jb25maWcoc3RydWN0IHBlY2lfY2xpZW50 X21hbmFnZXIgKnByaXYsCj4gKwkJCQl1OCBpbmRleCwgdTE2IHBhcmFtLCB1OCAqZGF0YSkKPiAr ewo+ICsJc3RydWN0IHBlY2lfcmRfcGtnX2NmZ19tc2cgbXNnOwo+ICsJaW50IHJldDsKPiArCj4g Kwltc2cuYWRkciA9IHByaXYtPmNsaWVudC0+YWRkcjsKPiArCW1zZy5pbmRleCA9IGluZGV4Owo+ ICsJbXNnLnBhcmFtID0gcGFyYW07Cj4gKwltc2cucnhfbGVuID0gNDsKPiArCj4gKwlyZXQgPSBw ZWNpX2NvbW1hbmQocHJpdi0+Y2xpZW50LT5hZGFwdGVyLCBQRUNJX0NNRF9SRF9QS0dfQ0ZHLCAm bXNnKTsKPiArCWlmIChtc2cuY2MgIT0gUEVDSV9ERVZfQ0NfU1VDQ0VTUykKPiArCQlyZXQgPSAt RUFHQUlOOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCW1lbWNweShkYXRh LCBtc2cucGtnX2NvbmZpZywgNCk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KCldoZXJlIGlzIHRo aXMgZnVuY3Rpb24gdXNlZD8KCj4gKyNlbmRpZiAvKiBfX0xJTlVYX01GRF9JTlRFTF9QRUNJX0NM SUVOVF9IICovCgotLSAKTGVlIEpvbmVzIFvmnY7nkLzmlq9dCkxpbmFybyBTZXJ2aWNlcyBUZWNo bmljYWwgTGVhZApMaW5hcm8ub3JnIOKUgiBPcGVuIHNvdXJjZSBzb2Z0d2FyZSBmb3IgQVJNIFNv Q3MKRm9sbG93IExpbmFybzogRmFjZWJvb2sgfCBUd2l0dGVyIHwgQmxvZwoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWls aW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0 cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=