[people/ms/u-boot.git] / net / eth-uclass.c

/*
 * (C) Copyright 2001-2015
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 * Joe Hershberger, National Instruments
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <environment.h>
#include <net.h>
#include <dm/device-internal.h>
#include <dm/uclass-internal.h>
#include "eth_internal.h"

DECLARE_GLOBAL_DATA_PTR;

/**
 * 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;
};

/* eth_errno - This stores the most recent failure code from DM functions */
static int eth_errno;

static struct eth_uclass_priv *eth_get_uclass_priv(void)
{
	struct uclass *uc;

	uclass_get(UCLASS_ETH, &uc);
	assert(uc);
	return uc->priv;
}

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);
}

/*
 * 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.
 */
struct udevice *eth_get_dev(void)
{
	struct eth_uclass_priv *uc_priv;

	uc_priv = eth_get_uclass_priv();
	if (!uc_priv->current)
		eth_errno = uclass_first_device(UCLASS_ETH,
				    &uc_priv->current);
	return uc_priv->current;
}

/*
 * 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.
 */
void eth_set_dev(struct udevice *dev)
{
	if (dev && !device_active(dev)) {
		eth_errno = device_probe(dev);
		if (eth_errno)
			dev = NULL;
	}

	eth_get_uclass_priv()->current = dev;
}

/*
 * 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;
	int len = strlen("eth");

	/* Must be longer than 3 to be an alias */
	if (!strncmp(devname, "eth", len) && strlen(devname) > len) {
		startp = devname + len;
		seq = simple_strtoul(startp, &endp, 10);
	}

	uclass_get(UCLASS_ETH, &uc);
	uclass_foreach_dev(it, uc) {
		/*
		 * 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().
		 */
		if (device_probe(it))
			continue;
		/* 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;
}

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;
}

static int eth_write_hwaddr(struct udevice *dev)
{
	struct eth_pdata *pdata;
	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)) {
		pdata = dev->platdata;
		if (!is_valid_ethaddr(pdata->enetaddr)) {
			printf("\nError: %s address %pM illegal value\n",
			       dev->name, pdata->enetaddr);
			return -EINVAL;
		}

		/*
		 * Drivers are allowed to decide not to implement this at
		 * run-time. E.g. Some devices may use it and some may not.
		 */
		ret = eth_get_ops(dev)->write_hwaddr(dev);
		if (ret == -ENOSYS)
			ret = 0;
		if (ret)
			printf("\nWarning: %s failed to set MAC address\n",
			       dev->name);
	}

	return ret;
}

static int on_ethaddr(const char *name, const char *value, enum env_op op,
	int flags)
{
	int index;
	int retval;
	struct udevice *dev;

	/* look for an index after "eth" */
	index = simple_strtoul(name + 3, NULL, 10);

	retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
	if (!retval) {
		struct eth_pdata *pdata = dev->platdata;
		switch (op) {
		case env_op_create:
		case env_op_overwrite:
			eth_parse_enetaddr(value, pdata->enetaddr);
			eth_write_hwaddr(dev);
			break;
		case env_op_delete:
			memset(pdata->enetaddr, 0, ARP_HLEN);
		}
	}

	return 0;
}
U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);

int eth_init(void)
{
	char *ethact = getenv("ethact");
	char *ethrotate = getenv("ethrotate");
	struct udevice *current = NULL;
	struct udevice *old_current;
	int ret = -ENODEV;

	/*
	 * When 'ethrotate' variable is set to 'no' and 'ethact' variable
	 * is already set to an ethernet device, we should stick to 'ethact'.
	 */
	if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) {
		if (ethact) {
			current = eth_get_dev_by_name(ethact);
			if (!current)
				return -EINVAL;
		}
	}

	if (!current) {
		current = eth_get_dev();
		if (!current) {
			printf("No ethernet found.\n");
			return -ENODEV;
		}
	}

	old_current = current;
	do {
		if (current) {
			debug("Trying %s\n", current->name);

			if (device_active(current)) {
				ret = eth_get_ops(current)->start(current);
				if (ret >= 0) {
					struct eth_device_priv *priv =
						current->uclass_priv;

					priv->state = ETH_STATE_ACTIVE;
					return 0;
				}
			} else {
				ret = eth_errno;
			}

			debug("FAIL\n");
		} else {
			debug("PROBE FAIL\n");
		}

		/*
		 * If ethrotate is enabled, this will change "current",
		 * otherwise we will drop out of this while loop immediately
		 */
		eth_try_another(0);
		/* This will ensure the new "current" attempted to probe */
		current = eth_get_dev();
	} while (old_current != current);

	return ret;
}

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_is_active(struct udevice *dev)
{
	struct eth_device_priv *priv;

	if (!dev || !device_active(dev))
		return 0;

	priv = dev_get_uclass_priv(dev);
	return priv->state == ETH_STATE_ACTIVE;
}

