xref: /src/sys/dev/usb/if_smsc.c

/*	$NetBSD: if_smsc.c,v 1.51 2019/08/10 02:17:36 mrg Exp $	*/

/*	$OpenBSD: if_smsc.c,v 1.4 2012/09/27 12:38:11 jsg Exp $	*/
/*	$FreeBSD: src/sys/dev/usb/net/if_smsc.c,v 1.1 2012/08/15 04:03:55 gonzo Exp $ */
/*-
 * Copyright (c) 2012
 *	Ben Gray <bgray (at) freebsd.org>.
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * SMSC LAN9xxx devices (http://www.smsc.com/)
 *
 * The LAN9500 & LAN9500A devices are stand-alone USB to Ethernet chips that
 * support USB 2.0 and 10/100 Mbps Ethernet.
 *
 * The LAN951x devices are an integrated USB hub and USB to Ethernet adapter.
 * The driver only covers the Ethernet part, the standard USB hub driver
 * supports the hub part.
 *
 * This driver is closely modelled on the Linux driver written and copyrighted
 * by SMSC.
 *
 * H/W TCP & UDP Checksum Offloading
 * ---------------------------------
 * The chip supports both tx and rx offloading of UDP & TCP checksums, this
 * feature can be dynamically enabled/disabled.
 *
 * RX checksuming is performed across bytes after the IPv4 header to the end of
 * the Ethernet frame, this means if the frame is padded with non-zero values
 * the H/W checksum will be incorrect, however the rx code compensates for this.
 *
 * TX checksuming is more complicated, the device requires a special header to
 * be prefixed onto the start of the frame which indicates the start and end
 * positions of the UDP or TCP frame.  This requires the driver to manually
 * go through the packet data and decode the headers prior to sending.
 * On Linux they generally provide cues to the location of the csum and the
 * area to calculate it over, on FreeBSD we seem to have to do it all ourselves,
 * hence this is not as optimal and therefore h/w TX checksum is currently not
 * implemented.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_smsc.c,v 1.51 2019/08/10 02:17:36 mrg Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

#include <sys/param.h>
#include <sys/module.h>

#include <dev/usb/usbnet.h>

#include <dev/usb/if_smscreg.h>

#include "ioconf.h"

#ifdef USB_DEBUG
int smsc_debug = 0;
#endif

struct smsc_softc {
	struct usbnet		smsc_un;

	/*
	 * The following stores the settings in the mac control (MAC_CSR)
	 * register
	 */
	uint32_t		sc_mac_csr;
	uint32_t		sc_rev_id;

	uint32_t		sc_coe_ctrl;
};

#define SMSC_MIN_BUFSZ		2048
#define SMSC_MAX_BUFSZ		18944

/*
 * Various supported device vendors/products.
 */
static const struct usb_devno smsc_devs[] = {
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_LAN89530 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_LAN9530 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_LAN9730 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500A },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500A_ALT },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500A_HAL },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500A_SAL10 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500_ALT },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9500_SAL10 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9505 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9505A },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9505A_HAL },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9505A_SAL10 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9505_SAL10 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9512_14 },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9512_14_ALT },
	{ USB_VENDOR_SMSC,	USB_PRODUCT_SMSC_SMSC9512_14_SAL10 }
};

#ifdef USB_DEBUG
#define smsc_dbg_printf(un, fmt, args...) \
	do { \
		if (smsc_debug > 0) \
			printf("debug: " fmt, ##args); \
	} while(0)
#else
#define smsc_dbg_printf(un, fmt, args...)
#endif

#define smsc_warn_printf(un, fmt, args...) \
	printf("%s: warning: " fmt, device_xname((un)->un_dev), ##args)

#define smsc_err_printf(un, fmt, args...) \
	printf("%s: error: " fmt, device_xname((un)->un_dev), ##args)

/* Function declarations */
int		 smsc_match(device_t, cfdata_t, void *);
void		 smsc_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(usmsc, sizeof(struct smsc_softc),
    smsc_match, smsc_attach, usbnet_detach, usbnet_activate);

int		 smsc_chip_init(struct usbnet *);
int		 smsc_setmacaddress(struct usbnet *, const uint8_t *);

int		 smsc_init(struct ifnet *);
int		 smsc_init_locked(struct ifnet *);
int		 smsc_ioctl(struct ifnet *, u_long, void *);
void		 smsc_stop_cb(struct ifnet *, int);

void		 smsc_reset(struct smsc_softc *);

static void	 smsc_miibus_statchg(struct ifnet *);
int		 smsc_readreg(struct usbnet *, uint32_t, uint32_t *);
int		 smsc_writereg(struct usbnet *, uint32_t, uint32_t);
int		 smsc_wait_for_bits(struct usbnet *, uint32_t, uint32_t);
usbd_status	 smsc_miibus_readreg(struct usbnet *, int, int, uint16_t *);
usbd_status	 smsc_miibus_writereg(struct usbnet *, int, int, uint16_t);

static int	 smsc_ioctl_cb(struct ifnet *, u_long, void *);
static unsigned	 smsc_tx_prepare(struct usbnet *, struct mbuf *,
		     struct usbnet_chain *);
static void	 smsc_rxeof_loop(struct usbnet *, struct usbd_xfer *,
		    struct usbnet_chain *, uint32_t);

static struct usbnet_ops smsc_ops = {
	.uno_stop = smsc_stop_cb,
	.uno_ioctl = smsc_ioctl_cb,
	.uno_read_reg = smsc_miibus_readreg,
	.uno_write_reg = smsc_miibus_writereg,
	.uno_statchg = smsc_miibus_statchg,
	.uno_tx_prepare = smsc_tx_prepare,
	.uno_rx_loop = smsc_rxeof_loop,
	.uno_init = smsc_init,
};

int
smsc_readreg(struct usbnet *un, uint32_t off, uint32_t *data)
{
	usb_device_request_t req;
	uint32_t buf;
	usbd_status err;

	usbnet_isowned_mii(un);

	if (usbnet_isdying(un))
		return 0;

	req.bmRequestType = UT_READ_VENDOR_DEVICE;
	req.bRequest = SMSC_UR_READ_REG;
	USETW(req.wValue, 0);
	USETW(req.wIndex, off);
	USETW(req.wLength, 4);

	err = usbd_do_request(un->un_udev, &req, &buf);
	if (err != 0)
		smsc_warn_printf(un, "Failed to read register 0x%0x\n", off);

	*data = le32toh(buf);

	return err;
}

int
smsc_writereg(struct usbnet *un, uint32_t off, uint32_t data)
{
	usb_device_request_t req;
	uint32_t buf;
	usbd_status err;

	usbnet_isowned_mii(un);

	if (usbnet_isdying(un))
		return 0;

	buf = htole32(data);

	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
	req.bRequest = SMSC_UR_WRITE_REG;
	USETW(req.wValue, 0);
	USETW(req.wIndex, off);
	USETW(req.wLength, 4);

	err = usbd_do_request(un->un_udev, &req, &buf);
	if (err != 0)
		smsc_warn_printf(un, "Failed to write register 0x%0x\n", off);

	return err;
}

int
smsc_wait_for_bits(struct usbnet *un, uint32_t reg, uint32_t bits)
{
	uint32_t val;
	int err, i;

	for (i = 0; i < 100; i++) {
		if ((err = smsc_readreg(un, reg, &val)) != 0)
			return err;
		if (!(val & bits))
			return 0;
		DELAY(5);
	}

	return 1;
}

usbd_status
smsc_miibus_readreg(struct usbnet *un, int phy, int reg, uint16_t *val)
{
	uint32_t addr;
	uint32_t data = 0;
	int rv = 0;

	usbnet_isowned_mii(un);

	if (smsc_wait_for_bits(un, SMSC_MII_ADDR, SMSC_MII_BUSY) != 0) {
		smsc_warn_printf(un, "MII is busy\n");
		rv = -1;
		goto done;
	}

	addr = (phy << 11) | (reg << 6) | SMSC_MII_READ;
	smsc_writereg(un, SMSC_MII_ADDR, addr);

	if (smsc_wait_for_bits(un, SMSC_MII_ADDR, SMSC_MII_BUSY) != 0) {
		smsc_warn_printf(un, "MII read timeout\n");
		rv = ETIMEDOUT;
	}

	smsc_readreg(un, SMSC_MII_DATA, &data);

done:
	*val = data & 0xffff;
	return rv;
}

usbd_status
smsc_miibus_writereg(struct usbnet *un, int phy, int reg, uint16_t val)
{
	uint32_t addr;

	usbnet_isowned_mii(un);

	if (un->un_phyno != phy)
		return -1;

	if (smsc_wait_for_bits(un, SMSC_MII_ADDR, SMSC_MII_BUSY) != 0) {
		smsc_warn_printf(un, "MII is busy\n");
		return -1;
	}

	smsc_writereg(un, SMSC_MII_DATA, val);

	addr = (phy << 11) | (reg << 6) | SMSC_MII_WRITE;
	smsc_writereg(un, SMSC_MII_ADDR, addr);

	if (smsc_wait_for_bits(un, SMSC_MII_ADDR, SMSC_MII_BUSY) != 0) {
		smsc_warn_printf(un, "MII write timeout\n");
		return ETIMEDOUT;
	}

	return 0;
}

void
smsc_miibus_statchg(struct ifnet *ifp)
{
	struct usbnet * const un = ifp->if_softc;

	if (usbnet_isdying(un))
		return;

	struct smsc_softc * const sc = usbnet_softc(un);
	struct mii_data * const mii = usbnet_mii(un);
	uint32_t flow;
	uint32_t afc_cfg;

	usbnet_set_link(un, false);
	if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
	    (IFM_ACTIVE | IFM_AVALID)) {
		switch (IFM_SUBTYPE(mii->mii_media_active)) {
			case IFM_10_T:
			case IFM_100_TX:
				usbnet_set_link(un, true);
				break;
			case IFM_1000_T:
				/* Gigabit ethernet not supported by chipset */
				break;
			default:
				break;
		}
	}

	/* Lost link, do nothing. */
	if (!usbnet_havelink(un))
		return;

	usbnet_lock_mii(un);
	int err = smsc_readreg(un, SMSC_AFC_CFG, &afc_cfg);
	usbnet_unlock_mii(un);
	if (err) {
		smsc_warn_printf(un, "failed to read initial AFC_CFG, "
		    "error %d\n", err);
		return;
	}

	/* Enable/disable full duplex operation and TX/RX pause */
	if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
		smsc_dbg_printf(un, "full duplex operation\n");
		sc->sc_mac_csr &= ~SMSC_MAC_CSR_RCVOWN;
		sc->sc_mac_csr |= SMSC_MAC_CSR_FDPX;

		if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
			flow = 0xffff0002;
		else
			flow = 0;

		if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
			afc_cfg |= 0xf;
		else
			afc_cfg &= ~0xf;
	} else {
		smsc_dbg_printf(un, "half duplex operation\n");
		sc->sc_mac_csr &= ~SMSC_MAC_CSR_FDPX;
		sc->sc_mac_csr |= SMSC_MAC_CSR_RCVOWN;

		flow = 0;
		afc_cfg |= 0xf;
	}

	usbnet_lock_mii(un);
	err = smsc_writereg(un, SMSC_MAC_CSR, sc->sc_mac_csr);
	err += smsc_writereg(un, SMSC_FLOW, flow);
	err += smsc_writereg(un, SMSC_AFC_CFG, afc_cfg);
	usbnet_unlock_mii(un);

	if (err)
		smsc_warn_printf(un, "media change failed, error %d\n", err);
}

static inline uint32_t
smsc_hash(uint8_t addr[ETHER_ADDR_LEN])
{

	return (ether_crc32_be(addr, ETHER_ADDR_LEN) >> 26) & 0x3f;
}

static void
smsc_setiff_locked(struct usbnet *un)
{
    	struct smsc_softc * const sc = usbnet_softc(un);
	struct ifnet * const ifp = usbnet_ifp(un);
	struct ethercom *ec = usbnet_ec(un);
	struct ether_multi *enm;
	struct ether_multistep step;
	uint32_t hashtbl[2] = { 0, 0 };
	uint32_t hash;

	usbnet_isowned_mii(un);

	if (usbnet_isdying(un))
		return;

	if (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)) {
allmulti:
		smsc_dbg_printf(un, "receive all multicast enabled\n");
		sc->sc_mac_csr |= SMSC_MAC_CSR_MCPAS;
		sc->sc_mac_csr &= ~SMSC_MAC_CSR_HPFILT;
		smsc_writereg(un, SMSC_MAC_CSR, sc->sc_mac_csr);
		return;
	} else {
		sc->sc_mac_csr |= SMSC_MAC_CSR_HPFILT;
		sc->sc_mac_csr &= ~(SMSC_MAC_CSR_PRMS | SMSC_MAC_CSR_MCPAS);
	}

	ETHER_LOCK(ec);
	ETHER_FIRST_MULTI(step, ec, enm);
	while (enm != NULL) {
		if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
			ETHER_UNLOCK(ec);
			goto allmulti;
		}

		hash = smsc_hash(enm->enm_addrlo);
		hashtbl[hash >> 5] |= 1 << (hash & 0x1F);
		ETHER_NEXT_MULTI(step, enm);
	}
	ETHER_UNLOCK(ec);

	/* Debug */
	if (sc->sc_mac_csr & SMSC_MAC_CSR_HPFILT) {
		smsc_dbg_printf(un, "receive select group of macs\n");
	} else {
		smsc_dbg_printf(un, "receive own packets only\n");
	}

	/* Write the hash table and mac control registers */

	//XXX should we be doing this?
	ifp->if_flags &= ~IFF_ALLMULTI;
	smsc_writereg(un, SMSC_HASHH, hashtbl[1]);
	smsc_writereg(un, SMSC_HASHL, hashtbl[0]);
	smsc_writereg(un, SMSC_MAC_CSR, sc->sc_mac_csr);
}

