* Copyright (c) 2008 KIYOHARA Takashi

/* $NetBSD: lan9118.c,v 1.36 2020/01/29 14:53:40 thorpej Exp $ */
/*
* Copyright (c) 2008 KIYOHARA Takashi
* 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.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lan9118.c,v 1.36 2020/01/29 14:53:40 thorpej Exp $");

/*
* The LAN9118 Family
* * The LAN9118 is targeted for 32-bit applications requiring high
* performance, and provides the highest level of performance possible for
* a non-PCI 10/100 Ethernet controller.
*
* * The LAN9117 is designed to provide the highest level of performance
* possible for 16-bit applications. It also has an external MII interface,
* which can be used to attach an external PHY.
*
* * The LAN9116 and LAN9115 are designed for performance-sensitive
* applications with less intensive performance requirements. The LAN9116
* is for 32-bit host processors, while the LAN9115 is for 16-bit
* applications, which may also require an external PHY. Both devices
* deliver superior levels of performance.
*
* The LAN9218 Family
* Also support HP Auto-MDIX.
*/

#include <sys/param.h>
#include <sys/callout.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/bus.h>
#include <sys/ioctl.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/systm.h>

#include <net/if.h>
#include <net/if_ether.h>
#include <net/if_media.h>

#include <dev/mii/mii.h>
#include <dev/mii/miivar.h>

#include <net/bpf.h>
#include <sys/rndsource.h>

#include <dev/ic/lan9118reg.h>
#include <dev/ic/lan9118var.h>

#ifdef SMSH_DEBUG
#define DPRINTF(x) if (smsh_debug) printf x
#define DPRINTFN(n, x) if (smsh_debug >= (n)) printf x
int smsh_debug = SMSH_DEBUG;
#else
#define DPRINTF(x)
#define DPRINTFN(n, x)
#endif

static void lan9118_start(struct ifnet *);
static int lan9118_ioctl(struct ifnet *, u_long, void *);
static int lan9118_init(struct ifnet *);
static void lan9118_stop(struct ifnet *, int);
static void lan9118_watchdog(struct ifnet *);

static int lan9118_ifm_change(struct ifnet *);
static void lan9118_ifm_status(struct ifnet *, struct ifmediareq *);

static int lan9118_miibus_readreg(device_t, int, int, uint16_t *);
static int lan9118_miibus_writereg(device_t, int, int, uint16_t);
static void lan9118_miibus_statchg(struct ifnet *);

static int lan9118_mii_readreg(struct lan9118_softc *, int, int, uint16_t *);
static int lan9118_mii_writereg(struct lan9118_softc *, int, int, uint16_t);
static uint32_t lan9118_mac_readreg(struct lan9118_softc *, int);
static void lan9118_mac_writereg(struct lan9118_softc *, int, uint32_t);

static void lan9118_set_filter(struct lan9118_softc *);
static void lan9118_rxintr(struct lan9118_softc *);
static void lan9118_txintr(struct lan9118_softc *);

static void lan9118_tick(void *);

/* This values refer from Linux's smc911x.c */
static uint32_t afc_cfg[] = {
/* 0 */ 0x00000000,
/* 1 */ 0x00000000,
/* 2 */ 0x008c4600 | LAN9118_AFC_CFG_BACK_DUR(10) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 3 */ 0x00824100 | LAN9118_AFC_CFG_BACK_DUR(9) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 4 */ 0x00783c00 | LAN9118_AFC_CFG_BACK_DUR(9) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 5 */ 0x006e3700 | LAN9118_AFC_CFG_BACK_DUR(8) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 6 */ 0x00643200 | LAN9118_AFC_CFG_BACK_DUR(8) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 7 */ 0x005a2d00 | LAN9118_AFC_CFG_BACK_DUR(7) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 8 */ 0x00502800 | LAN9118_AFC_CFG_BACK_DUR(7) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* 9 */ 0x00462300 | LAN9118_AFC_CFG_BACK_DUR(6) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* a */ 0x003c1e00 | LAN9118_AFC_CFG_BACK_DUR(6) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* b */ 0x00321900 | LAN9118_AFC_CFG_BACK_DUR(5) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* c */ 0x00241200 | LAN9118_AFC_CFG_BACK_DUR(4) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* d */ 0x00150700 | LAN9118_AFC_CFG_BACK_DUR(3) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* e */ 0x00060300 | LAN9118_AFC_CFG_BACK_DUR(2) |
LAN9118_AFC_CFG_FCMULT | LAN9118_AFC_CFG_FCBRD |
LAN9118_AFC_CFG_FCADD | LAN9118_AFC_CFG_FCANY,
/* f */ 0x00000000,
};

int
lan9118_attach(struct lan9118_softc *sc)
{
struct ifnet *ifp = &sc->sc_ec.ec_if;
struct mii_data *mii = &sc->sc_mii;
uint32_t val, irq_cfg;
int timo, i;

if (sc->sc_flags & LAN9118_FLAGS_SWAP)
/* byte swap mode */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_WORD_SWAP,
0xffffffff);
val = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_BYTE_TEST);
if (val != LAN9118_BYTE_TEST_VALUE) {
aprint_error(": failed to detect chip\n");
return EINVAL;
}

val = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_ID_REV);
sc->sc_id = LAN9118_ID_REV_ID(val);
sc->sc_rev = LAN9118_ID_REV_REV(val);

#define LAN9xxx_ID(id) \
(IS_LAN9118(id) ? (id) : (IS_LAN9218(id) ? ((id) >> 4) + 0x100 : (id) & 0xfff))

aprint_normal(": SMSC LAN9%03x Rev %d\n",
LAN9xxx_ID(sc->sc_id), sc->sc_rev);

if (sc->sc_flags & LAN9118_FLAGS_SWAP)
aprint_normal_dev(sc->sc_dev, "byte swap mode\n");

timo = 3 * 1000 * 1000; /* XXXX 3sec */
do {
val = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_MAC_CSR_CMD);
if (!(val & LAN9118_MAC_CSR_CMD_BUSY))
break;
delay(100);
} while (timo -= 100);
if (timo <= 0)
aprint_error_dev(sc->sc_dev, "%s: command busy\n", __func__);
if (!(sc->sc_flags & LAN9118_FLAGS_NO_EEPROM)) {
/* Read auto-loaded MAC address */
val = lan9118_mac_readreg(sc, LAN9118_ADDRL);
sc->sc_enaddr[3] = (val >> 24) & 0xff;
sc->sc_enaddr[2] = (val >> 16) & 0xff;
sc->sc_enaddr[1] = (val >> 8) & 0xff;
sc->sc_enaddr[0] = val & 0xff;
val = lan9118_mac_readreg(sc, LAN9118_ADDRH);
sc->sc_enaddr[5] = (val >> 8) & 0xff;
sc->sc_enaddr[4] = val & 0xff;
}
aprint_normal_dev(sc->sc_dev, "MAC address %s\n",
ether_sprintf(sc->sc_enaddr));

/* Set IRQ config */
irq_cfg = 0;
if (sc->sc_flags & LAN9118_FLAGS_IRQ_ACTHI)
irq_cfg |= LAN9118_IRQ_CFG_IRQ_POL;
if (sc->sc_flags & LAN9118_FLAGS_IRQ_PP)
irq_cfg |= LAN9118_IRQ_CFG_IRQ_TYPE;
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_IRQ_CFG, irq_cfg);

KASSERT(LAN9118_TX_FIF_SZ >= 2 && LAN9118_TX_FIF_SZ < 15);
sc->sc_afc_cfg = afc_cfg[LAN9118_TX_FIF_SZ];

/* Initialize the ifnet structure. */
strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_start = lan9118_start;
ifp->if_ioctl = lan9118_ioctl;
ifp->if_init = lan9118_init;
ifp->if_stop = lan9118_stop;
ifp->if_watchdog = lan9118_watchdog;
IFQ_SET_READY(&ifp->if_snd);

#if 0 /* Not support 802.1Q VLAN-sized frames yet. */
sc->sc_ec.ec_capabilities |= ETHERCAP_VLAN_MTU;
#endif

sc->sc_ec.ec_mii = mii;
ifmedia_init(&mii->mii_media, 0,
lan9118_ifm_change, lan9118_ifm_status);
mii->mii_ifp = ifp;
mii->mii_readreg = lan9118_miibus_readreg;
mii->mii_writereg = lan9118_miibus_writereg;
mii->mii_statchg = lan9118_miibus_statchg;

/*
* Number of instance of Internal PHY is always 0. External PHY
* number that above.
*/
mii_attach(sc->sc_dev, mii, 0xffffffff, 1, MII_OFFSET_ANY, 0);

if (sc->sc_id == LAN9118_ID_9115 || sc->sc_id == LAN9118_ID_9117 ||
sc->sc_id == LAN9218_ID_9215 || sc->sc_id == LAN9218_ID_9217) {
if (bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG) &
LAN9118_HW_CFG_EXT_PHY_DET) {
/*
* We always have a internal PHY at phy1.
* In addition, external PHY is attached.
*/
DPRINTFN(1, ("%s: detect External PHY\n", __func__));

/* Switch MII and SMI */
bus_space_write_4(sc->sc_iot, sc->sc_ioh,
LAN9118_HW_CFG,
LAN9118_HW_CFG_MBO |
LAN9118_HW_CFG_PHY_CLK_SEL_CD);
delay(1); /* Wait 5 cycle */
bus_space_write_4(sc->sc_iot, sc->sc_ioh,
LAN9118_HW_CFG,
LAN9118_HW_CFG_MBO |
LAN9118_HW_CFG_PHY_CLK_SEL_EMII |
LAN9118_HW_CFG_SMI_SEL |
LAN9118_HW_CFG_EXT_PHY_EN);
delay(1); /* Once wait more 5 cycle */

/* Call mii_attach, avoid at phy1. */
mii_attach(sc->sc_dev, mii, 0xffffffff,
0, MII_OFFSET_ANY, 0);
for (i = 2; i < MII_NPHY; i++)
mii_attach(sc->sc_dev, mii, 0xffffffff,
i, MII_OFFSET_ANY, 0);
}
}

ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);

/* Attach the interface. */
if_attach(ifp);
if_deferred_start_init(ifp, NULL);
ether_ifattach(ifp, sc->sc_enaddr);

callout_init(&sc->sc_tick, 0);

rnd_attach_source(&sc->rnd_source, device_xname(sc->sc_dev),
RND_TYPE_NET, RND_FLAG_DEFAULT);
return 0;
}

int
lan9118_intr(void *arg)
{
struct lan9118_softc *sc = (struct lan9118_softc *)arg;
struct ifnet *ifp = &sc->sc_ec.ec_if;
uint32_t int_sts, int_en, datum = 0;
int handled = 0;

for (;;) {
int_sts =
bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_STS);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_STS,
int_sts);
int_en =
bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_EN) |
LAN9118_INT_SW_INT;

DPRINTFN(3, ("%s: int_sts=0x%x, int_en=0x%x\n",
__func__, int_sts, int_en));

if (!(int_sts & int_en))
break;
datum = int_sts;
handled = 1;

#if 0 /* not yet... */
if (int_sts & LAN9118_INT_PHY_INT) { /* PHY */
/* Shall we need? */
}
if (int_sts & LAN9118_INT_PME_INT) { /*Power Management Event*/
/* not yet... */
}
#endif
if (int_sts & LAN9118_INT_RXE) {
if_statinc(ifp, if_ierrors);
aprint_error_ifnet(ifp, "Receive Error\n");
}
if (int_sts & (LAN9118_INT_TSFL|LAN9118_INT_SW_INT)) /* TX Status FIFO Level */
lan9118_txintr(sc);
if (int_sts & LAN9118_INT_RXDF_INT) {
if_statinc(ifp, if_ierrors);
aprint_error_ifnet(ifp, "RX Dropped Frame Interrupt\n");
}
if (int_sts & LAN9118_INT_RSFF) {
if_statinc(ifp, if_ierrors);
aprint_error_ifnet(ifp, "RX Status FIFO Full\n");
}
if (int_sts & LAN9118_INT_RSFL) /* RX Status FIFO Level */
lan9118_rxintr(sc);
}

if (handled)
if_schedule_deferred_start(ifp);

rnd_add_uint32(&sc->rnd_source, datum);

return handled;
}

static void
lan9118_start(struct ifnet *ifp)
{
struct lan9118_softc *sc = ifp->if_softc;
struct mbuf *m0, *m;
unsigned tdfree, totlen, dso;
uint32_t txa, txb, int_en;
uint8_t *p;
int n;

DPRINTFN(3, ("%s\n", __func__));

if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
return;

totlen = 0;
for (;;) {
IFQ_POLL(&ifp->if_snd, m0);
if (m0 == NULL)
break;

tdfree = LAN9118_TX_FIFO_INF_TDFREE(bus_space_read_4(sc->sc_iot,
sc->sc_ioh, LAN9118_TX_FIFO_INF));
if (tdfree < 2036) {
/*
* 2036 is the possible maximum FIFO consumption
* for the most fragmented frame.
*/
ifp->if_flags |= IFF_OACTIVE;
break;
}

IFQ_DEQUEUE(&ifp->if_snd, m0);

/*
* WE ARE NOW COMMITTED TO TRANSMITTING THE PACKET.
*/

/*
* Check mbuf chain -- "middle" buffers must be >= 4 bytes
* and maximum # of buffers is 86.
*/
m = m0;
n = 0;
while (m) {
if (m->m_len < 4 || ++n > 86) {
/* Copy mbuf chain. */
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
goto discard; /* discard packet */
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);
goto discard; /* discard packet */
}
m_copydata(m0, 0, m0->m_pkthdr.len,
mtod(m, void *));
m->m_pkthdr.len = m->m_len = m0->m_pkthdr.len;
m_freem(m0);
m0 = m;
break;
}
m = m->m_next;
}

m = m0;
totlen = m->m_pkthdr.len;
p = mtod(m, uint8_t *);
dso = (unsigned)p & 0x3;
txa =
LAN9118_TXC_A_BEA_4B |
LAN9118_TXC_A_DSO(dso) |
LAN9118_TXC_A_FS |
LAN9118_TXC_A_BS(m->m_len);
txb = LAN9118_TXC_B_PL(totlen);
while (m->m_next != NULL) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TXDFIFOP, txa);
bus_space_write_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TXDFIFOP, txb);
bus_space_write_multi_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TXDFIFOP, (uint32_t *)(p - dso),
(m->m_len + dso + 3) >> 2);

m = m->m_next;
p = mtod(m, uint8_t *);
dso = (unsigned)p & 0x3;
txa =
LAN9118_TXC_A_BEA_4B |
LAN9118_TXC_A_DSO(dso) |
LAN9118_TXC_A_BS(m->m_len);
}
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_TXDFIFOP,
txa | LAN9118_TXC_A_LS);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_TXDFIFOP,
txb);
bus_space_write_multi_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TXDFIFOP, (uint32_t *)(p - dso),
(m->m_len + dso + 3) >> 2);

discard:
/*
* Pass the packet to any BPF listeners.
*/
bpf_mtap(ifp, m0, BPF_D_OUT);

m_freem(m0);
}

if (totlen > 0) {
ifp->if_timer = 5;

/*
* Trigger a software interrupt to catch any missed completion
* interrupts.
*/
int_en = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_INT_EN);
int_en |= LAN9118_INT_SW_INT;
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_EN,
int_en);
}
}

static int
lan9118_ioctl(struct ifnet *ifp, u_long command, void *data)
{
struct lan9118_softc *sc = ifp->if_softc;
int s, error = 0;

s = splnet();

switch (command) {
case SIOCSIFFLAGS:
DPRINTFN(2, ("%s: IFFLAGS\n", __func__));
if ((error = ifioctl_common(ifp, command, data)) != 0)
break;
switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
case IFF_RUNNING:
lan9118_stop(ifp, 0);
break;
case IFF_UP:
lan9118_init(ifp);
break;
case IFF_UP | IFF_RUNNING:
lan9118_set_filter(sc);
break;
default:
break;
}
error = 0;
break;

default:
DPRINTFN(2, ("%s: ETHER\n", __func__));
error = ether_ioctl(ifp, command, data);
if (error == ENETRESET) {
if (ifp->if_flags & IFF_RUNNING) {
lan9118_set_filter(sc);
DPRINTFN(2, ("%s set_filter called\n",
__func__));
}
error = 0;
}
break;
}

splx(s);

return error;
}

static int
lan9118_init(struct ifnet *ifp)
{
struct lan9118_softc *sc = ifp->if_softc;
struct ifmedia *ifm = &sc->sc_mii.mii_media;
uint32_t reg, hw_cfg, mac_cr, irq_cfg;
int timo, s;

DPRINTFN(2, ("%s\n", __func__));

s = splnet();

/* wait for PMT_CTRL[READY] */
timo = mstohz(5000); /* XXXX 5sec */
while (!(bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_PMT_CTRL) &
LAN9118_PMT_CTRL_READY)) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_BYTE_TEST,
0xbad0c0de);
tsleep(&sc, PRIBIO, "lan9118_pmt_ready", 1);
if (--timo <= 0) {
splx(s);
return EBUSY;
}
}

/* Soft Reset */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG,
LAN9118_HW_CFG_SRST);
do {
reg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG);
if (reg & LAN9118_HW_CFG_SRST_TO) {
aprint_error_dev(sc->sc_dev,
"soft reset timeouted out\n");
splx(s);
return ETIMEDOUT;
}
} while (reg & LAN9118_HW_CFG_SRST);

/* Set MAC and PHY CSRs */

if (sc->sc_flags & LAN9118_FLAGS_SWAP)
/* need byte swap */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_WORD_SWAP,
0xffffffff);

while (bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_E2P_CMD) &
LAN9118_E2P_CMD_EPCB);
if (!(bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_E2P_CMD) &
LAN9118_E2P_CMD_MACAL)) {
lan9118_mac_writereg(sc, LAN9118_ADDRL,
sc->sc_enaddr[0] |
sc->sc_enaddr[1] << 8 |
sc->sc_enaddr[2] << 16 |
sc->sc_enaddr[3] << 24);
lan9118_mac_writereg(sc, LAN9118_ADDRH,
sc->sc_enaddr[4] | sc->sc_enaddr[5] << 8);
}

