+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-#ifndef _ASM_POWERPC_DEBUGFS_H
-#define _ASM_POWERPC_DEBUGFS_H
-
-/*
- * Copyright 2017, Michael Ellerman, IBM Corporation.
- */
-
-#include <linux/debugfs.h>
-
-extern struct dentry *powerpc_debugfs_root;
-
-#endif /* _ASM_POWERPC_DEBUGFS_H */
 
                                   prom.o traps.o setup-common.o \
                                   udbg.o misc.o io.o misc_$(BITS).o \
                                   of_platform.o prom_parse.o firmware.o \
-                                  hw_breakpoint_constraints.o interrupt.o
+                                  hw_breakpoint_constraints.o interrupt.o \
+                                  kdebugfs.o
 obj-y                          += ptrace/
 obj-$(CONFIG_PPC64)            += setup_64.o \
                                   paca.o nvram_64.o note.o
 
 #include <linux/export.h>
 #include <linux/fs.h>
 #include <linux/debugfs.h>
-#include <asm/debugfs.h>
 #include <asm/machdep.h>
 #include <asm/hvcall.h>
 
        if (PVR_VER(mfspr(SPRN_PVR)) == PVR_POWER9) {
                /* Turn DAWR off by default, but allow admin to turn it on */
                debugfs_create_file_unsafe("dawr_enable_dangerous", 0600,
-                                          powerpc_debugfs_root,
+                                          arch_debugfs_dir,
                                           &dawr_force_enable,
                                           &dawr_enable_fops);
        }
 
 #include <linux/spinlock.h>
 #include <linux/export.h>
 #include <linux/of.h>
+#include <linux/debugfs.h>
 
 #include <linux/atomic.h>
-#include <asm/debugfs.h>
 #include <asm/eeh.h>
 #include <asm/eeh_event.h>
 #include <asm/io.h>
                proc_create_single("powerpc/eeh", 0, NULL, proc_eeh_show);
 #ifdef CONFIG_DEBUG_FS
                debugfs_create_file_unsafe("eeh_enable", 0600,
-                                          powerpc_debugfs_root, NULL,
+                                          arch_debugfs_dir, NULL,
                                           &eeh_enable_dbgfs_ops);
                debugfs_create_u32("eeh_max_freezes", 0600,
-                               powerpc_debugfs_root, &eeh_max_freezes);
+                               arch_debugfs_dir, &eeh_max_freezes);
                debugfs_create_bool("eeh_disable_recovery", 0600,
-                               powerpc_debugfs_root,
+                               arch_debugfs_dir,
                                &eeh_debugfs_no_recover);
                debugfs_create_file_unsafe("eeh_dev_check", 0600,
-                               powerpc_debugfs_root, NULL,
+                               arch_debugfs_dir, NULL,
                                &eeh_dev_check_fops);
                debugfs_create_file_unsafe("eeh_dev_break", 0600,
-                               powerpc_debugfs_root, NULL,
+                               arch_debugfs_dir, NULL,
                                &eeh_dev_break_fops);
                debugfs_create_file_unsafe("eeh_force_recover", 0600,
-                               powerpc_debugfs_root, NULL,
+                               arch_debugfs_dir, NULL,
                                &eeh_force_recover_fops);
                debugfs_create_file_unsafe("eeh_dev_can_recover", 0600,
-                               powerpc_debugfs_root, NULL,
+                               arch_debugfs_dir, NULL,
                                &eeh_dev_can_recover_fops);
                eeh_cache_debugfs_init();
 #endif
 
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/atomic.h>
+#include <linux/debugfs.h>
 #include <asm/pci-bridge.h>
-#include <asm/debugfs.h>
 #include <asm/ppc-pci.h>
 
 
 void eeh_cache_debugfs_init(void)
 {
        debugfs_create_file_unsafe("eeh_address_cache", 0400,
-                       powerpc_debugfs_root, NULL,
+                       arch_debugfs_dir, NULL,
                        &eeh_addr_cache_fops);
 }
 
 #include <linux/slab.h>
 #include <linux/cma.h>
 #include <linux/hugetlb.h>
+#include <linux/debugfs.h>
 
-#include <asm/debugfs.h>
 #include <asm/page.h>
 #include <asm/prom.h>
 #include <asm/fadump.h>
                return;
        }
 
