[thirdparty/u-boot.git] / drivers / usb / eth / mcs7830.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2013 Gerhard Sittig <gsi@denx.de>
 * based on the U-Boot Asix driver as well as information
 * from the Linux Moschip driver
 */

/*
 * MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <log.h>
#include <net.h>
#include <linux/delay.h>
#include <linux/mii.h>
#include <malloc.h>
#include <memalign.h>
#include <usb.h>
#include <linux/printk.h>

#include "usb_ether.h"

#define MCS7830_BASE_NAME	"mcs"

#define USBCALL_TIMEOUT		1000
#define LINKSTATUS_TIMEOUT	5000	/* link status, connect timeout */
#define LINKSTATUS_TIMEOUT_RES	50	/* link status, resolution in msec */

#define MCS7830_RX_URB_SIZE	2048

/* command opcodes */
#define MCS7830_WR_BREQ		0x0d
#define MCS7830_RD_BREQ		0x0e

/* register layout, numerical offset specs for USB API calls */
struct mcs7830_regs {
	uint8_t multicast_hashes[8];
	uint8_t packet_gap[2];
	uint8_t phy_data[2];
	uint8_t phy_command[2];
	uint8_t configuration;
	uint8_t ether_address[6];
	uint8_t frame_drop_count;
	uint8_t pause_threshold;
};
#define REG_MULTICAST_HASH	offsetof(struct mcs7830_regs, multicast_hashes)
#define REG_PHY_DATA		offsetof(struct mcs7830_regs, phy_data)
#define REG_PHY_CMD		offsetof(struct mcs7830_regs, phy_command)
#define REG_CONFIG		offsetof(struct mcs7830_regs, configuration)
#define REG_ETHER_ADDR		offsetof(struct mcs7830_regs, ether_address)
#define REG_FRAME_DROP_COUNTER	offsetof(struct mcs7830_regs, frame_drop_count)
#define REG_PAUSE_THRESHOLD	offsetof(struct mcs7830_regs, pause_threshold)

/* bit masks and default values for the above registers */
#define PHY_CMD1_READ		0x40
#define PHY_CMD1_WRITE		0x20
#define PHY_CMD1_PHYADDR	0x01

#define PHY_CMD2_PEND		0x80
#define PHY_CMD2_READY		0x40

#define CONF_CFG		0x80
#define CONF_SPEED100		0x40
#define CONF_FDX_ENABLE		0x20
#define CONF_RXENABLE		0x10
#define CONF_TXENABLE		0x08
#define CONF_SLEEPMODE		0x04
#define CONF_ALLMULTICAST	0x02
#define CONF_PROMISCUOUS	0x01

#define PAUSE_THRESHOLD_DEFAULT	0

/* bit masks for the status byte which follows received ethernet frames */
#define STAT_RX_FRAME_CORRECT	0x20
#define STAT_RX_LARGE_FRAME	0x10
#define STAT_RX_CRC_ERROR	0x08
#define STAT_RX_ALIGNMENT_ERROR	0x04
#define STAT_RX_LENGTH_ERROR	0x02
#define STAT_RX_SHORT_FRAME	0x01

/*
 * struct mcs7830_private - private driver data for an individual adapter
 * @config:	shadow for the network adapter's configuration register
 * @mchash:	shadow for the network adapter's multicast hash registers
 */
struct mcs7830_private {
	uint8_t rx_buf[MCS7830_RX_URB_SIZE];
	struct ueth_data ueth;
	uint8_t config;
	uint8_t mchash[8];
};

/*
 * mcs7830_read_reg() - read a register of the network adapter
 * @udev:	network device to read from
 * @idx:	index of the register to start reading from
 * @size:	number of bytes to read
 * @data:	buffer to read into
 * Return: zero upon success, negative upon error
 */
static int mcs7830_read_reg(struct usb_device *udev, uint8_t idx,
			    uint16_t size, void *data)
{
	int len;
	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);

	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);

	len = usb_control_msg(udev,
			      usb_rcvctrlpipe(udev, 0),
			      MCS7830_RD_BREQ,
			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			      0, idx, buf, size,
			      USBCALL_TIMEOUT);
	if (len != size) {
		debug("%s() len=%d != sz=%d\n", __func__, len, size);
		return -EIO;
	}
	memcpy(data, buf, size);
	return 0;
}

/*
 * mcs7830_write_reg() - write a register of the network adapter
 * @udev:	network device to write to
 * @idx:	index of the register to start writing to
 * @size:	number of bytes to write
 * @data:	buffer holding the data to write
 * Return: zero upon success, negative upon error
 */
static int mcs7830_write_reg(struct usb_device *udev, uint8_t idx,
			     uint16_t size, void *data)
{
	int len;
	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);

	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);

	memcpy(buf, data, size);
	len = usb_control_msg(udev,
			      usb_sndctrlpipe(udev, 0),
			      MCS7830_WR_BREQ,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			      0, idx, buf, size,
			      USBCALL_TIMEOUT);
	if (len != size) {
		debug("%s() len=%d != sz=%d\n", __func__, len, size);
		return -EIO;
	}
	return 0;
}

/*
 * mcs7830_phy_emit_wait() - emit PHY read/write access, wait for its execution
 * @udev:	network device to talk to
 * @rwflag:	PHY_CMD1_READ or PHY_CMD1_WRITE opcode
 * @index:	number of the PHY register to read or write
 * Return: zero upon success, negative upon error
 */
static int mcs7830_phy_emit_wait(struct usb_device *udev,
				 uint8_t rwflag, uint8_t index)
{
	int rc;
	int retry;
	uint8_t cmd[2];

	/* send the PHY read/write request */
	cmd[0] = rwflag | PHY_CMD1_PHYADDR;
	cmd[1] = PHY_CMD2_PEND | (index & 0x1f);
	rc = mcs7830_write_reg(udev, REG_PHY_CMD, sizeof(cmd), cmd);
	if (rc < 0)
		return rc;

	/* wait for the response to become available (usually < 1ms) */
	retry = 10;
	do {
		rc = mcs7830_read_reg(udev, REG_PHY_CMD, sizeof(cmd), cmd);
		if (rc < 0)
			return rc;
		if (cmd[1] & PHY_CMD2_READY)
			return 0;
		if (!retry--)
			return -ETIMEDOUT;
		mdelay(1);
	} while (1);
	/* UNREACH */
}

