]>
Commit | Line | Data |
---|---|---|
a2d974da DN |
1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public | |
3 | * License. See the file "COPYING" in the main directory of this archive | |
4 | * for more details. | |
5 | * | |
45d9ca49 | 6 | * Copyright (C) 1999-2008 Silicon Graphics, Inc. All rights reserved. |
a2d974da DN |
7 | */ |
8 | ||
a2d974da DN |
9 | /* |
10 | * Cross Partition Network Interface (XPNET) support | |
11 | * | |
12 | * XPNET provides a virtual network layered on top of the Cross | |
13 | * Partition communication layer. | |
14 | * | |
15 | * XPNET provides direct point-to-point and broadcast-like support | |
16 | * for an ethernet-like device. The ethernet broadcast medium is | |
17 | * replaced with a point-to-point message structure which passes | |
18 | * pointers to a DMA-capable block that a remote partition should | |
19 | * retrieve and pass to the upper level networking layer. | |
20 | * | |
21 | */ | |
22 | ||
a2d974da | 23 | #include <linux/module.h> |
a2d974da DN |
24 | #include <linux/netdevice.h> |
25 | #include <linux/etherdevice.h> | |
45d9ca49 | 26 | #include "xp.h" |
a2d974da | 27 | |
a2d974da DN |
28 | /* |
29 | * The message payload transferred by XPC. | |
30 | * | |
31 | * buf_pa is the physical address where the DMA should pull from. | |
32 | * | |
33 | * NOTE: for performance reasons, buf_pa should _ALWAYS_ begin on a | |
34 | * cacheline boundary. To accomplish this, we record the number of | |
35 | * bytes from the beginning of the first cacheline to the first useful | |
36 | * byte of the skb (leadin_ignore) and the number of bytes from the | |
37 | * last useful byte of the skb to the end of the last cacheline | |
38 | * (tailout_ignore). | |
39 | * | |
40 | * size is the number of bytes to transfer which includes the skb->len | |
41 | * (useful bytes of the senders skb) plus the leadin and tailout | |
42 | */ | |
43 | struct xpnet_message { | |
44 | u16 version; /* Version for this message */ | |
45 | u16 embedded_bytes; /* #of bytes embedded in XPC message */ | |
46 | u32 magic; /* Special number indicating this is xpnet */ | |
a812dcc3 | 47 | unsigned long buf_pa; /* phys address of buffer to retrieve */ |
a2d974da DN |
48 | u32 size; /* #of bytes in buffer */ |
49 | u8 leadin_ignore; /* #of bytes to ignore at the beginning */ | |
50 | u8 tailout_ignore; /* #of bytes to ignore at the end */ | |
51 | unsigned char data; /* body of small packets */ | |
52 | }; | |
53 | ||
54 | /* | |
55 | * Determine the size of our message, the cacheline aligned size, | |
56 | * and then the number of message will request from XPC. | |
57 | * | |
58 | * XPC expects each message to exist in an individual cacheline. | |
59 | */ | |
bd3e64c1 | 60 | #define XPNET_MSG_SIZE XPC_MSG_PAYLOAD_MAX_SIZE |
a2d974da | 61 | #define XPNET_MSG_DATA_MAX \ |
bd3e64c1 DN |
62 | (XPNET_MSG_SIZE - offsetof(struct xpnet_message, data)) |
63 | #define XPNET_MSG_NENTRIES (PAGE_SIZE / XPC_MSG_MAX_SIZE) | |
a2d974da | 64 | |
a2d974da DN |
65 | #define XPNET_MAX_KTHREADS (XPNET_MSG_NENTRIES + 1) |
66 | #define XPNET_MAX_IDLE_KTHREADS (XPNET_MSG_NENTRIES + 1) | |
67 | ||
68 | /* | |
69 | * Version number of XPNET implementation. XPNET can always talk to versions | |
70 | * with same major #, and never talk to versions with a different version. | |
71 | */ | |
72 | #define _XPNET_VERSION(_major, _minor) (((_major) << 4) | (_minor)) | |
73 | #define XPNET_VERSION_MAJOR(_v) ((_v) >> 4) | |
74 | #define XPNET_VERSION_MINOR(_v) ((_v) & 0xf) | |
75 | ||
2c2b94f9 DN |
76 | #define XPNET_VERSION _XPNET_VERSION(1, 0) /* version 1.0 */ |
77 | #define XPNET_VERSION_EMBED _XPNET_VERSION(1, 1) /* version 1.1 */ | |
35190506 | 78 | #define XPNET_MAGIC 0x88786984 /* "XNET" */ |
a2d974da DN |
79 | |
80 | #define XPNET_VALID_MSG(_m) \ | |
81 | ((XPNET_VERSION_MAJOR(_m->version) == XPNET_VERSION_MAJOR(XPNET_VERSION)) \ | |
82 | && (msg->magic == XPNET_MAGIC)) | |
83 | ||
84 | #define XPNET_DEVICE_NAME "xp0" | |
85 | ||
a2d974da DN |
86 | /* |
87 | * When messages are queued with xpc_send_notify, a kmalloc'd buffer | |
88 | * of the following type is passed as a notification cookie. When the | |
89 | * notification function is called, we use the cookie to decide | |
90 | * whether all outstanding message sends have completed. The skb can | |
91 | * then be released. | |
92 | */ | |
93 | struct xpnet_pending_msg { | |
a2d974da DN |
94 | struct sk_buff *skb; |
95 | atomic_t use_count; | |
96 | }; | |
97 | ||
98 | /* driver specific structure pointed to by the device structure */ | |
99 | struct xpnet_dev_private { | |
100 | struct net_device_stats stats; | |
101 | }; | |
102 | ||
103 | struct net_device *xpnet_device; | |
104 | ||
105 | /* | |
106 | * When we are notified of other partitions activating, we add them to | |
107 | * our bitmask of partitions to which we broadcast. | |
108 | */ | |
a7b4d509 | 109 | static unsigned long *xpnet_broadcast_partitions; |
a2d974da | 110 | /* protect above */ |
a9f6a0dd | 111 | static DEFINE_SPINLOCK(xpnet_broadcast_lock); |
a2d974da DN |
112 | |
113 | /* | |
114 | * Since the Block Transfer Engine (BTE) is being used for the transfer | |
115 | * and it relies upon cache-line size transfers, we need to reserve at | |
116 | * least one cache-line for head and tail alignment. The BTE is | |
117 | * limited to 8MB transfers. | |
118 | * | |
119 | * Testing has shown that changing MTU to greater than 64KB has no effect | |
120 | * on TCP as the two sides negotiate a Max Segment Size that is limited | |
121 | * to 64K. Other protocols May use packets greater than this, but for | |
122 | * now, the default is 64KB. | |
123 | */ | |
124 | #define XPNET_MAX_MTU (0x800000UL - L1_CACHE_BYTES) | |
125 | /* 32KB has been determined to be the ideal */ | |
126 | #define XPNET_DEF_MTU (0x8000UL) | |
127 | ||
a2d974da | 128 | /* |
a7b4d509 DN |
129 | * The partid is encapsulated in the MAC address beginning in the following |
130 | * octet and it consists of two octets. | |
a2d974da | 131 | */ |
a7b4d509 DN |
132 | #define XPNET_PARTID_OCTET 2 |
133 | ||
134 | /* Define the XPNET debug device structures to be used with dev_dbg() et al */ | |
a2d974da | 135 | |
a2d974da DN |
136 | struct device_driver xpnet_dbg_name = { |
137 | .name = "xpnet" | |
138 | }; | |
139 | ||
140 | struct device xpnet_dbg_subname = { | |
35190506 | 141 | .bus_id = {0}, /* set to "" */ |
a2d974da DN |
142 | .driver = &xpnet_dbg_name |
143 | }; | |
144 | ||
145 | struct device *xpnet = &xpnet_dbg_subname; | |
146 | ||
147 | /* | |
148 | * Packet was recevied by XPC and forwarded to us. | |
149 | */ | |
150 | static void | |
64d032ba | 151 | xpnet_receive(short partid, int channel, struct xpnet_message *msg) |
a2d974da DN |
152 | { |
153 | struct sk_buff *skb; | |
a812dcc3 | 154 | void *dst; |
908787db | 155 | enum xp_retval ret; |
3f9b766c | 156 | struct xpnet_dev_private *priv = netdev_priv(xpnet_device); |
a2d974da DN |
157 | |
158 | if (!XPNET_VALID_MSG(msg)) { | |
159 | /* | |
160 | * Packet with a different XPC version. Ignore. | |
161 | */ | |
35190506 | 162 | xpc_received(partid, channel, (void *)msg); |
a2d974da DN |
163 | |
164 | priv->stats.rx_errors++; | |
165 | ||
166 | return; | |
167 | } | |
a812dcc3 DN |
168 | dev_dbg(xpnet, "received 0x%lx, %d, %d, %d\n", msg->buf_pa, msg->size, |
169 | msg->leadin_ignore, msg->tailout_ignore); | |
a2d974da | 170 | |
a2d974da DN |
171 | /* reserve an extra cache line */ |
172 | skb = dev_alloc_skb(msg->size + L1_CACHE_BYTES); | |
173 | if (!skb) { | |
174 | dev_err(xpnet, "failed on dev_alloc_skb(%d)\n", | |
175 | msg->size + L1_CACHE_BYTES); | |
176 | ||
35190506 | 177 | xpc_received(partid, channel, (void *)msg); |
a2d974da DN |
178 | |
179 | priv->stats.rx_errors++; | |
180 | ||
181 | return; | |
182 | } | |
183 | ||
184 | /* | |
185 | * The allocated skb has some reserved space. | |
908787db | 186 | * In order to use xp_remote_memcpy(), we need to get the |
a2d974da DN |
187 | * skb->data pointer moved forward. |
188 | */ | |
189 | skb_reserve(skb, (L1_CACHE_BYTES - ((u64)skb->data & | |
190 | (L1_CACHE_BYTES - 1)) + | |
191 | msg->leadin_ignore)); | |
192 | ||
193 | /* | |
194 | * Update the tail pointer to indicate data actually | |
195 | * transferred. | |
196 | */ | |
197 | skb_put(skb, (msg->size - msg->leadin_ignore - msg->tailout_ignore)); | |
198 | ||
199 | /* | |
4b3f686d | 200 | * Move the data over from the other side. |
a2d974da DN |
201 | */ |
202 | if ((XPNET_VERSION_MINOR(msg->version) == 1) && | |
35190506 | 203 | (msg->embedded_bytes != 0)) { |
a2d974da DN |
204 | dev_dbg(xpnet, "copying embedded message. memcpy(0x%p, 0x%p, " |
205 | "%lu)\n", skb->data, &msg->data, | |
35190506 | 206 | (size_t)msg->embedded_bytes); |
a2d974da | 207 | |
35190506 DN |
208 | skb_copy_to_linear_data(skb, &msg->data, |
209 | (size_t)msg->embedded_bytes); | |
a2d974da | 210 | } else { |
a812dcc3 | 211 | dst = (void *)((u64)skb->data & ~(L1_CACHE_BYTES - 1)); |
a2d974da | 212 | dev_dbg(xpnet, "transferring buffer to the skb->data area;\n\t" |
a812dcc3 | 213 | "xp_remote_memcpy(0x%p, 0x%p, %hu)\n", dst, |
908787db | 214 | (void *)msg->buf_pa, msg->size); |
a2d974da | 215 | |
a812dcc3 | 216 | ret = xp_remote_memcpy(xp_pa(dst), msg->buf_pa, msg->size); |
908787db | 217 | if (ret != xpSuccess) { |
2c2b94f9 | 218 | /* |
ea57f80c DN |
219 | * !!! Need better way of cleaning skb. Currently skb |
220 | * !!! appears in_use and we can't just call | |
221 | * !!! dev_kfree_skb. | |
2c2b94f9 | 222 | */ |
908787db | 223 | dev_err(xpnet, "xp_remote_memcpy(0x%p, 0x%p, 0x%hx) " |
a812dcc3 | 224 | "returned error=0x%x\n", dst, |
908787db | 225 | (void *)msg->buf_pa, msg->size, ret); |
a2d974da | 226 | |
35190506 | 227 | xpc_received(partid, channel, (void *)msg); |
a2d974da DN |
228 | |
229 | priv->stats.rx_errors++; | |
230 | ||
231 | return; | |
232 | } | |
233 | } | |
234 | ||
235 | dev_dbg(xpnet, "<skb->head=0x%p skb->data=0x%p skb->tail=0x%p " | |
35190506 | 236 | "skb->end=0x%p skb->len=%d\n", (void *)skb->head, |
4305b541 | 237 | (void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb), |
a2d974da DN |
238 | skb->len); |
239 | ||
a2d974da DN |
240 | skb->protocol = eth_type_trans(skb, xpnet_device); |
241 | skb->ip_summed = CHECKSUM_UNNECESSARY; | |
242 | ||
898eb71c JP |
243 | dev_dbg(xpnet, "passing skb to network layer\n" |
244 | KERN_DEBUG "\tskb->head=0x%p skb->data=0x%p skb->tail=0x%p " | |
245 | "skb->end=0x%p skb->len=%d\n", | |
27a884dc | 246 | (void *)skb->head, (void *)skb->data, skb_tail_pointer(skb), |
4305b541 | 247 | skb_end_pointer(skb), skb->len); |
a2d974da | 248 | |
a2d974da DN |
249 | xpnet_device->last_rx = jiffies; |
250 | priv->stats.rx_packets++; | |
251 | priv->stats.rx_bytes += skb->len + ETH_HLEN; | |
252 | ||
253 | netif_rx_ni(skb); | |
35190506 | 254 | xpc_received(partid, channel, (void *)msg); |
a2d974da DN |
255 | } |
256 | ||
a2d974da DN |
257 | /* |
258 | * This is the handler which XPC calls during any sort of change in | |
259 | * state or message reception on a connection. | |
260 | */ | |
261 | static void | |
64d032ba | 262 | xpnet_connection_activity(enum xp_retval reason, short partid, int channel, |
a2d974da DN |
263 | void *data, void *key) |
264 | { | |
bc63d387 | 265 | DBUG_ON(partid < 0 || partid >= xp_max_npartitions); |
a2d974da DN |
266 | DBUG_ON(channel != XPC_NET_CHANNEL); |
267 | ||
35190506 | 268 | switch (reason) { |
65c17b80 | 269 | case xpMsgReceived: /* message received */ |
a2d974da DN |
270 | DBUG_ON(data == NULL); |
271 | ||
35190506 | 272 | xpnet_receive(partid, channel, (struct xpnet_message *)data); |
a2d974da DN |
273 | break; |
274 | ||
65c17b80 | 275 | case xpConnected: /* connection completed to a partition */ |
a2d974da | 276 | spin_lock_bh(&xpnet_broadcast_lock); |
a7b4d509 | 277 | __set_bit(partid, xpnet_broadcast_partitions); |
a2d974da DN |
278 | spin_unlock_bh(&xpnet_broadcast_lock); |
279 | ||
280 | netif_carrier_on(xpnet_device); | |
281 | ||
a7b4d509 DN |
282 | dev_dbg(xpnet, "%s connected to partition %d\n", |
283 | xpnet_device->name, partid); | |
a2d974da DN |
284 | break; |
285 | ||
286 | default: | |
287 | spin_lock_bh(&xpnet_broadcast_lock); | |
a7b4d509 | 288 | __clear_bit(partid, xpnet_broadcast_partitions); |
a2d974da DN |
289 | spin_unlock_bh(&xpnet_broadcast_lock); |
290 | ||
a7b4d509 DN |
291 | if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions, |
292 | xp_max_npartitions)) { | |
a2d974da | 293 | netif_carrier_off(xpnet_device); |
a7b4d509 | 294 | } |
a2d974da | 295 | |
a7b4d509 DN |
296 | dev_dbg(xpnet, "%s disconnected from partition %d\n", |
297 | xpnet_device->name, partid); | |
a2d974da | 298 | break; |
a2d974da DN |
299 | } |
300 | } | |
301 | ||
a2d974da DN |
302 | static int |
303 | xpnet_dev_open(struct net_device *dev) | |
304 | { | |
65c17b80 | 305 | enum xp_retval ret; |
a2d974da | 306 | |
b9ae3bd2 TL |
307 | dev_dbg(xpnet, "calling xpc_connect(%d, 0x%p, NULL, %ld, %ld, %ld, " |
308 | "%ld)\n", XPC_NET_CHANNEL, xpnet_connection_activity, | |
261f3b49 DN |
309 | (unsigned long)XPNET_MSG_SIZE, |
310 | (unsigned long)XPNET_MSG_NENTRIES, | |
311 | (unsigned long)XPNET_MAX_KTHREADS, | |
312 | (unsigned long)XPNET_MAX_IDLE_KTHREADS); | |
a2d974da DN |
313 | |
314 | ret = xpc_connect(XPC_NET_CHANNEL, xpnet_connection_activity, NULL, | |
315 | XPNET_MSG_SIZE, XPNET_MSG_NENTRIES, | |
316 | XPNET_MAX_KTHREADS, XPNET_MAX_IDLE_KTHREADS); | |
65c17b80 | 317 | if (ret != xpSuccess) { |
a2d974da DN |
318 | dev_err(xpnet, "ifconfig up of %s failed on XPC connect, " |
319 | "ret=%d\n", dev->name, ret); | |
320 | ||
321 | return -ENOMEM; | |
322 | } | |
323 | ||
324 | dev_dbg(xpnet, "ifconfig up of %s; XPC connected\n", dev->name); | |
325 | ||
326 | return 0; | |
327 | } | |
328 | ||
a2d974da DN |
329 | static int |
330 | xpnet_dev_stop(struct net_device *dev) | |
331 | { | |
332 | xpc_disconnect(XPC_NET_CHANNEL); | |
333 | ||
334 | dev_dbg(xpnet, "ifconfig down of %s; XPC disconnected\n", dev->name); | |
335 | ||
336 | return 0; | |
337 | } | |
338 | ||
a2d974da DN |
339 | static int |
340 | xpnet_dev_change_mtu(struct net_device *dev, int new_mtu) | |
341 | { | |
342 | /* 68 comes from min TCP+IP+MAC header */ | |
343 | if ((new_mtu < 68) || (new_mtu > XPNET_MAX_MTU)) { | |
344 | dev_err(xpnet, "ifconfig %s mtu %d failed; value must be " | |
345 | "between 68 and %ld\n", dev->name, new_mtu, | |
346 | XPNET_MAX_MTU); | |
347 | return -EINVAL; | |
348 | } | |
349 | ||
350 | dev->mtu = new_mtu; | |
351 | dev_dbg(xpnet, "ifconfig %s mtu set to %d\n", dev->name, new_mtu); | |
352 | return 0; | |
353 | } | |
354 | ||
a2d974da DN |
355 | /* |
356 | * Required for the net_device structure. | |
357 | */ | |
358 | static int | |
359 | xpnet_dev_set_config(struct net_device *dev, struct ifmap *new_map) | |
360 | { | |
361 | return 0; | |
362 | } | |
363 | ||
a2d974da DN |
364 | /* |
365 | * Return statistics to the caller. | |
366 | */ | |
367 | static struct net_device_stats * | |
368 | xpnet_dev_get_stats(struct net_device *dev) | |
369 | { | |
3f9b766c | 370 | struct xpnet_dev_private *priv = netdev_priv(dev); |
a2d974da DN |
371 | |
372 | return &priv->stats; | |
373 | } | |
374 | ||
a2d974da DN |
375 | /* |
376 | * Notification that the other end has received the message and | |
377 | * DMA'd the skb information. At this point, they are done with | |
378 | * our side. When all recipients are done processing, we | |
379 | * release the skb and then release our pending message structure. | |
380 | */ | |
381 | static void | |
64d032ba | 382 | xpnet_send_completed(enum xp_retval reason, short partid, int channel, |
35190506 | 383 | void *__qm) |
a2d974da | 384 | { |
35190506 | 385 | struct xpnet_pending_msg *queued_msg = (struct xpnet_pending_msg *)__qm; |
a2d974da DN |
386 | |
387 | DBUG_ON(queued_msg == NULL); | |
388 | ||
389 | dev_dbg(xpnet, "message to %d notified with reason %d\n", | |
390 | partid, reason); | |
391 | ||
392 | if (atomic_dec_return(&queued_msg->use_count) == 0) { | |
393 | dev_dbg(xpnet, "all acks for skb->head=-x%p\n", | |
35190506 | 394 | (void *)queued_msg->skb->head); |
a2d974da DN |
395 | |
396 | dev_kfree_skb_any(queued_msg->skb); | |
397 | kfree(queued_msg); | |
398 | } | |
399 | } | |
400 | ||
a7b4d509 DN |
401 | static void |
402 | xpnet_send(struct sk_buff *skb, struct xpnet_pending_msg *queued_msg, | |
403 | u64 start_addr, u64 end_addr, u16 embedded_bytes, int dest_partid) | |
404 | { | |
405 | u8 msg_buffer[XPNET_MSG_SIZE]; | |
406 | struct xpnet_message *msg = (struct xpnet_message *)&msg_buffer; | |
bd3e64c1 | 407 | u16 msg_size = sizeof(struct xpnet_message); |
a7b4d509 DN |
408 | enum xp_retval ret; |
409 | ||
410 | msg->embedded_bytes = embedded_bytes; | |
411 | if (unlikely(embedded_bytes != 0)) { | |
412 | msg->version = XPNET_VERSION_EMBED; | |
413 | dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n", | |
414 | &msg->data, skb->data, (size_t)embedded_bytes); | |
415 | skb_copy_from_linear_data(skb, &msg->data, | |
416 | (size_t)embedded_bytes); | |
bd3e64c1 | 417 | msg_size += embedded_bytes - 1; |
a7b4d509 DN |
418 | } else { |
419 | msg->version = XPNET_VERSION; | |
420 | } | |
421 | msg->magic = XPNET_MAGIC; | |
422 | msg->size = end_addr - start_addr; | |
423 | msg->leadin_ignore = (u64)skb->data - start_addr; | |
424 | msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb); | |
a812dcc3 | 425 | msg->buf_pa = xp_pa((void *)start_addr); |
a7b4d509 DN |
426 | |
427 | dev_dbg(xpnet, "sending XPC message to %d:%d\n" | |
428 | KERN_DEBUG "msg->buf_pa=0x%lx, msg->size=%u, " | |
429 | "msg->leadin_ignore=%u, msg->tailout_ignore=%u\n", | |
a812dcc3 DN |
430 | dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size, |
431 | msg->leadin_ignore, msg->tailout_ignore); | |
a7b4d509 DN |
432 | |
433 | atomic_inc(&queued_msg->use_count); | |
434 | ||
435 | ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, msg, | |
bd3e64c1 | 436 | msg_size, xpnet_send_completed, queued_msg); |
a7b4d509 DN |
437 | if (unlikely(ret != xpSuccess)) |
438 | atomic_dec(&queued_msg->use_count); | |
439 | } | |
440 | ||
a2d974da DN |
441 | /* |
442 | * Network layer has formatted a packet (skb) and is ready to place it | |
443 | * "on the wire". Prepare and send an xpnet_message to all partitions | |
444 | * which have connected with us and are targets of this packet. | |
445 | * | |
446 | * MAC-NOTE: For the XPNET driver, the MAC address contains the | |
a7b4d509 DN |
447 | * destination partid. If the destination partid octets are 0xffff, |
448 | * this packet is to be broadcast to all connected partitions. | |
a2d974da DN |
449 | */ |
450 | static int | |
451 | xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) | |
452 | { | |
453 | struct xpnet_pending_msg *queued_msg; | |
a2d974da | 454 | u64 start_addr, end_addr; |
64d032ba | 455 | short dest_partid; |
3f9b766c | 456 | struct xpnet_dev_private *priv = netdev_priv(dev); |
a7b4d509 | 457 | u16 embedded_bytes = 0; |
a2d974da DN |
458 | |
459 | dev_dbg(xpnet, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p " | |
35190506 | 460 | "skb->end=0x%p skb->len=%d\n", (void *)skb->head, |
4305b541 | 461 | (void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb), |
a2d974da DN |
462 | skb->len); |
463 | ||
a7b4d509 DN |
464 | if (skb->data[0] == 0x33) { |
465 | dev_kfree_skb(skb); | |
466 | return 0; /* nothing needed to be done */ | |
467 | } | |
468 | ||
a2d974da DN |
469 | /* |
470 | * The xpnet_pending_msg tracks how many outstanding | |
471 | * xpc_send_notifies are relying on this skb. When none | |
472 | * remain, release the skb. | |
473 | */ | |
474 | queued_msg = kmalloc(sizeof(struct xpnet_pending_msg), GFP_ATOMIC); | |
475 | if (queued_msg == NULL) { | |
476 | dev_warn(xpnet, "failed to kmalloc %ld bytes; dropping " | |
35190506 | 477 | "packet\n", sizeof(struct xpnet_pending_msg)); |
a2d974da DN |
478 | |
479 | priv->stats.tx_errors++; | |
a2d974da DN |
480 | return -ENOMEM; |
481 | } | |
482 | ||
a2d974da | 483 | /* get the beginning of the first cacheline and end of last */ |
35190506 | 484 | start_addr = ((u64)skb->data & ~(L1_CACHE_BYTES - 1)); |
27a884dc | 485 | end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb)); |
a2d974da DN |
486 | |
487 | /* calculate how many bytes to embed in the XPC message */ | |
a2d974da DN |
488 | if (unlikely(skb->len <= XPNET_MSG_DATA_MAX)) { |
489 | /* skb->data does fit so embed */ | |
490 | embedded_bytes = skb->len; | |
491 | } | |
492 | ||
a2d974da DN |
493 | /* |
494 | * Since the send occurs asynchronously, we set the count to one | |
495 | * and begin sending. Any sends that happen to complete before | |
496 | * we are done sending will not free the skb. We will be left | |
497 | * with that task during exit. This also handles the case of | |
498 | * a packet destined for a partition which is no longer up. | |
499 | */ | |
500 | atomic_set(&queued_msg->use_count, 1); | |
501 | queued_msg->skb = skb; | |
502 | ||
a7b4d509 | 503 | if (skb->data[0] == 0xff) { |
a2d974da | 504 | /* we are being asked to broadcast to all partitions */ |
a7b4d509 DN |
505 | for_each_bit(dest_partid, xpnet_broadcast_partitions, |
506 | xp_max_npartitions) { | |
a2d974da | 507 | |
a7b4d509 DN |
508 | xpnet_send(skb, queued_msg, start_addr, end_addr, |
509 | embedded_bytes, dest_partid); | |
a2d974da | 510 | } |
a7b4d509 DN |
511 | } else { |
512 | dest_partid = (short)skb->data[XPNET_PARTID_OCTET + 1]; | |
513 | dest_partid |= (short)skb->data[XPNET_PARTID_OCTET + 0] << 8; | |
a2d974da | 514 | |
a7b4d509 DN |
515 | if (dest_partid >= 0 && |
516 | dest_partid < xp_max_npartitions && | |
517 | test_bit(dest_partid, xpnet_broadcast_partitions) != 0) { | |
a2d974da | 518 | |
a7b4d509 DN |
519 | xpnet_send(skb, queued_msg, start_addr, end_addr, |
520 | embedded_bytes, dest_partid); | |
a2d974da | 521 | } |
a2d974da DN |
522 | } |
523 | ||
524 | if (atomic_dec_return(&queued_msg->use_count) == 0) { | |
a2d974da DN |
525 | dev_kfree_skb(skb); |
526 | kfree(queued_msg); | |
527 | } | |
528 | ||
529 | priv->stats.tx_packets++; | |
530 | priv->stats.tx_bytes += skb->len; | |
531 | ||
532 | return 0; | |
533 | } | |
534 | ||
a2d974da DN |
535 | /* |
536 | * Deal with transmit timeouts coming from the network layer. | |
537 | */ | |
538 | static void | |
35190506 | 539 | xpnet_dev_tx_timeout(struct net_device *dev) |
a2d974da | 540 | { |
3f9b766c | 541 | struct xpnet_dev_private *priv = netdev_priv(dev); |
a2d974da DN |
542 | |
543 | priv->stats.tx_errors++; | |
544 | return; | |
545 | } | |
546 | ||
a2d974da DN |
547 | static int __init |
548 | xpnet_init(void) | |
549 | { | |
a7b4d509 | 550 | int result; |
a2d974da | 551 | |
a7b4d509 | 552 | if (!is_shub() && !is_uv()) |
408865ce | 553 | return -ENODEV; |
408865ce | 554 | |
a2d974da DN |
555 | dev_info(xpnet, "registering network device %s\n", XPNET_DEVICE_NAME); |
556 | ||
a7b4d509 DN |
557 | xpnet_broadcast_partitions = kzalloc(BITS_TO_LONGS(xp_max_npartitions) * |
558 | sizeof(long), GFP_KERNEL); | |
559 | if (xpnet_broadcast_partitions == NULL) | |
560 | return -ENOMEM; | |
561 | ||
a2d974da DN |
562 | /* |
563 | * use ether_setup() to init the majority of our device | |
564 | * structure and then override the necessary pieces. | |
565 | */ | |
566 | xpnet_device = alloc_netdev(sizeof(struct xpnet_dev_private), | |
567 | XPNET_DEVICE_NAME, ether_setup); | |
a7b4d509 DN |
568 | if (xpnet_device == NULL) { |
569 | kfree(xpnet_broadcast_partitions); | |
a2d974da | 570 | return -ENOMEM; |
a7b4d509 | 571 | } |
a2d974da DN |
572 | |
573 | netif_carrier_off(xpnet_device); | |
574 | ||
575 | xpnet_device->mtu = XPNET_DEF_MTU; | |
576 | xpnet_device->change_mtu = xpnet_dev_change_mtu; | |
577 | xpnet_device->open = xpnet_dev_open; | |
578 | xpnet_device->get_stats = xpnet_dev_get_stats; | |
579 | xpnet_device->stop = xpnet_dev_stop; | |
580 | xpnet_device->hard_start_xmit = xpnet_dev_hard_start_xmit; | |
581 | xpnet_device->tx_timeout = xpnet_dev_tx_timeout; | |
582 | xpnet_device->set_config = xpnet_dev_set_config; | |
583 | ||
584 | /* | |
585 | * Multicast assumes the LSB of the first octet is set for multicast | |
586 | * MAC addresses. We chose the first octet of the MAC to be unlikely | |
587 | * to collide with any vendor's officially issued MAC. | |
588 | */ | |
a7b4d509 DN |
589 | xpnet_device->dev_addr[0] = 0x02; /* locally administered, no OUI */ |
590 | ||
261f3b49 DN |
591 | xpnet_device->dev_addr[XPNET_PARTID_OCTET + 1] = xp_partition_id; |
592 | xpnet_device->dev_addr[XPNET_PARTID_OCTET + 0] = (xp_partition_id >> 8); | |
a2d974da DN |
593 | |
594 | /* | |
595 | * ether_setup() sets this to a multicast device. We are | |
596 | * really not supporting multicast at this time. | |
597 | */ | |
598 | xpnet_device->flags &= ~IFF_MULTICAST; | |
599 | ||
600 | /* | |
601 | * No need to checksum as it is a DMA transfer. The BTE will | |
602 | * report an error if the data is not retrievable and the | |
603 | * packet will be dropped. | |
604 | */ | |
605 | xpnet_device->features = NETIF_F_NO_CSUM; | |
606 | ||
607 | result = register_netdev(xpnet_device); | |
a7b4d509 | 608 | if (result != 0) { |
a2d974da | 609 | free_netdev(xpnet_device); |
a7b4d509 DN |
610 | kfree(xpnet_broadcast_partitions); |
611 | } | |
a2d974da DN |
612 | |
613 | return result; | |
614 | } | |
a2d974da | 615 | |
35190506 | 616 | module_init(xpnet_init); |
a2d974da DN |
617 | |
618 | static void __exit | |
619 | xpnet_exit(void) | |
620 | { | |
621 | dev_info(xpnet, "unregistering network device %s\n", | |
35190506 | 622 | xpnet_device[0].name); |
a2d974da DN |
623 | |
624 | unregister_netdev(xpnet_device); | |
a2d974da | 625 | free_netdev(xpnet_device); |
a7b4d509 | 626 | kfree(xpnet_broadcast_partitions); |
a2d974da | 627 | } |
a2d974da | 628 | |
35190506 | 629 | module_exit(xpnet_exit); |
a2d974da DN |
630 | |
631 | MODULE_AUTHOR("Silicon Graphics, Inc."); | |
632 | MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)"); | |
633 | MODULE_LICENSE("GPL"); |