[unix-history] / usr / src / sys / vax / if / if_pcl.c

/*
 * Copyright (c) 1982, 1986 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *	@(#)if_pcl.c	7.4 (Berkeley) %G%
 */

#include "pcl.h"
#if NPCL > 0
/*
 * DEC CSS PCL-11B Parallel Communications Interface
 *
 * Written by Mike Muuss and Jeff Schwab.
 */
#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"
#endif

#include "../vax/cpu.h"
#include "../vax/mtpr.h"
#include "if_pclreg.h"
#include "if_uba.h"
#include "../vaxuba/ubareg.h"
#include "../vaxuba/ubavar.h"

/* The MTU has been carefully selected to prevent fragmentation <-> ArpaNet */
#define	PCLMTU		(1006)	/* Max transmission unit (bytes) */
#define	PCLMAXTDM	7	/* Max unit number on TDM bus */

int	pclprobe(), pclattach(), pclrint(), pclxint();
int	pclinit(), pclioctl(), pcloutput(), pclreset();

struct	uba_device	*pclinfo[NPCL];
u_short pclstd[] = { 0 };
#define	PCLUNIT(x)	minor(x)
struct	uba_driver pcldriver =
	{ pclprobe, 0, pclattach, 0, pclstd, "pcl", pclinfo };

/*
 * PCL software status per interface.
 *
 * Each interface is referenced by a network interface structure,
 * sc_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	pcl_softc {
	struct	ifnet sc_if;		/* network-visible interface */
	struct	ifuba sc_ifuba;		/* UNIBUS resources */
	short	sc_oactive;		/* is output active? */
	short	sc_olen;		/* length of last output */
	short	sc_lastdest;		/* previous destination */
	short	sc_odest;		/* current xmit destination */
	short	sc_bdest;		/* buffer's stated destination */
	short	sc_pattern;		/* identification pattern */
} pcl_softc[NPCL];

/*
 * Structure of "local header", which only goes between
 * pcloutput and pclstart.
 */
struct pcl_header {
	short	pcl_dest;		/* Destination PCL station */
};

/*
 * Do non-DMA output of 1 word to determine presence of interface,
 * and to find the interupt vector.  1 word messages are a special
 * case in the receiver routine, and will be discarded.
 */
pclprobe(reg)
	caddr_t reg;
{
	register int br, cvec;		/* r11, r10 value-result */
	register struct pcldevice *addr = (struct pcldevice *)reg;

#ifdef lint
	br = 0; cvec = br; br = cvec;
	pclrint(0); pclxint(0);
#endif
	addr->pcl_rcr = PCL_RCINIT;
	addr->pcl_tcr = PCL_TXINIT;
	addr->pcl_tsba = 0xFFFE;
	/* going for 01777776 */
	addr->pcl_tsbc = -4;		/* really short */
	addr->pcl_tcr =
	 ((1 & 0xF) << 8) | PCL_TXNPR | PCL_SNDWD | PCL_STTXM | PCL_IE | 0x0030;
	DELAY(100000);
	addr->pcl_tcr = PCL_TXINIT;
	return (sizeof (struct pcldevice));
}

/*
 * Interface exists: make available by filling in network interface
 * record.  System will initialize the interface when it is ready
 * to accept packets.
 */
pclattach(ui)
	struct uba_device *ui;
{
	register struct pcl_softc *sc = &pcl_softc[ui->ui_unit];

	sc->sc_if.if_unit = ui->ui_unit;
	sc->sc_if.if_name = "pcl";
	sc->sc_if.if_mtu = PCLMTU;
	sc->sc_if.if_init = pclinit;
	sc->sc_if.if_output = pcloutput;
	sc->sc_if.if_ioctl = pclioctl;
	sc->sc_if.if_reset = pclreset;
	sc->sc_if.if_flags = IFF_BROADCAST;
	sc->sc_ifuba.ifu_flags = UBA_NEEDBDP;
	if_attach(&sc->sc_if);
}

/*
 * Reset of interface after UNIBUS reset.
 * If interface is on specified uba, reset its state.
 */
pclreset(unit, uban)
	int unit, uban;
{
	register struct uba_device *ui;

	if (unit >= NPCL || (ui = pclinfo[unit]) == 0 || ui->ui_alive == 0 ||
	    ui->ui_ubanum != uban)
		return;
	printf(" pcl%d", unit);
	pclinit(unit);
}

/*
 * Initialization of interface; clear recorded pending
 * operations, and reinitialize UNIBUS usage.
 */
