root/dev/isa/if_eg.c

DEFINITIONS

1. egprintpcb
2. egprintstat
3. egoutPCB
4. egreadPCBstat
5. egreadPCBready
6. egwritePCB
7. egreadPCB
8. egprobe
9. egattach
10. eginit
11. egrecv
12. egstart
13. egintr
14. egread
15. egget
16. egioctl
17. egreset
18. egwatchdog
19. egstop

    1 /*      $OpenBSD: if_eg.c,v 1.30 2007/01/07 15:15:58 miod Exp $ */
    2 /*      $NetBSD: if_eg.c,v 1.26 1996/05/12 23:52:27 mycroft Exp $       */
    4 /*
    5  * Copyright (c) 1993 Dean Huxley <dean@fsa.ca>
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *      This product includes software developed by Dean Huxley.
   19  * 4. The name of Dean Huxley may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  */
   33 /*
   34  * Support for 3Com 3c505 Etherlink+ card.
   35  */
   37 /* To do:
   38  * - multicast
   39  * - promiscuous
   40  */
   41 #include "bpfilter.h"
   43 #include <sys/types.h>
   44 #include <sys/param.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/socket.h>
   47 #include <sys/ioctl.h>
   48 #include <sys/errno.h>
   49 #include <sys/syslog.h>
   50 #include <sys/systm.h>
   51 #include <sys/selinfo.h>
   52 #include <sys/device.h>
   54 #include <net/if.h>
   55 #include <net/if_dl.h>
   56 #include <net/if_types.h>
   57 #include <net/netisr.h>
   59 #ifdef INET
   60 #include <netinet/in.h>
   61 #include <netinet/in_systm.h>
   62 #include <netinet/in_var.h>
   63 #include <netinet/ip.h>
   64 #include <netinet/if_ether.h>
   65 #endif
   67 #if NBPFILTER > 0
   68 #include <net/bpf.h>
   69 #endif
   71 #include <machine/cpu.h>
   72 #include <machine/intr.h>
   74 #include <dev/isa/isavar.h>
   75 #include <dev/isa/if_egreg.h>
   76 #include <dev/isa/elink.h>
   78 /* for debugging convenience */
   79 #ifdef EGDEBUG
   80 #define DPRINTF(x) printf x
   81 #else
   82 #define DPRINTF(x)
   83 #endif
   85 #define EG_INLEN        10
   86 #define EG_BUFLEN       0x0670
   88 /*
   89  * Ethernet software status per interface.
   90  */
   91 struct eg_softc {
   92         struct device sc_dev;
   93         void *sc_ih;
bus_space_tag_t sc_bst;
bus_space_handle_t sc_bsh;
   96         struct arpcom sc_arpcom;        /* Ethernet common part */
u_char  eg_rom_major;           /* Cards ROM version (major number) */ 
u_char  eg_rom_minor;           /* Cards ROM version (minor number) */ 
   99         short   eg_ram;                 /* Amount of RAM on the card */
u_char  eg_pcb[64];             /* Primary Command Block buffer */
u_char  eg_incount;             /* Number of buffers currently used */
u_char  *eg_inbuf;              /* Incoming packet buffer */
u_char  *eg_outbuf;             /* Outgoing packet buffer */
  104 };
  106 int egprobe(struct device *, void *, void *);
  107 void egattach(struct device *, struct device *, void *);
  109 struct cfattach eg_ca = {
  110         sizeof(struct eg_softc), egprobe, egattach
  111 };
  113 struct cfdriver eg_cd = {
NULL, "eg", DV_IFNET
  115 };
  117 int egintr(void *);
  118 void eginit(struct eg_softc *);
  119 int egioctl(struct ifnet *, u_long, caddr_t);
  120 void egrecv(struct eg_softc *);
  121 void egstart(struct ifnet *);
  122 void egwatchdog(struct ifnet *);
  123 void egreset(struct eg_softc *);
  124 void egread(struct eg_softc *, caddr_t, int);
  125 struct mbuf *egget(struct eg_softc *, caddr_t, int);
  126 void egstop(struct eg_softc *);
  128 static __inline void egprintpcb(struct eg_softc *);
  129 static __inline void egprintstat(u_char);
  130 static int egoutPCB(struct eg_softc *, u_char);
  131 static int egreadPCBstat(struct eg_softc *, u_char);
  132 static int egreadPCBready(struct eg_softc *);
  133 static int egwritePCB(struct eg_softc *);
  134 static int egreadPCB(struct eg_softc *);
  136 /*
  137  * Support stuff
  138  */
  140 static __inline void
