开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
arcnet.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：27k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

arcnet.c：源码内容
  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.  */
  44. #define VERSION "arcnet: v3.93 BETA 2000/04/29 - by Avery Pennarun et al.n"
  46. #include <linux/module.h>
  47. #include <linux/config.h>
  48. #include <linux/types.h>
  49. #include <linux/delay.h>
  50. #include <linux/netdevice.h>
  51. #include <linux/if_arp.h>
  52. #include <net/arp.h>
  53. #include <linux/init.h>
  54. #include <linux/arcdevice.h>
  57. /* "do nothing" functions for protocol drivers */
  58. static void null_rx(struct net_device *dev, int bufnum,
  59.     struct archdr *pkthdr, int length);
  60. static int null_build_header(struct sk_buff *skb, unsigned short type,
  61.      uint8_t daddr);
  62. static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,
  63.    int length, int bufnum);
  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, *arc_bcast_proto;
  74. struct ArcProto arc_proto_null =
  75. {
  76. '?',
  77. XMTU,
  78. null_rx,
  79. null_build_header,
  80. null_prepare_tx
  81. };
  84. /* Exported function prototypes */
  85. int arcnet_debug = ARCNET_DEBUG;
  87. EXPORT_SYMBOL(arc_proto_map);
  88. EXPORT_SYMBOL(arc_proto_default);
  89. EXPORT_SYMBOL(arc_bcast_proto);
  90. EXPORT_SYMBOL(arc_proto_null);
  91. EXPORT_SYMBOL(arcnet_unregister_proto);
  92. EXPORT_SYMBOL(arcnet_debug);
  93. EXPORT_SYMBOL(arcdev_setup);
  94. EXPORT_SYMBOL(arcnet_interrupt);
  96. /* Internal function prototypes */
  97. static int arcnet_open(struct net_device *dev);
  98. static int arcnet_close(struct net_device *dev);
  99. static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev);
  100. static void arcnet_timeout(struct net_device *dev);
  101. static int arcnet_header(struct sk_buff *skb, struct net_device *dev,
  102.  unsigned short type, void *daddr, void *saddr,
  103.  unsigned len);
  104. static int arcnet_rebuild_header(struct sk_buff *skb);
  105. static struct net_device_stats *arcnet_get_stats(struct net_device *dev);
  106. static int go_tx(struct net_device *dev);
  108. void __init arcnet_init(void)
  109. {
  110. static int arcnet_inited;
  111. int count;
  113. if (arcnet_inited++)
  114. return;
  116. printk(VERSION);
  118. #ifdef ALPHA_WARNING
  119. BUGLVL(D_EXTRA) {
  120. printk("arcnet: ***n"
  121. "arcnet: * Read arcnet.txt for important release notes!n"
  122.        "arcnet: *n"
  123.        "arcnet: * This is an ALPHA version! (Last stable release: v3.02)  E-mailn"
  124.        "arcnet: * me if you have any questions, comments, or bug reports.n"
  125.        "arcnet: ***n");
  126. }
  127. #endif
  129. /* initialize the protocol map */
  130. arc_proto_default = arc_bcast_proto = &arc_proto_null;
  131. for (count = 0; count < 256; count++)
  132. arc_proto_map[count] = arc_proto_default;
  134. BUGLVL(D_DURING)
  135.     printk("arcnet: struct sizes: %d %d %d %d %dn",
  136.  sizeof(struct arc_hardware), sizeof(struct arc_rfc1201),
  137. sizeof(struct arc_rfc1051), sizeof(struct arc_eth_encap),
  138.    sizeof(struct archdr));
  140. #ifdef CONFIG_ARCNET /* We're not built as a module */
  141. printk("arcnet: Available protocols:");
  142. #ifdef CONFIG_ARCNET_1201
  143. printk(" RFC1201");
  144. arcnet_rfc1201_init();
  145. #endif
  146. #ifdef CONFIG_ARCNET_1051
  147. printk(" RFC1051");
  148. arcnet_rfc1051_init();
  149. #endif
  150. #ifdef CONFIG_ARCNET_RAW
  151. printk(" RAW");
  152. arcnet_raw_init();
  153. #endif
  154. printk("n");
  155. #ifdef CONFIG_ARCNET_COM90xx
  156. com90xx_probe(NULL);
  157. #endif
  158. #endif
  159. }
  162. #ifdef MODULE
  164. static int debug = ARCNET_DEBUG;
  165. MODULE_PARM(debug, "i");
  166. MODULE_LICENSE("GPL");
  168. int __init init_module(void)
  169. {
  170. arcnet_debug = debug;
  171. arcnet_init();
  172. return 0;
  173. }
  175. void cleanup_module(void)
  176. {
  177. }
  179. #endif
  182. /*
  183.  * Dump the contents of an sk_buff
  184.  */
  185. #if ARCNET_DEBUG_MAX & D_SKB
  186. void arcnet_dump_skb(struct net_device *dev, struct sk_buff *skb, char *desc)
  187. {
  188. int i;
  189. unsigned long flags;
  191. save_flags(flags);
  192. cli();
  193. printk(KERN_DEBUG "%6s: skb dump (%s) follows:", dev->name, desc);
  194. for (i = 0; i < skb->len; i++) {
  195. if (i % 16 == 0)
  196. printk("n" KERN_DEBUG "[%04X] ", i);
  197. printk("%02X ", ((u_char *) skb->data)[i]);
  198. }
  199. printk("n");
  200. restore_flags(flags);
  201. }
  203. EXPORT_SYMBOL(arcnet_dump_skb);
  204. #endif
  207. /*
  208.  * Dump the contents of an ARCnet buffer
  209.  */
  210. #if (ARCNET_DEBUG_MAX & (D_RX | D_TX))
  211. void arcnet_dump_packet(struct net_device *dev, int bufnum, char *desc)
  212. {
  213. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  214. int i, length;
  215. unsigned long flags;
  216. static uint8_t buf[512];
  218. save_flags(flags);
  219. cli();
  221. lp->hw.copy_from_card(dev, bufnum, 0, buf, 512);
  223. /* if the offset[0] byte is nonzero, this is a 256-byte packet */
  224. length = (buf[2] ? 256 : 512);
  226. printk(KERN_DEBUG "%6s: packet dump (%s) follows:", dev->name, desc);
  227. for (i = 0; i < length; i++) {
  228. if (i % 16 == 0)
  229. printk("n" KERN_DEBUG "[%04X] ", i);
  230. printk("%02X ", buf[i]);
  231. }
  232. printk("n");
  234. restore_flags(flags);
  235. }
  237. EXPORT_SYMBOL(arcnet_dump_packet);
  238. #endif
  241. /*
  242.  * Unregister a protocol driver from the arc_proto_map.  Protocol drivers
  243.  * are responsible for registering themselves, but the unregister routine
  244.  * is pretty generic so we'll do it here.
  245.  */
  246. void arcnet_unregister_proto(struct ArcProto *proto)
  247. {
  248. int count;
  250. if (arc_proto_default == proto)
  251. arc_proto_default = &arc_proto_null;
  252. if (arc_bcast_proto == proto)
  253. arc_bcast_proto = arc_proto_default;
  255. for (count = 0; count < 256; count++) {
  256. if (arc_proto_map[count] == proto)
  257. arc_proto_map[count] = arc_proto_default;
  258. }
  259. }
  262. /*
  263.  * Add a buffer to the queue.  Only the interrupt handler is allowed to do
  264.  * this, unless interrupts are disabled.
  265.  * 
  266.  * Note: we don't check for a full queue, since there aren't enough buffers
  267.  * to more than fill it.
  268.  */
  269. static void release_arcbuf(struct net_device *dev, int bufnum)
  270. {
  271. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  272. int i;
  274. lp->buf_queue[lp->first_free_buf++] = bufnum;
  275. lp->first_free_buf %= 5;
  277. BUGLVL(D_DURING) {
  278. BUGMSG(D_DURING, "release_arcbuf: freed #%d; buffer queue is now: ",
  279.        bufnum);
  280. for (i = lp->next_buf; i != lp->first_free_buf; i = ++i % 5)
  281. BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);
  282. BUGMSG2(D_DURING, "n");
  283. }
  284. }
  287. /*
  288.  * Get a buffer from the queue.  If this returns -1, there are no buffers
  289.  * available.
  290.  */
  291. static int get_arcbuf(struct net_device *dev)
  292. {
  293. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  294. int buf = -1, i;
  296. if (!atomic_dec_and_test(&lp->buf_lock)) /* already in this function */
  297. BUGMSG(D_NORMAL, "get_arcbuf: overlap (%d)!n", lp->buf_lock.counter);
  298. else { /* we can continue */
  299. if (lp->next_buf >= 5)
  300. lp->next_buf -= 5;
  302. if (lp->next_buf == lp->first_free_buf)
  303. BUGMSG(D_NORMAL, "get_arcbuf: BUG: no buffers are available??n");
  304. else {
  305. buf = lp->buf_queue[lp->next_buf++];
  306. lp->next_buf %= 5;
  307. }
  308. }
  311. BUGLVL(D_DURING) {
  312. BUGMSG(D_DURING, "get_arcbuf: got #%d; buffer queue is now: ", buf);
  313. for (i = lp->next_buf; i != lp->first_free_buf; i = ++i % 5)
  314. BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);
  315. BUGMSG2(D_DURING, "n");
  316. }
  318. atomic_inc(&lp->buf_lock);
  319. return buf;
  320. }
  323. static int choose_mtu(void)
  324. {
  325. int count, mtu = 65535;
  327. /* choose the smallest MTU of all available encaps */
  328. for (count = 0; count < 256; count++) {
  329. if (arc_proto_map[count] != &arc_proto_null
  330.     && arc_proto_map[count]->mtu < mtu) {
  331. mtu = arc_proto_map[count]->mtu;
  332. }
  333. }
  335. return mtu == 65535 ? XMTU : mtu;
  336. }
  339. /* Setup a struct device for ARCnet. */
  340. void arcdev_setup(struct net_device *dev)
  341. {
  342. dev->type = ARPHRD_ARCNET;
  343. dev->hard_header_len = sizeof(struct archdr);
  344. dev->mtu = choose_mtu();
  346. dev->addr_len = 1;
  347. dev->tx_queue_len = 30;
  348. dev->broadcast[0] = 0x00; /* for us, broadcasts are address 0 */
  349. dev->watchdog_timeo = TX_TIMEOUT;
  351. /* New-style flags. */
  352. dev->flags = IFF_BROADCAST;
  354. /*
  355.  * Put in this stuff here, so we don't have to export the symbols to
  356.  * the chipset drivers.
  357.  */
  358. dev->open = arcnet_open;
  359. dev->stop = arcnet_close;
  360. dev->hard_start_xmit = arcnet_send_packet;
  361. dev->tx_timeout = arcnet_timeout;
  362. dev->get_stats = arcnet_get_stats;
  363. dev->hard_header = arcnet_header;
  364. dev->rebuild_header = arcnet_rebuild_header;
  365. }
  368. /*
  369.  * Open/initialize the board.  This is called sometime after booting when
  370.  * the 'ifconfig' program is run.
  371.  *
  372.  * This routine should set everything up anew at each open, even registers
  373.  * that "should" only need to be set once at boot, so that there is
  374.  * non-reboot way to recover if something goes wrong.
  375.  */
  376. static int arcnet_open(struct net_device *dev)
  377. {
  378. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  379. int count, newmtu;
  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. }
  391. BUGMSG(D_INIT, "arcnet_open: resetting card.n");
  393. /* try to put the card in a defined state - if it fails the first
  394.  * time, actually reset it.
  395.  */
  396. if (ARCRESET(0) && ARCRESET(1))
  397. return -ENODEV;
  399. newmtu = choose_mtu();
  400. if (newmtu < dev->mtu)
  401. dev->mtu = newmtu;
  403. /* autodetect the encapsulation for each host. */
  404. memset(lp->default_proto, 0, sizeof(lp->default_proto));
  406. /* the broadcast address is special - use the 'bcast' protocol */
  407. for (count = 0; count < 256; count++) {
  408. if (arc_proto_map[count] == arc_bcast_proto) {
  409. lp->default_proto[0] = count;
  410. break;
  411. }
  412. }
  414. /* initialize buffers */
  415. atomic_set(&lp->buf_lock, 1);
  416. lp->next_buf = lp->first_free_buf = 0;
  417. release_arcbuf(dev, 0);
  418. release_arcbuf(dev, 1);
  419. release_arcbuf(dev, 2);
  420. release_arcbuf(dev, 3);
  421. lp->cur_tx = lp->next_tx = -1;
  422. lp->cur_rx = -1;
  424. lp->rfc1201.sequence = 1;
  426. /* bring up the hardware driver */
  427. ARCOPEN(1);
  429. if (dev->dev_addr[0] == 0)
  430. BUGMSG(D_NORMAL, "WARNING!  Station address 00 is reserved "
  431.        "for broadcasts!n");
  432. else if (dev->dev_addr[0] == 255)
  433. BUGMSG(D_NORMAL, "WARNING!  Station address FF may confuse "
  434.        "DOS networking programs!n");
  436. if (ASTATUS() & RESETflag)
  437. ACOMMAND(CFLAGScmd | RESETclear);
  439. /* make sure we're ready to receive IRQ's. */
  440. AINTMASK(0);
  441. udelay(1); /* give it time to set the mask before
  442.  * we reset it again. (may not even be
  443.  * necessary)
  444.  */
  445. lp->intmask = NORXflag | RECONflag;
  446. AINTMASK(lp->intmask);
  448. netif_start_queue(dev);
  450. return 0;
  451. }
  454. /* The inverse routine to arcnet_open - shuts down the card. */
  455. static int arcnet_close(struct net_device *dev)
  456. {
  457. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  459. netif_stop_queue(dev);
  461. /* flush TX and disable RX */
  462. AINTMASK(0);
  463. ACOMMAND(NOTXcmd); /* stop transmit */
  464. ACOMMAND(NORXcmd); /* disable receive */
  465. mdelay(1);
  467. /* shut down the card */
  468. ARCOPEN(0);
  470. return 0;
  471. }
  474. static int arcnet_header(struct sk_buff *skb, struct net_device *dev,
  475.  unsigned short type, void *daddr, void *saddr,
  476.  unsigned len)
  477. {
  478. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  479. uint8_t _daddr, proto_num;
  480. struct ArcProto *proto;
  482. BUGMSG(D_DURING,
  483.     "create header from %d to %d; protocol %d (%Xh); size %u.n",
  484.        saddr ? *(uint8_t *) saddr : -1,
  485.        daddr ? *(uint8_t *) daddr : -1,
  486.        type, type, len);
  488. if (len != skb->len)
  489. BUGMSG(D_NORMAL, "arcnet_header: Yikes!  skb->len(%d) != len(%d)!n",
  490.        skb->len, len);
  492. /*
  493.  * if the dest addr isn't provided, we can't choose an encapsulation!
  494.  * Store the packet type (eg. ETH_P_IP) for now, and we'll push on a
  495.  * real header when we do rebuild_header. 
  496.  */
  497. if (!daddr) {
  498. *(uint16_t *) skb_push(skb, 2) = type;
  499. if (skb->nh.raw - skb->mac.raw != 2)
  500. BUGMSG(D_NORMAL, "arcnet_header: Yikes!  diff (%d) is not 2!n",
  501.        skb->nh.raw - skb->mac.raw);
  502. return -2; /* return error -- can't transmit yet! */
  503. }
  504. /* otherwise, we can just add the header as usual. */
  505. _daddr = *(uint8_t *) daddr;
  506. proto_num = lp->default_proto[_daddr];
  507. proto = arc_proto_map[proto_num];
  508. BUGMSG(D_DURING, "building header for %02Xh using protocol '%c'n",
  509.        proto_num, proto->suffix);
  510. if (proto == &arc_proto_null && arc_bcast_proto != proto) {
  511. BUGMSG(D_DURING, "actually, let's use '%c' instead.n",
  512.        arc_bcast_proto->suffix);
  513. proto = arc_bcast_proto;
  514. }
  515. return proto->build_header(skb, type, _daddr);
  516. }
  519. /* 
  520.  * Rebuild the ARCnet hard header. This is called after an ARP (or in the
  521.  * future other address resolution) has completed on this sk_buff. We now
  522.  * let ARP fill in the destination field.
  523.  */
  524. static int arcnet_rebuild_header(struct sk_buff *skb)
  525. {
  526. struct net_device *dev = skb->dev;
  527. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  528. int status = 0; /* default is failure */
  529. unsigned short type;
  530. uint8_t daddr=0;
  532. if (skb->nh.raw - skb->mac.raw != 2) {
  533. BUGMSG(D_NORMAL,
  534.      "rebuild_header: shouldn't be here! (hdrsize=%d)n",
  535.        skb->nh.raw - skb->mac.raw);
  536. return 0;
  537. }
  538. type = *(uint16_t *) skb_pull(skb, 2);
  540. if (type == ETH_P_IP) {
  541. #ifdef CONFIG_INET
  542. BUGMSG(D_DURING, "rebuild header for ethernet protocol %Xhn", type);
  543. status = arp_find(&daddr, skb) ? 1 : 0;
  544. BUGMSG(D_DURING, " rebuilt: dest is %d; protocol %Xhn",
  545.        daddr, type);
  546. #endif
  547. } else {
  548. BUGMSG(D_NORMAL,
  549.        "I don't understand ethernet protocol %Xh addresses!n", type);
  550. lp->stats.tx_errors++;
  551. lp->stats.tx_aborted_errors++;
  552. }
  554. /* if we couldn't resolve the address... give up. */
  555. if (!status)
  556. return 0;
  558. /* add the _real_ header this time! */
  559. arc_proto_map[lp->default_proto[daddr]]->build_header(skb, type, daddr);
  561. return 1; /* success */
  562. }
  566. /* Called by the kernel in order to transmit a packet. */
  567. static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
  568. {
  569. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  570. struct archdr *pkt;
  571. struct arc_rfc1201 *soft;
  572. struct ArcProto *proto;
  573. int txbuf;
  575. BUGMSG(D_DURING,
  576.        "transmit requested (status=%Xh, txbufs=%d/%d, len=%d)n",
  577.        ASTATUS(), lp->cur_tx, lp->next_tx, skb->len);
  579. pkt = (struct archdr *) skb->data;
  580. soft = &pkt->soft.rfc1201;
  581. proto = arc_proto_map[soft->proto];
  583. BUGMSG(D_SKB_SIZE, "skb: transmitting %d bytes to %02Xn",
  584. skb->len, pkt->hard.dest);
  585. BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "tx");
  587. /* fits in one packet? */
  588. if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {
  589. BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!n");
  590. dev_kfree_skb(skb);
  591. return 0; /* don't try again */
  592. }
  594. /* We're busy transmitting a packet... */
  595. netif_stop_queue(dev);
  597. AINTMASK(0);
  599. txbuf = get_arcbuf(dev);
  600. if (txbuf != -1) {
  601. if (proto->prepare_tx(dev, pkt, skb->len, txbuf)) {
  602. /* done right away */
  603. lp->stats.tx_bytes += skb->len;
  604. dev_kfree_skb(skb);
  605. } else {
  606. /* do it the 'split' way */
  607. lp->outgoing.proto = proto;
  608. lp->outgoing.skb = skb;
  609. lp->outgoing.pkt = pkt;
  611. if (!proto->continue_tx)
  612. BUGMSG(D_NORMAL, "bug! prep_tx==0, but no continue_tx!n");
  613. else if (proto->continue_tx(dev, txbuf)) {
  614. BUGMSG(D_NORMAL,
  615.        "bug! continue_tx finished the first time! "
  616.        "(proto='%c')n", proto->suffix);
  617. }
  618. }
  620. lp->next_tx = txbuf;
  621. } else
  622. dev_kfree_skb(skb);
  624. /* make sure we didn't ignore a TX IRQ while we were in here */
  625. AINTMASK(0);
  626. lp->intmask |= TXFREEflag;
  627. AINTMASK(lp->intmask);
  629. return 0; /* no need to try again */
  630. }
  633. /*
  634.  * Actually start transmitting a packet that was loaded into a buffer
  635.  * by prepare_tx.  This should _only_ be called by the interrupt handler.
  636.  */
  637. static int go_tx(struct net_device *dev)
  638. {
  639. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  641. BUGMSG(D_DURING, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%dn",
  642.        ASTATUS(), lp->intmask, lp->next_tx, lp->cur_tx);
  644. if (lp->cur_tx != -1 || lp->next_tx == -1)
  645. return 0;
  647. BUGLVL(D_TX) arcnet_dump_packet(dev, lp->next_tx, "go_tx");
  649. lp->cur_tx = lp->next_tx;
  650. lp->next_tx = -1;
  652. /* start sending */
  653. ACOMMAND(TXcmd | (lp->cur_tx << 3));
  655. dev->trans_start = jiffies;
  656. lp->stats.tx_packets++;
  657. lp->lasttrans_dest = lp->lastload_dest;
  658. lp->lastload_dest = 0;
  659. lp->intmask |= TXFREEflag;
  661. return 1;
  662. }
  665. /* Called by the kernel when transmit times out */
  666. static void arcnet_timeout(struct net_device *dev)
  667. {
  668. unsigned long flags;
  669. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  670. int status = ASTATUS();
  671. char *msg;
  673. save_flags(flags);
  674. cli();
  676. if (status & TXFREEflag) { /* transmit _DID_ finish */
  677. msg = " - missed IRQ?";
  678. } else {
  679. msg = "";
  680. lp->stats.tx_aborted_errors++;
  681. lp->timed_out = 1;
  682. ACOMMAND(NOTXcmd | (lp->cur_tx << 3));
  683. }
  684. lp->stats.tx_errors++;
  686. /* make sure we didn't miss a TX IRQ */
  687. AINTMASK(0);
  688. lp->intmask |= TXFREEflag;
  689. AINTMASK(lp->intmask);
  691. restore_flags(flags);
  693. if (jiffies - lp->last_timeout > 10*HZ) {
  694. BUGMSG(D_EXTRA, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)n",
  695.        msg, status, lp->intmask, lp->lasttrans_dest);
  696. lp->last_timeout = jiffies;
  697. }
  699. if (lp->cur_tx == -1)
  700. netif_wake_queue(dev);
  701. }
  704. /*
  705.  * The typical workload of the driver: Handle the network interface
  706.  * interrupts. Establish which device needs attention, and call the correct
  707.  * chipset interrupt handler.
  708.  */
  709. void arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  710. {
  711. struct net_device *dev = dev_id;
  712. struct arcnet_local *lp;
  713. int recbuf, status, didsomething, boguscount;
  715. BUGMSG(D_DURING, "n");
  717. if (dev == NULL) {
  718. BUGMSG(D_DURING, "arcnet: irq %d for unknown device.n", irq);
  719. return;
  720. }
  721. BUGMSG(D_DURING, "in arcnet_interruptn");
  723. lp = (struct arcnet_local *) dev->priv;
  724. if (!lp) {
  725. BUGMSG(D_DURING, "arcnet: irq ignored due to missing lp.n");
  726. return;
  727. }
  728. /*
  729.  * RESET flag was enabled - if device is not running, we must clear it right
  730.  * away (but nothing else).
  731.  */
  732. if (!netif_running(dev)) {
  733. if (ASTATUS() & RESETflag)
  734. ACOMMAND(CFLAGScmd | RESETclear);
  735. AINTMASK(0);
  736. return;
  737. }
  739. BUGMSG(D_DURING, "in arcnet_inthandler (status=%Xh, intmask=%Xh)n",
  740.        ASTATUS(), lp->intmask);
  742. boguscount = 5;
  743. do {
  744. status = ASTATUS();
  745. didsomething = 0;
  747. /*
  748.  * RESET flag was enabled - card is resetting and if RX is
  749.  * disabled, it's NOT because we just got a packet.
  750.  * 
  751.  * The card is in an undefined state.  Clear it out and start over.
  752.  */
  753. if (status & RESETflag) {
  754. BUGMSG(D_NORMAL, "spurious reset (status=%Xh)n", status);
  755. arcnet_close(dev);
  756. arcnet_open(dev);
  758. /* get out of the interrupt handler! */
  759. break;
  760. }
  761. /* 
  762.  * RX is inhibited - we must have received something. Prepare to
  763.  * receive into the next buffer.
  764.  * 
  765.  * We don't actually copy the received packet from the card until
  766.  * after the transmit handler runs (and possibly launches the next
  767.  * tx); this should improve latency slightly if we get both types
  768.  * of interrupts at once. 
  769.  */
  770. recbuf = -1;
  771. if (status & lp->intmask & NORXflag) {
  772. recbuf = lp->cur_rx;
  773. BUGMSG(D_DURING, "Buffer #%d: receive irq (status=%Xh)n",
  774.        recbuf, status);
  776. lp->cur_rx = get_arcbuf(dev);
  777. if (lp->cur_rx != -1) {
  778. BUGMSG(D_DURING, "enabling receive to buffer #%dn",
  779.        lp->cur_rx);
  780. ACOMMAND(RXcmd | (lp->cur_rx << 3) | RXbcasts);
  781. }
  782. didsomething++;
  783. }
  784. /* a transmit finished, and we're interested in it. */
  785. if ((status & lp->intmask & TXFREEflag) || lp->timed_out) {
  786. lp->intmask &= ~TXFREEflag;
  788. BUGMSG(D_DURING, "TX IRQ (stat=%Xh)n", status);
  790. if (lp->cur_tx != -1 && !(status & TXACKflag) && !lp->timed_out) {
  791. if (lp->lasttrans_dest != 0) {
  792. BUGMSG(D_EXTRA, "transmit was not acknowledged! "
  793.     "(status=%Xh, dest=%02Xh)n",
  794.      status, lp->lasttrans_dest);
  795. lp->stats.tx_errors++;
  796. lp->stats.tx_carrier_errors++;
  797. } else {
  798. BUGMSG(D_DURING,
  799.        "broadcast was not acknowledged; that's normal "
  800.     "(status=%Xh, dest=%02Xh)n",
  801.      status, lp->lasttrans_dest);
  802. }
  803. }
  804. if (lp->cur_tx != -1)
  805. release_arcbuf(dev, lp->cur_tx);
  807. lp->cur_tx = -1;
  808. lp->timed_out = 0;
  809. didsomething++;
  811. /* send another packet if there is one */
  812. go_tx(dev);
  814. /* continue a split packet, if any */
  815. if (lp->outgoing.proto && lp->outgoing.proto->continue_tx) {
  816. int txbuf = get_arcbuf(dev);
  817. if (txbuf != -1) {
  818. if (lp->outgoing.proto->continue_tx(dev, txbuf)) {
  819. /* that was the last segment */
  820. lp->stats.tx_bytes += lp->outgoing.skb->len;
  821. dev_kfree_skb_irq(lp->outgoing.skb);
  822. lp->outgoing.proto = NULL;
  823. }
  824. lp->next_tx = txbuf;
  825. }
  826. }
  827. /* inform upper layers of idleness, if necessary */
  828. if (lp->cur_tx == -1)
  829. netif_wake_queue(dev);
  830. }
  831. /* now process the received packet, if any */
  832. if (recbuf != -1) {
  833. BUGLVL(D_RX) arcnet_dump_packet(dev, recbuf, "rx irq");
  835. arcnet_rx(dev, recbuf);
  836. release_arcbuf(dev, recbuf);
  838. didsomething++;
  839. }
  840. if (status & lp->intmask & RECONflag) {
  841. ACOMMAND(CFLAGScmd | CONFIGclear);
  842. lp->stats.tx_carrier_errors++;
  844. BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)n",
  845.        status);
  847. /* is the RECON info empty or old? */
  848. if (!lp->first_recon || !lp->last_recon ||
  849.     jiffies - lp->last_recon > HZ * 10) {
  850. if (lp->network_down)
  851. BUGMSG(D_NORMAL, "reconfiguration detected: cabling restored?n");
  852. lp->first_recon = lp->last_recon = jiffies;
  853. lp->num_recons = lp->network_down = 0;
  855. BUGMSG(D_DURING, "recon: clearing counters.n");
  856. } else { /* add to current RECON counter */
  857. lp->last_recon = jiffies;
  858. lp->num_recons++;
  860. BUGMSG(D_DURING, "recon: counter=%d, time=%lds, net=%dn",
  861.        lp->num_recons,
  862.  (lp->last_recon - lp->first_recon) / HZ,
  863.        lp->network_down);
  865. /* if network is marked up;
  866.  * and first_recon and last_recon are 60+ apart;
  867.  * and the average no. of recons counted is
  868.  *    > RECON_THRESHOLD/min;
  869.  * then print a warning message.
  870.  */
  871. if (!lp->network_down
  872.     && (lp->last_recon - lp->first_recon) <= HZ * 60
  873.   && lp->num_recons >= RECON_THRESHOLD) {
  874. lp->network_down = 1;
  875. BUGMSG(D_NORMAL, "many reconfigurations detected: cabling problem?n");
  876. } else if (!lp->network_down
  877.    && lp->last_recon - lp->first_recon > HZ * 60) {
  878. /* reset counters if we've gone for over a minute. */
  879. lp->first_recon = lp->last_recon;
  880. lp->num_recons = 1;
  881. }
  882. }
  883. } else if (lp->network_down && jiffies - lp->last_recon > HZ * 10) {
  884. if (lp->network_down)
  885. BUGMSG(D_NORMAL, "cabling restored?n");
  886. lp->first_recon = lp->last_recon = 0;
  887. lp->num_recons = lp->network_down = 0;
  889. BUGMSG(D_DURING, "not recon: clearing counters anyway.n");
  890. }
  891. }
  892. while (--boguscount && didsomething);
  894. BUGMSG(D_DURING, "arcnet_interrupt complete (status=%Xh, count=%d)n",
  895.        ASTATUS(), boguscount);
  896. BUGMSG(D_DURING, "n");
  899. AINTMASK(0);
  900. udelay(1);
  901. AINTMASK(lp->intmask);
  902. }
  905. /*
  906.  * This is a generic packet receiver that calls arcnet??_rx depending on the
  907.  * protocol ID found.
  908.  */
  909. void arcnet_rx(struct net_device *dev, int bufnum)
  910. {
  911. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  912. struct archdr pkt;
  913. struct arc_rfc1201 *soft;
  914. int length, ofs;
  916. soft = &pkt.soft.rfc1201;
  918. lp->hw.copy_from_card(dev, bufnum, 0, &pkt, sizeof(ARC_HDR_SIZE));
  919. if (pkt.hard.offset[0]) {
  920. ofs = pkt.hard.offset[0];
  921. length = 256 - ofs;
  922. } else {
  923. ofs = pkt.hard.offset[1];
  924. length = 512 - ofs;
  925. }
  927. /* get the full header, if possible */
  928. if (sizeof(pkt.soft) < length)
  929. lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft));
  930. else {
  931. memset(&pkt.soft, 0, sizeof(pkt.soft));
  932. lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);
  933. }
  935. BUGMSG(D_DURING, "Buffer #%d: received packet from %02Xh to %02Xh "
  936.        "(%d+4 bytes)n",
  937.        bufnum, pkt.hard.source, pkt.hard.dest, length);
  939. lp->stats.rx_packets++;
  940. lp->stats.rx_bytes += length + ARC_HDR_SIZE;
  942. /* call the right receiver for the protocol */
  943. if (arc_proto_map[soft->proto] != &arc_proto_null) {
  944. BUGLVL(D_PROTO) {
  945. struct ArcProto
  946. *oldp = arc_proto_map[lp->default_proto[pkt.hard.source]],
  947. *newp = arc_proto_map[soft->proto];
  949. if (oldp != newp) {
  950. BUGMSG(D_PROTO,
  951.        "got protocol %02Xh; encap for host %02Xh is now '%c'"
  952.        " (was '%c')n", soft->proto, pkt.hard.source,
  953.        newp->suffix, oldp->suffix);
  954. }
  955. }
  957. /* broadcasts will always be done with the last-used encap. */
  958. lp->default_proto[0] = soft->proto;
  960. /* in striking contrast, the following isn't a hack. */
  961. lp->default_proto[pkt.hard.source] = soft->proto;
  962. }
  963. /* call the protocol-specific receiver. */
  964. arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length);
  965. }
  969. /* 
  970.  * Get the current statistics.  This may be called with the card open or
  971.  * closed.
  972.  */
  973. static struct net_device_stats *arcnet_get_stats(struct net_device *dev)
  974. {
  975. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  976. return &lp->stats;
  977. }
  980. static void null_rx(struct net_device *dev, int bufnum,
  981.     struct archdr *pkthdr, int length)
  982. {
  983. BUGMSG(D_PROTO,
  984. "rx: don't know how to deal with proto %02Xh from host %02Xh.n",
  985.        pkthdr->soft.rfc1201.proto, pkthdr->hard.source);
  986. }
  989. static int null_build_header(struct sk_buff *skb, unsigned short type,
  990.      uint8_t daddr)
  991. {
  992. struct net_device *dev = skb->dev;
  993. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  995. BUGMSG(D_PROTO,
  996.        "tx: can't build header for encap %02Xh; load a protocol driver.n",
  997.        lp->default_proto[daddr]);
  999. /* always fails */
  1000. return 0;
  1001. }
  1004. /* the "do nothing" prepare_tx function warns that there's nothing to do. */
  1005. static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,
  1006.    int length, int bufnum)
  1007. {
  1008. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  1009. struct arc_hardware newpkt;
  1011. BUGMSG(D_PROTO, "tx: no encap for this host; load a protocol driver.n");
  1013. /* send a packet to myself -- will never get received, of course */
  1014. newpkt.source = newpkt.dest = dev->dev_addr[0];
  1016. /* only one byte of actual data (and it's random) */
  1017. newpkt.offset[0] = 0xFF;
  1019. lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE);
  1021. return 1; /* done */
  1022. }