Merge tag 'powerpc-4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux

Pull powerpc updates from Michael Ellerman:
 "Highlights:
   - PowerNV PCI hotplug support.
   - Lots more Power9 support.
   - eBPF JIT support on ppc64le.
   - Lots of cxl updates.
   - Boot code consolidation.

  Bug fixes:
   - Fix spin_unlock_wait() from Boqun Feng
   - Fix stack pointer corruption in __tm_recheckpoint() from Michael
     Neuling
   - Fix multiple bugs in memory_hotplug_max() from Bharata B Rao
   - mm: Ensure "special" zones are empty from Oliver O'Halloran
   - ftrace: Separate the heuristics for checking call sites from
     Michael Ellerman
   - modules: Never restore r2 for a mprofile-kernel style mcount() call
     from Michael Ellerman
   - Fix endianness when reading TCEs from Alexey Kardashevskiy
   - start rtasd before PCI probing from Greg Kurz
   - PCI: rpaphp: Fix slot registration for multiple slots under a PHB
     from Tyrel Datwyler
   - powerpc/mm: Add memory barrier in __hugepte_alloc() from Sukadev
     Bhattiprolu

  Cleanups & fixes:
   - Drop support for MPIC in pseries from Rashmica Gupta
   - Define and use PPC64_ELF_ABI_v2/v1 from Michael Ellerman
   - Remove unused symbols in asm-offsets.c from Rashmica Gupta
   - Fix SRIOV not building without EEH enabled from Russell Currey
   - Remove kretprobe_trampoline_holder from Thiago Jung Bauermann
   - Reduce log level of PCI I/O space warning from Benjamin
     Herrenschmidt
   - Add array bounds checking to crash_shutdown_handlers from Suraj
     Jitindar Singh
   - Avoid -maltivec when using clang integrated assembler from Anton
     Blanchard
   - Fix array overrun in ppc_rtas() syscall from Andrew Donnellan
   - Fix error return value in cmm_mem_going_offline() from Rasmus
     Villemoes
   - export cpu_to_core_id() from Mauricio Faria de Oliveira
   - Remove old symbols from defconfigs from Andrew Donnellan
   - Update obsolete comments in setup_32.c about entry conditions from
     Benjamin Herrenschmidt
   - Add comment explaining the purpose of setup_kdump_trampoline() from
     Benjamin Herrenschmidt
   - Merge the RELOCATABLE config entries for ppc32 and ppc64 from Kevin
     Hao
   - Remove RELOCATABLE_PPC32 from Kevin Hao
   - Fix .long's in tlb-radix.c to more meaningful from Balbir Singh

  Minor cleanups & fixes:
   - Andrew Donnellan, Anna-Maria Gleixner, Anton Blanchard, Benjamin
     Herrenschmidt, Bharata B Rao, Christophe Leroy, Colin Ian King,
     Geliang Tang, Greg Kurz, Madhavan Srinivasan, Michael Ellerman,
     Michael Ellerman, Stephen Rothwell, Stewart Smith.

  Freescale updates from Scott:
   - "Highlights include more 8xx optimizations, device tree updates,
     and MVME7100 support."

  PowerNV PCI hotplug from Gavin Shan:
   - PCI: Add pcibios_setup_bridge()
   - Override pcibios_setup_bridge()
   - Remove PCI_RESET_DELAY_US
   - Move pnv_pci_ioda_setup_opal_tce_kill() around
   - Increase PE# capacity
   - Allocate PE# in reverse order
   - Create PEs in pcibios_setup_bridge()
   - Setup PE for root bus
   - Extend PCI bridge resources
   - Make pnv_ioda_deconfigure_pe() visible
   - Dynamically release PE
   - Update bridge windows on PCI plug
   - Delay populating pdn
   - Support PCI slot ID
   - Use PCI slot reset infrastructure
   - Introduce pnv_pci_get_slot_id()
   - Functions to get/set PCI slot state
   - PCI/hotplug: PowerPC PowerNV PCI hotplug driver
   - Print correct PHB type names

  Power9 idle support from Shreyas B. Prabhu:
   - set power_save func after the idle states are initialized
   - Use PNV_THREAD_WINKLE macro while requesting for winkle
   - make hypervisor state restore a function
   - Rename idle_power7.S to idle_book3s.S
   - Rename reusable idle functions to hardware agnostic names
   - Make pnv_powersave_common more generic
   - abstraction for saving SPRs before entering deep idle states
   - Add platform support for stop instruction
   - cpuidle/powernv: Use CPUIDLE_STATE_MAX instead of MAX_POWERNV_IDLE_STATES
   - cpuidle/powernv: cleanup cpuidle-powernv.c
   - cpuidle/powernv: Add support for POWER ISA v3 idle states
   - Use deepest stop state when cpu is offlined

  Power9 PMU from Madhavan Srinivasan:
   - factor out power8 pmu macros and defines
   - factor out power8 pmu functions
   - factor out power8 __init_pmu code
   - Add power9 event list macros for generic and cache events
   - Power9 PMU support
   - Export Power9 generic and cache events to sysfs

  Power9 preliminary interrupt & PCI support from Benjamin Herrenschmidt:
   - Add XICS emulation APIs
   - Move a few exception common handlers to make room
   - Add support for HV virtualization interrupts
   - Add mechanism to force a replay of interrupts
   - Add ICP OPAL backend
   - Discover IODA3 PHBs
   - pci: Remove obsolete SW invalidate
   - opal: Add real mode call wrappers
   - Rename TCE invalidation calls
   - Remove SWINV constants and obsolete TCE code
   - Rework accessing the TCE invalidate register
   - Fallback to OPAL for TCE invalidations
   - Use the device-tree to get available range of M64's
   - Check status of a PHB before using it
   - pci: Don't try to allocate resources that will be reassigned

  Other Power9:
   - Send SIGBUS on unaligned copy and paste from Chris Smart
   - Large Decrementer support from Oliver O'Halloran
   - Load Monitor Register Support from Jack Miller

  Performance improvements from Anton Blanchard:
   - Avoid load hit store in __giveup_fpu() and __giveup_altivec()
   - Avoid load hit store in setup_sigcontext()
   - Remove assembly versions of strcpy, strcat, strlen and strcmp
   - Align hot loops of some string functions

  eBPF JIT from Naveen N. Rao:
   - Fix/enhance 32-bit Load Immediate implementation
   - Optimize 64-bit Immediate loads
   - Introduce rotate immediate instructions
   - A few cleanups
   - Isolate classic BPF JIT specifics into a separate header
   - Implement JIT compiler for extended BPF

  Operator Panel driver from Suraj Jitindar Singh:
   - devicetree/bindings: Add binding for operator panel on FSP machines
   - Add inline function to get rc from an ASYNC_COMP opal_msg
   - Add driver for operator panel on FSP machines

  Sparse fixes from Daniel Axtens:
   - make some things static
   - Introduce asm-prototypes.h
   - Include headers containing prototypes
   - Use #ifdef __BIG_ENDIAN__ #else for REG_BYTE
   - kvm: Clarify __user annotations
   - Pass endianness to sparse
   - Make ppc_md.{halt, restart} __noreturn

  MM fixes & cleanups from Aneesh Kumar K.V:
   - radix: Update LPCR HR bit as per ISA
   - use _raw variant of page table accessors
   - Compile out radix related functions if RADIX_MMU is disabled
   - Clear top 16 bits of va only on older cpus
   - Print formation regarding the the MMU mode
   - hash: Update SDR1 size encoding as documented in ISA 3.0
   - radix: Update PID switch sequence
   - radix: Update machine call back to support new HCALL.
   - radix: Add LPID based tlb flush helpers
   - radix: Add a kernel command line to disable radix
   - Cleanup LPCR defines

  Boot code consolidation from Benjamin Herrenschmidt:
   - Move epapr_paravirt_early_init() to early_init_devtree()
   - cell: Don't use flat device-tree after boot
   - ge_imp3a: Don't use the flat device-tree after boot
   - mpc85xx_ds: Don't use the flat device-tree after boot
   - mpc85xx_rdb: Don't use the flat device-tree after boot
   - Don't test for machine type in rtas_initialize()
   - Don't test for machine type in smp_setup_cpu_maps()
   - dt: Add of_device_compatible_match()
   - Factor do_feature_fixup calls
   - Move 64-bit feature fixup earlier
   - Move 64-bit memory reserves to setup_arch()
   - Use a cachable DART
   - Move FW feature probing out of pseries probe()
   - Put exception configuration in a common place
   - Remove early allocation of the SMU command buffer
   - Move MMU backend selection out of platform code
   - pasemi: Remove IOBMAP allocation from platform probe()
   - mm/hash: Don't use machine_is() early during boot
   - Don't test for machine type to detect HEA special case
   - pmac: Remove spurrious machine type test
   - Move hash table ops to a separate structure
   - Ensure that ppc_md is empty before probing for machine type
   - Move 64-bit probe_machine() to later in the boot process
   - Move 32-bit probe() machine to later in the boot process
   - Get rid of ppc_md.init_early()
   - Move the boot time info banner to a separate function
   - Move setting of {i,d}cache_bsize to initialize_cache_info()
   - Move the content of setup_system() to setup_arch()
   - Move cache info inits to a separate function
   - Re-order the call to smp_setup_cpu_maps()
   - Re-order setup_panic()
   - Make a few boot functions __init
   - Merge 32-bit and 64-bit setup_arch()

  Other new features:
   - tty/hvc: Use IRQF_SHARED for OPAL hvc consoles from Sam Mendoza-Jonas
   - tty/hvc: Use opal irqchip interface if available from Sam Mendoza-Jonas
   - powerpc: Add module autoloading based on CPU features from Alastair D'Silva
   - crypto: vmx - Convert to CPU feature based module autoloading from Alastair D'Silva
   - Wake up kopald polling thread before waiting for events from Benjamin Herrenschmidt
   - xmon: Dump ISA 2.06 SPRs from Michael Ellerman
   - xmon: Dump ISA 2.07 SPRs from Michael Ellerman
   - Add a parameter to disable 1TB segs from Oliver O'Halloran
   - powerpc/boot: Add OPAL console to epapr wrappers from Oliver O'Halloran
   - Assign fixed PHB number based on device-tree properties from Guilherme G. Piccoli
   - pseries: Add pseries hotplug workqueue from John Allen
   - pseries: Add support for hotplug interrupt source from John Allen
   - pseries: Use kernel hotplug queue for PowerVM hotplug events from John Allen
   - pseries: Move property cloning into its own routine from Nathan Fontenot
   - pseries: Dynamic add entires to associativity lookup array from Nathan Fontenot
   - pseries: Auto-online hotplugged memory from Nathan Fontenot
   - pseries: Remove call to memblock_add() from Nathan Fontenot

  cxl:
   - Add set and get private data to context struct from Michael Neuling
   - make base more explicitly non-modular from Paul Gortmaker
   - Use for_each_compatible_node() macro from Wei Yongjun
   - Frederic Barrat
   - Abstract the differences between the PSL and XSL
   - Make vPHB device node match adapter's
   - Philippe Bergheaud
   - Add mechanism for delivering AFU driver specific events
   - Ignore CAPI adapters misplaced in switched slots
   - Refine slice error debug messages
   - Andrew Donnellan
   - static-ify variables to fix sparse warnings
   - PCI/hotplug: pnv_php: export symbols and move struct types needed by cxl
   - PCI/hotplug: pnv_php: handle OPAL_PCI_SLOT_OFFLINE power state
   - Add cxl_check_and_switch_mode() API to switch bi-modal cards
   - remove dead Kconfig options
   - fix potential NULL dereference in free_adapter()
   - Ian Munsie
   - Update process element after allocating interrupts
   - Add support for CAPP DMA mode
   - Fix allowing bogus AFU descriptors with 0 maximum processes
   - Fix allocating a minimum of 2 pages for the SPA
   - Fix bug where AFU disable operation had no effect
   - Workaround XSL bug that does not clear the RA bit after a reset
   - Fix NULL pointer dereference on kernel contexts with no AFU interrupts
   - powerpc/powernv: Split cxl code out into a separate file
   - Add cxl_slot_is_supported API
   - Enable bus mastering for devices using CAPP DMA mode
   - Move cxl_afu_get / cxl_afu_put to base
   - Allow a default context to be associated with an external pci_dev
   - Do not create vPHB if there are no AFU configuration records
   - powerpc/powernv: Add support for the cxl kernel api on the real phb
   - Add support for using the kernel API with a real PHB
   - Add kernel APIs to get & set the max irqs per context
   - Add preliminary workaround for CX4 interrupt limitation
   - Add support for interrupts on the Mellanox CX4
   - Workaround PE=0 hardware limitation in Mellanox CX4
   - powerpc/powernv: Fix pci-cxl.c build when CONFIG_MODULES=n

  selftests:
   - Test unaligned copy and paste from Chris Smart
   - Load Monitor Register Tests from Jack Miller
   - Cyril Bur
   - exec() with suspended transaction
   - Use signed long to read perf_event_paranoid
   - Fix usage message in context_switch
   - Fix generation of vector instructions/types in context_switch
   - Michael Ellerman
   - Use "Delta" rather than "Error" in normal output
   - Import Anton's mmap & futex micro benchmarks
   - Add a test for PROT_SAO"

