linux/drivers/misc/uacce/uacce.c

// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/compat.h>
#include <linux/dma-mapping.h>
#include <linux/iommu.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/uacce.h>

static dev_t uacce_devt;
static DEFINE_XARRAY_ALLOC(uacce_xa);

static const struct class uacce_class = …;

/*
 * If the parent driver or the device disappears, the queue state is invalid and
 * ops are not usable anymore.
 */
static bool uacce_queue_is_valid(struct uacce_queue *q)
{ … }

static int uacce_start_queue(struct uacce_queue *q)
{ … }

static int uacce_put_queue(struct uacce_queue *q)
{ … }

static long uacce_fops_unl_ioctl(struct file *filep,
				 unsigned int cmd, unsigned long arg)
{ … }

#ifdef CONFIG_COMPAT
static long uacce_fops_compat_ioctl(struct file *filep,
				   unsigned int cmd, unsigned long arg)
{ … }
#endif

static int uacce_bind_queue(struct uacce_device *uacce, struct uacce_queue *q)
{ … }

static void uacce_unbind_queue(struct uacce_queue *q)
{ … }

static int uacce_fops_open(struct inode *inode, struct file *filep)
{ … }

static int uacce_fops_release(struct inode *inode, struct file *filep)
{ … }

static void uacce_vma_close(struct vm_area_struct *vma)
{ … }

static const struct vm_operations_struct uacce_vm_ops = …;

static int uacce_fops_mmap(struct file *filep, struct vm_area_struct *vma)
{ … }

static __poll_t uacce_fops_poll(struct file *file, poll_table *wait)
{ … }

static const struct file_operations uacce_fops = …;

#define to_uacce_device(dev) …

static ssize_t api_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{ … }

static ssize_t flags_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{ … }

static ssize_t available_instances_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{ … }

static ssize_t algorithms_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{ … }

static ssize_t region_mmio_size_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{ … }

static ssize_t region_dus_size_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{ … }

static ssize_t isolate_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
{ … }

static ssize_t isolate_strategy_show(struct device *dev, struct device_attribute *attr, char *buf)
{ … }

static ssize_t isolate_strategy_store(struct device *dev, struct device_attribute *attr,
				   const char *buf, size_t count)
{ … }

static DEVICE_ATTR_RO(api);
static DEVICE_ATTR_RO(flags);
static DEVICE_ATTR_RO(available_instances);
static DEVICE_ATTR_RO(algorithms);
static DEVICE_ATTR_RO(region_mmio_size);
static DEVICE_ATTR_RO(region_dus_size);
static DEVICE_ATTR_RO(isolate);
static DEVICE_ATTR_RW(isolate_strategy);

static struct attribute *uacce_dev_attrs[] = …;

static umode_t uacce_dev_is_visible(struct kobject *kobj,
				    struct attribute *attr, int n)
{ … }

static struct attribute_group uacce_dev_group = …;

__ATTRIBUTE_GROUPS(…);

static void uacce_release(struct device *dev)
{ … }

static unsigned int uacce_enable_sva(struct device *parent, unsigned int flags)
{ … }

static void uacce_disable_sva(struct uacce_device *uacce)
{ … }

/**
 * uacce_alloc() - alloc an accelerator
 * @parent: pointer of uacce parent device
 * @interface: pointer of uacce_interface for register
 *
 * Returns uacce pointer if success and ERR_PTR if not
 * Need check returned negotiated uacce->flags
 */
struct uacce_device *uacce_alloc(struct device *parent,
				 struct uacce_interface *interface)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * uacce_register() - add the accelerator to cdev and export to user space
 * @uacce: The initialized uacce device
 *
 * Return 0 if register succeeded, or an error.
 */
int uacce_register(struct uacce_device *uacce)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * uacce_remove() - remove the accelerator
 * @uacce: the accelerator to remove
 */
void uacce_remove(struct uacce_device *uacce)
{ … }
EXPORT_SYMBOL_GPL(…);

static int __init uacce_init(void)
{ … }

static __exit void uacce_exit(void)
{ … }

subsys_initcall(uacce_init);
module_exit(uacce_exit);

MODULE_LICENSE(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;