/*
 * mcs7830_read_phy() - read a PHY register of the network adapter
 * @udev:	network device to read from
 * @index:	index of the PHY register to read from
 * Return: non-negative 16bit register content, negative upon error
 */
static int mcs7830_read_phy(struct usb_device *udev, uint8_t index)
{
	int rc;
	uint16_t val;

	/* issue the PHY read request and wait for its execution */
	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_READ, index);
	if (rc < 0)
		return rc;

	/* fetch the PHY data which was read */
	rc = mcs7830_read_reg(udev, REG_PHY_DATA, sizeof(val), &val);
	if (rc < 0)
		return rc;
	rc = le16_to_cpu(val);
	debug("%s(%d) => 0x%04X\n", __func__, index, rc);
	return rc;
}

/*
 * mcs7830_write_phy() - write a PHY register of the network adapter
 * @udev:	network device to write to
 * @index:	index of the PHY register to write to
 * @val:	value to write to the PHY register
 * Return: zero upon success, negative upon error
 */
static int mcs7830_write_phy(struct usb_device *udev, uint8_t index,
			     uint16_t val)
{
	int rc;

	debug("%s(%d, 0x%04X)\n", __func__, index, val);

	/* setup the PHY data which is to get written */
	val = cpu_to_le16(val);
	rc = mcs7830_write_reg(udev, REG_PHY_DATA, sizeof(val), &val);
	if (rc < 0)
		return rc;

	/* issue the PHY write request and wait for its execution */
	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_WRITE, index);
	if (rc < 0)
		return rc;

	return 0;
}

/*
 * mcs7830_write_config() - write to the network adapter's config register
 * @udev:	network device to write to
 * @priv:	private data
 * Return: zero upon success, negative upon error
 *
 * the data which gets written is taken from the shadow config register
 * within the device driver's private data
 */
static int mcs7830_write_config(struct usb_device *udev,
				struct mcs7830_private *priv)
{
	int rc;

	debug("%s()\n", __func__);

	rc = mcs7830_write_reg(udev, REG_CONFIG,
			       sizeof(priv->config), &priv->config);
	if (rc < 0) {
		debug("writing config to adapter failed\n");
		return rc;
	}

	return 0;
}

/*
 * mcs7830_write_mchash() - write the network adapter's multicast filter
 * @udev:	network device to write to
 * @priv:	private data
 * Return: zero upon success, negative upon error
 *
 * the data which gets written is taken from the shadow multicast hashes
 * within the device driver's private data
 */
static int mcs7830_write_mchash(struct usb_device *udev,
				struct mcs7830_private *priv)
{
	int rc;

	debug("%s()\n", __func__);

	rc = mcs7830_write_reg(udev, REG_MULTICAST_HASH,
			       sizeof(priv->mchash), &priv->mchash);
	if (rc < 0) {
		debug("writing multicast hash to adapter failed\n");
		return rc;
	}

	return 0;
}

/*
 * mcs7830_set_autoneg() - setup and trigger ethernet link autonegotiation
 * @udev:	network device to run link negotiation on
 * Return: zero upon success, negative upon error
 *
 * the routine advertises available media and starts autonegotiation
 */
static int mcs7830_set_autoneg(struct usb_device *udev)
{
	int adv, flg;
	int rc;

	debug("%s()\n", __func__);

	/*
	 * algorithm taken from the Linux driver, which took it from
	 * "the original mcs7830 version 1.4 driver":
	 *
	 * enable all media, reset BMCR, enable auto neg, restart
	 * auto neg while keeping the enable auto neg flag set
	 */

	adv = ADVERTISE_PAUSE_CAP | ADVERTISE_ALL | ADVERTISE_CSMA;
	rc = mcs7830_write_phy(udev, MII_ADVERTISE, adv);

	flg = 0;
	if (!rc)
		rc = mcs7830_write_phy(udev, MII_BMCR, flg);

	flg |= BMCR_ANENABLE;
	if (!rc)
		rc = mcs7830_write_phy(udev, MII_BMCR, flg);

	flg |= BMCR_ANRESTART;
	if (!rc)
		rc = mcs7830_write_phy(udev, MII_BMCR, flg);

	return rc;
}

/*
 * mcs7830_get_rev() - identify a network adapter's chip revision
 * @udev:	network device to identify
 * Return: non-negative number, reflecting the revision number
 *
 * currently, only "rev C and higher" and "below rev C" are needed, so
 * the return value is #1 for "below rev C", and #2 for "rev C and above"
 */
static int mcs7830_get_rev(struct usb_device *udev)
{
	uint8_t buf[2];
	int rc;
	int rev;

	/* register 22 is readable in rev C and higher */
	rc = mcs7830_read_reg(udev, REG_FRAME_DROP_COUNTER, sizeof(buf), buf);
	if (rc < 0)
		rev = 1;
	else
		rev = 2;
	debug("%s() rc=%d, rev=%d\n", __func__, rc, rev);
	return rev;
}

/*
 * mcs7830_apply_fixup() - identify an adapter and potentially apply fixups
 * @udev:	network device to identify and apply fixups to
 * Return: zero upon success (no errors emitted from here)
 *
 * this routine identifies the network adapter's chip revision, and applies
 * fixups for known issues
 */
static int mcs7830_apply_fixup(struct usb_device *udev)
{
	int rev;
	int i;
	uint8_t thr;

	rev = mcs7830_get_rev(udev);
	debug("%s() rev=%d\n", __func__, rev);

	/*
	 * rev C requires setting the pause threshold (the Linux driver
	 * is inconsistent, the implementation does it for "rev C
	 * exactly", the introductory comment says "rev C and above")
	 */
	if (rev == 2) {
		debug("%s: applying rev C fixup\n", __func__);
		thr = PAUSE_THRESHOLD_DEFAULT;
		for (i = 0; i < 2; i++) {
			(void)mcs7830_write_reg(udev, REG_PAUSE_THRESHOLD,
						sizeof(thr), &thr);
			mdelay(1);
		}
	}

	return 0;
}

/*
 * mcs7830_basic_reset() - bring the network adapter into a known first state
 * @eth:	network device to act upon
 * Return: zero upon success, negative upon error
 *
 * this routine initializes the network adapter such that subsequent invocations
 * of the interface callbacks can exchange ethernet frames; link negotiation is
 * triggered from here already and continues in background
 */
