mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 12:16:42 +07:00
afc8eb46c0
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
1670 lines
42 KiB
C
1670 lines
42 KiB
C
/* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4 and 2.6.
|
|
*
|
|
* (c) Copyright 1998 Red Hat Software Inc
|
|
* Written by Alan Cox.
|
|
* Further debugging by Carl Drougge.
|
|
* Initial SMP support by Felipe W Damasio <felipewd@terra.com.br>
|
|
* Heavily modified by Richard Procter <rnp@paradise.net.nz>
|
|
*
|
|
* Based on skeleton.c written 1993-94 by Donald Becker and ne2.c
|
|
* (for the MCA stuff) written by Wim Dumon.
|
|
*
|
|
* Thanks to 3Com for making this possible by providing me with the
|
|
* documentation.
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*
|
|
*/
|
|
|
|
#define DRV_NAME "3c527"
|
|
#define DRV_VERSION "0.7-SMP"
|
|
#define DRV_RELDATE "2003/09/21"
|
|
|
|
static const char *version =
|
|
DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.nz>\n";
|
|
|
|
/**
|
|
* DOC: Traps for the unwary
|
|
*
|
|
* The diagram (Figure 1-1) and the POS summary disagree with the
|
|
* "Interrupt Level" section in the manual.
|
|
*
|
|
* The manual contradicts itself when describing the minimum number
|
|
* buffers in the 'configure lists' command.
|
|
* My card accepts a buffer config of 4/4.
|
|
*
|
|
* Setting the SAV BP bit does not save bad packets, but
|
|
* only enables RX on-card stats collection.
|
|
*
|
|
* The documentation in places seems to miss things. In actual fact
|
|
* I've always eventually found everything is documented, it just
|
|
* requires careful study.
|
|
*
|
|
* DOC: Theory Of Operation
|
|
*
|
|
* The 3com 3c527 is a 32bit MCA bus mastering adapter with a large
|
|
* amount of on board intelligence that housekeeps a somewhat dumber
|
|
* Intel NIC. For performance we want to keep the transmit queue deep
|
|
* as the card can transmit packets while fetching others from main
|
|
* memory by bus master DMA. Transmission and reception are driven by
|
|
* circular buffer queues.
|
|
*
|
|
* The mailboxes can be used for controlling how the card traverses
|
|
* its buffer rings, but are used only for inital setup in this
|
|
* implementation. The exec mailbox allows a variety of commands to
|
|
* be executed. Each command must complete before the next is
|
|
* executed. Primarily we use the exec mailbox for controlling the
|
|
* multicast lists. We have to do a certain amount of interesting
|
|
* hoop jumping as the multicast list changes can occur in interrupt
|
|
* state when the card has an exec command pending. We defer such
|
|
* events until the command completion interrupt.
|
|
*
|
|
* A copy break scheme (taken from 3c59x.c) is employed whereby
|
|
* received frames exceeding a configurable length are passed
|
|
* directly to the higher networking layers without incuring a copy,
|
|
* in what amounts to a time/space trade-off.
|
|
*
|
|
* The card also keeps a large amount of statistical information
|
|
* on-board. In a perfect world, these could be used safely at no
|
|
* cost. However, lacking information to the contrary, processing
|
|
* them without races would involve so much extra complexity as to
|
|
* make it unworthwhile to do so. In the end, a hybrid SW/HW
|
|
* implementation was made necessary --- see mc32_update_stats().
|
|
*
|
|
* DOC: Notes
|
|
*
|
|
* It should be possible to use two or more cards, but at this stage
|
|
* only by loading two copies of the same module.
|
|
*
|
|
* The on-board 82586 NIC has trouble receiving multiple
|
|
* back-to-back frames and so is likely to drop packets from fast
|
|
* senders.
|
|
**/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/mca-legacy.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/in.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/ethtool.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/semaphore.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
#include <asm/dma.h>
|
|
|
|
#include "3c527.h"
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
/*
|
|
* The name of the card. Is used for messages and in the requests for
|
|
* io regions, irqs and dma channels
|
|
*/
|
|
static const char* cardname = DRV_NAME;
|
|
|
|
/* use 0 for production, 1 for verification, >2 for debug */
|
|
#ifndef NET_DEBUG
|
|
#define NET_DEBUG 2
|
|
#endif
|
|
|
|
#undef DEBUG_IRQ
|
|
|
|
static unsigned int mc32_debug = NET_DEBUG;
|
|
|
|
/* The number of low I/O ports used by the ethercard. */
|
|
#define MC32_IO_EXTENT 8
|
|
|
|
/* As implemented, values must be a power-of-2 -- 4/8/16/32 */
|
|
#define TX_RING_LEN 32 /* Typically the card supports 37 */
|
|
#define RX_RING_LEN 8 /* " " " */
|
|
|
|
/* Copy break point, see above for details.
|
|
* Setting to > 1512 effectively disables this feature. */
|
|
#define RX_COPYBREAK 200 /* Value from 3c59x.c */
|
|
|
|
/* Issue the 82586 workaround command - this is for "busy lans", but
|
|
* basically means for all lans now days - has a performance (latency)
|
|
* cost, but best set. */
|
|
static const int WORKAROUND_82586=1;
|
|
|
|
/* Pointers to buffers and their on-card records */
|
|
struct mc32_ring_desc
|
|
{
|
|
volatile struct skb_header *p;
|
|
struct sk_buff *skb;
|
|
};
|
|
|
|
/* Information that needs to be kept for each board. */
|
|
struct mc32_local
|
|
{
|
|
int slot;
|
|
|
|
u32 base;
|
|
struct net_device_stats net_stats;
|
|
volatile struct mc32_mailbox *rx_box;
|
|
volatile struct mc32_mailbox *tx_box;
|
|
volatile struct mc32_mailbox *exec_box;
|
|
volatile struct mc32_stats *stats; /* Start of on-card statistics */
|
|
u16 tx_chain; /* Transmit list start offset */
|
|
u16 rx_chain; /* Receive list start offset */
|
|
u16 tx_len; /* Transmit list count */
|
|
u16 rx_len; /* Receive list count */
|
|
|
|
u16 xceiver_desired_state; /* HALTED or RUNNING */
|
|
u16 cmd_nonblocking; /* Thread is uninterested in command result */
|
|
u16 mc_reload_wait; /* A multicast load request is pending */
|
|
u32 mc_list_valid; /* True when the mclist is set */
|
|
|
|
struct mc32_ring_desc tx_ring[TX_RING_LEN]; /* Host Transmit ring */
|
|
struct mc32_ring_desc rx_ring[RX_RING_LEN]; /* Host Receive ring */
|
|
|
|
atomic_t tx_count; /* buffers left */
|
|
atomic_t tx_ring_head; /* index to tx en-queue end */
|
|
u16 tx_ring_tail; /* index to tx de-queue end */
|
|
|
|
u16 rx_ring_tail; /* index to rx de-queue end */
|
|
|
|
struct semaphore cmd_mutex; /* Serialises issuing of execute commands */
|
|
struct completion execution_cmd; /* Card has completed an execute command */
|
|
struct completion xceiver_cmd; /* Card has completed a tx or rx command */
|
|
};
|
|
|
|
/* The station (ethernet) address prefix, used for a sanity check. */
|
|
#define SA_ADDR0 0x02
|
|
#define SA_ADDR1 0x60
|
|
#define SA_ADDR2 0xAC
|
|
|
|
struct mca_adapters_t {
|
|
unsigned int id;
|
|
char *name;
|
|
};
|
|
|
|
static const struct mca_adapters_t mc32_adapters[] = {
|
|
{ 0x0041, "3COM EtherLink MC/32" },
|
|
{ 0x8EF5, "IBM High Performance Lan Adapter" },
|
|
{ 0x0000, NULL }
|
|
};
|
|
|
|
|
|
/* Macros for ring index manipulations */
|
|
static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
|
|
static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
|
|
|
|
static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
|
|
|
|
|
|
/* Index to functions, as function prototypes. */
|
|
static int mc32_probe1(struct net_device *dev, int ioaddr);
|
|
static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
|
|
static int mc32_open(struct net_device *dev);
|
|
static void mc32_timeout(struct net_device *dev);
|
|
static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
|
|
static irqreturn_t mc32_interrupt(int irq, void *dev_id);
|
|
static int mc32_close(struct net_device *dev);
|
|
static struct net_device_stats *mc32_get_stats(struct net_device *dev);
|
|
static void mc32_set_multicast_list(struct net_device *dev);
|
|
static void mc32_reset_multicast_list(struct net_device *dev);
|
|
static const struct ethtool_ops netdev_ethtool_ops;
|
|
|
|
static void cleanup_card(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
unsigned slot = lp->slot;
|
|
mca_mark_as_unused(slot);
|
|
mca_set_adapter_name(slot, NULL);
|
|
free_irq(dev->irq, dev);
|
|
release_region(dev->base_addr, MC32_IO_EXTENT);
|
|
}
|
|
|
|
/**
|
|
* mc32_probe - Search for supported boards
|
|
* @unit: interface number to use
|
|
*
|
|
* Because MCA bus is a real bus and we can scan for cards we could do a
|
|
* single scan for all boards here. Right now we use the passed in device
|
|
* structure and scan for only one board. This needs fixing for modules
|
|
* in particular.
|
|
*/
|
|
|
|
struct net_device *__init mc32_probe(int unit)
|
|
{
|
|
struct net_device *dev = alloc_etherdev(sizeof(struct mc32_local));
|
|
static int current_mca_slot = -1;
|
|
int i;
|
|
int err;
|
|
|
|
if (!dev)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
if (unit >= 0)
|
|
sprintf(dev->name, "eth%d", unit);
|
|
|
|
SET_MODULE_OWNER(dev);
|
|
|
|
/* Do not check any supplied i/o locations.
|
|
POS registers usually don't fail :) */
|
|
|
|
/* MCA cards have POS registers.
|
|
Autodetecting MCA cards is extremely simple.
|
|
Just search for the card. */
|
|
|
|
for(i = 0; (mc32_adapters[i].name != NULL); i++) {
|
|
current_mca_slot =
|
|
mca_find_unused_adapter(mc32_adapters[i].id, 0);
|
|
|
|
if(current_mca_slot != MCA_NOTFOUND) {
|
|
if(!mc32_probe1(dev, current_mca_slot))
|
|
{
|
|
mca_set_adapter_name(current_mca_slot,
|
|
mc32_adapters[i].name);
|
|
mca_mark_as_used(current_mca_slot);
|
|
err = register_netdev(dev);
|
|
if (err) {
|
|
cleanup_card(dev);
|
|
free_netdev(dev);
|
|
dev = ERR_PTR(err);
|
|
}
|
|
return dev;
|
|
}
|
|
|
|
}
|
|
}
|
|
free_netdev(dev);
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
/**
|
|
* mc32_probe1 - Check a given slot for a board and test the card
|
|
* @dev: Device structure to fill in
|
|
* @slot: The MCA bus slot being used by this card
|
|
*
|
|
* Decode the slot data and configure the card structures. Having done this we
|
|
* can reset the card and configure it. The card does a full self test cycle
|
|
* in firmware so we have to wait for it to return and post us either a
|
|
* failure case or some addresses we use to find the board internals.
|
|
*/
|
|
|
|
static int __init mc32_probe1(struct net_device *dev, int slot)
|
|
{
|
|
static unsigned version_printed;
|
|
int i, err;
|
|
u8 POS;
|
|
u32 base;
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
static u16 mca_io_bases[]={
|
|
0x7280,0x7290,
|
|
0x7680,0x7690,
|
|
0x7A80,0x7A90,
|
|
0x7E80,0x7E90
|
|
};
|
|
static u32 mca_mem_bases[]={
|
|
0x00C0000,
|
|
0x00C4000,
|
|
0x00C8000,
|
|
0x00CC000,
|
|
0x00D0000,
|
|
0x00D4000,
|
|
0x00D8000,
|
|
0x00DC000
|
|
};
|
|
static char *failures[]={
|
|
"Processor instruction",
|
|
"Processor data bus",
|
|
"Processor data bus",
|
|
"Processor data bus",
|
|
"Adapter bus",
|
|
"ROM checksum",
|
|
"Base RAM",
|
|
"Extended RAM",
|
|
"82586 internal loopback",
|
|
"82586 initialisation failure",
|
|
"Adapter list configuration error"
|
|
};
|
|
|
|
/* Time to play MCA games */
|
|
|
|
if (mc32_debug && version_printed++ == 0)
|
|
printk(KERN_DEBUG "%s", version);
|
|
|
|
printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
|
|
|
|
POS = mca_read_stored_pos(slot, 2);
|
|
|
|
if(!(POS&1))
|
|
{
|
|
printk(" disabled.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* Fill in the 'dev' fields. */
|
|
dev->base_addr = mca_io_bases[(POS>>1)&7];
|
|
dev->mem_start = mca_mem_bases[(POS>>4)&7];
|
|
|
|
POS = mca_read_stored_pos(slot, 4);
|
|
if(!(POS&1))
|
|
{
|
|
printk("memory window disabled.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
POS = mca_read_stored_pos(slot, 5);
|
|
|
|
i=(POS>>4)&3;
|
|
if(i==3)
|
|
{
|
|
printk("invalid memory window.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
i*=16384;
|
|
i+=16384;
|
|
|
|
dev->mem_end=dev->mem_start + i;
|
|
|
|
dev->irq = ((POS>>2)&3)+9;
|
|
|
|
if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
|
|
{
|
|
printk("io 0x%3lX, which is busy.\n", dev->base_addr);
|
|
return -EBUSY;
|
|
}
|
|
|
|
printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
|
|
dev->base_addr, dev->irq, dev->mem_start, i/1024);
|
|
|
|
|
|
/* We ought to set the cache line size here.. */
|
|
|
|
|
|
/*
|
|
* Go PROM browsing
|
|
*/
|
|
|
|
printk("%s: Address ", dev->name);
|
|
|
|
/* Retrieve and print the ethernet address. */
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
mca_write_pos(slot, 6, i+12);
|
|
mca_write_pos(slot, 7, 0);
|
|
|
|
printk(" %2.2x", dev->dev_addr[i] = mca_read_pos(slot,3));
|
|
}
|
|
|
|
mca_write_pos(slot, 6, 0);
|
|
mca_write_pos(slot, 7, 0);
|
|
|
|
POS = mca_read_stored_pos(slot, 4);
|
|
|
|
if(POS&2)
|
|
printk(" : BNC port selected.\n");
|
|
else
|
|
printk(" : AUI port selected.\n");
|
|
|
|
POS=inb(dev->base_addr+HOST_CTRL);
|
|
POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
|
|
POS&=~HOST_CTRL_INTE;
|
|
outb(POS, dev->base_addr+HOST_CTRL);
|
|
/* Reset adapter */
|
|
udelay(100);
|
|
/* Reset off */
|
|
POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
|
|
outb(POS, dev->base_addr+HOST_CTRL);
|
|
|
|
udelay(300);
|
|
|
|
/*
|
|
* Grab the IRQ
|
|
*/
|
|
|
|
err = request_irq(dev->irq, &mc32_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DRV_NAME, dev);
|
|
if (err) {
|
|
release_region(dev->base_addr, MC32_IO_EXTENT);
|
|
printk(KERN_ERR "%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
|
|
goto err_exit_ports;
|
|
}
|
|
|
|
memset(lp, 0, sizeof(struct mc32_local));
|
|
lp->slot = slot;
|
|
|
|
i=0;
|
|
|
|
base = inb(dev->base_addr);
|
|
|
|
while(base == 0xFF)
|
|
{
|
|
i++;
|
|
if(i == 1000)
|
|
{
|
|
printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
|
|
err = -ENODEV;
|
|
goto err_exit_irq;
|
|
}
|
|
udelay(1000);
|
|
if(inb(dev->base_addr+2)&(1<<5))
|
|
base = inb(dev->base_addr);
|
|
}
|
|
|
|
if(base>0)
|
|
{
|
|
if(base < 0x0C)
|
|
printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
|
|
base<0x0A?" test failure":"");
|
|
else
|
|
printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
|
|
err = -ENODEV;
|
|
goto err_exit_irq;
|
|
}
|
|
|
|
base=0;
|
|
for(i=0;i<4;i++)
|
|
{
|
|
int n=0;
|
|
|
|
while(!(inb(dev->base_addr+2)&(1<<5)))
|
|
{
|
|
n++;
|
|
udelay(50);
|
|
if(n>100)
|
|
{
|
|
printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
|
|
err = -ENODEV;
|
|
goto err_exit_irq;
|
|
}
|
|
}
|
|
|
|
base|=(inb(dev->base_addr)<<(8*i));
|
|
}
|
|
|
|
lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
|
|
|
|
base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
|
|
|
|
lp->base = dev->mem_start+base;
|
|
|
|
lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]);
|
|
lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
|
|
|
|
lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
|
|
|
|
/*
|
|
* Descriptor chains (card relative)
|
|
*/
|
|
|
|
lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
|
|
lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
|
|
lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
|
|
lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
|
|
|
|
init_MUTEX_LOCKED(&lp->cmd_mutex);
|
|
init_completion(&lp->execution_cmd);
|
|
init_completion(&lp->xceiver_cmd);
|
|
|
|
printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
|
|
dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
|
|
|
|
dev->open = mc32_open;
|
|
dev->stop = mc32_close;
|
|
dev->hard_start_xmit = mc32_send_packet;
|
|
dev->get_stats = mc32_get_stats;
|
|
dev->set_multicast_list = mc32_set_multicast_list;
|
|
dev->tx_timeout = mc32_timeout;
|
|
dev->watchdog_timeo = HZ*5; /* Board does all the work */
|
|
dev->ethtool_ops = &netdev_ethtool_ops;
|
|
|
|
return 0;
|
|
|
|
err_exit_irq:
|
|
free_irq(dev->irq, dev);
|
|
err_exit_ports:
|
|
release_region(dev->base_addr, MC32_IO_EXTENT);
|
|
return err;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_ready_poll - wait until we can feed it a command
|
|
* @dev: The device to wait for
|
|
*
|
|
* Wait until the card becomes ready to accept a command via the
|
|
* command register. This tells us nothing about the completion
|
|
* status of any pending commands and takes very little time at all.
|
|
*/
|
|
|
|
static inline void mc32_ready_poll(struct net_device *dev)
|
|
{
|
|
int ioaddr = dev->base_addr;
|
|
while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_command_nowait - send a command non blocking
|
|
* @dev: The 3c527 to issue the command to
|
|
* @cmd: The command word to write to the mailbox
|
|
* @data: A data block if the command expects one
|
|
* @len: Length of the data block
|
|
*
|
|
* Send a command from interrupt state. If there is a command
|
|
* currently being executed then we return an error of -1. It
|
|
* simply isn't viable to wait around as commands may be
|
|
* slow. This can theoretically be starved on SMP, but it's hard
|
|
* to see a realistic situation. We do not wait for the command
|
|
* to complete --- we rely on the interrupt handler to tidy up
|
|
* after us.
|
|
*/
|
|
|
|
static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int ioaddr = dev->base_addr;
|
|
int ret = -1;
|
|
|
|
if (down_trylock(&lp->cmd_mutex) == 0)
|
|
{
|
|
lp->cmd_nonblocking=1;
|
|
lp->exec_box->mbox=0;
|
|
lp->exec_box->mbox=cmd;
|
|
memcpy((void *)lp->exec_box->data, data, len);
|
|
barrier(); /* the memcpy forgot the volatile so be sure */
|
|
|
|
/* Send the command */
|
|
mc32_ready_poll(dev);
|
|
outb(1<<6, ioaddr+HOST_CMD);
|
|
|
|
ret = 0;
|
|
|
|
/* Interrupt handler will signal mutex on completion */
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_command - send a command and sleep until completion
|
|
* @dev: The 3c527 card to issue the command to
|
|
* @cmd: The command word to write to the mailbox
|
|
* @data: A data block if the command expects one
|
|
* @len: Length of the data block
|
|
*
|
|
* Sends exec commands in a user context. This permits us to wait around
|
|
* for the replies and also to wait for the command buffer to complete
|
|
* from a previous command before we execute our command. After our
|
|
* command completes we will attempt any pending multicast reload
|
|
* we blocked off by hogging the exec buffer.
|
|
*
|
|
* You feed the card a command, you wait, it interrupts you get a
|
|
* reply. All well and good. The complication arises because you use
|
|
* commands for filter list changes which come in at bh level from things
|
|
* like IPV6 group stuff.
|
|
*/
|
|
|
|
static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int ioaddr = dev->base_addr;
|
|
int ret = 0;
|
|
|
|
down(&lp->cmd_mutex);
|
|
|
|
/*
|
|
* My Turn
|
|
*/
|
|
|
|
lp->cmd_nonblocking=0;
|
|
lp->exec_box->mbox=0;
|
|
lp->exec_box->mbox=cmd;
|
|
memcpy((void *)lp->exec_box->data, data, len);
|
|
barrier(); /* the memcpy forgot the volatile so be sure */
|
|
|
|
mc32_ready_poll(dev);
|
|
outb(1<<6, ioaddr+HOST_CMD);
|
|
|
|
wait_for_completion(&lp->execution_cmd);
|
|
|
|
if(lp->exec_box->mbox&(1<<13))
|
|
ret = -1;
|
|
|
|
up(&lp->cmd_mutex);
|
|
|
|
/*
|
|
* A multicast set got blocked - try it now
|
|
*/
|
|
|
|
if(lp->mc_reload_wait)
|
|
{
|
|
mc32_reset_multicast_list(dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_start_transceiver - tell board to restart tx/rx
|
|
* @dev: The 3c527 card to issue the command to
|
|
*
|
|
* This may be called from the interrupt state, where it is used
|
|
* to restart the rx ring if the card runs out of rx buffers.
|
|
*
|
|
* We must first check if it's ok to (re)start the transceiver. See
|
|
* mc32_close for details.
|
|
*/
|
|
|
|
static void mc32_start_transceiver(struct net_device *dev) {
|
|
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int ioaddr = dev->base_addr;
|
|
|
|
/* Ignore RX overflow on device closure */
|
|
if (lp->xceiver_desired_state==HALTED)
|
|
return;
|
|
|
|
/* Give the card the offset to the post-EOL-bit RX descriptor */
|
|
mc32_ready_poll(dev);
|
|
lp->rx_box->mbox=0;
|
|
lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
|
|
outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
|
|
|
|
mc32_ready_poll(dev);
|
|
lp->tx_box->mbox=0;
|
|
outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD); /* card ignores this on RX restart */
|
|
|
|
/* We are not interrupted on start completion */
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_halt_transceiver - tell board to stop tx/rx
|
|
* @dev: The 3c527 card to issue the command to
|
|
*
|
|
* We issue the commands to halt the card's transceiver. In fact,
|
|
* after some experimenting we now simply tell the card to
|
|
* suspend. When issuing aborts occasionally odd things happened.
|
|
*
|
|
* We then sleep until the card has notified us that both rx and
|
|
* tx have been suspended.
|
|
*/
|
|
|
|
static void mc32_halt_transceiver(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int ioaddr = dev->base_addr;
|
|
|
|
mc32_ready_poll(dev);
|
|
lp->rx_box->mbox=0;
|
|
outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
|
|
wait_for_completion(&lp->xceiver_cmd);
|
|
|
|
mc32_ready_poll(dev);
|
|
lp->tx_box->mbox=0;
|
|
outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
|
|
wait_for_completion(&lp->xceiver_cmd);
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_load_rx_ring - load the ring of receive buffers
|
|
* @dev: 3c527 to build the ring for
|
|
*
|
|
* This initalises the on-card and driver datastructures to
|
|
* the point where mc32_start_transceiver() can be called.
|
|
*
|
|
* The card sets up the receive ring for us. We are required to use the
|
|
* ring it provides, although the size of the ring is configurable.
|
|
*
|
|
* We allocate an sk_buff for each ring entry in turn and
|
|
* initalise its house-keeping info. At the same time, we read
|
|
* each 'next' pointer in our rx_ring array. This reduces slow
|
|
* shared-memory reads and makes it easy to access predecessor
|
|
* descriptors.
|
|
*
|
|
* We then set the end-of-list bit for the last entry so that the
|
|
* card will know when it has run out of buffers.
|
|
*/
|
|
|
|
static int mc32_load_rx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int i;
|
|
u16 rx_base;
|
|
volatile struct skb_header *p;
|
|
|
|
rx_base=lp->rx_chain;
|
|
|
|
for(i=0; i<RX_RING_LEN; i++) {
|
|
lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
|
|
if (lp->rx_ring[i].skb==NULL) {
|
|
for (;i>=0;i--)
|
|
kfree_skb(lp->rx_ring[i].skb);
|
|
return -ENOBUFS;
|
|
}
|
|
skb_reserve(lp->rx_ring[i].skb, 18);
|
|
|
|
p=isa_bus_to_virt(lp->base+rx_base);
|
|
|
|
p->control=0;
|
|
p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
|
|
p->status=0;
|
|
p->length=1532;
|
|
|
|
lp->rx_ring[i].p=p;
|
|
rx_base=p->next;
|
|
}
|
|
|
|
lp->rx_ring[i-1].p->control |= CONTROL_EOL;
|
|
|
|
lp->rx_ring_tail=0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_flush_rx_ring - free the ring of receive buffers
|
|
* @lp: Local data of 3c527 to flush the rx ring of
|
|
*
|
|
* Free the buffer for each ring slot. This may be called
|
|
* before mc32_load_rx_ring(), eg. on error in mc32_open().
|
|
* Requires rx skb pointers to point to a valid skb, or NULL.
|
|
*/
|
|
|
|
static void mc32_flush_rx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int i;
|
|
|
|
for(i=0; i < RX_RING_LEN; i++)
|
|
{
|
|
if (lp->rx_ring[i].skb) {
|
|
dev_kfree_skb(lp->rx_ring[i].skb);
|
|
lp->rx_ring[i].skb = NULL;
|
|
}
|
|
lp->rx_ring[i].p=NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_load_tx_ring - load transmit ring
|
|
* @dev: The 3c527 card to issue the command to
|
|
*
|
|
* This sets up the host transmit data-structures.
|
|
*
|
|
* First, we obtain from the card it's current postion in the tx
|
|
* ring, so that we will know where to begin transmitting
|
|
* packets.
|
|
*
|
|
* Then, we read the 'next' pointers from the on-card tx ring into
|
|
* our tx_ring array to reduce slow shared-mem reads. Finally, we
|
|
* intitalise the tx house keeping variables.
|
|
*
|
|
*/
|
|
|
|
static void mc32_load_tx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
volatile struct skb_header *p;
|
|
int i;
|
|
u16 tx_base;
|
|
|
|
tx_base=lp->tx_box->data[0];
|
|
|
|
for(i=0 ; i<TX_RING_LEN ; i++)
|
|
{
|
|
p=isa_bus_to_virt(lp->base+tx_base);
|
|
lp->tx_ring[i].p=p;
|
|
lp->tx_ring[i].skb=NULL;
|
|
|
|
tx_base=p->next;
|
|
}
|
|
|
|
/* -1 so that tx_ring_head cannot "lap" tx_ring_tail */
|
|
/* see mc32_tx_ring */
|
|
|
|
atomic_set(&lp->tx_count, TX_RING_LEN-1);
|
|
atomic_set(&lp->tx_ring_head, 0);
|
|
lp->tx_ring_tail=0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_flush_tx_ring - free transmit ring
|
|
* @lp: Local data of 3c527 to flush the tx ring of
|
|
*
|
|
* If the ring is non-empty, zip over the it, freeing any
|
|
* allocated skb_buffs. The tx ring house-keeping variables are
|
|
* then reset. Requires rx skb pointers to point to a valid skb,
|
|
* or NULL.
|
|
*/
|
|
|
|
static void mc32_flush_tx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int i;
|
|
|
|
for (i=0; i < TX_RING_LEN; i++)
|
|
{
|
|
if (lp->tx_ring[i].skb)
|
|
{
|
|
dev_kfree_skb(lp->tx_ring[i].skb);
|
|
lp->tx_ring[i].skb = NULL;
|
|
}
|
|
}
|
|
|
|
atomic_set(&lp->tx_count, 0);
|
|
atomic_set(&lp->tx_ring_head, 0);
|
|
lp->tx_ring_tail=0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_open - handle 'up' of card
|
|
* @dev: device to open
|
|
*
|
|
* The user is trying to bring the card into ready state. This requires
|
|
* a brief dialogue with the card. Firstly we enable interrupts and then
|
|
* 'indications'. Without these enabled the card doesn't bother telling
|
|
* us what it has done. This had me puzzled for a week.
|
|
*
|
|
* We configure the number of card descriptors, then load the network
|
|
* address and multicast filters. Turn on the workaround mode. This
|
|
* works around a bug in the 82586 - it asks the firmware to do
|
|
* so. It has a performance (latency) hit but is needed on busy
|
|
* [read most] lans. We load the ring with buffers then we kick it
|
|
* all off.
|
|
*/
|
|
|
|
static int mc32_open(struct net_device *dev)
|
|
{
|
|
int ioaddr = dev->base_addr;
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
u8 one=1;
|
|
u8 regs;
|
|
u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
|
|
|
|
/*
|
|
* Interrupts enabled
|
|
*/
|
|
|
|
regs=inb(ioaddr+HOST_CTRL);
|
|
regs|=HOST_CTRL_INTE;
|
|
outb(regs, ioaddr+HOST_CTRL);
|
|
|
|
/*
|
|
* Allow ourselves to issue commands
|
|
*/
|
|
|
|
up(&lp->cmd_mutex);
|
|
|
|
|
|
/*
|
|
* Send the indications on command
|
|
*/
|
|
|
|
mc32_command(dev, 4, &one, 2);
|
|
|
|
/*
|
|
* Poke it to make sure it's really dead.
|
|
*/
|
|
|
|
mc32_halt_transceiver(dev);
|
|
mc32_flush_tx_ring(dev);
|
|
|
|
/*
|
|
* Ask card to set up on-card descriptors to our spec
|
|
*/
|
|
|
|
if(mc32_command(dev, 8, descnumbuffs, 4)) {
|
|
printk("%s: %s rejected our buffer configuration!\n",
|
|
dev->name, cardname);
|
|
mc32_close(dev);
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
/* Report new configuration */
|
|
mc32_command(dev, 6, NULL, 0);
|
|
|
|
lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */
|
|
lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */
|
|
lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */
|
|
lp->rx_len = lp->exec_box->data[11]; /* Receive list count */
|
|
|
|
/* Set Network Address */
|
|
mc32_command(dev, 1, dev->dev_addr, 6);
|
|
|
|
/* Set the filters */
|
|
mc32_set_multicast_list(dev);
|
|
|
|
if (WORKAROUND_82586) {
|
|
u16 zero_word=0;
|
|
mc32_command(dev, 0x0D, &zero_word, 2); /* 82586 bug workaround on */
|
|
}
|
|
|
|
mc32_load_tx_ring(dev);
|
|
|
|
if(mc32_load_rx_ring(dev))
|
|
{
|
|
mc32_close(dev);
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
lp->xceiver_desired_state = RUNNING;
|
|
|
|
/* And finally, set the ball rolling... */
|
|
mc32_start_transceiver(dev);
|
|
|
|
netif_start_queue(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_timeout - handle a timeout from the network layer
|
|
* @dev: 3c527 that timed out
|
|
*
|
|
* Handle a timeout on transmit from the 3c527. This normally means
|
|
* bad things as the hardware handles cable timeouts and mess for
|
|
* us.
|
|
*
|
|
*/
|
|
|
|
static void mc32_timeout(struct net_device *dev)
|
|
{
|
|
printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
|
|
/* Try to restart the adaptor. */
|
|
netif_wake_queue(dev);
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_send_packet - queue a frame for transmit
|
|
* @skb: buffer to transmit
|
|
* @dev: 3c527 to send it out of
|
|
*
|
|
* Transmit a buffer. This normally means throwing the buffer onto
|
|
* the transmit queue as the queue is quite large. If the queue is
|
|
* full then we set tx_busy and return. Once the interrupt handler
|
|
* gets messages telling it to reclaim transmit queue entries, we will
|
|
* clear tx_busy and the kernel will start calling this again.
|
|
*
|
|
* We do not disable interrupts or acquire any locks; this can
|
|
* run concurrently with mc32_tx_ring(), and the function itself
|
|
* is serialised at a higher layer. However, similarly for the
|
|
* card itself, we must ensure that we update tx_ring_head only
|
|
* after we've established a valid packet on the tx ring (and
|
|
* before we let the card "see" it, to prevent it racing with the
|
|
* irq handler).
|
|
*
|
|
*/
|
|
|
|
static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
u32 head = atomic_read(&lp->tx_ring_head);
|
|
|
|
volatile struct skb_header *p, *np;
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
if(atomic_read(&lp->tx_count)==0) {
|
|
return 1;
|
|
}
|
|
|
|
if (skb_padto(skb, ETH_ZLEN)) {
|
|
netif_wake_queue(dev);
|
|
return 0;
|
|
}
|
|
|
|
atomic_dec(&lp->tx_count);
|
|
|
|
/* P is the last sending/sent buffer as a pointer */
|
|
p=lp->tx_ring[head].p;
|
|
|
|
head = next_tx(head);
|
|
|
|
/* NP is the buffer we will be loading */
|
|
np=lp->tx_ring[head].p;
|
|
|
|
/* We will need this to flush the buffer out */
|
|
lp->tx_ring[head].skb=skb;
|
|
|
|
np->length = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
|
|
np->data = isa_virt_to_bus(skb->data);
|
|
np->status = 0;
|
|
np->control = CONTROL_EOP | CONTROL_EOL;
|
|
wmb();
|
|
|
|
/*
|
|
* The new frame has been setup; we can now
|
|
* let the interrupt handler and card "see" it
|
|
*/
|
|
|
|
atomic_set(&lp->tx_ring_head, head);
|
|
p->control &= ~CONTROL_EOL;
|
|
|
|
netif_wake_queue(dev);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_update_stats - pull off the on board statistics
|
|
* @dev: 3c527 to service
|
|
*
|
|
*
|
|
* Query and reset the on-card stats. There's the small possibility
|
|
* of a race here, which would result in an underestimation of
|
|
* actual errors. As such, we'd prefer to keep all our stats
|
|
* collection in software. As a rule, we do. However it can't be
|
|
* used for rx errors and collisions as, by default, the card discards
|
|
* bad rx packets.
|
|
*
|
|
* Setting the SAV BP in the rx filter command supposedly
|
|
* stops this behaviour. However, testing shows that it only seems to
|
|
* enable the collation of on-card rx statistics --- the driver
|
|
* never sees an RX descriptor with an error status set.
|
|
*
|
|
*/
|
|
|
|
static void mc32_update_stats(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
volatile struct mc32_stats *st = lp->stats;
|
|
|
|
u32 rx_errors=0;
|
|
|
|
rx_errors+=lp->net_stats.rx_crc_errors +=st->rx_crc_errors;
|
|
st->rx_crc_errors=0;
|
|
rx_errors+=lp->net_stats.rx_fifo_errors +=st->rx_overrun_errors;
|
|
st->rx_overrun_errors=0;
|
|
rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors;
|
|
st->rx_alignment_errors=0;
|
|
rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors;
|
|
st->rx_tooshort_errors=0;
|
|
rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
|
|
st->rx_outofresource_errors=0;
|
|
lp->net_stats.rx_errors=rx_errors;
|
|
|
|
/* Number of packets which saw one collision */
|
|
lp->net_stats.collisions+=st->dataC[10];
|
|
st->dataC[10]=0;
|
|
|
|
/* Number of packets which saw 2--15 collisions */
|
|
lp->net_stats.collisions+=st->dataC[11];
|
|
st->dataC[11]=0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_rx_ring - process the receive ring
|
|
* @dev: 3c527 that needs its receive ring processing
|
|
*
|
|
*
|
|
* We have received one or more indications from the card that a
|
|
* receive has completed. The buffer ring thus contains dirty
|
|
* entries. We walk the ring by iterating over the circular rx_ring
|
|
* array, starting at the next dirty buffer (which happens to be the
|
|
* one we finished up at last time around).
|
|
*
|
|
* For each completed packet, we will either copy it and pass it up
|
|
* the stack or, if the packet is near MTU sized, we allocate
|
|
* another buffer and flip the old one up the stack.
|
|
*
|
|
* We must succeed in keeping a buffer on the ring. If necessary we
|
|
* will toss a received packet rather than lose a ring entry. Once
|
|
* the first uncompleted descriptor is found, we move the
|
|
* End-Of-List bit to include the buffers just processed.
|
|
*
|
|
*/
|
|
|
|
static void mc32_rx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
volatile struct skb_header *p;
|
|
u16 rx_ring_tail;
|
|
u16 rx_old_tail;
|
|
int x=0;
|
|
|
|
rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
|
|
|
|
do
|
|
{
|
|
p=lp->rx_ring[rx_ring_tail].p;
|
|
|
|
if(!(p->status & (1<<7))) { /* Not COMPLETED */
|
|
break;
|
|
}
|
|
if(p->status & (1<<6)) /* COMPLETED_OK */
|
|
{
|
|
|
|
u16 length=p->length;
|
|
struct sk_buff *skb;
|
|
struct sk_buff *newskb;
|
|
|
|
/* Try to save time by avoiding a copy on big frames */
|
|
|
|
if ((length > RX_COPYBREAK)
|
|
&& ((newskb=dev_alloc_skb(1532)) != NULL))
|
|
{
|
|
skb=lp->rx_ring[rx_ring_tail].skb;
|
|
skb_put(skb, length);
|
|
|
|
skb_reserve(newskb,18);
|
|
lp->rx_ring[rx_ring_tail].skb=newskb;
|
|
p->data=isa_virt_to_bus(newskb->data);
|
|
}
|
|
else
|
|
{
|
|
skb=dev_alloc_skb(length+2);
|
|
|
|
if(skb==NULL) {
|
|
lp->net_stats.rx_dropped++;
|
|
goto dropped;
|
|
}
|
|
|
|
skb_reserve(skb,2);
|
|
memcpy(skb_put(skb, length),
|
|
lp->rx_ring[rx_ring_tail].skb->data, length);
|
|
}
|
|
|
|
skb->protocol=eth_type_trans(skb,dev);
|
|
skb->dev=dev;
|
|
dev->last_rx = jiffies;
|
|
lp->net_stats.rx_packets++;
|
|
lp->net_stats.rx_bytes += length;
|
|
netif_rx(skb);
|
|
}
|
|
|
|
dropped:
|
|
p->length = 1532;
|
|
p->status = 0;
|
|
|
|
rx_ring_tail=next_rx(rx_ring_tail);
|
|
}
|
|
while(x++<48);
|
|
|
|
/* If there was actually a frame to be processed, place the EOL bit */
|
|
/* at the descriptor prior to the one to be filled next */
|
|
|
|
if (rx_ring_tail != rx_old_tail)
|
|
{
|
|
lp->rx_ring[prev_rx(rx_ring_tail)].p->control |= CONTROL_EOL;
|
|
lp->rx_ring[prev_rx(rx_old_tail)].p->control &= ~CONTROL_EOL;
|
|
|
|
lp->rx_ring_tail=rx_ring_tail;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_tx_ring - process completed transmits
|
|
* @dev: 3c527 that needs its transmit ring processing
|
|
*
|
|
*
|
|
* This operates in a similar fashion to mc32_rx_ring. We iterate
|
|
* over the transmit ring. For each descriptor which has been
|
|
* processed by the card, we free its associated buffer and note
|
|
* any errors. This continues until the transmit ring is emptied
|
|
* or we reach a descriptor that hasn't yet been processed by the
|
|
* card.
|
|
*
|
|
*/
|
|
|
|
static void mc32_tx_ring(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
volatile struct skb_header *np;
|
|
|
|
/*
|
|
* We rely on head==tail to mean 'queue empty'.
|
|
* This is why lp->tx_count=TX_RING_LEN-1: in order to prevent
|
|
* tx_ring_head wrapping to tail and confusing a 'queue empty'
|
|
* condition with 'queue full'
|
|
*/
|
|
|
|
while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))
|
|
{
|
|
u16 t;
|
|
|
|
t=next_tx(lp->tx_ring_tail);
|
|
np=lp->tx_ring[t].p;
|
|
|
|
if(!(np->status & (1<<7)))
|
|
{
|
|
/* Not COMPLETED */
|
|
break;
|
|
}
|
|
lp->net_stats.tx_packets++;
|
|
if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
|
|
{
|
|
lp->net_stats.tx_errors++;
|
|
|
|
switch(np->status&0x0F)
|
|
{
|
|
case 1:
|
|
lp->net_stats.tx_aborted_errors++;
|
|
break; /* Max collisions */
|
|
case 2:
|
|
lp->net_stats.tx_fifo_errors++;
|
|
break;
|
|
case 3:
|
|
lp->net_stats.tx_carrier_errors++;
|
|
break;
|
|
case 4:
|
|
lp->net_stats.tx_window_errors++;
|
|
break; /* CTS Lost */
|
|
case 5:
|
|
lp->net_stats.tx_aborted_errors++;
|
|
break; /* Transmit timeout */
|
|
}
|
|
}
|
|
/* Packets are sent in order - this is
|
|
basically a FIFO queue of buffers matching
|
|
the card ring */
|
|
lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
|
|
dev_kfree_skb_irq(lp->tx_ring[t].skb);
|
|
lp->tx_ring[t].skb=NULL;
|
|
atomic_inc(&lp->tx_count);
|
|
netif_wake_queue(dev);
|
|
|
|
lp->tx_ring_tail=t;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_interrupt - handle an interrupt from a 3c527
|
|
* @irq: Interrupt number
|
|
* @dev_id: 3c527 that requires servicing
|
|
* @regs: Registers (unused)
|
|
*
|
|
*
|
|
* An interrupt is raised whenever the 3c527 writes to the command
|
|
* register. This register contains the message it wishes to send us
|
|
* packed into a single byte field. We keep reading status entries
|
|
* until we have processed all the control items, but simply count
|
|
* transmit and receive reports. When all reports are in we empty the
|
|
* transceiver rings as appropriate. This saves the overhead of
|
|
* multiple command requests.
|
|
*
|
|
* Because MCA is level-triggered, we shouldn't miss indications.
|
|
* Therefore, we needn't ask the card to suspend interrupts within
|
|
* this handler. The card receives an implicit acknowledgment of the
|
|
* current interrupt when we read the command register.
|
|
*
|
|
*/
|
|
|
|
static irqreturn_t mc32_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct net_device *dev = dev_id;
|
|
struct mc32_local *lp;
|
|
int ioaddr, status, boguscount = 0;
|
|
int rx_event = 0;
|
|
int tx_event = 0;
|
|
|
|
ioaddr = dev->base_addr;
|
|
lp = netdev_priv(dev);
|
|
|
|
/* See whats cooking */
|
|
|
|
while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
|
|
{
|
|
status=inb(ioaddr+HOST_CMD);
|
|
|
|
#ifdef DEBUG_IRQ
|
|
printk("Status TX%d RX%d EX%d OV%d BC%d\n",
|
|
(status&7), (status>>3)&7, (status>>6)&1,
|
|
(status>>7)&1, boguscount);
|
|
#endif
|
|
|
|
switch(status&7)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 6: /* TX fail */
|
|
case 2: /* TX ok */
|
|
tx_event = 1;
|
|
break;
|
|
case 3: /* Halt */
|
|
case 4: /* Abort */
|
|
complete(&lp->xceiver_cmd);
|
|
break;
|
|
default:
|
|
printk("%s: strange tx ack %d\n", dev->name, status&7);
|
|
}
|
|
status>>=3;
|
|
switch(status&7)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 2: /* RX */
|
|
rx_event=1;
|
|
break;
|
|
case 3: /* Halt */
|
|
case 4: /* Abort */
|
|
complete(&lp->xceiver_cmd);
|
|
break;
|
|
case 6:
|
|
/* Out of RX buffers stat */
|
|
/* Must restart rx */
|
|
lp->net_stats.rx_dropped++;
|
|
mc32_rx_ring(dev);
|
|
mc32_start_transceiver(dev);
|
|
break;
|
|
default:
|
|
printk("%s: strange rx ack %d\n",
|
|
dev->name, status&7);
|
|
}
|
|
status>>=3;
|
|
if(status&1)
|
|
{
|
|
/*
|
|
* No thread is waiting: we need to tidy
|
|
* up ourself.
|
|
*/
|
|
|
|
if (lp->cmd_nonblocking) {
|
|
up(&lp->cmd_mutex);
|
|
if (lp->mc_reload_wait)
|
|
mc32_reset_multicast_list(dev);
|
|
}
|
|
else complete(&lp->execution_cmd);
|
|
}
|
|
if(status&2)
|
|
{
|
|
/*
|
|
* We get interrupted once per
|
|
* counter that is about to overflow.
|
|
*/
|
|
|
|
mc32_update_stats(dev);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Process the transmit and receive rings
|
|
*/
|
|
|
|
if(tx_event)
|
|
mc32_tx_ring(dev);
|
|
|
|
if(rx_event)
|
|
mc32_rx_ring(dev);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_close - user configuring the 3c527 down
|
|
* @dev: 3c527 card to shut down
|
|
*
|
|
* The 3c527 is a bus mastering device. We must be careful how we
|
|
* shut it down. It may also be running shared interrupt so we have
|
|
* to be sure to silence it properly
|
|
*
|
|
* We indicate that the card is closing to the rest of the
|
|
* driver. Otherwise, it is possible that the card may run out
|
|
* of receive buffers and restart the transceiver while we're
|
|
* trying to close it.
|
|
*
|
|
* We abort any receive and transmits going on and then wait until
|
|
* any pending exec commands have completed in other code threads.
|
|
* In theory we can't get here while that is true, in practice I am
|
|
* paranoid
|
|
*
|
|
* We turn off the interrupt enable for the board to be sure it can't
|
|
* intefere with other devices.
|
|
*/
|
|
|
|
static int mc32_close(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
int ioaddr = dev->base_addr;
|
|
|
|
u8 regs;
|
|
u16 one=1;
|
|
|
|
lp->xceiver_desired_state = HALTED;
|
|
netif_stop_queue(dev);
|
|
|
|
/*
|
|
* Send the indications on command (handy debug check)
|
|
*/
|
|
|
|
mc32_command(dev, 4, &one, 2);
|
|
|
|
/* Shut down the transceiver */
|
|
|
|
mc32_halt_transceiver(dev);
|
|
|
|
/* Ensure we issue no more commands beyond this point */
|
|
|
|
down(&lp->cmd_mutex);
|
|
|
|
/* Ok the card is now stopping */
|
|
|
|
regs=inb(ioaddr+HOST_CTRL);
|
|
regs&=~HOST_CTRL_INTE;
|
|
outb(regs, ioaddr+HOST_CTRL);
|
|
|
|
mc32_flush_rx_ring(dev);
|
|
mc32_flush_tx_ring(dev);
|
|
|
|
mc32_update_stats(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_get_stats - hand back stats to network layer
|
|
* @dev: The 3c527 card to handle
|
|
*
|
|
* We've collected all the stats we can in software already. Now
|
|
* it's time to update those kept on-card and return the lot.
|
|
*
|
|
*/
|
|
|
|
static struct net_device_stats *mc32_get_stats(struct net_device *dev)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
|
|
mc32_update_stats(dev);
|
|
return &lp->net_stats;
|
|
}
|
|
|
|
|
|
/**
|
|
* do_mc32_set_multicast_list - attempt to update multicasts
|
|
* @dev: 3c527 device to load the list on
|
|
* @retry: indicates this is not the first call.
|
|
*
|
|
*
|
|
* Actually set or clear the multicast filter for this adaptor. The
|
|
* locking issues are handled by this routine. We have to track
|
|
* state as it may take multiple calls to get the command sequence
|
|
* completed. We just keep trying to schedule the loads until we
|
|
* manage to process them all.
|
|
*
|
|
* num_addrs == -1 Promiscuous mode, receive all packets
|
|
*
|
|
* num_addrs == 0 Normal mode, clear multicast list
|
|
*
|
|
* num_addrs > 0 Multicast mode, receive normal and MC packets,
|
|
* and do best-effort filtering.
|
|
*
|
|
* See mc32_update_stats() regards setting the SAV BP bit.
|
|
*
|
|
*/
|
|
|
|
static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
|
|
{
|
|
struct mc32_local *lp = netdev_priv(dev);
|
|
u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */
|
|
|
|
if (dev->flags&IFF_PROMISC)
|
|
/* Enable promiscuous mode */
|
|
filt |= 1;
|
|
else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
|
|
{
|
|
dev->flags|=IFF_PROMISC;
|
|
filt |= 1;
|
|
}
|
|
else if(dev->mc_count)
|
|
{
|
|
unsigned char block[62];
|
|
unsigned char *bp;
|
|
struct dev_mc_list *dmc=dev->mc_list;
|
|
|
|
int i;
|
|
|
|
if(retry==0)
|
|
lp->mc_list_valid = 0;
|
|
if(!lp->mc_list_valid)
|
|
{
|
|
block[1]=0;
|
|
block[0]=dev->mc_count;
|
|
bp=block+2;
|
|
|
|
for(i=0;i<dev->mc_count;i++)
|
|
{
|
|
memcpy(bp, dmc->dmi_addr, 6);
|
|
bp+=6;
|
|
dmc=dmc->next;
|
|
}
|
|
if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
|
|
{
|
|
lp->mc_reload_wait = 1;
|
|
return;
|
|
}
|
|
lp->mc_list_valid=1;
|
|
}
|
|
}
|
|
|
|
if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
|
|
{
|
|
lp->mc_reload_wait = 1;
|
|
}
|
|
else {
|
|
lp->mc_reload_wait = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_set_multicast_list - queue multicast list update
|
|
* @dev: The 3c527 to use
|
|
*
|
|
* Commence loading the multicast list. This is called when the kernel
|
|
* changes the lists. It will override any pending list we are trying to
|
|
* load.
|
|
*/
|
|
|
|
static void mc32_set_multicast_list(struct net_device *dev)
|
|
{
|
|
do_mc32_set_multicast_list(dev,0);
|
|
}
|
|
|
|
|
|
/**
|
|
* mc32_reset_multicast_list - reset multicast list
|
|
* @dev: The 3c527 to use
|
|
*
|
|
* Attempt the next step in loading the multicast lists. If this attempt
|
|
* fails to complete then it will be scheduled and this function called
|
|
* again later from elsewhere.
|
|
*/
|
|
|
|
static void mc32_reset_multicast_list(struct net_device *dev)
|
|
{
|
|
do_mc32_set_multicast_list(dev,1);
|
|
}
|
|
|
|
static void netdev_get_drvinfo(struct net_device *dev,
|
|
struct ethtool_drvinfo *info)
|
|
{
|
|
strcpy(info->driver, DRV_NAME);
|
|
strcpy(info->version, DRV_VERSION);
|
|
sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
|
|
}
|
|
|
|
static u32 netdev_get_msglevel(struct net_device *dev)
|
|
{
|
|
return mc32_debug;
|
|
}
|
|
|
|
static void netdev_set_msglevel(struct net_device *dev, u32 level)
|
|
{
|
|
mc32_debug = level;
|
|
}
|
|
|
|
static const struct ethtool_ops netdev_ethtool_ops = {
|
|
.get_drvinfo = netdev_get_drvinfo,
|
|
.get_msglevel = netdev_get_msglevel,
|
|
.set_msglevel = netdev_set_msglevel,
|
|
};
|
|
|
|
#ifdef MODULE
|
|
|
|
static struct net_device *this_device;
|
|
|
|
/**
|
|
* init_module - entry point
|
|
*
|
|
* Probe and locate a 3c527 card. This really should probe and locate
|
|
* all the 3c527 cards in the machine not just one of them. Yes you can
|
|
* insmod multiple modules for now but it's a hack.
|
|
*/
|
|
|
|
int __init init_module(void)
|
|
{
|
|
this_device = mc32_probe(-1);
|
|
if (IS_ERR(this_device))
|
|
return PTR_ERR(this_device);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* cleanup_module - free resources for an unload
|
|
*
|
|
* Unloading time. We release the MCA bus resources and the interrupt
|
|
* at which point everything is ready to unload. The card must be stopped
|
|
* at this point or we would not have been called. When we unload we
|
|
* leave the card stopped but not totally shut down. When the card is
|
|
* initialized it must be rebooted or the rings reloaded before any
|
|
* transmit operations are allowed to start scribbling into memory.
|
|
*/
|
|
|
|
void __exit cleanup_module(void)
|
|
{
|
|
unregister_netdev(this_device);
|
|
cleanup_card(this_device);
|
|
free_netdev(this_device);
|
|
}
|
|
|
|
#endif /* MODULE */
|