1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
57static const char version[] =
58 "smc9194.c:v0.14 12/15/00 by Erik Stahlman (erik@vt.edu)\n";
59
60#include <linux/module.h>
61#include <linux/kernel.h>
62#include <linux/types.h>
63#include <linux/fcntl.h>
64#include <linux/interrupt.h>
65#include <linux/ioport.h>
66#include <linux/in.h>
67#include <linux/slab.h>
68#include <linux/string.h>
69#include <linux/init.h>
70#include <linux/crc32.h>
71#include <linux/errno.h>
72#include <linux/netdevice.h>
73#include <linux/etherdevice.h>
74#include <linux/skbuff.h>
75#include <linux/bitops.h>
76
77#include <asm/io.h>
78
79#include "smc9194.h"
80
81#define DRV_NAME "smc9194"
82
83
84
85
86
87
88
89
90
91
92
93#ifdef __sh__
94#undef USE_32_BIT
95#else
96#define USE_32_BIT 1
97#endif
98
99#if defined(__H8300H__) || defined(__H8300S__)
100#define NO_AUTOPROBE
101#undef insl
102#undef outsl
103#define insl(a,b,l) io_insl_noswap(a,b,l)
104#define outsl(a,b,l) io_outsl_noswap(a,b,l)
105#endif
106
107
108
109
110
111
112
113struct devlist {
114 unsigned int port;
115 unsigned int irq;
116};
117
118#if defined(CONFIG_H8S_EDOSK2674)
119static struct devlist smc_devlist[] __initdata = {
120 {.port = 0xf80000, .irq = 16},
121 {.port = 0, .irq = 0 },
122};
123#else
124static struct devlist smc_devlist[] __initdata = {
125 {.port = 0x200, .irq = 0},
126 {.port = 0x220, .irq = 0},
127 {.port = 0x240, .irq = 0},
128 {.port = 0x260, .irq = 0},
129 {.port = 0x280, .irq = 0},
130 {.port = 0x2A0, .irq = 0},
131 {.port = 0x2C0, .irq = 0},
132 {.port = 0x2E0, .irq = 0},
133 {.port = 0x300, .irq = 0},
134 {.port = 0x320, .irq = 0},
135 {.port = 0x340, .irq = 0},
136 {.port = 0x360, .irq = 0},
137 {.port = 0x380, .irq = 0},
138 {.port = 0x3A0, .irq = 0},
139 {.port = 0x3C0, .irq = 0},
140 {.port = 0x3E0, .irq = 0},
141 {.port = 0, .irq = 0},
142};
143#endif
144
145
146
147
148
149#define MEMORY_WAIT_TIME 16
150
151
152
153
154
155
156
157
158
159
160#define SMC_DEBUG 0
161
162#if (SMC_DEBUG > 2 )
163#define PRINTK3(x) printk x
164#else
165#define PRINTK3(x)
166#endif
167
168#if SMC_DEBUG > 1
169#define PRINTK2(x) printk x
170#else
171#define PRINTK2(x)
172#endif
173
174#ifdef SMC_DEBUG
175#define PRINTK(x) printk x
176#else
177#define PRINTK(x)
178#endif
179
180
181
182
183
184
185
186
187
188#define CARDNAME "SMC9194"
189
190
191
192struct smc_local {
193
194
195
196
197
198 struct sk_buff * saved_skb;
199
200
201
202
203
204
205 int packets_waiting;
206};
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224struct net_device *smc_init(int unit);
225
226
227
228
229
230static int smc_open(struct net_device *dev);
231
232
233
234
235static void smc_timeout(struct net_device *dev);
236
237
238
239
240
241
242static int smc_close(struct net_device *dev);
243
244
245
246
247
248static void smc_set_multicast_list(struct net_device *dev);
249
250
251
252
253
254
255
256
257
258
259
260static irqreturn_t smc_interrupt(int irq, void *);
261
262
263
264
265static inline void smc_rcv( struct net_device *dev );
266
267
268
269
270static inline void smc_tx( struct net_device * dev );
271
272
273
274
275
276
277
278
279
280
281
282
283
284static int smc_probe(struct net_device *dev, int ioaddr);
285
286
287
288
289#if SMC_DEBUG > 2
290static void print_packet( byte *, int );
291#endif
292
293#define tx_done(dev) 1
294
295
296static void smc_hardware_send_packet( struct net_device * dev );
297
298
299
300
301
302static int smc_wait_to_send_packet( struct sk_buff * skb, struct net_device *dev );
303
304
305static void smc_reset( int ioaddr );
306
307
308static void smc_enable( int ioaddr );
309
310
311static void smc_shutdown( int ioaddr );
312
313
314
315static int smc_findirq( int ioaddr );
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334static void smc_reset( int ioaddr )
335{
336
337
338 SMC_SELECT_BANK( 0 );
339 outw( RCR_SOFTRESET, ioaddr + RCR );
340
341
342 SMC_DELAY( );
343
344
345
346 outw( RCR_CLEAR, ioaddr + RCR );
347 outw( TCR_CLEAR, ioaddr + TCR );
348
349
350
351
352 SMC_SELECT_BANK( 1 );
353 outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );
354
355
356 SMC_SELECT_BANK( 2 );
357 outw( MC_RESET, ioaddr + MMU_CMD );
358
359
360
361
362
363 outb( 0, ioaddr + INT_MASK );
364}
365
366
367
368
369
370
371
372
373
374static void smc_enable( int ioaddr )
375{
376 SMC_SELECT_BANK( 0 );
377
378 outw( TCR_NORMAL, ioaddr + TCR );
379 outw( RCR_NORMAL, ioaddr + RCR );
380
381
382 SMC_SELECT_BANK( 2 );
383 outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
384}
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400static void smc_shutdown( int ioaddr )
401{
402
403 SMC_SELECT_BANK( 2 );
404 outb( 0, ioaddr + INT_MASK );
405
406
407 SMC_SELECT_BANK( 0 );
408 outb( RCR_CLEAR, ioaddr + RCR );
409 outb( TCR_CLEAR, ioaddr + TCR );
410#if 0
411
412 SMC_SELECT_BANK( 1 );
413 outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL );
414#endif
415}
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list * addrs ) {
437 int i;
438 unsigned char multicast_table[ 8 ];
439 struct dev_mc_list * cur_addr;
440
441 unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
442
443
444 memset( multicast_table, 0, sizeof( multicast_table ) );
445
446 cur_addr = addrs;
447 for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next ) {
448 int position;
449
450
451 if ( !cur_addr )
452 break;
453
454
455 if ( !( *cur_addr->dmi_addr & 1 ) )
456 continue;
457
458
459 position = ether_crc_le(6, cur_addr->dmi_addr) & 0x3f;
460
461
462 multicast_table[invert3[position&7]] |=
463 (1<<invert3[(position>>3)&7]);
464
465 }
466
467 SMC_SELECT_BANK( 3 );
468
469 for ( i = 0; i < 8 ; i++ ) {
470 outb( multicast_table[i], ioaddr + MULTICAST1 + i );
471 }
472}
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490static int smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * dev )
491{
492 struct smc_local *lp = netdev_priv(dev);
493 unsigned int ioaddr = dev->base_addr;
494 word length;
495 unsigned short numPages;
496 word time_out;
497
498 netif_stop_queue(dev);
499
500
501
502 if ( lp->saved_skb) {
503
504 dev->stats.tx_aborted_errors++;
505 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
506 return 1;
507 }
508 lp->saved_skb = skb;
509
510 length = skb->len;
511
512 if (length < ETH_ZLEN) {
513 if (skb_padto(skb, ETH_ZLEN)) {
514 netif_wake_queue(dev);
515 return 0;
516 }
517 length = ETH_ZLEN;
518 }
519
520
521
522
523
524
525
526
527 numPages = ((length & 0xfffe) + 6) / 256;
528
529 if (numPages > 7 ) {
530 printk(CARDNAME": Far too big packet error. \n");
531
532
533 dev_kfree_skb (skb);
534 lp->saved_skb = NULL;
535
536 netif_wake_queue(dev);
537 return 0;
538 }
539
540 lp->packets_waiting++;
541
542
543 SMC_SELECT_BANK( 2 );
544 outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
545
546
547
548
549
550
551
552
553
554
555
556
557 time_out = MEMORY_WAIT_TIME;
558 do {
559 word status;
560
561 status = inb( ioaddr + INTERRUPT );
562 if ( status & IM_ALLOC_INT ) {
563
564 outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
565 break;
566 }
567 } while ( -- time_out );
568
569 if ( !time_out ) {
570
571 SMC_ENABLE_INT( IM_ALLOC_INT );
572 PRINTK2((CARDNAME": memory allocation deferred. \n"));
573
574 return 0;
575 }
576
577 smc_hardware_send_packet(dev);
578 netif_wake_queue(dev);
579 return 0;
580}
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600static void smc_hardware_send_packet( struct net_device * dev )
601{
602 struct smc_local *lp = netdev_priv(dev);
603 byte packet_no;
604 struct sk_buff * skb = lp->saved_skb;
605 word length;
606 unsigned int ioaddr;
607 byte * buf;
608
609 ioaddr = dev->base_addr;
610
611 if ( !skb ) {
612 PRINTK((CARDNAME": In XMIT with no packet to send \n"));
613 return;
614 }
615 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
616 buf = skb->data;
617
618
619 packet_no = inb( ioaddr + PNR_ARR + 1 );
620 if ( packet_no & 0x80 ) {
621
622 printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
623 dev_kfree_skb_any(skb);
624 lp->saved_skb = NULL;
625 netif_wake_queue(dev);
626 return;
627 }
628
629
630 outb( packet_no, ioaddr + PNR_ARR );
631
632
633 outw( PTR_AUTOINC , ioaddr + POINTER );
634
635 PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
636#if SMC_DEBUG > 2
637 print_packet( buf, length );
638#endif
639
640
641
642#ifdef USE_32_BIT
643 outl( (length +6 ) << 16 , ioaddr + DATA_1 );
644#else
645 outw( 0, ioaddr + DATA_1 );
646
647 outb( (length+6) & 0xFF,ioaddr + DATA_1 );
648 outb( (length+6) >> 8 , ioaddr + DATA_1 );
649#endif
650
651
652
653
654
655
656
657
658#ifdef USE_32_BIT
659 if ( length & 0x2 ) {
660 outsl(ioaddr + DATA_1, buf, length >> 2 );
661#if !defined(__H8300H__) && !defined(__H8300S__)
662 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
663#else
664 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
665#endif
666 }
667 else
668 outsl(ioaddr + DATA_1, buf, length >> 2 );
669#else
670 outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
671#endif
672
673
674 if ( (length & 1) == 0 ) {
675 outw( 0, ioaddr + DATA_1 );
676 } else {
677 outb( buf[length -1 ], ioaddr + DATA_1 );
678 outb( 0x20, ioaddr + DATA_1);
679 }
680
681
682 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
683
684
685 outw( MC_ENQUEUE , ioaddr + MMU_CMD );
686
687 PRINTK2((CARDNAME": Sent packet of length %d \n",length));
688
689 lp->saved_skb = NULL;
690 dev_kfree_skb_any (skb);
691
692 dev->trans_start = jiffies;
693
694
695 netif_wake_queue(dev);
696
697 return;
698}
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714static int io;
715static int irq;
716static int ifport;
717
718struct net_device * __init smc_init(int unit)
719{
720 struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
721 struct devlist *smcdev = smc_devlist;
722 int err = 0;
723
724 if (!dev)
725 return ERR_PTR(-ENODEV);
726
727 if (unit >= 0) {
728 sprintf(dev->name, "eth%d", unit);
729 netdev_boot_setup_check(dev);
730 io = dev->base_addr;
731 irq = dev->irq;
732 }
733
734 if (io > 0x1ff) {
735 err = smc_probe(dev, io);
736 } else if (io != 0) {
737 err = -ENXIO;
738 } else {
739 for (;smcdev->port; smcdev++) {
740 if (smc_probe(dev, smcdev->port) == 0)
741 break;
742 }
743 if (!smcdev->port)
744 err = -ENODEV;
745 }
746 if (err)
747 goto out;
748 err = register_netdev(dev);
749 if (err)
750 goto out1;
751 return dev;
752out1:
753 free_irq(dev->irq, dev);
754 release_region(dev->base_addr, SMC_IO_EXTENT);
755out:
756 free_netdev(dev);
757 return ERR_PTR(err);
758}
759
760
761
762
763
764
765
766
767int __init smc_findirq( int ioaddr )
768{
769#ifndef NO_AUTOPROBE
770 int timeout = 20;
771 unsigned long cookie;
772
773
774 cookie = probe_irq_on();
775
776
777
778
779
780
781
782
783 SMC_SELECT_BANK(2);
784
785 outb( IM_ALLOC_INT, ioaddr + INT_MASK );
786
787
788
789
790
791 outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
792
793
794
795
796 while ( timeout ) {
797 byte int_status;
798
799 int_status = inb( ioaddr + INTERRUPT );
800
801 if ( int_status & IM_ALLOC_INT )
802 break;
803 timeout--;
804 }
805
806
807
808
809
810
811
812
813
814
815
816 SMC_DELAY();
817 SMC_DELAY();
818
819
820 outb( 0, ioaddr + INT_MASK );
821
822
823 return probe_irq_off(cookie);
824#else
825 struct devlist *smcdev;
826 for (smcdev = smc_devlist; smcdev->port; smcdev++) {
827 if (smcdev->port == ioaddr)
828 return smcdev->irq;
829 }
830 return 0;
831#endif
832}
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863static int __init smc_probe(struct net_device *dev, int ioaddr)
864{
865 int i, memory, retval;
866 static unsigned version_printed;
867 unsigned int bank;
868
869 const char *version_string;
870 const char *if_string;
871
872
873 word revision_register;
874 word base_address_register;
875 word configuration_register;
876 word memory_info_register;
877 word memory_cfg_register;
878
879 DECLARE_MAC_BUF(mac);
880
881
882 if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
883 return -EBUSY;
884
885 dev->irq = irq;
886 dev->if_port = ifport;
887
888
889 bank = inw( ioaddr + BANK_SELECT );
890 if ( (bank & 0xFF00) != 0x3300 ) {
891 retval = -ENODEV;
892 goto err_out;
893 }
894
895
896 outw( 0x0, ioaddr + BANK_SELECT );
897 bank = inw( ioaddr + BANK_SELECT );
898 if ( (bank & 0xFF00 ) != 0x3300 ) {
899 retval = -ENODEV;
900 goto err_out;
901 }
902#if !defined(CONFIG_H8S_EDOSK2674)
903
904
905
906 SMC_SELECT_BANK(1);
907 base_address_register = inw( ioaddr + BASE );
908 if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {
909 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x)."
910 "Probably not a SMC chip\n",
911 ioaddr, base_address_register >> 3 & 0x3E0 );
912
913
914 retval = -ENODEV;
915 goto err_out;
916 }
917#else
918 (void)base_address_register;
919#endif
920
921
922
923
924
925 SMC_SELECT_BANK(3);
926 revision_register = inw( ioaddr + REVISION );
927 if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {
928
929 printk(CARDNAME ": IO %x: Unrecognized revision register:"
930 " %x, Contact author. \n", ioaddr, revision_register );
931
932 retval = -ENODEV;
933 goto err_out;
934 }
935
936
937
938
939
940 if (version_printed++ == 0)
941 printk("%s", version);
942
943
944 dev->base_addr = ioaddr;
945
946
947
948
949 SMC_SELECT_BANK( 1 );
950 for ( i = 0; i < 6; i += 2 ) {
951 word address;
952
953 address = inw( ioaddr + ADDR0 + i );
954 dev->dev_addr[ i + 1] = address >> 8;
955 dev->dev_addr[ i ] = address & 0xFF;
956 }
957
958
959
960 SMC_SELECT_BANK( 0 );
961 memory_info_register = inw( ioaddr + MIR );
962 memory_cfg_register = inw( ioaddr + MCR );
963 memory = ( memory_cfg_register >> 9 ) & 0x7;
964 memory *= 256 * ( memory_info_register & 0xFF );
965
966
967
968
969
970
971 SMC_SELECT_BANK(3);
972 revision_register = inw( ioaddr + REVISION );
973 version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];
974 if ( !version_string ) {
975
976 retval = -ENODEV;
977 goto err_out;
978 }
979
980
981 if ( dev->if_port == 0 ) {
982 SMC_SELECT_BANK(1);
983 configuration_register = inw( ioaddr + CONFIG );
984 if ( configuration_register & CFG_AUI_SELECT )
985 dev->if_port = 2;
986 else
987 dev->if_port = 1;
988 }
989 if_string = interfaces[ dev->if_port - 1 ];
990
991
992 smc_reset( ioaddr );
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010 if ( dev->irq < 2 ) {
1011 int trials;
1012
1013 trials = 3;
1014 while ( trials-- ) {
1015 dev->irq = smc_findirq( ioaddr );
1016 if ( dev->irq )
1017 break;
1018
1019 smc_reset( ioaddr );
1020 }
1021 }
1022 if (dev->irq == 0 ) {
1023 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1024 retval = -ENODEV;
1025 goto err_out;
1026 }
1027
1028
1029
1030 printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1031 version_string, revision_register & 0xF, ioaddr, dev->irq,
1032 if_string, memory );
1033
1034
1035
1036 printk("ADDR: %s\n", print_mac(mac, dev->dev_addr));
1037
1038
1039 memset(dev->priv, 0, sizeof(struct smc_local));
1040
1041
1042 retval = request_irq(dev->irq, &smc_interrupt, 0, DRV_NAME, dev);
1043 if (retval) {
1044 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1045 dev->irq, retval);
1046 goto err_out;
1047 }
1048
1049 dev->open = smc_open;
1050 dev->stop = smc_close;
1051 dev->hard_start_xmit = smc_wait_to_send_packet;
1052 dev->tx_timeout = smc_timeout;
1053 dev->watchdog_timeo = HZ/20;
1054 dev->set_multicast_list = smc_set_multicast_list;
1055
1056 return 0;
1057
1058err_out:
1059 release_region(ioaddr, SMC_IO_EXTENT);
1060 return retval;
1061}
1062
1063#if SMC_DEBUG > 2
1064static void print_packet( byte * buf, int length )
1065{
1066#if 0
1067 int i;
1068 int remainder;
1069 int lines;
1070
1071 printk("Packet of length %d \n", length );
1072 lines = length / 16;
1073 remainder = length % 16;
1074
1075 for ( i = 0; i < lines ; i ++ ) {
1076 int cur;
1077
1078 for ( cur = 0; cur < 8; cur ++ ) {
1079 byte a, b;
1080
1081 a = *(buf ++ );
1082 b = *(buf ++ );
1083 printk("%02x%02x ", a, b );
1084 }
1085 printk("\n");
1086 }
1087 for ( i = 0; i < remainder/2 ; i++ ) {
1088 byte a, b;
1089
1090 a = *(buf ++ );
1091 b = *(buf ++ );
1092 printk("%02x%02x ", a, b );
1093 }
1094 printk("\n");
1095#endif
1096}
1097#endif
1098
1099
1100
1101
1102
1103
1104
1105
1106static int smc_open(struct net_device *dev)
1107{
1108 int ioaddr = dev->base_addr;
1109
1110 int i;
1111
1112
1113 memset(dev->priv, 0, sizeof(struct smc_local));
1114
1115
1116
1117 smc_reset( ioaddr );
1118 smc_enable( ioaddr );
1119
1120
1121
1122 SMC_SELECT_BANK( 1 );
1123 if ( dev->if_port == 1 ) {
1124 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1125 ioaddr + CONFIG );
1126 }
1127 else if ( dev->if_port == 2 ) {
1128 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1129 ioaddr + CONFIG );
1130 }
1131
1132
1133
1134
1135
1136
1137 SMC_SELECT_BANK( 1 );
1138 for ( i = 0; i < 6; i += 2 ) {
1139 word address;
1140
1141 address = dev->dev_addr[ i + 1 ] << 8 ;
1142 address |= dev->dev_addr[ i ];
1143 outw( address, ioaddr + ADDR0 + i );
1144 }
1145
1146 netif_start_queue(dev);
1147 return 0;
1148}
1149
1150
1151
1152
1153
1154
1155
1156
1157static void smc_timeout(struct net_device *dev)
1158{
1159
1160
1161 printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1162 tx_done(dev) ? "IRQ conflict" :
1163 "network cable problem");
1164
1165 smc_reset( dev->base_addr );
1166 smc_enable( dev->base_addr );
1167 dev->trans_start = jiffies;
1168
1169 ((struct smc_local *)dev->priv)->saved_skb = NULL;
1170 netif_wake_queue(dev);
1171}
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185static void smc_rcv(struct net_device *dev)
1186{
1187 int ioaddr = dev->base_addr;
1188 int packet_number;
1189 word status;
1190 word packet_length;
1191
1192
1193
1194 packet_number = inw( ioaddr + FIFO_PORTS );
1195
1196 if ( packet_number & FP_RXEMPTY ) {
1197
1198 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
1199
1200 return;
1201 }
1202
1203
1204 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1205
1206
1207 status = inw( ioaddr + DATA_1 );
1208 packet_length = inw( ioaddr + DATA_1 );
1209
1210 packet_length &= 0x07ff;
1211
1212 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1213
1214
1215
1216
1217 packet_length -= 6;
1218
1219 if ( !(status & RS_ERRORS ) ){
1220
1221 struct sk_buff * skb;
1222 byte * data;
1223
1224
1225 if ( status & RS_ODDFRAME )
1226 packet_length++;
1227
1228
1229 if ( status & RS_MULTICAST )
1230 dev->stats.multicast++;
1231
1232 skb = dev_alloc_skb( packet_length + 5);
1233
1234 if ( skb == NULL ) {
1235 printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1236 dev->stats.rx_dropped++;
1237 goto done;
1238 }
1239
1240
1241
1242
1243
1244
1245 skb_reserve( skb, 2 );
1246
1247 data = skb_put( skb, packet_length);
1248
1249#ifdef USE_32_BIT
1250
1251
1252
1253
1254 PRINTK3((" Reading %d dwords (and %d bytes) \n",
1255 packet_length >> 2, packet_length & 3 ));
1256 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1257
1258 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1259 packet_length & 0x3 );
1260#else
1261 PRINTK3((" Reading %d words and %d byte(s) \n",
1262 (packet_length >> 1 ), packet_length & 1 ));
1263 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1264 if ( packet_length & 1 ) {
1265 data += packet_length & ~1;
1266 *(data++) = inb( ioaddr + DATA_1 );
1267 }
1268#endif
1269#if SMC_DEBUG > 2
1270 print_packet( data, packet_length );
1271#endif
1272
1273 skb->protocol = eth_type_trans(skb, dev );
1274 netif_rx(skb);
1275 dev->last_rx = jiffies;
1276 dev->stats.rx_packets++;
1277 dev->stats.rx_bytes += packet_length;
1278 } else {
1279
1280 dev->stats.rx_errors++;
1281
1282 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
1283 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1284 dev->stats.rx_length_errors++;
1285 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
1286 }
1287
1288done:
1289
1290 outw( MC_RELEASE, ioaddr + MMU_CMD );
1291}
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309static void smc_tx( struct net_device * dev )
1310{
1311 int ioaddr = dev->base_addr;
1312 struct smc_local *lp = netdev_priv(dev);
1313 byte saved_packet;
1314 byte packet_no;
1315 word tx_status;
1316
1317
1318
1319
1320 saved_packet = inb( ioaddr + PNR_ARR );
1321 packet_no = inw( ioaddr + FIFO_PORTS );
1322 packet_no &= 0x7F;
1323
1324
1325 outb( packet_no, ioaddr + PNR_ARR );
1326
1327
1328 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1329
1330 tx_status = inw( ioaddr + DATA_1 );
1331 PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
1332
1333 dev->stats.tx_errors++;
1334 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1335 if ( tx_status & TS_LATCOL ) {
1336 printk(KERN_DEBUG CARDNAME
1337 ": Late collision occurred on last xmit.\n");
1338 dev->stats.tx_window_errors++;
1339 }
1340#if 0
1341 if ( tx_status & TS_16COL ) { ... }
1342#endif
1343
1344 if ( tx_status & TS_SUCCESS ) {
1345 printk(CARDNAME": Successful packet caused interrupt \n");
1346 }
1347
1348 SMC_SELECT_BANK( 0 );
1349 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1350
1351
1352 SMC_SELECT_BANK( 2 );
1353 outw( MC_FREEPKT, ioaddr + MMU_CMD );
1354
1355
1356 lp->packets_waiting--;
1357
1358 outb( saved_packet, ioaddr + PNR_ARR );
1359 return;
1360}
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375static irqreturn_t smc_interrupt(int irq, void * dev_id)
1376{
1377 struct net_device *dev = dev_id;
1378 int ioaddr = dev->base_addr;
1379 struct smc_local *lp = netdev_priv(dev);
1380
1381 byte status;
1382 word card_stats;
1383 byte mask;
1384 int timeout;
1385
1386 word saved_bank;
1387 word saved_pointer;
1388 int handled = 0;
1389
1390
1391 PRINTK3((CARDNAME": SMC interrupt started \n"));
1392
1393 saved_bank = inw( ioaddr + BANK_SELECT );
1394
1395 SMC_SELECT_BANK(2);
1396 saved_pointer = inw( ioaddr + POINTER );
1397
1398 mask = inb( ioaddr + INT_MASK );
1399
1400 outb( 0, ioaddr + INT_MASK );
1401
1402
1403
1404 timeout = 4;
1405
1406 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
1407 do {
1408
1409 status = inb( ioaddr + INTERRUPT ) & mask;
1410 if (!status )
1411 break;
1412
1413 handled = 1;
1414
1415 PRINTK3((KERN_WARNING CARDNAME
1416 ": Handling interrupt status %x \n", status ));
1417
1418 if (status & IM_RCV_INT) {
1419
1420 PRINTK2((KERN_WARNING CARDNAME
1421 ": Receive Interrupt\n"));
1422 smc_rcv(dev);
1423 } else if (status & IM_TX_INT ) {
1424 PRINTK2((KERN_WARNING CARDNAME
1425 ": TX ERROR handled\n"));
1426 smc_tx(dev);
1427 outb(IM_TX_INT, ioaddr + INTERRUPT );
1428 } else if (status & IM_TX_EMPTY_INT ) {
1429
1430 SMC_SELECT_BANK( 0 );
1431 card_stats = inw( ioaddr + COUNTER );
1432
1433 dev->stats.collisions += card_stats & 0xF;
1434 card_stats >>= 4;
1435
1436 dev->stats.collisions += card_stats & 0xF;
1437
1438
1439
1440 SMC_SELECT_BANK( 2 );
1441 PRINTK2((KERN_WARNING CARDNAME
1442 ": TX_BUFFER_EMPTY handled\n"));
1443 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1444 mask &= ~IM_TX_EMPTY_INT;
1445 dev->stats.tx_packets += lp->packets_waiting;
1446 lp->packets_waiting = 0;
1447
1448 } else if (status & IM_ALLOC_INT ) {
1449 PRINTK2((KERN_DEBUG CARDNAME
1450 ": Allocation interrupt \n"));
1451
1452 mask &= ~IM_ALLOC_INT;
1453
1454 smc_hardware_send_packet( dev );
1455
1456
1457 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1458
1459
1460 netif_wake_queue(dev);
1461
1462 PRINTK2((CARDNAME": Handoff done successfully.\n"));
1463 } else if (status & IM_RX_OVRN_INT ) {
1464 dev->stats.rx_errors++;
1465 dev->stats.rx_fifo_errors++;
1466 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1467 } else if (status & IM_EPH_INT ) {
1468 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
1469 } else if (status & IM_ERCV_INT ) {
1470 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
1471 outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1472 }
1473 } while ( timeout -- );
1474
1475
1476
1477 SMC_SELECT_BANK( 2 );
1478 outb( mask, ioaddr + INT_MASK );
1479
1480 PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
1481 outw( saved_pointer, ioaddr + POINTER );
1482
1483 SMC_SELECT_BANK( saved_bank );
1484
1485 PRINTK3((CARDNAME ": Interrupt done\n"));
1486 return IRQ_RETVAL(handled);
1487}
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498static int smc_close(struct net_device *dev)
1499{
1500 netif_stop_queue(dev);
1501
1502 smc_shutdown( dev->base_addr );
1503
1504
1505 return 0;
1506}
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516static void smc_set_multicast_list(struct net_device *dev)
1517{
1518 short ioaddr = dev->base_addr;
1519
1520 SMC_SELECT_BANK(0);
1521 if ( dev->flags & IFF_PROMISC )
1522 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533 else if (dev->flags & IFF_ALLMULTI)
1534 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1535
1536
1537
1538
1539 else if (dev->mc_count ) {
1540
1541
1542
1543 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1544 ioaddr + RCR );
1545
1546
1547 smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
1548 }
1549 else {
1550 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1551 ioaddr + RCR );
1552
1553
1554
1555
1556
1557 SMC_SELECT_BANK( 3 );
1558 outw( 0, ioaddr + MULTICAST1 );
1559 outw( 0, ioaddr + MULTICAST2 );
1560 outw( 0, ioaddr + MULTICAST3 );
1561 outw( 0, ioaddr + MULTICAST4 );
1562 }
1563}
1564
1565#ifdef MODULE
1566
1567static struct net_device *devSMC9194;
1568MODULE_LICENSE("GPL");
1569
1570module_param(io, int, 0);
1571module_param(irq, int, 0);
1572module_param(ifport, int, 0);
1573MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1574MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1575MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1576
1577int __init init_module(void)
1578{
1579 if (io == 0)
1580 printk(KERN_WARNING
1581 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1582
1583
1584 devSMC9194 = smc_init(-1);
1585 if (IS_ERR(devSMC9194))
1586 return PTR_ERR(devSMC9194);
1587 return 0;
1588}
1589
1590void __exit cleanup_module(void)
1591{
1592 unregister_netdev(devSMC9194);
1593 free_irq(devSMC9194->irq, devSMC9194);
1594 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1595 free_netdev(devSMC9194);
1596}
1597
1598#endif
1599