static int mcs7830_basic_reset(struct usb_device *udev,
			       struct mcs7830_private *priv)
{
	int rc;

	debug("%s()\n", __func__);

	/*
	 * comment from the respective Linux driver, which
	 * unconditionally sets the ALLMULTICAST flag as well:
	 * should not be needed, but does not work otherwise
	 */
	priv->config = CONF_TXENABLE;
	priv->config |= CONF_ALLMULTICAST;

	rc = mcs7830_set_autoneg(udev);
	if (rc < 0) {
		pr_err("setting autoneg failed\n");
		return rc;
	}

	rc = mcs7830_write_mchash(udev, priv);
	if (rc < 0) {
		pr_err("failed to set multicast hash\n");
		return rc;
	}

	rc = mcs7830_write_config(udev, priv);
	if (rc < 0) {
		pr_err("failed to set configuration\n");
		return rc;
	}

	rc = mcs7830_apply_fixup(udev);
	if (rc < 0) {
		pr_err("fixup application failed\n");
		return rc;
	}

	return 0;
}

/*
 * mcs7830_read_mac() - read an ethernet adapter's MAC address
 * @udev:	network device to read from
 * @enetaddr:	place to put ethernet MAC address
 * Return: zero upon success, negative upon error
 *
 * this routine fetches the MAC address stored within the ethernet adapter,
 * and stores it in the ethernet interface's data structure
 */
static int mcs7830_read_mac(struct usb_device *udev, unsigned char enetaddr[])
{
	int rc;
	uint8_t buf[ETH_ALEN];

	debug("%s()\n", __func__);

	rc = mcs7830_read_reg(udev, REG_ETHER_ADDR, ETH_ALEN, buf);
	if (rc < 0) {
		debug("reading MAC from adapter failed\n");
		return rc;
	}

	memcpy(enetaddr, buf, ETH_ALEN);
	return 0;
}

static int mcs7830_write_mac_common(struct usb_device *udev,
				    unsigned char enetaddr[])
{
	int rc;

	debug("%s()\n", __func__);

	rc = mcs7830_write_reg(udev, REG_ETHER_ADDR, ETH_ALEN, enetaddr);
	if (rc < 0) {
		debug("writing MAC to adapter failed\n");
		return rc;
	}
	return 0;
}

static int mcs7830_init_common(struct usb_device *udev)
{
	int timeout;
	int have_link;

	debug("%s()\n", __func__);

	timeout = 0;
	do {
		have_link = mcs7830_read_phy(udev, MII_BMSR) & BMSR_LSTATUS;
		if (have_link)
			break;
		udelay(LINKSTATUS_TIMEOUT_RES * 1000);
		timeout += LINKSTATUS_TIMEOUT_RES;
	} while (timeout < LINKSTATUS_TIMEOUT);
	if (!have_link) {
		debug("ethernet link is down\n");
		return -ETIMEDOUT;
	}
	return 0;
}

static int mcs7830_send_common(struct ueth_data *ueth, void *packet,
			       int length)
{
	struct usb_device *udev = ueth->pusb_dev;
	int rc;
	int gotlen;
	/* there is a status byte after the ethernet frame */
	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, PKTSIZE + sizeof(uint8_t));

	memcpy(buf, packet, length);
	rc = usb_bulk_msg(udev,
			  usb_sndbulkpipe(udev, ueth->ep_out),
			  &buf[0], length, &gotlen,
			  USBCALL_TIMEOUT);
	debug("%s() TX want len %d, got len %d, rc %d\n",
	      __func__, length, gotlen, rc);
	return rc;
}

static int mcs7830_recv_common(struct ueth_data *ueth, uint8_t *buf)
{
	int rc, wantlen, gotlen;
	uint8_t sts;

	debug("%s()\n", __func__);

	/* fetch input data from the adapter */
	wantlen = MCS7830_RX_URB_SIZE;
	rc = usb_bulk_msg(ueth->pusb_dev,
			  usb_rcvbulkpipe(ueth->pusb_dev, ueth->ep_in),
			  &buf[0], wantlen, &gotlen,
			  USBCALL_TIMEOUT);
	debug("%s() RX want len %d, got len %d, rc %d\n",
	      __func__, wantlen, gotlen, rc);
	if (rc != 0) {
		pr_err("RX: failed to receive\n");
		return rc;
	}
	if (gotlen > wantlen) {
		pr_err("RX: got too many bytes (%d)\n", gotlen);
		return -EIO;
	}

	/*
	 * the bulk message that we received from USB contains exactly
	 * one ethernet frame and a trailing status byte
	 */
	if (gotlen < sizeof(sts))
		return -EIO;
	gotlen -= sizeof(sts);
	sts = buf[gotlen];

	if (sts == STAT_RX_FRAME_CORRECT) {
		debug("%s() got a frame, len=%d\n", __func__, gotlen);
		return gotlen;
	}

	debug("RX: frame error (sts 0x%02X, %s %s %s %s %s)\n",
	      sts,
	      (sts & STAT_RX_LARGE_FRAME) ? "large" : "-",
	      (sts & STAT_RX_LENGTH_ERROR) ?  "length" : "-",
	      (sts & STAT_RX_SHORT_FRAME) ? "short" : "-",
	      (sts & STAT_RX_CRC_ERROR) ? "crc" : "-",
	      (sts & STAT_RX_ALIGNMENT_ERROR) ?  "align" : "-");
	return -EIO;
}

static int mcs7830_eth_start(struct udevice *dev)
{
	struct usb_device *udev = dev_get_parent_priv(dev);

	return mcs7830_init_common(udev);
}

void mcs7830_eth_stop(struct udevice *dev)
{
	debug("** %s()\n", __func__);
}

int mcs7830_eth_send(struct udevice *dev, void *packet, int length)
{
	struct mcs7830_private *priv = dev_get_priv(dev);
	struct ueth_data *ueth = &priv->ueth;

	return mcs7830_send_common(ueth, packet, length);
}

int mcs7830_eth_recv(struct udevice *dev, int flags, uchar **packetp)
{
	struct mcs7830_private *priv = dev_get_priv(dev);
	struct ueth_data *ueth = &priv->ueth;
	int len;

	len = mcs7830_recv_common(ueth, priv->rx_buf);
	*packetp = priv->rx_buf;

	return len;
}

