root/dev/pci/if_lmc_obsd.c

DEFINITIONS

1. lmc_pci_probe
2. lmc_pci_attach
3. lmc_shutdown
4. lmc_busdma_allocmem
5. lmc_busdma_init

    1 /*      $OpenBSD: if_lmc_obsd.c,v 1.19 2005/11/07 00:29:21 brad Exp $ */
    2 /*      $NetBSD: if_lmc_nbsd.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 #include "bpfilter.h"
   68 #include <sys/param.h>
   69 #include <sys/systm.h>
   70 #include <sys/mbuf.h>
   71 #include <sys/socket.h>
   72 #include <sys/ioctl.h>
   73 #include <sys/errno.h>
   74 #include <sys/malloc.h>
   75 #include <sys/kernel.h>
   76 #include <sys/proc.h>   /* only for declaration of wakeup() used by vm.h */
   77 #include <sys/device.h>
   79 #include <dev/pci/pcidevs.h>
   81 #include <net/if.h>
   82 #include <net/if_types.h>
   83 #include <net/if_dl.h>
   84 #include <net/netisr.h>
   86 #if NBPFILTER > 0
   87 #include <net/bpf.h>
   88 #endif
   90 #include <net/if_sppp.h>
   92 #include <machine/bus.h>
   94 #include <dev/pci/pcireg.h>
   95 #include <dev/pci/pcivar.h>
   96 #include <dev/ic/dc21040reg.h>
   98 #include <dev/pci/if_lmc_types.h>
   99 #include <dev/pci/if_lmcioctl.h>
  100 #include <dev/pci/if_lmcvar.h>
  102 /*
  103  * This file is INCLUDED (gross, I know, but...)
  104  */
  106 static void lmc_shutdown(void *arg);
  107 static int lmc_busdma_init(lmc_softc_t * const sc);
  108 static int lmc_busdma_allocmem(lmc_softc_t * const sc, size_t size,
bus_dmamap_t *map_p, lmc_desc_t **desc_p);
  111 static int
lmc_pci_probe(struct device *parent,
  113                void *match,
  114                void *aux)
  115 {
  116         struct pci_attach_args *pa = (struct pci_attach_args *)aux;
u_int32_t id;
  119         /*
  120          * check first for the DEC chip we expect to find.  We expect
  121          * 21140A, pass 2.2 or higher.
  122          */
  123         if (PCI_VENDORID(pa->pa_id) != PCI_VENDOR_DEC)
  124                 return 0;
  125         if (PCI_CHIPID(pa->pa_id) != PCI_PRODUCT_DEC_21140)
  126                 return 0;
id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFRV) & 0xff;
  128         if (id < 0x22)
  129                 return 0;
  131         /*
  132          * Next, check the subsystem ID and see if it matches what we
  133          * expect.
  134          */
id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SSID);
  136         if (PCI_VENDORID(id) != PCI_VENDOR_LMC)
  137                 return 0;
  138         if ((PCI_CHIPID(id) != PCI_PRODUCT_LMC_HSSI)
  139             && (PCI_CHIPID(id) != PCI_PRODUCT_LMC_HSSIC)
  140             && (PCI_CHIPID(id) != PCI_PRODUCT_LMC_DS3)
  141             && (PCI_CHIPID(id) != PCI_PRODUCT_LMC_SSI)
  142             && (PCI_CHIPID(id) != PCI_PRODUCT_LMC_DS1))
  143                 return 0;
  145         return 20; /* must be > than any other tulip driver */
  146 }
  148 static void  lmc_pci_attach(struct device * const parent,
  149                              struct device * const self, void * const aux);
  151 struct cfattach lmc_ca = {
  152     sizeof(lmc_softc_t), lmc_pci_probe, lmc_pci_attach
  153 };
  155 struct cfdriver lmc_cd = {
  156         0, "lmc", DV_IFNET
  157 };
  159 static void
lmc_pci_attach(struct device * const parent,
  161                 struct device * const self, void * const aux)
  162 {
u_int32_t revinfo, cfdainfo, id, ssid;
pci_intr_handle_t intrhandle;
  165         const char *intrstr;
  166         unsigned csroffset = LMC_PCI_CSROFFSET;
  167         unsigned csrsize = LMC_PCI_CSRSIZE;
lmc_csrptr_t csr_base;
lmc_spl_t s;
lmc_intrfunc_t (*intr_rtn)(void *) = lmc_intr_normal;
lmc_softc_t * const sc = (lmc_softc_t *) self;
  172         struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
  173         extern lmc_media_t lmc_hssi_media;
  174         extern lmc_media_t lmc_ds3_media;
  175         extern lmc_media_t lmc_t1_media;
  176         extern lmc_media_t lmc_ssi_media;
revinfo  = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFRV) & 0xFF;
id       = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFID);
cfdainfo = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFDA);
ssid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SSID);
  183         switch (PCI_CHIPID(ssid)) {
  184         case PCI_PRODUCT_LMC_HSSI:
printf(": HSSI\n");
sc->lmc_media = &lmc_hssi_media;
  187                 break;
  188         case PCI_PRODUCT_LMC_HSSIC:
printf(": HSSIc\n");
sc->lmc_media = &lmc_hssi_media;
  191                 break;
  192         case PCI_PRODUCT_LMC_DS3:
printf(": DS3\n");
sc->lmc_media = &lmc_ds3_media;
  195                 break;
  196         case PCI_PRODUCT_LMC_SSI:
printf(": SSI\n");
sc->lmc_media = &lmc_ssi_media;
  199                 break;
  200         case PCI_PRODUCT_LMC_DS1:
printf(": T1\n");
sc->lmc_media = &lmc_t1_media;
  203                 break;
  204         }
sc->lmc_pci_busno = parent;
sc->lmc_pci_devno = pa->pa_device;
sc->lmc_chipid = LMC_21140A;
sc->lmc_features |= LMC_HAVE_STOREFWD;
  211         if (sc->lmc_chipid == LMC_21140A && revinfo <= 0x22)
sc->lmc_features |= LMC_HAVE_RXBADOVRFLW;
  214         if (cfdainfo & (TULIP_CFDA_SLEEP | TULIP_CFDA_SNOOZE)) {
cfdainfo &= ~(TULIP_CFDA_SLEEP | TULIP_CFDA_SNOOZE);
pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFDA, cfdainfo);
DELAY(11 * 1000);
  218         }
bcopy(self->dv_xname, sc->lmc_if.if_xname, IFNAMSIZ);
sc->lmc_if.if_softc = sc;
sc->lmc_pc = pa->pa_pc;
sc->lmc_revinfo = revinfo;
sc->lmc_if.if_softc = sc;
csr_base = 0;
  228         {
bus_space_tag_t iot, memt;
bus_space_handle_t ioh, memh;
  231                 int ioh_valid, memh_valid;
ioh_valid = (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO,
  234                     0, &iot, &ioh, NULL, NULL, 0) == 0);
memh_valid = (pci_mapreg_map(pa, PCI_CBMA,
PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT, 0, &memt,
  237                     &memh, NULL, NULL, 0) == 0);
  239                 if (memh_valid) {
sc->lmc_bustag = memt;
sc->lmc_bushandle = memh;
  242                 } else if (ioh_valid) {
sc->lmc_bustag = iot;
sc->lmc_bushandle = ioh;
  245                 } else {
printf("%s: unable to map device registers\n",
sc->lmc_dev.dv_xname);
  248                         return;
  249                 }
  250         }
sc->lmc_dmatag = pa->pa_dmat;
  253         if ((lmc_busdma_init(sc)) != 0) {
printf("error initing bus_dma\n");
  255                 return;
  256         }
lmc_initcsrs(sc, csr_base + csroffset, csrsize);
lmc_initring(sc, &sc->lmc_rxinfo, sc->lmc_rxdescs,
LMC_RXDESCS);
lmc_initring(sc, &sc->lmc_txinfo, sc->lmc_txdescs,
LMC_TXDESCS);
lmc_gpio_mkinput(sc, 0xff);
sc->lmc_gpio = 0;  /* drive no signals yet */
sc->lmc_media->defaults(sc);
sc->lmc_media->set_link_status(sc, LMC_LINK_DOWN); /* down */
  271         /*
  272          * Make sure there won't be any interrupts or such...
  273          */
LMC_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
  276         /*
  277          * Wait 10 microseconds (actually 50 PCI cycles but at 
  278          * 33MHz that comes to two microseconds but wait a
  279          * bit longer anyways)
  280          */
DELAY(100);
lmc_read_macaddr(sc);
  285         if (pci_intr_map(pa, &intrhandle)) {
printf("%s: couldn't map interrupt\n",
sc->lmc_dev.dv_xname);
  288                 return;
  289         }
intrstr = pci_intr_string(pa->pa_pc, intrhandle);
sc->lmc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET,
intr_rtn, sc, self->dv_xname);
  295         if (sc->lmc_ih == NULL) {
printf("%s: couldn't establish interrupt",
sc->lmc_dev.dv_xname);
  298                 if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
  301                 return;
  302         }
printf("%s: pass %d.%d, serial " LMC_EADDR_FMT ", %s\n",
sc->lmc_dev.dv_xname,
  306                (sc->lmc_revinfo & 0xF0) >> 4, sc->lmc_revinfo & 0x0F,
LMC_EADDR_ARGS(sc->lmc_enaddr), intrstr);
sc->lmc_ats = shutdownhook_establish(lmc_shutdown, sc);
  310         if (sc->lmc_ats == NULL)
printf("%s: warning: couldn't establish shutdown hook\n",
sc->lmc_xname);
s = LMC_RAISESPL();
lmc_dec_reset(sc);
lmc_reset(sc);
lmc_attach(sc);
LMC_RESTORESPL(s);
  319 }
  321 static void
lmc_shutdown(void *arg)
  323 {
lmc_softc_t * const sc = arg;
LMC_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
DELAY(10);
sc->lmc_miireg16 = 0;  /* deassert ready, and all others too */
lmc_led_on(sc, LMC_MII16_LED_ALL);
  330 }
  332 static int
lmc_busdma_allocmem(
lmc_softc_t * const sc,
size_t size,
bus_dmamap_t *map_p,
lmc_desc_t **desc_p)
  338 {
bus_dma_segment_t segs[1];
  340     int nsegs, error;
error = bus_dmamem_alloc(sc->lmc_dmatag, size, 1, NBPG,
segs, sizeof(segs)/sizeof(segs[0]),
  343                              &nsegs, BUS_DMA_NOWAIT);
  344     if (error == 0) {
  345         void *desc;
error = bus_dmamem_map(sc->lmc_dmatag, segs, nsegs, size,
  347                                (void *) &desc, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
  348         if (error == 0) {
bus_dmamap_t map;
error = bus_dmamap_create(sc->lmc_dmatag, size, 1, size, 0,
BUS_DMA_NOWAIT, &map);
  352             if (error == 0) {
error = bus_dmamap_load(sc->lmc_dmatag, map, desc,
size, NULL, BUS_DMA_NOWAIT);
  355                 if (error)
bus_dmamap_destroy(sc->lmc_dmatag, map);
  357                 else
  358                     *map_p = map;
  359             }
  360             if (error)
bus_dmamem_unmap(sc->lmc_dmatag, desc, size);
  362         }
  363         if (error)
bus_dmamem_free(sc->lmc_dmatag, segs, nsegs);
  365         else
  366             *desc_p = desc;
  367     }
  368     return error;
  369 }
  371 static int
lmc_busdma_init(
lmc_softc_t * const sc)
  374 {
  375     int error = 0;
  377     /*
  378      * Allocate space and dmamap for transmit ring
  379      */
  380     if (error == 0) {
error = lmc_busdma_allocmem(sc, sizeof(lmc_desc_t) * LMC_TXDESCS,
  382                                       &sc->lmc_txdescmap,
  383                                       &sc->lmc_txdescs);
  384     }
  386     /*
  387      * Allocate dmamaps for each transmit descriptors
  388      */
  389     if (error == 0) {
  390         while (error == 0 && sc->lmc_txmaps_free < LMC_TXDESCS) {
bus_dmamap_t map;
  392             if ((error = LMC_TXMAP_CREATE(sc, &map)) == 0)
sc->lmc_txmaps[sc->lmc_txmaps_free++] = map;
  394         }
  395         if (error) {
  396             while (sc->lmc_txmaps_free > 0) 
bus_dmamap_destroy(sc->lmc_dmatag,
sc->lmc_txmaps[--sc->lmc_txmaps_free]);
  399         }
  400     }
  402     /*
  403      * Allocate space and dmamap for receive ring
  404      */
  405     if (error == 0) {
error = lmc_busdma_allocmem(sc, sizeof(lmc_desc_t) * LMC_RXDESCS,
  407                                       &sc->lmc_rxdescmap,
  408                                       &sc->lmc_rxdescs);
  409     }
  411     /*
  412      * Allocate dmamaps for each receive descriptors
  413      */
  414     if (error == 0) {
  415         while (error == 0 && sc->lmc_rxmaps_free < LMC_RXDESCS) {
bus_dmamap_t map;
  417             if ((error = LMC_RXMAP_CREATE(sc, &map)) == 0)
sc->lmc_rxmaps[sc->lmc_rxmaps_free++] = map;
  419         }
  420         if (error) {
  421             while (sc->lmc_rxmaps_free > 0) 
bus_dmamap_destroy(sc->lmc_dmatag,
sc->lmc_rxmaps[--sc->lmc_rxmaps_free]);
  424         }
  425     }
  427     return error;
  428 }