sys/dev/le/lance.c

   1 /*      $NetBSD: lance.c,v 1.34 2005/12/24 20:27:30 perry Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
   9  * Simulation Facility, NASA Ames Research Center.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*-
  34  * Copyright (c) 1992, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  *
  37  * This code is derived from software contributed to Berkeley by
  38  * Ralph Campbell and Rick Macklem.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions
  42  * are met:
  43  * 1. Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  * 2. Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in the
  47  *    documentation and/or other materials provided with the distribution.
  48  * 3. Neither the name of the University nor the names of its contributors
  49  *    may be used to endorse or promote products derived from this software
  50  *    without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  62  * SUCH DAMAGE.
  63  *
  64  *      @(#)if_le.c     8.2 (Berkeley) 11/16/93
  65  */
  66
  67 #include <sys/cdefs.h>
  68 __FBSDID("$FreeBSD$");
  69
  70 #include <sys/param.h>
  71 #include <sys/bus.h>
  72 #include <sys/endian.h>
  73 #include <sys/lock.h>
  74 #include <sys/kernel.h>
  75 #include <sys/mbuf.h>
  76 #include <sys/mutex.h>
  77 #include <sys/socket.h>
  78 #include <sys/sockio.h>
  79
  80 #include <net/ethernet.h>
  81 #include <net/if.h>
  82 #include <net/if_var.h>
  83 #include <net/if_arp.h>
  84 #include <net/if_dl.h>
  85 #include <net/if_media.h>
  86 #include <net/if_types.h>
  87 #include <net/if_vlan_var.h>
  88
  89 #include <machine/bus.h>
  90
  91 #include <dev/le/lancereg.h>
  92 #include <dev/le/lancevar.h>
  93
  94 devclass_t le_devclass;
  95
  96 static void lance_start(struct ifnet *);
  97 static void lance_stop(struct lance_softc *);
  98 static void lance_init(void *);
  99 static void lance_watchdog(void *s);
 100 static int lance_mediachange(struct ifnet *);
 101 static void lance_mediastatus(struct ifnet *, struct ifmediareq *);
 102 static int lance_ioctl(struct ifnet *, u_long, caddr_t);
 103
 104 int
 105 lance_config(struct lance_softc *sc, const char* name, int unit)
 106 {
 107         struct ifnet *ifp;
 108         int i, nbuf;
 109
 110         if (LE_LOCK_INITIALIZED(sc) == 0)
 111                 return (ENXIO);
 112
 113         ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
 114         if (ifp == NULL)
 115                 return (ENOSPC);
 116
 117         callout_init_mtx(&sc->sc_wdog_ch, &sc->sc_mtx, 0);
 118
 119         /* Initialize ifnet structure. */
 120         ifp->if_softc = sc;
 121         if_initname(ifp, name, unit);
 122         ifp->if_start = lance_start;
 123         ifp->if_ioctl = lance_ioctl;
 124         ifp->if_init = lance_init;
 125         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 126 #ifdef LANCE_REVC_BUG
 127         ifp->if_flags &= ~IFF_MULTICAST;
 128 #endif
 129         ifp->if_baudrate = IF_Mbps(10);
 130         IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
 131         ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
 132         IFQ_SET_READY(&ifp->if_snd);
 133
 134         /* Initialize ifmedia structures. */
 135         ifmedia_init(&sc->sc_media, 0, lance_mediachange, lance_mediastatus);
 136         if (sc->sc_supmedia != NULL) {
 137                 for (i = 0; i < sc->sc_nsupmedia; i++)
 138                         ifmedia_add(&sc->sc_media, sc->sc_supmedia[i], 0, NULL);
 139                 ifmedia_set(&sc->sc_media, sc->sc_defaultmedia);
 140         } else {
 141                 ifmedia_add(&sc->sc_media,
 142                     IFM_MAKEWORD(IFM_ETHER, IFM_MANUAL, 0, 0), 0, NULL);
 143                 ifmedia_set(&sc->sc_media,
 144                     IFM_MAKEWORD(IFM_ETHER, IFM_MANUAL, 0, 0));
 145         }
 146
 147         switch (sc->sc_memsize) {
 148         case 8192:
 149                 sc->sc_nrbuf = 4;
 150                 sc->sc_ntbuf = 1;
 151                 break;
 152         case 16384:
 153                 sc->sc_nrbuf = 8;
 154                 sc->sc_ntbuf = 2;
 155                 break;
 156         case 32768:
 157                 sc->sc_nrbuf = 16;
 158                 sc->sc_ntbuf = 4;
 159                 break;
 160         case 65536:
 161                 sc->sc_nrbuf = 32;
 162                 sc->sc_ntbuf = 8;
 163                 break;
 164         case 131072:
 165                 sc->sc_nrbuf = 64;
 166                 sc->sc_ntbuf = 16;
 167                 break;
 168         case 262144:
 169                 sc->sc_nrbuf = 128;
 170                 sc->sc_ntbuf = 32;
 171                 break;
 172         default:
 173                 /* weird memory size; cope with it */
 174                 nbuf = sc->sc_memsize / LEBLEN;
 175                 sc->sc_ntbuf = nbuf / 5;
 176                 sc->sc_nrbuf = nbuf - sc->sc_ntbuf;
 177         }
 178
 179         if_printf(ifp, "%d receive buffers, %d transmit buffers\n",
 180             sc->sc_nrbuf, sc->sc_ntbuf);
 181
 182         /* Make sure the chip is stopped. */
 183         LE_LOCK(sc);
 184         lance_stop(sc);
 185         LE_UNLOCK(sc);
 186
 187         return (0);
 188 }
 189
 190 void
 191 lance_attach(struct lance_softc *sc)
 192 {
 193         struct ifnet *ifp = sc->sc_ifp;
 194
 195         /* Attach the interface. */
 196         ether_ifattach(ifp, sc->sc_enaddr);
 197
 198         /* Claim 802.1q capability. */
 199         ifp->if_hdrlen = sizeof(struct ether_vlan_header);
 200         ifp->if_capabilities |= IFCAP_VLAN_MTU;
 201         ifp->if_capenable |= IFCAP_VLAN_MTU;
 202 }
 203
 204 void
 205 lance_detach(struct lance_softc *sc)
 206 {
 207         struct ifnet *ifp = sc->sc_ifp;
 208
 209         LE_LOCK(sc);
 210         lance_stop(sc);
 211         LE_UNLOCK(sc);
 212         callout_drain(&sc->sc_wdog_ch);
 213         ether_ifdetach(ifp);
 214         if_free(ifp);
 215 }
 216
 217 void
 218 lance_suspend(struct lance_softc *sc)
 219 {
 220
 221         LE_LOCK(sc);
 222         lance_stop(sc);
 223         LE_UNLOCK(sc);
 224 }
 225
 226 void
 227 lance_resume(struct lance_softc *sc)
 228 {
 229
 230         LE_LOCK(sc);
 231         if (sc->sc_ifp->if_flags & IFF_UP)
 232                 lance_init_locked(sc);
 233         LE_UNLOCK(sc);
 234 }
 235
 236 static void
 237 lance_start(struct ifnet *ifp)
 238 {
 239         struct lance_softc *sc = ifp->if_softc;
 240
 241         LE_LOCK(sc);
 242         (*sc->sc_start_locked)(sc);
 243         LE_UNLOCK(sc);
 244 }
 245
 246 static void
 247 lance_stop(struct lance_softc *sc)
 248 {
 249         struct ifnet *ifp = sc->sc_ifp;
 250
 251         LE_LOCK_ASSERT(sc, MA_OWNED);
 252
 253         /*
 254          * Mark the interface down and cancel the watchdog timer.
 255          */
 256         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 257         callout_stop(&sc->sc_wdog_ch);
 258         sc->sc_wdog_timer = 0;
 259
 260         (*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_STOP);
 261 }
 262
 263 static void
 264 lance_init(void *xsc)
 265 {
 266         struct lance_softc *sc = (struct lance_softc *)xsc;
 267
 268         LE_LOCK(sc);
 269         lance_init_locked(sc);
 270         LE_UNLOCK(sc);
 271 }
 272
 273 /*
 274  * Initialization of interface; set up initialization block
 275  * and transmit/receive descriptor rings.
 276  */
 277 void
 278 lance_init_locked(struct lance_softc *sc)
 279 {
 280         struct ifnet *ifp = sc->sc_ifp;
 281         u_long a;
 282         int timo;
 283
 284         LE_LOCK_ASSERT(sc, MA_OWNED);
 285
 286         (*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_STOP);
 287         DELAY(100);
 288
 289         /* Newer LANCE chips have a reset register. */
 290         if (sc->sc_hwreset)
 291                 (*sc->sc_hwreset)(sc);
 292
 293         /* Set the correct byte swapping mode, etc. */
 294         (*sc->sc_wrcsr)(sc, LE_CSR3, sc->sc_conf3);
 295
 296         /* Set the current media. This may require the chip to be stopped. */
 297         if (sc->sc_mediachange)
 298                 (void)(*sc->sc_mediachange)(sc);
 299
 300         /*
 301          * Update our private copy of the Ethernet address.
 302          * We NEED the copy so we can ensure its alignment!
 303          */
 304         memcpy(sc->sc_enaddr, IF_LLADDR(ifp), ETHER_ADDR_LEN);
 305
 306         /* Set up LANCE init block. */
 307         (*sc->sc_meminit)(sc);
 308
 309         /* Give LANCE the physical address of its init block. */
 310         a = sc->sc_addr + LE_INITADDR(sc);
 311         (*sc->sc_wrcsr)(sc, LE_CSR1, a & 0xffff);
 312         (*sc->sc_wrcsr)(sc, LE_CSR2, a >> 16);
 313
 314         /* Try to initialize the LANCE. */
 315         DELAY(100);
 316         (*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_INIT);
 317
 318         /* Wait for initialization to finish. */
 319         for (timo = 100000; timo; timo--)
 320                 if ((*sc->sc_rdcsr)(sc, LE_CSR0) & LE_C0_IDON)
 321                         break;
 322
 323         if ((*sc->sc_rdcsr)(sc, LE_CSR0) & LE_C0_IDON) {
 324                 /* Start the LANCE. */
 325                 (*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_INEA | LE_C0_STRT);
 326                 ifp->if_drv_flags |= IFF_DRV_RUNNING;
 327                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 328                 sc->sc_wdog_timer = 0;
 329                 callout_reset(&sc->sc_wdog_ch, hz, lance_watchdog, sc);
 330                 (*sc->sc_start_locked)(sc);
 331         } else
 332                 if_printf(ifp, "controller failed to initialize\n");
 333
 334         if (sc->sc_hwinit)
 335                 (*sc->sc_hwinit)(sc);
 336 }
 337
 338 /*
 339  * Routine to copy from mbuf chain to transmit buffer in
 340  * network buffer memory.
 341  */
 342 int
 343 lance_put(struct lance_softc *sc, int boff, struct mbuf *m)
 344 {
 345         struct mbuf *n;
 346         int len, tlen = 0;
 347
 348         LE_LOCK_ASSERT(sc, MA_OWNED);
 349
 350         for (; m; m = n) {
 351                 len = m->m_len;
 352                 if (len == 0) {
 353                         n = m_free(m);
 354                         m = NULL;
 355                         continue;
 356                 }
 357                 (*sc->sc_copytobuf)(sc, mtod(m, caddr_t), boff, len);
 358                 boff += len;
 359                 tlen += len;
 360                 n = m_free(m);
 361                 m = NULL;
 362         }
 363         if (tlen < LEMINSIZE) {
 364                 (*sc->sc_zerobuf)(sc, boff, LEMINSIZE - tlen);
 365                 tlen = LEMINSIZE;
 366         }
 367         return (tlen);
 368 }
 369
 370 /*
 371  * Pull data off an interface.
 372  * Len is length of data, with local net header stripped.
 373  * We copy the data into mbufs.  When full cluster sized units are present
 374  * we copy into clusters.
 375  */
 376 struct mbuf *
 377 lance_get(struct lance_softc *sc, int boff, int totlen)
 378 {
 379         struct ifnet *ifp = sc->sc_ifp;
 380         struct mbuf *m, *m0, *newm;
 381         caddr_t newdata;
 382         int len;
 383
 384         if (totlen <= ETHER_HDR_LEN || totlen > LEBLEN - ETHER_CRC_LEN) {
 385 #ifdef LEDEBUG
 386                 if_printf(ifp, "invalid packet size %d; dropping\n", totlen);
 387 #endif
 388                 return (NULL);
 389         }
 390
 391         MGETHDR(m0, M_NOWAIT, MT_DATA);
 392         if (m0 == NULL)
 393                 return (NULL);
 394         m0->m_pkthdr.rcvif = ifp;
 395         m0->m_pkthdr.len = totlen;
 396         len = MHLEN;
 397         m = m0;
 398
 399         while (totlen > 0) {
 400                 if (totlen >= MINCLSIZE) {
 401                         MCLGET(m, M_NOWAIT);
 402                         if ((m->m_flags & M_EXT) == 0)
 403                                 goto bad;
 404                         len = MCLBYTES;
 405                 }
 406
 407                 if (m == m0) {
 408                         newdata = (caddr_t)
 409                             ALIGN(m->m_data + ETHER_HDR_LEN) - ETHER_HDR_LEN;
 410                         len -= newdata - m->m_data;
 411                         m->m_data = newdata;
 412                 }
 413
 414                 m->m_len = len = min(totlen, len);
 415                 (*sc->sc_copyfrombuf)(sc, mtod(m, caddr_t), boff, len);
 416                 boff += len;
 417
 418                 totlen -= len;
 419                 if (totlen > 0) {
 420                         MGET(newm, M_NOWAIT, MT_DATA);
 421                         if (newm == 0)
 422                                 goto bad;
 423                         len = MLEN;
 424                         m = m->m_next = newm;
 425                 }
 426         }
 427
 428         return (m0);
 429
 430  bad:
 431         m_freem(m0);
 432         return (NULL);
 433 }
 434
 435 static void
 436 lance_watchdog(void *xsc)
 437 {
 438         struct lance_softc *sc = (struct lance_softc *)xsc;
 439         struct ifnet *ifp = sc->sc_ifp;
 440
 441         LE_LOCK_ASSERT(sc, MA_OWNED);
 442
 443         if (sc->sc_wdog_timer == 0 || --sc->sc_wdog_timer != 0) {
 444                 callout_reset(&sc->sc_wdog_ch, hz, lance_watchdog, sc);
 445                 return;
 446         }
 447
 448         if_printf(ifp, "device timeout\n");
 449         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 450         lance_init_locked(sc);
 451 }
 452
 453 static int
 454 lance_mediachange(struct ifnet *ifp)
 455 {
 456         struct lance_softc *sc = ifp->if_softc;
 457
 458         if (sc->sc_mediachange) {
 459                 /*
 460                  * For setting the port in LE_CSR15 the PCnet chips must
 461                  * be powered down or stopped and unlike documented may
 462                  * not take effect without an initialization. So don't
 463                  * invoke (*sc_mediachange) directly here but go through
 464                  * lance_init_locked().
 465                  */
 466                 LE_LOCK(sc);
 467                 lance_stop(sc);
 468                 lance_init_locked(sc);
 469                 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
 470                         (*sc->sc_start_locked)(sc);
 471                 LE_UNLOCK(sc);
 472         }
 473         return (0);
 474 }
 475
 476 static void
 477 lance_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
 478 {
 479         struct lance_softc *sc = ifp->if_softc;
 480
 481         LE_LOCK(sc);
 482         if (!(ifp->if_flags & IFF_UP)) {
 483                 LE_UNLOCK(sc);
 484                 return;
 485         }
 486
 487         ifmr->ifm_status = IFM_AVALID;
 488         if (sc->sc_flags & LE_CARRIER)
 489                 ifmr->ifm_status |= IFM_ACTIVE;
 490
 491         if (sc->sc_mediastatus)
 492                 (*sc->sc_mediastatus)(sc, ifmr);
 493         LE_UNLOCK(sc);
 494 }
 495
 496 /*
 497  * Process an ioctl request.
 498  */
 499 static int
 500 lance_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 501 {
 502         struct lance_softc *sc = ifp->if_softc;
 503         struct ifreq *ifr = (struct ifreq *)data;
 504         int error = 0;
 505
 506         switch (cmd) {
 507         case SIOCSIFFLAGS:
 508                 LE_LOCK(sc);
 509                 if (ifp->if_flags & IFF_PROMISC) {
 510                         if (!(sc->sc_flags & LE_PROMISC)) {
 511                                 sc->sc_flags |= LE_PROMISC;
 512                                 lance_init_locked(sc);
 513                         }
 514                 } else if (sc->sc_flags & LE_PROMISC) {
 515                         sc->sc_flags &= ~LE_PROMISC;
 516                         lance_init_locked(sc);
 517                 }
 518
 519                 if ((ifp->if_flags & IFF_ALLMULTI) &&
 520                     !(sc->sc_flags & LE_ALLMULTI)) {
 521                         sc->sc_flags |= LE_ALLMULTI;
 522                         lance_init_locked(sc);
 523                 } else if (!(ifp->if_flags & IFF_ALLMULTI) &&
 524                     (sc->sc_flags & LE_ALLMULTI)) {
 525                         sc->sc_flags &= ~LE_ALLMULTI;
 526                         lance_init_locked(sc);
 527                 }
 528
 529                 if (!(ifp->if_flags & IFF_UP) &&
 530                     ifp->if_drv_flags & IFF_DRV_RUNNING) {
 531                         /*
 532                          * If interface is marked down and it is running, then
 533                          * stop it.
 534                          */
 535                         lance_stop(sc);
 536                 } else if (ifp->if_flags & IFF_UP &&
 537                     !(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 538                         /*
 539                          * If interface is marked up and it is stopped, then
 540                          * start it.
 541                          */
 542                         lance_init_locked(sc);
 543                 }
 544 #ifdef LEDEBUG
 545                 if (ifp->if_flags & IFF_DEBUG)
 546                         sc->sc_flags |= LE_DEBUG;
 547                 else
 548                         sc->sc_flags &= ~LE_DEBUG;
 549 #endif
 550                 LE_UNLOCK(sc);
 551                 break;
 552
 553         case SIOCADDMULTI:
 554         case SIOCDELMULTI:
 555                 /*
 556                  * Multicast list has changed; set the hardware filter
 557                  * accordingly.
 558                  */
 559                 LE_LOCK(sc);
 560                 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 561                         lance_init_locked(sc);
 562                 LE_UNLOCK(sc);
 563                 break;
 564
 565         case SIOCGIFMEDIA:
 566         case SIOCSIFMEDIA:
 567                 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
 568                 break;
 569
 570         default:
 571                 error = ether_ioctl(ifp, cmd, data);
 572                 break;
 573         }
 574
 575         return (error);
 576 }
 577
 578 /*
 579  * Set up the logical address filter.
 580  */
 581 void
 582 lance_setladrf(struct lance_softc *sc, uint16_t *af)
 583 {
 584         struct ifnet *ifp = sc->sc_ifp;
 585         struct ifmultiaddr *ifma;
 586         uint32_t crc;
 587
 588         /*
 589          * Set up multicast address filter by passing all multicast addresses
 590          * through a crc generator, and then using the high order 6 bits as an
 591          * index into the 64 bit logical address filter.  The high order bit
 592          * selects the word, while the rest of the bits select the bit within
 593          * the word.
 594          */
 595
 596         if (ifp->if_flags & IFF_PROMISC || sc->sc_flags & LE_ALLMULTI) {
 597                 af[0] = af[1] = af[2] = af[3] = 0xffff;
 598                 return;
 599         }
 600
 601         af[0] = af[1] = af[2] = af[3] = 0x0000;
 602         if_maddr_rlock(ifp);
 603         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 604                 if (ifma->ifma_addr->sa_family != AF_LINK)
 605                         continue;
 606
 607                 crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
 608                     ifma->ifma_addr), ETHER_ADDR_LEN);
 609
 610                 /* Just want the 6 most significant bits. */
 611                 crc >>= 26;
 612
 613                 /* Set the corresponding bit in the filter. */
 614                 af[crc >> 4] |= LE_HTOLE16(1 << (crc & 0xf));
 615         }
 616         if_maddr_runlock(ifp);
 617 }
 618
 619 /*
 620  * Routines for accessing the transmit and receive buffers.
 621  * The various CPU and adapter configurations supported by this
 622  * driver require three different access methods for buffers
 623  * and descriptors:
 624  *      (1) contig (contiguous data; no padding),
 625  *      (2) gap2 (two bytes of data followed by two bytes of padding),
 626  *      (3) gap16 (16 bytes of data followed by 16 bytes of padding).
 627  */
 628
 629 /*
 630  * contig: contiguous data with no padding.
 631  *
 632  * Buffers may have any alignment.
 633  */
 634
 635 void
 636 lance_copytobuf_contig(struct lance_softc *sc, void *from, int boff, int len)
 637 {
 638         volatile caddr_t buf = sc->sc_mem;
 639
 640         /*
 641          * Just call memcpy() to do the work.
 642          */
 643         memcpy(buf + boff, from, len);
 644 }
 645
 646 void
 647 lance_copyfrombuf_contig(struct lance_softc *sc, void *to, int boff, int len)
 648 {
 649         volatile caddr_t buf = sc->sc_mem;
 650
 651         /*
 652          * Just call memcpy() to do the work.
 653          */
 654         memcpy(to, buf + boff, len);
 655 }
 656
 657 void
 658 lance_zerobuf_contig(struct lance_softc *sc, int boff, int len)
 659 {
 660         volatile caddr_t buf = sc->sc_mem;
 661
 662         /*
 663          * Just let memset() do the work
 664          */
 665         memset(buf + boff, 0, len);
 666 }
 667
 668 #if 0
 669 /*
 670  * Examples only; duplicate these and tweak (if necessary) in
 671  * machine-specific front-ends.
 672  */
 673
 674 /*
 675  * gap2: two bytes of data followed by two bytes of pad.
 676  *
 677  * Buffers must be 4-byte aligned.  The code doesn't worry about
 678  * doing an extra byte.
 679  */
 680
 681 static void
 682 lance_copytobuf_gap2(struct lance_softc *sc, void *fromv, int boff, int len)
 683 {
 684         volatile caddr_t buf = sc->sc_mem;
 685         caddr_t from = fromv;
 686         volatile uint16_t *bptr;
 687
 688         if (boff & 0x1) {
 689                 /* Handle unaligned first byte. */
 690                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 691                 *bptr = (*from++ << 8) | (*bptr & 0xff);
 692                 bptr += 2;
 693                 len--;
 694         } else
 695                 bptr = ((volatile uint16_t *)buf) + boff;
 696         while (len > 1) {
 697                 *bptr = (from[1] << 8) | (from[0] & 0xff);
 698                 bptr += 2;
 699                 from += 2;
 700                 len -= 2;
 701         }
 702         if (len == 1)
 703                 *bptr = (uint16_t)*from;
 704 }
 705
 706 static void
 707 lance_copyfrombuf_gap2(struct lance_softc *sc, void *tov, int boff, int len)
 708 {
 709         volatile caddr_t buf = sc->sc_mem;
 710         caddr_t to = tov;
 711         volatile uint16_t *bptr;
 712         uint16_t tmp;
 713
 714         if (boff & 0x1) {
 715                 /* Handle unaligned first byte. */
 716                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 717                 *to++ = (*bptr >> 8) & 0xff;
 718                 bptr += 2;
 719                 len--;
 720         } else
 721                 bptr = ((volatile uint16_t *)buf) + boff;
 722         while (len > 1) {
 723                 tmp = *bptr;
 724                 *to++ = tmp & 0xff;
 725                 *to++ = (tmp >> 8) & 0xff;
 726                 bptr += 2;
 727                 len -= 2;
 728         }
 729         if (len == 1)
 730                 *to = *bptr & 0xff;
 731 }
 732
 733 static void
 734 lance_zerobuf_gap2(struct lance_softc *sc, int boff, int len)
 735 {
 736         volatile caddr_t buf = sc->sc_mem;
 737         volatile uint16_t *bptr;
 738
 739         if ((unsigned)boff & 0x1) {
 740                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 741                 *bptr &= 0xff;
 742                 bptr += 2;
 743                 len--;
 744         } else
 745                 bptr = ((volatile uint16_t *)buf) + boff;
 746         while (len > 0) {
 747                 *bptr = 0;
 748                 bptr += 2;
 749                 len -= 2;
 750         }
 751 }
 752
 753 /*
 754  * gap16: 16 bytes of data followed by 16 bytes of pad.
 755  *
 756  * Buffers must be 32-byte aligned.
 757  */
 758
 759 static void
 760 lance_copytobuf_gap16(struct lance_softc *sc, void *fromv, int boff, int len)
 761 {
 762         volatile caddr_t buf = sc->sc_mem;
 763         caddr_t bptr, from = fromv;
 764         int xfer;
 765
 766         bptr = buf + ((boff << 1) & ~0x1f);
 767         boff &= 0xf;
 768         xfer = min(len, 16 - boff);
 769         while (len > 0) {
 770                 memcpy(bptr + boff, from, xfer);
 771                 from += xfer;
 772                 bptr += 32;
 773                 boff = 0;
 774                 len -= xfer;
 775                 xfer = min(len, 16);
 776         }
 777 }
 778
 779 static void
 780 lance_copyfrombuf_gap16(struct lance_softc *sc, void *tov, int boff, int len)
 781 {
 782         volatile caddr_t buf = sc->sc_mem;
 783         caddr_t bptr, to = tov;
 784         int xfer;
 785
 786         bptr = buf + ((boff << 1) & ~0x1f);
 787         boff &= 0xf;
 788         xfer = min(len, 16 - boff);
 789         while (len > 0) {
 790                 memcpy(to, bptr + boff, xfer);
 791                 to += xfer;
 792                 bptr += 32;
 793                 boff = 0;
 794                 len -= xfer;
 795                 xfer = min(len, 16);
 796         }
 797 }
 798
 799 static void
 800 lance_zerobuf_gap16(struct lance_softc *sc, int boff, int len)
 801 {
 802         volatile caddr_t buf = sc->sc_mem;
 803         caddr_t bptr;
 804         int xfer;
 805
 806         bptr = buf + ((boff << 1) & ~0x1f);
 807         boff &= 0xf;
 808         xfer = min(len, 16 - boff);
 809         while (len > 0) {
 810                 memset(bptr + boff, 0, xfer);
 811                 bptr += 32;
 812                 boff = 0;
 813                 len -= xfer;
 814                 xfer = min(len, 16);
 815         }
 816 }
 817 #endif /* Example only */