root/dev/pci/if_lmc.c

DEFINITIONS

1. lmc_delay_300ns
2. lmc_srom_idle
3. lmc_srom_read
4. lmc_mii_writebits
5. lmc_mii_turnaround
6. lmc_mii_readbits
7. lmc_mii_readreg
8. lmc_mii_writereg
9. lmc_read_macaddr
10. lmc_watchdog
11. lmc_ifup
12. lmc_ifdown
13. lmc_rx_intr
14. lmc_tx_intr
15. lmc_print_abnormal_interrupt
16. lmc_intr_handler
17. lmc_intr_normal
18. lmc_mbuf_compress
19. lmc_txput
20. lmc_ifioctl
21. lmc_ifstart
22. lmc_ifstart_one
23. lmc_attach
24. lmc_initring

    1 /*      $OpenBSD: if_lmc.c,v 1.23 2006/05/13 19:10:02 brad Exp $ */
    2 /*      $NetBSD: if_lmc.c,v 1.1 1999/03/25 03:32:43 explorer Exp $      */
    4 /*-
    5  * Copyright (c) 1997-1999 LAN Media Corporation (LMC)
    6  * All rights reserved.  www.lanmedia.com
    7  *
    8  * This code is written by Michael Graff <graff@vix.com> for LMC.
    9  * The code is derived from permitted modifications to software created
   10  * by Matt Thomas (matt@3am-software.com).
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above
   18  *    copyright notice, this list of conditions and the following disclaimer
   19  *    in the documentation and/or other materials provided with the
   20  *    distribution.
   21  * 3. All marketing or advertising materials mentioning features or
   22  *    use of this software must display the following acknowledgement:
   23  *      This product includes software developed by LAN Media Corporation
   24  *      and its contributors.
   25  * 4. Neither the name of LAN Media Corporation nor the names of its
   26  *    contributors may be used to endorse or promote products derived
   27  *    from this software without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY LAN MEDIA CORPORATION AND CONTRIBUTORS
   30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   33  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   39  * THE POSSIBILITY OF SUCH DAMAGE.
   40  */
   42 /*-
   43  * Copyright (c) 1994-1997 Matt Thomas (matt@3am-software.com)
   44  * All rights reserved.
   45  *
   46  * Redistribution and use in source and binary forms, with or without
   47  * modification, are permitted provided that the following conditions
   48  * are met:
   49  * 1. Redistributions of source code must retain the above copyright
   50  *    notice, this list of conditions and the following disclaimer.
   51  * 2. The name of the author may not be used to endorse or promote products
   52  *    derived from this software without specific prior written permission
   53  *
   54  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   55  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   56  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   57  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   58  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   59  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   60  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   61  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   63  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   64  */
   66 /*
   67  * LMC1200 (DS1) & LMC5245 (DS3) LED definitions
   68  * led0 yellow = far-end link is in Red alarm condition
   69  * led1 blue   = received an Alarm Indication signal (upstream failure)
   70  * led2 Green  = power to adapter, Gate Array loaded & driver attached
   71  * led3 red    = Loss of Signal (LOS) or out of frame (OOF) conditions
   72  *               detected on T3 receive signal
   73  *
   74  * LMC1000 (SSI) & LMC5200 (HSSI) LED definitions
   75  * led0 Green  = power to adapter, Gate Array loaded & driver attached
   76  * led1 Green  = DSR and DTR and RTS and CTS are set (CA, TA for LMC5200)
   77  * led2 Green  = Cable detected (Green indicates non-loopback mode for LMC5200)
   78  * led3 red    = No timing is available from the cable or the on-board
   79  *               frequency generator. (ST not available for LMC5200)
   80  */
   82 #include "bpfilter.h"
   84 #include <sys/param.h>
   85 #include <sys/systm.h>
   86 #include <sys/mbuf.h>
   87 #include <sys/socket.h>
   88 #include <sys/ioctl.h>
   89 #include <sys/errno.h>
   90 #include <sys/malloc.h>
   91 #include <sys/kernel.h>
   92 #include <sys/proc.h>
   93 #include <sys/device.h>
   95 #include <dev/pci/pcidevs.h>
   97 #include <net/if.h>
   98 #include <net/if_types.h>
   99 #include <net/if_dl.h>
  100 #include <net/netisr.h>
  102 #if NBPFILTER > 0
  103 #include <net/bpf.h>
  104 #endif
  106 #include <net/if_sppp.h>
  108 #include <machine/bus.h>
  110 #include <dev/pci/pcireg.h>
  111 #include <dev/pci/pcivar.h>
  112 #include <dev/ic/dc21040reg.h>
  114 #include <dev/pci/if_lmc_types.h>
  115 #include <dev/pci/if_lmcioctl.h>
  116 #include <dev/pci/if_lmcvar.h>
  118 /*
  119  * This module supports
  120  *      the DEC 21140A pass 2.2 PCI Fast Ethernet Controller.
  121  */
  122 static ifnet_ret_t lmc_ifstart_one(struct ifnet *ifp);
  123 static ifnet_ret_t lmc_ifstart(struct ifnet *ifp);
  124 static struct mbuf *lmc_txput(lmc_softc_t * const sc, struct mbuf *m);
  125 static void lmc_rx_intr(lmc_softc_t * const sc);
  127 static void lmc_watchdog(struct ifnet *ifp);
  128 static void lmc_ifup(lmc_softc_t * const sc);
  129 static void lmc_ifdown(lmc_softc_t * const sc);
  131 /*
  132  * Code the read the SROM and MII bit streams (I2C)
  133  */
  134 static inline void
lmc_delay_300ns(lmc_softc_t * const sc)
  136 {
  137         int idx;
  138         for (idx = (300 / 33) + 1; idx > 0; idx--)
  139                 (void)LMC_CSR_READ(sc, csr_busmode);
  140 }
  142 #define EMIT    \
  143 do { \
LMC_CSR_WRITE(sc, csr_srom_mii, csr); \
lmc_delay_300ns(sc); \
  146 } while (0)
  148 static inline void
lmc_srom_idle(lmc_softc_t * const sc)
  150 {
  151         unsigned bit, csr;
csr  = SROMSEL ; EMIT;
csr  = SROMSEL | SROMRD; EMIT;  
csr ^= SROMCS; EMIT;
csr ^= SROMCLKON; EMIT;
  158         /*
  159          * Write 25 cycles of 0 which will force the SROM to be idle.
  160          */
  161         for (bit = 3 + SROM_BITWIDTH + 16; bit > 0; bit--) {
csr ^= SROMCLKOFF; EMIT;    /* clock low; data not valid */
csr ^= SROMCLKON; EMIT;     /* clock high; data valid */
  164         }
csr ^= SROMCLKOFF; EMIT;
csr ^= SROMCS; EMIT;
csr  = 0; EMIT;
  168 }
  171 static void
lmc_srom_read(lmc_softc_t * const sc)
  173 {   
  174         unsigned idx; 
  175         const unsigned bitwidth = SROM_BITWIDTH;
  176         const unsigned cmdmask = (SROMCMD_RD << bitwidth);
  177         const unsigned msb = 1 << (bitwidth + 3 - 1);
  178         unsigned lastidx = (1 << bitwidth) - 1;
lmc_srom_idle(sc);
  182         for (idx = 0; idx <= lastidx; idx++) {
  183                 unsigned lastbit, data, bits, bit, csr;
csr  = SROMSEL ;                EMIT;
csr  = SROMSEL | SROMRD;        EMIT;
csr ^= SROMCSON;                EMIT;
csr ^=            SROMCLKON;    EMIT;
lastbit = 0;
  190                 for (bits = idx|cmdmask, bit = bitwidth + 3
  191                              ; bit > 0
  192                              ; bit--, bits <<= 1) {
  193                         const unsigned thisbit = bits & msb;
csr ^= SROMCLKOFF; EMIT;    /* clock L data invalid */
  195                         if (thisbit != lastbit) {
csr ^= SROMDOUT; EMIT;/* clock L invert data */
  197                         } else {
EMIT;
  199                         }
csr ^= SROMCLKON; EMIT;     /* clock H data valid */
lastbit = thisbit;
  202                 }
csr ^= SROMCLKOFF; EMIT;
  205                 for (data = 0, bits = 0; bits < 16; bits++) {
data <<= 1;
csr ^= SROMCLKON; EMIT;     /* clock H data valid */ 
data |= LMC_CSR_READ(sc, csr_srom_mii) & SROMDIN ? 1 : 0;
csr ^= SROMCLKOFF; EMIT;    /* clock L data invalid */
  210                 }
sc->lmc_rombuf[idx*2] = data & 0xFF;
sc->lmc_rombuf[idx*2+1] = data >> 8;
csr  = SROMSEL | SROMRD; EMIT;
csr  = 0; EMIT;
  215         }
lmc_srom_idle(sc);
  217 }
  219 #define MII_EMIT    do { LMC_CSR_WRITE(sc, csr_srom_mii, csr); lmc_delay_300ns(sc); } while (0)
  221 static inline void
lmc_mii_writebits(lmc_softc_t * const sc, unsigned data, unsigned bits)
  223 {
  224     unsigned msb = 1 << (bits - 1);
  225     unsigned csr = LMC_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
  226     unsigned lastbit = (csr & MII_DOUT) ? msb : 0;
csr |= MII_WR; MII_EMIT;            /* clock low; assert write */
  230     for (; bits > 0; bits--, data <<= 1) {
  231         const unsigned thisbit = data & msb;
  232         if (thisbit != lastbit) {
csr ^= MII_DOUT; MII_EMIT;  /* clock low; invert data */
  234         }
csr ^= MII_CLKON; MII_EMIT;     /* clock high; data valid */
lastbit = thisbit;
csr ^= MII_CLKOFF; MII_EMIT;    /* clock low; data not valid */
  238     }
  239 }
  241 static void
lmc_mii_turnaround(lmc_softc_t * const sc, u_int32_t cmd)
  243 {
u_int32_t csr;
csr = LMC_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
  247     if (cmd == MII_WRCMD) {
csr |= MII_DOUT; MII_EMIT;      /* clock low; change data */
csr ^= MII_CLKON; MII_EMIT;     /* clock high; data valid */
csr ^= MII_CLKOFF; MII_EMIT;    /* clock low; data not valid */
csr ^= MII_DOUT; MII_EMIT;      /* clock low; change data */
  252     } else {
csr |= MII_RD; MII_EMIT;        /* clock low; switch to read */
  254     }
csr ^= MII_CLKON; MII_EMIT;         /* clock high; data valid */
csr ^= MII_CLKOFF; MII_EMIT;        /* clock low; data not valid */
  257 }
  259 static u_int32_t
lmc_mii_readbits(lmc_softc_t * const sc)
  261 {
u_int32_t data;
u_int32_t csr = LMC_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
  264     int idx;
  266     for (idx = 0, data = 0; idx < 16; idx++) {
data <<= 1;     /* this is NOOP on the first pass through */
csr ^= MII_CLKON; MII_EMIT;     /* clock high; data valid */
  269         if (LMC_CSR_READ(sc, csr_srom_mii) & MII_DIN)
data |= 1;
csr ^= MII_CLKOFF; MII_EMIT;    /* clock low; data not valid */
  272     }
csr ^= MII_RD; MII_EMIT;            /* clock low; turn off read */
  275     return data;
  276 }
u_int32_t
lmc_mii_readreg(lmc_softc_t * const sc, u_int32_t devaddr, u_int32_t regno)
  280 {
u_int32_t csr = LMC_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
u_int32_t data;
csr &= ~(MII_RD|MII_CLK); MII_EMIT;
lmc_mii_writebits(sc, MII_PREAMBLE, 32);
lmc_mii_writebits(sc, MII_RDCMD, 8);
lmc_mii_writebits(sc, devaddr, 5);
lmc_mii_writebits(sc, regno, 5);
lmc_mii_turnaround(sc, MII_RDCMD);
data = lmc_mii_readbits(sc);
  292     return (data);
  293 }
  295 void
lmc_mii_writereg(lmc_softc_t * const sc, u_int32_t devaddr,
u_int32_t regno, u_int32_t data)
  298 {
u_int32_t csr;
csr = LMC_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
csr &= ~(MII_RD|MII_CLK); MII_EMIT;
lmc_mii_writebits(sc, MII_PREAMBLE, 32);
lmc_mii_writebits(sc, MII_WRCMD, 8);
lmc_mii_writebits(sc, devaddr, 5);
lmc_mii_writebits(sc, regno, 5);
lmc_mii_turnaround(sc, MII_WRCMD);
lmc_mii_writebits(sc, data, 16);
  309 }
  311 int
lmc_read_macaddr(lmc_softc_t * const sc)
  313 {
lmc_srom_read(sc);
bcopy(sc->lmc_rombuf + 20, sc->lmc_enaddr, 6);
  318         return 0;
  319 }
  321 /*
  322  * Check to make certain there is a signal from the modem, and flicker
  323  * lights as needed.
  324  */
  325 static void
lmc_watchdog(struct ifnet *ifp)
  327 {
lmc_softc_t * const sc = LMC_IFP_TO_SOFTC(ifp);
  329         int state;
u_int32_t ostatus;
u_int32_t link_status;
u_int32_t ticks;
state = 0;
  336         /*
  337          * Make sure the tx jabber and rx watchdog are off,
  338          * and the transmit and receive processes are running.
  339          */
LMC_CSR_WRITE (sc, csr_15, 0x00000011);
sc->lmc_cmdmode |= TULIP_CMD_TXRUN | TULIP_CMD_RXRUN;
LMC_CSR_WRITE (sc, csr_command, sc->lmc_cmdmode);
  344         /* Is the transmit clock still available? */
ticks = LMC_CSR_READ (sc, csr_gp_timer);
ticks = 0x0000ffff - (ticks & 0x0000ffff);
  347         if (ticks == 0)
  348         {
  349                 /* no clock found ? */
  350                 if (sc->tx_clockState != 0)
  351                 {
sc->tx_clockState = 0;
  353                         if (sc->lmc_cardtype == LMC_CARDTYPE_SSI)
lmc_led_on (sc, LMC_MII16_LED3); /* ON red */
  355                 }
  356         else
  357                 if (sc->tx_clockState == 0)
  358                 {
sc->tx_clockState = 1;
  360                         if (sc->lmc_cardtype == LMC_CARDTYPE_SSI)
lmc_led_off (sc, LMC_MII16_LED3); /* OFF red */
  362                 }
  363         }
link_status = sc->lmc_media->get_link_status(sc);
ostatus = ((sc->lmc_flags & LMC_MODEMOK) == LMC_MODEMOK);
  368         /*
  369          * hardware level link lost, but the interface is marked as up.
  370          * Mark it as down.
  371          */
  372         if (link_status == LMC_LINK_DOWN && ostatus) {
printf(LMC_PRINTF_FMT ": physical link down\n",
LMC_PRINTF_ARGS);
sc->lmc_flags &= ~LMC_MODEMOK;
  376                 if (sc->lmc_cardtype == LMC_CARDTYPE_DS3 ||
sc->lmc_cardtype == LMC_CARDTYPE_T1)
lmc_led_on (sc, LMC_DS3_LED3 | LMC_DS3_LED2);
  379                                                         /* turn on red LED */
  380                 else {
lmc_led_off (sc, LMC_MII16_LED1);
lmc_led_on (sc, LMC_MII16_LED0);
  383                         if (sc->lmc_timing == LMC_CTL_CLOCK_SOURCE_EXT)
lmc_led_on (sc, LMC_MII16_LED3);
  385                 }
  387         }
  389         /*
  390          * hardware link is up, but the interface is marked as down.
  391          * Bring it back up again.
  392          */
  393         if (link_status != LMC_LINK_DOWN && !ostatus) {
printf(LMC_PRINTF_FMT ": physical link up\n",
LMC_PRINTF_ARGS);
  396                 if (sc->lmc_flags & LMC_IFUP)
lmc_ifup(sc);
sc->lmc_flags |= LMC_MODEMOK;
  399                 if (sc->lmc_cardtype == LMC_CARDTYPE_DS3 ||
sc->lmc_cardtype == LMC_CARDTYPE_T1)
  401                 {
sc->lmc_miireg16 |= LMC_DS3_LED3;
lmc_led_off (sc, LMC_DS3_LED3);
  404                                                         /* turn off red LED */
lmc_led_on (sc, LMC_DS3_LED2);
  406                 } else {
lmc_led_on (sc, LMC_MII16_LED0 | LMC_MII16_LED1
  408                                     | LMC_MII16_LED2);
  409                         if (sc->lmc_timing != LMC_CTL_CLOCK_SOURCE_EXT)
lmc_led_off (sc, LMC_MII16_LED3);
  411                 }
  413                 return;
  414         }
  416         /* Call media specific watchdog functions */
sc->lmc_media->watchdog(sc);
  419         /*
  420          * remember the timer value
  421          */
ticks = LMC_CSR_READ(sc, csr_gp_timer);
LMC_CSR_WRITE(sc, csr_gp_timer, 0xffffffffUL);
sc->ictl.ticks = 0x0000ffff - (ticks & 0x0000ffff);
ifp->if_timer = 1;
  427 }
  429 /*
  430  * Mark the interface as "up" and enable TX/RX and TX/RX interrupts.
  431  * This also does a full software reset.
  432  */
  433 static void
lmc_ifup(lmc_softc_t * const sc)
  435 {
sc->lmc_if.if_timer = 0;
lmc_dec_reset(sc);
lmc_reset(sc);
sc->lmc_media->set_link_status(sc, LMC_LINK_UP);
sc->lmc_media->set_status(sc, NULL);
sc->lmc_flags |= LMC_IFUP;
  446         /*
  447          * for DS3 & DS1 adapters light the green light, led2
  448          */
  449         if (sc->lmc_cardtype == LMC_CARDTYPE_DS3 ||
sc->lmc_cardtype == LMC_CARDTYPE_T1)
lmc_led_on (sc, LMC_MII16_LED2);
  452         else
lmc_led_on (sc, LMC_MII16_LED0 | LMC_MII16_LED2);
  455         /*
  456          * select what interrupts we want to get
  457          */
sc->lmc_intrmask |= (TULIP_STS_NORMALINTR
  459                                | TULIP_STS_RXINTR
  460                                | TULIP_STS_RXNOBUF
  461                                | TULIP_STS_TXINTR
  462                                | TULIP_STS_ABNRMLINTR
  463                                | TULIP_STS_SYSERROR
  464                                | TULIP_STS_TXSTOPPED
  465                                | TULIP_STS_TXUNDERFLOW
  466                                | TULIP_STS_RXSTOPPED
  467                                );
LMC_CSR_WRITE(sc, csr_intr, sc->lmc_intrmask);
sc->lmc_cmdmode |= TULIP_CMD_TXRUN;
sc->lmc_cmdmode |= TULIP_CMD_RXRUN;
LMC_CSR_WRITE(sc, csr_command, sc->lmc_cmdmode);
sc->lmc_if.if_timer = 1;
  475 }
  477 /*
  478  * Mark the interface as "down" and disable TX/RX and TX/RX interrupts.
  479  * This is done by performing a full reset on the interface.
  480  */
  481 static void
lmc_ifdown(lmc_softc_t * const sc)
  483 {
sc->lmc_if.if_timer = 0;
sc->lmc_flags &= ~LMC_IFUP;
sc->lmc_media->set_link_status(sc, LMC_LINK_DOWN);
lmc_led_off(sc, LMC_MII16_LED_ALL);
lmc_dec_reset(sc);
lmc_reset(sc);
sc->lmc_media->set_status(sc, NULL);
  493 }
  495 static void
lmc_rx_intr(lmc_softc_t * const sc)
  497 {
lmc_ringinfo_t * const ri = &sc->lmc_rxinfo;
  499         struct ifnet * const ifp = &sc->lmc_if;
u_int32_t status;
  501         int fillok = 1;
sc->lmc_rxtick++;
  505         for (;;) {
lmc_desc_t *eop = ri->ri_nextin;
  507                 int total_len = 0, last_offset = 0;
  508                 struct mbuf *ms = NULL, *me = NULL;
  509                 int accept = 0;
bus_dmamap_t map;
  511                 int error;
  513                 if (fillok && sc->lmc_rxq.ifq_len < LMC_RXQ_TARGET)
  514                         goto queue_mbuf;
  516                 /*
  517                  * If the TULIP has no descriptors, there can't be any receive
  518                  * descriptors to process.
  519                  */
  520                 if (eop == ri->ri_nextout)
  521                         break;
  523                 /*
  524                  * 90% of the packets will fit in one descriptor.  So we
  525                  * optimize for that case.
  526                  */
LMC_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
status = letoh32(((volatile lmc_desc_t *) eop)->d_status);
  529                 if ((status &
  530                         (TULIP_DSTS_OWNER|TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) == 
  531                         (TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) {
IF_DEQUEUE(&sc->lmc_rxq, ms);
me = ms;
  534                 } else {
  535                         /*
  536                          * If still owned by the TULIP, don't touch it.
  537                          */
  538                         if (status & TULIP_DSTS_OWNER)
  539                                 break;
  541                         /*
  542                          * It is possible (though improbable unless the
  543                          * BIG_PACKET support is enabled or MCLBYTES < 1518)
  544                          * for a received packet to cross more than one
  545                          * receive descriptor.
  546                          */
  547                         while ((status & TULIP_DSTS_RxLASTDESC) == 0) {
  548                                 if (++eop == ri->ri_last)
eop = ri->ri_first;
LMC_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
status = letoh32(((volatile lmc_desc_t *)
eop)->d_status);
  553                                 if (eop == ri->ri_nextout || 
  554                                         (status & TULIP_DSTS_OWNER)) {
  555                                         return;
  556                                 }
total_len++;
  558                         }
  560                         /*
  561                          * Dequeue the first buffer for the start of the
  562                          * packet.  Hopefully this will be the only one we
  563                          * need to dequeue.  However, if the packet consumed
  564                          * multiple descriptors, then we need to dequeue
  565                          * those buffers and chain to the starting mbuf.
  566                          * All buffers but the last buffer have the same
  567                          * length so we can set that now. (we add to
  568                          * last_offset instead of multiplying since we
  569                          * normally won't go into the loop and thereby
  570                          * saving a ourselves from doing a multiplication
  571                          * by 0 in the normal case).
  572                          */
IF_DEQUEUE(&sc->lmc_rxq, ms);
  574                         for (me = ms; total_len > 0; total_len--) {
map = LMC_GETCTX(me, bus_dmamap_t);
LMC_RXMAP_POSTSYNC(sc, map);
bus_dmamap_unload(sc->lmc_dmatag, map);
sc->lmc_rxmaps[sc->lmc_rxmaps_free++] = map;
  579 #if defined(DIAGNOSTIC)
LMC_SETCTX(me, NULL);
  581 #endif
me->m_len = LMC_RX_BUFLEN;
last_offset += LMC_RX_BUFLEN;
IF_DEQUEUE(&sc->lmc_rxq, me->m_next);
me = me->m_next;
  586                         }
  587                 }
  589                 /*
  590                  *  Now get the size of received packet (minus the CRC).
  591                  */
total_len = ((status >> 16) & 0x7FFF);
  593                 if (sc->ictl.crc_length == 16)
total_len -= 2;
  595                 else
total_len -= 4;
  598                 if ((sc->lmc_flags & LMC_RXIGNORE) == 0
  599                     && ((status & LMC_DSTS_ERRSUM) == 0
  600 #ifdef BIG_PACKET
  601                         || (total_len <= sc->lmc_if.if_mtu + PPP_HEADER_LEN
  602                             && (status & TULIP_DSTS_RxOVERFLOW) == 0)
  603 #endif
  604                         )) {
map = LMC_GETCTX(me, bus_dmamap_t);
bus_dmamap_sync(sc->lmc_dmatag, map, 0, me->m_len,
BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->lmc_dmatag, map);
sc->lmc_rxmaps[sc->lmc_rxmaps_free++] = map;
  611 #if defined(DIAGNOSTIC)
LMC_SETCTX(me, NULL);
  613 #endif
me->m_len = total_len - last_offset;
  616 #if NBPFILTER > 0
  617                         if (sc->lmc_bpf != NULL) {
  618                                 if (me == ms)
LMC_BPF_TAP(sc, mtod(ms, caddr_t),
total_len, BPF_DIRECTION_IN);
  621                                 else
LMC_BPF_MTAP(sc, ms, BPF_DIRECTION_IN);
  623                         }
  624 #endif
sc->lmc_flags |= LMC_RXACT;
accept = 1;
  627                 } else {
ifp->if_ierrors++;
  629                         if (status & TULIP_DSTS_RxOVERFLOW) {
sc->lmc_dot3stats.dot3StatsInternalMacReceiveErrors++;
  631                         }
map = LMC_GETCTX(me, bus_dmamap_t);
bus_dmamap_unload(sc->lmc_dmatag, map);
sc->lmc_rxmaps[sc->lmc_rxmaps_free++] = map;
  635 #if defined(DIAGNOSTIC)
LMC_SETCTX(me, NULL);
  637 #endif
  638                 }
ifp->if_ipackets++;
  641                 if (++eop == ri->ri_last)
eop = ri->ri_first;
ri->ri_nextin = eop;
queue_mbuf:
  646                 /*
  647                  * Either we are priming the TULIP with mbufs (m == NULL)
  648                  * or we are about to accept an mbuf for the upper layers
  649                  * so we need to allocate an mbuf to replace it.  If we
  650                  * can't replace it, send up it anyways.  This may cause
  651                  * us to drop packets in the future but that's better than
  652                  * being caught in livelock.
  653                  *
  654                  * Note that if this packet crossed multiple descriptors
  655                  * we don't even try to reallocate all the mbufs here.
  656                  * Instead we rely on the test of the beginning of
  657                  * the loop to refill for the extra consumed mbufs.
  658                  */
  659                 if (accept || ms == NULL) {
  660                         struct mbuf *m0;
MGETHDR(m0, M_DONTWAIT, MT_DATA);
  662                         if (m0 != NULL) {
MCLGET(m0, M_DONTWAIT);
  664                                 if ((m0->m_flags & M_EXT) == 0) {
m_freem(m0);
m0 = NULL;
  667                                 }
  668                         }
  669                         if (accept) {
ms->m_pkthdr.len = total_len;
ms->m_pkthdr.rcvif = ifp;
sppp_input(ifp, ms);
  673                         }
ms = m0;
  675                 }
  676                 if (ms == NULL) {
  677                         /*
  678                          * Couldn't allocate a new buffer.  Don't bother 
  679                          * trying to replenish the receive queue.
  680                          */
fillok = 0;
sc->lmc_flags |= LMC_RXBUFSLOW;
  683                         continue;
  684                 }
  685                 /*
  686                  * Now give the buffer(s) to the TULIP and save in our
  687                  * receive queue.
  688                  */
  689                 do {
u_int32_t ctl;
lmc_desc_t * const nextout = ri->ri_nextout;
  693                         if (sc->lmc_rxmaps_free > 0) {
map = sc->lmc_rxmaps[--sc->lmc_rxmaps_free];
  695                         } else {
m_freem(ms);
sc->lmc_flags |= LMC_RXBUFSLOW;
  698 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_rxlowbufs++;
  700 #endif
  701                                 break;
  702                         }
LMC_SETCTX(ms, map);
error = bus_dmamap_load(sc->lmc_dmatag, map,
mtod(ms, void *), LMC_RX_BUFLEN, 
NULL, BUS_DMA_NOWAIT);
  707                         if (error) {
printf(LMC_PRINTF_FMT
  709                                         ": unable to load rx map, "
  710                                         "error = %d\n",
LMC_PRINTF_ARGS, error);
panic("lmc_rx_intr");           /* XXX */
  713                         }
ctl = letoh32(nextout->d_ctl);
  716                         /* For some weird reason we lose TULIP_DFLAG_ENDRING */
  717                         if ((nextout+1) == ri->ri_last)
ctl = LMC_CTL(LMC_CTL_FLGS(ctl)|
TULIP_DFLAG_ENDRING, 0, 0);
nextout->d_addr1 = htole32(map->dm_segs[0].ds_addr);
  721                         if (map->dm_nsegs == 2) {
nextout->d_addr2 = htole32(map->dm_segs[1].ds_addr);
nextout->d_ctl = 
htole32(LMC_CTL(LMC_CTL_FLGS(ctl),
map->dm_segs[0].ds_len,
map->dm_segs[1].ds_len));
  727                         } else {
nextout->d_addr2 = 0;
nextout->d_ctl = 
htole32(LMC_CTL(LMC_CTL_FLGS(ctl),
map->dm_segs[0].ds_len, 0));
  732                         }
LMC_RXDESC_POSTSYNC(sc, nextout, sizeof(*nextout));
ri->ri_nextout->d_status = htole32(TULIP_DSTS_OWNER);
LMC_RXDESC_POSTSYNC(sc, nextout, sizeof(u_int32_t));
  736                         if (++ri->ri_nextout == ri->ri_last)
ri->ri_nextout = ri->ri_first;
me = ms->m_next;
ms->m_next = NULL;
IF_ENQUEUE(&sc->lmc_rxq, ms);
  741                 } while ((ms = me) != NULL);
  743                 if (sc->lmc_rxq.ifq_len >= LMC_RXQ_TARGET)
sc->lmc_flags &= ~LMC_RXBUFSLOW;
  745         }
  746 }
  748 static int
lmc_tx_intr(lmc_softc_t * const sc)
  750 {
lmc_ringinfo_t * const ri = &sc->lmc_txinfo;
  752     struct mbuf *m;
  753     int xmits = 0;
  754     int descs = 0;
u_int32_t d_status;
sc->lmc_txtick++;
  759     while (ri->ri_free < ri->ri_max) {
u_int32_t flag;
LMC_TXDESC_POSTSYNC(sc, ri->ri_nextin, sizeof(*ri->ri_nextin));
d_status = letoh32(((volatile lmc_desc_t *) ri->ri_nextin)->d_status);
  764         if (d_status & TULIP_DSTS_OWNER)
  765             break;
flag = LMC_CTL_FLGS(letoh32(ri->ri_nextin->d_ctl));
  768         if (flag & TULIP_DFLAG_TxLASTSEG) {
IF_DEQUEUE(&sc->lmc_txq, m);
  770                 if (m != NULL) {
bus_dmamap_t map = LMC_GETCTX(m, bus_dmamap_t);
LMC_TXMAP_POSTSYNC(sc, map);
sc->lmc_txmaps[sc->lmc_txmaps_free++] = map;
  774 #if NBPFILTER > 0
  775                     if (sc->lmc_bpf != NULL)
LMC_BPF_MTAP(sc, m, BPF_DIRECTION_OUT);
  777 #endif
m_freem(m);
  779 #if defined(LMC_DEBUG)
  780                 } else {
printf(LMC_PRINTF_FMT ": tx_intr: failed to dequeue mbuf?!?\n", LMC_PRINTF_ARGS);
  782 #endif
  783                 }
xmits++;
  785                     if (d_status & LMC_DSTS_ERRSUM) {
sc->lmc_if.if_oerrors++;
  787                         if (d_status & TULIP_DSTS_TxUNDERFLOW) {
sc->lmc_dot3stats.dot3StatsInternalTransmitUnderflows++;
  789                         }
  790                     } else {
  791                         if (d_status & TULIP_DSTS_TxDEFERRED) {
sc->lmc_dot3stats.dot3StatsDeferredTransmissions++;
  793                         }
  794                     }
  795         }
  797         if (++ri->ri_nextin == ri->ri_last)
ri->ri_nextin = ri->ri_first;
ri->ri_free++;
descs++;
sc->lmc_if.if_flags &= ~IFF_OACTIVE;
  803     }
  804     /*
  805      * If nothing left to transmit, disable the timer.
  806      * Else if progress, reset the timer back to 2 ticks.
  807      */
sc->lmc_if.if_opackets += xmits;
  810     return descs;
  811 }
  813 static void
lmc_print_abnormal_interrupt (lmc_softc_t * const sc, u_int32_t csr)
  815 {
printf(LMC_PRINTF_FMT ": Abnormal interrupt\n", LMC_PRINTF_ARGS);
  817 }
  819 static const char * const lmc_system_errors[] = {
  820     "parity error",
  821     "master abort",
  822     "target abort",
  823     "reserved #3",
  824     "reserved #4",
  825     "reserved #5",
  826     "reserved #6",
  827     "reserved #7",
  828 };
  830 static void
lmc_intr_handler(lmc_softc_t * const sc, int *progress_p)
  832 {
u_int32_t csr;
  835     while ((csr = LMC_CSR_READ(sc, csr_status)) & sc->lmc_intrmask) {
  837         *progress_p = 1;
LMC_CSR_WRITE(sc, csr_status, csr);
  840         if (csr & TULIP_STS_SYSERROR) {
sc->lmc_last_system_error = (csr & TULIP_STS_ERRORMASK) >> TULIP_STS_ERR_SHIFT;
  842             if (sc->lmc_flags & LMC_NOMESSAGES) {
sc->lmc_flags |= LMC_SYSTEMERROR;
  844             } else {
printf(LMC_PRINTF_FMT ": system error: %s\n",
LMC_PRINTF_ARGS,
lmc_system_errors[sc->lmc_last_system_error]);
  848             }
sc->lmc_flags |= LMC_NEEDRESET;
sc->lmc_system_errors++;
  851             break;
  852         }
  853         if (csr & (TULIP_STS_RXINTR | TULIP_STS_RXNOBUF)) {
u_int32_t misses = LMC_CSR_READ(sc, csr_missed_frames);
  855             if (csr & TULIP_STS_RXNOBUF)
sc->lmc_dot3stats.dot3StatsMissedFrames += misses & 0xFFFF;
  857             /*
  858              * Pass 2.[012] of the 21140A-A[CDE] may hang and/or corrupt data
  859              * on receive overflows.
  860              */
  861            if ((misses & 0x0FFE0000) && (sc->lmc_features & LMC_HAVE_RXBADOVRFLW)) {
sc->lmc_dot3stats.dot3StatsInternalMacReceiveErrors++;
  863                 /*
  864                  * Stop the receiver process and spin until it's stopped.
  865                  * Tell rx_intr to drop the packets it dequeues.
  866                  */
LMC_CSR_WRITE(sc, csr_command, sc->lmc_cmdmode & ~TULIP_CMD_RXRUN);
  868                 while ((LMC_CSR_READ(sc, csr_status) & TULIP_STS_RXSTOPPED) == 0)
  869                     ;
LMC_CSR_WRITE(sc, csr_status, TULIP_STS_RXSTOPPED);
sc->lmc_flags |= LMC_RXIGNORE;
  872             }
lmc_rx_intr(sc);
  874             if (sc->lmc_flags & LMC_RXIGNORE) {
  875                 /*
  876                  * Restart the receiver.
  877                  */
sc->lmc_flags &= ~LMC_RXIGNORE;
LMC_CSR_WRITE(sc, csr_command, sc->lmc_cmdmode);
  880             }
  881         }
  882         if (csr & TULIP_STS_ABNRMLINTR) {
u_int32_t tmp = csr & sc->lmc_intrmask
  884                 & ~(TULIP_STS_NORMALINTR|TULIP_STS_ABNRMLINTR);
  885             if (csr & TULIP_STS_TXUNDERFLOW) {
  886                 if ((sc->lmc_cmdmode & TULIP_CMD_THRESHOLDCTL) != TULIP_CMD_THRSHLD160) {
sc->lmc_cmdmode += TULIP_CMD_THRSHLD96;
sc->lmc_flags |= LMC_NEWTXTHRESH;
  889                 } else if (sc->lmc_features & LMC_HAVE_STOREFWD) {
sc->lmc_cmdmode |= TULIP_CMD_STOREFWD;
sc->lmc_flags |= LMC_NEWTXTHRESH;
  892                 }
  893             }
  894             if (sc->lmc_flags & LMC_NOMESSAGES) {
sc->lmc_statusbits |= tmp;
  896             } else {
lmc_print_abnormal_interrupt(sc, tmp);
sc->lmc_flags |= LMC_NOMESSAGES;
  899             }
LMC_CSR_WRITE(sc, csr_command, sc->lmc_cmdmode);
  901         }
  903         if (csr & TULIP_STS_TXINTR)
lmc_tx_intr(sc);
  906         if (sc->lmc_flags & LMC_WANTTXSTART)
lmc_ifstart(&sc->lmc_if);
  908     }
  909 }
lmc_intrfunc_t
lmc_intr_normal(void *arg)
  913 {
lmc_softc_t * sc = (lmc_softc_t *) arg;
  915         int progress = 0;
lmc_intr_handler(sc, &progress);
  919 #if !defined(LMC_VOID_INTRFUNC)
  920         return progress;
  921 #endif
  922 }
  924 static struct mbuf *
lmc_mbuf_compress(struct mbuf *m)
  926 {
  927         struct mbuf *m0;
  928 #if MCLBYTES >= LMC_MTU + PPP_HEADER_LEN && !defined(BIG_PACKET)
MGETHDR(m0, M_DONTWAIT, MT_DATA);
  930         if (m0 != NULL) {
  931                 if (m->m_pkthdr.len > MHLEN) {
MCLGET(m0, M_DONTWAIT);
  933                         if ((m0->m_flags & M_EXT) == 0) {
m_freem(m);
m_freem(m0);
  936                                 return NULL;
  937                         }
  938                 }
m_copydata(m, 0, m->m_pkthdr.len, mtod(m0, caddr_t));
m0->m_pkthdr.len = m0->m_len = m->m_pkthdr.len;
  941         }
  942 #else
  943         int mlen = MHLEN;
  944         int len = m->m_pkthdr.len;
  945         struct mbuf **mp = &m0;
  947         while (len > 0) {
  948                 if (mlen == MHLEN) {
MGETHDR(*mp, M_DONTWAIT, MT_DATA);
  950                 } else {
MGET(*mp, M_DONTWAIT, MT_DATA);
  952                 }
  953                 if (*mp == NULL) {
m_freem(m0);
m0 = NULL;
  956                         break;
  957                 }
  958                 if (len > MLEN) {
MCLGET(*mp, M_DONTWAIT);
  960                         if (((*mp)->m_flags & M_EXT) == 0) {
m_freem(m0);
m0 = NULL;
  963                                 break;
  964                         }
  965                         (*mp)->m_len = (len <= MCLBYTES ? len : MCLBYTES);
  966                 } else {
  967                         (*mp)->m_len = (len <= mlen ? len : mlen);
  968                 }
m_copydata(m, m->m_pkthdr.len - len,
  970                            (*mp)->m_len, mtod((*mp), caddr_t));
len -= (*mp)->m_len;
mp = &(*mp)->m_next;
mlen = MLEN;
  974         }
  975 #endif
m_freem(m);
  977         return m0;
  978 }
  980 /*
  981  * queue the mbuf handed to us for the interface.  If we cannot
  982  * queue it, return the mbuf.  Return NULL if the mbuf was queued.
  983  */
  984 static struct mbuf *
lmc_txput(lmc_softc_t * const sc, struct mbuf *m)
  986 {
lmc_ringinfo_t * const ri = &sc->lmc_txinfo;
lmc_desc_t *eop, *nextout;
  989         int segcnt, free;
u_int32_t d_status, ctl;
bus_dmamap_t map;
  992         int error;
  994 #if defined(LMC_DEBUG)
  995         if ((sc->lmc_cmdmode & TULIP_CMD_TXRUN) == 0) {
printf(LMC_PRINTF_FMT ": txput: tx not running\n",
LMC_PRINTF_ARGS);
sc->lmc_flags |= LMC_WANTTXSTART;
  999                 goto finish;
 1000         }
 1001 #endif
 1003         /*
 1004          * Now we try to fill in our transmit descriptors.  This is
 1005          * a bit reminiscent of going on the Ark two by two
 1006          * since each descriptor for the TULIP can describe
 1007          * two buffers.  So we advance through packet filling
 1008          * each of the two entries at a time to fill each
 1009          * descriptor.  Clear the first and last segment bits
 1010          * in each descriptor (actually just clear everything
 1011          * but the end-of-ring or chain bits) to make sure
 1012          * we don't get messed up by previously sent packets.
 1013          *
 1014          * We may fail to put the entire packet on the ring if
 1015          * there is either not enough ring entries free or if the
 1016          * packet has more than MAX_TXSEG segments.  In the former
 1017          * case we will just wait for the ring to empty.  In the
 1018          * latter case we have to recopy.
 1019          */
d_status = 0;
eop = nextout = ri->ri_nextout;
segcnt = 0;
free = ri->ri_free;
 1024         /*
 1025          * Reclaim some DMA maps from if we are out.
 1026          */
 1027         if (sc->lmc_txmaps_free == 0) {
 1028 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_no_txmaps++;
 1030 #endif
free += lmc_tx_intr(sc);
 1032         }
 1033         if (sc->lmc_txmaps_free > 0) {
map = sc->lmc_txmaps[sc->lmc_txmaps_free-1];
 1035         } else {
sc->lmc_flags |= LMC_WANTTXSTART;
 1037 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_txput_finishes[1]++;
 1039 #endif
 1040                 goto finish;
 1041         }
error = bus_dmamap_load_mbuf(sc->lmc_dmatag, map, m, BUS_DMA_NOWAIT);
 1043         if (error != 0) {
 1044                 if (error == EFBIG) {
 1045                         /*
 1046                          * The packet exceeds the number of transmit buffer
 1047                          * entries that we can use for one packet, so we have
 1048                          * to recopy it into one mbuf and then try again.
 1049                          */
m = lmc_mbuf_compress(m);
 1051                         if (m == NULL) {
 1052 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_txput_finishes[2]++;
 1054 #endif
 1055                                 goto finish;
 1056                         }
error = bus_dmamap_load_mbuf(sc->lmc_dmatag, map, m,
BUS_DMA_NOWAIT);
 1059                 }
 1060                 if (error != 0) {
printf(LMC_PRINTF_FMT ": unable to load tx map, "
 1062                                 "error = %d\n", LMC_PRINTF_ARGS, error);
 1063 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_txput_finishes[3]++;
 1065 #endif
 1066                         goto finish;
 1067                 }
 1068         }
 1069         if ((free -= (map->dm_nsegs + 1) / 2) <= 0
 1070                 /*
 1071                  * See if there's any unclaimed space in the transmit ring.
 1072                  */
 1073                 && (free += lmc_tx_intr(sc)) <= 0) {
 1074                 /*
 1075                  * There's no more room but since nothing
 1076                  * has been committed at this point, just
 1077                  * show output is active, put back the
 1078                  * mbuf and return.
 1079                  */
sc->lmc_flags |= LMC_WANTTXSTART;
 1081 #if defined(LMC_DEBUG)
sc->lmc_dbg.dbg_txput_finishes[4]++;
 1083 #endif
bus_dmamap_unload(sc->lmc_dmatag, map);
 1085                 goto finish;
 1086         }
 1087         for (; map->dm_nsegs - segcnt > 1; segcnt += 2) {
 1088                 int flg;
eop = nextout;
flg            = LMC_CTL_FLGS(letoh32(eop->d_ctl));
flg           &= TULIP_DFLAG_ENDRING;
flg           |= TULIP_DFLAG_TxNOPADDING;
 1094                 if (sc->ictl.crc_length == 16)
flg |= TULIP_DFLAG_TxHASCRC;
eop->d_status  = htole32(d_status);
eop->d_addr1   = htole32(map->dm_segs[segcnt].ds_addr);
eop->d_addr2   = htole32(map->dm_segs[segcnt+1].ds_addr);
eop->d_ctl     = htole32(LMC_CTL(flg, 
map->dm_segs[segcnt].ds_len,
map->dm_segs[segcnt+1].ds_len));
d_status = TULIP_DSTS_OWNER;
 1103                 if (++nextout == ri->ri_last)
nextout = ri->ri_first;
 1105         }
 1106         if (segcnt < map->dm_nsegs) {
 1107                 int flg;
eop = nextout;
flg            = LMC_CTL_FLGS(letoh32(eop->d_ctl));
flg           &= TULIP_DFLAG_ENDRING;
flg           |= TULIP_DFLAG_TxNOPADDING;
 1113                 if (sc->ictl.crc_length == 16)
flg |= TULIP_DFLAG_TxHASCRC;
eop->d_status  = htole32(d_status);
eop->d_addr1   = htole32(map->dm_segs[segcnt].ds_addr);
eop->d_addr2   = 0;
eop->d_ctl     = htole32(LMC_CTL(flg, 
map->dm_segs[segcnt].ds_len, 0));
 1120                 if (++nextout == ri->ri_last)
nextout = ri->ri_first;
 1122         }
LMC_TXMAP_PRESYNC(sc, map);
LMC_SETCTX(m, map);
map = NULL;
 1126         --sc->lmc_txmaps_free;          /* commit to using the dmamap */
 1128         /*
 1129          * The descriptors have been filled in.  Now get ready
 1130          * to transmit.
 1131          */
IF_ENQUEUE(&sc->lmc_txq, m);
m = NULL;
 1135         /*
 1136          * Make sure the next descriptor after this packet is owned
 1137          * by us since it may have been set up above if we ran out
 1138          * of room in the ring.
 1139          */
nextout->d_status = 0;
LMC_TXDESC_PRESYNC(sc, nextout, sizeof(u_int32_t));
 1143         /*
 1144          * Mark the last and first segments, indicate we want a transmit
 1145          * complete interrupt, and tell it to transmit!
 1146          */
ctl = letoh32(eop->d_ctl);
eop->d_ctl = htole32(LMC_CTL(
LMC_CTL_FLGS(ctl)|TULIP_DFLAG_TxLASTSEG|TULIP_DFLAG_TxWANTINTR,
LMC_CTL_LEN1(ctl),
LMC_CTL_LEN2(ctl)));
 1153         /*
 1154          * Note that ri->ri_nextout is still the start of the packet
 1155          * and until we set the OWNER bit, we can still back out of
 1156          * everything we have done.
 1157          */
ctl = letoh32(ri->ri_nextout->d_ctl);
ri->ri_nextout->d_ctl = htole32(LMC_CTL(
LMC_CTL_FLGS(ctl)|TULIP_DFLAG_TxFIRSTSEG,
LMC_CTL_LEN1(ctl),
LMC_CTL_LEN2(ctl)));
 1163         if (eop < ri->ri_nextout) {
LMC_TXDESC_PRESYNC(sc, ri->ri_nextout,
 1165                         (caddr_t) ri->ri_last - (caddr_t) ri->ri_nextout);
LMC_TXDESC_PRESYNC(sc, ri->ri_first,
 1167                         (caddr_t) (eop + 1) - (caddr_t) ri->ri_first);
 1168         } else {
LMC_TXDESC_PRESYNC(sc, ri->ri_nextout,
 1170                         (caddr_t) (eop + 1) - (caddr_t) ri->ri_nextout);
 1171         }
ri->ri_nextout->d_status = htole32(TULIP_DSTS_OWNER);
LMC_TXDESC_PRESYNC(sc, ri->ri_nextout, sizeof(u_int32_t));
LMC_CSR_WRITE(sc, csr_txpoll, 1);
 1177         /*
 1178          * This advances the ring for us.
 1179          */
ri->ri_nextout = nextout;
ri->ri_free = free;
 1183         /*
 1184          * switch back to the single queueing ifstart.
 1185          */
sc->lmc_flags &= ~LMC_WANTTXSTART;
sc->lmc_if.if_start = lmc_ifstart_one;
 1189         /*
 1190          * If we want a txstart, there must be not enough space in the
 1191          * transmit ring.  So we want to enable transmit done interrupts
 1192          * so we can immediately reclaim some space.  When the transmit
 1193          * interrupt is posted, the interrupt handler will call tx_intr
 1194          * to reclaim space and then txstart (since WANTTXSTART is set).
 1195          * txstart will move the packet into the transmit ring and clear
 1196          * WANTTXSTART thereby causing TXINTR to be cleared.
 1197          */
finish:
 1199         if (sc->lmc_flags & LMC_WANTTXSTART) {
sc->lmc_if.if_flags |= IFF_OACTIVE;
sc->lmc_if.if_start = lmc_ifstart;
 1202         }
 1204         return m;
 1205 }
 1208 /*
 1209  * This routine is entered at splnet()
 1210  */
 1211 static int
lmc_ifioctl(struct ifnet * ifp, ioctl_cmd_t cmd, caddr_t data)
 1213 {
lmc_softc_t * const sc = LMC_IFP_TO_SOFTC(ifp);
 1215         int s;
 1216         struct proc *p = curproc;
 1217         int error = 0;
 1218         struct ifreq *ifr = (struct ifreq *)data;
u_int32_t new_state;
u_int32_t old_state;
lmc_ctl_t ctl;
s = LMC_RAISESPL();
 1225         switch (cmd) {
 1226         case LMCIOCGINFO:
error = copyout(&sc->ictl, ifr->ifr_data, sizeof(lmc_ctl_t));
 1229                 goto out;
 1230                 break;
 1232         case LMCIOCSINFO:
error = suser(p, 0);
 1234                 if (error)
 1235                         goto out;
error = copyin(ifr->ifr_data, &ctl, sizeof(lmc_ctl_t));
 1238                 if (error != 0)
 1239                         goto out;
sc->lmc_media->set_status(sc, &ctl);
 1243                 goto out;
 1244                 break;
 1246         case SIOCSIFMTU:
 1247                 /*
 1248                  * Don't allow the MTU to get larger than we can handle
 1249                  */
 1250                 if (ifr->ifr_mtu > LMC_MTU) {
error = EINVAL;
 1252                         goto out;
 1253                 } else {
ifp->if_mtu = ifr->ifr_mtu;
 1255                 }
 1256                 break;
 1257         }
 1259         /*
 1260          * call the sppp ioctl layer
 1261          */
error = sppp_ioctl(ifp, cmd, data);
 1263         if (error != 0)
 1264                 goto out;
 1266         /*
 1267          * If we are transitioning from up to down or down to up, call
 1268          * our init routine.
 1269          */
new_state = ifp->if_flags & IFF_UP;
old_state = sc->lmc_flags & LMC_IFUP;
 1273         if (new_state && !old_state)
lmc_ifup(sc);
 1275         else if (!new_state && old_state)
lmc_ifdown(sc);
out:
LMC_RESTORESPL(s);
 1281         return error;
 1282 }
 1284 /*
 1285  * These routines gets called at device spl (from sppp_output).
 1286  */
 1288 static ifnet_ret_t
lmc_ifstart(struct ifnet * const ifp)
 1290 {
lmc_softc_t * const sc = LMC_IFP_TO_SOFTC(ifp);
 1292         struct mbuf *m, *m0;
 1294         if (sc->lmc_flags & LMC_IFUP) {
 1295                 while (sppp_isempty(ifp) == 0) {
m = sppp_pick(ifp);
 1297                         if (m == NULL)
 1298                                 break;
 1299                         if ((m = lmc_txput(sc, m)) != NULL)
 1300                                 break;
m0 = sppp_dequeue(ifp);
 1302 #if defined(LMC_DEBUG)
 1303                         if (m0 != m)
printf("lmc_ifstart: mbuf mismatch!\n");
 1305 #endif
 1306                 }
LMC_CSR_WRITE(sc, csr_txpoll, 1);
 1308         }
 1309 }
 1311 static ifnet_ret_t
lmc_ifstart_one(struct ifnet * const ifp)
 1313 {
lmc_softc_t * const sc = LMC_IFP_TO_SOFTC(ifp);
 1315         struct mbuf *m, *m0;
 1317         if ((sc->lmc_flags & LMC_IFUP) && (sppp_isempty(ifp) == 0)) {
m = sppp_pick(ifp);
 1319                 if ((m = lmc_txput(sc, m)) != NULL)
 1320                         return;
m0 = sppp_dequeue(ifp);
 1322 #if defined(LMC_DEBUG)
 1323                 if (m0 != m)
printf("lmc_ifstart: mbuf mismatch!\n");
 1325 #endif
LMC_CSR_WRITE(sc, csr_txpoll, 1);
 1327         }
 1328 }
 1330 /*
 1331  * Set up the OS interface magic and attach to the operating system
 1332  * network services.
 1333  */
 1334 void
lmc_attach(lmc_softc_t * const sc)
 1336 {
 1337         struct ifnet * const ifp = &sc->lmc_if;
ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
ifp->if_ioctl = lmc_ifioctl;
ifp->if_start = lmc_ifstart;
ifp->if_watchdog = lmc_watchdog;
ifp->if_timer = 1;
ifp->if_mtu = LMC_MTU;
IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
if_alloc_sadl(ifp);
sppp_attach((struct ifnet *)&sc->lmc_sppp);
sc->lmc_sppp.pp_flags = PP_CISCO | PP_KEEPALIVE;
sc->lmc_sppp.pp_framebytes = 3;
 1355 #if NBPFILTER > 0
LMC_BPF_ATTACH(sc);
 1357 #endif
 1359         /*
 1360          * turn off those LEDs...
 1361          */
sc->lmc_miireg16 |= LMC_MII16_LED_ALL;
 1363         /*
 1364          * for DS3 & DS1 adapters light the green light, led2
 1365          */
 1366         if (sc->lmc_cardtype == LMC_CARDTYPE_DS3 ||
sc->lmc_cardtype == LMC_CARDTYPE_T1)
lmc_led_on (sc, LMC_MII16_LED2);
 1369         else
lmc_led_on (sc, LMC_MII16_LED0 | LMC_MII16_LED2);
 1371 }
 1373 void
lmc_initring(lmc_softc_t * const sc, lmc_ringinfo_t * const ri,
lmc_desc_t *descs, int ndescs)
 1376 {
ri->ri_max = ndescs;
ri->ri_first = descs;
ri->ri_last = ri->ri_first + ri->ri_max;
bzero((caddr_t) ri->ri_first, sizeof(ri->ri_first[0]) * ri->ri_max);
ri->ri_last[-1].d_ctl = htole32(LMC_CTL(TULIP_DFLAG_ENDRING, 0, 0));
 1382 }