1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2015 National Instruments
4 *
5 * (C) Copyright 2015
6 * Joe Hershberger <joe.hershberger@ni.com>
7 */
8
9 #include <asm/eth-raw-os.h>
10 #include <common.h>
11 #include <dm.h>
12 #include <malloc.h>
13 #include <net.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 static int reply_arp;
18 static struct in_addr arp_ip;
19
sb_eth_raw_start(struct udevice * dev)20 static int sb_eth_raw_start(struct udevice *dev)
21 {
22 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
23 struct eth_pdata *pdata = dev_get_platdata(dev);
24 int ret;
25
26 debug("eth_sandbox_raw: Start\n");
27
28 ret = sandbox_eth_raw_os_start(priv, pdata->enetaddr);
29 if (priv->local) {
30 env_set("ipaddr", "127.0.0.1");
31 env_set("serverip", "127.0.0.1");
32 net_ip = string_to_ip("127.0.0.1");
33 net_server_ip = net_ip;
34 }
35 return ret;
36 }
37
sb_eth_raw_send(struct udevice * dev,void * packet,int length)38 static int sb_eth_raw_send(struct udevice *dev, void *packet, int length)
39 {
40 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
41
42 debug("eth_sandbox_raw: Send packet %d\n", length);
43
44 if (priv->local) {
45 struct ethernet_hdr *eth = packet;
46
47 if (ntohs(eth->et_protlen) == PROT_ARP) {
48 struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
49
50 /**
51 * localhost works on a higher-level API in Linux than
52 * ARP packets, so fake it
53 */
54 arp_ip = net_read_ip(&arp->ar_tpa);
55 reply_arp = 1;
56 return 0;
57 }
58 packet += ETHER_HDR_SIZE;
59 length -= ETHER_HDR_SIZE;
60 }
61 return sandbox_eth_raw_os_send(packet, length, priv);
62 }
63
sb_eth_raw_recv(struct udevice * dev,int flags,uchar ** packetp)64 static int sb_eth_raw_recv(struct udevice *dev, int flags, uchar **packetp)
65 {
66 struct eth_pdata *pdata = dev_get_platdata(dev);
67 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
68 int retval = 0;
69 int length;
70
71 if (reply_arp) {
72 struct arp_hdr *arp = (void *)net_rx_packets[0] +
73 ETHER_HDR_SIZE;
74
75 /*
76 * Fake an ARP response. The u-boot network stack is sending an
77 * ARP request (to find the MAC address to address the actual
78 * packet to) and requires an ARP response to continue. Since
79 * this is the localhost interface, there is no Etherent level
80 * traffic at all, so there is no way to send an ARP request or
81 * to get a response. For this reason we fake the response to
82 * make the u-boot network stack happy.
83 */
84 arp->ar_hrd = htons(ARP_ETHER);
85 arp->ar_pro = htons(PROT_IP);
86 arp->ar_hln = ARP_HLEN;
87 arp->ar_pln = ARP_PLEN;
88 arp->ar_op = htons(ARPOP_REPLY);
89 /* Any non-zero MAC address will work */
90 memset(&arp->ar_sha, 0x01, ARP_HLEN);
91 /* Use whatever IP we were looking for (always 127.0.0.1?) */
92 net_write_ip(&arp->ar_spa, arp_ip);
93 memcpy(&arp->ar_tha, pdata->enetaddr, ARP_HLEN);
94 net_write_ip(&arp->ar_tpa, net_ip);
95 length = ARP_HDR_SIZE;
96 } else {
97 /* If local, the Ethernet header won't be included; skip it */
98 uchar *pktptr = priv->local ?
99 net_rx_packets[0] + ETHER_HDR_SIZE : net_rx_packets[0];
100
101 retval = sandbox_eth_raw_os_recv(pktptr, &length, priv);
102 }
103
104 if (!retval && length) {
105 if (priv->local) {
106 struct ethernet_hdr *eth = (void *)net_rx_packets[0];
107
108 /* Fill in enough of the missing Ethernet header */
109 memcpy(eth->et_dest, pdata->enetaddr, ARP_HLEN);
110 memset(eth->et_src, 0x01, ARP_HLEN);
111 eth->et_protlen = htons(reply_arp ? PROT_ARP : PROT_IP);
112 reply_arp = 0;
113 length += ETHER_HDR_SIZE;
114 }
115
116 debug("eth_sandbox_raw: received packet %d\n",
117 length);
118 *packetp = net_rx_packets[0];
119 return length;
120 }
121 return retval;
122 }
123
sb_eth_raw_stop(struct udevice * dev)124 static void sb_eth_raw_stop(struct udevice *dev)
125 {
126 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
127
128 debug("eth_sandbox_raw: Stop\n");
129
130 sandbox_eth_raw_os_stop(priv);
131 }
132
sb_eth_raw_read_rom_hwaddr(struct udevice * dev)133 static int sb_eth_raw_read_rom_hwaddr(struct udevice *dev)
134 {
135 struct eth_pdata *pdata = dev_get_platdata(dev);
136
137 net_random_ethaddr(pdata->enetaddr);
138
139 return 0;
140 }
141
142 static const struct eth_ops sb_eth_raw_ops = {
143 .start = sb_eth_raw_start,
144 .send = sb_eth_raw_send,
145 .recv = sb_eth_raw_recv,
146 .stop = sb_eth_raw_stop,
147 .read_rom_hwaddr = sb_eth_raw_read_rom_hwaddr,
148 };
149
sb_eth_raw_ofdata_to_platdata(struct udevice * dev)150 static int sb_eth_raw_ofdata_to_platdata(struct udevice *dev)
151 {
152 struct eth_pdata *pdata = dev_get_platdata(dev);
153 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
154 const char *ifname;
155 int ret;
156
157 pdata->iobase = dev_read_addr(dev);
158
159 ifname = dev_read_string(dev, "host-raw-interface");
160 if (ifname) {
161 strncpy(priv->host_ifname, ifname, IFNAMSIZ);
162 printf(": Using %s from DT\n", priv->host_ifname);
163 }
164 if (dev_read_u32(dev, "host-raw-interface-idx",
165 &priv->host_ifindex) < 0) {
166 priv->host_ifindex = 0;
167 } else {
168 ret = sandbox_eth_raw_os_idx_to_name(priv);
169 if (ret < 0)
170 return ret;
171 printf(": Using interface index %d from DT (%s)\n",
172 priv->host_ifindex, priv->host_ifname);
173 }
174
175 ret = sandbox_eth_raw_os_is_local(priv->host_ifname);
176 if (ret < 0)
177 return ret;
178 priv->local = ret;
179
180 return 0;
181 }
182
183 static const struct udevice_id sb_eth_raw_ids[] = {
184 { .compatible = "sandbox,eth-raw" },
185 { }
186 };
187
188 U_BOOT_DRIVER(eth_sandbox_raw) = {
189 .name = "eth_sandbox_raw",
190 .id = UCLASS_ETH,
191 .of_match = sb_eth_raw_ids,
192 .ofdata_to_platdata = sb_eth_raw_ofdata_to_platdata,
193 .ops = &sb_eth_raw_ops,
194 .priv_auto_alloc_size = sizeof(struct eth_sandbox_raw_priv),
195 .platdata_auto_alloc_size = sizeof(struct eth_pdata),
196 };
197