[infiniband] Pass address vector in receive completions
[people/mcb30/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 #include <stdint.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <byteswap.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <gpxe/list.h>
28 #include <gpxe/if_arp.h>
29 #include <gpxe/netdevice.h>
30 #include <gpxe/iobuf.h>
31 #include <gpxe/ipoib.h>
32 #include <gpxe/process.h>
33 #include <gpxe/infiniband.h>
34
35 /** @file
36  *
37  * Infiniband protocol
38  *
39  */
40
41 /** List of Infiniband devices */
42 struct list_head ib_devices = LIST_HEAD_INIT ( ib_devices );
43
44 /**
45  * Create completion queue
46  *
47  * @v ibdev             Infiniband device
48  * @v num_cqes          Number of completion queue entries
49  * @v op                Completion queue operations
50  * @ret cq              New completion queue
51  */
52 struct ib_completion_queue *
53 ib_create_cq ( struct ib_device *ibdev, unsigned int num_cqes,
54                struct ib_completion_queue_operations *op ) {
55         struct ib_completion_queue *cq;
56         int rc;
57
58         DBGC ( ibdev, "IBDEV %p creating completion queue\n", ibdev );
59
60         /* Allocate and initialise data structure */
61         cq = zalloc ( sizeof ( *cq ) );
62         if ( ! cq )
63                 return NULL;
64         cq->num_cqes = num_cqes;
65         INIT_LIST_HEAD ( &cq->work_queues );
66         cq->op = op;
67
68         /* Perform device-specific initialisation and get CQN */
69         if ( ( rc = ibdev->op->create_cq ( ibdev, cq ) ) != 0 ) {
70                 DBGC ( ibdev, "IBDEV %p could not initialise completion "
71                        "queue: %s\n", ibdev, strerror ( rc ) );
72                 free ( cq );
73                 return NULL;
74         }
75
76         DBGC ( ibdev, "IBDEV %p created %d-entry completion queue %p (%p) "
77                "with CQN %#lx\n", ibdev, num_cqes, cq,
78                ib_cq_get_drvdata ( cq ), cq->cqn );
79         return cq;
80 }
81
82 /**
83  * Destroy completion queue
84  *
85  * @v ibdev             Infiniband device
86  * @v cq                Completion queue
87  */
88 void ib_destroy_cq ( struct ib_device *ibdev,
89                      struct ib_completion_queue *cq ) {
90         DBGC ( ibdev, "IBDEV %p destroying completion queue %#lx\n",
91                ibdev, cq->cqn );
92         assert ( list_empty ( &cq->work_queues ) );
93         ibdev->op->destroy_cq ( ibdev, cq );
94         free ( cq );
95 }
96
97 /**
98  * Create queue pair
99  *
100  * @v ibdev             Infiniband device
101  * @v num_send_wqes     Number of send work queue entries
102  * @v send_cq           Send completion queue
103  * @v num_recv_wqes     Number of receive work queue entries
104  * @v recv_cq           Receive completion queue
105  * @v qkey              Queue key
106  * @ret qp              Queue pair
107  */
108 struct ib_queue_pair * ib_create_qp ( struct ib_device *ibdev,
109                                       unsigned int num_send_wqes,
110                                       struct ib_completion_queue *send_cq,
111                                       unsigned int num_recv_wqes,
112                                       struct ib_completion_queue *recv_cq,
113                                       unsigned long qkey ) {
114         struct ib_queue_pair *qp;
115         size_t total_size;
116         int rc;
117
118         DBGC ( ibdev, "IBDEV %p creating queue pair\n", ibdev );
119
120         /* Allocate and initialise data structure */
121         total_size = ( sizeof ( *qp ) +
122                        ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) ) +
123                        ( num_recv_wqes * sizeof ( qp->recv.iobufs[0] ) ) );
124         qp = zalloc ( total_size );
125         if ( ! qp )
126                 return NULL;
127         qp->qkey = qkey;
128         qp->send.qp = qp;
129         qp->send.is_send = 1;
130         qp->send.cq = send_cq;
131         list_add ( &qp->send.list, &send_cq->work_queues );
132         qp->send.num_wqes = num_send_wqes;
133         qp->send.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) );
134         qp->recv.qp = qp;
135         qp->recv.cq = recv_cq;
136         list_add ( &qp->recv.list, &recv_cq->work_queues );
137         qp->recv.num_wqes = num_recv_wqes;
138         qp->recv.iobufs = ( ( ( void * ) qp ) + sizeof ( *qp ) +
139                             ( num_send_wqes * sizeof ( qp->send.iobufs[0] ) ));
140
141         /* Perform device-specific initialisation and get QPN */
142         if ( ( rc = ibdev->op->create_qp ( ibdev, qp ) ) != 0 ) {
143                 DBGC ( ibdev, "IBDEV %p could not initialise queue pair: "
144                        "%s\n", ibdev, strerror ( rc ) );
145                 list_del ( &qp->send.list );
146                 list_del ( &qp->recv.list );
147                 free ( qp );
148                 return NULL;
149         }
150
151         DBGC ( ibdev, "IBDEV %p created queue pair %p (%p) with QPN %#lx\n",
152                ibdev, qp, ib_qp_get_drvdata ( qp ), qp->qpn );
153         DBGC ( ibdev, "IBDEV %p QPN %#lx has %d send entries at [%p,%p)\n",
154                ibdev, qp->qpn, num_send_wqes, qp->send.iobufs,
155                qp->recv.iobufs );
156         DBGC ( ibdev, "IBDEV %p QPN %#lx has %d receive entries at [%p,%p)\n",
157                ibdev, qp->qpn, num_recv_wqes, qp->recv.iobufs,
158                ( ( ( void * ) qp ) + total_size ) );
159         return qp;
160 }
161
162 /**
163  * Modify queue pair
164  *
165  * @v ibdev             Infiniband device
166  * @v qp                Queue pair
167  * @v mod_list          Modification list
168  * @v qkey              New queue key, if applicable
169  * @ret rc              Return status code
170  */
171 int ib_modify_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp,
172                    unsigned long mod_list, unsigned long qkey ) {
173         int rc;
174
175         DBGC ( ibdev, "IBDEV %p modifying QPN %#lx\n", ibdev, qp->qpn );
176
177         if ( mod_list & IB_MODIFY_QKEY )
178                 qp->qkey = qkey;
179
180         if ( ( rc = ibdev->op->modify_qp ( ibdev, qp, mod_list ) ) != 0 ) {
181                 DBGC ( ibdev, "IBDEV %p could not modify QPN %#lx: %s\n",
182                        ibdev, qp->qpn, strerror ( rc ) );
183                 return rc;
184         }
185
186         return 0;
187 }
188
189 /**
190  * Destroy queue pair
191  *
192  * @v ibdev             Infiniband device
193  * @v qp                Queue pair
194  */
195 void ib_destroy_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ) {
196         struct io_buffer *iobuf;
197         unsigned int i;
198
199         DBGC ( ibdev, "IBDEV %p destroying QPN %#lx\n",
200                ibdev, qp->qpn );
201
202         /* Perform device-specific destruction */
203         ibdev->op->destroy_qp ( ibdev, qp );
204
205         /* Complete any remaining I/O buffers with errors */
206         for ( i = 0 ; i < qp->send.num_wqes ; i++ ) {
207                 if ( ( iobuf = qp->send.iobufs[i] ) != NULL )
208                         ib_complete_send ( ibdev, qp, iobuf, -ECANCELED );
209         }
210         for ( i = 0 ; i < qp->recv.num_wqes ; i++ ) {
211                 if ( ( iobuf = qp->recv.iobufs[i] ) != NULL ) {
212                         ib_complete_recv ( ibdev, qp, NULL, iobuf,
213                                            -ECANCELED );
214                 }
215         }
216
217         /* Remove work queues from completion queue */
218         list_del ( &qp->send.list );
219         list_del ( &qp->recv.list );
220
221         /* Free QP */
222         free ( qp );
223 }
224
225 /**
226  * Find work queue belonging to completion queue
227  *
228  * @v cq                Completion queue
229  * @v qpn               Queue pair number
230  * @v is_send           Find send work queue (rather than receive)
231  * @ret wq              Work queue, or NULL if not found
232  */
233 struct ib_work_queue * ib_find_wq ( struct ib_completion_queue *cq,
234                                     unsigned long qpn, int is_send ) {
235         struct ib_work_queue *wq;
236
237         list_for_each_entry ( wq, &cq->work_queues, list ) {
238                 if ( ( wq->qp->qpn == qpn ) && ( wq->is_send == is_send ) )
239                         return wq;
240         }
241         return NULL;
242 }
243
244 /**
245  * Post send work queue entry
246  *
247  * @v ibdev             Infiniband device
248  * @v qp                Queue pair
249  * @v av                Address vector
250  * @v iobuf             I/O buffer
251  * @ret rc              Return status code
252  */
253 int ib_post_send ( struct ib_device *ibdev, struct ib_queue_pair *qp,
254                    struct ib_address_vector *av,
255                    struct io_buffer *iobuf ) {
256         int rc;
257
258         /* Check queue fill level */
259         if ( qp->send.fill >= qp->send.num_wqes ) {
260                 DBGC ( ibdev, "IBDEV %p QPN %#lx send queue full\n",
261                        ibdev, qp->qpn );
262                 return -ENOBUFS;
263         }
264
265         /* Post to hardware */
266         if ( ( rc = ibdev->op->post_send ( ibdev, qp, av, iobuf ) ) != 0 ) {
267                 DBGC ( ibdev, "IBDEV %p QPN %#lx could not post send WQE: "
268                        "%s\n", ibdev, qp->qpn, strerror ( rc ) );
269                 return rc;
270         }
271
272         qp->send.fill++;
273         return 0;
274 }
275
276 /**
277  * Post receive work queue entry
278  *
279  * @v ibdev             Infiniband device
280  * @v qp                Queue pair
281  * @v iobuf             I/O buffer
282  * @ret rc              Return status code
283  */
284 int ib_post_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp,
285                    struct io_buffer *iobuf ) {
286         int rc;
287
288         /* Check queue fill level */
289         if ( qp->recv.fill >= qp->recv.num_wqes ) {
290                 DBGC ( ibdev, "IBDEV %p QPN %#lx receive queue full\n",
291                        ibdev, qp->qpn );
292                 return -ENOBUFS;
293         }
294
295         /* Post to hardware */
296         if ( ( rc = ibdev->op->post_recv ( ibdev, qp, iobuf ) ) != 0 ) {
297                 DBGC ( ibdev, "IBDEV %p QPN %#lx could not post receive WQE: "
298                        "%s\n", ibdev, qp->qpn, strerror ( rc ) );
299                 return rc;
300         }
301
302         qp->recv.fill++;
303         return 0;
304 }
305
306 /**
307  * Complete send work queue entry
308  *
309  * @v ibdev             Infiniband device
310  * @v qp                Queue pair
311  * @v iobuf             I/O buffer
312  * @v rc                Completion status code
313  */
314 void ib_complete_send ( struct ib_device *ibdev, struct ib_queue_pair *qp,
315                         struct io_buffer *iobuf, int rc ) {
316         qp->send.cq->op->complete_send ( ibdev, qp, iobuf, rc );
317         qp->send.fill--;
318 }
319
320 /**
321  * Complete receive work queue entry
322  *
323  * @v ibdev             Infiniband device
324  * @v qp                Queue pair
325  * @v av                Address vector
326  * @v iobuf             I/O buffer
327  * @v rc                Completion status code
328  */
329 void ib_complete_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp,
330                         struct ib_address_vector *av,
331                         struct io_buffer *iobuf, int rc ) {
332         qp->recv.cq->op->complete_recv ( ibdev, qp, av, iobuf, rc );
333         qp->recv.fill--;
334 }
335
336 /***************************************************************************
337  *
338  * Management datagram operations
339  *
340  ***************************************************************************
341  */
342
343 /**
344  * Get port information
345  *
346  * @v ibdev             Infiniband device
347  * @v port_info         Port information datagram to fill in
348  * @ret rc              Return status code
349  */
350 static int ib_get_port_info ( struct ib_device *ibdev,
351                               struct ib_mad_port_info *port_info ) {
352         struct ib_mad_hdr *hdr = &port_info->mad_hdr;
353         int rc;
354
355         /* Construct MAD */
356         memset ( port_info, 0, sizeof ( *port_info ) );
357         hdr->base_version = IB_MGMT_BASE_VERSION;
358         hdr->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
359         hdr->class_version = 1;
360         hdr->method = IB_MGMT_METHOD_GET;
361         hdr->attr_id = htons ( IB_SMP_ATTR_PORT_INFO );
362         hdr->attr_mod = htonl ( ibdev->port );
363
364         if ( ( rc = ib_mad ( ibdev, hdr, sizeof ( *port_info ) ) ) != 0 ) {
365                 DBGC ( ibdev, "IBDEV %p could not get port info: %s\n",
366                        ibdev, strerror ( rc ) );
367                 return rc;
368         }
369         return 0;
370 }
371
372 /**
373  * Get GUID information
374  *
375  * @v ibdev             Infiniband device
376  * @v guid_info         GUID information datagram to fill in
377  * @ret rc              Return status code
378  */
379 static int ib_get_guid_info ( struct ib_device *ibdev,
380                               struct ib_mad_guid_info *guid_info ) {
381         struct ib_mad_hdr *hdr = &guid_info->mad_hdr;
382         int rc;
383
384         /* Construct MAD */
385         memset ( guid_info, 0, sizeof ( *guid_info ) );
386         hdr->base_version = IB_MGMT_BASE_VERSION;
387         hdr->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
388         hdr->class_version = 1;
389         hdr->method = IB_MGMT_METHOD_GET;
390         hdr->attr_id = htons ( IB_SMP_ATTR_GUID_INFO );
391
392         if ( ( rc = ib_mad ( ibdev, hdr, sizeof ( *guid_info ) ) ) != 0 ) {
393                 DBGC ( ibdev, "IBDEV %p could not get GUID info: %s\n",
394                        ibdev, strerror ( rc ) );
395                 return rc;
396         }
397         return 0;
398 }
399
400 /**
401  * Get partition key table
402  *
403  * @v ibdev             Infiniband device
404  * @v guid_info         Partition key table datagram to fill in
405  * @ret rc              Return status code
406  */
407 static int ib_get_pkey_table ( struct ib_device *ibdev,
408                                struct ib_mad_pkey_table *pkey_table ) {
409         struct ib_mad_hdr *hdr = &pkey_table->mad_hdr;
410         int rc;
411
412         /* Construct MAD */
413         memset ( pkey_table, 0, sizeof ( *pkey_table ) );
414         hdr->base_version = IB_MGMT_BASE_VERSION;
415         hdr->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
416         hdr->class_version = 1;
417         hdr->method = IB_MGMT_METHOD_GET;
418         hdr->attr_id = htons ( IB_SMP_ATTR_PKEY_TABLE );
419
420         if ( ( rc = ib_mad ( ibdev, hdr, sizeof ( *pkey_table ) ) ) != 0 ) {
421                 DBGC ( ibdev, "IBDEV %p could not get pkey table: %s\n",
422                        ibdev, strerror ( rc ) );
423                 return rc;
424         }
425         return 0;
426 }
427
428 /**
429  * Get MAD parameters
430  *
431  * @v ibdev             Infiniband device
432  * @ret rc              Return status code
433  */
434 static int ib_get_mad_params ( struct ib_device *ibdev ) {
435         union {
436                 /* This union exists just to save stack space */
437                 struct ib_mad_port_info port_info;
438                 struct ib_mad_guid_info guid_info;
439                 struct ib_mad_pkey_table pkey_table;
440         } u;
441         int rc;
442
443         /* Port info gives us the link state, the first half of the
444          * port GID and the SM LID.
445          */
446         if ( ( rc = ib_get_port_info ( ibdev, &u.port_info ) ) != 0 )
447                 return rc;
448         ibdev->link_up = ( ( u.port_info.port_state__link_speed_supported
449                              & 0xf ) == 4 );
450         memcpy ( &ibdev->port_gid.u.bytes[0], u.port_info.gid_prefix, 8 );
451         ibdev->sm_lid = ntohs ( u.port_info.mastersm_lid );
452
453         /* GUID info gives us the second half of the port GID */
454         if ( ( rc = ib_get_guid_info ( ibdev, &u.guid_info ) ) != 0 )
455                 return rc;
456         memcpy ( &ibdev->port_gid.u.bytes[8], u.guid_info.gid_local, 8 );
457
458         /* Get partition key */
459         if ( ( rc = ib_get_pkey_table ( ibdev, &u.pkey_table ) ) != 0 )
460                 return rc;
461         ibdev->pkey = ntohs ( u.pkey_table.pkey[0][0] );
462
463         DBGC ( ibdev, "IBDEV %p port GID is %08lx:%08lx:%08lx:%08lx\n",
464                ibdev, htonl ( ibdev->port_gid.u.dwords[0] ),
465                htonl ( ibdev->port_gid.u.dwords[1] ),
466                htonl ( ibdev->port_gid.u.dwords[2] ),
467                htonl ( ibdev->port_gid.u.dwords[3] ) );
468
469         return 0;
470 }
471
472 /***************************************************************************
473  *
474  * Event queues
475  *
476  ***************************************************************************
477  */
478
479 /**
480  * Handle Infiniband link state change
481  *
482  * @v ibdev             Infiniband device
483  */
484 void ib_link_state_changed ( struct ib_device *ibdev ) {
485         int rc;
486
487         /* Update MAD parameters */
488         if ( ( rc = ib_get_mad_params ( ibdev ) ) != 0 ) {
489                 DBGC ( ibdev, "IBDEV %p could not update MAD parameters: %s\n",
490                        ibdev, strerror ( rc ) );
491                 return;
492         }
493
494         /* Notify IPoIB of link state change */
495         ipoib_link_state_changed ( ibdev );
496 }
497
498 /**
499  * Single-step the Infiniband event queue
500  *
501  * @v process           Infiniband event queue process
502  */
503 static void ib_step ( struct process *process __unused ) {
504         struct ib_device *ibdev;
505
506         list_for_each_entry ( ibdev, &ib_devices, list ) {
507                 ibdev->op->poll_eq ( ibdev );
508         }
509 }
510
511 /** Infiniband event queue process */
512 struct process ib_process __permanent_process = {
513         .step = ib_step,
514 };
515
516 /***************************************************************************
517  *
518  * Infiniband device creation/destruction
519  *
520  ***************************************************************************
521  */
522
523 /**
524  * Allocate Infiniband device
525  *
526  * @v priv_size         Size of driver private data area
527  * @ret ibdev           Infiniband device, or NULL
528  */
529 struct ib_device * alloc_ibdev ( size_t priv_size ) {
530         struct ib_device *ibdev;
531         void *drv_priv;
532         size_t total_len;
533
534         total_len = ( sizeof ( *ibdev ) + priv_size );
535         ibdev = zalloc ( total_len );
536         if ( ibdev ) {
537                 drv_priv = ( ( ( void * ) ibdev ) + sizeof ( *ibdev ) );
538                 ib_set_drvdata ( ibdev, drv_priv );
539         }
540         return ibdev;
541 }
542
543 /**
544  * Register Infiniband device
545  *
546  * @v ibdev             Infiniband device
547  * @ret rc              Return status code
548  */
549 int register_ibdev ( struct ib_device *ibdev ) {
550         int rc;
551
552         /* Add to device list */
553         ibdev_get ( ibdev );
554         list_add_tail ( &ibdev->list, &ib_devices );
555
556         /* Open link */
557         if ( ( rc = ib_open ( ibdev ) ) != 0 )
558                 goto err_open;
559
560         /* Get MAD parameters */
561         if ( ( rc = ib_get_mad_params ( ibdev ) ) != 0 )
562                 goto err_get_mad_params;
563
564         /* Add IPoIB device */
565         if ( ( rc = ipoib_probe ( ibdev ) ) != 0 ) {
566                 DBGC ( ibdev, "IBDEV %p could not add IPoIB device: %s\n",
567                        ibdev, strerror ( rc ) );
568                 goto err_ipoib_probe;
569         }
570
571         DBGC ( ibdev, "IBDEV %p registered (phys %s)\n", ibdev,
572                ibdev->dev->name );
573         return 0;
574
575  err_ipoib_probe:
576  err_get_mad_params:
577         ib_close ( ibdev );
578  err_open:
579         list_del ( &ibdev->list );
580         ibdev_put ( ibdev );
581         return rc;
582 }
583
584 /**
585  * Unregister Infiniband device
586  *
587  * @v ibdev             Infiniband device
588  */
589 void unregister_ibdev ( struct ib_device *ibdev ) {
590
591         /* Close device */
592         ipoib_remove ( ibdev );
593         ib_close ( ibdev );
594
595         /* Remove from device list */
596         list_del ( &ibdev->list );
597         ibdev_put ( ibdev );
598         DBGC ( ibdev, "IBDEV %p unregistered\n", ibdev );
599 }