539c529062629a87f030d96dc19e3094d13e059c
[people/oremanj/gpxe.git] / src / net / infiniband.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 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <byteswap.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include <gpxe/list.h>
30 #include <gpxe/if_arp.h>
31 #include <gpxe/netdevice.h>
32 #include <gpxe/iobuf.h>
33 #include <gpxe/ipoib.h>
34 #include <gpxe/process.h>
35 #include <gpxe/infiniband.h>
36 #include <gpxe/ib_mi.h>
37 #include <gpxe/ib_sma.h>
38
39 /** @file
40  *
41  * Infiniband protocol
42  *
43  */
44
45 /** List of Infiniband devices */
46 struct list_head ib_devices = LIST_HEAD_INIT ( ib_devices );
47
48 /***************************************************************************
49  *
50  * Completion queues
51  *
52  ***************************************************************************
53  */
54
55 /**
56  * Create completion queue
57  *
58  * @v ibdev             Infiniband device
59  * @v num_cqes          Number of completion queue entries
60  * @v op                Completion queue operations
61  * @ret cq              New completion queue
62  */
63 struct ib_completion_queue *
64 ib_create_cq ( struct ib_device *ibdev, unsigned int num_cqes,
65                struct ib_completion_queue_operations *op ) {
66         struct ib_completion_queue *cq;
67         int rc;
68
69         DBGC ( ibdev, "IBDEV %p creating completion queue\n", ibdev );
70
71         /* Allocate and initialise data structure */
72         cq = zalloc ( sizeof ( *cq ) );
73         if ( ! cq )
74                 goto err_alloc_cq;
75         cq->ibdev = ibdev;
76         list_add ( &cq->list, &ibdev->cqs );
77         cq->num_cqes = num_cqes;
78         INIT_LIST_HEAD ( &cq->work_queues );
79         cq->op = op;
80
81         /* Perform device-specific initialisation and get CQN */
82         if ( ( rc = ibdev->op->create_cq ( ibdev, cq ) ) != 0 ) {
83                 DBGC ( ibdev, "IBDEV %p could not initialise completion "
84                        "queue: %s\n", ibdev, strerror ( rc ) );
85                 goto err_dev_create_cq;
86         }
87
88         DBGC ( ibdev, "IBDEV %p created %d-entry completion queue %p (%p) "
89                "with CQN %#lx\n", ibdev, num_cqes, cq,
90                ib_cq_get_drvdata ( cq ), cq->cqn );
91         return cq;
92
93         ibdev->op->destroy_cq ( ibdev, cq );
94  err_dev_create_cq:
95         list_del ( &cq->list );
96         free ( cq );
97  err_alloc_cq:
98         return NULL;
99 }
100
101 /**
102  * Destroy completion queue
103  *
104  * @v ibdev             Infiniband device
105  * @v cq                Completion queue
106  */
107 void ib_destroy_cq ( struct ib_device *ibdev,
108                      struct ib_completion_queue *cq ) {
109         DBGC ( ibdev, "IBDEV %p destroying completion queue %#lx\n",
110                ibdev, cq->cqn );
111         assert ( list_empty ( &cq->work_queues ) );
112         ibdev->op->destroy_cq ( ibdev, cq );
113         list_del ( &cq->list );
114         free ( cq );
115 }
116
117 /**
118  * Poll completion queue
119  *
120  * @v ibdev             Infiniband device
121  * @v cq                Completion queue
122  */
123 void ib_poll_cq ( struct ib_device *ibdev,
124                   struct ib_completion_queue *cq ) {
125         struct ib_work_queue *wq;
126
127         /* Poll completion queue */
128         ibdev->op->poll_cq ( ibdev, cq );
129
130         /* Refill receive work queues */
131         list_for_each_entry ( wq, &cq->work_queues, list ) {
132                 if ( ! wq->is_send )
133                         ib_refill_recv ( ibdev, wq->qp );
134         }
135 }
136
137 /***************************************************************************
138  *
139  * Work queues
140  *
141  ***************************************************************************
142  */
143
144 /**
145  * Create queue pair
146  *
147  * @v ibdev             Infiniband device
148  * @v type              Queue pair type
149  * @v num_send_wqes     Number of send work queue entries
150  * @v send_cq           Send completion queue
151  * @v num_recv_wqes     Number of receive work queue entries
152  * @v recv_cq           Receive completion queue
153  * @ret qp              Queue pair
154  *
155  * The queue pair will be left in the INIT state; you must call
156  * ib_modify_qp() before it is ready to use for sending and receiving.
157  */
158 struct ib_queue_pair * ib_create_qp ( struct ib_device *ibdev,
159                                       enum ib_queue_pair_type type,
160                                       unsigned int num_send_wqes,
161                                       struct ib_completion_queue *send_cq,
162                                       unsigned int num_recv_wqes,
163                                       struct ib_completion_queue *recv_cq ) {
164         struct ib_queue_pair *qp;
165         size_t total_size;
166         int rc;
167
168         DBGC ( ibdev, "IBDEV %p creating queue pair\n", ibdev );
169
170         /* Allocate and initialise data structure */
171         total_size = ( sizeof ( *qp ) +
172                        ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) ) +
173                        ( num_recv_wqes * sizeof ( qp->recv.iobufs[0] ) ) );
174         qp = zalloc ( total_size );
175         if ( ! qp )
176                 goto err_alloc_qp;
177         qp->ibdev = ibdev;
178         list_add ( &qp->list, &ibdev->qps );
179         qp->type = type;
180         qp->send.qp = qp;
181         qp->send.is_send = 1;
182         qp->send.cq = send_cq;
183         list_add ( &qp->send.list, &send_cq->work_queues );
184         qp->send.psn = ( random() & 0xffffffUL );
185         qp->send.num_wqes = num_send_wqes;
186         qp->send.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) );
187         qp->recv.qp = qp;
188         qp->recv.cq = recv_cq;
189         list_add ( &qp->recv.list, &recv_cq->work_queues );
190         qp->recv.psn = ( random() & 0xffffffUL );
191         qp->recv.num_wqes = num_recv_wqes;
192         qp->recv.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) +
193                             ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) ));
194         INIT_LIST_HEAD ( &qp->mgids );
195
196         /* Perform device-specific initialisation and get QPN */
197         if ( ( rc = ibdev->op->create_qp ( ibdev, qp ) ) != 0 ) {
198                 DBGC ( ibdev, "IBDEV %p could not initialise queue pair: "
199                        "%s\n", ibdev, strerror ( rc ) );
200                 goto err_dev_create_qp;
201         }
202         DBGC ( ibdev, "IBDEV %p created queue pair %p (%p) with QPN %#lx\n",
203                ibdev, qp, ib_qp_get_drvdata ( qp ), qp->qpn );
204         DBGC ( ibdev, "IBDEV %p QPN %#lx has %d send entries at [%p,%p)\n",
205                ibdev, qp->qpn, num_send_wqes, qp->send.iobufs,
206                qp->recv.iobufs );
207         DBGC ( ibdev, "IBDEV %p QPN %#lx has %d receive entries at [%p,%p)\n",
208                ibdev, qp->qpn, num_recv_wqes, qp->recv.iobufs,
209                ( ( ( void * ) qp ) + total_size ) );
210
211         /* Calculate externally-visible QPN */
212         switch ( type ) {
213         case IB_QPT_SMI:
214                 qp->ext_qpn = IB_QPN_SMI;
215                 break;
216         case IB_QPT_GSI:
217                 qp->ext_qpn = IB_QPN_GSI;
218                 break;
219         default:
220                 qp->ext_qpn = qp->qpn;
221                 break;
222         }
223         if ( qp->ext_qpn != qp->qpn ) {
224                 DBGC ( ibdev, "IBDEV %p QPN %#lx has external QPN %#lx\n",
225                        ibdev, qp->qpn, qp->ext_qpn );
226         }
227
228         return qp;
229
230         ibdev->op->destroy_qp ( ibdev, qp );
231  err_dev_create_qp:
232         list_del ( &qp->send.list );
233         list_del ( &qp->recv.list );
234         list_del ( &qp->list );
235         free ( qp );
236  err_alloc_qp:
237         return NULL;
238 }
239
240 /**
241  * Modify queue pair
242  *
243  * @v ibdev             Infiniband device
244  * @v qp                Queue pair
245  * @v av                New address vector, if applicable
246  * @ret rc              Return status code
247  */
248 int ib_modify_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ) {
249         int rc;
250
251         DBGC ( ibdev, "IBDEV %p modifying QPN %#lx\n", ibdev, qp->qpn );
252
253         if ( ( rc = ibdev->op->modify_qp ( ibdev, qp ) ) != 0 ) {
254                 DBGC ( ibdev, "IBDEV %p could not modify QPN %#lx: %s\n",
255                        ibdev, qp->qpn, strerror ( rc ) );
256                 return rc;
257         }
258
259         return 0;
260 }
261
262 /**
263  * Destroy queue pair
264  *
265  * @v ibdev             Infiniband device
266  * @v qp                Queue pair
267  */
268 void ib_destroy_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ) {
269         struct io_buffer *iobuf;
270         unsigned int i;
271
272         DBGC ( ibdev, "IBDEV %p destroying QPN %#lx\n",
273                ibdev, qp->qpn );
274
275         assert ( list_empty ( &qp->mgids ) );
276
277         /* Perform device-specific destruction */
278         ibdev->op->destroy_qp ( ibdev, qp );
279
280         /* Complete any remaining I/O buffers with errors */
281         for ( i = 0 ; i < qp->send.num_wqes ; i++ ) {
282                 if ( ( iobuf = qp->send.iobufs[i] ) != NULL )
283                         ib_complete_send ( ibdev, qp, iobuf, -ECANCELED );
284         }
285         for ( i = 0 ; i < qp->recv.num_wqes ; i++ ) {
286                 if ( ( iobuf = qp->recv.iobufs[i] ) != NULL ) {
287                         ib_complete_recv ( ibdev, qp, NULL, iobuf,
288                                            -ECANCELED );
289                 }
290         }
291
292         /* Remove work queues from completion queue */
293         list_del ( &qp->send.list );
294         list_del ( &qp->recv.list );
295
296         /* Free QP */
297         list_del ( &qp->list );
298         free ( qp );
299 }
300
301 /**
302  * Find queue pair by QPN
303  *
304  * @v ibdev             Infiniband device
305  * @v qpn               Queue pair number
306  * @ret qp              Queue pair, or NULL
307  */
308 struct ib_queue_pair * ib_find_qp_qpn ( struct ib_device *ibdev,
309                                         unsigned long qpn ) {
310         struct ib_queue_pair *qp;
311
312         list_for_each_entry ( qp, &ibdev->qps, list ) {
313                 if ( ( qpn == qp->qpn ) || ( qpn == qp->ext_qpn ) )
314                         return qp;
315         }
316         return NULL;
317 }
318
319 /**
320  * Find queue pair by multicast GID
321  *
322  * @v ibdev             Infiniband device
323  * @v gid               Multicast GID
324  * @ret qp              Queue pair, or NULL
325  */
326 struct ib_queue_pair * ib_find_qp_mgid ( struct ib_device *ibdev,
327                                          struct ib_gid *gid ) {
328         struct ib_queue_pair *qp;
329         struct ib_multicast_gid *mgid;
330
331         list_for_each_entry ( qp, &ibdev->qps, list ) {
332                 list_for_each_entry ( mgid, &qp->mgids, list ) {
333                         if ( memcmp ( &mgid->gid, gid,
334                                       sizeof ( mgid->gid ) ) == 0 ) {
335                                 return qp;
336                         }
337                 }
338         }
339         return NULL;
340 }
341
342 /**
343  * Find work queue belonging to completion queue
344  *
345  * @v cq                Completion queue
346  * @v qpn               Queue pair number
347  * @v is_send           Find send work queue (rather than receive)
348  * @ret wq              Work queue, or NULL if not found
349  */
350 struct ib_work_queue * ib_find_wq ( struct ib_completion_queue *cq,
351                                     unsigned long qpn, int is_send ) {
352         struct ib_work_queue *wq;
353
354         list_for_each_entry ( wq, &cq->work_queues, list ) {
355                 if ( ( wq->qp->qpn == qpn ) && ( wq->is_send == is_send ) )
356                         return wq;
357         }
358         return NULL;
359 }
360
361 /**
362  * Post send work queue entry
363  *
364  * @v ibdev             Infiniband device
365  * @v qp                Queue pair
366  * @v av                Address vector
367  * @v iobuf             I/O buffer
368  * @ret rc              Return status code
369  */
370 int ib_post_send ( struct ib_device *ibdev, struct ib_queue_pair *qp,
371                    struct ib_address_vector *av,
372                    struct io_buffer *iobuf ) {
373         struct ib_address_vector av_copy;
374         int rc;
375
376         /* Check queue fill level */
377         if ( qp->send.fill >= qp->send.num_wqes ) {
378                 DBGC ( ibdev, "IBDEV %p QPN %#lx send queue full\n",
379                        ibdev, qp->qpn );
380                 return -ENOBUFS;
381         }
382
383         /* Use default address vector if none specified */
384         if ( ! av )
385                 av = &qp->av;
386
387         /* Make modifiable copy of address vector */
388         memcpy ( &av_copy, av, sizeof ( av_copy ) );
389         av = &av_copy;
390
391         /* Fill in optional parameters in address vector */
392         if ( ! av->qkey )
393                 av->qkey = qp->qkey;
394         if ( ! av->rate )
395                 av->rate = IB_RATE_2_5;
396
397         /* Post to hardware */
398         if ( ( rc = ibdev->op->post_send ( ibdev, qp, av, iobuf ) ) != 0 ) {
399                 DBGC ( ibdev, "IBDEV %p QPN %#lx could not post send WQE: "
400                        "%s\n", ibdev, qp->qpn, strerror ( rc ) );
401                 return rc;
402         }
403
404         qp->send.fill++;
405         return 0;
406 }
407
408 /**
409  * Post receive work queue entry
410  *
411  * @v ibdev             Infiniband device
412  * @v qp                Queue pair
413  * @v iobuf             I/O buffer
414  * @ret rc              Return status code
415  */
416 int ib_post_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp,
417                    struct io_buffer *iobuf ) {
418         int rc;
419
420         /* Check packet length */
421         if ( iob_tailroom ( iobuf ) < IB_MAX_PAYLOAD_SIZE ) {
422                 DBGC ( ibdev, "IBDEV %p QPN %#lx wrong RX buffer size (%zd)\n",
423                        ibdev, qp->qpn, iob_tailroom ( iobuf ) );
424                 return -EINVAL;
425         }
426
427         /* Check queue fill level */
428         if ( qp->recv.fill >= qp->recv.num_wqes ) {
429                 DBGC ( ibdev, "IBDEV %p QPN %#lx receive queue full\n",
430                        ibdev, qp->qpn );
431                 return -ENOBUFS;
432         }
433
434         /* Post to hardware */
435         if ( ( rc = ibdev->op->post_recv ( ibdev, qp, iobuf ) ) != 0 ) {
436                 DBGC ( ibdev, "IBDEV %p QPN %#lx could not post receive WQE: "
437                        "%s\n", ibdev, qp->qpn, strerror ( rc ) );
438                 return rc;
439         }
440
441         qp->recv.fill++;
442         return 0;
443 }
444
445 /**
446  * Complete send work queue entry
447  *
448  * @v ibdev             Infiniband device
449  * @v qp                Queue pair
450  * @v iobuf             I/O buffer
451  * @v rc                Completion status code
452  */
453 void ib_complete_send ( struct ib_device *ibdev, struct ib_queue_pair *qp,
454                         struct io_buffer *iobuf, int rc ) {
455
456         if ( qp->send.cq->op->complete_send ) {
457                 qp->send.cq->op->complete_send ( ibdev, qp, iobuf, rc );
458         } else {
459                 free_iob ( iobuf );
460         }
461         qp->send.fill--;
462 }
463
464 /**
465  * Complete receive work queue entry
466  *
467  * @v ibdev             Infiniband device
468  * @v qp                Queue pair
469  * @v av                Address vector
470  * @v iobuf             I/O buffer
471  * @v rc                Completion status code
472  */
473 void ib_complete_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp,
474                         struct ib_address_vector *av,
475                         struct io_buffer *iobuf, int rc ) {
476
477         if ( qp->recv.cq->op->complete_recv ) {
478                 qp->recv.cq->op->complete_recv ( ibdev, qp, av, iobuf, rc );
479         } else {
480                 free_iob ( iobuf );
481         }
482         qp->recv.fill--;
483 }
484
485 /**
486  * Refill receive work queue
487  *
488  * @v ibdev             Infiniband device
489  * @v qp                Queue pair
490  */
491 void ib_refill_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp ) {
492         struct io_buffer *iobuf;
493         int rc;
494
495         /* Keep filling while unfilled entries remain */
496         while ( qp->recv.fill < qp->recv.num_wqes ) {
497
498                 /* Allocate I/O buffer */
499                 iobuf = alloc_iob ( IB_MAX_PAYLOAD_SIZE );
500                 if ( ! iobuf ) {
501                         /* Non-fatal; we will refill on next attempt */
502                         return;
503                 }
504
505                 /* Post I/O buffer */
506                 if ( ( rc = ib_post_recv ( ibdev, qp, iobuf ) ) != 0 ) {
507                         DBGC ( ibdev, "IBDEV %p could not refill: %s\n",
508                                ibdev, strerror ( rc ) );
509                         free_iob ( iobuf );
510                         /* Give up */
511                         return;
512                 }
513         }
514 }
515
516 /***************************************************************************
517  *
518  * Link control
519  *
520  ***************************************************************************
521  */
522
523 /**
524  * Open port
525  *
526  * @v ibdev             Infiniband device
527  * @ret rc              Return status code
528  */
529 int ib_open ( struct ib_device *ibdev ) {
530         int rc;
531
532         /* Increment device open request counter */
533         if ( ibdev->open_count++ > 0 ) {
534                 /* Device was already open; do nothing */
535                 return 0;
536         }
537
538         /* Create subnet management interface */
539         ibdev->smi = ib_create_mi ( ibdev, IB_QPT_SMI );
540         if ( ! ibdev->smi ) {
541                 DBGC ( ibdev, "IBDEV %p could not create SMI\n", ibdev );
542                 rc = -ENOMEM;
543                 goto err_create_smi;
544         }
545
546         /* Create subnet management agent */
547         if ( ( rc = ib_create_sma ( ibdev, ibdev->smi ) ) != 0 ) {
548                 DBGC ( ibdev, "IBDEV %p could not create SMA: %s\n",
549                        ibdev, strerror ( rc ) );
550                 goto err_create_sma;
551         }
552
553         /* Create general services interface */
554         ibdev->gsi = ib_create_mi ( ibdev, IB_QPT_GSI );
555         if ( ! ibdev->gsi ) {
556                 DBGC ( ibdev, "IBDEV %p could not create GSI\n", ibdev );
557                 rc = -ENOMEM;
558                 goto err_create_gsi;
559         }
560
561         /* Open device */
562         if ( ( rc = ibdev->op->open ( ibdev ) ) != 0 ) {
563                 DBGC ( ibdev, "IBDEV %p could not open: %s\n",
564                        ibdev, strerror ( rc ) );
565                 goto err_open;
566         }
567
568         assert ( ibdev->open_count == 1 );
569         return 0;
570
571         ibdev->op->close ( ibdev );
572  err_open:
573         ib_destroy_mi ( ibdev, ibdev->gsi );
574  err_create_gsi:
575         ib_destroy_sma ( ibdev, ibdev->smi );
576  err_create_sma:
577         ib_destroy_mi ( ibdev, ibdev->smi );
578  err_create_smi:
579         assert ( ibdev->open_count == 1 );
580         ibdev->open_count = 0;
581         return rc;
582 }
583
584 /**
585  * Close port
586  *
587  * @v ibdev             Infiniband device
588  */
589 void ib_close ( struct ib_device *ibdev ) {
590
591         /* Decrement device open request counter */
592         ibdev->open_count--;
593
594         /* Close device if this was the last remaining requested opening */
595         if ( ibdev->open_count == 0 ) {
596                 ib_destroy_mi ( ibdev, ibdev->gsi );
597                 ib_destroy_sma ( ibdev, ibdev->smi );
598                 ib_destroy_mi ( ibdev, ibdev->smi );
599                 ibdev->op->close ( ibdev );
600         }
601 }
602
603 /***************************************************************************
604  *
605  * Multicast
606  *
607  ***************************************************************************
608  */
609
610 /**
611  * Attach to multicast group
612  *
613  * @v ibdev             Infiniband device
614  * @v qp                Queue pair
615  * @v gid               Multicast GID
616  * @ret rc              Return status code
617  *
618  * Note that this function handles only the local device's attachment
619  * to the multicast GID; it does not issue the relevant MADs to join
620  * the multicast group on the subnet.
621  */
622 int ib_mcast_attach ( struct ib_device *ibdev, struct ib_queue_pair *qp,
623                       struct ib_gid *gid ) {
624         struct ib_multicast_gid *mgid;
625         int rc;
626
627         /* Add to software multicast GID list */
628         mgid = zalloc ( sizeof ( *mgid ) );
629         if ( ! mgid ) {
630                 rc = -ENOMEM;
631                 goto err_alloc_mgid;
632         }
633         memcpy ( &mgid->gid, gid, sizeof ( mgid->gid ) );
634         list_add ( &mgid->list, &qp->mgids );
635
636         /* Add to hardware multicast GID list */
637         if ( ( rc = ibdev->op->mcast_attach ( ibdev, qp, gid ) ) != 0 )
638                 goto err_dev_mcast_attach;
639
640         return 0;
641
642  err_dev_mcast_attach:
643         list_del ( &mgid->list );
644         free ( mgid );
645  err_alloc_mgid:
646         return rc;
647 }
648
649 /**
650  * Detach from multicast group
651  *
652  * @v ibdev             Infiniband device
653  * @v qp                Queue pair
654  * @v gid               Multicast GID
655  */
656 void ib_mcast_detach ( struct ib_device *ibdev, struct ib_queue_pair *qp,
657                        struct ib_gid *gid ) {
658         struct ib_multicast_gid *mgid;
659
660         /* Remove from hardware multicast GID list */
661         ibdev->op->mcast_detach ( ibdev, qp, gid );
662
663         /* Remove from software multicast GID list */
664         list_for_each_entry ( mgid, &qp->mgids, list ) {
665                 if ( memcmp ( &mgid->gid, gid, sizeof ( mgid->gid ) ) == 0 ) {
666                         list_del ( &mgid->list );
667                         free ( mgid );
668                         break;
669                 }
670         }
671 }
672
673 /***************************************************************************
674  *
675  * Miscellaneous
676  *
677  ***************************************************************************
678  */
679
680 /**
681  * Get Infiniband HCA information
682  *
683  * @v ibdev             Infiniband device
684  * @ret hca_guid        HCA GUID
685  * @ret num_ports       Number of ports
686  */
687 int ib_get_hca_info ( struct ib_device *ibdev,
688                       struct ib_gid_half *hca_guid ) {
689         struct ib_device *tmp;
690         int num_ports = 0;
691
692         /* Search for IB devices with the same physical device to
693          * identify port count and a suitable Node GUID.
694          */
695         for_each_ibdev ( tmp ) {
696                 if ( tmp->dev != ibdev->dev )
697                         continue;
698                 if ( num_ports == 0 ) {
699                         memcpy ( hca_guid, &tmp->gid.u.half[1],
700                                  sizeof ( *hca_guid ) );
701                 }
702                 num_ports++;
703         }
704         return num_ports;
705 }
706
707 /**
708  * Set port information
709  *
710  * @v ibdev             Infiniband device
711  * @v mad               Set port information MAD
712  */
713 int ib_set_port_info ( struct ib_device *ibdev, union ib_mad *mad ) {
714         int rc;
715
716         /* Adapters with embedded SMAs do not need to support this method */
717         if ( ! ibdev->op->set_port_info ) {
718                 DBGC ( ibdev, "IBDEV %p does not support setting port "
719                        "information\n", ibdev );
720                 return -ENOTSUP;
721         }
722
723         if ( ( rc = ibdev->op->set_port_info ( ibdev, mad ) ) != 0 ) {
724                 DBGC ( ibdev, "IBDEV %p could not set port information: %s\n",
725                        ibdev, strerror ( rc ) );
726                 return rc;
727         }
728
729         return 0;
730 };
731
732 /**
733  * Set partition key table
734  *
735  * @v ibdev             Infiniband device
736  * @v mad               Set partition key table MAD
737  */
738 int ib_set_pkey_table ( struct ib_device *ibdev, union ib_mad *mad ) {
739         int rc;
740
741         /* Adapters with embedded SMAs do not need to support this method */
742         if ( ! ibdev->op->set_pkey_table ) {
743                 DBGC ( ibdev, "IBDEV %p does not support setting partition "
744                        "key table\n", ibdev );
745                 return -ENOTSUP;
746         }
747
748         if ( ( rc = ibdev->op->set_pkey_table ( ibdev, mad ) ) != 0 ) {
749                 DBGC ( ibdev, "IBDEV %p could not set partition key table: "
750                        "%s\n", ibdev, strerror ( rc ) );
751                 return rc;
752         }
753
754         return 0;
755 };
756
757 /***************************************************************************
758  *
759  * Event queues
760  *
761  ***************************************************************************
762  */
763
764 /**
765  * Handle Infiniband link state change
766  *
767  * @v ibdev             Infiniband device
768  */
769 void ib_link_state_changed ( struct ib_device *ibdev ) {
770
771         /* Notify IPoIB of link state change */
772         ipoib_link_state_changed ( ibdev );
773 }
774
775 /**
776  * Poll event queue
777  *
778  * @v ibdev             Infiniband device
779  */
780 void ib_poll_eq ( struct ib_device *ibdev ) {
781         struct ib_completion_queue *cq;
782
783         /* Poll device's event queue */
784         ibdev->op->poll_eq ( ibdev );
785
786         /* Poll all completion queues */
787         list_for_each_entry ( cq, &ibdev->cqs, list )
788                 ib_poll_cq ( ibdev, cq );
789 }
790
791 /**
792  * Single-step the Infiniband event queue
793  *
794  * @v process           Infiniband event queue process
795  */
796 static void ib_step ( struct process *process __unused ) {
797         struct ib_device *ibdev;
798
799         for_each_ibdev ( ibdev )
800                 ib_poll_eq ( ibdev );
801 }
802
803 /** Infiniband event queue process */
804 struct process ib_process __permanent_process = {
805         .list = LIST_HEAD_INIT ( ib_process.list ),
806         .step = ib_step,
807 };
808
809 /***************************************************************************
810  *
811  * Infiniband device creation/destruction
812  *
813  ***************************************************************************
814  */
815
816 /**
817  * Allocate Infiniband device
818  *
819  * @v priv_size         Size of driver private data area
820  * @ret ibdev           Infiniband device, or NULL
821  */
822 struct ib_device * alloc_ibdev ( size_t priv_size ) {
823         struct ib_device *ibdev;
824         void *drv_priv;
825         size_t total_len;
826
827         total_len = ( sizeof ( *ibdev ) + priv_size );
828         ibdev = zalloc ( total_len );
829         if ( ibdev ) {
830                 drv_priv = ( ( ( void * ) ibdev ) + sizeof ( *ibdev ) );
831                 ib_set_drvdata ( ibdev, drv_priv );
832                 INIT_LIST_HEAD ( &ibdev->cqs );
833                 INIT_LIST_HEAD ( &ibdev->qps );
834                 ibdev->lid = IB_LID_NONE;
835                 ibdev->pkey = IB_PKEY_NONE;
836         }
837         return ibdev;
838 }
839
840 /**
841  * Register Infiniband device
842  *
843  * @v ibdev             Infiniband device
844  * @ret rc              Return status code
845  */
846 int register_ibdev ( struct ib_device *ibdev ) {
847         int rc;
848
849         /* Add to device list */
850         ibdev_get ( ibdev );
851         list_add_tail ( &ibdev->list, &ib_devices );
852
853         /* Add IPoIB device */
854         if ( ( rc = ipoib_probe ( ibdev ) ) != 0 ) {
855                 DBGC ( ibdev, "IBDEV %p could not add IPoIB device: %s\n",
856                        ibdev, strerror ( rc ) );
857                 goto err_ipoib_probe;
858         }
859
860         DBGC ( ibdev, "IBDEV %p registered (phys %s)\n", ibdev,
861                ibdev->dev->name );
862         return 0;
863
864  err_ipoib_probe:
865         list_del ( &ibdev->list );
866         ibdev_put ( ibdev );
867         return rc;
868 }
869
870 /**
871  * Unregister Infiniband device
872  *
873  * @v ibdev             Infiniband device
874  */
875 void unregister_ibdev ( struct ib_device *ibdev ) {
876
877         /* Close device */
878         ipoib_remove ( ibdev );
879
880         /* Remove from device list */
881         list_del ( &ibdev->list );
882         ibdev_put ( ibdev );
883         DBGC ( ibdev, "IBDEV %p unregistered\n", ibdev );
884 }