patch-2.4.10 linux/drivers/net/pcmcia/xircom_cb.c

Next file: linux/drivers/net/pcmcia/xircom_tulip_cb.c
Previous file: linux/drivers/net/pcmcia/xirc2ps_cs.c
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.4.9/linux/drivers/net/pcmcia/xircom_cb.c linux/drivers/net/pcmcia/xircom_cb.c
@@ -0,0 +1,1410 @@
+/*
+ * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards 
+ *
+ * This software is Copyright 2001 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, Donald Becker and Ion Badulescu
+ *
+ *  	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.11 2001/06/05 09:50:57 fenrus Exp $
+ */
+
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+
+
+
+#ifdef DEBUG
+#define enter()   printk("Enter: %s, %s line %i\n",__FUNCTION__,__FILE__,__LINE__)
+#define leave()   printk("Leave: %s, %s line %i\n",__FUNCTION__,__FILE__,__LINE__)
+#else
+#define enter()   do {} while (0)
+#define leave()   do {} while (0)
+#endif
+
+
+MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
+MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
+
+
+
+/* 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
+#define RXTXBUFSIZE 8192
+#define MAX_PACKETSIZE 1536
+
+
+#define DescOwnedCard	0x80000000
+#define DescOwnedDriver	0x00000000
+
+#define PromiscBit		(1<<6)
+#define CollisionBit 		(1<<8)
+#define TxActiveBit		(1<<13)
+#define RxActiveBit		(1<<1)
+#define LastDescBit	 	(1<<25)
+#define LinkStatusBit 		(1<<27)
+
+#define PowerMgmtBits		( (1<<31)|(1<<30) )
+
+static const unsigned int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
+
+/* note: this struct is assumed to be packed as this is the "hardware" layout */
+struct descriptor {
+	u32	status;
+	u32	control;
+	u32	address1;
+	u32	address2;
+};
+
+
+struct xircom_private {
+	/* Send and receive buffers, kernel-addressable and dma addressable forms */
+
+	unsigned char *rx_buffer;
+	unsigned char *tx_buffer;
+	
+	struct descriptor *rx_desc;
+	struct descriptor *tx_desc;
+
+	dma_addr_t rx_dma_handle;
+	dma_addr_t tx_dma_handle;
+
+	struct sk_buff *tx_skb[NUMDESCRIPTORS];
+
+	unsigned long io_port;
+	
+	/* transmit_used is the rotating counter that indicates which transmit
+	   descriptor has to be used next */
+	unsigned 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 void xircom_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
+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);
+
+static void investigate_rx_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
+static unsigned int investigate_tx_descriptor(struct net_device *dev, struct xircom_private *card, unsigned int descnr, unsigned int bufferoffset);
+static void read_mac_address(struct xircom_private *card);
+static void tranceiver_voodoo(struct xircom_private *card);
+static void initialize_card(struct xircom_private *card);
+static inline void trigger_transmit(struct xircom_private *card);
+static inline void trigger_receive(struct xircom_private *card);
+static void setup_descriptors(struct xircom_private *card);
+static inline void remove_descriptors(struct xircom_private *card);
+static inline unsigned 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 inline unsigned int link_status(struct xircom_private *card);
+static int mdio_read(struct xircom_private *card, int phy_id, int location);
+static void mdio_write(struct xircom_private *card, int phy_id, int location, int value);
+
+
+
+static struct pci_device_id xircom_pci_table[] __devinitdata = {
+	{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, 
+};
+
+
+#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
+
+/* 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;
+	u8 chip_rev;
+	unsigned long flags;
+	u32 tmp32;
+	u16 tmp16;
+	int ret;
+	enter();
+	
+	/* First do the PCI initialisation */
+
+	ret = pci_enable_device(pdev);
+	if (ret)
+		return ret;
+
+	/* disable all powermanagement */
+	pci_read_config_dword(pdev, PCI_POWERMGMT,&tmp32);
+	tmp32 &= ~PowerMgmtBits; 
+	pci_write_config_dword(pdev, PCI_POWERMGMT, tmp32);
+	
+	pci_set_master(pdev); 
+
+	/* 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;
+	}
+
+	
+	dev = init_etherdev(dev, sizeof(*private));
+	if (dev == NULL) {
+		printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
+		return -ENODEV;
+	}
+	SET_MODULE_OWNER(dev);
+	private = dev->priv;
+	if (private==NULL) {
+		printk(KERN_ERR "xircom_probe: failed to allocate private device struct\n");
+		return -ENODEV;
+	}
+		
+	/* Allocate the send/receive buffers */
+	private->rx_buffer = pci_alloc_consistent(pdev,RXTXBUFSIZE,&private->rx_dma_handle);
+	if (private->rx_buffer == NULL) {
+ 		printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
+ 		kfree(private);
+		return -ENODEV;
+	}	
+	/* the descriptors are stored in the first bytes of the rx_buffer, hence the ugly cast */
+	private->rx_desc = (struct descriptor *)private->rx_buffer;
+
+	private->tx_buffer = pci_alloc_consistent(pdev,RXTXBUFSIZE,&private->tx_dma_handle);
+	if (private->tx_buffer == NULL) {
+		printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
+		kfree(private->rx_buffer);
+		kfree(private);
+		return -ENODEV;
+	}
+	/* the descriptors are stored in the first bytes of the tx_buffer, hence the ugly cast */
+	private->tx_desc = (struct descriptor *)private->tx_buffer;
+	
+	
+	printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, chip_rev, pdev->irq);
+
+	private->dev = dev;
+	private->pdev = pdev;
+	private->io_port = pci_resource_start(pdev, 0);
+	private->lock = SPIN_LOCK_UNLOCKED;
+	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;
+	pci_set_drvdata(pdev,dev);
+
+	
+	/* start the transmitter to get a heartbeat; don't do
+	   that when there already is one though; Cisco's 
+	   really don't like that. */
+	if (!link_status(private))
+		tranceiver_voodoo(private);
+	
+	spin_lock_irqsave(&private->lock,flags);
+	  activate_transmitter(private);
+	  activate_receiver(private);
+	spin_unlock_irqrestore(&private->lock,flags);
+
+	/* TODO: send 2 dummy packets here */
+	
+	trigger_receive(private);
+	
+	leave();
+	return 0;
+}
+
+
+/*
+ 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 = pdev->driver_data;
+	struct xircom_private *card;
+	enter();
+	
+	card=dev->priv;
+
+	if (card->rx_buffer!=NULL)
+		pci_free_consistent(pdev,RXTXBUFSIZE,card->rx_buffer,card->rx_dma_handle);
+	card->rx_buffer = NULL;
+	card->rx_desc = NULL;
+	if (card->tx_buffer!=NULL)
+		pci_free_consistent(pdev,RXTXBUFSIZE,card->tx_buffer,card->tx_dma_handle);
+	card->tx_buffer = NULL;			
+	card->tx_desc = NULL;
+
+	release_region(dev->base_addr, 128);
+	unregister_netdev(dev);
+	kfree(dev);
+	pci_set_drvdata(pdev,NULL);
+	leave();
+} 
+
+static void xircom_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
+{
+	struct net_device *dev = dev_instance;
+	struct xircom_private *card = dev->priv;
+	u32 status;
+	unsigned int xmit_free_count;
+	unsigned int i;
+
+	enter();
+
+
+	spin_lock(&card->lock);
+	status = inl(card->io_port+CSR5);
+	if (status==0xffffffff) {/* card has been ejected / powered down */
+		spin_unlock(&card->lock);
+		return;
+	}
+
+	/* Todo: check if there were any events at all; to speed up
+	   returning if we're on a shared interrupt */	
+
+	if (link_status_changed(card)) {
+		int newlink;
+		printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
+		newlink = link_status(card);
+		if (newlink) {
+			printk(KERN_INFO  "xircom_cb: Link is %i mbit \n",newlink);
+			netif_carrier_on(dev);
+		} else {
+			printk(KERN_INFO  "xircom_cb: Link is absent \n");
+			netif_carrier_off(dev);
+		}
+	}
+
+	/* Clear all remaining interrupt events */	
+	status |= 0xffffffff; /* FIXME: make this clear only the
+				        real existing bits */
+	outl(status,card->io_port+CSR5);
+	
+	xmit_free_count = 0;
+
+	for (i=0;i<NUMDESCRIPTORS;i++) 
+		xmit_free_count += investigate_tx_descriptor(dev,card,i,bufferoffsets[i]);
+	for (i=0;i<NUMDESCRIPTORS;i++) 
+		investigate_rx_descriptor(dev,card,i,bufferoffsets[i]);
+
+	
+	if (xmit_free_count)
+		netif_start_queue(dev);
+		
+	spin_unlock(&card->lock);
+	leave();
+}
+
+static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+	struct xircom_private *card;
+	unsigned long flags;
+	unsigned int nextdescriptor;
+	unsigned int desc;
+	enter();
+	
+	card = (struct xircom_private*)dev->priv;
+
+	spin_lock_irqsave(&card->lock,flags);
+	
+	nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
+	desc = card->transmit_used;
+	
+	/* only send the packet if the descriptor is free */
+	if (card->tx_desc[desc].status==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]],0,MAX_PACKETSIZE);
+			memcpy(&(card->tx_buffer[bufferoffsets[desc]]),skb->data,skb->len);
+	
+	
+			/* FIXME: The specification tells us that the length we send HAS to be a multiple of
+			   4 bytes. */
+			   
+			card->tx_desc[desc].control = skb->len;
+			if (desc == NUMDESCRIPTORS-1)
+				card->tx_desc[desc].control |= LastDescBit;  /* bit 25: last descriptor of the ring */
+
+			card->tx_desc[desc].control |= 0xF0000000;
+						 /* 0xF0... means want interrupts*/ 
+			card->tx_skb[desc] = skb;
+			
+			wmb();
+			/* This gives the descriptor to the card */
+			card->tx_desc[desc].status = DescOwnedCard;
+			trigger_transmit(card);
+			if (((int)card->tx_desc[nextdescriptor].status)<0) {	/* next descriptor is occupied... */
+				netif_stop_queue(dev);
+			}
+			card->transmit_used = nextdescriptor;
+			spin_unlock_irqrestore(&card->lock,flags);
+			leave();
+			return 0;
+	}
+	
+
+
+	/* Uh oh... no free descriptor... drop the packet */
+	/* This should not happen in theory...*/
+	netif_stop_queue(dev);
+	spin_unlock_irqrestore(&card->lock,flags);
+	trigger_transmit(card);
+	leave();
+	
+	return -EIO;
+}
+
+
+
+
+static int xircom_open(struct net_device *dev)
+{
+	struct xircom_private *xp = (struct xircom_private *) dev->priv;
+	int retval;
+	enter();
+	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, SA_SHIRQ, dev->name, dev);
+	if (retval) {
+		printk(KERN_ERR "xircom_cb: Unable to aquire IRQ %i, aborting.\n",dev->irq);
+		leave();
+		return retval;
+	}
+	
+	xircom_up(xp);
+	leave();
+	return 0;
+}
+
+static int xircom_close(struct net_device *dev)
+{
+	struct xircom_private *card;
+	unsigned long flags;
+	
+	enter();
+	card = dev->priv;
+	netif_stop_queue(dev); /* we don't want to send 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);
+	
+	free_irq(dev->irq,dev);
+	
+	leave();
+		
+	return 0;
+	
+}
+
+
+
+static struct net_device_stats *xircom_get_stats(struct net_device *dev)
+{
+        struct xircom_private *card = (struct xircom_private *)dev->priv;
+        return &card->stats;
+} 
+                                                 
+
+
+
+static void initialize_card(struct xircom_private *card)
+{
+	unsigned int val;
+	unsigned long flags;
+	enter();
+
+
+	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();
+}
+
+/*
+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 inline void trigger_transmit(struct xircom_private *card)
+{
+	enter();
+	outl(0, card->io_port + CSR1);
+	leave();
+}
+
+/*
+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 inline void trigger_receive(struct xircom_private *card)
+{
+	enter();
+	outl(0, card->io_port + CSR2);
+	leave();
+}
+
+/*
+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;
+	u32 address;
+	unsigned int i;
+	enter();
+
+
+	if (card->rx_buffer == NULL)
+		BUG();
+	if (card->tx_buffer == NULL)
+		BUG();
+
+	/* Receive descriptors */
+	memset(card->rx_desc, 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_desc[i].status = DescOwnedCard;
+		/* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
+		card->rx_desc[i].control = MAX_PACKETSIZE;
+		if (i==NUMDESCRIPTORS-1)
+			card->rx_desc[i].control |= LastDescBit; /* bit 25 is "last descriptor" */
+
+		/* Rx Descr2: address of the buffer
+		   we store the buffer at the 2nd half of the page */
+	
+		address = card->rx_dma_handle;
+		
+		card->rx_desc[i].address1 = cpu_to_le32(address + bufferoffsets[i]);
+		/* Rx Desc3: address of 2nd buffer -> 0 */
+		card->rx_desc[i].address2 = 0;
+	}
+	
+	wmb();
+	/* Write the receive descriptor ring address to the card */
+	address = card->rx_dma_handle;
+	val = cpu_to_le32(address); 
+	outl(val, card->io_port + CSR3);	/* Receive descr list address */
+
+
+	/* transmit descriptors */
+	memset(card->tx_desc, 0, 128);	/* clear the descriptors */
+	
+	for (i=0;i<NUMDESCRIPTORS;i++ ) {
+		/* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
+		card->tx_desc[i].status = DescOwnedDriver;
+		/* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
+		card->tx_desc[i].control = MAX_PACKETSIZE;
+		if (i==NUMDESCRIPTORS-1)
+			card->tx_desc[i].control |= LastDescBit; /* bit 25 is "last descriptor" */
+		
+		/* Tx Descr2: address of the buffer
+		   we store the buffer at the 2nd half of the page */
+		address = card->tx_dma_handle;
+		card->tx_desc[i].address1 = cpu_to_le32(address + bufferoffsets[i]);
+		/* Tx Desc3: address of 2nd buffer -> 0 */
+		card->tx_desc[i].address2 = 0;
+	}
+
+	wmb();
+	/* wite the transmit descriptor ring to the card */
+	address = card->tx_dma_handle;
+	val =cpu_to_le32(address);
+	outl(val, card->io_port + CSR4);	/* xmit descr list address */
+
+	leave();
+}
+
+/*
+remove_descriptors informs the card the descriptors are no longer
+valid by setting the address in the card to 0x00.
+*/
+static inline void remove_descriptors(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+
+	val = 0;
+	outl(val, card->io_port + CSR3);	/* Receive descriptor address */
+	outl(val, card->io_port + CSR4);	/* Send descriptor address */
+
+	leave();
+}
+
+/*
+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 inline unsigned int link_status_changed(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+
+	val = inl(card->io_port + CSR5);	/* Status register */
+
+	if ((val & LinkStatusBit) == 0) {	/* no change */
+		leave();
+		return 0;
+	}
+
+	/* clear the event by writing a 1 to the bit in the
+	   status register. */
+	val = LinkStatusBit;
+	outl(val, card->io_port + CSR5);
+
+	leave();
+	return 1;
+}
+
+
+/*
+transmit_active returns 1 if the transmitter on the card is
+in a non-stopped state.
+*/
+static inline int transmit_active(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+
+	val = inl(card->io_port + CSR5);	/* Status register */
+
+	if ((val & (7 << 20)) == 0) {	/* transmitter disabled */
+		leave();
+		return 0;
+	}
+
+	leave();
+	return 1;
+}
+
+/*
+receive_active returns 1 if the receiver on the card is
+in a non-stopped state.
+*/
+static inline unsigned int receive_active(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+
+
+	val = inl(card->io_port + CSR5);	/* Status register */
+
+	if ((val & (7 << 17)) == 0) {	/* receiver disabled */
+		leave();
+		return 0;
+	}
+
+	leave();
+	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();
+
+
+	val = inl(card->io_port + CSR6);	/* Operation mode */
+	
+	/* If the "active" bit (1) is set and the receiver is already
+	   active, no need to do the expensive thing */
+	if ((val& RxActiveBit) && (receive_active(card)))
+		return;
+	
+	
+	val = val & ~RxActiveBit;		/* 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 | RxActiveBit;		/* 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();
+}
+
+/*
+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();
+
+	val = inl(card->io_port + CSR6);	/* Operation mode */
+	val = val & ~RxActiveBit;		/* 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();
+}
+
+
+/*
+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();
+
+
+	val = inl(card->io_port + CSR6);	/* Operation mode */
+
+	/* If the "active" bit (13) is set and the receiver is already
+	   active, no need to do the expensive thing */	 
+	if ((val & TxActiveBit) && (transmit_active(card)))
+		return;
+
+	val = val & ~TxActiveBit;	/* 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 | TxActiveBit;	/* 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();
+}
+
+/*
+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();
+
+	val = inl(card->io_port + CSR6);	/* Operation mode */
+	val = val & ~TxActiveBit;		/* 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();
+}
+
+
+/*
+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();
+
+	val = inl(card->io_port + CSR7);	/* Interrupt enable register */
+	val |= 1;				/* enable the transmit interrupt */
+	outl(val, card->io_port + CSR7);
+
+	leave();
+}
+
+
+/*
+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();
+
+	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_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();
+
+	val = inl(card->io_port + CSR7);	/* Interrupt enable register */
+	val = val | LinkStatusBit;			/* enable the link status chage interrupt */
+	outl(val, card->io_port + CSR7);
+
+	leave();
+}
+
+
+
+/*
+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();
+	
+	val = 0;				/* disable all interrupts */
+	outl(val, card->io_port + CSR7);
+
+	leave();
+}
+
+/*
+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();
+
+	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_promisc starts promisc mode
+
+must be called with the lock held and interrupts disabled.
+*/
+static inline void enable_promisc(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+
+	val = inl(card->io_port + CSR6);	
+	val = val | PromiscBit;	 /* Bit 6 */
+	outl(val, card->io_port + CSR6);
+
+	printk(KERN_INFO "xircom_cb: enabling promiscuous mode \n");
+	leave();
+}
+
+
+
+
+/* 
+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 inline unsigned int link_status(struct xircom_private *card)
+{
+	unsigned int val;
+	enter();
+	
+	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();
+	return 0;
+}
+
+
+
+/* 
+
+set_half_duplex() sets the card to half duplex mode. In order to do this,
+set_half_duplex() has to deactivate the transmitter and receiver first. It
+will re-enable the transmitter and receiver if those were active from the
+beginning.
+
+Update: the above is not enough. It doesn't touch the MII, in fact it ensures
+the main chipset and the MII are never in sync if a full-duplex connection
+is negotiated. The proper fix is to tell the MII to force a half-duplex
+connection. -Ion
+
+Must be called in locked state
+*/
+static void set_half_duplex(struct xircom_private *card)
+{
+	unsigned int val;
+	int rx,tx,tmp;
+	enter();
+	
+	rx=receive_active(card);
+	tx=transmit_active(card);
+	
+	deactivate_transmitter(card);
+	deactivate_receiver(card);
+	
+	val = inb(card->io_port + CSR6);
+	val &= ~(1<<9);
+	outb(val,card->io_port + CSR6);
+
+	/* tell the MII not to advertise 10/100FDX */
+	tmp = mdio_read(card, 0, 4);
+	printk("xircom_cb: capabilities changed from %#x to %#x\n",
+	       tmp, tmp & ~0x140);
+	tmp &= ~0x140;
+	mdio_write(card, 0, 4, tmp);
+	/* restart autonegotiation */
+	tmp = mdio_read(card, 0, 0);
+	mdio_write(card, 0, 0, tmp | 0x1200);
+
+	if (rx)
+		activate_receiver(card);
+	if (tx)
+		activate_transmitter(card);	
+
+	leave();
+}
+
+
+/*
+  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();
+		
+	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();
+}
+
+
+/* MII transceiver control section.
+   Read and write the MII registers using software-generated serial
+   MDIO protocol.  See the MII specifications or DP83840A data sheet
+   for details. */
+
+/* The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
+   met by back-to-back PCI I/O cycles, but we insert a delay to avoid
+   "overclocking" issues or future 66Mhz PCI. */
+#define mdio_delay() inl(mdio_addr)
+
+/* Read and write the MII registers using software-generated serial
+   MDIO protocol.  It is just different enough from the EEPROM protocol
+   to not share code.  The maxium data clock rate is 2.5 Mhz. */
+#define MDIO_SHIFT_CLK	0x10000
+#define MDIO_DATA_WRITE0 0x00000
+#define MDIO_DATA_WRITE1 0x20000
+#define MDIO_ENB	0x00000		/* Ignore the 0x02000 databook setting. */
+#define MDIO_ENB_IN	0x40000
+#define MDIO_DATA_READ	0x80000
+
+static int mdio_read(struct xircom_private *card, int phy_id, int location)
+{
+	int i;
+	int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
+	int retval = 0;
+	long mdio_addr = card->io_port + CSR9;
+
+	/* Establish sync by sending at least 32 logic ones. */
+	for (i = 32; i >= 0; i--) {
+		outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
+		mdio_delay();
+		outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+	/* Shift the read command bits out. */
+	for (i = 15; i >= 0; i--) {
+		int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
+
+		outl(MDIO_ENB | dataval, mdio_addr);
+		mdio_delay();
+		outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+	/* Read the two transition, 16 data, and wire-idle bits. */
+	for (i = 19; i > 0; i--) {
+		outl(MDIO_ENB_IN, mdio_addr);
+		mdio_delay();
+		retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
+		outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+	return (retval>>1) & 0xffff;
+}
+
+static void mdio_write(struct xircom_private *card, int phy_id, int location, int value)
+{
+	int i;
+	int cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
+	long mdio_addr = card->io_port + CSR9;
+
+	/* Establish sync by sending 32 logic ones. */
+	for (i = 32; i >= 0; i--) {
+		outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
+		mdio_delay();
+		outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+	/* Shift the command bits out. */
+	for (i = 31; i >= 0; i--) {
+		int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
+		outl(MDIO_ENB | dataval, mdio_addr);
+		mdio_delay();
+		outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+	/* Clear out extra bits. */
+	for (i = 2; i > 0; i--) {
+		outl(MDIO_ENB_IN, mdio_addr);
+		mdio_delay();
+		outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
+		mdio_delay();
+	}
+}
+
+
+/*
+ tranceiver_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 tranceiver_voodoo(struct xircom_private *card)
+{
+	unsigned long flags;
+	u32 tmp32;
+
+	enter();
+
+	/* disable all powermanagement */
+	pci_read_config_dword(card->pdev, PCI_POWERMGMT,&tmp32);
+	tmp32 &= ~PowerMgmtBits; 
+	pci_write_config_dword(card->pdev, PCI_POWERMGMT, tmp32);
+
+	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();
+}
+
+
+static void xircom_up(struct xircom_private *card)
+{
+	unsigned long flags;
+	int i;
+	u32 tmp32;
+
+	enter();
+
+	/* disable all powermanagement */
+	pci_read_config_dword(card->pdev, PCI_POWERMGMT,&tmp32);
+	tmp32 &= ~PowerMgmtBits; 
+	pci_write_config_dword(card->pdev, PCI_POWERMGMT, tmp32);
+
+	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_rx_descriptor(card->dev,card,i,bufferoffsets[i]);
+
+
+	set_half_duplex(card);
+	spin_unlock_irqrestore(&card->lock, flags);
+	trigger_receive(card);
+	trigger_transmit(card);
+	netif_start_queue(card->dev);
+	leave();
+}
+
+static void investigate_rx_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
+{
+		int status;		
+		
+		enter();
+		status = card->rx_desc[descnr].status;
+		
+		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, &card->rx_buffer[bufferoffset], 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_desc[descnr].status = DescOwnedCard;
+			trigger_receive(card);
+		}
+
+		leave();
+
+}
+
+
+/* Returns 1 if the descriptor is free or became free */
+static unsigned int investigate_tx_descriptor(struct net_device *dev, struct xircom_private *card, unsigned int descnr, unsigned int bufferoffset)
+{
+		int status,retval = 0;
+		enter();
+		
+		status = card->tx_desc[descnr].status;
+		
+		if (status == DescOwnedDriver)
+			return 1;
+#if 0		
+		if (status & 0x8000) {	/* Major error */
+			printk(KERN_ERR "Major transmit error status %x \n", status);
+			card->tx_desc[descnr].status = 0;
+			netif_wake_queue (dev);
+		}
+#endif
+		if (status > 0) {	/* bit 31 is 0 when done */
+			card->stats.tx_packets++;
+			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 & CollisionBit)
+				card->stats.collisions++;
+			card->tx_desc[descnr].status = DescOwnedDriver; /* descriptor is free again */
+			retval = 1;
+		}
+
+		leave();
+		return retval;		
+}
+
+
+static int __init xircom_init(void)
+{
+	pci_register_driver(&xircom_ops);
+	return 0;
+}
+
+static void __exit xircom_exit(void)
+{
+	pci_unregister_driver(&xircom_ops);
+} 
+
+module_init(xircom_init) 
+module_exit(xircom_exit)

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)