sys/dev/isa/if_el.c

   1 /*      $NetBSD: if_el.c,v 1.83 2009/05/12 08:44:19 cegger Exp $        */
   2
   3 /*
   4  * Copyright (c) 1994, Matthew E. Kimmel.  Permission is hereby granted
   5  * to use, copy, modify and distribute this software provided that both
   6  * the copyright notice and this permission notice appear in all copies
   7  * of the software, derivative works or modified versions, and any
   8  * portions thereof.
   9  */
  10
  11 /*
  12  * 3COM Etherlink 3C501 device driver
  13  */
  14
  15 /*
  16  * Bugs/possible improvements:
  17  *      - Does not currently support DMA
  18  *      - Does not currently support multicasts
  19  */
  20
  21 #include <sys/cdefs.h>
  22 __KERNEL_RCSID(0, "$NetBSD: if_el.c,v 1.83 2009/05/12 08:44:19 cegger Exp $");
  23
  24 #include "opt_inet.h"
  25 #include "bpfilter.h"
  26 #include "rnd.h"
  27
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/errno.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/mbuf.h>
  33 #include <sys/socket.h>
  34 #include <sys/syslog.h>
  35 #include <sys/device.h>
  36 #if NRND > 0
  37 #include <sys/rnd.h>
  38 #endif
  39
  40 #include <net/if.h>
  41 #include <net/if_dl.h>
  42 #include <net/if_types.h>
  43
  44 #include <net/if_ether.h>
  45
  46 #ifdef INET
  47 #include <netinet/in.h>
  48 #include <netinet/in_systm.h>
  49 #include <netinet/in_var.h>
  50 #include <netinet/ip.h>
  51 #include <netinet/if_inarp.h>
  52 #endif
  53
  54
  55 #if NBPFILTER > 0
  56 #include <net/bpf.h>
  57 #include <net/bpfdesc.h>
  58 #endif
  59
  60 #include <sys/cpu.h>
  61 #include <sys/intr.h>
  62 #include <sys/bus.h>
  63
  64 #include <dev/isa/isavar.h>
  65 #include <dev/isa/if_elreg.h>
  66
  67 /* for debugging convenience */
  68 #ifdef EL_DEBUG
  69 #define DPRINTF(x) printf x
  70 #else
  71 #define DPRINTF(x)
  72 #endif
  73
  74 /*
  75  * per-line info and status
  76  */
  77 struct el_softc {
  78         struct device sc_dev;
  79         void *sc_ih;
  80
  81         struct ethercom sc_ethercom;    /* ethernet common */
  82         bus_space_tag_t sc_iot;         /* bus space identifier */
  83         bus_space_handle_t sc_ioh;      /* i/o handle */
  84
  85 #if NRND > 0
  86         rndsource_element_t rnd_source;
  87 #endif
  88 };
  89
  90 /*
  91  * prototypes
  92  */
  93 int elintr(void *);
  94 void elinit(struct el_softc *);
  95 int elioctl(struct ifnet *, u_long, void *);
  96 void elstart(struct ifnet *);
  97 void elwatchdog(struct ifnet *);
  98 void elreset(struct el_softc *);
  99 void elstop(struct el_softc *);
 100 static int el_xmit(struct el_softc *);
 101 void elread(struct el_softc *, int);
 102 struct mbuf *elget(struct el_softc *sc, int);
 103 static inline void el_hardreset(struct el_softc *);
 104
 105 int elprobe(device_t, cfdata_t, void *);
 106 void elattach(device_t, device_t, void *);
 107
 108 CFATTACH_DECL(el, sizeof(struct el_softc),
 109     elprobe, elattach, NULL, NULL);
 110
 111 /*
 112  * Probe routine.
 113  *
 114  * See if the card is there and at the right place.
 115  * (XXX - cgd -- needs help)
 116  */
 117 int
 118 elprobe(device_t parent, cfdata_t match, void *aux)
 119 {
 120         struct isa_attach_args *ia = aux;
 121         bus_space_tag_t iot = ia->ia_iot;
 122         bus_space_handle_t ioh;
 123         int iobase;
 124         u_int8_t station_addr[ETHER_ADDR_LEN];
 125         u_int8_t i;
 126         int rval;
 127
 128         rval = 0;
 129
 130         if (ia->ia_nio < 1)
 131                 return (0);
 132         if (ia->ia_nirq < 1)
 133                 return (0);
 134
 135         if (ISA_DIRECT_CONFIG(ia))
 136                 return (0);
 137
 138         iobase = ia->ia_io[0].ir_addr;
 139
 140         if (ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT)
 141                 return (0);
 142         if (ia->ia_irq[0].ir_irq == ISA_UNKNOWN_IRQ)
 143                 return (0);
 144
 145         /* First check the base. */
 146         if (iobase < 0x200 || iobase > 0x3f0)
 147                 return 0;
 148
 149         /* Map i/o space. */
 150         if (bus_space_map(iot, iobase, 16, 0, &ioh))
 151                 return 0;
 152
 153         /*
 154          * Now attempt to grab the station address from the PROM and see if it
 155          * contains the 3com vendor code.
 156          */
 157         DPRINTF(("Probing 3c501 at 0x%x...\n", iobase));
 158
 159         /* Reset the board. */
 160         DPRINTF(("Resetting board...\n"));
 161         bus_space_write_1(iot, ioh, EL_AC, EL_AC_RESET);
 162         delay(5);
 163         bus_space_write_1(iot, ioh, EL_AC, 0);
 164
 165         /* Now read the address. */
 166         DPRINTF(("Reading station address...\n"));
 167         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 168                 bus_space_write_1(iot, ioh, EL_GPBL, i);
 169                 station_addr[i] = bus_space_read_1(iot, ioh, EL_EAW);
 170         }
 171         DPRINTF(("Address is %s\n", ether_sprintf(station_addr)));
 172
 173         /*
 174          * If the vendor code is ok, return a 1.  We'll assume that whoever
 175          * configured this system is right about the IRQ.
 176          */
 177         if (station_addr[0] != 0x02 || station_addr[1] != 0x60 ||
 178             station_addr[2] != 0x8c) {
 179                 DPRINTF(("Bad vendor code.\n"));
 180                 goto out;
 181         }
 182         DPRINTF(("Vendor code ok.\n"));
 183
 184         ia->ia_nio = 1;
 185         ia->ia_io[0].ir_size = 16;
 186
 187         ia->ia_nirq = 1;
 188
 189         ia->ia_niomem = 0;
 190         ia->ia_ndrq = 0;
 191
 192         rval = 1;
 193
 194  out:
 195         bus_space_unmap(iot, ioh, 16);
 196         return rval;
 197 }
 198
 199 /*
 200  * Attach the interface to the kernel data structures.  By the time this is
 201  * called, we know that the card exists at the given I/O address.  We still
 202  * assume that the IRQ given is correct.
 203  */
 204 void
 205 elattach(device_t parent, device_t self, void *aux)
 206 {
 207         struct el_softc *sc = (void *)self;
 208         struct isa_attach_args *ia = aux;
 209         bus_space_tag_t iot = ia->ia_iot;
 210         bus_space_handle_t ioh;
 211         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 212         u_int8_t myaddr[ETHER_ADDR_LEN];
 213         u_int8_t i;
 214
 215         printf("\n");
 216
 217         DPRINTF(("Attaching %s...\n", device_xname(&sc->sc_dev)));
 218
 219         /* Map i/o space. */
 220         if (bus_space_map(iot, ia->ia_io[0].ir_addr, 16, 0, &ioh)) {
 221                 aprint_error_dev(self, "can't map i/o space\n");
 222                 return;
 223         }
 224
 225         sc->sc_iot = iot;
 226         sc->sc_ioh = ioh;
 227
 228         /* Reset the board. */
 229         bus_space_write_1(iot, ioh, EL_AC, EL_AC_RESET);
 230         delay(5);
 231         bus_space_write_1(iot, ioh, EL_AC, 0);
 232
 233         /* Now read the address. */
 234         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 235                 bus_space_write_1(iot, ioh, EL_GPBL, i);
 236                 myaddr[i] = bus_space_read_1(iot, ioh, EL_EAW);
 237         }
 238
 239         /* Stop the board. */
 240         elstop(sc);
 241
 242         /* Initialize ifnet structure. */
 243         strlcpy(ifp->if_xname, device_xname(&sc->sc_dev), IFNAMSIZ);
 244         ifp->if_softc = sc;
 245         ifp->if_start = elstart;
 246         ifp->if_ioctl = elioctl;
 247         ifp->if_watchdog = elwatchdog;
 248         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
 249         IFQ_SET_READY(&ifp->if_snd);
 250
 251         /* Now we can attach the interface. */
 252         DPRINTF(("Attaching interface...\n"));
 253         if_attach(ifp);
 254         ether_ifattach(ifp, myaddr);
 255
 256         /* Print out some information for the user. */
 257         printf("%s: address %s\n", device_xname(self), ether_sprintf(myaddr));
 258
 259         sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq[0].ir_irq,
 260             IST_EDGE, IPL_NET, elintr, sc);
 261
 262 #if NRND > 0
 263         DPRINTF(("Attaching to random...\n"));
 264         rnd_attach_source(&sc->rnd_source, device_xname(&sc->sc_dev),
 265                           RND_TYPE_NET, 0);
 266 #endif
 267
 268         DPRINTF(("elattach() finished.\n"));
 269 }
 270
 271 /*
 272  * Reset interface.
 273  */
 274 void
 275 elreset(struct el_softc *sc)
 276 {
 277         int s;
 278
 279         DPRINTF(("elreset()\n"));
 280         s = splnet();
 281         elstop(sc);
 282         elinit(sc);
 283         splx(s);
 284 }
 285
 286 /*
 287  * Stop interface.
 288  */
 289 void
 290 elstop(struct el_softc *sc)
 291 {
 292
 293         bus_space_write_1(sc->sc_iot, sc->sc_ioh, EL_AC, 0);
 294 }
 295
 296 /*
 297  * Do a hardware reset of the board, and upload the ethernet address again in
 298  * case the board forgets.
 299  */
 300 static inline void
 301 el_hardreset(struct el_softc *sc)
 302 {
 303         bus_space_tag_t iot = sc->sc_iot;
 304         bus_space_handle_t ioh = sc->sc_ioh;
 305         int i;
 306
 307         bus_space_write_1(iot, ioh, EL_AC, EL_AC_RESET);
 308         delay(5);
 309         bus_space_write_1(iot, ioh, EL_AC, 0);
 310
 311         for (i = 0; i < ETHER_ADDR_LEN; i++)
 312                 bus_space_write_1(iot, ioh, i,
 313                     CLLADDR(sc->sc_ethercom.ec_if.if_sadl)[i]);
 314 }
 315
 316 /*
 317  * Initialize interface.
 318  */
 319 void
 320 elinit(struct el_softc *sc)
 321 {
 322         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 323         bus_space_tag_t iot = sc->sc_iot;
 324         bus_space_handle_t ioh = sc->sc_ioh;
 325
 326         /* First, reset the board. */
 327         el_hardreset(sc);
 328
 329         /* Configure rx. */
 330         DPRINTF(("Configuring rx...\n"));
 331         if (ifp->if_flags & IFF_PROMISC)
 332                 bus_space_write_1(iot, ioh, EL_RXC,
 333                     EL_RXC_AGF | EL_RXC_DSHORT | EL_RXC_DDRIB |
 334                     EL_RXC_DOFLOW | EL_RXC_PROMISC);
 335         else
 336                 bus_space_write_1(iot, ioh, EL_RXC,
 337                     EL_RXC_AGF | EL_RXC_DSHORT | EL_RXC_DDRIB |
 338                     EL_RXC_DOFLOW | EL_RXC_ABROAD);
 339         bus_space_write_1(iot, ioh, EL_RBC, 0);
 340
 341         /* Configure TX. */
 342         DPRINTF(("Configuring tx...\n"));
 343         bus_space_write_1(iot, ioh, EL_TXC, 0);
 344
 345         /* Start reception. */
 346         DPRINTF(("Starting reception...\n"));
 347         bus_space_write_1(iot, ioh, EL_AC, EL_AC_IRQE | EL_AC_RX);
 348
 349         /* Set flags appropriately. */
 350         ifp->if_flags |= IFF_RUNNING;
 351         ifp->if_flags &= ~IFF_OACTIVE;
 352
 353         /* And start output. */
 354         elstart(ifp);
 355 }
 356
 357 /*
 358  * Start output on interface.  Get datagrams from the queue and output them,
 359  * giving the receiver a chance between datagrams.  Call only from splnet or
 360  * interrupt level!
 361  */
 362 void
 363 elstart(struct ifnet *ifp)
 364 {
 365         struct el_softc *sc = ifp->if_softc;
 366         bus_space_tag_t iot = sc->sc_iot;
 367         bus_space_handle_t ioh = sc->sc_ioh;
 368         struct mbuf *m, *m0;
 369         int s, i, off, retries;
 370
 371         DPRINTF(("elstart()...\n"));
 372         s = splnet();
 373
 374         /* Don't do anything if output is active. */
 375         if ((ifp->if_flags & IFF_OACTIVE) != 0) {
 376                 splx(s);
 377                 return;
 378         }
 379
 380         ifp->if_flags |= IFF_OACTIVE;
 381
 382         /*
 383          * The main loop.  They warned me against endless loops, but would I
 384          * listen?  NOOO....
 385          */
 386         for (;;) {
 387                 /* Dequeue the next datagram. */
 388                 IFQ_DEQUEUE(&ifp->if_snd, m0);
 389
 390                 /* If there's nothing to send, return. */
 391                 if (m0 == 0)
 392                         break;
 393
 394 #if NBPFILTER > 0
 395                 /* Give the packet to the bpf, if any. */
 396                 if (ifp->if_bpf)
 397                         bpf_mtap(ifp->if_bpf, m0);
 398 #endif
 399
 400                 /* Disable the receiver. */
 401                 bus_space_write_1(iot, ioh, EL_AC, EL_AC_HOST);
 402                 bus_space_write_1(iot, ioh, EL_RBC, 0);
 403
 404                 /* Transfer datagram to board. */
 405                 DPRINTF(("el: xfr pkt length=%d...\n", m0->m_pkthdr.len));
 406                 off = EL_BUFSIZ - max(m0->m_pkthdr.len,
 407                     ETHER_MIN_LEN - ETHER_CRC_LEN);
 408 #ifdef DIAGNOSTIC
 409                 if ((off & 0xffff) != off)
 410                         printf("%s: bogus off 0x%x\n",
 411                             device_xname(&sc->sc_dev), off);
 412 #endif
 413                 bus_space_write_1(iot, ioh, EL_GPBL, off & 0xff);
 414                 bus_space_write_1(iot, ioh, EL_GPBH, (off >> 8) & 0xff);
 415
 416                 /* Copy the datagram to the buffer. */
 417                 for (m = m0; m != 0; m = m->m_next)
 418                         bus_space_write_multi_1(iot, ioh, EL_BUF,
 419                             mtod(m, u_int8_t *), m->m_len);
 420                 for (i = 0;
 421                     i < ETHER_MIN_LEN - ETHER_CRC_LEN - m0->m_pkthdr.len; i++)
 422                         bus_space_write_1(iot, ioh, EL_BUF, 0);
 423
 424                 m_freem(m0);
 425
 426                 /* Now transmit the datagram. */
 427                 retries = 0;
 428                 for (;;) {
 429                         bus_space_write_1(iot, ioh, EL_GPBL, off & 0xff);
 430                         bus_space_write_1(iot, ioh, EL_GPBH, (off >> 8) & 0xff);
 431                         if (el_xmit(sc)) {
 432                                 ifp->if_oerrors++;
 433                                 break;
 434                         }
 435                         /* Check out status. */
 436                         i = bus_space_read_1(iot, ioh, EL_TXS);
 437                         DPRINTF(("tx status=0x%x\n", i));
 438                         if ((i & EL_TXS_READY) == 0) {
 439                                 DPRINTF(("el: err txs=%x\n", i));
 440                                 if (i & (EL_TXS_COLL | EL_TXS_COLL16)) {
 441                                         ifp->if_collisions++;
 442                                         if ((i & EL_TXC_DCOLL16) == 0 &&
 443                                             retries < 15) {
 444                                                 retries++;
 445                                                 bus_space_write_1(iot, ioh,
 446                                                     EL_AC, EL_AC_HOST);
 447                                         }
 448                                 } else {
 449                                         ifp->if_oerrors++;
 450                                         break;
 451                                 }
 452                         } else {
 453                                 ifp->if_opackets++;
 454                                 break;
 455                         }
 456                 }
 457
 458                 /*
 459                  * Now give the card a chance to receive.
 460                  * Gotta love 3c501s...
 461                  */
 462                 (void)bus_space_read_1(iot, ioh, EL_AS);
 463                 bus_space_write_1(iot, ioh, EL_AC, EL_AC_IRQE | EL_AC_RX);
 464                 splx(s);
 465                 /* Interrupt here. */
 466                 s = splnet();
 467         }
 468
 469         (void)bus_space_read_1(iot, ioh, EL_AS);
 470         bus_space_write_1(iot, ioh, EL_AC, EL_AC_IRQE | EL_AC_RX);
 471         ifp->if_flags &= ~IFF_OACTIVE;
 472         splx(s);
 473 }
 474
 475 /*
 476  * This function actually attempts to transmit a datagram downloaded to the
 477  * board.  Call at splnet or interrupt, after downloading data!  Returns 0 on
 478  * success, non-0 on failure.
 479  */
 480 static int
 481 el_xmit(struct el_softc *sc)
 482 {
 483         bus_space_tag_t iot = sc->sc_iot;
 484         bus_space_handle_t ioh = sc->sc_ioh;
 485         int i;
 486
 487         /*
 488          * XXX
 489          * This busy-waits for the tx completion.  Can we get an interrupt
 490          * instead?
 491          */
 492
 493         DPRINTF(("el: xmit..."));
 494         bus_space_write_1(iot, ioh, EL_AC, EL_AC_TXFRX);
 495         i = 20000;
 496         while ((bus_space_read_1(iot, ioh, EL_AS) & EL_AS_TXBUSY) && (i > 0))
 497                 i--;
 498         if (i == 0) {
 499                 DPRINTF(("tx not ready\n"));
 500                 return -1;
 501         }
 502         DPRINTF(("%d cycles.\n", 20000 - i));
 503         return 0;
 504 }
 505
 506 /*
 507  * Controller interrupt.
 508  */
 509 int
 510 elintr(void *arg)
 511 {
 512         struct el_softc *sc = arg;
 513         bus_space_tag_t iot = sc->sc_iot;
 514         bus_space_handle_t ioh = sc->sc_ioh;
 515         u_int8_t rxstat;
 516         int len;
 517
 518         DPRINTF(("elintr: "));
 519
 520         /* Check board status. */
 521         if ((bus_space_read_1(iot, ioh, EL_AS) & EL_AS_RXBUSY) != 0) {
 522                 (void)bus_space_read_1(iot, ioh, EL_RXC);
 523                 bus_space_write_1(iot, ioh, EL_AC, EL_AC_IRQE | EL_AC_RX);
 524                 return 0;
 525         }
 526
 527         for (;;) {
 528                 rxstat = bus_space_read_1(iot, ioh, EL_RXS);
 529                 if (rxstat & EL_RXS_STALE)
 530                         break;
 531
 532                 /* If there's an overflow, reinit the board. */
 533                 if ((rxstat & EL_RXS_NOFLOW) == 0) {
 534                         DPRINTF(("overflow.\n"));
 535                         el_hardreset(sc);
 536                         /* Put board back into receive mode. */
 537                         if (sc->sc_ethercom.ec_if.if_flags & IFF_PROMISC)
 538                                 bus_space_write_1(iot, ioh, EL_RXC,
 539                                     EL_RXC_AGF | EL_RXC_DSHORT | EL_RXC_DDRIB |
 540                                     EL_RXC_DOFLOW | EL_RXC_PROMISC);
 541                         else
 542                                 bus_space_write_1(iot, ioh, EL_RXC,
 543                                     EL_RXC_AGF | EL_RXC_DSHORT | EL_RXC_DDRIB |
 544                                     EL_RXC_DOFLOW | EL_RXC_ABROAD);
 545                         (void)bus_space_read_1(iot, ioh, EL_AS);
 546                         bus_space_write_1(iot, ioh, EL_RBC, 0);
 547                         break;
 548                 }
 549
 550                 /* Incoming packet. */
 551                 len = bus_space_read_1(iot, ioh, EL_RBL);
 552                 len |= bus_space_read_1(iot, ioh, EL_RBH) << 8;
 553                 DPRINTF(("receive len=%d rxstat=%x ", len, rxstat));
 554                 bus_space_write_1(iot, ioh, EL_AC, EL_AC_HOST);
 555
 556                 /* Pass data up to upper levels. */
 557                 elread(sc, len);
 558
 559                 /* Is there another packet? */
 560                 if ((bus_space_read_1(iot, ioh, EL_AS) & EL_AS_RXBUSY) != 0)
 561                         break;
 562
 563 #if NRND > 0
 564                 rnd_add_uint32(&sc->rnd_source, rxstat);
 565 #endif
 566
 567                 DPRINTF(("<rescan> "));
 568         }
 569
 570         (void)bus_space_read_1(iot, ioh, EL_RXC);
 571         bus_space_write_1(iot, ioh, EL_AC, EL_AC_IRQE | EL_AC_RX);
 572         return 1;
 573 }
 574
 575 /*
 576  * Pass a packet to the higher levels.
 577  */
 578 void
 579 elread(struct el_softc *sc, int len)
 580 {
 581         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 582         struct mbuf *m;
 583
 584         if (len <= sizeof(struct ether_header) ||
 585             len > ETHER_MAX_LEN) {
 586                 printf("%s: invalid packet size %d; dropping\n",
 587                     device_xname(&sc->sc_dev), len);
 588                 ifp->if_ierrors++;
 589                 return;
 590         }
 591
 592         /* Pull packet off interface. */
 593         m = elget(sc, len);
 594         if (m == 0) {
 595                 ifp->if_ierrors++;
 596                 return;
 597         }
 598
 599         ifp->if_ipackets++;
 600
 601 #if NBPFILTER > 0
 602         /*
 603          * Check if there's a BPF listener on this interface.
 604          * If so, hand off the raw packet to BPF.
 605          */
 606         if (ifp->if_bpf)
 607                 bpf_mtap(ifp->if_bpf, m);
 608 #endif
 609
 610         (*ifp->if_input)(ifp, m);
 611 }
 612
 613 /*
 614  * Pull read data off a interface.  Len is length of data, with local net
 615  * header stripped.  We copy the data into mbufs.  When full cluster sized
 616  * units are present we copy into clusters.
 617  */
 618 struct mbuf *
 619 elget(struct el_softc *sc, int totlen)
 620 {
 621         struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 622         bus_space_tag_t iot = sc->sc_iot;
 623         bus_space_handle_t ioh = sc->sc_ioh;
 624         struct mbuf *m, *m0, *newm;
 625         int len;
 626
 627         MGETHDR(m0, M_DONTWAIT, MT_DATA);
 628         if (m0 == 0)
 629                 return (0);
 630         m0->m_pkthdr.rcvif = ifp;
 631         m0->m_pkthdr.len = totlen;
 632         len = MHLEN;
 633         m = m0;
 634
 635         bus_space_write_1(iot, ioh, EL_GPBL, 0);
 636         bus_space_write_1(iot, ioh, EL_GPBH, 0);
 637
 638         while (totlen > 0) {
 639                 if (totlen >= MINCLSIZE) {
 640                         MCLGET(m, M_DONTWAIT);
 641                         if ((m->m_flags & M_EXT) == 0)
 642                                 goto bad;
 643                         len = MCLBYTES;
 644                 }
 645
 646                 m->m_len = len = min(totlen, len);
 647                 bus_space_read_multi_1(iot, ioh, EL_BUF, mtod(m, u_int8_t *), len);
 648
 649                 totlen -= len;
 650                 if (totlen > 0) {
 651                         MGET(newm, M_DONTWAIT, MT_DATA);
 652                         if (newm == 0)
 653                                 goto bad;
 654                         len = MLEN;
 655                         m = m->m_next = newm;
 656                 }
 657         }
 658
 659         bus_space_write_1(iot, ioh, EL_RBC, 0);
 660         bus_space_write_1(iot, ioh, EL_AC, EL_AC_RX);
 661
 662         return (m0);
 663
 664 bad:
 665         m_freem(m0);
 666         return (0);
 667 }
 668
 669 /*
 670  * Process an ioctl request. This code needs some work - it looks pretty ugly.
 671  */
 672 int
 673 elioctl(struct ifnet *ifp, u_long cmd, void *data)
 674 {
 675         struct el_softc *sc = ifp->if_softc;
 676         struct ifaddr *ifa = (struct ifaddr *)data;
 677         int s, error = 0;
 678
 679         s = splnet();
 680
 681         switch (cmd) {
 682
 683         case SIOCINITIFADDR:
 684                 ifp->if_flags |= IFF_UP;
 685
 686                 elinit(sc);
 687                 switch (ifa->ifa_addr->sa_family) {
 688 #ifdef INET
 689                 case AF_INET:
 690                         arp_ifinit(ifp, ifa);
 691                         break;
 692 #endif
 693                 default:
 694                         break;
 695                 }
 696                 break;
 697
 698         case SIOCSIFFLAGS:
 699                 if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 700                         break;
 701                 /* XXX re-use ether_ioctl() */
 702                 switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
 703                 case IFF_RUNNING:
 704                         /*
 705                          * If interface is marked down and it is running, then
 706                          * stop it.
 707                          */
 708                         elstop(sc);
 709                         ifp->if_flags &= ~IFF_RUNNING;
 710                         break;
 711                 case IFF_UP:
 712                         /*
 713                          * If interface is marked up and it is stopped, then
 714                          * start it.
 715                          */
 716                         elinit(sc);
 717                         break;
 718                 default:
 719                         /*
 720                          * Some other important flag might have changed, so
 721                          * reset.
 722                          */
 723                         elreset(sc);
 724                         break;
 725                 }
 726                 break;
 727
 728         default:
 729                 error = ether_ioctl(ifp, cmd, data);
 730                 break;
 731         }
 732
 733         splx(s);
 734         return error;
 735 }
 736
 737 /*
 738  * Device timeout routine.
 739  */
 740 void
 741 elwatchdog(struct ifnet *ifp)
 742 {
 743         struct el_softc *sc = ifp->if_softc;
 744
 745         log(LOG_ERR, "%s: device timeout\n", device_xname(&sc->sc_dev));
 746         sc->sc_ethercom.ec_if.if_oerrors++;
 747
 748         elreset(sc);
 749 }