2002-11-03 09:24:07 +09:00
|
|
|
/*
|
2015-03-23 07:09:10 +09:00
|
|
|
* (C) Copyright 2001-2015
|
2002-11-03 09:24:07 +09:00
|
|
|
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
2015-03-23 07:09:10 +09:00
|
|
|
* Joe Hershberger, National Instruments
|
2002-11-03 09:24:07 +09:00
|
|
|
*
|
2013-07-08 16:37:19 +09:00
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
2002-11-03 09:24:07 +09:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
|
|
|
#include <command.h>
|
2015-03-23 07:09:10 +09:00
|
|
|
#include <dm.h>
|
2002-11-03 09:24:07 +09:00
|
|
|
#include <net.h>
|
2005-12-01 02:06:04 +09:00
|
|
|
#include <miiphy.h>
|
Create PHY Lib for U-Boot
Extends the mii_dev structure to participate in a full-blown MDIO and
PHY driver scheme. The mii_dev structure and miiphy calls are modified
in such a way to allow the original mii command and miiphy
infrastructure to work as before, but also to support a new set of APIs
which allow (among other things) sharing of PHY driver code and 10G support
The mii command will continue to support normal PHY management functions
(Clause 22 of 802.3), but will not be changed to support 10G
(Clause 45).
The basic design is similar to PHY Lib from Linux, but simplified for
U-Boot's network and driver infrastructure.
We now have MDIO drivers and PHY drivers
An MDIO driver provides:
read
write
reset
A PHY driver provides:
(optionally): probe
config - initial setup, starting of auto-negotiation
startup - waiting for AN, and reading link state
shutdown - any cleanup needed
The ethernet drivers interact with the PHY Lib using these functions:
phy_connect()
phy_config()
phy_startup()
phy_shutdown()
Each PHY driver can be configured separately, or all at once using
config_phylib_all_drivers.h (added in the patch which adds the drivers)
We also provide generic drivers for Clause 22 (10/100/1000), and
Clause 45 (10G) PHYs.
We also implement phy_reset(), and call it in phy_connect(). Because
phy_reset() is essentially the same as miiphy_reset, but:
a) must support 10G PHYs, and
b) should use the phylib primitives,
we implement miiphy_reset, using phy_reset(), but only when
CONFIG_PHYLIB is set. Otherwise, we just use the old version. In this
way, we save on compile size, even if we don't manage to save code size.
Pulled ethtool.h and mdio.h from:
git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
782d640afd15af7a1faf01cfe566ca4ac511319d
With many, many deletions so as to enable compilation under u-boot
Signed-off-by: Andy Fleming <afleming@freescale.com>
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
Acked-by: Detlev Zundel <dzu@denx.de>
2011-04-08 16:10:27 +09:00
|
|
|
#include <phy.h>
|
2014-07-13 17:27:02 +09:00
|
|
|
#include <asm/errno.h>
|
2015-03-23 07:09:10 +09:00
|
|
|
#include <dm/device-internal.h>
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:06 +09:00
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
|
2009-01-30 09:43:44 +09:00
|
|
|
void eth_parse_enetaddr(const char *addr, uchar *enetaddr)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 6; ++i) {
|
|
|
|
enetaddr[i] = addr ? simple_strtoul(addr, &end, 16) : 0;
|
|
|
|
if (addr)
|
|
|
|
addr = (*end) ? end + 1 : end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_getenv_enetaddr(char *name, uchar *enetaddr)
|
|
|
|
{
|
|
|
|
eth_parse_enetaddr(getenv(name), enetaddr);
|
|
|
|
return is_valid_ether_addr(enetaddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_setenv_enetaddr(char *name, const uchar *enetaddr)
|
|
|
|
{
|
|
|
|
char buf[20];
|
|
|
|
|
|
|
|
sprintf(buf, "%pM", enetaddr);
|
|
|
|
|
|
|
|
return setenv(name, buf);
|
|
|
|
}
|
2009-07-16 10:31:28 +09:00
|
|
|
|
2011-06-14 08:13:10 +09:00
|
|
|
int eth_getenv_enetaddr_by_index(const char *base_name, int index,
|
|
|
|
uchar *enetaddr)
|
2009-07-16 10:31:28 +09:00
|
|
|
{
|
|
|
|
char enetvar[32];
|
2011-06-14 08:13:10 +09:00
|
|
|
sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
|
2009-07-16 10:31:28 +09:00
|
|
|
return eth_getenv_enetaddr(enetvar, enetaddr);
|
|
|
|
}
|
2009-01-30 09:43:44 +09:00
|
|
|
|
2012-07-11 06:23:22 +09:00
|
|
|
static inline int eth_setenv_enetaddr_by_index(const char *base_name, int index,
|
2012-04-15 03:06:49 +09:00
|
|
|
uchar *enetaddr)
|
|
|
|
{
|
|
|
|
char enetvar[32];
|
|
|
|
sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
|
|
|
|
return eth_setenv_enetaddr(enetvar, enetaddr);
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
static void eth_env_init(void)
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
s = getenv("bootfile");
|
|
|
|
if (s != NULL)
|
|
|
|
copy_filename(BootFile, s, sizeof(BootFile));
|
|
|
|
}
|
2012-04-15 03:06:49 +09:00
|
|
|
|
2010-04-27 03:11:46 +09:00
|
|
|
static int eth_mac_skip(int index)
|
|
|
|
{
|
|
|
|
char enetvar[15];
|
|
|
|
char *skip_state;
|
|
|
|
sprintf(enetvar, index ? "eth%dmacskip" : "ethmacskip", index);
|
|
|
|
return ((skip_state = getenv(enetvar)) != NULL);
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
static void eth_current_changed(void);
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
#ifdef CONFIG_DM_ETH
|
|
|
|
/**
|
|
|
|
* struct eth_device_priv - private structure for each Ethernet device
|
|
|
|
*
|
|
|
|
* @state: The state of the Ethernet MAC driver (defined by enum eth_state_t)
|
|
|
|
*/
|
|
|
|
struct eth_device_priv {
|
|
|
|
enum eth_state_t state;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct eth_uclass_priv - The structure attached to the uclass itself
|
|
|
|
*
|
|
|
|
* @current: The Ethernet device that the network functions are using
|
|
|
|
*/
|
|
|
|
struct eth_uclass_priv {
|
|
|
|
struct udevice *current;
|
|
|
|
};
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
/* eth_errno - This stores the most recent failure code from DM functions */
|
|
|
|
static int eth_errno;
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
static struct eth_uclass_priv *eth_get_uclass_priv(void)
|
|
|
|
{
|
|
|
|
struct uclass *uc;
|
|
|
|
|
|
|
|
uclass_get(UCLASS_ETH, &uc);
|
|
|
|
assert(uc);
|
|
|
|
return uc->priv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void eth_set_current_to_next(void)
|
|
|
|
{
|
|
|
|
struct eth_uclass_priv *uc_priv;
|
|
|
|
|
|
|
|
uc_priv = eth_get_uclass_priv();
|
|
|
|
if (uc_priv->current)
|
|
|
|
uclass_next_device(&uc_priv->current);
|
|
|
|
if (!uc_priv->current)
|
|
|
|
uclass_first_device(UCLASS_ETH, &uc_priv->current);
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
/*
|
|
|
|
* Typically this will simply return the active device.
|
|
|
|
* In the case where the most recent active device was unset, this will attempt
|
|
|
|
* to return the first device. If that device doesn't exist or fails to probe,
|
|
|
|
* this function will return NULL.
|
|
|
|
*/
|
2015-03-23 07:09:10 +09:00
|
|
|
struct udevice *eth_get_dev(void)
|
|
|
|
{
|
|
|
|
struct eth_uclass_priv *uc_priv;
|
|
|
|
|
|
|
|
uc_priv = eth_get_uclass_priv();
|
|
|
|
if (!uc_priv->current)
|
2015-03-23 07:09:24 +09:00
|
|
|
eth_errno = uclass_first_device(UCLASS_ETH,
|
2015-03-23 07:09:10 +09:00
|
|
|
&uc_priv->current);
|
|
|
|
return uc_priv->current;
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
/*
|
|
|
|
* Typically this will just store a device pointer.
|
|
|
|
* In case it was not probed, we will attempt to do so.
|
|
|
|
* dev may be NULL to unset the active device.
|
|
|
|
*/
|
2015-03-23 07:09:10 +09:00
|
|
|
static void eth_set_dev(struct udevice *dev)
|
|
|
|
{
|
2015-03-23 07:09:24 +09:00
|
|
|
if (dev && !device_active(dev))
|
|
|
|
eth_errno = device_probe(dev);
|
2015-03-23 07:09:10 +09:00
|
|
|
eth_get_uclass_priv()->current = dev;
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:16 +09:00
|
|
|
/*
|
|
|
|
* Find the udevice that either has the name passed in as devname or has an
|
|
|
|
* alias named devname.
|
|
|
|
*/
|
|
|
|
struct udevice *eth_get_dev_by_name(const char *devname)
|
|
|
|
{
|
|
|
|
int seq = -1;
|
|
|
|
char *endp = NULL;
|
|
|
|
const char *startp = NULL;
|
|
|
|
struct udevice *it;
|
|
|
|
struct uclass *uc;
|
|
|
|
|
|
|
|
/* Must be longer than 3 to be an alias */
|
|
|
|
if (strlen(devname) > strlen("eth")) {
|
|
|
|
startp = devname + strlen("eth");
|
|
|
|
seq = simple_strtoul(startp, &endp, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
uclass_get(UCLASS_ETH, &uc);
|
|
|
|
uclass_foreach_dev(it, uc) {
|
2015-03-23 07:09:24 +09:00
|
|
|
/*
|
|
|
|
* We need the seq to be valid, so try to probe it.
|
|
|
|
* If the probe fails, the seq will not match since it will be
|
|
|
|
* -1 instead of what we are looking for.
|
|
|
|
* We don't care about errors from probe here. Either they won't
|
|
|
|
* match an alias or it will match a literal name and we'll pick
|
|
|
|
* up the error when we try to probe again in eth_set_dev().
|
|
|
|
*/
|
2015-03-23 07:09:16 +09:00
|
|
|
device_probe(it);
|
|
|
|
/*
|
|
|
|
* Check for the name or the sequence number to match
|
|
|
|
*/
|
|
|
|
if (strcmp(it->name, devname) == 0 ||
|
|
|
|
(endp > startp && it->seq == seq))
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
unsigned char *eth_get_ethaddr(void)
|
|
|
|
{
|
|
|
|
struct eth_pdata *pdata;
|
|
|
|
|
|
|
|
if (eth_get_dev()) {
|
|
|
|
pdata = eth_get_dev()->platdata;
|
|
|
|
return pdata->enetaddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set active state without calling start on the driver */
|
|
|
|
int eth_init_state_only(void)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
|
|
|
struct eth_device_priv *priv;
|
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current || !device_active(current))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
priv = current->uclass_priv;
|
|
|
|
priv->state = ETH_STATE_ACTIVE;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set passive state without calling stop on the driver */
|
|
|
|
void eth_halt_state_only(void)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
|
|
|
struct eth_device_priv *priv;
|
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current || !device_active(current))
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv = current->uclass_priv;
|
|
|
|
priv->state = ETH_STATE_PASSIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_get_dev_index(void)
|
|
|
|
{
|
|
|
|
if (eth_get_dev())
|
|
|
|
return eth_get_dev()->seq;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_init(void)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
|
|
|
struct udevice *old_current;
|
2015-03-23 07:09:24 +09:00
|
|
|
int ret = -ENODEV;
|
2015-03-23 07:09:10 +09:00
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current) {
|
|
|
|
printf("No ethernet found.\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
old_current = current;
|
|
|
|
do {
|
|
|
|
debug("Trying %s\n", current->name);
|
|
|
|
|
|
|
|
if (device_active(current)) {
|
|
|
|
uchar env_enetaddr[6];
|
|
|
|
struct eth_pdata *pdata = current->platdata;
|
|
|
|
|
|
|
|
/* Sync environment with network device */
|
|
|
|
if (eth_getenv_enetaddr_by_index("eth", current->seq,
|
|
|
|
env_enetaddr))
|
|
|
|
memcpy(pdata->enetaddr, env_enetaddr, 6);
|
|
|
|
else
|
|
|
|
memset(pdata->enetaddr, 0, 6);
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
ret = eth_get_ops(current)->start(current);
|
|
|
|
if (ret >= 0) {
|
2015-03-23 07:09:10 +09:00
|
|
|
struct eth_device_priv *priv =
|
|
|
|
current->uclass_priv;
|
|
|
|
|
|
|
|
priv->state = ETH_STATE_ACTIVE;
|
|
|
|
return 0;
|
|
|
|
}
|
2015-03-23 07:09:24 +09:00
|
|
|
} else
|
|
|
|
ret = eth_errno;
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
debug("FAIL\n");
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
/*
|
|
|
|
* If ethrotate is enabled, this will change "current",
|
|
|
|
* otherwise we will drop out of this while loop immediately
|
|
|
|
*/
|
2015-03-23 07:09:10 +09:00
|
|
|
eth_try_another(0);
|
2015-03-23 07:09:24 +09:00
|
|
|
/* This will ensure the new "current" attempted to probe */
|
2015-03-23 07:09:10 +09:00
|
|
|
current = eth_get_dev();
|
|
|
|
} while (old_current != current);
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
return ret;
|
2015-03-23 07:09:10 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
void eth_halt(void)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
|
|
|
struct eth_device_priv *priv;
|
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current || !device_active(current))
|
|
|
|
return;
|
|
|
|
|
|
|
|
eth_get_ops(current)->stop(current);
|
|
|
|
priv = current->uclass_priv;
|
|
|
|
priv->state = ETH_STATE_PASSIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_send(void *packet, int length)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
2015-03-23 07:09:24 +09:00
|
|
|
int ret;
|
2015-03-23 07:09:10 +09:00
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (!device_active(current))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-03-23 07:09:24 +09:00
|
|
|
ret = eth_get_ops(current)->send(current, packet, length);
|
|
|
|
if (ret < 0) {
|
|
|
|
/* We cannot completely return the error at present */
|
|
|
|
debug("%s: send() returned error %d\n", __func__, ret);
|
|
|
|
}
|
|
|
|
return ret;
|
2015-03-23 07:09:10 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
int eth_rx(void)
|
|
|
|
{
|
|
|
|
struct udevice *current;
|
2015-03-23 07:09:12 +09:00
|
|
|
uchar *packet;
|
|
|
|
int ret;
|
|
|
|
int i;
|
2015-03-23 07:09:10 +09:00
|
|
|
|
|
|
|
current = eth_get_dev();
|
|
|
|
if (!current)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (!device_active(current))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-03-23 07:09:12 +09:00
|
|
|
/* Process up to 32 packets at one time */
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
|
|
ret = eth_get_ops(current)->recv(current, &packet);
|
|
|
|
if (ret > 0)
|
|
|
|
net_process_received_packet(packet, ret);
|
2015-04-04 10:09:46 +09:00
|
|
|
if (ret >= 0 && eth_get_ops(current)->free_pkt)
|
|
|
|
eth_get_ops(current)->free_pkt(current, packet, ret);
|
|
|
|
if (ret <= 0)
|
2015-03-23 07:09:12 +09:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ret == -EAGAIN)
|
|
|
|
ret = 0;
|
2015-03-23 07:09:24 +09:00
|
|
|
if (ret < 0) {
|
|
|
|
/* We cannot completely return the error at present */
|
|
|
|
debug("%s: recv() returned error %d\n", __func__, ret);
|
|
|
|
}
|
2015-03-23 07:09:12 +09:00
|
|
|
return ret;
|
2015-03-23 07:09:10 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
static int eth_write_hwaddr(struct udevice *dev)
|
|
|
|
{
|
|
|
|
struct eth_pdata *pdata = dev->platdata;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!dev || !device_active(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* seq is valid since the device is active */
|
|
|
|
if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev->seq)) {
|
|
|
|
if (!is_valid_ether_addr(pdata->enetaddr)) {
|
|
|
|
printf("\nError: %s address %pM illegal value\n",
|
|
|
|
dev->name, pdata->enetaddr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = eth_get_ops(dev)->write_hwaddr(dev);
|
|
|
|
if (ret)
|
|
|
|
printf("\nWarning: %s failed to set MAC address\n",
|
|
|
|
dev->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_initialize(void)
|
|
|
|
{
|
|
|
|
int num_devices = 0;
|
|
|
|
struct udevice *dev;
|
|
|
|
|
|
|
|
bootstage_mark(BOOTSTAGE_ID_NET_ETH_START);
|
|
|
|
eth_env_init();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Devices need to write the hwaddr even if not started so that Linux
|
|
|
|
* will have access to the hwaddr that u-boot stored for the device.
|
|
|
|
* This is accomplished by attempting to probe each device and calling
|
|
|
|
* their write_hwaddr() operation.
|
|
|
|
*/
|
|
|
|
uclass_first_device(UCLASS_ETH, &dev);
|
|
|
|
if (!dev) {
|
|
|
|
printf("No ethernet found.\n");
|
|
|
|
bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
|
|
|
|
} else {
|
2015-03-23 07:09:17 +09:00
|
|
|
char *ethprime = getenv("ethprime");
|
|
|
|
struct udevice *prime_dev = NULL;
|
|
|
|
|
|
|
|
if (ethprime)
|
|
|
|
prime_dev = eth_get_dev_by_name(ethprime);
|
|
|
|
if (prime_dev) {
|
|
|
|
eth_set_dev(prime_dev);
|
|
|
|
eth_current_changed();
|
|
|
|
} else {
|
|
|
|
eth_set_dev(NULL);
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
|
|
|
|
do {
|
|
|
|
if (num_devices)
|
|
|
|
printf(", ");
|
|
|
|
|
|
|
|
printf("eth%d: %s", dev->seq, dev->name);
|
|
|
|
|
2015-03-23 07:09:17 +09:00
|
|
|
if (ethprime && dev == prime_dev)
|
|
|
|
printf(" [PRIME]");
|
|
|
|
|
2015-03-23 07:09:10 +09:00
|
|
|
eth_write_hwaddr(dev);
|
|
|
|
|
|
|
|
uclass_next_device(&dev);
|
|
|
|
num_devices++;
|
|
|
|
} while (dev);
|
|
|
|
|
|
|
|
putc('\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
return num_devices;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eth_post_bind(struct udevice *dev)
|
|
|
|
{
|
|
|
|
if (strchr(dev->name, ' ')) {
|
|
|
|
printf("\nError: eth device name \"%s\" has a space!\n",
|
|
|
|
dev->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eth_pre_unbind(struct udevice *dev)
|
|
|
|
{
|
|
|
|
/* Don't hang onto a pointer that is going away */
|
|
|
|
if (dev == eth_get_uclass_priv()->current)
|
|
|
|
eth_set_dev(NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eth_post_probe(struct udevice *dev)
|
|
|
|
{
|
|
|
|
struct eth_device_priv *priv = dev->uclass_priv;
|
|
|
|
struct eth_pdata *pdata = dev->platdata;
|
|
|
|
unsigned char env_enetaddr[6];
|
|
|
|
|
|
|
|
priv->state = ETH_STATE_INIT;
|
|
|
|
|
|
|
|
/* Check if the device has a MAC address in ROM */
|
|
|
|
if (eth_get_ops(dev)->read_rom_hwaddr)
|
|
|
|
eth_get_ops(dev)->read_rom_hwaddr(dev);
|
|
|
|
|
|
|
|
eth_getenv_enetaddr_by_index("eth", dev->seq, env_enetaddr);
|
|
|
|
if (!is_zero_ether_addr(env_enetaddr)) {
|
|
|
|
if (!is_zero_ether_addr(pdata->enetaddr) &&
|
|
|
|
memcmp(pdata->enetaddr, env_enetaddr, 6)) {
|
|
|
|
printf("\nWarning: %s MAC addresses don't match:\n",
|
|
|
|
dev->name);
|
|
|
|
printf("Address in SROM is %pM\n",
|
|
|
|
pdata->enetaddr);
|
|
|
|
printf("Address in environment is %pM\n",
|
|
|
|
env_enetaddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Override the ROM MAC address */
|
|
|
|
memcpy(pdata->enetaddr, env_enetaddr, 6);
|
|
|
|
} else if (is_valid_ether_addr(pdata->enetaddr)) {
|
|
|
|
eth_setenv_enetaddr_by_index("eth", dev->seq, pdata->enetaddr);
|
|
|
|
printf("\nWarning: %s using MAC address from ROM\n",
|
|
|
|
dev->name);
|
|
|
|
} else if (is_zero_ether_addr(pdata->enetaddr)) {
|
|
|
|
printf("\nError: %s address not set.\n",
|
|
|
|
dev->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eth_pre_remove(struct udevice *dev)
|
|
|
|
{
|
|
|
|
eth_get_ops(dev)->stop(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
UCLASS_DRIVER(eth) = {
|
|
|
|
.name = "eth",
|
|
|
|
.id = UCLASS_ETH,
|
|
|
|
.post_bind = eth_post_bind,
|
|
|
|
.pre_unbind = eth_pre_unbind,
|
|
|
|
.post_probe = eth_post_probe,
|
|
|
|
.pre_remove = eth_pre_remove,
|
|
|
|
.priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
|
|
|
|
.per_device_auto_alloc_size = sizeof(struct eth_device_priv),
|
2015-03-23 07:09:16 +09:00
|
|
|
.flags = DM_UC_FLAG_SEQ_ALIAS,
|
2015-03-23 07:09:10 +09:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef CONFIG_DM_ETH
|
2008-06-24 14:57:27 +09:00
|
|
|
/*
|
|
|
|
* CPU and board-specific Ethernet initializations. Aliased function
|
|
|
|
* signals caller to move on
|
|
|
|
*/
|
|
|
|
static int __def_eth_init(bd_t *bis)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
2009-04-21 01:08:46 +09:00
|
|
|
int cpu_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
|
|
|
|
int board_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
|
2008-06-24 14:57:27 +09:00
|
|
|
|
2007-12-28 02:19:02 +09:00
|
|
|
#ifdef CONFIG_API
|
|
|
|
static struct {
|
|
|
|
uchar data[PKTSIZE];
|
|
|
|
int length;
|
|
|
|
} eth_rcv_bufs[PKTBUFSRX];
|
|
|
|
|
2012-05-15 17:59:07 +09:00
|
|
|
static unsigned int eth_rcv_current, eth_rcv_last;
|
2007-12-28 02:19:02 +09:00
|
|
|
#endif
|
|
|
|
|
2012-08-03 19:59:08 +09:00
|
|
|
static struct eth_device *eth_devices;
|
|
|
|
struct eth_device *eth_current;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
static void eth_set_current_to_next(void)
|
|
|
|
{
|
|
|
|
eth_current = eth_current->next;
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:16 +09:00
|
|
|
static void eth_set_dev(struct eth_device *dev)
|
|
|
|
{
|
|
|
|
eth_current = dev;
|
|
|
|
}
|
|
|
|
|
2010-07-30 04:56:11 +09:00
|
|
|
struct eth_device *eth_get_dev_by_name(const char *devname)
|
2005-10-29 05:30:33 +09:00
|
|
|
{
|
|
|
|
struct eth_device *dev, *target_dev;
|
|
|
|
|
2011-08-22 09:17:17 +09:00
|
|
|
BUG_ON(devname == NULL);
|
|
|
|
|
2005-10-29 05:30:33 +09:00
|
|
|
if (!eth_devices)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dev = eth_devices;
|
|
|
|
target_dev = NULL;
|
|
|
|
do {
|
|
|
|
if (strcmp(devname, dev->name) == 0) {
|
|
|
|
target_dev = dev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dev = dev->next;
|
|
|
|
} while (dev != eth_devices);
|
|
|
|
|
|
|
|
return target_dev;
|
|
|
|
}
|
|
|
|
|
2009-02-12 06:07:24 +09:00
|
|
|
struct eth_device *eth_get_dev_by_index(int index)
|
|
|
|
{
|
|
|
|
struct eth_device *dev, *target_dev;
|
|
|
|
|
|
|
|
if (!eth_devices)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dev = eth_devices;
|
|
|
|
target_dev = NULL;
|
|
|
|
do {
|
2011-10-27 20:31:35 +09:00
|
|
|
if (dev->index == index) {
|
2009-02-12 06:07:24 +09:00
|
|
|
target_dev = dev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dev = dev->next;
|
|
|
|
} while (dev != eth_devices);
|
|
|
|
|
|
|
|
return target_dev;
|
|
|
|
}
|
|
|
|
|
2012-05-15 17:59:07 +09:00
|
|
|
int eth_get_dev_index(void)
|
2002-11-03 09:24:07 +09:00
|
|
|
{
|
2012-05-15 17:59:07 +09:00
|
|
|
if (!eth_current)
|
2011-10-27 20:31:35 +09:00
|
|
|
return -1;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2011-10-27 20:31:35 +09:00
|
|
|
return eth_current->index;
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
|
|
|
|
2011-06-14 08:13:10 +09:00
|
|
|
int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
|
|
|
|
int eth_number)
|
|
|
|
{
|
|
|
|
unsigned char env_enetaddr[6];
|
|
|
|
int ret = 0;
|
|
|
|
|
net/eth.c: fix eth_write_hwaddr() to use dev->enetaddr as fall back
Ignore the return value of eth_getenv_enetaddr_by_index(), and if it
fails, fall back to use dev->enetaddr, which could be filled up by
the ethernet device driver:
With the current code, introduced with below commit, eth_write_hwaddr()
will fail immediately if there is no eth<n>addr in the environment variables.
However, e.g. for an overo based product that uses the SMSC911x ethernet
chip (with the MAC address set via EEPROM connected to the SMSC911x chip),
the MAC address is still OK.
On mx28 boards that are depending on the OCOTP bits to set the MAC address
(like the Denx m28 board), the OCOTP bits should be used instead of
failing on the environment variables.
Actually, this was the original behavior, and was later changed by
commit 7616e7850804c7c69e0a22c179dfcba9e8f3f587.
Signed-off-by: Eric Miao <eric.miao@linaro.org>
Acked-by: Simon Glass <sjg@chromium.org>
Acked-by: Dirk Behme <dirk.behme@de.bosch.com>
CC: Stefan Roese <sr@denx.de>
CC: Eric Miao <eric.miao@linaro.org>
CC: Wolfgang Denk <wd@denx.de>
CC: Philip Balister <philip@balister.org>
CC: Zach Sadecki <zach@itwatchdogs.com>
2012-01-19 07:56:33 +09:00
|
|
|
eth_getenv_enetaddr_by_index(base_name, eth_number, env_enetaddr);
|
2011-06-14 08:13:10 +09:00
|
|
|
|
2015-03-23 07:09:01 +09:00
|
|
|
if (!is_zero_ether_addr(env_enetaddr)) {
|
|
|
|
if (!is_zero_ether_addr(dev->enetaddr) &&
|
|
|
|
memcmp(dev->enetaddr, env_enetaddr, 6)) {
|
2011-06-14 08:13:10 +09:00
|
|
|
printf("\nWarning: %s MAC addresses don't match:\n",
|
|
|
|
dev->name);
|
|
|
|
printf("Address in SROM is %pM\n",
|
|
|
|
dev->enetaddr);
|
|
|
|
printf("Address in environment is %pM\n",
|
|
|
|
env_enetaddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(dev->enetaddr, env_enetaddr, 6);
|
2012-04-15 03:06:49 +09:00
|
|
|
} else if (is_valid_ether_addr(dev->enetaddr)) {
|
|
|
|
eth_setenv_enetaddr_by_index(base_name, eth_number,
|
|
|
|
dev->enetaddr);
|
|
|
|
printf("\nWarning: %s using MAC address from net device\n",
|
|
|
|
dev->name);
|
2015-03-23 07:09:01 +09:00
|
|
|
} else if (is_zero_ether_addr(dev->enetaddr)) {
|
2014-07-13 17:27:02 +09:00
|
|
|
printf("\nError: %s address not set.\n",
|
|
|
|
dev->name);
|
|
|
|
return -EINVAL;
|
2011-06-14 08:13:10 +09:00
|
|
|
}
|
|
|
|
|
2014-07-13 17:27:02 +09:00
|
|
|
if (dev->write_hwaddr && !eth_mac_skip(eth_number)) {
|
|
|
|
if (!is_valid_ether_addr(dev->enetaddr)) {
|
|
|
|
printf("\nError: %s address %pM illegal value\n",
|
|
|
|
dev->name, dev->enetaddr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-08-10 16:56:21 +09:00
|
|
|
|
2011-06-14 08:13:10 +09:00
|
|
|
ret = dev->write_hwaddr(dev);
|
2014-07-13 17:27:02 +09:00
|
|
|
if (ret)
|
|
|
|
printf("\nWarning: %s failed to set MAC address\n", dev->name);
|
2012-08-10 16:56:21 +09:00
|
|
|
}
|
2011-06-14 08:13:10 +09:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-17 04:14:33 +09:00
|
|
|
int eth_register(struct eth_device *dev)
|
|
|
|
{
|
|
|
|
struct eth_device *d;
|
2012-05-15 17:59:07 +09:00
|
|
|
static int index;
|
2011-08-30 08:30:13 +09:00
|
|
|
|
2011-11-10 23:11:04 +09:00
|
|
|
assert(strlen(dev->name) < sizeof(dev->name));
|
2011-08-30 08:30:13 +09:00
|
|
|
|
2011-02-17 04:14:33 +09:00
|
|
|
if (!eth_devices) {
|
|
|
|
eth_current = eth_devices = dev;
|
|
|
|
eth_current_changed();
|
2002-11-03 09:24:07 +09:00
|
|
|
} else {
|
2012-05-15 17:59:07 +09:00
|
|
|
for (d = eth_devices; d->next != eth_devices; d = d->next)
|
2010-04-01 00:56:08 +09:00
|
|
|
;
|
2002-11-03 09:24:07 +09:00
|
|
|
d->next = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->state = ETH_STATE_INIT;
|
|
|
|
dev->next = eth_devices;
|
2011-10-27 20:31:35 +09:00
|
|
|
dev->index = index++;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-09 17:32:36 +09:00
|
|
|
int eth_unregister(struct eth_device *dev)
|
|
|
|
{
|
|
|
|
struct eth_device *cur;
|
|
|
|
|
|
|
|
/* No device */
|
|
|
|
if (!eth_devices)
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ENODEV;
|
2012-01-09 17:32:36 +09:00
|
|
|
|
|
|
|
for (cur = eth_devices; cur->next != eth_devices && cur->next != dev;
|
|
|
|
cur = cur->next)
|
|
|
|
;
|
|
|
|
|
|
|
|
/* Device not found */
|
|
|
|
if (cur->next != dev)
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ENODEV;
|
2012-01-09 17:32:36 +09:00
|
|
|
|
|
|
|
cur->next = dev->next;
|
|
|
|
|
|
|
|
if (eth_devices == dev)
|
|
|
|
eth_devices = dev->next == eth_devices ? NULL : dev->next;
|
|
|
|
|
|
|
|
if (eth_current == dev) {
|
|
|
|
eth_current = eth_devices;
|
|
|
|
eth_current_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:06 +09:00
|
|
|
int eth_initialize(void)
|
2002-11-03 09:24:07 +09:00
|
|
|
{
|
2011-10-27 20:31:35 +09:00
|
|
|
int num_devices = 0;
|
2002-11-03 09:24:07 +09:00
|
|
|
eth_devices = NULL;
|
|
|
|
eth_current = NULL;
|
|
|
|
|
2012-02-13 22:51:18 +09:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NET_ETH_START);
|
2014-01-11 00:58:11 +09:00
|
|
|
#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
|
2005-12-01 02:06:04 +09:00
|
|
|
miiphy_init();
|
|
|
|
#endif
|
Create PHY Lib for U-Boot
Extends the mii_dev structure to participate in a full-blown MDIO and
PHY driver scheme. The mii_dev structure and miiphy calls are modified
in such a way to allow the original mii command and miiphy
infrastructure to work as before, but also to support a new set of APIs
which allow (among other things) sharing of PHY driver code and 10G support
The mii command will continue to support normal PHY management functions
(Clause 22 of 802.3), but will not be changed to support 10G
(Clause 45).
The basic design is similar to PHY Lib from Linux, but simplified for
U-Boot's network and driver infrastructure.
We now have MDIO drivers and PHY drivers
An MDIO driver provides:
read
write
reset
A PHY driver provides:
(optionally): probe
config - initial setup, starting of auto-negotiation
startup - waiting for AN, and reading link state
shutdown - any cleanup needed
The ethernet drivers interact with the PHY Lib using these functions:
phy_connect()
phy_config()
phy_startup()
phy_shutdown()
Each PHY driver can be configured separately, or all at once using
config_phylib_all_drivers.h (added in the patch which adds the drivers)
We also provide generic drivers for Clause 22 (10/100/1000), and
Clause 45 (10G) PHYs.
We also implement phy_reset(), and call it in phy_connect(). Because
phy_reset() is essentially the same as miiphy_reset, but:
a) must support 10G PHYs, and
b) should use the phylib primitives,
we implement miiphy_reset, using phy_reset(), but only when
CONFIG_PHYLIB is set. Otherwise, we just use the old version. In this
way, we save on compile size, even if we don't manage to save code size.
Pulled ethtool.h and mdio.h from:
git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
782d640afd15af7a1faf01cfe566ca4ac511319d
With many, many deletions so as to enable compilation under u-boot
Signed-off-by: Andy Fleming <afleming@freescale.com>
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
Acked-by: Detlev Zundel <dzu@denx.de>
2011-04-08 16:10:27 +09:00
|
|
|
|
|
|
|
#ifdef CONFIG_PHYLIB
|
|
|
|
phy_init();
|
|
|
|
#endif
|
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
eth_env_init();
|
2012-04-05 03:53:41 +09:00
|
|
|
|
2010-09-01 15:05:04 +09:00
|
|
|
/*
|
|
|
|
* If board-specific initialization exists, call it.
|
|
|
|
* If not, call a CPU-specific one
|
|
|
|
*/
|
|
|
|
if (board_eth_init != __def_eth_init) {
|
2015-03-23 07:09:06 +09:00
|
|
|
if (board_eth_init(gd->bd) < 0)
|
2010-09-01 15:05:04 +09:00
|
|
|
printf("Board Net Initialization Failed\n");
|
|
|
|
} else if (cpu_eth_init != __def_eth_init) {
|
2015-03-23 07:09:06 +09:00
|
|
|
if (cpu_eth_init(gd->bd) < 0)
|
2010-09-01 15:05:04 +09:00
|
|
|
printf("CPU Net Initialization Failed\n");
|
|
|
|
} else
|
|
|
|
printf("Net Initialization Skipped\n");
|
2005-12-01 02:06:04 +09:00
|
|
|
|
2002-11-03 09:24:07 +09:00
|
|
|
if (!eth_devices) {
|
2012-05-15 17:59:07 +09:00
|
|
|
puts("No ethernet found.\n");
|
2012-02-13 22:51:18 +09:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
|
2002-11-03 09:24:07 +09:00
|
|
|
} else {
|
|
|
|
struct eth_device *dev = eth_devices;
|
2012-05-15 17:59:07 +09:00
|
|
|
char *ethprime = getenv("ethprime");
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2012-02-13 22:51:18 +09:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
|
2002-11-03 09:24:07 +09:00
|
|
|
do {
|
2011-10-27 20:31:35 +09:00
|
|
|
if (dev->index)
|
2012-05-15 17:59:07 +09:00
|
|
|
puts(", ");
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
printf("%s", dev->name);
|
|
|
|
|
2012-05-15 17:59:07 +09:00
|
|
|
if (ethprime && strcmp(dev->name, ethprime) == 0) {
|
2002-11-03 09:24:07 +09:00
|
|
|
eth_current = dev;
|
2012-05-15 17:59:07 +09:00
|
|
|
puts(" [PRIME]");
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
|
|
|
|
2010-06-10 11:10:48 +09:00
|
|
|
if (strchr(dev->name, ' '))
|
2012-05-15 17:59:07 +09:00
|
|
|
puts("\nWarning: eth device name has a space!"
|
|
|
|
"\n");
|
2010-06-10 11:10:48 +09:00
|
|
|
|
2014-07-13 17:27:02 +09:00
|
|
|
eth_write_hwaddr(dev, "eth", dev->index);
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
dev = dev->next;
|
2011-10-27 20:31:35 +09:00
|
|
|
num_devices++;
|
2012-05-15 17:59:07 +09:00
|
|
|
} while (dev != eth_devices);
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2011-02-17 04:14:33 +09:00
|
|
|
eth_current_changed();
|
2012-05-15 17:59:07 +09:00
|
|
|
putc('\n');
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
|
|
|
|
2011-10-27 20:31:35 +09:00
|
|
|
return num_devices;
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
|
|
|
|
2007-06-12 00:41:07 +09:00
|
|
|
#ifdef CONFIG_MCAST_TFTP
|
|
|
|
/* Multicast.
|
|
|
|
* mcast_addr: multicast ipaddr from which multicast Mac is made
|
2007-08-14 16:47:27 +09:00
|
|
|
* join: 1=join, 0=leave.
|
2007-06-12 00:41:07 +09:00
|
|
|
*/
|
2015-03-23 07:09:05 +09:00
|
|
|
int eth_mcast_join(IPaddr_t mcast_ip, int join)
|
2007-06-12 00:41:07 +09:00
|
|
|
{
|
2012-05-15 17:59:07 +09:00
|
|
|
u8 mcast_mac[6];
|
2007-08-14 16:47:27 +09:00
|
|
|
if (!eth_current || !eth_current->mcast)
|
2007-06-12 00:41:07 +09:00
|
|
|
return -1;
|
|
|
|
mcast_mac[5] = htonl(mcast_ip) & 0xff;
|
|
|
|
mcast_mac[4] = (htonl(mcast_ip)>>8) & 0xff;
|
|
|
|
mcast_mac[3] = (htonl(mcast_ip)>>16) & 0x7f;
|
|
|
|
mcast_mac[2] = 0x5e;
|
|
|
|
mcast_mac[1] = 0x0;
|
|
|
|
mcast_mac[0] = 0x1;
|
|
|
|
return eth_current->mcast(eth_current, mcast_mac, join);
|
|
|
|
}
|
|
|
|
|
2007-08-14 16:47:27 +09:00
|
|
|
/* the 'way' for ethernet-CRC-32. Spliced in from Linux lib/crc32.c
|
|
|
|
* and this is the ethernet-crc method needed for TSEC -- and perhaps
|
2007-06-12 00:41:07 +09:00
|
|
|
* some other adapter -- hash tables
|
|
|
|
*/
|
|
|
|
#define CRCPOLY_LE 0xedb88320
|
2012-05-15 17:59:07 +09:00
|
|
|
u32 ether_crc(size_t len, unsigned char const *p)
|
2007-06-12 00:41:07 +09:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u32 crc;
|
|
|
|
crc = ~0;
|
|
|
|
while (len--) {
|
|
|
|
crc ^= *p++;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
|
|
crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
|
|
|
|
}
|
|
|
|
/* an reverse the bits, cuz of way they arrive -- last-first */
|
|
|
|
crc = (crc >> 16) | (crc << 16);
|
|
|
|
crc = (crc >> 8 & 0x00ff00ff) | (crc << 8 & 0xff00ff00);
|
|
|
|
crc = (crc >> 4 & 0x0f0f0f0f) | (crc << 4 & 0xf0f0f0f0);
|
|
|
|
crc = (crc >> 2 & 0x33333333) | (crc << 2 & 0xcccccccc);
|
|
|
|
crc = (crc >> 1 & 0x55555555) | (crc << 1 & 0xaaaaaaaa);
|
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:06 +09:00
|
|
|
int eth_init(void)
|
2002-11-03 09:24:07 +09:00
|
|
|
{
|
2009-07-16 10:31:28 +09:00
|
|
|
struct eth_device *old_current, *dev;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2008-03-05 01:40:41 +09:00
|
|
|
if (!eth_current) {
|
2012-05-15 17:59:07 +09:00
|
|
|
puts("No ethernet found.\n");
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ENODEV;
|
2008-03-05 01:40:41 +09:00
|
|
|
}
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2009-07-16 10:31:28 +09:00
|
|
|
/* Sync environment with network devices */
|
|
|
|
dev = eth_devices;
|
|
|
|
do {
|
|
|
|
uchar env_enetaddr[6];
|
|
|
|
|
2011-10-27 20:31:35 +09:00
|
|
|
if (eth_getenv_enetaddr_by_index("eth", dev->index,
|
2011-06-14 08:13:10 +09:00
|
|
|
env_enetaddr))
|
2009-07-16 10:31:28 +09:00
|
|
|
memcpy(dev->enetaddr, env_enetaddr, 6);
|
|
|
|
|
|
|
|
dev = dev->next;
|
|
|
|
} while (dev != eth_devices);
|
|
|
|
|
2002-11-03 09:24:07 +09:00
|
|
|
old_current = eth_current;
|
|
|
|
do {
|
2009-07-23 16:01:03 +09:00
|
|
|
debug("Trying %s\n", eth_current->name);
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:06 +09:00
|
|
|
if (eth_current->init(eth_current, gd->bd) >= 0) {
|
2002-11-03 09:24:07 +09:00
|
|
|
eth_current->state = ETH_STATE_ACTIVE;
|
|
|
|
|
2007-11-29 15:46:13 +09:00
|
|
|
return 0;
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
2009-07-23 16:01:03 +09:00
|
|
|
debug("FAIL\n");
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
eth_try_another(0);
|
|
|
|
} while (old_current != eth_current);
|
|
|
|
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ETIMEDOUT;
|
2002-11-03 09:24:07 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
void eth_halt(void)
|
|
|
|
{
|
|
|
|
if (!eth_current)
|
|
|
|
return;
|
|
|
|
|
|
|
|
eth_current->halt(eth_current);
|
|
|
|
|
|
|
|
eth_current->state = ETH_STATE_PASSIVE;
|
|
|
|
}
|
|
|
|
|
2012-05-15 17:59:04 +09:00
|
|
|
int eth_send(void *packet, int length)
|
2002-11-03 09:24:07 +09:00
|
|
|
{
|
|
|
|
if (!eth_current)
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ENODEV;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
return eth_current->send(eth_current, packet, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_rx(void)
|
|
|
|
{
|
|
|
|
if (!eth_current)
|
2015-03-23 07:09:04 +09:00
|
|
|
return -ENODEV;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
|
|
|
return eth_current->recv(eth_current);
|
|
|
|
}
|
2015-03-23 07:09:10 +09:00
|
|
|
#endif /* ifndef CONFIG_DM_ETH */
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2007-12-28 02:19:02 +09:00
|
|
|
#ifdef CONFIG_API
|
2012-05-15 17:59:04 +09:00
|
|
|
static void eth_save_packet(void *packet, int length)
|
2007-12-28 02:19:02 +09:00
|
|
|
{
|
2012-05-15 17:59:04 +09:00
|
|
|
char *p = packet;
|
2007-12-28 02:19:02 +09:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((eth_rcv_last+1) % PKTBUFSRX == eth_rcv_current)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (PKTSIZE < length)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++)
|
|
|
|
eth_rcv_bufs[eth_rcv_last].data[i] = p[i];
|
|
|
|
|
|
|
|
eth_rcv_bufs[eth_rcv_last].length = length;
|
|
|
|
eth_rcv_last = (eth_rcv_last + 1) % PKTBUFSRX;
|
|
|
|
}
|
|
|
|
|
2012-05-15 17:59:04 +09:00
|
|
|
int eth_receive(void *packet, int length)
|
2007-12-28 02:19:02 +09:00
|
|
|
{
|
2012-05-15 17:59:04 +09:00
|
|
|
char *p = packet;
|
2007-12-28 02:19:02 +09:00
|
|
|
void *pp = push_packet;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (eth_rcv_current == eth_rcv_last) {
|
|
|
|
push_packet = eth_save_packet;
|
|
|
|
eth_rx();
|
|
|
|
push_packet = pp;
|
|
|
|
|
|
|
|
if (eth_rcv_current == eth_rcv_last)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-06-22 20:24:28 +09:00
|
|
|
length = min(eth_rcv_bufs[eth_rcv_current].length, length);
|
2007-12-28 02:19:02 +09:00
|
|
|
|
|
|
|
for (i = 0; i < length; i++)
|
|
|
|
p[i] = eth_rcv_bufs[eth_rcv_current].data[i];
|
|
|
|
|
|
|
|
eth_rcv_current = (eth_rcv_current + 1) % PKTBUFSRX;
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_API */
|
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
static void eth_current_changed(void)
|
|
|
|
{
|
|
|
|
char *act = getenv("ethact");
|
|
|
|
/* update current ethernet name */
|
|
|
|
if (eth_get_dev()) {
|
|
|
|
if (act == NULL || strcmp(act, eth_get_name()) != 0)
|
|
|
|
setenv("ethact", eth_get_name());
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* remove the variable completely if there is no active
|
|
|
|
* interface
|
|
|
|
*/
|
|
|
|
else if (act != NULL)
|
|
|
|
setenv("ethact", NULL);
|
|
|
|
}
|
|
|
|
|
2002-11-03 09:24:07 +09:00
|
|
|
void eth_try_another(int first_restart)
|
|
|
|
{
|
2015-03-23 07:09:10 +09:00
|
|
|
static void *first_failed;
|
2011-02-20 04:15:14 +09:00
|
|
|
char *ethrotate;
|
2008-01-17 15:45:05 +09:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do not rotate between network interfaces when
|
|
|
|
* 'ethrotate' variable is set to 'no'.
|
|
|
|
*/
|
2012-05-15 17:59:07 +09:00
|
|
|
ethrotate = getenv("ethrotate");
|
|
|
|
if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0))
|
2008-01-17 15:45:05 +09:00
|
|
|
return;
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
if (!eth_get_dev())
|
2002-11-03 09:24:07 +09:00
|
|
|
return;
|
|
|
|
|
2012-05-15 17:59:07 +09:00
|
|
|
if (first_restart)
|
2015-03-23 07:09:03 +09:00
|
|
|
first_failed = eth_get_dev();
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
eth_set_current_to_next();
|
2002-11-03 09:24:07 +09:00
|
|
|
|
2011-02-17 04:14:33 +09:00
|
|
|
eth_current_changed();
|
2004-04-16 06:48:45 +09:00
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
if (first_failed == eth_get_dev())
|
2002-11-03 09:24:07 +09:00
|
|
|
NetRestartWrap = 1;
|
|
|
|
}
|
|
|
|
|
2004-04-16 06:48:45 +09:00
|
|
|
void eth_set_current(void)
|
|
|
|
{
|
2012-05-15 17:59:07 +09:00
|
|
|
static char *act;
|
|
|
|
static int env_changed_id;
|
2009-02-10 17:38:52 +09:00
|
|
|
int env_id;
|
2004-04-16 06:48:45 +09:00
|
|
|
|
2009-02-10 17:38:52 +09:00
|
|
|
env_id = get_env_id();
|
|
|
|
if ((act == NULL) || (env_changed_id != env_id)) {
|
|
|
|
act = getenv("ethact");
|
|
|
|
env_changed_id = env_id;
|
|
|
|
}
|
2015-03-23 07:09:17 +09:00
|
|
|
|
|
|
|
if (act == NULL) {
|
|
|
|
char *ethprime = getenv("ethprime");
|
|
|
|
void *dev = NULL;
|
|
|
|
|
|
|
|
if (ethprime)
|
|
|
|
dev = eth_get_dev_by_name(ethprime);
|
|
|
|
if (dev)
|
|
|
|
eth_set_dev(dev);
|
|
|
|
else
|
|
|
|
eth_set_dev(NULL);
|
|
|
|
} else {
|
2015-03-23 07:09:16 +09:00
|
|
|
eth_set_dev(eth_get_dev_by_name(act));
|
2015-03-23 07:09:17 +09:00
|
|
|
}
|
2004-04-16 06:48:45 +09:00
|
|
|
|
2011-02-17 04:14:33 +09:00
|
|
|
eth_current_changed();
|
2004-04-16 06:48:45 +09:00
|
|
|
}
|
|
|
|
|
2015-03-23 07:09:03 +09:00
|
|
|
const char *eth_get_name(void)
|
2003-11-18 06:14:37 +09:00
|
|
|
{
|
2015-03-23 07:09:03 +09:00
|
|
|
return eth_get_dev() ? eth_get_dev()->name : "unknown";
|
2003-11-18 06:14:37 +09:00
|
|
|
}
|