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