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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
arcnet.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

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");
  167. int __init init_module(void)
  168. {
  169. arcnet_debug = debug;
  170. arcnet_init();
  171. return 0;
  172. }
  174. void cleanup_module(void)
  175. {
  176. }
  178. #endif
  181. /*
  182.  * Dump the contents of an sk_buff
  183.  */
  184. #if ARCNET_DEBUG_MAX & D_SKB
  185. void arcnet_dump_skb(struct net_device *dev, struct sk_buff *skb, char *desc)
  186. {
  187. int i;
  188. long flags;
  190. save_flags(flags);
  191. cli();
  192. printk(KERN_DEBUG "%6s: skb dump (%s) follows:", dev->name, desc);
  193. for (i = 0; i < skb->len; i++) {
  194. if (i % 16 == 0)
  195. printk("n" KERN_DEBUG "[%04X] ", i);
  196. printk("%02X ", ((u_char *) skb->data)[i]);
  197. }
  198. printk("n");
  199. restore_flags(flags);
  200. }
  202. EXPORT_SYMBOL(arcnet_dump_skb);
  203. #endif
  206. /*
  207.  * Dump the contents of an ARCnet buffer
  208.  */
  209. #if (ARCNET_DEBUG_MAX & (D_RX | D_TX))
  210. void arcnet_dump_packet(struct net_device *dev, int bufnum, char *desc)
  211. {
  212. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  213. int i, length;
  214. long flags;
  215. static uint8_t buf[512];
  217. save_flags(flags);
  218. cli();
  220. lp->hw.copy_from_card(dev, bufnum, 0, buf, 512);
  222. /* if the offset[0] byte is nonzero, this is a 256-byte packet */
  223. length = (buf[2] ? 256 : 512);
  225. printk(KERN_DEBUG "%6s: packet dump (%s) follows:", dev->name, desc);
  226. for (i = 0; i < length; i++) {
  227. if (i % 16 == 0)
  228. printk("n" KERN_DEBUG "[%04X] ", i);
  229. printk("%02X ", buf[i]);
  230. }
  231. printk("n");
  233. restore_flags(flags);
  234. }
  236. EXPORT_SYMBOL(arcnet_dump_packet);
  237. #endif
  240. /*
  241.  * Unregister a protocol driver from the arc_proto_map.  Protocol drivers
  242.  * are responsible for registering themselves, but the unregister routine
  243.  * is pretty generic so we'll do it here.
  244.  */
  245. void arcnet_unregister_proto(struct ArcProto *proto)
  246. {
  247. int count;
  249. if (arc_proto_default == proto)
  250. arc_proto_default = &arc_proto_null;
  251. if (arc_bcast_proto == proto)
  252. arc_bcast_proto = arc_proto_default;
  254. for (count = 0; count < 256; count++) {
  255. if (arc_proto_map[count] == proto)
  256. arc_proto_map[count] = arc_proto_default;
  257. }
  258. }
  261. /*
  262.  * Add a buffer to the queue.  Only the interrupt handler is allowed to do
  263.  * this, unless interrupts are disabled.
  264.  * 
  265.  * Note: we don't check for a full queue, since there aren't enough buffers
  266.  * to more than fill it.
  267.  */
  268. static void release_arcbuf(struct net_device *dev, int bufnum)
  269. {
  270. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  271. int i;
  273. lp->buf_queue[lp->first_free_buf++] = bufnum;
  274. lp->first_free_buf %= 5;
  276. BUGLVL(D_DURING) {
  277. BUGMSG(D_DURING, "release_arcbuf: freed #%d; buffer queue is now: ",
  278.        bufnum);
  279. for (i = lp->next_buf; i != lp->first_free_buf; i = ++i % 5)
  280. BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);
  281. BUGMSG2(D_DURING, "n");
  282. }
  283. }
  286. /*
  287.  * Get a buffer from the queue.  If this returns -1, there are no buffers
  288.  * available.
  289.  */
  290. static int get_arcbuf(struct net_device *dev)
  291. {
  292. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  293. int buf = -1, i;
  295. if (!atomic_dec_and_test(&lp->buf_lock)) /* already in this function */
  296. BUGMSG(D_NORMAL, "get_arcbuf: overlap (%d)!n", lp->buf_lock.counter);
  297. else { /* we can continue */
  298. if (lp->next_buf >= 5)
  299. lp->next_buf -= 5;
  301. if (lp->next_buf == lp->first_free_buf)
  302. BUGMSG(D_NORMAL, "get_arcbuf: BUG: no buffers are available??n");
  303. else {
  304. buf = lp->buf_queue[lp->next_buf++];
  305. lp->next_buf %= 5;
  306. }
  307. }
  310. BUGLVL(D_DURING) {
  311. BUGMSG(D_DURING, "get_arcbuf: got #%d; buffer queue is now: ", buf);
  312. for (i = lp->next_buf; i != lp->first_free_buf; i = ++i % 5)
  313. BUGMSG2(D_DURING, "#%d ", lp->buf_queue[i]);
  314. BUGMSG2(D_DURING, "n");
  315. }
  317. atomic_inc(&lp->buf_lock);
  318. return buf;
  319. }
  322. static int choose_mtu(void)
  323. {
  324. int count, mtu = 65535;
  326. /* choose the smallest MTU of all available encaps */
  327. for (count = 0; count < 256; count++) {
  328. if (arc_proto_map[count] != &arc_proto_null
  329.     && arc_proto_map[count]->mtu < mtu) {
  330. mtu = arc_proto_map[count]->mtu;
  331. }
  332. }
  334. return mtu == 65535 ? XMTU : mtu;
  335. }
  338. /* Setup a struct device for ARCnet. */
  339. void arcdev_setup(struct net_device *dev)
  340. {
  341. dev->type = ARPHRD_ARCNET;
  342. dev->hard_header_len = sizeof(struct archdr);
  343. dev->mtu = choose_mtu();
  345. dev->addr_len = 1;
  346. dev->tx_queue_len = 30;
  347. dev->broadcast[0] = 0x00; /* for us, broadcasts are address 0 */
  348. dev->watchdog_timeo = TX_TIMEOUT;
  350. /* New-style flags. */
  351. dev->flags = IFF_BROADCAST;
  353. /*
  354.  * Put in this stuff here, so we don't have to export the symbols to
  355.  * the chipset drivers.
  356.  */
  357. dev->open = arcnet_open;
  358. dev->stop = arcnet_close;
  359. dev->hard_start_xmit = arcnet_send_packet;
  360. dev->tx_timeout = arcnet_timeout;
  361. dev->get_stats = arcnet_get_stats;
  362. dev->hard_header = arcnet_header;
  363. dev->rebuild_header = arcnet_rebuild_header;
  364. }
  367. /*
  368.  * Open/initialize the board.  This is called sometime after booting when
  369.  * the 'ifconfig' program is run.
  370.  *
  371.  * This routine should set everything up anew at each open, even registers
  372.  * that "should" only need to be set once at boot, so that there is
  373.  * non-reboot way to recover if something goes wrong.
  374.  */
  375. static int arcnet_open(struct net_device *dev)
  376. {
  377. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  378. int count, newmtu;
  380. BUGLVL(D_PROTO) {
  381. int count;
  382. BUGMSG(D_PROTO, "protocol map (default is '%c'): ",
  383.        arc_proto_default->suffix);
  384. for (count = 0; count < 256; count++)
  385. BUGMSG2(D_PROTO, "%c", arc_proto_map[count]->suffix);
  386. BUGMSG2(D_PROTO, "n");
  387. }
  390. BUGMSG(D_INIT, "arcnet_open: resetting card.n");
  392. /* try to put the card in a defined state - if it fails the first
  393.  * time, actually reset it.
  394.  */
  395. if (ARCRESET(0) && ARCRESET(1))
  396. return -ENODEV;
  398. newmtu = choose_mtu();
  399. if (newmtu < dev->mtu)
  400. dev->mtu = newmtu;
  402. /* autodetect the encapsulation for each host. */
  403. memset(lp->default_proto, 0, sizeof(lp->default_proto));
  405. /* the broadcast address is special - use the 'bcast' protocol */
  406. for (count = 0; count < 256; count++) {
  407. if (arc_proto_map[count] == arc_bcast_proto) {
  408. lp->default_proto[0] = count;
  409. break;
  410. }
  411. }
  413. /* initialize buffers */
  414. atomic_set(&lp->buf_lock, 1);
  415. lp->next_buf = lp->first_free_buf = 0;
  416. release_arcbuf(dev, 0);
  417. release_arcbuf(dev, 1);
  418. release_arcbuf(dev, 2);
  419. release_arcbuf(dev, 3);
  420. lp->cur_tx = lp->next_tx = -1;
  421. lp->cur_rx = -1;
  423. lp->rfc1201.sequence = 1;
  425. /* bring up the hardware driver */
  426. ARCOPEN(1);
  428. if (dev->dev_addr[0] == 0)
  429. BUGMSG(D_NORMAL, "WARNING!  Station address 00 is reserved "
  430.        "for broadcasts!n");
  431. else if (dev->dev_addr[0] == 255)
  432. BUGMSG(D_NORMAL, "WARNING!  Station address FF may confuse "
  433.        "DOS networking programs!n");
  435. if (ASTATUS() & RESETflag)
  436. ACOMMAND(CFLAGScmd | RESETclear);
  438. /* make sure we're ready to receive IRQ's. */
  439. AINTMASK(0);
  440. udelay(1); /* give it time to set the mask before
  441.  * we reset it again. (may not even be
  442.  * necessary)
  443.  */
  444. lp->intmask = NORXflag | RECONflag;
  445. AINTMASK(lp->intmask);
  447. netif_start_queue(dev);
  449. return 0;
  450. }
  453. /* The inverse routine to arcnet_open - shuts down the card. */
  454. static int arcnet_close(struct net_device *dev)
  455. {
  456. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  458. netif_stop_queue(dev);
  460. /* flush TX and disable RX */
  461. AINTMASK(0);
  462. ACOMMAND(NOTXcmd); /* stop transmit */
  463. ACOMMAND(NORXcmd); /* disable receive */
  464. mdelay(1);
  466. /* shut down the card */
  467. ARCOPEN(0);
  469. return 0;
  470. }
  473. static int arcnet_header(struct sk_buff *skb, struct net_device *dev,
  474.  unsigned short type, void *daddr, void *saddr,
  475.  unsigned len)
  476. {
  477. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  478. uint8_t _daddr, proto_num;
  479. struct ArcProto *proto;
  481. BUGMSG(D_DURING,
  482.     "create header from %d to %d; protocol %d (%Xh); size %u.n",
  483.        saddr ? *(uint8_t *) saddr : -1,
  484.        daddr ? *(uint8_t *) daddr : -1,
  485.        type, type, len);
  487. if (len != skb->len)
  488. BUGMSG(D_NORMAL, "arcnet_header: Yikes!  skb->len(%d) != len(%d)!n",
  489.        skb->len, len);
  491. /*
  492.  * if the dest addr isn't provided, we can't choose an encapsulation!
  493.  * Store the packet type (eg. ETH_P_IP) for now, and we'll push on a
  494.  * real header when we do rebuild_header. 
  495.  */
  496. if (!daddr) {
  497. *(uint16_t *) skb_push(skb, 2) = type;
  498. if (skb->nh.raw - skb->mac.raw != 2)
  499. BUGMSG(D_NORMAL, "arcnet_header: Yikes!  diff (%d) is not 2!n",
  500.        skb->nh.raw - skb->mac.raw);
  501. return -2; /* return error -- can't transmit yet! */
  502. }
  503. /* otherwise, we can just add the header as usual. */
  504. _daddr = *(uint8_t *) daddr;
  505. proto_num = lp->default_proto[_daddr];
  506. proto = arc_proto_map[proto_num];
  507. BUGMSG(D_DURING, "building header for %02Xh using protocol '%c'n",
  508.        proto_num, proto->suffix);
  509. if (proto == &arc_proto_null && arc_bcast_proto != proto) {
  510. BUGMSG(D_DURING, "actually, let's use '%c' instead.n",
  511.        arc_bcast_proto->suffix);
  512. proto = arc_bcast_proto;
  513. }
  514. return proto->build_header(skb, type, _daddr);
  515. }
  518. /* 
  519.  * Rebuild the ARCnet hard header. This is called after an ARP (or in the
  520.  * future other address resolution) has completed on this sk_buff. We now
  521.  * let ARP fill in the destination field.
  522.  */
  523. static int arcnet_rebuild_header(struct sk_buff *skb)
  524. {
  525. struct net_device *dev = skb->dev;
  526. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  527. int status = 0; /* default is failure */
  528. unsigned short type;
  529. uint8_t daddr=0;
  531. if (skb->nh.raw - skb->mac.raw != 2) {
  532. BUGMSG(D_NORMAL,
  533.      "rebuild_header: shouldn't be here! (hdrsize=%d)n",
  534.        skb->nh.raw - skb->mac.raw);
  535. return 0;
  536. }
  537. type = *(uint16_t *) skb_pull(skb, 2);
  539. if (type == ETH_P_IP) {
  540. #ifdef CONFIG_INET
  541. BUGMSG(D_DURING, "rebuild header for ethernet protocol %Xhn", type);
  542. status = arp_find(&daddr, skb) ? 1 : 0;
  543. BUGMSG(D_DURING, " rebuilt: dest is %d; protocol %Xhn",
  544.        daddr, type);
  545. #endif
  546. } else {
  547. BUGMSG(D_NORMAL,
  548.        "I don't understand ethernet protocol %Xh addresses!n", type);
  549. lp->stats.tx_errors++;
  550. lp->stats.tx_aborted_errors++;
  551. }
  553. /* if we couldn't resolve the address... give up. */
  554. if (!status)
  555. return 0;
  557. /* add the _real_ header this time! */
  558. arc_proto_map[lp->default_proto[daddr]]->build_header(skb, type, daddr);
  560. return 1; /* success */
  561. }
  565. /* Called by the kernel in order to transmit a packet. */
  566. static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
  567. {
  568. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  569. struct archdr *pkt;
  570. struct arc_rfc1201 *soft;
  571. struct ArcProto *proto;
  572. int txbuf;
  574. BUGMSG(D_DURING,
  575.        "transmit requested (status=%Xh, txbufs=%d/%d, len=%d)n",
  576.        ASTATUS(), lp->cur_tx, lp->next_tx, skb->len);
  578. pkt = (struct archdr *) skb->data;
  579. soft = &pkt->soft.rfc1201;
  580. proto = arc_proto_map[soft->proto];
  582. BUGMSG(D_SKB_SIZE, "skb: transmitting %d bytes to %02Xn",
  583. skb->len, pkt->hard.dest);
  584. BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "tx");
  586. /* fits in one packet? */
  587. if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {
  588. BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!n");
  589. dev_kfree_skb(skb);
  590. return 0; /* don't try again */
  591. }
  593. /* We're busy transmitting a packet... */
  594. netif_stop_queue(dev);
  596. AINTMASK(0);
  598. txbuf = get_arcbuf(dev);
  599. if (txbuf != -1) {
  600. if (proto->prepare_tx(dev, pkt, skb->len, txbuf)) {
  601. /* done right away */
  602. lp->stats.tx_bytes += skb->len;
  603. dev_kfree_skb(skb);
  604. } else {
  605. /* do it the 'split' way */
  606. lp->outgoing.proto = proto;
  607. lp->outgoing.skb = skb;
  608. lp->outgoing.pkt = pkt;
  610. if (!proto->continue_tx)
  611. BUGMSG(D_NORMAL, "bug! prep_tx==0, but no continue_tx!n");
  612. else if (proto->continue_tx(dev, txbuf)) {
  613. BUGMSG(D_NORMAL,
  614.        "bug! continue_tx finished the first time! "
  615.        "(proto='%c')n", proto->suffix);
  616. }
  617. }
  619. lp->next_tx = txbuf;
  620. } else
  621. dev_kfree_skb(skb);
  623. /* make sure we didn't ignore a TX IRQ while we were in here */
  624. AINTMASK(0);
  625. lp->intmask |= TXFREEflag;
  626. AINTMASK(lp->intmask);
  628. return 0; /* no need to try again */
  629. }
  632. /*
  633.  * Actually start transmitting a packet that was loaded into a buffer
  634.  * by prepare_tx.  This should _only_ be called by the interrupt handler.
  635.  */
  636. static int go_tx(struct net_device *dev)
  637. {
  638. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  640. BUGMSG(D_DURING, "go_tx: status=%Xh, intmask=%Xh, next_tx=%d, cur_tx=%dn",
  641.        ASTATUS(), lp->intmask, lp->next_tx, lp->cur_tx);
  643. if (lp->cur_tx != -1 || lp->next_tx == -1)
  644. return 0;
  646. BUGLVL(D_TX) arcnet_dump_packet(dev, lp->next_tx, "go_tx");
  648. lp->cur_tx = lp->next_tx;
  649. lp->next_tx = -1;
  651. /* start sending */
  652. ACOMMAND(TXcmd | (lp->cur_tx << 3));
  654. dev->trans_start = jiffies;
  655. lp->stats.tx_packets++;
  656. lp->lasttrans_dest = lp->lastload_dest;
  657. lp->lastload_dest = 0;
  658. lp->intmask |= TXFREEflag;
  660. return 1;
  661. }
  664. /* Called by the kernel when transmit times out */
  665. static void arcnet_timeout(struct net_device *dev)
  666. {
  667. unsigned long flags;
  668. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  669. int status = ASTATUS();
  670. char *msg;
  672. save_flags(flags);
  673. cli();
  675. if (status & TXFREEflag) { /* transmit _DID_ finish */
  676. msg = " - missed IRQ?";
  677. } else {
  678. msg = "";
  679. lp->stats.tx_aborted_errors++;
  680. lp->timed_out = 1;
  681. ACOMMAND(NOTXcmd | (lp->cur_tx << 3));
  682. }
  683. lp->stats.tx_errors++;
  685. /* make sure we didn't miss a TX IRQ */
  686. AINTMASK(0);
  687. lp->intmask |= TXFREEflag;
  688. AINTMASK(lp->intmask);
  690. restore_flags(flags);
  692. if (jiffies - lp->last_timeout > 10*HZ) {
  693. BUGMSG(D_EXTRA, "tx timed out%s (status=%Xh, intmask=%Xh, dest=%02Xh)n",
  694.        msg, status, lp->intmask, lp->lasttrans_dest);
  695. lp->last_timeout = jiffies;
  696. }
  698. if (lp->cur_tx == -1)
  699. netif_wake_queue(dev);
  700. }
  703. /*
  704.  * The typical workload of the driver: Handle the network interface
  705.  * interrupts. Establish which device needs attention, and call the correct
  706.  * chipset interrupt handler.
  707.  */
  708. void arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  709. {
  710. struct net_device *dev = dev_id;
  711. struct arcnet_local *lp;
  712. int recbuf, status, didsomething, boguscount;
  714. BUGMSG(D_DURING, "n");
  716. if (dev == NULL) {
  717. BUGMSG(D_DURING, "arcnet: irq %d for unknown device.n", irq);
  718. return;
  719. }
  720. BUGMSG(D_DURING, "in arcnet_interruptn");
  722. lp = (struct arcnet_local *) dev->priv;
  723. if (!lp) {
  724. BUGMSG(D_DURING, "arcnet: irq ignored due to missing lp.n");
  725. return;
  726. }
  727. /*
  728.  * RESET flag was enabled - if device is not running, we must clear it right
  729.  * away (but nothing else).
  730.  */
  731. if (!netif_running(dev)) {
  732. if (ASTATUS() & RESETflag)
  733. ACOMMAND(CFLAGScmd | RESETclear);
  734. AINTMASK(0);
  735. return;
  736. }
  738. BUGMSG(D_DURING, "in arcnet_inthandler (status=%Xh, intmask=%Xh)n",
  739.        ASTATUS(), lp->intmask);
  741. boguscount = 5;
  742. do {
  743. status = ASTATUS();
  744. didsomething = 0;
  746. /*
  747.  * RESET flag was enabled - card is resetting and if RX is
  748.  * disabled, it's NOT because we just got a packet.
  749.  * 
  750.  * The card is in an undefined state.  Clear it out and start over.
  751.  */
  752. if (status & RESETflag) {
  753. BUGMSG(D_NORMAL, "spurious reset (status=%Xh)n", status);
  754. arcnet_close(dev);
  755. arcnet_open(dev);
  757. /* get out of the interrupt handler! */
  758. break;
  759. }
  760. /* 
  761.  * RX is inhibited - we must have received something. Prepare to
  762.  * receive into the next buffer.
  763.  * 
  764.  * We don't actually copy the received packet from the card until
  765.  * after the transmit handler runs (and possibly launches the next
  766.  * tx); this should improve latency slightly if we get both types
  767.  * of interrupts at once. 
  768.  */
  769. recbuf = -1;
  770. if (status & lp->intmask & NORXflag) {
  771. recbuf = lp->cur_rx;
  772. BUGMSG(D_DURING, "Buffer #%d: receive irq (status=%Xh)n",
  773.        recbuf, status);
  775. lp->cur_rx = get_arcbuf(dev);
  776. if (lp->cur_rx != -1) {
  777. BUGMSG(D_DURING, "enabling receive to buffer #%dn",
  778.        lp->cur_rx);
  779. ACOMMAND(RXcmd | (lp->cur_rx << 3) | RXbcasts);
  780. }
  781. didsomething++;
  782. }
  783. /* a transmit finished, and we're interested in it. */
  784. if ((status & lp->intmask & TXFREEflag) || lp->timed_out) {
  785. lp->intmask &= ~TXFREEflag;
  787. BUGMSG(D_DURING, "TX IRQ (stat=%Xh)n", status);
  789. if (lp->cur_tx != -1 && !(status & TXACKflag) && !lp->timed_out) {
  790. if (lp->lasttrans_dest != 0) {
  791. BUGMSG(D_EXTRA, "transmit was not acknowledged! "
  792.     "(status=%Xh, dest=%02Xh)n",
  793.      status, lp->lasttrans_dest);
  794. lp->stats.tx_errors++;
  795. lp->stats.tx_carrier_errors++;
  796. } else {
  797. BUGMSG(D_DURING,
  798.        "broadcast was not acknowledged; that's normal "
  799.     "(status=%Xh, dest=%02Xh)n",
  800.      status, lp->lasttrans_dest);
  801. }
  802. }
  803. if (lp->cur_tx != -1)
  804. release_arcbuf(dev, lp->cur_tx);
  806. lp->cur_tx = -1;
  807. lp->timed_out = 0;
  808. didsomething++;
  810. /* send another packet if there is one */
  811. go_tx(dev);
  813. /* continue a split packet, if any */
  814. if (lp->outgoing.proto && lp->outgoing.proto->continue_tx) {
  815. int txbuf = get_arcbuf(dev);
  816. if (txbuf != -1) {
  817. if (lp->outgoing.proto->continue_tx(dev, txbuf)) {
  818. /* that was the last segment */
  819. lp->stats.tx_bytes += lp->outgoing.skb->len;
  820. dev_kfree_skb_irq(lp->outgoing.skb);
  821. lp->outgoing.proto = NULL;
  822. }
  823. lp->next_tx = txbuf;
  824. }
  825. }
  826. /* inform upper layers of idleness, if necessary */
  827. if (lp->cur_tx == -1)
  828. netif_wake_queue(dev);
  829. }
  830. /* now process the received packet, if any */
  831. if (recbuf != -1) {
  832. BUGLVL(D_RX) arcnet_dump_packet(dev, recbuf, "rx irq");
  834. arcnet_rx(dev, recbuf);
  835. release_arcbuf(dev, recbuf);
  837. didsomething++;
  838. }
  839. if (status & lp->intmask & RECONflag) {
  840. ACOMMAND(CFLAGScmd | CONFIGclear);
  841. lp->stats.tx_carrier_errors++;
  843. BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)n",
  844.        status);
  846. /* is the RECON info empty or old? */
  847. if (!lp->first_recon || !lp->last_recon ||
  848.     jiffies - lp->last_recon > HZ * 10) {
  849. if (lp->network_down)
  850. BUGMSG(D_NORMAL, "reconfiguration detected: cabling restored?n");
  851. lp->first_recon = lp->last_recon = jiffies;
  852. lp->num_recons = lp->network_down = 0;
  854. BUGMSG(D_DURING, "recon: clearing counters.n");
  855. } else { /* add to current RECON counter */
  856. lp->last_recon = jiffies;
  857. lp->num_recons++;
  859. BUGMSG(D_DURING, "recon: counter=%d, time=%lds, net=%dn",
  860.        lp->num_recons,
  861.  (lp->last_recon - lp->first_recon) / HZ,
  862.        lp->network_down);
  864. /* if network is marked up;
  865.  * and first_recon and last_recon are 60+ apart;
  866.  * and the average no. of recons counted is
  867.  *    > RECON_THRESHOLD/min;
  868.  * then print a warning message.
  869.  */
  870. if (!lp->network_down
  871.     && (lp->last_recon - lp->first_recon) <= HZ * 60
  872.   && lp->num_recons >= RECON_THRESHOLD) {
  873. lp->network_down = 1;
  874. BUGMSG(D_NORMAL, "many reconfigurations detected: cabling problem?n");
  875. } else if (!lp->network_down
  876.    && lp->last_recon - lp->first_recon > HZ * 60) {
  877. /* reset counters if we've gone for over a minute. */
  878. lp->first_recon = lp->last_recon;
  879. lp->num_recons = 1;
  880. }
  881. }
  882. } else if (lp->network_down && jiffies - lp->last_recon > HZ * 10) {
  883. if (lp->network_down)
  884. BUGMSG(D_NORMAL, "cabling restored?n");
  885. lp->first_recon = lp->last_recon = 0;
  886. lp->num_recons = lp->network_down = 0;
  888. BUGMSG(D_DURING, "not recon: clearing counters anyway.n");
  889. }
  890. }
  891. while (--boguscount && didsomething);
  893. BUGMSG(D_DURING, "arcnet_interrupt complete (status=%Xh, count=%d)n",
  894.        ASTATUS(), boguscount);
  895. BUGMSG(D_DURING, "n");
  898. AINTMASK(0);
  899. udelay(1);
  900. AINTMASK(lp->intmask);
  901. }
  904. /*
  905.  * This is a generic packet receiver that calls arcnet??_rx depending on the
  906.  * protocol ID found.
  907.  */
  908. void arcnet_rx(struct net_device *dev, int bufnum)
  909. {
  910. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  911. struct archdr pkt;
  912. struct arc_rfc1201 *soft;
  913. int length, ofs;
  915. soft = &pkt.soft.rfc1201;
  917. lp->hw.copy_from_card(dev, bufnum, 0, &pkt, sizeof(ARC_HDR_SIZE));
  918. if (pkt.hard.offset[0]) {
  919. ofs = pkt.hard.offset[0];
  920. length = 256 - ofs;
  921. } else {
  922. ofs = pkt.hard.offset[1];
  923. length = 512 - ofs;
  924. }
  926. /* get the full header, if possible */
  927. if (sizeof(pkt.soft) < length)
  928. lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft));
  929. else {
  930. memset(&pkt.soft, 0, sizeof(pkt.soft));
  931. lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);
  932. }
  934. BUGMSG(D_DURING, "Buffer #%d: received packet from %02Xh to %02Xh "
  935.        "(%d+4 bytes)n",
  936.        bufnum, pkt.hard.source, pkt.hard.dest, length);
  938. lp->stats.rx_packets++;
  939. lp->stats.rx_bytes += length + ARC_HDR_SIZE;
  941. /* call the right receiver for the protocol */
  942. if (arc_proto_map[soft->proto] != &arc_proto_null) {
  943. BUGLVL(D_PROTO) {
  944. struct ArcProto
  945. *oldp = arc_proto_map[lp->default_proto[pkt.hard.source]],
  946. *newp = arc_proto_map[soft->proto];
  948. if (oldp != newp) {
  949. BUGMSG(D_PROTO,
  950.        "got protocol %02Xh; encap for host %02Xh is now '%c'"
  951.        " (was '%c')n", soft->proto, pkt.hard.source,
  952.        newp->suffix, oldp->suffix);
  953. }
  954. }
  956. /* broadcasts will always be done with the last-used encap. */
  957. lp->default_proto[0] = soft->proto;
  959. /* in striking contrast, the following isn't a hack. */
  960. lp->default_proto[pkt.hard.source] = soft->proto;
  961. }
  962. /* call the protocol-specific receiver. */
  963. arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length);
  964. }
  968. /* 
  969.  * Get the current statistics.  This may be called with the card open or
  970.  * closed.
  971.  */
  972. static struct net_device_stats *arcnet_get_stats(struct net_device *dev)
  973. {
  974. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  975. return &lp->stats;
  976. }
  979. static void null_rx(struct net_device *dev, int bufnum,
  980.     struct archdr *pkthdr, int length)
  981. {
  982. BUGMSG(D_PROTO,
  983. "rx: don't know how to deal with proto %02Xh from host %02Xh.n",
  984.        pkthdr->soft.rfc1201.proto, pkthdr->hard.source);
  985. }
  988. static int null_build_header(struct sk_buff *skb, unsigned short type,
  989.      uint8_t daddr)
  990. {
  991. struct net_device *dev = skb->dev;
  992. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  994. BUGMSG(D_PROTO,
  995.        "tx: can't build header for encap %02Xh; load a protocol driver.n",
  996.        lp->default_proto[daddr]);
  998. /* always fails */
  999. return 0;
  1000. }
  1003. /* the "do nothing" prepare_tx function warns that there's nothing to do. */
  1004. static int null_prepare_tx(struct net_device *dev, struct archdr *pkt,
  1005.    int length, int bufnum)
  1006. {
  1007. struct arcnet_local *lp = (struct arcnet_local *) dev->priv;
  1008. struct arc_hardware newpkt;
  1010. BUGMSG(D_PROTO, "tx: no encap for this host; load a protocol driver.n");
  1012. /* send a packet to myself -- will never get received, of course */
  1013. newpkt.source = newpkt.dest = dev->dev_addr[0];
  1015. /* only one byte of actual data (and it's random) */
  1016. newpkt.offset[0] = 0xFF;
  1018. lp->hw.copy_to_card(dev, bufnum, 0, &newpkt, ARC_HDR_SIZE);
  1020. return 1; /* done */
  1021. }