src/drivers/net/ipoib.c

   1 /*
   2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stdint.h>
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <byteswap.h>
  26 #include <errno.h>
  27 #include <gpxe/errortab.h>
  28 #include <gpxe/if_arp.h>
  29 #include <gpxe/iobuf.h>
  30 #include <gpxe/netdevice.h>
  31 #include <gpxe/infiniband.h>
  32 #include <gpxe/ib_pathrec.h>
  33 #include <gpxe/ib_mcast.h>
  34 #include <gpxe/ipoib.h>
  35
  36 /** @file
  37  *
  38  * IP over Infiniband
  39  */
  40
  41 /** Number of IPoIB send work queue entries */
  42 #define IPOIB_NUM_SEND_WQES 2
  43
  44 /** Number of IPoIB receive work queue entries */
  45 #define IPOIB_NUM_RECV_WQES 4
  46
  47 /** Number of IPoIB completion entries */
  48 #define IPOIB_NUM_CQES 8
  49
  50 /** An IPoIB device */
  51 struct ipoib_device {
  52         /** Network device */
  53         struct net_device *netdev;
  54         /** Underlying Infiniband device */
  55         struct ib_device *ibdev;
  56         /** Completion queue */
  57         struct ib_completion_queue *cq;
  58         /** Queue pair */
  59         struct ib_queue_pair *qp;
  60         /** Broadcast MAC */
  61         struct ipoib_mac broadcast;
  62         /** Joined to IPv4 broadcast multicast group
  63          *
  64          * This flag indicates whether or not we have initiated the
  65          * join to the IPv4 broadcast multicast group.
  66          */
  67         int broadcast_joined;
  68         /** IPv4 broadcast multicast group membership */
  69         struct ib_mc_membership broadcast_membership;
  70 };
  71
  72 /** Broadcast IPoIB address */
  73 static struct ipoib_mac ipoib_broadcast = {
  74         .flags__qpn = htonl ( IB_QPN_BROADCAST ),
  75         .gid.u.bytes =  { 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
  76                           0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff },
  77 };
  78
  79 /** Link status for "broadcast join in progress" */
  80 #define EINPROGRESS_JOINING ( EINPROGRESS | EUNIQ_01 )
  81
  82 /** Human-readable message for the link status */
  83 struct errortab ipoib_errors[] __errortab = {
  84         { EINPROGRESS_JOINING, "Joining" },
  85 };
  86
  87 /****************************************************************************
  88  *
  89  * IPoIB peer cache
  90  *
  91  ****************************************************************************
  92  */
  93
  94 /**
  95  * IPoIB peer address
  96  *
  97  * The IPoIB link-layer header is only four bytes long and so does not
  98  * have sufficient room to store IPoIB MAC address(es).  We therefore
  99  * maintain a cache of MAC addresses identified by a single-byte key,
 100  * and abuse the spare two bytes within the link-layer header to
 101  * communicate these MAC addresses between the link-layer code and the
 102  * netdevice driver.
 103  */
 104 struct ipoib_peer {
 105         /** Key */
 106         uint8_t key;
 107         /** MAC address */
 108         struct ipoib_mac mac;
 109 };
 110
 111 /** Number of IPoIB peer cache entries
 112  *
 113  * Must be a power of two.
 114  */
 115 #define IPOIB_NUM_CACHED_PEERS 4
 116
 117 /** IPoIB peer address cache */
 118 static struct ipoib_peer ipoib_peer_cache[IPOIB_NUM_CACHED_PEERS];
 119
 120 /** Oldest IPoIB peer cache entry index */
 121 static unsigned int ipoib_peer_cache_idx = 1;
 122
 123 /**
 124  * Look up cached peer by key
 125  *
 126  * @v key               Peer cache key
 127  * @ret peer            Peer cache entry, or NULL
 128  */
 129 static struct ipoib_peer * ipoib_lookup_peer_by_key ( unsigned int key ) {
 130         struct ipoib_peer *peer;
 131         unsigned int i;
 132
 133         for ( i = 0 ; i < IPOIB_NUM_CACHED_PEERS ; i++ ) {
 134                 peer = &ipoib_peer_cache[i];
 135                 if ( peer->key == key )
 136                         return peer;
 137         }
 138
 139         if ( key != 0 ) {
 140                 DBG ( "IPoIB warning: peer cache lost track of key %x while "
 141                       "still in use\n", key );
 142         }
 143         return NULL;
 144 }
 145
 146 /**
 147  * Store GID and QPN in peer cache
 148  *
 149  * @v mac               Peer MAC address
 150  * @ret peer            Peer cache entry
 151  */
 152 static struct ipoib_peer * ipoib_cache_peer ( const struct ipoib_mac *mac ) {
 153         struct ipoib_peer *peer;
 154         unsigned int key;
 155         unsigned int i;
 156
 157         /* Look for existing cache entry */
 158         for ( i = 0 ; i < IPOIB_NUM_CACHED_PEERS ; i++ ) {
 159                 peer = &ipoib_peer_cache[i];
 160                 if ( memcmp ( &peer->mac, mac, sizeof ( peer->mac ) ) == 0 )
 161                         return peer;
 162         }
 163
 164         /* No entry found: create a new one */
 165         key = ipoib_peer_cache_idx++;
 166         peer = &ipoib_peer_cache[ key % IPOIB_NUM_CACHED_PEERS ];
 167         if ( peer->key )
 168                 DBG ( "IPoIB peer %x evicted from cache\n", peer->key );
 169
 170         memset ( peer, 0, sizeof ( *peer ) );
 171         peer->key = key;
 172         memcpy ( &peer->mac, mac, sizeof ( peer->mac ) );
 173         DBG ( "IPoIB peer %x has MAC %s\n",
 174               peer->key, ipoib_ntoa ( &peer->mac ) );
 175         return peer;
 176 }
 177
 178 /****************************************************************************
 179  *
 180  * IPoIB link layer
 181  *
 182  ****************************************************************************
 183  */
 184
 185 /**
 186  * Add IPoIB link-layer header
 187  *
 188  * @v netdev            Network device
 189  * @v iobuf             I/O buffer
 190  * @v ll_dest           Link-layer destination address
 191  * @v ll_source         Source link-layer address
 192  * @v net_proto         Network-layer protocol, in network-byte order
 193  * @ret rc              Return status code
 194  */
 195 static int ipoib_push ( struct net_device *netdev __unused,
 196                         struct io_buffer *iobuf, const void *ll_dest,
 197                         const void *ll_source __unused, uint16_t net_proto ) {
 198         struct ipoib_hdr *ipoib_hdr =
 199                 iob_push ( iobuf, sizeof ( *ipoib_hdr ) );
 200         const struct ipoib_mac *dest_mac = ll_dest;
 201         const struct ipoib_mac *src_mac = ll_source;
 202         struct ipoib_peer *dest;
 203         struct ipoib_peer *src;
 204
 205         /* Add link-layer addresses to cache */
 206         dest = ipoib_cache_peer ( dest_mac );
 207         src = ipoib_cache_peer ( src_mac );
 208
 209         /* Build IPoIB header */
 210         ipoib_hdr->proto = net_proto;
 211         ipoib_hdr->u.peer.dest = dest->key;
 212         ipoib_hdr->u.peer.src = src->key;
 213
 214         return 0;
 215 }
 216
 217 /**
 218  * Remove IPoIB link-layer header
 219  *
 220  * @v netdev            Network device
 221  * @v iobuf             I/O buffer
 222  * @ret ll_dest         Link-layer destination address
 223  * @ret ll_source       Source link-layer address
 224  * @ret net_proto       Network-layer protocol, in network-byte order
 225  * @ret rc              Return status code
 226  */
 227 static int ipoib_pull ( struct net_device *netdev,
 228                         struct io_buffer *iobuf, const void **ll_dest,
 229                         const void **ll_source, uint16_t *net_proto ) {
 230         struct ipoib_device *ipoib = netdev->priv;
 231         struct ipoib_hdr *ipoib_hdr = iobuf->data;
 232         struct ipoib_peer *dest;
 233         struct ipoib_peer *source;
 234
 235         /* Sanity check */
 236         if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
 237                 DBG ( "IPoIB packet too short for link-layer header\n" );
 238                 DBG_HD ( iobuf->data, iob_len ( iobuf ) );
 239                 return -EINVAL;
 240         }
 241
 242         /* Strip off IPoIB header */
 243         iob_pull ( iobuf, sizeof ( *ipoib_hdr ) );
 244
 245         /* Identify source and destination addresses, and clear
 246          * reserved word in IPoIB header
 247          */
 248         dest = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.dest );
 249         source = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.src );
 250         ipoib_hdr->u.reserved = 0;
 251
 252         /* Fill in required fields */
 253         *ll_dest = ( dest ? &dest->mac : &ipoib->broadcast );
 254         *ll_source = ( source ? &source->mac : &ipoib->broadcast );
 255         *net_proto = ipoib_hdr->proto;
 256
 257         return 0;
 258 }
 259
 260 /**
 261  * Initialise IPoIB link-layer address
 262  *
 263  * @v hw_addr           Hardware address
 264  * @v ll_addr           Link-layer address
 265  */
 266 static void ipoib_init_addr ( const void *hw_addr, void *ll_addr ) {
 267         const struct ib_gid_half *guid = hw_addr;
 268         struct ipoib_mac *mac = ll_addr;
 269
 270         memset ( mac, 0, sizeof ( *mac ) );
 271         memcpy ( &mac->gid.u.half[1], guid, sizeof ( mac->gid.u.half[1] ) );
 272 }
 273
 274 /**
 275  * Transcribe IPoIB link-layer address
 276  *
 277  * @v ll_addr   Link-layer address
 278  * @ret string  Link-layer address in human-readable format
 279  */
 280 const char * ipoib_ntoa ( const void *ll_addr ) {
 281         static char buf[45];
 282         const struct ipoib_mac *mac = ll_addr;
 283
 284         snprintf ( buf, sizeof ( buf ), "%08x:%08x:%08x:%08x:%08x",
 285                    htonl ( mac->flags__qpn ), htonl ( mac->gid.u.dwords[0] ),
 286                    htonl ( mac->gid.u.dwords[1] ),
 287                    htonl ( mac->gid.u.dwords[2] ),
 288                    htonl ( mac->gid.u.dwords[3] ) );
 289         return buf;
 290 }
 291
 292 /**
 293  * Hash multicast address
 294  *
 295  * @v af                Address family
 296  * @v net_addr          Network-layer address
 297  * @v ll_addr           Link-layer address to fill in
 298  * @ret rc              Return status code
 299  */
 300 static int ipoib_mc_hash ( unsigned int af __unused,
 301                            const void *net_addr __unused,
 302                            void *ll_addr __unused ) {
 303
 304         return -ENOTSUP;
 305 }
 306
 307 /**
 308  * Generate Mellanox Ethernet-compatible compressed link-layer address
 309  *
 310  * @v ll_addr           Link-layer address
 311  * @v eth_addr          Ethernet-compatible address to fill in
 312  */
 313 static int ipoib_mlx_eth_addr ( const struct ib_gid_half *guid,
 314                                 uint8_t *eth_addr ) {
 315         eth_addr[0] = ( ( guid->u.bytes[3] == 2 ) ? 0x00 : 0x02 );
 316         eth_addr[1] = guid->u.bytes[1];
 317         eth_addr[2] = guid->u.bytes[2];
 318         eth_addr[3] = guid->u.bytes[5];
 319         eth_addr[4] = guid->u.bytes[6];
 320         eth_addr[5] = guid->u.bytes[7];
 321         return 0;
 322 }
 323
 324 /** An IPoIB Ethernet-compatible compressed link-layer address generator */
 325 struct ipoib_eth_addr_handler {
 326         /** GUID byte 1 */
 327         uint8_t byte1;
 328         /** GUID byte 2 */
 329         uint8_t byte2;
 330         /** Handler */
 331         int ( * eth_addr ) ( const struct ib_gid_half *guid,
 332                              uint8_t *eth_addr );
 333 };
 334
 335 /** IPoIB Ethernet-compatible compressed link-layer address generators */
 336 static struct ipoib_eth_addr_handler ipoib_eth_addr_handlers[] = {
 337         { 0x02, 0xc9, ipoib_mlx_eth_addr },
 338 };
 339
 340 /**
 341  * Generate Ethernet-compatible compressed link-layer address
 342  *
 343  * @v ll_addr           Link-layer address
 344  * @v eth_addr          Ethernet-compatible address to fill in
 345  */
 346 static int ipoib_eth_addr ( const void *ll_addr, void *eth_addr ) {
 347         const struct ipoib_mac *ipoib_addr = ll_addr;
 348         const struct ib_gid_half *guid = &ipoib_addr->gid.u.half[1];
 349         struct ipoib_eth_addr_handler *handler;
 350         unsigned int i;
 351
 352         for ( i = 0 ; i < ( sizeof ( ipoib_eth_addr_handlers ) /
 353                             sizeof ( ipoib_eth_addr_handlers[0] ) ) ; i++ ) {
 354                 handler = &ipoib_eth_addr_handlers[i];
 355                 if ( ( handler->byte1 == guid->u.bytes[1] ) &&
 356                      ( handler->byte2 == guid->u.bytes[2] ) ) {
 357                         return handler->eth_addr ( guid, eth_addr );
 358                 }
 359         }
 360         return -ENOTSUP;
 361 }
 362
 363 /** IPoIB protocol */
 364 struct ll_protocol ipoib_protocol __ll_protocol = {
 365         .name           = "IPoIB",
 366         .ll_proto       = htons ( ARPHRD_INFINIBAND ),
 367         .hw_addr_len    = sizeof ( struct ib_gid_half ),
 368         .ll_addr_len    = IPOIB_ALEN,
 369         .ll_header_len  = IPOIB_HLEN,
 370         .push           = ipoib_push,
 371         .pull           = ipoib_pull,
 372         .init_addr      = ipoib_init_addr,
 373         .ntoa           = ipoib_ntoa,
 374         .mc_hash        = ipoib_mc_hash,
 375         .eth_addr       = ipoib_eth_addr,
 376 };
 377
 378 /**
 379  * Allocate IPoIB device
 380  *
 381  * @v priv_size         Size of driver private data
 382  * @ret netdev          Network device, or NULL
 383  */
 384 struct net_device * alloc_ipoibdev ( size_t priv_size ) {
 385         struct net_device *netdev;
 386
 387         netdev = alloc_netdev ( priv_size );
 388         if ( netdev ) {
 389                 netdev->ll_protocol = &ipoib_protocol;
 390                 netdev->ll_broadcast = ( uint8_t * ) &ipoib_broadcast;
 391                 netdev->max_pkt_len = IB_MAX_PAYLOAD_SIZE;
 392         }
 393         return netdev;
 394 }
 395
 396 /****************************************************************************
 397  *
 398  * IPoIB network device
 399  *
 400  ****************************************************************************
 401  */
 402
 403 /**
 404  * Transmit packet via IPoIB network device
 405  *
 406  * @v netdev            Network device
 407  * @v iobuf             I/O buffer
 408  * @ret rc              Return status code
 409  */
 410 static int ipoib_transmit ( struct net_device *netdev,
 411                             struct io_buffer *iobuf ) {
 412         struct ipoib_device *ipoib = netdev->priv;
 413         struct ib_device *ibdev = ipoib->ibdev;
 414         struct ipoib_hdr *ipoib_hdr;
 415         struct ipoib_peer *dest;
 416         struct ib_address_vector av;
 417         int rc;
 418
 419         /* Sanity check */
 420         if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
 421                 DBGC ( ipoib, "IPoIB %p buffer too short\n", ipoib );
 422                 return -EINVAL;
 423         }
 424         ipoib_hdr = iobuf->data;
 425
 426         /* Attempting transmission while link is down will put the
 427          * queue pair into an error state, so don't try it.
 428          */
 429         if ( ! ib_link_ok ( ibdev ) )
 430                 return -ENETUNREACH;
 431
 432         /* Identify destination address */
 433         dest = ipoib_lookup_peer_by_key ( ipoib_hdr->u.peer.dest );
 434         if ( ! dest )
 435                 return -ENXIO;
 436         ipoib_hdr->u.reserved = 0;
 437
 438         /* Construct address vector */
 439         memset ( &av, 0, sizeof ( av ) );
 440         av.qpn = ( ntohl ( dest->mac.flags__qpn ) & IB_QPN_MASK );
 441         av.gid_present = 1;
 442         memcpy ( &av.gid, &dest->mac.gid, sizeof ( av.gid ) );
 443         if ( ( rc = ib_resolve_path ( ibdev, &av ) ) != 0 ) {
 444                 /* Path not resolved yet */
 445                 return rc;
 446         }
 447
 448         return ib_post_send ( ibdev, ipoib->qp, &av, iobuf );
 449 }
 450
 451 /**
 452  * Handle IPoIB send completion
 453  *
 454  * @v ibdev             Infiniband device
 455  * @v qp                Queue pair
 456  * @v iobuf             I/O buffer
 457  * @v rc                Completion status code
 458  */
 459 static void ipoib_complete_send ( struct ib_device *ibdev __unused,
 460                                   struct ib_queue_pair *qp,
 461                                   struct io_buffer *iobuf, int rc ) {
 462         struct ipoib_device *ipoib = ib_qp_get_ownerdata ( qp );
 463
 464         netdev_tx_complete_err ( ipoib->netdev, iobuf, rc );
 465 }
 466
 467 /**
 468  * Handle IPoIB receive completion
 469  *
 470  * @v ibdev             Infiniband device
 471  * @v qp                Queue pair
 472  * @v av                Address vector, or NULL
 473  * @v iobuf             I/O buffer
 474  * @v rc                Completion status code
 475  */
 476 static void ipoib_complete_recv ( struct ib_device *ibdev __unused,
 477                                   struct ib_queue_pair *qp,
 478                                   struct ib_address_vector *av,
 479                                   struct io_buffer *iobuf, int rc ) {
 480         struct ipoib_device *ipoib = ib_qp_get_ownerdata ( qp );
 481         struct net_device *netdev = ipoib->netdev;
 482         struct ipoib_hdr *ipoib_hdr;
 483         struct ipoib_mac ll_src;
 484         struct ipoib_peer *src;
 485
 486         if ( rc != 0 ) {
 487                 netdev_rx_err ( netdev, iobuf, rc );
 488                 return;
 489         }
 490
 491         /* Sanity check */
 492         if ( iob_len ( iobuf ) < sizeof ( struct ipoib_hdr ) ) {
 493                 DBGC ( ipoib, "IPoIB %p received packet too short to "
 494                        "contain IPoIB header\n", ipoib );
 495                 DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
 496                 netdev_rx_err ( netdev, iobuf, -EIO );
 497                 return;
 498         }
 499         ipoib_hdr = iobuf->data;
 500
 501         /* Parse source address */
 502         if ( av->gid_present ) {
 503                 ll_src.flags__qpn = htonl ( av->qpn );
 504                 memcpy ( &ll_src.gid, &av->gid, sizeof ( ll_src.gid ) );
 505                 src = ipoib_cache_peer ( &ll_src );
 506                 ipoib_hdr->u.peer.src = src->key;
 507         }
 508
 509         /* Hand off to network layer */
 510         netdev_rx ( netdev, iobuf );
 511 }
 512
 513 /** IPoIB completion operations */
 514 static struct ib_completion_queue_operations ipoib_cq_op = {
 515         .complete_send = ipoib_complete_send,
 516         .complete_recv = ipoib_complete_recv,
 517 };
 518
 519 /**
 520  * Poll IPoIB network device
 521  *
 522  * @v netdev            Network device
 523  */
 524 static void ipoib_poll ( struct net_device *netdev ) {
 525         struct ipoib_device *ipoib = netdev->priv;
 526         struct ib_device *ibdev = ipoib->ibdev;
 527
 528         ib_poll_eq ( ibdev );
 529 }
 530
 531 /**
 532  * Enable/disable interrupts on IPoIB network device
 533  *
 534  * @v netdev            Network device
 535  * @v enable            Interrupts should be enabled
 536  */
 537 static void ipoib_irq ( struct net_device *netdev __unused,
 538                         int enable __unused ) {
 539         /* No implementation */
 540 }
 541
 542 /**
 543  * Handle IPv4 broadcast multicast group join completion
 544  *
 545  * @v ibdev             Infiniband device
 546  * @v qp                Queue pair
 547  * @v membership        Multicast group membership
 548  * @v rc                Status code
 549  * @v mad               Response MAD (or NULL on error)
 550  */
 551 void ipoib_join_complete ( struct ib_device *ibdev __unused,
 552                            struct ib_queue_pair *qp __unused,
 553                            struct ib_mc_membership *membership, int rc,
 554                            union ib_mad *mad __unused ) {
 555         struct ipoib_device *ipoib = container_of ( membership,
 556                                    struct ipoib_device, broadcast_membership );
 557
 558         /* Record join status as link status */
 559         netdev_link_err ( ipoib->netdev, rc );
 560 }
 561
 562 /**
 563  * Join IPv4 broadcast multicast group
 564  *
 565  * @v ipoib             IPoIB device
 566  * @ret rc              Return status code
 567  */
 568 static int ipoib_join_broadcast_group ( struct ipoib_device *ipoib ) {
 569         int rc;
 570
 571         if ( ( rc = ib_mcast_join ( ipoib->ibdev, ipoib->qp,
 572                                     &ipoib->broadcast_membership,
 573                                     &ipoib->broadcast.gid,
 574                                     ipoib_join_complete ) ) != 0 ) {
 575                 DBGC ( ipoib, "IPoIB %p could not join broadcast group: %s\n",
 576                        ipoib, strerror ( rc ) );
 577                 return rc;
 578         }
 579         ipoib->broadcast_joined = 1;
 580
 581         return 0;
 582 }
 583
 584 /**
 585  * Leave IPv4 broadcast multicast group
 586  *
 587  * @v ipoib             IPoIB device
 588  */
 589 static void ipoib_leave_broadcast_group ( struct ipoib_device *ipoib ) {
 590
 591         if ( ipoib->broadcast_joined ) {
 592                 ib_mcast_leave ( ipoib->ibdev, ipoib->qp,
 593                                  &ipoib->broadcast_membership );
 594                 ipoib->broadcast_joined = 0;
 595         }
 596 }
 597
 598 /**
 599  * Open IPoIB network device
 600  *
 601  * @v netdev            Network device
 602  * @ret rc              Return status code
 603  */
 604 static int ipoib_open ( struct net_device *netdev ) {
 605         struct ipoib_device *ipoib = netdev->priv;
 606         struct ib_device *ibdev = ipoib->ibdev;
 607         struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
 608         int rc;
 609
 610         /* Open IB device */
 611         if ( ( rc = ib_open ( ibdev ) ) != 0 ) {
 612                 DBGC ( ipoib, "IPoIB %p could not open device: %s\n",
 613                        ipoib, strerror ( rc ) );
 614                 goto err_ib_open;
 615         }
 616
 617         /* Allocate completion queue */
 618         ipoib->cq = ib_create_cq ( ibdev, IPOIB_NUM_CQES, &ipoib_cq_op );
 619         if ( ! ipoib->cq ) {
 620                 DBGC ( ipoib, "IPoIB %p could not allocate completion queue\n",
 621                        ipoib );
 622                 rc = -ENOMEM;
 623                 goto err_create_cq;
 624         }
 625
 626         /* Allocate queue pair */
 627         ipoib->qp = ib_create_qp ( ibdev, IB_QPT_UD,
 628                                    IPOIB_NUM_SEND_WQES, ipoib->cq,
 629                                    IPOIB_NUM_RECV_WQES, ipoib->cq );
 630         if ( ! ipoib->qp ) {
 631                 DBGC ( ipoib, "IPoIB %p could not allocate queue pair\n",
 632                        ipoib );
 633                 rc = -ENOMEM;
 634                 goto err_create_qp;
 635         }
 636         ib_qp_set_ownerdata ( ipoib->qp, ipoib );
 637
 638         /* Update MAC address with QPN */
 639         mac->flags__qpn = htonl ( ipoib->qp->qpn );
 640
 641         /* Fill receive rings */
 642         ib_refill_recv ( ibdev, ipoib->qp );
 643
 644         /* Fake a link status change to join the broadcast group */
 645         ipoib_link_state_changed ( ibdev );
 646
 647         return 0;
 648
 649         ib_destroy_qp ( ibdev, ipoib->qp );
 650  err_create_qp:
 651         ib_destroy_cq ( ibdev, ipoib->cq );
 652  err_create_cq:
 653         ib_close ( ibdev );
 654  err_ib_open:
 655         return rc;
 656 }
 657
 658 /**
 659  * Close IPoIB network device
 660  *
 661  * @v netdev            Network device
 662  */
 663 static void ipoib_close ( struct net_device *netdev ) {
 664         struct ipoib_device *ipoib = netdev->priv;
 665         struct ib_device *ibdev = ipoib->ibdev;
 666         struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
 667
 668         /* Leave broadcast group */
 669         ipoib_leave_broadcast_group ( ipoib );
 670
 671         /* Remove QPN from MAC address */
 672         mac->flags__qpn = 0;
 673
 674         /* Tear down the queues */
 675         ib_destroy_qp ( ibdev, ipoib->qp );
 676         ib_destroy_cq ( ibdev, ipoib->cq );
 677
 678         /* Close IB device */
 679         ib_close ( ibdev );
 680 }
 681
 682 /** IPoIB network device operations */
 683 static struct net_device_operations ipoib_operations = {
 684         .open           = ipoib_open,
 685         .close          = ipoib_close,
 686         .transmit       = ipoib_transmit,
 687         .poll           = ipoib_poll,
 688         .irq            = ipoib_irq,
 689 };
 690
 691 /**
 692  * Handle link status change
 693  *
 694  * @v ibdev             Infiniband device
 695  */
 696 void ipoib_link_state_changed ( struct ib_device *ibdev ) {
 697         struct net_device *netdev = ib_get_ownerdata ( ibdev );
 698         struct ipoib_device *ipoib = netdev->priv;
 699         struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
 700         int rc;
 701
 702         /* Leave existing broadcast group */
 703         ipoib_leave_broadcast_group ( ipoib );
 704
 705         /* Update MAC address based on potentially-new GID prefix */
 706         memcpy ( &mac->gid.u.half[0], &ibdev->gid.u.half[0],
 707                  sizeof ( mac->gid.u.half[0] ) );
 708
 709         /* Update broadcast GID based on potentially-new partition key */
 710         ipoib->broadcast.gid.u.words[2] =
 711                 htons ( ibdev->pkey | IB_PKEY_FULL );
 712
 713         /* Set net device link state to reflect Infiniband link state */
 714         rc = ib_link_rc ( ibdev );
 715         netdev_link_err ( netdev, ( rc ? rc : -EINPROGRESS_JOINING ) );
 716
 717         /* Join new broadcast group */
 718         if ( ib_link_ok ( ibdev ) &&
 719              ( ( rc = ipoib_join_broadcast_group ( ipoib ) ) != 0 ) ) {
 720                 DBGC ( ipoib, "IPoIB %p could not rejoin broadcast group: "
 721                        "%s\n", ipoib, strerror ( rc ) );
 722                 netdev_link_err ( netdev, rc );
 723                 return;
 724         }
 725 }
 726
 727 /**
 728  * Probe IPoIB device
 729  *
 730  * @v ibdev             Infiniband device
 731  * @ret rc              Return status code
 732  */
 733 int ipoib_probe ( struct ib_device *ibdev ) {
 734         struct net_device *netdev;
 735         struct ipoib_device *ipoib;
 736         int rc;
 737
 738         /* Allocate network device */
 739         netdev = alloc_ipoibdev ( sizeof ( *ipoib ) );
 740         if ( ! netdev )
 741                 return -ENOMEM;
 742         netdev_init ( netdev, &ipoib_operations );
 743         ipoib = netdev->priv;
 744         ib_set_ownerdata ( ibdev, netdev );
 745         netdev->dev = ibdev->dev;
 746         memset ( ipoib, 0, sizeof ( *ipoib ) );
 747         ipoib->netdev = netdev;
 748         ipoib->ibdev = ibdev;
 749
 750         /* Extract hardware address */
 751         memcpy ( netdev->hw_addr, &ibdev->gid.u.half[1],
 752                  sizeof ( ibdev->gid.u.half[1] ) );
 753
 754         /* Set default broadcast address */
 755         memcpy ( &ipoib->broadcast, &ipoib_broadcast,
 756                  sizeof ( ipoib->broadcast ) );
 757         netdev->ll_broadcast = ( ( uint8_t * ) &ipoib->broadcast );
 758
 759         /* Register network device */
 760         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 761                 goto err_register_netdev;
 762
 763         return 0;
 764
 765  err_register_netdev:
 766         netdev_nullify ( netdev );
 767         netdev_put ( netdev );
 768         return rc;
 769 }
 770
 771 /**
 772  * Remove IPoIB device
 773  *
 774  * @v ibdev             Infiniband device
 775  */
 776 void ipoib_remove ( struct ib_device *ibdev ) {
 777         struct net_device *netdev = ib_get_ownerdata ( ibdev );
 778
 779         unregister_netdev ( netdev );
 780         netdev_nullify ( netdev );
 781         netdev_put ( netdev );
 782 }