From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 36D07C5DF64 for ; Wed, 6 Nov 2019 07:14:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D7E49217F5 for ; Wed, 6 Nov 2019 07:14:27 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="SQzTZEI9" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731248AbfKFHOZ (ORCPT ); Wed, 6 Nov 2019 02:14:25 -0500 Received: from us-smtp-1.mimecast.com ([205.139.110.61]:46646 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1725980AbfKFHOZ (ORCPT ); Wed, 6 Nov 2019 02:14:25 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1573024462; 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=ZIJAtuaeC/flAgfyNCJGB/oqkTsDq4tzC/SAiq6v5f0=; b=SQzTZEI9NVihkL7EXl7GSv7jyG1yrsx+TO+6rpyKZC2ULlL+CO0neRQkI1KUS+rlKoCvcM zLoLFkNagtiX55rWiHTdylV32FXoWG1OhxdLrxuN4Wy5Q0ueHuTA5vzOz//b7YA+/kViAu du8FGWg/33+0mBz7EFPHZhWyt4HXLAU= 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-88-YSb2ObhtMtej5K6Kghc6SQ-1; Wed, 06 Nov 2019 02:14:19 -0500 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 79447477; Wed, 6 Nov 2019 07:14:15 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-193.pek2.redhat.com [10.72.12.193]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E2961001B00; Wed, 6 Nov 2019 07:12:27 +0000 (UTC) From: Jason Wang To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, cohuck@redhat.com, maxime.coquelin@redhat.com, cunming.liang@intel.com, zhihong.wang@intel.com, rob.miller@broadcom.com, xiao.w.wang@intel.com, haotian.wang@sifive.com, zhenyuw@linux.intel.com, zhi.a.wang@intel.com, jani.nikula@linux.intel.com, joonas.lahtinen@linux.intel.com, rodrigo.vivi@intel.com, airlied@linux.ie, daniel@ffwll.ch, farman@linux.ibm.com, pasic@linux.ibm.com, sebott@linux.ibm.com, oberpar@linux.ibm.com, heiko.carstens@de.ibm.com, gor@linux.ibm.com, borntraeger@de.ibm.com, akrowiak@linux.ibm.com, freude@linux.ibm.com, lingshan.zhu@intel.com, idos@mellanox.com, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com, Jason Wang Subject: [PATCH V9 5/6] virtio: introduce a mdev based transport Date: Wed, 6 Nov 2019 15:05:47 +0800 Message-Id: <20191106070548.18980-6-jasowang@redhat.com> In-Reply-To: <20191106070548.18980-1-jasowang@redhat.com> References: <20191106070548.18980-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-MC-Unique: YSb2ObhtMtej5K6Kghc6SQ-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch introduces a new mdev transport for virtio. This is used to use kernel virtio driver to drive the mediated device that is capable of populating virtqueue directly. A new virtio-mdev driver will be registered to the mdev bus, when a new virtio-mdev device is probed, it will register the device with mdev based config ops. This means it is a software transport between mdev driver and mdev device. The transport was implemented through device specific ops which is a part of mdev_parent_ops now. Signed-off-by: Jason Wang --- drivers/virtio/Kconfig | 13 ++ drivers/virtio/Makefile | 1 + drivers/virtio/virtio_mdev.c | 406 +++++++++++++++++++++++++++++++++++ 3 files changed, 420 insertions(+) create mode 100644 drivers/virtio/virtio_mdev.c diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 078615cf2afc..558ac607d107 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -43,6 +43,19 @@ config VIRTIO_PCI_LEGACY =20 =09 If unsure, say Y. =20 +config VIRTIO_MDEV +=09tristate "MDEV driver for virtio devices" +=09depends on VFIO_MDEV && VIRTIO +=09default n +=09help +=09 This driver provides support for virtio based paravirtual +=09 device driver over MDEV bus. This requires your environemnt +=09 has appropriate virtio mdev device implementation which may +=09 operate on the physical device that the datapath of virtio +=09 could be offloaded to hardware. + +=09 If unsure, say M + config VIRTIO_PMEM =09tristate "Support for virtio pmem driver" =09depends on VIRTIO diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile index 3a2b5c5dcf46..f2997b6c812f 100644 --- a/drivers/virtio/Makefile +++ b/drivers/virtio/Makefile @@ -6,3 +6,4 @@ virtio_pci-y :=3D virtio_pci_modern.o virtio_pci_common.o virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) +=3D virtio_pci_legacy.o obj-$(CONFIG_VIRTIO_BALLOON) +=3D virtio_balloon.o obj-$(CONFIG_VIRTIO_INPUT) +=3D virtio_input.o +obj-$(CONFIG_VIRTIO_MDEV) +=3D virtio_mdev.o diff --git a/drivers/virtio/virtio_mdev.c b/drivers/virtio/virtio_mdev.c new file mode 100644 index 000000000000..9e12ef240493 --- /dev/null +++ b/drivers/virtio/virtio_mdev.c @@ -0,0 +1,406 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * VIRTIO based driver for Mediated device + * + * Copyright (c) 2019, Red Hat. All rights reserved. + * Author: Jason Wang + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DRIVER_VERSION "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" +#define DRIVER_DESC "VIRTIO based driver for Mediated device" + +#define to_virtio_mdev_device(dev) \ +=09container_of(dev, struct virtio_mdev_device, vdev) + +struct virtio_mdev_device { +=09struct virtio_device vdev; +=09struct mdev_device *mdev; +=09u64 features; + +=09/* The lock to protect virtqueue list */ +=09spinlock_t lock; +=09/* List of virtio_mdev_vq_info */ +=09struct list_head virtqueues; +}; + +struct virtio_mdev_vq_info { +=09/* the actual virtqueue */ +=09struct virtqueue *vq; + +=09/* the list node for the virtqueues list */ +=09struct list_head node; +}; + +static struct mdev_device *vm_get_mdev(struct virtio_device *vdev) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09return mdev; +} + +static void virtio_mdev_get(struct virtio_device *vdev, unsigned offset, +=09=09=09 void *buf, unsigned len) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->get_config(mdev, offset, buf, len); +} + +static void virtio_mdev_set(struct virtio_device *vdev, unsigned offset, +=09=09=09 const void *buf, unsigned len) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->set_config(mdev, offset, buf, len); +} + +static u32 virtio_mdev_generation(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09if (ops->get_generation) +=09=09return ops->get_generation(mdev); + +=09return 0; +} + +static u8 virtio_mdev_get_status(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->get_status(mdev); +} + +static void virtio_mdev_set_status(struct virtio_device *vdev, u8 status) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->set_status(mdev, status); +} + +static void virtio_mdev_reset(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->set_status(mdev, 0); +} + +static bool virtio_mdev_notify(struct virtqueue *vq) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vq->vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->kick_vq(mdev, vq->index); + +=09return true; +} + +static irqreturn_t virtio_mdev_config_cb(void *private) +{ +=09struct virtio_mdev_device *vm_dev =3D private; + +=09virtio_config_changed(&vm_dev->vdev); + +=09return IRQ_HANDLED; +} + +static irqreturn_t virtio_mdev_virtqueue_cb(void *private) +{ +=09struct virtio_mdev_vq_info *info =3D private; + +=09return vring_interrupt(0, info->vq); +} + +static struct virtqueue * +virtio_mdev_setup_vq(struct virtio_device *vdev, unsigned int index, +=09=09 void (*callback)(struct virtqueue *vq), +=09=09 const char *name, bool ctx) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_vq_info *info; +=09struct virtio_mdev_callback cb; +=09struct virtqueue *vq; +=09u64 desc_addr, driver_addr, device_addr; +=09unsigned long flags; +=09u32 align, num; +=09int err; + +=09if (!name) +=09=09return NULL; + +=09/* Queue shouldn't already be set up. */ +=09if (ops->get_vq_ready(mdev, index)) +=09=09return ERR_PTR(-ENOENT); + +=09/* Allocate and fill out our active queue description */ +=09info =3D kmalloc(sizeof(*info), GFP_KERNEL); +=09if (!info) +=09=09return ERR_PTR(-ENOMEM); + +=09num =3D ops->get_vq_num_max(mdev); +=09if (num =3D=3D 0) { +=09=09err =3D -ENOENT; +=09=09goto error_new_virtqueue; +=09} + +=09/* Create the vring */ +=09align =3D ops->get_vq_align(mdev); +=09vq =3D vring_create_virtqueue(index, num, align, vdev, +=09=09=09=09 true, true, ctx, +=09=09=09=09 virtio_mdev_notify, callback, name); +=09if (!vq) { +=09=09err =3D -ENOMEM; +=09=09goto error_new_virtqueue; +=09} + +=09/* Setup virtqueue callback */ +=09cb.callback =3D virtio_mdev_virtqueue_cb; +=09cb.private =3D info; +=09ops->set_vq_cb(mdev, index, &cb); +=09ops->set_vq_num(mdev, index, virtqueue_get_vring_size(vq)); + +=09desc_addr =3D virtqueue_get_desc_addr(vq); +=09driver_addr =3D virtqueue_get_avail_addr(vq); +=09device_addr =3D virtqueue_get_used_addr(vq); + +=09if (ops->set_vq_address(mdev, index, +=09=09=09=09desc_addr, driver_addr, +=09=09=09=09device_addr)) { +=09=09err =3D -EINVAL; +=09=09goto err_vq; +=09} + +=09ops->set_vq_ready(mdev, index, 1); + +=09vq->priv =3D info; +=09info->vq =3D vq; + +=09spin_lock_irqsave(&vm_dev->lock, flags); +=09list_add(&info->node, &vm_dev->virtqueues); +=09spin_unlock_irqrestore(&vm_dev->lock, flags); + +=09return vq; + +err_vq: +=09vring_del_virtqueue(vq); +error_new_virtqueue: +=09ops->set_vq_ready(mdev, index, 0); +=09WARN_ON(ops->get_vq_ready(mdev, index)); +=09kfree(info); +=09return ERR_PTR(err); +} + +static void virtio_mdev_del_vq(struct virtqueue *vq) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vq->vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_vq_info *info =3D vq->priv; +=09unsigned int index =3D vq->index; +=09unsigned long flags; + +=09spin_lock_irqsave(&vm_dev->lock, flags); +=09list_del(&info->node); +=09spin_unlock_irqrestore(&vm_dev->lock, flags); + +=09/* Select and deactivate the queue */ +=09ops->set_vq_ready(mdev, index, 0); +=09WARN_ON(ops->get_vq_ready(mdev, index)); + +=09vring_del_virtqueue(vq); + +=09kfree(info); +} + +static void virtio_mdev_del_vqs(struct virtio_device *vdev) +{ +=09struct virtqueue *vq, *n; + +=09list_for_each_entry_safe(vq, n, &vdev->vqs, list) +=09=09virtio_mdev_del_vq(vq); +} + +static int virtio_mdev_find_vqs(struct virtio_device *vdev, unsigned nvqs, +=09=09=09=09struct virtqueue *vqs[], +=09=09=09=09vq_callback_t *callbacks[], +=09=09=09=09const char * const names[], +=09=09=09=09const bool *ctx, +=09=09=09=09struct irq_affinity *desc) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_callback cb; +=09int i, err, queue_idx =3D 0; + +=09for (i =3D 0; i < nvqs; ++i) { +=09=09if (!names[i]) { +=09=09=09vqs[i] =3D NULL; +=09=09=09continue; +=09=09} + +=09=09vqs[i] =3D virtio_mdev_setup_vq(vdev, queue_idx++, +=09=09=09=09=09 callbacks[i], names[i], ctx ? +=09=09=09=09=09 ctx[i] : false); +=09=09if (IS_ERR(vqs[i])) { +=09=09=09err =3D PTR_ERR(vqs[i]); +=09=09=09goto err_setup_vq; +=09=09} +=09} + +=09cb.callback =3D virtio_mdev_config_cb; +=09cb.private =3D vm_dev; +=09ops->set_config_cb(mdev, &cb); + +=09return 0; + +err_setup_vq: +=09virtio_mdev_del_vqs(vdev); +=09return err; +} + +static u64 virtio_mdev_get_features(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->get_features(mdev); +} + +static int virtio_mdev_finalize_features(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09/* Give virtio_ring a chance to accept features. */ +=09vring_transport_features(vdev); + +=09return ops->set_features(mdev, vdev->features); +} + +static const char *virtio_mdev_bus_name(struct virtio_device *vdev) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09return dev_name(mdev_dev(mdev)); +} + +static const struct virtio_config_ops virtio_mdev_config_ops =3D { +=09.get=09=09=3D virtio_mdev_get, +=09.set=09=09=3D virtio_mdev_set, +=09.generation=09=3D virtio_mdev_generation, +=09.get_status=09=3D virtio_mdev_get_status, +=09.set_status=09=3D virtio_mdev_set_status, +=09.reset=09=09=3D virtio_mdev_reset, +=09.find_vqs=09=3D virtio_mdev_find_vqs, +=09.del_vqs=09=3D virtio_mdev_del_vqs, +=09.get_features=09=3D virtio_mdev_get_features, +=09.finalize_features =3D virtio_mdev_finalize_features, +=09.bus_name=09=3D virtio_mdev_bus_name, +}; + +static void virtio_mdev_release_dev(struct device *_d) +{ +=09struct virtio_device *vdev =3D +=09 container_of(_d, struct virtio_device, dev); +=09struct virtio_mdev_device *vm_dev =3D +=09 container_of(vdev, struct virtio_mdev_device, vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09devm_kfree(mdev_dev(mdev), vm_dev); +} + +static int virtio_mdev_probe(struct device *dev) +{ +=09struct mdev_device *mdev =3D mdev_from_dev(dev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_device *vm_dev; +=09int rc; + +=09vm_dev =3D devm_kzalloc(dev, sizeof(*vm_dev), GFP_KERNEL); +=09if (!vm_dev) +=09=09return -ENOMEM; + +=09vm_dev->vdev.dev.parent =3D dev; +=09vm_dev->vdev.dev.release =3D virtio_mdev_release_dev; +=09vm_dev->vdev.config =3D &virtio_mdev_config_ops; +=09vm_dev->mdev =3D mdev; +=09INIT_LIST_HEAD(&vm_dev->virtqueues); +=09spin_lock_init(&vm_dev->lock); + +=09vm_dev->vdev.id.device =3D ops->get_device_id(mdev); +=09if (vm_dev->vdev.id.device =3D=3D 0) +=09=09return -ENODEV; + +=09vm_dev->vdev.id.vendor =3D ops->get_vendor_id(mdev); +=09rc =3D register_virtio_device(&vm_dev->vdev); +=09if (rc) +=09=09put_device(dev); +=09else +=09=09dev_set_drvdata(dev, vm_dev); + +=09return rc; +} + +static void virtio_mdev_remove(struct device *dev) +{ +=09struct virtio_mdev_device *vm_dev =3D dev_get_drvdata(dev); + +=09unregister_virtio_device(&vm_dev->vdev); +} + +static const struct mdev_class_id virtio_id_table[] =3D { +=09{ MDEV_CLASS_ID_VIRTIO }, +=09{ 0 }, +}; + +MODULE_DEVICE_TABLE(mdev, virtio_id_table); + +static struct mdev_driver virtio_mdev_driver =3D { +=09.name=09=3D "virtio_mdev", +=09.probe=09=3D virtio_mdev_probe, +=09.remove =3D virtio_mdev_remove, +=09.id_table =3D virtio_id_table, +}; + +static int __init virtio_mdev_init(void) +{ +=09return mdev_register_driver(&virtio_mdev_driver, THIS_MODULE); +} + +static void __exit virtio_mdev_exit(void) +{ +=09mdev_unregister_driver(&virtio_mdev_driver); +} + +module_init(virtio_mdev_init) +module_exit(virtio_mdev_exit) + +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); --=20 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V9 5/6] virtio: introduce a mdev based transport Date: Wed, 6 Nov 2019 15:05:47 +0800 Message-ID: <20191106070548.18980-6-jasowang@redhat.com> References: <20191106070548.18980-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: <20191106070548.18980-1-jasowang@redhat.com> Sender: linux-kernel-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, idos@mellanox.com, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com List-Id: dri-devel@lists.freedesktop.org This patch introduces a new mdev transport for virtio. This is used to use kernel virtio driver to drive the mediated device that is capable of populating virtqueue directly. A new virtio-mdev driver will be registered to the mdev bus, when a new virtio-mdev device is probed, it will register the device with mdev based config ops. This means it is a software transport between mdev driver and mdev device. The transport was implemented through device specific ops which is a part of mdev_parent_ops now. Signed-off-by: Jason Wang --- drivers/virtio/Kconfig | 13 ++ drivers/virtio/Makefile | 1 + drivers/virtio/virtio_mdev.c | 406 +++++++++++++++++++++++++++++++++++ 3 files changed, 420 insertions(+) create mode 100644 drivers/virtio/virtio_mdev.c diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 078615cf2afc..558ac607d107 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -43,6 +43,19 @@ config VIRTIO_PCI_LEGACY =20 =09 If unsure, say Y. =20 +config VIRTIO_MDEV +=09tristate "MDEV driver for virtio devices" +=09depends on VFIO_MDEV && VIRTIO +=09default n +=09help +=09 This driver provides support for virtio based paravirtual +=09 device driver over MDEV bus. This requires your environemnt +=09 has appropriate virtio mdev device implementation which may +=09 operate on the physical device that the datapath of virtio +=09 could be offloaded to hardware. + +=09 If unsure, say M + config VIRTIO_PMEM =09tristate "Support for virtio pmem driver" =09depends on VIRTIO diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile index 3a2b5c5dcf46..f2997b6c812f 100644 --- a/drivers/virtio/Makefile +++ b/drivers/virtio/Makefile @@ -6,3 +6,4 @@ virtio_pci-y :=3D virtio_pci_modern.o virtio_pci_common.o virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) +=3D virtio_pci_legacy.o obj-$(CONFIG_VIRTIO_BALLOON) +=3D virtio_balloon.o obj-$(CONFIG_VIRTIO_INPUT) +=3D virtio_input.o +obj-$(CONFIG_VIRTIO_MDEV) +=3D virtio_mdev.o diff --git a/drivers/virtio/virtio_mdev.c b/drivers/virtio/virtio_mdev.c new file mode 100644 index 000000000000..9e12ef240493 --- /dev/null +++ b/drivers/virtio/virtio_mdev.c @@ -0,0 +1,406 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * VIRTIO based driver for Mediated device + * + * Copyright (c) 2019, Red Hat. All rights reserved. + * Author: Jason Wang + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DRIVER_VERSION "0.1" +#define DRIVER_AUTHOR "Red Hat Corporation" +#define DRIVER_DESC "VIRTIO based driver for Mediated device" + +#define to_virtio_mdev_device(dev) \ +=09container_of(dev, struct virtio_mdev_device, vdev) + +struct virtio_mdev_device { +=09struct virtio_device vdev; +=09struct mdev_device *mdev; +=09u64 features; + +=09/* The lock to protect virtqueue list */ +=09spinlock_t lock; +=09/* List of virtio_mdev_vq_info */ +=09struct list_head virtqueues; +}; + +struct virtio_mdev_vq_info { +=09/* the actual virtqueue */ +=09struct virtqueue *vq; + +=09/* the list node for the virtqueues list */ +=09struct list_head node; +}; + +static struct mdev_device *vm_get_mdev(struct virtio_device *vdev) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09return mdev; +} + +static void virtio_mdev_get(struct virtio_device *vdev, unsigned offset, +=09=09=09 void *buf, unsigned len) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->get_config(mdev, offset, buf, len); +} + +static void virtio_mdev_set(struct virtio_device *vdev, unsigned offset, +=09=09=09 const void *buf, unsigned len) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->set_config(mdev, offset, buf, len); +} + +static u32 virtio_mdev_generation(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09if (ops->get_generation) +=09=09return ops->get_generation(mdev); + +=09return 0; +} + +static u8 virtio_mdev_get_status(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->get_status(mdev); +} + +static void virtio_mdev_set_status(struct virtio_device *vdev, u8 status) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->set_status(mdev, status); +} + +static void virtio_mdev_reset(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->set_status(mdev, 0); +} + +static bool virtio_mdev_notify(struct virtqueue *vq) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vq->vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09ops->kick_vq(mdev, vq->index); + +=09return true; +} + +static irqreturn_t virtio_mdev_config_cb(void *private) +{ +=09struct virtio_mdev_device *vm_dev =3D private; + +=09virtio_config_changed(&vm_dev->vdev); + +=09return IRQ_HANDLED; +} + +static irqreturn_t virtio_mdev_virtqueue_cb(void *private) +{ +=09struct virtio_mdev_vq_info *info =3D private; + +=09return vring_interrupt(0, info->vq); +} + +static struct virtqueue * +virtio_mdev_setup_vq(struct virtio_device *vdev, unsigned int index, +=09=09 void (*callback)(struct virtqueue *vq), +=09=09 const char *name, bool ctx) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_vq_info *info; +=09struct virtio_mdev_callback cb; +=09struct virtqueue *vq; +=09u64 desc_addr, driver_addr, device_addr; +=09unsigned long flags; +=09u32 align, num; +=09int err; + +=09if (!name) +=09=09return NULL; + +=09/* Queue shouldn't already be set up. */ +=09if (ops->get_vq_ready(mdev, index)) +=09=09return ERR_PTR(-ENOENT); + +=09/* Allocate and fill out our active queue description */ +=09info =3D kmalloc(sizeof(*info), GFP_KERNEL); +=09if (!info) +=09=09return ERR_PTR(-ENOMEM); + +=09num =3D ops->get_vq_num_max(mdev); +=09if (num =3D=3D 0) { +=09=09err =3D -ENOENT; +=09=09goto error_new_virtqueue; +=09} + +=09/* Create the vring */ +=09align =3D ops->get_vq_align(mdev); +=09vq =3D vring_create_virtqueue(index, num, align, vdev, +=09=09=09=09 true, true, ctx, +=09=09=09=09 virtio_mdev_notify, callback, name); +=09if (!vq) { +=09=09err =3D -ENOMEM; +=09=09goto error_new_virtqueue; +=09} + +=09/* Setup virtqueue callback */ +=09cb.callback =3D virtio_mdev_virtqueue_cb; +=09cb.private =3D info; +=09ops->set_vq_cb(mdev, index, &cb); +=09ops->set_vq_num(mdev, index, virtqueue_get_vring_size(vq)); + +=09desc_addr =3D virtqueue_get_desc_addr(vq); +=09driver_addr =3D virtqueue_get_avail_addr(vq); +=09device_addr =3D virtqueue_get_used_addr(vq); + +=09if (ops->set_vq_address(mdev, index, +=09=09=09=09desc_addr, driver_addr, +=09=09=09=09device_addr)) { +=09=09err =3D -EINVAL; +=09=09goto err_vq; +=09} + +=09ops->set_vq_ready(mdev, index, 1); + +=09vq->priv =3D info; +=09info->vq =3D vq; + +=09spin_lock_irqsave(&vm_dev->lock, flags); +=09list_add(&info->node, &vm_dev->virtqueues); +=09spin_unlock_irqrestore(&vm_dev->lock, flags); + +=09return vq; + +err_vq: +=09vring_del_virtqueue(vq); +error_new_virtqueue: +=09ops->set_vq_ready(mdev, index, 0); +=09WARN_ON(ops->get_vq_ready(mdev, index)); +=09kfree(info); +=09return ERR_PTR(err); +} + +static void virtio_mdev_del_vq(struct virtqueue *vq) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vq->vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_vq_info *info =3D vq->priv; +=09unsigned int index =3D vq->index; +=09unsigned long flags; + +=09spin_lock_irqsave(&vm_dev->lock, flags); +=09list_del(&info->node); +=09spin_unlock_irqrestore(&vm_dev->lock, flags); + +=09/* Select and deactivate the queue */ +=09ops->set_vq_ready(mdev, index, 0); +=09WARN_ON(ops->get_vq_ready(mdev, index)); + +=09vring_del_virtqueue(vq); + +=09kfree(info); +} + +static void virtio_mdev_del_vqs(struct virtio_device *vdev) +{ +=09struct virtqueue *vq, *n; + +=09list_for_each_entry_safe(vq, n, &vdev->vqs, list) +=09=09virtio_mdev_del_vq(vq); +} + +static int virtio_mdev_find_vqs(struct virtio_device *vdev, unsigned nvqs, +=09=09=09=09struct virtqueue *vqs[], +=09=09=09=09vq_callback_t *callbacks[], +=09=09=09=09const char * const names[], +=09=09=09=09const bool *ctx, +=09=09=09=09struct irq_affinity *desc) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_callback cb; +=09int i, err, queue_idx =3D 0; + +=09for (i =3D 0; i < nvqs; ++i) { +=09=09if (!names[i]) { +=09=09=09vqs[i] =3D NULL; +=09=09=09continue; +=09=09} + +=09=09vqs[i] =3D virtio_mdev_setup_vq(vdev, queue_idx++, +=09=09=09=09=09 callbacks[i], names[i], ctx ? +=09=09=09=09=09 ctx[i] : false); +=09=09if (IS_ERR(vqs[i])) { +=09=09=09err =3D PTR_ERR(vqs[i]); +=09=09=09goto err_setup_vq; +=09=09} +=09} + +=09cb.callback =3D virtio_mdev_config_cb; +=09cb.private =3D vm_dev; +=09ops->set_config_cb(mdev, &cb); + +=09return 0; + +err_setup_vq: +=09virtio_mdev_del_vqs(vdev); +=09return err; +} + +static u64 virtio_mdev_get_features(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09return ops->get_features(mdev); +} + +static int virtio_mdev_finalize_features(struct virtio_device *vdev) +{ +=09struct mdev_device *mdev =3D vm_get_mdev(vdev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); + +=09/* Give virtio_ring a chance to accept features. */ +=09vring_transport_features(vdev); + +=09return ops->set_features(mdev, vdev->features); +} + +static const char *virtio_mdev_bus_name(struct virtio_device *vdev) +{ +=09struct virtio_mdev_device *vm_dev =3D to_virtio_mdev_device(vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09return dev_name(mdev_dev(mdev)); +} + +static const struct virtio_config_ops virtio_mdev_config_ops =3D { +=09.get=09=09=3D virtio_mdev_get, +=09.set=09=09=3D virtio_mdev_set, +=09.generation=09=3D virtio_mdev_generation, +=09.get_status=09=3D virtio_mdev_get_status, +=09.set_status=09=3D virtio_mdev_set_status, +=09.reset=09=09=3D virtio_mdev_reset, +=09.find_vqs=09=3D virtio_mdev_find_vqs, +=09.del_vqs=09=3D virtio_mdev_del_vqs, +=09.get_features=09=3D virtio_mdev_get_features, +=09.finalize_features =3D virtio_mdev_finalize_features, +=09.bus_name=09=3D virtio_mdev_bus_name, +}; + +static void virtio_mdev_release_dev(struct device *_d) +{ +=09struct virtio_device *vdev =3D +=09 container_of(_d, struct virtio_device, dev); +=09struct virtio_mdev_device *vm_dev =3D +=09 container_of(vdev, struct virtio_mdev_device, vdev); +=09struct mdev_device *mdev =3D vm_dev->mdev; + +=09devm_kfree(mdev_dev(mdev), vm_dev); +} + +static int virtio_mdev_probe(struct device *dev) +{ +=09struct mdev_device *mdev =3D mdev_from_dev(dev); +=09const struct mdev_virtio_device_ops *ops =3D mdev_get_virtio_ops(mdev); +=09struct virtio_mdev_device *vm_dev; +=09int rc; + +=09vm_dev =3D devm_kzalloc(dev, sizeof(*vm_dev), GFP_KERNEL); +=09if (!vm_dev) +=09=09return -ENOMEM; + +=09vm_dev->vdev.dev.parent =3D dev; +=09vm_dev->vdev.dev.release =3D virtio_mdev_release_dev; +=09vm_dev->vdev.config =3D &virtio_mdev_config_ops; +=09vm_dev->mdev =3D mdev; +=09INIT_LIST_HEAD(&vm_dev->virtqueues); +=09spin_lock_init(&vm_dev->lock); + +=09vm_dev->vdev.id.device =3D ops->get_device_id(mdev); +=09if (vm_dev->vdev.id.device =3D=3D 0) +=09=09return -ENODEV; + +=09vm_dev->vdev.id.vendor =3D ops->get_vendor_id(mdev); +=09rc =3D register_virtio_device(&vm_dev->vdev); +=09if (rc) +=09=09put_device(dev); +=09else +=09=09dev_set_drvdata(dev, vm_dev); + +=09return rc; +} + +static void virtio_mdev_remove(struct device *dev) +{ +=09struct virtio_mdev_device *vm_dev =3D dev_get_drvdata(dev); + +=09unregister_virtio_device(&vm_dev->vdev); +} + +static const struct mdev_class_id virtio_id_table[] =3D { +=09{ MDEV_CLASS_ID_VIRTIO }, +=09{ 0 }, +}; + +MODULE_DEVICE_TABLE(mdev, virtio_id_table); + +static struct mdev_driver virtio_mdev_driver =3D { +=09.name=09=3D "virtio_mdev", +=09.probe=09=3D virtio_mdev_probe, +=09.remove =3D virtio_mdev_remove, +=09.id_table =3D virtio_id_table, +}; + +static int __init virtio_mdev_init(void) +{ +=09return mdev_register_driver(&virtio_mdev_driver, THIS_MODULE); +} + +static void __exit virtio_mdev_exit(void) +{ +=09mdev_unregister_driver(&virtio_mdev_driver); +} + +module_init(virtio_mdev_init) +module_exit(virtio_mdev_exit) + +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); --=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 B278DC5DF62 for ; Wed, 6 Nov 2019 07:14:25 +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 748CA217D7 for ; Wed, 6 Nov 2019 07:14:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 748CA217D7 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 CCF546EC0D; Wed, 6 Nov 2019 07:14:24 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1D6526EC14 for ; Wed, 6 Nov 2019 07:14:24 +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-88-YSb2ObhtMtej5K6Kghc6SQ-1; Wed, 06 Nov 2019 02:14:19 -0500 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 79447477; Wed, 6 Nov 2019 07:14:15 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-193.pek2.redhat.com [10.72.12.193]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E2961001B00; Wed, 6 Nov 2019 07:12:27 +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 V9 5/6] virtio: introduce a mdev based transport Date: Wed, 6 Nov 2019 15:05:47 +0800 Message-Id: <20191106070548.18980-6-jasowang@redhat.com> In-Reply-To: <20191106070548.18980-1-jasowang@redhat.com> References: <20191106070548.18980-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-MC-Unique: YSb2ObhtMtej5K6Kghc6SQ-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=1573024463; 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=ZIJAtuaeC/flAgfyNCJGB/oqkTsDq4tzC/SAiq6v5f0=; b=RK7ibLMnKPP7VdQlHjb0AQCvGE9CDK8M673ZdfDZ5leTHhjVIyR4KzI/Yekvp2Zqt743ad Mx7TCeWOBJUWIGRN+FtrxaSNL1fsAb5aFmQQleSgK+a7SR5gT4+SP+66N6LMFD368uZ6RL PxgKN6q+fX86oFHeDbpqxyh7OfnBrJY= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, kevin.tian@intel.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, zhi.a.wang@intel.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191106070547.0s9FgDcxP5sDnccgqYFBxTZAh4EX5Q_JxmsVCB56by8@z> VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIGEgbmV3IG1kZXYgdHJhbnNwb3J0IGZvciB2aXJ0aW8uIFRo aXMgaXMgdXNlZCB0bwp1c2Uga2VybmVsIHZpcnRpbyBkcml2ZXIgdG8gZHJpdmUgdGhlIG1lZGlh dGVkIGRldmljZSB0aGF0IGlzIGNhcGFibGUKb2YgcG9wdWxhdGluZyB2aXJ0cXVldWUgZGlyZWN0 bHkuCgpBIG5ldyB2aXJ0aW8tbWRldiBkcml2ZXIgd2lsbCBiZSByZWdpc3RlcmVkIHRvIHRoZSBt ZGV2IGJ1cywgd2hlbiBhCm5ldyB2aXJ0aW8tbWRldiBkZXZpY2UgaXMgcHJvYmVkLCBpdCB3aWxs IHJlZ2lzdGVyIHRoZSBkZXZpY2Ugd2l0aAptZGV2IGJhc2VkIGNvbmZpZyBvcHMuIFRoaXMgbWVh bnMgaXQgaXMgYSBzb2Z0d2FyZSB0cmFuc3BvcnQgYmV0d2VlbgptZGV2IGRyaXZlciBhbmQgbWRl diBkZXZpY2UuIFRoZSB0cmFuc3BvcnQgd2FzIGltcGxlbWVudGVkIHRocm91Z2gKZGV2aWNlIHNw ZWNpZmljIG9wcyB3aGljaCBpcyBhIHBhcnQgb2YgbWRldl9wYXJlbnRfb3BzIG5vdy4KClNpZ25l ZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogZHJpdmVycy92 aXJ0aW8vS2NvbmZpZyAgICAgICB8ICAxMyArKwogZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUgICAg ICB8ICAgMSArCiBkcml2ZXJzL3ZpcnRpby92aXJ0aW9fbWRldi5jIHwgNDA2ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDQyMCBpbnNlcnRpb25z KCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy92aXJ0aW8vdmlydGlvX21kZXYuYwoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL0tjb25maWcgYi9kcml2ZXJzL3ZpcnRpby9LY29uZmln CmluZGV4IDA3ODYxNWNmMmFmYy4uNTU4YWM2MDdkMTA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Zp cnRpby9LY29uZmlnCisrKyBiL2RyaXZlcnMvdmlydGlvL0tjb25maWcKQEAgLTQzLDYgKzQzLDE5 IEBAIGNvbmZpZyBWSVJUSU9fUENJX0xFR0FDWQogCiAJICBJZiB1bnN1cmUsIHNheSBZLgogCitj b25maWcgVklSVElPX01ERVYKKwl0cmlzdGF0ZSAiTURFViBkcml2ZXIgZm9yIHZpcnRpbyBkZXZp Y2VzIgorCWRlcGVuZHMgb24gVkZJT19NREVWICYmIFZJUlRJTworCWRlZmF1bHQgbgorCWhlbHAK KwkgIFRoaXMgZHJpdmVyIHByb3ZpZGVzIHN1cHBvcnQgZm9yIHZpcnRpbyBiYXNlZCBwYXJhdmly dHVhbAorCSAgZGV2aWNlIGRyaXZlciBvdmVyIE1ERVYgYnVzLiBUaGlzIHJlcXVpcmVzIHlvdXIg ZW52aXJvbmVtbnQKKwkgIGhhcyBhcHByb3ByaWF0ZSB2aXJ0aW8gbWRldiBkZXZpY2UgaW1wbGVt ZW50YXRpb24gd2hpY2ggbWF5CisJICBvcGVyYXRlIG9uIHRoZSBwaHlzaWNhbCBkZXZpY2UgdGhh dCB0aGUgZGF0YXBhdGggb2YgdmlydGlvCisJICBjb3VsZCBiZSBvZmZsb2FkZWQgdG8gaGFyZHdh cmUuCisKKwkgIElmIHVuc3VyZSwgc2F5IE0KKwogY29uZmlnIFZJUlRJT19QTUVNCiAJdHJpc3Rh dGUgIlN1cHBvcnQgZm9yIHZpcnRpbyBwbWVtIGRyaXZlciIKIAlkZXBlbmRzIG9uIFZJUlRJTwpk aWZmIC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUgYi9kcml2ZXJzL3ZpcnRpby9NYWtl ZmlsZQppbmRleCAzYTJiNWM1ZGNmNDYuLmYyOTk3YjZjODEyZiAxMDA2NDQKLS0tIGEvZHJpdmVy cy92aXJ0aW8vTWFrZWZpbGUKKysrIGIvZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUKQEAgLTYsMyAr Niw0IEBAIHZpcnRpb19wY2kteSA6PSB2aXJ0aW9fcGNpX21vZGVybi5vIHZpcnRpb19wY2lfY29t bW9uLm8KIHZpcnRpb19wY2ktJChDT05GSUdfVklSVElPX1BDSV9MRUdBQ1kpICs9IHZpcnRpb19w Y2lfbGVnYWN5Lm8KIG9iai0kKENPTkZJR19WSVJUSU9fQkFMTE9PTikgKz0gdmlydGlvX2JhbGxv b24ubwogb2JqLSQoQ09ORklHX1ZJUlRJT19JTlBVVCkgKz0gdmlydGlvX2lucHV0Lm8KK29iai0k KENPTkZJR19WSVJUSU9fTURFVikgKz0gdmlydGlvX21kZXYubwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy92aXJ0aW8vdmlydGlvX21kZXYuYyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19tZGV2LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45ZTEyZWYyNDA0OTMKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fbWRldi5jCkBAIC0wLDAgKzEsNDA2 IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisvKgorICogVklS VElPIGJhc2VkIGRyaXZlciBmb3IgTWVkaWF0ZWQgZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChj KSAyMDE5LCBSZWQgSGF0LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogICAgIEF1dGhvcjogSmFz b24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4 L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZp Y2UuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ CisjaW5jbHVkZSA8bGludXgvdXVpZC5oPgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNs dWRlIDxsaW51eC9tZGV2X3ZpcnRpb19vcHMuaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW8uaD4K KyNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgvdmlydGlv X3JpbmcuaD4KKworI2RlZmluZSBEUklWRVJfVkVSU0lPTiAgIjAuMSIKKyNkZWZpbmUgRFJJVkVS X0FVVEhPUiAgICJSZWQgSGF0IENvcnBvcmF0aW9uIgorI2RlZmluZSBEUklWRVJfREVTQyAgICAg IlZJUlRJTyBiYXNlZCBkcml2ZXIgZm9yIE1lZGlhdGVkIGRldmljZSIKKworI2RlZmluZSB0b192 aXJ0aW9fbWRldl9kZXZpY2UoZGV2KSBcCisJY29udGFpbmVyX29mKGRldiwgc3RydWN0IHZpcnRp b19tZGV2X2RldmljZSwgdmRldikKKworc3RydWN0IHZpcnRpb19tZGV2X2RldmljZSB7CisJc3Ry dWN0IHZpcnRpb19kZXZpY2UgdmRldjsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXY7CisJdTY0 IGZlYXR1cmVzOworCisJLyogVGhlIGxvY2sgdG8gcHJvdGVjdCB2aXJ0cXVldWUgbGlzdCAqLwor CXNwaW5sb2NrX3QgbG9jazsKKwkvKiBMaXN0IG9mIHZpcnRpb19tZGV2X3ZxX2luZm8gKi8KKwlz dHJ1Y3QgbGlzdF9oZWFkIHZpcnRxdWV1ZXM7Cit9OworCitzdHJ1Y3QgdmlydGlvX21kZXZfdnFf aW5mbyB7CisJLyogdGhlIGFjdHVhbCB2aXJ0cXVldWUgKi8KKwlzdHJ1Y3QgdmlydHF1ZXVlICp2 cTsKKworCS8qIHRoZSBsaXN0IG5vZGUgZm9yIHRoZSB2aXJ0cXVldWVzIGxpc3QgKi8KKwlzdHJ1 Y3QgbGlzdF9oZWFkIG5vZGU7Cit9OworCitzdGF0aWMgc3RydWN0IG1kZXZfZGV2aWNlICp2bV9n ZXRfbWRldihzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKK3sKKwlzdHJ1Y3QgdmlydGlvX21k ZXZfZGV2aWNlICp2bV9kZXYgPSB0b192aXJ0aW9fbWRldl9kZXZpY2UodmRldik7CisJc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2ID0gdm1fZGV2LT5tZGV2OworCisJcmV0dXJuIG1kZXY7Cit9CisK K3N0YXRpYyB2b2lkIHZpcnRpb19tZGV2X2dldChzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwg dW5zaWduZWQgb2Zmc2V0LAorCQkJICAgIHZvaWQgKmJ1ZiwgdW5zaWduZWQgbGVuKQoreworCXN0 cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVj dCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYp OworCisJb3BzLT5nZXRfY29uZmlnKG1kZXYsIG9mZnNldCwgYnVmLCBsZW4pOworfQorCitzdGF0 aWMgdm9pZCB2aXJ0aW9fbWRldl9zZXQoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYsIHVuc2ln bmVkIG9mZnNldCwKKwkJCSAgICBjb25zdCB2b2lkICpidWYsIHVuc2lnbmVkIGxlbikKK3sKKwlz dHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2ZGV2KTsKKwljb25zdCBzdHJ1 Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9nZXRfdmlydGlvX29wcyhtZGV2 KTsKKworCW9wcy0+c2V0X2NvbmZpZyhtZGV2LCBvZmZzZXQsIGJ1ZiwgbGVuKTsKK30KKworc3Rh dGljIHUzMiB2aXJ0aW9fbWRldl9nZW5lcmF0aW9uKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2 KQoreworCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNv bnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9f b3BzKG1kZXYpOworCisJaWYgKG9wcy0+Z2V0X2dlbmVyYXRpb24pCisJCXJldHVybiBvcHMtPmdl dF9nZW5lcmF0aW9uKG1kZXYpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB1OCB2aXJ0aW9f bWRldl9nZXRfc3RhdHVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2 X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJ cmV0dXJuIG9wcy0+Z2V0X3N0YXR1cyhtZGV2KTsKK30KKworc3RhdGljIHZvaWQgdmlydGlvX21k ZXZfc2V0X3N0YXR1cyhzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwgdTggc3RhdHVzKQorewor CXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0 cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1k ZXYpOworCisJcmV0dXJuIG9wcy0+c2V0X3N0YXR1cyhtZGV2LCBzdGF0dXMpOworfQorCitzdGF0 aWMgdm9pZCB2aXJ0aW9fbWRldl9yZXNldChzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKK3sK KwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2ZGV2KTsKKwljb25zdCBz dHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9nZXRfdmlydGlvX29wcyht ZGV2KTsKKworCXJldHVybiBvcHMtPnNldF9zdGF0dXMobWRldiwgMCk7Cit9CisKK3N0YXRpYyBi b29sIHZpcnRpb19tZGV2X25vdGlmeShzdHJ1Y3QgdmlydHF1ZXVlICp2cSkKK3sKKwlzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2cS0+dmRldik7CisJY29uc3Qgc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7 CisKKwlvcHMtPmtpY2tfdnEobWRldiwgdnEtPmluZGV4KTsKKworCXJldHVybiB0cnVlOworfQor CitzdGF0aWMgaXJxcmV0dXJuX3QgdmlydGlvX21kZXZfY29uZmlnX2NiKHZvaWQgKnByaXZhdGUp Cit7CisJc3RydWN0IHZpcnRpb19tZGV2X2RldmljZSAqdm1fZGV2ID0gcHJpdmF0ZTsKKworCXZp cnRpb19jb25maWdfY2hhbmdlZCgmdm1fZGV2LT52ZGV2KTsKKworCXJldHVybiBJUlFfSEFORExF RDsKK30KKworc3RhdGljIGlycXJldHVybl90IHZpcnRpb19tZGV2X3ZpcnRxdWV1ZV9jYih2b2lk ICpwcml2YXRlKQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl92cV9pbmZvICppbmZvID0gcHJpdmF0 ZTsKKworCXJldHVybiB2cmluZ19pbnRlcnJ1cHQoMCwgaW5mby0+dnEpOworfQorCitzdGF0aWMg c3RydWN0IHZpcnRxdWV1ZSAqCit2aXJ0aW9fbWRldl9zZXR1cF92cShzdHJ1Y3QgdmlydGlvX2Rl dmljZSAqdmRldiwgdW5zaWduZWQgaW50IGluZGV4LAorCQkgICAgIHZvaWQgKCpjYWxsYmFjayko c3RydWN0IHZpcnRxdWV1ZSAqdnEpLAorCQkgICAgIGNvbnN0IGNoYXIgKm5hbWUsIGJvb2wgY3R4 KQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2RldiA9IHRvX3ZpcnRpb19tZGV2 X2RldmljZSh2ZGV2KTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2 ZGV2KTsKKwljb25zdCBzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9n ZXRfdmlydGlvX29wcyhtZGV2KTsKKwlzdHJ1Y3QgdmlydGlvX21kZXZfdnFfaW5mbyAqaW5mbzsK KwlzdHJ1Y3QgdmlydGlvX21kZXZfY2FsbGJhY2sgY2I7CisJc3RydWN0IHZpcnRxdWV1ZSAqdnE7 CisJdTY0IGRlc2NfYWRkciwgZHJpdmVyX2FkZHIsIGRldmljZV9hZGRyOworCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CisJdTMyIGFsaWduLCBudW07CisJaW50IGVycjsKKworCWlmICghbmFtZSkKKwkJ cmV0dXJuIE5VTEw7CisKKwkvKiBRdWV1ZSBzaG91bGRuJ3QgYWxyZWFkeSBiZSBzZXQgdXAuICov CisJaWYgKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSkKKwkJcmV0dXJuIEVSUl9QVFIo LUVOT0VOVCk7CisKKwkvKiBBbGxvY2F0ZSBhbmQgZmlsbCBvdXQgb3VyIGFjdGl2ZSBxdWV1ZSBk ZXNjcmlwdGlvbiAqLworCWluZm8gPSBrbWFsbG9jKHNpemVvZigqaW5mbyksIEdGUF9LRVJORUwp OworCWlmICghaW5mbykKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwludW0gPSBvcHMt PmdldF92cV9udW1fbWF4KG1kZXYpOworCWlmIChudW0gPT0gMCkgeworCQllcnIgPSAtRU5PRU5U OworCQlnb3RvIGVycm9yX25ld192aXJ0cXVldWU7CisJfQorCisJLyogQ3JlYXRlIHRoZSB2cmlu ZyAqLworCWFsaWduID0gb3BzLT5nZXRfdnFfYWxpZ24obWRldik7CisJdnEgPSB2cmluZ19jcmVh dGVfdmlydHF1ZXVlKGluZGV4LCBudW0sIGFsaWduLCB2ZGV2LAorCQkJCSAgICB0cnVlLCB0cnVl LCBjdHgsCisJCQkJICAgIHZpcnRpb19tZGV2X25vdGlmeSwgY2FsbGJhY2ssIG5hbWUpOworCWlm ICghdnEpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJvcl9uZXdfdmlydHF1ZXVlOwor CX0KKworCS8qIFNldHVwIHZpcnRxdWV1ZSBjYWxsYmFjayAqLworCWNiLmNhbGxiYWNrID0gdmly dGlvX21kZXZfdmlydHF1ZXVlX2NiOworCWNiLnByaXZhdGUgPSBpbmZvOworCW9wcy0+c2V0X3Zx X2NiKG1kZXYsIGluZGV4LCAmY2IpOworCW9wcy0+c2V0X3ZxX251bShtZGV2LCBpbmRleCwgdmly dHF1ZXVlX2dldF92cmluZ19zaXplKHZxKSk7CisKKwlkZXNjX2FkZHIgPSB2aXJ0cXVldWVfZ2V0 X2Rlc2NfYWRkcih2cSk7CisJZHJpdmVyX2FkZHIgPSB2aXJ0cXVldWVfZ2V0X2F2YWlsX2FkZHIo dnEpOworCWRldmljZV9hZGRyID0gdmlydHF1ZXVlX2dldF91c2VkX2FkZHIodnEpOworCisJaWYg KG9wcy0+c2V0X3ZxX2FkZHJlc3MobWRldiwgaW5kZXgsCisJCQkJZGVzY19hZGRyLCBkcml2ZXJf YWRkciwKKwkJCQlkZXZpY2VfYWRkcikpIHsKKwkJZXJyID0gLUVJTlZBTDsKKwkJZ290byBlcnJf dnE7CisJfQorCisJb3BzLT5zZXRfdnFfcmVhZHkobWRldiwgaW5kZXgsIDEpOworCisJdnEtPnBy aXYgPSBpbmZvOworCWluZm8tPnZxID0gdnE7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdm1fZGV2 LT5sb2NrLCBmbGFncyk7CisJbGlzdF9hZGQoJmluZm8tPm5vZGUsICZ2bV9kZXYtPnZpcnRxdWV1 ZXMpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnZtX2Rldi0+bG9jaywgZmxhZ3MpOworCisJ cmV0dXJuIHZxOworCitlcnJfdnE6CisJdnJpbmdfZGVsX3ZpcnRxdWV1ZSh2cSk7CitlcnJvcl9u ZXdfdmlydHF1ZXVlOgorCW9wcy0+c2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4LCAwKTsKKwlXQVJO X09OKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSk7CisJa2ZyZWUoaW5mbyk7CisJcmV0 dXJuIEVSUl9QVFIoZXJyKTsKK30KKworc3RhdGljIHZvaWQgdmlydGlvX21kZXZfZGVsX3ZxKHN0 cnVjdCB2aXJ0cXVldWUgKnZxKQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2Rl diA9IHRvX3ZpcnRpb19tZGV2X2RldmljZSh2cS0+dmRldik7CisJc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2ID0gdm1fZGV2LT5tZGV2OworCWNvbnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vf b3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCXN0cnVjdCB2aXJ0aW9fbWRl dl92cV9pbmZvICppbmZvID0gdnEtPnByaXY7CisJdW5zaWduZWQgaW50IGluZGV4ID0gdnEtPmlu ZGV4OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdm1fZGV2 LT5sb2NrLCBmbGFncyk7CisJbGlzdF9kZWwoJmluZm8tPm5vZGUpOworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJnZtX2Rldi0+bG9jaywgZmxhZ3MpOworCisJLyogU2VsZWN0IGFuZCBkZWFjdGl2 YXRlIHRoZSBxdWV1ZSAqLworCW9wcy0+c2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4LCAwKTsKKwlX QVJOX09OKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSk7CisKKwl2cmluZ19kZWxfdmly dHF1ZXVlKHZxKTsKKworCWtmcmVlKGluZm8pOworfQorCitzdGF0aWMgdm9pZCB2aXJ0aW9fbWRl dl9kZWxfdnFzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCB2aXJ0cXVl dWUgKnZxLCAqbjsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh2cSwgbiwgJnZkZXYtPnZx cywgbGlzdCkKKwkJdmlydGlvX21kZXZfZGVsX3ZxKHZxKTsKK30KKworc3RhdGljIGludCB2aXJ0 aW9fbWRldl9maW5kX3ZxcyhzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwgdW5zaWduZWQgbnZx cywKKwkJCQlzdHJ1Y3QgdmlydHF1ZXVlICp2cXNbXSwKKwkJCQl2cV9jYWxsYmFja190ICpjYWxs YmFja3NbXSwKKwkJCQljb25zdCBjaGFyICogY29uc3QgbmFtZXNbXSwKKwkJCQljb25zdCBib29s ICpjdHgsCisJCQkJc3RydWN0IGlycV9hZmZpbml0eSAqZGVzYykKK3sKKwlzdHJ1Y3QgdmlydGlv X21kZXZfZGV2aWNlICp2bV9kZXYgPSB0b192aXJ0aW9fbWRldl9kZXZpY2UodmRldik7CisJc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2ID0gdm1fZ2V0X21kZXYodmRldik7CisJY29uc3Qgc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7 CisJc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrIGNiOworCWludCBpLCBlcnIsIHF1ZXVlX2lk eCA9IDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnZxczsgKytpKSB7CisJCWlmICghbmFtZXNbaV0p IHsKKwkJCXZxc1tpXSA9IE5VTEw7CisJCQljb250aW51ZTsKKwkJfQorCisJCXZxc1tpXSA9IHZp cnRpb19tZGV2X3NldHVwX3ZxKHZkZXYsIHF1ZXVlX2lkeCsrLAorCQkJCQkgICAgICBjYWxsYmFj a3NbaV0sIG5hbWVzW2ldLCBjdHggPworCQkJCQkgICAgICBjdHhbaV0gOiBmYWxzZSk7CisJCWlm IChJU19FUlIodnFzW2ldKSkgeworCQkJZXJyID0gUFRSX0VSUih2cXNbaV0pOworCQkJZ290byBl cnJfc2V0dXBfdnE7CisJCX0KKwl9CisKKwljYi5jYWxsYmFjayA9IHZpcnRpb19tZGV2X2NvbmZp Z19jYjsKKwljYi5wcml2YXRlID0gdm1fZGV2OworCW9wcy0+c2V0X2NvbmZpZ19jYihtZGV2LCAm Y2IpOworCisJcmV0dXJuIDA7CisKK2Vycl9zZXR1cF92cToKKwl2aXJ0aW9fbWRldl9kZWxfdnFz KHZkZXYpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB1NjQgdmlydGlvX21kZXZfZ2V0X2Zl YXR1cmVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBtZGV2X2Rldmlj ZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19k ZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJcmV0dXJuIG9w cy0+Z2V0X2ZlYXR1cmVzKG1kZXYpOworfQorCitzdGF0aWMgaW50IHZpcnRpb19tZGV2X2ZpbmFs aXplX2ZlYXR1cmVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBtZGV2 X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2X3Zp cnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJLyog R2l2ZSB2aXJ0aW9fcmluZyBhIGNoYW5jZSB0byBhY2NlcHQgZmVhdHVyZXMuICovCisJdnJpbmdf dHJhbnNwb3J0X2ZlYXR1cmVzKHZkZXYpOworCisJcmV0dXJuIG9wcy0+c2V0X2ZlYXR1cmVzKG1k ZXYsIHZkZXYtPmZlYXR1cmVzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKnZpcnRpb19tZGV2 X2J1c19uYW1lKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCB2aXJ0aW9f bWRldl9kZXZpY2UgKnZtX2RldiA9IHRvX3ZpcnRpb19tZGV2X2RldmljZSh2ZGV2KTsKKwlzdHJ1 Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9kZXYtPm1kZXY7CisKKwlyZXR1cm4gZGV2X25hbWUo bWRldl9kZXYobWRldikpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHZpcnRpb19jb25maWdf b3BzIHZpcnRpb19tZGV2X2NvbmZpZ19vcHMgPSB7CisJLmdldAkJPSB2aXJ0aW9fbWRldl9nZXQs CisJLnNldAkJPSB2aXJ0aW9fbWRldl9zZXQsCisJLmdlbmVyYXRpb24JPSB2aXJ0aW9fbWRldl9n ZW5lcmF0aW9uLAorCS5nZXRfc3RhdHVzCT0gdmlydGlvX21kZXZfZ2V0X3N0YXR1cywKKwkuc2V0 X3N0YXR1cwk9IHZpcnRpb19tZGV2X3NldF9zdGF0dXMsCisJLnJlc2V0CQk9IHZpcnRpb19tZGV2 X3Jlc2V0LAorCS5maW5kX3Zxcwk9IHZpcnRpb19tZGV2X2ZpbmRfdnFzLAorCS5kZWxfdnFzCT0g dmlydGlvX21kZXZfZGVsX3ZxcywKKwkuZ2V0X2ZlYXR1cmVzCT0gdmlydGlvX21kZXZfZ2V0X2Zl YXR1cmVzLAorCS5maW5hbGl6ZV9mZWF0dXJlcyA9IHZpcnRpb19tZGV2X2ZpbmFsaXplX2ZlYXR1 cmVzLAorCS5idXNfbmFtZQk9IHZpcnRpb19tZGV2X2J1c19uYW1lLAorfTsKKworc3RhdGljIHZv aWQgdmlydGlvX21kZXZfcmVsZWFzZV9kZXYoc3RydWN0IGRldmljZSAqX2QpCit7CisJc3RydWN0 IHZpcnRpb19kZXZpY2UgKnZkZXYgPQorCSAgICAgICBjb250YWluZXJfb2YoX2QsIHN0cnVjdCB2 aXJ0aW9fZGV2aWNlLCBkZXYpOworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2RldiA9 CisJICAgICAgIGNvbnRhaW5lcl9vZih2ZGV2LCBzdHJ1Y3QgdmlydGlvX21kZXZfZGV2aWNlLCB2 ZGV2KTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9kZXYtPm1kZXY7CisKKwlkZXZt X2tmcmVlKG1kZXZfZGV2KG1kZXYpLCB2bV9kZXYpOworfQorCitzdGF0aWMgaW50IHZpcnRpb19t ZGV2X3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYgPSBtZGV2X2Zyb21fZGV2KGRldik7CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2Rldmlj ZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7CisJc3RydWN0IHZpcnRpb19t ZGV2X2RldmljZSAqdm1fZGV2OworCWludCByYzsKKworCXZtX2RldiA9IGRldm1fa3phbGxvYyhk ZXYsIHNpemVvZigqdm1fZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF2bV9kZXYpCisJCXJldHVy biAtRU5PTUVNOworCisJdm1fZGV2LT52ZGV2LmRldi5wYXJlbnQgPSBkZXY7CisJdm1fZGV2LT52 ZGV2LmRldi5yZWxlYXNlID0gdmlydGlvX21kZXZfcmVsZWFzZV9kZXY7CisJdm1fZGV2LT52ZGV2 LmNvbmZpZyA9ICZ2aXJ0aW9fbWRldl9jb25maWdfb3BzOworCXZtX2Rldi0+bWRldiA9IG1kZXY7 CisJSU5JVF9MSVNUX0hFQUQoJnZtX2Rldi0+dmlydHF1ZXVlcyk7CisJc3Bpbl9sb2NrX2luaXQo JnZtX2Rldi0+bG9jayk7CisKKwl2bV9kZXYtPnZkZXYuaWQuZGV2aWNlID0gb3BzLT5nZXRfZGV2 aWNlX2lkKG1kZXYpOworCWlmICh2bV9kZXYtPnZkZXYuaWQuZGV2aWNlID09IDApCisJCXJldHVy biAtRU5PREVWOworCisJdm1fZGV2LT52ZGV2LmlkLnZlbmRvciA9IG9wcy0+Z2V0X3ZlbmRvcl9p ZChtZGV2KTsKKwlyYyA9IHJlZ2lzdGVyX3ZpcnRpb19kZXZpY2UoJnZtX2Rldi0+dmRldik7CisJ aWYgKHJjKQorCQlwdXRfZGV2aWNlKGRldik7CisJZWxzZQorCQlkZXZfc2V0X2RydmRhdGEoZGV2 LCB2bV9kZXYpOworCisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgdm9pZCB2aXJ0aW9fbWRldl9y ZW1vdmUoc3RydWN0IGRldmljZSAqZGV2KQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2Ug KnZtX2RldiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCisJdW5yZWdpc3Rlcl92aXJ0aW9fZGV2 aWNlKCZ2bV9kZXYtPnZkZXYpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfY2xhc3Nf aWQgdmlydGlvX2lkX3RhYmxlW10gPSB7CisJeyBNREVWX0NMQVNTX0lEX1ZJUlRJTyB9LAorCXsg MCB9LAorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShtZGV2LCB2aXJ0aW9faWRfdGFibGUpOwor CitzdGF0aWMgc3RydWN0IG1kZXZfZHJpdmVyIHZpcnRpb19tZGV2X2RyaXZlciA9IHsKKwkubmFt ZQk9ICJ2aXJ0aW9fbWRldiIsCisJLnByb2JlCT0gdmlydGlvX21kZXZfcHJvYmUsCisJLnJlbW92 ZSA9IHZpcnRpb19tZGV2X3JlbW92ZSwKKwkuaWRfdGFibGUgPSB2aXJ0aW9faWRfdGFibGUsCit9 OworCitzdGF0aWMgaW50IF9faW5pdCB2aXJ0aW9fbWRldl9pbml0KHZvaWQpCit7CisJcmV0dXJu IG1kZXZfcmVnaXN0ZXJfZHJpdmVyKCZ2aXJ0aW9fbWRldl9kcml2ZXIsIFRISVNfTU9EVUxFKTsK K30KKworc3RhdGljIHZvaWQgX19leGl0IHZpcnRpb19tZGV2X2V4aXQodm9pZCkKK3sKKwltZGV2 X3VucmVnaXN0ZXJfZHJpdmVyKCZ2aXJ0aW9fbWRldl9kcml2ZXIpOworfQorCittb2R1bGVfaW5p dCh2aXJ0aW9fbWRldl9pbml0KQorbW9kdWxlX2V4aXQodmlydGlvX21kZXZfZXhpdCkKKworTU9E VUxFX1ZFUlNJT04oRFJJVkVSX1ZFUlNJT04pOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwor TU9EVUxFX0FVVEhPUihEUklWRVJfQVVUSE9SKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJf REVTQyk7Ci0tIAoyLjE5LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbA== 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 02F53C5DF64 for ; Wed, 6 Nov 2019 07:14:28 +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 BD6E0217D7 for ; Wed, 6 Nov 2019 07:14:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BD6E0217D7 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 6F4616EC16; Wed, 6 Nov 2019 07:14:25 +0000 (UTC) Received: from us-smtp-delivery-1.mimecast.com (us-smtp-1.mimecast.com [205.139.110.61]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1B9286EC11 for ; Wed, 6 Nov 2019 07:14:24 +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-88-YSb2ObhtMtej5K6Kghc6SQ-1; Wed, 06 Nov 2019 02:14:19 -0500 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 79447477; Wed, 6 Nov 2019 07:14:15 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-193.pek2.redhat.com [10.72.12.193]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E2961001B00; Wed, 6 Nov 2019 07:12:27 +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: Wed, 6 Nov 2019 15:05:47 +0800 Message-Id: <20191106070548.18980-6-jasowang@redhat.com> In-Reply-To: <20191106070548.18980-1-jasowang@redhat.com> References: <20191106070548.18980-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-MC-Unique: YSb2ObhtMtej5K6Kghc6SQ-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=1573024463; 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=ZIJAtuaeC/flAgfyNCJGB/oqkTsDq4tzC/SAiq6v5f0=; b=RK7ibLMnKPP7VdQlHjb0AQCvGE9CDK8M673ZdfDZ5leTHhjVIyR4KzI/Yekvp2Zqt743ad Mx7TCeWOBJUWIGRN+FtrxaSNL1fsAb5aFmQQleSgK+a7SR5gT4+SP+66N6LMFD368uZ6RL PxgKN6q+fX86oFHeDbpqxyh7OfnBrJY= Subject: [Intel-gfx] [PATCH V9 5/6] virtio: introduce a mdev based transport X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Message-ID: <20191106070547.Yb5tyCN3eVAFawEwQINu_Nul5YxV4pnl9DEkA5mz0KA@z> VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIGEgbmV3IG1kZXYgdHJhbnNwb3J0IGZvciB2aXJ0aW8uIFRo aXMgaXMgdXNlZCB0bwp1c2Uga2VybmVsIHZpcnRpbyBkcml2ZXIgdG8gZHJpdmUgdGhlIG1lZGlh dGVkIGRldmljZSB0aGF0IGlzIGNhcGFibGUKb2YgcG9wdWxhdGluZyB2aXJ0cXVldWUgZGlyZWN0 bHkuCgpBIG5ldyB2aXJ0aW8tbWRldiBkcml2ZXIgd2lsbCBiZSByZWdpc3RlcmVkIHRvIHRoZSBt ZGV2IGJ1cywgd2hlbiBhCm5ldyB2aXJ0aW8tbWRldiBkZXZpY2UgaXMgcHJvYmVkLCBpdCB3aWxs IHJlZ2lzdGVyIHRoZSBkZXZpY2Ugd2l0aAptZGV2IGJhc2VkIGNvbmZpZyBvcHMuIFRoaXMgbWVh bnMgaXQgaXMgYSBzb2Z0d2FyZSB0cmFuc3BvcnQgYmV0d2VlbgptZGV2IGRyaXZlciBhbmQgbWRl diBkZXZpY2UuIFRoZSB0cmFuc3BvcnQgd2FzIGltcGxlbWVudGVkIHRocm91Z2gKZGV2aWNlIHNw ZWNpZmljIG9wcyB3aGljaCBpcyBhIHBhcnQgb2YgbWRldl9wYXJlbnRfb3BzIG5vdy4KClNpZ25l ZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Ci0tLQogZHJpdmVycy92 aXJ0aW8vS2NvbmZpZyAgICAgICB8ICAxMyArKwogZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUgICAg ICB8ICAgMSArCiBkcml2ZXJzL3ZpcnRpby92aXJ0aW9fbWRldi5jIHwgNDA2ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDQyMCBpbnNlcnRpb25z KCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy92aXJ0aW8vdmlydGlvX21kZXYuYwoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL0tjb25maWcgYi9kcml2ZXJzL3ZpcnRpby9LY29uZmln CmluZGV4IDA3ODYxNWNmMmFmYy4uNTU4YWM2MDdkMTA3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Zp cnRpby9LY29uZmlnCisrKyBiL2RyaXZlcnMvdmlydGlvL0tjb25maWcKQEAgLTQzLDYgKzQzLDE5 IEBAIGNvbmZpZyBWSVJUSU9fUENJX0xFR0FDWQogCiAJICBJZiB1bnN1cmUsIHNheSBZLgogCitj b25maWcgVklSVElPX01ERVYKKwl0cmlzdGF0ZSAiTURFViBkcml2ZXIgZm9yIHZpcnRpbyBkZXZp Y2VzIgorCWRlcGVuZHMgb24gVkZJT19NREVWICYmIFZJUlRJTworCWRlZmF1bHQgbgorCWhlbHAK KwkgIFRoaXMgZHJpdmVyIHByb3ZpZGVzIHN1cHBvcnQgZm9yIHZpcnRpbyBiYXNlZCBwYXJhdmly dHVhbAorCSAgZGV2aWNlIGRyaXZlciBvdmVyIE1ERVYgYnVzLiBUaGlzIHJlcXVpcmVzIHlvdXIg ZW52aXJvbmVtbnQKKwkgIGhhcyBhcHByb3ByaWF0ZSB2aXJ0aW8gbWRldiBkZXZpY2UgaW1wbGVt ZW50YXRpb24gd2hpY2ggbWF5CisJICBvcGVyYXRlIG9uIHRoZSBwaHlzaWNhbCBkZXZpY2UgdGhh dCB0aGUgZGF0YXBhdGggb2YgdmlydGlvCisJICBjb3VsZCBiZSBvZmZsb2FkZWQgdG8gaGFyZHdh cmUuCisKKwkgIElmIHVuc3VyZSwgc2F5IE0KKwogY29uZmlnIFZJUlRJT19QTUVNCiAJdHJpc3Rh dGUgIlN1cHBvcnQgZm9yIHZpcnRpbyBwbWVtIGRyaXZlciIKIAlkZXBlbmRzIG9uIFZJUlRJTwpk aWZmIC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUgYi9kcml2ZXJzL3ZpcnRpby9NYWtl ZmlsZQppbmRleCAzYTJiNWM1ZGNmNDYuLmYyOTk3YjZjODEyZiAxMDA2NDQKLS0tIGEvZHJpdmVy cy92aXJ0aW8vTWFrZWZpbGUKKysrIGIvZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUKQEAgLTYsMyAr Niw0IEBAIHZpcnRpb19wY2kteSA6PSB2aXJ0aW9fcGNpX21vZGVybi5vIHZpcnRpb19wY2lfY29t bW9uLm8KIHZpcnRpb19wY2ktJChDT05GSUdfVklSVElPX1BDSV9MRUdBQ1kpICs9IHZpcnRpb19w Y2lfbGVnYWN5Lm8KIG9iai0kKENPTkZJR19WSVJUSU9fQkFMTE9PTikgKz0gdmlydGlvX2JhbGxv b24ubwogb2JqLSQoQ09ORklHX1ZJUlRJT19JTlBVVCkgKz0gdmlydGlvX2lucHV0Lm8KK29iai0k KENPTkZJR19WSVJUSU9fTURFVikgKz0gdmlydGlvX21kZXYubwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy92aXJ0aW8vdmlydGlvX21kZXYuYyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19tZGV2LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45ZTEyZWYyNDA0OTMKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fbWRldi5jCkBAIC0wLDAgKzEsNDA2 IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisvKgorICogVklS VElPIGJhc2VkIGRyaXZlciBmb3IgTWVkaWF0ZWQgZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChj KSAyMDE5LCBSZWQgSGF0LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogICAgIEF1dGhvcjogSmFz b24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4 L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZp Y2UuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ CisjaW5jbHVkZSA8bGludXgvdXVpZC5oPgorI2luY2x1ZGUgPGxpbnV4L21kZXYuaD4KKyNpbmNs dWRlIDxsaW51eC9tZGV2X3ZpcnRpb19vcHMuaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW8uaD4K KyNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgvdmlydGlv X3JpbmcuaD4KKworI2RlZmluZSBEUklWRVJfVkVSU0lPTiAgIjAuMSIKKyNkZWZpbmUgRFJJVkVS X0FVVEhPUiAgICJSZWQgSGF0IENvcnBvcmF0aW9uIgorI2RlZmluZSBEUklWRVJfREVTQyAgICAg IlZJUlRJTyBiYXNlZCBkcml2ZXIgZm9yIE1lZGlhdGVkIGRldmljZSIKKworI2RlZmluZSB0b192 aXJ0aW9fbWRldl9kZXZpY2UoZGV2KSBcCisJY29udGFpbmVyX29mKGRldiwgc3RydWN0IHZpcnRp b19tZGV2X2RldmljZSwgdmRldikKKworc3RydWN0IHZpcnRpb19tZGV2X2RldmljZSB7CisJc3Ry dWN0IHZpcnRpb19kZXZpY2UgdmRldjsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXY7CisJdTY0 IGZlYXR1cmVzOworCisJLyogVGhlIGxvY2sgdG8gcHJvdGVjdCB2aXJ0cXVldWUgbGlzdCAqLwor CXNwaW5sb2NrX3QgbG9jazsKKwkvKiBMaXN0IG9mIHZpcnRpb19tZGV2X3ZxX2luZm8gKi8KKwlz dHJ1Y3QgbGlzdF9oZWFkIHZpcnRxdWV1ZXM7Cit9OworCitzdHJ1Y3QgdmlydGlvX21kZXZfdnFf aW5mbyB7CisJLyogdGhlIGFjdHVhbCB2aXJ0cXVldWUgKi8KKwlzdHJ1Y3QgdmlydHF1ZXVlICp2 cTsKKworCS8qIHRoZSBsaXN0IG5vZGUgZm9yIHRoZSB2aXJ0cXVldWVzIGxpc3QgKi8KKwlzdHJ1 Y3QgbGlzdF9oZWFkIG5vZGU7Cit9OworCitzdGF0aWMgc3RydWN0IG1kZXZfZGV2aWNlICp2bV9n ZXRfbWRldihzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKK3sKKwlzdHJ1Y3QgdmlydGlvX21k ZXZfZGV2aWNlICp2bV9kZXYgPSB0b192aXJ0aW9fbWRldl9kZXZpY2UodmRldik7CisJc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2ID0gdm1fZGV2LT5tZGV2OworCisJcmV0dXJuIG1kZXY7Cit9CisK K3N0YXRpYyB2b2lkIHZpcnRpb19tZGV2X2dldChzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwg dW5zaWduZWQgb2Zmc2V0LAorCQkJICAgIHZvaWQgKmJ1ZiwgdW5zaWduZWQgbGVuKQoreworCXN0 cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVj dCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYp OworCisJb3BzLT5nZXRfY29uZmlnKG1kZXYsIG9mZnNldCwgYnVmLCBsZW4pOworfQorCitzdGF0 aWMgdm9pZCB2aXJ0aW9fbWRldl9zZXQoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYsIHVuc2ln bmVkIG9mZnNldCwKKwkJCSAgICBjb25zdCB2b2lkICpidWYsIHVuc2lnbmVkIGxlbikKK3sKKwlz dHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2ZGV2KTsKKwljb25zdCBzdHJ1 Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9nZXRfdmlydGlvX29wcyhtZGV2 KTsKKworCW9wcy0+c2V0X2NvbmZpZyhtZGV2LCBvZmZzZXQsIGJ1ZiwgbGVuKTsKK30KKworc3Rh dGljIHUzMiB2aXJ0aW9fbWRldl9nZW5lcmF0aW9uKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2 KQoreworCXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNv bnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9f b3BzKG1kZXYpOworCisJaWYgKG9wcy0+Z2V0X2dlbmVyYXRpb24pCisJCXJldHVybiBvcHMtPmdl dF9nZW5lcmF0aW9uKG1kZXYpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB1OCB2aXJ0aW9f bWRldl9nZXRfc3RhdHVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2 X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJ cmV0dXJuIG9wcy0+Z2V0X3N0YXR1cyhtZGV2KTsKK30KKworc3RhdGljIHZvaWQgdmlydGlvX21k ZXZfc2V0X3N0YXR1cyhzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwgdTggc3RhdHVzKQorewor CXN0cnVjdCBtZGV2X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0 cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1k ZXYpOworCisJcmV0dXJuIG9wcy0+c2V0X3N0YXR1cyhtZGV2LCBzdGF0dXMpOworfQorCitzdGF0 aWMgdm9pZCB2aXJ0aW9fbWRldl9yZXNldChzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKK3sK KwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2ZGV2KTsKKwljb25zdCBz dHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9nZXRfdmlydGlvX29wcyht ZGV2KTsKKworCXJldHVybiBvcHMtPnNldF9zdGF0dXMobWRldiwgMCk7Cit9CisKK3N0YXRpYyBi b29sIHZpcnRpb19tZGV2X25vdGlmeShzdHJ1Y3QgdmlydHF1ZXVlICp2cSkKK3sKKwlzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2cS0+dmRldik7CisJY29uc3Qgc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7 CisKKwlvcHMtPmtpY2tfdnEobWRldiwgdnEtPmluZGV4KTsKKworCXJldHVybiB0cnVlOworfQor CitzdGF0aWMgaXJxcmV0dXJuX3QgdmlydGlvX21kZXZfY29uZmlnX2NiKHZvaWQgKnByaXZhdGUp Cit7CisJc3RydWN0IHZpcnRpb19tZGV2X2RldmljZSAqdm1fZGV2ID0gcHJpdmF0ZTsKKworCXZp cnRpb19jb25maWdfY2hhbmdlZCgmdm1fZGV2LT52ZGV2KTsKKworCXJldHVybiBJUlFfSEFORExF RDsKK30KKworc3RhdGljIGlycXJldHVybl90IHZpcnRpb19tZGV2X3ZpcnRxdWV1ZV9jYih2b2lk ICpwcml2YXRlKQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl92cV9pbmZvICppbmZvID0gcHJpdmF0 ZTsKKworCXJldHVybiB2cmluZ19pbnRlcnJ1cHQoMCwgaW5mby0+dnEpOworfQorCitzdGF0aWMg c3RydWN0IHZpcnRxdWV1ZSAqCit2aXJ0aW9fbWRldl9zZXR1cF92cShzdHJ1Y3QgdmlydGlvX2Rl dmljZSAqdmRldiwgdW5zaWduZWQgaW50IGluZGV4LAorCQkgICAgIHZvaWQgKCpjYWxsYmFjayko c3RydWN0IHZpcnRxdWV1ZSAqdnEpLAorCQkgICAgIGNvbnN0IGNoYXIgKm5hbWUsIGJvb2wgY3R4 KQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2RldiA9IHRvX3ZpcnRpb19tZGV2 X2RldmljZSh2ZGV2KTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9nZXRfbWRldih2 ZGV2KTsKKwljb25zdCBzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqb3BzID0gbWRldl9n ZXRfdmlydGlvX29wcyhtZGV2KTsKKwlzdHJ1Y3QgdmlydGlvX21kZXZfdnFfaW5mbyAqaW5mbzsK KwlzdHJ1Y3QgdmlydGlvX21kZXZfY2FsbGJhY2sgY2I7CisJc3RydWN0IHZpcnRxdWV1ZSAqdnE7 CisJdTY0IGRlc2NfYWRkciwgZHJpdmVyX2FkZHIsIGRldmljZV9hZGRyOworCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CisJdTMyIGFsaWduLCBudW07CisJaW50IGVycjsKKworCWlmICghbmFtZSkKKwkJ cmV0dXJuIE5VTEw7CisKKwkvKiBRdWV1ZSBzaG91bGRuJ3QgYWxyZWFkeSBiZSBzZXQgdXAuICov CisJaWYgKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSkKKwkJcmV0dXJuIEVSUl9QVFIo LUVOT0VOVCk7CisKKwkvKiBBbGxvY2F0ZSBhbmQgZmlsbCBvdXQgb3VyIGFjdGl2ZSBxdWV1ZSBk ZXNjcmlwdGlvbiAqLworCWluZm8gPSBrbWFsbG9jKHNpemVvZigqaW5mbyksIEdGUF9LRVJORUwp OworCWlmICghaW5mbykKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwludW0gPSBvcHMt PmdldF92cV9udW1fbWF4KG1kZXYpOworCWlmIChudW0gPT0gMCkgeworCQllcnIgPSAtRU5PRU5U OworCQlnb3RvIGVycm9yX25ld192aXJ0cXVldWU7CisJfQorCisJLyogQ3JlYXRlIHRoZSB2cmlu ZyAqLworCWFsaWduID0gb3BzLT5nZXRfdnFfYWxpZ24obWRldik7CisJdnEgPSB2cmluZ19jcmVh dGVfdmlydHF1ZXVlKGluZGV4LCBudW0sIGFsaWduLCB2ZGV2LAorCQkJCSAgICB0cnVlLCB0cnVl LCBjdHgsCisJCQkJICAgIHZpcnRpb19tZGV2X25vdGlmeSwgY2FsbGJhY2ssIG5hbWUpOworCWlm ICghdnEpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJvcl9uZXdfdmlydHF1ZXVlOwor CX0KKworCS8qIFNldHVwIHZpcnRxdWV1ZSBjYWxsYmFjayAqLworCWNiLmNhbGxiYWNrID0gdmly dGlvX21kZXZfdmlydHF1ZXVlX2NiOworCWNiLnByaXZhdGUgPSBpbmZvOworCW9wcy0+c2V0X3Zx X2NiKG1kZXYsIGluZGV4LCAmY2IpOworCW9wcy0+c2V0X3ZxX251bShtZGV2LCBpbmRleCwgdmly dHF1ZXVlX2dldF92cmluZ19zaXplKHZxKSk7CisKKwlkZXNjX2FkZHIgPSB2aXJ0cXVldWVfZ2V0 X2Rlc2NfYWRkcih2cSk7CisJZHJpdmVyX2FkZHIgPSB2aXJ0cXVldWVfZ2V0X2F2YWlsX2FkZHIo dnEpOworCWRldmljZV9hZGRyID0gdmlydHF1ZXVlX2dldF91c2VkX2FkZHIodnEpOworCisJaWYg KG9wcy0+c2V0X3ZxX2FkZHJlc3MobWRldiwgaW5kZXgsCisJCQkJZGVzY19hZGRyLCBkcml2ZXJf YWRkciwKKwkJCQlkZXZpY2VfYWRkcikpIHsKKwkJZXJyID0gLUVJTlZBTDsKKwkJZ290byBlcnJf dnE7CisJfQorCisJb3BzLT5zZXRfdnFfcmVhZHkobWRldiwgaW5kZXgsIDEpOworCisJdnEtPnBy aXYgPSBpbmZvOworCWluZm8tPnZxID0gdnE7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdm1fZGV2 LT5sb2NrLCBmbGFncyk7CisJbGlzdF9hZGQoJmluZm8tPm5vZGUsICZ2bV9kZXYtPnZpcnRxdWV1 ZXMpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnZtX2Rldi0+bG9jaywgZmxhZ3MpOworCisJ cmV0dXJuIHZxOworCitlcnJfdnE6CisJdnJpbmdfZGVsX3ZpcnRxdWV1ZSh2cSk7CitlcnJvcl9u ZXdfdmlydHF1ZXVlOgorCW9wcy0+c2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4LCAwKTsKKwlXQVJO X09OKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSk7CisJa2ZyZWUoaW5mbyk7CisJcmV0 dXJuIEVSUl9QVFIoZXJyKTsKK30KKworc3RhdGljIHZvaWQgdmlydGlvX21kZXZfZGVsX3ZxKHN0 cnVjdCB2aXJ0cXVldWUgKnZxKQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2Rl diA9IHRvX3ZpcnRpb19tZGV2X2RldmljZSh2cS0+dmRldik7CisJc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2ID0gdm1fZGV2LT5tZGV2OworCWNvbnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vf b3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCXN0cnVjdCB2aXJ0aW9fbWRl dl92cV9pbmZvICppbmZvID0gdnEtPnByaXY7CisJdW5zaWduZWQgaW50IGluZGV4ID0gdnEtPmlu ZGV4OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdm1fZGV2 LT5sb2NrLCBmbGFncyk7CisJbGlzdF9kZWwoJmluZm8tPm5vZGUpOworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJnZtX2Rldi0+bG9jaywgZmxhZ3MpOworCisJLyogU2VsZWN0IGFuZCBkZWFjdGl2 YXRlIHRoZSBxdWV1ZSAqLworCW9wcy0+c2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4LCAwKTsKKwlX QVJOX09OKG9wcy0+Z2V0X3ZxX3JlYWR5KG1kZXYsIGluZGV4KSk7CisKKwl2cmluZ19kZWxfdmly dHF1ZXVlKHZxKTsKKworCWtmcmVlKGluZm8pOworfQorCitzdGF0aWMgdm9pZCB2aXJ0aW9fbWRl dl9kZWxfdnFzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCB2aXJ0cXVl dWUgKnZxLCAqbjsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh2cSwgbiwgJnZkZXYtPnZx cywgbGlzdCkKKwkJdmlydGlvX21kZXZfZGVsX3ZxKHZxKTsKK30KKworc3RhdGljIGludCB2aXJ0 aW9fbWRldl9maW5kX3ZxcyhzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwgdW5zaWduZWQgbnZx cywKKwkJCQlzdHJ1Y3QgdmlydHF1ZXVlICp2cXNbXSwKKwkJCQl2cV9jYWxsYmFja190ICpjYWxs YmFja3NbXSwKKwkJCQljb25zdCBjaGFyICogY29uc3QgbmFtZXNbXSwKKwkJCQljb25zdCBib29s ICpjdHgsCisJCQkJc3RydWN0IGlycV9hZmZpbml0eSAqZGVzYykKK3sKKwlzdHJ1Y3QgdmlydGlv X21kZXZfZGV2aWNlICp2bV9kZXYgPSB0b192aXJ0aW9fbWRldl9kZXZpY2UodmRldik7CisJc3Ry dWN0IG1kZXZfZGV2aWNlICptZGV2ID0gdm1fZ2V0X21kZXYodmRldik7CisJY29uc3Qgc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7 CisJc3RydWN0IHZpcnRpb19tZGV2X2NhbGxiYWNrIGNiOworCWludCBpLCBlcnIsIHF1ZXVlX2lk eCA9IDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnZxczsgKytpKSB7CisJCWlmICghbmFtZXNbaV0p IHsKKwkJCXZxc1tpXSA9IE5VTEw7CisJCQljb250aW51ZTsKKwkJfQorCisJCXZxc1tpXSA9IHZp cnRpb19tZGV2X3NldHVwX3ZxKHZkZXYsIHF1ZXVlX2lkeCsrLAorCQkJCQkgICAgICBjYWxsYmFj a3NbaV0sIG5hbWVzW2ldLCBjdHggPworCQkJCQkgICAgICBjdHhbaV0gOiBmYWxzZSk7CisJCWlm IChJU19FUlIodnFzW2ldKSkgeworCQkJZXJyID0gUFRSX0VSUih2cXNbaV0pOworCQkJZ290byBl cnJfc2V0dXBfdnE7CisJCX0KKwl9CisKKwljYi5jYWxsYmFjayA9IHZpcnRpb19tZGV2X2NvbmZp Z19jYjsKKwljYi5wcml2YXRlID0gdm1fZGV2OworCW9wcy0+c2V0X2NvbmZpZ19jYihtZGV2LCAm Y2IpOworCisJcmV0dXJuIDA7CisKK2Vycl9zZXR1cF92cToKKwl2aXJ0aW9fbWRldl9kZWxfdnFz KHZkZXYpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB1NjQgdmlydGlvX21kZXZfZ2V0X2Zl YXR1cmVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBtZGV2X2Rldmlj ZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19k ZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJcmV0dXJuIG9w cy0+Z2V0X2ZlYXR1cmVzKG1kZXYpOworfQorCitzdGF0aWMgaW50IHZpcnRpb19tZGV2X2ZpbmFs aXplX2ZlYXR1cmVzKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCBtZGV2 X2RldmljZSAqbWRldiA9IHZtX2dldF9tZGV2KHZkZXYpOworCWNvbnN0IHN0cnVjdCBtZGV2X3Zp cnRpb19kZXZpY2Vfb3BzICpvcHMgPSBtZGV2X2dldF92aXJ0aW9fb3BzKG1kZXYpOworCisJLyog R2l2ZSB2aXJ0aW9fcmluZyBhIGNoYW5jZSB0byBhY2NlcHQgZmVhdHVyZXMuICovCisJdnJpbmdf dHJhbnNwb3J0X2ZlYXR1cmVzKHZkZXYpOworCisJcmV0dXJuIG9wcy0+c2V0X2ZlYXR1cmVzKG1k ZXYsIHZkZXYtPmZlYXR1cmVzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKnZpcnRpb19tZGV2 X2J1c19uYW1lKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQoreworCXN0cnVjdCB2aXJ0aW9f bWRldl9kZXZpY2UgKnZtX2RldiA9IHRvX3ZpcnRpb19tZGV2X2RldmljZSh2ZGV2KTsKKwlzdHJ1 Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9kZXYtPm1kZXY7CisKKwlyZXR1cm4gZGV2X25hbWUo bWRldl9kZXYobWRldikpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHZpcnRpb19jb25maWdf b3BzIHZpcnRpb19tZGV2X2NvbmZpZ19vcHMgPSB7CisJLmdldAkJPSB2aXJ0aW9fbWRldl9nZXQs CisJLnNldAkJPSB2aXJ0aW9fbWRldl9zZXQsCisJLmdlbmVyYXRpb24JPSB2aXJ0aW9fbWRldl9n ZW5lcmF0aW9uLAorCS5nZXRfc3RhdHVzCT0gdmlydGlvX21kZXZfZ2V0X3N0YXR1cywKKwkuc2V0 X3N0YXR1cwk9IHZpcnRpb19tZGV2X3NldF9zdGF0dXMsCisJLnJlc2V0CQk9IHZpcnRpb19tZGV2 X3Jlc2V0LAorCS5maW5kX3Zxcwk9IHZpcnRpb19tZGV2X2ZpbmRfdnFzLAorCS5kZWxfdnFzCT0g dmlydGlvX21kZXZfZGVsX3ZxcywKKwkuZ2V0X2ZlYXR1cmVzCT0gdmlydGlvX21kZXZfZ2V0X2Zl YXR1cmVzLAorCS5maW5hbGl6ZV9mZWF0dXJlcyA9IHZpcnRpb19tZGV2X2ZpbmFsaXplX2ZlYXR1 cmVzLAorCS5idXNfbmFtZQk9IHZpcnRpb19tZGV2X2J1c19uYW1lLAorfTsKKworc3RhdGljIHZv aWQgdmlydGlvX21kZXZfcmVsZWFzZV9kZXYoc3RydWN0IGRldmljZSAqX2QpCit7CisJc3RydWN0 IHZpcnRpb19kZXZpY2UgKnZkZXYgPQorCSAgICAgICBjb250YWluZXJfb2YoX2QsIHN0cnVjdCB2 aXJ0aW9fZGV2aWNlLCBkZXYpOworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2UgKnZtX2RldiA9 CisJICAgICAgIGNvbnRhaW5lcl9vZih2ZGV2LCBzdHJ1Y3QgdmlydGlvX21kZXZfZGV2aWNlLCB2 ZGV2KTsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB2bV9kZXYtPm1kZXY7CisKKwlkZXZt X2tmcmVlKG1kZXZfZGV2KG1kZXYpLCB2bV9kZXYpOworfQorCitzdGF0aWMgaW50IHZpcnRpb19t ZGV2X3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYgPSBtZGV2X2Zyb21fZGV2KGRldik7CisJY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2Rldmlj ZV9vcHMgKm9wcyA9IG1kZXZfZ2V0X3ZpcnRpb19vcHMobWRldik7CisJc3RydWN0IHZpcnRpb19t ZGV2X2RldmljZSAqdm1fZGV2OworCWludCByYzsKKworCXZtX2RldiA9IGRldm1fa3phbGxvYyhk ZXYsIHNpemVvZigqdm1fZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF2bV9kZXYpCisJCXJldHVy biAtRU5PTUVNOworCisJdm1fZGV2LT52ZGV2LmRldi5wYXJlbnQgPSBkZXY7CisJdm1fZGV2LT52 ZGV2LmRldi5yZWxlYXNlID0gdmlydGlvX21kZXZfcmVsZWFzZV9kZXY7CisJdm1fZGV2LT52ZGV2 LmNvbmZpZyA9ICZ2aXJ0aW9fbWRldl9jb25maWdfb3BzOworCXZtX2Rldi0+bWRldiA9IG1kZXY7 CisJSU5JVF9MSVNUX0hFQUQoJnZtX2Rldi0+dmlydHF1ZXVlcyk7CisJc3Bpbl9sb2NrX2luaXQo JnZtX2Rldi0+bG9jayk7CisKKwl2bV9kZXYtPnZkZXYuaWQuZGV2aWNlID0gb3BzLT5nZXRfZGV2 aWNlX2lkKG1kZXYpOworCWlmICh2bV9kZXYtPnZkZXYuaWQuZGV2aWNlID09IDApCisJCXJldHVy biAtRU5PREVWOworCisJdm1fZGV2LT52ZGV2LmlkLnZlbmRvciA9IG9wcy0+Z2V0X3ZlbmRvcl9p ZChtZGV2KTsKKwlyYyA9IHJlZ2lzdGVyX3ZpcnRpb19kZXZpY2UoJnZtX2Rldi0+dmRldik7CisJ aWYgKHJjKQorCQlwdXRfZGV2aWNlKGRldik7CisJZWxzZQorCQlkZXZfc2V0X2RydmRhdGEoZGV2 LCB2bV9kZXYpOworCisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgdm9pZCB2aXJ0aW9fbWRldl9y ZW1vdmUoc3RydWN0IGRldmljZSAqZGV2KQoreworCXN0cnVjdCB2aXJ0aW9fbWRldl9kZXZpY2Ug KnZtX2RldiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCisJdW5yZWdpc3Rlcl92aXJ0aW9fZGV2 aWNlKCZ2bV9kZXYtPnZkZXYpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG1kZXZfY2xhc3Nf aWQgdmlydGlvX2lkX3RhYmxlW10gPSB7CisJeyBNREVWX0NMQVNTX0lEX1ZJUlRJTyB9LAorCXsg MCB9LAorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShtZGV2LCB2aXJ0aW9faWRfdGFibGUpOwor CitzdGF0aWMgc3RydWN0IG1kZXZfZHJpdmVyIHZpcnRpb19tZGV2X2RyaXZlciA9IHsKKwkubmFt ZQk9ICJ2aXJ0aW9fbWRldiIsCisJLnByb2JlCT0gdmlydGlvX21kZXZfcHJvYmUsCisJLnJlbW92 ZSA9IHZpcnRpb19tZGV2X3JlbW92ZSwKKwkuaWRfdGFibGUgPSB2aXJ0aW9faWRfdGFibGUsCit9 OworCitzdGF0aWMgaW50IF9faW5pdCB2aXJ0aW9fbWRldl9pbml0KHZvaWQpCit7CisJcmV0dXJu IG1kZXZfcmVnaXN0ZXJfZHJpdmVyKCZ2aXJ0aW9fbWRldl9kcml2ZXIsIFRISVNfTU9EVUxFKTsK K30KKworc3RhdGljIHZvaWQgX19leGl0IHZpcnRpb19tZGV2X2V4aXQodm9pZCkKK3sKKwltZGV2 X3VucmVnaXN0ZXJfZHJpdmVyKCZ2aXJ0aW9fbWRldl9kcml2ZXIpOworfQorCittb2R1bGVfaW5p dCh2aXJ0aW9fbWRldl9pbml0KQorbW9kdWxlX2V4aXQodmlydGlvX21kZXZfZXhpdCkKKworTU9E VUxFX1ZFUlNJT04oRFJJVkVSX1ZFUlNJT04pOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwor TU9EVUxFX0FVVEhPUihEUklWRVJfQVVUSE9SKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJf REVTQyk7Ci0tIAoyLjE5LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2lu dGVsLWdmeA==