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