* tag 'powerpc-4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (263 commits)
  powerpc/mm: Parenthesise IS_ENABLED() in if condition
  tty/hvc: Use opal irqchip interface if available
  tty/hvc: Use IRQF_SHARED for OPAL hvc consoles
  selftests/powerpc: exec() with suspended transaction
  powerpc: Improve comment explaining why we modify VRSAVE
  powerpc/mm: Drop unused externs for hpte_init_beat[_v3]()
  powerpc/mm: Rename hpte_init_lpar() and move the fallback to a header
  powerpc/mm: Fix build break when PPC_NATIVE=n
  crypto: vmx - Convert to CPU feature based module autoloading
  powerpc: Add module autoloading based on CPU features
  powerpc/powernv/ioda: Fix endianness when reading TCEs
  powerpc/mm: Add memory barrier in __hugepte_alloc()
  powerpc/modules: Never restore r2 for a mprofile-kernel style mcount() call
  powerpc/ftrace: Separate the heuristics for checking call sites
  powerpc: Merge 32-bit and 64-bit setup_arch()
  powerpc/64: Make a few boot functions __init
  powerpc: Re-order setup_panic()
  powerpc: Re-order the call to smp_setup_cpu_maps()
  powerpc/32: Move cache info inits to a separate function
  powerpc/64: Move the content of setup_system() to setup_arch()
  ...

