* Copyright (c) 1999 Ludd, University of Lule}, Sweden. All rights reserved.

/* $NetBSD: sgec.c,v 1.53 2020/03/15 22:19:00 thorpej Exp $ */
/*
* Copyright (c) 1999 Ludd, University of Lule}, Sweden. 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.
*/

/*
* Driver for the SGEC (Second Generation Ethernet Controller), sitting
* on for example the VAX 4000/300 (KA670).
*
* The SGEC looks like a mixture of the DEQNA and the TULIP. Fun toy.
*
* Even though the chip is capable to use virtual addresses (read the
* System Page Table directly) this driver doesn't do so, and there
* is no benefit in doing it either in NetBSD of today.
*
* Things that is still to do:
* Collect statistics.
* Use imperfect filtering when many multicast addresses.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sgec.c,v 1.53 2020/03/15 22:19:00 thorpej Exp $");

#include "opt_inet.h"

#include <sys/param.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/device.h>
#include <sys/systm.h>
#include <sys/sockio.h>

#include <net/if.h>
#include <net/if_ether.h>
#include <net/if_dl.h>
#include <net/bpf.h>

#include <netinet/in.h>
#include <netinet/if_inarp.h>

#include <sys/bus.h>

#include <dev/ic/sgecreg.h>
#include <dev/ic/sgecvar.h>

static void zeinit(struct ze_softc *);
static void zestart(struct ifnet *);
static int zeioctl(struct ifnet *, u_long, void *);
static int ze_add_rxbuf(struct ze_softc *, int);
static void ze_setup(struct ze_softc *);
static void zetimeout(struct ifnet *);
static bool zereset(struct ze_softc *);

#define ZE_WCSR(csr, val) \
bus_space_write_4(sc->sc_iot, sc->sc_ioh, csr, val)
#define ZE_RCSR(csr) \
bus_space_read_4(sc->sc_iot, sc->sc_ioh, csr)

/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets.
*/
void
sgec_attach(struct ze_softc *sc)
{
struct ifnet *ifp = &sc->sc_if;
struct ze_tdes *tp;
struct ze_rdes *rp;
bus_dma_segment_t seg;
int i, rseg, error;

/*
* Allocate DMA safe memory for descriptors and setup memory.
*/
error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct ze_cdata),
PAGE_SIZE, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
if (error) {
aprint_error(": unable to allocate control data, error = %d\n",
error);
goto fail_0;
}

error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, sizeof(struct ze_cdata),
(void **)&sc->sc_zedata, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
if (error) {
aprint_error(
": unable to map control data, error = %d\n", error);
goto fail_1;
}

error = bus_dmamap_create(sc->sc_dmat, sizeof(struct ze_cdata), 1,
sizeof(struct ze_cdata), 0, BUS_DMA_NOWAIT, &sc->sc_cmap);
if (error) {
aprint_error(
": unable to create control data DMA map, error = %d\n",
error);
goto fail_2;
}

error = bus_dmamap_load(sc->sc_dmat, sc->sc_cmap, sc->sc_zedata,
sizeof(struct ze_cdata), NULL, BUS_DMA_NOWAIT);
if (error) {
aprint_error(
": unable to load control data DMA map, error = %d\n",
error);
goto fail_3;
}

/*
* Zero the newly allocated memory.
*/
memset(sc->sc_zedata, 0, sizeof(struct ze_cdata));

/*
* Create the transmit descriptor DMA maps.
*/
for (i = 0; error == 0 && i < TXDESCS; i++) {
error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, TXDESCS - 1,
MCLBYTES, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
&sc->sc_xmtmap[i]);
}
if (error) {
aprint_error(": unable to create tx DMA map %d, error = %d\n",
i, error);
goto fail_4;
}

/*
* Create receive buffer DMA maps.
*/
for (i = 0; error == 0 && i < RXDESCS; i++) {
error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
MCLBYTES, 0, BUS_DMA_NOWAIT, &sc->sc_rcvmap[i]);
}
if (error) {
aprint_error(": unable to create rx DMA map %d, error = %d\n",
i, error);
goto fail_5;
}

