xref: /openbmc/u-boot/net/eth-uclass.c (revision aea02abe)
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 
17 DECLARE_GLOBAL_DATA_PTR;
18 
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 {
184 	struct eth_pdata *pdata = dev->platdata;
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)) {
192 		if (!is_valid_ethaddr(pdata->enetaddr)) {
193 			printf("\nError: %s address %pM illegal value\n",
194 			       dev->name, pdata->enetaddr);
195 			return -EINVAL;
196 		}
197 
198 		/*
199 		 * Drivers are allowed to decide not to implement this at
200 		 * run-time. E.g. Some devices may use it and some may not.
201 		 */
202 		ret = eth_get_ops(dev)->write_hwaddr(dev);
203 		if (ret == -ENOSYS)
204 			ret = 0;
205 		if (ret)
206 			printf("\nWarning: %s failed to set MAC address\n",
207 			       dev->name);
208 	}
209 
210 	return ret;
211 }
212 
213 static int on_ethaddr(const char *name, const char *value, enum env_op op,
214 	int flags)
215 {
216 	int index;
217 	int retval;
218 	struct udevice *dev;
219 
220 	/* look for an index after "eth" */
221 	index = simple_strtoul(name + 3, NULL, 10);
222 
223 	retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
224 	if (!retval) {
225 		struct eth_pdata *pdata = dev->platdata;
226 		switch (op) {
227 		case env_op_create:
228 		case env_op_overwrite:
229 			eth_parse_enetaddr(value, pdata->enetaddr);
230 			break;
231 		case env_op_delete:
232 			memset(pdata->enetaddr, 0, 6);
233 		}
234 	}
235 
236 	return 0;
237 }
238 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
239 
240 int eth_init(void)
241 {
242 	char *ethact = getenv("ethact");
243 	char *ethrotate = getenv("ethrotate");
244 	struct udevice *current = NULL;
245 	struct udevice *old_current;
246 	int ret = -ENODEV;
247 
248 	/*
249 	 * When 'ethrotate' variable is set to 'no' and 'ethact' variable
250 	 * is already set to an ethernet device, we should stick to 'ethact'.
251 	 */
252 	if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) {
253 		if (ethact) {
254 			current = eth_get_dev_by_name(ethact);
255 			if (!current)
256 				return -EINVAL;
257 		}
258 	}
259 
260 	if (!current) {
261 		current = eth_get_dev();
262 		if (!current) {
263 			printf("No ethernet found.\n");
264 			return -ENODEV;
265 		}
266 	}
267 
268 	old_current = current;
269 	do {
270 		if (current) {
271 			debug("Trying %s\n", current->name);
272 
273 			if (device_active(current)) {
274 				ret = eth_get_ops(current)->start(current);
275 				if (ret >= 0) {
276 					struct eth_device_priv *priv =
277 						current->uclass_priv;
278 
279 					priv->state = ETH_STATE_ACTIVE;
280 					return 0;
281 				}
282 			} else {
283 				ret = eth_errno;
284 			}
285 
286 			debug("FAIL\n");
287 		} else {
288 			debug("PROBE FAIL\n");
289 		}
290 
291 		/*
292 		 * If ethrotate is enabled, this will change "current",
293 		 * otherwise we will drop out of this while loop immediately
294 		 */
295 		eth_try_another(0);
296 		/* This will ensure the new "current" attempted to probe */
297 		current = eth_get_dev();
298 	} while (old_current != current);
299 
300 	return ret;
301 }
302 
303 void eth_halt(void)
304 {
305 	struct udevice *current;
306 	struct eth_device_priv *priv;
307 
308 	current = eth_get_dev();
309 	if (!current || !device_active(current))
310 		return;
311 
312 	eth_get_ops(current)->stop(current);
313 	priv = current->uclass_priv;
314 	priv->state = ETH_STATE_PASSIVE;
315 }
316 
317 int eth_is_active(struct udevice *dev)
318 {
319 	struct eth_device_priv *priv;
320 
321 	if (!dev || !device_active(dev))
322 		return 0;
323 
324 	priv = dev_get_uclass_priv(dev);
325 	return priv->state == ETH_STATE_ACTIVE;
326 }
327 
328 int eth_send(void *packet, int length)
329 {
330 	struct udevice *current;
331 	int ret;
332 
333 	current = eth_get_dev();
334 	if (!current)
335 		return -ENODEV;
336 
337 	if (!device_active(current))
338 		return -EINVAL;
339 
340 	ret = eth_get_ops(current)->send(current, packet, length);
341 	if (ret < 0) {
342 		/* We cannot completely return the error at present */
343 		debug("%s: send() returned error %d\n", __func__, ret);
344 	}
345 	return ret;
346 }
347 
348 int eth_rx(void)
349 {
350 	struct udevice *current;
351 	uchar *packet;
352 	int flags;
353 	int ret;
354 	int i;
355 
356 	current = eth_get_dev();
357 	if (!current)
358 		return -ENODEV;
359 
360 	if (!device_active(current))
361 		return -EINVAL;
362 
363 	/* Process up to 32 packets at one time */
364 	flags = ETH_RECV_CHECK_DEVICE;
365 	for (i = 0; i < 32; i++) {
366 		ret = eth_get_ops(current)->recv(current, flags, &packet);
367 		flags = 0;
368 		if (ret > 0)
369 			net_process_received_packet(packet, ret);
370 		if (ret >= 0 && eth_get_ops(current)->free_pkt)
371 			eth_get_ops(current)->free_pkt(current, packet, ret);
372 		if (ret <= 0)
373 			break;
374 	}
375 	if (ret == -EAGAIN)
376 		ret = 0;
377 	if (ret < 0) {
378 		/* We cannot completely return the error at present */
379 		debug("%s: recv() returned error %d\n", __func__, ret);
380 	}
381 	return ret;
382 }
383 
384 int eth_initialize(void)
385 {
386 	int num_devices = 0;
387 	struct udevice *dev;
388 
389 	eth_common_init();
390 
391 	/*
392 	 * Devices need to write the hwaddr even if not started so that Linux
393 	 * will have access to the hwaddr that u-boot stored for the device.
394 	 * This is accomplished by attempting to probe each device and calling
395 	 * their write_hwaddr() operation.
396 	 */
397 	uclass_first_device(UCLASS_ETH, &dev);
398 	if (!dev) {
399 		printf("No ethernet found.\n");
400 		bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
401 	} else {
402 		char *ethprime = getenv("ethprime");
403 		struct udevice *prime_dev = NULL;
404 
405 		if (ethprime)
406 			prime_dev = eth_get_dev_by_name(ethprime);
407 		if (prime_dev) {
408 			eth_set_dev(prime_dev);
409 			eth_current_changed();
410 		} else {
411 			eth_set_dev(NULL);
412 		}
413 
414 		bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
415 		do {
416 			if (num_devices)
417 				printf(", ");
418 
419 			printf("eth%d: %s", dev->seq, dev->name);
420 
421 			if (ethprime && dev == prime_dev)
422 				printf(" [PRIME]");
423 
424 			eth_write_hwaddr(dev);
425 
426 			uclass_next_device(&dev);
427 			num_devices++;
428 		} while (dev);
429 
430 		putc('\n');
431 	}
432 
433 	return num_devices;
434 }
435 
436 static int eth_post_bind(struct udevice *dev)
437 {
438 	if (strchr(dev->name, ' ')) {
439 		printf("\nError: eth device name \"%s\" has a space!\n",
440 		       dev->name);
441 		return -EINVAL;
442 	}
443 
444 	return 0;
445 }
446 
447 static int eth_pre_unbind(struct udevice *dev)
448 {
449 	/* Don't hang onto a pointer that is going away */
450 	if (dev == eth_get_uclass_priv()->current)
451 		eth_set_dev(NULL);
452 
453 	return 0;
454 }
455 
456 static int eth_post_probe(struct udevice *dev)
457 {
458 	struct eth_device_priv *priv = dev->uclass_priv;
459 	struct eth_pdata *pdata = dev->platdata;
460 	unsigned char env_enetaddr[6];
461 
462 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
463 	struct eth_ops *ops = eth_get_ops(dev);
464 	static int reloc_done;
465 
466 	if (!reloc_done) {
467 		if (ops->start)
468 			ops->start += gd->reloc_off;
469 		if (ops->send)
470 			ops->send += gd->reloc_off;
471 		if (ops->recv)
472 			ops->recv += gd->reloc_off;
473 		if (ops->free_pkt)
474 			ops->free_pkt += gd->reloc_off;
475 		if (ops->stop)
476 			ops->stop += gd->reloc_off;
477 #ifdef CONFIG_MCAST_TFTP
478 		if (ops->mcast)
479 			ops->mcast += gd->reloc_off;
480 #endif
481 		if (ops->write_hwaddr)
482 			ops->write_hwaddr += gd->reloc_off;
483 		if (ops->read_rom_hwaddr)
484 			ops->read_rom_hwaddr += gd->reloc_off;
485 
486 		reloc_done++;
487 	}
488 #endif
489 
490 	priv->state = ETH_STATE_INIT;
491 
492 	/* Check if the device has a MAC address in ROM */
493 	if (eth_get_ops(dev)->read_rom_hwaddr)
494 		eth_get_ops(dev)->read_rom_hwaddr(dev);
495 
496 	eth_getenv_enetaddr_by_index("eth", dev->seq, env_enetaddr);
497 	if (!is_zero_ethaddr(env_enetaddr)) {
498 		if (!is_zero_ethaddr(pdata->enetaddr) &&
499 		    memcmp(pdata->enetaddr, env_enetaddr, 6)) {
500 			printf("\nWarning: %s MAC addresses don't match:\n",
501 			       dev->name);
502 			printf("Address in SROM is         %pM\n",
503 			       pdata->enetaddr);
504 			printf("Address in environment is  %pM\n",
505 			       env_enetaddr);
506 		}
507 
508 		/* Override the ROM MAC address */
509 		memcpy(pdata->enetaddr, env_enetaddr, 6);
510 	} else if (is_valid_ethaddr(pdata->enetaddr)) {
511 		eth_setenv_enetaddr_by_index("eth", dev->seq, pdata->enetaddr);
512 		printf("\nWarning: %s using MAC address from ROM\n",
513 		       dev->name);
514 	} else if (is_zero_ethaddr(pdata->enetaddr)) {
515 #ifdef CONFIG_NET_RANDOM_ETHADDR
516 		net_random_ethaddr(pdata->enetaddr);
517 		printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
518 		       dev->name, dev->seq, pdata->enetaddr);
519 #else
520 		printf("\nError: %s address not set.\n",
521 		       dev->name);
522 		return -EINVAL;
523 #endif
524 	}
525 
526 	return 0;
527 }
528 
529 static int eth_pre_remove(struct udevice *dev)
530 {
531 	struct eth_pdata *pdata = dev->platdata;
532 
533 	eth_get_ops(dev)->stop(dev);
534 
535 	/* clear the MAC address */
536 	memset(pdata->enetaddr, 0, 6);
537 
538 	return 0;
539 }
540 
541 UCLASS_DRIVER(eth) = {
542 	.name		= "eth",
543 	.id		= UCLASS_ETH,
544 	.post_bind	= eth_post_bind,
545 	.pre_unbind	= eth_pre_unbind,
546 	.post_probe	= eth_post_probe,
547 	.pre_remove	= eth_pre_remove,
548 	.priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
549 	.per_device_auto_alloc_size = sizeof(struct eth_device_priv),
550 	.flags		= DM_UC_FLAG_SEQ_ALIAS,
551 };
552