static void
smsc_setiff(struct usbnet *un)
{
	usbnet_lock_mii(un);
	smsc_setiff_locked(un);
	usbnet_unlock_mii(un);
}

static int
smsc_setoe_locked(struct usbnet *un)
{
	struct smsc_softc * const sc = usbnet_softc(un);
	struct ifnet * const ifp = usbnet_ifp(un);
	uint32_t val;
	int err;

	usbnet_isowned_mii(un);

	err = smsc_readreg(un, SMSC_COE_CTRL, &val);
	if (err != 0) {
		smsc_warn_printf(un, "failed to read SMSC_COE_CTRL (err=%d)\n",
		    err);
		return err;
	}

	/* Enable/disable the Rx checksum */
	if (ifp->if_capenable & (IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx))
		val |= (SMSC_COE_CTRL_RX_EN | SMSC_COE_CTRL_RX_MODE);
	else
		val &= ~(SMSC_COE_CTRL_RX_EN | SMSC_COE_CTRL_RX_MODE);

	/* Enable/disable the Tx checksum (currently not supported) */
	if (ifp->if_capenable & (IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_UDPv4_Tx))
		val |= SMSC_COE_CTRL_TX_EN;
	else
		val &= ~SMSC_COE_CTRL_TX_EN;

	sc->sc_coe_ctrl = val;

	err = smsc_writereg(un, SMSC_COE_CTRL, val);
	if (err != 0) {
		smsc_warn_printf(un, "failed to write SMSC_COE_CTRL (err=%d)\n",
		    err);
		return err;
	}

	return 0;
}

static void
smsc_setoe(struct usbnet *un)
{

	usbnet_lock_mii(un);
	smsc_setoe_locked(un);
	usbnet_unlock_mii(un);
}


int
smsc_setmacaddress(struct usbnet *un, const uint8_t *addr)
{
	int err;
	uint32_t val;

	smsc_dbg_printf(un, "setting mac address to "
	    "%02x:%02x:%02x:%02x:%02x:%02x\n",
	    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);

	val = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0];
	if ((err = smsc_writereg(un, SMSC_MAC_ADDRL, val)) != 0)
		goto done;

	val = (addr[5] << 8) | addr[4];
	err = smsc_writereg(un, SMSC_MAC_ADDRH, val);

done:
	return err;
}

void
smsc_reset(struct smsc_softc *sc)
{
	struct usbnet * const un = &sc->smsc_un;

	usbnet_isowned(un);
	if (usbnet_isdying(un))
		return;

	/* Wait a little while for the chip to get its brains in order. */
	DELAY(1000);

	/* Reinitialize controller to achieve full reset. */
	smsc_chip_init(un);
}

int
smsc_init(struct ifnet *ifp)
{
	struct usbnet * const un = ifp->if_softc;

	usbnet_lock(un);
	int ret = smsc_init_locked(ifp);
	usbnet_unlock(un);

	return ret;
}

int
smsc_init_locked(struct ifnet *ifp)
{
	struct usbnet * const un = ifp->if_softc;
	struct smsc_softc * const sc = usbnet_softc(un);

	if (usbnet_isdying(un))
		return EIO;

	/* Cancel pending I/O */
	usbnet_stop(un, ifp, 1);

	/* Reset the ethernet interface. */
	smsc_reset(sc);

	usbnet_lock_mii_un_locked(un);

	/* Load the multicast filter. */
	smsc_setiff_locked(un);

	/* TCP/UDP checksum offload engines. */
	smsc_setoe_locked(un);

	usbnet_unlock_mii_un_locked(un);

	return usbnet_init_rx_tx(un);
}

void
smsc_stop_cb(struct ifnet *ifp, int disable)
{
	struct usbnet * const un = ifp->if_softc;
	struct smsc_softc * const sc = usbnet_softc(un);

	// XXXNH didn't do this before
	smsc_reset(sc);
}

int
smsc_chip_init(struct usbnet *un)
{
	struct smsc_softc * const sc = usbnet_softc(un);
	uint32_t reg_val;
	int burst_cap;
	int err;

	usbnet_lock_mii_un_locked(un);

	/* Enter H/W config mode */
	smsc_writereg(un, SMSC_HW_CFG, SMSC_HW_CFG_LRST);

	if ((err = smsc_wait_for_bits(un, SMSC_HW_CFG,
	    SMSC_HW_CFG_LRST)) != 0) {
		smsc_warn_printf(un, "timed-out waiting for reset to "
		    "complete\n");
		goto init_failed;
	}

	/* Reset the PHY */
	smsc_writereg(un, SMSC_PM_CTRL, SMSC_PM_CTRL_PHY_RST);

	if ((err = smsc_wait_for_bits(un, SMSC_PM_CTRL,
	    SMSC_PM_CTRL_PHY_RST)) != 0) {
		smsc_warn_printf(un, "timed-out waiting for phy reset to "
		    "complete\n");
		goto init_failed;
	}
	usbd_delay_ms(un->un_udev, 40);

	/* Set the mac address */
	struct ifnet * const ifp = usbnet_ifp(un);
	const char *eaddr = CLLADDR(ifp->if_sadl);
	if ((err = smsc_setmacaddress(un, eaddr)) != 0) {
		smsc_warn_printf(un, "failed to set the MAC address\n");
		goto init_failed;
	}

	/*
	 * Don't know what the HW_CFG_BIR bit is, but following the reset
	 * sequence as used in the Linux driver.
	 */
	if ((err = smsc_readreg(un, SMSC_HW_CFG, &reg_val)) != 0) {
		smsc_warn_printf(un, "failed to read HW_CFG: %d\n", err);
		goto init_failed;
	}
	reg_val |= SMSC_HW_CFG_BIR;
	smsc_writereg(un, SMSC_HW_CFG, reg_val);

	/*
	 * There is a so called 'turbo mode' that the linux driver supports, it
	 * seems to allow you to jam multiple frames per Rx transaction.
	 * By default this driver supports that and therefore allows multiple
	 * frames per USB transfer.
	 *
	 * The xfer buffer size needs to reflect this as well, therefore based
	 * on the calculations in the Linux driver the RX bufsize is set to
	 * 18944,
	 *     bufsz = (16 * 1024 + 5 * 512)
	 *
	 * Burst capability is the number of URBs that can be in a burst of
	 * data/ethernet frames.
	 */

	if (un->un_udev->ud_speed == USB_SPEED_HIGH)
		burst_cap = 37;
	else
		burst_cap = 128;

	smsc_writereg(un, SMSC_BURST_CAP, burst_cap);

	/* Set the default bulk in delay (magic value from Linux driver) */
	smsc_writereg(un, SMSC_BULK_IN_DLY, 0x00002000);

	/*
	 * Initialise the RX interface
	 */
	if ((err = smsc_readreg(un, SMSC_HW_CFG, &reg_val)) < 0) {
		smsc_warn_printf(un, "failed to read HW_CFG: (err = %d)\n",
		    err);
		goto init_failed;
	}

	/*
	 * The following settings are used for 'turbo mode', a.k.a multiple
	 * frames per Rx transaction (again info taken form Linux driver).
	 */
	reg_val |= (SMSC_HW_CFG_MEF | SMSC_HW_CFG_BCE);

	/*
	 * set Rx data offset to ETHER_ALIGN which will make the IP header
	 * align on a word boundary.
	 */
	reg_val |= ETHER_ALIGN << SMSC_HW_CFG_RXDOFF_SHIFT;

	smsc_writereg(un, SMSC_HW_CFG, reg_val);

	/* Clear the status register ? */
	smsc_writereg(un, SMSC_INTR_STATUS, 0xffffffff);

	/* Read and display the revision register */
	if ((err = smsc_readreg(un, SMSC_ID_REV, &sc->sc_rev_id)) < 0) {
		smsc_warn_printf(un, "failed to read ID_REV (err = %d)\n", err);
		goto init_failed;
	}

	/* GPIO/LED setup */
	reg_val = SMSC_LED_GPIO_CFG_SPD_LED | SMSC_LED_GPIO_CFG_LNK_LED |
	    SMSC_LED_GPIO_CFG_FDX_LED;
	smsc_writereg(un, SMSC_LED_GPIO_CFG, reg_val);

	/*
	 * Initialise the TX interface
	 */
	smsc_writereg(un, SMSC_FLOW, 0);

	smsc_writereg(un, SMSC_AFC_CFG, AFC_CFG_DEFAULT);

	/* Read the current MAC configuration */
	if ((err = smsc_readreg(un, SMSC_MAC_CSR, &sc->sc_mac_csr)) < 0) {
		smsc_warn_printf(un, "failed to read MAC_CSR (err=%d)\n", err);
		goto init_failed;
	}

	/* disable pad stripping, collides with checksum offload */
	sc->sc_mac_csr &= ~SMSC_MAC_CSR_PADSTR;

	/* Vlan */
	smsc_writereg(un, SMSC_VLAN1, (uint32_t)ETHERTYPE_VLAN);

	/*
	 * Start TX
	 */
	sc->sc_mac_csr |= SMSC_MAC_CSR_TXEN;
	smsc_writereg(un, SMSC_MAC_CSR, sc->sc_mac_csr);
	smsc_writereg(un, SMSC_TX_CFG, SMSC_TX_CFG_ON);

	/*
	 * Start RX
	 */
	sc->sc_mac_csr |= SMSC_MAC_CSR_RXEN;
	smsc_writereg(un, SMSC_MAC_CSR, sc->sc_mac_csr);
	usbnet_unlock_mii_un_locked(un);

	return 0;

init_failed:
	usbnet_unlock_mii_un_locked(un);
	smsc_err_printf(un, "smsc_chip_init failed (err=%d)\n", err);
	return err;
}

static int
smsc_ioctl_cb(struct ifnet *ifp, u_long cmd, void *data)
{
	struct usbnet * const un = ifp->if_softc;

	switch (cmd) {
	case SIOCSIFFLAGS:
	case SIOCSETHERCAP:
	case SIOCADDMULTI:
	case SIOCDELMULTI:
		smsc_setiff(un);
		break;
	case SIOCSIFCAP:
		smsc_setoe(un);
		break;
	default:
		break;
	}

	return 0;
}

int
smsc_match(device_t parent, cfdata_t match, void *aux)
{
	struct usb_attach_arg *uaa = aux;

	return (usb_lookup(smsc_devs, uaa->uaa_vendor, uaa->uaa_product) != NULL) ?
	    UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}

void
smsc_attach(device_t parent, device_t self, void *aux)
{
	struct smsc_softc * const sc = device_private(self);
	struct usbnet * const un = &sc->smsc_un;
	struct usb_attach_arg *uaa = aux;
	struct usbd_device *dev = uaa->uaa_device;
	usb_interface_descriptor_t *id;
	usb_endpoint_descriptor_t *ed;
	char *devinfop;
	unsigned bufsz;
	int err, i;
	uint32_t mac_h, mac_l;

	/* Switch to usbnet for device_private() */
	self->dv_private = un;

	aprint_naive("\n");
	aprint_normal("\n");

	un->un_dev = self;
	un->un_udev = dev;
	un->un_sc = sc;
	un->un_ops = &smsc_ops;
	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
	un->un_rx_list_cnt = SMSC_RX_LIST_CNT;
	un->un_tx_list_cnt = SMSC_TX_LIST_CNT;

	devinfop = usbd_devinfo_alloc(un->un_udev, 0);
	aprint_normal_dev(self, "%s\n", devinfop);
	usbd_devinfo_free(devinfop);

	err = usbd_set_config_no(dev, SMSC_CONFIG_INDEX, 1);
	if (err) {
		aprint_error_dev(self, "failed to set configuration"
		    ", err=%s\n", usbd_errstr(err));
		return;
	}

	/* Setup the endpoints for the SMSC LAN95xx device(s) */
	err = usbd_device2interface_handle(dev, SMSC_IFACE_IDX, &un->un_iface);
	if (err) {
		aprint_error_dev(self, "getting interface handle failed\n");
		return;
	}

	id = usbd_get_interface_descriptor(un->un_iface);

	if (dev->ud_speed >= USB_SPEED_HIGH) {
		bufsz = SMSC_MAX_BUFSZ;
	} else {
		bufsz = SMSC_MIN_BUFSZ;
	}
	un->un_rx_bufsz = bufsz;
	un->un_tx_bufsz = bufsz;

	/* Find endpoints. */
	for (i = 0; i < id->bNumEndpoints; i++) {
		ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
		if (!ed) {
			aprint_error_dev(self, "couldn't get ep %d\n", i);
			return;
		}
		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
			un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
			un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
#if 0 /* not used yet */
		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
			un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress;
#endif
		}
	}

	usbnet_attach(un, "smscdet");

