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