int eth_send(void *packet, int length)
{
	struct udevice *current;
	int ret;

	current = eth_get_dev();
	if (!current)
		return -ENODEV;

	if (!device_active(current))
		return -EINVAL;

	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;
}

int eth_rx(void)
{
	struct udevice *current;
	uchar *packet;
	int flags;
	int ret;
	int i;

	current = eth_get_dev();
	if (!current)
		return -ENODEV;

	if (!device_active(current))
		return -EINVAL;

	/* Process up to 32 packets at one time */
	flags = ETH_RECV_CHECK_DEVICE;
	for (i = 0; i < 32; i++) {
		ret = eth_get_ops(current)->recv(current, flags, &packet);
		flags = 0;
		if (ret > 0)
			net_process_received_packet(packet, ret);
		if (ret >= 0 && eth_get_ops(current)->free_pkt)
			eth_get_ops(current)->free_pkt(current, packet, ret);
		if (ret <= 0)
			break;
	}
	if (ret == -EAGAIN)
		ret = 0;
	if (ret < 0) {
		/* We cannot completely return the error at present */
		debug("%s: recv() returned error %d\n", __func__, ret);
	}
	return ret;
}

int eth_initialize(void)
{
	int num_devices = 0;
	struct udevice *dev;

	eth_common_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 {
		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);
		}

		bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
		do {
			if (num_devices)
				printf(", ");

			printf("eth%d: %s", dev->seq, dev->name);

			if (ethprime && dev == prime_dev)
				printf(" [PRIME]");

			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[ARP_HLEN];

#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	struct eth_ops *ops = eth_get_ops(dev);
	static int reloc_done;

	if (!reloc_done) {
		if (ops->start)
			ops->start += gd->reloc_off;
		if (ops->send)
			ops->send += gd->reloc_off;
		if (ops->recv)
			ops->recv += gd->reloc_off;
		if (ops->free_pkt)
			ops->free_pkt += gd->reloc_off;
		if (ops->stop)
			ops->stop += gd->reloc_off;
#ifdef CONFIG_MCAST_TFTP
		if (ops->mcast)
			ops->mcast += gd->reloc_off;
#endif
		if (ops->write_hwaddr)
			ops->write_hwaddr += gd->reloc_off;
		if (ops->read_rom_hwaddr)
			ops->read_rom_hwaddr += gd->reloc_off;

		reloc_done++;
	}
#endif

	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_ethaddr(env_enetaddr)) {
		if (!is_zero_ethaddr(pdata->enetaddr) &&
		    memcmp(pdata->enetaddr, env_enetaddr, ARP_HLEN)) {
			printf("\nWarning: %s MAC addresses don't match:\n",
			       dev->name);
			printf("Address in ROM is          %pM\n",
			       pdata->enetaddr);
			printf("Address in environment is  %pM\n",
			       env_enetaddr);
		}

		/* Override the ROM MAC address */
		memcpy(pdata->enetaddr, env_enetaddr, ARP_HLEN);
	} else if (is_valid_ethaddr(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_ethaddr(pdata->enetaddr) ||
		   !is_valid_ethaddr(pdata->enetaddr)) {
#ifdef CONFIG_NET_RANDOM_ETHADDR
		net_random_ethaddr(pdata->enetaddr);
		printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
		       dev->name, dev->seq, pdata->enetaddr);
#else
		printf("\nError: %s address not set.\n",
		       dev->name);
		return -EINVAL;
#endif
	}

	return 0;
}

static int eth_pre_remove(struct udevice *dev)
{
	struct eth_pdata *pdata = dev->platdata;

	eth_get_ops(dev)->stop(dev);

	/* clear the MAC address */
	memset(pdata->enetaddr, 0, ARP_HLEN);

	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),
	.flags		= DM_UC_FLAG_SEQ_ALIAS,
};
Commit	Line	Data
db9391e1 SG	1	/*
	2	* (C) Copyright 2001-2015
	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	4	* Joe Hershberger, National Instruments
	5	*
	6	* SPDX-License-Identifier: GPL-2.0+
	7	*/
	8
	9	#include <common.h>
	10	#include <dm.h>
	11	#include <environment.h>
	12	#include <net.h>
	13	#include <dm/device-internal.h>
	14	#include <dm/uclass-internal.h>
	15	#include "eth_internal.h"
	16
