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