1 files changed, 165 insertions, 42 deletions

diff --git a/drivers/misc/cxl/native.c b/drivers/misc/cxl/native.c
index 55d8a1459f28..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;
@@ -430,7 +442,6 @@ static int remove_process_element(struct cxl_context *ctx)
         return rc;
 }
 
-
 void cxl_assign_psn_space(struct cxl_context *ctx)
 {
         if (!ctx->afu->pp_size || ctx->master) {
@@ -507,10 +518,39 @@ static u64 calculate_sr(struct cxl_context *ctx)
         return sr;
 }
 
+static void update_ivtes_directed(struct cxl_context *ctx)
+{
+        bool need_update = (ctx->status == STARTED);
+        int r;
+
+        if (need_update) {
+                WARN_ON(terminate_process_element(ctx));
+                WARN_ON(remove_process_element(ctx));
+        }
+
+        for (r = 0; r < CXL_IRQ_RANGES; r++) {
+                ctx->elem->ivte_offsets[r] = cpu_to_be16(ctx->irqs.offset[r]);
+                ctx->elem->ivte_ranges[r] = cpu_to_be16(ctx->irqs.range[r]);
+        }
+
+        /*
+         * Theoretically we could use the update llcmd, instead of a
+         * terminate/remove/add (or if an atomic update was required we could
+         * do a suspend/update/resume), however it seems there might be issues
+         * with the update llcmd on some cards (including those using an XSL on
+         * an ASIC) so for now it's safest to go with the commands that are
+         * known to work. In the future if we come across a situation where the
+         * card may be performing transactions using the same PE while we are
+         * doing this update we might need to revisit this.
+         */
+        if (need_update)
+                WARN_ON(add_process_element(ctx));
+}
+
 static int attach_afu_directed(struct cxl_context *ctx, u64 wed, u64 amr)
 {
         u32 pid;
-        int r, result;
+        int result;
 
         cxl_assign_psn_space(ctx);
 
@@ -545,10 +585,7 @@ static int attach_afu_directed(struct cxl_context *ctx, u64 wed, u64 amr)
                 ctx->irqs.range[0] = 1;
         }
 
-        for (r = 0; r < CXL_IRQ_RANGES; r++) {
-                ctx->elem->ivte_offsets[r] = cpu_to_be16(ctx->irqs.offset[r]);
-                ctx->elem->ivte_ranges[r] = cpu_to_be16(ctx->irqs.range[r]);
-        }
+        update_ivtes_directed(ctx);
 
         ctx->elem->common.amr = cpu_to_be64(amr);
         ctx->elem->common.wed = cpu_to_be64(wed);
@@ -570,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);
 
