40ea89fb19
Now that the driver core allows for struct class to be in read-only memory, we should make all 'class' structures declared at build time placing them into read-only memory, instead of having to be dynamically allocated at runtime. Cc: Zhou Wang <wangzhou1@hisilicon.com> Cc: Arnd Bergmann <arnd@arndb.de> Cc: linux-accelerators@lists.ozlabs.org Tested-by: Zhangfei Gao <zhangfei.gao@linaro.org> Link: https://lore.kernel.org/r/2023102458-designate-vicinity-4c86@gregkh Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
652 lines
15 KiB
C
652 lines
15 KiB
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 = {
|
|
.name = UACCE_NAME,
|
|
};
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
return q->state == UACCE_Q_INIT || q->state == UACCE_Q_STARTED;
|
|
}
|
|
|
|
static int uacce_start_queue(struct uacce_queue *q)
|
|
{
|
|
int ret;
|
|
|
|
if (q->state != UACCE_Q_INIT)
|
|
return -EINVAL;
|
|
|
|
if (q->uacce->ops->start_queue) {
|
|
ret = q->uacce->ops->start_queue(q);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
q->state = UACCE_Q_STARTED;
|
|
return 0;
|
|
}
|
|
|
|
static int uacce_put_queue(struct uacce_queue *q)
|
|
{
|
|
struct uacce_device *uacce = q->uacce;
|
|
|
|
if ((q->state == UACCE_Q_STARTED) && uacce->ops->stop_queue)
|
|
uacce->ops->stop_queue(q);
|
|
|
|
if ((q->state == UACCE_Q_INIT || q->state == UACCE_Q_STARTED) &&
|
|
uacce->ops->put_queue)
|
|
uacce->ops->put_queue(q);
|
|
|
|
q->state = UACCE_Q_ZOMBIE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static long uacce_fops_unl_ioctl(struct file *filep,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct uacce_queue *q = filep->private_data;
|
|
struct uacce_device *uacce = q->uacce;
|
|
long ret = -ENXIO;
|
|
|
|
/*
|
|
* uacce->ops->ioctl() may take the mmap_lock when copying arg to/from
|
|
* user. Avoid a circular lock dependency with uacce_fops_mmap(), which
|
|
* gets called with mmap_lock held, by taking uacce->mutex instead of
|
|
* q->mutex. Doing this in uacce_fops_mmap() is not possible because
|
|
* uacce_fops_open() calls iommu_sva_bind_device(), which takes
|
|
* mmap_lock, while holding uacce->mutex.
|
|
*/
|
|
mutex_lock(&uacce->mutex);
|
|
if (!uacce_queue_is_valid(q))
|
|
goto out_unlock;
|
|
|
|
switch (cmd) {
|
|
case UACCE_CMD_START_Q:
|
|
ret = uacce_start_queue(q);
|
|
break;
|
|
case UACCE_CMD_PUT_Q:
|
|
ret = uacce_put_queue(q);
|
|
break;
|
|
default:
|
|
if (uacce->ops->ioctl)
|
|
ret = uacce->ops->ioctl(q, cmd, arg);
|
|
else
|
|
ret = -EINVAL;
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&uacce->mutex);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
static long uacce_fops_compat_ioctl(struct file *filep,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
arg = (unsigned long)compat_ptr(arg);
|
|
|
|
return uacce_fops_unl_ioctl(filep, cmd, arg);
|
|
}
|
|
#endif
|
|
|
|
static int uacce_bind_queue(struct uacce_device *uacce, struct uacce_queue *q)
|
|
{
|
|
u32 pasid;
|
|
struct iommu_sva *handle;
|
|
|
|
if (!(uacce->flags & UACCE_DEV_SVA))
|
|
return 0;
|
|
|
|
handle = iommu_sva_bind_device(uacce->parent, current->mm);
|
|
if (IS_ERR(handle))
|
|
return PTR_ERR(handle);
|
|
|
|
pasid = iommu_sva_get_pasid(handle);
|
|
if (pasid == IOMMU_PASID_INVALID) {
|
|
iommu_sva_unbind_device(handle);
|
|
return -ENODEV;
|
|
}
|
|
|
|
q->handle = handle;
|
|
q->pasid = pasid;
|
|
return 0;
|
|
}
|
|
|
|
static void uacce_unbind_queue(struct uacce_queue *q)
|
|
{
|
|
if (!q->handle)
|
|
return;
|
|
iommu_sva_unbind_device(q->handle);
|
|
q->handle = NULL;
|
|
}
|
|
|
|
static int uacce_fops_open(struct inode *inode, struct file *filep)
|
|
{
|
|
struct uacce_device *uacce;
|
|
struct uacce_queue *q;
|
|
int ret;
|
|
|
|
uacce = xa_load(&uacce_xa, iminor(inode));
|
|
if (!uacce)
|
|
return -ENODEV;
|
|
|
|
q = kzalloc(sizeof(struct uacce_queue), GFP_KERNEL);
|
|
if (!q)
|
|
return -ENOMEM;
|
|
|
|
mutex_lock(&uacce->mutex);
|
|
|
|
if (!uacce->parent) {
|
|
ret = -EINVAL;
|
|
goto out_with_mem;
|
|
}
|
|
|
|
ret = uacce_bind_queue(uacce, q);
|
|
if (ret)
|
|
goto out_with_mem;
|
|
|
|
q->uacce = uacce;
|
|
|
|
if (uacce->ops->get_queue) {
|
|
ret = uacce->ops->get_queue(uacce, q->pasid, q);
|
|
if (ret < 0)
|
|
goto out_with_bond;
|
|
}
|
|
|
|
init_waitqueue_head(&q->wait);
|
|
filep->private_data = q;
|
|
q->state = UACCE_Q_INIT;
|
|
q->mapping = filep->f_mapping;
|
|
mutex_init(&q->mutex);
|
|
list_add(&q->list, &uacce->queues);
|
|
mutex_unlock(&uacce->mutex);
|
|
|
|
return 0;
|
|
|
|
out_with_bond:
|
|
uacce_unbind_queue(q);
|
|
out_with_mem:
|
|
kfree(q);
|
|
mutex_unlock(&uacce->mutex);
|
|
return ret;
|
|
}
|
|
|
|
static int uacce_fops_release(struct inode *inode, struct file *filep)
|
|
{
|
|
struct uacce_queue *q = filep->private_data;
|
|
struct uacce_device *uacce = q->uacce;
|
|
|
|
mutex_lock(&uacce->mutex);
|
|
uacce_put_queue(q);
|
|
uacce_unbind_queue(q);
|
|
list_del(&q->list);
|
|
mutex_unlock(&uacce->mutex);
|
|
kfree(q);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void uacce_vma_close(struct vm_area_struct *vma)
|
|
{
|
|
struct uacce_queue *q = vma->vm_private_data;
|
|
|
|
if (vma->vm_pgoff < UACCE_MAX_REGION) {
|
|
struct uacce_qfile_region *qfr = q->qfrs[vma->vm_pgoff];
|
|
|
|
mutex_lock(&q->mutex);
|
|
q->qfrs[vma->vm_pgoff] = NULL;
|
|
mutex_unlock(&q->mutex);
|
|
kfree(qfr);
|
|
}
|
|
}
|
|
|
|
static const struct vm_operations_struct uacce_vm_ops = {
|
|
.close = uacce_vma_close,
|
|
};
|
|
|
|
static int uacce_fops_mmap(struct file *filep, struct vm_area_struct *vma)
|
|
{
|
|
struct uacce_queue *q = filep->private_data;
|
|
struct uacce_device *uacce = q->uacce;
|
|
struct uacce_qfile_region *qfr;
|
|
enum uacce_qfrt type = UACCE_MAX_REGION;
|
|
int ret = 0;
|
|
|
|
if (vma->vm_pgoff < UACCE_MAX_REGION)
|
|
type = vma->vm_pgoff;
|
|
else
|
|
return -EINVAL;
|
|
|
|
qfr = kzalloc(sizeof(*qfr), GFP_KERNEL);
|
|
if (!qfr)
|
|
return -ENOMEM;
|
|
|
|
vm_flags_set(vma, VM_DONTCOPY | VM_DONTEXPAND | VM_WIPEONFORK);
|
|
vma->vm_ops = &uacce_vm_ops;
|
|
vma->vm_private_data = q;
|
|
qfr->type = type;
|
|
|
|
mutex_lock(&q->mutex);
|
|
if (!uacce_queue_is_valid(q)) {
|
|
ret = -ENXIO;
|
|
goto out_with_lock;
|
|
}
|
|
|
|
if (q->qfrs[type]) {
|
|
ret = -EEXIST;
|
|
goto out_with_lock;
|
|
}
|
|
|
|
switch (type) {
|
|
case UACCE_QFRT_MMIO:
|
|
case UACCE_QFRT_DUS:
|
|
if (!uacce->ops->mmap) {
|
|
ret = -EINVAL;
|
|
goto out_with_lock;
|
|
}
|
|
|
|
ret = uacce->ops->mmap(q, vma, qfr);
|
|
if (ret)
|
|
goto out_with_lock;
|
|
break;
|
|
|
|
default:
|
|
ret = -EINVAL;
|
|
goto out_with_lock;
|
|
}
|
|
|
|
q->qfrs[type] = qfr;
|
|
mutex_unlock(&q->mutex);
|
|
|
|
return ret;
|
|
|
|
out_with_lock:
|
|
mutex_unlock(&q->mutex);
|
|
kfree(qfr);
|
|
return ret;
|
|
}
|
|
|
|
static __poll_t uacce_fops_poll(struct file *file, poll_table *wait)
|
|
{
|
|
struct uacce_queue *q = file->private_data;
|
|
struct uacce_device *uacce = q->uacce;
|
|
__poll_t ret = 0;
|
|
|
|
mutex_lock(&q->mutex);
|
|
if (!uacce_queue_is_valid(q))
|
|
goto out_unlock;
|
|
|
|
poll_wait(file, &q->wait, wait);
|
|
|
|
if (uacce->ops->is_q_updated && uacce->ops->is_q_updated(q))
|
|
ret = EPOLLIN | EPOLLRDNORM;
|
|
|
|
out_unlock:
|
|
mutex_unlock(&q->mutex);
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations uacce_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = uacce_fops_open,
|
|
.release = uacce_fops_release,
|
|
.unlocked_ioctl = uacce_fops_unl_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = uacce_fops_compat_ioctl,
|
|
#endif
|
|
.mmap = uacce_fops_mmap,
|
|
.poll = uacce_fops_poll,
|
|
};
|
|
|
|
#define to_uacce_device(dev) container_of(dev, struct uacce_device, dev)
|
|
|
|
static ssize_t api_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%s\n", uacce->api_ver);
|
|
}
|
|
|
|
static ssize_t flags_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%u\n", uacce->flags);
|
|
}
|
|
|
|
static ssize_t available_instances_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
if (!uacce->ops->get_available_instances)
|
|
return -ENODEV;
|
|
|
|
return sysfs_emit(buf, "%d\n",
|
|
uacce->ops->get_available_instances(uacce));
|
|
}
|
|
|
|
static ssize_t algorithms_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%s\n", uacce->algs);
|
|
}
|
|
|
|
static ssize_t region_mmio_size_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%lu\n",
|
|
uacce->qf_pg_num[UACCE_QFRT_MMIO] << PAGE_SHIFT);
|
|
}
|
|
|
|
static ssize_t region_dus_size_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%lu\n",
|
|
uacce->qf_pg_num[UACCE_QFRT_DUS] << PAGE_SHIFT);
|
|
}
|
|
|
|
static ssize_t isolate_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
return sysfs_emit(buf, "%d\n", uacce->ops->get_isolate_state(uacce));
|
|
}
|
|
|
|
static ssize_t isolate_strategy_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
u32 val;
|
|
|
|
val = uacce->ops->isolate_err_threshold_read(uacce);
|
|
|
|
return sysfs_emit(buf, "%u\n", val);
|
|
}
|
|
|
|
static ssize_t isolate_strategy_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
unsigned long val;
|
|
int ret;
|
|
|
|
if (kstrtoul(buf, 0, &val) < 0)
|
|
return -EINVAL;
|
|
|
|
if (val > UACCE_MAX_ERR_THRESHOLD)
|
|
return -EINVAL;
|
|
|
|
ret = uacce->ops->isolate_err_threshold_write(uacce, val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 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[] = {
|
|
&dev_attr_api.attr,
|
|
&dev_attr_flags.attr,
|
|
&dev_attr_available_instances.attr,
|
|
&dev_attr_algorithms.attr,
|
|
&dev_attr_region_mmio_size.attr,
|
|
&dev_attr_region_dus_size.attr,
|
|
&dev_attr_isolate.attr,
|
|
&dev_attr_isolate_strategy.attr,
|
|
NULL,
|
|
};
|
|
|
|
static umode_t uacce_dev_is_visible(struct kobject *kobj,
|
|
struct attribute *attr, int n)
|
|
{
|
|
struct device *dev = kobj_to_dev(kobj);
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
if (((attr == &dev_attr_region_mmio_size.attr) &&
|
|
(!uacce->qf_pg_num[UACCE_QFRT_MMIO])) ||
|
|
((attr == &dev_attr_region_dus_size.attr) &&
|
|
(!uacce->qf_pg_num[UACCE_QFRT_DUS])))
|
|
return 0;
|
|
|
|
if (attr == &dev_attr_isolate_strategy.attr &&
|
|
(!uacce->ops->isolate_err_threshold_read &&
|
|
!uacce->ops->isolate_err_threshold_write))
|
|
return 0;
|
|
|
|
if (attr == &dev_attr_isolate.attr && !uacce->ops->get_isolate_state)
|
|
return 0;
|
|
|
|
return attr->mode;
|
|
}
|
|
|
|
static struct attribute_group uacce_dev_group = {
|
|
.is_visible = uacce_dev_is_visible,
|
|
.attrs = uacce_dev_attrs,
|
|
};
|
|
|
|
__ATTRIBUTE_GROUPS(uacce_dev);
|
|
|
|
static void uacce_release(struct device *dev)
|
|
{
|
|
struct uacce_device *uacce = to_uacce_device(dev);
|
|
|
|
kfree(uacce);
|
|
}
|
|
|
|
static unsigned int uacce_enable_sva(struct device *parent, unsigned int flags)
|
|
{
|
|
int ret;
|
|
|
|
if (!(flags & UACCE_DEV_SVA))
|
|
return flags;
|
|
|
|
flags &= ~UACCE_DEV_SVA;
|
|
|
|
ret = iommu_dev_enable_feature(parent, IOMMU_DEV_FEAT_IOPF);
|
|
if (ret) {
|
|
dev_err(parent, "failed to enable IOPF feature! ret = %pe\n", ERR_PTR(ret));
|
|
return flags;
|
|
}
|
|
|
|
ret = iommu_dev_enable_feature(parent, IOMMU_DEV_FEAT_SVA);
|
|
if (ret) {
|
|
dev_err(parent, "failed to enable SVA feature! ret = %pe\n", ERR_PTR(ret));
|
|
iommu_dev_disable_feature(parent, IOMMU_DEV_FEAT_IOPF);
|
|
return flags;
|
|
}
|
|
|
|
return flags | UACCE_DEV_SVA;
|
|
}
|
|
|
|
static void uacce_disable_sva(struct uacce_device *uacce)
|
|
{
|
|
if (!(uacce->flags & UACCE_DEV_SVA))
|
|
return;
|
|
|
|
iommu_dev_disable_feature(uacce->parent, IOMMU_DEV_FEAT_SVA);
|
|
iommu_dev_disable_feature(uacce->parent, IOMMU_DEV_FEAT_IOPF);
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
unsigned int flags = interface->flags;
|
|
struct uacce_device *uacce;
|
|
int ret;
|
|
|
|
uacce = kzalloc(sizeof(struct uacce_device), GFP_KERNEL);
|
|
if (!uacce)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
flags = uacce_enable_sva(parent, flags);
|
|
|
|
uacce->parent = parent;
|
|
uacce->flags = flags;
|
|
uacce->ops = interface->ops;
|
|
|
|
ret = xa_alloc(&uacce_xa, &uacce->dev_id, uacce, xa_limit_32b,
|
|
GFP_KERNEL);
|
|
if (ret < 0)
|
|
goto err_with_uacce;
|
|
|
|
INIT_LIST_HEAD(&uacce->queues);
|
|
mutex_init(&uacce->mutex);
|
|
device_initialize(&uacce->dev);
|
|
uacce->dev.devt = MKDEV(MAJOR(uacce_devt), uacce->dev_id);
|
|
uacce->dev.class = &uacce_class;
|
|
uacce->dev.groups = uacce_dev_groups;
|
|
uacce->dev.parent = uacce->parent;
|
|
uacce->dev.release = uacce_release;
|
|
dev_set_name(&uacce->dev, "%s-%d", interface->name, uacce->dev_id);
|
|
|
|
return uacce;
|
|
|
|
err_with_uacce:
|
|
uacce_disable_sva(uacce);
|
|
kfree(uacce);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_GPL(uacce_alloc);
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
if (!uacce)
|
|
return -ENODEV;
|
|
|
|
uacce->cdev = cdev_alloc();
|
|
if (!uacce->cdev)
|
|
return -ENOMEM;
|
|
|
|
uacce->cdev->ops = &uacce_fops;
|
|
uacce->cdev->owner = THIS_MODULE;
|
|
|
|
return cdev_device_add(uacce->cdev, &uacce->dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(uacce_register);
|
|
|
|
/**
|
|
* uacce_remove() - remove the accelerator
|
|
* @uacce: the accelerator to remove
|
|
*/
|
|
void uacce_remove(struct uacce_device *uacce)
|
|
{
|
|
struct uacce_queue *q, *next_q;
|
|
|
|
if (!uacce)
|
|
return;
|
|
|
|
/*
|
|
* uacce_fops_open() may be running concurrently, even after we remove
|
|
* the cdev. Holding uacce->mutex ensures that open() does not obtain a
|
|
* removed uacce device.
|
|
*/
|
|
mutex_lock(&uacce->mutex);
|
|
/* ensure no open queue remains */
|
|
list_for_each_entry_safe(q, next_q, &uacce->queues, list) {
|
|
/*
|
|
* Taking q->mutex ensures that fops do not use the defunct
|
|
* uacce->ops after the queue is disabled.
|
|
*/
|
|
mutex_lock(&q->mutex);
|
|
uacce_put_queue(q);
|
|
mutex_unlock(&q->mutex);
|
|
uacce_unbind_queue(q);
|
|
|
|
/*
|
|
* unmap remaining mapping from user space, preventing user still
|
|
* access the mmaped area while parent device is already removed
|
|
*/
|
|
unmap_mapping_range(q->mapping, 0, 0, 1);
|
|
}
|
|
|
|
/* disable sva now since no opened queues */
|
|
uacce_disable_sva(uacce);
|
|
|
|
if (uacce->cdev)
|
|
cdev_device_del(uacce->cdev, &uacce->dev);
|
|
xa_erase(&uacce_xa, uacce->dev_id);
|
|
/*
|
|
* uacce exists as long as there are open fds, but ops will be freed
|
|
* now. Ensure that bugs cause NULL deref rather than use-after-free.
|
|
*/
|
|
uacce->ops = NULL;
|
|
uacce->parent = NULL;
|
|
mutex_unlock(&uacce->mutex);
|
|
put_device(&uacce->dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(uacce_remove);
|
|
|
|
static int __init uacce_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = class_register(&uacce_class);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = alloc_chrdev_region(&uacce_devt, 0, MINORMASK, UACCE_NAME);
|
|
if (ret)
|
|
class_unregister(&uacce_class);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static __exit void uacce_exit(void)
|
|
{
|
|
unregister_chrdev_region(uacce_devt, MINORMASK);
|
|
class_unregister(&uacce_class);
|
|
}
|
|
|
|
subsys_initcall(uacce_init);
|
|
module_exit(uacce_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("HiSilicon Tech. Co., Ltd.");
|
|
MODULE_DESCRIPTION("Accelerator interface for Userland applications");
|