sys/dev/le/if_le_isa.c

   1 /*      $NetBSD: if_le_isa.c,v 1.41 2005/12/24 20:27:41 perry Exp $     */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-2-Clause-NetBSD AND BSD-3-Clause
   5  *
   6  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
  11  * Simulation Facility, NASA Ames Research Center.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*-
  36  * Copyright (c) 1992, 1993
  37  *      The Regents of the University of California.  All rights reserved.
  38  *
  39  * This code is derived from software contributed to Berkeley by
  40  * Ralph Campbell and Rick Macklem.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  *
  66  *      @(#)if_le.c     8.2 (Berkeley) 11/16/93
  67  */
  68
  69 #include <sys/cdefs.h>
  70 __FBSDID("$FreeBSD$");
  71
  72 #include <sys/param.h>
  73 #include <sys/systm.h>
  74 #include <sys/bus.h>
  75 #include <sys/endian.h>
  76 #include <sys/kernel.h>
  77 #include <sys/lock.h>
  78 #include <sys/module.h>
  79 #include <sys/mutex.h>
  80 #include <sys/resource.h>
  81 #include <sys/rman.h>
  82 #include <sys/socket.h>
  83
  84 #include <net/ethernet.h>
  85 #include <net/if.h>
  86 #include <net/if_media.h>
  87
  88 #include <machine/bus.h>
  89 #include <machine/resource.h>
  90
  91 #include <isa/isavar.h>
  92
  93 #include <dev/le/lancereg.h>
  94 #include <dev/le/lancevar.h>
  95 #include <dev/le/am7990var.h>
  96
  97 #define LE_ISA_MEMSIZE  (16*1024)
  98 #define PCNET_RDP       0x10
  99 #define PCNET_RAP       0x12
 100
 101 struct le_isa_softc {
 102         struct am7990_softc     sc_am7990;      /* glue to MI code */
 103
 104         bus_size_t              sc_rap;         /* offsets to LANCE... */
 105         bus_size_t              sc_rdp;         /* ...registers */
 106
 107         struct resource         *sc_rres;
 108
 109         struct resource         *sc_dres;
 110
 111         struct resource         *sc_ires;
 112         void                    *sc_ih;
 113
 114         bus_dma_tag_t           sc_pdmat;
 115         bus_dma_tag_t           sc_dmat;
 116         bus_dmamap_t            sc_dmam;
 117 };
 118
 119 static device_probe_t le_isa_probe;
 120 static device_attach_t le_isa_attach;
 121 static device_detach_t le_isa_detach;
 122 static device_resume_t le_isa_resume;
 123 static device_suspend_t le_isa_suspend;
 124
 125 static device_method_t le_isa_methods[] = {
 126         /* Device interface */
 127         DEVMETHOD(device_probe,         le_isa_probe),
 128         DEVMETHOD(device_attach,        le_isa_attach),
 129         DEVMETHOD(device_detach,        le_isa_detach),
 130         /* We can just use the suspend method here. */
 131         DEVMETHOD(device_shutdown,      le_isa_suspend),
 132         DEVMETHOD(device_suspend,       le_isa_suspend),
 133         DEVMETHOD(device_resume,        le_isa_resume),
 134
 135         { 0, 0 }
 136 };
 137
 138 struct le_isa_param {
 139         const char      *name;
 140         u_long          iosize;
 141         bus_size_t      rap;
 142         bus_size_t      rdp;
 143         bus_size_t      macstart;
 144         int             macstride;
 145 } static const le_isa_params[] = {
 146         { "BICC Isolan", 24, 0xe, 0xc, 0, 2 },
 147         { "Novell NE2100", 16, 0x12, 0x10, 0, 1 }
 148 };
 149
 150 static struct isa_pnp_id le_isa_ids[] = {
 151         { 0x0322690e, "Cabletron E2200 Single Chip" },  /* CSI2203 */
 152         { 0x0110490a, "Boca LANCard Combo" },           /* BRI1001 */
 153         { 0x0100a60a, "Melco Inc. LGY-IV" },            /* BUF0001 */
 154         { 0xd880d041, "Novell NE2100" },                /* PNP80D8 */
 155         { 0x0082d041, "Cabletron E2100 Series DNI" },   /* PNP8200 */
 156         { 0x3182d041, "AMD AM1500T/AM2100" },           /* PNP8231 */
 157         { 0x8c82d041, "AMD PCnet-ISA" },                /* PNP828C */
 158         { 0x8d82d041, "AMD PCnet-32" },                 /* PNP828D */
 159         { 0xcefaedfe, "Racal InterLan EtherBlaster" },  /* _WMFACE */
 160         { 0, NULL }
 161 };
 162
 163 static void le_isa_wrcsr(struct lance_softc *, uint16_t, uint16_t);
 164 static uint16_t le_isa_rdcsr(struct lance_softc *, uint16_t);
 165 static bus_dmamap_callback_t le_isa_dma_callback;
 166 static int le_isa_probe_legacy(device_t, const struct le_isa_param *);
 167
 168 static void
 169 le_isa_wrcsr(struct lance_softc *sc, uint16_t port, uint16_t val)
 170 {
 171         struct le_isa_softc *lesc = (struct le_isa_softc *)sc;
 172
 173         bus_write_2(lesc->sc_rres, lesc->sc_rap, port);
 174         bus_barrier(lesc->sc_rres, lesc->sc_rap, 2, BUS_SPACE_BARRIER_WRITE);
 175         bus_write_2(lesc->sc_rres, lesc->sc_rdp, val);
 176 }
 177
 178 static uint16_t
 179 le_isa_rdcsr(struct lance_softc *sc, uint16_t port)
 180 {
 181         struct le_isa_softc *lesc = (struct le_isa_softc *)sc;
 182
 183         bus_write_2(lesc->sc_rres, lesc->sc_rap, port);
 184         bus_barrier(lesc->sc_rres, lesc->sc_rap, 2, BUS_SPACE_BARRIER_WRITE);
 185         return (bus_read_2(lesc->sc_rres, lesc->sc_rdp));
 186 }
 187
 188 static void
 189 le_isa_dma_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
 190 {
 191         struct lance_softc *sc = (struct lance_softc *)xsc;
 192
 193         if (error != 0)
 194                 return;
 195         KASSERT(nsegs == 1, ("%s: bad DMA segment count", __func__));
 196         sc->sc_addr = segs[0].ds_addr;
 197 }
 198
 199 static int
 200 le_isa_probe_legacy(device_t dev, const struct le_isa_param *leip)
 201 {
 202         struct le_isa_softc *lesc;
 203         struct lance_softc *sc;
 204         int error, i;
 205
 206         lesc = device_get_softc(dev);
 207         sc = &lesc->sc_am7990.lsc;
 208
 209         i = 0;
 210         lesc->sc_rres = bus_alloc_resource_anywhere(dev, SYS_RES_IOPORT, &i,
 211             leip->iosize, RF_ACTIVE);
 212         if (lesc->sc_rres == NULL)
 213                 return (ENXIO);
 214         lesc->sc_rap = leip->rap;
 215         lesc->sc_rdp = leip->rdp;
 216
 217         /* Stop the chip and put it in a known state. */
 218         le_isa_wrcsr(sc, LE_CSR0, LE_C0_STOP);
 219         DELAY(100);
 220         if (le_isa_rdcsr(sc, LE_CSR0) != LE_C0_STOP) {
 221                 error = ENXIO;
 222                 goto fail;
 223         }
 224         le_isa_wrcsr(sc, LE_CSR3, 0);
 225         error = 0;
 226
 227  fail:
 228         bus_release_resource(dev, SYS_RES_IOPORT,
 229             rman_get_rid(lesc->sc_rres), lesc->sc_rres);
 230         return (error);
 231 }
 232
 233 static int
 234 le_isa_probe(device_t dev)
 235 {
 236         int i;
 237
 238         switch (ISA_PNP_PROBE(device_get_parent(dev), dev, le_isa_ids)) {
 239         case 0:
 240                 return (BUS_PROBE_DEFAULT);
 241         case ENOENT:
 242                 for (i = 0; i < nitems(le_isa_params); i++) {
 243                         if (le_isa_probe_legacy(dev, &le_isa_params[i]) == 0) {
 244                                 device_set_desc(dev, le_isa_params[i].name);
 245                                 return (BUS_PROBE_DEFAULT);
 246                         }
 247                 }
 248                 /* FALLTHROUGH */
 249         case ENXIO:
 250         default:
 251                 return (ENXIO);
 252         }
 253 }
 254
 255 static int
 256 le_isa_attach(device_t dev)
 257 {
 258         struct le_isa_softc *lesc;
 259         struct lance_softc *sc;
 260         bus_size_t macstart, rap, rdp;
 261         int error, i, j, macstride;
 262
 263         lesc = device_get_softc(dev);
 264         sc = &lesc->sc_am7990.lsc;
 265
 266         LE_LOCK_INIT(sc, device_get_nameunit(dev));
 267
 268         j = 0;
 269         switch (ISA_PNP_PROBE(device_get_parent(dev), dev, le_isa_ids)) {
 270         case 0:
 271                 lesc->sc_rres = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
 272                     &j, RF_ACTIVE);
 273                 rap = PCNET_RAP;
 274                 rdp = PCNET_RDP;
 275                 macstart = 0;
 276                 macstride = 1;
 277                 break;
 278         case ENOENT:
 279                 for (i = 0; i < nitems(le_isa_params); i++) {
 280                         if (le_isa_probe_legacy(dev, &le_isa_params[i]) == 0) {
 281                                 lesc->sc_rres = bus_alloc_resource_anywhere(dev,
 282                                     SYS_RES_IOPORT, &j,
 283                                     le_isa_params[i].iosize, RF_ACTIVE);
 284                                 rap = le_isa_params[i].rap;
 285                                 rdp = le_isa_params[i].rdp;
 286                                 macstart = le_isa_params[i].macstart;
 287                                 macstride = le_isa_params[i].macstride;
 288                                 goto found;
 289                         }
 290                 }
 291                 /* FALLTHROUGH */
 292         case ENXIO:
 293         default:
 294                 device_printf(dev, "cannot determine chip\n");
 295                 error = ENXIO;
 296                 goto fail_mtx;
 297         }
 298
 299  found:
 300         if (lesc->sc_rres == NULL) {
 301                 device_printf(dev, "cannot allocate registers\n");
 302                 error = ENXIO;
 303                 goto fail_mtx;
 304         }
 305         lesc->sc_rap = rap;
 306         lesc->sc_rdp = rdp;
 307
 308         i = 0;
 309         if ((lesc->sc_dres = bus_alloc_resource_any(dev, SYS_RES_DRQ,
 310             &i, RF_ACTIVE)) == NULL) {
 311                 device_printf(dev, "cannot allocate DMA channel\n");
 312                 error = ENXIO;
 313                 goto fail_rres;
 314         }
 315
 316         i = 0;
 317         if ((lesc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 318             &i, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
 319                 device_printf(dev, "cannot allocate interrupt\n");
 320                 error = ENXIO;
 321                 goto fail_dres;
 322         }
 323
 324         error = bus_dma_tag_create(
 325             bus_get_dma_tag(dev),       /* parent */
 326             1, 0,                       /* alignment, boundary */
 327             BUS_SPACE_MAXADDR_24BIT,    /* lowaddr */
 328             BUS_SPACE_MAXADDR,          /* highaddr */
 329             NULL, NULL,                 /* filter, filterarg */
 330             BUS_SPACE_MAXSIZE_32BIT,    /* maxsize */
 331             0,                          /* nsegments */
 332             BUS_SPACE_MAXSIZE_32BIT,    /* maxsegsize */
 333             0,                          /* flags */
 334             NULL, NULL,                 /* lockfunc, lockarg */
 335             &lesc->sc_pdmat);
 336         if (error != 0) {
 337                 device_printf(dev, "cannot allocate parent DMA tag\n");
 338                 goto fail_ires;
 339         }
 340
 341         sc->sc_memsize = LE_ISA_MEMSIZE;
 342         /*
 343          * For Am79C90, Am79C961 and Am79C961A the init block must be 2-byte
 344          * aligned and the ring descriptors must be 8-byte aligned.
 345          */
 346         error = bus_dma_tag_create(
 347             lesc->sc_pdmat,             /* parent */
 348             8, 0,                       /* alignment, boundary */
 349             BUS_SPACE_MAXADDR_24BIT,    /* lowaddr */
 350             BUS_SPACE_MAXADDR,          /* highaddr */
 351             NULL, NULL,                 /* filter, filterarg */
 352             sc->sc_memsize,             /* maxsize */
 353             1,                          /* nsegments */
 354             sc->sc_memsize,             /* maxsegsize */
 355             0,                          /* flags */
 356             NULL, NULL,                 /* lockfunc, lockarg */
 357             &lesc->sc_dmat);
 358         if (error != 0) {
 359                 device_printf(dev, "cannot allocate buffer DMA tag\n");
 360                 goto fail_pdtag;
 361         }
 362
 363         error = bus_dmamem_alloc(lesc->sc_dmat, (void **)&sc->sc_mem,
 364             BUS_DMA_WAITOK | BUS_DMA_COHERENT, &lesc->sc_dmam);
 365         if (error != 0) {
 366                 device_printf(dev, "cannot allocate DMA buffer memory\n");
 367                 goto fail_dtag;
 368         }
 369
 370         sc->sc_addr = 0;
 371         error = bus_dmamap_load(lesc->sc_dmat, lesc->sc_dmam, sc->sc_mem,
 372             sc->sc_memsize, le_isa_dma_callback, sc, 0);
 373         if (error != 0 || sc->sc_addr == 0) {
 374                 device_printf(dev, "cannot load DMA buffer map\n");
 375                 goto fail_dmem;
 376         }
 377
 378         isa_dmacascade(rman_get_start(lesc->sc_dres));
 379
 380         sc->sc_flags = 0;
 381         sc->sc_conf3 = 0;
 382
 383         /*
 384          * Extract the physical MAC address from the ROM.
 385          */
 386         for (i = 0; i < sizeof(sc->sc_enaddr); i++)
 387                 sc->sc_enaddr[i] = bus_read_1(lesc->sc_rres,
 388                     macstart + i * macstride);
 389
 390         sc->sc_copytodesc = lance_copytobuf_contig;
 391         sc->sc_copyfromdesc = lance_copyfrombuf_contig;
 392         sc->sc_copytobuf = lance_copytobuf_contig;
 393         sc->sc_copyfrombuf = lance_copyfrombuf_contig;
 394         sc->sc_zerobuf = lance_zerobuf_contig;
 395
 396         sc->sc_rdcsr = le_isa_rdcsr;
 397         sc->sc_wrcsr = le_isa_wrcsr;
 398         sc->sc_hwreset = NULL;
 399         sc->sc_hwinit = NULL;
 400         sc->sc_hwintr = NULL;
 401         sc->sc_nocarrier = NULL;
 402         sc->sc_mediachange = NULL;
 403         sc->sc_mediastatus = NULL;
 404         sc->sc_supmedia = NULL;
 405
 406         error = am7990_config(&lesc->sc_am7990, device_get_name(dev),
 407             device_get_unit(dev));
 408         if (error != 0) {
 409                 device_printf(dev, "cannot attach Am7990\n");
 410                 goto fail_dmap;
 411         }
 412
 413         error = bus_setup_intr(dev, lesc->sc_ires, INTR_TYPE_NET | INTR_MPSAFE,
 414             NULL, am7990_intr, sc, &lesc->sc_ih);
 415         if (error != 0) {
 416                 device_printf(dev, "cannot set up interrupt\n");
 417                 goto fail_am7990;
 418         }
 419
 420         return (0);
 421
 422  fail_am7990:
 423         am7990_detach(&lesc->sc_am7990);
 424  fail_dmap:
 425         bus_dmamap_unload(lesc->sc_dmat, lesc->sc_dmam);
 426  fail_dmem:
 427         bus_dmamem_free(lesc->sc_dmat, sc->sc_mem, lesc->sc_dmam);
 428  fail_dtag:
 429         bus_dma_tag_destroy(lesc->sc_dmat);
 430  fail_pdtag:
 431         bus_dma_tag_destroy(lesc->sc_pdmat);
 432  fail_ires:
 433         bus_release_resource(dev, SYS_RES_IRQ,
 434             rman_get_rid(lesc->sc_ires), lesc->sc_ires);
 435  fail_dres:
 436         bus_release_resource(dev, SYS_RES_DRQ,
 437             rman_get_rid(lesc->sc_dres), lesc->sc_dres);
 438  fail_rres:
 439         bus_release_resource(dev, SYS_RES_IOPORT,
 440             rman_get_rid(lesc->sc_rres), lesc->sc_rres);
 441  fail_mtx:
 442         LE_LOCK_DESTROY(sc);
 443         return (error);
 444 }
 445
 446 static int
 447 le_isa_detach(device_t dev)
 448 {
 449         struct le_isa_softc *lesc;
 450         struct lance_softc *sc;
 451
 452         lesc = device_get_softc(dev);
 453         sc = &lesc->sc_am7990.lsc;
 454
 455         bus_teardown_intr(dev, lesc->sc_ires, lesc->sc_ih);
 456         am7990_detach(&lesc->sc_am7990);
 457         bus_dmamap_unload(lesc->sc_dmat, lesc->sc_dmam);
 458         bus_dmamem_free(lesc->sc_dmat, sc->sc_mem, lesc->sc_dmam);
 459         bus_dma_tag_destroy(lesc->sc_dmat);
 460         bus_dma_tag_destroy(lesc->sc_pdmat);
 461         bus_release_resource(dev, SYS_RES_IRQ,
 462             rman_get_rid(lesc->sc_ires), lesc->sc_ires);
 463         bus_release_resource(dev, SYS_RES_DRQ,
 464             rman_get_rid(lesc->sc_dres), lesc->sc_dres);
 465         bus_release_resource(dev, SYS_RES_IOPORT,
 466             rman_get_rid(lesc->sc_rres), lesc->sc_rres);
 467         LE_LOCK_DESTROY(sc);
 468
 469         return (0);
 470 }
 471
 472 static int
 473 le_isa_suspend(device_t dev)
 474 {
 475         struct le_isa_softc *lesc;
 476
 477         lesc = device_get_softc(dev);
 478
 479         lance_suspend(&lesc->sc_am7990.lsc);
 480
 481         return (0);
 482 }
 483
 484 static int
 485 le_isa_resume(device_t dev)
 486 {
 487         struct le_isa_softc *lesc;
 488
 489         lesc = device_get_softc(dev);
 490
 491         lance_resume(&lesc->sc_am7990.lsc);
 492
 493         return (0);
 494 }
 495
 496 DEFINE_CLASS_0(le, le_isa_driver, le_isa_methods, sizeof(struct le_isa_softc));
 497 DRIVER_MODULE(le, isa, le_isa_driver, le_devclass, 0, 0);
 498 MODULE_DEPEND(le, ether, 1, 1, 1);
 499 ISA_PNP_INFO(le_isa_ids);