pclinit(unit)
	int unit;
{
	register struct pcl_softc *sc = &pcl_softc[unit];
	register struct uba_device *ui = pclinfo[unit];
	register struct pcldevice *addr;
	int s;

	if (sc->sc_if.if_addrlist == (struct ifaddr *)0)
		return;
	if (if_ubainit(&sc->sc_ifuba, ui->ui_ubanum, 0,
	    (int)btoc(PCLMTU)) == 0) { 
		printf("pcl%d: can't init\n", unit);
		sc->sc_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
		return;
	}
	sc->sc_if.if_flags |= IFF_RUNNING;
	addr = (struct pcldevice *)ui->ui_addr;
	addr->pcl_rcr = PCL_RCINIT;
	addr->pcl_tcr = PCL_TXINIT;

	/*
	 * Hang a receive and start any
	 * pending writes by faking a transmit complete.
	 */
	s = splimp();
	addr->pcl_rdba = (short) sc->sc_ifuba.ifu_r.ifrw_info;
	addr->pcl_rdbc = -PCLMTU;
	addr->pcl_rcr = (((int)(sc->sc_ifuba.ifu_r.ifrw_info>>12))&0x0030) |
		PCL_RCNPR | PCL_RCVWD | PCL_RCVDAT | PCL_IE;
	sc->sc_oactive = 0;
	pclstart(unit);
	splx(s);
}

/*
 * PCL output routine.
 */
pcloutput(ifp, m, dst)
	struct ifnet *ifp;
	struct mbuf *m;
	struct sockaddr *dst;
{
	int dest, s, error;
	struct pcl_header *pclp;
	struct mbuf *m2;

	switch (dst->sa_family) {

#ifdef INET
	case AF_INET:
		if (in_broadcast(((struct sockaddr_in *)dst)->sin_addr))
			dest = 0;
		else
			dest = in_lnaof(((struct sockaddr_in *)dst)->sin_addr);
		if (dest > PCLMAXTDM) {
			error = EHOSTUNREACH;
			goto bad;
		}
		break;
#endif
	default:
		printf("pcl%d: can't handle af%d\n", ifp->if_unit,
			dst->sa_family);
		error = EAFNOSUPPORT;
		goto bad;
	}

	/*
	 * Add pseudo local net header.
	 * Actually, it does not get transmitted, but merely stripped
	 * off and used by the START routine to route the packet.
	 * If no space in first mbuf, allocate another.
	 */
	M_PREPEND(m, sizeof(struct pcl_header), M_DONTWAIT);
	if (m == 0) {
		error = ENOBUFS;
		goto bad;
	}
	pclp = mtod(m, struct pcl_header *);
	pclp->pcl_dest = dest;

