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=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 0EDCCC432C0 for ; Mon, 18 Nov 2019 11:02:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C9ED02073A for ; Mon, 18 Nov 2019 11:02:21 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="IQV3/9jV" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727226AbfKRLCV (ORCPT ); Mon, 18 Nov 2019 06:02:21 -0500 Received: from us-smtp-2.mimecast.com ([207.211.31.81]:20209 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726579AbfKRLCS (ORCPT ); Mon, 18 Nov 2019 06:02:18 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1574074936; 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=3ja26PSJK9ygpRuIQpXY0DayGYbCviriRvTlXBCNZRc=; b=IQV3/9jVahpx5ulmQj7W1LakbWfB9t4DfZ3+btAWmSPYDmwJSBFWhd+g0JPYE4nJ6S4isH b1vtEMp5qpjnJA8AUMs2/HcVsCza1tb7m8Ismw8GlxJKXmQcxSujIAWZDiUjyVPcfalstk yuEdjcHcF5DyBCTbTvCbJi8COcrtTKk= 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-57-tZBqeW2pONKR0-_5Ku4cEA-1; Mon, 18 Nov 2019 06:02:13 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E8FBB805319; Mon, 18 Nov 2019 11:02:07 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-65.pek2.redhat.com [10.72.12.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5B2D660BE1; Mon, 18 Nov 2019 11:01:42 +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, gregkh@linuxfoundation.org, jgg@mellanox.com Cc: 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, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com, rdunlap@infradead.org, hch@infradead.org, aadam@redhat.com, jakub.kicinski@netronome.com, jiri@mellanox.com, jeffrey.t.kirsher@intel.com, Jason Wang Subject: [PATCH V13 4/6] mdev: introduce mediated virtio bus Date: Mon, 18 Nov 2019 18:59:21 +0800 Message-Id: <20191118105923.7991-5-jasowang@redhat.com> In-Reply-To: <20191118105923.7991-1-jasowang@redhat.com> References: <20191118105923.7991-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-MC-Unique: tZBqeW2pONKR0-_5Ku4cEA-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch implements a mediated virtio bus over mdev framework. This will be used by the future virtio-mdev and vhost-mdev on top to allow driver from either userspace or kernel to control the device which is capable of offloading virtio datapath. Signed-off-by: Jason Wang --- MAINTAINERS | 2 + drivers/mdev/Kconfig | 10 ++ drivers/mdev/Makefile | 2 + drivers/mdev/virtio.c | 126 +++++++++++++++++++++++ include/linux/mdev_virtio.h | 163 ++++++++++++++++++++++++++++++ include/linux/mod_devicetable.h | 8 ++ scripts/mod/devicetable-offsets.c | 3 + scripts/mod/file2alias.c | 12 +++ 8 files changed, 326 insertions(+) create mode 100644 drivers/mdev/virtio.c create mode 100644 include/linux/mdev_virtio.h diff --git a/MAINTAINERS b/MAINTAINERS index 5d7e8badf58c..e1b57c84f249 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17269,6 +17269,8 @@ F:=09include/linux/virtio*.h F:=09include/uapi/linux/virtio_*.h F:=09drivers/crypto/virtio/ F:=09mm/balloon_compaction.c +F:=09include/linux/mdev_virtio.h +F:=09drivers/mdev/virtio.c =20 VIRTIO BLOCK AND SCSI DRIVERS M:=09"Michael S. Tsirkin" diff --git a/drivers/mdev/Kconfig b/drivers/mdev/Kconfig index 4561f2d4178f..cd84d4670552 100644 --- a/drivers/mdev/Kconfig +++ b/drivers/mdev/Kconfig @@ -17,3 +17,13 @@ config VFIO_MDEV =09 more details. =20 =09 If you don't know what do here, say N. + +config MDEV_VIRTIO + tristate "Mediated VIRTIO bus" + depends on VIRTIO && MDEV + default n + help +=09 Proivdes a mediated BUS for virtio. It could be used by + either kenrel driver or userspace driver. + +=09 If you don't know what do here, say N. diff --git a/drivers/mdev/Makefile b/drivers/mdev/Makefile index 0b749e7f8ff4..eb14031c9944 100644 --- a/drivers/mdev/Makefile +++ b/drivers/mdev/Makefile @@ -1,5 +1,7 @@ =20 mdev-y :=3D mdev_core.o mdev_sysfs.o mdev_driver.o mdev_vfio-y :=3D vfio.o +mdev_virtio-y :=3D virtio.o obj-$(CONFIG_MDEV) +=3D mdev.o obj-$(CONFIG_VFIO_MDEV) +=3D mdev_vfio.o +obj-$(CONFIG_MDEV_VIRTIO) +=3D mdev_virtio.o diff --git a/drivers/mdev/virtio.c b/drivers/mdev/virtio.c new file mode 100644 index 000000000000..25de329615c4 --- /dev/null +++ b/drivers/mdev/virtio.c @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Mediated VIRTIO bus + * + * Copyright (c) 2019, Red Hat. All rights reserved. + * Author: Jason Wang + */ + +#include +#include +#include +#include +#include +#include + +#include "mdev_private.h" + +#define DRIVER_VERSION=09=09"0.1" +#define DRIVER_AUTHOR=09=09"Jason Wang" +#define DRIVER_DESC=09=09"Mediated VIRTIO bus" + +struct bus_type mdev_virtio_bus_type; + +struct mdev_virtio_device { +=09struct mdev_device mdev; +=09const struct mdev_virtio_ops *ops; +=09u16 class_id; +}; + +#define to_mdev_virtio(mdev) container_of(mdev, \ +=09=09=09=09=09 struct mdev_virtio_device, mdev) +#define to_mdev_virtio_drv(mdrv) container_of(mdrv, \ +=09=09=09=09=09 struct mdev_virtio_driver, drv) + +static int mdev_virtio_match(struct device *dev, struct device_driver *drv= ) +{ +=09unsigned int i; +=09struct mdev_device *mdev =3D mdev_from_dev(dev, &mdev_virtio_bus_type); +=09struct mdev_virtio_device *mdev_virtio =3D to_mdev_virtio(mdev); +=09struct mdev_driver *mdrv =3D to_mdev_driver(drv); +=09struct mdev_virtio_driver *mdrv_virtio =3D to_mdev_virtio_drv(mdrv); +=09const struct mdev_virtio_class_id *ids =3D mdrv_virtio->id_table; + +=09if (!ids) +=09=09return 0; + +=09for (i =3D 0; ids[i].id; i++) +=09=09if (ids[i].id =3D=3D mdev_virtio->class_id) +=09=09=09return 1; +=09return 0; +} + +static int mdev_virtio_uevent(struct device *dev, struct kobj_uevent_env *= env) +{ +=09struct mdev_device *mdev =3D mdev_from_dev(dev, &mdev_virtio_bus_type); +=09struct mdev_virtio_device *mdev_virtio =3D to_mdev_virtio(mdev); + +=09return add_uevent_var(env, "MODALIAS=3Dmdev_virtio:c%02X", +=09=09=09 mdev_virtio->class_id); +} + +struct bus_type mdev_virtio_bus_type =3D { +=09.name=09=09=3D "mdev_virtio", +=09.probe=09=09=3D mdev_probe, +=09.remove=09=09=3D mdev_remove, +=09.match=09 =3D mdev_virtio_match, +=09.uevent=09=09=3D mdev_virtio_uevent, +}; +EXPORT_SYMBOL(mdev_virtio_bus_type); + +void mdev_virtio_set_class_id(struct mdev_device *mdev, u16 class_id) +{ +=09struct mdev_virtio_device *mdev_virtio =3D to_mdev_virtio(mdev); + +=09mdev_virtio->class_id =3D class_id; +} +EXPORT_SYMBOL(mdev_virtio_set_class_id); + +int mdev_virtio_register_device(struct device *dev, +=09=09=09=09const struct mdev_parent_ops *ops) +{ +=09return mdev_register_device(dev, ops, &mdev_virtio_bus_type, +=09=09=09=09 sizeof(struct mdev_virtio_device)); +} +EXPORT_SYMBOL(mdev_virtio_register_device); + +void mdev_virtio_unregister_device(struct device *dev) +{ +=09return mdev_unregister_device(dev); +} +EXPORT_SYMBOL(mdev_virtio_unregister_device); + +void mdev_virtio_set_ops(struct mdev_device *mdev, +=09=09=09 const struct mdev_virtio_ops *ops) +{ +=09struct mdev_virtio_device *mdev_virtio =3D to_mdev_virtio(mdev); + +=09mdev_virtio->ops =3D ops; +} +EXPORT_SYMBOL(mdev_virtio_set_ops); + +const struct mdev_virtio_ops *mdev_virtio_get_ops(struct mdev_device *mdev= ) +{ +=09struct mdev_virtio_device *mdev_virtio =3D to_mdev_virtio(mdev); + +=09return mdev_virtio->ops; +} +EXPORT_SYMBOL(mdev_virtio_get_ops); + +static int __init mdev_init(void) +{ +=09return mdev_register_bus(&mdev_virtio_bus_type); +} + +static void __exit mdev_exit(void) +{ +=09mdev_unregister_bus(&mdev_virtio_bus_type); +} + +module_init(mdev_init) +module_exit(mdev_exit) + +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); diff --git a/include/linux/mdev_virtio.h b/include/linux/mdev_virtio.h new file mode 100644 index 000000000000..ef2dbb6c383a --- /dev/null +++ b/include/linux/mdev_virtio.h @@ -0,0 +1,163 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * VIRTIO Mediated device definition + * + * Copyright (c) 2019, Red Hat. All rights reserved. + * Author: Jason Wang + */ + +#ifndef VIRTIO_MDEV_H +#define VIRTIO_MDEV_H + +#include +#include +#include + +extern struct bus_type mdev_virtio_bus_type; + +struct mdev_virtio_driver { +=09struct mdev_driver drv; +=09const struct mdev_virtio_class_id *id_table; +}; + +struct virtio_mdev_callback { +=09irqreturn_t (*callback)(void *data); +=09void *private; +}; + +/** + * struct mdev_virtio_device_ops - Structure to be registered for each + * mdev device to register the device for virtio/vhost drivers. + * + * The callbacks are mandatory unless explicitly mentioned. + * + * @set_vq_address:=09=09Set the address of virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09@desc_area: address of desc area + *=09=09=09=09@driver_area: address of driver area + *=09=09=09=09@device_area: address of device area + *=09=09=09=09Returns integer: success (0) or error (< 0) + * @set_vq_num:=09=09=09Set the size of virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09@num: the size of virtqueue + * @kick_vq:=09=09=09Kick the virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + * @set_vq_cb:=09=09=09Set the interrupt callback function for + *=09=09=09=09a virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09@cb: virtio-mdev interrupt callback structure + * @set_vq_ready:=09=09Set ready status for a virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09@ready: ready (true) not ready(false) + * @get_vq_ready:=09=09Get ready status for a virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09Returns boolean: ready (true) or not (false) + * @set_vq_state:=09=09Set the state for a virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09@state: virtqueue state (last_avail_idx) + *=09=09=09=09Returns integer: success (0) or error (< 0) + * @get_vq_state:=09=09Get the state for a virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@idx: virtqueue index + *=09=09=09=09Returns virtqueue state (last_avail_idx) + * @get_vq_align:=09=09Get the virtqueue align requirement + *=09=09=09=09for the device + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns virtqueue algin requirement + * @get_features:=09=09Get virtio features supported by the device + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns the virtio features support by the + *=09=09=09=09device + * @set_features:=09=09Set virtio features supported by the driver + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@features: feature support by the driver + *=09=09=09=09Returns integer: success (0) or error (< 0) + * @set_config_cb:=09=09Set the config interrupt callback + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@cb: virtio-mdev interrupt callback structure + * @get_vq_num_max:=09=09Get the max size of virtqueue + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns u16: max size of virtqueue + * @get_device_id:=09=09Get virtio device id + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns u32: virtio device id + * @get_vendor_id:=09=09Get id for the vendor that provides this device + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns u32: virtio vendor id + * @get_status:=09=09=09Get the device status + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns u8: virtio device status + * @set_status:=09=09=09Set the device status + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@status: virtio device status + * @get_config:=09=09=09Read from device specific configuration space + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@offset: offset from the beginning of + *=09=09=09=09configuration space + *=09=09=09=09@buf: buffer used to read to + *=09=09=09=09@len: the length to read from + *=09=09=09=09configration space + * @set_config:=09=09=09Write to device specific configuration space + *=09=09=09=09@mdev: mediated device + *=09=09=09=09@offset: offset from the beginning of + *=09=09=09=09configuration space + *=09=09=09=09@buf: buffer used to write from + *=09=09=09=09@len: the length to write to + *=09=09=09=09configration space + * @get_generation:=09=09Get device config generaton (optional) + *=09=09=09=09@mdev: mediated device + *=09=09=09=09Returns u32: device generation + */ +struct mdev_virtio_ops { +=09/* Virtqueue ops */ +=09int (*set_vq_address)(struct mdev_device *mdev, +=09=09=09 u16 idx, u64 desc_area, u64 driver_area, +=09=09=09 u64 device_area); +=09void (*set_vq_num)(struct mdev_device *mdev, u16 idx, u32 num); +=09void (*kick_vq)(struct mdev_device *mdev, u16 idx); +=09void (*set_vq_cb)(struct mdev_device *mdev, u16 idx, +=09=09=09 struct virtio_mdev_callback *cb); +=09void (*set_vq_ready)(struct mdev_device *mdev, u16 idx, bool ready); +=09bool (*get_vq_ready)(struct mdev_device *mdev, u16 idx); +=09int (*set_vq_state)(struct mdev_device *mdev, u16 idx, u64 state); +=09u64 (*get_vq_state)(struct mdev_device *mdev, u16 idx); + +=09/* Device ops */ +=09u16 (*get_vq_align)(struct mdev_device *mdev); +=09u64 (*get_features)(struct mdev_device *mdev); +=09int (*set_features)(struct mdev_device *mdev, u64 features); +=09void (*set_config_cb)(struct mdev_device *mdev, +=09=09=09 struct virtio_mdev_callback *cb); +=09u16 (*get_vq_num_max)(struct mdev_device *mdev); +=09u32 (*get_device_id)(struct mdev_device *mdev); +=09u32 (*get_vendor_id)(struct mdev_device *mdev); +=09u8 (*get_status)(struct mdev_device *mdev); +=09void (*set_status)(struct mdev_device *mdev, u8 status); +=09void (*get_config)(struct mdev_device *mdev, unsigned int offset, +=09=09=09 void *buf, unsigned int len); +=09void (*set_config)(struct mdev_device *mdev, unsigned int offset, +=09=09=09 const void *buf, unsigned int len); +=09u32 (*get_generation)(struct mdev_device *mdev); +}; + +int mdev_virtio_register_device(struct device *dev, +=09=09=09=09const struct mdev_parent_ops *ops); +void mdev_virtio_unregister_device(struct device *dev); +void mdev_virtio_set_ops(struct mdev_device *mdev, +=09=09=09 const struct mdev_virtio_ops *ops); +const struct mdev_virtio_ops *mdev_virtio_get_ops(struct mdev_device *mdev= ); +void mdev_virtio_set_class_id(struct mdev_device *mdev, u16 class_id); + +static inline struct mdev_device *mdev_virtio_from_dev(struct device *dev) +{ +=09return mdev_from_dev(dev, &mdev_virtio_bus_type); +} + +#endif diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetabl= e.h index 5714fd35a83c..59006c47ae8e 100644 --- a/include/linux/mod_devicetable.h +++ b/include/linux/mod_devicetable.h @@ -821,4 +821,12 @@ struct wmi_device_id { =09const void *context; }; =20 +/** + * struct mdev_class_id - MDEV VIRTIO device class identifier + * @id: Used to identify a specific class of device, e.g vfio-mdev device. + */ +struct mdev_virtio_class_id { +=09__u16 id; +}; + #endif /* LINUX_MOD_DEVICETABLE_H */ diff --git a/scripts/mod/devicetable-offsets.c b/scripts/mod/devicetable-of= fsets.c index 054405b90ba4..178fd7c70812 100644 --- a/scripts/mod/devicetable-offsets.c +++ b/scripts/mod/devicetable-offsets.c @@ -231,5 +231,8 @@ int main(void) =09DEVID(wmi_device_id); =09DEVID_FIELD(wmi_device_id, guid_string); =20 +=09DEVID(mdev_virtio_class_id); +=09DEVID_FIELD(mdev_virtio_class_id, id); + =09return 0; } diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c index c91eba751804..1a9c1f591951 100644 --- a/scripts/mod/file2alias.c +++ b/scripts/mod/file2alias.c @@ -1335,6 +1335,17 @@ static int do_wmi_entry(const char *filename, void *= symval, char *alias) =09return 1; } =20 +/* looks like: "mdev_virtio:cN" */ +static int do_mdev_virtio_entry(const char *filename, void *symval, char *= alias) +{ +=09DEF_FIELD(symval, mdev_virtio_class_id, id); + +=09sprintf(alias, "mdev_virtio:c%02X", id); +=09add_wildcard(alias); +=09return 1; +} + + /* Does namelen bytes of name exactly match the symbol? */ static bool sym_is(const char *name, unsigned namelen, const char *symbol) { @@ -1407,6 +1418,7 @@ static const struct devtable devtable[] =3D { =09{"typec", SIZE_typec_device_id, do_typec_entry}, =09{"tee", SIZE_tee_client_device_id, do_tee_entry}, =09{"wmi", SIZE_wmi_device_id, do_wmi_entry}, +=09{"mdev_virtio", SIZE_mdev_virtio_class_id, do_mdev_virtio_entry}, }; =20 /* Create MODULE_ALIAS() statements. --=20 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V13 4/6] mdev: introduce mediated virtio bus Date: Mon, 18 Nov 2019 18:59:21 +0800 Message-ID: <20191118105923.7991-5-jasowang@redhat.com> References: <20191118105923.7991-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: 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 CDDB16E45F for ; Mon, 18 Nov 2019 11:02:17 +0000 (UTC) In-Reply-To: <20191118105923.7991-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, gregkh@linuxfoundation.org, jgg@mellanox.com Cc: rdunlap@infradead.org, jakub.kicinski@netronome.com, christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, kevin.tian@intel.com, rob.miller@broadcom.com, hch@infradead.org, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, jeffrey.t.kirsher@intel.com, zhi.a.wang@intel.com, farman@linux.ibm.com, parav@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, stefanha@redhat.com, zhihong.wang@intel.com, akrowiak@linux.ibm.com, jiri@mellanox.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, aadam@redhat.com, lingshan.zhu@intel.com List-Id: dri-devel@lists.freedesktop.org VGhpcyBwYXRjaCBpbXBsZW1lbnRzIGEgbWVkaWF0ZWQgdmlydGlvIGJ1cyBvdmVyIG1kZXYgZnJh bWV3b3JrLiBUaGlzCndpbGwgYmUgdXNlZCBieSB0aGUgZnV0dXJlIHZpcnRpby1tZGV2IGFuZCB2 aG9zdC1tZGV2IG9uIHRvcCB0byBhbGxvdwpkcml2ZXIgZnJvbSBlaXRoZXIgdXNlcnNwYWNlIG9y IGtlcm5lbCB0byBjb250cm9sIHRoZSBkZXZpY2Ugd2hpY2ggaXMKY2FwYWJsZSBvZiBvZmZsb2Fk aW5nIHZpcnRpbyBkYXRhcGF0aC4KClNpZ25lZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5n QHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgIHwgICAy ICsKIGRyaXZlcnMvbWRldi9LY29uZmlnICAgICAgICAgICAgICB8ICAxMCArKwogZHJpdmVycy9t ZGV2L01ha2VmaWxlICAgICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMvbWRldi92aXJ0aW8uYyAg ICAgICAgICAgICB8IDEyNiArKysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9t ZGV2X3ZpcnRpby5oICAgICAgIHwgMTYzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog aW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaCAgIHwgICA4ICsrCiBzY3JpcHRzL21vZC9k ZXZpY2V0YWJsZS1vZmZzZXRzLmMgfCAgIDMgKwogc2NyaXB0cy9tb2QvZmlsZTJhbGlhcy5jICAg ICAgICAgIHwgIDEyICsrKwogOCBmaWxlcyBjaGFuZ2VkLCAzMjYgaW5zZXJ0aW9ucygrKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWRldi92aXJ0aW8uYwogY3JlYXRlIG1vZGUgMTAwNjQ0 IGluY2x1ZGUvbGludXgvbWRldl92aXJ0aW8uaAoKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIv TUFJTlRBSU5FUlMKaW5kZXggNWQ3ZThiYWRmNThjLi5lMWI1N2M4NGYyNDkgMTAwNjQ0Ci0tLSBh L01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC0xNzI2OSw2ICsxNzI2OSw4IEBAIEY6 CWluY2x1ZGUvbGludXgvdmlydGlvKi5oCiBGOglpbmNsdWRlL3VhcGkvbGludXgvdmlydGlvXyou aAogRjoJZHJpdmVycy9jcnlwdG8vdmlydGlvLwogRjoJbW0vYmFsbG9vbl9jb21wYWN0aW9uLmMK K0Y6CWluY2x1ZGUvbGludXgvbWRldl92aXJ0aW8uaAorRjoJZHJpdmVycy9tZGV2L3ZpcnRpby5j CiAKIFZJUlRJTyBCTE9DSyBBTkQgU0NTSSBEUklWRVJTCiBNOgkiTWljaGFlbCBTLiBUc2lya2lu IiA8bXN0QHJlZGhhdC5jb20+CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kZXYvS2NvbmZpZyBiL2Ry aXZlcnMvbWRldi9LY29uZmlnCmluZGV4IDQ1NjFmMmQ0MTc4Zi4uY2Q4NGQ0NjcwNTUyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kZXYvS2NvbmZpZworKysgYi9kcml2ZXJzL21kZXYvS2NvbmZpZwpA QCAtMTcsMyArMTcsMTMgQEAgY29uZmlnIFZGSU9fTURFVgogCSAgbW9yZSBkZXRhaWxzLgogCiAJ ICBJZiB5b3UgZG9uJ3Qga25vdyB3aGF0IGRvIGhlcmUsIHNheSBOLgorCitjb25maWcgTURFVl9W SVJUSU8KKyAgICAgICB0cmlzdGF0ZSAiTWVkaWF0ZWQgVklSVElPIGJ1cyIKKyAgICAgICBkZXBl bmRzIG9uIFZJUlRJTyAmJiBNREVWCisgICAgICAgZGVmYXVsdCBuCisgICAgICAgaGVscAorCSAg UHJvaXZkZXMgYSBtZWRpYXRlZCBCVVMgZm9yIHZpcnRpby4gSXQgY291bGQgYmUgdXNlZCBieQor ICAgICAgICAgIGVpdGhlciBrZW5yZWwgZHJpdmVyIG9yIHVzZXJzcGFjZSBkcml2ZXIuCisKKwkg IElmIHlvdSBkb24ndCBrbm93IHdoYXQgZG8gaGVyZSwgc2F5IE4uCmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kZXYvTWFrZWZpbGUgYi9kcml2ZXJzL21kZXYvTWFrZWZpbGUKaW5kZXggMGI3NDllN2Y4 ZmY0Li5lYjE0MDMxYzk5NDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWRldi9NYWtlZmlsZQorKysg Yi9kcml2ZXJzL21kZXYvTWFrZWZpbGUKQEAgLTEsNSArMSw3IEBACiAKIG1kZXYteSA6PSBtZGV2 X2NvcmUubyBtZGV2X3N5c2ZzLm8gbWRldl9kcml2ZXIubwogbWRldl92ZmlvLXkgOj0gdmZpby5v CittZGV2X3ZpcnRpby15IDo9IHZpcnRpby5vCiBvYmotJChDT05GSUdfTURFVikgKz0gbWRldi5v CiBvYmotJChDT05GSUdfVkZJT19NREVWKSArPSBtZGV2X3ZmaW8ubworb2JqLSQoQ09ORklHX01E RVZfVklSVElPKSArPSBtZGV2X3ZpcnRpby5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kZXYvdmly dGlvLmMgYi9kcml2ZXJzL21kZXYvdmlydGlvLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwLi4yNWRlMzI5NjE1YzQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21k ZXYvdmlydGlvLmMKQEAgLTAsMCArMSwxMjYgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wLW9ubHkKKy8qCisgKiBNZWRpYXRlZCBWSVJUSU8gYnVzCisgKgorICogQ29weXJp Z2h0IChjKSAyMDE5LCBSZWQgSGF0LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogICAgIEF1dGhv cjogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvdXVpZC5oPgorI2luY2x1ZGUgPGxpbnV4L2Rl dmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9tZGV2X3Zp cnRpby5oPgorI2luY2x1ZGUgPGxpbnV4L21vZF9kZXZpY2V0YWJsZS5oPgorCisjaW5jbHVkZSAi bWRldl9wcml2YXRlLmgiCisKKyNkZWZpbmUgRFJJVkVSX1ZFUlNJT04JCSIwLjEiCisjZGVmaW5l IERSSVZFUl9BVVRIT1IJCSJKYXNvbiBXYW5nIgorI2RlZmluZSBEUklWRVJfREVTQwkJIk1lZGlh dGVkIFZJUlRJTyBidXMiCisKK3N0cnVjdCBidXNfdHlwZSBtZGV2X3ZpcnRpb19idXNfdHlwZTsK Kworc3RydWN0IG1kZXZfdmlydGlvX2RldmljZSB7CisJc3RydWN0IG1kZXZfZGV2aWNlIG1kZXY7 CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyAqb3BzOworCXUxNiBjbGFzc19pZDsKK307 CisKKyNkZWZpbmUgdG9fbWRldl92aXJ0aW8obWRldikgY29udGFpbmVyX29mKG1kZXYsIFwKKwkJ CQkJICBzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlLCBtZGV2KQorI2RlZmluZSB0b19tZGV2X3Zp cnRpb19kcnYobWRydikgY29udGFpbmVyX29mKG1kcnYsIFwKKwkJCQkJICAgICAgc3RydWN0IG1k ZXZfdmlydGlvX2RyaXZlciwgZHJ2KQorCitzdGF0aWMgaW50IG1kZXZfdmlydGlvX21hdGNoKHN0 cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9kcml2ZXIgKmRydikKK3sKKwl1bnNpZ25l ZCBpbnQgaTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSBtZGV2X2Zyb21fZGV2KGRldiwg Jm1kZXZfdmlydGlvX2J1c190eXBlKTsKKwlzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlICptZGV2 X3ZpcnRpbyA9IHRvX21kZXZfdmlydGlvKG1kZXYpOworCXN0cnVjdCBtZGV2X2RyaXZlciAqbWRy diA9IHRvX21kZXZfZHJpdmVyKGRydik7CisJc3RydWN0IG1kZXZfdmlydGlvX2RyaXZlciAqbWRy dl92aXJ0aW8gPSB0b19tZGV2X3ZpcnRpb19kcnYobWRydik7CisJY29uc3Qgc3RydWN0IG1kZXZf dmlydGlvX2NsYXNzX2lkICppZHMgPSBtZHJ2X3ZpcnRpby0+aWRfdGFibGU7CisKKwlpZiAoIWlk cykKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGkgPSAwOyBpZHNbaV0uaWQ7IGkrKykKKwkJaWYgKGlk c1tpXS5pZCA9PSBtZGV2X3ZpcnRpby0+Y2xhc3NfaWQpCisJCQlyZXR1cm4gMTsKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCBtZGV2X3ZpcnRpb191ZXZlbnQoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3Qga29ial91ZXZlbnRfZW52ICplbnYpCit7CisJc3RydWN0IG1kZXZfZGV2aWNlICpt ZGV2ID0gbWRldl9mcm9tX2RldihkZXYsICZtZGV2X3ZpcnRpb19idXNfdHlwZSk7CisJc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZSAqbWRldl92aXJ0aW8gPSB0b19tZGV2X3ZpcnRpbyhtZGV2KTsK KworCXJldHVybiBhZGRfdWV2ZW50X3ZhcihlbnYsICJNT0RBTElBUz1tZGV2X3ZpcnRpbzpjJTAy WCIsCisJCQkgICAgICBtZGV2X3ZpcnRpby0+Y2xhc3NfaWQpOworfQorCitzdHJ1Y3QgYnVzX3R5 cGUgbWRldl92aXJ0aW9fYnVzX3R5cGUgPSB7CisJLm5hbWUJCT0gIm1kZXZfdmlydGlvIiwKKwku cHJvYmUJCT0gbWRldl9wcm9iZSwKKwkucmVtb3ZlCQk9IG1kZXZfcmVtb3ZlLAorCS5tYXRjaAkg ICAgICAgID0gbWRldl92aXJ0aW9fbWF0Y2gsCisJLnVldmVudAkJPSBtZGV2X3ZpcnRpb191ZXZl bnQsCit9OworRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19idXNfdHlwZSk7CisKK3ZvaWQgbWRl dl92aXJ0aW9fc2V0X2NsYXNzX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGNsYXNz X2lkKQoreworCXN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2UgKm1kZXZfdmlydGlvID0gdG9fbWRl dl92aXJ0aW8obWRldik7CisKKwltZGV2X3ZpcnRpby0+Y2xhc3NfaWQgPSBjbGFzc19pZDsKK30K K0VYUE9SVF9TWU1CT0wobWRldl92aXJ0aW9fc2V0X2NsYXNzX2lkKTsKKworaW50IG1kZXZfdmly dGlvX3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJY29uc3Qgc3RydWN0 IG1kZXZfcGFyZW50X29wcyAqb3BzKQoreworCXJldHVybiBtZGV2X3JlZ2lzdGVyX2RldmljZShk ZXYsIG9wcywgJm1kZXZfdmlydGlvX2J1c190eXBlLAorCQkJCSAgICBzaXplb2Yoc3RydWN0IG1k ZXZfdmlydGlvX2RldmljZSkpOworfQorRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19yZWdpc3Rl cl9kZXZpY2UpOworCit2b2lkIG1kZXZfdmlydGlvX3VucmVnaXN0ZXJfZGV2aWNlKHN0cnVjdCBk ZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gbWRldl91bnJlZ2lzdGVyX2RldmljZShkZXYpOworfQor RVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb191bnJlZ2lzdGVyX2RldmljZSk7CisKK3ZvaWQgbWRl dl92aXJ0aW9fc2V0X29wcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgY29uc3Qgc3Ry dWN0IG1kZXZfdmlydGlvX29wcyAqb3BzKQoreworCXN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Ug Km1kZXZfdmlydGlvID0gdG9fbWRldl92aXJ0aW8obWRldik7CisKKwltZGV2X3ZpcnRpby0+b3Bz ID0gb3BzOworfQorRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19zZXRfb3BzKTsKKworY29uc3Qg c3RydWN0IG1kZXZfdmlydGlvX29wcyAqbWRldl92aXJ0aW9fZ2V0X29wcyhzdHJ1Y3QgbWRldl9k ZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG1kZXZfdmlydGlvX2RldmljZSAqbWRldl92aXJ0aW8g PSB0b19tZGV2X3ZpcnRpbyhtZGV2KTsKKworCXJldHVybiBtZGV2X3ZpcnRpby0+b3BzOworfQor RVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19nZXRfb3BzKTsKKworc3RhdGljIGludCBfX2luaXQg bWRldl9pbml0KHZvaWQpCit7CisJcmV0dXJuIG1kZXZfcmVnaXN0ZXJfYnVzKCZtZGV2X3ZpcnRp b19idXNfdHlwZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBtZGV2X2V4aXQodm9pZCkKK3sK KwltZGV2X3VucmVnaXN0ZXJfYnVzKCZtZGV2X3ZpcnRpb19idXNfdHlwZSk7Cit9CisKK21vZHVs ZV9pbml0KG1kZXZfaW5pdCkKK21vZHVsZV9leGl0KG1kZXZfZXhpdCkKKworTU9EVUxFX1ZFUlNJ T04oRFJJVkVSX1ZFUlNJT04pOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworTU9EVUxFX0FV VEhPUihEUklWRVJfQVVUSE9SKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CmRp ZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvLmggYi9pbmNsdWRlL2xpbnV4L21k ZXZfdmlydGlvLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lZjJk YmI2YzM4M2EKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvLmgK QEAgLTAsMCArMSwxNjMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkgKi8KKy8qCisgKiBWSVJUSU8gTWVkaWF0ZWQgZGV2aWNlIGRlZmluaXRpb24KKyAqCisgKiBD b3B5cmlnaHQgKGMpIDIwMTksIFJlZCBIYXQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiAgICAg QXV0aG9yOiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgorICovCisKKyNpZm5kZWYg VklSVElPX01ERVZfSAorI2RlZmluZSBWSVJUSU9fTURFVl9ICisKKyNpbmNsdWRlIDxsaW51eC9p bnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2RfZGV2aWNldGFibGUuaD4KKyNpbmNsdWRl IDxsaW51eC9tZGV2Lmg+CisKK2V4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgbWRldl92aXJ0aW9fYnVz X3R5cGU7CisKK3N0cnVjdCBtZGV2X3ZpcnRpb19kcml2ZXIgeworCXN0cnVjdCBtZGV2X2RyaXZl ciBkcnY7CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2NsYXNzX2lkICppZF90YWJsZTsKK307 CisKK3N0cnVjdCB2aXJ0aW9fbWRldl9jYWxsYmFjayB7CisJaXJxcmV0dXJuX3QgKCpjYWxsYmFj aykodm9pZCAqZGF0YSk7CisJdm9pZCAqcHJpdmF0ZTsKK307CisKKy8qKgorICogc3RydWN0IG1k ZXZfdmlydGlvX2RldmljZV9vcHMgLSBTdHJ1Y3R1cmUgdG8gYmUgcmVnaXN0ZXJlZCBmb3IgZWFj aAorICogbWRldiBkZXZpY2UgdG8gcmVnaXN0ZXIgdGhlIGRldmljZSBmb3IgdmlydGlvL3Zob3N0 IGRyaXZlcnMuCisgKgorICogVGhlIGNhbGxiYWNrcyBhcmUgbWFuZGF0b3J5IHVubGVzcyBleHBs aWNpdGx5IG1lbnRpb25lZC4KKyAqCisgKiBAc2V0X3ZxX2FkZHJlc3M6CQlTZXQgdGhlIGFkZHJl c3Mgb2YgdmlydHF1ZXVlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAaWR4 OiB2aXJ0cXVldWUgaW5kZXgKKyAqCQkJCUBkZXNjX2FyZWE6IGFkZHJlc3Mgb2YgZGVzYyBhcmVh CisgKgkJCQlAZHJpdmVyX2FyZWE6IGFkZHJlc3Mgb2YgZHJpdmVyIGFyZWEKKyAqCQkJCUBkZXZp Y2VfYXJlYTogYWRkcmVzcyBvZiBkZXZpY2UgYXJlYQorICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBz dWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQorICogQHNldF92cV9udW06CQkJU2V0IHRoZSBzaXpl IG9mIHZpcnRxdWV1ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJQGlkeDog dmlydHF1ZXVlIGluZGV4CisgKgkJCQlAbnVtOiB0aGUgc2l6ZSBvZiB2aXJ0cXVldWUKKyAqIEBr aWNrX3ZxOgkJCUtpY2sgdGhlIHZpcnRxdWV1ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmlj ZQorICoJCQkJQGlkeDogdmlydHF1ZXVlIGluZGV4CisgKiBAc2V0X3ZxX2NiOgkJCVNldCB0aGUg aW50ZXJydXB0IGNhbGxiYWNrIGZ1bmN0aW9uIGZvcgorICoJCQkJYSB2aXJ0cXVldWUKKyAqCQkJ CUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJ CQkJQGNiOiB2aXJ0aW8tbWRldiBpbnRlcnJ1cHQgY2FsbGJhY2sgc3RydWN0dXJlCisgKiBAc2V0 X3ZxX3JlYWR5OgkJU2V0IHJlYWR5IHN0YXR1cyBmb3IgYSB2aXJ0cXVldWUKKyAqCQkJCUBtZGV2 OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJCQkJQHJl YWR5OiByZWFkeSAodHJ1ZSkgbm90IHJlYWR5KGZhbHNlKQorICogQGdldF92cV9yZWFkeToJCUdl dCByZWFkeSBzdGF0dXMgZm9yIGEgdmlydHF1ZXVlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2 aWNlCisgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5kZXgKKyAqCQkJCVJldHVybnMgYm9vbGVhbjog cmVhZHkgKHRydWUpIG9yIG5vdCAoZmFsc2UpCisgKiBAc2V0X3ZxX3N0YXRlOgkJU2V0IHRoZSBz dGF0ZSBmb3IgYSB2aXJ0cXVldWUKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJ CUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJCQkJQHN0YXRlOiB2aXJ0cXVldWUgc3RhdGUgKGxh c3RfYXZhaWxfaWR4KQorICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJv ciAoPCAwKQorICogQGdldF92cV9zdGF0ZToJCUdldCB0aGUgc3RhdGUgZm9yIGEgdmlydHF1ZXVl CisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5k ZXgKKyAqCQkJCVJldHVybnMgdmlydHF1ZXVlIHN0YXRlIChsYXN0X2F2YWlsX2lkeCkKKyAqIEBn ZXRfdnFfYWxpZ246CQlHZXQgdGhlIHZpcnRxdWV1ZSBhbGlnbiByZXF1aXJlbWVudAorICoJCQkJ Zm9yIHRoZSBkZXZpY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCVJldHVy bnMgdmlydHF1ZXVlIGFsZ2luIHJlcXVpcmVtZW50CisgKiBAZ2V0X2ZlYXR1cmVzOgkJR2V0IHZp cnRpbyBmZWF0dXJlcyBzdXBwb3J0ZWQgYnkgdGhlIGRldmljZQorICoJCQkJQG1kZXY6IG1lZGlh dGVkIGRldmljZQorICoJCQkJUmV0dXJucyB0aGUgdmlydGlvIGZlYXR1cmVzIHN1cHBvcnQgYnkg dGhlCisgKgkJCQlkZXZpY2UKKyAqIEBzZXRfZmVhdHVyZXM6CQlTZXQgdmlydGlvIGZlYXR1cmVz IHN1cHBvcnRlZCBieSB0aGUgZHJpdmVyCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisg KgkJCQlAZmVhdHVyZXM6IGZlYXR1cmUgc3VwcG9ydCBieSB0aGUgZHJpdmVyCisgKgkJCQlSZXR1 cm5zIGludGVnZXI6IHN1Y2Nlc3MgKDApIG9yIGVycm9yICg8IDApCisgKiBAc2V0X2NvbmZpZ19j YjoJCVNldCB0aGUgY29uZmlnIGludGVycnVwdCBjYWxsYmFjaworICoJCQkJQG1kZXY6IG1lZGlh dGVkIGRldmljZQorICoJCQkJQGNiOiB2aXJ0aW8tbWRldiBpbnRlcnJ1cHQgY2FsbGJhY2sgc3Ry dWN0dXJlCisgKiBAZ2V0X3ZxX251bV9tYXg6CQlHZXQgdGhlIG1heCBzaXplIG9mIHZpcnRxdWV1 ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJUmV0dXJucyB1MTY6IG1heCBz aXplIG9mIHZpcnRxdWV1ZQorICogQGdldF9kZXZpY2VfaWQ6CQlHZXQgdmlydGlvIGRldmljZSBp ZAorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJUmV0dXJucyB1MzI6IHZpcnRp byBkZXZpY2UgaWQKKyAqIEBnZXRfdmVuZG9yX2lkOgkJR2V0IGlkIGZvciB0aGUgdmVuZG9yIHRo YXQgcHJvdmlkZXMgdGhpcyBkZXZpY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAq CQkJCVJldHVybnMgdTMyOiB2aXJ0aW8gdmVuZG9yIGlkCisgKiBAZ2V0X3N0YXR1czoJCQlHZXQg dGhlIGRldmljZSBzdGF0dXMKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCVJl dHVybnMgdTg6IHZpcnRpbyBkZXZpY2Ugc3RhdHVzCisgKiBAc2V0X3N0YXR1czoJCQlTZXQgdGhl IGRldmljZSBzdGF0dXMKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBzdGF0 dXM6IHZpcnRpbyBkZXZpY2Ugc3RhdHVzCisgKiBAZ2V0X2NvbmZpZzoJCQlSZWFkIGZyb20gZGV2 aWNlIHNwZWNpZmljIGNvbmZpZ3VyYXRpb24gc3BhY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBk ZXZpY2UKKyAqCQkJCUBvZmZzZXQ6IG9mZnNldCBmcm9tIHRoZSBiZWdpbm5pbmcgb2YKKyAqCQkJ CWNvbmZpZ3VyYXRpb24gc3BhY2UKKyAqCQkJCUBidWY6IGJ1ZmZlciB1c2VkIHRvIHJlYWQgdG8K KyAqCQkJCUBsZW46IHRoZSBsZW5ndGggdG8gcmVhZCBmcm9tCisgKgkJCQljb25maWdyYXRpb24g c3BhY2UKKyAqIEBzZXRfY29uZmlnOgkJCVdyaXRlIHRvIGRldmljZSBzcGVjaWZpYyBjb25maWd1 cmF0aW9uIHNwYWNlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAb2Zmc2V0 OiBvZmZzZXQgZnJvbSB0aGUgYmVnaW5uaW5nIG9mCisgKgkJCQljb25maWd1cmF0aW9uIHNwYWNl CisgKgkJCQlAYnVmOiBidWZmZXIgdXNlZCB0byB3cml0ZSBmcm9tCisgKgkJCQlAbGVuOiB0aGUg bGVuZ3RoIHRvIHdyaXRlIHRvCisgKgkJCQljb25maWdyYXRpb24gc3BhY2UKKyAqIEBnZXRfZ2Vu ZXJhdGlvbjoJCUdldCBkZXZpY2UgY29uZmlnIGdlbmVyYXRvbiAob3B0aW9uYWwpCisgKgkJCQlA bWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlSZXR1cm5zIHUzMjogZGV2aWNlIGdlbmVyYXRp b24KKyAqLworc3RydWN0IG1kZXZfdmlydGlvX29wcyB7CisJLyogVmlydHF1ZXVlIG9wcyAqLwor CWludCAoKnNldF92cV9hZGRyZXNzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgICAg ICB1MTYgaWR4LCB1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEsCisJCQkgICAgICB1NjQg ZGV2aWNlX2FyZWEpOworCXZvaWQgKCpzZXRfdnFfbnVtKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYsIHUxNiBpZHgsIHUzMiBudW0pOworCXZvaWQgKCpraWNrX3ZxKShzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYsIHUxNiBpZHgpOworCXZvaWQgKCpzZXRfdnFfY2IpKHN0cnVjdCBtZGV2X2Rldmlj ZSAqbWRldiwgdTE2IGlkeCwKKwkJCSAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpjYik7 CisJdm9pZCAoKnNldF92cV9yZWFkeSkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4 LCBib29sIHJlYWR5KTsKKwlib29sICgqZ2V0X3ZxX3JlYWR5KShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYsIHUxNiBpZHgpOworCWludCAoKnNldF92cV9zdGF0ZSkoc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2LCB1MTYgaWR4LCB1NjQgc3RhdGUpOworCXU2NCAoKmdldF92cV9zdGF0ZSkoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KTsKKworCS8qIERldmljZSBvcHMgKi8KKwl1MTYg KCpnZXRfdnFfYWxpZ24pKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7CisJdTY0ICgqZ2V0X2Zl YXR1cmVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOworCWludCAoKnNldF9mZWF0dXJlcyko c3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1NjQgZmVhdHVyZXMpOworCXZvaWQgKCpzZXRfY29u ZmlnX2NiKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgICAgICBzdHJ1Y3QgdmlydGlv X21kZXZfY2FsbGJhY2sgKmNiKTsKKwl1MTYgKCpnZXRfdnFfbnVtX21heCkoc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2KTsKKwl1MzIgKCpnZXRfZGV2aWNlX2lkKShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYpOworCXUzMiAoKmdldF92ZW5kb3JfaWQpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7 CisJdTggKCpnZXRfc3RhdHVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOworCXZvaWQgKCpz ZXRfc3RhdHVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cyk7CisJdm9pZCAo KmdldF9jb25maWcpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNl dCwKKwkJCSAgIHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbik7CisJdm9pZCAoKnNldF9jb25m aWcpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAg IGNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbik7CisJdTMyICgqZ2V0X2dlbmVyYXRp b24pKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7Cit9OworCitpbnQgbWRldl92aXJ0aW9fcmVn aXN0ZXJfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQljb25zdCBzdHJ1Y3QgbWRldl9w YXJlbnRfb3BzICpvcHMpOwordm9pZCBtZGV2X3ZpcnRpb191bnJlZ2lzdGVyX2RldmljZShzdHJ1 Y3QgZGV2aWNlICpkZXYpOwordm9pZCBtZGV2X3ZpcnRpb19zZXRfb3BzKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwKKwkJCSBjb25zdCBzdHJ1Y3QgbWRldl92aXJ0aW9fb3BzICpvcHMpOworY29u c3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyAqbWRldl92aXJ0aW9fZ2V0X29wcyhzdHJ1Y3QgbWRl dl9kZXZpY2UgKm1kZXYpOwordm9pZCBtZGV2X3ZpcnRpb19zZXRfY2xhc3NfaWQoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2LCB1MTYgY2xhc3NfaWQpOworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldl92aXJ0aW9fZnJvbV9kZXYoc3RydWN0IGRldmljZSAqZGV2KQorewor CXJldHVybiBtZGV2X2Zyb21fZGV2KGRldiwgJm1kZXZfdmlydGlvX2J1c190eXBlKTsKK30KKwor I2VuZGlmCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oIGIvaW5j bHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaAppbmRleCA1NzE0ZmQzNWE4M2MuLjU5MDA2YzQ3 YWU4ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaAorKysgYi9p bmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oCkBAIC04MjEsNCArODIxLDEyIEBAIHN0cnVj dCB3bWlfZGV2aWNlX2lkIHsKIAljb25zdCB2b2lkICpjb250ZXh0OwogfTsKIAorLyoqCisgKiBz dHJ1Y3QgbWRldl9jbGFzc19pZCAtIE1ERVYgVklSVElPIGRldmljZSBjbGFzcyBpZGVudGlmaWVy CisgKiBAaWQ6IFVzZWQgdG8gaWRlbnRpZnkgYSBzcGVjaWZpYyBjbGFzcyBvZiBkZXZpY2UsIGUu ZyB2ZmlvLW1kZXYgZGV2aWNlLgorICovCitzdHJ1Y3QgbWRldl92aXJ0aW9fY2xhc3NfaWQgewor CV9fdTE2IGlkOworfTsKKwogI2VuZGlmIC8qIExJTlVYX01PRF9ERVZJQ0VUQUJMRV9IICovCmRp ZmYgLS1naXQgYS9zY3JpcHRzL21vZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMgYi9zY3JpcHRzL21v ZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMKaW5kZXggMDU0NDA1YjkwYmE0Li4xNzhmZDdjNzA4MTIg MTAwNjQ0Ci0tLSBhL3NjcmlwdHMvbW9kL2RldmljZXRhYmxlLW9mZnNldHMuYworKysgYi9zY3Jp cHRzL21vZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMKQEAgLTIzMSw1ICsyMzEsOCBAQCBpbnQgbWFp bih2b2lkKQogCURFVklEKHdtaV9kZXZpY2VfaWQpOwogCURFVklEX0ZJRUxEKHdtaV9kZXZpY2Vf aWQsIGd1aWRfc3RyaW5nKTsKIAorCURFVklEKG1kZXZfdmlydGlvX2NsYXNzX2lkKTsKKwlERVZJ RF9GSUVMRChtZGV2X3ZpcnRpb19jbGFzc19pZCwgaWQpOworCiAJcmV0dXJuIDA7CiB9CmRpZmYg LS1naXQgYS9zY3JpcHRzL21vZC9maWxlMmFsaWFzLmMgYi9zY3JpcHRzL21vZC9maWxlMmFsaWFz LmMKaW5kZXggYzkxZWJhNzUxODA0Li4xYTljMWY1OTE5NTEgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMv bW9kL2ZpbGUyYWxpYXMuYworKysgYi9zY3JpcHRzL21vZC9maWxlMmFsaWFzLmMKQEAgLTEzMzUs NiArMTMzNSwxNyBAQCBzdGF0aWMgaW50IGRvX3dtaV9lbnRyeShjb25zdCBjaGFyICpmaWxlbmFt ZSwgdm9pZCAqc3ltdmFsLCBjaGFyICphbGlhcykKIAlyZXR1cm4gMTsKIH0KIAorLyogbG9va3Mg bGlrZTogIm1kZXZfdmlydGlvOmNOIiAqLworc3RhdGljIGludCBkb19tZGV2X3ZpcnRpb19lbnRy eShjb25zdCBjaGFyICpmaWxlbmFtZSwgdm9pZCAqc3ltdmFsLCBjaGFyICphbGlhcykKK3sKKwlE RUZfRklFTEQoc3ltdmFsLCBtZGV2X3ZpcnRpb19jbGFzc19pZCwgaWQpOworCisJc3ByaW50Zihh bGlhcywgIm1kZXZfdmlydGlvOmMlMDJYIiwgaWQpOworCWFkZF93aWxkY2FyZChhbGlhcyk7CisJ cmV0dXJuIDE7Cit9CisKKwogLyogRG9lcyBuYW1lbGVuIGJ5dGVzIG9mIG5hbWUgZXhhY3RseSBt YXRjaCB0aGUgc3ltYm9sPyAqLwogc3RhdGljIGJvb2wgc3ltX2lzKGNvbnN0IGNoYXIgKm5hbWUs IHVuc2lnbmVkIG5hbWVsZW4sIGNvbnN0IGNoYXIgKnN5bWJvbCkKIHsKQEAgLTE0MDcsNiArMTQx OCw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2dGFibGUgZGV2dGFibGVbXSA9IHsKIAl7InR5 cGVjIiwgU0laRV90eXBlY19kZXZpY2VfaWQsIGRvX3R5cGVjX2VudHJ5fSwKIAl7InRlZSIsIFNJ WkVfdGVlX2NsaWVudF9kZXZpY2VfaWQsIGRvX3RlZV9lbnRyeX0sCiAJeyJ3bWkiLCBTSVpFX3dt aV9kZXZpY2VfaWQsIGRvX3dtaV9lbnRyeX0sCisJeyJtZGV2X3ZpcnRpbyIsIFNJWkVfbWRldl92 aXJ0aW9fY2xhc3NfaWQsIGRvX21kZXZfdmlydGlvX2VudHJ5fSwKIH07CiAKIC8qIENyZWF0ZSBN T0RVTEVfQUxJQVMoKSBzdGF0ZW1lbnRzLgotLSAKMi4xOS4xCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWw= 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 14F93C432C3 for ; Mon, 18 Nov 2019 11:02:20 +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 E5DB620730 for ; Mon, 18 Nov 2019 11:02:19 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E5DB620730 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 615BF6E45E; Mon, 18 Nov 2019 11:02:19 +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 C83176E45E for ; Mon, 18 Nov 2019 11:02:17 +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-57-tZBqeW2pONKR0-_5Ku4cEA-1; Mon, 18 Nov 2019 06:02:13 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E8FBB805319; Mon, 18 Nov 2019 11:02:07 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-65.pek2.redhat.com [10.72.12.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5B2D660BE1; Mon, 18 Nov 2019 11:01:42 +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, gregkh@linuxfoundation.org, jgg@mellanox.com Date: Mon, 18 Nov 2019 18:59:21 +0800 Message-Id: <20191118105923.7991-5-jasowang@redhat.com> In-Reply-To: <20191118105923.7991-1-jasowang@redhat.com> References: <20191118105923.7991-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-MC-Unique: tZBqeW2pONKR0-_5Ku4cEA-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=1574074936; 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=3ja26PSJK9ygpRuIQpXY0DayGYbCviriRvTlXBCNZRc=; b=IQV3/9jVahpx5ulmQj7W1LakbWfB9t4DfZ3+btAWmSPYDmwJSBFWhd+g0JPYE4nJ6S4isH b1vtEMp5qpjnJA8AUMs2/HcVsCza1tb7m8Ismw8GlxJKXmQcxSujIAWZDiUjyVPcfalstk yuEdjcHcF5DyBCTbTvCbJi8COcrtTKk= Subject: [Intel-gfx] [PATCH V13 4/6] mdev: introduce mediated virtio bus 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: rdunlap@infradead.org, jakub.kicinski@netronome.com, christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, rob.miller@broadcom.com, hch@infradead.org, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, jeffrey.t.kirsher@intel.com, farman@linux.ibm.com, parav@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, stefanha@redhat.com, zhihong.wang@intel.com, akrowiak@linux.ibm.com, jiri@mellanox.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, aadam@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: <20191118105921.kgj27czhdCeaLcioWm9pRlrHFH2tMKLGn22SszgbU_k@z> VGhpcyBwYXRjaCBpbXBsZW1lbnRzIGEgbWVkaWF0ZWQgdmlydGlvIGJ1cyBvdmVyIG1kZXYgZnJh bWV3b3JrLiBUaGlzCndpbGwgYmUgdXNlZCBieSB0aGUgZnV0dXJlIHZpcnRpby1tZGV2IGFuZCB2 aG9zdC1tZGV2IG9uIHRvcCB0byBhbGxvdwpkcml2ZXIgZnJvbSBlaXRoZXIgdXNlcnNwYWNlIG9y IGtlcm5lbCB0byBjb250cm9sIHRoZSBkZXZpY2Ugd2hpY2ggaXMKY2FwYWJsZSBvZiBvZmZsb2Fk aW5nIHZpcnRpbyBkYXRhcGF0aC4KClNpZ25lZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5n QHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgIHwgICAy ICsKIGRyaXZlcnMvbWRldi9LY29uZmlnICAgICAgICAgICAgICB8ICAxMCArKwogZHJpdmVycy9t ZGV2L01ha2VmaWxlICAgICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMvbWRldi92aXJ0aW8uYyAg ICAgICAgICAgICB8IDEyNiArKysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9t ZGV2X3ZpcnRpby5oICAgICAgIHwgMTYzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog aW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaCAgIHwgICA4ICsrCiBzY3JpcHRzL21vZC9k ZXZpY2V0YWJsZS1vZmZzZXRzLmMgfCAgIDMgKwogc2NyaXB0cy9tb2QvZmlsZTJhbGlhcy5jICAg ICAgICAgIHwgIDEyICsrKwogOCBmaWxlcyBjaGFuZ2VkLCAzMjYgaW5zZXJ0aW9ucygrKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWRldi92aXJ0aW8uYwogY3JlYXRlIG1vZGUgMTAwNjQ0 IGluY2x1ZGUvbGludXgvbWRldl92aXJ0aW8uaAoKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIv TUFJTlRBSU5FUlMKaW5kZXggNWQ3ZThiYWRmNThjLi5lMWI1N2M4NGYyNDkgMTAwNjQ0Ci0tLSBh L01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC0xNzI2OSw2ICsxNzI2OSw4IEBAIEY6 CWluY2x1ZGUvbGludXgvdmlydGlvKi5oCiBGOglpbmNsdWRlL3VhcGkvbGludXgvdmlydGlvXyou aAogRjoJZHJpdmVycy9jcnlwdG8vdmlydGlvLwogRjoJbW0vYmFsbG9vbl9jb21wYWN0aW9uLmMK K0Y6CWluY2x1ZGUvbGludXgvbWRldl92aXJ0aW8uaAorRjoJZHJpdmVycy9tZGV2L3ZpcnRpby5j CiAKIFZJUlRJTyBCTE9DSyBBTkQgU0NTSSBEUklWRVJTCiBNOgkiTWljaGFlbCBTLiBUc2lya2lu IiA8bXN0QHJlZGhhdC5jb20+CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kZXYvS2NvbmZpZyBiL2Ry aXZlcnMvbWRldi9LY29uZmlnCmluZGV4IDQ1NjFmMmQ0MTc4Zi4uY2Q4NGQ0NjcwNTUyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kZXYvS2NvbmZpZworKysgYi9kcml2ZXJzL21kZXYvS2NvbmZpZwpA QCAtMTcsMyArMTcsMTMgQEAgY29uZmlnIFZGSU9fTURFVgogCSAgbW9yZSBkZXRhaWxzLgogCiAJ ICBJZiB5b3UgZG9uJ3Qga25vdyB3aGF0IGRvIGhlcmUsIHNheSBOLgorCitjb25maWcgTURFVl9W SVJUSU8KKyAgICAgICB0cmlzdGF0ZSAiTWVkaWF0ZWQgVklSVElPIGJ1cyIKKyAgICAgICBkZXBl bmRzIG9uIFZJUlRJTyAmJiBNREVWCisgICAgICAgZGVmYXVsdCBuCisgICAgICAgaGVscAorCSAg UHJvaXZkZXMgYSBtZWRpYXRlZCBCVVMgZm9yIHZpcnRpby4gSXQgY291bGQgYmUgdXNlZCBieQor ICAgICAgICAgIGVpdGhlciBrZW5yZWwgZHJpdmVyIG9yIHVzZXJzcGFjZSBkcml2ZXIuCisKKwkg IElmIHlvdSBkb24ndCBrbm93IHdoYXQgZG8gaGVyZSwgc2F5IE4uCmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kZXYvTWFrZWZpbGUgYi9kcml2ZXJzL21kZXYvTWFrZWZpbGUKaW5kZXggMGI3NDllN2Y4 ZmY0Li5lYjE0MDMxYzk5NDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWRldi9NYWtlZmlsZQorKysg Yi9kcml2ZXJzL21kZXYvTWFrZWZpbGUKQEAgLTEsNSArMSw3IEBACiAKIG1kZXYteSA6PSBtZGV2 X2NvcmUubyBtZGV2X3N5c2ZzLm8gbWRldl9kcml2ZXIubwogbWRldl92ZmlvLXkgOj0gdmZpby5v CittZGV2X3ZpcnRpby15IDo9IHZpcnRpby5vCiBvYmotJChDT05GSUdfTURFVikgKz0gbWRldi5v CiBvYmotJChDT05GSUdfVkZJT19NREVWKSArPSBtZGV2X3ZmaW8ubworb2JqLSQoQ09ORklHX01E RVZfVklSVElPKSArPSBtZGV2X3ZpcnRpby5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kZXYvdmly dGlvLmMgYi9kcml2ZXJzL21kZXYvdmlydGlvLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwLi4yNWRlMzI5NjE1YzQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21k ZXYvdmlydGlvLmMKQEAgLTAsMCArMSwxMjYgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wLW9ubHkKKy8qCisgKiBNZWRpYXRlZCBWSVJUSU8gYnVzCisgKgorICogQ29weXJp Z2h0IChjKSAyMDE5LCBSZWQgSGF0LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogICAgIEF1dGhv cjogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvdXVpZC5oPgorI2luY2x1ZGUgPGxpbnV4L2Rl dmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9tZGV2X3Zp cnRpby5oPgorI2luY2x1ZGUgPGxpbnV4L21vZF9kZXZpY2V0YWJsZS5oPgorCisjaW5jbHVkZSAi bWRldl9wcml2YXRlLmgiCisKKyNkZWZpbmUgRFJJVkVSX1ZFUlNJT04JCSIwLjEiCisjZGVmaW5l IERSSVZFUl9BVVRIT1IJCSJKYXNvbiBXYW5nIgorI2RlZmluZSBEUklWRVJfREVTQwkJIk1lZGlh dGVkIFZJUlRJTyBidXMiCisKK3N0cnVjdCBidXNfdHlwZSBtZGV2X3ZpcnRpb19idXNfdHlwZTsK Kworc3RydWN0IG1kZXZfdmlydGlvX2RldmljZSB7CisJc3RydWN0IG1kZXZfZGV2aWNlIG1kZXY7 CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyAqb3BzOworCXUxNiBjbGFzc19pZDsKK307 CisKKyNkZWZpbmUgdG9fbWRldl92aXJ0aW8obWRldikgY29udGFpbmVyX29mKG1kZXYsIFwKKwkJ CQkJICBzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlLCBtZGV2KQorI2RlZmluZSB0b19tZGV2X3Zp cnRpb19kcnYobWRydikgY29udGFpbmVyX29mKG1kcnYsIFwKKwkJCQkJICAgICAgc3RydWN0IG1k ZXZfdmlydGlvX2RyaXZlciwgZHJ2KQorCitzdGF0aWMgaW50IG1kZXZfdmlydGlvX21hdGNoKHN0 cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9kcml2ZXIgKmRydikKK3sKKwl1bnNpZ25l ZCBpbnQgaTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSBtZGV2X2Zyb21fZGV2KGRldiwg Jm1kZXZfdmlydGlvX2J1c190eXBlKTsKKwlzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlICptZGV2 X3ZpcnRpbyA9IHRvX21kZXZfdmlydGlvKG1kZXYpOworCXN0cnVjdCBtZGV2X2RyaXZlciAqbWRy diA9IHRvX21kZXZfZHJpdmVyKGRydik7CisJc3RydWN0IG1kZXZfdmlydGlvX2RyaXZlciAqbWRy dl92aXJ0aW8gPSB0b19tZGV2X3ZpcnRpb19kcnYobWRydik7CisJY29uc3Qgc3RydWN0IG1kZXZf dmlydGlvX2NsYXNzX2lkICppZHMgPSBtZHJ2X3ZpcnRpby0+aWRfdGFibGU7CisKKwlpZiAoIWlk cykKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGkgPSAwOyBpZHNbaV0uaWQ7IGkrKykKKwkJaWYgKGlk c1tpXS5pZCA9PSBtZGV2X3ZpcnRpby0+Y2xhc3NfaWQpCisJCQlyZXR1cm4gMTsKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCBtZGV2X3ZpcnRpb191ZXZlbnQoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3Qga29ial91ZXZlbnRfZW52ICplbnYpCit7CisJc3RydWN0IG1kZXZfZGV2aWNlICpt ZGV2ID0gbWRldl9mcm9tX2RldihkZXYsICZtZGV2X3ZpcnRpb19idXNfdHlwZSk7CisJc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZSAqbWRldl92aXJ0aW8gPSB0b19tZGV2X3ZpcnRpbyhtZGV2KTsK KworCXJldHVybiBhZGRfdWV2ZW50X3ZhcihlbnYsICJNT0RBTElBUz1tZGV2X3ZpcnRpbzpjJTAy WCIsCisJCQkgICAgICBtZGV2X3ZpcnRpby0+Y2xhc3NfaWQpOworfQorCitzdHJ1Y3QgYnVzX3R5 cGUgbWRldl92aXJ0aW9fYnVzX3R5cGUgPSB7CisJLm5hbWUJCT0gIm1kZXZfdmlydGlvIiwKKwku cHJvYmUJCT0gbWRldl9wcm9iZSwKKwkucmVtb3ZlCQk9IG1kZXZfcmVtb3ZlLAorCS5tYXRjaAkg ICAgICAgID0gbWRldl92aXJ0aW9fbWF0Y2gsCisJLnVldmVudAkJPSBtZGV2X3ZpcnRpb191ZXZl bnQsCit9OworRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19idXNfdHlwZSk7CisKK3ZvaWQgbWRl dl92aXJ0aW9fc2V0X2NsYXNzX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGNsYXNz X2lkKQoreworCXN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2UgKm1kZXZfdmlydGlvID0gdG9fbWRl dl92aXJ0aW8obWRldik7CisKKwltZGV2X3ZpcnRpby0+Y2xhc3NfaWQgPSBjbGFzc19pZDsKK30K K0VYUE9SVF9TWU1CT0wobWRldl92aXJ0aW9fc2V0X2NsYXNzX2lkKTsKKworaW50IG1kZXZfdmly dGlvX3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJY29uc3Qgc3RydWN0 IG1kZXZfcGFyZW50X29wcyAqb3BzKQoreworCXJldHVybiBtZGV2X3JlZ2lzdGVyX2RldmljZShk ZXYsIG9wcywgJm1kZXZfdmlydGlvX2J1c190eXBlLAorCQkJCSAgICBzaXplb2Yoc3RydWN0IG1k ZXZfdmlydGlvX2RldmljZSkpOworfQorRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19yZWdpc3Rl cl9kZXZpY2UpOworCit2b2lkIG1kZXZfdmlydGlvX3VucmVnaXN0ZXJfZGV2aWNlKHN0cnVjdCBk ZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gbWRldl91bnJlZ2lzdGVyX2RldmljZShkZXYpOworfQor RVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb191bnJlZ2lzdGVyX2RldmljZSk7CisKK3ZvaWQgbWRl dl92aXJ0aW9fc2V0X29wcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgY29uc3Qgc3Ry dWN0IG1kZXZfdmlydGlvX29wcyAqb3BzKQoreworCXN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Ug Km1kZXZfdmlydGlvID0gdG9fbWRldl92aXJ0aW8obWRldik7CisKKwltZGV2X3ZpcnRpby0+b3Bz ID0gb3BzOworfQorRVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19zZXRfb3BzKTsKKworY29uc3Qg c3RydWN0IG1kZXZfdmlydGlvX29wcyAqbWRldl92aXJ0aW9fZ2V0X29wcyhzdHJ1Y3QgbWRldl9k ZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG1kZXZfdmlydGlvX2RldmljZSAqbWRldl92aXJ0aW8g PSB0b19tZGV2X3ZpcnRpbyhtZGV2KTsKKworCXJldHVybiBtZGV2X3ZpcnRpby0+b3BzOworfQor RVhQT1JUX1NZTUJPTChtZGV2X3ZpcnRpb19nZXRfb3BzKTsKKworc3RhdGljIGludCBfX2luaXQg bWRldl9pbml0KHZvaWQpCit7CisJcmV0dXJuIG1kZXZfcmVnaXN0ZXJfYnVzKCZtZGV2X3ZpcnRp b19idXNfdHlwZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBtZGV2X2V4aXQodm9pZCkKK3sK KwltZGV2X3VucmVnaXN0ZXJfYnVzKCZtZGV2X3ZpcnRpb19idXNfdHlwZSk7Cit9CisKK21vZHVs ZV9pbml0KG1kZXZfaW5pdCkKK21vZHVsZV9leGl0KG1kZXZfZXhpdCkKKworTU9EVUxFX1ZFUlNJ T04oRFJJVkVSX1ZFUlNJT04pOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworTU9EVUxFX0FV VEhPUihEUklWRVJfQVVUSE9SKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CmRp ZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvLmggYi9pbmNsdWRlL2xpbnV4L21k ZXZfdmlydGlvLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lZjJk YmI2YzM4M2EKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvLmgK QEAgLTAsMCArMSwxNjMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkgKi8KKy8qCisgKiBWSVJUSU8gTWVkaWF0ZWQgZGV2aWNlIGRlZmluaXRpb24KKyAqCisgKiBD b3B5cmlnaHQgKGMpIDIwMTksIFJlZCBIYXQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiAgICAg QXV0aG9yOiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgorICovCisKKyNpZm5kZWYg VklSVElPX01ERVZfSAorI2RlZmluZSBWSVJUSU9fTURFVl9ICisKKyNpbmNsdWRlIDxsaW51eC9p bnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2RfZGV2aWNldGFibGUuaD4KKyNpbmNsdWRl IDxsaW51eC9tZGV2Lmg+CisKK2V4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgbWRldl92aXJ0aW9fYnVz X3R5cGU7CisKK3N0cnVjdCBtZGV2X3ZpcnRpb19kcml2ZXIgeworCXN0cnVjdCBtZGV2X2RyaXZl ciBkcnY7CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2NsYXNzX2lkICppZF90YWJsZTsKK307 CisKK3N0cnVjdCB2aXJ0aW9fbWRldl9jYWxsYmFjayB7CisJaXJxcmV0dXJuX3QgKCpjYWxsYmFj aykodm9pZCAqZGF0YSk7CisJdm9pZCAqcHJpdmF0ZTsKK307CisKKy8qKgorICogc3RydWN0IG1k ZXZfdmlydGlvX2RldmljZV9vcHMgLSBTdHJ1Y3R1cmUgdG8gYmUgcmVnaXN0ZXJlZCBmb3IgZWFj aAorICogbWRldiBkZXZpY2UgdG8gcmVnaXN0ZXIgdGhlIGRldmljZSBmb3IgdmlydGlvL3Zob3N0 IGRyaXZlcnMuCisgKgorICogVGhlIGNhbGxiYWNrcyBhcmUgbWFuZGF0b3J5IHVubGVzcyBleHBs aWNpdGx5IG1lbnRpb25lZC4KKyAqCisgKiBAc2V0X3ZxX2FkZHJlc3M6CQlTZXQgdGhlIGFkZHJl c3Mgb2YgdmlydHF1ZXVlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAaWR4 OiB2aXJ0cXVldWUgaW5kZXgKKyAqCQkJCUBkZXNjX2FyZWE6IGFkZHJlc3Mgb2YgZGVzYyBhcmVh CisgKgkJCQlAZHJpdmVyX2FyZWE6IGFkZHJlc3Mgb2YgZHJpdmVyIGFyZWEKKyAqCQkJCUBkZXZp Y2VfYXJlYTogYWRkcmVzcyBvZiBkZXZpY2UgYXJlYQorICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBz dWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQorICogQHNldF92cV9udW06CQkJU2V0IHRoZSBzaXpl IG9mIHZpcnRxdWV1ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJQGlkeDog dmlydHF1ZXVlIGluZGV4CisgKgkJCQlAbnVtOiB0aGUgc2l6ZSBvZiB2aXJ0cXVldWUKKyAqIEBr aWNrX3ZxOgkJCUtpY2sgdGhlIHZpcnRxdWV1ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmlj ZQorICoJCQkJQGlkeDogdmlydHF1ZXVlIGluZGV4CisgKiBAc2V0X3ZxX2NiOgkJCVNldCB0aGUg aW50ZXJydXB0IGNhbGxiYWNrIGZ1bmN0aW9uIGZvcgorICoJCQkJYSB2aXJ0cXVldWUKKyAqCQkJ CUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJ CQkJQGNiOiB2aXJ0aW8tbWRldiBpbnRlcnJ1cHQgY2FsbGJhY2sgc3RydWN0dXJlCisgKiBAc2V0 X3ZxX3JlYWR5OgkJU2V0IHJlYWR5IHN0YXR1cyBmb3IgYSB2aXJ0cXVldWUKKyAqCQkJCUBtZGV2 OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJCQkJQHJl YWR5OiByZWFkeSAodHJ1ZSkgbm90IHJlYWR5KGZhbHNlKQorICogQGdldF92cV9yZWFkeToJCUdl dCByZWFkeSBzdGF0dXMgZm9yIGEgdmlydHF1ZXVlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2 aWNlCisgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5kZXgKKyAqCQkJCVJldHVybnMgYm9vbGVhbjog cmVhZHkgKHRydWUpIG9yIG5vdCAoZmFsc2UpCisgKiBAc2V0X3ZxX3N0YXRlOgkJU2V0IHRoZSBz dGF0ZSBmb3IgYSB2aXJ0cXVldWUKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJ CUBpZHg6IHZpcnRxdWV1ZSBpbmRleAorICoJCQkJQHN0YXRlOiB2aXJ0cXVldWUgc3RhdGUgKGxh c3RfYXZhaWxfaWR4KQorICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJv ciAoPCAwKQorICogQGdldF92cV9zdGF0ZToJCUdldCB0aGUgc3RhdGUgZm9yIGEgdmlydHF1ZXVl CisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5k ZXgKKyAqCQkJCVJldHVybnMgdmlydHF1ZXVlIHN0YXRlIChsYXN0X2F2YWlsX2lkeCkKKyAqIEBn ZXRfdnFfYWxpZ246CQlHZXQgdGhlIHZpcnRxdWV1ZSBhbGlnbiByZXF1aXJlbWVudAorICoJCQkJ Zm9yIHRoZSBkZXZpY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCVJldHVy bnMgdmlydHF1ZXVlIGFsZ2luIHJlcXVpcmVtZW50CisgKiBAZ2V0X2ZlYXR1cmVzOgkJR2V0IHZp cnRpbyBmZWF0dXJlcyBzdXBwb3J0ZWQgYnkgdGhlIGRldmljZQorICoJCQkJQG1kZXY6IG1lZGlh dGVkIGRldmljZQorICoJCQkJUmV0dXJucyB0aGUgdmlydGlvIGZlYXR1cmVzIHN1cHBvcnQgYnkg dGhlCisgKgkJCQlkZXZpY2UKKyAqIEBzZXRfZmVhdHVyZXM6CQlTZXQgdmlydGlvIGZlYXR1cmVz IHN1cHBvcnRlZCBieSB0aGUgZHJpdmVyCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisg KgkJCQlAZmVhdHVyZXM6IGZlYXR1cmUgc3VwcG9ydCBieSB0aGUgZHJpdmVyCisgKgkJCQlSZXR1 cm5zIGludGVnZXI6IHN1Y2Nlc3MgKDApIG9yIGVycm9yICg8IDApCisgKiBAc2V0X2NvbmZpZ19j YjoJCVNldCB0aGUgY29uZmlnIGludGVycnVwdCBjYWxsYmFjaworICoJCQkJQG1kZXY6IG1lZGlh dGVkIGRldmljZQorICoJCQkJQGNiOiB2aXJ0aW8tbWRldiBpbnRlcnJ1cHQgY2FsbGJhY2sgc3Ry dWN0dXJlCisgKiBAZ2V0X3ZxX251bV9tYXg6CQlHZXQgdGhlIG1heCBzaXplIG9mIHZpcnRxdWV1 ZQorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJUmV0dXJucyB1MTY6IG1heCBz aXplIG9mIHZpcnRxdWV1ZQorICogQGdldF9kZXZpY2VfaWQ6CQlHZXQgdmlydGlvIGRldmljZSBp ZAorICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQorICoJCQkJUmV0dXJucyB1MzI6IHZpcnRp byBkZXZpY2UgaWQKKyAqIEBnZXRfdmVuZG9yX2lkOgkJR2V0IGlkIGZvciB0aGUgdmVuZG9yIHRo YXQgcHJvdmlkZXMgdGhpcyBkZXZpY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAq CQkJCVJldHVybnMgdTMyOiB2aXJ0aW8gdmVuZG9yIGlkCisgKiBAZ2V0X3N0YXR1czoJCQlHZXQg dGhlIGRldmljZSBzdGF0dXMKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCVJl dHVybnMgdTg6IHZpcnRpbyBkZXZpY2Ugc3RhdHVzCisgKiBAc2V0X3N0YXR1czoJCQlTZXQgdGhl IGRldmljZSBzdGF0dXMKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKKyAqCQkJCUBzdGF0 dXM6IHZpcnRpbyBkZXZpY2Ugc3RhdHVzCisgKiBAZ2V0X2NvbmZpZzoJCQlSZWFkIGZyb20gZGV2 aWNlIHNwZWNpZmljIGNvbmZpZ3VyYXRpb24gc3BhY2UKKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBk ZXZpY2UKKyAqCQkJCUBvZmZzZXQ6IG9mZnNldCBmcm9tIHRoZSBiZWdpbm5pbmcgb2YKKyAqCQkJ CWNvbmZpZ3VyYXRpb24gc3BhY2UKKyAqCQkJCUBidWY6IGJ1ZmZlciB1c2VkIHRvIHJlYWQgdG8K KyAqCQkJCUBsZW46IHRoZSBsZW5ndGggdG8gcmVhZCBmcm9tCisgKgkJCQljb25maWdyYXRpb24g c3BhY2UKKyAqIEBzZXRfY29uZmlnOgkJCVdyaXRlIHRvIGRldmljZSBzcGVjaWZpYyBjb25maWd1 cmF0aW9uIHNwYWNlCisgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlAb2Zmc2V0 OiBvZmZzZXQgZnJvbSB0aGUgYmVnaW5uaW5nIG9mCisgKgkJCQljb25maWd1cmF0aW9uIHNwYWNl CisgKgkJCQlAYnVmOiBidWZmZXIgdXNlZCB0byB3cml0ZSBmcm9tCisgKgkJCQlAbGVuOiB0aGUg bGVuZ3RoIHRvIHdyaXRlIHRvCisgKgkJCQljb25maWdyYXRpb24gc3BhY2UKKyAqIEBnZXRfZ2Vu ZXJhdGlvbjoJCUdldCBkZXZpY2UgY29uZmlnIGdlbmVyYXRvbiAob3B0aW9uYWwpCisgKgkJCQlA bWRldjogbWVkaWF0ZWQgZGV2aWNlCisgKgkJCQlSZXR1cm5zIHUzMjogZGV2aWNlIGdlbmVyYXRp b24KKyAqLworc3RydWN0IG1kZXZfdmlydGlvX29wcyB7CisJLyogVmlydHF1ZXVlIG9wcyAqLwor CWludCAoKnNldF92cV9hZGRyZXNzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgICAg ICB1MTYgaWR4LCB1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEsCisJCQkgICAgICB1NjQg ZGV2aWNlX2FyZWEpOworCXZvaWQgKCpzZXRfdnFfbnVtKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYsIHUxNiBpZHgsIHUzMiBudW0pOworCXZvaWQgKCpraWNrX3ZxKShzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYsIHUxNiBpZHgpOworCXZvaWQgKCpzZXRfdnFfY2IpKHN0cnVjdCBtZGV2X2Rldmlj ZSAqbWRldiwgdTE2IGlkeCwKKwkJCSAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpjYik7 CisJdm9pZCAoKnNldF92cV9yZWFkeSkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4 LCBib29sIHJlYWR5KTsKKwlib29sICgqZ2V0X3ZxX3JlYWR5KShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYsIHUxNiBpZHgpOworCWludCAoKnNldF92cV9zdGF0ZSkoc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2LCB1MTYgaWR4LCB1NjQgc3RhdGUpOworCXU2NCAoKmdldF92cV9zdGF0ZSkoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KTsKKworCS8qIERldmljZSBvcHMgKi8KKwl1MTYg KCpnZXRfdnFfYWxpZ24pKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7CisJdTY0ICgqZ2V0X2Zl YXR1cmVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOworCWludCAoKnNldF9mZWF0dXJlcyko c3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1NjQgZmVhdHVyZXMpOworCXZvaWQgKCpzZXRfY29u ZmlnX2NiKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkgICAgICBzdHJ1Y3QgdmlydGlv X21kZXZfY2FsbGJhY2sgKmNiKTsKKwl1MTYgKCpnZXRfdnFfbnVtX21heCkoc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2KTsKKwl1MzIgKCpnZXRfZGV2aWNlX2lkKShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYpOworCXUzMiAoKmdldF92ZW5kb3JfaWQpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7 CisJdTggKCpnZXRfc3RhdHVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOworCXZvaWQgKCpz ZXRfc3RhdHVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cyk7CisJdm9pZCAo KmdldF9jb25maWcpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNl dCwKKwkJCSAgIHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbik7CisJdm9pZCAoKnNldF9jb25m aWcpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAg IGNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbik7CisJdTMyICgqZ2V0X2dlbmVyYXRp b24pKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldik7Cit9OworCitpbnQgbWRldl92aXJ0aW9fcmVn aXN0ZXJfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQljb25zdCBzdHJ1Y3QgbWRldl9w YXJlbnRfb3BzICpvcHMpOwordm9pZCBtZGV2X3ZpcnRpb191bnJlZ2lzdGVyX2RldmljZShzdHJ1 Y3QgZGV2aWNlICpkZXYpOwordm9pZCBtZGV2X3ZpcnRpb19zZXRfb3BzKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwKKwkJCSBjb25zdCBzdHJ1Y3QgbWRldl92aXJ0aW9fb3BzICpvcHMpOworY29u c3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyAqbWRldl92aXJ0aW9fZ2V0X29wcyhzdHJ1Y3QgbWRl dl9kZXZpY2UgKm1kZXYpOwordm9pZCBtZGV2X3ZpcnRpb19zZXRfY2xhc3NfaWQoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2LCB1MTYgY2xhc3NfaWQpOworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldl92aXJ0aW9fZnJvbV9kZXYoc3RydWN0IGRldmljZSAqZGV2KQorewor CXJldHVybiBtZGV2X2Zyb21fZGV2KGRldiwgJm1kZXZfdmlydGlvX2J1c190eXBlKTsKK30KKwor I2VuZGlmCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oIGIvaW5j bHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaAppbmRleCA1NzE0ZmQzNWE4M2MuLjU5MDA2YzQ3 YWU4ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaAorKysgYi9p bmNsdWRlL2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oCkBAIC04MjEsNCArODIxLDEyIEBAIHN0cnVj dCB3bWlfZGV2aWNlX2lkIHsKIAljb25zdCB2b2lkICpjb250ZXh0OwogfTsKIAorLyoqCisgKiBz dHJ1Y3QgbWRldl9jbGFzc19pZCAtIE1ERVYgVklSVElPIGRldmljZSBjbGFzcyBpZGVudGlmaWVy CisgKiBAaWQ6IFVzZWQgdG8gaWRlbnRpZnkgYSBzcGVjaWZpYyBjbGFzcyBvZiBkZXZpY2UsIGUu ZyB2ZmlvLW1kZXYgZGV2aWNlLgorICovCitzdHJ1Y3QgbWRldl92aXJ0aW9fY2xhc3NfaWQgewor CV9fdTE2IGlkOworfTsKKwogI2VuZGlmIC8qIExJTlVYX01PRF9ERVZJQ0VUQUJMRV9IICovCmRp ZmYgLS1naXQgYS9zY3JpcHRzL21vZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMgYi9zY3JpcHRzL21v ZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMKaW5kZXggMDU0NDA1YjkwYmE0Li4xNzhmZDdjNzA4MTIg MTAwNjQ0Ci0tLSBhL3NjcmlwdHMvbW9kL2RldmljZXRhYmxlLW9mZnNldHMuYworKysgYi9zY3Jp cHRzL21vZC9kZXZpY2V0YWJsZS1vZmZzZXRzLmMKQEAgLTIzMSw1ICsyMzEsOCBAQCBpbnQgbWFp bih2b2lkKQogCURFVklEKHdtaV9kZXZpY2VfaWQpOwogCURFVklEX0ZJRUxEKHdtaV9kZXZpY2Vf aWQsIGd1aWRfc3RyaW5nKTsKIAorCURFVklEKG1kZXZfdmlydGlvX2NsYXNzX2lkKTsKKwlERVZJ RF9GSUVMRChtZGV2X3ZpcnRpb19jbGFzc19pZCwgaWQpOworCiAJcmV0dXJuIDA7CiB9CmRpZmYg LS1naXQgYS9zY3JpcHRzL21vZC9maWxlMmFsaWFzLmMgYi9zY3JpcHRzL21vZC9maWxlMmFsaWFz LmMKaW5kZXggYzkxZWJhNzUxODA0Li4xYTljMWY1OTE5NTEgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMv bW9kL2ZpbGUyYWxpYXMuYworKysgYi9zY3JpcHRzL21vZC9maWxlMmFsaWFzLmMKQEAgLTEzMzUs NiArMTMzNSwxNyBAQCBzdGF0aWMgaW50IGRvX3dtaV9lbnRyeShjb25zdCBjaGFyICpmaWxlbmFt ZSwgdm9pZCAqc3ltdmFsLCBjaGFyICphbGlhcykKIAlyZXR1cm4gMTsKIH0KIAorLyogbG9va3Mg bGlrZTogIm1kZXZfdmlydGlvOmNOIiAqLworc3RhdGljIGludCBkb19tZGV2X3ZpcnRpb19lbnRy eShjb25zdCBjaGFyICpmaWxlbmFtZSwgdm9pZCAqc3ltdmFsLCBjaGFyICphbGlhcykKK3sKKwlE RUZfRklFTEQoc3ltdmFsLCBtZGV2X3ZpcnRpb19jbGFzc19pZCwgaWQpOworCisJc3ByaW50Zihh bGlhcywgIm1kZXZfdmlydGlvOmMlMDJYIiwgaWQpOworCWFkZF93aWxkY2FyZChhbGlhcyk7CisJ cmV0dXJuIDE7Cit9CisKKwogLyogRG9lcyBuYW1lbGVuIGJ5dGVzIG9mIG5hbWUgZXhhY3RseSBt YXRjaCB0aGUgc3ltYm9sPyAqLwogc3RhdGljIGJvb2wgc3ltX2lzKGNvbnN0IGNoYXIgKm5hbWUs IHVuc2lnbmVkIG5hbWVsZW4sIGNvbnN0IGNoYXIgKnN5bWJvbCkKIHsKQEAgLTE0MDcsNiArMTQx OCw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2dGFibGUgZGV2dGFibGVbXSA9IHsKIAl7InR5 cGVjIiwgU0laRV90eXBlY19kZXZpY2VfaWQsIGRvX3R5cGVjX2VudHJ5fSwKIAl7InRlZSIsIFNJ WkVfdGVlX2NsaWVudF9kZXZpY2VfaWQsIGRvX3RlZV9lbnRyeX0sCiAJeyJ3bWkiLCBTSVpFX3dt aV9kZXZpY2VfaWQsIGRvX3dtaV9lbnRyeX0sCisJeyJtZGV2X3ZpcnRpbyIsIFNJWkVfbWRldl92 aXJ0aW9fY2xhc3NfaWQsIGRvX21kZXZfdmlydGlvX2VudHJ5fSwKIH07CiAKIC8qIENyZWF0ZSBN T0RVTEVfQUxJQVMoKSBzdGF0ZW1lbnRzLgotLSAKMi4xOS4xCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZng=