1 files changed, 69 insertions, 13 deletions

diff --git a/drivers/misc/cxl/native.c b/drivers/misc/cxl/native.c
index e80d8f7d4dcb..3bcdaee11ba1 100644
--- a/drivers/misc/cxl/native.c
+++ b/drivers/misc/cxl/native.c
@@ -21,10 +21,10 @@
 #include "cxl.h"
 #include "trace.h"
 
-static int afu_control(struct cxl_afu *afu, u64 command,
+static int afu_control(struct cxl_afu *afu, u64 command, u64 clear,
                        u64 result, u64 mask, bool enabled)
 {
-        u64 AFU_Cntl = cxl_p2n_read(afu, CXL_AFU_Cntl_An);
+        u64 AFU_Cntl;
         unsigned long timeout = jiffies + (HZ * CXL_TIMEOUT);
         int rc = 0;
 
@@ -33,7 +33,8 @@ static int afu_control(struct cxl_afu *afu, u64 command,
 
         trace_cxl_afu_ctrl(afu, command);
 
-        cxl_p2n_write(afu, CXL_AFU_Cntl_An, AFU_Cntl | command);
+        AFU_Cntl = cxl_p2n_read(afu, CXL_AFU_Cntl_An);
+        cxl_p2n_write(afu, CXL_AFU_Cntl_An, (AFU_Cntl & ~clear) | command);
 
         AFU_Cntl = cxl_p2n_read(afu, CXL_AFU_Cntl_An);
         while ((AFU_Cntl & mask) != result) {
@@ -54,6 +55,16 @@ static int afu_control(struct cxl_afu *afu, u64 command,
                 cpu_relax();
                 AFU_Cntl = cxl_p2n_read(afu, CXL_AFU_Cntl_An);
         };
+
+        if (AFU_Cntl & CXL_AFU_Cntl_An_RA) {
+                /*
+                 * Workaround for a bug in the XSL used in the Mellanox CX4
+                 * that fails to clear the RA bit after an AFU reset,
+                 * preventing subsequent AFU resets from working.
+                 */
+                cxl_p2n_write(afu, CXL_AFU_Cntl_An, AFU_Cntl & ~CXL_AFU_Cntl_An_RA);
+        }
+
         pr_devel("AFU command complete: %llx\n", command);
         afu->enabled = enabled;
 out:
@@ -67,7 +78,7 @@ static int afu_enable(struct cxl_afu *afu)
 {
         pr_devel("AFU enable request\n");
 
-        return afu_control(afu, CXL_AFU_Cntl_An_E,
+        return afu_control(afu, CXL_AFU_Cntl_An_E, 0,
                            CXL_AFU_Cntl_An_ES_Enabled,
                            CXL_AFU_Cntl_An_ES_MASK, true);
 }
@@ -76,7 +87,8 @@ int cxl_afu_disable(struct cxl_afu *afu)
 {
         pr_devel("AFU disable request\n");
 
-        return afu_control(afu, 0, CXL_AFU_Cntl_An_ES_Disabled,
+        return afu_control(afu, 0, CXL_AFU_Cntl_An_E,
+                           CXL_AFU_Cntl_An_ES_Disabled,
                            CXL_AFU_Cntl_An_ES_MASK, false);
 }
 
@@ -85,7 +97,7 @@ static int native_afu_reset(struct cxl_afu *afu)
 {
         pr_devel("AFU reset request\n");
 
-        return afu_control(afu, CXL_AFU_Cntl_An_RA,
+        return afu_control(afu, CXL_AFU_Cntl_An_RA, 0,
                            CXL_AFU_Cntl_An_RS_Complete | CXL_AFU_Cntl_An_ES_Disabled,
                            CXL_AFU_Cntl_An_RS_MASK | CXL_AFU_Cntl_An_ES_MASK,
                            false);
@@ -189,7 +201,7 @@ int cxl_alloc_spa(struct cxl_afu *afu)
         unsigned spa_size;
 
         /* Work out how many pages to allocate */
-        afu->native->spa_order = 0;
+        afu->native->spa_order = -1;
         do {
                 afu->native->spa_order++;
                 spa_size = (1 << afu->native->spa_order) * PAGE_SIZE;
@@ -595,7 +607,33 @@ static int deactivate_afu_directed(struct cxl_afu *afu)
         cxl_sysfs_afu_m_remove(afu);
         cxl_chardev_afu_remove(afu);
 
-        cxl_ops->afu_reset(afu);
+        /*
+         * The CAIA section 2.2.1 indicates that the procedure for starting and
+         * stopping an AFU in AFU directed mode is AFU specific, which is not
+         * ideal since this code is generic and with one exception has no
+         * knowledge of the AFU. This is in contrast to the procedure for
+         * disabling a dedicated process AFU, which is documented to just
+         * require a reset. The architecture does indicate that both an AFU
+         * reset and an AFU disable should result in the AFU being disabled and
+         * we do both followed by a PSL purge for safety.
+         *
+         * Notably we used to have some issues with the disable sequence on PSL
+         * cards, which is why we ended up using this heavy weight procedure in
+         * the first place, however a bug was discovered that had rendered the
+         * disable operation ineffective, so it is conceivable that was the
+         * sole explanation for those difficulties. Careful regression testing
+         * is recommended if anyone attempts to remove or reorder these
+         * operations.
+         *
+         * The XSL on the Mellanox CX4 behaves a little differently from the
+         * PSL based cards and will time out an AFU reset if the AFU is still
+         * enabled. That card is special in that we do have a means to identify
+         * it from this code, so in that case we skip the reset and just use a
+         * disable/purge to avoid the timeout and corresponding noise in the
+         * kernel log.
+         */
+        if (afu->adapter->native->sl_ops->needs_reset_before_disable)
+                cxl_ops->afu_reset(afu);
         cxl_afu_disable(afu);
         cxl_psl_purge(afu);
 
@@ -735,6 +773,22 @@ static int native_attach_process(struct cxl_context *ctx, bool kernel,
 
 static inline int detach_process_native_dedicated(struct cxl_context *ctx)
 {
+        /*
+         * The CAIA section 2.1.1 indicates that we need to do an AFU reset to
+         * stop the AFU in dedicated mode (we therefore do not make that
+         * optional like we do in the afu directed path). It does not indicate
+         * that we need to do an explicit disable (which should occur
+         * implicitly as part of the reset) or purge, but we do these as well
+         * to be on the safe side.
+         *
+         * Notably we used to have some issues with the disable sequence
+         * (before the sequence was spelled out in the architecture) which is
+         * why we were so heavy weight in the first place, however a bug was
+         * discovered that had rendered the disable operation ineffective, so
+         * it is conceivable that was the sole explanation for those
+         * difficulties. Point is, we should be careful and do some regression
+         * testing if we ever attempt to remove any part of this procedure.
+         */
         cxl_ops->afu_reset(ctx->afu);
         cxl_afu_disable(ctx->afu);
         cxl_psl_purge(ctx->afu);
@@ -808,7 +862,7 @@ void cxl_native_psl_irq_dump_regs(struct cxl_context *ctx)
         dev_crit(&ctx->afu->dev, "PSL_FIR2: 0x%016llx\n", fir2);
         if (ctx->afu->adapter->native->sl_ops->register_serr_irq) {
                 serr = cxl_p1n_read(ctx->afu, CXL_PSL_SERR_An);
-                dev_crit(&ctx->afu->dev, "PSL_SERR_An: 0x%016llx\n", serr);
+                cxl_afu_decode_psl_serr(ctx->afu, serr);
         }
         dev_crit(&ctx->afu->dev, "PSL_FIR_SLICE_An: 0x%016llx\n", fir_slice);
         dev_crit(&ctx->afu->dev, "CXL_PSL_AFU_DEBUG_An: 0x%016llx\n", afu_debug);
@@ -902,21 +956,23 @@ void native_irq_wait(struct cxl_context *ctx)
 static irqreturn_t native_slice_irq_err(int irq, void *data)
 {
         struct cxl_afu *afu = data;
-        u64 fir_slice, errstat, serr, afu_debug;
+        u64 fir_slice, errstat, serr, afu_debug, afu_error, dsisr;
 
         /*
          * slice err interrupt is only used with full PSL (no XSL)
          */
-        WARN(irq, "CXL SLICE ERROR interrupt %i\n", irq);
-
         serr = cxl_p1n_read(afu, CXL_PSL_SERR_An);
         fir_slice = cxl_p1n_read(afu, CXL_PSL_FIR_SLICE_An);
         errstat = cxl_p2n_read(afu, CXL_PSL_ErrStat_An);
         afu_debug = cxl_p1n_read(afu, CXL_AFU_DEBUG_An);
-        dev_crit(&afu->dev, "PSL_SERR_An: 0x%016llx\n", serr);
+        afu_error = cxl_p2n_read(afu, CXL_AFU_ERR_An);
+        dsisr = cxl_p2n_read(afu, CXL_PSL_DSISR_An);
+        cxl_afu_decode_psl_serr(afu, serr);
         dev_crit(&afu->dev, "PSL_FIR_SLICE_An: 0x%016llx\n", fir_slice);
         dev_crit(&afu->dev, "CXL_PSL_ErrStat_An: 0x%016llx\n", errstat);
         dev_crit(&afu->dev, "CXL_PSL_AFU_DEBUG_An: 0x%016llx\n", afu_debug);
+        dev_crit(&afu->dev, "AFU_ERR_An: 0x%.16llx\n", afu_error);
+        dev_crit(&afu->dev, "PSL_DSISR_An: 0x%.16llx\n", dsisr);
 
         cxl_p1n_write(afu, CXL_PSL_SERR_An, serr);