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