mirror of
https://github.com/torvalds/linux.git
synced 2024-11-16 17:12:06 +00:00
7d12e780e0
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
1278 lines
32 KiB
C
1278 lines
32 KiB
C
/*
|
|
* xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
|
|
*
|
|
* This software is (C) by the respective authors, and licensed under the GPL
|
|
* License.
|
|
*
|
|
* Written by Arjan van de Ven for Red Hat, Inc.
|
|
* Based on work by Jeff Garzik, Doug Ledford and Donald Becker
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*
|
|
*
|
|
* $Id: xircom_cb.c,v 1.33 2001/03/19 14:02:07 arjanv Exp $
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/init.h>
|
|
#include <linux/ethtool.h>
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
#include <asm/io.h>
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
#include <asm/irq.h>
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
#define enter(x) printk("Enter: %s, %s line %i\n",x,__FILE__,__LINE__)
|
|
#define leave(x) printk("Leave: %s, %s line %i\n",x,__FILE__,__LINE__)
|
|
#else
|
|
#define enter(x) do {} while (0)
|
|
#define leave(x) do {} while (0)
|
|
#endif
|
|
|
|
|
|
MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
|
|
MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
/* IO registers on the card, offsets */
|
|
#define CSR0 0x00
|
|
#define CSR1 0x08
|
|
#define CSR2 0x10
|
|
#define CSR3 0x18
|
|
#define CSR4 0x20
|
|
#define CSR5 0x28
|
|
#define CSR6 0x30
|
|
#define CSR7 0x38
|
|
#define CSR8 0x40
|
|
#define CSR9 0x48
|
|
#define CSR10 0x50
|
|
#define CSR11 0x58
|
|
#define CSR12 0x60
|
|
#define CSR13 0x68
|
|
#define CSR14 0x70
|
|
#define CSR15 0x78
|
|
#define CSR16 0x80
|
|
|
|
/* PCI registers */
|
|
#define PCI_POWERMGMT 0x40
|
|
|
|
/* Offsets of the buffers within the descriptor pages, in bytes */
|
|
|
|
#define NUMDESCRIPTORS 4
|
|
|
|
static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
|
|
|
|
|
|
struct xircom_private {
|
|
/* Send and receive buffers, kernel-addressable and dma addressable forms */
|
|
|
|
unsigned int *rx_buffer;
|
|
unsigned int *tx_buffer;
|
|
|
|
dma_addr_t rx_dma_handle;
|
|
dma_addr_t tx_dma_handle;
|
|
|
|
struct sk_buff *tx_skb[4];
|
|
|
|
unsigned long io_port;
|
|
int open;
|
|
|
|
/* transmit_used is the rotating counter that indicates which transmit
|
|
descriptor has to be used next */
|
|
int transmit_used;
|
|
|
|
/* Spinlock to serialize register operations.
|
|
It must be helt while manipulating the following registers:
|
|
CSR0, CSR6, CSR7, CSR9, CSR10, CSR15
|
|
*/
|
|
spinlock_t lock;
|
|
|
|
|
|
struct pci_dev *pdev;
|
|
struct net_device *dev;
|
|
struct net_device_stats stats;
|
|
};
|
|
|
|
|
|
/* Function prototypes */
|
|
static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
|
|
static void xircom_remove(struct pci_dev *pdev);
|
|
static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
|
|
static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
|
|
static int xircom_open(struct net_device *dev);
|
|
static int xircom_close(struct net_device *dev);
|
|
static void xircom_up(struct xircom_private *card);
|
|
static struct net_device_stats *xircom_get_stats(struct net_device *dev);
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
static void xircom_poll_controller(struct net_device *dev);
|
|
#endif
|
|
|
|
static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
|
|
static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
|
|
static void read_mac_address(struct xircom_private *card);
|
|
static void transceiver_voodoo(struct xircom_private *card);
|
|
static void initialize_card(struct xircom_private *card);
|
|
static void trigger_transmit(struct xircom_private *card);
|
|
static void trigger_receive(struct xircom_private *card);
|
|
static void setup_descriptors(struct xircom_private *card);
|
|
static void remove_descriptors(struct xircom_private *card);
|
|
static int link_status_changed(struct xircom_private *card);
|
|
static void activate_receiver(struct xircom_private *card);
|
|
static void deactivate_receiver(struct xircom_private *card);
|
|
static void activate_transmitter(struct xircom_private *card);
|
|
static void deactivate_transmitter(struct xircom_private *card);
|
|
static void enable_transmit_interrupt(struct xircom_private *card);
|
|
static void enable_receive_interrupt(struct xircom_private *card);
|
|
static void enable_link_interrupt(struct xircom_private *card);
|
|
static void disable_all_interrupts(struct xircom_private *card);
|
|
static int link_status(struct xircom_private *card);
|
|
|
|
|
|
|
|
static struct pci_device_id xircom_pci_table[] = {
|
|
{0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
|
|
{0,},
|
|
};
|
|
MODULE_DEVICE_TABLE(pci, xircom_pci_table);
|
|
|
|
static struct pci_driver xircom_ops = {
|
|
.name = "xircom_cb",
|
|
.id_table = xircom_pci_table,
|
|
.probe = xircom_probe,
|
|
.remove = xircom_remove,
|
|
.suspend =NULL,
|
|
.resume =NULL
|
|
};
|
|
|
|
|
|
#ifdef DEBUG
|
|
static void print_binary(unsigned int number)
|
|
{
|
|
int i,i2;
|
|
char buffer[64];
|
|
memset(buffer,0,64);
|
|
i2=0;
|
|
for (i=31;i>=0;i--) {
|
|
if (number & (1<<i))
|
|
buffer[i2++]='1';
|
|
else
|
|
buffer[i2++]='0';
|
|
if ((i&3)==0)
|
|
buffer[i2++]=' ';
|
|
}
|
|
printk("%s\n",buffer);
|
|
}
|
|
#endif
|
|
|
|
static void netdev_get_drvinfo(struct net_device *dev,
|
|
struct ethtool_drvinfo *info)
|
|
{
|
|
struct xircom_private *private = netdev_priv(dev);
|
|
|
|
strcpy(info->driver, "xircom_cb");
|
|
strcpy(info->bus_info, pci_name(private->pdev));
|
|
}
|
|
|
|
static const struct ethtool_ops netdev_ethtool_ops = {
|
|
.get_drvinfo = netdev_get_drvinfo,
|
|
};
|
|
|
|
/* xircom_probe is the code that gets called on device insertion.
|
|
it sets up the hardware and registers the device to the networklayer.
|
|
|
|
TODO: Send 1 or 2 "dummy" packets here as the card seems to discard the
|
|
first two packets that get send, and pump hates that.
|
|
|
|
*/
|
|
static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
|
{
|
|
struct net_device *dev = NULL;
|
|
struct xircom_private *private;
|
|
unsigned char chip_rev;
|
|
unsigned long flags;
|
|
unsigned short tmp16;
|
|
enter("xircom_probe");
|
|
|
|
/* First do the PCI initialisation */
|
|
|
|
if (pci_enable_device(pdev))
|
|
return -ENODEV;
|
|
|
|
/* disable all powermanagement */
|
|
pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
|
|
|
|
pci_set_master(pdev); /* Why isn't this done by pci_enable_device ?*/
|
|
|
|
/* clear PCI status, if any */
|
|
pci_read_config_word (pdev,PCI_STATUS, &tmp16);
|
|
pci_write_config_word (pdev, PCI_STATUS,tmp16);
|
|
|
|
pci_read_config_byte(pdev, PCI_REVISION_ID, &chip_rev);
|
|
|
|
if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
|
|
printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*
|
|
Before changing the hardware, allocate the memory.
|
|
This way, we can fail gracefully if not enough memory
|
|
is available.
|
|
*/
|
|
dev = alloc_etherdev(sizeof(struct xircom_private));
|
|
if (!dev) {
|
|
printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
|
|
goto device_fail;
|
|
}
|
|
private = netdev_priv(dev);
|
|
|
|
/* Allocate the send/receive buffers */
|
|
private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
|
|
if (private->rx_buffer == NULL) {
|
|
printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
|
|
goto rx_buf_fail;
|
|
}
|
|
private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
|
|
if (private->tx_buffer == NULL) {
|
|
printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
|
|
goto tx_buf_fail;
|
|
}
|
|
|
|
SET_MODULE_OWNER(dev);
|
|
SET_NETDEV_DEV(dev, &pdev->dev);
|
|
|
|
|
|
private->dev = dev;
|
|
private->pdev = pdev;
|
|
private->io_port = pci_resource_start(pdev, 0);
|
|
spin_lock_init(&private->lock);
|
|
dev->irq = pdev->irq;
|
|
dev->base_addr = private->io_port;
|
|
|
|
initialize_card(private);
|
|
read_mac_address(private);
|
|
setup_descriptors(private);
|
|
|
|
dev->open = &xircom_open;
|
|
dev->hard_start_xmit = &xircom_start_xmit;
|
|
dev->stop = &xircom_close;
|
|
dev->get_stats = &xircom_get_stats;
|
|
dev->priv = private;
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
dev->poll_controller = &xircom_poll_controller;
|
|
#endif
|
|
SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
|
|
pci_set_drvdata(pdev, dev);
|
|
|
|
if (register_netdev(dev)) {
|
|
printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
|
|
goto reg_fail;
|
|
}
|
|
|
|
printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, chip_rev, pdev->irq);
|
|
/* start the transmitter to get a heartbeat */
|
|
/* TODO: send 2 dummy packets here */
|
|
transceiver_voodoo(private);
|
|
|
|
spin_lock_irqsave(&private->lock,flags);
|
|
activate_transmitter(private);
|
|
activate_receiver(private);
|
|
spin_unlock_irqrestore(&private->lock,flags);
|
|
|
|
trigger_receive(private);
|
|
|
|
leave("xircom_probe");
|
|
return 0;
|
|
|
|
reg_fail:
|
|
kfree(private->tx_buffer);
|
|
tx_buf_fail:
|
|
kfree(private->rx_buffer);
|
|
rx_buf_fail:
|
|
free_netdev(dev);
|
|
device_fail:
|
|
return -ENODEV;
|
|
}
|
|
|
|
|
|
/*
|
|
xircom_remove is called on module-unload or on device-eject.
|
|
it unregisters the irq, io-region and network device.
|
|
Interrupts and such are already stopped in the "ifconfig ethX down"
|
|
code.
|
|
*/
|
|
static void __devexit xircom_remove(struct pci_dev *pdev)
|
|
{
|
|
struct net_device *dev = pci_get_drvdata(pdev);
|
|
struct xircom_private *card = netdev_priv(dev);
|
|
|
|
enter("xircom_remove");
|
|
pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
|
|
pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
|
|
|
|
release_region(dev->base_addr, 128);
|
|
unregister_netdev(dev);
|
|
free_netdev(dev);
|
|
pci_set_drvdata(pdev, NULL);
|
|
leave("xircom_remove");
|
|
}
|
|
|
|
static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
|
|
{
|
|
struct net_device *dev = (struct net_device *) dev_instance;
|
|
struct xircom_private *card = netdev_priv(dev);
|
|
unsigned int status;
|
|
int i;
|
|
|
|
enter("xircom_interrupt\n");
|
|
|
|
spin_lock(&card->lock);
|
|
status = inl(card->io_port+CSR5);
|
|
|
|
#ifdef DEBUG
|
|
print_binary(status);
|
|
printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
|
|
printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
|
|
#endif
|
|
/* Handle shared irq and hotplug */
|
|
if (status == 0 || status == 0xffffffff) {
|
|
spin_unlock(&card->lock);
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
if (link_status_changed(card)) {
|
|
int newlink;
|
|
printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
|
|
newlink = link_status(card);
|
|
printk(KERN_INFO "xircom_cb: Link is %i mbit \n",newlink);
|
|
if (newlink)
|
|
netif_carrier_on(dev);
|
|
else
|
|
netif_carrier_off(dev);
|
|
|
|
}
|
|
|
|
/* Clear all remaining interrupts */
|
|
status |= 0xffffffff; /* FIXME: make this clear only the
|
|
real existing bits */
|
|
outl(status,card->io_port+CSR5);
|
|
|
|
|
|
for (i=0;i<NUMDESCRIPTORS;i++)
|
|
investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
|
|
for (i=0;i<NUMDESCRIPTORS;i++)
|
|
investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
|
|
|
|
|
|
spin_unlock(&card->lock);
|
|
leave("xircom_interrupt");
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
struct xircom_private *card;
|
|
unsigned long flags;
|
|
int nextdescriptor;
|
|
int desc;
|
|
enter("xircom_start_xmit");
|
|
|
|
card = netdev_priv(dev);
|
|
spin_lock_irqsave(&card->lock,flags);
|
|
|
|
/* First see if we can free some descriptors */
|
|
for (desc=0;desc<NUMDESCRIPTORS;desc++)
|
|
investigate_write_descriptor(dev,card,desc,bufferoffsets[desc]);
|
|
|
|
|
|
nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
|
|
desc = card->transmit_used;
|
|
|
|
/* only send the packet if the descriptor is free */
|
|
if (card->tx_buffer[4*desc]==0) {
|
|
/* Copy the packet data; zero the memory first as the card
|
|
sometimes sends more than you ask it to. */
|
|
|
|
memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
|
|
memcpy(&(card->tx_buffer[bufferoffsets[desc]/4]),skb->data,skb->len);
|
|
|
|
|
|
/* FIXME: The specification tells us that the length we send HAS to be a multiple of
|
|
4 bytes. */
|
|
|
|
card->tx_buffer[4*desc+1] = skb->len;
|
|
if (desc == NUMDESCRIPTORS-1)
|
|
card->tx_buffer[4*desc+1] |= (1<<25); /* bit 25: last descriptor of the ring */
|
|
|
|
card->tx_buffer[4*desc+1] |= 0xF0000000;
|
|
/* 0xF0... means want interrupts*/
|
|
card->tx_skb[desc] = skb;
|
|
|
|
wmb();
|
|
/* This gives the descriptor to the card */
|
|
card->tx_buffer[4*desc] = 0x80000000;
|
|
trigger_transmit(card);
|
|
if (((int)card->tx_buffer[nextdescriptor*4])<0) { /* next descriptor is occupied... */
|
|
netif_stop_queue(dev);
|
|
}
|
|
card->transmit_used = nextdescriptor;
|
|
leave("xircom-start_xmit - sent");
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/* Uh oh... no free descriptor... drop the packet */
|
|
netif_stop_queue(dev);
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
trigger_transmit(card);
|
|
|
|
return -EIO;
|
|
}
|
|
|
|
|
|
|
|
|
|
static int xircom_open(struct net_device *dev)
|
|
{
|
|
struct xircom_private *xp = netdev_priv(dev);
|
|
int retval;
|
|
enter("xircom_open");
|
|
printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
|
|
retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
|
|
if (retval) {
|
|
leave("xircom_open - No IRQ");
|
|
return retval;
|
|
}
|
|
|
|
xircom_up(xp);
|
|
xp->open = 1;
|
|
leave("xircom_open");
|
|
return 0;
|
|
}
|
|
|
|
static int xircom_close(struct net_device *dev)
|
|
{
|
|
struct xircom_private *card;
|
|
unsigned long flags;
|
|
|
|
enter("xircom_close");
|
|
card = netdev_priv(dev);
|
|
netif_stop_queue(dev); /* we don't want new packets */
|
|
|
|
|
|
spin_lock_irqsave(&card->lock,flags);
|
|
|
|
disable_all_interrupts(card);
|
|
#if 0
|
|
/* We can enable this again once we send dummy packets on ifconfig ethX up */
|
|
deactivate_receiver(card);
|
|
deactivate_transmitter(card);
|
|
#endif
|
|
remove_descriptors(card);
|
|
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
|
|
card->open = 0;
|
|
free_irq(dev->irq,dev);
|
|
|
|
leave("xircom_close");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_device_stats *xircom_get_stats(struct net_device *dev)
|
|
{
|
|
struct xircom_private *card = netdev_priv(dev);
|
|
return &card->stats;
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
static void xircom_poll_controller(struct net_device *dev)
|
|
{
|
|
disable_irq(dev->irq);
|
|
xircom_interrupt(dev->irq, dev);
|
|
enable_irq(dev->irq);
|
|
}
|
|
#endif
|
|
|
|
|
|
static void initialize_card(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
unsigned long flags;
|
|
enter("initialize_card");
|
|
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
/* First: reset the card */
|
|
val = inl(card->io_port + CSR0);
|
|
val |= 0x01; /* Software reset */
|
|
outl(val, card->io_port + CSR0);
|
|
|
|
udelay(100); /* give the card some time to reset */
|
|
|
|
val = inl(card->io_port + CSR0);
|
|
val &= ~0x01; /* disable Software reset */
|
|
outl(val, card->io_port + CSR0);
|
|
|
|
|
|
val = 0; /* Value 0x00 is a safe and conservative value
|
|
for the PCI configuration settings */
|
|
outl(val, card->io_port + CSR0);
|
|
|
|
|
|
disable_all_interrupts(card);
|
|
deactivate_receiver(card);
|
|
deactivate_transmitter(card);
|
|
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
|
|
leave("initialize_card");
|
|
}
|
|
|
|
/*
|
|
trigger_transmit causes the card to check for frames to be transmitted.
|
|
This is accomplished by writing to the CSR1 port. The documentation
|
|
claims that the act of writing is sufficient and that the value is
|
|
ignored; I chose zero.
|
|
*/
|
|
static void trigger_transmit(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("trigger_transmit");
|
|
|
|
val = 0;
|
|
outl(val, card->io_port + CSR1);
|
|
|
|
leave("trigger_transmit");
|
|
}
|
|
|
|
/*
|
|
trigger_receive causes the card to check for empty frames in the
|
|
descriptor list in which packets can be received.
|
|
This is accomplished by writing to the CSR2 port. The documentation
|
|
claims that the act of writing is sufficient and that the value is
|
|
ignored; I chose zero.
|
|
*/
|
|
static void trigger_receive(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("trigger_receive");
|
|
|
|
val = 0;
|
|
outl(val, card->io_port + CSR2);
|
|
|
|
leave("trigger_receive");
|
|
}
|
|
|
|
/*
|
|
setup_descriptors initializes the send and receive buffers to be valid
|
|
descriptors and programs the addresses into the card.
|
|
*/
|
|
static void setup_descriptors(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
unsigned int address;
|
|
int i;
|
|
enter("setup_descriptors");
|
|
|
|
|
|
BUG_ON(card->rx_buffer == NULL);
|
|
BUG_ON(card->tx_buffer == NULL);
|
|
|
|
/* Receive descriptors */
|
|
memset(card->rx_buffer, 0, 128); /* clear the descriptors */
|
|
for (i=0;i<NUMDESCRIPTORS;i++ ) {
|
|
|
|
/* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
|
|
card->rx_buffer[i*4 + 0] = 0x80000000;
|
|
/* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
|
|
card->rx_buffer[i*4 + 1] = 1536;
|
|
if (i==NUMDESCRIPTORS-1)
|
|
card->rx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
|
|
|
|
/* Rx Descr2: address of the buffer
|
|
we store the buffer at the 2nd half of the page */
|
|
|
|
address = (unsigned long) card->rx_dma_handle;
|
|
card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
|
|
/* Rx Desc3: address of 2nd buffer -> 0 */
|
|
card->rx_buffer[i*4 + 3] = 0;
|
|
}
|
|
|
|
wmb();
|
|
/* Write the receive descriptor ring address to the card */
|
|
address = (unsigned long) card->rx_dma_handle;
|
|
val = cpu_to_le32(address);
|
|
outl(val, card->io_port + CSR3); /* Receive descr list address */
|
|
|
|
|
|
/* transmit descriptors */
|
|
memset(card->tx_buffer, 0, 128); /* clear the descriptors */
|
|
|
|
for (i=0;i<NUMDESCRIPTORS;i++ ) {
|
|
/* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
|
|
card->tx_buffer[i*4 + 0] = 0x00000000;
|
|
/* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
|
|
card->tx_buffer[i*4 + 1] = 1536;
|
|
if (i==NUMDESCRIPTORS-1)
|
|
card->tx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
|
|
|
|
/* Tx Descr2: address of the buffer
|
|
we store the buffer at the 2nd half of the page */
|
|
address = (unsigned long) card->tx_dma_handle;
|
|
card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
|
|
/* Tx Desc3: address of 2nd buffer -> 0 */
|
|
card->tx_buffer[i*4 + 3] = 0;
|
|
}
|
|
|
|
wmb();
|
|
/* wite the transmit descriptor ring to the card */
|
|
address = (unsigned long) card->tx_dma_handle;
|
|
val =cpu_to_le32(address);
|
|
outl(val, card->io_port + CSR4); /* xmit descr list address */
|
|
|
|
leave("setup_descriptors");
|
|
}
|
|
|
|
/*
|
|
remove_descriptors informs the card the descriptors are no longer
|
|
valid by setting the address in the card to 0x00.
|
|
*/
|
|
static void remove_descriptors(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("remove_descriptors");
|
|
|
|
val = 0;
|
|
outl(val, card->io_port + CSR3); /* Receive descriptor address */
|
|
outl(val, card->io_port + CSR4); /* Send descriptor address */
|
|
|
|
leave("remove_descriptors");
|
|
}
|
|
|
|
/*
|
|
link_status_changed returns 1 if the card has indicated that
|
|
the link status has changed. The new link status has to be read from CSR12.
|
|
|
|
This function also clears the status-bit.
|
|
*/
|
|
static int link_status_changed(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("link_status_changed");
|
|
|
|
val = inl(card->io_port + CSR5); /* Status register */
|
|
|
|
if ((val & (1 << 27)) == 0) { /* no change */
|
|
leave("link_status_changed - nochange");
|
|
return 0;
|
|
}
|
|
|
|
/* clear the event by writing a 1 to the bit in the
|
|
status register. */
|
|
val = (1 << 27);
|
|
outl(val, card->io_port + CSR5);
|
|
|
|
leave("link_status_changed - changed");
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
transmit_active returns 1 if the transmitter on the card is
|
|
in a non-stopped state.
|
|
*/
|
|
static int transmit_active(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("transmit_active");
|
|
|
|
val = inl(card->io_port + CSR5); /* Status register */
|
|
|
|
if ((val & (7 << 20)) == 0) { /* transmitter disabled */
|
|
leave("transmit_active - inactive");
|
|
return 0;
|
|
}
|
|
|
|
leave("transmit_active - active");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
receive_active returns 1 if the receiver on the card is
|
|
in a non-stopped state.
|
|
*/
|
|
static int receive_active(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("receive_active");
|
|
|
|
|
|
val = inl(card->io_port + CSR5); /* Status register */
|
|
|
|
if ((val & (7 << 17)) == 0) { /* receiver disabled */
|
|
leave("receive_active - inactive");
|
|
return 0;
|
|
}
|
|
|
|
leave("receive_active - active");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
activate_receiver enables the receiver on the card.
|
|
Before being allowed to active the receiver, the receiver
|
|
must be completely de-activated. To achieve this,
|
|
this code actually disables the receiver first; then it waits for the
|
|
receiver to become inactive, then it activates the receiver and then
|
|
it waits for the receiver to be active.
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void activate_receiver(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
int counter;
|
|
enter("activate_receiver");
|
|
|
|
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
|
|
/* If the "active" bit is set and the receiver is already
|
|
active, no need to do the expensive thing */
|
|
if ((val&2) && (receive_active(card)))
|
|
return;
|
|
|
|
|
|
val = val & ~2; /* disable the receiver */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
counter = 10;
|
|
while (counter > 0) {
|
|
if (!receive_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
|
|
}
|
|
|
|
/* enable the receiver */
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
val = val | 2; /* enable the receiver */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
/* now wait for the card to activate again */
|
|
counter = 10;
|
|
while (counter > 0) {
|
|
if (receive_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
|
|
}
|
|
|
|
leave("activate_receiver");
|
|
}
|
|
|
|
/*
|
|
deactivate_receiver disables the receiver on the card.
|
|
To achieve this this code disables the receiver first;
|
|
then it waits for the receiver to become inactive.
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void deactivate_receiver(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
int counter;
|
|
enter("deactivate_receiver");
|
|
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
val = val & ~2; /* disable the receiver */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
counter = 10;
|
|
while (counter > 0) {
|
|
if (!receive_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
|
|
}
|
|
|
|
|
|
leave("deactivate_receiver");
|
|
}
|
|
|
|
|
|
/*
|
|
activate_transmitter enables the transmitter on the card.
|
|
Before being allowed to active the transmitter, the transmitter
|
|
must be completely de-activated. To achieve this,
|
|
this code actually disables the transmitter first; then it waits for the
|
|
transmitter to become inactive, then it activates the transmitter and then
|
|
it waits for the transmitter to be active again.
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void activate_transmitter(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
int counter;
|
|
enter("activate_transmitter");
|
|
|
|
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
|
|
/* If the "active" bit is set and the receiver is already
|
|
active, no need to do the expensive thing */
|
|
if ((val&(1<<13)) && (transmit_active(card)))
|
|
return;
|
|
|
|
val = val & ~(1 << 13); /* disable the transmitter */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
counter = 10;
|
|
while (counter > 0) {
|
|
if (!transmit_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
|
|
}
|
|
|
|
/* enable the transmitter */
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
val = val | (1 << 13); /* enable the transmitter */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
/* now wait for the card to activate again */
|
|
counter = 10;
|
|
while (counter > 0) {
|
|
if (transmit_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
|
|
}
|
|
|
|
leave("activate_transmitter");
|
|
}
|
|
|
|
/*
|
|
deactivate_transmitter disables the transmitter on the card.
|
|
To achieve this this code disables the transmitter first;
|
|
then it waits for the transmitter to become inactive.
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void deactivate_transmitter(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
int counter;
|
|
enter("deactivate_transmitter");
|
|
|
|
val = inl(card->io_port + CSR6); /* Operation mode */
|
|
val = val & ~2; /* disable the transmitter */
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
counter = 20;
|
|
while (counter > 0) {
|
|
if (!transmit_active(card))
|
|
break;
|
|
/* wait a while */
|
|
udelay(50);
|
|
counter--;
|
|
if (counter <= 0)
|
|
printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
|
|
}
|
|
|
|
|
|
leave("deactivate_transmitter");
|
|
}
|
|
|
|
|
|
/*
|
|
enable_transmit_interrupt enables the transmit interrupt
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void enable_transmit_interrupt(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_transmit_interrupt");
|
|
|
|
val = inl(card->io_port + CSR7); /* Interrupt enable register */
|
|
val |= 1; /* enable the transmit interrupt */
|
|
outl(val, card->io_port + CSR7);
|
|
|
|
leave("enable_transmit_interrupt");
|
|
}
|
|
|
|
|
|
/*
|
|
enable_receive_interrupt enables the receive interrupt
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void enable_receive_interrupt(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_receive_interrupt");
|
|
|
|
val = inl(card->io_port + CSR7); /* Interrupt enable register */
|
|
val = val | (1 << 6); /* enable the receive interrupt */
|
|
outl(val, card->io_port + CSR7);
|
|
|
|
leave("enable_receive_interrupt");
|
|
}
|
|
|
|
/*
|
|
enable_link_interrupt enables the link status change interrupt
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void enable_link_interrupt(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_link_interrupt");
|
|
|
|
val = inl(card->io_port + CSR7); /* Interrupt enable register */
|
|
val = val | (1 << 27); /* enable the link status chage interrupt */
|
|
outl(val, card->io_port + CSR7);
|
|
|
|
leave("enable_link_interrupt");
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
disable_all_interrupts disables all interrupts
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void disable_all_interrupts(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_all_interrupts");
|
|
|
|
val = 0; /* disable all interrupts */
|
|
outl(val, card->io_port + CSR7);
|
|
|
|
leave("disable_all_interrupts");
|
|
}
|
|
|
|
/*
|
|
enable_common_interrupts enables several weird interrupts
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static void enable_common_interrupts(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_link_interrupt");
|
|
|
|
val = inl(card->io_port + CSR7); /* Interrupt enable register */
|
|
val |= (1<<16); /* Normal Interrupt Summary */
|
|
val |= (1<<15); /* Abnormal Interrupt Summary */
|
|
val |= (1<<13); /* Fatal bus error */
|
|
val |= (1<<8); /* Receive Process Stopped */
|
|
val |= (1<<7); /* Receive Buffer Unavailable */
|
|
val |= (1<<5); /* Transmit Underflow */
|
|
val |= (1<<2); /* Transmit Buffer Unavailable */
|
|
val |= (1<<1); /* Transmit Process Stopped */
|
|
outl(val, card->io_port + CSR7);
|
|
|
|
leave("enable_link_interrupt");
|
|
}
|
|
|
|
/*
|
|
enable_promisc starts promisc mode
|
|
|
|
must be called with the lock held and interrupts disabled.
|
|
*/
|
|
static int enable_promisc(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("enable_promisc");
|
|
|
|
val = inl(card->io_port + CSR6);
|
|
val = val | (1 << 6);
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
leave("enable_promisc");
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
link_status() checks the the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
|
|
|
|
Must be called in locked state with interrupts disabled
|
|
*/
|
|
static int link_status(struct xircom_private *card)
|
|
{
|
|
unsigned int val;
|
|
enter("link_status");
|
|
|
|
val = inb(card->io_port + CSR12);
|
|
|
|
if (!(val&(1<<2))) /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
|
|
return 10;
|
|
if (!(val&(1<<1))) /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
|
|
return 100;
|
|
|
|
/* If we get here -> no link at all */
|
|
|
|
leave("link_status");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
|
|
|
|
This function will take the spinlock itself and can, as a result, not be called with the lock helt.
|
|
*/
|
|
static void read_mac_address(struct xircom_private *card)
|
|
{
|
|
unsigned char j, tuple, link, data_id, data_count;
|
|
unsigned long flags;
|
|
int i;
|
|
|
|
enter("read_mac_address");
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
outl(1 << 12, card->io_port + CSR9); /* enable boot rom access */
|
|
for (i = 0x100; i < 0x1f7; i += link + 2) {
|
|
outl(i, card->io_port + CSR10);
|
|
tuple = inl(card->io_port + CSR9) & 0xff;
|
|
outl(i + 1, card->io_port + CSR10);
|
|
link = inl(card->io_port + CSR9) & 0xff;
|
|
outl(i + 2, card->io_port + CSR10);
|
|
data_id = inl(card->io_port + CSR9) & 0xff;
|
|
outl(i + 3, card->io_port + CSR10);
|
|
data_count = inl(card->io_port + CSR9) & 0xff;
|
|
if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
|
|
/*
|
|
* This is it. We have the data we want.
|
|
*/
|
|
for (j = 0; j < 6; j++) {
|
|
outl(i + j + 4, card->io_port + CSR10);
|
|
card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
|
|
}
|
|
break;
|
|
} else if (link == 0) {
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
#ifdef DEBUG
|
|
for (i = 0; i < 6; i++)
|
|
printk("%c%2.2X", i ? ':' : ' ', card->dev->dev_addr[i]);
|
|
printk("\n");
|
|
#endif
|
|
leave("read_mac_address");
|
|
}
|
|
|
|
|
|
/*
|
|
transceiver_voodoo() enables the external UTP plug thingy.
|
|
it's called voodoo as I stole this code and cannot cross-reference
|
|
it with the specification.
|
|
*/
|
|
static void transceiver_voodoo(struct xircom_private *card)
|
|
{
|
|
unsigned long flags;
|
|
|
|
enter("transceiver_voodoo");
|
|
|
|
/* disable all powermanagement */
|
|
pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
|
|
|
|
setup_descriptors(card);
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
outl(0x0008, card->io_port + CSR15);
|
|
udelay(25);
|
|
outl(0xa8050000, card->io_port + CSR15);
|
|
udelay(25);
|
|
outl(0xa00f0000, card->io_port + CSR15);
|
|
udelay(25);
|
|
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
|
|
netif_start_queue(card->dev);
|
|
leave("transceiver_voodoo");
|
|
}
|
|
|
|
|
|
static void xircom_up(struct xircom_private *card)
|
|
{
|
|
unsigned long flags;
|
|
int i;
|
|
|
|
enter("xircom_up");
|
|
|
|
/* disable all powermanagement */
|
|
pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
|
|
|
|
setup_descriptors(card);
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
|
|
enable_link_interrupt(card);
|
|
enable_transmit_interrupt(card);
|
|
enable_receive_interrupt(card);
|
|
enable_common_interrupts(card);
|
|
enable_promisc(card);
|
|
|
|
/* The card can have received packets already, read them away now */
|
|
for (i=0;i<NUMDESCRIPTORS;i++)
|
|
investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
|
|
|
|
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
trigger_receive(card);
|
|
trigger_transmit(card);
|
|
netif_start_queue(card->dev);
|
|
leave("xircom_up");
|
|
}
|
|
|
|
/* Bufferoffset is in BYTES */
|
|
static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
|
|
{
|
|
int status;
|
|
|
|
enter("investigate_read_descriptor");
|
|
status = card->rx_buffer[4*descnr];
|
|
|
|
if ((status > 0)) { /* packet received */
|
|
|
|
/* TODO: discard error packets */
|
|
|
|
short pkt_len = ((status >> 16) & 0x7ff) - 4; /* minus 4, we don't want the CRC */
|
|
struct sk_buff *skb;
|
|
|
|
if (pkt_len > 1518) {
|
|
printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
|
|
pkt_len = 1518;
|
|
}
|
|
|
|
skb = dev_alloc_skb(pkt_len + 2);
|
|
if (skb == NULL) {
|
|
card->stats.rx_dropped++;
|
|
goto out;
|
|
}
|
|
skb->dev = dev;
|
|
skb_reserve(skb, 2);
|
|
eth_copy_and_sum(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len, 0);
|
|
skb_put(skb, pkt_len);
|
|
skb->protocol = eth_type_trans(skb, dev);
|
|
netif_rx(skb);
|
|
dev->last_rx = jiffies;
|
|
card->stats.rx_packets++;
|
|
card->stats.rx_bytes += pkt_len;
|
|
|
|
out:
|
|
/* give the buffer back to the card */
|
|
card->rx_buffer[4*descnr] = 0x80000000;
|
|
trigger_receive(card);
|
|
}
|
|
|
|
leave("investigate_read_descriptor");
|
|
|
|
}
|
|
|
|
|
|
/* Bufferoffset is in BYTES */
|
|
static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
|
|
{
|
|
int status;
|
|
|
|
enter("investigate_write_descriptor");
|
|
|
|
status = card->tx_buffer[4*descnr];
|
|
#if 0
|
|
if (status & 0x8000) { /* Major error */
|
|
printk(KERN_ERR "Major transmit error status %x \n", status);
|
|
card->tx_buffer[4*descnr] = 0;
|
|
netif_wake_queue (dev);
|
|
}
|
|
#endif
|
|
if (status > 0) { /* bit 31 is 0 when done */
|
|
if (card->tx_skb[descnr]!=NULL) {
|
|
card->stats.tx_bytes += card->tx_skb[descnr]->len;
|
|
dev_kfree_skb_irq(card->tx_skb[descnr]);
|
|
}
|
|
card->tx_skb[descnr] = NULL;
|
|
/* Bit 8 in the status field is 1 if there was a collision */
|
|
if (status&(1<<8))
|
|
card->stats.collisions++;
|
|
card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
|
|
netif_wake_queue (dev);
|
|
card->stats.tx_packets++;
|
|
}
|
|
|
|
leave("investigate_write_descriptor");
|
|
|
|
}
|
|
|
|
|
|
static int __init xircom_init(void)
|
|
{
|
|
return pci_register_driver(&xircom_ops);
|
|
}
|
|
|
|
static void __exit xircom_exit(void)
|
|
{
|
|
pci_unregister_driver(&xircom_ops);
|
|
}
|
|
|
|
module_init(xircom_init)
|
|
module_exit(xircom_exit)
|
|
|