--- /dev/null
+// SPDX-License-Identifier: GPL-2.0+
+/* Copyright (c) 2018-2019 Hisilicon Limited. */
+
+#include <linux/debugfs.h>
+#include <linux/device.h>
+
+#include "hnae3.h"
+#include "hns3_enet.h"
+
+#define HNS3_DBG_READ_LEN 256
+
+static struct dentry *hns3_dbgfs_root;
+
+static void hns3_dbg_help(struct hnae3_handle *h)
+{
+       dev_info(&h->pdev->dev, "available commands\n");
+       dev_info(&h->pdev->dev, "queue info [number]\n");
+       dev_info(&h->pdev->dev, "dump fd tcam\n");
+}
+
+static ssize_t hns3_dbg_cmd_read(struct file *filp, char __user *buffer,
+                                size_t count, loff_t *ppos)
+{
+       int uncopy_bytes;
+       char *buf;
+       int len;
+
+       if (*ppos != 0)
+               return 0;
+
+       if (count < HNS3_DBG_READ_LEN)
+               return -ENOSPC;
+
+       buf = kzalloc(HNS3_DBG_READ_LEN, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       len = snprintf(buf, HNS3_DBG_READ_LEN, "%s\n",
+                      "Please echo help to cmd to get help information");
+       uncopy_bytes = copy_to_user(buffer, buf, len);
+
+       kfree(buf);
+
+       if (uncopy_bytes)
+               return -EFAULT;
+
+       return (*ppos = len);
+}
+
+static ssize_t hns3_dbg_cmd_write(struct file *filp, const char __user *buffer,
+                                 size_t count, loff_t *ppos)
+{
+       struct hnae3_handle *handle = filp->private_data;
+       char *cmd_buf, *cmd_buf_tmp;
+       int uncopied_bytes;
+       int ret = 0;
+
+       if (*ppos != 0)
+               return 0;
+
+       cmd_buf = kzalloc(count + 1, GFP_KERNEL);
+       if (!cmd_buf)
+               return count;
+
+       uncopied_bytes = copy_from_user(cmd_buf, buffer, count);
+       if (uncopied_bytes) {
+               kfree(cmd_buf);
+               return -EFAULT;
+       }
+
+       cmd_buf[count] = '\0';
+
+       cmd_buf_tmp = strchr(cmd_buf, '\n');
+       if (cmd_buf_tmp) {
+               *cmd_buf_tmp = '\0';
+               count = cmd_buf_tmp - cmd_buf + 1;
+       }
+
+       if (strncmp(cmd_buf, "help", 4) == 0)
+               hns3_dbg_help(handle);
+
+       if (ret)
+               hns3_dbg_help(handle);
+
+       kfree(cmd_buf);
+       cmd_buf = NULL;
+
+       return count;
+}
+
+static const struct file_operations hns3_dbg_cmd_fops = {
+       .owner = THIS_MODULE,
+       .open  = simple_open,
+       .read  = hns3_dbg_cmd_read,
+       .write = hns3_dbg_cmd_write,
+};
+
+void hns3_dbg_init(struct hnae3_handle *handle)
+{
+       const char *name = pci_name(handle->pdev);
+       struct dentry *pfile;
+
+       handle->hnae3_dbgfs = debugfs_create_dir(name, hns3_dbgfs_root);
+       if (!handle->hnae3_dbgfs)
+               return;
+
+       pfile = debugfs_create_file("cmd", 0600, handle->hnae3_dbgfs, handle,
+                                   &hns3_dbg_cmd_fops);
+       if (!pfile) {
+               debugfs_remove_recursive(handle->hnae3_dbgfs);
+               handle->hnae3_dbgfs = NULL;
+               dev_warn(&handle->pdev->dev, "create file for %s fail\n",
+                        name);
+       }
+}
+
+void hns3_dbg_uninit(struct hnae3_handle *handle)
+{
+       debugfs_remove_recursive(handle->hnae3_dbgfs);
+       handle->hnae3_dbgfs = NULL;
+}
+
+void hns3_dbg_register_debugfs(const char *debugfs_dir_name)
+{
+       hns3_dbgfs_root = debugfs_create_dir(debugfs_dir_name, NULL);
+       if (!hns3_dbgfs_root) {
+               pr_warn("Register debugfs for %s fail\n", debugfs_dir_name);
+               return;
+       }
+}
+
+void hns3_dbg_unregister_debugfs(void)
+{
+       debugfs_remove_recursive(hns3_dbgfs_root);
+       hns3_dbgfs_root = NULL;
+}
 
 
        hns3_dcbnl_setup(handle);
 
+       hns3_dbg_init(handle);
+
        /* MTU range: (ETH_MIN_MTU(kernel default) - 9702) */
        netdev->max_mtu = HNS3_MAX_MTU;
 
 
        hns3_put_ring_config(priv);
 
+       hns3_dbg_uninit(handle);
+
        priv->ring_data = NULL;
 
 out_netdev_free:
 
        INIT_LIST_HEAD(&client.node);
 
+       hns3_dbg_register_debugfs(hns3_driver_name);
+
        ret = hnae3_register_client(&client);
        if (ret)
-               return ret;
+               goto err_reg_client;
 
        ret = pci_register_driver(&hns3_driver);
        if (ret)
-               hnae3_unregister_client(&client);
+               goto err_reg_driver;
 
        return ret;
+
+err_reg_driver:
+       hnae3_unregister_client(&client);
+err_reg_client:
+       hns3_dbg_unregister_debugfs();
+       return ret;
 }
 module_init(hns3_init_module);
 
 {
        pci_unregister_driver(&hns3_driver);
        hnae3_unregister_client(&client);
+       hns3_dbg_unregister_debugfs();
 }
 module_exit(hns3_exit_module);