static int mcs7830_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
{
	struct mcs7830_private *priv = dev_get_priv(dev);

	packet_len = ALIGN(packet_len, 4);
	usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);

	return 0;
}

int mcs7830_write_hwaddr(struct udevice *dev)
{
	struct usb_device *udev = dev_get_parent_priv(dev);
	struct eth_pdata *pdata = dev_get_plat(dev);

	return mcs7830_write_mac_common(udev, pdata->enetaddr);
}

static int mcs7830_eth_probe(struct udevice *dev)
{
	struct usb_device *udev = dev_get_parent_priv(dev);
	struct mcs7830_private *priv = dev_get_priv(dev);
	struct eth_pdata *pdata = dev_get_plat(dev);
	struct ueth_data *ueth = &priv->ueth;

	if (mcs7830_basic_reset(udev, priv))
		return 0;

	if (mcs7830_read_mac(udev, pdata->enetaddr))
		return 0;

	return usb_ether_register(dev, ueth, MCS7830_RX_URB_SIZE);
}

static const struct eth_ops mcs7830_eth_ops = {
	.start	= mcs7830_eth_start,
	.send	= mcs7830_eth_send,
	.recv	= mcs7830_eth_recv,
	.free_pkt = mcs7830_free_pkt,
	.stop	= mcs7830_eth_stop,
	.write_hwaddr = mcs7830_write_hwaddr,
};

U_BOOT_DRIVER(mcs7830_eth) = {
	.name	= "mcs7830_eth",
	.id	= UCLASS_ETH,
	.probe = mcs7830_eth_probe,
	.ops	= &mcs7830_eth_ops,
	.priv_auto	= sizeof(struct mcs7830_private),
	.plat_auto	= sizeof(struct eth_pdata),
	.flags	= DM_FLAG_ALLOC_PRIV_DMA,
};

static const struct usb_device_id mcs7830_eth_id_table[] = {
	{ USB_DEVICE(0x9710, 0x7832) },		/* Moschip 7832 */
	{ USB_DEVICE(0x9710, 0x7830), },	/* Moschip 7830 */
	{ USB_DEVICE(0x9710, 0x7730), },	/* Moschip 7730 */
	{ USB_DEVICE(0x0df6, 0x0021), },	/* Sitecom LN 30 */
	{ }		/* Terminating entry */
};

U_BOOT_USB_DEVICE(mcs7830_eth, mcs7830_eth_id_table);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
df4fb1c3 GS	2	/*
	3	* Copyright (c) 2013 Gerhard Sittig <gsi@denx.de>
	4	* based on the U-Boot Asix driver as well as information
	5	* from the Linux Moschip driver
df4fb1c3 GS	6	*/
	7
	8	/*
	9	* MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
	10	*/
	11
d678a59d	12	#include <common.h>
d4f847ec	13	#include <dm.h>
df4fb1c3	14	#include <errno.h>
f7ae49fc	15	#include <log.h>
90526e9f	16	#include <net.h>
c05ed00a	17	#include <linux/delay.h>
df4fb1c3 GS	18	#include <linux/mii.h>
df4fb1c3 GS	19	#include <malloc.h>
cf92e05c	20	#include <memalign.h>
df4fb1c3	21	#include <usb.h>
1e94b46f	22	#include <linux/printk.h>
df4fb1c3 GS	23
	24	#include "usb_ether.h"
	25
	26	#define MCS7830_BASE_NAME "mcs"
	27
	28	#define USBCALL_TIMEOUT 1000
	29	#define LINKSTATUS_TIMEOUT 5000 /* link status, connect timeout */
	30	#define LINKSTATUS_TIMEOUT_RES 50 /* link status, resolution in msec */
	31
	32	#define MCS7830_RX_URB_SIZE 2048
	33
	34	/* command opcodes */
	35	#define MCS7830_WR_BREQ 0x0d
	36	#define MCS7830_RD_BREQ 0x0e
	37
	38	/* register layout, numerical offset specs for USB API calls */
	39	struct mcs7830_regs {
	40	uint8_t multicast_hashes[8];
	41	uint8_t packet_gap[2];
	42	uint8_t phy_data[2];
	43	uint8_t phy_command[2];
	44	uint8_t configuration;
	45	uint8_t ether_address[6];
	46	uint8_t frame_drop_count;
	47	uint8_t pause_threshold;
	48	};
	49	#define REG_MULTICAST_HASH offsetof(struct mcs7830_regs, multicast_hashes)
	50	#define REG_PHY_DATA offsetof(struct mcs7830_regs, phy_data)
	51	#define REG_PHY_CMD offsetof(struct mcs7830_regs, phy_command)
	52	#define REG_CONFIG offsetof(struct mcs7830_regs, configuration)
	53	#define REG_ETHER_ADDR offsetof(struct mcs7830_regs, ether_address)
	54	#define REG_FRAME_DROP_COUNTER offsetof(struct mcs7830_regs, frame_drop_count)
	55	#define REG_PAUSE_THRESHOLD offsetof(struct mcs7830_regs, pause_threshold)
	56
	57	/* bit masks and default values for the above registers */
	58	#define PHY_CMD1_READ 0x40
	59	#define PHY_CMD1_WRITE 0x20
	60	#define PHY_CMD1_PHYADDR 0x01
	61
	62	#define PHY_CMD2_PEND 0x80
	63	#define PHY_CMD2_READY 0x40
	64
	65	#define CONF_CFG 0x80
	66	#define CONF_SPEED100 0x40
	67	#define CONF_FDX_ENABLE 0x20
	68	#define CONF_RXENABLE 0x10
	69	#define CONF_TXENABLE 0x08
	70	#define CONF_SLEEPMODE 0x04
	71	#define CONF_ALLMULTICAST 0x02
	72	#define CONF_PROMISCUOUS 0x01
	73
	74	#define PAUSE_THRESHOLD_DEFAULT 0
	75
	76	/* bit masks for the status byte which follows received ethernet frames */
	77	#define STAT_RX_FRAME_CORRECT 0x20
	78	#define STAT_RX_LARGE_FRAME 0x10
	79	#define STAT_RX_CRC_ERROR 0x08
	80	#define STAT_RX_ALIGNMENT_ERROR 0x04
	81	#define STAT_RX_LENGTH_ERROR 0x02
	82	#define STAT_RX_SHORT_FRAME 0x01
	83
	84	/*
	85	* struct mcs7830_private - private driver data for an individual adapter
	86	* @config: shadow for the network adapter's configuration register
87	* @mchash: shadow for the network adapter's multicast hash registers
88	*/
89	struct mcs7830_private {
d4f847ec SG	90	uint8_t rx_buf[MCS7830_RX_URB_SIZE];
d4f847ec SG	91	struct ueth_data ueth;
df4fb1c3 GS	92	uint8_t config;
	93	uint8_t mchash[8];
	94	};
	95
	96	/*
	97	* mcs7830_read_reg() - read a register of the network adapter
ce932c70	98	* @udev: network device to read from
df4fb1c3 GS	99	* @idx: index of the register to start reading from
	100	* @size: number of bytes to read
	101	* @data: buffer to read into
	102	* Return: zero upon success, negative upon error
	103	*/
