blob: 7e6625d0202fcf074a1706705d4e4c0a2915af59 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0
Joe Hershbergera346ca72015-03-22 17:09:21 -05002/*
3 * Copyright (c) 2015 National Instruments
4 *
5 * (C) Copyright 2015
6 * Joe Hershberger <joe.hershberger@ni.com>
Joe Hershbergera346ca72015-03-22 17:09:21 -05007 */
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
Joe Hershberger22f68522015-03-22 17:09:23 -050017static int reply_arp;
Joe Hershberger049a95a2015-04-08 01:41:01 -050018static struct in_addr arp_ip;
Joe Hershbergera346ca72015-03-22 17:09:21 -050019
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);
Joe Hershberger8c7988b2018-07-02 14:47:50 -050024 int ret;
Joe Hershbergera346ca72015-03-22 17:09:21 -050025
26 debug("eth_sandbox_raw: Start\n");
27
Joe Hershberger8c7988b2018-07-02 14:47:50 -050028 ret = sandbox_eth_raw_os_start(priv, pdata->enetaddr);
29 if (priv->local) {
Simon Glass382bee52017-08-03 12:22:09 -060030 env_set("ipaddr", "127.0.0.1");
31 env_set("serverip", "127.0.0.1");
Joe Hershbergerac132702018-07-02 14:47:51 -050032 net_ip = string_to_ip("127.0.0.1");
33 net_server_ip = net_ip;
Joe Hershberger22f68522015-03-22 17:09:23 -050034 }
Joe Hershberger8c7988b2018-07-02 14:47:50 -050035 return ret;
Joe Hershbergera346ca72015-03-22 17:09:21 -050036}
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
Joe Hershberger22f68522015-03-22 17:09:23 -050044 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 */
Joe Hershberger049a95a2015-04-08 01:41:01 -050054 arp_ip = net_read_ip(&arp->ar_tpa);
Joe Hershberger22f68522015-03-22 17:09:23 -050055 reply_arp = 1;
56 return 0;
57 }
58 packet += ETHER_HDR_SIZE;
59 length -= ETHER_HDR_SIZE;
60 }
Joe Hershbergera346ca72015-03-22 17:09:21 -050061 return sandbox_eth_raw_os_send(packet, length, priv);
62}
63
Simon Glassa1ca92e2015-07-06 16:47:49 -060064static int sb_eth_raw_recv(struct udevice *dev, int flags, uchar **packetp)
Joe Hershbergera346ca72015-03-22 17:09:21 -050065{
Joe Hershberger22f68522015-03-22 17:09:23 -050066 struct eth_pdata *pdata = dev_get_platdata(dev);
Joe Hershbergera346ca72015-03-22 17:09:21 -050067 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
Joe Hershberger22f68522015-03-22 17:09:23 -050068 int retval = 0;
Joe Hershbergera346ca72015-03-22 17:09:21 -050069 int length;
70
Joe Hershberger22f68522015-03-22 17:09:23 -050071 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?) */
Joe Hershberger049a95a2015-04-08 01:41:01 -050092 net_write_ip(&arp->ar_spa, arp_ip);
Joe Hershberger22f68522015-03-22 17:09:23 -050093 memcpy(&arp->ar_tha, pdata->enetaddr, ARP_HLEN);
Joe Hershberger049a95a2015-04-08 01:41:01 -050094 net_write_ip(&arp->ar_tpa, net_ip);
Joe Hershberger22f68522015-03-22 17:09:23 -050095 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 }
Joe Hershbergera346ca72015-03-22 17:09:21 -0500103
104 if (!retval && length) {
Joe Hershberger22f68522015-03-22 17:09:23 -0500105 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
Joe Hershbergera346ca72015-03-22 17:09:21 -0500116 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
Joe Hershbergerb96ced92018-07-02 14:47:53 -0500133static 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
Joe Hershbergera346ca72015-03-22 17:09:21 -0500142static 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,
Joe Hershbergerb96ced92018-07-02 14:47:53 -0500147 .read_rom_hwaddr = sb_eth_raw_read_rom_hwaddr,
Joe Hershbergera346ca72015-03-22 17:09:21 -0500148};
149
150static int sb_eth_raw_ofdata_to_platdata(struct udevice *dev)
151{
152 struct eth_pdata *pdata = dev_get_platdata(dev);
Joe Hershberger8c7988b2018-07-02 14:47:50 -0500153 struct eth_sandbox_raw_priv *priv = dev_get_priv(dev);
154 const char *ifname;
Joe Hershbergerc9e2caf2018-07-02 14:47:52 -0500155 int ret;
Joe Hershbergera346ca72015-03-22 17:09:21 -0500156
Joe Hershberger8c7988b2018-07-02 14:47:50 -0500157 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);
Joe Hershberger8c7988b2018-07-02 14:47:50 -0500163 }
Joe Hershbergerc9e2caf2018-07-02 14:47:52 -0500164 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 }
Joe Hershberger8c7988b2018-07-02 14:47:50 -0500174
Simon Glass84054522019-01-07 16:44:22 -0700175 ret = sandbox_eth_raw_os_is_local(priv->host_ifname);
176 if (ret < 0)
177 return ret;
178 priv->local = ret;
Joe Hershbergerac132702018-07-02 14:47:51 -0500179
Joe Hershbergera346ca72015-03-22 17:09:21 -0500180 return 0;
181}
182
183static const struct udevice_id sb_eth_raw_ids[] = {
184 { .compatible = "sandbox,eth-raw" },
185 { }
186};
187
188U_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};