|
|
@@ -1,11 +1,11 @@
|
|
|
/*
|
|
|
- * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
|
|
|
+ * 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
|
|
|
+ * 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.
|
|
|
@@ -93,7 +93,7 @@ struct xircom_private {
|
|
|
|
|
|
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;
|
|
|
@@ -153,10 +153,10 @@ static struct pci_device_id xircom_pci_table[] = {
|
|
|
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,
|
|
|
+ .name = "xircom_cb",
|
|
|
+ .id_table = xircom_pci_table,
|
|
|
+ .probe = xircom_probe,
|
|
|
+ .remove = xircom_remove,
|
|
|
.suspend =NULL,
|
|
|
.resume =NULL
|
|
|
};
|
|
|
@@ -174,7 +174,7 @@ static void print_binary(unsigned int number)
|
|
|
buffer[i2++]='1';
|
|
|
else
|
|
|
buffer[i2++]='0';
|
|
|
- if ((i&3)==0)
|
|
|
+ if ((i&3)==0)
|
|
|
buffer[i2++]=' ';
|
|
|
}
|
|
|
printk("%s\n",buffer);
|
|
|
@@ -196,10 +196,10 @@ static struct ethtool_ops netdev_ethtool_ops = {
|
|
|
|
|
|
/* 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)
|
|
|
{
|
|
|
@@ -209,7 +209,7 @@ static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_
|
|
|
unsigned long flags;
|
|
|
unsigned short tmp16;
|
|
|
enter("xircom_probe");
|
|
|
-
|
|
|
+
|
|
|
/* First do the PCI initialisation */
|
|
|
|
|
|
if (pci_enable_device(pdev))
|
|
|
@@ -217,24 +217,24 @@ static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_
|
|
|
|
|
|
/* 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);
|
|
|
+ /* 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.
|
|
|
+ is available.
|
|
|
*/
|
|
|
dev = alloc_etherdev(sizeof(struct xircom_private));
|
|
|
if (!dev) {
|
|
|
@@ -242,13 +242,13 @@ static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_
|
|
|
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");
|
|
|
@@ -265,11 +265,11 @@ static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_
|
|
|
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;
|
|
|
@@ -285,19 +285,19 @@ static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_
|
|
|
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;
|
|
|
|
|
|
@@ -332,7 +332,7 @@ static void __devexit xircom_remove(struct pci_dev *pdev)
|
|
|
free_netdev(dev);
|
|
|
pci_set_drvdata(pdev, NULL);
|
|
|
leave("xircom_remove");
|
|
|
-}
|
|
|
+}
|
|
|
|
|
|
static irqreturn_t xircom_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
|
|
|
{
|
|
|
@@ -346,11 +346,11 @@ static irqreturn_t xircom_interrupt(int irq, void *dev_instance, struct pt_regs
|
|
|
spin_lock(&card->lock);
|
|
|
status = inl(card->io_port+CSR5);
|
|
|
|
|
|
-#ifdef DEBUG
|
|
|
+#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
|
|
|
+#endif
|
|
|
/* Handle shared irq and hotplug */
|
|
|
if (status == 0 || status == 0xffffffff) {
|
|
|
spin_unlock(&card->lock);
|
|
|
@@ -366,21 +366,21 @@ static irqreturn_t xircom_interrupt(int irq, void *dev_instance, struct pt_regs
|
|
|
netif_carrier_on(dev);
|
|
|
else
|
|
|
netif_carrier_off(dev);
|
|
|
-
|
|
|
+
|
|
|
}
|
|
|
|
|
|
- /* Clear all remaining interrupts */
|
|
|
+ /* 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++)
|
|
|
+
|
|
|
+ for (i=0;i<NUMDESCRIPTORS;i++)
|
|
|
investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
|
|
|
- for (i=0;i<NUMDESCRIPTORS;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;
|
|
|
@@ -393,38 +393,38 @@ static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
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++)
|
|
|
+ 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*/
|
|
|
+ /* 0xF0... means want interrupts*/
|
|
|
card->tx_skb[desc] = skb;
|
|
|
-
|
|
|
+
|
|
|
wmb();
|
|
|
/* This gives the descriptor to the card */
|
|
|
card->tx_buffer[4*desc] = 0x80000000;
|
|
|
@@ -433,18 +433,18 @@ static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
netif_stop_queue(dev);
|
|
|
}
|
|
|
card->transmit_used = nextdescriptor;
|
|
|
- leave("xircom-start_xmit - sent");
|
|
|
+ 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;
|
|
|
}
|
|
|
|
|
|
@@ -462,7 +462,7 @@ static int xircom_open(struct net_device *dev)
|
|
|
leave("xircom_open - No IRQ");
|
|
|
return retval;
|
|
|
}
|
|
|
-
|
|
|
+
|
|
|
xircom_up(xp);
|
|
|
xp->open = 1;
|
|
|
leave("xircom_open");
|
|
|
@@ -473,31 +473,31 @@ 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
|
|
|
+#if 0
|
|
|
/* We can enable this again once we send dummy packets on ifconfig ethX up */
|
|
|
deactivate_receiver(card);
|
|
|
deactivate_transmitter(card);
|
|
|
-#endif
|
|
|
+#endif
|
|
|
remove_descriptors(card);
|
|
|
-
|
|
|
+
|
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
|
-
|
|
|
+
|
|
|
card->open = 0;
|
|
|
free_irq(dev->irq,dev);
|
|
|
-
|
|
|
+
|
|
|
leave("xircom_close");
|
|
|
-
|
|
|
+
|
|
|
return 0;
|
|
|
-
|
|
|
+
|
|
|
}
|
|
|
|
|
|
|
|
|
@@ -506,8 +506,8 @@ 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)
|
|
|
@@ -540,7 +540,7 @@ static void initialize_card(struct xircom_private *card)
|
|
|
outl(val, card->io_port + CSR0);
|
|
|
|
|
|
|
|
|
- val = 0; /* Value 0x00 is a safe and conservative value
|
|
|
+ val = 0; /* Value 0x00 is a safe and conservative value
|
|
|
for the PCI configuration settings */
|
|
|
outl(val, card->io_port + CSR0);
|
|
|
|
|
|
@@ -617,23 +617,23 @@ static void setup_descriptors(struct xircom_private *card)
|
|
|
|
|
|
/* 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);
|
|
|
+ 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;
|
|
|
@@ -641,7 +641,7 @@ static void setup_descriptors(struct xircom_private *card)
|
|
|
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;
|
|
|
@@ -748,7 +748,7 @@ static int receive_active(struct xircom_private *card)
|
|
|
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
|
|
|
+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.
|
|
|
|
|
|
@@ -762,13 +762,13 @@ static void activate_receiver(struct xircom_private *card)
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
@@ -805,7 +805,7 @@ static void activate_receiver(struct xircom_private *card)
|
|
|
|
|
|
/*
|
|
|
deactivate_receiver disables the receiver on the card.
|
|
|
-To achieve this this code disables the receiver first;
|
|
|
+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.
|
|
|
@@ -840,7 +840,7 @@ static void deactivate_receiver(struct xircom_private *card)
|
|
|
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
|
|
|
+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.
|
|
|
|
|
|
@@ -856,7 +856,7 @@ static void activate_transmitter(struct xircom_private *card)
|
|
|
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 */
|
|
|
+ active, no need to do the expensive thing */
|
|
|
if ((val&(1<<13)) && (transmit_active(card)))
|
|
|
return;
|
|
|
|
|
|
@@ -896,7 +896,7 @@ static void activate_transmitter(struct xircom_private *card)
|
|
|
|
|
|
/*
|
|
|
deactivate_transmitter disables the transmitter on the card.
|
|
|
-To achieve this this code disables the transmitter first;
|
|
|
+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.
|
|
|
@@ -990,7 +990,7 @@ 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);
|
|
|
|
|
|
@@ -1031,8 +1031,8 @@ static int enable_promisc(struct xircom_private *card)
|
|
|
unsigned int val;
|
|
|
enter("enable_promisc");
|
|
|
|
|
|
- val = inl(card->io_port + CSR6);
|
|
|
- val = val | (1 << 6);
|
|
|
+ val = inl(card->io_port + CSR6);
|
|
|
+ val = val | (1 << 6);
|
|
|
outl(val, card->io_port + CSR6);
|
|
|
|
|
|
leave("enable_promisc");
|
|
|
@@ -1042,7 +1042,7 @@ static int enable_promisc(struct xircom_private *card)
|
|
|
|
|
|
|
|
|
|
|
|
-/*
|
|
|
+/*
|
|
|
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
|
|
|
@@ -1051,15 +1051,15 @@ 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 */
|
|
|
+
|
|
|
+ /* If we get here -> no link at all */
|
|
|
|
|
|
leave("link_status");
|
|
|
return 0;
|
|
|
@@ -1071,7 +1071,7 @@ static int link_status(struct xircom_private *card)
|
|
|
|
|
|
/*
|
|
|
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)
|
|
|
@@ -1081,7 +1081,7 @@ static void read_mac_address(struct xircom_private *card)
|
|
|
int i;
|
|
|
|
|
|
enter("read_mac_address");
|
|
|
-
|
|
|
+
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
|
|
outl(1 << 12, card->io_port + CSR9); /* enable boot rom access */
|
|
|
@@ -1095,7 +1095,7 @@ static void read_mac_address(struct xircom_private *card)
|
|
|
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++) {
|
|
|
@@ -1136,12 +1136,12 @@ static void transceiver_voodoo(struct xircom_private *card)
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
|
|
|
|
outl(0x0008, card->io_port + CSR15);
|
|
|
- udelay(25);
|
|
|
+ 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);
|
|
|
@@ -1163,15 +1163,15 @@ static void xircom_up(struct xircom_private *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++)
|
|
|
+ for (i=0;i<NUMDESCRIPTORS;i++)
|
|
|
investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
|
|
|
|
|
|
|
|
|
@@ -1185,15 +1185,15 @@ static void xircom_up(struct xircom_private *card)
|
|
|
/* Bufferoffset is in BYTES */
|
|
|
static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
|
|
|
{
|
|
|
- int status;
|
|
|
-
|
|
|
+ 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;
|
|
|
|
|
|
@@ -1216,7 +1216,7 @@ static void investigate_read_descriptor(struct net_device *dev,struct xircom_pri
|
|
|
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;
|
|
|
@@ -1234,9 +1234,9 @@ static void investigate_write_descriptor(struct net_device *dev, struct xircom_p
|
|
|
int status;
|
|
|
|
|
|
enter("investigate_write_descriptor");
|
|
|
-
|
|
|
+
|
|
|
status = card->tx_buffer[4*descnr];
|
|
|
-#if 0
|
|
|
+#if 0
|
|
|
if (status & 0x8000) { /* Major error */
|
|
|
printk(KERN_ERR "Major transmit error status %x \n", status);
|
|
|
card->tx_buffer[4*descnr] = 0;
|
|
|
@@ -1258,7 +1258,7 @@ static void investigate_write_descriptor(struct net_device *dev, struct xircom_p
|
|
|
}
|
|
|
|
|
|
leave("investigate_write_descriptor");
|
|
|
-
|
|
|
+
|
|
|
}
|
|
|
|
|
|
|
|
|
@@ -1271,8 +1271,8 @@ static int __init xircom_init(void)
|
|
|
static void __exit xircom_exit(void)
|
|
|
{
|
|
|
pci_unregister_driver(&xircom_ops);
|
|
|
-}
|
|
|
+}
|
|
|
|
|
|
-module_init(xircom_init)
|
|
|
+module_init(xircom_init)
|
|
|
module_exit(xircom_exit)
|
|
|
|
Jeff Garzik