drivers/misc/sgi-xp/xpnet.c

   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, channel, (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(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, channel, (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, (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, (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, &msg->data,
 207                                         (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, channel, (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, 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, channel, (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, (struct xpnet_message *)data);
 270                 break;
 271
 272         case xpConnected:       /* connection completed to a partition */
 273                 spin_lock_bh(&xpnet_broadcast_lock);
 274                 __set_bit(partid, xpnet_broadcast_partitions);
 275                 spin_unlock_bh(&xpnet_broadcast_lock);
 276
 277                 netif_carrier_on(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(&xpnet_broadcast_lock);
 285                 __clear_bit(partid, xpnet_broadcast_partitions);
 286                 spin_unlock_bh(&xpnet_broadcast_lock);
 287
 288                 if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions,
 289                                  xp_max_npartitions)) {
 290                         netif_carrier_off(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(&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(queued_msg->skb);
 358                 kfree(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, &msg->data,
 377                                           (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(&queued_msg->use_count);
 395
 396         ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, msg,
 397                               msg_size, xpnet_send_completed, queued_msg);
 398         if (unlikely(ret != xpSuccess))
 399                 atomic_dec(&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(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(&queued_msg->use_count, 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(&queued_msg->use_count) == 0) {
 489                 dev_kfree_skb(skb);
 490                 kfree(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 = kcalloc(BITS_TO_LONGS(xp_max_npartitions),
 526                                              sizeof(long),
 527                                              GFP_KERNEL);
 528         if (xpnet_broadcast_partitions == NULL)
 529                 return -ENOMEM;
 530
 531         /*
 532          * use ether_setup() to init the majority of our device
 533          * structure and then override the necessary pieces.
 534          */
 535         xpnet_device = alloc_netdev(0, XPNET_DEVICE_NAME, NET_NAME_UNKNOWN,
 536                                     ether_setup);
 537         if (xpnet_device == NULL) {
 538                 kfree(xpnet_broadcast_partitions);
 539                 return -ENOMEM;
 540         }
 541
 542         netif_carrier_off(xpnet_device);
 543
 544         xpnet_device->netdev_ops = &xpnet_netdev_ops;
 545         xpnet_device->mtu = XPNET_DEF_MTU;
 546         xpnet_device->min_mtu = XPNET_MIN_MTU;
 547         xpnet_device->max_mtu = XPNET_MAX_MTU;
 548
 549         memset(addr, 0, sizeof(addr));
 550         /*
 551          * Multicast assumes the LSB of the first octet is set for multicast
 552          * MAC addresses.  We chose the first octet of the MAC to be unlikely
 553          * to collide with any vendor's officially issued MAC.
 554          */
 555         addr[0] = 0x02;     /* locally administered, no OUI */
 556
 557         addr[XPNET_PARTID_OCTET + 1] = xp_partition_id;
 558         addr[XPNET_PARTID_OCTET + 0] = (xp_partition_id >> 8);
 559         eth_hw_addr_set(xpnet_device, addr);
 560
 561         /*
 562          * ether_setup() sets this to a multicast device.  We are
 563          * really not supporting multicast at this time.
 564          */
 565         xpnet_device->flags &= ~IFF_MULTICAST;
 566
 567         /*
 568          * No need to checksum as it is a DMA transfer.  The BTE will
 569          * report an error if the data is not retrievable and the
 570          * packet will be dropped.
 571          */
 572         xpnet_device->features = NETIF_F_HW_CSUM;
 573
 574         result = register_netdev(xpnet_device);
 575         if (result != 0) {
 576                 free_netdev(xpnet_device);
 577                 kfree(xpnet_broadcast_partitions);
 578         }
 579
 580         return result;
 581 }
 582
 583 module_init(xpnet_init);
 584
 585 static void __exit
 586 xpnet_exit(void)
 587 {
 588         dev_info(xpnet, "unregistering network device %s\n",
 589                  xpnet_device[0].name);
 590
 591         unregister_netdev(xpnet_device);
 592         free_netdev(xpnet_device);
 593         kfree(xpnet_broadcast_partitions);
 594 }
 595
 596 module_exit(xpnet_exit);
 597
 598 MODULE_AUTHOR("Silicon Graphics, Inc.");
 599 MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)");
 600 MODULE_LICENSE("GPL");