Home | History | Annotate | Line # | Download | only in qbus
if_dmc.c revision 1.29.10.1
      1  1.29.10.1  perseant /*	$NetBSD: if_dmc.c,v 1.29.10.1 2025/08/02 05:57:02 perseant Exp $	*/
      2        1.1     ragge /*
      3        1.1     ragge  * Copyright (c) 1982, 1986 Regents of the University of California.
      4        1.1     ragge  * All rights reserved.
      5        1.1     ragge  *
      6        1.1     ragge  * Redistribution and use in source and binary forms, with or without
      7        1.1     ragge  * modification, are permitted provided that the following conditions
      8        1.1     ragge  * are met:
      9        1.1     ragge  * 1. Redistributions of source code must retain the above copyright
     10        1.1     ragge  *    notice, this list of conditions and the following disclaimer.
     11        1.1     ragge  * 2. Redistributions in binary form must reproduce the above copyright
     12        1.1     ragge  *    notice, this list of conditions and the following disclaimer in the
     13        1.1     ragge  *    documentation and/or other materials provided with the distribution.
     14        1.7       agc  * 3. Neither the name of the University nor the names of its contributors
     15        1.1     ragge  *    may be used to endorse or promote products derived from this software
     16        1.1     ragge  *    without specific prior written permission.
     17        1.1     ragge  *
     18        1.1     ragge  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     19        1.1     ragge  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     20        1.1     ragge  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     21        1.1     ragge  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     22        1.1     ragge  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     23        1.1     ragge  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     24        1.1     ragge  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     25        1.1     ragge  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     26        1.1     ragge  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     27        1.1     ragge  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     28        1.1     ragge  * SUCH DAMAGE.
     29        1.1     ragge  *
     30        1.1     ragge  *	@(#)if_dmc.c	7.10 (Berkeley) 12/16/90
     31        1.1     ragge  */
     32        1.1     ragge 
     33        1.1     ragge /*
     34        1.1     ragge  * DMC11 device driver, internet version
     35        1.1     ragge  *
     36        1.1     ragge  *	Bill Nesheim
     37        1.1     ragge  *	Cornell University
     38        1.1     ragge  *
     39        1.1     ragge  *	Lou Salkind
     40        1.1     ragge  *	New York University
     41        1.1     ragge  */
     42        1.2     lukem 
     43        1.2     lukem #include <sys/cdefs.h>
     44  1.29.10.1  perseant __KERNEL_RCSID(0, "$NetBSD: if_dmc.c,v 1.29.10.1 2025/08/02 05:57:02 perseant Exp $");
     45        1.1     ragge 
     46        1.1     ragge #undef DMCDEBUG	/* for base table dump on fatal error */
     47        1.1     ragge 
     48        1.1     ragge #include "opt_inet.h"
     49        1.1     ragge 
     50        1.1     ragge #include <sys/param.h>
     51        1.1     ragge #include <sys/systm.h>
     52        1.1     ragge #include <sys/mbuf.h>
     53        1.1     ragge #include <sys/ioctl.h>
     54        1.1     ragge #include <sys/socket.h>
     55        1.1     ragge #include <sys/syslog.h>
     56        1.1     ragge #include <sys/device.h>
     57        1.1     ragge 
     58        1.1     ragge #include <net/if.h>
     59        1.1     ragge 
     60        1.1     ragge #ifdef	INET
     61        1.1     ragge #include <netinet/in.h>
     62        1.1     ragge #include <netinet/in_var.h>
     63        1.1     ragge #endif
     64        1.1     ragge 
     65       1.15        ad #include <sys/bus.h>
     66        1.1     ragge 
     67        1.1     ragge #include <dev/qbus/ubareg.h>
     68        1.1     ragge #include <dev/qbus/ubavar.h>
     69        1.1     ragge #include <dev/qbus/if_uba.h>
     70        1.1     ragge 
     71        1.1     ragge #include <dev/qbus/if_dmcreg.h>
     72        1.1     ragge 
     73        1.1     ragge 
     74        1.1     ragge /*
     75        1.1     ragge  * output timeout value, sec.; should depend on line speed.
     76        1.1     ragge  */
     77        1.1     ragge static int dmc_timeout = 20;
     78        1.1     ragge 
     79        1.1     ragge #define NRCV 7
     80        1.9    simonb #define NXMT 3
     81        1.1     ragge #define NCMDS	(NRCV+NXMT+4)	/* size of command queue */
     82        1.1     ragge 
     83        1.1     ragge #define DMC_WBYTE(csr, val) \
     84        1.1     ragge 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, csr, val)
     85        1.1     ragge #define DMC_WWORD(csr, val) \
     86        1.1     ragge 	bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val)
     87        1.1     ragge #define DMC_RBYTE(csr) \
     88        1.1     ragge 	bus_space_read_1(sc->sc_iot, sc->sc_ioh, csr)
     89        1.1     ragge #define DMC_RWORD(csr) \
     90        1.1     ragge 	bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr)
     91        1.1     ragge 
     92        1.1     ragge 
     93        1.1     ragge #ifdef DMCDEBUG
     94        1.1     ragge #define printd if(dmcdebug)printf
     95        1.1     ragge int dmcdebug = 0;
     96        1.1     ragge #endif
     97        1.1     ragge 
     98        1.1     ragge /* error reporting intervals */
     99        1.1     ragge #define DMC_RPNBFS	50
    100        1.1     ragge #define DMC_RPDSC	1
    101        1.1     ragge #define DMC_RPTMO	10
    102        1.1     ragge #define DMC_RPDCK	10
    103        1.1     ragge 
    104        1.1     ragge struct  dmc_command {
    105        1.1     ragge 	char	qp_cmd;		/* command */
    106        1.1     ragge 	short	qp_ubaddr;	/* buffer address */
    107        1.1     ragge 	short	qp_cc;		/* character count || XMEM */
    108        1.1     ragge 	struct	dmc_command *qp_next;	/* next command on queue */
    109        1.1     ragge };
    110        1.1     ragge 
    111        1.1     ragge struct dmcbufs {
    112        1.1     ragge 	int	ubinfo;		/* from uballoc */
    113        1.1     ragge 	short	cc;		/* buffer size */
    114        1.1     ragge 	short	flags;		/* access control */
    115        1.1     ragge };
    116        1.1     ragge #define	DBUF_OURS	0	/* buffer is available */
    117        1.1     ragge #define	DBUF_DMCS	1	/* buffer claimed by somebody */
    118        1.1     ragge #define	DBUF_XMIT	4	/* transmit buffer */
    119        1.1     ragge #define	DBUF_RCV	8	/* receive buffer */
    120        1.1     ragge 
    121        1.1     ragge 
    122        1.1     ragge /*
    123        1.1     ragge  * DMC software status per interface.
    124        1.1     ragge  *
    125        1.1     ragge  * Each interface is referenced by a network interface structure,
    126        1.1     ragge  * sc_if, which the routing code uses to locate the interface.
    127        1.1     ragge  * This structure contains the output queue for the interface, its address, ...
    128        1.1     ragge  * We also have, for each interface, a  set of 7 UBA interface structures
    129        1.1     ragge  * for each, which
    130        1.1     ragge  * contain information about the UNIBUS resources held by the interface:
    131        1.1     ragge  * map registers, buffered data paths, etc.  Information is cached in this
    132        1.1     ragge  * structure for use by the if_uba.c routines in running the interface
    133        1.1     ragge  * efficiently.
    134        1.1     ragge  */
    135        1.1     ragge struct dmc_softc {
    136       1.21       chs 	device_t sc_dev;		/* Configuration common part */
    137        1.1     ragge 	struct	ifnet sc_if;		/* network-visible interface */
    138        1.1     ragge 	short	sc_oused;		/* output buffers currently in use */
    139        1.1     ragge 	short	sc_iused;		/* input buffers given to DMC */
    140        1.1     ragge 	short	sc_flag;		/* flags */
    141        1.1     ragge 	struct	ubinfo sc_ui;		/* UBA mapping info for base table */
    142        1.1     ragge 	int	sc_errors[4];		/* non-fatal error counters */
    143        1.1     ragge 	bus_space_tag_t sc_iot;
    144        1.1     ragge 	bus_addr_t sc_ioh;
    145        1.1     ragge 	bus_dma_tag_t sc_dmat;
    146        1.1     ragge 	struct	evcnt sc_rintrcnt;	/* Interrupt counting */
    147        1.1     ragge 	struct	evcnt sc_tintrcnt;	/* Interrupt counting */
    148        1.1     ragge #define sc_datck sc_errors[0]
    149        1.1     ragge #define sc_timeo sc_errors[1]
    150        1.1     ragge #define sc_nobuf sc_errors[2]
    151        1.1     ragge #define sc_disc  sc_errors[3]
    152        1.1     ragge 	struct	dmcbufs sc_rbufs[NRCV];	/* receive buffer info */
    153        1.1     ragge 	struct	dmcbufs sc_xbufs[NXMT];	/* transmit buffer info */
    154        1.1     ragge 	struct	ifubinfo sc_ifuba;	/* UNIBUS resources */
    155        1.1     ragge 	struct	ifrw sc_ifr[NRCV];	/* UNIBUS receive buffer maps */
    156        1.1     ragge 	struct	ifxmt sc_ifw[NXMT];	/* UNIBUS receive buffer maps */
    157        1.1     ragge 	/* command queue stuff */
    158        1.1     ragge 	struct	dmc_command sc_cmdbuf[NCMDS];
    159        1.1     ragge 	struct	dmc_command *sc_qhead;	/* head of command queue */
    160        1.1     ragge 	struct	dmc_command *sc_qtail;	/* tail of command queue */
    161        1.1     ragge 	struct	dmc_command *sc_qactive;	/* command in progress */
    162        1.1     ragge 	struct	dmc_command *sc_qfreeh;	/* head of list of free cmd buffers */
    163        1.1     ragge 	struct	dmc_command *sc_qfreet;	/* tail of list of free cmd buffers */
    164        1.1     ragge 	/* end command queue stuff */
    165        1.1     ragge 	struct dmc_base {
    166        1.1     ragge 		short	d_base[128];		/* DMC base table */
    167        1.1     ragge 	} dmc_base;
    168        1.1     ragge };
    169        1.1     ragge 
    170       1.20    cegger static  int dmcmatch(device_t, cfdata_t, void *);
    171       1.20    cegger static  void dmcattach(device_t, device_t, void *);
    172        1.1     ragge static  int dmcinit(struct ifnet *);
    173        1.1     ragge static  void dmcrint(void *);
    174        1.1     ragge static  void dmcxint(void *);
    175        1.1     ragge static  void dmcdown(struct dmc_softc *sc);
    176        1.1     ragge static  void dmcrestart(struct dmc_softc *);
    177        1.1     ragge static  void dmcload(struct dmc_softc *, int, u_short, u_short);
    178        1.1     ragge static  void dmcstart(struct ifnet *);
    179        1.1     ragge static  void dmctimeout(struct ifnet *);
    180       1.14  christos static  int dmcioctl(struct ifnet *, u_long, void *);
    181        1.1     ragge static  int dmcoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
    182        1.1     ragge 	struct rtentry *);
    183       1.20    cegger static  void dmcreset(device_t);
    184        1.1     ragge 
    185       1.21       chs CFATTACH_DECL_NEW(dmc, sizeof(struct dmc_softc),
    186        1.6   thorpej     dmcmatch, dmcattach, NULL, NULL);
    187        1.1     ragge 
    188        1.1     ragge /* flags */
    189        1.1     ragge #define DMC_RUNNING	0x01		/* device initialized */
    190        1.1     ragge #define DMC_BMAPPED	0x02		/* base table mapped */
    191        1.1     ragge #define DMC_RESTART	0x04		/* software restart in progress */
    192        1.1     ragge #define DMC_ONLINE	0x08		/* device running (had a RDYO) */
    193        1.1     ragge 
    194        1.1     ragge 
    195        1.1     ragge /* queue manipulation macros */
    196        1.1     ragge #define	QUEUE_AT_HEAD(qp, head, tail) \
    197        1.1     ragge 	(qp)->qp_next = (head); \
    198        1.1     ragge 	(head) = (qp); \
    199        1.1     ragge 	if ((tail) == (struct dmc_command *) 0) \
    200        1.9    simonb 		(tail) = (head)
    201        1.1     ragge 
    202        1.1     ragge #define QUEUE_AT_TAIL(qp, head, tail) \
    203        1.1     ragge 	if ((tail)) \
    204        1.1     ragge 		(tail)->qp_next = (qp); \
    205        1.1     ragge 	else \
    206        1.1     ragge 		(head) = (qp); \
    207        1.1     ragge 	(qp)->qp_next = (struct dmc_command *) 0; \
    208        1.1     ragge 	(tail) = (qp)
    209        1.1     ragge 
    210        1.1     ragge #define DEQUEUE(head, tail) \
    211        1.1     ragge 	(head) = (head)->qp_next;\
    212        1.1     ragge 	if ((head) == (struct dmc_command *) 0)\
    213        1.1     ragge 		(tail) = (head)
    214        1.1     ragge 
    215        1.1     ragge int
    216       1.20    cegger dmcmatch(device_t parent, cfdata_t cf, void *aux)
    217        1.1     ragge {
    218        1.1     ragge 	struct uba_attach_args *ua = aux;
    219        1.1     ragge 	struct dmc_softc ssc;
    220        1.1     ragge 	struct dmc_softc *sc = &ssc;
    221        1.1     ragge 	int i;
    222        1.1     ragge 
    223        1.1     ragge 	sc->sc_iot = ua->ua_iot;
    224        1.1     ragge 	sc->sc_ioh = ua->ua_ioh;
    225        1.1     ragge 
    226        1.1     ragge 	DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
    227        1.1     ragge 	for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
    228        1.1     ragge 		;
    229        1.1     ragge 	if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
    230        1.1     ragge 		printf("dmcprobe: can't start device\n" );
    231        1.1     ragge 		return (0);
    232        1.1     ragge 	}
    233        1.1     ragge 	DMC_WBYTE(DMC_BSEL0, DMC_RQI|DMC_IEI);
    234        1.1     ragge 	/* let's be paranoid */
    235        1.1     ragge 	DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) | DMC_RQI|DMC_IEI);
    236        1.1     ragge 	DELAY(1000000);
    237        1.1     ragge 	DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
    238        1.1     ragge 	for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
    239        1.1     ragge 		;
    240        1.1     ragge 	return (1);
    241        1.1     ragge }
    242        1.1     ragge 
    243        1.1     ragge /*
    244        1.1     ragge  * Interface exists: make available by filling in network interface
    245        1.1     ragge  * record.  System will initialize the interface when it is ready
    246        1.1     ragge  * to accept packets.
    247        1.1     ragge  */
    248        1.1     ragge void
    249       1.20    cegger dmcattach(device_t parent, device_t self, void *aux)
    250        1.1     ragge {
    251        1.1     ragge 	struct uba_attach_args *ua = aux;
    252       1.13   thorpej 	struct dmc_softc *sc = device_private(self);
    253        1.1     ragge 
    254       1.21       chs 	sc->sc_dev = self;
    255        1.1     ragge 	sc->sc_iot = ua->ua_iot;
    256        1.1     ragge 	sc->sc_ioh = ua->ua_ioh;
    257        1.1     ragge 	sc->sc_dmat = ua->ua_dmat;
    258        1.1     ragge 
    259       1.21       chs 	strlcpy(sc->sc_if.if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
    260        1.1     ragge 	sc->sc_if.if_mtu = DMCMTU;
    261        1.1     ragge 	sc->sc_if.if_init = dmcinit;
    262        1.1     ragge 	sc->sc_if.if_output = dmcoutput;
    263        1.1     ragge 	sc->sc_if.if_ioctl = dmcioctl;
    264        1.1     ragge 	sc->sc_if.if_watchdog = dmctimeout;
    265        1.1     ragge 	sc->sc_if.if_flags = IFF_POINTOPOINT;
    266        1.1     ragge 	sc->sc_if.if_softc = sc;
    267        1.3    itojun 	IFQ_SET_READY(&sc->sc_if.if_snd);
    268        1.1     ragge 
    269        1.1     ragge 	uba_intr_establish(ua->ua_icookie, ua->ua_cvec, dmcrint, sc,
    270        1.1     ragge 	    &sc->sc_rintrcnt);
    271        1.1     ragge 	uba_intr_establish(ua->ua_icookie, ua->ua_cvec+4, dmcxint, sc,
    272        1.1     ragge 	    &sc->sc_tintrcnt);
    273       1.21       chs 	uba_reset_establish(dmcreset, sc->sc_dev);
    274        1.1     ragge 	evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
    275       1.21       chs 	    device_xname(sc->sc_dev), "intr");
    276        1.1     ragge 	evcnt_attach_dynamic(&sc->sc_tintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
    277       1.21       chs 	    device_xname(sc->sc_dev), "intr");
    278        1.1     ragge 
    279        1.1     ragge 	if_attach(&sc->sc_if);
    280        1.1     ragge }
    281        1.1     ragge 
    282        1.1     ragge /*
    283        1.1     ragge  * Reset of interface after UNIBUS reset.
    284        1.1     ragge  * If interface is on specified UBA, reset its state.
    285        1.1     ragge  */
    286        1.1     ragge void
    287       1.20    cegger dmcreset(device_t dev)
    288        1.1     ragge {
    289       1.21       chs 	struct dmc_softc *sc = device_private(dev);
    290        1.1     ragge 
    291        1.1     ragge 	sc->sc_flag = 0;
    292        1.1     ragge 	sc->sc_if.if_flags &= ~IFF_RUNNING;
    293        1.1     ragge 	dmcinit(&sc->sc_if);
    294        1.1     ragge }
    295        1.1     ragge 
    296        1.1     ragge /*
    297        1.1     ragge  * Initialization of interface; reinitialize UNIBUS usage.
    298        1.1     ragge  */
    299        1.1     ragge int
    300        1.1     ragge dmcinit(struct ifnet *ifp)
    301        1.1     ragge {
    302        1.1     ragge 	struct dmc_softc *sc = ifp->if_softc;
    303        1.1     ragge 	struct ifrw *ifrw;
    304        1.1     ragge 	struct ifxmt *ifxp;
    305        1.1     ragge 	struct dmcbufs *rp;
    306        1.1     ragge 	struct dmc_command *qp;
    307        1.1     ragge 	struct ifaddr *ifa;
    308       1.21       chs 	cfdata_t ui = device_cfdata(sc->sc_dev);
    309        1.1     ragge 	int base;
    310        1.1     ragge 	int s;
    311        1.1     ragge 
    312        1.1     ragge 	/*
    313        1.1     ragge 	 * Check to see that an address has been set
    314        1.1     ragge 	 * (both local and destination for an address family).
    315        1.1     ragge 	 */
    316       1.26     ozaki 	s = pserialize_read_enter();
    317       1.26     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
    318        1.1     ragge 		if (ifa->ifa_addr->sa_family && ifa->ifa_dstaddr->sa_family)
    319        1.1     ragge 			break;
    320       1.26     ozaki 	}
    321       1.26     ozaki 	pserialize_read_exit(s);
    322       1.25     ozaki 	if (ifa == NULL)
    323        1.1     ragge 		return 0;
    324        1.1     ragge 
    325        1.1     ragge 	if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
    326        1.1     ragge 		printf("dmcinit: DMC not running\n");
    327        1.1     ragge 		ifp->if_flags &= ~IFF_UP;
    328        1.1     ragge 		return 0;
    329        1.1     ragge 	}
    330        1.1     ragge 	/* map base table */
    331        1.1     ragge 	if ((sc->sc_flag & DMC_BMAPPED) == 0) {
    332        1.1     ragge 		sc->sc_ui.ui_size = sizeof(struct dmc_base);
    333       1.14  christos 		sc->sc_ui.ui_vaddr = (void *)&sc->dmc_base;
    334       1.21       chs 		uballoc(device_private(device_parent(sc->sc_dev)), &sc->sc_ui, 0);
    335        1.1     ragge 		sc->sc_flag |= DMC_BMAPPED;
    336        1.1     ragge 	}
    337        1.1     ragge 	/* initialize UNIBUS resources */
    338        1.1     ragge 	sc->sc_iused = sc->sc_oused = 0;
    339        1.1     ragge 	if ((ifp->if_flags & IFF_RUNNING) == 0) {
    340       1.11   thorpej 		if (if_ubaminit(&sc->sc_ifuba,
    341       1.21       chs 		    device_private(device_parent(sc->sc_dev)),
    342        1.1     ragge 		    sizeof(struct dmc_header) + DMCMTU,
    343        1.1     ragge 		    sc->sc_ifr, NRCV, sc->sc_ifw, NXMT) == 0) {
    344       1.21       chs 			aprint_error_dev(sc->sc_dev, "can't allocate uba resources\n");
    345        1.1     ragge 			ifp->if_flags &= ~IFF_UP;
    346        1.1     ragge 			return 0;
    347        1.1     ragge 		}
    348        1.1     ragge 		ifp->if_flags |= IFF_RUNNING;
    349        1.1     ragge 	}
    350        1.1     ragge 	sc->sc_flag &= ~DMC_ONLINE;
    351        1.1     ragge 	sc->sc_flag |= DMC_RUNNING;
    352        1.1     ragge 	/*
    353        1.1     ragge 	 * Limit packets enqueued until we see if we're on the air.
    354        1.1     ragge 	 */
    355        1.1     ragge 	ifp->if_snd.ifq_maxlen = 3;
    356        1.1     ragge 
    357        1.1     ragge 	/* initialize buffer pool */
    358        1.1     ragge 	/* receives */
    359        1.1     ragge 	ifrw = &sc->sc_ifr[0];
    360        1.1     ragge 	for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
    361        1.1     ragge 		rp->ubinfo = ifrw->ifrw_info;
    362        1.1     ragge 		rp->cc = DMCMTU + sizeof (struct dmc_header);
    363        1.1     ragge 		rp->flags = DBUF_OURS|DBUF_RCV;
    364        1.9    simonb 		ifrw++;
    365        1.1     ragge 	}
    366        1.1     ragge 	/* transmits */
    367        1.1     ragge 	ifxp = &sc->sc_ifw[0];
    368        1.1     ragge 	for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
    369        1.1     ragge 		rp->ubinfo = ifxp->ifw_info;
    370        1.1     ragge 		rp->cc = 0;
    371        1.1     ragge 		rp->flags = DBUF_OURS|DBUF_XMIT;
    372        1.9    simonb 		ifxp++;
    373        1.1     ragge 	}
    374        1.1     ragge 
    375        1.1     ragge 	/* set up command queues */
    376        1.1     ragge 	sc->sc_qfreeh = sc->sc_qfreet
    377        1.1     ragge 		 = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
    378        1.1     ragge 		(struct dmc_command *)0;
    379        1.1     ragge 	/* set up free command buffer list */
    380        1.1     ragge 	for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) {
    381        1.1     ragge 		QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
    382        1.1     ragge 	}
    383        1.1     ragge 
    384        1.1     ragge 	/* base in */
    385        1.1     ragge 	base = sc->sc_ui.ui_baddr;
    386        1.1     ragge 	dmcload(sc, DMC_BASEI, (u_short)base, (base>>2) & DMC_XMEM);
    387        1.1     ragge 	/* specify half duplex operation, flags tell if primary */
    388        1.1     ragge 	/* or secondary station */
    389        1.1     ragge 	if (ui->cf_flags == 0)
    390        1.1     ragge 		/* use DDCMP mode in full duplex */
    391        1.1     ragge 		dmcload(sc, DMC_CNTLI, 0, 0);
    392        1.1     ragge 	else if (ui->cf_flags == 1)
    393       1.29    andvar 		/* use MAINTENANCE mode */
    394        1.1     ragge 		dmcload(sc, DMC_CNTLI, 0, DMC_MAINT );
    395        1.1     ragge 	else if (ui->cf_flags == 2)
    396        1.1     ragge 		/* use DDCMP half duplex as primary station */
    397        1.1     ragge 		dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX);
    398        1.1     ragge 	else if (ui->cf_flags == 3)
    399        1.1     ragge 		/* use DDCMP half duplex as secondary station */
    400        1.1     ragge 		dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC);
    401        1.1     ragge 
    402        1.1     ragge 	/* enable operation done interrupts */
    403        1.1     ragge 	while ((DMC_RBYTE(DMC_BSEL2) & DMC_IEO) == 0)
    404        1.1     ragge 		DMC_WBYTE(DMC_BSEL2, DMC_RBYTE(DMC_BSEL2) | DMC_IEO);
    405        1.1     ragge 	s = splnet();
    406        1.1     ragge 	/* queue first NRCV buffers for DMC to fill */
    407        1.1     ragge 	for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
    408        1.1     ragge 		rp->flags |= DBUF_DMCS;
    409        1.1     ragge 		dmcload(sc, DMC_READ, rp->ubinfo,
    410        1.1     ragge 			(((rp->ubinfo>>2)&DMC_XMEM) | rp->cc));
    411        1.1     ragge 		sc->sc_iused++;
    412        1.1     ragge 	}
    413        1.1     ragge 	splx(s);
    414        1.1     ragge 	return 0;
    415        1.1     ragge }
    416        1.1     ragge 
    417        1.1     ragge /*
    418        1.1     ragge  * Start output on interface.  Get another datagram
    419        1.1     ragge  * to send from the interface queue and map it to
    420        1.1     ragge  * the interface before starting output.
    421        1.1     ragge  *
    422        1.1     ragge  * Must be called at spl 5
    423        1.1     ragge  */
    424        1.1     ragge void
    425        1.1     ragge dmcstart(struct ifnet *ifp)
    426        1.1     ragge {
    427        1.1     ragge 	struct dmc_softc *sc = ifp->if_softc;
    428        1.1     ragge 	struct mbuf *m;
    429        1.1     ragge 	struct dmcbufs *rp;
    430        1.1     ragge 	int n;
    431        1.1     ragge 
    432        1.1     ragge 	/*
    433        1.1     ragge 	 * Dequeue up to NXMT requests and map them to the UNIBUS.
    434        1.1     ragge 	 * If no more requests, or no dmc buffers available, just return.
    435        1.1     ragge 	 */
    436        1.1     ragge 	n = 0;
    437        1.1     ragge 	for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
    438        1.1     ragge 		/* find an available buffer */
    439        1.1     ragge 		if ((rp->flags & DBUF_DMCS) == 0) {
    440        1.3    itojun 			IFQ_DEQUEUE(&sc->sc_if.if_snd, m);
    441        1.1     ragge 			if (m == 0)
    442        1.1     ragge 				return;
    443        1.1     ragge 			/* mark it dmcs */
    444        1.1     ragge 			rp->flags |= (DBUF_DMCS);
    445        1.1     ragge 			/*
    446        1.1     ragge 			 * Have request mapped to UNIBUS for transmission
    447        1.1     ragge 			 * and start the output.
    448        1.1     ragge 			 */
    449        1.1     ragge 			rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m);
    450        1.1     ragge 			rp->cc &= DMC_CCOUNT;
    451        1.1     ragge 			if (++sc->sc_oused == 1)
    452        1.1     ragge 				sc->sc_if.if_timer = dmc_timeout;
    453        1.9    simonb 			dmcload(sc, DMC_WRITE, rp->ubinfo,
    454        1.1     ragge 				rp->cc | ((rp->ubinfo>>2)&DMC_XMEM));
    455        1.1     ragge 		}
    456        1.1     ragge 		n++;
    457        1.1     ragge 	}
    458        1.1     ragge }
    459        1.1     ragge 
    460        1.1     ragge /*
    461        1.1     ragge  * Utility routine to load the DMC device registers.
    462        1.1     ragge  */
    463        1.1     ragge void
    464        1.1     ragge dmcload(struct dmc_softc *sc, int type, u_short w0, u_short w1)
    465        1.1     ragge {
    466        1.1     ragge 	struct dmc_command *qp;
    467        1.1     ragge 	int sps;
    468        1.1     ragge 
    469        1.1     ragge 	sps = splnet();
    470        1.1     ragge 
    471        1.1     ragge 	/* grab a command buffer from the free list */
    472        1.1     ragge 	if ((qp = sc->sc_qfreeh) == (struct dmc_command *)0)
    473        1.1     ragge 		panic("dmc command queue overflow");
    474        1.1     ragge 	DEQUEUE(sc->sc_qfreeh, sc->sc_qfreet);
    475        1.1     ragge 
    476        1.1     ragge 	/* fill in requested info */
    477        1.1     ragge 	qp->qp_cmd = (type | DMC_RQI);
    478        1.1     ragge 	qp->qp_ubaddr = w0;
    479        1.1     ragge 	qp->qp_cc = w1;
    480        1.9    simonb 
    481        1.1     ragge 	if (sc->sc_qactive) {	/* command in progress */
    482        1.1     ragge 		if (type == DMC_READ) {
    483        1.1     ragge 			QUEUE_AT_HEAD(qp, sc->sc_qhead, sc->sc_qtail);
    484        1.1     ragge 		} else {
    485        1.1     ragge 			QUEUE_AT_TAIL(qp, sc->sc_qhead, sc->sc_qtail);
    486        1.1     ragge 		}
    487        1.1     ragge 	} else {	/* command port free */
    488        1.1     ragge 		sc->sc_qactive = qp;
    489        1.1     ragge 		DMC_WBYTE(DMC_BSEL0, qp->qp_cmd);
    490        1.1     ragge 		dmcrint(sc);
    491        1.1     ragge 	}
    492        1.1     ragge 	splx(sps);
    493        1.1     ragge }
    494        1.1     ragge 
    495        1.1     ragge /*
    496        1.1     ragge  * DMC interface receiver interrupt.
    497        1.1     ragge  * Ready to accept another command,
    498        1.1     ragge  * pull one off the command queue.
    499        1.1     ragge  */
    500        1.1     ragge void
    501        1.1     ragge dmcrint(void *arg)
    502        1.1     ragge {
    503        1.1     ragge 	struct dmc_softc *sc = arg;
    504        1.1     ragge 	struct dmc_command *qp;
    505        1.1     ragge 	int n;
    506        1.1     ragge 
    507        1.1     ragge 	if ((qp = sc->sc_qactive) == (struct dmc_command *) 0) {
    508       1.21       chs 		printf("%s: dmcrint no command\n", device_xname(sc->sc_dev));
    509        1.1     ragge 		return;
    510        1.1     ragge 	}
    511        1.1     ragge 	while (DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) {
    512        1.1     ragge 		DMC_WWORD(DMC_SEL4, qp->qp_ubaddr);
    513        1.1     ragge 		DMC_WWORD(DMC_SEL6, qp->qp_cc);
    514        1.1     ragge 		DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & ~(DMC_IEI|DMC_RQI));
    515        1.1     ragge 		/* free command buffer */
    516        1.1     ragge 		QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
    517        1.1     ragge 		while (DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) {
    518        1.1     ragge 			/*
    519        1.1     ragge 			 * Can't check for RDYO here 'cause
    520        1.1     ragge 			 * this routine isn't reentrant!
    521        1.1     ragge 			 */
    522        1.1     ragge 			DELAY(5);
    523        1.1     ragge 		}
    524        1.1     ragge 		/* move on to next command */
    525        1.1     ragge 		if ((sc->sc_qactive = sc->sc_qhead) == (struct dmc_command *)0)
    526        1.1     ragge 			break;		/* all done */
    527        1.1     ragge 		/* more commands to do, start the next one */
    528        1.1     ragge 		qp = sc->sc_qactive;
    529        1.1     ragge 		DEQUEUE(sc->sc_qhead, sc->sc_qtail);
    530        1.1     ragge 		DMC_WBYTE(DMC_BSEL0, qp->qp_cmd);
    531        1.1     ragge 		n = RDYSCAN;
    532        1.1     ragge 		while (n-- > 0)
    533        1.1     ragge 			if ((DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) ||
    534        1.1     ragge 			    (DMC_RBYTE(DMC_BSEL2) & DMC_RDYO))
    535        1.1     ragge 				break;
    536        1.1     ragge 	}
    537        1.1     ragge 	if (sc->sc_qactive) {
    538        1.1     ragge 		DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & (DMC_IEI|DMC_RQI));
    539        1.1     ragge 		/* VMS does it twice !*$%@# */
    540        1.1     ragge 		DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & (DMC_IEI|DMC_RQI));
    541        1.1     ragge 	}
    542        1.1     ragge 
    543        1.1     ragge }
    544        1.1     ragge 
    545        1.1     ragge /*
    546        1.1     ragge  * DMC interface transmitter interrupt.
    547        1.1     ragge  * A transfer may have completed, check for errors.
    548        1.1     ragge  * If it was a read, notify appropriate protocol.
    549        1.1     ragge  * If it was a write, pull the next one off the queue.
    550        1.1     ragge  */
    551        1.1     ragge void
    552        1.1     ragge dmcxint(void *a)
    553        1.1     ragge {
    554        1.9    simonb 	struct dmc_softc *sc = a;
    555        1.1     ragge 
    556        1.1     ragge 	struct ifnet *ifp;
    557        1.1     ragge 	struct mbuf *m;
    558        1.1     ragge 	int arg, pkaddr, cmd, len, s;
    559        1.1     ragge 	struct ifrw *ifrw;
    560        1.1     ragge 	struct dmcbufs *rp;
    561        1.1     ragge 	struct ifxmt *ifxp;
    562        1.1     ragge 	struct dmc_header *dh;
    563        1.1     ragge 	char buf[64];
    564        1.1     ragge 
    565        1.1     ragge 	ifp = &sc->sc_if;
    566        1.1     ragge 
    567        1.1     ragge 	while (DMC_RBYTE(DMC_BSEL2) & DMC_RDYO) {
    568        1.1     ragge 
    569        1.1     ragge 		cmd = DMC_RBYTE(DMC_BSEL2) & 0xff;
    570        1.1     ragge 		arg = DMC_RWORD(DMC_SEL6) & 0xffff;
    571        1.1     ragge 		/* reconstruct UNIBUS address of buffer returned to us */
    572        1.1     ragge 		pkaddr = ((arg&DMC_XMEM)<<2) | (DMC_RWORD(DMC_SEL4) & 0xffff);
    573        1.1     ragge 		/* release port */
    574        1.1     ragge 		DMC_WBYTE(DMC_BSEL2, DMC_RBYTE(DMC_BSEL2) & ~DMC_RDYO);
    575        1.1     ragge 		switch (cmd & 07) {
    576        1.1     ragge 
    577        1.1     ragge 		case DMC_OUR:
    578        1.1     ragge 			/*
    579        1.9    simonb 			 * A read has completed.
    580        1.1     ragge 			 * Pass packet to type specific
    581        1.1     ragge 			 * higher-level input routine.
    582        1.1     ragge 			 */
    583       1.28     skrll 			if_statinc(ifp, if_ipackets);
    584        1.1     ragge 			/* find location in dmcuba struct */
    585        1.1     ragge 			ifrw= &sc->sc_ifr[0];
    586        1.1     ragge 			for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
    587        1.1     ragge 				if(rp->ubinfo == pkaddr)
    588        1.1     ragge 					break;
    589        1.1     ragge 				ifrw++;
    590        1.1     ragge 			}
    591        1.1     ragge 			if (rp >= &sc->sc_rbufs[NRCV])
    592        1.1     ragge 				panic("dmc rcv");
    593        1.1     ragge 			if ((rp->flags & DBUF_DMCS) == 0)
    594       1.21       chs 				aprint_error_dev(sc->sc_dev, "done unalloc rbuf\n");
    595        1.1     ragge 
    596        1.1     ragge 			len = (arg & DMC_CCOUNT) - sizeof (struct dmc_header);
    597        1.1     ragge 			if (len < 0 || len > DMCMTU) {
    598       1.27     skrll 				if_statinc(ifp, if_ierrors);
    599        1.1     ragge #ifdef DMCDEBUG
    600        1.1     ragge 				printd("%s: bad rcv pkt addr 0x%x len 0x%x\n",
    601       1.21       chs 				    device_xname(sc->sc_dev), pkaddr, len);
    602        1.1     ragge #endif
    603        1.1     ragge 				goto setup;
    604        1.1     ragge 			}
    605        1.1     ragge 			/*
    606        1.1     ragge 			 * Deal with trailer protocol: if type is trailer
    607        1.1     ragge 			 * get true type from first 16-bit word past data.
    608        1.1     ragge 			 * Remember that type was trailer by setting off.
    609        1.1     ragge 			 */
    610        1.1     ragge 			dh = (struct dmc_header *)ifrw->ifrw_addr;
    611        1.1     ragge 			dh->dmc_type = ntohs((u_short)dh->dmc_type);
    612        1.1     ragge 			if (len == 0)
    613        1.1     ragge 				goto setup;
    614        1.1     ragge 
    615        1.1     ragge 			/*
    616        1.1     ragge 			 * Pull packet off interface.  Off is nonzero if
    617        1.1     ragge 			 * packet has trailing header; dmc_get will then
    618        1.1     ragge 			 * force this header information to be at the front,
    619        1.1     ragge 			 * but we still have to drop the type and length
    620        1.1     ragge 			 * which are at the front of any trailer data.
    621        1.1     ragge 			 */
    622        1.1     ragge 			m = if_ubaget(&sc->sc_ifuba, ifrw, ifp, len);
    623        1.1     ragge 			if (m == 0)
    624        1.1     ragge 				goto setup;
    625        1.1     ragge 			/* Shave off dmc_header */
    626        1.1     ragge 			m_adj(m, sizeof(struct dmc_header));
    627        1.1     ragge 			switch (dh->dmc_type) {
    628        1.1     ragge #ifdef INET
    629        1.1     ragge 			case DMC_IPTYPE:
    630        1.1     ragge 				break;
    631        1.1     ragge #endif
    632        1.1     ragge 			default:
    633        1.1     ragge 				m_freem(m);
    634        1.1     ragge 				goto setup;
    635        1.1     ragge 			}
    636        1.1     ragge 
    637        1.1     ragge 			s = splnet();
    638       1.23     rmind 			if (__predict_false(!pktq_enqueue(ip_pktq, m, 0))) {
    639        1.1     ragge 				m_freem(m);
    640       1.22   msaitoh 			}
    641        1.1     ragge 			splx(s);
    642        1.1     ragge 
    643        1.1     ragge 	setup:
    644        1.1     ragge 			/* is this needed? */
    645        1.1     ragge 			rp->ubinfo = ifrw->ifrw_info;
    646        1.1     ragge 
    647        1.9    simonb 			dmcload(sc, DMC_READ, rp->ubinfo,
    648        1.1     ragge 			    ((rp->ubinfo >> 2) & DMC_XMEM) | rp->cc);
    649        1.1     ragge 			break;
    650        1.1     ragge 
    651        1.1     ragge 		case DMC_OUX:
    652        1.1     ragge 			/*
    653        1.1     ragge 			 * A write has completed, start another
    654        1.1     ragge 			 * transfer if there is more data to send.
    655        1.1     ragge 			 */
    656       1.27     skrll 			if_statinc(ifp, if_opackets);
    657        1.1     ragge 			/* find associated dmcbuf structure */
    658        1.1     ragge 			ifxp = &sc->sc_ifw[0];
    659        1.1     ragge 			for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
    660        1.1     ragge 				if(rp->ubinfo == pkaddr)
    661        1.1     ragge 					break;
    662        1.1     ragge 				ifxp++;
    663        1.1     ragge 			}
    664        1.1     ragge 			if (rp >= &sc->sc_xbufs[NXMT]) {
    665       1.21       chs 				aprint_error_dev(sc->sc_dev, "bad packet address 0x%x\n",
    666       1.16    cegger 				    pkaddr);
    667        1.1     ragge 				break;
    668        1.1     ragge 			}
    669        1.1     ragge 			if ((rp->flags & DBUF_DMCS) == 0)
    670       1.21       chs 				aprint_error_dev(sc->sc_dev, "unallocated packet 0x%x\n",
    671       1.16    cegger 				    pkaddr);
    672        1.1     ragge 			/* mark buffer free */
    673        1.1     ragge 			if_ubaend(&sc->sc_ifuba, ifxp);
    674        1.1     ragge 			rp->flags &= ~DBUF_DMCS;
    675        1.1     ragge 			if (--sc->sc_oused == 0)
    676        1.1     ragge 				sc->sc_if.if_timer = 0;
    677        1.1     ragge 			else
    678        1.1     ragge 				sc->sc_if.if_timer = dmc_timeout;
    679        1.1     ragge 			if ((sc->sc_flag & DMC_ONLINE) == 0) {
    680        1.1     ragge 				extern int ifqmaxlen;
    681        1.1     ragge 
    682        1.1     ragge 				/*
    683        1.1     ragge 				 * We're on the air.
    684        1.1     ragge 				 * Open the queue to the usual value.
    685        1.1     ragge 				 */
    686        1.1     ragge 				sc->sc_flag |= DMC_ONLINE;
    687        1.1     ragge 				ifp->if_snd.ifq_maxlen = ifqmaxlen;
    688        1.1     ragge 			}
    689        1.1     ragge 			break;
    690        1.1     ragge 
    691        1.1     ragge 		case DMC_CNTLO:
    692        1.1     ragge 			arg &= DMC_CNTMASK;
    693        1.1     ragge 			if (arg & DMC_FATAL) {
    694        1.1     ragge 				if (arg != DMC_START) {
    695       1.18  christos 					snprintb(buf, sizeof(buf), CNTLO_BITS,
    696       1.18  christos 					    arg);
    697        1.1     ragge 					log(LOG_ERR,
    698        1.1     ragge 					    "%s: fatal error, flags=%s\n",
    699       1.21       chs 					    device_xname(sc->sc_dev), buf);
    700        1.1     ragge 				}
    701        1.1     ragge 				dmcrestart(sc);
    702        1.1     ragge 				break;
    703        1.1     ragge 			}
    704        1.1     ragge 			/* ACCUMULATE STATISTICS */
    705        1.1     ragge 			switch(arg) {
    706        1.1     ragge 			case DMC_NOBUFS:
    707       1.27     skrll 				if_statinc(ifp, if_ierrors);
    708        1.1     ragge 				if ((sc->sc_nobuf++ % DMC_RPNBFS) == 0)
    709        1.1     ragge 					goto report;
    710        1.1     ragge 				break;
    711        1.1     ragge 			case DMC_DISCONN:
    712        1.1     ragge 				if ((sc->sc_disc++ % DMC_RPDSC) == 0)
    713        1.1     ragge 					goto report;
    714        1.1     ragge 				break;
    715        1.1     ragge 			case DMC_TIMEOUT:
    716        1.1     ragge 				if ((sc->sc_timeo++ % DMC_RPTMO) == 0)
    717        1.1     ragge 					goto report;
    718        1.1     ragge 				break;
    719        1.1     ragge 			case DMC_DATACK:
    720       1.27     skrll 				if_statinc(ifp, if_oerrors);
    721        1.1     ragge 				if ((sc->sc_datck++ % DMC_RPDCK) == 0)
    722        1.1     ragge 					goto report;
    723        1.1     ragge 				break;
    724        1.1     ragge 			default:
    725        1.1     ragge 				goto report;
    726        1.1     ragge 			}
    727        1.1     ragge 			break;
    728        1.1     ragge 		report:
    729        1.1     ragge #ifdef DMCDEBUG
    730       1.18  christos 			snprintb(buf, sizeof(buf), CNTLO_BITS, arg);
    731        1.1     ragge 			printd("%s: soft error, flags=%s\n",
    732       1.21       chs 			    device_xname(sc->sc_dev), buf);
    733        1.1     ragge #endif
    734        1.1     ragge 			if ((sc->sc_flag & DMC_RESTART) == 0) {
    735        1.1     ragge 				/*
    736        1.1     ragge 				 * kill off the dmc to get things
    737        1.1     ragge 				 * going again by generating a
    738        1.1     ragge 				 * procedure error
    739        1.1     ragge 				 */
    740        1.1     ragge 				sc->sc_flag |= DMC_RESTART;
    741        1.1     ragge 				arg = sc->sc_ui.ui_baddr;
    742        1.1     ragge 				dmcload(sc, DMC_BASEI, arg, (arg>>2)&DMC_XMEM);
    743        1.1     ragge 			}
    744        1.1     ragge 			break;
    745        1.1     ragge 
    746        1.1     ragge 		default:
    747        1.9    simonb 			printf("%s: bad control %o\n",
    748       1.21       chs 			    device_xname(sc->sc_dev), cmd);
    749        1.1     ragge 			break;
    750        1.1     ragge 		}
    751        1.1     ragge 	}
    752        1.1     ragge 	dmcstart(ifp);
    753        1.1     ragge }
    754        1.1     ragge 
    755        1.1     ragge /*
    756        1.1     ragge  * DMC output routine.
    757        1.1     ragge  * Encapsulate a packet of type family for the dmc.
    758        1.1     ragge  * Use trailer local net encapsulation if enough data in first
    759        1.1     ragge  * packet leaves a multiple of 512 bytes of data in remainder.
    760        1.1     ragge  */
    761        1.1     ragge int
    762        1.1     ragge dmcoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
    763        1.1     ragge     struct rtentry *rt)
    764        1.1     ragge {
    765        1.1     ragge 	int type, error, s;
    766        1.1     ragge 	struct mbuf *m = m0;
    767        1.1     ragge 	struct dmc_header *dh;
    768        1.1     ragge 
    769        1.1     ragge 	if ((ifp->if_flags & IFF_UP) == 0) {
    770        1.1     ragge 		error = ENETDOWN;
    771        1.1     ragge 		goto bad;
    772        1.1     ragge 	}
    773        1.1     ragge 
    774       1.24  knakahar 	IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
    775        1.3    itojun 
    776        1.1     ragge 	switch (dst->sa_family) {
    777        1.1     ragge #ifdef	INET
    778        1.1     ragge 	case AF_INET:
    779        1.1     ragge 		type = DMC_IPTYPE;
    780        1.1     ragge 		break;
    781        1.1     ragge #endif
    782        1.1     ragge 
    783        1.1     ragge 	case AF_UNSPEC:
    784        1.1     ragge 		dh = (struct dmc_header *)dst->sa_data;
    785        1.1     ragge 		type = dh->dmc_type;
    786        1.1     ragge 		break;
    787        1.1     ragge 
    788        1.1     ragge 	default:
    789        1.1     ragge 		printf("%s: can't handle af%d\n", ifp->if_xname,
    790        1.1     ragge 			dst->sa_family);
    791        1.1     ragge 		error = EAFNOSUPPORT;
    792        1.1     ragge 		goto bad;
    793        1.1     ragge 	}
    794        1.1     ragge 
    795        1.1     ragge 	/*
    796        1.1     ragge 	 * Add local network header
    797        1.1     ragge 	 * (there is space for a uba on a vax to step on)
    798        1.1     ragge 	 */
    799        1.1     ragge 	M_PREPEND(m, sizeof(struct dmc_header), M_DONTWAIT);
    800        1.1     ragge 	if (m == 0) {
    801        1.1     ragge 		error = ENOBUFS;
    802        1.1     ragge 		goto bad;
    803        1.1     ragge 	}
    804        1.1     ragge 	dh = mtod(m, struct dmc_header *);
    805        1.1     ragge 	dh->dmc_type = htons((u_short)type);
    806        1.1     ragge 
    807        1.1     ragge 	/*
    808        1.1     ragge 	 * Queue message on interface, and start output if interface
    809        1.1     ragge 	 * not yet active.
    810        1.1     ragge 	 */
    811        1.1     ragge 	s = splnet();
    812       1.24  knakahar 	IFQ_ENQUEUE(&ifp->if_snd, m, error);
    813        1.3    itojun 	if (error) {
    814        1.3    itojun 		/* mbuf is already freed */
    815        1.1     ragge 		splx(s);
    816        1.3    itojun 		return (error);
    817        1.1     ragge 	}
    818        1.1     ragge 	dmcstart(ifp);
    819        1.1     ragge 	splx(s);
    820        1.1     ragge 	return (0);
    821        1.1     ragge 
    822        1.1     ragge bad:
    823        1.1     ragge 	m_freem(m0);
    824        1.1     ragge 	return (error);
    825        1.1     ragge }
    826        1.1     ragge 
    827        1.1     ragge 
    828        1.1     ragge /*
    829        1.1     ragge  * Process an ioctl request.
    830        1.1     ragge  */
    831        1.1     ragge /* ARGSUSED */
    832        1.1     ragge int
    833       1.14  christos dmcioctl(struct ifnet *ifp, u_long cmd, void *data)
    834        1.1     ragge {
    835        1.1     ragge 	int s = splnet(), error = 0;
    836        1.1     ragge 	register struct dmc_softc *sc = ifp->if_softc;
    837        1.1     ragge 
    838        1.1     ragge 	switch (cmd) {
    839        1.1     ragge 
    840       1.17    dyoung 	case SIOCINITIFADDR:
    841        1.1     ragge 		ifp->if_flags |= IFF_UP;
    842        1.1     ragge 		if ((ifp->if_flags & IFF_RUNNING) == 0)
    843        1.9    simonb 			dmcinit(ifp);
    844        1.1     ragge 		break;
    845        1.1     ragge 
    846        1.1     ragge 	case SIOCSIFDSTADDR:
    847        1.1     ragge 		if ((ifp->if_flags & IFF_RUNNING) == 0)
    848        1.9    simonb 			dmcinit(ifp);
    849        1.1     ragge 		break;
    850        1.9    simonb 
    851        1.1     ragge 	case SIOCSIFFLAGS:
    852       1.17    dyoung 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
    853       1.17    dyoung 			break;
    854        1.1     ragge 		if ((ifp->if_flags & IFF_UP) == 0 &&
    855        1.1     ragge 		    sc->sc_flag & DMC_RUNNING)
    856        1.1     ragge 			dmcdown(sc);
    857        1.1     ragge 		else if (ifp->if_flags & IFF_UP &&
    858        1.1     ragge 		    (sc->sc_flag & DMC_RUNNING) == 0)
    859        1.1     ragge 			dmcrestart(sc);
    860        1.1     ragge 		break;
    861        1.1     ragge 
    862        1.1     ragge 	default:
    863       1.17    dyoung 		error = ifioctl_common(ifp, cmd, data);
    864        1.1     ragge 	}
    865        1.1     ragge 	splx(s);
    866        1.1     ragge 	return (error);
    867        1.1     ragge }
    868        1.1     ragge 
    869        1.1     ragge /*
    870        1.1     ragge  * Restart after a fatal error.
    871        1.1     ragge  * Clear device and reinitialize.
    872        1.1     ragge  */
    873        1.1     ragge void
    874        1.1     ragge dmcrestart(struct dmc_softc *sc)
    875        1.1     ragge {
    876        1.1     ragge 	int s, i;
    877        1.9    simonb 
    878        1.1     ragge #ifdef DMCDEBUG
    879        1.1     ragge 	/* dump base table */
    880       1.21       chs 	printf("%s base table:\n", device_xname(sc->sc_dev));
    881        1.1     ragge 	for (i = 0; i < sizeof (struct dmc_base); i++)
    882        1.1     ragge 		printf("%o\n" ,dmc_base[unit].d_base[i]);
    883        1.1     ragge #endif
    884        1.1     ragge 
    885        1.1     ragge 	dmcdown(sc);
    886        1.1     ragge 
    887        1.1     ragge 	/*
    888        1.1     ragge 	 * Let the DMR finish the MCLR.	 At 1 Mbit, it should do so
    889        1.1     ragge 	 * in about a max of 6.4 milliseconds with diagnostics enabled.
    890        1.1     ragge 	 */
    891        1.1     ragge 	for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
    892        1.1     ragge 		;
    893        1.1     ragge 	/* Did the timer expire or did the DMR finish? */
    894        1.1     ragge 	if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
    895       1.21       chs 		log(LOG_ERR, "%s: M820 Test Failed\n", device_xname(sc->sc_dev));
    896        1.1     ragge 		return;
    897        1.1     ragge 	}
    898        1.1     ragge 
    899        1.1     ragge 	/* restart DMC */
    900        1.1     ragge 	dmcinit(&sc->sc_if);
    901        1.1     ragge 	sc->sc_flag &= ~DMC_RESTART;
    902        1.1     ragge 	s = splnet();
    903        1.1     ragge 	dmcstart(&sc->sc_if);
    904        1.1     ragge 	splx(s);
    905        1.1     ragge 	sc->sc_if.if_collisions++;	/* why not? */
    906        1.1     ragge }
    907        1.1     ragge 
    908        1.1     ragge /*
    909        1.1     ragge  * Reset a device and mark down.
    910        1.1     ragge  * Flush output queue and drop queue limit.
    911        1.1     ragge  */
    912        1.1     ragge void
    913        1.1     ragge dmcdown(struct dmc_softc *sc)
    914        1.1     ragge {
    915        1.1     ragge 	struct ifxmt *ifxp;
    916        1.1     ragge 
    917        1.1     ragge 	DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
    918        1.1     ragge 	sc->sc_flag &= ~(DMC_RUNNING | DMC_ONLINE);
    919        1.1     ragge 
    920        1.1     ragge 	for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) {
    921        1.1     ragge #ifdef notyet
    922  1.29.10.1  perseant 		m_freem(ifxp->ifw_xtofree);
    923  1.29.10.1  perseant 		ifxp->ifw_xtofree = NULL;
    924        1.1     ragge #endif
    925        1.1     ragge 	}
    926        1.1     ragge 	IF_PURGE(&sc->sc_if.if_snd);
    927        1.1     ragge }
    928        1.1     ragge 
    929        1.1     ragge /*
    930        1.1     ragge  * Watchdog timeout to see that transmitted packets don't
    931        1.1     ragge  * lose interrupts.  The device has to be online (the first
    932        1.1     ragge  * transmission may block until the other side comes up).
    933        1.1     ragge  */
    934        1.1     ragge void
    935        1.1     ragge dmctimeout(struct ifnet *ifp)
    936        1.1     ragge {
    937        1.1     ragge 	struct dmc_softc *sc = ifp->if_softc;
    938        1.1     ragge 	char buf1[64], buf2[64];
    939        1.1     ragge 
    940        1.1     ragge 	if (sc->sc_flag & DMC_ONLINE) {
    941       1.18  christos 		snprintb(buf1, sizeof(buf1), DMC0BITS,
    942       1.18  christos 		    DMC_RBYTE(DMC_BSEL0) & 0xff);
    943       1.18  christos 		snprintb(buf2, sizeof(buf2), DMC2BITS,
    944       1.18  christos 		    DMC_RBYTE(DMC_BSEL2) & 0xff);
    945        1.1     ragge 		log(LOG_ERR, "%s: output timeout, bsel0=%s bsel2=%s\n",
    946       1.21       chs 		    device_xname(sc->sc_dev), buf1, buf2);
    947        1.1     ragge 		dmcrestart(sc);
    948        1.1     ragge 	}
    949        1.1     ragge }
    950