egprintpcb(sc)
  142         struct eg_softc *sc;
  143 {
  144         int i;
  146         for (i = 0; i < sc->eg_pcb[1] + 2; i++)
DPRINTF(("pcb[%2d] = %x\n", i, sc->eg_pcb[i]));
  148 }
  151 static __inline void
egprintstat(b)
u_char b;
  154 {
DPRINTF(("%s %s %s %s %s %s %s\n", 
  156             (b & EG_STAT_HCRE)?"HCRE":"",
  157             (b & EG_STAT_ACRF)?"ACRF":"",
  158             (b & EG_STAT_DIR )?"DIR ":"",
  159             (b & EG_STAT_DONE)?"DONE":"",
  160             (b & EG_STAT_ASF3)?"ASF3":"",
  161             (b & EG_STAT_ASF2)?"ASF2":"",
  162             (b & EG_STAT_ASF1)?"ASF1":""));
  163 }
  165 static int
egoutPCB(sc, b)
  167         struct eg_softc *sc;
u_char b;
  169 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  172         int i;
  174         for (i = 0; i < 4000; i++) {
  175                 if (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_HCRE) {
bus_space_write_1(bst, bsh, EG_COMMAND, b);
  177                         return 0;
  178                 }
delay(10);
  180         }
DPRINTF(("egoutPCB failed\n"));
  182         return (1);
  183 }
  185 static int
egreadPCBstat(sc, statb)
  187         struct eg_softc *sc;
u_char statb;
  189 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  192         int i;
  194         for (i=0; i < 5000; i++) {
  195                 if ((bus_space_read_1(bst, bsh, EG_STATUS) & EG_PCB_STAT) !=
EG_PCB_NULL) 
  197                         break;
delay(10);
  199         }
  200         if ((bus_space_read_1(bst, bsh, EG_STATUS) & EG_PCB_STAT) == statb) 
  201                 return (0);
  202         return (1);
  203 }
  205 static int
egreadPCBready(sc)
  207         struct eg_softc *sc;
  208 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  211         int i;
  213         for (i=0; i < 10000; i++) {
  214                 if (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_ACRF)
  215                         return (0);
delay(5);
  217         }
DPRINTF(("PCB read not ready status %02x\n",
bus_space_read_1(bst, bsh, EG_STATUS)));
  220         return (1);
  221 }
  223 static int
egwritePCB(sc)
  225         struct eg_softc *sc;
  226 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  229         int i;
u_char len;
bus_space_write_1(bst, bsh, EG_CONTROL,
  233             (bus_space_read_1(bst, bsh, EG_CONTROL) & ~EG_PCB_STAT) |
EG_PCB_NULL);
len = sc->eg_pcb[1] + 2;
  237         for (i = 0; i < len; i++)
egoutPCB(sc, sc->eg_pcb[i]);
  240         for (i=0; i < 4000; i++) {
  241                 if (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_HCRE)
  242                         break;
delay(10);
  244         }
bus_space_write_1(bst, bsh, EG_CONTROL,
  247             (bus_space_read_1(bst, bsh, EG_CONTROL) & ~EG_PCB_STAT) |
EG_PCB_DONE);
egoutPCB(sc, len);
  252         if (egreadPCBstat(sc, EG_PCB_ACCEPT))
  253                 return (1);
  254         return (0);
  255 }       
  257 static int
egreadPCB(sc)
  259         struct eg_softc *sc;
  260 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  263         int i;