#ifdef notyet
	/*
	 * We can do TCPv4, and UDPv4 checksums in hardware.
	 */
	struct ifnet *ifp = usbnet_ifp(un);

	ifp->if_capabilities |=
	    /*IFCAP_CSUM_TCPv4_Tx |*/ IFCAP_CSUM_TCPv4_Rx |
	    /*IFCAP_CSUM_UDPv4_Tx |*/ IFCAP_CSUM_UDPv4_Rx;
#endif
	struct ethercom *ec = usbnet_ec(un);
	ec->ec_capabilities = ETHERCAP_VLAN_MTU;

	/* Setup some of the basics */
	un->un_phyno = 1;

	usbnet_lock_mii(un);
	/*
	 * Attempt to get the mac address, if an EEPROM is not attached this
	 * will just return FF:FF:FF:FF:FF:FF, so in such cases we invent a MAC
	 * address based on urandom.
	 */
	memset(un->un_eaddr, 0xff, ETHER_ADDR_LEN);

	prop_dictionary_t dict = device_properties(self);
	prop_data_t eaprop = prop_dictionary_get(dict, "mac-address");

	if (eaprop != NULL) {
		KASSERT(prop_object_type(eaprop) == PROP_TYPE_DATA);
		KASSERT(prop_data_size(eaprop) == ETHER_ADDR_LEN);
		memcpy(un->un_eaddr, prop_data_data_nocopy(eaprop),
		    ETHER_ADDR_LEN);
	} else {
		/* Check if there is already a MAC address in the register */
		if ((smsc_readreg(un, SMSC_MAC_ADDRL, &mac_l) == 0) &&
		    (smsc_readreg(un, SMSC_MAC_ADDRH, &mac_h) == 0)) {
			un->un_eaddr[5] = (uint8_t)((mac_h >> 8) & 0xff);
			un->un_eaddr[4] = (uint8_t)((mac_h) & 0xff);
			un->un_eaddr[3] = (uint8_t)((mac_l >> 24) & 0xff);
			un->un_eaddr[2] = (uint8_t)((mac_l >> 16) & 0xff);
			un->un_eaddr[1] = (uint8_t)((mac_l >> 8) & 0xff);
			un->un_eaddr[0] = (uint8_t)((mac_l) & 0xff);
		}
	}
	usbnet_unlock_mii(un);

	usbnet_attach_ifp(un, true, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
	    0, 0);
}

void
smsc_rxeof_loop(struct usbnet * un, struct usbd_xfer *xfer,
    struct usbnet_chain *c, uint32_t total_len)
{
	struct smsc_softc * const sc = usbnet_softc(un);
	struct ifnet *ifp = usbnet_ifp(un);
	uint8_t *buf = c->unc_buf;

	usbnet_isowned_rx(un);