@@ -600,6 +663,22 @@ static int activate_dedicated_process(struct cxl_afu *afu)
         return cxl_chardev_d_afu_add(afu);
 }
 
+static void update_ivtes_dedicated(struct cxl_context *ctx)
+{
+        struct cxl_afu *afu = ctx->afu;
+
+        cxl_p1n_write(afu, CXL_PSL_IVTE_Offset_An,
+                       (((u64)ctx->irqs.offset[0] & 0xffff) << 48) |
+                       (((u64)ctx->irqs.offset[1] & 0xffff) << 32) |
+                       (((u64)ctx->irqs.offset[2] & 0xffff) << 16) |
+                        ((u64)ctx->irqs.offset[3] & 0xffff));
+        cxl_p1n_write(afu, CXL_PSL_IVTE_Limit_An, (u64)
+                       (((u64)ctx->irqs.range[0] & 0xffff) << 48) |
+                       (((u64)ctx->irqs.range[1] & 0xffff) << 32) |
+                       (((u64)ctx->irqs.range[2] & 0xffff) << 16) |
+                        ((u64)ctx->irqs.range[3] & 0xffff));
+}
+
 static int attach_dedicated(struct cxl_context *ctx, u64 wed, u64 amr)
 {
         struct cxl_afu *afu = ctx->afu;
@@ -618,16 +697,7 @@ static int attach_dedicated(struct cxl_context *ctx, u64 wed, u64 amr)
 
         cxl_prefault(ctx, wed);
 
-        cxl_p1n_write(afu, CXL_PSL_IVTE_Offset_An,
-                       (((u64)ctx->irqs.offset[0] & 0xffff) << 48) |
-                       (((u64)ctx->irqs.offset[1] & 0xffff) << 32) |
-                       (((u64)ctx->irqs.offset[2] & 0xffff) << 16) |
-                        ((u64)ctx->irqs.offset[3] & 0xffff));
-        cxl_p1n_write(afu, CXL_PSL_IVTE_Limit_An, (u64)
-                       (((u64)ctx->irqs.range[0] & 0xffff) << 48) |
-                       (((u64)ctx->irqs.range[1] & 0xffff) << 32) |
-                       (((u64)ctx->irqs.range[2] & 0xffff) << 16) |
-                        ((u64)ctx->irqs.range[3] & 0xffff));
+        update_ivtes_dedicated(ctx);
 
         cxl_p2n_write(afu, CXL_PSL_AMR_An, amr);
 
@@ -703,12 +773,37 @@ 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);
         return 0;
 }
 