a7c45ec4 SG	17	DECLARE_GLOBAL_DATA_PTR;
a7c45ec4 SG	18
db9391e1 SG	19	/**
	20	* struct eth_device_priv - private structure for each Ethernet device
	21	*
	22	* @state: The state of the Ethernet MAC driver (defined by enum eth_state_t)
	23	*/
	24	struct eth_device_priv {
	25	enum eth_state_t state;
	26	};
	27
	28	/**
	29	* struct eth_uclass_priv - The structure attached to the uclass itself
	30	*
	31	* @current: The Ethernet device that the network functions are using
	32	*/
	33	struct eth_uclass_priv {
	34	struct udevice *current;
	35	};
	36
	37	/* eth_errno - This stores the most recent failure code from DM functions */
	38	static int eth_errno;
	39
	40	static struct eth_uclass_priv *eth_get_uclass_priv(void)
	41	{
	42	struct uclass *uc;
	43
	44	uclass_get(UCLASS_ETH, &uc);
	45	assert(uc);
	46	return uc->priv;
	47	}
	48
	49	void eth_set_current_to_next(void)
	50	{
	51	struct eth_uclass_priv *uc_priv;
	52
	53	uc_priv = eth_get_uclass_priv();
	54	if (uc_priv->current)
	55	uclass_next_device(&uc_priv->current);
	56	if (!uc_priv->current)
	57	uclass_first_device(UCLASS_ETH, &uc_priv->current);
	58	}
	59
	60	/*
	61	* Typically this will simply return the active device.
	62	* In the case where the most recent active device was unset, this will attempt
	63	* to return the first device. If that device doesn't exist or fails to probe,
	64	* this function will return NULL.
	65	*/
	66	struct udevice *eth_get_dev(void)
	67	{
	68	struct eth_uclass_priv *uc_priv;
	69
	70	uc_priv = eth_get_uclass_priv();
	71	if (!uc_priv->current)
	72	eth_errno = uclass_first_device(UCLASS_ETH,
	73	&uc_priv->current);
	74	return uc_priv->current;
	75	}
	76
	77	/*
	78	* Typically this will just store a device pointer.
	79	* In case it was not probed, we will attempt to do so.
	80	* dev may be NULL to unset the active device.
	81	*/
	82	void eth_set_dev(struct udevice *dev)
