This source file includes following definitions.
- arcnet_probe
- arcnet_ioprobe
- arcnet_memprobe
- arcnet_open
- arcnet_close
- arcnet_send_packet
- arcnet_continue_tx
- careful_xmit_wait
- arcnet_prepare_tx
- arcnet_go_tx
- arcnet_interrupt
- arcnet_inthandler
- arcnet_rx
- arcnet_timer
- arcnet_get_stats
- set_multicast_list
- arcnet_reset
- arc_header
- arc_rebuild_header
- arc_type_trans
- init_module
- cleanup_module
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 #define DANGER_PROBE
47
48
49
50
51 #undef EXTRA_DELAYS
52
53
54
55
56 #define IRQ_XMIT
57
58
59
60
61 #undef CAREFUL_XMIT
62
63
64
65
66 #define STRICT_MEM_DETECT
67
68
69
70
71
72
73
74 #undef LIMIT_MTU
75
76
77
78
79
80
81
82
83
84
85 #undef USE_TIMER_HANDLER
86
87
88
89 static char *version =
90 "arcnet.c:v1.01 95/03/24 Avery Pennarun <apenwarr@tourism.807-city.on.ca>\n";
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107 #include <linux/config.h>
108 #ifdef MODULE
109 #include <linux/module.h>
110 #include <linux/version.h>
111 #endif
112
113 #include <linux/kernel.h>
114 #include <linux/sched.h>
115 #include <linux/types.h>
116 #include <linux/fcntl.h>
117 #include <linux/interrupt.h>
118 #include <linux/ptrace.h>
119 #include <linux/ioport.h>
120 #include <linux/in.h>
121 #include <linux/malloc.h>
122 #include <linux/string.h>
123 #include <linux/timer.h>
124 #include <linux/errno.h>
125 #include <linux/delay.h>
126
127 #include <asm/system.h>
128 #include <asm/bitops.h>
129 #include <asm/io.h>
130 #include <asm/dma.h>
131
132 #include <linux/netdevice.h>
133 #include <linux/etherdevice.h>
134 #include <linux/skbuff.h>
135 #include <net/arp.h>
136
137
138
139
140
141
142
143
144
145
146
147 #define D_OFF 0
148 #define D_NORMAL 1
149 #define D_INIT 2
150 #define D_EXTRA 3
151 #define D_DURING 4
152 #define D_DATA 6
153 #define D_TX 8
154 #define D_RX 9
155
156 #ifndef NET_DEBUG
157 #define NET_DEBUG D_INIT
158 #endif
159 static unsigned int net_debug = NET_DEBUG;
160
161 #ifndef HAVE_AUTOIRQ
162
163 extern void autoirq_setup(int waittime);
164 extern int autoirq_report(int waittime);
165
166
167 extern struct device *irq2dev_map[16];
168 #endif
169
170 #ifndef HAVE_PORTRESERVE
171 #define check_region(ioaddr, size) 0
172 #define request_region(ioaddr, size) do ; while (0)
173 #endif
174
175
176 #define BUGLVL(x) if (net_debug>=x)
177
178
179 #define ETHERCARD_TOTAL_SIZE 16
180
181
182
183
184 #define INTMASK (ioaddr+0)
185 #define STATUS (ioaddr+0)
186 #define COMMAND (ioaddr+1)
187 #define RESET (ioaddr+8)
188
189
190 #define RESETtime 40
191 #define XMITtime 10
192 #define ACKtime 10
193
194
195
196
197
198
199
200
201
202 #define MTU (253+EXTRA_CLIENTDATA)
203 #define MinTU (257+EXTRA_CLIENTDATA)
204 #define XMTU (508+EXTRA_CLIENTDATA)
205
206
207 #define TXFREEflag 0x001
208 #define TXACKflag 0x002
209 #define RECONflag 0x004
210 #define TESTflag 0x008
211 #define RESETflag 0x010
212 #define RES1flag 0x020
213 #define RES2flag 0x040
214 #define NORXflag 0x080
215
216
217
218
219
220
221 #define NOTXcmd 0x001
222 #define NORXcmd 0x002
223 #define TXcmd 0x003
224 #define RXcmd 0x004
225 #define CONFIGcmd 0x005
226 #define CFLAGScmd 0x006
227 #define TESTcmd 0x007
228
229
230 #define RESETclear 0x008
231 #define CONFIGclear 0x010
232
233
234 #define TESTload 0x008
235
236
237 #define TESTvalue 0321
238
239
240 #define RXbcasts 0x080
241
242
243 #define NORMALconf 0x000
244 #define EXTconf 0x008
245
246
247
248 #define EnableReceiver() outb(RXcmd|(recbuf<<3)|RXbcasts,COMMAND)
249
250
251
252 #define ARC_P_IP 212
253 #define ARC_P_ARP 213
254 #define ARC_P_RARP 214
255 #define ARC_P_IPX 250
256 #define ARC_P_LANSOFT 251
257 #define ARC_P_ATALK 0xDD
258
259
260 #define TIMERval (HZ/8)
261
262
263 #define NORMAL 0
264 #define EXTENDED 1
265 #define EXCEPTION 2
266
267
268 struct HardHeader
269 {
270 u_char source,
271 destination,
272 offset1,
273 offset2;
274 };
275
276
277 union ArcPacket
278 {
279 struct HardHeader hardheader;
280 u_char raw[512];
281 };
282
283
284
285
286
287 struct ClientData
288 {
289
290 u_char daddr;
291
292
293
294 u_char saddr;
295
296
297 u_char protocol_id,
298 split_flag;
299 u_short sequence;
300 };
301 #define EXTRA_CLIENTDATA (sizeof(struct ClientData)-4)
302
303
304
305
306
307 struct Incoming
308 {
309 struct sk_buff *skb;
310 unsigned char lastpacket,
311 numpackets;
312 u_short sequence;
313 };
314
315 struct Outgoing
316 {
317 struct sk_buff *skb;
318 struct ClientData *hdr;
319 u_char *data;
320 short length,
321 dataleft,
322 segnum,
323 numsegs,
324 seglen;
325 };
326
327
328
329 struct arcnet_local {
330 struct enet_statistics stats;
331 u_char arcnum;
332 u_short sequence;
333 u_char recbuf,
334 txbuf,
335 txready;
336 short intx,
337 in_txhandler,
338 sending;
339 short tx_left;
340 struct timer_list timer;
341 struct Incoming incoming[256];
342 struct Outgoing outgoing;
343 };
344
345
346
347 extern int arcnet_probe(struct device *dev);
348 #ifndef MODULE
349 static int arcnet_memprobe(struct device *dev,u_char *addr);
350 static int arcnet_ioprobe(struct device *dev, short ioaddr);
351 #endif
352
353 static int arcnet_open(struct device *dev);
354 static int arcnet_close(struct device *dev);
355
356 static int arcnet_send_packet(struct sk_buff *skb, struct device *dev);
357 #ifdef CAREFUL_XMIT
358 static void careful_xmit_wait(struct device *dev);
359 #else
360 #define careful_xmit_wait(dev)
361 #endif
362 static void arcnet_continue_tx(struct device *dev);
363 static void arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,
364 short length,char *data);
365 static void arcnet_go_tx(struct device *dev);
366
367 static void arcnet_interrupt(int irq,struct pt_regs *regs);
368 static void arcnet_inthandler(struct device *dev);
369 static void arcnet_rx(struct device *dev,int recbuf);
370
371 #ifdef USE_TIMER_HANDLER
372 static void arcnet_timer(unsigned long arg);
373 #endif
374
375 static struct enet_statistics *arcnet_get_stats(struct device *dev);
376 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
377
378
379 int arc_header(unsigned char *buff,struct device *dev,unsigned short type,
380 void *daddr,void *saddr,unsigned len,struct sk_buff *skb);
381 int arc_rebuild_header(void *eth,struct device *dev,unsigned long raddr,
382 struct sk_buff *skb);
383 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev);
384
385 static int arcnet_reset(struct device *dev);
386
387 #ifdef MODULE
388 int init_module(void);
389 void cleanup_module(void);
390 #endif
391
392 #define tx_done(dev) 1
393
394
395
396
397 #define JIFFER(time) for (delayval=0; delayval<(time*10); delayval++) \
398 udelay(1000);
399
400 #ifdef EXTRA_DELAYS
401 #define XJIFFER(time) JIFFER(time)
402 #else
403 #define XJIFFER(time)
404 #endif
405
406
407
408
409
410
411
412
413 int
414 arcnet_probe(struct device *dev)
415 {
416 #ifndef MODULE
417
418
419
420 int *port, ports[] = {
421 0x300,0x2E0,0x2F0,0x2D0,
422
423 0x200,0x210,0x220,0x230,0x240,0x250,0x260,0x270,
424 0x280,0x290,0x2a0,0x2b0,0x2c0,
425 0x310,0x320,0x330,0x340,0x350,0x360,0x370,
426 0x380,0x390,0x3a0,0x3e0,0x3f0,
427
428 0};
429
430
431 unsigned long *addr, addrs[] = {0xD0000,0xE0000,0xA0000,0xB0000,
432 0xC0000,0xF0000,
433
434 0xE1000,
435 0xDD000,0xDC000,
436 0xD9000,0xD8000,0xD5000,0xD4000,0xD1000,
437 0xCD000,0xCC000,
438 0xC9000,0xC8000,0xC5000,0xC4000,
439
440 0};
441 int base_addr=dev->base_addr, status=0;
442 #endif
443 int delayval;
444 struct arcnet_local *lp;
445
446 if (net_debug)
447 {
448 printk(version);
449 printk("arcnet: ***\n");
450 printk("arcnet: * Read linux/drivers/net/README.arcnet for important release notes!\n");
451 printk("arcnet: *\n");
452 printk("arcnet: * This version should be stable, but e-mail me if you have any\n");
453 printk("arcnet: * questions, comments, or bug reports!\n");
454 printk("arcnet: ***\n");
455 }
456
457 BUGLVL(D_INIT)
458 printk("arcnet: given: base %lXh, IRQ %Xh, shmem %lXh\n",
459 dev->base_addr,dev->irq,dev->mem_start);
460
461 #ifndef MODULE
462 if (base_addr > 0x1ff)
463 status=arcnet_ioprobe(dev, base_addr);
464 else if (base_addr > 0)
465 return ENXIO;
466 else for (port = &ports[0]; *port; port++)
467 {
468 int ioaddr = *port;
469 if (check_region(ioaddr, ETHERCARD_TOTAL_SIZE))
470 {
471 BUGLVL(D_INIT)
472 printk("arcnet: Skipping %Xh because of check_region...\n",
473 ioaddr);
474 continue;
475 }
476
477 status=arcnet_ioprobe(dev, ioaddr);
478 if (!status) break;
479 }
480
481 if (status) return status;
482
483
484
485
486 BUGLVL(D_INIT)
487 printk("arcnet: ioprobe okay! Waiting for reset...\n");
488 JIFFER(100);
489
490
491 BUGLVL(D_INIT)
492 printk("arcnet: starting memory probe, given %lXh\n",
493 dev->mem_start);
494 if (dev->mem_start)
495 {
496 status=arcnet_memprobe(dev,(u_char *)dev->mem_start);
497 if (status) return status;
498 }
499 else
500 {
501 for (addr = &addrs[0]; *addr; addr++) {
502 status=arcnet_memprobe(dev,(u_char *)(*addr));
503 if (!status) break;
504 }
505
506 if (status) return status;
507 }
508 #else
509 if (!dev->base_addr || !dev->irq || !dev->mem_start
510 || !dev->rmem_start)
511 {
512 printk("arcnet: loadable modules can't autoprobe!\n");
513 printk("arcnet: try using io=, irqnum=, and shmem= on the insmod line.\n");
514 printk("arcnet: you may also need num= to change the device name. (ie. num=1 for arc1)\n");
515 return ENODEV;
516 }
517 #endif
518
519 {
520 int irqval = request_irq(dev->irq, &arcnet_interrupt, 0,
521 "arcnet");
522 if (irqval) {
523 printk("%s: unable to get IRQ %d (irqval=%d).\n",
524 dev->name,dev->irq, irqval);
525 return EAGAIN;
526 }
527 }
528
529
530 request_region(dev->base_addr, ETHERCARD_TOTAL_SIZE,"arcnet");
531
532 printk("%s: ARCnet card found at %03lXh, IRQ %d, ShMem at %lXh.\n",
533 dev->name, dev->base_addr, dev->irq, dev->mem_start);
534
535
536 dev->priv = kmalloc(sizeof(struct arcnet_local), GFP_KERNEL);
537 memset(dev->priv, 0, sizeof(struct arcnet_local));
538 lp=(struct arcnet_local *)(dev->priv);
539
540 dev->open = arcnet_open;
541 dev->stop = arcnet_close;
542 dev->hard_start_xmit = arcnet_send_packet;
543 dev->get_stats = arcnet_get_stats;
544 #ifdef HAVE_MULTICAST
545 dev->set_multicast_list = &set_multicast_list;
546 #endif
547
548
549 ether_setup(dev);
550
551
552
553 dev->type=ARPHRD_ARCNET;
554 dev->hard_header_len=sizeof(struct ClientData);
555 BUGLVL(D_EXTRA)
556 printk("arcnet: ClientData header size is %d.\narcnet: HardHeader size is %d.\n",
557 sizeof(struct ClientData),sizeof(struct HardHeader));
558 #if LIMIT_MTU
559 dev->mtu=512-sizeof(struct HardHeader)+EXTRA_CLIENTDATA;
560 #endif
561
562
563
564 dev->addr_len=1;
565 dev->broadcast[0]=0x00;
566
567 BUGLVL(D_INIT) printk("arcnet: arcnet_probe: resetting card.\n");
568 arcnet_reset(dev);
569 JIFFER(50);
570 BUGLVL(D_NORMAL)
571 printk("arcnet: We appear to be station %d (%02Xh)\n",
572 lp->arcnum,lp->arcnum);
573 if (lp->arcnum==0)
574 printk("arcnet: WARNING! Station address 0 is reserved for broadcasts!\n");
575 if (lp->arcnum==255)
576 printk("arcnet: WARNING! Station address 255 may confuse DOS networking programs!\n");
577 dev->dev_addr[0]=lp->arcnum;
578 lp->sequence=1;
579 lp->recbuf=0;
580
581 dev->hard_header = arc_header;
582 dev->rebuild_header = arc_rebuild_header;
583
584 return 0;
585 }
586
587 #ifndef MODULE
588
589 int arcnet_ioprobe(struct device *dev, short ioaddr)
590 {
591 int delayval,airq;
592
593 BUGLVL(D_INIT)
594 printk("arcnet: probing address %Xh\n",ioaddr);
595
596 BUGLVL(D_INIT)
597 printk("arcnet: status1=%Xh\n",inb(STATUS));
598
599
600
601
602
603
604
605
606 inb(RESET);
607 JIFFER(RESETtime);
608
609
610 if (inb(STATUS)==0xFF)
611 {
612 BUGLVL(D_INIT)
613 printk("arcnet: probe failed. Status port empty.\n");
614 return ENODEV;
615 }
616
617
618
619
620
621
622 {
623 int initval,curval;
624
625 curval=initval=inb(COMMAND);
626 delayval=jiffies+5;
627 while (delayval>=jiffies && curval==initval)
628 curval=inb(COMMAND);
629
630 if (curval==initval)
631 {
632 printk("arcnet: probe failed. never-changing command port (%02Xh).\n",
633 initval);
634 return ENODEV;
635 }
636 }
637
638 BUGLVL(D_INIT)
639 printk("arcnet: status2=%Xh\n",inb(STATUS));
640
641
642 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
643 XJIFFER(ACKtime);
644 if (inb(STATUS) & RESETflag)
645 {
646 BUGLVL(D_INIT)
647 printk("arcnet: probe failed. eternal reset flag1...(status=%Xh)\n",
648 inb(STATUS));
649 return ENODEV;
650 }
651
652
653 autoirq_setup(0);
654
655
656 outb(RESETflag,INTMASK);
657
658
659 inb(RESET);
660 JIFFER(RESETtime);
661
662 BUGLVL(D_INIT)
663 printk("arcnet: status3=%Xh\n",inb(STATUS));
664
665
666 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
667 XJIFFER(ACKtime);
668
669 BUGLVL(D_INIT)
670 printk("arcnet: status4=%Xh\n",inb(STATUS));
671
672
673 outb(RESETflag,INTMASK);
674
675
676 inb(RESET);
677 JIFFER(RESETtime);
678
679 BUGLVL(D_INIT)
680 printk("arcnet: status5=%Xh\n",inb(STATUS));
681
682
683
684
685
686
687
688
689 #ifdef DANGER_PROBE
690 outb(NORXflag,INTMASK);
691 JIFFER(RESETtime);
692 outb(0,INTMASK);
693 #endif
694
695
696 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
697 XJIFFER(ACKtime);
698
699 airq = autoirq_report(0);
700 if (net_debug>=D_INIT && airq)
701 printk("arcnet: autoirq is %d\n", airq);
702
703
704
705
706 if (!airq && !(dev->base_addr && dev->irq))
707 {
708 BUGLVL(D_INIT)
709 printk("arcnet: probe failed. no autoirq...\n");
710 return ENODEV;
711 }
712
713
714
715 if (inb(STATUS) & RESETflag)
716 {
717
718 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
719 XJIFFER(ACKtime);
720 }
721
722 if (inb(STATUS) & RESETflag)
723 {
724 BUGLVL(D_INIT)
725 printk("arcnet: probe failed. eternal reset flag...(status=%Xh)\n",
726 inb(STATUS));
727 return ENODEV;
728 }
729
730
731 if (!dev->base_addr) dev->base_addr=ioaddr;
732
733 if (dev->irq < 2)
734 {
735
736 dev->irq=airq;
737 }
738 else if (dev->irq == 2)
739 {
740 if (net_debug)
741 printk("arcnet: IRQ2 == IRQ9, don't worry.\n");
742 dev->irq = 9;
743 }
744
745 BUGLVL(D_INIT)
746 printk("arcnet: irq and base address seem okay. (%lXh, IRQ %d)\n",
747 dev->base_addr,dev->irq);
748 return 0;
749 }
750
751
752
753
754
755
756 int arcnet_memprobe(struct device *dev,u_char *addr)
757 {
758 BUGLVL(D_INIT)
759 printk("arcnet: probing memory at %lXh\n",(u_long)addr);
760
761 dev->mem_start=0;
762
763 #ifdef STRICT_MEM_DETECT
764
765 if (addr[0]!=TESTvalue)
766 {
767 BUGLVL(D_INIT)
768 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not %Xh)\n",
769 (unsigned long)addr,addr[0],TESTvalue);
770 return ENODEV;
771 }
772
773
774 addr[0]=0x42;
775 if (addr[0]!=0x42)
776 {
777 BUGLVL(D_INIT)
778 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not 42h)\n",
779 (unsigned long)addr,addr[0]);
780 return ENODEV;
781 }
782 #else
783 if (addr[0]!=TESTvalue)
784 {
785 BUGLVL(D_INIT)
786 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not %Xh)\n",
787 (unsigned long)addr,addr[0],TESTvalue);
788 return ENODEV;
789 }
790 #endif
791
792
793 dev->mem_start=(unsigned long)addr;
794 dev->mem_end=dev->mem_start+512*4-1;
795 dev->rmem_start=dev->mem_start+512*0;
796 dev->rmem_end=dev->mem_start+512*2-1;
797
798 return 0;
799 }
800
801 #endif
802
803
804
805
806
807
808
809
810
811 static int
812 arcnet_open(struct device *dev)
813 {
814 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
815
816
817 if (dev->metric>=10)
818 {
819 net_debug=dev->metric-10;
820 dev->metric=1;
821 }
822
823 if (net_debug) printk(version);
824
825 #if 0
826
827
828 if (request_irq(dev->irq, &arcnet_interrupt, 0, "arcnet")) {
829 return -EAGAIN;
830 }
831 #endif
832
833 irq2dev_map[dev->irq] = dev;
834
835
836 BUGLVL(D_EXTRA) printk("arcnet: arcnet_open: resetting card.\n");
837
838
839 if (arcnet_reset(dev) && arcnet_reset(dev))
840 return -ENODEV;
841
842
843
844
845
846
847 dev->tbusy=0;
848 dev->interrupt=0;
849 dev->start=1;
850 lp->intx=0;
851 lp->in_txhandler=0;
852
853 #ifdef USE_TIMER_HANDLER
854
855 init_timer(&lp->timer);
856 lp->timer.expires = TIMERval;
857 lp->timer.data = (unsigned long)dev;
858 lp->timer.function = &arcnet_timer;
859 add_timer(&lp->timer);
860 #endif
861
862 #ifdef MODULE
863 MOD_INC_USE_COUNT;
864 #endif
865
866 return 0;
867 }
868
869
870
871 static int
872 arcnet_close(struct device *dev)
873 {
874 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
875 int ioaddr = dev->base_addr;
876 #ifdef EXTRA_DELAYS
877 int delayval;
878 #endif
879
880
881
882 dev->tbusy = 1;
883 dev->start = 0;
884
885
886 del_timer(&lp->timer);
887
888
889
890
891
892 outb(0,INTMASK);
893 outb(NOTXcmd,COMMAND);
894 XJIFFER(ACKtime);
895 outb(NORXcmd,COMMAND);
896
897
898
899 #ifdef MODULE
900 MOD_DEC_USE_COUNT;
901 #endif
902
903 return 0;
904 }
905
906
907 static int
908 arcnet_send_packet(struct sk_buff *skb, struct device *dev)
909 {
910 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
911 int ioaddr=dev->base_addr;
912
913
914 lp->intx++;
915
916 BUGLVL(D_DURING)
917 printk("arcnet: transmit requested (status=%Xh, inTX=%d)\n",
918 inb(STATUS),lp->intx);
919
920 if (dev->tbusy || lp->in_txhandler)
921 {
922
923
924 int tickssofar = jiffies - dev->trans_start;
925 int recbuf=lp->recbuf;
926 int status=inb(STATUS);
927
928
929 #if 0
930 if (lp->txready && (inb(STATUS)&TXFREEflag))
931 {
932 printk("arcnet: kickme: starting a TX (status=%Xh)\n",
933 inb(STATUS));
934 arcnet_go_tx(dev);
935 lp->intx--;
936 return 1;
937 }
938 #endif
939
940 if (tickssofar < 5)
941 {
942 BUGLVL(D_DURING)
943 printk("arcnet: premature kickme! (status=%Xh ticks=%d o.skb=%ph numsegs=%d segnum=%d\n",
944 status,tickssofar,lp->outgoing.skb,
945 lp->outgoing.numsegs,
946 lp->outgoing.segnum);
947 lp->intx--;
948 return 1;
949 }
950
951 BUGLVL(D_INIT)
952 printk("arcnet: transmit timed out (status=%Xh, inTX=%d, tickssofar=%d)\n",
953 status,lp->intx,tickssofar);
954
955
956
957
958 if (status&NORXflag) EnableReceiver();
959 if (!(status&TXFREEflag)) outb(NOTXcmd,COMMAND);
960 dev->trans_start = jiffies;
961
962 if (lp->outgoing.skb)
963 dev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
964 lp->outgoing.skb=NULL;
965
966 dev->tbusy=0;
967 mark_bh(NET_BH);
968 lp->intx=0;
969 lp->in_txhandler=0;
970 lp->txready=0;
971 lp->sending=0;
972
973 return 1;
974 }
975
976
977
978
979 if (skb == NULL) {
980 BUGLVL(D_INIT)
981 printk("arcnet: tx passed null skb (status=%Xh, inTX=%d, tickssofar=%ld)\n",
982 inb(STATUS),lp->intx,jiffies-dev->trans_start);
983 dev_tint(dev);
984 lp->intx--;
985 return 0;
986 }
987
988 if (lp->txready)
989 {
990 printk("arcnet: trying to start new packet while busy!\n");
991 printk("arcnet: marking as not ready.\n");
992 lp->txready=0;
993 return 1;
994 }
995
996
997
998 if (set_bit(0, (void*)&dev->tbusy) != 0)
999 {
1000 printk("arcnet: transmitter called with busy bit set! (status=%Xh, inTX=%d, tickssofar=%ld)\n",
1001 inb(STATUS),lp->intx,jiffies-dev->trans_start);
1002 lp->intx--;
1003 return -EBUSY;
1004 }
1005 else {
1006 struct Outgoing *out=&(lp->outgoing);
1007 out->length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1008 out->hdr=(struct ClientData*)skb->data;
1009 out->skb=skb;
1010 BUGLVL( D_DATA ) {
1011 short i;
1012 for( i=0; i< skb->len; i++)
1013 {
1014 if( i%16 == 0 ) printk("\n[%04hX] ",i);
1015 printk("%02hX ",((unsigned char*)skb->data)[i]);
1016 }
1017 printk("\n");
1018 }
1019
1020 #ifdef IRQ_XMIT
1021 if (lp->txready && inb(STATUS)&TXFREEflag)
1022 arcnet_go_tx(dev);
1023 #endif
1024
1025
1026 if (out->length<=XMTU)
1027 {
1028 BUGLVL(D_TX) printk("arcnet: not splitting %d-byte packet. (split_flag=%d)\n",
1029 out->length,out->hdr->split_flag);
1030 BUGLVL(D_INIT) if (out->hdr->split_flag)
1031 printk("arcnet: short packet has split_flag set?! (split_flag=%d)\n",
1032 out->hdr->split_flag);
1033 out->numsegs=1;
1034 out->segnum=1;
1035 arcnet_prepare_tx(dev,out->hdr,
1036 out->length-sizeof(struct ClientData),
1037 ((char *)skb->data)+sizeof(struct ClientData));
1038 careful_xmit_wait(dev);
1039
1040
1041 dev_kfree_skb(out->skb,FREE_WRITE);
1042 out->skb=NULL;
1043
1044 if (!lp->sending)
1045 {
1046 arcnet_go_tx(dev);
1047
1048
1049 dev->tbusy=0;
1050 mark_bh(NET_BH);
1051 }
1052 }
1053 else
1054 {
1055 int maxsegsize=XMTU-sizeof(struct ClientData);
1056
1057 out->data=(u_char *)skb->data
1058 + sizeof(struct ClientData);
1059 out->dataleft=out->length-sizeof(struct ClientData);
1060 out->numsegs=(out->dataleft+maxsegsize-1)/maxsegsize;
1061
1062 out->segnum=0;
1063
1064 BUGLVL(D_TX) printk("arcnet: packet (%d bytes) split into %d fragments:\n",
1065 out->length,out->numsegs);
1066
1067 #ifdef IRQ_XMIT
1068
1069 if (lp->txready && inb(STATUS)&TXFREEflag)
1070 arcnet_go_tx(dev);
1071
1072 if (!lp->txready)
1073 {
1074
1075
1076
1077 arcnet_continue_tx(dev);
1078 if (!lp->sending)
1079 {
1080 arcnet_go_tx(dev);
1081 arcnet_continue_tx(dev);
1082 if (!lp->sending)
1083 arcnet_go_tx(dev);
1084 }
1085 }
1086
1087
1088
1089
1090 if (out->segnum==out->numsegs)
1091 {
1092
1093 out->segnum++;
1094 if (out->skb)
1095 dev_kfree_skb(out->skb,FREE_WRITE);
1096 out->skb=NULL;
1097 #if 0
1098
1099 dev->tbusy=0;
1100 mark_bh(NET_BH);
1101 #endif
1102 }
1103
1104 #else
1105 while (out->segnum<out->numsegs)
1106 {
1107 arcnet_continue_tx(dev);
1108 careful_xmit_wait(dev);
1109 arcnet_go_tx(dev);
1110 dev->trans_start=jiffies;
1111 }
1112
1113 dev_kfree_skb(out->skb,FREE_WRITE);
1114 out->skb=NULL;
1115
1116
1117 dev->tbusy = 0;
1118 mark_bh(NET_BH);
1119 #endif
1120 }
1121 }
1122
1123 lp->intx--;
1124 lp->stats.tx_packets++;
1125 dev->trans_start=jiffies;
1126 return 0;
1127 }
1128
1129 static void arcnet_continue_tx(struct device *dev)
1130 {
1131 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1132 int maxsegsize=XMTU-sizeof(struct ClientData);
1133 struct Outgoing *out=&(lp->outgoing);
1134
1135 if (lp->txready)
1136 {
1137 printk("arcnet: continue_tx: called with packet in buffer!\n");
1138 return;
1139 }
1140
1141 if (out->segnum>=out->numsegs)
1142 {
1143 printk("arcnet: continue_tx: building segment %d of %d!\n",
1144 out->segnum+1,out->numsegs);
1145 }
1146
1147 if (!out->segnum)
1148 out->hdr->split_flag=((out->numsegs-2)<<1)+1;
1149 else
1150 out->hdr->split_flag=out->segnum<<1;
1151
1152 out->seglen=maxsegsize;
1153 if (out->seglen>out->dataleft) out->seglen=out->dataleft;
1154
1155 BUGLVL(D_TX) printk("arcnet: building packet #%d (%d bytes) of %d (%d total), splitflag=%d\n",
1156 out->segnum+1,out->seglen,out->numsegs,
1157 out->length,out->hdr->split_flag);
1158
1159 arcnet_prepare_tx(dev,out->hdr,out->seglen,out->data);
1160
1161 out->dataleft-=out->seglen;
1162 out->data+=out->seglen;
1163 out->segnum++;
1164 }
1165
1166 #ifdef CAREFUL_XMIT
1167 static void careful_xmit_wait(struct device *dev)
1168 {
1169 int ioaddr=dev->base_addr;
1170 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1171
1172
1173 while ( !(inb(STATUS)&TXFREEflag) )
1174 {
1175 if (jiffies-dev->trans_start > 20 || !dev->tbusy)
1176 {
1177 BUGLVL(D_INIT)
1178 printk("arcnet: CAREFUL_XMIT timeout. (busy=%d, status=%Xh)\n",
1179 dev->tbusy,inb(STATUS));
1180 lp->stats.tx_errors++;
1181
1182 outb(NOTXcmd,COMMAND);
1183 return;
1184 }
1185 }
1186 BUGLVL(D_TX) printk("arcnet: transmit completed successfully. (status=%Xh)\n",
1187 inb(STATUS));
1188 }
1189 #endif
1190
1191 static void
1192 arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,short length,
1193 char *data)
1194 {
1195
1196 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1197 struct ClientData *arcsoft;
1198 union ArcPacket *arcpacket =
1199 (union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
1200 u_char pkttype;
1201 int offset;
1202 short daddr;
1203
1204 lp->txbuf=lp->txbuf^1;
1205
1206 length+=sizeof(struct ClientData);
1207
1208 BUGLVL(D_TX)
1209 printk("arcnet: arcnet_prep_tx: hdr:%ph, length:%d, data:%ph\n",
1210 hdr,length,data);
1211
1212
1213 BUGLVL(D_DURING)
1214 memset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
1215
1216 daddr=arcpacket->hardheader.destination=hdr->daddr;
1217
1218
1219 if (length<=MTU)
1220 {
1221 pkttype=NORMAL;
1222
1223 arcpacket->hardheader.offset1=offset=256-length
1224 + EXTRA_CLIENTDATA;
1225 arcsoft=(struct ClientData *)
1226 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1227 }
1228 else if (length>=MinTU)
1229 {
1230 pkttype=EXTENDED;
1231
1232 arcpacket->hardheader.offset1=0;
1233 arcpacket->hardheader.offset2=offset=512-length
1234 + EXTRA_CLIENTDATA;
1235 arcsoft=(struct ClientData *)
1236 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1237 }
1238 else
1239 {
1240 pkttype=EXCEPTION;
1241
1242 arcpacket->hardheader.offset1=0;
1243 arcpacket->hardheader.offset2=offset=512-length-4
1244 + EXTRA_CLIENTDATA;
1245 arcsoft=(struct ClientData *)
1246 (&arcpacket->raw[offset+4-EXTRA_CLIENTDATA]);
1247
1248
1249
1250
1251
1252 arcpacket->raw[offset+0]=arcsoft->protocol_id;
1253 arcpacket->raw[offset+1]=0xFF;
1254 arcpacket->raw[offset+2]=0xFF;
1255 arcpacket->raw[offset+3]=0xFF;
1256 }
1257
1258
1259
1260
1261
1262 memcpy((u_char*)arcsoft+EXTRA_CLIENTDATA,
1263 (u_char*)hdr+EXTRA_CLIENTDATA,
1264 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1265 memcpy((u_char*)arcsoft+sizeof(struct ClientData),
1266 data,
1267 length-sizeof(struct ClientData));
1268
1269 BUGLVL(D_DURING) printk("arcnet: transmitting packet to station %02Xh (%d bytes, type=%d)\n",
1270 daddr,length,pkttype);
1271
1272 BUGLVL(D_TX)
1273 {
1274 int countx,county;
1275
1276 printk("arcnet: packet dump [tx] follows:");
1277
1278 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1279 {
1280 printk("\n[%04X] ",county*16);
1281 for (countx=0; countx<16; countx++)
1282 printk("%02X ",
1283 arcpacket->raw[county*16+countx]);
1284 }
1285
1286 printk("\n");
1287 }
1288 #ifdef CAREFUL_XMIT
1289 #if 0
1290 careful_xmit_wait(dev);
1291
1292
1293
1294
1295
1296 if (daddr && !(inb(STATUS)&TXACKflag))
1297 {
1298 BUGLVL(D_INIT)
1299 printk("arcnet: transmit not acknowledged. (status=%Xh, daddr=%02Xh)\n",
1300 inb(STATUS),daddr);
1301 lp->stats.tx_errors++;
1302 return -ENONET;
1303 }
1304 #endif
1305 #endif
1306 lp->txready=lp->txbuf;
1307
1308 #if 0
1309 #ifdef IRQ_XMIT
1310 if (inb(STATUS)&TXFREEflag) arcnet_go_tx(dev);
1311 #endif
1312 #endif
1313 }
1314
1315 static void
1316 arcnet_go_tx(struct device *dev)
1317 {
1318 struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1319 int ioaddr=dev->base_addr;
1320
1321 BUGLVL(D_DURING)
1322 printk("arcnet: go_tx: status=%Xh\n",
1323 inb(STATUS));
1324
1325 if (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
1326
1327
1328 outb(TXcmd|(lp->txready<<3),COMMAND);
1329
1330 #ifdef IRQ_XMIT
1331 outb(TXFREEflag|NORXflag,INTMASK);
1332 #endif
1333
1334 dev->trans_start = jiffies;
1335 lp->txready=0;
1336 lp->sending++;
1337 }
1338
1339
1340
1341
1342 static void
1343 arcnet_interrupt(int irq,struct pt_regs *regs)
1344 {
1345 struct device *dev = (struct device *)(irq2dev_map[irq]);
1346
1347 if (dev == NULL) {
1348 if (net_debug >= D_DURING)
1349 printk("arcnet: irq %d for unknown device.\n", irq);
1350 return;
1351 }
1352
1353 arcnet_inthandler(dev);
1354 }
1355
1356 static void
1357 arcnet_inthandler(struct device *dev)
1358 {
1359 struct arcnet_local *lp;
1360 int ioaddr, status, boguscount = 3, didsomething;
1361
1362 dev->interrupt = 1;
1363 sti();
1364
1365 ioaddr = dev->base_addr;
1366 lp = (struct arcnet_local *)dev->priv;
1367
1368 #ifdef IRQ_XMIT
1369 outb(0,INTMASK);
1370 #endif
1371
1372 BUGLVL(D_DURING)
1373 printk("arcnet: in net_interrupt (status=%Xh)\n",inb(STATUS));
1374
1375 do
1376 {
1377 status = inb(STATUS);
1378 didsomething=0;
1379
1380 if (!dev->start)
1381 {
1382 BUGLVL(D_EXTRA)
1383 printk("arcnet: ARCnet not yet initialized. irq ignored. (status=%Xh)\n",
1384 status);
1385 #ifdef IRQ_XMIT
1386 if (!(status&NORXflag))
1387 outb(NORXflag,INTMASK);
1388 #endif
1389 dev->interrupt=0;
1390 return;
1391 }
1392
1393
1394
1395
1396 if (status & RESETflag)
1397 {
1398 BUGLVL(D_INIT)
1399 printk("arcnet: reset irq (status=%Xh)\n",
1400 status);
1401 dev->interrupt=0;
1402 return;
1403 }
1404
1405 #if 1
1406
1407 if (status & NORXflag)
1408 {
1409 int recbuf=lp->recbuf=!lp->recbuf;
1410
1411 BUGLVL(D_DURING)
1412 printk("arcnet: receive irq (status=%Xh)\n",
1413 status);
1414
1415
1416 EnableReceiver();
1417
1418
1419 arcnet_rx(dev,!recbuf);
1420
1421 didsomething++;
1422 }
1423 #endif
1424 #ifdef IRQ_XMIT
1425
1426 if (status&TXFREEflag && !lp->in_txhandler && lp->sending)
1427 {
1428 struct Outgoing *out=&(lp->outgoing);
1429
1430 lp->in_txhandler++;
1431 lp->sending--;
1432
1433 BUGLVL(D_DURING)
1434 printk("arcnet: TX IRQ (stat=%Xh, numsegs=%d, segnum=%d, skb=%ph)\n",
1435 status,out->numsegs,out->segnum,out->skb);
1436
1437
1438 if (lp->txready)
1439 {
1440 arcnet_go_tx(dev);
1441 didsomething++;
1442 }
1443
1444 if (lp->intx)
1445 {
1446 lp->in_txhandler--;
1447 continue;
1448 }
1449
1450 if (!lp->outgoing.skb)
1451 {
1452 BUGLVL(D_DURING)
1453 printk("arcnet: TX IRQ done: no split to continue.\n");
1454
1455
1456 if (!lp->txready && dev->tbusy)
1457 {
1458 dev->tbusy=0;
1459 mark_bh(NET_BH);
1460 }
1461
1462 lp->in_txhandler--;
1463 continue;
1464 }
1465
1466
1467
1468
1469
1470
1471 if (out->segnum<out->numsegs)
1472 arcnet_continue_tx(dev);
1473 if (lp->txready && !lp->sending)
1474 arcnet_go_tx(dev);
1475
1476
1477
1478
1479 if (out->segnum>=out->numsegs)
1480 {
1481
1482 out->segnum++;
1483 if (out->skb)
1484 dev_kfree_skb(out->skb,FREE_WRITE);
1485 out->skb=NULL;
1486
1487
1488 if (!lp->txready && dev->tbusy)
1489 {
1490 dev->tbusy=0;
1491 mark_bh(NET_BH);
1492 }
1493 }
1494 didsomething++;
1495
1496 lp->in_txhandler--;
1497 }
1498 #endif
1499 } while (--boguscount && didsomething);
1500
1501 BUGLVL(D_DURING)
1502 printk("arcnet: net_interrupt complete (status=%Xh)\n",
1503 inb(STATUS));
1504
1505 #ifdef IRQ_XMIT
1506 if (dev->start && lp->sending )
1507 outb(NORXflag|TXFREEflag,INTMASK);
1508 else
1509 outb(NORXflag,INTMASK);
1510 #endif
1511
1512 dev->interrupt=0;
1513 }
1514
1515
1516
1517 static void
1518 arcnet_rx(struct device *dev,int recbuf)
1519 {
1520 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1521 int ioaddr = dev->base_addr;
1522
1523
1524 struct sk_buff *skb;
1525
1526 union ArcPacket *arcpacket=
1527 (union ArcPacket *)(dev->mem_start+recbuf*512);
1528 struct ClientData *soft,*arcsoft;
1529 short length,offset;
1530 u_char pkttype,daddr,saddr;
1531
1532 daddr=arcpacket->hardheader.destination;
1533 saddr=arcpacket->hardheader.source;
1534
1535
1536 if (saddr==0)
1537 {
1538
1539 printk("arcnet: discarding old packet. (status=%Xh)\n",
1540 inb(STATUS));
1541 lp->stats.rx_errors++;
1542 return;
1543 }
1544 arcpacket->hardheader.source=0;
1545
1546 if (arcpacket->hardheader.offset1)
1547 {
1548 offset=arcpacket->hardheader.offset1;
1549 arcsoft=(struct ClientData *)
1550 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1551 length=256-offset+EXTRA_CLIENTDATA;
1552 pkttype=NORMAL;
1553 }
1554 else
1555 {
1556 offset=arcpacket->hardheader.offset2;
1557 arcsoft=(struct ClientData *)
1558 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1559
1560 if (arcsoft->split_flag!=0xFF)
1561 {
1562 length=512-offset+EXTRA_CLIENTDATA;
1563 pkttype=EXTENDED;
1564 }
1565 else
1566 {
1567
1568 arcsoft=(struct ClientData *)
1569 ((u_char *)arcsoft + 4);
1570 length=512-offset+EXTRA_CLIENTDATA-4;
1571 pkttype=EXCEPTION;
1572 }
1573 }
1574
1575 if (!arcsoft->split_flag)
1576 {
1577 struct Incoming *in=&lp->incoming[saddr];
1578
1579 BUGLVL(D_RX) printk("arcnet: incoming is not split (splitflag=%d)\n",
1580 arcsoft->split_flag);
1581
1582 if (in->skb)
1583 {
1584 BUGLVL(D_INIT) printk("arcnet: aborting assembly (seq=%d) for unsplit packet (splitflag=%d, seq=%d)\n",
1585 in->sequence,arcsoft->split_flag,
1586 arcsoft->sequence);
1587 kfree_skb(in->skb,FREE_WRITE);
1588 in->skb=NULL;
1589 }
1590
1591 in->sequence=arcsoft->sequence;
1592
1593 skb = alloc_skb(length, GFP_ATOMIC);
1594 if (skb == NULL) {
1595 printk("%s: Memory squeeze, dropping packet.\n",
1596 dev->name);
1597 lp->stats.rx_dropped++;
1598 return;
1599 }
1600 soft=(struct ClientData *)skb->data;
1601
1602 skb->len = length;
1603 skb->dev = dev;
1604
1605 memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1606 (u_char *)arcsoft+EXTRA_CLIENTDATA,
1607 length-EXTRA_CLIENTDATA);
1608 soft->daddr=daddr;
1609 soft->saddr=saddr;
1610
1611 BUGLVL(D_DURING)
1612 printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1613 saddr,daddr,length,pkttype);
1614 BUGLVL(D_RX)
1615 {
1616 int countx,county;
1617
1618 printk("arcnet: packet dump [rx-unsplit] follows:");
1619
1620 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1621 {
1622 printk("\n[%04X] ",county*16);
1623 for (countx=0; countx<16; countx++)
1624 printk("%02X ",
1625 arcpacket->raw[county*16+countx]);
1626 }
1627
1628 printk("\n");
1629 }
1630
1631
1632
1633
1634
1635
1636 if (soft->protocol_id == ARC_P_ARP)
1637 {
1638 struct arphdr *arp=(struct arphdr *)
1639 ((char *)soft+sizeof(struct ClientData));
1640
1641
1642 if (arp->ar_hln==1 && arp->ar_pln==4)
1643 {
1644 char *cptr=(char *)(arp)+sizeof(struct arphdr);
1645
1646 if (!*cptr)
1647 {
1648 BUGLVL(D_DURING)
1649 printk("arcnet: ARP source address was 00h, set to %02Xh.\n",
1650 saddr);
1651 *cptr=saddr;
1652 }
1653 else BUGLVL(D_DURING)
1654 {
1655 printk("arcnet: ARP source address (%Xh) is fine.\n",
1656 *cptr);
1657 }
1658 }
1659 else
1660 {
1661 printk("arcnet: funny-shaped ARP packet. (%Xh, %Xh)\n",
1662 arp->ar_hln,arp->ar_pln);
1663 }
1664 }
1665 skb->protocol=arc_type_trans(skb,dev);
1666 netif_rx(skb);
1667 lp->stats.rx_packets++;
1668 }
1669 else
1670 {
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688 struct Incoming *in=&lp->incoming[saddr];
1689
1690 BUGLVL(D_RX) printk("arcnet: packet is split (splitflag=%d, seq=%d)\n",
1691 arcsoft->split_flag,in->sequence);
1692
1693 if (in->skb && in->sequence!=arcsoft->sequence)
1694 {
1695 BUGLVL(D_INIT) printk("arcnet: wrong seq number, aborting assembly (expected=%d, seq=%d, splitflag=%d)\n",
1696 in->sequence,arcsoft->sequence,
1697 arcsoft->split_flag);
1698 kfree_skb(in->skb,FREE_WRITE);
1699 in->skb=NULL;
1700 in->lastpacket=in->numpackets=0;
1701 }
1702
1703 if (arcsoft->split_flag & 1)
1704 {
1705 BUGLVL(D_RX) printk("arcnet: brand new splitpacket (splitflag=%d)\n",
1706 arcsoft->split_flag);
1707 if (in->skb)
1708 {
1709 BUGLVL(D_INIT) printk("arcnet: aborting previous (seq=%d) assembly (splitflag=%d, seq=%d)\n",
1710 in->sequence,arcsoft->split_flag,
1711 arcsoft->sequence);
1712 kfree_skb(in->skb,FREE_WRITE);
1713 }
1714
1715 in->sequence=arcsoft->sequence;
1716 in->numpackets=((unsigned)arcsoft->split_flag>>1)+2;
1717 in->lastpacket=1;
1718
1719 if (in->numpackets>16)
1720 {
1721 printk("arcnet: incoming packet more than 16 segments; dropping. (splitflag=%d)\n",
1722 arcsoft->split_flag);
1723 lp->stats.rx_dropped++;
1724 return;
1725 }
1726
1727 in->skb=skb=alloc_skb(508*in->numpackets
1728 + sizeof(struct ClientData),
1729 GFP_ATOMIC);
1730 if (skb == NULL) {
1731 printk("%s: (split) memory squeeze, dropping packet.\n",
1732 dev->name);
1733 lp->stats.rx_dropped++;
1734 return;
1735 }
1736
1737
1738
1739
1740 skb->free=1;
1741
1742 soft=(struct ClientData *)skb->data;
1743
1744 skb->len=sizeof(struct ClientData);
1745 skb->dev=dev;
1746
1747 memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1748 (u_char *)arcsoft+EXTRA_CLIENTDATA,
1749 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1750 soft->split_flag=0;
1751 }
1752 else
1753 {
1754 int packetnum=((unsigned)arcsoft->split_flag>>1) + 1;
1755
1756
1757
1758
1759 if (!in->skb)
1760 {
1761 BUGLVL(D_INIT) printk("arcnet: can't continue split without starting first! (splitflag=%d, seq=%d)\n",
1762 arcsoft->split_flag,arcsoft->sequence);
1763 return;
1764 }
1765
1766 in->lastpacket++;
1767 if (packetnum!=in->lastpacket)
1768 {
1769
1770 if (packetnum<=in->lastpacket-1)
1771 {
1772 BUGLVL(D_INIT) printk("arcnet: duplicate splitpacket ignored! (splitflag=%d)\n",
1773 arcsoft->split_flag);
1774 return;
1775 }
1776
1777
1778 BUGLVL(D_INIT) printk("arcnet: out-of-order splitpacket, reassembly (seq=%d) aborted (splitflag=%d, seq=%d)\n",
1779 in->sequence,arcsoft->split_flag,
1780 arcsoft->sequence);
1781 kfree_skb(in->skb,FREE_WRITE);
1782 in->skb=NULL;
1783 in->lastpacket=in->numpackets=0;
1784 return;
1785 }
1786
1787 soft=(struct ClientData *)in->skb->data;
1788 }
1789
1790 skb=in->skb;
1791
1792 memcpy(skb->data+skb->len,
1793 (u_char *)arcsoft+sizeof(struct ClientData),
1794 length-sizeof(struct ClientData));
1795
1796 skb->len+=length-sizeof(struct ClientData);
1797
1798 soft->daddr=daddr;
1799 soft->saddr=saddr;
1800
1801 BUGLVL(D_DURING)
1802 printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1803 saddr,daddr,length,pkttype);
1804 BUGLVL(D_RX)
1805 {
1806 int countx,county;
1807
1808 printk("arcnet: packet dump [rx-split] follows:");
1809
1810 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1811 {
1812 printk("\n[%04X] ",county*16);
1813 for (countx=0; countx<16; countx++)
1814 printk("%02X ",
1815 arcpacket->raw[county*16+countx]);
1816 }
1817
1818 printk("\n");
1819 }
1820
1821
1822 if (in->lastpacket == in->numpackets)
1823 {
1824 if (!skb || !in->skb)
1825 printk("arcnet: ?!? done reassembling packet, no skb? (skb=%ph, in->skb=%ph)\n",
1826 skb,in->skb);
1827 in->skb=NULL;
1828 in->lastpacket=in->numpackets=0;
1829 skb->protocol=arc_type_trans(skb,dev);
1830 netif_rx(skb);
1831 lp->stats.rx_packets++;
1832 }
1833 }
1834
1835
1836
1837
1838 }
1839
1840
1841 #ifdef USE_TIMER_HANDLER
1842
1843
1844
1845
1846
1847
1848
1849 static void
1850 arcnet_timer(unsigned long arg)
1851 {
1852 struct device *dev=(struct device *)arg;
1853 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1854 short ioaddr=dev->base_addr;
1855 int status=inb(STATUS);
1856
1857
1858
1859
1860 if (!dev->interrupt && dev->start
1861 && status&NORXflag && !status&RESETflag)
1862 {
1863 BUGLVL(D_INIT)
1864 printk("arcnet: timer: ARCnet was stuck! (status=%Xh)\n",
1865 status);
1866
1867 arcnet_inthandler(dev);
1868 }
1869
1870
1871 init_timer(&lp->timer);
1872 lp->timer.expires=TIMERval;
1873 add_timer(&lp->timer);
1874 }
1875 #endif
1876
1877
1878
1879 static struct enet_statistics *
1880 arcnet_get_stats(struct device *dev)
1881 {
1882 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1883
1884
1885 return &lp->stats;
1886 }
1887
1888
1889
1890
1891
1892
1893
1894 static void
1895 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
1896 {
1897 #if 0
1898 struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
1899
1900 short ioaddr = dev->base_addr;
1901 if (num_addrs) {
1902 outw(69, ioaddr);
1903 } else
1904 outw(99, ioaddr);
1905 #endif
1906 }
1907
1908 int arcnet_reset(struct device *dev)
1909 {
1910 struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1911 short ioaddr=dev->base_addr;
1912 int delayval,recbuf=lp->recbuf;
1913
1914 outb(0,INTMASK);
1915
1916 BUGLVL(D_INIT)
1917 printk("arcnet: Resetting %s (status=%Xh)\n",
1918 dev->name,inb(STATUS));
1919
1920 inb(RESET);
1921 JIFFER(RESETtime);
1922
1923 outb(CFLAGScmd|RESETclear, COMMAND);
1924 outb(CFLAGScmd|CONFIGclear,COMMAND);
1925
1926
1927
1928
1929 {
1930 u_char *cardmem = (u_char *) dev->mem_start;
1931 if (cardmem[0] != TESTvalue)
1932 {
1933 BUGLVL(D_INIT)
1934 printk("arcnet: reset failed: TESTvalue not present.\n");
1935 return 1;
1936 }
1937 lp->arcnum=cardmem[1];
1938 }
1939
1940
1941 recbuf=lp->recbuf=0;
1942 lp->txbuf=2;
1943
1944
1945
1946 outb(CONFIGcmd|EXTconf,COMMAND);
1947 XJIFFER(ACKtime);
1948
1949
1950 BUGLVL(D_DURING)
1951 memset((void *)dev->mem_start,0x42,2048);
1952
1953
1954 EnableReceiver();
1955
1956
1957 outb(NORXflag,INTMASK);
1958
1959
1960 return 0;
1961 }
1962
1963
1964
1965
1966
1967
1968
1969
1970 int arc_header(unsigned char *buff,struct device *dev,unsigned short type,
1971 void *daddr,void *saddr,unsigned len,struct sk_buff *skb)
1972 {
1973 struct ClientData *head = (struct ClientData *)buff;
1974 struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
1975
1976
1977 switch(type)
1978 {
1979 case ETH_P_IP:
1980 head->protocol_id=ARC_P_IP;
1981 break;
1982 case ETH_P_ARP:
1983 head->protocol_id=ARC_P_ARP;
1984 break;
1985 case ETH_P_RARP:
1986 head->protocol_id=ARC_P_RARP;
1987 break;
1988 case ETH_P_IPX:
1989 head->protocol_id=ARC_P_IPX;
1990 break;
1991 case ETH_P_ATALK:
1992 head->protocol_id=ARC_P_ATALK;
1993 break;
1994 default:
1995 printk("arcnet: I don't understand protocol %d (%Xh)\n",
1996 type,type);
1997 return 0;
1998 }
1999
2000 #if 1
2001
2002
2003
2004
2005
2006
2007 if(saddr)
2008 head->saddr=((u_char*)saddr)[0];
2009 else
2010 head->saddr=((u_char*)(dev->dev_addr))[0];
2011 #endif
2012
2013 #if 0
2014
2015
2016
2017
2018
2019
2020 if (dev->flags & IFF_LOOPBACK)
2021 {
2022 head->daddr=0;
2023 return(dev->hard_header_len);
2024 }
2025 #endif
2026
2027 head->split_flag=0;
2028 head->sequence=(lp->sequence++);
2029
2030
2031 if(daddr)
2032 {
2033 head->daddr=((u_char*)daddr)[0];
2034 return dev->hard_header_len;
2035 }
2036 else
2037 head->daddr=0;
2038
2039 return -dev->hard_header_len;
2040 }
2041
2042
2043
2044
2045
2046
2047
2048 int arc_rebuild_header(void *buff,struct device *dev,unsigned long dst,
2049 struct sk_buff *skb)
2050 {
2051 struct ClientData *head = (struct ClientData *)buff;
2052
2053
2054
2055
2056
2057 if(head->protocol_id != ARC_P_IP)
2058 {
2059 printk("arcnet: I don't understand resolve type %d (%Xh) addresses!\n",
2060 head->protocol_id,head->protocol_id);
2061 head->daddr=0;
2062
2063 return 0;
2064 }
2065
2066
2067
2068
2069 #ifdef CONFIG_INET
2070 return arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
2071 #else
2072 return 0;
2073 #endif
2074 }
2075
2076
2077
2078
2079
2080
2081 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
2082 {
2083 struct ClientData *head = (struct ClientData *) skb->data;
2084
2085 if (head->daddr==0)
2086 skb->pkt_type=PACKET_BROADCAST;
2087 else if(dev->flags&IFF_PROMISC)
2088 {
2089
2090 if (head->daddr != dev->dev_addr[0])
2091 skb->pkt_type=PACKET_OTHERHOST;
2092 }
2093
2094
2095 switch (head->protocol_id)
2096 {
2097 case ARC_P_IP: return htons(ETH_P_IP);
2098 case ARC_P_ARP: return htons(ETH_P_ARP);
2099 case ARC_P_RARP: return htons(ETH_P_RARP);
2100 case ARC_P_IPX: return htons(ETH_P_IPX);
2101 case ARC_P_ATALK: return htons(ETH_P_ATALK);
2102 case ARC_P_LANSOFT:
2103 default:
2104 BUGLVL(D_DURING)
2105 printk("arcnet: received packet of unknown protocol id %d (%Xh)\n",
2106 head->protocol_id,head->protocol_id);
2107 return 0;
2108 }
2109 return htons(ETH_P_IP);
2110 }
2111
2112 #ifdef MODULE
2113 char kernel_version[] = UTS_RELEASE;
2114 static struct device thisARCnet = {
2115 " ",
2116 0, 0, 0, 0,
2117 0, 0,
2118 0, 0, 0, NULL, arcnet_probe };
2119
2120
2121 int io=0x0;
2122 int irqnum=0;
2123 int shmem=0;
2124 int num=0;
2125
2126 int
2127 init_module(void)
2128 {
2129 sprintf(thisARCnet.name,"arc%d",num);
2130
2131 thisARCnet.base_addr=io;
2132
2133 thisARCnet.irq=irqnum;
2134 if (thisARCnet.irq==2) thisARCnet.irq=9;
2135
2136 if (shmem)
2137 {
2138 thisARCnet.mem_start=shmem;
2139 thisARCnet.mem_end=thisARCnet.mem_start+512*4-1;
2140 thisARCnet.rmem_start=thisARCnet.mem_start+512*0;
2141 thisARCnet.rmem_end=thisARCnet.mem_start+512*2-1;
2142 }
2143
2144 if (register_netdev(&thisARCnet) != 0)
2145 return -EIO;
2146 return 0;
2147 }
2148
2149 void
2150 cleanup_module(void)
2151 {
2152 if (MOD_IN_USE) {
2153 printk("%s: device busy, remove delayed\n",thisARCnet.name);
2154 } else {
2155 if (thisARCnet.start) arcnet_close(&thisARCnet);
2156 if (thisARCnet.irq) free_irq(thisARCnet.irq);
2157 if (thisARCnet.base_addr) release_region(thisARCnet.base_addr,
2158 ETHERCARD_TOTAL_SIZE);
2159 unregister_netdev(&thisARCnet);
2160 }
2161 }
2162
2163 #endif
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175