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=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 32C82C433E1 for ; Fri, 29 May 2020 17:57:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1EFF92075A for ; Fri, 29 May 2020 17:57:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728189AbgE2R5I (ORCPT ); Fri, 29 May 2020 13:57:08 -0400 Received: from asav22.altibox.net ([109.247.116.9]:39060 "EHLO asav22.altibox.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728178AbgE2R5H (ORCPT ); Fri, 29 May 2020 13:57:07 -0400 Received: from localhost.localdomain (unknown [81.166.168.211]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: noralf.tronnes@ebnett.no) by asav22.altibox.net (Postfix) with ESMTPSA id 973FA200CE; Fri, 29 May 2020 19:57:03 +0200 (CEST) From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= To: dri-devel@lists.freedesktop.org, balbi@kernel.org Cc: linux-usb@vger.kernel.org, sam@ravnborg.org, =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= Subject: [PATCH v3 3/6] drm/client: Add a way to set modeset, properties and rotation Date: Fri, 29 May 2020 19:56:40 +0200 Message-Id: <20200529175643.46094-4-noralf@tronnes.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20200529175643.46094-1-noralf@tronnes.org> References: <20200529175643.46094-1-noralf@tronnes.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CMAE-Score: 0 X-CMAE-Analysis: v=2.3 cv=LvK8NEVc c=1 sm=1 tr=0 a=OYZzhG0JTxDrWp/F2OJbnw==:117 a=OYZzhG0JTxDrWp/F2OJbnw==:17 a=IkcTkHD0fZMA:10 a=M51BFTxLslgA:10 a=SJz97ENfAAAA:8 a=M-TpJSvIHFVSw-O4hR8A:9 a=Se0h0s-PsaGxwzjN:21 a=KLOMj-mo1MvUhMRw:21 a=QEXdDO2ut3YA:10 a=vFet0B0WnEQeilDPIY6i:22 Sender: linux-usb-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org This adds functions for clients that need more control over the configuration than what's setup by drm_client_modeset_probe(). Connector, fb and display mode can be set using drm_client_modeset_set(). Plane rotation can be set using drm_client_modeset_set_rotation() and other properties using drm_client_modeset_set_property(). Property setting is only implemented for atomic drivers. v2: - drm_client_modeset_set(): Remove undocumented functionality to clear modesets. A disable function takes care of that need now. - drm_client_modeset_set_property(): Return -EOPNOTSUPP if driver is not atomic (Sam) Signed-off-by: Noralf Trønnes --- drivers/gpu/drm/drm_client_modeset.c | 137 +++++++++++++++++++++++++++ include/drm/drm_client.h | 38 +++++++- 2 files changed, 174 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/drm_client_modeset.c b/drivers/gpu/drm/drm_client_modeset.c index 977bcd063520..9eee9567b9aa 100644 --- a/drivers/gpu/drm/drm_client_modeset.c +++ b/drivers/gpu/drm/drm_client_modeset.c @@ -83,6 +83,10 @@ static void drm_client_modeset_release(struct drm_client_dev *client) } modeset->num_connectors = 0; } + + kfree(client->properties); + client->properties = NULL; + client->num_properties = 0; } void drm_client_modeset_free(struct drm_client_dev *client) @@ -879,6 +883,130 @@ int drm_client_modeset_probe(struct drm_client_dev *client, unsigned int width, } EXPORT_SYMBOL(drm_client_modeset_probe); +/** + * drm_client_modeset_set() - Set modeset configuration + * @client: DRM client + * @connector: Connector + * @mode: Display mode + * @fb: Framebuffer + * + * This function releases any current modeset info, including properties, and + * sets the new modeset in the client's modeset array. + * + * Returns: + * Zero on success or negative error code on failure. + */ +int drm_client_modeset_set(struct drm_client_dev *client, struct drm_connector *connector, + struct drm_display_mode *mode, struct drm_framebuffer *fb) +{ + struct drm_mode_set *modeset; + int ret = -ENOENT; + + mutex_lock(&client->modeset_mutex); + + drm_client_modeset_release(client); + + drm_client_for_each_modeset(modeset, client) { + if (!connector_has_possible_crtc(connector, modeset->crtc)) + continue; + + modeset->mode = drm_mode_duplicate(client->dev, mode); + if (!modeset->mode) { + ret = -ENOMEM; + break; + } + + drm_mode_set_crtcinfo(modeset->mode, CRTC_INTERLACE_HALVE_V); + + drm_connector_get(connector); + modeset->connectors[modeset->num_connectors++] = connector; + + modeset->fb = fb; + ret = 0; + break; + } + + mutex_unlock(&client->modeset_mutex); + + return ret; +} +EXPORT_SYMBOL(drm_client_modeset_set); + +/** + * drm_client_modeset_set_property() - Set a property on the current configuration + * @client: DRM client + * @obj: DRM Mode Object + * @prop: DRM Property + * @value: Property value + * + * Note: Currently only implemented for atomic drivers. + * + * Returns: + * Zero on success or negative error code on failure. + */ +int drm_client_modeset_set_property(struct drm_client_dev *client, struct drm_mode_object *obj, + struct drm_property *prop, u64 value) +{ + struct drm_client_property *properties; + int ret = 0; + + if (!prop) + return -EINVAL; + + if (!drm_drv_uses_atomic_modeset(client->dev)) + return -EOPNOTSUPP; + + mutex_lock(&client->modeset_mutex); + + properties = krealloc(client->properties, + (client->num_properties + 1) * sizeof(*properties), GFP_KERNEL); + if (!properties) { + ret = -ENOMEM; + goto unlock; + } + + properties[client->num_properties].obj = obj; + properties[client->num_properties].prop = prop; + properties[client->num_properties].value = value; + client->properties = properties; + client->num_properties++; +unlock: + mutex_unlock(&client->modeset_mutex); + + return ret; +} +EXPORT_SYMBOL(drm_client_modeset_set_property); + +/** + * drm_client_modeset_set_rotation() - Set rotation on the current configuration + * @client: DRM client + * @value: Rotation value + * + * Returns: + * Zero on success or negative error code on failure. + */ +int drm_client_modeset_set_rotation(struct drm_client_dev *client, u64 value) +{ + struct drm_plane *plane = NULL; + struct drm_mode_set *modeset; + + mutex_lock(&client->modeset_mutex); + drm_client_for_each_modeset(modeset, client) { + if (modeset->mode) { + plane = modeset->crtc->primary; + break; + } + } + mutex_unlock(&client->modeset_mutex); + + if (!plane) + return -ENOENT; + + return drm_client_modeset_set_property(client, &plane->base, + plane->rotation_property, value); +} +EXPORT_SYMBOL(drm_client_modeset_set_rotation); + /** * drm_client_rotation() - Check the initial rotation value * @modeset: DRM modeset @@ -973,6 +1101,7 @@ static int drm_client_modeset_commit_atomic(struct drm_client_dev *client, bool struct drm_atomic_state *state; struct drm_modeset_acquire_ctx ctx; struct drm_mode_set *mode_set; + unsigned int i; int ret; drm_modeset_acquire_init(&ctx, 0); @@ -1033,6 +1162,14 @@ static int drm_client_modeset_commit_atomic(struct drm_client_dev *client, bool } } + for (i = 0; i < client->num_properties; i++) { + struct drm_client_property *prop = &client->properties[i]; + + ret = drm_atomic_set_property(state, NULL, prop->obj, prop->prop, prop->value); + if (ret) + goto out_state; + } + if (check) ret = drm_atomic_check_only(state); else diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h index 498089b647da..bdcdc30519e6 100644 --- a/include/drm/drm_client.h +++ b/include/drm/drm_client.h @@ -16,6 +16,7 @@ struct drm_file; struct drm_framebuffer; struct drm_gem_object; struct drm_minor; +struct drm_property; struct module; /** @@ -64,6 +65,26 @@ struct drm_client_funcs { int (*hotplug)(struct drm_client_dev *client); }; +/** + * struct drm_client_property - DRM client property + */ +struct drm_client_property { + /** + * @obj: DRM Mode Object to which the property belongs. + */ + struct drm_mode_object *obj; + + /** + * @prop: DRM Property. + */ + struct drm_property *prop; + + /** + * @value: Property value. + */ + u64 value; +}; + /** * struct drm_client_dev - DRM client instance */ @@ -97,7 +118,7 @@ struct drm_client_dev { struct drm_file *file; /** - * @modeset_mutex: Protects @modesets. + * @modeset_mutex: Protects @modesets and @properties. */ struct mutex modeset_mutex; @@ -105,6 +126,16 @@ struct drm_client_dev { * @modesets: CRTC configurations */ struct drm_mode_set *modesets; + + /** + * @properties: DRM properties attached to the configuration. + */ + struct drm_client_property *properties; + + /** + * @num_properties: Number of attached properties. + */ + unsigned int num_properties; }; int drm_client_init(struct drm_device *dev, struct drm_client_dev *client, @@ -163,6 +194,11 @@ void drm_client_buffer_vunmap(struct drm_client_buffer *buffer); int drm_client_modeset_create(struct drm_client_dev *client); void drm_client_modeset_free(struct drm_client_dev *client); int drm_client_modeset_probe(struct drm_client_dev *client, unsigned int width, unsigned int height); +int drm_client_modeset_set(struct drm_client_dev *client, struct drm_connector *connector, + struct drm_display_mode *mode, struct drm_framebuffer *fb); +int drm_client_modeset_set_property(struct drm_client_dev *client, struct drm_mode_object *obj, + struct drm_property *prop, u64 value); +int drm_client_modeset_set_rotation(struct drm_client_dev *client, u64 value); bool drm_client_rotation(struct drm_mode_set *modeset, unsigned int *rotation); int drm_client_modeset_check(struct drm_client_dev *client); int drm_client_modeset_commit_locked(struct drm_client_dev *client); -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8CE8FC433E0 for ; Fri, 29 May 2020 17:57:13 +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 6A5D82073B for ; Fri, 29 May 2020 17:57:13 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6A5D82073B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=tronnes.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id A06C36E957; Fri, 29 May 2020 17:57:07 +0000 (UTC) Received: from asav22.altibox.net (asav22.altibox.net [109.247.116.9]) by gabe.freedesktop.org (Postfix) with ESMTPS id EBCE36E95B for ; Fri, 29 May 2020 17:57:05 +0000 (UTC) Received: from localhost.localdomain (unknown [81.166.168.211]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: noralf.tronnes@ebnett.no) by asav22.altibox.net (Postfix) with ESMTPSA id 973FA200CE; Fri, 29 May 2020 19:57:03 +0200 (CEST) From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= To: dri-devel@lists.freedesktop.org, balbi@kernel.org Subject: [PATCH v3 3/6] drm/client: Add a way to set modeset, properties and rotation Date: Fri, 29 May 2020 19:56:40 +0200 Message-Id: <20200529175643.46094-4-noralf@tronnes.org> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20200529175643.46094-1-noralf@tronnes.org> References: <20200529175643.46094-1-noralf@tronnes.org> MIME-Version: 1.0 X-CMAE-Score: 0 X-CMAE-Analysis: v=2.3 cv=LvK8NEVc c=1 sm=1 tr=0 a=OYZzhG0JTxDrWp/F2OJbnw==:117 a=OYZzhG0JTxDrWp/F2OJbnw==:17 a=IkcTkHD0fZMA:10 a=M51BFTxLslgA:10 a=SJz97ENfAAAA:8 a=M-TpJSvIHFVSw-O4hR8A:9 a=Se0h0s-PsaGxwzjN:21 a=KLOMj-mo1MvUhMRw:21 a=QEXdDO2ut3YA:10 a=vFet0B0WnEQeilDPIY6i:22 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-usb@vger.kernel.org, sam@ravnborg.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBhZGRzIGZ1bmN0aW9ucyBmb3IgY2xpZW50cyB0aGF0IG5lZWQgbW9yZSBjb250cm9sIG92 ZXIgdGhlCmNvbmZpZ3VyYXRpb24gdGhhbiB3aGF0J3Mgc2V0dXAgYnkgZHJtX2NsaWVudF9tb2Rl c2V0X3Byb2JlKCkuCkNvbm5lY3RvciwgZmIgYW5kIGRpc3BsYXkgbW9kZSBjYW4gYmUgc2V0IHVz aW5nIGRybV9jbGllbnRfbW9kZXNldF9zZXQoKS4KUGxhbmUgcm90YXRpb24gY2FuIGJlIHNldCB1 c2luZyBkcm1fY2xpZW50X21vZGVzZXRfc2V0X3JvdGF0aW9uKCkgYW5kCm90aGVyIHByb3BlcnRp ZXMgdXNpbmcgZHJtX2NsaWVudF9tb2Rlc2V0X3NldF9wcm9wZXJ0eSgpLiBQcm9wZXJ0eQpzZXR0 aW5nIGlzIG9ubHkgaW1wbGVtZW50ZWQgZm9yIGF0b21pYyBkcml2ZXJzLgoKdjI6Ci0gZHJtX2Ns aWVudF9tb2Rlc2V0X3NldCgpOiBSZW1vdmUgdW5kb2N1bWVudGVkIGZ1bmN0aW9uYWxpdHkgdG8g Y2xlYXIKICBtb2Rlc2V0cy4gQSBkaXNhYmxlIGZ1bmN0aW9uIHRha2VzIGNhcmUgb2YgdGhhdCBu ZWVkIG5vdy4KLSBkcm1fY2xpZW50X21vZGVzZXRfc2V0X3Byb3BlcnR5KCk6IFJldHVybiAtRU9Q Tk9UU1VQUCBpZiBkcml2ZXIgaXMgbm90CiAgYXRvbWljIChTYW0pCgpTaWduZWQtb2ZmLWJ5OiBO b3JhbGYgVHLDuG5uZXMgPG5vcmFsZkB0cm9ubmVzLm9yZz4KLS0tCiBkcml2ZXJzL2dwdS9kcm0v ZHJtX2NsaWVudF9tb2Rlc2V0LmMgfCAxMzcgKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBp bmNsdWRlL2RybS9kcm1fY2xpZW50LmggICAgICAgICAgICAgfCAgMzggKysrKysrKy0KIDIgZmls ZXMgY2hhbmdlZCwgMTc0IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vZHJtX2NsaWVudF9tb2Rlc2V0LmMgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2NsaWVudF9tb2Rlc2V0LmMKaW5kZXggOTc3YmNkMDYzNTIwLi45ZWVlOTU2N2I5YWEgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY2xpZW50X21vZGVzZXQuYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vZHJtX2NsaWVudF9tb2Rlc2V0LmMKQEAgLTgzLDYgKzgzLDEwIEBAIHN0YXRp YyB2b2lkIGRybV9jbGllbnRfbW9kZXNldF9yZWxlYXNlKHN0cnVjdCBkcm1fY2xpZW50X2RldiAq Y2xpZW50KQogCQl9CiAJCW1vZGVzZXQtPm51bV9jb25uZWN0b3JzID0gMDsKIAl9CisKKwlrZnJl ZShjbGllbnQtPnByb3BlcnRpZXMpOworCWNsaWVudC0+cHJvcGVydGllcyA9IE5VTEw7CisJY2xp ZW50LT5udW1fcHJvcGVydGllcyA9IDA7CiB9CiAKIHZvaWQgZHJtX2NsaWVudF9tb2Rlc2V0X2Zy ZWUoc3RydWN0IGRybV9jbGllbnRfZGV2ICpjbGllbnQpCkBAIC04NzksNiArODgzLDEzMCBAQCBp bnQgZHJtX2NsaWVudF9tb2Rlc2V0X3Byb2JlKHN0cnVjdCBkcm1fY2xpZW50X2RldiAqY2xpZW50 LCB1bnNpZ25lZCBpbnQgd2lkdGgsCiB9CiBFWFBPUlRfU1lNQk9MKGRybV9jbGllbnRfbW9kZXNl dF9wcm9iZSk7CiAKKy8qKgorICogZHJtX2NsaWVudF9tb2Rlc2V0X3NldCgpIC0gU2V0IG1vZGVz ZXQgY29uZmlndXJhdGlvbgorICogQGNsaWVudDogRFJNIGNsaWVudAorICogQGNvbm5lY3Rvcjog Q29ubmVjdG9yCisgKiBAbW9kZTogRGlzcGxheSBtb2RlCisgKiBAZmI6IEZyYW1lYnVmZmVyCisg KgorICogVGhpcyBmdW5jdGlvbiByZWxlYXNlcyBhbnkgY3VycmVudCBtb2Rlc2V0IGluZm8sIGlu Y2x1ZGluZyBwcm9wZXJ0aWVzLCBhbmQKKyAqIHNldHMgdGhlIG5ldyBtb2Rlc2V0IGluIHRoZSBj bGllbnQncyBtb2Rlc2V0IGFycmF5LgorICoKKyAqIFJldHVybnM6CisgKiBaZXJvIG9uIHN1Y2Nl c3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgZHJtX2NsaWVu dF9tb2Rlc2V0X3NldChzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgc3RydWN0IGRybV9j b25uZWN0b3IgKmNvbm5lY3RvciwKKwkJCSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2Rl LCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYikKK3sKKwlzdHJ1Y3QgZHJtX21vZGVfc2V0ICpt b2Rlc2V0OworCWludCByZXQgPSAtRU5PRU5UOworCisJbXV0ZXhfbG9jaygmY2xpZW50LT5tb2Rl c2V0X211dGV4KTsKKworCWRybV9jbGllbnRfbW9kZXNldF9yZWxlYXNlKGNsaWVudCk7CisKKwlk cm1fY2xpZW50X2Zvcl9lYWNoX21vZGVzZXQobW9kZXNldCwgY2xpZW50KSB7CisJCWlmICghY29u bmVjdG9yX2hhc19wb3NzaWJsZV9jcnRjKGNvbm5lY3RvciwgbW9kZXNldC0+Y3J0YykpCisJCQlj b250aW51ZTsKKworCQltb2Rlc2V0LT5tb2RlID0gZHJtX21vZGVfZHVwbGljYXRlKGNsaWVudC0+ ZGV2LCBtb2RlKTsKKwkJaWYgKCFtb2Rlc2V0LT5tb2RlKSB7CisJCQlyZXQgPSAtRU5PTUVNOwor CQkJYnJlYWs7CisJCX0KKworCQlkcm1fbW9kZV9zZXRfY3J0Y2luZm8obW9kZXNldC0+bW9kZSwg Q1JUQ19JTlRFUkxBQ0VfSEFMVkVfVik7CisKKwkJZHJtX2Nvbm5lY3Rvcl9nZXQoY29ubmVjdG9y KTsKKwkJbW9kZXNldC0+Y29ubmVjdG9yc1ttb2Rlc2V0LT5udW1fY29ubmVjdG9ycysrXSA9IGNv bm5lY3RvcjsKKworCQltb2Rlc2V0LT5mYiA9IGZiOworCQlyZXQgPSAwOworCQlicmVhazsKKwl9 CisKKwltdXRleF91bmxvY2soJmNsaWVudC0+bW9kZXNldF9tdXRleCk7CisKKwlyZXR1cm4gcmV0 OworfQorRVhQT1JUX1NZTUJPTChkcm1fY2xpZW50X21vZGVzZXRfc2V0KTsKKworLyoqCisgKiBk cm1fY2xpZW50X21vZGVzZXRfc2V0X3Byb3BlcnR5KCkgLSBTZXQgYSBwcm9wZXJ0eSBvbiB0aGUg Y3VycmVudCBjb25maWd1cmF0aW9uCisgKiBAY2xpZW50OiBEUk0gY2xpZW50CisgKiBAb2JqOiBE Uk0gTW9kZSBPYmplY3QKKyAqIEBwcm9wOiBEUk0gUHJvcGVydHkKKyAqIEB2YWx1ZTogUHJvcGVy dHkgdmFsdWUKKyAqCisgKiBOb3RlOiBDdXJyZW50bHkgb25seSBpbXBsZW1lbnRlZCBmb3IgYXRv bWljIGRyaXZlcnMuCisgKgorICogUmV0dXJuczoKKyAqIFplcm8gb24gc3VjY2VzcyBvciBuZWdh dGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisgKi8KK2ludCBkcm1fY2xpZW50X21vZGVzZXRf c2V0X3Byb3BlcnR5KHN0cnVjdCBkcm1fY2xpZW50X2RldiAqY2xpZW50LCBzdHJ1Y3QgZHJtX21v ZGVfb2JqZWN0ICpvYmosCisJCQkJICAgIHN0cnVjdCBkcm1fcHJvcGVydHkgKnByb3AsIHU2NCB2 YWx1ZSkKK3sKKwlzdHJ1Y3QgZHJtX2NsaWVudF9wcm9wZXJ0eSAqcHJvcGVydGllczsKKwlpbnQg cmV0ID0gMDsKKworCWlmICghcHJvcCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoIWRybV9k cnZfdXNlc19hdG9taWNfbW9kZXNldChjbGllbnQtPmRldikpCisJCXJldHVybiAtRU9QTk9UU1VQ UDsKKworCW11dGV4X2xvY2soJmNsaWVudC0+bW9kZXNldF9tdXRleCk7CisKKwlwcm9wZXJ0aWVz ID0ga3JlYWxsb2MoY2xpZW50LT5wcm9wZXJ0aWVzLAorCQkJICAgICAgKGNsaWVudC0+bnVtX3By b3BlcnRpZXMgKyAxKSAqIHNpemVvZigqcHJvcGVydGllcyksIEdGUF9LRVJORUwpOworCWlmICgh cHJvcGVydGllcykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIHVubG9jazsKKwl9CisKKwlw cm9wZXJ0aWVzW2NsaWVudC0+bnVtX3Byb3BlcnRpZXNdLm9iaiA9IG9iajsKKwlwcm9wZXJ0aWVz W2NsaWVudC0+bnVtX3Byb3BlcnRpZXNdLnByb3AgPSBwcm9wOworCXByb3BlcnRpZXNbY2xpZW50 LT5udW1fcHJvcGVydGllc10udmFsdWUgPSB2YWx1ZTsKKwljbGllbnQtPnByb3BlcnRpZXMgPSBw cm9wZXJ0aWVzOworCWNsaWVudC0+bnVtX3Byb3BlcnRpZXMrKzsKK3VubG9jazoKKwltdXRleF91 bmxvY2soJmNsaWVudC0+bW9kZXNldF9tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JU X1NZTUJPTChkcm1fY2xpZW50X21vZGVzZXRfc2V0X3Byb3BlcnR5KTsKKworLyoqCisgKiBkcm1f Y2xpZW50X21vZGVzZXRfc2V0X3JvdGF0aW9uKCkgLSBTZXQgcm90YXRpb24gb24gdGhlIGN1cnJl bnQgY29uZmlndXJhdGlvbgorICogQGNsaWVudDogRFJNIGNsaWVudAorICogQHZhbHVlOiBSb3Rh dGlvbiB2YWx1ZQorICoKKyAqIFJldHVybnM6CisgKiBaZXJvIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRp dmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgZHJtX2NsaWVudF9tb2Rlc2V0X3Nl dF9yb3RhdGlvbihzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgdTY0IHZhbHVlKQorewor CXN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lID0gTlVMTDsKKwlzdHJ1Y3QgZHJtX21vZGVfc2V0ICpt b2Rlc2V0OworCisJbXV0ZXhfbG9jaygmY2xpZW50LT5tb2Rlc2V0X211dGV4KTsKKwlkcm1fY2xp ZW50X2Zvcl9lYWNoX21vZGVzZXQobW9kZXNldCwgY2xpZW50KSB7CisJCWlmIChtb2Rlc2V0LT5t b2RlKSB7CisJCQlwbGFuZSA9IG1vZGVzZXQtPmNydGMtPnByaW1hcnk7CisJCQlicmVhazsKKwkJ fQorCX0KKwltdXRleF91bmxvY2soJmNsaWVudC0+bW9kZXNldF9tdXRleCk7CisKKwlpZiAoIXBs YW5lKQorCQlyZXR1cm4gLUVOT0VOVDsKKworCXJldHVybiBkcm1fY2xpZW50X21vZGVzZXRfc2V0 X3Byb3BlcnR5KGNsaWVudCwgJnBsYW5lLT5iYXNlLAorCQkJCQkgICAgICAgcGxhbmUtPnJvdGF0 aW9uX3Byb3BlcnR5LCB2YWx1ZSk7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9jbGllbnRfbW9kZXNl dF9zZXRfcm90YXRpb24pOworCiAvKioKICAqIGRybV9jbGllbnRfcm90YXRpb24oKSAtIENoZWNr IHRoZSBpbml0aWFsIHJvdGF0aW9uIHZhbHVlCiAgKiBAbW9kZXNldDogRFJNIG1vZGVzZXQKQEAg LTk3Myw2ICsxMTAxLDcgQEAgc3RhdGljIGludCBkcm1fY2xpZW50X21vZGVzZXRfY29tbWl0X2F0 b21pYyhzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgYm9vbAogCXN0cnVjdCBkcm1fYXRv bWljX3N0YXRlICpzdGF0ZTsKIAlzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHggY3R4Owog CXN0cnVjdCBkcm1fbW9kZV9zZXQgKm1vZGVfc2V0OworCXVuc2lnbmVkIGludCBpOwogCWludCBy ZXQ7CiAKIAlkcm1fbW9kZXNldF9hY3F1aXJlX2luaXQoJmN0eCwgMCk7CkBAIC0xMDMzLDYgKzEx NjIsMTQgQEAgc3RhdGljIGludCBkcm1fY2xpZW50X21vZGVzZXRfY29tbWl0X2F0b21pYyhzdHJ1 Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgYm9vbAogCQl9CiAJfQogCisJZm9yIChpID0gMDsg aSA8IGNsaWVudC0+bnVtX3Byb3BlcnRpZXM7IGkrKykgeworCQlzdHJ1Y3QgZHJtX2NsaWVudF9w cm9wZXJ0eSAqcHJvcCA9ICZjbGllbnQtPnByb3BlcnRpZXNbaV07CisKKwkJcmV0ID0gZHJtX2F0 b21pY19zZXRfcHJvcGVydHkoc3RhdGUsIE5VTEwsIHByb3AtPm9iaiwgcHJvcC0+cHJvcCwgcHJv cC0+dmFsdWUpOworCQlpZiAocmV0KQorCQkJZ290byBvdXRfc3RhdGU7CisJfQorCiAJaWYgKGNo ZWNrKQogCQlyZXQgPSBkcm1fYXRvbWljX2NoZWNrX29ubHkoc3RhdGUpOwogCWVsc2UKZGlmZiAt LWdpdCBhL2luY2x1ZGUvZHJtL2RybV9jbGllbnQuaCBiL2luY2x1ZGUvZHJtL2RybV9jbGllbnQu aAppbmRleCA0OTgwODliNjQ3ZGEuLmJkY2RjMzA1MTllNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9k cm0vZHJtX2NsaWVudC5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9jbGllbnQuaApAQCAtMTYsNiAr MTYsNyBAQCBzdHJ1Y3QgZHJtX2ZpbGU7CiBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyOwogc3RydWN0 IGRybV9nZW1fb2JqZWN0Owogc3RydWN0IGRybV9taW5vcjsKK3N0cnVjdCBkcm1fcHJvcGVydHk7 CiBzdHJ1Y3QgbW9kdWxlOwogCiAvKioKQEAgLTY0LDYgKzY1LDI2IEBAIHN0cnVjdCBkcm1fY2xp ZW50X2Z1bmNzIHsKIAlpbnQgKCpob3RwbHVnKShzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVu dCk7CiB9OwogCisvKioKKyAqIHN0cnVjdCBkcm1fY2xpZW50X3Byb3BlcnR5IC0gRFJNIGNsaWVu dCBwcm9wZXJ0eQorICovCitzdHJ1Y3QgZHJtX2NsaWVudF9wcm9wZXJ0eSB7CisJLyoqCisJICog QG9iajogRFJNIE1vZGUgT2JqZWN0IHRvIHdoaWNoIHRoZSBwcm9wZXJ0eSBiZWxvbmdzLgorCSAq LworCXN0cnVjdCBkcm1fbW9kZV9vYmplY3QgKm9iajsKKworCS8qKgorCSAqIEBwcm9wOiBEUk0g UHJvcGVydHkuCisJICovCisJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcDsKKworCS8qKgorCSAq IEB2YWx1ZTogUHJvcGVydHkgdmFsdWUuCisJICovCisJdTY0IHZhbHVlOworfTsKKwogLyoqCiAg KiBzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgLSBEUk0gY2xpZW50IGluc3RhbmNlCiAgKi8KQEAgLTk3 LDcgKzExOCw3IEBAIHN0cnVjdCBkcm1fY2xpZW50X2RldiB7CiAJc3RydWN0IGRybV9maWxlICpm aWxlOwogCiAJLyoqCi0JICogQG1vZGVzZXRfbXV0ZXg6IFByb3RlY3RzIEBtb2Rlc2V0cy4KKwkg KiBAbW9kZXNldF9tdXRleDogUHJvdGVjdHMgQG1vZGVzZXRzIGFuZCBAcHJvcGVydGllcy4KIAkg Ki8KIAlzdHJ1Y3QgbXV0ZXggbW9kZXNldF9tdXRleDsKIApAQCAtMTA1LDYgKzEyNiwxNiBAQCBz dHJ1Y3QgZHJtX2NsaWVudF9kZXYgewogCSAqIEBtb2Rlc2V0czogQ1JUQyBjb25maWd1cmF0aW9u cwogCSAqLwogCXN0cnVjdCBkcm1fbW9kZV9zZXQgKm1vZGVzZXRzOworCisJLyoqCisJICogQHBy b3BlcnRpZXM6IERSTSBwcm9wZXJ0aWVzIGF0dGFjaGVkIHRvIHRoZSBjb25maWd1cmF0aW9uLgor CSAqLworCXN0cnVjdCBkcm1fY2xpZW50X3Byb3BlcnR5ICpwcm9wZXJ0aWVzOworCisJLyoqCisJ ICogQG51bV9wcm9wZXJ0aWVzOiBOdW1iZXIgb2YgYXR0YWNoZWQgcHJvcGVydGllcy4KKwkgKi8K Kwl1bnNpZ25lZCBpbnQgbnVtX3Byb3BlcnRpZXM7CiB9OwogCiBpbnQgZHJtX2NsaWVudF9pbml0 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fY2xpZW50X2RldiAqY2xpZW50LApA QCAtMTYzLDYgKzE5NCwxMSBAQCB2b2lkIGRybV9jbGllbnRfYnVmZmVyX3Z1bm1hcChzdHJ1Y3Qg ZHJtX2NsaWVudF9idWZmZXIgKmJ1ZmZlcik7CiBpbnQgZHJtX2NsaWVudF9tb2Rlc2V0X2NyZWF0 ZShzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCk7CiB2b2lkIGRybV9jbGllbnRfbW9kZXNl dF9mcmVlKHN0cnVjdCBkcm1fY2xpZW50X2RldiAqY2xpZW50KTsKIGludCBkcm1fY2xpZW50X21v ZGVzZXRfcHJvYmUoc3RydWN0IGRybV9jbGllbnRfZGV2ICpjbGllbnQsIHVuc2lnbmVkIGludCB3 aWR0aCwgdW5zaWduZWQgaW50IGhlaWdodCk7CitpbnQgZHJtX2NsaWVudF9tb2Rlc2V0X3NldChz dHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5l Y3RvciwKKwkJCSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLCBzdHJ1Y3QgZHJtX2Zy YW1lYnVmZmVyICpmYik7CitpbnQgZHJtX2NsaWVudF9tb2Rlc2V0X3NldF9wcm9wZXJ0eShzdHJ1 Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCwgc3RydWN0IGRybV9tb2RlX29iamVjdCAqb2JqLAor CQkJCSAgICBzdHJ1Y3QgZHJtX3Byb3BlcnR5ICpwcm9wLCB1NjQgdmFsdWUpOworaW50IGRybV9j bGllbnRfbW9kZXNldF9zZXRfcm90YXRpb24oc3RydWN0IGRybV9jbGllbnRfZGV2ICpjbGllbnQs IHU2NCB2YWx1ZSk7CiBib29sIGRybV9jbGllbnRfcm90YXRpb24oc3RydWN0IGRybV9tb2RlX3Nl dCAqbW9kZXNldCwgdW5zaWduZWQgaW50ICpyb3RhdGlvbik7CiBpbnQgZHJtX2NsaWVudF9tb2Rl c2V0X2NoZWNrKHN0cnVjdCBkcm1fY2xpZW50X2RldiAqY2xpZW50KTsKIGludCBkcm1fY2xpZW50 X21vZGVzZXRfY29tbWl0X2xvY2tlZChzdHJ1Y3QgZHJtX2NsaWVudF9kZXYgKmNsaWVudCk7Ci0t IAoyLjIzLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=