From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V5 1/6] mdev: class id support Date: Wed, 23 Oct 2019 21:07:47 +0800 Message-ID: <20191023130752.18980-2-jasowang@redhat.com> References: <20191023130752.18980-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <20191023130752.18980-1-jasowang@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: virtualization-bounces@lists.linux-foundation.org Errors-To: virtualization-bounces@lists.linux-foundation.org To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, joonas.lahtinen@linux.intel.com, heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, zhi.a.wang@intel.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, zhenyuw@linux.intel.com, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, jani.nikula@linux.intel.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, daniel@ffwll.ch, lingshan.zhu@intel.com List-Id: intel-gfx@lists.freedesktop.org Mdev bus only supports vfio driver right now, so it doesn't implement match method. But in the future, we may add drivers other than vfio, the first driver could be virtio-mdev. This means we need to add device class id support in bus match method to pair the mdev device and mdev driver correctly. So this patch adds id_table to mdev_driver and class_id for mdev device with the match method for mdev bus. Signed-off-by: Jason Wang --- .../driver-api/vfio-mediated-device.rst | 5 +++++ drivers/gpu/drm/i915/gvt/kvmgt.c | 1 + drivers/s390/cio/vfio_ccw_ops.c | 1 + drivers/s390/crypto/vfio_ap_ops.c | 1 + drivers/vfio/mdev/mdev_core.c | 18 +++++++++++++++ drivers/vfio/mdev/mdev_driver.c | 22 +++++++++++++++++++ drivers/vfio/mdev/mdev_private.h | 1 + drivers/vfio/mdev/vfio_mdev.c | 6 +++++ include/linux/mdev.h | 8 +++++++ include/linux/mod_devicetable.h | 8 +++++++ samples/vfio-mdev/mbochs.c | 1 + samples/vfio-mdev/mdpy.c | 1 + samples/vfio-mdev/mtty.c | 1 + 13 files changed, 74 insertions(+) diff --git a/Documentation/driver-api/vfio-mediated-device.rst b/Documentation/driver-api/vfio-mediated-device.rst index 25eb7d5b834b..6709413bee29 100644 --- a/Documentation/driver-api/vfio-mediated-device.rst +++ b/Documentation/driver-api/vfio-mediated-device.rst @@ -102,12 +102,14 @@ structure to represent a mediated device's driver:: * @probe: called when new device created * @remove: called when device removed * @driver: device driver structure + * @id_table: the ids serviced by this driver */ struct mdev_driver { const char *name; int (*probe) (struct device *dev); void (*remove) (struct device *dev); struct device_driver driver; + const struct mdev_class_id *id_table; }; A mediated bus driver for mdev should use this structure in the function calls @@ -170,6 +172,9 @@ that a driver should use to unregister itself with the mdev core driver:: extern void mdev_unregister_device(struct device *dev); +It is also required to specify the class_id in create() callback through:: + + int mdev_set_class(struct mdev_device *mdev, u16 id); Mediated Device Management Interface Through sysfs ================================================== diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c index 343d79c1cb7e..6420f0dbd31b 100644 --- a/drivers/gpu/drm/i915/gvt/kvmgt.c +++ b/drivers/gpu/drm/i915/gvt/kvmgt.c @@ -678,6 +678,7 @@ static int intel_vgpu_create(struct kobject *kobj, struct mdev_device *mdev) dev_name(mdev_dev(mdev))); ret = 0; + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); out: return ret; } diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_ops.c index f0d71ab77c50..cf2c013ae32f 100644 --- a/drivers/s390/cio/vfio_ccw_ops.c +++ b/drivers/s390/cio/vfio_ccw_ops.c @@ -129,6 +129,7 @@ static int vfio_ccw_mdev_create(struct kobject *kobj, struct mdev_device *mdev) private->sch->schid.ssid, private->sch->schid.sch_no); + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); return 0; } diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c index 5c0f53c6dde7..07c31070afeb 100644 --- a/drivers/s390/crypto/vfio_ap_ops.c +++ b/drivers/s390/crypto/vfio_ap_ops.c @@ -343,6 +343,7 @@ static int vfio_ap_mdev_create(struct kobject *kobj, struct mdev_device *mdev) list_add(&matrix_mdev->node, &matrix_dev->mdev_list); mutex_unlock(&matrix_dev->lock); + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); return 0; } diff --git a/drivers/vfio/mdev/mdev_core.c b/drivers/vfio/mdev/mdev_core.c index b558d4cfd082..3a9c52d71b4e 100644 --- a/drivers/vfio/mdev/mdev_core.c +++ b/drivers/vfio/mdev/mdev_core.c @@ -45,6 +45,16 @@ void mdev_set_drvdata(struct mdev_device *mdev, void *data) } EXPORT_SYMBOL(mdev_set_drvdata); +/* Specify the class for the mdev device, this must be called during + * create() callback. + */ +void mdev_set_class(struct mdev_device *mdev, u16 id) +{ + WARN_ON(mdev->class_id); + mdev->class_id = id; +} +EXPORT_SYMBOL(mdev_set_class); + struct device *mdev_dev(struct mdev_device *mdev) { return &mdev->dev; @@ -135,6 +145,7 @@ static int mdev_device_remove_cb(struct device *dev, void *data) * mdev_register_device : Register a device * @dev: device structure representing parent device. * @ops: Parent device operation structure to be registered. + * @id: class id. * * Add device to list of registered parent devices. * Returns a negative value on error, otherwise 0. @@ -324,6 +335,13 @@ int mdev_device_create(struct kobject *kobj, if (ret) goto ops_create_fail; + if (!mdev->class_id) { + ret = -EINVAL; + WARN(1, "class id must be specified for device %s\n", + dev_name(dev)); + goto add_fail; + } + ret = device_add(&mdev->dev); if (ret) goto add_fail; diff --git a/drivers/vfio/mdev/mdev_driver.c b/drivers/vfio/mdev/mdev_driver.c index 0d3223aee20b..319d886ffaf7 100644 --- a/drivers/vfio/mdev/mdev_driver.c +++ b/drivers/vfio/mdev/mdev_driver.c @@ -69,8 +69,30 @@ static int mdev_remove(struct device *dev) return 0; } +static int mdev_match(struct device *dev, struct device_driver *drv) +{ + unsigned int i; + struct mdev_device *mdev = to_mdev_device(dev); + struct mdev_driver *mdrv = to_mdev_driver(drv); + const struct mdev_class_id *ids = mdrv->id_table; + + for (i = 0; ids[i].id; i++) + if (ids[i].id == mdev->class_id) + return 1; + return 0; +} + +static int mdev_uevent(struct device *dev, struct kobj_uevent_env *env) +{ + struct mdev_device *mdev = to_mdev_device(dev); + + return add_uevent_var(env, "MODALIAS=mdev:c%02X", mdev->class_id); +} + struct bus_type mdev_bus_type = { .name = "mdev", + .match = mdev_match, + .uevent = mdev_uevent, .probe = mdev_probe, .remove = mdev_remove, }; diff --git a/drivers/vfio/mdev/mdev_private.h b/drivers/vfio/mdev/mdev_private.h index 7d922950caaf..c65f436c1869 100644 --- a/drivers/vfio/mdev/mdev_private.h +++ b/drivers/vfio/mdev/mdev_private.h @@ -33,6 +33,7 @@ struct mdev_device { struct kobject *type_kobj; struct device *iommu_device; bool active; + u16 class_id; }; #define to_mdev_device(dev) container_of(dev, struct mdev_device, dev) diff --git a/drivers/vfio/mdev/vfio_mdev.c b/drivers/vfio/mdev/vfio_mdev.c index 30964a4e0a28..7b24ee9cb8dd 100644 --- a/drivers/vfio/mdev/vfio_mdev.c +++ b/drivers/vfio/mdev/vfio_mdev.c @@ -120,10 +120,16 @@ static void vfio_mdev_remove(struct device *dev) vfio_del_group_dev(dev); } +static const struct mdev_class_id id_table[] = { + { MDEV_CLASS_ID_VFIO }, + { 0 }, +}; + static struct mdev_driver vfio_mdev_driver = { .name = "vfio_mdev", .probe = vfio_mdev_probe, .remove = vfio_mdev_remove, + .id_table = id_table, }; static int __init vfio_mdev_init(void) diff --git a/include/linux/mdev.h b/include/linux/mdev.h index 0ce30ca78db0..78b69d09eb54 100644 --- a/include/linux/mdev.h +++ b/include/linux/mdev.h @@ -118,6 +118,7 @@ struct mdev_type_attribute mdev_type_attr_##_name = \ * @probe: called when new device created * @remove: called when device removed * @driver: device driver structure + * @id_table: the ids serviced by this driver * **/ struct mdev_driver { @@ -125,6 +126,7 @@ struct mdev_driver { int (*probe)(struct device *dev); void (*remove)(struct device *dev); struct device_driver driver; + const struct mdev_class_id *id_table; }; #define to_mdev_driver(drv) container_of(drv, struct mdev_driver, driver) @@ -132,6 +134,7 @@ struct mdev_driver { void *mdev_get_drvdata(struct mdev_device *mdev); void mdev_set_drvdata(struct mdev_device *mdev, void *data); const guid_t *mdev_uuid(struct mdev_device *mdev); +void mdev_set_class(struct mdev_device *mdev, u16 id); extern struct bus_type mdev_bus_type; @@ -145,4 +148,9 @@ struct device *mdev_parent_dev(struct mdev_device *mdev); struct device *mdev_dev(struct mdev_device *mdev); struct mdev_device *mdev_from_dev(struct device *dev); +enum { + MDEV_CLASS_ID_VFIO = 1, + /* New entries must be added here */ +}; + #endif /* MDEV_H */ diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h index 5714fd35a83c..f32c6e44fb1a 100644 --- a/include/linux/mod_devicetable.h +++ b/include/linux/mod_devicetable.h @@ -821,4 +821,12 @@ struct wmi_device_id { const void *context; }; +/** + * struct mdev_class_id - MDEV device class identifier + * @id: Used to identify a specific class of device, e.g vfio-mdev device. + */ +struct mdev_class_id { + __u16 id; +}; + #endif /* LINUX_MOD_DEVICETABLE_H */ diff --git a/samples/vfio-mdev/mbochs.c b/samples/vfio-mdev/mbochs.c index ac5c8c17b1ff..115bc5074656 100644 --- a/samples/vfio-mdev/mbochs.c +++ b/samples/vfio-mdev/mbochs.c @@ -561,6 +561,7 @@ static int mbochs_create(struct kobject *kobj, struct mdev_device *mdev) mbochs_reset(mdev); mbochs_used_mbytes += type->mbytes; + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); return 0; err_mem: diff --git a/samples/vfio-mdev/mdpy.c b/samples/vfio-mdev/mdpy.c index cc86bf6566e4..665614574d50 100644 --- a/samples/vfio-mdev/mdpy.c +++ b/samples/vfio-mdev/mdpy.c @@ -269,6 +269,7 @@ static int mdpy_create(struct kobject *kobj, struct mdev_device *mdev) mdpy_reset(mdev); mdpy_count++; + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); return 0; } diff --git a/samples/vfio-mdev/mtty.c b/samples/vfio-mdev/mtty.c index ce84a300a4da..90da12ff7fd9 100644 --- a/samples/vfio-mdev/mtty.c +++ b/samples/vfio-mdev/mtty.c @@ -755,6 +755,7 @@ static int mtty_create(struct kobject *kobj, struct mdev_device *mdev) list_add(&mdev_state->next, &mdev_devices_list); mutex_unlock(&mdev_list_lock); + mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); return 0; } -- 2.19.1 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=-6.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,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 6AE01C47E49 for ; Wed, 23 Oct 2019 13:14:31 +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 4AB4721906 for ; Wed, 23 Oct 2019 13:14:31 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4AB4721906 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 238106EA9A; Wed, 23 Oct 2019 13:14:30 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6EAC96EA9A for ; Wed, 23 Oct 2019 13:14:28 +0000 (UTC) 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-295-p1Bzi35XNCiDsbI1W_34VA-1; Wed, 23 Oct 2019 09:14:23 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 5AA7B800D58; Wed, 23 Oct 2019 13:14:17 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-126.pek2.redhat.com [10.72.12.126]) by smtp.corp.redhat.com (Postfix) with ESMTP id 90B7460161; Wed, 23 Oct 2019 13:11:00 +0000 (UTC) From: Jason Wang To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Date: Wed, 23 Oct 2019 21:07:47 +0800 Message-Id: <20191023130752.18980-2-jasowang@redhat.com> In-Reply-To: <20191023130752.18980-1-jasowang@redhat.com> References: <20191023130752.18980-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-MC-Unique: p1Bzi35XNCiDsbI1W_34VA-1 X-Mimecast-Spam-Score: 0 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1571836467; 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=TjCPajc4CEGR5rS6ag/k9ArXmJclaoe4P99dbfRjJ0k=; b=FFzYOHOp5bgyHv0UgvTqBFGERcfrWY5YIROkg1QANj2GybafZtrmKe1680U4G+H24Ghz6Y mO2Yz0wBjfsBX6lcXr5FZpdSPO0qofxjmsll8qcN50SXCv0LVx4Ss5CWnW8OlnGu3GbDLZ nVESK3Mlw3hvDFsd3USaekz2a6OnFTo= Subject: [Intel-gfx] [PATCH V5 1/6] mdev: class id support X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Message-ID: <20191023130747.Soj8tRTDpRF67HwFn-n8H4jF5B-xJkaLWKeTwGPvoCk@z> TWRldiBidXMgb25seSBzdXBwb3J0cyB2ZmlvIGRyaXZlciByaWdodCBub3csIHNvIGl0IGRvZXNu J3QgaW1wbGVtZW50Cm1hdGNoIG1ldGhvZC4gQnV0IGluIHRoZSBmdXR1cmUsIHdlIG1heSBhZGQg ZHJpdmVycyBvdGhlciB0aGFuIHZmaW8sCnRoZSBmaXJzdCBkcml2ZXIgY291bGQgYmUgdmlydGlv LW1kZXYuIFRoaXMgbWVhbnMgd2UgbmVlZCB0byBhZGQKZGV2aWNlIGNsYXNzIGlkIHN1cHBvcnQg aW4gYnVzIG1hdGNoIG1ldGhvZCB0byBwYWlyIHRoZSBtZGV2IGRldmljZQphbmQgbWRldiBkcml2 ZXIgY29ycmVjdGx5LgoKU28gdGhpcyBwYXRjaCBhZGRzIGlkX3RhYmxlIHRvIG1kZXZfZHJpdmVy IGFuZCBjbGFzc19pZCBmb3IgbWRldgpkZXZpY2Ugd2l0aCB0aGUgbWF0Y2ggbWV0aG9kIGZvciBt ZGV2IGJ1cy4KClNpZ25lZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+ Ci0tLQogLi4uL2RyaXZlci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0ICAgICAgIHwgIDUg KysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jICAgICAgICAgICAgICB8ICAx ICsKIGRyaXZlcnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMgICAgICAgICAgICAgICB8ICAxICsK IGRyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMuYyAgICAgICAgICAgICB8ICAxICsKIGRy aXZlcnMvdmZpby9tZGV2L21kZXZfY29yZS5jICAgICAgICAgICAgICAgICB8IDE4ICsrKysrKysr KysrKysrKwogZHJpdmVycy92ZmlvL21kZXYvbWRldl9kcml2ZXIuYyAgICAgICAgICAgICAgIHwg MjIgKysrKysrKysrKysrKysrKysrKwogZHJpdmVycy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmgg ICAgICAgICAgICAgIHwgIDEgKwogZHJpdmVycy92ZmlvL21kZXYvdmZpb19tZGV2LmMgICAgICAg ICAgICAgICAgIHwgIDYgKysrKysKIGluY2x1ZGUvbGludXgvbWRldi5oICAgICAgICAgICAgICAg ICAgICAgICAgICB8ICA4ICsrKysrKysKIGluY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmgg ICAgICAgICAgICAgICB8ICA4ICsrKysrKysKIHNhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5jICAg ICAgICAgICAgICAgICAgICB8ICAxICsKIHNhbXBsZXMvdmZpby1tZGV2L21kcHkuYyAgICAgICAg ICAgICAgICAgICAgICB8ICAxICsKIHNhbXBsZXMvdmZpby1tZGV2L210dHkuYyAgICAgICAgICAg ICAgICAgICAgICB8ICAxICsKIDEzIGZpbGVzIGNoYW5nZWQsIDc0IGluc2VydGlvbnMoKykKCmRp ZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2Uu cnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL3ZmaW8tbWVkaWF0ZWQtZGV2aWNlLnJzdApp bmRleCAyNWViN2Q1YjgzNGIuLjY3MDk0MTNiZWUyOSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlv bi9kcml2ZXItYXBpL3ZmaW8tbWVkaWF0ZWQtZGV2aWNlLnJzdAorKysgYi9Eb2N1bWVudGF0aW9u L2RyaXZlci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0CkBAIC0xMDIsMTIgKzEwMiwxNCBA QCBzdHJ1Y3R1cmUgdG8gcmVwcmVzZW50IGEgbWVkaWF0ZWQgZGV2aWNlJ3MgZHJpdmVyOjoKICAg ICAgICogQHByb2JlOiBjYWxsZWQgd2hlbiBuZXcgZGV2aWNlIGNyZWF0ZWQKICAgICAgICogQHJl bW92ZTogY2FsbGVkIHdoZW4gZGV2aWNlIHJlbW92ZWQKICAgICAgICogQGRyaXZlcjogZGV2aWNl IGRyaXZlciBzdHJ1Y3R1cmUKKyAgICAgICogQGlkX3RhYmxlOiB0aGUgaWRzIHNlcnZpY2VkIGJ5 IHRoaXMgZHJpdmVyCiAgICAgICAqLwogICAgICBzdHJ1Y3QgbWRldl9kcml2ZXIgewogCSAgICAg Y29uc3QgY2hhciAqbmFtZTsKIAkgICAgIGludCAgKCpwcm9iZSkgIChzdHJ1Y3QgZGV2aWNlICpk ZXYpOwogCSAgICAgdm9pZCAoKnJlbW92ZSkgKHN0cnVjdCBkZXZpY2UgKmRldik7CiAJICAgICBz dHJ1Y3QgZGV2aWNlX2RyaXZlciAgICBkcml2ZXI7CisJICAgICBjb25zdCBzdHJ1Y3QgbWRldl9j bGFzc19pZCAqaWRfdGFibGU7CiAgICAgIH07CiAKIEEgbWVkaWF0ZWQgYnVzIGRyaXZlciBmb3Ig bWRldiBzaG91bGQgdXNlIHRoaXMgc3RydWN0dXJlIGluIHRoZSBmdW5jdGlvbiBjYWxscwpAQCAt MTcwLDYgKzE3Miw5IEBAIHRoYXQgYSBkcml2ZXIgc2hvdWxkIHVzZSB0byB1bnJlZ2lzdGVyIGl0 c2VsZiB3aXRoIHRoZSBtZGV2IGNvcmUgZHJpdmVyOjoKIAogCWV4dGVybiB2b2lkIG1kZXZfdW5y ZWdpc3Rlcl9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2KTsKIAorSXQgaXMgYWxzbyByZXF1aXJl ZCB0byBzcGVjaWZ5IHRoZSBjbGFzc19pZCBpbiBjcmVhdGUoKSBjYWxsYmFjayB0aHJvdWdoOjoK KworCWludCBtZGV2X3NldF9jbGFzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZCk7 CiAKIE1lZGlhdGVkIERldmljZSBNYW5hZ2VtZW50IEludGVyZmFjZSBUaHJvdWdoIHN5c2ZzCiA9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2t2bWd0LmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndnQva3ZtZ3QuYwppbmRleCAzNDNkNzljMWNiN2UuLjY0MjBmMGRiZDMxYiAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2t2bWd0LmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3Z0L2t2bWd0LmMKQEAgLTY3OCw2ICs2NzgsNyBAQCBzdGF0aWMgaW50IGludGVs X3ZncHVfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYpCiAJCSAgICAgZGV2X25hbWUobWRldl9kZXYobWRldikpKTsKIAlyZXQgPSAwOwogCisJbWRl dl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIG91dDoKIAlyZXR1cm4gcmV0 OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Npby92ZmlvX2Njd19vcHMuYyBiL2RyaXZl cnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMKaW5kZXggZjBkNzFhYjc3YzUwLi5jZjJjMDEzYWUz MmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMKKysrIGIvZHJp dmVycy9zMzkwL2Npby92ZmlvX2Njd19vcHMuYwpAQCAtMTI5LDYgKzEyOSw3IEBAIHN0YXRpYyBp bnQgdmZpb19jY3dfbWRldl9jcmVhdGUoc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBtZGV2 X2RldmljZSAqbWRldikKIAkJCSAgIHByaXZhdGUtPnNjaC0+c2NoaWQuc3NpZCwKIAkJCSAgIHBy aXZhdGUtPnNjaC0+c2NoaWQuc2NoX25vKTsKIAorCW1kZXZfc2V0X2NsYXNzKG1kZXYsIE1ERVZf Q0xBU1NfSURfVkZJTyk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5 MC9jcnlwdG8vdmZpb19hcF9vcHMuYyBiL2RyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMu YwppbmRleCA1YzBmNTNjNmRkZTcuLjA3YzMxMDcwYWZlYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9z MzkwL2NyeXB0by92ZmlvX2FwX29wcy5jCisrKyBiL2RyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19h cF9vcHMuYwpAQCAtMzQzLDYgKzM0Myw3IEBAIHN0YXRpYyBpbnQgdmZpb19hcF9tZGV2X2NyZWF0 ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCWxpc3Rf YWRkKCZtYXRyaXhfbWRldi0+bm9kZSwgJm1hdHJpeF9kZXYtPm1kZXZfbGlzdCk7CiAJbXV0ZXhf dW5sb2NrKCZtYXRyaXhfZGV2LT5sb2NrKTsKIAorCW1kZXZfc2V0X2NsYXNzKG1kZXYsIE1ERVZf Q0xBU1NfSURfVkZJTyk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmZp by9tZGV2L21kZXZfY29yZS5jIGIvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMKaW5kZXgg YjU1OGQ0Y2ZkMDgyLi4zYTljNTJkNzFiNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmZpby9tZGV2 L21kZXZfY29yZS5jCisrKyBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfY29yZS5jCkBAIC00NSw2 ICs0NSwxNiBAQCB2b2lkIG1kZXZfc2V0X2RydmRhdGEoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2 LCB2b2lkICpkYXRhKQogfQogRVhQT1JUX1NZTUJPTChtZGV2X3NldF9kcnZkYXRhKTsKIAorLyog U3BlY2lmeSB0aGUgY2xhc3MgZm9yIHRoZSBtZGV2IGRldmljZSwgdGhpcyBtdXN0IGJlIGNhbGxl ZCBkdXJpbmcKKyAqIGNyZWF0ZSgpIGNhbGxiYWNrLgorICovCit2b2lkIG1kZXZfc2V0X2NsYXNz KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkKQoreworCVdBUk5fT04obWRldi0+Y2xh c3NfaWQpOworCW1kZXYtPmNsYXNzX2lkID0gaWQ7Cit9CitFWFBPUlRfU1lNQk9MKG1kZXZfc2V0 X2NsYXNzKTsKKwogc3RydWN0IGRldmljZSAqbWRldl9kZXYoc3RydWN0IG1kZXZfZGV2aWNlICpt ZGV2KQogewogCXJldHVybiAmbWRldi0+ZGV2OwpAQCAtMTM1LDYgKzE0NSw3IEBAIHN0YXRpYyBp bnQgbWRldl9kZXZpY2VfcmVtb3ZlX2NiKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkK ICAqIG1kZXZfcmVnaXN0ZXJfZGV2aWNlIDogUmVnaXN0ZXIgYSBkZXZpY2UKICAqIEBkZXY6IGRl dmljZSBzdHJ1Y3R1cmUgcmVwcmVzZW50aW5nIHBhcmVudCBkZXZpY2UuCiAgKiBAb3BzOiBQYXJl bnQgZGV2aWNlIG9wZXJhdGlvbiBzdHJ1Y3R1cmUgdG8gYmUgcmVnaXN0ZXJlZC4KKyAqIEBpZDog Y2xhc3MgaWQuCiAgKgogICogQWRkIGRldmljZSB0byBsaXN0IG9mIHJlZ2lzdGVyZWQgcGFyZW50 IGRldmljZXMuCiAgKiBSZXR1cm5zIGEgbmVnYXRpdmUgdmFsdWUgb24gZXJyb3IsIG90aGVyd2lz ZSAwLgpAQCAtMzI0LDYgKzMzNSwxMyBAQCBpbnQgbWRldl9kZXZpY2VfY3JlYXRlKHN0cnVjdCBr b2JqZWN0ICprb2JqLAogCWlmIChyZXQpCiAJCWdvdG8gb3BzX2NyZWF0ZV9mYWlsOwogCisJaWYg KCFtZGV2LT5jbGFzc19pZCkgeworCQlyZXQgPSAtRUlOVkFMOworCQlXQVJOKDEsICJjbGFzcyBp ZCBtdXN0IGJlIHNwZWNpZmllZCBmb3IgZGV2aWNlICVzXG4iLAorCQkgICAgIGRldl9uYW1lKGRl dikpOworCQlnb3RvIGFkZF9mYWlsOworCX0KKwogCXJldCA9IGRldmljZV9hZGQoJm1kZXYtPmRl dik7CiAJaWYgKHJldCkKIAkJZ290byBhZGRfZmFpbDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmZp by9tZGV2L21kZXZfZHJpdmVyLmMgYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2RyaXZlci5jCmlu ZGV4IDBkMzIyM2FlZTIwYi4uMzE5ZDg4NmZmYWY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZmaW8v bWRldi9tZGV2X2RyaXZlci5jCisrKyBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfZHJpdmVyLmMK QEAgLTY5LDggKzY5LDMwIEBAIHN0YXRpYyBpbnQgbWRldl9yZW1vdmUoc3RydWN0IGRldmljZSAq ZGV2KQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IG1kZXZfbWF0Y2goc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2KQoreworCXVuc2lnbmVkIGludCBpOwor CXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHRvX21kZXZfZGV2aWNlKGRldik7CisJc3RydWN0 IG1kZXZfZHJpdmVyICptZHJ2ID0gdG9fbWRldl9kcml2ZXIoZHJ2KTsKKwljb25zdCBzdHJ1Y3Qg bWRldl9jbGFzc19pZCAqaWRzID0gbWRydi0+aWRfdGFibGU7CisKKwlmb3IgKGkgPSAwOyBpZHNb aV0uaWQ7IGkrKykKKwkJaWYgKGlkc1tpXS5pZCA9PSBtZGV2LT5jbGFzc19pZCkKKwkJCXJldHVy biAxOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IG1kZXZfdWV2ZW50KHN0cnVjdCBkZXZp Y2UgKmRldiwgc3RydWN0IGtvYmpfdWV2ZW50X2VudiAqZW52KQoreworCXN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiA9IHRvX21kZXZfZGV2aWNlKGRldik7CisKKwlyZXR1cm4gYWRkX3VldmVudF92 YXIoZW52LCAiTU9EQUxJQVM9bWRldjpjJTAyWCIsIG1kZXYtPmNsYXNzX2lkKTsKK30KKwogc3Ry dWN0IGJ1c190eXBlIG1kZXZfYnVzX3R5cGUgPSB7CiAJLm5hbWUJCT0gIm1kZXYiLAorCS5tYXRj aAkJPSBtZGV2X21hdGNoLAorCS51ZXZlbnQJCT0gbWRldl91ZXZlbnQsCiAJLnByb2JlCQk9IG1k ZXZfcHJvYmUsCiAJLnJlbW92ZQkJPSBtZGV2X3JlbW92ZSwKIH07CmRpZmYgLS1naXQgYS9kcml2 ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZhdGUuaCBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJp dmF0ZS5oCmluZGV4IDdkOTIyOTUwY2FhZi4uYzY1ZjQzNmMxODY5IDEwMDY0NAotLS0gYS9kcml2 ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZhdGUuaAorKysgYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2 X3ByaXZhdGUuaApAQCAtMzMsNiArMzMsNyBAQCBzdHJ1Y3QgbWRldl9kZXZpY2UgewogCXN0cnVj dCBrb2JqZWN0ICp0eXBlX2tvYmo7CiAJc3RydWN0IGRldmljZSAqaW9tbXVfZGV2aWNlOwogCWJv b2wgYWN0aXZlOworCXUxNiBjbGFzc19pZDsKIH07CiAKICNkZWZpbmUgdG9fbWRldl9kZXZpY2Uo ZGV2KQljb250YWluZXJfb2YoZGV2LCBzdHJ1Y3QgbWRldl9kZXZpY2UsIGRldikKZGlmZiAtLWdp dCBhL2RyaXZlcnMvdmZpby9tZGV2L3ZmaW9fbWRldi5jIGIvZHJpdmVycy92ZmlvL21kZXYvdmZp b19tZGV2LmMKaW5kZXggMzA5NjRhNGUwYTI4Li43YjI0ZWU5Y2I4ZGQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvdmZpby9tZGV2L3ZmaW9fbWRldi5jCisrKyBiL2RyaXZlcnMvdmZpby9tZGV2L3ZmaW9f bWRldi5jCkBAIC0xMjAsMTAgKzEyMCwxNiBAQCBzdGF0aWMgdm9pZCB2ZmlvX21kZXZfcmVtb3Zl KHN0cnVjdCBkZXZpY2UgKmRldikKIAl2ZmlvX2RlbF9ncm91cF9kZXYoZGV2KTsKIH0KIAorc3Rh dGljIGNvbnN0IHN0cnVjdCBtZGV2X2NsYXNzX2lkIGlkX3RhYmxlW10gPSB7CisJeyBNREVWX0NM QVNTX0lEX1ZGSU8gfSwKKwl7IDAgfSwKK307CisKIHN0YXRpYyBzdHJ1Y3QgbWRldl9kcml2ZXIg dmZpb19tZGV2X2RyaXZlciA9IHsKIAkubmFtZQk9ICJ2ZmlvX21kZXYiLAogCS5wcm9iZQk9IHZm aW9fbWRldl9wcm9iZSwKIAkucmVtb3ZlCT0gdmZpb19tZGV2X3JlbW92ZSwKKwkuaWRfdGFibGUg PSBpZF90YWJsZSwKIH07CiAKIHN0YXRpYyBpbnQgX19pbml0IHZmaW9fbWRldl9pbml0KHZvaWQp CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21kZXYuaCBiL2luY2x1ZGUvbGludXgvbWRldi5o CmluZGV4IDBjZTMwY2E3OGRiMC4uNzhiNjlkMDllYjU0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xp bnV4L21kZXYuaAorKysgYi9pbmNsdWRlL2xpbnV4L21kZXYuaApAQCAtMTE4LDYgKzExOCw3IEBA IHN0cnVjdCBtZGV2X3R5cGVfYXR0cmlidXRlIG1kZXZfdHlwZV9hdHRyXyMjX25hbWUgPQkJXAog ICogQHByb2JlOiBjYWxsZWQgd2hlbiBuZXcgZGV2aWNlIGNyZWF0ZWQKICAqIEByZW1vdmU6IGNh bGxlZCB3aGVuIGRldmljZSByZW1vdmVkCiAgKiBAZHJpdmVyOiBkZXZpY2UgZHJpdmVyIHN0cnVj dHVyZQorICogQGlkX3RhYmxlOiB0aGUgaWRzIHNlcnZpY2VkIGJ5IHRoaXMgZHJpdmVyCiAgKgog ICoqLwogc3RydWN0IG1kZXZfZHJpdmVyIHsKQEAgLTEyNSw2ICsxMjYsNyBAQCBzdHJ1Y3QgbWRl dl9kcml2ZXIgewogCWludCAgKCpwcm9iZSkoc3RydWN0IGRldmljZSAqZGV2KTsKIAl2b2lkICgq cmVtb3ZlKShzdHJ1Y3QgZGV2aWNlICpkZXYpOwogCXN0cnVjdCBkZXZpY2VfZHJpdmVyIGRyaXZl cjsKKwljb25zdCBzdHJ1Y3QgbWRldl9jbGFzc19pZCAqaWRfdGFibGU7CiB9OwogCiAjZGVmaW5l IHRvX21kZXZfZHJpdmVyKGRydikJY29udGFpbmVyX29mKGRydiwgc3RydWN0IG1kZXZfZHJpdmVy LCBkcml2ZXIpCkBAIC0xMzIsNiArMTM0LDcgQEAgc3RydWN0IG1kZXZfZHJpdmVyIHsKIHZvaWQg Km1kZXZfZ2V0X2RydmRhdGEoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKIHZvaWQgbWRldl9z ZXRfZHJ2ZGF0YShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHZvaWQgKmRhdGEpOwogY29uc3Qg Z3VpZF90ICptZGV2X3V1aWQoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKK3ZvaWQgbWRldl9z ZXRfY2xhc3Moc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWQpOwogCiBleHRlcm4gc3Ry dWN0IGJ1c190eXBlIG1kZXZfYnVzX3R5cGU7CiAKQEAgLTE0NSw0ICsxNDgsOSBAQCBzdHJ1Y3Qg ZGV2aWNlICptZGV2X3BhcmVudF9kZXYoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKIHN0cnVj dCBkZXZpY2UgKm1kZXZfZGV2KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7CiBzdHJ1Y3QgbWRl dl9kZXZpY2UgKm1kZXZfZnJvbV9kZXYoc3RydWN0IGRldmljZSAqZGV2KTsKIAorZW51bSB7CisJ TURFVl9DTEFTU19JRF9WRklPID0gMSwKKwkvKiBOZXcgZW50cmllcyBtdXN0IGJlIGFkZGVkIGhl cmUgKi8KK307CisKICNlbmRpZiAvKiBNREVWX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvbW9kX2RldmljZXRhYmxlLmggYi9pbmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oCmlu ZGV4IDU3MTRmZDM1YTgzYy4uZjMyYzZlNDRmYjFhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4 L21vZF9kZXZpY2V0YWJsZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmgK QEAgLTgyMSw0ICs4MjEsMTIgQEAgc3RydWN0IHdtaV9kZXZpY2VfaWQgewogCWNvbnN0IHZvaWQg KmNvbnRleHQ7CiB9OwogCisvKioKKyAqIHN0cnVjdCBtZGV2X2NsYXNzX2lkIC0gTURFViBkZXZp Y2UgY2xhc3MgaWRlbnRpZmllcgorICogQGlkOiBVc2VkIHRvIGlkZW50aWZ5IGEgc3BlY2lmaWMg Y2xhc3Mgb2YgZGV2aWNlLCBlLmcgdmZpby1tZGV2IGRldmljZS4KKyAqLworc3RydWN0IG1kZXZf Y2xhc3NfaWQgeworCV9fdTE2IGlkOworfTsKKwogI2VuZGlmIC8qIExJTlVYX01PRF9ERVZJQ0VU QUJMRV9IICovCmRpZmYgLS1naXQgYS9zYW1wbGVzL3ZmaW8tbWRldi9tYm9jaHMuYyBiL3NhbXBs ZXMvdmZpby1tZGV2L21ib2Nocy5jCmluZGV4IGFjNWM4YzE3YjFmZi4uMTE1YmM1MDc0NjU2IDEw MDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8tbWRldi9tYm9jaHMuYworKysgYi9zYW1wbGVzL3ZmaW8t bWRldi9tYm9jaHMuYwpAQCAtNTYxLDYgKzU2MSw3IEBAIHN0YXRpYyBpbnQgbWJvY2hzX2NyZWF0 ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCW1ib2No c19yZXNldChtZGV2KTsKIAogCW1ib2Noc191c2VkX21ieXRlcyArPSB0eXBlLT5tYnl0ZXM7CisJ bWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIAlyZXR1cm4gMDsKIAog ZXJyX21lbToKZGlmZiAtLWdpdCBhL3NhbXBsZXMvdmZpby1tZGV2L21kcHkuYyBiL3NhbXBsZXMv dmZpby1tZGV2L21kcHkuYwppbmRleCBjYzg2YmY2NTY2ZTQuLjY2NTYxNDU3NGQ1MCAxMDA2NDQK LS0tIGEvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jCisrKyBiL3NhbXBsZXMvdmZpby1tZGV2L21k cHkuYwpAQCAtMjY5LDYgKzI2OSw3IEBAIHN0YXRpYyBpbnQgbWRweV9jcmVhdGUoc3RydWN0IGtv YmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIAltZHB5X3Jlc2V0KG1kZXYp OwogCiAJbWRweV9jb3VudCsrOworCW1kZXZfc2V0X2NsYXNzKG1kZXYsIE1ERVZfQ0xBU1NfSURf VkZJTyk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL3NhbXBsZXMvdmZpby1tZGV2L210 dHkuYyBiL3NhbXBsZXMvdmZpby1tZGV2L210dHkuYwppbmRleCBjZTg0YTMwMGE0ZGEuLjkwZGEx MmZmN2ZkOSAxMDA2NDQKLS0tIGEvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jCisrKyBiL3NhbXBs ZXMvdmZpby1tZGV2L210dHkuYwpAQCAtNzU1LDYgKzc1NSw3IEBAIHN0YXRpYyBpbnQgbXR0eV9j cmVhdGUoc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIAls aXN0X2FkZCgmbWRldl9zdGF0ZS0+bmV4dCwgJm1kZXZfZGV2aWNlc19saXN0KTsKIAltdXRleF91 bmxvY2soJm1kZXZfbGlzdF9sb2NrKTsKIAorCW1kZXZfc2V0X2NsYXNzKG1kZXYsIE1ERVZfQ0xB U1NfSURfVkZJTyk7CiAJcmV0dXJuIDA7CiB9CiAKLS0gCjIuMTkuMQoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJ bnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4