From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754973AbcHVPdS (ORCPT ); Mon, 22 Aug 2016 11:33:18 -0400 Received: from mx1.redhat.com ([209.132.183.28]:42542 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756123AbcHVPcA (ORCPT ); Mon, 22 Aug 2016 11:32:00 -0400 From: Lyude To: gregkh@linuxfoundation.org Cc: Lyude , stable@vger.kernel.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Daniel Vetter , Jani Nikula , David Airlie , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH 4/4] drm/i915: Enable polling when we don't have hpd Date: Mon, 22 Aug 2016 11:31:35 -0400 Message-Id: <1471879896-19761-5-git-send-email-cpaul@redhat.com> In-Reply-To: <1471879896-19761-1-git-send-email-cpaul@redhat.com> References: <147152082520357@kroah.com> <1471879896-19761-1-git-send-email-cpaul@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.38]); Mon, 22 Aug 2016 15:31:44 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Unfortunately, there's two situations where we lose hpd right now: - Runtime suspend - When we've shut off all of the power wells on Valleyview/Cherryview While it would be nice if this didn't cause issues, this has the ability to get us in some awkward states where a user won't be able to get their display to turn on. For instance; if we boot a Valleyview system without any monitors connected, it won't need any of it's power wells and thus shut them off. Since this causes us to lose HPD, this means that unless the user knows how to ssh into their machine and do a manual reprobe for monitors, none of the monitors they connect after booting will actually work. Eventually we should come up with a better fix then having to enable polling for this, since this makes rpm a lot less useful, but for now the infrastructure in i915 just isn't there yet to get hpd in these situations. Changes since v1: - Add comment explaining the addition of the if (!mode_config->poll_running) in intel_hpd_init() - Remove unneeded if (!dev->mode_config.poll_enabled) in i915_hpd_poll_init_work() - Call to drm_helper_hpd_irq_event() after we disable polling - Add cancel_work_sync() call to intel_hpd_cancel_work() Changes since v2: - Apparently dev->mode_config.poll_running doesn't actually reflect whether or not a poll is currently in progress, and is actually used for dynamic module paramter enabling/disabling. So now we instead keep track of our own poll_running variable in dev_priv->hotplug - Clean i915_hpd_poll_init_work() a little bit Changes since v3: - Remove the now-redundant connector loop in intel_hpd_init(), just rely on intel_hpd_poll_enable() for setting connector->polled correctly on each connector - Get rid of poll_running - Don't assign enabled in i915_hpd_poll_init_work before we actually lock dev->mode_config.mutex - Wrap enabled assignment in i915_hpd_poll_init_work() in READ_ONCE() for doc purposes - Do the same for dev_priv->hotplug.poll_enabled with WRITE_ONCE in intel_hpd_poll_enable() - Add some comments about racing not mattering in intel_hpd_poll_enable Changes since v4: - Rename intel_hpd_poll_enable() to intel_hpd_poll_init() - Drop the bool argument from intel_hpd_poll_init() - Remove redundant calls to intel_hpd_poll_init() - Rename poll_enable_work to poll_init_work - Add some kerneldoc for intel_hpd_poll_init() - Cross-reference intel_hpd_poll_init() in intel_hpd_init() - Just copy the loop from intel_hpd_init() in intel_hpd_poll_init() Changes since v5: - Minor kerneldoc nitpicks Cc: stable@vger.kernel.org Cc: Ville Syrjälä Reviewed-by: Daniel Vetter Signed-off-by: Lyude --- drivers/gpu/drm/i915/i915_drv.c | 3 ++ drivers/gpu/drm/i915/i915_drv.h | 3 ++ drivers/gpu/drm/i915/intel_drv.h | 2 + drivers/gpu/drm/i915/intel_hotplug.c | 90 ++++++++++++++++++++++++++++----- drivers/gpu/drm/i915/intel_runtime_pm.c | 2 + 5 files changed, 88 insertions(+), 12 deletions(-) diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 85c4deb..fd3553b 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -1578,6 +1578,9 @@ static int intel_runtime_suspend(struct device *device) assert_forcewakes_inactive(dev_priv); + if (!IS_VALLEYVIEW(dev_priv) || !IS_CHERRYVIEW(dev_priv)) + intel_hpd_poll_init(dev_priv); + DRM_DEBUG_KMS("Device suspended\n"); return 0; } diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 7f8ea58..0ed5fd3 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -281,6 +281,9 @@ struct i915_hotplug { u32 short_port_mask; struct work_struct dig_port_work; + struct work_struct poll_init_work; + bool poll_enabled; + /* * if we get a HPD irq from DP and a HPD irq from non-DP * the non-DP HPD could block the workqueue on a mode config diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 14d1dc6..94144a7 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1346,6 +1346,8 @@ void intel_dsi_init(struct drm_device *dev); /* intel_dvo.c */ void intel_dvo_init(struct drm_device *dev); +/* intel_hotplug.c */ +void intel_hpd_poll_init(struct drm_i915_private *dev_priv); /* legacy fbdev emulation in intel_fbdev.c */ diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c index 0c9ee3f..2c49458 100644 --- a/drivers/gpu/drm/i915/intel_hotplug.c +++ b/drivers/gpu/drm/i915/intel_hotplug.c @@ -453,20 +453,47 @@ void intel_hpd_irq_handler(struct drm_device *dev, * * This is a separate step from interrupt enabling to simplify the locking rules * in the driver load and resume code. + * + * Also see: intel_hpd_poll_init(), which enables connector polling */ void intel_hpd_init(struct drm_i915_private *dev_priv) { - struct drm_device *dev = dev_priv->dev; - struct drm_mode_config *mode_config = &dev->mode_config; - struct drm_connector *connector; int i; for_each_hpd_pin(i) { dev_priv->hotplug.stats[i].count = 0; dev_priv->hotplug.stats[i].state = HPD_ENABLED; } + + WRITE_ONCE(dev_priv->hotplug.poll_enabled, false); + schedule_work(&dev_priv->hotplug.poll_init_work); + + /* + * Interrupt setup is already guaranteed to be single-threaded, this is + * just to make the assert_spin_locked checks happy. + */ + spin_lock_irq(&dev_priv->irq_lock); + if (dev_priv->display.hpd_irq_setup) + dev_priv->display.hpd_irq_setup(dev_priv->dev); + spin_unlock_irq(&dev_priv->irq_lock); +} + +void i915_hpd_poll_init_work(struct work_struct *work) { + struct drm_i915_private *dev_priv = + container_of(work, struct drm_i915_private, + hotplug.poll_init_work); + struct drm_device *dev = dev_priv->dev; + struct drm_mode_config *mode_config = &dev->mode_config; + struct drm_connector *connector; + bool enabled; + + mutex_lock(&dev->mode_config.mutex); + + enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); + list_for_each_entry(connector, &mode_config->connector_list, head) { - struct intel_connector *intel_connector = to_intel_connector(connector); + struct intel_connector *intel_connector = + to_intel_connector(connector); connector->polled = intel_connector->polled; /* MST has a dynamic intel_connector->encoder and it's reprobing @@ -475,24 +502,62 @@ void intel_hpd_init(struct drm_i915_private *dev_priv) continue; if (!connector->polled && I915_HAS_HOTPLUG(dev) && - intel_connector->encoder->hpd_pin > HPD_NONE) - connector->polled = DRM_CONNECTOR_POLL_HPD; + intel_connector->encoder->hpd_pin > HPD_NONE) { + connector->polled = enabled ? + DRM_CONNECTOR_POLL_CONNECT | + DRM_CONNECTOR_POLL_DISCONNECT : + DRM_CONNECTOR_POLL_HPD; + } } + if (enabled) + drm_kms_helper_poll_enable_locked(dev); + + mutex_unlock(&dev->mode_config.mutex); + /* - * Interrupt setup is already guaranteed to be single-threaded, this is - * just to make the assert_spin_locked checks happy. + * We might have missed any hotplugs that happened while we were + * in the middle of disabling polling */ - spin_lock_irq(&dev_priv->irq_lock); - if (dev_priv->display.hpd_irq_setup) - dev_priv->display.hpd_irq_setup(dev); - spin_unlock_irq(&dev_priv->irq_lock); + if (!enabled) + drm_helper_hpd_irq_event(dev); +} + +/** + * intel_hpd_poll_init - enables/disables polling for connectors with hpd + * @dev_priv: i915 device instance + * @enabled: Whether to enable or disable polling + * + * This function enables polling for all connectors, regardless of whether or + * not they support hotplug detection. Under certain conditions HPD may not be + * functional. On most Intel GPUs, this happens when we enter runtime suspend. + * On Valleyview and Cherryview systems, this also happens when we shut off all + * of the powerwells. + * + * Since this function can get called in contexts where we're already holding + * dev->mode_config.mutex, we do the actual hotplug enabling in a seperate + * worker. + * + * Also see: intel_hpd_init(), which restores hpd handling. + */ +void intel_hpd_poll_init(struct drm_i915_private *dev_priv) +{ + WRITE_ONCE(dev_priv->hotplug.poll_enabled, true); + + /* + * We might already be holding dev->mode_config.mutex, so do this in a + * seperate worker + * As well, there's no issue if we race here since we always reschedule + * this worker anyway + */ + schedule_work(&dev_priv->hotplug.poll_init_work); } void intel_hpd_init_work(struct drm_i915_private *dev_priv) { INIT_WORK(&dev_priv->hotplug.hotplug_work, i915_hotplug_work_func); INIT_WORK(&dev_priv->hotplug.dig_port_work, i915_digport_work_func); + INIT_WORK(&dev_priv->hotplug.poll_init_work, i915_hpd_poll_init_work); INIT_DELAYED_WORK(&dev_priv->hotplug.reenable_work, intel_hpd_irq_storm_reenable_work); } @@ -509,6 +574,7 @@ void intel_hpd_cancel_work(struct drm_i915_private *dev_priv) cancel_work_sync(&dev_priv->hotplug.dig_port_work); cancel_work_sync(&dev_priv->hotplug.hotplug_work); + cancel_work_sync(&dev_priv->hotplug.poll_init_work); cancel_delayed_work_sync(&dev_priv->hotplug.reenable_work); } diff --git a/drivers/gpu/drm/i915/intel_runtime_pm.c b/drivers/gpu/drm/i915/intel_runtime_pm.c index 4a3fd3a..2592b39 100644 --- a/drivers/gpu/drm/i915/intel_runtime_pm.c +++ b/drivers/gpu/drm/i915/intel_runtime_pm.c @@ -1007,6 +1007,8 @@ static void vlv_display_power_well_deinit(struct drm_i915_private *dev_priv) synchronize_irq(dev_priv->dev->irq); vlv_power_sequencer_reset(dev_priv); + + intel_hpd_poll_init(dev_priv); } static void vlv_display_power_well_enable(struct drm_i915_private *dev_priv, -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH 4/4] drm/i915: Enable polling when we don't have hpd Date: Mon, 22 Aug 2016 11:31:35 -0400 Message-ID: <1471879896-19761-5-git-send-email-cpaul@redhat.com> References: <147152082520357@kroah.com> <1471879896-19761-1-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1471879896-19761-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: gregkh@linuxfoundation.org Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, stable@vger.kernel.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org VW5mb3J0dW5hdGVseSwgdGhlcmUncyB0d28gc2l0dWF0aW9ucyB3aGVyZSB3ZSBsb3NlIGhwZCBy aWdodCBub3c6CiAtIFJ1bnRpbWUgc3VzcGVuZAogLSBXaGVuIHdlJ3ZlIHNodXQgb2ZmIGFsbCBv ZiB0aGUgcG93ZXIgd2VsbHMgb24gVmFsbGV5dmlldy9DaGVycnl2aWV3CgpXaGlsZSBpdCB3b3Vs ZCBiZSBuaWNlIGlmIHRoaXMgZGlkbid0IGNhdXNlIGlzc3VlcywgdGhpcyBoYXMgdGhlCmFiaWxp dHkgdG8gZ2V0IHVzIGluIHNvbWUgYXdrd2FyZCBzdGF0ZXMgd2hlcmUgYSB1c2VyIHdvbid0IGJl IGFibGUgdG8KZ2V0IHRoZWlyIGRpc3BsYXkgdG8gdHVybiBvbi4gRm9yIGluc3RhbmNlOyBpZiB3 ZSBib290IGEgVmFsbGV5dmlldwpzeXN0ZW0gd2l0aG91dCBhbnkgbW9uaXRvcnMgY29ubmVjdGVk LCBpdCB3b24ndCBuZWVkIGFueSBvZiBpdCdzIHBvd2VyCndlbGxzIGFuZCB0aHVzIHNodXQgdGhl bSBvZmYuIFNpbmNlIHRoaXMgY2F1c2VzIHVzIHRvIGxvc2UgSFBELCB0aGlzCm1lYW5zIHRoYXQg dW5sZXNzIHRoZSB1c2VyIGtub3dzIGhvdyB0byBzc2ggaW50byB0aGVpciBtYWNoaW5lIGFuZCBk byBhCm1hbnVhbCByZXByb2JlIGZvciBtb25pdG9ycywgbm9uZSBvZiB0aGUgbW9uaXRvcnMgdGhl eSBjb25uZWN0IGFmdGVyCmJvb3Rpbmcgd2lsbCBhY3R1YWxseSB3b3JrLgoKRXZlbnR1YWxseSB3 ZSBzaG91bGQgY29tZSB1cCB3aXRoIGEgYmV0dGVyIGZpeCB0aGVuIGhhdmluZyB0byBlbmFibGUK cG9sbGluZyBmb3IgdGhpcywgc2luY2UgdGhpcyBtYWtlcyBycG0gYSBsb3QgbGVzcyB1c2VmdWws IGJ1dCBmb3Igbm93CnRoZSBpbmZyYXN0cnVjdHVyZSBpbiBpOTE1IGp1c3QgaXNuJ3QgdGhlcmUg eWV0IHRvIGdldCBocGQgaW4gdGhlc2UKc2l0dWF0aW9ucy4KCkNoYW5nZXMgc2luY2UgdjE6CiAt IEFkZCBjb21tZW50IGV4cGxhaW5pbmcgdGhlIGFkZGl0aW9uIG9mIHRoZSBpZgogICAoIW1vZGVf Y29uZmlnLT5wb2xsX3J1bm5pbmcpIGluIGludGVsX2hwZF9pbml0KCkKIC0gUmVtb3ZlIHVubmVl ZGVkIGlmICghZGV2LT5tb2RlX2NvbmZpZy5wb2xsX2VuYWJsZWQpIGluCiAgIGk5MTVfaHBkX3Bv bGxfaW5pdF93b3JrKCkKIC0gQ2FsbCB0byBkcm1faGVscGVyX2hwZF9pcnFfZXZlbnQoKSBhZnRl ciB3ZSBkaXNhYmxlIHBvbGxpbmcKIC0gQWRkIGNhbmNlbF93b3JrX3N5bmMoKSBjYWxsIHRvIGlu dGVsX2hwZF9jYW5jZWxfd29yaygpCgpDaGFuZ2VzIHNpbmNlIHYyOgogLSBBcHBhcmVudGx5IGRl di0+bW9kZV9jb25maWcucG9sbF9ydW5uaW5nIGRvZXNuJ3QgYWN0dWFsbHkgcmVmbGVjdAogICB3 aGV0aGVyIG9yIG5vdCBhIHBvbGwgaXMgY3VycmVudGx5IGluIHByb2dyZXNzLCBhbmQgaXMgYWN0 dWFsbHkgdXNlZAogICBmb3IgZHluYW1pYyBtb2R1bGUgcGFyYW10ZXIgZW5hYmxpbmcvZGlzYWJs aW5nLiBTbyBub3cgd2UgaW5zdGVhZAogICBrZWVwIHRyYWNrIG9mIG91ciBvd24gcG9sbF9ydW5u aW5nIHZhcmlhYmxlIGluIGRldl9wcml2LT5ob3RwbHVnCiAtIENsZWFuIGk5MTVfaHBkX3BvbGxf aW5pdF93b3JrKCkgYSBsaXR0bGUgYml0CgpDaGFuZ2VzIHNpbmNlIHYzOgogLSBSZW1vdmUgdGhl IG5vdy1yZWR1bmRhbnQgY29ubmVjdG9yIGxvb3AgaW4gaW50ZWxfaHBkX2luaXQoKSwganVzdAog ICByZWx5IG9uIGludGVsX2hwZF9wb2xsX2VuYWJsZSgpIGZvciBzZXR0aW5nIGNvbm5lY3Rvci0+ cG9sbGVkCiAgIGNvcnJlY3RseSBvbiBlYWNoIGNvbm5lY3RvcgogLSBHZXQgcmlkIG9mIHBvbGxf cnVubmluZwogLSBEb24ndCBhc3NpZ24gZW5hYmxlZCBpbiBpOTE1X2hwZF9wb2xsX2luaXRfd29y ayBiZWZvcmUgd2UgYWN0dWFsbHkKICAgbG9jayBkZXYtPm1vZGVfY29uZmlnLm11dGV4CiAtIFdy YXAgZW5hYmxlZCBhc3NpZ25tZW50IGluIGk5MTVfaHBkX3BvbGxfaW5pdF93b3JrKCkgaW4gUkVB RF9PTkNFKCkKICAgZm9yIGRvYyBwdXJwb3NlcwogLSBEbyB0aGUgc2FtZSBmb3IgZGV2X3ByaXYt PmhvdHBsdWcucG9sbF9lbmFibGVkIHdpdGggV1JJVEVfT05DRSBpbgogICBpbnRlbF9ocGRfcG9s bF9lbmFibGUoKQogLSBBZGQgc29tZSBjb21tZW50cyBhYm91dCByYWNpbmcgbm90IG1hdHRlcmlu ZyBpbiBpbnRlbF9ocGRfcG9sbF9lbmFibGUKCkNoYW5nZXMgc2luY2UgdjQ6CiAtIFJlbmFtZSBp bnRlbF9ocGRfcG9sbF9lbmFibGUoKSB0byBpbnRlbF9ocGRfcG9sbF9pbml0KCkKIC0gRHJvcCB0 aGUgYm9vbCBhcmd1bWVudCBmcm9tIGludGVsX2hwZF9wb2xsX2luaXQoKQogLSBSZW1vdmUgcmVk dW5kYW50IGNhbGxzIHRvIGludGVsX2hwZF9wb2xsX2luaXQoKQogLSBSZW5hbWUgcG9sbF9lbmFi bGVfd29yayB0byBwb2xsX2luaXRfd29yawogLSBBZGQgc29tZSBrZXJuZWxkb2MgZm9yIGludGVs X2hwZF9wb2xsX2luaXQoKQogLSBDcm9zcy1yZWZlcmVuY2UgaW50ZWxfaHBkX3BvbGxfaW5pdCgp IGluIGludGVsX2hwZF9pbml0KCkKIC0gSnVzdCBjb3B5IHRoZSBsb29wIGZyb20gaW50ZWxfaHBk X2luaXQoKSBpbiBpbnRlbF9ocGRfcG9sbF9pbml0KCkKCkNoYW5nZXMgc2luY2UgdjU6CiAtIE1p bm9yIGtlcm5lbGRvYyBuaXRwaWNrcwoKQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IFZp bGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+ClJldmlld2VkLWJ5 OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgpTaWduZWQtb2ZmLWJ5OiBM eXVkZSA8Y3BhdWxAcmVkaGF0LmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Ry di5jICAgICAgICAgfCAgMyArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCAgICAg ICAgIHwgIDMgKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oICAgICAgICB8ICAy ICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYyAgICB8IDkwICsrKysrKysr KysrKysrKysrKysrKysrKysrKystLS0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcnVu dGltZV9wbS5jIHwgIDIgKwogNSBmaWxlcyBjaGFuZ2VkLCA4OCBpbnNlcnRpb25zKCspLCAxMiBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5j IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYwppbmRleCA4NWM0ZGViLi5mZDM1NTNi IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMKQEAgLTE1NzgsNiArMTU3OCw5IEBAIHN0YXRpYyBp bnQgaW50ZWxfcnVudGltZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldmljZSkKIAogCWFzc2Vy dF9mb3JjZXdha2VzX2luYWN0aXZlKGRldl9wcml2KTsKIAorCWlmICghSVNfVkFMTEVZVklFVyhk ZXZfcHJpdikgfHwgIUlTX0NIRVJSWVZJRVcoZGV2X3ByaXYpKQorCQlpbnRlbF9ocGRfcG9sbF9p bml0KGRldl9wcml2KTsKKwogCURSTV9ERUJVR19LTVMoIkRldmljZSBzdXNwZW5kZWRcbiIpOwog CXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYu aCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKaW5kZXggN2Y4ZWE1OC4uMGVkNWZk MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAorKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCkBAIC0yODEsNiArMjgxLDkgQEAgc3RydWN0IGk5 MTVfaG90cGx1ZyB7CiAJdTMyIHNob3J0X3BvcnRfbWFzazsKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3Qg ZGlnX3BvcnRfd29yazsKIAorCXN0cnVjdCB3b3JrX3N0cnVjdCBwb2xsX2luaXRfd29yazsKKwli b29sIHBvbGxfZW5hYmxlZDsKKwogCS8qCiAJICogaWYgd2UgZ2V0IGEgSFBEIGlycSBmcm9tIERQ IGFuZCBhIEhQRCBpcnEgZnJvbSBub24tRFAKIAkgKiB0aGUgbm9uLURQIEhQRCBjb3VsZCBibG9j ayB0aGUgd29ya3F1ZXVlIG9uIGEgbW9kZSBjb25maWcKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgK aW5kZXggMTRkMWRjNi4uOTQxNDRhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKQEAgLTEz NDYsNiArMTM0Niw4IEBAIHZvaWQgaW50ZWxfZHNpX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRl dik7CiAKIC8qIGludGVsX2R2by5jICovCiB2b2lkIGludGVsX2R2b19pbml0KHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYpOworLyogaW50ZWxfaG90cGx1Zy5jICovCit2b2lkIGludGVsX2hwZF9wb2xs X2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KTsKIAogCiAvKiBsZWdhY3kg ZmJkZXYgZW11bGF0aW9uIGluIGludGVsX2ZiZGV2LmMgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2hvdHBsdWcuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2hvdHBsdWcuYwppbmRleCAwYzllZTNmLi4yYzQ5NDU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9ob3RwbHVnLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfaG90cGx1Zy5jCkBAIC00NTMsMjAgKzQ1Myw0NyBAQCB2b2lkIGludGVsX2hwZF9pcnFfaGFu ZGxlcihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogICoKICAqIFRoaXMgaXMgYSBzZXBhcmF0ZSBz dGVwIGZyb20gaW50ZXJydXB0IGVuYWJsaW5nIHRvIHNpbXBsaWZ5IHRoZSBsb2NraW5nIHJ1bGVz CiAgKiBpbiB0aGUgZHJpdmVyIGxvYWQgYW5kIHJlc3VtZSBjb2RlLgorICoKKyAqIEFsc28gc2Vl OiBpbnRlbF9ocGRfcG9sbF9pbml0KCksIHdoaWNoIGVuYWJsZXMgY29ubmVjdG9yIHBvbGxpbmcK ICAqLwogdm9pZCBpbnRlbF9ocGRfaW5pdChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYpCiB7Ci0Jc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRldl9wcml2LT5kZXY7Ci0Jc3RydWN0 IGRybV9tb2RlX2NvbmZpZyAqbW9kZV9jb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKLQlzdHJ1 Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yOwogCWludCBpOwogCiAJZm9yX2VhY2hfaHBkX3Bp bihpKSB7CiAJCWRldl9wcml2LT5ob3RwbHVnLnN0YXRzW2ldLmNvdW50ID0gMDsKIAkJZGV2X3By aXYtPmhvdHBsdWcuc3RhdHNbaV0uc3RhdGUgPSBIUERfRU5BQkxFRDsKIAl9CisKKwlXUklURV9P TkNFKGRldl9wcml2LT5ob3RwbHVnLnBvbGxfZW5hYmxlZCwgZmFsc2UpOworCXNjaGVkdWxlX3dv cmsoJmRldl9wcml2LT5ob3RwbHVnLnBvbGxfaW5pdF93b3JrKTsKKworCS8qCisJICogSW50ZXJy dXB0IHNldHVwIGlzIGFscmVhZHkgZ3VhcmFudGVlZCB0byBiZSBzaW5nbGUtdGhyZWFkZWQsIHRo aXMgaXMKKwkgKiBqdXN0IHRvIG1ha2UgdGhlIGFzc2VydF9zcGluX2xvY2tlZCBjaGVja3MgaGFw cHkuCisJICovCisJc3Bpbl9sb2NrX2lycSgmZGV2X3ByaXYtPmlycV9sb2NrKTsKKwlpZiAoZGV2 X3ByaXYtPmRpc3BsYXkuaHBkX2lycV9zZXR1cCkKKwkJZGV2X3ByaXYtPmRpc3BsYXkuaHBkX2ly cV9zZXR1cChkZXZfcHJpdi0+ZGV2KTsKKwlzcGluX3VubG9ja19pcnEoJmRldl9wcml2LT5pcnFf bG9jayk7Cit9CisKK3ZvaWQgaTkxNV9ocGRfcG9sbF9pbml0X3dvcmsoc3RydWN0IHdvcmtfc3Ry dWN0ICp3b3JrKSB7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0KKwkJY29u dGFpbmVyX29mKHdvcmssIHN0cnVjdCBkcm1faTkxNV9wcml2YXRlLAorCQkJICAgICBob3RwbHVn LnBvbGxfaW5pdF93b3JrKTsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZGV2X3ByaXYtPmRl djsKKwlzdHJ1Y3QgZHJtX21vZGVfY29uZmlnICptb2RlX2NvbmZpZyA9ICZkZXYtPm1vZGVfY29u ZmlnOworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7CisJYm9vbCBlbmFibGVkOwor CisJbXV0ZXhfbG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7CisKKwllbmFibGVkID0gUkVB RF9PTkNFKGRldl9wcml2LT5ob3RwbHVnLnBvbGxfZW5hYmxlZCk7CisKIAlsaXN0X2Zvcl9lYWNo X2VudHJ5KGNvbm5lY3RvciwgJm1vZGVfY29uZmlnLT5jb25uZWN0b3JfbGlzdCwgaGVhZCkgewot CQlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICppbnRlbF9jb25uZWN0b3IgPSB0b19pbnRlbF9jb25u ZWN0b3IoY29ubmVjdG9yKTsKKwkJc3RydWN0IGludGVsX2Nvbm5lY3RvciAqaW50ZWxfY29ubmVj dG9yID0KKwkJCXRvX2ludGVsX2Nvbm5lY3Rvcihjb25uZWN0b3IpOwogCQljb25uZWN0b3ItPnBv bGxlZCA9IGludGVsX2Nvbm5lY3Rvci0+cG9sbGVkOwogCiAJCS8qIE1TVCBoYXMgYSBkeW5hbWlj IGludGVsX2Nvbm5lY3Rvci0+ZW5jb2RlciBhbmQgaXQncyByZXByb2JpbmcKQEAgLTQ3NSwyNCAr NTAyLDYyIEBAIHZvaWQgaW50ZWxfaHBkX2luaXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRl dl9wcml2KQogCQkJY29udGludWU7CiAKIAkJaWYgKCFjb25uZWN0b3ItPnBvbGxlZCAmJiBJOTE1 X0hBU19IT1RQTFVHKGRldikgJiYKLQkJICAgIGludGVsX2Nvbm5lY3Rvci0+ZW5jb2Rlci0+aHBk X3BpbiA+IEhQRF9OT05FKQotCQkJY29ubmVjdG9yLT5wb2xsZWQgPSBEUk1fQ09OTkVDVE9SX1BP TExfSFBEOworCQkgICAgaW50ZWxfY29ubmVjdG9yLT5lbmNvZGVyLT5ocGRfcGluID4gSFBEX05P TkUpIHsKKwkJCWNvbm5lY3Rvci0+cG9sbGVkID0gZW5hYmxlZCA/CisJCQkJRFJNX0NPTk5FQ1RP Ul9QT0xMX0NPTk5FQ1QgfAorCQkJCURSTV9DT05ORUNUT1JfUE9MTF9ESVNDT05ORUNUIDoKKwkJ CQlEUk1fQ09OTkVDVE9SX1BPTExfSFBEOworCQl9CiAJfQogCisJaWYgKGVuYWJsZWQpCisJCWRy bV9rbXNfaGVscGVyX3BvbGxfZW5hYmxlX2xvY2tlZChkZXYpOworCisJbXV0ZXhfdW5sb2NrKCZk ZXYtPm1vZGVfY29uZmlnLm11dGV4KTsKKwogCS8qCi0JICogSW50ZXJydXB0IHNldHVwIGlzIGFs cmVhZHkgZ3VhcmFudGVlZCB0byBiZSBzaW5nbGUtdGhyZWFkZWQsIHRoaXMgaXMKLQkgKiBqdXN0 IHRvIG1ha2UgdGhlIGFzc2VydF9zcGluX2xvY2tlZCBjaGVja3MgaGFwcHkuCisJICogV2UgbWln aHQgaGF2ZSBtaXNzZWQgYW55IGhvdHBsdWdzIHRoYXQgaGFwcGVuZWQgd2hpbGUgd2Ugd2VyZQor CSAqIGluIHRoZSBtaWRkbGUgb2YgZGlzYWJsaW5nIHBvbGxpbmcKIAkgKi8KLQlzcGluX2xvY2tf aXJxKCZkZXZfcHJpdi0+aXJxX2xvY2spOwotCWlmIChkZXZfcHJpdi0+ZGlzcGxheS5ocGRfaXJx X3NldHVwKQotCQlkZXZfcHJpdi0+ZGlzcGxheS5ocGRfaXJxX3NldHVwKGRldik7Ci0Jc3Bpbl91 bmxvY2tfaXJxKCZkZXZfcHJpdi0+aXJxX2xvY2spOworCWlmICghZW5hYmxlZCkKKwkJZHJtX2hl bHBlcl9ocGRfaXJxX2V2ZW50KGRldik7Cit9CisKKy8qKgorICogaW50ZWxfaHBkX3BvbGxfaW5p dCAtIGVuYWJsZXMvZGlzYWJsZXMgcG9sbGluZyBmb3IgY29ubmVjdG9ycyB3aXRoIGhwZAorICog QGRldl9wcml2OiBpOTE1IGRldmljZSBpbnN0YW5jZQorICogQGVuYWJsZWQ6IFdoZXRoZXIgdG8g ZW5hYmxlIG9yIGRpc2FibGUgcG9sbGluZworICoKKyAqIFRoaXMgZnVuY3Rpb24gZW5hYmxlcyBw b2xsaW5nIGZvciBhbGwgY29ubmVjdG9ycywgcmVnYXJkbGVzcyBvZiB3aGV0aGVyIG9yCisgKiBu b3QgdGhleSBzdXBwb3J0IGhvdHBsdWcgZGV0ZWN0aW9uLiBVbmRlciBjZXJ0YWluIGNvbmRpdGlv bnMgSFBEIG1heSBub3QgYmUKKyAqIGZ1bmN0aW9uYWwuIE9uIG1vc3QgSW50ZWwgR1BVcywgdGhp cyBoYXBwZW5zIHdoZW4gd2UgZW50ZXIgcnVudGltZSBzdXNwZW5kLgorICogT24gVmFsbGV5dmll dyBhbmQgQ2hlcnJ5dmlldyBzeXN0ZW1zLCB0aGlzIGFsc28gaGFwcGVucyB3aGVuIHdlIHNodXQg b2ZmIGFsbAorICogb2YgdGhlIHBvd2Vyd2VsbHMuCisgKgorICogU2luY2UgdGhpcyBmdW5jdGlv biBjYW4gZ2V0IGNhbGxlZCBpbiBjb250ZXh0cyB3aGVyZSB3ZSdyZSBhbHJlYWR5IGhvbGRpbmcK KyAqIGRldi0+bW9kZV9jb25maWcubXV0ZXgsIHdlIGRvIHRoZSBhY3R1YWwgaG90cGx1ZyBlbmFi bGluZyBpbiBhIHNlcGVyYXRlCisgKiB3b3JrZXIuCisgKgorICogQWxzbyBzZWU6IGludGVsX2hw ZF9pbml0KCksIHdoaWNoIHJlc3RvcmVzIGhwZCBoYW5kbGluZy4KKyAqLwordm9pZCBpbnRlbF9o cGRfcG9sbF9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKK3sKKwlXUklU RV9PTkNFKGRldl9wcml2LT5ob3RwbHVnLnBvbGxfZW5hYmxlZCwgdHJ1ZSk7CisKKwkvKgorCSAq IFdlIG1pZ2h0IGFscmVhZHkgYmUgaG9sZGluZyBkZXYtPm1vZGVfY29uZmlnLm11dGV4LCBzbyBk byB0aGlzIGluIGEKKwkgKiBzZXBlcmF0ZSB3b3JrZXIKKwkgKiBBcyB3ZWxsLCB0aGVyZSdzIG5v IGlzc3VlIGlmIHdlIHJhY2UgaGVyZSBzaW5jZSB3ZSBhbHdheXMgcmVzY2hlZHVsZQorCSAqIHRo aXMgd29ya2VyIGFueXdheQorCSAqLworCXNjaGVkdWxlX3dvcmsoJmRldl9wcml2LT5ob3RwbHVn LnBvbGxfaW5pdF93b3JrKTsKIH0KIAogdm9pZCBpbnRlbF9ocGRfaW5pdF93b3JrKHN0cnVjdCBk cm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIHsKIAlJTklUX1dPUksoJmRldl9wcml2LT5ob3Rw bHVnLmhvdHBsdWdfd29yaywgaTkxNV9ob3RwbHVnX3dvcmtfZnVuYyk7CiAJSU5JVF9XT1JLKCZk ZXZfcHJpdi0+aG90cGx1Zy5kaWdfcG9ydF93b3JrLCBpOTE1X2RpZ3BvcnRfd29ya19mdW5jKTsK KwlJTklUX1dPUksoJmRldl9wcml2LT5ob3RwbHVnLnBvbGxfaW5pdF93b3JrLCBpOTE1X2hwZF9w b2xsX2luaXRfd29yayk7CiAJSU5JVF9ERUxBWUVEX1dPUksoJmRldl9wcml2LT5ob3RwbHVnLnJl ZW5hYmxlX3dvcmssCiAJCQkgIGludGVsX2hwZF9pcnFfc3Rvcm1fcmVlbmFibGVfd29yayk7CiB9 CkBAIC01MDksNiArNTc0LDcgQEAgdm9pZCBpbnRlbF9ocGRfY2FuY2VsX3dvcmsoc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCiAJY2FuY2VsX3dvcmtfc3luYygmZGV2X3ByaXYt PmhvdHBsdWcuZGlnX3BvcnRfd29yayk7CiAJY2FuY2VsX3dvcmtfc3luYygmZGV2X3ByaXYtPmhv dHBsdWcuaG90cGx1Z193b3JrKTsKKwljYW5jZWxfd29ya19zeW5jKCZkZXZfcHJpdi0+aG90cGx1 Zy5wb2xsX2luaXRfd29yayk7CiAJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZkZXZfcHJpdi0+ aG90cGx1Zy5yZWVuYWJsZV93b3JrKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcnVudGltZV9wbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcnVu dGltZV9wbS5jCmluZGV4IDRhM2ZkM2EuLjI1OTJiMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3J1bnRpbWVfcG0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9ydW50aW1lX3BtLmMKQEAgLTEwMDcsNiArMTAwNyw4IEBAIHN0YXRpYyB2b2lkIHZsdl9k aXNwbGF5X3Bvd2VyX3dlbGxfZGVpbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKIAlzeW5jaHJvbml6ZV9pcnEoZGV2X3ByaXYtPmRldi0+aXJxKTsKIAogCXZsdl9wb3dlcl9z ZXF1ZW5jZXJfcmVzZXQoZGV2X3ByaXYpOworCisJaW50ZWxfaHBkX3BvbGxfaW5pdChkZXZfcHJp dik7CiB9CiAKIHN0YXRpYyB2b2lkIHZsdl9kaXNwbGF5X3Bvd2VyX3dlbGxfZW5hYmxlKHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKLS0gCjIuNy40CgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK