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                         if (!(MCLGET(m, M_NOWAIT)))
 402                                 goto bad;
 403                         len = MCLBYTES;
 404                 }
 405
 406                 if (m == m0) {
 407                         newdata = (caddr_t)
 408                             ALIGN(m->m_data + ETHER_HDR_LEN) - ETHER_HDR_LEN;
 409                         len -= newdata - m->m_data;
 410                         m->m_data = newdata;
 411                 }
 412
 413                 m->m_len = len = min(totlen, len);
 414                 (*sc->sc_copyfrombuf)(sc, mtod(m, caddr_t), boff, len);
 415                 boff += len;
 416
 417                 totlen -= len;
 418                 if (totlen > 0) {
 419                         MGET(newm, M_NOWAIT, MT_DATA);
 420                         if (newm == 0)
 421                                 goto bad;
 422                         len = MLEN;
 423                         m = m->m_next = newm;
 424                 }
 425         }
 426
 427         return (m0);
 428
 429  bad:
 430         m_freem(m0);
 431         return (NULL);
 432 }
 433
 434 static void
 435 lance_watchdog(void *xsc)
 436 {
 437         struct lance_softc *sc = (struct lance_softc *)xsc;
 438         struct ifnet *ifp = sc->sc_ifp;
 439
 440         LE_LOCK_ASSERT(sc, MA_OWNED);
 441
 442         if (sc->sc_wdog_timer == 0 || --sc->sc_wdog_timer != 0) {
 443                 callout_reset(&sc->sc_wdog_ch, hz, lance_watchdog, sc);
 444                 return;
 445         }
 446
 447         if_printf(ifp, "device timeout\n");
 448         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 449         lance_init_locked(sc);
 450 }
 451
 452 static int
 453 lance_mediachange(struct ifnet *ifp)
 454 {
 455         struct lance_softc *sc = ifp->if_softc;
 456
 457         if (sc->sc_mediachange) {
 458                 /*
 459                  * For setting the port in LE_CSR15 the PCnet chips must
 460                  * be powered down or stopped and unlike documented may
 461                  * not take effect without an initialization. So don't
 462                  * invoke (*sc_mediachange) directly here but go through
 463                  * lance_init_locked().
 464                  */
 465                 LE_LOCK(sc);
 466                 lance_stop(sc);
 467                 lance_init_locked(sc);
 468                 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
 469                         (*sc->sc_start_locked)(sc);
 470                 LE_UNLOCK(sc);
 471         }
 472         return (0);
 473 }
 474
 475 static void
 476 lance_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
 477 {
 478         struct lance_softc *sc = ifp->if_softc;
 479
 480         LE_LOCK(sc);
 481         if (!(ifp->if_flags & IFF_UP)) {
 482                 LE_UNLOCK(sc);
 483                 return;
 484         }
 485
 486         ifmr->ifm_status = IFM_AVALID;
 487         if (sc->sc_flags & LE_CARRIER)
 488                 ifmr->ifm_status |= IFM_ACTIVE;
 489
 490         if (sc->sc_mediastatus)
 491                 (*sc->sc_mediastatus)(sc, ifmr);
 492         LE_UNLOCK(sc);
 493 }
 494
 495 /*
 496  * Process an ioctl request.
 497  */
 498 static int
 499 lance_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 500 {
 501         struct lance_softc *sc = ifp->if_softc;
 502         struct ifreq *ifr = (struct ifreq *)data;
 503         int error = 0;
 504
 505         switch (cmd) {
 506         case SIOCSIFFLAGS:
 507                 LE_LOCK(sc);
 508                 if (ifp->if_flags & IFF_PROMISC) {
 509                         if (!(sc->sc_flags & LE_PROMISC)) {
 510                                 sc->sc_flags |= LE_PROMISC;
 511                                 lance_init_locked(sc);
 512                         }
 513                 } else if (sc->sc_flags & LE_PROMISC) {
 514                         sc->sc_flags &= ~LE_PROMISC;
 515                         lance_init_locked(sc);
 516                 }
 517
 518                 if ((ifp->if_flags & IFF_ALLMULTI) &&
 519                     !(sc->sc_flags & LE_ALLMULTI)) {
 520                         sc->sc_flags |= LE_ALLMULTI;
 521                         lance_init_locked(sc);
 522                 } else if (!(ifp->if_flags & IFF_ALLMULTI) &&
 523                     (sc->sc_flags & LE_ALLMULTI)) {
 524                         sc->sc_flags &= ~LE_ALLMULTI;
 525                         lance_init_locked(sc);
 526                 }
 527
 528                 if (!(ifp->if_flags & IFF_UP) &&
 529                     ifp->if_drv_flags & IFF_DRV_RUNNING) {
 530                         /*
 531                          * If interface is marked down and it is running, then
 532                          * stop it.
 533                          */
 534                         lance_stop(sc);
 535                 } else if (ifp->if_flags & IFF_UP &&
 536                     !(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 537                         /*
 538                          * If interface is marked up and it is stopped, then
 539                          * start it.
 540                          */
 541                         lance_init_locked(sc);
 542                 }
 543 #ifdef LEDEBUG
 544                 if (ifp->if_flags & IFF_DEBUG)
 545                         sc->sc_flags |= LE_DEBUG;
 546                 else
 547                         sc->sc_flags &= ~LE_DEBUG;
 548 #endif
 549                 LE_UNLOCK(sc);
 550                 break;
 551
 552         case SIOCADDMULTI:
 553         case SIOCDELMULTI:
 554                 /*
 555                  * Multicast list has changed; set the hardware filter
 556                  * accordingly.
 557                  */
 558                 LE_LOCK(sc);
 559                 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 560                         lance_init_locked(sc);
 561                 LE_UNLOCK(sc);
 562                 break;
 563
 564         case SIOCGIFMEDIA:
 565         case SIOCSIFMEDIA:
 566                 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
 567                 break;
 568
 569         default:
 570                 error = ether_ioctl(ifp, cmd, data);
 571                 break;
 572         }
 573
 574         return (error);
 575 }
 576
 577 /*
 578  * Set up the logical address filter.
 579  */
 580 void
 581 lance_setladrf(struct lance_softc *sc, uint16_t *af)
 582 {
 583         struct ifnet *ifp = sc->sc_ifp;
 584         struct ifmultiaddr *ifma;
 585         uint32_t crc;
 586
 587         /*
 588          * Set up multicast address filter by passing all multicast addresses
 589          * through a crc generator, and then using the high order 6 bits as an
 590          * index into the 64 bit logical address filter.  The high order bit
 591          * selects the word, while the rest of the bits select the bit within
 592          * the word.
 593          */
 594
 595         if (ifp->if_flags & IFF_PROMISC || sc->sc_flags & LE_ALLMULTI) {
 596                 af[0] = af[1] = af[2] = af[3] = 0xffff;
 597                 return;
 598         }
 599
 600         af[0] = af[1] = af[2] = af[3] = 0x0000;
 601         if_maddr_rlock(ifp);
 602         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 603                 if (ifma->ifma_addr->sa_family != AF_LINK)
 604                         continue;
 605
 606                 crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
 607                     ifma->ifma_addr), ETHER_ADDR_LEN);
 608
 609                 /* Just want the 6 most significant bits. */
 610                 crc >>= 26;
 611
 612                 /* Set the corresponding bit in the filter. */
 613                 af[crc >> 4] |= LE_HTOLE16(1 << (crc & 0xf));
 614         }
 615         if_maddr_runlock(ifp);
 616 }
 617
 618 /*
 619  * Routines for accessing the transmit and receive buffers.
 620  * The various CPU and adapter configurations supported by this
 621  * driver require three different access methods for buffers
 622  * and descriptors:
 623  *      (1) contig (contiguous data; no padding),
 624  *      (2) gap2 (two bytes of data followed by two bytes of padding),
 625  *      (3) gap16 (16 bytes of data followed by 16 bytes of padding).
 626  */
 627
 628 /*
 629  * contig: contiguous data with no padding.
 630  *
 631  * Buffers may have any alignment.
 632  */
 633
 634 void
 635 lance_copytobuf_contig(struct lance_softc *sc, void *from, int boff, int len)
 636 {
 637         volatile caddr_t buf = sc->sc_mem;
 638
 639         /*
 640          * Just call memcpy() to do the work.
 641          */
 642         memcpy(buf + boff, from, len);
 643 }
 644
 645 void
 646 lance_copyfrombuf_contig(struct lance_softc *sc, void *to, int boff, int len)
 647 {
 648         volatile caddr_t buf = sc->sc_mem;
 649
 650         /*
 651          * Just call memcpy() to do the work.
 652          */
 653         memcpy(to, buf + boff, len);
 654 }
 655
 656 void
 657 lance_zerobuf_contig(struct lance_softc *sc, int boff, int len)
 658 {
 659         volatile caddr_t buf = sc->sc_mem;
 660
 661         /*
 662          * Just let memset() do the work
 663          */
 664         memset(buf + boff, 0, len);
 665 }
 666
 667 #if 0
 668 /*
 669  * Examples only; duplicate these and tweak (if necessary) in
 670  * machine-specific front-ends.
 671  */
 672
 673 /*
 674  * gap2: two bytes of data followed by two bytes of pad.
 675  *
 676  * Buffers must be 4-byte aligned.  The code doesn't worry about
 677  * doing an extra byte.
 678  */
 679
 680 static void
 681 lance_copytobuf_gap2(struct lance_softc *sc, void *fromv, int boff, int len)
 682 {
 683         volatile caddr_t buf = sc->sc_mem;
 684         caddr_t from = fromv;
 685         volatile uint16_t *bptr;
 686
 687         if (boff & 0x1) {
 688                 /* Handle unaligned first byte. */
 689                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 690                 *bptr = (*from++ << 8) | (*bptr & 0xff);
 691                 bptr += 2;
 692                 len--;
 693         } else
 694                 bptr = ((volatile uint16_t *)buf) + boff;
 695         while (len > 1) {
 696                 *bptr = (from[1] << 8) | (from[0] & 0xff);
 697                 bptr += 2;
 698                 from += 2;
 699                 len -= 2;
 700         }
 701         if (len == 1)
 702                 *bptr = (uint16_t)*from;
 703 }
 704
 705 static void
 706 lance_copyfrombuf_gap2(struct lance_softc *sc, void *tov, int boff, int len)
 707 {
 708         volatile caddr_t buf = sc->sc_mem;
 709         caddr_t to = tov;
 710         volatile uint16_t *bptr;
 711         uint16_t tmp;
 712
 713         if (boff & 0x1) {
 714                 /* Handle unaligned first byte. */
 715                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 716                 *to++ = (*bptr >> 8) & 0xff;
 717                 bptr += 2;
 718                 len--;
 719         } else
 720                 bptr = ((volatile uint16_t *)buf) + boff;
 721         while (len > 1) {
 722                 tmp = *bptr;
 723                 *to++ = tmp & 0xff;
 724                 *to++ = (tmp >> 8) & 0xff;
 725                 bptr += 2;
 726                 len -= 2;
 727         }
 728         if (len == 1)
 729                 *to = *bptr & 0xff;
 730 }
 731
 732 static void
 733 lance_zerobuf_gap2(struct lance_softc *sc, int boff, int len)
 734 {
 735         volatile caddr_t buf = sc->sc_mem;
 736         volatile uint16_t *bptr;
 737
 738         if ((unsigned)boff & 0x1) {
 739                 bptr = ((volatile uint16_t *)buf) + (boff - 1);
 740                 *bptr &= 0xff;
 741                 bptr += 2;
 742                 len--;
 743         } else
 744                 bptr = ((volatile uint16_t *)buf) + boff;
 745         while (len > 0) {
 746                 *bptr = 0;
 747                 bptr += 2;
 748                 len -= 2;
 749         }
 750 }
 751
 752 /*
 753  * gap16: 16 bytes of data followed by 16 bytes of pad.
 754  *
 755  * Buffers must be 32-byte aligned.
 756  */
 757
 758 static void
 759 lance_copytobuf_gap16(struct lance_softc *sc, void *fromv, int boff, int len)
 760 {
 761         volatile caddr_t buf = sc->sc_mem;
 762         caddr_t bptr, from = fromv;
 763         int xfer;
 764
 765         bptr = buf + ((boff << 1) & ~0x1f);
 766         boff &= 0xf;
 767         xfer = min(len, 16 - boff);
 768         while (len > 0) {
 769                 memcpy(bptr + boff, from, xfer);
 770                 from += xfer;
 771                 bptr += 32;
 772                 boff = 0;
 773                 len -= xfer;
 774                 xfer = min(len, 16);
 775         }
 776 }
 777
 778 static void
 779 lance_copyfrombuf_gap16(struct lance_softc *sc, void *tov, int boff, int len)
 780 {
 781         volatile caddr_t buf = sc->sc_mem;
 782         caddr_t bptr, to = tov;
 783         int xfer;
 784
 785         bptr = buf + ((boff << 1) & ~0x1f);
 786         boff &= 0xf;
 787         xfer = min(len, 16 - boff);
 788         while (len > 0) {
 789                 memcpy(to, bptr + boff, xfer);
 790                 to += xfer;
 791                 bptr += 32;
 792                 boff = 0;
 793                 len -= xfer;
 794                 xfer = min(len, 16);
 795         }
 796 }
 797
 798 static void
 799 lance_zerobuf_gap16(struct lance_softc *sc, int boff, int len)
 800 {
 801         volatile caddr_t buf = sc->sc_mem;
 802         caddr_t bptr;
 803         int xfer;
 804
 805         bptr = buf + ((boff << 1) & ~0x1f);
 806         boff &= 0xf;
 807         xfer = min(len, 16 - boff);
 808         while (len > 0) {
 809                 memset(bptr + boff, 0, xfer);
 810                 bptr += 32;
 811                 boff = 0;
 812                 len -= xfer;
 813                 xfer = min(len, 16);
 814         }
 815 }
 816 #endif /* Example only */