mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
942 lines
25 KiB
942 lines
25 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* Copyright (c) 2013 Gerhard Sittig <[email protected]> |
|
* 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 <linux/mii.h> |
|
#include <malloc.h> |
|
#include <memalign.h> |
|
#include <usb.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 { |
|
#ifdef CONFIG_DM_ETH |
|
uint8_t rx_buf[MCS7830_RX_URB_SIZE]; |
|
struct ueth_data ueth; |
|
#endif |
|
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; |
|
} |
|
|
|
#ifndef CONFIG_DM_ETH |
|
/* |
|
* mcs7830_init() - network interface's init callback |
|
* @udev: network device to initialize |
|
* @bd: board information |
|
* Return: zero upon success, negative upon error |
|
* |
|
* after initial setup during probe() and get_info(), this init() callback |
|
* ensures that the link is up and subsequent send() and recv() calls can |
|
* exchange ethernet frames |
|
*/ |
|
static int mcs7830_init(struct eth_device *eth, bd_t *bd) |
|
{ |
|
struct ueth_data *dev = eth->priv; |
|
|
|
return mcs7830_init_common(dev->pusb_dev); |
|
} |
|
|
|
/* |
|
* mcs7830_send() - network interface's send callback |
|
* @eth: network device to send the frame from |
|
* @packet: ethernet frame content |
|
* @length: ethernet frame length |
|
* Return: zero upon success, negative upon error |
|
* |
|
* this routine send an ethernet frame out of the network interface |
|
*/ |
|
static int mcs7830_send(struct eth_device *eth, void *packet, int length) |
|
{ |
|
struct ueth_data *dev = eth->priv; |
|
|
|
return mcs7830_send_common(dev, packet, length); |
|
} |
|
|
|
/* |
|
* mcs7830_recv() - network interface's recv callback |
|
* @eth: network device to receive frames from |
|
* Return: zero upon success, negative upon error |
|
* |
|
* this routine checks for available ethernet frames that the network |
|
* interface might have received, and notifies the network stack |
|
*/ |
|
static int mcs7830_recv(struct eth_device *eth) |
|
{ |
|
ALLOC_CACHE_ALIGN_BUFFER(uint8_t, buf, MCS7830_RX_URB_SIZE); |
|
struct ueth_data *ueth = eth->priv; |
|
int len; |
|
|
|
len = mcs7830_recv_common(ueth, buf); |
|
if (len >= 0) { |
|
net_process_received_packet(buf, len); |
|
return 0; |
|
} |
|
|
|
return len; |
|
} |
|
|
|
/* |
|
* mcs7830_halt() - network interface's halt callback |
|
* @eth: network device to cease operation of |
|
* Return: none |
|
* |
|
* this routine is supposed to undo the effect of previous initialization and |
|
* ethernet frames exchange; in this implementation it's a NOP |
|
*/ |
|
static void mcs7830_halt(struct eth_device *eth) |
|
{ |
|
debug("%s()\n", __func__); |
|
} |
|
|
|
/* |
|
* mcs7830_write_mac() - write an ethernet adapter's MAC address |
|
* @eth: network device to write to |
|
* Return: zero upon success, negative upon error |
|
* |
|
* this routine takes the MAC address from the ethernet interface's data |
|
* structure, and writes it into the ethernet adapter such that subsequent |
|
* exchange of ethernet frames uses this address |
|
*/ |
|
static int mcs7830_write_mac(struct eth_device *eth) |
|
{ |
|
struct ueth_data *ueth = eth->priv; |
|
|
|
return mcs7830_write_mac_common(ueth->pusb_dev, eth->enetaddr); |
|
} |
|
|
|
/* |
|
* mcs7830_iface_idx - index of detected network interfaces |
|
* |
|
* this counter keeps track of identified supported interfaces, |
|
* to assign unique names as more interfaces are found |
|
*/ |
|
static int mcs7830_iface_idx; |
|
|
|
/* |
|
* mcs7830_eth_before_probe() - network driver's before_probe callback |
|
* Return: none |
|
* |
|
* this routine initializes driver's internal data in preparation of |
|
* subsequent probe callbacks |
|
*/ |
|
void mcs7830_eth_before_probe(void) |
|
{ |
|
mcs7830_iface_idx = 0; |
|
} |
|
|
|
/* |
|
* struct mcs7830_dongle - description of a supported Moschip ethernet dongle |
|
* @vendor: 16bit USB vendor identification |
|
* @product: 16bit USB product identification |
|
* |
|
* this structure describes a supported USB ethernet dongle by means of the |
|
* vendor and product codes found during USB enumeration; no flags are held |
|
* here since all supported dongles have identical behaviour, and required |
|
* fixups get determined at runtime, such that no manual configuration is |
|
* needed |
|
*/ |
|
struct mcs7830_dongle { |
|
uint16_t vendor; |
|
uint16_t product; |
|
}; |
|
|
|
/* |
|
* mcs7830_dongles - the list of supported Moschip based USB ethernet dongles |
|
*/ |
|
static const struct mcs7830_dongle mcs7830_dongles[] = { |
|
{ 0x9710, 0x7832, }, /* Moschip 7832 */ |
|
{ 0x9710, 0x7830, }, /* Moschip 7830 */ |
|
{ 0x9710, 0x7730, }, /* Moschip 7730 */ |
|
{ 0x0df6, 0x0021, }, /* Sitecom LN 30 */ |
|
}; |
|
|
|
/* |
|
* mcs7830_eth_probe() - network driver's probe callback |
|
* @dev: detected USB device to check |
|
* @ifnum: detected USB interface to check |
|
* @ss: USB ethernet data structure to fill in upon match |
|
* Return: #1 upon match, #0 upon mismatch or error |
|
* |
|
* this routine checks whether the found USB device is supported by |
|
* this ethernet driver, and upon match fills in the USB ethernet |
|
* data structure which later is passed to the get_info callback |
|
*/ |
|
int mcs7830_eth_probe(struct usb_device *dev, unsigned int ifnum, |
|
struct ueth_data *ss) |
|
{ |
|
struct usb_interface *iface; |
|
struct usb_interface_descriptor *iface_desc; |
|
int i; |
|
struct mcs7830_private *priv; |
|
int ep_in_found, ep_out_found, ep_intr_found; |
|
|
|
debug("%s()\n", __func__); |
|
|
|
/* iterate the list of supported dongles */ |
|
iface = &dev->config.if_desc[ifnum]; |
|
iface_desc = &iface->desc; |
|
for (i = 0; i < ARRAY_SIZE(mcs7830_dongles); i++) { |
|
if (dev->descriptor.idVendor == mcs7830_dongles[i].vendor && |
|
dev->descriptor.idProduct == mcs7830_dongles[i].product) |
|
break; |
|
} |
|
if (i == ARRAY_SIZE(mcs7830_dongles)) |
|
return 0; |
|
debug("detected USB ethernet device: %04X:%04X\n", |
|
dev->descriptor.idVendor, dev->descriptor.idProduct); |
|
|
|
/* fill in driver private data */ |
|
priv = calloc(1, sizeof(*priv)); |
|
if (!priv) |
|
return 0; |
|
|
|
/* fill in the ueth_data structure, attach private data */ |
|
memset(ss, 0, sizeof(*ss)); |
|
ss->ifnum = ifnum; |
|
ss->pusb_dev = dev; |
|
ss->subclass = iface_desc->bInterfaceSubClass; |
|
ss->protocol = iface_desc->bInterfaceProtocol; |
|
ss->dev_priv = priv; |
|
|
|
/* |
|
* a minimum of three endpoints is expected: in (bulk), |
|
* out (bulk), and interrupt; ignore all others |
|
*/ |
|
ep_in_found = ep_out_found = ep_intr_found = 0; |
|
for (i = 0; i < iface_desc->bNumEndpoints; i++) { |
|
uint8_t eptype, epaddr; |
|
bool is_input; |
|
|
|
eptype = iface->ep_desc[i].bmAttributes; |
|
eptype &= USB_ENDPOINT_XFERTYPE_MASK; |
|
|
|
epaddr = iface->ep_desc[i].bEndpointAddress; |
|
is_input = epaddr & USB_DIR_IN; |
|
epaddr &= USB_ENDPOINT_NUMBER_MASK; |
|
|
|
if (eptype == USB_ENDPOINT_XFER_BULK) { |
|
if (is_input && !ep_in_found) { |
|
ss->ep_in = epaddr; |
|
ep_in_found++; |
|
} |
|
if (!is_input && !ep_out_found) { |
|
ss->ep_out = epaddr; |
|
ep_out_found++; |
|
} |
|
} |
|
|
|
if (eptype == USB_ENDPOINT_XFER_INT) { |
|
if (is_input && !ep_intr_found) { |
|
ss->ep_int = epaddr; |
|
ss->irqinterval = iface->ep_desc[i].bInterval; |
|
ep_intr_found++; |
|
} |
|
} |
|
} |
|
debug("endpoints: in %d, out %d, intr %d\n", |
|
ss->ep_in, ss->ep_out, ss->ep_int); |
|
|
|
/* apply basic sanity checks */ |
|
if (usb_set_interface(dev, iface_desc->bInterfaceNumber, 0) || |
|
!ss->ep_in || !ss->ep_out || !ss->ep_int) { |
|
debug("device probe incomplete\n"); |
|
return 0; |
|
} |
|
|
|
dev->privptr = ss; |
|
return 1; |
|
} |
|
|
|
/* |
|
* mcs7830_eth_get_info() - network driver's get_info callback |
|
* @dev: detected USB device |
|
* @ss: USB ethernet data structure filled in at probe() |
|
* @eth: ethernet interface data structure to fill in |
|
* Return: #1 upon success, #0 upon error |
|
* |
|
* this routine registers the mandatory init(), send(), recv(), and |
|
* halt() callbacks with the ethernet interface, can register the |
|
* optional write_hwaddr() callback with the ethernet interface, |
|
* and initiates configuration of the interface such that subsequent |
|
* calls to those callbacks results in network communication |
|
*/ |
|
int mcs7830_eth_get_info(struct usb_device *dev, struct ueth_data *ss, |
|
struct eth_device *eth) |
|
{ |
|
debug("%s()\n", __func__); |
|
if (!eth) { |
|
debug("%s: missing parameter.\n", __func__); |
|
return 0; |
|
} |
|
|
|
snprintf(eth->name, sizeof(eth->name), "%s%d", |
|
MCS7830_BASE_NAME, mcs7830_iface_idx++); |
|
eth->init = mcs7830_init; |
|
eth->send = mcs7830_send; |
|
eth->recv = mcs7830_recv; |
|
eth->halt = mcs7830_halt; |
|
eth->write_hwaddr = mcs7830_write_mac; |
|
eth->priv = ss; |
|
|
|
if (mcs7830_basic_reset(ss->pusb_dev, ss->dev_priv)) |
|
return 0; |
|
|
|
if (mcs7830_read_mac(ss->pusb_dev, eth->enetaddr)) |
|
return 0; |
|
debug("MAC %pM\n", eth->enetaddr); |
|
|
|
return 1; |
|
} |
|
#endif |
|
|
|
|
|
#ifdef CONFIG_DM_ETH |
|
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_platdata(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_platdata(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_alloc_size = sizeof(struct mcs7830_private), |
|
.platdata_auto_alloc_size = 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); |
|
#endif
|
|
|