+/*
+ * Copyright (c) 1986 Regents of the University of California.
+ * All rights reserved. The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ * @(#)if_ix.c 6.1 (Berkeley) %G%
+ */
+
+#include "np.h"
+#if NNP > 0
+
+/*
+ * Interlan NP100 Ethernet Communications Controller interface
+ */
+#include "../machine/pte.h"
+
+#include "param.h"
+#include "systm.h"
+#include "mbuf.h"
+#include "buf.h"
+#include "protosw.h"
+#include "socket.h"
+#include "vmmac.h"
+#include "ioctl.h"
+#include "errno.h"
+
+#include "../net/if.h"
+#include "../net/netisr.h"
+#include "../net/route.h"
+
+#ifdef INET
+#include "../netinet/in.h"
+#include "../netinet/in_systm.h"
+#include "../netinet/in_var.h"
+#include "../netinet/ip.h"
+#include "../netinet/if_ether.h"
+#endif
+
+#ifdef NS
+#include "../netns/ns.h"
+#include "../netns/ns_if.h"
+#endif
+
+#include "../vax/cpu.h"
+#include "../vax/mtpr.h"
+#include "../vaxif/if_uba.h"
+#include "../vaxuba/ubareg.h"
+#include "../vaxuba/ubavar.h"
+#include "../vaxuba/npreg.h"
+#include "../vaxif/if_ix.h"
+
+int ixattach(), ixrint(), ixcint();
+#define ILUNIT(x) minor(x)
+int ixinit(), ixoutput(), ixioctl(), ixreset(), ixwatch();
+int (*IxAttach)() = ixattach;
+int (*IxReset)() = ixreset;
+
+/*
+ * Ethernet software status per interface.
+ *
+ * Each interface is referenced by a network interface structure,
+ * ix_if, which the routing code uses to locate the interface.
+ * This structure contains the output queue for the interface, its address, ...
+ * We also have, for each interface, a UBA interface structure, which
+ * contains information about the UNIBUS resources held by the interface:
+ * map registers, buffered data paths, etc. Information is cached in this
+ * structure for use by the if_uba.c routines in running the interface
+ * efficiently.
+ */
+struct ix_softc {
+ struct arpcom ix_ac; /* Ethernet common part */
+#define ix_if ix_ac.ac_if /* network-visible interface */
+#define ix_addr ix_ac.ac_enaddr /* hardware Ethernet address */
+ int ix_flags;
+#define IXF_OACTIVE 0x1 /* output is active */
+#define IXF_RCVPENDING 0x2 /* start rcv in ilcint */
+#define IXF_GOTUBA 0x4 /* unibus resources mapped */
+#define IXF_RUNNING 0x8 /* board is running */
+#define IXF_SETADDR 0x10 /* physical address is changed */
+#define IXF_STATPENDING 0x20 /* stat cmd pending */
+#define IXF_GOTCQE 0x40 /* np resources available */
+ struct ifuba ix_ifuba; /* unibus resources */
+ u_short ix_aid; /* Access Id returned by open DDL */
+ u_short ix_badcqe;
+ struct npmaster *ix_mp; /* Board physio request header */
+ struct npreq *ix_rrp; /* Cached npreq for recv */
+ struct npreq *ix_wrp; /* Cached npreq for xmit */
+ short ix_scaninterval; /* interval of stat collection */
+#define IXWATCHINTERVAL 60 /* once every 60 seconds */
+ union ix_stats ix_stats; /* holds on-board statistics */
+ int ix_ubaddr; /* mapping registers of ix_stats */
+} ix_softc[NNP];
+extern struct uba_device *npdinfo[];
+
+/*
+ * Interface exists: make available by filling in network interface
+ * record. System will initialize the interface when it is ready
+ * to accept packets. We can't even get the ethernet address
+ * or other interesting data until the board has been downloaded.
+ * running ifconfig will attempt to start unit.
+ */
+ixattach(ui)
+ struct uba_device *ui;
+{
+ register struct ix_softc *ix = &ix_softc[ui->ui_unit];
+ register struct ifnet *ifp = &ix->ix_if;
+ extern struct npmaster npmasters[];
+
+ ifp->if_unit = ui->ui_unit;
+ ifp->if_name = "ix";
+ ifp->if_mtu = ETHERMTU;
+ ifp->if_flags = IFF_BROADCAST;
+
+ ifp->if_init = ixinit;
+ ifp->if_output = ixoutput;
+ ifp->if_ioctl = ixioctl;
+ ifp->if_reset = ixreset;
+
+ ix->ix_mp = npmasters + ui->ui_unit;
+ ix->ix_ifuba.ifu_flags = UBA_CANTWAIT;
+
+ if_attach(ifp);
+}
+
+struct npreq *
+ix_GetReq(mp, addr, len)
+ struct npmaster *mp;
+ caddr_t addr;
+{
+ int unit = mp->unit;
+ register struct npreq *rp;
+ register struct CQE *ep;
+ struct ix_softc *ix = ix_softc + unit;
+ extern struct npreq *NpGetReq();
+
+ while ((rp = NpGetReq(mp->reqtab)) == NULL) {
+ mp->reqtab->flags |= WANTREQ;
+ sleep((caddr_t)(mp->reqtab), PZERO - 1);
+ }
+ rp->flags = KERNREQ; /* Clear flags */
+
+ ep = rp->element; /* Associated CQE */
+ ep->cqe_famid = (unsign32)ix; /* Process ID */
+ ep->cqe_wind = 0; /* Amount of buffer mapped */
+ ep->cqe_nbuf = 1; /* Must be 1, no buffer chain */
+ ep->cqe_char = 1; /* Driver owns this CQE */
+ ep->cqe_prot = NPDLA; /* Data Link Access protocol */
+ ep->cqe_bcnt = len; /* Byte count */
+ rp->bufaddr = (caddr_t) (UBADDRMASK & (int) addr);/* mapped buffer */
+ ep->cqe_dma[0] = (unsign16)LOWORD(rp->bufaddr);
+ ep->cqe_dma[1] = (unsign16)HIWORD(rp->bufaddr);
+ return (rp);
+}
+
+ix_DoReq(mp, rp, cmd, addr, len, rpb, routine)
+ struct npmaster *mp;
+ register struct npreq *rp;
+ u_short cmd;
+ caddr_t addr;
+ int len;
+ register u_short *rpb;
+ int (*routine)();
+{
+ register struct CQE *ep = rp->element;
+ register u_short *p = &ep->rpb1;
+ u_short cnt = *rpb++;
+ extern long NpDebug;
+ int pri;
+
+ ep->cqe_ust0 = ep->cqe_ust1 = NPCLEAR; /* Clear status */
+ ep->cqe_bcnt = len; /* Byte count */
+ rp->flags = KERNREQ; /* Clear flags */
+ rp->bufaddr = (caddr_t) (UBADDRMASK & (int) addr);/* mapped buffer */
+ rp->intr = routine;
+ rp->user = (caddr_t) (ep->cqe_func = cmd);/* In case pissed on in CQE */
+ ep->cqe_dma[0] = (unsign16)LOWORD(rp->bufaddr);
+ ep->cqe_dma[1] = (unsign16)HIWORD(rp->bufaddr);
+ ep->cqe_lenrpb = cnt + cnt;
+ for (; cnt > 0; cnt--) *p++ = *rpb++;
+
+ if (NpDebug & DEBCQE)
+ printf("Function is %x ep %x reqid %x\n", ep->cqe_func, ep, ep->cqe_reqid);
+ if (NpDebug & DEBCQE)
+ printf("irp len = %x rp = %x\n", ep->cqe_lenrpb, rp);
+ if (routine == 0) {
+ NpAddReq(mp->reqtab, rp); /* Queue onto active list */
+ while (!(rp->flags & REQDONE)) {
+ pri = spl4();
+ NpAddCQE(ep, &mp->shmemp->devcq, mp);
+ sleep((caddr_t)rp, PZERO - 1);
+ splx(pri);
+ }
+ if (rp->flags & IOABORT || ep->cqe_sts != NPDONE
+ || ep->cqe_ust0 != NPDONE
+ || ep->cqe_ust1 != NPOK) {
+ struct ix_softc *ix = (struct ix_softc *)ep->cqe_famid;
+ printf("ix%d: Req failed, cmd %x, stat %x, ",
+ ix->ix_if.if_unit, rp->user, ep->cqe_sts);
+ printf("ust error %x,%x\n", ep->cqe_ust0, ep->cqe_ust1);
+ }
+ NpRemReq(rp); /* Clear request */
+ } else {
+ pri = spl4();
+ NpAddCQE(ep, &mp->shmemp->devcq, mp);
+ splx(pri);
+ }
+}
+
+/*
+ * Ethernet output routine.
+ * Encapsulate a packet of type family for the local net.
+ * Use trailer local net encapsulation if enough data in first
+ * packet leaves a multiple of 512 bytes of data in remainder.
+ */
+ixoutput(ifp, m0, dst)
+ struct ifnet *ifp;
+ struct mbuf *m0;
+ struct sockaddr *dst;
+{
+ int type, s, error;
+ u_char edst[6];
+ struct in_addr idst;
+ register struct ix_softc *ix = &ix_softc[ifp->if_unit];
+ register struct mbuf *m = m0;
+ register struct ether_header *il;
+ register int off;
+ int usetrailers;
+
+ if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
+ error = ENETDOWN;
+ goto bad;
+ }
+ switch (dst->sa_family) {
+
+#ifdef INET
+ case AF_INET:
+ idst = ((struct sockaddr_in *)dst)->sin_addr;
+ if (!arpresolve(&ix->ix_ac, m, &idst, edst, &usetrailers))
+ return (0); /* if not yet resolved */
+ off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
+ if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
+ m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
+ type = ETHERTYPE_TRAIL + (off>>9);
+ m->m_off -= 2 * sizeof (u_short);
+ m->m_len += 2 * sizeof (u_short);
+ *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
+ *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
+ goto gottrailertype;
+ }
+ type = ETHERTYPE_IP;
+ off = 0;
+ goto gottype;
+#endif
+#ifdef NS
+ case AF_NS:
+ type = ETHERTYPE_NS;
+ bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
+ (caddr_t)edst, sizeof (edst));
+ off = 0;
+ goto gottype;
+#endif
+
+ case AF_UNSPEC:
+ il = (struct ether_header *)dst->sa_data;
+ bcopy((caddr_t)il->ether_dhost, (caddr_t)edst, sizeof (edst));
+ type = il->ether_type;
+ goto gottype;
+
+ default:
+ printf("ix%d: can't handle af%d\n", ifp->if_unit,
+ dst->sa_family);
+ error = EAFNOSUPPORT;
+ goto bad;
+ }
+
+gottrailertype:
+ /*
+ * Packet to be sent as trailer: move first packet
+ * (control information) to end of chain.
+ */
+ while (m->m_next)
+ m = m->m_next;
+ m->m_next = m0;
+ m = m0->m_next;
+ m0->m_next = 0;
+ m0 = m;
+
+gottype:
+ /*
+ * Add local net header. If no space in first mbuf,
+ * allocate another.
+ */
+ if (m->m_off > MMAXOFF ||
+ MMINOFF + sizeof (struct ether_header) > m->m_off) {
+ m = m_get(M_DONTWAIT, MT_HEADER);
+ if (m == 0) {
+ error = ENOBUFS;
+ goto bad;
+ }
+ m->m_next = m0;
+ m->m_off = MMINOFF;
+ m->m_len = sizeof (struct ether_header);
+ } else {
+ m->m_off -= sizeof (struct ether_header);
+ m->m_len += sizeof (struct ether_header);
+ }
+ il = mtod(m, struct ether_header *);
+ il->ether_type = htons((u_short)type);
+ bcopy((caddr_t)edst, (caddr_t)il->ether_dhost, sizeof (edst));
+ bcopy((caddr_t)ix->ix_addr, (caddr_t)il->ether_shost,
+ sizeof(il->ether_shost));
+
+ /*
+ * Queue message on interface, and start output if interface
+ * not yet active.
+ */
+ s = splimp();
+ if (IF_QFULL(&ifp->if_snd)) {
+ IF_DROP(&ifp->if_snd);
+ splx(s);
+ m_freem(m);
+ return (ENOBUFS);
+ }
+ IF_ENQUEUE(&ifp->if_snd, m);
+ if ((ix->ix_flags & IXF_OACTIVE) == 0)
+ ixstart(ifp->if_unit);
+ splx(s);
+ return (0);
+
+bad:
+ m_freem(m0);
+ return (error);
+}
+/*
+ * Reset of interface after UNIBUS reset.
+ * If interface is on specified uba, reset its state.
+ */
+ixreset(unit, uban, softp)
+ int unit, uban;
+ caddr_t softp;
+{
+ register struct uba_device *ui;
+ int mask = IXF_SETADDR; /* Only remember new physaddr */
+
+ if (unit >= NNP || (ui = npdinfo[unit]) == 0 || ui->ui_alive == 0 ||
+ ui->ui_ubanum != uban)
+ return;
+ printf(" ix%d reset", unit);
+ if (softp)
+ mask |= IXF_GOTUBA; /* UBA mapping regs still valid; */
+ ix_softc[unit].ix_if.if_flags &= ~IFF_RUNNING;
+ ix_softc[unit].ix_flags &= mask;
+}
+
+
+/*
+ * Initialization of interface; clear recorded pending
+ * operations, and reinitialize UNIBUS usage.
+ */
+ixinit(unit)
+ int unit;
+{
+ register struct ix_softc *ix = &ix_softc[unit];
+ struct uba_device *ui = npdinfo[unit];
+ register struct ifnet *ifp = &ix->ix_if;
+ register struct CQE *ep;
+ struct npreq *rp;
+ struct npmaster *mp = ix->ix_mp;
+ register u_short *dpmp = & mp->shmemp->statblock.sb_dpm;
+ u_short rpb[7];
+ int s;
+
+ /* not yet, if address still unknown */
+ if (ifp->if_addrlist == (struct ifaddr *)0)
+ return;
+ if (ix->ix_flags & IXF_RUNNING)
+ return;
+ if ((mp->flags & AVAILABLE) == 0 || (*dpmp & PROTOMASK(NPDLA)) == 0) {
+ ifp->if_flags &= ~IFF_UP;
+ return;
+ }
+ if ((ix->ix_flags & IXF_GOTUBA) == 0) {
+ ix->ix_ifuba.ifu_flags = UBA_CANTWAIT;
+ if (if_ubainit(&ix->ix_ifuba, ui->ui_ubanum,
+ sizeof (struct ether_header), (int)btoc(ETHERMTU)) == 0) {
+ printf("ix%d: can't initialize\n", unit);
+ ix->ix_if.if_flags &= ~IFF_UP;
+ return;
+ }
+ ix->ix_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&ix->ix_stats,
+ sizeof (union ix_stats), 0);
+ ix->ix_flags |= IXF_GOTUBA;
+ }
+ if ((ix->ix_flags & IXF_GOTCQE) == 0) {
+ ix->ix_rrp = ix_GetReq(mp, ix->ix_ifuba.ifu_r.ifrw_info,
+ ETHERMTU);
+ ix->ix_wrp = ix_GetReq(mp, 0, 0);
+ ix->ix_flags |= IXF_GOTCQE;
+ }
+
+ rp = ix->ix_wrp;
+ ep = rp->element;
+
+ /* Changing the ethernet address resets the dla module,
+ so must do it before opening the channel */
+ if (ix->ix_flags & IXF_SETADDR) {
+ register char *cp = (char *) &ix->ix_stats;
+ int spincount;
+ int x;
+ *cp++ = 1;
+ bcopy(ix->ix_addr, (caddr_t)cp, 6);
+ rpb[0] = 1; /* RPB length */
+ ix_DoReq(mp, rp, IXC_LDPA, ix->ix_ubaddr, 7, rpb, 0);
+#ifndef TheyFinallyFixedTheBoard
+ /* Board requires some time to reinitialize its protocols */
+ x = spl1();
+ spincount = 2000000;
+ while (((*dpmp & PROTOMASK(NPDLA))==0) && spincount > 0)
+ spincount--;
+ if (spincount==0) {
+ printf("ix%d: failed to reinitialize DLA module\n",
+ unit);
+ splx(x);
+ }
+ splx(x);
+#endif
+ }
+ rpb[0] = 6; /* RPB length */
+ rpb[2] = 0x10; /* Share with any smart users */
+ rpb[3] = 0; /* Take (a copy of) all frames */
+ rpb[5] = 8; /* On board rcv queue length */
+ rpb[6] = 0; /* XMT packets as is */
+ ix_DoReq(mp, rp, IXC_OPEN, 0, 0, rpb, 0);
+
+ ix->ix_aid = ep->rpb1;
+
+ /* Here we request our ethernet address, if we didn't reset it*/
+ if ((ix->ix_flags & IXF_SETADDR)==0) {
+ rpb[0] = 2;
+ rpb[1] = ix->ix_aid;
+ rpb[2] = 0; /* get all stats */
+ ix_DoReq(mp, rp, IXC_GSTAT, /* Get Stats */
+ (caddr_t) ix->ix_ubaddr, sizeof(ix->ix_stats) - 8,
+ rpb, 0);
+ bcopy((caddr_t) &ix->ix_stats, (caddr_t) ix->ix_addr, 6);
+ }
+ ix->ix_if.if_flags |= IFF_RUNNING;
+ ix->ix_flags |= IXF_RUNNING;
+ ifp->if_watchdog = ixwatch;
+ ifp->if_timer = ix->ix_scaninterval = IXWATCHINTERVAL;
+ ixrint(mp, 0);
+}
+
+/*
+ * Start output on interface.
+ * Get another datagram to send off of the interface queue,
+ * and map it to the interface before starting the output.
+ */
+ixstart(dev)
+dev_t dev;
+{
+ int len = 0;
+ int unit = minor(dev);
+ register struct ix_softc *ix = &ix_softc[unit];
+ register struct mbuf *n;
+ struct mbuf *m;
+ int s, error = 0;
+ struct npmaster *mp = ix->ix_mp;
+ struct npreq *rp = ix->ix_wrp;
+ struct CQE *ep;
+ u_short rpb[8];
+
+ IF_DEQUEUE(&ix->ix_if.if_snd, m);
+ if (m == 0) {
+ if (ix->ix_flags & IXF_STATPENDING) {
+ ix->ix_flags |= IXF_OACTIVE;
+ rpb[0] = 2;
+ rpb[1] = ix->ix_aid;
+ rpb[2] = 0; /* get all stats */
+ ix_DoReq(mp, rp, IXC_GSTAT, /* general Stats */
+ (caddr_t) ix->ix_ubaddr, sizeof(ix->ix_stats) - 8,
+ rpb, ixcint);
+ }
+ return;
+ }
+ /*
+ * Ensure minimum packet length.
+ * This makes the safe assumtion that there are no virtual holes
+ * after the data.
+ * For security, it might be wise to zero out the added bytes,
+ * but we're mainly interested in speed at the moment.
+ */
+ len = if_wubaput(&ix->ix_ifuba, m);
+ if (len - sizeof(struct ether_header) < ETHERMIN)
+ len = ETHERMIN + sizeof(struct ether_header);
+
+ ix->ix_flags |= IXF_OACTIVE;
+
+ /* Now setup to call np driver */
+ rpb[0] = 8;
+ rpb[1] = ix->ix_aid;
+ ix_DoReq(mp, rp, IXC_XMIT, /* send frame */
+ ix->ix_ifuba.ifu_w.ifrw_info, len, rpb, ixcint);
+}
+
+/*
+ * Command done interrupt. (almost)
+ */
+ixcint(mp, rp)
+ struct npmaster *mp;
+ struct npreq *rp;
+{
+ struct CQE *ep;
+ register struct ix_softc *ix;
+ int s = splimp();
+
+ ep = rp->element;
+ ix = (struct ix_softc *)ep->cqe_famid;
+ if ((ix->ix_flags & IXF_OACTIVE) == 0) {
+ printf("ix%d: stray xmit interrupt, npreq=%x\n",
+ ix->ix_if.if_unit, rp);
+ }
+ ix->ix_flags &= ~IXF_OACTIVE;
+
+ switch (ep->cqe_func) {
+
+ case IXC_XMIT:
+ if (ep->cqe_sts == 1)
+ ix->ix_if.if_opackets++;
+ else
+ ix->ix_if.if_oerrors++;
+ break;
+
+ case IXC_GSTAT:
+ if (ep->cqe_sts == 1)
+ ix->ix_if.if_collisions = ix->ix_stats.ixg.macg_xrty;
+ break;
+ }
+ if (ix->ix_ifuba.ifu_xtofree) {
+ m_freem(ix->ix_ifuba.ifu_xtofree);
+ ix->ix_ifuba.ifu_xtofree = 0;
+ }
+done:
+ ixstart(ix->ix_if.if_unit);
+ splx(s);
+}
+
+/*
+ * Ethernet interface receiver interrupt.
+ * If input error just drop packet.
+ * Otherwise purge input buffered data path and examine
+ * packet to determine type. If can't determine length
+ * from type, then have to drop packet. Othewise decapsulate
+ * packet based on type and pass to type specific higher-level
+ * input routine.
+ */
+ixrint(mp, rp)
+ struct npmaster *mp;
+ struct npreq *rp;
+{
+ struct CQE *ep;
+ register struct ix_softc *ix = ix_softc + mp->unit;
+ register struct ether_header *il;
+ struct mbuf *m;
+ int len, off, resid, s;
+ register struct ifqueue *inq;
+
+ if ((ix->ix_flags & IXF_RUNNING) == 0)
+ return;
+ if (rp == 0)
+ goto setup;
+ ix->ix_flags &= ~IXF_RCVPENDING;
+ ep = rp->element;
+ ix->ix_if.if_ipackets++;
+ if (ix->ix_ifuba.ifu_flags & UBA_NEEDBDP)
+ UBAPURGE(ix->ix_ifuba.ifu_uba, ix->ix_ifuba.ifu_r.ifrw_bdp);
+ il = (struct ether_header *)(ix->ix_ifuba.ifu_r.ifrw_addr);
+ len = ep->cqe_bcnt - sizeof (struct ether_header);
+ if (ep->cqe_sts != NPDONE
+ || ep->cqe_ust0 != NPDONE
+ || ep->cqe_ust1 != NPOK) {
+ printf("ixrint: cqe error %x, %x, %x\n",
+ ep->cqe_sts, ep->cqe_ust0, ep->cqe_ust1);
+ if (++ix->ix_badcqe > 100) {
+ ix->ix_badcqe = 0;
+ printf("ixrint: shutting down unix dla\n");
+ ix->ix_if.if_flags &= ~IFF_UP;
+ return;
+ }
+ goto setup;
+ }
+
+ if ( len < 46 || len > ETHERMTU) {
+ ix->ix_if.if_ierrors++;
+#ifdef notdef
+ if (ix->ix_if.if_ierrors % 100 == 0)
+ printf("ix%d: += 100 input errors\n", unit);
+#endif
+ goto setup;
+ }
+
+ /*
+ * Deal with trailer protocol: if type is trailer type
+ * get true type from first 16-bit word past data.
+ * Remember that type was trailer by setting off.
+ */
+ il->ether_type = ntohs((u_short)il->ether_type);
+#define ildataaddr(il, off, type) ((type)(((caddr_t)((il)+1)+(off))))
+ if (il->ether_type >= ETHERTYPE_TRAIL &&
+ il->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
+ off = (il->ether_type - ETHERTYPE_TRAIL) * 512;
+ if (off >= ETHERMTU)
+ goto setup; /* sanity */
+ il->ether_type = ntohs(*ildataaddr(il, off, u_short *));
+ resid = ntohs(*(ildataaddr(il, off+2, u_short *)));
+ if (off + resid > len)
+ goto setup; /* sanity */
+ len = off + resid;
+ } else
+ off = 0;
+ if (len == 0)
+ goto setup;
+
+ /*
+ * Pull packet off interface. Off is nonzero if packet
+ * has trailing header; ilget will then force this header
+ * information to be at the front, but we still have to drop
+ * the type and length which are at the front of any trailer data.
+ */
+ m = if_rubaget(&ix->ix_ifuba, len, off, &ix->ix_if);
+ if (m == 0)
+ goto setup;
+ if (off) {
+ struct ifnet *ifp;
+
+ ifp = *(mtod(m, struct ifnet **));
+ m->m_off += 2 * sizeof (u_short);
+ m->m_len -= 2 * sizeof (u_short);
+ *(mtod(m, struct ifnet **)) = ifp;
+ }
+ switch (il->ether_type) {
+
+#ifdef INET
+ case ETHERTYPE_IP:
+ schednetisr(NETISR_IP);
+ inq = &ipintrq;
+ break;
+
+ case ETHERTYPE_ARP:
+ arpinput(&ix->ix_ac, m);
+ goto setup;
+#endif
+#ifdef NS
+ case ETHERTYPE_NS:
+ schednetisr(NETISR_NS);
+ inq = &nsintrq;
+ break;
+
+#endif
+ default:
+ m_freem(m);
+ goto setup;
+ }
+
+ s = splimp();
+ if (IF_QFULL(inq)) {
+ IF_DROP(inq);
+ m_freem(m);
+ } else
+ IF_ENQUEUE(inq, m);
+ splx(s);
+
+setup:
+ /*
+ * Reset for next packet if possible.
+ * If waiting for transmit command completion, set flag
+ * and wait until command completes.
+ */
+ if (rp == 0) {
+ rp = ix->ix_rrp;
+ rp->intr = ixrint;
+ ep = rp->element;
+ }
+ len = ETHERMTU + sizeof(struct ether_header);
+
+ /* Now setup to call np driver */
+ /* Initializations of request structure */
+
+ ep->cqe_func = IXC_RECV; /* get frame */
+ ep->cqe_ust0 = ep->cqe_ust1 = NPCLEAR; /* Clear status */
+ ep->cqe_bcnt = len; /* Byte count */
+ ep->cqe_lenrpb = 10; /* RPB length */
+ ep->rpb1 = ix->ix_aid; /* which channel */
+ ep->rpb2 = 65535; /* Timeout */
+
+ ix->ix_flags |= IXF_RCVPENDING;
+
+ s = spl4();
+ NpAddCQE(ep, &mp->shmemp->devcq, mp); /* Add CQE to device's queue */
+ splx(s);
+}
+
+
+/*
+ * Watchdog routine, request statistics from board.
+ */
+ixwatch(unit)
+ int unit;
+{
+ register struct ix_softc *ix = &ix_softc[unit];
+ register struct ifnet *ifp = &ix->ix_if;
+ int s;
+
+ if (ix->ix_flags & IXF_STATPENDING) {
+ ifp->if_timer = ix->ix_scaninterval;
+ return;
+ }
+ s = splimp();
+ ix->ix_flags |= IXF_STATPENDING;
+ if ((ix->ix_flags & IXF_OACTIVE) == 0)
+ ixstart(ifp->if_unit);
+ splx(s);
+ ifp->if_timer = ix->ix_scaninterval;
+}
+/*
+ * Process an ioctl request.
+ */
+ixioctl(ifp, cmd, data)
+ register struct ifnet *ifp;
+ int cmd;
+ caddr_t data;
+{
+ register struct ifaddr *ifa = (struct ifaddr *)data;
+ register struct ix_softc *ix = &ix_softc[ifp->if_unit];
+ int s = splimp(), error = 0;
+
+ switch (cmd) {
+
+ case SIOCSIFADDR:
+ ifp->if_flags |= IFF_UP;
+ ixinit(ifp->if_unit);
+ if ((ifp->if_flags & IFF_UP) == 0)
+ return (EBUSY);
+
+ switch (ifa->ifa_addr.sa_family) {
+#ifdef INET
+ case AF_INET:
+ ((struct arpcom *)ifp)->ac_ipaddr =
+ IA_SIN(ifa)->sin_addr;
+ arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
+ break;
+#endif
+#ifdef NS
+ case AF_NS:
+ {
+ register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
+
+ if (ns_nullhost(*ina)) {
+ ina->x_host = * (union ns_host *)
+ (ix_softc[ifp->if_unit].ix_addr);
+ } else {
+ return
+ ix_setaddr(ina->x_host.c_host, ifp->if_unit);
+ }
+ break;
+ }
+#endif
+ }
+ break;
+
+ case SIOCSIFFLAGS:
+ if ((ifp->if_flags & IFF_UP) == 0 &&
+ ix->ix_flags & IXF_RUNNING) {
+ ix->ix_flags &= ~IXF_RUNNING;
+ NpReset(ix->ix_mp, 0);
+ } else if (ifp->if_flags & IFF_UP &&
+ (ix->ix_flags & IXF_RUNNING) == 0)
+ ixinit(ifp->if_unit);
+ break;
+
+ default:
+ error = EINVAL;
+ }
+ splx(s);
+ return (error);
+}
+
+/*
+ * set ethernet address for unit
+ */
+ix_setaddr(physaddr, unit)
+u_char *physaddr;
+int unit;
+{
+ register struct ix_softc *ix = &ix_softc[unit];
+
+ if (! (ix->ix_flags & IXF_RUNNING))
+ return (EBUSY);
+
+ /* The following is a big cop out due to the fact that
+ Changing the ethernet address resets the dla module,
+ so must re-open the channel, anyway. */
+
+
+ bcopy((caddr_t)physaddr, (caddr_t)ix->ix_addr, sizeof ix->ix_addr);
+ ix->ix_flags &= ~IXF_RUNNING;
+ ix->ix_flags |= IXF_SETADDR;
+ ixinit(unit);
+ NpKill(ix->ix_mp, ix->ix_rrp);
+}
+#endif
projects / unix-history / commitdiff