-       debugfs_create_file("fadump_region", 0444, powerpc_debugfs_root, NULL,
+       debugfs_create_file("fadump_region", 0444, arch_debugfs_dir, NULL,
                            &fadump_region_fops);
 
        if (fw_dump.dump_active) {
 
 #include <asm/processor.h>
 #include <asm/sstep.h>
 #include <asm/debug.h>
-#include <asm/debugfs.h>
 #include <asm/hvcall.h>
 #include <asm/inst.h>
 #include <linux/uaccess.h>
 
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/debugfs.h>
+#include <linux/export.h>
+#include <linux/init.h>
+
+struct dentry *arch_debugfs_dir;
+EXPORT_SYMBOL(arch_debugfs_dir);
+
+static int __init arch_kdebugfs_init(void)
+{
+       arch_debugfs_dir = debugfs_create_dir("powerpc", NULL);
+       return 0;
+}
+arch_initcall(arch_kdebugfs_init);
 
 #include <linux/nospec.h>
 #include <linux/prctl.h>
 #include <linux/seq_buf.h>
+#include <linux/debugfs.h>
 
 #include <asm/asm-prototypes.h>
 #include <asm/code-patching.h>
-#include <asm/debugfs.h>
 #include <asm/security_features.h>
 #include <asm/setup.h>
 #include <asm/inst.h>
 static __init int barrier_nospec_debugfs_init(void)
 {
        debugfs_create_file_unsafe("barrier_nospec", 0600,
-                                  powerpc_debugfs_root, NULL,
+                                  arch_debugfs_dir, NULL,
                                   &fops_barrier_nospec);
        return 0;
 }
 
 static __init int security_feature_debugfs_init(void)
 {
-       debugfs_create_x64("security_features", 0400, powerpc_debugfs_root,
+       debugfs_create_x64("security_features", 0400, arch_debugfs_dir,
                           &powerpc_security_features);
        return 0;
 }
 
 static __init int stf_barrier_debugfs_init(void)
 {
-       debugfs_create_file_unsafe("stf_barrier", 0600, powerpc_debugfs_root,
+       debugfs_create_file_unsafe("stf_barrier", 0600, arch_debugfs_dir,
                                   NULL, &fops_stf_barrier);
        return 0;
 }
 static __init int count_cache_flush_debugfs_init(void)
 {
        debugfs_create_file_unsafe("count_cache_flush", 0600,
-                                  powerpc_debugfs_root, NULL,
+                                  arch_debugfs_dir, NULL,
                                   &fops_count_cache_flush);
        return 0;
 }
 
 static __init int rfi_flush_debugfs_init(void)
 {
-       debugfs_create_file("rfi_flush", 0600, powerpc_debugfs_root, NULL, &fops_rfi_flush);
-       debugfs_create_file("entry_flush", 0600, powerpc_debugfs_root, NULL, &fops_entry_flush);
-       debugfs_create_file("uaccess_flush", 0600, powerpc_debugfs_root, NULL, &fops_uaccess_flush);
+       debugfs_create_file("rfi_flush", 0600, arch_debugfs_dir, NULL, &fops_rfi_flush);
+       debugfs_create_file("entry_flush", 0600, arch_debugfs_dir, NULL, &fops_entry_flush);
+       debugfs_create_file("uaccess_flush", 0600, arch_debugfs_dir, NULL, &fops_uaccess_flush);
        return 0;
 }
 device_initcall(rfi_flush_debugfs_init);
 
 #include <linux/of_platform.h>
 #include <linux/hugetlb.h>
 #include <linux/pgtable.h>
-#include <asm/debugfs.h>
 #include <asm/io.h>
 #include <asm/paca.h>
 #include <asm/prom.h>
 late_initcall(check_cache_coherency);
 #endif /* CONFIG_CHECK_CACHE_COHERENCY */
 
-#ifdef CONFIG_DEBUG_FS
-struct dentry *powerpc_debugfs_root;
-EXPORT_SYMBOL(powerpc_debugfs_root);
-
-static int powerpc_debugfs_init(void)
-{
-       powerpc_debugfs_root = debugfs_create_dir("powerpc", NULL);
-       return 0;
-}
-arch_initcall(powerpc_debugfs_init);
-#endif
-
 void ppc_printk_progress(char *s, unsigned short hex)
 {
        pr_info("%s\n", s);
 
 #include <linux/nmi.h>
 #include <linux/pgtable.h>
 
-#include <asm/debugfs.h>
 #include <asm/kvm_guest.h>
 #include <asm/io.h>
 #include <asm/kdump.h>
 
 #include <linux/smp.h>
 #include <linux/console.h>
 #include <linux/kmsg_dump.h>
+#include <linux/debugfs.h>
 
 #include <asm/emulated_ops.h>
 #include <linux/uaccess.h>
-#include <asm/debugfs.h>
 #include <asm/interrupt.h>
 #include <asm/io.h>
 #include <asm/machdep.h>
        struct ppc_emulated_entry *entries = (void *)&ppc_emulated;
 
        dir = debugfs_create_dir("emulated_instructions",
-                                powerpc_debugfs_root);
+                                arch_debugfs_dir);
 
        debugfs_create_u32("do_warn", 0644, dir, &ppc_warn_emulated);
 
 
 #include <linux/gfp.h>
 #include <linux/anon_inodes.h>
 #include <linux/spinlock.h>
-
+#include <linux/debugfs.h>
 #include <linux/uaccess.h>
+
 #include <asm/kvm_book3s.h>
 #include <asm/kvm_ppc.h>
 #include <asm/hvcall.h>
 #include <asm/xics.h>
-#include <asm/debugfs.h>
 #include <asm/time.h>
 
 #include <linux/seq_file.h>
                return;
        }
 
-       xics->dentry = debugfs_create_file(name, 0444, powerpc_debugfs_root,
+       xics->dentry = debugfs_create_file(name, 0444, arch_debugfs_dir,
                                           xics, &xics_debug_fops);
 
        pr_debug("%s: created %s\n", __func__, name);
 
 #include <asm/xive.h>
 #include <asm/xive-regs.h>
 #include <asm/debug.h>
-#include <asm/debugfs.h>
 #include <asm/time.h>
 #include <asm/opal.h>
 
                return;
        }
 
-       xive->dentry = debugfs_create_file(name, S_IRUGO, powerpc_debugfs_root,
+       xive->dentry = debugfs_create_file(name, S_IRUGO, arch_debugfs_dir,
                                           xive, &xive_debug_fops);
 
        pr_debug("%s: created %s\n", __func__, name);
 
 #include <asm/xive.h>
 #include <asm/xive-regs.h>
 #include <asm/debug.h>
-#include <asm/debugfs.h>
 #include <asm/opal.h>
 
 #include <linux/debugfs.h>
                return;
        }
 
-       xive->dentry = debugfs_create_file(name, 0444, powerpc_debugfs_root,
+       xive->dentry = debugfs_create_file(name, 0444, arch_debugfs_dir,
                                           xive, &xive_native_debug_fops);
 
        pr_debug("%s: created %s\n", __func__, name);
 
 #include <linux/hugetlb.h>
 #include <linux/cpu.h>
 #include <linux/pgtable.h>
+#include <linux/debugfs.h>
 
-#include <asm/debugfs.h>
 #include <asm/interrupt.h>
 #include <asm/processor.h>
 #include <asm/mmu.h>
 
 static int __init hash64_debugfs(void)
 {
-       debugfs_create_file("hpt_order", 0600, powerpc_debugfs_root, NULL,
+       debugfs_create_file("hpt_order", 0600, arch_debugfs_dir, NULL,
                            &fops_hpt_order);
        return 0;
 }
 
 #include <linux/sched.h>
 #include <linux/mm_types.h>
 #include <linux/memblock.h>
+#include <linux/debugfs.h>
 #include <misc/cxl-base.h>
 
-#include <asm/debugfs.h>
 #include <asm/pgalloc.h>
 #include <asm/tlb.h>
 #include <asm/trace.h>
         * invalidated as expected.
         */
        debugfs_create_bool("tlbie_enabled", 0600,
-                       powerpc_debugfs_root,
+                       arch_debugfs_dir,
                        &tlbie_enabled);
 
        return 0;
 
 #include <linux/memblock.h>
 #include <linux/mmu_context.h>
 #include <linux/sched/mm.h>
+#include <linux/debugfs.h>
 
 #include <asm/ppc-opcode.h>
 #include <asm/tlb.h>
 #include <asm/trace.h>
 #include <asm/cputhreads.h>
 #include <asm/plpar_wrappers.h>
-#include <asm/debugfs.h>
 
 #include "internal.h"
 
 static int __init create_tlb_single_page_flush_ceiling(void)
 {
        debugfs_create_u32("tlb_single_page_flush_ceiling", 0600,
-                          powerpc_debugfs_root, &tlb_single_page_flush_ceiling);
+                          arch_debugfs_dir, &tlb_single_page_flush_ceiling);
        debugfs_create_u32("tlb_local_single_page_flush_ceiling", 0600,
-                          powerpc_debugfs_root, &tlb_local_single_page_flush_ceiling);
+                          arch_debugfs_dir, &tlb_local_single_page_flush_ceiling);
        return 0;
 }
 late_initcall(create_tlb_single_page_flush_ceiling);
 
  */
 
 #include <linux/pgtable.h>
-#include <asm/debugfs.h>
+#include <linux/debugfs.h>
 #include <asm/cpu_has_feature.h>
 
 #include "ptdump.h"
 static int __init bats_init(void)
 {
        debugfs_create_file("block_address_translation", 0400,
-                           powerpc_debugfs_root, NULL, &bats_fops);
+                           arch_debugfs_dir, NULL, &bats_fops);
        return 0;
 }
 device_initcall(bats_init);
 
  * This dumps the content of Segment Registers
  */
 
-#include <asm/debugfs.h>
+#include <linux/debugfs.h>
 
 static void seg_show(struct seq_file *m, int i)
 {
 
 static int __init sr_init(void)
 {
-       debugfs_create_file("segment_registers", 0400, powerpc_debugfs_root,
+       debugfs_create_file("segment_registers", 0400, arch_debugfs_dir,
                            NULL, &sr_fops);
        return 0;
 }
 
 #include <linux/export.h>
 #include <linux/of_platform.h>
 #include <linux/slab.h>
+#include <linux/debugfs.h>
 
-#include <asm/debugfs.h>
 #include <asm/dcr.h>
 #include <asm/machdep.h>
 #include <asm/prom.h>
 
        snprintf(name, sizeof(name), "msic_%d", of_node_to_nid(dn));
 
-       debugfs_create_file(name, 0600, powerpc_debugfs_root, msic, &fops_msic);
+       debugfs_create_file(name, 0600, arch_debugfs_dir, msic, &fops_msic);
 }
 #endif /* DEBUG */
 
 #include <linux/memory_hotplug.h>
 #include <linux/numa.h>
 #include <asm/machdep.h>
-#include <asm/debugfs.h>
 #include <asm/cacheflush.h>
 
 /* This enables us to keep track of the memory removed from each node. */
 static int memtrace_init(void)
 {
        memtrace_debugfs_dir = debugfs_create_dir("memtrace",
-                                                 powerpc_debugfs_root);
+                                                 arch_debugfs_dir);
 
        debugfs_create_file("enable", 0600, memtrace_debugfs_dir,
                            NULL, &memtrace_init_fops);
 
 #include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/crash_dump.h>
+#include <linux/debugfs.h>
 #include <asm/opal.h>
 #include <asm/io.h>
 #include <asm/imc-pmu.h>
 #include <asm/cputhreads.h>
-#include <asm/debugfs.h>
 
 static struct dentry *imc_debugfs_parent;
 
        u32 cb_offset;
        struct imc_mem_info *ptr = pmu_ptr->mem_info;
 
-       imc_debugfs_parent = debugfs_create_dir("imc", powerpc_debugfs_root);
+       imc_debugfs_parent = debugfs_create_dir("imc", arch_debugfs_dir);
 
        if (of_property_read_u32(node, "cb_offset", &cb_offset))
                cb_offset = IMC_CNTL_BLK_OFFSET;
 
 #include <linux/bug.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/debugfs.h>
 
 #include <asm/machdep.h>
 #include <asm/firmware.h>
 #include <asm/opal.h>
 #include <asm/prom.h>
 #include <linux/uaccess.h>
-#include <asm/debugfs.h>
 #include <asm/isa-bridge.h>
 
 static int opal_lpc_chip_id = -1;
        if (opal_lpc_chip_id < 0)
                return -ENODEV;
 
-       root = debugfs_create_dir("lpc", powerpc_debugfs_root);
+       root = debugfs_create_dir("lpc", arch_debugfs_dir);
 
        rc |= opal_lpc_debugfs_create_type(root, "io", OPAL_LPC_IO);
        rc |= opal_lpc_debugfs_create_type(root, "mem", OPAL_LPC_MEM);
 
 #include <linux/gfp.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
+#include <linux/debugfs.h>
 
 #include <asm/machdep.h>
 #include <asm/firmware.h>
 #include <asm/opal.h>
-#include <asm/debugfs.h>
 #include <asm/prom.h>
 
 static u64 opal_scom_unmangle(u64 addr)
        if (!firmware_has_feature(FW_FEATURE_OPAL))
                return 0;
 
-       root = debugfs_create_dir("scom", powerpc_debugfs_root);
+       root = debugfs_create_dir("scom", arch_debugfs_dir);
        if (!root)
                return -1;
 
 
 #include <linux/iommu.h>
 #include <linux/rculist.h>
 #include <linux/sizes.h>
+#include <linux/debugfs.h>
 
 #include <asm/sections.h>
 #include <asm/io.h>
 #include <asm/iommu.h>
 #include <asm/tce.h>
 #include <asm/xics.h>
-#include <asm/debugfs.h>
 #include <asm/firmware.h>
 #include <asm/pnv-pci.h>
 #include <asm/mmzone.h>
                phb = hose->private_data;
 
                sprintf(name, "PCI%04x", hose->global_number);
-               phb->dbgfs = debugfs_create_dir(name, powerpc_debugfs_root);
+               phb->dbgfs = debugfs_create_dir(name, arch_debugfs_dir);
 
                debugfs_create_file_unsafe("dump_diag_regs", 0200, phb->dbgfs,
                                           phb, &pnv_pci_diag_data_fops);
 
 #include <linux/spinlock.h>
 #include <asm/smp.h>
 #include <linux/uaccess.h>
+#include <linux/debugfs.h>
 #include <asm/firmware.h>
 #include <asm/dtl.h>
 #include <asm/lppaca.h>
-#include <asm/debugfs.h>
 #include <asm/plpar_wrappers.h>
 #include <asm/machdep.h>
 
 
        /* set up common debugfs structure */
 
-       dtl_dir = debugfs_create_dir("dtl", powerpc_debugfs_root);
+       dtl_dir = debugfs_create_dir("dtl", arch_debugfs_dir);
 
        debugfs_create_x8("dtl_event_mask", 0600, dtl_dir, &dtl_event_mask);
        debugfs_create_u32("dtl_buf_entries", 0400, dtl_dir, &dtl_buf_entries);
 
 #include <linux/workqueue.h>
 #include <linux/proc_fs.h>
 #include <linux/pgtable.h>
+#include <linux/debugfs.h>
+
 #include <asm/processor.h>
 #include <asm/mmu.h>
 #include <asm/page.h>
 #include <asm/kexec.h>
 #include <asm/fadump.h>
 #include <asm/asm-prototypes.h>
-#include <asm/debugfs.h>
 #include <asm/dtl.h>
 
 #include "pseries.h"
        if (!firmware_has_feature(FW_FEATURE_SPLPAR))
                return 0;
 
-       vpa_dir = debugfs_create_dir("vpa", powerpc_debugfs_root);
+       vpa_dir = debugfs_create_dir("vpa", arch_debugfs_dir);
 
        /* set up the per-cpu vpa file*/
        for_each_possible_cpu(i) {
 
 #include <linux/msi.h>
 #include <linux/vmalloc.h>
 
-#include <asm/debugfs.h>
 #include <asm/prom.h>
 #include <asm/io.h>
 #include <asm/smp.h>
 int xive_core_debug_init(void)
 {
        if (xive_enabled())
-               debugfs_create_file("xive", 0400, powerpc_debugfs_root,
+               debugfs_create_file("xive", 0400, arch_debugfs_dir,
                                    NULL, &xive_core_debug_fops);
        return 0;
 }
 
 #include <linux/ctype.h>
 #include <linux/highmem.h>
 #include <linux/security.h>
+#include <linux/debugfs.h>
 
-#include <asm/debugfs.h>
 #include <asm/ptrace.h>
 #include <asm/smp.h>
 #include <asm/string.h>
 
 static int __init setup_xmon_dbgfs(void)
 {
-       debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
-                               &xmon_dbgfs_ops);
+       debugfs_create_file("xmon", 0600, arch_debugfs_dir, NULL,
+                           &xmon_dbgfs_ops);
        return 0;
 }
 device_initcall(setup_xmon_dbgfs);