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