From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx1.redhat.com ([209.132.183.28]:41774 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727438AbfIWNEY (ORCPT ); Mon, 23 Sep 2019 09:04:24 -0400 From: Jason Wang Subject: [PATCH 1/6] mdev: class id support Date: Mon, 23 Sep 2019 21:03:26 +0800 Message-Id: <20190923130331.29324-2-jasowang@redhat.com> In-Reply-To: <20190923130331.29324-1-jasowang@redhat.com> References: <20190923130331.29324-1-jasowang@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-s390-owner@vger.kernel.org List-ID: 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: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, cohuck@redhat.com, maxime.coquelin@redhat.com, cunming.liang@intel.com, zhihong.wang@intel.com, rob.miller@broadcom.com, xiao.w.wang@intel.com, haotian.wang@sifive.com, zhenyuw@linux.intel.com, zhi.a.wang@intel.com, jani.nikula@linux.intel.com, joonas.lahtinen@linux.intel.com, rodrigo.vivi@intel.com, airlied@linux.ie, daniel@ffwll.ch, farman@linux.ibm.com, pasic@linux.ibm.com, sebott@linux.ibm.com, oberpar@linux.ibm.com, heiko.carstens@de.ibm.com, gor@linux.ibm.com, borntraeger@de.ibm.com, akrowiak@linux.ibm.com, freude@linux.ibm.com, lingshan.zhu@intel.com, idos@mellanox.com, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, Jason Wang 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, one example is virtio-mdev[1] driver. 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 parent with the match method for mdev bus. Signed-off-by: Jason Wang --- Documentation/driver-api/vfio-mediated-device.rst | 7 +++++-- drivers/gpu/drm/i915/gvt/kvmgt.c | 2 +- drivers/s390/cio/vfio_ccw_ops.c | 2 +- drivers/s390/crypto/vfio_ap_ops.c | 3 ++- drivers/vfio/mdev/mdev_core.c | 14 ++++++++++++-- drivers/vfio/mdev/mdev_driver.c | 14 ++++++++++++++ drivers/vfio/mdev/mdev_private.h | 1 + drivers/vfio/mdev/vfio_mdev.c | 6 ++++++ include/linux/mdev.h | 7 ++++++- include/linux/mod_devicetable.h | 8 ++++++++ samples/vfio-mdev/mbochs.c | 2 +- samples/vfio-mdev/mdpy.c | 2 +- samples/vfio-mdev/mtty.c | 2 +- 13 files changed, 59 insertions(+), 11 deletions(-) diff --git a/Documentation/driver-api/vfio-mediated-device.rst b/Documentation/driver-api/vfio-mediated-device.rst index 25eb7d5b834b..0e052072e1d8 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 @@ -116,7 +118,7 @@ to register and unregister itself with the core driver: * Register:: extern int mdev_register_driver(struct mdev_driver *drv, - struct module *owner); + struct module *owner); * Unregister:: @@ -163,7 +165,8 @@ A driver should use the mdev_parent_ops structure in the function call to register itself with the mdev core driver:: extern int mdev_register_device(struct device *dev, - const struct mdev_parent_ops *ops); + const struct mdev_parent_ops *ops, + u8 class_id); However, the mdev_parent_ops structure is not required in the function call that a driver should use to unregister itself with the mdev core driver:: diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c index 23aa3e50cbf8..19d51a35f019 100644 --- a/drivers/gpu/drm/i915/gvt/kvmgt.c +++ b/drivers/gpu/drm/i915/gvt/kvmgt.c @@ -1625,7 +1625,7 @@ static int kvmgt_host_init(struct device *dev, void *gvt, const void *ops) return -EFAULT; intel_vgpu_ops.supported_type_groups = kvm_vgpu_type_groups; - return mdev_register_device(dev, &intel_vgpu_ops); + return mdev_register_vfio_device(dev, &intel_vgpu_ops); } static void kvmgt_host_exit(struct device *dev) diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_ops.c index f0d71ab77c50..246ff0f80944 100644 --- a/drivers/s390/cio/vfio_ccw_ops.c +++ b/drivers/s390/cio/vfio_ccw_ops.c @@ -588,7 +588,7 @@ static const struct mdev_parent_ops vfio_ccw_mdev_ops = { int vfio_ccw_mdev_reg(struct subchannel *sch) { - return mdev_register_device(&sch->dev, &vfio_ccw_mdev_ops); + return mdev_register_vfio_device(&sch->dev, &vfio_ccw_mdev_ops); } void vfio_ccw_mdev_unreg(struct subchannel *sch) diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c index 5c0f53c6dde7..7487fc39d2c5 100644 --- a/drivers/s390/crypto/vfio_ap_ops.c +++ b/drivers/s390/crypto/vfio_ap_ops.c @@ -1295,7 +1295,8 @@ int vfio_ap_mdev_register(void) { atomic_set(&matrix_dev->available_instances, MAX_ZDEV_ENTRIES_EXT); - return mdev_register_device(&matrix_dev->device, &vfio_ap_matrix_ops); + return mdev_register_vfio_device(&matrix_dev->device, + &vfio_ap_matrix_ops); } void vfio_ap_mdev_unregister(void) diff --git a/drivers/vfio/mdev/mdev_core.c b/drivers/vfio/mdev/mdev_core.c index b558d4cfd082..a02c256a3514 100644 --- a/drivers/vfio/mdev/mdev_core.c +++ b/drivers/vfio/mdev/mdev_core.c @@ -135,11 +135,14 @@ 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: device id. * * Add device to list of registered parent devices. * Returns a negative value on error, otherwise 0. */ -int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops) +int mdev_register_device(struct device *dev, + const struct mdev_parent_ops *ops, + u8 class_id) { int ret; struct mdev_parent *parent; @@ -175,6 +178,7 @@ int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops) parent->dev = dev; parent->ops = ops; + parent->class_id = class_id; if (!mdev_bus_compat_class) { mdev_bus_compat_class = class_compat_register("mdev_bus"); @@ -208,7 +212,13 @@ int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops) put_device(dev); return ret; } -EXPORT_SYMBOL(mdev_register_device); + +int mdev_register_vfio_device(struct device *dev, + const struct mdev_parent_ops *ops) +{ + return mdev_register_device(dev, ops, MDEV_ID_VFIO); +} +EXPORT_SYMBOL(mdev_register_vfio_device); /* * mdev_unregister_device : Unregister a parent device diff --git a/drivers/vfio/mdev/mdev_driver.c b/drivers/vfio/mdev/mdev_driver.c index 0d3223aee20b..b70bbebc9dd3 100644 --- a/drivers/vfio/mdev/mdev_driver.c +++ b/drivers/vfio/mdev/mdev_driver.c @@ -69,8 +69,22 @@ 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->parent->class_id) + return 1; + return 0; +} + struct bus_type mdev_bus_type = { .name = "mdev", + .match = mdev_match, .probe = mdev_probe, .remove = mdev_remove, }; diff --git a/drivers/vfio/mdev/mdev_private.h b/drivers/vfio/mdev/mdev_private.h index 7d922950caaf..e58b07c866b1 100644 --- a/drivers/vfio/mdev/mdev_private.h +++ b/drivers/vfio/mdev/mdev_private.h @@ -22,6 +22,7 @@ struct mdev_parent { struct list_head type_list; /* Synchronize device creation/removal with parent unregistration */ struct rw_semaphore unreg_sem; + u8 class_id; }; struct mdev_device { diff --git a/drivers/vfio/mdev/vfio_mdev.c b/drivers/vfio/mdev/vfio_mdev.c index 30964a4e0a28..fd2a4d9a3f26 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 struct mdev_class_id id_table[] = { + { MDEV_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..3ebae310f599 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) @@ -135,7 +137,8 @@ const guid_t *mdev_uuid(struct mdev_device *mdev); extern struct bus_type mdev_bus_type; -int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops); +int mdev_register_vfio_device(struct device *dev, + const struct mdev_parent_ops *ops); void mdev_unregister_device(struct device *dev); int mdev_register_driver(struct mdev_driver *drv, struct module *owner); @@ -145,4 +148,6 @@ 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); +#define MDEV_ID_VFIO 1 /* VFIO device */ + #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..71a4469be85d 100644 --- a/samples/vfio-mdev/mbochs.c +++ b/samples/vfio-mdev/mbochs.c @@ -1468,7 +1468,7 @@ static int __init mbochs_dev_init(void) if (ret) goto failed2; - ret = mdev_register_device(&mbochs_dev, &mdev_fops); + ret = mdev_register_vfio_device(&mbochs_dev, &mdev_fops); if (ret) goto failed3; diff --git a/samples/vfio-mdev/mdpy.c b/samples/vfio-mdev/mdpy.c index cc86bf6566e4..d3029dd27d91 100644 --- a/samples/vfio-mdev/mdpy.c +++ b/samples/vfio-mdev/mdpy.c @@ -775,7 +775,7 @@ static int __init mdpy_dev_init(void) if (ret) goto failed2; - ret = mdev_register_device(&mdpy_dev, &mdev_fops); + ret = mdev_register_vfio_device(&mdpy_dev, &mdev_fops); if (ret) goto failed3; diff --git a/samples/vfio-mdev/mtty.c b/samples/vfio-mdev/mtty.c index 92e770a06ea2..744c88a6b22c 100644 --- a/samples/vfio-mdev/mtty.c +++ b/samples/vfio-mdev/mtty.c @@ -1468,7 +1468,7 @@ static int __init mtty_dev_init(void) if (ret) goto failed2; - ret = mdev_register_device(&mtty_dev.dev, &mdev_fops); + ret = mdev_register_vfio_device(&mtty_dev.dev, &mdev_fops); if (ret) goto failed3; -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH 1/6] mdev: class id support Date: Mon, 23 Sep 2019 21:03:26 +0800 Message-ID: <20190923130331.29324-2-jasowang@redhat.com> References: <20190923130331.29324-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190923130331.29324-1-jasowang@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" 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: 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, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com List-Id: dri-devel@lists.freedesktop.org TWRldiBidXMgb25seSBzdXBwb3J0cyB2ZmlvIGRyaXZlciByaWdodCBub3csIHNvIGl0IGRvZXNu J3QgaW1wbGVtZW50Cm1hdGNoIG1ldGhvZC4gQnV0IGluIHRoZSBmdXR1cmUsIHdlIG1heSBhZGQg ZHJpdmVycyBvdGhlciB0aGFuIHZmaW8sCm9uZSBleGFtcGxlIGlzIHZpcnRpby1tZGV2WzFdIGRy aXZlci4gVGhpcyBtZWFucyB3ZSBuZWVkIHRvIGFkZCBkZXZpY2UKY2xhc3MgaWQgc3VwcG9ydCBp biBidXMgbWF0Y2ggbWV0aG9kIHRvIHBhaXIgdGhlIG1kZXYgZGV2aWNlIGFuZCBtZGV2CmRyaXZl ciBjb3JyZWN0bHkuCgpTbyB0aGlzIHBhdGNoIGFkZHMgaWRfdGFibGUgdG8gbWRldl9kcml2ZXIg YW5kIGNsYXNzX2lkIGZvciBtZGV2CnBhcmVudCB3aXRoIHRoZSBtYXRjaCBtZXRob2QgZm9yIG1k ZXYgYnVzLgoKU2lnbmVkLW9mZi1ieTogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4K LS0tCiBEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0IHwg IDcgKysrKystLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2t2bWd0LmMgICAgICAgICAgICAg ICAgICB8ICAyICstCiBkcml2ZXJzL3MzOTAvY2lvL3ZmaW9fY2N3X29wcy5jICAgICAgICAgICAg ICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMuYyAgICAgICAg ICAgICAgICAgfCAgMyArKy0KIGRyaXZlcnMvdmZpby9tZGV2L21kZXZfY29yZS5jICAgICAgICAg ICAgICAgICAgICAgfCAxNCArKysrKysrKysrKystLQogZHJpdmVycy92ZmlvL21kZXYvbWRldl9k cml2ZXIuYyAgICAgICAgICAgICAgICAgICB8IDE0ICsrKysrKysrKysrKysrCiBkcml2ZXJzL3Zm aW8vbWRldi9tZGV2X3ByaXZhdGUuaCAgICAgICAgICAgICAgICAgIHwgIDEgKwogZHJpdmVycy92 ZmlvL21kZXYvdmZpb19tZGV2LmMgICAgICAgICAgICAgICAgICAgICB8ICA2ICsrKysrKwogaW5j bHVkZS9saW51eC9tZGV2LmggICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICA3ICsrKysr Ky0KIGluY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmggICAgICAgICAgICAgICAgICAgfCAg OCArKysrKysrKwogc2FtcGxlcy92ZmlvLW1kZXYvbWJvY2hzLmMgICAgICAgICAgICAgICAgICAg ICAgICB8ICAyICstCiBzYW1wbGVzL3ZmaW8tbWRldi9tZHB5LmMgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgIDIgKy0KIHNhbXBsZXMvdmZpby1tZGV2L210dHkuYyAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgMiArLQogMTMgZmlsZXMgY2hhbmdlZCwgNTkgaW5zZXJ0aW9ucygrKSwgMTEg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL3ZmaW8t bWVkaWF0ZWQtZGV2aWNlLnJzdCBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS92ZmlvLW1lZGlh dGVkLWRldmljZS5yc3QKaW5kZXggMjVlYjdkNWI4MzRiLi4wZTA1MjA3MmUxZDggMTAwNjQ0Ci0t LSBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS92ZmlvLW1lZGlhdGVkLWRldmljZS5yc3QKKysr IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL3ZmaW8tbWVkaWF0ZWQtZGV2aWNlLnJzdApAQCAt MTAyLDEyICsxMDIsMTQgQEAgc3RydWN0dXJlIHRvIHJlcHJlc2VudCBhIG1lZGlhdGVkIGRldmlj ZSdzIGRyaXZlcjo6CiAgICAgICAqIEBwcm9iZTogY2FsbGVkIHdoZW4gbmV3IGRldmljZSBjcmVh dGVkCiAgICAgICAqIEByZW1vdmU6IGNhbGxlZCB3aGVuIGRldmljZSByZW1vdmVkCiAgICAgICAq IEBkcml2ZXI6IGRldmljZSBkcml2ZXIgc3RydWN0dXJlCisgICAgICAqIEBpZF90YWJsZTogdGhl IGlkcyBzZXJ2aWNlZCBieSB0aGlzIGRyaXZlci4KICAgICAgICovCiAgICAgIHN0cnVjdCBtZGV2 X2RyaXZlciB7CiAJICAgICBjb25zdCBjaGFyICpuYW1lOwogCSAgICAgaW50ICAoKnByb2JlKSAg KHN0cnVjdCBkZXZpY2UgKmRldik7CiAJICAgICB2b2lkICgqcmVtb3ZlKSAoc3RydWN0IGRldmlj ZSAqZGV2KTsKIAkgICAgIHN0cnVjdCBkZXZpY2VfZHJpdmVyICAgIGRyaXZlcjsKKwkgICAgIGNv bnN0IHN0cnVjdCBtZGV2X2NsYXNzX2lkICppZF90YWJsZTsKICAgICAgfTsKIAogQSBtZWRpYXRl ZCBidXMgZHJpdmVyIGZvciBtZGV2IHNob3VsZCB1c2UgdGhpcyBzdHJ1Y3R1cmUgaW4gdGhlIGZ1 bmN0aW9uIGNhbGxzCkBAIC0xMTYsNyArMTE4LDcgQEAgdG8gcmVnaXN0ZXIgYW5kIHVucmVnaXN0 ZXIgaXRzZWxmIHdpdGggdGhlIGNvcmUgZHJpdmVyOgogKiBSZWdpc3Rlcjo6CiAKICAgICBleHRl cm4gaW50ICBtZGV2X3JlZ2lzdGVyX2RyaXZlcihzdHJ1Y3QgbWRldl9kcml2ZXIgKmRydiwKLQkJ CQkgICBzdHJ1Y3QgbW9kdWxlICpvd25lcik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc3RydWN0IG1vZHVsZSAqb3duZXIpOwogCiAqIFVucmVnaXN0ZXI6OgogCkBAIC0x NjMsNyArMTY1LDggQEAgQSBkcml2ZXIgc2hvdWxkIHVzZSB0aGUgbWRldl9wYXJlbnRfb3BzIHN0 cnVjdHVyZSBpbiB0aGUgZnVuY3Rpb24gY2FsbCB0bwogcmVnaXN0ZXIgaXRzZWxmIHdpdGggdGhl IG1kZXYgY29yZSBkcml2ZXI6OgogCiAJZXh0ZXJuIGludCAgbWRldl9yZWdpc3Rlcl9kZXZpY2Uo c3RydWN0IGRldmljZSAqZGV2LAotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNv bnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgKm9wcyk7CisJICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyAqb3BzLAorCSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHU4IGNsYXNzX2lkKTsKIAogSG93ZXZlciwgdGhlIG1k ZXZfcGFyZW50X29wcyBzdHJ1Y3R1cmUgaXMgbm90IHJlcXVpcmVkIGluIHRoZSBmdW5jdGlvbiBj YWxsCiB0aGF0IGEgZHJpdmVyIHNob3VsZCB1c2UgdG8gdW5yZWdpc3RlciBpdHNlbGYgd2l0aCB0 aGUgbWRldiBjb3JlIGRyaXZlcjo6CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dnQva3ZtZ3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jCmluZGV4IDIzYWEz ZTUwY2JmOC4uMTlkNTFhMzVmMDE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dnQva3ZtZ3QuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndnQva3ZtZ3QuYwpAQCAtMTYy NSw3ICsxNjI1LDcgQEAgc3RhdGljIGludCBrdm1ndF9ob3N0X2luaXQoc3RydWN0IGRldmljZSAq ZGV2LCB2b2lkICpndnQsIGNvbnN0IHZvaWQgKm9wcykKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJaW50 ZWxfdmdwdV9vcHMuc3VwcG9ydGVkX3R5cGVfZ3JvdXBzID0ga3ZtX3ZncHVfdHlwZV9ncm91cHM7 CiAKLQlyZXR1cm4gbWRldl9yZWdpc3Rlcl9kZXZpY2UoZGV2LCAmaW50ZWxfdmdwdV9vcHMpOwor CXJldHVybiBtZGV2X3JlZ2lzdGVyX3ZmaW9fZGV2aWNlKGRldiwgJmludGVsX3ZncHVfb3BzKTsK IH0KIAogc3RhdGljIHZvaWQga3ZtZ3RfaG9zdF9leGl0KHN0cnVjdCBkZXZpY2UgKmRldikKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMgYi9kcml2ZXJzL3MzOTAv Y2lvL3ZmaW9fY2N3X29wcy5jCmluZGV4IGYwZDcxYWI3N2M1MC4uMjQ2ZmYwZjgwOTQ0IDEwMDY0 NAotLS0gYS9kcml2ZXJzL3MzOTAvY2lvL3ZmaW9fY2N3X29wcy5jCisrKyBiL2RyaXZlcnMvczM5 MC9jaW8vdmZpb19jY3dfb3BzLmMKQEAgLTU4OCw3ICs1ODgsNyBAQCBzdGF0aWMgY29uc3Qgc3Ry dWN0IG1kZXZfcGFyZW50X29wcyB2ZmlvX2Njd19tZGV2X29wcyA9IHsKIAogaW50IHZmaW9fY2N3 X21kZXZfcmVnKHN0cnVjdCBzdWJjaGFubmVsICpzY2gpCiB7Ci0JcmV0dXJuIG1kZXZfcmVnaXN0 ZXJfZGV2aWNlKCZzY2gtPmRldiwgJnZmaW9fY2N3X21kZXZfb3BzKTsKKwlyZXR1cm4gbWRldl9y ZWdpc3Rlcl92ZmlvX2RldmljZSgmc2NoLT5kZXYsICZ2ZmlvX2Njd19tZGV2X29wcyk7CiB9CiAK IHZvaWQgdmZpb19jY3dfbWRldl91bnJlZyhzdHJ1Y3Qgc3ViY2hhbm5lbCAqc2NoKQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9zMzkwL2NyeXB0by92ZmlvX2FwX29wcy5jIGIvZHJpdmVycy9zMzkwL2Ny eXB0by92ZmlvX2FwX29wcy5jCmluZGV4IDVjMGY1M2M2ZGRlNy4uNzQ4N2ZjMzlkMmM1IDEwMDY0 NAotLS0gYS9kcml2ZXJzL3MzOTAvY3J5cHRvL3ZmaW9fYXBfb3BzLmMKKysrIGIvZHJpdmVycy9z MzkwL2NyeXB0by92ZmlvX2FwX29wcy5jCkBAIC0xMjk1LDcgKzEyOTUsOCBAQCBpbnQgdmZpb19h cF9tZGV2X3JlZ2lzdGVyKHZvaWQpCiB7CiAJYXRvbWljX3NldCgmbWF0cml4X2Rldi0+YXZhaWxh YmxlX2luc3RhbmNlcywgTUFYX1pERVZfRU5UUklFU19FWFQpOwogCi0JcmV0dXJuIG1kZXZfcmVn aXN0ZXJfZGV2aWNlKCZtYXRyaXhfZGV2LT5kZXZpY2UsICZ2ZmlvX2FwX21hdHJpeF9vcHMpOwor CXJldHVybiBtZGV2X3JlZ2lzdGVyX3ZmaW9fZGV2aWNlKCZtYXRyaXhfZGV2LT5kZXZpY2UsCisJ CQkJCSAmdmZpb19hcF9tYXRyaXhfb3BzKTsKIH0KIAogdm9pZCB2ZmlvX2FwX21kZXZfdW5yZWdp c3Rlcih2b2lkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMgYi9k cml2ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYwppbmRleCBiNTU4ZDRjZmQwODIuLmEwMmMyNTZh MzUxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMKKysrIGIvZHJp dmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMKQEAgLTEzNSwxMSArMTM1LDE0IEBAIHN0YXRpYyBp bnQgbWRldl9kZXZpY2VfcmVtb3ZlX2NiKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkK ICAqIG1kZXZfcmVnaXN0ZXJfZGV2aWNlIDogUmVnaXN0ZXIgYSBkZXZpY2UKICAqIEBkZXY6IGRl dmljZSBzdHJ1Y3R1cmUgcmVwcmVzZW50aW5nIHBhcmVudCBkZXZpY2UuCiAgKiBAb3BzOiBQYXJl bnQgZGV2aWNlIG9wZXJhdGlvbiBzdHJ1Y3R1cmUgdG8gYmUgcmVnaXN0ZXJlZC4KKyAqIEBpZDog ZGV2aWNlIGlkLgogICoKICAqIEFkZCBkZXZpY2UgdG8gbGlzdCBvZiByZWdpc3RlcmVkIHBhcmVu dCBkZXZpY2VzLgogICogUmV0dXJucyBhIG5lZ2F0aXZlIHZhbHVlIG9uIGVycm9yLCBvdGhlcndp c2UgMC4KICAqLwotaW50IG1kZXZfcmVnaXN0ZXJfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwg Y29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyAqb3BzKQoraW50IG1kZXZfcmVnaXN0ZXJfZGV2 aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3Bz ICpvcHMsCisJCQkgdTggY2xhc3NfaWQpCiB7CiAJaW50IHJldDsKIAlzdHJ1Y3QgbWRldl9wYXJl bnQgKnBhcmVudDsKQEAgLTE3NSw2ICsxNzgsNyBAQCBpbnQgbWRldl9yZWdpc3Rlcl9kZXZpY2Uo c3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3BzICpvcHMpCiAK IAlwYXJlbnQtPmRldiA9IGRldjsKIAlwYXJlbnQtPm9wcyA9IG9wczsKKwlwYXJlbnQtPmNsYXNz X2lkID0gY2xhc3NfaWQ7CiAKIAlpZiAoIW1kZXZfYnVzX2NvbXBhdF9jbGFzcykgewogCQltZGV2 X2J1c19jb21wYXRfY2xhc3MgPSBjbGFzc19jb21wYXRfcmVnaXN0ZXIoIm1kZXZfYnVzIik7CkBA IC0yMDgsNyArMjEyLDEzIEBAIGludCBtZGV2X3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2aWNl ICpkZXYsIGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgKm9wcykKIAkJcHV0X2RldmljZShk ZXYpOwogCXJldHVybiByZXQ7CiB9Ci1FWFBPUlRfU1lNQk9MKG1kZXZfcmVnaXN0ZXJfZGV2aWNl KTsKKworaW50IG1kZXZfcmVnaXN0ZXJfdmZpb19kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2LAor CQkJICAgICAgY29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyAqb3BzKQoreworCXJldHVybiBt ZGV2X3JlZ2lzdGVyX2RldmljZShkZXYsIG9wcywgTURFVl9JRF9WRklPKTsKK30KK0VYUE9SVF9T WU1CT0wobWRldl9yZWdpc3Rlcl92ZmlvX2RldmljZSk7CiAKIC8qCiAgKiBtZGV2X3VucmVnaXN0 ZXJfZGV2aWNlIDogVW5yZWdpc3RlciBhIHBhcmVudCBkZXZpY2UKZGlmZiAtLWdpdCBhL2RyaXZl cnMvdmZpby9tZGV2L21kZXZfZHJpdmVyLmMgYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2RyaXZl ci5jCmluZGV4IDBkMzIyM2FlZTIwYi4uYjcwYmJlYmM5ZGQzIDEwMDY0NAotLS0gYS9kcml2ZXJz L3ZmaW8vbWRldi9tZGV2X2RyaXZlci5jCisrKyBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfZHJp dmVyLmMKQEAgLTY5LDggKzY5LDIyIEBAIHN0YXRpYyBpbnQgbWRldl9yZW1vdmUoc3RydWN0IGRl dmljZSAqZGV2KQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IG1kZXZfbWF0Y2goc3RydWN0 IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2KQoreworCXVuc2lnbmVkIGlu dCBpOworCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHRvX21kZXZfZGV2aWNlKGRldik7CisJ c3RydWN0IG1kZXZfZHJpdmVyICptZHJ2ID0gdG9fbWRldl9kcml2ZXIoZHJ2KTsKKwljb25zdCBz dHJ1Y3QgbWRldl9jbGFzc19pZCAqaWRzID0gbWRydi0+aWRfdGFibGU7CisKKwlmb3IgKGkgPSAw OyBpZHNbaV0uaWQ7IGkrKykKKwkJaWYgKGlkc1tpXS5pZCA9PSBtZGV2LT5wYXJlbnQtPmNsYXNz X2lkKQorCQkJcmV0dXJuIDE7CisJcmV0dXJuIDA7Cit9CisKIHN0cnVjdCBidXNfdHlwZSBtZGV2 X2J1c190eXBlID0gewogCS5uYW1lCQk9ICJtZGV2IiwKKwkubWF0Y2gJCT0gbWRldl9tYXRjaCwK IAkucHJvYmUJCT0gbWRldl9wcm9iZSwKIAkucmVtb3ZlCQk9IG1kZXZfcmVtb3ZlLAogfTsKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oIGIvZHJpdmVycy92Zmlv L21kZXYvbWRldl9wcml2YXRlLmgKaW5kZXggN2Q5MjI5NTBjYWFmLi5lNThiMDdjODY2YjEgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oCisrKyBiL2RyaXZlcnMv dmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oCkBAIC0yMiw2ICsyMiw3IEBAIHN0cnVjdCBtZGV2X3Bh cmVudCB7CiAJc3RydWN0IGxpc3RfaGVhZCB0eXBlX2xpc3Q7CiAJLyogU3luY2hyb25pemUgZGV2 aWNlIGNyZWF0aW9uL3JlbW92YWwgd2l0aCBwYXJlbnQgdW5yZWdpc3RyYXRpb24gKi8KIAlzdHJ1 Y3Qgcndfc2VtYXBob3JlIHVucmVnX3NlbTsKKwl1OCBjbGFzc19pZDsKIH07CiAKIHN0cnVjdCBt ZGV2X2RldmljZSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYyBi L2RyaXZlcnMvdmZpby9tZGV2L3ZmaW9fbWRldi5jCmluZGV4IDMwOTY0YTRlMGEyOC4uZmQyYTRk OWEzZjI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYworKysgYi9k cml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYwpAQCAtMTIwLDEwICsxMjAsMTYgQEAgc3RhdGlj IHZvaWQgdmZpb19tZGV2X3JlbW92ZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJdmZpb19kZWxfZ3Jv dXBfZGV2KGRldik7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbWRldl9jbGFzc19pZCBpZF90YWJsZVtd ID0geworCXsgTURFVl9JRF9WRklPIH0sCisJeyAwIH0sCit9OworCiBzdGF0aWMgc3RydWN0IG1k ZXZfZHJpdmVyIHZmaW9fbWRldl9kcml2ZXIgPSB7CiAJLm5hbWUJPSAidmZpb19tZGV2IiwKIAku cHJvYmUJPSB2ZmlvX21kZXZfcHJvYmUsCiAJLnJlbW92ZQk9IHZmaW9fbWRldl9yZW1vdmUsCisJ LmlkX3RhYmxlID0gaWRfdGFibGUsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCB2ZmlvX21kZXZf aW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZGV2LmggYi9pbmNsdWRlL2xp bnV4L21kZXYuaAppbmRleCAwY2UzMGNhNzhkYjAuLjNlYmFlMzEwZjU5OSAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC9tZGV2LmgKKysrIGIvaW5jbHVkZS9saW51eC9tZGV2LmgKQEAgLTExOCw2 ICsxMTgsNyBAQCBzdHJ1Y3QgbWRldl90eXBlX2F0dHJpYnV0ZSBtZGV2X3R5cGVfYXR0cl8jI19u YW1lID0JCVwKICAqIEBwcm9iZTogY2FsbGVkIHdoZW4gbmV3IGRldmljZSBjcmVhdGVkCiAgKiBA cmVtb3ZlOiBjYWxsZWQgd2hlbiBkZXZpY2UgcmVtb3ZlZAogICogQGRyaXZlcjogZGV2aWNlIGRy aXZlciBzdHJ1Y3R1cmUKKyAqIEBpZF90YWJsZTogdGhlIGlkcyBzZXJ2aWNlZCBieSB0aGlzIGRy aXZlci4KICAqCiAgKiovCiBzdHJ1Y3QgbWRldl9kcml2ZXIgewpAQCAtMTI1LDYgKzEyNiw3IEBA IHN0cnVjdCBtZGV2X2RyaXZlciB7CiAJaW50ICAoKnByb2JlKShzdHJ1Y3QgZGV2aWNlICpkZXYp OwogCXZvaWQgKCpyZW1vdmUpKHN0cnVjdCBkZXZpY2UgKmRldik7CiAJc3RydWN0IGRldmljZV9k cml2ZXIgZHJpdmVyOworCWNvbnN0IHN0cnVjdCBtZGV2X2NsYXNzX2lkICppZF90YWJsZTsKIH07 CiAKICNkZWZpbmUgdG9fbWRldl9kcml2ZXIoZHJ2KQljb250YWluZXJfb2YoZHJ2LCBzdHJ1Y3Qg bWRldl9kcml2ZXIsIGRyaXZlcikKQEAgLTEzNSw3ICsxMzcsOCBAQCBjb25zdCBndWlkX3QgKm1k ZXZfdXVpZChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOwogCiBleHRlcm4gc3RydWN0IGJ1c190 eXBlIG1kZXZfYnVzX3R5cGU7CiAKLWludCBtZGV2X3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2 aWNlICpkZXYsIGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgKm9wcyk7CitpbnQgbWRldl9y ZWdpc3Rlcl92ZmlvX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkgICAgICBjb25zdCBz dHJ1Y3QgbWRldl9wYXJlbnRfb3BzICpvcHMpOwogdm9pZCBtZGV2X3VucmVnaXN0ZXJfZGV2aWNl KHN0cnVjdCBkZXZpY2UgKmRldik7CiAKIGludCBtZGV2X3JlZ2lzdGVyX2RyaXZlcihzdHJ1Y3Qg bWRldl9kcml2ZXIgKmRydiwgc3RydWN0IG1vZHVsZSAqb3duZXIpOwpAQCAtMTQ1LDQgKzE0OCw2 IEBAIHN0cnVjdCBkZXZpY2UgKm1kZXZfcGFyZW50X2RldihzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYpOwogc3RydWN0IGRldmljZSAqbWRldl9kZXYoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsK IHN0cnVjdCBtZGV2X2RldmljZSAqbWRldl9mcm9tX2RldihzdHJ1Y3QgZGV2aWNlICpkZXYpOwog CisjZGVmaW5lIE1ERVZfSURfVkZJTyAxIC8qIFZGSU8gZGV2aWNlICovCisKICNlbmRpZiAvKiBN REVWX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmggYi9p bmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oCmluZGV4IDU3MTRmZDM1YTgzYy4uZjMyYzZl NDRmYjFhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oCisrKyBi L2luY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmgKQEAgLTgyMSw0ICs4MjEsMTIgQEAgc3Ry dWN0IHdtaV9kZXZpY2VfaWQgewogCWNvbnN0IHZvaWQgKmNvbnRleHQ7CiB9OwogCisvKioKKyAq IHN0cnVjdCBtZGV2X2NsYXNzX2lkIC0gTURFViBkZXZpY2UgY2xhc3MgaWRlbnRpZmllcgorICog QGlkOiBVc2VkIHRvIGlkZW50aWZ5IGEgc3BlY2lmaWMgY2xhc3Mgb2YgZGV2aWNlLCBlLmcgdmZp by1tZGV2IGRldmljZS4KKyAqLworc3RydWN0IG1kZXZfY2xhc3NfaWQgeworCV9fdTE2IGlkOwor fTsKKwogI2VuZGlmIC8qIExJTlVYX01PRF9ERVZJQ0VUQUJMRV9IICovCmRpZmYgLS1naXQgYS9z YW1wbGVzL3ZmaW8tbWRldi9tYm9jaHMuYyBiL3NhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5jCmlu ZGV4IGFjNWM4YzE3YjFmZi4uNzFhNDQ2OWJlODVkIDEwMDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8t bWRldi9tYm9jaHMuYworKysgYi9zYW1wbGVzL3ZmaW8tbWRldi9tYm9jaHMuYwpAQCAtMTQ2OCw3 ICsxNDY4LDcgQEAgc3RhdGljIGludCBfX2luaXQgbWJvY2hzX2Rldl9pbml0KHZvaWQpCiAJaWYg KHJldCkKIAkJZ290byBmYWlsZWQyOwogCi0JcmV0ID0gbWRldl9yZWdpc3Rlcl9kZXZpY2UoJm1i b2Noc19kZXYsICZtZGV2X2ZvcHMpOworCXJldCA9IG1kZXZfcmVnaXN0ZXJfdmZpb19kZXZpY2Uo Jm1ib2Noc19kZXYsICZtZGV2X2ZvcHMpOwogCWlmIChyZXQpCiAJCWdvdG8gZmFpbGVkMzsKIApk aWZmIC0tZ2l0IGEvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jIGIvc2FtcGxlcy92ZmlvLW1kZXYv bWRweS5jCmluZGV4IGNjODZiZjY1NjZlNC4uZDMwMjlkZDI3ZDkxIDEwMDY0NAotLS0gYS9zYW1w bGVzL3ZmaW8tbWRldi9tZHB5LmMKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jCkBAIC03 NzUsNyArNzc1LDcgQEAgc3RhdGljIGludCBfX2luaXQgbWRweV9kZXZfaW5pdCh2b2lkKQogCWlm IChyZXQpCiAJCWdvdG8gZmFpbGVkMjsKIAotCXJldCA9IG1kZXZfcmVnaXN0ZXJfZGV2aWNlKCZt ZHB5X2RldiwgJm1kZXZfZm9wcyk7CisJcmV0ID0gbWRldl9yZWdpc3Rlcl92ZmlvX2RldmljZSgm bWRweV9kZXYsICZtZGV2X2ZvcHMpOwogCWlmIChyZXQpCiAJCWdvdG8gZmFpbGVkMzsKIApkaWZm IC0tZ2l0IGEvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXR0 eS5jCmluZGV4IDkyZTc3MGEwNmVhMi4uNzQ0Yzg4YTZiMjJjIDEwMDY0NAotLS0gYS9zYW1wbGVz L3ZmaW8tbWRldi9tdHR5LmMKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jCkBAIC0xNDY4 LDcgKzE0NjgsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBtdHR5X2Rldl9pbml0KHZvaWQpCiAJaWYg KHJldCkKIAkJZ290byBmYWlsZWQyOwogCi0JcmV0ID0gbWRldl9yZWdpc3Rlcl9kZXZpY2UoJm10 dHlfZGV2LmRldiwgJm1kZXZfZm9wcyk7CisJcmV0ID0gbWRldl9yZWdpc3Rlcl92ZmlvX2Rldmlj ZSgmbXR0eV9kZXYuZGV2LCAmbWRldl9mb3BzKTsKIAlpZiAocmV0KQogCQlnb3RvIGZhaWxlZDM7 CiAKLS0gCjIuMTkuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4