sys/boot/uboot/lib/net.c

   1 /*-
   2  * Copyright (c) 2000-2001 Benno Rice
   3  * Copyright (c) 2007 Semihalf, Rafal Jaworowski <raj@semihalf.com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34
  35 #include <net/if.h>
  36 #include <netinet/in.h>
  37 #include <netinet/in_systm.h>
  38 #include <netinet/if_ether.h>
  39 #include <netinet/ip.h>
  40
  41 #include <stand.h>
  42 #include <net.h>
  43 #include <netif.h>
  44
  45 #include "api_public.h"
  46 #include "glue.h"
  47 #include "libuboot.h"
  48 #include "dev_net.h"
  49
  50 static int      net_probe(struct netif *, void *);
  51 static int      net_match(struct netif *, void *);
  52 static void     net_init(struct iodesc *, void *);
  53 static int      net_get(struct iodesc *, void *, size_t, time_t);
  54 static int      net_put(struct iodesc *, void *, size_t);
  55 static void     net_end(struct netif *);
  56
  57 extern struct netif_stats net_stats[];
  58
  59 struct netif_dif net_ifs[] = {
  60         /*      dif_unit        dif_nsel        dif_stats       dif_private */
  61         {       0,              1,              &net_stats[0],  0,      },
  62 };
  63
  64 struct netif_stats net_stats[NENTS(net_ifs)];
  65
  66 struct netif_driver uboot_net = {
  67         "uboot_eth",            /* netif_bname */
  68         net_match,              /* netif_match */
  69         net_probe,              /* netif_probe */
  70         net_init,               /* netif_init */
  71         net_get,                /* netif_get */
  72         net_put,                /* netif_put */
  73         net_end,                /* netif_end */
  74         net_ifs,                /* netif_ifs */
  75         NENTS(net_ifs)          /* netif_nifs */
  76 };
  77
  78 struct uboot_softc {
  79         uint32_t        sc_pad;
  80         uint8_t         sc_rxbuf[ETHER_MAX_LEN];
  81         uint8_t         sc_txbuf[ETHER_MAX_LEN + PKTALIGN];
  82         uint8_t         *sc_txbufp;
  83         int             sc_handle;      /* device handle for ub_dev_xxx */
  84 };
  85
  86 static struct uboot_softc uboot_softc;
  87
  88 /*
  89  * get_env_net_params()
  90  *
  91  * Attempt to obtain all the parms we need for netbooting from the U-Boot
  92  * environment.  If we fail to obtain the values it may still be possible to
  93  * netboot; the net_dev code will attempt to get the values from bootp, rarp,
  94  * and other such sources.
  95  *
  96  * If rootip.s_addr is non-zero net_dev assumes the required global variables
  97  * are set and skips the bootp inquiry.  For that reason, we don't set rootip
  98  * until we've verified that we have at least the minimum required info.
  99  *
 100  * This is called from netif_init() which can result in it getting called
 101  * multiple times, by design.  The network code at higher layers zeroes out
 102  * rootip when it closes a network interface, so if it gets opened again we have
 103  * to obtain all this info again.
 104  */
 105 static void
 106 get_env_net_params()
 107 {
 108         char *envstr;
 109         in_addr_t rootaddr, serveraddr;
 110
 111         /* Silently get out right away if we don't have rootpath. */
 112         if (ub_env_get("rootpath") == NULL)
 113                 return;
 114
 115         /*
 116          * Our own IP address must be valid.  Silently get out if it's not set,
 117          * but whine if it's there and we can't parse it.
 118          */
 119         if ((envstr = ub_env_get("ipaddr")) == NULL)
 120                 return;
 121         if ((myip.s_addr = inet_addr(envstr)) == INADDR_NONE) {
 122                 printf("Could not parse ipaddr '%s'\n", envstr);
 123                 return;
 124         }
 125
 126         /*
 127          * Netmask is optional, default to the "natural" netmask for our IP, but
 128          * whine if it was provided and we couldn't parse it.
 129          */
 130         if ((envstr = ub_env_get("netmask")) != NULL &&
 131             (netmask = inet_addr(envstr)) == INADDR_NONE) {
 132                 printf("Could not parse netmask '%s'\n", envstr);
 133         }
 134         if (netmask == INADDR_NONE) {
 135                 if (IN_CLASSA(myip.s_addr))
 136                         netmask = IN_CLASSA_NET;
 137                 else if (IN_CLASSB(myip.s_addr))
 138                         netmask = IN_CLASSB_NET;
 139                 else
 140                         netmask = IN_CLASSC_NET;
 141         }
 142
 143         /*
 144          * Get optional serverip before rootpath; the latter can override it.
 145          * Whine only if it's present but can't be parsed.
 146          */
 147         serveraddr = INADDR_NONE;
 148         if ((envstr = ub_env_get("serverip")) != NULL) {
 149                 if ((serveraddr = inet_addr(envstr)) == INADDR_NONE)
 150                         printf("Could not parse serverip '%s'\n", envstr);
 151         }
 152
 153         /*
 154          * There must be a rootpath.  It may be ip:/path or it may be just the
 155          * path in which case the ip needs to be in serverip.
 156          */
 157         if ((envstr = ub_env_get("rootpath")) == NULL)
 158                 return;
 159         strncpy(rootpath, envstr, sizeof(rootpath) - 1);
 160         rootaddr = net_parse_rootpath();
 161         if (rootaddr == INADDR_NONE)
 162                 rootaddr = serveraddr;
 163         if (rootaddr == INADDR_NONE) {
 164                 printf("No server address for rootpath '%s'\n", envstr);
 165                 return;
 166         }
 167         rootip.s_addr = rootaddr;
 168
 169         /*
 170          * Gateway IP is optional unless rootip is on a different net in which
 171          * case whine if it's missing or we can't parse it, and set rootip addr
 172          * to zero, which signals to other network code that network params
 173          * aren't set (so it will try dhcp, bootp, etc).
 174          */
 175         envstr = ub_env_get("gatewayip");
 176         if (!SAMENET(myip, rootip, netmask)) {
 177                 if (envstr == NULL)  {
 178                         printf("Need gatewayip for a root server on a "
 179                             "different network.\n");
 180                         rootip.s_addr = 0;
 181                         return;
 182                 }
 183                 if ((gateip.s_addr = inet_addr(envstr) == INADDR_NONE)) {
 184                         printf("Could not parse gatewayip '%s'\n", envstr);
 185                         rootip.s_addr = 0;
 186                         return;
 187                 }
 188         }
 189 }
 190
 191 static int
 192 net_match(struct netif *nif, void *machdep_hint)
 193 {
 194         char **a = (char **)machdep_hint;
 195
 196         if (memcmp("net", *a, 3) == 0)
 197                 return (1);
 198
 199         printf("net_match: could not match network device\n");
 200         return (0);
 201 }
 202
 203 static int
 204 net_probe(struct netif *nif, void *machdep_hint)
 205 {
 206         struct device_info *di;
 207         int i;
 208
 209         for (i = 0; i < devs_no; i++)
 210                 if ((di = ub_dev_get(i)) != NULL)
 211                         if (di->type == DEV_TYP_NET)
 212                                 break;
 213
 214         if (i == devs_no) {
 215                 printf("net_probe: no network devices found, maybe not"
 216                     " enumerated yet..?\n");
 217                 return (-1);
 218         }
 219
 220 #if defined(NETIF_DEBUG)
 221         printf("net_probe: network device found: %d\n", i);
 222 #endif
 223         uboot_softc.sc_handle = i;
 224
 225         return (0);
 226 }
 227
 228 static int
 229 net_put(struct iodesc *desc, void *pkt, size_t len)
 230 {
 231         struct netif *nif = desc->io_netif;
 232         struct uboot_softc *sc = nif->nif_devdata;
 233         size_t sendlen;
 234         ssize_t rv;
 235
 236 #if defined(NETIF_DEBUG)
 237         struct ether_header *eh;
 238
 239         printf("net_put: desc %p, pkt %p, len %d\n", desc, pkt, len);
 240         eh = pkt;
 241         printf("dst: %s ", ether_sprintf(eh->ether_dhost));
 242         printf("src: %s ", ether_sprintf(eh->ether_shost));
 243         printf("type: 0x%x\n", eh->ether_type & 0xffff);
 244 #endif
 245
 246         if (len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
 247                 sendlen = ETHER_MIN_LEN - ETHER_CRC_LEN;
 248                 bzero(sc->sc_txbufp, sendlen);
 249         } else
 250                 sendlen = len;
 251
 252         memcpy(sc->sc_txbufp, pkt, len);
 253
 254         rv = ub_dev_send(sc->sc_handle, sc->sc_txbufp, sendlen);
 255
 256 #if defined(NETIF_DEBUG)
 257         printf("net_put: ub_send returned %d\n", rv);
 258 #endif
 259         if (rv == 0)
 260                 rv = len;
 261         else
 262                 rv = -1;
 263
 264         return (rv);
 265 }
 266
 267 static int
 268 net_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
 269 {
 270         struct netif *nif = desc->io_netif;
 271         struct uboot_softc *sc = nif->nif_devdata;
 272         time_t t;
 273         int err, rlen;
 274
 275 #if defined(NETIF_DEBUG)
 276         printf("net_get: pkt %p, len %d, timeout %d\n", pkt, len, timeout);
 277 #endif
 278         t = getsecs();
 279         do {
 280                 err = ub_dev_recv(sc->sc_handle, sc->sc_rxbuf, len, &rlen);
 281
 282                 if (err != 0) {
 283                         printf("net_get: ub_dev_recv() failed, error=%d\n",
 284                             err);
 285                         rlen = 0;
 286                         break;
 287                 }
 288         } while ((rlen == -1 || rlen == 0) && (getsecs() - t < timeout));
 289
 290 #if defined(NETIF_DEBUG)
 291         printf("net_get: received len %d (%x)\n", rlen, rlen);
 292 #endif
 293
 294         if (rlen > 0) {
 295                 memcpy(pkt, sc->sc_rxbuf, MIN(len, rlen));
 296                 if (rlen != len) {
 297 #if defined(NETIF_DEBUG)
 298                         printf("net_get: len %x, rlen %x\n", len, rlen);
 299 #endif
 300                 }
 301                 return (rlen);
 302         }
 303
 304         return (-1);
 305 }
 306
 307 static void
 308 net_init(struct iodesc *desc, void *machdep_hint)
 309 {
 310         struct netif *nif = desc->io_netif;
 311         struct uboot_softc *sc;
 312         struct device_info *di;
 313         int err;
 314
 315         sc = nif->nif_devdata = &uboot_softc;
 316
 317         if ((err = ub_dev_open(sc->sc_handle)) != 0)
 318                 panic("%s%d: initialisation failed with error %d\n",
 319                     nif->nif_driver->netif_bname, nif->nif_unit, err);
 320
 321         /* Get MAC address */
 322         di = ub_dev_get(sc->sc_handle);
 323         memcpy(desc->myea, di->di_net.hwaddr, 6);
 324         if (memcmp (desc->myea, "\0\0\0\0\0\0", 6) == 0) {
 325                 panic("%s%d: empty ethernet address!",
 326                     nif->nif_driver->netif_bname, nif->nif_unit);
 327         }
 328
 329         /* Attempt to get netboot params from the u-boot env. */
 330         get_env_net_params();
 331         if (myip.s_addr != 0)
 332                 desc->myip = myip;
 333
 334 #if defined(NETIF_DEBUG)
 335         printf("network: %s%d attached to %s\n", nif->nif_driver->netif_bname,
 336             nif->nif_unit, ether_sprintf(desc->myea));
 337 #endif
 338
 339         /* Set correct alignment for TX packets */
 340         sc->sc_txbufp = sc->sc_txbuf;
 341         if ((unsigned long)sc->sc_txbufp % PKTALIGN)
 342                 sc->sc_txbufp += PKTALIGN -
 343                     (unsigned long)sc->sc_txbufp % PKTALIGN;
 344 }
 345
 346 static void
 347 net_end(struct netif *nif)
 348 {
 349         struct uboot_softc *sc = nif->nif_devdata;
 350         int err;
 351
 352         if ((err = ub_dev_close(sc->sc_handle)) != 0)
 353                 panic("%s%d: net_end failed with error %d\n",
 354                     nif->nif_driver->netif_bname, nif->nif_unit, err);
 355 }