Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
[ne2k_isa] Restore support for ne2k isa cards
Add the simplified ne2k_isa driver.  It is just a selective copy+paste
of the relevant parts from ns8390.c plus a little trivial hacking to
make it actually work.

It is true that the code is pretty ugly, but:
  a) ns8390.c is worse
  b) It is only 372 lines and no #ifdefs
  c) It works both in qemu/bochs and in real hardware
     and we all know it is easier to cleanup working code

Hope someone will find the time to rewrite this driver properly,
but until then at least for me this is an ok solution.

Signed-off-by: Pantelis Koukousoulas <pktoss@gmail.com>
  • Loading branch information
pkt authored and Michael Brown committed Nov 8, 2008
1 parent 180d99f commit dd34500
Show file tree
Hide file tree
Showing 2 changed files with 374 additions and 0 deletions.
373 changes: 373 additions & 0 deletions src/drivers/net/ne2k_isa.c
@@ -0,0 +1,373 @@
/**************************************************************************
ETHERBOOT - BOOTP/TFTP Bootstrap Program
Author: Martin Renters
Date: May/94
This code is based heavily on David Greenman's if_ed.c driver
Copyright (C) 1993-1994, David Greenman, Martin Renters.
This software may be used, modified, copied, distributed, and sold, in
both source and binary form provided that the above copyright and these
terms are retained. Under no circumstances are the authors responsible for
the proper functioning of this software, nor do the authors assume any
responsibility for damages incurred with its use.
Multicast support added by Timothy Legge (timlegge@users.sourceforge.net) 09/28/2003
Relocation support added by Ken Yap (ken_yap@users.sourceforge.net) 28/12/02
Card Detect support adapted from the eCos driver (Christian Plessl <cplessl@ee.ethz.ch>)
Extracted from ns8390.c and adapted by Pantelis Koukousoulas <pktoss@gmail.com>
**************************************************************************/

#include "ns8390.h"
#include "etherboot.h"
#include "nic.h"
#include <gpxe/ethernet.h>
#include <gpxe/isa.h>
#include <errno.h>

#define ASIC_PIO NE_DATA

static unsigned char eth_vendor, eth_flags;
static unsigned short eth_nic_base, eth_asic_base;
static unsigned char eth_memsize, eth_rx_start, eth_tx_start;
static Address eth_bmem, eth_rmem;
static unsigned char eth_drain_receiver;

static struct nic_operations ne_operations;
static void ne_reset(struct nic *nic, struct isa_device *isa);

static isa_probe_addr_t ne_probe_addrs[] = { 0x300, 0x280, 0x320, 0x340, 0x380, 0x220, };

/**************************************************************************
ETH_PIO_READ - Read a frame via Programmed I/O
**************************************************************************/
static void eth_pio_read(unsigned int src, unsigned char *dst, unsigned int cnt) {
outb(D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
outb(cnt, eth_nic_base + D8390_P0_RBCR0);
outb(cnt >> 8, eth_nic_base + D8390_P0_RBCR1);
outb(src, eth_nic_base + D8390_P0_RSAR0);
outb(src >> 8, eth_nic_base + D8390_P0_RSAR1);
outb(D8390_COMMAND_RD0 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
if (eth_flags & FLAG_16BIT)
cnt = (cnt + 1) >> 1;

while (cnt--) {
if (eth_flags & FLAG_16BIT) {
*((unsigned short *) dst) = inw(eth_asic_base + ASIC_PIO);
dst += 2;
} else
*(dst++) = inb(eth_asic_base + ASIC_PIO);
}
}

/**************************************************************************
ETH_PIO_WRITE - Write a frame via Programmed I/O
**************************************************************************/
static void eth_pio_write(const unsigned char *src, unsigned int dst,
unsigned int cnt) {
outb(D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
outb(D8390_ISR_RDC, eth_nic_base + D8390_P0_ISR);
outb(cnt, eth_nic_base + D8390_P0_RBCR0);
outb(cnt >> 8, eth_nic_base + D8390_P0_RBCR1);
outb(dst, eth_nic_base + D8390_P0_RSAR0);
outb(dst >> 8, eth_nic_base + D8390_P0_RSAR1);
outb(D8390_COMMAND_RD1 | D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
if (eth_flags & FLAG_16BIT)
cnt = (cnt + 1) >> 1;

while (cnt--) {

if (eth_flags & FLAG_16BIT) {
outw(*((unsigned short *) src), eth_asic_base + ASIC_PIO);
src += 2;
} else
outb(*(src++), eth_asic_base + ASIC_PIO);
}
}

/**************************************************************************
enable_multicast - Enable Multicast
**************************************************************************/
static void enable_multicast(unsigned short eth_nic_base) {
unsigned char mcfilter[8];
int i;

memset(mcfilter, 0xFF, 8);
outb(4, eth_nic_base + D8390_P0_RCR);
outb(D8390_COMMAND_RD2 + D8390_COMMAND_PS1, eth_nic_base + D8390_P0_COMMAND);
for (i = 0; i < 8; i++) {
outb(mcfilter[i], eth_nic_base + 8 + i);
if (inb(eth_nic_base + 8 + i) != mcfilter[i])
DBG("Error SMC 83C690 Multicast filter read/write mishap %d\n",
i);
}
outb(D8390_COMMAND_RD2 + D8390_COMMAND_PS0, eth_nic_base + D8390_P0_COMMAND);
outb(4 | 0x08, eth_nic_base + D8390_P0_RCR);
}

/**************************************************************************
NE_PROBE1 - Look for an adapter on the ISA bus
**************************************************************************/
static int ne_probe1(isa_probe_addr_t ioaddr) {
//From the eCos driver
unsigned int regd;
unsigned int state;

state = inb(ioaddr);
outb(ioaddr, D8390_COMMAND_RD2 | D8390_COMMAND_PS1 | D8390_COMMAND_STP);
regd = inb(ioaddr + D8390_P0_TCR);

if (inb(ioaddr + D8390_P0_TCR)) {
outb(ioaddr, state);
outb(ioaddr + 0x0d, regd);
return 0;
}

return 1;
}

/**************************************************************************
NE_PROBE - Initialize an adapter ???
**************************************************************************/
static int ne_probe(struct nic *nic, struct isa_device *isa) {
int i;
unsigned char c;
unsigned char romdata[16];
unsigned char testbuf[32];

eth_vendor = VENDOR_NONE;
eth_drain_receiver = 0;

nic->irqno = 0;
nic->ioaddr = isa->ioaddr;
eth_nic_base = isa->ioaddr;

/******************************************************************
Search for NE1000/2000 if no WD/SMC or 3com cards
******************************************************************/
if (eth_vendor == VENDOR_NONE) {

static unsigned char test[] = "NE*000 memory";

eth_bmem = 0; /* No shared memory */

eth_flags = FLAG_PIO;
eth_asic_base = eth_nic_base + NE_ASIC_OFFSET;
eth_memsize = MEM_16384;
eth_tx_start = 32;
eth_rx_start = 32 + D8390_TXBUF_SIZE;
c = inb(eth_asic_base + NE_RESET);
outb(c, eth_asic_base + NE_RESET);
(void) inb(0x84);
outb(D8390_COMMAND_STP | D8390_COMMAND_RD2, eth_nic_base
+ D8390_P0_COMMAND);
outb(D8390_RCR_MON, eth_nic_base + D8390_P0_RCR);
outb(D8390_DCR_FT1 | D8390_DCR_LS, eth_nic_base + D8390_P0_DCR);
outb(MEM_8192, eth_nic_base + D8390_P0_PSTART);
outb(MEM_16384, eth_nic_base + D8390_P0_PSTOP);
eth_pio_write((unsigned char *) test, 8192, sizeof(test));
eth_pio_read(8192, testbuf, sizeof(test));
if (!memcmp(test, testbuf, sizeof(test)))
goto out;
eth_flags |= FLAG_16BIT;
eth_memsize = MEM_32768;
eth_tx_start = 64;
eth_rx_start = 64 + D8390_TXBUF_SIZE;
outb(D8390_DCR_WTS | D8390_DCR_FT1 | D8390_DCR_LS, eth_nic_base
+ D8390_P0_DCR);
outb(MEM_16384, eth_nic_base + D8390_P0_PSTART);
outb(MEM_32768, eth_nic_base + D8390_P0_PSTOP);
eth_pio_write((unsigned char *) test, 16384, sizeof(test));
eth_pio_read(16384, testbuf, sizeof(test));
if (!memcmp(testbuf, test, sizeof(test)))
goto out;


out:
if (eth_nic_base == 0)
return (0);
if (eth_nic_base > ISA_MAX_ADDR) /* PCI probably */
eth_flags |= FLAG_16BIT;
eth_vendor = VENDOR_NOVELL;
eth_pio_read(0, romdata, sizeof(romdata));
for (i = 0; i < ETH_ALEN; i++) {
nic->node_addr[i] = romdata[i + ((eth_flags & FLAG_16BIT) ? i : 0)];
}
nic->ioaddr = eth_nic_base;
DBG("\nNE%c000 base %4.4x, MAC Addr %s\n",
(eth_flags & FLAG_16BIT) ? '2' : '1', eth_nic_base, eth_ntoa(
nic->node_addr));
}

if (eth_vendor == VENDOR_NONE)
return (0);

if (eth_vendor != VENDOR_3COM)
eth_rmem = eth_bmem;

ne_reset(nic, isa);
nic->nic_op = &ne_operations;
return 1;
}


/**************************************************************************
NE_DISABLE - Turn off adapter
**************************************************************************/
static void ne_disable(struct nic *nic, struct isa_device *isa) {
ne_reset(nic, isa);
}


/**************************************************************************
NE_RESET - Reset adapter
**************************************************************************/
static void ne_reset(struct nic *nic, struct isa_device *isa __unused)
{
int i;

eth_drain_receiver = 0;
outb(D8390_COMMAND_PS0 | D8390_COMMAND_RD2 |
D8390_COMMAND_STP, eth_nic_base+D8390_P0_COMMAND);
if (eth_flags & FLAG_16BIT)
outb(0x49, eth_nic_base+D8390_P0_DCR);
else
outb(0x48, eth_nic_base+D8390_P0_DCR);
outb(0, eth_nic_base+D8390_P0_RBCR0);
outb(0, eth_nic_base+D8390_P0_RBCR1);
outb(0x20, eth_nic_base+D8390_P0_RCR); /* monitor mode */
outb(2, eth_nic_base+D8390_P0_TCR);
outb(eth_tx_start, eth_nic_base+D8390_P0_TPSR);
outb(eth_rx_start, eth_nic_base+D8390_P0_PSTART);

outb(eth_memsize, eth_nic_base+D8390_P0_PSTOP);
outb(eth_memsize - 1, eth_nic_base+D8390_P0_BOUND);
outb(0xFF, eth_nic_base+D8390_P0_ISR);
outb(0, eth_nic_base+D8390_P0_IMR);
outb(D8390_COMMAND_PS1 |
D8390_COMMAND_RD2 | D8390_COMMAND_STP, eth_nic_base+D8390_P0_COMMAND);

for (i=0; i<ETH_ALEN; i++)
outb(nic->node_addr[i], eth_nic_base+D8390_P1_PAR0+i);
for (i=0; i<ETH_ALEN; i++)
outb(0xFF, eth_nic_base+D8390_P1_MAR0+i);
outb(eth_rx_start, eth_nic_base+D8390_P1_CURR);
outb(D8390_COMMAND_PS0 |
D8390_COMMAND_RD2 | D8390_COMMAND_STA, eth_nic_base+D8390_P0_COMMAND);
outb(0xFF, eth_nic_base+D8390_P0_ISR);
outb(0, eth_nic_base+D8390_P0_TCR); /* transmitter on */
outb(4, eth_nic_base+D8390_P0_RCR); /* allow rx broadcast frames */

enable_multicast(eth_nic_base);
}


/**************************************************************************
NE_POLL - Wait for a frame
**************************************************************************/
static int ne_poll(struct nic *nic __unused, int retrieve __unused)
{
int ret = 0;
unsigned char rstat, curr, next;
unsigned short len, frag;
unsigned short pktoff;
unsigned char *p;
struct ringbuffer pkthdr;

rstat = inb(eth_nic_base+D8390_P0_RSR);
if (!(rstat & D8390_RSTAT_PRX)) return(0);
next = inb(eth_nic_base+D8390_P0_BOUND)+1;
if (next >= eth_memsize) next = eth_rx_start;
outb(D8390_COMMAND_PS1, eth_nic_base+D8390_P0_COMMAND);
curr = inb(eth_nic_base+D8390_P1_CURR);
outb(D8390_COMMAND_PS0, eth_nic_base+D8390_P0_COMMAND);
if (curr >= eth_memsize) curr=eth_rx_start;
if (curr == next) return(0);

if ( ! retrieve ) return 1;

pktoff = next << 8;
if (eth_flags & FLAG_PIO)
eth_pio_read(pktoff, (unsigned char *)&pkthdr, 4);
else
memcpy(&pkthdr, bus_to_virt(eth_rmem + pktoff), 4);
pktoff += sizeof(pkthdr);
/* incoming length includes FCS so must sub 4 */
len = pkthdr.len - 4;
if ((pkthdr.status & D8390_RSTAT_PRX) == 0 || len < ETH_ZLEN
|| len> ETH_FRAME_LEN) {
DBG("Bogus packet, ignoring\n");
return (0);
}
else {
p = nic->packet;
nic->packetlen = len; /* available to caller */
frag = (eth_memsize << 8) - pktoff;
if (len> frag) { /* We have a wrap-around */
/* read first part */
if (eth_flags & FLAG_PIO)
eth_pio_read(pktoff, p, frag);
else
memcpy(p, bus_to_virt(eth_rmem + pktoff), frag);
pktoff = eth_rx_start << 8;
p += frag;
len -= frag;
}
/* read second part */
if (eth_flags & FLAG_PIO)
eth_pio_read(pktoff, p, len);
else
memcpy(p, bus_to_virt(eth_rmem + pktoff), len);
ret = 1;
}
next = pkthdr.next; /* frame number of next packet */
if (next == eth_rx_start)
next = eth_memsize;
outb(next-1, eth_nic_base+D8390_P0_BOUND);
return(ret);
}


/**************************************************************************
NE_TRANSMIT - Transmit a frame
**************************************************************************/
static void ne_transmit(struct nic *nic, const char *d, /* Destination */
unsigned int t, /* Type */
unsigned int s, /* size */
const char *p) { /* Packet */

/* Programmed I/O */
unsigned short type;
type = (t >> 8) | (t << 8);
eth_pio_write((unsigned char *) d, eth_tx_start << 8, ETH_ALEN);
eth_pio_write(nic->node_addr, (eth_tx_start << 8) + ETH_ALEN, ETH_ALEN);
/* bcc generates worse code without (const+const) below */
eth_pio_write((unsigned char *) &type, (eth_tx_start << 8) + (ETH_ALEN
+ ETH_ALEN), 2);
eth_pio_write((unsigned char *) p, (eth_tx_start << 8) + ETH_HLEN, s);
s += ETH_HLEN;
if (s < ETH_ZLEN)
s = ETH_ZLEN;

outb(D8390_COMMAND_PS0 | D8390_COMMAND_RD2 | D8390_COMMAND_STA,
eth_nic_base + D8390_P0_COMMAND);
outb(eth_tx_start, eth_nic_base + D8390_P0_TPSR);
outb(s, eth_nic_base + D8390_P0_TBCR0);
outb(s >> 8, eth_nic_base + D8390_P0_TBCR1);

outb(D8390_COMMAND_PS0 | D8390_COMMAND_TXP | D8390_COMMAND_RD2
| D8390_COMMAND_STA, eth_nic_base + D8390_P0_COMMAND);
}

static struct nic_operations ne_operations = { .connect = dummy_connect,
.poll = ne_poll, .transmit = ne_transmit, .irq = dummy_irq,
};

ISA_DRIVER ( ne_driver, ne_probe_addrs, ne_probe1,
GENERIC_ISAPNP_VENDOR, 0x0600 );

DRIVER ( "ne", nic_driver, isapnp_driver, ne_driver,
ne_probe, ne_disable );

ISA_ROM("ne","NE1000/2000 and clones");
1 change: 1 addition & 0 deletions src/include/gpxe/errfile.h
Expand Up @@ -106,6 +106,7 @@
#define ERRFILE_e1000_hw ( ERRFILE_DRIVER | 0x00490000 )
#define ERRFILE_mtnic ( ERRFILE_DRIVER | 0x004a0000 )
#define ERRFILE_phantom ( ERRFILE_DRIVER | 0x004b0000 )
#define ERRFILE_ne2k_isa ( ERRFILE_DRIVER | 0x004c0000 )

#define ERRFILE_scsi ( ERRFILE_DRIVER | 0x00700000 )
#define ERRFILE_arbel ( ERRFILE_DRIVER | 0x00710000 )
Expand Down

0 comments on commit dd34500

Please sign in to comment.