]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
db9391e1 SG |
2 | /* |
3 | * (C) Copyright 2001-2015 | |
4 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
5 | * Joe Hershberger, National Instruments | |
db9391e1 SG |
6 | */ |
7 | ||
79d191ef PD |
8 | #define LOG_CATEGORY UCLASS_ETH |
9 | ||
db9391e1 | 10 | #include <common.h> |
4fd8d077 | 11 | #include <bootdev.h> |
52f24238 | 12 | #include <bootstage.h> |
db9391e1 | 13 | #include <dm.h> |
9fb625ce | 14 | #include <env.h> |
f7ae49fc | 15 | #include <log.h> |
db9391e1 | 16 | #include <net.h> |
97d0f9bf | 17 | #include <nvmem.h> |
401d1c4f | 18 | #include <asm/global_data.h> |
db9391e1 SG |
19 | #include <dm/device-internal.h> |
20 | #include <dm/uclass-internal.h> | |
3eaac630 | 21 | #include <net/pcap.h> |
db9391e1 | 22 | #include "eth_internal.h" |
5fe419ef | 23 | #include <eth_phy.h> |
db9391e1 | 24 | |
a7c45ec4 SG |
25 | DECLARE_GLOBAL_DATA_PTR; |
26 | ||
db9391e1 SG |
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 | */ | |
32 | struct eth_device_priv { | |
33 | enum eth_state_t state; | |
fa795f45 | 34 | bool running; |
db9391e1 SG |
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 | |
70dd8865 SG |
41 | * @no_bootdevs: true to skip binding Ethernet bootdevs (this is a negative flag |
42 | * so that the default value enables it) | |
db9391e1 SG |
43 | */ |
44 | struct eth_uclass_priv { | |
45 | struct udevice *current; | |
70dd8865 | 46 | bool no_bootdevs; |
db9391e1 SG |
47 | }; |
48 | ||
49 | /* eth_errno - This stores the most recent failure code from DM functions */ | |
50 | static int eth_errno; | |
51 | ||
6c7e5598 MV |
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 | ||
db9391e1 SG |
59 | static struct eth_uclass_priv *eth_get_uclass_priv(void) |
60 | { | |
61 | struct uclass *uc; | |
d2b70205 PF |
62 | int ret; |
63 | ||
64 | ret = uclass_get(UCLASS_ETH, &uc); | |
65 | if (ret) | |
66 | return NULL; | |
db9391e1 | 67 | |
db9391e1 | 68 | assert(uc); |
0fd3d911 | 69 | return uclass_get_priv(uc); |
db9391e1 SG |
70 | } |
71 | ||
70dd8865 SG |
72 | void 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 | ||
db9391e1 SG |
80 | void 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 | |
6e424b4a MW |
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. | |
db9391e1 SG |
99 | */ |
100 | struct udevice *eth_get_dev(void) | |
101 | { | |
102 | struct eth_uclass_priv *uc_priv; | |
103 | ||
104 | uc_priv = eth_get_uclass_priv(); | |
c3f0278e SA |
105 | if (!uc_priv) |
106 | return NULL; | |
107 | ||
6e424b4a MW |
108 | if (!uc_priv->current) { |
109 | eth_errno = uclass_get_device_by_seq(UCLASS_ETH, 0, | |
110 | &uc_priv->current); | |
111 | if (eth_errno) | |
c726fc01 MS |
112 | eth_errno = uclass_first_device_err(UCLASS_ETH, |
113 | &uc_priv->current); | |
0736f7aa MS |
114 | if (eth_errno) |
115 | uc_priv->current = NULL; | |
6e424b4a | 116 | } |
db9391e1 SG |
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 | */ | |
125 | void 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 | */ | |
140 | struct 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"); | |
d2b70205 | 148 | int ret; |
db9391e1 SG |
149 | |
150 | /* Must be longer than 3 to be an alias */ | |
151 | if (!strncmp(devname, "eth", len) && strlen(devname) > len) { | |
152 | startp = devname + len; | |
0b1284eb | 153 | seq = dectoul(startp, &endp); |
db9391e1 SG |
154 | } |
155 | ||
d2b70205 PF |
156 | ret = uclass_get(UCLASS_ETH, &uc); |
157 | if (ret) | |
158 | return NULL; | |
159 | ||
db9391e1 SG |
160 | uclass_foreach_dev(it, uc) { |
161 | /* | |
db9391e1 SG |
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 || | |
8b85dfc6 | 170 | (endp > startp && dev_seq(it) == seq)) |
db9391e1 SG |
171 | return it; |
172 | } | |
173 | ||
174 | return NULL; | |
175 | } | |
176 | ||
177 | unsigned char *eth_get_ethaddr(void) | |
178 | { | |
179 | struct eth_pdata *pdata; | |
180 | ||
181 | if (eth_get_dev()) { | |
0fd3d911 | 182 | pdata = dev_get_plat(eth_get_dev()); |
db9391e1 SG |
183 | return pdata->enetaddr; |
184 | } | |
185 | ||
186 | return NULL; | |
187 | } | |
188 | ||
189 | /* Set active state without calling start on the driver */ | |
190 | int 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 | ||
0fd3d911 | 199 | priv = dev_get_uclass_priv(current); |
db9391e1 SG |
200 | priv->state = ETH_STATE_ACTIVE; |
201 | ||
202 | return 0; | |
203 | } | |
204 | ||
205 | /* Set passive state without calling stop on the driver */ | |
206 | void 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 | ||
0fd3d911 | 215 | priv = dev_get_uclass_priv(current); |
db9391e1 SG |
216 | priv->state = ETH_STATE_PASSIVE; |
217 | } | |
218 | ||
219 | int eth_get_dev_index(void) | |
220 | { | |
221 | if (eth_get_dev()) | |
8b85dfc6 | 222 | return dev_seq(eth_get_dev()); |
db9391e1 SG |
223 | return -1; |
224 | } | |
225 | ||
226 | static int eth_write_hwaddr(struct udevice *dev) | |
227 | { | |
c08248d6 | 228 | struct eth_pdata *pdata; |
db9391e1 SG |
229 | int ret = 0; |
230 | ||
231 | if (!dev || !device_active(dev)) | |
232 | return -EINVAL; | |
233 | ||
234 | /* seq is valid since the device is active */ | |
8b85dfc6 | 235 | if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev_seq(dev))) { |
0fd3d911 | 236 | pdata = dev_get_plat(dev); |
db9391e1 SG |
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 | ||
258 | static 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" */ | |
0b1284eb | 266 | index = dectoul(name + 3, NULL); |
db9391e1 | 267 | |
99175919 | 268 | retval = uclass_find_device_by_seq(UCLASS_ETH, index, &dev); |
db9391e1 | 269 | if (!retval) { |
0fd3d911 | 270 | struct eth_pdata *pdata = dev_get_plat(dev); |
db9391e1 SG |
271 | switch (op) { |
272 | case env_op_create: | |
273 | case env_op_overwrite: | |
fb8977c5 | 274 | string_to_enetaddr(value, pdata->enetaddr); |
c86ff7fd | 275 | eth_write_hwaddr(dev); |
db9391e1 SG |
276 | break; |
277 | case env_op_delete: | |
a40db6d5 | 278 | memset(pdata->enetaddr, 0, ARP_HLEN); |
db9391e1 SG |
279 | } |
280 | } | |
281 | ||
282 | return 0; | |
283 | } | |
284 | U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr); | |
285 | ||
286 | int eth_init(void) | |
287 | { | |
00caae6d SG |
288 | char *ethact = env_get("ethact"); |
289 | char *ethrotate = env_get("ethrotate"); | |
db9391e1 SG |
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) { | |
ad895913 | 309 | log_err("No ethernet found.\n"); |
db9391e1 SG |
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 = | |
0fd3d911 | 323 | dev_get_uclass_priv(current); |
db9391e1 SG |
324 | |
325 | priv->state = ETH_STATE_ACTIVE; | |
fa795f45 | 326 | priv->running = true; |
db9391e1 SG |
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 | ||
350 | void eth_halt(void) | |
351 | { | |
352 | struct udevice *current; | |
353 | struct eth_device_priv *priv; | |
354 | ||
355 | current = eth_get_dev(); | |
fa795f45 | 356 | if (!current) |
db9391e1 SG |
357 | return; |
358 | ||
0fd3d911 | 359 | priv = dev_get_uclass_priv(current); |
fa795f45 MS |
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; | |
db9391e1 SG |
366 | } |
367 | ||
368 | int 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 | ||
379 | int 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 | ||
a532e2f2 | 388 | if (!eth_is_active(current)) |
db9391e1 SG |
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 | } | |
3eaac630 RF |
396 | #if defined(CONFIG_CMD_PCAP) |
397 | if (ret >= 0) | |
398 | pcap_post(packet, length, true); | |
399 | #endif | |
db9391e1 SG |
400 | return ret; |
401 | } | |
402 | ||
403 | int 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 | ||
a532e2f2 | 415 | if (!eth_is_active(current)) |
db9391e1 SG |
416 | return -EINVAL; |
417 | ||
418 | /* Process up to 32 packets at one time */ | |
419 | flags = ETH_RECV_CHECK_DEVICE; | |
36ea0cab | 420 | for (i = 0; i < ETH_PACKETS_BATCH_RECV; i++) { |
db9391e1 SG |
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 | ||
439 | int 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 | */ | |
3ce43042 | 452 | uclass_first_device_check(UCLASS_ETH, &dev); |
db9391e1 | 453 | if (!dev) { |
ad895913 | 454 | log_err("No ethernet found.\n"); |
db9391e1 SG |
455 | bootstage_error(BOOTSTAGE_ID_NET_ETH_START); |
456 | } else { | |
00caae6d | 457 | char *ethprime = env_get("ethprime"); |
db9391e1 SG |
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 { | |
552da335 | 471 | if (device_active(dev)) { |
19820db0 MW |
472 | if (num_devices) |
473 | printf(", "); | |
db9391e1 | 474 | |
8b85dfc6 | 475 | printf("eth%d: %s", dev_seq(dev), dev->name); |
db9391e1 | 476 | |
19820db0 MW |
477 | if (ethprime && dev == prime_dev) |
478 | printf(" [PRIME]"); | |
479 | } | |
db9391e1 SG |
480 | |
481 | eth_write_hwaddr(dev); | |
482 | ||
552da335 | 483 | if (device_active(dev)) |
19820db0 | 484 | num_devices++; |
3ce43042 | 485 | uclass_next_device_check(&dev); |
db9391e1 SG |
486 | } while (dev); |
487 | ||
19820db0 | 488 | if (!num_devices) |
ad895913 | 489 | log_err("No ethernet found.\n"); |
db9391e1 SG |
490 | putc('\n'); |
491 | } | |
492 | ||
493 | return num_devices; | |
494 | } | |
495 | ||
496 | static int eth_post_bind(struct udevice *dev) | |
497 | { | |
70dd8865 | 498 | struct eth_uclass_priv *priv = uclass_get_priv(dev->uclass); |
4fd8d077 SG |
499 | int ret; |
500 | ||
db9391e1 SG |
501 | if (strchr(dev->name, ' ')) { |
502 | printf("\nError: eth device name \"%s\" has a space!\n", | |
503 | dev->name); | |
504 | return -EINVAL; | |
505 | } | |
506 | ||
5fe419ef YL |
507 | #ifdef CONFIG_DM_ETH_PHY |
508 | eth_phy_binds_nodes(dev); | |
509 | #endif | |
70dd8865 | 510 | if (CONFIG_IS_ENABLED(BOOTDEV_ETH) && !priv->no_bootdevs) { |
4fd8d077 SG |
511 | ret = bootdev_setup_for_dev(dev, "eth_bootdev"); |
512 | if (ret) | |
513 | return log_msg_ret("bootdev", ret); | |
514 | } | |
5fe419ef | 515 | |
db9391e1 SG |
516 | return 0; |
517 | } | |
518 | ||
519 | static 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 | ||
379af67a TR |
528 | static bool eth_dev_get_mac_address(struct udevice *dev, u8 mac[ARP_HLEN]) |
529 | { | |
177e7f9c | 530 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
379af67a | 531 | const uint8_t *p; |
97d0f9bf | 532 | struct nvmem_cell mac_cell; |
379af67a TR |
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 | ||
97d0f9bf SA |
538 | if (p) { |
539 | memcpy(mac, p, ARP_HLEN); | |
540 | return true; | |
541 | } | |
379af67a | 542 | |
97d0f9bf SA |
543 | if (nvmem_cell_get_by_name(dev, "mac-address", &mac_cell)) |
544 | return false; | |
379af67a | 545 | |
97d0f9bf | 546 | return !nvmem_cell_read(&mac_cell, mac, ARP_HLEN); |
379af67a TR |
547 | #else |
548 | return false; | |
549 | #endif | |
550 | } | |
551 | ||
db9391e1 SG |
552 | static int eth_post_probe(struct udevice *dev) |
553 | { | |
0fd3d911 SG |
554 | struct eth_device_priv *priv = dev_get_uclass_priv(dev); |
555 | struct eth_pdata *pdata = dev_get_plat(dev); | |
a40db6d5 | 556 | unsigned char env_enetaddr[ARP_HLEN]; |
d4172c94 | 557 | char *source = "DT"; |
db9391e1 | 558 | |
db9391e1 | 559 | priv->state = ETH_STATE_INIT; |
fa795f45 | 560 | priv->running = false; |
db9391e1 | 561 | |
379af67a TR |
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 */ | |
d71e7f41 MS |
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 | } | |
379af67a | 573 | } |
db9391e1 | 574 | |
8b85dfc6 | 575 | eth_env_get_enetaddr_by_index("eth", dev_seq(dev), env_enetaddr); |
db9391e1 SG |
576 | if (!is_zero_ethaddr(env_enetaddr)) { |
577 | if (!is_zero_ethaddr(pdata->enetaddr) && | |
a40db6d5 | 578 | memcmp(pdata->enetaddr, env_enetaddr, ARP_HLEN)) { |
db9391e1 SG |
579 | printf("\nWarning: %s MAC addresses don't match:\n", |
580 | dev->name); | |
d4172c94 MS |
581 | printf("Address in %s is\t\t%pM\n", |
582 | source, pdata->enetaddr); | |
583 | printf("Address in environment is\t%pM\n", | |
db9391e1 SG |
584 | env_enetaddr); |
585 | } | |
586 | ||
587 | /* Override the ROM MAC address */ | |
a40db6d5 | 588 | memcpy(pdata->enetaddr, env_enetaddr, ARP_HLEN); |
db9391e1 | 589 | } else if (is_valid_ethaddr(pdata->enetaddr)) { |
8b85dfc6 SG |
590 | eth_env_set_enetaddr_by_index("eth", dev_seq(dev), |
591 | pdata->enetaddr); | |
aa555fe9 SDPP |
592 | } else if (is_zero_ethaddr(pdata->enetaddr) || |
593 | !is_valid_ethaddr(pdata->enetaddr)) { | |
db9391e1 SG |
594 | #ifdef CONFIG_NET_RANDOM_ETHADDR |
595 | net_random_ethaddr(pdata->enetaddr); | |
596 | printf("\nWarning: %s (eth%d) using random MAC address - %pM\n", | |
8b85dfc6 | 597 | dev->name, dev_seq(dev), pdata->enetaddr); |
381e6e54 MS |
598 | eth_env_set_enetaddr_by_index("eth", dev_seq(dev), |
599 | pdata->enetaddr); | |
db9391e1 | 600 | #else |
7907cf80 | 601 | printf("\nError: %s No valid MAC address found.\n", |
db9391e1 SG |
602 | dev->name); |
603 | return -EINVAL; | |
604 | #endif | |
605 | } | |
606 | ||
b743bbd2 TR |
607 | eth_write_hwaddr(dev); |
608 | ||
db9391e1 SG |
609 | return 0; |
610 | } | |
611 | ||
612 | static int eth_pre_remove(struct udevice *dev) | |
613 | { | |
0fd3d911 | 614 | struct eth_pdata *pdata = dev_get_plat(dev); |
db9391e1 SG |
615 | |
616 | eth_get_ops(dev)->stop(dev); | |
617 | ||
618 | /* clear the MAC address */ | |
a40db6d5 | 619 | memset(pdata->enetaddr, 0, ARP_HLEN); |
db9391e1 SG |
620 | |
621 | return 0; | |
622 | } | |
623 | ||
82a3c9ef MW |
624 | UCLASS_DRIVER(ethernet) = { |
625 | .name = "ethernet", | |
db9391e1 SG |
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, | |
41575d8e SG |
631 | .priv_auto = sizeof(struct eth_uclass_priv), |
632 | .per_device_auto = sizeof(struct eth_device_priv), | |
db9391e1 SG |
633 | .flags = DM_UC_FLAG_SEQ_ALIAS, |
634 | }; |