1
2
3
4
5
6
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
15DECLARE_GLOBAL_DATA_PTR;
16
17static int reply_arp;
18static struct in_addr arp_ip;
19
20static 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
38static 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
52
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
64static 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
77
78
79
80
81
82
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
90 memset(&arp->ar_sha, 0x01, ARP_HLEN);
91
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
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
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
124static 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
133static 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
142static 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
150static 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 u32 local;
156 int ret;
157
158 pdata->iobase = dev_read_addr(dev);
159
160 ifname = dev_read_string(dev, "host-raw-interface");
161 if (ifname) {
162 strncpy(priv->host_ifname, ifname, IFNAMSIZ);
163 printf(": Using %s from DT\n", priv->host_ifname);
164 }
165 if (dev_read_u32(dev, "host-raw-interface-idx",
166 &priv->host_ifindex) < 0) {
167 priv->host_ifindex = 0;
168 } else {
169 ret = sandbox_eth_raw_os_idx_to_name(priv);
170 if (ret < 0)
171 return ret;
172 printf(": Using interface index %d from DT (%s)\n",
173 priv->host_ifindex, priv->host_ifname);
174 }
175
176 local = sandbox_eth_raw_os_is_local(priv->host_ifname);
177 if (local < 0)
178 return local;
179 priv->local = local;
180
181 return 0;
182}
183
184static const struct udevice_id sb_eth_raw_ids[] = {
185 { .compatible = "sandbox,eth-raw" },
186 { }
187};
188
189U_BOOT_DRIVER(eth_sandbox_raw) = {
190 .name = "eth_sandbox_raw",
191 .id = UCLASS_ETH,
192 .of_match = sb_eth_raw_ids,
193 .ofdata_to_platdata = sb_eth_raw_ofdata_to_platdata,
194 .ops = &sb_eth_raw_ops,
195 .priv_auto_alloc_size = sizeof(struct eth_sandbox_raw_priv),
196 .platdata_auto_alloc_size = sizeof(struct eth_pdata),
197};
198