freebsd-dev/sys/dev/ex/if_ex.c
Matthew N. Dodd 5178bd8bde Fix bus_setup_intr(); I changed exintr() to take a pointer to ex_softc
but didn't change bus_setup_intr() to pass the softc in.

Submitted by:	Warner Losh <imp@village.org>
1999-11-03 15:45:14 +00:00

1107 lines
26 KiB
C

/*
* Copyright (c) 1996, Javier Martín Rueda (jmrueda@diatel.upm.es)
* 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 unmodified, 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*
* MAINTAINER: Matthew N. Dodd <winter@jurai.net>
* <mdodd@FreeBSD.org>
*/
/*
* Intel EtherExpress Pro/10, Pro/10+ Ethernet driver
*
* Revision history:
*
* 30-Oct-1996: first beta version. Inet and BPF supported, but no multicast.
*/
#include "ex.h"
#if NEX > 0
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/sockio.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>
#include <net/ethernet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <net/bpf.h>
#include <machine/clock.h>
#include <isa/isavar.h>
#include <isa/pnpvar.h>
#include <i386/isa/if_exreg.h>
#ifdef EXDEBUG
# define Start_End 1
# define Rcvd_Pkts 2
# define Sent_Pkts 4
# define Status 8
static int debug_mask = 0;
static int exintr_count = 0;
# define DODEBUG(level, action) if (level & debug_mask) action
#else
# define DODEBUG(level, action)
#endif
#define Conn_BNC 1
#define Conn_TPE 2
#define Conn_AUI 3
#define CARD_TYPE_EX_10 1
#define CARD_TYPE_EX_10_PLUS 2
struct ex_softc {
struct arpcom arpcom; /* Ethernet common data */
device_t dev;
struct resource *ioport;
struct resource *irq;
u_int iobase; /* I/O base address. */
u_short irq_no; /* IRQ number. */
char * irq2ee; /* irq <-> internal */
u_char * ee2irq; /* representation conversion */
u_short connector; /* Connector type. */
u_int mem_size; /* Total memory size, in bytes. */
u_int rx_mem_size; /* Rx memory size (by default, */
/* first 3/4 of total memory). */
u_int rx_lower_limit; /* Lower and upper limits of */
u_int rx_upper_limit; /* receive buffer. */
u_int rx_head; /* Head of receive ring buffer. */
u_int tx_mem_size; /* Tx memory size (by default, */
/* last quarter of total memory).*/
u_int tx_lower_limit; /* Lower and upper limits of */
u_int tx_upper_limit; /* transmit buffer. */
u_int tx_head; /* Head and tail of */
u_int tx_tail; /* transmit ring buffer. */
u_int tx_last; /* Pointer to beginning of last */
/* frame in the chain. */
};
static char irq2eemap[] =
{ -1, -1, 0, 1, -1, 2, -1, -1, -1, 0, 3, 4, -1, -1, -1, -1 };
static u_char ee2irqmap[] =
{ 9, 3, 5, 10, 11, 0, 0, 0 };
static char plus_irq2eemap[] =
{ -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, -1, -1, -1 };
static u_char plus_ee2irqmap[] =
{ 3, 4, 5, 7, 9, 10, 11, 12 };
/* Bus Front End Functions */
static int ex_isa_probe __P((device_t));
static int ex_attach __P((device_t));
/* Network Interface Functions */
static void ex_init __P((void *));
static void ex_start __P((struct ifnet *));
static int ex_ioctl __P((struct ifnet *, u_long, caddr_t));
static void ex_watchdog __P((struct ifnet *));
static void ex_stop __P((struct ex_softc *));
static void ex_reset __P((struct ex_softc *));
static driver_intr_t exintr;
static void ex_tx_intr __P((struct ex_softc *));
static void ex_rx_intr __P((struct ex_softc *));
static u_short eeprom_read __P((int, int));
static device_method_t ex_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, ex_isa_probe),
DEVMETHOD(device_attach, ex_attach),
{ 0, 0 }
};
static driver_t ex_driver = {
"ex",
ex_methods,
sizeof(struct ex_softc),
};
static devclass_t ex_devclass;
DRIVER_MODULE(ex, isa, ex_driver, ex_devclass, 0, 0);
static struct isa_pnp_id ex_ids[] = {
{ 0x3110d425, NULL }, /* INT1031 */
{ 0x3010d425, NULL }, /* INT1030 */
{ 0, NULL },
};
static int look_for_card(u_int iobase)
{
int count1, count2;
/*
* Check for the i82595 signature, and check that the round robin
* counter actually advances.
*/
if (((count1 = inb(iobase + ID_REG)) & Id_Mask) != Id_Sig)
return(0);
count2 = inb(iobase + ID_REG);
count2 = inb(iobase + ID_REG);
count2 = inb(iobase + ID_REG);
return((count2 & Counter_bits) == ((count1 + 0xc0) & Counter_bits));
}
static int
ex_get_media (u_int32_t iobase)
{
int tmp;
outb(iobase + CMD_REG, Bank2_Sel);
tmp = inb(iobase + REG3);
outb(iobase + CMD_REG, Bank0_Sel);
if (tmp & TPE_bit)
return(Conn_TPE);
if (tmp & BNC_bit)
return(Conn_BNC);
return (Conn_AUI);
}
static void
ex_get_address (u_int32_t iobase, u_char *enaddr)
{
u_int16_t eaddr_tmp;
eaddr_tmp = eeprom_read(iobase, EE_Eth_Addr_Lo);
enaddr[5] = eaddr_tmp & 0xff;
enaddr[4] = eaddr_tmp >> 8;
eaddr_tmp = eeprom_read(iobase, EE_Eth_Addr_Mid);
enaddr[3] = eaddr_tmp & 0xff;
enaddr[2] = eaddr_tmp >> 8;
eaddr_tmp = eeprom_read(iobase, EE_Eth_Addr_Hi);
enaddr[1] = eaddr_tmp & 0xff;
enaddr[0] = eaddr_tmp >> 8;
return;
}
static int
ex_card_type (u_char *enaddr)
{
if ((enaddr[0] == 0x00) && (enaddr[1] == 0xA0) && (enaddr[2] == 0xC9))
return (CARD_TYPE_EX_10_PLUS);
return (CARD_TYPE_EX_10);
}
static int
ex_isa_probe(device_t dev)
{
u_int iobase;
u_int irq;
char * irq2ee;
u_char * ee2irq;
u_char enaddr[6];
int tmp;
int error;
DODEBUG(Start_End, printf("ex_probe: start\n"););
/* Check isapnp ids */
error = ISA_PNP_PROBE(device_get_parent(dev), dev, ex_ids);
/* If the card had a PnP ID that didn't match any we know about */
if (error == ENXIO) {
return(error);
}
/* If we had some other problem. */
if (!(error == 0 || error == ENOENT)) {
return(error);
}
/*
* If an I/O address was supplied in the configuration file
* or by PnP ,probe only that. Otherwise, cycle through the
* predefined set of possible addresses.
* This should really be a bus enumerator ala DEVICE_IDENTFY()
*/
iobase = bus_get_resource_start(dev, SYS_RES_IOPORT, 0);
if (iobase != 0) {
if (! look_for_card(iobase)) {
printf("ex: no card found at 0x%03x\n", iobase);
return(ENXIO);
}
} else {
for (iobase = 0x200; iobase < 0x3a0; iobase += 0x10) {
if (look_for_card(iobase))
break;
}
if (iobase >= 0x3a0) {
return(ENXIO);
} else {
bus_set_resource(dev, SYS_RES_IOPORT, 0,
iobase, EX_IOSIZE);
}
}
/*
* Reset the card.
*/
outb(iobase + CMD_REG, Reset_CMD);
DELAY(400);
ex_get_address(iobase, enaddr);
/* work out which set of irq <-> internal tables to use */
if (ex_card_type(enaddr) == CARD_TYPE_EX_10_PLUS) {
irq2ee = plus_irq2eemap;
ee2irq = plus_ee2irqmap;
} else {
irq2ee = irq2eemap;
ee2irq = ee2irqmap;
}
tmp = eeprom_read(iobase, EE_IRQ_No) & IRQ_No_Mask;
irq = bus_get_resource_start(dev, SYS_RES_IRQ, 0);
if (irq > 0) {
if (ee2irq[tmp] != irq) {
printf("ex: WARNING: board's EEPROM is configured"
" for IRQ %d, using %d\n",
ee2irq[tmp], irq);
}
} else {
irq = ee2irq[tmp];
bus_set_resource(dev, SYS_RES_IRQ, 0, irq, 1);
}
if (irq == 0) {
printf("ex: invalid IRQ.\n");
return(ENXIO);
}
DODEBUG(Start_End, printf("ex_probe: finish\n"););
return(0);
}
int ex_attach(device_t dev)
{
struct ex_softc * sc = device_get_softc(dev);
struct ifnet * ifp = &sc->arpcom.ac_if;
int unit = device_get_unit(dev);
int error;
int rid;
void * ih;
DODEBUG(Start_End, device_printf(dev, "start\n"););
rid = 0;
sc->ioport = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
0, ~0, 1, RF_ACTIVE);
if (!sc->ioport) {
device_printf(dev, "No I/O space?!\n");
goto bad;
}
rid = 0;
sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid,
0, ~0, 1, RF_ACTIVE);
if (!sc->irq) {
device_printf(dev, "No IRQ?!\n");
goto bad;
}
error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET,
exintr, (void *)sc, &ih);
if (error) {
device_printf(dev, "bus_setup_intr() failed!\n");
goto bad;
}
/*
* Fill in several fields of the softc structure:
* - I/O base address.
* - Hardware Ethernet address.
* - IRQ number (if not supplied in config file, read it from EEPROM).
* - Connector type.
*/
sc->dev = dev;
sc->iobase = rman_get_start(sc->ioport);
sc->irq_no = rman_get_start(sc->irq);
ex_get_address(sc->iobase, sc->arpcom.ac_enaddr);
/* work out which set of irq <-> internal tables to use */
if (ex_card_type(sc->arpcom.ac_enaddr) == CARD_TYPE_EX_10_PLUS) {
sc->irq2ee = plus_irq2eemap;
sc->ee2irq = plus_ee2irqmap;
} else {
sc->irq2ee = irq2eemap;
sc->ee2irq = ee2irqmap;
}
sc->connector = ex_get_media(sc->iobase);
sc->mem_size = CARD_RAM_SIZE; /* XXX This should be read from the card itself. */
/*
* Initialize the ifnet structure.
*/
ifp->if_softc = sc;
ifp->if_unit = unit;
ifp->if_name = "ex";
ifp->if_init = ex_init;
ifp->if_output = ether_output;
ifp->if_start = ex_start;
ifp->if_ioctl = ex_ioctl;
ifp->if_watchdog = ex_watchdog;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST
/* XXX not done yet. | IFF_MULTICAST */;
/*
* Attach the interface.
*/
if_attach(ifp);
ether_ifattach(ifp);
if (ex_card_type(sc->arpcom.ac_enaddr) == CARD_TYPE_EX_10_PLUS) {
printf("ex%d: Intel EtherExpress Pro/10+, address %6D, connector ", unit, sc->arpcom.ac_enaddr, ":");
} else {
printf("ex%d: Intel EtherExpress Pro/10, address %6D, connector ", unit, sc->arpcom.ac_enaddr, ":");
}
switch(sc->connector) {
case Conn_TPE: printf("TPE\n"); break;
case Conn_BNC: printf("BNC\n"); break;
case Conn_AUI: printf("AUI\n"); break;
default: printf("???\n");
}
/*
* If BPF is in the kernel, call the attach for it
*/
bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
DODEBUG(Start_End, printf("ex_attach%d: finish\n", unit););
sc->arpcom.ac_if.if_snd.ifq_maxlen = ifqmaxlen;
return(0);
bad:
if (sc->ioport)
bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->ioport);
if (sc->irq)
bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
return (-1);
}
void ex_init(void *xsc)
{
struct ex_softc * sc = (struct ex_softc *) xsc;
struct ifnet * ifp = &sc->arpcom.ac_if;
int s;
int i;
register int iobase = sc->iobase;
unsigned short temp_reg;
DODEBUG(Start_End, printf("ex_init%d: start\n", ifp->if_unit););
if (ifp->if_addrhead.tqh_first == NULL) {
return;
}
s = splimp();
sc->arpcom.ac_if.if_timer = 0;
/*
* Load the ethernet address into the card.
*/
outb(iobase + CMD_REG, Bank2_Sel);
temp_reg = inb(iobase + EEPROM_REG);
if (temp_reg & Trnoff_Enable) {
outb(iobase + EEPROM_REG, temp_reg & ~Trnoff_Enable);
}
for (i = 0; i < ETHER_ADDR_LEN; i++) {
outb(iobase + I_ADDR_REG0 + i, sc->arpcom.ac_enaddr[i]);
}
/*
* - Setup transmit chaining and discard bad received frames.
* - Match broadcast.
* - Clear test mode.
* - Set receiving mode.
* - Set IRQ number.
*/
outb(iobase + REG1, inb(iobase + REG1) | Tx_Chn_Int_Md | Tx_Chn_ErStp | Disc_Bad_Fr);
outb(iobase + REG2, inb(iobase + REG2) | No_SA_Ins | RX_CRC_InMem);
outb(iobase + REG3, inb(iobase + REG3) & 0x3f /* XXX constants. */ );
outb(iobase + CMD_REG, Bank1_Sel);
outb(iobase + INT_NO_REG, (inb(iobase + INT_NO_REG) & 0xf8) | sc->irq2ee[sc->irq_no]);
/*
* Divide the available memory in the card into rcv and xmt buffers.
* By default, I use the first 3/4 of the memory for the rcv buffer,
* and the remaining 1/4 of the memory for the xmt buffer.
*/
sc->rx_mem_size = sc->mem_size * 3 / 4;
sc->tx_mem_size = sc->mem_size - sc->rx_mem_size;
sc->rx_lower_limit = 0x0000;
sc->rx_upper_limit = sc->rx_mem_size - 2;
sc->tx_lower_limit = sc->rx_mem_size;
sc->tx_upper_limit = sc->mem_size - 2;
outb(iobase + RCV_LOWER_LIMIT_REG, sc->rx_lower_limit >> 8);
outb(iobase + RCV_UPPER_LIMIT_REG, sc->rx_upper_limit >> 8);
outb(iobase + XMT_LOWER_LIMIT_REG, sc->tx_lower_limit >> 8);
outb(iobase + XMT_UPPER_LIMIT_REG, sc->tx_upper_limit >> 8);
/*
* Enable receive and transmit interrupts, and clear any pending int.
*/
outb(iobase + REG1, inb(iobase + REG1) | TriST_INT);
outb(iobase + CMD_REG, Bank0_Sel);
outb(iobase + MASK_REG, All_Int & ~(Rx_Int | Tx_Int));
outb(iobase + STATUS_REG, All_Int);
/*
* Initialize receive and transmit ring buffers.
*/
outw(iobase + RCV_BAR, sc->rx_lower_limit);
sc->rx_head = sc->rx_lower_limit;
outw(iobase + RCV_STOP_REG, sc->rx_upper_limit | 0xfe);
outw(iobase + XMT_BAR, sc->tx_lower_limit);
sc->tx_head = sc->tx_tail = sc->tx_lower_limit;
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
DODEBUG(Status, printf("OIDLE init\n"););
/*
* Final reset of the board, and enable operation.
*/
outb(iobase + CMD_REG, Sel_Reset_CMD);
DELAY(2);
outb(iobase + CMD_REG, Rcv_Enable_CMD);
ex_start(ifp);
splx(s);
DODEBUG(Start_End, printf("ex_init%d: finish\n", ifp->if_unit););
}
void
ex_start(struct ifnet *ifp)
{
struct ex_softc * sc = ifp->if_softc;
int iobase = sc->iobase;
int i, s, len, data_len, avail, dest, next;
unsigned char tmp16[2];
struct mbuf * opkt;
struct mbuf * m;
DODEBUG(Start_End, printf("ex_start%d: start\n", unit););
s = splimp();
/*
* Main loop: send outgoing packets to network card until there are no
* more packets left, or the card cannot accept any more yet.
*/
while (((opkt = ifp->if_snd.ifq_head) != NULL) &&
!(ifp->if_flags & IFF_OACTIVE)) {
/*
* Ensure there is enough free transmit buffer space for
* this packet, including its header. Note: the header
* cannot wrap around the end of the transmit buffer and
* must be kept together, so we allow space for twice the
* length of the header, just in case.
*/
for (len = 0, m = opkt; m != NULL; m = m->m_next) {
len += m->m_len;
}
data_len = len;
DODEBUG(Sent_Pkts, printf("1. Sending packet with %d data bytes. ", data_len););
if (len & 1) {
len += XMT_HEADER_LEN + 1;
} else {
len += XMT_HEADER_LEN;
}
if ((i = sc->tx_tail - sc->tx_head) >= 0) {
avail = sc->tx_mem_size - i;
} else {
avail = -i;
}
DODEBUG(Sent_Pkts, printf("i=%d, avail=%d\n", i, avail););
if (avail >= len + XMT_HEADER_LEN) {
IF_DEQUEUE(&ifp->if_snd, opkt);
#ifdef EX_PSA_INTR
/*
* Disable rx and tx interrupts, to avoid corruption
* of the host address register by interrupt service
* routines.
* XXX Is this necessary with splimp() enabled?
*/
outb(iobase + MASK_REG, All_Int);
#endif
/*
* Compute the start and end addresses of this
* frame in the tx buffer.
*/
dest = sc->tx_tail;
next = dest + len;
if (next > sc->tx_upper_limit) {
if ((sc->tx_upper_limit + 2 - sc->tx_tail) <=
XMT_HEADER_LEN) {
dest = sc->tx_lower_limit;
next = dest + len;
}
} else {
next = sc->tx_lower_limit +
next - sc->tx_upper_limit - 2;
}
/*
* Build the packet frame in the card's ring buffer.
*/
DODEBUG(Sent_Pkts, printf("2. dest=%d, next=%d. ", dest, next););
outw(iobase + HOST_ADDR_REG, dest);
outw(iobase + IO_PORT_REG, Transmit_CMD);
outw(iobase + IO_PORT_REG, 0);
outw(iobase + IO_PORT_REG, next);
outw(iobase + IO_PORT_REG, data_len);
/*
* Output the packet data to the card. Ensure all
* transfers are 16-bit wide, even if individual
* mbufs have odd length.
*/
for (m = opkt, i = 0; m != NULL; m = m->m_next) {
DODEBUG(Sent_Pkts, printf("[%d]", m->m_len););
if (i) {
tmp16[1] = *(mtod(m, caddr_t));
outsw(iobase + IO_PORT_REG, tmp16, 1);
}
outsw(iobase + IO_PORT_REG,
mtod(m, caddr_t) + i, (m->m_len - i) / 2);
if ((i = (m->m_len - i) & 1) != 0) {
tmp16[0] = *(mtod(m, caddr_t) +
m->m_len - 1);
}
}
if (i) {
outsw(iobase + IO_PORT_REG, tmp16, 1);
/*
* If there were other frames chained, update the
* chain in the last one.
*/
if (sc->tx_head != sc->tx_tail) {
if (sc->tx_tail != dest) {
outw(iobase + HOST_ADDR_REG,
sc->tx_last + XMT_Chain_Point);
outw(iobase + IO_PORT_REG, dest);
}
outw(iobase + HOST_ADDR_REG,
sc->tx_last + XMT_Byte_Count);
i = inw(iobase + IO_PORT_REG);
outw(iobase + HOST_ADDR_REG,
sc->tx_last + XMT_Byte_Count);
outw(iobase + IO_PORT_REG, i | Ch_bit);
}
/*
* Resume normal operation of the card:
* - Make a dummy read to flush the DRAM write
* pipeline.
* - Enable receive and transmit interrupts.
* - Send Transmit or Resume_XMT command, as
* appropriate.
*/
inw(iobase + IO_PORT_REG);
#ifdef EX_PSA_INTR
outb(iobase + MASK_REG, All_Int & ~(Rx_Int | Tx_Int));
#endif
if (sc->tx_head == sc->tx_tail) {
outw(iobase + XMT_BAR, dest);
outb(iobase + CMD_REG, Transmit_CMD);
sc->tx_head = dest;
DODEBUG(Sent_Pkts, printf("Transmit\n"););
} else {
outb(iobase + CMD_REG, Resume_XMT_List_CMD);
DODEBUG(Sent_Pkts, printf("Resume\n"););
}
sc->tx_last = dest;
sc->tx_tail = next;
if (ifp->if_bpf != NULL) {
bpf_mtap(ifp, opkt);
}
ifp->if_timer = 2;
ifp->if_opackets++;
m_freem(opkt);
} else {
ifp->if_flags |= IFF_OACTIVE;
DODEBUG(Status, printf("OACTIVE start\n"););
}
}
}
splx(s);
DODEBUG(Start_End, printf("ex_start%d: finish\n", unit););
}
static void
ex_stop(struct ex_softc *sc)
{
int iobase = sc->iobase;
DODEBUG(Start_End, printf("ex_stop%d: start\n", unit););
/*
* Disable card operation:
* - Disable the interrupt line.
* - Flush transmission and disable reception.
* - Mask and clear all interrupts.
* - Reset the 82595.
*/
outb(iobase + CMD_REG, Bank1_Sel);
outb(iobase + REG1, inb(iobase + REG1) & ~TriST_INT);
outb(iobase + CMD_REG, Bank0_Sel);
outb(iobase + CMD_REG, Rcv_Stop);
sc->tx_head = sc->tx_tail = sc->tx_lower_limit;
sc->tx_last = 0; /* XXX I think these two lines are not necessary, because ex_init will always be called again to reinit the interface. */
outb(iobase + MASK_REG, All_Int);
outb(iobase + STATUS_REG, All_Int);
outb(iobase + CMD_REG, Reset_CMD);
DELAY(200);
DODEBUG(Start_End, printf("ex_stop%d: finish\n", unit););
return;
}
static void
exintr(void *arg)
{
struct ex_softc * sc = (struct ex_softc *)arg;
struct ifnet * ifp = &sc->arpcom.ac_if;
int iobase = sc->iobase;
int int_status, send_pkts;
DODEBUG(Start_End, printf("exintr%d: start\n", unit););
#ifdef EXDEBUG
if (++exintr_count != 1)
printf("WARNING: nested interrupt (%d). Mail the author.\n", exintr_count);
#endif
send_pkts = 0;
while ((int_status = inb(iobase + STATUS_REG)) & (Tx_Int | Rx_Int)) {
if (int_status & Rx_Int) {
outb(iobase + STATUS_REG, Rx_Int);
ex_rx_intr(sc);
} else if (int_status & Tx_Int) {
outb(iobase + STATUS_REG, Tx_Int);
ex_tx_intr(sc);
send_pkts = 1;
}
}
/*
* If any packet has been transmitted, and there are queued packets to
* be sent, attempt to send more packets to the network card.
*/
if (send_pkts && (ifp->if_snd.ifq_head != NULL)) {
ex_start(ifp);
}
#ifdef EXDEBUG
exintr_count--;
#endif
DODEBUG(Start_End, printf("exintr%d: finish\n", unit););
return;
}
static void
ex_tx_intr(struct ex_softc *sc)
{
struct ifnet * ifp = &sc->arpcom.ac_if;
int iobase = sc->iobase;
int tx_status;
DODEBUG(Start_End, printf("ex_tx_intr%d: start\n", unit););
/*
* - Cancel the watchdog.
* For all packets transmitted since last transmit interrupt:
* - Advance chain pointer to next queued packet.
* - Update statistics.
*/
ifp->if_timer = 0;
while (sc->tx_head != sc->tx_tail) {
outw(iobase + HOST_ADDR_REG, sc->tx_head);
if (! inw(iobase + IO_PORT_REG) & Done_bit)
break;
tx_status = inw(iobase + IO_PORT_REG);
sc->tx_head = inw(iobase + IO_PORT_REG);
if (tx_status & TX_OK_bit) {
ifp->if_opackets++;
} else {
ifp->if_oerrors++;
}
ifp->if_collisions += tx_status & No_Collisions_bits;
}
/*
* The card should be ready to accept more packets now.
*/
ifp->if_flags &= ~IFF_OACTIVE;
DODEBUG(Status, printf("OIDLE tx_intr\n"););
DODEBUG(Start_End, printf("ex_tx_intr%d: finish\n", unit););
return;
}
static void
ex_rx_intr(struct ex_softc *sc)
{
struct ifnet * ifp = &sc->arpcom.ac_if;
int iobase = sc->iobase;
int rx_status;
int pkt_len;
int QQQ;
struct mbuf * m;
struct mbuf * ipkt;
struct ether_header * eh;
DODEBUG(Start_End, printf("ex_rx_intr%d: start\n", unit););
/*
* For all packets received since last receive interrupt:
* - If packet ok, read it into a new mbuf and queue it to interface,
* updating statistics.
* - If packet bad, just discard it, and update statistics.
* Finally, advance receive stop limit in card's memory to new location.
*/
outw(iobase + HOST_ADDR_REG, sc->rx_head);
while (inw(iobase + IO_PORT_REG) == RCV_Done) {
rx_status = inw(iobase + IO_PORT_REG);
sc->rx_head = inw(iobase + IO_PORT_REG);
QQQ = pkt_len = inw(iobase + IO_PORT_REG);
if (rx_status & RCV_OK_bit) {
MGETHDR(m, M_DONTWAIT, MT_DATA);
ipkt = m;
if (ipkt == NULL) {
ifp->if_iqdrops++;
} else {
ipkt->m_pkthdr.rcvif = ifp;
ipkt->m_pkthdr.len = pkt_len;
ipkt->m_len = MHLEN;
while (pkt_len > 0) {
if (pkt_len > MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
if (m->m_flags & M_EXT) {
m->m_len = MCLBYTES;
} else {
m_freem(ipkt);
ifp->if_iqdrops++;
goto rx_another;
}
}
m->m_len = min(m->m_len, pkt_len);
/*
* NOTE: I'm assuming that all mbufs allocated are of even length,
* except for the last one in an odd-length packet.
*/
insw(iobase + IO_PORT_REG,
mtod(m, caddr_t), m->m_len / 2);
if (m->m_len & 1) {
*(mtod(m, caddr_t) + m->m_len - 1) = inb(iobase + IO_PORT_REG);
}
pkt_len -= m->m_len;
if (pkt_len > 0) {
MGET(m->m_next, M_DONTWAIT, MT_DATA);
if (m->m_next == NULL) {
m_freem(ipkt);
ifp->if_iqdrops++;
goto rx_another;
}
m = m->m_next;
m->m_len = MLEN;
}
}
eh = mtod(ipkt, struct ether_header *);
#ifdef EXDEBUG
if (debug_mask & Rcvd_Pkts) {
if ((eh->ether_dhost[5] != 0xff) || (eh->ether_dhost[0] != 0xff)) {
printf("Receive packet with %d data bytes: %6D -> ", QQQ, eh->ether_shost, ":");
printf("%6D\n", eh->ether_dhost, ":");
} /* QQQ */
}
#endif
if (ifp->if_bpf != NULL) {
bpf_mtap(ifp, ipkt);
/*
* Note that the interface cannot be in promiscuous mode
* if there are no BPF listeners. And if we are in
* promiscuous mode, we have to check if this packet is
* really ours.
*/
if ((ifp->if_flags & IFF_PROMISC) &&
(eh->ether_dhost[0] & 1) == 0 &&
bcmp(eh->ether_dhost, sc->arpcom.ac_enaddr, sizeof(eh->ether_dhost)) != 0 &&
bcmp(eh->ether_dhost, etherbroadcastaddr, sizeof(eh->ether_dhost)) != 0) {
m_freem(ipkt);
goto rx_another;
}
}
m_adj(ipkt, sizeof(struct ether_header));
ether_input(ifp, eh, ipkt);
ifp->if_ipackets++;
}
} else {
ifp->if_ierrors++;
}
outw(iobase + HOST_ADDR_REG, sc->rx_head);
rx_another: ;
}
if (sc->rx_head < sc->rx_lower_limit + 2)
outw(iobase + RCV_STOP_REG, sc->rx_upper_limit);
else
outw(iobase + RCV_STOP_REG, sc->rx_head - 2);
DODEBUG(Start_End, printf("ex_rx_intr%d: finish\n", unit););
return;
}
int ex_ioctl(register struct ifnet *ifp, u_long cmd, caddr_t data)
{
struct ex_softc * sc = ifp->if_softc;
int s;
int error = 0;
DODEBUG(Start_End, printf("ex_ioctl%d: start ", ifp->if_unit););
s = splimp();
switch(cmd) {
case SIOCSIFADDR:
case SIOCGIFADDR:
case SIOCSIFMTU:
error = ether_ioctl(ifp, cmd, data);
break;
case SIOCSIFFLAGS:
DODEBUG(Start_End, printf("SIOCSIFFLAGS"););
if ((ifp->if_flags & IFF_UP) == 0 &&
(ifp->if_flags & IFF_RUNNING)) {
ifp->if_flags &= ~IFF_RUNNING;
ex_stop(sc);
} else {
ex_init(sc);
}
break;
#ifdef NODEF
case SIOCGHWADDR:
DODEBUG(Start_End, printf("SIOCGHWADDR"););
bcopy((caddr_t)sc->sc_addr, (caddr_t)&ifr->ifr_data,
sizeof(sc->sc_addr));
break;
#endif
case SIOCADDMULTI:
DODEBUG(Start_End, printf("SIOCADDMULTI"););
case SIOCDELMULTI:
DODEBUG(Start_End, printf("SIOCDELMULTI"););
/* XXX Support not done yet. */
error = EINVAL;
break;
default:
DODEBUG(Start_End, printf("unknown"););
error = EINVAL;
}
splx(s);
DODEBUG(Start_End, printf("\nex_ioctl%d: finish\n", ifp->if_unit););
return(error);
}
static void
ex_reset(struct ex_softc *sc)
{
int s;
DODEBUG(Start_End, printf("ex_reset%d: start\n", unit););
s = splimp();
ex_stop(sc);
ex_init(sc);
splx(s);
DODEBUG(Start_End, printf("ex_reset%d: finish\n", unit););
return;
}
static void
ex_watchdog(struct ifnet *ifp)
{
struct ex_softc * sc = ifp->if_softc;
DODEBUG(Start_End, printf("ex_watchdog%d: start\n", ifp->if_unit););
ifp->if_flags &= ~IFF_OACTIVE;
DODEBUG(Status, printf("OIDLE watchdog\n"););
ifp->if_oerrors++;
ex_reset(sc);
ex_start(ifp);
DODEBUG(Start_End, printf("ex_watchdog%d: finish\n", ifp->if_unit););
return;
}
static u_short
eeprom_read(int iobase, int location)
{
int i;
u_short data = 0;
int ee_addr;
int read_cmd = location | EE_READ_CMD;
short ctrl_val = EECS;
ee_addr = iobase + EEPROM_REG;
outb(iobase + CMD_REG, Bank2_Sel);
outb(ee_addr, EECS);
for (i = 8; i >= 0; i--) {
short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI : ctrl_val;
outb(ee_addr, outval);
outb(ee_addr, outval | EESK);
DELAY(3);
outb(ee_addr, outval);
DELAY(2);
}
outb(ee_addr, ctrl_val);
for (i = 16; i > 0; i--) {
outb(ee_addr, ctrl_val | EESK);
DELAY(3);
data = (data << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0);
outb(ee_addr, ctrl_val);
DELAY(2);
}
ctrl_val &= ~EECS;
outb(ee_addr, ctrl_val | EESK);
DELAY(3);
outb(ee_addr, ctrl_val);
DELAY(2);
outb(iobase + CMD_REG, Bank0_Sel);
return(data);
}
#endif /* NEX > 0 */