if (ifm->ifm_media & IFM_FLOW) {
lan9118_mac_writereg(sc, LAN9118_FLOW,
LAN9118_FLOW_FCPT(1) | LAN9118_FLOW_FCEN);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_AFC_CFG,
sc->sc_afc_cfg);
}

lan9118_ifm_change(ifp);
hw_cfg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG);
hw_cfg &= ~LAN9118_HW_CFG_TX_FIF_MASK;
hw_cfg |= LAN9118_HW_CFG_TX_FIF_SZ(LAN9118_TX_FIF_SZ);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG, hw_cfg);

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_GPIO_CFG,
LAN9118_GPIO_CFG_LEDX_EN(2) |
LAN9118_GPIO_CFG_LEDX_EN(1) |
LAN9118_GPIO_CFG_LEDX_EN(0) |
LAN9118_GPIO_CFG_GPIOBUFN(2) |
LAN9118_GPIO_CFG_GPIOBUFN(1) |
LAN9118_GPIO_CFG_GPIOBUFN(0));

irq_cfg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_IRQ_CFG);
irq_cfg |= LAN9118_IRQ_CFG_IRQ_EN;
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_IRQ_CFG, irq_cfg);

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_STS,
bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_STS));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_FIFO_INT,
LAN9118_FIFO_INT_TXSL(0) | LAN9118_FIFO_INT_RXSL(0));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_EN,
#if 0 /* not yet... */
LAN9118_INT_PHY_INT | /* PHY */
LAN9118_INT_PME_INT | /* Power Management Event */
#endif
LAN9118_INT_RXE | /* Receive Error */
LAN9118_INT_TSFL | /* TX Status FIFO Level */
LAN9118_INT_RXDF_INT| /* RX Dropped Frame Interrupt */
LAN9118_INT_RSFF | /* RX Status FIFO Full */
LAN9118_INT_RSFL); /* RX Status FIFO Level */

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_RX_CFG,
LAN9118_RX_CFG_RXDOFF(2));
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_TX_CFG,
LAN9118_TX_CFG_TX_ON);
mac_cr = lan9118_mac_readreg(sc, LAN9118_MAC_CR);
lan9118_mac_writereg(sc, LAN9118_MAC_CR,
mac_cr | LAN9118_MAC_CR_TXEN | LAN9118_MAC_CR_RXEN);

lan9118_set_filter(sc);

ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;

callout_reset(&sc->sc_tick, hz, lan9118_tick, sc);

splx(s);

return 0;
}

static void
lan9118_stop(struct ifnet *ifp, int disable)
{
struct lan9118_softc *sc = ifp->if_softc;
uint32_t cr;

DPRINTFN(2, ("%s\n", __func__));

/* Disable IRQ */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_EN, 0);

/* Stopping transmitter */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_TX_CFG,
LAN9118_TX_CFG_STOP_TX);
while (bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_TX_CFG) &
(LAN9118_TX_CFG_TX_ON | LAN9118_TX_CFG_STOP_TX));

/* Purge TX Status/Data FIFOs */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_TX_CFG,
LAN9118_TX_CFG_TXS_DUMP | LAN9118_TX_CFG_TXD_DUMP);

/* Stopping receiver, also clear TXEN */
cr = lan9118_mac_readreg(sc, LAN9118_MAC_CR);
cr &= ~(LAN9118_MAC_CR_TXEN | LAN9118_MAC_CR_RXEN);
lan9118_mac_writereg(sc, LAN9118_MAC_CR, cr);
while (!(bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_INT_STS) &
LAN9118_INT_RXSTOP_INT));

/* Clear RX Status/Data FIFOs */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_RX_CFG,
LAN9118_RX_CFG_RX_DUMP);

callout_stop(&sc->sc_tick);
}

static void
lan9118_watchdog(struct ifnet *ifp)
{
struct lan9118_softc *sc = ifp->if_softc;

/*
* Reclaim first as there is a possibility of losing Tx completion
* interrupts.
*/
lan9118_txintr(sc);

aprint_error_ifnet(ifp, "watchdog timeout\n");
if_statinc(ifp, if_oerrors);

lan9118_init(ifp);
}

static int
lan9118_ifm_change(struct ifnet *ifp)
{
struct lan9118_softc *sc = ifp->if_softc;
struct mii_data *mii = &sc->sc_mii;
struct ifmedia *ifm = &mii->mii_media;
struct ifmedia_entry *ife = ifm->ifm_cur;
uint32_t pmt_ctrl;

DPRINTFN(3, ("%s: ifm inst %d\n", __func__, IFM_INST(ife->ifm_media)));

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG,
LAN9118_HW_CFG_MBO | LAN9118_HW_CFG_PHY_CLK_SEL_CD);
delay(1); /* Wait 5 cycle */

if (IFM_INST(ife->ifm_media) != 0) {
/* Use External PHY */

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG,
LAN9118_HW_CFG_MBO |
LAN9118_HW_CFG_PHY_CLK_SEL_EMII |
LAN9118_HW_CFG_SMI_SEL |
LAN9118_HW_CFG_EXT_PHY_EN);
delay(1);
return mii_mediachg(&sc->sc_mii);
}

/* Setup Internal PHY */

mii->mii_media_status = IFM_AVALID;
mii->mii_media_active = IFM_ETHER;

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_HW_CFG,
LAN9118_HW_CFG_MBO |
LAN9118_HW_CFG_PHY_CLK_SEL_IPHY);
delay(1);

/* Reset PHY */
pmt_ctrl = bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_PMT_CTRL);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_PMT_CTRL,
pmt_ctrl | LAN9118_PMT_CTRL_PHY_RST);
while (bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_PMT_CTRL) &
LAN9118_PMT_CTRL_PHY_RST);

mii_mediachg(&sc->sc_mii);
return 0;
}

static void
lan9118_ifm_status(struct ifnet *ifp, struct ifmediareq *ifmr)
{
struct lan9118_softc *sc = ifp->if_softc;
struct mii_data *mii = &sc->sc_mii;

DPRINTFN(3, ("%s\n", __func__));

mii_pollstat(mii);
ifmr->ifm_active = mii->mii_media_active;
ifmr->ifm_status = mii->mii_media_status;
}

static int
lan9118_miibus_readreg(device_t dev, int phy, int reg, uint16_t *val)
{

return lan9118_mii_readreg(device_private(dev), phy, reg, val);
}
static int
lan9118_miibus_writereg(device_t dev, int phy, int reg, uint16_t val)
{

return lan9118_mii_writereg(device_private(dev), phy, reg, val);
}

static void
lan9118_miibus_statchg(struct ifnet *ifp)
{
struct lan9118_softc *sc = ifp->if_softc;
u_int cr;

cr = lan9118_mac_readreg(sc, LAN9118_MAC_CR);
if (IFM_OPTIONS(sc->sc_mii.mii_media_active) & IFM_FDX) {
cr &= ~LAN9118_MAC_CR_RCVOWN;
cr |= LAN9118_MAC_CR_FDPX;
} else {
cr |= LAN9118_MAC_CR_RCVOWN;
cr &= ~LAN9118_MAC_CR_FDPX;
}
lan9118_mac_writereg(sc, LAN9118_MAC_CR, cr);
}

static int
lan9118_mii_readreg(struct lan9118_softc *sc, int phy, int reg, uint16_t *val)
{
uint32_t acc;

while (lan9118_mac_readreg(sc, LAN9118_MII_ACC) &
LAN9118_MII_ACC_MIIBZY);
acc = LAN9118_MII_ACC_PHYA(phy) | LAN9118_MII_ACC_MIIRINDA(reg);
lan9118_mac_writereg(sc, LAN9118_MII_ACC, acc);
while (lan9118_mac_readreg(sc, LAN9118_MII_ACC) &
LAN9118_MII_ACC_MIIBZY);
*val = lan9118_mac_readreg(sc, LAN9118_MII_DATA) & 0xffff;
return 0;
}

static int
lan9118_mii_writereg(struct lan9118_softc *sc, int phy, int reg, uint16_t val)
{
uint32_t acc;

while (lan9118_mac_readreg(sc, LAN9118_MII_ACC) &
LAN9118_MII_ACC_MIIBZY);
acc = LAN9118_MII_ACC_PHYA(phy) | LAN9118_MII_ACC_MIIRINDA(reg) |
LAN9118_MII_ACC_MIIWNR;
lan9118_mac_writereg(sc, LAN9118_MII_DATA, val);
lan9118_mac_writereg(sc, LAN9118_MII_ACC, acc);
while (lan9118_mac_readreg(sc, LAN9118_MII_ACC) &
LAN9118_MII_ACC_MIIBZY);

return 0;
}

static uint32_t
lan9118_mac_readreg(struct lan9118_softc *sc, int reg)
{
uint32_t cmd;
int timo = 3 * 1000 * 1000; /* XXXX: 3sec */

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_MAC_CSR_CMD,
LAN9118_MAC_CSR_CMD_BUSY | LAN9118_MAC_CSR_CMD_R | reg);
do {
cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_MAC_CSR_CMD);
if (!(cmd & LAN9118_MAC_CSR_CMD_BUSY))
break;
delay(100);
} while (timo -= 100);
if (timo <= 0)
aprint_error_dev(sc->sc_dev, "%s: command busy\n", __func__);
return bus_space_read_4(sc->sc_iot, sc->sc_ioh, LAN9118_MAC_CSR_DATA);
}