u_char b;
bus_space_write_1(bst, bsh, EG_CONTROL,
  267             (bus_space_read_1(bst, bsh, EG_CONTROL) & ~EG_PCB_STAT) |
EG_PCB_NULL);
bzero(sc->eg_pcb, sizeof(sc->eg_pcb));
  272         if (egreadPCBready(sc))
  273                 return (1);
sc->eg_pcb[0] = bus_space_read_1(bst, bsh, EG_COMMAND);
  277         if (egreadPCBready(sc))
  278                 return (1);
sc->eg_pcb[1] = bus_space_read_1(bst, bsh, EG_COMMAND);
  282         if (sc->eg_pcb[1] > 62) {
DPRINTF(("len %d too large\n", sc->eg_pcb[1]));
  284                 return (1);
  285         }
  287         for (i = 0; i < sc->eg_pcb[1]; i++) {
  288                 if (egreadPCBready(sc))
  289                         return (1);
sc->eg_pcb[2+i] = bus_space_read_1(bst, bsh, EG_COMMAND);
  291         }
  292         if (egreadPCBready(sc))
  293                 return (1);
  294         if (egreadPCBstat(sc, EG_PCB_DONE))
  295                 return (1);
  296         if ((b = bus_space_read_1(bst, bsh, EG_COMMAND)) != sc->eg_pcb[1] + 2) {
DPRINTF(("%d != %d\n", b, sc->eg_pcb[1] + 2));
  298                 return (1);
  299         }
bus_space_write_1(bst, bsh, EG_CONTROL,
  302             (bus_space_read_1(bst, bsh, EG_CONTROL) & ~EG_PCB_STAT) |
EG_PCB_ACCEPT);
  305         return (0);
  306 }       
  308 /*
  309  * Real stuff
  310  */
  312 int
egprobe(parent, match, aux)
  314         struct device *parent;
  315         void *match, *aux;
  316 {
  317         struct eg_softc *sc = match;
  318         struct isa_attach_args *ia = aux;
bus_space_tag_t bst = sc->sc_bst = ia->ia_iot;
bus_space_handle_t bsh;
  321         int i;
  323         if ((ia->ia_iobase & ~0x07f0) != 0) {
DPRINTF(("Weird iobase %x\n", ia->ia_iobase));
  325                 return (0);
  326         }
  328         if (bus_space_map(bst, ia->ia_iobase, EG_IO_PORTS, 0, &bsh)) {
DPRINTF(("%s: can't map I/O space\n", sc->sc_dev.dv_xname));
  330                 return (0);
  331         }
sc->sc_bsh = bsh;
  334         /* hard reset card */
bus_space_write_1(bst, bsh, EG_CONTROL, EG_CTL_RESET); 
bus_space_write_1(bst, bsh, EG_CONTROL, 0);
  337         for (i = 0; i < 5000; i++) {
delay(1000);
  339                 if ((bus_space_read_1(bst, bsh, EG_STATUS) & EG_PCB_STAT) ==
EG_PCB_NULL) 
  341                         break;
  342         }
  343         if ((bus_space_read_1(bst, bsh, EG_STATUS) & EG_PCB_STAT) !=
EG_PCB_NULL) {
DPRINTF(("eg: Reset failed\n"));
  346                 goto lose;
  347         }
sc->eg_pcb[0] = EG_CMD_GETINFO; /* Get Adapter Info */
sc->eg_pcb[1] = 0;
  350         if (egwritePCB(sc) != 0)
  351                 goto lose;
  353         if (egreadPCB(sc) != 0) {
egprintpcb(sc);
  355                 goto lose;
  356         }
  358         if (sc->eg_pcb[0] != EG_RSP_GETINFO || /* Get Adapter Info Response */
sc->eg_pcb[1] != 0x0a) {
egprintpcb(sc);
  361                 goto lose;
  362         }
sc->eg_rom_major = sc->eg_pcb[3];
sc->eg_rom_minor = sc->eg_pcb[2];
sc->eg_ram = sc->eg_pcb[6] | (sc->eg_pcb[7] << 8);
ia->ia_iosize = 0x08;
ia->ia_msize = 0;
bus_space_unmap(bst, bsh, EG_IO_PORTS);
  370         return (1);
lose:
bus_space_unmap(bst, bsh, EG_IO_PORTS);
  374         return (0);
  375 }
  377 void
