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