From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Jason Wang Subject: [PATCH V12 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Mon, 18 Nov 2019 14:17:03 +0800 Message-Id: <20191118061703.8669-7-jasowang@redhat.com> In-Reply-To: <20191118061703.8669-1-jasowang@redhat.com> References: <20191118061703.8669-1-jasowang@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Sender: netdev-owner@vger.kernel.org List-ID: To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, cohuck@redhat.com, maxime.coquelin@redhat.com, cunming.liang@intel.com, zhihong.wang@intel.com, rob.miller@broadcom.com, xiao.w.wang@intel.com, haotian.wang@sifive.com, zhenyuw@linux.intel.com, zhi.a.wang@intel.com, jani.nikula@linux.intel.com, joonas.lahtinen@linux.intel.com, rodrigo.vivi@intel.com, airlied@linux.ie, daniel@ffwll.ch, farman@linux.ibm.com, pasic@linux.ibm.com, sebott@linux.ibm.com, oberpar@linux.ibm.com, heiko.carstens@de.ibm.com, gor@linux.ibm.com, borntraeger@de.ibm.com, akrowiak@linux.ibm.com, freude@linux.ibm.com, lingshan.zhu@intel.com, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com, rdunlap@infradead.org, hch@infradead.org, gregkh@linuxfoundation.org, jgg@mellanox.com, Jason Wang 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 | 10 + samples/vfio-mdev/Makefile | 1 + samples/vfio-mdev/mvnet_loopback.c | 690 +++++++++++++++++++++++++++++ 4 files changed, 702 insertions(+) create mode 100644 samples/vfio-mdev/mvnet_loopback.c diff --git a/MAINTAINERS b/MAINTAINERS index 4c2e41641f7a..c032049f3fa0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17228,6 +17228,7 @@ F:=09net/vmw_vsock/virtio_transport.c F:=09drivers/net/vsockmon.c F:=09drivers/vhost/vsock.c F:=09tools/testing/vsock/ +F:=09samples/vfio-mdev/mvnet_loopback.c =20 VIRTIO CONSOLE DRIVER M:=09Amit Shah diff --git a/samples/Kconfig b/samples/Kconfig index c8dacb4dda80..1bef029cc977 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -131,6 +131,16 @@ 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_LOOPBACK +=09tristate "Build loopback VIRTIO net example mediated device sample code= -- loadable modules only" +=09depends on MDEV_VIRTIO && VHOST_RING && m +=09help +=09 Build a networking sample device for use as a virtio +=09 mediated device. The device cooperates with virtio-mdev bus +=09 driver to present an virtio ethernet driver for +=09 kernel. It simply loopbacks all packets from its TX +=09 virtqueue to its RX virtqueue. + 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..817618569848 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_LOOPBACK) +=3D mvnet_loopback.o diff --git a/samples/vfio-mdev/mvnet_loopback.c b/samples/vfio-mdev/mvnet_l= oopback.c new file mode 100644 index 000000000000..79059a177f39 --- /dev/null +++ b/samples/vfio-mdev/mvnet_loopback.c @@ -0,0 +1,690 @@ +// 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_loopback + * # cd /sys/devices/virtual/mvnet_loopback/mvnet_loopback/ \ + * mdev_supported_types/mvnet_loopback-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_loopback" +#define MVNET_NAME "mvnet_loopback" + +#define VIRTIO_MDEV_DEVICE_API_STRING "virtio-mdev" + +/* + * 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; +=09/* spinlock to synchronize virtqueue state */ +=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=09 false, 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) +=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_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(*mvnet), GFP_KERNEL); +=09if (!mvnet) +=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_virtio_set_ops(mdev, &mdev_virtio_ops); +=09mdev_virtio_set_class_id(mdev, MDEV_VIRTIO_CLASS_ID_VIRTIO); + +=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_virtio_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_virtio_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_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_virtio_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_virtio_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 V12 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Mon, 18 Nov 2019 14:17:03 +0800 Message-ID: <20191118061703.8669-7-jasowang@redhat.com> References: <20191118061703.8669-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191118061703.8669-1-jasowang@redhat.com> Sender: netdev-owner@vger.kernel.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: 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, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com, rdunlap@infradead List-Id: dri-devel@lists.freedesktop.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 | 10 + samples/vfio-mdev/Makefile | 1 + samples/vfio-mdev/mvnet_loopback.c | 690 +++++++++++++++++++++++++++++ 4 files changed, 702 insertions(+) create mode 100644 samples/vfio-mdev/mvnet_loopback.c diff --git a/MAINTAINERS b/MAINTAINERS index 4c2e41641f7a..c032049f3fa0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17228,6 +17228,7 @@ F:=09net/vmw_vsock/virtio_transport.c F:=09drivers/net/vsockmon.c F:=09drivers/vhost/vsock.c F:=09tools/testing/vsock/ +F:=09samples/vfio-mdev/mvnet_loopback.c =20 VIRTIO CONSOLE DRIVER M:=09Amit Shah diff --git a/samples/Kconfig b/samples/Kconfig index c8dacb4dda80..1bef029cc977 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -131,6 +131,16 @@ 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_LOOPBACK +=09tristate "Build loopback VIRTIO net example mediated device sample code= -- loadable modules only" +=09depends on MDEV_VIRTIO && VHOST_RING && m +=09help +=09 Build a networking sample device for use as a virtio +=09 mediated device. The device cooperates with virtio-mdev bus +=09 driver to present an virtio ethernet driver for +=09 kernel. It simply loopbacks all packets from its TX +=09 virtqueue to its RX virtqueue. + 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..817618569848 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_LOOPBACK) +=3D mvnet_loopback.o diff --git a/samples/vfio-mdev/mvnet_loopback.c b/samples/vfio-mdev/mvnet_l= oopback.c new file mode 100644 index 000000000000..79059a177f39 --- /dev/null +++ b/samples/vfio-mdev/mvnet_loopback.c @@ -0,0 +1,690 @@ +// 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_loopback + * # cd /sys/devices/virtual/mvnet_loopback/mvnet_loopback/ \ + * mdev_supported_types/mvnet_loopback-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_loopback" +#define MVNET_NAME "mvnet_loopback" + +#define VIRTIO_MDEV_DEVICE_API_STRING "virtio-mdev" + +/* + * 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; +=09/* spinlock to synchronize virtqueue state */ +=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=09 false, 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) +=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_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(*mvnet), GFP_KERNEL); +=09if (!mvnet) +=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_virtio_set_ops(mdev, &mdev_virtio_ops); +=09mdev_virtio_set_class_id(mdev, MDEV_VIRTIO_CLASS_ID_VIRTIO); + +=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_virtio_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_virtio_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_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_virtio_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_virtio_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 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 102FAC43215 for ; Mon, 18 Nov 2019 06:21:08 +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 E60E52073A for ; Mon, 18 Nov 2019 06:21:07 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E60E52073A 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 3EEC289F9F; Mon, 18 Nov 2019 06:21:07 +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 7116B89F9F for ; Mon, 18 Nov 2019 06:21:06 +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-41-1CDj9YRxPJ6pDrVU2v9BRw-1; Mon, 18 Nov 2019 01:21:03 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 1FEB3188355E; Mon, 18 Nov 2019 06:20:58 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-215.pek2.redhat.com [10.72.12.215]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2185960BF4; Mon, 18 Nov 2019 06:20:29 +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 V12 6/6] docs: sample driver to demonstrate how to implement virtio-mdev framework Date: Mon, 18 Nov 2019 14:17:03 +0800 Message-Id: <20191118061703.8669-7-jasowang@redhat.com> In-Reply-To: <20191118061703.8669-1-jasowang@redhat.com> References: <20191118061703.8669-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-MC-Unique: 1CDj9YRxPJ6pDrVU2v9BRw-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=1574058065; 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=iTcPp5HdX1tr83nOhZO3+KYdhl7hzfrc78/rmLIo9uI=; b=DAZtv2Q63sNnF2QW4bXJlez3VyDLxGRkILEnFTXaVMAyg9n9/7uCZDrPJOYsU71vyKTzKl 4Fg6lkmHwjuMPzLqc2+jliFVYQMMNPamvCSxeuBwXXDt6c+1+cNB3HEBhzqIuxxxp5Gk5e pMMnS8MzeurUC3dc/QORDRzGwiMH6Vg= 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: rdunlap@infradead.org, 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, jgg@mellanox.com, rob.miller@broadcom.com, hch@infradead.org, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, zhi.a.wang@intel.com, farman@linux.ibm.com, parav@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, stefanha@redhat.com, zhihong.wang@intel.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, gregkh@linuxfoundation.org, 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: <20191118061703.IfUaEgXjFjuKunew1BuTIQIbvYocivwTeZRIxiNZRUM@z> VGhpcyBzYW1wbGUgZHJpdmVyIGNyZWF0ZXMgbWRldiBkZXZpY2UgdGhhdCBzaW11bGF0ZSB2aXJ0 aW8gbmV0IGRldmljZQpvdmVyIHZpcnRpbyBtZGV2IHRyYW5zcG9ydC4gVGhlIGRldmljZSBpcyBp bXBsZW1lbnRlZCB0aHJvdWdoIHZyaW5naAphbmQgd29ya3F1ZXVlLiBBIGRldmljZSBzcGVjaWZp YyBkbWEgb3BzIGlzIHRvIG1ha2Ugc3VyZSBIVkEgaXMgdXNlZApkaXJlY3RseSBhcyB0aGUgSU9W QS4gVGhpcyBzaG91bGQgYmUgc3VmZmljaWVudCBmb3Iga2VybmVsIHZpcnRpbwpkcml2ZXIgdG8g d29yay4KCk9ubHkgJ3ZpcnRpbycgdHlwZSBpcyBzdXBwb3J0ZWQgcmlnaHQgbm93LiBJIHBsYW4g dG8gYWRkICd2aG9zdCcgdHlwZQpvbiB0b3Agd2hpY2ggcmVxdWlyZXMgc29tZSB2aXJ0dWFsIElP TU1VIGltcGxlbWVudGVkIGluIHRoaXMgc2FtcGxlCmRyaXZlci4KClNpZ25lZC1vZmYtYnk6IEph c29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMSArCiBzYW1wbGVzL0tjb25maWcgICAgICAgICAgICAgICAgICAg IHwgIDEwICsKIHNhbXBsZXMvdmZpby1tZGV2L01ha2VmaWxlICAgICAgICAgfCAgIDEgKwogc2Ft cGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJhY2suYyB8IDY5MCArKysrKysrKysrKysrKysrKysr KysrKysrKysrKwogNCBmaWxlcyBjaGFuZ2VkLCA3MDIgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IHNhbXBsZXMvdmZpby1tZGV2L212bmV0X2xvb3BiYWNrLmMKCmRpZmYgLS1naXQg YS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDRjMmU0MTY0MWY3YS4uYzAzMjA0OWYz ZmEwIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtMTcyMjgs NiArMTcyMjgsNyBAQCBGOgluZXQvdm13X3Zzb2NrL3ZpcnRpb190cmFuc3BvcnQuYwogRjoJZHJp dmVycy9uZXQvdnNvY2ttb24uYwogRjoJZHJpdmVycy92aG9zdC92c29jay5jCiBGOgl0b29scy90 ZXN0aW5nL3Zzb2NrLworRjoJc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJhY2suYwogCiBW SVJUSU8gQ09OU09MRSBEUklWRVIKIE06CUFtaXQgU2hhaCA8YW1pdEBrZXJuZWwub3JnPgpkaWZm IC0tZ2l0IGEvc2FtcGxlcy9LY29uZmlnIGIvc2FtcGxlcy9LY29uZmlnCmluZGV4IGM4ZGFjYjRk ZGE4MC4uMWJlZjAyOWNjOTc3IDEwMDY0NAotLS0gYS9zYW1wbGVzL0tjb25maWcKKysrIGIvc2Ft cGxlcy9LY29uZmlnCkBAIC0xMzEsNiArMTMxLDE2IEBAIGNvbmZpZyBTQU1QTEVfVkZJT19NREVW X01EUFkKIAkgIG1lZGlhdGVkIGRldmljZS4gIEl0IGlzIGEgc2ltcGxlIGZyYW1lYnVmZmVyIGFu ZCBzdXBwb3J0cwogCSAgdGhlIHJlZ2lvbiBkaXNwbGF5IGludGVyZmFjZSAoVkZJT19HRlhfUExB TkVfVFlQRV9SRUdJT04pLgogCitjb25maWcgU0FNUExFX1ZJUlRJT19NREVWX05FVF9MT09QQkFD SworCXRyaXN0YXRlICJCdWlsZCBsb29wYmFjayBWSVJUSU8gbmV0IGV4YW1wbGUgbWVkaWF0ZWQg ZGV2aWNlIHNhbXBsZSBjb2RlIC0tIGxvYWRhYmxlIG1vZHVsZXMgb25seSIKKwlkZXBlbmRzIG9u IE1ERVZfVklSVElPICYmIFZIT1NUX1JJTkcgJiYgbQorCWhlbHAKKwkgIEJ1aWxkIGEgbmV0d29y a2luZyBzYW1wbGUgZGV2aWNlIGZvciB1c2UgYXMgYSB2aXJ0aW8KKwkgIG1lZGlhdGVkIGRldmlj ZS4gVGhlIGRldmljZSBjb29wZXJhdGVzIHdpdGggdmlydGlvLW1kZXYgYnVzCisJICBkcml2ZXIg dG8gcHJlc2VudCBhbiB2aXJ0aW8gZXRoZXJuZXQgZHJpdmVyIGZvcgorCSAga2VybmVsLiBJdCBz aW1wbHkgbG9vcGJhY2tzIGFsbCBwYWNrZXRzIGZyb20gaXRzIFRYCisJICB2aXJ0cXVldWUgdG8g aXRzIFJYIHZpcnRxdWV1ZS4KKwogY29uZmlnIFNBTVBMRV9WRklPX01ERVZfTURQWV9GQgogCXRy aXN0YXRlICJCdWlsZCBWRklPIG1kcHkgZXhhbXBsZSBndWVzdCBmYmRldiBkcml2ZXIgLS0gbG9h ZGFibGUgbW9kdWxlIG9ubHkiCiAJZGVwZW5kcyBvbiBGQiAmJiBtCmRpZmYgLS1naXQgYS9zYW1w bGVzL3ZmaW8tbWRldi9NYWtlZmlsZSBiL3NhbXBsZXMvdmZpby1tZGV2L01ha2VmaWxlCmluZGV4 IDEwZDE3OWM0ZmRlYi4uODE3NjE4NTY5ODQ4IDEwMDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8tbWRl di9NYWtlZmlsZQorKysgYi9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZQpAQCAtMywzICszLDQg QEAgb2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTVRUWSkgKz0gbXR0eS5vCiBvYmotJChD T05GSUdfU0FNUExFX1ZGSU9fTURFVl9NRFBZKSArPSBtZHB5Lm8KIG9iai0kKENPTkZJR19TQU1Q TEVfVkZJT19NREVWX01EUFlfRkIpICs9IG1kcHktZmIubwogb2JqLSQoQ09ORklHX1NBTVBMRV9W RklPX01ERVZfTUJPQ0hTKSArPSBtYm9jaHMubworb2JqLSQoQ09ORklHX1NBTVBMRV9WSVJUSU9f TURFVl9ORVRfTE9PUEJBQ0spICs9IG12bmV0X2xvb3BiYWNrLm8KZGlmZiAtLWdpdCBhL3NhbXBs ZXMvdmZpby1tZGV2L212bmV0X2xvb3BiYWNrLmMgYi9zYW1wbGVzL3ZmaW8tbWRldi9tdm5ldF9s b29wYmFjay5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNzkwNTlh MTc3ZjM5Ci0tLSAvZGV2L251bGwKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJh Y2suYwpAQCAtMCwwICsxLDY5MCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjAtb25seQorLyoKKyAqIE1lZGlhdGVkIHZpcnR1YWwgdmlydGlvLW5ldCBkZXZpY2UgZHJpdmVy LgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxOSwgUmVkIEhhdCBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiAgICAgQXV0aG9yOiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgor ICoKKyAqIFNhbXBsZSBkcml2ZXIgdGhhdCBjcmVhdGVzIG1kZXYgZGV2aWNlIHRoYXQgc2ltdWxh dGVzIGV0aGVybmV0IGxvb3BiYWNrCisgKiBkZXZpY2UuCisgKgorICogVXNhZ2U6CisgKgorICog IyBtb2Rwcm9iZSB2aXJ0aW9fbWRldgorICogIyBtb2Rwcm9iZSBtdm5ldF9sb29wYmFjaworICog IyBjZCAvc3lzL2RldmljZXMvdmlydHVhbC9tdm5ldF9sb29wYmFjay9tdm5ldF9sb29wYmFjay8g XAorICogICAgICBtZGV2X3N1cHBvcnRlZF90eXBlcy9tdm5ldF9sb29wYmFjay12aXJ0aW8KKyAq ICMgZWNobyAiODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxIiA+IC4vY3JlYXRl CisgKiAjIGNkIGRldmljZXMvODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxCisg KiAjIGxzIC1kIHZpcnRpbzAKKyAqIHZpcnRpbzAKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5p dC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5j bHVkZSA8bGludXgvcG9sbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxs aW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKyNpbmNsdWRlIDxsaW51eC91 dWlkLmg+CisjaW5jbHVkZSA8bGludXgvaW9tbXUuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNmcy5o PgorI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92cmluZ2guaD4KKyNp bmNsdWRlIDxsaW51eC9tZGV2X3ZpcnRpby5oPgorI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlv X2NvbmZpZy5oPgorI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX25ldC5oPgorCisjZGVmaW5l IFZFUlNJT05fU1RSSU5HICAiMC4xIgorI2RlZmluZSBEUklWRVJfQVVUSE9SICAgIlJlZCBIYXQg Q29ycG9yYXRpb24iCisKKyNkZWZpbmUgTVZORVRfQ0xBU1NfTkFNRSAibXZuZXRfbG9vcGJhY2si CisjZGVmaW5lIE1WTkVUX05BTUUgICAgICAgIm12bmV0X2xvb3BiYWNrIgorCisjZGVmaW5lIFZJ UlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HICJ2aXJ0aW8tbWRldiIKKworLyoKKyAqIEdsb2Jh bCBTdHJ1Y3R1cmVzCisgKi8KKworc3RhdGljIHN0cnVjdCBtdm5ldF9kZXYgeworCXN0cnVjdCBj bGFzcwkqdmRfY2xhc3M7CisJc3RydWN0IGlkcgl2ZF9pZHI7CisJc3RydWN0IGRldmljZQlkZXY7 Cit9IG12bmV0X2RldjsKKworc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB7CisJc3RydWN0IHZyaW5n aCB2cmluZzsKKwlzdHJ1Y3QgdnJpbmdoX2tpb3YgaW92OworCXVuc2lnbmVkIHNob3J0IGhlYWQ7 CisJYm9vbCByZWFkeTsKKwl1NjQgZGVzY19hZGRyOworCXU2NCBkZXZpY2VfYWRkcjsKKwl1NjQg ZHJpdmVyX2FkZHI7CisJdTMyIG51bTsKKwl2b2lkICpwcml2YXRlOworCWlycXJldHVybl90ICgq Y2IpKHZvaWQgKmRhdGEpOworfTsKKworI2RlZmluZSBNVk5FVF9RVUVVRV9BTElHTiBQQUdFX1NJ WkUKKyNkZWZpbmUgTVZORVRfUVVFVUVfTUFYIDI1NgorI2RlZmluZSBNVk5FVF9ERVZJQ0VfSUQg MHgxCisjZGVmaW5lIE1WTkVUX1ZFTkRPUl9JRCAwCisKK3U2NCBtdm5ldF9mZWF0dXJlcyA9ICgx VUxMIDw8IFZJUlRJT19GX0FOWV9MQVlPVVQpIHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9W RVJTSU9OXzEpIHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9JT01NVV9QTEFURk9STSk7CisK Ky8qIFN0YXRlIG9mIGVhY2ggbWRldiBkZXZpY2UgKi8KK3N0cnVjdCBtdm5ldF9zdGF0ZSB7CisJ c3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB2cXNbMl07CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7 CisJLyogc3BpbmxvY2sgdG8gc3luY2hyb25pemUgdmlydHF1ZXVlIHN0YXRlICovCisJc3Bpbmxv Y2tfdCBsb2NrOworCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldjsKKwlzdHJ1Y3QgdmlydGlvX25l dF9jb25maWcgY29uZmlnOworCXZvaWQgKmJ1ZmZlcjsKKwl1MzIgc3RhdHVzOworCXUzMiBnZW5l cmF0aW9uOworCXU2NCBmZWF0dXJlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5leHQ7Cit9OworCitz dGF0aWMgc3RydWN0IG11dGV4IG1kZXZfbGlzdF9sb2NrOworc3RhdGljIHN0cnVjdCBsaXN0X2hl YWQgbWRldl9kZXZpY2VzX2xpc3Q7CisKK3N0YXRpYyB2b2lkIG12bmV0X3F1ZXVlX3JlYWR5KHN0 cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQsIHVuc2lnbmVkIGludCBpZHgpCit7CisJc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCWludCByZXQ7CisKKwlyZXQg PSB2cmluZ2hfaW5pdF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVV RV9NQVgsCisJCQkgICAgICAgZmFsc2UsIChzdHJ1Y3QgdnJpbmdfZGVzYyAqKXZxLT5kZXNjX2Fk ZHIsCisJCQkgICAgICAgKHN0cnVjdCB2cmluZ19hdmFpbCAqKXZxLT5kcml2ZXJfYWRkciwKKwkJ CSAgICAgICAoc3RydWN0IHZyaW5nX3VzZWQgKil2cS0+ZGV2aWNlX2FkZHIpOworfQorCitzdGF0 aWMgdm9pZCBtdm5ldF92cV9yZXNldChzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSkKK3sKKwl2 cS0+cmVhZHkgPSAwOworCXZxLT5kZXNjX2FkZHIgPSAwOworCXZxLT5kcml2ZXJfYWRkciA9IDA7 CisJdnEtPmRldmljZV9hZGRyID0gMDsKKwl2cS0+Y2IgPSBOVUxMOworCXZxLT5wcml2YXRlID0g TlVMTDsKKwl2cmluZ2hfaW5pdF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5F VF9RVUVVRV9NQVgsCisJCQkgZmFsc2UsIDAsIDAsIDApOworfQorCitzdGF0aWMgdm9pZCBtdm5l dF9yZXNldChzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0KQoreworCWludCBpOworCisJZm9yIChp ID0gMDsgaSA8IDI7IGkrKykKKwkJbXZuZXRfdnFfcmVzZXQoJm12bmV0LT52cXNbaV0pOworCisJ bXZuZXQtPmZlYXR1cmVzID0gMDsKKwltdm5ldC0+c3RhdHVzID0gMDsKKwkrK212bmV0LT5nZW5l cmF0aW9uOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAq d29yaykKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gY29udGFpbmVyX29mKHdvcmss IHN0cnVjdAorCQkJCQkJIG12bmV0X3N0YXRlLCB3b3JrKTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1 ZXVlICp0eHEgPSAmbXZuZXQtPnZxc1sxXTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICpyeHEg PSAmbXZuZXQtPnZxc1swXTsKKwlzaXplX3QgcmVhZCwgd3JpdGUsIHRvdGFsX3dyaXRlOworCWlu dCBlcnI7CisJaW50IHBrdHMgPSAwOworCisJc3Bpbl9sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlp ZiAoIXR4cS0+cmVhZHkgfHwgIXJ4cS0+cmVhZHkpCisJCWdvdG8gb3V0OworCisJd2hpbGUgKHRy dWUpIHsKKwkJdG90YWxfd3JpdGUgPSAwOworCQllcnIgPSB2cmluZ2hfZ2V0ZGVzY19rZXJuKCZ0 eHEtPnZyaW5nLCAmdHhxLT5pb3YsIE5VTEwsCisJCQkJCSAgJnR4cS0+aGVhZCwgR0ZQX0FUT01J Qyk7CisJCWlmIChlcnIgPD0gMCkKKwkJCWJyZWFrOworCisJCWVyciA9IHZyaW5naF9nZXRkZXNj X2tlcm4oJnJ4cS0+dnJpbmcsIE5VTEwsICZyeHEtPmlvdiwKKwkJCQkJICAmcnhxLT5oZWFkLCBH RlBfQVRPTUlDKTsKKwkJaWYgKGVyciA8PSAwKSB7CisJCQl2cmluZ2hfY29tcGxldGVfa2Vybigm dHhxLT52cmluZywgdHhxLT5oZWFkLCAwKTsKKwkJCWJyZWFrOworCQl9CisKKwkJd2hpbGUgKHRy dWUpIHsKKwkJCXJlYWQgPSB2cmluZ2hfaW92X3B1bGxfa2VybigmdHhxLT5pb3YsIG12bmV0LT5i dWZmZXIsCisJCQkJCQkgICAgUEFHRV9TSVpFKTsKKwkJCWlmIChyZWFkIDw9IDApCisJCQkJYnJl YWs7CisKKwkJCXdyaXRlID0gdnJpbmdoX2lvdl9wdXNoX2tlcm4oJnJ4cS0+aW92LCBtdm5ldC0+ YnVmZmVyLAorCQkJCQkJICAgICByZWFkKTsKKwkJCWlmICh3cml0ZSA8PSAwKQorCQkJCWJyZWFr OworCisJCQl0b3RhbF93cml0ZSArPSB3cml0ZTsKKwkJfQorCisJCS8qIE1ha2Ugc3VyZSBkYXRh IGlzIHdyb3RlIGJlZm9yZSBhZHZhbmNpbmcgaW5kZXggKi8KKwkJc21wX3dtYigpOworCisJCXZy aW5naF9jb21wbGV0ZV9rZXJuKCZ0eHEtPnZyaW5nLCB0eHEtPmhlYWQsIDApOworCQl2cmluZ2hf Y29tcGxldGVfa2VybigmcnhxLT52cmluZywgcnhxLT5oZWFkLCB0b3RhbF93cml0ZSk7CisKKwkJ LyogTWFrZSBzdXJlIHVzZWQgaXMgdmlzaWJsZSBiZWZvcmUgcmFzaW5nIHRoZSBpbnRlcnJ1cHQu ICovCisJCXNtcF93bWIoKTsKKworCQlsb2NhbF9iaF9kaXNhYmxlKCk7CisJCWlmICh0eHEtPmNi KQorCQkJdHhxLT5jYih0eHEtPnByaXZhdGUpOworCQlpZiAocnhxLT5jYikKKwkJCXJ4cS0+Y2Io cnhxLT5wcml2YXRlKTsKKwkJbG9jYWxfYmhfZW5hYmxlKCk7CisKKwkJaWYgKCsrcGt0cyA+IDQp IHsKKwkJCXNjaGVkdWxlX3dvcmsoJm12bmV0LT53b3JrKTsKKwkJCWdvdG8gb3V0OworCQl9CisJ fQorCitvdXQ6CisJc3Bpbl91bmxvY2soJm12bmV0LT5sb2NrKTsKK30KKworc3RhdGljIGRtYV9h ZGRyX3QgbXZuZXRfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFn ZSwKKwkJCQkgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLAorCQkJCSBlbnVtIGRt YV9kYXRhX2RpcmVjdGlvbiBkaXIsCisJCQkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCit7CisJLyog VnJpbmdoIGNhbiBvbmx5IHVzZSBIVkEgKi8KKwlyZXR1cm4gKGRtYV9hZGRyX3QpKHBhZ2VfYWRk cmVzcyhwYWdlKSArIG9mZnNldCk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3VubWFwX3BhZ2Uo c3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRyLAorCQkJICAgICBzaXplX3Qg c2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAorCQkJICAgICB1bnNpZ25lZCBsb25n IGF0dHJzKQoreworfQorCitzdGF0aWMgdm9pZCAqbXZuZXRfYWxsb2NfY29oZXJlbnQoc3RydWN0 IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKKwkJCQkgIGRtYV9hZGRyX3QgKmRtYV9hZGRyLCBn ZnBfdCBmbGFnLAorCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwl2b2lkICphZGRyID0g a21hbGxvYyhzaXplLCBmbGFnKTsKKworCWlmICghYWRkcikKKwkJKmRtYV9hZGRyID0gRE1BX01B UFBJTkdfRVJST1I7CisJZWxzZQorCQkqZG1hX2FkZHIgPSAoZG1hX2FkZHJfdClhZGRyOworCisJ cmV0dXJuIGFkZHI7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2ZyZWVfY29oZXJlbnQoc3RydWN0 IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKKwkJCQl2b2lkICp2YWRkciwgZG1hX2FkZHJfdCBk bWFfYWRkciwKKwkJCQl1bnNpZ25lZCBsb25nIGF0dHJzKQoreworCWtmcmVlKCh2b2lkICopZG1h X2FkZHIpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIG12bmV0X2RtYV9v cHMgPSB7CisJLm1hcF9wYWdlID0gbXZuZXRfbWFwX3BhZ2UsCisJLnVubWFwX3BhZ2UgPSBtdm5l dF91bm1hcF9wYWdlLAorCS5hbGxvYyA9IG12bmV0X2FsbG9jX2NvaGVyZW50LAorCS5mcmVlID0g bXZuZXRfZnJlZV9jb2hlcmVudCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl92aXJ0 aW9fb3BzIG1kZXZfdmlydGlvX29wczsKKworc3RhdGljIGludCBtdm5ldF9jcmVhdGUoc3RydWN0 IGtvYmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlzdHJ1Y3QgbXZu ZXRfc3RhdGUgKm12bmV0OworCXN0cnVjdCB2aXJ0aW9fbmV0X2NvbmZpZyAqY29uZmlnOworCXN0 cnVjdCBkZXZpY2UgKmRldiA9IG1kZXZfZGV2KG1kZXYpOworCisJaWYgKCFtZGV2KQorCQlyZXR1 cm4gLUVJTlZBTDsKKworCW12bmV0ID0ga3phbGxvYyhzaXplb2YoKm12bmV0KSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFtdm5ldCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltdm5ldC0+YnVmZmVyID0g a21hbGxvYyhQQUdFX1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghbXZuZXQtPmJ1ZmZlcikgewor CQlrZnJlZShtdm5ldCk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWNvbmZpZyA9ICZtdm5l dC0+Y29uZmlnOworCWNvbmZpZy0+bXR1ID0gMTUwMDsKKwljb25maWctPnN0YXR1cyA9IFZJUlRJ T19ORVRfU19MSU5LX1VQOworCWV0aF9yYW5kb21fYWRkcihjb25maWctPm1hYyk7CisKKwlJTklU X1dPUksoJm12bmV0LT53b3JrLCBtdm5ldF93b3JrKTsKKworCXNwaW5fbG9ja19pbml0KCZtdm5l dC0+bG9jayk7CisJbXZuZXQtPm1kZXYgPSBtZGV2OworCW1kZXZfc2V0X2RydmRhdGEobWRldiwg bXZuZXQpOworCisJbXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOworCWxpc3RfYWRkKCZtdm5l dC0+bmV4dCwgJm1kZXZfZGV2aWNlc19saXN0KTsKKwltdXRleF91bmxvY2soJm1kZXZfbGlzdF9s b2NrKTsKKworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklUX01BU0soNjQpOworCXNl dF9kbWFfb3BzKGRldiwgJm12bmV0X2RtYV9vcHMpOworCisJbWRldl92aXJ0aW9fc2V0X29wcyht ZGV2LCAmbWRldl92aXJ0aW9fb3BzKTsKKwltZGV2X3ZpcnRpb19zZXRfY2xhc3NfaWQobWRldiwg TURFVl9WSVJUSU9fQ0xBU1NfSURfVklSVElPKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IG12bmV0X3JlbW92ZShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG12 bmV0X3N0YXRlICptZHMsICp0bXBfbWRzOworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBt ZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCWludCByZXQgPSAtRUlOVkFMOworCisJbXV0ZXhfbG9j aygmbWRldl9saXN0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtZHMsIHRtcF9t ZHMsICZtZGV2X2RldmljZXNfbGlzdCwgbmV4dCkgeworCQlpZiAobXZuZXQgPT0gbWRzKSB7CisJ CQlsaXN0X2RlbCgmbXZuZXQtPm5leHQpOworCQkJbWRldl9zZXRfZHJ2ZGF0YShtZGV2LCBOVUxM KTsKKwkJCWtmcmVlKG12bmV0LT5idWZmZXIpOworCQkJa2ZyZWUobXZuZXQpOworCQkJcmV0ID0g MDsKKwkJCWJyZWFrOworCQl9CisJfQorCW11dGV4X3VubG9jaygmbWRldl9saXN0X2xvY2spOwor CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHNzaXplX3QKK3NhbXBsZV9tdm5ldF9kZXZfc2hv dyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkg ICAgICBjaGFyICpidWYpCit7CisJaWYgKG1kZXZfdmlydGlvX2Zyb21fZGV2KGRldikpCisJCXJl dHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xuIiwgZGV2X25hbWUoZGV2KSk7CisK KwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitzdGF0aWMgREVWSUNFX0FUVFJfUk8o c2FtcGxlX212bmV0X2Rldik7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICptdm5ldF9kZXZf YXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfc2FtcGxlX212bmV0X2Rldi5hdHRyLAorCU5VTEwsCit9 OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBtdm5ldF9kZXZfZ3JvdXAg PSB7CisJLm5hbWUgID0gIm12bmV0X2RldiIsCisJLmF0dHJzID0gbXZuZXRfZGV2X2F0dHJzLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKm12bmV0X2Rldl9ncm91 cHNbXSA9IHsKKwkmbXZuZXRfZGV2X2dyb3VwLAorCU5VTEwsCit9OworCitzdGF0aWMgc3NpemVf dAorc2FtcGxlX21kZXZfZGV2X3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNl X2F0dHJpYnV0ZSAqYXR0ciwKKwkJICAgICBjaGFyICpidWYpCit7CisJaWYgKG1kZXZfdmlydGlv X2Zyb21fZGV2KGRldikpCisJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xu IiwgZGV2X25hbWUoZGV2KSk7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitz dGF0aWMgREVWSUNFX0FUVFJfUk8oc2FtcGxlX21kZXZfZGV2KTsKKworc3RhdGljIHN0cnVjdCBh dHRyaWJ1dGUgKm1kZXZfZGV2X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tZGV2X2Rl di5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91 cCBtZGV2X2Rldl9ncm91cCA9IHsKKwkubmFtZSAgPSAidmVuZG9yIiwKKwkuYXR0cnMgPSBtZGV2 X2Rldl9hdHRycywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICpt ZGV2X2Rldl9ncm91cHNbXSA9IHsKKwkmbWRldl9kZXZfZ3JvdXAsCisJTlVMTCwKK307CisKKyNk ZWZpbmUgTVZORVRfU1RSSU5HX0xFTiAxNgorCitzdGF0aWMgc3NpemVfdAorbmFtZV9zaG93KHN0 cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgZGV2aWNlICpkZXYsIGNoYXIgKmJ1ZikKK3sKKwlj aGFyIG5hbWVbTVZORVRfU1RSSU5HX0xFTl07CisJY29uc3QgY2hhciAqbmFtZV9zdHIgPSAidmly dGlvLW5ldCI7CisKKwlzbnByaW50ZihuYW1lLCBNVk5FVF9TVFJJTkdfTEVOLCAiJXMiLCBkZXZf ZHJpdmVyX3N0cmluZyhkZXYpKTsKKwlpZiAoIXN0cmNtcChrb2JqLT5uYW1lLCBuYW1lKSkKKwkJ cmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIG5hbWVfc3RyKTsKKworCXJldHVybiAtRUlOVkFM OworfQorCitzdGF0aWMgTURFVl9UWVBFX0FUVFJfUk8obmFtZSk7CisKK3N0YXRpYyBzc2l6ZV90 CithdmFpbGFibGVfaW5zdGFuY2VzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBk ZXZpY2UgKmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBJ TlRfTUFYKTsKK30KKworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGF2YWlsYWJsZV9pbnN0YW5j ZXMpOworCitzdGF0aWMgc3NpemVfdCBkZXZpY2VfYXBpX3Nob3coc3RydWN0IGtvYmplY3QgKmtv YmosIHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgICBjaGFyICpidWYpCit7CisJcmV0dXJu IHNwcmludGYoYnVmLCAiJXNcbiIsIFZJUlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HKTsKK30K Kworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGRldmljZV9hcGkpOworCitzdGF0aWMgc3RydWN0 IGF0dHJpYnV0ZSAqbWRldl90eXBlc19hdHRyc1tdID0geworCSZtZGV2X3R5cGVfYXR0cl9uYW1l LmF0dHIsCisJJm1kZXZfdHlwZV9hdHRyX2RldmljZV9hcGkuYXR0ciwKKwkmbWRldl90eXBlX2F0 dHJfYXZhaWxhYmxlX2luc3RhbmNlcy5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0 IGF0dHJpYnV0ZV9ncm91cCBtZGV2X3R5cGVfZ3JvdXAgPSB7CisJLm5hbWUgID0gInZpcnRpbyIs CisJLmF0dHJzID0gbWRldl90eXBlc19hdHRycywKK307CisKKy8qIFRCRDogInZob3N0IiB0eXBl ICovCisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X3R5cGVfZ3JvdXBzW10g PSB7CisJJm1kZXZfdHlwZV9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIGludCBtdm5ldF9z ZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZHgsCisJCQkJdTY0 IGRlc2NfYXJlYSwgdTY0IGRyaXZlcl9hcmVhLCB1NjQgZGV2aWNlX2FyZWEpCit7CisJc3RydWN0 IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisJc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCisJdnEtPmRlc2NfYWRkciA9 IGRlc2NfYXJlYTsKKwl2cS0+ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKKwl2cS0+ZGV2aWNl X2FkZHIgPSBkZXZpY2VfYXJlYTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBtdm5l dF9zZXRfdnFfbnVtKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgdTMyIG51bSkK K3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsK KwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+ bnVtID0gbnVtOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9raWNrX3ZxKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdTE2IGlkeCkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRl dl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5l dC0+dnFzW2lkeF07CisKKwlpZiAodnEtPnJlYWR5KQorCQlzY2hlZHVsZV93b3JrKCZtdm5ldC0+ d29yayk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3NldF92cV9jYihzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYsIHUxNiBpZHgsCisJCQkgICAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpj YikKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2 KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2 cS0+Y2IgPSBjYi0+Y2FsbGJhY2s7CisJdnEtPnByaXZhdGUgPSBjYi0+cHJpdmF0ZTsKK30KKwor c3RhdGljIHZvaWQgbXZuZXRfc2V0X3ZxX3JlYWR5KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwg dTE2IGlkeCwgYm9vbCByZWFkeSkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRl dl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5l dC0+dnFzW2lkeF07CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKwl2cS0+cmVhZHkgPSBy ZWFkeTsKKwlpZiAodnEtPnJlYWR5KQorCQltdm5ldF9xdWV1ZV9yZWFkeShtdm5ldCwgaWR4KTsK KwlzcGluX3VubG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgYm9vbCBtdm5ldF9nZXRf dnFfcmVhZHkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0cnVjdCBt dm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5l dF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKworCXJldHVybiB2cS0+cmVhZHk7 Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X3ZxX3N0YXRlKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwgdTE2IGlkeCwgdTY0IHN0YXRlKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0g Jm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJ c3Bpbl9sb2NrKCZtdm5ldC0+bG9jayk7CisJdnJoLT5sYXN0X2F2YWlsX2lkeCA9IHN0YXRlOwor CXNwaW5fdW5sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHU2 NCBtdm5ldF9nZXRfdnFfc3RhdGUoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQor eworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOwor CXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3Qg dnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJcmV0dXJuIHZyaC0+bGFzdF9hdmFpbF9pZHg7 Cit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX2FsaWduKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldikKK3sKKwlyZXR1cm4gTVZORVRfUVVFVUVfQUxJR047Cit9CisKK3N0YXRpYyB1NjQgbXZu ZXRfZ2V0X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gbXZu ZXRfZmVhdHVyZXM7Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X2ZlYXR1cmVzKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiwgdTY0IGZlYXR1cmVzKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJLyogRE1BIG1hcHBpbmcgbXVzdCBi ZSBkb25lIGJ5IGRyaXZlciAqLworCWlmICghKGZlYXR1cmVzICYgKDFVTEwgPDwgVklSVElPX0Zf SU9NTVVfUExBVEZPUk0pKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltdm5ldC0+ZmVhdHVyZXMg PSBmZWF0dXJlcyAmIG12bmV0X2ZlYXR1cmVzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2 b2lkIG12bmV0X3NldF9jb25maWdfY2Ioc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LAorCQkJCXN0 cnVjdCB2aXJ0aW9fbWRldl9jYWxsYmFjayAqY2IpCit7CisJLyogV2UgZG9uJ3Qgc3VwcG9ydCBj b25maWcgaW50ZXJydXB0ICovCit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX251bV9tYXgo c3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXJldHVybiBNVk5FVF9RVUVVRV9NQVg7Cit9 CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2RldmljZV9pZChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYpCit7CisJcmV0dXJuIE1WTkVUX0RFVklDRV9JRDsKK30KKworc3RhdGljIHUzMiBtdm5ldF9n ZXRfdmVuZG9yX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gTVZORVRf VkVORE9SX0lEOworfQorCitzdGF0aWMgdTggbXZuZXRfZ2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9k ZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2Ry dmRhdGEobWRldik7CisKKwlyZXR1cm4gbXZuZXQtPnN0YXR1czsKK30KKworc3RhdGljIHZvaWQg bXZuZXRfc2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cykKK3sK KwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwor CW12bmV0LT5zdGF0dXMgPSBzdGF0dXM7CisKKwlpZiAoc3RhdHVzID09IDApIHsKKwkJc3Bpbl9s b2NrKCZtdm5ldC0+bG9jayk7CisJCW12bmV0X3Jlc2V0KG12bmV0KTsKKwkJc3Bpbl91bmxvY2so Jm12bmV0LT5sb2NrKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2dldF9jb25maWcoc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAorCQkJICAgICB2b2lk ICpidWYsIHVuc2lnbmVkIGludCBsZW4pCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9 IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisKKwlpZiAob2Zmc2V0ICsgbGVuIDwgc2l6ZW9mKHN0 cnVjdCB2aXJ0aW9fbmV0X2NvbmZpZykpCisJCW1lbWNweShidWYsICZtdm5ldC0+Y29uZmlnICsg b2Zmc2V0LCBsZW4pOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRfY29uZmlnKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAgICAgY29uc3Qgdm9p ZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQoreworCS8qIE5vIHdyaXRhYmxlIGNvbmZpZyBzdXBw b3J0dGVkIGJ5IG12bmV0ICovCit9CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2dlbmVyYXRpb24o c3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJcmV0dXJuIG12bmV0LT5nZW5lcmF0aW9uOwor fQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyBtZGV2X3ZpcnRpb19vcHMg PSB7CisJLnNldF92cV9hZGRyZXNzICAgICAgICAgPSBtdm5ldF9zZXRfdnFfYWRkcmVzcywKKwku c2V0X3ZxX251bSAgICAgICAgICAgICA9IG12bmV0X3NldF92cV9udW0sCisJLmtpY2tfdnEgICAg ICAgICAgICAgICAgPSBtdm5ldF9raWNrX3ZxLAorCS5zZXRfdnFfY2IgICAgICAgICAgICAgID0g bXZuZXRfc2V0X3ZxX2NiLAorCS5zZXRfdnFfcmVhZHkgICAgICAgICAgID0gbXZuZXRfc2V0X3Zx X3JlYWR5LAorCS5nZXRfdnFfcmVhZHkgICAgICAgICAgID0gbXZuZXRfZ2V0X3ZxX3JlYWR5LAor CS5zZXRfdnFfc3RhdGUgICAgICAgICAgID0gbXZuZXRfc2V0X3ZxX3N0YXRlLAorCS5nZXRfdnFf c3RhdGUgICAgICAgICAgID0gbXZuZXRfZ2V0X3ZxX3N0YXRlLAorCS5nZXRfdnFfYWxpZ24gICAg ICAgICAgID0gbXZuZXRfZ2V0X3ZxX2FsaWduLAorCS5nZXRfZmVhdHVyZXMgICAgICAgICAgID0g bXZuZXRfZ2V0X2ZlYXR1cmVzLAorCS5zZXRfZmVhdHVyZXMgICAgICAgICAgID0gbXZuZXRfc2V0 X2ZlYXR1cmVzLAorCS5zZXRfY29uZmlnX2NiICAgICAgICAgID0gbXZuZXRfc2V0X2NvbmZpZ19j YiwKKwkuZ2V0X3ZxX251bV9tYXggICAgICAgICA9IG12bmV0X2dldF92cV9udW1fbWF4LAorCS5n ZXRfZGV2aWNlX2lkICAgICAgICAgID0gbXZuZXRfZ2V0X2RldmljZV9pZCwKKwkuZ2V0X3ZlbmRv cl9pZCAgICAgICAgICA9IG12bmV0X2dldF92ZW5kb3JfaWQsCisJLmdldF9zdGF0dXMgICAgICAg ICAgICAgPSBtdm5ldF9nZXRfc3RhdHVzLAorCS5zZXRfc3RhdHVzICAgICAgICAgICAgID0gbXZu ZXRfc2V0X3N0YXR1cywKKwkuZ2V0X2NvbmZpZyAgICAgICAgICAgICA9IG12bmV0X2dldF9jb25m aWcsCisJLnNldF9jb25maWcgICAgICAgICAgICAgPSBtdm5ldF9zZXRfY29uZmlnLAorCS5nZXRf Z2VuZXJhdGlvbiAgICAgICAgID0gbXZuZXRfZ2V0X2dlbmVyYXRpb24sCit9OworCitzdGF0aWMg Y29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyBtZGV2X2ZvcHMgPSB7CisJLm93bmVyICAgICAg ICAgICAgICAgICAgPSBUSElTX01PRFVMRSwKKwkuZGV2X2F0dHJfZ3JvdXBzICAgICAgICA9IG12 bmV0X2Rldl9ncm91cHMsCisJLm1kZXZfYXR0cl9ncm91cHMgICAgICAgPSBtZGV2X2Rldl9ncm91 cHMsCisJLnN1cHBvcnRlZF90eXBlX2dyb3VwcyAgPSBtZGV2X3R5cGVfZ3JvdXBzLAorCS5jcmVh dGUgICAgICAgICAgICAgICAgID0gbXZuZXRfY3JlYXRlLAorCS5yZW1vdmUJCQk9IG12bmV0X3Jl bW92ZSwKK307CisKK3N0YXRpYyB2b2lkIG12bmV0X2RldmljZV9yZWxlYXNlKHN0cnVjdCBkZXZp Y2UgKmRldikKK3sKKwlkZXZfZGJnKGRldiwgIm12bmV0OiByZWxlYXNlZFxuIik7Cit9CisKK3N0 YXRpYyBpbnQgX19pbml0IG12bmV0X2Rldl9pbml0KHZvaWQpCit7CisJaW50IHJldCA9IDA7CisK Kwlwcl9pbmZvKCJtdm5ldF9kZXY6ICVzXG4iLCBfX2Z1bmNfXyk7CisKKwltZW1zZXQoJm12bmV0 X2RldiwgMCwgc2l6ZW9mKG12bmV0X2RldikpOworCisJaWRyX2luaXQoJm12bmV0X2Rldi52ZF9p ZHIpOworCisJbXZuZXRfZGV2LnZkX2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCBN Vk5FVF9DTEFTU19OQU1FKTsKKworCWlmIChJU19FUlIobXZuZXRfZGV2LnZkX2NsYXNzKSkgewor CQlwcl9lcnIoIkVycm9yOiBmYWlsZWQgdG8gcmVnaXN0ZXIgbXZuZXRfZGV2IGNsYXNzXG4iKTsK KwkJcmV0ID0gUFRSX0VSUihtdm5ldF9kZXYudmRfY2xhc3MpOworCQlnb3RvIGZhaWxlZDE7CisJ fQorCisJbXZuZXRfZGV2LmRldi5jbGFzcyA9IG12bmV0X2Rldi52ZF9jbGFzczsKKwltdm5ldF9k ZXYuZGV2LnJlbGVhc2UgPSBtdm5ldF9kZXZpY2VfcmVsZWFzZTsKKwlkZXZfc2V0X25hbWUoJm12 bmV0X2Rldi5kZXYsICIlcyIsIE1WTkVUX05BTUUpOworCisJcmV0ID0gZGV2aWNlX3JlZ2lzdGVy KCZtdm5ldF9kZXYuZGV2KTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWxlZDI7CisKKwlyZXQgPSBt ZGV2X3ZpcnRpb19yZWdpc3Rlcl9kZXZpY2UoJm12bmV0X2Rldi5kZXYsICZtZGV2X2ZvcHMpOwor CWlmIChyZXQpCisJCWdvdG8gZmFpbGVkMzsKKworCW11dGV4X2luaXQoJm1kZXZfbGlzdF9sb2Nr KTsKKwlJTklUX0xJU1RfSEVBRCgmbWRldl9kZXZpY2VzX2xpc3QpOworCisJZ290byBhbGxfZG9u ZTsKKworZmFpbGVkMzoKKworCWRldmljZV91bnJlZ2lzdGVyKCZtdm5ldF9kZXYuZGV2KTsKK2Zh aWxlZDI6CisJY2xhc3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCitmYWlsZWQxOgor YWxsX2RvbmU6CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG12bmV0X2Rl dl9leGl0KHZvaWQpCit7CisJbXZuZXRfZGV2LmRldi5idXMgPSBOVUxMOworCW1kZXZfdmlydGlv X3VucmVnaXN0ZXJfZGV2aWNlKCZtdm5ldF9kZXYuZGV2KTsKKworCWRldmljZV91bnJlZ2lzdGVy KCZtdm5ldF9kZXYuZGV2KTsKKwlpZHJfZGVzdHJveSgmbXZuZXRfZGV2LnZkX2lkcik7CisJY2xh c3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCW12bmV0X2Rldi52ZF9jbGFzcyA9IE5V TEw7CisJcHJfaW5mbygibXZuZXRfZGV2OiBVbmxvYWRlZCFcbiIpOworfQorCittb2R1bGVfaW5p dChtdm5ldF9kZXZfaW5pdCkKK21vZHVsZV9leGl0KG12bmV0X2Rldl9leGl0KQorCitNT0RVTEVf TElDRU5TRSgiR1BMIHYyIik7CitNT0RVTEVfSU5GTyhzdXBwb3J0ZWQsICJTaW11bGF0ZSBsb29w YmFjayBldGhlcm5ldCBkZXZpY2Ugb3ZlciBtZGV2Iik7CitNT0RVTEVfVkVSU0lPTihWRVJTSU9O X1NUUklORyk7CitNT0RVTEVfQVVUSE9SKERSSVZFUl9BVVRIT1IpOwotLSAKMi4xOS4xCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFp bGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWw= 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 6BD59C432C3 for ; Mon, 18 Nov 2019 06:21:08 +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 4C54F2075E for ; Mon, 18 Nov 2019 06:21:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4C54F2075E 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 609CC89FA0; Mon, 18 Nov 2019 06:21:07 +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 8129789FAD for ; Mon, 18 Nov 2019 06:21:06 +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-41-1CDj9YRxPJ6pDrVU2v9BRw-1; Mon, 18 Nov 2019 01:21:03 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 1FEB3188355E; Mon, 18 Nov 2019 06:20:58 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-215.pek2.redhat.com [10.72.12.215]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2185960BF4; Mon, 18 Nov 2019 06:20:29 +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: Mon, 18 Nov 2019 14:17:03 +0800 Message-Id: <20191118061703.8669-7-jasowang@redhat.com> In-Reply-To: <20191118061703.8669-1-jasowang@redhat.com> References: <20191118061703.8669-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-MC-Unique: 1CDj9YRxPJ6pDrVU2v9BRw-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=1574058065; 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=iTcPp5HdX1tr83nOhZO3+KYdhl7hzfrc78/rmLIo9uI=; b=DAZtv2Q63sNnF2QW4bXJlez3VyDLxGRkILEnFTXaVMAyg9n9/7uCZDrPJOYsU71vyKTzKl 4Fg6lkmHwjuMPzLqc2+jliFVYQMMNPamvCSxeuBwXXDt6c+1+cNB3HEBhzqIuxxxp5Gk5e pMMnS8MzeurUC3dc/QORDRzGwiMH6Vg= Subject: [Intel-gfx] [PATCH V12 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: rdunlap@infradead.org, christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, jgg@mellanox.com, rob.miller@broadcom.com, hch@infradead.org, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, farman@linux.ibm.com, parav@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, stefanha@redhat.com, zhihong.wang@intel.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, gregkh@linuxfoundation.org, 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: <20191118061703.6K83UMOJCIgZ8L5S7qdTQukOGB2Hl4SFoxJEUBMgDwY@z> VGhpcyBzYW1wbGUgZHJpdmVyIGNyZWF0ZXMgbWRldiBkZXZpY2UgdGhhdCBzaW11bGF0ZSB2aXJ0 aW8gbmV0IGRldmljZQpvdmVyIHZpcnRpbyBtZGV2IHRyYW5zcG9ydC4gVGhlIGRldmljZSBpcyBp bXBsZW1lbnRlZCB0aHJvdWdoIHZyaW5naAphbmQgd29ya3F1ZXVlLiBBIGRldmljZSBzcGVjaWZp YyBkbWEgb3BzIGlzIHRvIG1ha2Ugc3VyZSBIVkEgaXMgdXNlZApkaXJlY3RseSBhcyB0aGUgSU9W QS4gVGhpcyBzaG91bGQgYmUgc3VmZmljaWVudCBmb3Iga2VybmVsIHZpcnRpbwpkcml2ZXIgdG8g d29yay4KCk9ubHkgJ3ZpcnRpbycgdHlwZSBpcyBzdXBwb3J0ZWQgcmlnaHQgbm93LiBJIHBsYW4g dG8gYWRkICd2aG9zdCcgdHlwZQpvbiB0b3Agd2hpY2ggcmVxdWlyZXMgc29tZSB2aXJ0dWFsIElP TU1VIGltcGxlbWVudGVkIGluIHRoaXMgc2FtcGxlCmRyaXZlci4KClNpZ25lZC1vZmYtYnk6IEph c29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogTUFJTlRBSU5FUlMgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMSArCiBzYW1wbGVzL0tjb25maWcgICAgICAgICAgICAgICAgICAg IHwgIDEwICsKIHNhbXBsZXMvdmZpby1tZGV2L01ha2VmaWxlICAgICAgICAgfCAgIDEgKwogc2Ft cGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJhY2suYyB8IDY5MCArKysrKysrKysrKysrKysrKysr KysrKysrKysrKwogNCBmaWxlcyBjaGFuZ2VkLCA3MDIgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IHNhbXBsZXMvdmZpby1tZGV2L212bmV0X2xvb3BiYWNrLmMKCmRpZmYgLS1naXQg YS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDRjMmU0MTY0MWY3YS4uYzAzMjA0OWYz ZmEwIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtMTcyMjgs NiArMTcyMjgsNyBAQCBGOgluZXQvdm13X3Zzb2NrL3ZpcnRpb190cmFuc3BvcnQuYwogRjoJZHJp dmVycy9uZXQvdnNvY2ttb24uYwogRjoJZHJpdmVycy92aG9zdC92c29jay5jCiBGOgl0b29scy90 ZXN0aW5nL3Zzb2NrLworRjoJc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJhY2suYwogCiBW SVJUSU8gQ09OU09MRSBEUklWRVIKIE06CUFtaXQgU2hhaCA8YW1pdEBrZXJuZWwub3JnPgpkaWZm IC0tZ2l0IGEvc2FtcGxlcy9LY29uZmlnIGIvc2FtcGxlcy9LY29uZmlnCmluZGV4IGM4ZGFjYjRk ZGE4MC4uMWJlZjAyOWNjOTc3IDEwMDY0NAotLS0gYS9zYW1wbGVzL0tjb25maWcKKysrIGIvc2Ft cGxlcy9LY29uZmlnCkBAIC0xMzEsNiArMTMxLDE2IEBAIGNvbmZpZyBTQU1QTEVfVkZJT19NREVW X01EUFkKIAkgIG1lZGlhdGVkIGRldmljZS4gIEl0IGlzIGEgc2ltcGxlIGZyYW1lYnVmZmVyIGFu ZCBzdXBwb3J0cwogCSAgdGhlIHJlZ2lvbiBkaXNwbGF5IGludGVyZmFjZSAoVkZJT19HRlhfUExB TkVfVFlQRV9SRUdJT04pLgogCitjb25maWcgU0FNUExFX1ZJUlRJT19NREVWX05FVF9MT09QQkFD SworCXRyaXN0YXRlICJCdWlsZCBsb29wYmFjayBWSVJUSU8gbmV0IGV4YW1wbGUgbWVkaWF0ZWQg ZGV2aWNlIHNhbXBsZSBjb2RlIC0tIGxvYWRhYmxlIG1vZHVsZXMgb25seSIKKwlkZXBlbmRzIG9u IE1ERVZfVklSVElPICYmIFZIT1NUX1JJTkcgJiYgbQorCWhlbHAKKwkgIEJ1aWxkIGEgbmV0d29y a2luZyBzYW1wbGUgZGV2aWNlIGZvciB1c2UgYXMgYSB2aXJ0aW8KKwkgIG1lZGlhdGVkIGRldmlj ZS4gVGhlIGRldmljZSBjb29wZXJhdGVzIHdpdGggdmlydGlvLW1kZXYgYnVzCisJICBkcml2ZXIg dG8gcHJlc2VudCBhbiB2aXJ0aW8gZXRoZXJuZXQgZHJpdmVyIGZvcgorCSAga2VybmVsLiBJdCBz aW1wbHkgbG9vcGJhY2tzIGFsbCBwYWNrZXRzIGZyb20gaXRzIFRYCisJICB2aXJ0cXVldWUgdG8g aXRzIFJYIHZpcnRxdWV1ZS4KKwogY29uZmlnIFNBTVBMRV9WRklPX01ERVZfTURQWV9GQgogCXRy aXN0YXRlICJCdWlsZCBWRklPIG1kcHkgZXhhbXBsZSBndWVzdCBmYmRldiBkcml2ZXIgLS0gbG9h ZGFibGUgbW9kdWxlIG9ubHkiCiAJZGVwZW5kcyBvbiBGQiAmJiBtCmRpZmYgLS1naXQgYS9zYW1w bGVzL3ZmaW8tbWRldi9NYWtlZmlsZSBiL3NhbXBsZXMvdmZpby1tZGV2L01ha2VmaWxlCmluZGV4 IDEwZDE3OWM0ZmRlYi4uODE3NjE4NTY5ODQ4IDEwMDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8tbWRl di9NYWtlZmlsZQorKysgYi9zYW1wbGVzL3ZmaW8tbWRldi9NYWtlZmlsZQpAQCAtMywzICszLDQg QEAgb2JqLSQoQ09ORklHX1NBTVBMRV9WRklPX01ERVZfTVRUWSkgKz0gbXR0eS5vCiBvYmotJChD T05GSUdfU0FNUExFX1ZGSU9fTURFVl9NRFBZKSArPSBtZHB5Lm8KIG9iai0kKENPTkZJR19TQU1Q TEVfVkZJT19NREVWX01EUFlfRkIpICs9IG1kcHktZmIubwogb2JqLSQoQ09ORklHX1NBTVBMRV9W RklPX01ERVZfTUJPQ0hTKSArPSBtYm9jaHMubworb2JqLSQoQ09ORklHX1NBTVBMRV9WSVJUSU9f TURFVl9ORVRfTE9PUEJBQ0spICs9IG12bmV0X2xvb3BiYWNrLm8KZGlmZiAtLWdpdCBhL3NhbXBs ZXMvdmZpby1tZGV2L212bmV0X2xvb3BiYWNrLmMgYi9zYW1wbGVzL3ZmaW8tbWRldi9tdm5ldF9s b29wYmFjay5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNzkwNTlh MTc3ZjM5Ci0tLSAvZGV2L251bGwKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXZuZXRfbG9vcGJh Y2suYwpAQCAtMCwwICsxLDY5MCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjAtb25seQorLyoKKyAqIE1lZGlhdGVkIHZpcnR1YWwgdmlydGlvLW5ldCBkZXZpY2UgZHJpdmVy LgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxOSwgUmVkIEhhdCBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiAgICAgQXV0aG9yOiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgor ICoKKyAqIFNhbXBsZSBkcml2ZXIgdGhhdCBjcmVhdGVzIG1kZXYgZGV2aWNlIHRoYXQgc2ltdWxh dGVzIGV0aGVybmV0IGxvb3BiYWNrCisgKiBkZXZpY2UuCisgKgorICogVXNhZ2U6CisgKgorICog IyBtb2Rwcm9iZSB2aXJ0aW9fbWRldgorICogIyBtb2Rwcm9iZSBtdm5ldF9sb29wYmFjaworICog IyBjZCAvc3lzL2RldmljZXMvdmlydHVhbC9tdm5ldF9sb29wYmFjay9tdm5ldF9sb29wYmFjay8g XAorICogICAgICBtZGV2X3N1cHBvcnRlZF90eXBlcy9tdm5ldF9sb29wYmFjay12aXJ0aW8KKyAq ICMgZWNobyAiODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxIiA+IC4vY3JlYXRl CisgKiAjIGNkIGRldmljZXMvODNiOGY0ZjItNTA5Zi0zODJmLTNjMWUtZTZiZmUwZmExMDAxCisg KiAjIGxzIC1kIHZpcnRpbzAKKyAqIHZpcnRpbzAKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5p dC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5j bHVkZSA8bGludXgvcG9sbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxs aW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKyNpbmNsdWRlIDxsaW51eC91 dWlkLmg+CisjaW5jbHVkZSA8bGludXgvaW9tbXUuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNmcy5o PgorI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNsdWRlIDxsaW51eC92cmluZ2guaD4KKyNp bmNsdWRlIDxsaW51eC9tZGV2X3ZpcnRpby5oPgorI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlv X2NvbmZpZy5oPgorI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX25ldC5oPgorCisjZGVmaW5l IFZFUlNJT05fU1RSSU5HICAiMC4xIgorI2RlZmluZSBEUklWRVJfQVVUSE9SICAgIlJlZCBIYXQg Q29ycG9yYXRpb24iCisKKyNkZWZpbmUgTVZORVRfQ0xBU1NfTkFNRSAibXZuZXRfbG9vcGJhY2si CisjZGVmaW5lIE1WTkVUX05BTUUgICAgICAgIm12bmV0X2xvb3BiYWNrIgorCisjZGVmaW5lIFZJ UlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HICJ2aXJ0aW8tbWRldiIKKworLyoKKyAqIEdsb2Jh bCBTdHJ1Y3R1cmVzCisgKi8KKworc3RhdGljIHN0cnVjdCBtdm5ldF9kZXYgeworCXN0cnVjdCBj bGFzcwkqdmRfY2xhc3M7CisJc3RydWN0IGlkcgl2ZF9pZHI7CisJc3RydWN0IGRldmljZQlkZXY7 Cit9IG12bmV0X2RldjsKKworc3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB7CisJc3RydWN0IHZyaW5n aCB2cmluZzsKKwlzdHJ1Y3QgdnJpbmdoX2tpb3YgaW92OworCXVuc2lnbmVkIHNob3J0IGhlYWQ7 CisJYm9vbCByZWFkeTsKKwl1NjQgZGVzY19hZGRyOworCXU2NCBkZXZpY2VfYWRkcjsKKwl1NjQg ZHJpdmVyX2FkZHI7CisJdTMyIG51bTsKKwl2b2lkICpwcml2YXRlOworCWlycXJldHVybl90ICgq Y2IpKHZvaWQgKmRhdGEpOworfTsKKworI2RlZmluZSBNVk5FVF9RVUVVRV9BTElHTiBQQUdFX1NJ WkUKKyNkZWZpbmUgTVZORVRfUVVFVUVfTUFYIDI1NgorI2RlZmluZSBNVk5FVF9ERVZJQ0VfSUQg MHgxCisjZGVmaW5lIE1WTkVUX1ZFTkRPUl9JRCAwCisKK3U2NCBtdm5ldF9mZWF0dXJlcyA9ICgx VUxMIDw8IFZJUlRJT19GX0FOWV9MQVlPVVQpIHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9W RVJTSU9OXzEpIHwKKwkJICAgICAoMVVMTCA8PCBWSVJUSU9fRl9JT01NVV9QTEFURk9STSk7CisK Ky8qIFN0YXRlIG9mIGVhY2ggbWRldiBkZXZpY2UgKi8KK3N0cnVjdCBtdm5ldF9zdGF0ZSB7CisJ c3RydWN0IG12bmV0X3ZpcnRxdWV1ZSB2cXNbMl07CisJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7 CisJLyogc3BpbmxvY2sgdG8gc3luY2hyb25pemUgdmlydHF1ZXVlIHN0YXRlICovCisJc3Bpbmxv Y2tfdCBsb2NrOworCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldjsKKwlzdHJ1Y3QgdmlydGlvX25l dF9jb25maWcgY29uZmlnOworCXZvaWQgKmJ1ZmZlcjsKKwl1MzIgc3RhdHVzOworCXUzMiBnZW5l cmF0aW9uOworCXU2NCBmZWF0dXJlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG5leHQ7Cit9OworCitz dGF0aWMgc3RydWN0IG11dGV4IG1kZXZfbGlzdF9sb2NrOworc3RhdGljIHN0cnVjdCBsaXN0X2hl YWQgbWRldl9kZXZpY2VzX2xpc3Q7CisKK3N0YXRpYyB2b2lkIG12bmV0X3F1ZXVlX3JlYWR5KHN0 cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQsIHVuc2lnbmVkIGludCBpZHgpCit7CisJc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCWludCByZXQ7CisKKwlyZXQg PSB2cmluZ2hfaW5pdF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5FVF9RVUVV RV9NQVgsCisJCQkgICAgICAgZmFsc2UsIChzdHJ1Y3QgdnJpbmdfZGVzYyAqKXZxLT5kZXNjX2Fk ZHIsCisJCQkgICAgICAgKHN0cnVjdCB2cmluZ19hdmFpbCAqKXZxLT5kcml2ZXJfYWRkciwKKwkJ CSAgICAgICAoc3RydWN0IHZyaW5nX3VzZWQgKil2cS0+ZGV2aWNlX2FkZHIpOworfQorCitzdGF0 aWMgdm9pZCBtdm5ldF92cV9yZXNldChzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSkKK3sKKwl2 cS0+cmVhZHkgPSAwOworCXZxLT5kZXNjX2FkZHIgPSAwOworCXZxLT5kcml2ZXJfYWRkciA9IDA7 CisJdnEtPmRldmljZV9hZGRyID0gMDsKKwl2cS0+Y2IgPSBOVUxMOworCXZxLT5wcml2YXRlID0g TlVMTDsKKwl2cmluZ2hfaW5pdF9rZXJuKCZ2cS0+dnJpbmcsIG12bmV0X2ZlYXR1cmVzLCBNVk5F VF9RVUVVRV9NQVgsCisJCQkgZmFsc2UsIDAsIDAsIDApOworfQorCitzdGF0aWMgdm9pZCBtdm5l dF9yZXNldChzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0KQoreworCWludCBpOworCisJZm9yIChp ID0gMDsgaSA8IDI7IGkrKykKKwkJbXZuZXRfdnFfcmVzZXQoJm12bmV0LT52cXNbaV0pOworCisJ bXZuZXQtPmZlYXR1cmVzID0gMDsKKwltdm5ldC0+c3RhdHVzID0gMDsKKwkrK212bmV0LT5nZW5l cmF0aW9uOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAq d29yaykKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gY29udGFpbmVyX29mKHdvcmss IHN0cnVjdAorCQkJCQkJIG12bmV0X3N0YXRlLCB3b3JrKTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1 ZXVlICp0eHEgPSAmbXZuZXQtPnZxc1sxXTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICpyeHEg PSAmbXZuZXQtPnZxc1swXTsKKwlzaXplX3QgcmVhZCwgd3JpdGUsIHRvdGFsX3dyaXRlOworCWlu dCBlcnI7CisJaW50IHBrdHMgPSAwOworCisJc3Bpbl9sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlp ZiAoIXR4cS0+cmVhZHkgfHwgIXJ4cS0+cmVhZHkpCisJCWdvdG8gb3V0OworCisJd2hpbGUgKHRy dWUpIHsKKwkJdG90YWxfd3JpdGUgPSAwOworCQllcnIgPSB2cmluZ2hfZ2V0ZGVzY19rZXJuKCZ0 eHEtPnZyaW5nLCAmdHhxLT5pb3YsIE5VTEwsCisJCQkJCSAgJnR4cS0+aGVhZCwgR0ZQX0FUT01J Qyk7CisJCWlmIChlcnIgPD0gMCkKKwkJCWJyZWFrOworCisJCWVyciA9IHZyaW5naF9nZXRkZXNj X2tlcm4oJnJ4cS0+dnJpbmcsIE5VTEwsICZyeHEtPmlvdiwKKwkJCQkJICAmcnhxLT5oZWFkLCBH RlBfQVRPTUlDKTsKKwkJaWYgKGVyciA8PSAwKSB7CisJCQl2cmluZ2hfY29tcGxldGVfa2Vybigm dHhxLT52cmluZywgdHhxLT5oZWFkLCAwKTsKKwkJCWJyZWFrOworCQl9CisKKwkJd2hpbGUgKHRy dWUpIHsKKwkJCXJlYWQgPSB2cmluZ2hfaW92X3B1bGxfa2VybigmdHhxLT5pb3YsIG12bmV0LT5i dWZmZXIsCisJCQkJCQkgICAgUEFHRV9TSVpFKTsKKwkJCWlmIChyZWFkIDw9IDApCisJCQkJYnJl YWs7CisKKwkJCXdyaXRlID0gdnJpbmdoX2lvdl9wdXNoX2tlcm4oJnJ4cS0+aW92LCBtdm5ldC0+ YnVmZmVyLAorCQkJCQkJICAgICByZWFkKTsKKwkJCWlmICh3cml0ZSA8PSAwKQorCQkJCWJyZWFr OworCisJCQl0b3RhbF93cml0ZSArPSB3cml0ZTsKKwkJfQorCisJCS8qIE1ha2Ugc3VyZSBkYXRh IGlzIHdyb3RlIGJlZm9yZSBhZHZhbmNpbmcgaW5kZXggKi8KKwkJc21wX3dtYigpOworCisJCXZy aW5naF9jb21wbGV0ZV9rZXJuKCZ0eHEtPnZyaW5nLCB0eHEtPmhlYWQsIDApOworCQl2cmluZ2hf Y29tcGxldGVfa2VybigmcnhxLT52cmluZywgcnhxLT5oZWFkLCB0b3RhbF93cml0ZSk7CisKKwkJ LyogTWFrZSBzdXJlIHVzZWQgaXMgdmlzaWJsZSBiZWZvcmUgcmFzaW5nIHRoZSBpbnRlcnJ1cHQu ICovCisJCXNtcF93bWIoKTsKKworCQlsb2NhbF9iaF9kaXNhYmxlKCk7CisJCWlmICh0eHEtPmNi KQorCQkJdHhxLT5jYih0eHEtPnByaXZhdGUpOworCQlpZiAocnhxLT5jYikKKwkJCXJ4cS0+Y2Io cnhxLT5wcml2YXRlKTsKKwkJbG9jYWxfYmhfZW5hYmxlKCk7CisKKwkJaWYgKCsrcGt0cyA+IDQp IHsKKwkJCXNjaGVkdWxlX3dvcmsoJm12bmV0LT53b3JrKTsKKwkJCWdvdG8gb3V0OworCQl9CisJ fQorCitvdXQ6CisJc3Bpbl91bmxvY2soJm12bmV0LT5sb2NrKTsKK30KKworc3RhdGljIGRtYV9h ZGRyX3QgbXZuZXRfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFn ZSwKKwkJCQkgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLAorCQkJCSBlbnVtIGRt YV9kYXRhX2RpcmVjdGlvbiBkaXIsCisJCQkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCit7CisJLyog VnJpbmdoIGNhbiBvbmx5IHVzZSBIVkEgKi8KKwlyZXR1cm4gKGRtYV9hZGRyX3QpKHBhZ2VfYWRk cmVzcyhwYWdlKSArIG9mZnNldCk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3VubWFwX3BhZ2Uo c3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRyLAorCQkJICAgICBzaXplX3Qg c2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAorCQkJICAgICB1bnNpZ25lZCBsb25n IGF0dHJzKQoreworfQorCitzdGF0aWMgdm9pZCAqbXZuZXRfYWxsb2NfY29oZXJlbnQoc3RydWN0 IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKKwkJCQkgIGRtYV9hZGRyX3QgKmRtYV9hZGRyLCBn ZnBfdCBmbGFnLAorCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKK3sKKwl2b2lkICphZGRyID0g a21hbGxvYyhzaXplLCBmbGFnKTsKKworCWlmICghYWRkcikKKwkJKmRtYV9hZGRyID0gRE1BX01B UFBJTkdfRVJST1I7CisJZWxzZQorCQkqZG1hX2FkZHIgPSAoZG1hX2FkZHJfdClhZGRyOworCisJ cmV0dXJuIGFkZHI7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2ZyZWVfY29oZXJlbnQoc3RydWN0 IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKKwkJCQl2b2lkICp2YWRkciwgZG1hX2FkZHJfdCBk bWFfYWRkciwKKwkJCQl1bnNpZ25lZCBsb25nIGF0dHJzKQoreworCWtmcmVlKCh2b2lkICopZG1h X2FkZHIpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIG12bmV0X2RtYV9v cHMgPSB7CisJLm1hcF9wYWdlID0gbXZuZXRfbWFwX3BhZ2UsCisJLnVubWFwX3BhZ2UgPSBtdm5l dF91bm1hcF9wYWdlLAorCS5hbGxvYyA9IG12bmV0X2FsbG9jX2NvaGVyZW50LAorCS5mcmVlID0g bXZuZXRfZnJlZV9jb2hlcmVudCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl92aXJ0 aW9fb3BzIG1kZXZfdmlydGlvX29wczsKKworc3RhdGljIGludCBtdm5ldF9jcmVhdGUoc3RydWN0 IGtvYmplY3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlzdHJ1Y3QgbXZu ZXRfc3RhdGUgKm12bmV0OworCXN0cnVjdCB2aXJ0aW9fbmV0X2NvbmZpZyAqY29uZmlnOworCXN0 cnVjdCBkZXZpY2UgKmRldiA9IG1kZXZfZGV2KG1kZXYpOworCisJaWYgKCFtZGV2KQorCQlyZXR1 cm4gLUVJTlZBTDsKKworCW12bmV0ID0ga3phbGxvYyhzaXplb2YoKm12bmV0KSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFtdm5ldCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltdm5ldC0+YnVmZmVyID0g a21hbGxvYyhQQUdFX1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghbXZuZXQtPmJ1ZmZlcikgewor CQlrZnJlZShtdm5ldCk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWNvbmZpZyA9ICZtdm5l dC0+Y29uZmlnOworCWNvbmZpZy0+bXR1ID0gMTUwMDsKKwljb25maWctPnN0YXR1cyA9IFZJUlRJ T19ORVRfU19MSU5LX1VQOworCWV0aF9yYW5kb21fYWRkcihjb25maWctPm1hYyk7CisKKwlJTklU X1dPUksoJm12bmV0LT53b3JrLCBtdm5ldF93b3JrKTsKKworCXNwaW5fbG9ja19pbml0KCZtdm5l dC0+bG9jayk7CisJbXZuZXQtPm1kZXYgPSBtZGV2OworCW1kZXZfc2V0X2RydmRhdGEobWRldiwg bXZuZXQpOworCisJbXV0ZXhfbG9jaygmbWRldl9saXN0X2xvY2spOworCWxpc3RfYWRkKCZtdm5l dC0+bmV4dCwgJm1kZXZfZGV2aWNlc19saXN0KTsKKwltdXRleF91bmxvY2soJm1kZXZfbGlzdF9s b2NrKTsKKworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklUX01BU0soNjQpOworCXNl dF9kbWFfb3BzKGRldiwgJm12bmV0X2RtYV9vcHMpOworCisJbWRldl92aXJ0aW9fc2V0X29wcyht ZGV2LCAmbWRldl92aXJ0aW9fb3BzKTsKKwltZGV2X3ZpcnRpb19zZXRfY2xhc3NfaWQobWRldiwg TURFVl9WSVJUSU9fQ0xBU1NfSURfVklSVElPKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IG12bmV0X3JlbW92ZShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG12 bmV0X3N0YXRlICptZHMsICp0bXBfbWRzOworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBt ZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCWludCByZXQgPSAtRUlOVkFMOworCisJbXV0ZXhfbG9j aygmbWRldl9saXN0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShtZHMsIHRtcF9t ZHMsICZtZGV2X2RldmljZXNfbGlzdCwgbmV4dCkgeworCQlpZiAobXZuZXQgPT0gbWRzKSB7CisJ CQlsaXN0X2RlbCgmbXZuZXQtPm5leHQpOworCQkJbWRldl9zZXRfZHJ2ZGF0YShtZGV2LCBOVUxM KTsKKwkJCWtmcmVlKG12bmV0LT5idWZmZXIpOworCQkJa2ZyZWUobXZuZXQpOworCQkJcmV0ID0g MDsKKwkJCWJyZWFrOworCQl9CisJfQorCW11dGV4X3VubG9jaygmbWRldl9saXN0X2xvY2spOwor CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHNzaXplX3QKK3NhbXBsZV9tdm5ldF9kZXZfc2hv dyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkg ICAgICBjaGFyICpidWYpCit7CisJaWYgKG1kZXZfdmlydGlvX2Zyb21fZGV2KGRldikpCisJCXJl dHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xuIiwgZGV2X25hbWUoZGV2KSk7CisK KwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitzdGF0aWMgREVWSUNFX0FUVFJfUk8o c2FtcGxlX212bmV0X2Rldik7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICptdm5ldF9kZXZf YXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfc2FtcGxlX212bmV0X2Rldi5hdHRyLAorCU5VTEwsCit9 OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBtdm5ldF9kZXZfZ3JvdXAg PSB7CisJLm5hbWUgID0gIm12bmV0X2RldiIsCisJLmF0dHJzID0gbXZuZXRfZGV2X2F0dHJzLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKm12bmV0X2Rldl9ncm91 cHNbXSA9IHsKKwkmbXZuZXRfZGV2X2dyb3VwLAorCU5VTEwsCit9OworCitzdGF0aWMgc3NpemVf dAorc2FtcGxlX21kZXZfZGV2X3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNl X2F0dHJpYnV0ZSAqYXR0ciwKKwkJICAgICBjaGFyICpidWYpCit7CisJaWYgKG1kZXZfdmlydGlv X2Zyb21fZGV2KGRldikpCisJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIlRoaXMgaXMgTURFViAlc1xu IiwgZGV2X25hbWUoZGV2KSk7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICJcbiIpOworfQorCitz dGF0aWMgREVWSUNFX0FUVFJfUk8oc2FtcGxlX21kZXZfZGV2KTsKKworc3RhdGljIHN0cnVjdCBh dHRyaWJ1dGUgKm1kZXZfZGV2X2F0dHJzW10gPSB7CisJJmRldl9hdHRyX3NhbXBsZV9tZGV2X2Rl di5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91 cCBtZGV2X2Rldl9ncm91cCA9IHsKKwkubmFtZSAgPSAidmVuZG9yIiwKKwkuYXR0cnMgPSBtZGV2 X2Rldl9hdHRycywKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICpt ZGV2X2Rldl9ncm91cHNbXSA9IHsKKwkmbWRldl9kZXZfZ3JvdXAsCisJTlVMTCwKK307CisKKyNk ZWZpbmUgTVZORVRfU1RSSU5HX0xFTiAxNgorCitzdGF0aWMgc3NpemVfdAorbmFtZV9zaG93KHN0 cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgZGV2aWNlICpkZXYsIGNoYXIgKmJ1ZikKK3sKKwlj aGFyIG5hbWVbTVZORVRfU1RSSU5HX0xFTl07CisJY29uc3QgY2hhciAqbmFtZV9zdHIgPSAidmly dGlvLW5ldCI7CisKKwlzbnByaW50ZihuYW1lLCBNVk5FVF9TVFJJTkdfTEVOLCAiJXMiLCBkZXZf ZHJpdmVyX3N0cmluZyhkZXYpKTsKKwlpZiAoIXN0cmNtcChrb2JqLT5uYW1lLCBuYW1lKSkKKwkJ cmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIG5hbWVfc3RyKTsKKworCXJldHVybiAtRUlOVkFM OworfQorCitzdGF0aWMgTURFVl9UWVBFX0FUVFJfUk8obmFtZSk7CisKK3N0YXRpYyBzc2l6ZV90 CithdmFpbGFibGVfaW5zdGFuY2VzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBk ZXZpY2UgKmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBJ TlRfTUFYKTsKK30KKworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGF2YWlsYWJsZV9pbnN0YW5j ZXMpOworCitzdGF0aWMgc3NpemVfdCBkZXZpY2VfYXBpX3Nob3coc3RydWN0IGtvYmplY3QgKmtv YmosIHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgICBjaGFyICpidWYpCit7CisJcmV0dXJu IHNwcmludGYoYnVmLCAiJXNcbiIsIFZJUlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HKTsKK30K Kworc3RhdGljIE1ERVZfVFlQRV9BVFRSX1JPKGRldmljZV9hcGkpOworCitzdGF0aWMgc3RydWN0 IGF0dHJpYnV0ZSAqbWRldl90eXBlc19hdHRyc1tdID0geworCSZtZGV2X3R5cGVfYXR0cl9uYW1l LmF0dHIsCisJJm1kZXZfdHlwZV9hdHRyX2RldmljZV9hcGkuYXR0ciwKKwkmbWRldl90eXBlX2F0 dHJfYXZhaWxhYmxlX2luc3RhbmNlcy5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0 IGF0dHJpYnV0ZV9ncm91cCBtZGV2X3R5cGVfZ3JvdXAgPSB7CisJLm5hbWUgID0gInZpcnRpbyIs CisJLmF0dHJzID0gbWRldl90eXBlc19hdHRycywKK307CisKKy8qIFRCRDogInZob3N0IiB0eXBl ICovCisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICptZGV2X3R5cGVfZ3JvdXBzW10g PSB7CisJJm1kZXZfdHlwZV9ncm91cCwKKwlOVUxMLAorfTsKKworc3RhdGljIGludCBtdm5ldF9z ZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHUxNiBpZHgsCisJCQkJdTY0 IGRlc2NfYXJlYSwgdTY0IGRyaXZlcl9hcmVhLCB1NjQgZGV2aWNlX2FyZWEpCit7CisJc3RydWN0 IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisJc3RydWN0IG12 bmV0X3ZpcnRxdWV1ZSAqdnEgPSAmbXZuZXQtPnZxc1tpZHhdOworCisJdnEtPmRlc2NfYWRkciA9 IGRlc2NfYXJlYTsKKwl2cS0+ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKKwl2cS0+ZGV2aWNl X2FkZHIgPSBkZXZpY2VfYXJlYTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBtdm5l dF9zZXRfdnFfbnVtKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgdTMyIG51bSkK K3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsK KwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2cS0+ bnVtID0gbnVtOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9raWNrX3ZxKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdTE2IGlkeCkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRl dl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5l dC0+dnFzW2lkeF07CisKKwlpZiAodnEtPnJlYWR5KQorCQlzY2hlZHVsZV93b3JrKCZtdm5ldC0+ d29yayk7Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X3NldF92cV9jYihzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYsIHUxNiBpZHgsCisJCQkgICAgc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrICpj YikKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2 KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5ldC0+dnFzW2lkeF07CisKKwl2 cS0+Y2IgPSBjYi0+Y2FsbGJhY2s7CisJdnEtPnByaXZhdGUgPSBjYi0+cHJpdmF0ZTsKK30KKwor c3RhdGljIHZvaWQgbXZuZXRfc2V0X3ZxX3JlYWR5KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwg dTE2IGlkeCwgYm9vbCByZWFkeSkKK3sKKwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRl dl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwlzdHJ1Y3QgbXZuZXRfdmlydHF1ZXVlICp2cSA9ICZtdm5l dC0+dnFzW2lkeF07CisKKwlzcGluX2xvY2soJm12bmV0LT5sb2NrKTsKKwl2cS0+cmVhZHkgPSBy ZWFkeTsKKwlpZiAodnEtPnJlYWR5KQorCQltdm5ldF9xdWV1ZV9yZWFkeShtdm5ldCwgaWR4KTsK KwlzcGluX3VubG9jaygmbXZuZXQtPmxvY2spOworfQorCitzdGF0aWMgYm9vbCBtdm5ldF9nZXRf dnFfcmVhZHkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQoreworCXN0cnVjdCBt dm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5l dF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKworCXJldHVybiB2cS0+cmVhZHk7 Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X3ZxX3N0YXRlKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwgdTE2IGlkeCwgdTY0IHN0YXRlKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0g Jm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3QgdnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJ c3Bpbl9sb2NrKCZtdm5ldC0+bG9jayk7CisJdnJoLT5sYXN0X2F2YWlsX2lkeCA9IHN0YXRlOwor CXNwaW5fdW5sb2NrKCZtdm5ldC0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHU2 NCBtdm5ldF9nZXRfdnFfc3RhdGUoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KQor eworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOwor CXN0cnVjdCBtdm5ldF92aXJ0cXVldWUgKnZxID0gJm12bmV0LT52cXNbaWR4XTsKKwlzdHJ1Y3Qg dnJpbmdoICp2cmggPSAmdnEtPnZyaW5nOworCisJcmV0dXJuIHZyaC0+bGFzdF9hdmFpbF9pZHg7 Cit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX2FsaWduKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldikKK3sKKwlyZXR1cm4gTVZORVRfUVVFVUVfQUxJR047Cit9CisKK3N0YXRpYyB1NjQgbXZu ZXRfZ2V0X2ZlYXR1cmVzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gbXZu ZXRfZmVhdHVyZXM7Cit9CisKK3N0YXRpYyBpbnQgbXZuZXRfc2V0X2ZlYXR1cmVzKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiwgdTY0IGZlYXR1cmVzKQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAq bXZuZXQgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJLyogRE1BIG1hcHBpbmcgbXVzdCBi ZSBkb25lIGJ5IGRyaXZlciAqLworCWlmICghKGZlYXR1cmVzICYgKDFVTEwgPDwgVklSVElPX0Zf SU9NTVVfUExBVEZPUk0pKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltdm5ldC0+ZmVhdHVyZXMg PSBmZWF0dXJlcyAmIG12bmV0X2ZlYXR1cmVzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2 b2lkIG12bmV0X3NldF9jb25maWdfY2Ioc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LAorCQkJCXN0 cnVjdCB2aXJ0aW9fbWRldl9jYWxsYmFjayAqY2IpCit7CisJLyogV2UgZG9uJ3Qgc3VwcG9ydCBj b25maWcgaW50ZXJydXB0ICovCit9CisKK3N0YXRpYyB1MTYgbXZuZXRfZ2V0X3ZxX251bV9tYXgo c3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXJldHVybiBNVk5FVF9RVUVVRV9NQVg7Cit9 CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2RldmljZV9pZChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYpCit7CisJcmV0dXJuIE1WTkVUX0RFVklDRV9JRDsKK30KKworc3RhdGljIHUzMiBtdm5ldF9n ZXRfdmVuZG9yX2lkKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlyZXR1cm4gTVZORVRf VkVORE9SX0lEOworfQorCitzdGF0aWMgdTggbXZuZXRfZ2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9k ZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9IG1kZXZfZ2V0X2Ry dmRhdGEobWRldik7CisKKwlyZXR1cm4gbXZuZXQtPnN0YXR1czsKK30KKworc3RhdGljIHZvaWQg bXZuZXRfc2V0X3N0YXR1cyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHU4IHN0YXR1cykKK3sK KwlzdHJ1Y3QgbXZuZXRfc3RhdGUgKm12bmV0ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKwor CW12bmV0LT5zdGF0dXMgPSBzdGF0dXM7CisKKwlpZiAoc3RhdHVzID09IDApIHsKKwkJc3Bpbl9s b2NrKCZtdm5ldC0+bG9jayk7CisJCW12bmV0X3Jlc2V0KG12bmV0KTsKKwkJc3Bpbl91bmxvY2so Jm12bmV0LT5sb2NrKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIG12bmV0X2dldF9jb25maWcoc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAorCQkJICAgICB2b2lk ICpidWYsIHVuc2lnbmVkIGludCBsZW4pCit7CisJc3RydWN0IG12bmV0X3N0YXRlICptdm5ldCA9 IG1kZXZfZ2V0X2RydmRhdGEobWRldik7CisKKwlpZiAob2Zmc2V0ICsgbGVuIDwgc2l6ZW9mKHN0 cnVjdCB2aXJ0aW9fbmV0X2NvbmZpZykpCisJCW1lbWNweShidWYsICZtdm5ldC0+Y29uZmlnICsg b2Zmc2V0LCBsZW4pOworfQorCitzdGF0aWMgdm9pZCBtdm5ldF9zZXRfY29uZmlnKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiwgdW5zaWduZWQgaW50IG9mZnNldCwKKwkJCSAgICAgY29uc3Qgdm9p ZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQoreworCS8qIE5vIHdyaXRhYmxlIGNvbmZpZyBzdXBw b3J0dGVkIGJ5IG12bmV0ICovCit9CisKK3N0YXRpYyB1MzIgbXZuZXRfZ2V0X2dlbmVyYXRpb24o c3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBtdm5ldF9zdGF0ZSAqbXZuZXQg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJcmV0dXJuIG12bmV0LT5nZW5lcmF0aW9uOwor fQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX29wcyBtZGV2X3ZpcnRpb19vcHMg PSB7CisJLnNldF92cV9hZGRyZXNzICAgICAgICAgPSBtdm5ldF9zZXRfdnFfYWRkcmVzcywKKwku c2V0X3ZxX251bSAgICAgICAgICAgICA9IG12bmV0X3NldF92cV9udW0sCisJLmtpY2tfdnEgICAg ICAgICAgICAgICAgPSBtdm5ldF9raWNrX3ZxLAorCS5zZXRfdnFfY2IgICAgICAgICAgICAgID0g bXZuZXRfc2V0X3ZxX2NiLAorCS5zZXRfdnFfcmVhZHkgICAgICAgICAgID0gbXZuZXRfc2V0X3Zx X3JlYWR5LAorCS5nZXRfdnFfcmVhZHkgICAgICAgICAgID0gbXZuZXRfZ2V0X3ZxX3JlYWR5LAor CS5zZXRfdnFfc3RhdGUgICAgICAgICAgID0gbXZuZXRfc2V0X3ZxX3N0YXRlLAorCS5nZXRfdnFf c3RhdGUgICAgICAgICAgID0gbXZuZXRfZ2V0X3ZxX3N0YXRlLAorCS5nZXRfdnFfYWxpZ24gICAg ICAgICAgID0gbXZuZXRfZ2V0X3ZxX2FsaWduLAorCS5nZXRfZmVhdHVyZXMgICAgICAgICAgID0g bXZuZXRfZ2V0X2ZlYXR1cmVzLAorCS5zZXRfZmVhdHVyZXMgICAgICAgICAgID0gbXZuZXRfc2V0 X2ZlYXR1cmVzLAorCS5zZXRfY29uZmlnX2NiICAgICAgICAgID0gbXZuZXRfc2V0X2NvbmZpZ19j YiwKKwkuZ2V0X3ZxX251bV9tYXggICAgICAgICA9IG12bmV0X2dldF92cV9udW1fbWF4LAorCS5n ZXRfZGV2aWNlX2lkICAgICAgICAgID0gbXZuZXRfZ2V0X2RldmljZV9pZCwKKwkuZ2V0X3ZlbmRv cl9pZCAgICAgICAgICA9IG12bmV0X2dldF92ZW5kb3JfaWQsCisJLmdldF9zdGF0dXMgICAgICAg ICAgICAgPSBtdm5ldF9nZXRfc3RhdHVzLAorCS5zZXRfc3RhdHVzICAgICAgICAgICAgID0gbXZu ZXRfc2V0X3N0YXR1cywKKwkuZ2V0X2NvbmZpZyAgICAgICAgICAgICA9IG12bmV0X2dldF9jb25m aWcsCisJLnNldF9jb25maWcgICAgICAgICAgICAgPSBtdm5ldF9zZXRfY29uZmlnLAorCS5nZXRf Z2VuZXJhdGlvbiAgICAgICAgID0gbXZuZXRfZ2V0X2dlbmVyYXRpb24sCit9OworCitzdGF0aWMg Y29uc3Qgc3RydWN0IG1kZXZfcGFyZW50X29wcyBtZGV2X2ZvcHMgPSB7CisJLm93bmVyICAgICAg ICAgICAgICAgICAgPSBUSElTX01PRFVMRSwKKwkuZGV2X2F0dHJfZ3JvdXBzICAgICAgICA9IG12 bmV0X2Rldl9ncm91cHMsCisJLm1kZXZfYXR0cl9ncm91cHMgICAgICAgPSBtZGV2X2Rldl9ncm91 cHMsCisJLnN1cHBvcnRlZF90eXBlX2dyb3VwcyAgPSBtZGV2X3R5cGVfZ3JvdXBzLAorCS5jcmVh dGUgICAgICAgICAgICAgICAgID0gbXZuZXRfY3JlYXRlLAorCS5yZW1vdmUJCQk9IG12bmV0X3Jl bW92ZSwKK307CisKK3N0YXRpYyB2b2lkIG12bmV0X2RldmljZV9yZWxlYXNlKHN0cnVjdCBkZXZp Y2UgKmRldikKK3sKKwlkZXZfZGJnKGRldiwgIm12bmV0OiByZWxlYXNlZFxuIik7Cit9CisKK3N0 YXRpYyBpbnQgX19pbml0IG12bmV0X2Rldl9pbml0KHZvaWQpCit7CisJaW50IHJldCA9IDA7CisK Kwlwcl9pbmZvKCJtdm5ldF9kZXY6ICVzXG4iLCBfX2Z1bmNfXyk7CisKKwltZW1zZXQoJm12bmV0 X2RldiwgMCwgc2l6ZW9mKG12bmV0X2RldikpOworCisJaWRyX2luaXQoJm12bmV0X2Rldi52ZF9p ZHIpOworCisJbXZuZXRfZGV2LnZkX2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCBN Vk5FVF9DTEFTU19OQU1FKTsKKworCWlmIChJU19FUlIobXZuZXRfZGV2LnZkX2NsYXNzKSkgewor CQlwcl9lcnIoIkVycm9yOiBmYWlsZWQgdG8gcmVnaXN0ZXIgbXZuZXRfZGV2IGNsYXNzXG4iKTsK KwkJcmV0ID0gUFRSX0VSUihtdm5ldF9kZXYudmRfY2xhc3MpOworCQlnb3RvIGZhaWxlZDE7CisJ fQorCisJbXZuZXRfZGV2LmRldi5jbGFzcyA9IG12bmV0X2Rldi52ZF9jbGFzczsKKwltdm5ldF9k ZXYuZGV2LnJlbGVhc2UgPSBtdm5ldF9kZXZpY2VfcmVsZWFzZTsKKwlkZXZfc2V0X25hbWUoJm12 bmV0X2Rldi5kZXYsICIlcyIsIE1WTkVUX05BTUUpOworCisJcmV0ID0gZGV2aWNlX3JlZ2lzdGVy KCZtdm5ldF9kZXYuZGV2KTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWxlZDI7CisKKwlyZXQgPSBt ZGV2X3ZpcnRpb19yZWdpc3Rlcl9kZXZpY2UoJm12bmV0X2Rldi5kZXYsICZtZGV2X2ZvcHMpOwor CWlmIChyZXQpCisJCWdvdG8gZmFpbGVkMzsKKworCW11dGV4X2luaXQoJm1kZXZfbGlzdF9sb2Nr KTsKKwlJTklUX0xJU1RfSEVBRCgmbWRldl9kZXZpY2VzX2xpc3QpOworCisJZ290byBhbGxfZG9u ZTsKKworZmFpbGVkMzoKKworCWRldmljZV91bnJlZ2lzdGVyKCZtdm5ldF9kZXYuZGV2KTsKK2Zh aWxlZDI6CisJY2xhc3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCitmYWlsZWQxOgor YWxsX2RvbmU6CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG12bmV0X2Rl dl9leGl0KHZvaWQpCit7CisJbXZuZXRfZGV2LmRldi5idXMgPSBOVUxMOworCW1kZXZfdmlydGlv X3VucmVnaXN0ZXJfZGV2aWNlKCZtdm5ldF9kZXYuZGV2KTsKKworCWRldmljZV91bnJlZ2lzdGVy KCZtdm5ldF9kZXYuZGV2KTsKKwlpZHJfZGVzdHJveSgmbXZuZXRfZGV2LnZkX2lkcik7CisJY2xh c3NfZGVzdHJveShtdm5ldF9kZXYudmRfY2xhc3MpOworCW12bmV0X2Rldi52ZF9jbGFzcyA9IE5V TEw7CisJcHJfaW5mbygibXZuZXRfZGV2OiBVbmxvYWRlZCFcbiIpOworfQorCittb2R1bGVfaW5p dChtdm5ldF9kZXZfaW5pdCkKK21vZHVsZV9leGl0KG12bmV0X2Rldl9leGl0KQorCitNT0RVTEVf TElDRU5TRSgiR1BMIHYyIik7CitNT0RVTEVfSU5GTyhzdXBwb3J0ZWQsICJTaW11bGF0ZSBsb29w YmFjayBldGhlcm5ldCBkZXZpY2Ugb3ZlciBtZGV2Iik7CitNT0RVTEVfVkVSU0lPTihWRVJTSU9O X1NUUklORyk7CitNT0RVTEVfQVVUSE9SKERSSVZFUl9BVVRIT1IpOwotLSAKMi4xOS4xCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZng=