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