egattach(parent, self, aux)
  379         struct device *parent, *self;
  380         void *aux;
  381 {
  382         struct eg_softc *sc = (void *)self;
  383         struct isa_attach_args *ia = aux;
bus_space_tag_t bst = sc->sc_bst = ia->ia_iot;
bus_space_handle_t bsh;
  386         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  388         if (bus_space_map(bst, ia->ia_iobase, EG_IO_PORTS, 0, &bsh)) {
printf("%s: can't map i/o space\n", sc->sc_dev.dv_xname);
  390                 return;
  391         }
sc->sc_bsh = bsh;
egstop(sc);
sc->eg_pcb[0] = EG_CMD_GETEADDR; /* Get Station address */
sc->eg_pcb[1] = 0;
  398         if (egwritePCB(sc) != 0) {
DPRINTF(("write error\n"));
  400                 return;
  401         }       
  402         if (egreadPCB(sc) != 0) {
DPRINTF(("read error\n"));
egprintpcb(sc);
  405                 return;
  406         }
  408         /* check Get station address response */
  409         if (sc->eg_pcb[0] != EG_RSP_GETEADDR || sc->eg_pcb[1] != 0x06) { 
DPRINTF(("parse error\n"));
egprintpcb(sc);
  412                 return;
  413         }
bcopy(&sc->eg_pcb[2], sc->sc_arpcom.ac_enaddr, ETHER_ADDR_LEN);
printf(": ROM v%d.%02d %dk address %s\n",
sc->eg_rom_major, sc->eg_rom_minor, sc->eg_ram,
ether_sprintf(sc->sc_arpcom.ac_enaddr));
sc->eg_pcb[0] = EG_CMD_SETEADDR; /* Set station address */
  421         if (egwritePCB(sc) != 0) {
DPRINTF(("write error2\n"));
  423                 return;
  424         }
  425         if (egreadPCB(sc) != 0) {
DPRINTF(("read error2\n"));
egprintpcb(sc);
  428                 return;
  429         }
  430         if (sc->eg_pcb[0] != EG_RSP_SETEADDR || sc->eg_pcb[1] != 0x02 ||
sc->eg_pcb[2] != 0 || sc->eg_pcb[3] != 0) {
DPRINTF(("parse error2\n"));
egprintpcb(sc);
  434                 return;
  435         }
  437         /* Initialize ifnet structure. */
bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_start = egstart;
ifp->if_ioctl = egioctl;
ifp->if_watchdog = egwatchdog;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
IFQ_SET_READY(&ifp->if_snd);
  446         /* Now we can attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
IPL_NET, egintr, sc, sc->sc_dev.dv_xname);
  452 }
  454 void
eginit(sc)
  456         register struct eg_softc *sc;
  457 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  460         register struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  462         /* soft reset the board */
bus_space_write_1(bst, bsh, EG_CONTROL, EG_CTL_FLSH);
delay(100);
bus_space_write_1(bst, bsh, EG_CONTROL, EG_CTL_ATTN);
delay(100);
bus_space_write_1(bst, bsh, EG_CONTROL, 0);
delay(200);
sc->eg_pcb[0] = EG_CMD_CONFIG82586; /* Configure 82586 */
sc->eg_pcb[1] = 2;
sc->eg_pcb[2] = 3; /* receive broadcast & multicast */
sc->eg_pcb[3] = 0;
  474         if (egwritePCB(sc) != 0)
DPRINTF(("write error3\n"));
  477         if (egreadPCB(sc) != 0) {
DPRINTF(("read error3\n"));
egprintpcb(sc);
  480         } else if (sc->eg_pcb[2] != 0 || sc->eg_pcb[3] != 0)
printf("%s: configure card command failed\n",
sc->sc_dev.dv_xname);
  484         if (sc->eg_inbuf == 0)
sc->eg_inbuf = malloc(EG_BUFLEN, M_TEMP, M_NOWAIT);
sc->eg_incount = 0;
  488         if (sc->eg_outbuf == 0)
sc->eg_outbuf = malloc(EG_BUFLEN, M_TEMP, M_NOWAIT);
bus_space_write_1(bst, bsh, EG_CONTROL, EG_CTL_CMDE);
sc->eg_incount = 0;
egrecv(sc);
  496         /* Interface is now `running', with no output active. */
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
  500         /* Attempt to start output, if any. */
egstart(ifp);
  502 }
  504 void
