* Copyright (c) 1998 Darrin B. Jewell

/* $NetBSD: if_xe.c,v 1.29 2024/07/05 04:31:49 rin Exp $ */
/*
* Copyright (c) 1998 Darrin B. Jewell
* 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: if_xe.c,v 1.29 2024/07/05 04:31:49 rin Exp $");

#include "opt_inet.h"

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

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

#ifdef INET
#include <netinet/in.h>
#include <netinet/if_inarp.h>
#endif

#include <machine/autoconf.h>
#include <machine/cpu.h>
#include <machine/intr.h>
#include <machine/bus.h>

#include <next68k/next68k/isr.h>

#include <next68k/dev/mb8795reg.h>
#include <next68k/dev/mb8795var.h>

#include <next68k/dev/bmapreg.h>
#include <next68k/dev/intiovar.h>
#include <next68k/dev/nextdmareg.h>
#include <next68k/dev/nextdmavar.h>

#include <next68k/dev/if_xevar.h>
#include <next68k/dev/if_xereg.h>

#ifdef DEBUG
#define XE_DEBUG
#endif

#ifdef XE_DEBUG
int xe_debug = 0;
#define DPRINTF(x) if (xe_debug) printf x;
#else
#define DPRINTF(x)
#endif
#define PRINTF(x) printf x;

extern int turbo;

int xe_match(device_t, cfdata_t, void *);
void xe_attach(device_t, device_t, void *);
int xe_tint(void *);
int xe_rint(void *);

struct mbuf *xe_dma_rxmap_load(struct mb8795_softc *, bus_dmamap_t);

bus_dmamap_t xe_dma_rx_continue(void *);
void xe_dma_rx_completed(bus_dmamap_t, void *);
bus_dmamap_t xe_dma_tx_continue(void *);
void xe_dma_tx_completed(bus_dmamap_t, void *);
void xe_dma_rx_shutdown(void *);
void xe_dma_tx_shutdown(void *);

static void findchannel_defer(device_t);

CFATTACH_DECL_NEW(xe, sizeof(struct xe_softc),
xe_match, xe_attach, NULL, NULL);

static int xe_dma_medias[] = {
IFM_ETHER | IFM_AUTO,
IFM_ETHER | IFM_10_T,
IFM_ETHER | IFM_10_2,
};
static int nxe_dma_medias = __arraycount(xe_dma_medias);

static int attached = 0;

/*
* Functions and the switch for the MI code.
*/
u_char xe_read_reg(struct mb8795_softc *, int);
void xe_write_reg(struct mb8795_softc *, int, u_char);
void xe_dma_reset(struct mb8795_softc *);
void xe_dma_rx_setup(struct mb8795_softc *);
void xe_dma_rx_go(struct mb8795_softc *);
struct mbuf * xe_dma_rx_mbuf(struct mb8795_softc *);
void xe_dma_tx_setup(struct mb8795_softc *);
void xe_dma_tx_go(struct mb8795_softc *);
int xe_dma_tx_mbuf(struct mb8795_softc *, struct mbuf *);
int xe_dma_tx_isactive(struct mb8795_softc *);

struct mb8795_glue xe_glue = {
xe_read_reg,
xe_write_reg,
xe_dma_reset,
xe_dma_rx_setup,
xe_dma_rx_go,
xe_dma_rx_mbuf,
xe_dma_tx_setup,
xe_dma_tx_go,
xe_dma_tx_mbuf,
xe_dma_tx_isactive,
};

int
xe_match(device_t parent, cfdata_t match, void *aux)
{
struct intio_attach_args *ia = (struct intio_attach_args *)aux;

if (attached)
return 0;

ia->ia_addr = (void *)NEXT_P_ENET;

return 1;
}