+static void native_update_ivtes(struct cxl_context *ctx)
+{
+        if (ctx->afu->current_mode == CXL_MODE_DIRECTED)
+                return update_ivtes_directed(ctx);
+        if (ctx->afu->current_mode == CXL_MODE_DEDICATED)
+                return update_ivtes_dedicated(ctx);
+        WARN(1, "native_update_ivtes: Bad mode\n");
+}
+
 static inline int detach_process_native_afu_directed(struct cxl_context *ctx)
 {
         if (!ctx->pe_inserted)
@@ -754,26 +849,38 @@ static int native_get_irq_info(struct cxl_afu *afu, struct cxl_irq_info *info)
         return 0;
 }
 
-static irqreturn_t native_handle_psl_slice_error(struct cxl_context *ctx,
-                                                u64 dsisr, u64 errstat)
+void cxl_native_psl_irq_dump_regs(struct cxl_context *ctx)
 {
         u64 fir1, fir2, fir_slice, serr, afu_debug;
 
         fir1 = cxl_p1_read(ctx->afu->adapter, CXL_PSL_FIR1);
         fir2 = cxl_p1_read(ctx->afu->adapter, CXL_PSL_FIR2);
         fir_slice = cxl_p1n_read(ctx->afu, CXL_PSL_FIR_SLICE_An);
-        serr = cxl_p1n_read(ctx->afu, CXL_PSL_SERR_An);
         afu_debug = cxl_p1n_read(ctx->afu, CXL_AFU_DEBUG_An);
 
-        dev_crit(&ctx->afu->dev, "PSL ERROR STATUS: 0x%016llx\n", errstat);
         dev_crit(&ctx->afu->dev, "PSL_FIR1: 0x%016llx\n", fir1);
         dev_crit(&ctx->afu->dev, "PSL_FIR2: 0x%016llx\n", fir2);
-        dev_crit(&ctx->afu->dev, "PSL_SERR_An: 0x%016llx\n", serr);
+        if (ctx->afu->adapter->native->sl_ops->register_serr_irq) {
+                serr = cxl_p1n_read(ctx->afu, CXL_PSL_SERR_An);
+                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);
+}
+
+static irqreturn_t native_handle_psl_slice_error(struct cxl_context *ctx,
+                                                u64 dsisr, u64 errstat)
+{
+
+        dev_crit(&ctx->afu->dev, "PSL ERROR STATUS: 0x%016llx\n", errstat);
 
-        dev_crit(&ctx->afu->dev, "STOPPING CXL TRACE\n");
-        cxl_stop_trace(ctx->afu->adapter);
+        if (ctx->afu->adapter->native->sl_ops->psl_irq_dump_registers)
+                ctx->afu->adapter->native->sl_ops->psl_irq_dump_registers(ctx);
+
+        if (ctx->afu->adapter->native->sl_ops->debugfs_stop_trace) {
+                dev_crit(&ctx->afu->dev, "STOPPING CXL TRACE\n");
+                ctx->afu->adapter->native->sl_ops->debugfs_stop_trace(ctx->afu->adapter);
+        }
 
         return cxl_ops->ack_irq(ctx, 0, errstat);
 }
