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