drivers/vdpa/vdpa.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vDPA bus.
   4  *
   5  * Copyright (c) 2020, Red Hat. All rights reserved.
   6  *     Author: Jason Wang <jasowang@redhat.com>
   7  *
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/idr.h>
  12 #include <linux/slab.h>
  13 #include <linux/vdpa.h>
  14
  15 static DEFINE_IDA(vdpa_index_ida);
  16
  17 static int vdpa_dev_probe(struct device *d)
  18 {
  19         struct vdpa_device *vdev = dev_to_vdpa(d);
  20         struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
  21         int ret = 0;
  22
  23         if (drv && drv->probe)
  24                 ret = drv->probe(vdev);
  25
  26         return ret;
  27 }
  28
  29 static int vdpa_dev_remove(struct device *d)
  30 {
  31         struct vdpa_device *vdev = dev_to_vdpa(d);
  32         struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
  33
  34         if (drv && drv->remove)
  35                 drv->remove(vdev);
  36
  37         return 0;
  38 }
  39
  40 static struct bus_type vdpa_bus = {
  41         .name  = "vdpa",
  42         .probe = vdpa_dev_probe,
  43         .remove = vdpa_dev_remove,
  44 };
  45
  46 static void vdpa_release_dev(struct device *d)
  47 {
  48         struct vdpa_device *vdev = dev_to_vdpa(d);
  49         const struct vdpa_config_ops *ops = vdev->config;
  50
  51         if (ops->free)
  52                 ops->free(vdev);
  53
  54         ida_simple_remove(&vdpa_index_ida, vdev->index);
  55         kfree(vdev);
  56 }
  57
  58 /**
  59  * __vdpa_alloc_device - allocate and initilaize a vDPA device
  60  * This allows driver to some prepartion after device is
  61  * initialized but before registered.
  62  * @parent: the parent device
  63  * @config: the bus operations that is supported by this device
  64  * @nvqs: number of virtqueues supported by this device
  65  * @size: size of the parent structure that contains private data
  66  *
  67  * Driver should use vdpa_alloc_device() wrapper macro instead of
  68  * using this directly.
  69  *
  70  * Returns an error when parent/config/dma_dev is not set or fail to get
  71  * ida.
  72  */
  73 struct vdpa_device *__vdpa_alloc_device(struct device *parent,
  74                                         const struct vdpa_config_ops *config,
  75                                         int nvqs,
  76                                         size_t size)
  77 {
  78         struct vdpa_device *vdev;
  79         int err = -EINVAL;
  80
  81         if (!config)
  82                 goto err;
  83
  84         if (!!config->dma_map != !!config->dma_unmap)
  85                 goto err;
  86
  87         err = -ENOMEM;
  88         vdev = kzalloc(size, GFP_KERNEL);
  89         if (!vdev)
  90                 goto err;
  91
  92         err = ida_alloc(&vdpa_index_ida, GFP_KERNEL);
  93         if (err < 0)
  94                 goto err_ida;
  95
  96         vdev->dev.bus = &vdpa_bus;
  97         vdev->dev.parent = parent;
  98         vdev->dev.release = vdpa_release_dev;
  99         vdev->index = err;
 100         vdev->config = config;
 101         vdev->features_valid = false;
 102         vdev->nvqs = nvqs;
 103
 104         err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index);
 105         if (err)
 106                 goto err_name;
 107
 108         device_initialize(&vdev->dev);
 109
 110         return vdev;
 111
 112 err_name:
 113         ida_simple_remove(&vdpa_index_ida, vdev->index);
 114 err_ida:
 115         kfree(vdev);
 116 err:
 117         return ERR_PTR(err);
 118 }
 119 EXPORT_SYMBOL_GPL(__vdpa_alloc_device);
 120
 121 /**
 122  * vdpa_register_device - register a vDPA device
 123  * Callers must have a succeed call of vdpa_alloc_device() before.
 124  * @vdev: the vdpa device to be registered to vDPA bus
 125  *
 126  * Returns an error when fail to add to vDPA bus
 127  */
 128 int vdpa_register_device(struct vdpa_device *vdev)
 129 {
 130         return device_add(&vdev->dev);
 131 }
 132 EXPORT_SYMBOL_GPL(vdpa_register_device);
 133
 134 /**
 135  * vdpa_unregister_device - unregister a vDPA device
 136  * @vdev: the vdpa device to be unregisted from vDPA bus
 137  */
 138 void vdpa_unregister_device(struct vdpa_device *vdev)
 139 {
 140         device_unregister(&vdev->dev);
 141 }
 142 EXPORT_SYMBOL_GPL(vdpa_unregister_device);
 143
 144 /**
 145  * __vdpa_register_driver - register a vDPA device driver
 146  * @drv: the vdpa device driver to be registered
 147  * @owner: module owner of the driver
 148  *
 149  * Returns an err when fail to do the registration
 150  */
 151 int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner)
 152 {
 153         drv->driver.bus = &vdpa_bus;
 154         drv->driver.owner = owner;
 155
 156         return driver_register(&drv->driver);
 157 }
 158 EXPORT_SYMBOL_GPL(__vdpa_register_driver);
 159
 160 /**
 161  * vdpa_unregister_driver - unregister a vDPA device driver
 162  * @drv: the vdpa device driver to be unregistered
 163  */
 164 void vdpa_unregister_driver(struct vdpa_driver *drv)
 165 {
 166         driver_unregister(&drv->driver);
 167 }
 168 EXPORT_SYMBOL_GPL(vdpa_unregister_driver);
 169
 170 static int vdpa_init(void)
 171 {
 172         return bus_register(&vdpa_bus);
 173 }
 174
 175 static void __exit vdpa_exit(void)
 176 {
 177         bus_unregister(&vdpa_bus);
 178         ida_destroy(&vdpa_index_ida);
 179 }
 180 core_initcall(vdpa_init);
 181 module_exit(vdpa_exit);
 182
 183 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
 184 MODULE_LICENSE("GPL v2");