diff --git a/drivers/usb/eth/Kconfig b/drivers/usb/eth/Kconfig
index 2f6bfa8e71..8a47ca0ec4 100644
--- a/drivers/usb/eth/Kconfig
+++ b/drivers/usb/eth/Kconfig
@@ -62,4 +62,12 @@ config USB_ETHER_SMSC95XX
 	  Say Y here if you would like to support SMSC LAN95xx based USB 2.0
 	  Ethernet Devices.
 
+config USB_ETHER_DM9601
+	bool "Davicom DM96xx based USB 10/100 ethernet devices"
+	depends on USB_HOST_ETHER
+	depends on DM_ETH
+	---help---
+	  This option adds support for Davicom DM9601/DM9620/DM9621A
+	  based USB 10/100 Ethernet adapters.
+
 endif
diff --git a/drivers/usb/eth/Makefile b/drivers/usb/eth/Makefile
index 2e5d0782e8..044b12f028 100644
--- a/drivers/usb/eth/Makefile
+++ b/drivers/usb/eth/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_USB_ETHER_ASIX) += asix.o
 obj-$(CONFIG_USB_ETHER_ASIX88179) += asix88179.o
 obj-$(CONFIG_USB_ETHER_MCS7830) += mcs7830.o
 obj-$(CONFIG_USB_ETHER_SMSC95XX) += smsc95xx.o
+obj-$(CONFIG_USB_ETHER_DM9601) += dm9601.o
 obj-$(CONFIG_USB_ETHER_LAN75XX) += lan7x.o lan75xx.o
 obj-$(CONFIG_USB_ETHER_LAN78XX) += lan7x.o lan78xx.o
 obj-$(CONFIG_USB_ETHER_RTL8152) += r8152.o r8152_fw.o