ce932c70	104	static int mcs7830_read_reg(struct usb_device *udev, uint8_t idx,
df4fb1c3 GS	105	uint16_t size, void *data)
	106	{
	107	int len;
	108	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);
	109
	110	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);
	111
ce932c70 SG	112	len = usb_control_msg(udev,
ce932c70 SG	113	usb_rcvctrlpipe(udev, 0),
df4fb1c3 GS	114	MCS7830_RD_BREQ,
	115	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	116	0, idx, buf, size,
	117	USBCALL_TIMEOUT);
	118	if (len != size) {
	119	debug("%s() len=%d != sz=%d\n", __func__, len, size);
	120	return -EIO;
	121	}
	122	memcpy(data, buf, size);
	123	return 0;
	124	}
	125
	126	/*
	127	* mcs7830_write_reg() - write a register of the network adapter
ce932c70	128	* @udev: network device to write to
df4fb1c3 GS	129	* @idx: index of the register to start writing to
	130	* @size: number of bytes to write
	131	* @data: buffer holding the data to write
	132	* Return: zero upon success, negative upon error
	133	*/
ce932c70	134	static int mcs7830_write_reg(struct usb_device *udev, uint8_t idx,
df4fb1c3 GS	135	uint16_t size, void *data)
	136	{
	137	int len;
	138	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, size);
	139
	140	debug("%s() idx=0x%04X sz=%d\n", __func__, idx, size);
	141
	142	memcpy(buf, data, size);
ce932c70 SG	143	len = usb_control_msg(udev,
ce932c70 SG	144	usb_sndctrlpipe(udev, 0),
df4fb1c3 GS	145	MCS7830_WR_BREQ,
	146	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	147	0, idx, buf, size,
	148	USBCALL_TIMEOUT);
	149	if (len != size) {
	150	debug("%s() len=%d != sz=%d\n", __func__, len, size);
	151	return -EIO;
	152	}
	153	return 0;
	154	}
	155
	156	/*
	157	* mcs7830_phy_emit_wait() - emit PHY read/write access, wait for its execution
ce932c70	158	* @udev: network device to talk to
df4fb1c3 GS	159	* @rwflag: PHY_CMD1_READ or PHY_CMD1_WRITE opcode
	160	* @index: number of the PHY register to read or write
	161	* Return: zero upon success, negative upon error
	162	*/
ce932c70	163	static int mcs7830_phy_emit_wait(struct usb_device *udev,
df4fb1c3 GS	164	uint8_t rwflag, uint8_t index)
	165	{
	166	int rc;
	167	int retry;
	168	uint8_t cmd[2];
	169
	170	/* send the PHY read/write request */
	171	cmd[0] = rwflag \| PHY_CMD1_PHYADDR;
	172	cmd[1] = PHY_CMD2_PEND \| (index & 0x1f);
ce932c70	173	rc = mcs7830_write_reg(udev, REG_PHY_CMD, sizeof(cmd), cmd);
df4fb1c3 GS	174	if (rc < 0)
	175	return rc;
	176
	177	/* wait for the response to become available (usually < 1ms) */
	178	retry = 10;
	179	do {
ce932c70	180	rc = mcs7830_read_reg(udev, REG_PHY_CMD, sizeof(cmd), cmd);
df4fb1c3 GS	181	if (rc < 0)
	182	return rc;
	183	if (cmd[1] & PHY_CMD2_READY)
	184	return 0;
	185	if (!retry--)
	186	return -ETIMEDOUT;
	187	mdelay(1);
	188	} while (1);
	189	/* UNREACH */
	190	}
	191
	192	/*
	193	* mcs7830_read_phy() - read a PHY register of the network adapter
ce932c70	194	* @udev: network device to read from
df4fb1c3 GS	195	* @index: index of the PHY register to read from
	196	* Return: non-negative 16bit register content, negative upon error
	197	*/
ce932c70	198	static int mcs7830_read_phy(struct usb_device *udev, uint8_t index)
df4fb1c3 GS	199	{
	200	int rc;
	201	uint16_t val;
	202
	203	/* issue the PHY read request and wait for its execution */
ce932c70	204	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_READ, index);
df4fb1c3 GS	205	if (rc < 0)
	206	return rc;
	207
	208	/* fetch the PHY data which was read */
ce932c70	209	rc = mcs7830_read_reg(udev, REG_PHY_DATA, sizeof(val), &val);
df4fb1c3 GS	210	if (rc < 0)
	211	return rc;
	212	rc = le16_to_cpu(val);
ce932c70	213	debug("%s(%d) => 0x%04X\n", __func__, index, rc);
df4fb1c3 GS	214	return rc;
	215	}
	216
	217	/*
	218	* mcs7830_write_phy() - write a PHY register of the network adapter
ce932c70	219	* @udev: network device to write to
df4fb1c3 GS	220	* @index: index of the PHY register to write to
	221	* @val: value to write to the PHY register
	222	* Return: zero upon success, negative upon error
	223	*/
