xircom_cb should return NETDEV_TX_BUSY when no descriptors available
[linux-2.6.git] / drivers / net / tulip / xircom_cb.c
1 /*
2  * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
3  *
4  * This software is (C) by the respective authors, and licensed under the GPL
5  * License.
6  *
7  * Written by Arjan van de Ven for Red Hat, Inc.
8  * Based on work by Jeff Garzik, Doug Ledford and Donald Becker
9  *
10  *      This software may be used and distributed according to the terms
11  *      of the GNU General Public License, incorporated herein by reference.
12  *
13  *
14  *      $Id: xircom_cb.c,v 1.33 2001/03/19 14:02:07 arjanv Exp $
15  */
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/ioport.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/pci.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/skbuff.h>
28 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/ethtool.h>
31 #include <linux/bitops.h>
32
33 #include <asm/uaccess.h>
34 #include <asm/io.h>
35 #ifdef CONFIG_NET_POLL_CONTROLLER
36 #include <asm/irq.h>
37 #endif
38
39 #ifdef DEBUG
40 #define enter(x)   printk("Enter: %s, %s line %i\n",x,__FILE__,__LINE__)
41 #define leave(x)   printk("Leave: %s, %s line %i\n",x,__FILE__,__LINE__)
42 #else
43 #define enter(x)   do {} while (0)
44 #define leave(x)   do {} while (0)
45 #endif
46
47
48 MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
49 MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
50 MODULE_LICENSE("GPL");
51
52
53
54 /* IO registers on the card, offsets */
55 #define CSR0    0x00
56 #define CSR1    0x08
57 #define CSR2    0x10
58 #define CSR3    0x18
59 #define CSR4    0x20
60 #define CSR5    0x28
61 #define CSR6    0x30
62 #define CSR7    0x38
63 #define CSR8    0x40
64 #define CSR9    0x48
65 #define CSR10   0x50
66 #define CSR11   0x58
67 #define CSR12   0x60
68 #define CSR13   0x68
69 #define CSR14   0x70
70 #define CSR15   0x78
71 #define CSR16   0x80
72
73 /* PCI registers */
74 #define PCI_POWERMGMT   0x40
75
76 /* Offsets of the buffers within the descriptor pages, in bytes */
77
78 #define NUMDESCRIPTORS 4
79
80 static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
81
82
83 struct xircom_private {
84         /* Send and receive buffers, kernel-addressable and dma addressable forms */
85
86         __le32 *rx_buffer;
87         __le32 *tx_buffer;
88
89         dma_addr_t rx_dma_handle;
90         dma_addr_t tx_dma_handle;
91
92         struct sk_buff *tx_skb[4];
93
94         unsigned long io_port;
95         int open;
96
97         /* transmit_used is the rotating counter that indicates which transmit
98            descriptor has to be used next */
99         int transmit_used;
100
101         /* Spinlock to serialize register operations.
102            It must be helt while manipulating the following registers:
103            CSR0, CSR6, CSR7, CSR9, CSR10, CSR15
104          */
105         spinlock_t lock;
106
107
108         struct pci_dev *pdev;
109         struct net_device *dev;
110         struct net_device_stats stats;
111 };
112
113
114 /* Function prototypes */
115 static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
116 static void xircom_remove(struct pci_dev *pdev);
117 static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
118 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
119 static int xircom_open(struct net_device *dev);
120 static int xircom_close(struct net_device *dev);
121 static void xircom_up(struct xircom_private *card);
122 static struct net_device_stats *xircom_get_stats(struct net_device *dev);
123 #ifdef CONFIG_NET_POLL_CONTROLLER
124 static void xircom_poll_controller(struct net_device *dev);
125 #endif
126
127 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
128 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
129 static void read_mac_address(struct xircom_private *card);
130 static void transceiver_voodoo(struct xircom_private *card);
131 static void initialize_card(struct xircom_private *card);
132 static void trigger_transmit(struct xircom_private *card);
133 static void trigger_receive(struct xircom_private *card);
134 static void setup_descriptors(struct xircom_private *card);
135 static void remove_descriptors(struct xircom_private *card);
136 static int link_status_changed(struct xircom_private *card);
137 static void activate_receiver(struct xircom_private *card);
138 static void deactivate_receiver(struct xircom_private *card);
139 static void activate_transmitter(struct xircom_private *card);
140 static void deactivate_transmitter(struct xircom_private *card);
141 static void enable_transmit_interrupt(struct xircom_private *card);
142 static void enable_receive_interrupt(struct xircom_private *card);
143 static void enable_link_interrupt(struct xircom_private *card);
144 static void disable_all_interrupts(struct xircom_private *card);
145 static int link_status(struct xircom_private *card);
146
147
148
149 static struct pci_device_id xircom_pci_table[] = {
150         {0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
151         {0,},
152 };
153 MODULE_DEVICE_TABLE(pci, xircom_pci_table);
154
155 static struct pci_driver xircom_ops = {
156         .name           = "xircom_cb",
157         .id_table       = xircom_pci_table,
158         .probe          = xircom_probe,
159         .remove         = xircom_remove,
160         .suspend =NULL,
161         .resume =NULL
162 };
163
164
165 #ifdef DEBUG
166 static void print_binary(unsigned int number)
167 {
168         int i,i2;
169         char buffer[64];
170         memset(buffer,0,64);
171         i2=0;
172         for (i=31;i>=0;i--) {
173                 if (number & (1<<i))
174                         buffer[i2++]='1';
175                 else
176                         buffer[i2++]='0';
177                 if ((i&3)==0)
178                         buffer[i2++]=' ';
179         }
180         printk("%s\n",buffer);
181 }
182 #endif
183
184 static void netdev_get_drvinfo(struct net_device *dev,
185                                struct ethtool_drvinfo *info)
186 {
187         struct xircom_private *private = netdev_priv(dev);
188
189         strcpy(info->driver, "xircom_cb");
190         strcpy(info->bus_info, pci_name(private->pdev));
191 }
192
193 static const struct ethtool_ops netdev_ethtool_ops = {
194         .get_drvinfo            = netdev_get_drvinfo,
195 };
196
197 /* xircom_probe is the code that gets called on device insertion.
198    it sets up the hardware and registers the device to the networklayer.
199
200    TODO: Send 1 or 2 "dummy" packets here as the card seems to discard the
201          first two packets that get send, and pump hates that.
202
203  */
204 static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
205 {
206         struct net_device *dev = NULL;
207         struct xircom_private *private;
208         unsigned long flags;
209         unsigned short tmp16;
210         enter("xircom_probe");
211
212         /* First do the PCI initialisation */
213
214         if (pci_enable_device(pdev))
215                 return -ENODEV;
216
217         /* disable all powermanagement */
218         pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
219
220         pci_set_master(pdev); /* Why isn't this done by pci_enable_device ?*/
221
222         /* clear PCI status, if any */
223         pci_read_config_word (pdev,PCI_STATUS, &tmp16);
224         pci_write_config_word (pdev, PCI_STATUS,tmp16);
225
226         if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
227                 printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
228                 return -ENODEV;
229         }
230
231         /*
232            Before changing the hardware, allocate the memory.
233            This way, we can fail gracefully if not enough memory
234            is available.
235          */
236         dev = alloc_etherdev(sizeof(struct xircom_private));
237         if (!dev) {
238                 printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
239                 goto device_fail;
240         }
241         private = netdev_priv(dev);
242
243         /* Allocate the send/receive buffers */
244         private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
245         if (private->rx_buffer == NULL) {
246                 printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
247                 goto rx_buf_fail;
248         }
249         private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
250         if (private->tx_buffer == NULL) {
251                 printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
252                 goto tx_buf_fail;
253         }
254
255         SET_NETDEV_DEV(dev, &pdev->dev);
256
257
258         private->dev = dev;
259         private->pdev = pdev;
260         private->io_port = pci_resource_start(pdev, 0);
261         spin_lock_init(&private->lock);
262         dev->irq = pdev->irq;
263         dev->base_addr = private->io_port;
264
265         initialize_card(private);
266         read_mac_address(private);
267         setup_descriptors(private);
268
269         dev->open = &xircom_open;
270         dev->hard_start_xmit = &xircom_start_xmit;
271         dev->stop = &xircom_close;
272         dev->get_stats = &xircom_get_stats;
273 #ifdef CONFIG_NET_POLL_CONTROLLER
274         dev->poll_controller = &xircom_poll_controller;
275 #endif
276         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
277         pci_set_drvdata(pdev, dev);
278
279         if (register_netdev(dev)) {
280                 printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
281                 goto reg_fail;
282         }
283
284         printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, pdev->revision, pdev->irq);
285         /* start the transmitter to get a heartbeat */
286         /* TODO: send 2 dummy packets here */
287         transceiver_voodoo(private);
288
289         spin_lock_irqsave(&private->lock,flags);
290         activate_transmitter(private);
291         activate_receiver(private);
292         spin_unlock_irqrestore(&private->lock,flags);
293
294         trigger_receive(private);
295
296         leave("xircom_probe");
297         return 0;
298
299 reg_fail:
300         kfree(private->tx_buffer);
301 tx_buf_fail:
302         kfree(private->rx_buffer);
303 rx_buf_fail:
304         free_netdev(dev);
305 device_fail:
306         return -ENODEV;
307 }
308
309
310 /*
311  xircom_remove is called on module-unload or on device-eject.
312  it unregisters the irq, io-region and network device.
313  Interrupts and such are already stopped in the "ifconfig ethX down"
314  code.
315  */
316 static void __devexit xircom_remove(struct pci_dev *pdev)
317 {
318         struct net_device *dev = pci_get_drvdata(pdev);
319         struct xircom_private *card = netdev_priv(dev);
320
321         enter("xircom_remove");
322         pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
323         pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
324
325         release_region(dev->base_addr, 128);
326         unregister_netdev(dev);
327         free_netdev(dev);
328         pci_set_drvdata(pdev, NULL);
329         leave("xircom_remove");
330 }
331
332 static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
333 {
334         struct net_device *dev = (struct net_device *) dev_instance;
335         struct xircom_private *card = netdev_priv(dev);
336         unsigned int status;
337         int i;
338
339         enter("xircom_interrupt\n");
340
341         spin_lock(&card->lock);
342         status = inl(card->io_port+CSR5);
343
344 #ifdef DEBUG
345         print_binary(status);
346         printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
347         printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
348 #endif
349         /* Handle shared irq and hotplug */
350         if (status == 0 || status == 0xffffffff) {
351                 spin_unlock(&card->lock);
352                 return IRQ_NONE;
353         }
354
355         if (link_status_changed(card)) {
356                 int newlink;
357                 printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
358                 newlink = link_status(card);
359                 printk(KERN_INFO  "xircom_cb: Link is %i mbit \n",newlink);
360                 if (newlink)
361                         netif_carrier_on(dev);
362                 else
363                         netif_carrier_off(dev);
364
365         }
366
367         /* Clear all remaining interrupts */
368         status |= 0xffffffff; /* FIXME: make this clear only the
369                                         real existing bits */
370         outl(status,card->io_port+CSR5);
371
372
373         for (i=0;i<NUMDESCRIPTORS;i++)
374                 investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
375         for (i=0;i<NUMDESCRIPTORS;i++)
376                 investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
377
378
379         spin_unlock(&card->lock);
380         leave("xircom_interrupt");
381         return IRQ_HANDLED;
382 }
383
384 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
385 {
386         struct xircom_private *card;
387         unsigned long flags;
388         int nextdescriptor;
389         int desc;
390         enter("xircom_start_xmit");
391
392         card = netdev_priv(dev);
393         spin_lock_irqsave(&card->lock,flags);
394
395         /* First see if we can free some descriptors */
396         for (desc=0;desc<NUMDESCRIPTORS;desc++)
397                 investigate_write_descriptor(dev,card,desc,bufferoffsets[desc]);
398
399
400         nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
401         desc = card->transmit_used;
402
403         /* only send the packet if the descriptor is free */
404         if (card->tx_buffer[4*desc]==0) {
405                         /* Copy the packet data; zero the memory first as the card
406                            sometimes sends more than you ask it to. */
407
408                         memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
409                         skb_copy_from_linear_data(skb,
410                                   &(card->tx_buffer[bufferoffsets[desc] / 4]),
411                                                   skb->len);
412                         /* FIXME: The specification tells us that the length we send HAS to be a multiple of
413                            4 bytes. */
414
415                         card->tx_buffer[4*desc+1] = cpu_to_le32(skb->len);
416                         if (desc == NUMDESCRIPTORS - 1) /* bit 25: last descriptor of the ring */
417                                 card->tx_buffer[4*desc+1] |= cpu_to_le32(1<<25);  
418
419                         card->tx_buffer[4*desc+1] |= cpu_to_le32(0xF0000000);
420                                                  /* 0xF0... means want interrupts*/
421                         card->tx_skb[desc] = skb;
422
423                         wmb();
424                         /* This gives the descriptor to the card */
425                         card->tx_buffer[4*desc] = cpu_to_le32(0x80000000);
426                         trigger_transmit(card);
427                         if (card->tx_buffer[nextdescriptor*4] & cpu_to_le32(0x8000000)) {
428                                 /* next descriptor is occupied... */
429                                 netif_stop_queue(dev);
430                         }
431                         card->transmit_used = nextdescriptor;
432                         leave("xircom-start_xmit - sent");
433                         spin_unlock_irqrestore(&card->lock,flags);
434                         return 0;
435         }
436
437
438
439         /* Uh oh... no free descriptor... drop the packet */
440         netif_stop_queue(dev);
441         spin_unlock_irqrestore(&card->lock,flags);
442         trigger_transmit(card);
443
444         return NETDEV_TX_BUSY;
445 }
446
447
448
449
450 static int xircom_open(struct net_device *dev)
451 {
452         struct xircom_private *xp = netdev_priv(dev);
453         int retval;
454         enter("xircom_open");
455         printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
456         retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
457         if (retval) {
458                 leave("xircom_open - No IRQ");
459                 return retval;
460         }
461
462         xircom_up(xp);
463         xp->open = 1;
464         leave("xircom_open");
465         return 0;
466 }
467
468 static int xircom_close(struct net_device *dev)
469 {
470         struct xircom_private *card;
471         unsigned long flags;
472
473         enter("xircom_close");
474         card = netdev_priv(dev);
475         netif_stop_queue(dev); /* we don't want new packets */
476
477
478         spin_lock_irqsave(&card->lock,flags);
479
480         disable_all_interrupts(card);
481 #if 0
482         /* We can enable this again once we send dummy packets on ifconfig ethX up */
483         deactivate_receiver(card);
484         deactivate_transmitter(card);
485 #endif
486         remove_descriptors(card);
487
488         spin_unlock_irqrestore(&card->lock,flags);
489
490         card->open = 0;
491         free_irq(dev->irq,dev);
492
493         leave("xircom_close");
494
495         return 0;
496
497 }
498
499
500
501 static struct net_device_stats *xircom_get_stats(struct net_device *dev)
502 {
503         struct xircom_private *card = netdev_priv(dev);
504         return &card->stats;
505 }
506
507
508 #ifdef CONFIG_NET_POLL_CONTROLLER
509 static void xircom_poll_controller(struct net_device *dev)
510 {
511         disable_irq(dev->irq);
512         xircom_interrupt(dev->irq, dev);
513         enable_irq(dev->irq);
514 }
515 #endif
516
517
518 static void initialize_card(struct xircom_private *card)
519 {
520         unsigned int val;
521         unsigned long flags;
522         enter("initialize_card");
523
524
525         spin_lock_irqsave(&card->lock, flags);
526
527         /* First: reset the card */
528         val = inl(card->io_port + CSR0);
529         val |= 0x01;            /* Software reset */
530         outl(val, card->io_port + CSR0);
531
532         udelay(100);            /* give the card some time to reset */
533
534         val = inl(card->io_port + CSR0);
535         val &= ~0x01;           /* disable Software reset */
536         outl(val, card->io_port + CSR0);
537
538
539         val = 0;                /* Value 0x00 is a safe and conservative value
540                                    for the PCI configuration settings */
541         outl(val, card->io_port + CSR0);
542
543
544         disable_all_interrupts(card);
545         deactivate_receiver(card);
546         deactivate_transmitter(card);
547
548         spin_unlock_irqrestore(&card->lock, flags);
549
550         leave("initialize_card");
551 }
552
553 /*
554 trigger_transmit causes the card to check for frames to be transmitted.
555 This is accomplished by writing to the CSR1 port. The documentation
556 claims that the act of writing is sufficient and that the value is
557 ignored; I chose zero.
558 */
559 static void trigger_transmit(struct xircom_private *card)
560 {
561         unsigned int val;
562         enter("trigger_transmit");
563
564         val = 0;
565         outl(val, card->io_port + CSR1);
566
567         leave("trigger_transmit");
568 }
569
570 /*
571 trigger_receive causes the card to check for empty frames in the
572 descriptor list in which packets can be received.
573 This is accomplished by writing to the CSR2 port. The documentation
574 claims that the act of writing is sufficient and that the value is
575 ignored; I chose zero.
576 */
577 static void trigger_receive(struct xircom_private *card)
578 {
579         unsigned int val;
580         enter("trigger_receive");
581
582         val = 0;
583         outl(val, card->io_port + CSR2);
584
585         leave("trigger_receive");
586 }
587
588 /*
589 setup_descriptors initializes the send and receive buffers to be valid
590 descriptors and programs the addresses into the card.
591 */
592 static void setup_descriptors(struct xircom_private *card)
593 {
594         u32 address;
595         int i;
596         enter("setup_descriptors");
597
598
599         BUG_ON(card->rx_buffer == NULL);
600         BUG_ON(card->tx_buffer == NULL);
601
602         /* Receive descriptors */
603         memset(card->rx_buffer, 0, 128);        /* clear the descriptors */
604         for (i=0;i<NUMDESCRIPTORS;i++ ) {
605
606                 /* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
607                 card->rx_buffer[i*4 + 0] = cpu_to_le32(0x80000000);
608                 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
609                 card->rx_buffer[i*4 + 1] = cpu_to_le32(1536);
610                 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
611                         card->rx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
612
613                 /* Rx Descr2: address of the buffer
614                    we store the buffer at the 2nd half of the page */
615
616                 address = card->rx_dma_handle;
617                 card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
618                 /* Rx Desc3: address of 2nd buffer -> 0 */
619                 card->rx_buffer[i*4 + 3] = 0;
620         }
621
622         wmb();
623         /* Write the receive descriptor ring address to the card */
624         address = card->rx_dma_handle;
625         outl(address, card->io_port + CSR3);    /* Receive descr list address */
626
627
628         /* transmit descriptors */
629         memset(card->tx_buffer, 0, 128);        /* clear the descriptors */
630
631         for (i=0;i<NUMDESCRIPTORS;i++ ) {
632                 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
633                 card->tx_buffer[i*4 + 0] = 0x00000000;
634                 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
635                 card->tx_buffer[i*4 + 1] = cpu_to_le32(1536);
636                 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
637                         card->tx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
638
639                 /* Tx Descr2: address of the buffer
640                    we store the buffer at the 2nd half of the page */
641                 address = card->tx_dma_handle;
642                 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
643                 /* Tx Desc3: address of 2nd buffer -> 0 */
644                 card->tx_buffer[i*4 + 3] = 0;
645         }
646
647         wmb();
648         /* wite the transmit descriptor ring to the card */
649         address = card->tx_dma_handle;
650         outl(address, card->io_port + CSR4);    /* xmit descr list address */
651
652         leave("setup_descriptors");
653 }
654
655 /*
656 remove_descriptors informs the card the descriptors are no longer
657 valid by setting the address in the card to 0x00.
658 */
659 static void remove_descriptors(struct xircom_private *card)
660 {
661         unsigned int val;
662         enter("remove_descriptors");
663
664         val = 0;
665         outl(val, card->io_port + CSR3);        /* Receive descriptor address */
666         outl(val, card->io_port + CSR4);        /* Send descriptor address */
667
668         leave("remove_descriptors");
669 }
670
671 /*
672 link_status_changed returns 1 if the card has indicated that
673 the link status has changed. The new link status has to be read from CSR12.
674
675 This function also clears the status-bit.
676 */
677 static int link_status_changed(struct xircom_private *card)
678 {
679         unsigned int val;
680         enter("link_status_changed");
681
682         val = inl(card->io_port + CSR5);        /* Status register */
683
684         if ((val & (1 << 27)) == 0) {   /* no change */
685                 leave("link_status_changed - nochange");
686                 return 0;
687         }
688
689         /* clear the event by writing a 1 to the bit in the
690            status register. */
691         val = (1 << 27);
692         outl(val, card->io_port + CSR5);
693
694         leave("link_status_changed - changed");
695         return 1;
696 }
697
698
699 /*
700 transmit_active returns 1 if the transmitter on the card is
701 in a non-stopped state.
702 */
703 static int transmit_active(struct xircom_private *card)
704 {
705         unsigned int val;
706         enter("transmit_active");
707
708         val = inl(card->io_port + CSR5);        /* Status register */
709
710         if ((val & (7 << 20)) == 0) {   /* transmitter disabled */
711                 leave("transmit_active - inactive");
712                 return 0;
713         }
714
715         leave("transmit_active - active");
716         return 1;
717 }
718
719 /*
720 receive_active returns 1 if the receiver on the card is
721 in a non-stopped state.
722 */
723 static int receive_active(struct xircom_private *card)
724 {
725         unsigned int val;
726         enter("receive_active");
727
728
729         val = inl(card->io_port + CSR5);        /* Status register */
730
731         if ((val & (7 << 17)) == 0) {   /* receiver disabled */
732                 leave("receive_active - inactive");
733                 return 0;
734         }
735
736         leave("receive_active - active");
737         return 1;
738 }
739
740 /*
741 activate_receiver enables the receiver on the card.
742 Before being allowed to active the receiver, the receiver
743 must be completely de-activated. To achieve this,
744 this code actually disables the receiver first; then it waits for the
745 receiver to become inactive, then it activates the receiver and then
746 it waits for the receiver to be active.
747
748 must be called with the lock held and interrupts disabled.
749 */
750 static void activate_receiver(struct xircom_private *card)
751 {
752         unsigned int val;
753         int counter;
754         enter("activate_receiver");
755
756
757         val = inl(card->io_port + CSR6);        /* Operation mode */
758
759         /* If the "active" bit is set and the receiver is already
760            active, no need to do the expensive thing */
761         if ((val&2) && (receive_active(card)))
762                 return;
763
764
765         val = val & ~2;         /* disable the receiver */
766         outl(val, card->io_port + CSR6);
767
768         counter = 10;
769         while (counter > 0) {
770                 if (!receive_active(card))
771                         break;
772                 /* wait a while */
773                 udelay(50);
774                 counter--;
775                 if (counter <= 0)
776                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
777         }
778
779         /* enable the receiver */
780         val = inl(card->io_port + CSR6);        /* Operation mode */
781         val = val | 2;                          /* enable the receiver */
782         outl(val, card->io_port + CSR6);
783
784         /* now wait for the card to activate again */
785         counter = 10;
786         while (counter > 0) {
787                 if (receive_active(card))
788                         break;
789                 /* wait a while */
790                 udelay(50);
791                 counter--;
792                 if (counter <= 0)
793                         printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
794         }
795
796         leave("activate_receiver");
797 }
798
799 /*
800 deactivate_receiver disables the receiver on the card.
801 To achieve this this code disables the receiver first;
802 then it waits for the receiver to become inactive.
803
804 must be called with the lock held and interrupts disabled.
805 */
806 static void deactivate_receiver(struct xircom_private *card)
807 {
808         unsigned int val;
809         int counter;
810         enter("deactivate_receiver");
811
812         val = inl(card->io_port + CSR6);        /* Operation mode */
813         val = val & ~2;                         /* disable the receiver */
814         outl(val, card->io_port + CSR6);
815
816         counter = 10;
817         while (counter > 0) {
818                 if (!receive_active(card))
819                         break;
820                 /* wait a while */
821                 udelay(50);
822                 counter--;
823                 if (counter <= 0)
824                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
825         }
826
827
828         leave("deactivate_receiver");
829 }
830
831
832 /*
833 activate_transmitter enables the transmitter on the card.
834 Before being allowed to active the transmitter, the transmitter
835 must be completely de-activated. To achieve this,
836 this code actually disables the transmitter first; then it waits for the
837 transmitter to become inactive, then it activates the transmitter and then
838 it waits for the transmitter to be active again.
839
840 must be called with the lock held and interrupts disabled.
841 */
842 static void activate_transmitter(struct xircom_private *card)
843 {
844         unsigned int val;
845         int counter;
846         enter("activate_transmitter");
847
848
849         val = inl(card->io_port + CSR6);        /* Operation mode */
850
851         /* If the "active" bit is set and the receiver is already
852            active, no need to do the expensive thing */
853         if ((val&(1<<13)) && (transmit_active(card)))
854                 return;
855
856         val = val & ~(1 << 13); /* disable the transmitter */
857         outl(val, card->io_port + CSR6);
858
859         counter = 10;
860         while (counter > 0) {
861                 if (!transmit_active(card))
862                         break;
863                 /* wait a while */
864                 udelay(50);
865                 counter--;
866                 if (counter <= 0)
867                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
868         }
869
870         /* enable the transmitter */
871         val = inl(card->io_port + CSR6);        /* Operation mode */
872         val = val | (1 << 13);  /* enable the transmitter */
873         outl(val, card->io_port + CSR6);
874
875         /* now wait for the card to activate again */
876         counter = 10;
877         while (counter > 0) {
878                 if (transmit_active(card))
879                         break;
880                 /* wait a while */
881                 udelay(50);
882                 counter--;
883                 if (counter <= 0)
884                         printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
885         }
886
887         leave("activate_transmitter");
888 }
889
890 /*
891 deactivate_transmitter disables the transmitter on the card.
892 To achieve this this code disables the transmitter first;
893 then it waits for the transmitter to become inactive.
894
895 must be called with the lock held and interrupts disabled.
896 */
897 static void deactivate_transmitter(struct xircom_private *card)
898 {
899         unsigned int val;
900         int counter;
901         enter("deactivate_transmitter");
902
903         val = inl(card->io_port + CSR6);        /* Operation mode */
904         val = val & ~2;         /* disable the transmitter */
905         outl(val, card->io_port + CSR6);
906
907         counter = 20;
908         while (counter > 0) {
909                 if (!transmit_active(card))
910                         break;
911                 /* wait a while */
912                 udelay(50);
913                 counter--;
914                 if (counter <= 0)
915                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
916         }
917
918
919         leave("deactivate_transmitter");
920 }
921
922
923 /*
924 enable_transmit_interrupt enables the transmit interrupt
925
926 must be called with the lock held and interrupts disabled.
927 */
928 static void enable_transmit_interrupt(struct xircom_private *card)
929 {
930         unsigned int val;
931         enter("enable_transmit_interrupt");
932
933         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
934         val |= 1;                               /* enable the transmit interrupt */
935         outl(val, card->io_port + CSR7);
936
937         leave("enable_transmit_interrupt");
938 }
939
940
941 /*
942 enable_receive_interrupt enables the receive interrupt
943
944 must be called with the lock held and interrupts disabled.
945 */
946 static void enable_receive_interrupt(struct xircom_private *card)
947 {
948         unsigned int val;
949         enter("enable_receive_interrupt");
950
951         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
952         val = val | (1 << 6);                   /* enable the receive interrupt */
953         outl(val, card->io_port + CSR7);
954
955         leave("enable_receive_interrupt");
956 }
957
958 /*
959 enable_link_interrupt enables the link status change interrupt
960
961 must be called with the lock held and interrupts disabled.
962 */
963 static void enable_link_interrupt(struct xircom_private *card)
964 {
965         unsigned int val;
966         enter("enable_link_interrupt");
967
968         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
969         val = val | (1 << 27);                  /* enable the link status chage interrupt */
970         outl(val, card->io_port + CSR7);
971
972         leave("enable_link_interrupt");
973 }
974
975
976
977 /*
978 disable_all_interrupts disables all interrupts
979
980 must be called with the lock held and interrupts disabled.
981 */
982 static void disable_all_interrupts(struct xircom_private *card)
983 {
984         unsigned int val;
985         enter("enable_all_interrupts");
986
987         val = 0;                                /* disable all interrupts */
988         outl(val, card->io_port + CSR7);
989
990         leave("disable_all_interrupts");
991 }
992
993 /*
994 enable_common_interrupts enables several weird interrupts
995
996 must be called with the lock held and interrupts disabled.
997 */
998 static void enable_common_interrupts(struct xircom_private *card)
999 {
1000         unsigned int val;
1001         enter("enable_link_interrupt");
1002
1003         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
1004         val |= (1<<16); /* Normal Interrupt Summary */
1005         val |= (1<<15); /* Abnormal Interrupt Summary */
1006         val |= (1<<13); /* Fatal bus error */
1007         val |= (1<<8);  /* Receive Process Stopped */
1008         val |= (1<<7);  /* Receive Buffer Unavailable */
1009         val |= (1<<5);  /* Transmit Underflow */
1010         val |= (1<<2);  /* Transmit Buffer Unavailable */
1011         val |= (1<<1);  /* Transmit Process Stopped */
1012         outl(val, card->io_port + CSR7);
1013
1014         leave("enable_link_interrupt");
1015 }
1016
1017 /*
1018 enable_promisc starts promisc mode
1019
1020 must be called with the lock held and interrupts disabled.
1021 */
1022 static int enable_promisc(struct xircom_private *card)
1023 {
1024         unsigned int val;
1025         enter("enable_promisc");
1026
1027         val = inl(card->io_port + CSR6);
1028         val = val | (1 << 6);
1029         outl(val, card->io_port + CSR6);
1030
1031         leave("enable_promisc");
1032         return 1;
1033 }
1034
1035
1036
1037
1038 /*
1039 link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
1040
1041 Must be called in locked state with interrupts disabled
1042 */
1043 static int link_status(struct xircom_private *card)
1044 {
1045         unsigned int val;
1046         enter("link_status");
1047
1048         val = inb(card->io_port + CSR12);
1049
1050         if (!(val&(1<<2)))  /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
1051                 return 10;
1052         if (!(val&(1<<1)))  /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
1053                 return 100;
1054
1055         /* If we get here -> no link at all */
1056
1057         leave("link_status");
1058         return 0;
1059 }
1060
1061
1062
1063
1064
1065 /*
1066   read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
1067
1068   This function will take the spinlock itself and can, as a result, not be called with the lock helt.
1069  */
1070 static void read_mac_address(struct xircom_private *card)
1071 {
1072         unsigned char j, tuple, link, data_id, data_count;
1073         unsigned long flags;
1074         int i;
1075         DECLARE_MAC_BUF(mac);
1076
1077         enter("read_mac_address");
1078
1079         spin_lock_irqsave(&card->lock, flags);
1080
1081         outl(1 << 12, card->io_port + CSR9);    /* enable boot rom access */
1082         for (i = 0x100; i < 0x1f7; i += link + 2) {
1083                 outl(i, card->io_port + CSR10);
1084                 tuple = inl(card->io_port + CSR9) & 0xff;
1085                 outl(i + 1, card->io_port + CSR10);
1086                 link = inl(card->io_port + CSR9) & 0xff;
1087                 outl(i + 2, card->io_port + CSR10);
1088                 data_id = inl(card->io_port + CSR9) & 0xff;
1089                 outl(i + 3, card->io_port + CSR10);
1090                 data_count = inl(card->io_port + CSR9) & 0xff;
1091                 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
1092                         /*
1093                          * This is it.  We have the data we want.
1094                          */
1095                         for (j = 0; j < 6; j++) {
1096                                 outl(i + j + 4, card->io_port + CSR10);
1097                                 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1098                         }
1099                         break;
1100                 } else if (link == 0) {
1101                         break;
1102                 }
1103         }
1104         spin_unlock_irqrestore(&card->lock, flags);
1105         pr_debug(" %s\n", print_mac(mac, card->dev->dev_addr));
1106         leave("read_mac_address");
1107 }
1108
1109
1110 /*
1111  transceiver_voodoo() enables the external UTP plug thingy.
1112  it's called voodoo as I stole this code and cannot cross-reference
1113  it with the specification.
1114  */
1115 static void transceiver_voodoo(struct xircom_private *card)
1116 {
1117         unsigned long flags;
1118
1119         enter("transceiver_voodoo");
1120
1121         /* disable all powermanagement */
1122         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1123
1124         setup_descriptors(card);
1125
1126         spin_lock_irqsave(&card->lock, flags);
1127
1128         outl(0x0008, card->io_port + CSR15);
1129         udelay(25);
1130         outl(0xa8050000, card->io_port + CSR15);
1131         udelay(25);
1132         outl(0xa00f0000, card->io_port + CSR15);
1133         udelay(25);
1134
1135         spin_unlock_irqrestore(&card->lock, flags);
1136
1137         netif_start_queue(card->dev);
1138         leave("transceiver_voodoo");
1139 }
1140
1141
1142 static void xircom_up(struct xircom_private *card)
1143 {
1144         unsigned long flags;
1145         int i;
1146
1147         enter("xircom_up");
1148
1149         /* disable all powermanagement */
1150         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1151
1152         setup_descriptors(card);
1153
1154         spin_lock_irqsave(&card->lock, flags);
1155
1156
1157         enable_link_interrupt(card);
1158         enable_transmit_interrupt(card);
1159         enable_receive_interrupt(card);
1160         enable_common_interrupts(card);
1161         enable_promisc(card);
1162
1163         /* The card can have received packets already, read them away now */
1164         for (i=0;i<NUMDESCRIPTORS;i++)
1165                 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1166
1167
1168         spin_unlock_irqrestore(&card->lock, flags);
1169         trigger_receive(card);
1170         trigger_transmit(card);
1171         netif_start_queue(card->dev);
1172         leave("xircom_up");
1173 }
1174
1175 /* Bufferoffset is in BYTES */
1176 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1177 {
1178                 int status;
1179
1180                 enter("investigate_read_descriptor");
1181                 status = le32_to_cpu(card->rx_buffer[4*descnr]);
1182
1183                 if ((status > 0)) {     /* packet received */
1184
1185                         /* TODO: discard error packets */
1186
1187                         short pkt_len = ((status >> 16) & 0x7ff) - 4;   /* minus 4, we don't want the CRC */
1188                         struct sk_buff *skb;
1189
1190                         if (pkt_len > 1518) {
1191                                 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1192                                 pkt_len = 1518;
1193                         }
1194
1195                         skb = dev_alloc_skb(pkt_len + 2);
1196                         if (skb == NULL) {
1197                                 card->stats.rx_dropped++;
1198                                 goto out;
1199                         }
1200                         skb_reserve(skb, 2);
1201                         skb_copy_to_linear_data(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len);
1202                         skb_put(skb, pkt_len);
1203                         skb->protocol = eth_type_trans(skb, dev);
1204                         netif_rx(skb);
1205                         dev->last_rx = jiffies;
1206                         card->stats.rx_packets++;
1207                         card->stats.rx_bytes += pkt_len;
1208
1209                       out:
1210                         /* give the buffer back to the card */
1211                         card->rx_buffer[4*descnr] =  cpu_to_le32(0x80000000);
1212                         trigger_receive(card);
1213                 }
1214
1215                 leave("investigate_read_descriptor");
1216
1217 }
1218
1219
1220 /* Bufferoffset is in BYTES */
1221 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1222 {
1223                 int status;
1224
1225                 enter("investigate_write_descriptor");
1226
1227                 status = le32_to_cpu(card->tx_buffer[4*descnr]);
1228 #if 0
1229                 if (status & 0x8000) {  /* Major error */
1230                         printk(KERN_ERR "Major transmit error status %x \n", status);
1231                         card->tx_buffer[4*descnr] = 0;
1232                         netif_wake_queue (dev);
1233                 }
1234 #endif
1235                 if (status > 0) {       /* bit 31 is 0 when done */
1236                         if (card->tx_skb[descnr]!=NULL) {
1237                                 card->stats.tx_bytes += card->tx_skb[descnr]->len;
1238                                 dev_kfree_skb_irq(card->tx_skb[descnr]);
1239                         }
1240                         card->tx_skb[descnr] = NULL;
1241                         /* Bit 8 in the status field is 1 if there was a collision */
1242                         if (status&(1<<8))
1243                                 card->stats.collisions++;
1244                         card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
1245                         netif_wake_queue (dev);
1246                         card->stats.tx_packets++;
1247                 }
1248
1249                 leave("investigate_write_descriptor");
1250
1251 }
1252
1253
1254 static int __init xircom_init(void)
1255 {
1256         return pci_register_driver(&xircom_ops);
1257 }
1258
1259 static void __exit xircom_exit(void)
1260 {
1261         pci_unregister_driver(&xircom_ops);
1262 }
1263
1264 module_init(xircom_init)
1265 module_exit(xircom_exit)
1266