	while (total_len != 0) {
		uint32_t rxhdr;
		if (total_len < sizeof(rxhdr)) {
			smsc_dbg_printf(un, "total_len %d < sizeof(rxhdr) %zu\n",
			    total_len, sizeof(rxhdr));
			ifp->if_ierrors++;
			return;
		}

		memcpy(&rxhdr, buf, sizeof(rxhdr));
		rxhdr = le32toh(rxhdr);
		buf += sizeof(rxhdr);
		total_len -= sizeof(rxhdr);

		if (rxhdr & SMSC_RX_STAT_COLLISION)
			ifp->if_collisions++;

		if (rxhdr & (SMSC_RX_STAT_ERROR
			   | SMSC_RX_STAT_LENGTH_ERROR
			   | SMSC_RX_STAT_MII_ERROR)) {
			smsc_dbg_printf(un, "rx error (hdr 0x%08x)\n", rxhdr);
			ifp->if_ierrors++;
			return;
		}

		uint16_t pktlen = (uint16_t)SMSC_RX_STAT_FRM_LENGTH(rxhdr);
		smsc_dbg_printf(un, "rxeof total_len %d pktlen %d rxhdr "
		    "0x%08x\n", total_len, pktlen, rxhdr);

		if (pktlen < ETHER_HDR_LEN) {
			smsc_dbg_printf(un, "pktlen %d < ETHER_HDR_LEN %d\n",
			    pktlen, ETHER_HDR_LEN);
			ifp->if_ierrors++;
			return;
		}

		pktlen += ETHER_ALIGN;

		if (pktlen > MCLBYTES) {
			smsc_dbg_printf(un, "pktlen %d > MCLBYTES %d\n",
			    pktlen, MCLBYTES);
			ifp->if_ierrors++;
			return;
		}

		if (pktlen > total_len) {
			smsc_dbg_printf(un, "pktlen %d > total_len %d\n",
			    pktlen, total_len);
			ifp->if_ierrors++;
			return;
		}

		uint8_t *pktbuf = buf + ETHER_ALIGN;
		size_t buflen = pktlen;
		int mbuf_flags = M_HASFCS;
		int csum_flags = 0;
		uint16_t csum_data = 0;

 		KASSERT(pktlen < MCLBYTES);

		/* Check if RX TCP/UDP checksumming is being offloaded */
		if (sc->sc_coe_ctrl & SMSC_COE_CTRL_RX_EN) {
			smsc_dbg_printf(un,"RX checksum offload checking\n");
			struct ether_header *eh = (struct ether_header *)pktbuf;
			const size_t cssz = sizeof(csum_data);

			/* Remove the extra 2 bytes of the csum */
			buflen -= cssz;

			/*
			 * The checksum appears to be simplistically calculated
			 * over the udp/tcp header and data up to the end of the
			 * eth frame.  Which means if the eth frame is padded
			 * the csum calculation is incorrectly performed over
			 * the padding bytes as well. Therefore to be safe we
			 * ignore the H/W csum on frames less than or equal to
			 * 64 bytes.
			 *
			 * Ignore H/W csum for non-IPv4 packets.
			 */
			smsc_dbg_printf(un,"Ethertype %02x pktlen %02x\n",
			    be16toh(eh->ether_type), pktlen);
			if (be16toh(eh->ether_type) == ETHERTYPE_IP &&
			    pktlen > ETHER_MIN_LEN) {

				csum_flags |=
				    (M_CSUM_TCPv4 | M_CSUM_UDPv4 | M_CSUM_DATA);

				/*
				 * Copy the TCP/UDP checksum from the last 2
				 * bytes of the transfer and put in the
				 * csum_data field.
				 */
				memcpy(&csum_data, buf + pktlen - cssz, cssz);

				/*
				 * The data is copied in network order, but the
				 * csum algorithm in the kernel expects it to be
				 * in host network order.
				 */
				csum_data = ntohs(csum_data);
				smsc_dbg_printf(un,
				    "RX checksum offloaded (0x%04x)\n",
				    csum_data);
			}
		}

		/* round up to next longword */
		pktlen = (pktlen + 3) & ~0x3;

		/* total_len does not include the padding */
		if (pktlen > total_len)
			pktlen = total_len;

		buf += pktlen;
		total_len -= pktlen;

		/* push the packet up */
		usbnet_enqueue(un, pktbuf, buflen, csum_flags, csum_data,
		    mbuf_flags);
	}
}

static unsigned
smsc_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
{
	uint32_t txhdr;
	uint32_t frm_len = 0;

	usbnet_isowned_tx(un);

	/*
	 * Each frame is prefixed with two 32-bit values describing the
	 * length of the packet and buffer.
	 */
	txhdr = SMSC_TX_CTRL_0_BUF_SIZE(m->m_pkthdr.len) |
	    SMSC_TX_CTRL_0_FIRST_SEG | SMSC_TX_CTRL_0_LAST_SEG;
	txhdr = htole32(txhdr);
	memcpy(c->unc_buf, &txhdr, sizeof(txhdr));

	txhdr = SMSC_TX_CTRL_1_PKT_LENGTH(m->m_pkthdr.len);
	txhdr = htole32(txhdr);
	memcpy(c->unc_buf + 4, &txhdr, sizeof(txhdr));

	frm_len += 8;

	/* Next copy in the actual packet */
	m_copydata(m, 0, m->m_pkthdr.len, c->unc_buf + frm_len);
	frm_len += m->m_pkthdr.len;

	return frm_len;
}

MODULE(MODULE_CLASS_DRIVER, if_smsc, "usbnet");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
if_smsc_modcmd(modcmd_t cmd, void *aux)
{
	int error = 0;

	switch (cmd) {
	case MODULE_CMD_INIT:
#ifdef _MODULE
		error = config_init_component(cfdriver_ioconf_smsc,
		    cfattach_ioconf_smsc, cfdata_ioconf_smsc);
#endif
		return error;
	case MODULE_CMD_FINI:
#ifdef _MODULE
		error = config_fini_component(cfdriver_ioconf_smsc,
		    cfattach_ioconf_smsc, cfdata_ioconf_smsc);
#endif
		return error;
	default:
		return ENOTTY;
	}
}