/* $NetBSD: hme.c,v 1.109 2022/05/29 10:43:46 rin Exp $ */ /*- * Copyright (c) 1999 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Paul Kranenburg. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * HME Ethernet module driver. */ #include __KERNEL_RCSID(0, "$NetBSD: hme.c,v 1.109 2022/05/29 10:43:46 rin Exp $"); /* #define HMEDEBUG */ #include "opt_inet.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef INET #include #include #include #include #include #include #include #include #endif #include #include #include #include #include static void hme_start(struct ifnet *); static void hme_stop(struct ifnet *, int); static int hme_ioctl(struct ifnet *, u_long, void *); static void hme_tick(void *); static void hme_watchdog(struct ifnet *); static bool hme_shutdown(device_t, int); static int hme_init(struct ifnet *); static void hme_meminit(struct hme_softc *); static void hme_mifinit(struct hme_softc *); static void hme_reset(struct hme_softc *); static void hme_chipreset(struct hme_softc *); static void hme_setladrf(struct hme_softc *); /* MII methods & callbacks */ static int hme_mii_readreg(device_t, int, int, uint16_t *); static int hme_mii_writereg(device_t, int, int, uint16_t); static void hme_mii_statchg(struct ifnet *); static int hme_mediachange(struct ifnet *); static struct mbuf *hme_get(struct hme_softc *, int, uint32_t); static int hme_put(struct hme_softc *, int, struct mbuf *); static void hme_read(struct hme_softc *, int, uint32_t); static int hme_eint(struct hme_softc *, u_int); static int hme_rint(struct hme_softc *); static int hme_tint(struct hme_softc *); #if 0 /* Default buffer copy routines */ static void hme_copytobuf_contig(struct hme_softc *, void *, int, int); static void hme_copyfrombuf_contig(struct hme_softc *, void *, int, int); #endif void hme_config(struct hme_softc *sc) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; struct mii_data *mii = &sc->sc_mii; struct mii_softc *child; bus_dma_tag_t dmatag = sc->sc_dmatag; bus_dma_segment_t seg; bus_size_t size; int rseg, error; /* * HME common initialization. * * hme_softc fields that must be initialized by the front-end: * * the bus tag: * sc_bustag * * the DMA bus tag: * sc_dmatag * * the bus handles: * sc_seb (Shared Ethernet Block registers) * sc_erx (Receiver Unit registers) * sc_etx (Transmitter Unit registers) * sc_mac (MAC registers) * sc_mif (Management Interface registers) * * the maximum bus burst size: * sc_burst * * (notyet:DMA capable memory for the ring descriptors & packet buffers: * rb_membase, rb_dmabase) * * the local Ethernet address: * sc_enaddr * */ /* Make sure the chip is stopped. */ hme_chipreset(sc); /* * Allocate descriptors and buffers * XXX - do all this differently.. and more configurably, * eg. use things as `dma_load_mbuf()' on transmit, * and a pool of `EXTMEM' mbufs (with buffers DMA-mapped * all the time) on the receiver side. * * Note: receive buffers must be 64-byte aligned. * Also, apparently, the buffers must extend to a DMA burst * boundary beyond the maximum packet size. */ #define _HME_NDESC 128 #define _HME_BUFSZ 1600 /* Note: the # of descriptors must be a multiple of 16 */ sc->sc_rb.rb_ntbuf = _HME_NDESC; sc->sc_rb.rb_nrbuf = _HME_NDESC; /* * Allocate DMA capable memory * Buffer descriptors must be aligned on a 2048 byte boundary; * take this into account when calculating the size. Note that * the maximum number of descriptors (256) occupies 2048 bytes, * so we allocate that much regardless of _HME_NDESC. */ size = 2048 + /* TX descriptors */ 2048 + /* RX descriptors */ sc->sc_rb.rb_ntbuf * _HME_BUFSZ + /* TX buffers */ sc->sc_rb.rb_nrbuf * _HME_BUFSZ; /* RX buffers */ /* Allocate DMA buffer */ if ((error = bus_dmamem_alloc(dmatag, size, 2048, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) { aprint_error_dev(sc->sc_dev, "DMA buffer alloc error %d\n", error); return; } /* Map DMA memory in CPU addressable space */ if ((error = bus_dmamem_map(dmatag, &seg, rseg, size, &sc->sc_rb.rb_membase, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) { aprint_error_dev(sc->sc_dev, "DMA buffer map error %d\n", error); goto bad_free; } if ((error = bus_dmamap_create(dmatag, size, 1, size, 0, BUS_DMA_NOWAIT, &sc->sc_dmamap)) != 0) { aprint_error_dev(sc->sc_dev, "DMA map create error %d\n", error); goto bad_unmap; } /* Load the buffer */ if ((error = bus_dmamap_load(dmatag, sc->sc_dmamap, sc->sc_rb.rb_membase, size, NULL, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) { aprint_error_dev(sc->sc_dev, "DMA buffer map load error %d\n", error); goto bad_destroy; } sc->sc_rb.rb_dmabase = sc->sc_dmamap->dm_segs[0].ds_addr; aprint_normal_dev(sc->sc_dev, "Ethernet address %s\n", ether_sprintf(sc->sc_enaddr)); /* Initialize ifnet structure. */ strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ); ifp->if_softc = sc; ifp->if_start = hme_start; ifp->if_stop = hme_stop; ifp->if_ioctl = hme_ioctl; ifp->if_init = hme_init; ifp->if_watchdog = hme_watchdog; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; sc->sc_if_flags = ifp->if_flags; ifp->if_capabilities |= IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv4_Rx; IFQ_SET_READY(&ifp->if_snd); /* Initialize ifmedia structures and MII info */ mii->mii_ifp = ifp; mii->mii_readreg = hme_mii_readreg; mii->mii_writereg = hme_mii_writereg; mii->mii_statchg = hme_mii_statchg; sc->sc_ethercom.ec_mii = mii; ifmedia_init(&mii->mii_media, 0, hme_mediachange, ether_mediastatus); hme_mifinit(sc); mii_attach(sc->sc_dev, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, MIIF_FORCEANEG); child = LIST_FIRST(&mii->mii_phys); if (child == NULL) { /* No PHY attached */ ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_MANUAL, 0, NULL); ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_MANUAL); } else { /* * Walk along the list of attached MII devices and * establish an `MII instance' to `phy number' * mapping. We'll use this mapping in media change * requests to determine which phy to use to program * the MIF configuration register. */ for (; child != NULL; child = LIST_NEXT(child, mii_list)) { /* * Note: we support just two PHYs: the built-in * internal device and an external on the MII * connector. */ if (child->mii_phy > 1 || child->mii_inst > 1) { aprint_error_dev(sc->sc_dev, "cannot accommodate MII device %s" " at phy %d, instance %d\n", device_xname(child->mii_dev), child->mii_phy, child->mii_inst); continue; } sc->sc_phys[child->mii_inst] = child->mii_phy; } /* * Set the default media to auto negotiation if the phy has * the auto negotiation capability. * XXX; What to do otherwise? */ if (ifmedia_match(&mii->mii_media, IFM_ETHER | IFM_AUTO, 0)) ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO); /* else ifmedia_set(&sc->sc_mii.mii_media, sc->sc_defaultmedia); */ } /* claim 802.1q capability */ sc->sc_ethercom.ec_capabilities |= ETHERCAP_VLAN_MTU; /* Attach the interface. */ if_attach(ifp); if_deferred_start_init(ifp, NULL); ether_ifattach(ifp, sc->sc_enaddr); if (pmf_device_register1(sc->sc_dev, NULL, NULL, hme_shutdown)) pmf_class_network_register(sc->sc_dev, ifp); else aprint_error_dev(sc->sc_dev, "couldn't establish power handler\n"); rnd_attach_source(&sc->rnd_source, device_xname(sc->sc_dev), RND_TYPE_NET, RND_FLAG_DEFAULT); callout_init(&sc->sc_tick_ch, 0); callout_setfunc(&sc->sc_tick_ch, hme_tick, sc); return; bad_destroy: bus_dmamap_destroy(dmatag, sc->sc_dmamap); bad_unmap: bus_dmamem_unmap(dmatag, sc->sc_rb.rb_membase, size); bad_free: bus_dmamem_free(dmatag, &seg, rseg); } void hme_tick(void *arg) { struct hme_softc *sc = arg; int s; s = splnet(); mii_tick(&sc->sc_mii); splx(s); callout_schedule(&sc->sc_tick_ch, hz); } void hme_reset(struct hme_softc *sc) { int s; s = splnet(); (void)hme_init(&sc->sc_ethercom.ec_if); splx(s); } void hme_chipreset(struct hme_softc *sc) { bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t seb = sc->sc_seb; int n; /* Mask all interrupts */ bus_space_write_4(t, seb, HME_SEBI_IMASK, 0xffffffff); /* Reset transmitter and receiver */ bus_space_write_4(t, seb, HME_SEBI_RESET, (HME_SEB_RESET_ETX | HME_SEB_RESET_ERX)); for (n = 0; n < 20; n++) { uint32_t v = bus_space_read_4(t, seb, HME_SEBI_RESET); if ((v & (HME_SEB_RESET_ETX | HME_SEB_RESET_ERX)) == 0) return; DELAY(20); } printf("%s: %s: reset failed\n", device_xname(sc->sc_dev), __func__); } void hme_stop(struct ifnet *ifp, int disable) { struct hme_softc *sc; sc = ifp->if_softc; ifp->if_timer = 0; ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); callout_stop(&sc->sc_tick_ch); mii_down(&sc->sc_mii); hme_chipreset(sc); } void hme_meminit(struct hme_softc *sc) { bus_addr_t txbufdma, rxbufdma; bus_addr_t dma; char *p; unsigned int ntbuf, nrbuf, i; struct hme_ring *hr = &sc->sc_rb; p = hr->rb_membase; dma = hr->rb_dmabase; ntbuf = hr->rb_ntbuf; nrbuf = hr->rb_nrbuf; /* * Allocate transmit descriptors */ hr->rb_txd = p; hr->rb_txddma = dma; p += ntbuf * HME_XD_SIZE; dma += ntbuf * HME_XD_SIZE; /* We have reserved descriptor space until the next 2048 byte boundary.*/ dma = (bus_addr_t)roundup((u_long)dma, 2048); p = (void *)roundup((u_long)p, 2048); /* * Allocate receive descriptors */ hr->rb_rxd = p; hr->rb_rxddma = dma; p += nrbuf * HME_XD_SIZE; dma += nrbuf * HME_XD_SIZE; /* Again move forward to the next 2048 byte boundary.*/ dma = (bus_addr_t)roundup((u_long)dma, 2048); p = (void *)roundup((u_long)p, 2048); /* * Allocate transmit buffers */ hr->rb_txbuf = p; txbufdma = dma; p += ntbuf * _HME_BUFSZ; dma += ntbuf * _HME_BUFSZ; /* * Allocate receive buffers */ hr->rb_rxbuf = p; rxbufdma = dma; p += nrbuf * _HME_BUFSZ; dma += nrbuf * _HME_BUFSZ; /* * Initialize transmit buffer descriptors */ for (i = 0; i < ntbuf; i++) { HME_XD_SETADDR(sc->sc_pci, hr->rb_txd, i, txbufdma + i * _HME_BUFSZ); HME_XD_SETFLAGS(sc->sc_pci, hr->rb_txd, i, 0); } /* * Initialize receive buffer descriptors */ for (i = 0; i < nrbuf; i++) { HME_XD_SETADDR(sc->sc_pci, hr->rb_rxd, i, rxbufdma + i * _HME_BUFSZ); HME_XD_SETFLAGS(sc->sc_pci, hr->rb_rxd, i, HME_XD_OWN | HME_XD_ENCODE_RSIZE(_HME_BUFSZ)); } hr->rb_tdhead = hr->rb_tdtail = 0; hr->rb_td_nbusy = 0; hr->rb_rdtail = 0; } /* * Initialization of interface; set up initialization block * and transmit/receive descriptor rings. */ int hme_init(struct ifnet *ifp) { struct hme_softc *sc = ifp->if_softc; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t seb = sc->sc_seb; bus_space_handle_t etx = sc->sc_etx; bus_space_handle_t erx = sc->sc_erx; bus_space_handle_t mac = sc->sc_mac; uint8_t *ea; uint32_t v; int rc; /* * Initialization sequence. The numbered steps below correspond * to the sequence outlined in section 6.3.5.1 in the Ethernet * Channel Engine manual (part of the PCIO manual). * See also the STP2002-STQ document from Sun Microsystems. */ /* step 1 & 2. Reset the Ethernet Channel */ hme_stop(ifp, 0); /* Re-initialize the MIF */ hme_mifinit(sc); /* Call MI reset function if any */ if (sc->sc_hwreset) (*sc->sc_hwreset)(sc); #if 0 /* Mask all MIF interrupts, just in case */ bus_space_write_4(t, mif, HME_MIFI_IMASK, 0xffff); #endif /* step 3. Setup data structures in host memory */ hme_meminit(sc); /* step 4. TX MAC registers & counters */ bus_space_write_4(t, mac, HME_MACI_NCCNT, 0); bus_space_write_4(t, mac, HME_MACI_FCCNT, 0); bus_space_write_4(t, mac, HME_MACI_EXCNT, 0); bus_space_write_4(t, mac, HME_MACI_LTCNT, 0); bus_space_write_4(t, mac, HME_MACI_TXSIZE, (sc->sc_ethercom.ec_capenable & ETHERCAP_VLAN_MTU) ? ETHER_VLAN_ENCAP_LEN + ETHER_MAX_LEN : ETHER_MAX_LEN); sc->sc_ec_capenable = sc->sc_ethercom.ec_capenable; /* Load station MAC address */ ea = sc->sc_enaddr; bus_space_write_4(t, mac, HME_MACI_MACADDR0, (ea[0] << 8) | ea[1]); bus_space_write_4(t, mac, HME_MACI_MACADDR1, (ea[2] << 8) | ea[3]); bus_space_write_4(t, mac, HME_MACI_MACADDR2, (ea[4] << 8) | ea[5]); /* * Init seed for backoff * (source suggested by manual: low 10 bits of MAC address) */ v = ((ea[4] << 8) | ea[5]) & 0x3fff; bus_space_write_4(t, mac, HME_MACI_RANDSEED, v); /* Note: Accepting power-on default for other MAC registers here.. */ /* step 5. RX MAC registers & counters */ hme_setladrf(sc); /* step 6 & 7. Program Descriptor Ring Base Addresses */ bus_space_write_4(t, etx, HME_ETXI_RING, sc->sc_rb.rb_txddma); bus_space_write_4(t, etx, HME_ETXI_RSIZE, sc->sc_rb.rb_ntbuf); bus_space_write_4(t, erx, HME_ERXI_RING, sc->sc_rb.rb_rxddma); bus_space_write_4(t, mac, HME_MACI_RXSIZE, (sc->sc_ethercom.ec_capenable & ETHERCAP_VLAN_MTU) ? ETHER_VLAN_ENCAP_LEN + ETHER_MAX_LEN : ETHER_MAX_LEN); /* step 8. Global Configuration & Interrupt Mask */ bus_space_write_4(t, seb, HME_SEBI_IMASK, ~( /*HME_SEB_STAT_GOTFRAME | HME_SEB_STAT_SENTFRAME |*/ HME_SEB_STAT_HOSTTOTX | HME_SEB_STAT_RXTOHOST | HME_SEB_STAT_TXALL | HME_SEB_STAT_TXPERR | HME_SEB_STAT_RCNTEXP | HME_SEB_STAT_MIFIRQ | HME_SEB_STAT_ALL_ERRORS )); switch (sc->sc_burst) { default: v = 0; break; case 16: v = HME_SEB_CFG_BURST16; break; case 32: v = HME_SEB_CFG_BURST32; break; case 64: v = HME_SEB_CFG_BURST64; break; } bus_space_write_4(t, seb, HME_SEBI_CFG, v); /* step 9. ETX Configuration: use mostly default values */ /* Enable DMA */ v = bus_space_read_4(t, etx, HME_ETXI_CFG); v |= HME_ETX_CFG_DMAENABLE; bus_space_write_4(t, etx, HME_ETXI_CFG, v); /* Transmit Descriptor ring size: in increments of 16 */ bus_space_write_4(t, etx, HME_ETXI_RSIZE, _HME_NDESC / 16 - 1); /* step 10. ERX Configuration */ v = bus_space_read_4(t, erx, HME_ERXI_CFG); /* Encode Receive Descriptor ring size: four possible values */ switch (_HME_NDESC /*XXX*/) { case 32: v |= HME_ERX_CFG_RINGSIZE32; break; case 64: v |= HME_ERX_CFG_RINGSIZE64; break; case 128: v |= HME_ERX_CFG_RINGSIZE128; break; case 256: v |= HME_ERX_CFG_RINGSIZE256; break; default: printf("hme: invalid Receive Descriptor ring size\n"); break; } /* Enable DMA */ v |= HME_ERX_CFG_DMAENABLE; /* set h/w rx checksum start offset (# of half-words) */ #ifdef INET v |= (((ETHER_HDR_LEN + sizeof(struct ip)) / sizeof(uint16_t)) << HME_ERX_CFG_CSUMSHIFT) & HME_ERX_CFG_CSUMSTART; #endif bus_space_write_4(t, erx, HME_ERXI_CFG, v); /* step 11. XIF Configuration */ v = bus_space_read_4(t, mac, HME_MACI_XIF); v |= HME_MAC_XIF_OE; bus_space_write_4(t, mac, HME_MACI_XIF, v); /* step 12. RX_MAC Configuration Register */ v = bus_space_read_4(t, mac, HME_MACI_RXCFG); v |= HME_MAC_RXCFG_ENABLE | HME_MAC_RXCFG_PSTRIP; bus_space_write_4(t, mac, HME_MACI_RXCFG, v); /* step 13. TX_MAC Configuration Register */ v = bus_space_read_4(t, mac, HME_MACI_TXCFG); v |= (HME_MAC_TXCFG_ENABLE | HME_MAC_TXCFG_DGIVEUP); bus_space_write_4(t, mac, HME_MACI_TXCFG, v); /* step 14. Issue Transmit Pending command */ /* Call MI initialization function if any */ if (sc->sc_hwinit) (*sc->sc_hwinit)(sc); /* Set the current media. */ if ((rc = hme_mediachange(ifp)) != 0) return rc; /* Start the one second timer. */ callout_schedule(&sc->sc_tick_ch, hz); ifp->if_flags |= IFF_RUNNING; ifp->if_flags &= ~IFF_OACTIVE; sc->sc_if_flags = ifp->if_flags; ifp->if_timer = 0; hme_start(ifp); return 0; } /* * Routine to copy from mbuf chain to transmit buffer in * network buffer memory. * Returns the amount of data copied. */ int hme_put(struct hme_softc *sc, int ri, struct mbuf *m) /* ri: Ring index */ { struct mbuf *n; int len, tlen = 0; char *bp; bp = (char *)sc->sc_rb.rb_txbuf + (ri % sc->sc_rb.rb_ntbuf) * _HME_BUFSZ; for (; m; m = n) { len = m->m_len; if (len == 0) { n = m_free(m); continue; } memcpy(bp, mtod(m, void *), len); bp += len; tlen += len; n = m_free(m); } return (tlen); } /* * Pull data off an interface. * Len is length of data, with local net header stripped. * We copy the data into mbufs. When full cluster sized units are present * we copy into clusters. */ struct mbuf * hme_get(struct hme_softc *sc, int ri, uint32_t flags) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; struct mbuf *m, *m0, *newm; char *bp; int len, totlen; #ifdef INET int csum_flags; #endif totlen = HME_XD_DECODE_RSIZE(flags); MGETHDR(m0, M_DONTWAIT, MT_DATA); if (m0 == 0) return (0); MCLAIM(m0, &sc->sc_ethercom.ec_rx_mowner); m_set_rcvif(m0, ifp); m0->m_pkthdr.len = totlen; len = MHLEN; m = m0; bp = (char *)sc->sc_rb.rb_rxbuf + (ri % sc->sc_rb.rb_nrbuf) * _HME_BUFSZ; while (totlen > 0) { if (totlen >= MINCLSIZE) { MCLGET(m, M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) goto bad; len = MCLBYTES; } if (m == m0) { char *newdata = (char *) ALIGN(m->m_data + sizeof(struct ether_header)) - sizeof(struct ether_header); len -= newdata - m->m_data; m->m_data = newdata; } m->m_len = len = uimin(totlen, len); memcpy(mtod(m, void *), bp, len); bp += len; totlen -= len; if (totlen > 0) { MGET(newm, M_DONTWAIT, MT_DATA); if (newm == 0) goto bad; len = MLEN; m = m->m_next = newm; } } #ifdef INET /* hardware checksum */ csum_flags = 0; if (ifp->if_csum_flags_rx & (M_CSUM_TCPv4 | M_CSUM_UDPv4)) { struct ether_header *eh; struct ether_vlan_header *evh; struct ip *ip; struct udphdr *uh; uint16_t *opts; int32_t hlen, pktlen; uint32_t csum_data; eh = mtod(m0, struct ether_header *); if (ntohs(eh->ether_type) == ETHERTYPE_IP) { ip = (struct ip *)((char *)eh + ETHER_HDR_LEN); pktlen = m0->m_pkthdr.len - ETHER_HDR_LEN; } else if (ntohs(eh->ether_type) == ETHERTYPE_VLAN) { evh = (struct ether_vlan_header *)eh; if (ntohs(evh->evl_proto) != ETHERTYPE_IP) goto swcsum; ip = (struct ip *)((char *)eh + ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN); pktlen = m0->m_pkthdr.len - ETHER_HDR_LEN - ETHER_VLAN_ENCAP_LEN; } else goto swcsum; /* IPv4 only */ if (ip->ip_v != IPVERSION) goto swcsum; hlen = ip->ip_hl << 2; if (hlen < sizeof(struct ip)) goto swcsum; /* * bail if too short, has random trailing garbage, truncated, * fragment, or has ethernet pad. */ if (ntohs(ip->ip_len) < hlen || ntohs(ip->ip_len) != pktlen || (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK)) != 0) goto swcsum; switch (ip->ip_p) { case IPPROTO_TCP: if ((ifp->if_csum_flags_rx & M_CSUM_TCPv4) == 0) goto swcsum; if (pktlen < (hlen + sizeof(struct tcphdr))) goto swcsum; csum_flags = M_CSUM_TCPv4 | M_CSUM_DATA | M_CSUM_NO_PSEUDOHDR; break; case IPPROTO_UDP: if ((ifp->if_csum_flags_rx & M_CSUM_UDPv4) == 0) goto swcsum; if (pktlen < (hlen + sizeof(struct udphdr))) goto swcsum; uh = (struct udphdr *)((char *)ip + hlen); /* no checksum */ if (uh->uh_sum == 0) goto swcsum; csum_flags = M_CSUM_UDPv4 | M_CSUM_DATA | M_CSUM_NO_PSEUDOHDR; break; default: goto swcsum; } /* w/ M_CSUM_NO_PSEUDOHDR, the uncomplemented sum is expected */ csum_data = ~flags & HME_XD_RXCKSUM; /* * If data offset is different from RX cksum start offset, * we have to deduct them. */ hlen = ((char *)ip + hlen) - ((char *)eh + ETHER_HDR_LEN + sizeof(struct ip)); if (hlen > 1) { uint32_t optsum; optsum = 0; opts = (uint16_t *)((char *)eh + ETHER_HDR_LEN + sizeof(struct ip)); while (hlen > 1) { optsum += ntohs(*opts++); hlen -= 2; } while (optsum >> 16) optsum = (optsum >> 16) + (optsum & 0xffff); /* Deduct the ip opts sum from the hwsum. */ csum_data += (uint16_t)~optsum; while (csum_data >> 16) csum_data = (csum_data >> 16) + (csum_data & 0xffff); } m0->m_pkthdr.csum_data = csum_data; } swcsum: m0->m_pkthdr.csum_flags = csum_flags; #endif return (m0); bad: m_freem(m0); return (0); } /* * Pass a packet to the higher levels. */ void hme_read(struct hme_softc *sc, int ix, uint32_t flags) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; struct mbuf *m; int len; len = HME_XD_DECODE_RSIZE(flags); if (len <= sizeof(struct ether_header) || len > ((sc->sc_ethercom.ec_capenable & ETHERCAP_VLAN_MTU) ? ETHER_VLAN_ENCAP_LEN + ETHERMTU + sizeof(struct ether_header) : ETHERMTU + sizeof(struct ether_header))) { #ifdef HMEDEBUG printf("%s: invalid packet size %d; dropping\n", device_xname(sc->sc_dev), len); #endif if_statinc(ifp, if_ierrors); return; } /* Pull packet off interface. */ m = hme_get(sc, ix, flags); if (m == 0) { if_statinc(ifp, if_ierrors); return; } /* Pass the packet up. */ if_percpuq_enqueue(ifp->if_percpuq, m); } void hme_start(struct ifnet *ifp) { struct hme_softc *sc = ifp->if_softc; void *txd = sc->sc_rb.rb_txd; struct mbuf *m; unsigned int txflags; unsigned int ri, len, obusy; unsigned int ntbuf = sc->sc_rb.rb_ntbuf; if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING) return; ri = sc->sc_rb.rb_tdhead; obusy = sc->sc_rb.rb_td_nbusy; for (;;) { IFQ_DEQUEUE(&ifp->if_snd, m); if (m == 0) break; /* * If BPF is listening on this interface, let it see the * packet before we commit it to the wire. */ bpf_mtap(ifp, m, BPF_D_OUT); #ifdef INET /* collect bits for h/w csum, before hme_put frees the mbuf */ if (ifp->if_csum_flags_tx & (M_CSUM_TCPv4 | M_CSUM_UDPv4) && m->m_pkthdr.csum_flags & (M_CSUM_TCPv4 | M_CSUM_UDPv4)) { struct ether_header *eh; uint16_t offset, start; eh = mtod(m, struct ether_header *); switch (ntohs(eh->ether_type)) { case ETHERTYPE_IP: start = ETHER_HDR_LEN; break; case ETHERTYPE_VLAN: start = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN; break; default: /* unsupported, drop it */ m_free(m); continue; } start += M_CSUM_DATA_IPv4_IPHL(m->m_pkthdr.csum_data); offset = M_CSUM_DATA_IPv4_OFFSET(m->m_pkthdr.csum_data) + start; txflags = HME_XD_TXCKSUM | (offset << HME_XD_TXCSSTUFFSHIFT) | (start << HME_XD_TXCSSTARTSHIFT); } else #endif txflags = 0; /* * Copy the mbuf chain into the transmit buffer. */ len = hme_put(sc, ri, m); /* * Initialize transmit registers and start transmission */ HME_XD_SETFLAGS(sc->sc_pci, txd, ri, HME_XD_OWN | HME_XD_SOP | HME_XD_EOP | HME_XD_ENCODE_TSIZE(len) | txflags); /*if (sc->sc_rb.rb_td_nbusy <= 0)*/ bus_space_write_4(sc->sc_bustag, sc->sc_etx, HME_ETXI_PENDING, HME_ETX_TP_DMAWAKEUP); if (++ri == ntbuf) ri = 0; if (++sc->sc_rb.rb_td_nbusy == ntbuf) { ifp->if_flags |= IFF_OACTIVE; break; } } if (obusy != sc->sc_rb.rb_td_nbusy) { sc->sc_rb.rb_tdhead = ri; ifp->if_timer = 5; } } /* * Transmit interrupt. */ int hme_tint(struct hme_softc *sc) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mac = sc->sc_mac; unsigned int ri, txflags; net_stat_ref_t nsr = IF_STAT_GETREF(ifp); /* * Unload collision counters */ if_statadd_ref(nsr, if_collisions, bus_space_read_4(t, mac, HME_MACI_NCCNT) + bus_space_read_4(t, mac, HME_MACI_FCCNT)); if_statadd_ref(nsr, if_oerrors, bus_space_read_4(t, mac, HME_MACI_EXCNT) + bus_space_read_4(t, mac, HME_MACI_LTCNT)); /* * then clear the hardware counters. */ bus_space_write_4(t, mac, HME_MACI_NCCNT, 0); bus_space_write_4(t, mac, HME_MACI_FCCNT, 0); bus_space_write_4(t, mac, HME_MACI_EXCNT, 0); bus_space_write_4(t, mac, HME_MACI_LTCNT, 0); /* Fetch current position in the transmit ring */ ri = sc->sc_rb.rb_tdtail; for (;;) { if (sc->sc_rb.rb_td_nbusy <= 0) break; txflags = HME_XD_GETFLAGS(sc->sc_pci, sc->sc_rb.rb_txd, ri); if (txflags & HME_XD_OWN) break; ifp->if_flags &= ~IFF_OACTIVE; if_statinc_ref(nsr, if_opackets); if (++ri == sc->sc_rb.rb_ntbuf) ri = 0; --sc->sc_rb.rb_td_nbusy; } IF_STAT_PUTREF(ifp); /* Update ring */ sc->sc_rb.rb_tdtail = ri; if_schedule_deferred_start(ifp); if (sc->sc_rb.rb_td_nbusy == 0) ifp->if_timer = 0; return (1); } /* * Receive interrupt. */ int hme_rint(struct hme_softc *sc) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mac = sc->sc_mac; void *xdr = sc->sc_rb.rb_rxd; unsigned int nrbuf = sc->sc_rb.rb_nrbuf; unsigned int ri; uint32_t flags; ri = sc->sc_rb.rb_rdtail; /* * Process all buffers with valid data. */ for (;;) { flags = HME_XD_GETFLAGS(sc->sc_pci, xdr, ri); if (flags & HME_XD_OWN) break; if (flags & HME_XD_OFL) { printf("%s: buffer overflow, ri=%d; flags=0x%x\n", device_xname(sc->sc_dev), ri, flags); } else hme_read(sc, ri, flags); /* This buffer can be used by the hardware again */ HME_XD_SETFLAGS(sc->sc_pci, xdr, ri, HME_XD_OWN | HME_XD_ENCODE_RSIZE(_HME_BUFSZ)); if (++ri == nrbuf) ri = 0; } sc->sc_rb.rb_rdtail = ri; /* Read error counters ... */ if_statadd(ifp, if_ierrors, bus_space_read_4(t, mac, HME_MACI_STAT_LCNT) + bus_space_read_4(t, mac, HME_MACI_STAT_ACNT) + bus_space_read_4(t, mac, HME_MACI_STAT_CCNT) + bus_space_read_4(t, mac, HME_MACI_STAT_CVCNT)); /* ... then clear the hardware counters. */ bus_space_write_4(t, mac, HME_MACI_STAT_LCNT, 0); bus_space_write_4(t, mac, HME_MACI_STAT_ACNT, 0); bus_space_write_4(t, mac, HME_MACI_STAT_CCNT, 0); bus_space_write_4(t, mac, HME_MACI_STAT_CVCNT, 0); return (1); } int hme_eint(struct hme_softc *sc, u_int status) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; char bits[128]; if ((status & HME_SEB_STAT_MIFIRQ) != 0) { bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mif = sc->sc_mif; uint32_t cf, st, sm; cf = bus_space_read_4(t, mif, HME_MIFI_CFG); st = bus_space_read_4(t, mif, HME_MIFI_STAT); sm = bus_space_read_4(t, mif, HME_MIFI_SM); printf("%s: XXXlink status changed: cfg=%x, stat %x, sm %x\n", device_xname(sc->sc_dev), cf, st, sm); return (1); } /* Receive error counters rolled over */ net_stat_ref_t nsr = IF_STAT_GETREF(ifp); if (status & HME_SEB_STAT_ACNTEXP) if_statadd_ref(nsr, if_ierrors, 0xff); if (status & HME_SEB_STAT_CCNTEXP) if_statadd_ref(nsr, if_ierrors, 0xff); if (status & HME_SEB_STAT_LCNTEXP) if_statadd_ref(nsr, if_ierrors, 0xff); if (status & HME_SEB_STAT_CVCNTEXP) if_statadd_ref(nsr, if_ierrors, 0xff); IF_STAT_PUTREF(ifp); /* RXTERR locks up the interface, so do a reset */ if (status & HME_SEB_STAT_RXTERR) hme_reset(sc); snprintb(bits, sizeof(bits), HME_SEB_STAT_BITS, status); printf("%s: status=%s\n", device_xname(sc->sc_dev), bits); return (1); } int hme_intr(void *v) { struct hme_softc *sc = v; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t seb = sc->sc_seb; uint32_t status; int r = 0; status = bus_space_read_4(t, seb, HME_SEBI_STAT); if ((status & HME_SEB_STAT_ALL_ERRORS) != 0) r |= hme_eint(sc, status); if ((status & (HME_SEB_STAT_TXALL | HME_SEB_STAT_HOSTTOTX)) != 0) r |= hme_tint(sc); if ((status & HME_SEB_STAT_RXTOHOST) != 0) r |= hme_rint(sc); rnd_add_uint32(&sc->rnd_source, status); return (r); } void hme_watchdog(struct ifnet *ifp) { struct hme_softc *sc = ifp->if_softc; log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev)); if_statinc(ifp, if_oerrors); hme_reset(sc); } /* * Initialize the MII Management Interface */ void hme_mifinit(struct hme_softc *sc) { bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mif = sc->sc_mif; bus_space_handle_t mac = sc->sc_mac; int instance, phy; uint32_t v; if (sc->sc_mii.mii_media.ifm_cur != NULL) { instance = IFM_INST(sc->sc_mii.mii_media.ifm_cur->ifm_media); phy = sc->sc_phys[instance]; } else /* No media set yet, pick phy arbitrarily.. */ phy = HME_PHYAD_EXTERNAL; /* Configure the MIF in frame mode, no poll, current phy select */ v = 0; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MIF_CFG_PHY; bus_space_write_4(t, mif, HME_MIFI_CFG, v); /* If an external transceiver is selected, enable its MII drivers */ v = bus_space_read_4(t, mac, HME_MACI_XIF); v &= ~HME_MAC_XIF_MIIENABLE; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MAC_XIF_MIIENABLE; bus_space_write_4(t, mac, HME_MACI_XIF, v); } /* * MII interface */ static int hme_mii_readreg(device_t self, int phy, int reg, uint16_t *val) { struct hme_softc *sc = device_private(self); bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mif = sc->sc_mif; bus_space_handle_t mac = sc->sc_mac; uint32_t v, xif_cfg, mifi_cfg; int n, rv; /* We can at most have two PHYs */ if (phy != HME_PHYAD_EXTERNAL && phy != HME_PHYAD_INTERNAL) return -1; /* Select the desired PHY in the MIF configuration register */ v = mifi_cfg = bus_space_read_4(t, mif, HME_MIFI_CFG); v &= ~HME_MIF_CFG_PHY; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MIF_CFG_PHY; bus_space_write_4(t, mif, HME_MIFI_CFG, v); /* Enable MII drivers on external transceiver */ v = xif_cfg = bus_space_read_4(t, mac, HME_MACI_XIF); if (phy == HME_PHYAD_EXTERNAL) v |= HME_MAC_XIF_MIIENABLE; else v &= ~HME_MAC_XIF_MIIENABLE; bus_space_write_4(t, mac, HME_MACI_XIF, v); #if 0 /* This doesn't work reliably; the MDIO_1 bit is off most of the time */ /* * Check whether a transceiver is connected by testing * the MIF configuration register's MDI_X bits. Note that * MDI_0 (int) == 0x100 and MDI_1 (ext) == 0x200; see hmereg.h */ mif_mdi_bit = 1 << (8 + (1 - phy)); delay(100); v = bus_space_read_4(t, mif, HME_MIFI_CFG); if ((v & mif_mdi_bit) == 0) { rv = -1; goto out; } #endif /* Construct the frame command */ v = (MII_COMMAND_START << HME_MIF_FO_ST_SHIFT) | HME_MIF_FO_TAMSB | (MII_COMMAND_READ << HME_MIF_FO_OPC_SHIFT) | (phy << HME_MIF_FO_PHYAD_SHIFT) | (reg << HME_MIF_FO_REGAD_SHIFT); bus_space_write_4(t, mif, HME_MIFI_FO, v); for (n = 0; n < 100; n++) { DELAY(1); v = bus_space_read_4(t, mif, HME_MIFI_FO); if (v & HME_MIF_FO_TALSB) { *val = v & HME_MIF_FO_DATA; rv = 0; goto out; } } rv = ETIMEDOUT; printf("%s: mii_read timeout\n", device_xname(sc->sc_dev)); out: /* Restore MIFI_CFG register */ bus_space_write_4(t, mif, HME_MIFI_CFG, mifi_cfg); /* Restore XIF register */ bus_space_write_4(t, mac, HME_MACI_XIF, xif_cfg); return rv; } static int hme_mii_writereg(device_t self, int phy, int reg, uint16_t val) { struct hme_softc *sc = device_private(self); bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mif = sc->sc_mif; bus_space_handle_t mac = sc->sc_mac; uint32_t v, xif_cfg, mifi_cfg; int n, rv; /* We can at most have two PHYs */ if (phy != HME_PHYAD_EXTERNAL && phy != HME_PHYAD_INTERNAL) return -1; /* Select the desired PHY in the MIF configuration register */ v = mifi_cfg = bus_space_read_4(t, mif, HME_MIFI_CFG); v &= ~HME_MIF_CFG_PHY; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MIF_CFG_PHY; bus_space_write_4(t, mif, HME_MIFI_CFG, v); /* Enable MII drivers on external transceiver */ v = xif_cfg = bus_space_read_4(t, mac, HME_MACI_XIF); if (phy == HME_PHYAD_EXTERNAL) v |= HME_MAC_XIF_MIIENABLE; else v &= ~HME_MAC_XIF_MIIENABLE; bus_space_write_4(t, mac, HME_MACI_XIF, v); #if 0 /* This doesn't work reliably; the MDIO_1 bit is off most of the time */ /* * Check whether a transceiver is connected by testing * the MIF configuration register's MDI_X bits. Note that * MDI_0 (int) == 0x100 and MDI_1 (ext) == 0x200; see hmereg.h */ mif_mdi_bit = 1 << (8 + (1 - phy)); delay(100); v = bus_space_read_4(t, mif, HME_MIFI_CFG); if ((v & mif_mdi_bit) == 0) { rv = -1; goto out; } #endif /* Construct the frame command */ v = (MII_COMMAND_START << HME_MIF_FO_ST_SHIFT) | HME_MIF_FO_TAMSB | (MII_COMMAND_WRITE << HME_MIF_FO_OPC_SHIFT) | (phy << HME_MIF_FO_PHYAD_SHIFT) | (reg << HME_MIF_FO_REGAD_SHIFT) | (val & HME_MIF_FO_DATA); bus_space_write_4(t, mif, HME_MIFI_FO, v); for (n = 0; n < 100; n++) { DELAY(1); v = bus_space_read_4(t, mif, HME_MIFI_FO); if (v & HME_MIF_FO_TALSB) { rv = 0; goto out; } } rv = ETIMEDOUT; printf("%s: mii_write timeout\n", device_xname(sc->sc_dev)); out: /* Restore MIFI_CFG register */ bus_space_write_4(t, mif, HME_MIFI_CFG, mifi_cfg); /* Restore XIF register */ bus_space_write_4(t, mac, HME_MACI_XIF, xif_cfg); return rv; } static void hme_mii_statchg(struct ifnet *ifp) { struct hme_softc *sc = ifp->if_softc; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mac = sc->sc_mac; uint32_t v; #ifdef HMEDEBUG if (sc->sc_debug) printf("hme_mii_statchg: status change\n"); #endif /* Set the MAC Full Duplex bit appropriately */ /* Apparently the hme chip is SIMPLEX if working in full duplex mode, but not otherwise. */ v = bus_space_read_4(t, mac, HME_MACI_TXCFG); if ((IFM_OPTIONS(sc->sc_mii.mii_media_active) & IFM_FDX) != 0) { v |= HME_MAC_TXCFG_FULLDPLX; sc->sc_ethercom.ec_if.if_flags |= IFF_SIMPLEX; } else { v &= ~HME_MAC_TXCFG_FULLDPLX; sc->sc_ethercom.ec_if.if_flags &= ~IFF_SIMPLEX; } sc->sc_if_flags = sc->sc_ethercom.ec_if.if_flags; bus_space_write_4(t, mac, HME_MACI_TXCFG, v); } int hme_mediachange(struct ifnet *ifp) { struct hme_softc *sc = ifp->if_softc; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mif = sc->sc_mif; bus_space_handle_t mac = sc->sc_mac; int instance = IFM_INST(sc->sc_mii.mii_media.ifm_cur->ifm_media); int phy = sc->sc_phys[instance]; int rc; uint32_t v; #ifdef HMEDEBUG if (sc->sc_debug) printf("hme_mediachange: phy = %d\n", phy); #endif /* Select the current PHY in the MIF configuration register */ v = bus_space_read_4(t, mif, HME_MIFI_CFG); v &= ~HME_MIF_CFG_PHY; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MIF_CFG_PHY; bus_space_write_4(t, mif, HME_MIFI_CFG, v); /* If an external transceiver is selected, enable its MII drivers */ v = bus_space_read_4(t, mac, HME_MACI_XIF); v &= ~HME_MAC_XIF_MIIENABLE; if (phy == HME_PHYAD_EXTERNAL) v |= HME_MAC_XIF_MIIENABLE; bus_space_write_4(t, mac, HME_MACI_XIF, v); if ((rc = mii_mediachg(&sc->sc_mii)) == ENXIO) return 0; return rc; } /* * Process an ioctl request. */ int hme_ioctl(struct ifnet *ifp, unsigned long cmd, void *data) { struct hme_softc *sc = ifp->if_softc; struct ifaddr *ifa = (struct ifaddr *)data; int s, error = 0; s = splnet(); switch (cmd) { case SIOCINITIFADDR: switch (ifa->ifa_addr->sa_family) { #ifdef INET case AF_INET: if (ifp->if_flags & IFF_UP) hme_setladrf(sc); else { ifp->if_flags |= IFF_UP; error = hme_init(ifp); } arp_ifinit(ifp, ifa); break; #endif default: ifp->if_flags |= IFF_UP; error = hme_init(ifp); break; } break; case SIOCSIFFLAGS: #ifdef HMEDEBUG { struct ifreq *ifr = data; sc->sc_debug = (ifr->ifr_flags & IFF_DEBUG) != 0 ? 1 : 0; } #endif if ((error = ifioctl_common(ifp, cmd, data)) != 0) break; switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) { case IFF_RUNNING: /* * If interface is marked down and it is running, then * stop it. */ hme_stop(ifp, 0); ifp->if_flags &= ~IFF_RUNNING; break; case IFF_UP: /* * If interface is marked up and it is stopped, then * start it. */ error = hme_init(ifp); break; case IFF_UP | IFF_RUNNING: /* * If setting debug or promiscuous mode, do not reset * the chip; for everything else, call hme_init() * which will trigger a reset. */ #define RESETIGN (IFF_CANTCHANGE | IFF_DEBUG) if (ifp->if_flags != sc->sc_if_flags) { if ((ifp->if_flags & (~RESETIGN)) == (sc->sc_if_flags & (~RESETIGN))) hme_setladrf(sc); else error = hme_init(ifp); } #undef RESETIGN break; case 0: break; } if (sc->sc_ec_capenable != sc->sc_ethercom.ec_capenable) error = hme_init(ifp); break; default: if ((error = ether_ioctl(ifp, cmd, data)) != ENETRESET) break; error = 0; if (cmd != SIOCADDMULTI && cmd != SIOCDELMULTI) ; else if (ifp->if_flags & IFF_RUNNING) { /* * Multicast list has changed; set the hardware filter * accordingly. */ hme_setladrf(sc); } break; } sc->sc_if_flags = ifp->if_flags; splx(s); return (error); } bool hme_shutdown(device_t self, int howto) { struct hme_softc *sc; struct ifnet *ifp; sc = device_private(self); ifp = &sc->sc_ethercom.ec_if; hme_stop(ifp, 1); return true; } /* * Set up the logical address filter. */ void hme_setladrf(struct hme_softc *sc) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; struct ether_multi *enm; struct ether_multistep step; struct ethercom *ec = &sc->sc_ethercom; bus_space_tag_t t = sc->sc_bustag; bus_space_handle_t mac = sc->sc_mac; uint32_t v; uint32_t crc; uint32_t hash[4]; /* Clear hash table */ hash[3] = hash[2] = hash[1] = hash[0] = 0; /* Get current RX configuration */ v = bus_space_read_4(t, mac, HME_MACI_RXCFG); if ((ifp->if_flags & IFF_PROMISC) != 0) { /* Turn on promiscuous mode; turn off the hash filter */ v |= HME_MAC_RXCFG_PMISC; v &= ~HME_MAC_RXCFG_HENABLE; ifp->if_flags |= IFF_ALLMULTI; goto chipit; } /* Turn off promiscuous mode; turn on the hash filter */ v &= ~HME_MAC_RXCFG_PMISC; v |= HME_MAC_RXCFG_HENABLE; /* * Set up multicast address filter by passing all multicast addresses * through a crc generator, and then using the high order 6 bits as an * index into the 64 bit logical address filter. The high order bit * selects the word, while the rest of the bits select the bit within * the word. */ ETHER_LOCK(ec); ETHER_FIRST_MULTI(step, ec, enm); while (enm != NULL) { if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) { /* * We must listen to a range of multicast addresses. * For now, just accept all multicasts, rather than * trying to set only those filter bits needed to match * the range. (At this time, the only use of address * ranges is for IP multicast routing, for which the * range is big enough to require all bits set.) */ hash[3] = hash[2] = hash[1] = hash[0] = 0xffff; ifp->if_flags |= IFF_ALLMULTI; ETHER_UNLOCK(ec); goto chipit; } crc = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN); /* Just want the 6 most significant bits. */ crc >>= 26; /* Set the corresponding bit in the filter. */ hash[crc >> 4] |= 1 << (crc & 0xf); ETHER_NEXT_MULTI(step, enm); } ETHER_UNLOCK(ec); ifp->if_flags &= ~IFF_ALLMULTI; chipit: /* Now load the hash table into the chip */ bus_space_write_4(t, mac, HME_MACI_HASHTAB0, hash[0]); bus_space_write_4(t, mac, HME_MACI_HASHTAB1, hash[1]); bus_space_write_4(t, mac, HME_MACI_HASHTAB2, hash[2]); bus_space_write_4(t, mac, HME_MACI_HASHTAB3, hash[3]); bus_space_write_4(t, mac, HME_MACI_RXCFG, v); } /* * Routines for accessing the transmit and receive buffers. * The various CPU and adapter configurations supported by this * driver require three different access methods for buffers * and descriptors: * (1) contig (contiguous data; no padding), * (2) gap2 (two bytes of data followed by two bytes of padding), * (3) gap16 (16 bytes of data followed by 16 bytes of padding). */ #if 0 /* * contig: contiguous data with no padding. * * Buffers may have any alignment. */ void hme_copytobuf_contig(struct hme_softc *sc, void *from, int ri, int len) { volatile void *buf = sc->sc_rb.rb_txbuf + (ri * _HME_BUFSZ); /* * Just call memcpy() to do the work. */ memcpy(buf, from, len); } void hme_copyfrombuf_contig(struct hme_softc *sc, void *to, int boff, int len) { volatile void *buf = sc->sc_rb.rb_rxbuf + (ri * _HME_BUFSZ); /* * Just call memcpy() to do the work. */ memcpy(to, buf, len); } #endif