ce932c70 SG	224	static int mcs7830_write_phy(struct usb_device *udev, uint8_t index,
ce932c70 SG	225	uint16_t val)
df4fb1c3 GS	226	{
	227	int rc;
	228
ce932c70	229	debug("%s(%d, 0x%04X)\n", __func__, index, val);
df4fb1c3 GS	230
	231	/* setup the PHY data which is to get written */
	232	val = cpu_to_le16(val);
ce932c70	233	rc = mcs7830_write_reg(udev, REG_PHY_DATA, sizeof(val), &val);
df4fb1c3 GS	234	if (rc < 0)
	235	return rc;
	236
	237	/* issue the PHY write request and wait for its execution */
ce932c70	238	rc = mcs7830_phy_emit_wait(udev, PHY_CMD1_WRITE, index);
df4fb1c3 GS	239	if (rc < 0)
	240	return rc;
	241
	242	return 0;
	243	}
	244
	245	/*
	246	* mcs7830_write_config() - write to the network adapter's config register
ce932c70 SG	247	* @udev: network device to write to
ce932c70 SG	248	* @priv: private data
df4fb1c3 GS	249	* Return: zero upon success, negative upon error
	250	*
	251	* the data which gets written is taken from the shadow config register
	252	* within the device driver's private data
	253	*/
ce932c70 SG	254	static int mcs7830_write_config(struct usb_device *udev,
ce932c70 SG	255	struct mcs7830_private *priv)
df4fb1c3	256	{
df4fb1c3 GS	257	int rc;
	258
	259	debug("%s()\n", __func__);
df4fb1c3	260
ce932c70	261	rc = mcs7830_write_reg(udev, REG_CONFIG,
df4fb1c3 GS	262	sizeof(priv->config), &priv->config);
	263	if (rc < 0) {
	264	debug("writing config to adapter failed\n");
	265	return rc;
	266	}
	267
	268	return 0;
	269	}
	270
	271	/*
	272	* mcs7830_write_mchash() - write the network adapter's multicast filter
ce932c70 SG	273	* @udev: network device to write to
ce932c70 SG	274	* @priv: private data
df4fb1c3 GS	275	* Return: zero upon success, negative upon error
	276	*
	277	* the data which gets written is taken from the shadow multicast hashes
	278	* within the device driver's private data
	279	*/
ce932c70 SG	280	static int mcs7830_write_mchash(struct usb_device *udev,
ce932c70 SG	281	struct mcs7830_private *priv)
df4fb1c3	282	{
df4fb1c3 GS	283	int rc;
	284
	285	debug("%s()\n", __func__);
df4fb1c3	286
ce932c70	287	rc = mcs7830_write_reg(udev, REG_MULTICAST_HASH,
df4fb1c3 GS	288	sizeof(priv->mchash), &priv->mchash);
	289	if (rc < 0) {
	290	debug("writing multicast hash to adapter failed\n");
	291	return rc;
	292	}
	293
	294	return 0;
	295	}
	296
	297	/*
	298	* mcs7830_set_autoneg() - setup and trigger ethernet link autonegotiation
ce932c70	299	* @udev: network device to run link negotiation on
df4fb1c3 GS	300	* Return: zero upon success, negative upon error
	301	*
	302	* the routine advertises available media and starts autonegotiation
	303	*/
ce932c70	304	static int mcs7830_set_autoneg(struct usb_device *udev)
df4fb1c3 GS	305	{
	306	int adv, flg;
	307	int rc;
	308
	309	debug("%s()\n", __func__);
	310
	311	/*
	312	* algorithm taken from the Linux driver, which took it from
	313	* "the original mcs7830 version 1.4 driver":
	314	*
	315	* enable all media, reset BMCR, enable auto neg, restart
	316	* auto neg while keeping the enable auto neg flag set
	317	*/
	318
	319	adv = ADVERTISE_PAUSE_CAP \| ADVERTISE_ALL \| ADVERTISE_CSMA;
ce932c70	320	rc = mcs7830_write_phy(udev, MII_ADVERTISE, adv);
df4fb1c3 GS	321
	322	flg = 0;
	323	if (!rc)
ce932c70	324	rc = mcs7830_write_phy(udev, MII_BMCR, flg);
df4fb1c3 GS	325
	326	flg \|= BMCR_ANENABLE;
	327	if (!rc)
ce932c70	328	rc = mcs7830_write_phy(udev, MII_BMCR, flg);
df4fb1c3 GS	329
	330	flg \|= BMCR_ANRESTART;
	331	if (!rc)
ce932c70	332	rc = mcs7830_write_phy(udev, MII_BMCR, flg);
df4fb1c3 GS	333
	334	return rc;
	335	}
	336
	337	/*
	338	* mcs7830_get_rev() - identify a network adapter's chip revision
ce932c70	339	* @udev: network device to identify
df4fb1c3 GS	340	* Return: non-negative number, reflecting the revision number
	341	*
	342	* currently, only "rev C and higher" and "below rev C" are needed, so
	343	* the return value is #1 for "below rev C", and #2 for "rev C and above"
	344	*/
ce932c70	345	static int mcs7830_get_rev(struct usb_device *udev)
df4fb1c3 GS	346	{
	347	uint8_t buf[2];
	348	int rc;
	349	int rev;
	350
	351	/* register 22 is readable in rev C and higher */
ce932c70	352	rc = mcs7830_read_reg(udev, REG_FRAME_DROP_COUNTER, sizeof(buf), buf);
df4fb1c3 GS	353	if (rc < 0)
	354	rev = 1;
	355	else
	356	rev = 2;
	357	debug("%s() rc=%d, rev=%d\n", __func__, rc, rev);
	358	return rev;
	359	}
	360
	361	/*
	362	* mcs7830_apply_fixup() - identify an adapter and potentially apply fixups
ce932c70	363	* @udev: network device to identify and apply fixups to
df4fb1c3 GS	364	* Return: zero upon success (no errors emitted from here)
	365	*
	366	* this routine identifies the network adapter's chip revision, and applies
	367	* fixups for known issues
	368	*/
ce932c70	369	static int mcs7830_apply_fixup(struct usb_device *udev)
df4fb1c3 GS	370	{
	371	int rev;
	372	int i;
	373	uint8_t thr;
	374
ce932c70	375	rev = mcs7830_get_rev(udev);
df4fb1c3 GS	376	debug("%s() rev=%d\n", __func__, rev);
	377
	378	/*
	379	* rev C requires setting the pause threshold (the Linux driver
	380	* is inconsistent, the implementation does it for "rev C
	381	* exactly", the introductory comment says "rev C and above")
	382	*/
	383	if (rev == 2) {
ce932c70	384	debug("%s: applying rev C fixup\n", __func__);
df4fb1c3 GS	385	thr = PAUSE_THRESHOLD_DEFAULT;
df4fb1c3 GS	386	for (i = 0; i < 2; i++) {
ce932c70	387	(void)mcs7830_write_reg(udev, REG_PAUSE_THRESHOLD,
df4fb1c3 GS	388	sizeof(thr), &thr);
	389	mdelay(1);
	390	}
	391	}
	392
	393	return 0;
	394	}
	395
	396	/*
	397	* mcs7830_basic_reset() - bring the network adapter into a known first state
	398	* @eth: network device to act upon
	399	* Return: zero upon success, negative upon error
	400	*
	401	* this routine initializes the network adapter such that subsequent invocations
	402	* of the interface callbacks can exchange ethernet frames; link negotiation is
	403	* triggered from here already and continues in background
	404	*/
ce932c70 SG	405	static int mcs7830_basic_reset(struct usb_device *udev,
ce932c70 SG	406	struct mcs7830_private *priv)
df4fb1c3	407	{
df4fb1c3 GS	408	int rc;
	409
	410	debug("%s()\n", __func__);
df4fb1c3 GS	411
	412	/*
	413	* comment from the respective Linux driver, which
	414	* unconditionally sets the ALLMULTICAST flag as well:
	415	* should not be needed, but does not work otherwise
	416	*/
	417	priv->config = CONF_TXENABLE;
	418	priv->config \|= CONF_ALLMULTICAST;
	419
ce932c70	420	rc = mcs7830_set_autoneg(udev);
df4fb1c3	421	if (rc < 0) {
9b643e31	422	pr_err("setting autoneg failed\n");
df4fb1c3 GS	423	return rc;
	424	}
	425
ce932c70	426	rc = mcs7830_write_mchash(udev, priv);
df4fb1c3	427	if (rc < 0) {
9b643e31	428	pr_err("failed to set multicast hash\n");
df4fb1c3 GS	429	return rc;
	430	}
	431
ce932c70	432	rc = mcs7830_write_config(udev, priv);
df4fb1c3	433	if (rc < 0) {
9b643e31	434	pr_err("failed to set configuration\n");
df4fb1c3 GS	435	return rc;
	436	}
	437
ce932c70	438	rc = mcs7830_apply_fixup(udev);
df4fb1c3	439	if (rc < 0) {
9b643e31	440	pr_err("fixup application failed\n");
df4fb1c3 GS	441	return rc;
	442	}
	443
	444	return 0;
	445	}
	446
	447	/*
	448	* mcs7830_read_mac() - read an ethernet adapter's MAC address
ce932c70 SG	449	* @udev: network device to read from
ce932c70 SG	450	* @enetaddr: place to put ethernet MAC address
df4fb1c3 GS	451	* Return: zero upon success, negative upon error
	452	*
	453	* this routine fetches the MAC address stored within the ethernet adapter,
	454	* and stores it in the ethernet interface's data structure
	455	*/
ce932c70	456	static int mcs7830_read_mac(struct usb_device *udev, unsigned char enetaddr[])
df4fb1c3	457	{
df4fb1c3 GS	458	int rc;
	459	uint8_t buf[ETH_ALEN];
	460
	461	debug("%s()\n", __func__);
df4fb1c3	462
ce932c70	463	rc = mcs7830_read_reg(udev, REG_ETHER_ADDR, ETH_ALEN, buf);
df4fb1c3 GS	464	if (rc < 0) {
	465	debug("reading MAC from adapter failed\n");
	466	return rc;
	467	}
	468
ce932c70	469	memcpy(enetaddr, buf, ETH_ALEN);
df4fb1c3 GS	470	return 0;
	471	}
	472
ce932c70 SG	473	static int mcs7830_write_mac_common(struct usb_device *udev,
ce932c70 SG	474	unsigned char enetaddr[])
df4fb1c3	475	{
df4fb1c3 GS	476	int rc;
	477
	478	debug("%s()\n", __func__);
df4fb1c3	479
ce932c70	480	rc = mcs7830_write_reg(udev, REG_ETHER_ADDR, ETH_ALEN, enetaddr);
df4fb1c3 GS	481	if (rc < 0) {
	482	debug("writing MAC to adapter failed\n");
	483	return rc;
	484	}
	485	return 0;
	486	}
	487
ce932c70	488	static int mcs7830_init_common(struct usb_device *udev)
df4fb1c3	489	{
df4fb1c3 GS	490	int timeout;
	491	int have_link;
	492
	493	debug("%s()\n", __func__);
df4fb1c3 GS	494
	495	timeout = 0;
	496	do {
ce932c70	497	have_link = mcs7830_read_phy(udev, MII_BMSR) & BMSR_LSTATUS;
df4fb1c3 GS	498	if (have_link)
	499	break;
	500	udelay(LINKSTATUS_TIMEOUT_RES * 1000);
	501	timeout += LINKSTATUS_TIMEOUT_RES;
	502	} while (timeout < LINKSTATUS_TIMEOUT);
	503	if (!have_link) {
	504	debug("ethernet link is down\n");
	505	return -ETIMEDOUT;
	506	}
	507	return 0;
	508	}
	509
ce932c70 SG	510	static int mcs7830_send_common(struct ueth_data ueth, void packet,
ce932c70 SG	511	int length)
df4fb1c3	512	{
ce932c70	513	struct usb_device *udev = ueth->pusb_dev;
df4fb1c3 GS	514	int rc;
	515	int gotlen;
	516	/* there is a status byte after the ethernet frame */
	517	ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, PKTSIZE + sizeof(uint8_t));
	518
df4fb1c3	519	memcpy(buf, packet, length);
ce932c70 SG	520	rc = usb_bulk_msg(udev,
ce932c70 SG	521	usb_sndbulkpipe(udev, ueth->ep_out),
df4fb1c3 GS	522	&buf[0], length, &gotlen,
	523	USBCALL_TIMEOUT);
	524	debug("%s() TX want len %d, got len %d, rc %d\n",
	525	__func__, length, gotlen, rc);
	526	return rc;
	527	}
	528
