[BACK]Return to if_dmc.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / qbus

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/qbus/if_dmc.c between version 1.1.2.1 and 1.1.2.2

version 1.1.2.1, 2001/05/06 17:36:04 version 1.1.2.2, 2001/06/21 20:05:26
Line 0 
Line 1 
   /*      $NetBSD$        */
   /*
    * Copyright (c) 1982, 1986 Regents of the University of California.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
    * 3. All advertising materials mentioning features or use of this software
    *    must display the following acknowledgement:
    *      This product includes software developed by the University of
    *      California, Berkeley and its contributors.
    * 4. Neither the name of the University nor the names of its contributors
    *    may be used to endorse or promote products derived from this software
    *    without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    * SUCH DAMAGE.
    *
    *      @(#)if_dmc.c    7.10 (Berkeley) 12/16/90
    */
   
   /*
    * DMC11 device driver, internet version
    *
    *      Bill Nesheim
    *      Cornell University
    *
    *      Lou Salkind
    *      New York University
    */
   
   #undef DMCDEBUG /* for base table dump on fatal error */
   
   #include "opt_inet.h"
   
   #include <sys/param.h>
   #include <sys/systm.h>
   #include <sys/mbuf.h>
   #include <sys/ioctl.h>
   #include <sys/socket.h>
   #include <sys/syslog.h>
   #include <sys/device.h>
   
   #include <net/if.h>
   #include <net/netisr.h>
   
   #ifdef  INET
   #include <netinet/in.h>
   #include <netinet/in_var.h>
   #endif
   
   #include <machine/bus.h>
   
   #include <dev/qbus/ubareg.h>
   #include <dev/qbus/ubavar.h>
   #include <dev/qbus/if_uba.h>
   
   #include <dev/qbus/if_dmcreg.h>
   
   
   /*
    * output timeout value, sec.; should depend on line speed.
    */
   static int dmc_timeout = 20;
   
   #define NRCV 7
   #define NXMT 3
   #define NCMDS   (NRCV+NXMT+4)   /* size of command queue */
   
   #define DMC_WBYTE(csr, val) \
           bus_space_write_1(sc->sc_iot, sc->sc_ioh, csr, val)
   #define DMC_WWORD(csr, val) \
           bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val)
   #define DMC_RBYTE(csr) \
           bus_space_read_1(sc->sc_iot, sc->sc_ioh, csr)
   #define DMC_RWORD(csr) \
           bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr)
   
   
   #ifdef DMCDEBUG
   #define printd if(dmcdebug)printf
   int dmcdebug = 0;
   #endif
   
   /* error reporting intervals */
   #define DMC_RPNBFS      50
   #define DMC_RPDSC       1
   #define DMC_RPTMO       10
   #define DMC_RPDCK       10
   
   struct  dmc_command {
           char    qp_cmd;         /* command */
           short   qp_ubaddr;      /* buffer address */
           short   qp_cc;          /* character count || XMEM */
           struct  dmc_command *qp_next;   /* next command on queue */
   };
   
   struct dmcbufs {
           int     ubinfo;         /* from uballoc */
           short   cc;             /* buffer size */
           short   flags;          /* access control */
   };
   #define DBUF_OURS       0       /* buffer is available */
   #define DBUF_DMCS       1       /* buffer claimed by somebody */
   #define DBUF_XMIT       4       /* transmit buffer */
   #define DBUF_RCV        8       /* receive buffer */
   
   
   /*
    * DMC 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  set of 7 UBA interface structures
    * for each, which
    * contain 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 dmc_softc {
           struct  device sc_dev;          /* Configuration common part */
           struct  ifnet sc_if;            /* network-visible interface */
           short   sc_oused;               /* output buffers currently in use */
           short   sc_iused;               /* input buffers given to DMC */
           short   sc_flag;                /* flags */
           struct  ubinfo sc_ui;           /* UBA mapping info for base table */
           int     sc_errors[4];           /* non-fatal error counters */
           bus_space_tag_t sc_iot;
           bus_addr_t sc_ioh;
           bus_dma_tag_t sc_dmat;
           struct  evcnt sc_rintrcnt;      /* Interrupt counting */
           struct  evcnt sc_tintrcnt;      /* Interrupt counting */
   #define sc_datck sc_errors[0]
   #define sc_timeo sc_errors[1]
   #define sc_nobuf sc_errors[2]
   #define sc_disc  sc_errors[3]
           struct  dmcbufs sc_rbufs[NRCV]; /* receive buffer info */
           struct  dmcbufs sc_xbufs[NXMT]; /* transmit buffer info */
           struct  ifubinfo sc_ifuba;      /* UNIBUS resources */
           struct  ifrw sc_ifr[NRCV];      /* UNIBUS receive buffer maps */
           struct  ifxmt sc_ifw[NXMT];     /* UNIBUS receive buffer maps */
           /* command queue stuff */
           struct  dmc_command sc_cmdbuf[NCMDS];
           struct  dmc_command *sc_qhead;  /* head of command queue */
           struct  dmc_command *sc_qtail;  /* tail of command queue */
           struct  dmc_command *sc_qactive;        /* command in progress */
           struct  dmc_command *sc_qfreeh; /* head of list of free cmd buffers */
           struct  dmc_command *sc_qfreet; /* tail of list of free cmd buffers */
           /* end command queue stuff */
           struct dmc_base {
                   short   d_base[128];            /* DMC base table */
           } dmc_base;
   };
   
   static  int dmcmatch(struct device *, struct cfdata *, void *);
   static  void dmcattach(struct device *, struct device *, void *);
   static  int dmcinit(struct ifnet *);
   static  void dmcrint(void *);
   static  void dmcxint(void *);
   static  void dmcdown(struct dmc_softc *sc);
   static  void dmcrestart(struct dmc_softc *);
   static  void dmcload(struct dmc_softc *, int, u_short, u_short);
   static  void dmcstart(struct ifnet *);
   static  void dmctimeout(struct ifnet *);
   static  int dmcioctl(struct ifnet *, u_long, caddr_t);
   static  int dmcoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
           struct rtentry *);
   static  void dmcreset(struct device *);
   
   struct  cfattach dmc_ca = {
           sizeof(struct dmc_softc), dmcmatch, dmcattach
   };
   
   /* flags */
   #define DMC_RUNNING     0x01            /* device initialized */
   #define DMC_BMAPPED     0x02            /* base table mapped */
   #define DMC_RESTART     0x04            /* software restart in progress */
   #define DMC_ONLINE      0x08            /* device running (had a RDYO) */
   
   
   /* queue manipulation macros */
   #define QUEUE_AT_HEAD(qp, head, tail) \
           (qp)->qp_next = (head); \
           (head) = (qp); \
           if ((tail) == (struct dmc_command *) 0) \
                   (tail) = (head)
   
   #define QUEUE_AT_TAIL(qp, head, tail) \
           if ((tail)) \
                   (tail)->qp_next = (qp); \
           else \
                   (head) = (qp); \
           (qp)->qp_next = (struct dmc_command *) 0; \
           (tail) = (qp)
   
   #define DEQUEUE(head, tail) \
           (head) = (head)->qp_next;\
           if ((head) == (struct dmc_command *) 0)\
                   (tail) = (head)
   
   int
   dmcmatch(struct device *parent, struct cfdata *cf, void *aux)
   {
           struct uba_attach_args *ua = aux;
           struct dmc_softc ssc;
           struct dmc_softc *sc = &ssc;
           int i;
   
           sc->sc_iot = ua->ua_iot;
           sc->sc_ioh = ua->ua_ioh;
   
           DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
           for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
                   ;
           if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
                   printf("dmcprobe: can't start device\n" );
                   return (0);
           }
           DMC_WBYTE(DMC_BSEL0, DMC_RQI|DMC_IEI);
           /* let's be paranoid */
           DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) | DMC_RQI|DMC_IEI);
           DELAY(1000000);
           DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
           for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
                   ;
           return (1);
   }
   
   /*
    * Interface exists: make available by filling in network interface
    * record.  System will initialize the interface when it is ready
    * to accept packets.
    */
   void
   dmcattach(struct device *parent, struct device *self, void *aux)
   {
           struct uba_attach_args *ua = aux;
           struct dmc_softc *sc = (struct dmc_softc *)self;
   
           sc->sc_iot = ua->ua_iot;
           sc->sc_ioh = ua->ua_ioh;
           sc->sc_dmat = ua->ua_dmat;
   
           strcpy(sc->sc_if.if_xname, sc->sc_dev.dv_xname);
           sc->sc_if.if_mtu = DMCMTU;
           sc->sc_if.if_init = dmcinit;
           sc->sc_if.if_output = dmcoutput;
           sc->sc_if.if_ioctl = dmcioctl;
           sc->sc_if.if_watchdog = dmctimeout;
           sc->sc_if.if_flags = IFF_POINTOPOINT;
           sc->sc_if.if_softc = sc;
   
           uba_intr_establish(ua->ua_icookie, ua->ua_cvec, dmcrint, sc,
               &sc->sc_rintrcnt);
           uba_intr_establish(ua->ua_icookie, ua->ua_cvec+4, dmcxint, sc,
               &sc->sc_tintrcnt);
           uba_reset_establish(dmcreset, &sc->sc_dev);
           evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
               sc->sc_dev.dv_xname, "intr");
           evcnt_attach_dynamic(&sc->sc_tintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
               sc->sc_dev.dv_xname, "intr");
   
           if_attach(&sc->sc_if);
   }
   
   /*
    * Reset of interface after UNIBUS reset.
    * If interface is on specified UBA, reset its state.
    */
   void
   dmcreset(struct device *dev)
   {
           struct dmc_softc *sc = (struct dmc_softc *)dev;
   
           sc->sc_flag = 0;
           sc->sc_if.if_flags &= ~IFF_RUNNING;
           dmcinit(&sc->sc_if);
   }
   
   /*
    * Initialization of interface; reinitialize UNIBUS usage.
    */
   int
   dmcinit(struct ifnet *ifp)
   {
           struct dmc_softc *sc = ifp->if_softc;
           struct ifrw *ifrw;
           struct ifxmt *ifxp;
           struct dmcbufs *rp;
           struct dmc_command *qp;
           struct ifaddr *ifa;
           struct cfdata *ui = sc->sc_dev.dv_cfdata;
           int base;
           int s;
   
           /*
            * Check to see that an address has been set
            * (both local and destination for an address family).
            */
           TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)
                   if (ifa->ifa_addr->sa_family && ifa->ifa_dstaddr->sa_family)
                           break;
           if (ifa == (struct ifaddr *) 0)
                   return 0;
   
           if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
                   printf("dmcinit: DMC not running\n");
                   ifp->if_flags &= ~IFF_UP;
                   return 0;
           }
           /* map base table */
           if ((sc->sc_flag & DMC_BMAPPED) == 0) {
                   sc->sc_ui.ui_size = sizeof(struct dmc_base);
                   sc->sc_ui.ui_vaddr = (caddr_t)&sc->dmc_base;
                   uballoc((void *)sc->sc_dev.dv_parent, &sc->sc_ui, 0);
                   sc->sc_flag |= DMC_BMAPPED;
           }
           /* initialize UNIBUS resources */
           sc->sc_iused = sc->sc_oused = 0;
           if ((ifp->if_flags & IFF_RUNNING) == 0) {
                   if (if_ubaminit(&sc->sc_ifuba, (void *)sc->sc_dev.dv_parent,
                       sizeof(struct dmc_header) + DMCMTU,
                       sc->sc_ifr, NRCV, sc->sc_ifw, NXMT) == 0) {
                           printf("%s: can't allocate uba resources\n",
                               sc->sc_dev.dv_xname);
                           ifp->if_flags &= ~IFF_UP;
                           return 0;
                   }
                   ifp->if_flags |= IFF_RUNNING;
           }
           sc->sc_flag &= ~DMC_ONLINE;
           sc->sc_flag |= DMC_RUNNING;
           /*
            * Limit packets enqueued until we see if we're on the air.
            */
           ifp->if_snd.ifq_maxlen = 3;
   
           /* initialize buffer pool */
           /* receives */
           ifrw = &sc->sc_ifr[0];
           for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
                   rp->ubinfo = ifrw->ifrw_info;
                   rp->cc = DMCMTU + sizeof (struct dmc_header);
                   rp->flags = DBUF_OURS|DBUF_RCV;
                   ifrw++;
           }
           /* transmits */
           ifxp = &sc->sc_ifw[0];
           for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
                   rp->ubinfo = ifxp->ifw_info;
                   rp->cc = 0;
                   rp->flags = DBUF_OURS|DBUF_XMIT;
                   ifxp++;
           }
   
           /* set up command queues */
           sc->sc_qfreeh = sc->sc_qfreet
                    = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
                   (struct dmc_command *)0;
           /* set up free command buffer list */
           for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) {
                   QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
           }
   
           /* base in */
           base = sc->sc_ui.ui_baddr;
           dmcload(sc, DMC_BASEI, (u_short)base, (base>>2) & DMC_XMEM);
           /* specify half duplex operation, flags tell if primary */
           /* or secondary station */
           if (ui->cf_flags == 0)
                   /* use DDCMP mode in full duplex */
                   dmcload(sc, DMC_CNTLI, 0, 0);
           else if (ui->cf_flags == 1)
                   /* use MAINTENENCE mode */
                   dmcload(sc, DMC_CNTLI, 0, DMC_MAINT );
           else if (ui->cf_flags == 2)
                   /* use DDCMP half duplex as primary station */
                   dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX);
           else if (ui->cf_flags == 3)
                   /* use DDCMP half duplex as secondary station */
                   dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC);
   
           /* enable operation done interrupts */
           while ((DMC_RBYTE(DMC_BSEL2) & DMC_IEO) == 0)
                   DMC_WBYTE(DMC_BSEL2, DMC_RBYTE(DMC_BSEL2) | DMC_IEO);
           s = splnet();
           /* queue first NRCV buffers for DMC to fill */
           for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
                   rp->flags |= DBUF_DMCS;
                   dmcload(sc, DMC_READ, rp->ubinfo,
                           (((rp->ubinfo>>2)&DMC_XMEM) | rp->cc));
                   sc->sc_iused++;
           }
           splx(s);
           return 0;
   }
   
   /*
    * Start output on interface.  Get another datagram
    * to send from the interface queue and map it to
    * the interface before starting output.
    *
    * Must be called at spl 5
    */
   void
   dmcstart(struct ifnet *ifp)
   {
           struct dmc_softc *sc = ifp->if_softc;
           struct mbuf *m;
           struct dmcbufs *rp;
           int n;
   
           /*
            * Dequeue up to NXMT requests and map them to the UNIBUS.
            * If no more requests, or no dmc buffers available, just return.
            */
           n = 0;
           for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
                   /* find an available buffer */
                   if ((rp->flags & DBUF_DMCS) == 0) {
                           IF_DEQUEUE(&sc->sc_if.if_snd, m);
                           if (m == 0)
                                   return;
                           /* mark it dmcs */
                           rp->flags |= (DBUF_DMCS);
                           /*
                            * Have request mapped to UNIBUS for transmission
                            * and start the output.
                            */
                           rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m);
                           rp->cc &= DMC_CCOUNT;
                           if (++sc->sc_oused == 1)
                                   sc->sc_if.if_timer = dmc_timeout;
                           dmcload(sc, DMC_WRITE, rp->ubinfo,
                                   rp->cc | ((rp->ubinfo>>2)&DMC_XMEM));
                   }
                   n++;
           }
   }
   
   /*
    * Utility routine to load the DMC device registers.
    */
   void
   dmcload(struct dmc_softc *sc, int type, u_short w0, u_short w1)
   {
           struct dmc_command *qp;
           int sps;
   
           sps = splnet();
   
           /* grab a command buffer from the free list */
           if ((qp = sc->sc_qfreeh) == (struct dmc_command *)0)
                   panic("dmc command queue overflow");
           DEQUEUE(sc->sc_qfreeh, sc->sc_qfreet);
   
           /* fill in requested info */
           qp->qp_cmd = (type | DMC_RQI);
           qp->qp_ubaddr = w0;
           qp->qp_cc = w1;
   
           if (sc->sc_qactive) {   /* command in progress */
                   if (type == DMC_READ) {
                           QUEUE_AT_HEAD(qp, sc->sc_qhead, sc->sc_qtail);
                   } else {
                           QUEUE_AT_TAIL(qp, sc->sc_qhead, sc->sc_qtail);
                   }
           } else {        /* command port free */
                   sc->sc_qactive = qp;
                   DMC_WBYTE(DMC_BSEL0, qp->qp_cmd);
                   dmcrint(sc);
           }
           splx(sps);
   }
   
   /*
    * DMC interface receiver interrupt.
    * Ready to accept another command,
    * pull one off the command queue.
    */
   void
   dmcrint(void *arg)
   {
           struct dmc_softc *sc = arg;
           struct dmc_command *qp;
           int n;
   
           if ((qp = sc->sc_qactive) == (struct dmc_command *) 0) {
                   printf("%s: dmcrint no command\n", sc->sc_dev.dv_xname);
                   return;
           }
           while (DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) {
                   DMC_WWORD(DMC_SEL4, qp->qp_ubaddr);
                   DMC_WWORD(DMC_SEL6, qp->qp_cc);
                   DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & ~(DMC_IEI|DMC_RQI));
                   /* free command buffer */
                   QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
                   while (DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) {
                           /*
                            * Can't check for RDYO here 'cause
                            * this routine isn't reentrant!
                            */
                           DELAY(5);
                   }
                   /* move on to next command */
                   if ((sc->sc_qactive = sc->sc_qhead) == (struct dmc_command *)0)
                           break;          /* all done */
                   /* more commands to do, start the next one */
                   qp = sc->sc_qactive;
                   DEQUEUE(sc->sc_qhead, sc->sc_qtail);
                   DMC_WBYTE(DMC_BSEL0, qp->qp_cmd);
                   n = RDYSCAN;
                   while (n-- > 0)
                           if ((DMC_RBYTE(DMC_BSEL0) & DMC_RDYI) ||
                               (DMC_RBYTE(DMC_BSEL2) & DMC_RDYO))
                                   break;
           }
           if (sc->sc_qactive) {
                   DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & (DMC_IEI|DMC_RQI));
                   /* VMS does it twice !*$%@# */
                   DMC_WBYTE(DMC_BSEL0, DMC_RBYTE(DMC_BSEL0) & (DMC_IEI|DMC_RQI));
           }
   
   }
   
   /*
    * DMC interface transmitter interrupt.
    * A transfer may have completed, check for errors.
    * If it was a read, notify appropriate protocol.
    * If it was a write, pull the next one off the queue.
    */
   void
   dmcxint(void *a)
   {
           struct dmc_softc *sc = a;
   
           struct ifnet *ifp;
           struct mbuf *m;
           struct ifqueue *inq;
           int arg, pkaddr, cmd, len, s;
           struct ifrw *ifrw;
           struct dmcbufs *rp;
           struct ifxmt *ifxp;
           struct dmc_header *dh;
           char buf[64];
   
           ifp = &sc->sc_if;
   
           while (DMC_RBYTE(DMC_BSEL2) & DMC_RDYO) {
   
                   cmd = DMC_RBYTE(DMC_BSEL2) & 0xff;
                   arg = DMC_RWORD(DMC_SEL6) & 0xffff;
                   /* reconstruct UNIBUS address of buffer returned to us */
                   pkaddr = ((arg&DMC_XMEM)<<2) | (DMC_RWORD(DMC_SEL4) & 0xffff);
                   /* release port */
                   DMC_WBYTE(DMC_BSEL2, DMC_RBYTE(DMC_BSEL2) & ~DMC_RDYO);
                   switch (cmd & 07) {
   
                   case DMC_OUR:
                           /*
                            * A read has completed.
                            * Pass packet to type specific
                            * higher-level input routine.
                            */
                           ifp->if_ipackets++;
                           /* find location in dmcuba struct */
                           ifrw= &sc->sc_ifr[0];
                           for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
                                   if(rp->ubinfo == pkaddr)
                                           break;
                                   ifrw++;
                           }
                           if (rp >= &sc->sc_rbufs[NRCV])
                                   panic("dmc rcv");
                           if ((rp->flags & DBUF_DMCS) == 0)
                                   printf("%s: done unalloc rbuf\n",
                                       sc->sc_dev.dv_xname);
   
                           len = (arg & DMC_CCOUNT) - sizeof (struct dmc_header);
                           if (len < 0 || len > DMCMTU) {
                                   ifp->if_ierrors++;
   #ifdef DMCDEBUG
                                   printd("%s: bad rcv pkt addr 0x%x len 0x%x\n",
                                       sc->sc_dev.dv_xname, pkaddr, len);
   #endif
                                   goto setup;
                           }
                           /*
                            * Deal with trailer protocol: if type is trailer
                            * get true type from first 16-bit word past data.
                            * Remember that type was trailer by setting off.
                            */
                           dh = (struct dmc_header *)ifrw->ifrw_addr;
                           dh->dmc_type = ntohs((u_short)dh->dmc_type);
                           if (len == 0)
                                   goto setup;
   
                           /*
                            * Pull packet off interface.  Off is nonzero if
                            * packet has trailing header; dmc_get 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_ubaget(&sc->sc_ifuba, ifrw, ifp, len);
                           if (m == 0)
                                   goto setup;
                           /* Shave off dmc_header */
                           m_adj(m, sizeof(struct dmc_header));
                           switch (dh->dmc_type) {
   
   #ifdef INET
                           case DMC_IPTYPE:
                                   schednetisr(NETISR_IP);
                                   inq = &ipintrq;
                                   break;
   #endif
                           default:
                                   m_freem(m);
                                   goto setup;
                           }
   
                           s = splnet();
                           if (IF_QFULL(inq)) {
                                   IF_DROP(inq);
                                   m_freem(m);
                           } else
                                   IF_ENQUEUE(inq, m);
                           splx(s);
   
           setup:
                           /* is this needed? */
                           rp->ubinfo = ifrw->ifrw_info;
   
                           dmcload(sc, DMC_READ, rp->ubinfo,
                               ((rp->ubinfo >> 2) & DMC_XMEM) | rp->cc);
                           break;
   
                   case DMC_OUX:
                           /*
                            * A write has completed, start another
                            * transfer if there is more data to send.
                            */
                           ifp->if_opackets++;
                           /* find associated dmcbuf structure */
                           ifxp = &sc->sc_ifw[0];
                           for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
                                   if(rp->ubinfo == pkaddr)
                                           break;
                                   ifxp++;
                           }
                           if (rp >= &sc->sc_xbufs[NXMT]) {
                                   printf("%s: bad packet address 0x%x\n",
                                       sc->sc_dev.dv_xname, pkaddr);
                                   break;
                           }
                           if ((rp->flags & DBUF_DMCS) == 0)
                                   printf("%s: unallocated packet 0x%x\n",
                                       sc->sc_dev.dv_xname, pkaddr);
                           /* mark buffer free */
                           if_ubaend(&sc->sc_ifuba, ifxp);
                           rp->flags &= ~DBUF_DMCS;
                           if (--sc->sc_oused == 0)
                                   sc->sc_if.if_timer = 0;
                           else
                                   sc->sc_if.if_timer = dmc_timeout;
                           if ((sc->sc_flag & DMC_ONLINE) == 0) {
                                   extern int ifqmaxlen;
   
                                   /*
                                    * We're on the air.
                                    * Open the queue to the usual value.
                                    */
                                   sc->sc_flag |= DMC_ONLINE;
                                   ifp->if_snd.ifq_maxlen = ifqmaxlen;
                           }
                           break;
   
                   case DMC_CNTLO:
                           arg &= DMC_CNTMASK;
                           if (arg & DMC_FATAL) {
                                   if (arg != DMC_START) {
                                           bitmask_snprintf(arg, CNTLO_BITS,
                                               buf, sizeof(buf));
                                           log(LOG_ERR,
                                               "%s: fatal error, flags=%s\n",
                                               sc->sc_dev.dv_xname, buf);
                                   }
                                   dmcrestart(sc);
                                   break;
                           }
                           /* ACCUMULATE STATISTICS */
                           switch(arg) {
                           case DMC_NOBUFS:
                                   ifp->if_ierrors++;
                                   if ((sc->sc_nobuf++ % DMC_RPNBFS) == 0)
                                           goto report;
                                   break;
                           case DMC_DISCONN:
                                   if ((sc->sc_disc++ % DMC_RPDSC) == 0)
                                           goto report;
                                   break;
                           case DMC_TIMEOUT:
                                   if ((sc->sc_timeo++ % DMC_RPTMO) == 0)
                                           goto report;
                                   break;
                           case DMC_DATACK:
                                   ifp->if_oerrors++;
                                   if ((sc->sc_datck++ % DMC_RPDCK) == 0)
                                           goto report;
                                   break;
                           default:
                                   goto report;
                           }
                           break;
                   report:
   #ifdef DMCDEBUG
                           bitmask_snprintf(arg, CNTLO_BITS, buf, sizeof(buf));
                           printd("%s: soft error, flags=%s\n",
                               sc->sc_dev.dv_xname, buf);
   #endif
                           if ((sc->sc_flag & DMC_RESTART) == 0) {
                                   /*
                                    * kill off the dmc to get things
                                    * going again by generating a
                                    * procedure error
                                    */
                                   sc->sc_flag |= DMC_RESTART;
                                   arg = sc->sc_ui.ui_baddr;
                                   dmcload(sc, DMC_BASEI, arg, (arg>>2)&DMC_XMEM);
                           }
                           break;
   
                   default:
                           printf("%s: bad control %o\n",
                               sc->sc_dev.dv_xname, cmd);
                           break;
                   }
           }
           dmcstart(ifp);
   }
   
   /*
    * DMC output routine.
    * Encapsulate a packet of type family for the dmc.
    * Use trailer local net encapsulation if enough data in first
    * packet leaves a multiple of 512 bytes of data in remainder.
    */
   int
   dmcoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
       struct rtentry *rt)
   {
           int type, error, s;
           struct mbuf *m = m0;
           struct dmc_header *dh;
   
           if ((ifp->if_flags & IFF_UP) == 0) {
                   error = ENETDOWN;
                   goto bad;
           }
   
           switch (dst->sa_family) {
   #ifdef  INET
           case AF_INET:
                   type = DMC_IPTYPE;
                   break;
   #endif
   
           case AF_UNSPEC:
                   dh = (struct dmc_header *)dst->sa_data;
                   type = dh->dmc_type;
                   break;
   
           default:
                   printf("%s: can't handle af%d\n", ifp->if_xname,
                           dst->sa_family);
                   error = EAFNOSUPPORT;
                   goto bad;
           }
   
           /*
            * Add local network header
            * (there is space for a uba on a vax to step on)
            */
           M_PREPEND(m, sizeof(struct dmc_header), M_DONTWAIT);
           if (m == 0) {
                   error = ENOBUFS;
                   goto bad;
           }
           dh = mtod(m, struct dmc_header *);
           dh->dmc_type = htons((u_short)type);
   
           /*
            * Queue message on interface, and start output if interface
            * not yet active.
            */
           s = splnet();
           if (IF_QFULL(&ifp->if_snd)) {
                   IF_DROP(&ifp->if_snd);
                   m_freem(m);
                   splx(s);
                   return (ENOBUFS);
           }
           IF_ENQUEUE(&ifp->if_snd, m);
           dmcstart(ifp);
           splx(s);
           return (0);
   
   bad:
           m_freem(m0);
           return (error);
   }
   
   
   /*
    * Process an ioctl request.
    */
   /* ARGSUSED */
   int
   dmcioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
   {
           int s = splnet(), error = 0;
           register struct dmc_softc *sc = ifp->if_softc;
   
           switch (cmd) {
   
           case SIOCSIFADDR:
                   ifp->if_flags |= IFF_UP;
                   if ((ifp->if_flags & IFF_RUNNING) == 0)
                           dmcinit(ifp);
                   break;
   
           case SIOCSIFDSTADDR:
                   if ((ifp->if_flags & IFF_RUNNING) == 0)
                           dmcinit(ifp);
                   break;
   
           case SIOCSIFFLAGS:
                   if ((ifp->if_flags & IFF_UP) == 0 &&
                       sc->sc_flag & DMC_RUNNING)
                           dmcdown(sc);
                   else if (ifp->if_flags & IFF_UP &&
                       (sc->sc_flag & DMC_RUNNING) == 0)
                           dmcrestart(sc);
                   break;
   
           default:
                   error = EINVAL;
           }
           splx(s);
           return (error);
   }
   
   /*
    * Restart after a fatal error.
    * Clear device and reinitialize.
    */
   void
   dmcrestart(struct dmc_softc *sc)
   {
           int s, i;
   
   #ifdef DMCDEBUG
           /* dump base table */
           printf("%s base table:\n", sc->sc_dev.dv_xname);
           for (i = 0; i < sizeof (struct dmc_base); i++)
                   printf("%o\n" ,dmc_base[unit].d_base[i]);
   #endif
   
           dmcdown(sc);
   
           /*
            * Let the DMR finish the MCLR.  At 1 Mbit, it should do so
            * in about a max of 6.4 milliseconds with diagnostics enabled.
            */
           for (i = 100000; i && (DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0; i--)
                   ;
           /* Did the timer expire or did the DMR finish? */
           if ((DMC_RBYTE(DMC_BSEL1) & DMC_RUN) == 0) {
                   log(LOG_ERR, "%s: M820 Test Failed\n", sc->sc_dev.dv_xname);
                   return;
           }
   
           /* restart DMC */
           dmcinit(&sc->sc_if);
           sc->sc_flag &= ~DMC_RESTART;
           s = splnet();
           dmcstart(&sc->sc_if);
           splx(s);
           sc->sc_if.if_collisions++;      /* why not? */
   }
   
   /*
    * Reset a device and mark down.
    * Flush output queue and drop queue limit.
    */
   void
   dmcdown(struct dmc_softc *sc)
   {
           struct ifxmt *ifxp;
   
           DMC_WBYTE(DMC_BSEL1, DMC_MCLR);
           sc->sc_flag &= ~(DMC_RUNNING | DMC_ONLINE);
   
           for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) {
   #ifdef notyet
                   if (ifxp->ifw_xtofree) {
                           (void) m_freem(ifxp->ifw_xtofree);
                           ifxp->ifw_xtofree = 0;
                   }
   #endif
           }
           IF_PURGE(&sc->sc_if.if_snd);
   }
   
   /*
    * Watchdog timeout to see that transmitted packets don't
    * lose interrupts.  The device has to be online (the first
    * transmission may block until the other side comes up).
    */
   void
   dmctimeout(struct ifnet *ifp)
   {
           struct dmc_softc *sc = ifp->if_softc;
           char buf1[64], buf2[64];
   
           if (sc->sc_flag & DMC_ONLINE) {
                   bitmask_snprintf(DMC_RBYTE(DMC_BSEL0) & 0xff, DMC0BITS,
                       buf1, sizeof(buf1));
                   bitmask_snprintf(DMC_RBYTE(DMC_BSEL2) & 0xff, DMC2BITS,
                       buf2, sizeof(buf2));
                   log(LOG_ERR, "%s: output timeout, bsel0=%s bsel2=%s\n",
                       sc->sc_dev.dv_xname, buf1, buf2);
                   dmcrestart(sc);
           }
   }

Legend:
Removed from v.1.1.2.1  
changed lines
  Added in v.1.1.2.2

CVSweb <webmaster@jp.NetBSD.org>