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