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 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <byteswap.h>
  24 #include <errno.h>
  25 #include <gpxe/if_arp.h>
  26 #include <gpxe/iobuf.h>
  27 #include <gpxe/netdevice.h>
  28 #include <gpxe/infiniband.h>
  29 #include <gpxe/ipoib.h>
  30
  31 /** @file
  32  *
  33  * IP over Infiniband
  34  */
  35
  36 /** IPoIB MTU */
  37 #define IPOIB_MTU 2048
  38
  39 /** Number of IPoIB data send work queue entries */
  40 #define IPOIB_DATA_NUM_SEND_WQES 2
  41
  42 /** Number of IPoIB data receive work queue entries */
  43 #define IPOIB_DATA_NUM_RECV_WQES 4
  44
  45 /** Number of IPoIB data completion entries */
  46 #define IPOIB_DATA_NUM_CQES 8
  47
  48 /** Number of IPoIB metadata send work queue entries */
  49 #define IPOIB_META_NUM_SEND_WQES 2
  50
  51 /** Number of IPoIB metadata receive work queue entries */
  52 #define IPOIB_META_NUM_RECV_WQES 2
  53
  54 /** Number of IPoIB metadata completion entries */
  55 #define IPOIB_META_NUM_CQES 8
  56
  57 /** An IPoIB queue set */
  58 struct ipoib_queue_set {
  59         /** Completion queue */
  60         struct ib_completion_queue *cq;
  61         /** Queue pair */
  62         struct ib_queue_pair *qp;
  63         /** Receive work queue fill level */
  64         unsigned int recv_fill;
  65         /** Receive work queue maximum fill level */
  66         unsigned int recv_max_fill;
  67 };
  68
  69 /** An IPoIB device */
  70 struct ipoib_device {
  71         /** Network device */
  72         struct net_device *netdev;
  73         /** Underlying Infiniband device */
  74         struct ib_device *ibdev;
  75         /** Data queue set */
  76         struct ipoib_queue_set data;
  77         /** Data queue set */
  78         struct ipoib_queue_set meta;
  79         /** Broadcast GID */
  80         struct ib_gid broadcast_gid;
  81         /** Broadcast LID */
  82         unsigned int broadcast_lid;
  83         /** Data queue key */
  84         unsigned long data_qkey;
  85         /** Attached to multicast group
  86          *
  87          * This flag indicates whether or not we have attached our
  88          * data queue pair to the broadcast multicast GID.
  89          */
  90         int broadcast_attached;
  91 };
  92
  93 /**
  94  * IPoIB path cache entry
  95  *
  96  * This serves a similar role to the ARP cache for Ethernet.  (ARP
  97  * *is* used on IPoIB; we have two caches to maintain.)
  98  */
  99 struct ipoib_cached_path {
 100         /** Destination GID */
 101         struct ib_gid gid;
 102         /** Destination LID */
 103         unsigned int dlid;
 104         /** Service level */
 105         unsigned int sl;
 106         /** Rate */
 107         unsigned int rate;
 108 };
 109
 110 /** Number of IPoIB path cache entries */
 111 #define IPOIB_NUM_CACHED_PATHS 2
 112
 113 /** IPoIB path cache */
 114 static struct ipoib_cached_path ipoib_path_cache[IPOIB_NUM_CACHED_PATHS];
 115
 116 /** Oldest IPoIB path cache entry index */
 117 static unsigned int ipoib_path_cache_idx = 0;
 118
 119 /** TID half used to identify get path record replies */
 120 #define IPOIB_TID_GET_PATH_REC 0x11111111UL
 121
 122 /** TID half used to identify multicast member record replies */
 123 #define IPOIB_TID_MC_MEMBER_REC 0x22222222UL
 124
 125 /** IPoIB metadata TID */
 126 static uint32_t ipoib_meta_tid = 0;
 127
 128 /** IPv4 broadcast GID */
 129 static const struct ib_gid ipv4_broadcast_gid = {
 130         { { 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
 131             0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff } }
 132 };
 133
 134 /** Maximum time we will wait for the broadcast join to succeed */
 135 #define IPOIB_JOIN_MAX_DELAY_MS 1000
 136
 137 /****************************************************************************
 138  *
 139  * IPoIB link layer
 140  *
 141  ****************************************************************************
 142  */
 143
 144 /** Broadcast QPN used in IPoIB MAC addresses
 145  *
 146  * This is a guaranteed invalid real QPN
 147  */
 148 #define IPOIB_BROADCAST_QPN 0xffffffffUL
 149
 150 /** Broadcast IPoIB address */
 151 static struct ipoib_mac ipoib_broadcast = {
 152         .qpn = ntohl ( IPOIB_BROADCAST_QPN ),
 153 };
 154
 155 /**
 156  * Transmit IPoIB packet
 157  *
 158  * @v iobuf             I/O buffer
 159  * @v netdev            Network device
 160  * @v net_protocol      Network-layer protocol
 161  * @v ll_dest           Link-layer destination address
 162  *
 163  * Prepends the IPoIB link-layer header and transmits the packet.
 164  */
 165 static int ipoib_tx ( struct io_buffer *iobuf, struct net_device *netdev,
 166                       struct net_protocol *net_protocol,
 167                       const void *ll_dest ) {
 168         struct ipoib_hdr *ipoib_hdr =
 169                 iob_push ( iobuf, sizeof ( *ipoib_hdr ) );
 170
 171         /* Build IPoIB header */
 172         memcpy ( &ipoib_hdr->pseudo.peer, ll_dest,
 173                  sizeof ( ipoib_hdr->pseudo.peer ) );
 174         ipoib_hdr->real.proto = net_protocol->net_proto;
 175         ipoib_hdr->real.reserved = 0;
 176
 177         /* Hand off to network device */
 178         return netdev_tx ( netdev, iobuf );
 179 }
 180
 181 /**
 182  * Process received IPoIB packet
 183  *
 184  * @v iobuf     I/O buffer
 185  * @v netdev    Network device
 186  *
 187  * Strips off the IPoIB link-layer header and passes up to the
 188  * network-layer protocol.
 189  */
 190 static int ipoib_rx ( struct io_buffer *iobuf, struct net_device *netdev ) {
 191         struct ipoib_hdr *ipoib_hdr = iobuf->data;
 192
 193         /* Sanity check */
 194         if ( iob_len ( iobuf ) < sizeof ( *ipoib_hdr ) ) {
 195                 DBG ( "IPoIB packet too short for link-layer header\n" );
 196                 DBG_HD ( iobuf->data, iob_len ( iobuf ) );
 197                 free_iob ( iobuf );
 198                 return -EINVAL;
 199         }
 200
 201         /* Strip off IPoIB header */
 202         iob_pull ( iobuf, sizeof ( *ipoib_hdr ) );
 203
 204         /* Hand off to network-layer protocol */
 205         return net_rx ( iobuf, netdev, ipoib_hdr->real.proto,
 206                         &ipoib_hdr->pseudo.peer );
 207 }
 208
 209 /**
 210  * Transcribe IPoIB address
 211  *
 212  * @v ll_addr   Link-layer address
 213  * @ret string  Link-layer address in human-readable format
 214  */
 215 const char * ipoib_ntoa ( const void *ll_addr ) {
 216         static char buf[45];
 217         const struct ipoib_mac *mac = ll_addr;
 218
 219         snprintf ( buf, sizeof ( buf ), "%08lx:%08lx:%08lx:%08lx:%08lx",
 220                    htonl ( mac->qpn ), htonl ( mac->gid.u.dwords[0] ),
 221                    htonl ( mac->gid.u.dwords[1] ),
 222                    htonl ( mac->gid.u.dwords[2] ),
 223                    htonl ( mac->gid.u.dwords[3] ) );
 224         return buf;
 225 }
 226
 227 /** IPoIB protocol */
 228 struct ll_protocol ipoib_protocol __ll_protocol = {
 229         .name           = "IPoIB",
 230         .ll_proto       = htons ( ARPHRD_INFINIBAND ),
 231         .ll_addr_len    = IPOIB_ALEN,
 232         .ll_header_len  = IPOIB_HLEN,
 233         .ll_broadcast   = ( uint8_t * ) &ipoib_broadcast,
 234         .tx             = ipoib_tx,
 235         .rx             = ipoib_rx,
 236         .ntoa           = ipoib_ntoa,
 237 };
 238
 239 /****************************************************************************
 240  *
 241  * IPoIB network device
 242  *
 243  ****************************************************************************
 244  */
 245
 246 /**
 247  * Destroy queue set
 248  *
 249  * @v ipoib             IPoIB device
 250  * @v qset              Queue set
 251  */
 252 static void ipoib_destroy_qset ( struct ipoib_device *ipoib,
 253                                  struct ipoib_queue_set *qset ) {
 254         struct ib_device *ibdev = ipoib->ibdev;
 255
 256         if ( qset->qp )
 257                 ib_destroy_qp ( ibdev, qset->qp );
 258         if ( qset->cq )
 259                 ib_destroy_cq ( ibdev, qset->cq );
 260         memset ( qset, 0, sizeof ( *qset ) );
 261 }
 262
 263 /**
 264  * Create queue set
 265  *
 266  * @v ipoib             IPoIB device
 267  * @v qset              Queue set
 268  * @ret rc              Return status code
 269  */
 270 static int ipoib_create_qset ( struct ipoib_device *ipoib,
 271                                struct ipoib_queue_set *qset,
 272                                unsigned int num_cqes,
 273                                unsigned int num_send_wqes,
 274                                unsigned int num_recv_wqes,
 275                                unsigned long qkey ) {
 276         struct ib_device *ibdev = ipoib->ibdev;
 277         int rc;
 278
 279         /* Sanity check */
 280         assert ( qset->cq == NULL );
 281         assert ( qset->qp == NULL );
 282
 283         /* Store queue parameters */
 284         qset->recv_max_fill = num_recv_wqes;
 285
 286         /* Allocate completion queue */
 287         qset->cq = ib_create_cq ( ibdev, num_cqes );
 288         if ( ! qset->cq ) {
 289                 DBGC ( ipoib, "IPoIB %p could not allocate completion queue\n",
 290                        ipoib );
 291                 rc = -ENOMEM;
 292                 goto err;
 293         }
 294
 295         /* Allocate queue pair */
 296         qset->qp = ib_create_qp ( ibdev, num_send_wqes, qset->cq,
 297                                   num_recv_wqes, qset->cq, qkey );
 298         if ( ! qset->qp ) {
 299                 DBGC ( ipoib, "IPoIB %p could not allocate queue pair\n",
 300                        ipoib );
 301                 rc = -ENOMEM;
 302                 goto err;
 303         }
 304         ib_qp_set_ownerdata ( qset->qp, ipoib->netdev );
 305
 306         return 0;
 307
 308  err:
 309         ipoib_destroy_qset ( ipoib, qset );
 310         return rc;
 311 }
 312
 313 /**
 314  * Find path cache entry by GID
 315  *
 316  * @v gid               GID
 317  * @ret entry           Path cache entry, or NULL
 318  */
 319 static struct ipoib_cached_path *
 320 ipoib_find_cached_path ( struct ib_gid *gid ) {
 321         struct ipoib_cached_path *path;
 322         unsigned int i;
 323
 324         for ( i = 0 ; i < IPOIB_NUM_CACHED_PATHS ; i++ ) {
 325                 path = &ipoib_path_cache[i];
 326                 if ( memcmp ( &path->gid, gid, sizeof ( *gid ) ) == 0 )
 327                         return path;
 328         }
 329         DBG ( "IPoIB %08lx:%08lx:%08lx:%08lx cache miss\n",
 330               htonl ( gid->u.dwords[0] ), htonl ( gid->u.dwords[1] ),
 331               htonl ( gid->u.dwords[2] ), htonl ( gid->u.dwords[3] ) );
 332         return NULL;
 333 }
 334
 335 /**
 336  * Transmit path record request
 337  *
 338  * @v ipoib             IPoIB device
 339  * @v gid               Destination GID
 340  * @ret rc              Return status code
 341  */
 342 static int ipoib_get_path_record ( struct ipoib_device *ipoib,
 343                                    struct ib_gid *gid ) {
 344         struct ib_device *ibdev = ipoib->ibdev;
 345         struct io_buffer *iobuf;
 346         struct ib_mad_path_record *path_record;
 347         struct ib_address_vector av;
 348         int rc;
 349
 350         /* Allocate I/O buffer */
 351         iobuf = alloc_iob ( sizeof ( *path_record ) );
 352         if ( ! iobuf )
 353                 return -ENOMEM;
 354         iob_put ( iobuf, sizeof ( *path_record ) );
 355         path_record = iobuf->data;
 356         memset ( path_record, 0, sizeof ( *path_record ) );
 357
 358         /* Construct path record request */
 359         path_record->mad_hdr.base_version = IB_MGMT_BASE_VERSION;
 360         path_record->mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
 361         path_record->mad_hdr.class_version = 2;
 362         path_record->mad_hdr.method = IB_MGMT_METHOD_GET;
 363         path_record->mad_hdr.attr_id = htons ( IB_SA_ATTR_PATH_REC );
 364         path_record->mad_hdr.tid[0] = IPOIB_TID_GET_PATH_REC;
 365         path_record->mad_hdr.tid[1] = ipoib_meta_tid++;
 366         path_record->sa_hdr.comp_mask[1] =
 367                 htonl ( IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID );
 368         memcpy ( &path_record->dgid, gid, sizeof ( path_record->dgid ) );
 369         memcpy ( &path_record->sgid, &ibdev->port_gid,
 370                  sizeof ( path_record->sgid ) );
 371
 372         /* Construct address vector */
 373         memset ( &av, 0, sizeof ( av ) );
 374         av.dlid = ibdev->sm_lid;
 375         av.dest_qp = IB_SA_QPN;
 376         av.qkey = IB_GLOBAL_QKEY;
 377
 378         /* Post send request */
 379         if ( ( rc = ib_post_send ( ibdev, ipoib->meta.qp, &av,
 380                                    iobuf ) ) != 0 ) {
 381                 DBGC ( ipoib, "IPoIB %p could not send get path record: %s\n",
 382                        ipoib, strerror ( rc ) );
 383                 free_iob ( iobuf );
 384                 return rc;
 385         }
 386
 387         return 0;
 388 }
 389
 390 /**
 391  * Transmit multicast group membership request
 392  *
 393  * @v ipoib             IPoIB device
 394  * @v gid               Multicast GID
 395  * @v join              Join (rather than leave) group
 396  * @ret rc              Return status code
 397  */
 398 static int ipoib_mc_member_record ( struct ipoib_device *ipoib,
 399                                     struct ib_gid *gid, int join ) {
 400         struct ib_device *ibdev = ipoib->ibdev;
 401         struct io_buffer *iobuf;
 402         struct ib_mad_mc_member_record *mc_member_record;
 403         struct ib_address_vector av;
 404         int rc;
 405
 406         /* Allocate I/O buffer */
 407         iobuf = alloc_iob ( sizeof ( *mc_member_record ) );
 408         if ( ! iobuf )
 409                 return -ENOMEM;
 410         iob_put ( iobuf, sizeof ( *mc_member_record ) );
 411         mc_member_record = iobuf->data;
 412         memset ( mc_member_record, 0, sizeof ( *mc_member_record ) );
 413
 414         /* Construct path record request */
 415         mc_member_record->mad_hdr.base_version = IB_MGMT_BASE_VERSION;
 416         mc_member_record->mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
 417         mc_member_record->mad_hdr.class_version = 2;
 418         mc_member_record->mad_hdr.method =
 419                 ( join ? IB_MGMT_METHOD_SET : IB_MGMT_METHOD_DELETE );
 420         mc_member_record->mad_hdr.attr_id = htons ( IB_SA_ATTR_MC_MEMBER_REC );
 421         mc_member_record->mad_hdr.tid[0] = IPOIB_TID_MC_MEMBER_REC;
 422         mc_member_record->mad_hdr.tid[1] = ipoib_meta_tid++;
 423         mc_member_record->sa_hdr.comp_mask[1] =
 424                 htonl ( IB_SA_MCMEMBER_REC_MGID | IB_SA_MCMEMBER_REC_PORT_GID |
 425                         IB_SA_MCMEMBER_REC_JOIN_STATE );
 426         mc_member_record->scope__join_state = 1;
 427         memcpy ( &mc_member_record->mgid, gid,
 428                  sizeof ( mc_member_record->mgid ) );
 429         memcpy ( &mc_member_record->port_gid, &ibdev->port_gid,
 430                  sizeof ( mc_member_record->port_gid ) );
 431
 432         /* Construct address vector */
 433         memset ( &av, 0, sizeof ( av ) );
 434         av.dlid = ibdev->sm_lid;
 435         av.dest_qp = IB_SA_QPN;
 436         av.qkey = IB_GLOBAL_QKEY;
 437
 438         /* Post send request */
 439         if ( ( rc = ib_post_send ( ibdev, ipoib->meta.qp, &av,
 440                                    iobuf ) ) != 0 ) {
 441                 DBGC ( ipoib, "IPoIB %p could not send get path record: %s\n",
 442                        ipoib, strerror ( rc ) );
 443                 free_iob ( iobuf );
 444                 return rc;
 445         }
 446
 447         return 0;
 448 }
 449
 450 /**
 451  * Transmit packet via IPoIB network device
 452  *
 453  * @v netdev            Network device
 454  * @v iobuf             I/O buffer
 455  * @ret rc              Return status code
 456  */
 457 static int ipoib_transmit ( struct net_device *netdev,
 458                             struct io_buffer *iobuf ) {
 459         struct ipoib_device *ipoib = netdev->priv;
 460         struct ib_device *ibdev = ipoib->ibdev;
 461         struct ipoib_pseudo_hdr *ipoib_pshdr = iobuf->data;
 462         struct ib_address_vector av;
 463         struct ib_gid *gid;
 464         struct ipoib_cached_path *path;
 465         int rc;
 466
 467         /* Sanity check */
 468         if ( iob_len ( iobuf ) < sizeof ( *ipoib_pshdr ) ) {
 469                 DBGC ( ipoib, "IPoIB %p buffer too short\n", ipoib );
 470                 return -EINVAL;
 471         }
 472         iob_pull ( iobuf, ( sizeof ( *ipoib_pshdr ) ) );
 473
 474         /* Construct address vector */
 475         memset ( &av, 0, sizeof ( av ) );
 476         av.qkey = IB_GLOBAL_QKEY;
 477         av.gid_present = 1;
 478         if ( ipoib_pshdr->peer.qpn == htonl ( IPOIB_BROADCAST_QPN ) ) {
 479                 /* Broadcast address */
 480                 av.dest_qp = IB_BROADCAST_QPN;
 481                 av.dlid = ipoib->broadcast_lid;
 482                 gid = &ipoib->broadcast_gid;
 483         } else {
 484                 /* Unicast - look in path cache */
 485                 path = ipoib_find_cached_path ( &ipoib_pshdr->peer.gid );
 486                 if ( ! path ) {
 487                         /* No path entry - get path record */
 488                         rc = ipoib_get_path_record ( ipoib,
 489                                                      &ipoib_pshdr->peer.gid );
 490                         netdev_tx_complete ( netdev, iobuf );
 491                         return rc;
 492                 }
 493                 av.dest_qp = ntohl ( ipoib_pshdr->peer.qpn );
 494                 av.dlid = path->dlid;
 495                 av.rate = path->rate;
 496                 av.sl = path->sl;
 497                 gid = &ipoib_pshdr->peer.gid;
 498         }
 499         memcpy ( &av.gid, gid, sizeof ( av.gid ) );
 500
 501         return ib_post_send ( ibdev, ipoib->data.qp, &av, iobuf );
 502 }
 503
 504 /**
 505  * Handle IPoIB data send completion
 506  *
 507  * @v ibdev             Infiniband device
 508  * @v qp                Queue pair
 509  * @v completion        Completion
 510  * @v iobuf             I/O buffer
 511  */
 512 static void ipoib_data_complete_send ( struct ib_device *ibdev __unused,
 513                                        struct ib_queue_pair *qp,
 514                                        struct ib_completion *completion,
 515                                        struct io_buffer *iobuf ) {
 516         struct net_device *netdev = ib_qp_get_ownerdata ( qp );
 517
 518         netdev_tx_complete_err ( netdev, iobuf,
 519                                  ( completion->syndrome ? -EIO : 0 ) );
 520 }
 521
 522 /**
 523  * Handle IPoIB data receive completion
 524  *
 525  * @v ibdev             Infiniband device
 526  * @v qp                Queue pair
 527  * @v completion        Completion
 528  * @v iobuf             I/O buffer
 529  */
 530 static void ipoib_data_complete_recv ( struct ib_device *ibdev __unused,
 531                                        struct ib_queue_pair *qp,
 532                                        struct ib_completion *completion,
 533                                        struct io_buffer *iobuf ) {
 534         struct net_device *netdev = ib_qp_get_ownerdata ( qp );
 535         struct ipoib_device *ipoib = netdev->priv;
 536         struct ipoib_pseudo_hdr *ipoib_pshdr;
 537
 538         if ( completion->syndrome ) {
 539                 netdev_rx_err ( netdev, iobuf, -EIO );
 540                 goto done;
 541         }
 542
 543         iob_put ( iobuf, completion->len );
 544         if ( iob_len ( iobuf ) < sizeof ( struct ib_global_route_header ) ) {
 545                 DBGC ( ipoib, "IPoIB %p received data packet too short to "
 546                        "contain GRH\n", ipoib );
 547                 DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
 548                 netdev_rx_err ( netdev, iobuf, -EIO );
 549                 goto done;
 550         }
 551         iob_pull ( iobuf, sizeof ( struct ib_global_route_header ) );
 552
 553         if ( iob_len ( iobuf ) < sizeof ( struct ipoib_real_hdr ) ) {
 554                 DBGC ( ipoib, "IPoIB %p received data packet too short to "
 555                        "contain IPoIB header\n", ipoib );
 556                 DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
 557                 netdev_rx_err ( netdev, iobuf, -EIO );
 558                 goto done;
 559         }
 560
 561         ipoib_pshdr = iob_push ( iobuf, sizeof ( *ipoib_pshdr ) );
 562         /* FIXME: fill in a MAC address for the sake of AoE! */
 563
 564         netdev_rx ( netdev, iobuf );
 565
 566  done:
 567         ipoib->data.recv_fill--;
 568 }
 569
 570 /**
 571  * Handle IPoIB metadata send completion
 572  *
 573  * @v ibdev             Infiniband device
 574  * @v qp                Queue pair
 575  * @v completion        Completion
 576  * @v iobuf             I/O buffer
 577  */
 578 static void ipoib_meta_complete_send ( struct ib_device *ibdev __unused,
 579                                        struct ib_queue_pair *qp,
 580                                        struct ib_completion *completion,
 581                                        struct io_buffer *iobuf ) {
 582         struct net_device *netdev = ib_qp_get_ownerdata ( qp );
 583         struct ipoib_device *ipoib = netdev->priv;
 584
 585         if ( completion->syndrome ) {
 586                 DBGC ( ipoib, "IPoIB %p metadata TX completion error %x\n",
 587                        ipoib, completion->syndrome );
 588         }
 589         free_iob ( iobuf );
 590 }
 591
 592 /**
 593  * Handle received IPoIB path record
 594  *
 595  * @v ipoib             IPoIB device
 596  * @v path_record       Path record
 597  */
 598 static void ipoib_recv_path_record ( struct ipoib_device *ipoib __unused,
 599                                      struct ib_mad_path_record *path_record ) {
 600         struct ipoib_cached_path *path;
 601
 602         /* Update path cache entry */
 603         path = &ipoib_path_cache[ipoib_path_cache_idx];
 604         memcpy ( &path->gid, &path_record->dgid, sizeof ( path->gid ) );
 605         path->dlid = ntohs ( path_record->dlid );
 606         path->sl = ( path_record->reserved__sl & 0x0f );
 607         path->rate = ( path_record->rate_selector__rate & 0x3f );
 608
 609         DBG ( "IPoIB %08lx:%08lx:%08lx:%08lx dlid %x sl %x rate %x\n",
 610               htonl ( path->gid.u.dwords[0] ), htonl ( path->gid.u.dwords[1] ),
 611               htonl ( path->gid.u.dwords[2] ), htonl ( path->gid.u.dwords[3] ),
 612               path->dlid, path->sl, path->rate );
 613
 614         /* Update path cache index */
 615         ipoib_path_cache_idx++;
 616         if ( ipoib_path_cache_idx == IPOIB_NUM_CACHED_PATHS )
 617                 ipoib_path_cache_idx = 0;
 618 }
 619
 620 /**
 621  * Handle received IPoIB multicast membership record
 622  *
 623  * @v ipoib             IPoIB device
 624  * @v mc_member_record  Multicast membership record
 625  */
 626 static void ipoib_recv_mc_member_record ( struct ipoib_device *ipoib,
 627                           struct ib_mad_mc_member_record *mc_member_record ) {
 628         int joined;
 629         int rc;
 630
 631         /* Record parameters */
 632         joined = ( mc_member_record->scope__join_state & 0x0f );
 633         ipoib->data_qkey = ntohl ( mc_member_record->qkey );
 634         ipoib->broadcast_lid = ntohs ( mc_member_record->mlid );
 635         DBGC ( ipoib, "IPoIB %p %s broadcast group: qkey %lx mlid %x\n",
 636                ipoib, ( joined ? "joined" : "left" ), ipoib->data_qkey,
 637                ipoib->broadcast_lid );
 638
 639         /* Update data queue pair qkey */
 640         if ( ( rc = ib_modify_qp ( ipoib->ibdev, ipoib->data.qp,
 641                                    IB_MODIFY_QKEY, ipoib->data_qkey ) ) != 0 ){
 642                 DBGC ( ipoib, "IPoIB %p could not update data qkey: %s\n",
 643                        ipoib, strerror ( rc ) );
 644                 return;
 645         }
 646 }
 647
 648 /**
 649  * Handle IPoIB metadata receive completion
 650  *
 651  * @v ibdev             Infiniband device
 652  * @v qp                Queue pair
 653  * @v completion        Completion
 654  * @v iobuf             I/O buffer
 655  */
 656 static void ipoib_meta_complete_recv ( struct ib_device *ibdev __unused,
 657                                        struct ib_queue_pair *qp,
 658                                        struct ib_completion *completion,
 659                                        struct io_buffer *iobuf ) {
 660         struct net_device *netdev = ib_qp_get_ownerdata ( qp );
 661         struct ipoib_device *ipoib = netdev->priv;
 662         union ib_mad *mad;
 663
 664         if ( completion->syndrome ) {
 665                 DBGC ( ipoib, "IPoIB %p metadata RX completion error %x\n",
 666                        ipoib, completion->syndrome );
 667                 goto done;
 668         }
 669
 670         iob_put ( iobuf, completion->len );
 671         if ( iob_len ( iobuf ) < sizeof ( struct ib_global_route_header ) ) {
 672                 DBGC ( ipoib, "IPoIB %p received metadata packet too short "
 673                        "to contain GRH\n", ipoib );
 674                 DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
 675                 goto done;
 676         }
 677         iob_pull ( iobuf, sizeof ( struct ib_global_route_header ) );
 678         if ( iob_len ( iobuf ) < sizeof ( *mad ) ) {
 679                 DBGC ( ipoib, "IPoIB %p received metadata packet too short "
 680                        "to contain reply\n", ipoib );
 681                 DBGC_HD ( ipoib, iobuf->data, iob_len ( iobuf ) );
 682                 goto done;
 683         }
 684         mad = iobuf->data;
 685
 686         if ( mad->mad_hdr.status != 0 ) {
 687                 DBGC ( ipoib, "IPoIB %p metadata RX err status %04x\n",
 688                        ipoib, ntohs ( mad->mad_hdr.status ) );
 689                 goto done;
 690         }
 691
 692         switch ( mad->mad_hdr.tid[0] ) {
 693         case IPOIB_TID_GET_PATH_REC:
 694                 ipoib_recv_path_record ( ipoib, &mad->path_record );
 695                 break;
 696         case IPOIB_TID_MC_MEMBER_REC:
 697                 ipoib_recv_mc_member_record ( ipoib, &mad->mc_member_record );
 698                 break;
 699         default:
 700                 DBGC ( ipoib, "IPoIB %p unwanted response:\n",
 701                        ipoib );
 702                 DBGC_HD ( ipoib, mad, sizeof ( *mad ) );
 703                 break;
 704         }
 705
 706  done:
 707         ipoib->meta.recv_fill--;
 708         free_iob ( iobuf );
 709 }
 710
 711 /**
 712  * Refill IPoIB receive ring
 713  *
 714  * @v ipoib             IPoIB device
 715  */
 716 static void ipoib_refill_recv ( struct ipoib_device *ipoib,
 717                                 struct ipoib_queue_set *qset ) {
 718         struct ib_device *ibdev = ipoib->ibdev;
 719         struct io_buffer *iobuf;
 720         int rc;
 721
 722         while ( qset->recv_fill < qset->recv_max_fill ) {
 723                 iobuf = alloc_iob ( IPOIB_MTU );
 724                 if ( ! iobuf )
 725                         break;
 726                 if ( ( rc = ib_post_recv ( ibdev, qset->qp, iobuf ) ) != 0 ) {
 727                         free_iob ( iobuf );
 728                         break;
 729                 }
 730                 qset->recv_fill++;
 731         }
 732 }
 733
 734 /**
 735  * Poll IPoIB network device
 736  *
 737  * @v netdev            Network device
 738  */
 739 static void ipoib_poll ( struct net_device *netdev ) {
 740         struct ipoib_device *ipoib = netdev->priv;
 741         struct ib_device *ibdev = ipoib->ibdev;
 742
 743         ib_poll_cq ( ibdev, ipoib->meta.cq, ipoib_meta_complete_send,
 744                      ipoib_meta_complete_recv );
 745         ib_poll_cq ( ibdev, ipoib->data.cq, ipoib_data_complete_send,
 746                      ipoib_data_complete_recv );
 747         ipoib_refill_recv ( ipoib, &ipoib->meta );
 748         ipoib_refill_recv ( ipoib, &ipoib->data );
 749 }
 750
 751 /**
 752  * Enable/disable interrupts on IPoIB network device
 753  *
 754  * @v netdev            Network device
 755  * @v enable            Interrupts should be enabled
 756  */
 757 static void ipoib_irq ( struct net_device *netdev __unused,
 758                         int enable __unused ) {
 759         /* No implementation */
 760 }
 761
 762 /**
 763  * Join IPv4 broadcast multicast group
 764  *
 765  * @v ipoib             IPoIB device
 766  * @ret rc              Return status code
 767  */
 768 static int ipoib_join_broadcast_group ( struct ipoib_device *ipoib ) {
 769         int rc;
 770
 771         /* Sanity check */
 772         if ( ! ipoib->data.qp )
 773                 return 0;
 774
 775         /* Attach data queue to broadcast multicast GID */
 776         assert ( ipoib->broadcast_attached == 0 );
 777         if ( ( rc = ib_mcast_attach ( ipoib->ibdev, ipoib->data.qp,
 778                                       &ipoib->broadcast_gid ) ) != 0 ){
 779                 DBGC ( ipoib, "IPoIB %p could not attach to broadcast GID: "
 780                        "%s\n", ipoib, strerror ( rc ) );
 781                 return rc;
 782         }
 783         ipoib->broadcast_attached = 1;
 784
 785         /* Initiate broadcast group join */
 786         if ( ( rc = ipoib_mc_member_record ( ipoib, &ipoib->broadcast_gid,
 787                                              1 ) ) != 0 ) {
 788                 DBGC ( ipoib, "IPoIB %p could not send broadcast join: %s\n",
 789                        ipoib, strerror ( rc ) );
 790                 return rc;
 791         }
 792
 793         return 0;
 794 }
 795
 796 /**
 797  * Leave IPv4 broadcast multicast group
 798  *
 799  * @v ipoib             IPoIB device
 800  */
 801 static void ipoib_leave_broadcast_group ( struct ipoib_device *ipoib ) {
 802
 803         /* Detach data queue from broadcast multicast GID */
 804         if ( ipoib->broadcast_attached ) {
 805                 assert ( ipoib->data.qp != NULL );
 806                 ib_mcast_detach ( ipoib->ibdev, ipoib->data.qp,
 807                                   &ipoib->broadcast_gid );
 808                 ipoib->broadcast_attached = 0;
 809         }
 810 }
 811
 812 /**
 813  * Open IPoIB network device
 814  *
 815  * @v netdev            Network device
 816  * @ret rc              Return status code
 817  */
 818 static int ipoib_open ( struct net_device *netdev ) {
 819         struct ipoib_device *ipoib = netdev->priv;
 820         struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
 821         int rc;
 822
 823         /* Allocate metadata queue set */
 824         if ( ( rc = ipoib_create_qset ( ipoib, &ipoib->meta,
 825                                         IPOIB_META_NUM_CQES,
 826                                         IPOIB_META_NUM_SEND_WQES,
 827                                         IPOIB_META_NUM_RECV_WQES,
 828                                         IB_GLOBAL_QKEY ) ) != 0 ) {
 829                 DBGC ( ipoib, "IPoIB %p could not allocate metadata QP: %s\n",
 830                        ipoib, strerror ( rc ) );
 831                 goto err_create_meta_qset;
 832         }
 833
 834         /* Allocate data queue set */
 835         if ( ( rc = ipoib_create_qset ( ipoib, &ipoib->data,
 836                                         IPOIB_DATA_NUM_CQES,
 837                                         IPOIB_DATA_NUM_SEND_WQES,
 838                                         IPOIB_DATA_NUM_RECV_WQES,
 839                                         IB_GLOBAL_QKEY ) ) != 0 ) {
 840                 DBGC ( ipoib, "IPoIB %p could not allocate data QP: %s\n",
 841                        ipoib, strerror ( rc ) );
 842                 goto err_create_data_qset;
 843         }
 844
 845         /* Update MAC address with data QPN */
 846         mac->qpn = htonl ( ipoib->data.qp->qpn );
 847
 848         /* Fill receive rings */
 849         ipoib_refill_recv ( ipoib, &ipoib->meta );
 850         ipoib_refill_recv ( ipoib, &ipoib->data );
 851
 852         /* Join broadcast group */
 853         if ( ( rc = ipoib_join_broadcast_group ( ipoib ) ) != 0 ) {
 854                 DBGC ( ipoib, "IPoIB %p could not join broadcast group: %s\n",
 855                        ipoib, strerror ( rc ) );
 856                 goto err_join_broadcast;
 857         }
 858
 859         return 0;
 860
 861  err_join_broadcast:
 862         ipoib_destroy_qset ( ipoib, &ipoib->data );
 863  err_create_data_qset:
 864         ipoib_destroy_qset ( ipoib, &ipoib->meta );
 865  err_create_meta_qset:
 866         return rc;
 867 }
 868
 869 /**
 870  * Close IPoIB network device
 871  *
 872  * @v netdev            Network device
 873  */
 874 static void ipoib_close ( struct net_device *netdev ) {
 875         struct ipoib_device *ipoib = netdev->priv;
 876         struct ipoib_mac *mac = ( ( struct ipoib_mac * ) netdev->ll_addr );
 877
 878         /* Leave broadcast group */
 879         ipoib_leave_broadcast_group ( ipoib );
 880
 881         /* Remove data QPN from MAC address */
 882         mac->qpn = 0;
 883
 884         /* Tear down the queues */
 885         ipoib_destroy_qset ( ipoib, &ipoib->data );
 886         ipoib_destroy_qset ( ipoib, &ipoib->meta );
 887 }
 888
 889 /** IPoIB network device operations */
 890 static struct net_device_operations ipoib_operations = {
 891         .open           = ipoib_open,
 892         .close          = ipoib_close,
 893         .transmit       = ipoib_transmit,
 894         .poll           = ipoib_poll,
 895         .irq            = ipoib_irq,
 896 };
 897
 898 /**
 899  * Update IPoIB dynamic Infiniband parameters
 900  *
 901  * @v ipoib             IPoIB device
 902  *
 903  * The Infiniband port GID and partition key will change at runtime,
 904  * when the link is established (or lost).  The MAC address is based
 905  * on the port GID, and the broadcast GID is based on the partition
 906  * key.  This function recalculates these IPoIB device parameters.
 907  */
 908 static void ipoib_set_ib_params ( struct ipoib_device *ipoib ) {
 909         struct ib_device *ibdev = ipoib->ibdev;
 910         struct ipoib_mac *mac;
 911
 912         /* Calculate GID portion of MAC address based on port GID */
 913         mac = ( ( struct ipoib_mac * ) ipoib->netdev->ll_addr );
 914         memcpy ( &mac->gid, &ibdev->port_gid, sizeof ( mac->gid ) );
 915
 916         /* Calculate broadcast GID based on partition key */
 917         memcpy ( &ipoib->broadcast_gid, &ipv4_broadcast_gid,
 918                  sizeof ( ipoib->broadcast_gid ) );
 919         ipoib->broadcast_gid.u.words[2] = htons ( ibdev->pkey );
 920 }
 921
 922 /**
 923  * Handle link status change
 924  *
 925  * @v ibdev             Infiniband device
 926  */
 927 void ipoib_link_state_changed ( struct ib_device *ibdev ) {
 928         struct net_device *netdev = ib_get_ownerdata ( ibdev );
 929         struct ipoib_device *ipoib = netdev->priv;
 930         int rc;
 931
 932         /* Leave existing broadcast group */
 933         ipoib_leave_broadcast_group ( ipoib );
 934
 935         /* Update MAC address and broadcast GID based on new port GID
 936          * and partition key.
 937          */
 938         ipoib_set_ib_params ( ipoib );
 939
 940         /* Join new broadcast group */
 941         if ( ( rc = ipoib_join_broadcast_group ( ipoib ) ) != 0 ) {
 942                 DBGC ( ipoib, "IPoIB %p could not rejoin broadcast group: "
 943                        "%s\n", ipoib, strerror ( rc ) );
 944                 return;
 945         }
 946 }
 947
 948 /**
 949  * Probe IPoIB device
 950  *
 951  * @v ibdev             Infiniband device
 952  * @ret rc              Return status code
 953  */
 954 int ipoib_probe ( struct ib_device *ibdev ) {
 955         struct net_device *netdev;
 956         struct ipoib_device *ipoib;
 957         int rc;
 958
 959         /* Allocate network device */
 960         netdev = alloc_ipoibdev ( sizeof ( *ipoib ) );
 961         if ( ! netdev )
 962                 return -ENOMEM;
 963         netdev_init ( netdev, &ipoib_operations );
 964         ipoib = netdev->priv;
 965         ib_set_ownerdata ( ibdev, netdev );
 966         netdev->dev = ibdev->dev;
 967         memset ( ipoib, 0, sizeof ( *ipoib ) );
 968         ipoib->netdev = netdev;
 969         ipoib->ibdev = ibdev;
 970
 971         /* Calculate as much of the broadcast GID and the MAC address
 972          * as we can.  We won't know either of these in full until we
 973          * have link-up.
 974          */
 975         ipoib_set_ib_params ( ipoib );
 976
 977         /* Register network device */
 978         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 979                 goto err_register_netdev;
 980
 981         return 0;
 982
 983  err_register_netdev:
 984         netdev_nullify ( netdev );
 985         netdev_put ( netdev );
 986         return rc;
 987 }
 988
 989 /**
 990  * Remove IPoIB device
 991  *
 992  * @v ibdev             Infiniband device
 993  */
 994 void ipoib_remove ( struct ib_device *ibdev ) {
 995         struct net_device *netdev = ib_get_ownerdata ( ibdev );
 996
 997         unregister_netdev ( netdev );
 998         netdev_nullify ( netdev );
 999         netdev_put ( netdev );
1000 }