sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/drivers/lance/lance.c
Cristiano Giuffrida 48c6bb79f4 Driver refactory for live update and crash recovery. 
SYSLIB CHANGES:
- DS calls to publish / retrieve labels consider endpoints instead of u32_t.

VFS CHANGES:
- mapdriver() only adds an entry in the dmap table in VFS.
- dev_up() is only executed upon reception of a driver up event.

INET CHANGES:
- INET no longer searches for existing drivers instances at startup.
- A newtwork driver is (re)initialized upon reception of a driver up event.
- Networking startup is now race-free by design. No need to waste 5 seconds
at startup any more.

DRIVER CHANGES:
- Every driver publishes driver up events when starting for the first time or
in case of restart when recovery actions must be taken in the upper layers.
- Driver up events are published by drivers through DS. 
- For regular drivers, VFS is normally the only subscriber, but not necessarily.
For instance, when the filter driver is in use, it must subscribe to driver
up events to initiate recovery.
- For network drivers, inet is the only subscriber for now.
- Every VFS driver is statically linked with libdriver, every network driver
is statically linked with libnetdriver.

DRIVER LIBRARIES CHANGES:
- Libdriver is extended to provide generic receive() and ds_publish() interfaces
for VFS drivers.
- driver_receive() is a wrapper for sef_receive() also used in driver_task()
to discard spurious messages that were meant to be delivered to a previous
version of the driver.
- driver_receive_mq() is the same as driver_receive() but integrates support
for queued messages.
- driver_announce() publishes a driver up event for VFS drivers and marks
the driver as initialized and expecting a DEV_OPEN message.
- Libnetdriver is introduced to provide similar receive() and ds_publish()
interfaces for network drivers (netdriver_announce() and netdriver_receive()).
- Network drivers all support live update with no state transfer now.

KERNEL CHANGES:
- Added kernel call statectl for state management. Used by driver_announce() to
unblock eventual callers sendrecing to the driver.
2010-04-08 13:41:35 +00:00

1768 lines
51 KiB
C
Raw Blame History

/*
* lance.c
*
* This file contains a ethernet device driver for AMD LANCE based ethernet
* cards.
*
* The valid messages and their parameters are:
*
* m_type DL_PORT DL_PROC DL_COUNT DL_MODE DL_ADDR DL_GRANT
* |------------+----------+---------+----------+---------+---------+---------|
* | HARDINT | | | | | | |
* |------------|----------|---------|----------|---------|---------|---------|
* | DL_WRITEV_S| port nr | proc nr | count | mode | | grant |
* |------------|----------|---------|----------|---------|---------|---------|
* | DL_READV_S | port nr | proc nr | count | | | grant |
* |------------|----------|---------|----------|---------|---------|---------|
* | DL_CONF | port nr | proc nr | | mode | address | |
* |------------|----------|---------|----------|---------|---------|---------|
* |DL_GETSTAT_S| port nr | proc nr | | | | grant |
* |------------|----------|---------|----------|---------|---------|---------|
* | DL_STOP | port_nr | | | | | |
* |------------|----------|---------|----------|---------|---------|---------|
*
* The messages sent are:
*
* m-type DL_POR T DL_PROC DL_COUNT DL_STAT DL_CLCK
* |------------|----------|---------|----------|---------|---------|
* |DL_TASK_REPL| port nr | proc nr | rd-count | err|stat| clock |
* |------------|----------|---------|----------|---------|---------|
*
* m_type m3_i1 m3_i2 m3_ca1
* |------------+---------+-----------+---------------|
* |DL_CONF_REPL| port nr | last port | ethernet addr |
* |------------|---------|-----------|---------------|
*
* Created: Jul 27, 2002 by Kazuya Kodama <kazuya@nii.ac.jp>
* Adapted for Minix 3: Sep 05, 2005 by Joren l'Ami <jwlami@cs.vu.nl>
*/
#define VERBOSE 0 /* Verbose debugging output */
#define LANCE_FKEY 0 /* Use function key to dump Lance stats */
#include <minix/drivers.h>
#include <minix/netdriver.h>
#include <net/hton.h>
#include <net/gen/ether.h>
#include <net/gen/eth_io.h>
#include <assert.h>
#include <minix/syslib.h>
#include <minix/endpoint.h>
#include <machine/pci.h>
#include <minix/ds.h>
#include "lance.h"
static ether_card_t ec_table[EC_PORT_NR_MAX];
static int eth_tasknr= ANY;
static u16_t eth_ign_proto;
/* Configuration */
typedef struct ec_conf
{
port_t ec_port;
int ec_irq;
phys_bytes ec_mem;
char *ec_envvar;
} ec_conf_t;
/* We hardly use these. Just "LANCE0=on/off" "LANCE1=on/off" mean. */
ec_conf_t ec_conf[]= /* Card addresses */
{
/* I/O port, IRQ, Buffer address, Env. var, Buf selector. */
{ 0x1000, 9, 0x00000, "LANCE0" },
{ 0xD000, 15, 0x00000, "LANCE1" },
};
/* Actually, we use PCI-BIOS info. */
PRIVATE struct pcitab
{
u16_t vid;
u16_t did;
int checkclass;
} pcitab[]=
{
{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LANCE, 0 }, /* AMD LANCE */
{ 0x0000, 0x0000, 0 }
};
/* General */
_PROTOTYPE( static void do_init, (message *mp) );
_PROTOTYPE( static void ec_init, (ether_card_t *ec) );
_PROTOTYPE( static void ec_confaddr, (ether_card_t *ec) );
_PROTOTYPE( static void ec_reinit, (ether_card_t *ec) );
_PROTOTYPE( static void ec_check_ints, (ether_card_t *ec) );
_PROTOTYPE( static void conf_hw, (ether_card_t *ec) );
_PROTOTYPE( static void update_conf, (ether_card_t *ec, ec_conf_t *ecp) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static void do_int, (ether_card_t *ec) );
_PROTOTYPE( static void reply,
(ether_card_t *ec, int err, int may_block) );
_PROTOTYPE( static void ec_reset, (ether_card_t *ec) );
_PROTOTYPE( static void ec_send, (ether_card_t *ec) );
_PROTOTYPE( static void ec_recv, (ether_card_t *ec) );
_PROTOTYPE( static void do_vwrite_s,
(message *mp, int from_int) );
_PROTOTYPE( static void do_vread_s, (const message *mp) );
_PROTOTYPE( static void ec_user2nic,
(ether_card_t *dep, iovec_dat_t *iovp,
vir_bytes offset, int nic_addr,
vir_bytes count) );
_PROTOTYPE( static void ec_nic2user,
(ether_card_t *ec, int nic_addr,
iovec_dat_t *iovp, vir_bytes offset,
vir_bytes count) );
_PROTOTYPE( static int calc_iovec_size, (iovec_dat_t *iovp) );
_PROTOTYPE( static void ec_next_iovec, (iovec_dat_t *iovp) );
_PROTOTYPE( static void do_getstat_s, (message *mp) );
_PROTOTYPE( static void do_stop, (message *mp) );
_PROTOTYPE( static void do_getname, (message *mp) );
_PROTOTYPE( static void lance_dump, (void) );
_PROTOTYPE( static void getAddressing, (int devind, ether_card_t *ec) );
/* probe+init LANCE cards */
_PROTOTYPE( static int lance_probe, (ether_card_t *ec) );
_PROTOTYPE( static void lance_init_card, (ether_card_t *ec) );
/* Accesses Lance Control and Status Registers */
_PROTOTYPE( static u8_t in_byte, (port_t port) );
_PROTOTYPE( static u16_t in_word, (port_t port) );
_PROTOTYPE( static void out_word, (port_t port, u16_t value) );
_PROTOTYPE( static u16_t read_csr, (port_t ioaddr, u16_t csrno) );
_PROTOTYPE( static void write_csr, (port_t ioaddr, u16_t csrno, u16_t value));
/* --- LANCE --- */
/* General */
#define Address unsigned long
#define virt_to_bus(x) (vir2phys((unsigned long)x))
unsigned long vir2phys( unsigned long x )
{
int r;
unsigned long value;
if ( (r=sys_umap( SELF, VM_D, x, 4, &value )) != OK ) {
printf("lance: umap of 0x%lx failed\n",x );
panic("sys_umap failed: %d", r);
}
return value;
}
/* DMA limitations */
#define DMA_ADDR_MASK 0xFFFFFF /* mask to verify DMA address is 24-bit */
#define CORRECT_DMA_MEM() ( (virt_to_bus(lance_buf + sizeof(struct lance_interface)) & ~DMA_ADDR_MASK) == 0 )
#define ETH_FRAME_LEN 1518
#define LANCE_MUST_PAD 0x00000001
#define LANCE_ENABLE_AUTOSELECT 0x00000002
#define LANCE_SELECT_PHONELINE 0x00000004
#define LANCE_MUST_UNRESET 0x00000008
static const struct lance_chip_type
{
int id_number;
const char *name;
int flags;
} chip_table[] = {
{0x0000, "LANCE 7990", /* Ancient lance chip. */
LANCE_MUST_PAD + LANCE_MUST_UNRESET},
{0x0003, "PCnet/ISA 79C960", /* 79C960 PCnet/ISA. */
LANCE_ENABLE_AUTOSELECT},
{0x2260, "PCnet/ISA+ 79C961", /* 79C961 PCnet/ISA+, Plug-n-Play. */
LANCE_ENABLE_AUTOSELECT},
{0x2420, "PCnet/PCI 79C970", /* 79C970 or 79C974 PCnet-SCSI, PCI. */
LANCE_ENABLE_AUTOSELECT},
{0x2430, "PCnet32", /* 79C965 PCnet for VL bus. */
LANCE_ENABLE_AUTOSELECT},
{0x2621, "PCnet/PCI-II 79C970A", /* 79C970A PCInetPCI II. */
LANCE_ENABLE_AUTOSELECT},
{0x2625, "PCnet-FAST III 79C973",/* 79C973 PCInet-FAST III. */
LANCE_ENABLE_AUTOSELECT},
{0x2626, "PCnet/HomePNA 79C978",
LANCE_ENABLE_AUTOSELECT|LANCE_SELECT_PHONELINE},
{0x0, "PCnet (unknown)",
LANCE_ENABLE_AUTOSELECT},
};
/* ############## for LANCE device ############## */
#define LANCE_ETH_ADDR 0x0
#define LANCE_DATA 0x10
#define LANCE_ADDR 0x12
#define LANCE_RESET 0x14
#define LANCE_BUS_IF 0x16
#define LANCE_TOTAL_SIZE 0x18
/* Use 2^4=16 {Rx,Tx} buffers */
#define LANCE_LOG_RX_BUFFERS 4
#define RX_RING_SIZE (1 << (LANCE_LOG_RX_BUFFERS))
#define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
#define RX_RING_LEN_BITS ((LANCE_LOG_RX_BUFFERS) << 29)
#define LANCE_LOG_TX_BUFFERS 4
#define TX_RING_SIZE (1 << (LANCE_LOG_TX_BUFFERS))
#define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
#define TX_RING_LEN_BITS ((LANCE_LOG_TX_BUFFERS) << 29)
/* for lance_interface */
struct lance_init_block
{
unsigned short mode;
unsigned char phys_addr[6];
unsigned long filter[2];
Address rx_ring;
Address tx_ring;
};
struct lance_rx_head
{
union {
Address base;
unsigned char addr[4];
} u;
short buf_length; /* 2s complement */
short msg_length;
};
struct lance_tx_head
{
union {
Address base;
unsigned char addr[4];
} u;
short buf_length; /* 2s complement */
short misc;
};
struct lance_interface
{
struct lance_init_block init_block;
struct lance_rx_head rx_ring[RX_RING_SIZE];
struct lance_tx_head tx_ring[TX_RING_SIZE];
unsigned char rbuf[RX_RING_SIZE][ETH_FRAME_LEN];
unsigned char tbuf[TX_RING_SIZE][ETH_FRAME_LEN];
};
/* =============== global variables =============== */
static struct lance_interface *lp;
#define LANCE_BUF_SIZE (sizeof(struct lance_interface))
static char *lance_buf = NULL;
static int rx_slot_nr = 0; /* Rx-slot number */
static int tx_slot_nr = 0; /* Tx-slot number */
static int cur_tx_slot_nr = 0; /* Tx-slot number */
static char isstored[TX_RING_SIZE]; /* Tx-slot in-use */
static const char *progname;
phys_bytes lance_buf_phys;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
EXTERN char **env_argv;
/*===========================================================================*
* main *
*===========================================================================*/
void main( int argc, char **argv )
{
message m;
int ipc_status;
int i,r;
ether_card_t *ec;
/* SEF local startup. */
env_setargs(argc, argv);
sef_local_startup();
while (TRUE)
{
for (i=0;i<EC_PORT_NR_MAX;++i)
{
ec= &ec_table[i];
if (ec->ec_irq != 0)
sys_irqenable(&ec->ec_hook);
}
if ((r= netdriver_receive(ANY, &m, &ipc_status)) != OK)
panic("netdriver_receive failed: %d", r);
for (i=0;i<EC_PORT_NR_MAX;++i)
{
ec= &ec_table[i];
if (ec->ec_irq != 0)
sys_irqdisable(&ec->ec_hook);
}
if (is_ipc_notify(ipc_status)) {
switch(_ENDPOINT_P(m.m_source)) {
case TTY_PROC_NR:
lance_dump();
break;
case HARDWARE:
for (i=0;i<EC_PORT_NR_MAX;++i)
{
ec= &ec_table[i];
if (ec->mode != EC_ENABLED)
continue;
{
ec->ec_int_pending = 0;
ec_check_ints(ec);
do_int(ec);
}
}
break;
default:
panic("illegal notify source: %d", m.m_source);
}
/* get next message */
continue;
}
switch (m.m_type)
{
case DL_WRITEV_S:
do_vwrite_s(&m, FALSE);
break;
case DL_READV_S:
do_vread_s(&m);
break;
case DL_CONF:
do_init(&m);
break;
case DL_GETSTAT_S:
do_getstat_s(&m);
break;
case DL_STOP:
do_stop(&m);
break;
case DL_GETNAME:
do_getname(&m);
break;
default:
panic("illegal message: %d", m.m_type);
}
}
}
/*===========================================================================*
* sef_local_startup *
*===========================================================================*/
PRIVATE void sef_local_startup()
{
/* Register init callbacks. */
sef_setcb_init_fresh(sef_cb_init_fresh);
sef_setcb_init_lu(sef_cb_init_fresh);
sef_setcb_init_restart(sef_cb_init_fresh);
/* Register live update callbacks. */
sef_setcb_lu_prepare(sef_cb_lu_prepare_always_ready);
sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_workfree);
/* Register signal callbacks. */
sef_setcb_signal_handler(sef_cb_signal_handler);
/* Let SEF perform startup. */
sef_startup();
}
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *UNUSED(info))
{
/* Initialize the lance driver. */
int r;
long v;
#if LANCE_FKEY
int fkeys, sfkeys;
#endif
(progname=strrchr(env_argv[0],'/')) ? progname++ : (progname=env_argv[0]);
#if LANCE_FKEY
fkeys = sfkeys = 0;
bit_set( sfkeys, 7 );
if ( (r = fkey_map(&fkeys, &sfkeys)) != OK )
printf("Warning: lance couldn't observe Shift+F7 key: %d\n",r);
#endif
v= 0;
(void) env_parse("ETH_IGN_PROTO", "x", 0, &v, 0x0000L, 0xFFFFL);
eth_ign_proto= htons((u16_t) v);
/* Announce we are up! */
netdriver_announce();
return OK;
}
/*===========================================================================*
* sef_cb_signal_handler *
*===========================================================================*/
PRIVATE void sef_cb_signal_handler(int signo)
{
message mess;
int i;
/* Only check for termination signal, ignore anything else. */
if (signo != SIGTERM) return;
for (i= 0; i<EC_PORT_NR_MAX; i++)
{
if (ec_table[i].mode != EC_ENABLED)
continue;
mess.m_type= DL_STOP;
mess.DL_PORT= i;
do_stop(&mess);
}
#if VERBOSE
printf("LANCE driver stopped.\n");
#endif
exit(0);
}
/*===========================================================================*
* lance_dump *
*===========================================================================*/
static void lance_dump()
{
ether_card_t *ec;
int i, isr, csr;
unsigned short ioaddr;
printf("\n");
for (i= 0, ec = &ec_table[0]; i<EC_PORT_NR_MAX; i++, ec++)
{
if (ec->mode == EC_DISABLED)
printf("lance port %d is disabled\n", i);
else if (ec->mode == EC_SINK)
printf("lance port %d is in sink mode\n", i);
if (ec->mode != EC_ENABLED)
continue;
printf("lance statistics of port %d:\n", i);
printf("recvErr :%8ld\t", ec->eth_stat.ets_recvErr);
printf("sendErr :%8ld\t", ec->eth_stat.ets_sendErr);
printf("OVW :%8ld\n", ec->eth_stat.ets_OVW);
printf("CRCerr :%8ld\t", ec->eth_stat.ets_CRCerr);
printf("frameAll :%8ld\t", ec->eth_stat.ets_frameAll);
printf("missedP :%8ld\n", ec->eth_stat.ets_missedP);
printf("packetR :%8ld\t", ec->eth_stat.ets_packetR);
printf("packetT :%8ld\t", ec->eth_stat.ets_packetT);
printf("transDef :%8ld\n", ec->eth_stat.ets_transDef);
printf("collision :%8ld\t", ec->eth_stat.ets_collision);
printf("transAb :%8ld\t", ec->eth_stat.ets_transAb);
printf("carrSense :%8ld\n", ec->eth_stat.ets_carrSense);
printf("fifoUnder :%8ld\t", ec->eth_stat.ets_fifoUnder);
printf("fifoOver :%8ld\t", ec->eth_stat.ets_fifoOver);
printf("CDheartbeat:%8ld\n", ec->eth_stat.ets_CDheartbeat);
printf("OWC :%8ld\t", ec->eth_stat.ets_OWC);
ioaddr = ec->ec_port;
isr = read_csr(ioaddr, LANCE_CSR0);
printf("isr = 0x%x, flags = 0x%x\n", isr,
ec->flags);
printf("irq = %d\tioadr = 0x%x\n", ec->ec_irq, ec->ec_port);
csr = read_csr(ioaddr, LANCE_CSR0);
printf("CSR0: 0x%x\n", csr);
csr = read_csr(ioaddr, LANCE_CSR3);
printf("CSR3: 0x%x\n", csr);
csr = read_csr(ioaddr, LANCE_CSR4);
printf("CSR4: 0x%x\n", csr);
csr = read_csr(ioaddr, LANCE_CSR5);
printf("CSR5: 0x%x\n", csr);
csr = read_csr(ioaddr, LANCE_CSR15);
printf("CSR15: 0x%x\n", csr);
}
}
/*===========================================================================*
* do_init *
*===========================================================================*/
static void do_init(mp)
message *mp;
{
int port;
ether_card_t *ec;
message reply_mess;
pci_init();
if(!lance_buf && !(lance_buf = alloc_contig(LANCE_BUF_SIZE, AC_ALIGN4K|AC_LOWER16M, &lance_buf_phys))) {
panic("alloc_contig failed: %d", LANCE_BUF_SIZE);
}
port = mp->DL_PORT;
if (port < 0 || port >= EC_PORT_NR_MAX)
{
reply_mess.m_type= DL_CONF_REPLY;
reply_mess.m3_i1= ENXIO;
mess_reply(mp, &reply_mess);
return;
}
ec= &ec_table[port];
strcpy(ec->port_name, "eth_card#0");
ec->port_name[9] += port;
if (ec->mode == EC_DISABLED)
{
/* This is the default, try to (re)locate the device. */
/* only try to enable if memory is correct for DMA */
if ( CORRECT_DMA_MEM() )
{
conf_hw(ec);
}
else
{
printf("LANCE: DMA denied because address out of range\n" );
}
if (ec->mode == EC_DISABLED)
{
/* Probe failed, or the device is configured off. */
reply_mess.m_type= DL_CONF_REPLY;
reply_mess.m3_i1= ENXIO;
mess_reply(mp, &reply_mess);
return;
}
if (ec->mode == EC_ENABLED)
ec_init(ec);
}
if (ec->mode == EC_SINK)
{
ec->mac_address.ea_addr[0] =
ec->mac_address.ea_addr[1] =
ec->mac_address.ea_addr[2] =
ec->mac_address.ea_addr[3] =
ec->mac_address.ea_addr[4] =
ec->mac_address.ea_addr[5] = 0;
ec_confaddr(ec);
reply_mess.m_type = DL_CONF_REPLY;
reply_mess.m3_i1 = mp->DL_PORT;
reply_mess.m3_i2 = EC_PORT_NR_MAX;
*(ether_addr_t *) reply_mess.m3_ca1 = ec->mac_address;
mess_reply(mp, &reply_mess);
return;
}
assert(ec->mode == EC_ENABLED);
assert(ec->flags & ECF_ENABLED);
ec->flags &= ~(ECF_PROMISC | ECF_MULTI | ECF_BROAD);
if (mp->DL_MODE & DL_PROMISC_REQ)
ec->flags |= ECF_PROMISC | ECF_MULTI | ECF_BROAD;
if (mp->DL_MODE & DL_MULTI_REQ)
ec->flags |= ECF_MULTI;
if (mp->DL_MODE & DL_BROAD_REQ)
ec->flags |= ECF_BROAD;
ec->client = mp->m_source;
ec_reinit(ec);
reply_mess.m_type = DL_CONF_REPLY;
reply_mess.m3_i1 = mp->DL_PORT;
reply_mess.m3_i2 = EC_PORT_NR_MAX;
*(ether_addr_t *) reply_mess.m3_ca1 = ec->mac_address;
mess_reply(mp, &reply_mess);
}
/*===========================================================================*
* do_int *
*===========================================================================*/
static void do_int(ec)
ether_card_t *ec;
{
if (ec->flags & (ECF_PACK_SEND | ECF_PACK_RECV))
reply(ec, OK, TRUE);
}
/*===========================================================================*
* conf_hw *
*===========================================================================*/
static void conf_hw(ec)
ether_card_t *ec;
{
static eth_stat_t empty_stat = {0, 0, 0, 0, 0, 0 /* ,... */ };
int ifnr;
ec_conf_t *ecp;
ec->mode= EC_DISABLED; /* Superfluous */
ifnr= ec-ec_table;
ecp= &ec_conf[ifnr];
update_conf(ec, ecp);
if (ec->mode != EC_ENABLED)
return;
if (!lance_probe(ec))
{
printf("%s: No ethernet card found on PCI-BIOS info.\n",
ec->port_name);
ec->mode= EC_DISABLED;
return;
}
/* XXX */ if (ec->ec_linmem == 0) ec->ec_linmem= 0xFFFF0000;
ec->flags = ECF_EMPTY;
ec->eth_stat = empty_stat;
}
/*===========================================================================*
* update_conf *
*===========================================================================*/
static void update_conf(ec, ecp)
ether_card_t *ec;
ec_conf_t *ecp;
{
long v;
static char ec_fmt[] = "x:d:x:x";
/* Get the default settings and modify them from the environment. */
ec->mode= EC_SINK;
v= ecp->ec_port;
switch (env_parse(ecp->ec_envvar, ec_fmt, 0, &v, 0x0000L, 0xFFFFL))
{
case EP_OFF:
ec->mode= EC_DISABLED;
break;
case EP_ON:
case EP_SET:
default:
ec->mode= EC_ENABLED; /* Might become disabled if
* all probes fail */
break;
}
ec->ec_port= v;
v= ecp->ec_irq | DEI_DEFAULT;
(void) env_parse(ecp->ec_envvar, ec_fmt, 1, &v, 0L,
(long) NR_IRQ_VECTORS - 1);
ec->ec_irq= v;
v= ecp->ec_mem;
(void) env_parse(ecp->ec_envvar, ec_fmt, 2, &v, 0L, 0xFFFFFL);
ec->ec_linmem= v;
v= 0;
(void) env_parse(ecp->ec_envvar, ec_fmt, 3, &v, 0x2000L, 0x8000L);
ec->ec_ramsize= v;
}
/*===========================================================================*
* ec_init *
*===========================================================================*/
static void ec_init(ec)
ether_card_t *ec;
{
int i, r;
/* General initialization */
ec->flags = ECF_EMPTY;
lance_init_card(ec); /* Get mac_address, etc ...*/
ec_confaddr(ec);
#if VERBOSE
printf("%s: Ethernet address ", ec->port_name);
for (i= 0; i < 6; i++)
printf("%x%c", ec->mac_address.ea_addr[i],
i < 5 ? ':' : '\n');
#endif
/* Finish the initialization */
ec->flags |= ECF_ENABLED;
/* Set the interrupt handler */
ec->ec_hook = ec->ec_irq;
if ((r=sys_irqsetpolicy(ec->ec_irq, 0, &ec->ec_hook)) != OK)
printf("lance: error, couldn't set IRQ policy: %d\n", r);
return;
}
/*===========================================================================*
* reply *
*===========================================================================*/
static void reply(ec, err, may_block)
ether_card_t *ec;
int err;
int may_block;
{
message reply;
int status,r;
clock_t now;
status = 0;
if (ec->flags & ECF_PACK_SEND)
status |= DL_PACK_SEND;
if (ec->flags & ECF_PACK_RECV)
status |= DL_PACK_RECV;
reply.m_type = DL_TASK_REPLY;
reply.DL_PORT = ec - ec_table;
reply.DL_PROC = ec->client;
reply.DL_STAT = status | ((u32_t) err << 16);
reply.DL_COUNT = ec->read_s;
if ((r=getuptime(&now)) != OK)
panic("getuptime() failed: %d", r);
reply.DL_CLCK = now;
r = send(ec->client, &reply);
if (r == ELOCKED && may_block)
{
return;
}
if (r < 0)
panic("send failed: %d", r);
ec->read_s = 0;
ec->flags &= ~(ECF_PACK_SEND | ECF_PACK_RECV);
}
/*===========================================================================*
* mess_reply *
*===========================================================================*/
static void mess_reply(req, reply_mess)
message *req;
message *reply_mess;
{
if (send(req->m_source, reply_mess) != OK)
panic("unable to mess_reply");
}
/*===========================================================================*
* ec_confaddr *
*===========================================================================*/
static void ec_confaddr(ec)
ether_card_t *ec;
{
int i;
char eakey[16];
static char eafmt[]= "x:x:x:x:x:x";
long v;
/* User defined ethernet address? */
strcpy(eakey, ec_conf[ec-ec_table].ec_envvar);
strcat(eakey, "_EA");
for (i = 0; i < 6; i++)
{
v= ec->mac_address.ea_addr[i];
if (env_parse(eakey, eafmt, i, &v, 0x00L, 0xFFL) != EP_SET)
break;
ec->mac_address.ea_addr[i]= v;
}
if (i != 0 && i != 6)
{
/* It's all or nothing; force a panic. */
(void) env_parse(eakey, "?", 0, &v, 0L, 0L);
}
}
/*===========================================================================*
* ec_reinit *
*===========================================================================*/
static void ec_reinit(ec)
ether_card_t *ec;
{
int i;
unsigned short ioaddr = ec->ec_port;
/* stop */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STOP);
/* purge Tx-ring */
tx_slot_nr = cur_tx_slot_nr = 0;
for (i=0; i<TX_RING_SIZE; i++)
{
lp->tx_ring[i].u.base = 0;
isstored[i]=0;
}
/* re-init Rx-ring */
rx_slot_nr = 0;
for (i=0; i<RX_RING_SIZE; i++)
{
lp->rx_ring[i].buf_length = -ETH_FRAME_LEN;
lp->rx_ring[i].u.addr[3] |= 0x80;
}
/* Set 'Receive Mode' */
if (ec->flags & ECF_PROMISC)
{
write_csr(ioaddr, LANCE_CSR15, LANCE_CSR15_PROM);
}
else
{
if (ec->flags & (ECF_BROAD | ECF_MULTI))
{
write_csr(ioaddr, LANCE_CSR15, 0x0000);
}
else
{
write_csr(ioaddr, LANCE_CSR15, LANCE_CSR15_DRCVBC);
}
}
/* start && enable interrupt */
write_csr(ioaddr, LANCE_CSR0,
LANCE_CSR0_IDON|LANCE_CSR0_IENA|LANCE_CSR0_STRT);
return;
}
/*===========================================================================*
* ec_check_ints *
*===========================================================================*/
static void ec_check_ints(ec)
ether_card_t *ec;
{
int must_restart = 0;
int check,status;
int isr = 0x0000;
unsigned short ioaddr = ec->ec_port;
if (!(ec->flags & ECF_ENABLED))
panic("got premature interrupt");
for (;;)
{
#if VERBOSE
printf("ETH: Reading ISR...");
#endif
isr = read_csr(ioaddr, LANCE_CSR0);
if (isr & (LANCE_CSR0_ERR|LANCE_CSR0_RINT|LANCE_CSR0_TINT)) {
write_csr(ioaddr, LANCE_CSR0,
isr & ~(LANCE_CSR0_IENA|LANCE_CSR0_TDMD|LANCE_CSR0_STOP
|LANCE_CSR0_STRT|LANCE_CSR0_INIT) );
}
write_csr(ioaddr, LANCE_CSR0,
LANCE_CSR0_BABL|LANCE_CSR0_CERR|LANCE_CSR0_MISS|LANCE_CSR0_MERR
|LANCE_CSR0_IDON|LANCE_CSR0_IENA);
#define ISR_RST 0x0000
if ((isr & (LANCE_CSR0_TINT|LANCE_CSR0_RINT|LANCE_CSR0_MISS
|LANCE_CSR0_BABL|LANCE_CSR0_ERR)) == 0x0000)
{
#if VERBOSE
printf("OK\n");
#endif
break;
}
if (isr & LANCE_CSR0_MISS)
{
#if VERBOSE
printf("RX Missed Frame\n");
#endif
ec->eth_stat.ets_recvErr++;
}
if ((isr & LANCE_CSR0_BABL) || (isr & LANCE_CSR0_TINT))
{
if (isr & LANCE_CSR0_BABL)
{
#if VERBOSE
printf("TX Timeout\n");
#endif
ec->eth_stat.ets_sendErr++;
}
if (isr & LANCE_CSR0_TINT)
{
#if VERBOSE
printf("TX INT\n");
#endif
/* status check: restart if needed. */
status = lp->tx_ring[cur_tx_slot_nr].u.base;
/* ??? */
if (status & 0x40000000)
{
status = lp->tx_ring[cur_tx_slot_nr].misc;
ec->eth_stat.ets_sendErr++;
if (status & 0x0400)
ec->eth_stat.ets_transAb++;
if (status & 0x0800)
ec->eth_stat.ets_carrSense++;
if (status & 0x1000)
ec->eth_stat.ets_OWC++;
if (status & 0x4000)
{
ec->eth_stat.ets_fifoUnder++;
must_restart=1;
}
}
else
{
if (status & 0x18000000)
ec->eth_stat.ets_collision++;
ec->eth_stat.ets_packetT++;
}
}
/* transmit a packet on the next slot if it exists. */
check = 0;
if (isstored[cur_tx_slot_nr]==1)
{
/* free the tx-slot just transmitted */
isstored[cur_tx_slot_nr]=0;
cur_tx_slot_nr = (++cur_tx_slot_nr) & TX_RING_MOD_MASK;
/* next tx-slot is ready? */
if (isstored[cur_tx_slot_nr]==1)
check=1;
else
check=0;
}
else
{
panic("got premature TX INT..");
}
if (check==1)
{
lp->tx_ring[cur_tx_slot_nr].u.addr[3] = 0x83;
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_IENA|LANCE_CSR0_TDMD);
}
else
if (check==-1)
continue;
/* we set a buffered message in the slot if it exists. */
/* and transmit it, if needed. */
if (ec->flags & ECF_SEND_AVAIL)
ec_send(ec);
}
if (isr & LANCE_CSR0_RINT)
{
#if VERBOSE
printf("RX INT\n");
#endif
ec_recv(ec);
}
if (isr & ISR_RST)
{
ec->flags = ECF_STOPPED;
#if VERBOSE
printf("ISR_RST\n");
#endif
break;
}
/* ??? cf. lance driver on linux */
if (must_restart == 1)
{
#if VERBOSE
printf("ETH: restarting...\n");
#endif
/* stop */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STOP);
/* start */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STRT);
}
}
if ((ec->flags & (ECF_READING|ECF_STOPPED)) == (ECF_READING|ECF_STOPPED))
{
#if VERBOSE
printf("ETH: resetting...\n");
#endif
ec_reset(ec);
}
}
/*===========================================================================*
* ec_reset *
*===========================================================================*/
static void ec_reset(ec)
ether_card_t *ec;
{
/* Stop/start the chip, and clear all RX,TX-slots */
unsigned short ioaddr = ec->ec_port;
int i;
/* stop */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STOP);
/* start */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STRT);
/* purge Tx-ring */
tx_slot_nr = cur_tx_slot_nr = 0;
for (i=0; i<TX_RING_SIZE; i++)
{
lp->tx_ring[i].u.base = 0;
isstored[i]=0;
}
/* re-init Rx-ring */
rx_slot_nr = 0;
for (i=0; i<RX_RING_SIZE; i++)
{
lp->rx_ring[i].buf_length = -ETH_FRAME_LEN;
lp->rx_ring[i].u.addr[3] |= 0x80;
}
/* store a buffered message on the slot if exists */
ec_send(ec);
ec->flags &= ~ECF_STOPPED;
}
/*===========================================================================*
* ec_send *
*===========================================================================*/
static void ec_send(ec)
ether_card_t *ec;
{
/* from ec_check_ints() or ec_reset(). */
/* this function proccesses the buffered message. (slot/transmit) */
if (!(ec->flags & ECF_SEND_AVAIL))
return;
ec->flags &= ~ECF_SEND_AVAIL;
switch(ec->sendmsg.m_type)
{
case DL_WRITEV_S: do_vwrite_s(&ec->sendmsg, TRUE); break;
default:
panic("wrong type: %d", ec->sendmsg.m_type);
break;
}
}
/*===========================================================================*
* do_vread_s *
*===========================================================================*/
static void do_vread_s(const message *mp)
{
int port, count, r;
ether_card_t *ec;
port = mp->DL_PORT;
count = mp->DL_COUNT;
ec= &ec_table[port];
ec->client= mp->DL_PROC;
r = sys_safecopyfrom(mp->DL_PROC, mp->DL_GRANT, 0,
(vir_bytes)ec->read_iovec.iod_iovec,
(count > IOVEC_NR ? IOVEC_NR : count) *
sizeof(iovec_s_t), D);
if (r != OK)
panic("do_vread_s: sys_safecopyfrom failed: %d", r);
ec->read_iovec.iod_iovec_s = count;
ec->read_iovec.iod_proc_nr = mp->DL_PROC;
ec->read_iovec.iod_grant = (cp_grant_id_t) mp->DL_GRANT;
ec->read_iovec.iod_iovec_offset = 0;
ec->tmp_iovec = ec->read_iovec;
ec->flags |= ECF_READING;
ec_recv(ec);
if ((ec->flags & (ECF_READING|ECF_STOPPED)) == (ECF_READING|ECF_STOPPED))
ec_reset(ec);
reply(ec, OK, FALSE);
}
/*===========================================================================*
* ec_recv *
*===========================================================================*/
static void ec_recv(ec)
ether_card_t *ec;
{
vir_bytes length;
int packet_processed;
int status;
unsigned short ioaddr = ec->ec_port;
if ((ec->flags & ECF_READING)==0)
return;
if (!(ec->flags & ECF_ENABLED))
return;
/* we check all the received slots until find a properly received packet */
packet_processed = FALSE;
while (!packet_processed)
{
status = lp->rx_ring[rx_slot_nr].u.base >> 24;
if ( (status & 0x80) == 0x00 )
{
status = lp->rx_ring[rx_slot_nr].u.base >> 24;
/* ??? */
if (status != 0x03)
{
if (status & 0x01)
ec->eth_stat.ets_recvErr++;
if (status & 0x04)
ec->eth_stat.ets_fifoOver++;
if (status & 0x08)
ec->eth_stat.ets_CRCerr++;
if (status & 0x10)
ec->eth_stat.ets_OVW++;
if (status & 0x20)
ec->eth_stat.ets_frameAll++;
length = 0;
}
else
{
ec->eth_stat.ets_packetR++;
length = lp->rx_ring[rx_slot_nr].msg_length;
}
if (length > 0)
{
ec_nic2user(ec, (int)(lp->rbuf[rx_slot_nr]),
&ec->read_iovec, 0, length);
ec->read_s = length;
ec->flags |= ECF_PACK_RECV;
ec->flags &= ~ECF_READING;
packet_processed = TRUE;
}
/* set up this slot again, and we move to the next slot */
lp->rx_ring[rx_slot_nr].buf_length = -ETH_FRAME_LEN;
lp->rx_ring[rx_slot_nr].u.addr[3] |= 0x80;
write_csr(ioaddr, LANCE_CSR0,
LANCE_CSR0_BABL|LANCE_CSR0_CERR|LANCE_CSR0_MISS
|LANCE_CSR0_MERR|LANCE_CSR0_IDON|LANCE_CSR0_IENA);
rx_slot_nr = (++rx_slot_nr) & RX_RING_MOD_MASK;
}
else
break;
}
}
/*===========================================================================*
* do_vwrite_s *
*===========================================================================*/
static void do_vwrite_s(mp, from_int)
message *mp;
int from_int;
{
int port, count, check, r;
ether_card_t *ec;
unsigned short ioaddr;
port = mp->DL_PORT;
count = mp->DL_COUNT;
ec = &ec_table[port];
ec->client= mp->DL_PROC;
if (isstored[tx_slot_nr]==1)
{
/* all slots are used, so this message is buffered */
ec->sendmsg= *mp;
ec->flags |= ECF_SEND_AVAIL;
reply(ec, OK, FALSE);
return;
}
/* convert the message to write_iovec */
r = sys_safecopyfrom(mp->DL_PROC, mp->DL_GRANT, 0,
(vir_bytes)ec->write_iovec.iod_iovec,
(count > IOVEC_NR ? IOVEC_NR : count) *
sizeof(iovec_s_t), D);
if (r != OK)
panic("do_vwrite_s: sys_safecopyfrom failed: %d", r);
ec->write_iovec.iod_iovec_s = count;
ec->write_iovec.iod_proc_nr = mp->DL_PROC;
ec->write_iovec.iod_grant = mp->DL_GRANT;
ec->write_iovec.iod_iovec_offset = 0;
ec->tmp_iovec = ec->write_iovec;
ec->write_s = calc_iovec_size(&ec->tmp_iovec);
/* copy write_iovec to the slot on DMA address */
ec_user2nic(ec, &ec->write_iovec, 0,
(int)(lp->tbuf[tx_slot_nr]), ec->write_s);
/* set-up for transmitting, and transmit it if needed. */
lp->tx_ring[tx_slot_nr].buf_length = -ec->write_s;
lp->tx_ring[tx_slot_nr].misc = 0x0;
lp->tx_ring[tx_slot_nr].u.base
= virt_to_bus(lp->tbuf[tx_slot_nr]) & 0xffffff;
isstored[tx_slot_nr]=1;
if (cur_tx_slot_nr == tx_slot_nr)
check=1;
else
check=0;
tx_slot_nr = (++tx_slot_nr) & TX_RING_MOD_MASK;
if (check == 1)
{
ioaddr = ec->ec_port;
lp->tx_ring[cur_tx_slot_nr].u.addr[3] = 0x83;
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_IENA|LANCE_CSR0_TDMD);
}
ec->flags |= ECF_PACK_SEND;
/* reply by calling do_int() if this function is called from interrupt. */
if (from_int)
return;
reply(ec, OK, FALSE);
}
/*===========================================================================*
* ec_user2nic *
*===========================================================================*/
static void ec_user2nic(ec, iovp, offset, nic_addr, count)
ether_card_t *ec;
iovec_dat_t *iovp;
vir_bytes offset;
int nic_addr;
vir_bytes count;
{
int bytes, i, r;
i= 0;
while (count > 0)
{
if (i >= IOVEC_NR)
{
ec_next_iovec(iovp);
i= 0;
continue;
}
if (offset >= iovp->iod_iovec[i].iov_size)
{
offset -= iovp->iod_iovec[i].iov_size;
i++;
continue;
}
bytes = iovp->iod_iovec[i].iov_size - offset;
if (bytes > count)
bytes = count;
if ( (r=sys_safecopyfrom(iovp->iod_proc_nr,
iovp->iod_iovec[i].iov_grant, offset,
nic_addr, bytes, D )) != OK )
panic("ec_user2nic: sys_safecopyfrom failed: %d", r);
count -= bytes;
nic_addr += bytes;
offset += bytes;
}
}
/*===========================================================================*
* ec_nic2user *
*===========================================================================*/
static void ec_nic2user(ec, nic_addr, iovp, offset, count)
ether_card_t *ec;
int nic_addr;
iovec_dat_t *iovp;
vir_bytes offset;
vir_bytes count;
{
int bytes, i, r;
i= 0;
while (count > 0)
{
if (i >= IOVEC_NR)
{
ec_next_iovec(iovp);
i= 0;
continue;
}
if (offset >= iovp->iod_iovec[i].iov_size)
{
offset -= iovp->iod_iovec[i].iov_size;
i++;
continue;
}
bytes = iovp->iod_iovec[i].iov_size - offset;
if (bytes > count)
bytes = count;
if ( (r=sys_safecopyto( iovp->iod_proc_nr, iovp->iod_iovec[i].iov_grant,
offset, nic_addr, bytes, D )) != OK )
panic("ec_nic2user: sys_safecopyto failed: %d", r);
count -= bytes;
nic_addr += bytes;
offset += bytes;
}
}
/*===========================================================================*
* calc_iovec_size *
*===========================================================================*/
static int calc_iovec_size(iovec_dat_t *iovp)
{
int size,i;
size = i = 0;
while (i < iovp->iod_iovec_s)
{
if (i >= IOVEC_NR)
{
ec_next_iovec(iovp);
i= 0;
continue;
}
size += iovp->iod_iovec[i].iov_size;
i++;
}
return size;
}
/*===========================================================================*
* ec_next_iovec *
*===========================================================================*/
static void ec_next_iovec(iovp)
iovec_dat_t *iovp;
{
int r;
iovp->iod_iovec_s -= IOVEC_NR;
iovp->iod_iovec_offset += IOVEC_NR * sizeof(iovec_s_t);
r = sys_safecopyfrom(iovp->iod_proc_nr, iovp->iod_grant,
iovp->iod_iovec_offset,
(vir_bytes)iovp->iod_iovec,
(iovp->iod_iovec_s > IOVEC_NR ?
IOVEC_NR : iovp->iod_iovec_s) *
sizeof(iovec_s_t), D);
if (r != OK)
panic("ec_next_iovec: sys_safecopyfrom failed: %d", r);
}
/*===========================================================================*
* do_getstat_s *
*===========================================================================*/
static void do_getstat_s(mp)
message *mp;
{
int r, port;
ether_card_t *ec;
port = mp->DL_PORT;
if (port < 0 || port >= EC_PORT_NR_MAX)
panic("illegal port: %d", port);
ec= &ec_table[port];
ec->client= mp->DL_PROC;
r = sys_safecopyto(mp->DL_PROC, mp->DL_GRANT, 0,
(vir_bytes)&ec->eth_stat, sizeof(ec->eth_stat), D);
if (r != OK)
panic("do_getstat_s: sys_safecopyto failed: %d", r);
mp->m_type= DL_STAT_REPLY;
mp->DL_PORT= port;
mp->DL_STAT= OK;
r= send(mp->m_source, mp);
if (r != OK)
panic("do_getstat_s: send failed: %d", r);
}
/*===========================================================================*
* do_stop *
*===========================================================================*/
static void do_stop(mp)
message *mp;
{
int port;
ether_card_t *ec;
unsigned short ioaddr;
port = mp->DL_PORT;
if (port < 0 || port >= EC_PORT_NR_MAX)
panic("illegal port: %d", port);
ec = &ec_table[port];
if (!(ec->flags & ECF_ENABLED))
return;
ioaddr = ec->ec_port;
/* stop */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STOP);
/* Reset */
in_word(ioaddr+LANCE_RESET);
ec->flags = ECF_EMPTY;
}
/*===========================================================================*
* getAddressing *
*===========================================================================*/
static void getAddressing(devind, ec)
int devind;
ether_card_t *ec;
{
unsigned int membase, ioaddr;
int reg, irq;
for (reg = PCI_BASE_ADDRESS_0; reg <= PCI_BASE_ADDRESS_5; reg += 4)
{
ioaddr = pci_attr_r32(devind, reg);
if ((ioaddr & PCI_BASE_ADDRESS_IO_MASK) == 0
|| (ioaddr & PCI_BASE_ADDRESS_SPACE_IO) == 0)
continue;
/* Strip the I/O address out of the returned value */
ioaddr &= PCI_BASE_ADDRESS_IO_MASK;
/* Get the memory base address */
membase = pci_attr_r32(devind, PCI_BASE_ADDRESS_1);
/* KK: Get the IRQ number */
irq = pci_attr_r8(devind, PCI_INTERRUPT_PIN);
if (irq)
irq = pci_attr_r8(devind, PCI_INTERRUPT_LINE);
ec->ec_linmem = membase;
ec->ec_port = ioaddr;
ec->ec_irq = irq;
}
}
/*===========================================================================*
* lance_probe *
*===========================================================================*/
static int lance_probe(ec)
ether_card_t *ec;
{
unsigned short pci_cmd;
unsigned short ioaddr;
int lance_version, chip_version;
int devind, just_one, i, r;
u16_t vid, did;
char *dname;
if ((ec->ec_pcibus | ec->ec_pcidev | ec->ec_pcifunc) != 0)
{
/* Look for specific PCI device */
r= pci_find_dev(ec->ec_pcibus, ec->ec_pcidev,
ec->ec_pcifunc, &devind);
if (r == 0)
{
printf("%s: no PCI found at %d.%d.%d\n",
ec->port_name, ec->ec_pcibus,
ec->ec_pcidev, ec->ec_pcifunc);
return 0;
}
pci_ids(devind, &vid, &did);
just_one= TRUE;
}
else
{
r= pci_first_dev(&devind, &vid, &did);
if (r == 0)
return 0;
just_one= FALSE;
}
for(;;)
{
for (i= 0; pcitab[i].vid != 0; i++)
{
if (pcitab[i].vid != vid)
continue;
if (pcitab[i].did != did)
continue;
if (pcitab[i].checkclass) {
panic("class check not implemented");
}
break;
}
if (pcitab[i].vid != 0)
break;
if (just_one)
{
printf(
"%s: wrong PCI device (%04x/%04x) found at %d.%d.%d\n",
ec->port_name, vid, did,
ec->ec_pcibus,
ec->ec_pcidev, ec->ec_pcifunc);
return 0;
}
r= pci_next_dev(&devind, &vid, &did);
if (!r)
return 0;
}
dname= pci_dev_name(vid, did);
if (!dname)
dname= "unknown device";
pci_reserve(devind);
getAddressing(devind, ec);
/* ===== Bus Master ? ===== */
pci_cmd = pci_attr_r32(devind, PCI_CR);
if (!(pci_cmd & PCI_COMMAND_MASTER)) {
pci_cmd |= PCI_COMMAND_MASTER;
pci_attr_w32(devind, PCI_CR, pci_cmd);
}
/* ===== Probe Details ===== */
ioaddr = ec->ec_port;
/* Reset */
in_word(ioaddr+LANCE_RESET);
if (read_csr(ioaddr, LANCE_CSR0) != LANCE_CSR0_STOP)
{
ec->mode=EC_DISABLED;
}
/* Probe Chip Version */
out_word(ioaddr+LANCE_ADDR, 88); /* Get the version of the chip */
if (in_word(ioaddr+LANCE_ADDR) != 88)
lance_version = 0;
else
{
chip_version = read_csr(ioaddr, LANCE_CSR88);
chip_version |= read_csr(ioaddr, LANCE_CSR89) << 16;
if ((chip_version & 0xfff) != 0x3)
{
ec->mode=EC_DISABLED;
}
chip_version = (chip_version >> 12) & 0xffff;
for (lance_version = 1; chip_table[lance_version].id_number != 0;
++lance_version)
if (chip_table[lance_version].id_number == chip_version)
break;
}
#if VERBOSE
printf("%s: %s at %X:%d\n",
ec->port_name, chip_table[lance_version].name,
ec->ec_port, ec->ec_irq);
#endif
return lance_version;
}
/*===========================================================================*
* do_getname *
*===========================================================================*/
static void do_getname(mp)
message *mp;
{
int r;
strncpy(mp->DL_NAME, progname, sizeof(mp->DL_NAME));
mp->DL_NAME[sizeof(mp->DL_NAME)-1]= '\0';
mp->m_type= DL_NAME_REPLY;
r= send(mp->m_source, mp);
if (r != OK)
panic("do_getname: send failed: %d", r);
}
/*===========================================================================*
* lance_init_card *
*===========================================================================*/
static void lance_init_card(ec)
ether_card_t *ec;
{
int i;
Address l = (vir_bytes)lance_buf;
unsigned short ioaddr = ec->ec_port;
/* ============= setup init_block(cf. lance_probe1) ================ */
/* make sure data structure is 8-byte aligned and below 16MB (for DMA) */
lp = (struct lance_interface *)l;
/* disable Tx and Rx */
lp->init_block.mode = LANCE_CSR15_DTX|LANCE_CSR15_DRX;
lp->init_block.filter[0] = lp->init_block.filter[1] = 0x0;
/* using multiple Rx/Tx buffer */
lp->init_block.rx_ring
= (virt_to_bus(&lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
lp->init_block.tx_ring
= (virt_to_bus(&lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
l = virt_to_bus(&lp->init_block);
write_csr(ioaddr, LANCE_CSR1, (unsigned short)l);
write_csr(ioaddr, LANCE_CSR2, (unsigned short)(l >> 16));
write_csr(ioaddr, LANCE_CSR4,
LANCE_CSR4_APAD_XMT|LANCE_CSR4_MFCOM|LANCE_CSR4_RCVCCOM
|LANCE_CSR4_TXSTRTM|LANCE_CSR4_JABM);
/* ============= Get MAC address (cf. lance_probe1) ================ */
for (i = 0; i < 6; ++i)
ec->mac_address.ea_addr[i]=in_byte(ioaddr+LANCE_ETH_ADDR+i);
/* ============ (re)start init_block(cf. lance_reset) =============== */
/* Reset the LANCE */
(void)in_word(ioaddr+LANCE_RESET);
/* ----- Re-initialize the LANCE ----- */
/* Set station address */
for (i = 0; i < 6; ++i)
lp->init_block.phys_addr[i] = ec->mac_address.ea_addr[i];
/* Preset the receive ring headers */
for (i=0; i<RX_RING_SIZE; i++)
{
lp->rx_ring[i].buf_length = -ETH_FRAME_LEN;
/* OWN */
lp->rx_ring[i].u.base = virt_to_bus(lp->rbuf[i]) & 0xffffff;
/* we set the top byte as the very last thing */
lp->rx_ring[i].u.addr[3] = 0x80;
}
/* Preset the transmitting ring headers */
for (i=0; i<TX_RING_SIZE; i++)
{
lp->tx_ring[i].u.base = 0;
isstored[i] = 0;
}
/* enable Rx and Tx */
lp->init_block.mode = 0x0;
l = (Address)virt_to_bus(&lp->init_block);
write_csr(ioaddr, LANCE_CSR1, (short)l);
write_csr(ioaddr, LANCE_CSR2, (short)(l >> 16));
write_csr(ioaddr, LANCE_CSR4,
LANCE_CSR4_APAD_XMT|LANCE_CSR4_MFCOM|LANCE_CSR4_RCVCCOM
|LANCE_CSR4_TXSTRTM|LANCE_CSR4_JABM);
/* ----- start when init done. ----- */
/* stop */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_STOP);
/* init */
write_csr(ioaddr, LANCE_CSR0, LANCE_CSR0_INIT);
/* poll for IDON */
for (i = 10000; i > 0; --i)
if (read_csr(ioaddr, LANCE_CSR0) & LANCE_CSR0_IDON)
break;
/* Set 'Multicast Table' */
for (i=0;i<4;++i)
{
write_csr(ioaddr, LANCE_CSR8 + i, 0xffff);
}
/* Set 'Receive Mode' */
if (ec->flags & ECF_PROMISC)
{
write_csr(ioaddr, LANCE_CSR15, LANCE_CSR15_PROM);
}
else
{
if (ec->flags & (ECF_BROAD | ECF_MULTI))
{
write_csr(ioaddr, LANCE_CSR15, 0x0000);
}
else
{
write_csr(ioaddr, LANCE_CSR15, LANCE_CSR15_DRCVBC);
}
}
/* start && enable interrupt */
write_csr(ioaddr, LANCE_CSR0,
LANCE_CSR0_IDON|LANCE_CSR0_IENA|LANCE_CSR0_STRT);
return;
}
/*===========================================================================*
* in_byte *
*===========================================================================*/
static u8_t in_byte(port_t port)
{
int r;
u32_t value;
r= sys_inb(port, &value);
if (r != OK)
panic("sys_inb failed: %d", r);
return value;
}
/*===========================================================================*
* in_word *
*===========================================================================*/
static u16_t in_word(port_t port)
{
int r;
u32_t value;
r= sys_inw(port, &value);
if (r != OK)
panic("sys_inw failed: %d", r);
return value;
}
/*===========================================================================*
* out_word *
*===========================================================================*/
static void out_word(port_t port, u16_t value)
{
int r;
r= sys_outw(port, value);
if (r != OK)
panic("sys_outw failed: %d", r);
}
/*===========================================================================*
* read_csr *
*===========================================================================*/
static u16_t read_csr(port_t ioaddr, u16_t csrno)
{
out_word(ioaddr+LANCE_ADDR, csrno);
return in_word(ioaddr+LANCE_DATA);
}
/*===========================================================================*
* write_csr *
*===========================================================================*/
static void write_csr(port_t ioaddr, u16_t csrno, u16_t value)
{
out_word(ioaddr+LANCE_ADDR, csrno);
out_word(ioaddr+LANCE_DATA, value);
}
Reference in a new issue View git blame Copy permalink