static int elmc_open(struct net_device *dev)
{
int ret;
elmc_id_attn586(); /* disable interrupts */
ret = request_irq(dev->irq, &elmc_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM,
dev->name, dev);
if (ret) {
printk(KERN_ERR "%s: couldn't get irq %d\n", dev->name, dev->irq);
elmc_id_reset586();
return ret;
}
alloc586(dev);
init586(dev);
startrecv586(dev);
netif_start_queue(dev);
return 0; /* most done by init */
}
static int elmc_open(struct net_device *dev)
{
int ret;
elmc_id_attn586(); /* disable interrupts */
ret = request_irq(dev->irq, elmc_interrupt, IRQF_SHARED,
dev->name, dev);
if (ret) {
pr_err("%s: couldn't get irq %d\n", dev->name, dev->irq);
elmc_id_reset586();
return ret;
}
alloc586(dev);
init586(dev);
startrecv586(dev);
netif_start_queue(dev);
return 0; /* most done by init */
}
static int __init check586(struct net_device *dev, unsigned long where, unsigned size)
{
struct priv *p = (struct priv *) dev->priv;
char *iscp_addrs[2];
int i = 0;
p->base = (unsigned long) bus_to_virt((unsigned long)where) + size - 0x01000000;
p->memtop = bus_to_virt((unsigned long)where) + size;
p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
memset((char *) p->scp, 0, sizeof(struct scp_struct));
p->scp->sysbus = SYSBUSVAL; /* 1 = 8Bit-Bus, 0 = 16 Bit */
iscp_addrs[0] = bus_to_virt((unsigned long)where);
iscp_addrs[1] = (char *) p->scp - sizeof(struct iscp_struct);
for (i = 0; i < 2; i++) {
p->iscp = (struct iscp_struct *) iscp_addrs[i];
memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
p->scp->iscp = make24(p->iscp);
p->iscp->busy = 1;
elmc_id_reset586();
/* reset586 does an implicit CA */
/* apparently, you sometimes have to kick the 82586 twice... */
elmc_id_attn586();
DELAY(1);
if (p->iscp->busy) { /* i82586 clears 'busy' after successful init */
return 0;
}
}
return 1;
}
static void elmc_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr)
{
struct net_device *dev = (struct net_device *) dev_id;
unsigned short stat;
struct priv *p;
if (dev == NULL) {
printk(KERN_ERR "elmc-interrupt: irq %d for unknown device.\n", (int) -(((struct pt_regs *) reg_ptr)->orig_eax + 2));
return;
} else if (!netif_running(dev)) {
/* The 3c523 has this habit of generating interrupts during the
reset. I'm not sure if the ni52 has this same problem, but it's
really annoying if we haven't finished initializing it. I was
hoping all the elmc_id_* commands would disable this, but I
might have missed a few. */
elmc_id_attn586(); /* ack inter. and disable any more */
return;
} else if (!(ELMC_CTRL_INT & inb(dev->base_addr + ELMC_CTRL))) {
/* wasn't this device */
return;
}
/* reading ELMC_CTRL also clears the INT bit. */
p = (struct priv *) dev->priv;
while ((stat = p->scb->status & STAT_MASK))
{
p->scb->cmd = stat;
elmc_attn586(); /* ack inter. */
if (stat & STAT_CX) {
/* command with I-bit set complete */
elmc_xmt_int(dev);
}
if (stat & STAT_FR) {
/* received a frame */
elmc_rcv_int(dev);
}
#ifndef NO_NOPCOMMANDS
if (stat & STAT_CNA) {
/* CU went 'not ready' */
if (netif_running(dev)) {
printk(KERN_WARNING "%s: oops! CU has left active state. stat: %04x/%04x.\n", dev->name, (int) stat, (int) p->scb->status);
}
}
#endif
if (stat & STAT_RNR) {
/* RU went 'not ready' */
if (p->scb->status & RU_SUSPEND) {
/* special case: RU_SUSPEND */
WAIT_4_SCB_CMD();
p->scb->cmd = RUC_RESUME;
elmc_attn586();
} else {
printk(KERN_WARNING "%s: Receiver-Unit went 'NOT READY': %04x/%04x.\n", dev->name, (int) stat, (int) p->scb->status);
elmc_rnr_int(dev);
}
}
WAIT_4_SCB_CMD(); /* wait for ack. (elmc_xmt_int can be faster than ack!!) */
if (p->scb->cmd) { /* timed out? */
break;
}
}
}
static int init586(struct net_device *dev)
{
void *ptr;
unsigned long s;
int i, result = 0;
struct priv *p = (struct priv *) dev->priv;
volatile struct configure_cmd_struct *cfg_cmd;
volatile struct iasetup_cmd_struct *ias_cmd;
volatile struct tdr_cmd_struct *tdr_cmd;
volatile struct mcsetup_cmd_struct *mc_cmd;
struct dev_mc_list *dmi = dev->mc_list;
int num_addrs = dev->mc_count;
ptr = (void *) ((char *) p->scb + sizeof(struct scb_struct));
cfg_cmd = (struct configure_cmd_struct *) ptr; /* configure-command */
cfg_cmd->cmd_status = 0;
cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST;
cfg_cmd->cmd_link = 0xffff;
cfg_cmd->byte_cnt = 0x0a; /* number of cfg bytes */
cfg_cmd->fifo = 0x08; /* fifo-limit (8=tx:32/rx:64) */
cfg_cmd->sav_bf = 0x40; /* hold or discard bad recv frames (bit 7) */
cfg_cmd->adr_len = 0x2e; /* addr_len |!src_insert |pre-len |loopback */
cfg_cmd->priority = 0x00;
cfg_cmd->ifs = 0x60;
cfg_cmd->time_low = 0x00;
cfg_cmd->time_high = 0xf2;
cfg_cmd->promisc = 0;
if (dev->flags & (IFF_ALLMULTI | IFF_PROMISC)) {
cfg_cmd->promisc = 1;
dev->flags |= IFF_PROMISC;
}
cfg_cmd->carr_coll = 0x00;
p->scb->cbl_offset = make16(cfg_cmd);
p->scb->cmd = CUC_START; /* cmd.-unit start */
elmc_id_attn586();
s = jiffies; /* warning: only active with interrupts on !! */
while (!(cfg_cmd->cmd_status & STAT_COMPL)) {
if (jiffies - s > 30*HZ/100)
break;
}
if ((cfg_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_COMPL | STAT_OK)) {
printk(KERN_WARNING "%s (elmc): configure command failed: %x\n", dev->name, cfg_cmd->cmd_status);
return 1;
}
/*
* individual address setup
*/
ias_cmd = (struct iasetup_cmd_struct *) ptr;
ias_cmd->cmd_status = 0;
ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST;
ias_cmd->cmd_link = 0xffff;
memcpy((char *) &ias_cmd->iaddr, (char *) dev->dev_addr, ETH_ALEN);
p->scb->cbl_offset = make16(ias_cmd);
p->scb->cmd = CUC_START; /* cmd.-unit start */
elmc_id_attn586();
s = jiffies;
while (!(ias_cmd->cmd_status & STAT_COMPL)) {
if (jiffies - s > 30*HZ/100)
break;
}
if ((ias_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_OK | STAT_COMPL)) {
printk(KERN_WARNING "%s (elmc): individual address setup command failed: %04x\n", dev->name, ias_cmd->cmd_status);
return 1;
}
/*
* TDR, wire check .. e.g. no resistor e.t.c
*/
tdr_cmd = (struct tdr_cmd_struct *) ptr;
tdr_cmd->cmd_status = 0;
tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST;
tdr_cmd->cmd_link = 0xffff;
tdr_cmd->status = 0;
p->scb->cbl_offset = make16(tdr_cmd);
p->scb->cmd = CUC_START; /* cmd.-unit start */
elmc_attn586();
s = jiffies;
while (!(tdr_cmd->cmd_status & STAT_COMPL)) {
if (jiffies - s > 30*HZ/100) {
printk(KERN_WARNING "%s: %d Problems while running the TDR.\n", dev->name, __LINE__);
result = 1;
break;
}
}
if (!result) {
DELAY(2); /* wait for result */
result = tdr_cmd->status;
p->scb->cmd = p->scb->status & STAT_MASK;
elmc_id_attn586(); /* ack the interrupts */
if (result & TDR_LNK_OK) {
/* empty */
} else if (result & TDR_XCVR_PRB) {
printk(KERN_WARNING "%s: TDR: Transceiver problem!\n", dev->name);
} else if (result & TDR_ET_OPN) {
printk(KERN_WARNING "%s: TDR: No correct termination %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
} else if (result & TDR_ET_SRT) {
if (result & TDR_TIMEMASK) /* time == 0 -> strange :-) */
printk(KERN_WARNING "%s: TDR: Detected a short circuit %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
} else {
printk(KERN_WARNING "%s: TDR: Unknown status %04x\n", dev->name, result);
}
}
/*
* ack interrupts
*/
p->scb->cmd = p->scb->status & STAT_MASK;
elmc_id_attn586();
/*
* alloc nop/xmit-cmds
*/
#if (NUM_XMIT_BUFFS == 1)
for (i = 0; i < 2; i++) {
p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
p->nop_cmds[i]->cmd_cmd = CMD_NOP;
p->nop_cmds[i]->cmd_status = 0;
p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
}
p->xmit_cmds[0] = (struct transmit_cmd_struct *) ptr; /* transmit cmd/buff 0 */
ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
#else
for (i = 0; i < NUM_XMIT_BUFFS; i++) {
p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
p->nop_cmds[i]->cmd_cmd = CMD_NOP;
p->nop_cmds[i]->cmd_status = 0;
p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
p->xmit_cmds[i] = (struct transmit_cmd_struct *) ptr; /*transmit cmd/buff 0 */
ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
}
#endif
ptr = alloc_rfa(dev, (void *) ptr); /* init receive-frame-area */
/*
* Multicast setup
*/
if (dev->mc_count) {
/* I don't understand this: do we really need memory after the init? */
int len = ((char *) p->iscp - (char *) ptr - 8) / 6;
if (len <= 0) {
printk(KERN_ERR "%s: Ooooops, no memory for MC-Setup!\n", dev->name);
} else {
if (len < num_addrs) {
num_addrs = len;
printk(KERN_WARNING "%s: Sorry, can only apply %d MC-Address(es).\n",
dev->name, num_addrs);
}
mc_cmd = (struct mcsetup_cmd_struct *) ptr;
mc_cmd->cmd_status = 0;
mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST;
mc_cmd->cmd_link = 0xffff;
mc_cmd->mc_cnt = num_addrs * 6;
for (i = 0; i < num_addrs; i++) {
memcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr, 6);
dmi = dmi->next;
}
p->scb->cbl_offset = make16(mc_cmd);
p->scb->cmd = CUC_START;
elmc_id_attn586();
s = jiffies;
while (!(mc_cmd->cmd_status & STAT_COMPL)) {
if (jiffies - s > 30*HZ/100)
break;
}
if (!(mc_cmd->cmd_status & STAT_COMPL)) {
printk(KERN_WARNING "%s: Can't apply multicast-address-list.\n", dev->name);
}
}
}
/*
* alloc xmit-buffs / init xmit_cmds
*/
for (i = 0; i < NUM_XMIT_BUFFS; i++) {
p->xmit_cbuffs[i] = (char *) ptr; /* char-buffs */
ptr = (char *) ptr + XMIT_BUFF_SIZE;
p->xmit_buffs[i] = (struct tbd_struct *) ptr; /* TBD */
ptr = (char *) ptr + sizeof(struct tbd_struct);
if ((void *) ptr > (void *) p->iscp) {
printk(KERN_ERR "%s: not enough shared-mem for your configuration!\n", dev->name);
return 1;
}
memset((char *) (p->xmit_cmds[i]), 0, sizeof(struct transmit_cmd_struct));
memset((char *) (p->xmit_buffs[i]), 0, sizeof(struct tbd_struct));
p->xmit_cmds[i]->cmd_status = STAT_COMPL;
p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT;
p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
p->xmit_buffs[i]->next = 0xffff;
p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
}
p->xmit_count = 0;
p->xmit_last = 0;
#ifndef NO_NOPCOMMANDS
p->nop_point = 0;
#endif
/*
* 'start transmitter' (nop-loop)
*/
#ifndef NO_NOPCOMMANDS
p->scb->cbl_offset = make16(p->nop_cmds[0]);
p->scb->cmd = CUC_START;
elmc_id_attn586();
WAIT_4_SCB_CMD();
#else
p->xmit_cmds[0]->cmd_link = 0xffff;
p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_LAST | CMD_INT;
#endif
return 0;
}
