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