diff --git a/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.c b/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.c
new file mode 100644
index 0000000..fc764a6
--- /dev/null
+++ b/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.c
@@ -0,0 +1,838 @@
+/*
+ * Copyright (c) 2015 MediaTek Inc.
+ * Author:
+ *  Shaocheng.Wang <shaocheng.wang@mediatek.com>
+ *  Chunfeng.Yun <chunfeng.yun@mediatek.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/kobject.h>
+
+#include "../core/usb.h"
+#include "xhci-mtk.h"
+
+static int t_test_j(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_k(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_se0(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_packet(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_suspend(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_resume(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+static int t_test_get_device_descriptor(struct xhci_hcd_mtk *mtk,
+				int argc, char **argv);
+static int t_test_enumerate_bus(struct xhci_hcd_mtk *mtk,
+				int argc, char **argv);
+static int t_power_u1u2(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+
+#define PORT_PLS_VALUE(p) ((p >> 5) & 0xf)
+
+#define MAX_NAME_SIZE 32
+#define MAX_ARG_SIZE 4
+
+struct hqa_test_cmd {
+	char name[MAX_NAME_SIZE];
+	int (*cb_func)(struct xhci_hcd_mtk *mtk, int argc, char **argv);
+	char *discription;
+};
+
+
+struct hqa_test_cmd xhci_mtk_hqa_cmds[] = {
+	{"test.j", &t_test_j, "Test_J"},
+	{"test.k", &t_test_k, "Test_K"},
+	{"test.se0", &t_test_se0, "Test_SE0_NAK"},
+	{"test.packet", &t_test_packet, "Test_PACKET"},
+	{"test.suspend", &t_test_suspend, "Port Suspend"},
+	{"test.resume", &t_test_resume, "Port Resume"},
+	{"test.enumbus", &t_test_enumerate_bus, "Enumerate Bus"},
+	{"test.getdesc", &t_test_get_device_descriptor,
+				"Get Device Discriptor"},
+	{"pm.u1u2", &t_power_u1u2, "Port U1,U2"},
+	{"", NULL, ""},
+};
+
+
+int call_hqa_func(struct xhci_hcd_mtk *mtk, char *buf)
+{
+	struct hqa_test_cmd *hqa;
+	struct usb_hcd *hcd = mtk->hcd;
+	char *argv[MAX_ARG_SIZE];
+	int argc;
+	int i;
+
+	argc = 0;
+	do {
+		argv[argc] = strsep(&buf, " ");
+		xhci_err(hcd_to_xhci(hcd), "[%d] %s\r\n", argc, argv[argc]);
+		argc++;
+	} while (buf);
+
+	for (i = 0; i < ARRAY_SIZE(xhci_mtk_hqa_cmds); i++) {
+		hqa = &xhci_mtk_hqa_cmds[i];
+		if ((!strcmp(hqa->name, argv[0])) && (hqa->cb_func != NULL))
+			return hqa->cb_func(mtk, argc, argv);
+	}
+
+	return -1;
+}
+
+static int test_mode_enter(struct xhci_hcd_mtk *mtk,
+				u32 port_id, u32 test_value)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 __iomem *addr;
+	u32 temp;
+
+	if (mtk->test_mode == 0) {
+		xhci_stop(hcd);
+		xhci_halt(xhci);
+	}
+
+	addr = &xhci->op_regs->port_power_base +
+			NUM_PORT_REGS * ((port_id - 1) & 0xff);
+	temp = readl(addr);
+	temp &= ~(0xf << 28);
+	temp |= (test_value << 28);
+	writel(temp, addr);
+	mtk->test_mode = 1;
+
+	return 0;
+}
+
+static int test_mode_exit(struct xhci_hcd_mtk *mtk)
+{
+	/* struct usb_hcd *hcd = mtk->hcd; */
+	/* struct xhci_hcd *xhci = hcd_to_xhci(hcd); */
+
+	if (mtk->test_mode == 1) {
+#if 0
+		xhci_reset(xhci);
+		/*reinitIP(&pdev->dev);*/
+
+		if (!usb_hcd_is_primary_hcd(test_hcd))
+			secondary_hcd = test_hcd;
+		else
+			secondary_hcd = xhci->shared_hcd;
+
+		retval = xhci_init(test_hcd->primary_hcd);
+		if (retval)
+			return retval;
+
+		retval = xhci_run(test_hcd->primary_hcd);
+		if (!retval)
+			retval = xhci_run(secondary_hcd);
+
+		/*enableXhciAllPortPower(xhci);*/
+#endif
+		mtk->test_mode = 0;
+	}
+	return 0;
+}
+
+static int t_test_j(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	long port_id;
+	u32 test_value;
+
+	port_id = 2;
+	test_value = 1;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+	test_mode_enter(mtk, port_id, test_value);
+
+	return 0;
+}
+
+static int t_test_k(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	long port_id;
+	u32 test_value;
+
+	port_id = 2;
+	test_value = 2;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+	test_mode_enter(mtk, port_id, test_value);
+
+	return 0;
+}
+
+static int t_test_se0(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	long port_id;
+	u32 test_value;
+
+	port_id = 2;
+	test_value = 3;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%ld\n", __func__, port_id);
+	test_mode_enter(mtk, port_id, test_value);
+
+	return 0;
+}
+
+static int t_test_packet(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	long port_id;
+	u32 test_value;
+
+	port_id = 2;
+	test_value = 4;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%ld\n", __func__, port_id);
+	test_mode_enter(mtk, port_id, test_value);
+
+	return 0;
+}
+
+/* only for u3 ports, valid values are 1, 2, ...*/
+static int t_power_u1u2(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 __iomem *addr;
+	u32 temp;
+	int port_id;
+	int retval = 0;
+	int u_num = 1;
+	int u1_val = 1;
+	int u2_val = 0;
+
+	port_id = 1; /* first u3port by default */
+
+	if (argc > 1 && kstrtoint(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	if (argc > 2 && kstrtoint(argv[2], 10, &u_num))
+		xhci_err(xhci, "mu3h %s get u_num failed\n", __func__);
+
+	if (argc > 3 && kstrtoint(argv[3], 10, &u1_val))
+		xhci_err(xhci, "mu3h %s get u1_val failed\n", __func__);
+
+	if (argc > 4 && kstrtoint(argv[4], 10, &u2_val))
+		xhci_err(xhci, "mu3h %s get u2_val failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d, u_num%d, u1_val%d, u2_val%d\n",
+		__func__, (int)port_id, u_num, u1_val, u2_val);
+
+	if (mtk->test_mode == 1) {
+		xhci_err(xhci, "please suspend port first\n");
+		return -1;
+	}
+
+	xhci_err(xhci, "%s: stop port polling\n", __func__);
+	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+	del_timer_sync(&hcd->rh_timer);
+	clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+	del_timer_sync(&xhci->shared_hcd->rh_timer);
+	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
+
+	addr = &xhci->op_regs->port_power_base +
+			NUM_PORT_REGS * ((port_id - 1) & 0xff);
+
+	temp = readl(addr);
+	if (u_num == 1) {
+		temp &= ~PORT_U1_TIMEOUT_MASK;
+		temp |= PORT_U1_TIMEOUT(u1_val);
+	} else if (u_num == 2) {
+		temp &= ~PORT_U2_TIMEOUT_MASK;
+		temp |= PORT_U2_TIMEOUT(u2_val);
+	} else if (u_num == 3) {
+		temp &= ~(PORT_U1_TIMEOUT_MASK | PORT_U2_TIMEOUT_MASK);
+		temp |= PORT_U1_TIMEOUT(u1_val) | PORT_U2_TIMEOUT(u2_val);
+	}
+
+	writel(temp, addr);
+
+	return retval;
+}
+
+
+static int t_test_suspend(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 __iomem *addr;
+	u32 temp;
+	long port_id;
+
+	port_id = 2;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+
+	xhci_err(xhci, "%s: stop port polling\n", __func__);
+	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+	del_timer_sync(&hcd->rh_timer);
+	clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+	del_timer_sync(&xhci->shared_hcd->rh_timer);
+	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
+
+	temp = readl(&xhci->ir_set->irq_pending);
+	writel(ER_IRQ_DISABLE(temp), &xhci->ir_set->irq_pending);
+
+	if (mtk->test_mode == 1)
+		test_mode_exit(mtk);
+
+	/* set PLS = 3 */
+	addr = &xhci->op_regs->port_status_base +
+			NUM_PORT_REGS*((port_id - 1) & 0xff);
+
+	temp = readl(addr);
+	temp = xhci_port_state_to_neutral(temp);
+	temp = (temp & ~(0xf << 5));
+	temp = (temp | (3 << 5) | PORT_LINK_STROBE);
+	writel(temp, addr);
+	xhci_handshake(addr, (0xf << 5), (3 << 5), 30*1000);
+
+	temp = readl(addr);
+	if (PORT_PLS_VALUE(temp) != 3)
+		xhci_err(xhci, "port not enter suspend state\n");
+	else
+		xhci_err(xhci, "port enter suspend state\n");
+
+	return 0;
+}
+
+static int t_test_resume(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 __iomem *addr;
+	u32 temp;
+	long port_id;
+	int retval = 0;
+
+	port_id = 2;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+
+	if (mtk->test_mode == 1) {
+		xhci_err(xhci, "please suspend port first\n");
+		return -1;
+	}
+	addr = &xhci->op_regs->port_status_base +
+			NUM_PORT_REGS * ((port_id - 1) & 0xff);
+
+	temp = readl(addr);
+	if (PORT_PLS_VALUE(temp) != 3) {
+		xhci_err(xhci, "port not in suspend state, please suspend port first\n");
+		retval = -1;
+	} else {
+		temp = xhci_port_state_to_neutral(temp);
+		temp = (temp & ~(0xf << 5));
+		temp = (temp | (15 << 5) | PORT_LINK_STROBE);
+		writel(temp, addr);
+		mdelay(20);
+
+		temp = readl(addr);
+		temp = xhci_port_state_to_neutral(temp);
+		temp = (temp & ~(0xf << 5));
+		temp = (temp | PORT_LINK_STROBE);
+		writel(temp, addr);
+
+		xhci_handshake(addr, (0xf << 5), (0 << 5), 100*1000);
+		temp = readl(addr);
+		if (PORT_PLS_VALUE(temp) != 0) {
+			xhci_err(xhci, "rusume fail,%x\n",
+				PORT_PLS_VALUE(temp));
+			retval = -1;
+		} else {
+			xhci_err(xhci, "port resume ok\n");
+		}
+	}
+
+	return retval;
+}
+
+static int t_test_enumerate_bus(struct xhci_hcd_mtk *mtk, int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	struct usb_device *usb2_rh;
+	struct usb_device *udev;
+	long port_id;
+	u32 retval;
+
+	port_id = 2;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+
+	if (mtk->test_mode == 1) {
+		test_mode_exit(mtk);
+		return 0;
+	}
+
+	usb2_rh = hcd->self.root_hub;
+	udev = usb_hub_find_child(usb2_rh, port_id - 1);
+
+	if (udev != NULL) {
+		retval = usb_reset_device(udev);
+		if (retval) {
+			xhci_err(xhci, "ERROR: enumerate bus fail!\n");
+			return -1;
+		}
+	} else {
+		xhci_err(xhci, "ERROR: Device does not exist!\n");
+		return -1;
+	}
+
+	return 0;
+}
+static int t_test_get_device_descriptor(struct xhci_hcd_mtk *mtk,
+				int argc, char **argv)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	struct usb_device *usb2_rh;
+	struct usb_device *udev;
+	long port_id;
+	u32 retval = 0;
+
+	port_id = 2;
+
+	if (argc > 1 && kstrtol(argv[1], 10, &port_id))
+		xhci_err(xhci, "mu3h %s get port-id failed\n", __func__);
+
+	xhci_err(xhci, "mu3h %s test port%d\n", __func__, (int)port_id);
+
+	if (mtk->test_mode == 1) {
+		test_mode_exit(mtk);
+		msleep(2000);
+	}
+
+	usb2_rh = hcd->self.root_hub;
+
+	udev = usb_hub_find_child(usb2_rh, port_id - 1);
+
+	if (udev != NULL) {
+		retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
+		if (retval != sizeof(udev->descriptor)) {
+			xhci_err(xhci, "ERROR: get device descriptor fail!\n");
+			return -1;
+		}
+	} else {
+		xhci_err(xhci, "ERROR: Device does not exist!\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static ssize_t mu3h_hqa_show(struct device *dev,
+			struct device_attribute *attr, char *buf)
+{
+	int len = 0;
+	int bufLen = PAGE_SIZE;
+	struct hqa_test_cmd *hqa;
+	int i;
+
+	len += snprintf(buf+len, bufLen-len, "info:\n");
+	len += snprintf(buf+len, bufLen-len,
+			"\techo -n item port-id > hqa\n");
+	len += snprintf(buf+len, bufLen-len,
+			"\tport-id : based on number of usb3-port, e.g.\n");
+	len += snprintf(buf+len, bufLen-len,
+			"\t\txHCI with 1 u3p, 2 u2p: 1st u2p-id is 2(1+1), 2nd is 3\n");
+	len += snprintf(buf+len, bufLen-len, "items:\n");
+
+	for (i = 0; i < ARRAY_SIZE(xhci_mtk_hqa_cmds); i++) {
+		hqa = &xhci_mtk_hqa_cmds[i];
+		len += snprintf(buf+len, bufLen-len,
+				"\t%s: %s\n", hqa->name, hqa->discription);
+	}
+
+	return len;
+}
+
+static ssize_t mu3h_hqa_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	int retval;
+
+	retval = call_hqa_func(mtk, (char *)buf);
+	if (retval < 0) {
+		xhci_err(xhci, "mu3h cli fail\n");
+		return -1;
+	}
+
+	return count;
+}
+
+static DEVICE_ATTR(hqa, 0664, mu3h_hqa_show, mu3h_hqa_store);
+
+#define REGS_LIMIT_XHCI 0x1000
+#define REGS_LIMIT_MU3D 0x3000
+#define REGS_LIMIT_IPPC 0x100
+#define REGS_LIMIT_PHYS 0x4000
+
+#define REGS_XHCI_OFFSET 0x0000
+#define REGS_MU3D_OFFSET 0x1000
+#define REGS_IPPC_OFFSET 0x3e00
+#define REGS_PHY_OFFSET  0xA20000
+
+static ssize_t ssusb_reg_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	int ret = -EINVAL;
+
+	ret = sprintf(buf, "SSUSB register operation interface help info.\n"
+		"  rx - read xhci reg: offset [len]\n"
+		"  rm - read mu3d reg: offset [len]\n"
+		"  ri - read ippc reg: offset [len]\n"
+		"  rp - read phy reg: offset [len]\n"
+		"  wx - write xhci reg: offset value\n"
+		"  wm - write mu3d reg: offset value\n"
+		"  wi - write ippc reg: offset value\n"
+		"  wp - write phy reg: offset value\n"
+		"  sx - set xhci mac reg bits: offset bit_start mask value\n"
+		"  sm - set mu3d mac reg bits: offset bit_start mask value\n"
+		"  si - set ippc reg bits: offset bit_start mask value\n"
+		"  sp - set phy reg bits: offset bit_start mask value\n"
+		"  px - print xhci mac reg bits: offset bit_start mask\n"
+		"  pm - print mu3d mac reg bits: offset bit_start mask\n"
+		"  pi - print ippc reg bits: offset bit_start mask\n"
+		"  pp - print phy reg bits: offset bit_start mask\n"
+		"  NOTE: numbers should be HEX, except bit_star(DEC)\n");
+
+	return ret;
+}
+
+/* base address: return value; limit is put into @limit */
+static void __iomem *get_reg_base_limit(struct xhci_hcd_mtk *mtk,
+		const char *buf, u32 *limit)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	void __iomem *base;
+	u32 len = 0;
+
+	switch (buf[1]) {
+	case 'x':
+		base = mtk->ip_base + REGS_XHCI_OFFSET;
+		len = REGS_LIMIT_XHCI;
+		xhci_info(xhci, "xhci's reg:\n");
+		break;
+	case 'm':
+		base = mtk->ip_base + REGS_MU3D_OFFSET;
+		len = REGS_LIMIT_MU3D;
+		xhci_info(xhci, "mu3d's reg:\n");
+		break;
+	case 'i':
+		base = mtk->ip_base + REGS_IPPC_OFFSET;
+		len = REGS_LIMIT_IPPC;
+		xhci_info(xhci, "ippc's reg:\n");
+		break;
+	case 'p':
+		base = mtk->ip_base + REGS_PHY_OFFSET;
+		len = REGS_LIMIT_PHYS;
+		xhci_info(xhci, "phy's reg:\n");
+		break;
+	default:
+		base = NULL;
+	}
+
+	*limit = len;
+
+	return base;
+}
+
+static void ssusb_write_reg(struct xhci_hcd_mtk *mtk, const char *buf)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	void __iomem *base;
+	u32 offset = 0;
+	u32 value = 0;
+	u32 old_val = 0;
+	u32 limit = 0;
+	u32 param;
+
+	param = sscanf(buf, "%*s 0x%x 0x%x", &offset, &value);
+	xhci_info(xhci, "params-%d (offset: %#x, value: %#x)\n",
+				param, offset, value);
+
+	base = get_reg_base_limit(mtk, buf, &limit);
+	if (!base || (param != 2)) {
+		xhci_err(xhci, "params are invalid!\n");
+		return;
+	}
+
+	offset &= ~0x3;  /* 4-bytes align */
+	if (offset >= limit) {
+		xhci_err(xhci, "reg's offset overrun!\n");
+		return;
+	}
+	old_val = readl(base + offset);
+	writel(value, base + offset);
+	xhci_info(xhci, "0x%8.8x : 0x%8.8x --> 0x%8.8x\n", offset, old_val,
+		readl(base + offset));
+}
+
+static void read_single_reg(struct xhci_hcd_mtk *mtk,
+			void __iomem *base, u32 offset, u32 limit)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	u32 value;
+
+	offset &= ~0x3;  /* 4-bytes align */
+	if (offset >= limit) {
+		xhci_err(xhci, "reg's offset overrun!\n");
+		return;
+	}
+	value = readl(base + offset);
+	xhci_err(xhci, "0x%8.8x : 0x%8.8x\n", offset, value);
+}
+
+static void read_multi_regs(struct xhci_hcd_mtk *mtk,
+	void __iomem *base, u32 offset, u32 len, u32 limit)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	int i;
+
+	/* at least 4 ints */
+	offset &= ~0xF;
+	len = (len + 0x3) & ~0x3;
+
+	if (offset + len > limit) {
+		xhci_err(xhci, "reg's offset overrun!\n");
+		return;
+	}
+
+	len >>= 2;
+	xhci_info(xhci, "read regs [%#x, %#x)\n", offset, offset + (len << 4));
+	for (i = 0; i < len; i++) {
+		xhci_err(xhci, "0x%8.8x : 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x\n",
+			offset, readl(base + offset),
+			readl(base + offset + 0x4),
+			readl(base + offset + 0x8),
+			readl(base + offset + 0xc));
+		offset += 0x10;
+	}
+}
+
+static void ssusb_read_regs(struct xhci_hcd_mtk *mtk, const char *buf)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	void __iomem *base;
+	u32 offset = 0;
+	u32 len = 0;
+	u32 limit = 0;
+	u32 param;
+
+	param = sscanf(buf, "%*s 0x%x 0x%x", &offset, &len);
+	xhci_info(xhci, "params-%d (offset: %#x, len: %#x)\n",
+				param, offset, len);
+
+	base = get_reg_base_limit(mtk, buf, &limit);
+	if (!base || !param) {
+		xhci_err(xhci, "params are invalid!\n");
+		return;
+	}
+
+	if (param == 1)
+		read_single_reg(mtk, base, offset, limit);
+	else
+		read_multi_regs(mtk, base, offset, len, limit);
+}
+
+static void ssusb_set_reg_bits(struct xhci_hcd_mtk *mtk, const char *buf)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	void __iomem *base;
+	u32 offset = 0;
+	u32 bit_start = 0;
+	u32 mask = 0;
+	u32 value = 0;
+	u32 old_val = 0;
+	u32 new_val = 0;
+	u32 limit = 0;
+	u32 param;
+
+	param = sscanf(buf, "%*s 0x%x %d 0x%x 0x%x",
+			&offset, &bit_start, &mask, &value);
+	xhci_info(xhci, "params-%d (offset:%#x,bit_start:%d,mask:%#x,value:%#x)\n",
+		param, offset, bit_start, mask, value);
+
+	base = get_reg_base_limit(mtk, buf, &limit);
+	if (!base || (param != 4) || (bit_start > 32)) {
+		xhci_err(xhci, "params are invalid!\n");
+		return;
+	}
+
+	offset &= ~0x3;  /* 4-bytes align */
+	if (offset >= limit) {
+		xhci_err(xhci, "reg's offset overrun!\n");
+		return;
+	}
+	old_val = readl(base + offset);
+	new_val = old_val;
+	new_val &= ~(mask << bit_start);
+	new_val |= (value << bit_start);
+	writel(new_val, base + offset);
+	xhci_info(xhci, "0x%8.8x : 0x%8.8x --> 0x%8.8x\n", offset, old_val,
+		readl(base + offset));
+}
+
+
+static void ssusb_print_reg_bits(struct xhci_hcd_mtk *mtk, const char *buf)
+{
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	void __iomem *base;
+	u32 offset = 0;
+	u32 bit_start = 0;
+	u32 mask = 0;
+	u32 old_val = 0;
+	u32 new_val = 0;
+	u32 limit = 0;
+	u32 param;
+
+	param = sscanf(buf, "%*s 0x%x %d 0x%x", &offset, &bit_start, &mask);
+	xhci_info(xhci, "params-%d (offset: %#x, bit_start: %d, mask: %#x)\n",
+		param, offset, bit_start, mask);
+
+	base = get_reg_base_limit(mtk, buf, &limit);
+	if (!base || (param != 3) || (bit_start > 32)) {
+		xhci_err(xhci, "params are invalid!\n");
+		return;
+	}
+
+	offset &= ~0x3;  /* 4-bytes align */
+	if (offset >= limit) {
+		xhci_err(xhci, "reg's offset overrun!\n");
+		return;
+	}
+
+	old_val = readl(base + offset);
+	new_val = old_val;
+	new_val >>= bit_start;
+	new_val &= mask;
+	xhci_info(xhci, "0x%8.8x : 0x%8.8x (0x%x)\n", offset, old_val, new_val);
+}
+
+
+static ssize_t
+ssusb_reg_store(struct device *dev, struct device_attribute *attr,
+			const char *buf, size_t n)
+{
+	struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+
+	xhci_info(xhci, " cmd: %s\n", buf);
+
+	switch (buf[0]) {
+	case 'w':
+		ssusb_write_reg(mtk, buf);
+		break;
+	case 'r':
+		ssusb_read_regs(mtk, buf);
+		break;
+	case 's':
+		ssusb_set_reg_bits(mtk, buf);
+		break;
+	case 'p':
+		ssusb_print_reg_bits(mtk, buf);
+		break;
+	default:
+		xhci_err(xhci, "No such cmd\n");
+	}
+
+	return n;
+}
+
+static DEVICE_ATTR(reg, 0664, ssusb_reg_show, ssusb_reg_store);
+
+static struct device_attribute *mu3h_hqa_attr_list[] = {
+	&dev_attr_hqa,
+	&dev_attr_reg,
+};
+
+static void ssusb_remap_ip_regs(struct device *dev)
+{
+	struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
+	struct usb_hcd *hcd = mtk->hcd;
+	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+
+	mtk->ip_base = ioremap(hcd->rsrc_start, 0xb00000);//0xa30000
+	if (!mtk->ip_base)
+		xhci_err(xhci, "could not ioremap regs\n");
+}
+
+int mu3h_hqa_create_attr(struct device *dev)
+{
+	int idx, err = 0;
+	int num = ARRAY_SIZE(mu3h_hqa_attr_list);
+
+	if (dev == NULL)
+		return -EINVAL;
+
+	ssusb_remap_ip_regs(dev);
+
+	for (idx = 0; idx < num; idx++) {
+		err = device_create_file(dev, mu3h_hqa_attr_list[idx]);
+		if (err)
+			break;
+	}
+
+	return err;
+}
+
+void mu3h_hqa_remove_attr(struct device *dev)
+{
+	int idx;
+	int num = ARRAY_SIZE(mu3h_hqa_attr_list);
+
+	for (idx = 0; idx < num; idx++)
+		device_remove_file(dev, mu3h_hqa_attr_list[idx]);
+}
diff --git a/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.h b/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.h
new file mode 100644
index 0000000..41199be
--- /dev/null
+++ b/target/linux/mediatek/files-5.4/drivers/usb/host/xhci-mtk-test.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2015 MediaTek Inc.
+ * Author:
+ *  Shaocheng.Wang <shaocheng.wang@mediatek.com>
+ *  Chunfeng.Yun <chunfeng.yun@mediatek.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __XHCI_MTK_TEST_H
+#define __XHCI_MTK_TEST_H
+
+int mu3h_hqa_create_attr(struct device *dev);
+void mu3h_hqa_remove_attr(struct device *dev);
+
+#endif /* __XHCI_MTK_TEST_H */