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