![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* arcnet.c
2 Written 1994-95 by Avery Pennarun, derived from skeleton.c by
3 Donald Becker.
4
5 Contact Avery at: apenwarr@tourism.807-city.on.ca or
6 RR #5 Pole Line Road, Thunder Bay, ON, Canada P7C 5M9
7
8 **********************
9
10 skeleton.c Written 1993 by Donald Becker.
11 Copyright 1993 United States Government as represented by the
12 Director, National Security Agency. This software may only be used
13 and distributed according to the terms of the GNU Public License as
14 modified by SRC, incorporated herein by reference.
15
16 **********************
17
18
19 v1.0 (95/02/15)
20 - Initial non-alpha release.
21
22
23 TO DO:
24
25 - Test in systems with NON-ARCnet network cards, just to see if
26 autoprobe kills anything. With any luck, it won't. (It's pretty
27 careful.)
28 - Except some unfriendly NE2000's die. (0.40)
29 - cards with shared memory that can be "turned off?"
30 - NFS mount freezes after several megabytes to SOSS for DOS.
31 unmount/remount works. Is this arcnet-specific? I don't know.
32 - Add support for the various stupid bugs ("I didn't read the RFC"
33 syndrome) in MS Windows for Workgroups and LanMan.
34
35 - get the net people to probe last for arcnet, and first for ne2000
36 in Space.c...
37 */
38
39 /**************************************************************************/
40
41 /* define this if you want to use the new but possibly dangerous ioprobe
42 * If you get lockups right after status5, you probably need
43 * to undefine this. It should make more cards probe correctly,
44 * I hope.
45 */
46 #define DANGER_PROBE
47
48 /* define this if you want to use the "extra delays" which were removed
49 * in 0.41 since they seemed needless.
50 */
51 #undef EXTRA_DELAYS
52
53 /* undefine this if you want to use the non-IRQ-driven transmitter. (possibly
54 * safer, although it takes more CPU time and IRQ_XMIT seems fine right now)
55 */
56 #define IRQ_XMIT
57
58 /* define this for "careful" transmitting. Try with and without if you have
59 * problems. If you use IRQ_XMIT, do NOT define this.
60 */
61 #undef CAREFUL_XMIT
62
63 /* define this for an extra-careful memory detect. This should work all
64 * the time now, but you never know.
65 */
66 #define STRICT_MEM_DETECT
67
68 /* define this to use the "old-style" limited MTU by default. It basically
69 * disables packet splitting. ifconfig can still be used to reset the MTU.
70 *
71 * leave this disabled if possible, so it will use ethernet defaults,
72 * which is our goal.
73 */
74 #undef LIMIT_MTU
75
76 /* define this if you have a problem with the card getting "stuck" now and
77 * then, which can only be fixed by a reboot or resetting the card manually
78 * via ifconfig up/down. ARCnet will set a timer function which is called
79 * 8 times every second.
80 *
81 * This should no longer be necessary. if you experience "stuck" ARCnet
82 * drivers, please email apenwarr@tourism.807-city.on.ca or I will remove
83 * this feature in a future release.
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 Sources:
94 Crynwr arcnet.com/arcether.com packet drivers.
95 arcnet.c v0.00 dated 1/1/94 and apparently by
96 Donald Becker - it didn't work :)
97 skeleton.c v0.05 dated 11/16/93 by Donald Becker
98 (from Linux Kernel 1.1.45)
99 ...I sure wish I had the ARCnet data sheets right about now!
100 RFC's 1201 and 1051 (mostly 1201) - re: ARCnet IP packets
101 net/inet/eth.c (from kernel 1.1.50) for header-building info...
102 Alternate Linux ARCnet source by V.Shergin <vsher@sao.stavropol.su>
103 Textual information and more alternate source from Joachim Koenig
104 <jojo@repas.de>
105 */
106
107 #include <linux/config.h>
108 #ifdef MODULE
109 #include <linux/module.h>
110 #include <linux/version.h>
111 #endif /* MODULE */
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 /* debug levels:
139 * D_OFF production
140 * D_NORMAL verification
141 * D_INIT show init/detect messages
142 * D_DURING show messages during normal use (ie interrupts)
143 * D_TX show tx packets
144 * D_RX show tx+rx packets
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 /* From auto_irq.c, in ioport.h for later versions. */
161 extern void autoirq_setup(int waittime);
162 extern int autoirq_report(int waittime);
163 /* The map from IRQ number (as passed to the interrupt handler) to
164 'struct device'. */
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 /* macro to simplify debug checking */
174 #define BUGLVL(x) if (net_debug>=x)
175
176 /* The number of low I/O ports used by the ethercard. */
177 #define ETHERCARD_TOTAL_SIZE 16
178
179
180 /* Handy defines for ARCnet specific stuff */
181 /* COM 9026 (?) --> ARCnet register addresses */
182 #define INTMASK (ioaddr+0) /* writable */
183 #define STATUS (ioaddr+0) /* readable */
184 #define COMMAND (ioaddr+1) /* writable, returns random vals on read (?) */
185 #define RESET (ioaddr+8) /* software reset writable */
186
187 /* time needed for various things (in clock ticks, 1/100 sec) */
188 #define RESETtime 40 /* reset */
189 #define XMITtime 10 /* send (?) */
190 #define ACKtime 10 /* acknowledge (?) */
191
192 /* these are the max/min lengths of packet data. (including
193 * ClientData header)
194 * note: packet sizes 250, 251, 252 are impossible (God knows why)
195 * so exception packets become necessary.
196 *
197 * These numbers are compared with the length of the full packet,
198 * including ClientData header.
199 */
200 #define MTU (253+EXTRA_CLIENTDATA) /* normal packet max size */
201 #define MinTU (257+EXTRA_CLIENTDATA) /* extended packet min size */
202 #define XMTU (508+EXTRA_CLIENTDATA) /* extended packet max size */
203
204 /* status/interrupt mask bit fields */
205 #define TXFREEflag 0x001 /* transmitter available */
206 #define TXACKflag 0x002 /* transmitted msg. ackd */
207 #define RECONflag 0x004 /* system reconfigured */
208 #define TESTflag 0x008 /* test flag */
209 #define RESETflag 0x010 /* power-on-reset */
210 #define RES1flag 0x020 /* unused */
211 #define RES2flag 0x040 /* unused */
212 #define NORXflag 0x080 /* receiver inhibited */
213
214 /* in the command register, the following bits have these meanings:
215 * 0-2 command
216 * 3-4 page number (for enable rcv/xmt command)
217 * 7 receive broadcasts
218 */
219 #define NOTXcmd 0x001 /* disable transmitter */
220 #define NORXcmd 0x002 /* disable receiver */
221 #define TXcmd 0x003 /* enable transmitter */
222 #define RXcmd 0x004 /* enable receiver */
223 #define CONFIGcmd 0x005 /* define configuration */
224 #define CFLAGScmd 0x006 /* clear flags */
225 #define TESTcmd 0x007 /* load test flags */
226
227 /* flags for "clear flags" command */
228 #define RESETclear 0x008 /* power-on-reset */
229 #define CONFIGclear 0x010 /* system reconfigured */
230
231 /* flags for "load test flags" command */
232 #define TESTload 0x008 /* test flag (diagnostic) */
233
234 /* byte deposited into first address of buffers on reset */
235 #define TESTvalue 0321 /* that's octal for 0xD1 :) */
236
237 /* for "enable receiver" command */
238 #define RXbcasts 0x080 /* receive broadcasts */
239
240 /* flags for "define configuration" command */
241 #define NORMALconf 0x000 /* 1-249 byte packets */
242 #define EXTconf 0x008 /* 250-504 byte packets */
243
244 /* buffers (4 total) used for receive and xmit.
245 */
246 #define EnableReceiver() outb(RXcmd|(recbuf<<3)|RXbcasts,COMMAND)
247 /*#define TXbuf 2 (Obsoleted by ping-pong xmits) */
248
249 /* Protocol ID's */
250 #define ARC_P_IP 212 /* 0xD4 */
251 #define ARC_P_ARP 213 /* 0xD5 */
252 #define ARC_P_RARP 214 /* 0xD6 */
253 #define ARC_P_IPX 250 /* 0xFA */
254 #define ARC_P_LANSOFT 251 /* 0xFB */
255 #define ARC_P_ATALK 0xDD
256
257 /* Length of time between "stuck" checks */
258 #define TIMERval (HZ/8) /* about 1/8 second */
259
260 /* these structures define the format of an arcnet packet. */
261 #define NORMAL 0
262 #define EXTENDED 1
263 #define EXCEPTION 2
264
265 /* the header required by the card itself */
266 struct HardHeader
267 {
268 u_char source, /* source ARCnet - filled in automagically */
269 destination, /* destination ARCnet - 0 for broadcast */
270 offset1, /* offset of ClientData (256-byte packets) */
271 offset2; /* offset of ClientData (512-byte packets) */
272 };
273
274 /* a complete ARCnet packet */
275 union ArcPacket
276 {
277 struct HardHeader hardheader; /* the hardware header */
278 u_char raw[512]; /* raw packet info, incl ClientData */
279 };
280
281 /* the "client data" header - RFC-1201 information
282 * notice that this screws up if it's not an even number of bytes
283 * <sigh>
284 */
285 struct ClientData
286 {
287 /* data that's NOT part of real packet */
288 u_char daddr; /* Destination address - stored here,
289 * but WE MUST GET RID OF IT BEFORE SENDING A
290 * PACKET!!
291 */
292 u_char stupid; /* filler to make struct an even # of bytes */
293
294 /* data that IS part of real packet */
295 u_char protocol_id, /* ARC_P_IP, ARC_P_ARP, or ARC_P_RARP */
296 split_flag; /* for use with split packets */
297 u_short sequence; /* sequence number (?) */
298 };
299 #define EXTRA_CLIENTDATA (sizeof(struct ClientData)-4)
300
301
302 /* "Incoming" is information needed for each address that could be sending
303 * to us. Mostly for partially-received split packets.
304 */
305 struct Incoming
306 {
307 struct sk_buff *skb; /* packet data buffer */
308 unsigned char lastpacket, /* number of last packet (from 1) */
309 numpackets; /* number of packets in split */
310 u_short sequence; /* sequence number of assembly */
311 };
312
313 struct Outgoing
314 {
315 struct sk_buff *skb; /* buffer from upper levels */
316 struct ClientData *hdr; /* clientdata of last packet */
317 u_char *data; /* pointer to data in packet */
318 short length, /* bytes total */
319 dataleft, /* bytes left */
320 segnum, /* segment being sent */
321 numsegs, /* number of segments */
322 seglen; /* length of segment */
323 };
324
325
326 /* Information that needs to be kept for each board. */
327 struct arcnet_local {
328 struct enet_statistics stats;
329 u_char arcnum; /* arcnet number - our 8-bit address */
330 u_short sequence; /* sequence number (incs with each packet) */
331 u_char recbuf, /* receive buffer # (0 or 1) */
332 txbuf, /* transmit buffer # (2 or 3) */
333 txready; /* buffer where a packet is ready to send */
334 short intx, /* in TX routine? */
335 in_txhandler, /* in TX_IRQ handler? */
336 sending; /* transmit in progress? */
337 short tx_left; /* segments of split packet left to TX */
338 struct timer_list timer; /* the timer interrupt struct */
339 struct Incoming incoming[256]; /* one from each address */
340 struct Outgoing outgoing; /* packet currently being sent */
341 };
342
343
344 /* Index to functions, as function prototypes. */
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 /* annoying functions for header/arp/etc building */
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 #define JIFFER(time) for (delayval=jiffies+(time); delayval>jiffies;);
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 /* Check for a network adaptor of this type, and return '0' if one exists.
406 * If dev->base_addr == 0, probe all likely locations.
407 * If dev->base_addr == 1, always return failure.
408 * If dev->base_addr == 2, allocate space for the device and return success
409 * (detachable devices only).
410 */
411 int
412 arcnet_probe(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
413 {
414 #ifndef MODULE
415 /* I refuse to probe anything less than 0x200, because anyone using
416 * an address like that should probably be shot.
417 */
418 int *port, ports[] = {/* first the suggested values! */
419 0x300,0x2E0,0x2F0,0x2D0,
420 /* ...now everything else possible. */
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,/* video ports, */0x3e0,0x3f0,
425 /* a null ends the list */
426 0};
427 /* I'm not going to probe below 0xA0000 either, for similar reasons.
428 */
429 unsigned long *addr, addrs[] = {0xD0000,0xE0000,0xA0000,0xB0000,
430 0xC0000,0xF0000,
431 /* from <mdrejhon@magi.com> */
432 0xE1000,
433 0xDD000,0xDC000,
434 0xD9000,0xD8000,0xD5000,0xD4000,0xD1000,
435 0xCD000,0xCC000,
436 0xC9000,0xC8000,0xC5000,0xC4000,
437 /* terminator */
438 0};
439 int base_addr=dev->base_addr, status=0;
440 #endif /* MODULE */
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) /* Check a single specified location. */
458 status=arcnet_ioprobe(dev, base_addr);
459 else if (base_addr > 0) /* Don't probe at all. */
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 /* ioprobe turned out okay. Now give it a couple seconds to finish
479 * initializing...
480 */
481 BUGLVL(D_INIT)
482 printk("arcnet: ioprobe okay! Waiting for reset...\n");
483 JIFFER(100);
484
485 /* okay, now we have to find the shared memory area. */
486 BUGLVL(D_INIT)
487 printk("arcnet: starting memory probe, given %lXh\n",
488 dev->mem_start);
489 if (dev->mem_start) /* value given - probe just that one */
490 {
491 status=arcnet_memprobe(dev,(u_char *)dev->mem_start);
492 if (status) return status;
493 }
494 else /* no value given - probe everything */
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 /* MODULE */
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 /* now reserve the irq... */
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 /* Grab the region so we can find another board if autoIRQ fails. */
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 /* Initialize the device structure. */
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 /* Fill in the fields of the device structure with ethernet-generic values. */
544 ether_setup(dev);
545
546 /* And now fill particular ones with arcnet values :) */
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 /* the old way - normally, now use ethernet default */
554 dev->mtu=512-sizeof(struct HardHeader)+EXTRA_CLIENTDATA;
555 #endif
556 /* since we strip EXTRA_CLIENTDATA bytes off before sending,
557 * we let Linux add that many bytes to the packet data...
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)
/* ![[previous]](../icons/left.png)
*/
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 /* very simple - all we have to do is reset the card, and if there's
597 * no irq, it's not an ARCnet. We can also kill two birds with
598 * one stone because we detect the IRQ at the same time :)
599 */
600
601 /* reset the card by reading the reset port */
602 inb(RESET);
603 JIFFER(RESETtime);
604
605 /* if status port is FF, there's certainly no arcnet... give up. */
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 /* we'll try to be reasonably sure it's an arcnet by making sure
614 * the value of the COMMAND port changes automatically once in a
615 * while. I have no idea what those values ARE, but at least
616 * they work.
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 /* now we turn the reset bit off so we can IRQ next reset... */
638 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
639 XJIFFER(ACKtime);
640 if (inb(STATUS) & RESETflag) /* reset flag STILL on */
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 /* set up automatic IRQ detection */
649 autoirq_setup(0);
650
651 /* enable reset IRQ's (shouldn't be necessary, but worth a try) */
652 outb(RESETflag,INTMASK);
653
654 /* now reset it again to generate an IRQ */
655 inb(RESET);
656 JIFFER(RESETtime);
657
658 BUGLVL(D_INIT)
659 printk("arcnet: status3=%Xh\n",inb(STATUS));
660
661 /* and turn the reset flag back off */
662 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
663 XJIFFER(ACKtime);
664
665 BUGLVL(D_INIT)
666 printk("arcnet: status4=%Xh\n",inb(STATUS));
667
668 /* enable reset IRQ's again */
669 outb(RESETflag,INTMASK);
670
671 /* now reset it again to generate an IRQ */
672 inb(RESET);
673 JIFFER(RESETtime);
674
675 BUGLVL(D_INIT)
676 printk("arcnet: status5=%Xh\n",inb(STATUS));
677
678 /* if we do this, we're sure to get an IRQ since the card has
679 * just reset and the NORXflag is on until we tell it to start
680 * receiving.
681 *
682 * However, this could, theoretically, cause a lockup. Maybe I'm just
683 * not very good at theory! :)
684 */
685 #ifdef DANGER_PROBE
686 outb(NORXflag,INTMASK);
687 JIFFER(RESETtime);
688 outb(0,INTMASK);
689 #endif
690
691 /* and turn the reset flag back off */
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 /* if there was no autoirq AND the user hasn't set any defaults,
700 * give up.
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 /* otherwise we probably have a card. Let's make sure. */
710
711 if (inb(STATUS) & RESETflag) /* reset flag on */
712 {
713 /* now we turn the reset bit off */
714 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
715 XJIFFER(ACKtime);
716 }
717
718 if (inb(STATUS) & RESETflag) /* reset flag STILL on */
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 /* okay, we've got a real, live ARCnet on our hands. */
727 if (!dev->base_addr) dev->base_addr=ioaddr;
728
729 if (dev->irq < 2) /* "Auto-IRQ" */
730 {
731 /* we already did the autoirq above, so store the values */
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 /* A memory probe that is called after the card is reset.
749 * It checks for the official TESTvalue in byte 0 and makes sure the buffer
750 * has certain characteristics of an ARCnet...
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 /* probably better. */
760 /* ARCnet memory byte 0 is TESTvalue */
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 /* now verify the shared memory writability */
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 /* got it! fill in dev */
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 /* MODULE */
798
799
800 /* Open/initialize the board. This is called (in the current kernel)
801 sometime after booting when the 'ifconfig' program is run.
802
803 This routine should set everything up anew at each open, even
804 registers that "should" only need to be set once at boot, so that
805 there is non-reboot way to recover if something goes wrong.
806 */
807 static int
808 arcnet_open(struct device *dev)
/* */
809 {
810 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
811 /* int ioaddr = dev->base_addr;*/
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 /* Yup, they're hardwired in arcnets */
822 /* This is used if the interrupt line can turned off (shared).
823 See 3c503.c for an example of selecting the IRQ at config-time. */
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 /* Reset the hardware here. */
832 BUGLVL(D_EXTRA) printk("arcnet: arcnet_open: resetting card.\n");
833
834 /* try to reset - twice if it fails the first time */
835 if (arcnet_reset(dev) && arcnet_reset(dev))
836 return -ENODEV;
837
838 /* chipset_init(dev, 1);*/
839 /* outb(0x00, ioaddr);*/
840
841 /* lp->open_time = jiffies;*/
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 /* grab a timer handler to recover from any missed IRQ's */
851 init_timer(&lp->timer);
852 lp->timer.expires = TIMERval; /* length of time */
853 lp->timer.data = (unsigned long)dev; /* pointer to "dev" structure */
854 lp->timer.function = &arcnet_timer; /* timer handler */
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 /* The inverse routine to arcnet_open(). */
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 /* lp->open_time = 0;*/
877
878 dev->tbusy = 1;
879 dev->start = 0;
880
881 /* release the timer */
882 del_timer(&lp->timer);
883
884 /* Flush the Tx and disable Rx here. */
885 /* resetting the card should do the job. */
886 /*inb(RESET);*/
887
888 outb(0,INTMASK); /* no IRQ's */
889 outb(NOTXcmd,COMMAND); /* disable transmit */
890 XJIFFER(ACKtime);
891 outb(NORXcmd,COMMAND); /* disable receive */
892
893 /* Update the statistics here. */
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 /* short daddr;*/
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 /* If we get here, some higher level has decided we are broken.
919 There should really be a "kick me" function call instead. */
920 int tickssofar = jiffies - dev->trans_start;
921 int recbuf=lp->recbuf;
922 int status=inb(STATUS);
923
924 /* resume any stopped tx's */
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 /* Try to restart the adaptor. */
952 /*arcnet_reset(dev);*/
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 /* If some higher layer thinks we've missed a tx-done interrupt
973 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
974 itself. */
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) /* transmit already in progress! */
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 /* Block a timer-based transmit from overlapping. This could better be
993 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
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) /* fits in one packet? */
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 /* done right away */
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 /* inform upper layers */
1036 dev->tbusy=0;
1037 mark_bh(NET_BH);
1038 }
1039 }
1040 else /* too big for one - split it */
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 /* if a packet waiting, launch it */
1056 if (lp->txready && inb(STATUS)&TXFREEflag)
1057 arcnet_go_tx(dev);
1058
1059 if (!lp->txready)
1060 {
1061 /* prepare a packet, launch it and prepare
1062 * another.
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 /* if segnum==numsegs, the transmission is finished;
1075 * free the skb right away.
1076 */
1077 if (out->segnum==out->numsegs)
1078 {
1079 /* transmit completed */
1080 out->segnum++;
1081 if (out->skb)
1082 dev_kfree_skb(out->skb,FREE_WRITE);
1083 out->skb=NULL;
1084 #if 0
1085 /* inform upper layers */
1086 dev->tbusy=0;
1087 mark_bh(NET_BH);
1088 #endif
1089 }
1090
1091 #else /* non-irq xmit */
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 /* inform upper layers */
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) /* first packet */
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 /* wait patiently for tx to become available again */
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 /* int ioaddr = dev->base_addr;*/
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; /* XOR with 1 to alternate between 2 and 3 */
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 /* clean out the page to make debugging make more sense :) */
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 /* load packet into shared memory */
1206 if (length<=MTU) /* Normal (256-byte) Packet */
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) /* Extended (512-byte) Packet */
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 /* Exception Packet */
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 /* exception-specific stuff - these four bytes
1236 * make the packet long enough to fit in a 512-byte
1237 * frame.
1238 */
1239 arcpacket->raw[offset+0]=arcsoft->protocol_id;
1240 arcpacket->raw[offset+1]=0xFF; /* FF flag */
1241 arcpacket->raw[offset+2]=0xFF; /* FF padding */
1242 arcpacket->raw[offset+3]=0xFF; /* FF padding */
1243 }
1244
1245
1246 /* copy the packet into ARCnet shmem
1247 * - the first bytes of ClientData header are skipped
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 /* if we're not broadcasting, make sure the xmit was ack'd.
1280 * if it wasn't, there is probably no card with that
1281 * address... or else it missed our tx somehow.
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; /* "machine is not on the network" */
1290 }
1291 #endif
1292 #endif
1293 lp->txready=lp->txbuf; /* packet is ready for sending */
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 /* start sending */
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 /* The typical workload of the driver:
1328 Handle the network interface interrupts. */
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 /* RESET flag was enabled - card is resetting and if RX
1381 * is disabled, it's NOT because we just got a packet.
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 /* yes, it's silly to disable this part but it makes good testing */
1393 /* RX is inhibited - we must have received something. */
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 /* enable receive of our next packet */
1403 EnableReceiver();
1404
1405 /* Got a packet. */
1406 arcnet_rx(dev,!recbuf);
1407
1408 didsomething++;
1409 }
1410 #endif
1411 #ifdef IRQ_XMIT
1412 /* it can only be an xmit-done irq if we're xmitting :) */
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 /* send packet if there is one */
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 /* inform upper layers */
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 /*lp->stats.tx_packets++;*/
1454
1455 /* if more than one segment, and not all segments
1456 * are done, then continue xmit.
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 /* if segnum==numsegs, the transmission is finished;
1464 * free the skb.
1465 */
1466 if (out->segnum>=out->numsegs)
1467 {
1468 /* transmit completed */
1469 out->segnum++;
1470 if (out->skb)
1471 dev_kfree_skb(out->skb,FREE_WRITE);
1472 out->skb=NULL;
1473
1474 /* inform upper layers */
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 /* IRQ_XMIT */
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 /* A packet has arrived; grab it from the buffers and possibly unsplit it.
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 /* int status = inb(STATUS);*/
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 /* if source is 0, it's not a "used" packet! */
1523 if (saddr==0)
1524 {
1525 /*BUGLVL(D_DURING)*/
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) /* Normal Packet */
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 /* ExtendedPacket or ExceptionPacket */
1542 {
1543 offset=arcpacket->hardheader.offset2;
1544 arcsoft=(struct ClientData *)
1545 (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1546
1547 if (arcsoft->split_flag!=0xFF) /* Extended Packet */
1548 {
1549 length=512-offset+EXTRA_CLIENTDATA;
1550 pkttype=EXTENDED;
1551 }
1552 else /* Exception Packet */
1553 {
1554 /* skip over 4-byte junkola */
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) /* not split */
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) /* already assembling one! */
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 /* ARP packets have problems when sent from DOS.
1618 * source address is always 0! So we take the hardware
1619 * source addr (which is impossible to fumble) and insert
1620 * it ourselves.
1621 */
1622 if (soft->protocol_id == ARC_P_ARP)
1623 {
1624 struct arphdr *arp=(struct arphdr *)
1625 ((char *)soft+sizeof(struct ClientData));
1626
1627 /* make sure addresses are the right length */
1628 if (arp->ar_hln==1 && arp->ar_pln==4)
1629 {
1630 char *cptr=(char *)(arp)+sizeof(struct arphdr);
1631
1632 if (!*cptr) /* is saddr = 00? */
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 /* split packet */
1656 {
1657 /* NOTE: MSDOS ARP packet correction should only need to
1658 * apply to unsplit packets, since ARP packets are so short.
1659 *
1660 * My interpretation of the RFC1201 (ARCnet) document is that
1661 * if a packet is received out of order, the entire assembly
1662 * process should be aborted.
1663 *
1664 * The RFC also mentions "it is possible for successfully
1665 * received packets to be retransmitted." As of 0.40 all
1666 * previously received packets are allowed, not just the
1667 * most recent one.
1668 *
1669 * We allow multiple assembly processes, one for each
1670 * ARCnet card possible on the network. Seems rather like
1671 * a waste of memory. Necessary?
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) /* first packet in split */
1690 {
1691 BUGLVL(D_RX) printk("arcnet: brand new splitpacket (splitflag=%d)\n",
1692 arcsoft->split_flag);
1693 if (in->skb) /* already assembling one! */
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 /* I don't know what this is for, but it DOES avoid
1724 * warnings...
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; /* final packet won't be split */
1744 }
1745 else /* not first packet */
1746 {
1747 int packetnum=((unsigned)arcsoft->split_flag>>1) + 1;
1748
1749 /* if we're not assembling, there's no point
1750 * trying to continue.
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) /* not the right flag! */
1761 {
1762 /* harmless duplicate? ignore. */
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 /* "bad" duplicate, kill reassembly */
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 /* are we done? */
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 /* If any worth-while packets have been received, dev_rint()
1827 has done a mark_bh(NET_BH) for us and will work on them
1828 when we get to the bottom-half routine. */
1829 /* arcnet: pardon? */
1830 }
1831
1832
1833 #ifdef USE_TIMER_HANDLER
1834 /* this function is called every once in a while to make sure the ARCnet
1835 * isn't stuck.
1836 *
1837 * If we miss a receive IRQ, the receiver (and IRQ) is permanently disabled
1838 * and we might never receive a packet again! This will check if this
1839 * is the case, and if so, re-enable the receiver.
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 /* if we didn't interrupt the IRQ handler, and RX's are still
1850 * disabled, and we're not resetting the card... then we're stuck!
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 /* requeue ourselves */
1863 init_timer(&lp->timer);
1864 lp->timer.expires=TIMERval;
1865 add_timer(&lp->timer);
1866 }
1867 #endif
1868
1869 /* Get the current statistics. This may be called with the card open or
1870 closed. */
1871 static struct enet_statistics *
1872 arcnet_get_stats(struct device *dev)
/* */
1873 {
1874 struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1875 /* short ioaddr = dev->base_addr;*/
1876
1877 return &lp->stats;
1878 }
1879
1880 /* Set or clear the multicast filter for this adaptor.
1881 num_addrs == -1 Promiscuous mode, receive all packets
1882 num_addrs == 0 Normal mode, clear multicast list
1883 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
1884 best-effort filtering.
1885 */
1886 static void
1887 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
/* */
1888 {
1889 #if 0 /* no promiscuous mode at all */
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); /* Enable promiscuous mode */
1895 } else
1896 outw(99, ioaddr); /* Disable promiscuous mode, use normal mode */
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); /* no IRQ's, please! */
1907
1908 BUGLVL(D_INIT)
1909 printk("arcnet: Resetting %s (status=%Xh)\n",
1910 dev->name,inb(STATUS));
1911
1912 inb(RESET); /* Reset by reading this port */
1913 JIFFER(RESETtime);
1914
1915 outb(CFLAGScmd|RESETclear, COMMAND); /* clear flags & end reset */
1916 outb(CFLAGScmd|CONFIGclear,COMMAND);
1917
1918 /* after a reset, the first byte of shared mem is TESTvalue and the
1919 * second byte is our 8-bit ARCnet address
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]; /* save address for later use */
1930 }
1931
1932 /* clear out status variables */
1933 recbuf=lp->recbuf=0;
1934 lp->txbuf=2;
1935 /*dev->tbusy=0;*/
1936
1937 /* enable extended (512-byte) packets */
1938 outb(CONFIGcmd|EXTconf,COMMAND);
1939 XJIFFER(ACKtime);
1940
1941 /* clean out all the memory to make debugging make more sense :) */
1942 BUGLVL(D_DURING)
1943 memset((void *)dev->mem_start,0x42,2048);
1944
1945 /* and enable receive of our first packet to the first buffer */
1946 EnableReceiver();
1947
1948 /* re-enable interrupts */
1949 outb(NORXflag,INTMASK);
1950
1951 /* done! return success. */
1952 return 0;
1953 }
1954
1955
1956 /*
1957 * Create the ARCnet ClientData header for an arbitrary protocol layer
1958 *
1959 * saddr=NULL means use device source address (always will anyway)
1960 * daddr=NULL means leave destination address (eg unresolved arp)
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 /* set the protocol ID according to RFC-1201 */
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 * Set the source hardware address.
1992 * AVE: we can't do this, so we don't. Code below is directly
1993 * stolen from eth.c driver and won't work.
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 * Anyway, the loopback-device should never use this function...
2004 *
2005 * And the chances of it using the ARCnet version of it are so
2006 * tiny that I don't think we have to worry :)
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; /* split packets are done elsewhere */
2016 head->sequence=(lp->sequence++);
2017
2018 /* supposedly if daddr is NULL, we should ignore it... */
2019 if(daddr)
2020 {
2021 head->daddr=((u_char*)daddr)[0];
2022 return dev->hard_header_len;
2023 }
2024 else
2025 head->daddr=0; /* better fill one in anyway */
2026
2027 return -dev->hard_header_len;
2028 }
2029
2030
2031 /*
2032 * Rebuild the ARCnet ClientData header. This is called after an ARP
2033 * (or in future other address resolution) has completed on this
2034 * sk_buff. We now let ARP fill in the other fields.
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 * Only ARP/IP is currently supported
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 /*memcpy(eth->h_source, dev->dev_addr, dev->addr_len);*/
2051 return 0;
2052 }
2053
2054 /*
2055 * Try and get ARP to resolve the header.
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 * Determine the packet's protocol ID.
2066 *
2067 * With ARCnet we have to convert everything to Ethernet-style stuff.
2068 */
2069 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
/* */
2070 {
2071 struct ClientData *head = (struct ClientData *) skb->data;
2072 /*unsigned char *rawp;*/
2073
2074 if (head->daddr==0)
2075 skb->pkt_type=PACKET_BROADCAST;
2076
2077 #if 0 /* code for ethernet with multicast */
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 /* if we're not sending to ourselves :) */
2090 if (head->daddr != dev->dev_addr[0])
2091 skb->pkt_type=PACKET_OTHERHOST;
2092 }
2093
2094 /* now return the protocol number */
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: /* don't understand. fall through. */
2102 case ARC_P_ATALK: /* appletalk - don't understand. fall through. */
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 /* more ethernet-specific junk */
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 " ",/* if blank, device name inserted by /linux/drivers/net/net_init.c */
2131 0, 0, 0, 0,
2132 0, 0, /* I/O address, IRQ */
2133 0, 0, 0, NULL, arcnet_probe };
2134
2135
2136 int io=0x0; /* <--- EDIT THESE LINES FOR YOUR CONFIGURATION */
2137 int irqnum=0; /* or use the insmod io= irq= shmem= options */
2138 int shmem=0;
2139 int num=0; /* number of device (ie for arc0, arc1, arc2...) */
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)
/* ![[last]](../icons/n_last.png)
*/
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 /* MODULE */
2179
2180
2181
2182 /*
2183 * Local variables:
2184 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
2185 * version-control: t
2186 * kept-new-versions: 5
2187 * tab-width: 4
2188 * End:
2189 */
2190
![[bottom]](../icons/n_bottom.png){kind=icon}
*/