1 files changed, 230 insertions, 0 deletions

diff --git a/drivers/misc/ocxl/context.c b/drivers/misc/ocxl/context.c
new file mode 100644
index 000000000000..b34b836f924c
--- /dev/null
+++ b/drivers/misc/ocxl/context.c
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: GPL-2.0+
+// Copyright 2017 IBM Corp.
+#include <linux/sched/mm.h>
+#include "ocxl_internal.h"
+
+struct ocxl_context *ocxl_context_alloc(void)
+{
+        return kzalloc(sizeof(struct ocxl_context), GFP_KERNEL);
+}
+
+int ocxl_context_init(struct ocxl_context *ctx, struct ocxl_afu *afu,
+                struct address_space *mapping)
+{
+        int pasid;
+
+        ctx->afu = afu;
+        mutex_lock(&afu->contexts_lock);
+        pasid = idr_alloc(&afu->contexts_idr, ctx, afu->pasid_base,
+                        afu->pasid_base + afu->pasid_max, GFP_KERNEL);
+        if (pasid < 0) {
+                mutex_unlock(&afu->contexts_lock);
+                return pasid;
+        }
+        afu->pasid_count++;
+        mutex_unlock(&afu->contexts_lock);
+
+        ctx->pasid = pasid;
+        ctx->status = OPENED;
+        mutex_init(&ctx->status_mutex);
+        ctx->mapping = mapping;
+        mutex_init(&ctx->mapping_lock);
+        init_waitqueue_head(&ctx->events_wq);
+        mutex_init(&ctx->xsl_error_lock);
+        /*
+         * Keep a reference on the AFU to make sure it's valid for the
+         * duration of the life of the context
+         */
+        ocxl_afu_get(afu);
+        return 0;
+}
+
+/*
+ * Callback for when a translation fault triggers an error
+ * data:        a pointer to the context which triggered the fault
+ * addr:        the address that triggered the error
+ * dsisr:       the value of the PPC64 dsisr register
+ */
+static void xsl_fault_error(void *data, u64 addr, u64 dsisr)
+{
+        struct ocxl_context *ctx = (struct ocxl_context *) data;
+
+        mutex_lock(&ctx->xsl_error_lock);
+        ctx->xsl_error.addr = addr;
+        ctx->xsl_error.dsisr = dsisr;
+        ctx->xsl_error.count++;
+        mutex_unlock(&ctx->xsl_error_lock);
+
+        wake_up_all(&ctx->events_wq);
+}
+
+int ocxl_context_attach(struct ocxl_context *ctx, u64 amr)
+{
+        int rc;
+
+        mutex_lock(&ctx->status_mutex);
+        if (ctx->status != OPENED) {
+                rc = -EIO;
+                goto out;
+        }
+
+        rc = ocxl_link_add_pe(ctx->afu->fn->link, ctx->pasid,
+                        current->mm->context.id, 0, amr, current->mm,
+                        xsl_fault_error, ctx);
+        if (rc)
+                goto out;
+
+        ctx->status = ATTACHED;
+out:
+        mutex_unlock(&ctx->status_mutex);
+        return rc;
+}
+
+static int map_pp_mmio(struct vm_area_struct *vma, unsigned long address,
+                u64 offset, struct ocxl_context *ctx)
+{
+        u64 pp_mmio_addr;
+        int pasid_off;
+
+        if (offset >= ctx->afu->config.pp_mmio_stride)
+                return VM_FAULT_SIGBUS;
+
+        mutex_lock(&ctx->status_mutex);
+        if (ctx->status != ATTACHED) {
+                mutex_unlock(&ctx->status_mutex);
+                pr_debug("%s: Context not attached, failing mmio mmap\n",
+                        __func__);
+                return VM_FAULT_SIGBUS;
+        }
+
+        pasid_off = ctx->pasid - ctx->afu->pasid_base;
+        pp_mmio_addr = ctx->afu->pp_mmio_start +
+                pasid_off * ctx->afu->config.pp_mmio_stride +
+                offset;
+
+        vm_insert_pfn(vma, address, pp_mmio_addr >> PAGE_SHIFT);
+        mutex_unlock(&ctx->status_mutex);
+        return VM_FAULT_NOPAGE;
+}
+
+static int ocxl_mmap_fault(struct vm_fault *vmf)
+{
+        struct vm_area_struct *vma = vmf->vma;
+        struct ocxl_context *ctx = vma->vm_file->private_data;
+        u64 offset;
+        int rc;
+
+        offset = vmf->pgoff << PAGE_SHIFT;
+        pr_debug("%s: pasid %d address 0x%lx offset 0x%llx\n", __func__,
+                ctx->pasid, vmf->address, offset);
+
+        rc = map_pp_mmio(vma, vmf->address, offset, ctx);
+        return rc;
+}
+
+static const struct vm_operations_struct ocxl_vmops = {
+        .fault = ocxl_mmap_fault,
+};
+
+static int check_mmap_mmio(struct ocxl_context *ctx,
+                        struct vm_area_struct *vma)
+{
+        if ((vma_pages(vma) + vma->vm_pgoff) >
+                (ctx->afu->config.pp_mmio_stride >> PAGE_SHIFT))
+                return -EINVAL;
+        return 0;
+}
+
+int ocxl_context_mmap(struct ocxl_context *ctx, struct vm_area_struct *vma)
+{
+        int rc;
+
+        rc = check_mmap_mmio(ctx, vma);
+        if (rc)
+                return rc;
+
+        vma->vm_flags |= VM_IO | VM_PFNMAP;
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        vma->vm_ops = &ocxl_vmops;
+        return 0;
+}
+
+int ocxl_context_detach(struct ocxl_context *ctx)
+{
+        struct pci_dev *dev;
+        int afu_control_pos;
+        enum ocxl_context_status status;
+        int rc;
+
+        mutex_lock(&ctx->status_mutex);
+        status = ctx->status;
+        ctx->status = CLOSED;
+        mutex_unlock(&ctx->status_mutex);
+        if (status != ATTACHED)
+                return 0;
+
+        dev = to_pci_dev(ctx->afu->fn->dev.parent);
+        afu_control_pos = ctx->afu->config.dvsec_afu_control_pos;
+
+        mutex_lock(&ctx->afu->afu_control_lock);
+        rc = ocxl_config_terminate_pasid(dev, afu_control_pos, ctx->pasid);
+        mutex_unlock(&ctx->afu->afu_control_lock);
+        if (rc) {
+                /*
+                 * If we timeout waiting for the AFU to terminate the
+                 * pasid, then it's dangerous to clean up the Process
+                 * Element entry in the SPA, as it may be referenced
+                 * in the future by the AFU. In which case, we would
+                 * checkstop because of an invalid PE access (FIR
+                 * register 2, bit 42). So leave the PE
+                 * defined. Caller shouldn't free the context so that
+                 * PASID remains allocated.
+                 *
+                 * A link reset will be required to cleanup the AFU
+                 * and the SPA.
+                 */
+                if (rc == -EBUSY)
+                        return rc;
+        }
+        rc = ocxl_link_remove_pe(ctx->afu->fn->link, ctx->pasid);
+        if (rc) {
+                dev_warn(&ctx->afu->dev,
+                        "Couldn't remove PE entry cleanly: %d\n", rc);
+        }
+        return 0;
+}
+
+void ocxl_context_detach_all(struct ocxl_afu *afu)
+{
+        struct ocxl_context *ctx;
+        int tmp;
+
+        mutex_lock(&afu->contexts_lock);
+        idr_for_each_entry(&afu->contexts_idr, ctx, tmp) {
+                ocxl_context_detach(ctx);
+                /*
+                 * We are force detaching - remove any active mmio
+                 * mappings so userspace cannot interfere with the
+                 * card if it comes back.  Easiest way to exercise
+                 * this is to unbind and rebind the driver via sysfs
+                 * while it is in use.
+                 */
+                mutex_lock(&ctx->mapping_lock);
+                if (ctx->mapping)
+                        unmap_mapping_range(ctx->mapping, 0, 0, 1);
+                mutex_unlock(&ctx->mapping_lock);
+        }
+        mutex_unlock(&afu->contexts_lock);
+}
+
+void ocxl_context_free(struct ocxl_context *ctx)
+{
+        mutex_lock(&ctx->afu->contexts_lock);
+        ctx->afu->pasid_count--;
+        idr_remove(&ctx->afu->contexts_idr, ctx->pasid);
+        mutex_unlock(&ctx->afu->contexts_lock);
+
+        /* reference to the AFU taken in ocxl_context_init */
+        ocxl_afu_put(ctx->afu);
+        kfree(ctx);
+}