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