sys/dev/netif/fea/if_fea.c

   1 /*-
   2  * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
   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, this list of conditions and the following disclaimer.
  10  * 2. The name of the author may not be used to endorse or promote products
  11  *    derived from this software withough specific prior written permission
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  *
  24  * $FreeBSD: src/sys/dev/pdq/if_fea.c,v 1.19 2000/01/14 07:14:03 peter Exp $
  25  * $DragonFly: src/sys/dev/netif/fea/Attic/if_fea.c,v 1.3 2003/08/07 21:17:02 dillon Exp $
  26  */
  27
  28 /*
  29  * DEC PDQ FDDI Controller
  30  *
  31  *      This module support the DEFEA EISA FDDI Controller.
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/kernel.h>
  37 #include <sys/socket.h>
  38
  39 #include <net/if.h>
  40 #include <net/if_arp.h>
  41
  42 #include <sys/module.h>
  43 #include <sys/bus.h>
  44 #include <machine/bus.h>
  45 #include <machine/resource.h>
  46 #include <sys/rman.h>
  47 #include <bus/eisa/eisaconf.h>
  48 #include <dev/netif/pdq_layer/pdqvar.h>
  49 #include <dev/netif/pdq_layer/pdqreg.h>
  50
  51 static void             pdq_eisa_subprobe       __P((pdq_bus_t, u_int32_t, u_int32_t *, u_int32_t *, u_int32_t *));
  52 static void             pdq_eisa_devinit        __P((pdq_softc_t *));
  53 static const char *     pdq_eisa_match          __P((eisa_id_t));
  54 static int              pdq_eisa_probe          __P((device_t));
  55 static int              pdq_eisa_attach         __P((device_t));
  56 void                    pdq_eisa_intr           __P((void *));
  57 static int              pdq_eisa_shutdown       __P((device_t));
  58
  59 #define DEFEA_IRQS                      0x0000FBA9U
  60
  61 #define DEFEA_INTRENABLE                0x8     /* level interrupt */
  62 #define DEFEA_DECODE_IRQ(n)             ((DEFEA_IRQS >> ((n) << 2)) & 0x0f)
  63
  64 #define EISA_DEVICE_ID_DEC_DEC3001      0x10a33001
  65 #define EISA_DEVICE_ID_DEC_DEC3002      0x10a33002
  66 #define EISA_DEVICE_ID_DEC_DEC3003      0x10a33003
  67 #define EISA_DEVICE_ID_DEC_DEC3004      0x10a33004
  68
  69 static void
  70 pdq_eisa_subprobe(bc, iobase, maddr, msize, irq)
  71         pdq_bus_t       bc;
  72         u_int32_t       iobase;
  73         u_int32_t       *maddr;
  74         u_int32_t       *msize;
  75         u_int32_t       *irq;
  76 {
  77         if (irq != NULL)
  78                 *irq = DEFEA_DECODE_IRQ(PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_IO_CONFIG_STAT_0) & 3);
  79         *maddr = (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_CMP_0) << 8)
  80                  | (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_CMP_1) << 16);
  81         *msize = (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_MASK_0) + 4) << 8;
  82
  83         return;
  84 }
  85
  86 static void
  87 pdq_eisa_devinit (sc)
  88         pdq_softc_t     *sc;
  89 {
  90         pdq_uint8_t     data;
  91
  92         /*
  93          * Do the standard initialization for the DEFEA registers.
  94          */
  95         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_FUNCTION_CTRL, 0x23);
  96         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CMP_1_1, (sc->sc_iobase >> 8) & 0xF0);
  97         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CMP_0_1, (sc->sc_iobase >> 8) & 0xF0);
  98         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_SLOT_CTRL, 0x01);
  99         data = PDQ_OS_IORD_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF);
 100 #if defined(PDQ_IOMAPPED)
 101         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF, data & ~1);
 102 #else
 103         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF, data | 1);
 104 #endif
 105         data = PDQ_OS_IORD_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CONFIG_STAT_0);
 106         PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CONFIG_STAT_0, data | DEFEA_INTRENABLE);
 107
 108         return;
 109 }
 110
 111 static const char *
 112 pdq_eisa_match (type)
 113         eisa_id_t       type;
 114 {
 115         switch (type) {
 116                 case EISA_DEVICE_ID_DEC_DEC3001:
 117                 case EISA_DEVICE_ID_DEC_DEC3002:
 118                 case EISA_DEVICE_ID_DEC_DEC3003:
 119                 case EISA_DEVICE_ID_DEC_DEC3004:
 120                         return ("DEC FDDIcontroller/EISA Adapter");
 121                         break;
 122                  default:
 123                         break;
 124         }
 125         return (NULL);
 126 }
 127
 128 static int
 129 pdq_eisa_probe (dev)
 130         device_t        dev;
 131 {
 132         const char      *desc;
 133         u_int32_t       iobase;
 134         u_int32_t       irq;
 135         u_int32_t       maddr;
 136         u_int32_t       msize;
 137
 138         u_int32_t       eisa_id = eisa_get_id(dev);;
 139
 140         desc = pdq_eisa_match(eisa_id);
 141         if (!desc) {
 142                 return (ENXIO);
 143         }
 144
 145         device_set_desc(dev, desc);
 146
 147         iobase = eisa_get_slot(dev) * EISA_SLOT_SIZE;
 148         pdq_eisa_subprobe(PDQ_BUS_EISA, iobase, &maddr, &msize, &irq);
 149
 150         eisa_add_iospace(dev, iobase, 0x200, RESVADDR_NONE);
 151         eisa_add_mspace(dev, maddr, msize, RESVADDR_NONE);
 152         eisa_add_intr(dev, irq, EISA_TRIGGER_LEVEL);
 153
 154         return (0);
 155 }
 156
 157 void
 158 pdq_eisa_intr(xdev)
 159         void            *xdev;
 160 {
 161         device_t        dev = (device_t) xdev;
 162         pdq_softc_t     *sc = device_get_softc(dev);
 163         (void) pdq_interrupt(sc->sc_pdq);
 164
 165         return;
 166 }
 167
 168 static int
 169 pdq_eisa_attach (dev)
 170         device_t                dev;
 171 {
 172         pdq_softc_t             *sc = device_get_softc(dev);
 173         struct resource         *io = 0;
 174         struct resource         *irq = 0;
 175         struct resource         *mspace = 0;
 176         int                     rid;
 177         void                    *ih;
 178         u_int32_t               m_addr, m_size;
 179
 180         rid = 0;
 181         io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
 182                                 0, ~0, 1, RF_ACTIVE);
 183
 184         if (!io) {
 185                 device_printf(dev, "No I/O space?!\n");
 186                 goto bad;
 187         }
 188
 189         rid = 0;
 190         mspace = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
 191                                     0, ~0, 1, RF_ACTIVE);
 192
 193         if (!mspace) {
 194                 device_printf(dev, "No memory space?!\n");
 195                 goto bad;
 196         }
 197
 198         rid = 0;
 199         irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid,
 200                                  0, ~0, 1, RF_ACTIVE);
 201
 202         if (!irq) {
 203                 device_printf(dev, "No, irq?!\n");
 204                 goto bad;
 205         }
 206
 207         m_addr = rman_get_start(mspace);
 208         m_size = (rman_get_end(mspace) - rman_get_start(mspace)) + 1;
 209
 210         sc->sc_iobase = (pdq_bus_ioport_t) rman_get_start(io);
 211         sc->sc_membase = (pdq_bus_memaddr_t) pmap_mapdev(m_addr, m_size);
 212         sc->sc_if.if_name = "fea";
 213         sc->sc_if.if_unit = device_get_unit(dev);
 214
 215         pdq_eisa_devinit(sc);
 216         sc->sc_pdq = pdq_initialize(PDQ_BUS_EISA, sc->sc_membase,
 217                                     sc->sc_if.if_name, sc->sc_if.if_unit,
 218                                     (void *) sc, PDQ_DEFEA);
 219         if (sc->sc_pdq == NULL) {
 220                 device_printf(dev, "initialization failed\n");
 221                 goto bad;
 222         }
 223
 224         if (bus_setup_intr(dev, irq, INTR_TYPE_NET, pdq_eisa_intr, dev, &ih)) {
 225                 goto bad;
 226         }
 227
 228         bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
 229         pdq_ifattach(sc, NULL);
 230
 231         return (0);
 232
 233 bad:
 234         if (io)
 235                 bus_release_resource(dev, SYS_RES_IOPORT, 0, io);
 236         if (irq)
 237                 bus_release_resource(dev, SYS_RES_IRQ, 0, irq);
 238         if (mspace)
 239                 bus_release_resource(dev, SYS_RES_MEMORY, 0, mspace);
 240
 241         return (-1);
 242 }
 243
 244 static int
 245 pdq_eisa_shutdown(dev)
 246         device_t        dev;
 247 {
 248         pdq_softc_t     *sc = device_get_softc(dev);
 249
 250         pdq_hwreset(sc->sc_pdq);
 251
 252         return (0);
 253 }
 254
 255 static device_method_t pdq_eisa_methods[] = {
 256         DEVMETHOD(device_probe,         pdq_eisa_probe),
 257         DEVMETHOD(device_attach,        pdq_eisa_attach),
 258         DEVMETHOD(device_shutdown,      pdq_eisa_shutdown),
 259
 260         { 0, 0 }
 261 };
 262
 263 static driver_t pdq_eisa_driver = {
 264         "fea",
 265         pdq_eisa_methods,
 266         sizeof(pdq_softc_t),
 267 };
 268
 269 static devclass_t pdq_devclass;
 270
 271 DRIVER_MODULE(pdq, eisa, pdq_eisa_driver, pdq_devclass, 0, 0);