@@ -849,41 +956,56 @@ 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;
-
-        WARN(irq, "CXL SLICE ERROR interrupt %i\n", irq);
+        u64 fir_slice, errstat, serr, afu_debug, afu_error, dsisr;
 
+        /*
+         * slice err interrupt is only used with full PSL (no XSL)
+         */
         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);
 
         return IRQ_HANDLED;
 }
 
+void cxl_native_err_irq_dump_regs(struct cxl *adapter)
+{
+        u64 fir1, fir2;
+
+        fir1 = cxl_p1_read(adapter, CXL_PSL_FIR1);
+        fir2 = cxl_p1_read(adapter, CXL_PSL_FIR2);
+
+        dev_crit(&adapter->dev, "PSL_FIR1: 0x%016llx\nPSL_FIR2: 0x%016llx\n", fir1, fir2);
+}
+
 static irqreturn_t native_irq_err(int irq, void *data)
 {
         struct cxl *adapter = data;
-        u64 fir1, fir2, err_ivte;
+        u64 err_ivte;
 
         WARN(1, "CXL ERROR interrupt %i\n", irq);
 
         err_ivte = cxl_p1_read(adapter, CXL_PSL_ErrIVTE);
         dev_crit(&adapter->dev, "PSL_ErrIVTE: 0x%016llx\n", err_ivte);
 
-        dev_crit(&adapter->dev, "STOPPING CXL TRACE\n");
-        cxl_stop_trace(adapter);
-
-        fir1 = cxl_p1_read(adapter, CXL_PSL_FIR1);
-        fir2 = cxl_p1_read(adapter, CXL_PSL_FIR2);
+        if (adapter->native->sl_ops->debugfs_stop_trace) {
+                dev_crit(&adapter->dev, "STOPPING CXL TRACE\n");
+                adapter->native->sl_ops->debugfs_stop_trace(adapter);
+        }
 
-        dev_crit(&adapter->dev, "PSL_FIR1: 0x%016llx\nPSL_FIR2: 0x%016llx\n", fir1, fir2);
+        if (adapter->native->sl_ops->err_irq_dump_registers)
+                adapter->native->sl_ops->err_irq_dump_registers(adapter);
 
         return IRQ_HANDLED;
 }
@@ -1128,6 +1250,7 @@ const struct cxl_backend_ops cxl_native_ops = {
         .irq_wait = native_irq_wait,
         .attach_process = native_attach_process,
         .detach_process = native_detach_process,
+        .update_ivtes = native_update_ivtes,
         .support_attributes = native_support_attributes,
         .link_ok = cxl_adapter_link_ok,
         .release_afu = cxl_pci_release_afu,