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 "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(unsigned char *buff,struct device *dev,unsigned short type,
387 void *daddr,void *saddr,unsigned len,struct sk_buff *skb);
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 dev->type_trans = arc_type_trans;
591
592 return 0;
593 }
594
595 #ifndef MODULE
596
597 int arcnet_ioprobe(struct device *dev, short ioaddr)
598 {
599 int delayval,airq;
600
601 BUGLVL(D_INIT)
602 printk("arcnet: probing address %Xh\n",ioaddr);
603
604 BUGLVL(D_INIT)
605 printk("arcnet: status1=%Xh\n",inb(STATUS));
606
607
608
609
610
611
612
613
614 inb(RESET);
615 JIFFER(RESETtime);
616
617
618 if (inb(STATUS)==0xFF)
619 {
620 BUGLVL(D_INIT)
621 printk("arcnet: probe failed. Status port empty.\n");
622 return ENODEV;
623 }
624
625
626
627
628
629
630 {
631 int initval,curval;
632
633 curval=initval=inb(COMMAND);
634 delayval=jiffies+5;
635 while (delayval>=jiffies && curval==initval)
636 curval=inb(COMMAND);
637
638 if (curval==initval)
639 {
640 printk("arcnet: probe failed. never-changing command port (%02Xh).\n",
641 initval);
642 return ENODEV;
643 }
644 }
645
646 BUGLVL(D_INIT)
647 printk("arcnet: status2=%Xh\n",inb(STATUS));
648
649
650 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
651 XJIFFER(ACKtime);
652 if (inb(STATUS) & RESETflag)
653 {
654 BUGLVL(D_INIT)
655 printk("arcnet: probe failed. eternal reset flag1...(status=%Xh)\n",
656 inb(STATUS));
657 return ENODEV;
658 }
659
660
661 autoirq_setup(0);
662
663
664 outb(RESETflag,INTMASK);
665
666
667 inb(RESET);
668 JIFFER(RESETtime);
669
670 BUGLVL(D_INIT)
671 printk("arcnet: status3=%Xh\n",inb(STATUS));
672
673
674 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
675 XJIFFER(ACKtime);
676
677 BUGLVL(D_INIT)
678 printk("arcnet: status4=%Xh\n",inb(STATUS));
679
680
681 outb(RESETflag,INTMASK);
682
683
684 inb(RESET);
685 JIFFER(RESETtime);
686
687 BUGLVL(D_INIT)
688 printk("arcnet: status5=%Xh\n",inb(STATUS));
689
690
691
692
693
694
695
696
697 #ifdef DANGER_PROBE
698 outb(NORXflag,INTMASK);
699 JIFFER(RESETtime);
700 outb(0,INTMASK);
701 #endif
702
703
704 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
705 XJIFFER(ACKtime);
706
707 airq = autoirq_report(0);
708 if (net_debug>=D_INIT && airq)
709 printk("arcnet: autoirq is %d\n", airq);
710
711
712
713
714 if (!airq && !(dev->base_addr && dev->irq))
715 {
716 BUGLVL(D_INIT)
717 printk("arcnet: probe failed. no autoirq...\n");
718 return ENODEV;
719 }
720
721
722
723 if (inb(STATUS) & RESETflag)
724 {
725
726 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
727 XJIFFER(ACKtime);
728 }
729
730 if (inb(STATUS) & RESETflag)
731 {
732 BUGLVL(D_INIT)
733 printk("arcnet: probe failed. eternal reset flag...(status=%Xh)\n",
734 inb(STATUS));
735 return ENODEV;
736 }
737
738
739 if (!dev->base_addr) dev->base_addr=ioaddr;
740
741 if (dev->irq < 2)
742 {
743
744 dev->irq=airq;
745 }
746 else if (dev->irq == 2)
747 {
748 if (net_debug)
749 printk("arcnet: IRQ2 == IRQ9, don't worry.\n");
750 dev->irq = 9;
751 }
752
753 BUGLVL(D_INIT)
754 printk("arcnet: irq and base address seem okay. (%lXh, IRQ %d)\n",
755 dev->base_addr,dev->irq);
756 return 0;
757 }
758
759
760
761
762
763
764 int arcnet_memprobe(struct device *dev,u_char *addr)
765 {
766 BUGLVL(D_INIT)
767 printk("arcnet: probing memory at %lXh\n",(u_long)addr);
768
769 dev->mem_start=0;
770
771 #ifdef STRICT_MEM_DETECT
772
773 if (addr[0]!=TESTvalue)
774 {
775 BUGLVL(D_INIT)
776 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not %Xh)\n",
777 (unsigned long)addr,addr[0],TESTvalue);
778 return ENODEV;
779 }
780
781
782 addr[0]=0x42;
783 if (addr[0]!=0x42)
784 {
785 BUGLVL(D_INIT)
786 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not 42h)\n",
787 (unsigned long)addr,addr[0]);
788 return ENODEV;
789 }
790 #else
791 if (addr[0]!=TESTvalue)
792 {
793 BUGLVL(D_INIT)
794 printk("arcnet: probe failed. addr=%lXh, addr[0]=%Xh (not %Xh)\n",
795 (unsigned long)addr,addr[0],TESTvalue);
796 return ENODEV;
797 }
798 #endif
799
800
801 dev->mem_start=(unsigned long)addr;
802 dev->mem_end=dev->mem_start+512*4-1;
803 dev->rmem_start=dev->mem_start+512*0;
804 dev->rmem_end=dev->mem_start+512*2-1;
805
806 return 0;
807 }
808
809 #endif
810
811
812
813
814
815
816
817
818
819 static int
820 arcnet_open(struct device *dev)
821 {
822 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
823
824
825 if (dev->metric>=10)
826 {
827 net_debug=dev->metric-10;
828 dev->metric=1;
829 }
830
831 if (net_debug) printk(version);
832
833 #if 0
834
835
836 if (request_irq(dev->irq, &arcnet_interrupt, 0, "arcnet")) {
837 return -EAGAIN;
838 }
839 #endif
840
841 irq2dev_map[dev->irq] = dev;
842
843
844 BUGLVL(D_EXTRA) printk("arcnet: arcnet_open: resetting card.\n");
845
846
847 if (arcnet_reset(dev) && arcnet_reset(dev))
848 return -ENODEV;
849
850
851
852
853
854
855 dev->tbusy=0;
856 dev->interrupt=0;
857 dev->start=1;
858 lp->intx=0;
859 lp->in_txhandler=0;
860
861 #ifdef USE_TIMER_HANDLER
862
863 init_timer(&lp->timer);
864 lp->timer.expires = TIMERval;
865 lp->timer.data = (unsigned long)dev;
866 lp->timer.function = &arcnet_timer;
867 add_timer(&lp->timer);
868 #endif
869
870 #ifdef MODULE
871 MOD_INC_USE_COUNT;
872 #endif
873
874 return 0;
875 }
876
877
878
879 static int
880 arcnet_close(struct device *dev)
881 {
882 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
883 int ioaddr = dev->base_addr;
884 #ifdef EXTRA_DELAYS
885 int delayval;
886 #endif
887
888
889
890 dev->tbusy = 1;
891 dev->start = 0;
892
893
894 del_timer(&lp->timer);
895
896
897
898
899
900 outb(0,INTMASK);
901 outb(NOTXcmd,COMMAND);
902 XJIFFER(ACKtime);
903 outb(NORXcmd,COMMAND);
904
905
906
907 #ifdef MODULE
908 MOD_DEC_USE_COUNT;
909 #endif
910
911 return 0;
912 }
913
914
915 static int
916 arcnet_send_packet(struct sk_buff *skb, struct device *dev)
917 {
918 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
919 int ioaddr=dev->base_addr;
920
921
922 lp->intx++;
923
924 BUGLVL(D_DURING)
925 printk("arcnet: transmit requested (status=%Xh, inTX=%d)\n",
926 inb(STATUS),lp->intx);
927
928 if (dev->tbusy || lp->in_txhandler)
929 {
930
931
932 int tickssofar = jiffies - dev->trans_start;
933 int recbuf=lp->recbuf;
934 int status=inb(STATUS);
935
936
937 #if 0
938 if (lp->txready && (inb(STATUS)&TXFREEflag))
939 {
940 printk("arcnet: kickme: starting a TX (status=%Xh)\n",
941 inb(STATUS));
942 arcnet_go_tx(dev);
943 lp->intx--;
944 return 1;
945 }
946 #endif
947
948 if (tickssofar < 5)
949 {
950 BUGLVL(D_DURING)
951 printk("arcnet: premature kickme! (status=%Xh ticks=%d o.skb=%ph numsegs=%d segnum=%d\n",
952 status,tickssofar,lp->outgoing.skb,
953 lp->outgoing.numsegs,
954 lp->outgoing.segnum);
955 lp->intx--;
956 return 1;
957 }
958
959 BUGLVL(D_INIT)
960 printk("arcnet: transmit timed out (status=%Xh, inTX=%d, tickssofar=%d)\n",
961 status,lp->intx,tickssofar);
962
963
964
965
966 if (status&NORXflag) EnableReceiver();
967 if (!(status&TXFREEflag)) outb(NOTXcmd,COMMAND);
968 dev->trans_start = jiffies;
969
970 if (lp->outgoing.skb)
971 dev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
972 lp->outgoing.skb=NULL;
973
974 dev->tbusy=0;
975 mark_bh(NET_BH);
976 lp->intx=0;
977 lp->in_txhandler=0;
978 lp->txready=0;
979 lp->sending=0;
980
981 return 1;
982 }
983
984
985
986
987 if (skb == NULL) {
988 BUGLVL(D_INIT)
989 printk("arcnet: tx passed null skb (status=%Xh, inTX=%d, tickssofar=%ld)\n",
990 inb(STATUS),lp->intx,jiffies-dev->trans_start);
991 dev_tint(dev);
992 lp->intx--;
993 return 0;
994 }
995
996 if (lp->txready)
997 {
998 printk("arcnet: trying to start new packet while busy!\n");
999 printk("arcnet: marking as not ready.\n");
1000 lp->txready=0;
1001 return 1;
1002 }
1003
1004
1005
1006 if (set_bit(0, (void*)&dev->tbusy) != 0)
1007 {
1008 printk("arcnet: transmitter called with busy bit set! (status=%Xh, inTX=%d, tickssofar=%ld)\n",
1009 inb(STATUS),lp->intx,jiffies-dev->trans_start);
1010 lp->intx--;
1011 return -EBUSY;
1012 }
1013 else {
1014 struct Outgoing *out=&(lp->outgoing);
1015 out->length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1016 out->hdr=(struct ClientData*)skb->data;
1017 out->skb=skb;
1018 BUGLVL( D_DATA ) {
1019 short i;
1020 for( i=0; i< skb->len; i++)
1021 {
1022 if( i%16 == 0 ) printk("\n[%04hX] ",i);
1023 printk("%02hX ",((unsigned char*)skb->data)[i]);
1024 }
1025 printk("\n");
1026 }
1027
1028 #ifdef IRQ_XMIT
1029 if (lp->txready && inb(STATUS)&TXFREEflag)
1030 arcnet_go_tx(dev);
1031 #endif
1032
1033
1034 if (out->length<=XMTU)
1035 {
1036 BUGLVL(D_TX) printk("arcnet: not splitting %d-byte packet. (split_flag=%d)\n",
1037 out->length,out->hdr->split_flag);
1038 BUGLVL(D_INIT) if (out->hdr->split_flag)
1039 printk("arcnet: short packet has split_flag set?! (split_flag=%d)\n",
1040 out->hdr->split_flag);
1041 out->numsegs=1;
1042 out->segnum=1;
1043 arcnet_prepare_tx(dev,out->hdr,
1044 out->length-sizeof(struct ClientData),
1045 ((char *)skb->data)+sizeof(struct ClientData));
1046 careful_xmit_wait(dev);
1047
1048
1049 dev_kfree_skb(out->skb,FREE_WRITE);
1050 out->skb=NULL;
1051
1052 if (!lp->sending)
1053 {
1054 arcnet_go_tx(dev);
1055
1056
1057 dev->tbusy=0;
1058 mark_bh(NET_BH);
1059 }
1060 }
1061 else
1062 {
1063 int maxsegsize=XMTU-sizeof(struct ClientData);
1064
1065 out->data=(u_char *)skb->data
1066 + sizeof(struct ClientData);
1067 out->dataleft=out->length-sizeof(struct ClientData);
1068 out->numsegs=(out->dataleft+maxsegsize-1)/maxsegsize;
1069
1070 out->segnum=0;
1071
1072 BUGLVL(D_TX) printk("arcnet: packet (%d bytes) split into %d fragments:\n",
1073 out->length,out->numsegs);
1074
1075 #ifdef IRQ_XMIT
1076
1077 if (lp->txready && inb(STATUS)&TXFREEflag)
1078 arcnet_go_tx(dev);
1079
1080 if (!lp->txready)
1081 {
1082
1083
1084
1085 arcnet_continue_tx(dev);
1086 if (!lp->sending)
1087 {
1088 arcnet_go_tx(dev);
1089 arcnet_continue_tx(dev);
1090 if (!lp->sending)
1091 arcnet_go_tx(dev);
1092 }
1093 }
1094
1095
1096
1097
1098 if (out->segnum==out->numsegs)
1099 {
1100
1101 out->segnum++;
1102 if (out->skb)
1103 dev_kfree_skb(out->skb,FREE_WRITE);
1104 out->skb=NULL;
1105 #if 0
1106
1107 dev->tbusy=0;
1108 mark_bh(NET_BH);
1109 #endif
1110 }
1111
1112 #else
1113 while (out->segnum<out->numsegs)
1114 {
1115 arcnet_continue_tx(dev);
1116 careful_xmit_wait(dev);
1117 arcnet_go_tx(dev);
1118 dev->trans_start=jiffies;
1119 }
1120
1121 dev_kfree_skb(out->skb,FREE_WRITE);
1122 out->skb=NULL;
1123
1124
1125 dev->tbusy = 0;
1126 mark_bh(NET_BH);
1127 #endif
1128 }
1129 }
1130
1131 lp->intx--;
1132 lp->stats.tx_packets++;
1133 dev->trans_start=jiffies;
1134 return 0;
1135 }
1136
1137 static void arcnet_continue_tx(struct device *dev)
1138 {
1139 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1140 int maxsegsize=XMTU-sizeof(struct ClientData);
1141 struct Outgoing *out=&(lp->outgoing);
1142
1143 if (lp->txready)
1144 {
1145 printk("arcnet: continue_tx: called with packet in buffer!\n");
1146 return;
1147 }
1148
1149 if (out->segnum>=out->numsegs)
1150 {
1151 printk("arcnet: continue_tx: building segment %d of %d!\n",
1152 out->segnum+1,out->numsegs);
1153 }
1154
1155 if (!out->segnum)
1156 out->hdr->split_flag=((out->numsegs-2)<<1)+1;
1157 else
1158 out->hdr->split_flag=out->segnum<<1;
1159
1160 out->seglen=maxsegsize;
1161 if (out->seglen>out->dataleft) out->seglen=out->dataleft;
1162
1163 BUGLVL(D_TX) printk("arcnet: building packet #%d (%d bytes) of %d (%d total), splitflag=%d\n",
1164 out->segnum+1,out->seglen,out->numsegs,
1165 out->length,out->hdr->split_flag);
1166
1167 arcnet_prepare_tx(dev,out->hdr,out->seglen,out->data);
1168
1169 out->dataleft-=out->seglen;
1170 out->data+=out->seglen;
1171 out->segnum++;
1172 }
1173
1174 #ifdef CAREFUL_XMIT
1175 static void careful_xmit_wait(struct device *dev)
1176 {
1177 int ioaddr=dev->base_addr;
1178 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1179
1180
1181 while ( !(inb(STATUS)&TXFREEflag) )
1182 {
1183 if (jiffies-dev->trans_start > 20 || !dev->tbusy)
1184 {
1185 BUGLVL(D_INIT)
1186 printk("arcnet: CAREFUL_XMIT timeout. (busy=%d, status=%Xh)\n",
1187 dev->tbusy,inb(STATUS));
1188 lp->stats.tx_errors++;
1189
1190 outb(NOTXcmd,COMMAND);
1191 return;
1192 }
1193 }
1194 BUGLVL(D_TX) printk("arcnet: transmit completed successfully. (status=%Xh)\n",
1195 inb(STATUS));
1196 }
1197 #endif
1198
1199 static void
1200 arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,short length,
1201 char *data)
1202 {
1203
1204 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1205 struct ClientData *arcsoft;
1206 union ArcPacket *arcpacket =
1207 (union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
1208 u_char pkttype;
1209 int offset;
1210 short daddr;
1211
1212 lp->txbuf=lp->txbuf^1;
1213
1214 length+=sizeof(struct ClientData);
1215
1216 BUGLVL(D_TX)
1217 printk("arcnet: arcnet_prep_tx: hdr:%ph, length:%d, data:%ph\n",
1218 hdr,length,data);
1219
1220
1221 BUGLVL(D_DURING)
1222 memset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
1223
1224 daddr=arcpacket->hardheader.destination=hdr->daddr;
1225
1226
1227 if (length<=MTU)
1228 {
1229 pkttype=NORMAL;
1230
1231 arcpacket->hardheader.offset1=offset=256-length
1232 + EXTRA_CLIENTDATA;
1233 arcsoft=(struct ClientData *)
1234 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1235 }
1236 else if (length>=MinTU)
1237 {
1238 pkttype=EXTENDED;
1239
1240 arcpacket->hardheader.offset1=0;
1241 arcpacket->hardheader.offset2=offset=512-length
1242 + EXTRA_CLIENTDATA;
1243 arcsoft=(struct ClientData *)
1244 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1245 }
1246 else
1247 {
1248 pkttype=EXCEPTION;
1249
1250 arcpacket->hardheader.offset1=0;
1251 arcpacket->hardheader.offset2=offset=512-length-4
1252 + EXTRA_CLIENTDATA;
1253 arcsoft=(struct ClientData *)
1254 (&arcpacket->raw[offset+4-EXTRA_CLIENTDATA]);
1255
1256
1257
1258
1259
1260 arcpacket->raw[offset+0]=hdr->protocol_id;
1261 arcpacket->raw[offset+1]=0xFF;
1262 arcpacket->raw[offset+2]=0xFF;
1263 arcpacket->raw[offset+3]=0xFF;
1264 }
1265
1266
1267
1268
1269
1270 memcpy((u_char*)arcsoft+EXTRA_CLIENTDATA,
1271 (u_char*)hdr+EXTRA_CLIENTDATA,
1272 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1273 memcpy((u_char*)arcsoft+sizeof(struct ClientData),
1274 data,
1275 length-sizeof(struct ClientData));
1276
1277 BUGLVL(D_DURING) printk("arcnet: transmitting packet to station %02Xh (%d bytes, type=%d)\n",
1278 daddr,length,pkttype);
1279
1280 BUGLVL(D_TX)
1281 {
1282 int countx,county;
1283
1284 printk("arcnet: packet dump [tx] follows:");
1285
1286 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1287 {
1288 printk("\n[%04X] ",county*16);
1289 for (countx=0; countx<16; countx++)
1290 printk("%02X ",
1291 arcpacket->raw[county*16+countx]);
1292 }
1293
1294 printk("\n");
1295 }
1296 #ifdef CAREFUL_XMIT
1297 #if 0
1298 careful_xmit_wait(dev);
1299
1300
1301
1302
1303
1304 if (daddr && !(inb(STATUS)&TXACKflag))
1305 {
1306 BUGLVL(D_INIT)
1307 printk("arcnet: transmit not acknowledged. (status=%Xh, daddr=%02Xh)\n",
1308 inb(STATUS),daddr);
1309 lp->stats.tx_errors++;
1310 return -ENONET;
1311 }
1312 #endif
1313 #endif
1314 lp->txready=lp->txbuf;
1315
1316 #if 0
1317 #ifdef IRQ_XMIT
1318 if (inb(STATUS)&TXFREEflag) arcnet_go_tx(dev);
1319 #endif
1320 #endif
1321 }
1322
1323 static void
1324 arcnet_go_tx(struct device *dev)
1325 {
1326 struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1327 int ioaddr=dev->base_addr;
1328
1329 BUGLVL(D_DURING)
1330 printk("arcnet: go_tx: status=%Xh\n",
1331 inb(STATUS));
1332
1333 if (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
1334
1335
1336 outb(TXcmd|(lp->txready<<3),COMMAND);
1337
1338 #ifdef IRQ_XMIT
1339 outb(TXFREEflag|NORXflag,INTMASK);
1340 #endif
1341
1342 dev->trans_start = jiffies;
1343 lp->txready=0;
1344 lp->sending++;
1345 }
1346
1347
1348
1349
1350 static void
1351 arcnet_interrupt(int irq,struct pt_regs *regs)
1352 {
1353 struct device *dev = (struct device *)(irq2dev_map[irq]);
1354
1355 if (dev == NULL) {
1356 if (net_debug >= D_DURING)
1357 printk("arcnet: irq %d for unknown device.\n", irq);
1358 return;
1359 }
1360
1361 arcnet_inthandler(dev);
1362 }
1363
1364 static void
1365 arcnet_inthandler(struct device *dev)
1366 {
1367 struct arcnet_local *lp;
1368 int ioaddr, status, boguscount = 3, didsomething;
1369
1370 dev->interrupt = 1;
1371 sti();
1372
1373 ioaddr = dev->base_addr;
1374 lp = (struct arcnet_local *)dev->priv;
1375
1376 #ifdef IRQ_XMIT
1377 outb(0,INTMASK);
1378 #endif
1379
1380 BUGLVL(D_DURING)
1381 printk("arcnet: in net_interrupt (status=%Xh)\n",inb(STATUS));
1382
1383 do
1384 {
1385 status = inb(STATUS);
1386 didsomething=0;
1387
1388 if (!dev->start)
1389 {
1390 BUGLVL(D_EXTRA)
1391 printk("arcnet: ARCnet not yet initialized. irq ignored. (status=%Xh)\n",
1392 status);
1393 #ifdef IRQ_XMIT
1394 if (!(status&NORXflag))
1395 outb(NORXflag,INTMASK);
1396 #endif
1397 dev->interrupt=0;
1398 return;
1399 }
1400
1401
1402
1403
1404 if (status & RESETflag)
1405 {
1406 BUGLVL(D_INIT)
1407 printk("arcnet: reset irq (status=%Xh)\n",
1408 status);
1409 dev->interrupt=0;
1410 return;
1411 }
1412
1413 #if 1
1414
1415 if (status & NORXflag)
1416 {
1417 int recbuf=lp->recbuf=!lp->recbuf;
1418
1419 BUGLVL(D_DURING)
1420 printk("arcnet: receive irq (status=%Xh)\n",
1421 status);
1422
1423
1424 EnableReceiver();
1425
1426
1427 arcnet_rx(dev,!recbuf);
1428
1429 didsomething++;
1430 }
1431 #endif
1432 #ifdef IRQ_XMIT
1433
1434 if (status&TXFREEflag && !lp->in_txhandler && lp->sending)
1435 {
1436 struct Outgoing *out=&(lp->outgoing);
1437
1438 lp->in_txhandler++;
1439 lp->sending--;
1440
1441 BUGLVL(D_DURING)
1442 printk("arcnet: TX IRQ (stat=%Xh, numsegs=%d, segnum=%d, skb=%ph)\n",
1443 status,out->numsegs,out->segnum,out->skb);
1444
1445
1446 if (lp->txready)
1447 {
1448 arcnet_go_tx(dev);
1449 didsomething++;
1450 }
1451
1452 if (lp->intx)
1453 {
1454 lp->in_txhandler--;
1455 continue;
1456 }
1457
1458 if (!lp->outgoing.skb)
1459 {
1460 BUGLVL(D_DURING)
1461 printk("arcnet: TX IRQ done: no split to continue.\n");
1462
1463
1464 if (!lp->txready && dev->tbusy)
1465 {
1466 dev->tbusy=0;
1467 mark_bh(NET_BH);
1468 }
1469
1470 lp->in_txhandler--;
1471 continue;
1472 }
1473
1474
1475
1476
1477
1478
1479 if (out->segnum<out->numsegs)
1480 arcnet_continue_tx(dev);
1481 if (lp->txready && !lp->sending)
1482 arcnet_go_tx(dev);
1483
1484
1485
1486
1487 if (out->segnum>=out->numsegs)
1488 {
1489
1490 out->segnum++;
1491 if (out->skb)
1492 dev_kfree_skb(out->skb,FREE_WRITE);
1493 out->skb=NULL;
1494
1495
1496 if (!lp->txready && dev->tbusy)
1497 {
1498 dev->tbusy=0;
1499 mark_bh(NET_BH);
1500 }
1501 }
1502 didsomething++;
1503
1504 lp->in_txhandler--;
1505 }
1506 #endif
1507 } while (--boguscount && didsomething);
1508
1509 BUGLVL(D_DURING)
1510 printk("arcnet: net_interrupt complete (status=%Xh)\n",
1511 inb(STATUS));
1512
1513 #ifdef IRQ_XMIT
1514 if (dev->start && lp->sending )
1515 outb(NORXflag|TXFREEflag,INTMASK);
1516 else
1517 outb(NORXflag,INTMASK);
1518 #endif
1519
1520 dev->interrupt=0;
1521 }
1522
1523
1524
1525 static void
1526 arcnet_rx(struct device *dev,int recbuf)
1527 {
1528 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1529 int ioaddr = dev->base_addr;
1530
1531
1532 struct sk_buff *skb;
1533
1534 union ArcPacket *arcpacket=
1535 (union ArcPacket *)(dev->mem_start+recbuf*512);
1536 struct ClientData *soft,*arcsoft;
1537 short length,offset;
1538 u_char pkttype,daddr,saddr;
1539
1540 daddr=arcpacket->hardheader.destination;
1541 saddr=arcpacket->hardheader.source;
1542
1543
1544 if (saddr==0)
1545 {
1546
1547 printk("arcnet: discarding old packet. (status=%Xh)\n",
1548 inb(STATUS));
1549 lp->stats.rx_errors++;
1550 return;
1551 }
1552 arcpacket->hardheader.source=0;
1553
1554 if (arcpacket->hardheader.offset1)
1555 {
1556 offset=arcpacket->hardheader.offset1;
1557 arcsoft=(struct ClientData *)
1558 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1559 length=256-offset+EXTRA_CLIENTDATA;
1560 pkttype=NORMAL;
1561 }
1562 else
1563 {
1564 offset=arcpacket->hardheader.offset2;
1565 arcsoft=(struct ClientData *)
1566 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1567
1568 if (arcsoft->split_flag!=0xFF)
1569 {
1570 length=512-offset+EXTRA_CLIENTDATA;
1571 pkttype=EXTENDED;
1572 }
1573 else
1574 {
1575
1576 arcsoft=(struct ClientData *)
1577 ((u_char *)arcsoft + 4);
1578 length=512-offset+EXTRA_CLIENTDATA-4;
1579 pkttype=EXCEPTION;
1580 }
1581 }
1582
1583 if (!arcsoft->split_flag)
1584 {
1585 struct Incoming *in=&lp->incoming[saddr];
1586
1587 BUGLVL(D_RX) printk("arcnet: incoming is not split (splitflag=%d)\n",
1588 arcsoft->split_flag);
1589
1590 if (in->skb)
1591 {
1592 BUGLVL(D_INIT) printk("arcnet: aborting assembly (seq=%d) for unsplit packet (splitflag=%d, seq=%d)\n",
1593 in->sequence,arcsoft->split_flag,
1594 arcsoft->sequence);
1595 kfree_skb(in->skb,FREE_WRITE);
1596 in->skb=NULL;
1597 }
1598
1599 in->sequence=arcsoft->sequence;
1600
1601 skb = alloc_skb(length, GFP_ATOMIC);
1602 if (skb == NULL) {
1603 printk("%s: Memory squeeze, dropping packet.\n",
1604 dev->name);
1605 lp->stats.rx_dropped++;
1606 return;
1607 }
1608 soft=(struct ClientData *)skb->data;
1609
1610 skb->len = length;
1611 skb->dev = dev;
1612
1613 memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1614 (u_char *)arcsoft+EXTRA_CLIENTDATA,
1615 length-EXTRA_CLIENTDATA);
1616 soft->daddr=daddr;
1617 soft->saddr=saddr;
1618
1619 BUGLVL(D_DURING)
1620 printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1621 saddr,daddr,length,pkttype);
1622 BUGLVL(D_RX)
1623 {
1624 int countx,county;
1625
1626 printk("arcnet: packet dump [rx-unsplit] follows:");
1627
1628 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1629 {
1630 printk("\n[%04X] ",county*16);
1631 for (countx=0; countx<16; countx++)
1632 printk("%02X ",
1633 arcpacket->raw[county*16+countx]);
1634 }
1635
1636 printk("\n");
1637 }
1638
1639
1640
1641
1642
1643
1644 if (soft->protocol_id == ARC_P_ARP)
1645 {
1646 struct arphdr *arp=(struct arphdr *)
1647 ((char *)soft+sizeof(struct ClientData));
1648
1649
1650 if (arp->ar_hln==1 && arp->ar_pln==4)
1651 {
1652 char *cptr=(char *)(arp)+sizeof(struct arphdr);
1653
1654 if (!*cptr)
1655 {
1656 BUGLVL(D_DURING)
1657 printk("arcnet: ARP source address was 00h, set to %02Xh.\n",
1658 saddr);
1659 *cptr=saddr;
1660 }
1661 else BUGLVL(D_DURING)
1662 {
1663 printk("arcnet: ARP source address (%Xh) is fine.\n",
1664 *cptr);
1665 }
1666 }
1667 else
1668 {
1669 printk("arcnet: funny-shaped ARP packet. (%Xh, %Xh)\n",
1670 arp->ar_hln,arp->ar_pln);
1671 }
1672 }
1673 BUGLVL( D_DATA ) {
1674 short i;
1675 for( i=0; i< skb->len; i++)
1676 {
1677 if( i%16 == 0 ) printk("\n[%04hX] ",i);
1678 printk("%02hX ",((unsigned char*)skb->data)[i]);
1679 }
1680 printk("\n");
1681 }
1682 netif_rx(skb);
1683 lp->stats.rx_packets++;
1684 }
1685 else
1686 {
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704 struct Incoming *in=&lp->incoming[saddr];
1705
1706 BUGLVL(D_RX) printk("arcnet: packet is split (splitflag=%d, seq=%d)\n",
1707 arcsoft->split_flag,in->sequence);
1708
1709 if (in->skb && in->sequence!=arcsoft->sequence)
1710 {
1711 BUGLVL(D_INIT) printk("arcnet: wrong seq number, aborting assembly (expected=%d, seq=%d, splitflag=%d)\n",
1712 in->sequence,arcsoft->sequence,
1713 arcsoft->split_flag);
1714 kfree_skb(in->skb,FREE_WRITE);
1715 in->skb=NULL;
1716 in->lastpacket=in->numpackets=0;
1717 }
1718
1719 if (arcsoft->split_flag & 1)
1720 {
1721 BUGLVL(D_RX) printk("arcnet: brand new splitpacket (splitflag=%d)\n",
1722 arcsoft->split_flag);
1723 if (in->skb)
1724 {
1725 BUGLVL(D_INIT) printk("arcnet: aborting previous (seq=%d) assembly (splitflag=%d, seq=%d)\n",
1726 in->sequence,arcsoft->split_flag,
1727 arcsoft->sequence);
1728 kfree_skb(in->skb,FREE_WRITE);
1729 }
1730
1731 in->sequence=arcsoft->sequence;
1732 in->numpackets=((unsigned)arcsoft->split_flag>>1)+2;
1733 in->lastpacket=1;
1734
1735 if (in->numpackets>16)
1736 {
1737 printk("arcnet: incoming packet more than 16 segments; dropping. (splitflag=%d)\n",
1738 arcsoft->split_flag);
1739 lp->stats.rx_dropped++;
1740 return;
1741 }
1742
1743 in->skb=skb=alloc_skb(508*in->numpackets
1744 + sizeof(struct ClientData),
1745 GFP_ATOMIC);
1746 if (skb == NULL) {
1747 printk("%s: (split) memory squeeze, dropping packet.\n",
1748 dev->name);
1749 lp->stats.rx_dropped++;
1750 return;
1751 }
1752
1753
1754
1755
1756 skb->free=1;
1757
1758 soft=(struct ClientData *)skb->data;
1759
1760 skb->len=sizeof(struct ClientData);
1761 skb->dev=dev;
1762
1763 memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1764 (u_char *)arcsoft+EXTRA_CLIENTDATA,
1765 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1766 soft->split_flag=0;
1767 }
1768 else
1769 {
1770 int packetnum=((unsigned)arcsoft->split_flag>>1) + 1;
1771
1772
1773
1774
1775 if (!in->skb)
1776 {
1777 BUGLVL(D_INIT) printk("arcnet: can't continue split without starting first! (splitflag=%d, seq=%d)\n",
1778 arcsoft->split_flag,arcsoft->sequence);
1779 return;
1780 }
1781
1782 in->lastpacket++;
1783 if (packetnum!=in->lastpacket)
1784 {
1785
1786 if (packetnum<=in->lastpacket-1)
1787 {
1788 BUGLVL(D_INIT) printk("arcnet: duplicate splitpacket ignored! (splitflag=%d)\n",
1789 arcsoft->split_flag);
1790 return;
1791 }
1792
1793
1794 BUGLVL(D_INIT) printk("arcnet: out-of-order splitpacket, reassembly (seq=%d) aborted (splitflag=%d, seq=%d)\n",
1795 in->sequence,arcsoft->split_flag,
1796 arcsoft->sequence);
1797 kfree_skb(in->skb,FREE_WRITE);
1798 in->skb=NULL;
1799 in->lastpacket=in->numpackets=0;
1800 return;
1801 }
1802
1803 soft=(struct ClientData *)in->skb->data;
1804 }
1805
1806 skb=in->skb;
1807
1808 memcpy(skb->data+skb->len,
1809 (u_char *)arcsoft+sizeof(struct ClientData),
1810 length-sizeof(struct ClientData));
1811
1812 skb->len+=length-sizeof(struct ClientData);
1813
1814 soft->daddr=daddr;
1815 soft->saddr=saddr;
1816
1817 BUGLVL(D_DURING)
1818 printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1819 saddr,daddr,length,pkttype);
1820 BUGLVL(D_RX)
1821 {
1822 int countx,county;
1823
1824 printk("arcnet: packet dump [rx-split] follows:");
1825
1826 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1827 {
1828 printk("\n[%04X] ",county*16);
1829 for (countx=0; countx<16; countx++)
1830 printk("%02X ",
1831 arcpacket->raw[county*16+countx]);
1832 }
1833
1834 printk("\n");
1835 }
1836
1837
1838 if (in->lastpacket == in->numpackets)
1839 {
1840 if (!skb || !in->skb)
1841 printk("arcnet: ?!? done reassembling packet, no skb? (skb=%ph, in->skb=%ph)\n",
1842 skb,in->skb);
1843 in->skb=NULL;
1844 in->lastpacket=in->numpackets=0;
1845 BUGLVL( D_DATA ) {
1846 short i;
1847 for( i=0; i< skb->len; i++)
1848 {
1849 if( i%16 == 0 ) printk("\n[%04hX] ",i);
1850 printk("%02hX ",((unsigned char*)skb->data)[i]);
1851 }
1852 printk("\n");
1853 }
1854 netif_rx(skb);
1855 lp->stats.rx_packets++;
1856 }
1857 }
1858
1859
1860
1861
1862
1863 }
1864
1865
1866 #ifdef USE_TIMER_HANDLER
1867
1868
1869
1870
1871
1872
1873
1874 static void
1875 arcnet_timer(unsigned long arg)
1876 {
1877 struct device *dev=(struct device *)arg;
1878 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1879 short ioaddr=dev->base_addr;
1880 int status=inb(STATUS);
1881
1882
1883
1884
1885 if (!dev->interrupt && dev->start
1886 && status&NORXflag && !status&RESETflag)
1887 {
1888 BUGLVL(D_INIT)
1889 printk("arcnet: timer: ARCnet was stuck! (status=%Xh)\n",
1890 status);
1891
1892 arcnet_inthandler(dev);
1893 }
1894
1895
1896 init_timer(&lp->timer);
1897 lp->timer.expires=TIMERval;
1898 add_timer(&lp->timer);
1899 }
1900 #endif
1901
1902
1903
1904 static struct enet_statistics *
1905 arcnet_get_stats(struct device *dev)
1906 {
1907 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1908
1909
1910 return &lp->stats;
1911 }
1912
1913
1914
1915
1916
1917
1918
1919 static void
1920 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
1921 {
1922 #if 0
1923 struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
1924
1925 short ioaddr = dev->base_addr;
1926 if (num_addrs) {
1927 outw(69, ioaddr);
1928 } else
1929 outw(99, ioaddr);
1930 #endif
1931 }
1932
1933 int arcnet_reset(struct device *dev)
1934 {
1935 struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1936 short ioaddr=dev->base_addr;
1937 int delayval,recbuf=lp->recbuf;
1938
1939 outb(0,INTMASK);
1940
1941 BUGLVL(D_INIT)
1942 printk("arcnet: Resetting %s (status=%Xh)\n",
1943 dev->name,inb(STATUS));
1944
1945 inb(RESET);
1946 JIFFER(RESETtime);
1947
1948 outb(CFLAGScmd|RESETclear, COMMAND);
1949 outb(CFLAGScmd|CONFIGclear,COMMAND);
1950
1951
1952
1953
1954 {
1955 u_char *cardmem = (u_char *) dev->mem_start;
1956 if (cardmem[0] != TESTvalue)
1957 {
1958 BUGLVL(D_INIT)
1959 printk("arcnet: reset failed: TESTvalue not present.\n");
1960 return 1;
1961 }
1962 lp->arcnum=cardmem[1];
1963 }
1964
1965
1966 recbuf=lp->recbuf=0;
1967 lp->txbuf=2;
1968
1969
1970
1971 outb(CONFIGcmd|EXTconf,COMMAND);
1972 XJIFFER(ACKtime);
1973
1974
1975 BUGLVL(D_DURING)
1976 memset((void *)dev->mem_start,0x42,2048);
1977
1978
1979 EnableReceiver();
1980
1981
1982 outb(NORXflag,INTMASK);
1983
1984
1985 return 0;
1986 }
1987
1988
1989
1990
1991
1992
1993
1994
1995 int arc_header(unsigned char *buff,struct device *dev,unsigned short type,
1996 void *daddr,void *saddr,unsigned len,struct sk_buff *skb)
1997 {
1998 struct ClientData *head = (struct ClientData *)buff;
1999 struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
2000
2001
2002 switch(type)
2003 {
2004 case ETH_P_IP:
2005 head->protocol_id=ARC_P_IP;
2006 break;
2007 case ETH_P_ARP:
2008 head->protocol_id=ARC_P_ARP;
2009 break;
2010 case ETH_P_RARP:
2011 head->protocol_id=ARC_P_RARP;
2012 break;
2013 case ETH_P_IPX:
2014 head->protocol_id=ARC_P_IPX;
2015 break;
2016 case ETH_P_ATALK:
2017 head->protocol_id=ARC_P_ATALK;
2018 break;
2019 default:
2020 printk("arcnet: I don't understand protocol %d (%Xh)\n",
2021 type,type);
2022 return 0;
2023 }
2024
2025 #if 1
2026
2027
2028
2029
2030
2031
2032 if(saddr)
2033 head->saddr=((u_char*)saddr)[0];
2034 else
2035 head->saddr=((u_char*)(dev->dev_addr))[0];
2036 #endif
2037
2038 #if 0
2039
2040
2041
2042
2043
2044
2045 if (dev->flags & IFF_LOOPBACK)
2046 {
2047 head->daddr=0;
2048 return(dev->hard_header_len);
2049 }
2050 #endif
2051
2052 head->split_flag=0;
2053 head->sequence=(lp->sequence++);
2054
2055
2056 if(daddr)
2057 {
2058 head->daddr=((u_char*)daddr)[0];
2059 return dev->hard_header_len;
2060 }
2061 else
2062 head->daddr=0;
2063
2064 return -dev->hard_header_len;
2065 }
2066
2067
2068
2069
2070
2071
2072
2073 int arc_rebuild_header(void *buff,struct device *dev,unsigned long dst,
2074 struct sk_buff *skb)
2075 {
2076 struct ClientData *head = (struct ClientData *)buff;
2077
2078
2079
2080
2081
2082 if(head->protocol_id != ARC_P_IP)
2083 {
2084 printk("arcnet: I don't understand resolve type %d (%Xh) addresses!\n",
2085 head->protocol_id,head->protocol_id);
2086 head->daddr=0;
2087
2088 return 0;
2089 }
2090
2091
2092
2093
2094 #ifdef CONFIG_INET
2095 return arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
2096 #else
2097 return 0;
2098 #endif
2099 }
2100
2101
2102
2103
2104
2105
2106 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
2107 {
2108 struct ClientData *head = (struct ClientData *) skb->data;
2109
2110
2111 if (head->daddr==0)
2112 skb->pkt_type=PACKET_BROADCAST;
2113
2114 #if 0
2115 if(*eth->h_dest&1)
2116 {
2117 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
2118 skb->pkt_type=PACKET_BROADCAST;
2119 else
2120 skb->pkt_type=PACKET_MULTICAST;
2121 }
2122 #endif
2123
2124 if(dev->flags&IFF_PROMISC)
2125 {
2126
2127 if (head->daddr != dev->dev_addr[0])
2128 skb->pkt_type=PACKET_OTHERHOST;
2129 }
2130
2131
2132 switch (head->protocol_id)
2133 {
2134 case ARC_P_IP: return htons(ETH_P_IP);
2135 case ARC_P_ARP: return htons(ETH_P_ARP);
2136 case ARC_P_RARP: return htons(ETH_P_RARP);
2137 case ARC_P_IPX: return htons(ETH_P_IPX);
2138 case ARC_P_ATALK: return htons(ETH_P_ATALK);
2139 case ARC_P_LANSOFT:
2140 default:
2141 BUGLVL(D_DURING)
2142 printk("arcnet: received packet of unknown protocol id %d (%Xh)\n",
2143 head->protocol_id,head->protocol_id);
2144 return 0;
2145 }
2146
2147 #if 0
2148 if (ntohs(eth->h_proto) >= 1536)
2149 return eth->h_proto;
2150
2151 rawp = (unsigned char *)(eth + 1);
2152
2153 if (*(unsigned short *)rawp == 0xFFFF)
2154 return htons(ETH_P_802_3);
2155 if (*(unsigned short *)rawp == 0xAAAA)
2156 return htons(ETH_P_SNAP);
2157
2158 return htons(ETH_P_802_2);
2159 #endif
2160
2161 return htons(ETH_P_IP);
2162 }
2163
2164 #ifdef MODULE
2165 char kernel_version[] = UTS_RELEASE;
2166 static struct device thisARCnet = {
2167 " ",
2168 0, 0, 0, 0,
2169 0, 0,
2170 0, 0, 0, NULL, arcnet_probe };
2171
2172
2173 int io=0x0;
2174 int irqnum=0;
2175 int shmem=0;
2176 int num=0;
2177
2178 int
2179 init_module(void)
2180 {
2181 sprintf(thisARCnet.name,"arc%d",num);
2182
2183 thisARCnet.base_addr=io;
2184
2185 thisARCnet.irq=irqnum;
2186 if (thisARCnet.irq==2) thisARCnet.irq=9;
2187
2188 if (shmem)
2189 {
2190 thisARCnet.mem_start=shmem;
2191 thisARCnet.mem_end=thisARCnet.mem_start+512*4-1;
2192 thisARCnet.rmem_start=thisARCnet.mem_start+512*0;
2193 thisARCnet.rmem_end=thisARCnet.mem_start+512*2-1;
2194 }
2195
2196 if (register_netdev(&thisARCnet) != 0)
2197 return -EIO;
2198 return 0;
2199 }
2200
2201 void
2202 cleanup_module(void)
2203 {
2204 if (MOD_IN_USE) {
2205 printk("%s: device busy, remove delayed\n",thisARCnet.name);
2206 } else {
2207 if (thisARCnet.start) arcnet_close(&thisARCnet);
2208 if (thisARCnet.irq) free_irq(thisARCnet.irq);
2209 if (thisARCnet.base_addr) release_region(thisARCnet.base_addr,
2210 ETHERCARD_TOTAL_SIZE);
2211 unregister_netdev(&thisARCnet);
2212 }
2213 }
2214
2215 #endif
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227