1 /* 2 * Linux ARCnet driver - device-independent routines 3 * 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. 8 * 9 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com) 10 * for sponsoring the further development of this driver. 11 * 12 * ********************** 13 * 14 * The original copyright was as follows: 15 * 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. 21 * 22 * ********************** 23 * 24 * The change log is now in a file called ChangeLog in this directory. 25 * 26 * Sources: 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 41 * <jojo@repas.de> 42 */ 43 44 #define VERSION "arcnet: v3.94 BETA 2007/02/08 - by Avery Pennarun et al.\n" 45 46 #include <linux/module.h> 47 #include <linux/types.h> 48 #include <linux/delay.h> 49 #include <linux/netdevice.h> 50 #include <linux/if_arp.h> 51 #include <net/arp.h> 52 #include <linux/init.h> 53 #include <linux/arcdevice.h> 54 #include <linux/jiffies.h> 55 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); 63 64 static void arcnet_rx(struct net_device *dev, int bufnum); 65 66 /* 67 * one ArcProto per possible proto ID. None of the elements of 68 * arc_proto_map are allowed to be NULL; they will get set to 69 * arc_proto_default instead. It also must not be NULL; if you would like 70 * to set it to NULL, set it to &arc_proto_null instead. 71 */ 72 struct ArcProto *arc_proto_map[256], *arc_proto_default, 73 *arc_bcast_proto, *arc_raw_proto; 74 75 static struct ArcProto arc_proto_null = 76 { 77 .suffix = '?', 78 .mtu = XMTU, 79 .is_ip = 0, 80 .rx = null_rx, 81 .build_header = null_build_header, 82 .prepare_tx = null_prepare_tx, 83 .continue_tx = NULL, 84 .ack_tx = NULL 85 }; 86 87 /* Exported function prototypes */ 88 int arcnet_debug = ARCNET_DEBUG; 89 90 EXPORT_SYMBOL(arc_proto_map); 91 EXPORT_SYMBOL(arc_proto_default); 92 EXPORT_SYMBOL(arc_bcast_proto); 93 EXPORT_SYMBOL(arc_raw_proto); 94 EXPORT_SYMBOL(arcnet_unregister_proto); 95 EXPORT_SYMBOL(arcnet_debug); 96 EXPORT_SYMBOL(alloc_arcdev); 97 EXPORT_SYMBOL(arcnet_interrupt); 98 EXPORT_SYMBOL(arcnet_open); 99 EXPORT_SYMBOL(arcnet_close); 100 EXPORT_SYMBOL(arcnet_send_packet); 101 EXPORT_SYMBOL(arcnet_timeout); 102 103 /* Internal function prototypes */ 104 static int arcnet_header(struct sk_buff *skb, struct net_device *dev, 105 unsigned short type, const void *daddr, 106 const void *saddr, unsigned len); 107 static int go_tx(struct net_device *dev); 108 109 static int debug = ARCNET_DEBUG; 110 module_param(debug, int, 0); 111 MODULE_LICENSE("GPL"); 112 113 static int __init arcnet_init(void) 114 { 115 int count; 116 117 arcnet_debug = debug; 118 119 printk("arcnet loaded.\n"); 120 121 #ifdef ALPHA_WARNING 122 BUGLVL(D_EXTRA) { 123 printk("arcnet: ***\n" 124 "arcnet: * Read arcnet.txt for important release notes!\n" 125 "arcnet: *\n" 126 "arcnet: * This is an ALPHA version! (Last stable release: v3.02) E-mail\n" 127 "arcnet: * me if you have any questions, comments, or bug reports.\n" 128 "arcnet: ***\n"); 129 } 130 #endif 131 132 /* initialize the protocol map */ 133 arc_raw_proto = arc_proto_default = arc_bcast_proto = &arc_proto_null; 134 for (count = 0; count < 256; count++) 135 arc_proto_map[count] = arc_proto_default; 136 137 BUGLVL(D_DURING) 138 printk("arcnet: struct sizes: %Zd %Zd %Zd %Zd %Zd\n", 139 sizeof(struct arc_hardware), sizeof(struct arc_rfc1201), 140 sizeof(struct arc_rfc1051), sizeof(struct arc_eth_encap), 141 sizeof(struct archdr)); 142 143 return 0; 144 } 145 146 static void __exit arcnet_exit(void) 147 { 148 } 149 150 module_init(arcnet_init); 151 module_exit(arcnet_exit); 152 153 /* 154 * Dump the contents of an sk_buff 155 */ 156 #if ARCNET_DEBUG_MAX & D_SKB 157 void arcnet_dump_skb(struct net_device *dev, 158 struct sk_buff *skb, char *desc) 159 { 160 char hdr[32]; 161 162 /* dump the packet */ 163 snprintf(hdr, sizeof(hdr), "%6s:%s skb->data:", dev->name, desc); 164 print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET, 165 16, 1, skb->data, skb->len, true); 166 } 167 168 EXPORT_SYMBOL(arcnet_dump_skb); 169 #endif 170 171 172 /* 173 * Dump the contents of an ARCnet buffer 174 */ 175 #if (ARCNET_DEBUG_MAX & (D_RX | D_TX)) 176 static void arcnet_dump_packet(struct net_device *dev, int bufnum, 177 char *desc, int take_arcnet_lock) 178 { 179 struct arcnet_local *lp = netdev_priv(dev); 180 int i, length; 181 unsigned long flags = 0; 182 static uint8_t buf[512]; 183 char hdr[32]; 184 185 /* hw.copy_from_card expects IRQ context so take the IRQ lock 186 to keep it single threaded */ 187 if(take_arcnet_lock) 188 spin_lock_irqsave(&lp->lock, flags); 189 190 lp->hw.copy_from_card(dev, bufnum, 0, buf, 512); 191 if(take_arcnet_lock) 192 spin_unlock_irqrestore(&lp->lock, flags); 193 194 /* if the offset[0] byte is nonzero, this is a 256-byte packet */ 195 length = (buf[2] ? 256 : 512); 196 197 /* dump the packet */ 198 snprintf(hdr, sizeof(hdr), "%6s:%s packet dump:", dev->name, desc); 199 print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET, 200 16, 1, buf, length, true); 201 } 202 203 #else 204 205 #define arcnet_dump_packet(dev, bufnum, desc,take_arcnet_lock) do { } while (0) 206 207 #endif 208 209 210 /* 211 * Unregister a protocol driver from the arc_proto_map. Protocol drivers 212 * are responsible for registering themselves, but the unregister routine 213 * is pretty generic so we'll do it here. 214 */ 215 void arcnet_unregister_proto(struct ArcProto *proto) 216 { 217 int count; 218 219 if (arc_proto_default == proto) 220 arc_proto_default = &arc_proto_null; 221 if (arc_bcast_proto == proto) 222 arc_bcast_proto = arc_proto_default; 223 if (arc_raw_proto == proto) 224 arc_raw_proto = arc_proto_default; 225 226 for (count = 0; count < 256; count++) { 227 if (arc_proto_map[count] == proto) 228 arc_proto_map[count] = arc_proto_default; 229 } 230 } 231 232 233 /* 234 * Add a buffer to the queue. Only the interrupt handler is allowed to do 235 * this, unless interrupts are disabled. 236 * 237 * Note: we don't check for a full queue, since there aren't enough buffers 238 * to more than fill it. 239 */ 240 static void release_arcbuf(struct net_device *dev, int bufnum) 241 { 242 struct arcnet_local *lp = netdev_priv(dev); 243 int i; 244 245 lp->buf_queue[lp->first_free_buf++] = bufnum; 246 lp->first_free_buf %= 5; 247 248 BUGLVL(D_DURING) { 249 BUGMSG(D_DURING, "release_arcbuf: freed #%d; buffer queue is now: ", 250 bufnum); 251 for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5) 252 BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]); 253 BUGMSG2(D_DURING, "\n"); 254 } 255 } 256 257 258 /* 259 * Get a buffer from the queue. If this returns -1, there are no buffers 260 * available. 261 */ 262 static int get_arcbuf(struct net_device *dev) 263 { 264 struct arcnet_local *lp = netdev_priv(dev); 265 int buf = -1, i; 266 267 if (!atomic_dec_and_test(&lp->buf_lock)) { 268 /* already in this function */ 269 BUGMSG(D_NORMAL, "get_arcbuf: overlap (%d)!\n", 270 lp->buf_lock.counter); 271 } 272 else { /* we can continue */ 273 if (lp->next_buf >= 5) 274 lp->next_buf -= 5; 275 276 if (lp->next_buf == lp->first_free_buf) 277 BUGMSG(D_NORMAL, "get_arcbuf: BUG: no buffers are available??\n"); 278 else { 279 buf = lp->buf_queue[lp->next_buf++]; 280 lp->next_buf %= 5; 281 } 282 } 283 284 285 BUGLVL(D_DURING) { 286 BUGMSG(D_DURING, "get_arcbuf: got #%d; buffer queue is now: ", buf); 287 for (i = lp->next_buf; i != lp->first_free_buf; i = (i+1) % 5) 288 BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]); 289 BUGMSG2(D_DURING, "\n"); 290 } 291 292 atomic_inc(&lp->buf_lock); 293 return buf; 294 } 295 296 297 static int choose_mtu(void) 298 { 299 int count, mtu = 65535; 300 301 /* choose the smallest MTU of all available encaps */ 302 for (count = 0; count < 256; count++) { 303 if (arc_proto_map[count] != &arc_proto_null && 304 arc_proto_map[count]->mtu < mtu) { 305 mtu = arc_proto_map[count]->mtu; 306 } 307 } 308 309 return mtu == 65535 ? XMTU : mtu; 310 } 311 312 static const struct header_ops arcnet_header_ops = { 313 .create = arcnet_header, 314 }; 315 316 static const struct net_device_ops arcnet_netdev_ops = { 317 .ndo_open = arcnet_open, 318 .ndo_stop = arcnet_close, 319 .ndo_start_xmit = arcnet_send_packet, 320 .ndo_tx_timeout = arcnet_timeout, 321 }; 322 323 /* Setup a struct device for ARCnet. */ 324 static void arcdev_setup(struct net_device *dev) 325 { 326 dev->type = ARPHRD_ARCNET; 327 dev->netdev_ops = &arcnet_netdev_ops; 328 dev->header_ops = &arcnet_header_ops; 329 dev->hard_header_len = sizeof(struct archdr); 330 dev->mtu = choose_mtu(); 331 332 dev->addr_len = ARCNET_ALEN; 333 dev->tx_queue_len = 100; 334 dev->broadcast[0] = 0x00; /* for us, broadcasts are address 0 */ 335 dev->watchdog_timeo = TX_TIMEOUT; 336 337 /* New-style flags. */ 338 dev->flags = IFF_BROADCAST; 339 340 } 341 342 struct net_device *alloc_arcdev(const char *name) 343 { 344 struct net_device *dev; 345 346 dev = alloc_netdev(sizeof(struct arcnet_local), 347 name && *name ? name : "arc%d", NET_NAME_UNKNOWN, 348 arcdev_setup); 349 if(dev) { 350 struct arcnet_local *lp = netdev_priv(dev); 351 spin_lock_init(&lp->lock); 352 } 353 354 return dev; 355 } 356 357 /* 358 * Open/initialize the board. This is called sometime after booting when 359 * the 'ifconfig' program is run. 360 * 361 * This routine should set everything up anew at each open, even registers 362 * that "should" only need to be set once at boot, so that there is 363 * non-reboot way to recover if something goes wrong. 364 */ 365 int arcnet_open(struct net_device *dev) 366 { 367 struct arcnet_local *lp = netdev_priv(dev); 368 int count, newmtu, error; 369 370 BUGMSG(D_INIT,"opened."); 371 372 if (!try_module_get(lp->hw.owner)) 373 return -ENODEV; 374 375 BUGLVL(D_PROTO) { 376 BUGMSG(D_PROTO, "protocol map (default is '%c'): ", 377 arc_proto_default->suffix); 378 for (count = 0; count < 256; count++) 379 BUGMSG2(D_PROTO, "%c", arc_proto_map[count]->suffix); 380 BUGMSG2(D_PROTO, "\n"); 381 } 382 383 384 BUGMSG(D_INIT, "arcnet_open: resetting card.\n"); 385 386 /* try to put the card in a defined state - if it fails the first 387 * time, actually reset it. 388 */ 389 error = -ENODEV; 390 if (ARCRESET(0) && ARCRESET(1)) 391 goto out_module_put; 392 393 newmtu = choose_mtu(); 394 if (newmtu < dev->mtu) 395 dev->mtu = newmtu; 396 397 BUGMSG(D_INIT, "arcnet_open: mtu: %d.\n", dev->mtu); 398 399 /* autodetect the encapsulation for each host. */ 400 memset(lp->default_proto, 0, sizeof(lp->default_proto)); 401 402 /* the broadcast address is special - use the 'bcast' protocol */ 403 for (count = 0; count < 256; count++) { 404 if (arc_proto_map[count] == arc_bcast_proto) { 405 lp->default_proto[0] = count; 406 break; 407 } 408 } 409 410 /* initialize buffers */ 411 atomic_set(&lp->buf_lock, 1); 412 413 lp->next_buf = lp->first_free_buf = 0; 414 release_arcbuf(dev, 0); 415 release_arcbuf(dev, 1); 416 release_arcbuf(dev, 2); 417 release_arcbuf(dev, 3); 418 lp->cur_tx = lp->next_tx = -1; 419 lp->cur_rx = -1; 420 421 lp->rfc1201.sequence = 1; 422 423 /* bring up the hardware driver */ 424 if (lp->hw.open) 425 lp->hw.open(dev); 426 427 if (dev->dev_addr[0] == 0) 428 BUGMSG(D_NORMAL, "WARNING! Station address 00 is reserved " 429 "for broadcasts!\n"); 430 else if (dev->dev_addr[0] == 255) 431 BUGMSG(D_NORMAL, "WARNING! Station address FF may confuse " 432 "DOS networking programs!\n"); 433 434 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 435 if (ASTATUS() & RESETflag) { 436 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 437 ACOMMAND(CFLAGScmd | RESETclear); 438 } 439 440 441 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 442 /* make sure we're ready to receive IRQ's. */ 443 AINTMASK(0); 444 udelay(1); /* give it time to set the mask before 445 * we reset it again. (may not even be 446 * necessary) 447 */ 448 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 449 lp->intmask = NORXflag | RECONflag; 450 AINTMASK(lp->intmask); 451 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 452 453 netif_start_queue(dev); 454 455 return 0; 456 457 out_module_put: 458 module_put(lp->hw.owner); 459 return error; 460 } 461 462 463 /* The inverse routine to arcnet_open - shuts down the card. */ 464 int arcnet_close(struct net_device *dev) 465 { 466 struct arcnet_local *lp = netdev_priv(dev); 467 468 netif_stop_queue(dev); 469 470 /* flush TX and disable RX */ 471 AINTMASK(0); 472 ACOMMAND(NOTXcmd); /* stop transmit */ 473 ACOMMAND(NORXcmd); /* disable receive */ 474 mdelay(1); 475 476 /* shut down the card */ 477 lp->hw.close(dev); 478 module_put(lp->hw.owner); 479 return 0; 480 } 481 482 483 static int arcnet_header(struct sk_buff *skb, struct net_device *dev, 484 unsigned short type, const void *daddr, 485 const void *saddr, unsigned len) 486 { 487 const struct arcnet_local *lp = netdev_priv(dev); 488 uint8_t _daddr, proto_num; 489 struct ArcProto *proto; 490 491 BUGMSG(D_DURING, 492 "create header from %d to %d; protocol %d (%Xh); size %u.\n", 493 saddr ? *(uint8_t *) saddr : -1, 494 daddr ? *(uint8_t *) daddr : -1, 495 type, type, len); 496 497 if (skb->len!=0 && len != skb->len) 498 BUGMSG(D_NORMAL, "arcnet_header: Yikes! skb->len(%d) != len(%d)!\n", 499 skb->len, len); 500 501 502 /* Type is host order - ? */ 503 if(type == ETH_P_ARCNET) { 504 proto = arc_raw_proto; 505 BUGMSG(D_DEBUG, "arc_raw_proto used. proto='%c'\n",proto->suffix); 506 _daddr = daddr ? *(uint8_t *) daddr : 0; 507 } 508 else if (!daddr) { 509 /* 510 * if the dest addr isn't provided, we can't choose an encapsulation! 511 * Store the packet type (eg. ETH_P_IP) for now, and we'll push on a 512 * real header when we do rebuild_header. 513 */ 514 *(uint16_t *) skb_push(skb, 2) = type; 515 /* 516 * XXX: Why not use skb->mac_len? 517 */ 518 if (skb->network_header - skb->mac_header != 2) 519 BUGMSG(D_NORMAL, "arcnet_header: Yikes! diff (%d) is not 2!\n", 520 (int)(skb->network_header - skb->mac_header)); 521 return -2; /* return error -- can't transmit yet! */ 522 } 523 else { 524 /* otherwise, we can just add the header as usual. */ 525 _daddr = *(uint8_t *) daddr; 526 proto_num = lp->default_proto[_daddr]; 527 proto = arc_proto_map[proto_num]; 528 BUGMSG(D_DURING, "building header for %02Xh using protocol '%c'\n", 529 proto_num, proto->suffix); 530 if (proto == &arc_proto_null && arc_bcast_proto != proto) { 531 BUGMSG(D_DURING, "actually, let's use '%c' instead.\n", 532 arc_bcast_proto->suffix); 533 proto = arc_bcast_proto; 534 } 535 } 536 return proto->build_header(skb, dev, type, _daddr); 537 } 538 539 /* Called by the kernel in order to transmit a packet. */ 540 netdev_tx_t arcnet_send_packet(struct sk_buff *skb, 541 struct net_device *dev) 542 { 543 struct arcnet_local *lp = netdev_priv(dev); 544 struct archdr *pkt; 545 struct arc_rfc1201 *soft; 546 struct ArcProto *proto; 547 int txbuf; 548 unsigned long flags; 549 int freeskb, retval; 550 551 BUGMSG(D_DURING, 552 "transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n", 553 ASTATUS(), lp->cur_tx, lp->next_tx, skb->len,skb->protocol); 554 555 pkt = (struct archdr *) skb->data; 556 soft = &pkt->soft.rfc1201; 557 proto = arc_proto_map[soft->proto]; 558 559 BUGMSG(D_SKB_SIZE, "skb: transmitting %d bytes to %02X\n", 560 skb->len, pkt->hard.dest); 561 BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "tx"); 562 563 /* fits in one packet? */ 564 if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) { 565 BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!\n"); 566 dev_kfree_skb(skb); 567 return NETDEV_TX_OK; /* don't try again */ 568 } 569 570 /* We're busy transmitting a packet... */ 571 netif_stop_queue(dev); 572 573 spin_lock_irqsave(&lp->lock, flags); 574 AINTMASK(0); 575 if(lp->next_tx == -1) 576 txbuf = get_arcbuf(dev); 577 else { 578 txbuf = -1; 579 } 580 if (txbuf != -1) { 581 if (proto->prepare_tx(dev, pkt, skb->len, txbuf) && 582 !proto->ack_tx) { 583 /* done right away and we don't want to acknowledge 584 the package later - forget about it now */ 585 dev->stats.tx_bytes += skb->len; 586 freeskb = 1; 587 } else { 588 /* do it the 'split' way */ 589 lp->outgoing.proto = proto; 590 lp->outgoing.skb = skb; 591 lp->outgoing.pkt = pkt; 592 593 freeskb = 0; 594 595 if (proto->continue_tx && 596 proto->continue_tx(dev, txbuf)) { 597 BUGMSG(D_NORMAL, 598 "bug! continue_tx finished the first time! " 599 "(proto='%c')\n", proto->suffix); 600 } 601 } 602 retval = NETDEV_TX_OK; 603 lp->next_tx = txbuf; 604 } else { 605 retval = NETDEV_TX_BUSY; 606 freeskb = 0; 607 } 608 609 BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__func__,ASTATUS()); 610 /* make sure we didn't ignore a TX IRQ while we were in here */ 611 AINTMASK(0); 612 613 BUGMSG(D_DEBUG, "%s: %d: %s\n",__FILE__,__LINE__,__func__); 614 lp->intmask |= TXFREEflag|EXCNAKflag; 615 AINTMASK(lp->intmask); 616 BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__func__,ASTATUS()); 617 618 spin_unlock_irqrestore(&lp->lock, flags); 619 if (freeskb) { 620 dev_kfree_skb(skb); 621 } 622 return retval; /* no need to try again */ 623 } 624 625 626 /* 627 * Actually start transmitting a packet that was loaded into a buffer 628 * by prepare_tx. This should _only_ be called by the interrupt handler. 629 */ 630 static int go_tx(struct net_device *dev) 631 { 632 struct arcnet_local *lp = netdev_priv(dev); 633 634 BUGMSG(D_DURING, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%d\n", 635 ASTATUS(), lp->intmask, lp->next_tx, lp->cur_tx); 636 637 if (lp->cur_tx != -1 || lp->next_tx == -1) 638 return 0; 639 640 BUGLVL(D_TX) arcnet_dump_packet(dev, lp->next_tx, "go_tx", 0); 641 642 lp->cur_tx = lp->next_tx; 643 lp->next_tx = -1; 644 645 /* start sending */ 646 ACOMMAND(TXcmd | (lp->cur_tx << 3)); 647 648 dev->stats.tx_packets++; 649 lp->lasttrans_dest = lp->lastload_dest; 650 lp->lastload_dest = 0; 651 lp->excnak_pending = 0; 652 lp->intmask |= TXFREEflag|EXCNAKflag; 653 654 return 1; 655 } 656 657 658 /* Called by the kernel when transmit times out */ 659 void arcnet_timeout(struct net_device *dev) 660 { 661 unsigned long flags; 662 struct arcnet_local *lp = netdev_priv(dev); 663 int status = ASTATUS(); 664 char *msg; 665 666 spin_lock_irqsave(&lp->lock, flags); 667 if (status & TXFREEflag) { /* transmit _DID_ finish */ 668 msg = " - missed IRQ?"; 669 } else { 670 msg = ""; 671 dev->stats.tx_aborted_errors++; 672 lp->timed_out = 1; 673 ACOMMAND(NOTXcmd | (lp->cur_tx << 3)); 674 } 675 dev->stats.tx_errors++; 676 677 /* make sure we didn't miss a TX or a EXC NAK IRQ */ 678 AINTMASK(0); 679 lp->intmask |= TXFREEflag|EXCNAKflag; 680 AINTMASK(lp->intmask); 681 682 spin_unlock_irqrestore(&lp->lock, flags); 683 684 if (time_after(jiffies, lp->last_timeout + 10*HZ)) { 685 BUGMSG(D_EXTRA, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)\n", 686 msg, status, lp->intmask, lp->lasttrans_dest); 687 lp->last_timeout = jiffies; 688 } 689 690 if (lp->cur_tx == -1) 691 netif_wake_queue(dev); 692 } 693 694 695 /* 696 * The typical workload of the driver: Handle the network interface 697 * interrupts. Establish which device needs attention, and call the correct 698 * chipset interrupt handler. 699 */ 700 irqreturn_t arcnet_interrupt(int irq, void *dev_id) 701 { 702 struct net_device *dev = dev_id; 703 struct arcnet_local *lp; 704 int recbuf, status, diagstatus, didsomething, boguscount; 705 int retval = IRQ_NONE; 706 707 BUGMSG(D_DURING, "\n"); 708 709 BUGMSG(D_DURING, "in arcnet_interrupt\n"); 710 711 lp = netdev_priv(dev); 712 BUG_ON(!lp); 713 714 spin_lock(&lp->lock); 715 716 /* 717 * RESET flag was enabled - if device is not running, we must clear it right 718 * away (but nothing else). 719 */ 720 if (!netif_running(dev)) { 721 if (ASTATUS() & RESETflag) 722 ACOMMAND(CFLAGScmd | RESETclear); 723 AINTMASK(0); 724 spin_unlock(&lp->lock); 725 return retval; 726 } 727 728 BUGMSG(D_DURING, "in arcnet_inthandler (status=%Xh, intmask=%Xh)\n", 729 ASTATUS(), lp->intmask); 730 731 boguscount = 5; 732 do { 733 status = ASTATUS(); 734 diagstatus = (status >> 8) & 0xFF; 735 736 BUGMSG(D_DEBUG, "%s: %d: %s: status=%x\n", 737 __FILE__,__LINE__,__func__,status); 738 didsomething = 0; 739 740 /* 741 * RESET flag was enabled - card is resetting and if RX is 742 * disabled, it's NOT because we just got a packet. 743 * 744 * The card is in an undefined state. Clear it out and start over. 745 */ 746 if (status & RESETflag) { 747 BUGMSG(D_NORMAL, "spurious reset (status=%Xh)\n", status); 748 arcnet_close(dev); 749 arcnet_open(dev); 750 751 /* get out of the interrupt handler! */ 752 break; 753 } 754 /* 755 * RX is inhibited - we must have received something. Prepare to 756 * receive into the next buffer. 757 * 758 * We don't actually copy the received packet from the card until 759 * after the transmit handler runs (and possibly launches the next 760 * tx); this should improve latency slightly if we get both types 761 * of interrupts at once. 762 */ 763 recbuf = -1; 764 if (status & lp->intmask & NORXflag) { 765 recbuf = lp->cur_rx; 766 BUGMSG(D_DURING, "Buffer #%d: receive irq (status=%Xh)\n", 767 recbuf, status); 768 769 lp->cur_rx = get_arcbuf(dev); 770 if (lp->cur_rx != -1) { 771 BUGMSG(D_DURING, "enabling receive to buffer #%d\n", 772 lp->cur_rx); 773 ACOMMAND(RXcmd | (lp->cur_rx << 3) | RXbcasts); 774 } 775 didsomething++; 776 } 777 778 if((diagstatus & EXCNAKflag)) { 779 BUGMSG(D_DURING, "EXCNAK IRQ (diagstat=%Xh)\n", 780 diagstatus); 781 782 ACOMMAND(NOTXcmd); /* disable transmit */ 783 lp->excnak_pending = 1; 784 785 ACOMMAND(EXCNAKclear); 786 lp->intmask &= ~(EXCNAKflag); 787 didsomething++; 788 } 789 790 791 /* a transmit finished, and we're interested in it. */ 792 if ((status & lp->intmask & TXFREEflag) || lp->timed_out) { 793 lp->intmask &= ~(TXFREEflag|EXCNAKflag); 794 795 BUGMSG(D_DURING, "TX IRQ (stat=%Xh)\n", status); 796 797 if (lp->cur_tx != -1 && !lp->timed_out) { 798 if(!(status & TXACKflag)) { 799 if (lp->lasttrans_dest != 0) { 800 BUGMSG(D_EXTRA, 801 "transmit was not acknowledged! " 802 "(status=%Xh, dest=%02Xh)\n", 803 status, lp->lasttrans_dest); 804 dev->stats.tx_errors++; 805 dev->stats.tx_carrier_errors++; 806 } else { 807 BUGMSG(D_DURING, 808 "broadcast was not acknowledged; that's normal " 809 "(status=%Xh, dest=%02Xh)\n", 810 status, lp->lasttrans_dest); 811 } 812 } 813 814 if (lp->outgoing.proto && 815 lp->outgoing.proto->ack_tx) { 816 int ackstatus; 817 if(status & TXACKflag) 818 ackstatus=2; 819 else if(lp->excnak_pending) 820 ackstatus=1; 821 else 822 ackstatus=0; 823 824 lp->outgoing.proto 825 ->ack_tx(dev, ackstatus); 826 } 827 } 828 if (lp->cur_tx != -1) 829 release_arcbuf(dev, lp->cur_tx); 830 831 lp->cur_tx = -1; 832 lp->timed_out = 0; 833 didsomething++; 834 835 /* send another packet if there is one */ 836 go_tx(dev); 837 838 /* continue a split packet, if any */ 839 if (lp->outgoing.proto && lp->outgoing.proto->continue_tx) { 840 int txbuf = get_arcbuf(dev); 841 if (txbuf != -1) { 842 if (lp->outgoing.proto->continue_tx(dev, txbuf)) { 843 /* that was the last segment */ 844 dev->stats.tx_bytes += lp->outgoing.skb->len; 845 if(!lp->outgoing.proto->ack_tx) 846 { 847 dev_kfree_skb_irq(lp->outgoing.skb); 848 lp->outgoing.proto = NULL; 849 } 850 } 851 lp->next_tx = txbuf; 852 } 853 } 854 /* inform upper layers of idleness, if necessary */ 855 if (lp->cur_tx == -1) 856 netif_wake_queue(dev); 857 } 858 /* now process the received packet, if any */ 859 if (recbuf != -1) { 860 BUGLVL(D_RX) arcnet_dump_packet(dev, recbuf, "rx irq", 0); 861 862 arcnet_rx(dev, recbuf); 863 release_arcbuf(dev, recbuf); 864 865 didsomething++; 866 } 867 if (status & lp->intmask & RECONflag) { 868 ACOMMAND(CFLAGScmd | CONFIGclear); 869 dev->stats.tx_carrier_errors++; 870 871 BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)\n", 872 status); 873 /* MYRECON bit is at bit 7 of diagstatus */ 874 if(diagstatus & 0x80) 875 BUGMSG(D_RECON,"Put out that recon myself\n"); 876 877 /* is the RECON info empty or old? */ 878 if (!lp->first_recon || !lp->last_recon || 879 time_after(jiffies, lp->last_recon + HZ * 10)) { 880 if (lp->network_down) 881 BUGMSG(D_NORMAL, "reconfiguration detected: cabling restored?\n"); 882 lp->first_recon = lp->last_recon = jiffies; 883 lp->num_recons = lp->network_down = 0; 884 885 BUGMSG(D_DURING, "recon: clearing counters.\n"); 886 } else { /* add to current RECON counter */ 887 lp->last_recon = jiffies; 888 lp->num_recons++; 889 890 BUGMSG(D_DURING, "recon: counter=%d, time=%lds, net=%d\n", 891 lp->num_recons, 892 (lp->last_recon - lp->first_recon) / HZ, 893 lp->network_down); 894 895 /* if network is marked up; 896 * and first_recon and last_recon are 60+ apart; 897 * and the average no. of recons counted is 898 * > RECON_THRESHOLD/min; 899 * then print a warning message. 900 */ 901 if (!lp->network_down && 902 (lp->last_recon - lp->first_recon) <= HZ * 60 && 903 lp->num_recons >= RECON_THRESHOLD) { 904 lp->network_down = 1; 905 BUGMSG(D_NORMAL, "many reconfigurations detected: cabling problem?\n"); 906 } else if (!lp->network_down && 907 lp->last_recon - lp->first_recon > HZ * 60) { 908 /* reset counters if we've gone for over a minute. */ 909 lp->first_recon = lp->last_recon; 910 lp->num_recons = 1; 911 } 912 } 913 } else if (lp->network_down && 914 time_after(jiffies, lp->last_recon + HZ * 10)) { 915 if (lp->network_down) 916 BUGMSG(D_NORMAL, "cabling restored?\n"); 917 lp->first_recon = lp->last_recon = 0; 918 lp->num_recons = lp->network_down = 0; 919 920 BUGMSG(D_DURING, "not recon: clearing counters anyway.\n"); 921 } 922 923 if(didsomething) { 924 retval |= IRQ_HANDLED; 925 } 926 } 927 while (--boguscount && didsomething); 928 929 BUGMSG(D_DURING, "arcnet_interrupt complete (status=%Xh, count=%d)\n", 930 ASTATUS(), boguscount); 931 BUGMSG(D_DURING, "\n"); 932 933 934 AINTMASK(0); 935 udelay(1); 936 AINTMASK(lp->intmask); 937 938 spin_unlock(&lp->lock); 939 return retval; 940 } 941 942 943 /* 944 * This is a generic packet receiver that calls arcnet??_rx depending on the 945 * protocol ID found. 946 */ 947 static void arcnet_rx(struct net_device *dev, int bufnum) 948 { 949 struct arcnet_local *lp = netdev_priv(dev); 950 struct archdr pkt; 951 struct arc_rfc1201 *soft; 952 int length, ofs; 953 954 soft = &pkt.soft.rfc1201; 955 956 lp->hw.copy_from_card(dev, bufnum, 0, &pkt, ARC_HDR_SIZE); 957 if (pkt.hard.offset[0]) { 958 ofs = pkt.hard.offset[0]; 959 length = 256 - ofs; 960 } else { 961 ofs = pkt.hard.offset[1]; 962 length = 512 - ofs; 963 } 964 965 /* get the full header, if possible */ 966 if (sizeof(pkt.soft) <= length) 967 lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft)); 968 else { 969 memset(&pkt.soft, 0, sizeof(pkt.soft)); 970 lp->hw.copy_from_card(dev, bufnum, ofs, soft, length); 971 } 972 973 BUGMSG(D_DURING, "Buffer #%d: received packet from %02Xh to %02Xh " 974 "(%d+4 bytes)\n", 975 bufnum, pkt.hard.source, pkt.hard.dest, length); 976 977 dev->stats.rx_packets++; 978 dev->stats.rx_bytes += length + ARC_HDR_SIZE; 979 980 /* call the right receiver for the protocol */ 981 if (arc_proto_map[soft->proto]->is_ip) { 982 BUGLVL(D_PROTO) { 983 struct ArcProto 984 *oldp = arc_proto_map[lp->default_proto[pkt.hard.source]], 985 *newp = arc_proto_map[soft->proto]; 986 987 if (oldp != newp) { 988 BUGMSG(D_PROTO, 989 "got protocol %02Xh; encap for host %02Xh is now '%c'" 990 " (was '%c')\n", soft->proto, pkt.hard.source, 991 newp->suffix, oldp->suffix); 992 } 993 } 994 995 /* broadcasts will always be done with the last-used encap. */ 996 lp->default_proto[0] = soft->proto; 997 998 /* in striking contrast, the following isn't a hack. */ 999 lp->default_proto[pkt.hard.source] = soft->proto; 1000 } 1001 /* call the protocol-specific receiver. */ 1002 arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length); 1003 } 1004 1005 1006 static void null_rx(struct net_device *dev, int bufnum, 1007 struct archdr *pkthdr, int length) 1008 { 1009 BUGMSG(D_PROTO, 1010 "rx: don't know how to deal with proto %02Xh from host %02Xh.\n", 1011 pkthdr->soft.rfc1201.proto, pkthdr->hard.source); 1012 } 1013 1014 1015 static int null_build_header(struct sk_buff *skb, struct net_device *dev, 1016 unsigned short type, uint8_t daddr) 1017 { 1018 struct arcnet_local *lp = netdev_priv(dev); 1019 1020 BUGMSG(D_PROTO, 1021 "tx: can't build header for encap %02Xh; load a protocol driver.\n", 1022 lp->default_proto[daddr]); 1023 1024 /* always fails */ 1025 return 0; 1026 } 1027 1028 1029 /* the "do nothing" prepare_tx function warns that there's nothing to do. */ 1030 static int null_prepare_tx(struct net_device *dev, struct archdr *pkt, 1031 int length, int bufnum) 1032 { 1033 struct arcnet_local *lp = netdev_priv(dev); 1034 struct arc_hardware newpkt; 1035 1036 BUGMSG(D_PROTO, "tx: no encap for this host; load a protocol driver.\n"); 1037 1038 /* send a packet to myself -- will never get received, of course */ 1039 newpkt.source = newpkt.dest = dev->dev_addr[0]; 1040 1041 /* only one byte of actual data (and it's random) */ 1042 newpkt.offset[0] = 0xFF; 1043 1044 lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE); 1045 1046 return 1; /* done */ 1047 } 1048