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