2.11BSD/sys/pdpif/if_qt.c
/* @(#)if_qt.c 1.2 (2.11BSD) 2/20/93
*
* Modification History
* 23-Feb-92 -- sms
* Rewrite the buffer handling so that fewer than the maximum number of
* buffers may be used (32 receive and 12 transmit buffers consume 66+kb
* of main system memory in addition to the internal structures in the
* networking code). A freelist of available buffers is maintained now.
* When I/O operations complete the associated buffer is placed on the
* freelist (a single linked list for simplicity) and when an I/O is
* started a buffer is pulled off the list.
*
* 20-Feb-92 -- sms
* It works! Darned board couldn't handle "short" rings - those rings
* where only half the entries were made available to the board (the
* ring descriptors were the full size, merely half the entries were
* flagged as belonging always to the driver). Grrrr. Would have thought
* the board could skip over those entries reserved by the driver.
* Now to find a way not to have to allocated 32+12 times 1.5kb worth of
* buffers...
*
* 03-Feb-92 -- sms
* Released but still not working. The driver now responds to arp and
* ping requests. The board is apparently not returning ring descriptors
* to the driver so eventually we run out of buffers. Back to the
* drawing board.
*
* 28-Dec-92 -- sms
* Still not released. Hiatus in finding free time and thin-netting
* the systems (many thanks Terry!).
* Added logic to dynamically allocate a vector and initialize it.
*
* 23-Oct-92 -- sms
* The INIT block must (apparently) be quadword aligned [no thanks to
* the manual for not mentioning that fact]. The necessary alignment
* is achieved by allocating the INIT block from main memory ('malloc'
* guarantees click alignment) and mapping it as needed (which is _very_
* infrequently). A check for quadword alignment of the ring descriptors
* was added - at present the descriptors are properly aligned, if this
* should change then something will have to be done (like do it "right").
* Darned alignment restrictions!
*
* A couple of typos were corrected (missing parentheses, reversed
* arguments to printf calls, etc).
*
* 13-Oct-92 -- sms@wlv.iipo.gtegsc.com
* Created based on the DELQA-PLUS addendum to DELQA User's Guide.
* This driver ('qt') is selected at system configuration time. If the
* board * is not a DELQA-YM an error message will be printed and the
* interface will not be attached.
*/
#include "qt.h"
#if NQT > 0
#include "param.h"
#include "pdp/psl.h"
#include "pdp/seg.h"
#include "map.h"
#include "systm.h"
#include "mbuf.h"
#include "buf.h"
#include "protosw.h"
#include "socket.h"
#include "ioctl.h"
#include "errno.h"
#include "syslog.h"
#include "time.h"
#include "kernel.h"
#include "../net/if.h"
#include "../net/netisr.h"
#include "../net/route.h"
#ifdef INET
#include "domain.h"
#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 "if_qtreg.h"
#include "if_uba.h"
#include "../pdpuba/ubavar.h"
#define NRCV 16 /* Receive descriptors (must be <= 32) */
#define NXMT 6 /* Transmit descriptors (must be <= 12) */
#if NRCV > 32 || NXMT > 12
generate an error
#endif
struct qt_uba
{
struct qt_uba *next; /* link to next buffer in list or
* NULL if the last buffer
*/
struct ifuba ubabuf; /* buffer descriptor */
};
struct qt_softc {
struct arpcom is_ac; /* common part - must be first */
#define is_if is_ac.ac_if /* network-visible interface */
#define is_addr is_ac.ac_enaddr /* hardware Ethernet address */
struct qt_uba *freelist; /* list of available buffers */
struct qt_uba ifrw[NRCV + NXMT];
u_short initclick; /* click addr of the INIT block */
struct qt_rring *rring; /* Receive ring address */
struct qt_tring *tring; /* Transmit ring address */
char r_align[QT_MAX_RCV * sizeof (struct qt_rring) + 8];
char t_align[QT_MAX_XMT * sizeof (struct qt_tring) + 8];
short qt_flags; /* software state */
#define QTF_RUNNING 0x1
#define QTF_STARTUP 0x2 /* Waiting for start interrupt */
char rindex; /* Receive Completed Index */
char nxtrcv; /* Next Receive Index */
char nrcv; /* Number of Receives active */
char tindex; /* Transmit index */
char otindex; /* Old transmit index */
char nxmit; /* # of xmits in progress */
struct qtdevice *addr; /* device CSR addr */
} qt_softc[NQT];
struct uba_device *qtinfo[NQT];
int qtattach(), qtintr(), qtinit(), qtoutput(), qtioctl();
extern struct ifnet loif;
u_short qtstd[] = { 0 };
struct uba_driver qtdriver =
{ 0, 0, qtattach, 0, qtstd, "qe", qtinfo };
/*
* Maximum packet size needs to include 4 bytes for the CRC
* on received packets.
*/
#define MAXPACKETSIZE (ETHERMTU + sizeof (struct ether_header) + 4)
#define MINPACKETSIZE 64
/*
* The C compiler's propensity for prepending '_'s to names is the reason
* for the hack below. We need the "handler" address (the code which
* sets up the interrupt stack frame) in order to initialize the vector.
*/
static int qtfoo()
{
asm("mov $qtintr, r0"); /* return value is in r0 */
}
/*
* Interface exists. More accurately, something exists at the CSR (see
* sys/sys_net.c) -- there's no guarantee it's a DELQA-YM.
*
* The ring descriptors are initialized, the buffers allocated using first the
* DMA region allocated at network load time and then later main memory. The
* INIT block is filled in and the device is poked/probed to see if it really
* is a DELQA-YM. If the device is not a -YM then a message is printed and
* the 'if_attach' call is skipped. For a -YM the START command is issued,
* but the device is not marked as running|up - that happens at interrupt level
* when the device interrupts to say it has started.
*/
qtattach(ui)
struct uba_device *ui;
{
register struct qt_softc *sc = &qt_softc[ui->ui_unit];
register struct ifnet *ifp = &sc->is_if;
register struct qt_init *iniblk = (struct qt_init *)SEG5;
segm seg5;
long bufaddr;
extern int nextiv();
ifp->if_unit = ui->ui_unit;
ifp->if_name = "qe";
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST;
/*
* Fill in most of the INIT block: vector, options (interrupt enable), ring
* locations. The physical address is copied from the ROMs as part of the
* -YM testing proceedure. The CSR is saved here rather than in qtinit()
* because the qtturbo() routine needs it.
*
* The INIT block must be quadword aligned. Using malloc() guarantees click
* (64 byte) alignment. Since the only time the INIT block is referenced is
* at 'startup' or 'reset' time there is really no time penalty (and a modest
* D space savings) involved.
*/
sc->addr = (struct qtdevice *)ui->ui_addr;
sc->initclick = MALLOC(coremap, btoc(sizeof (struct qt_init)));
saveseg5(seg5);
mapseg5(sc->initclick, 077406);
bzero(iniblk, sizeof (struct qt_init));
sc->rring = (struct qt_rring *)(((int)sc->r_align + 7) & ~7);
sc->tring = (struct qt_tring *)(((int)sc->t_align + 7) & ~7);
/*
* Fetch the next available interrupt vector. The routine is in the kernel
* (for several reasons) so use SKcall. Then initialize the vector with
* the address of our 'handler' and PSW of supervisor, priority 4 and unit
*/
iniblk->vector = SKcall(nextiv, 0);
mtkd(iniblk->vector, qtfoo());
mtkd(iniblk->vector + 2, PSL_CURSUP | PSL_BR4 | ifp->if_unit);
iniblk->options = INIT_OPTIONS_INT;
bufaddr = startnet + (long)sc->rring;
iniblk->rx_lo = loint(bufaddr);
iniblk->rx_hi = hiint(bufaddr);
bufaddr = startnet + (long)sc->tring;
iniblk->tx_lo = loint(bufaddr);
iniblk->tx_hi = hiint(bufaddr);
restorseg5(seg5);
/*
* Now allocate the buffers and initialize the buffers. This should _never_
* fail because main memory is allocated after the DMA pool is used up.
*/
if (!qbaini(sc, NRCV + NXMT))
return; /* XXX */
ifp->if_init = qtinit;
ifp->if_output = qtoutput;
ifp->if_ioctl = qtioctl;
ifp->if_reset = 0;
if (qtturbo(sc))
if_attach(ifp);
}
qtturbo(sc)
register struct qt_softc *sc;
{
register int i;
register struct qtdevice *addr = sc->addr;
struct qt_init *iniblk = (struct qt_init *)SEG5;
segm seg5;
/*
* Issue the software reset. Delay 150us. The board should now be in
* DELQA-Normal mode. Set ITB and DEQTA select. If both bits do not
* stay turned on then the board is not a DELQA-YM.
*/
addr->arqr = ARQR_SR;
addr->arqr = 0;
delay(150L);
addr->srr = 0x8001; /* MS | ITB */
i = addr->srr;
addr->srr = 0x8000; /* Turn off ITB, set DELQA select */
if (i != 0x8001)
{
printf("qt@%o !-YM\n", addr);
return(0);
}
/*
* Board is a DELQA-YM. Send the commands to enable Turbo mode. Delay
* 1 second, testing the SRR register every millisecond to see if the
* board has shifted to Turbo mode.
*/
addr->xcr0 = 0x0baf;
addr->xcr1 = 0xff00;
for (i = 0; i < 1000; i++)
{
if ((addr->srr & SRR_RESP) == 1)
break;
delay(1000L);
}
if (i >= 1000)
{
printf("qt@%o !Turbo\n", addr);
return(0);
}
/*
* Board has entered Turbo mode. Now copy the physical address from the
* ROMs to the INIT block. Fill in the address in the part of the structure
* "visible" to the rest of the system.
*/
saveseg5(seg5);
mapseg5(sc->initclick, 077406);
sc->is_addr[0] = addr->sarom[0];
sc->is_addr[1] = addr->sarom[2];
sc->is_addr[2] = addr->sarom[4];
sc->is_addr[3] = addr->sarom[6];
sc->is_addr[4] = addr->sarom[8];
sc->is_addr[5] = addr->sarom[10];
bcopy(sc->is_addr, iniblk->paddr, 6);
restorseg5(seg5);
return(1);
}
qtinit(unit)
int unit;
{
int s;
register struct qt_softc *sc = &qt_softc[unit];
struct qtdevice *addr = sc->addr;
struct ifnet *ifp = &sc->is_if;
struct qt_rring *rp;
struct qt_tring *tp;
register struct qt_uba *xp;
register int i;
long buf_adr;
if (!ifp->if_addrlist) /* oops! */
return;
/*
* Now initialize the receive ring descriptors. Because this routine can be
* called with outstanding I/O operations we check the ring descriptors for
* a non-zero 'rhost0' (or 'thost0') word and place those buffers back on
* the free list.
*/
for (i = 0, rp = sc->rring; i < QT_MAX_RCV; i++, rp++)
{
rp->rmd3 = RMD3_OWN;
if (xp = rp->rhost0)
{
rp->rhost0 = 0;
xp->next = sc->freelist;
sc->freelist = xp;
}
}
for (i = 0, tp = sc->tring ; i < QT_MAX_XMT; i++, tp++)
{
sc->tring[i].tmd3 = TMD3_OWN;
if (xp = tp->thost0)
{
tp->thost0 = 0;
xp->next = sc->freelist;
sc->freelist = xp;
}
}
sc->nxmit = 0;
sc->otindex = 0;
sc->tindex = 0;
sc->rindex = 0;
sc->nxtrcv = 0;
sc->nrcv = 0;
s = splimp();
/*
* Now we tell the device the address of the INIT block. The device
* _must_ be in the Turbo mode at this time. The "START" command is
* then issued to the device. A 1 second timeout is then started.
* When the interrupt occurs the IFF_UP|IFF_RUNNING state is entered and
* full operations will proceed. If the timeout expires without an interrupt
* being received an error is printed, the flags cleared and the device left
* marked down.
*/
buf_adr = ctob((long)sc->initclick);
addr->ibal = loint(buf_adr);
addr->ibah = hiint(buf_adr);
addr->srqr = 2;
/*
* set internal state to 'startup' and start a one second timer. the interrupt
* service routine will be entered either 1) when the device posts the 'start'
* interrupt or 2) when the timer expires. The interrupt routine will fill
* the receive rings, etc.
*/
sc->qt_flags = QTF_STARTUP;
TIMEOUT(qtintr, unit, 60);
splx(s);
}
/*
* Start output on interface.
*/
qtstart(unit)
int unit;
{
int len, s;
register struct qt_softc *sc = &qt_softc[unit];
register struct qt_tring *rp;
struct mbuf *m;
long buf_addr;
register struct qt_uba *xp;
s = splimp();
while (sc->nxmit < NXMT)
{
IF_DEQUEUE(&sc->is_if.if_snd, m);
if (m == 0)
break;
rp = &sc->tring[sc->tindex];
#ifdef QTDEBUG
if ((rp->tmd3 & TMD3_OWN) == 0)
printf("qt xmit in progress\n");
#endif
/*
* Now pull a buffer off of the freelist. Guaranteed to be a buffer
* because both the receive and transmit sides limit themselves to
* NRCV and NXMT buffers respectively.
*/
xp = sc->freelist;
sc->freelist = xp->next;
buf_addr = xp->ubabuf.ifu_w.ifrw_info;
len = if_wubaput(&xp->ubabuf, m);
if (len < MINPACKETSIZE)
len = MINPACKETSIZE;
rp->tmd4 = loint(buf_addr);
rp->tmd5 = hiint(buf_addr) & TMD5_HADR;
rp->tmd3 = len & TMD3_BCT; /* set length,clear ownership */
rp->thost0 = xp; /* set entry active */
sc->addr->arqr = ARQR_TRQ; /* tell device it has buffer */
sc->nxmit++;
if (++sc->tindex >= QT_MAX_XMT)
sc->tindex = 0;
}
splx(s);
}
/*
* General interrupt service routine. Receive, transmit, device start
* interrupts and timeouts come here. Check for hard device errors and print a
* message if any errors are found. If we are waiting for the device to
* START then check if the device is now running.
*/
qtintr(unit)
int unit;
{
register struct qt_softc *sc = &qt_softc[unit];
register int status;
int s;
status = sc->addr->srr;
if (status < 0)
/* should we reset the device after a bunch of these errs? */
qtsrr(unit, status);
if (sc->qt_flags == QTF_STARTUP)
{
if ((status & SRR_RESP) == 2)
{
sc->qt_flags = QTF_RUNNING;
sc->is_if.if_flags |= (IFF_UP | IFF_RUNNING);
}
else
printf("qt%d !start\n", unit);
}
s = splimp();
qtrint(unit);
if (sc->nxmit)
qttint(unit);
qtstart(unit);
splx(s);
}
/*
* Transmit interrupt service. Only called if there are outstanding transmit
* requests which could have completed. The DELQA-YM doesn't provide the
* status bits telling the kind (receive, transmit) of interrupt.
*/
#define BBLMIS (TMD2_BBL|TMD2_MIS)
qttint(unit)
int unit;
{
register struct qt_softc *sc = &qt_softc[unit];
register struct qt_tring *rp;
register struct qt_uba *xp;
while (sc->nxmit > 0)
{
rp = &sc->tring[sc->otindex];
if ((rp->tmd3 & TMD3_OWN) == 0)
break;
/*
* Now check the buffer address (the first word in the ring descriptor
* available for the host's use). If it is NULL then we have already seen
* and processed (or never presented to the board in the first place) this
* entry and the ring descriptor should not be counted.
*/
xp = rp->thost0;
if (xp == 0)
break;
/*
* Clear the buffer address from the ring descriptor and put the
* buffer back on the freelist for future use.
*/
rp->thost0 = 0;
xp->next = sc->freelist;
sc->freelist = xp;
sc->nxmit--;
sc->is_if.if_opackets++;
/*
* Collisions don't count as output errors, but babbling and missing packets
* do count as output errors.
*/
if (rp->tmd2 & TMD2_CER)
sc->is_if.if_collisions++;
if ((rp->tmd0 & TMD0_ERR1) ||
((rp->tmd2 & TMD2_ERR2) && (rp->tmd2 & BBLMIS)))
{
#ifdef QTDEBUG
printf("qt%d tmd2 %b\n", unit, rp->tmd2, TMD2_BITS);
#endif
sc->is_if.if_oerrors++;
}
if (++sc->otindex >= QT_MAX_XMT)
sc->otindex = 0;
}
}
/*
* Receive interrupt service. Pull packet off the interface and put into
* a mbuf chain for processing later.
*/
qtrint(unit)
int unit;
{
register struct qt_softc *sc = &qt_softc[unit];
register struct qt_rring *rp;
register struct qt_uba *xp;
int len;
long bufaddr;
while (sc->rring[sc->rindex].rmd3 & RMD3_OWN)
{
rp = &sc->rring[sc->rindex];
/*
* If the host word is 0 then this is a buffer either already seen or not
* presented to the device in the first place.
*/
xp = rp->rhost0;
if (xp == 0)
break;
if ((rp->rmd0 & (RMD0_STP|RMD0_ENP)) != (RMD0_STP|RMD0_ENP))
{
printf("qt%d chained packet\n", unit);
sc->is_if.if_ierrors++;
goto rnext;
}
len = (rp->rmd1 & RMD1_MCNT) - 4; /* -4 for CRC */
sc->is_if.if_ipackets++;
if ((rp->rmd0 & RMD0_ERR3) || (rp->rmd2 & RMD2_ERR4))
{
sc->is_if.if_ierrors++;
#ifdef QTDEBUG
printf("qt%d rmd0 %b\n", unit, rp->rmd0, RMD0_BITS);
printf("qt%d rmd2 %b\n", unit, rp->rmd2, RMD2_BITS);
#endif
}
else
qtread(sc, &xp->ubabuf,
len - sizeof (struct ether_header));
rnext:
--sc->nrcv;
if (++sc->rindex >= QT_MAX_RCV)
sc->rindex = 0;
/*
* put the buffer back on the free list and clear the first host word
* in the ring descriptor so we don't process this one again.
*/
xp->next = sc->freelist;
sc->freelist = xp;
rp->rhost0 = 0;
}
while (sc->nrcv < NRCV)
{
rp = &sc->rring[sc->nxtrcv];
#ifdef QTDEBUG
if ((rp->rmd3 & RMD3_OWN) == 0)
printf("qtrint: !OWN\n");
#endif
xp = sc->freelist;
sc->freelist = xp->next;
bufaddr = xp->ubabuf.ifu_r.ifrw_info;
rp->rmd1 = MAXPACKETSIZE;
rp->rmd4 = loint(bufaddr);
rp->rmd5 = hiint(bufaddr);
rp->rhost0 = xp;
rp->rmd3 = 0; /* clear RMD3_OWN */
++sc->nrcv;
sc->addr->arqr = ARQR_RRQ; /* tell device it has buffer */
if (++sc->nxtrcv >= QT_MAX_RCV)
sc->nxtrcv = 0;
}
}
/*
* Place data on the appropriate queue and call the start routine to
* send the data to the device.
*/
qtoutput(ifp, m0, dst)
struct ifnet *ifp;
struct mbuf *m0;
struct sockaddr *dst;
{
int type, s, trail;
u_char edst[6];
struct in_addr idst;
register struct ether_header *eh;
register struct qt_softc *is = &qt_softc[ifp->if_unit];
register struct mbuf *m = m0;
struct mbuf *mcopy = (struct mbuf *)0;
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
{
m_freem(m0);
return(ENETDOWN);
}
switch (dst->sa_family)
{
#ifdef INET
case AF_INET:
idst = ((struct sockaddr_in *)dst)->sin_addr;
if (!arpresolve(&is->is_ac, m, &idst, edst,&trail))
return(0); /* wait for arp to finish */
if (!bcmp(edst, etherbroadcastaddr,sizeof (edst)))
mcopy = m_copy(m, 0, (int)M_COPYALL);
type = ETHERTYPE_IP;
break;
#endif
#ifdef NS
case AF_NS:
type = ETHERTYPE_NS;
bcopy(&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
edst, sizeof (edst));
if (!bcmp(edst, &ns_broadcast, sizeof (edst)))
return(looutput(&loif, m, dst));
break;
#endif
case AF_UNSPEC:
eh = (struct ether_header *)dst->sa_data;
bcopy(eh->ether_dhost, (caddr_t)edst, sizeof (edst));
type = eh->ether_type;
break;
default:
printf("qt%d can't handle af%d\n", ifp->if_unit,
dst->sa_family);
m_freem(m);
return(EAFNOSUPPORT);
}
/*
* 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)
{
m_freem(m0);
nobufs: if (mcopy)
m_freem(mcopy);
return(ENOBUFS);
}
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);
}
eh = mtod(m, struct ether_header *);
eh->ether_type = htons((u_short)type);
bcopy(edst, (caddr_t)eh->ether_dhost, sizeof (edst));
bcopy(is->is_addr, (caddr_t)eh->ether_shost, sizeof (is->is_addr));
s = splimp();
if (IF_QFULL(&ifp->if_snd))
{
IF_DROP(&ifp->if_snd);
m_freem(m);
splx(s);
goto nobufs;
}
IF_ENQUEUE(&ifp->if_snd, m);
qtstart(ifp->if_unit);
splx(s);
return(mcopy ? looutput(&loif, mcopy, dst) : 0);
}
qtioctl(ifp, cmd, data)
register struct ifnet *ifp;
int cmd;
caddr_t data;
{
struct qt_softc *sc = &qt_softc[ifp->if_unit];
struct ifaddr *ifa = (struct ifaddr *)data;
int s = splimp(), error = 0;
#ifdef NS
register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
#endif
switch (cmd)
{
case SIOCSIFADDR:
/*
* Resetting the board is probably overkill, but then again this is only
* done when the system comes up or possibly when a reset is needed after a
* major network fault (open wire, etc).
*/
qtrestart(sc);
switch (ifa->ifa_addr.sa_family)
{
#ifdef INET
case AF_INET:
((struct arpcom *)ifp)->ac_ipaddr =
IA_SIN(ifa)->sin_addr;
arpwhohas(ifp, &IA_SIN(ifa)->sin_addr);
break;
#endif
#ifdef NS
case AF_NS:
if (ns_nullhost(*ina))
ina->x_host =
*(union ns_host *)(sc->is_addr);
else
{
qt_ns(ina->x_host.c_host);
qtrestart(sc);
}
break;
#endif
}
break;
case SIOCSIFFLAGS:
if ((ifp->if_flags & IFF_UP) == 0 &&
sc->qt_flags & QTF_RUNNING)
{
/*
* We've been asked to stop the board and leave it that way. qtturbo()
* does this with the side effect of placing the device back in Turbo mode.
*/
qtturbo(sc);
sc->qt_flags &= ~QTF_RUNNING;
}
else if (ifp->if_flags & IFF_UP &&
!(sc->qt_flags & QTF_RUNNING))
qtrestart(sc);
break;
default:
error = EINVAL;
}
splx(s);
return(error);
}
#ifdef NS
qt_ns(cp)
register char *cp;
{
segm seg5;
register struct qt_init *iniblk = (struct qt_init *)SEG5;
saveseg5(seg5);
mapseg5(sc->initclick, 077406);
bcopy(cp, sc->is_addr, 6);
bcopy(cp, iniblk->paddr, 6);
restorseg5(seg5);
}
#endif
/*
* Pull the data off of the board and pass back to the upper layers of
* the networking code. Trailers are counted as errors and the packet
* dropped. SEG5 is saved and restored (used to peek at the packet type).
*/
qtread(sc, ifuba, len)
register struct qt_softc *sc;
struct ifuba *ifuba;
int len;
{
struct ether_header *eh;
register struct mbuf *m;
struct ifqueue *inq;
int type;
segm seg5;
saveseg5(seg5);
mapseg5(ifuba->ifu_r.ifrw_click, 077406);
eh = (struct ether_header *)SEG5;
eh->ether_type = ntohs((u_short)eh->ether_type);
type = eh->ether_type;
restorseg5(seg5);
if (len == 0 || type >= ETHERTYPE_TRAIL &&
type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER)
{
sc->is_if.if_ierrors++;
return;
}
m = if_rubaget(ifuba, len, 0, &sc->is_if);
if (m == 0)
return;
switch (type)
{
#ifdef INET
case ETHERTYPE_IP:
schednetisr(NETISR_IP);
inq = &ipintrq;
break;
case ETHERTYPE_ARP:
arpinput(&sc->is_ac, m);
return;
#endif
#ifdef NS
case ETHERTYPE_NS:
schednetisr(NETISR_NS);
inq = &nsintrq;
break;
#endif
default:
m_freem(m);
return;
}
if (IF_QFULL(inq))
{
IF_DROP(inq);
m_freem(m);
return;
}
IF_ENQUEUE(inq, m);
}
qtsrr(unit, srrbits)
int unit, srrbits;
{
printf("qt%d srr=%b\n", unit, srrbits, SRR_BITS);
}
/*
* Reset the device. This moves it from DELQA-T mode to DELQA-Normal mode.
* After the reset put the device back in -T mode. Then call qtinit() to
* reinitialize the ring structures and issue the 'timeout' for the "device
* started interrupt".
*/
qtrestart(sc)
register struct qt_softc *sc;
{
qtturbo(sc);
qtinit(sc - qt_softc);
}
qbaini(sc, num)
struct qt_softc *sc;
int num;
{
register int i;
register memaddr click;
struct qt_uba *xp;
register struct ifuba *ifuba;
for (i = 0; i < num; i++)
{
xp = &sc->ifrw[i];
ifuba = &xp->ubabuf;
click = m_ioget(MAXPACKETSIZE);
if (click == 0)
{
click = MALLOC(coremap, btoc(MAXPACKETSIZE));
if (click == 0)
return(0); /* _can't_ happen */
}
ifuba->ifu_hlen = sizeof (struct ether_header);
ifuba->ifu_w.ifrw_click = ifuba->ifu_r.ifrw_click = click;
ifuba->ifu_w.ifrw_info = ifuba->ifu_r.ifrw_info =
ctob((long)click);
xp->next = sc->freelist;
sc->freelist = xp;
}
return(1);
}
#endif