static void
findchannel_defer(device_t self)
{
struct xe_softc *xsc = device_private(self);
struct mb8795_softc *sc = &xsc->sc_mb8795;
int i, error;

if (!xsc->sc_txdma) {
xsc->sc_txdma = nextdma_findchannel ("enetx");
if (xsc->sc_txdma == NULL)
panic("%s: can't find enetx DMA channel",
device_xname(sc->sc_dev));
}
if (!xsc->sc_rxdma) {
xsc->sc_rxdma = nextdma_findchannel ("enetr");
if (xsc->sc_rxdma == NULL)
panic ("%s: can't find enetr DMA channel",
device_xname(sc->sc_dev));
}
aprint_normal_dev(sc->sc_dev, "using DMA channels %s %s\n",
device_xname(xsc->sc_txdma->sc_dev),
device_xname(xsc->sc_rxdma->sc_dev));

nextdma_setconf (xsc->sc_rxdma, continue_cb, xe_dma_rx_continue);
nextdma_setconf (xsc->sc_rxdma, completed_cb, xe_dma_rx_completed);
nextdma_setconf (xsc->sc_rxdma, shutdown_cb, xe_dma_rx_shutdown);
nextdma_setconf (xsc->sc_rxdma, cb_arg, sc);

nextdma_setconf (xsc->sc_txdma, continue_cb, xe_dma_tx_continue);
nextdma_setconf (xsc->sc_txdma, completed_cb, xe_dma_tx_completed);
nextdma_setconf (xsc->sc_txdma, shutdown_cb, xe_dma_tx_shutdown);
nextdma_setconf (xsc->sc_txdma, cb_arg, sc);

/* Initialize the DMA maps */
error = bus_dmamap_create(xsc->sc_txdma->sc_dmat, MCLBYTES,
(MCLBYTES/MSIZE), MCLBYTES, 0, BUS_DMA_ALLOCNOW,
&xsc->sc_tx_dmamap);
if (error) {
aprint_error_dev(sc->sc_dev,
"can't create tx DMA map, error = %d", error);
}

for(i = 0; i < MB8795_NRXBUFS; i++) {
error = bus_dmamap_create(xsc->sc_rxdma->sc_dmat, MCLBYTES,
(MCLBYTES/MSIZE), MCLBYTES, 0, BUS_DMA_ALLOCNOW,
&xsc->sc_rx_dmamap[i]);
if (error) {
panic("%s: can't create rx DMA map, error = %d",
device_xname(sc->sc_dev), error);
}
xsc->sc_rx_mb_head[i] = NULL;
}
xsc->sc_rx_loaded_idx = 0;
xsc->sc_rx_completed_idx = 0;
xsc->sc_rx_handled_idx = 0;

/*
* @@@ more next hacks
* the 2000 covers at least a 1500 mtu + headers
* + DMA_BEGINALIGNMENT+ DMA_ENDALIGNMENT
*/
xsc->sc_txbuf = kmem_alloc(2000, KM_SLEEP);
xsc->sc_tx_mb_head = NULL;
xsc->sc_tx_loaded = 0;

mb8795_config(sc, xe_dma_medias, nxe_dma_medias, xe_dma_medias[0]);

isrlink_autovec(xe_tint, sc, NEXT_I_IPL(NEXT_I_ENETX), 1, NULL);
INTR_ENABLE(NEXT_I_ENETX);
isrlink_autovec(xe_rint, sc, NEXT_I_IPL(NEXT_I_ENETR), 1, NULL);
INTR_ENABLE(NEXT_I_ENETR);
}

