]> git.sur5r.net Git - u-boot/blob - net/arp.c
ARM: atmel: at91sam9m10g45ek: convert to generic board
[u-boot] / net / arp.c
1 /*
2  *      Copied from Linux Monitor (LiMon) - Networking.
3  *
4  *      Copyright 1994 - 2000 Neil Russell.
5  *      (See License)
6  *      Copyright 2000 Roland Borde
7  *      Copyright 2000 Paolo Scaffardi
8  *      Copyright 2000-2002 Wolfgang Denk, wd@denx.de
9  */
10
11 #include <common.h>
12
13 #include "arp.h"
14
15 #ifndef CONFIG_ARP_TIMEOUT
16 /* Milliseconds before trying ARP again */
17 # define ARP_TIMEOUT            5000UL
18 #else
19 # define ARP_TIMEOUT            CONFIG_ARP_TIMEOUT
20 #endif
21
22
23 #ifndef CONFIG_NET_RETRY_COUNT
24 # define ARP_TIMEOUT_COUNT      5       /* # of timeouts before giving up  */
25 #else
26 # define ARP_TIMEOUT_COUNT      CONFIG_NET_RETRY_COUNT
27 #endif
28
29 IPaddr_t        NetArpWaitPacketIP;
30 static IPaddr_t NetArpWaitReplyIP;
31 /* MAC address of waiting packet's destination */
32 uchar          *NetArpWaitPacketMAC;
33 int             NetArpWaitTxPacketSize;
34 ulong           NetArpWaitTimerStart;
35 int             NetArpWaitTry;
36
37 static uchar   *NetArpTxPacket; /* THE ARP transmit packet */
38 static uchar    NetArpPacketBuf[PKTSIZE_ALIGN + PKTALIGN];
39
40 void ArpInit(void)
41 {
42         /* XXX problem with bss workaround */
43         NetArpWaitPacketMAC = NULL;
44         NetArpWaitPacketIP = 0;
45         NetArpWaitReplyIP = 0;
46         NetArpWaitTxPacketSize = 0;
47         NetArpTxPacket = &NetArpPacketBuf[0] + (PKTALIGN - 1);
48         NetArpTxPacket -= (ulong)NetArpTxPacket % PKTALIGN;
49 }
50
51 void arp_raw_request(IPaddr_t sourceIP, const uchar *targetEther,
52         IPaddr_t targetIP)
53 {
54         uchar *pkt;
55         struct arp_hdr *arp;
56         int eth_hdr_size;
57
58         debug_cond(DEBUG_DEV_PKT, "ARP broadcast %d\n", NetArpWaitTry);
59
60         pkt = NetArpTxPacket;
61
62         eth_hdr_size = NetSetEther(pkt, NetBcastAddr, PROT_ARP);
63         pkt += eth_hdr_size;
64
65         arp = (struct arp_hdr *) pkt;
66
67         arp->ar_hrd = htons(ARP_ETHER);
68         arp->ar_pro = htons(PROT_IP);
69         arp->ar_hln = ARP_HLEN;
70         arp->ar_pln = ARP_PLEN;
71         arp->ar_op = htons(ARPOP_REQUEST);
72
73         memcpy(&arp->ar_sha, NetOurEther, ARP_HLEN);    /* source ET addr */
74         NetWriteIP(&arp->ar_spa, sourceIP);             /* source IP addr */
75         memcpy(&arp->ar_tha, targetEther, ARP_HLEN);    /* target ET addr */
76         NetWriteIP(&arp->ar_tpa, targetIP);             /* target IP addr */
77
78         NetSendPacket(NetArpTxPacket, eth_hdr_size + ARP_HDR_SIZE);
79 }
80
81 void ArpRequest(void)
82 {
83         if ((NetArpWaitPacketIP & NetOurSubnetMask) !=
84             (NetOurIP & NetOurSubnetMask)) {
85                 if (NetOurGatewayIP == 0) {
86                         puts("## Warning: gatewayip needed but not set\n");
87                         NetArpWaitReplyIP = NetArpWaitPacketIP;
88                 } else {
89                         NetArpWaitReplyIP = NetOurGatewayIP;
90                 }
91         } else {
92                 NetArpWaitReplyIP = NetArpWaitPacketIP;
93         }
94
95         arp_raw_request(NetOurIP, NetEtherNullAddr, NetArpWaitReplyIP);
96 }
97
98 void ArpTimeoutCheck(void)
99 {
100         ulong t;
101
102         if (!NetArpWaitPacketIP)
103                 return;
104
105         t = get_timer(0);
106
107         /* check for arp timeout */
108         if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT) {
109                 NetArpWaitTry++;
110
111                 if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) {
112                         puts("\nARP Retry count exceeded; starting again\n");
113                         NetArpWaitTry = 0;
114                         NetStartAgain();
115                 } else {
116                         NetArpWaitTimerStart = t;
117                         ArpRequest();
118                 }
119         }
120 }
121
122 void ArpReceive(struct ethernet_hdr *et, struct ip_udp_hdr *ip, int len)
123 {
124         struct arp_hdr *arp;
125         IPaddr_t reply_ip_addr;
126         uchar *pkt;
127         int eth_hdr_size;
128
129         /*
130          * We have to deal with two types of ARP packets:
131          * - REQUEST packets will be answered by sending  our
132          *   IP address - if we know it.
133          * - REPLY packates are expected only after we asked
134          *   for the TFTP server's or the gateway's ethernet
135          *   address; so if we receive such a packet, we set
136          *   the server ethernet address
137          */
138         debug_cond(DEBUG_NET_PKT, "Got ARP\n");
139
140         arp = (struct arp_hdr *)ip;
141         if (len < ARP_HDR_SIZE) {
142                 printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
143                 return;
144         }
145         if (ntohs(arp->ar_hrd) != ARP_ETHER)
146                 return;
147         if (ntohs(arp->ar_pro) != PROT_IP)
148                 return;
149         if (arp->ar_hln != ARP_HLEN)
150                 return;
151         if (arp->ar_pln != ARP_PLEN)
152                 return;
153
154         if (NetOurIP == 0)
155                 return;
156
157         if (NetReadIP(&arp->ar_tpa) != NetOurIP)
158                 return;
159
160         switch (ntohs(arp->ar_op)) {
161         case ARPOP_REQUEST:
162                 /* reply with our IP address */
163                 debug_cond(DEBUG_DEV_PKT, "Got ARP REQUEST, return our IP\n");
164                 pkt = (uchar *)et;
165                 eth_hdr_size = net_update_ether(et, et->et_src, PROT_ARP);
166                 pkt += eth_hdr_size;
167                 arp->ar_op = htons(ARPOP_REPLY);
168                 memcpy(&arp->ar_tha, &arp->ar_sha, ARP_HLEN);
169                 NetCopyIP(&arp->ar_tpa, &arp->ar_spa);
170                 memcpy(&arp->ar_sha, NetOurEther, ARP_HLEN);
171                 NetCopyIP(&arp->ar_spa, &NetOurIP);
172
173 #ifdef CONFIG_CMD_LINK_LOCAL
174                 /*
175                  * Work-around for brain-damaged Cisco equipment with
176                  *   arp-proxy enabled.
177                  *
178                  *   If the requesting IP is not on our subnet, wait 5ms to
179                  *   reply to ARP request so that our reply will overwrite
180                  *   the arp-proxy's instead of the other way around.
181                  */
182                 if ((NetReadIP(&arp->ar_tpa) & NetOurSubnetMask) !=
183                     (NetReadIP(&arp->ar_spa) & NetOurSubnetMask))
184                         udelay(5000);
185 #endif
186                 NetSendPacket((uchar *)et, eth_hdr_size + ARP_HDR_SIZE);
187                 return;
188
189         case ARPOP_REPLY:               /* arp reply */
190                 /* are we waiting for a reply */
191                 if (!NetArpWaitPacketIP)
192                         break;
193
194 #ifdef CONFIG_KEEP_SERVERADDR
195                 if (NetServerIP == NetArpWaitPacketIP) {
196                         char buf[20];
197                         sprintf(buf, "%pM", &arp->ar_sha);
198                         setenv("serveraddr", buf);
199                 }
200 #endif
201
202                 reply_ip_addr = NetReadIP(&arp->ar_spa);
203
204                 /* matched waiting packet's address */
205                 if (reply_ip_addr == NetArpWaitReplyIP) {
206                         debug_cond(DEBUG_DEV_PKT,
207                                 "Got ARP REPLY, set eth addr (%pM)\n",
208                                 arp->ar_data);
209
210                         /* save address for later use */
211                         if (NetArpWaitPacketMAC != NULL)
212                                 memcpy(NetArpWaitPacketMAC,
213                                        &arp->ar_sha, ARP_HLEN);
214
215                         net_get_arp_handler()((uchar *)arp, 0, reply_ip_addr,
216                                 0, len);
217
218                         /* set the mac address in the waiting packet's header
219                            and transmit it */
220                         memcpy(((struct ethernet_hdr *)NetTxPacket)->et_dest,
221                                 &arp->ar_sha, ARP_HLEN);
222                         NetSendPacket(NetTxPacket, NetArpWaitTxPacketSize);
223
224                         /* no arp request pending now */
225                         NetArpWaitPacketIP = 0;
226                         NetArpWaitTxPacketSize = 0;
227                         NetArpWaitPacketMAC = NULL;
228
229                 }
230                 return;
231         default:
232                 debug("Unexpected ARP opcode 0x%x\n",
233                       ntohs(arp->ar_op));
234                 return;
235         }
236 }