projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BSD 4_2 release
[unix-history] / usr / src / sys / vaxif / if_il.c
/* if_il.c 6.2 83/09/24 */
#include "il.h"
/*
* Interlan Ethernet Communications Controller interface
*/
#include "../machine/pte.h"
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/mbuf.h"
#include "../h/buf.h"
#include "../h/protosw.h"
#include "../h/socket.h"
#include "../h/vmmac.h"
#include "../h/ioctl.h"
#include "../h/errno.h"
#include "../net/if.h"
#include "../net/netisr.h"
#include "../net/route.h"
#include "../netinet/in.h"
#include "../netinet/in_systm.h"
#include "../netinet/ip.h"
#include "../netinet/ip_var.h"
#include "../netinet/if_ether.h"
#include "../netpup/pup.h"
#include "../vax/cpu.h"
#include "../vax/mtpr.h"
#include "../vaxif/if_il.h"
#include "../vaxif/if_ilreg.h"
#include "../vaxif/if_uba.h"
#include "../vaxuba/ubareg.h"
#include "../vaxuba/ubavar.h"
int ilprobe(), ilattach(), ilrint(), ilcint();
struct uba_device *ilinfo[NIL];
u_short ilstd[] = { 0 };
struct uba_driver ildriver =
{ ilprobe, 0, ilattach, 0, ilstd, "il", ilinfo };
#define ILUNIT(x) minor(x)
int ilinit(),iloutput(),ilioctl(),ilreset(),ilwatch();
/*
* Ethernet software status per interface.
*
* Each interface is referenced by a network interface structure,
* is_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 il_softc {
struct arpcom is_ac; /* Ethernet common part */
#define is_if is_ac.ac_if /* network-visible interface */
#define is_addr is_ac.ac_enaddr /* hardware Ethernet address */
struct ifuba is_ifuba; /* UNIBUS resources */
int is_flags;
#define ILF_OACTIVE 0x1 /* output is active */
#define ILF_RCVPENDING 0x2 /* start rcv in ilcint */
#define ILF_STATPENDING 0x4 /* stat cmd pending */
short is_lastcmd; /* can't read csr, so must save it */
short is_scaninterval; /* interval of stat collection */
#define ILWATCHINTERVAL 60 /* once every 60 seconds */
struct il_stats is_stats; /* holds on-board statistics */
struct il_stats is_sum; /* summation over time */
int is_ubaddr; /* mapping registers of is_stats */
} il_softc[NIL];
ilprobe(reg)
caddr_t reg;
{
register int br, cvec; /* r11, r10 value-result */
register struct ildevice *addr = (struct ildevice *)reg;
register i;
#ifdef lint
br = 0; cvec = br; br = cvec;
i = 0; ilrint(i); ilcint(i); ilwatch(i);
#endif
addr->il_csr = ILC_OFFLINE|IL_CIE;
DELAY(100000);
i = addr->il_csr; /* clear CDONE */
if (cvec > 0 && cvec != 0x200)
cvec -= 4;
return (1);
}
/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets. A STATUS command is done to get the ethernet
* address and other interesting data.
*/
ilattach(ui)
struct uba_device *ui;
{
register struct il_softc *is = &il_softc[ui->ui_unit];
register struct ifnet *ifp = &is->is_if;
register struct ildevice *addr = (struct ildevice *)ui->ui_addr;
struct sockaddr_in *sin;
ifp->if_unit = ui->ui_unit;
ifp->if_name = "il";
ifp->if_mtu = ETHERMTU;
/*
* Reset the board and map the statistics
* buffer onto the Unibus.
*/
addr->il_csr = ILC_RESET;
while ((addr->il_csr&IL_CDONE) == 0)
;
if (addr->il_csr&IL_STATUS)
printf("il%d: reset failed, csr=%b\n", ui->ui_unit,
addr->il_csr, IL_BITS);
is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats,
sizeof (struct il_stats), 0);
addr->il_bar = is->is_ubaddr & 0xffff;
addr->il_bcr = sizeof (struct il_stats);
addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT;
while ((addr->il_csr&IL_CDONE) == 0)
;
if (addr->il_csr&IL_STATUS)
printf("il%d: status failed, csr=%b\n", ui->ui_unit,
addr->il_csr, IL_BITS);
ubarelse(ui->ui_ubanum, &is->is_ubaddr);
#ifdef notdef
printf("il%d: addr=%x:%x:%x:%x:%x:%x module=%s firmware=%s\n",
ui->ui_unit,
is->is_stats.ils_addr[0]&0xff, is->is_stats.ils_addr[1]&0xff,
is->is_stats.ils_addr[2]&0xff, is->is_stats.ils_addr[3]&0xff,
is->is_stats.ils_addr[4]&0xff, is->is_stats.ils_addr[5]&0xff,
is->is_stats.ils_module, is->is_stats.ils_firmware);
#endif
bcopy((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr,
sizeof (is->is_addr));
sin = (struct sockaddr_in *)&ifp->if_addr;
sin->sin_family = AF_INET;
sin->sin_addr = arpmyaddr((struct arpcom *)0);
ifp->if_init = ilinit;
ifp->if_output = iloutput;
ifp->if_ioctl = ilioctl;
ifp->if_reset = ilreset;
is->is_ifuba.ifu_flags = UBA_CANTWAIT;
#ifdef notdef
is->is_ifuba.ifu_flags |= UBA_NEEDBDP;
#endif
if_attach(ifp);
}
/*
* Reset of interface after UNIBUS reset.
* If interface is on specified uba, reset its state.
*/
ilreset(unit, uban)
int unit, uban;
{
register struct uba_device *ui;
if (unit >= NIL || (ui = ilinfo[unit]) == 0 || ui->ui_alive == 0 ||
ui->ui_ubanum != uban)
return;
printf(" il%d", unit);
ilinit(unit);
}
/*
* Initialization of interface; clear recorded pending
* operations, and reinitialize UNIBUS usage.
*/
ilinit(unit)
int unit;
{
register struct il_softc *is = &il_softc[unit];
register struct uba_device *ui = ilinfo[unit];
register struct ildevice *addr;
register struct ifnet *ifp = &is->is_if;
register struct sockaddr_in *sin;
int s;
sin = (struct sockaddr_in *)&ifp->if_addr;
if (sin->sin_addr.s_addr == 0) /* address still unknown */
return;
if (ifp->if_flags & IFF_RUNNING)
goto justarp;
if (if_ubainit(&is->is_ifuba, ui->ui_ubanum,
sizeof (struct il_rheader), (int)btoc(ETHERMTU)) == 0) {
printf("il%d: can't initialize\n", unit);
is->is_if.if_flags &= ~IFF_UP;
return;
}
is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats,
sizeof (struct il_stats), 0);
ifp->if_watchdog = ilwatch;
is->is_scaninterval = ILWATCHINTERVAL;
ifp->if_timer = is->is_scaninterval;
addr = (struct ildevice *)ui->ui_addr;
/*
* Turn off source address insertion (it's faster this way),
* and set board online. Former doesn't work if board is
* already online (happens on ubareset), so we put it offline
* first.
*/
s = splimp();
addr->il_csr = ILC_OFFLINE;
while ((addr->il_csr & IL_CDONE) == 0)
;
addr->il_csr = ILC_CISA;
while ((addr->il_csr & IL_CDONE) == 0)
;
/*
* Set board online.
* Hang receive buffer and start any pending
* writes by faking a transmit complete.
* Receive bcr is not a muliple of 4 so buffer
* chaining can't happen.
*/
addr->il_csr = ILC_ONLINE;
while ((addr->il_csr & IL_CDONE) == 0)
;
addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
addr->il_csr =
((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
while ((addr->il_csr & IL_CDONE) == 0)
;
is->is_flags = ILF_OACTIVE;
is->is_if.if_flags |= IFF_UP|IFF_RUNNING;
is->is_lastcmd = 0;
ilcint(unit);
splx(s);
justarp:
if_rtinit(&is->is_if, RTF_UP);
arpattach(&is->is_ac);
arpwhohas(&is->is_ac, &sin->sin_addr);
}
/*
* Start output on interface.
* Get another datagram to send off of the interface queue,
* and map it to the interface before starting the output.
*/
ilstart(dev)
dev_t dev;
{
int unit = ILUNIT(dev), len;
struct uba_device *ui = ilinfo[unit];
register struct il_softc *is = &il_softc[unit];
register struct ildevice *addr;
struct mbuf *m;
short csr;
IF_DEQUEUE(&is->is_if.if_snd, m);
addr = (struct ildevice *)ui->ui_addr;
if (m == 0) {
if ((is->is_flags & ILF_STATPENDING) == 0)
return;
addr->il_bar = is->is_ubaddr & 0xffff;
addr->il_bcr = sizeof (struct il_stats);
csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT|IL_RIE|IL_CIE;
is->is_flags &= ~ILF_STATPENDING;
goto startcmd;
}
len = if_wubaput(&is->is_ifuba, m);
/*
* 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.
*/
if (len - sizeof(struct ether_header) < ETHERMIN)
len = ETHERMIN + sizeof(struct ether_header);
if (is->is_ifuba.ifu_flags & UBA_NEEDBDP)
UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_w.ifrw_bdp);
addr->il_bar = is->is_ifuba.ifu_w.ifrw_info & 0xffff;
addr->il_bcr = len;
csr =
((is->is_ifuba.ifu_w.ifrw_info >> 2) & IL_EUA)|ILC_XMIT|IL_CIE|IL_RIE;
startcmd:
is->is_lastcmd = csr & IL_CMD;
addr->il_csr = csr;
is->is_flags |= ILF_OACTIVE;
}
/*
* Command done interrupt.
*/
ilcint(unit)
int unit;
{
register struct il_softc *is = &il_softc[unit];
struct uba_device *ui = ilinfo[unit];
register struct ildevice *addr = (struct ildevice *)ui->ui_addr;
short csr;
if ((is->is_flags & ILF_OACTIVE) == 0) {
printf("il%d: stray xmit interrupt, csr=%b\n", unit,
addr->il_csr, IL_BITS);
return;
}
csr = addr->il_csr;
/*
* Hang receive buffer if it couldn't
* be done earlier (in ilrint).
*/
if (is->is_flags & ILF_RCVPENDING) {
addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
addr->il_csr =
((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
while ((addr->il_csr & IL_CDONE) == 0)
;
is->is_flags &= ~ILF_RCVPENDING;
}
is->is_flags &= ~ILF_OACTIVE;
csr &= IL_STATUS;
switch (is->is_lastcmd) {
case ILC_XMIT:
is->is_if.if_opackets++;
if (csr > ILERR_RETRIES)
is->is_if.if_oerrors++;
break;
case ILC_STAT:
if (csr == ILERR_SUCCESS)
iltotal(is);
break;
}
if (is->is_ifuba.ifu_xtofree) {
m_freem(is->is_ifuba.ifu_xtofree);
is->is_ifuba.ifu_xtofree = 0;
}
ilstart(unit);
}
/*
* 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.
*/
ilrint(unit)
int unit;
{
register struct il_softc *is = &il_softc[unit];
struct ildevice *addr = (struct ildevice *)ilinfo[unit]->ui_addr;
register struct il_rheader *il;
struct mbuf *m;
int len, off, resid;
register struct ifqueue *inq;
is->is_if.if_ipackets++;
if (is->is_ifuba.ifu_flags & UBA_NEEDBDP)
UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_r.ifrw_bdp);
il = (struct il_rheader *)(is->is_ifuba.ifu_r.ifrw_addr);
len = il->ilr_length - sizeof(struct il_rheader);
if ((il->ilr_status&(ILFSTAT_A|ILFSTAT_C)) || len < 46 ||
len > ETHERMTU) {
is->is_if.if_ierrors++;
#ifdef notdef
if (is->is_if.if_ierrors % 100 == 0)
printf("il%d: += 100 input errors\n", unit);
#endif
goto setup;
}
/*
* Deal with trailer protocol: if type is PUP trailer
* get true type from first 16-bit word past data.
* Remember that type was trailer by setting off.
*/
il->ilr_type = ntohs((u_short)il->ilr_type);
#define ildataaddr(il, off, type) ((type)(((caddr_t)((il)+1)+(off))))
if (il->ilr_type >= ETHERPUP_TRAIL &&
il->ilr_type < ETHERPUP_TRAIL+ETHERPUP_NTRAILER) {
off = (il->ilr_type - ETHERPUP_TRAIL) * 512;
if (off >= ETHERMTU)
goto setup; /* sanity */
il->ilr_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(&is->is_ifuba, len, off);
if (m == 0)
goto setup;
if (off) {
m->m_off += 2 * sizeof (u_short);
m->m_len -= 2 * sizeof (u_short);
}
switch (il->ilr_type) {
#ifdef INET
case ETHERPUP_IPTYPE:
schednetisr(NETISR_IP);
inq = &ipintrq;
break;
case ETHERPUP_ARPTYPE:
arpinput(&is->is_ac, m);
goto setup;
#endif
default:
m_freem(m);
goto setup;
}
if (IF_QFULL(inq)) {
IF_DROP(inq);
m_freem(m);
goto setup;
}
IF_ENQUEUE(inq, m);
setup:
/*
* Reset for next packet if possible.
* If waiting for transmit command completion, set flag
* and wait until command completes.
*/
if (is->is_flags & ILF_OACTIVE) {
is->is_flags |= ILF_RCVPENDING;
return;
}
addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
addr->il_csr =
((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
while ((addr->il_csr & IL_CDONE) == 0)
;
}
/*
* 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.
*/
iloutput(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 il_softc *is = &il_softc[ifp->if_unit];
register struct mbuf *m = m0;
register struct ether_header *il;
register int off;
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
idst = ((struct sockaddr_in *)dst)->sin_addr;
if (!arpresolve(&is->is_ac, m, &idst, edst))
return (0); /* if not yet resolved */
off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
/* need per host negotiation */
if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
if (off > 0 && (off & 0x1ff) == 0 &&
m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
type = ETHERPUP_TRAIL + (off>>9);
m->m_off -= 2 * sizeof (u_short);
m->m_len += 2 * sizeof (u_short);
*mtod(m, u_short *) = htons((u_short)ETHERPUP_IPTYPE);
*(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
goto gottrailertype;
}
type = ETHERPUP_IPTYPE;
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("il%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)is->is_addr, (caddr_t)il->ether_shost, 6);
/*
* 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 ((is->is_flags & ILF_OACTIVE) == 0)
ilstart(ifp->if_unit);
splx(s);
return (0);
bad:
m_freem(m0);
return (error);
}
/*
* Watchdog routine, request statistics from board.
*/
ilwatch(unit)
int unit;
{
register struct il_softc *is = &il_softc[unit];
register struct ifnet *ifp = &is->is_if;
int s;
if (is->is_flags & ILF_STATPENDING) {
ifp->if_timer = is->is_scaninterval;
return;
}
s = splimp();
is->is_flags |= ILF_STATPENDING;
if ((is->is_flags & ILF_OACTIVE) == 0)
ilstart(ifp->if_unit);
splx(s);
ifp->if_timer = is->is_scaninterval;
}
/*
* Total up the on-board statistics.
*/
iltotal(is)
register struct il_softc *is;
{
register u_short *interval, *sum, *end;
interval = &is->is_stats.ils_frames;
sum = &is->is_sum.ils_frames;
end = is->is_sum.ils_fill2;
while (sum < end)
*sum++ += *interval++;
is->is_if.if_collisions = is->is_sum.ils_collis;
}
/*
* Process an ioctl request.
*/
ilioctl(ifp, cmd, data)
register struct ifnet *ifp;
int cmd;
caddr_t data;
{
register struct ifreq *ifr = (struct ifreq *)data;
int s = splimp(), error = 0;
switch (cmd) {
case SIOCSIFADDR:
if (ifp->if_flags & IFF_RUNNING)
if_rtinit(ifp, -1); /* delete previous route */
ilsetaddr(ifp, (struct sockaddr_in *)&ifr->ifr_addr);
ilinit(ifp->if_unit);
break;
default:
error = EINVAL;
}
splx(s);
return (error);
}
ilsetaddr(ifp, sin)
register struct ifnet *ifp;
register struct sockaddr_in *sin;
{
ifp->if_addr = *(struct sockaddr *)sin;
ifp->if_net = in_netof(sin->sin_addr);
ifp->if_host[0] = in_lnaof(sin->sin_addr);
sin = (struct sockaddr_in *)&ifp->if_broadaddr;
sin->sin_family = AF_INET;
sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY);
ifp->if_flags |= IFF_BROADCAST;
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.