drivers/vfio/mdev/mdev_driver.c

   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
  16 static 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
  34 static 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
  40 static 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
  60 static 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
  72 static 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
  81 struct bus_type mdev_bus_type = {
  82         .name           = "mdev",
  83         .probe          = mdev_probe,
  84         .remove         = mdev_remove,
  85         .match          = mdev_match,
  86 };
  87 EXPORT_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  **/
  95 int 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 }
 103 EXPORT_SYMBOL(mdev_register_driver);
 104
 105 /*
 106  * mdev_unregister_driver - unregister MDEV driver
 107  * @drv: the driver to unregister
 108  */
 109 void mdev_unregister_driver(struct mdev_driver *drv)
 110 {
 111         driver_unregister(&drv->driver);
 112 }
 113 EXPORT_SYMBOL(mdev_unregister_driver);
 114
 115 int mdev_bus_register(void)
 116 {
 117         return bus_register(&mdev_bus_type);
 118 }
 119
 120 void mdev_bus_unregister(void)
 121 {
 122         bus_unregister(&mdev_bus_type);
 123 }