void
xe_attach(device_t parent, device_t self, void *aux)
{
struct intio_attach_args *ia = (struct intio_attach_args *)aux;
struct xe_softc *xsc = device_private(self);
struct mb8795_softc *sc = &xsc->sc_mb8795;

sc->sc_dev = self;
DPRINTF(("%s: xe_attach()\n", device_xname(self)));

{
/* kludge from machdep.c:next68k_bootargs() */
extern u_char rom_enetaddr[6];
int i;

for (i = 0; i < 6; i++)
sc->sc_enaddr[i] = rom_enetaddr[i];
}

printf("\n%s: MAC address %02x:%02x:%02x:%02x:%02x:%02x\n",
device_xname(self),
sc->sc_enaddr[0],sc->sc_enaddr[1],sc->sc_enaddr[2],
sc->sc_enaddr[3],sc->sc_enaddr[4],sc->sc_enaddr[5]);

xsc->sc_bst = ia->ia_bst;
if (bus_space_map(xsc->sc_bst, NEXT_P_ENET,
XE_DEVICE_SIZE, 0, &xsc->sc_bsh)) {
panic("\n%s: can't map mb8795 registers",
device_xname(self));
}

sc->sc_bmap_bst = ia->ia_bst;
if (bus_space_map(sc->sc_bmap_bst, NEXT_P_BMAP,
BMAP_SIZE, 0, &sc->sc_bmap_bsh))
panic("\n%s: can't map bmap registers", device_xname(self));

/* Set up glue for MI code. */
sc->sc_glue = &xe_glue;

xsc->sc_txdma = nextdma_findchannel("enetx");
xsc->sc_rxdma = nextdma_findchannel("enetr");
if (xsc->sc_rxdma && xsc->sc_txdma)
findchannel_defer(self);
else
config_defer(self, findchannel_defer);

attached = 1;
}

int
xe_tint(void *arg)
{
if (!INTR_OCCURRED(NEXT_I_ENETX))
return 0;
mb8795_tint((struct mb8795_softc *)arg);
return 1;
}

int
xe_rint(void *arg)
{
if (!INTR_OCCURRED(NEXT_I_ENETR))
return 0;
mb8795_rint((struct mb8795_softc *)arg);
return 1;
}

/*
* Glue functions.
*/

u_char
xe_read_reg(struct mb8795_softc *sc, int reg)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

return bus_space_read_1(xsc->sc_bst, xsc->sc_bsh, reg);
}

void
xe_write_reg(struct mb8795_softc *sc, int reg, u_char val)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

bus_space_write_1(xsc->sc_bst, xsc->sc_bsh, reg, val);
}

void
xe_dma_reset(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;
int i;

DPRINTF(("xe DMA reset\n"));

nextdma_reset(xsc->sc_rxdma);
nextdma_reset(xsc->sc_txdma);

if (xsc->sc_tx_loaded) {
bus_dmamap_sync(xsc->sc_txdma->sc_dmat, xsc->sc_tx_dmamap,
0, xsc->sc_tx_dmamap->dm_mapsize, BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(xsc->sc_txdma->sc_dmat, xsc->sc_tx_dmamap);
xsc->sc_tx_loaded = 0;
}
m_freem(xsc->sc_tx_mb_head);
xsc->sc_tx_mb_head = NULL;

for(i = 0; i < MB8795_NRXBUFS; i++) {
if (xsc->sc_rx_mb_head[i]) {
bus_dmamap_unload(xsc->sc_rxdma->sc_dmat,
xsc->sc_rx_dmamap[i]);
m_freem(xsc->sc_rx_mb_head[i]);
xsc->sc_rx_mb_head[i] = NULL;
}
}
}

void
xe_dma_rx_setup(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;
int i;

DPRINTF(("xe DMA rx setup\n"));

for(i = 0; i < MB8795_NRXBUFS; i++)
xsc->sc_rx_mb_head[i] =
xe_dma_rxmap_load(sc, xsc->sc_rx_dmamap[i]);

xsc->sc_rx_loaded_idx = 0;
xsc->sc_rx_completed_idx = 0;
xsc->sc_rx_handled_idx = 0;

nextdma_init(xsc->sc_rxdma);
}

void
xe_dma_rx_go(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

DPRINTF(("xe DMA rx go\n"));

nextdma_start(xsc->sc_rxdma, DMACSR_SETREAD);
}

struct mbuf *
xe_dma_rx_mbuf(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;
bus_dmamap_t map;
struct mbuf *m;

m = NULL;
if (xsc->sc_rx_handled_idx != xsc->sc_rx_completed_idx) {
xsc->sc_rx_handled_idx++;
xsc->sc_rx_handled_idx %= MB8795_NRXBUFS;

map = xsc->sc_rx_dmamap[xsc->sc_rx_handled_idx];
m = xsc->sc_rx_mb_head[xsc->sc_rx_handled_idx];

m->m_len = map->dm_xfer_len;

bus_dmamap_sync(xsc->sc_rxdma->sc_dmat, map,
0, map->dm_mapsize, BUS_DMASYNC_POSTREAD);

bus_dmamap_unload(xsc->sc_rxdma->sc_dmat, map);

/* Install a fresh mbuf for next packet */

xsc->sc_rx_mb_head[xsc->sc_rx_handled_idx] =
xe_dma_rxmap_load(sc,map);

/* Punt runt packets
* DMA restarts create 0 length packets for example
*/
if (m->m_len < ETHER_MIN_LEN) {
m_freem(m);
m = NULL;
}
}
return m;
}

void
xe_dma_tx_setup(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

DPRINTF(("xe DMA tx setup\n"));

nextdma_init(xsc->sc_txdma);
}

void
xe_dma_tx_go(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

DPRINTF(("xe DMA tx go\n"));

nextdma_start(xsc->sc_txdma, DMACSR_SETWRITE);
}

int
xe_dma_tx_mbuf(struct mb8795_softc *sc, struct mbuf *m)
{
struct xe_softc *xsc = (struct xe_softc *)sc;
int error;

xsc->sc_tx_mb_head = m;

/* The following is a next specific hack that should
* probably be moved out of MI code.
* This macro assumes it can move forward as needed
* in the buffer. Perhaps it should zero the extra buffer.
*/
#define REALIGN_DMABUF(s,l) \
{ (s) = ((u_char *)(((unsigned)(s)+DMA_BEGINALIGNMENT-1) \
&~(DMA_BEGINALIGNMENT-1))); \
(l) = ((u_char *)(((unsigned)((s)+(l))+DMA_ENDALIGNMENT-1) \
&~(DMA_ENDALIGNMENT-1)))-(s);}

#if 0
error = bus_dmamap_load_mbuf(xsc->sc_txdma->sc_dmat,
xsc->sc_tx_dmamap, xsc->sc_tx_mb_head, BUS_DMA_NOWAIT);
#else
{
u_char *buf = xsc->sc_txbuf;
int buflen = 0;

buflen = m->m_pkthdr.len;

{
u_char *p = buf;
for (m=xsc->sc_tx_mb_head; m; m = m->m_next) {
if (m->m_len == 0) continue;
memcpy(p, mtod(m, u_char *), m->m_len);
p += m->m_len;
}
/* Fix runt packets */
if (buflen < ETHER_MIN_LEN - ETHER_CRC_LEN) {
memset(p, 0,
ETHER_MIN_LEN - ETHER_CRC_LEN - buflen);
buflen = ETHER_MIN_LEN - ETHER_CRC_LEN;
}
}

error = bus_dmamap_load(xsc->sc_txdma->sc_dmat,
xsc->sc_tx_dmamap, buf, buflen, NULL, BUS_DMA_NOWAIT);
}
#endif
if (error) {
aprint_error_dev(sc->sc_dev,
"can't load mbuf chain, error = %d\n", error);
m_freem(xsc->sc_tx_mb_head);
xsc->sc_tx_mb_head = NULL;
return error;
}

#ifdef DIAGNOSTIC
if (xsc->sc_tx_loaded != 0) {
panic("%s: xsc->sc_tx_loaded is %d", device_xname(sc->sc_dev),
xsc->sc_tx_loaded);
}
#endif

bus_dmamap_sync(xsc->sc_txdma->sc_dmat, xsc->sc_tx_dmamap, 0,
xsc->sc_tx_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);

return 0;
}

int
xe_dma_tx_isactive(struct mb8795_softc *sc)
{
struct xe_softc *xsc = (struct xe_softc *)sc;

return (xsc->sc_tx_loaded != 0);
}

/****************************************************************/

void
xe_dma_tx_completed(bus_dmamap_t map, void *arg)
{
#if defined (XE_DEBUG) || defined (DIAGNOSTIC)
struct mb8795_softc *sc = arg;
#endif
#ifdef DIAGNOSTIC
struct xe_softc *xsc = (struct xe_softc *)sc;
#endif

DPRINTF(("%s: xe_dma_tx_completed()\n", device_xname(sc->sc_dev)));

#ifdef DIAGNOSTIC
if (!xsc->sc_tx_loaded)
panic("%s: tx completed never loaded",
device_xname(sc->sc_dev));

if (map != xsc->sc_tx_dmamap)
panic("%s: unexpected tx completed map",
device_xname(sc->sc_dev));

#endif
}

void
xe_dma_tx_shutdown(void *arg)
{
struct mb8795_softc *sc = arg;
struct xe_softc *xsc = (struct xe_softc *)sc;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;

DPRINTF(("%s: xe_dma_tx_shutdown()\n", device_xname(sc->sc_dev)));

#ifdef DIAGNOSTIC
if (!xsc->sc_tx_loaded)
panic("%s: tx shutdown never loaded",
device_xname(sc->sc_dev));
#endif

if (turbo)
MB_WRITE_REG(sc, MB8795_TXMODE, MB8795_TXMODE_TURBO1);
if (xsc->sc_tx_loaded) {
bus_dmamap_sync(xsc->sc_txdma->sc_dmat, xsc->sc_tx_dmamap,
0, xsc->sc_tx_dmamap->dm_mapsize, BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(xsc->sc_txdma->sc_dmat, xsc->sc_tx_dmamap);
m_freem(xsc->sc_tx_mb_head);
xsc->sc_tx_mb_head = NULL;

xsc->sc_tx_loaded--;
}

#ifdef DIAGNOSTIC
if (xsc->sc_tx_loaded != 0)
panic("%s: sc->sc_tx_loaded is %d", device_xname(sc->sc_dev),
xsc->sc_tx_loaded);
#endif

ifp->if_timer = 0;

#if 1
if ((ifp->if_flags & IFF_RUNNING) && !IF_IS_EMPTY(&sc->sc_tx_snd)) {
void mb8795_start_dma(struct mb8795_softc *); /* XXXX */
mb8795_start_dma(sc);
}
#endif

#if 0
/* Enable ready interrupt */
MB_WRITE_REG(sc, MB8795_TXMASK,
MB_READ_REG(sc, MB8795_TXMASK)
| MB8795_TXMASK_TXRXIE/* READYIE */);
#endif
}

void
xe_dma_rx_completed(bus_dmamap_t map, void *arg)
{
struct mb8795_softc *sc = arg;
struct xe_softc *xsc = (struct xe_softc *)sc;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;

if (ifp->if_flags & IFF_RUNNING) {
xsc->sc_rx_completed_idx++;
xsc->sc_rx_completed_idx %= MB8795_NRXBUFS;

DPRINTF(("%s: xe_dma_rx_completed(), "
"sc->sc_rx_completed_idx = %d\n",
device_xname(sc->sc_dev), xsc->sc_rx_completed_idx));

#if (defined(DIAGNOSTIC))
if (map != xsc->sc_rx_dmamap[xsc->sc_rx_completed_idx])
panic("%s: Unexpected rx dmamap completed",
device_xname(sc->sc_dev));
#endif
}
#ifdef DIAGNOSTIC
else
DPRINTF(("%s: Unexpected rx dmamap completed while if not "
"running\n", device_xname(sc->sc_dev)));
#endif
}

void
xe_dma_rx_shutdown(void *arg)
{
struct mb8795_softc *sc = arg;
struct xe_softc *xsc = (struct xe_softc *)sc;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;

if (ifp->if_flags & IFF_RUNNING) {
DPRINTF(("%s: xe_dma_rx_shutdown(), restarting.\n",
device_xname(sc->sc_dev)));

nextdma_start(xsc->sc_rxdma, DMACSR_SETREAD);
if (turbo)
MB_WRITE_REG(sc, MB8795_RXMODE,
MB8795_RXMODE_TEST | MB8795_RXMODE_MULTICAST);
}
#ifdef DIAGNOSTIC
else
DPRINTF(("%s: Unexpected rx DMA shutdown while if not "
"running\n", device_xname(sc->sc_dev)));
#endif
}

/*
* load a dmamap with a freshly allocated mbuf
*/
struct mbuf *
xe_dma_rxmap_load(struct mb8795_softc *sc, bus_dmamap_t map)
{
struct xe_softc *xsc = (struct xe_softc *)sc;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
struct mbuf *m;
int error;

MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m) {
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_freem(m);
m = NULL;
} else
m->m_len = MCLBYTES;
}
if (!m) {
/*
* @@@ Handle this gracefully by reusing a scratch buffer
* or something.
*/
panic("Unable to get memory for incoming ethernet");
}

/*
* Align buffer, @@@ next specific.
* perhaps should be using M_ALIGN here instead?
* First we give us a little room to align with.
*/
{
u_char *buf = m->m_data;
int buflen = m->m_len;
buflen -= DMA_ENDALIGNMENT+DMA_BEGINALIGNMENT;
REALIGN_DMABUF(buf, buflen);
m->m_data = buf;
m->m_len = buflen;
}

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

error = bus_dmamap_load_mbuf(xsc->sc_rxdma->sc_dmat,
map, m, BUS_DMA_NOWAIT);

bus_dmamap_sync(xsc->sc_rxdma->sc_dmat, map, 0,
map->dm_mapsize, BUS_DMASYNC_PREREAD);

if (error) {
DPRINTF(("DEBUG: m->m_data = %p, m->m_len = %d\n",
m->m_data, m->m_len));
DPRINTF(("DEBUG: MCLBYTES = %d, map->_dm_size = %ld\n",
MCLBYTES, map->_dm_size));

panic("%s: can't load rx mbuf chain, error = %d",
device_xname(sc->sc_dev), error);
m_freem(m);
m = NULL;
}

return m;
}

bus_dmamap_t
xe_dma_rx_continue(void *arg)
{
struct mb8795_softc *sc = arg;
struct xe_softc *xsc = (struct xe_softc *)sc;
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
bus_dmamap_t map = NULL;

if (ifp->if_flags & IFF_RUNNING) {
if (((xsc->sc_rx_loaded_idx+1)%MB8795_NRXBUFS)
== xsc->sc_rx_handled_idx) {
/* Make space for one packet by dropping one */
struct mbuf *m;
m = xe_dma_rx_mbuf (sc);
if (m)
m_freem(m);
#if (defined(DIAGNOSTIC))
DPRINTF(("%s: out of receive DMA buffers\n",
device_xname(sc->sc_dev)));
#endif
}
xsc->sc_rx_loaded_idx++;
xsc->sc_rx_loaded_idx %= MB8795_NRXBUFS;
map = xsc->sc_rx_dmamap[xsc->sc_rx_loaded_idx];

DPRINTF(("%s: xe_dma_rx_continue() xsc->sc_rx_loaded_idx "
"= %d\n", device_xname(sc->sc_dev),
xsc->sc_rx_loaded_idx));
}
#ifdef DIAGNOSTIC
else
panic("%s: Unexpected rx DMA continue while if not running",
device_xname(sc->sc_dev));
#endif

return map;
}

bus_dmamap_t
xe_dma_tx_continue(void *arg)
{
struct mb8795_softc *sc = arg;
struct xe_softc *xsc = (struct xe_softc *)sc;
bus_dmamap_t map;

DPRINTF(("%s: xe_dma_tx_continue()\n", device_xname(sc->sc_dev)));

if (xsc->sc_tx_loaded)
map = NULL;
else {
map = xsc->sc_tx_dmamap;
xsc->sc_tx_loaded++;
}

#ifdef DIAGNOSTIC
if (xsc->sc_tx_loaded != 1)
panic("%s: sc->sc_tx_loaded is %d", device_xname(sc->sc_dev),
xsc->sc_tx_loaded);
#endif

return map;
}