[infiniband] Move non-driver-specific code to net/infiniband
[people/lynusvaz/gpxe.git] / src / net / infiniband / ib_sma.c
1 /*
2  * Copyright (C) 2008 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 <string.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <unistd.h>
27 #include <byteswap.h>
28 #include <gpxe/infiniband.h>
29 #include <gpxe/iobuf.h>
30 #include <gpxe/process.h>
31 #include <gpxe/ib_sma.h>
32
33 /**
34  * @file
35  *
36  * Infiniband Subnet Management Agent
37  *
38  */
39
40 /**
41  * Get node information
42  *
43  * @v sma               Subnet management agent
44  * @v get               Attribute to get
45  */
46 static void ib_sma_get_node_info ( struct ib_sma *sma,
47                                    union ib_smp_data *get ) {
48         struct ib_device *ibdev = sma->ibdev;
49         struct ib_node_info *node_info = &get->node_info;
50         struct ib_device *tmp;
51
52         memset ( node_info, 0, sizeof ( *node_info ) );
53         node_info->base_version = IB_MGMT_BASE_VERSION;
54         node_info->class_version = IB_SMP_CLASS_VERSION;
55         node_info->node_type = IB_NODE_TYPE_HCA;
56         /* Search for IB devices with the same physical device to
57          * identify port count and a suitable Node GUID.
58          */
59         for_each_ibdev ( tmp ) {
60                 if ( tmp->dev != ibdev->dev )
61                         continue;
62                 if ( node_info->num_ports == 0 ) {
63                         memcpy ( node_info->sys_guid, &tmp->gid.u.half[1],
64                                  sizeof ( node_info->sys_guid ) );
65                         memcpy ( node_info->node_guid, &tmp->gid.u.half[1],
66                                  sizeof ( node_info->node_guid ) );
67                 }
68                 node_info->num_ports++;
69         }
70         memcpy ( node_info->port_guid, &ibdev->gid.u.half[1],
71                  sizeof ( node_info->port_guid ) );
72         node_info->partition_cap = htons ( 1 );
73         node_info->local_port_num = ibdev->port;
74 }
75
76 /**
77  * Get node description
78  *
79  * @v sma               Subnet management agent
80  * @v get               Attribute to get
81  */
82 static void ib_sma_get_node_desc ( struct ib_sma *sma,
83                                    union ib_smp_data *get ) {
84         struct ib_device *ibdev = sma->ibdev;
85         struct ib_node_desc *node_desc = &get->node_desc;
86         struct ib_gid_half *guid = &ibdev->gid.u.half[1];
87
88         memset ( node_desc, 0, sizeof ( *node_desc ) );
89         snprintf ( node_desc->node_string, sizeof ( node_desc->node_string ),
90                    "gPXE %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x (%s)",
91                    guid->bytes[0], guid->bytes[1], guid->bytes[2],
92                    guid->bytes[3], guid->bytes[4], guid->bytes[5],
93                    guid->bytes[6], guid->bytes[7], ibdev->dev->name );
94 }
95
96 /**
97  * Get GUID information
98  *
99  * @v sma               Subnet management agent
100  * @v get               Attribute to get
101  */
102 static void ib_sma_get_guid_info ( struct ib_sma *sma,
103                                    union ib_smp_data *get ) {
104         struct ib_device *ibdev = sma->ibdev;
105         struct ib_guid_info *guid_info = &get->guid_info;
106
107         memset ( guid_info, 0, sizeof ( *guid_info ) );
108         memcpy ( guid_info->guid[0], &ibdev->gid.u.half[1],
109                  sizeof ( guid_info->guid[0] ) );
110 }
111
112 /**
113  * Get port information
114  *
115  * @v sma               Subnet management agent
116  * @v get               Attribute to get
117  */
118 static void ib_sma_get_port_info ( struct ib_sma *sma,
119                                    union ib_smp_data *get ) {
120         struct ib_device *ibdev = sma->ibdev;
121         struct ib_port_info *port_info = &get->port_info;
122
123         memset ( port_info, 0, sizeof ( *port_info ) );
124         memcpy ( port_info->gid_prefix, &ibdev->gid.u.half[0],
125                  sizeof ( port_info->gid_prefix ) );
126         port_info->lid = ntohs ( ibdev->lid );
127         port_info->mastersm_lid = ntohs ( ibdev->sm_lid );
128         port_info->local_port_num = ibdev->port;
129         port_info->link_width_enabled = ibdev->link_width;
130         port_info->link_width_supported = ibdev->link_width;
131         port_info->link_width_active = ibdev->link_width;
132         port_info->link_speed_supported__port_state =
133                 ( ( ibdev->link_speed << 4 ) | ibdev->port_state );
134         port_info->port_phys_state__link_down_def_state =
135                 ( ( IB_PORT_PHYS_STATE_POLLING << 4 ) |
136                   IB_PORT_PHYS_STATE_POLLING );
137         port_info->link_speed_active__link_speed_enabled =
138                 ( ( ibdev->link_speed << 4 ) | ibdev->link_speed );
139         port_info->neighbour_mtu__mastersm_sl =
140                 ( ( IB_MTU_2048 << 4 ) | ibdev->sm_sl );
141         port_info->vl_cap__init_type = ( IB_VL_0 << 4 );
142         port_info->init_type_reply__mtu_cap = IB_MTU_2048;
143         port_info->operational_vls__enforcement = ( IB_VL_0 << 4 );
144         port_info->guid_cap = 1;
145 }
146
147 /**
148  * Set port information
149  *
150  * @v sma               Subnet management agent
151  * @v set               Attribute to set
152  * @ret rc              Return status code
153  */
154 static int ib_sma_set_port_info ( struct ib_sma *sma,
155                                   const union ib_smp_data *set ) {
156         struct ib_device *ibdev = sma->ibdev;
157         const struct ib_port_info *port_info = &set->port_info;
158
159         memcpy ( &ibdev->gid.u.half[0], port_info->gid_prefix,
160                  sizeof ( ibdev->gid.u.half[0] ) );
161         ibdev->lid = ntohs ( port_info->lid );
162         ibdev->sm_lid = ntohs ( port_info->mastersm_lid );
163         ibdev->sm_sl = ( port_info->neighbour_mtu__mastersm_sl & 0xf );
164
165         if ( ! sma->op->set_port_info ) {
166                 /* Not an error; we just ignore all other settings */
167                 return 0;
168         }
169
170         return sma->op->set_port_info ( ibdev, port_info );
171 }
172
173 /**
174  * Get partition key table
175  *
176  * @v sma               Subnet management agent
177  * @v get               Attribute to get
178  */
179 static void ib_sma_get_pkey_table ( struct ib_sma *sma,
180                                     union ib_smp_data *get ) {
181         struct ib_device *ibdev = sma->ibdev;
182         struct ib_pkey_table *pkey_table = &get->pkey_table;
183
184         memset ( pkey_table, 0, sizeof ( *pkey_table ) );
185         pkey_table->pkey[0] = htons ( ibdev->pkey );
186 }
187
188 /**
189  * Set partition key table
190  *
191  * @v sma               Subnet management agent
192  * @v set               Attribute to set
193  */
194 static int ib_sma_set_pkey_table ( struct ib_sma *sma,
195                                    const union ib_smp_data *get ) {
196         struct ib_device *ibdev = sma->ibdev;
197         const struct ib_pkey_table *pkey_table = &get->pkey_table;
198
199         ibdev->pkey = ntohs ( pkey_table->pkey[0] );
200         return 0;
201 }
202
203 /** An attribute handler */
204 struct ib_sma_handler {
205         /** Attribute (in network byte order) */
206         uint16_t attr_id;
207         /** Get attribute
208          *
209          * @v sma       Subnet management agent
210          * @v get       Attribute to get
211          * @ret rc      Return status code
212          */
213         void ( * get ) ( struct ib_sma *sma, union ib_smp_data *get );
214         /** Set attribute
215          *
216          * @v sma       Subnet management agent
217          * @v set       Attribute to set
218          * @ret rc      Return status code
219          */
220         int ( * set ) ( struct ib_sma *sma, const union ib_smp_data *set );
221 };
222
223 /** List of attribute handlers */
224 static struct ib_sma_handler ib_sma_handlers[] = {
225         { htons ( IB_SMP_ATTR_NODE_DESC ),
226           ib_sma_get_node_desc, NULL },
227         { htons ( IB_SMP_ATTR_NODE_INFO ),
228           ib_sma_get_node_info, NULL },
229         { htons ( IB_SMP_ATTR_GUID_INFO ),
230           ib_sma_get_guid_info, NULL },
231         { htons ( IB_SMP_ATTR_PORT_INFO ),
232           ib_sma_get_port_info, ib_sma_set_port_info },
233         { htons ( IB_SMP_ATTR_PKEY_TABLE ),
234           ib_sma_get_pkey_table, ib_sma_set_pkey_table },
235 };
236
237 /**
238  * Identify attribute handler
239  *
240  * @v attr_id           Attribute ID (in network byte order)
241  * @ret handler         Attribute handler (or NULL)
242  */
243 static struct ib_sma_handler * ib_sma_handler ( uint16_t attr_id ) {
244         struct ib_sma_handler *handler;
245         unsigned int i;
246
247         for ( i = 0 ; i < ( sizeof ( ib_sma_handlers ) /
248                             sizeof ( ib_sma_handlers[0] ) ) ; i++ ) {
249                 handler = &ib_sma_handlers[i];
250                 if ( handler->attr_id == attr_id )
251                         return handler;
252         }
253
254         return NULL;
255 }
256
257 /**
258  * Respond to management datagram
259  *
260  * @v sma               Subnet management agent
261  * @v mad               Management datagram
262  * @ret rc              Return status code
263  */
264 static int ib_sma_mad ( struct ib_sma *sma, union ib_mad *mad ) {
265         struct ib_device *ibdev = sma->ibdev;
266         struct ib_mad_hdr *hdr = &mad->hdr;
267         struct ib_mad_smp *smp = &mad->smp;
268         struct ib_sma_handler *handler = NULL;
269         unsigned int hop_pointer;
270         unsigned int hop_count;
271         int rc;
272
273         DBGC ( sma, "SMA %p received SMP with bv=%02x mc=%02x cv=%02x "
274                "meth=%02x attr=%04x mod=%08x\n", sma, hdr->base_version,
275                hdr->mgmt_class, hdr->class_version, hdr->method,
276                ntohs ( hdr->attr_id ), ntohl ( hdr->attr_mod ) );
277         DBGC2_HDA ( sma, 0, mad, sizeof ( *mad ) );
278
279         /* Sanity checks */
280         if ( hdr->base_version != IB_MGMT_BASE_VERSION ) {
281                 DBGC ( sma, "SMA %p unsupported base version %x\n",
282                        sma, hdr->base_version );
283                 return -ENOTSUP;
284         }
285         if ( ( hdr->mgmt_class != IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE ) &&
286              ( hdr->mgmt_class != IB_MGMT_CLASS_SUBN_LID_ROUTED ) ) {
287                 DBGC ( sma, "SMA %p unsupported management class %x\n",
288                        sma, hdr->mgmt_class );
289                 return -ENOTSUP;
290         }
291         if ( hdr->class_version != IB_SMP_CLASS_VERSION ) {
292                 DBGC ( sma, "SMA %p unsupported class version %x\n",
293                        sma, hdr->class_version );
294                 return -ENOTSUP;
295         }
296         if ( ( hdr->method != IB_MGMT_METHOD_GET ) &&
297              ( hdr->method != IB_MGMT_METHOD_SET ) ) {
298                 DBGC ( sma, "SMA %p unsupported method %x\n",
299                        sma, hdr->method );
300                 return -ENOTSUP;
301         }
302
303         /* Identify handler */
304         if ( ! ( handler = ib_sma_handler ( hdr->attr_id ) ) ) {
305                 DBGC ( sma, "SMA %p unsupported attribute %x\n",
306                        sma, ntohs ( hdr->attr_id ) );
307                 hdr->status = htons ( IB_MGMT_STATUS_UNSUPPORTED_METHOD_ATTR );
308                 goto respond_without_data;
309         }
310
311         /* Set attribute (if applicable) */
312         if ( hdr->method != IB_MGMT_METHOD_SET ) {
313                 hdr->status = htons ( IB_MGMT_STATUS_OK );
314                 goto respond;
315         }
316         if ( ! handler->set ) {
317                 DBGC ( sma, "SMA %p attribute %x is unsettable\n",
318                        sma, ntohs ( hdr->attr_id ) );
319                 hdr->status = htons ( IB_MGMT_STATUS_UNSUPPORTED_METHOD_ATTR );
320                 goto respond;
321         }
322         if ( ( rc = handler->set ( sma, &smp->smp_data ) ) != 0 ) {
323                 DBGC ( sma, "SMA %p could not set attribute %x: %s\n",
324                        sma, ntohs ( hdr->attr_id ), strerror ( rc ) );
325                 hdr->status = htons ( IB_MGMT_STATUS_UNSUPPORTED_METHOD_ATTR );
326                 goto respond;
327         }
328
329         hdr->status = htons ( IB_MGMT_STATUS_OK );
330
331  respond:
332         /* Get attribute */
333         handler->get ( sma, &smp->smp_data );
334
335  respond_without_data:
336
337         /* Set method to "Get Response" */
338         hdr->method = IB_MGMT_METHOD_GET_RESP;
339
340         /* Set response fields for directed route SMPs */
341         if ( hdr->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE ) {
342                 hdr->status |= htons ( IB_SMP_STATUS_D_INBOUND );
343                 hop_pointer = smp->mad_hdr.class_specific.smp.hop_pointer;
344                 hop_count = smp->mad_hdr.class_specific.smp.hop_count;
345                 assert ( hop_count == hop_pointer );
346                 if ( hop_pointer < ( sizeof ( smp->return_path.hops ) /
347                                      sizeof ( smp->return_path.hops[0] ) ) ) {
348                         smp->return_path.hops[hop_pointer] = ibdev->port;
349                 } else {
350                         DBGC ( sma, "SMA %p invalid hop pointer %d\n",
351                                sma, hop_pointer );
352                         return -EINVAL;
353                 }
354         }
355
356         DBGC ( sma, "SMA %p responding with status=%04x\n",
357                sma, ntohs ( hdr->status ) );
358         DBGC2_HDA ( sma, 0, mad, sizeof ( *mad ) );
359
360         return 0;
361 }
362
363 /**
364  * Refill SMA receive ring
365  *
366  * @v sma               Subnet management agent
367  */
368 static void ib_sma_refill_recv ( struct ib_sma *sma ) {
369         struct ib_device *ibdev = sma->ibdev;
370         struct io_buffer *iobuf;
371         int rc;
372
373         while ( sma->qp->recv.fill < IB_SMA_NUM_RECV_WQES ) {
374
375                 /* Allocate I/O buffer */
376                 iobuf = alloc_iob ( IB_SMA_PAYLOAD_LEN );
377                 if ( ! iobuf ) {
378                         /* Non-fatal; we will refill on next attempt */
379                         return;
380                 }
381
382                 /* Post I/O buffer */
383                 if ( ( rc = ib_post_recv ( ibdev, sma->qp, iobuf ) ) != 0 ) {
384                         DBGC ( sma, "SMA %p could not refill: %s\n",
385                                sma, strerror ( rc ) );
386                         free_iob ( iobuf );
387                         /* Give up */
388                         return;
389                 }
390         }
391 }
392
393 /**
394  * Complete SMA send
395  *
396  *
397  * @v ibdev             Infiniband device
398  * @v qp                Queue pair
399  * @v iobuf             I/O buffer
400  * @v rc                Completion status code
401  */
402 static void ib_sma_complete_send ( struct ib_device *ibdev __unused,
403                                    struct ib_queue_pair *qp,
404                                    struct io_buffer *iobuf, int rc ) {
405         struct ib_sma *sma = ib_qp_get_ownerdata ( qp );
406
407         if ( rc != 0 ) {
408                 DBGC ( sma, "SMA %p send completion error: %s\n",
409                        sma, strerror ( rc ) );
410         }
411         free_iob ( iobuf );
412 }
413
414 /**
415  * Complete SMA receive
416  *
417  *
418  * @v ibdev             Infiniband device
419  * @v qp                Queue pair
420  * @v av                Address vector
421  * @v iobuf             I/O buffer
422  * @v rc                Completion status code
423  */
424 static void ib_sma_complete_recv ( struct ib_device *ibdev,
425                                    struct ib_queue_pair *qp,
426                                    struct ib_address_vector *av,
427                                    struct io_buffer *iobuf, int rc ) {
428         struct ib_sma *sma = ib_qp_get_ownerdata ( qp );
429         union ib_mad *mad;
430
431         /* Ignore errors */
432         if ( rc != 0 ) {
433                 DBGC ( sma, "SMA %p RX error: %s\n", sma, strerror ( rc ) );
434                 goto err;
435         }
436
437         /* Sanity check */
438         if ( iob_len ( iobuf ) != sizeof ( *mad ) ) {
439                 DBGC ( sma, "SMA %p RX bad size (%zd bytes)\n",
440                        sma, iob_len ( iobuf ) );
441                 goto err;
442         }
443         mad = iobuf->data;
444
445         /* Construct MAD response */
446         if ( ( rc = ib_sma_mad ( sma, mad ) ) != 0 ) {
447                 DBGC ( sma, "SMA %p could not construct MAD response: %s\n",
448                        sma, strerror ( rc ) );
449                 goto err;
450         }
451
452         /* Send MAD response */
453         if ( ( rc = ib_post_send ( ibdev, qp, av, iobuf ) ) != 0 ) {
454                 DBGC ( sma, "SMA %p could not send MAD response: %s\n",
455                        sma, strerror ( rc ) );
456                 goto err;
457         }
458
459         return;
460
461  err:
462         free_iob ( iobuf );
463 }
464
465 /** SMA completion operations */
466 static struct ib_completion_queue_operations ib_sma_completion_ops = {
467         .complete_send = ib_sma_complete_send,
468         .complete_recv = ib_sma_complete_recv,
469 };
470
471 /**
472  * Poll SMA
473  *
474  * @v process           Process
475  */
476 static void ib_sma_step ( struct process *process ) {
477         struct ib_sma *sma =
478                 container_of ( process, struct ib_sma, poll );
479         struct ib_device *ibdev = sma->ibdev;
480
481         /* Poll the kernel completion queue */
482         ib_poll_cq ( ibdev, sma->cq );
483
484         /* Refill the receive ring */
485         ib_sma_refill_recv ( sma );
486 }
487
488 /**
489  * Create SMA
490  *
491  * @v sma               Subnet management agent
492  * @v ibdev             Infiniband device
493  * @v op                Subnet management operations
494  * @ret rc              Return status code
495  */
496 int ib_create_sma ( struct ib_sma *sma, struct ib_device *ibdev,
497                     struct ib_sma_operations *op ) {
498         int rc;
499
500         /* Initialise fields */
501         memset ( sma, 0, sizeof ( *sma ) );
502         sma->ibdev = ibdev;
503         sma->op = op;
504         process_init ( &sma->poll, ib_sma_step, &ibdev->refcnt );
505
506         /* Create completion queue */
507         sma->cq = ib_create_cq ( ibdev, IB_SMA_NUM_CQES,
508                                  &ib_sma_completion_ops );
509         if ( ! sma->cq ) {
510                 rc = -ENOMEM;
511                 goto err_create_cq;
512         }
513
514         /* Create queue pair */
515         sma->qp = ib_create_qp ( ibdev, IB_SMA_NUM_SEND_WQES, sma->cq,
516                                  IB_SMA_NUM_RECV_WQES, sma->cq, 0 );
517         if ( ! sma->qp ) {
518                 rc = -ENOMEM;
519                 goto err_create_qp;
520         }
521         ib_qp_set_ownerdata ( sma->qp, sma );
522
523         /* If we don't get QP0, we can't function */
524         if ( sma->qp->qpn != IB_QPN_SMP ) {
525                 DBGC ( sma, "SMA %p on QPN %lx, needs to be on QPN 0\n",
526                        sma, sma->qp->qpn );
527                 rc = -ENOTSUP;
528                 goto err_not_qp0;
529         }
530
531         /* Fill receive ring */
532         ib_sma_refill_recv ( sma );
533         return 0;
534
535  err_not_qp0:
536         ib_destroy_qp ( ibdev, sma->qp );
537  err_create_qp:
538         ib_destroy_cq ( ibdev, sma->cq );
539  err_create_cq:
540         process_del ( &sma->poll );
541         return rc;
542 }
543
544 /**
545  * Destroy SMA
546  *
547  * @v sma               Subnet management agent
548  */
549 void ib_destroy_sma ( struct ib_sma *sma ) {
550         struct ib_device *ibdev = sma->ibdev;
551
552         ib_destroy_qp ( ibdev, sma->qp );
553         ib_destroy_cq ( ibdev, sma->cq );
554         process_del ( &sma->poll );
555 }