	/*
	 * 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);
		error = ENOBUFS;
		goto qfull;
	}
	IF_ENQUEUE(&ifp->if_snd, m);
	if (pcl_softc[ifp->if_unit].sc_oactive == 0)
		pclstart(ifp->if_unit);
	splx(s);
	return (0);
qfull:
	splx(s);
bad:
	m_freem(m);
	return (error);
}

/*
 * Start or restart output on interface.
 * If interface is already active, then this is a retransmit.
 * If interface is not already active, get another datagram
 * to send off of the interface queue, and map it to the interface
 * before starting the output.
 */
pclstart(dev)
	dev_t dev;
{
        int unit = PCLUNIT(dev);
	struct uba_device *ui = pclinfo[unit];
	register struct pcl_softc *sc = &pcl_softc[unit];
	register struct pcldevice *addr;
	struct mbuf *m;

	if (sc->sc_oactive)
		goto restart;

	/*
	 * Not already active: dequeue another request
	 * and map it to the UNIBUS.  If no more requests,
	 * just return.
	 */
	IF_DEQUEUE(&sc->sc_if.if_snd, m);
	if (m == 0) {
		sc->sc_oactive = 0;
		return;
	}

	/*
	 * Pull destination node out of pseudo-local net header.
	 * remove it from outbound data.
	 * Note that if_wubaput calls m_bcopy, which is prepared for
	 * m_len to be 0 in the first mbuf in the chain.
	 */
	sc->sc_bdest = mtod(m, struct pcl_header *)->pcl_dest;
	sc->sc_odest = sc->sc_bdest? sc->sc_bdest: 1;
	m->m_data += sizeof (struct pcl_header);
	m->m_len -= sizeof (struct pcl_header);
	if (m->m_flags & M_PKTHDR)
		m->m_pkthdr.len -= sizeof (struct pcl_header);

	/* Map out to the DMA area */
	sc->sc_olen = if_wubaput(&sc->sc_ifuba, m);

restart:
	/*
	 * Have request mapped to UNIBUS for transmission.
	 * Purge any stale data from this BDP, and start the output.
	 */
	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
		UBAPURGE(sc->sc_ifuba.ifu_uba, sc->sc_ifuba.ifu_w.ifrw_bdp);
	addr = (struct pcldevice *)ui->ui_addr;
	addr->pcl_tcr = PCL_TXINIT;
	addr->pcl_tsba = (int)sc->sc_ifuba.ifu_w.ifrw_info;
	addr->pcl_tsbc = -sc->sc_olen;

	/*
	 * RIB (retry if busy) is used on the second and subsequent packets
	 * to a single host, because TCP often wants to transmit multiple
	 * buffers in a row,
	 * and if they are all going to the same place, the second and
	 * subsequent ones may be lost due to receiver not ready again yet.
	 * This can cause serious problems, because the TCP will resend the
	 * whole window, which just repeats the problem.  The result is that
	 * a perfectly good link appears not to work unless we take steps here.
	 */
	addr->pcl_tcr = (((int)(sc->sc_ifuba.ifu_w.ifrw_info>>12))&0x0030) |
		((sc->sc_odest & 0xF)<<8) |
		PCL_TXNPR | PCL_SNDWD | PCL_STTXM | PCL_IE |
		(sc->sc_odest == sc->sc_lastdest ? PCL_RIB : 0);
	sc->sc_lastdest = sc->sc_odest;
	sc->sc_oactive = 1;
}

/*
 * PCL transmitter interrupt.
 * Start another output if more data to send.
 */
pclxint(unit)
	int unit;
{
	register struct uba_device *ui = pclinfo[unit];
	register struct pcl_softc *sc = &pcl_softc[unit];
	register struct pcldevice *addr = (struct pcldevice *)ui->ui_addr;

	if (sc->sc_oactive == 0) {
		printf ("pcl%d: stray interrupt\n", unit);
		return;
	}
	if (addr->pcl_tsr & PCL_ERR) {
		sc->sc_lastdest = 0;		/* don't bother with RIB */
		if (addr->pcl_tsr & PCL_MSTDWN) {
			addr->pcl_tmmr = PCL_MASTER|PCL_AUTOADDR;
			pclstart(unit);	/* Retry */
			printf("pcl%d: master\n", unit );
			return;
		}
#ifndef PCL_TESTING
		if ((addr->pcl_tsr & (PCL_ERR|PCL_RESPB)) == (PCL_ERR|0))  {
			;	/* Receiver Offline -- not exactly an error */
		}  else  {
#else
		{
#endif
			/* Log as an error */
			printf("pcl%d: send error, tcr=%b tsr=%b\n",
				unit, addr->pcl_tcr, PCL_TCSRBITS,
				addr->pcl_tsr, PCL_TERRBITS);
			sc->sc_if.if_oerrors++;
		}
	} else
		sc->sc_if.if_opackets++;
	if (sc->sc_bdest == 0 && sc->sc_odest < PCLMAXTDM) {
		sc->sc_odest++;		/* do next host (broadcast) */
	} else {
		sc->sc_oactive = 0;
		if (sc->sc_ifuba.ifu_xtofree) {
			m_freem(sc->sc_ifuba.ifu_xtofree);
			sc->sc_ifuba.ifu_xtofree = 0;
		}
	}
	pclstart(unit);
}

/*
 * PCL interface receiver interrupt.
 * If input error just drop packet.
 */
pclrint(unit)
	int unit;
{
	register struct pcl_softc *sc = &pcl_softc[unit];
	struct pcldevice *addr = (struct pcldevice *)pclinfo[unit]->ui_addr;
    	struct mbuf *m;
	int len;
	register struct ifqueue *inq;

	sc->sc_if.if_ipackets++;
	/*
	 * Purge BDP; drop if input error indicated.
	 */
	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
		UBAPURGE(sc->sc_ifuba.ifu_uba, sc->sc_ifuba.ifu_r.ifrw_bdp);
	if (addr->pcl_rsr & PCL_ERR) {
		printf("pcl%d: rcv error, rcr=%b rsr=%b\n",
			unit, addr->pcl_rcr, PCL_RCSRBITS,
			addr->pcl_rsr, PCL_RERRBITS);
		sc->sc_if.if_ierrors++;
		goto setup;
	}
	len = PCLMTU + addr->pcl_rdbc;
	if (len <= 0 || len > PCLMTU) {
		printf("pcl%d: bad len=%d.\n", unit, len);
		sc->sc_if.if_ierrors++;
		goto setup;
	}

	/* Really short packets will be part of the startup sequence */
	if (len <= 4) {
		/* Later, do comming-up processing here */
		goto setup;	/* drop packet */
	}

	/*
	 * Pull packet off interface.
	 */
	m = if_rubaget(&sc->sc_ifuba, len, 0, &sc->sc_if);
	if (m == 0)
		goto setup;

	schednetisr(NETISR_IP);
	inq = &ipintrq;

	if (IF_QFULL(inq)) {
		IF_DROP(inq);
		m_freem(m);
	} else
		IF_ENQUEUE(inq, m);
setup:
	/*
	 * Reset for next packet.
	 */
	addr->pcl_rcr = PCL_RCINIT;
	addr->pcl_rdba = (int)sc->sc_ifuba.ifu_r.ifrw_info;
	addr->pcl_rdbc = -PCLMTU;
	addr->pcl_rcr = (((int)(sc->sc_ifuba.ifu_w.ifrw_info>>12))&0x0030) |
		PCL_RCNPR | PCL_RCVWD | PCL_RCVDAT | PCL_IE;
}

/*
 * Process an ioctl request.
 */
/* ARGSUSED */
pclioctl(ifp, cmd, data)
	register struct ifnet *ifp;
	int cmd;
	caddr_t data;
{
	int s = splimp(), error = 0;

	switch (cmd) {

	case SIOCSIFADDR:
		ifp->if_flags |= IFF_UP;
		if ((ifp->if_flags & IFF_RUNNING) == 0)
			pclinit(ifp->if_unit);
		break;

	default:
		error = EINVAL;
	}
	splx(s);
	return (error);
}
#endif
Commit	Line	Data
da7c5cc6	1	/*
2eb4e665	2	* Copyright (c) 1982, 1986 Regents of the University of California.
5f9369d6	3	* All rights reserved.
da7c5cc6	4	*
5f9369d6 KB	5	* Redistribution and use in source and binary forms are permitted
	6	* provided that the above copyright notice and this paragraph are
	7	* duplicated in all such forms and that any documentation,
	8	* advertising materials, and other materials related to such
	9	* distribution and use acknowledge that the software was developed
	10	* by the University of California, Berkeley. The name of the
	11	* University may not be used to endorse or promote products derived
	12	* from this software without specific prior written permission.
	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	15	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	16	*
c18e27ed	17	* @(#)if_pcl.c 7.4 (Berkeley) %G%
da7c5cc6	18	*/
f5a868d6 SL	19
	20	#include "pcl.h"
	21	#if NPCL > 0
	22	/*
	23	* DEC CSS PCL-11B Parallel Communications Interface
	24	*
e99dc359	25	* Written by Mike Muuss and Jeff Schwab.
f5a868d6	26	*/
c18e27ed	27	#include "machine/pte.h"
f5a868d6	28
a6e960e7 JB	29	#include "param.h"
	30	#include "systm.h"
	31	#include "mbuf.h"
	32	#include "buf.h"
	33	#include "protosw.h"
	34	#include "socket.h"
	35	#include "vmmac.h"
	36	#include "ioctl.h"
	37	#include "errno.h"
f5a868d6 SL	38
	39	#include "../net/if.h"
	40	#include "../net/netisr.h"
	41	#include "../net/route.h"
67eb6277	42
58bca61d	43	#ifdef INET
f5a868d6 SL	44	#include "../netinet/in.h"
f5a868d6 SL	45	#include "../netinet/in_systm.h"
58bca61d	46	#include "../netinet/in_var.h"
f5a868d6	47	#include "../netinet/ip.h"
58bca61d	48	#endif
f5a868d6 SL	49
	50	#include "../vax/cpu.h"
	51	#include "../vax/mtpr.h"
a6e960e7 JB	52	#include "if_pclreg.h"
a6e960e7 JB	53	#include "if_uba.h"
f5a868d6 SL	54	#include "../vaxuba/ubareg.h"
	55	#include "../vaxuba/ubavar.h"
	56
	57	/* The MTU has been carefully selected to prevent fragmentation <-> ArpaNet */
e99dc359 SL	58	#define PCLMTU (1006) /* Max transmission unit (bytes) */
e99dc359 SL	59	#define PCLMAXTDM 7 /* Max unit number on TDM bus */
f5a868d6 SL	60
f5a868d6 SL	61	int pclprobe(), pclattach(), pclrint(), pclxint();
17718098	62	int pclinit(), pclioctl(), pcloutput(), pclreset();
f5a868d6 SL	63
	64	struct uba_device *pclinfo[NPCL];
	65	u_short pclstd[] = { 0 };
	66	#define PCLUNIT(x) minor(x)
	67	struct uba_driver pcldriver =
	68	{ pclprobe, 0, pclattach, 0, pclstd, "pcl", pclinfo };
	69
	70	/*
	71	* PCL software status per interface.
	72	*
	73	* Each interface is referenced by a network interface structure,
	74	* sc_if, which the routing code uses to locate the interface.
	75	* This structure contains the output queue for the interface, its address, ...
	76	* We also have, for each interface, a UBA interface structure, which
	77	* contains information about the UNIBUS resources held by the interface:
	78	* map registers, buffered data paths, etc. Information is cached in this
	79	* structure for use by the if_uba.c routines in running the interface
	80	* efficiently.
	81	*/
	82	struct pcl_softc {
	83	struct ifnet sc_if; /* network-visible interface */
	84	struct ifuba sc_ifuba; /* UNIBUS resources */
	85	short sc_oactive; /* is output active? */
	86	short sc_olen; /* length of last output */
	87	short sc_lastdest; /* previous destination */
	88	short sc_odest; /* current xmit destination */
e99dc359	89	short sc_bdest; /* buffer's stated destination */
f5a868d6 SL	90	short sc_pattern; /* identification pattern */
	91	} pcl_softc[NPCL];
	92
	93	/*
	94	* Structure of "local header", which only goes between
	95	* pcloutput and pclstart.
	96	*/
	97	struct pcl_header {
	98	short pcl_dest; /* Destination PCL station */
	99	};
	100
	101	/*
	102	* Do non-DMA output of 1 word to determine presence of interface,
	103	* and to find the interupt vector. 1 word messages are a special
	104	* case in the receiver routine, and will be discarded.
	105	*/
	106	pclprobe(reg)
	107	caddr_t reg;
	108	{
	109	register int br, cvec; /* r11, r10 value-result */
	110	register struct pcldevice addr = (struct pcldevice )reg;
	111
	112	#ifdef lint
	113	br = 0; cvec = br; br = cvec;
	114	pclrint(0); pclxint(0);
	115	#endif
	116	addr->pcl_rcr = PCL_RCINIT;
	117	addr->pcl_tcr = PCL_TXINIT;
	118	addr->pcl_tsba = 0xFFFE;
	119	/* going for 01777776 */
	120	addr->pcl_tsbc = -4; /* really short */
	121	addr->pcl_tcr =
	122	((1 & 0xF) << 8) \| PCL_TXNPR \| PCL_SNDWD \| PCL_STTXM \| PCL_IE \| 0x0030;
	123	DELAY(100000);
	124	addr->pcl_tcr = PCL_TXINIT;
	125	return (sizeof (struct pcldevice));
	126	}
	127
	128	/*
	129	* Interface exists: make available by filling in network interface
	130	* record. System will initialize the interface when it is ready
	131	* to accept packets.
	132	*/
	133	pclattach(ui)
	134	struct uba_device *ui;
	135	{
	136	register struct pcl_softc *sc = &pcl_softc[ui->ui_unit];
f5a868d6 SL	137
	138	sc->sc_if.if_unit = ui->ui_unit;
	139	sc->sc_if.if_name = "pcl";
	140	sc->sc_if.if_mtu = PCLMTU;
f5a868d6 SL	141	sc->sc_if.if_init = pclinit;
f5a868d6 SL	142	sc->sc_if.if_output = pcloutput;
17718098	143	sc->sc_if.if_ioctl = pclioctl;
f5a868d6	144	sc->sc_if.if_reset = pclreset;
b05c393d	145	sc->sc_if.if_flags = IFF_BROADCAST;
f5a868d6 SL	146	sc->sc_ifuba.ifu_flags = UBA_NEEDBDP;
	147	if_attach(&sc->sc_if);
	148	}
	149
	150	/*
	151	* Reset of interface after UNIBUS reset.
	152	* If interface is on specified uba, reset its state.
	153	*/
	154	pclreset(unit, uban)
	155	int unit, uban;
	156	{
	157	register struct uba_device *ui;
	158
	159	if (unit >= NPCL \|\| (ui = pclinfo[unit]) == 0 \|\| ui->ui_alive == 0 \|\|
	160	ui->ui_ubanum != uban)
	161	return;
	162	printf(" pcl%d", unit);
	163	pclinit(unit);
	164	}
	165
	166	/*
	167	* Initialization of interface; clear recorded pending
	168	* operations, and reinitialize UNIBUS usage.
	169	*/
	170	pclinit(unit)
	171	int unit;
	172	{
	173	register struct pcl_softc *sc = &pcl_softc[unit];
	174	register struct uba_device *ui = pclinfo[unit];
	175	register struct pcldevice *addr;
	176	int s;
	177
b05c393d	178	if (sc->sc_if.if_addrlist == (struct ifaddr *)0)
17718098	179	return;
f5a868d6 SL	180	if (if_ubainit(&sc->sc_ifuba, ui->ui_ubanum, 0,
	181	(int)btoc(PCLMTU)) == 0) {
	182	printf("pcl%d: can't init\n", unit);
b05c393d	183	sc->sc_if.if_flags &= ~(IFF_UP \| IFF_RUNNING);
f5a868d6 SL	184	return;
f5a868d6 SL	185	}
b05c393d	186	sc->sc_if.if_flags \|= IFF_RUNNING;
f5a868d6 SL	187	addr = (struct pcldevice *)ui->ui_addr;
	188	addr->pcl_rcr = PCL_RCINIT;
	189	addr->pcl_tcr = PCL_TXINIT;
	190
	191	/*
	192	* Hang a receive and start any
	193	* pending writes by faking a transmit complete.
	194	*/
	195	s = splimp();
	196	addr->pcl_rdba = (short) sc->sc_ifuba.ifu_r.ifrw_info;
	197	addr->pcl_rdbc = -PCLMTU;
	198	addr->pcl_rcr = (((int)(sc->sc_ifuba.ifu_r.ifrw_info>>12))&0x0030) \|
	199	PCL_RCNPR \| PCL_RCVWD \| PCL_RCVDAT \| PCL_IE;
	200	sc->sc_oactive = 0;
f5a868d6 SL	201	pclstart(unit);
f5a868d6 SL	202	splx(s);
f5a868d6 SL	203	}
	204
	205	/*
	206	* PCL output routine.
	207	*/
	208	pcloutput(ifp, m, dst)
	209	struct ifnet *ifp;
	210	struct mbuf *m;
	211	struct sockaddr *dst;
	212	{
44eb2da3	213	int dest, s, error;
f5a868d6 SL	214	struct pcl_header *pclp;
	215	struct mbuf *m2;
	216
	217	switch (dst->sa_family) {
	218
	219	#ifdef INET
	220	case AF_INET:
b05c393d MK	221	if (in_broadcast(((struct sockaddr_in *)dst)->sin_addr))
	222	dest = 0;
	223	else
	224	dest = in_lnaof(((struct sockaddr_in *)dst)->sin_addr);
e99dc359 SL	225	if (dest > PCLMAXTDM) {
	226	error = EHOSTUNREACH;
	227	goto bad;
	228	}
f5a868d6 SL	229	break;
	230	#endif
	231	default:
	232	printf("pcl%d: can't handle af%d\n", ifp->if_unit,
	233	dst->sa_family);
	234	error = EAFNOSUPPORT;
	235	goto bad;
	236	}
	237
	238	/*
	239	* Add pseudo local net header.
	240	* Actually, it does not get transmitted, but merely stripped
	241	* off and used by the START routine to route the packet.
	242	* If no space in first mbuf, allocate another.
	243	*/
4f02060d KS	244	M_PREPEND(m, sizeof(struct pcl_header), M_DONTWAIT);
	245	if (m == 0) {
	246	error = ENOBUFS;
	247	goto bad;
f5a868d6 SL	248	}
	249	pclp = mtod(m, struct pcl_header *);
	250	pclp->pcl_dest = dest;
	251
	252	/*
	253	* Queue message on interface, and start output if interface
	254	* not yet active.
	255	*/
	256	s = splimp();
	257	if (IF_QFULL(&ifp->if_snd)) {
	258	IF_DROP(&ifp->if_snd);
	259	error = ENOBUFS;
	260	goto qfull;
	261	}
	262	IF_ENQUEUE(&ifp->if_snd, m);
	263	if (pcl_softc[ifp->if_unit].sc_oactive == 0)
	264	pclstart(ifp->if_unit);
	265	splx(s);
	266	return (0);
	267	qfull:
	268	splx(s);
	269	bad:
	270	m_freem(m);
	271	return (error);
	272	}
	273
	274	/*
	275	* Start or restart output on interface.
	276	* If interface is already active, then this is a retransmit.
	277	* If interface is not already active, get another datagram
	278	* to send off of the interface queue, and map it to the interface
	279	* before starting the output.
	280	*/
	281	pclstart(dev)
	282	dev_t dev;
	283	{
	284	int unit = PCLUNIT(dev);
	285	struct uba_device *ui = pclinfo[unit];
	286	register struct pcl_softc *sc = &pcl_softc[unit];
	287	register struct pcldevice *addr;
	288	struct mbuf *m;
	289
	290	if (sc->sc_oactive)
	291	goto restart;
	292
	293	/*
	294	* Not already active: dequeue another request
	295	* and map it to the UNIBUS. If no more requests,
	296	* just return.
	297	*/
	298	IF_DEQUEUE(&sc->sc_if.if_snd, m);
	299	if (m == 0) {
	300	sc->sc_oactive = 0;
	301	return;
	302	}
	303
	304	/*
	305	* Pull destination node out of pseudo-local net header.
	306	* remove it from outbound data.
	307	* Note that if_wubaput calls m_bcopy, which is prepared for
	308	* m_len to be 0 in the first mbuf in the chain.
	309	*/
e99dc359 SL	310	sc->sc_bdest = mtod(m, struct pcl_header *)->pcl_dest;
e99dc359 SL	311	sc->sc_odest = sc->sc_bdest? sc->sc_bdest: 1;
4f02060d	312	m->m_data += sizeof (struct pcl_header);
f5a868d6	313	m->m_len -= sizeof (struct pcl_header);
4f02060d KS	314	if (m->m_flags & M_PKTHDR)
4f02060d KS	315	m->m_pkthdr.len -= sizeof (struct pcl_header);
f5a868d6 SL	316
	317	/* Map out to the DMA area */
	318	sc->sc_olen = if_wubaput(&sc->sc_ifuba, m);
	319
	320	restart:
	321	/*
	322	* Have request mapped to UNIBUS for transmission.
e99dc359	323	* Purge any stale data from this BDP, and start the output.
f5a868d6 SL	324	*/
	325	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
	326	UBAPURGE(sc->sc_ifuba.ifu_uba, sc->sc_ifuba.ifu_w.ifrw_bdp);
	327	addr = (struct pcldevice *)ui->ui_addr;
	328	addr->pcl_tcr = PCL_TXINIT;
	329	addr->pcl_tsba = (int)sc->sc_ifuba.ifu_w.ifrw_info;
	330	addr->pcl_tsbc = -sc->sc_olen;
	331
	332	/*
	333	* RIB (retry if busy) is used on the second and subsequent packets
	334	* to a single host, because TCP often wants to transmit multiple
	335	* buffers in a row,
	336	* and if they are all going to the same place, the second and
	337	* subsequent ones may be lost due to receiver not ready again yet.
	338	* This can cause serious problems, because the TCP will resend the
	339	* whole window, which just repeats the problem. The result is that
	340	* a perfectly good link appears not to work unless we take steps here.
	341	*/
	342	addr->pcl_tcr = (((int)(sc->sc_ifuba.ifu_w.ifrw_info>>12))&0x0030) \|
	343	((sc->sc_odest & 0xF)<<8) \|
	344	PCL_TXNPR \| PCL_SNDWD \| PCL_STTXM \| PCL_IE \|
	345	(sc->sc_odest == sc->sc_lastdest ? PCL_RIB : 0);
	346	sc->sc_lastdest = sc->sc_odest;
	347	sc->sc_oactive = 1;
	348	}
	349
	350	/*
	351	* PCL transmitter interrupt.
	352	* Start another output if more data to send.
	353	*/
	354	pclxint(unit)
	355	int unit;
	356	{
	357	register struct uba_device *ui = pclinfo[unit];
	358	register struct pcl_softc *sc = &pcl_softc[unit];
	359	register struct pcldevice addr = (struct pcldevice )ui->ui_addr;
	360
	361	if (sc->sc_oactive == 0) {
	362	printf ("pcl%d: stray interrupt\n", unit);
	363	return;
	364	}
	365	if (addr->pcl_tsr & PCL_ERR) {
	366	sc->sc_lastdest = 0; /* don't bother with RIB */
	367	if (addr->pcl_tsr & PCL_MSTDWN) {
	368	addr->pcl_tmmr = PCL_MASTER\|PCL_AUTOADDR;
	369	pclstart(unit); /* Retry */
	370	printf("pcl%d: master\n", unit );
	371	return;
	372	}
e99dc359 SL	373	#ifndef PCL_TESTING
	374	if ((addr->pcl_tsr & (PCL_ERR\|PCL_RESPB)) == (PCL_ERR\|0)) {
	375	; /* Receiver Offline -- not exactly an error */
	376	} else {
	377	#else
	378	{
	379	#endif
f5a868d6 SL	380	/* Log as an error */
	381	printf("pcl%d: send error, tcr=%b tsr=%b\n",
	382	unit, addr->pcl_tcr, PCL_TCSRBITS,
	383	addr->pcl_tsr, PCL_TERRBITS);
	384	sc->sc_if.if_oerrors++;
	385	}
	386	} else
	387	sc->sc_if.if_opackets++;
e99dc359 SL	388	if (sc->sc_bdest == 0 && sc->sc_odest < PCLMAXTDM) {
	389	sc->sc_odest++; /* do next host (broadcast) */
	390	} else {
	391	sc->sc_oactive = 0;
	392	if (sc->sc_ifuba.ifu_xtofree) {
	393	m_freem(sc->sc_ifuba.ifu_xtofree);
	394	sc->sc_ifuba.ifu_xtofree = 0;
	395	}
f5a868d6 SL	396	}
	397	pclstart(unit);
	398	}
	399
	400	/*
	401	* PCL interface receiver interrupt.
	402	* If input error just drop packet.
	403	*/
	404	pclrint(unit)
	405	int unit;
	406	{
	407	register struct pcl_softc *sc = &pcl_softc[unit];
	408	struct pcldevice addr = (struct pcldevice )pclinfo[unit]->ui_addr;
	409	struct mbuf *m;
44eb2da3	410	int len;
f5a868d6	411	register struct ifqueue *inq;
f5a868d6 SL	412
	413	sc->sc_if.if_ipackets++;
	414	/*
	415	* Purge BDP; drop if input error indicated.
	416	*/
	417	if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
	418	UBAPURGE(sc->sc_ifuba.ifu_uba, sc->sc_ifuba.ifu_r.ifrw_bdp);
	419	if (addr->pcl_rsr & PCL_ERR) {
	420	printf("pcl%d: rcv error, rcr=%b rsr=%b\n",
	421	unit, addr->pcl_rcr, PCL_RCSRBITS,
	422	addr->pcl_rsr, PCL_RERRBITS);
	423	sc->sc_if.if_ierrors++;
	424	goto setup;
	425	}
	426	len = PCLMTU + addr->pcl_rdbc;
	427	if (len <= 0 \|\| len > PCLMTU) {
	428	printf("pcl%d: bad len=%d.\n", unit, len);
	429	sc->sc_if.if_ierrors++;
	430	goto setup;
	431	}
	432
	433	/* Really short packets will be part of the startup sequence */
	434	if (len <= 4) {
	435	/* Later, do comming-up processing here */
	436	goto setup; /* drop packet */
	437	}
	438
	439	/*
	440	* Pull packet off interface.
	441	*/
67eb6277	442	m = if_rubaget(&sc->sc_ifuba, len, 0, &sc->sc_if);
f5a868d6 SL	443	if (m == 0)
	444	goto setup;
	445
	446	schednetisr(NETISR_IP);
	447	inq = &ipintrq;
	448
	449	if (IF_QFULL(inq)) {
	450	IF_DROP(inq);
	451	m_freem(m);
	452	} else
	453	IF_ENQUEUE(inq, m);
	454	setup:
	455	/*
	456	* Reset for next packet.
	457	*/
	458	addr->pcl_rcr = PCL_RCINIT;
	459	addr->pcl_rdba = (int)sc->sc_ifuba.ifu_r.ifrw_info;
	460	addr->pcl_rdbc = -PCLMTU;
	461	addr->pcl_rcr = (((int)(sc->sc_ifuba.ifu_w.ifrw_info>>12))&0x0030) \|
	462	PCL_RCNPR \| PCL_RCVWD \| PCL_RCVDAT \| PCL_IE;
	463	}
17718098 SL	464
	465	/*
	466	* Process an ioctl request.
	467	*/
9205905c	468	/* ARGSUSED */
17718098 SL	469	pclioctl(ifp, cmd, data)
	470	register struct ifnet *ifp;
	471	int cmd;
	472	caddr_t data;
	473	{
17718098 SL	474	int s = splimp(), error = 0;
	475
	476	switch (cmd) {
	477
	478	case SIOCSIFADDR:
67eb6277	479	ifp->if_flags \|= IFF_UP;
b05c393d	480	if ((ifp->if_flags & IFF_RUNNING) == 0)
17718098 SL	481	pclinit(ifp->if_unit);
	482	break;
	483
	484	default:
	485	error = EINVAL;
	486	}
	487	splx(s);
	488	return (error);
	489	}
f5a868d6	490	#endif