ce932c70	529	static int mcs7830_recv_common(struct ueth_data ueth, uint8_t buf)
df4fb1c3	530	{
df4fb1c3 GS	531	int rc, wantlen, gotlen;
	532	uint8_t sts;
	533
	534	debug("%s()\n", __func__);
df4fb1c3 GS	535
	536	/* fetch input data from the adapter */
	537	wantlen = MCS7830_RX_URB_SIZE;
ce932c70 SG	538	rc = usb_bulk_msg(ueth->pusb_dev,
ce932c70 SG	539	usb_rcvbulkpipe(ueth->pusb_dev, ueth->ep_in),
df4fb1c3 GS	540	&buf[0], wantlen, &gotlen,
	541	USBCALL_TIMEOUT);
	542	debug("%s() RX want len %d, got len %d, rc %d\n",
	543	__func__, wantlen, gotlen, rc);
	544	if (rc != 0) {
9b643e31	545	pr_err("RX: failed to receive\n");
df4fb1c3 GS	546	return rc;
	547	}
	548	if (gotlen > wantlen) {
9b643e31	549	pr_err("RX: got too many bytes (%d)\n", gotlen);
df4fb1c3 GS	550	return -EIO;
	551	}
	552
	553	/*
	554	* the bulk message that we received from USB contains exactly
	555	* one ethernet frame and a trailing status byte
	556	*/
	557	if (gotlen < sizeof(sts))
	558	return -EIO;
	559	gotlen -= sizeof(sts);
	560	sts = buf[gotlen];
	561
	562	if (sts == STAT_RX_FRAME_CORRECT) {
	563	debug("%s() got a frame, len=%d\n", __func__, gotlen);
ce932c70	564	return gotlen;
df4fb1c3 GS	565	}
	566
	567	debug("RX: frame error (sts 0x%02X, %s %s %s %s %s)\n",
	568	sts,
	569	(sts & STAT_RX_LARGE_FRAME) ? "large" : "-",
	570	(sts & STAT_RX_LENGTH_ERROR) ? "length" : "-",
	571	(sts & STAT_RX_SHORT_FRAME) ? "short" : "-",
	572	(sts & STAT_RX_CRC_ERROR) ? "crc" : "-",
	573	(sts & STAT_RX_ALIGNMENT_ERROR) ? "align" : "-");
	574	return -EIO;
	575	}
	576
d4f847ec SG	577	static int mcs7830_eth_start(struct udevice *dev)
	578	{
	579	struct usb_device *udev = dev_get_parent_priv(dev);
	580
	581	return mcs7830_init_common(udev);
	582	}
	583
	584	void mcs7830_eth_stop(struct udevice *dev)
	585	{
	586	debug("** %s()\n", __func__);
	587	}
	588
	589	int mcs7830_eth_send(struct udevice dev, void packet, int length)
	590	{
	591	struct mcs7830_private *priv = dev_get_priv(dev);
	592	struct ueth_data *ueth = &priv->ueth;
	593
	594	return mcs7830_send_common(ueth, packet, length);
	595	}
	596
	597	int mcs7830_eth_recv(struct udevice dev, int flags, uchar *packetp)
	598	{
	599	struct mcs7830_private *priv = dev_get_priv(dev);
	600	struct ueth_data *ueth = &priv->ueth;
	601	int len;
	602
	603	len = mcs7830_recv_common(ueth, priv->rx_buf);
	604	*packetp = priv->rx_buf;
	605
	606	return len;
	607	}
	608
	609	static int mcs7830_free_pkt(struct udevice dev, uchar packet, int packet_len)
	610	{
	611	struct mcs7830_private *priv = dev_get_priv(dev);
	612
	613	packet_len = ALIGN(packet_len, 4);
	614	usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);
	615
	616	return 0;
	617	}
	618
	619	int mcs7830_write_hwaddr(struct udevice *dev)
	620	{
	621	struct usb_device *udev = dev_get_parent_priv(dev);
c69cda25	622	struct eth_pdata *pdata = dev_get_plat(dev);
d4f847ec SG	623
	624	return mcs7830_write_mac_common(udev, pdata->enetaddr);
	625	}
	626
	627	static int mcs7830_eth_probe(struct udevice *dev)
	628	{
	629	struct usb_device *udev = dev_get_parent_priv(dev);
	630	struct mcs7830_private *priv = dev_get_priv(dev);
c69cda25	631	struct eth_pdata *pdata = dev_get_plat(dev);
d4f847ec SG	632	struct ueth_data *ueth = &priv->ueth;
	633
	634	if (mcs7830_basic_reset(udev, priv))
	635	return 0;
	636
	637	if (mcs7830_read_mac(udev, pdata->enetaddr))
	638	return 0;
	639
	640	return usb_ether_register(dev, ueth, MCS7830_RX_URB_SIZE);
	641	}
	642
	643	static const struct eth_ops mcs7830_eth_ops = {
	644	.start = mcs7830_eth_start,
	645	.send = mcs7830_eth_send,
	646	.recv = mcs7830_eth_recv,
	647	.free_pkt = mcs7830_free_pkt,
	648	.stop = mcs7830_eth_stop,
	649	.write_hwaddr = mcs7830_write_hwaddr,
	650	};
	651
	652	U_BOOT_DRIVER(mcs7830_eth) = {
	653	.name = "mcs7830_eth",
	654	.id = UCLASS_ETH,
	655	.probe = mcs7830_eth_probe,
	656	.ops = &mcs7830_eth_ops,
41575d8e	657	.priv_auto = sizeof(struct mcs7830_private),
caa4daa2	658	.plat_auto = sizeof(struct eth_pdata),
d4f847ec SG	659	.flags = DM_FLAG_ALLOC_PRIV_DMA,
	660	};
	661
	662	static const struct usb_device_id mcs7830_eth_id_table[] = {
	663	{ USB_DEVICE(0x9710, 0x7832) }, /* Moschip 7832 */
	664	{ USB_DEVICE(0x9710, 0x7830), }, /* Moschip 7830 */
	665	{ USB_DEVICE(0x9710, 0x7730), }, /* Moschip 7730 */
	666	{ USB_DEVICE(0x0df6, 0x0021), }, /* Sitecom LN 30 */
	667	{ } /* Terminating entry */
	668	};
	669
	670	U_BOOT_USB_DEVICE(mcs7830_eth, mcs7830_eth_id_table);