Merge branch 'for-4.3/gembird' into for-linus

14 files changed, 946 insertions, 125 deletions

diff --git a/drivers/misc/cxl/Kconfig b/drivers/misc/cxl/Kconfig
index a990b39b4dfb..b6db9ebd52c2 100644
--- a/drivers/misc/cxl/Kconfig
+++ b/drivers/misc/cxl/Kconfig
@@ -7,10 +7,15 @@ config CXL_BASE
         default n
         select PPC_COPRO_BASE
 
+config CXL_KERNEL_API
+        bool
+        default n
+
 config CXL
         tristate "Support for IBM Coherent Accelerators (CXL)"
         depends on PPC_POWERNV && PCI_MSI
         select CXL_BASE
+        select CXL_KERNEL_API
         default m
         help
           Select this option to enable driver support for IBM Coherent
diff --git a/drivers/misc/cxl/Makefile b/drivers/misc/cxl/Makefile
index edb494d3ff27..14e3f8219a11 100644
--- a/drivers/misc/cxl/Makefile
+++ b/drivers/misc/cxl/Makefile
@@ -1,4 +1,6 @@
-cxl-y                           += main.o file.o irq.o fault.o native.o context.o sysfs.o debugfs.o pci.o trace.o
+cxl-y                           += main.o file.o irq.o fault.o native.o
+cxl-y                           += context.o sysfs.o debugfs.o pci.o trace.o
+cxl-y                           += vphb.o api.o
 obj-$(CONFIG_CXL)               += cxl.o
 obj-$(CONFIG_CXL_BASE)          += base.o
 
diff --git a/drivers/misc/cxl/api.c b/drivers/misc/cxl/api.c
new file mode 100644
index 000000000000..729e0851167d
--- /dev/null
+++ b/drivers/misc/cxl/api.c
@@ -0,0 +1,329 @@
+/*
+ * Copyright 2014 IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/anon_inodes.h>
+#include <linux/file.h>
+#include <misc/cxl.h>
+
+#include "cxl.h"
+
+struct cxl_context *cxl_dev_context_init(struct pci_dev *dev)
+{
+        struct cxl_afu *afu;
+        struct cxl_context  *ctx;
+        int rc;
+
+        afu = cxl_pci_to_afu(dev);
+
+        get_device(&afu->dev);
+        ctx = cxl_context_alloc();
+        if (IS_ERR(ctx))
+                return ctx;
+
+        /* Make it a slave context.  We can promote it later? */
+        rc = cxl_context_init(ctx, afu, false, NULL);
+        if (rc) {
+                kfree(ctx);
+                put_device(&afu->dev);
+                return ERR_PTR(-ENOMEM);
+        }
+        cxl_assign_psn_space(ctx);
+
+        return ctx;
+}
+EXPORT_SYMBOL_GPL(cxl_dev_context_init);
+
+struct cxl_context *cxl_get_context(struct pci_dev *dev)
+{
+        return dev->dev.archdata.cxl_ctx;
+}
+EXPORT_SYMBOL_GPL(cxl_get_context);
+
+struct device *cxl_get_phys_dev(struct pci_dev *dev)
+{
+        struct cxl_afu *afu;
+
+        afu = cxl_pci_to_afu(dev);
+
+        return afu->adapter->dev.parent;
+}
+EXPORT_SYMBOL_GPL(cxl_get_phys_dev);
+
+int cxl_release_context(struct cxl_context *ctx)
+{
+        if (ctx->status != CLOSED)
+                return -EBUSY;
+
+        put_device(&ctx->afu->dev);
+
+        cxl_context_free(ctx);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cxl_release_context);
+
+int cxl_allocate_afu_irqs(struct cxl_context *ctx, int num)
+{
+        if (num == 0)
+                num = ctx->afu->pp_irqs;
+        return afu_allocate_irqs(ctx, num);
+}
+EXPORT_SYMBOL_GPL(cxl_allocate_afu_irqs);
+
+void cxl_free_afu_irqs(struct cxl_context *ctx)
+{
+        cxl_release_irq_ranges(&ctx->irqs, ctx->afu->adapter);
+}
+EXPORT_SYMBOL_GPL(cxl_free_afu_irqs);
+
+static irq_hw_number_t cxl_find_afu_irq(struct cxl_context *ctx, int num)
+{
+        __u16 range;
+        int r;
+
+        WARN_ON(num == 0);
+
+        for (r = 0; r < CXL_IRQ_RANGES; r++) {
+                range = ctx->irqs.range[r];
+                if (num < range) {
+                        return ctx->irqs.offset[r] + num;
+                }
+                num -= range;
+        }
+        return 0;
+}
+
+int cxl_map_afu_irq(struct cxl_context *ctx, int num,
+                    irq_handler_t handler, void *cookie, char *name)
+{
+        irq_hw_number_t hwirq;
+
+        /*
+         * Find interrupt we are to register.
+         */
+        hwirq = cxl_find_afu_irq(ctx, num);
+        if (!hwirq)
+                return -ENOENT;
+
+        return cxl_map_irq(ctx->afu->adapter, hwirq, handler, cookie, name);
+}
+EXPORT_SYMBOL_GPL(cxl_map_afu_irq);
+
+void cxl_unmap_afu_irq(struct cxl_context *ctx, int num, void *cookie)
+{
+        irq_hw_number_t hwirq;
+        unsigned int virq;
+
+        hwirq = cxl_find_afu_irq(ctx, num);
+        if (!hwirq)
+                return;
+
+        virq = irq_find_mapping(NULL, hwirq);
+        if (virq)
+                cxl_unmap_irq(virq, cookie);
+}
+EXPORT_SYMBOL_GPL(cxl_unmap_afu_irq);
+
+/*
+ * Start a context
+ * Code here similar to afu_ioctl_start_work().
+ */
+int cxl_start_context(struct cxl_context *ctx, u64 wed,
+                      struct task_struct *task)
+{
+        int rc = 0;
+        bool kernel = true;
+
+        pr_devel("%s: pe: %i\n", __func__, ctx->pe);
+
+        mutex_lock(&ctx->status_mutex);
+        if (ctx->status == STARTED)
+                goto out; /* already started */
+
+        if (task) {
+                ctx->pid = get_task_pid(task, PIDTYPE_PID);
+                get_pid(ctx->pid);
+                kernel = false;
+        }
+
+        cxl_ctx_get();
+
+        if ((rc = cxl_attach_process(ctx, kernel, wed , 0))) {
+                put_pid(ctx->pid);
+                cxl_ctx_put();
+                goto out;
+        }
+
+        ctx->status = STARTED;
+out:
+        mutex_unlock(&ctx->status_mutex);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(cxl_start_context);
+
+int cxl_process_element(struct cxl_context *ctx)
+{
+        return ctx->pe;
+}
+EXPORT_SYMBOL_GPL(cxl_process_element);
+
+/* Stop a context.  Returns 0 on success, otherwise -Errno */
+int cxl_stop_context(struct cxl_context *ctx)
+{
+        return __detach_context(ctx);
+}
+EXPORT_SYMBOL_GPL(cxl_stop_context);
+
+void cxl_set_master(struct cxl_context *ctx)
+{
+        ctx->master = true;
+        cxl_assign_psn_space(ctx);
+}
+EXPORT_SYMBOL_GPL(cxl_set_master);
+
+/* wrappers around afu_* file ops which are EXPORTED */
+int cxl_fd_open(struct inode *inode, struct file *file)
+{
+        return afu_open(inode, file);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_open);
+int cxl_fd_release(struct inode *inode, struct file *file)
+{
+        return afu_release(inode, file);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_release);
+long cxl_fd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        return afu_ioctl(file, cmd, arg);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_ioctl);
+int cxl_fd_mmap(struct file *file, struct vm_area_struct *vm)
+{
+        return afu_mmap(file, vm);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_mmap);
+unsigned int cxl_fd_poll(struct file *file, struct poll_table_struct *poll)
+{
+        return afu_poll(file, poll);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_poll);
+ssize_t cxl_fd_read(struct file *file, char __user *buf, size_t count,
+                        loff_t *off)
+{
+        return afu_read(file, buf, count, off);
+}
+EXPORT_SYMBOL_GPL(cxl_fd_read);
+
+#define PATCH_FOPS(NAME) if (!fops->NAME) fops->NAME = afu_fops.NAME
+
+/* Get a struct file and fd for a context and attach the ops */
+struct file *cxl_get_fd(struct cxl_context *ctx, struct file_operations *fops,
+                        int *fd)
+{
+        struct file *file;
+        int rc, flags, fdtmp;
+
+        flags = O_RDWR | O_CLOEXEC;
+
+        /* This code is similar to anon_inode_getfd() */
+        rc = get_unused_fd_flags(flags);
+        if (rc < 0)
+                return ERR_PTR(rc);
+        fdtmp = rc;
+
+        /*
+         * Patch the file ops.  Needs to be careful that this is rentrant safe.
+         */
+        if (fops) {
+                PATCH_FOPS(open);
+                PATCH_FOPS(poll);
+                PATCH_FOPS(read);
+                PATCH_FOPS(release);
+                PATCH_FOPS(unlocked_ioctl);
+                PATCH_FOPS(compat_ioctl);
+                PATCH_FOPS(mmap);
+        } else /* use default ops */
+                fops = (struct file_operations *)&afu_fops;
+
+        file = anon_inode_getfile("cxl", fops, ctx, flags);
+        if (IS_ERR(file))
+                put_unused_fd(fdtmp);
+        *fd = fdtmp;
+        return file;
+}
+EXPORT_SYMBOL_GPL(cxl_get_fd);
+
+struct cxl_context *cxl_fops_get_context(struct file *file)
+{
+        return file->private_data;
+}
+EXPORT_SYMBOL_GPL(cxl_fops_get_context);
+
+int cxl_start_work(struct cxl_context *ctx,
+                   struct cxl_ioctl_start_work *work)
+{
+        int rc;
+
+        /* code taken from afu_ioctl_start_work */
+        if (!(work->flags & CXL_START_WORK_NUM_IRQS))
+                work->num_interrupts = ctx->afu->pp_irqs;
+        else if ((work->num_interrupts < ctx->afu->pp_irqs) ||
+                 (work->num_interrupts > ctx->afu->irqs_max)) {
+                return -EINVAL;
+        }
+
+        rc = afu_register_irqs(ctx, work->num_interrupts);
+        if (rc)
+                return rc;
+
+        rc = cxl_start_context(ctx, work->work_element_descriptor, current);
+        if (rc < 0) {
+                afu_release_irqs(ctx, ctx);
+                return rc;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cxl_start_work);
+
+void __iomem *cxl_psa_map(struct cxl_context *ctx)
+{
+        struct cxl_afu *afu = ctx->afu;
+        int rc;
+
+        rc = cxl_afu_check_and_enable(afu);
+        if (rc)
+                return NULL;
+
+        pr_devel("%s: psn_phys%llx size:%llx\n",
+                 __func__, afu->psn_phys, afu->adapter->ps_size);
+        return ioremap(ctx->psn_phys, ctx->psn_size);
+}
+EXPORT_SYMBOL_GPL(cxl_psa_map);
+
+void cxl_psa_unmap(void __iomem *addr)
+{
+        iounmap(addr);
+}
+EXPORT_SYMBOL_GPL(cxl_psa_unmap);
+
+int cxl_afu_reset(struct cxl_context *ctx)
+{
+        struct cxl_afu *afu = ctx->afu;
+        int rc;
+
+        rc = __cxl_afu_reset(afu);
+        if (rc)
+                return rc;
+
+        return cxl_afu_check_and_enable(afu);
+}
+EXPORT_SYMBOL_GPL(cxl_afu_reset);
diff --git a/drivers/misc/cxl/base.c b/drivers/misc/cxl/base.c
index 0654ad83675e..a9f0dd3255a2 100644
--- a/drivers/misc/cxl/base.c
+++ b/drivers/misc/cxl/base.c
@@ -10,7 +10,7 @@
 #include <linux/module.h>
 #include <linux/rcupdate.h>
 #include <asm/errno.h>
-#include <misc/cxl.h>
+#include <misc/cxl-base.h>
 #include "cxl.h"
 
 /* protected by rcu */
diff --git a/drivers/misc/cxl/context.c b/drivers/misc/cxl/context.c
index d1b55fe62817..1287148629c0 100644
--- a/drivers/misc/cxl/context.c
+++ b/drivers/misc/cxl/context.c
@@ -113,11 +113,11 @@ static int cxl_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 
         if (ctx->afu->current_mode == CXL_MODE_DEDICATED) {
                 area = ctx->afu->psn_phys;
-                if (offset > ctx->afu->adapter->ps_size)
+                if (offset >= ctx->afu->adapter->ps_size)
                         return VM_FAULT_SIGBUS;
         } else {
                 area = ctx->psn_phys;
-                if (offset > ctx->psn_size)
+                if (offset >= ctx->psn_size)
                         return VM_FAULT_SIGBUS;
         }
 
@@ -145,8 +145,16 @@ static const struct vm_operations_struct cxl_mmap_vmops = {
  */
 int cxl_context_iomap(struct cxl_context *ctx, struct vm_area_struct *vma)
 {
+        u64 start = vma->vm_pgoff << PAGE_SHIFT;
         u64 len = vma->vm_end - vma->vm_start;
-        len = min(len, ctx->psn_size);
+
+        if (ctx->afu->current_mode == CXL_MODE_DEDICATED) {
+                if (start + len > ctx->afu->adapter->ps_size)
+                        return -EINVAL;
+        } else {
+                if (start + len > ctx->psn_size)
+                        return -EINVAL;
+        }
 
         if (ctx->afu->current_mode != CXL_MODE_DEDICATED) {
                 /* make sure there is a valid per process space for this AFU */
@@ -174,7 +182,7 @@ int cxl_context_iomap(struct cxl_context *ctx, struct vm_area_struct *vma)
  * return until all outstanding interrupts for this context have completed. The
  * hardware should no longer access *ctx after this has returned.
  */
-static void __detach_context(struct cxl_context *ctx)
+int __detach_context(struct cxl_context *ctx)
 {
         enum cxl_context_status status;
 
@@ -183,12 +191,13 @@ static void __detach_context(struct cxl_context *ctx)
         ctx->status = CLOSED;
         mutex_unlock(&ctx->status_mutex);
         if (status != STARTED)
-                return;
+                return -EBUSY;
 
         WARN_ON(cxl_detach_process(ctx));
-        afu_release_irqs(ctx);
         flush_work(&ctx->fault_work); /* Only needed for dedicated process */
-        wake_up_all(&ctx->wq);
+        put_pid(ctx->pid);
+        cxl_ctx_put();
+        return 0;
 }
 
 /*
@@ -199,7 +208,14 @@ static void __detach_context(struct cxl_context *ctx)
  */
 void cxl_context_detach(struct cxl_context *ctx)
 {
-        __detach_context(ctx);
+        int rc;
+
+        rc = __detach_context(ctx);
+        if (rc)
+                return;
+
+        afu_release_irqs(ctx, ctx);
+        wake_up_all(&ctx->wq);
 }
 
 /*
@@ -216,7 +232,7 @@ void cxl_context_detach_all(struct cxl_afu *afu)
                  * Anything done in here needs to be setup before the IDR is
                  * created and torn down after the IDR removed
                  */
-                __detach_context(ctx);
+                cxl_context_detach(ctx);
 
                 /*
                  * We are force detaching - remove any active PSA mappings so
@@ -232,16 +248,20 @@ void cxl_context_detach_all(struct cxl_afu *afu)
         mutex_unlock(&afu->contexts_lock);
 }
 
-void cxl_context_free(struct cxl_context *ctx)
+static void reclaim_ctx(struct rcu_head *rcu)
 {
-        mutex_lock(&ctx->afu->contexts_lock);
-        idr_remove(&ctx->afu->contexts_idr, ctx->pe);
-        mutex_unlock(&ctx->afu->contexts_lock);
-        synchronize_rcu();
+        struct cxl_context *ctx = container_of(rcu, struct cxl_context, rcu);
 
         free_page((u64)ctx->sstp);
         ctx->sstp = NULL;
 
-        put_pid(ctx->pid);
         kfree(ctx);
 }
+
+void cxl_context_free(struct cxl_context *ctx)
+{
+        mutex_lock(&ctx->afu->contexts_lock);
+        idr_remove(&ctx->afu->contexts_idr, ctx->pe);
+        mutex_unlock(&ctx->afu->contexts_lock);
+        call_rcu(&ctx->rcu, reclaim_ctx);
+}
diff --git a/drivers/misc/cxl/cxl.h b/drivers/misc/cxl/cxl.h
index a1cee4767ec6..4fd66cabde1e 100644
--- a/drivers/misc/cxl/cxl.h
+++ b/drivers/misc/cxl/cxl.h
@@ -18,10 +18,11 @@
 #include <linux/pid.h>
 #include <linux/io.h>
 #include <linux/pci.h>
+#include <linux/fs.h>
 #include <asm/cputable.h>
 #include <asm/mmu.h>
 #include <asm/reg.h>
-#include <misc/cxl.h>
+#include <misc/cxl-base.h>
 
 #include <uapi/misc/cxl.h>
 
@@ -315,8 +316,6 @@ static const cxl_p2n_reg_t CXL_PSL_WED_An     = {0x0A0};
 #define CXL_MAX_SLICES 4
 #define MAX_AFU_MMIO_REGS 3
 
-#define CXL_MODE_DEDICATED   0x1
-#define CXL_MODE_DIRECTED    0x2
 #define CXL_MODE_TIME_SLICED 0x4
 #define CXL_SUPPORTED_MODES (CXL_MODE_DEDICATED | CXL_MODE_DIRECTED)
 
@@ -362,6 +361,10 @@ struct cxl_afu {
         struct mutex spa_mutex;
         spinlock_t afu_cntl_lock;
 
+        /* AFU error buffer fields and bin attribute for sysfs */
+        u64 eb_len, eb_offset;
+        struct bin_attribute attr_eb;
+
         /*
          * Only the first part of the SPA is used for the process element
          * linked list. The only other part that software needs to worry about
@@ -375,6 +378,9 @@ struct cxl_afu {
         int spa_max_procs;
         unsigned int psl_virq;
 
+        /* pointer to the vphb */
+        struct pci_controller *phb;
+
         int pp_irqs;
         int irqs_max;
         int num_procs;
@@ -455,6 +461,8 @@ struct cxl_context {
         bool pending_irq;
         bool pending_fault;
         bool pending_afu_err;
+
+        struct rcu_head rcu;
 };
 
 struct cxl {
@@ -563,6 +571,9 @@ static inline void __iomem *_cxl_p2n_addr(struct cxl_afu *afu, cxl_p2n_reg_t reg
 u16 cxl_afu_cr_read16(struct cxl_afu *afu, int cr, u64 off);
 u8 cxl_afu_cr_read8(struct cxl_afu *afu, int cr, u64 off);
 
+ssize_t cxl_afu_read_err_buffer(struct cxl_afu *afu, char *buf,
+                                loff_t off, size_t count);
+
 
 struct cxl_calls {
         void (*cxl_slbia)(struct mm_struct *mm);
@@ -606,7 +617,7 @@ void cxl_release_psl_err_irq(struct cxl *adapter);
 int cxl_register_serr_irq(struct cxl_afu *afu);
 void cxl_release_serr_irq(struct cxl_afu *afu);
 int afu_register_irqs(struct cxl_context *ctx, u32 count);
-void afu_release_irqs(struct cxl_context *ctx);
+void afu_release_irqs(struct cxl_context *ctx, void *cookie);
 irqreturn_t cxl_slice_irq_err(int irq, void *data);
 
 int cxl_debugfs_init(void);
@@ -629,6 +640,10 @@ int cxl_context_init(struct cxl_context *ctx, struct cxl_afu *afu, bool master,
                      struct address_space *mapping);
 void cxl_context_free(struct cxl_context *ctx);
 int cxl_context_iomap(struct cxl_context *ctx, struct vm_area_struct *vma);
+unsigned int cxl_map_irq(struct cxl *adapter, irq_hw_number_t hwirq,
+                         irq_handler_t handler, void *cookie, const char *name);
+void cxl_unmap_irq(unsigned int virq, void *cookie);
+int __detach_context(struct cxl_context *ctx);
 
 /* This matches the layout of the H_COLLECT_CA_INT_INFO retbuf */
 struct cxl_irq_info {
@@ -642,6 +657,7 @@ struct cxl_irq_info {
         u64 padding[3]; /* to match the expected retbuf size for plpar_hcall9 */
 };
 
+void cxl_assign_psn_space(struct cxl_context *ctx);
 int cxl_attach_process(struct cxl_context *ctx, bool kernel, u64 wed,
                             u64 amr);
 int cxl_detach_process(struct cxl_context *ctx);
@@ -653,11 +669,23 @@ int cxl_check_error(struct cxl_afu *afu);
 int cxl_afu_slbia(struct cxl_afu *afu);
 int cxl_tlb_slb_invalidate(struct cxl *adapter);
 int cxl_afu_disable(struct cxl_afu *afu);
-int cxl_afu_reset(struct cxl_afu *afu);
+int __cxl_afu_reset(struct cxl_afu *afu);
+int cxl_afu_check_and_enable(struct cxl_afu *afu);
 int cxl_psl_purge(struct cxl_afu *afu);
 
 void cxl_stop_trace(struct cxl *cxl);
+int cxl_pci_vphb_add(struct cxl_afu *afu);
+void cxl_pci_vphb_remove(struct cxl_afu *afu);
 
 extern struct pci_driver cxl_pci_driver;
+int afu_allocate_irqs(struct cxl_context *ctx, u32 count);
+
+int afu_open(struct inode *inode, struct file *file);
+int afu_release(struct inode *inode, struct file *file);
+long afu_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+int afu_mmap(struct file *file, struct vm_area_struct *vm);
+unsigned int afu_poll(struct file *file, struct poll_table_struct *poll);
+ssize_t afu_read(struct file *file, char __user *buf, size_t count, loff_t *off);
+extern const struct file_operations afu_fops;
 
 #endif
diff --git a/drivers/misc/cxl/fault.c b/drivers/misc/cxl/fault.c
index 5286b8b704f5..25a5418c55cb 100644
--- a/drivers/misc/cxl/fault.c
+++ b/drivers/misc/cxl/fault.c
@@ -172,8 +172,8 @@ void cxl_handle_fault(struct work_struct *fault_work)
                 container_of(fault_work, struct cxl_context, fault_work);
         u64 dsisr = ctx->dsisr;
         u64 dar = ctx->dar;
-        struct task_struct *task;
-        struct mm_struct *mm;
+        struct task_struct *task = NULL;
+        struct mm_struct *mm = NULL;
 
         if (cxl_p2n_read(ctx->afu, CXL_PSL_DSISR_An) != dsisr ||
             cxl_p2n_read(ctx->afu, CXL_PSL_DAR_An) != dar ||
@@ -194,17 +194,19 @@ void cxl_handle_fault(struct work_struct *fault_work)
         pr_devel("CXL BOTTOM HALF handling fault for afu pe: %i. "
                 "DSISR: %#llx DAR: %#llx\n", ctx->pe, dsisr, dar);
 
-        if (!(task = get_pid_task(ctx->pid, PIDTYPE_PID))) {
-                pr_devel("cxl_handle_fault unable to get task %i\n",
-                         pid_nr(ctx->pid));
-                cxl_ack_ae(ctx);
-                return;
-        }
-        if (!(mm = get_task_mm(task))) {
-                pr_devel("cxl_handle_fault unable to get mm %i\n",
-                         pid_nr(ctx->pid));
-                cxl_ack_ae(ctx);
-                goto out;
+        if (!ctx->kernel) {
+                if (!(task = get_pid_task(ctx->pid, PIDTYPE_PID))) {
+                        pr_devel("cxl_handle_fault unable to get task %i\n",
+                                 pid_nr(ctx->pid));
+                        cxl_ack_ae(ctx);
+                        return;
+                }
+                if (!(mm = get_task_mm(task))) {
+                        pr_devel("cxl_handle_fault unable to get mm %i\n",
+                                 pid_nr(ctx->pid));
+                        cxl_ack_ae(ctx);
+                        goto out;
+                }
         }
 
         if (dsisr & CXL_PSL_DSISR_An_DS)
@@ -214,9 +216,11 @@ void cxl_handle_fault(struct work_struct *fault_work)
         else
                 WARN(1, "cxl_handle_fault has nothing to handle\n");
 
-        mmput(mm);
+        if (mm)
+                mmput(mm);
 out:
-        put_task_struct(task);
+        if (task)
+                put_task_struct(task);
 }
 
 static void cxl_prefault_one(struct cxl_context *ctx, u64 ea)
diff --git a/drivers/misc/cxl/file.c b/drivers/misc/cxl/file.c
index 2364bcadb9a9..e3f4b69527a9 100644
--- a/drivers/misc/cxl/file.c
+++ b/drivers/misc/cxl/file.c
@@ -96,7 +96,8 @@ err_put_adapter:
         put_device(&adapter->dev);
         return rc;
 }
-static int afu_open(struct inode *inode, struct file *file)
+
+int afu_open(struct inode *inode, struct file *file)
 {
         return __afu_open(inode, file, false);
 }
@@ -106,7 +107,7 @@ static int afu_master_open(struct inode *inode, struct file *file)
         return __afu_open(inode, file, true);
 }
 
-static int afu_release(struct inode *inode, struct file *file)
+int afu_release(struct inode *inode, struct file *file)
 {
         struct cxl_context *ctx = file->private_data;
 
@@ -128,7 +129,6 @@ static int afu_release(struct inode *inode, struct file *file)
          */
         cxl_context_free(ctx);
 
-        cxl_ctx_put();
         return 0;
 }
 
@@ -191,7 +191,7 @@ static long afu_ioctl_start_work(struct cxl_context *ctx,
 
         if ((rc = cxl_attach_process(ctx, false, work.work_element_descriptor,
                                      amr))) {
-                afu_release_irqs(ctx);
+                afu_release_irqs(ctx, ctx);
                 goto out;
         }
 
@@ -212,7 +212,26 @@ static long afu_ioctl_process_element(struct cxl_context *ctx,
         return 0;
 }
 
-static long afu_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static long afu_ioctl_get_afu_id(struct cxl_context *ctx,
+                                 struct cxl_afu_id __user *upafuid)
+{
+        struct cxl_afu_id afuid = { 0 };
+
+        afuid.card_id = ctx->afu->adapter->adapter_num;
+        afuid.afu_offset = ctx->afu->slice;
+        afuid.afu_mode = ctx->afu->current_mode;
+
+        /* set the flag bit in case the afu is a slave */
+        if (ctx->afu->current_mode == CXL_MODE_DIRECTED && !ctx->master)
+                afuid.flags |= CXL_AFUID_FLAG_SLAVE;
+
+        if (copy_to_user(upafuid, &afuid, sizeof(afuid)))
+                return -EFAULT;
+
+        return 0;
+}
+
+long afu_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct cxl_context *ctx = file->private_data;
 
@@ -225,17 +244,20 @@ static long afu_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 return afu_ioctl_start_work(ctx, (struct cxl_ioctl_start_work __user *)arg);
         case CXL_IOCTL_GET_PROCESS_ELEMENT:
                 return afu_ioctl_process_element(ctx, (__u32 __user *)arg);
+        case CXL_IOCTL_GET_AFU_ID:
+                return afu_ioctl_get_afu_id(ctx, (struct cxl_afu_id __user *)
+                                            arg);
         }
         return -EINVAL;
 }
 
-static long afu_compat_ioctl(struct file *file, unsigned int cmd,
+long afu_compat_ioctl(struct file *file, unsigned int cmd,
                              unsigned long arg)
 {
         return afu_ioctl(file, cmd, arg);
 }
 
-static int afu_mmap(struct file *file, struct vm_area_struct *vm)
+int afu_mmap(struct file *file, struct vm_area_struct *vm)
 {
         struct cxl_context *ctx = file->private_data;
 
@@ -246,7 +268,7 @@ static int afu_mmap(struct file *file, struct vm_area_struct *vm)
         return cxl_context_iomap(ctx, vm);
 }
 
-static unsigned int afu_poll(struct file *file, struct poll_table_struct *poll)
+unsigned int afu_poll(struct file *file, struct poll_table_struct *poll)
 {
         struct cxl_context *ctx = file->private_data;
         int mask = 0;
@@ -278,7 +300,7 @@ static inline int ctx_event_pending(struct cxl_context *ctx)
             ctx->pending_afu_err || (ctx->status == CLOSED));
 }
 
-static ssize_t afu_read(struct file *file, char __user *buf, size_t count,
+ssize_t afu_read(struct file *file, char __user *buf, size_t count,
                         loff_t *off)
 {
         struct cxl_context *ctx = file->private_data;
@@ -359,7 +381,11 @@ out:
         return rc;
 }
 
-static const struct file_operations afu_fops = {
+/* 
+ * Note: if this is updated, we need to update api.c to patch the new ones in
+ * too
+ */
+const struct file_operations afu_fops = {
         .owner          = THIS_MODULE,
         .open           = afu_open,
         .poll           = afu_poll,
@@ -370,7 +396,7 @@ static const struct file_operations afu_fops = {
         .mmap           = afu_mmap,
 };
 
-static const struct file_operations afu_master_fops = {
+const struct file_operations afu_master_fops = {
         .owner          = THIS_MODULE,
         .open           = afu_master_open,
         .poll           = afu_poll,
diff --git a/drivers/misc/cxl/irq.c b/drivers/misc/cxl/irq.c
index c8929c526691..680cd263436d 100644
--- a/drivers/misc/cxl/irq.c
+++ b/drivers/misc/cxl/irq.c
@@ -14,7 +14,7 @@
 #include <linux/slab.h>
 #include <linux/pid.h>
 #include <asm/cputable.h>
-#include <misc/cxl.h>
+#include <misc/cxl-base.h>
 
 #include "cxl.h"
 #include "trace.h"
@@ -416,9 +416,8 @@ void afu_irq_name_free(struct cxl_context *ctx)
         }
 }
 
-int afu_register_irqs(struct cxl_context *ctx, u32 count)
+int afu_allocate_irqs(struct cxl_context *ctx, u32 count)
 {
-        irq_hw_number_t hwirq;
         int rc, r, i, j = 1;
         struct cxl_irq_name *irq_name;
 
@@ -458,6 +457,18 @@ int afu_register_irqs(struct cxl_context *ctx, u32 count)
                         j++;
                 }
         }
+        return 0;
+
+out:
+        afu_irq_name_free(ctx);
+        return -ENOMEM;
+}
+
+void afu_register_hwirqs(struct cxl_context *ctx)
+{
+        irq_hw_number_t hwirq;
+        struct cxl_irq_name *irq_name;
+        int r,i;
 
         /* We've allocated all memory now, so let's do the irq allocations */
         irq_name = list_first_entry(&ctx->irq_names, struct cxl_irq_name, list);
@@ -469,15 +480,21 @@ int afu_register_irqs(struct cxl_context *ctx, u32 count)
                         irq_name = list_next_entry(irq_name, list);
                 }
         }
+}
 
-        return 0;
+int afu_register_irqs(struct cxl_context *ctx, u32 count)
+{
+        int rc;
 
-out:
-        afu_irq_name_free(ctx);
-        return -ENOMEM;
-}
+        rc = afu_allocate_irqs(ctx, count);
+        if (rc)
+                return rc;
+
+        afu_register_hwirqs(ctx);
+        return 0;
+ }
 
-void afu_release_irqs(struct cxl_context *ctx)
+void afu_release_irqs(struct cxl_context *ctx, void *cookie)
 {
         irq_hw_number_t hwirq;
         unsigned int virq;
@@ -488,7 +505,7 @@ void afu_release_irqs(struct cxl_context *ctx)
                 for (i = 0; i < ctx->irqs.range[r]; hwirq++, i++) {
                         virq = irq_find_mapping(NULL, hwirq);
                         if (virq)
-                                cxl_unmap_irq(virq, ctx);
+                                cxl_unmap_irq(virq, cookie);
                 }
         }
 
diff --git a/drivers/misc/cxl/main.c b/drivers/misc/cxl/main.c
index 8ccddceead66..4a164ab8b35a 100644
--- a/drivers/misc/cxl/main.c
+++ b/drivers/misc/cxl/main.c
@@ -20,7 +20,7 @@
 #include <linux/idr.h>
 #include <linux/pci.h>
 #include <asm/cputable.h>
-#include <misc/cxl.h>
+#include <misc/cxl-base.h>
 
 #include "cxl.h"
 #include "trace.h"
@@ -73,7 +73,7 @@ static inline void cxl_slbia_core(struct mm_struct *mm)
                 spin_lock(&adapter->afu_list_lock);
                 for (slice = 0; slice < adapter->slices; slice++) {
                         afu = adapter->afu[slice];
-                        if (!afu->enabled)
+                        if (!afu || !afu->enabled)
                                 continue;
                         rcu_read_lock();
                         idr_for_each_entry(&afu->contexts_idr, ctx, id)
diff --git a/drivers/misc/cxl/native.c b/drivers/misc/cxl/native.c
index 29185fc61276..10567f245818 100644
--- a/drivers/misc/cxl/native.c
+++ b/drivers/misc/cxl/native.c
@@ -15,7 +15,7 @@
 #include <linux/mm.h>
 #include <linux/uaccess.h>
 #include <asm/synch.h>
-#include <misc/cxl.h>
+#include <misc/cxl-base.h>
 
 #include "cxl.h"
 #include "trace.h"
@@ -73,7 +73,7 @@ int cxl_afu_disable(struct cxl_afu *afu)
 }
 
 /* This will disable as well as reset */
-int cxl_afu_reset(struct cxl_afu *afu)
+int __cxl_afu_reset(struct cxl_afu *afu)
 {
         pr_devel("AFU reset request\n");
 
@@ -83,7 +83,7 @@ int cxl_afu_reset(struct cxl_afu *afu)
                            false);
 }
 
-static int afu_check_and_enable(struct cxl_afu *afu)
+int cxl_afu_check_and_enable(struct cxl_afu *afu)
 {
         if (afu->enabled)
                 return 0;
@@ -379,7 +379,7 @@ static int remove_process_element(struct cxl_context *ctx)
 }
 
 
-static void assign_psn_space(struct cxl_context *ctx)
+void cxl_assign_psn_space(struct cxl_context *ctx)
 {
         if (!ctx->afu->pp_size || ctx->master) {
                 ctx->psn_phys = ctx->afu->psn_phys;
@@ -430,34 +430,46 @@ err:
 #define set_endian(sr) ((sr) &= ~(CXL_PSL_SR_An_LE))
 #endif
 
+static u64 calculate_sr(struct cxl_context *ctx)
+{
+        u64 sr = 0;
+
+        if (ctx->master)
+                sr |= CXL_PSL_SR_An_MP;
+        if (mfspr(SPRN_LPCR) & LPCR_TC)
+                sr |= CXL_PSL_SR_An_TC;
+        if (ctx->kernel) {
+                sr |= CXL_PSL_SR_An_R | (mfmsr() & MSR_SF);
+                sr |= CXL_PSL_SR_An_HV;
+        } else {
+                sr |= CXL_PSL_SR_An_PR | CXL_PSL_SR_An_R;
+                set_endian(sr);
+                sr &= ~(CXL_PSL_SR_An_HV);
+                if (!test_tsk_thread_flag(current, TIF_32BIT))
+                        sr |= CXL_PSL_SR_An_SF;
+        }
+        return sr;
+}
+
 static int attach_afu_directed(struct cxl_context *ctx, u64 wed, u64 amr)
 {
-        u64 sr;
+        u32 pid;
         int r, result;
 
-        assign_psn_space(ctx);
+        cxl_assign_psn_space(ctx);
 
         ctx->elem->ctxtime = 0; /* disable */
         ctx->elem->lpid = cpu_to_be32(mfspr(SPRN_LPID));
         ctx->elem->haurp = 0; /* disable */
         ctx->elem->sdr = cpu_to_be64(mfspr(SPRN_SDR1));
 
-        sr = 0;
-        if (ctx->master)
-                sr |= CXL_PSL_SR_An_MP;
-        if (mfspr(SPRN_LPCR) & LPCR_TC)
-                sr |= CXL_PSL_SR_An_TC;
-        /* HV=0, PR=1, R=1 for userspace
-         * For kernel contexts: this would need to change
-         */
-        sr |= CXL_PSL_SR_An_PR | CXL_PSL_SR_An_R;
-        set_endian(sr);
-        sr &= ~(CXL_PSL_SR_An_HV);
-        if (!test_tsk_thread_flag(current, TIF_32BIT))
-                sr |= CXL_PSL_SR_An_SF;
-        ctx->elem->common.pid = cpu_to_be32(current->pid);
+        pid = current->pid;
+        if (ctx->kernel)
+                pid = 0;
         ctx->elem->common.tid = 0;
-        ctx->elem->sr = cpu_to_be64(sr);
+        ctx->elem->common.pid = cpu_to_be32(pid);
+
+        ctx->elem->sr = cpu_to_be64(calculate_sr(ctx));
 
         ctx->elem->common.csrp = 0; /* disable */
         ctx->elem->common.aurp0 = 0; /* disable */
@@ -477,7 +489,7 @@ static int attach_afu_directed(struct cxl_context *ctx, u64 wed, u64 amr)
         ctx->elem->common.wed = cpu_to_be64(wed);
 
         /* first guy needs to enable */
-        if ((result = afu_check_and_enable(ctx->afu)))
+        if ((result = cxl_afu_check_and_enable(ctx->afu)))
                 return result;
 
         add_process_element(ctx);
@@ -495,7 +507,7 @@ static int deactivate_afu_directed(struct cxl_afu *afu)
         cxl_sysfs_afu_m_remove(afu);
         cxl_chardev_afu_remove(afu);
 
-        cxl_afu_reset(afu);
+        __cxl_afu_reset(afu);
         cxl_afu_disable(afu);
         cxl_psl_purge(afu);
 
@@ -530,20 +542,15 @@ static int activate_dedicated_process(struct cxl_afu *afu)
 static int attach_dedicated(struct cxl_context *ctx, u64 wed, u64 amr)
 {
         struct cxl_afu *afu = ctx->afu;
-        u64 sr;
+        u64 pid;
         int rc;
 
-        sr = 0;
-        set_endian(sr);
-        if (ctx->master)
-                sr |= CXL_PSL_SR_An_MP;
-        if (mfspr(SPRN_LPCR) & LPCR_TC)
-                sr |= CXL_PSL_SR_An_TC;
-        sr |= CXL_PSL_SR_An_PR | CXL_PSL_SR_An_R;
-        if (!test_tsk_thread_flag(current, TIF_32BIT))
-                sr |= CXL_PSL_SR_An_SF;
-        cxl_p2n_write(afu, CXL_PSL_PID_TID_An, (u64)current->pid << 32);
-        cxl_p1n_write(afu, CXL_PSL_SR_An, sr);
+        pid = (u64)current->pid << 32;
+        if (ctx->kernel)
+                pid = 0;
+        cxl_p2n_write(afu, CXL_PSL_PID_TID_An, pid);
+
+        cxl_p1n_write(afu, CXL_PSL_SR_An, calculate_sr(ctx));
 
         if ((rc = cxl_write_sstp(afu, ctx->sstp0, ctx->sstp1)))
                 return rc;
@@ -564,9 +571,9 @@ static int attach_dedicated(struct cxl_context *ctx, u64 wed, u64 amr)
         cxl_p2n_write(afu, CXL_PSL_AMR_An, amr);
 
         /* master only context for dedicated */
-        assign_psn_space(ctx);
+        cxl_assign_psn_space(ctx);
 
-        if ((rc = cxl_afu_reset(afu)))
+        if ((rc = __cxl_afu_reset(afu)))
                 return rc;
 
         cxl_p2n_write(afu, CXL_PSL_WED_An, wed);
@@ -629,7 +636,7 @@ int cxl_attach_process(struct cxl_context *ctx, bool kernel, u64 wed, u64 amr)
 
 static inline int detach_process_native_dedicated(struct cxl_context *ctx)
 {
-        cxl_afu_reset(ctx->afu);
+        __cxl_afu_reset(ctx->afu);
         cxl_afu_disable(ctx->afu);
         cxl_psl_purge(ctx->afu);
         return 0;
diff --git a/drivers/misc/cxl/pci.c b/drivers/misc/cxl/pci.c
index 1ef01647265f..32ad09705949 100644
--- a/drivers/misc/cxl/pci.c
+++ b/drivers/misc/cxl/pci.c
@@ -90,6 +90,7 @@
 /* This works a little different than the p1/p2 register accesses to make it
  * easier to pull out individual fields */
 #define AFUD_READ(afu, off)             in_be64(afu->afu_desc_mmio + off)
+#define AFUD_READ_LE(afu, off)          in_le64(afu->afu_desc_mmio + off)
 #define EXTRACT_PPC_BIT(val, bit)       (!!(val & PPC_BIT(bit)))
 #define EXTRACT_PPC_BITS(val, bs, be)   ((val & PPC_BITMASK(bs, be)) >> PPC_BITLSHIFT(be))
 
@@ -204,7 +205,7 @@ static void dump_cxl_config_space(struct pci_dev *dev)
         dev_info(&dev->dev, "p1 regs: %#llx, len: %#llx\n",
                 p1_base(dev), p1_size(dev));
         dev_info(&dev->dev, "p2 regs: %#llx, len: %#llx\n",
-                p1_base(dev), p2_size(dev));
+                p2_base(dev), p2_size(dev));
         dev_info(&dev->dev, "BAR 4/5: %#llx, len: %#llx\n",
                 pci_resource_start(dev, 4), pci_resource_len(dev, 4));
 
@@ -286,7 +287,8 @@ static void dump_cxl_config_space(struct pci_dev *dev)
 
 static void dump_afu_descriptor(struct cxl_afu *afu)
 {
-        u64 val;
+        u64 val, afu_cr_num, afu_cr_off, afu_cr_len;
+        int i;
 
 #define show_reg(name, what) \
         dev_info(&afu->dev, "afu desc: %30s: %#llx\n", name, what)
@@ -296,6 +298,7 @@ static void dump_afu_descriptor(struct cxl_afu *afu)
         show_reg("num_of_processes", AFUD_NUM_PROCS(val));
         show_reg("num_of_afu_CRs", AFUD_NUM_CRS(val));
         show_reg("req_prog_mode", val & 0xffffULL);
+        afu_cr_num = AFUD_NUM_CRS(val);
 
         val = AFUD_READ(afu, 0x8);
         show_reg("Reserved", val);
@@ -307,8 +310,10 @@ static void dump_afu_descriptor(struct cxl_afu *afu)
         val = AFUD_READ_CR(afu);
         show_reg("Reserved", (val >> (63-7)) & 0xff);
         show_reg("AFU_CR_len", AFUD_CR_LEN(val));
+        afu_cr_len = AFUD_CR_LEN(val) * 256;
 
         val = AFUD_READ_CR_OFF(afu);
+        afu_cr_off = val;
         show_reg("AFU_CR_offset", val);
 
         val = AFUD_READ_PPPSA(afu);
@@ -325,6 +330,11 @@ static void dump_afu_descriptor(struct cxl_afu *afu)
         val = AFUD_READ_EB_OFF(afu);
         show_reg("AFU_EB_offset", val);
 
+        for (i = 0; i < afu_cr_num; i++) {
+                val = AFUD_READ_LE(afu, afu_cr_off + i * afu_cr_len);
+                show_reg("CR Vendor", val & 0xffff);
+                show_reg("CR Device", (val >> 16) & 0xffff);
+        }
 #undef show_reg
 }
 
@@ -529,7 +539,7 @@ err:
 
 static void cxl_unmap_slice_regs(struct cxl_afu *afu)
 {
-        if (afu->p1n_mmio)
+        if (afu->p2n_mmio)
                 iounmap(afu->p2n_mmio);
         if (afu->p1n_mmio)
                 iounmap(afu->p1n_mmio);
@@ -593,6 +603,22 @@ static int cxl_read_afu_descriptor(struct cxl_afu *afu)
         afu->crs_len = AFUD_CR_LEN(val) * 256;
         afu->crs_offset = AFUD_READ_CR_OFF(afu);
 
+
+        /* eb_len is in multiple of 4K */
+        afu->eb_len = AFUD_EB_LEN(AFUD_READ_EB(afu)) * 4096;
+        afu->eb_offset = AFUD_READ_EB_OFF(afu);
+
+        /* eb_off is 4K aligned so lower 12 bits are always zero */
+        if (EXTRACT_PPC_BITS(afu->eb_offset, 0, 11) != 0) {
+                dev_warn(&afu->dev,
+                         "Invalid AFU error buffer offset %Lx\n",
+                         afu->eb_offset);
+                dev_info(&afu->dev,
+                         "Ignoring AFU error buffer in the descriptor\n");
+                /* indicate that no afu buffer exists */
+                afu->eb_len = 0;
+        }
+
         return 0;
 }
 
@@ -631,7 +657,7 @@ static int sanitise_afu_regs(struct cxl_afu *afu)
         reg = cxl_p2n_read(afu, CXL_AFU_Cntl_An);
         if ((reg & CXL_AFU_Cntl_An_ES_MASK) != CXL_AFU_Cntl_An_ES_Disabled) {
                 dev_warn(&afu->dev, "WARNING: AFU was not disabled: %#.16llx\n", reg);
-                if (cxl_afu_reset(afu))
+                if (__cxl_afu_reset(afu))
                         return -EIO;
                 if (cxl_afu_disable(afu))
                         return -EIO;
@@ -672,6 +698,50 @@ static int sanitise_afu_regs(struct cxl_afu *afu)
         return 0;
 }
 
+#define ERR_BUFF_MAX_COPY_SIZE PAGE_SIZE
+/*
+ * afu_eb_read:
+ * Called from sysfs and reads the afu error info buffer. The h/w only supports
+ * 4/8 bytes aligned access. So in case the requested offset/count arent 8 byte
+ * aligned the function uses a bounce buffer which can be max PAGE_SIZE.
+ */
+ssize_t cxl_afu_read_err_buffer(struct cxl_afu *afu, char *buf,
+                                loff_t off, size_t count)
+{
+        loff_t aligned_start, aligned_end;
+        size_t aligned_length;
+        void *tbuf;
+        const void __iomem *ebuf = afu->afu_desc_mmio + afu->eb_offset;
+
+        if (count == 0 || off < 0 || (size_t)off >= afu->eb_len)
+                return 0;
+
+        /* calculate aligned read window */
+        count = min((size_t)(afu->eb_len - off), count);
+        aligned_start = round_down(off, 8);
+        aligned_end = round_up(off + count, 8);
+        aligned_length = aligned_end - aligned_start;
+
+        /* max we can copy in one read is PAGE_SIZE */
+        if (aligned_length > ERR_BUFF_MAX_COPY_SIZE) {
+                aligned_length = ERR_BUFF_MAX_COPY_SIZE;
+                count = ERR_BUFF_MAX_COPY_SIZE - (off & 0x7);
+        }
+
+        /* use bounce buffer for copy */
+        tbuf = (void *)__get_free_page(GFP_TEMPORARY);
+        if (!tbuf)
+                return -ENOMEM;
+
+        /* perform aligned read from the mmio region */
+        memcpy_fromio(tbuf, ebuf + aligned_start, aligned_length);
+        memcpy(buf, tbuf + (off & 0x7), count);
+
+        free_page((unsigned long)tbuf);
+
+        return count;
+}
+
 static int cxl_init_afu(struct cxl *adapter, int slice, struct pci_dev *dev)
 {
         struct cxl_afu *afu;
@@ -691,7 +761,7 @@ static int cxl_init_afu(struct cxl *adapter, int slice, struct pci_dev *dev)
                 goto err2;
 
         /* We need to reset the AFU before we can read the AFU descriptor */
-        if ((rc = cxl_afu_reset(afu)))
+        if ((rc = __cxl_afu_reset(afu)))
                 goto err2;
 
         if (cxl_verbose)
@@ -731,6 +801,9 @@ static int cxl_init_afu(struct cxl *adapter, int slice, struct pci_dev *dev)
 
         adapter->afu[afu->slice] = afu;
 
+        if ((rc = cxl_pci_vphb_add(afu)))
+                dev_info(&afu->dev, "Can't register vPHB\n");
+
         return 0;
 
 err_put2:
@@ -783,8 +856,10 @@ int cxl_reset(struct cxl *adapter)
 
         dev_info(&dev->dev, "CXL reset\n");
 
-        for (i = 0; i < adapter->slices; i++)
+        for (i = 0; i < adapter->slices; i++) {
+                cxl_pci_vphb_remove(adapter->afu[i]);
                 cxl_remove_afu(adapter->afu[i]);
+        }
 
         /* pcie_warm_reset requests a fundamental pci reset which includes a
          * PERST assert/deassert.  PERST triggers a loading of the image
@@ -857,13 +932,13 @@ static int cxl_read_vsec(struct cxl *adapter, struct pci_dev *dev)
         u8 image_state;
 
         if (!(vsec = find_cxl_vsec(dev))) {
-                dev_err(&adapter->dev, "ABORTING: CXL VSEC not found!\n");
+                dev_err(&dev->dev, "ABORTING: CXL VSEC not found!\n");
                 return -ENODEV;
         }
 
         CXL_READ_VSEC_LENGTH(dev, vsec, &vseclen);
         if (vseclen < CXL_VSEC_MIN_SIZE) {
-                pr_err("ABORTING: CXL VSEC too short\n");
+                dev_err(&dev->dev, "ABORTING: CXL VSEC too short\n");
                 return -EINVAL;
         }
 
@@ -902,24 +977,24 @@ static int cxl_vsec_looks_ok(struct cxl *adapter, struct pci_dev *dev)
                 return -EBUSY;
 
         if (adapter->vsec_status & CXL_UNSUPPORTED_FEATURES) {
-                dev_err(&adapter->dev, "ABORTING: CXL requires unsupported features\n");
+                dev_err(&dev->dev, "ABORTING: CXL requires unsupported features\n");
                 return -EINVAL;
         }
 
         if (!adapter->slices) {
                 /* Once we support dynamic reprogramming we can use the card if
                  * it supports loadable AFUs */
-                dev_err(&adapter->dev, "ABORTING: Device has no AFUs\n");
+                dev_err(&dev->dev, "ABORTING: Device has no AFUs\n");
                 return -EINVAL;
         }
 
         if (!adapter->afu_desc_off || !adapter->afu_desc_size) {
-                dev_err(&adapter->dev, "ABORTING: VSEC shows no AFU descriptors\n");
+                dev_err(&dev->dev, "ABORTING: VSEC shows no AFU descriptors\n");
                 return -EINVAL;
         }
 
         if (adapter->ps_size > p2_size(dev) - adapter->ps_off) {
-                dev_err(&adapter->dev, "ABORTING: Problem state size larger than "
+                dev_err(&dev->dev, "ABORTING: Problem state size larger than "
                                    "available in BAR2: 0x%llx > 0x%llx\n",
                          adapter->ps_size, p2_size(dev) - adapter->ps_off);
                 return -EINVAL;
@@ -968,6 +1043,15 @@ static struct cxl *cxl_init_adapter(struct pci_dev *dev)
         if (!(adapter = cxl_alloc_adapter(dev)))
                 return ERR_PTR(-ENOMEM);
 
+        if ((rc = cxl_read_vsec(adapter, dev)))
+                goto err1;
+
+        if ((rc = cxl_vsec_looks_ok(adapter, dev)))
+                goto err1;
+
+        if ((rc = setup_cxl_bars(dev)))
+                goto err1;
+
         if ((rc = switch_card_to_cxl(dev)))
                 goto err1;
 
@@ -977,12 +1061,6 @@ static struct cxl *cxl_init_adapter(struct pci_dev *dev)
         if ((rc = dev_set_name(&adapter->dev, "card%i", adapter->adapter_num)))
                 goto err2;
 
-        if ((rc = cxl_read_vsec(adapter, dev)))
-                goto err2;
-
-        if ((rc = cxl_vsec_looks_ok(adapter, dev)))
-                goto err2;
-
         if ((rc = cxl_update_image_control(adapter)))
                 goto err2;
 
@@ -1067,9 +1145,6 @@ static int cxl_probe(struct pci_dev *dev, const struct pci_device_id *id)
         if (cxl_verbose)
                 dump_cxl_config_space(dev);
 
-        if ((rc = setup_cxl_bars(dev)))
-                return rc;
-
         if ((rc = pci_enable_device(dev))) {
                 dev_err(&dev->dev, "pci_enable_device failed: %i\n", rc);
                 return rc;
@@ -1078,6 +1153,7 @@ static int cxl_probe(struct pci_dev *dev, const struct pci_device_id *id)
         adapter = cxl_init_adapter(dev);
         if (IS_ERR(adapter)) {
                 dev_err(&dev->dev, "cxl_init_adapter failed: %li\n", PTR_ERR(adapter));
+                pci_disable_device(dev);
                 return PTR_ERR(adapter);
         }
 
@@ -1092,16 +1168,18 @@ static int cxl_probe(struct pci_dev *dev, const struct pci_device_id *id)
 static void cxl_remove(struct pci_dev *dev)
 {
         struct cxl *adapter = pci_get_drvdata(dev);
-        int afu;
-
-        dev_warn(&dev->dev, "pci remove\n");
+        struct cxl_afu *afu;
+        int i;
 
         /*
          * Lock to prevent someone grabbing a ref through the adapter list as
          * we are removing it
          */
-        for (afu = 0; afu < adapter->slices; afu++)
-                cxl_remove_afu(adapter->afu[afu]);
+        for (i = 0; i < adapter->slices; i++) {
+                afu = adapter->afu[i];
+                cxl_pci_vphb_remove(afu);
+                cxl_remove_afu(afu);
+        }
         cxl_remove_adapter(adapter);
 }
 
@@ -1110,4 +1188,5 @@ struct pci_driver cxl_pci_driver = {
         .id_table = cxl_pci_tbl,
         .probe = cxl_probe,
         .remove = cxl_remove,
+        .shutdown = cxl_remove,
 };
diff --git a/drivers/misc/cxl/sysfs.c b/drivers/misc/cxl/sysfs.c
index d0c38c7bc0c4..31f38bc71a3d 100644
--- a/drivers/misc/cxl/sysfs.c
+++ b/drivers/misc/cxl/sysfs.c
@@ -185,7 +185,7 @@ static ssize_t reset_store_afu(struct device *device,
                 goto err;
         }
 
-        if ((rc = cxl_afu_reset(afu)))
+        if ((rc = __cxl_afu_reset(afu)))
                 goto err;
 
         rc = count;
@@ -356,6 +356,16 @@ static ssize_t api_version_compatible_show(struct device *device,
         return scnprintf(buf, PAGE_SIZE, "%i\n", CXL_API_VERSION_COMPATIBLE);
 }
 
+static ssize_t afu_eb_read(struct file *filp, struct kobject *kobj,
+                               struct bin_attribute *bin_attr, char *buf,
+                               loff_t off, size_t count)
+{
+        struct cxl_afu *afu = to_cxl_afu(container_of(kobj,
+                                                      struct device, kobj));
+
+        return cxl_afu_read_err_buffer(afu, buf, off, count);
+}
+
 static struct device_attribute afu_attrs[] = {
         __ATTR_RO(mmio_size),
         __ATTR_RO(irqs_min),
@@ -534,6 +544,10 @@ void cxl_sysfs_afu_remove(struct cxl_afu *afu)
         struct afu_config_record *cr, *tmp;
         int i;
 
+        /* remove the err buffer bin attribute */
+        if (afu->eb_len)
+                device_remove_bin_file(&afu->dev, &afu->attr_eb);
+
         for (i = 0; i < ARRAY_SIZE(afu_attrs); i++)
                 device_remove_file(&afu->dev, &afu_attrs[i]);
 
@@ -555,6 +569,22 @@ int cxl_sysfs_afu_add(struct cxl_afu *afu)
                         goto err;
         }
 
+        /* conditionally create the add the binary file for error info buffer */
+        if (afu->eb_len) {
+                afu->attr_eb.attr.name = "afu_err_buff";
+                afu->attr_eb.attr.mode = S_IRUGO;
+                afu->attr_eb.size = afu->eb_len;
+                afu->attr_eb.read = afu_eb_read;
+
+                rc = device_create_bin_file(&afu->dev, &afu->attr_eb);
+                if (rc) {
+                        dev_err(&afu->dev,
+                                "Unable to create eb attr for the afu. Err(%d)\n",
+                                rc);
+                        goto err;
+                }
+        }
+
         for (i = 0; i < afu->crs_num; i++) {
                 cr = cxl_sysfs_afu_new_cr(afu, i);
                 if (IS_ERR(cr)) {
@@ -570,6 +600,9 @@ err1:
         cxl_sysfs_afu_remove(afu);
         return rc;
 err:
+        /* reset the eb_len as we havent created the bin attr */
+        afu->eb_len = 0;
+
         for (i--; i >= 0; i--)
                 device_remove_file(&afu->dev, &afu_attrs[i]);
         return rc;
diff --git a/drivers/misc/cxl/vphb.c b/drivers/misc/cxl/vphb.c
new file mode 100644
index 000000000000..2eba002b580b
--- /dev/null
+++ b/drivers/misc/cxl/vphb.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2014 IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/pci.h>
+#include <misc/cxl.h>
+#include "cxl.h"
+
+static int cxl_dma_set_mask(struct pci_dev *pdev, u64 dma_mask)
+{
+        if (dma_mask < DMA_BIT_MASK(64)) {
+                pr_info("%s only 64bit DMA supported on CXL", __func__);
+                return -EIO;
+        }
+
+        *(pdev->dev.dma_mask) = dma_mask;
+        return 0;
+}
+
+static int cxl_pci_probe_mode(struct pci_bus *bus)
+{
+        return PCI_PROBE_NORMAL;
+}
+
+static int cxl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
+{
+        return -ENODEV;
+}
+
+static void cxl_teardown_msi_irqs(struct pci_dev *pdev)
+{
+        /*
+         * MSI should never be set but need still need to provide this call
+         * back.
+         */
+}
+
+static bool cxl_pci_enable_device_hook(struct pci_dev *dev)
+{
+        struct pci_controller *phb;
+        struct cxl_afu *afu;
+        struct cxl_context *ctx;
+
+        phb = pci_bus_to_host(dev->bus);
+        afu = (struct cxl_afu *)phb->private_data;
+        set_dma_ops(&dev->dev, &dma_direct_ops);
+        set_dma_offset(&dev->dev, PAGE_OFFSET);
+
+        /*
+         * Allocate a context to do cxl things too.  If we eventually do real
+         * DMA ops, we'll need a default context to attach them to
+         */
+        ctx = cxl_dev_context_init(dev);
+        if (!ctx)
+                return false;
+        dev->dev.archdata.cxl_ctx = ctx;
+
+        return (cxl_afu_check_and_enable(afu) == 0);
+}
+
+static void cxl_pci_disable_device(struct pci_dev *dev)
+{
+        struct cxl_context *ctx = cxl_get_context(dev);
+
+        if (ctx) {
+                if (ctx->status == STARTED) {
+                        dev_err(&dev->dev, "Default context started\n");
+                        return;
+                }
+                dev->dev.archdata.cxl_ctx = NULL;
+                cxl_release_context(ctx);
+        }
+}
+
+static resource_size_t cxl_pci_window_alignment(struct pci_bus *bus,
+                                                unsigned long type)
+{
+        return 1;
+}
+
+static void cxl_pci_reset_secondary_bus(struct pci_dev *dev)
+{
+        /* Should we do an AFU reset here ? */
+}
+
+static int cxl_pcie_cfg_record(u8 bus, u8 devfn)
+{
+        return (bus << 8) + devfn;
+}
+
+static unsigned long cxl_pcie_cfg_addr(struct pci_controller* phb,
+                                       u8 bus, u8 devfn, int offset)
+{
+        int record = cxl_pcie_cfg_record(bus, devfn);
+
+        return (unsigned long)phb->cfg_addr + ((unsigned long)phb->cfg_data * record) + offset;
+}
+
+
+static int cxl_pcie_config_info(struct pci_bus *bus, unsigned int devfn,
+                                int offset, int len,
+                                volatile void __iomem **ioaddr,
+                                u32 *mask, int *shift)
+{
+        struct pci_controller *phb;
+        struct cxl_afu *afu;
+        unsigned long addr;
+
+        phb = pci_bus_to_host(bus);
+        if (phb == NULL)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        afu = (struct cxl_afu *)phb->private_data;
+
+        if (cxl_pcie_cfg_record(bus->number, devfn) > afu->crs_num)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (offset >= (unsigned long)phb->cfg_data)
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+        addr = cxl_pcie_cfg_addr(phb, bus->number, devfn, offset);
+
+        *ioaddr = (void *)(addr & ~0x3ULL);
+        *shift = ((addr & 0x3) * 8);
+        switch (len) {
+        case 1:
+                *mask = 0xff;
+                break;
+        case 2:
+                *mask = 0xffff;
+                break;
+        default:
+                *mask = 0xffffffff;
+                break;
+        }
+        return 0;
+}
+
+static int cxl_pcie_read_config(struct pci_bus *bus, unsigned int devfn,
+                                int offset, int len, u32 *val)
+{
+        volatile void __iomem *ioaddr;
+        int shift, rc;
+        u32 mask;
+
+        rc = cxl_pcie_config_info(bus, devfn, offset, len, &ioaddr,
+                                  &mask, &shift);
+        if (rc)
+                return rc;
+
+        /* Can only read 32 bits */
+        *val = (in_le32(ioaddr) >> shift) & mask;
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int cxl_pcie_write_config(struct pci_bus *bus, unsigned int devfn,
+                                 int offset, int len, u32 val)
+{
+        volatile void __iomem *ioaddr;
+        u32 v, mask;
+        int shift, rc;
+
+        rc = cxl_pcie_config_info(bus, devfn, offset, len, &ioaddr,
+                                  &mask, &shift);
+        if (rc)
+                return rc;
+
+        /* Can only write 32 bits so do read-modify-write */
+        mask <<= shift;
+        val <<= shift;
+
+        v = (in_le32(ioaddr) & ~mask) || (val & mask);
+
+        out_le32(ioaddr, v);
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static struct pci_ops cxl_pcie_pci_ops =
+{
+        .read = cxl_pcie_read_config,
+        .write = cxl_pcie_write_config,
+};
+
+
+static struct pci_controller_ops cxl_pci_controller_ops =
+{
+        .probe_mode = cxl_pci_probe_mode,
+        .enable_device_hook = cxl_pci_enable_device_hook,
+        .disable_device = cxl_pci_disable_device,
+        .release_device = cxl_pci_disable_device,
+        .window_alignment = cxl_pci_window_alignment,
+        .reset_secondary_bus = cxl_pci_reset_secondary_bus,
+        .setup_msi_irqs = cxl_setup_msi_irqs,
+        .teardown_msi_irqs = cxl_teardown_msi_irqs,
+        .dma_set_mask = cxl_dma_set_mask,
+};
+
+int cxl_pci_vphb_add(struct cxl_afu *afu)
+{
+        struct pci_dev *phys_dev;
+        struct pci_controller *phb, *phys_phb;
+
+        phys_dev = to_pci_dev(afu->adapter->dev.parent);
+        phys_phb = pci_bus_to_host(phys_dev->bus);
+
+        /* Alloc and setup PHB data structure */
+        phb = pcibios_alloc_controller(phys_phb->dn);
+
+        if (!phb)
+                return -ENODEV;
+
+        /* Setup parent in sysfs */
+        phb->parent = &phys_dev->dev;
+
+        /* Setup the PHB using arch provided callback */
+        phb->ops = &cxl_pcie_pci_ops;
+        phb->cfg_addr = afu->afu_desc_mmio + afu->crs_offset;
+        phb->cfg_data = (void *)(u64)afu->crs_len;
+        phb->private_data = afu;
+        phb->controller_ops = cxl_pci_controller_ops;
+
+        /* Scan the bus */
+        pcibios_scan_phb(phb);
+        if (phb->bus == NULL)
+                return -ENXIO;
+
+        /* Claim resources. This might need some rework as well depending
+         * whether we are doing probe-only or not, like assigning unassigned
+         * resources etc...
+         */
+        pcibios_claim_one_bus(phb->bus);
+
+        /* Add probed PCI devices to the device model */
+        pci_bus_add_devices(phb->bus);
+
+        afu->phb = phb;
+
+        return 0;
+}
+
+
+void cxl_pci_vphb_remove(struct cxl_afu *afu)
+{
+        struct pci_controller *phb;
+
+        /* If there is no configuration record we won't have one of these */
+        if (!afu || !afu->phb)
+                return;
+
+        phb = afu->phb;
+
+        pci_remove_root_bus(phb->bus);
+}
+
+struct cxl_afu *cxl_pci_to_afu(struct pci_dev *dev)
+{
+        struct pci_controller *phb;
+
+        phb = pci_bus_to_host(dev->bus);
+
+        return (struct cxl_afu *)phb->private_data;
+}
+EXPORT_SYMBOL_GPL(cxl_pci_to_afu);
+
+unsigned int cxl_pci_to_cfg_record(struct pci_dev *dev)
+{
+        return cxl_pcie_cfg_record(dev->bus->number, dev->devfn);
+}
+EXPORT_SYMBOL_GPL(cxl_pci_to_cfg_record);