egrecv(sc)
  506         struct eg_softc *sc;
  507 {
  509         while (sc->eg_incount < EG_INLEN) {
sc->eg_pcb[0] = EG_CMD_RECVPACKET;
sc->eg_pcb[1] = 0x08;
sc->eg_pcb[2] = 0; /* address not used.. we send zero */
sc->eg_pcb[3] = 0;
sc->eg_pcb[4] = 0;
sc->eg_pcb[5] = 0;
sc->eg_pcb[6] = EG_BUFLEN & 0xff; /* our buffer size */
sc->eg_pcb[7] = (EG_BUFLEN >> 8) & 0xff;
sc->eg_pcb[8] = 0; /* timeout, 0 == none */
sc->eg_pcb[9] = 0;
  520                 if (egwritePCB(sc) != 0)
  521                         break;
sc->eg_incount++;
  523         }
  524 }
  526 void
egstart(ifp)
  528         struct ifnet *ifp;
  529 {
  530         struct eg_softc *sc = ifp->if_softc;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  533         struct mbuf *m0, *m;
caddr_t buffer;
  535         int len;
u_short *ptr;
u_int i;
  539         /* Don't transmit if interface is busy or not running */
  540         if ((ifp->if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING)
  541                 return;
loop:
  544         /* Dequeue the next datagram. */
IFQ_DEQUEUE(&ifp->if_snd, m0);
  546         if (m0 == 0)
  547                 return;
ifp->if_flags |= IFF_OACTIVE;
  551         /* We need to use m->m_pkthdr.len, so require the header */
  552         if ((m0->m_flags & M_PKTHDR) == 0)
panic("egstart: no header mbuf");
len = max(m0->m_pkthdr.len, ETHER_MIN_LEN);
  556 #if NBPFILTER > 0
  557         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
  559 #endif
sc->eg_pcb[0] = EG_CMD_SENDPACKET;
sc->eg_pcb[1] = 0x06;
sc->eg_pcb[2] = 0; /* address not used, we send zero */
sc->eg_pcb[3] = 0;
sc->eg_pcb[4] = 0;
sc->eg_pcb[5] = 0;
sc->eg_pcb[6] = len; /* length of packet */
sc->eg_pcb[7] = len >> 8;
  569         if (egwritePCB(sc) != 0) {
DPRINTF(("egwritePCB in egstart failed\n"));
ifp->if_oerrors++;
ifp->if_flags &= ~IFF_OACTIVE;
m_freem(m0);
  574                 goto loop;
  575         }
buffer = sc->eg_outbuf;
  578         for (m = m0; m != 0; m = m->m_next) {
bcopy(mtod(m, caddr_t), buffer, m->m_len);
buffer += m->m_len;
  581         }
  582         if (len > m0->m_pkthdr.len)
bzero(buffer, len - m0->m_pkthdr.len);
  585         /* set direction bit: host -> adapter */
bus_space_write_1(bst, bsh, EG_CONTROL,
bus_space_read_1(bst, bsh, EG_CONTROL) & ~EG_CTL_DIR); 
  589         for (ptr = (u_short *)sc->eg_outbuf; len > 0; len -= 2) {
bus_space_write_2(bst, bsh, EG_DATA, *ptr++);
  591                 for (i = 10000; i != 0; i--) {
  592                         if (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_HRDY)
  593                                 break;
delay(10);
  595                 }
  596                 if (i == 0) {
printf("%s: start failed\n", sc->sc_dev.dv_xname);
  598                         break;
  599                 }
  600         }
m_freem(m0);
  603 }
  605 int
egintr(arg)
  607         void *arg;
  608 {
  609         struct eg_softc *sc = arg;
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
  612         int ret = 0;
  613         int i, len;
u_short *ptr;
  616         while (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_ACRF) {
ret = 1;
egreadPCB(sc);
  619                 switch (sc->eg_pcb[0]) {
  620                 case EG_RSP_RECVPACKET:
len = sc->eg_pcb[6] | (sc->eg_pcb[7] << 8);
  623                         /* Set direction bit : Adapter -> host */
bus_space_write_1(bst, bsh, EG_CONTROL,
bus_space_read_1(bst, bsh, EG_CONTROL) |
EG_CTL_DIR); 
  628                         for (ptr = (u_short *)sc->eg_inbuf; len > 0; len -= 2) {
  629                                 for (i = 10000; i != 0; i--) {
  630                                         if (bus_space_read_1(bst, bsh, EG_STATUS) & EG_STAT_HRDY)
  631                                                 break;
delay(10);
  633                                 }
  634                                 if (i == 0) {
printf("%s: receive failed\n",
sc->sc_dev.dv_xname);
  637                                         break;
  638                                 }
  639                                 *ptr++ = bus_space_read_2(bst, bsh, EG_DATA);
  640                         }
  642                         if (len <= 0) {
len = sc->eg_pcb[8] | (sc->eg_pcb[9] << 8);
egread(sc, sc->eg_inbuf, len);
sc->eg_incount--;
egrecv(sc);
  648                         }
  649                         break;
  651                 case EG_RSP_SENDPACKET:
  652                         if (sc->eg_pcb[6] || sc->eg_pcb[7]) {
DPRINTF(("packet dropped\n"));
sc->sc_arpcom.ac_if.if_oerrors++;
  655                         } else
sc->sc_arpcom.ac_if.if_opackets++;
sc->sc_arpcom.ac_if.if_collisions +=
sc->eg_pcb[8] & 0xf;
sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
egstart(&sc->sc_arpcom.ac_if);
  661                         break;
  663                 case EG_RSP_GETSTATS:
DPRINTF(("Card Statistics\n"));
bcopy(&sc->eg_pcb[2], &i, sizeof(i));
DPRINTF(("Receive Packets %d\n", i));
bcopy(&sc->eg_pcb[6], &i, sizeof(i));
DPRINTF(("Transmit Packets %d\n", i));
DPRINTF(("CRC errors %d\n", *(short *)&sc->eg_pcb[10]));
DPRINTF(("alignment errors %d\n",
  671                             *(short *)&sc->eg_pcb[12]));
DPRINTF(("no resources errors %d\n",
  673                             *(short *)&sc->eg_pcb[14]));
DPRINTF(("overrun errors %d\n",
  675                             *(short *)&sc->eg_pcb[16]));
  676                         break;
  678                 default:
DPRINTF(("egintr: Unknown response %x??\n",
sc->eg_pcb[0]));
egprintpcb(sc);
  682                         break;
  683                 }
  684         }
  686         return (ret);
  687 }
  689 /*
  690  * Pass a packet up to the higher levels.
  691  */
  692 void
egread(sc, buf, len)
  694         struct eg_softc *sc;
caddr_t buf;
  696         int len;
  697 {
  698         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  699         struct mbuf *m;
  701         if (len <= sizeof(struct ether_header) ||
len > ETHER_MAX_LEN) {
printf("%s: invalid packet size %d; dropping\n",
sc->sc_dev.dv_xname, len);
ifp->if_ierrors++;
  706                 return;
  707         }
  709         /* Pull packet off interface. */
m = egget(sc, buf, len);
  711         if (m == 0) {
ifp->if_ierrors++;
  713                 return;
  714         }
ifp->if_ipackets++;
  718 #if NBPFILTER > 0
  719         /*
  720          * Check if there's a BPF listener on this interface.
  721          * If so, hand off the raw packet to BPF.
  722          */
  723         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
  725 #endif
ether_input_mbuf(ifp, m);
  728 }
  730 /*
  731  * convert buf into mbufs
  732  */
  733 struct mbuf *
egget(sc, buf, totlen)
  735         struct eg_softc *sc;
caddr_t buf;
  737         int totlen;
  738 {
  739         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  740         struct mbuf *top, **mp, *m;
  741         int len;
MGETHDR(m, M_DONTWAIT, MT_DATA);
  744         if (m == 0)
  745                 return (0);
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.len = totlen;
len = MHLEN;
top = 0;
mp = &top;
  752         while (totlen > 0) {
  753                 if (top) {
MGET(m, M_DONTWAIT, MT_DATA);
  755                         if (m == 0) {
m_freem(top);
  757                                 return (0);
  758                         }
len = MLEN;
  760                 }
  761                 if (totlen >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
  763                         if (m->m_flags & M_EXT)
len = MCLBYTES;
  765                 }
m->m_len = len = min(totlen, len);
bcopy((caddr_t)buf, mtod(m, caddr_t), len);
buf += len;
totlen -= len;
  770                 *mp = m;
mp = &m->m_next;
  772         }
  774         return (top);
  775 }
  777 int
egioctl(ifp, cmd, data)
  779         register struct ifnet *ifp;
u_long cmd;
caddr_t data;
  782 {
  783         struct eg_softc *sc = ifp->if_softc;
  784         struct ifaddr *ifa = (struct ifaddr *)data;
  785         int s, error = 0;
s = splnet();
  789         if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
splx(s);
  791                 return (error);
  792         }
  794         switch (cmd) {
  796         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
  799                 switch (ifa->ifa_addr->sa_family) {
  800 #ifdef INET
  801                 case AF_INET:
eginit(sc);
arp_ifinit(&sc->sc_arpcom, ifa);
  804                         break;
  805 #endif
  806                 default:
eginit(sc);
  808                         break;
  809                 }
  810                 break;
  812         case SIOCSIFFLAGS:
  813                 if ((ifp->if_flags & IFF_UP) == 0 &&
  814                     (ifp->if_flags & IFF_RUNNING) != 0) {
  815                         /*
  816                          * If interface is marked down and it is running, then
  817                          * stop it.
  818                          */
egstop(sc);
ifp->if_flags &= ~IFF_RUNNING;
  821                 } else if ((ifp->if_flags & IFF_UP) != 0 &&
  822                            (ifp->if_flags & IFF_RUNNING) == 0) {
  823                         /*
  824                          * If interface is marked up and it is stopped, then
  825                          * start it.
  826                          */
eginit(sc);
  828                 } else {
sc->eg_pcb[0] = EG_CMD_GETSTATS;
sc->eg_pcb[1] = 0;
  831                         if (egwritePCB(sc) != 0)
DPRINTF(("write error\n"));
  833                         /*
  834                          * XXX deal with flags changes:
  835                          * IFF_MULTICAST, IFF_PROMISC,
  836                          * IFF_LINK0, IFF_LINK1,
  837                          */
  838                 }
  839                 break;
  841         default:
error = EINVAL;
  843                 break;
  844         }
splx(s);
  847         return (error);
  848 }
  850 void
egreset(sc)
  852         struct eg_softc *sc;
  853 {
  854         int s;
DPRINTF(("egreset()\n"));
s = splnet();
egstop(sc);
eginit(sc);
splx(s);
  861 }
  863 void
egwatchdog(ifp)
  865         struct ifnet *ifp;
  866 {
  867         struct eg_softc *sc = ifp->if_softc;
log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_oerrors++;
egreset(sc);
  873 }
  875 void
egstop(sc)
  877         register struct eg_softc *sc;
  878 {
bus_space_tag_t bst = sc->sc_bst;
bus_space_handle_t bsh = sc->sc_bsh;
bus_space_write_1(bst, bsh, EG_CONTROL, 0);
  883 }