diff --git a/drivers/usb/eth/dm9601.c b/drivers/usb/eth/dm9601.c
new file mode 100644
index 0000000000..f5956c7c73
--- /dev/null
+++ b/drivers/usb/eth/dm9601.c
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Davicom DM96xx USB 10/100Mbps ethernet devices
+ *
+ * Ported from Linux driver - drivers/net/usb9601.c
+ *
+ * Copyright (C) 2020 hey <hyyoxhk@163.com>
+ */
+
+#include <common.h>
+#include <linux/delay.h>
+#include <dm.h>
+#include <usb.h>
+#include <memalign.h>
+#include <errno.h>
+#include <linux/mii.h>
+#include "usb_ether.h"
+
+/* control requests */
+#define DM_READ_REGS	0x00
+#define DM_WRITE_REGS	0x01
+#define DM_READ_MEMS	0x02
+#define DM_WRITE_REG	0x03
+#define DM_WRITE_MEMS	0x05
+#define DM_WRITE_MEM	0x07
+
+/* registers */
+#define DM_NET_CTRL	0x00
+#define DM_RX_CTRL	0x05
+#define DM_SHARED_CTRL	0x0b
+#define DM_SHARED_ADDR	0x0c
+#define DM_SHARED_DATA	0x0d	/* low + high */
+#define DM_PHY_ADDR	0x10	/* 6 bytes */
+#define DM_MCAST_ADDR	0x16	/* 8 bytes */
+#define DM_GPR_CTRL	0x1e
+#define DM_GPR_DATA	0x1f
+#define DM_CHIP_ID	0x2c
+#define DM_MODE_CTRL	0x91	/* only on dm9620 */
+
+/* chip id values */
+#define ID_DM9601	0
+#define ID_DM9620	1
+
+#define DM_MAX_MCAST	64
+#define DM_MCAST_SIZE	8
+#define DM_EEPROM_LEN	256
+#define DM_TX_OVERHEAD	2	/* 2 byte header */
+#define DM_RX_OVERHEAD	7	/* 3 byte header + 4 byte crc tail */
+#define DM_TIMEOUT	1000
+
+#define USB_CTRL_SET_TIMEOUT 5000
+#define PHY_CONNECT_TIMEOUT 5000
+#define USB_BULK_SEND_TIMEOUT 5000
+#define USB_BULK_RECV_TIMEOUT 5000
+#define RX_URB_SIZE 2048
+
+/* driver private */
+struct dm9601_private {
+	struct ueth_data ueth;
+};
+
+static int dm_read(struct usb_device *udev, u8 reg, u16 length, void *data)
+{
+	ALLOC_CACHE_ALIGN_BUFFER(u8, v, length);
+	int err;
+
+	err = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+			      DM_READ_REGS,
+			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+			      0, reg, v, length,
+			      USB_CTRL_SET_TIMEOUT);
+
+	memcpy(data, v, length);
+
+	if (err != length && err >= 0)
+		err = -EINVAL;
+
+	return err;
+}
+
+static int dm_read_reg(struct usb_device *udev, u8 reg, u8 *value)
+{
+	return dm_read(udev, reg, 1, value);
+}
+
+static int dm_write(struct usb_device *udev, u8 reg, u16 length, void *data)
+{
+	ALLOC_CACHE_ALIGN_BUFFER(u8, v, length);
+	int err;
+
+	memcpy(v, data, length);
+
+	err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+			      DM_WRITE_REGS,
+			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+			      0, reg, v, length,
+			      USB_CTRL_SET_TIMEOUT);
+	if (err >= 0 && err < length)
+		err = -EINVAL;
+
+	return err;
+}
+
+static int dm_write_reg(struct usb_device *udev, u8 reg, u8 value)
+{
+	ALLOC_CACHE_ALIGN_BUFFER(u8, v, 1);
+	v[0] = value;
+
+	return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+				DM_WRITE_REG,
+				USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+				v[0], reg, NULL, 0,
+				USB_CTRL_SET_TIMEOUT);
+}
+
+static int dm_read_shared_word(struct usb_device *udev, int phy, u8 reg, __le16 *value)
+{
+	int ret, i;
+
+	dm_write_reg(udev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
+	dm_write_reg(udev, DM_SHARED_CTRL, phy ? 0xc : 0x4);
+
+	for (i = 0; i < DM_TIMEOUT; i++) {
+		u8 tmp = 0;
+
+		udelay(1);
+		ret = dm_read_reg(udev, DM_SHARED_CTRL, &tmp);
+		if (ret < 0)
+			goto out;
+
+		/* ready */
+		if ((tmp & 1) == 0)
+			break;
+	}
+
+	if (i == DM_TIMEOUT) {
+		printf("%s read timed out!\n", phy ? "phy" : "eeprom");
+		ret = -EIO;
+		goto out;
+	}
+
+	dm_write_reg(udev, DM_SHARED_CTRL, 0x0);
+	ret = dm_read(udev, DM_SHARED_DATA, 2, value);
+
+out:
+	return ret;
+}
+
+static int dm_write_shared_word(struct usb_device *udev, int phy, u8 reg, __le16 value)
+{
+	int ret, i;
+
+	ret = dm_write(udev, DM_SHARED_DATA, 2, &value);
+	if (ret < 0)
+		goto out;
+
+	dm_write_reg(udev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
+	dm_write_reg(udev, DM_SHARED_CTRL, phy ? 0x1a : 0x12);
+
+	for (i = 0; i < DM_TIMEOUT; i++) {
+		u8 tmp = 0;
+
+		udelay(1);
+		ret = dm_read_reg(udev, DM_SHARED_CTRL, &tmp);
+		if (ret < 0)
+			goto out;
+
+		/* ready */
+		if ((tmp & 1) == 0)
+			break;
+	}
+
+	if (i == DM_TIMEOUT) {
+		printf("%s write timed out!\n", phy ? "phy" : "eeprom");
+		ret = -EIO;
+		goto out;
+	}
+
+	dm_write_reg(udev, DM_SHARED_CTRL, 0x0);
+
+out:
+	return ret;
+}
+
+static int dm9601_mdio_read(struct ueth_data *ueth, int phy_id, int loc)
+{
+	__le16 res;
+
+	if (phy_id) {
+		printf("Only internal phy supported\n");
+		return 0;
+	}
+
+	dm_read_shared_word(ueth->pusb_dev, 1, loc, &res);
+
+	return le16_to_cpu(res);
+}
+
+static void dm9601_mdio_write(struct ueth_data *ueth, int phy_id, int loc, int val)
+{
+	__le16 res = cpu_to_le16(val);
+
+	if (phy_id) {
+		printf("Only internal phy supported\n");
+		return;
+	}
+
+	dm_write_shared_word(ueth->pusb_dev, 1, loc, res);
+}
+
+static int dm9601_set_mac_address(struct usb_device *udev, u8 *enetaddr)
+{
+	if (!is_valid_ethaddr(enetaddr)) {
+		printf("not setting invalid mac address %pM\n", enetaddr);
+		return -EINVAL;
+	}
+
+	dm_write(udev, DM_PHY_ADDR, ETH_ALEN, enetaddr);
+
+	return 0;
+}
+
+/**
+ * mii_nway_restart - restart NWay (autonegotiation) for this interface
+ * @mii: the MII interface
+ *
+ * Returns 0 on success, negative on error.
+ */
+static int mii_nway_restart(struct ueth_data *ueth)
+{
+	int bmcr;
+	int r = -EINVAL;
+
+	/* if autoneg is off, it's an error */
+	bmcr = dm9601_mdio_read(ueth, ueth->phy_id, MII_BMCR);
+
+	if (bmcr & BMCR_ANENABLE) {
+		bmcr |= BMCR_ANRESTART;
+		dm9601_mdio_write(ueth, ueth->phy_id, MII_BMCR, bmcr);
+		r = 0;
+	}
+
+	return r;
+}
+
+static void dm9601_set_multicast(struct usb_device *udev)
+{
+	u8 hashes[DM_MCAST_SIZE];
+	u8 rx_ctl = 0x31;
+
+	memset(hashes, 0x00, DM_MCAST_SIZE);
+	hashes[DM_MCAST_SIZE - 1] |= 0x80;  /* broadcast address */
+
+	dm_write(udev, DM_MCAST_ADDR, DM_MCAST_SIZE, hashes);
+	dm_write_reg(udev, DM_RX_CTRL, rx_ctl);
+}
+
+static int dm9601_bind(struct udevice *dev)
+{
+	struct eth_pdata *pdata = dev_get_platdata(dev);
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+	int ret = 0;
+	u8 mac[ETH_ALEN], id;
+
+	/* reset */
+	dm_write_reg(ueth->pusb_dev, DM_NET_CTRL, 1);
+	udelay(20);
+
+	/* read MAC */
+	if (dm_read(ueth->pusb_dev, DM_PHY_ADDR, ETH_ALEN, mac) < 0) {
+		printf("Error reading MAC address\n");
+		ret = -ENODEV;
+		goto out;
+	}
+
+	/*
+	 * Overwrite the auto-generated address only with good ones.
+	 */
+	if (is_valid_ethaddr(mac))
+		memcpy(pdata->enetaddr, mac, ETH_ALEN);
+	else
+		printf("dm9601: No valid MAC address in EEPROM, using %pM\n", pdata->enetaddr);
+
+	if (dm_read_reg(ueth->pusb_dev, DM_CHIP_ID, &id) < 0) {
+		printf("Error reading chip ID\n");
+		ret = -ENODEV;
+		goto out;
+	}
+
+	/* put dm9620 devices in dm9601 mode */
+	if (id == ID_DM9620) {
+		u8 mode;
+
+		if (dm_read_reg(ueth->pusb_dev, DM_MODE_CTRL, &mode) < 0) {
+			printf("Error reading MODE_CTRL\n");
+			ret = -ENODEV;
+			goto out;
+		}
+		dm_write_reg(ueth->pusb_dev, DM_MODE_CTRL, mode & 0x7f);
+	}
+
+	/* power up phy */
+	dm_write_reg(ueth->pusb_dev, DM_GPR_CTRL, 1);
+	dm_write_reg(ueth->pusb_dev, DM_GPR_DATA, 0);
+
+	/* receive broadcast packets */
+	dm9601_set_multicast(ueth->pusb_dev);
+
+	dm9601_mdio_write(ueth, ueth->phy_id, MII_BMCR, BMCR_RESET);
+	dm9601_mdio_write(ueth, ueth->phy_id, MII_ADVERTISE,
+			  ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
+	mii_nway_restart(ueth);
+
+out:
+	return ret;
+}
+
+static int dm9601_eth_start(struct udevice *dev)
+{
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+	int timeout = 0;
+	int link_detected;
+
+	debug("\n----> %s()\n", __func__);
+
+#define TIMEOUT_RESOLUTION 50   /* ms */
+	do {
+		link_detected = dm9601_mdio_read(ueth, ueth->phy_id, MII_BMSR) & BMSR_LSTATUS;
+		if (!link_detected) {
+			if (timeout == 0)
+				printf("Waiting for Ethernet connection... ");
+
+			udelay(TIMEOUT_RESOLUTION * 1000);
+			timeout += TIMEOUT_RESOLUTION;
+		}
+	} while (!link_detected && timeout < PHY_CONNECT_TIMEOUT);
+
+	if (link_detected) {
+		if (timeout != 0)
+			printf("done.\n");
+
+	} else {
+		printf("unable to connect.\n");
+		return -EIO;
+	}
+	return 0;
+}
+
+static int dm9601_eth_send(struct udevice *dev, void *packet, int length)
+{
+	int err;
+	u16 packet_len;
+	int actual_len;
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+
+	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg, PKTSIZE + DM_TX_OVERHEAD);
+
+	/* format:
+	 * b1: packet length low
+	 * b2: packet length high
+	 * b3..n: packet data
+	 */
+
+	packet_len = length;
+	cpu_to_le16s(&packet_len);
+
+	memcpy(msg, &packet_len, DM_TX_OVERHEAD);
+	memcpy(msg + DM_TX_OVERHEAD, (void *)packet, length);
+
+	err = usb_bulk_msg(ueth->pusb_dev,
+			   usb_sndbulkpipe(ueth->pusb_dev, ueth->ep_out),
+			   (void *)msg,
+			   length + sizeof(packet_len),
+			   &actual_len,
+			   USB_BULK_SEND_TIMEOUT);
+
+	return err;
+}
+
+static int dm9601_eth_recv(struct udevice *dev, int flags, uchar **packetp)
+{
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+	u8 *ptr;
+	int ret, len;
+	u8 status;
+	u32 packet_len;
+
+	len = usb_ether_get_rx_bytes(ueth, &ptr);
+	debug("%s: first try, len=%d\n", __func__, len);
+	if (!len) {
+		if (!(flags & ETH_RECV_CHECK_DEVICE))
+			return -EAGAIN;
+		ret = usb_ether_receive(ueth, RX_URB_SIZE);
+		if (ret == -EAGAIN)
+			return ret;
+
+		len = usb_ether_get_rx_bytes(ueth, &ptr);
+		debug("%s: second try, len=%d\n", __func__, len);
+	}
+
+	/* format:
+	 * b1: rx status
+	 * b2: packet length (incl crc) low
+	 * b3: packet length (incl crc) high
+	 * b4..n-4: packet data
+	 * bn-3..bn: ethernet crc
+	 */
+
+	if (unlikely(len < DM_RX_OVERHEAD)) {
+		debug("unexpected tiny rx frame\n");
+		goto err;
+	}
+
+	status = ptr[0];
+	packet_len = (ptr[1] | (ptr[2] << 8)) - 4;
+
+	if (unlikely(status & 0xbf)) {
+		debug("Rx: packet status failure: %d\n", status);
+		goto err;
+	}
+
+	if (packet_len > len - DM_RX_OVERHEAD) {
+		debug("Rx: too large packet: %d\n", packet_len);
+		goto err;
+	}
+
+	*packetp = ptr + 3;
+
+	return packet_len;
+
+err:
+	usb_ether_advance_rxbuf(ueth, -1);
+	return -EINVAL;
+}
+
+static int dm9601_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
+{
+	struct dm9601_private *priv = dev_get_priv(dev);
+
+	usb_ether_advance_rxbuf(&priv->ueth, DM_RX_OVERHEAD + packet_len);
+
+	return 0;
+}
+
+static void dm9601_eth_stop(struct udevice *dev)
+{
+	debug("** %s()\n", __func__);
+}
+
+static int dm9601_write_hwaddr(struct udevice *dev)
+{
+	struct eth_pdata *pdata = dev_get_platdata(dev);
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+
+	return dm9601_set_mac_address(ueth->pusb_dev, pdata->enetaddr);
+}
+
+static int dm9601_eth_probe(struct udevice *dev)
+{
+	struct dm9601_private *priv = dev_get_priv(dev);
+	struct ueth_data *ueth = &priv->ueth;
+	int ret;
+
+	ret = usb_ether_register(dev, ueth, RX_URB_SIZE);
+	if (ret) {
+		printf("usb ether register failed! ret = %d\n", ret);
+		return ret;
+	}
+
+	if (dm9601_bind(dev)) {
+		printf("basic init failed!\n");
+		goto err;
+	}
+
+	return 0;
+err:
+	return usb_ether_deregister(ueth);
+}
+
+static const struct eth_ops dm9601_eth_ops = {
+	.start		= dm9601_eth_start,
+	.send		= dm9601_eth_send,
+	.recv		= dm9601_eth_recv,
+	.free_pkt	= dm9601_free_pkt,
+	.stop		= dm9601_eth_stop,
+	.write_hwaddr	= dm9601_write_hwaddr,
+};
+
+U_BOOT_DRIVER(dm9601_eth) = {
+	.name = "dm9601_eth",
+	.id = UCLASS_ETH,
+	.probe = dm9601_eth_probe,
+	.ops = &dm9601_eth_ops,
+	.priv_auto_alloc_size = sizeof(struct dm9601_private),
+	.platdata_auto_alloc_size = sizeof(struct eth_pdata),
+};
+
+static const struct usb_device_id dm9601_eth_id_table[] = {
+	{ USB_DEVICE(0x07aa, 0x9601) },	/* Corega FEther USB-TXC */
+	{ USB_DEVICE(0x0a46, 0x9601) },	/* Davicom USB-100 */
+	{ USB_DEVICE(0x0a46, 0x6688) },	/* ZT6688 USB NIC */
+	{ USB_DEVICE(0x0a46, 0x0268) },	/* ShanTou ST268 USB NIC */
+	{ USB_DEVICE(0x0a46, 0x8515) },	/* ADMtek ADM8515 USB NIC */
+	{ USB_DEVICE(0x0a47, 0x9601) },	/* Hirose USB-100 */
+	{ USB_DEVICE(0x0fe6, 0x8101) },	/* DM9601 USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0fe6, 0x9700) },	/* DM9601 USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0a46, 0x9000) },	/* DM9000E */
+	{ USB_DEVICE(0x0a46, 0x9620) },	/* DM9620 USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0a46, 0x9621) },	/* DM9621A USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0a46, 0x9622) },	/* DM9622 USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0a46, 0x0269) },	/* DM962OA USB to Fast Ethernet Adapter */
+	{ USB_DEVICE(0x0a46, 0x1269) },	/* DM9621A USB to Fast Ethernet Adapter */
+	{},
+};
+
+U_BOOT_USB_DEVICE(dm9601_eth, dm9601_eth_id_table);
