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