sys/dev/netif/snc/if_snc.c

   1 /*
   2  * Copyright (c) 1995, David Greenman
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/snc/if_snc.c,v 1.2.2.1 2000/10/21 03:30:03 nyan Exp $
  28  * $DragonFly: src/sys/dev/netif/snc/Attic/if_snc.c,v 1.2 2003/06/17 04:28:29 dillon Exp $
  29  */
  30
  31 /*
  32  *      National Semiconductor  DP8393X SONIC Driver
  33  *
  34  *      This is the bus independent attachment on FreeBSD 4.x
  35  *              written by Motomichi Matsuzaki <mzaki@e-mail.ne.jp>
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/sockio.h>
  41 #include <sys/mbuf.h>
  42 #include <sys/socket.h>
  43 #include <sys/syslog.h>
  44
  45 #include <sys/module.h>
  46 #include <sys/bus.h>
  47 #include <machine/bus.h>
  48 #include <sys/rman.h>
  49 #include <machine/resource.h>
  50
  51 #include <net/ethernet.h>
  52 #include <net/if.h>
  53 #include <net/if_arp.h>
  54 #include <net/if_media.h>
  55 #include <net/if_dl.h>
  56 #include <net/if_mib.h>
  57
  58 #include <net/bpf.h>
  59 #include "opt_bdg.h"
  60 #ifdef BRIDGE
  61 #include <net/bridge.h>
  62 #endif
  63
  64 #include <dev/snc/dp83932reg.h>
  65 #include <dev/snc/dp83932var.h>
  66 #include <dev/snc/dp83932subr.h>
  67 #include <dev/snc/if_sncreg.h>
  68 #include <dev/snc/if_sncvar.h>
  69
  70 /* devclass for "snc" */
  71 devclass_t snc_devclass;
  72
  73 /****************************************************************
  74   Resource management functions
  75  ****************************************************************/
  76
  77 /*
  78  * Allocate a port resource with the given resource id.
  79  */
  80 int
  81 snc_alloc_port(dev, rid)
  82         device_t dev;
  83         int rid;
  84 {
  85         struct snc_softc *sc = device_get_softc(dev);
  86         struct resource *res;
  87
  88         res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
  89                                  0ul, ~0ul, SNEC_NREGS, RF_ACTIVE);
  90         if (res) {
  91                 sc->ioport = res;
  92                 sc->ioport_rid = rid;
  93                 sc->sc_iot = rman_get_bustag(res);
  94                 sc->sc_ioh = rman_get_bushandle(res);
  95                 return (0);
  96         } else {
  97                 device_printf(dev, "can't assign port\n");
  98                 return (ENOENT);
  99         }
 100 }
 101
 102 /*
 103  * Allocate a memory resource with the given resource id.
 104  */
 105 int
 106 snc_alloc_memory(dev, rid)
 107         device_t dev;
 108         int rid;
 109 {
 110         struct snc_softc *sc = device_get_softc(dev);
 111         struct resource *res;
 112
 113         res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
 114                                  0ul, ~0ul, SNEC_NMEMS, RF_ACTIVE);
 115         if (res) {
 116                 sc->iomem = res;
 117                 sc->iomem_rid = rid;
 118                 sc->sc_memt = rman_get_bustag(res);
 119                 sc->sc_memh = rman_get_bushandle(res);
 120                 return (0);
 121         } else {
 122                 device_printf(dev, "can't assign memory\n");
 123                 return (ENOENT);
 124         }
 125 }
 126
 127 /*
 128  * Allocate an irq resource with the given resource id.
 129  */
 130 int
 131 snc_alloc_irq(dev, rid, flags)
 132         device_t dev;
 133         int rid;
 134         int flags;
 135 {
 136         struct snc_softc *sc = device_get_softc(dev);
 137         struct resource *res;
 138
 139         res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid,
 140                                  0ul, ~0ul, 1, (RF_ACTIVE | flags));
 141         if (res) {
 142                 sc->irq = res;
 143                 sc->irq_rid = rid;
 144                 return (0);
 145         } else {
 146                 device_printf(dev, "can't assign irq\n");
 147                 return (ENOENT);
 148         }
 149 }
 150
 151 /*
 152  * Release all resources
 153  */
 154 void
 155 snc_release_resources(dev)
 156         device_t dev;
 157 {
 158         struct snc_softc *sc = device_get_softc(dev);
 159
 160         if (sc->ioport) {
 161                 bus_release_resource(dev, SYS_RES_IOPORT,
 162                                      sc->ioport_rid, sc->ioport);
 163                 sc->ioport = 0;
 164         }
 165         if (sc->iomem) {
 166                 bus_release_resource(dev, SYS_RES_MEMORY,
 167                                      sc->iomem_rid, sc->iomem);
 168                 sc->iomem = 0;
 169         }
 170         if (sc->irq) {
 171                 bus_release_resource(dev, SYS_RES_IRQ,
 172                                      sc->irq_rid, sc->irq);
 173                 sc->irq = 0;
 174         }
 175 }
 176
 177 /****************************************************************
 178   Probe routine
 179  ****************************************************************/
 180
 181 int
 182 snc_probe(dev, type)
 183      device_t dev;
 184      int type;
 185 {
 186         struct snc_softc *sc = device_get_softc(dev);
 187
 188         return snc_nec16_detectsubr(sc->sc_iot, sc->sc_ioh,
 189                                     sc->sc_memt, sc->sc_memh,
 190                                     rman_get_start(sc->irq),
 191                                     rman_get_start(sc->iomem),
 192                                     type);
 193 }
 194
 195 /****************************************************************
 196   Attach routine
 197  ****************************************************************/
 198
 199 int
 200 snc_attach(dev)
 201         device_t dev;
 202 {
 203         struct snc_softc *sc = device_get_softc(dev);
 204         u_int8_t myea[ETHER_ADDR_LEN];
 205
 206         if (snc_nec16_register_irq(sc, rman_get_start(sc->irq)) == 0 ||
 207             snc_nec16_register_mem(sc, rman_get_start(sc->iomem)) == 0) {
 208                 snc_release_resources(dev);
 209                 return(ENOENT);
 210         }
 211
 212         snc_nec16_get_enaddr(sc->sc_iot, sc->sc_ioh, myea);
 213         device_printf(dev, "%s Ethernet\n", snc_nec16_detect_type(myea));
 214
 215         sc->sc_dev = dev;
 216
 217         sc->sncr_dcr = DCR_SYNC | DCR_WAIT0 |
 218             DCR_DMABLOCK | DCR_RFT16 | DCR_TFT28;
 219         sc->sncr_dcr2 = 0;      /* XXX */
 220         sc->bitmode = 0;        /* 16 bit card */
 221
 222         sc->sc_nic_put = snc_nec16_nic_put;
 223         sc->sc_nic_get = snc_nec16_nic_get;
 224         sc->sc_writetodesc = snc_nec16_writetodesc;
 225         sc->sc_readfromdesc = snc_nec16_readfromdesc;
 226         sc->sc_copytobuf = snc_nec16_copytobuf;
 227         sc->sc_copyfrombuf = snc_nec16_copyfrombuf;
 228         sc->sc_zerobuf = snc_nec16_zerobuf;
 229
 230         /* sncsetup returns 1 if something fails */
 231         if (sncsetup(sc, myea)) {
 232                 snc_release_resources(dev);
 233                 return(ENOENT);
 234         }
 235
 236         sncconfig(sc, NULL, 0, 0, myea);
 237
 238         return 0;
 239 }
 240
 241 /****************************************************************
 242   Shutdown routine
 243  ****************************************************************/
 244
 245 void
 246 snc_shutdown(dev)
 247         device_t dev;
 248 {
 249         sncshutdown(device_get_softc(dev));
 250 }