2 * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
4 * This software is (C) by the respective authors, and licensed under the GPL
7 * Written by Arjan van de Ven for Red Hat, Inc.
8 * Based on work by Jeff Garzik, Doug Ledford and Donald Becker
10 * This software may be used and distributed according to the terms
11 * of the GNU General Public License, incorporated herein by reference.
14 * $Id: xircom_cb.c,v 1.33 2001/03/19 14:02:07 arjanv Exp $
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/string.h>
22 #include <linux/errno.h>
23 #include <linux/ioport.h>
24 #include <linux/slab.h>
25 #include <linux/interrupt.h>
26 #include <linux/pci.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/delay.h>
31 #include <linux/init.h>
32 #include <linux/bitops.h>
34 #include <asm/uaccess.h>
36 #ifdef CONFIG_NET_POLL_CONTROLLER
40 MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
41 MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
42 MODULE_LICENSE("GPL");
46 /* IO registers on the card, offsets */
66 #define PCI_POWERMGMT 0x40
68 /* Offsets of the buffers within the descriptor pages, in bytes */
70 #define NUMDESCRIPTORS 4
72 static int bufferoffsets
[NUMDESCRIPTORS
] = {128,2048,4096,6144};
75 struct xircom_private
{
76 /* Send and receive buffers, kernel-addressable and dma addressable forms */
81 dma_addr_t rx_dma_handle
;
82 dma_addr_t tx_dma_handle
;
84 struct sk_buff
*tx_skb
[4];
86 unsigned long io_port
;
89 /* transmit_used is the rotating counter that indicates which transmit
90 descriptor has to be used next */
93 /* Spinlock to serialize register operations.
94 It must be helt while manipulating the following registers:
95 CSR0, CSR6, CSR7, CSR9, CSR10, CSR15
100 struct net_device
*dev
;
104 /* Function prototypes */
105 static int xircom_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
);
106 static void xircom_remove(struct pci_dev
*pdev
);
107 static irqreturn_t
xircom_interrupt(int irq
, void *dev_instance
);
108 static netdev_tx_t
xircom_start_xmit(struct sk_buff
*skb
,
109 struct net_device
*dev
);
110 static int xircom_open(struct net_device
*dev
);
111 static int xircom_close(struct net_device
*dev
);
112 static void xircom_up(struct xircom_private
*card
);
113 #ifdef CONFIG_NET_POLL_CONTROLLER
114 static void xircom_poll_controller(struct net_device
*dev
);
117 static void investigate_read_descriptor(struct net_device
*dev
,struct xircom_private
*card
, int descnr
, unsigned int bufferoffset
);
118 static void investigate_write_descriptor(struct net_device
*dev
, struct xircom_private
*card
, int descnr
, unsigned int bufferoffset
);
119 static void read_mac_address(struct xircom_private
*card
);
120 static void transceiver_voodoo(struct xircom_private
*card
);
121 static void initialize_card(struct xircom_private
*card
);
122 static void trigger_transmit(struct xircom_private
*card
);
123 static void trigger_receive(struct xircom_private
*card
);
124 static void setup_descriptors(struct xircom_private
*card
);
125 static void remove_descriptors(struct xircom_private
*card
);
126 static int link_status_changed(struct xircom_private
*card
);
127 static void activate_receiver(struct xircom_private
*card
);
128 static void deactivate_receiver(struct xircom_private
*card
);
129 static void activate_transmitter(struct xircom_private
*card
);
130 static void deactivate_transmitter(struct xircom_private
*card
);
131 static void enable_transmit_interrupt(struct xircom_private
*card
);
132 static void enable_receive_interrupt(struct xircom_private
*card
);
133 static void enable_link_interrupt(struct xircom_private
*card
);
134 static void disable_all_interrupts(struct xircom_private
*card
);
135 static int link_status(struct xircom_private
*card
);
139 static DEFINE_PCI_DEVICE_TABLE(xircom_pci_table
) = {
140 {0x115D, 0x0003, PCI_ANY_ID
, PCI_ANY_ID
,},
143 MODULE_DEVICE_TABLE(pci
, xircom_pci_table
);
145 static struct pci_driver xircom_ops
= {
147 .id_table
= xircom_pci_table
,
148 .probe
= xircom_probe
,
149 .remove
= xircom_remove
,
155 #if defined DEBUG && DEBUG > 1
156 static void print_binary(unsigned int number
)
162 for (i
=31;i
>=0;i
--) {
170 pr_debug("%s\n",buffer
);
174 static const struct net_device_ops netdev_ops
= {
175 .ndo_open
= xircom_open
,
176 .ndo_stop
= xircom_close
,
177 .ndo_start_xmit
= xircom_start_xmit
,
178 .ndo_change_mtu
= eth_change_mtu
,
179 .ndo_set_mac_address
= eth_mac_addr
,
180 .ndo_validate_addr
= eth_validate_addr
,
181 #ifdef CONFIG_NET_POLL_CONTROLLER
182 .ndo_poll_controller
= xircom_poll_controller
,
186 /* xircom_probe is the code that gets called on device insertion.
187 it sets up the hardware and registers the device to the networklayer.
189 TODO: Send 1 or 2 "dummy" packets here as the card seems to discard the
190 first two packets that get send, and pump hates that.
193 static int __devinit
xircom_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
195 struct net_device
*dev
= NULL
;
196 struct xircom_private
*private;
198 unsigned short tmp16
;
200 /* First do the PCI initialisation */
202 if (pci_enable_device(pdev
))
205 /* disable all powermanagement */
206 pci_write_config_dword(pdev
, PCI_POWERMGMT
, 0x0000);
208 pci_set_master(pdev
); /* Why isn't this done by pci_enable_device ?*/
210 /* clear PCI status, if any */
211 pci_read_config_word (pdev
,PCI_STATUS
, &tmp16
);
212 pci_write_config_word (pdev
, PCI_STATUS
,tmp16
);
214 if (!request_region(pci_resource_start(pdev
, 0), 128, "xircom_cb")) {
215 pr_err("%s: failed to allocate io-region\n", __func__
);
220 Before changing the hardware, allocate the memory.
221 This way, we can fail gracefully if not enough memory
224 dev
= alloc_etherdev(sizeof(struct xircom_private
));
226 pr_err("%s: failed to allocate etherdev\n", __func__
);
229 private = netdev_priv(dev
);
231 /* Allocate the send/receive buffers */
232 private->rx_buffer
= pci_alloc_consistent(pdev
,8192,&private->rx_dma_handle
);
233 if (private->rx_buffer
== NULL
) {
234 pr_err("%s: no memory for rx buffer\n", __func__
);
237 private->tx_buffer
= pci_alloc_consistent(pdev
,8192,&private->tx_dma_handle
);
238 if (private->tx_buffer
== NULL
) {
239 pr_err("%s: no memory for tx buffer\n", __func__
);
243 SET_NETDEV_DEV(dev
, &pdev
->dev
);
247 private->pdev
= pdev
;
248 private->io_port
= pci_resource_start(pdev
, 0);
249 spin_lock_init(&private->lock
);
250 dev
->irq
= pdev
->irq
;
251 dev
->base_addr
= private->io_port
;
253 initialize_card(private);
254 read_mac_address(private);
255 setup_descriptors(private);
257 dev
->netdev_ops
= &netdev_ops
;
258 pci_set_drvdata(pdev
, dev
);
260 if (register_netdev(dev
)) {
261 pr_err("%s: netdevice registration failed\n", __func__
);
265 dev_info(&dev
->dev
, "Xircom cardbus revision %i at irq %i\n",
266 pdev
->revision
, pdev
->irq
);
267 /* start the transmitter to get a heartbeat */
268 /* TODO: send 2 dummy packets here */
269 transceiver_voodoo(private);
271 spin_lock_irqsave(&private->lock
,flags
);
272 activate_transmitter(private);
273 activate_receiver(private);
274 spin_unlock_irqrestore(&private->lock
,flags
);
276 trigger_receive(private);
281 kfree(private->tx_buffer
);
283 kfree(private->rx_buffer
);
292 xircom_remove is called on module-unload or on device-eject.
293 it unregisters the irq, io-region and network device.
294 Interrupts and such are already stopped in the "ifconfig ethX down"
297 static void __devexit
xircom_remove(struct pci_dev
*pdev
)
299 struct net_device
*dev
= pci_get_drvdata(pdev
);
300 struct xircom_private
*card
= netdev_priv(dev
);
302 pci_free_consistent(pdev
,8192,card
->rx_buffer
,card
->rx_dma_handle
);
303 pci_free_consistent(pdev
,8192,card
->tx_buffer
,card
->tx_dma_handle
);
305 release_region(dev
->base_addr
, 128);
306 unregister_netdev(dev
);
308 pci_set_drvdata(pdev
, NULL
);
311 static irqreturn_t
xircom_interrupt(int irq
, void *dev_instance
)
313 struct net_device
*dev
= (struct net_device
*) dev_instance
;
314 struct xircom_private
*card
= netdev_priv(dev
);
318 spin_lock(&card
->lock
);
319 status
= inl(card
->io_port
+CSR5
);
321 #if defined DEBUG && DEBUG > 1
322 print_binary(status
);
323 pr_debug("tx status 0x%08x 0x%08x\n",
324 card
->tx_buffer
[0], card
->tx_buffer
[4]);
325 pr_debug("rx status 0x%08x 0x%08x\n",
326 card
->rx_buffer
[0], card
->rx_buffer
[4]);
328 /* Handle shared irq and hotplug */
329 if (status
== 0 || status
== 0xffffffff) {
330 spin_unlock(&card
->lock
);
334 if (link_status_changed(card
)) {
336 printk(KERN_DEBUG
"xircom_cb: Link status has changed\n");
337 newlink
= link_status(card
);
338 dev_info(&dev
->dev
, "Link is %i mbit\n", newlink
);
340 netif_carrier_on(dev
);
342 netif_carrier_off(dev
);
346 /* Clear all remaining interrupts */
347 status
|= 0xffffffff; /* FIXME: make this clear only the
348 real existing bits */
349 outl(status
,card
->io_port
+CSR5
);
352 for (i
=0;i
<NUMDESCRIPTORS
;i
++)
353 investigate_write_descriptor(dev
,card
,i
,bufferoffsets
[i
]);
354 for (i
=0;i
<NUMDESCRIPTORS
;i
++)
355 investigate_read_descriptor(dev
,card
,i
,bufferoffsets
[i
]);
357 spin_unlock(&card
->lock
);
361 static netdev_tx_t
xircom_start_xmit(struct sk_buff
*skb
,
362 struct net_device
*dev
)
364 struct xircom_private
*card
;
369 card
= netdev_priv(dev
);
370 spin_lock_irqsave(&card
->lock
,flags
);
372 /* First see if we can free some descriptors */
373 for (desc
=0;desc
<NUMDESCRIPTORS
;desc
++)
374 investigate_write_descriptor(dev
,card
,desc
,bufferoffsets
[desc
]);
377 nextdescriptor
= (card
->transmit_used
+1) % (NUMDESCRIPTORS
);
378 desc
= card
->transmit_used
;
380 /* only send the packet if the descriptor is free */
381 if (card
->tx_buffer
[4*desc
]==0) {
382 /* Copy the packet data; zero the memory first as the card
383 sometimes sends more than you ask it to. */
385 memset(&card
->tx_buffer
[bufferoffsets
[desc
]/4],0,1536);
386 skb_copy_from_linear_data(skb
,
387 &(card
->tx_buffer
[bufferoffsets
[desc
] / 4]),
389 /* FIXME: The specification tells us that the length we send HAS to be a multiple of
392 card
->tx_buffer
[4*desc
+1] = cpu_to_le32(skb
->len
);
393 if (desc
== NUMDESCRIPTORS
- 1) /* bit 25: last descriptor of the ring */
394 card
->tx_buffer
[4*desc
+1] |= cpu_to_le32(1<<25);
396 card
->tx_buffer
[4*desc
+1] |= cpu_to_le32(0xF0000000);
397 /* 0xF0... means want interrupts*/
398 card
->tx_skb
[desc
] = skb
;
401 /* This gives the descriptor to the card */
402 card
->tx_buffer
[4*desc
] = cpu_to_le32(0x80000000);
403 trigger_transmit(card
);
404 if (card
->tx_buffer
[nextdescriptor
*4] & cpu_to_le32(0x8000000)) {
405 /* next descriptor is occupied... */
406 netif_stop_queue(dev
);
408 card
->transmit_used
= nextdescriptor
;
409 spin_unlock_irqrestore(&card
->lock
,flags
);
413 /* Uh oh... no free descriptor... drop the packet */
414 netif_stop_queue(dev
);
415 spin_unlock_irqrestore(&card
->lock
,flags
);
416 trigger_transmit(card
);
418 return NETDEV_TX_BUSY
;
424 static int xircom_open(struct net_device
*dev
)
426 struct xircom_private
*xp
= netdev_priv(dev
);
429 pr_info("xircom cardbus adaptor found, registering as %s, using irq %i\n",
430 dev
->name
, dev
->irq
);
431 retval
= request_irq(dev
->irq
, xircom_interrupt
, IRQF_SHARED
, dev
->name
, dev
);
441 static int xircom_close(struct net_device
*dev
)
443 struct xircom_private
*card
;
446 card
= netdev_priv(dev
);
447 netif_stop_queue(dev
); /* we don't want new packets */
450 spin_lock_irqsave(&card
->lock
,flags
);
452 disable_all_interrupts(card
);
454 /* We can enable this again once we send dummy packets on ifconfig ethX up */
455 deactivate_receiver(card
);
456 deactivate_transmitter(card
);
458 remove_descriptors(card
);
460 spin_unlock_irqrestore(&card
->lock
,flags
);
463 free_irq(dev
->irq
,dev
);
470 #ifdef CONFIG_NET_POLL_CONTROLLER
471 static void xircom_poll_controller(struct net_device
*dev
)
473 disable_irq(dev
->irq
);
474 xircom_interrupt(dev
->irq
, dev
);
475 enable_irq(dev
->irq
);
480 static void initialize_card(struct xircom_private
*card
)
485 spin_lock_irqsave(&card
->lock
, flags
);
487 /* First: reset the card */
488 val
= inl(card
->io_port
+ CSR0
);
489 val
|= 0x01; /* Software reset */
490 outl(val
, card
->io_port
+ CSR0
);
492 udelay(100); /* give the card some time to reset */
494 val
= inl(card
->io_port
+ CSR0
);
495 val
&= ~0x01; /* disable Software reset */
496 outl(val
, card
->io_port
+ CSR0
);
499 val
= 0; /* Value 0x00 is a safe and conservative value
500 for the PCI configuration settings */
501 outl(val
, card
->io_port
+ CSR0
);
504 disable_all_interrupts(card
);
505 deactivate_receiver(card
);
506 deactivate_transmitter(card
);
508 spin_unlock_irqrestore(&card
->lock
, flags
);
512 trigger_transmit causes the card to check for frames to be transmitted.
513 This is accomplished by writing to the CSR1 port. The documentation
514 claims that the act of writing is sufficient and that the value is
515 ignored; I chose zero.
517 static void trigger_transmit(struct xircom_private
*card
)
522 outl(val
, card
->io_port
+ CSR1
);
526 trigger_receive causes the card to check for empty frames in the
527 descriptor list in which packets can be received.
528 This is accomplished by writing to the CSR2 port. The documentation
529 claims that the act of writing is sufficient and that the value is
530 ignored; I chose zero.
532 static void trigger_receive(struct xircom_private
*card
)
537 outl(val
, card
->io_port
+ CSR2
);
541 setup_descriptors initializes the send and receive buffers to be valid
542 descriptors and programs the addresses into the card.
544 static void setup_descriptors(struct xircom_private
*card
)
549 BUG_ON(card
->rx_buffer
== NULL
);
550 BUG_ON(card
->tx_buffer
== NULL
);
552 /* Receive descriptors */
553 memset(card
->rx_buffer
, 0, 128); /* clear the descriptors */
554 for (i
=0;i
<NUMDESCRIPTORS
;i
++ ) {
556 /* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
557 card
->rx_buffer
[i
*4 + 0] = cpu_to_le32(0x80000000);
558 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
559 card
->rx_buffer
[i
*4 + 1] = cpu_to_le32(1536);
560 if (i
== NUMDESCRIPTORS
- 1) /* bit 25 is "last descriptor" */
561 card
->rx_buffer
[i
*4 + 1] |= cpu_to_le32(1 << 25);
563 /* Rx Descr2: address of the buffer
564 we store the buffer at the 2nd half of the page */
566 address
= card
->rx_dma_handle
;
567 card
->rx_buffer
[i
*4 + 2] = cpu_to_le32(address
+ bufferoffsets
[i
]);
568 /* Rx Desc3: address of 2nd buffer -> 0 */
569 card
->rx_buffer
[i
*4 + 3] = 0;
573 /* Write the receive descriptor ring address to the card */
574 address
= card
->rx_dma_handle
;
575 outl(address
, card
->io_port
+ CSR3
); /* Receive descr list address */
578 /* transmit descriptors */
579 memset(card
->tx_buffer
, 0, 128); /* clear the descriptors */
581 for (i
=0;i
<NUMDESCRIPTORS
;i
++ ) {
582 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
583 card
->tx_buffer
[i
*4 + 0] = 0x00000000;
584 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
585 card
->tx_buffer
[i
*4 + 1] = cpu_to_le32(1536);
586 if (i
== NUMDESCRIPTORS
- 1) /* bit 25 is "last descriptor" */
587 card
->tx_buffer
[i
*4 + 1] |= cpu_to_le32(1 << 25);
589 /* Tx Descr2: address of the buffer
590 we store the buffer at the 2nd half of the page */
591 address
= card
->tx_dma_handle
;
592 card
->tx_buffer
[i
*4 + 2] = cpu_to_le32(address
+ bufferoffsets
[i
]);
593 /* Tx Desc3: address of 2nd buffer -> 0 */
594 card
->tx_buffer
[i
*4 + 3] = 0;
598 /* wite the transmit descriptor ring to the card */
599 address
= card
->tx_dma_handle
;
600 outl(address
, card
->io_port
+ CSR4
); /* xmit descr list address */
604 remove_descriptors informs the card the descriptors are no longer
605 valid by setting the address in the card to 0x00.
607 static void remove_descriptors(struct xircom_private
*card
)
612 outl(val
, card
->io_port
+ CSR3
); /* Receive descriptor address */
613 outl(val
, card
->io_port
+ CSR4
); /* Send descriptor address */
617 link_status_changed returns 1 if the card has indicated that
618 the link status has changed. The new link status has to be read from CSR12.
620 This function also clears the status-bit.
622 static int link_status_changed(struct xircom_private
*card
)
626 val
= inl(card
->io_port
+ CSR5
); /* Status register */
628 if ((val
& (1 << 27)) == 0) /* no change */
631 /* clear the event by writing a 1 to the bit in the
634 outl(val
, card
->io_port
+ CSR5
);
641 transmit_active returns 1 if the transmitter on the card is
642 in a non-stopped state.
644 static int transmit_active(struct xircom_private
*card
)
648 val
= inl(card
->io_port
+ CSR5
); /* Status register */
650 if ((val
& (7 << 20)) == 0) /* transmitter disabled */
657 receive_active returns 1 if the receiver on the card is
658 in a non-stopped state.
660 static int receive_active(struct xircom_private
*card
)
664 val
= inl(card
->io_port
+ CSR5
); /* Status register */
666 if ((val
& (7 << 17)) == 0) /* receiver disabled */
673 activate_receiver enables the receiver on the card.
674 Before being allowed to active the receiver, the receiver
675 must be completely de-activated. To achieve this,
676 this code actually disables the receiver first; then it waits for the
677 receiver to become inactive, then it activates the receiver and then
678 it waits for the receiver to be active.
680 must be called with the lock held and interrupts disabled.
682 static void activate_receiver(struct xircom_private
*card
)
687 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
689 /* If the "active" bit is set and the receiver is already
690 active, no need to do the expensive thing */
691 if ((val
&2) && (receive_active(card
)))
695 val
= val
& ~2; /* disable the receiver */
696 outl(val
, card
->io_port
+ CSR6
);
699 while (counter
> 0) {
700 if (!receive_active(card
))
706 pr_err("Receiver failed to deactivate\n");
709 /* enable the receiver */
710 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
711 val
= val
| 2; /* enable the receiver */
712 outl(val
, card
->io_port
+ CSR6
);
714 /* now wait for the card to activate again */
716 while (counter
> 0) {
717 if (receive_active(card
))
723 pr_err("Receiver failed to re-activate\n");
728 deactivate_receiver disables the receiver on the card.
729 To achieve this this code disables the receiver first;
730 then it waits for the receiver to become inactive.
732 must be called with the lock held and interrupts disabled.
734 static void deactivate_receiver(struct xircom_private
*card
)
739 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
740 val
= val
& ~2; /* disable the receiver */
741 outl(val
, card
->io_port
+ CSR6
);
744 while (counter
> 0) {
745 if (!receive_active(card
))
751 pr_err("Receiver failed to deactivate\n");
757 activate_transmitter enables the transmitter on the card.
758 Before being allowed to active the transmitter, the transmitter
759 must be completely de-activated. To achieve this,
760 this code actually disables the transmitter first; then it waits for the
761 transmitter to become inactive, then it activates the transmitter and then
762 it waits for the transmitter to be active again.
764 must be called with the lock held and interrupts disabled.
766 static void activate_transmitter(struct xircom_private
*card
)
771 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
773 /* If the "active" bit is set and the receiver is already
774 active, no need to do the expensive thing */
775 if ((val
&(1<<13)) && (transmit_active(card
)))
778 val
= val
& ~(1 << 13); /* disable the transmitter */
779 outl(val
, card
->io_port
+ CSR6
);
782 while (counter
> 0) {
783 if (!transmit_active(card
))
789 pr_err("Transmitter failed to deactivate\n");
792 /* enable the transmitter */
793 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
794 val
= val
| (1 << 13); /* enable the transmitter */
795 outl(val
, card
->io_port
+ CSR6
);
797 /* now wait for the card to activate again */
799 while (counter
> 0) {
800 if (transmit_active(card
))
806 pr_err("Transmitter failed to re-activate\n");
811 deactivate_transmitter disables the transmitter on the card.
812 To achieve this this code disables the transmitter first;
813 then it waits for the transmitter to become inactive.
815 must be called with the lock held and interrupts disabled.
817 static void deactivate_transmitter(struct xircom_private
*card
)
822 val
= inl(card
->io_port
+ CSR6
); /* Operation mode */
823 val
= val
& ~2; /* disable the transmitter */
824 outl(val
, card
->io_port
+ CSR6
);
827 while (counter
> 0) {
828 if (!transmit_active(card
))
834 pr_err("Transmitter failed to deactivate\n");
840 enable_transmit_interrupt enables the transmit interrupt
842 must be called with the lock held and interrupts disabled.
844 static void enable_transmit_interrupt(struct xircom_private
*card
)
848 val
= inl(card
->io_port
+ CSR7
); /* Interrupt enable register */
849 val
|= 1; /* enable the transmit interrupt */
850 outl(val
, card
->io_port
+ CSR7
);
855 enable_receive_interrupt enables the receive interrupt
857 must be called with the lock held and interrupts disabled.
859 static void enable_receive_interrupt(struct xircom_private
*card
)
863 val
= inl(card
->io_port
+ CSR7
); /* Interrupt enable register */
864 val
= val
| (1 << 6); /* enable the receive interrupt */
865 outl(val
, card
->io_port
+ CSR7
);
869 enable_link_interrupt enables the link status change interrupt
871 must be called with the lock held and interrupts disabled.
873 static void enable_link_interrupt(struct xircom_private
*card
)
877 val
= inl(card
->io_port
+ CSR7
); /* Interrupt enable register */
878 val
= val
| (1 << 27); /* enable the link status chage interrupt */
879 outl(val
, card
->io_port
+ CSR7
);
885 disable_all_interrupts disables all interrupts
887 must be called with the lock held and interrupts disabled.
889 static void disable_all_interrupts(struct xircom_private
*card
)
893 val
= 0; /* disable all interrupts */
894 outl(val
, card
->io_port
+ CSR7
);
898 enable_common_interrupts enables several weird interrupts
900 must be called with the lock held and interrupts disabled.
902 static void enable_common_interrupts(struct xircom_private
*card
)
906 val
= inl(card
->io_port
+ CSR7
); /* Interrupt enable register */
907 val
|= (1<<16); /* Normal Interrupt Summary */
908 val
|= (1<<15); /* Abnormal Interrupt Summary */
909 val
|= (1<<13); /* Fatal bus error */
910 val
|= (1<<8); /* Receive Process Stopped */
911 val
|= (1<<7); /* Receive Buffer Unavailable */
912 val
|= (1<<5); /* Transmit Underflow */
913 val
|= (1<<2); /* Transmit Buffer Unavailable */
914 val
|= (1<<1); /* Transmit Process Stopped */
915 outl(val
, card
->io_port
+ CSR7
);
919 enable_promisc starts promisc mode
921 must be called with the lock held and interrupts disabled.
923 static int enable_promisc(struct xircom_private
*card
)
927 val
= inl(card
->io_port
+ CSR6
);
928 val
= val
| (1 << 6);
929 outl(val
, card
->io_port
+ CSR6
);
938 link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
940 Must be called in locked state with interrupts disabled
942 static int link_status(struct xircom_private
*card
)
946 val
= inb(card
->io_port
+ CSR12
);
948 if (!(val
&(1<<2))) /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
950 if (!(val
&(1<<1))) /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
953 /* If we get here -> no link at all */
963 read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
965 This function will take the spinlock itself and can, as a result, not be called with the lock helt.
967 static void read_mac_address(struct xircom_private
*card
)
969 unsigned char j
, tuple
, link
, data_id
, data_count
;
973 spin_lock_irqsave(&card
->lock
, flags
);
975 outl(1 << 12, card
->io_port
+ CSR9
); /* enable boot rom access */
976 for (i
= 0x100; i
< 0x1f7; i
+= link
+ 2) {
977 outl(i
, card
->io_port
+ CSR10
);
978 tuple
= inl(card
->io_port
+ CSR9
) & 0xff;
979 outl(i
+ 1, card
->io_port
+ CSR10
);
980 link
= inl(card
->io_port
+ CSR9
) & 0xff;
981 outl(i
+ 2, card
->io_port
+ CSR10
);
982 data_id
= inl(card
->io_port
+ CSR9
) & 0xff;
983 outl(i
+ 3, card
->io_port
+ CSR10
);
984 data_count
= inl(card
->io_port
+ CSR9
) & 0xff;
985 if ((tuple
== 0x22) && (data_id
== 0x04) && (data_count
== 0x06)) {
987 * This is it. We have the data we want.
989 for (j
= 0; j
< 6; j
++) {
990 outl(i
+ j
+ 4, card
->io_port
+ CSR10
);
991 card
->dev
->dev_addr
[j
] = inl(card
->io_port
+ CSR9
) & 0xff;
994 } else if (link
== 0) {
998 spin_unlock_irqrestore(&card
->lock
, flags
);
999 pr_debug(" %pM\n", card
->dev
->dev_addr
);
1004 transceiver_voodoo() enables the external UTP plug thingy.
1005 it's called voodoo as I stole this code and cannot cross-reference
1006 it with the specification.
1008 static void transceiver_voodoo(struct xircom_private
*card
)
1010 unsigned long flags
;
1012 /* disable all powermanagement */
1013 pci_write_config_dword(card
->pdev
, PCI_POWERMGMT
, 0x0000);
1015 setup_descriptors(card
);
1017 spin_lock_irqsave(&card
->lock
, flags
);
1019 outl(0x0008, card
->io_port
+ CSR15
);
1021 outl(0xa8050000, card
->io_port
+ CSR15
);
1023 outl(0xa00f0000, card
->io_port
+ CSR15
);
1026 spin_unlock_irqrestore(&card
->lock
, flags
);
1028 netif_start_queue(card
->dev
);
1032 static void xircom_up(struct xircom_private
*card
)
1034 unsigned long flags
;
1037 /* disable all powermanagement */
1038 pci_write_config_dword(card
->pdev
, PCI_POWERMGMT
, 0x0000);
1040 setup_descriptors(card
);
1042 spin_lock_irqsave(&card
->lock
, flags
);
1045 enable_link_interrupt(card
);
1046 enable_transmit_interrupt(card
);
1047 enable_receive_interrupt(card
);
1048 enable_common_interrupts(card
);
1049 enable_promisc(card
);
1051 /* The card can have received packets already, read them away now */
1052 for (i
=0;i
<NUMDESCRIPTORS
;i
++)
1053 investigate_read_descriptor(card
->dev
,card
,i
,bufferoffsets
[i
]);
1056 spin_unlock_irqrestore(&card
->lock
, flags
);
1057 trigger_receive(card
);
1058 trigger_transmit(card
);
1059 netif_start_queue(card
->dev
);
1062 /* Bufferoffset is in BYTES */
1063 static void investigate_read_descriptor(struct net_device
*dev
,struct xircom_private
*card
, int descnr
, unsigned int bufferoffset
)
1067 status
= le32_to_cpu(card
->rx_buffer
[4*descnr
]);
1069 if ((status
> 0)) { /* packet received */
1071 /* TODO: discard error packets */
1073 short pkt_len
= ((status
>> 16) & 0x7ff) - 4; /* minus 4, we don't want the CRC */
1074 struct sk_buff
*skb
;
1076 if (pkt_len
> 1518) {
1077 pr_err("Packet length %i is bogus\n", pkt_len
);
1081 skb
= dev_alloc_skb(pkt_len
+ 2);
1083 dev
->stats
.rx_dropped
++;
1086 skb_reserve(skb
, 2);
1087 skb_copy_to_linear_data(skb
, (unsigned char*)&card
->rx_buffer
[bufferoffset
/ 4], pkt_len
);
1088 skb_put(skb
, pkt_len
);
1089 skb
->protocol
= eth_type_trans(skb
, dev
);
1091 dev
->stats
.rx_packets
++;
1092 dev
->stats
.rx_bytes
+= pkt_len
;
1095 /* give the buffer back to the card */
1096 card
->rx_buffer
[4*descnr
] = cpu_to_le32(0x80000000);
1097 trigger_receive(card
);
1102 /* Bufferoffset is in BYTES */
1103 static void investigate_write_descriptor(struct net_device
*dev
, struct xircom_private
*card
, int descnr
, unsigned int bufferoffset
)
1107 status
= le32_to_cpu(card
->tx_buffer
[4*descnr
]);
1109 if (status
& 0x8000) { /* Major error */
1110 pr_err("Major transmit error status %x\n", status
);
1111 card
->tx_buffer
[4*descnr
] = 0;
1112 netif_wake_queue (dev
);
1115 if (status
> 0) { /* bit 31 is 0 when done */
1116 if (card
->tx_skb
[descnr
]!=NULL
) {
1117 dev
->stats
.tx_bytes
+= card
->tx_skb
[descnr
]->len
;
1118 dev_kfree_skb_irq(card
->tx_skb
[descnr
]);
1120 card
->tx_skb
[descnr
] = NULL
;
1121 /* Bit 8 in the status field is 1 if there was a collision */
1123 dev
->stats
.collisions
++;
1124 card
->tx_buffer
[4*descnr
] = 0; /* descriptor is free again */
1125 netif_wake_queue (dev
);
1126 dev
->stats
.tx_packets
++;
1132 static int __init
xircom_init(void)
1134 return pci_register_driver(&xircom_ops
);
1137 static void __exit
xircom_exit(void)
1139 pci_unregister_driver(&xircom_ops
);
1142 module_init(xircom_init
)
1143 module_exit(xircom_exit
)