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