// SPDX-License-Identifier: GPL-2.0-only
  /*
   * vDPA bus.
   *
   * Copyright (c) 2020, Red Hat. All rights reserved.
   *     Author: Jason Wang <jasowang@redhat.com>
   *
   */
  
  #include <linux/module.h>
  #include <linux/idr.h>
  #include <linux/slab.h>
  #include <linux/vdpa.h>
  
  static DEFINE_IDA(vdpa_index_ida);
  
  static int vdpa_dev_probe(struct device *d)
  {
  	struct vdpa_device *vdev = dev_to_vdpa(d);
  	struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
  	int ret = 0;
  
  	if (drv && drv->probe)
  		ret = drv->probe(vdev);
  
  	return ret;
  }
  
  static int vdpa_dev_remove(struct device *d)
  {
  	struct vdpa_device *vdev = dev_to_vdpa(d);
  	struct vdpa_driver *drv = drv_to_vdpa(vdev->dev.driver);
  
  	if (drv && drv->remove)
  		drv->remove(vdev);
  
  	return 0;
  }
  
  static struct bus_type vdpa_bus = {
  	.name  = "vdpa",
  	.probe = vdpa_dev_probe,
  	.remove = vdpa_dev_remove,
  };
  
  static void vdpa_release_dev(struct device *d)
  {
  	struct vdpa_device *vdev = dev_to_vdpa(d);
  	const struct vdpa_config_ops *ops = vdev->config;
  
  	if (ops->free)
  		ops->free(vdev);
  
  	ida_simple_remove(&vdpa_index_ida, vdev->index);
  	kfree(vdev);
  }
  
  /**
   * __vdpa_alloc_device - allocate and initilaize a vDPA device
   * This allows driver to some prepartion after device is
   * initialized but before registered.
   * @parent: the parent device
   * @config: the bus operations that is supported by this device

   * @nvqs: number of virtqueues supported by this device

   * @size: size of the parent structure that contains private data
   *

   * Driver should use vdpa_alloc_device() wrapper macro instead of

   * using this directly.
   *
   * Returns an error when parent/config/dma_dev is not set or fail to get
   * ida.
   */
  struct vdpa_device *__vdpa_alloc_device(struct device *parent,
  					const struct vdpa_config_ops *config,

  					int nvqs,

  					size_t size)
  {
  	struct vdpa_device *vdev;
  	int err = -EINVAL;
  
  	if (!config)
  		goto err;
  
  	if (!!config->dma_map != !!config->dma_unmap)
  		goto err;
  
  	err = -ENOMEM;
  	vdev = kzalloc(size, GFP_KERNEL);
  	if (!vdev)
  		goto err;
  
  	err = ida_simple_get(&vdpa_index_ida, 0, 0, GFP_KERNEL);
  	if (err < 0)
  		goto err_ida;
  
  	vdev->dev.bus = &vdpa_bus;
  	vdev->dev.parent = parent;
  	vdev->dev.release = vdpa_release_dev;
  	vdev->index = err;
  	vdev->config = config;

  	vdev->features_valid = false;

  	vdev->nvqs = nvqs;

  
  	err = dev_set_name(&vdev->dev, "vdpa%u", vdev->index);
  	if (err)
  		goto err_name;
  
  	device_initialize(&vdev->dev);
  
  	return vdev;
  
  err_name:
  	ida_simple_remove(&vdpa_index_ida, vdev->index);
  err_ida:
  	kfree(vdev);
  err:
  	return ERR_PTR(err);
  }
  EXPORT_SYMBOL_GPL(__vdpa_alloc_device);
  
  /**
   * vdpa_register_device - register a vDPA device

   * Callers must have a succeed call of vdpa_alloc_device() before.

   * @vdev: the vdpa device to be registered to vDPA bus
   *
   * Returns an error when fail to add to vDPA bus
   */
  int vdpa_register_device(struct vdpa_device *vdev)
  {
  	return device_add(&vdev->dev);
  }
  EXPORT_SYMBOL_GPL(vdpa_register_device);
  
  /**
   * vdpa_unregister_device - unregister a vDPA device
   * @vdev: the vdpa device to be unregisted from vDPA bus
   */
  void vdpa_unregister_device(struct vdpa_device *vdev)
  {
  	device_unregister(&vdev->dev);
  }
  EXPORT_SYMBOL_GPL(vdpa_unregister_device);
  
  /**
   * __vdpa_register_driver - register a vDPA device driver
   * @drv: the vdpa device driver to be registered
   * @owner: module owner of the driver
   *
   * Returns an err when fail to do the registration
   */
  int __vdpa_register_driver(struct vdpa_driver *drv, struct module *owner)
  {
  	drv->driver.bus = &vdpa_bus;
  	drv->driver.owner = owner;
  
  	return driver_register(&drv->driver);
  }
  EXPORT_SYMBOL_GPL(__vdpa_register_driver);
  
  /**
   * vdpa_unregister_driver - unregister a vDPA device driver
   * @drv: the vdpa device driver to be unregistered
   */
  void vdpa_unregister_driver(struct vdpa_driver *drv)
  {
  	driver_unregister(&drv->driver);
  }
  EXPORT_SYMBOL_GPL(vdpa_unregister_driver);
  
  static int vdpa_init(void)
  {
  	return bus_register(&vdpa_bus);
  }
  
  static void __exit vdpa_exit(void)
  {
  	bus_unregister(&vdpa_bus);
  	ida_destroy(&vdpa_index_ida);
  }
  core_initcall(vdpa_init);
  module_exit(vdpa_exit);
  
  MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
  MODULE_LICENSE("GPL v2");