/*
* Pre-allocate the receive buffers.
*/
for (i = 0; error == 0 && i < RXDESCS; i++) {
error = ze_add_rxbuf(sc, i);
}

if (error) {
aprint_error(
": unable to allocate or map rx buffer %d, error = %d\n",
i, error);
goto fail_6;
}

/* For vmstat -i
*/
evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
device_xname(sc->sc_dev), "intr");
evcnt_attach_dynamic(&sc->sc_rxintrcnt, EVCNT_TYPE_INTR,
&sc->sc_intrcnt, device_xname(sc->sc_dev), "rx intr");
evcnt_attach_dynamic(&sc->sc_txintrcnt, EVCNT_TYPE_INTR,
&sc->sc_intrcnt, device_xname(sc->sc_dev), "tx intr");
evcnt_attach_dynamic(&sc->sc_txdraincnt, EVCNT_TYPE_INTR,
&sc->sc_intrcnt, device_xname(sc->sc_dev), "tx drain");
evcnt_attach_dynamic(&sc->sc_nobufintrcnt, EVCNT_TYPE_INTR,
&sc->sc_intrcnt, device_xname(sc->sc_dev), "nobuf intr");
evcnt_attach_dynamic(&sc->sc_nointrcnt, EVCNT_TYPE_INTR,
&sc->sc_intrcnt, device_xname(sc->sc_dev), "no intr");

/*
* Create ring loops of the buffer chains.
* This is only done once.
*/
sc->sc_pzedata = (struct ze_cdata *)sc->sc_cmap->dm_segs[0].ds_addr;

rp = sc->sc_zedata->zc_recv;
rp[RXDESCS].ze_framelen = ZE_FRAMELEN_OW;
rp[RXDESCS].ze_rdes1 = ZE_RDES1_CA;
rp[RXDESCS].ze_bufaddr = (char *)sc->sc_pzedata->zc_recv;

tp = sc->sc_zedata->zc_xmit;
tp[TXDESCS].ze_tdr = ZE_TDR_OW;
tp[TXDESCS].ze_tdes1 = ZE_TDES1_CA;
tp[TXDESCS].ze_bufaddr = (char *)sc->sc_pzedata->zc_xmit;

if (zereset(sc))
return;

strcpy(ifp->if_xname, device_xname(sc->sc_dev));
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_start = zestart;
ifp->if_ioctl = zeioctl;
ifp->if_watchdog = zetimeout;
IFQ_SET_READY(&ifp->if_snd);

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

aprint_normal("\n");
aprint_normal_dev(sc->sc_dev, "hardware address %s\n",
ether_sprintf(sc->sc_enaddr));
return;

/*
* Free any resources we've allocated during the failed attach
* attempt. Do this in reverse order and fall through.
*/
fail_6:
for (i = 0; i < RXDESCS; i++) {
if (sc->sc_rxmbuf[i] != NULL) {
bus_dmamap_unload(sc->sc_dmat, sc->sc_rcvmap[i]);
m_freem(sc->sc_rxmbuf[i]);
}
}
fail_5:
for (i = 0; i < TXDESCS; i++) {
if (sc->sc_xmtmap[i] != NULL)
bus_dmamap_destroy(sc->sc_dmat, sc->sc_xmtmap[i]);
}
fail_4:
for (i = 0; i < RXDESCS; i++) {
if (sc->sc_rcvmap[i] != NULL)
bus_dmamap_destroy(sc->sc_dmat, sc->sc_rcvmap[i]);
}
bus_dmamap_unload(sc->sc_dmat, sc->sc_cmap);
fail_3:
bus_dmamap_destroy(sc->sc_dmat, sc->sc_cmap);
fail_2:
bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_zedata,
sizeof(struct ze_cdata));
fail_1:
bus_dmamem_free(sc->sc_dmat, &seg, rseg);
fail_0:
return;
}

/*
* Initialization of interface.
*/
void
zeinit(struct ze_softc *sc)
{
struct ifnet *ifp = &sc->sc_if;
struct ze_cdata *zc = sc->sc_zedata;
int i;

/*
* Reset the interface.
*/
if (zereset(sc))
return;

sc->sc_nexttx = sc->sc_inq = sc->sc_lastack = sc->sc_txcnt = 0;
/*
* Release and init transmit descriptors.
*/
for (i = 0; i < TXDESCS; i++) {
if (sc->sc_xmtmap[i]->dm_nsegs > 0)
bus_dmamap_unload(sc->sc_dmat, sc->sc_xmtmap[i]);
if (sc->sc_txmbuf[i]) {
m_freem(sc->sc_txmbuf[i]);
sc->sc_txmbuf[i] = 0;
}
zc->zc_xmit[i].ze_tdr = 0; /* Clear valid bit */
}

/*
* Init receive descriptors.
*/
for (i = 0; i < RXDESCS; i++)
zc->zc_recv[i].ze_framelen = ZE_FRAMELEN_OW;
sc->sc_nextrx = 0;

ZE_WCSR(ZE_CSR6, ZE_NICSR6_IE | ZE_NICSR6_BL_8 | ZE_NICSR6_ST |
ZE_NICSR6_SR | ZE_NICSR6_DC);

ifp->if_flags |= IFF_RUNNING;

/*
* Send a setup frame.
* This will start the transmit machinery as well.
*/
ze_setup(sc);

}

/*
* Start output on interface.
*/
void
zestart(struct ifnet *ifp)
{
struct ze_softc *sc = ifp->if_softc;
struct ze_cdata *zc = sc->sc_zedata;
paddr_t buffer;
struct mbuf *m;
int nexttx, starttx;
int len, i, totlen, error;
int old_inq = sc->sc_inq;
uint16_t orword, tdr = 0;
bus_dmamap_t map;

while (sc->sc_inq < (TXDESCS - 1)) {

if (sc->sc_setup) {
ze_setup(sc);
continue;
}
nexttx = sc->sc_nexttx;
IFQ_POLL(&sc->sc_if.if_snd, m);
if (m == 0)
goto out;
/*
* Count number of mbufs in chain.
* Always do DMA directly from mbufs, therefore the transmit
* ring is really big.
*/
map = sc->sc_xmtmap[nexttx];
error = bus_dmamap_load_mbuf(sc->sc_dmat, map, m,
BUS_DMA_WRITE);
if (error) {
aprint_error_dev(sc->sc_dev,
"zestart: load_mbuf failed: %d", error);
goto out;
}

if (map->dm_nsegs >= TXDESCS)
panic("zestart"); /* XXX */

if ((map->dm_nsegs + sc->sc_inq) >= (TXDESCS - 1)) {
bus_dmamap_unload(sc->sc_dmat, map);
goto out;
}

/*
* m now points to a mbuf chain that can be loaded.
* Loop around and set it.
*/
totlen = 0;
orword = ZE_TDES1_FS;
starttx = nexttx;
for (i = 0; i < map->dm_nsegs; i++) {
buffer = map->dm_segs[i].ds_addr;
len = map->dm_segs[i].ds_len;

KASSERT(len > 0);

totlen += len;
/* Word alignment calc */
if (totlen == m->m_pkthdr.len) {
sc->sc_txcnt += map->dm_nsegs;
if (sc->sc_txcnt >= TXDESCS * 3 / 4) {
orword |= ZE_TDES1_IC;
sc->sc_txcnt = 0;
}
orword |= ZE_TDES1_LS;
sc->sc_txmbuf[nexttx] = m;
}
zc->zc_xmit[nexttx].ze_bufsize = len;
zc->zc_xmit[nexttx].ze_bufaddr = (char *)buffer;
zc->zc_xmit[nexttx].ze_tdes1 = orword;
zc->zc_xmit[nexttx].ze_tdr = tdr;

if (++nexttx == TXDESCS)
nexttx = 0;
orword = 0;
tdr = ZE_TDR_OW;
}

sc->sc_inq += map->dm_nsegs;

IFQ_DEQUEUE(&ifp->if_snd, m);
#ifdef DIAGNOSTIC
if (totlen != m->m_pkthdr.len)
panic("zestart: len fault");
#endif
/*
* Turn ownership of the packet over to the device.
*/
zc->zc_xmit[starttx].ze_tdr = ZE_TDR_OW;

/*
* Kick off the transmit logic, if it is stopped.
*/
if ((ZE_RCSR(ZE_CSR5) & ZE_NICSR5_TS) != ZE_NICSR5_TS_RUN)
ZE_WCSR(ZE_CSR1, -1);
sc->sc_nexttx = nexttx;

bpf_mtap(ifp, m, BPF_D_OUT);
}

out: if (old_inq < sc->sc_inq)
ifp->if_timer = 5; /* If transmit logic dies */
}

int
sgec_intr(struct ze_softc *sc)
{
struct ze_cdata *zc = sc->sc_zedata;
struct ifnet *ifp = &sc->sc_if;
struct mbuf *m;
int csr, len;

csr = ZE_RCSR(ZE_CSR5);
if ((csr & ZE_NICSR5_IS) == 0) { /* Wasn't we */
sc->sc_nointrcnt.ev_count++;
return 0;
}
ZE_WCSR(ZE_CSR5, csr);

if (csr & ZE_NICSR5_RU)
sc->sc_nobufintrcnt.ev_count++;

if (csr & ZE_NICSR5_RI) {
sc->sc_rxintrcnt.ev_count++;
while ((zc->zc_recv[sc->sc_nextrx].ze_framelen &
ZE_FRAMELEN_OW) == 0) {

m = sc->sc_rxmbuf[sc->sc_nextrx];
len = zc->zc_recv[sc->sc_nextrx].ze_framelen;
ze_add_rxbuf(sc, sc->sc_nextrx);
if (++sc->sc_nextrx == RXDESCS)
sc->sc_nextrx = 0;
if (len < ETHER_MIN_LEN) {
if_statinc(ifp, if_ierrors);
m_freem(m);
} else {
m_set_rcvif(m, ifp);
m->m_pkthdr.len = m->m_len =
len - ETHER_CRC_LEN;
if_percpuq_enqueue(ifp->if_percpuq, m);
}
}
}

if (csr & ZE_NICSR5_TI)
sc->sc_txintrcnt.ev_count++;
if (sc->sc_lastack != sc->sc_nexttx) {
int lastack;
for (lastack = sc->sc_lastack; lastack != sc->sc_nexttx; ) {
bus_dmamap_t map;
int nlastack;

if ((zc->zc_xmit[lastack].ze_tdr & ZE_TDR_OW) != 0)
break;

if ((zc->zc_xmit[lastack].ze_tdes1 & ZE_TDES1_DT) ==
ZE_TDES1_DT_SETUP) {
if (++lastack == TXDESCS)
lastack = 0;
sc->sc_inq--;
continue;
}

KASSERT(zc->zc_xmit[lastack].ze_tdes1 & ZE_TDES1_FS);
map = sc->sc_xmtmap[lastack];
KASSERT(map->dm_nsegs > 0);
nlastack = (lastack + map->dm_nsegs - 1) % TXDESCS;
if (zc->zc_xmit[nlastack].ze_tdr & ZE_TDR_OW)
break;
lastack = nlastack;
if (sc->sc_txcnt > map->dm_nsegs)
sc->sc_txcnt -= map->dm_nsegs;
else
sc->sc_txcnt = 0;
sc->sc_inq -= map->dm_nsegs;
KASSERT(zc->zc_xmit[lastack].ze_tdes1 & ZE_TDES1_LS);
if_statinc(ifp, if_opackets);
bus_dmamap_unload(sc->sc_dmat, map);
KASSERT(sc->sc_txmbuf[lastack]);
m_freem(sc->sc_txmbuf[lastack]);
sc->sc_txmbuf[lastack] = 0;
if (++lastack == TXDESCS)
lastack = 0;
}
if (lastack != sc->sc_lastack) {
sc->sc_txdraincnt.ev_count++;
sc->sc_lastack = lastack;
if (sc->sc_inq == 0)
ifp->if_timer = 0;
zestart(ifp); /* Put in more in queue */
}
}
return 1;
}

/*
* Process an ioctl request.
*/
int
zeioctl(struct ifnet *ifp, u_long cmd, void *data)
{
struct ze_softc *sc = ifp->if_softc;
struct ifaddr *ifa = data;
int s = splnet(), error = 0;

switch (cmd) {

case SIOCINITIFADDR:
ifp->if_flags |= IFF_UP;
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
zeinit(sc);
arp_ifinit(ifp, ifa);
break;
#endif
}
break;

case SIOCSIFFLAGS:
if ((error = ifioctl_common(ifp, cmd, data)) != 0)
break;
/* XXX re-use ether_ioctl() */
switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
case IFF_RUNNING:
/*
* If interface is marked down and it is running,
* stop it. (by disabling receive mechanism).
*/
ZE_WCSR(ZE_CSR6, ZE_RCSR(ZE_CSR6) &
~(ZE_NICSR6_ST | ZE_NICSR6_SR));
ifp->if_flags &= ~IFF_RUNNING;
break;
case IFF_UP:
/*
* If interface it marked up and it is stopped, then
* start it.
*/
zeinit(sc);
break;
case IFF_UP | IFF_RUNNING:
/*
* Send a new setup packet to match any new changes.
* (Like IFF_PROMISC etc)
*/
ze_setup(sc);
break;
case 0:
break;
}
break;

case SIOCADDMULTI:
case SIOCDELMULTI:
/*
* Update our multicast list.
*/
if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
/*
* Multicast list has changed; set the hardware filter
* accordingly.
*/
if (ifp->if_flags & IFF_RUNNING)
ze_setup(sc);
error = 0;
}
break;

default:
error = ether_ioctl(ifp, cmd, data);

}
splx(s);
return error;
}

/*
* Add a receive buffer to the indicated descriptor.
*/
int
ze_add_rxbuf(struct ze_softc *sc, int i)
{
struct mbuf *m;
struct ze_rdes *rp;
int error;

MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
return ENOBUFS;

MCLAIM(m, &sc->sc_ec.ec_rx_mowner);
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);
return ENOBUFS;
}

if (sc->sc_rxmbuf[i] != NULL)
bus_dmamap_unload(sc->sc_dmat, sc->sc_rcvmap[i]);

error = bus_dmamap_load(sc->sc_dmat, sc->sc_rcvmap[i],
m->m_ext.ext_buf, m->m_ext.ext_size, NULL,
BUS_DMA_READ | BUS_DMA_NOWAIT);
if (error)
panic("%s: can't load rx DMA map %d, error = %d",
device_xname(sc->sc_dev), i, error);
sc->sc_rxmbuf[i] = m;

bus_dmamap_sync(sc->sc_dmat, sc->sc_rcvmap[i], 0,
sc->sc_rcvmap[i]->dm_mapsize, BUS_DMASYNC_PREREAD);

/*
* We know that the mbuf cluster is page aligned. Also, be sure
* that the IP header will be longword aligned.
*/
m->m_data += 2;
rp = &sc->sc_zedata->zc_recv[i];
rp->ze_bufsize = (m->m_ext.ext_size - 2);
rp->ze_bufaddr = (char *)sc->sc_rcvmap[i]->dm_segs[0].ds_addr + 2;
rp->ze_framelen = ZE_FRAMELEN_OW;

return 0;
}

/*
* Create a setup packet and put in queue for sending.
*/
void
ze_setup(struct ze_softc *sc)
{
struct ethercom *ec = &sc->sc_ec;
struct ether_multi *enm;
struct ether_multistep step;
struct ze_cdata *zc = sc->sc_zedata;
struct ifnet *ifp = &sc->sc_if;
const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
int j, idx, reg;

if (sc->sc_inq == (TXDESCS - 1)) {
sc->sc_setup = 1;
return;
}
sc->sc_setup = 0;
/*
* Init the setup packet with valid info.
*/
memset(zc->zc_setup, 0xff, sizeof(zc->zc_setup)); /* Broadcast */
memcpy(zc->zc_setup, enaddr, ETHER_ADDR_LEN);

/*
* Multicast handling. The SGEC can handle up to 16 direct
* ethernet addresses.
*/
j = 16;
ifp->if_flags &= ~IFF_ALLMULTI;
ETHER_LOCK(ec);
ETHER_FIRST_MULTI(step, ec, enm);
while (enm != NULL) {
if (memcmp(enm->enm_addrlo, enm->enm_addrhi, 6)) {
ifp->if_flags |= IFF_ALLMULTI;
break;
}
memcpy(&zc->zc_setup[j], enm->enm_addrlo, ETHER_ADDR_LEN);
j += 8;
ETHER_NEXT_MULTI(step, enm);
if ((enm != NULL)&& (j == 128)) {
ifp->if_flags |= IFF_ALLMULTI;
break;
}
}
ETHER_UNLOCK(ec);

/*
* ALLMULTI implies PROMISC in this driver.
*/
if (ifp->if_flags & IFF_ALLMULTI)
ifp->if_flags |= IFF_PROMISC;
else if (ifp->if_pcount == 0)
ifp->if_flags &= ~IFF_PROMISC;

/*
* Fiddle with the receive logic.
*/
reg = ZE_RCSR(ZE_CSR6);
DELAY(10);
ZE_WCSR(ZE_CSR6, reg & ~ZE_NICSR6_SR); /* Stop rx */
reg &= ~ZE_NICSR6_AF;
if (ifp->if_flags & IFF_PROMISC)
reg |= ZE_NICSR6_AF_PROM;
else if (ifp->if_flags & IFF_ALLMULTI)
reg |= ZE_NICSR6_AF_ALLM;
DELAY(10);
ZE_WCSR(ZE_CSR6, reg);
/*
* Only send a setup packet if needed.
*/
if ((ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI)) == 0) {
idx = sc->sc_nexttx;
zc->zc_xmit[idx].ze_tdes1 = ZE_TDES1_DT_SETUP;
zc->zc_xmit[idx].ze_bufsize = 128;
zc->zc_xmit[idx].ze_bufaddr = sc->sc_pzedata->zc_setup;
zc->zc_xmit[idx].ze_tdr = ZE_TDR_OW;

if ((ZE_RCSR(ZE_CSR5) & ZE_NICSR5_TS) != ZE_NICSR5_TS_RUN)
ZE_WCSR(ZE_CSR1, -1);

sc->sc_inq++;
if (++sc->sc_nexttx == TXDESCS)
sc->sc_nexttx = 0;
}
}

/*
* Check for dead transmit logic.
*/
void
zetimeout(struct ifnet *ifp)
{
struct ze_softc *sc = ifp->if_softc;

if (sc->sc_inq == 0)
return;

aprint_error_dev(sc->sc_dev, "xmit logic died, resetting...\n");
/*
* Do a reset of interface, to get it going again.
* Will it work by just restart the transmit logic?
*/
zeinit(sc);
}

/*
* Reset chip:
* Set/reset the reset flag.
* Write interrupt vector.
* Write ring buffer addresses.
* Write SBR.
*/
bool
zereset(struct ze_softc *sc)
{
int reg, i;

ZE_WCSR(ZE_CSR6, ZE_NICSR6_RE);
DELAY(50000);
if (ZE_RCSR(ZE_CSR6) & ZE_NICSR5_SF) {
aprint_error_dev(sc->sc_dev, "selftest failed\n");
return true;
}

/*
* Get the vector that were set at match time, and remember it.
* WHICH VECTOR TO USE? Take one unused. XXX
* Funny way to set vector described in the programmers manual.
*/
reg = ZE_NICSR0_IPL14 | sc->sc_intvec | 0x1fff0003; /* SYNC/ASYNC??? */
i = 10;
do {
if (i-- == 0) {
aprint_error_dev(sc->sc_dev,
"failing SGEC CSR0 init\n");
return true;
}
ZE_WCSR(ZE_CSR0, reg);
} while (ZE_RCSR(ZE_CSR0) != reg);

ZE_WCSR(ZE_CSR3, (vaddr_t)sc->sc_pzedata->zc_recv);
ZE_WCSR(ZE_CSR4, (vaddr_t)sc->sc_pzedata->zc_xmit);
return false;
}