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.3 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED 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 873FFC433E0 for ; Mon, 8 Feb 2021 23:43:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3ECC664E9D for ; Mon, 8 Feb 2021 23:43:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231235AbhBHXnd (ORCPT ); Mon, 8 Feb 2021 18:43:33 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:53283 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230071AbhBHXlR (ORCPT ); Mon, 8 Feb 2021 18:41:17 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1612827589; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=gE9U5BslqCar72kVEWsclaxt7xAzUfHLFCjpahn4dKk=; b=fAFZgq7DZmLW06BN6f5C2Xv2aYI+EvLrk5JMVj2BcCUY/wSBZqS8qc53D+HIa6/e40iYyS YTmReHXnqy5QW8eNo8t0YlfY+4TX+SEnNHaITyp5nMXwSn8TsyjGZu9jndwNCYiOF7H2aS X+cAhDdsSZ+s1+YU1kRW/dKOrkQA8vE= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-434-xGYuc_3bN2eggmu2PhXpnA-1; Mon, 08 Feb 2021 18:39:43 -0500 X-MC-Unique: xGYuc_3bN2eggmu2PhXpnA-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0FDF280402C; Mon, 8 Feb 2021 23:39:42 +0000 (UTC) Received: from Whitewolf.redhat.com (ovpn-114-219.rdu2.redhat.com [10.10.114.219]) by smtp.corp.redhat.com (Postfix) with ESMTP id BDC1B608DB; Mon, 8 Feb 2021 23:39:40 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Cc: Jani Nikula , Dave Airlie , greg.depoire@gmail.com, Ben Skeggs , David Airlie , Daniel Vetter , Dave Airlie , Pankaj Bharadiya , James Jones , linux-kernel@vger.kernel.org (open list) Subject: [RFC v4 11/11] drm/nouveau/kms/nv50-: Add basic DPCD backlight support for nouveau Date: Mon, 8 Feb 2021 18:39:01 -0500 Message-Id: <20210208233902.1289693-12-lyude@redhat.com> In-Reply-To: <20210208233902.1289693-1-lyude@redhat.com> References: <20210208233902.1289693-1-lyude@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This adds support for controlling panel backlights over eDP using VESA's standard backlight control interface. Luckily, Nvidia was cool enough to never come up with their own proprietary backlight control interface (at least, not any that I or the laptop manufacturers I've talked to are aware of), so this should work for any laptop panels which support the VESA backlight control interface. Note that we don't yet provide the panel backlight frequency to the DRM DP backlight helpers. This should be fine for the time being, since it's not required to get basic backlight controls working. For reference: there's some mentions of PWM backlight values in nouveau_reg.h, but I'm not sure these are the values we would want to use. If we figure out how to get this information in the future, we'll have the benefit of more granular backlight control. Signed-off-by: Lyude Paul Cc: Jani Nikula Cc: Dave Airlie Cc: greg.depoire@gmail.com --- drivers/gpu/drm/nouveau/dispnv50/disp.c | 28 ++++ drivers/gpu/drm/nouveau/nouveau_backlight.c | 166 ++++++++++++++++++-- drivers/gpu/drm/nouveau/nouveau_connector.h | 9 +- drivers/gpu/drm/nouveau/nouveau_encoder.h | 1 + 4 files changed, 186 insertions(+), 18 deletions(-) diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.c b/drivers/gpu/drm/nouveau/dispnv50/disp.c index 196612addfd6..4a1819b02084 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/disp.c +++ b/drivers/gpu/drm/nouveau/dispnv50/disp.c @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -1647,15 +1648,30 @@ nv50_sor_update(struct nouveau_encoder *nv_encoder, u8 head, core->func->sor->ctrl(core, nv_encoder->or, nv_encoder->ctrl, asyh); } +/* TODO: Should we extend this to PWM-only backlights? + * As well, should we add a DRM helper for waiting for the backlight to acknowledge + * the panel backlight has been shut off? Intel doesn't seem to do this, and uses a + * fixed time delay from the vbios… + */ static void nv50_sor_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state) { struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder); + struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nouveau_crtc *nv_crtc = nouveau_crtc(nv_encoder->crtc); struct nouveau_connector *nv_connector = nv50_outp_get_old_connector(state, nv_encoder); + struct nouveau_backlight *backlight = nv_connector->backlight; struct drm_dp_aux *aux = &nv_connector->aux; + int ret; u8 pwr; + if (backlight && backlight->uses_dpcd) { + ret = drm_edp_backlight_disable(aux, &backlight->edp_info); + if (ret < 0) + NV_ERROR(drm, "Failed to disable backlight on [CONNECTOR:%d:%s]: %d\n", + nv_connector->base.base.id, nv_connector->base.name, ret); + } + if (nv_encoder->dcb->type == DCB_OUTPUT_DP) { int ret = drm_dp_dpcd_readb(aux, DP_SET_POWER, &pwr); @@ -1694,6 +1710,9 @@ nv50_sor_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *sta struct drm_device *dev = encoder->dev; struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_connector *nv_connector; +#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT + struct nouveau_backlight *backlight; +#endif struct nvbios *bios = &drm->vbios; bool hda = false; u8 proto = NV507D_SOR_SET_CONTROL_PROTOCOL_CUSTOM; @@ -1768,6 +1787,14 @@ nv50_sor_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *sta proto = NV887D_SOR_SET_CONTROL_PROTOCOL_DP_B; nv50_audio_enable(encoder, nv_crtc, nv_connector, state, mode); + +#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT + backlight = nv_connector->backlight; + if (backlight && backlight->uses_dpcd) + drm_edp_backlight_enable(&nv_connector->aux, &backlight->edp_info, + (u16)backlight->dev->props.brightness); +#endif + break; default: BUG(); @@ -2293,6 +2320,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state) nv50_crc_atomic_start_reporting(state); if (!flushed) nv50_crc_atomic_release_notifier_contexts(state); + drm_atomic_helper_commit_hw_done(state); drm_atomic_helper_cleanup_planes(dev, state); drm_atomic_helper_commit_cleanup_done(state); diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c index 42b498e7e2bf..a11811b5e63e 100644 --- a/drivers/gpu/drm/nouveau/nouveau_backlight.c +++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c @@ -42,11 +42,6 @@ static struct ida bl_ida; #define BL_NAME_SIZE 15 // 12 for name + 2 for digits + 1 for '\0' -struct nouveau_backlight { - struct backlight_device *dev; - int id; -}; - static bool nouveau_get_backlight_name(char backlight_name[BL_NAME_SIZE], struct nouveau_backlight *bl) @@ -147,6 +142,98 @@ static const struct backlight_ops nv50_bl_ops = { .update_status = nv50_set_intensity, }; +/* + * eDP brightness callbacks need to happen under lock, since we need to + * enable/disable the backlight ourselves for modesets + */ +static int +nv50_edp_get_brightness(struct backlight_device *bd) +{ + struct drm_connector *connector = dev_get_drvdata(bd->dev.parent); + struct drm_device *dev = connector->dev; + struct drm_crtc *crtc; + struct drm_modeset_acquire_ctx ctx; + int ret = 0; + + drm_modeset_acquire_init(&ctx, 0); + +retry: + ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx); + if (ret == -EDEADLK) + goto deadlock; + else if (ret < 0) + goto out; + + crtc = connector->state->crtc; + if (!crtc) + goto out; + + ret = drm_modeset_lock(&crtc->mutex, &ctx); + if (ret == -EDEADLK) + goto deadlock; + else if (ret < 0) + goto out; + + if (!crtc->state->active) + goto out; + + ret = bd->props.brightness; +out: + drm_modeset_drop_locks(&ctx); + drm_modeset_acquire_fini(&ctx); + return ret; +deadlock: + drm_modeset_backoff(&ctx); + goto retry; +} + +static int +nv50_edp_set_brightness(struct backlight_device *bd) +{ + struct drm_connector *connector = dev_get_drvdata(bd->dev.parent); + struct nouveau_connector *nv_connector = nouveau_connector(connector); + struct drm_device *dev = connector->dev; + struct drm_crtc *crtc; + struct drm_dp_aux *aux = &nv_connector->aux; + struct nouveau_backlight *nv_bl = nv_connector->backlight; + struct drm_modeset_acquire_ctx ctx; + int ret = 0; + + drm_modeset_acquire_init(&ctx, 0); +retry: + ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx); + if (ret == -EDEADLK) + goto deadlock; + else if (ret < 0) + goto out; + + crtc = connector->state->crtc; + if (!crtc) + goto out; + + ret = drm_modeset_lock(&crtc->mutex, &ctx); + if (ret == -EDEADLK) + goto deadlock; + else if (ret < 0) + goto out; + + if (crtc->state->active) + ret = drm_edp_backlight_set_level(aux, &nv_bl->edp_info, bd->props.brightness); + +out: + drm_modeset_drop_locks(&ctx); + drm_modeset_acquire_fini(&ctx); + return ret; +deadlock: + drm_modeset_backoff(&ctx); + goto retry; +} + +static const struct backlight_ops nv50_edp_bl_ops = { + .get_brightness = nv50_edp_get_brightness, + .update_status = nv50_edp_set_brightness, +}; + static int nva3_get_intensity(struct backlight_device *bd) { @@ -193,8 +280,13 @@ static const struct backlight_ops nva3_bl_ops = { .update_status = nva3_set_intensity, }; +/* FIXME: perform backlight probing for eDP _before_ this, this only gets called after connector + * registration which happens after the initial modeset + */ static int -nv50_backlight_init(struct nouveau_encoder *nv_encoder, +nv50_backlight_init(struct nouveau_backlight *bl, + struct nouveau_connector *nv_conn, + struct nouveau_encoder *nv_encoder, struct backlight_properties *props, const struct backlight_ops **ops) { @@ -204,6 +296,41 @@ nv50_backlight_init(struct nouveau_encoder *nv_encoder, if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(ffs(nv_encoder->dcb->or) - 1))) return -ENODEV; + if (nv_conn->type == DCB_CONNECTOR_eDP) { + int ret; + u16 current_level; + u8 edp_dpcd[EDP_DISPLAY_CTL_CAP_SIZE]; + u8 current_mode; + + ret = drm_dp_dpcd_read(&nv_conn->aux, DP_EDP_DPCD_REV, edp_dpcd, + EDP_DISPLAY_CTL_CAP_SIZE); + if (ret < 0) + return ret; + + if (drm_edp_backlight_supported(edp_dpcd)) { + NV_DEBUG(drm, "DPCD backlight controls supported on %s\n", + nv_conn->base.name); + + ret = drm_edp_backlight_init(&nv_conn->aux, &bl->edp_info, 0, edp_dpcd, + ¤t_level, ¤t_mode); + if (ret < 0) + return ret; + + ret = drm_edp_backlight_enable(&nv_conn->aux, &bl->edp_info, current_level); + if (ret < 0) { + NV_ERROR(drm, "Failed to enable backlight on %s: %d\n", + nv_conn->base.name, ret); + return ret; + } + + *ops = &nv50_edp_bl_ops; + props->brightness = current_level; + props->max_brightness = bl->edp_info.max; + bl->uses_dpcd = true; + return 0; + } + } + if (drm->client.device.info.chipset <= 0xa0 || drm->client.device.info.chipset == 0xaa || drm->client.device.info.chipset == 0xac) @@ -243,6 +370,10 @@ nouveau_backlight_init(struct drm_connector *connector) if (!nv_encoder) return 0; + bl = kzalloc(sizeof(*bl), GFP_KERNEL); + if (!bl) + return -ENOMEM; + switch (device->info.family) { case NV_DEVICE_INFO_V0_CURIE: ret = nv40_backlight_init(nv_encoder, &props, &ops); @@ -255,20 +386,19 @@ nouveau_backlight_init(struct drm_connector *connector) case NV_DEVICE_INFO_V0_VOLTA: case NV_DEVICE_INFO_V0_TURING: case NV_DEVICE_INFO_V0_AMPERE: //XXX: not confirmed - ret = nv50_backlight_init(nv_encoder, &props, &ops); + ret = nv50_backlight_init(bl, nouveau_connector(connector), + nv_encoder, &props, &ops); break; default: - return 0; + ret = 0; + goto fail_alloc; } - if (ret == -ENODEV) - return 0; - else if (ret) - return ret; - - bl = kzalloc(sizeof(*bl), GFP_KERNEL); - if (!bl) - return -ENOMEM; + if (ret) { + if (ret == -ENODEV) + ret = 0; + goto fail_alloc; + } if (!nouveau_get_backlight_name(backlight_name, bl)) { NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n"); @@ -285,7 +415,9 @@ nouveau_backlight_init(struct drm_connector *connector) } nouveau_connector(connector)->backlight = bl; - bl->dev->props.brightness = bl->dev->ops->get_brightness(bl->dev); + if (!bl->dev->props.brightness) + bl->dev->props.brightness = + bl->dev->ops->get_brightness(bl->dev); backlight_update_status(bl->dev); return 0; diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.h b/drivers/gpu/drm/nouveau/nouveau_connector.h index d0b859c4a80e..40f90e353540 100644 --- a/drivers/gpu/drm/nouveau/nouveau_connector.h +++ b/drivers/gpu/drm/nouveau/nouveau_connector.h @@ -46,7 +46,14 @@ struct nvkm_i2c_port; struct dcb_output; #ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT -struct nouveau_backlight; +struct nouveau_backlight { + struct backlight_device *dev; + + struct drm_edp_backlight_info edp_info; + bool uses_dpcd : 1; + + int id; +}; #endif #define nouveau_conn_atom(p) \ diff --git a/drivers/gpu/drm/nouveau/nouveau_encoder.h b/drivers/gpu/drm/nouveau/nouveau_encoder.h index 1ffcc0a491fd..77c2fed76e8b 100644 --- a/drivers/gpu/drm/nouveau/nouveau_encoder.h +++ b/drivers/gpu/drm/nouveau/nouveau_encoder.h @@ -30,6 +30,7 @@ #include #include +#include #include #include "dispnv04/disp.h" struct nv50_head_atom; -- 2.29.2 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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 A7EF2C433DB for ; Mon, 8 Feb 2021 23:39:52 +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 719DD64D9D for ; Mon, 8 Feb 2021 23:39:52 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 719DD64D9D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=nouveau-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 67B6D6EA55; Mon, 8 Feb 2021 23:39:50 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by gabe.freedesktop.org (Postfix) with ESMTPS id 979106EA46 for ; Mon, 8 Feb 2021 23:39:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1612827587; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=gE9U5BslqCar72kVEWsclaxt7xAzUfHLFCjpahn4dKk=; b=Ihlgd+TRzBePWAccvT/a44DwMsdo9wg68s+M1GK3gD3jj0P7fjkIm3jH+zuZw9kJL390+s k9XpCIz6i8aYNqgUrIoCk2pkFgjkekLWZlikdkMEmxUdII1wXIuzrSTEES93ZCezfbJLes 5FBSNx+N7AzgSynBBmWO0NeyN38zjw8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-434-xGYuc_3bN2eggmu2PhXpnA-1; Mon, 08 Feb 2021 18:39:43 -0500 X-MC-Unique: xGYuc_3bN2eggmu2PhXpnA-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0FDF280402C; Mon, 8 Feb 2021 23:39:42 +0000 (UTC) Received: from Whitewolf.redhat.com (ovpn-114-219.rdu2.redhat.com [10.10.114.219]) by smtp.corp.redhat.com (Postfix) with ESMTP id BDC1B608DB; Mon, 8 Feb 2021 23:39:40 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Date: Mon, 8 Feb 2021 18:39:01 -0500 Message-Id: <20210208233902.1289693-12-lyude@redhat.com> In-Reply-To: <20210208233902.1289693-1-lyude@redhat.com> References: <20210208233902.1289693-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Subject: [Nouveau] [RFC v4 11/11] drm/nouveau/kms/nv50-: Add basic DPCD backlight support for nouveau X-BeenThere: nouveau@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Nouveau development list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jani Nikula , Pankaj Bharadiya , David Airlie , open list , greg.depoire@gmail.com, Ben Skeggs , Daniel Vetter , Dave Airlie Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: nouveau-bounces@lists.freedesktop.org Sender: "Nouveau" VGhpcyBhZGRzIHN1cHBvcnQgZm9yIGNvbnRyb2xsaW5nIHBhbmVsIGJhY2tsaWdodHMgb3ZlciBl RFAgdXNpbmcgVkVTQSdzCnN0YW5kYXJkIGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4gTHVj a2lseSwgTnZpZGlhIHdhcyBjb29sIGVub3VnaCB0bwpuZXZlciBjb21lIHVwIHdpdGggdGhlaXIg b3duIHByb3ByaWV0YXJ5IGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZSAoYXQKbGVhc3QsIG5v dCBhbnkgdGhhdCBJIG9yIHRoZSBsYXB0b3AgbWFudWZhY3R1cmVycyBJJ3ZlIHRhbGtlZCB0byBh cmUgYXdhcmUKb2YpLCBzbyB0aGlzIHNob3VsZCB3b3JrIGZvciBhbnkgbGFwdG9wIHBhbmVscyB3 aGljaCBzdXBwb3J0IHRoZSBWRVNBCmJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4KCk5vdGUg dGhhdCB3ZSBkb24ndCB5ZXQgcHJvdmlkZSB0aGUgcGFuZWwgYmFja2xpZ2h0IGZyZXF1ZW5jeSB0 byB0aGUgRFJNIERQCmJhY2tsaWdodCBoZWxwZXJzLiBUaGlzIHNob3VsZCBiZSBmaW5lIGZvciB0 aGUgdGltZSBiZWluZywgc2luY2UgaXQncyBub3QKcmVxdWlyZWQgdG8gZ2V0IGJhc2ljIGJhY2ts aWdodCBjb250cm9scyB3b3JraW5nLgoKRm9yIHJlZmVyZW5jZTogdGhlcmUncyBzb21lIG1lbnRp b25zIG9mIFBXTSBiYWNrbGlnaHQgdmFsdWVzIGluCm5vdXZlYXVfcmVnLmgsIGJ1dCBJJ20gbm90 IHN1cmUgdGhlc2UgYXJlIHRoZSB2YWx1ZXMgd2Ugd291bGQgd2FudCB0byB1c2UuCklmIHdlIGZp Z3VyZSBvdXQgaG93IHRvIGdldCB0aGlzIGluZm9ybWF0aW9uIGluIHRoZSBmdXR1cmUsIHdlJ2xs IGhhdmUgdGhlCmJlbmVmaXQgb2YgbW9yZSBncmFudWxhciBiYWNrbGlnaHQgY29udHJvbC4KClNp Z25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhhdC5jb20+CkNjOiBKYW5pIE5pa3Vs YSA8amFuaS5uaWt1bGFAaW50ZWwuY29tPgpDYzogRGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwu Y29tPgpDYzogZ3JlZy5kZXBvaXJlQGdtYWlsLmNvbQotLS0KIGRyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L2Rpc3BudjUwL2Rpc3AuYyAgICAgfCAgMjggKysrKwogZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbm91dmVhdV9iYWNrbGlnaHQuYyB8IDE2NiArKysrKysrKysrKysrKysrKystLQogZHJpdmVy cy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaCB8ICAgOSArLQogZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggICB8ICAgMSArCiA0IGZpbGVzIGNoYW5n ZWQsIDE4NiBpbnNlcnRpb25zKCspLCAxOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91 dmVhdS9kaXNwbnY1MC9kaXNwLmMKaW5kZXggMTk2NjEyYWRkZmQ2Li40YTE4MTliMDIwODQgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMKQEAgLTMxLDYgKzMxLDcgQEAK ICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2hkbWkuaD4K ICNpbmNsdWRlIDxsaW51eC9jb21wb25lbnQuaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4K IAogI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNf aGVscGVyLmg+CkBAIC0xNjQ3LDE1ICsxNjQ4LDMwIEBAIG52NTBfc29yX3VwZGF0ZShzdHJ1Y3Qg bm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLCB1OCBoZWFkLAogCWNvcmUtPmZ1bmMtPnNvci0+ Y3RybChjb3JlLCBudl9lbmNvZGVyLT5vciwgbnZfZW5jb2Rlci0+Y3RybCwgYXN5aCk7CiB9CiAK Ky8qIFRPRE86IFNob3VsZCB3ZSBleHRlbmQgdGhpcyB0byBQV00tb25seSBiYWNrbGlnaHRzPwor ICogQXMgd2VsbCwgc2hvdWxkIHdlIGFkZCBhIERSTSBoZWxwZXIgZm9yIHdhaXRpbmcgZm9yIHRo ZSBiYWNrbGlnaHQgdG8gYWNrbm93bGVkZ2UKKyAqIHRoZSBwYW5lbCBiYWNrbGlnaHQgaGFzIGJl ZW4gc2h1dCBvZmY/IEludGVsIGRvZXNuJ3Qgc2VlbSB0byBkbyB0aGlzLCBhbmQgdXNlcyBhCisg KiBmaXhlZCB0aW1lIGRlbGF5IGZyb20gdGhlIHZiaW9z4oCmCisgKi8KIHN0YXRpYyB2b2lkCiBu djUwX3Nvcl9hdG9taWNfZGlzYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIHsKIAlzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpu dl9lbmNvZGVyID0gbm91dmVhdV9lbmNvZGVyKGVuY29kZXIpOworCXN0cnVjdCBub3V2ZWF1X2Ry bSAqZHJtID0gbm91dmVhdV9kcm0obnZfZW5jb2Rlci0+YmFzZS5iYXNlLmRldik7CiAJc3RydWN0 IG5vdXZlYXVfY3J0YyAqbnZfY3J0YyA9IG5vdXZlYXVfY3J0Yyhudl9lbmNvZGVyLT5jcnRjKTsK IAlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG52NTBfb3V0cF9nZXRf b2xkX2Nvbm5lY3RvcihzdGF0ZSwgbnZfZW5jb2Rlcik7CisJc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0ICpiYWNrbGlnaHQgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKIAlzdHJ1Y3QgZHJtX2Rw X2F1eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCWludCByZXQ7CiAJdTggcHdyOwogCisJ aWYgKGJhY2tsaWdodCAmJiBiYWNrbGlnaHQtPnVzZXNfZHBjZCkgeworCQlyZXQgPSBkcm1fZWRw X2JhY2tsaWdodF9kaXNhYmxlKGF1eCwgJmJhY2tsaWdodC0+ZWRwX2luZm8pOworCQlpZiAocmV0 IDwgMCkKKwkJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byBkaXNhYmxlIGJhY2tsaWdodCBvbiBb Q09OTkVDVE9SOiVkOiVzXTogJWRcbiIsCisJCQkJIG52X2Nvbm5lY3Rvci0+YmFzZS5iYXNlLmlk LCBudl9jb25uZWN0b3ItPmJhc2UubmFtZSwgcmV0KTsKKwl9CisKIAlpZiAobnZfZW5jb2Rlci0+ ZGNiLT50eXBlID09IERDQl9PVVRQVVRfRFApIHsKIAkJaW50IHJldCA9IGRybV9kcF9kcGNkX3Jl YWRiKGF1eCwgRFBfU0VUX1BPV0VSLCAmcHdyKTsKIApAQCAtMTY5NCw2ICsxNzEwLDkgQEAgbnY1 MF9zb3JfYXRvbWljX2VuYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGEKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZW5jb2Rlci0+ ZGV2OwogCXN0cnVjdCBub3V2ZWF1X2RybSAqZHJtID0gbm91dmVhdV9kcm0oZGV2KTsKIAlzdHJ1 Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvcjsKKyNpZmRlZiBDT05GSUdfRFJNX05P VVZFQVVfQkFDS0xJR0hUCisJc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0ICpiYWNrbGlnaHQ7Cisj ZW5kaWYKIAlzdHJ1Y3QgbnZiaW9zICpiaW9zID0gJmRybS0+dmJpb3M7CiAJYm9vbCBoZGEgPSBm YWxzZTsKIAl1OCBwcm90byA9IE5WNTA3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfQ1VTVE9N OwpAQCAtMTc2OCw2ICsxNzg3LDE0IEBAIG52NTBfc29yX2F0b21pY19lbmFibGUoc3RydWN0IGRy bV9lbmNvZGVyICplbmNvZGVyLCBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhCiAJCQlwcm90 byA9IE5WODg3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfRFBfQjsKIAogCQludjUwX2F1ZGlv X2VuYWJsZShlbmNvZGVyLCBudl9jcnRjLCBudl9jb25uZWN0b3IsIHN0YXRlLCBtb2RlKTsKKwor I2lmZGVmIENPTkZJR19EUk1fTk9VVkVBVV9CQUNLTElHSFQKKwkJYmFja2xpZ2h0ID0gbnZfY29u bmVjdG9yLT5iYWNrbGlnaHQ7CisJCWlmIChiYWNrbGlnaHQgJiYgYmFja2xpZ2h0LT51c2VzX2Rw Y2QpCisJCQlkcm1fZWRwX2JhY2tsaWdodF9lbmFibGUoJm52X2Nvbm5lY3Rvci0+YXV4LCAmYmFj a2xpZ2h0LT5lZHBfaW5mbywKKwkJCQkJCSAodTE2KWJhY2tsaWdodC0+ZGV2LT5wcm9wcy5icmln aHRuZXNzKTsKKyNlbmRpZgorCiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCUJVRygpOwpAQCAtMjI5 Myw2ICsyMzIwLDcgQEAgbnY1MF9kaXNwX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUpCiAJbnY1MF9jcmNfYXRvbWljX3N0YXJ0X3JlcG9ydGluZyhzdGF0 ZSk7CiAJaWYgKCFmbHVzaGVkKQogCQludjUwX2NyY19hdG9taWNfcmVsZWFzZV9ub3RpZmllcl9j b250ZXh0cyhzdGF0ZSk7CisKIAlkcm1fYXRvbWljX2hlbHBlcl9jb21taXRfaHdfZG9uZShzdGF0 ZSk7CiAJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiAJZHJt X2F0b21pY19oZWxwZXJfY29tbWl0X2NsZWFudXBfZG9uZShzdGF0ZSk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5jIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbm91dmVhdV9iYWNrbGlnaHQuYwppbmRleCA0MmI0OThlN2UyYmYuLmExMTgx MWI1ZTYzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9iYWNr bGlnaHQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5j CkBAIC00MiwxMSArNDIsNiBAQAogc3RhdGljIHN0cnVjdCBpZGEgYmxfaWRhOwogI2RlZmluZSBC TF9OQU1FX1NJWkUgMTUgLy8gMTIgZm9yIG5hbWUgKyAyIGZvciBkaWdpdHMgKyAxIGZvciAnXDAn CiAKLXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCB7Ci0Jc3RydWN0IGJhY2tsaWdodF9kZXZpY2Ug KmRldjsKLQlpbnQgaWQ7Ci19OwotCiBzdGF0aWMgYm9vbAogbm91dmVhdV9nZXRfYmFja2xpZ2h0 X25hbWUoY2hhciBiYWNrbGlnaHRfbmFtZVtCTF9OQU1FX1NJWkVdLAogCQkJICAgc3RydWN0IG5v dXZlYXVfYmFja2xpZ2h0ICpibCkKQEAgLTE0Nyw2ICsxNDIsOTggQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCBiYWNrbGlnaHRfb3BzIG52NTBfYmxfb3BzID0gewogCS51cGRhdGVfc3RhdHVzID0gbnY1 MF9zZXRfaW50ZW5zaXR5LAogfTsKIAorLyoKKyAqIGVEUCBicmlnaHRuZXNzIGNhbGxiYWNrcyBu ZWVkIHRvIGhhcHBlbiB1bmRlciBsb2NrLCBzaW5jZSB3ZSBuZWVkIHRvCisgKiBlbmFibGUvZGlz YWJsZSB0aGUgYmFja2xpZ2h0IG91cnNlbHZlcyBmb3IgbW9kZXNldHMKKyAqLworc3RhdGljIGlu dAorbnY1MF9lZHBfZ2V0X2JyaWdodG5lc3Moc3RydWN0IGJhY2tsaWdodF9kZXZpY2UgKmJkKQor eworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSBkZXZfZ2V0X2RydmRhdGEoYmQt PmRldi5wYXJlbnQpOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmRldjsK KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CisJc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4 IGN0eDsKKwlpbnQgcmV0ID0gMDsKKworCWRybV9tb2Rlc2V0X2FjcXVpcmVfaW5pdCgmY3R4LCAw KTsKKworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5j b25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQlnb3RvIGRl YWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9IGNvbm5l Y3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJldCA9IGRy bV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExL KQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJ aWYgKCFjcnRjLT5zdGF0ZS0+YWN0aXZlKQorCQlnb3RvIG91dDsKKworCXJldCA9IGJkLT5wcm9w cy5icmlnaHRuZXNzOworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJt X21vZGVzZXRfYWNxdWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlk cm1fbW9kZXNldF9iYWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBpbnQK K252NTBfZWRwX3NldF9icmlnaHRuZXNzKHN0cnVjdCBiYWNrbGlnaHRfZGV2aWNlICpiZCkKK3sK KwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gZGV2X2dldF9kcnZkYXRhKGJkLT5k ZXYucGFyZW50KTsKKwlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG5v dXZlYXVfY29ubmVjdG9yKGNvbm5lY3Rvcik7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNv bm5lY3Rvci0+ZGV2OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlzdHJ1Y3QgZHJtX2RwX2F1 eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCAq bnZfYmwgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKKwlzdHJ1Y3QgZHJtX21vZGVzZXRfYWNx dWlyZV9jdHggY3R4OworCWludCByZXQgPSAwOworCisJZHJtX21vZGVzZXRfYWNxdWlyZV9pbml0 KCZjdHgsIDApOworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2Nv bmZpZy5jb25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQln b3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9 IGNvbm5lY3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJl dCA9IGRybV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1F REVBRExLKQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0 OworCisJaWYgKGNydGMtPnN0YXRlLT5hY3RpdmUpCisJCXJldCA9IGRybV9lZHBfYmFja2xpZ2h0 X3NldF9sZXZlbChhdXgsICZudl9ibC0+ZWRwX2luZm8sIGJkLT5wcm9wcy5icmlnaHRuZXNzKTsK Kworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJtX21vZGVzZXRfYWNx dWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlkcm1fbW9kZXNldF9i YWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmFj a2xpZ2h0X29wcyBudjUwX2VkcF9ibF9vcHMgPSB7CisJLmdldF9icmlnaHRuZXNzID0gbnY1MF9l ZHBfZ2V0X2JyaWdodG5lc3MsCisJLnVwZGF0ZV9zdGF0dXMgPSBudjUwX2VkcF9zZXRfYnJpZ2h0 bmVzcywKK307CisKIHN0YXRpYyBpbnQKIG52YTNfZ2V0X2ludGVuc2l0eShzdHJ1Y3QgYmFja2xp Z2h0X2RldmljZSAqYmQpCiB7CkBAIC0xOTMsOCArMjgwLDEzIEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgYmFja2xpZ2h0X29wcyBudmEzX2JsX29wcyA9IHsKIAkudXBkYXRlX3N0YXR1cyA9IG52YTNf c2V0X2ludGVuc2l0eSwKIH07CiAKKy8qIEZJWE1FOiBwZXJmb3JtIGJhY2tsaWdodCBwcm9iaW5n IGZvciBlRFAgX2JlZm9yZV8gdGhpcywgdGhpcyBvbmx5IGdldHMgY2FsbGVkIGFmdGVyIGNvbm5l Y3RvcgorICogcmVnaXN0cmF0aW9uIHdoaWNoIGhhcHBlbnMgYWZ0ZXIgdGhlIGluaXRpYWwgbW9k ZXNldAorICovCiBzdGF0aWMgaW50Ci1udjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2VuY29kZXIgKm52X2VuY29kZXIsCitudjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2JhY2tsaWdodCAqYmwsCisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm4s CisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLAogCQkgICAgc3RydWN0 IGJhY2tsaWdodF9wcm9wZXJ0aWVzICpwcm9wcywKIAkJICAgIGNvbnN0IHN0cnVjdCBiYWNrbGln aHRfb3BzICoqb3BzKQogewpAQCAtMjA0LDYgKzI5Niw0MSBAQCBudjUwX2JhY2tsaWdodF9pbml0 KHN0cnVjdCBub3V2ZWF1X2VuY29kZXIgKm52X2VuY29kZXIsCiAJaWYgKCFudmlmX3JkMzIoZGV2 aWNlLCBOVjUwX1BESVNQX1NPUl9QV01fQ1RMKGZmcyhudl9lbmNvZGVyLT5kY2ItPm9yKSAtIDEp KSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKKwlpZiAobnZfY29ubi0+dHlwZSA9PSBEQ0JfQ09OTkVD VE9SX2VEUCkgeworCQlpbnQgcmV0OworCQl1MTYgY3VycmVudF9sZXZlbDsKKwkJdTggZWRwX2Rw Y2RbRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFXTsKKwkJdTggY3VycmVudF9tb2RlOworCisJCXJl dCA9IGRybV9kcF9kcGNkX3JlYWQoJm52X2Nvbm4tPmF1eCwgRFBfRURQX0RQQ0RfUkVWLCBlZHBf ZHBjZCwKKwkJCQkgICAgICAgRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFKTsKKwkJaWYgKHJldCA8 IDApCisJCQlyZXR1cm4gcmV0OworCisJCWlmIChkcm1fZWRwX2JhY2tsaWdodF9zdXBwb3J0ZWQo ZWRwX2RwY2QpKSB7CisJCQlOVl9ERUJVRyhkcm0sICJEUENEIGJhY2tsaWdodCBjb250cm9scyBz dXBwb3J0ZWQgb24gJXNcbiIsCisJCQkJIG52X2Nvbm4tPmJhc2UubmFtZSk7CisKKwkJCXJldCA9 IGRybV9lZHBfYmFja2xpZ2h0X2luaXQoJm52X2Nvbm4tPmF1eCwgJmJsLT5lZHBfaW5mbywgMCwg ZWRwX2RwY2QsCisJCQkJCQkgICAgICZjdXJyZW50X2xldmVsLCAmY3VycmVudF9tb2RlKTsKKwkJ CWlmIChyZXQgPCAwKQorCQkJCXJldHVybiByZXQ7CisKKwkJCXJldCA9IGRybV9lZHBfYmFja2xp Z2h0X2VuYWJsZSgmbnZfY29ubi0+YXV4LCAmYmwtPmVkcF9pbmZvLCBjdXJyZW50X2xldmVsKTsK KwkJCWlmIChyZXQgPCAwKSB7CisJCQkJTlZfRVJST1IoZHJtLCAiRmFpbGVkIHRvIGVuYWJsZSBi YWNrbGlnaHQgb24gJXM6ICVkXG4iLAorCQkJCQkgbnZfY29ubi0+YmFzZS5uYW1lLCByZXQpOwor CQkJCXJldHVybiByZXQ7CisJCQl9CisKKwkJCSpvcHMgPSAmbnY1MF9lZHBfYmxfb3BzOworCQkJ cHJvcHMtPmJyaWdodG5lc3MgPSBjdXJyZW50X2xldmVsOworCQkJcHJvcHMtPm1heF9icmlnaHRu ZXNzID0gYmwtPmVkcF9pbmZvLm1heDsKKwkJCWJsLT51c2VzX2RwY2QgPSB0cnVlOworCQkJcmV0 dXJuIDA7CisJCX0KKwl9CisKIAlpZiAoZHJtLT5jbGllbnQuZGV2aWNlLmluZm8uY2hpcHNldCA8 PSAweGEwIHx8CiAJICAgIGRybS0+Y2xpZW50LmRldmljZS5pbmZvLmNoaXBzZXQgPT0gMHhhYSB8 fAogCSAgICBkcm0tPmNsaWVudC5kZXZpY2UuaW5mby5jaGlwc2V0ID09IDB4YWMpCkBAIC0yNDMs NiArMzcwLDEwIEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKIAlpZiAoIW52X2VuY29kZXIpCiAJCXJldHVybiAwOwogCisJYmwgPSBremFs bG9jKHNpemVvZigqYmwpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJsKQorCQlyZXR1cm4gLUVOT01F TTsKKwogCXN3aXRjaCAoZGV2aWNlLT5pbmZvLmZhbWlseSkgewogCWNhc2UgTlZfREVWSUNFX0lO Rk9fVjBfQ1VSSUU6CiAJCXJldCA9IG52NDBfYmFja2xpZ2h0X2luaXQobnZfZW5jb2RlciwgJnBy b3BzLCAmb3BzKTsKQEAgLTI1NSwyMCArMzg2LDE5IEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAljYXNlIE5WX0RFVklDRV9JTkZPX1Yw X1ZPTFRBOgogCWNhc2UgTlZfREVWSUNFX0lORk9fVjBfVFVSSU5HOgogCWNhc2UgTlZfREVWSUNF X0lORk9fVjBfQU1QRVJFOiAvL1hYWDogbm90IGNvbmZpcm1lZAotCQlyZXQgPSBudjUwX2JhY2ts aWdodF9pbml0KG52X2VuY29kZXIsICZwcm9wcywgJm9wcyk7CisJCXJldCA9IG52NTBfYmFja2xp Z2h0X2luaXQoYmwsIG5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciksCisJCQkJCSAgbnZfZW5j b2RlciwgJnByb3BzLCAmb3BzKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcmV0dXJuIDA7CisJ CXJldCA9IDA7CisJCWdvdG8gZmFpbF9hbGxvYzsKIAl9CiAKLQlpZiAocmV0ID09IC1FTk9ERVYp Ci0JCXJldHVybiAwOwotCWVsc2UgaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCWJsID0ga3ph bGxvYyhzaXplb2YoKmJsKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFibCkKLQkJcmV0dXJuIC1FTk9N RU07CisJaWYgKHJldCkgeworCQlpZiAocmV0ID09IC1FTk9ERVYpCisJCQlyZXQgPSAwOworCQln b3RvIGZhaWxfYWxsb2M7CisJfQogCiAJaWYgKCFub3V2ZWF1X2dldF9iYWNrbGlnaHRfbmFtZShi YWNrbGlnaHRfbmFtZSwgYmwpKSB7CiAJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byByZXRyaWV2 ZSBhIHVuaXF1ZSBuYW1lIGZvciB0aGUgYmFja2xpZ2h0IGludGVyZmFjZVxuIik7CkBAIC0yODUs NyArNDE1LDkgQEAgbm91dmVhdV9iYWNrbGlnaHRfaW5pdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yKQogCX0KIAogCW5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciktPmJhY2tsaWdo dCA9IGJsOwotCWJsLT5kZXYtPnByb3BzLmJyaWdodG5lc3MgPSBibC0+ZGV2LT5vcHMtPmdldF9i cmlnaHRuZXNzKGJsLT5kZXYpOworCWlmICghYmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcykKKwkJ YmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcyA9CisJCQlibC0+ZGV2LT5vcHMtPmdldF9icmlnaHRu ZXNzKGJsLT5kZXYpOwogCWJhY2tsaWdodF91cGRhdGVfc3RhdHVzKGJsLT5kZXYpOwogCiAJcmV0 dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Nvbm5l Y3Rvci5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAppbmRl eCBkMGI4NTljNGE4MGUuLjQwZjkwZTM1MzU0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVh dS9ub3V2ZWF1X2Nvbm5lY3Rvci5oCkBAIC00Niw3ICs0NiwxNCBAQCBzdHJ1Y3QgbnZrbV9pMmNf cG9ydDsKIHN0cnVjdCBkY2Jfb3V0cHV0OwogCiAjaWZkZWYgQ09ORklHX0RSTV9OT1VWRUFVX0JB Q0tMSUdIVAotc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0Oworc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0IHsKKwlzdHJ1Y3QgYmFja2xpZ2h0X2RldmljZSAqZGV2OworCisJc3RydWN0IGRybV9lZHBf YmFja2xpZ2h0X2luZm8gZWRwX2luZm87CisJYm9vbCB1c2VzX2RwY2QgOiAxOworCisJaW50IGlk OworfTsKICNlbmRpZgogCiAjZGVmaW5lIG5vdXZlYXVfY29ubl9hdG9tKHApICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggYi9kcml2ZXJzL2dwdS9kcm0v bm91dmVhdS9ub3V2ZWF1X2VuY29kZXIuaAppbmRleCAxZmZjYzBhNDkxZmQuLjc3YzJmZWQ3NmU4 YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgKQEAgLTMwLDYg KzMwLDcgQEAKICNpbmNsdWRlIDxzdWJkZXYvYmlvcy9kY2IuaD4KIAogI2luY2x1ZGUgPGRybS9k cm1fZW5jb2Rlcl9zbGF2ZS5oPgorI2luY2x1ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+CiAjaW5j bHVkZSA8ZHJtL2RybV9kcF9tc3RfaGVscGVyLmg+CiAjaW5jbHVkZSAiZGlzcG52MDQvZGlzcC5o Igogc3RydWN0IG52NTBfaGVhZF9hdG9tOwotLSAKMi4yOS4yCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpOb3V2ZWF1IG1haWxpbmcgbGlzdApOb3V2ZWF1 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL25vdXZlYXUK 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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 B93A6C43381 for ; Mon, 8 Feb 2021 23:39:54 +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 8B1D264E7D for ; Mon, 8 Feb 2021 23:39:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8B1D264E7D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com 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 5140E6EA57; Mon, 8 Feb 2021 23:39:51 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by gabe.freedesktop.org (Postfix) with ESMTPS id 543056EA4D for ; Mon, 8 Feb 2021 23:39:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1612827587; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=gE9U5BslqCar72kVEWsclaxt7xAzUfHLFCjpahn4dKk=; b=Ihlgd+TRzBePWAccvT/a44DwMsdo9wg68s+M1GK3gD3jj0P7fjkIm3jH+zuZw9kJL390+s k9XpCIz6i8aYNqgUrIoCk2pkFgjkekLWZlikdkMEmxUdII1wXIuzrSTEES93ZCezfbJLes 5FBSNx+N7AzgSynBBmWO0NeyN38zjw8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-434-xGYuc_3bN2eggmu2PhXpnA-1; Mon, 08 Feb 2021 18:39:43 -0500 X-MC-Unique: xGYuc_3bN2eggmu2PhXpnA-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0FDF280402C; Mon, 8 Feb 2021 23:39:42 +0000 (UTC) Received: from Whitewolf.redhat.com (ovpn-114-219.rdu2.redhat.com [10.10.114.219]) by smtp.corp.redhat.com (Postfix) with ESMTP id BDC1B608DB; Mon, 8 Feb 2021 23:39:40 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Subject: [RFC v4 11/11] drm/nouveau/kms/nv50-: Add basic DPCD backlight support for nouveau Date: Mon, 8 Feb 2021 18:39:01 -0500 Message-Id: <20210208233902.1289693-12-lyude@redhat.com> In-Reply-To: <20210208233902.1289693-1-lyude@redhat.com> References: <20210208233902.1289693-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 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: Jani Nikula , Pankaj Bharadiya , David Airlie , open list , greg.depoire@gmail.com, Ben Skeggs , Dave Airlie , James Jones Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBhZGRzIHN1cHBvcnQgZm9yIGNvbnRyb2xsaW5nIHBhbmVsIGJhY2tsaWdodHMgb3ZlciBl RFAgdXNpbmcgVkVTQSdzCnN0YW5kYXJkIGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4gTHVj a2lseSwgTnZpZGlhIHdhcyBjb29sIGVub3VnaCB0bwpuZXZlciBjb21lIHVwIHdpdGggdGhlaXIg b3duIHByb3ByaWV0YXJ5IGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZSAoYXQKbGVhc3QsIG5v dCBhbnkgdGhhdCBJIG9yIHRoZSBsYXB0b3AgbWFudWZhY3R1cmVycyBJJ3ZlIHRhbGtlZCB0byBh cmUgYXdhcmUKb2YpLCBzbyB0aGlzIHNob3VsZCB3b3JrIGZvciBhbnkgbGFwdG9wIHBhbmVscyB3 aGljaCBzdXBwb3J0IHRoZSBWRVNBCmJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4KCk5vdGUg dGhhdCB3ZSBkb24ndCB5ZXQgcHJvdmlkZSB0aGUgcGFuZWwgYmFja2xpZ2h0IGZyZXF1ZW5jeSB0 byB0aGUgRFJNIERQCmJhY2tsaWdodCBoZWxwZXJzLiBUaGlzIHNob3VsZCBiZSBmaW5lIGZvciB0 aGUgdGltZSBiZWluZywgc2luY2UgaXQncyBub3QKcmVxdWlyZWQgdG8gZ2V0IGJhc2ljIGJhY2ts aWdodCBjb250cm9scyB3b3JraW5nLgoKRm9yIHJlZmVyZW5jZTogdGhlcmUncyBzb21lIG1lbnRp b25zIG9mIFBXTSBiYWNrbGlnaHQgdmFsdWVzIGluCm5vdXZlYXVfcmVnLmgsIGJ1dCBJJ20gbm90 IHN1cmUgdGhlc2UgYXJlIHRoZSB2YWx1ZXMgd2Ugd291bGQgd2FudCB0byB1c2UuCklmIHdlIGZp Z3VyZSBvdXQgaG93IHRvIGdldCB0aGlzIGluZm9ybWF0aW9uIGluIHRoZSBmdXR1cmUsIHdlJ2xs IGhhdmUgdGhlCmJlbmVmaXQgb2YgbW9yZSBncmFudWxhciBiYWNrbGlnaHQgY29udHJvbC4KClNp Z25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhhdC5jb20+CkNjOiBKYW5pIE5pa3Vs YSA8amFuaS5uaWt1bGFAaW50ZWwuY29tPgpDYzogRGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwu Y29tPgpDYzogZ3JlZy5kZXBvaXJlQGdtYWlsLmNvbQotLS0KIGRyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L2Rpc3BudjUwL2Rpc3AuYyAgICAgfCAgMjggKysrKwogZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbm91dmVhdV9iYWNrbGlnaHQuYyB8IDE2NiArKysrKysrKysrKysrKysrKystLQogZHJpdmVy cy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaCB8ICAgOSArLQogZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggICB8ICAgMSArCiA0IGZpbGVzIGNoYW5n ZWQsIDE4NiBpbnNlcnRpb25zKCspLCAxOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91 dmVhdS9kaXNwbnY1MC9kaXNwLmMKaW5kZXggMTk2NjEyYWRkZmQ2Li40YTE4MTliMDIwODQgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMKQEAgLTMxLDYgKzMxLDcgQEAK ICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2hkbWkuaD4K ICNpbmNsdWRlIDxsaW51eC9jb21wb25lbnQuaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4K IAogI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNf aGVscGVyLmg+CkBAIC0xNjQ3LDE1ICsxNjQ4LDMwIEBAIG52NTBfc29yX3VwZGF0ZShzdHJ1Y3Qg bm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLCB1OCBoZWFkLAogCWNvcmUtPmZ1bmMtPnNvci0+ Y3RybChjb3JlLCBudl9lbmNvZGVyLT5vciwgbnZfZW5jb2Rlci0+Y3RybCwgYXN5aCk7CiB9CiAK Ky8qIFRPRE86IFNob3VsZCB3ZSBleHRlbmQgdGhpcyB0byBQV00tb25seSBiYWNrbGlnaHRzPwor ICogQXMgd2VsbCwgc2hvdWxkIHdlIGFkZCBhIERSTSBoZWxwZXIgZm9yIHdhaXRpbmcgZm9yIHRo ZSBiYWNrbGlnaHQgdG8gYWNrbm93bGVkZ2UKKyAqIHRoZSBwYW5lbCBiYWNrbGlnaHQgaGFzIGJl ZW4gc2h1dCBvZmY/IEludGVsIGRvZXNuJ3Qgc2VlbSB0byBkbyB0aGlzLCBhbmQgdXNlcyBhCisg KiBmaXhlZCB0aW1lIGRlbGF5IGZyb20gdGhlIHZiaW9z4oCmCisgKi8KIHN0YXRpYyB2b2lkCiBu djUwX3Nvcl9hdG9taWNfZGlzYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIHsKIAlzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpu dl9lbmNvZGVyID0gbm91dmVhdV9lbmNvZGVyKGVuY29kZXIpOworCXN0cnVjdCBub3V2ZWF1X2Ry bSAqZHJtID0gbm91dmVhdV9kcm0obnZfZW5jb2Rlci0+YmFzZS5iYXNlLmRldik7CiAJc3RydWN0 IG5vdXZlYXVfY3J0YyAqbnZfY3J0YyA9IG5vdXZlYXVfY3J0Yyhudl9lbmNvZGVyLT5jcnRjKTsK IAlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG52NTBfb3V0cF9nZXRf b2xkX2Nvbm5lY3RvcihzdGF0ZSwgbnZfZW5jb2Rlcik7CisJc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0ICpiYWNrbGlnaHQgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKIAlzdHJ1Y3QgZHJtX2Rw X2F1eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCWludCByZXQ7CiAJdTggcHdyOwogCisJ aWYgKGJhY2tsaWdodCAmJiBiYWNrbGlnaHQtPnVzZXNfZHBjZCkgeworCQlyZXQgPSBkcm1fZWRw X2JhY2tsaWdodF9kaXNhYmxlKGF1eCwgJmJhY2tsaWdodC0+ZWRwX2luZm8pOworCQlpZiAocmV0 IDwgMCkKKwkJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byBkaXNhYmxlIGJhY2tsaWdodCBvbiBb Q09OTkVDVE9SOiVkOiVzXTogJWRcbiIsCisJCQkJIG52X2Nvbm5lY3Rvci0+YmFzZS5iYXNlLmlk LCBudl9jb25uZWN0b3ItPmJhc2UubmFtZSwgcmV0KTsKKwl9CisKIAlpZiAobnZfZW5jb2Rlci0+ ZGNiLT50eXBlID09IERDQl9PVVRQVVRfRFApIHsKIAkJaW50IHJldCA9IGRybV9kcF9kcGNkX3Jl YWRiKGF1eCwgRFBfU0VUX1BPV0VSLCAmcHdyKTsKIApAQCAtMTY5NCw2ICsxNzEwLDkgQEAgbnY1 MF9zb3JfYXRvbWljX2VuYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGEKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZW5jb2Rlci0+ ZGV2OwogCXN0cnVjdCBub3V2ZWF1X2RybSAqZHJtID0gbm91dmVhdV9kcm0oZGV2KTsKIAlzdHJ1 Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvcjsKKyNpZmRlZiBDT05GSUdfRFJNX05P VVZFQVVfQkFDS0xJR0hUCisJc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0ICpiYWNrbGlnaHQ7Cisj ZW5kaWYKIAlzdHJ1Y3QgbnZiaW9zICpiaW9zID0gJmRybS0+dmJpb3M7CiAJYm9vbCBoZGEgPSBm YWxzZTsKIAl1OCBwcm90byA9IE5WNTA3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfQ1VTVE9N OwpAQCAtMTc2OCw2ICsxNzg3LDE0IEBAIG52NTBfc29yX2F0b21pY19lbmFibGUoc3RydWN0IGRy bV9lbmNvZGVyICplbmNvZGVyLCBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhCiAJCQlwcm90 byA9IE5WODg3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfRFBfQjsKIAogCQludjUwX2F1ZGlv X2VuYWJsZShlbmNvZGVyLCBudl9jcnRjLCBudl9jb25uZWN0b3IsIHN0YXRlLCBtb2RlKTsKKwor I2lmZGVmIENPTkZJR19EUk1fTk9VVkVBVV9CQUNLTElHSFQKKwkJYmFja2xpZ2h0ID0gbnZfY29u bmVjdG9yLT5iYWNrbGlnaHQ7CisJCWlmIChiYWNrbGlnaHQgJiYgYmFja2xpZ2h0LT51c2VzX2Rw Y2QpCisJCQlkcm1fZWRwX2JhY2tsaWdodF9lbmFibGUoJm52X2Nvbm5lY3Rvci0+YXV4LCAmYmFj a2xpZ2h0LT5lZHBfaW5mbywKKwkJCQkJCSAodTE2KWJhY2tsaWdodC0+ZGV2LT5wcm9wcy5icmln aHRuZXNzKTsKKyNlbmRpZgorCiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCUJVRygpOwpAQCAtMjI5 Myw2ICsyMzIwLDcgQEAgbnY1MF9kaXNwX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUpCiAJbnY1MF9jcmNfYXRvbWljX3N0YXJ0X3JlcG9ydGluZyhzdGF0 ZSk7CiAJaWYgKCFmbHVzaGVkKQogCQludjUwX2NyY19hdG9taWNfcmVsZWFzZV9ub3RpZmllcl9j b250ZXh0cyhzdGF0ZSk7CisKIAlkcm1fYXRvbWljX2hlbHBlcl9jb21taXRfaHdfZG9uZShzdGF0 ZSk7CiAJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiAJZHJt X2F0b21pY19oZWxwZXJfY29tbWl0X2NsZWFudXBfZG9uZShzdGF0ZSk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5jIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbm91dmVhdV9iYWNrbGlnaHQuYwppbmRleCA0MmI0OThlN2UyYmYuLmExMTgx MWI1ZTYzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9iYWNr bGlnaHQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5j CkBAIC00MiwxMSArNDIsNiBAQAogc3RhdGljIHN0cnVjdCBpZGEgYmxfaWRhOwogI2RlZmluZSBC TF9OQU1FX1NJWkUgMTUgLy8gMTIgZm9yIG5hbWUgKyAyIGZvciBkaWdpdHMgKyAxIGZvciAnXDAn CiAKLXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCB7Ci0Jc3RydWN0IGJhY2tsaWdodF9kZXZpY2Ug KmRldjsKLQlpbnQgaWQ7Ci19OwotCiBzdGF0aWMgYm9vbAogbm91dmVhdV9nZXRfYmFja2xpZ2h0 X25hbWUoY2hhciBiYWNrbGlnaHRfbmFtZVtCTF9OQU1FX1NJWkVdLAogCQkJICAgc3RydWN0IG5v dXZlYXVfYmFja2xpZ2h0ICpibCkKQEAgLTE0Nyw2ICsxNDIsOTggQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCBiYWNrbGlnaHRfb3BzIG52NTBfYmxfb3BzID0gewogCS51cGRhdGVfc3RhdHVzID0gbnY1 MF9zZXRfaW50ZW5zaXR5LAogfTsKIAorLyoKKyAqIGVEUCBicmlnaHRuZXNzIGNhbGxiYWNrcyBu ZWVkIHRvIGhhcHBlbiB1bmRlciBsb2NrLCBzaW5jZSB3ZSBuZWVkIHRvCisgKiBlbmFibGUvZGlz YWJsZSB0aGUgYmFja2xpZ2h0IG91cnNlbHZlcyBmb3IgbW9kZXNldHMKKyAqLworc3RhdGljIGlu dAorbnY1MF9lZHBfZ2V0X2JyaWdodG5lc3Moc3RydWN0IGJhY2tsaWdodF9kZXZpY2UgKmJkKQor eworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSBkZXZfZ2V0X2RydmRhdGEoYmQt PmRldi5wYXJlbnQpOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmRldjsK KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CisJc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4 IGN0eDsKKwlpbnQgcmV0ID0gMDsKKworCWRybV9tb2Rlc2V0X2FjcXVpcmVfaW5pdCgmY3R4LCAw KTsKKworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5j b25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQlnb3RvIGRl YWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9IGNvbm5l Y3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJldCA9IGRy bV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExL KQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJ aWYgKCFjcnRjLT5zdGF0ZS0+YWN0aXZlKQorCQlnb3RvIG91dDsKKworCXJldCA9IGJkLT5wcm9w cy5icmlnaHRuZXNzOworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJt X21vZGVzZXRfYWNxdWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlk cm1fbW9kZXNldF9iYWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBpbnQK K252NTBfZWRwX3NldF9icmlnaHRuZXNzKHN0cnVjdCBiYWNrbGlnaHRfZGV2aWNlICpiZCkKK3sK KwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gZGV2X2dldF9kcnZkYXRhKGJkLT5k ZXYucGFyZW50KTsKKwlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG5v dXZlYXVfY29ubmVjdG9yKGNvbm5lY3Rvcik7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNv bm5lY3Rvci0+ZGV2OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlzdHJ1Y3QgZHJtX2RwX2F1 eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCAq bnZfYmwgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKKwlzdHJ1Y3QgZHJtX21vZGVzZXRfYWNx dWlyZV9jdHggY3R4OworCWludCByZXQgPSAwOworCisJZHJtX21vZGVzZXRfYWNxdWlyZV9pbml0 KCZjdHgsIDApOworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2Nv bmZpZy5jb25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQln b3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9 IGNvbm5lY3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJl dCA9IGRybV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1F REVBRExLKQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0 OworCisJaWYgKGNydGMtPnN0YXRlLT5hY3RpdmUpCisJCXJldCA9IGRybV9lZHBfYmFja2xpZ2h0 X3NldF9sZXZlbChhdXgsICZudl9ibC0+ZWRwX2luZm8sIGJkLT5wcm9wcy5icmlnaHRuZXNzKTsK Kworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJtX21vZGVzZXRfYWNx dWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlkcm1fbW9kZXNldF9i YWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmFj a2xpZ2h0X29wcyBudjUwX2VkcF9ibF9vcHMgPSB7CisJLmdldF9icmlnaHRuZXNzID0gbnY1MF9l ZHBfZ2V0X2JyaWdodG5lc3MsCisJLnVwZGF0ZV9zdGF0dXMgPSBudjUwX2VkcF9zZXRfYnJpZ2h0 bmVzcywKK307CisKIHN0YXRpYyBpbnQKIG52YTNfZ2V0X2ludGVuc2l0eShzdHJ1Y3QgYmFja2xp Z2h0X2RldmljZSAqYmQpCiB7CkBAIC0xOTMsOCArMjgwLDEzIEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgYmFja2xpZ2h0X29wcyBudmEzX2JsX29wcyA9IHsKIAkudXBkYXRlX3N0YXR1cyA9IG52YTNf c2V0X2ludGVuc2l0eSwKIH07CiAKKy8qIEZJWE1FOiBwZXJmb3JtIGJhY2tsaWdodCBwcm9iaW5n IGZvciBlRFAgX2JlZm9yZV8gdGhpcywgdGhpcyBvbmx5IGdldHMgY2FsbGVkIGFmdGVyIGNvbm5l Y3RvcgorICogcmVnaXN0cmF0aW9uIHdoaWNoIGhhcHBlbnMgYWZ0ZXIgdGhlIGluaXRpYWwgbW9k ZXNldAorICovCiBzdGF0aWMgaW50Ci1udjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2VuY29kZXIgKm52X2VuY29kZXIsCitudjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2JhY2tsaWdodCAqYmwsCisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm4s CisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLAogCQkgICAgc3RydWN0 IGJhY2tsaWdodF9wcm9wZXJ0aWVzICpwcm9wcywKIAkJICAgIGNvbnN0IHN0cnVjdCBiYWNrbGln aHRfb3BzICoqb3BzKQogewpAQCAtMjA0LDYgKzI5Niw0MSBAQCBudjUwX2JhY2tsaWdodF9pbml0 KHN0cnVjdCBub3V2ZWF1X2VuY29kZXIgKm52X2VuY29kZXIsCiAJaWYgKCFudmlmX3JkMzIoZGV2 aWNlLCBOVjUwX1BESVNQX1NPUl9QV01fQ1RMKGZmcyhudl9lbmNvZGVyLT5kY2ItPm9yKSAtIDEp KSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKKwlpZiAobnZfY29ubi0+dHlwZSA9PSBEQ0JfQ09OTkVD VE9SX2VEUCkgeworCQlpbnQgcmV0OworCQl1MTYgY3VycmVudF9sZXZlbDsKKwkJdTggZWRwX2Rw Y2RbRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFXTsKKwkJdTggY3VycmVudF9tb2RlOworCisJCXJl dCA9IGRybV9kcF9kcGNkX3JlYWQoJm52X2Nvbm4tPmF1eCwgRFBfRURQX0RQQ0RfUkVWLCBlZHBf ZHBjZCwKKwkJCQkgICAgICAgRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFKTsKKwkJaWYgKHJldCA8 IDApCisJCQlyZXR1cm4gcmV0OworCisJCWlmIChkcm1fZWRwX2JhY2tsaWdodF9zdXBwb3J0ZWQo ZWRwX2RwY2QpKSB7CisJCQlOVl9ERUJVRyhkcm0sICJEUENEIGJhY2tsaWdodCBjb250cm9scyBz dXBwb3J0ZWQgb24gJXNcbiIsCisJCQkJIG52X2Nvbm4tPmJhc2UubmFtZSk7CisKKwkJCXJldCA9 IGRybV9lZHBfYmFja2xpZ2h0X2luaXQoJm52X2Nvbm4tPmF1eCwgJmJsLT5lZHBfaW5mbywgMCwg ZWRwX2RwY2QsCisJCQkJCQkgICAgICZjdXJyZW50X2xldmVsLCAmY3VycmVudF9tb2RlKTsKKwkJ CWlmIChyZXQgPCAwKQorCQkJCXJldHVybiByZXQ7CisKKwkJCXJldCA9IGRybV9lZHBfYmFja2xp Z2h0X2VuYWJsZSgmbnZfY29ubi0+YXV4LCAmYmwtPmVkcF9pbmZvLCBjdXJyZW50X2xldmVsKTsK KwkJCWlmIChyZXQgPCAwKSB7CisJCQkJTlZfRVJST1IoZHJtLCAiRmFpbGVkIHRvIGVuYWJsZSBi YWNrbGlnaHQgb24gJXM6ICVkXG4iLAorCQkJCQkgbnZfY29ubi0+YmFzZS5uYW1lLCByZXQpOwor CQkJCXJldHVybiByZXQ7CisJCQl9CisKKwkJCSpvcHMgPSAmbnY1MF9lZHBfYmxfb3BzOworCQkJ cHJvcHMtPmJyaWdodG5lc3MgPSBjdXJyZW50X2xldmVsOworCQkJcHJvcHMtPm1heF9icmlnaHRu ZXNzID0gYmwtPmVkcF9pbmZvLm1heDsKKwkJCWJsLT51c2VzX2RwY2QgPSB0cnVlOworCQkJcmV0 dXJuIDA7CisJCX0KKwl9CisKIAlpZiAoZHJtLT5jbGllbnQuZGV2aWNlLmluZm8uY2hpcHNldCA8 PSAweGEwIHx8CiAJICAgIGRybS0+Y2xpZW50LmRldmljZS5pbmZvLmNoaXBzZXQgPT0gMHhhYSB8 fAogCSAgICBkcm0tPmNsaWVudC5kZXZpY2UuaW5mby5jaGlwc2V0ID09IDB4YWMpCkBAIC0yNDMs NiArMzcwLDEwIEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKIAlpZiAoIW52X2VuY29kZXIpCiAJCXJldHVybiAwOwogCisJYmwgPSBremFs bG9jKHNpemVvZigqYmwpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJsKQorCQlyZXR1cm4gLUVOT01F TTsKKwogCXN3aXRjaCAoZGV2aWNlLT5pbmZvLmZhbWlseSkgewogCWNhc2UgTlZfREVWSUNFX0lO Rk9fVjBfQ1VSSUU6CiAJCXJldCA9IG52NDBfYmFja2xpZ2h0X2luaXQobnZfZW5jb2RlciwgJnBy b3BzLCAmb3BzKTsKQEAgLTI1NSwyMCArMzg2LDE5IEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAljYXNlIE5WX0RFVklDRV9JTkZPX1Yw X1ZPTFRBOgogCWNhc2UgTlZfREVWSUNFX0lORk9fVjBfVFVSSU5HOgogCWNhc2UgTlZfREVWSUNF X0lORk9fVjBfQU1QRVJFOiAvL1hYWDogbm90IGNvbmZpcm1lZAotCQlyZXQgPSBudjUwX2JhY2ts aWdodF9pbml0KG52X2VuY29kZXIsICZwcm9wcywgJm9wcyk7CisJCXJldCA9IG52NTBfYmFja2xp Z2h0X2luaXQoYmwsIG5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciksCisJCQkJCSAgbnZfZW5j b2RlciwgJnByb3BzLCAmb3BzKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcmV0dXJuIDA7CisJ CXJldCA9IDA7CisJCWdvdG8gZmFpbF9hbGxvYzsKIAl9CiAKLQlpZiAocmV0ID09IC1FTk9ERVYp Ci0JCXJldHVybiAwOwotCWVsc2UgaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCWJsID0ga3ph bGxvYyhzaXplb2YoKmJsKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFibCkKLQkJcmV0dXJuIC1FTk9N RU07CisJaWYgKHJldCkgeworCQlpZiAocmV0ID09IC1FTk9ERVYpCisJCQlyZXQgPSAwOworCQln b3RvIGZhaWxfYWxsb2M7CisJfQogCiAJaWYgKCFub3V2ZWF1X2dldF9iYWNrbGlnaHRfbmFtZShi YWNrbGlnaHRfbmFtZSwgYmwpKSB7CiAJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byByZXRyaWV2 ZSBhIHVuaXF1ZSBuYW1lIGZvciB0aGUgYmFja2xpZ2h0IGludGVyZmFjZVxuIik7CkBAIC0yODUs NyArNDE1LDkgQEAgbm91dmVhdV9iYWNrbGlnaHRfaW5pdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yKQogCX0KIAogCW5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciktPmJhY2tsaWdo dCA9IGJsOwotCWJsLT5kZXYtPnByb3BzLmJyaWdodG5lc3MgPSBibC0+ZGV2LT5vcHMtPmdldF9i cmlnaHRuZXNzKGJsLT5kZXYpOworCWlmICghYmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcykKKwkJ YmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcyA9CisJCQlibC0+ZGV2LT5vcHMtPmdldF9icmlnaHRu ZXNzKGJsLT5kZXYpOwogCWJhY2tsaWdodF91cGRhdGVfc3RhdHVzKGJsLT5kZXYpOwogCiAJcmV0 dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Nvbm5l Y3Rvci5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAppbmRl eCBkMGI4NTljNGE4MGUuLjQwZjkwZTM1MzU0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVh dS9ub3V2ZWF1X2Nvbm5lY3Rvci5oCkBAIC00Niw3ICs0NiwxNCBAQCBzdHJ1Y3QgbnZrbV9pMmNf cG9ydDsKIHN0cnVjdCBkY2Jfb3V0cHV0OwogCiAjaWZkZWYgQ09ORklHX0RSTV9OT1VWRUFVX0JB Q0tMSUdIVAotc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0Oworc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0IHsKKwlzdHJ1Y3QgYmFja2xpZ2h0X2RldmljZSAqZGV2OworCisJc3RydWN0IGRybV9lZHBf YmFja2xpZ2h0X2luZm8gZWRwX2luZm87CisJYm9vbCB1c2VzX2RwY2QgOiAxOworCisJaW50IGlk OworfTsKICNlbmRpZgogCiAjZGVmaW5lIG5vdXZlYXVfY29ubl9hdG9tKHApICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggYi9kcml2ZXJzL2dwdS9kcm0v bm91dmVhdS9ub3V2ZWF1X2VuY29kZXIuaAppbmRleCAxZmZjYzBhNDkxZmQuLjc3YzJmZWQ3NmU4 YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgKQEAgLTMwLDYg KzMwLDcgQEAKICNpbmNsdWRlIDxzdWJkZXYvYmlvcy9kY2IuaD4KIAogI2luY2x1ZGUgPGRybS9k cm1fZW5jb2Rlcl9zbGF2ZS5oPgorI2luY2x1ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+CiAjaW5j bHVkZSA8ZHJtL2RybV9kcF9tc3RfaGVscGVyLmg+CiAjaW5jbHVkZSAiZGlzcG52MDQvZGlzcC5o Igogc3RydWN0IG52NTBfaGVhZF9hdG9tOwotLSAKMi4yOS4yCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK 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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 15984C433E9 for ; Mon, 8 Feb 2021 23:39:54 +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 DB28064E7D for ; Mon, 8 Feb 2021 23:39:53 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DB28064E7D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id CC4CE6EA56; Mon, 8 Feb 2021 23:39:50 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9949F6EA4F for ; Mon, 8 Feb 2021 23:39:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1612827587; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=gE9U5BslqCar72kVEWsclaxt7xAzUfHLFCjpahn4dKk=; b=Ihlgd+TRzBePWAccvT/a44DwMsdo9wg68s+M1GK3gD3jj0P7fjkIm3jH+zuZw9kJL390+s k9XpCIz6i8aYNqgUrIoCk2pkFgjkekLWZlikdkMEmxUdII1wXIuzrSTEES93ZCezfbJLes 5FBSNx+N7AzgSynBBmWO0NeyN38zjw8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-434-xGYuc_3bN2eggmu2PhXpnA-1; Mon, 08 Feb 2021 18:39:43 -0500 X-MC-Unique: xGYuc_3bN2eggmu2PhXpnA-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0FDF280402C; Mon, 8 Feb 2021 23:39:42 +0000 (UTC) Received: from Whitewolf.redhat.com (ovpn-114-219.rdu2.redhat.com [10.10.114.219]) by smtp.corp.redhat.com (Postfix) with ESMTP id BDC1B608DB; Mon, 8 Feb 2021 23:39:40 +0000 (UTC) From: Lyude Paul To: dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Date: Mon, 8 Feb 2021 18:39:01 -0500 Message-Id: <20210208233902.1289693-12-lyude@redhat.com> In-Reply-To: <20210208233902.1289693-1-lyude@redhat.com> References: <20210208233902.1289693-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Subject: [Intel-gfx] [RFC v4 11/11] drm/nouveau/kms/nv50-: Add basic DPCD backlight support for nouveau 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: Jani Nikula , David Airlie , open list , greg.depoire@gmail.com, Ben Skeggs , Dave Airlie , James Jones Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" VGhpcyBhZGRzIHN1cHBvcnQgZm9yIGNvbnRyb2xsaW5nIHBhbmVsIGJhY2tsaWdodHMgb3ZlciBl RFAgdXNpbmcgVkVTQSdzCnN0YW5kYXJkIGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4gTHVj a2lseSwgTnZpZGlhIHdhcyBjb29sIGVub3VnaCB0bwpuZXZlciBjb21lIHVwIHdpdGggdGhlaXIg b3duIHByb3ByaWV0YXJ5IGJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZSAoYXQKbGVhc3QsIG5v dCBhbnkgdGhhdCBJIG9yIHRoZSBsYXB0b3AgbWFudWZhY3R1cmVycyBJJ3ZlIHRhbGtlZCB0byBh cmUgYXdhcmUKb2YpLCBzbyB0aGlzIHNob3VsZCB3b3JrIGZvciBhbnkgbGFwdG9wIHBhbmVscyB3 aGljaCBzdXBwb3J0IHRoZSBWRVNBCmJhY2tsaWdodCBjb250cm9sIGludGVyZmFjZS4KCk5vdGUg dGhhdCB3ZSBkb24ndCB5ZXQgcHJvdmlkZSB0aGUgcGFuZWwgYmFja2xpZ2h0IGZyZXF1ZW5jeSB0 byB0aGUgRFJNIERQCmJhY2tsaWdodCBoZWxwZXJzLiBUaGlzIHNob3VsZCBiZSBmaW5lIGZvciB0 aGUgdGltZSBiZWluZywgc2luY2UgaXQncyBub3QKcmVxdWlyZWQgdG8gZ2V0IGJhc2ljIGJhY2ts aWdodCBjb250cm9scyB3b3JraW5nLgoKRm9yIHJlZmVyZW5jZTogdGhlcmUncyBzb21lIG1lbnRp b25zIG9mIFBXTSBiYWNrbGlnaHQgdmFsdWVzIGluCm5vdXZlYXVfcmVnLmgsIGJ1dCBJJ20gbm90 IHN1cmUgdGhlc2UgYXJlIHRoZSB2YWx1ZXMgd2Ugd291bGQgd2FudCB0byB1c2UuCklmIHdlIGZp Z3VyZSBvdXQgaG93IHRvIGdldCB0aGlzIGluZm9ybWF0aW9uIGluIHRoZSBmdXR1cmUsIHdlJ2xs IGhhdmUgdGhlCmJlbmVmaXQgb2YgbW9yZSBncmFudWxhciBiYWNrbGlnaHQgY29udHJvbC4KClNp Z25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhhdC5jb20+CkNjOiBKYW5pIE5pa3Vs YSA8amFuaS5uaWt1bGFAaW50ZWwuY29tPgpDYzogRGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwu Y29tPgpDYzogZ3JlZy5kZXBvaXJlQGdtYWlsLmNvbQotLS0KIGRyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L2Rpc3BudjUwL2Rpc3AuYyAgICAgfCAgMjggKysrKwogZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbm91dmVhdV9iYWNrbGlnaHQuYyB8IDE2NiArKysrKysrKysrKysrKysrKystLQogZHJpdmVy cy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaCB8ICAgOSArLQogZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggICB8ICAgMSArCiA0IGZpbGVzIGNoYW5n ZWQsIDE4NiBpbnNlcnRpb25zKCspLCAxOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91 dmVhdS9kaXNwbnY1MC9kaXNwLmMKaW5kZXggMTk2NjEyYWRkZmQ2Li40YTE4MTliMDIwODQgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmMKQEAgLTMxLDYgKzMxLDcgQEAK ICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2hkbWkuaD4K ICNpbmNsdWRlIDxsaW51eC9jb21wb25lbnQuaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4K IAogI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNf aGVscGVyLmg+CkBAIC0xNjQ3LDE1ICsxNjQ4LDMwIEBAIG52NTBfc29yX3VwZGF0ZShzdHJ1Y3Qg bm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLCB1OCBoZWFkLAogCWNvcmUtPmZ1bmMtPnNvci0+ Y3RybChjb3JlLCBudl9lbmNvZGVyLT5vciwgbnZfZW5jb2Rlci0+Y3RybCwgYXN5aCk7CiB9CiAK Ky8qIFRPRE86IFNob3VsZCB3ZSBleHRlbmQgdGhpcyB0byBQV00tb25seSBiYWNrbGlnaHRzPwor ICogQXMgd2VsbCwgc2hvdWxkIHdlIGFkZCBhIERSTSBoZWxwZXIgZm9yIHdhaXRpbmcgZm9yIHRo ZSBiYWNrbGlnaHQgdG8gYWNrbm93bGVkZ2UKKyAqIHRoZSBwYW5lbCBiYWNrbGlnaHQgaGFzIGJl ZW4gc2h1dCBvZmY/IEludGVsIGRvZXNuJ3Qgc2VlbSB0byBkbyB0aGlzLCBhbmQgdXNlcyBhCisg KiBmaXhlZCB0aW1lIGRlbGF5IGZyb20gdGhlIHZiaW9z4oCmCisgKi8KIHN0YXRpYyB2b2lkCiBu djUwX3Nvcl9hdG9taWNfZGlzYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKIHsKIAlzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpu dl9lbmNvZGVyID0gbm91dmVhdV9lbmNvZGVyKGVuY29kZXIpOworCXN0cnVjdCBub3V2ZWF1X2Ry bSAqZHJtID0gbm91dmVhdV9kcm0obnZfZW5jb2Rlci0+YmFzZS5iYXNlLmRldik7CiAJc3RydWN0 IG5vdXZlYXVfY3J0YyAqbnZfY3J0YyA9IG5vdXZlYXVfY3J0Yyhudl9lbmNvZGVyLT5jcnRjKTsK IAlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG52NTBfb3V0cF9nZXRf b2xkX2Nvbm5lY3RvcihzdGF0ZSwgbnZfZW5jb2Rlcik7CisJc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0ICpiYWNrbGlnaHQgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKIAlzdHJ1Y3QgZHJtX2Rw X2F1eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCWludCByZXQ7CiAJdTggcHdyOwogCisJ aWYgKGJhY2tsaWdodCAmJiBiYWNrbGlnaHQtPnVzZXNfZHBjZCkgeworCQlyZXQgPSBkcm1fZWRw X2JhY2tsaWdodF9kaXNhYmxlKGF1eCwgJmJhY2tsaWdodC0+ZWRwX2luZm8pOworCQlpZiAocmV0 IDwgMCkKKwkJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byBkaXNhYmxlIGJhY2tsaWdodCBvbiBb Q09OTkVDVE9SOiVkOiVzXTogJWRcbiIsCisJCQkJIG52X2Nvbm5lY3Rvci0+YmFzZS5iYXNlLmlk LCBudl9jb25uZWN0b3ItPmJhc2UubmFtZSwgcmV0KTsKKwl9CisKIAlpZiAobnZfZW5jb2Rlci0+ ZGNiLT50eXBlID09IERDQl9PVVRQVVRfRFApIHsKIAkJaW50IHJldCA9IGRybV9kcF9kcGNkX3Jl YWRiKGF1eCwgRFBfU0VUX1BPV0VSLCAmcHdyKTsKIApAQCAtMTY5NCw2ICsxNzEwLDkgQEAgbnY1 MF9zb3JfYXRvbWljX2VuYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGEKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZW5jb2Rlci0+ ZGV2OwogCXN0cnVjdCBub3V2ZWF1X2RybSAqZHJtID0gbm91dmVhdV9kcm0oZGV2KTsKIAlzdHJ1 Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvcjsKKyNpZmRlZiBDT05GSUdfRFJNX05P VVZFQVVfQkFDS0xJR0hUCisJc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0ICpiYWNrbGlnaHQ7Cisj ZW5kaWYKIAlzdHJ1Y3QgbnZiaW9zICpiaW9zID0gJmRybS0+dmJpb3M7CiAJYm9vbCBoZGEgPSBm YWxzZTsKIAl1OCBwcm90byA9IE5WNTA3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfQ1VTVE9N OwpAQCAtMTc2OCw2ICsxNzg3LDE0IEBAIG52NTBfc29yX2F0b21pY19lbmFibGUoc3RydWN0IGRy bV9lbmNvZGVyICplbmNvZGVyLCBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhCiAJCQlwcm90 byA9IE5WODg3RF9TT1JfU0VUX0NPTlRST0xfUFJPVE9DT0xfRFBfQjsKIAogCQludjUwX2F1ZGlv X2VuYWJsZShlbmNvZGVyLCBudl9jcnRjLCBudl9jb25uZWN0b3IsIHN0YXRlLCBtb2RlKTsKKwor I2lmZGVmIENPTkZJR19EUk1fTk9VVkVBVV9CQUNLTElHSFQKKwkJYmFja2xpZ2h0ID0gbnZfY29u bmVjdG9yLT5iYWNrbGlnaHQ7CisJCWlmIChiYWNrbGlnaHQgJiYgYmFja2xpZ2h0LT51c2VzX2Rw Y2QpCisJCQlkcm1fZWRwX2JhY2tsaWdodF9lbmFibGUoJm52X2Nvbm5lY3Rvci0+YXV4LCAmYmFj a2xpZ2h0LT5lZHBfaW5mbywKKwkJCQkJCSAodTE2KWJhY2tsaWdodC0+ZGV2LT5wcm9wcy5icmln aHRuZXNzKTsKKyNlbmRpZgorCiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCUJVRygpOwpAQCAtMjI5 Myw2ICsyMzIwLDcgQEAgbnY1MF9kaXNwX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGUpCiAJbnY1MF9jcmNfYXRvbWljX3N0YXJ0X3JlcG9ydGluZyhzdGF0 ZSk7CiAJaWYgKCFmbHVzaGVkKQogCQludjUwX2NyY19hdG9taWNfcmVsZWFzZV9ub3RpZmllcl9j b250ZXh0cyhzdGF0ZSk7CisKIAlkcm1fYXRvbWljX2hlbHBlcl9jb21taXRfaHdfZG9uZShzdGF0 ZSk7CiAJZHJtX2F0b21pY19oZWxwZXJfY2xlYW51cF9wbGFuZXMoZGV2LCBzdGF0ZSk7CiAJZHJt X2F0b21pY19oZWxwZXJfY29tbWl0X2NsZWFudXBfZG9uZShzdGF0ZSk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5jIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbm91dmVhdV9iYWNrbGlnaHQuYwppbmRleCA0MmI0OThlN2UyYmYuLmExMTgx MWI1ZTYzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9iYWNr bGlnaHQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2JhY2tsaWdodC5j CkBAIC00MiwxMSArNDIsNiBAQAogc3RhdGljIHN0cnVjdCBpZGEgYmxfaWRhOwogI2RlZmluZSBC TF9OQU1FX1NJWkUgMTUgLy8gMTIgZm9yIG5hbWUgKyAyIGZvciBkaWdpdHMgKyAxIGZvciAnXDAn CiAKLXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCB7Ci0Jc3RydWN0IGJhY2tsaWdodF9kZXZpY2Ug KmRldjsKLQlpbnQgaWQ7Ci19OwotCiBzdGF0aWMgYm9vbAogbm91dmVhdV9nZXRfYmFja2xpZ2h0 X25hbWUoY2hhciBiYWNrbGlnaHRfbmFtZVtCTF9OQU1FX1NJWkVdLAogCQkJICAgc3RydWN0IG5v dXZlYXVfYmFja2xpZ2h0ICpibCkKQEAgLTE0Nyw2ICsxNDIsOTggQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCBiYWNrbGlnaHRfb3BzIG52NTBfYmxfb3BzID0gewogCS51cGRhdGVfc3RhdHVzID0gbnY1 MF9zZXRfaW50ZW5zaXR5LAogfTsKIAorLyoKKyAqIGVEUCBicmlnaHRuZXNzIGNhbGxiYWNrcyBu ZWVkIHRvIGhhcHBlbiB1bmRlciBsb2NrLCBzaW5jZSB3ZSBuZWVkIHRvCisgKiBlbmFibGUvZGlz YWJsZSB0aGUgYmFja2xpZ2h0IG91cnNlbHZlcyBmb3IgbW9kZXNldHMKKyAqLworc3RhdGljIGlu dAorbnY1MF9lZHBfZ2V0X2JyaWdodG5lc3Moc3RydWN0IGJhY2tsaWdodF9kZXZpY2UgKmJkKQor eworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSBkZXZfZ2V0X2RydmRhdGEoYmQt PmRldi5wYXJlbnQpOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmRldjsK KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CisJc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4 IGN0eDsKKwlpbnQgcmV0ID0gMDsKKworCWRybV9tb2Rlc2V0X2FjcXVpcmVfaW5pdCgmY3R4LCAw KTsKKworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5j b25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQlnb3RvIGRl YWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9IGNvbm5l Y3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJldCA9IGRy bV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExL KQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJ aWYgKCFjcnRjLT5zdGF0ZS0+YWN0aXZlKQorCQlnb3RvIG91dDsKKworCXJldCA9IGJkLT5wcm9w cy5icmlnaHRuZXNzOworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJt X21vZGVzZXRfYWNxdWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlk cm1fbW9kZXNldF9iYWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBpbnQK K252NTBfZWRwX3NldF9icmlnaHRuZXNzKHN0cnVjdCBiYWNrbGlnaHRfZGV2aWNlICpiZCkKK3sK KwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gZGV2X2dldF9kcnZkYXRhKGJkLT5k ZXYucGFyZW50KTsKKwlzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm5lY3RvciA9IG5v dXZlYXVfY29ubmVjdG9yKGNvbm5lY3Rvcik7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNv bm5lY3Rvci0+ZGV2OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlzdHJ1Y3QgZHJtX2RwX2F1 eCAqYXV4ID0gJm52X2Nvbm5lY3Rvci0+YXV4OworCXN0cnVjdCBub3V2ZWF1X2JhY2tsaWdodCAq bnZfYmwgPSBudl9jb25uZWN0b3ItPmJhY2tsaWdodDsKKwlzdHJ1Y3QgZHJtX21vZGVzZXRfYWNx dWlyZV9jdHggY3R4OworCWludCByZXQgPSAwOworCisJZHJtX21vZGVzZXRfYWNxdWlyZV9pbml0 KCZjdHgsIDApOworcmV0cnk6CisJcmV0ID0gZHJtX21vZGVzZXRfbG9jaygmZGV2LT5tb2RlX2Nv bmZpZy5jb25uZWN0aW9uX211dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1FREVBRExLKQorCQln b3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJY3J0YyA9 IGNvbm5lY3Rvci0+c3RhdGUtPmNydGM7CisJaWYgKCFjcnRjKQorCQlnb3RvIG91dDsKKworCXJl dCA9IGRybV9tb2Rlc2V0X2xvY2soJmNydGMtPm11dGV4LCAmY3R4KTsKKwlpZiAocmV0ID09IC1F REVBRExLKQorCQlnb3RvIGRlYWRsb2NrOworCWVsc2UgaWYgKHJldCA8IDApCisJCWdvdG8gb3V0 OworCisJaWYgKGNydGMtPnN0YXRlLT5hY3RpdmUpCisJCXJldCA9IGRybV9lZHBfYmFja2xpZ2h0 X3NldF9sZXZlbChhdXgsICZudl9ibC0+ZWRwX2luZm8sIGJkLT5wcm9wcy5icmlnaHRuZXNzKTsK Kworb3V0OgorCWRybV9tb2Rlc2V0X2Ryb3BfbG9ja3MoJmN0eCk7CisJZHJtX21vZGVzZXRfYWNx dWlyZV9maW5pKCZjdHgpOworCXJldHVybiByZXQ7CitkZWFkbG9jazoKKwlkcm1fbW9kZXNldF9i YWNrb2ZmKCZjdHgpOworCWdvdG8gcmV0cnk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmFj a2xpZ2h0X29wcyBudjUwX2VkcF9ibF9vcHMgPSB7CisJLmdldF9icmlnaHRuZXNzID0gbnY1MF9l ZHBfZ2V0X2JyaWdodG5lc3MsCisJLnVwZGF0ZV9zdGF0dXMgPSBudjUwX2VkcF9zZXRfYnJpZ2h0 bmVzcywKK307CisKIHN0YXRpYyBpbnQKIG52YTNfZ2V0X2ludGVuc2l0eShzdHJ1Y3QgYmFja2xp Z2h0X2RldmljZSAqYmQpCiB7CkBAIC0xOTMsOCArMjgwLDEzIEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgYmFja2xpZ2h0X29wcyBudmEzX2JsX29wcyA9IHsKIAkudXBkYXRlX3N0YXR1cyA9IG52YTNf c2V0X2ludGVuc2l0eSwKIH07CiAKKy8qIEZJWE1FOiBwZXJmb3JtIGJhY2tsaWdodCBwcm9iaW5n IGZvciBlRFAgX2JlZm9yZV8gdGhpcywgdGhpcyBvbmx5IGdldHMgY2FsbGVkIGFmdGVyIGNvbm5l Y3RvcgorICogcmVnaXN0cmF0aW9uIHdoaWNoIGhhcHBlbnMgYWZ0ZXIgdGhlIGluaXRpYWwgbW9k ZXNldAorICovCiBzdGF0aWMgaW50Ci1udjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2VuY29kZXIgKm52X2VuY29kZXIsCitudjUwX2JhY2tsaWdodF9pbml0KHN0cnVjdCBub3V2ZWF1 X2JhY2tsaWdodCAqYmwsCisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9jb25uZWN0b3IgKm52X2Nvbm4s CisJCSAgICBzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpudl9lbmNvZGVyLAogCQkgICAgc3RydWN0 IGJhY2tsaWdodF9wcm9wZXJ0aWVzICpwcm9wcywKIAkJICAgIGNvbnN0IHN0cnVjdCBiYWNrbGln aHRfb3BzICoqb3BzKQogewpAQCAtMjA0LDYgKzI5Niw0MSBAQCBudjUwX2JhY2tsaWdodF9pbml0 KHN0cnVjdCBub3V2ZWF1X2VuY29kZXIgKm52X2VuY29kZXIsCiAJaWYgKCFudmlmX3JkMzIoZGV2 aWNlLCBOVjUwX1BESVNQX1NPUl9QV01fQ1RMKGZmcyhudl9lbmNvZGVyLT5kY2ItPm9yKSAtIDEp KSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKKwlpZiAobnZfY29ubi0+dHlwZSA9PSBEQ0JfQ09OTkVD VE9SX2VEUCkgeworCQlpbnQgcmV0OworCQl1MTYgY3VycmVudF9sZXZlbDsKKwkJdTggZWRwX2Rw Y2RbRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFXTsKKwkJdTggY3VycmVudF9tb2RlOworCisJCXJl dCA9IGRybV9kcF9kcGNkX3JlYWQoJm52X2Nvbm4tPmF1eCwgRFBfRURQX0RQQ0RfUkVWLCBlZHBf ZHBjZCwKKwkJCQkgICAgICAgRURQX0RJU1BMQVlfQ1RMX0NBUF9TSVpFKTsKKwkJaWYgKHJldCA8 IDApCisJCQlyZXR1cm4gcmV0OworCisJCWlmIChkcm1fZWRwX2JhY2tsaWdodF9zdXBwb3J0ZWQo ZWRwX2RwY2QpKSB7CisJCQlOVl9ERUJVRyhkcm0sICJEUENEIGJhY2tsaWdodCBjb250cm9scyBz dXBwb3J0ZWQgb24gJXNcbiIsCisJCQkJIG52X2Nvbm4tPmJhc2UubmFtZSk7CisKKwkJCXJldCA9 IGRybV9lZHBfYmFja2xpZ2h0X2luaXQoJm52X2Nvbm4tPmF1eCwgJmJsLT5lZHBfaW5mbywgMCwg ZWRwX2RwY2QsCisJCQkJCQkgICAgICZjdXJyZW50X2xldmVsLCAmY3VycmVudF9tb2RlKTsKKwkJ CWlmIChyZXQgPCAwKQorCQkJCXJldHVybiByZXQ7CisKKwkJCXJldCA9IGRybV9lZHBfYmFja2xp Z2h0X2VuYWJsZSgmbnZfY29ubi0+YXV4LCAmYmwtPmVkcF9pbmZvLCBjdXJyZW50X2xldmVsKTsK KwkJCWlmIChyZXQgPCAwKSB7CisJCQkJTlZfRVJST1IoZHJtLCAiRmFpbGVkIHRvIGVuYWJsZSBi YWNrbGlnaHQgb24gJXM6ICVkXG4iLAorCQkJCQkgbnZfY29ubi0+YmFzZS5uYW1lLCByZXQpOwor CQkJCXJldHVybiByZXQ7CisJCQl9CisKKwkJCSpvcHMgPSAmbnY1MF9lZHBfYmxfb3BzOworCQkJ cHJvcHMtPmJyaWdodG5lc3MgPSBjdXJyZW50X2xldmVsOworCQkJcHJvcHMtPm1heF9icmlnaHRu ZXNzID0gYmwtPmVkcF9pbmZvLm1heDsKKwkJCWJsLT51c2VzX2RwY2QgPSB0cnVlOworCQkJcmV0 dXJuIDA7CisJCX0KKwl9CisKIAlpZiAoZHJtLT5jbGllbnQuZGV2aWNlLmluZm8uY2hpcHNldCA8 PSAweGEwIHx8CiAJICAgIGRybS0+Y2xpZW50LmRldmljZS5pbmZvLmNoaXBzZXQgPT0gMHhhYSB8 fAogCSAgICBkcm0tPmNsaWVudC5kZXZpY2UuaW5mby5jaGlwc2V0ID09IDB4YWMpCkBAIC0yNDMs NiArMzcwLDEwIEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKIAlpZiAoIW52X2VuY29kZXIpCiAJCXJldHVybiAwOwogCisJYmwgPSBremFs bG9jKHNpemVvZigqYmwpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJsKQorCQlyZXR1cm4gLUVOT01F TTsKKwogCXN3aXRjaCAoZGV2aWNlLT5pbmZvLmZhbWlseSkgewogCWNhc2UgTlZfREVWSUNFX0lO Rk9fVjBfQ1VSSUU6CiAJCXJldCA9IG52NDBfYmFja2xpZ2h0X2luaXQobnZfZW5jb2RlciwgJnBy b3BzLCAmb3BzKTsKQEAgLTI1NSwyMCArMzg2LDE5IEBAIG5vdXZlYXVfYmFja2xpZ2h0X2luaXQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAljYXNlIE5WX0RFVklDRV9JTkZPX1Yw X1ZPTFRBOgogCWNhc2UgTlZfREVWSUNFX0lORk9fVjBfVFVSSU5HOgogCWNhc2UgTlZfREVWSUNF X0lORk9fVjBfQU1QRVJFOiAvL1hYWDogbm90IGNvbmZpcm1lZAotCQlyZXQgPSBudjUwX2JhY2ts aWdodF9pbml0KG52X2VuY29kZXIsICZwcm9wcywgJm9wcyk7CisJCXJldCA9IG52NTBfYmFja2xp Z2h0X2luaXQoYmwsIG5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciksCisJCQkJCSAgbnZfZW5j b2RlciwgJnByb3BzLCAmb3BzKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcmV0dXJuIDA7CisJ CXJldCA9IDA7CisJCWdvdG8gZmFpbF9hbGxvYzsKIAl9CiAKLQlpZiAocmV0ID09IC1FTk9ERVYp Ci0JCXJldHVybiAwOwotCWVsc2UgaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCWJsID0ga3ph bGxvYyhzaXplb2YoKmJsKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFibCkKLQkJcmV0dXJuIC1FTk9N RU07CisJaWYgKHJldCkgeworCQlpZiAocmV0ID09IC1FTk9ERVYpCisJCQlyZXQgPSAwOworCQln b3RvIGZhaWxfYWxsb2M7CisJfQogCiAJaWYgKCFub3V2ZWF1X2dldF9iYWNrbGlnaHRfbmFtZShi YWNrbGlnaHRfbmFtZSwgYmwpKSB7CiAJCU5WX0VSUk9SKGRybSwgIkZhaWxlZCB0byByZXRyaWV2 ZSBhIHVuaXF1ZSBuYW1lIGZvciB0aGUgYmFja2xpZ2h0IGludGVyZmFjZVxuIik7CkBAIC0yODUs NyArNDE1LDkgQEAgbm91dmVhdV9iYWNrbGlnaHRfaW5pdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yKQogCX0KIAogCW5vdXZlYXVfY29ubmVjdG9yKGNvbm5lY3RvciktPmJhY2tsaWdo dCA9IGJsOwotCWJsLT5kZXYtPnByb3BzLmJyaWdodG5lc3MgPSBibC0+ZGV2LT5vcHMtPmdldF9i cmlnaHRuZXNzKGJsLT5kZXYpOworCWlmICghYmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcykKKwkJ YmwtPmRldi0+cHJvcHMuYnJpZ2h0bmVzcyA9CisJCQlibC0+ZGV2LT5vcHMtPmdldF9icmlnaHRu ZXNzKGJsLT5kZXYpOwogCWJhY2tsaWdodF91cGRhdGVfc3RhdHVzKGJsLT5kZXYpOwogCiAJcmV0 dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Nvbm5l Y3Rvci5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAppbmRl eCBkMGI4NTljNGE4MGUuLjQwZjkwZTM1MzU0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L25vdXZlYXUvbm91dmVhdV9jb25uZWN0b3IuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVh dS9ub3V2ZWF1X2Nvbm5lY3Rvci5oCkBAIC00Niw3ICs0NiwxNCBAQCBzdHJ1Y3QgbnZrbV9pMmNf cG9ydDsKIHN0cnVjdCBkY2Jfb3V0cHV0OwogCiAjaWZkZWYgQ09ORklHX0RSTV9OT1VWRUFVX0JB Q0tMSUdIVAotc3RydWN0IG5vdXZlYXVfYmFja2xpZ2h0Oworc3RydWN0IG5vdXZlYXVfYmFja2xp Z2h0IHsKKwlzdHJ1Y3QgYmFja2xpZ2h0X2RldmljZSAqZGV2OworCisJc3RydWN0IGRybV9lZHBf YmFja2xpZ2h0X2luZm8gZWRwX2luZm87CisJYm9vbCB1c2VzX2RwY2QgOiAxOworCisJaW50IGlk OworfTsKICNlbmRpZgogCiAjZGVmaW5lIG5vdXZlYXVfY29ubl9hdG9tKHApICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmggYi9kcml2ZXJzL2dwdS9kcm0v bm91dmVhdS9ub3V2ZWF1X2VuY29kZXIuaAppbmRleCAxZmZjYzBhNDkxZmQuLjc3YzJmZWQ3NmU4 YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9lbmNvZGVyLmgKQEAgLTMwLDYg KzMwLDcgQEAKICNpbmNsdWRlIDxzdWJkZXYvYmlvcy9kY2IuaD4KIAogI2luY2x1ZGUgPGRybS9k cm1fZW5jb2Rlcl9zbGF2ZS5oPgorI2luY2x1ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+CiAjaW5j bHVkZSA8ZHJtL2RybV9kcF9tc3RfaGVscGVyLmg+CiAjaW5jbHVkZSAiZGlzcG52MDQvZGlzcC5o Igogc3RydWN0IG52NTBfaGVhZF9hdG9tOwotLSAKMi4yOS4yCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK