static netdev_tx_t elp_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
unsigned long flags;
elp_device *adapter = netdev_priv(dev);
spin_lock_irqsave(&adapter->lock, flags);
check_3c505_dma(dev);
if (elp_debug >= 3)
pr_debug("%s: request to send packet of length %d\n", dev->name, (int) skb->len);
netif_stop_queue(dev);
/*
* send the packet at skb->data for skb->len
*/
if (!send_packet(dev, skb)) {
if (elp_debug >= 2) {
pr_debug("%s: failed to transmit packet\n", dev->name);
}
spin_unlock_irqrestore(&adapter->lock, flags);
return NETDEV_TX_BUSY;
}
if (elp_debug >= 3)
pr_debug("%s: packet of length %d sent\n", dev->name, (int) skb->len);
prime_rx(dev);
spin_unlock_irqrestore(&adapter->lock, flags);
netif_start_queue(dev);
return NETDEV_TX_OK;
}
static int elp_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
unsigned long flags;
elp_device *adapter = dev->priv;
spin_lock_irqsave(&adapter->lock, flags);
check_3c505_dma(dev);
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: request to send packet of length %d\n", dev->name, (int) skb->len);
netif_stop_queue(dev);
/*
* send the packet at skb->data for skb->len
*/
if (!send_packet(dev, skb)) {
if (elp_debug >= 2) {
printk(KERN_DEBUG "%s: failed to transmit packet\n", dev->name);
}
spin_unlock_irqrestore(&adapter->lock, flags);
return 1;
}
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: packet of length %d sent\n", dev->name, (int) skb->len);
/*
* start the transmit timeout
*/
dev->trans_start = jiffies;
prime_rx(dev);
spin_unlock_irqrestore(&adapter->lock, flags);
netif_start_queue(dev);
return 0;
}
static irqreturn_t elp_interrupt(int irq, void *dev_id)
{
int len;
int dlen;
int icount = 0;
struct net_device *dev;
elp_device *adapter;
unsigned long timeout;
dev = dev_id;
adapter = (elp_device *) dev->priv;
spin_lock(&adapter->lock);
do {
/*
* has a DMA transfer finished?
*/
if (inb_status(dev->base_addr) & DONE) {
if (!adapter->dmaing) {
printk(KERN_WARNING "%s: phantom DMA completed\n", dev->name);
}
if (elp_debug >= 3) {
printk(KERN_DEBUG "%s: %s DMA complete, status %02x\n", dev->name, adapter->current_dma.direction ? "tx" : "rx", inb_status(dev->base_addr));
}
outb_control(adapter->hcr_val & ~(DMAE | TCEN | DIR), dev);
if (adapter->current_dma.direction) {
dev_kfree_skb_irq(adapter->current_dma.skb);
} else {
struct sk_buff *skb = adapter->current_dma.skb;
if (skb) {
if (adapter->current_dma.target) {
/* have already done the skb_put() */
memcpy(adapter->current_dma.target, adapter->dma_buffer, adapter->current_dma.length);
}
skb->protocol = eth_type_trans(skb,dev);
adapter->stats.rx_bytes += skb->len;
netif_rx(skb);
dev->last_rx = jiffies;
}
}
adapter->dmaing = 0;
if (adapter->rx_backlog.in != adapter->rx_backlog.out) {
int t = adapter->rx_backlog.length[adapter->rx_backlog.out];
adapter->rx_backlog.out = backlog_next(adapter->rx_backlog.out);
if (elp_debug >= 2)
printk(KERN_DEBUG "%s: receiving backlogged packet (%d)\n", dev->name, t);
receive_packet(dev, t);
} else {
adapter->busy = 0;
}
} else {
/* has one timed out? */
check_3c505_dma(dev);
}
/*
* receive a PCB from the adapter
*/
timeout = jiffies + 3*HZ/100;
while ((inb_status(dev->base_addr) & ACRF) != 0 && time_before(jiffies, timeout)) {
if (receive_pcb(dev, &adapter->irx_pcb)) {
switch (adapter->irx_pcb.command)
{
case 0:
break;
/*
* received a packet - this must be handled fast
*/
case 0xff:
case CMD_RECEIVE_PACKET_COMPLETE:
/* if the device isn't open, don't pass packets up the stack */
if (!netif_running(dev))
break;
len = adapter->irx_pcb.data.rcv_resp.pkt_len;
dlen = adapter->irx_pcb.data.rcv_resp.buf_len;
if (adapter->irx_pcb.data.rcv_resp.timeout != 0) {
printk(KERN_ERR "%s: interrupt - packet not received correctly\n", dev->name);
} else {
if (elp_debug >= 3) {
printk(KERN_DEBUG "%s: interrupt - packet received of length %i (%i)\n", dev->name, len, dlen);
}
if (adapter->irx_pcb.command == 0xff) {
if (elp_debug >= 2)
printk(KERN_DEBUG "%s: adding packet to backlog (len = %d)\n", dev->name, dlen);
adapter->rx_backlog.length[adapter->rx_backlog.in] = dlen;
adapter->rx_backlog.in = backlog_next(adapter->rx_backlog.in);
} else {
receive_packet(dev, dlen);
}
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: packet received\n", dev->name);
}
break;
/*
* 82586 configured correctly
*/
case CMD_CONFIGURE_82586_RESPONSE:
adapter->got[CMD_CONFIGURE_82586] = 1;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: interrupt - configure response received\n", dev->name);
break;
/*
* Adapter memory configuration
*/
case CMD_CONFIGURE_ADAPTER_RESPONSE:
adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 1;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: Adapter memory configuration %s.\n", dev->name,
adapter->irx_pcb.data.failed ? "failed" : "succeeded");
break;
/*
* Multicast list loading
*/
case CMD_LOAD_MULTICAST_RESPONSE:
adapter->got[CMD_LOAD_MULTICAST_LIST] = 1;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: Multicast address list loading %s.\n", dev->name,
adapter->irx_pcb.data.failed ? "failed" : "succeeded");
break;
/*
* Station address setting
*/
case CMD_SET_ADDRESS_RESPONSE:
adapter->got[CMD_SET_STATION_ADDRESS] = 1;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: Ethernet address setting %s.\n", dev->name,
adapter->irx_pcb.data.failed ? "failed" : "succeeded");
break;
/*
* received board statistics
*/
case CMD_NETWORK_STATISTICS_RESPONSE:
adapter->stats.rx_packets += adapter->irx_pcb.data.netstat.tot_recv;
adapter->stats.tx_packets += adapter->irx_pcb.data.netstat.tot_xmit;
adapter->stats.rx_crc_errors += adapter->irx_pcb.data.netstat.err_CRC;
adapter->stats.rx_frame_errors += adapter->irx_pcb.data.netstat.err_align;
adapter->stats.rx_fifo_errors += adapter->irx_pcb.data.netstat.err_ovrrun;
adapter->stats.rx_over_errors += adapter->irx_pcb.data.netstat.err_res;
adapter->got[CMD_NETWORK_STATISTICS] = 1;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: interrupt - statistics response received\n", dev->name);
break;
/*
* sent a packet
*/
case CMD_TRANSMIT_PACKET_COMPLETE:
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: interrupt - packet sent\n", dev->name);
if (!netif_running(dev))
break;
switch (adapter->irx_pcb.data.xmit_resp.c_stat) {
case 0xffff:
adapter->stats.tx_aborted_errors++;
printk(KERN_INFO "%s: transmit timed out, network cable problem?\n", dev->name);
break;
case 0xfffe:
adapter->stats.tx_fifo_errors++;
printk(KERN_INFO "%s: transmit timed out, FIFO underrun\n", dev->name);
break;
}
netif_wake_queue(dev);
break;
/*
* some unknown PCB
*/
default:
printk(KERN_DEBUG "%s: unknown PCB received - %2.2x\n", dev->name, adapter->irx_pcb.command);
break;
}
} else {
printk(KERN_WARNING "%s: failed to read PCB on interrupt\n", dev->name);
adapter_reset(dev);
}
}
} while (icount++ < 5 && (inb_status(dev->base_addr) & (ACRF | DONE)));
prime_rx(dev);
/*
* indicate no longer in interrupt routine
*/
spin_unlock(&adapter->lock);
return IRQ_HANDLED;
}
static int send_pcb(struct net_device *dev, pcb_struct * pcb)
{
int i;
unsigned long timeout;
elp_device *adapter = dev->priv;
unsigned long flags;
check_3c505_dma(dev);
if (adapter->dmaing && adapter->current_dma.direction == 0)
return FALSE;
/* Avoid contention */
if (test_and_set_bit(1, &adapter->send_pcb_semaphore)) {
if (elp_debug >= 3) {
printk(KERN_DEBUG "%s: send_pcb entered while threaded\n", dev->name);
}
return FALSE;
}
/*
* load each byte into the command register and
* wait for the HCRE bit to indicate the adapter
* had read the byte
*/
set_hsf(dev, 0);
if (send_pcb_slow(dev->base_addr, pcb->command))
goto abort;
spin_lock_irqsave(&adapter->lock, flags);
if (send_pcb_fast(dev->base_addr, pcb->length))
goto sti_abort;
for (i = 0; i < pcb->length; i++) {
if (send_pcb_fast(dev->base_addr, pcb->data.raw[i]))
goto sti_abort;
}
outb_control(adapter->hcr_val | 3, dev); /* signal end of PCB */
outb_command(2 + pcb->length, dev->base_addr);
/* now wait for the acknowledgement */
spin_unlock_irqrestore(&adapter->lock, flags);
for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
switch (GET_ASF(dev->base_addr)) {
case ASF_PCB_ACK:
adapter->send_pcb_semaphore = 0;
return TRUE;
case ASF_PCB_NAK:
#ifdef ELP_DEBUG
printk(KERN_DEBUG "%s: send_pcb got NAK\n", dev->name);
#endif
goto abort;
}
}
if (elp_debug >= 1)
printk(KERN_DEBUG "%s: timeout waiting for PCB acknowledge (status %02x)\n", dev->name, inb_status(dev->base_addr));
goto abort;
sti_abort:
spin_unlock_irqrestore(&adapter->lock, flags);
abort:
adapter->send_pcb_semaphore = 0;
return FALSE;
}
static bool send_pcb(struct net_device *dev, pcb_struct * pcb)
{
int i;
unsigned long timeout;
elp_device *adapter = netdev_priv(dev);
unsigned long flags;
check_3c505_dma(dev);
if (adapter->dmaing && adapter->current_dma.direction == 0)
return false;
if (test_and_set_bit(1, &adapter->send_pcb_semaphore)) {
if (elp_debug >= 3) {
pr_debug("%s: send_pcb entered while threaded\n", dev->name);
}
return false;
}
set_hsf(dev, 0);
if (send_pcb_slow(dev->base_addr, pcb->command))
goto abort;
spin_lock_irqsave(&adapter->lock, flags);
if (send_pcb_fast(dev->base_addr, pcb->length))
goto sti_abort;
for (i = 0; i < pcb->length; i++) {
if (send_pcb_fast(dev->base_addr, pcb->data.raw[i]))
goto sti_abort;
}
outb_control(adapter->hcr_val | 3, dev);
outb_command(2 + pcb->length, dev->base_addr);
spin_unlock_irqrestore(&adapter->lock, flags);
for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
switch (GET_ASF(dev->base_addr)) {
case ASF_PCB_ACK:
adapter->send_pcb_semaphore = 0;
return true;
case ASF_PCB_NAK:
#ifdef ELP_DEBUG
pr_debug("%s: send_pcb got NAK\n", dev->name);
#endif
goto abort;
}
}
if (elp_debug >= 1)
pr_debug("%s: timeout waiting for PCB acknowledge (status %02x)\n",
dev->name, inb_status(dev->base_addr));
goto abort;
sti_abort:
spin_unlock_irqrestore(&adapter->lock, flags);
abort:
adapter->send_pcb_semaphore = 0;
return false;
}