LXR linux/drivers/vfio/mdev/mdev

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * MDEV driver
   4 *
   5 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   6 *     Author: Neo Jia <cjia@nvidia.com>
   7 *             Kirti Wankhede <kwankhede@nvidia.com>
   8 */
   9
  10#include <linux/device.h>
  11#include <linux/iommu.h>
  12#include <linux/mdev.h>
  13
  14#include "mdev_private.h"
  15
  16static int mdev_attach_iommu(struct mdev_device *mdev)
  17{
  18        int ret;
  19        struct iommu_group *group;
  20
  21        group = iommu_group_alloc();
  22        if (IS_ERR(group))
  23                return PTR_ERR(group);
  24
  25        ret = iommu_group_add_device(group, &mdev->dev);
  26        if (!ret)
  27                dev_info(&mdev->dev, "MDEV: group_id = %d\n",
  28                         iommu_group_id(group));
  29
  30        iommu_group_put(group);
  31        return ret;
  32}
  33
  34static void mdev_detach_iommu(struct mdev_device *mdev)
  35{
  36        iommu_group_remove_device(&mdev->dev);
  37        dev_info(&mdev->dev, "MDEV: detaching iommu\n");
  38}
  39
  40static int mdev_probe(struct device *dev)
  41{
  42        struct mdev_driver *drv =
  43                container_of(dev->driver, struct mdev_driver, driver);
  44        struct mdev_device *mdev = to_mdev_device(dev);
  45        int ret;
  46
  47        ret = mdev_attach_iommu(mdev);
  48        if (ret)
  49                return ret;
  50
  51        if (drv->probe) {
  52                ret = drv->probe(mdev);
  53                if (ret)
  54                        mdev_detach_iommu(mdev);
  55        }
  56
  57        return ret;
  58}
  59
  60static void mdev_remove(struct device *dev)
  61{
  62        struct mdev_driver *drv =
  63                container_of(dev->driver, struct mdev_driver, driver);
  64        struct mdev_device *mdev = to_mdev_device(dev);
  65
  66        if (drv->remove)
  67                drv->remove(mdev);
  68
  69        mdev_detach_iommu(mdev);
  70}
  71
  72static int mdev_match(struct device *dev, struct device_driver *drv)
  73{
  74        /*
  75         * No drivers automatically match. Drivers are only bound by explicit
  76         * device_driver_attach()
  77         */
  78        return 0;
  79}
  80
  81struct bus_type mdev_bus_type = {
  82        .name           = "mdev",
  83        .probe          = mdev_probe,
  84        .remove         = mdev_remove,
  85        .match          = mdev_match,
  86};
  87EXPORT_SYMBOL_GPL(mdev_bus_type);
  88
  89/**
  90 * mdev_register_driver - register a new MDEV driver
  91 * @drv: the driver to register
  92 *
  93 * Returns a negative value on error, otherwise 0.
  94 **/
  95int mdev_register_driver(struct mdev_driver *drv)
  96{
  97        /* initialize common driver fields */
  98        drv->driver.bus = &mdev_bus_type;
  99
 100        /* register with core */
 101        return driver_register(&drv->driver);
 102}
 103EXPORT_SYMBOL(mdev_register_driver);
 104
 105/*
 106 * mdev_unregister_driver - unregister MDEV driver
 107 * @drv: the driver to unregister
 108 */
 109void mdev_unregister_driver(struct mdev_driver *drv)
 110{
 111        driver_unregister(&drv->driver);
 112}
 113EXPORT_SYMBOL(mdev_unregister_driver);
 114
 115int mdev_bus_register(void)
 116{
 117        return bus_register(&mdev_bus_type);
 118}
 119
 120void mdev_bus_unregister(void)
 121{
 122        bus_unregister(&mdev_bus_type);
 123}
 124