 @@ -1,14 +1,14 @@
-/* $NetBSD: if_mec.c,v 1.33 2008/08/23 18:44:51 tsutsui Exp $ */
+/* $NetBSD: if_mec.c,v 1.34 2009/03/16 09:58:51 tsutsui Exp $ */
 /*-
  * Copyright (c) 2004, 2008 Izumi Tsutsui.  All rights reserved.
+ *
  * 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.
+ *
 @@ -51,52 +51,58 @@
  * 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.
  */
 /*
  * MACE MAC-110 Ethernet driver
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_mec.c,v 1.33 2008/08/23 18:44:51 tsutsui Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_mec.c,v 1.34 2009/03/16 09:58:51 tsutsui Exp $");
 #include "opt_ddb.h"
 #include "bpfilter.h"
 #include "rnd.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/callout.h>
 #include <sys/mbuf.h>
 #include <sys/malloc.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/errno.h>
 #if NRND > 0
 #include <sys/rnd.h>
 #endif
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_media.h>
 #include <net/if_ether.h>
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
 #include <netinet/tcp.h>
 #include <netinet/udp.h>
 #if NBPFILTER > 0
 #include <net/bpf.h>
 #endif
 #include <machine/bus.h>
 #include <machine/intr.h>
 #include <machine/machtype.h>
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 #include <sgimips/mace/macevar.h>
 #include <sgimips/mace/if_mecreg.h>
 @@ -229,26 +235,27 @@ struct mec_rxdesc {
 #define MEC_RXSTAT_VIOLATION	0x0000000000010000	/* code violation (?) */
 #define MEC_RXSTAT_UNUSED2	0x0000000000020000	/* unknown (?) */
 #define MEC_RXSTAT_CRCERROR	0x0000000000040000	/* CRC error */
 #define MEC_RXSTAT_MULTICAST	0x0000000000080000	/* multicast packet */
 #define MEC_RXSTAT_BROADCAST	0x0000000000100000	/* broadcast packet */
 #define MEC_RXSTAT_INVALID	0x0000000000200000	/* invalid preamble */
 #define MEC_RXSTAT_LONGEVENT	0x0000000000400000	/* long packet */
 #define MEC_RXSTAT_BADPACKET	0x0000000000800000	/* bad packet */
 #define MEC_RXSTAT_CAREVENT	0x0000000001000000	/* carrier event */
 #define MEC_RXSTAT_MATCHMCAST	0x0000000002000000	/* match multicast */
 #define MEC_RXSTAT_MATCHMAC	0x0000000004000000	/* match MAC */
 #define MEC_RXSTAT_SEQNUM	0x00000000f8000000	/* sequence number */
 #define MEC_RXSTAT_CKSUM	0x0000ffff00000000ULL	/* IP checksum */
 #define  RXSTAT_CKSUM(x)	(((uint64_t)(x) & MEC_RXSTAT_CKSUM) >> 32)
 #define MEC_RXSTAT_UNUSED1	0x7fff000000000000ULL	/* should be zero */
 #define MEC_RXSTAT_RECEIVED	0x8000000000000000ULL	/* set to 1 on RX */
 	uint64_t rxd_pad1[MEC_RXD_NRXPAD];
 	uint8_t  rxd_buf[MEC_RXD_BUFSIZE];
 };
 /*
  * control structures for DMA ops
  */
 struct mec_control_data {
 	/*
 	 * TX descriptors and buffers
 	 */
 @@ -396,26 +403,28 @@ static void	mec_statchg(device_t);
 static void	enaddr_aton(const char *, uint8_t *);
 static int	mec_init(struct ifnet * ifp);
 static void	mec_start(struct ifnet *);
 static void	mec_watchdog(struct ifnet *);
 static void	mec_tick(void *);
 static int	mec_ioctl(struct ifnet *, u_long, void *);
 static void	mec_reset(struct mec_softc *);
 static void	mec_setfilter(struct mec_softc *);
 static int	mec_intr(void *arg);
 static void	mec_stop(struct ifnet *, int);
 static void	mec_rxintr(struct mec_softc *);
 static void	mec_rxcsum(struct mec_softc *, struct mbuf *, uint16_t,
 		    uint32_t);
 static void	mec_txintr(struct mec_softc *, uint32_t);
 static void	mec_shutdown(void *);
 CFATTACH_DECL_NEW(mec, sizeof(struct mec_softc),
     mec_match, mec_attach, NULL, NULL);
 static int mec_matched = 0;
 static int
 mec_match(device_t parent, cfdata_t cf, void *aux)
+{
 	/* allow only one device */
 @@ -598,26 +607,29 @@ mec_attach(device_t parent, device_t sel
+	}
 	strcpy(ifp->if_xname, device_xname(self));
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_ioctl = mec_ioctl;
 	ifp->if_start = mec_start;
 	ifp->if_watchdog = mec_watchdog;
 	ifp->if_init = mec_init;
 	ifp->if_stop = mec_stop;
 	ifp->if_mtu = ETHERMTU;
 	IFQ_SET_READY(&ifp->if_snd);
 	/* mec has dumb RX cksum support */
 	ifp->if_capabilities = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx;
 	/* We can support 802.1Q VLAN-sized frames. */
 	sc->sc_ethercom.ec_capabilities |= ETHERCAP_VLAN_MTU;
 	/* attach the interface */
 	if_attach(ifp);
 	ether_ifattach(ifp, sc->sc_enaddr);
 	/* establish interrupt */
 	cpu_intr_establish(maa->maa_intr, maa->maa_intrmask, mec_intr, sc);
 #if NRND > 0
 	rnd_attach_source(&sc->sc_rnd_source, device_xname(self),
 	    RND_TYPE_NET, 0);
 @@ -1646,26 +1658,27 @@ mec_intr(void *arg)
+}
 static void
 mec_rxintr(struct mec_softc *sc)
+{
 	bus_space_tag_t st = sc->sc_st;
 	bus_space_handle_t sh = sc->sc_sh;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct mbuf *m;
 	struct mec_rxdesc *rxd;
 	uint64_t rxstat;
 	u_int len;
 	int i;
 	uint32_t crc;
 	DPRINTF(MEC_DEBUG_RXINTR, ("mec_rxintr: called\n"));
 	for (i = sc->sc_rxptr;; i = MEC_NEXTRX(i)) {
 		rxd = &sc->sc_rxdesc[i];
 		MEC_RXSTATSYNC(sc, i, BUS_DMASYNC_POSTREAD);
 		rxstat = rxd->rxd_stat;
 		DPRINTF(MEC_DEBUG_RXINTR,
 		    ("mec_rxintr: rxstat = 0x%016llx, rxptr = %d\n",
 		    rxstat, i));
 		DPRINTF(MEC_DEBUG_RXINTR, ("mec_rxintr: rxfifo = 0x%08x\n",
 @@ -1730,59 +1743,157 @@ mec_rxintr(struct mec_softc *sc)
 			if ((m->m_flags & M_EXT) == 0) {
 				printf("%s: unable to allocate RX cluster\n",
 				    device_xname(sc->sc_dev));
 				m_freem(m);
 				m = NULL;
 				goto dropit;
+			}
+		}
 		/*
 		 * Note MEC chip seems to insert 2 byte padding at the top of
 		 * RX buffer, but we copy whole buffer to avoid unaligned copy.
 		 */
-		MEC_RXBUFSYNC(sc, i, len, BUS_DMASYNC_POSTREAD);
+		MEC_RXBUFSYNC(sc, i, len + ETHER_CRC_LEN, BUS_DMASYNC_POSTREAD);
 		memcpy(mtod(m, void *), rxd->rxd_buf, MEC_ETHER_ALIGN + len);
 		crc = be32dec(rxd->rxd_buf + MEC_ETHER_ALIGN + len);
 		MEC_RXBUFSYNC(sc, i, ETHER_MAX_LEN, BUS_DMASYNC_PREREAD);
 		m->m_data += MEC_ETHER_ALIGN;
 		/* put RX buffer into FIFO again */
 		rxd->rxd_stat = 0;
 		MEC_RXSTATSYNC(sc, i, BUS_DMASYNC_PREREAD);
 		bus_space_write_8(st, sh, MEC_MCL_RX_FIFO, MEC_CDRXADDR(sc, i));
 		m->m_pkthdr.rcvif = ifp;
 		m->m_pkthdr.len = m->m_len = len;
 		if ((ifp->if_csum_flags_rx & (M_CSUM_TCPv4|M_CSUM_UDPv4)) != 0)
 			mec_rxcsum(sc, m, RXSTAT_CKSUM(rxstat), crc);
 		ifp->if_ipackets++;
 #if NBPFILTER > 0
 		/*
 		 * Pass this up to any BPF listeners, but only
 		 * pass it up the stack if it's for us.
 		 */
 		if (ifp->if_bpf)
 			bpf_mtap(ifp->if_bpf, m);
 #endif
 		/* Pass it on. */
 		(*ifp->if_input)(ifp, m);
+	}
 	/* update RX pointer */
 	sc->sc_rxptr = i;
+}
 static void
 mec_rxcsum(struct mec_softc *sc, struct mbuf *m, uint16_t rxcsum, uint32_t crc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_header *eh;
 	struct ip *ip;
 	struct udphdr *uh;
 	u_int len, pktlen, hlen;
 	uint32_t csum_data, dsum;
 	int csum_flags;
 	const uint16_t *dp;
 	csum_data = 0;
 	csum_flags = 0;
 	len = m->m_len;
 	if (len < ETHER_HDR_LEN + sizeof(struct ip))
 		goto out;
 	pktlen = len - ETHER_HDR_LEN;
 	eh = mtod(m, struct ether_header *);
 	if (ntohs(eh->ether_type) != ETHERTYPE_IP)
 		goto out;
 	ip = (struct ip *)((uint8_t *)eh + ETHER_HDR_LEN);
 	if (ip->ip_v != IPVERSION)
 		goto out;
 	hlen = ip->ip_hl << 2;
 	if (hlen < sizeof(struct ip))
 		goto out;
 	/*
 	 * 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 out;
 	switch (ip->ip_p) {
 	case IPPROTO_TCP:
 		if ((ifp->if_csum_flags_rx & M_CSUM_TCPv4) == 0 ||
 		    pktlen < (hlen + sizeof(struct tcphdr)))
 			goto out;
 		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 ||
 		    pktlen < (hlen + sizeof(struct udphdr)))
 			goto out;
 		uh = (struct udphdr *)((uint8_t *)ip + hlen);
 		if (uh->uh_sum == 0)
 			goto out;	/* no checksum */
 		csum_flags = M_CSUM_UDPv4 | M_CSUM_DATA | M_CSUM_NO_PSEUDOHDR;
 		break;
 	default:
 		goto out;
+	}
 	/*
 	 * The computed checksum includes Ethernet header, IP headers,
 	 * and CRC, so we have to deduct them.
 	 * Note IP header cksum should be 0xffff so we don't have to
 	 * dedecut them.
 	 */
 	dsum = 0;
 	/* deduct Ethernet header */
 	dp = (const uint16_t *)eh;
 	for (hlen = 0; hlen < (ETHER_HDR_LEN / sizeof(uint16_t)); hlen++)
 		dsum += ntohs(*dp++);
 	/* deduct CRC */
 	if (len & 1) {
 		dsum += (crc >> 24) & 0x00ff;
 		dsum += (crc >>  8) & 0xffff;
 		dsum += (crc <<  8) & 0xff00;
 	} else {
 		dsum += (crc >> 16) & 0xffff;
 		dsum += (crc >>  0) & 0xffff;
+	}
 	while (dsum >> 16)
 		dsum = (dsum >> 16) + (dsum & 0xffff);
 	csum_data = rxcsum;
 	csum_data += (uint16_t)~dsum;
 	while (csum_data >> 16)
 		csum_data = (csum_data >> 16) + (csum_data & 0xffff);
  out:
 	m->m_pkthdr.csum_flags = csum_flags;
 	m->m_pkthdr.csum_data = csum_data;
+}
 static void
 mec_txintr(struct mec_softc *sc, uint32_t txptr)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct mec_txdesc *txd;
 	struct mec_txsoft *txs;
 	bus_dmamap_t dmamap;
 	uint64_t txstat;
 	int i;
 	u_int col;
 	DPRINTF(MEC_DEBUG_TXINTR, ("mec_txintr: called\n"));
 	for (i = sc->sc_txdirty; i != txptr && sc->sc_txpending != 0;