1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
48MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
49MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
50MODULE_LICENSE("GPL");
51
52
53
54
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
74#define PCI_POWERMGMT 0x40
75
76
77
78#define NUMDESCRIPTORS 4
79
80static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
81
82
83struct xircom_private {
84
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
98
99 int transmit_used;
100
101
102
103
104
105 spinlock_t lock;
106
107 struct pci_dev *pdev;
108 struct net_device *dev;
109};
110
111
112
113static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
114static void xircom_remove(struct pci_dev *pdev);
115static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
116static netdev_tx_t xircom_start_xmit(struct sk_buff *skb,
117 struct net_device *dev);
118static int xircom_open(struct net_device *dev);
119static int xircom_close(struct net_device *dev);
120static void xircom_up(struct xircom_private *card);
121#ifdef CONFIG_NET_POLL_CONTROLLER
122static void xircom_poll_controller(struct net_device *dev);
123#endif
124
125static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
126static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
127static void read_mac_address(struct xircom_private *card);
128static void transceiver_voodoo(struct xircom_private *card);
129static void initialize_card(struct xircom_private *card);
130static void trigger_transmit(struct xircom_private *card);
131static void trigger_receive(struct xircom_private *card);
132static void setup_descriptors(struct xircom_private *card);
133static void remove_descriptors(struct xircom_private *card);
134static int link_status_changed(struct xircom_private *card);
135static void activate_receiver(struct xircom_private *card);
136static void deactivate_receiver(struct xircom_private *card);
137static void activate_transmitter(struct xircom_private *card);
138static void deactivate_transmitter(struct xircom_private *card);
139static void enable_transmit_interrupt(struct xircom_private *card);
140static void enable_receive_interrupt(struct xircom_private *card);
141static void enable_link_interrupt(struct xircom_private *card);
142static void disable_all_interrupts(struct xircom_private *card);
143static int link_status(struct xircom_private *card);
144
145
146
147static struct pci_device_id xircom_pci_table[] = {
148 {0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
149 {0,},
150};
151MODULE_DEVICE_TABLE(pci, xircom_pci_table);
152
153static struct pci_driver xircom_ops = {
154 .name = "xircom_cb",
155 .id_table = xircom_pci_table,
156 .probe = xircom_probe,
157 .remove = xircom_remove,
158 .suspend =NULL,
159 .resume =NULL
160};
161
162
163#ifdef DEBUG
164static void print_binary(unsigned int number)
165{
166 int i,i2;
167 char buffer[64];
168 memset(buffer,0,64);
169 i2=0;
170 for (i=31;i>=0;i--) {
171 if (number & (1<<i))
172 buffer[i2++]='1';
173 else
174 buffer[i2++]='0';
175 if ((i&3)==0)
176 buffer[i2++]=' ';
177 }
178 printk("%s\n",buffer);
179}
180#endif
181
182static void netdev_get_drvinfo(struct net_device *dev,
183 struct ethtool_drvinfo *info)
184{
185 struct xircom_private *private = netdev_priv(dev);
186
187 strcpy(info->driver, "xircom_cb");
188 strcpy(info->bus_info, pci_name(private->pdev));
189}
190
191static const struct ethtool_ops netdev_ethtool_ops = {
192 .get_drvinfo = netdev_get_drvinfo,
193};
194
195static const struct net_device_ops netdev_ops = {
196 .ndo_open = xircom_open,
197 .ndo_stop = xircom_close,
198 .ndo_start_xmit = xircom_start_xmit,
199 .ndo_change_mtu = eth_change_mtu,
200 .ndo_set_mac_address = eth_mac_addr,
201 .ndo_validate_addr = eth_validate_addr,
202#ifdef CONFIG_NET_POLL_CONTROLLER
203 .ndo_poll_controller = xircom_poll_controller,
204#endif
205};
206
207
208
209
210
211
212
213
214static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
215{
216 struct net_device *dev = NULL;
217 struct xircom_private *private;
218 unsigned long flags;
219 unsigned short tmp16;
220 enter("xircom_probe");
221
222
223
224 if (pci_enable_device(pdev))
225 return -ENODEV;
226
227
228 pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
229
230 pci_set_master(pdev);
231
232
233 pci_read_config_word (pdev,PCI_STATUS, &tmp16);
234 pci_write_config_word (pdev, PCI_STATUS,tmp16);
235
236 if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
237 printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
238 return -ENODEV;
239 }
240
241
242
243
244
245
246 dev = alloc_etherdev(sizeof(struct xircom_private));
247 if (!dev) {
248 printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
249 goto device_fail;
250 }
251 private = netdev_priv(dev);
252
253
254 private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
255 if (private->rx_buffer == NULL) {
256 printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
257 goto rx_buf_fail;
258 }
259 private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
260 if (private->tx_buffer == NULL) {
261 printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
262 goto tx_buf_fail;
263 }
264
265 SET_NETDEV_DEV(dev, &pdev->dev);
266
267
268 private->dev = dev;
269 private->pdev = pdev;
270 private->io_port = pci_resource_start(pdev, 0);
271 spin_lock_init(&private->lock);
272 dev->irq = pdev->irq;
273 dev->base_addr = private->io_port;
274
275 initialize_card(private);
276 read_mac_address(private);
277 setup_descriptors(private);
278
279 dev->netdev_ops = &netdev_ops;
280 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
281 pci_set_drvdata(pdev, dev);
282
283 if (register_netdev(dev)) {
284 printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
285 goto reg_fail;
286 }
287
288 printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, pdev->revision, pdev->irq);
289
290
291 transceiver_voodoo(private);
292
293 spin_lock_irqsave(&private->lock,flags);
294 activate_transmitter(private);
295 activate_receiver(private);
296 spin_unlock_irqrestore(&private->lock,flags);
297
298 trigger_receive(private);
299
300 leave("xircom_probe");
301 return 0;
302
303reg_fail:
304 kfree(private->tx_buffer);
305tx_buf_fail:
306 kfree(private->rx_buffer);
307rx_buf_fail:
308 free_netdev(dev);
309device_fail:
310 return -ENODEV;
311}
312
313
314
315
316
317
318
319
320static void __devexit xircom_remove(struct pci_dev *pdev)
321{
322 struct net_device *dev = pci_get_drvdata(pdev);
323 struct xircom_private *card = netdev_priv(dev);
324
325 enter("xircom_remove");
326 pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
327 pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
328
329 release_region(dev->base_addr, 128);
330 unregister_netdev(dev);
331 free_netdev(dev);
332 pci_set_drvdata(pdev, NULL);
333 leave("xircom_remove");
334}
335
336static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
337{
338 struct net_device *dev = (struct net_device *) dev_instance;
339 struct xircom_private *card = netdev_priv(dev);
340 unsigned int status;
341 int i;
342
343 enter("xircom_interrupt\n");
344
345 spin_lock(&card->lock);
346 status = inl(card->io_port+CSR5);
347
348#ifdef DEBUG
349 print_binary(status);
350 printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
351 printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
352#endif
353
354 if (status == 0 || status == 0xffffffff) {
355 spin_unlock(&card->lock);
356 return IRQ_NONE;
357 }
358
359 if (link_status_changed(card)) {
360 int newlink;
361 printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
362 newlink = link_status(card);
363 printk(KERN_INFO "xircom_cb: Link is %i mbit \n",newlink);
364 if (newlink)
365 netif_carrier_on(dev);
366 else
367 netif_carrier_off(dev);
368
369 }
370
371
372 status |= 0xffffffff;
373
374 outl(status,card->io_port+CSR5);
375
376
377 for (i=0;i<NUMDESCRIPTORS;i++)
378 investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
379 for (i=0;i<NUMDESCRIPTORS;i++)
380 investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
381
382
383 spin_unlock(&card->lock);
384 leave("xircom_interrupt");
385 return IRQ_HANDLED;
386}
387
388static netdev_tx_t xircom_start_xmit(struct sk_buff *skb,
389 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
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
409 if (card->tx_buffer[4*desc]==0) {
410
411
412
413 memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
414 skb_copy_from_linear_data(skb,
415 &(card->tx_buffer[bufferoffsets[desc] / 4]),
416 skb->len);
417
418
419
420 card->tx_buffer[4*desc+1] = cpu_to_le32(skb->len);
421 if (desc == NUMDESCRIPTORS - 1)
422 card->tx_buffer[4*desc+1] |= cpu_to_le32(1<<25);
423
424 card->tx_buffer[4*desc+1] |= cpu_to_le32(0xF0000000);
425
426 card->tx_skb[desc] = skb;
427
428 wmb();
429
430 card->tx_buffer[4*desc] = cpu_to_le32(0x80000000);
431 trigger_transmit(card);
432 if (card->tx_buffer[nextdescriptor*4] & cpu_to_le32(0x8000000)) {
433
434 netif_stop_queue(dev);
435 }
436 card->transmit_used = nextdescriptor;
437 leave("xircom-start_xmit - sent");
438 spin_unlock_irqrestore(&card->lock,flags);
439 return NETDEV_TX_OK;
440 }
441
442
443
444
445 netif_stop_queue(dev);
446 spin_unlock_irqrestore(&card->lock,flags);
447 trigger_transmit(card);
448
449 return NETDEV_TX_BUSY;
450}
451
452
453
454
455static int xircom_open(struct net_device *dev)
456{
457 struct xircom_private *xp = netdev_priv(dev);
458 int retval;
459 enter("xircom_open");
460 printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
461 retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
462 if (retval) {
463 leave("xircom_open - No IRQ");
464 return retval;
465 }
466
467 xircom_up(xp);
468 xp->open = 1;
469 leave("xircom_open");
470 return 0;
471}
472
473static int xircom_close(struct net_device *dev)
474{
475 struct xircom_private *card;
476 unsigned long flags;
477
478 enter("xircom_close");
479 card = netdev_priv(dev);
480 netif_stop_queue(dev);
481
482
483 spin_lock_irqsave(&card->lock,flags);
484
485 disable_all_interrupts(card);
486#if 0
487
488 deactivate_receiver(card);
489 deactivate_transmitter(card);
490#endif
491 remove_descriptors(card);
492
493 spin_unlock_irqrestore(&card->lock,flags);
494
495 card->open = 0;
496 free_irq(dev->irq,dev);
497
498 leave("xircom_close");
499
500 return 0;
501
502}
503
504
505#ifdef CONFIG_NET_POLL_CONTROLLER
506static void xircom_poll_controller(struct net_device *dev)
507{
508 disable_irq(dev->irq);
509 xircom_interrupt(dev->irq, dev);
510 enable_irq(dev->irq);
511}
512#endif
513
514
515static void initialize_card(struct xircom_private *card)
516{
517 unsigned int val;
518 unsigned long flags;
519 enter("initialize_card");
520
521
522 spin_lock_irqsave(&card->lock, flags);
523
524
525 val = inl(card->io_port + CSR0);
526 val |= 0x01;
527 outl(val, card->io_port + CSR0);
528
529 udelay(100);
530
531 val = inl(card->io_port + CSR0);
532 val &= ~0x01;
533 outl(val, card->io_port + CSR0);
534
535
536 val = 0;
537
538 outl(val, card->io_port + CSR0);
539
540
541 disable_all_interrupts(card);
542 deactivate_receiver(card);
543 deactivate_transmitter(card);
544
545 spin_unlock_irqrestore(&card->lock, flags);
546
547 leave("initialize_card");
548}
549
550
551
552
553
554
555
556static void trigger_transmit(struct xircom_private *card)
557{
558 unsigned int val;
559 enter("trigger_transmit");
560
561 val = 0;
562 outl(val, card->io_port + CSR1);
563
564 leave("trigger_transmit");
565}
566
567
568
569
570
571
572
573
574static void trigger_receive(struct xircom_private *card)
575{
576 unsigned int val;
577 enter("trigger_receive");
578
579 val = 0;
580 outl(val, card->io_port + CSR2);
581
582 leave("trigger_receive");
583}
584
585
586
587
588
589static void setup_descriptors(struct xircom_private *card)
590{
591 u32 address;
592 int i;
593 enter("setup_descriptors");
594
595
596 BUG_ON(card->rx_buffer == NULL);
597 BUG_ON(card->tx_buffer == NULL);
598
599
600 memset(card->rx_buffer, 0, 128);
601 for (i=0;i<NUMDESCRIPTORS;i++ ) {
602
603
604 card->rx_buffer[i*4 + 0] = cpu_to_le32(0x80000000);
605
606 card->rx_buffer[i*4 + 1] = cpu_to_le32(1536);
607 if (i == NUMDESCRIPTORS - 1)
608 card->rx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
609
610
611
612
613 address = card->rx_dma_handle;
614 card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
615
616 card->rx_buffer[i*4 + 3] = 0;
617 }
618
619 wmb();
620
621 address = card->rx_dma_handle;
622 outl(address, card->io_port + CSR3);
623
624
625
626 memset(card->tx_buffer, 0, 128);
627
628 for (i=0;i<NUMDESCRIPTORS;i++ ) {
629
630 card->tx_buffer[i*4 + 0] = 0x00000000;
631
632 card->tx_buffer[i*4 + 1] = cpu_to_le32(1536);
633 if (i == NUMDESCRIPTORS - 1)
634 card->tx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
635
636
637
638 address = card->tx_dma_handle;
639 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
640
641 card->tx_buffer[i*4 + 3] = 0;
642 }
643
644 wmb();
645
646 address = card->tx_dma_handle;
647 outl(address, card->io_port + CSR4);
648
649 leave("setup_descriptors");
650}
651
652
653
654
655
656static void remove_descriptors(struct xircom_private *card)
657{
658 unsigned int val;
659 enter("remove_descriptors");
660
661 val = 0;
662 outl(val, card->io_port + CSR3);
663 outl(val, card->io_port + CSR4);
664
665 leave("remove_descriptors");
666}
667
668
669
670
671
672
673
674static int link_status_changed(struct xircom_private *card)
675{
676 unsigned int val;
677 enter("link_status_changed");
678
679 val = inl(card->io_port + CSR5);
680
681 if ((val & (1 << 27)) == 0) {
682 leave("link_status_changed - nochange");
683 return 0;
684 }
685
686
687
688 val = (1 << 27);
689 outl(val, card->io_port + CSR5);
690
691 leave("link_status_changed - changed");
692 return 1;
693}
694
695
696
697
698
699
700static int transmit_active(struct xircom_private *card)
701{
702 unsigned int val;
703 enter("transmit_active");
704
705 val = inl(card->io_port + CSR5);
706
707 if ((val & (7 << 20)) == 0) {
708 leave("transmit_active - inactive");
709 return 0;
710 }
711
712 leave("transmit_active - active");
713 return 1;
714}
715
716
717
718
719
720static int receive_active(struct xircom_private *card)
721{
722 unsigned int val;
723 enter("receive_active");
724
725
726 val = inl(card->io_port + CSR5);
727
728 if ((val & (7 << 17)) == 0) {
729 leave("receive_active - inactive");
730 return 0;
731 }
732
733 leave("receive_active - active");
734 return 1;
735}
736
737
738
739
740
741
742
743
744
745
746
747static void activate_receiver(struct xircom_private *card)
748{
749 unsigned int val;
750 int counter;
751 enter("activate_receiver");
752
753
754 val = inl(card->io_port + CSR6);
755
756
757
758 if ((val&2) && (receive_active(card)))
759 return;
760
761
762 val = val & ~2;
763 outl(val, card->io_port + CSR6);
764
765 counter = 10;
766 while (counter > 0) {
767 if (!receive_active(card))
768 break;
769
770 udelay(50);
771 counter--;
772 if (counter <= 0)
773 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
774 }
775
776
777 val = inl(card->io_port + CSR6);
778 val = val | 2;
779 outl(val, card->io_port + CSR6);
780
781
782 counter = 10;
783 while (counter > 0) {
784 if (receive_active(card))
785 break;
786
787 udelay(50);
788 counter--;
789 if (counter <= 0)
790 printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
791 }
792
793 leave("activate_receiver");
794}
795
796
797
798
799
800
801
802
803static void deactivate_receiver(struct xircom_private *card)
804{
805 unsigned int val;
806 int counter;
807 enter("deactivate_receiver");
808
809 val = inl(card->io_port + CSR6);
810 val = val & ~2;
811 outl(val, card->io_port + CSR6);
812
813 counter = 10;
814 while (counter > 0) {
815 if (!receive_active(card))
816 break;
817
818 udelay(50);
819 counter--;
820 if (counter <= 0)
821 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
822 }
823
824
825 leave("deactivate_receiver");
826}
827
828
829
830
831
832
833
834
835
836
837
838
839static void activate_transmitter(struct xircom_private *card)
840{
841 unsigned int val;
842 int counter;
843 enter("activate_transmitter");
844
845
846 val = inl(card->io_port + CSR6);
847
848
849
850 if ((val&(1<<13)) && (transmit_active(card)))
851 return;
852
853 val = val & ~(1 << 13);
854 outl(val, card->io_port + CSR6);
855
856 counter = 10;
857 while (counter > 0) {
858 if (!transmit_active(card))
859 break;
860
861 udelay(50);
862 counter--;
863 if (counter <= 0)
864 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
865 }
866
867
868 val = inl(card->io_port + CSR6);
869 val = val | (1 << 13);
870 outl(val, card->io_port + CSR6);
871
872
873 counter = 10;
874 while (counter > 0) {
875 if (transmit_active(card))
876 break;
877
878 udelay(50);
879 counter--;
880 if (counter <= 0)
881 printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
882 }
883
884 leave("activate_transmitter");
885}
886
887
888
889
890
891
892
893
894static void deactivate_transmitter(struct xircom_private *card)
895{
896 unsigned int val;
897 int counter;
898 enter("deactivate_transmitter");
899
900 val = inl(card->io_port + CSR6);
901 val = val & ~2;
902 outl(val, card->io_port + CSR6);
903
904 counter = 20;
905 while (counter > 0) {
906 if (!transmit_active(card))
907 break;
908
909 udelay(50);
910 counter--;
911 if (counter <= 0)
912 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
913 }
914
915
916 leave("deactivate_transmitter");
917}
918
919
920
921
922
923
924
925static void enable_transmit_interrupt(struct xircom_private *card)
926{
927 unsigned int val;
928 enter("enable_transmit_interrupt");
929
930 val = inl(card->io_port + CSR7);
931 val |= 1;
932 outl(val, card->io_port + CSR7);
933
934 leave("enable_transmit_interrupt");
935}
936
937
938
939
940
941
942
943static void enable_receive_interrupt(struct xircom_private *card)
944{
945 unsigned int val;
946 enter("enable_receive_interrupt");
947
948 val = inl(card->io_port + CSR7);
949 val = val | (1 << 6);
950 outl(val, card->io_port + CSR7);
951
952 leave("enable_receive_interrupt");
953}
954
955
956
957
958
959
960static void enable_link_interrupt(struct xircom_private *card)
961{
962 unsigned int val;
963 enter("enable_link_interrupt");
964
965 val = inl(card->io_port + CSR7);
966 val = val | (1 << 27);
967 outl(val, card->io_port + CSR7);
968
969 leave("enable_link_interrupt");
970}
971
972
973
974
975
976
977
978
979static void disable_all_interrupts(struct xircom_private *card)
980{
981 unsigned int val;
982 enter("enable_all_interrupts");
983
984 val = 0;
985 outl(val, card->io_port + CSR7);
986
987 leave("disable_all_interrupts");
988}
989
990
991
992
993
994
995static void enable_common_interrupts(struct xircom_private *card)
996{
997 unsigned int val;
998 enter("enable_link_interrupt");
999
1000 val = inl(card->io_port + CSR7);
1001 val |= (1<<16);
1002 val |= (1<<15);
1003 val |= (1<<13);
1004 val |= (1<<8);
1005 val |= (1<<7);
1006 val |= (1<<5);
1007 val |= (1<<2);
1008 val |= (1<<1);
1009 outl(val, card->io_port + CSR7);
1010
1011 leave("enable_link_interrupt");
1012}
1013
1014
1015
1016
1017
1018
1019static int enable_promisc(struct xircom_private *card)
1020{
1021 unsigned int val;
1022 enter("enable_promisc");
1023
1024 val = inl(card->io_port + CSR6);
1025 val = val | (1 << 6);
1026 outl(val, card->io_port + CSR6);
1027
1028 leave("enable_promisc");
1029 return 1;
1030}
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040static int link_status(struct xircom_private *card)
1041{
1042 unsigned int val;
1043 enter("link_status");
1044
1045 val = inb(card->io_port + CSR12);
1046
1047 if (!(val&(1<<2)))
1048 return 10;
1049 if (!(val&(1<<1)))
1050 return 100;
1051
1052
1053
1054 leave("link_status");
1055 return 0;
1056}
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067static void read_mac_address(struct xircom_private *card)
1068{
1069 unsigned char j, tuple, link, data_id, data_count;
1070 unsigned long flags;
1071 int i;
1072
1073 enter("read_mac_address");
1074
1075 spin_lock_irqsave(&card->lock, flags);
1076
1077 outl(1 << 12, card->io_port + CSR9);
1078 for (i = 0x100; i < 0x1f7; i += link + 2) {
1079 outl(i, card->io_port + CSR10);
1080 tuple = inl(card->io_port + CSR9) & 0xff;
1081 outl(i + 1, card->io_port + CSR10);
1082 link = inl(card->io_port + CSR9) & 0xff;
1083 outl(i + 2, card->io_port + CSR10);
1084 data_id = inl(card->io_port + CSR9) & 0xff;
1085 outl(i + 3, card->io_port + CSR10);
1086 data_count = inl(card->io_port + CSR9) & 0xff;
1087 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
1088
1089
1090
1091 for (j = 0; j < 6; j++) {
1092 outl(i + j + 4, card->io_port + CSR10);
1093 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1094 }
1095 break;
1096 } else if (link == 0) {
1097 break;
1098 }
1099 }
1100 spin_unlock_irqrestore(&card->lock, flags);
1101 pr_debug(" %pM\n", card->dev->dev_addr);
1102 leave("read_mac_address");
1103}
1104
1105
1106
1107
1108
1109
1110
1111static void transceiver_voodoo(struct xircom_private *card)
1112{
1113 unsigned long flags;
1114
1115 enter("transceiver_voodoo");
1116
1117
1118 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1119
1120 setup_descriptors(card);
1121
1122 spin_lock_irqsave(&card->lock, flags);
1123
1124 outl(0x0008, card->io_port + CSR15);
1125 udelay(25);
1126 outl(0xa8050000, card->io_port + CSR15);
1127 udelay(25);
1128 outl(0xa00f0000, card->io_port + CSR15);
1129 udelay(25);
1130
1131 spin_unlock_irqrestore(&card->lock, flags);
1132
1133 netif_start_queue(card->dev);
1134 leave("transceiver_voodoo");
1135}
1136
1137
1138static void xircom_up(struct xircom_private *card)
1139{
1140 unsigned long flags;
1141 int i;
1142
1143 enter("xircom_up");
1144
1145
1146 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1147
1148 setup_descriptors(card);
1149
1150 spin_lock_irqsave(&card->lock, flags);
1151
1152
1153 enable_link_interrupt(card);
1154 enable_transmit_interrupt(card);
1155 enable_receive_interrupt(card);
1156 enable_common_interrupts(card);
1157 enable_promisc(card);
1158
1159
1160 for (i=0;i<NUMDESCRIPTORS;i++)
1161 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1162
1163
1164 spin_unlock_irqrestore(&card->lock, flags);
1165 trigger_receive(card);
1166 trigger_transmit(card);
1167 netif_start_queue(card->dev);
1168 leave("xircom_up");
1169}
1170
1171
1172static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1173{
1174 int status;
1175
1176 enter("investigate_read_descriptor");
1177 status = le32_to_cpu(card->rx_buffer[4*descnr]);
1178
1179 if ((status > 0)) {
1180
1181
1182
1183 short pkt_len = ((status >> 16) & 0x7ff) - 4;
1184 struct sk_buff *skb;
1185
1186 if (pkt_len > 1518) {
1187 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1188 pkt_len = 1518;
1189 }
1190
1191 skb = dev_alloc_skb(pkt_len + 2);
1192 if (skb == NULL) {
1193 dev->stats.rx_dropped++;
1194 goto out;
1195 }
1196 skb_reserve(skb, 2);
1197 skb_copy_to_linear_data(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len);
1198 skb_put(skb, pkt_len);
1199 skb->protocol = eth_type_trans(skb, dev);
1200 netif_rx(skb);
1201 dev->stats.rx_packets++;
1202 dev->stats.rx_bytes += pkt_len;
1203
1204 out:
1205
1206 card->rx_buffer[4*descnr] = cpu_to_le32(0x80000000);
1207 trigger_receive(card);
1208 }
1209
1210 leave("investigate_read_descriptor");
1211
1212}
1213
1214
1215
1216static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1217{
1218 int status;
1219
1220 enter("investigate_write_descriptor");
1221
1222 status = le32_to_cpu(card->tx_buffer[4*descnr]);
1223#if 0
1224 if (status & 0x8000) {
1225 printk(KERN_ERR "Major transmit error status %x \n", status);
1226 card->tx_buffer[4*descnr] = 0;
1227 netif_wake_queue (dev);
1228 }
1229#endif
1230 if (status > 0) {
1231 if (card->tx_skb[descnr]!=NULL) {
1232 dev->stats.tx_bytes += card->tx_skb[descnr]->len;
1233 dev_kfree_skb_irq(card->tx_skb[descnr]);
1234 }
1235 card->tx_skb[descnr] = NULL;
1236
1237 if (status&(1<<8))
1238 dev->stats.collisions++;
1239 card->tx_buffer[4*descnr] = 0;
1240 netif_wake_queue (dev);
1241 dev->stats.tx_packets++;
1242 }
1243
1244 leave("investigate_write_descriptor");
1245
1246}
1247
1248
1249static int __init xircom_init(void)
1250{
1251 return pci_register_driver(&xircom_ops);
1252}
1253
1254static void __exit xircom_exit(void)
1255{
1256 pci_unregister_driver(&xircom_ops);
1257}
1258
1259module_init(xircom_init)
1260module_exit(xircom_exit)
1261
1262