rfc1051.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
  1. /*
  2. * Linux ARCnet driver - RFC1051 ("simple" standard) packet encapsulation
  3. *
  4. * Written 1994-1999 by Avery Pennarun.
  5. * Derived from skeleton.c by Donald Becker.
  6. *
  7. * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
  8. * for sponsoring the further development of this driver.
  9. *
  10. * **********************
  11. *
  12. * The original copyright of skeleton.c was as follows:
  13. *
  14. * skeleton.c Written 1993 by Donald Becker.
  15. * Copyright 1993 United States Government as represented by the
  16. * Director, National Security Agency. This software may only be used
  17. * and distributed according to the terms of the GNU General Public License as
  18. * modified by SRC, incorporated herein by reference.
  19. *
  20. * **********************
  21. *
  22. * For more details, see drivers/net/arcnet.c
  23. *
  24. * **********************
  25. */
  26. #define pr_fmt(fmt) "arcnet:" KBUILD_MODNAME ": " fmt
  27. #include <linux/module.h>
  28. #include <linux/gfp.h>
  29. #include <linux/init.h>
  30. #include <linux/if_arp.h>
  31. #include <net/arp.h>
  32. #include <linux/netdevice.h>
  33. #include <linux/skbuff.h>
  34. #include "arcdevice.h"
  35. static __be16 type_trans(struct sk_buff *skb, struct net_device *dev);
  36. static void rx(struct net_device *dev, int bufnum,
  37. struct archdr *pkthdr, int length);
  38. static int build_header(struct sk_buff *skb, struct net_device *dev,
  39. unsigned short type, uint8_t daddr);
  40. static int prepare_tx(struct net_device *dev, struct archdr *pkt, int length,
  41. int bufnum);
  42. static struct ArcProto rfc1051_proto = {
  43. .suffix = 's',
  44. .mtu = XMTU - RFC1051_HDR_SIZE,
  45. .is_ip = 1,
  46. .rx = rx,
  47. .build_header = build_header,
  48. .prepare_tx = prepare_tx,
  49. .continue_tx = NULL,
  50. .ack_tx = NULL
  51. };
  52. static int __init arcnet_rfc1051_init(void)
  53. {
  54. pr_info("%s\n", "RFC1051 \"simple standard\" (`s') encapsulation support loaded");
  55. arc_proto_map[ARC_P_IP_RFC1051]
  56. = arc_proto_map[ARC_P_ARP_RFC1051]
  57. = &rfc1051_proto;
  58. /* if someone else already owns the broadcast, we won't take it */
  59. if (arc_bcast_proto == arc_proto_default)
  60. arc_bcast_proto = &rfc1051_proto;
  61. return 0;
  62. }
  63. static void __exit arcnet_rfc1051_exit(void)
  64. {
  65. arcnet_unregister_proto(&rfc1051_proto);
  66. }
  67. module_init(arcnet_rfc1051_init);
  68. module_exit(arcnet_rfc1051_exit);
  69. MODULE_LICENSE("GPL");
  70. /* Determine a packet's protocol ID.
  71. *
  72. * With ARCnet we have to convert everything to Ethernet-style stuff.
  73. */
  74. static __be16 type_trans(struct sk_buff *skb, struct net_device *dev)
  75. {
  76. struct archdr *pkt = (struct archdr *)skb->data;
  77. struct arc_rfc1051 *soft = &pkt->soft.rfc1051;
  78. int hdr_size = ARC_HDR_SIZE + RFC1051_HDR_SIZE;
  79. /* Pull off the arcnet header. */
  80. skb_reset_mac_header(skb);
  81. skb_pull(skb, hdr_size);
  82. if (pkt->hard.dest == 0) {
  83. skb->pkt_type = PACKET_BROADCAST;
  84. } else if (dev->flags & IFF_PROMISC) {
  85. /* if we're not sending to ourselves :) */
  86. if (pkt->hard.dest != dev->dev_addr[0])
  87. skb->pkt_type = PACKET_OTHERHOST;
  88. }
  89. /* now return the protocol number */
  90. switch (soft->proto) {
  91. case ARC_P_IP_RFC1051:
  92. return htons(ETH_P_IP);
  93. case ARC_P_ARP_RFC1051:
  94. return htons(ETH_P_ARP);
  95. default:
  96. dev->stats.rx_errors++;
  97. dev->stats.rx_crc_errors++;
  98. return 0;
  99. }
  100. return htons(ETH_P_IP);
  101. }
  102. /* packet receiver */
  103. static void rx(struct net_device *dev, int bufnum,
  104. struct archdr *pkthdr, int length)
  105. {
  106. struct arcnet_local *lp = netdev_priv(dev);
  107. struct sk_buff *skb;
  108. struct archdr *pkt = pkthdr;
  109. int ofs;
  110. arc_printk(D_DURING, dev, "it's a raw packet (length=%d)\n", length);
  111. if (length >= MinTU)
  112. ofs = 512 - length;
  113. else
  114. ofs = 256 - length;
  115. skb = alloc_skb(length + ARC_HDR_SIZE, GFP_ATOMIC);
  116. if (!skb) {
  117. dev->stats.rx_dropped++;
  118. return;
  119. }
  120. skb_put(skb, length + ARC_HDR_SIZE);
  121. skb->dev = dev;
  122. pkt = (struct archdr *)skb->data;
  123. /* up to sizeof(pkt->soft) has already been copied from the card */
  124. memcpy(pkt, pkthdr, sizeof(struct archdr));
  125. if (length > sizeof(pkt->soft))
  126. lp->hw.copy_from_card(dev, bufnum, ofs + sizeof(pkt->soft),
  127. pkt->soft.raw + sizeof(pkt->soft),
  128. length - sizeof(pkt->soft));
  129. if (BUGLVL(D_SKB))
  130. arcnet_dump_skb(dev, skb, "rx");
  131. skb->protocol = type_trans(skb, dev);
  132. netif_rx(skb);
  133. }
  134. /* Create the ARCnet hard/soft headers for RFC1051 */
  135. static int build_header(struct sk_buff *skb, struct net_device *dev,
  136. unsigned short type, uint8_t daddr)
  137. {
  138. int hdr_size = ARC_HDR_SIZE + RFC1051_HDR_SIZE;
  139. struct archdr *pkt = skb_push(skb, hdr_size);
  140. struct arc_rfc1051 *soft = &pkt->soft.rfc1051;
  141. /* set the protocol ID according to RFC1051 */
  142. switch (type) {
  143. case ETH_P_IP:
  144. soft->proto = ARC_P_IP_RFC1051;
  145. break;
  146. case ETH_P_ARP:
  147. soft->proto = ARC_P_ARP_RFC1051;
  148. break;
  149. default:
  150. arc_printk(D_NORMAL, dev, "RFC1051: I don't understand protocol %d (%Xh)\n",
  151. type, type);
  152. dev->stats.tx_errors++;
  153. dev->stats.tx_aborted_errors++;
  154. return 0;
  155. }
  156. /* Set the source hardware address.
  157. *
  158. * This is pretty pointless for most purposes, but it can help in
  159. * debugging. ARCnet does not allow us to change the source address
  160. * in the actual packet sent.
  161. */
  162. pkt->hard.source = *dev->dev_addr;
  163. /* see linux/net/ethernet/eth.c to see where I got the following */
  164. if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
  165. /* FIXME: fill in the last byte of the dest ipaddr here to
  166. * better comply with RFC1051 in "noarp" mode.
  167. */
  168. pkt->hard.dest = 0;
  169. return hdr_size;
  170. }
  171. /* otherwise, just fill it in and go! */
  172. pkt->hard.dest = daddr;
  173. return hdr_size; /* success */
  174. }
  175. static int prepare_tx(struct net_device *dev, struct archdr *pkt, int length,
  176. int bufnum)
  177. {
  178. struct arcnet_local *lp = netdev_priv(dev);
  179. struct arc_hardware *hard = &pkt->hard;
  180. int ofs;
  181. arc_printk(D_DURING, dev, "prepare_tx: txbufs=%d/%d/%d\n",
  182. lp->next_tx, lp->cur_tx, bufnum);
  183. /* hard header is not included in packet length */
  184. length -= ARC_HDR_SIZE;
  185. if (length > XMTU) {
  186. /* should never happen! other people already check for this. */
  187. arc_printk(D_NORMAL, dev, "Bug! prepare_tx with size %d (> %d)\n",
  188. length, XMTU);
  189. length = XMTU;
  190. }
  191. if (length > MinTU) {
  192. hard->offset[0] = 0;
  193. hard->offset[1] = ofs = 512 - length;
  194. } else if (length > MTU) {
  195. hard->offset[0] = 0;
  196. hard->offset[1] = ofs = 512 - length - 3;
  197. } else {
  198. hard->offset[0] = ofs = 256 - length;
  199. }
  200. lp->hw.copy_to_card(dev, bufnum, 0, hard, ARC_HDR_SIZE);
  201. lp->hw.copy_to_card(dev, bufnum, ofs, &pkt->soft, length);
  202. lp->lastload_dest = hard->dest;
  203. return 1; /* done */
  204. }