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 66462FA374C for ; Tue, 5 Nov 2019 09:42:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 29419217F5 for ; Tue, 5 Nov 2019 09:42:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="CNMgl8xu" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730867AbfKEJmj (ORCPT ); Tue, 5 Nov 2019 04:42:39 -0500 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:24156 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1730598AbfKEJmi (ORCPT ); Tue, 5 Nov 2019 04:42:38 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1572946955; 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=syXqnRjGmjED8oe1bGzFfKezKmp2rR8du99TBlzamLo=; b=CNMgl8xu/5pD71WLCbBNd9U79ZU57t3pNhS11be9ACo4Z1keRjUwURbiRQRcuQiqaASfKl 3DHvurRrN5rkyxNV1S7U3pJGcAYoQDTLD0qccM4z3SXU+D0I5Fz7CSJjfu0prgdmdxfGlK PO0Bcx0mc0461sQIiihIPBAGWLfEbZk= 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-367-QKyKdWrBOfGSQkBZ_IXJ0A-1; Tue, 05 Nov 2019 04:42:32 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CD414477; Tue, 5 Nov 2019 09:42:26 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-252.pek2.redhat.com [10.72.12.252]) by smtp.corp.redhat.com (Postfix) with ESMTP id 426A25C28D; Tue, 5 Nov 2019 09:39:35 +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, stefanha@redhat.com, Jason Wang Subject: [PATCH V8 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Tue, 5 Nov 2019 17:32:40 +0800 Message-Id: <20191105093240.5135-7-jasowang@redhat.com> In-Reply-To: <20191105093240.5135-1-jasowang@redhat.com> References: <20191105093240.5135-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-MC-Unique: QKyKdWrBOfGSQkBZ_IXJ0A-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 sample driver creates mdev device that simulate virtio net device over virtio mdev transport. The device is implemented through vringh and workqueue. A device specific dma ops is to make sure HVA is used directly as the IOVA. This should be sufficient for kernel virtio driver to work. Only 'virtio' type is supported right now. I plan to add 'vhost' type on top which requires some virtual IOMMU implemented in this sample driver. Signed-off-by: Jason Wang --- MAINTAINERS | 1 + samples/Kconfig | 7 + samples/vfio-mdev/Makefile | 1 + samples/vfio-mdev/mvnet.c | 685 +++++++++++++++++++++++++++++++++++++ 4 files changed, 694 insertions(+) create mode 100644 samples/vfio-mdev/mvnet.c diff --git a/MAINTAINERS b/MAINTAINERS index f661d13344d6..35e9204d5c68 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17248,6 +17248,7 @@ F:=09include/linux/virtio*.h F:=09include/uapi/linux/virtio_*.h F:=09drivers/crypto/virtio/ F:=09mm/balloon_compaction.c +F:=09samples/vfio-mdev/mvnet.c =20 VIRTIO BLOCK AND SCSI DRIVERS M:=09"Michael S. Tsirkin" diff --git a/samples/Kconfig b/samples/Kconfig index c8dacb4dda80..a1a1ca2c00b7 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -131,6 +131,13 @@ config SAMPLE_VFIO_MDEV_MDPY =09 mediated device. It is a simple framebuffer and supports =09 the region display interface (VFIO_GFX_PLANE_TYPE_REGION). =20 +config SAMPLE_VIRTIO_MDEV_NET + tristate "Build virtio mdev net example mediated device sample cod= e -- loadable modules only" +=09depends on VIRTIO_MDEV_DEVICE && VHOST_RING && m +=09help +=09 Build a networking sample device for use as a virtio +=09 mediated device. + config SAMPLE_VFIO_MDEV_MDPY_FB =09tristate "Build VFIO mdpy example guest fbdev driver -- loadable module= only" =09depends on FB && m diff --git a/samples/vfio-mdev/Makefile b/samples/vfio-mdev/Makefile index 10d179c4fdeb..f34af90ed0a0 100644 --- a/samples/vfio-mdev/Makefile +++ b/samples/vfio-mdev/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_SAMPLE_VFIO_MDEV_MTTY) +=3D mtty.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY) +=3D mdpy.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY_FB) +=3D mdpy-fb.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MBOCHS) +=3D mbochs.o +obj-$(CONFIG_SAMPLE_VIRTIO_MDEV_NET) +=3D mvnet.o diff --git a/samples/vfio-mdev/mvnet.c b/samples/vfio-mdev/mvnet.c new file mode 100644 index 000000000000..8b43fcc78a68 --- /dev/null +++ b/samples/vfio-mdev/mvnet.c @@ -0,0 +1,685 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Mediated virtual virtio-net device driver. + * + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * Author: Jason Wang + * + * Sample driver that creates mdev device that simulates ethernet loopback + * device. + * + * Usage: + * + * # modprobe virtio_mdev + * # modprobe mvnet + * # cd /sys/devices/virtual/mvnet/mvnet/mdev_supported_types/mvnet-virtio + * # echo "83b8f4f2-509f-382f-3c1e-e6bfe0fa1001" > ./create + * # cd devices/83b8f4f2-509f-382f-3c1e-e6bfe0fa1001 + * # ls -d virtio0 + * virtio0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define VERSION_STRING "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" + +#define MVNET_CLASS_NAME "mvnet" +#define MVNET_NAME "mvnet" + +/* + * Global Structures + */ + +static struct mvnet_dev { +=09struct class=09*vd_class; +=09struct idr=09vd_idr; +=09struct device=09dev; +} mvnet_dev; + +struct mvnet_virtqueue { +=09struct vringh vring; +=09struct vringh_kiov iov; +=09unsigned short head; +=09bool ready; +=09u64 desc_addr; +=09u64 device_addr; +=09u64 driver_addr; +=09u32 num; +=09void *private; +=09irqreturn_t (*cb)(void *data); +}; + +#define MVNET_QUEUE_ALIGN PAGE_SIZE +#define MVNET_QUEUE_MAX 256 +#define MVNET_DEVICE_ID 0x1 +#define MVNET_VENDOR_ID 0 + +u64 mvnet_features =3D (1ULL << VIRTIO_F_ANY_LAYOUT) | +=09=09 (1ULL << VIRTIO_F_VERSION_1) | +=09=09 (1ULL << VIRTIO_F_IOMMU_PLATFORM); + +/* State of each mdev device */ +struct mvnet_state { +=09struct mvnet_virtqueue vqs[2]; +=09struct work_struct work; +=09spinlock_t lock; +=09struct mdev_device *mdev; +=09struct virtio_net_config config; +=09void *buffer; +=09u32 status; +=09u32 generation; +=09u64 features; +=09struct list_head next; +}; + +static struct mutex mdev_list_lock; +static struct list_head mdev_devices_list; + +static void mvnet_queue_ready(struct mvnet_state *mvnet, unsigned int idx) +{ +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; +=09int ret; + +=09ret =3D vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, +=09=09=09 false, (struct vring_desc *)vq->desc_addr, +=09=09=09 (struct vring_avail *)vq->driver_addr, +=09=09=09 (struct vring_used *)vq->device_addr); +} + +static void mvnet_vq_reset(struct mvnet_virtqueue *vq) +{ +=09vq->ready =3D 0; +=09vq->desc_addr =3D 0; +=09vq->driver_addr =3D 0; +=09vq->device_addr =3D 0; +=09vq->cb =3D NULL; +=09vq->private =3D NULL; +=09vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, +=09=09=09false, 0, 0, 0); +} + +static void mvnet_reset(struct mvnet_state *mvnet) +{ +=09int i; + +=09for (i =3D 0; i < 2; i++) +=09=09mvnet_vq_reset(&mvnet->vqs[i]); + +=09mvnet->features =3D 0; +=09mvnet->status =3D 0; +=09++mvnet->generation; +} + +static void mvnet_work(struct work_struct *work) +{ +=09struct mvnet_state *mvnet =3D container_of(work, struct +=09=09=09=09=09=09 mvnet_state, work); +=09struct mvnet_virtqueue *txq =3D &mvnet->vqs[1]; +=09struct mvnet_virtqueue *rxq =3D &mvnet->vqs[0]; +=09size_t read, write, total_write; +=09int err; +=09int pkts =3D 0; + +=09spin_lock(&mvnet->lock); + +=09if (!txq->ready || !rxq->ready) +=09=09goto out; + +=09while (true) { +=09=09total_write =3D 0; +=09=09err =3D vringh_getdesc_kern(&txq->vring, &txq->iov, NULL, +=09=09=09=09=09 &txq->head, GFP_ATOMIC); +=09=09if (err <=3D 0) +=09=09=09break; + +=09=09err =3D vringh_getdesc_kern(&rxq->vring, NULL, &rxq->iov, +=09=09=09=09=09 &rxq->head, GFP_ATOMIC); +=09=09if (err <=3D 0) { +=09=09=09vringh_complete_kern(&txq->vring, txq->head, 0); +=09=09=09break; +=09=09} + +=09=09while (true) { +=09=09=09read =3D vringh_iov_pull_kern(&txq->iov, mvnet->buffer, +=09=09=09=09=09=09 PAGE_SIZE); +=09=09=09if (read <=3D 0) +=09=09=09=09break; + +=09=09=09write =3D vringh_iov_push_kern(&rxq->iov, mvnet->buffer, +=09=09=09=09=09=09 read); +=09=09=09if (write <=3D 0) +=09=09=09=09break; + +=09=09=09total_write +=3D write; +=09=09} + +=09=09/* Make sure data is wrote before advancing index */ +=09=09smp_wmb(); + +=09=09vringh_complete_kern(&txq->vring, txq->head, 0); +=09=09vringh_complete_kern(&rxq->vring, rxq->head, total_write); + +=09=09/* Make sure used is visible before rasing the interrupt. */ +=09=09smp_wmb(); + +=09=09local_bh_disable(); +=09=09if (txq->cb) +=09=09=09txq->cb(txq->private); +=09=09if (rxq->cb) +=09=09=09rxq->cb(rxq->private); +=09=09local_bh_enable(); + +=09=09if (++pkts > 4) { +=09=09=09schedule_work(&mvnet->work); +=09=09=09goto out; +=09=09} +=09} + +out: +=09spin_unlock(&mvnet->lock); +} + +static dma_addr_t mvnet_map_page(struct device *dev, struct page *page, +=09=09=09=09 unsigned long offset, size_t size, +=09=09=09=09 enum dma_data_direction dir, +=09=09=09=09 unsigned long attrs) +{ +=09/* Vringh can only use HVA */ +=09return (dma_addr_t)(page_address(page) + offset); +} + +static void mvnet_unmap_page(struct device *dev, dma_addr_t dma_addr, +=09=09=09 size_t size, enum dma_data_direction dir, +=09=09=09 unsigned long attrs) +{ +} + +static void *mvnet_alloc_coherent(struct device *dev, size_t size, +=09=09=09=09 dma_addr_t *dma_addr, gfp_t flag, +=09=09=09=09 unsigned long attrs) +{ +=09void *addr =3D kmalloc(size, flag); + +=09if (addr =3D=3D NULL) +=09=09*dma_addr =3D DMA_MAPPING_ERROR; +=09else +=09=09*dma_addr =3D (dma_addr_t) addr; + +=09return addr; +} + +static void mvnet_free_coherent(struct device *dev, size_t size, +=09=09=09=09void *vaddr, dma_addr_t dma_addr, +=09=09=09=09unsigned long attrs) +{ +=09kfree((void *)dma_addr); +} + +static const struct dma_map_ops mvnet_dma_ops =3D { +=09.map_page =3D mvnet_map_page, +=09.unmap_page =3D mvnet_unmap_page, +=09.alloc =3D mvnet_alloc_coherent, +=09.free =3D mvnet_free_coherent, +}; + +static const struct mdev_virtio_device_ops mdev_virtio_ops; + +static int mvnet_create(struct kobject *kobj, struct mdev_device *mdev) +{ +=09struct mvnet_state *mvnet; +=09struct virtio_net_config *config; +=09struct device *dev =3D mdev_dev(mdev); + +=09if (!mdev) +=09=09return -EINVAL; + +=09mvnet =3D kzalloc(sizeof(struct mvnet_state), GFP_KERNEL); +=09if (mvnet =3D=3D NULL) +=09=09return -ENOMEM; + +=09mvnet->buffer =3D kmalloc(PAGE_SIZE, GFP_KERNEL); +=09if (!mvnet->buffer) { +=09=09kfree(mvnet); +=09=09return -ENOMEM; +=09} + +=09config =3D &mvnet->config; +=09config->mtu =3D 1500; +=09config->status =3D VIRTIO_NET_S_LINK_UP; +=09eth_random_addr(config->mac); + +=09INIT_WORK(&mvnet->work, mvnet_work); + +=09spin_lock_init(&mvnet->lock); +=09mvnet->mdev =3D mdev; +=09mdev_set_drvdata(mdev, mvnet); + +=09mutex_lock(&mdev_list_lock); +=09list_add(&mvnet->next, &mdev_devices_list); +=09mutex_unlock(&mdev_list_lock); + +=09dev->coherent_dma_mask =3D DMA_BIT_MASK(64); +=09set_dma_ops(dev, &mvnet_dma_ops); + +=09mdev_set_virtio_ops(mdev, &mdev_virtio_ops); + +=09return 0; +} + +static int mvnet_remove(struct mdev_device *mdev) +{ +=09struct mvnet_state *mds, *tmp_mds; +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09int ret =3D -EINVAL; + +=09mutex_lock(&mdev_list_lock); +=09list_for_each_entry_safe(mds, tmp_mds, &mdev_devices_list, next) { +=09=09if (mvnet =3D=3D mds) { +=09=09=09list_del(&mvnet->next); +=09=09=09mdev_set_drvdata(mdev, NULL); +=09=09=09kfree(mvnet->buffer); +=09=09=09kfree(mvnet); +=09=09=09ret =3D 0; +=09=09=09break; +=09=09} +=09} +=09mutex_unlock(&mdev_list_lock); + +=09return ret; +} + +static ssize_t +sample_mvnet_dev_show(struct device *dev, struct device_attribute *attr, +=09=09 char *buf) +{ +=09if (mdev_from_dev(dev)) +=09=09return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + +=09return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mvnet_dev); + +static struct attribute *mvnet_dev_attrs[] =3D { +=09&dev_attr_sample_mvnet_dev.attr, +=09NULL, +}; + +static const struct attribute_group mvnet_dev_group =3D { +=09.name =3D "mvnet_dev", +=09.attrs =3D mvnet_dev_attrs, +}; + +static const struct attribute_group *mvnet_dev_groups[] =3D { +=09&mvnet_dev_group, +=09NULL, +}; + +static ssize_t +sample_mdev_dev_show(struct device *dev, struct device_attribute *attr, +=09=09 char *buf) +{ +=09if (mdev_from_dev(dev)) +=09=09return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + +=09return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mdev_dev); + +static struct attribute *mdev_dev_attrs[] =3D { +=09&dev_attr_sample_mdev_dev.attr, +=09NULL, +}; + +static const struct attribute_group mdev_dev_group =3D { +=09.name =3D "vendor", +=09.attrs =3D mdev_dev_attrs, +}; + +static const struct attribute_group *mdev_dev_groups[] =3D { +=09&mdev_dev_group, +=09NULL, +}; + +#define MVNET_STRING_LEN 16 + +static ssize_t +name_show(struct kobject *kobj, struct device *dev, char *buf) +{ +=09char name[MVNET_STRING_LEN]; +=09const char *name_str =3D "virtio-net"; + +=09snprintf(name, MVNET_STRING_LEN, "%s", dev_driver_string(dev)); +=09if (!strcmp(kobj->name, name)) +=09=09return sprintf(buf, "%s\n", name_str); + +=09return -EINVAL; +} + +static MDEV_TYPE_ATTR_RO(name); + +static ssize_t +available_instances_show(struct kobject *kobj, struct device *dev, char *b= uf) +{ +=09return sprintf(buf, "%d\n", INT_MAX); +} + +static MDEV_TYPE_ATTR_RO(available_instances); + +static ssize_t device_api_show(struct kobject *kobj, struct device *dev, +=09=09=09 char *buf) +{ +=09return sprintf(buf, "%s\n", VIRTIO_MDEV_DEVICE_API_STRING); +} + +static MDEV_TYPE_ATTR_RO(device_api); + +static struct attribute *mdev_types_attrs[] =3D { +=09&mdev_type_attr_name.attr, +=09&mdev_type_attr_device_api.attr, +=09&mdev_type_attr_available_instances.attr, +=09NULL, +}; + +static struct attribute_group mdev_type_group =3D { +=09.name =3D "virtio", +=09.attrs =3D mdev_types_attrs, +}; + +/* TBD: "vhost" type */ + +static struct attribute_group *mdev_type_groups[] =3D { +=09&mdev_type_group, +=09NULL, +}; + +static int mvnet_set_vq_address(struct mdev_device *mdev, u16 idx, +=09=09=09=09u64 desc_area, u64 driver_area, u64 device_area) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09vq->desc_addr =3D desc_area; +=09vq->driver_addr =3D driver_area; +=09vq->device_addr =3D device_area; + +=09return 0; +} + +static void mvnet_set_vq_num(struct mdev_device *mdev, u16 idx, u32 num) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09vq->num =3D num; +} + +static void mvnet_kick_vq(struct mdev_device *mdev, u16 idx) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09if (vq->ready) +=09=09schedule_work(&mvnet->work); +} + +static void mvnet_set_vq_cb(struct mdev_device *mdev, u16 idx, +=09=09=09 struct virtio_mdev_callback *cb) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09vq->cb =3D cb->callback; +=09vq->private =3D cb->private; +} + +static void mvnet_set_vq_ready(struct mdev_device *mdev, u16 idx, bool rea= dy) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09spin_lock(&mvnet->lock); +=09vq->ready =3D ready; +=09if (vq->ready) +=09=09mvnet_queue_ready(mvnet, idx); +=09spin_unlock(&mvnet->lock); +} + +static bool mvnet_get_vq_ready(struct mdev_device *mdev, u16 idx) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; + +=09return vq->ready; +} + +static int mvnet_set_vq_state(struct mdev_device *mdev, u16 idx, u64 state= ) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; +=09struct vringh *vrh =3D &vq->vring; + +=09spin_lock(&mvnet->lock); +=09vrh->last_avail_idx =3D state; +=09spin_unlock(&mvnet->lock); + +=09return 0; +} + +static u64 mvnet_get_vq_state(struct mdev_device *mdev, u16 idx) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); +=09struct mvnet_virtqueue *vq =3D &mvnet->vqs[idx]; +=09struct vringh *vrh =3D &vq->vring; + +=09return vrh->last_avail_idx; +} + +static u16 mvnet_get_vq_align(struct mdev_device *mdev) +{ +=09return MVNET_QUEUE_ALIGN; +} + +static u64 mvnet_get_features(struct mdev_device *mdev) +{ +=09return mvnet_features; +} + +static int mvnet_set_features(struct mdev_device *mdev, u64 features) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); + +=09/* DMA mapping must be done by driver */ +=09if (!(features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))) +=09=09return -EINVAL; + +=09mvnet->features =3D features & mvnet_features; + +=09return 0; +} + +static void mvnet_set_config_cb(struct mdev_device *mdev, +=09=09=09=09struct virtio_mdev_callback *cb) +{ +=09/* We don't support config interrupt */ +} + +static u16 mvnet_get_vq_num_max(struct mdev_device *mdev) +{ +=09return MVNET_QUEUE_MAX; +} + +static u32 mvnet_get_device_id(struct mdev_device *mdev) +{ +=09return MVNET_DEVICE_ID; +} + +static u32 mvnet_get_vendor_id(struct mdev_device *mdev) +{ +=09return MVNET_VENDOR_ID; +} + +static u8 mvnet_get_status(struct mdev_device *mdev) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); + +=09return mvnet->status; +} + +static void mvnet_set_status(struct mdev_device *mdev, u8 status) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); + +=09mvnet->status =3D status; + +=09if (status =3D=3D 0) { +=09=09spin_lock(&mvnet->lock); +=09=09mvnet_reset(mvnet); +=09=09spin_unlock(&mvnet->lock); +=09} +} + +static void mvnet_get_config(struct mdev_device *mdev, unsigned int offset= , +=09=09=09 void *buf, unsigned int len) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); + +=09if (offset + len < sizeof(struct virtio_net_config)) +=09=09memcpy(buf, &mvnet->config + offset, len); +} + +static void mvnet_set_config(struct mdev_device *mdev, unsigned int offset= , +=09=09=09 const void *buf, unsigned int len) +{ +=09/* No writable config supportted by mvnet */ +} + +static u32 mvnet_get_generation(struct mdev_device *mdev) +{ +=09struct mvnet_state *mvnet =3D mdev_get_drvdata(mdev); + +=09return mvnet->generation; +} + +static const struct mdev_virtio_device_ops mdev_virtio_ops =3D { +=09.set_vq_address =3D mvnet_set_vq_address, +=09.set_vq_num =3D mvnet_set_vq_num, +=09.kick_vq =3D mvnet_kick_vq, +=09.set_vq_cb =3D mvnet_set_vq_cb, +=09.set_vq_ready =3D mvnet_set_vq_ready, +=09.get_vq_ready =3D mvnet_get_vq_ready, +=09.set_vq_state =3D mvnet_set_vq_state, +=09.get_vq_state =3D mvnet_get_vq_state, +=09.get_vq_align =3D mvnet_get_vq_align, +=09.get_features =3D mvnet_get_features, +=09.set_features =3D mvnet_set_features, +=09.set_config_cb =3D mvnet_set_config_cb, +=09.get_vq_num_max =3D mvnet_get_vq_num_max, +=09.get_device_id =3D mvnet_get_device_id, +=09.get_vendor_id =3D mvnet_get_vendor_id, +=09.get_status =3D mvnet_get_status, +=09.set_status =3D mvnet_set_status, +=09.get_config =3D mvnet_get_config, +=09.set_config =3D mvnet_set_config, +=09.get_generation =3D mvnet_get_generation, +}; + +static const struct mdev_parent_ops mdev_fops =3D { +=09.owner =3D THIS_MODULE, +=09.dev_attr_groups =3D mvnet_dev_groups, +=09.mdev_attr_groups =3D mdev_dev_groups, +=09.supported_type_groups =3D mdev_type_groups, +=09.create =3D mvnet_create, +=09.remove=09=09=09=3D mvnet_remove, +}; + +static void mvnet_device_release(struct device *dev) +{ +=09dev_dbg(dev, "mvnet: released\n"); +} + +static int __init mvnet_dev_init(void) +{ +=09int ret =3D 0; + +=09pr_info("mvnet_dev: %s\n", __func__); + +=09memset(&mvnet_dev, 0, sizeof(mvnet_dev)); + +=09idr_init(&mvnet_dev.vd_idr); + +=09mvnet_dev.vd_class =3D class_create(THIS_MODULE, MVNET_CLASS_NAME); + +=09if (IS_ERR(mvnet_dev.vd_class)) { +=09=09pr_err("Error: failed to register mvnet_dev class\n"); +=09=09ret =3D PTR_ERR(mvnet_dev.vd_class); +=09=09goto failed1; +=09} + +=09mvnet_dev.dev.class =3D mvnet_dev.vd_class; +=09mvnet_dev.dev.release =3D mvnet_device_release; +=09dev_set_name(&mvnet_dev.dev, "%s", MVNET_NAME); + +=09ret =3D device_register(&mvnet_dev.dev); +=09if (ret) +=09=09goto failed2; + +=09ret =3D mdev_register_device(&mvnet_dev.dev, &mdev_fops); +=09if (ret) +=09=09goto failed3; + +=09mutex_init(&mdev_list_lock); +=09INIT_LIST_HEAD(&mdev_devices_list); + +=09goto all_done; + +failed3: + +=09device_unregister(&mvnet_dev.dev); +failed2: +=09class_destroy(mvnet_dev.vd_class); + +failed1: +all_done: +=09return ret; +} + +static void __exit mvnet_dev_exit(void) +{ +=09mvnet_dev.dev.bus =3D NULL; +=09mdev_unregister_device(&mvnet_dev.dev); + +=09device_unregister(&mvnet_dev.dev); +=09idr_destroy(&mvnet_dev.vd_idr); +=09class_destroy(mvnet_dev.vd_class); +=09mvnet_dev.vd_class =3D NULL; +=09pr_info("mvnet_dev: Unloaded!\n"); +} + +module_init(mvnet_dev_init) +module_exit(mvnet_dev_exit) + +MODULE_LICENSE("GPL v2"); +MODULE_INFO(supported, "Simulate loopback ethernet device over mdev"); +MODULE_VERSION(VERSION_STRING); +MODULE_AUTHOR(DRIVER_AUTHOR); --=20 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V8 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Tue, 5 Nov 2019 17:32:40 +0800 Message-ID: <20191105093240.5135-7-jasowang@redhat.com> References: <20191105093240.5135-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <20191105093240.5135-1-jasowang@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: virtualization-bounces@lists.linux-foundation.org Errors-To: virtualization-bounces@lists.linux-foundation.org To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, joonas.lahtinen@linux.intel.com, heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, zhi.a.wang@intel.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, zhenyuw@linux.intel.com, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, jani.nikula@linux.intel.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, daniel@ffwll.ch, lingshan.zhu@intel.com List-Id: virtualization@lists.linuxfoundation.org This sample driver creates mdev device that simulate virtio net device over virtio mdev transport. The device is implemented through vringh and workqueue. A device specific dma ops is to make sure HVA is used directly as the IOVA. This should be sufficient for kernel virtio driver to work. Only 'virtio' type is supported right now. I plan to add 'vhost' type on top which requires some virtual IOMMU implemented in this sample driver. Signed-off-by: Jason Wang --- MAINTAINERS | 1 + samples/Kconfig | 7 + samples/vfio-mdev/Makefile | 1 + samples/vfio-mdev/mvnet.c | 685 +++++++++++++++++++++++++++++++++++++ 4 files changed, 694 insertions(+) create mode 100644 samples/vfio-mdev/mvnet.c diff --git a/MAINTAINERS b/MAINTAINERS index f661d13344d6..35e9204d5c68 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17248,6 +17248,7 @@ F: include/linux/virtio*.h F: include/uapi/linux/virtio_*.h F: drivers/crypto/virtio/ F: mm/balloon_compaction.c +F: samples/vfio-mdev/mvnet.c VIRTIO BLOCK AND SCSI DRIVERS M: "Michael S. Tsirkin" diff --git a/samples/Kconfig b/samples/Kconfig index c8dacb4dda80..a1a1ca2c00b7 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -131,6 +131,13 @@ config SAMPLE_VFIO_MDEV_MDPY mediated device. It is a simple framebuffer and supports the region display interface (VFIO_GFX_PLANE_TYPE_REGION). +config SAMPLE_VIRTIO_MDEV_NET + tristate "Build virtio mdev net example mediated device sample code -- loadable modules only" + depends on VIRTIO_MDEV_DEVICE && VHOST_RING && m + help + Build a networking sample device for use as a virtio + mediated device. + config SAMPLE_VFIO_MDEV_MDPY_FB tristate "Build VFIO mdpy example guest fbdev driver -- loadable module only" depends on FB && m diff --git a/samples/vfio-mdev/Makefile b/samples/vfio-mdev/Makefile index 10d179c4fdeb..f34af90ed0a0 100644 --- a/samples/vfio-mdev/Makefile +++ b/samples/vfio-mdev/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_SAMPLE_VFIO_MDEV_MTTY) += mtty.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY) += mdpy.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MDPY_FB) += mdpy-fb.o obj-$(CONFIG_SAMPLE_VFIO_MDEV_MBOCHS) += mbochs.o +obj-$(CONFIG_SAMPLE_VIRTIO_MDEV_NET) += mvnet.o diff --git a/samples/vfio-mdev/mvnet.c b/samples/vfio-mdev/mvnet.c new file mode 100644 index 000000000000..8b43fcc78a68 --- /dev/null +++ b/samples/vfio-mdev/mvnet.c @@ -0,0 +1,685 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Mediated virtual virtio-net device driver. + * + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * Author: Jason Wang + * + * Sample driver that creates mdev device that simulates ethernet loopback + * device. + * + * Usage: + * + * # modprobe virtio_mdev + * # modprobe mvnet + * # cd /sys/devices/virtual/mvnet/mvnet/mdev_supported_types/mvnet-virtio + * # echo "83b8f4f2-509f-382f-3c1e-e6bfe0fa1001" > ./create + * # cd devices/83b8f4f2-509f-382f-3c1e-e6bfe0fa1001 + * # ls -d virtio0 + * virtio0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define VERSION_STRING "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" + +#define MVNET_CLASS_NAME "mvnet" +#define MVNET_NAME "mvnet" + +/* + * Global Structures + */ + +static struct mvnet_dev { + struct class *vd_class; + struct idr vd_idr; + struct device dev; +} mvnet_dev; + +struct mvnet_virtqueue { + struct vringh vring; + struct vringh_kiov iov; + unsigned short head; + bool ready; + u64 desc_addr; + u64 device_addr; + u64 driver_addr; + u32 num; + void *private; + irqreturn_t (*cb)(void *data); +}; + +#define MVNET_QUEUE_ALIGN PAGE_SIZE +#define MVNET_QUEUE_MAX 256 +#define MVNET_DEVICE_ID 0x1 +#define MVNET_VENDOR_ID 0 + +u64 mvnet_features = (1ULL << VIRTIO_F_ANY_LAYOUT) | + (1ULL << VIRTIO_F_VERSION_1) | + (1ULL << VIRTIO_F_IOMMU_PLATFORM); + +/* State of each mdev device */ +struct mvnet_state { + struct mvnet_virtqueue vqs[2]; + struct work_struct work; + spinlock_t lock; + struct mdev_device *mdev; + struct virtio_net_config config; + void *buffer; + u32 status; + u32 generation; + u64 features; + struct list_head next; +}; + +static struct mutex mdev_list_lock; +static struct list_head mdev_devices_list; + +static void mvnet_queue_ready(struct mvnet_state *mvnet, unsigned int idx) +{ + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + int ret; + + ret = vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, + false, (struct vring_desc *)vq->desc_addr, + (struct vring_avail *)vq->driver_addr, + (struct vring_used *)vq->device_addr); +} + +static void mvnet_vq_reset(struct mvnet_virtqueue *vq) +{ + vq->ready = 0; + vq->desc_addr = 0; + vq->driver_addr = 0; + vq->device_addr = 0; + vq->cb = NULL; + vq->private = NULL; + vringh_init_kern(&vq->vring, mvnet_features, MVNET_QUEUE_MAX, + false, 0, 0, 0); +} + +static void mvnet_reset(struct mvnet_state *mvnet) +{ + int i; + + for (i = 0; i < 2; i++) + mvnet_vq_reset(&mvnet->vqs[i]); + + mvnet->features = 0; + mvnet->status = 0; + ++mvnet->generation; +} + +static void mvnet_work(struct work_struct *work) +{ + struct mvnet_state *mvnet = container_of(work, struct + mvnet_state, work); + struct mvnet_virtqueue *txq = &mvnet->vqs[1]; + struct mvnet_virtqueue *rxq = &mvnet->vqs[0]; + size_t read, write, total_write; + int err; + int pkts = 0; + + spin_lock(&mvnet->lock); + + if (!txq->ready || !rxq->ready) + goto out; + + while (true) { + total_write = 0; + err = vringh_getdesc_kern(&txq->vring, &txq->iov, NULL, + &txq->head, GFP_ATOMIC); + if (err <= 0) + break; + + err = vringh_getdesc_kern(&rxq->vring, NULL, &rxq->iov, + &rxq->head, GFP_ATOMIC); + if (err <= 0) { + vringh_complete_kern(&txq->vring, txq->head, 0); + break; + } + + while (true) { + read = vringh_iov_pull_kern(&txq->iov, mvnet->buffer, + PAGE_SIZE); + if (read <= 0) + break; + + write = vringh_iov_push_kern(&rxq->iov, mvnet->buffer, + read); + if (write <= 0) + break; + + total_write += write; + } + + /* Make sure data is wrote before advancing index */ + smp_wmb(); + + vringh_complete_kern(&txq->vring, txq->head, 0); + vringh_complete_kern(&rxq->vring, rxq->head, total_write); + + /* Make sure used is visible before rasing the interrupt. */ + smp_wmb(); + + local_bh_disable(); + if (txq->cb) + txq->cb(txq->private); + if (rxq->cb) + rxq->cb(rxq->private); + local_bh_enable(); + + if (++pkts > 4) { + schedule_work(&mvnet->work); + goto out; + } + } + +out: + spin_unlock(&mvnet->lock); +} + +static dma_addr_t mvnet_map_page(struct device *dev, struct page *page, + unsigned long offset, size_t size, + enum dma_data_direction dir, + unsigned long attrs) +{ + /* Vringh can only use HVA */ + return (dma_addr_t)(page_address(page) + offset); +} + +static void mvnet_unmap_page(struct device *dev, dma_addr_t dma_addr, + size_t size, enum dma_data_direction dir, + unsigned long attrs) +{ +} + +static void *mvnet_alloc_coherent(struct device *dev, size_t size, + dma_addr_t *dma_addr, gfp_t flag, + unsigned long attrs) +{ + void *addr = kmalloc(size, flag); + + if (addr == NULL) + *dma_addr = DMA_MAPPING_ERROR; + else + *dma_addr = (dma_addr_t) addr; + + return addr; +} + +static void mvnet_free_coherent(struct device *dev, size_t size, + void *vaddr, dma_addr_t dma_addr, + unsigned long attrs) +{ + kfree((void *)dma_addr); +} + +static const struct dma_map_ops mvnet_dma_ops = { + .map_page = mvnet_map_page, + .unmap_page = mvnet_unmap_page, + .alloc = mvnet_alloc_coherent, + .free = mvnet_free_coherent, +}; + +static const struct mdev_virtio_device_ops mdev_virtio_ops; + +static int mvnet_create(struct kobject *kobj, struct mdev_device *mdev) +{ + struct mvnet_state *mvnet; + struct virtio_net_config *config; + struct device *dev = mdev_dev(mdev); + + if (!mdev) + return -EINVAL; + + mvnet = kzalloc(sizeof(struct mvnet_state), GFP_KERNEL); + if (mvnet == NULL) + return -ENOMEM; + + mvnet->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL); + if (!mvnet->buffer) { + kfree(mvnet); + return -ENOMEM; + } + + config = &mvnet->config; + config->mtu = 1500; + config->status = VIRTIO_NET_S_LINK_UP; + eth_random_addr(config->mac); + + INIT_WORK(&mvnet->work, mvnet_work); + + spin_lock_init(&mvnet->lock); + mvnet->mdev = mdev; + mdev_set_drvdata(mdev, mvnet); + + mutex_lock(&mdev_list_lock); + list_add(&mvnet->next, &mdev_devices_list); + mutex_unlock(&mdev_list_lock); + + dev->coherent_dma_mask = DMA_BIT_MASK(64); + set_dma_ops(dev, &mvnet_dma_ops); + + mdev_set_virtio_ops(mdev, &mdev_virtio_ops); + + return 0; +} + +static int mvnet_remove(struct mdev_device *mdev) +{ + struct mvnet_state *mds, *tmp_mds; + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + int ret = -EINVAL; + + mutex_lock(&mdev_list_lock); + list_for_each_entry_safe(mds, tmp_mds, &mdev_devices_list, next) { + if (mvnet == mds) { + list_del(&mvnet->next); + mdev_set_drvdata(mdev, NULL); + kfree(mvnet->buffer); + kfree(mvnet); + ret = 0; + break; + } + } + mutex_unlock(&mdev_list_lock); + + return ret; +} + +static ssize_t +sample_mvnet_dev_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + if (mdev_from_dev(dev)) + return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + + return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mvnet_dev); + +static struct attribute *mvnet_dev_attrs[] = { + &dev_attr_sample_mvnet_dev.attr, + NULL, +}; + +static const struct attribute_group mvnet_dev_group = { + .name = "mvnet_dev", + .attrs = mvnet_dev_attrs, +}; + +static const struct attribute_group *mvnet_dev_groups[] = { + &mvnet_dev_group, + NULL, +}; + +static ssize_t +sample_mdev_dev_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + if (mdev_from_dev(dev)) + return sprintf(buf, "This is MDEV %s\n", dev_name(dev)); + + return sprintf(buf, "\n"); +} + +static DEVICE_ATTR_RO(sample_mdev_dev); + +static struct attribute *mdev_dev_attrs[] = { + &dev_attr_sample_mdev_dev.attr, + NULL, +}; + +static const struct attribute_group mdev_dev_group = { + .name = "vendor", + .attrs = mdev_dev_attrs, +}; + +static const struct attribute_group *mdev_dev_groups[] = { + &mdev_dev_group, + NULL, +}; + +#define MVNET_STRING_LEN 16 + +static ssize_t +name_show(struct kobject *kobj, struct device *dev, char *buf) +{ + char name[MVNET_STRING_LEN]; + const char *name_str = "virtio-net"; + + snprintf(name, MVNET_STRING_LEN, "%s", dev_driver_string(dev)); + if (!strcmp(kobj->name, name)) + return sprintf(buf, "%s\n", name_str); + + return -EINVAL; +} + +static MDEV_TYPE_ATTR_RO(name); + +static ssize_t +available_instances_show(struct kobject *kobj, struct device *dev, char *buf) +{ + return sprintf(buf, "%d\n", INT_MAX); +} + +static MDEV_TYPE_ATTR_RO(available_instances); + +static ssize_t device_api_show(struct kobject *kobj, struct device *dev, + char *buf) +{ + return sprintf(buf, "%s\n", VIRTIO_MDEV_DEVICE_API_STRING); +} + +static MDEV_TYPE_ATTR_RO(device_api); + +static struct attribute *mdev_types_attrs[] = { + &mdev_type_attr_name.attr, + &mdev_type_attr_device_api.attr, + &mdev_type_attr_available_instances.attr, + NULL, +}; + +static struct attribute_group mdev_type_group = { + .name = "virtio", + .attrs = mdev_types_attrs, +}; + +/* TBD: "vhost" type */ + +static struct attribute_group *mdev_type_groups[] = { + &mdev_type_group, + NULL, +}; + +static int mvnet_set_vq_address(struct mdev_device *mdev, u16 idx, + u64 desc_area, u64 driver_area, u64 device_area) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->desc_addr = desc_area; + vq->driver_addr = driver_area; + vq->device_addr = device_area; + + return 0; +} + +static void mvnet_set_vq_num(struct mdev_device *mdev, u16 idx, u32 num) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->num = num; +} + +static void mvnet_kick_vq(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + if (vq->ready) + schedule_work(&mvnet->work); +} + +static void mvnet_set_vq_cb(struct mdev_device *mdev, u16 idx, + struct virtio_mdev_callback *cb) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + vq->cb = cb->callback; + vq->private = cb->private; +} + +static void mvnet_set_vq_ready(struct mdev_device *mdev, u16 idx, bool ready) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + spin_lock(&mvnet->lock); + vq->ready = ready; + if (vq->ready) + mvnet_queue_ready(mvnet, idx); + spin_unlock(&mvnet->lock); +} + +static bool mvnet_get_vq_ready(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + + return vq->ready; +} + +static int mvnet_set_vq_state(struct mdev_device *mdev, u16 idx, u64 state) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + struct vringh *vrh = &vq->vring; + + spin_lock(&mvnet->lock); + vrh->last_avail_idx = state; + spin_unlock(&mvnet->lock); + + return 0; +} + +static u64 mvnet_get_vq_state(struct mdev_device *mdev, u16 idx) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + struct mvnet_virtqueue *vq = &mvnet->vqs[idx]; + struct vringh *vrh = &vq->vring; + + return vrh->last_avail_idx; +} + +static u16 mvnet_get_vq_align(struct mdev_device *mdev) +{ + return MVNET_QUEUE_ALIGN; +} + +static u64 mvnet_get_features(struct mdev_device *mdev) +{ + return mvnet_features; +} + +static int mvnet_set_features(struct mdev_device *mdev, u64 features) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + /* DMA mapping must be done by driver */ + if (!(features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))) + return -EINVAL; + + mvnet->features = features & mvnet_features; + + return 0; +} + +static void mvnet_set_config_cb(struct mdev_device *mdev, + struct virtio_mdev_callback *cb) +{ + /* We don't support config interrupt */ +} + +static u16 mvnet_get_vq_num_max(struct mdev_device *mdev) +{ + return MVNET_QUEUE_MAX; +} + +static u32 mvnet_get_device_id(struct mdev_device *mdev) +{ + return MVNET_DEVICE_ID; +} + +static u32 mvnet_get_vendor_id(struct mdev_device *mdev) +{ + return MVNET_VENDOR_ID; +} + +static u8 mvnet_get_status(struct mdev_device *mdev) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + return mvnet->status; +} + +static void mvnet_set_status(struct mdev_device *mdev, u8 status) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + mvnet->status = status; + + if (status == 0) { + spin_lock(&mvnet->lock); + mvnet_reset(mvnet); + spin_unlock(&mvnet->lock); + } +} + +static void mvnet_get_config(struct mdev_device *mdev, unsigned int offset, + void *buf, unsigned int len) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + if (offset + len < sizeof(struct virtio_net_config)) + memcpy(buf, &mvnet->config + offset, len); +} + +static void mvnet_set_config(struct mdev_device *mdev, unsigned int offset, + const void *buf, unsigned int len) +{ + /* No writable config supportted by mvnet */ +} + +static u32 mvnet_get_generation(struct mdev_device *mdev) +{ + struct mvnet_state *mvnet = mdev_get_drvdata(mdev); + + return mvnet->generation; +} + +static const struct mdev_virtio_device_ops mdev_virtio_ops = { + .set_vq_address = mvnet_set_vq_address, + .set_vq_num = mvnet_set_vq_num, + .kick_vq = mvnet_kick_vq, + .set_vq_cb = mvnet_set_vq_cb, + .set_vq_ready = mvnet_set_vq_ready, + .get_vq_ready = mvnet_get_vq_ready, + .set_vq_state = mvnet_set_vq_state, + .get_vq_state = mvnet_get_vq_state, + .get_vq_align = mvnet_get_vq_align, + .get_features = mvnet_get_features, + .set_features = mvnet_set_features, + .set_config_cb = mvnet_set_config_cb, + .get_vq_num_max = mvnet_get_vq_num_max, + .get_device_id = mvnet_get_device_id, + .get_vendor_id = mvnet_get_vendor_id, + .get_status = mvnet_get_status, + .set_status = mvnet_set_status, + .get_config = mvnet_get_config, + .set_config = mvnet_set_config, + .get_generation = mvnet_get_generation, +}; + +static const struct mdev_parent_ops mdev_fops = { + .owner = THIS_MODULE, + .dev_attr_groups = mvnet_dev_groups, + .mdev_attr_groups = mdev_dev_groups, + .supported_type_groups = mdev_type_groups, + .create = mvnet_create, + .remove = mvnet_remove, +}; + +static void mvnet_device_release(struct device *dev) +{ + dev_dbg(dev, "mvnet: released\n"); +} + +static int __init mvnet_dev_init(void) +{ + int ret = 0; + + pr_info("mvnet_dev: %s\n", __func__); + + memset(&mvnet_dev, 0, sizeof(mvnet_dev)); + + idr_init(&mvnet_dev.vd_idr); + + mvnet_dev.vd_class = class_create(THIS_MODULE, MVNET_CLASS_NAME); + + if (IS_ERR(mvnet_dev.vd_class)) { + pr_err("Error: failed to register mvnet_dev class\n"); + ret = PTR_ERR(mvnet_dev.vd_class); + goto failed1; + } + + mvnet_dev.dev.class = mvnet_dev.vd_class; + mvnet_dev.dev.release = mvnet_device_release; + dev_set_name(&mvnet_dev.dev, "%s", MVNET_NAME); + + ret = device_register(&mvnet_dev.dev); + if (ret) + goto failed2; + + ret = mdev_register_device(&mvnet_dev.dev, &mdev_fops); + if (ret) + goto failed3; + + mutex_init(&mdev_list_lock); + INIT_LIST_HEAD(&mdev_devices_list); + + goto all_done; + +failed3: + + device_unregister(&mvnet_dev.dev); +failed2: + class_destroy(mvnet_dev.vd_class); + +failed1: +all_done: + return ret; +} + +static void __exit mvnet_dev_exit(void) +{ + mvnet_dev.dev.bus = NULL; + mdev_unregister_device(&mvnet_dev.dev); + + device_unregister(&mvnet_dev.dev); + idr_destroy(&mvnet_dev.vd_idr); + class_destroy(mvnet_dev.vd_class); + mvnet_dev.vd_class = NULL; + pr_info("mvnet_dev: Unloaded!\n"); +} + +module_init(mvnet_dev_init) +module_exit(mvnet_dev_exit) + +MODULE_LICENSE("GPL v2"); +MODULE_INFO(supported, "Simulate loopback ethernet device over mdev"); +MODULE_VERSION(VERSION_STRING); +MODULE_AUTHOR(DRIVER_AUTHOR); -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.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 E6B22C49EAD for ; Tue, 5 Nov 2019 09:42:38 +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 C416C21929 for ; Tue, 5 Nov 2019 09:42:38 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C416C21929 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 3A8026E975; Tue, 5 Nov 2019 09:42:38 +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 C1C5D6E977 for ; Tue, 5 Nov 2019 09:42:36 +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-367-QKyKdWrBOfGSQkBZ_IXJ0A-1; Tue, 05 Nov 2019 04:42:32 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CD414477; Tue, 5 Nov 2019 09:42:26 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-252.pek2.redhat.com [10.72.12.252]) by smtp.corp.redhat.com (Postfix) with ESMTP id 426A25C28D; Tue, 5 Nov 2019 09:39:35 +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 Subject: [PATCH V8 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Tue, 5 Nov 2019 17:32:40 +0800 Message-Id: <20191105093240.5135-7-jasowang@redhat.com> In-Reply-To: <20191105093240.5135-1-jasowang@redhat.com> References: <20191105093240.5135-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-MC-Unique: QKyKdWrBOfGSQkBZ_IXJ0A-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=1572946955; 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=syXqnRjGmjED8oe1bGzFfKezKmp2rR8du99TBlzamLo=; b=CNMgl8xu/5pD71WLCbBNd9U79ZU57t3pNhS11be9ACo4Z1keRjUwURbiRQRcuQiqaASfKl 3DHvurRrN5rkyxNV1S7U3pJGcAYoQDTLD0qccM4z3SXU+D0I5Fz7CSJjfu0prgdmdxfGlK PO0Bcx0mc0461sQIiihIPBAGWLfEbZk= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, 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, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191105093240.mC8MbJBl1AhmKEYvytfPx7YCQmqiPApwoU7SLM7nvT8@z> VGhpcyBzYW1wbGUgZHJpdmVyIGNyZWF0ZXMgbWRldiBkZXZpY2UgdGhhdCBzaW11bGF0ZSB2aXJ0 aW8gbmV0IGRldmljZQpvdmVyIHZpcnRpbyBtZGV2IHRyYW5zcG9ydC4gVGhlIGRldmljZSBpcyBp bXBsZW1lbnRlZCB0aHJvdWdoIHZyaW5naAphbmQgd29ya3F1ZXVlLiBBIGRldmljZSBzcGVjaWZp YyBkbWEgb3BzIGlzIHRvIG1ha2Ugc3VyZSBIVkEgaXMgdXNlZApkaXJlY3RseSBhcyB0aGUgSU9W QS4gVGhpcyBzaG91bGQgYmUgc3VmZmljaWVudCBmb3Iga2VybmVsIHZpcnRpbwpkcml2ZXIgdG8g d29yay4KCk9ubHkgJ3ZpcnRpbycgdHlwZSBpcyBzdXBwb3J0ZWQgcmlnaHQgbm93LiBJIHBsYW4g dG8gYWRkICd2aG9zdCcgdHlwZQpvbiB0b3Agd2hpY2ggcmVxdWlyZXMgc29tZSB2aXJ0dWFsIElP TU1VIGltcGxlbWVudGVkIGluIHRoaXMgc2FtcGxlCmRyaXZlci4KClNpZ25lZC1vZmYtYnk6IEph c29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAg ICAgICAgfCAgIDEgKwogc2FtcGxlcy9LY29uZmlnICAgICAgICAgICAgfCAgIDcgKwogc2FtcGxl cy92ZmlvLW1kZXYvTWFrZWZpbGUgfCAgIDEgKwogc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXQuYyAg fCA2ODUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogNCBmaWxlcyBjaGFu Z2VkLCA2OTQgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IHNhbXBsZXMvdmZpby1t ZGV2L212bmV0LmMKCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4 IGY2NjFkMTMzNDRkNi4uMzVlOTIwNGQ1YzY4IDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysg Yi9NQUlOVEFJTkVSUwpAQCAtMTcyNDgsNiArMTcyNDgsNyBAQCBGOglpbmNsdWRlL2xpbnV4L3Zp cnRpbyouaAogRjoJaW5jbHVkZS91YXBpL2xpbnV4L3ZpcnRpb18qLmgKIEY6CWRyaXZlcnMvY3J5 cHRvL3ZpcnRpby8KIEY6CW1tL2JhbGxvb25fY29tcGFjdGlvbi5jCitGOglzYW1wbGVzL3ZmaW8t bWRldi9tdm5ldC5jCiAKIFZJUlRJTyBCTE9DSyBBTkQgU0NTSSBEUklWRVJTCiBNOgkiTWljaGFl bCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+CmRpZmYgLS1naXQgYS9zYW1wbGVzL0tjb25m aWcgYi9zYW1wbGVzL0tjb25maWcKaW5kZXggYzhkYWNiNGRkYTgwLi5hMWExY2EyYzAwYjcgMTAw NjQ0Ci0tLSBhL3NhbXBsZXMvS2NvbmZpZworKysgYi9zYW1wbGVzL0tjb25maWcKQEAgLTEzMSw2 ICsxMzEsMTMgQEAgY29uZmlnIFNBTVBMRV9WRklPX01ERVZfTURQWQogCSAgbWVkaWF0ZWQgZGV2 aWNlLiAgSXQgaXMgYSBzaW1wbGUgZnJhbWVidWZmZXIgYW5kIHN1cHBvcnRzCiAJICB0aGUgcmVn aW9uIGRpc3BsYXkgaW50ZXJmYWNlIChWRklPX0dGWF9QTEFORV9UWVBFX1JFR0lPTikuCiAKK2Nv bmZpZyBTQU1QTEVfVklSVElPX01ERVZfTkVUCisgICAgICAgIHRyaXN0YXRlICJCdWlsZCB2aXJ0 aW8gbWRldiBuZXQgZXhhbXBsZSBtZWRpYXRlZCBkZXZpY2Ugc2FtcGxlIGNvZGUgLS0gbG9hZGFi bGUgbW9kdWxlcyBvbmx5IgorCWRlcGVuZHMgb24gVklSVElPX01ERVZfREVWSUNFICYmIFZIT1NU X1JJTkcgJiYgbQorCWhlbHAKKwkgIEJ1aWxkIGEgbmV0d29ya2luZyBzYW1wbGUgZGV2aWNlIGZv ciB1c2UgYXMgYSB2aXJ0aW8KKwkgIG1lZGlhdGVkIGRldmljZS4KKwogY29uZmlnIFNBTVBMRV9W RklPX01ERVZfTURQWV9GQgogCXRyaXN0YXRlICJCdWlsZCBWRklPIG1kcHkgZXhhbXBsZSBndWVz dCBmYmRldiBkcml2ZXIgLS0gbG9hZGFibGUgbW9kdWxlIG9ubHkiCiAJZGVwZW5kcyBvbiBGQiAm JiBtCmRpZmYgLS1naXQgYS9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZSBiL3NhbXBsZXMvdmZp by1tZGV2L01ha2VmaWxlCmluZGV4IDEwZDE3OWM0ZmRlYi4uZjM0YWY5MGVkMGEwIDEwMDY0NAot LS0gYS9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZQorKysgYi9zYW1wbGVzL3ZmaW8tbWRldi9N YWtlZmlsZQpAQCAtMywzICszLDQgQEAgb2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTVRU WSkgKz0gbXR0eS5vCiBvYmotJChDT05GSUdfU0FNUExFX1ZGSU9fTURFVl9NRFBZKSArPSBtZHB5 Lm8KIG9iai0kKENPTkZJR19TQU1QTEVfVkZJT19NREVWX01EUFlfRkIpICs9IG1kcHktZmIubwog b2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTUJPQ0hTKSArPSBtYm9jaHMubworb2JqLSQo Q09ORklHX1NBTVBMRV9WSVJUSU9fTURFVl9ORVQpICs9IG12bmV0Lm8KZGlmZiAtLWdpdCBhL3Nh bXBsZXMvdmZpby1tZGV2L212bmV0LmMgYi9zYW1wbGVzL3ZmaW8tbWRldi9tdm5ldC5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOGI0M2ZjYzc4YTY4Ci0tLSAvZGV2 L251bGwKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXQuYwpAQCAtMCwwICsxLDY4NSBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQorLyoKKyAqIE1lZGlhdGVk IHZpcnR1YWwgdmlydGlvLW5ldCBkZXZpY2UgZHJpdmVyLgorICoKKyAqIENvcHlyaWdodCAoYykg MjAxOSwgUmVkIEhhdCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiAgICAgQXV0aG9yOiBK YXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgorICoKKyAqIFNhbXBsZSBkcml2ZXIgdGhh dCBjcmVhdGVzIG1kZXYgZGV2aWNlIHRoYXQgc2ltdWxhdGVzIGV0aGVybmV0IGxvb3BiYWNrCisg KiBkZXZpY2UuCisgKgorICogVXNhZ2U6CisgKgorICogIyBtb2Rwcm9iZSB2aXJ0aW9fbWRldgor ICogIyBtb2Rwcm9iZSBtdm5ldAorICogIyBjZCAvc3lzL2RldmljZXMvdmlydHVhbC9tdm5ldC9t dm5ldC9tZGV2X3N1cHBvcnRlZF90eXBlcy9tdm5ldC12aXJ0aW8KKyAqICMgZWNobyAiODNiOGY0 ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxIiA+IC4vY3JlYXRlCisgKiAjIGNkIGRldmlj ZXMvODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxCisgKiAjIGxzIC1kIHZpcnRp bzAKKyAqIHZpcnRpbzAKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvcG9s bC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgor I2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKyNpbmNsdWRlIDxsaW51eC91dWlkLmg+CisjaW5jbHVk ZSA8bGludXgvaW9tbXUuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNmcy5oPgorI2luY2x1ZGUgPGxp bnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgorI2luY2x1ZGUgPGxp bnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92cmluZ2guaD4KKyNpbmNsdWRlIDxsaW51eC9t ZGV2X3ZpcnRpb19vcHMuaD4KKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19jb25maWcuaD4K KyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19uZXQuaD4KKworI2RlZmluZSBWRVJTSU9OX1NU UklORyAgIjAuMSIKKyNkZWZpbmUgRFJJVkVSX0FVVEhPUiAgICJSZWQgSGF0IENvcnBvcmF0aW9u IgorCisjZGVmaW5lIE1WTkVUX0NMQVNTX05BTUUgIm12bmV0IgorI2RlZmluZSBNVk5FVF9OQU1F ICAgICAgICJtdm5ldCIKKworLyoKKyAqIEdsb2JhbCBTdHJ1Y3R1cmVzCisgKi8KKworc3RhdGlj IHN0cnVjdCBtdm5ldF9kZXYgeworCXN0cnVjdCBjbGFzcwkqdmRfY2xhc3M7CisJc3RydWN0IGlk cgl2ZF9pZHI7CisJc3RydWN0IGRldmljZQlkZXY7Cit9IG12bmV0X2RldjsKKworc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSB7CisJc3RydWN0IHZyaW5naCB2cmluZzsKKwlzdHJ1Y3QgdnJpbmdoX2tp b3YgaW92OworCXVuc2lnbmVkIHNob3J0IGhlYWQ7CisJYm9vbCByZWFkeTsKKwl1NjQgZGVzY19h ZGRyOworCXU2NCBkZXZpY2VfYWRkcjsKKwl1NjQgZHJpdmVyX2FkZHI7CisJdTMyIG51bTsKKwl2 b2lkICpwcml2YXRlOworCWlycXJldHVybl90ICgqY2IpKHZvaWQgKmRhdGEpOworfTsKKworI2Rl ZmluZSBNVk5FVF9RVUVVRV9BTElHTiBQQUdFX1NJWkUKKyNkZWZpbmUgTVZORVRfUVVFVUVfTUFY IDI1NgorI2RlZmluZSBNVk5FVF9ERVZJQ0VfSUQgMHgxCisjZGVmaW5lIE1WTkVUX1ZFTkRPUl9J RCAwCisKK3U2NCBtdm5ldF9mZWF0dXJlcyA9ICgxVUxMIDw8IFZJUlRJT19GX0FOWV9MQVlPVVQp IHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9WRVJTSU9OXzEpIHwKKwkJICAgICAoMVVMTCA8 PCBWSVJUSU9fRl9JT01NVV9QTEFURk9STSk7CisKKy8qIFN0YXRlIG9mIGVhY2ggbWRldiBkZXZp Y2UgKi8KK3N0cnVjdCBtdm5ldF9zdGF0ZSB7CisJc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB2cXNb Ml07CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7CisJc3BpbmxvY2tfdCBsb2NrOworCXN0cnVj dCBtZGV2X2RldmljZSAqbWRldjsKKwlzdHJ1Y3QgdmlydGlvX25ldF9jb25maWcgY29uZmlnOwor CXZvaWQgKmJ1ZmZlcjsKKwl1MzIgc3RhdHVzOworCXUzMiBnZW5lcmF0aW9uOworCXU2NCBmZWF0 dXJlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5leHQ7Cit9OworCitzdGF0aWMgc3RydWN0IG11dGV4 IG1kZXZfbGlzdF9sb2NrOworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgbWRldl9kZXZpY2VzX2xp c3Q7CisKK3N0YXRpYyB2b2lkIG12bmV0X3F1ZXVlX3JlYWR5KHN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQsIHVuc2lnbmVkIGludCBpZHgpCit7CisJc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSAqdnEg PSAmbXZuZXQtPnZxc1tpZHhdOworCWludCByZXQ7CisKKwlyZXQgPSB2cmluZ2hfaW5pdF9rZXJu KCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVVRV9NQVgsCisJCQkgICAgICAg ZmFsc2UsIChzdHJ1Y3QgdnJpbmdfZGVzYyAqKXZxLT5kZXNjX2FkZHIsCisJCQkgICAgICAgKHN0 cnVjdCB2cmluZ19hdmFpbCAqKXZxLT5kcml2ZXJfYWRkciwKKwkJCSAgICAgICAoc3RydWN0IHZy aW5nX3VzZWQgKil2cS0+ZGV2aWNlX2FkZHIpOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF92cV9y ZXNldChzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSkKK3sKKwl2cS0+cmVhZHkgPSAwOworCXZx LT5kZXNjX2FkZHIgPSAwOworCXZxLT5kcml2ZXJfYWRkciA9IDA7CisJdnEtPmRldmljZV9hZGRy ID0gMDsKKwl2cS0+Y2IgPSBOVUxMOworCXZxLT5wcml2YXRlID0gTlVMTDsKKwl2cmluZ2hfaW5p dF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVVRV9NQVgsCisJCQlm YWxzZSwgMCwgMCwgMCk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3Jlc2V0KHN0cnVjdCBtdm5l dF9zdGF0ZSAqbXZuZXQpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKQor CQltdm5ldF92cV9yZXNldCgmbXZuZXQtPnZxc1tpXSk7CisKKwltdm5ldC0+ZmVhdHVyZXMgPSAw OworCW12bmV0LT5zdGF0dXMgPSAwOworCSsrbXZuZXQtPmdlbmVyYXRpb247Cit9CisKK3N0YXRp YyB2b2lkIG12bmV0X3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQoreworCXN0cnVjdCBt dm5ldF9zdGF0ZSAqbXZuZXQgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0CisJCQkJCQkgbXZu ZXRfc3RhdGUsIHdvcmspOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnR4cSA9ICZtdm5ldC0+ dnFzWzFdOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnJ4cSA9ICZtdm5ldC0+dnFzWzBdOwor CXNpemVfdCByZWFkLCB3cml0ZSwgdG90YWxfd3JpdGU7CisJaW50IGVycjsKKwlpbnQgcGt0cyA9 IDA7CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKworCWlmICghdHhxLT5yZWFkeSB8fCAh cnhxLT5yZWFkeSkKKwkJZ290byBvdXQ7CisKKwl3aGlsZSAodHJ1ZSkgeworCQl0b3RhbF93cml0 ZSA9IDA7CisJCWVyciA9IHZyaW5naF9nZXRkZXNjX2tlcm4oJnR4cS0+dnJpbmcsICZ0eHEtPmlv diwgTlVMTCwKKwkJCQkJICAmdHhxLT5oZWFkLCBHRlBfQVRPTUlDKTsKKwkJaWYgKGVyciA8PSAw KQorCQkJYnJlYWs7CisKKwkJZXJyID0gdnJpbmdoX2dldGRlc2Nfa2VybigmcnhxLT52cmluZywg TlVMTCwgJnJ4cS0+aW92LAorCQkJCQkgICZyeHEtPmhlYWQsIEdGUF9BVE9NSUMpOworCQlpZiAo ZXJyIDw9IDApIHsKKwkJCXZyaW5naF9jb21wbGV0ZV9rZXJuKCZ0eHEtPnZyaW5nLCB0eHEtPmhl YWQsIDApOworCQkJYnJlYWs7CisJCX0KKworCQl3aGlsZSAodHJ1ZSkgeworCQkJcmVhZCA9IHZy aW5naF9pb3ZfcHVsbF9rZXJuKCZ0eHEtPmlvdiwgbXZuZXQtPmJ1ZmZlciwKKwkJCQkJCSAgICBQ QUdFX1NJWkUpOworCQkJaWYgKHJlYWQgPD0gMCkKKwkJCQlicmVhazsKKworCQkJd3JpdGUgPSB2 cmluZ2hfaW92X3B1c2hfa2VybigmcnhxLT5pb3YsIG12bmV0LT5idWZmZXIsCisJCQkJCQkgICAg IHJlYWQpOworCQkJaWYgKHdyaXRlIDw9IDApCisJCQkJYnJlYWs7CisKKwkJCXRvdGFsX3dyaXRl ICs9IHdyaXRlOworCQl9CisKKwkJLyogTWFrZSBzdXJlIGRhdGEgaXMgd3JvdGUgYmVmb3JlIGFk dmFuY2luZyBpbmRleCAqLworCQlzbXBfd21iKCk7CisKKwkJdnJpbmdoX2NvbXBsZXRlX2tlcm4o JnR4cS0+dnJpbmcsIHR4cS0+aGVhZCwgMCk7CisJCXZyaW5naF9jb21wbGV0ZV9rZXJuKCZyeHEt PnZyaW5nLCByeHEtPmhlYWQsIHRvdGFsX3dyaXRlKTsKKworCQkvKiBNYWtlIHN1cmUgdXNlZCBp cyB2aXNpYmxlIGJlZm9yZSByYXNpbmcgdGhlIGludGVycnVwdC4gKi8KKwkJc21wX3dtYigpOwor CisJCWxvY2FsX2JoX2Rpc2FibGUoKTsKKwkJaWYgKHR4cS0+Y2IpCisJCQl0eHEtPmNiKHR4cS0+ cHJpdmF0ZSk7CisJCWlmIChyeHEtPmNiKQorCQkJcnhxLT5jYihyeHEtPnByaXZhdGUpOworCQls b2NhbF9iaF9lbmFibGUoKTsKKworCQlpZiAoKytwa3RzID4gNCkgeworCQkJc2NoZWR1bGVfd29y aygmbXZuZXQtPndvcmspOworCQkJZ290byBvdXQ7CisJCX0KKwl9CisKK291dDoKKwlzcGluX3Vu bG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgZG1hX2FkZHJfdCBtdm5ldF9tYXBfcGFn ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCSB1bnNpZ25lZCBs b25nIG9mZnNldCwgc2l6ZV90IHNpemUsCisJCQkJIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp ciwKKwkJCQkgdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwkvKiBWcmluZ2ggY2FuIG9ubHkgdXNl IEhWQSAqLworCXJldHVybiAoZG1hX2FkZHJfdCkocGFnZV9hZGRyZXNzKHBhZ2UpICsgb2Zmc2V0 KTsKK30KKworc3RhdGljIHZvaWQgbXZuZXRfdW5tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYs IGRtYV9hZGRyX3QgZG1hX2FkZHIsCisJCQkgICAgIHNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRh X2RpcmVjdGlvbiBkaXIsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCit7Cit9CisKK3N0 YXRpYyB2b2lkICptdm5ldF9hbGxvY19jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVf dCBzaXplLAorCQkJCSAgZG1hX2FkZHJfdCAqZG1hX2FkZHIsIGdmcF90IGZsYWcsCisJCQkJICB1 bnNpZ25lZCBsb25nIGF0dHJzKQoreworCXZvaWQgKmFkZHIgPSBrbWFsbG9jKHNpemUsIGZsYWcp OworCisJaWYgKGFkZHIgPT0gTlVMTCkKKwkJKmRtYV9hZGRyID0gRE1BX01BUFBJTkdfRVJST1I7 CisJZWxzZQorCQkqZG1hX2FkZHIgPSAoZG1hX2FkZHJfdCkgYWRkcjsKKworCXJldHVybiBhZGRy OworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9mcmVlX2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmRl diwgc2l6ZV90IHNpemUsCisJCQkJdm9pZCAqdmFkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsCisJ CQkJdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwlrZnJlZSgodm9pZCAqKWRtYV9hZGRyKTsKK30K Kworc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyBtdm5ldF9kbWFfb3BzID0geworCS5t YXBfcGFnZSA9IG12bmV0X21hcF9wYWdlLAorCS51bm1hcF9wYWdlID0gbXZuZXRfdW5tYXBfcGFn ZSwKKwkuYWxsb2MgPSBtdm5ldF9hbGxvY19jb2hlcmVudCwKKwkuZnJlZSA9IG12bmV0X2ZyZWVf Y29oZXJlbnQsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2RldmljZV9v cHMgbWRldl92aXJ0aW9fb3BzOworCitzdGF0aWMgaW50IG12bmV0X2NyZWF0ZShzdHJ1Y3Qga29i amVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9z dGF0ZSAqbXZuZXQ7CisJc3RydWN0IHZpcnRpb19uZXRfY29uZmlnICpjb25maWc7CisJc3RydWN0 IGRldmljZSAqZGV2ID0gbWRldl9kZXYobWRldik7CisKKwlpZiAoIW1kZXYpCisJCXJldHVybiAt RUlOVkFMOworCisJbXZuZXQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgbXZuZXRfc3RhdGUpLCBH RlBfS0VSTkVMKTsKKwlpZiAobXZuZXQgPT0gTlVMTCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlt dm5ldC0+YnVmZmVyID0ga21hbGxvYyhQQUdFX1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghbXZu ZXQtPmJ1ZmZlcikgeworCQlrZnJlZShtdm5ldCk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKwor CWNvbmZpZyA9ICZtdm5ldC0+Y29uZmlnOworCWNvbmZpZy0+bXR1ID0gMTUwMDsKKwljb25maWct PnN0YXR1cyA9IFZJUlRJT19ORVRfU19MSU5LX1VQOworCWV0aF9yYW5kb21fYWRkcihjb25maWct Pm1hYyk7CisKKwlJTklUX1dPUksoJm12bmV0LT53b3JrLCBtdm5ldF93b3JrKTsKKworCXNwaW5f bG9ja19pbml0KCZtdm5ldC0+bG9jayk7CisJbXZuZXQtPm1kZXYgPSBtZGV2OworCW1kZXZfc2V0 X2RydmRhdGEobWRldiwgbXZuZXQpOworCisJbXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOwor CWxpc3RfYWRkKCZtdm5ldC0+bmV4dCwgJm1kZXZfZGV2aWNlc19saXN0KTsKKwltdXRleF91bmxv Y2soJm1kZXZfbGlzdF9sb2NrKTsKKworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklU X01BU0soNjQpOworCXNldF9kbWFfb3BzKGRldiwgJm12bmV0X2RtYV9vcHMpOworCisJbWRldl9z ZXRfdmlydGlvX29wcyhtZGV2LCAmbWRldl92aXJ0aW9fb3BzKTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgaW50IG12bmV0X3JlbW92ZShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7CisJ c3RydWN0IG12bmV0X3N0YXRlICptZHMsICp0bXBfbWRzOworCXN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCWludCByZXQgPSAtRUlOVkFMOworCisJ bXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht ZHMsIHRtcF9tZHMsICZtZGV2X2RldmljZXNfbGlzdCwgbmV4dCkgeworCQlpZiAobXZuZXQgPT0g bWRzKSB7CisJCQlsaXN0X2RlbCgmbXZuZXQtPm5leHQpOworCQkJbWRldl9zZXRfZHJ2ZGF0YSht ZGV2LCBOVUxMKTsKKwkJCWtmcmVlKG12bmV0LT5idWZmZXIpOworCQkJa2ZyZWUobXZuZXQpOwor CQkJcmV0ID0gMDsKKwkJCWJyZWFrOworCQl9CisJfQorCW11dGV4X3VubG9jaygmbWRldl9saXN0 X2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHNzaXplX3QKK3NhbXBsZV9tdm5l dF9kZXZfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICph dHRyLAorCQkgICAgIGNoYXIgKmJ1ZikKK3sKKwlpZiAobWRldl9mcm9tX2RldihkZXYpKQorCQly ZXR1cm4gc3ByaW50ZihidWYsICJUaGlzIGlzIE1ERVYgJXNcbiIsIGRldl9uYW1lKGRldikpOwor CisJcmV0dXJuIHNwcmludGYoYnVmLCAiXG4iKTsKK30KKworc3RhdGljIERFVklDRV9BVFRSX1JP KHNhbXBsZV9tdm5ldF9kZXYpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqbXZuZXRfZGV2 X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tdm5ldF9kZXYuYXR0ciwKKwlOVUxMLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgbXZuZXRfZGV2X2dyb3Vw ID0geworCS5uYW1lICA9ICJtdm5ldF9kZXYiLAorCS5hdHRycyA9IG12bmV0X2Rldl9hdHRycywK K307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptdm5ldF9kZXZfZ3Jv dXBzW10gPSB7CisJJm12bmV0X2Rldl9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIHNzaXpl X3QKK3NhbXBsZV9tZGV2X2Rldl9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmlj ZV9hdHRyaWJ1dGUgKmF0dHIsCisJCSAgICAgY2hhciAqYnVmKQoreworCWlmIChtZGV2X2Zyb21f ZGV2KGRldikpCisJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xuIiwgZGV2 X25hbWUoZGV2KSk7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitzdGF0aWMg REVWSUNFX0FUVFJfUk8oc2FtcGxlX21kZXZfZGV2KTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1 dGUgKm1kZXZfZGV2X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tZGV2X2Rldi5hdHRy LAorCU5VTEwsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBtZGV2 X2Rldl9ncm91cCA9IHsKKwkubmFtZSAgPSAidmVuZG9yIiwKKwkuYXR0cnMgPSBtZGV2X2Rldl9h dHRycywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X2Rl dl9ncm91cHNbXSA9IHsKKwkmbWRldl9kZXZfZ3JvdXAsCisJTlVMTCwKK307CisKKyNkZWZpbmUg TVZORVRfU1RSSU5HX0xFTiAxNgorCitzdGF0aWMgc3NpemVfdAorbmFtZV9zaG93KHN0cnVjdCBr b2JqZWN0ICprb2JqLCBzdHJ1Y3QgZGV2aWNlICpkZXYsIGNoYXIgKmJ1ZikKK3sKKwljaGFyIG5h bWVbTVZORVRfU1RSSU5HX0xFTl07CisJY29uc3QgY2hhciAqbmFtZV9zdHIgPSAidmlydGlvLW5l dCI7CisKKwlzbnByaW50ZihuYW1lLCBNVk5FVF9TVFJJTkdfTEVOLCAiJXMiLCBkZXZfZHJpdmVy X3N0cmluZyhkZXYpKTsKKwlpZiAoIXN0cmNtcChrb2JqLT5uYW1lLCBuYW1lKSkKKwkJcmV0dXJu IHNwcmludGYoYnVmLCAiJXNcbiIsIG5hbWVfc3RyKTsKKworCXJldHVybiAtRUlOVkFMOworfQor CitzdGF0aWMgTURFVl9UWVBFX0FUVFJfUk8obmFtZSk7CisKK3N0YXRpYyBzc2l6ZV90CithdmFp bGFibGVfaW5zdGFuY2VzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBkZXZpY2Ug KmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBJTlRfTUFY KTsKK30KKworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGF2YWlsYWJsZV9pbnN0YW5jZXMpOwor CitzdGF0aWMgc3NpemVfdCBkZXZpY2VfYXBpX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0 cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgICBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmlu dGYoYnVmLCAiJXNcbiIsIFZJUlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HKTsKK30KKworc3Rh dGljIE1ERVZfVFlQRV9BVFRSX1JPKGRldmljZV9hcGkpOworCitzdGF0aWMgc3RydWN0IGF0dHJp YnV0ZSAqbWRldl90eXBlc19hdHRyc1tdID0geworCSZtZGV2X3R5cGVfYXR0cl9uYW1lLmF0dHIs CisJJm1kZXZfdHlwZV9hdHRyX2RldmljZV9hcGkuYXR0ciwKKwkmbWRldl90eXBlX2F0dHJfYXZh aWxhYmxlX2luc3RhbmNlcy5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGF0dHJp YnV0ZV9ncm91cCBtZGV2X3R5cGVfZ3JvdXAgPSB7CisJLm5hbWUgID0gInZpcnRpbyIsCisJLmF0 dHJzID0gbWRldl90eXBlc19hdHRycywKK307CisKKy8qIFRCRDogInZob3N0IiB0eXBlICovCisK K3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X3R5cGVfZ3JvdXBzW10gPSB7CisJ Jm1kZXZfdHlwZV9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIGludCBtdm5ldF9zZXRfdnFf YWRkcmVzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZHgsCisJCQkJdTY0IGRlc2Nf YXJlYSwgdTY0IGRyaXZlcl9hcmVhLCB1NjQgZGV2aWNlX2FyZWEpCit7CisJc3RydWN0IG12bmV0 X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisJc3RydWN0IG12bmV0X3Zp cnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCisJdnEtPmRlc2NfYWRkciA9IGRlc2Nf YXJlYTsKKwl2cS0+ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKKwl2cS0+ZGV2aWNlX2FkZHIg PSBkZXZpY2VfYXJlYTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRf dnFfbnVtKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgdTMyIG51bSkKK3sKKwlz dHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1 Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+bnVtID0g bnVtOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9raWNrX3ZxKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwgdTE2IGlkeCkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRf ZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFz W2lkeF07CisKKwlpZiAodnEtPnJlYWR5KQorCQlzY2hlZHVsZV93b3JrKCZtdm5ldC0+d29yayk7 Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3NldF92cV9jYihzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYsIHUxNiBpZHgsCisJCQkgICAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpjYikKK3sK KwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlz dHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+Y2Ig PSBjYi0+Y2FsbGJhY2s7CisJdnEtPnByaXZhdGUgPSBjYi0+cHJpdmF0ZTsKK30KKworc3RhdGlj IHZvaWQgbXZuZXRfc2V0X3ZxX3JlYWR5KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlk eCwgYm9vbCByZWFkeSkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRf ZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFz W2lkeF07CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKwl2cS0+cmVhZHkgPSByZWFkeTsK KwlpZiAodnEtPnJlYWR5KQorCQltdm5ldF9xdWV1ZV9yZWFkeShtdm5ldCwgaWR4KTsKKwlzcGlu X3VubG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgYm9vbCBtdm5ldF9nZXRfdnFfcmVh ZHkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0cnVjdCBtdm5ldF9z dGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0 cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKworCXJldHVybiB2cS0+cmVhZHk7Cit9CisK K3N0YXRpYyBpbnQgbXZuZXRfc2V0X3ZxX3N0YXRlKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwg dTE2IGlkeCwgdTY0IHN0YXRlKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2 X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0 LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJc3Bpbl9s b2NrKCZtdm5ldC0+bG9jayk7CisJdnJoLT5sYXN0X2F2YWlsX2lkeCA9IHN0YXRlOworCXNwaW5f dW5sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHU2NCBtdm5l dF9nZXRfdnFfc3RhdGUoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0 cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVj dCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdo ICp2cmggPSAmdnEtPnZyaW5nOworCisJcmV0dXJuIHZyaC0+bGFzdF9hdmFpbF9pZHg7Cit9CisK K3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX2FsaWduKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikK K3sKKwlyZXR1cm4gTVZORVRfUVVFVUVfQUxJR047Cit9CisKK3N0YXRpYyB1NjQgbXZuZXRfZ2V0 X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gbXZuZXRfZmVh dHVyZXM7Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdTY0IGZlYXR1cmVzKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJLyogRE1BIG1hcHBpbmcgbXVzdCBiZSBkb25l IGJ5IGRyaXZlciAqLworCWlmICghKGZlYXR1cmVzICYgKDFVTEwgPDwgVklSVElPX0ZfSU9NTVVf UExBVEZPUk0pKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltdm5ldC0+ZmVhdHVyZXMgPSBmZWF0 dXJlcyAmIG12bmV0X2ZlYXR1cmVzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIG12 bmV0X3NldF9jb25maWdfY2Ioc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LAorCQkJCXN0cnVjdCB2 aXJ0aW9fbWRldl9jYWxsYmFjayAqY2IpCit7CisJLyogV2UgZG9uJ3Qgc3VwcG9ydCBjb25maWcg aW50ZXJydXB0ICovCit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX251bV9tYXgoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2KQoreworCXJldHVybiBNVk5FVF9RVUVVRV9NQVg7Cit9CisKK3N0 YXRpYyB1MzIgbXZuZXRfZ2V0X2RldmljZV9pZChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7 CisJcmV0dXJuIE1WTkVUX0RFVklDRV9JRDsKK30KKworc3RhdGljIHUzMiBtdm5ldF9nZXRfdmVu ZG9yX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gTVZORVRfVkVORE9S X0lEOworfQorCitzdGF0aWMgdTggbXZuZXRfZ2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYpCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEo bWRldik7CisKKwlyZXR1cm4gbXZuZXQtPnN0YXR1czsKK30KKworc3RhdGljIHZvaWQgbXZuZXRf c2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cykKK3sKKwlzdHJ1 Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKworCW12bmV0 LT5zdGF0dXMgPSBzdGF0dXM7CisKKwlpZiAoc3RhdHVzID09IDApIHsKKwkJc3Bpbl9sb2NrKCZt dm5ldC0+bG9jayk7CisJCW12bmV0X3Jlc2V0KG12bmV0KTsKKwkJc3Bpbl91bmxvY2soJm12bmV0 LT5sb2NrKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2dldF9jb25maWcoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAorCQkJICAgICB2b2lkICpidWYs IHVuc2lnbmVkIGludCBsZW4pCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZf Z2V0X2RydmRhdGEobWRldik7CisKKwlpZiAob2Zmc2V0ICsgbGVuIDwgc2l6ZW9mKHN0cnVjdCB2 aXJ0aW9fbmV0X2NvbmZpZykpCisJCW1lbWNweShidWYsICZtdm5ldC0+Y29uZmlnICsgb2Zmc2V0 LCBsZW4pOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRfY29uZmlnKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAgICAgY29uc3Qgdm9pZCAqYnVm LCB1bnNpZ25lZCBpbnQgbGVuKQoreworCS8qIE5vIHdyaXRhYmxlIGNvbmZpZyBzdXBwb3J0dGVk IGJ5IG12bmV0ICovCit9CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2dlbmVyYXRpb24oc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2 X2dldF9kcnZkYXRhKG1kZXYpOworCisJcmV0dXJuIG12bmV0LT5nZW5lcmF0aW9uOworfQorCitz dGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2RldmljZV9vcHMgbWRldl92aXJ0aW9fb3Bz ID0geworCS5zZXRfdnFfYWRkcmVzcyAgICAgICAgID0gbXZuZXRfc2V0X3ZxX2FkZHJlc3MsCisJ LnNldF92cV9udW0gICAgICAgICAgICAgPSBtdm5ldF9zZXRfdnFfbnVtLAorCS5raWNrX3ZxICAg ICAgICAgICAgICAgID0gbXZuZXRfa2lja192cSwKKwkuc2V0X3ZxX2NiICAgICAgICAgICAgICA9 IG12bmV0X3NldF92cV9jYiwKKwkuc2V0X3ZxX3JlYWR5ICAgICAgICAgICA9IG12bmV0X3NldF92 cV9yZWFkeSwKKwkuZ2V0X3ZxX3JlYWR5ICAgICAgICAgICA9IG12bmV0X2dldF92cV9yZWFkeSwK Kwkuc2V0X3ZxX3N0YXRlICAgICAgICAgICA9IG12bmV0X3NldF92cV9zdGF0ZSwKKwkuZ2V0X3Zx X3N0YXRlICAgICAgICAgICA9IG12bmV0X2dldF92cV9zdGF0ZSwKKwkuZ2V0X3ZxX2FsaWduICAg ICAgICAgICA9IG12bmV0X2dldF92cV9hbGlnbiwKKwkuZ2V0X2ZlYXR1cmVzICAgICAgICAgICA9 IG12bmV0X2dldF9mZWF0dXJlcywKKwkuc2V0X2ZlYXR1cmVzICAgICAgICAgICA9IG12bmV0X3Nl dF9mZWF0dXJlcywKKwkuc2V0X2NvbmZpZ19jYiAgICAgICAgICA9IG12bmV0X3NldF9jb25maWdf Y2IsCisJLmdldF92cV9udW1fbWF4ICAgICAgICAgPSBtdm5ldF9nZXRfdnFfbnVtX21heCwKKwku Z2V0X2RldmljZV9pZCAgICAgICAgICA9IG12bmV0X2dldF9kZXZpY2VfaWQsCisJLmdldF92ZW5k b3JfaWQgICAgICAgICAgPSBtdm5ldF9nZXRfdmVuZG9yX2lkLAorCS5nZXRfc3RhdHVzICAgICAg ICAgICAgID0gbXZuZXRfZ2V0X3N0YXR1cywKKwkuc2V0X3N0YXR1cyAgICAgICAgICAgICA9IG12 bmV0X3NldF9zdGF0dXMsCisJLmdldF9jb25maWcgICAgICAgICAgICAgPSBtdm5ldF9nZXRfY29u ZmlnLAorCS5zZXRfY29uZmlnICAgICAgICAgICAgID0gbXZuZXRfc2V0X2NvbmZpZywKKwkuZ2V0 X2dlbmVyYXRpb24gICAgICAgICA9IG12bmV0X2dldF9nZW5lcmF0aW9uLAorfTsKKworc3RhdGlj IGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgbWRldl9mb3BzID0geworCS5vd25lciAgICAg ICAgICAgICAgICAgID0gVEhJU19NT0RVTEUsCisJLmRldl9hdHRyX2dyb3VwcyAgICAgICAgPSBt dm5ldF9kZXZfZ3JvdXBzLAorCS5tZGV2X2F0dHJfZ3JvdXBzICAgICAgID0gbWRldl9kZXZfZ3Jv dXBzLAorCS5zdXBwb3J0ZWRfdHlwZV9ncm91cHMgID0gbWRldl90eXBlX2dyb3VwcywKKwkuY3Jl YXRlICAgICAgICAgICAgICAgICA9IG12bmV0X2NyZWF0ZSwKKwkucmVtb3ZlCQkJPSBtdm5ldF9y ZW1vdmUsCit9OworCitzdGF0aWMgdm9pZCBtdm5ldF9kZXZpY2VfcmVsZWFzZShzdHJ1Y3QgZGV2 aWNlICpkZXYpCit7CisJZGV2X2RiZyhkZXYsICJtdm5ldDogcmVsZWFzZWRcbiIpOworfQorCitz dGF0aWMgaW50IF9faW5pdCBtdm5ldF9kZXZfaW5pdCh2b2lkKQoreworCWludCByZXQgPSAwOwor CisJcHJfaW5mbygibXZuZXRfZGV2OiAlc1xuIiwgX19mdW5jX18pOworCisJbWVtc2V0KCZtdm5l dF9kZXYsIDAsIHNpemVvZihtdm5ldF9kZXYpKTsKKworCWlkcl9pbml0KCZtdm5ldF9kZXYudmRf aWRyKTsKKworCW12bmV0X2Rldi52ZF9jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwg TVZORVRfQ0xBU1NfTkFNRSk7CisKKwlpZiAoSVNfRVJSKG12bmV0X2Rldi52ZF9jbGFzcykpIHsK KwkJcHJfZXJyKCJFcnJvcjogZmFpbGVkIHRvIHJlZ2lzdGVyIG12bmV0X2RldiBjbGFzc1xuIik7 CisJCXJldCA9IFBUUl9FUlIobXZuZXRfZGV2LnZkX2NsYXNzKTsKKwkJZ290byBmYWlsZWQxOwor CX0KKworCW12bmV0X2Rldi5kZXYuY2xhc3MgPSBtdm5ldF9kZXYudmRfY2xhc3M7CisJbXZuZXRf ZGV2LmRldi5yZWxlYXNlID0gbXZuZXRfZGV2aWNlX3JlbGVhc2U7CisJZGV2X3NldF9uYW1lKCZt dm5ldF9kZXYuZGV2LCAiJXMiLCBNVk5FVF9OQU1FKTsKKworCXJldCA9IGRldmljZV9yZWdpc3Rl cigmbXZuZXRfZGV2LmRldik7CisJaWYgKHJldCkKKwkJZ290byBmYWlsZWQyOworCisJcmV0ID0g bWRldl9yZWdpc3Rlcl9kZXZpY2UoJm12bmV0X2Rldi5kZXYsICZtZGV2X2ZvcHMpOworCWlmIChy ZXQpCisJCWdvdG8gZmFpbGVkMzsKKworCW11dGV4X2luaXQoJm1kZXZfbGlzdF9sb2NrKTsKKwlJ TklUX0xJU1RfSEVBRCgmbWRldl9kZXZpY2VzX2xpc3QpOworCisJZ290byBhbGxfZG9uZTsKKwor ZmFpbGVkMzoKKworCWRldmljZV91bnJlZ2lzdGVyKCZtdm5ldF9kZXYuZGV2KTsKK2ZhaWxlZDI6 CisJY2xhc3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCitmYWlsZWQxOgorYWxsX2Rv bmU6CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG12bmV0X2Rldl9leGl0 KHZvaWQpCit7CisJbXZuZXRfZGV2LmRldi5idXMgPSBOVUxMOworCW1kZXZfdW5yZWdpc3Rlcl9k ZXZpY2UoJm12bmV0X2Rldi5kZXYpOworCisJZGV2aWNlX3VucmVnaXN0ZXIoJm12bmV0X2Rldi5k ZXYpOworCWlkcl9kZXN0cm95KCZtdm5ldF9kZXYudmRfaWRyKTsKKwljbGFzc19kZXN0cm95KG12 bmV0X2Rldi52ZF9jbGFzcyk7CisJbXZuZXRfZGV2LnZkX2NsYXNzID0gTlVMTDsKKwlwcl9pbmZv KCJtdm5ldF9kZXY6IFVubG9hZGVkIVxuIik7Cit9CisKK21vZHVsZV9pbml0KG12bmV0X2Rldl9p bml0KQorbW9kdWxlX2V4aXQobXZuZXRfZGV2X2V4aXQpCisKK01PRFVMRV9MSUNFTlNFKCJHUEwg djIiKTsKK01PRFVMRV9JTkZPKHN1cHBvcnRlZCwgIlNpbXVsYXRlIGxvb3BiYWNrIGV0aGVybmV0 IGRldmljZSBvdmVyIG1kZXYiKTsKK01PRFVMRV9WRVJTSU9OKFZFUlNJT05fU1RSSU5HKTsKK01P RFVMRV9BVVRIT1IoRFJJVkVSX0FVVEhPUik7Ci0tIAoyLjE5LjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA== 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 8FCAFC49EAD for ; Tue, 5 Nov 2019 09:42:39 +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 71114217F5 for ; Tue, 5 Nov 2019 09:42:39 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 71114217F5 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 78EDE6E976; Tue, 5 Nov 2019 09:42:38 +0000 (UTC) Received: from us-smtp-delivery-1.mimecast.com (us-smtp-2.mimecast.com [207.211.31.81]) by gabe.freedesktop.org (Postfix) with ESMTPS id B753C6E975 for ; Tue, 5 Nov 2019 09:42:36 +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-367-QKyKdWrBOfGSQkBZ_IXJ0A-1; Tue, 05 Nov 2019 04:42:32 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CD414477; Tue, 5 Nov 2019 09:42:26 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-252.pek2.redhat.com [10.72.12.252]) by smtp.corp.redhat.com (Postfix) with ESMTP id 426A25C28D; Tue, 5 Nov 2019 09:39:35 +0000 (UTC) From: Jason Wang To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Date: Tue, 5 Nov 2019 17:32:40 +0800 Message-Id: <20191105093240.5135-7-jasowang@redhat.com> In-Reply-To: <20191105093240.5135-1-jasowang@redhat.com> References: <20191105093240.5135-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-MC-Unique: QKyKdWrBOfGSQkBZ_IXJ0A-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=1572946955; 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=syXqnRjGmjED8oe1bGzFfKezKmp2rR8du99TBlzamLo=; b=CNMgl8xu/5pD71WLCbBNd9U79ZU57t3pNhS11be9ACo4Z1keRjUwURbiRQRcuQiqaASfKl 3DHvurRrN5rkyxNV1S7U3pJGcAYoQDTLD0qccM4z3SXU+D0I5Fz7CSJjfu0prgdmdxfGlK PO0Bcx0mc0461sQIiihIPBAGWLfEbZk= Subject: [Intel-gfx] [PATCH V8 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Message-ID: <20191105093240.8TAKO2-sGxybTasTgxPnnNOZZ_E-cHmwS_aeC4gPD8Y@z> VGhpcyBzYW1wbGUgZHJpdmVyIGNyZWF0ZXMgbWRldiBkZXZpY2UgdGhhdCBzaW11bGF0ZSB2aXJ0 aW8gbmV0IGRldmljZQpvdmVyIHZpcnRpbyBtZGV2IHRyYW5zcG9ydC4gVGhlIGRldmljZSBpcyBp bXBsZW1lbnRlZCB0aHJvdWdoIHZyaW5naAphbmQgd29ya3F1ZXVlLiBBIGRldmljZSBzcGVjaWZp YyBkbWEgb3BzIGlzIHRvIG1ha2Ugc3VyZSBIVkEgaXMgdXNlZApkaXJlY3RseSBhcyB0aGUgSU9W QS4gVGhpcyBzaG91bGQgYmUgc3VmZmljaWVudCBmb3Iga2VybmVsIHZpcnRpbwpkcml2ZXIgdG8g d29yay4KCk9ubHkgJ3ZpcnRpbycgdHlwZSBpcyBzdXBwb3J0ZWQgcmlnaHQgbm93LiBJIHBsYW4g dG8gYWRkICd2aG9zdCcgdHlwZQpvbiB0b3Agd2hpY2ggcmVxdWlyZXMgc29tZSB2aXJ0dWFsIElP TU1VIGltcGxlbWVudGVkIGluIHRoaXMgc2FtcGxlCmRyaXZlci4KClNpZ25lZC1vZmYtYnk6IEph c29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAg ICAgICAgfCAgIDEgKwogc2FtcGxlcy9LY29uZmlnICAgICAgICAgICAgfCAgIDcgKwogc2FtcGxl cy92ZmlvLW1kZXYvTWFrZWZpbGUgfCAgIDEgKwogc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXQuYyAg fCA2ODUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogNCBmaWxlcyBjaGFu Z2VkLCA2OTQgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IHNhbXBsZXMvdmZpby1t ZGV2L212bmV0LmMKCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4 IGY2NjFkMTMzNDRkNi4uMzVlOTIwNGQ1YzY4IDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysg Yi9NQUlOVEFJTkVSUwpAQCAtMTcyNDgsNiArMTcyNDgsNyBAQCBGOglpbmNsdWRlL2xpbnV4L3Zp cnRpbyouaAogRjoJaW5jbHVkZS91YXBpL2xpbnV4L3ZpcnRpb18qLmgKIEY6CWRyaXZlcnMvY3J5 cHRvL3ZpcnRpby8KIEY6CW1tL2JhbGxvb25fY29tcGFjdGlvbi5jCitGOglzYW1wbGVzL3ZmaW8t bWRldi9tdm5ldC5jCiAKIFZJUlRJTyBCTE9DSyBBTkQgU0NTSSBEUklWRVJTCiBNOgkiTWljaGFl bCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+CmRpZmYgLS1naXQgYS9zYW1wbGVzL0tjb25m aWcgYi9zYW1wbGVzL0tjb25maWcKaW5kZXggYzhkYWNiNGRkYTgwLi5hMWExY2EyYzAwYjcgMTAw NjQ0Ci0tLSBhL3NhbXBsZXMvS2NvbmZpZworKysgYi9zYW1wbGVzL0tjb25maWcKQEAgLTEzMSw2 ICsxMzEsMTMgQEAgY29uZmlnIFNBTVBMRV9WRklPX01ERVZfTURQWQogCSAgbWVkaWF0ZWQgZGV2 aWNlLiAgSXQgaXMgYSBzaW1wbGUgZnJhbWVidWZmZXIgYW5kIHN1cHBvcnRzCiAJICB0aGUgcmVn aW9uIGRpc3BsYXkgaW50ZXJmYWNlIChWRklPX0dGWF9QTEFORV9UWVBFX1JFR0lPTikuCiAKK2Nv bmZpZyBTQU1QTEVfVklSVElPX01ERVZfTkVUCisgICAgICAgIHRyaXN0YXRlICJCdWlsZCB2aXJ0 aW8gbWRldiBuZXQgZXhhbXBsZSBtZWRpYXRlZCBkZXZpY2Ugc2FtcGxlIGNvZGUgLS0gbG9hZGFi bGUgbW9kdWxlcyBvbmx5IgorCWRlcGVuZHMgb24gVklSVElPX01ERVZfREVWSUNFICYmIFZIT1NU X1JJTkcgJiYgbQorCWhlbHAKKwkgIEJ1aWxkIGEgbmV0d29ya2luZyBzYW1wbGUgZGV2aWNlIGZv ciB1c2UgYXMgYSB2aXJ0aW8KKwkgIG1lZGlhdGVkIGRldmljZS4KKwogY29uZmlnIFNBTVBMRV9W RklPX01ERVZfTURQWV9GQgogCXRyaXN0YXRlICJCdWlsZCBWRklPIG1kcHkgZXhhbXBsZSBndWVz dCBmYmRldiBkcml2ZXIgLS0gbG9hZGFibGUgbW9kdWxlIG9ubHkiCiAJZGVwZW5kcyBvbiBGQiAm JiBtCmRpZmYgLS1naXQgYS9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZSBiL3NhbXBsZXMvdmZp by1tZGV2L01ha2VmaWxlCmluZGV4IDEwZDE3OWM0ZmRlYi4uZjM0YWY5MGVkMGEwIDEwMDY0NAot LS0gYS9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZQorKysgYi9zYW1wbGVzL3ZmaW8tbWRldi9N YWtlZmlsZQpAQCAtMywzICszLDQgQEAgb2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTVRU WSkgKz0gbXR0eS5vCiBvYmotJChDT05GSUdfU0FNUExFX1ZGSU9fTURFVl9NRFBZKSArPSBtZHB5 Lm8KIG9iai0kKENPTkZJR19TQU1QTEVfVkZJT19NREVWX01EUFlfRkIpICs9IG1kcHktZmIubwog b2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTUJPQ0hTKSArPSBtYm9jaHMubworb2JqLSQo Q09ORklHX1NBTVBMRV9WSVJUSU9fTURFVl9ORVQpICs9IG12bmV0Lm8KZGlmZiAtLWdpdCBhL3Nh bXBsZXMvdmZpby1tZGV2L212bmV0LmMgYi9zYW1wbGVzL3ZmaW8tbWRldi9tdm5ldC5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOGI0M2ZjYzc4YTY4Ci0tLSAvZGV2 L251bGwKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXQuYwpAQCAtMCwwICsxLDY4NSBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQorLyoKKyAqIE1lZGlhdGVk IHZpcnR1YWwgdmlydGlvLW5ldCBkZXZpY2UgZHJpdmVyLgorICoKKyAqIENvcHlyaWdodCAoYykg MjAxOSwgUmVkIEhhdCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiAgICAgQXV0aG9yOiBK YXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgorICoKKyAqIFNhbXBsZSBkcml2ZXIgdGhh dCBjcmVhdGVzIG1kZXYgZGV2aWNlIHRoYXQgc2ltdWxhdGVzIGV0aGVybmV0IGxvb3BiYWNrCisg KiBkZXZpY2UuCisgKgorICogVXNhZ2U6CisgKgorICogIyBtb2Rwcm9iZSB2aXJ0aW9fbWRldgor ICogIyBtb2Rwcm9iZSBtdm5ldAorICogIyBjZCAvc3lzL2RldmljZXMvdmlydHVhbC9tdm5ldC9t dm5ldC9tZGV2X3N1cHBvcnRlZF90eXBlcy9tdm5ldC12aXJ0aW8KKyAqICMgZWNobyAiODNiOGY0 ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxIiA+IC4vY3JlYXRlCisgKiAjIGNkIGRldmlj ZXMvODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxCisgKiAjIGxzIC1kIHZpcnRp bzAKKyAqIHZpcnRpbzAKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvcG9s bC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgor I2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKyNpbmNsdWRlIDxsaW51eC91dWlkLmg+CisjaW5jbHVk ZSA8bGludXgvaW9tbXUuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNmcy5oPgorI2luY2x1ZGUgPGxp bnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgorI2luY2x1ZGUgPGxp bnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92cmluZ2guaD4KKyNpbmNsdWRlIDxsaW51eC9t ZGV2X3ZpcnRpb19vcHMuaD4KKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19jb25maWcuaD4K KyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19uZXQuaD4KKworI2RlZmluZSBWRVJTSU9OX1NU UklORyAgIjAuMSIKKyNkZWZpbmUgRFJJVkVSX0FVVEhPUiAgICJSZWQgSGF0IENvcnBvcmF0aW9u IgorCisjZGVmaW5lIE1WTkVUX0NMQVNTX05BTUUgIm12bmV0IgorI2RlZmluZSBNVk5FVF9OQU1F ICAgICAgICJtdm5ldCIKKworLyoKKyAqIEdsb2JhbCBTdHJ1Y3R1cmVzCisgKi8KKworc3RhdGlj IHN0cnVjdCBtdm5ldF9kZXYgeworCXN0cnVjdCBjbGFzcwkqdmRfY2xhc3M7CisJc3RydWN0IGlk cgl2ZF9pZHI7CisJc3RydWN0IGRldmljZQlkZXY7Cit9IG12bmV0X2RldjsKKworc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSB7CisJc3RydWN0IHZyaW5naCB2cmluZzsKKwlzdHJ1Y3QgdnJpbmdoX2tp b3YgaW92OworCXVuc2lnbmVkIHNob3J0IGhlYWQ7CisJYm9vbCByZWFkeTsKKwl1NjQgZGVzY19h ZGRyOworCXU2NCBkZXZpY2VfYWRkcjsKKwl1NjQgZHJpdmVyX2FkZHI7CisJdTMyIG51bTsKKwl2 b2lkICpwcml2YXRlOworCWlycXJldHVybl90ICgqY2IpKHZvaWQgKmRhdGEpOworfTsKKworI2Rl ZmluZSBNVk5FVF9RVUVVRV9BTElHTiBQQUdFX1NJWkUKKyNkZWZpbmUgTVZORVRfUVVFVUVfTUFY IDI1NgorI2RlZmluZSBNVk5FVF9ERVZJQ0VfSUQgMHgxCisjZGVmaW5lIE1WTkVUX1ZFTkRPUl9J RCAwCisKK3U2NCBtdm5ldF9mZWF0dXJlcyA9ICgxVUxMIDw8IFZJUlRJT19GX0FOWV9MQVlPVVQp IHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9WRVJTSU9OXzEpIHwKKwkJICAgICAoMVVMTCA8 PCBWSVJUSU9fRl9JT01NVV9QTEFURk9STSk7CisKKy8qIFN0YXRlIG9mIGVhY2ggbWRldiBkZXZp Y2UgKi8KK3N0cnVjdCBtdm5ldF9zdGF0ZSB7CisJc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB2cXNb Ml07CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7CisJc3BpbmxvY2tfdCBsb2NrOworCXN0cnVj dCBtZGV2X2RldmljZSAqbWRldjsKKwlzdHJ1Y3QgdmlydGlvX25ldF9jb25maWcgY29uZmlnOwor CXZvaWQgKmJ1ZmZlcjsKKwl1MzIgc3RhdHVzOworCXUzMiBnZW5lcmF0aW9uOworCXU2NCBmZWF0 dXJlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5leHQ7Cit9OworCitzdGF0aWMgc3RydWN0IG11dGV4 IG1kZXZfbGlzdF9sb2NrOworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgbWRldl9kZXZpY2VzX2xp c3Q7CisKK3N0YXRpYyB2b2lkIG12bmV0X3F1ZXVlX3JlYWR5KHN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQsIHVuc2lnbmVkIGludCBpZHgpCit7CisJc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSAqdnEg PSAmbXZuZXQtPnZxc1tpZHhdOworCWludCByZXQ7CisKKwlyZXQgPSB2cmluZ2hfaW5pdF9rZXJu KCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVVRV9NQVgsCisJCQkgICAgICAg ZmFsc2UsIChzdHJ1Y3QgdnJpbmdfZGVzYyAqKXZxLT5kZXNjX2FkZHIsCisJCQkgICAgICAgKHN0 cnVjdCB2cmluZ19hdmFpbCAqKXZxLT5kcml2ZXJfYWRkciwKKwkJCSAgICAgICAoc3RydWN0IHZy aW5nX3VzZWQgKil2cS0+ZGV2aWNlX2FkZHIpOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF92cV9y ZXNldChzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSkKK3sKKwl2cS0+cmVhZHkgPSAwOworCXZx LT5kZXNjX2FkZHIgPSAwOworCXZxLT5kcml2ZXJfYWRkciA9IDA7CisJdnEtPmRldmljZV9hZGRy ID0gMDsKKwl2cS0+Y2IgPSBOVUxMOworCXZxLT5wcml2YXRlID0gTlVMTDsKKwl2cmluZ2hfaW5p dF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVVRV9NQVgsCisJCQlm YWxzZSwgMCwgMCwgMCk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3Jlc2V0KHN0cnVjdCBtdm5l dF9zdGF0ZSAqbXZuZXQpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKQor CQltdm5ldF92cV9yZXNldCgmbXZuZXQtPnZxc1tpXSk7CisKKwltdm5ldC0+ZmVhdHVyZXMgPSAw OworCW12bmV0LT5zdGF0dXMgPSAwOworCSsrbXZuZXQtPmdlbmVyYXRpb247Cit9CisKK3N0YXRp YyB2b2lkIG12bmV0X3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQoreworCXN0cnVjdCBt dm5ldF9zdGF0ZSAqbXZuZXQgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0CisJCQkJCQkgbXZu ZXRfc3RhdGUsIHdvcmspOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnR4cSA9ICZtdm5ldC0+ dnFzWzFdOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnJ4cSA9ICZtdm5ldC0+dnFzWzBdOwor CXNpemVfdCByZWFkLCB3cml0ZSwgdG90YWxfd3JpdGU7CisJaW50IGVycjsKKwlpbnQgcGt0cyA9 IDA7CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKworCWlmICghdHhxLT5yZWFkeSB8fCAh cnhxLT5yZWFkeSkKKwkJZ290byBvdXQ7CisKKwl3aGlsZSAodHJ1ZSkgeworCQl0b3RhbF93cml0 ZSA9IDA7CisJCWVyciA9IHZyaW5naF9nZXRkZXNjX2tlcm4oJnR4cS0+dnJpbmcsICZ0eHEtPmlv diwgTlVMTCwKKwkJCQkJICAmdHhxLT5oZWFkLCBHRlBfQVRPTUlDKTsKKwkJaWYgKGVyciA8PSAw KQorCQkJYnJlYWs7CisKKwkJZXJyID0gdnJpbmdoX2dldGRlc2Nfa2VybigmcnhxLT52cmluZywg TlVMTCwgJnJ4cS0+aW92LAorCQkJCQkgICZyeHEtPmhlYWQsIEdGUF9BVE9NSUMpOworCQlpZiAo ZXJyIDw9IDApIHsKKwkJCXZyaW5naF9jb21wbGV0ZV9rZXJuKCZ0eHEtPnZyaW5nLCB0eHEtPmhl YWQsIDApOworCQkJYnJlYWs7CisJCX0KKworCQl3aGlsZSAodHJ1ZSkgeworCQkJcmVhZCA9IHZy aW5naF9pb3ZfcHVsbF9rZXJuKCZ0eHEtPmlvdiwgbXZuZXQtPmJ1ZmZlciwKKwkJCQkJCSAgICBQ QUdFX1NJWkUpOworCQkJaWYgKHJlYWQgPD0gMCkKKwkJCQlicmVhazsKKworCQkJd3JpdGUgPSB2 cmluZ2hfaW92X3B1c2hfa2VybigmcnhxLT5pb3YsIG12bmV0LT5idWZmZXIsCisJCQkJCQkgICAg IHJlYWQpOworCQkJaWYgKHdyaXRlIDw9IDApCisJCQkJYnJlYWs7CisKKwkJCXRvdGFsX3dyaXRl ICs9IHdyaXRlOworCQl9CisKKwkJLyogTWFrZSBzdXJlIGRhdGEgaXMgd3JvdGUgYmVmb3JlIGFk dmFuY2luZyBpbmRleCAqLworCQlzbXBfd21iKCk7CisKKwkJdnJpbmdoX2NvbXBsZXRlX2tlcm4o JnR4cS0+dnJpbmcsIHR4cS0+aGVhZCwgMCk7CisJCXZyaW5naF9jb21wbGV0ZV9rZXJuKCZyeHEt PnZyaW5nLCByeHEtPmhlYWQsIHRvdGFsX3dyaXRlKTsKKworCQkvKiBNYWtlIHN1cmUgdXNlZCBp cyB2aXNpYmxlIGJlZm9yZSByYXNpbmcgdGhlIGludGVycnVwdC4gKi8KKwkJc21wX3dtYigpOwor CisJCWxvY2FsX2JoX2Rpc2FibGUoKTsKKwkJaWYgKHR4cS0+Y2IpCisJCQl0eHEtPmNiKHR4cS0+ cHJpdmF0ZSk7CisJCWlmIChyeHEtPmNiKQorCQkJcnhxLT5jYihyeHEtPnByaXZhdGUpOworCQls b2NhbF9iaF9lbmFibGUoKTsKKworCQlpZiAoKytwa3RzID4gNCkgeworCQkJc2NoZWR1bGVfd29y aygmbXZuZXQtPndvcmspOworCQkJZ290byBvdXQ7CisJCX0KKwl9CisKK291dDoKKwlzcGluX3Vu bG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgZG1hX2FkZHJfdCBtdm5ldF9tYXBfcGFn ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCSB1bnNpZ25lZCBs b25nIG9mZnNldCwgc2l6ZV90IHNpemUsCisJCQkJIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp ciwKKwkJCQkgdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwkvKiBWcmluZ2ggY2FuIG9ubHkgdXNl IEhWQSAqLworCXJldHVybiAoZG1hX2FkZHJfdCkocGFnZV9hZGRyZXNzKHBhZ2UpICsgb2Zmc2V0 KTsKK30KKworc3RhdGljIHZvaWQgbXZuZXRfdW5tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYs IGRtYV9hZGRyX3QgZG1hX2FkZHIsCisJCQkgICAgIHNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRh X2RpcmVjdGlvbiBkaXIsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCit7Cit9CisKK3N0 YXRpYyB2b2lkICptdm5ldF9hbGxvY19jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVf dCBzaXplLAorCQkJCSAgZG1hX2FkZHJfdCAqZG1hX2FkZHIsIGdmcF90IGZsYWcsCisJCQkJICB1 bnNpZ25lZCBsb25nIGF0dHJzKQoreworCXZvaWQgKmFkZHIgPSBrbWFsbG9jKHNpemUsIGZsYWcp OworCisJaWYgKGFkZHIgPT0gTlVMTCkKKwkJKmRtYV9hZGRyID0gRE1BX01BUFBJTkdfRVJST1I7 CisJZWxzZQorCQkqZG1hX2FkZHIgPSAoZG1hX2FkZHJfdCkgYWRkcjsKKworCXJldHVybiBhZGRy OworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9mcmVlX2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmRl diwgc2l6ZV90IHNpemUsCisJCQkJdm9pZCAqdmFkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsCisJ CQkJdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwlrZnJlZSgodm9pZCAqKWRtYV9hZGRyKTsKK30K Kworc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyBtdm5ldF9kbWFfb3BzID0geworCS5t YXBfcGFnZSA9IG12bmV0X21hcF9wYWdlLAorCS51bm1hcF9wYWdlID0gbXZuZXRfdW5tYXBfcGFn ZSwKKwkuYWxsb2MgPSBtdm5ldF9hbGxvY19jb2hlcmVudCwKKwkuZnJlZSA9IG12bmV0X2ZyZWVf Y29oZXJlbnQsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2RldmljZV9v cHMgbWRldl92aXJ0aW9fb3BzOworCitzdGF0aWMgaW50IG12bmV0X2NyZWF0ZShzdHJ1Y3Qga29i amVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9z dGF0ZSAqbXZuZXQ7CisJc3RydWN0IHZpcnRpb19uZXRfY29uZmlnICpjb25maWc7CisJc3RydWN0 IGRldmljZSAqZGV2ID0gbWRldl9kZXYobWRldik7CisKKwlpZiAoIW1kZXYpCisJCXJldHVybiAt RUlOVkFMOworCisJbXZuZXQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgbXZuZXRfc3RhdGUpLCBH RlBfS0VSTkVMKTsKKwlpZiAobXZuZXQgPT0gTlVMTCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlt dm5ldC0+YnVmZmVyID0ga21hbGxvYyhQQUdFX1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghbXZu ZXQtPmJ1ZmZlcikgeworCQlrZnJlZShtdm5ldCk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKwor CWNvbmZpZyA9ICZtdm5ldC0+Y29uZmlnOworCWNvbmZpZy0+bXR1ID0gMTUwMDsKKwljb25maWct PnN0YXR1cyA9IFZJUlRJT19ORVRfU19MSU5LX1VQOworCWV0aF9yYW5kb21fYWRkcihjb25maWct Pm1hYyk7CisKKwlJTklUX1dPUksoJm12bmV0LT53b3JrLCBtdm5ldF93b3JrKTsKKworCXNwaW5f bG9ja19pbml0KCZtdm5ldC0+bG9jayk7CisJbXZuZXQtPm1kZXYgPSBtZGV2OworCW1kZXZfc2V0 X2RydmRhdGEobWRldiwgbXZuZXQpOworCisJbXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOwor CWxpc3RfYWRkKCZtdm5ldC0+bmV4dCwgJm1kZXZfZGV2aWNlc19saXN0KTsKKwltdXRleF91bmxv Y2soJm1kZXZfbGlzdF9sb2NrKTsKKworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklU X01BU0soNjQpOworCXNldF9kbWFfb3BzKGRldiwgJm12bmV0X2RtYV9vcHMpOworCisJbWRldl9z ZXRfdmlydGlvX29wcyhtZGV2LCAmbWRldl92aXJ0aW9fb3BzKTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgaW50IG12bmV0X3JlbW92ZShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7CisJ c3RydWN0IG12bmV0X3N0YXRlICptZHMsICp0bXBfbWRzOworCXN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCWludCByZXQgPSAtRUlOVkFMOworCisJ bXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht ZHMsIHRtcF9tZHMsICZtZGV2X2RldmljZXNfbGlzdCwgbmV4dCkgeworCQlpZiAobXZuZXQgPT0g bWRzKSB7CisJCQlsaXN0X2RlbCgmbXZuZXQtPm5leHQpOworCQkJbWRldl9zZXRfZHJ2ZGF0YSht ZGV2LCBOVUxMKTsKKwkJCWtmcmVlKG12bmV0LT5idWZmZXIpOworCQkJa2ZyZWUobXZuZXQpOwor CQkJcmV0ID0gMDsKKwkJCWJyZWFrOworCQl9CisJfQorCW11dGV4X3VubG9jaygmbWRldl9saXN0 X2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHNzaXplX3QKK3NhbXBsZV9tdm5l dF9kZXZfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICph dHRyLAorCQkgICAgIGNoYXIgKmJ1ZikKK3sKKwlpZiAobWRldl9mcm9tX2RldihkZXYpKQorCQly ZXR1cm4gc3ByaW50ZihidWYsICJUaGlzIGlzIE1ERVYgJXNcbiIsIGRldl9uYW1lKGRldikpOwor CisJcmV0dXJuIHNwcmludGYoYnVmLCAiXG4iKTsKK30KKworc3RhdGljIERFVklDRV9BVFRSX1JP KHNhbXBsZV9tdm5ldF9kZXYpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqbXZuZXRfZGV2 X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tdm5ldF9kZXYuYXR0ciwKKwlOVUxMLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgbXZuZXRfZGV2X2dyb3Vw ID0geworCS5uYW1lICA9ICJtdm5ldF9kZXYiLAorCS5hdHRycyA9IG12bmV0X2Rldl9hdHRycywK K307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptdm5ldF9kZXZfZ3Jv dXBzW10gPSB7CisJJm12bmV0X2Rldl9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIHNzaXpl X3QKK3NhbXBsZV9tZGV2X2Rldl9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmlj ZV9hdHRyaWJ1dGUgKmF0dHIsCisJCSAgICAgY2hhciAqYnVmKQoreworCWlmIChtZGV2X2Zyb21f ZGV2KGRldikpCisJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xuIiwgZGV2 X25hbWUoZGV2KSk7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitzdGF0aWMg REVWSUNFX0FUVFJfUk8oc2FtcGxlX21kZXZfZGV2KTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1 dGUgKm1kZXZfZGV2X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tZGV2X2Rldi5hdHRy LAorCU5VTEwsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBtZGV2 X2Rldl9ncm91cCA9IHsKKwkubmFtZSAgPSAidmVuZG9yIiwKKwkuYXR0cnMgPSBtZGV2X2Rldl9h dHRycywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X2Rl dl9ncm91cHNbXSA9IHsKKwkmbWRldl9kZXZfZ3JvdXAsCisJTlVMTCwKK307CisKKyNkZWZpbmUg TVZORVRfU1RSSU5HX0xFTiAxNgorCitzdGF0aWMgc3NpemVfdAorbmFtZV9zaG93KHN0cnVjdCBr b2JqZWN0ICprb2JqLCBzdHJ1Y3QgZGV2aWNlICpkZXYsIGNoYXIgKmJ1ZikKK3sKKwljaGFyIG5h bWVbTVZORVRfU1RSSU5HX0xFTl07CisJY29uc3QgY2hhciAqbmFtZV9zdHIgPSAidmlydGlvLW5l dCI7CisKKwlzbnByaW50ZihuYW1lLCBNVk5FVF9TVFJJTkdfTEVOLCAiJXMiLCBkZXZfZHJpdmVy X3N0cmluZyhkZXYpKTsKKwlpZiAoIXN0cmNtcChrb2JqLT5uYW1lLCBuYW1lKSkKKwkJcmV0dXJu IHNwcmludGYoYnVmLCAiJXNcbiIsIG5hbWVfc3RyKTsKKworCXJldHVybiAtRUlOVkFMOworfQor CitzdGF0aWMgTURFVl9UWVBFX0FUVFJfUk8obmFtZSk7CisKK3N0YXRpYyBzc2l6ZV90CithdmFp bGFibGVfaW5zdGFuY2VzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBkZXZpY2Ug KmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBJTlRfTUFY KTsKK30KKworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGF2YWlsYWJsZV9pbnN0YW5jZXMpOwor CitzdGF0aWMgc3NpemVfdCBkZXZpY2VfYXBpX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0 cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgICBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmlu dGYoYnVmLCAiJXNcbiIsIFZJUlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HKTsKK30KKworc3Rh dGljIE1ERVZfVFlQRV9BVFRSX1JPKGRldmljZV9hcGkpOworCitzdGF0aWMgc3RydWN0IGF0dHJp YnV0ZSAqbWRldl90eXBlc19hdHRyc1tdID0geworCSZtZGV2X3R5cGVfYXR0cl9uYW1lLmF0dHIs CisJJm1kZXZfdHlwZV9hdHRyX2RldmljZV9hcGkuYXR0ciwKKwkmbWRldl90eXBlX2F0dHJfYXZh aWxhYmxlX2luc3RhbmNlcy5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGF0dHJp YnV0ZV9ncm91cCBtZGV2X3R5cGVfZ3JvdXAgPSB7CisJLm5hbWUgID0gInZpcnRpbyIsCisJLmF0 dHJzID0gbWRldl90eXBlc19hdHRycywKK307CisKKy8qIFRCRDogInZob3N0IiB0eXBlICovCisK K3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X3R5cGVfZ3JvdXBzW10gPSB7CisJ Jm1kZXZfdHlwZV9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIGludCBtdm5ldF9zZXRfdnFf YWRkcmVzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZHgsCisJCQkJdTY0IGRlc2Nf YXJlYSwgdTY0IGRyaXZlcl9hcmVhLCB1NjQgZGV2aWNlX2FyZWEpCit7CisJc3RydWN0IG12bmV0 X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisJc3RydWN0IG12bmV0X3Zp cnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCisJdnEtPmRlc2NfYWRkciA9IGRlc2Nf YXJlYTsKKwl2cS0+ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKKwl2cS0+ZGV2aWNlX2FkZHIg PSBkZXZpY2VfYXJlYTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRf dnFfbnVtKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgdTMyIG51bSkKK3sKKwlz dHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1 Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+bnVtID0g bnVtOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9raWNrX3ZxKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwgdTE2IGlkeCkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRf ZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFz W2lkeF07CisKKwlpZiAodnEtPnJlYWR5KQorCQlzY2hlZHVsZV93b3JrKCZtdm5ldC0+d29yayk7 Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3NldF92cV9jYihzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYsIHUxNiBpZHgsCisJCQkgICAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpjYikKK3sK KwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlz dHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+Y2Ig PSBjYi0+Y2FsbGJhY2s7CisJdnEtPnByaXZhdGUgPSBjYi0+cHJpdmF0ZTsKK30KKworc3RhdGlj IHZvaWQgbXZuZXRfc2V0X3ZxX3JlYWR5KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlk eCwgYm9vbCByZWFkeSkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRf ZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFz W2lkeF07CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKwl2cS0+cmVhZHkgPSByZWFkeTsK KwlpZiAodnEtPnJlYWR5KQorCQltdm5ldF9xdWV1ZV9yZWFkeShtdm5ldCwgaWR4KTsKKwlzcGlu X3VubG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgYm9vbCBtdm5ldF9nZXRfdnFfcmVh ZHkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0cnVjdCBtdm5ldF9z dGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0 cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKworCXJldHVybiB2cS0+cmVhZHk7Cit9CisK K3N0YXRpYyBpbnQgbXZuZXRfc2V0X3ZxX3N0YXRlKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwg dTE2IGlkeCwgdTY0IHN0YXRlKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2 X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0 LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJc3Bpbl9s b2NrKCZtdm5ldC0+bG9jayk7CisJdnJoLT5sYXN0X2F2YWlsX2lkeCA9IHN0YXRlOworCXNwaW5f dW5sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHU2NCBtdm5l dF9nZXRfdnFfc3RhdGUoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0 cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVj dCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdo ICp2cmggPSAmdnEtPnZyaW5nOworCisJcmV0dXJuIHZyaC0+bGFzdF9hdmFpbF9pZHg7Cit9CisK K3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX2FsaWduKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikK K3sKKwlyZXR1cm4gTVZORVRfUVVFVUVfQUxJR047Cit9CisKK3N0YXRpYyB1NjQgbXZuZXRfZ2V0 X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gbXZuZXRfZmVh dHVyZXM7Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdTY0IGZlYXR1cmVzKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJLyogRE1BIG1hcHBpbmcgbXVzdCBiZSBkb25l IGJ5IGRyaXZlciAqLworCWlmICghKGZlYXR1cmVzICYgKDFVTEwgPDwgVklSVElPX0ZfSU9NTVVf UExBVEZPUk0pKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltdm5ldC0+ZmVhdHVyZXMgPSBmZWF0 dXJlcyAmIG12bmV0X2ZlYXR1cmVzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIG12 bmV0X3NldF9jb25maWdfY2Ioc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LAorCQkJCXN0cnVjdCB2 aXJ0aW9fbWRldl9jYWxsYmFjayAqY2IpCit7CisJLyogV2UgZG9uJ3Qgc3VwcG9ydCBjb25maWcg aW50ZXJydXB0ICovCit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX251bV9tYXgoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2KQoreworCXJldHVybiBNVk5FVF9RVUVVRV9NQVg7Cit9CisKK3N0 YXRpYyB1MzIgbXZuZXRfZ2V0X2RldmljZV9pZChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7 CisJcmV0dXJuIE1WTkVUX0RFVklDRV9JRDsKK30KKworc3RhdGljIHUzMiBtdm5ldF9nZXRfdmVu ZG9yX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gTVZORVRfVkVORE9S X0lEOworfQorCitzdGF0aWMgdTggbXZuZXRfZ2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYpCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEo bWRldik7CisKKwlyZXR1cm4gbXZuZXQtPnN0YXR1czsKK30KKworc3RhdGljIHZvaWQgbXZuZXRf c2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cykKK3sKKwlzdHJ1 Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKworCW12bmV0 LT5zdGF0dXMgPSBzdGF0dXM7CisKKwlpZiAoc3RhdHVzID09IDApIHsKKwkJc3Bpbl9sb2NrKCZt dm5ldC0+bG9jayk7CisJCW12bmV0X3Jlc2V0KG12bmV0KTsKKwkJc3Bpbl91bmxvY2soJm12bmV0 LT5sb2NrKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2dldF9jb25maWcoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAorCQkJICAgICB2b2lkICpidWYs IHVuc2lnbmVkIGludCBsZW4pCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZf Z2V0X2RydmRhdGEobWRldik7CisKKwlpZiAob2Zmc2V0ICsgbGVuIDwgc2l6ZW9mKHN0cnVjdCB2 aXJ0aW9fbmV0X2NvbmZpZykpCisJCW1lbWNweShidWYsICZtdm5ldC0+Y29uZmlnICsgb2Zmc2V0 LCBsZW4pOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRfY29uZmlnKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAgICAgY29uc3Qgdm9pZCAqYnVm LCB1bnNpZ25lZCBpbnQgbGVuKQoreworCS8qIE5vIHdyaXRhYmxlIGNvbmZpZyBzdXBwb3J0dGVk IGJ5IG12bmV0ICovCit9CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2dlbmVyYXRpb24oc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2 X2dldF9kcnZkYXRhKG1kZXYpOworCisJcmV0dXJuIG12bmV0LT5nZW5lcmF0aW9uOworfQorCitz dGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2RldmljZV9vcHMgbWRldl92aXJ0aW9fb3Bz ID0geworCS5zZXRfdnFfYWRkcmVzcyAgICAgICAgID0gbXZuZXRfc2V0X3ZxX2FkZHJlc3MsCisJ LnNldF92cV9udW0gICAgICAgICAgICAgPSBtdm5ldF9zZXRfdnFfbnVtLAorCS5raWNrX3ZxICAg ICAgICAgICAgICAgID0gbXZuZXRfa2lja192cSwKKwkuc2V0X3ZxX2NiICAgICAgICAgICAgICA9 IG12bmV0X3NldF92cV9jYiwKKwkuc2V0X3ZxX3JlYWR5ICAgICAgICAgICA9IG12bmV0X3NldF92 cV9yZWFkeSwKKwkuZ2V0X3ZxX3JlYWR5ICAgICAgICAgICA9IG12bmV0X2dldF92cV9yZWFkeSwK Kwkuc2V0X3ZxX3N0YXRlICAgICAgICAgICA9IG12bmV0X3NldF92cV9zdGF0ZSwKKwkuZ2V0X3Zx X3N0YXRlICAgICAgICAgICA9IG12bmV0X2dldF92cV9zdGF0ZSwKKwkuZ2V0X3ZxX2FsaWduICAg ICAgICAgICA9IG12bmV0X2dldF92cV9hbGlnbiwKKwkuZ2V0X2ZlYXR1cmVzICAgICAgICAgICA9 IG12bmV0X2dldF9mZWF0dXJlcywKKwkuc2V0X2ZlYXR1cmVzICAgICAgICAgICA9IG12bmV0X3Nl dF9mZWF0dXJlcywKKwkuc2V0X2NvbmZpZ19jYiAgICAgICAgICA9IG12bmV0X3NldF9jb25maWdf Y2IsCisJLmdldF92cV9udW1fbWF4ICAgICAgICAgPSBtdm5ldF9nZXRfdnFfbnVtX21heCwKKwku Z2V0X2RldmljZV9pZCAgICAgICAgICA9IG12bmV0X2dldF9kZXZpY2VfaWQsCisJLmdldF92ZW5k b3JfaWQgICAgICAgICAgPSBtdm5ldF9nZXRfdmVuZG9yX2lkLAorCS5nZXRfc3RhdHVzICAgICAg ICAgICAgID0gbXZuZXRfZ2V0X3N0YXR1cywKKwkuc2V0X3N0YXR1cyAgICAgICAgICAgICA9IG12 bmV0X3NldF9zdGF0dXMsCisJLmdldF9jb25maWcgICAgICAgICAgICAgPSBtdm5ldF9nZXRfY29u ZmlnLAorCS5zZXRfY29uZmlnICAgICAgICAgICAgID0gbXZuZXRfc2V0X2NvbmZpZywKKwkuZ2V0 X2dlbmVyYXRpb24gICAgICAgICA9IG12bmV0X2dldF9nZW5lcmF0aW9uLAorfTsKKworc3RhdGlj IGNvbnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgbWRldl9mb3BzID0geworCS5vd25lciAgICAg ICAgICAgICAgICAgID0gVEhJU19NT0RVTEUsCisJLmRldl9hdHRyX2dyb3VwcyAgICAgICAgPSBt dm5ldF9kZXZfZ3JvdXBzLAorCS5tZGV2X2F0dHJfZ3JvdXBzICAgICAgID0gbWRldl9kZXZfZ3Jv dXBzLAorCS5zdXBwb3J0ZWRfdHlwZV9ncm91cHMgID0gbWRldl90eXBlX2dyb3VwcywKKwkuY3Jl YXRlICAgICAgICAgICAgICAgICA9IG12bmV0X2NyZWF0ZSwKKwkucmVtb3ZlCQkJPSBtdm5ldF9y ZW1vdmUsCit9OworCitzdGF0aWMgdm9pZCBtdm5ldF9kZXZpY2VfcmVsZWFzZShzdHJ1Y3QgZGV2 aWNlICpkZXYpCit7CisJZGV2X2RiZyhkZXYsICJtdm5ldDogcmVsZWFzZWRcbiIpOworfQorCitz dGF0aWMgaW50IF9faW5pdCBtdm5ldF9kZXZfaW5pdCh2b2lkKQoreworCWludCByZXQgPSAwOwor CisJcHJfaW5mbygibXZuZXRfZGV2OiAlc1xuIiwgX19mdW5jX18pOworCisJbWVtc2V0KCZtdm5l dF9kZXYsIDAsIHNpemVvZihtdm5ldF9kZXYpKTsKKworCWlkcl9pbml0KCZtdm5ldF9kZXYudmRf aWRyKTsKKworCW12bmV0X2Rldi52ZF9jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwg TVZORVRfQ0xBU1NfTkFNRSk7CisKKwlpZiAoSVNfRVJSKG12bmV0X2Rldi52ZF9jbGFzcykpIHsK KwkJcHJfZXJyKCJFcnJvcjogZmFpbGVkIHRvIHJlZ2lzdGVyIG12bmV0X2RldiBjbGFzc1xuIik7 CisJCXJldCA9IFBUUl9FUlIobXZuZXRfZGV2LnZkX2NsYXNzKTsKKwkJZ290byBmYWlsZWQxOwor CX0KKworCW12bmV0X2Rldi5kZXYuY2xhc3MgPSBtdm5ldF9kZXYudmRfY2xhc3M7CisJbXZuZXRf ZGV2LmRldi5yZWxlYXNlID0gbXZuZXRfZGV2aWNlX3JlbGVhc2U7CisJZGV2X3NldF9uYW1lKCZt dm5ldF9kZXYuZGV2LCAiJXMiLCBNVk5FVF9OQU1FKTsKKworCXJldCA9IGRldmljZV9yZWdpc3Rl cigmbXZuZXRfZGV2LmRldik7CisJaWYgKHJldCkKKwkJZ290byBmYWlsZWQyOworCisJcmV0ID0g bWRldl9yZWdpc3Rlcl9kZXZpY2UoJm12bmV0X2Rldi5kZXYsICZtZGV2X2ZvcHMpOworCWlmIChy ZXQpCisJCWdvdG8gZmFpbGVkMzsKKworCW11dGV4X2luaXQoJm1kZXZfbGlzdF9sb2NrKTsKKwlJ TklUX0xJU1RfSEVBRCgmbWRldl9kZXZpY2VzX2xpc3QpOworCisJZ290byBhbGxfZG9uZTsKKwor ZmFpbGVkMzoKKworCWRldmljZV91bnJlZ2lzdGVyKCZtdm5ldF9kZXYuZGV2KTsKK2ZhaWxlZDI6 CisJY2xhc3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCitmYWlsZWQxOgorYWxsX2Rv bmU6CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG12bmV0X2Rldl9leGl0 KHZvaWQpCit7CisJbXZuZXRfZGV2LmRldi5idXMgPSBOVUxMOworCW1kZXZfdW5yZWdpc3Rlcl9k ZXZpY2UoJm12bmV0X2Rldi5kZXYpOworCisJZGV2aWNlX3VucmVnaXN0ZXIoJm12bmV0X2Rldi5k ZXYpOworCWlkcl9kZXN0cm95KCZtdm5ldF9kZXYudmRfaWRyKTsKKwljbGFzc19kZXN0cm95KG12 bmV0X2Rldi52ZF9jbGFzcyk7CisJbXZuZXRfZGV2LnZkX2NsYXNzID0gTlVMTDsKKwlwcl9pbmZv KCJtdm5ldF9kZXY6IFVubG9hZGVkIVxuIik7Cit9CisKK21vZHVsZV9pbml0KG12bmV0X2Rldl9p bml0KQorbW9kdWxlX2V4aXQobXZuZXRfZGV2X2V4aXQpCisKK01PRFVMRV9MSUNFTlNFKCJHUEwg djIiKTsKK01PRFVMRV9JTkZPKHN1cHBvcnRlZCwgIlNpbXVsYXRlIGxvb3BiYWNrIGV0aGVybmV0 IGRldmljZSBvdmVyIG1kZXYiKTsKK01PRFVMRV9WRVJTSU9OKFZFUlNJT05fU1RSSU5HKTsKK01P RFVMRV9BVVRIT1IoRFJJVkVSX0FVVEhPUik7Ci0tIAoyLjE5LjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeA==