1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#define DRV_NAME "3c527"
21#define DRV_VERSION "0.7-SMP"
22#define DRV_RELDATE "2003/09/21"
23
24static const char *version =
25DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.nz>\n";
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85#include <linux/module.h>
86
87#include <linux/errno.h>
88#include <linux/netdevice.h>
89#include <linux/etherdevice.h>
90#include <linux/if_ether.h>
91#include <linux/init.h>
92#include <linux/kernel.h>
93#include <linux/types.h>
94#include <linux/fcntl.h>
95#include <linux/interrupt.h>
96#include <linux/mca-legacy.h>
97#include <linux/ioport.h>
98#include <linux/in.h>
99#include <linux/skbuff.h>
100#include <linux/slab.h>
101#include <linux/string.h>
102#include <linux/wait.h>
103#include <linux/ethtool.h>
104#include <linux/completion.h>
105#include <linux/bitops.h>
106
107#include <asm/semaphore.h>
108#include <asm/uaccess.h>
109#include <asm/system.h>
110#include <asm/io.h>
111#include <asm/dma.h>
112
113#include "3c527.h"
114
115MODULE_LICENSE("GPL");
116
117
118
119
120
121static const char* cardname = DRV_NAME;
122
123
124#ifndef NET_DEBUG
125#define NET_DEBUG 2
126#endif
127
128#undef DEBUG_IRQ
129
130static unsigned int mc32_debug = NET_DEBUG;
131
132
133#define MC32_IO_EXTENT 8
134
135
136#define TX_RING_LEN 32
137#define RX_RING_LEN 8
138
139
140
141#define RX_COPYBREAK 200
142
143
144
145
146static const int WORKAROUND_82586=1;
147
148
149struct mc32_ring_desc
150{
151 volatile struct skb_header *p;
152 struct sk_buff *skb;
153};
154
155
156struct mc32_local
157{
158 int slot;
159
160 u32 base;
161 struct net_device_stats net_stats;
162 volatile struct mc32_mailbox *rx_box;
163 volatile struct mc32_mailbox *tx_box;
164 volatile struct mc32_mailbox *exec_box;
165 volatile struct mc32_stats *stats;
166 u16 tx_chain;
167 u16 rx_chain;
168 u16 tx_len;
169 u16 rx_len;
170
171 u16 xceiver_desired_state;
172 u16 cmd_nonblocking;
173 u16 mc_reload_wait;
174 u32 mc_list_valid;
175
176 struct mc32_ring_desc tx_ring[TX_RING_LEN];
177 struct mc32_ring_desc rx_ring[RX_RING_LEN];
178
179 atomic_t tx_count;
180 atomic_t tx_ring_head;
181 u16 tx_ring_tail;
182
183 u16 rx_ring_tail;
184
185 struct semaphore cmd_mutex;
186 struct completion execution_cmd;
187 struct completion xceiver_cmd;
188};
189
190
191#define SA_ADDR0 0x02
192#define SA_ADDR1 0x60
193#define SA_ADDR2 0xAC
194
195struct mca_adapters_t {
196 unsigned int id;
197 char *name;
198};
199
200static const struct mca_adapters_t mc32_adapters[] = {
201 { 0x0041, "3COM EtherLink MC/32" },
202 { 0x8EF5, "IBM High Performance Lan Adapter" },
203 { 0x0000, NULL }
204};
205
206
207
208static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
209static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
210
211static inline u16 next_tx(u16 tx) { return (tx+1)&(TX_RING_LEN-1); };
212
213
214
215static int mc32_probe1(struct net_device *dev, int ioaddr);
216static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
217static int mc32_open(struct net_device *dev);
218static void mc32_timeout(struct net_device *dev);
219static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
220static irqreturn_t mc32_interrupt(int irq, void *dev_id);
221static int mc32_close(struct net_device *dev);
222static struct net_device_stats *mc32_get_stats(struct net_device *dev);
223static void mc32_set_multicast_list(struct net_device *dev);
224static void mc32_reset_multicast_list(struct net_device *dev);
225static const struct ethtool_ops netdev_ethtool_ops;
226
227static void cleanup_card(struct net_device *dev)
228{
229 struct mc32_local *lp = netdev_priv(dev);
230 unsigned slot = lp->slot;
231 mca_mark_as_unused(slot);
232 mca_set_adapter_name(slot, NULL);
233 free_irq(dev->irq, dev);
234 release_region(dev->base_addr, MC32_IO_EXTENT);
235}
236
237
238
239
240
241
242
243
244
245
246
247struct net_device *__init mc32_probe(int unit)
248{
249 struct net_device *dev = alloc_etherdev(sizeof(struct mc32_local));
250 static int current_mca_slot = -1;
251 int i;
252 int err;
253
254 if (!dev)
255 return ERR_PTR(-ENOMEM);
256
257 if (unit >= 0)
258 sprintf(dev->name, "eth%d", unit);
259
260
261
262
263
264
265
266
267 for(i = 0; (mc32_adapters[i].name != NULL); i++) {
268 current_mca_slot =
269 mca_find_unused_adapter(mc32_adapters[i].id, 0);
270
271 if(current_mca_slot != MCA_NOTFOUND) {
272 if(!mc32_probe1(dev, current_mca_slot))
273 {
274 mca_set_adapter_name(current_mca_slot,
275 mc32_adapters[i].name);
276 mca_mark_as_used(current_mca_slot);
277 err = register_netdev(dev);
278 if (err) {
279 cleanup_card(dev);
280 free_netdev(dev);
281 dev = ERR_PTR(err);
282 }
283 return dev;
284 }
285
286 }
287 }
288 free_netdev(dev);
289 return ERR_PTR(-ENODEV);
290}
291
292
293
294
295
296
297
298
299
300
301
302
303static int __init mc32_probe1(struct net_device *dev, int slot)
304{
305 static unsigned version_printed;
306 int i, err;
307 u8 POS;
308 u32 base;
309 struct mc32_local *lp = netdev_priv(dev);
310 static u16 mca_io_bases[]={
311 0x7280,0x7290,
312 0x7680,0x7690,
313 0x7A80,0x7A90,
314 0x7E80,0x7E90
315 };
316 static u32 mca_mem_bases[]={
317 0x00C0000,
318 0x00C4000,
319 0x00C8000,
320 0x00CC000,
321 0x00D0000,
322 0x00D4000,
323 0x00D8000,
324 0x00DC000
325 };
326 static char *failures[]={
327 "Processor instruction",
328 "Processor data bus",
329 "Processor data bus",
330 "Processor data bus",
331 "Adapter bus",
332 "ROM checksum",
333 "Base RAM",
334 "Extended RAM",
335 "82586 internal loopback",
336 "82586 initialisation failure",
337 "Adapter list configuration error"
338 };
339 DECLARE_MAC_BUF(mac);
340
341
342
343 if (mc32_debug && version_printed++ == 0)
344 printk(KERN_DEBUG "%s", version);
345
346 printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
347
348 POS = mca_read_stored_pos(slot, 2);
349
350 if(!(POS&1))
351 {
352 printk(" disabled.\n");
353 return -ENODEV;
354 }
355
356
357 dev->base_addr = mca_io_bases[(POS>>1)&7];
358 dev->mem_start = mca_mem_bases[(POS>>4)&7];
359
360 POS = mca_read_stored_pos(slot, 4);
361 if(!(POS&1))
362 {
363 printk("memory window disabled.\n");
364 return -ENODEV;
365 }
366
367 POS = mca_read_stored_pos(slot, 5);
368
369 i=(POS>>4)&3;
370 if(i==3)
371 {
372 printk("invalid memory window.\n");
373 return -ENODEV;
374 }
375
376 i*=16384;
377 i+=16384;
378
379 dev->mem_end=dev->mem_start + i;
380
381 dev->irq = ((POS>>2)&3)+9;
382
383 if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
384 {
385 printk("io 0x%3lX, which is busy.\n", dev->base_addr);
386 return -EBUSY;
387 }
388
389 printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
390 dev->base_addr, dev->irq, dev->mem_start, i/1024);
391
392
393
394
395
396
397
398
399
400
401 for (i = 0; i < 6; i++)
402 {
403 mca_write_pos(slot, 6, i+12);
404 mca_write_pos(slot, 7, 0);
405
406 dev->dev_addr[i] = mca_read_pos(slot,3);
407 }
408
409 printk("%s: Address %s", dev->name, print_mac(mac, dev->dev_addr));
410
411 mca_write_pos(slot, 6, 0);
412 mca_write_pos(slot, 7, 0);
413
414 POS = mca_read_stored_pos(slot, 4);
415
416 if(POS&2)
417 printk(" : BNC port selected.\n");
418 else
419 printk(" : AUI port selected.\n");
420
421 POS=inb(dev->base_addr+HOST_CTRL);
422 POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
423 POS&=~HOST_CTRL_INTE;
424 outb(POS, dev->base_addr+HOST_CTRL);
425
426 udelay(100);
427
428 POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
429 outb(POS, dev->base_addr+HOST_CTRL);
430
431 udelay(300);
432
433
434
435
436
437 err = request_irq(dev->irq, &mc32_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DRV_NAME, dev);
438 if (err) {
439 release_region(dev->base_addr, MC32_IO_EXTENT);
440 printk(KERN_ERR "%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
441 goto err_exit_ports;
442 }
443
444 memset(lp, 0, sizeof(struct mc32_local));
445 lp->slot = slot;
446
447 i=0;
448
449 base = inb(dev->base_addr);
450
451 while(base == 0xFF)
452 {
453 i++;
454 if(i == 1000)
455 {
456 printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
457 err = -ENODEV;
458 goto err_exit_irq;
459 }
460 udelay(1000);
461 if(inb(dev->base_addr+2)&(1<<5))
462 base = inb(dev->base_addr);
463 }
464
465 if(base>0)
466 {
467 if(base < 0x0C)
468 printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
469 base<0x0A?" test failure":"");
470 else
471 printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
472 err = -ENODEV;
473 goto err_exit_irq;
474 }
475
476 base=0;
477 for(i=0;i<4;i++)
478 {
479 int n=0;
480
481 while(!(inb(dev->base_addr+2)&(1<<5)))
482 {
483 n++;
484 udelay(50);
485 if(n>100)
486 {
487 printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
488 err = -ENODEV;
489 goto err_exit_irq;
490 }
491 }
492
493 base|=(inb(dev->base_addr)<<(8*i));
494 }
495
496 lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
497
498 base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
499
500 lp->base = dev->mem_start+base;
501
502 lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]);
503 lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
504
505 lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
506
507
508
509
510
511 lp->tx_chain = lp->exec_box->data[8];
512 lp->rx_chain = lp->exec_box->data[10];
513 lp->tx_len = lp->exec_box->data[9];
514 lp->rx_len = lp->exec_box->data[11];
515
516 init_MUTEX_LOCKED(&lp->cmd_mutex);
517 init_completion(&lp->execution_cmd);
518 init_completion(&lp->xceiver_cmd);
519
520 printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
521 dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
522
523 dev->open = mc32_open;
524 dev->stop = mc32_close;
525 dev->hard_start_xmit = mc32_send_packet;
526 dev->get_stats = mc32_get_stats;
527 dev->set_multicast_list = mc32_set_multicast_list;
528 dev->tx_timeout = mc32_timeout;
529 dev->watchdog_timeo = HZ*5;
530 dev->ethtool_ops = &netdev_ethtool_ops;
531
532 return 0;
533
534err_exit_irq:
535 free_irq(dev->irq, dev);
536err_exit_ports:
537 release_region(dev->base_addr, MC32_IO_EXTENT);
538 return err;
539}
540
541
542
543
544
545
546
547
548
549
550
551static inline void mc32_ready_poll(struct net_device *dev)
552{
553 int ioaddr = dev->base_addr;
554 while(!(inb(ioaddr+HOST_STATUS)&HOST_STATUS_CRR));
555}
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int len)
575{
576 struct mc32_local *lp = netdev_priv(dev);
577 int ioaddr = dev->base_addr;
578 int ret = -1;
579
580 if (down_trylock(&lp->cmd_mutex) == 0)
581 {
582 lp->cmd_nonblocking=1;
583 lp->exec_box->mbox=0;
584 lp->exec_box->mbox=cmd;
585 memcpy((void *)lp->exec_box->data, data, len);
586 barrier();
587
588
589 mc32_ready_poll(dev);
590 outb(1<<6, ioaddr+HOST_CMD);
591
592 ret = 0;
593
594
595 }
596
597 return ret;
598}
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
621{
622 struct mc32_local *lp = netdev_priv(dev);
623 int ioaddr = dev->base_addr;
624 int ret = 0;
625
626 down(&lp->cmd_mutex);
627
628
629
630
631
632 lp->cmd_nonblocking=0;
633 lp->exec_box->mbox=0;
634 lp->exec_box->mbox=cmd;
635 memcpy((void *)lp->exec_box->data, data, len);
636 barrier();
637
638 mc32_ready_poll(dev);
639 outb(1<<6, ioaddr+HOST_CMD);
640
641 wait_for_completion(&lp->execution_cmd);
642
643 if(lp->exec_box->mbox&(1<<13))
644 ret = -1;
645
646 up(&lp->cmd_mutex);
647
648
649
650
651
652 if(lp->mc_reload_wait)
653 {
654 mc32_reset_multicast_list(dev);
655 }
656
657 return ret;
658}
659
660
661
662
663
664
665
666
667
668
669
670
671
672static void mc32_start_transceiver(struct net_device *dev) {
673
674 struct mc32_local *lp = netdev_priv(dev);
675 int ioaddr = dev->base_addr;
676
677
678 if (lp->xceiver_desired_state==HALTED)
679 return;
680
681
682 mc32_ready_poll(dev);
683 lp->rx_box->mbox=0;
684 lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
685 outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
686
687 mc32_ready_poll(dev);
688 lp->tx_box->mbox=0;
689 outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD);
690
691
692}
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707static void mc32_halt_transceiver(struct net_device *dev)
708{
709 struct mc32_local *lp = netdev_priv(dev);
710 int ioaddr = dev->base_addr;
711
712 mc32_ready_poll(dev);
713 lp->rx_box->mbox=0;
714 outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
715 wait_for_completion(&lp->xceiver_cmd);
716
717 mc32_ready_poll(dev);
718 lp->tx_box->mbox=0;
719 outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
720 wait_for_completion(&lp->xceiver_cmd);
721}
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744static int mc32_load_rx_ring(struct net_device *dev)
745{
746 struct mc32_local *lp = netdev_priv(dev);
747 int i;
748 u16 rx_base;
749 volatile struct skb_header *p;
750
751 rx_base=lp->rx_chain;
752
753 for(i=0; i<RX_RING_LEN; i++) {
754 lp->rx_ring[i].skb=alloc_skb(1532, GFP_KERNEL);
755 if (lp->rx_ring[i].skb==NULL) {
756 for (;i>=0;i--)
757 kfree_skb(lp->rx_ring[i].skb);
758 return -ENOBUFS;
759 }
760 skb_reserve(lp->rx_ring[i].skb, 18);
761
762 p=isa_bus_to_virt(lp->base+rx_base);
763
764 p->control=0;
765 p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
766 p->status=0;
767 p->length=1532;
768
769 lp->rx_ring[i].p=p;
770 rx_base=p->next;
771 }
772
773 lp->rx_ring[i-1].p->control |= CONTROL_EOL;
774
775 lp->rx_ring_tail=0;
776
777 return 0;
778}
779
780
781
782
783
784
785
786
787
788
789
790static void mc32_flush_rx_ring(struct net_device *dev)
791{
792 struct mc32_local *lp = netdev_priv(dev);
793 int i;
794
795 for(i=0; i < RX_RING_LEN; i++)
796 {
797 if (lp->rx_ring[i].skb) {
798 dev_kfree_skb(lp->rx_ring[i].skb);
799 lp->rx_ring[i].skb = NULL;
800 }
801 lp->rx_ring[i].p=NULL;
802 }
803}
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822static void mc32_load_tx_ring(struct net_device *dev)
823{
824 struct mc32_local *lp = netdev_priv(dev);
825 volatile struct skb_header *p;
826 int i;
827 u16 tx_base;
828
829 tx_base=lp->tx_box->data[0];
830
831 for(i=0 ; i<TX_RING_LEN ; i++)
832 {
833 p=isa_bus_to_virt(lp->base+tx_base);
834 lp->tx_ring[i].p=p;
835 lp->tx_ring[i].skb=NULL;
836
837 tx_base=p->next;
838 }
839
840
841
842
843 atomic_set(&lp->tx_count, TX_RING_LEN-1);
844 atomic_set(&lp->tx_ring_head, 0);
845 lp->tx_ring_tail=0;
846}
847
848
849
850
851
852
853
854
855
856
857
858
859static void mc32_flush_tx_ring(struct net_device *dev)
860{
861 struct mc32_local *lp = netdev_priv(dev);
862 int i;
863
864 for (i=0; i < TX_RING_LEN; i++)
865 {
866 if (lp->tx_ring[i].skb)
867 {
868 dev_kfree_skb(lp->tx_ring[i].skb);
869 lp->tx_ring[i].skb = NULL;
870 }
871 }
872
873 atomic_set(&lp->tx_count, 0);
874 atomic_set(&lp->tx_ring_head, 0);
875 lp->tx_ring_tail=0;
876}
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896static int mc32_open(struct net_device *dev)
897{
898 int ioaddr = dev->base_addr;
899 struct mc32_local *lp = netdev_priv(dev);
900 u8 one=1;
901 u8 regs;
902 u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN};
903
904
905
906
907
908 regs=inb(ioaddr+HOST_CTRL);
909 regs|=HOST_CTRL_INTE;
910 outb(regs, ioaddr+HOST_CTRL);
911
912
913
914
915
916 up(&lp->cmd_mutex);
917
918
919
920
921
922
923 mc32_command(dev, 4, &one, 2);
924
925
926
927
928
929 mc32_halt_transceiver(dev);
930 mc32_flush_tx_ring(dev);
931
932
933
934
935
936 if(mc32_command(dev, 8, descnumbuffs, 4)) {
937 printk("%s: %s rejected our buffer configuration!\n",
938 dev->name, cardname);
939 mc32_close(dev);
940 return -ENOBUFS;
941 }
942
943
944 mc32_command(dev, 6, NULL, 0);
945
946 lp->tx_chain = lp->exec_box->data[8];
947 lp->rx_chain = lp->exec_box->data[10];
948 lp->tx_len = lp->exec_box->data[9];
949 lp->rx_len = lp->exec_box->data[11];
950
951
952 mc32_command(dev, 1, dev->dev_addr, 6);
953
954
955 mc32_set_multicast_list(dev);
956
957 if (WORKAROUND_82586) {
958 u16 zero_word=0;
959 mc32_command(dev, 0x0D, &zero_word, 2);
960 }
961
962 mc32_load_tx_ring(dev);
963
964 if(mc32_load_rx_ring(dev))
965 {
966 mc32_close(dev);
967 return -ENOBUFS;
968 }
969
970 lp->xceiver_desired_state = RUNNING;
971
972
973 mc32_start_transceiver(dev);
974
975 netif_start_queue(dev);
976
977 return 0;
978}
979
980
981
982
983
984
985
986
987
988
989
990
991static void mc32_timeout(struct net_device *dev)
992{
993 printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
994
995 netif_wake_queue(dev);
996}
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
1021{
1022 struct mc32_local *lp = netdev_priv(dev);
1023 u32 head = atomic_read(&lp->tx_ring_head);
1024
1025 volatile struct skb_header *p, *np;
1026
1027 netif_stop_queue(dev);
1028
1029 if(atomic_read(&lp->tx_count)==0) {
1030 return 1;
1031 }
1032
1033 if (skb_padto(skb, ETH_ZLEN)) {
1034 netif_wake_queue(dev);
1035 return 0;
1036 }
1037
1038 atomic_dec(&lp->tx_count);
1039
1040
1041 p=lp->tx_ring[head].p;
1042
1043 head = next_tx(head);
1044
1045
1046 np=lp->tx_ring[head].p;
1047
1048
1049 lp->tx_ring[head].skb=skb;
1050
1051 np->length = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1052 np->data = isa_virt_to_bus(skb->data);
1053 np->status = 0;
1054 np->control = CONTROL_EOP | CONTROL_EOL;
1055 wmb();
1056
1057
1058
1059
1060
1061
1062 atomic_set(&lp->tx_ring_head, head);
1063 p->control &= ~CONTROL_EOL;
1064
1065 netif_wake_queue(dev);
1066 return 0;
1067}
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089static void mc32_update_stats(struct net_device *dev)
1090{
1091 struct mc32_local *lp = netdev_priv(dev);
1092 volatile struct mc32_stats *st = lp->stats;
1093
1094 u32 rx_errors=0;
1095
1096 rx_errors+=lp->net_stats.rx_crc_errors +=st->rx_crc_errors;
1097 st->rx_crc_errors=0;
1098 rx_errors+=lp->net_stats.rx_fifo_errors +=st->rx_overrun_errors;
1099 st->rx_overrun_errors=0;
1100 rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors;
1101 st->rx_alignment_errors=0;
1102 rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors;
1103 st->rx_tooshort_errors=0;
1104 rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
1105 st->rx_outofresource_errors=0;
1106 lp->net_stats.rx_errors=rx_errors;
1107
1108
1109 lp->net_stats.collisions+=st->dataC[10];
1110 st->dataC[10]=0;
1111
1112
1113 lp->net_stats.collisions+=st->dataC[11];
1114 st->dataC[11]=0;
1115}
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140static void mc32_rx_ring(struct net_device *dev)
1141{
1142 struct mc32_local *lp = netdev_priv(dev);
1143 volatile struct skb_header *p;
1144 u16 rx_ring_tail;
1145 u16 rx_old_tail;
1146 int x=0;
1147
1148 rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
1149
1150 do
1151 {
1152 p=lp->rx_ring[rx_ring_tail].p;
1153
1154 if(!(p->status & (1<<7))) {
1155 break;
1156 }
1157 if(p->status & (1<<6))
1158 {
1159
1160 u16 length=p->length;
1161 struct sk_buff *skb;
1162 struct sk_buff *newskb;
1163
1164
1165
1166 if ((length > RX_COPYBREAK)
1167 && ((newskb=dev_alloc_skb(1532)) != NULL))
1168 {
1169 skb=lp->rx_ring[rx_ring_tail].skb;
1170 skb_put(skb, length);
1171
1172 skb_reserve(newskb,18);
1173 lp->rx_ring[rx_ring_tail].skb=newskb;
1174 p->data=isa_virt_to_bus(newskb->data);
1175 }
1176 else
1177 {
1178 skb=dev_alloc_skb(length+2);
1179
1180 if(skb==NULL) {
1181 lp->net_stats.rx_dropped++;
1182 goto dropped;
1183 }
1184
1185 skb_reserve(skb,2);
1186 memcpy(skb_put(skb, length),
1187 lp->rx_ring[rx_ring_tail].skb->data, length);
1188 }
1189
1190 skb->protocol=eth_type_trans(skb,dev);
1191 dev->last_rx = jiffies;
1192 lp->net_stats.rx_packets++;
1193 lp->net_stats.rx_bytes += length;
1194 netif_rx(skb);
1195 }
1196
1197 dropped:
1198 p->length = 1532;
1199 p->status = 0;
1200
1201 rx_ring_tail=next_rx(rx_ring_tail);
1202 }
1203 while(x++<48);
1204
1205
1206
1207
1208 if (rx_ring_tail != rx_old_tail)
1209 {
1210 lp->rx_ring[prev_rx(rx_ring_tail)].p->control |= CONTROL_EOL;
1211 lp->rx_ring[prev_rx(rx_old_tail)].p->control &= ~CONTROL_EOL;
1212
1213 lp->rx_ring_tail=rx_ring_tail;
1214 }
1215}
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232static void mc32_tx_ring(struct net_device *dev)
1233{
1234 struct mc32_local *lp = netdev_priv(dev);
1235 volatile struct skb_header *np;
1236
1237
1238
1239
1240
1241
1242
1243
1244 while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))
1245 {
1246 u16 t;
1247
1248 t=next_tx(lp->tx_ring_tail);
1249 np=lp->tx_ring[t].p;
1250
1251 if(!(np->status & (1<<7)))
1252 {
1253
1254 break;
1255 }
1256 lp->net_stats.tx_packets++;
1257 if(!(np->status & (1<<6)))
1258 {
1259 lp->net_stats.tx_errors++;
1260
1261 switch(np->status&0x0F)
1262 {
1263 case 1:
1264 lp->net_stats.tx_aborted_errors++;
1265 break;
1266 case 2:
1267 lp->net_stats.tx_fifo_errors++;
1268 break;
1269 case 3:
1270 lp->net_stats.tx_carrier_errors++;
1271 break;
1272 case 4:
1273 lp->net_stats.tx_window_errors++;
1274 break;
1275 case 5:
1276 lp->net_stats.tx_aborted_errors++;
1277 break;
1278 }
1279 }
1280
1281
1282
1283 lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
1284 dev_kfree_skb_irq(lp->tx_ring[t].skb);
1285 lp->tx_ring[t].skb=NULL;
1286 atomic_inc(&lp->tx_count);
1287 netif_wake_queue(dev);
1288
1289 lp->tx_ring_tail=t;
1290 }
1291
1292}
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317static irqreturn_t mc32_interrupt(int irq, void *dev_id)
1318{
1319 struct net_device *dev = dev_id;
1320 struct mc32_local *lp;
1321 int ioaddr, status, boguscount = 0;
1322 int rx_event = 0;
1323 int tx_event = 0;
1324
1325 ioaddr = dev->base_addr;
1326 lp = netdev_priv(dev);
1327
1328
1329
1330 while((inb(ioaddr+HOST_STATUS)&HOST_STATUS_CWR) && boguscount++<2000)
1331 {
1332 status=inb(ioaddr+HOST_CMD);
1333
1334#ifdef DEBUG_IRQ
1335 printk("Status TX%d RX%d EX%d OV%d BC%d\n",
1336 (status&7), (status>>3)&7, (status>>6)&1,
1337 (status>>7)&1, boguscount);
1338#endif
1339
1340 switch(status&7)
1341 {
1342 case 0:
1343 break;
1344 case 6:
1345 case 2:
1346 tx_event = 1;
1347 break;
1348 case 3:
1349 case 4:
1350 complete(&lp->xceiver_cmd);
1351 break;
1352 default:
1353 printk("%s: strange tx ack %d\n", dev->name, status&7);
1354 }
1355 status>>=3;
1356 switch(status&7)
1357 {
1358 case 0:
1359 break;
1360 case 2:
1361 rx_event=1;
1362 break;
1363 case 3:
1364 case 4:
1365 complete(&lp->xceiver_cmd);
1366 break;
1367 case 6:
1368
1369
1370 lp->net_stats.rx_dropped++;
1371 mc32_rx_ring(dev);
1372 mc32_start_transceiver(dev);
1373 break;
1374 default:
1375 printk("%s: strange rx ack %d\n",
1376 dev->name, status&7);
1377 }
1378 status>>=3;
1379 if(status&1)
1380 {
1381
1382
1383
1384
1385
1386 if (lp->cmd_nonblocking) {
1387 up(&lp->cmd_mutex);
1388 if (lp->mc_reload_wait)
1389 mc32_reset_multicast_list(dev);
1390 }
1391 else complete(&lp->execution_cmd);
1392 }
1393 if(status&2)
1394 {
1395
1396
1397
1398
1399
1400 mc32_update_stats(dev);
1401 }
1402 }
1403
1404
1405
1406
1407
1408
1409 if(tx_event)
1410 mc32_tx_ring(dev);
1411
1412 if(rx_event)
1413 mc32_rx_ring(dev);
1414
1415 return IRQ_HANDLED;
1416}
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441static int mc32_close(struct net_device *dev)
1442{
1443 struct mc32_local *lp = netdev_priv(dev);
1444 int ioaddr = dev->base_addr;
1445
1446 u8 regs;
1447 u16 one=1;
1448
1449 lp->xceiver_desired_state = HALTED;
1450 netif_stop_queue(dev);
1451
1452
1453
1454
1455
1456 mc32_command(dev, 4, &one, 2);
1457
1458
1459
1460 mc32_halt_transceiver(dev);
1461
1462
1463
1464 down(&lp->cmd_mutex);
1465
1466
1467
1468 regs=inb(ioaddr+HOST_CTRL);
1469 regs&=~HOST_CTRL_INTE;
1470 outb(regs, ioaddr+HOST_CTRL);
1471
1472 mc32_flush_rx_ring(dev);
1473 mc32_flush_tx_ring(dev);
1474
1475 mc32_update_stats(dev);
1476
1477 return 0;
1478}
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490static struct net_device_stats *mc32_get_stats(struct net_device *dev)
1491{
1492 struct mc32_local *lp = netdev_priv(dev);
1493
1494 mc32_update_stats(dev);
1495 return &lp->net_stats;
1496}
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
1523{
1524 struct mc32_local *lp = netdev_priv(dev);
1525 u16 filt = (1<<2);
1526
1527 if (dev->flags&IFF_PROMISC)
1528
1529 filt |= 1;
1530 else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
1531 {
1532 dev->flags|=IFF_PROMISC;
1533 filt |= 1;
1534 }
1535 else if(dev->mc_count)
1536 {
1537 unsigned char block[62];
1538 unsigned char *bp;
1539 struct dev_mc_list *dmc=dev->mc_list;
1540
1541 int i;
1542
1543 if(retry==0)
1544 lp->mc_list_valid = 0;
1545 if(!lp->mc_list_valid)
1546 {
1547 block[1]=0;
1548 block[0]=dev->mc_count;
1549 bp=block+2;
1550
1551 for(i=0;i<dev->mc_count;i++)
1552 {
1553 memcpy(bp, dmc->dmi_addr, 6);
1554 bp+=6;
1555 dmc=dmc->next;
1556 }
1557 if(mc32_command_nowait(dev, 2, block, 2+6*dev->mc_count)==-1)
1558 {
1559 lp->mc_reload_wait = 1;
1560 return;
1561 }
1562 lp->mc_list_valid=1;
1563 }
1564 }
1565
1566 if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
1567 {
1568 lp->mc_reload_wait = 1;
1569 }
1570 else {
1571 lp->mc_reload_wait = 0;
1572 }
1573}
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585static void mc32_set_multicast_list(struct net_device *dev)
1586{
1587 do_mc32_set_multicast_list(dev,0);
1588}
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600static void mc32_reset_multicast_list(struct net_device *dev)
1601{
1602 do_mc32_set_multicast_list(dev,1);
1603}
1604
1605static void netdev_get_drvinfo(struct net_device *dev,
1606 struct ethtool_drvinfo *info)
1607{
1608 strcpy(info->driver, DRV_NAME);
1609 strcpy(info->version, DRV_VERSION);
1610 sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1611}
1612
1613static u32 netdev_get_msglevel(struct net_device *dev)
1614{
1615 return mc32_debug;
1616}
1617
1618static void netdev_set_msglevel(struct net_device *dev, u32 level)
1619{
1620 mc32_debug = level;
1621}
1622
1623static const struct ethtool_ops netdev_ethtool_ops = {
1624 .get_drvinfo = netdev_get_drvinfo,
1625 .get_msglevel = netdev_get_msglevel,
1626 .set_msglevel = netdev_set_msglevel,
1627};
1628
1629#ifdef MODULE
1630
1631static struct net_device *this_device;
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641int __init init_module(void)
1642{
1643 this_device = mc32_probe(-1);
1644 if (IS_ERR(this_device))
1645 return PTR_ERR(this_device);
1646 return 0;
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660void __exit cleanup_module(void)
1661{
1662 unregister_netdev(this_device);
1663 cleanup_card(this_device);
1664 free_netdev(this_device);
1665}
1666
1667#endif
1668