ocxl: Driver code for 'generic' opencapi devices

Add an ocxl driver to handle generic opencapi devices. Of course, it's
not meant to be the only opencapi driver, any device is free to
implement its own. But if a host application only needs basic services
like attaching to an opencapi adapter, have translation faults handled
or allocate AFU interrupts, it should suffice.

The AFU config space must follow the opencapi specification and use
the expected vendor/device ID to be seen by the generic driver.

The driver exposes the device AFUs as a char device in /dev/ocxl/

Note that the driver currently doesn't handle memory attached to the
opencapi device.

Signed-off-by: Frederic Barrat <fbarrat@linux.vnet.ibm.com>
Signed-off-by: Andrew Donnellan <andrew.donnellan@au1.ibm.com>
Signed-off-by: Alastair D'Silva <alastair@d-silva.org>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>

1 files changed, 398 insertions, 0 deletions

diff --git a/drivers/misc/ocxl/file.c b/drivers/misc/ocxl/file.c
new file mode 100644
index 000000000000..6f0befda6a8a
--- /dev/null
+++ b/drivers/misc/ocxl/file.c
@@ -0,0 +1,398 @@
+// SPDX-License-Identifier: GPL-2.0+
+// Copyright 2017 IBM Corp.
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/sched/signal.h>
+#include <linux/uaccess.h>
+#include <uapi/misc/ocxl.h>
+#include "ocxl_internal.h"
+
+
+#define OCXL_NUM_MINORS 256 /* Total to reserve */
+
+static dev_t ocxl_dev;
+static struct class *ocxl_class;
+static struct mutex minors_idr_lock;
+static struct idr minors_idr;
+
+static struct ocxl_afu *find_and_get_afu(dev_t devno)
+{
+        struct ocxl_afu *afu;
+        int afu_minor;
+
+        afu_minor = MINOR(devno);
+        /*
+         * We don't declare an RCU critical section here, as our AFU
+         * is protected by a reference counter on the device. By the time the
+         * minor number of a device is removed from the idr, the ref count of
+         * the device is already at 0, so no user API will access that AFU and
+         * this function can't return it.
+         */
+        afu = idr_find(&minors_idr, afu_minor);
+        if (afu)
+                ocxl_afu_get(afu);
+        return afu;
+}
+
+static int allocate_afu_minor(struct ocxl_afu *afu)
+{
+        int minor;
+
+        mutex_lock(&minors_idr_lock);
+        minor = idr_alloc(&minors_idr, afu, 0, OCXL_NUM_MINORS, GFP_KERNEL);
+        mutex_unlock(&minors_idr_lock);
+        return minor;
+}
+
+static void free_afu_minor(struct ocxl_afu *afu)
+{
+        mutex_lock(&minors_idr_lock);
+        idr_remove(&minors_idr, MINOR(afu->dev.devt));
+        mutex_unlock(&minors_idr_lock);
+}
+
+static int afu_open(struct inode *inode, struct file *file)
+{
+        struct ocxl_afu *afu;
+        struct ocxl_context *ctx;
+        int rc;
+
+        pr_debug("%s for device %x\n", __func__, inode->i_rdev);
+
+        afu = find_and_get_afu(inode->i_rdev);
+        if (!afu)
+                return -ENODEV;
+
+        ctx = ocxl_context_alloc();
+        if (!ctx) {
+                rc = -ENOMEM;
+                goto put_afu;
+        }
+
+        rc = ocxl_context_init(ctx, afu, inode->i_mapping);
+        if (rc)
+                goto put_afu;
+        file->private_data = ctx;
+        ocxl_afu_put(afu);
+        return 0;
+
+put_afu:
+        ocxl_afu_put(afu);
+        return rc;
+}
+
+static long afu_ioctl_attach(struct ocxl_context *ctx,
+                        struct ocxl_ioctl_attach __user *uarg)
+{
+        struct ocxl_ioctl_attach arg;
+        u64 amr = 0;
+        int rc;
+
+        pr_debug("%s for context %d\n", __func__, ctx->pasid);
+
+        if (copy_from_user(&arg, uarg, sizeof(arg)))
+                return -EFAULT;
+
+        /* Make sure reserved fields are not set for forward compatibility */
+        if (arg.reserved1 || arg.reserved2 || arg.reserved3)
+                return -EINVAL;
+
+        amr = arg.amr & mfspr(SPRN_UAMOR);
+        rc = ocxl_context_attach(ctx, amr);
+        return rc;
+}
+
+#define CMD_STR(x) (x == OCXL_IOCTL_ATTACH ? "ATTACH" :                 \
+                        "UNKNOWN")
+
+static long afu_ioctl(struct file *file, unsigned int cmd,
+                unsigned long args)
+{
+        struct ocxl_context *ctx = file->private_data;
+        long rc;
+
+        pr_debug("%s for context %d, command %s\n", __func__, ctx->pasid,
+                CMD_STR(cmd));
+
+        if (ctx->status == CLOSED)
+                return -EIO;
+
+        switch (cmd) {
+        case OCXL_IOCTL_ATTACH:
+                rc = afu_ioctl_attach(ctx,
+                                (struct ocxl_ioctl_attach __user *) args);
+                break;
+
+        default:
+                rc = -EINVAL;
+        }
+        return rc;
+}
+
+static long afu_compat_ioctl(struct file *file, unsigned int cmd,
+                        unsigned long args)
+{
+        return afu_ioctl(file, cmd, args);
+}
+
+static int afu_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct ocxl_context *ctx = file->private_data;
+
+        pr_debug("%s for context %d\n", __func__, ctx->pasid);
+        return ocxl_context_mmap(ctx, vma);
+}
+
+static bool has_xsl_error(struct ocxl_context *ctx)
+{
+        bool ret;
+
+        mutex_lock(&ctx->xsl_error_lock);
+        ret = !!ctx->xsl_error.addr;
+        mutex_unlock(&ctx->xsl_error_lock);
+
+        return ret;
+}
+
+/*
+ * Are there any events pending on the AFU
+ * ctx: The AFU context
+ * Returns: true if there are events pending
+ */
+static bool afu_events_pending(struct ocxl_context *ctx)
+{
+        if (has_xsl_error(ctx))
+                return true;
+        return false;
+}
+
+static unsigned int afu_poll(struct file *file, struct poll_table_struct *wait)
+{
+        struct ocxl_context *ctx = file->private_data;
+        unsigned int mask = 0;
+        bool closed;
+
+        pr_debug("%s for context %d\n", __func__, ctx->pasid);
+
+        poll_wait(file, &ctx->events_wq, wait);
+
+        mutex_lock(&ctx->status_mutex);
+        closed = (ctx->status == CLOSED);
+        mutex_unlock(&ctx->status_mutex);
+
+        if (afu_events_pending(ctx))
+                mask = POLLIN | POLLRDNORM;
+        else if (closed)
+                mask = POLLERR;
+
+        return mask;
+}
+
+/*
+ * Populate the supplied buffer with a single XSL error
+ * ctx: The AFU context to report the error from
+ * header: the event header to populate
+ * buf: The buffer to write the body into (should be at least
+ *      AFU_EVENT_BODY_XSL_ERROR_SIZE)
+ * Return: the amount of buffer that was populated
+ */
+static ssize_t append_xsl_error(struct ocxl_context *ctx,
+                                struct ocxl_kernel_event_header *header,
+                                char __user *buf)
+{
+        struct ocxl_kernel_event_xsl_fault_error body;
+
+        memset(&body, 0, sizeof(body));
+
+        mutex_lock(&ctx->xsl_error_lock);
+        if (!ctx->xsl_error.addr) {
+                mutex_unlock(&ctx->xsl_error_lock);
+                return 0;
+        }
+
+        body.addr = ctx->xsl_error.addr;
+        body.dsisr = ctx->xsl_error.dsisr;
+        body.count = ctx->xsl_error.count;
+
+        ctx->xsl_error.addr = 0;
+        ctx->xsl_error.dsisr = 0;
+        ctx->xsl_error.count = 0;
+
+        mutex_unlock(&ctx->xsl_error_lock);
+
+        header->type = OCXL_AFU_EVENT_XSL_FAULT_ERROR;
+
+        if (copy_to_user(buf, &body, sizeof(body)))
+                return -EFAULT;
+
+        return sizeof(body);
+}
+
+#define AFU_EVENT_BODY_MAX_SIZE sizeof(struct ocxl_kernel_event_xsl_fault_error)
+
+/*
+ * Reports events on the AFU
+ * Format:
+ *      Header (struct ocxl_kernel_event_header)
+ *      Body (struct ocxl_kernel_event_*)
+ *      Header...
+ */
+static ssize_t afu_read(struct file *file, char __user *buf, size_t count,
+                        loff_t *off)
+{
+        struct ocxl_context *ctx = file->private_data;
+        struct ocxl_kernel_event_header header;
+        ssize_t rc;
+        size_t used = 0;
+        DEFINE_WAIT(event_wait);
+
+        memset(&header, 0, sizeof(header));
+
+        /* Require offset to be 0 */
+        if (*off != 0)
+                return -EINVAL;
+
+        if (count < (sizeof(struct ocxl_kernel_event_header) +
+                        AFU_EVENT_BODY_MAX_SIZE))
+                return -EINVAL;
+
+        for (;;) {
+                prepare_to_wait(&ctx->events_wq, &event_wait,
+                                TASK_INTERRUPTIBLE);
+
+                if (afu_events_pending(ctx))
+                        break;
+
+                if (ctx->status == CLOSED)
+                        break;
+
+                if (file->f_flags & O_NONBLOCK) {
+                        finish_wait(&ctx->events_wq, &event_wait);
+                        return -EAGAIN;
+                }
+
+                if (signal_pending(current)) {
+                        finish_wait(&ctx->events_wq, &event_wait);
+                        return -ERESTARTSYS;
+                }
+
+                schedule();
+        }
+
+        finish_wait(&ctx->events_wq, &event_wait);
+
+        if (has_xsl_error(ctx)) {
+                used = append_xsl_error(ctx, &header, buf + sizeof(header));
+                if (used < 0)
+                        return used;
+        }
+
+        if (!afu_events_pending(ctx))
+                header.flags |= OCXL_KERNEL_EVENT_FLAG_LAST;
+
+        if (copy_to_user(buf, &header, sizeof(header)))
+                return -EFAULT;
+
+        used += sizeof(header);
+
+        rc = (ssize_t) used;
+        return rc;
+}
+
+static int afu_release(struct inode *inode, struct file *file)
+{
+        struct ocxl_context *ctx = file->private_data;
+        int rc;
+
+        pr_debug("%s for device %x\n", __func__, inode->i_rdev);
+        rc = ocxl_context_detach(ctx);
+        mutex_lock(&ctx->mapping_lock);
+        ctx->mapping = NULL;
+        mutex_unlock(&ctx->mapping_lock);
+        wake_up_all(&ctx->events_wq);
+        if (rc != -EBUSY)
+                ocxl_context_free(ctx);
+        return 0;
+}
+
+static const struct file_operations ocxl_afu_fops = {
+        .owner          = THIS_MODULE,
+        .open           = afu_open,
+        .unlocked_ioctl = afu_ioctl,
+        .compat_ioctl   = afu_compat_ioctl,
+        .mmap           = afu_mmap,
+        .poll           = afu_poll,
+        .read           = afu_read,
+        .release        = afu_release,
+};
+
+int ocxl_create_cdev(struct ocxl_afu *afu)
+{
+        int rc;
+
+        cdev_init(&afu->cdev, &ocxl_afu_fops);
+        rc = cdev_add(&afu->cdev, afu->dev.devt, 1);
+        if (rc) {
+                dev_err(&afu->dev, "Unable to add afu char device: %d\n", rc);
+                return rc;
+        }
+        return 0;
+}
+
+void ocxl_destroy_cdev(struct ocxl_afu *afu)
+{
+        cdev_del(&afu->cdev);
+}
+
+int ocxl_register_afu(struct ocxl_afu *afu)
+{
+        int minor;
+
+        minor = allocate_afu_minor(afu);
+        if (minor < 0)
+                return minor;
+        afu->dev.devt = MKDEV(MAJOR(ocxl_dev), minor);
+        afu->dev.class = ocxl_class;
+        return device_register(&afu->dev);
+}
+
+void ocxl_unregister_afu(struct ocxl_afu *afu)
+{
+        free_afu_minor(afu);
+}
+
+static char *ocxl_devnode(struct device *dev, umode_t *mode)
+{
+        return kasprintf(GFP_KERNEL, "ocxl/%s", dev_name(dev));
+}
+
+int ocxl_file_init(void)
+{
+        int rc;
+
+        mutex_init(&minors_idr_lock);
+        idr_init(&minors_idr);
+
+        rc = alloc_chrdev_region(&ocxl_dev, 0, OCXL_NUM_MINORS, "ocxl");
+        if (rc) {
+                pr_err("Unable to allocate ocxl major number: %d\n", rc);
+                return rc;
+        }
+
+        ocxl_class = class_create(THIS_MODULE, "ocxl");
+        if (IS_ERR(ocxl_class)) {
+                pr_err("Unable to create ocxl class\n");
+                unregister_chrdev_region(ocxl_dev, OCXL_NUM_MINORS);
+                return PTR_ERR(ocxl_class);
+        }
+
+        ocxl_class->devnode = ocxl_devnode;
+        return 0;
+}
+
+void ocxl_file_exit(void)
+{
+        class_destroy(ocxl_class);
+        unregister_chrdev_region(ocxl_dev, OCXL_NUM_MINORS);
+        idr_destroy(&minors_idr);
+}