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