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=-14.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,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 258E7C83006 for ; Wed, 29 Apr 2020 12:57:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 029E321D91 for ; Wed, 29 Apr 2020 12:57:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727041AbgD2M55 (ORCPT ); Wed, 29 Apr 2020 08:57:57 -0400 Received: from asav21.altibox.net ([109.247.116.8]:58612 "EHLO asav21.altibox.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726968AbgD2M55 (ORCPT ); Wed, 29 Apr 2020 08:57:57 -0400 Received: from localhost.localdomain (unknown [81.166.168.211]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: noralf.tronnes@ebnett.no) by asav21.altibox.net (Postfix) with ESMTPSA id 32ABF8018B; Wed, 29 Apr 2020 14:48:50 +0200 (CEST) From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= To: dri-devel@lists.freedesktop.org, linux-usb@vger.kernel.org Cc: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= , Hans de Goede , Jani Nikula , Martin Peres , Daniel Thompson Subject: [PATCH 02/10] drm: Add backlight helper Date: Wed, 29 Apr 2020 14:48:22 +0200 Message-Id: <20200429124830.27475-3-noralf@tronnes.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20200429124830.27475-1-noralf@tronnes.org> References: <20200429124830.27475-1-noralf@tronnes.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CMAE-Score: 0 X-CMAE-Analysis: v=2.3 cv=AvXAIt1P c=1 sm=1 tr=0 a=OYZzhG0JTxDrWp/F2OJbnw==:117 a=OYZzhG0JTxDrWp/F2OJbnw==:17 a=IkcTkHD0fZMA:10 a=M51BFTxLslgA:10 a=VwQbUJbxAAAA:8 a=QyXUC8HyAAAA:8 a=aiIX5UjjAAAA:8 a=nGqoV0jOAAAA:20 a=e5mUnYsNAAAA:8 a=Oh2cFVv5AAAA:8 a=bhchkAzmAAAA:20 a=20KFwNOVAAAA:8 a=KKAkSRfTAAAA:8 a=SJz97ENfAAAA:8 a=UO0b44jCD_nsarDuR4EA:9 a=QEXdDO2ut3YA:10 a=oU43SoCdRycA:10 a=AjGcO6oz07-iQ99wixmX:22 a=K4UmP72BP_XnEf30ZnvK:22 a=Vxmtnl_E_bksehYqCbjh:22 a=7KeoIwV6GZqOttXkcoxL:22 a=cvBusfyB2V15izCimMoJ:22 a=vFet0B0WnEQeilDPIY6i:22 a=pHzHmUro8NiASowvMSCR:22 a=n87TN5wuljxrRezIQYnT:22 Sender: linux-usb-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org This adds a function that creates a backlight device for a connector. It does not deal with the KMS backlight ABI proposition[1] to add a connector property. It only takes the current best practise to standardise the creation of a backlight device for DRM drivers while we wait for the property. The brightness value is set using a connector state variable and an atomic commit. I have looked through some of the backlight users and this is what I've found: GNOME [2] --------- Brightness range: 0-100 Scale: Assumes perceptual Avoids setting the sysfs brightness value to zero if max_brightness >= 99. Can connect connector and backlight using the sysfs device. KDE [3] ------- Brightness range: 0-100 Scale: Assumes perceptual Weston [4] ---------- Brightness range: 0-255 Scale: Assumes perceptual Chromium OS [5] --------------- Brightness range: 0-100 Scale: Depends on the sysfs file 'scale' which is a recent addition (2019) xserver [6] ----------- Brightness range: 0-x (driver specific) (1 is minimum, 0 is OFF) Scale: Assumes perceptual The builtin modesetting driver[7] does not support Backlight, Intel[8] does. [1] https://lore.kernel.org/dri-devel/4b17ba08-39f3-57dd-5aad-d37d844b02c6@linux.intel.com/ [2] https://gitlab.gnome.org/GNOME/gnome-settings-daemon/-/blob/master/plugins/power/gsd-backlight.c [3] https://github.com/KDE/powerdevil/blob/master/daemon/backends/upower/backlighthelper.cpp [4] https://gitlab.freedesktop.org/wayland/weston/-/blob/master/libweston/backend-drm/drm.c [5] https://chromium.googlesource.com/chromiumos/platform2/+/refs/heads/master/power_manager/powerd/system/internal_backlight.cc [6] https://github.com/freedesktop/xorg-randrproto/blob/master/randrproto.txt [7] https://gitlab.freedesktop.org/xorg/xserver/-/blob/master/hw/xfree86/drivers/modesetting/drmmode_display.c [8] https://gitlab.freedesktop.org/xorg/driver/xf86-video-intel/-/blob/master/src/backlight.c Cc: Hans de Goede Cc: Jani Nikula Cc: Martin Peres Cc: Daniel Thompson Signed-off-by: Noralf Trønnes --- Documentation/gpu/drm-kms-helpers.rst | 6 + drivers/gpu/drm/Kconfig | 7 ++ drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/drm_backlight_helper.c | 154 +++++++++++++++++++++++++ include/drm/drm_backlight_helper.h | 9 ++ include/drm/drm_connector.h | 10 ++ 6 files changed, 187 insertions(+) create mode 100644 drivers/gpu/drm/drm_backlight_helper.c create mode 100644 include/drm/drm_backlight_helper.h diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst index 9668a7fe2408..29a2f4b49fd2 100644 --- a/Documentation/gpu/drm-kms-helpers.rst +++ b/Documentation/gpu/drm-kms-helpers.rst @@ -411,3 +411,9 @@ SHMEM GEM Helper Reference .. kernel-doc:: drivers/gpu/drm/drm_gem_shmem_helper.c :export: + +Backlight Helper Reference +========================== + +.. kernel-doc:: drivers/gpu/drm/drm_backlight_helper.c + :export: diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index d0aa6cff2e02..f6e13e18c9ca 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -224,6 +224,13 @@ config DRM_GEM_SHMEM_HELPER help Choose this if you need the GEM shmem helper functions +config DRM_BACKLIGHT_HELPER + bool + depends on DRM + select BACKLIGHT_CLASS_DEVICE + help + Choose this if you need the backlight device helper functions + config DRM_VM bool depends on DRM && MMU diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 6493088a0fdd..0d17662dde0a 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -52,6 +52,7 @@ drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o drm_kms_helper-$(CONFIG_DRM_KMS_CMA_HELPER) += drm_fb_cma_helper.o drm_kms_helper-$(CONFIG_DRM_DP_AUX_CHARDEV) += drm_dp_aux_dev.o drm_kms_helper-$(CONFIG_DRM_DP_CEC) += drm_dp_cec.o +drm_kms_helper-$(CONFIG_DRM_BACKLIGHT_HELPER) += drm_backlight_helper.o obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o obj-$(CONFIG_DRM_DEBUG_SELFTEST) += selftests/ diff --git a/drivers/gpu/drm/drm_backlight_helper.c b/drivers/gpu/drm/drm_backlight_helper.c new file mode 100644 index 000000000000..06e6a75d1d0a --- /dev/null +++ b/drivers/gpu/drm/drm_backlight_helper.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT +/* + * Copyright 2020 Noralf Trønnes + */ + +#include + +#include +#include +#include +#include + +static int drm_backlight_update_status(struct backlight_device *bd) +{ + struct drm_connector *connector = bl_get_data(bd); + struct drm_connector_state *connector_state; + struct drm_device *dev = connector->dev; + struct drm_modeset_acquire_ctx ctx; + struct drm_atomic_state *state; + int ret; + + state = drm_atomic_state_alloc(dev); + if (!state) + return -ENOMEM; + + drm_modeset_acquire_init(&ctx, 0); + state->acquire_ctx = &ctx; +retry: + connector_state = drm_atomic_get_connector_state(state, connector); + if (IS_ERR(connector_state)) { + ret = PTR_ERR(connector_state); + goto out; + } + + connector_state->backlight_brightness = bd->props.brightness; + + ret = drm_atomic_commit(state); +out: + if (ret == -EDEADLK) { + drm_atomic_state_clear(state); + drm_modeset_backoff(&ctx); + goto retry; + } + + drm_atomic_state_put(state); + + drm_modeset_drop_locks(&ctx); + drm_modeset_acquire_fini(&ctx); + + return ret; +} + +static int drm_backlight_get_brightness(struct backlight_device *bd) +{ + struct drm_connector *connector = bl_get_data(bd); + struct drm_device *dev = connector->dev; + int brightness; + + drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); + brightness = connector->state->backlight_brightness; + drm_modeset_unlock(&dev->mode_config.connection_mutex); + + return brightness; +} + +static const struct backlight_ops drm_backlight_ops = { + .get_brightness = drm_backlight_get_brightness, + .update_status = drm_backlight_update_status, +}; + +/* Can be exported for drivers carrying a legacy name */ +static int drm_backlight_register_with_name(struct drm_connector *connector, const char *name) +{ + struct backlight_device *bd; + const struct backlight_properties props = { + .type = BACKLIGHT_RAW, + .scale = BACKLIGHT_SCALE_NON_LINEAR, + .max_brightness = 100, + }; + + if (WARN_ON(!drm_core_check_feature(connector->dev, DRIVER_MODESET) || + !drm_drv_uses_atomic_modeset(connector->dev) || + !connector->kdev)) + return -EINVAL; + + bd = backlight_device_register(name, connector->kdev, connector, + &drm_backlight_ops, &props); + if (IS_ERR(bd)) + return PTR_ERR(bd); + + connector->backlight = bd; + + return 0; +} + +/** + * drm_backlight_register() - Register a backlight device for a connector + * @connector: Connector + * + * This function registers a backlight device for @connector with the following + * characteristics: + * + * - The connector sysfs device is used as a parent device for the backlight device. + * Userspace can use this to connect backlight device and connector. + * - Name will be on the form: **card0-HDMI-A-1-backlight** + * - Type is "raw" + * - Scale is "non-linear" (perceptual) + * - Max brightness is 100 giving a range of 0-100 inclusive + * - Reading sysfs **brightness** returns the backlight device property + * - Reading sysfs **actual_brightness** returns the connector state value + * - Writing sysfs **bl_power** is ignored, the DPMS connector property should + * be used to control power. + * - Backlight device suspend/resume events are ignored. + * + * Note: + * + * Brightness zero should not turn off backlight it should be the minimum + * brightness, DPMS handles power. + * + * This function must be called from &drm_connector_funcs->late_register() since + * it depends on the sysfs device. + * + * Returns: + * Zero on success or negative error code on failure. + */ +int drm_backlight_register(struct drm_connector *connector) +{ + const char *name = NULL; + int ret; + + name = kasprintf(GFP_KERNEL, "card%d-%s-backlight", + connector->dev->primary->index, connector->name); + if (!name) + return -ENOMEM; + + ret = drm_backlight_register_with_name(connector, name); + kfree(name); + + return ret; +} +EXPORT_SYMBOL(drm_backlight_register); + +/** + * drm_backlight_unregister() - Unregister backlight device + * @connector: Connector + * + * Unregister a backlight device. This must be called from the + * &drm_connector_funcs->early_unregister() callback. + */ +void drm_backlight_unregister(struct drm_connector *connector) +{ + backlight_device_unregister(connector->backlight); +} +EXPORT_SYMBOL(drm_backlight_unregister); diff --git a/include/drm/drm_backlight_helper.h b/include/drm/drm_backlight_helper.h new file mode 100644 index 000000000000..4151b66eb0b4 --- /dev/null +++ b/include/drm/drm_backlight_helper.h @@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ + +#ifndef _LINUX_DRM_BACKLIGHT_HELPER_H +#define _LINUX_DRM_BACKLIGHT_HELPER_H + +int drm_backlight_register(struct drm_connector *connector); +void drm_backlight_unregister(struct drm_connector *connector); + +#endif diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index 221910948b37..ce678b694f45 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -32,6 +32,7 @@ #include +struct backlight_device; struct drm_connector_helper_funcs; struct drm_modeset_acquire_ctx; struct drm_device; @@ -656,6 +657,12 @@ struct drm_connector_state { */ u8 max_bpc; + /** + * @backlight_brightness: Brightness value of the connector backlight + * device. See drm_backlight_register(). + */ + u8 backlight_brightness; + /** * @hdr_output_metadata: * DRM blob property for HDR output metadata @@ -1422,6 +1429,9 @@ struct drm_connector { /** @hdr_sink_metadata: HDR Metadata Information read from sink */ struct hdr_sink_metadata hdr_sink_metadata; + + /** @backlight: Backlight device. See drm_backlight_register() */ + struct backlight_device *backlight; }; #define obj_to_connector(x) container_of(x, struct drm_connector, base) -- 2.23.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=-14.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,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 16339C83003 for ; Wed, 29 Apr 2020 12:58:01 +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 E9F5D208FE for ; Wed, 29 Apr 2020 12:58:00 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E9F5D208FE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=tronnes.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 1D3606EDFE; Wed, 29 Apr 2020 12:57:57 +0000 (UTC) Received: from asav21.altibox.net (asav21.altibox.net [109.247.116.8]) by gabe.freedesktop.org (Postfix) with ESMTPS id A5A366EE1E for ; Wed, 29 Apr 2020 12:57:55 +0000 (UTC) Received: from localhost.localdomain (unknown [81.166.168.211]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: noralf.tronnes@ebnett.no) by asav21.altibox.net (Postfix) with ESMTPSA id 32ABF8018B; Wed, 29 Apr 2020 14:48:50 +0200 (CEST) From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= To: dri-devel@lists.freedesktop.org, linux-usb@vger.kernel.org Subject: [PATCH 02/10] drm: Add backlight helper Date: Wed, 29 Apr 2020 14:48:22 +0200 Message-Id: <20200429124830.27475-3-noralf@tronnes.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20200429124830.27475-1-noralf@tronnes.org> References: <20200429124830.27475-1-noralf@tronnes.org> MIME-Version: 1.0 X-CMAE-Score: 0 X-CMAE-Analysis: v=2.3 cv=AvXAIt1P c=1 sm=1 tr=0 a=OYZzhG0JTxDrWp/F2OJbnw==:117 a=OYZzhG0JTxDrWp/F2OJbnw==:17 a=IkcTkHD0fZMA:10 a=M51BFTxLslgA:10 a=VwQbUJbxAAAA:8 a=QyXUC8HyAAAA:8 a=aiIX5UjjAAAA:8 a=nGqoV0jOAAAA:20 a=e5mUnYsNAAAA:8 a=Oh2cFVv5AAAA:8 a=bhchkAzmAAAA:20 a=20KFwNOVAAAA:8 a=KKAkSRfTAAAA:8 a=SJz97ENfAAAA:8 a=UO0b44jCD_nsarDuR4EA:9 a=QEXdDO2ut3YA:10 a=oU43SoCdRycA:10 a=AjGcO6oz07-iQ99wixmX:22 a=K4UmP72BP_XnEf30ZnvK:22 a=Vxmtnl_E_bksehYqCbjh:22 a=7KeoIwV6GZqOttXkcoxL:22 a=cvBusfyB2V15izCimMoJ:22 a=vFet0B0WnEQeilDPIY6i:22 a=pHzHmUro8NiASowvMSCR:22 a=n87TN5wuljxrRezIQYnT:22 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: Hans de Goede , Daniel Thompson Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBhZGRzIGEgZnVuY3Rpb24gdGhhdCBjcmVhdGVzIGEgYmFja2xpZ2h0IGRldmljZSBmb3Ig YSBjb25uZWN0b3IuCkl0IGRvZXMgbm90IGRlYWwgd2l0aCB0aGUgS01TIGJhY2tsaWdodCBBQkkg cHJvcG9zaXRpb25bMV0gdG8gYWRkIGEKY29ubmVjdG9yIHByb3BlcnR5LiBJdCBvbmx5IHRha2Vz IHRoZSBjdXJyZW50IGJlc3QgcHJhY3Rpc2UgdG8gc3RhbmRhcmRpc2UKdGhlIGNyZWF0aW9uIG9m IGEgYmFja2xpZ2h0IGRldmljZSBmb3IgRFJNIGRyaXZlcnMgd2hpbGUgd2Ugd2FpdCBmb3IgdGhl CnByb3BlcnR5LgoKVGhlIGJyaWdodG5lc3MgdmFsdWUgaXMgc2V0IHVzaW5nIGEgY29ubmVjdG9y IHN0YXRlIHZhcmlhYmxlIGFuZCBhbiBhdG9taWMKY29tbWl0LgoKSSBoYXZlIGxvb2tlZCB0aHJv dWdoIHNvbWUgb2YgdGhlIGJhY2tsaWdodCB1c2VycyBhbmQgdGhpcyBpcyB3aGF0IEkndmUgZm91 bmQ6CgpHTk9NRSBbMl0KLS0tLS0tLS0tCgpCcmlnaHRuZXNzIHJhbmdlOiAwLTEwMApTY2FsZTog QXNzdW1lcyBwZXJjZXB0dWFsCgpBdm9pZHMgc2V0dGluZyB0aGUgc3lzZnMgYnJpZ2h0bmVzcyB2 YWx1ZSB0byB6ZXJvIGlmIG1heF9icmlnaHRuZXNzID49IDk5LgpDYW4gY29ubmVjdCBjb25uZWN0 b3IgYW5kIGJhY2tsaWdodCB1c2luZyB0aGUgc3lzZnMgZGV2aWNlLgoKS0RFIFszXQotLS0tLS0t CgpCcmlnaHRuZXNzIHJhbmdlOiAwLTEwMApTY2FsZTogQXNzdW1lcyBwZXJjZXB0dWFsCgpXZXN0 b24gWzRdCi0tLS0tLS0tLS0KCkJyaWdodG5lc3MgcmFuZ2U6IDAtMjU1ClNjYWxlOiBBc3N1bWVz IHBlcmNlcHR1YWwKCkNocm9taXVtIE9TIFs1XQotLS0tLS0tLS0tLS0tLS0KCkJyaWdodG5lc3Mg cmFuZ2U6IDAtMTAwClNjYWxlOiBEZXBlbmRzIG9uIHRoZSBzeXNmcyBmaWxlICdzY2FsZScgd2hp Y2ggaXMgYSByZWNlbnQgYWRkaXRpb24gKDIwMTkpCgp4c2VydmVyIFs2XQotLS0tLS0tLS0tLQoK QnJpZ2h0bmVzcyByYW5nZTogMC14IChkcml2ZXIgc3BlY2lmaWMpICgxIGlzIG1pbmltdW0sIDAg aXMgT0ZGKQpTY2FsZTogQXNzdW1lcyBwZXJjZXB0dWFsCgpUaGUgYnVpbHRpbiBtb2Rlc2V0dGlu ZyBkcml2ZXJbN10gZG9lcyBub3Qgc3VwcG9ydCBCYWNrbGlnaHQsIEludGVsWzhdIGRvZXMuCgpb MV0gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvZHJpLWRldmVsLzRiMTdiYTA4LTM5ZjMtNTdkZC01 YWFkLWQzN2Q4NDRiMDJjNkBsaW51eC5pbnRlbC5jb20vClsyXSBodHRwczovL2dpdGxhYi5nbm9t ZS5vcmcvR05PTUUvZ25vbWUtc2V0dGluZ3MtZGFlbW9uLy0vYmxvYi9tYXN0ZXIvcGx1Z2lucy9w b3dlci9nc2QtYmFja2xpZ2h0LmMKWzNdIGh0dHBzOi8vZ2l0aHViLmNvbS9LREUvcG93ZXJkZXZp bC9ibG9iL21hc3Rlci9kYWVtb24vYmFja2VuZHMvdXBvd2VyL2JhY2tsaWdodGhlbHBlci5jcHAK WzRdIGh0dHBzOi8vZ2l0bGFiLmZyZWVkZXNrdG9wLm9yZy93YXlsYW5kL3dlc3Rvbi8tL2Jsb2Iv bWFzdGVyL2xpYndlc3Rvbi9iYWNrZW5kLWRybS9kcm0uYwpbNV0gaHR0cHM6Ly9jaHJvbWl1bS5n b29nbGVzb3VyY2UuY29tL2Nocm9taXVtb3MvcGxhdGZvcm0yLysvcmVmcy9oZWFkcy9tYXN0ZXIv cG93ZXJfbWFuYWdlci9wb3dlcmQvc3lzdGVtL2ludGVybmFsX2JhY2tsaWdodC5jYwpbNl0gaHR0 cHM6Ly9naXRodWIuY29tL2ZyZWVkZXNrdG9wL3hvcmctcmFuZHJwcm90by9ibG9iL21hc3Rlci9y YW5kcnByb3RvLnR4dApbN10gaHR0cHM6Ly9naXRsYWIuZnJlZWRlc2t0b3Aub3JnL3hvcmcveHNl cnZlci8tL2Jsb2IvbWFzdGVyL2h3L3hmcmVlODYvZHJpdmVycy9tb2Rlc2V0dGluZy9kcm1tb2Rl X2Rpc3BsYXkuYwpbOF0gaHR0cHM6Ly9naXRsYWIuZnJlZWRlc2t0b3Aub3JnL3hvcmcvZHJpdmVy L3hmODYtdmlkZW8taW50ZWwvLS9ibG9iL21hc3Rlci9zcmMvYmFja2xpZ2h0LmMKCkNjOiBIYW5z IGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgpDYzogSmFuaSBOaWt1bGEgPGphbmkubmlr dWxhQGxpbnV4LmludGVsLmNvbT4KQ2M6IE1hcnRpbiBQZXJlcyA8bWFydGluLnBlcmVzQGxpbnV4 LmludGVsLmNvbT4KQ2M6IERhbmllbCBUaG9tcHNvbiA8ZGFuaWVsLnRob21wc29uQGxpbmFyby5v cmc+ClNpZ25lZC1vZmYtYnk6IE5vcmFsZiBUcsO4bm5lcyA8bm9yYWxmQHRyb25uZXMub3JnPgot LS0KIERvY3VtZW50YXRpb24vZ3B1L2RybS1rbXMtaGVscGVycy5yc3QgIHwgICA2ICsKIGRyaXZl cnMvZ3B1L2RybS9LY29uZmlnICAgICAgICAgICAgICAgIHwgICA3ICsrCiBkcml2ZXJzL2dwdS9k cm0vTWFrZWZpbGUgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2Jh Y2tsaWdodF9oZWxwZXIuYyB8IDE1NCArKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRl L2RybS9kcm1fYmFja2xpZ2h0X2hlbHBlci5oICAgICB8ICAgOSArKwogaW5jbHVkZS9kcm0vZHJt X2Nvbm5lY3Rvci5oICAgICAgICAgICAgfCAgMTAgKysKIDYgZmlsZXMgY2hhbmdlZCwgMTg3IGlu c2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vZHJtX2JhY2ts aWdodF9oZWxwZXIuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvZHJtL2RybV9iYWNrbGln aHRfaGVscGVyLmgKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBl cnMucnN0IGIvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy1oZWxwZXJzLnJzdAppbmRleCA5NjY4 YTdmZTI0MDguLjI5YTJmNGI0OWZkMiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJt LWttcy1oZWxwZXJzLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMu cnN0CkBAIC00MTEsMyArNDExLDkgQEAgU0hNRU0gR0VNIEhlbHBlciBSZWZlcmVuY2UKIAogLi4g a2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9kcm1fZ2VtX3NobWVtX2hlbHBlci5jCiAgICA6 ZXhwb3J0OgorCitCYWNrbGlnaHQgSGVscGVyIFJlZmVyZW5jZQorPT09PT09PT09PT09PT09PT09 PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9kcm1fYmFja2xpZ2h0 X2hlbHBlci5jCisgICA6ZXhwb3J0OgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL0tjb25m aWcgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwppbmRleCBkMGFhNmNmZjJlMDIuLmY2ZTEzZTE4 YzljYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKKysrIGIvZHJpdmVycy9n cHUvZHJtL0tjb25maWcKQEAgLTIyNCw2ICsyMjQsMTMgQEAgY29uZmlnIERSTV9HRU1fU0hNRU1f SEVMUEVSCiAJaGVscAogCSAgQ2hvb3NlIHRoaXMgaWYgeW91IG5lZWQgdGhlIEdFTSBzaG1lbSBo ZWxwZXIgZnVuY3Rpb25zCiAKK2NvbmZpZyBEUk1fQkFDS0xJR0hUX0hFTFBFUgorCWJvb2wKKwlk ZXBlbmRzIG9uIERSTQorCXNlbGVjdCBCQUNLTElHSFRfQ0xBU1NfREVWSUNFCisJaGVscAorCSAg Q2hvb3NlIHRoaXMgaWYgeW91IG5lZWQgdGhlIGJhY2tsaWdodCBkZXZpY2UgaGVscGVyIGZ1bmN0 aW9ucworCiBjb25maWcgRFJNX1ZNCiAJYm9vbAogCWRlcGVuZHMgb24gRFJNICYmIE1NVQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL01ha2Vm aWxlCmluZGV4IDY0OTMwODhhMGZkZC4uMGQxNzY2MmRkZTBhIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCkBAIC01Miw2 ICs1Miw3IEBAIGRybV9rbXNfaGVscGVyLSQoQ09ORklHX0RSTV9GQkRFVl9FTVVMQVRJT04pICs9 IGRybV9mYl9oZWxwZXIubwogZHJtX2ttc19oZWxwZXItJChDT05GSUdfRFJNX0tNU19DTUFfSEVM UEVSKSArPSBkcm1fZmJfY21hX2hlbHBlci5vCiBkcm1fa21zX2hlbHBlci0kKENPTkZJR19EUk1f RFBfQVVYX0NIQVJERVYpICs9IGRybV9kcF9hdXhfZGV2Lm8KIGRybV9rbXNfaGVscGVyLSQoQ09O RklHX0RSTV9EUF9DRUMpICs9IGRybV9kcF9jZWMubworZHJtX2ttc19oZWxwZXItJChDT05GSUdf RFJNX0JBQ0tMSUdIVF9IRUxQRVIpICs9IGRybV9iYWNrbGlnaHRfaGVscGVyLm8KIAogb2JqLSQo Q09ORklHX0RSTV9LTVNfSEVMUEVSKSArPSBkcm1fa21zX2hlbHBlci5vCiBvYmotJChDT05GSUdf RFJNX0RFQlVHX1NFTEZURVNUKSArPSBzZWxmdGVzdHMvCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vZHJtX2JhY2tsaWdodF9oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYmFja2xp Z2h0X2hlbHBlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMDZl NmE3NWQxZDBhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9iYWNrbGln aHRfaGVscGVyLmMKQEAgLTAsMCArMSwxNTQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wIE9SIE1JVAorLyoKKyAqIENvcHlyaWdodCAyMDIwIE5vcmFsZiBUcsO4bm5lcwor ICovCisKKyNpbmNsdWRlIDxsaW51eC9iYWNrbGlnaHQuaD4KKworI2luY2x1ZGUgPGRybS9kcm1f YXRvbWljLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jb25uZWN0b3IuaD4KKyNpbmNsdWRlIDxkcm0v ZHJtX2Rydi5oPgorI2luY2x1ZGUgPGRybS9kcm1fZmlsZS5oPgorCitzdGF0aWMgaW50IGRybV9i YWNrbGlnaHRfdXBkYXRlX3N0YXR1cyhzdHJ1Y3QgYmFja2xpZ2h0X2RldmljZSAqYmQpCit7CisJ c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciA9IGJsX2dldF9kYXRhKGJkKTsKKwlzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubmVjdG9yX3N0YXRlOworCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXYgPSBjb25uZWN0b3ItPmRldjsKKwlzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9j dHggY3R4OworCXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZTsKKwlpbnQgcmV0OworCisJ c3RhdGUgPSBkcm1fYXRvbWljX3N0YXRlX2FsbG9jKGRldik7CisJaWYgKCFzdGF0ZSkKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwlkcm1fbW9kZXNldF9hY3F1aXJlX2luaXQoJmN0eCwgMCk7CisJc3Rh dGUtPmFjcXVpcmVfY3R4ID0gJmN0eDsKK3JldHJ5OgorCWNvbm5lY3Rvcl9zdGF0ZSA9IGRybV9h dG9taWNfZ2V0X2Nvbm5lY3Rvcl9zdGF0ZShzdGF0ZSwgY29ubmVjdG9yKTsKKwlpZiAoSVNfRVJS KGNvbm5lY3Rvcl9zdGF0ZSkpIHsKKwkJcmV0ID0gUFRSX0VSUihjb25uZWN0b3Jfc3RhdGUpOwor CQlnb3RvIG91dDsKKwl9CisKKwljb25uZWN0b3Jfc3RhdGUtPmJhY2tsaWdodF9icmlnaHRuZXNz ID0gYmQtPnByb3BzLmJyaWdodG5lc3M7CisKKwlyZXQgPSBkcm1fYXRvbWljX2NvbW1pdChzdGF0 ZSk7CitvdXQ6CisJaWYgKHJldCA9PSAtRURFQURMSykgeworCQlkcm1fYXRvbWljX3N0YXRlX2Ns ZWFyKHN0YXRlKTsKKwkJZHJtX21vZGVzZXRfYmFja29mZigmY3R4KTsKKwkJZ290byByZXRyeTsK Kwl9CisKKwlkcm1fYXRvbWljX3N0YXRlX3B1dChzdGF0ZSk7CisKKwlkcm1fbW9kZXNldF9kcm9w X2xvY2tzKCZjdHgpOworCWRybV9tb2Rlc2V0X2FjcXVpcmVfZmluaSgmY3R4KTsKKworCXJldHVy biByZXQ7Cit9CisKK3N0YXRpYyBpbnQgZHJtX2JhY2tsaWdodF9nZXRfYnJpZ2h0bmVzcyhzdHJ1 Y3QgYmFja2xpZ2h0X2RldmljZSAqYmQpCit7CisJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5l Y3RvciA9IGJsX2dldF9kYXRhKGJkKTsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY29ubmVj dG9yLT5kZXY7CisJaW50IGJyaWdodG5lc3M7CisKKwlkcm1fbW9kZXNldF9sb2NrKCZkZXYtPm1v ZGVfY29uZmlnLmNvbm5lY3Rpb25fbXV0ZXgsIE5VTEwpOworCWJyaWdodG5lc3MgPSBjb25uZWN0 b3ItPnN0YXRlLT5iYWNrbGlnaHRfYnJpZ2h0bmVzczsKKwlkcm1fbW9kZXNldF91bmxvY2soJmRl di0+bW9kZV9jb25maWcuY29ubmVjdGlvbl9tdXRleCk7CisKKwlyZXR1cm4gYnJpZ2h0bmVzczsK K30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiYWNrbGlnaHRfb3BzIGRybV9iYWNrbGlnaHRfb3Bz ID0geworCS5nZXRfYnJpZ2h0bmVzcyA9IGRybV9iYWNrbGlnaHRfZ2V0X2JyaWdodG5lc3MsCisJ LnVwZGF0ZV9zdGF0dXMJPSBkcm1fYmFja2xpZ2h0X3VwZGF0ZV9zdGF0dXMsCit9OworCisvKiBD YW4gYmUgZXhwb3J0ZWQgZm9yIGRyaXZlcnMgY2FycnlpbmcgYSBsZWdhY3kgbmFtZSAqLworc3Rh dGljIGludCBkcm1fYmFja2xpZ2h0X3JlZ2lzdGVyX3dpdGhfbmFtZShzdHJ1Y3QgZHJtX2Nvbm5l Y3RvciAqY29ubmVjdG9yLCBjb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCBiYWNrbGlnaHRf ZGV2aWNlICpiZDsKKwljb25zdCBzdHJ1Y3QgYmFja2xpZ2h0X3Byb3BlcnRpZXMgcHJvcHMgPSB7 CisJCS50eXBlID0gQkFDS0xJR0hUX1JBVywKKwkJLnNjYWxlID0gQkFDS0xJR0hUX1NDQUxFX05P Tl9MSU5FQVIsCisJCS5tYXhfYnJpZ2h0bmVzcyA9IDEwMCwKKwl9OworCisJaWYgKFdBUk5fT04o IWRybV9jb3JlX2NoZWNrX2ZlYXR1cmUoY29ubmVjdG9yLT5kZXYsIERSSVZFUl9NT0RFU0VUKSB8 fAorCQkgICAgIWRybV9kcnZfdXNlc19hdG9taWNfbW9kZXNldChjb25uZWN0b3ItPmRldikgfHwK KwkJICAgICFjb25uZWN0b3ItPmtkZXYpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWJkID0gYmFj a2xpZ2h0X2RldmljZV9yZWdpc3RlcihuYW1lLCBjb25uZWN0b3ItPmtkZXYsIGNvbm5lY3RvciwK KwkJCQkgICAgICAgJmRybV9iYWNrbGlnaHRfb3BzLCAmcHJvcHMpOworCWlmIChJU19FUlIoYmQp KQorCQlyZXR1cm4gUFRSX0VSUihiZCk7CisKKwljb25uZWN0b3ItPmJhY2tsaWdodCA9IGJkOwor CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogZHJtX2JhY2tsaWdodF9yZWdpc3RlcigpIC0gUmVn aXN0ZXIgYSBiYWNrbGlnaHQgZGV2aWNlIGZvciBhIGNvbm5lY3RvcgorICogQGNvbm5lY3Rvcjog Q29ubmVjdG9yCisgKgorICogVGhpcyBmdW5jdGlvbiByZWdpc3RlcnMgYSBiYWNrbGlnaHQgZGV2 aWNlIGZvciBAY29ubmVjdG9yIHdpdGggdGhlIGZvbGxvd2luZworICogY2hhcmFjdGVyaXN0aWNz OgorICoKKyAqIC0gVGhlIGNvbm5lY3RvciBzeXNmcyBkZXZpY2UgaXMgdXNlZCBhcyBhIHBhcmVu dCBkZXZpY2UgZm9yIHRoZSBiYWNrbGlnaHQgZGV2aWNlLgorICogICBVc2Vyc3BhY2UgY2FuIHVz ZSB0aGlzIHRvIGNvbm5lY3QgYmFja2xpZ2h0IGRldmljZSBhbmQgY29ubmVjdG9yLgorICogLSBO YW1lIHdpbGwgYmUgb24gdGhlIGZvcm06ICoqY2FyZDAtSERNSS1BLTEtYmFja2xpZ2h0KioKKyAq IC0gVHlwZSBpcyAicmF3IgorICogLSBTY2FsZSBpcyAibm9uLWxpbmVhciIgKHBlcmNlcHR1YWwp CisgKiAtIE1heCBicmlnaHRuZXNzIGlzIDEwMCBnaXZpbmcgYSByYW5nZSBvZiAwLTEwMCBpbmNs dXNpdmUKKyAqIC0gUmVhZGluZyBzeXNmcyAqKmJyaWdodG5lc3MqKiByZXR1cm5zIHRoZSBiYWNr bGlnaHQgZGV2aWNlIHByb3BlcnR5CisgKiAtIFJlYWRpbmcgc3lzZnMgKiphY3R1YWxfYnJpZ2h0 bmVzcyoqIHJldHVybnMgdGhlIGNvbm5lY3RvciBzdGF0ZSB2YWx1ZQorICogLSBXcml0aW5nIHN5 c2ZzICoqYmxfcG93ZXIqKiBpcyBpZ25vcmVkLCB0aGUgRFBNUyBjb25uZWN0b3IgcHJvcGVydHkg c2hvdWxkCisgKiAgIGJlIHVzZWQgdG8gY29udHJvbCBwb3dlci4KKyAqIC0gQmFja2xpZ2h0IGRl dmljZSBzdXNwZW5kL3Jlc3VtZSBldmVudHMgYXJlIGlnbm9yZWQuCisgKgorICogTm90ZToKKyAq CisgKiBCcmlnaHRuZXNzIHplcm8gc2hvdWxkIG5vdCB0dXJuIG9mZiBiYWNrbGlnaHQgaXQgc2hv dWxkIGJlIHRoZSBtaW5pbXVtCisgKiBicmlnaHRuZXNzLCBEUE1TIGhhbmRsZXMgcG93ZXIuCisg KgorICogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCBmcm9tICZkcm1fY29ubmVjdG9yX2Z1 bmNzLT5sYXRlX3JlZ2lzdGVyKCkgc2luY2UKKyAqIGl0IGRlcGVuZHMgb24gdGhlIHN5c2ZzIGRl dmljZS4KKyAqCisgKiBSZXR1cm5zOgorICogWmVybyBvbiBzdWNjZXNzIG9yIG5lZ2F0aXZlIGVy cm9yIGNvZGUgb24gZmFpbHVyZS4KKyAqLworaW50IGRybV9iYWNrbGlnaHRfcmVnaXN0ZXIoc3Ry dWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKK3sKKwljb25zdCBjaGFyICpuYW1lID0gTlVM TDsKKwlpbnQgcmV0OworCisJbmFtZSA9IGthc3ByaW50ZihHRlBfS0VSTkVMLCAiY2FyZCVkLSVz LWJhY2tsaWdodCIsCisJCQkgY29ubmVjdG9yLT5kZXYtPnByaW1hcnktPmluZGV4LCBjb25uZWN0 b3ItPm5hbWUpOworCWlmICghbmFtZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXQgPSBkcm1f YmFja2xpZ2h0X3JlZ2lzdGVyX3dpdGhfbmFtZShjb25uZWN0b3IsIG5hbWUpOworCWtmcmVlKG5h bWUpOworCisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2JhY2tsaWdodF9yZWdp c3Rlcik7CisKKy8qKgorICogZHJtX2JhY2tsaWdodF91bnJlZ2lzdGVyKCkgLSBVbnJlZ2lzdGVy IGJhY2tsaWdodCBkZXZpY2UKKyAqIEBjb25uZWN0b3I6IENvbm5lY3RvcgorICoKKyAqIFVucmVn aXN0ZXIgYSBiYWNrbGlnaHQgZGV2aWNlLiBUaGlzIG11c3QgYmUgY2FsbGVkIGZyb20gdGhlCisg KiAmZHJtX2Nvbm5lY3Rvcl9mdW5jcy0+ZWFybHlfdW5yZWdpc3RlcigpIGNhbGxiYWNrLgorICov Cit2b2lkIGRybV9iYWNrbGlnaHRfdW5yZWdpc3RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29u bmVjdG9yKQoreworCWJhY2tsaWdodF9kZXZpY2VfdW5yZWdpc3Rlcihjb25uZWN0b3ItPmJhY2ts aWdodCk7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9iYWNrbGlnaHRfdW5yZWdpc3Rlcik7CmRpZmYg LS1naXQgYS9pbmNsdWRlL2RybS9kcm1fYmFja2xpZ2h0X2hlbHBlci5oIGIvaW5jbHVkZS9kcm0v ZHJtX2JhY2tsaWdodF9oZWxwZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLjQxNTFiNjZlYjBiNAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvZHJtL2RybV9i YWNrbGlnaHRfaGVscGVyLmgKQEAgLTAsMCArMSw5IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRp ZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworI2lmbmRlZiBfTElOVVhfRFJNX0JBQ0tMSUdIVF9I RUxQRVJfSAorI2RlZmluZSBfTElOVVhfRFJNX0JBQ0tMSUdIVF9IRUxQRVJfSAorCitpbnQgZHJt X2JhY2tsaWdodF9yZWdpc3RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKK3Zv aWQgZHJtX2JhY2tsaWdodF91bnJlZ2lzdGVyKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0 b3IpOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaCBi L2luY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaAppbmRleCAyMjE5MTA5NDhiMzcuLmNlNjc4YjY5 NGY0NSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oCisrKyBiL2luY2x1 ZGUvZHJtL2RybV9jb25uZWN0b3IuaApAQCAtMzIsNiArMzIsNyBAQAogCiAjaW5jbHVkZSA8dWFw aS9kcm0vZHJtX21vZGUuaD4KIAorc3RydWN0IGJhY2tsaWdodF9kZXZpY2U7CiBzdHJ1Y3QgZHJt X2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3M7CiBzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHg7 CiBzdHJ1Y3QgZHJtX2RldmljZTsKQEAgLTY1Niw2ICs2NTcsMTIgQEAgc3RydWN0IGRybV9jb25u ZWN0b3Jfc3RhdGUgewogCSAqLwogCXU4IG1heF9icGM7CiAKKwkvKioKKwkgKiBAYmFja2xpZ2h0 X2JyaWdodG5lc3M6IEJyaWdodG5lc3MgdmFsdWUgb2YgdGhlIGNvbm5lY3RvciBiYWNrbGlnaHQK KwkgKiBkZXZpY2UuIFNlZSBkcm1fYmFja2xpZ2h0X3JlZ2lzdGVyKCkuCisJICovCisJdTggYmFj a2xpZ2h0X2JyaWdodG5lc3M7CisKIAkvKioKIAkgKiBAaGRyX291dHB1dF9tZXRhZGF0YToKIAkg KiBEUk0gYmxvYiBwcm9wZXJ0eSBmb3IgSERSIG91dHB1dCBtZXRhZGF0YQpAQCAtMTQyMiw2ICsx NDI5LDkgQEAgc3RydWN0IGRybV9jb25uZWN0b3IgewogCiAJLyoqIEBoZHJfc2lua19tZXRhZGF0 YTogSERSIE1ldGFkYXRhIEluZm9ybWF0aW9uIHJlYWQgZnJvbSBzaW5rICovCiAJc3RydWN0IGhk cl9zaW5rX21ldGFkYXRhIGhkcl9zaW5rX21ldGFkYXRhOworCisJLyoqIEBiYWNrbGlnaHQ6IEJh Y2tsaWdodCBkZXZpY2UuIFNlZSBkcm1fYmFja2xpZ2h0X3JlZ2lzdGVyKCkgKi8KKwlzdHJ1Y3Qg YmFja2xpZ2h0X2RldmljZSAqYmFja2xpZ2h0OwogfTsKIAogI2RlZmluZSBvYmpfdG9fY29ubmVj dG9yKHgpIGNvbnRhaW5lcl9vZih4LCBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciwgYmFzZSkKLS0gCjIu MjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==