static void
lan9118_mac_writereg(struct lan9118_softc *sc, int reg, uint32_t val)
{
uint32_t cmd;
int timo = 3 * 1000 * 1000; /* XXXX: 3sec */

bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_MAC_CSR_DATA, val);
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_MAC_CSR_CMD,
LAN9118_MAC_CSR_CMD_BUSY | LAN9118_MAC_CSR_CMD_W | reg);
do {
cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_MAC_CSR_CMD);
if (!(cmd & LAN9118_MAC_CSR_CMD_BUSY))
break;
delay(100);
} while (timo -= 100);
if (timo <= 0)
aprint_error_dev(sc->sc_dev, "%s: command busy\n", __func__);
}

static void
lan9118_set_filter(struct lan9118_softc *sc)
{
struct ethercom *ec = &sc->sc_ec;
struct ether_multistep step;
struct ether_multi *enm;
struct ifnet *ifp = &ec->ec_if;
uint32_t mac_cr, h, hashes[2] = { 0, 0 };

mac_cr = lan9118_mac_readreg(sc, LAN9118_MAC_CR);
if (ifp->if_flags & IFF_PROMISC) {
lan9118_mac_writereg(sc, LAN9118_MAC_CR,
mac_cr | LAN9118_MAC_CR_PRMS);
return;
}

mac_cr &= ~(LAN9118_MAC_CR_PRMS | LAN9118_MAC_CR_MCPAS |
LAN9118_MAC_CR_BCAST | LAN9118_MAC_CR_HPFILT);
if (!(ifp->if_flags & IFF_BROADCAST))
mac_cr |= LAN9118_MAC_CR_BCAST;

if (ifp->if_flags & IFF_ALLMULTI)
mac_cr |= LAN9118_MAC_CR_MCPAS;
else {
ETHER_LOCK(ec);
ETHER_FIRST_MULTI(step, ec, enm);
while (enm != NULL) {
if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
ETHER_ADDR_LEN) != 0) {
/*
* 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.)
*/
ifp->if_flags |= IFF_ALLMULTI;
mac_cr |= LAN9118_MAC_CR_MCPAS;
break;
}
h = ether_crc32_le(enm->enm_addrlo,
ETHER_ADDR_LEN) >> 26;
hashes[h >> 5] |= 1 << (h & 0x1f);

mac_cr |= LAN9118_MAC_CR_HPFILT;
ETHER_NEXT_MULTI(step, enm);
}
ETHER_UNLOCK(ec);
if (mac_cr & LAN9118_MAC_CR_HPFILT) {
lan9118_mac_writereg(sc, LAN9118_HASHH, hashes[1]);
lan9118_mac_writereg(sc, LAN9118_HASHL, hashes[0]);
}
}
lan9118_mac_writereg(sc, LAN9118_MAC_CR, mac_cr);
return;
}

static void
lan9118_rxintr(struct lan9118_softc *sc)
{
struct ifnet *ifp = &sc->sc_ec.ec_if;
struct mbuf *m;
uint32_t rx_fifo_inf, rx_status;
int pktlen;
const int pad = ETHER_HDR_LEN % sizeof(uint32_t);

DPRINTFN(3, ("%s\n", __func__));

for (;;) {
rx_fifo_inf = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_RX_FIFO_INF);
if (LAN9118_RX_FIFO_INF_RXSUSED(rx_fifo_inf) == 0)
break;

rx_status = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_RXSFIFOP);
pktlen = LAN9118_RXS_PKTLEN(rx_status);
DPRINTFN(3, ("%s: rx_status=0x%x(pktlen %d)\n",
__func__, rx_status, pktlen));
if (rx_status & (LAN9118_RXS_ES | LAN9118_RXS_LENERR |
LAN9118_RXS_RWTO | LAN9118_RXS_MIIERR | LAN9118_RXS_DBIT)) {
if (rx_status & LAN9118_RXS_LENERR)
aprint_error_dev(sc->sc_dev, "Length Error\n");
if (rx_status & LAN9118_RXS_RUNTF)
aprint_error_dev(sc->sc_dev, "Runt Frame\n");
if (rx_status & LAN9118_RXS_FTL)
aprint_error_dev(sc->sc_dev,
"Frame Too Long\n");
if (rx_status & LAN9118_RXS_RWTO)
aprint_error_dev(sc->sc_dev,
"Receive Watchdog time-out\n");
if (rx_status & LAN9118_RXS_MIIERR)
aprint_error_dev(sc->sc_dev, "MII Error\n");
if (rx_status & LAN9118_RXS_DBIT)
aprint_error_dev(sc->sc_dev, "Drabbling Bit\n");
if (rx_status & LAN9118_RXS_COLS)
aprint_error_dev(sc->sc_dev,
"Collision Seen\n");
if (rx_status & LAN9118_RXS_CRCERR)
aprint_error_dev(sc->sc_dev, "CRC Error\n");

dropit:
if_statinc(ifp, if_ierrors);
/*
* Receive Data FIFO Fast Forward
* When performing a fast-forward, there must be at
* least 4 DWORDs of data in the RX data FIFO for the
* packet being discarded.
*/
if (pktlen >= 4 * sizeof(uint32_t)) {
uint32_t rx_dp_ctl;

bus_space_write_4(sc->sc_iot, sc->sc_ioh,
LAN9118_RX_DP_CTL,
LAN9118_RX_DP_CTL_RX_FFWD);
/* DP_FFWD bit is self clearing */
do {
rx_dp_ctl = bus_space_read_4(sc->sc_iot,
sc->sc_ioh, LAN9118_RX_DP_CTL);
} while (rx_dp_ctl & LAN9118_RX_DP_CTL_RX_FFWD);
} else {
/* For less than 4 DWORDs do not use RX_FFWD. */
uint32_t garbage[4];

bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh,
LAN9118_RXDFIFOP, garbage,
roundup(pktlen, 4) >> 2);
}
continue;
}

MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
goto dropit;
if (pktlen > (MHLEN - pad)) {
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);
goto dropit;
}
}

/* STRICT_ALIGNMENT */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, LAN9118_RX_CFG,
LAN9118_RX_CFG_RXEA_4B | LAN9118_RX_CFG_RXDOFF(pad));
bus_space_read_multi_4(sc->sc_iot, sc->sc_ioh, LAN9118_RXDFIFOP,
mtod(m, uint32_t *),
roundup(pad + pktlen, sizeof(uint32_t)) >> 2);
m->m_data += pad;

m_set_rcvif(m, ifp);
m->m_pkthdr.len = m->m_len = (pktlen - ETHER_CRC_LEN);

/* Pass it on. */
if_percpuq_enqueue(ifp->if_percpuq, m);
}
}

static void
lan9118_txintr(struct lan9118_softc *sc)
{
struct ifnet *ifp = &sc->sc_ec.ec_if;
uint32_t tx_fifo_inf, tx_status;
int fdx = IFM_OPTIONS(sc->sc_mii.mii_media_active) & IFM_FDX;
int tdfree;

DPRINTFN(3, ("%s\n", __func__));

for (;;) {
tx_fifo_inf = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TX_FIFO_INF);
if (LAN9118_TX_FIFO_INF_TXSUSED(tx_fifo_inf) == 0)
break;

tx_status = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
LAN9118_TXSFIFOP);
DPRINTFN(3, ("%s: tx_status=0x%x\n", __func__, tx_status));
if (tx_status & LAN9118_TXS_ES) {
if (tx_status & LAN9118_TXS_LOC)
aprint_error_dev(sc->sc_dev,
"Loss Of Carrier\n");
if ((tx_status & LAN9118_TXS_NC) && !fdx)
aprint_error_dev(sc->sc_dev, "No Carrier\n");
if (tx_status & LAN9118_TXS_LCOL)
aprint_error_dev(sc->sc_dev,
"Late Collision\n");
if (tx_status & LAN9118_TXS_ECOL) {
/* Rearch 16 collision */
if_statadd(ifp, if_collisions, 16);
aprint_error_dev(sc->sc_dev,
"Excessive Collision\n");
}
if (LAN9118_TXS_COLCNT(tx_status) != 0)
aprint_error_dev(sc->sc_dev,
"Collision Count: %d\n",
LAN9118_TXS_COLCNT(tx_status));
if (tx_status & LAN9118_TXS_ED)
aprint_error_dev(sc->sc_dev,
"Excessive Deferral\n");
if (tx_status & LAN9118_TXS_DEFERRED)
aprint_error_dev(sc->sc_dev, "Deferred\n");
if_statinc(ifp, if_oerrors);
} else
if_statinc(ifp, if_opackets);
}

tdfree = LAN9118_TX_FIFO_INF_TDFREE(tx_fifo_inf);
if (tdfree == LAN9118_TX_DATA_FIFO_SIZE)
/* FIFO empty */
ifp->if_timer = 0;
if (tdfree >= 2036)
/*
* 2036 is the possible maximum FIFO consumption
* for the most fragmented frame.
*/
ifp->if_flags &= ~IFF_OACTIVE;
}

void
lan9118_tick(void *v)
{
struct lan9118_softc *sc = v;
int s;

s = splnet();
mii_tick(&sc->sc_mii);
callout_schedule(&sc->sc_tick, hz);
splx(s);
}