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.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 913D8ECE58C for ; Fri, 11 Oct 2019 08:19:13 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 56A7F2196E for ; Fri, 11 Oct 2019 08:19:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727274AbfJKITM (ORCPT ); Fri, 11 Oct 2019 04:19:12 -0400 Received: from mx1.redhat.com ([209.132.183.28]:45442 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726843AbfJKITL (ORCPT ); Fri, 11 Oct 2019 04:19:11 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 1642F3090FD1; Fri, 11 Oct 2019 08:19:10 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-241.pek2.redhat.com [10.72.12.241]) by smtp.corp.redhat.com (Postfix) with ESMTP id 071B710018F8; Fri, 11 Oct 2019 08:18:36 +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 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, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, Jason Wang Subject: [PATCH V3 4/7] mdev: introduce device specific ops Date: Fri, 11 Oct 2019 16:15:54 +0800 Message-Id: <20191011081557.28302-5-jasowang@redhat.com> In-Reply-To: <20191011081557.28302-1-jasowang@redhat.com> References: <20191011081557.28302-1-jasowang@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.43]); Fri, 11 Oct 2019 08:19:10 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Currently, except for the create and remove, the rest of mdev_parent_ops is designed for vfio-mdev driver only and may not help for kernel mdev driver. With the help of class id, this patch introduces device specific callbacks inside mdev_device structure. This allows different set of callback to be used by vfio-mdev and virtio-mdev. Signed-off-by: Jason Wang --- .../driver-api/vfio-mediated-device.rst | 22 +++++--- MAINTAINERS | 1 + drivers/gpu/drm/i915/gvt/kvmgt.c | 18 ++++--- drivers/s390/cio/vfio_ccw_ops.c | 18 ++++--- drivers/s390/crypto/vfio_ap_ops.c | 14 +++-- drivers/vfio/mdev/mdev_core.c | 9 +++- drivers/vfio/mdev/mdev_private.h | 1 + drivers/vfio/mdev/vfio_mdev.c | 37 ++++++------- include/linux/mdev.h | 42 +++------------ include/linux/vfio_mdev.h | 52 +++++++++++++++++++ samples/vfio-mdev/mbochs.c | 20 ++++--- samples/vfio-mdev/mdpy.c | 21 +++++--- samples/vfio-mdev/mtty.c | 18 ++++--- 13 files changed, 177 insertions(+), 96 deletions(-) create mode 100644 include/linux/vfio_mdev.h diff --git a/Documentation/driver-api/vfio-mediated-device.rst b/Documentation/driver-api/vfio-mediated-device.rst index 2035e48da7b2..553574ebba73 100644 --- a/Documentation/driver-api/vfio-mediated-device.rst +++ b/Documentation/driver-api/vfio-mediated-device.rst @@ -152,11 +152,20 @@ callbacks per mdev parent device, per mdev type, or any other categorization. Vendor drivers are expected to be fully asynchronous in this respect or provide their own internal resource protection.) -The callbacks in the mdev_parent_ops structure are as follows: +In order to support multiple types of device/driver, device needs to +provide both class_id and device_ops through: -* open: open callback of mediated device -* close: close callback of mediated device -* ioctl: ioctl callback of mediated device + void mdev_set_class(struct mdev_device *mdev, u16 id, const void *ops); + +The class_id is used to be paired with ids in id_table in mdev_driver +structure for probing the correct driver. The device_ops is device +specific callbacks which can be get through mdev_get_dev_ops() +function by mdev bus driver. For vfio-mdev device, its device specific +ops are as follows: + +* open: open callback of vfio mediated device +* close: close callback of vfio mediated device +* ioctl: ioctl callback of vfio mediated device * read : read emulation callback * write: write emulation callback * mmap: mmap emulation callback @@ -167,9 +176,10 @@ register itself with the mdev core driver:: extern int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops); -It is also required to specify the class_id through:: +It is also required to specify the class_id and device specific ops through:: - extern int mdev_set_class(struct device *dev, u16 id); + extern int mdev_set_class(struct device *dev, u16 id, + const void *ops); 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/MAINTAINERS b/MAINTAINERS index 8824f61cd2c0..3d196a023b5e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17127,6 +17127,7 @@ S: Maintained F: Documentation/driver-api/vfio-mediated-device.rst F: drivers/vfio/mdev/ F: include/linux/mdev.h +F: include/linux/vfio_mdev.h F: samples/vfio-mdev/ VFIO PLATFORM DRIVER diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c index 17e9d4634c84..7e2b720074fd 100644 --- a/drivers/gpu/drm/i915/gvt/kvmgt.c +++ b/drivers/gpu/drm/i915/gvt/kvmgt.c @@ -42,6 +42,7 @@ #include #include #include +#include #include #include @@ -643,6 +644,8 @@ static void kvmgt_put_vfio_device(void *vgpu) vfio_device_put(((struct intel_vgpu *)vgpu)->vdev.vfio_device); } +static const struct vfio_mdev_device_ops intel_vfio_vgpu_dev_ops; + static int intel_vgpu_create(struct kobject *kobj, struct mdev_device *mdev) { struct intel_vgpu *vgpu = NULL; @@ -678,7 +681,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_ID_VFIO); + mdev_set_class(mdev, MDEV_ID_VFIO, &intel_vfio_vgpu_dev_ops); out: return ret; } @@ -1599,20 +1602,21 @@ static const struct attribute_group *intel_vgpu_groups[] = { NULL, }; -static struct mdev_parent_ops intel_vgpu_ops = { - .mdev_attr_groups = intel_vgpu_groups, - .create = intel_vgpu_create, - .remove = intel_vgpu_remove, - +static const struct vfio_mdev_device_ops intel_vfio_vgpu_dev_ops = { .open = intel_vgpu_open, .release = intel_vgpu_release, - .read = intel_vgpu_read, .write = intel_vgpu_write, .mmap = intel_vgpu_mmap, .ioctl = intel_vgpu_ioctl, }; +static struct mdev_parent_ops intel_vgpu_ops = { + .mdev_attr_groups = intel_vgpu_groups, + .create = intel_vgpu_create, + .remove = intel_vgpu_remove, +}; + static int kvmgt_host_init(struct device *dev, void *gvt, const void *ops) { struct attribute **kvm_type_attrs; diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_ops.c index b5d223882c6c..322991f0feb0 100644 --- a/drivers/s390/cio/vfio_ccw_ops.c +++ b/drivers/s390/cio/vfio_ccw_ops.c @@ -12,6 +12,7 @@ #include #include +#include #include #include @@ -110,6 +111,8 @@ static struct attribute_group *mdev_type_groups[] = { NULL, }; +static const struct vfio_mdev_device_ops vfio_mdev_ops; + static int vfio_ccw_mdev_create(struct kobject *kobj, struct mdev_device *mdev) { struct vfio_ccw_private *private = @@ -129,7 +132,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_ID_VFIO); + mdev_set_class(mdev, MDEV_ID_VFIO, &vfio_mdev_ops); return 0; } @@ -575,11 +578,7 @@ static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev, } } -static const struct mdev_parent_ops vfio_ccw_mdev_ops = { - .owner = THIS_MODULE, - .supported_type_groups = mdev_type_groups, - .create = vfio_ccw_mdev_create, - .remove = vfio_ccw_mdev_remove, +static const struct vfio_mdev_device_ops vfio_mdev_ops = { .open = vfio_ccw_mdev_open, .release = vfio_ccw_mdev_release, .read = vfio_ccw_mdev_read, @@ -587,6 +586,13 @@ static const struct mdev_parent_ops vfio_ccw_mdev_ops = { .ioctl = vfio_ccw_mdev_ioctl, }; +static const struct mdev_parent_ops vfio_ccw_mdev_ops = { + .owner = THIS_MODULE, + .supported_type_groups = mdev_type_groups, + .create = vfio_ccw_mdev_create, + .remove = vfio_ccw_mdev_remove, +}; + int vfio_ccw_mdev_reg(struct subchannel *sch) { return mdev_register_device(&sch->dev, &vfio_ccw_mdev_ops); diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c index 47df1c593c35..e9bd5f3b1cc2 100644 --- a/drivers/s390/crypto/vfio_ap_ops.c +++ b/drivers/s390/crypto/vfio_ap_ops.c @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -321,6 +322,8 @@ static void vfio_ap_matrix_init(struct ap_config_info *info, matrix->adm_max = info->apxa ? info->Nd : 15; } +static const struct vfio_mdev_device_ops vfio_mdev_ops; + static int vfio_ap_mdev_create(struct kobject *kobj, struct mdev_device *mdev) { struct ap_matrix_mdev *matrix_mdev; @@ -343,7 +346,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_ID_VFIO); + mdev_set_class(mdev, MDEV_ID_VFIO, &vfio_mdev_ops); return 0; } @@ -1281,15 +1284,18 @@ static ssize_t vfio_ap_mdev_ioctl(struct mdev_device *mdev, return ret; } +static const struct vfio_mdev_device_ops vfio_mdev_ops = { + .open = vfio_ap_mdev_open, + .release = vfio_ap_mdev_release, + .ioctl = vfio_ap_mdev_ioctl, +}; + static const struct mdev_parent_ops vfio_ap_matrix_ops = { .owner = THIS_MODULE, .supported_type_groups = vfio_ap_mdev_type_groups, .mdev_attr_groups = vfio_ap_mdev_attr_groups, .create = vfio_ap_mdev_create, .remove = vfio_ap_mdev_remove, - .open = vfio_ap_mdev_open, - .release = vfio_ap_mdev_release, - .ioctl = vfio_ap_mdev_ioctl, }; int vfio_ap_mdev_register(void) diff --git a/drivers/vfio/mdev/mdev_core.c b/drivers/vfio/mdev/mdev_core.c index 724e9b9841d8..c79d0e16522b 100644 --- a/drivers/vfio/mdev/mdev_core.c +++ b/drivers/vfio/mdev/mdev_core.c @@ -45,12 +45,19 @@ void mdev_set_drvdata(struct mdev_device *mdev, void *data) } EXPORT_SYMBOL(mdev_set_drvdata); -void mdev_set_class(struct mdev_device *mdev, u16 id) +void mdev_set_class(struct mdev_device *mdev, u16 id, const void *ops) { mdev->class_id = id; + mdev->device_ops = ops; } EXPORT_SYMBOL(mdev_set_class); +const void *mdev_get_dev_ops(struct mdev_device *mdev) +{ + return mdev->device_ops; +} +EXPORT_SYMBOL(mdev_get_dev_ops); + struct device *mdev_dev(struct mdev_device *mdev) { return &mdev->dev; diff --git a/drivers/vfio/mdev/mdev_private.h b/drivers/vfio/mdev/mdev_private.h index c65f436c1869..b666805f0b1f 100644 --- a/drivers/vfio/mdev/mdev_private.h +++ b/drivers/vfio/mdev/mdev_private.h @@ -34,6 +34,7 @@ struct mdev_device { struct device *iommu_device; bool active; u16 class_id; + const void *device_ops; }; #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 891cf83a2d9a..95efa054442f 100644 --- a/drivers/vfio/mdev/vfio_mdev.c +++ b/drivers/vfio/mdev/vfio_mdev.c @@ -14,6 +14,7 @@ #include #include #include +#include #include "mdev_private.h" @@ -24,16 +25,16 @@ static int vfio_mdev_open(void *device_data) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); int ret; - if (unlikely(!parent->ops->open)) + if (unlikely(!ops->open)) return -EINVAL; if (!try_module_get(THIS_MODULE)) return -ENODEV; - ret = parent->ops->open(mdev); + ret = ops->open(mdev); if (ret) module_put(THIS_MODULE); @@ -43,10 +44,10 @@ static int vfio_mdev_open(void *device_data) static void vfio_mdev_release(void *device_data) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); - if (likely(parent->ops->release)) - parent->ops->release(mdev); + if (likely(ops->release)) + ops->release(mdev); module_put(THIS_MODULE); } @@ -55,47 +56,47 @@ static long vfio_mdev_unlocked_ioctl(void *device_data, unsigned int cmd, unsigned long arg) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); - if (unlikely(!parent->ops->ioctl)) + if (unlikely(!ops->ioctl)) return -EINVAL; - return parent->ops->ioctl(mdev, cmd, arg); + return ops->ioctl(mdev, cmd, arg); } static ssize_t vfio_mdev_read(void *device_data, char __user *buf, size_t count, loff_t *ppos) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); - if (unlikely(!parent->ops->read)) + if (unlikely(!ops->read)) return -EINVAL; - return parent->ops->read(mdev, buf, count, ppos); + return ops->read(mdev, buf, count, ppos); } static ssize_t vfio_mdev_write(void *device_data, const char __user *buf, size_t count, loff_t *ppos) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); - if (unlikely(!parent->ops->write)) + if (unlikely(!ops->write)) return -EINVAL; - return parent->ops->write(mdev, buf, count, ppos); + return ops->write(mdev, buf, count, ppos); } static int vfio_mdev_mmap(void *device_data, struct vm_area_struct *vma) { struct mdev_device *mdev = device_data; - struct mdev_parent *parent = mdev->parent; + const struct vfio_mdev_device_ops *ops = mdev_get_dev_ops(mdev); - if (unlikely(!parent->ops->mmap)) + if (unlikely(!ops->mmap)) return -EINVAL; - return parent->ops->mmap(mdev, vma); + return ops->mmap(mdev, vma); } static const struct vfio_device_ops vfio_mdev_dev_ops = { diff --git a/include/linux/mdev.h b/include/linux/mdev.h index a7570cf13ba4..f491308674e5 100644 --- a/include/linux/mdev.h +++ b/include/linux/mdev.h @@ -10,6 +10,11 @@ #ifndef MDEV_H #define MDEV_H +#include +#include +#include +#include + struct mdev_device; /* @@ -48,30 +53,7 @@ struct device *mdev_get_iommu_device(struct device *dev); * @mdev: mdev_device device structure which is being * destroyed * Returns integer: success (0) or error (< 0) - * @open: Open mediated device. - * @mdev: mediated device. - * Returns integer: success (0) or error (< 0) - * @release: release mediated device - * @mdev: mediated device. - * @read: Read emulation callback - * @mdev: mediated device structure - * @buf: read buffer - * @count: number of bytes to read - * @ppos: address. - * Retuns number on bytes read on success or error. - * @write: Write emulation callback - * @mdev: mediated device structure - * @buf: write buffer - * @count: number of bytes to be written - * @ppos: address. - * Retuns number on bytes written on success or error. - * @ioctl: IOCTL callback - * @mdev: mediated device structure - * @cmd: ioctl command - * @arg: arguments to ioctl - * @mmap: mmap callback - * @mdev: mediated device structure - * @vma: vma structure + * * Parent device that support mediated device should be registered with mdev * module with mdev_parent_ops structure. **/ @@ -83,15 +65,6 @@ struct mdev_parent_ops { int (*create)(struct kobject *kobj, struct mdev_device *mdev); int (*remove)(struct mdev_device *mdev); - int (*open)(struct mdev_device *mdev); - void (*release)(struct mdev_device *mdev); - ssize_t (*read)(struct mdev_device *mdev, char __user *buf, - size_t count, loff_t *ppos); - ssize_t (*write)(struct mdev_device *mdev, const char __user *buf, - size_t count, loff_t *ppos); - long (*ioctl)(struct mdev_device *mdev, unsigned int cmd, - unsigned long arg); - int (*mmap)(struct mdev_device *mdev, struct vm_area_struct *vma); }; /* interface for exporting mdev supported type attributes */ @@ -133,7 +106,8 @@ struct mdev_driver { void *mdev_get_drvdata(struct mdev_device *mdev); void mdev_set_drvdata(struct mdev_device *mdev, void *data); -void mdev_set_class(struct mdev_device *mdev, u16 id); +void mdev_set_class(struct mdev_device *mdev, u16 id, const void *ops); +const void *mdev_get_dev_ops(struct mdev_device *mdev); const guid_t *mdev_uuid(struct mdev_device *mdev); extern struct bus_type mdev_bus_type; diff --git a/include/linux/vfio_mdev.h b/include/linux/vfio_mdev.h new file mode 100644 index 000000000000..3907c5371c2b --- /dev/null +++ b/include/linux/vfio_mdev.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * VFIO Mediated device definition + */ + +#ifndef VFIO_MDEV_H +#define VFIO_MDEV_H + +#include + +/** + * struct vfio_mdev_device_ops - Structure to be registered for each + * mdev device to register the device to vfio-mdev module. + * + * @open: Open mediated device. + * @mdev: mediated device. + * Returns integer: success (0) or error (< 0) + * @release: release mediated device + * @mdev: mediated device. + * @read: Read emulation callback + * @mdev: mediated device structure + * @buf: read buffer + * @count: number of bytes to read + * @ppos: address. + * Retuns number on bytes read on success or error. + * @write: Write emulation callback + * @mdev: mediated device structure + * @buf: write buffer + * @count: number of bytes to be written + * @ppos: address. + * Retuns number on bytes written on success or error. + * @ioctl: IOCTL callback + * @mdev: mediated device structure + * @cmd: ioctl command + * @arg: arguments to ioctl + * @mmap: mmap callback + * @mdev: mediated device structure + * @vma: vma structure + */ +struct vfio_mdev_device_ops { + int (*open)(struct mdev_device *mdev); + void (*release)(struct mdev_device *mdev); + ssize_t (*read)(struct mdev_device *mdev, char __user *buf, + size_t count, loff_t *ppos); + ssize_t (*write)(struct mdev_device *mdev, const char __user *buf, + size_t count, loff_t *ppos); + long (*ioctl)(struct mdev_device *mdev, unsigned int cmd, + unsigned long arg); + int (*mmap)(struct mdev_device *mdev, struct vm_area_struct *vma); +}; + +#endif diff --git a/samples/vfio-mdev/mbochs.c b/samples/vfio-mdev/mbochs.c index fd8491e58fe2..9db771ed5e4b 100644 --- a/samples/vfio-mdev/mbochs.c +++ b/samples/vfio-mdev/mbochs.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -516,6 +517,8 @@ static int mbochs_reset(struct mdev_device *mdev) return 0; } +static const struct vfio_mdev_device_ops vfio_mdev_ops; + static int mbochs_create(struct kobject *kobj, struct mdev_device *mdev) { const struct mbochs_type *type = mbochs_find_type(kobj); @@ -561,7 +564,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_ID_VFIO); + mdev_set_class(mdev, MDEV_ID_VFIO, &vfio_mdev_ops); return 0; err_mem: @@ -1419,12 +1422,7 @@ static struct attribute_group *mdev_type_groups[] = { NULL, }; -static const struct mdev_parent_ops mdev_fops = { - .owner = THIS_MODULE, - .mdev_attr_groups = mdev_dev_groups, - .supported_type_groups = mdev_type_groups, - .create = mbochs_create, - .remove = mbochs_remove, +static const struct vfio_mdev_device_ops vfio_mdev_ops = { .open = mbochs_open, .release = mbochs_close, .read = mbochs_read, @@ -1433,6 +1431,14 @@ static const struct mdev_parent_ops mdev_fops = { .mmap = mbochs_mmap, }; +static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mbochs_create, + .remove = mbochs_remove, +}; + static const struct file_operations vd_fops = { .owner = THIS_MODULE, }; diff --git a/samples/vfio-mdev/mdpy.c b/samples/vfio-mdev/mdpy.c index 889472b06708..f0fdbc6ec706 100644 --- a/samples/vfio-mdev/mdpy.c +++ b/samples/vfio-mdev/mdpy.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include "mdpy-defs.h" @@ -226,6 +227,8 @@ static int mdpy_reset(struct mdev_device *mdev) return 0; } +static const struct vfio_mdev_device_ops vfio_mdev_ops; + static int mdpy_create(struct kobject *kobj, struct mdev_device *mdev) { const struct mdpy_type *type = mdpy_find_type(kobj); @@ -269,7 +272,8 @@ static int mdpy_create(struct kobject *kobj, struct mdev_device *mdev) mdpy_reset(mdev); mdpy_count++; - mdev_set_class(mdev, MDEV_ID_VFIO); + + mdev_set_class(mdev, MDEV_ID_VFIO, &vfio_mdev_ops); return 0; } @@ -726,12 +730,7 @@ static struct attribute_group *mdev_type_groups[] = { NULL, }; -static const struct mdev_parent_ops mdev_fops = { - .owner = THIS_MODULE, - .mdev_attr_groups = mdev_dev_groups, - .supported_type_groups = mdev_type_groups, - .create = mdpy_create, - .remove = mdpy_remove, +static const struct vfio_mdev_device_ops vfio_mdev_ops = { .open = mdpy_open, .release = mdpy_close, .read = mdpy_read, @@ -740,6 +739,14 @@ static const struct mdev_parent_ops mdev_fops = { .mmap = mdpy_mmap, }; +static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mdpy_create, + .remove = mdpy_remove, +}; + static const struct file_operations vd_fops = { .owner = THIS_MODULE, }; diff --git a/samples/vfio-mdev/mtty.c b/samples/vfio-mdev/mtty.c index 618810ca4331..18d0f83a228a 100644 --- a/samples/vfio-mdev/mtty.c +++ b/samples/vfio-mdev/mtty.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -708,6 +709,8 @@ static ssize_t mdev_access(struct mdev_device *mdev, u8 *buf, size_t count, return ret; } +static const struct vfio_mdev_device_ops vfio_dev_ops; + static int mtty_create(struct kobject *kobj, struct mdev_device *mdev) { struct mdev_state *mdev_state; @@ -755,7 +758,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_ID_VFIO); + mdev_set_class(mdev, MDEV_ID_VFIO, &vfio_dev_ops); return 0; } @@ -1388,6 +1391,14 @@ static struct attribute_group *mdev_type_groups[] = { NULL, }; +static const struct vfio_mdev_device_ops vfio_dev_ops = { + .open = mtty_open, + .release = mtty_close, + .read = mtty_read, + .write = mtty_write, + .ioctl = mtty_ioctl, +}; + static const struct mdev_parent_ops mdev_fops = { .owner = THIS_MODULE, .dev_attr_groups = mtty_dev_groups, @@ -1395,11 +1406,6 @@ static const struct mdev_parent_ops mdev_fops = { .supported_type_groups = mdev_type_groups, .create = mtty_create, .remove = mtty_remove, - .open = mtty_open, - .release = mtty_close, - .read = mtty_read, - .write = mtty_write, - .ioctl = mtty_ioctl, }; static void mtty_device_release(struct device *dev) -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V3 4/7] mdev: introduce device specific ops Date: Fri, 11 Oct 2019 16:15:54 +0800 Message-ID: <20191011081557.28302-5-jasowang@redhat.com> References: <20191011081557.28302-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191011081557.28302-1-jasowang@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" 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, Jason Wang , heiko.carstens@de.ibm.com, kevin.tian@intel.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, cunming.liang@intel.com, rodrigo.vivi@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 Q3VycmVudGx5LCBleGNlcHQgZm9yIHRoZSBjcmVhdGUgYW5kIHJlbW92ZSwgdGhlIHJlc3Qgb2YK bWRldl9wYXJlbnRfb3BzIGlzIGRlc2lnbmVkIGZvciB2ZmlvLW1kZXYgZHJpdmVyIG9ubHkgYW5k IG1heSBub3QgaGVscApmb3Iga2VybmVsIG1kZXYgZHJpdmVyLiBXaXRoIHRoZSBoZWxwIG9mIGNs YXNzIGlkLCB0aGlzIHBhdGNoCmludHJvZHVjZXMgZGV2aWNlIHNwZWNpZmljIGNhbGxiYWNrcyBp bnNpZGUgbWRldl9kZXZpY2UKc3RydWN0dXJlLiBUaGlzIGFsbG93cyBkaWZmZXJlbnQgc2V0IG9m IGNhbGxiYWNrIHRvIGJlIHVzZWQgYnkKdmZpby1tZGV2IGFuZCB2aXJ0aW8tbWRldi4KClNpZ25l ZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogLi4uL2RyaXZl ci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0ICAgICAgIHwgMjIgKysrKystLS0KIE1BSU5U QUlORVJTICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxICsKIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jICAgICAgICAgICAgICB8IDE4ICsrKystLS0KIGRyaXZl cnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMgICAgICAgICAgICAgICB8IDE4ICsrKystLS0KIGRy aXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMuYyAgICAgICAgICAgICB8IDE0ICsrKy0tCiBk cml2ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYyAgICAgICAgICAgICAgICAgfCAgOSArKystCiBk cml2ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZhdGUuaCAgICAgICAgICAgICAgfCAgMSArCiBkcml2 ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYyAgICAgICAgICAgICAgICAgfCAzNyArKysrKystLS0t LS0tCiBpbmNsdWRlL2xpbnV4L21kZXYuaCAgICAgICAgICAgICAgICAgICAgICAgICAgfCA0MiAr KystLS0tLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvdmZpb19tZGV2LmggICAgICAgICAgICAgICAg ICAgICB8IDUyICsrKysrKysrKysrKysrKysrKysKIHNhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5j ICAgICAgICAgICAgICAgICAgICB8IDIwICsrKystLS0KIHNhbXBsZXMvdmZpby1tZGV2L21kcHku YyAgICAgICAgICAgICAgICAgICAgICB8IDIxICsrKysrLS0tCiBzYW1wbGVzL3ZmaW8tbWRldi9t dHR5LmMgICAgICAgICAgICAgICAgICAgICAgfCAxOCArKysrLS0tCiAxMyBmaWxlcyBjaGFuZ2Vk LCAxNzcgaW5zZXJ0aW9ucygrKSwgOTYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQg aW5jbHVkZS9saW51eC92ZmlvX21kZXYuaAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJp dmVyLWFwaS92ZmlvLW1lZGlhdGVkLWRldmljZS5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1h cGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0CmluZGV4IDIwMzVlNDhkYTdiMi4uNTUzNTc0ZWJi YTczIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvdmZpby1tZWRpYXRlZC1k ZXZpY2UucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS92ZmlvLW1lZGlhdGVkLWRl dmljZS5yc3QKQEAgLTE1MiwxMSArMTUyLDIwIEBAIGNhbGxiYWNrcyBwZXIgbWRldiBwYXJlbnQg ZGV2aWNlLCBwZXIgbWRldiB0eXBlLCBvciBhbnkgb3RoZXIgY2F0ZWdvcml6YXRpb24uCiBWZW5k b3IgZHJpdmVycyBhcmUgZXhwZWN0ZWQgdG8gYmUgZnVsbHkgYXN5bmNocm9ub3VzIGluIHRoaXMg cmVzcGVjdCBvcgogcHJvdmlkZSB0aGVpciBvd24gaW50ZXJuYWwgcmVzb3VyY2UgcHJvdGVjdGlv bi4pCiAKLVRoZSBjYWxsYmFja3MgaW4gdGhlIG1kZXZfcGFyZW50X29wcyBzdHJ1Y3R1cmUgYXJl IGFzIGZvbGxvd3M6CitJbiBvcmRlciB0byBzdXBwb3J0IG11bHRpcGxlIHR5cGVzIG9mIGRldmlj ZS9kcml2ZXIsIGRldmljZSBuZWVkcyB0bworcHJvdmlkZSBib3RoIGNsYXNzX2lkIGFuZCBkZXZp Y2Vfb3BzIHRocm91Z2g6CiAKLSogb3Blbjogb3BlbiBjYWxsYmFjayBvZiBtZWRpYXRlZCBkZXZp Y2UKLSogY2xvc2U6IGNsb3NlIGNhbGxiYWNrIG9mIG1lZGlhdGVkIGRldmljZQotKiBpb2N0bDog aW9jdGwgY2FsbGJhY2sgb2YgbWVkaWF0ZWQgZGV2aWNlCisgICAgdm9pZCBtZGV2X3NldF9jbGFz cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZCwgY29uc3Qgdm9pZCAqb3BzKTsKKwor VGhlIGNsYXNzX2lkIGlzIHVzZWQgdG8gYmUgcGFpcmVkIHdpdGggaWRzIGluIGlkX3RhYmxlIGlu IG1kZXZfZHJpdmVyCitzdHJ1Y3R1cmUgZm9yIHByb2JpbmcgdGhlIGNvcnJlY3QgZHJpdmVyLiBU aGUgZGV2aWNlX29wcyBpcyBkZXZpY2UKK3NwZWNpZmljIGNhbGxiYWNrcyB3aGljaCBjYW4gYmUg Z2V0IHRocm91Z2ggbWRldl9nZXRfZGV2X29wcygpCitmdW5jdGlvbiBieSBtZGV2IGJ1cyBkcml2 ZXIuIEZvciB2ZmlvLW1kZXYgZGV2aWNlLCBpdHMgZGV2aWNlIHNwZWNpZmljCitvcHMgYXJlIGFz IGZvbGxvd3M6CisKKyogb3Blbjogb3BlbiBjYWxsYmFjayBvZiB2ZmlvIG1lZGlhdGVkIGRldmlj ZQorKiBjbG9zZTogY2xvc2UgY2FsbGJhY2sgb2YgdmZpbyBtZWRpYXRlZCBkZXZpY2UKKyogaW9j dGw6IGlvY3RsIGNhbGxiYWNrIG9mIHZmaW8gbWVkaWF0ZWQgZGV2aWNlCiAqIHJlYWQgOiByZWFk IGVtdWxhdGlvbiBjYWxsYmFjawogKiB3cml0ZTogd3JpdGUgZW11bGF0aW9uIGNhbGxiYWNrCiAq IG1tYXA6IG1tYXAgZW11bGF0aW9uIGNhbGxiYWNrCkBAIC0xNjcsOSArMTc2LDEwIEBAIHJlZ2lz dGVyIGl0c2VsZiB3aXRoIHRoZSBtZGV2IGNvcmUgZHJpdmVyOjoKIAlleHRlcm4gaW50ICBtZGV2 X3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgY29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyAqb3BzKTsKIAotSXQg aXMgYWxzbyByZXF1aXJlZCB0byBzcGVjaWZ5IHRoZSBjbGFzc19pZCB0aHJvdWdoOjoKK0l0IGlz IGFsc28gcmVxdWlyZWQgdG8gc3BlY2lmeSB0aGUgY2xhc3NfaWQgYW5kIGRldmljZSBzcGVjaWZp YyBvcHMgdGhyb3VnaDo6CiAKLQlleHRlcm4gaW50IG1kZXZfc2V0X2NsYXNzKHN0cnVjdCBkZXZp Y2UgKmRldiwgdTE2IGlkKTsKKwlleHRlcm4gaW50IG1kZXZfc2V0X2NsYXNzKHN0cnVjdCBkZXZp Y2UgKmRldiwgdTE2IGlkLAorCSAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgdm9pZCAq b3BzKTsKIAogSG93ZXZlciwgdGhlIG1kZXZfcGFyZW50X29wcyBzdHJ1Y3R1cmUgaXMgbm90IHJl cXVpcmVkIGluIHRoZSBmdW5jdGlvbiBjYWxsCiB0aGF0IGEgZHJpdmVyIHNob3VsZCB1c2UgdG8g dW5yZWdpc3RlciBpdHNlbGYgd2l0aCB0aGUgbWRldiBjb3JlIGRyaXZlcjo6CmRpZmYgLS1naXQg YS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDg4MjRmNjFjZDJjMC4uM2QxOTZhMDIz YjVlIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtMTcxMjcs NiArMTcxMjcsNyBAQCBTOglNYWludGFpbmVkCiBGOglEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkv dmZpby1tZWRpYXRlZC1kZXZpY2UucnN0CiBGOglkcml2ZXJzL3ZmaW8vbWRldi8KIEY6CWluY2x1 ZGUvbGludXgvbWRldi5oCitGOglpbmNsdWRlL2xpbnV4L3ZmaW9fbWRldi5oCiBGOglzYW1wbGVz L3ZmaW8tbWRldi8KIAogVkZJTyBQTEFURk9STSBEUklWRVIKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L2t2bWd0 LmMKaW5kZXggMTdlOWQ0NjM0Yzg0Li43ZTJiNzIwMDc0ZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9r dm1ndC5jCkBAIC00Miw2ICs0Miw3IEBACiAjaW5jbHVkZSA8bGludXgva3ZtX2hvc3QuaD4KICNp bmNsdWRlIDxsaW51eC92ZmlvLmg+CiAjaW5jbHVkZSA8bGludXgvbWRldi5oPgorI2luY2x1ZGUg PGxpbnV4L3ZmaW9fbWRldi5oPgogI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KIAogI2luY2x1 ZGUgPGxpbnV4L25vc3BlYy5oPgpAQCAtNjQzLDYgKzY0NCw4IEBAIHN0YXRpYyB2b2lkIGt2bWd0 X3B1dF92ZmlvX2RldmljZSh2b2lkICp2Z3B1KQogCXZmaW9fZGV2aWNlX3B1dCgoKHN0cnVjdCBp bnRlbF92Z3B1ICopdmdwdSktPnZkZXYudmZpb19kZXZpY2UpOwogfQogCitzdGF0aWMgY29uc3Qg c3RydWN0IHZmaW9fbWRldl9kZXZpY2Vfb3BzIGludGVsX3ZmaW9fdmdwdV9kZXZfb3BzOworCiBz dGF0aWMgaW50IGludGVsX3ZncHVfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYpCiB7CiAJc3RydWN0IGludGVsX3ZncHUgKnZncHUgPSBOVUxMOwpA QCAtNjc4LDcgKzY4MSw3IEBAIHN0YXRpYyBpbnQgaW50ZWxfdmdwdV9jcmVhdGUoc3RydWN0IGtv YmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIAkJICAgICBkZXZfbmFtZSht ZGV2X2RldihtZGV2KSkpOwogCXJldCA9IDA7CiAKLQltZGV2X3NldF9jbGFzcyhtZGV2LCBNREVW X0lEX1ZGSU8pOworCW1kZXZfc2V0X2NsYXNzKG1kZXYsIE1ERVZfSURfVkZJTywgJmludGVsX3Zm aW9fdmdwdV9kZXZfb3BzKTsKIG91dDoKIAlyZXR1cm4gcmV0OwogfQpAQCAtMTU5OSwyMCArMTYw MiwyMSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqaW50ZWxfdmdwdV9n cm91cHNbXSA9IHsKIAlOVUxMLAogfTsKIAotc3RhdGljIHN0cnVjdCBtZGV2X3BhcmVudF9vcHMg aW50ZWxfdmdwdV9vcHMgPSB7Ci0JLm1kZXZfYXR0cl9ncm91cHMgICAgICAgPSBpbnRlbF92Z3B1 X2dyb3VwcywKLQkuY3JlYXRlCQkJPSBpbnRlbF92Z3B1X2NyZWF0ZSwKLQkucmVtb3ZlCQkJPSBp bnRlbF92Z3B1X3JlbW92ZSwKLQorc3RhdGljIGNvbnN0IHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNl X29wcyBpbnRlbF92ZmlvX3ZncHVfZGV2X29wcyA9IHsKIAkub3BlbgkJCT0gaW50ZWxfdmdwdV9v cGVuLAogCS5yZWxlYXNlCQk9IGludGVsX3ZncHVfcmVsZWFzZSwKLQogCS5yZWFkCQkJPSBpbnRl bF92Z3B1X3JlYWQsCiAJLndyaXRlCQkJPSBpbnRlbF92Z3B1X3dyaXRlLAogCS5tbWFwCQkJPSBp bnRlbF92Z3B1X21tYXAsCiAJLmlvY3RsCQkJPSBpbnRlbF92Z3B1X2lvY3RsLAogfTsKIAorc3Rh dGljIHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgaW50ZWxfdmdwdV9vcHMgPSB7CisJLm1kZXZfYXR0 cl9ncm91cHMgICAgICAgPSBpbnRlbF92Z3B1X2dyb3VwcywKKwkuY3JlYXRlCQkJPSBpbnRlbF92 Z3B1X2NyZWF0ZSwKKwkucmVtb3ZlCQkJPSBpbnRlbF92Z3B1X3JlbW92ZSwKK307CisKIHN0YXRp YyBpbnQga3ZtZ3RfaG9zdF9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZ3Z0LCBjb25z dCB2b2lkICpvcHMpCiB7CiAJc3RydWN0IGF0dHJpYnV0ZSAqKmt2bV90eXBlX2F0dHJzOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Npby92ZmlvX2Njd19vcHMuYyBiL2RyaXZlcnMvczM5MC9j aW8vdmZpb19jY3dfb3BzLmMKaW5kZXggYjVkMjIzODgyYzZjLi4zMjI5OTFmMGZlYjAgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vdmZpb19jY3dfb3BzLmMKKysrIGIvZHJpdmVycy9zMzkw L2Npby92ZmlvX2Njd19vcHMuYwpAQCAtMTIsNiArMTIsNyBAQAogCiAjaW5jbHVkZSA8bGludXgv dmZpby5oPgogI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92ZmlvX21k ZXYuaD4KICNpbmNsdWRlIDxsaW51eC9ub3NwZWMuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ CiAKQEAgLTExMCw2ICsxMTEsOCBAQCBzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqbWRl dl90eXBlX2dyb3Vwc1tdID0gewogCU5VTEwsCiB9OwogCitzdGF0aWMgY29uc3Qgc3RydWN0IHZm aW9fbWRldl9kZXZpY2Vfb3BzIHZmaW9fbWRldl9vcHM7CisKIHN0YXRpYyBpbnQgdmZpb19jY3df bWRldl9jcmVhdGUoc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRl dikKIHsKIAlzdHJ1Y3QgdmZpb19jY3dfcHJpdmF0ZSAqcHJpdmF0ZSA9CkBAIC0xMjksNyArMTMy LDcgQEAgc3RhdGljIGludCB2ZmlvX2Njd19tZGV2X2NyZWF0ZShzdHJ1Y3Qga29iamVjdCAqa29i aiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCQkJICAgcHJpdmF0ZS0+c2NoLT5zY2hpZC5z c2lkLAogCQkJICAgcHJpdmF0ZS0+c2NoLT5zY2hpZC5zY2hfbm8pOwogCi0JbWRldl9zZXRfY2xh c3MobWRldiwgTURFVl9JRF9WRklPKTsKKwltZGV2X3NldF9jbGFzcyhtZGV2LCBNREVWX0lEX1ZG SU8sICZ2ZmlvX21kZXZfb3BzKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNTc1LDExICs1NzgsNyBA QCBzdGF0aWMgc3NpemVfdCB2ZmlvX2Njd19tZGV2X2lvY3RsKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwKIAl9CiB9CiAKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3BzIHZmaW9f Y2N3X21kZXZfb3BzID0gewotCS5vd25lcgkJCT0gVEhJU19NT0RVTEUsCi0JLnN1cHBvcnRlZF90 eXBlX2dyb3VwcyAgPSBtZGV2X3R5cGVfZ3JvdXBzLAotCS5jcmVhdGUJCQk9IHZmaW9fY2N3X21k ZXZfY3JlYXRlLAotCS5yZW1vdmUJCQk9IHZmaW9fY2N3X21kZXZfcmVtb3ZlLAorc3RhdGljIGNv bnN0IHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyB2ZmlvX21kZXZfb3BzID0gewogCS5vcGVu CQkJPSB2ZmlvX2Njd19tZGV2X29wZW4sCiAJLnJlbGVhc2UJCT0gdmZpb19jY3dfbWRldl9yZWxl YXNlLAogCS5yZWFkCQkJPSB2ZmlvX2Njd19tZGV2X3JlYWQsCkBAIC01ODcsNiArNTg2LDEzIEBA IHN0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3BzIHZmaW9fY2N3X21kZXZfb3BzID0g ewogCS5pb2N0bAkJCT0gdmZpb19jY3dfbWRldl9pb2N0bCwKIH07CiAKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgbWRldl9wYXJlbnRfb3BzIHZmaW9fY2N3X21kZXZfb3BzID0geworCS5vd25lcgkJCT0g VEhJU19NT0RVTEUsCisJLnN1cHBvcnRlZF90eXBlX2dyb3VwcyAgPSBtZGV2X3R5cGVfZ3JvdXBz LAorCS5jcmVhdGUJCQk9IHZmaW9fY2N3X21kZXZfY3JlYXRlLAorCS5yZW1vdmUJCQk9IHZmaW9f Y2N3X21kZXZfcmVtb3ZlLAorfTsKKwogaW50IHZmaW9fY2N3X21kZXZfcmVnKHN0cnVjdCBzdWJj aGFubmVsICpzY2gpCiB7CiAJcmV0dXJuIG1kZXZfcmVnaXN0ZXJfZGV2aWNlKCZzY2gtPmRldiwg JnZmaW9fY2N3X21kZXZfb3BzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9jcnlwdG8vdmZp b19hcF9vcHMuYyBiL2RyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMuYwppbmRleCA0N2Rm MWM1OTNjMzUuLmU5YmQ1ZjNiMWNjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2NyeXB0by92 ZmlvX2FwX29wcy5jCisrKyBiL2RyaXZlcnMvczM5MC9jcnlwdG8vdmZpb19hcF9vcHMuYwpAQCAt MTYsNiArMTYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgogI2luY2x1ZGUgPGxpbnV4 L2t2bV9ob3N0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgv dmZpb19tZGV2Lmg+CiAjaW5jbHVkZSA8YXNtL2t2bS5oPgogI2luY2x1ZGUgPGFzbS96Y3J5cHQu aD4KIApAQCAtMzIxLDYgKzMyMiw4IEBAIHN0YXRpYyB2b2lkIHZmaW9fYXBfbWF0cml4X2luaXQo c3RydWN0IGFwX2NvbmZpZ19pbmZvICppbmZvLAogCW1hdHJpeC0+YWRtX21heCA9IGluZm8tPmFw eGEgPyBpbmZvLT5OZCA6IDE1OwogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IHZmaW9fbWRldl9k ZXZpY2Vfb3BzIHZmaW9fbWRldl9vcHM7CisKIHN0YXRpYyBpbnQgdmZpb19hcF9tZGV2X2NyZWF0 ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogewogCXN0 cnVjdCBhcF9tYXRyaXhfbWRldiAqbWF0cml4X21kZXY7CkBAIC0zNDMsNyArMzQ2LDcgQEAgc3Rh dGljIGludCB2ZmlvX2FwX21kZXZfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYpCiAJbGlzdF9hZGQoJm1hdHJpeF9tZGV2LT5ub2RlLCAmbWF0cml4 X2Rldi0+bWRldl9saXN0KTsKIAltdXRleF91bmxvY2soJm1hdHJpeF9kZXYtPmxvY2spOwogCi0J bWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9JRF9WRklPKTsKKwltZGV2X3NldF9jbGFzcyhtZGV2 LCBNREVWX0lEX1ZGSU8sICZ2ZmlvX21kZXZfb3BzKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTI4 MSwxNSArMTI4NCwxOCBAQCBzdGF0aWMgc3NpemVfdCB2ZmlvX2FwX21kZXZfaW9jdGwoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2LAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgdmZpb19tZGV2X2RldmljZV9vcHMgdmZpb19tZGV2X29wcyA9IHsKKwkub3BlbgkJCT0gdmZp b19hcF9tZGV2X29wZW4sCisJLnJlbGVhc2UJCT0gdmZpb19hcF9tZGV2X3JlbGVhc2UsCisJLmlv Y3RsCQkJPSB2ZmlvX2FwX21kZXZfaW9jdGwsCit9OworCiBzdGF0aWMgY29uc3Qgc3RydWN0IG1k ZXZfcGFyZW50X29wcyB2ZmlvX2FwX21hdHJpeF9vcHMgPSB7CiAJLm93bmVyCQkJPSBUSElTX01P RFVMRSwKIAkuc3VwcG9ydGVkX3R5cGVfZ3JvdXBzCT0gdmZpb19hcF9tZGV2X3R5cGVfZ3JvdXBz LAogCS5tZGV2X2F0dHJfZ3JvdXBzCT0gdmZpb19hcF9tZGV2X2F0dHJfZ3JvdXBzLAogCS5jcmVh dGUJCQk9IHZmaW9fYXBfbWRldl9jcmVhdGUsCiAJLnJlbW92ZQkJCT0gdmZpb19hcF9tZGV2X3Jl bW92ZSwKLQkub3BlbgkJCT0gdmZpb19hcF9tZGV2X29wZW4sCi0JLnJlbGVhc2UJCT0gdmZpb19h cF9tZGV2X3JlbGVhc2UsCi0JLmlvY3RsCQkJPSB2ZmlvX2FwX21kZXZfaW9jdGwsCiB9OwogCiBp bnQgdmZpb19hcF9tZGV2X3JlZ2lzdGVyKHZvaWQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZmaW8v bWRldi9tZGV2X2NvcmUuYyBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfY29yZS5jCmluZGV4IDcy NGU5Yjk4NDFkOC4uYzc5ZDBlMTY1MjJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZmaW8vbWRldi9t ZGV2X2NvcmUuYworKysgYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYwpAQCAtNDUsMTIg KzQ1LDE5IEBAIHZvaWQgbWRldl9zZXRfZHJ2ZGF0YShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYs IHZvaWQgKmRhdGEpCiB9CiBFWFBPUlRfU1lNQk9MKG1kZXZfc2V0X2RydmRhdGEpOwogCi12b2lk IG1kZXZfc2V0X2NsYXNzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkKQordm9pZCBt ZGV2X3NldF9jbGFzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZCwgY29uc3Qgdm9p ZCAqb3BzKQogewogCW1kZXYtPmNsYXNzX2lkID0gaWQ7CisJbWRldi0+ZGV2aWNlX29wcyA9IG9w czsKIH0KIEVYUE9SVF9TWU1CT0wobWRldl9zZXRfY2xhc3MpOwogCitjb25zdCB2b2lkICptZGV2 X2dldF9kZXZfb3BzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gbWRldi0+ ZGV2aWNlX29wczsKK30KK0VYUE9SVF9TWU1CT0wobWRldl9nZXRfZGV2X29wcyk7CisKIHN0cnVj dCBkZXZpY2UgKm1kZXZfZGV2KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIHsKIAlyZXR1cm4g Jm1kZXYtPmRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5o IGIvZHJpdmVycy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmgKaW5kZXggYzY1ZjQzNmMxODY5Li5i NjY2ODA1ZjBiMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5o CisrKyBiL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oCkBAIC0zNCw2ICszNCw3IEBA IHN0cnVjdCBtZGV2X2RldmljZSB7CiAJc3RydWN0IGRldmljZSAqaW9tbXVfZGV2aWNlOwogCWJv b2wgYWN0aXZlOwogCXUxNiBjbGFzc19pZDsKKwljb25zdCB2b2lkICpkZXZpY2Vfb3BzOwogfTsK IAogI2RlZmluZSB0b19tZGV2X2RldmljZShkZXYpCWNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBt ZGV2X2RldmljZSwgZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZmlvL21kZXYvdmZpb19tZGV2 LmMgYi9kcml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYwppbmRleCA4OTFjZjgzYTJkOWEuLjk1 ZWZhMDU0NDQyZiAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL21kZXYvdmZpb19tZGV2LmMKKysr IGIvZHJpdmVycy92ZmlvL21kZXYvdmZpb19tZGV2LmMKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNs dWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvdmZpby5oPgogI2luY2x1ZGUgPGxp bnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92ZmlvX21kZXYuaD4KIAogI2luY2x1ZGUgIm1k ZXZfcHJpdmF0ZS5oIgogCkBAIC0yNCwxNiArMjUsMTYgQEAKIHN0YXRpYyBpbnQgdmZpb19tZGV2 X29wZW4odm9pZCAqZGV2aWNlX2RhdGEpCiB7CiAJc3RydWN0IG1kZXZfZGV2aWNlICptZGV2ID0g ZGV2aWNlX2RhdGE7Ci0Jc3RydWN0IG1kZXZfcGFyZW50ICpwYXJlbnQgPSBtZGV2LT5wYXJlbnQ7 CisJY29uc3Qgc3RydWN0IHZmaW9fbWRldl9kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF9kZXZf b3BzKG1kZXYpOwogCWludCByZXQ7CiAKLQlpZiAodW5saWtlbHkoIXBhcmVudC0+b3BzLT5vcGVu KSkKKwlpZiAodW5saWtlbHkoIW9wcy0+b3BlbikpCiAJCXJldHVybiAtRUlOVkFMOwogCiAJaWYg KCF0cnlfbW9kdWxlX2dldChUSElTX01PRFVMRSkpCiAJCXJldHVybiAtRU5PREVWOwogCi0JcmV0 ID0gcGFyZW50LT5vcHMtPm9wZW4obWRldik7CisJcmV0ID0gb3BzLT5vcGVuKG1kZXYpOwogCWlm IChyZXQpCiAJCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUpOwogCkBAIC00MywxMCArNDQsMTAgQEAg c3RhdGljIGludCB2ZmlvX21kZXZfb3Blbih2b2lkICpkZXZpY2VfZGF0YSkKIHN0YXRpYyB2b2lk IHZmaW9fbWRldl9yZWxlYXNlKHZvaWQgKmRldmljZV9kYXRhKQogewogCXN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiA9IGRldmljZV9kYXRhOwotCXN0cnVjdCBtZGV2X3BhcmVudCAqcGFyZW50ID0g bWRldi0+cGFyZW50OworCWNvbnN0IHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyAqb3BzID0g bWRldl9nZXRfZGV2X29wcyhtZGV2KTsKIAotCWlmIChsaWtlbHkocGFyZW50LT5vcHMtPnJlbGVh c2UpKQotCQlwYXJlbnQtPm9wcy0+cmVsZWFzZShtZGV2KTsKKwlpZiAobGlrZWx5KG9wcy0+cmVs ZWFzZSkpCisJCW9wcy0+cmVsZWFzZShtZGV2KTsKIAogCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUp OwogfQpAQCAtNTUsNDcgKzU2LDQ3IEBAIHN0YXRpYyBsb25nIHZmaW9fbWRldl91bmxvY2tlZF9p b2N0bCh2b2lkICpkZXZpY2VfZGF0YSwKIAkJCQkgICAgIHVuc2lnbmVkIGludCBjbWQsIHVuc2ln bmVkIGxvbmcgYXJnKQogewogCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IGRldmljZV9kYXRh OwotCXN0cnVjdCBtZGV2X3BhcmVudCAqcGFyZW50ID0gbWRldi0+cGFyZW50OworCWNvbnN0IHN0 cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyAqb3BzID0gbWRldl9nZXRfZGV2X29wcyhtZGV2KTsK IAotCWlmICh1bmxpa2VseSghcGFyZW50LT5vcHMtPmlvY3RsKSkKKwlpZiAodW5saWtlbHkoIW9w cy0+aW9jdGwpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCXJldHVybiBwYXJlbnQtPm9wcy0+aW9j dGwobWRldiwgY21kLCBhcmcpOworCXJldHVybiBvcHMtPmlvY3RsKG1kZXYsIGNtZCwgYXJnKTsK IH0KIAogc3RhdGljIHNzaXplX3QgdmZpb19tZGV2X3JlYWQodm9pZCAqZGV2aWNlX2RhdGEsIGNo YXIgX191c2VyICpidWYsCiAJCQkgICAgICBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykKIHsK IAlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSBkZXZpY2VfZGF0YTsKLQlzdHJ1Y3QgbWRldl9w YXJlbnQgKnBhcmVudCA9IG1kZXYtPnBhcmVudDsKKwljb25zdCBzdHJ1Y3QgdmZpb19tZGV2X2Rl dmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X2Rldl9vcHMobWRldik7CiAKLQlpZiAodW5saWtlbHko IXBhcmVudC0+b3BzLT5yZWFkKSkKKwlpZiAodW5saWtlbHkoIW9wcy0+cmVhZCkpCiAJCXJldHVy biAtRUlOVkFMOwogCi0JcmV0dXJuIHBhcmVudC0+b3BzLT5yZWFkKG1kZXYsIGJ1ZiwgY291bnQs IHBwb3MpOworCXJldHVybiBvcHMtPnJlYWQobWRldiwgYnVmLCBjb3VudCwgcHBvcyk7CiB9CiAK IHN0YXRpYyBzc2l6ZV90IHZmaW9fbWRldl93cml0ZSh2b2lkICpkZXZpY2VfZGF0YSwgY29uc3Qg Y2hhciBfX3VzZXIgKmJ1ZiwKIAkJCSAgICAgICBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykK IHsKIAlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSBkZXZpY2VfZGF0YTsKLQlzdHJ1Y3QgbWRl dl9wYXJlbnQgKnBhcmVudCA9IG1kZXYtPnBhcmVudDsKKwljb25zdCBzdHJ1Y3QgdmZpb19tZGV2 X2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X2Rldl9vcHMobWRldik7CiAKLQlpZiAodW5saWtl bHkoIXBhcmVudC0+b3BzLT53cml0ZSkpCisJaWYgKHVubGlrZWx5KCFvcHMtPndyaXRlKSkKIAkJ cmV0dXJuIC1FSU5WQUw7CiAKLQlyZXR1cm4gcGFyZW50LT5vcHMtPndyaXRlKG1kZXYsIGJ1Ziwg Y291bnQsIHBwb3MpOworCXJldHVybiBvcHMtPndyaXRlKG1kZXYsIGJ1ZiwgY291bnQsIHBwb3Mp OwogfQogCiBzdGF0aWMgaW50IHZmaW9fbWRldl9tbWFwKHZvaWQgKmRldmljZV9kYXRhLCBzdHJ1 Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKIHsKIAlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSBk ZXZpY2VfZGF0YTsKLQlzdHJ1Y3QgbWRldl9wYXJlbnQgKnBhcmVudCA9IG1kZXYtPnBhcmVudDsK Kwljb25zdCBzdHJ1Y3QgdmZpb19tZGV2X2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X2Rldl9v cHMobWRldik7CiAKLQlpZiAodW5saWtlbHkoIXBhcmVudC0+b3BzLT5tbWFwKSkKKwlpZiAodW5s aWtlbHkoIW9wcy0+bW1hcCkpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JcmV0dXJuIHBhcmVudC0+ b3BzLT5tbWFwKG1kZXYsIHZtYSk7CisJcmV0dXJuIG9wcy0+bW1hcChtZGV2LCB2bWEpOwogfQog CiBzdGF0aWMgY29uc3Qgc3RydWN0IHZmaW9fZGV2aWNlX29wcyB2ZmlvX21kZXZfZGV2X29wcyA9 IHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWRldi5oIGIvaW5jbHVkZS9saW51eC9tZGV2 LmgKaW5kZXggYTc1NzBjZjEzYmE0Li5mNDkxMzA4Njc0ZTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUv bGludXgvbWRldi5oCisrKyBiL2luY2x1ZGUvbGludXgvbWRldi5oCkBAIC0xMCw2ICsxMCwxMSBA QAogI2lmbmRlZiBNREVWX0gKICNkZWZpbmUgTURFVl9ICiAKKyNpbmNsdWRlIDxsaW51eC90eXBl cy5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4K KyNpbmNsdWRlIDx1YXBpL2xpbnV4L3V1aWQuaD4KKwogc3RydWN0IG1kZXZfZGV2aWNlOwogCiAv KgpAQCAtNDgsMzAgKzUzLDcgQEAgc3RydWN0IGRldmljZSAqbWRldl9nZXRfaW9tbXVfZGV2aWNl KHN0cnVjdCBkZXZpY2UgKmRldik7CiAgKgkJCUBtZGV2OiBtZGV2X2RldmljZSBkZXZpY2Ugc3Ry dWN0dXJlIHdoaWNoIGlzIGJlaW5nCiAgKgkJCSAgICAgICBkZXN0cm95ZWQKICAqCQkJUmV0dXJu cyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQotICogQG9wZW46CQlPcGVuIG1l ZGlhdGVkIGRldmljZS4KLSAqCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZS4KLSAqCQkJUmV0dXJu cyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQotICogQHJlbGVhc2U6CQlyZWxl YXNlIG1lZGlhdGVkIGRldmljZQotICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlLgotICogQHJl YWQ6CQlSZWFkIGVtdWxhdGlvbiBjYWxsYmFjawotICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNl IHN0cnVjdHVyZQotICoJCQlAYnVmOiByZWFkIGJ1ZmZlcgotICoJCQlAY291bnQ6IG51bWJlciBv ZiBieXRlcyB0byByZWFkCi0gKgkJCUBwcG9zOiBhZGRyZXNzLgotICoJCQlSZXR1bnMgbnVtYmVy IG9uIGJ5dGVzIHJlYWQgb24gc3VjY2VzcyBvciBlcnJvci4KLSAqIEB3cml0ZToJCVdyaXRlIGVt dWxhdGlvbiBjYWxsYmFjawotICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlIHN0cnVjdHVyZQot ICoJCQlAYnVmOiB3cml0ZSBidWZmZXIKLSAqCQkJQGNvdW50OiBudW1iZXIgb2YgYnl0ZXMgdG8g YmUgd3JpdHRlbgotICoJCQlAcHBvczogYWRkcmVzcy4KLSAqCQkJUmV0dW5zIG51bWJlciBvbiBi eXRlcyB3cml0dGVuIG9uIHN1Y2Nlc3Mgb3IgZXJyb3IuCi0gKiBAaW9jdGw6CQlJT0NUTCBjYWxs YmFjawotICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlIHN0cnVjdHVyZQotICoJCQlAY21kOiBp b2N0bCBjb21tYW5kCi0gKgkJCUBhcmc6IGFyZ3VtZW50cyB0byBpb2N0bAotICogQG1tYXA6CQlt bWFwIGNhbGxiYWNrCi0gKgkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2Ugc3RydWN0dXJlCi0gKgkJ CUB2bWE6IHZtYSBzdHJ1Y3R1cmUKKyAqCiAgKiBQYXJlbnQgZGV2aWNlIHRoYXQgc3VwcG9ydCBt ZWRpYXRlZCBkZXZpY2Ugc2hvdWxkIGJlIHJlZ2lzdGVyZWQgd2l0aCBtZGV2CiAgKiBtb2R1bGUg d2l0aCBtZGV2X3BhcmVudF9vcHMgc3RydWN0dXJlLgogICoqLwpAQCAtODMsMTUgKzY1LDYgQEAg c3RydWN0IG1kZXZfcGFyZW50X29wcyB7CiAKIAlpbnQgICAgICgqY3JlYXRlKShzdHJ1Y3Qga29i amVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKIAlpbnQgICAgICgqcmVtb3Zl KShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOwotCWludCAgICAgKCpvcGVuKShzdHJ1Y3QgbWRl dl9kZXZpY2UgKm1kZXYpOwotCXZvaWQgICAgKCpyZWxlYXNlKShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYpOwotCXNzaXplX3QgKCpyZWFkKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIGNoYXIg X191c2VyICpidWYsCi0JCQlzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcyk7Ci0Jc3NpemVfdCAo KndyaXRlKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIGNvbnN0IGNoYXIgX191c2VyICpidWYs Ci0JCQkgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpOwotCWxvbmcJKCppb2N0bCkoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2LCB1bnNpZ25lZCBpbnQgY21kLAotCQkJIHVuc2lnbmVkIGxvbmcg YXJnKTsKLQlpbnQJKCptbWFwKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHN0cnVjdCB2bV9h cmVhX3N0cnVjdCAqdm1hKTsKIH07CiAKIC8qIGludGVyZmFjZSBmb3IgZXhwb3J0aW5nIG1kZXYg c3VwcG9ydGVkIHR5cGUgYXR0cmlidXRlcyAqLwpAQCAtMTMzLDcgKzEwNiw4IEBAIHN0cnVjdCBt ZGV2X2RyaXZlciB7CiAKIHZvaWQgKm1kZXZfZ2V0X2RydmRhdGEoc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2KTsKIHZvaWQgbWRldl9zZXRfZHJ2ZGF0YShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYs IHZvaWQgKmRhdGEpOwotdm9pZCBtZGV2X3NldF9jbGFzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYsIHUxNiBpZCk7Cit2b2lkIG1kZXZfc2V0X2NsYXNzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRl diwgdTE2IGlkLCBjb25zdCB2b2lkICpvcHMpOworY29uc3Qgdm9pZCAqbWRldl9nZXRfZGV2X29w cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOwogY29uc3QgZ3VpZF90ICptZGV2X3V1aWQoc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2KTsKIAogZXh0ZXJuIHN0cnVjdCBidXNfdHlwZSBtZGV2X2J1 c190eXBlOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92ZmlvX21kZXYuaCBiL2luY2x1ZGUv bGludXgvdmZpb19tZGV2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li4zOTA3YzUzNzFjMmIKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L3ZmaW9fbWRl di5oCkBAIC0wLDAgKzEsNTIgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9ubHkgKi8KKy8qCisgKiBWRklPIE1lZGlhdGVkIGRldmljZSBkZWZpbml0aW9uCisgKi8KKwor I2lmbmRlZiBWRklPX01ERVZfSAorI2RlZmluZSBWRklPX01ERVZfSAorCisjaW5jbHVkZSA8bGlu dXgvbWRldi5oPgorCisvKioKKyAqIHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyAtIFN0cnVj dHVyZSB0byBiZSByZWdpc3RlcmVkIGZvciBlYWNoCisgKiBtZGV2IGRldmljZSB0byByZWdpc3Rl ciB0aGUgZGV2aWNlIHRvIHZmaW8tbWRldiBtb2R1bGUuCisgKgorICogQG9wZW46CQlPcGVuIG1l ZGlhdGVkIGRldmljZS4KKyAqCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZS4KKyAqCQkJUmV0dXJu cyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQorICogQHJlbGVhc2U6CQlyZWxl YXNlIG1lZGlhdGVkIGRldmljZQorICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlLgorICogQHJl YWQ6CQlSZWFkIGVtdWxhdGlvbiBjYWxsYmFjaworICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNl IHN0cnVjdHVyZQorICoJCQlAYnVmOiByZWFkIGJ1ZmZlcgorICoJCQlAY291bnQ6IG51bWJlciBv ZiBieXRlcyB0byByZWFkCisgKgkJCUBwcG9zOiBhZGRyZXNzLgorICoJCQlSZXR1bnMgbnVtYmVy IG9uIGJ5dGVzIHJlYWQgb24gc3VjY2VzcyBvciBlcnJvci4KKyAqIEB3cml0ZToJCVdyaXRlIGVt dWxhdGlvbiBjYWxsYmFjaworICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlIHN0cnVjdHVyZQor ICoJCQlAYnVmOiB3cml0ZSBidWZmZXIKKyAqCQkJQGNvdW50OiBudW1iZXIgb2YgYnl0ZXMgdG8g YmUgd3JpdHRlbgorICoJCQlAcHBvczogYWRkcmVzcy4KKyAqCQkJUmV0dW5zIG51bWJlciBvbiBi eXRlcyB3cml0dGVuIG9uIHN1Y2Nlc3Mgb3IgZXJyb3IuCisgKiBAaW9jdGw6CQlJT0NUTCBjYWxs YmFjaworICoJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlIHN0cnVjdHVyZQorICoJCQlAY21kOiBp b2N0bCBjb21tYW5kCisgKgkJCUBhcmc6IGFyZ3VtZW50cyB0byBpb2N0bAorICogQG1tYXA6CQlt bWFwIGNhbGxiYWNrCisgKgkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2Ugc3RydWN0dXJlCisgKgkJ CUB2bWE6IHZtYSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IHZmaW9fbWRldl9kZXZpY2Vfb3BzIHsK KwlpbnQgICAgICgqb3Blbikoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKKwl2b2lkICAgICgq cmVsZWFzZSkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKKwlzc2l6ZV90ICgqcmVhZCkoc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2LCBjaGFyIF9fdXNlciAqYnVmLAorCQkJc2l6ZV90IGNvdW50 LCBsb2ZmX3QgKnBwb3MpOworCXNzaXplX3QgKCp3cml0ZSkoc3RydWN0IG1kZXZfZGV2aWNlICpt ZGV2LCBjb25zdCBjaGFyIF9fdXNlciAqYnVmLAorCQkJIHNpemVfdCBjb3VudCwgbG9mZl90ICpw cG9zKTsKKwlsb25nCSgqaW9jdGwpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQg aW50IGNtZCwKKwkJCSB1bnNpZ25lZCBsb25nIGFyZyk7CisJaW50CSgqbW1hcCkoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2LCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7Cit9OworCisjZW5k aWYKZGlmZiAtLWdpdCBhL3NhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5jIGIvc2FtcGxlcy92Zmlv LW1kZXYvbWJvY2hzLmMKaW5kZXggZmQ4NDkxZTU4ZmUyLi45ZGI3NzFlZDVlNGIgMTAwNjQ0Ci0t LSBhL3NhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5jCisrKyBiL3NhbXBsZXMvdmZpby1tZGV2L21i b2Nocy5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvaW9tbXUuaD4KICNpbmNs dWRlIDxsaW51eC9zeXNmcy5oPgogI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxs aW51eC92ZmlvX21kZXYuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51 eC9kbWEtYnVmLmg+CiAjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgpAQCAtNTE2LDYgKzUxNyw4 IEBAIHN0YXRpYyBpbnQgbWJvY2hzX3Jlc2V0KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIAly ZXR1cm4gMDsKIH0KIAorc3RhdGljIGNvbnN0IHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyB2 ZmlvX21kZXZfb3BzOworCiBzdGF0aWMgaW50IG1ib2Noc19jcmVhdGUoc3RydWN0IGtvYmplY3Qg KmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIHsKIAljb25zdCBzdHJ1Y3QgbWJvY2hz X3R5cGUgKnR5cGUgPSBtYm9jaHNfZmluZF90eXBlKGtvYmopOwpAQCAtNTYxLDcgKzU2NCw3IEBA IHN0YXRpYyBpbnQgbWJvY2hzX2NyZWF0ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2KQogCW1ib2Noc19yZXNldChtZGV2KTsKIAogCW1ib2Noc191c2VkX21i eXRlcyArPSB0eXBlLT5tYnl0ZXM7Ci0JbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9JRF9WRklP KTsKKwltZGV2X3NldF9jbGFzcyhtZGV2LCBNREVWX0lEX1ZGSU8sICZ2ZmlvX21kZXZfb3BzKTsK IAlyZXR1cm4gMDsKIAogZXJyX21lbToKQEAgLTE0MTksMTIgKzE0MjIsNyBAQCBzdGF0aWMgc3Ry dWN0IGF0dHJpYnV0ZV9ncm91cCAqbWRldl90eXBlX2dyb3Vwc1tdID0gewogCU5VTEwsCiB9Owog Ci1zdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyBtZGV2X2ZvcHMgPSB7Ci0JLm93 bmVyCQkJPSBUSElTX01PRFVMRSwKLQkubWRldl9hdHRyX2dyb3Vwcwk9IG1kZXZfZGV2X2dyb3Vw cywKLQkuc3VwcG9ydGVkX3R5cGVfZ3JvdXBzCT0gbWRldl90eXBlX2dyb3VwcywKLQkuY3JlYXRl CQkJPSBtYm9jaHNfY3JlYXRlLAotCS5yZW1vdmUJCQk9IG1ib2Noc19yZW1vdmUsCitzdGF0aWMg Y29uc3Qgc3RydWN0IHZmaW9fbWRldl9kZXZpY2Vfb3BzIHZmaW9fbWRldl9vcHMgPSB7CiAJLm9w ZW4JCQk9IG1ib2Noc19vcGVuLAogCS5yZWxlYXNlCQk9IG1ib2Noc19jbG9zZSwKIAkucmVhZAkJ CT0gbWJvY2hzX3JlYWQsCkBAIC0xNDMzLDYgKzE0MzEsMTQgQEAgc3RhdGljIGNvbnN0IHN0cnVj dCBtZGV2X3BhcmVudF9vcHMgbWRldl9mb3BzID0gewogCS5tbWFwCQkJPSBtYm9jaHNfbW1hcCwK IH07CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3BzIG1kZXZfZm9wcyA9IHsK Kwkub3duZXIJCQk9IFRISVNfTU9EVUxFLAorCS5tZGV2X2F0dHJfZ3JvdXBzCT0gbWRldl9kZXZf Z3JvdXBzLAorCS5zdXBwb3J0ZWRfdHlwZV9ncm91cHMJPSBtZGV2X3R5cGVfZ3JvdXBzLAorCS5j cmVhdGUJCQk9IG1ib2Noc19jcmVhdGUsCisJLnJlbW92ZQkJCT0gbWJvY2hzX3JlbW92ZSwKK307 CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHZkX2ZvcHMgPSB7CiAJLm93 bmVyCQk9IFRISVNfTU9EVUxFLAogfTsKZGlmZiAtLWdpdCBhL3NhbXBsZXMvdmZpby1tZGV2L21k cHkuYyBiL3NhbXBsZXMvdmZpby1tZGV2L21kcHkuYwppbmRleCA4ODk0NzJiMDY3MDguLmYwZmRi YzZlYzcwNiAxMDA2NDQKLS0tIGEvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jCisrKyBiL3NhbXBs ZXMvdmZpby1tZGV2L21kcHkuYwpAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2lv bW11Lmg+CiAjaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KICNpbmNsdWRlIDxsaW51eC9tZGV2Lmg+ CisjaW5jbHVkZSA8bGludXgvdmZpb19tZGV2Lmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CiAj aW5jbHVkZSA8ZHJtL2RybV9mb3VyY2MuaD4KICNpbmNsdWRlICJtZHB5LWRlZnMuaCIKQEAgLTIy Niw2ICsyMjcsOCBAQCBzdGF0aWMgaW50IG1kcHlfcmVzZXQoc3RydWN0IG1kZXZfZGV2aWNlICpt ZGV2KQogCXJldHVybiAwOwogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IHZmaW9fbWRldl9kZXZp Y2Vfb3BzIHZmaW9fbWRldl9vcHM7CisKIHN0YXRpYyBpbnQgbWRweV9jcmVhdGUoc3RydWN0IGtv YmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIHsKIAljb25zdCBzdHJ1Y3Qg bWRweV90eXBlICp0eXBlID0gbWRweV9maW5kX3R5cGUoa29iaik7CkBAIC0yNjksNyArMjcyLDgg QEAgc3RhdGljIGludCBtZHB5X2NyZWF0ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2KQogCW1kcHlfcmVzZXQobWRldik7CiAKIAltZHB5X2NvdW50Kys7Ci0J bWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9JRF9WRklPKTsKKworCW1kZXZfc2V0X2NsYXNzKG1k ZXYsIE1ERVZfSURfVkZJTywgJnZmaW9fbWRldl9vcHMpOwogCXJldHVybiAwOwogfQogCkBAIC03 MjYsMTIgKzczMCw3IEBAIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X3R5cGVf Z3JvdXBzW10gPSB7CiAJTlVMTCwKIH07CiAKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9wYXJl bnRfb3BzIG1kZXZfZm9wcyA9IHsKLQkub3duZXIJCQk9IFRISVNfTU9EVUxFLAotCS5tZGV2X2F0 dHJfZ3JvdXBzCT0gbWRldl9kZXZfZ3JvdXBzLAotCS5zdXBwb3J0ZWRfdHlwZV9ncm91cHMJPSBt ZGV2X3R5cGVfZ3JvdXBzLAotCS5jcmVhdGUJCQk9IG1kcHlfY3JlYXRlLAotCS5yZW1vdmUJCQk9 IG1kcHlfcmVtb3ZlLAorc3RhdGljIGNvbnN0IHN0cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyB2 ZmlvX21kZXZfb3BzID0gewogCS5vcGVuCQkJPSBtZHB5X29wZW4sCiAJLnJlbGVhc2UJCT0gbWRw eV9jbG9zZSwKIAkucmVhZAkJCT0gbWRweV9yZWFkLApAQCAtNzQwLDYgKzczOSwxNCBAQCBzdGF0 aWMgY29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyBtZGV2X2ZvcHMgPSB7CiAJLm1tYXAJCQk9 IG1kcHlfbW1hcCwKIH07CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9wYXJlbnRfb3BzIG1k ZXZfZm9wcyA9IHsKKwkub3duZXIJCQk9IFRISVNfTU9EVUxFLAorCS5tZGV2X2F0dHJfZ3JvdXBz CT0gbWRldl9kZXZfZ3JvdXBzLAorCS5zdXBwb3J0ZWRfdHlwZV9ncm91cHMJPSBtZGV2X3R5cGVf Z3JvdXBzLAorCS5jcmVhdGUJCQk9IG1kcHlfY3JlYXRlLAorCS5yZW1vdmUJCQk9IG1kcHlfcmVt b3ZlLAorfTsKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgdmRfZm9wcyA9 IHsKIAkub3duZXIJCT0gVEhJU19NT0RVTEUsCiB9OwpkaWZmIC0tZ2l0IGEvc2FtcGxlcy92Zmlv LW1kZXYvbXR0eS5jIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jCmluZGV4IDYxODgxMGNhNDMz MS4uMThkMGY4M2EyMjhhIDEwMDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8tbWRldi9tdHR5LmMKKysr IGIvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSA8 bGludXgvY3R5cGUuaD4KICNpbmNsdWRlIDxsaW51eC9maWxlLmg+CiAjaW5jbHVkZSA8bGludXgv bWRldi5oPgorI2luY2x1ZGUgPGxpbnV4L3ZmaW9fbWRldi5oPgogI2luY2x1ZGUgPGxpbnV4L3Bj aS5oPgogI2luY2x1ZGUgPGxpbnV4L3NlcmlhbC5oPgogI2luY2x1ZGUgPHVhcGkvbGludXgvc2Vy aWFsX3JlZy5oPgpAQCAtNzA4LDYgKzcwOSw4IEBAIHN0YXRpYyBzc2l6ZV90IG1kZXZfYWNjZXNz KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTggKmJ1Ziwgc2l6ZV90IGNvdW50LAogCXJldHVy biByZXQ7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmZpb19tZGV2X2RldmljZV9vcHMgdmZp b19kZXZfb3BzOworCiBzdGF0aWMgaW50IG10dHlfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2Jq LCBzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCiB7CiAJc3RydWN0IG1kZXZfc3RhdGUgKm1kZXZf c3RhdGU7CkBAIC03NTUsNyArNzU4LDcgQEAgc3RhdGljIGludCBtdHR5X2NyZWF0ZShzdHJ1Y3Qg a29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCWxpc3RfYWRkKCZtZGV2 X3N0YXRlLT5uZXh0LCAmbWRldl9kZXZpY2VzX2xpc3QpOwogCW11dGV4X3VubG9jaygmbWRldl9s aXN0X2xvY2spOwogCi0JbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9JRF9WRklPKTsKKwltZGV2 X3NldF9jbGFzcyhtZGV2LCBNREVWX0lEX1ZGSU8sICZ2ZmlvX2Rldl9vcHMpOwogCXJldHVybiAw OwogfQogCkBAIC0xMzg4LDYgKzEzOTEsMTQgQEAgc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3Jv dXAgKm1kZXZfdHlwZV9ncm91cHNbXSA9IHsKIAlOVUxMLAogfTsKIAorc3RhdGljIGNvbnN0IHN0 cnVjdCB2ZmlvX21kZXZfZGV2aWNlX29wcyB2ZmlvX2Rldl9vcHMgPSB7CisJLm9wZW4gICAgICAg ICAgICAgICAgICAgPSBtdHR5X29wZW4sCisJLnJlbGVhc2UgICAgICAgICAgICAgICAgPSBtdHR5 X2Nsb3NlLAorCS5yZWFkICAgICAgICAgICAgICAgICAgID0gbXR0eV9yZWFkLAorCS53cml0ZSAg ICAgICAgICAgICAgICAgID0gbXR0eV93cml0ZSwKKwkuaW9jdGwJCSAgICAgICAgPSBtdHR5X2lv Y3RsLAorfTsKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgbWRldl9mb3Bz ID0gewogCS5vd25lciAgICAgICAgICAgICAgICAgID0gVEhJU19NT0RVTEUsCiAJLmRldl9hdHRy X2dyb3VwcyAgICAgICAgPSBtdHR5X2Rldl9ncm91cHMsCkBAIC0xMzk1LDExICsxNDA2LDYgQEAg c3RhdGljIGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgbWRldl9mb3BzID0gewogCS5zdXBw b3J0ZWRfdHlwZV9ncm91cHMgID0gbWRldl90eXBlX2dyb3VwcywKIAkuY3JlYXRlICAgICAgICAg ICAgICAgICA9IG10dHlfY3JlYXRlLAogCS5yZW1vdmUJCQk9IG10dHlfcmVtb3ZlLAotCS5vcGVu ICAgICAgICAgICAgICAgICAgID0gbXR0eV9vcGVuLAotCS5yZWxlYXNlICAgICAgICAgICAgICAg ID0gbXR0eV9jbG9zZSwKLQkucmVhZCAgICAgICAgICAgICAgICAgICA9IG10dHlfcmVhZCwKLQku d3JpdGUgICAgICAgICAgICAgICAgICA9IG10dHlfd3JpdGUsCi0JLmlvY3RsCQkgICAgICAgID0g bXR0eV9pb2N0bCwKIH07CiAKIHN0YXRpYyB2b2lkIG10dHlfZGV2aWNlX3JlbGVhc2Uoc3RydWN0 IGRldmljZSAqZGV2KQotLSAKMi4xOS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWw=