capmode.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  1. /*
  2. * Linux ARCnet driver - "cap mode" packet encapsulation.
  3. * It adds sequence numbers to packets for communicating between a user space
  4. * application and the driver. After a transmit it sends a packet with protocol
  5. * byte 0 back up to the userspace containing the sequence number of the packet
  6. * plus the transmit-status on the ArcNet.
  7. *
  8. * Written 2002-4 by Esben Nielsen, Vestas Wind Systems A/S
  9. * Derived from arc-rawmode.c by Avery Pennarun.
  10. * arc-rawmode was in turned based on skeleton.c, see below.
  11. *
  12. * **********************
  13. *
  14. * The original copyright of skeleton.c 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. * For more details, see drivers/net/arcnet.c
  25. *
  26. * **********************
  27. */
  28. #define pr_fmt(fmt) "arcnet:" KBUILD_MODNAME ": " fmt
  29. #include <linux/module.h>
  30. #include <linux/gfp.h>
  31. #include <linux/init.h>
  32. #include <linux/if_arp.h>
  33. #include <net/arp.h>
  34. #include <linux/netdevice.h>
  35. #include <linux/skbuff.h>
  36. #include "arcdevice.h"
  37. /* packet receiver */
  38. static void rx(struct net_device *dev, int bufnum,
  39. struct archdr *pkthdr, int length)
  40. {
  41. struct arcnet_local *lp = netdev_priv(dev);
  42. struct sk_buff *skb;
  43. struct archdr *pkt;
  44. char *pktbuf, *pkthdrbuf;
  45. int ofs;
  46. arc_printk(D_DURING, dev, "it's a raw(cap) packet (length=%d)\n",
  47. length);
  48. if (length >= MinTU)
  49. ofs = 512 - length;
  50. else
  51. ofs = 256 - length;
  52. skb = alloc_skb(length + ARC_HDR_SIZE + sizeof(int), GFP_ATOMIC);
  53. if (!skb) {
  54. dev->stats.rx_dropped++;
  55. return;
  56. }
  57. skb_put(skb, length + ARC_HDR_SIZE + sizeof(int));
  58. skb->dev = dev;
  59. skb_reset_mac_header(skb);
  60. pkt = (struct archdr *)skb_mac_header(skb);
  61. skb_pull(skb, ARC_HDR_SIZE);
  62. /* up to sizeof(pkt->soft) has already been copied from the card
  63. * squeeze in an int for the cap encapsulation
  64. * use these variables to be sure we count in bytes, not in
  65. * sizeof(struct archdr)
  66. */
  67. pktbuf = (char *)pkt;
  68. pkthdrbuf = (char *)pkthdr;
  69. memcpy(pktbuf, pkthdrbuf, ARC_HDR_SIZE + sizeof(pkt->soft.cap.proto));
  70. memcpy(pktbuf + ARC_HDR_SIZE + sizeof(pkt->soft.cap.proto) + sizeof(int),
  71. pkthdrbuf + ARC_HDR_SIZE + sizeof(pkt->soft.cap.proto),
  72. sizeof(struct archdr) - ARC_HDR_SIZE - sizeof(pkt->soft.cap.proto));
  73. if (length > sizeof(pkt->soft))
  74. lp->hw.copy_from_card(dev, bufnum, ofs + sizeof(pkt->soft),
  75. pkt->soft.raw + sizeof(pkt->soft)
  76. + sizeof(int),
  77. length - sizeof(pkt->soft));
  78. if (BUGLVL(D_SKB))
  79. arcnet_dump_skb(dev, skb, "rx");
  80. skb->protocol = cpu_to_be16(ETH_P_ARCNET);
  81. netif_rx(skb);
  82. }
  83. /* Create the ARCnet hard/soft headers for cap mode.
  84. * There aren't any soft headers in cap mode - not even the protocol id.
  85. */
  86. static int build_header(struct sk_buff *skb,
  87. struct net_device *dev,
  88. unsigned short type,
  89. uint8_t daddr)
  90. {
  91. int hdr_size = ARC_HDR_SIZE;
  92. struct archdr *pkt = skb_push(skb, hdr_size);
  93. arc_printk(D_PROTO, dev, "Preparing header for cap packet %x.\n",
  94. *((int *)&pkt->soft.cap.cookie[0]));
  95. /* Set the source hardware address.
  96. *
  97. * This is pretty pointless for most purposes, but it can help in
  98. * debugging. ARCnet does not allow us to change the source address in
  99. * the actual packet sent)
  100. */
  101. pkt->hard.source = *dev->dev_addr;
  102. /* see linux/net/ethernet/eth.c to see where I got the following */
  103. if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
  104. /* FIXME: fill in the last byte of the dest ipaddr here to
  105. * better comply with RFC1051 in "noarp" mode.
  106. */
  107. pkt->hard.dest = 0;
  108. return hdr_size;
  109. }
  110. /* otherwise, just fill it in and go! */
  111. pkt->hard.dest = daddr;
  112. return hdr_size; /* success */
  113. }
  114. static int prepare_tx(struct net_device *dev, struct archdr *pkt, int length,
  115. int bufnum)
  116. {
  117. struct arcnet_local *lp = netdev_priv(dev);
  118. struct arc_hardware *hard = &pkt->hard;
  119. int ofs;
  120. /* hard header is not included in packet length */
  121. length -= ARC_HDR_SIZE;
  122. /* And neither is the cookie field */
  123. length -= sizeof(int);
  124. arc_printk(D_DURING, dev, "prepare_tx: txbufs=%d/%d/%d\n",
  125. lp->next_tx, lp->cur_tx, bufnum);
  126. arc_printk(D_PROTO, dev, "Sending for cap packet %x.\n",
  127. *((int *)&pkt->soft.cap.cookie[0]));
  128. if (length > XMTU) {
  129. /* should never happen! other people already check for this. */
  130. arc_printk(D_NORMAL, dev, "Bug! prepare_tx with size %d (> %d)\n",
  131. length, XMTU);
  132. length = XMTU;
  133. }
  134. if (length > MinTU) {
  135. hard->offset[0] = 0;
  136. hard->offset[1] = ofs = 512 - length;
  137. } else if (length > MTU) {
  138. hard->offset[0] = 0;
  139. hard->offset[1] = ofs = 512 - length - 3;
  140. } else {
  141. hard->offset[0] = ofs = 256 - length;
  142. }
  143. arc_printk(D_DURING, dev, "prepare_tx: length=%d ofs=%d\n",
  144. length, ofs);
  145. /* Copy the arcnet-header + the protocol byte down: */
  146. lp->hw.copy_to_card(dev, bufnum, 0, hard, ARC_HDR_SIZE);
  147. lp->hw.copy_to_card(dev, bufnum, ofs, &pkt->soft.cap.proto,
  148. sizeof(pkt->soft.cap.proto));
  149. /* Skip the extra integer we have written into it as a cookie
  150. * but write the rest of the message:
  151. */
  152. lp->hw.copy_to_card(dev, bufnum, ofs + 1,
  153. ((unsigned char *)&pkt->soft.cap.mes), length - 1);
  154. lp->lastload_dest = hard->dest;
  155. return 1; /* done */
  156. }
  157. static int ack_tx(struct net_device *dev, int acked)
  158. {
  159. struct arcnet_local *lp = netdev_priv(dev);
  160. struct sk_buff *ackskb;
  161. struct archdr *ackpkt;
  162. int length = sizeof(struct arc_cap);
  163. arc_printk(D_DURING, dev, "capmode: ack_tx: protocol: %x: result: %d\n",
  164. lp->outgoing.skb->protocol, acked);
  165. if (BUGLVL(D_SKB))
  166. arcnet_dump_skb(dev, lp->outgoing.skb, "ack_tx");
  167. /* Now alloc a skb to send back up through the layers: */
  168. ackskb = alloc_skb(length + ARC_HDR_SIZE, GFP_ATOMIC);
  169. if (!ackskb)
  170. goto free_outskb;
  171. skb_put(ackskb, length + ARC_HDR_SIZE);
  172. ackskb->dev = dev;
  173. skb_reset_mac_header(ackskb);
  174. ackpkt = (struct archdr *)skb_mac_header(ackskb);
  175. /* skb_pull(ackskb, ARC_HDR_SIZE); */
  176. skb_copy_from_linear_data(lp->outgoing.skb, ackpkt,
  177. ARC_HDR_SIZE + sizeof(struct arc_cap));
  178. ackpkt->soft.cap.proto = 0; /* using protocol 0 for acknowledge */
  179. ackpkt->soft.cap.mes.ack = acked;
  180. arc_printk(D_PROTO, dev, "Acknowledge for cap packet %x.\n",
  181. *((int *)&ackpkt->soft.cap.cookie[0]));
  182. ackskb->protocol = cpu_to_be16(ETH_P_ARCNET);
  183. if (BUGLVL(D_SKB))
  184. arcnet_dump_skb(dev, ackskb, "ack_tx_recv");
  185. netif_rx(ackskb);
  186. free_outskb:
  187. dev_kfree_skb_irq(lp->outgoing.skb);
  188. lp->outgoing.proto = NULL;
  189. /* We are always finished when in this protocol */
  190. return 0;
  191. }
  192. static struct ArcProto capmode_proto = {
  193. .suffix = 'r',
  194. .mtu = XMTU,
  195. .rx = rx,
  196. .build_header = build_header,
  197. .prepare_tx = prepare_tx,
  198. .ack_tx = ack_tx
  199. };
  200. static int __init capmode_module_init(void)
  201. {
  202. int count;
  203. pr_info("cap mode (`c') encapsulation support loaded\n");
  204. for (count = 1; count <= 8; count++)
  205. if (arc_proto_map[count] == arc_proto_default)
  206. arc_proto_map[count] = &capmode_proto;
  207. /* for cap mode, we only set the bcast proto if there's no better one */
  208. if (arc_bcast_proto == arc_proto_default)
  209. arc_bcast_proto = &capmode_proto;
  210. arc_proto_default = &capmode_proto;
  211. arc_raw_proto = &capmode_proto;
  212. return 0;
  213. }
  214. static void __exit capmode_module_exit(void)
  215. {
  216. arcnet_unregister_proto(&capmode_proto);
  217. }
  218. module_init(capmode_module_init);
  219. module_exit(capmode_module_exit);
  220. MODULE_LICENSE("GPL");