83	{
84	if (dev && !device_active(dev)) {
85	eth_errno = device_probe(dev);
86	if (eth_errno)
87	dev = NULL;
88	}
89
90	eth_get_uclass_priv()->current = dev;
91	}
92
93	/*
94	* Find the udevice that either has the name passed in as devname or has an
95	* alias named devname.
96	*/
97	struct udevice eth_get_dev_by_name(const char devname)
98	{
99	int seq = -1;
100	char *endp = NULL;
101	const char *startp = NULL;
102	struct udevice *it;
103	struct uclass *uc;
104	int len = strlen("eth");
105
106	/* Must be longer than 3 to be an alias */
107	if (!strncmp(devname, "eth", len) && strlen(devname) > len) {
108	startp = devname + len;
109	seq = simple_strtoul(startp, &endp, 10);
110	}
111
112	uclass_get(UCLASS_ETH, &uc);
113	uclass_foreach_dev(it, uc) {
114	/*
115	* We need the seq to be valid, so try to probe it.
116	* If the probe fails, the seq will not match since it will be
117	* -1 instead of what we are looking for.
118	* We don't care about errors from probe here. Either they won't
119	* match an alias or it will match a literal name and we'll pick
120	* up the error when we try to probe again in eth_set_dev().
121	*/
122	if (device_probe(it))
123	continue;
124	/* Check for the name or the sequence number to match */
125	if (strcmp(it->name, devname) == 0 \|\|
126	(endp > startp && it->seq == seq))
127	return it;
128	}
129
130	return NULL;
131	}
132
133	unsigned char *eth_get_ethaddr(void)
134	{
135	struct eth_pdata *pdata;
136
137	if (eth_get_dev()) {
138	pdata = eth_get_dev()->platdata;
139	return pdata->enetaddr;
140	}
141
142	return NULL;
143	}
144
145	/* Set active state without calling start on the driver */
146	int eth_init_state_only(void)
147	{
148	struct udevice *current;
149	struct eth_device_priv *priv;
150
151	current = eth_get_dev();
152	if (!current \|\| !device_active(current))
153	return -EINVAL;
154
155	priv = current->uclass_priv;
156	priv->state = ETH_STATE_ACTIVE;
157
158	return 0;
159	}
160
161	/* Set passive state without calling stop on the driver */
162	void eth_halt_state_only(void)
163	{
164	struct udevice *current;
165	struct eth_device_priv *priv;
166
167	current = eth_get_dev();
168	if (!current \|\| !device_active(current))
169	return;
170
171	priv = current->uclass_priv;
172	priv->state = ETH_STATE_PASSIVE;
173	}
174
175	int eth_get_dev_index(void)
176	{
177	if (eth_get_dev())
178	return eth_get_dev()->seq;
179	return -1;
180	}
181
182	static int eth_write_hwaddr(struct udevice *dev)
183	{
c08248d6	184	struct eth_pdata *pdata;
db9391e1 SG	185	int ret = 0;
	186
	187	if (!dev \|\| !device_active(dev))
	188	return -EINVAL;
	189
	190	/* seq is valid since the device is active */
	191	if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev->seq)) {
c08248d6	192	pdata = dev->platdata;
db9391e1 SG	193	if (!is_valid_ethaddr(pdata->enetaddr)) {
	194	printf("\nError: %s address %pM illegal value\n",
	195	dev->name, pdata->enetaddr);
	196	return -EINVAL;
	197	}
	198
	199	/*
	200	* Drivers are allowed to decide not to implement this at
	201	* run-time. E.g. Some devices may use it and some may not.
	202	*/
	203	ret = eth_get_ops(dev)->write_hwaddr(dev);
	204	if (ret == -ENOSYS)
	205	ret = 0;
	206	if (ret)
	207	printf("\nWarning: %s failed to set MAC address\n",
	208	dev->name);
	209	}
	210
	211	return ret;
	212	}
	213
	214	static int on_ethaddr(const char name, const char value, enum env_op op,
	215	int flags)
	216	{
	217	int index;
	218	int retval;
	219	struct udevice *dev;
	220
	221	/* look for an index after "eth" */
	222	index = simple_strtoul(name + 3, NULL, 10);
	223
	224	retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
	225	if (!retval) {
	226	struct eth_pdata *pdata = dev->platdata;
	227	switch (op) {
	228	case env_op_create:
	229	case env_op_overwrite:
	230	eth_parse_enetaddr(value, pdata->enetaddr);
c86ff7fd	231	eth_write_hwaddr(dev);
db9391e1 SG	232	break;
db9391e1 SG	233	case env_op_delete:
a40db6d5	234	memset(pdata->enetaddr, 0, ARP_HLEN);
db9391e1 SG	235	}
	236	}
	237
	238	return 0;
	239	}
	240	U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
	241
	242	int eth_init(void)
	243	{
	244	char *ethact = getenv("ethact");
	245	char *ethrotate = getenv("ethrotate");
	246	struct udevice *current = NULL;
	247	struct udevice *old_current;
	248	int ret = -ENODEV;
	249
	250	/*
	251	* When 'ethrotate' variable is set to 'no' and 'ethact' variable
	252	* is already set to an ethernet device, we should stick to 'ethact'.
	253	*/
	254	if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) {
	255	if (ethact) {
	256	current = eth_get_dev_by_name(ethact);
	257	if (!current)
	258	return -EINVAL;
	259	}
	260	}
	261
	262	if (!current) {
	263	current = eth_get_dev();
	264	if (!current) {
	265	printf("No ethernet found.\n");
	266	return -ENODEV;
	267	}
	268	}
	269
	270	old_current = current;
	271	do {
	272	if (current) {
	273	debug("Trying %s\n", current->name);
	274
	275	if (device_active(current)) {
	276	ret = eth_get_ops(current)->start(current);
	277	if (ret >= 0) {
	278	struct eth_device_priv *priv =
	279	current->uclass_priv;
	280
	281	priv->state = ETH_STATE_ACTIVE;
	282	return 0;
	283	}
	284	} else {
	285	ret = eth_errno;
	286	}
	287
	288	debug("FAIL\n");
	289	} else {
	290	debug("PROBE FAIL\n");
	291	}
	292
	293	/*
	294	* If ethrotate is enabled, this will change "current",
	295	* otherwise we will drop out of this while loop immediately
	296	*/
	297	eth_try_another(0);
	298	/* This will ensure the new "current" attempted to probe */
299	current = eth_get_dev();
300	} while (old_current != current);
301
302	return ret;
303	}
304
305	void eth_halt(void)
306	{
307	struct udevice *current;
308	struct eth_device_priv *priv;
309
310	current = eth_get_dev();
311	if (!current \|\| !device_active(current))
312	return;
313
314	eth_get_ops(current)->stop(current);
315	priv = current->uclass_priv;
316	priv->state = ETH_STATE_PASSIVE;
317	}
318
319	int eth_is_active(struct udevice *dev)
320	{
321	struct eth_device_priv *priv;
322
323	if (!dev \|\| !device_active(dev))
324	return 0;
325
326	priv = dev_get_uclass_priv(dev);
327	return priv->state == ETH_STATE_ACTIVE;
328	}
329
330	int eth_send(void *packet, int length)
331	{
332	struct udevice *current;
333	int ret;
334
335	current = eth_get_dev();
336	if (!current)
337	return -ENODEV;
338
339	if (!device_active(current))
340	return -EINVAL;
341
342	ret = eth_get_ops(current)->send(current, packet, length);
343	if (ret < 0) {
344	/* We cannot completely return the error at present */
345	debug("%s: send() returned error %d\n", __func__, ret);
346	}
347	return ret;
348	}
349
350	int eth_rx(void)
351	{
352	struct udevice *current;
353	uchar *packet;
354	int flags;
355	int ret;
356	int i;
357
358	current = eth_get_dev();
359	if (!current)
360	return -ENODEV;
361
362	if (!device_active(current))
363	return -EINVAL;
364
365	/* Process up to 32 packets at one time */
366	flags = ETH_RECV_CHECK_DEVICE;
367	for (i = 0; i < 32; i++) {
368	ret = eth_get_ops(current)->recv(current, flags, &packet);
369	flags = 0;
370	if (ret > 0)
371	net_process_received_packet(packet, ret);
372	if (ret >= 0 && eth_get_ops(current)->free_pkt)
373	eth_get_ops(current)->free_pkt(current, packet, ret);
374	if (ret <= 0)
375	break;
376	}
377	if (ret == -EAGAIN)
378	ret = 0;
379	if (ret < 0) {
380	/* We cannot completely return the error at present */
381	debug("%s: recv() returned error %d\n", __func__, ret);
382	}
383	return ret;
384	}
385
386	int eth_initialize(void)
387	{
388	int num_devices = 0;
389	struct udevice *dev;
390
391	eth_common_init();
392
393	/*
394	* Devices need to write the hwaddr even if not started so that Linux
395	* will have access to the hwaddr that u-boot stored for the device.
396	* This is accomplished by attempting to probe each device and calling
397	* their write_hwaddr() operation.
398	*/
399	uclass_first_device(UCLASS_ETH, &dev);
400	if (!dev) {
401	printf("No ethernet found.\n");
402	bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
403	} else {
404	char *ethprime = getenv("ethprime");
405	struct udevice *prime_dev = NULL;
406
407	if (ethprime)
408	prime_dev = eth_get_dev_by_name(ethprime);
409	if (prime_dev) {
410	eth_set_dev(prime_dev);
411	eth_current_changed();
412	} else {
413	eth_set_dev(NULL);
414	}
415
416	bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
417	do {
418	if (num_devices)
419	printf(", ");
420
421	printf("eth%d: %s", dev->seq, dev->name);
422
423	if (ethprime && dev == prime_dev)
424	printf(" [PRIME]");
425
426	eth_write_hwaddr(dev);
427
428	uclass_next_device(&dev);
429	num_devices++;
430	} while (dev);
431
432	putc('\n');
433	}
434
435	return num_devices;
436	}
437
438	static int eth_post_bind(struct udevice *dev)
439	{
440	if (strchr(dev->name, ' ')) {
441	printf("\nError: eth device name \"%s\" has a space!\n",
442	dev->name);
443	return -EINVAL;
444	}
445
446	return 0;
447	}
448
449	static int eth_pre_unbind(struct udevice *dev)
450	{
451	/* Don't hang onto a pointer that is going away */
452	if (dev == eth_get_uclass_priv()->current)
453	eth_set_dev(NULL);
454
455	return 0;
456	}
457
458	static int eth_post_probe(struct udevice *dev)
459	{
460	struct eth_device_priv *priv = dev->uclass_priv;
461	struct eth_pdata *pdata = dev->platdata;
a40db6d5	462	unsigned char env_enetaddr[ARP_HLEN];
db9391e1 SG	463
	464	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	465	struct eth_ops *ops = eth_get_ops(dev);
	466	static int reloc_done;
	467
	468	if (!reloc_done) {
	469	if (ops->start)
	470	ops->start += gd->reloc_off;
	471	if (ops->send)
	472	ops->send += gd->reloc_off;
	473	if (ops->recv)
	474	ops->recv += gd->reloc_off;
	475	if (ops->free_pkt)
	476	ops->free_pkt += gd->reloc_off;
	477	if (ops->stop)
	478	ops->stop += gd->reloc_off;
	479	#ifdef CONFIG_MCAST_TFTP
	480	if (ops->mcast)
	481	ops->mcast += gd->reloc_off;
	482	#endif
	483	if (ops->write_hwaddr)
	484	ops->write_hwaddr += gd->reloc_off;
	485	if (ops->read_rom_hwaddr)
	486	ops->read_rom_hwaddr += gd->reloc_off;
	487
	488	reloc_done++;
	489	}
	490	#endif
	491
	492	priv->state = ETH_STATE_INIT;
	493
	494	/* Check if the device has a MAC address in ROM */
	495	if (eth_get_ops(dev)->read_rom_hwaddr)
	496	eth_get_ops(dev)->read_rom_hwaddr(dev);
	497
	498	eth_getenv_enetaddr_by_index("eth", dev->seq, env_enetaddr);
	499	if (!is_zero_ethaddr(env_enetaddr)) {
	500	if (!is_zero_ethaddr(pdata->enetaddr) &&
a40db6d5	501	memcmp(pdata->enetaddr, env_enetaddr, ARP_HLEN)) {
db9391e1 SG	502	printf("\nWarning: %s MAC addresses don't match:\n",
db9391e1 SG	503	dev->name);
26d40b0a	504	printf("Address in ROM is %pM\n",
db9391e1 SG	505	pdata->enetaddr);
	506	printf("Address in environment is %pM\n",
	507	env_enetaddr);
	508	}
	509
	510	/* Override the ROM MAC address */
a40db6d5	511	memcpy(pdata->enetaddr, env_enetaddr, ARP_HLEN);
db9391e1 SG	512	} else if (is_valid_ethaddr(pdata->enetaddr)) {
	513	eth_setenv_enetaddr_by_index("eth", dev->seq, pdata->enetaddr);
	514	printf("\nWarning: %s using MAC address from ROM\n",
	515	dev->name);
aa555fe9 SDPP	516	} else if (is_zero_ethaddr(pdata->enetaddr) \|\|
aa555fe9 SDPP	517	!is_valid_ethaddr(pdata->enetaddr)) {
db9391e1 SG	518	#ifdef CONFIG_NET_RANDOM_ETHADDR
	519	net_random_ethaddr(pdata->enetaddr);
	520	printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
	521	dev->name, dev->seq, pdata->enetaddr);
	522	#else
	523	printf("\nError: %s address not set.\n",
	524	dev->name);
	525	return -EINVAL;
	526	#endif
	527	}
	528
	529	return 0;
	530	}
	531
	532	static int eth_pre_remove(struct udevice *dev)
	533	{
	534	struct eth_pdata *pdata = dev->platdata;
	535
	536	eth_get_ops(dev)->stop(dev);
	537
	538	/* clear the MAC address */
a40db6d5	539	memset(pdata->enetaddr, 0, ARP_HLEN);
db9391e1 SG	540
	541	return 0;
	542	}
	543
	544	UCLASS_DRIVER(eth) = {
	545	.name = "eth",
	546	.id = UCLASS_ETH,
	547	.post_bind = eth_post_bind,
	548	.pre_unbind = eth_pre_unbind,
	549	.post_probe = eth_post_probe,
	550	.pre_remove = eth_pre_remove,
	551	.priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
	552	.per_device_auto_alloc_size = sizeof(struct eth_device_priv),
	553	.flags = DM_UC_FLAG_SEQ_ALIAS,
	554	};