if_lnc_cbus.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 1994-2000
    3  *      Paul Richards. All rights reserved.
    4  *
    5  * PC-98 port by Chiharu Shibata & FreeBSD(98) porting team.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer,
   12  *    verbatim and that no modifications are made prior to this
   13  *    point in the file.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  * 3. The name Paul Richards may not be used to endorse or promote products
   18  *    derived from this software without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL PAUL RICHARDS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  * $FreeBSD: releng/5.0/sys/dev/lnc/if_lnc_cbus.c 106937 2002-11-14 23:54:55Z sam $
   33  */
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/bus.h>
   38 #include <sys/kernel.h>
   39 #include <sys/malloc.h>
   40 #include <sys/socket.h>
   41 
   42 #include <machine/clock.h>      /* DELAY() */
   43 #include <machine/bus.h>
   44 #include <machine/resource.h>
   45 #include <sys/rman.h>
   46 
   47 #include <net/ethernet.h>
   48 #include <net/if.h>
   49 #include <net/if_arp.h>
   50 
   51 #include <isa/isavar.h>
   52 
   53 #include <dev/lnc/if_lncvar.h>
   54 #include <dev/lnc/if_lncreg.h>
   55 
   56 static struct isa_pnp_id lnc_pnp_ids[] = {
   57         {0,     NULL}
   58 };
   59 
   60 static bus_addr_t lnc_ioaddr_cnet98s[CNET98S_IOSIZE] = {
   61         0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007,
   62         0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
   63         0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407,
   64         0x408, 0x409, 0x40a, 0x40b, 0x40c, 0x40d, 0x40e, 0x40f,
   65 };
   66 
   67 static int
   68 lnc_legacy_probe(device_t dev)
   69 {
   70         struct lnc_softc *sc = device_get_softc(dev);
   71         u_int16_t tmp;
   72 
   73         sc->portrid = 0;
   74         sc->portres = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &sc->portrid,
   75                                           lnc_ioaddr_cnet98s, CNET98S_IOSIZE,
   76                                           RF_ACTIVE);
   77 
   78         if (! sc->portres) {
   79                 device_printf(dev, "Failed to allocate I/O ports\n");
   80                 lnc_release_resources(dev);
   81                 return (ENXIO);
   82         }
   83 
   84         isa_load_resourcev(sc->portres, lnc_ioaddr_cnet98s, CNET98S_IOSIZE);
   85 
   86         sc->lnc_btag = rman_get_bustag(sc->portres);
   87         sc->lnc_bhandle = rman_get_bushandle(sc->portres);
   88 
   89         /* Reset */
   90         tmp = lnc_inw(CNET98S_RESET);
   91         lnc_outw(CNET98S_RESET, tmp);
   92         DELAY(500);
   93 
   94         sc->rap = CNET98S_RAP;
   95         sc->rdp = CNET98S_RDP;
   96         sc->nic.mem_mode = DMA_FIXED;
   97 
   98         if ((sc->nic.ic = lance_probe(sc))) {
   99                 sc->nic.ident = CNET98S;
  100                 device_set_desc(dev, "C-NET(98)S");
  101                 lnc_release_resources(dev);
  102                 return (0);
  103         } else {
  104                 lnc_release_resources(dev);
  105                 return (ENXIO);
  106         }
  107 }
  108 
  109 static int
  110 lnc_isa_probe(device_t dev)
  111 {
  112         int pnp;
  113 
  114         pnp = ISA_PNP_PROBE(device_get_parent(dev), dev, lnc_pnp_ids);
  115         if (pnp == ENOENT) {
  116                 /* It's not a PNP card, see if we support it by probing it */
  117                 return (lnc_legacy_probe(dev));
  118         } else if (pnp == ENXIO) {
  119                 return (ENXIO);
  120         } else {
  121                 /* Found PNP card we support */
  122                 return (0);
  123         }
  124 }
  125 
  126 static void
  127 lnc_alloc_callback(void *arg, bus_dma_segment_t *seg, int nseg, int error)
  128 {
  129         /* Do nothing */
  130         return;
  131 }
  132 
  133 static int
  134 lnc_isa_attach(device_t dev)
  135 {
  136         lnc_softc_t *sc = device_get_softc(dev);
  137         int err = 0;
  138         bus_size_t lnc_mem_size;
  139 
  140         device_printf(dev, "Attaching %s\n", device_get_desc(dev));
  141 
  142         sc->portrid = 0;
  143         sc->portres = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &sc->portrid,
  144                                           lnc_ioaddr_cnet98s, CNET98S_IOSIZE,
  145                                           RF_ACTIVE);
  146 
  147         if (! sc->portres) {
  148                 device_printf(dev, "Failed to allocate I/O ports\n");
  149                 lnc_release_resources(dev);
  150                 return (ENXIO);
  151         }
  152 
  153         isa_load_resourcev(sc->portres, lnc_ioaddr_cnet98s, CNET98S_IOSIZE);
  154 
  155         sc->lnc_btag = rman_get_bustag(sc->portres);
  156         sc->lnc_bhandle = rman_get_bushandle(sc->portres);
  157 
  158         sc->drqrid = 0;
  159         sc->drqres = NULL;
  160 
  161         if (isa_get_irq(dev) == -1)
  162                 bus_set_resource(dev, SYS_RES_IRQ, 0,  6, 1);
  163 
  164         sc->irqrid = 0;
  165         sc->irqres = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irqrid, 0, ~0, 1,
  166                                         RF_ACTIVE);
  167 
  168         if (! sc->irqres) {
  169                 device_printf(dev, "Failed to allocate irq\n");
  170                 lnc_release_resources(dev);
  171                 return (ENXIO);
  172         }
  173 
  174         err = bus_setup_intr(dev, sc->irqres, INTR_TYPE_NET, lncintr,
  175                              sc, &sc->intrhand);
  176 
  177         if (err) {
  178                 device_printf(dev, "Failed to setup irq handler\n");
  179                 lnc_release_resources(dev);
  180                 return (err);
  181         }
  182 
  183         /* XXX temp setting for nic */
  184         sc->nic.mem_mode = DMA_FIXED;
  185         sc->nrdre  = NRDRE;
  186         sc->ntdre  = NTDRE;
  187 
  188         if (sc->nic.ident == CNET98S) {
  189             sc->rap = CNET98S_RAP;
  190             sc->rdp = CNET98S_RDP;
  191         } else if (sc->nic.ident == NE2100) {
  192             sc->rap = PCNET_RAP;
  193             sc->rdp = PCNET_RDP;
  194             sc->bdp = PCNET_BDP;
  195         } else {
  196             sc->rap = BICC_RAP;
  197             sc->rdp = BICC_RDP;
  198         }
  199 
  200         /* Create a DMA tag describing the ring memory we need */
  201 
  202         lnc_mem_size = ((NDESC(sc->nrdre) + NDESC(sc->ntdre)) *
  203                          sizeof(struct host_ring_entry));
  204 
  205         lnc_mem_size += (NDESC(sc->nrdre) * RECVBUFSIZE) +
  206                         (NDESC(sc->ntdre) * TRANSBUFSIZE);
  207 
  208         err = bus_dma_tag_create(NULL,                  /* parent */
  209                                  4,                     /* alignement */
  210                                  0,                     /* boundary */
  211                                  BUS_SPACE_MAXADDR_24BIT,       /* lowaddr */
  212                                  BUS_SPACE_MAXADDR,     /* highaddr */
  213                                  NULL, NULL,            /* filter, filterarg */
  214                                  lnc_mem_size,          /* segsize */
  215                                  1,                     /* nsegments */
  216                                  BUS_SPACE_MAXSIZE_32BIT,       /* maxsegsize */
  217                                  0,                     /* flags */
  218                                  &sc->dmat);
  219 
  220         if (err) {
  221                 device_printf(dev, "Can't create DMA tag\n");
  222                 lnc_release_resources(dev);
  223                 return (ENOMEM);
  224         }
  225 
  226         err = bus_dmamem_alloc(sc->dmat, (void **)&sc->recv_ring,
  227                                BUS_DMA_NOWAIT, &sc->dmamap);
  228 
  229         if (err) {
  230                 device_printf(dev, "Couldn't allocate memory\n");
  231                 lnc_release_resources(dev);
  232                 return (ENOMEM);
  233         }
  234 
  235         err = bus_dmamap_load(sc->dmat, sc->dmamap, sc->recv_ring, lnc_mem_size,
  236                         lnc_alloc_callback, sc->recv_ring, BUS_DMA_NOWAIT);
  237 
  238         if (err) {
  239                 device_printf(dev, "Couldn't load DMA map\n");
  240                 lnc_release_resources(dev);
  241                 return (ENOMEM);
  242         }
  243 
  244         /* Call generic attach code */
  245         if (! lnc_attach_common(dev)) {
  246                 device_printf(dev, "Generic attach code failed\n");
  247                 lnc_release_resources(dev);
  248                 return (ENXIO);
  249         }
  250 
  251         /*
  252          * ISA Configuration
  253          *
  254          * XXX - Following parameters are Contec C-NET(98)S only.
  255          *       So, check the Ethernet address here.
  256          *
  257          *       Contec uses 00 80 4c ?? ?? ??
  258          */ 
  259         if (sc->arpcom.ac_enaddr[0] == (u_char)0x00 &&
  260             sc->arpcom.ac_enaddr[1] == (u_char)0x80 &&
  261             sc->arpcom.ac_enaddr[2] == (u_char)0x4c) {
  262                 lnc_outw(sc->rap, MSRDA);
  263                 lnc_outw(CNET98S_IDP, 0x0006);
  264                 lnc_outw(sc->rap, MSWRA);
  265                 lnc_outw(CNET98S_IDP, 0x0006);
  266 #ifdef DIAGNOSTIC
  267                 lnc_outw(sc->rap, MC);
  268                 printf("ISACSR2 = %x\n", lnc_inw(CNET98S_IDP));
  269 #endif
  270                 lnc_outw(sc->rap, LED1);
  271                 lnc_outw(CNET98S_IDP, LED_PSE | LED_XMTE);
  272                 lnc_outw(sc->rap, LED2);
  273                 lnc_outw(CNET98S_IDP, LED_PSE | LED_RCVE);
  274                 lnc_outw(sc->rap, LED3);
  275                 lnc_outw(CNET98S_IDP, LED_PSE | LED_COLE);
  276         }
  277 
  278         return (0);
  279 }
  280 
  281 static int
  282 lnc_isa_detach(device_t dev)
  283 {
  284         lnc_softc_t *sc = device_get_softc(dev);
  285         int s = splimp();
  286 
  287         ether_ifdetach(&sc->arpcom.ac_if);
  288         splx(s);
  289 
  290         lnc_stop(sc);
  291         lnc_release_resources(dev);
  292 
  293         return (0);
  294 }
  295 
  296 static device_method_t lnc_isa_methods[] = {
  297 /*      DEVMETHOD(device_identify,      lnc_isa_identify), */
  298         DEVMETHOD(device_probe,         lnc_isa_probe),
  299         DEVMETHOD(device_attach,        lnc_isa_attach),
  300         DEVMETHOD(device_detach,        lnc_isa_detach),
  301 #ifdef notyet
  302         DEVMETHOD(device_suspend,       lnc_isa_suspend),
  303         DEVMETHOD(device_resume,        lnc_isa_resume),
  304         DEVMETHOD(device_shutdown,      lnc_isa_shutdown),
  305 #endif
  306         { 0, 0 }
  307 };
  308 
  309 static driver_t lnc_isa_driver = {
  310         "lnc",
  311         lnc_isa_methods,
  312         sizeof(struct lnc_softc),
  313 };
  314 
  315 DRIVER_MODULE(if_lnc, isa, lnc_isa_driver, lnc_devclass, 0, 0);
Cache object: a5081ae6a8e5ef59c1a2e59152300ab6
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/lnc/if_lnc_cbus.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/lnc/if_lnc_cbus.c
