[infiniband] Call ib_open() only when opening the IPoIB net device
[people/mcb30/gpxe.git] / src / drivers / infiniband / arbel.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * Based in part upon the original driver by Mellanox Technologies
5  * Ltd.  Portions may be Copyright (c) Mellanox Technologies Ltd.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2 of the
10  * License, or any later version.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include <stdint.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <strings.h>
27 #include <unistd.h>
28 #include <errno.h>
29 #include <byteswap.h>
30 #include <gpxe/io.h>
31 #include <gpxe/pci.h>
32 #include <gpxe/malloc.h>
33 #include <gpxe/umalloc.h>
34 #include <gpxe/iobuf.h>
35 #include <gpxe/netdevice.h>
36 #include <gpxe/infiniband.h>
37 #include <gpxe/ib_smc.h>
38 #include "arbel.h"
39
40 /**
41  * @file
42  *
43  * Mellanox Arbel Infiniband HCA
44  *
45  */
46
47 /***************************************************************************
48  *
49  * Queue number allocation
50  *
51  ***************************************************************************
52  */
53
54 /**
55  * Allocate queue number
56  *
57  * @v q_inuse           Queue usage bitmask
58  * @v max_inuse         Maximum number of in-use queues
59  * @ret qn_offset       Free queue number offset, or negative error
60  */
61 static int arbel_alloc_qn_offset ( arbel_bitmask_t *q_inuse,
62                                    unsigned int max_inuse ) {
63         unsigned int qn_offset = 0;
64         arbel_bitmask_t mask = 1;
65
66         while ( qn_offset < max_inuse ) {
67                 if ( ( mask & *q_inuse ) == 0 ) {
68                         *q_inuse |= mask;
69                         return qn_offset;
70                 }
71                 qn_offset++;
72                 mask <<= 1;
73                 if ( ! mask ) {
74                         mask = 1;
75                         q_inuse++;
76                 }
77         }
78         return -ENFILE;
79 }
80
81 /**
82  * Free queue number
83  *
84  * @v q_inuse           Queue usage bitmask
85  * @v qn_offset         Queue number offset
86  */
87 static void arbel_free_qn_offset ( arbel_bitmask_t *q_inuse, int qn_offset ) {
88         arbel_bitmask_t mask;
89
90         mask = ( 1 << ( qn_offset % ( 8 * sizeof ( mask ) ) ) );
91         q_inuse += ( qn_offset / ( 8 * sizeof ( mask ) ) );
92         *q_inuse &= ~mask;
93 }
94
95 /***************************************************************************
96  *
97  * HCA commands
98  *
99  ***************************************************************************
100  */
101
102 /**
103  * Wait for Arbel command completion
104  *
105  * @v arbel             Arbel device
106  * @ret rc              Return status code
107  */
108 static int arbel_cmd_wait ( struct arbel *arbel,
109                             struct arbelprm_hca_command_register *hcr ) {
110         unsigned int wait;
111
112         for ( wait = ARBEL_HCR_MAX_WAIT_MS ; wait ; wait-- ) {
113                 hcr->u.dwords[6] =
114                         readl ( arbel->config + ARBEL_HCR_REG ( 6 ) );
115                 if ( MLX_GET ( hcr, go ) == 0 )
116                         return 0;
117                 mdelay ( 1 );
118         }
119         return -EBUSY;
120 }
121
122 /**
123  * Issue HCA command
124  *
125  * @v arbel             Arbel device
126  * @v command           Command opcode, flags and input/output lengths
127  * @v op_mod            Opcode modifier (0 if no modifier applicable)
128  * @v in                Input parameters
129  * @v in_mod            Input modifier (0 if no modifier applicable)
130  * @v out               Output parameters
131  * @ret rc              Return status code
132  */
133 static int arbel_cmd ( struct arbel *arbel, unsigned long command,
134                        unsigned int op_mod, const void *in,
135                        unsigned int in_mod, void *out ) {
136         struct arbelprm_hca_command_register hcr;
137         unsigned int opcode = ARBEL_HCR_OPCODE ( command );
138         size_t in_len = ARBEL_HCR_IN_LEN ( command );
139         size_t out_len = ARBEL_HCR_OUT_LEN ( command );
140         void *in_buffer;
141         void *out_buffer;
142         unsigned int status;
143         unsigned int i;
144         int rc;
145
146         assert ( in_len <= ARBEL_MBOX_SIZE );
147         assert ( out_len <= ARBEL_MBOX_SIZE );
148
149         DBGC2 ( arbel, "Arbel %p command %02x in %zx%s out %zx%s\n",
150                 arbel, opcode, in_len,
151                 ( ( command & ARBEL_HCR_IN_MBOX ) ? "(mbox)" : "" ), out_len,
152                 ( ( command & ARBEL_HCR_OUT_MBOX ) ? "(mbox)" : "" ) );
153
154         /* Check that HCR is free */
155         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
156                 DBGC ( arbel, "Arbel %p command interface locked\n", arbel );
157                 return rc;
158         }
159
160         /* Prepare HCR */
161         memset ( &hcr, 0, sizeof ( hcr ) );
162         in_buffer = &hcr.u.dwords[0];
163         if ( in_len && ( command & ARBEL_HCR_IN_MBOX ) ) {
164                 in_buffer = arbel->mailbox_in;
165                 MLX_FILL_1 ( &hcr, 1, in_param_l, virt_to_bus ( in_buffer ) );
166         }
167         memcpy ( in_buffer, in, in_len );
168         MLX_FILL_1 ( &hcr, 2, input_modifier, in_mod );
169         out_buffer = &hcr.u.dwords[3];
170         if ( out_len && ( command & ARBEL_HCR_OUT_MBOX ) ) {
171                 out_buffer = arbel->mailbox_out;
172                 MLX_FILL_1 ( &hcr, 4, out_param_l,
173                              virt_to_bus ( out_buffer ) );
174         }
175         MLX_FILL_3 ( &hcr, 6,
176                      opcode, opcode,
177                      opcode_modifier, op_mod,
178                      go, 1 );
179         DBGC2_HD ( arbel, &hcr, sizeof ( hcr ) );
180         if ( in_len ) {
181                 DBGC2 ( arbel, "Input:\n" );
182                 DBGC2_HD ( arbel, in, ( ( in_len < 512 ) ? in_len : 512 ) );
183         }
184
185         /* Issue command */
186         for ( i = 0 ; i < ( sizeof ( hcr ) / sizeof ( hcr.u.dwords[0] ) ) ;
187               i++ ) {
188                 writel ( hcr.u.dwords[i],
189                          arbel->config + ARBEL_HCR_REG ( i ) );
190                 barrier();
191         }
192
193         /* Wait for command completion */
194         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
195                 DBGC ( arbel, "Arbel %p timed out waiting for command:\n",
196                        arbel );
197                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
198                 return rc;
199         }
200
201         /* Check command status */
202         status = MLX_GET ( &hcr, status );
203         if ( status != 0 ) {
204                 DBGC ( arbel, "Arbel %p command failed with status %02x:\n",
205                        arbel, status );
206                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
207                 return -EIO;
208         }
209
210         /* Read output parameters, if any */
211         hcr.u.dwords[3] = readl ( arbel->config + ARBEL_HCR_REG ( 3 ) );
212         hcr.u.dwords[4] = readl ( arbel->config + ARBEL_HCR_REG ( 4 ) );
213         memcpy ( out, out_buffer, out_len );
214         if ( out_len ) {
215                 DBGC2 ( arbel, "Output:\n" );
216                 DBGC2_HD ( arbel, out, ( ( out_len < 512 ) ? out_len : 512 ) );
217         }
218
219         return 0;
220 }
221
222 static inline int
223 arbel_cmd_query_dev_lim ( struct arbel *arbel,
224                           struct arbelprm_query_dev_lim *dev_lim ) {
225         return arbel_cmd ( arbel,
226                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_QUERY_DEV_LIM,
227                                                1, sizeof ( *dev_lim ) ),
228                            0, NULL, 0, dev_lim );
229 }
230
231 static inline int
232 arbel_cmd_query_fw ( struct arbel *arbel, struct arbelprm_query_fw *fw ) {
233         return arbel_cmd ( arbel,
234                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_QUERY_FW, 
235                                                1, sizeof ( *fw ) ),
236                            0, NULL, 0, fw );
237 }
238
239 static inline int
240 arbel_cmd_init_hca ( struct arbel *arbel,
241                      const struct arbelprm_init_hca *init_hca ) {
242         return arbel_cmd ( arbel,
243                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_INIT_HCA,
244                                               1, sizeof ( *init_hca ) ),
245                            0, init_hca, 0, NULL );
246 }
247
248 static inline int
249 arbel_cmd_close_hca ( struct arbel *arbel ) {
250         return arbel_cmd ( arbel,
251                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_CLOSE_HCA ),
252                            0, NULL, 0, NULL );
253 }
254
255 static inline int
256 arbel_cmd_init_ib ( struct arbel *arbel, unsigned int port,
257                     const struct arbelprm_init_ib *init_ib ) {
258         return arbel_cmd ( arbel,
259                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_INIT_IB,
260                                               1, sizeof ( *init_ib ) ),
261                            0, init_ib, port, NULL );
262 }
263
264 static inline int
265 arbel_cmd_close_ib ( struct arbel *arbel, unsigned int port ) {
266         return arbel_cmd ( arbel,
267                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_CLOSE_IB ),
268                            0, NULL, port, NULL );
269 }
270
271 static inline int
272 arbel_cmd_sw2hw_mpt ( struct arbel *arbel, unsigned int index,
273                       const struct arbelprm_mpt *mpt ) {
274         return arbel_cmd ( arbel,
275                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_SW2HW_MPT,
276                                               1, sizeof ( *mpt ) ),
277                            0, mpt, index, NULL );
278 }
279
280 static inline int
281 arbel_cmd_map_eq ( struct arbel *arbel, unsigned long index_map,
282                    const struct arbelprm_event_mask *mask ) {
283         return arbel_cmd ( arbel,
284                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_MAP_EQ,
285                                               0, sizeof ( *mask ) ),
286                            0, mask, index_map, NULL );
287 }
288
289 static inline int
290 arbel_cmd_sw2hw_eq ( struct arbel *arbel, unsigned int index,
291                      const struct arbelprm_eqc *eqctx ) {
292         return arbel_cmd ( arbel,
293                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_SW2HW_EQ,
294                                               1, sizeof ( *eqctx ) ),
295                            0, eqctx, index, NULL );
296 }
297
298 static inline int
299 arbel_cmd_hw2sw_eq ( struct arbel *arbel, unsigned int index,
300                      struct arbelprm_eqc *eqctx ) {
301         return arbel_cmd ( arbel,
302                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_HW2SW_EQ,
303                                                1, sizeof ( *eqctx ) ),
304                            1, NULL, index, eqctx );
305 }
306
307 static inline int
308 arbel_cmd_sw2hw_cq ( struct arbel *arbel, unsigned long cqn,
309                      const struct arbelprm_completion_queue_context *cqctx ) {
310         return arbel_cmd ( arbel,
311                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_SW2HW_CQ,
312                                               1, sizeof ( *cqctx ) ),
313                            0, cqctx, cqn, NULL );
314 }
315
316 static inline int
317 arbel_cmd_hw2sw_cq ( struct arbel *arbel, unsigned long cqn,
318                      struct arbelprm_completion_queue_context *cqctx) {
319         return arbel_cmd ( arbel,
320                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_HW2SW_CQ,
321                                                1, sizeof ( *cqctx ) ),
322                            0, NULL, cqn, cqctx );
323 }
324
325 static inline int
326 arbel_cmd_rst2init_qpee ( struct arbel *arbel, unsigned long qpn,
327                           const struct arbelprm_qp_ee_state_transitions *ctx ){
328         return arbel_cmd ( arbel,
329                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_RST2INIT_QPEE,
330                                               1, sizeof ( *ctx ) ),
331                            0, ctx, qpn, NULL );
332 }
333
334 static inline int
335 arbel_cmd_init2rtr_qpee ( struct arbel *arbel, unsigned long qpn,
336                           const struct arbelprm_qp_ee_state_transitions *ctx ){
337         return arbel_cmd ( arbel,
338                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_INIT2RTR_QPEE,
339                                               1, sizeof ( *ctx ) ),
340                            0, ctx, qpn, NULL );
341 }
342
343 static inline int
344 arbel_cmd_rtr2rts_qpee ( struct arbel *arbel, unsigned long qpn,
345                          const struct arbelprm_qp_ee_state_transitions *ctx ) {
346         return arbel_cmd ( arbel,
347                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_RTR2RTS_QPEE,
348                                               1, sizeof ( *ctx ) ),
349                            0, ctx, qpn, NULL );
350 }
351
352 static inline int
353 arbel_cmd_rts2rts_qp ( struct arbel *arbel, unsigned long qpn,
354                        const struct arbelprm_qp_ee_state_transitions *ctx ) {
355         return arbel_cmd ( arbel,
356                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_RTS2RTS_QPEE,
357                                               1, sizeof ( *ctx ) ),
358                            0, ctx, qpn, NULL );
359 }
360
361 static inline int
362 arbel_cmd_2rst_qpee ( struct arbel *arbel, unsigned long qpn ) {
363         return arbel_cmd ( arbel,
364                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_2RST_QPEE ),
365                            0x03, NULL, qpn, NULL );
366 }
367
368 static inline int
369 arbel_cmd_mad_ifc ( struct arbel *arbel, unsigned int port,
370                     union arbelprm_mad *mad ) {
371         return arbel_cmd ( arbel,
372                            ARBEL_HCR_INOUT_CMD ( ARBEL_HCR_MAD_IFC,
373                                                  1, sizeof ( *mad ),
374                                                  1, sizeof ( *mad ) ),
375                            0x03, mad, port, mad );
376 }
377
378 static inline int
379 arbel_cmd_read_mgm ( struct arbel *arbel, unsigned int index,
380                      struct arbelprm_mgm_entry *mgm ) {
381         return arbel_cmd ( arbel,
382                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_READ_MGM,
383                                                1, sizeof ( *mgm ) ),
384                            0, NULL, index, mgm );
385 }
386
387 static inline int
388 arbel_cmd_write_mgm ( struct arbel *arbel, unsigned int index,
389                       const struct arbelprm_mgm_entry *mgm ) {
390         return arbel_cmd ( arbel,
391                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_WRITE_MGM,
392                                               1, sizeof ( *mgm ) ),
393                            0, mgm, index, NULL );
394 }
395
396 static inline int
397 arbel_cmd_mgid_hash ( struct arbel *arbel, const struct ib_gid *gid,
398                       struct arbelprm_mgm_hash *hash ) {
399         return arbel_cmd ( arbel,
400                            ARBEL_HCR_INOUT_CMD ( ARBEL_HCR_MGID_HASH,
401                                                  1, sizeof ( *gid ),
402                                                  0, sizeof ( *hash ) ),
403                            0, gid, 0, hash );
404 }
405
406 static inline int
407 arbel_cmd_run_fw ( struct arbel *arbel ) {
408         return arbel_cmd ( arbel,
409                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_RUN_FW ),
410                            0, NULL, 0, NULL );
411 }
412
413 static inline int
414 arbel_cmd_disable_lam ( struct arbel *arbel ) {
415         return arbel_cmd ( arbel,
416                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_DISABLE_LAM ),
417                            0, NULL, 0, NULL );
418 }
419
420 static inline int
421 arbel_cmd_enable_lam ( struct arbel *arbel, struct arbelprm_access_lam *lam ) {
422         return arbel_cmd ( arbel,
423                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_ENABLE_LAM,
424                                                1, sizeof ( *lam ) ),
425                            1, NULL, 0, lam );
426 }
427
428 static inline int
429 arbel_cmd_unmap_icm ( struct arbel *arbel, unsigned int page_count ) {
430         return arbel_cmd ( arbel,
431                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_UNMAP_ICM ),
432                            0, NULL, page_count, NULL );
433 }
434
435 static inline int
436 arbel_cmd_map_icm ( struct arbel *arbel,
437                     const struct arbelprm_virtual_physical_mapping *map ) {
438         return arbel_cmd ( arbel,
439                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_MAP_ICM,
440                                               1, sizeof ( *map ) ),
441                            0, map, 1, NULL );
442 }
443
444 static inline int
445 arbel_cmd_unmap_icm_aux ( struct arbel *arbel ) {
446         return arbel_cmd ( arbel,
447                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_UNMAP_ICM_AUX ),
448                            0, NULL, 0, NULL );
449 }
450
451 static inline int
452 arbel_cmd_map_icm_aux ( struct arbel *arbel,
453                         const struct arbelprm_virtual_physical_mapping *map ) {
454         return arbel_cmd ( arbel,
455                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_MAP_ICM_AUX,
456                                               1, sizeof ( *map ) ),
457                            0, map, 1, NULL );
458 }
459
460 static inline int
461 arbel_cmd_set_icm_size ( struct arbel *arbel,
462                          const struct arbelprm_scalar_parameter *icm_size,
463                          struct arbelprm_scalar_parameter *icm_aux_size ) {
464         return arbel_cmd ( arbel,
465                            ARBEL_HCR_INOUT_CMD ( ARBEL_HCR_SET_ICM_SIZE,
466                                                  0, sizeof ( *icm_size ),
467                                                  0, sizeof ( *icm_aux_size ) ),
468                            0, icm_size, 0, icm_aux_size );
469 }
470
471 static inline int
472 arbel_cmd_unmap_fa ( struct arbel *arbel ) {
473         return arbel_cmd ( arbel,
474                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_UNMAP_FA ),
475                            0, NULL, 0, NULL );
476 }
477
478 static inline int
479 arbel_cmd_map_fa ( struct arbel *arbel,
480                    const struct arbelprm_virtual_physical_mapping *map ) {
481         return arbel_cmd ( arbel,
482                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_MAP_FA,
483                                               1, sizeof ( *map ) ),
484                            0, map, 1, NULL );
485 }
486
487 /***************************************************************************
488  *
489  * MAD operations
490  *
491  ***************************************************************************
492  */
493
494 /**
495  * Issue management datagram
496  *
497  * @v ibdev             Infiniband device
498  * @v mad               Management datagram
499  * @ret rc              Return status code
500  */
501 static int arbel_mad ( struct ib_device *ibdev, union ib_mad *mad ) {
502         struct arbel *arbel = ib_get_drvdata ( ibdev );
503         union arbelprm_mad mad_ifc;
504         int rc;
505
506         linker_assert ( sizeof ( *mad ) == sizeof ( mad_ifc.mad ),
507                         mad_size_mismatch );
508
509         /* Copy in request packet */
510         memcpy ( &mad_ifc.mad, mad, sizeof ( mad_ifc.mad ) );
511
512         /* Issue MAD */
513         if ( ( rc = arbel_cmd_mad_ifc ( arbel, ibdev->port,
514                                         &mad_ifc ) ) != 0 ) {
515                 DBGC ( arbel, "Arbel %p could not issue MAD IFC: %s\n",
516                        arbel, strerror ( rc ) );
517                 return rc;
518         }
519
520         /* Copy out reply packet */
521         memcpy ( mad, &mad_ifc.mad, sizeof ( *mad ) );
522
523         if ( mad->hdr.status != 0 ) {
524                 DBGC ( arbel, "Arbel %p MAD IFC status %04x\n",
525                        arbel, ntohs ( mad->hdr.status ) );
526                 return -EIO;
527         }
528         return 0;
529 }
530
531 /***************************************************************************
532  *
533  * Completion queue operations
534  *
535  ***************************************************************************
536  */
537
538 /**
539  * Create completion queue
540  *
541  * @v ibdev             Infiniband device
542  * @v cq                Completion queue
543  * @ret rc              Return status code
544  */
545 static int arbel_create_cq ( struct ib_device *ibdev,
546                              struct ib_completion_queue *cq ) {
547         struct arbel *arbel = ib_get_drvdata ( ibdev );
548         struct arbel_completion_queue *arbel_cq;
549         struct arbelprm_completion_queue_context cqctx;
550         struct arbelprm_cq_ci_db_record *ci_db_rec;
551         struct arbelprm_cq_arm_db_record *arm_db_rec;
552         int cqn_offset;
553         unsigned int i;
554         int rc;
555
556         /* Find a free completion queue number */
557         cqn_offset = arbel_alloc_qn_offset ( arbel->cq_inuse, ARBEL_MAX_CQS );
558         if ( cqn_offset < 0 ) {
559                 DBGC ( arbel, "Arbel %p out of completion queues\n", arbel );
560                 rc = cqn_offset;
561                 goto err_cqn_offset;
562         }
563         cq->cqn = ( arbel->limits.reserved_cqs + cqn_offset );
564
565         /* Allocate control structures */
566         arbel_cq = zalloc ( sizeof ( *arbel_cq ) );
567         if ( ! arbel_cq ) {
568                 rc = -ENOMEM;
569                 goto err_arbel_cq;
570         }
571         arbel_cq->ci_doorbell_idx = arbel_cq_ci_doorbell_idx ( cqn_offset );
572         arbel_cq->arm_doorbell_idx = arbel_cq_arm_doorbell_idx ( cqn_offset );
573
574         /* Allocate completion queue itself */
575         arbel_cq->cqe_size = ( cq->num_cqes * sizeof ( arbel_cq->cqe[0] ) );
576         arbel_cq->cqe = malloc_dma ( arbel_cq->cqe_size,
577                                      sizeof ( arbel_cq->cqe[0] ) );
578         if ( ! arbel_cq->cqe ) {
579                 rc = -ENOMEM;
580                 goto err_cqe;
581         }
582         memset ( arbel_cq->cqe, 0, arbel_cq->cqe_size );
583         for ( i = 0 ; i < cq->num_cqes ; i++ ) {
584                 MLX_FILL_1 ( &arbel_cq->cqe[i].normal, 7, owner, 1 );
585         }
586         barrier();
587
588         /* Initialise doorbell records */
589         ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
590         MLX_FILL_1 ( ci_db_rec, 0, counter, 0 );
591         MLX_FILL_2 ( ci_db_rec, 1,
592                      res, ARBEL_UAR_RES_CQ_CI,
593                      cq_number, cq->cqn );
594         arm_db_rec = &arbel->db_rec[arbel_cq->arm_doorbell_idx].cq_arm;
595         MLX_FILL_1 ( arm_db_rec, 0, counter, 0 );
596         MLX_FILL_2 ( arm_db_rec, 1,
597                      res, ARBEL_UAR_RES_CQ_ARM,
598                      cq_number, cq->cqn );
599
600         /* Hand queue over to hardware */
601         memset ( &cqctx, 0, sizeof ( cqctx ) );
602         MLX_FILL_1 ( &cqctx, 0, st, 0xa /* "Event fired" */ );
603         MLX_FILL_1 ( &cqctx, 2, start_address_l,
604                      virt_to_bus ( arbel_cq->cqe ) );
605         MLX_FILL_2 ( &cqctx, 3,
606                      usr_page, arbel->limits.reserved_uars,
607                      log_cq_size, fls ( cq->num_cqes - 1 ) );
608         MLX_FILL_1 ( &cqctx, 5, c_eqn, ARBEL_NO_EQ );
609         MLX_FILL_1 ( &cqctx, 6, pd, ARBEL_GLOBAL_PD );
610         MLX_FILL_1 ( &cqctx, 7, l_key, arbel->reserved_lkey );
611         MLX_FILL_1 ( &cqctx, 12, cqn, cq->cqn );
612         MLX_FILL_1 ( &cqctx, 13,
613                      cq_ci_db_record, arbel_cq->ci_doorbell_idx );
614         MLX_FILL_1 ( &cqctx, 14,
615                      cq_state_db_record, arbel_cq->arm_doorbell_idx );
616         if ( ( rc = arbel_cmd_sw2hw_cq ( arbel, cq->cqn, &cqctx ) ) != 0 ) {
617                 DBGC ( arbel, "Arbel %p SW2HW_CQ failed: %s\n",
618                        arbel, strerror ( rc ) );
619                 goto err_sw2hw_cq;
620         }
621
622         DBGC ( arbel, "Arbel %p CQN %#lx ring at [%p,%p)\n",
623                arbel, cq->cqn, arbel_cq->cqe,
624                ( ( ( void * ) arbel_cq->cqe ) + arbel_cq->cqe_size ) );
625         ib_cq_set_drvdata ( cq, arbel_cq );
626         return 0;
627
628  err_sw2hw_cq:
629         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
630         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
631         free_dma ( arbel_cq->cqe, arbel_cq->cqe_size );
632  err_cqe:
633         free ( arbel_cq );
634  err_arbel_cq:
635         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
636  err_cqn_offset:
637         return rc;
638 }
639
640 /**
641  * Destroy completion queue
642  *
643  * @v ibdev             Infiniband device
644  * @v cq                Completion queue
645  */
646 static void arbel_destroy_cq ( struct ib_device *ibdev,
647                                struct ib_completion_queue *cq ) {
648         struct arbel *arbel = ib_get_drvdata ( ibdev );
649         struct arbel_completion_queue *arbel_cq = ib_cq_get_drvdata ( cq );
650         struct arbelprm_completion_queue_context cqctx;
651         struct arbelprm_cq_ci_db_record *ci_db_rec;
652         struct arbelprm_cq_arm_db_record *arm_db_rec;
653         int cqn_offset;
654         int rc;
655
656         /* Take ownership back from hardware */
657         if ( ( rc = arbel_cmd_hw2sw_cq ( arbel, cq->cqn, &cqctx ) ) != 0 ) {
658                 DBGC ( arbel, "Arbel %p FATAL HW2SW_CQ failed on CQN %#lx: "
659                        "%s\n", arbel, cq->cqn, strerror ( rc ) );
660                 /* Leak memory and return; at least we avoid corruption */
661                 return;
662         }
663
664         /* Clear doorbell records */
665         ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
666         arm_db_rec = &arbel->db_rec[arbel_cq->arm_doorbell_idx].cq_arm;
667         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
668         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
669
670         /* Free memory */
671         free_dma ( arbel_cq->cqe, arbel_cq->cqe_size );
672         free ( arbel_cq );
673
674         /* Mark queue number as free */
675         cqn_offset = ( cq->cqn - arbel->limits.reserved_cqs );
676         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
677
678         ib_cq_set_drvdata ( cq, NULL );
679 }
680
681 /***************************************************************************
682  *
683  * Queue pair operations
684  *
685  ***************************************************************************
686  */
687
688 /**
689  * Create send work queue
690  *
691  * @v arbel_send_wq     Send work queue
692  * @v num_wqes          Number of work queue entries
693  * @ret rc              Return status code
694  */
695 static int arbel_create_send_wq ( struct arbel_send_work_queue *arbel_send_wq,
696                                   unsigned int num_wqes ) {
697         struct arbelprm_ud_send_wqe *wqe;
698         struct arbelprm_ud_send_wqe *next_wqe;
699         unsigned int wqe_idx_mask;
700         unsigned int i;
701
702         /* Allocate work queue */
703         arbel_send_wq->wqe_size = ( num_wqes *
704                                     sizeof ( arbel_send_wq->wqe[0] ) );
705         arbel_send_wq->wqe = malloc_dma ( arbel_send_wq->wqe_size,
706                                           sizeof ( arbel_send_wq->wqe[0] ) );
707         if ( ! arbel_send_wq->wqe )
708                 return -ENOMEM;
709         memset ( arbel_send_wq->wqe, 0, arbel_send_wq->wqe_size );
710
711         /* Link work queue entries */
712         wqe_idx_mask = ( num_wqes - 1 );
713         for ( i = 0 ; i < num_wqes ; i++ ) {
714                 wqe = &arbel_send_wq->wqe[i].ud;
715                 next_wqe = &arbel_send_wq->wqe[ ( i + 1 ) & wqe_idx_mask ].ud;
716                 MLX_FILL_1 ( &wqe->next, 0, nda_31_6,
717                              ( virt_to_bus ( next_wqe ) >> 6 ) );
718         }
719         
720         return 0;
721 }
722
723 /**
724  * Create receive work queue
725  *
726  * @v arbel_recv_wq     Receive work queue
727  * @v num_wqes          Number of work queue entries
728  * @ret rc              Return status code
729  */
730 static int arbel_create_recv_wq ( struct arbel_recv_work_queue *arbel_recv_wq,
731                                   unsigned int num_wqes ) {
732         struct arbelprm_recv_wqe *wqe;
733         struct arbelprm_recv_wqe *next_wqe;
734         unsigned int wqe_idx_mask;
735         size_t nds;
736         unsigned int i;
737         unsigned int j;
738
739         /* Allocate work queue */
740         arbel_recv_wq->wqe_size = ( num_wqes *
741                                     sizeof ( arbel_recv_wq->wqe[0] ) );
742         arbel_recv_wq->wqe = malloc_dma ( arbel_recv_wq->wqe_size,
743                                           sizeof ( arbel_recv_wq->wqe[0] ) );
744         if ( ! arbel_recv_wq->wqe )
745                 return -ENOMEM;
746         memset ( arbel_recv_wq->wqe, 0, arbel_recv_wq->wqe_size );
747
748         /* Link work queue entries */
749         wqe_idx_mask = ( num_wqes - 1 );
750         nds = ( ( offsetof ( typeof ( *wqe ), data ) +
751                   sizeof ( wqe->data[0] ) ) >> 4 );
752         for ( i = 0 ; i < num_wqes ; i++ ) {
753                 wqe = &arbel_recv_wq->wqe[i].recv;
754                 next_wqe = &arbel_recv_wq->wqe[( i + 1 ) & wqe_idx_mask].recv;
755                 MLX_FILL_1 ( &wqe->next, 0, nda_31_6,
756                              ( virt_to_bus ( next_wqe ) >> 6 ) );
757                 MLX_FILL_1 ( &wqe->next, 1, nds, ( sizeof ( *wqe ) / 16 ) );
758                 for ( j = 0 ; ( ( ( void * ) &wqe->data[j] ) <
759                                 ( ( void * ) ( wqe + 1 ) ) ) ; j++ ) {
760                         MLX_FILL_1 ( &wqe->data[j], 1,
761                                      l_key, ARBEL_INVALID_LKEY );
762                 }
763         }
764         
765         return 0;
766 }
767
768 /**
769  * Create queue pair
770  *
771  * @v ibdev             Infiniband device
772  * @v qp                Queue pair
773  * @ret rc              Return status code
774  */
775 static int arbel_create_qp ( struct ib_device *ibdev,
776                              struct ib_queue_pair *qp ) {
777         struct arbel *arbel = ib_get_drvdata ( ibdev );
778         struct arbel_queue_pair *arbel_qp;
779         struct arbelprm_qp_ee_state_transitions qpctx;
780         struct arbelprm_qp_db_record *send_db_rec;
781         struct arbelprm_qp_db_record *recv_db_rec;
782         int qpn_offset;
783         int rc;
784
785         /* Find a free queue pair number */
786         qpn_offset = arbel_alloc_qn_offset ( arbel->qp_inuse, ARBEL_MAX_QPS );
787         if ( qpn_offset < 0 ) {
788                 DBGC ( arbel, "Arbel %p out of queue pairs\n", arbel );
789                 rc = qpn_offset;
790                 goto err_qpn_offset;
791         }
792         qp->qpn = ( ARBEL_QPN_BASE + arbel->limits.reserved_qps + qpn_offset );
793
794         /* Allocate control structures */
795         arbel_qp = zalloc ( sizeof ( *arbel_qp ) );
796         if ( ! arbel_qp ) {
797                 rc = -ENOMEM;
798                 goto err_arbel_qp;
799         }
800         arbel_qp->send.doorbell_idx = arbel_send_doorbell_idx ( qpn_offset );
801         arbel_qp->recv.doorbell_idx = arbel_recv_doorbell_idx ( qpn_offset );
802
803         /* Create send and receive work queues */
804         if ( ( rc = arbel_create_send_wq ( &arbel_qp->send,
805                                            qp->send.num_wqes ) ) != 0 )
806                 goto err_create_send_wq;
807         if ( ( rc = arbel_create_recv_wq ( &arbel_qp->recv,
808                                            qp->recv.num_wqes ) ) != 0 )
809                 goto err_create_recv_wq;
810
811         /* Initialise doorbell records */
812         send_db_rec = &arbel->db_rec[arbel_qp->send.doorbell_idx].qp;
813         MLX_FILL_1 ( send_db_rec, 0, counter, 0 );
814         MLX_FILL_2 ( send_db_rec, 1,
815                      res, ARBEL_UAR_RES_SQ,
816                      qp_number, qp->qpn );
817         recv_db_rec = &arbel->db_rec[arbel_qp->recv.doorbell_idx].qp;
818         MLX_FILL_1 ( recv_db_rec, 0, counter, 0 );
819         MLX_FILL_2 ( recv_db_rec, 1,
820                      res, ARBEL_UAR_RES_RQ,
821                      qp_number, qp->qpn );
822
823         /* Hand queue over to hardware */
824         memset ( &qpctx, 0, sizeof ( qpctx ) );
825         MLX_FILL_3 ( &qpctx, 2,
826                      qpc_eec_data.de, 1,
827                      qpc_eec_data.pm_state, 0x03 /* Always 0x03 for UD */,
828                      qpc_eec_data.st, ARBEL_ST_UD );
829         MLX_FILL_6 ( &qpctx, 4,
830                      qpc_eec_data.mtu, ARBEL_MTU_2048,
831                      qpc_eec_data.msg_max, 11 /* 2^11 = 2048 */,
832                      qpc_eec_data.log_rq_size, fls ( qp->recv.num_wqes - 1 ),
833                      qpc_eec_data.log_rq_stride,
834                      ( fls ( sizeof ( arbel_qp->recv.wqe[0] ) - 1 ) - 4 ),
835                      qpc_eec_data.log_sq_size, fls ( qp->send.num_wqes - 1 ),
836                      qpc_eec_data.log_sq_stride,
837                      ( fls ( sizeof ( arbel_qp->send.wqe[0] ) - 1 ) - 4 ) );
838         MLX_FILL_1 ( &qpctx, 5,
839                      qpc_eec_data.usr_page, arbel->limits.reserved_uars );
840         MLX_FILL_1 ( &qpctx, 10, qpc_eec_data.primary_address_path.port_number,
841                      ibdev->port );
842         MLX_FILL_1 ( &qpctx, 27, qpc_eec_data.pd, ARBEL_GLOBAL_PD );
843         MLX_FILL_1 ( &qpctx, 29, qpc_eec_data.wqe_lkey, arbel->reserved_lkey );
844         MLX_FILL_1 ( &qpctx, 30, qpc_eec_data.ssc, 1 );
845         MLX_FILL_1 ( &qpctx, 33, qpc_eec_data.cqn_snd, qp->send.cq->cqn );
846         MLX_FILL_1 ( &qpctx, 34, qpc_eec_data.snd_wqe_base_adr_l,
847                      ( virt_to_bus ( arbel_qp->send.wqe ) >> 6 ) );
848         MLX_FILL_1 ( &qpctx, 35, qpc_eec_data.snd_db_record_index,
849                      arbel_qp->send.doorbell_idx );
850         MLX_FILL_1 ( &qpctx, 38, qpc_eec_data.rsc, 1 );
851         MLX_FILL_1 ( &qpctx, 41, qpc_eec_data.cqn_rcv, qp->recv.cq->cqn );
852         MLX_FILL_1 ( &qpctx, 42, qpc_eec_data.rcv_wqe_base_adr_l,
853                      ( virt_to_bus ( arbel_qp->recv.wqe ) >> 6 ) );
854         MLX_FILL_1 ( &qpctx, 43, qpc_eec_data.rcv_db_record_index,
855                      arbel_qp->recv.doorbell_idx );
856         MLX_FILL_1 ( &qpctx, 44, qpc_eec_data.q_key, qp->qkey );
857         if ( ( rc = arbel_cmd_rst2init_qpee ( arbel, qp->qpn, &qpctx )) != 0 ){
858                 DBGC ( arbel, "Arbel %p RST2INIT_QPEE failed: %s\n",
859                        arbel, strerror ( rc ) );
860                 goto err_rst2init_qpee;
861         }
862         memset ( &qpctx, 0, sizeof ( qpctx ) );
863         MLX_FILL_2 ( &qpctx, 4,
864                      qpc_eec_data.mtu, ARBEL_MTU_2048,
865                      qpc_eec_data.msg_max, 11 /* 2^11 = 2048 */ );
866         if ( ( rc = arbel_cmd_init2rtr_qpee ( arbel, qp->qpn, &qpctx )) != 0 ){
867                 DBGC ( arbel, "Arbel %p INIT2RTR_QPEE failed: %s\n",
868                        arbel, strerror ( rc ) );
869                 goto err_init2rtr_qpee;
870         }
871         memset ( &qpctx, 0, sizeof ( qpctx ) );
872         if ( ( rc = arbel_cmd_rtr2rts_qpee ( arbel, qp->qpn, &qpctx ) ) != 0 ){
873                 DBGC ( arbel, "Arbel %p RTR2RTS_QPEE failed: %s\n",
874                        arbel, strerror ( rc ) );
875                 goto err_rtr2rts_qpee;
876         }
877
878         DBGC ( arbel, "Arbel %p QPN %#lx send ring at [%p,%p)\n",
879                arbel, qp->qpn, arbel_qp->send.wqe,
880                ( ( (void *) arbel_qp->send.wqe ) + arbel_qp->send.wqe_size ) );
881         DBGC ( arbel, "Arbel %p QPN %#lx receive ring at [%p,%p)\n",
882                arbel, qp->qpn, arbel_qp->recv.wqe,
883                ( ( (void *) arbel_qp->recv.wqe ) + arbel_qp->recv.wqe_size ) );
884         ib_qp_set_drvdata ( qp, arbel_qp );
885         return 0;
886
887  err_rtr2rts_qpee:
888  err_init2rtr_qpee:
889         arbel_cmd_2rst_qpee ( arbel, qp->qpn );
890  err_rst2init_qpee:
891         MLX_FILL_1 ( send_db_rec, 1, res, ARBEL_UAR_RES_NONE );
892         MLX_FILL_1 ( recv_db_rec, 1, res, ARBEL_UAR_RES_NONE );
893         free_dma ( arbel_qp->recv.wqe, arbel_qp->recv.wqe_size );
894  err_create_recv_wq:
895         free_dma ( arbel_qp->send.wqe, arbel_qp->send.wqe_size );
896  err_create_send_wq:
897         free ( arbel_qp );
898  err_arbel_qp:
899         arbel_free_qn_offset ( arbel->qp_inuse, qpn_offset );
900  err_qpn_offset:
901         return rc;
902 }
903
904 /**
905  * Modify queue pair
906  *
907  * @v ibdev             Infiniband device
908  * @v qp                Queue pair
909  * @v mod_list          Modification list
910  * @ret rc              Return status code
911  */
912 static int arbel_modify_qp ( struct ib_device *ibdev,
913                              struct ib_queue_pair *qp,
914                              unsigned long mod_list ) {
915         struct arbel *arbel = ib_get_drvdata ( ibdev );
916         struct arbelprm_qp_ee_state_transitions qpctx;
917         unsigned long optparammask = 0;
918         int rc;
919
920         /* Construct optparammask */
921         if ( mod_list & IB_MODIFY_QKEY )
922                 optparammask |= ARBEL_QPEE_OPT_PARAM_QKEY;
923
924         /* Issue RTS2RTS_QP */
925         memset ( &qpctx, 0, sizeof ( qpctx ) );
926         MLX_FILL_1 ( &qpctx, 0, opt_param_mask, optparammask );
927         MLX_FILL_1 ( &qpctx, 44, qpc_eec_data.q_key, qp->qkey );
928         if ( ( rc = arbel_cmd_rts2rts_qp ( arbel, qp->qpn, &qpctx ) ) != 0 ){
929                 DBGC ( arbel, "Arbel %p RTS2RTS_QP failed: %s\n",
930                        arbel, strerror ( rc ) );
931                 return rc;
932         }
933
934         return 0;
935 }
936
937 /**
938  * Destroy queue pair
939  *
940  * @v ibdev             Infiniband device
941  * @v qp                Queue pair
942  */
943 static void arbel_destroy_qp ( struct ib_device *ibdev,
944                                struct ib_queue_pair *qp ) {
945         struct arbel *arbel = ib_get_drvdata ( ibdev );
946         struct arbel_queue_pair *arbel_qp = ib_qp_get_drvdata ( qp );
947         struct arbelprm_qp_db_record *send_db_rec;
948         struct arbelprm_qp_db_record *recv_db_rec;
949         int qpn_offset;
950         int rc;
951
952         /* Take ownership back from hardware */
953         if ( ( rc = arbel_cmd_2rst_qpee ( arbel, qp->qpn ) ) != 0 ) {
954                 DBGC ( arbel, "Arbel %p FATAL 2RST_QPEE failed on QPN %#lx: "
955                        "%s\n", arbel, qp->qpn, strerror ( rc ) );
956                 /* Leak memory and return; at least we avoid corruption */
957                 return;
958         }
959
960         /* Clear doorbell records */
961         send_db_rec = &arbel->db_rec[arbel_qp->send.doorbell_idx].qp;
962         recv_db_rec = &arbel->db_rec[arbel_qp->recv.doorbell_idx].qp;
963         MLX_FILL_1 ( send_db_rec, 1, res, ARBEL_UAR_RES_NONE );
964         MLX_FILL_1 ( recv_db_rec, 1, res, ARBEL_UAR_RES_NONE );
965
966         /* Free memory */
967         free_dma ( arbel_qp->send.wqe, arbel_qp->send.wqe_size );
968         free_dma ( arbel_qp->recv.wqe, arbel_qp->recv.wqe_size );
969         free ( arbel_qp );
970
971         /* Mark queue number as free */
972         qpn_offset = ( qp->qpn - ARBEL_QPN_BASE - arbel->limits.reserved_qps );
973         arbel_free_qn_offset ( arbel->qp_inuse, qpn_offset );
974
975         ib_qp_set_drvdata ( qp, NULL );
976 }
977
978 /***************************************************************************
979  *
980  * Work request operations
981  *
982  ***************************************************************************
983  */
984
985 /**
986  * Ring doorbell register in UAR
987  *
988  * @v arbel             Arbel device
989  * @v db_reg            Doorbell register structure
990  * @v offset            Address of doorbell
991  */
992 static void arbel_ring_doorbell ( struct arbel *arbel,
993                                   union arbelprm_doorbell_register *db_reg,
994                                   unsigned int offset ) {
995
996         DBGC2 ( arbel, "Arbel %p ringing doorbell %08x:%08x at %lx\n",
997                 arbel, db_reg->dword[0], db_reg->dword[1],
998                 virt_to_phys ( arbel->uar + offset ) );
999
1000         barrier();
1001         writel ( db_reg->dword[0], ( arbel->uar + offset + 0 ) );
1002         barrier();
1003         writel ( db_reg->dword[1], ( arbel->uar + offset + 4 ) );
1004 }
1005
1006 /** GID used for GID-less send work queue entries */
1007 static const struct ib_gid arbel_no_gid = {
1008         { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0 } }
1009 };
1010
1011 /**
1012  * Post send work queue entry
1013  *
1014  * @v ibdev             Infiniband device
1015  * @v qp                Queue pair
1016  * @v av                Address vector
1017  * @v iobuf             I/O buffer
1018  * @ret rc              Return status code
1019  */
1020 static int arbel_post_send ( struct ib_device *ibdev,
1021                              struct ib_queue_pair *qp,
1022                              struct ib_address_vector *av,
1023                              struct io_buffer *iobuf ) {
1024         struct arbel *arbel = ib_get_drvdata ( ibdev );
1025         struct arbel_queue_pair *arbel_qp = ib_qp_get_drvdata ( qp );
1026         struct ib_work_queue *wq = &qp->send;
1027         struct arbel_send_work_queue *arbel_send_wq = &arbel_qp->send;
1028         struct arbelprm_ud_send_wqe *prev_wqe;
1029         struct arbelprm_ud_send_wqe *wqe;
1030         struct arbelprm_qp_db_record *qp_db_rec;
1031         union arbelprm_doorbell_register db_reg;
1032         const struct ib_gid *gid;
1033         unsigned int wqe_idx_mask;
1034         size_t nds;
1035
1036         /* Allocate work queue entry */
1037         wqe_idx_mask = ( wq->num_wqes - 1 );
1038         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
1039                 DBGC ( arbel, "Arbel %p send queue full", arbel );
1040                 return -ENOBUFS;
1041         }
1042         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
1043         prev_wqe = &arbel_send_wq->wqe[(wq->next_idx - 1) & wqe_idx_mask].ud;
1044         wqe = &arbel_send_wq->wqe[wq->next_idx & wqe_idx_mask].ud;
1045
1046         /* Construct work queue entry */
1047         MLX_FILL_1 ( &wqe->next, 1, always1, 1 );
1048         memset ( &wqe->ctrl, 0, sizeof ( wqe->ctrl ) );
1049         MLX_FILL_1 ( &wqe->ctrl, 0, always1, 1 );
1050         memset ( &wqe->ud, 0, sizeof ( wqe->ud ) );
1051         MLX_FILL_2 ( &wqe->ud, 0,
1052                      ud_address_vector.pd, ARBEL_GLOBAL_PD,
1053                      ud_address_vector.port_number, ibdev->port );
1054         MLX_FILL_2 ( &wqe->ud, 1,
1055                      ud_address_vector.rlid, av->lid,
1056                      ud_address_vector.g, av->gid_present );
1057         MLX_FILL_2 ( &wqe->ud, 2,
1058                      ud_address_vector.max_stat_rate,
1059                          ( ( av->rate >= 3 ) ? 0 : 1 ),
1060                      ud_address_vector.msg, 3 );
1061         MLX_FILL_1 ( &wqe->ud, 3, ud_address_vector.sl, av->sl );
1062         gid = ( av->gid_present ? &av->gid : &arbel_no_gid );
1063         memcpy ( &wqe->ud.u.dwords[4], gid, sizeof ( *gid ) );
1064         MLX_FILL_1 ( &wqe->ud, 8, destination_qp, av->qpn );
1065         MLX_FILL_1 ( &wqe->ud, 9, q_key, av->qkey );
1066         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_len ( iobuf ) );
1067         MLX_FILL_1 ( &wqe->data[0], 1, l_key, arbel->reserved_lkey );
1068         MLX_FILL_1 ( &wqe->data[0], 3,
1069                      local_address_l, virt_to_bus ( iobuf->data ) );
1070
1071         /* Update previous work queue entry's "next" field */
1072         nds = ( ( offsetof ( typeof ( *wqe ), data ) +
1073                   sizeof ( wqe->data[0] ) ) >> 4 );
1074         MLX_SET ( &prev_wqe->next, nopcode, ARBEL_OPCODE_SEND );
1075         MLX_FILL_3 ( &prev_wqe->next, 1,
1076                      nds, nds,
1077                      f, 1,
1078                      always1, 1 );
1079
1080         /* Update doorbell record */
1081         barrier();
1082         qp_db_rec = &arbel->db_rec[arbel_send_wq->doorbell_idx].qp;
1083         MLX_FILL_1 ( qp_db_rec, 0,
1084                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );
1085
1086         /* Ring doorbell register */
1087         MLX_FILL_4 ( &db_reg.send, 0,
1088                      nopcode, ARBEL_OPCODE_SEND,
1089                      f, 1,
1090                      wqe_counter, ( wq->next_idx & 0xffff ),
1091                      wqe_cnt, 1 );
1092         MLX_FILL_2 ( &db_reg.send, 1,
1093                      nds, nds,
1094                      qpn, qp->qpn );
1095         arbel_ring_doorbell ( arbel, &db_reg, ARBEL_DB_POST_SND_OFFSET );
1096
1097         /* Update work queue's index */
1098         wq->next_idx++;
1099
1100         return 0;
1101 }
1102
1103 /**
1104  * Post receive work queue entry
1105  *
1106  * @v ibdev             Infiniband device
1107  * @v qp                Queue pair
1108  * @v iobuf             I/O buffer
1109  * @ret rc              Return status code
1110  */
1111 static int arbel_post_recv ( struct ib_device *ibdev,
1112                              struct ib_queue_pair *qp,
1113                              struct io_buffer *iobuf ) {
1114         struct arbel *arbel = ib_get_drvdata ( ibdev );
1115         struct arbel_queue_pair *arbel_qp = ib_qp_get_drvdata ( qp );
1116         struct ib_work_queue *wq = &qp->recv;
1117         struct arbel_recv_work_queue *arbel_recv_wq = &arbel_qp->recv;
1118         struct arbelprm_recv_wqe *wqe;
1119         union arbelprm_doorbell_record *db_rec;
1120         unsigned int wqe_idx_mask;
1121
1122         /* Allocate work queue entry */
1123         wqe_idx_mask = ( wq->num_wqes - 1 );
1124         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
1125                 DBGC ( arbel, "Arbel %p receive queue full", arbel );
1126                 return -ENOBUFS;
1127         }
1128         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
1129         wqe = &arbel_recv_wq->wqe[wq->next_idx & wqe_idx_mask].recv;
1130
1131         /* Construct work queue entry */
1132         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_tailroom ( iobuf ) );
1133         MLX_FILL_1 ( &wqe->data[0], 1, l_key, arbel->reserved_lkey );
1134         MLX_FILL_1 ( &wqe->data[0], 3,
1135                      local_address_l, virt_to_bus ( iobuf->data ) );
1136
1137         /* Update doorbell record */
1138         barrier();
1139         db_rec = &arbel->db_rec[arbel_recv_wq->doorbell_idx];
1140         MLX_FILL_1 ( &db_rec->qp, 0,
1141                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );      
1142
1143         /* Update work queue's index */
1144         wq->next_idx++;
1145
1146         return 0;       
1147 }
1148
1149 /**
1150  * Handle completion
1151  *
1152  * @v ibdev             Infiniband device
1153  * @v cq                Completion queue
1154  * @v cqe               Hardware completion queue entry
1155  * @ret rc              Return status code
1156  */
1157 static int arbel_complete ( struct ib_device *ibdev,
1158                             struct ib_completion_queue *cq,
1159                             union arbelprm_completion_entry *cqe ) {
1160         struct arbel *arbel = ib_get_drvdata ( ibdev );
1161         struct ib_work_queue *wq;
1162         struct ib_queue_pair *qp;
1163         struct arbel_queue_pair *arbel_qp;
1164         struct arbel_send_work_queue *arbel_send_wq;
1165         struct arbel_recv_work_queue *arbel_recv_wq;
1166         struct arbelprm_recv_wqe *recv_wqe;
1167         struct io_buffer *iobuf;
1168         struct ib_address_vector av;
1169         struct ib_global_route_header *grh;
1170         unsigned int opcode;
1171         unsigned long qpn;
1172         int is_send;
1173         unsigned long wqe_adr;
1174         unsigned int wqe_idx;
1175         size_t len;
1176         int rc = 0;
1177
1178         /* Parse completion */
1179         qpn = MLX_GET ( &cqe->normal, my_qpn );
1180         is_send = MLX_GET ( &cqe->normal, s );
1181         wqe_adr = ( MLX_GET ( &cqe->normal, wqe_adr ) << 6 );
1182         opcode = MLX_GET ( &cqe->normal, opcode );
1183         if ( opcode >= ARBEL_OPCODE_RECV_ERROR ) {
1184                 /* "s" field is not valid for error opcodes */
1185                 is_send = ( opcode == ARBEL_OPCODE_SEND_ERROR );
1186                 DBGC ( arbel, "Arbel %p CPN %lx syndrome %x vendor %x\n",
1187                        arbel, cq->cqn, MLX_GET ( &cqe->error, syndrome ),
1188                        MLX_GET ( &cqe->error, vendor_code ) );
1189                 rc = -EIO;
1190                 /* Don't return immediately; propagate error to completer */
1191         }
1192
1193         /* Identify work queue */
1194         wq = ib_find_wq ( cq, qpn, is_send );
1195         if ( ! wq ) {
1196                 DBGC ( arbel, "Arbel %p CQN %lx unknown %s QPN %lx\n",
1197                        arbel, cq->cqn, ( is_send ? "send" : "recv" ), qpn );
1198                 return -EIO;
1199         }
1200         qp = wq->qp;
1201         arbel_qp = ib_qp_get_drvdata ( qp );
1202         arbel_send_wq = &arbel_qp->send;
1203         arbel_recv_wq = &arbel_qp->recv;
1204
1205         /* Identify work queue entry index */
1206         if ( is_send ) {
1207                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_send_wq->wqe ) ) /
1208                             sizeof ( arbel_send_wq->wqe[0] ) );
1209                 assert ( wqe_idx < qp->send.num_wqes );
1210         } else {
1211                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_recv_wq->wqe ) ) /
1212                             sizeof ( arbel_recv_wq->wqe[0] ) );
1213                 assert ( wqe_idx < qp->recv.num_wqes );
1214         }
1215
1216         /* Identify I/O buffer */
1217         iobuf = wq->iobufs[wqe_idx];
1218         if ( ! iobuf ) {
1219                 DBGC ( arbel, "Arbel %p CQN %lx QPN %lx empty WQE %x\n",
1220                        arbel, cq->cqn, qpn, wqe_idx );
1221                 return -EIO;
1222         }
1223         wq->iobufs[wqe_idx] = NULL;
1224
1225         if ( is_send ) {
1226                 /* Hand off to completion handler */
1227                 ib_complete_send ( ibdev, qp, iobuf, rc );
1228         } else {
1229                 /* Set received length */
1230                 len = MLX_GET ( &cqe->normal, byte_cnt );
1231                 recv_wqe = &arbel_recv_wq->wqe[wqe_idx].recv;
1232                 assert ( MLX_GET ( &recv_wqe->data[0], local_address_l ) ==
1233                          virt_to_bus ( iobuf->data ) );
1234                 assert ( MLX_GET ( &recv_wqe->data[0], byte_count ) ==
1235                          iob_tailroom ( iobuf ) );
1236                 MLX_FILL_1 ( &recv_wqe->data[0], 0, byte_count, 0 );
1237                 MLX_FILL_1 ( &recv_wqe->data[0], 1,
1238                              l_key, ARBEL_INVALID_LKEY );
1239                 assert ( len <= iob_tailroom ( iobuf ) );
1240                 iob_put ( iobuf, len );
1241                 assert ( iob_len ( iobuf ) >= sizeof ( *grh ) );
1242                 grh = iobuf->data;
1243                 iob_pull ( iobuf, sizeof ( *grh ) );
1244                 /* Construct address vector */
1245                 memset ( &av, 0, sizeof ( av ) );
1246                 av.qpn = MLX_GET ( &cqe->normal, rqpn );
1247                 av.lid = MLX_GET ( &cqe->normal, rlid );
1248                 av.sl = MLX_GET ( &cqe->normal, sl );
1249                 av.gid_present = MLX_GET ( &cqe->normal, g );
1250                 memcpy ( &av.gid, &grh->sgid, sizeof ( av.gid ) );
1251                 /* Hand off to completion handler */
1252                 ib_complete_recv ( ibdev, qp, &av, iobuf, rc );
1253         }
1254
1255         return rc;
1256 }                            
1257
1258 /**
1259  * Poll completion queue
1260  *
1261  * @v ibdev             Infiniband device
1262  * @v cq                Completion queue
1263  */
1264 static void arbel_poll_cq ( struct ib_device *ibdev,
1265                             struct ib_completion_queue *cq ) {
1266         struct arbel *arbel = ib_get_drvdata ( ibdev );
1267         struct arbel_completion_queue *arbel_cq = ib_cq_get_drvdata ( cq );
1268         struct arbelprm_cq_ci_db_record *ci_db_rec;
1269         union arbelprm_completion_entry *cqe;
1270         unsigned int cqe_idx_mask;
1271         int rc;
1272
1273         while ( 1 ) {
1274                 /* Look for completion entry */
1275                 cqe_idx_mask = ( cq->num_cqes - 1 );
1276                 cqe = &arbel_cq->cqe[cq->next_idx & cqe_idx_mask];
1277                 if ( MLX_GET ( &cqe->normal, owner ) != 0 ) {
1278                         /* Entry still owned by hardware; end of poll */
1279                         break;
1280                 }
1281
1282                 /* Handle completion */
1283                 if ( ( rc = arbel_complete ( ibdev, cq, cqe ) ) != 0 ) {
1284                         DBGC ( arbel, "Arbel %p failed to complete: %s\n",
1285                                arbel, strerror ( rc ) );
1286                         DBGC_HD ( arbel, cqe, sizeof ( *cqe ) );
1287                 }
1288
1289                 /* Return ownership to hardware */
1290                 MLX_FILL_1 ( &cqe->normal, 7, owner, 1 );
1291                 barrier();
1292                 /* Update completion queue's index */
1293                 cq->next_idx++;
1294                 /* Update doorbell record */
1295                 ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
1296                 MLX_FILL_1 ( ci_db_rec, 0,
1297                              counter, ( cq->next_idx & 0xffffffffUL ) );
1298         }
1299 }
1300
1301 /***************************************************************************
1302  *
1303  * Event queues
1304  *
1305  ***************************************************************************
1306  */
1307
1308 /**
1309  * Create event queue
1310  *
1311  * @v arbel             Arbel device
1312  * @ret rc              Return status code
1313  */
1314 static int arbel_create_eq ( struct arbel *arbel ) {
1315         struct arbel_event_queue *arbel_eq = &arbel->eq;
1316         struct arbelprm_eqc eqctx;
1317         struct arbelprm_event_mask mask;
1318         unsigned int i;
1319         int rc;
1320
1321         /* Select event queue number */
1322         arbel_eq->eqn = arbel->limits.reserved_eqs;
1323
1324         /* Calculate doorbell address */
1325         arbel_eq->doorbell = ( arbel->eq_ci_doorbells +
1326                                ARBEL_DB_EQ_OFFSET ( arbel_eq->eqn ) );
1327
1328         /* Allocate event queue itself */
1329         arbel_eq->eqe_size =
1330                 ( ARBEL_NUM_EQES * sizeof ( arbel_eq->eqe[0] ) );
1331         arbel_eq->eqe = malloc_dma ( arbel_eq->eqe_size,
1332                                      sizeof ( arbel_eq->eqe[0] ) );
1333         if ( ! arbel_eq->eqe ) {
1334                 rc = -ENOMEM;
1335                 goto err_eqe;
1336         }
1337         memset ( arbel_eq->eqe, 0, arbel_eq->eqe_size );
1338         for ( i = 0 ; i < ARBEL_NUM_EQES ; i++ ) {
1339                 MLX_FILL_1 ( &arbel_eq->eqe[i].generic, 7, owner, 1 );
1340         }
1341         barrier();
1342
1343         /* Hand queue over to hardware */
1344         memset ( &eqctx, 0, sizeof ( eqctx ) );
1345         MLX_FILL_1 ( &eqctx, 0, st, 0xa /* "Fired" */ );
1346         MLX_FILL_1 ( &eqctx, 2,
1347                      start_address_l, virt_to_phys ( arbel_eq->eqe ) );
1348         MLX_FILL_1 ( &eqctx, 3, log_eq_size, fls ( ARBEL_NUM_EQES - 1 ) );
1349         MLX_FILL_1 ( &eqctx, 6, pd, ARBEL_GLOBAL_PD );
1350         MLX_FILL_1 ( &eqctx, 7, lkey, arbel->reserved_lkey );
1351         if ( ( rc = arbel_cmd_sw2hw_eq ( arbel, arbel_eq->eqn,
1352                                          &eqctx ) ) != 0 ) {
1353                 DBGC ( arbel, "Arbel %p SW2HW_EQ failed: %s\n",
1354                        arbel, strerror ( rc ) );
1355                 goto err_sw2hw_eq;
1356         }
1357
1358         /* Map events to this event queue */
1359         memset ( &mask, 0, sizeof ( mask ) );
1360         MLX_FILL_1 ( &mask, 1, port_state_change, 1 );
1361         if ( ( rc = arbel_cmd_map_eq ( arbel,
1362                                        ( ARBEL_MAP_EQ | arbel_eq->eqn ),
1363                                        &mask ) ) != 0 ) {
1364                 DBGC ( arbel, "Arbel %p MAP_EQ failed: %s\n",
1365                        arbel, strerror ( rc )  );
1366                 goto err_map_eq;
1367         }
1368
1369         DBGC ( arbel, "Arbel %p EQN %#lx ring at [%p,%p])\n",
1370                arbel, arbel_eq->eqn, arbel_eq->eqe,
1371                ( ( ( void * ) arbel_eq->eqe ) + arbel_eq->eqe_size ) );
1372         return 0;
1373
1374  err_map_eq:
1375         arbel_cmd_hw2sw_eq ( arbel, arbel_eq->eqn, &eqctx );
1376  err_sw2hw_eq:
1377         free_dma ( arbel_eq->eqe, arbel_eq->eqe_size );
1378  err_eqe:
1379         memset ( arbel_eq, 0, sizeof ( *arbel_eq ) );
1380         return rc;
1381 }
1382
1383 /**
1384  * Destroy event queue
1385  *
1386  * @v arbel             Arbel device
1387  */
1388 static void arbel_destroy_eq ( struct arbel *arbel ) {
1389         struct arbel_event_queue *arbel_eq = &arbel->eq;
1390         struct arbelprm_eqc eqctx;
1391         struct arbelprm_event_mask mask;
1392         int rc;
1393
1394         /* Unmap events from event queue */
1395         memset ( &mask, 0, sizeof ( mask ) );
1396         MLX_FILL_1 ( &mask, 1, port_state_change, 1 );
1397         if ( ( rc = arbel_cmd_map_eq ( arbel,
1398                                        ( ARBEL_UNMAP_EQ | arbel_eq->eqn ),
1399                                        &mask ) ) != 0 ) {
1400                 DBGC ( arbel, "Arbel %p FATAL MAP_EQ failed to unmap: %s\n",
1401                        arbel, strerror ( rc ) );
1402                 /* Continue; HCA may die but system should survive */
1403         }
1404
1405         /* Take ownership back from hardware */
1406         if ( ( rc = arbel_cmd_hw2sw_eq ( arbel, arbel_eq->eqn,
1407                                          &eqctx ) ) != 0 ) {
1408                 DBGC ( arbel, "Arbel %p FATAL HW2SW_EQ failed: %s\n",
1409                        arbel, strerror ( rc ) );
1410                 /* Leak memory and return; at least we avoid corruption */
1411                 return;
1412         }
1413
1414         /* Free memory */
1415         free_dma ( arbel_eq->eqe, arbel_eq->eqe_size );
1416         memset ( arbel_eq, 0, sizeof ( *arbel_eq ) );
1417 }
1418
1419 /**
1420  * Handle port state event
1421  *
1422  * @v arbel             Arbel device
1423  * @v eqe               Port state change event queue entry
1424  */
1425 static void arbel_event_port_state_change ( struct arbel *arbel,
1426                                             union arbelprm_event_entry *eqe){
1427         unsigned int port;
1428         int link_up;
1429
1430         /* Get port and link status */
1431         port = ( MLX_GET ( &eqe->port_state_change, data.p ) - 1 );
1432         link_up = ( MLX_GET ( &eqe->generic, event_sub_type ) & 0x04 );
1433         DBGC ( arbel, "Arbel %p port %d link %s\n", arbel, ( port + 1 ),
1434                ( link_up ? "up" : "down" ) );
1435
1436         /* Sanity check */
1437         if ( port >= ARBEL_NUM_PORTS ) {
1438                 DBGC ( arbel, "Arbel %p port %d does not exist!\n",
1439                        arbel, ( port + 1 ) );
1440                 return;
1441         }
1442
1443         /* Update MAD parameters */
1444         ib_smc_update ( arbel->ibdev[port], arbel_mad );
1445
1446         /* Notify Infiniband core of link state change */
1447         ib_link_state_changed ( arbel->ibdev[port] );
1448 }
1449
1450 /**
1451  * Poll event queue
1452  *
1453  * @v ibdev             Infiniband device
1454  */
1455 static void arbel_poll_eq ( struct ib_device *ibdev ) {
1456         struct arbel *arbel = ib_get_drvdata ( ibdev );
1457         struct arbel_event_queue *arbel_eq = &arbel->eq;
1458         union arbelprm_event_entry *eqe;
1459         union arbelprm_eq_doorbell_register db_reg;
1460         unsigned int eqe_idx_mask;
1461         unsigned int event_type;
1462
1463         while ( 1 ) {
1464                 /* Look for event entry */
1465                 eqe_idx_mask = ( ARBEL_NUM_EQES - 1 );
1466                 eqe = &arbel_eq->eqe[arbel_eq->next_idx & eqe_idx_mask];
1467                 if ( MLX_GET ( &eqe->generic, owner ) != 0 ) {
1468                         /* Entry still owned by hardware; end of poll */
1469                         break;
1470                 }
1471                 DBGCP ( arbel, "Arbel %p event:\n", arbel );
1472                 DBGCP_HD ( arbel, eqe, sizeof ( *eqe ) );
1473
1474                 /* Handle event */
1475                 event_type = MLX_GET ( &eqe->generic, event_type );
1476                 switch ( event_type ) {
1477                 case ARBEL_EV_PORT_STATE_CHANGE:
1478                         arbel_event_port_state_change ( arbel, eqe );
1479                         break;
1480                 default:
1481                         DBGC ( arbel, "Arbel %p unrecognised event type "
1482                                "%#x:\n", arbel, event_type );
1483                         DBGC_HD ( arbel, eqe, sizeof ( *eqe ) );
1484                         break;
1485                 }
1486
1487                 /* Return ownership to hardware */
1488                 MLX_FILL_1 ( &eqe->generic, 7, owner, 1 );
1489                 barrier();
1490
1491                 /* Update event queue's index */
1492                 arbel_eq->next_idx++;
1493
1494                 /* Ring doorbell */
1495                 MLX_FILL_1 ( &db_reg.ci, 0, ci, arbel_eq->next_idx );
1496                 DBGCP ( arbel, "Ringing doorbell %08lx with %08x\n",
1497                         virt_to_phys ( arbel_eq->doorbell ),
1498                         db_reg.dword[0] );
1499                 writel ( db_reg.dword[0], arbel_eq->doorbell );
1500         }
1501 }
1502
1503 /***************************************************************************
1504  *
1505  * Infiniband link-layer operations
1506  *
1507  ***************************************************************************
1508  */
1509
1510 /**
1511  * Initialise Infiniband link
1512  *
1513  * @v ibdev             Infiniband device
1514  * @ret rc              Return status code
1515  */
1516 static int arbel_open ( struct ib_device *ibdev ) {
1517         struct arbel *arbel = ib_get_drvdata ( ibdev );
1518         struct arbelprm_init_ib init_ib;
1519         int rc;
1520
1521         memset ( &init_ib, 0, sizeof ( init_ib ) );
1522         MLX_FILL_3 ( &init_ib, 0,
1523                      mtu_cap, ARBEL_MTU_2048,
1524                      port_width_cap, 3,
1525                      vl_cap, 1 );
1526         MLX_FILL_1 ( &init_ib, 1, max_gid, 1 );
1527         MLX_FILL_1 ( &init_ib, 2, max_pkey, 64 );
1528         if ( ( rc = arbel_cmd_init_ib ( arbel, ibdev->port,
1529                                         &init_ib ) ) != 0 ) {
1530                 DBGC ( arbel, "Arbel %p could not intialise IB: %s\n",
1531                        arbel, strerror ( rc ) );
1532                 return rc;
1533         }
1534
1535         /* Update MAD parameters */
1536         ib_smc_update ( ibdev, arbel_mad );
1537
1538         return 0;
1539 }
1540
1541 /**
1542  * Close Infiniband link
1543  *
1544  * @v ibdev             Infiniband device
1545  */
1546 static void arbel_close ( struct ib_device *ibdev ) {
1547         struct arbel *arbel = ib_get_drvdata ( ibdev );
1548         int rc;
1549
1550         if ( ( rc = arbel_cmd_close_ib ( arbel, ibdev->port ) ) != 0 ) {
1551                 DBGC ( arbel, "Arbel %p could not close IB: %s\n",
1552                        arbel, strerror ( rc ) );
1553                 /* Nothing we can do about this */
1554         }
1555 }
1556
1557 /***************************************************************************
1558  *
1559  * Multicast group operations
1560  *
1561  ***************************************************************************
1562  */
1563
1564 /**
1565  * Attach to multicast group
1566  *
1567  * @v ibdev             Infiniband device
1568  * @v qp                Queue pair
1569  * @v gid               Multicast GID
1570  * @ret rc              Return status code
1571  */
1572 static int arbel_mcast_attach ( struct ib_device *ibdev,
1573                                 struct ib_queue_pair *qp,
1574                                 struct ib_gid *gid ) {
1575         struct arbel *arbel = ib_get_drvdata ( ibdev );
1576         struct arbelprm_mgm_hash hash;
1577         struct arbelprm_mgm_entry mgm;
1578         unsigned int index;
1579         int rc;
1580
1581         /* Generate hash table index */
1582         if ( ( rc = arbel_cmd_mgid_hash ( arbel, gid, &hash ) ) != 0 ) {
1583                 DBGC ( arbel, "Arbel %p could not hash GID: %s\n",
1584                        arbel, strerror ( rc ) );
1585                 return rc;
1586         }
1587         index = MLX_GET ( &hash, hash );
1588
1589         /* Check for existing hash table entry */
1590         if ( ( rc = arbel_cmd_read_mgm ( arbel, index, &mgm ) ) != 0 ) {
1591                 DBGC ( arbel, "Arbel %p could not read MGM %#x: %s\n",
1592                        arbel, index, strerror ( rc ) );
1593                 return rc;
1594         }
1595         if ( MLX_GET ( &mgm, mgmqp_0.qi ) != 0 ) {
1596                 /* FIXME: this implementation allows only a single QP
1597                  * per multicast group, and doesn't handle hash
1598                  * collisions.  Sufficient for IPoIB but may need to
1599                  * be extended in future.
1600                  */
1601                 DBGC ( arbel, "Arbel %p MGID index %#x already in use\n",
1602                        arbel, index );
1603                 return -EBUSY;
1604         }
1605
1606         /* Update hash table entry */
1607         MLX_FILL_2 ( &mgm, 8,
1608                      mgmqp_0.qpn_i, qp->qpn,
1609                      mgmqp_0.qi, 1 );
1610         memcpy ( &mgm.u.dwords[4], gid, sizeof ( *gid ) );
1611         if ( ( rc = arbel_cmd_write_mgm ( arbel, index, &mgm ) ) != 0 ) {
1612                 DBGC ( arbel, "Arbel %p could not write MGM %#x: %s\n",
1613                        arbel, index, strerror ( rc ) );
1614                 return rc;
1615         }
1616
1617         return 0;
1618 }
1619
1620 /**
1621  * Detach from multicast group
1622  *
1623  * @v ibdev             Infiniband device
1624  * @v qp                Queue pair
1625  * @v gid               Multicast GID
1626  */
1627 static void arbel_mcast_detach ( struct ib_device *ibdev,
1628                                  struct ib_queue_pair *qp __unused,
1629                                  struct ib_gid *gid ) {
1630         struct arbel *arbel = ib_get_drvdata ( ibdev );
1631         struct arbelprm_mgm_hash hash;
1632         struct arbelprm_mgm_entry mgm;
1633         unsigned int index;
1634         int rc;
1635
1636         /* Generate hash table index */
1637         if ( ( rc = arbel_cmd_mgid_hash ( arbel, gid, &hash ) ) != 0 ) {
1638                 DBGC ( arbel, "Arbel %p could not hash GID: %s\n",
1639                        arbel, strerror ( rc ) );
1640                 return;
1641         }
1642         index = MLX_GET ( &hash, hash );
1643
1644         /* Clear hash table entry */
1645         memset ( &mgm, 0, sizeof ( mgm ) );
1646         if ( ( rc = arbel_cmd_write_mgm ( arbel, index, &mgm ) ) != 0 ) {
1647                 DBGC ( arbel, "Arbel %p could not write MGM %#x: %s\n",
1648                        arbel, index, strerror ( rc ) );
1649                 return;
1650         }
1651 }
1652
1653 /** Arbel Infiniband operations */
1654 static struct ib_device_operations arbel_ib_operations = {
1655         .create_cq      = arbel_create_cq,
1656         .destroy_cq     = arbel_destroy_cq,
1657         .create_qp      = arbel_create_qp,
1658         .modify_qp      = arbel_modify_qp,
1659         .destroy_qp     = arbel_destroy_qp,
1660         .post_send      = arbel_post_send,
1661         .post_recv      = arbel_post_recv,
1662         .poll_cq        = arbel_poll_cq,
1663         .poll_eq        = arbel_poll_eq,
1664         .open           = arbel_open,
1665         .close          = arbel_close,
1666         .mcast_attach   = arbel_mcast_attach,
1667         .mcast_detach   = arbel_mcast_detach,
1668 };
1669
1670 /***************************************************************************
1671  *
1672  * Firmware control
1673  *
1674  ***************************************************************************
1675  */
1676
1677 /**
1678  * Start firmware running
1679  *
1680  * @v arbel             Arbel device
1681  * @ret rc              Return status code
1682  */
1683 static int arbel_start_firmware ( struct arbel *arbel ) {
1684         struct arbelprm_query_fw fw;
1685         struct arbelprm_access_lam lam;
1686         struct arbelprm_virtual_physical_mapping map_fa;
1687         unsigned int fw_pages;
1688         unsigned int log2_fw_pages;
1689         size_t fw_size;
1690         physaddr_t fw_base;
1691         uint64_t eq_set_ci_base_addr;
1692         int rc;
1693
1694         /* Get firmware parameters */
1695         if ( ( rc = arbel_cmd_query_fw ( arbel, &fw ) ) != 0 ) {
1696                 DBGC ( arbel, "Arbel %p could not query firmware: %s\n",
1697                        arbel, strerror ( rc ) );
1698                 goto err_query_fw;
1699         }
1700         DBGC ( arbel, "Arbel %p firmware version %d.%d.%d\n", arbel,
1701                MLX_GET ( &fw, fw_rev_major ), MLX_GET ( &fw, fw_rev_minor ),
1702                MLX_GET ( &fw, fw_rev_subminor ) );
1703         fw_pages = MLX_GET ( &fw, fw_pages );
1704         log2_fw_pages = fls ( fw_pages - 1 );
1705         fw_pages = ( 1 << log2_fw_pages );
1706         DBGC ( arbel, "Arbel %p requires %d kB for firmware\n",
1707                arbel, ( fw_pages * 4 ) );
1708         eq_set_ci_base_addr =
1709                 ( ( (uint64_t) MLX_GET ( &fw, eq_set_ci_base_addr_h ) << 32 ) |
1710                   ( (uint64_t) MLX_GET ( &fw, eq_set_ci_base_addr_l ) ) );
1711         arbel->eq_ci_doorbells = ioremap ( eq_set_ci_base_addr, 0x200 );
1712
1713         /* Enable locally-attached memory.  Ignore failure; there may
1714          * be no attached memory.
1715          */
1716         arbel_cmd_enable_lam ( arbel, &lam );
1717
1718         /* Allocate firmware pages and map firmware area */
1719         fw_size = ( fw_pages * 4096 );
1720         arbel->firmware_area = umalloc ( fw_size * 2 );
1721         if ( ! arbel->firmware_area ) {
1722                 rc = -ENOMEM;
1723                 goto err_alloc_fa;
1724         }
1725         fw_base = ( user_to_phys ( arbel->firmware_area, fw_size ) &
1726                     ~( fw_size - 1 ) );
1727         DBGC ( arbel, "Arbel %p firmware area at physical [%lx,%lx)\n",
1728                arbel, fw_base, ( fw_base + fw_size ) );
1729         memset ( &map_fa, 0, sizeof ( map_fa ) );
1730         MLX_FILL_2 ( &map_fa, 3,
1731                      log2size, log2_fw_pages,
1732                      pa_l, ( fw_base >> 12 ) );
1733         if ( ( rc = arbel_cmd_map_fa ( arbel, &map_fa ) ) != 0 ) {
1734                 DBGC ( arbel, "Arbel %p could not map firmware: %s\n",
1735                        arbel, strerror ( rc ) );
1736                 goto err_map_fa;
1737         }
1738
1739         /* Start firmware */
1740         if ( ( rc = arbel_cmd_run_fw ( arbel ) ) != 0 ) {
1741                 DBGC ( arbel, "Arbel %p could not run firmware: %s\n",
1742                        arbel, strerror ( rc ) );
1743                 goto err_run_fw;
1744         }
1745
1746         DBGC ( arbel, "Arbel %p firmware started\n", arbel );
1747         return 0;
1748
1749  err_run_fw:
1750         arbel_cmd_unmap_fa ( arbel );
1751  err_map_fa:
1752         ufree ( arbel->firmware_area );
1753         arbel->firmware_area = UNULL;
1754  err_alloc_fa:
1755  err_query_fw:
1756         return rc;
1757 }
1758
1759 /**
1760  * Stop firmware running
1761  *
1762  * @v arbel             Arbel device
1763  */
1764 static void arbel_stop_firmware ( struct arbel *arbel ) {
1765         int rc;
1766
1767         if ( ( rc = arbel_cmd_unmap_fa ( arbel ) ) != 0 ) {
1768                 DBGC ( arbel, "Arbel %p FATAL could not stop firmware: %s\n",
1769                        arbel, strerror ( rc ) );
1770                 /* Leak memory and return; at least we avoid corruption */
1771                 return;
1772         }
1773         ufree ( arbel->firmware_area );
1774         arbel->firmware_area = UNULL;
1775 }
1776
1777 /***************************************************************************
1778  *
1779  * Infinihost Context Memory management
1780  *
1781  ***************************************************************************
1782  */
1783
1784 /**
1785  * Get device limits
1786  *
1787  * @v arbel             Arbel device
1788  * @ret rc              Return status code
1789  */
1790 static int arbel_get_limits ( struct arbel *arbel ) {
1791         struct arbelprm_query_dev_lim dev_lim;
1792         int rc;
1793
1794         if ( ( rc = arbel_cmd_query_dev_lim ( arbel, &dev_lim ) ) != 0 ) {
1795                 DBGC ( arbel, "Arbel %p could not get device limits: %s\n",
1796                        arbel, strerror ( rc ) );
1797                 return rc;
1798         }
1799
1800         arbel->limits.reserved_qps =
1801                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_qps ) );
1802         arbel->limits.qpc_entry_size = MLX_GET ( &dev_lim, qpc_entry_sz );
1803         arbel->limits.eqpc_entry_size = MLX_GET ( &dev_lim, eqpc_entry_sz );
1804         arbel->limits.reserved_srqs =
1805                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_srqs ) );
1806         arbel->limits.srqc_entry_size = MLX_GET ( &dev_lim, srq_entry_sz );
1807         arbel->limits.reserved_ees =
1808                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_ees ) );
1809         arbel->limits.eec_entry_size = MLX_GET ( &dev_lim, eec_entry_sz );
1810         arbel->limits.eeec_entry_size = MLX_GET ( &dev_lim, eeec_entry_sz );
1811         arbel->limits.reserved_cqs =
1812                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_cqs ) );
1813         arbel->limits.cqc_entry_size = MLX_GET ( &dev_lim, cqc_entry_sz );
1814         arbel->limits.reserved_eqs = MLX_GET ( &dev_lim, num_rsvd_eqs );
1815         arbel->limits.reserved_mtts =
1816                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_mtts ) );
1817         arbel->limits.mtt_entry_size = MLX_GET ( &dev_lim, mtt_entry_sz );
1818         arbel->limits.reserved_mrws =
1819                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_mrws ) );
1820         arbel->limits.mpt_entry_size = MLX_GET ( &dev_lim, mpt_entry_sz );
1821         arbel->limits.reserved_rdbs =
1822                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_rdbs ) );
1823         arbel->limits.eqc_entry_size = MLX_GET ( &dev_lim, eqc_entry_sz );
1824         arbel->limits.reserved_uars = MLX_GET ( &dev_lim, num_rsvd_uars );
1825
1826         return 0;
1827 }
1828
1829 /**
1830  * Get ICM usage
1831  *
1832  * @v log_num_entries   Log2 of the number of entries
1833  * @v entry_size        Entry size
1834  * @ret usage           Usage size in ICM
1835  */
1836 static size_t icm_usage ( unsigned int log_num_entries, size_t entry_size ) {
1837         size_t usage;
1838
1839         usage = ( ( 1 << log_num_entries ) * entry_size );
1840         usage = ( ( usage + 4095 ) & ~4095 );
1841         return usage;
1842 }
1843
1844 /**
1845  * Allocate ICM
1846  *
1847  * @v arbel             Arbel device
1848  * @v init_hca          INIT_HCA structure to fill in
1849  * @ret rc              Return status code
1850  */
1851 static int arbel_alloc_icm ( struct arbel *arbel,
1852                              struct arbelprm_init_hca *init_hca ) {
1853         struct arbelprm_scalar_parameter icm_size;
1854         struct arbelprm_scalar_parameter icm_aux_size;
1855         struct arbelprm_virtual_physical_mapping map_icm_aux;
1856         struct arbelprm_virtual_physical_mapping map_icm;
1857         union arbelprm_doorbell_record *db_rec;
1858         size_t icm_offset = 0;
1859         unsigned int log_num_qps, log_num_srqs, log_num_ees, log_num_cqs;
1860         unsigned int log_num_mtts, log_num_mpts, log_num_rdbs, log_num_eqs;
1861         int rc;
1862
1863         icm_offset = ( ( arbel->limits.reserved_uars + 1 ) << 12 );
1864
1865         /* Queue pair contexts */
1866         log_num_qps = fls ( arbel->limits.reserved_qps + ARBEL_MAX_QPS - 1 );
1867         MLX_FILL_2 ( init_hca, 13,
1868                      qpc_eec_cqc_eqc_rdb_parameters.qpc_base_addr_l,
1869                      ( icm_offset >> 7 ),
1870                      qpc_eec_cqc_eqc_rdb_parameters.log_num_of_qp,
1871                      log_num_qps );
1872         DBGC ( arbel, "Arbel %p ICM QPC base = %zx\n", arbel, icm_offset );
1873         icm_offset += icm_usage ( log_num_qps, arbel->limits.qpc_entry_size );
1874
1875         /* Extended queue pair contexts */
1876         MLX_FILL_1 ( init_hca, 25,
1877                      qpc_eec_cqc_eqc_rdb_parameters.eqpc_base_addr_l,
1878                      icm_offset );
1879         DBGC ( arbel, "Arbel %p ICM EQPC base = %zx\n", arbel, icm_offset );
1880         //      icm_offset += icm_usage ( log_num_qps, arbel->limits.eqpc_entry_size );
1881         icm_offset += icm_usage ( log_num_qps, arbel->limits.qpc_entry_size );  
1882
1883         /* Shared receive queue contexts */
1884         log_num_srqs = fls ( arbel->limits.reserved_srqs - 1 );
1885         MLX_FILL_2 ( init_hca, 19,
1886                      qpc_eec_cqc_eqc_rdb_parameters.srqc_base_addr_l,
1887                      ( icm_offset >> 5 ),
1888                      qpc_eec_cqc_eqc_rdb_parameters.log_num_of_srq,
1889                      log_num_srqs );
1890         DBGC ( arbel, "Arbel %p ICM SRQC base = %zx\n", arbel, icm_offset );
1891         icm_offset += icm_usage ( log_num_srqs, arbel->limits.srqc_entry_size );
1892
1893         /* End-to-end contexts */
1894         log_num_ees = fls ( arbel->limits.reserved_ees - 1 );
1895         MLX_FILL_2 ( init_hca, 17,
1896                      qpc_eec_cqc_eqc_rdb_parameters.eec_base_addr_l,
1897                      ( icm_offset >> 7 ),
1898                      qpc_eec_cqc_eqc_rdb_parameters.log_num_of_ee,
1899                      log_num_ees );
1900         DBGC ( arbel, "Arbel %p ICM EEC base = %zx\n", arbel, icm_offset );
1901         icm_offset += icm_usage ( log_num_ees, arbel->limits.eec_entry_size );
1902
1903         /* Extended end-to-end contexts */
1904         MLX_FILL_1 ( init_hca, 29,
1905                      qpc_eec_cqc_eqc_rdb_parameters.eeec_base_addr_l,
1906                      icm_offset );
1907         DBGC ( arbel, "Arbel %p ICM EEEC base = %zx\n", arbel, icm_offset );
1908         icm_offset += icm_usage ( log_num_ees, arbel->limits.eeec_entry_size );
1909
1910         /* Completion queue contexts */
1911         log_num_cqs = fls ( arbel->limits.reserved_cqs + ARBEL_MAX_CQS - 1 );
1912         MLX_FILL_2 ( init_hca, 21,
1913                      qpc_eec_cqc_eqc_rdb_parameters.cqc_base_addr_l,
1914                      ( icm_offset >> 6 ),
1915                      qpc_eec_cqc_eqc_rdb_parameters.log_num_of_cq,
1916                      log_num_cqs );
1917         DBGC ( arbel, "Arbel %p ICM CQC base = %zx\n", arbel, icm_offset );
1918         icm_offset += icm_usage ( log_num_cqs, arbel->limits.cqc_entry_size );
1919
1920         /* Memory translation table */
1921         log_num_mtts = fls ( arbel->limits.reserved_mtts - 1 );
1922         MLX_FILL_1 ( init_hca, 65,
1923                      tpt_parameters.mtt_base_addr_l, icm_offset );
1924         DBGC ( arbel, "Arbel %p ICM MTT base = %zx\n", arbel, icm_offset );
1925         icm_offset += icm_usage ( log_num_mtts, arbel->limits.mtt_entry_size );
1926
1927         /* Memory protection table */
1928         log_num_mpts = fls ( arbel->limits.reserved_mrws + 1 - 1 );
1929         MLX_FILL_1 ( init_hca, 61,
1930                      tpt_parameters.mpt_base_adr_l, icm_offset );
1931         MLX_FILL_1 ( init_hca, 62,
1932                      tpt_parameters.log_mpt_sz, log_num_mpts );
1933         DBGC ( arbel, "Arbel %p ICM MTT base = %zx\n", arbel, icm_offset );
1934         icm_offset += icm_usage ( log_num_mpts, arbel->limits.mpt_entry_size );
1935
1936         /* RDMA something or other */
1937         log_num_rdbs = fls ( arbel->limits.reserved_rdbs - 1 );
1938         MLX_FILL_1 ( init_hca, 37,
1939                      qpc_eec_cqc_eqc_rdb_parameters.rdb_base_addr_l,
1940                      icm_offset );
1941         DBGC ( arbel, "Arbel %p ICM RDB base = %zx\n", arbel, icm_offset );
1942         icm_offset += icm_usage ( log_num_rdbs, 32 );
1943
1944         /* Event queue contexts */
1945         log_num_eqs =  fls ( arbel->limits.reserved_eqs + ARBEL_MAX_EQS - 1 );
1946         MLX_FILL_2 ( init_hca, 33,
1947                      qpc_eec_cqc_eqc_rdb_parameters.eqc_base_addr_l,
1948                      ( icm_offset >> 6 ),
1949                      qpc_eec_cqc_eqc_rdb_parameters.log_num_eq,
1950                      log_num_eqs );
1951         DBGC ( arbel, "Arbel %p ICM EQ base = %zx\n", arbel, icm_offset );
1952         icm_offset += ( ( 1 << log_num_eqs ) * arbel->limits.eqc_entry_size );
1953
1954         /* Multicast table */
1955         MLX_FILL_1 ( init_hca, 49,
1956                      multicast_parameters.mc_base_addr_l, icm_offset );
1957         MLX_FILL_1 ( init_hca, 52,
1958                      multicast_parameters.log_mc_table_entry_sz,
1959                      fls ( sizeof ( struct arbelprm_mgm_entry ) - 1 ) );
1960         MLX_FILL_1 ( init_hca, 53,
1961                      multicast_parameters.mc_table_hash_sz, 8 );
1962         MLX_FILL_1 ( init_hca, 54,
1963                      multicast_parameters.log_mc_table_sz, 3 );
1964         DBGC ( arbel, "Arbel %p ICM MC base = %zx\n", arbel, icm_offset );
1965         icm_offset += ( 8 * sizeof ( struct arbelprm_mgm_entry ) );
1966
1967         arbel->icm_len = icm_offset;
1968         arbel->icm_len = ( ( arbel->icm_len + 4095 ) & ~4095 );
1969
1970         /* Get ICM auxiliary area size */
1971         memset ( &icm_size, 0, sizeof ( icm_size ) );
1972         MLX_FILL_1 ( &icm_size, 1, value, arbel->icm_len );
1973         if ( ( rc = arbel_cmd_set_icm_size ( arbel, &icm_size,
1974                                              &icm_aux_size ) ) != 0 ) {
1975                 DBGC ( arbel, "Arbel %p could not set ICM size: %s\n",
1976                        arbel, strerror ( rc ) );
1977                 goto err_set_icm_size;
1978         }
1979         arbel->icm_aux_len = ( MLX_GET ( &icm_aux_size, value ) * 4096 );
1980
1981         /* Allocate ICM data and auxiliary area */
1982         DBGC ( arbel, "Arbel %p requires %zd kB ICM and %zd kB AUX ICM\n",
1983                arbel, ( arbel->icm_len / 1024 ),
1984                ( arbel->icm_aux_len / 1024 ) );
1985         arbel->icm = umalloc ( arbel->icm_len + arbel->icm_aux_len );
1986         if ( ! arbel->icm ) {
1987                 rc = -ENOMEM;
1988                 goto err_alloc;
1989         }
1990
1991         /* Map ICM auxiliary area */
1992         memset ( &map_icm_aux, 0, sizeof ( map_icm_aux ) );
1993         MLX_FILL_2 ( &map_icm_aux, 3,
1994                      log2size, fls ( ( arbel->icm_aux_len / 4096 ) - 1 ),
1995                      pa_l,
1996                      ( user_to_phys ( arbel->icm, arbel->icm_len ) >> 12 ) );
1997         if ( ( rc = arbel_cmd_map_icm_aux ( arbel, &map_icm_aux ) ) != 0 ) {
1998                 DBGC ( arbel, "Arbel %p could not map AUX ICM: %s\n",
1999                        arbel, strerror ( rc ) );
2000                 goto err_map_icm_aux;
2001         }
2002
2003         /* MAP ICM area */
2004         memset ( &map_icm, 0, sizeof ( map_icm ) );
2005         MLX_FILL_2 ( &map_icm, 3,
2006                      log2size, fls ( ( arbel->icm_len / 4096 ) - 1 ),
2007                      pa_l, ( user_to_phys ( arbel->icm, 0 ) >> 12 ) );
2008         if ( ( rc = arbel_cmd_map_icm ( arbel, &map_icm ) ) != 0 ) {
2009                 DBGC ( arbel, "Arbel %p could not map ICM: %s\n",
2010                        arbel, strerror ( rc ) );
2011                 goto err_map_icm;
2012         }
2013
2014         /* Initialise UAR context */
2015         arbel->db_rec = phys_to_virt ( user_to_phys ( arbel->icm, 0 ) +
2016                                        ( arbel->limits.reserved_uars *
2017                                          ARBEL_PAGE_SIZE ) );
2018         memset ( arbel->db_rec, 0, ARBEL_PAGE_SIZE );
2019         db_rec = &arbel->db_rec[ARBEL_GROUP_SEPARATOR_DOORBELL];
2020         MLX_FILL_1 ( &db_rec->qp, 1, res, ARBEL_UAR_RES_GROUP_SEP );
2021
2022         return 0;
2023
2024         arbel_cmd_unmap_icm ( arbel, ( arbel->icm_len / 4096 ) );
2025  err_map_icm:
2026         arbel_cmd_unmap_icm_aux ( arbel );
2027  err_map_icm_aux:
2028         ufree ( arbel->icm );
2029         arbel->icm = UNULL;
2030  err_alloc:
2031  err_set_icm_size:
2032         return rc;
2033 }
2034
2035 /**
2036  * Free ICM
2037  *
2038  * @v arbel             Arbel device
2039  */
2040 static void arbel_free_icm ( struct arbel *arbel ) {
2041         arbel_cmd_unmap_icm ( arbel, ( arbel->icm_len / 4096 ) );
2042         arbel_cmd_unmap_icm_aux ( arbel );
2043         ufree ( arbel->icm );
2044         arbel->icm = UNULL;
2045 }
2046
2047 /***************************************************************************
2048  *
2049  * PCI interface
2050  *
2051  ***************************************************************************
2052  */
2053
2054 /**
2055  * Set up memory protection table
2056  *
2057  * @v arbel             Arbel device
2058  * @ret rc              Return status code
2059  */
2060 static int arbel_setup_mpt ( struct arbel *arbel ) {
2061         struct arbelprm_mpt mpt;
2062         uint32_t key;
2063         int rc;
2064
2065         /* Derive key */
2066         key = ( arbel->limits.reserved_mrws | ARBEL_MKEY_PREFIX );
2067         arbel->reserved_lkey = ( ( key << 8 ) | ( key >> 24 ) );
2068
2069         /* Initialise memory protection table */
2070         memset ( &mpt, 0, sizeof ( mpt ) );
2071         MLX_FILL_4 ( &mpt, 0,
2072                      r_w, 1,
2073                      pa, 1,
2074                      lr, 1,
2075                      lw, 1 );
2076         MLX_FILL_1 ( &mpt, 2, mem_key, key );
2077         MLX_FILL_1 ( &mpt, 3, pd, ARBEL_GLOBAL_PD );
2078         MLX_FILL_1 ( &mpt, 6, reg_wnd_len_h, 0xffffffffUL );
2079         MLX_FILL_1 ( &mpt, 7, reg_wnd_len_l, 0xffffffffUL );
2080         if ( ( rc = arbel_cmd_sw2hw_mpt ( arbel, arbel->limits.reserved_mrws,
2081                                           &mpt ) ) != 0 ) {
2082                 DBGC ( arbel, "Arbel %p could not set up MPT: %s\n",
2083                        arbel, strerror ( rc ) );
2084                 return rc;
2085         }
2086
2087         return 0;
2088 }
2089         
2090 /**
2091  * Probe PCI device
2092  *
2093  * @v pci               PCI device
2094  * @v id                PCI ID
2095  * @ret rc              Return status code
2096  */
2097 static int arbel_probe ( struct pci_device *pci,
2098                          const struct pci_device_id *id __unused ) {
2099         struct arbel *arbel;
2100         struct ib_device *ibdev;
2101         struct arbelprm_init_hca init_hca;
2102         int i;
2103         int rc;
2104
2105         /* Allocate Arbel device */
2106         arbel = zalloc ( sizeof ( *arbel ) );
2107         if ( ! arbel ) {
2108                 rc = -ENOMEM;
2109                 goto err_alloc_arbel;
2110         }
2111         pci_set_drvdata ( pci, arbel );
2112
2113         /* Allocate Infiniband devices */
2114         for ( i = 0 ; i < ARBEL_NUM_PORTS ; i++ ) {
2115                 ibdev = alloc_ibdev ( 0 );
2116                 if ( ! ibdev ) {
2117                         rc = -ENOMEM;
2118                         goto err_alloc_ibdev;
2119                 }
2120                 arbel->ibdev[i] = ibdev;
2121                 ibdev->op = &arbel_ib_operations;
2122                 ibdev->dev = &pci->dev;
2123                 ibdev->port = ( ARBEL_PORT_BASE + i );
2124                 ib_set_drvdata ( ibdev, arbel );
2125         }
2126
2127         /* Fix up PCI device */
2128         adjust_pci_device ( pci );
2129
2130         /* Get PCI BARs */
2131         arbel->config = ioremap ( pci_bar_start ( pci, ARBEL_PCI_CONFIG_BAR ),
2132                                   ARBEL_PCI_CONFIG_BAR_SIZE );
2133         arbel->uar = ioremap ( ( pci_bar_start ( pci, ARBEL_PCI_UAR_BAR ) +
2134                                  ARBEL_PCI_UAR_IDX * ARBEL_PCI_UAR_SIZE ),
2135                                ARBEL_PCI_UAR_SIZE );
2136
2137         /* Allocate space for mailboxes */
2138         arbel->mailbox_in = malloc_dma ( ARBEL_MBOX_SIZE, ARBEL_MBOX_ALIGN );
2139         if ( ! arbel->mailbox_in ) {
2140                 rc = -ENOMEM;
2141                 goto err_mailbox_in;
2142         }
2143         arbel->mailbox_out = malloc_dma ( ARBEL_MBOX_SIZE, ARBEL_MBOX_ALIGN );
2144         if ( ! arbel->mailbox_out ) {
2145                 rc = -ENOMEM;
2146                 goto err_mailbox_out;
2147         }
2148
2149         /* Start firmware */
2150         if ( ( rc = arbel_start_firmware ( arbel ) ) != 0 )
2151                 goto err_start_firmware;
2152
2153         /* Get device limits */
2154         if ( ( rc = arbel_get_limits ( arbel ) ) != 0 )
2155                 goto err_get_limits;
2156
2157         /* Allocate ICM */
2158         memset ( &init_hca, 0, sizeof ( init_hca ) );
2159         if ( ( rc = arbel_alloc_icm ( arbel, &init_hca ) ) != 0 )
2160                 goto err_alloc_icm;
2161
2162         /* Initialise HCA */
2163         MLX_FILL_1 ( &init_hca, 74, uar_parameters.log_max_uars, 1 );
2164         if ( ( rc = arbel_cmd_init_hca ( arbel, &init_hca ) ) != 0 ) {
2165                 DBGC ( arbel, "Arbel %p could not initialise HCA: %s\n",
2166                        arbel, strerror ( rc ) );
2167                 goto err_init_hca;
2168         }
2169
2170         /* Set up memory protection */
2171         if ( ( rc = arbel_setup_mpt ( arbel ) ) != 0 )
2172                 goto err_setup_mpt;
2173
2174         /* Set up event queue */
2175         if ( ( rc = arbel_create_eq ( arbel ) ) != 0 )
2176                 goto err_create_eq;
2177
2178         /* Update MAD parameters */
2179         for ( i = 0 ; i < ARBEL_NUM_PORTS ; i++ )
2180                 ib_smc_update ( arbel->ibdev[i], arbel_mad );
2181
2182         /* Register Infiniband devices */
2183         for ( i = 0 ; i < ARBEL_NUM_PORTS ; i++ ) {
2184                 if ( ( rc = register_ibdev ( arbel->ibdev[i] ) ) != 0 ) {
2185                         DBGC ( arbel, "Arbel %p could not register IB "
2186                                "device: %s\n", arbel, strerror ( rc ) );
2187                         goto err_register_ibdev;
2188                 }
2189         }
2190
2191         return 0;
2192
2193         i = ARBEL_NUM_PORTS;
2194  err_register_ibdev:
2195         for ( i-- ; i >= 0 ; i-- )
2196                 unregister_ibdev ( arbel->ibdev[i] );
2197         arbel_destroy_eq ( arbel );
2198  err_create_eq:
2199  err_setup_mpt:
2200         arbel_cmd_close_hca ( arbel );
2201  err_init_hca:
2202         arbel_free_icm ( arbel );
2203  err_alloc_icm:
2204  err_get_limits:
2205         arbel_stop_firmware ( arbel );
2206  err_start_firmware:
2207         free_dma ( arbel->mailbox_out, ARBEL_MBOX_SIZE );
2208  err_mailbox_out:
2209         free_dma ( arbel->mailbox_in, ARBEL_MBOX_SIZE );
2210  err_mailbox_in:
2211         i = ARBEL_NUM_PORTS;
2212  err_alloc_ibdev:
2213         for ( i-- ; i >= 0 ; i-- )
2214                 ibdev_put ( arbel->ibdev[i] );
2215         free ( arbel );
2216  err_alloc_arbel:
2217         return rc;
2218 }
2219
2220 /**
2221  * Remove PCI device
2222  *
2223  * @v pci               PCI device
2224  */
2225 static void arbel_remove ( struct pci_device *pci ) {
2226         struct arbel *arbel = pci_get_drvdata ( pci );
2227         int i;
2228
2229         for ( i = ( ARBEL_NUM_PORTS - 1 ) ; i >= 0 ; i-- )
2230                 unregister_ibdev ( arbel->ibdev[i] );
2231         arbel_destroy_eq ( arbel );
2232         arbel_cmd_close_hca ( arbel );
2233         arbel_free_icm ( arbel );
2234         arbel_stop_firmware ( arbel );
2235         arbel_stop_firmware ( arbel );
2236         free_dma ( arbel->mailbox_out, ARBEL_MBOX_SIZE );
2237         free_dma ( arbel->mailbox_in, ARBEL_MBOX_SIZE );
2238         for ( i = ( ARBEL_NUM_PORTS - 1 ) ; i >= 0 ; i-- )
2239                 ibdev_put ( arbel->ibdev[i] );
2240         free ( arbel );
2241 }
2242
2243 static struct pci_device_id arbel_nics[] = {
2244         PCI_ROM ( 0x15b3, 0x6282, "mt25218", "MT25218 HCA driver" ),
2245         PCI_ROM ( 0x15b3, 0x6274, "mt25204", "MT25204 HCA driver" ),
2246 };
2247
2248 struct pci_driver arbel_driver __pci_driver = {
2249         .ids = arbel_nics,
2250         .id_count = ( sizeof ( arbel_nics ) / sizeof ( arbel_nics[0] ) ),
2251         .probe = arbel_probe,
2252         .remove = arbel_remove,
2253 };