2 * Linux ARCnet driver - device-independent routines
4 * Written 1997 by David Woodhouse.
5 * Written 1994-1999 by Avery Pennarun.
6 * Written 1999-2000 by Martin Mares <mj@ucw.cz>.
7 * Derived from skeleton.c by Donald Becker.
9 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
10 * for sponsoring the further development of this driver.
12 * **********************
14 * The original copyright was as follows:
16 * skeleton.c Written 1993 by Donald Becker.
17 * Copyright 1993 United States Government as represented by the
18 * Director, National Security Agency. This software may only be used
19 * and distributed according to the terms of the GNU General Public License as
20 * modified by SRC, incorporated herein by reference.
22 * **********************
24 * The change log is now in a file called ChangeLog in this directory.
27 * - Crynwr arcnet.com/arcether.com packet drivers.
28 * - arcnet.c v0.00 dated 1/1/94 and apparently by
29 * Donald Becker - it didn't work :)
30 * - skeleton.c v0.05 dated 11/16/93 by Donald Becker
31 * (from Linux Kernel 1.1.45)
32 * - RFC's 1201 and 1051 - re: TCP/IP over ARCnet
33 * - The official ARCnet COM9026 data sheets (!) thanks to
34 * Ken Cornetet <kcornete@nyx10.cs.du.edu>
35 * - The official ARCnet COM20020 data sheets.
36 * - Information on some more obscure ARCnet controller chips, thanks
37 * to the nice people at SMSC.
38 * - net/inet/eth.c (from kernel 1.1.50) for header-building info.
39 * - Alternate Linux ARCnet source by V.Shergin <vsher@sao.stavropol.su>
40 * - Textual information and more alternate source from Joachim Koenig
44 #define VERSION "arcnet: v3.93 BETA 2000/04/29 - by Avery Pennarun et al.\n"
46 #include <linux/module.h>
47 #include <linux/config.h>
48 #include <linux/types.h>
49 #include <linux/delay.h>
50 #include <linux/netdevice.h>
51 #include <linux/if_arp.h>
53 #include <linux/init.h>
54 #include <linux/arcdevice.h>
56 /* "do nothing" functions for protocol drivers */
57 static void null_rx(struct net_device
*dev
, int bufnum
,
58 struct archdr
*pkthdr
, int length
);
59 static int null_build_header(struct sk_buff
*skb
, struct net_device
*dev
,
60 unsigned short type
, uint8_t daddr
);
61 static int null_prepare_tx(struct net_device
*dev
, struct archdr
*pkt
,
62 int length
, int bufnum
);
66 * one ArcProto per possible proto ID. None of the elements of
67 * arc_proto_map are allowed to be NULL; they will get set to
68 * arc_proto_default instead. It also must not be NULL; if you would like
69 * to set it to NULL, set it to &arc_proto_null instead.
71 struct ArcProto
*arc_proto_map
[256], *arc_proto_default
,
72 *arc_bcast_proto
, *arc_raw_proto
;
74 struct ArcProto arc_proto_null
=
80 .build_header
= null_build_header
,
81 .prepare_tx
= null_prepare_tx
,
86 /* Exported function prototypes */
87 int arcnet_debug
= ARCNET_DEBUG
;
89 EXPORT_SYMBOL(arc_proto_map
);
90 EXPORT_SYMBOL(arc_proto_default
);
91 EXPORT_SYMBOL(arc_bcast_proto
);
92 EXPORT_SYMBOL(arc_raw_proto
);
93 EXPORT_SYMBOL(arc_proto_null
);
94 EXPORT_SYMBOL(arcnet_unregister_proto
);
95 EXPORT_SYMBOL(arcnet_debug
);
96 EXPORT_SYMBOL(alloc_arcdev
);
97 EXPORT_SYMBOL(arcnet_interrupt
);
99 /* Internal function prototypes */
100 static int arcnet_open(struct net_device
*dev
);
101 static int arcnet_close(struct net_device
*dev
);
102 static int arcnet_send_packet(struct sk_buff
*skb
, struct net_device
*dev
);
103 static void arcnet_timeout(struct net_device
*dev
);
104 static int arcnet_header(struct sk_buff
*skb
, struct net_device
*dev
,
105 unsigned short type
, void *daddr
, void *saddr
,
107 static int arcnet_rebuild_header(struct sk_buff
*skb
);
108 static struct net_device_stats
*arcnet_get_stats(struct net_device
*dev
);
109 static int go_tx(struct net_device
*dev
);
111 static int debug
= ARCNET_DEBUG
;
112 module_param(debug
, int, 0);
113 MODULE_LICENSE("GPL");
115 static int __init
arcnet_init(void)
119 arcnet_debug
= debug
;
125 printk("arcnet: ***\n"
126 "arcnet: * Read arcnet.txt for important release notes!\n"
128 "arcnet: * This is an ALPHA version! (Last stable release: v3.02) E-mail\n"
129 "arcnet: * me if you have any questions, comments, or bug reports.\n"
134 /* initialize the protocol map */
135 arc_raw_proto
= arc_proto_default
= arc_bcast_proto
= &arc_proto_null
;
136 for (count
= 0; count
< 256; count
++)
137 arc_proto_map
[count
] = arc_proto_default
;
140 printk("arcnet: struct sizes: %Zd %Zd %Zd %Zd %Zd\n",
141 sizeof(struct arc_hardware
), sizeof(struct arc_rfc1201
),
142 sizeof(struct arc_rfc1051
), sizeof(struct arc_eth_encap
),
143 sizeof(struct archdr
));
148 static void __exit
arcnet_exit(void)
152 module_init(arcnet_init
);
153 module_exit(arcnet_exit
);
156 * Dump the contents of an sk_buff
158 #if ARCNET_DEBUG_MAX & D_SKB
159 void arcnet_dump_skb(struct net_device
*dev
,
160 struct sk_buff
*skb
, char *desc
)
164 printk(KERN_DEBUG
"%6s: skb dump (%s) follows:", dev
->name
, desc
);
165 for (i
= 0; i
< skb
->len
; i
++) {
167 printk("\n" KERN_DEBUG
"[%04X] ", i
);
168 printk("%02X ", ((u_char
*) skb
->data
)[i
]);
173 EXPORT_SYMBOL(arcnet_dump_skb
);
178 * Dump the contents of an ARCnet buffer
180 #if (ARCNET_DEBUG_MAX & (D_RX | D_TX))
181 void arcnet_dump_packet(struct net_device
*dev
, int bufnum
, char *desc
,
182 int take_arcnet_lock
)
184 struct arcnet_local
*lp
= dev
->priv
;
186 unsigned long flags
= 0;
187 static uint8_t buf
[512];
189 /* hw.copy_from_card expects IRQ context so take the IRQ lock
190 to keep it single threaded */
192 spin_lock_irqsave(&lp
->lock
, flags
);
194 lp
->hw
.copy_from_card(dev
, bufnum
, 0, buf
, 512);
196 spin_unlock_irqrestore(&lp
->lock
, flags
);
198 /* if the offset[0] byte is nonzero, this is a 256-byte packet */
199 length
= (buf
[2] ? 256 : 512);
201 printk(KERN_DEBUG
"%6s: packet dump (%s) follows:", dev
->name
, desc
);
202 for (i
= 0; i
< length
; i
++) {
204 printk("\n" KERN_DEBUG
"[%04X] ", i
);
205 printk("%02X ", buf
[i
]);
211 EXPORT_SYMBOL(arcnet_dump_packet
);
216 * Unregister a protocol driver from the arc_proto_map. Protocol drivers
217 * are responsible for registering themselves, but the unregister routine
218 * is pretty generic so we'll do it here.
220 void arcnet_unregister_proto(struct ArcProto
*proto
)
224 if (arc_proto_default
== proto
)
225 arc_proto_default
= &arc_proto_null
;
226 if (arc_bcast_proto
== proto
)
227 arc_bcast_proto
= arc_proto_default
;
228 if (arc_raw_proto
== proto
)
229 arc_raw_proto
= arc_proto_default
;
231 for (count
= 0; count
< 256; count
++) {
232 if (arc_proto_map
[count
] == proto
)
233 arc_proto_map
[count
] = arc_proto_default
;
239 * Add a buffer to the queue. Only the interrupt handler is allowed to do
240 * this, unless interrupts are disabled.
242 * Note: we don't check for a full queue, since there aren't enough buffers
243 * to more than fill it.
245 static void release_arcbuf(struct net_device
*dev
, int bufnum
)
247 struct arcnet_local
*lp
= dev
->priv
;
250 lp
->buf_queue
[lp
->first_free_buf
++] = bufnum
;
251 lp
->first_free_buf
%= 5;
254 BUGMSG(D_DURING
, "release_arcbuf: freed #%d; buffer queue is now: ",
256 for (i
= lp
->next_buf
; i
!= lp
->first_free_buf
; i
= (i
+1) % 5)
257 BUGMSG2(D_DURING
, "#%d ", lp
->buf_queue
[i
]);
258 BUGMSG2(D_DURING
, "\n");
264 * Get a buffer from the queue. If this returns -1, there are no buffers
267 static int get_arcbuf(struct net_device
*dev
)
269 struct arcnet_local
*lp
= dev
->priv
;
272 if (!atomic_dec_and_test(&lp
->buf_lock
)) {
273 /* already in this function */
274 BUGMSG(D_NORMAL
, "get_arcbuf: overlap (%d)!\n",
275 lp
->buf_lock
.counter
);
277 else { /* we can continue */
278 if (lp
->next_buf
>= 5)
281 if (lp
->next_buf
== lp
->first_free_buf
)
282 BUGMSG(D_NORMAL
, "get_arcbuf: BUG: no buffers are available??\n");
284 buf
= lp
->buf_queue
[lp
->next_buf
++];
291 BUGMSG(D_DURING
, "get_arcbuf: got #%d; buffer queue is now: ", buf
);
292 for (i
= lp
->next_buf
; i
!= lp
->first_free_buf
; i
= (i
+1) % 5)
293 BUGMSG2(D_DURING
, "#%d ", lp
->buf_queue
[i
]);
294 BUGMSG2(D_DURING
, "\n");
297 atomic_inc(&lp
->buf_lock
);
302 static int choose_mtu(void)
304 int count
, mtu
= 65535;
306 /* choose the smallest MTU of all available encaps */
307 for (count
= 0; count
< 256; count
++) {
308 if (arc_proto_map
[count
] != &arc_proto_null
309 && arc_proto_map
[count
]->mtu
< mtu
) {
310 mtu
= arc_proto_map
[count
]->mtu
;
314 return mtu
== 65535 ? XMTU
: mtu
;
318 /* Setup a struct device for ARCnet. */
319 static void arcdev_setup(struct net_device
*dev
)
321 dev
->type
= ARPHRD_ARCNET
;
322 dev
->hard_header_len
= sizeof(struct archdr
);
323 dev
->mtu
= choose_mtu();
325 dev
->addr_len
= ARCNET_ALEN
;
326 dev
->tx_queue_len
= 100;
327 dev
->broadcast
[0] = 0x00; /* for us, broadcasts are address 0 */
328 dev
->watchdog_timeo
= TX_TIMEOUT
;
330 /* New-style flags. */
331 dev
->flags
= IFF_BROADCAST
;
334 * Put in this stuff here, so we don't have to export the symbols to
335 * the chipset drivers.
337 dev
->open
= arcnet_open
;
338 dev
->stop
= arcnet_close
;
339 dev
->hard_start_xmit
= arcnet_send_packet
;
340 dev
->tx_timeout
= arcnet_timeout
;
341 dev
->get_stats
= arcnet_get_stats
;
342 dev
->hard_header
= arcnet_header
;
343 dev
->rebuild_header
= arcnet_rebuild_header
;
346 struct net_device
*alloc_arcdev(char *name
)
348 struct net_device
*dev
;
350 dev
= alloc_netdev(sizeof(struct arcnet_local
),
351 name
&& *name
? name
: "arc%d", arcdev_setup
);
353 struct arcnet_local
*lp
= (struct arcnet_local
*) dev
->priv
;
354 spin_lock_init(&lp
->lock
);
361 * Open/initialize the board. This is called sometime after booting when
362 * the 'ifconfig' program is run.
364 * This routine should set everything up anew at each open, even registers
365 * that "should" only need to be set once at boot, so that there is
366 * non-reboot way to recover if something goes wrong.
368 static int arcnet_open(struct net_device
*dev
)
370 struct arcnet_local
*lp
= dev
->priv
;
371 int count
, newmtu
, error
;
373 BUGMSG(D_INIT
,"opened.");
375 if (!try_module_get(lp
->hw
.owner
))
380 BUGMSG(D_PROTO
, "protocol map (default is '%c'): ",
381 arc_proto_default
->suffix
);
382 for (count
= 0; count
< 256; count
++)
383 BUGMSG2(D_PROTO
, "%c", arc_proto_map
[count
]->suffix
);
384 BUGMSG2(D_PROTO
, "\n");
388 BUGMSG(D_INIT
, "arcnet_open: resetting card.\n");
390 /* try to put the card in a defined state - if it fails the first
391 * time, actually reset it.
394 if (ARCRESET(0) && ARCRESET(1))
397 newmtu
= choose_mtu();
398 if (newmtu
< dev
->mtu
)
401 BUGMSG(D_INIT
, "arcnet_open: mtu: %d.\n", dev
->mtu
);
403 /* autodetect the encapsulation for each host. */
404 memset(lp
->default_proto
, 0, sizeof(lp
->default_proto
));
406 /* the broadcast address is special - use the 'bcast' protocol */
407 for (count
= 0; count
< 256; count
++) {
408 if (arc_proto_map
[count
] == arc_bcast_proto
) {
409 lp
->default_proto
[0] = count
;
414 /* initialize buffers */
415 atomic_set(&lp
->buf_lock
, 1);
417 lp
->next_buf
= lp
->first_free_buf
= 0;
418 release_arcbuf(dev
, 0);
419 release_arcbuf(dev
, 1);
420 release_arcbuf(dev
, 2);
421 release_arcbuf(dev
, 3);
422 lp
->cur_tx
= lp
->next_tx
= -1;
425 lp
->rfc1201
.sequence
= 1;
427 /* bring up the hardware driver */
431 if (dev
->dev_addr
[0] == 0)
432 BUGMSG(D_NORMAL
, "WARNING! Station address 00 is reserved "
433 "for broadcasts!\n");
434 else if (dev
->dev_addr
[0] == 255)
435 BUGMSG(D_NORMAL
, "WARNING! Station address FF may confuse "
436 "DOS networking programs!\n");
438 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
439 if (ASTATUS() & RESETflag
) {
440 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
441 ACOMMAND(CFLAGScmd
| RESETclear
);
445 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
446 /* make sure we're ready to receive IRQ's. */
448 udelay(1); /* give it time to set the mask before
449 * we reset it again. (may not even be
452 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
453 lp
->intmask
= NORXflag
| RECONflag
;
454 AINTMASK(lp
->intmask
);
455 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
457 netif_start_queue(dev
);
462 module_put(lp
->hw
.owner
);
467 /* The inverse routine to arcnet_open - shuts down the card. */
468 static int arcnet_close(struct net_device
*dev
)
470 struct arcnet_local
*lp
= dev
->priv
;
472 netif_stop_queue(dev
);
474 /* flush TX and disable RX */
476 ACOMMAND(NOTXcmd
); /* stop transmit */
477 ACOMMAND(NORXcmd
); /* disable receive */
480 /* shut down the card */
482 module_put(lp
->hw
.owner
);
487 static int arcnet_header(struct sk_buff
*skb
, struct net_device
*dev
,
488 unsigned short type
, void *daddr
, void *saddr
,
491 struct arcnet_local
*lp
= dev
->priv
;
492 uint8_t _daddr
, proto_num
;
493 struct ArcProto
*proto
;
496 "create header from %d to %d; protocol %d (%Xh); size %u.\n",
497 saddr
? *(uint8_t *) saddr
: -1,
498 daddr
? *(uint8_t *) daddr
: -1,
501 if (skb
->len
!=0 && len
!= skb
->len
)
502 BUGMSG(D_NORMAL
, "arcnet_header: Yikes! skb->len(%d) != len(%d)!\n",
506 /* Type is host order - ? */
507 if(type
== ETH_P_ARCNET
) {
508 proto
= arc_raw_proto
;
509 BUGMSG(D_DEBUG
, "arc_raw_proto used. proto='%c'\n",proto
->suffix
);
510 _daddr
= daddr
? *(uint8_t *) daddr
: 0;
514 * if the dest addr isn't provided, we can't choose an encapsulation!
515 * Store the packet type (eg. ETH_P_IP) for now, and we'll push on a
516 * real header when we do rebuild_header.
518 *(uint16_t *) skb_push(skb
, 2) = type
;
519 if (skb
->nh
.raw
- skb
->mac
.raw
!= 2)
520 BUGMSG(D_NORMAL
, "arcnet_header: Yikes! diff (%d) is not 2!\n",
521 (int)(skb
->nh
.raw
- skb
->mac
.raw
));
522 return -2; /* return error -- can't transmit yet! */
525 /* otherwise, we can just add the header as usual. */
526 _daddr
= *(uint8_t *) daddr
;
527 proto_num
= lp
->default_proto
[_daddr
];
528 proto
= arc_proto_map
[proto_num
];
529 BUGMSG(D_DURING
, "building header for %02Xh using protocol '%c'\n",
530 proto_num
, proto
->suffix
);
531 if (proto
== &arc_proto_null
&& arc_bcast_proto
!= proto
) {
532 BUGMSG(D_DURING
, "actually, let's use '%c' instead.\n",
533 arc_bcast_proto
->suffix
);
534 proto
= arc_bcast_proto
;
537 return proto
->build_header(skb
, dev
, type
, _daddr
);
542 * Rebuild the ARCnet hard header. This is called after an ARP (or in the
543 * future other address resolution) has completed on this sk_buff. We now
544 * let ARP fill in the destination field.
546 static int arcnet_rebuild_header(struct sk_buff
*skb
)
548 struct net_device
*dev
= skb
->dev
;
549 struct arcnet_local
*lp
= dev
->priv
;
550 int status
= 0; /* default is failure */
553 struct ArcProto
*proto
;
555 if (skb
->nh
.raw
- skb
->mac
.raw
!= 2) {
557 "rebuild_header: shouldn't be here! (hdrsize=%d)\n",
558 (int)(skb
->nh
.raw
- skb
->mac
.raw
));
561 type
= *(uint16_t *) skb_pull(skb
, 2);
562 BUGMSG(D_DURING
, "rebuild header for protocol %Xh\n", type
);
564 if (type
== ETH_P_IP
) {
566 BUGMSG(D_DURING
, "rebuild header for ethernet protocol %Xh\n", type
);
567 status
= arp_find(&daddr
, skb
) ? 1 : 0;
568 BUGMSG(D_DURING
, " rebuilt: dest is %d; protocol %Xh\n",
573 "I don't understand ethernet protocol %Xh addresses!\n", type
);
574 lp
->stats
.tx_errors
++;
575 lp
->stats
.tx_aborted_errors
++;
578 /* if we couldn't resolve the address... give up. */
582 /* add the _real_ header this time! */
583 proto
= arc_proto_map
[lp
->default_proto
[daddr
]];
584 proto
->build_header(skb
, dev
, type
, daddr
);
586 return 1; /* success */
591 /* Called by the kernel in order to transmit a packet. */
592 static int arcnet_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
594 struct arcnet_local
*lp
= dev
->priv
;
596 struct arc_rfc1201
*soft
;
597 struct ArcProto
*proto
;
603 "transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n",
604 ASTATUS(), lp
->cur_tx
, lp
->next_tx
, skb
->len
,skb
->protocol
);
606 pkt
= (struct archdr
*) skb
->data
;
607 soft
= &pkt
->soft
.rfc1201
;
608 proto
= arc_proto_map
[soft
->proto
];
610 BUGMSG(D_SKB_SIZE
, "skb: transmitting %d bytes to %02X\n",
611 skb
->len
, pkt
->hard
.dest
);
612 BUGLVL(D_SKB
) arcnet_dump_skb(dev
, skb
, "tx");
614 /* fits in one packet? */
615 if (skb
->len
- ARC_HDR_SIZE
> XMTU
&& !proto
->continue_tx
) {
616 BUGMSG(D_NORMAL
, "fixme: packet too large: compensating badly!\n");
618 return NETDEV_TX_OK
; /* don't try again */
621 /* We're busy transmitting a packet... */
622 netif_stop_queue(dev
);
624 spin_lock_irqsave(&lp
->lock
, flags
);
626 if(lp
->next_tx
== -1)
627 txbuf
= get_arcbuf(dev
);
632 if (proto
->prepare_tx(dev
, pkt
, skb
->len
, txbuf
) &&
634 /* done right away and we don't want to acknowledge
635 the package later - forget about it now */
636 lp
->stats
.tx_bytes
+= skb
->len
;
639 /* do it the 'split' way */
640 lp
->outgoing
.proto
= proto
;
641 lp
->outgoing
.skb
= skb
;
642 lp
->outgoing
.pkt
= pkt
;
646 if (proto
->continue_tx
&&
647 proto
->continue_tx(dev
, txbuf
)) {
649 "bug! continue_tx finished the first time! "
650 "(proto='%c')\n", proto
->suffix
);
653 retval
= NETDEV_TX_OK
;
654 dev
->trans_start
= jiffies
;
657 retval
= NETDEV_TX_BUSY
;
661 BUGMSG(D_DEBUG
, "%s: %d: %s, status: %x\n",__FILE__
,__LINE__
,__FUNCTION__
,ASTATUS());
662 /* make sure we didn't ignore a TX IRQ while we were in here */
665 BUGMSG(D_DEBUG
, "%s: %d: %s\n",__FILE__
,__LINE__
,__FUNCTION__
);
666 lp
->intmask
|= TXFREEflag
|EXCNAKflag
;
667 AINTMASK(lp
->intmask
);
668 BUGMSG(D_DEBUG
, "%s: %d: %s, status: %x\n",__FILE__
,__LINE__
,__FUNCTION__
,ASTATUS());
670 spin_unlock_irqrestore(&lp
->lock
, flags
);
674 return retval
; /* no need to try again */
679 * Actually start transmitting a packet that was loaded into a buffer
680 * by prepare_tx. This should _only_ be called by the interrupt handler.
682 static int go_tx(struct net_device
*dev
)
684 struct arcnet_local
*lp
= dev
->priv
;
686 BUGMSG(D_DURING
, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%d\n",
687 ASTATUS(), lp
->intmask
, lp
->next_tx
, lp
->cur_tx
);
689 if (lp
->cur_tx
!= -1 || lp
->next_tx
== -1)
692 BUGLVL(D_TX
) arcnet_dump_packet(dev
, lp
->next_tx
, "go_tx", 0);
694 lp
->cur_tx
= lp
->next_tx
;
698 ACOMMAND(TXcmd
| (lp
->cur_tx
<< 3));
700 lp
->stats
.tx_packets
++;
701 lp
->lasttrans_dest
= lp
->lastload_dest
;
702 lp
->lastload_dest
= 0;
703 lp
->excnak_pending
= 0;
704 lp
->intmask
|= TXFREEflag
|EXCNAKflag
;
710 /* Called by the kernel when transmit times out */
711 static void arcnet_timeout(struct net_device
*dev
)
714 struct arcnet_local
*lp
= dev
->priv
;
715 int status
= ASTATUS();
718 spin_lock_irqsave(&lp
->lock
, flags
);
719 if (status
& TXFREEflag
) { /* transmit _DID_ finish */
720 msg
= " - missed IRQ?";
723 lp
->stats
.tx_aborted_errors
++;
725 ACOMMAND(NOTXcmd
| (lp
->cur_tx
<< 3));
727 lp
->stats
.tx_errors
++;
729 /* make sure we didn't miss a TX or a EXC NAK IRQ */
731 lp
->intmask
|= TXFREEflag
|EXCNAKflag
;
732 AINTMASK(lp
->intmask
);
734 spin_unlock_irqrestore(&lp
->lock
, flags
);
736 if (jiffies
- lp
->last_timeout
> 10*HZ
) {
737 BUGMSG(D_EXTRA
, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)\n",
738 msg
, status
, lp
->intmask
, lp
->lasttrans_dest
);
739 lp
->last_timeout
= jiffies
;
742 if (lp
->cur_tx
== -1)
743 netif_wake_queue(dev
);
748 * The typical workload of the driver: Handle the network interface
749 * interrupts. Establish which device needs attention, and call the correct
750 * chipset interrupt handler.
752 irqreturn_t
arcnet_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
754 struct net_device
*dev
= dev_id
;
755 struct arcnet_local
*lp
;
756 int recbuf
, status
, diagstatus
, didsomething
, boguscount
;
757 int retval
= IRQ_NONE
;
759 BUGMSG(D_DURING
, "\n");
761 BUGMSG(D_DURING
, "in arcnet_interrupt\n");
767 spin_lock(&lp
->lock
);
770 * RESET flag was enabled - if device is not running, we must clear it right
771 * away (but nothing else).
773 if (!netif_running(dev
)) {
774 if (ASTATUS() & RESETflag
)
775 ACOMMAND(CFLAGScmd
| RESETclear
);
777 spin_unlock(&lp
->lock
);
781 BUGMSG(D_DURING
, "in arcnet_inthandler (status=%Xh, intmask=%Xh)\n",
782 ASTATUS(), lp
->intmask
);
787 diagstatus
= (status
>> 8) & 0xFF;
789 BUGMSG(D_DEBUG
, "%s: %d: %s: status=%x\n",
790 __FILE__
,__LINE__
,__FUNCTION__
,status
);
794 * RESET flag was enabled - card is resetting and if RX is
795 * disabled, it's NOT because we just got a packet.
797 * The card is in an undefined state. Clear it out and start over.
799 if (status
& RESETflag
) {
800 BUGMSG(D_NORMAL
, "spurious reset (status=%Xh)\n", status
);
804 /* get out of the interrupt handler! */
808 * RX is inhibited - we must have received something. Prepare to
809 * receive into the next buffer.
811 * We don't actually copy the received packet from the card until
812 * after the transmit handler runs (and possibly launches the next
813 * tx); this should improve latency slightly if we get both types
814 * of interrupts at once.
817 if (status
& lp
->intmask
& NORXflag
) {
819 BUGMSG(D_DURING
, "Buffer #%d: receive irq (status=%Xh)\n",
822 lp
->cur_rx
= get_arcbuf(dev
);
823 if (lp
->cur_rx
!= -1) {
824 BUGMSG(D_DURING
, "enabling receive to buffer #%d\n",
826 ACOMMAND(RXcmd
| (lp
->cur_rx
<< 3) | RXbcasts
);
831 if((diagstatus
& EXCNAKflag
)) {
832 BUGMSG(D_DURING
, "EXCNAK IRQ (diagstat=%Xh)\n",
835 ACOMMAND(NOTXcmd
); /* disable transmit */
836 lp
->excnak_pending
= 1;
838 ACOMMAND(EXCNAKclear
);
839 lp
->intmask
&= ~(EXCNAKflag
);
844 /* a transmit finished, and we're interested in it. */
845 if ((status
& lp
->intmask
& TXFREEflag
) || lp
->timed_out
) {
846 lp
->intmask
&= ~(TXFREEflag
|EXCNAKflag
);
848 BUGMSG(D_DURING
, "TX IRQ (stat=%Xh)\n", status
);
850 if (lp
->cur_tx
!= -1 && !lp
->timed_out
) {
851 if(!(status
& TXACKflag
)) {
852 if (lp
->lasttrans_dest
!= 0) {
854 "transmit was not acknowledged! "
855 "(status=%Xh, dest=%02Xh)\n",
856 status
, lp
->lasttrans_dest
);
857 lp
->stats
.tx_errors
++;
858 lp
->stats
.tx_carrier_errors
++;
861 "broadcast was not acknowledged; that's normal "
862 "(status=%Xh, dest=%02Xh)\n",
863 status
, lp
->lasttrans_dest
);
867 if (lp
->outgoing
.proto
&&
868 lp
->outgoing
.proto
->ack_tx
) {
870 if(status
& TXACKflag
)
872 else if(lp
->excnak_pending
)
878 ->ack_tx(dev
, ackstatus
);
881 if (lp
->cur_tx
!= -1)
882 release_arcbuf(dev
, lp
->cur_tx
);
888 /* send another packet if there is one */
891 /* continue a split packet, if any */
892 if (lp
->outgoing
.proto
&& lp
->outgoing
.proto
->continue_tx
) {
893 int txbuf
= get_arcbuf(dev
);
895 if (lp
->outgoing
.proto
->continue_tx(dev
, txbuf
)) {
896 /* that was the last segment */
897 lp
->stats
.tx_bytes
+= lp
->outgoing
.skb
->len
;
898 if(!lp
->outgoing
.proto
->ack_tx
)
900 dev_kfree_skb_irq(lp
->outgoing
.skb
);
901 lp
->outgoing
.proto
= NULL
;
907 /* inform upper layers of idleness, if necessary */
908 if (lp
->cur_tx
== -1)
909 netif_wake_queue(dev
);
911 /* now process the received packet, if any */
913 BUGLVL(D_RX
) arcnet_dump_packet(dev
, recbuf
, "rx irq", 0);
915 arcnet_rx(dev
, recbuf
);
916 release_arcbuf(dev
, recbuf
);
920 if (status
& lp
->intmask
& RECONflag
) {
921 ACOMMAND(CFLAGScmd
| CONFIGclear
);
922 lp
->stats
.tx_carrier_errors
++;
924 BUGMSG(D_RECON
, "Network reconfiguration detected (status=%Xh)\n",
926 /* MYRECON bit is at bit 7 of diagstatus */
927 if(diagstatus
& 0x80)
928 BUGMSG(D_RECON
,"Put out that recon myself\n");
930 /* is the RECON info empty or old? */
931 if (!lp
->first_recon
|| !lp
->last_recon
||
932 jiffies
- lp
->last_recon
> HZ
* 10) {
933 if (lp
->network_down
)
934 BUGMSG(D_NORMAL
, "reconfiguration detected: cabling restored?\n");
935 lp
->first_recon
= lp
->last_recon
= jiffies
;
936 lp
->num_recons
= lp
->network_down
= 0;
938 BUGMSG(D_DURING
, "recon: clearing counters.\n");
939 } else { /* add to current RECON counter */
940 lp
->last_recon
= jiffies
;
943 BUGMSG(D_DURING
, "recon: counter=%d, time=%lds, net=%d\n",
945 (lp
->last_recon
- lp
->first_recon
) / HZ
,
948 /* if network is marked up;
949 * and first_recon and last_recon are 60+ apart;
950 * and the average no. of recons counted is
951 * > RECON_THRESHOLD/min;
952 * then print a warning message.
954 if (!lp
->network_down
955 && (lp
->last_recon
- lp
->first_recon
) <= HZ
* 60
956 && lp
->num_recons
>= RECON_THRESHOLD
) {
957 lp
->network_down
= 1;
958 BUGMSG(D_NORMAL
, "many reconfigurations detected: cabling problem?\n");
959 } else if (!lp
->network_down
960 && lp
->last_recon
- lp
->first_recon
> HZ
* 60) {
961 /* reset counters if we've gone for over a minute. */
962 lp
->first_recon
= lp
->last_recon
;
966 } else if (lp
->network_down
&& jiffies
- lp
->last_recon
> HZ
* 10) {
967 if (lp
->network_down
)
968 BUGMSG(D_NORMAL
, "cabling restored?\n");
969 lp
->first_recon
= lp
->last_recon
= 0;
970 lp
->num_recons
= lp
->network_down
= 0;
972 BUGMSG(D_DURING
, "not recon: clearing counters anyway.\n");
976 retval
|= IRQ_HANDLED
;
979 while (--boguscount
&& didsomething
);
981 BUGMSG(D_DURING
, "arcnet_interrupt complete (status=%Xh, count=%d)\n",
982 ASTATUS(), boguscount
);
983 BUGMSG(D_DURING
, "\n");
988 AINTMASK(lp
->intmask
);
990 spin_unlock(&lp
->lock
);
996 * This is a generic packet receiver that calls arcnet??_rx depending on the
999 void arcnet_rx(struct net_device
*dev
, int bufnum
)
1001 struct arcnet_local
*lp
= dev
->priv
;
1003 struct arc_rfc1201
*soft
;
1006 soft
= &pkt
.soft
.rfc1201
;
1008 lp
->hw
.copy_from_card(dev
, bufnum
, 0, &pkt
, sizeof(ARC_HDR_SIZE
));
1009 if (pkt
.hard
.offset
[0]) {
1010 ofs
= pkt
.hard
.offset
[0];
1013 ofs
= pkt
.hard
.offset
[1];
1017 /* get the full header, if possible */
1018 if (sizeof(pkt
.soft
) <= length
)
1019 lp
->hw
.copy_from_card(dev
, bufnum
, ofs
, soft
, sizeof(pkt
.soft
));
1021 memset(&pkt
.soft
, 0, sizeof(pkt
.soft
));
1022 lp
->hw
.copy_from_card(dev
, bufnum
, ofs
, soft
, length
);
1025 BUGMSG(D_DURING
, "Buffer #%d: received packet from %02Xh to %02Xh "
1027 bufnum
, pkt
.hard
.source
, pkt
.hard
.dest
, length
);
1029 lp
->stats
.rx_packets
++;
1030 lp
->stats
.rx_bytes
+= length
+ ARC_HDR_SIZE
;
1032 /* call the right receiver for the protocol */
1033 if (arc_proto_map
[soft
->proto
]->is_ip
) {
1036 *oldp
= arc_proto_map
[lp
->default_proto
[pkt
.hard
.source
]],
1037 *newp
= arc_proto_map
[soft
->proto
];
1041 "got protocol %02Xh; encap for host %02Xh is now '%c'"
1042 " (was '%c')\n", soft
->proto
, pkt
.hard
.source
,
1043 newp
->suffix
, oldp
->suffix
);
1047 /* broadcasts will always be done with the last-used encap. */
1048 lp
->default_proto
[0] = soft
->proto
;
1050 /* in striking contrast, the following isn't a hack. */
1051 lp
->default_proto
[pkt
.hard
.source
] = soft
->proto
;
1053 /* call the protocol-specific receiver. */
1054 arc_proto_map
[soft
->proto
]->rx(dev
, bufnum
, &pkt
, length
);
1060 * Get the current statistics. This may be called with the card open or
1063 static struct net_device_stats
*arcnet_get_stats(struct net_device
*dev
)
1065 struct arcnet_local
*lp
= dev
->priv
;
1070 static void null_rx(struct net_device
*dev
, int bufnum
,
1071 struct archdr
*pkthdr
, int length
)
1074 "rx: don't know how to deal with proto %02Xh from host %02Xh.\n",
1075 pkthdr
->soft
.rfc1201
.proto
, pkthdr
->hard
.source
);
1079 static int null_build_header(struct sk_buff
*skb
, struct net_device
*dev
,
1080 unsigned short type
, uint8_t daddr
)
1082 struct arcnet_local
*lp
= dev
->priv
;
1085 "tx: can't build header for encap %02Xh; load a protocol driver.\n",
1086 lp
->default_proto
[daddr
]);
1093 /* the "do nothing" prepare_tx function warns that there's nothing to do. */
1094 static int null_prepare_tx(struct net_device
*dev
, struct archdr
*pkt
,
1095 int length
, int bufnum
)
1097 struct arcnet_local
*lp
= dev
->priv
;
1098 struct arc_hardware newpkt
;
1100 BUGMSG(D_PROTO
, "tx: no encap for this host; load a protocol driver.\n");
1102 /* send a packet to myself -- will never get received, of course */
1103 newpkt
.source
= newpkt
.dest
= dev
->dev_addr
[0];
1105 /* only one byte of actual data (and it's random) */
1106 newpkt
.offset
[0] = 0xFF;
1108 lp
->hw
.copy_to_card(dev
, bufnum
, 0, &newpkt
, ARC_HDR_SIZE
);
1110 return 1; /* done */