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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 E75E4C4338F for ; Thu, 29 Jul 2021 02:02:28 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 A53D76103B for ; Thu, 29 Jul 2021 02:02:28 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org A53D76103B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 327036E415; Thu, 29 Jul 2021 02:02:28 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id ABBF96E415; Thu, 29 Jul 2021 02:02:27 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10059"; a="298370397" X-IronPort-AV: E=Sophos;i="5.84,276,1620716400"; d="scan'208";a="298370397" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jul 2021 19:02:27 -0700 X-IronPort-AV: E=Sophos;i="5.84,276,1620716400"; d="scan'208";a="417467985" Received: from dceraolo-linux.fm.intel.com ([10.1.27.145]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jul 2021 19:02:27 -0700 From: Daniele Ceraolo Spurio To: intel-gfx@lists.freedesktop.org Subject: [PATCH v6 02/15] mei: pxp: export pavp client to me client bus Date: Wed, 28 Jul 2021 19:00:53 -0700 Message-Id: <20210729020106.18346-3-daniele.ceraolospurio@intel.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210729020106.18346-1-daniele.ceraolospurio@intel.com> References: <20210729020106.18346-1-daniele.ceraolospurio@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Tomas Winkler , Daniele Ceraolo Spurio , Vitaly Lubart , dri-devel@lists.freedesktop.org, Rodrigo Vivi Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Vitaly Lubart Export PAVP client to work with i915 driver, for binding it uses kernel component framework. v2:drop debug prints, refactor match code to match mei_hdcp (Tomas) Signed-off-by: Vitaly Lubart Signed-off-by: Tomas Winkler Signed-off-by: Daniele Ceraolo Spurio Reviewed-by: Rodrigo Vivi #v1 --- drivers/misc/mei/Kconfig | 2 + drivers/misc/mei/Makefile | 1 + drivers/misc/mei/pxp/Kconfig | 13 ++ drivers/misc/mei/pxp/Makefile | 7 + drivers/misc/mei/pxp/mei_pxp.c | 229 +++++++++++++++++++++++++++++++++ drivers/misc/mei/pxp/mei_pxp.h | 18 +++ 6 files changed, 270 insertions(+) create mode 100644 drivers/misc/mei/pxp/Kconfig create mode 100644 drivers/misc/mei/pxp/Makefile create mode 100644 drivers/misc/mei/pxp/mei_pxp.c create mode 100644 drivers/misc/mei/pxp/mei_pxp.h diff --git a/drivers/misc/mei/Kconfig b/drivers/misc/mei/Kconfig index f5fd5b786607..0e0bcd0da852 100644 --- a/drivers/misc/mei/Kconfig +++ b/drivers/misc/mei/Kconfig @@ -47,3 +47,5 @@ config INTEL_MEI_TXE Intel Bay Trail source "drivers/misc/mei/hdcp/Kconfig" +source "drivers/misc/mei/pxp/Kconfig" + diff --git a/drivers/misc/mei/Makefile b/drivers/misc/mei/Makefile index f1c76f7ee804..d8e5165917f2 100644 --- a/drivers/misc/mei/Makefile +++ b/drivers/misc/mei/Makefile @@ -26,3 +26,4 @@ mei-$(CONFIG_EVENT_TRACING) += mei-trace.o CFLAGS_mei-trace.o = -I$(src) obj-$(CONFIG_INTEL_MEI_HDCP) += hdcp/ +obj-$(CONFIG_INTEL_MEI_PXP) += pxp/ diff --git a/drivers/misc/mei/pxp/Kconfig b/drivers/misc/mei/pxp/Kconfig new file mode 100644 index 000000000000..4029b96afc04 --- /dev/null +++ b/drivers/misc/mei/pxp/Kconfig @@ -0,0 +1,13 @@ + +# SPDX-License-Identifier: GPL-2.0 +# Copyright (c) 2020, Intel Corporation. All rights reserved. +# +config INTEL_MEI_PXP + tristate "Intel PXP services of ME Interface" + select INTEL_MEI_ME + depends on DRM_I915 + help + MEI Support for PXP Services on Intel platforms. + + Enables the ME FW services required for PXP support through + I915 display driver of Intel. diff --git a/drivers/misc/mei/pxp/Makefile b/drivers/misc/mei/pxp/Makefile new file mode 100644 index 000000000000..0329950d5794 --- /dev/null +++ b/drivers/misc/mei/pxp/Makefile @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (c) 2020, Intel Corporation. All rights reserved. +# +# Makefile - PXP client driver for Intel MEI Bus Driver. + +obj-$(CONFIG_INTEL_MEI_PXP) += mei_pxp.o diff --git a/drivers/misc/mei/pxp/mei_pxp.c b/drivers/misc/mei/pxp/mei_pxp.c new file mode 100644 index 000000000000..f7380d387bab --- /dev/null +++ b/drivers/misc/mei/pxp/mei_pxp.c @@ -0,0 +1,229 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright © 2020 - 2021 Intel Corporation + */ + +/** + * DOC: MEI_PXP Client Driver + * + * The mei_pxp driver acts as a translation layer between PXP + * protocol implementer (I915) and ME FW by translating PXP + * negotiation messages to ME FW command payloads and vice versa. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mei_pxp.h" + +/** + * mei_pxp_send_message() - Sends a PXP message to ME FW. + * @dev: device corresponding to the mei_cl_device + * @message: a message buffer to send + * @size: size of the message + * Return: 0 on Success, <0 on Failure + */ +static int +mei_pxp_send_message(struct device *dev, const void *message, size_t size) +{ + struct mei_cl_device *cldev; + ssize_t byte; + + if (!dev || !message) + return -EINVAL; + + cldev = to_mei_cl_device(dev); + + /* temporary drop const qualifier till the API is fixed */ + byte = mei_cldev_send(cldev, (u8 *)message, size); + if (byte < 0) { + dev_dbg(dev, "mei_cldev_send failed. %zd\n", byte); + return byte; + } + + return 0; +} + +/** + * mei_pxp_receive_message() - Receives a PXP message from ME FW. + * @dev: device corresponding to the mei_cl_device + * @buffer: a message buffer to contain the received message + * @size: size of the buffer + * Return: bytes sent on Success, <0 on Failure + */ +static int +mei_pxp_receive_message(struct device *dev, void *buffer, size_t size) +{ + struct mei_cl_device *cldev; + ssize_t byte; + + if (!dev || !buffer) + return -EINVAL; + + cldev = to_mei_cl_device(dev); + + byte = mei_cldev_recv(cldev, buffer, size); + if (byte < 0) { + dev_dbg(dev, "mei_cldev_recv failed. %zd\n", byte); + return byte; + } + + return byte; +} + +static const struct i915_pxp_component_ops mei_pxp_ops = { + .owner = THIS_MODULE, + .send = mei_pxp_send_message, + .recv = mei_pxp_receive_message, +}; + +static int mei_component_master_bind(struct device *dev) +{ + struct mei_cl_device *cldev = to_mei_cl_device(dev); + struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev); + int ret; + + comp_master->ops = &mei_pxp_ops; + comp_master->tee_dev = dev; + ret = component_bind_all(dev, comp_master); + if (ret < 0) + return ret; + + return 0; +} + +static void mei_component_master_unbind(struct device *dev) +{ + struct mei_cl_device *cldev = to_mei_cl_device(dev); + struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev); + + component_unbind_all(dev, comp_master); +} + +static const struct component_master_ops mei_component_master_ops = { + .bind = mei_component_master_bind, + .unbind = mei_component_master_unbind, +}; + +/** + * mei_pxp_component_match - compare function for matching mei pxp. + * + * The function checks if the driver is i915, the subcomponent is PXP + * and the grand parent of pxp and the parent of i915 are the same + * PCH device. + * + * @dev: master device + * @subcomponent: subcomponent to match (I915_COMPONENT_PXP) + * @data: compare data (mei pxp device) + * + * Return: + * * 1 - if components match + * * 0 - otherwise + */ +static int mei_pxp_component_match(struct device *dev, int subcomponent, + void *data) +{ + struct device *base = data; + + if (strcmp(dev->driver->name, "i915") || + subcomponent != I915_COMPONENT_PXP) + return 0; + + base = base->parent; + if (!base) + return 0; + + base = base->parent; + dev = dev->parent; + + return (base && dev && dev == base); +} + +static int mei_pxp_probe(struct mei_cl_device *cldev, + const struct mei_cl_device_id *id) +{ + struct i915_pxp_component *comp_master; + struct component_match *master_match; + int ret; + + ret = mei_cldev_enable(cldev); + if (ret < 0) { + dev_err(&cldev->dev, "mei_cldev_enable Failed. %d\n", ret); + goto enable_err_exit; + } + + comp_master = kzalloc(sizeof(*comp_master), GFP_KERNEL); + if (!comp_master) { + ret = -ENOMEM; + goto err_exit; + } + + master_match = NULL; + component_match_add_typed(&cldev->dev, &master_match, + mei_pxp_component_match, &cldev->dev); + if (IS_ERR_OR_NULL(master_match)) { + ret = -ENOMEM; + goto err_exit; + } + + mei_cldev_set_drvdata(cldev, comp_master); + ret = component_master_add_with_match(&cldev->dev, + &mei_component_master_ops, + master_match); + if (ret < 0) { + dev_err(&cldev->dev, "Master comp add failed %d\n", ret); + goto err_exit; + } + + return 0; + +err_exit: + mei_cldev_set_drvdata(cldev, NULL); + kfree(comp_master); + mei_cldev_disable(cldev); +enable_err_exit: + return ret; +} + +static void mei_pxp_remove(struct mei_cl_device *cldev) +{ + struct i915_pxp_component *comp_master = mei_cldev_get_drvdata(cldev); + int ret; + + component_master_del(&cldev->dev, &mei_component_master_ops); + kfree(comp_master); + mei_cldev_set_drvdata(cldev, NULL); + + ret = mei_cldev_disable(cldev); + if (ret) + dev_warn(&cldev->dev, "mei_cldev_disable() failed\n"); +} + +/* fbf6fcf1-96cf-4e2e-a6a6-1bab8cbe36b1 : PAVP GUID*/ +#define MEI_GUID_PXP GUID_INIT(0xfbf6fcf1, 0x96cf, 0x4e2e, 0xA6, \ + 0xa6, 0x1b, 0xab, 0x8c, 0xbe, 0x36, 0xb1) + +static struct mei_cl_device_id mei_pxp_tbl[] = { + { .uuid = MEI_GUID_PXP, .version = MEI_CL_VERSION_ANY }, + { } +}; +MODULE_DEVICE_TABLE(mei, mei_pxp_tbl); + +static struct mei_cl_driver mei_pxp_driver = { + .id_table = mei_pxp_tbl, + .name = KBUILD_MODNAME, + .probe = mei_pxp_probe, + .remove = mei_pxp_remove, +}; + +module_mei_cl_driver(mei_pxp_driver); + +MODULE_AUTHOR("Intel Corporation"); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("MEI PXP"); diff --git a/drivers/misc/mei/pxp/mei_pxp.h b/drivers/misc/mei/pxp/mei_pxp.h new file mode 100644 index 000000000000..e7b15373fefd --- /dev/null +++ b/drivers/misc/mei/pxp/mei_pxp.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright © 2020 Intel Corporation + * + * Authors: + * Vitaly Lubart + */ + +#ifndef __MEI_PXP_H__ +#define __MEI_PXP_H__ + +/* me_pxp_status: Enumeration of all PXP Status Codes */ +enum me_pxp_status { + ME_PXP_STATUS_SUCCESS = 0x0000, + +}; + +#endif /* __MEI_PXP_H__ */ -- 2.32.0 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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 3EB5AC432BE for ; Thu, 29 Jul 2021 02:02:43 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 062F46056C for ; Thu, 29 Jul 2021 02:02:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 062F46056C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 45DAF6EB7B; Thu, 29 Jul 2021 02:02:31 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id ABBF96E415; Thu, 29 Jul 2021 02:02:27 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10059"; a="298370397" X-IronPort-AV: E=Sophos;i="5.84,276,1620716400"; d="scan'208";a="298370397" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jul 2021 19:02:27 -0700 X-IronPort-AV: E=Sophos;i="5.84,276,1620716400"; d="scan'208";a="417467985" Received: from dceraolo-linux.fm.intel.com ([10.1.27.145]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jul 2021 19:02:27 -0700 From: Daniele Ceraolo Spurio To: intel-gfx@lists.freedesktop.org Date: Wed, 28 Jul 2021 19:00:53 -0700 Message-Id: <20210729020106.18346-3-daniele.ceraolospurio@intel.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210729020106.18346-1-daniele.ceraolospurio@intel.com> References: <20210729020106.18346-1-daniele.ceraolospurio@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v6 02/15] mei: pxp: export pavp client to me client bus X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Tomas Winkler , Vitaly Lubart , dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogVml0YWx5IEx1YmFydCA8dml0YWx5Lmx1YmFydEBpbnRlbC5jb20+CgpFeHBvcnQgUEFW UCBjbGllbnQgdG8gd29yayB3aXRoIGk5MTUgZHJpdmVyLApmb3IgYmluZGluZyBpdCB1c2VzIGtl cm5lbCBjb21wb25lbnQgZnJhbWV3b3JrLgoKdjI6ZHJvcCBkZWJ1ZyBwcmludHMsIHJlZmFjdG9y IG1hdGNoIGNvZGUgdG8gbWF0Y2ggbWVpX2hkY3AgKFRvbWFzKQoKU2lnbmVkLW9mZi1ieTogVml0 YWx5IEx1YmFydCA8dml0YWx5Lmx1YmFydEBpbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IFRvbWFz IFdpbmtsZXIgPHRvbWFzLndpbmtsZXJAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYW5pZWxl IENlcmFvbG8gU3B1cmlvIDxkYW5pZWxlLmNlcmFvbG9zcHVyaW9AaW50ZWwuY29tPgpSZXZpZXdl ZC1ieTogUm9kcmlnbyBWaXZpIDxyb2RyaWdvLnZpdmlAaW50ZWwuY29tPiAjdjEKLS0tCiBkcml2 ZXJzL21pc2MvbWVpL0tjb25maWcgICAgICAgfCAgIDIgKwogZHJpdmVycy9taXNjL21laS9NYWtl ZmlsZSAgICAgIHwgICAxICsKIGRyaXZlcnMvbWlzYy9tZWkvcHhwL0tjb25maWcgICB8ICAxMyAr KwogZHJpdmVycy9taXNjL21laS9weHAvTWFrZWZpbGUgIHwgICA3ICsKIGRyaXZlcnMvbWlzYy9t ZWkvcHhwL21laV9weHAuYyB8IDIyOSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGRyaXZlcnMvbWlzYy9tZWkvcHhwL21laV9weHAuaCB8ICAxOCArKysKIDYgZmlsZXMgY2hhbmdl ZCwgMjcwIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21pc2MvbWVp L3B4cC9LY29uZmlnCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9taXNjL21laS9weHAvTWFr ZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21pc2MvbWVpL3B4cC9tZWlfcHhwLmMK IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21pc2MvbWVpL3B4cC9tZWlfcHhwLmgKCmRpZmYg LS1naXQgYS9kcml2ZXJzL21pc2MvbWVpL0tjb25maWcgYi9kcml2ZXJzL21pc2MvbWVpL0tjb25m aWcKaW5kZXggZjVmZDViNzg2NjA3Li4wZTBiY2QwZGE4NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWlzYy9tZWkvS2NvbmZpZworKysgYi9kcml2ZXJzL21pc2MvbWVpL0tjb25maWcKQEAgLTQ3LDMg KzQ3LDUgQEAgY29uZmlnIElOVEVMX01FSV9UWEUKIAkgIEludGVsIEJheSBUcmFpbAogCiBzb3Vy Y2UgImRyaXZlcnMvbWlzYy9tZWkvaGRjcC9LY29uZmlnIgorc291cmNlICJkcml2ZXJzL21pc2Mv bWVpL3B4cC9LY29uZmlnIgorCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvbWVpL01ha2VmaWxl IGIvZHJpdmVycy9taXNjL21laS9NYWtlZmlsZQppbmRleCBmMWM3NmY3ZWU4MDQuLmQ4ZTUxNjU5 MTdmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL21laS9NYWtlZmlsZQorKysgYi9kcml2ZXJz L21pc2MvbWVpL01ha2VmaWxlCkBAIC0yNiwzICsyNiw0IEBAIG1laS0kKENPTkZJR19FVkVOVF9U UkFDSU5HKSArPSBtZWktdHJhY2UubwogQ0ZMQUdTX21laS10cmFjZS5vID0gLUkkKHNyYykKIAog b2JqLSQoQ09ORklHX0lOVEVMX01FSV9IRENQKSArPSBoZGNwLworb2JqLSQoQ09ORklHX0lOVEVM X01FSV9QWFApICs9IHB4cC8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9tZWkvcHhwL0tjb25m aWcgYi9kcml2ZXJzL21pc2MvbWVpL3B4cC9LY29uZmlnCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uNDAyOWI5NmFmYzA0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVy cy9taXNjL21laS9weHAvS2NvbmZpZwpAQCAtMCwwICsxLDEzIEBACisKKyMgU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAKKyMgQ29weXJpZ2h0IChjKSAyMDIwLCBJbnRlbCBDb3Jwb3Jh dGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKK2NvbmZpZyBJTlRFTF9NRUlfUFhQCisJdHJp c3RhdGUgIkludGVsIFBYUCBzZXJ2aWNlcyBvZiBNRSBJbnRlcmZhY2UiCisJc2VsZWN0IElOVEVM X01FSV9NRQorCWRlcGVuZHMgb24gRFJNX0k5MTUKKwloZWxwCisJICBNRUkgU3VwcG9ydCBmb3Ig UFhQIFNlcnZpY2VzIG9uIEludGVsIHBsYXRmb3Jtcy4KKworCSAgRW5hYmxlcyB0aGUgTUUgRlcg c2VydmljZXMgcmVxdWlyZWQgZm9yIFBYUCBzdXBwb3J0IHRocm91Z2gKKwkgIEk5MTUgZGlzcGxh eSBkcml2ZXIgb2YgSW50ZWwuCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvbWVpL3B4cC9NYWtl ZmlsZSBiL2RyaXZlcnMvbWlzYy9tZWkvcHhwL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uMDMyOTk1MGQ1Nzk0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJp dmVycy9taXNjL21laS9weHAvTWFrZWZpbGUKQEAgLTAsMCArMSw3IEBACisjIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wCisjCisjIENvcHlyaWdodCAoYykgMjAyMCwgSW50ZWwgQ29y cG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIE1ha2VmaWxlIC0gUFhQIGNsaWVu dCBkcml2ZXIgZm9yIEludGVsIE1FSSBCdXMgRHJpdmVyLgorCitvYmotJChDT05GSUdfSU5URUxf TUVJX1BYUCkgKz0gbWVpX3B4cC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvbWVpL3B4cC9t ZWlfcHhwLmMgYi9kcml2ZXJzL21pc2MvbWVpL3B4cC9tZWlfcHhwLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mNzM4MGQzODdiYWIKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL21pc2MvbWVpL3B4cC9tZWlfcHhwLmMKQEAgLTAsMCArMSwyMjkgQEAKKy8vIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjAg LSAyMDIxIEludGVsIENvcnBvcmF0aW9uCisgKi8KKworLyoqCisgKiBET0M6IE1FSV9QWFAgQ2xp ZW50IERyaXZlcgorICoKKyAqIFRoZSBtZWlfcHhwIGRyaXZlciBhY3RzIGFzIGEgdHJhbnNsYXRp b24gbGF5ZXIgYmV0d2VlbiBQWFAKKyAqIHByb3RvY29sICBpbXBsZW1lbnRlciAoSTkxNSkgYW5k IE1FIEZXIGJ5IHRyYW5zbGF0aW5nIFBYUAorICogbmVnb3RpYXRpb24gbWVzc2FnZXMgdG8gTUUg RlcgY29tbWFuZCBwYXlsb2FkcyBhbmQgdmljZSB2ZXJzYS4KKyAqLworCisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3V1 aWQuaD4KKyNpbmNsdWRlIDxsaW51eC9tZWlfY2xfYnVzLmg+CisjaW5jbHVkZSA8bGludXgvY29t cG9uZW50Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jb25uZWN0b3IuaD4KKyNpbmNsdWRlIDxkcm0v aTkxNV9jb21wb25lbnQuaD4KKyNpbmNsdWRlIDxkcm0vaTkxNV9weHBfdGVlX2ludGVyZmFjZS5o PgorCisjaW5jbHVkZSAibWVpX3B4cC5oIgorCisvKioKKyAqIG1laV9weHBfc2VuZF9tZXNzYWdl KCkgLSBTZW5kcyBhIFBYUCBtZXNzYWdlIHRvIE1FIEZXLgorICogQGRldjogZGV2aWNlIGNvcnJl c3BvbmRpbmcgdG8gdGhlIG1laV9jbF9kZXZpY2UKKyAqIEBtZXNzYWdlOiBhIG1lc3NhZ2UgYnVm ZmVyIHRvIHNlbmQKKyAqIEBzaXplOiBzaXplIG9mIHRoZSBtZXNzYWdlCisgKiBSZXR1cm46IDAg b24gU3VjY2VzcywgPDAgb24gRmFpbHVyZQorICovCitzdGF0aWMgaW50CittZWlfcHhwX3NlbmRf bWVzc2FnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHZvaWQgKm1lc3NhZ2UsIHNpemVfdCBz aXplKQoreworCXN0cnVjdCBtZWlfY2xfZGV2aWNlICpjbGRldjsKKwlzc2l6ZV90IGJ5dGU7CisK KwlpZiAoIWRldiB8fCAhbWVzc2FnZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwljbGRldiA9IHRv X21laV9jbF9kZXZpY2UoZGV2KTsKKworCS8qIHRlbXBvcmFyeSBkcm9wIGNvbnN0IHF1YWxpZmll ciB0aWxsIHRoZSBBUEkgaXMgZml4ZWQgKi8KKwlieXRlID0gbWVpX2NsZGV2X3NlbmQoY2xkZXYs ICh1OCAqKW1lc3NhZ2UsIHNpemUpOworCWlmIChieXRlIDwgMCkgeworCQlkZXZfZGJnKGRldiwg Im1laV9jbGRldl9zZW5kIGZhaWxlZC4gJXpkXG4iLCBieXRlKTsKKwkJcmV0dXJuIGJ5dGU7CisJ fQorCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogbWVpX3B4cF9yZWNlaXZlX21lc3NhZ2UoKSAt IFJlY2VpdmVzIGEgUFhQIG1lc3NhZ2UgZnJvbSBNRSBGVy4KKyAqIEBkZXY6IGRldmljZSBjb3Jy ZXNwb25kaW5nIHRvIHRoZSBtZWlfY2xfZGV2aWNlCisgKiBAYnVmZmVyOiBhIG1lc3NhZ2UgYnVm ZmVyIHRvIGNvbnRhaW4gdGhlIHJlY2VpdmVkIG1lc3NhZ2UKKyAqIEBzaXplOiBzaXplIG9mIHRo ZSBidWZmZXIKKyAqIFJldHVybjogYnl0ZXMgc2VudCBvbiBTdWNjZXNzLCA8MCBvbiBGYWlsdXJl CisgKi8KK3N0YXRpYyBpbnQKK21laV9weHBfcmVjZWl2ZV9tZXNzYWdlKHN0cnVjdCBkZXZpY2Ug KmRldiwgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgbWVpX2NsX2Rldmlj ZSAqY2xkZXY7CisJc3NpemVfdCBieXRlOworCisJaWYgKCFkZXYgfHwgIWJ1ZmZlcikKKwkJcmV0 dXJuIC1FSU5WQUw7CisKKwljbGRldiA9IHRvX21laV9jbF9kZXZpY2UoZGV2KTsKKworCWJ5dGUg PSBtZWlfY2xkZXZfcmVjdihjbGRldiwgYnVmZmVyLCBzaXplKTsKKwlpZiAoYnl0ZSA8IDApIHsK KwkJZGV2X2RiZyhkZXYsICJtZWlfY2xkZXZfcmVjdiBmYWlsZWQuICV6ZFxuIiwgYnl0ZSk7CisJ CXJldHVybiBieXRlOworCX0KKworCXJldHVybiBieXRlOworfQorCitzdGF0aWMgY29uc3Qgc3Ry dWN0IGk5MTVfcHhwX2NvbXBvbmVudF9vcHMgbWVpX3B4cF9vcHMgPSB7CisJLm93bmVyID0gVEhJ U19NT0RVTEUsCisJLnNlbmQgPSBtZWlfcHhwX3NlbmRfbWVzc2FnZSwKKwkucmVjdiA9IG1laV9w eHBfcmVjZWl2ZV9tZXNzYWdlLAorfTsKKworc3RhdGljIGludCBtZWlfY29tcG9uZW50X21hc3Rl cl9iaW5kKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgbWVpX2NsX2RldmljZSAqY2xk ZXYgPSB0b19tZWlfY2xfZGV2aWNlKGRldik7CisJc3RydWN0IGk5MTVfcHhwX2NvbXBvbmVudCAq Y29tcF9tYXN0ZXIgPSBtZWlfY2xkZXZfZ2V0X2RydmRhdGEoY2xkZXYpOworCWludCByZXQ7CisK Kwljb21wX21hc3Rlci0+b3BzID0gJm1laV9weHBfb3BzOworCWNvbXBfbWFzdGVyLT50ZWVfZGV2 ID0gZGV2OworCXJldCA9IGNvbXBvbmVudF9iaW5kX2FsbChkZXYsIGNvbXBfbWFzdGVyKTsKKwlp ZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9p ZCBtZWlfY29tcG9uZW50X21hc3Rlcl91bmJpbmQoc3RydWN0IGRldmljZSAqZGV2KQoreworCXN0 cnVjdCBtZWlfY2xfZGV2aWNlICpjbGRldiA9IHRvX21laV9jbF9kZXZpY2UoZGV2KTsKKwlzdHJ1 Y3QgaTkxNV9weHBfY29tcG9uZW50ICpjb21wX21hc3RlciA9IG1laV9jbGRldl9nZXRfZHJ2ZGF0 YShjbGRldik7CisKKwljb21wb25lbnRfdW5iaW5kX2FsbChkZXYsIGNvbXBfbWFzdGVyKTsKK30K Kworc3RhdGljIGNvbnN0IHN0cnVjdCBjb21wb25lbnRfbWFzdGVyX29wcyBtZWlfY29tcG9uZW50 X21hc3Rlcl9vcHMgPSB7CisJLmJpbmQgPSBtZWlfY29tcG9uZW50X21hc3Rlcl9iaW5kLAorCS51 bmJpbmQgPSBtZWlfY29tcG9uZW50X21hc3Rlcl91bmJpbmQsCit9OworCisvKioKKyAqIG1laV9w eHBfY29tcG9uZW50X21hdGNoIC0gY29tcGFyZSBmdW5jdGlvbiBmb3IgbWF0Y2hpbmcgbWVpIHB4 cC4KKyAqCisgKiAgICBUaGUgZnVuY3Rpb24gY2hlY2tzIGlmIHRoZSBkcml2ZXIgaXMgaTkxNSwg dGhlIHN1YmNvbXBvbmVudCBpcyBQWFAKKyAqICAgIGFuZCB0aGUgZ3JhbmQgcGFyZW50IG9mIHB4 cCBhbmQgdGhlIHBhcmVudCBvZiBpOTE1IGFyZSB0aGUgc2FtZQorICogICAgUENIIGRldmljZS4K KyAqCisgKiBAZGV2OiBtYXN0ZXIgZGV2aWNlCisgKiBAc3ViY29tcG9uZW50OiBzdWJjb21wb25l bnQgdG8gbWF0Y2ggKEk5MTVfQ09NUE9ORU5UX1BYUCkKKyAqIEBkYXRhOiBjb21wYXJlIGRhdGEg KG1laSBweHAgZGV2aWNlKQorICoKKyAqIFJldHVybjoKKyAqICogMSAtIGlmIGNvbXBvbmVudHMg bWF0Y2gKKyAqICogMCAtIG90aGVyd2lzZQorICovCitzdGF0aWMgaW50IG1laV9weHBfY29tcG9u ZW50X21hdGNoKHN0cnVjdCBkZXZpY2UgKmRldiwgaW50IHN1YmNvbXBvbmVudCwKKwkJCQkgICB2 b2lkICpkYXRhKQoreworCXN0cnVjdCBkZXZpY2UgKmJhc2UgPSBkYXRhOworCisJaWYgKHN0cmNt cChkZXYtPmRyaXZlci0+bmFtZSwgImk5MTUiKSB8fAorCSAgICBzdWJjb21wb25lbnQgIT0gSTkx NV9DT01QT05FTlRfUFhQKQorCQlyZXR1cm4gMDsKKworCWJhc2UgPSBiYXNlLT5wYXJlbnQ7CisJ aWYgKCFiYXNlKQorCQlyZXR1cm4gMDsKKworCWJhc2UgPSBiYXNlLT5wYXJlbnQ7CisJZGV2ID0g ZGV2LT5wYXJlbnQ7CisKKwlyZXR1cm4gKGJhc2UgJiYgZGV2ICYmIGRldiA9PSBiYXNlKTsKK30K Kworc3RhdGljIGludCBtZWlfcHhwX3Byb2JlKHN0cnVjdCBtZWlfY2xfZGV2aWNlICpjbGRldiwK KwkJCSBjb25zdCBzdHJ1Y3QgbWVpX2NsX2RldmljZV9pZCAqaWQpCit7CisJc3RydWN0IGk5MTVf cHhwX2NvbXBvbmVudCAqY29tcF9tYXN0ZXI7CisJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqbWFz dGVyX21hdGNoOworCWludCByZXQ7CisKKwlyZXQgPSBtZWlfY2xkZXZfZW5hYmxlKGNsZGV2KTsK KwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKCZjbGRldi0+ZGV2LCAibWVpX2NsZGV2X2VuYWJs ZSBGYWlsZWQuICVkXG4iLCByZXQpOworCQlnb3RvIGVuYWJsZV9lcnJfZXhpdDsKKwl9CisKKwlj b21wX21hc3RlciA9IGt6YWxsb2Moc2l6ZW9mKCpjb21wX21hc3RlciksIEdGUF9LRVJORUwpOwor CWlmICghY29tcF9tYXN0ZXIpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBlcnJfZXhpdDsK Kwl9CisKKwltYXN0ZXJfbWF0Y2ggPSBOVUxMOworCWNvbXBvbmVudF9tYXRjaF9hZGRfdHlwZWQo JmNsZGV2LT5kZXYsICZtYXN0ZXJfbWF0Y2gsCisJCQkJICBtZWlfcHhwX2NvbXBvbmVudF9tYXRj aCwgJmNsZGV2LT5kZXYpOworCWlmIChJU19FUlJfT1JfTlVMTChtYXN0ZXJfbWF0Y2gpKSB7CisJ CXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyX2V4aXQ7CisJfQorCisJbWVpX2NsZGV2X3NldF9k cnZkYXRhKGNsZGV2LCBjb21wX21hc3Rlcik7CisJcmV0ID0gY29tcG9uZW50X21hc3Rlcl9hZGRf d2l0aF9tYXRjaCgmY2xkZXYtPmRldiwKKwkJCQkJICAgICAgJm1laV9jb21wb25lbnRfbWFzdGVy X29wcywKKwkJCQkJICAgICAgbWFzdGVyX21hdGNoKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZf ZXJyKCZjbGRldi0+ZGV2LCAiTWFzdGVyIGNvbXAgYWRkIGZhaWxlZCAlZFxuIiwgcmV0KTsKKwkJ Z290byBlcnJfZXhpdDsKKwl9CisKKwlyZXR1cm4gMDsKKworZXJyX2V4aXQ6CisJbWVpX2NsZGV2 X3NldF9kcnZkYXRhKGNsZGV2LCBOVUxMKTsKKwlrZnJlZShjb21wX21hc3Rlcik7CisJbWVpX2Ns ZGV2X2Rpc2FibGUoY2xkZXYpOworZW5hYmxlX2Vycl9leGl0OgorCXJldHVybiByZXQ7Cit9CisK K3N0YXRpYyB2b2lkIG1laV9weHBfcmVtb3ZlKHN0cnVjdCBtZWlfY2xfZGV2aWNlICpjbGRldikK K3sKKwlzdHJ1Y3QgaTkxNV9weHBfY29tcG9uZW50ICpjb21wX21hc3RlciA9IG1laV9jbGRldl9n ZXRfZHJ2ZGF0YShjbGRldik7CisJaW50IHJldDsKKworCWNvbXBvbmVudF9tYXN0ZXJfZGVsKCZj bGRldi0+ZGV2LCAmbWVpX2NvbXBvbmVudF9tYXN0ZXJfb3BzKTsKKwlrZnJlZShjb21wX21hc3Rl cik7CisJbWVpX2NsZGV2X3NldF9kcnZkYXRhKGNsZGV2LCBOVUxMKTsKKworCXJldCA9IG1laV9j bGRldl9kaXNhYmxlKGNsZGV2KTsKKwlpZiAocmV0KQorCQlkZXZfd2FybigmY2xkZXYtPmRldiwg Im1laV9jbGRldl9kaXNhYmxlKCkgZmFpbGVkXG4iKTsKK30KKworLyogZmJmNmZjZjEtOTZjZi00 ZTJlLWE2YTYtMWJhYjhjYmUzNmIxIDogUEFWUCBHVUlEKi8KKyNkZWZpbmUgTUVJX0dVSURfUFhQ IEdVSURfSU5JVCgweGZiZjZmY2YxLCAweDk2Y2YsIDB4NGUyZSwgMHhBNiwgXAorCQkJICAgICAg IDB4YTYsIDB4MWIsIDB4YWIsIDB4OGMsIDB4YmUsIDB4MzYsIDB4YjEpCisKK3N0YXRpYyBzdHJ1 Y3QgbWVpX2NsX2RldmljZV9pZCBtZWlfcHhwX3RibFtdID0geworCXsgLnV1aWQgPSBNRUlfR1VJ RF9QWFAsIC52ZXJzaW9uID0gTUVJX0NMX1ZFUlNJT05fQU5ZIH0sCisJeyB9Cit9OworTU9EVUxF X0RFVklDRV9UQUJMRShtZWksIG1laV9weHBfdGJsKTsKKworc3RhdGljIHN0cnVjdCBtZWlfY2xf ZHJpdmVyIG1laV9weHBfZHJpdmVyID0geworCS5pZF90YWJsZSA9IG1laV9weHBfdGJsLAorCS5u YW1lID0gS0JVSUxEX01PRE5BTUUsCisJLnByb2JlID0gbWVpX3B4cF9wcm9iZSwKKwkucmVtb3Zl CT0gbWVpX3B4cF9yZW1vdmUsCit9OworCittb2R1bGVfbWVpX2NsX2RyaXZlcihtZWlfcHhwX2Ry aXZlcik7CisKK01PRFVMRV9BVVRIT1IoIkludGVsIENvcnBvcmF0aW9uIik7CitNT0RVTEVfTElD RU5TRSgiR1BMIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIk1FSSBQWFAiKTsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWlzYy9tZWkvcHhwL21laV9weHAuaCBiL2RyaXZlcnMvbWlzYy9tZWkvcHhwL21l aV9weHAuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU3YjE1Mzcz ZmVmZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbWlzYy9tZWkvcHhwL21laV9weHAuaApA QCAtMCwwICsxLDE4IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLwor LyoKKyAqIENvcHlyaWdodCDCqSAyMDIwIEludGVsIENvcnBvcmF0aW9uCisgKgorICogQXV0aG9y czoKKyAqIFZpdGFseSBMdWJhcnQgPHZpdGFseS5sdWJhcnRAaW50ZWwuY29tPgorICovCisKKyNp Zm5kZWYgX19NRUlfUFhQX0hfXworI2RlZmluZSBfX01FSV9QWFBfSF9fCisKKy8qIG1lX3B4cF9z dGF0dXM6IEVudW1lcmF0aW9uIG9mIGFsbCBQWFAgU3RhdHVzIENvZGVzICovCitlbnVtIG1lX3B4 cF9zdGF0dXMgeworCU1FX1BYUF9TVEFUVVNfU1VDQ0VTUwkJCT0gMHgwMDAwLAorCit9OworCisj ZW5kaWYgLyogX19NRUlfUFhQX0hfXyAqLwotLSAKMi4zMi4wCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK