src/drivers/net/mlx_ipoib/mt25218.c

   1 /**************************************************************************
   2 Etherboot -  BOOTP/TFTP Bootstrap Program
   3 Skeleton NIC driver for Etherboot
   4 ***************************************************************************/
   5
   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, or (at
  10  * your option) any later version.
  11  */
  12
  13 #include <errno.h>
  14 #include <gpxe/pci.h>
  15 #include <gpxe/malloc.h>
  16 #include <gpxe/iobuf.h>
  17 #include <gpxe/netdevice.h>
  18 #include <gpxe/infiniband.h>
  19
  20 /* to get some global routines like printf */
  21 #include "etherboot.h"
  22 /* to get the interface to the body of the program */
  23 #include "nic.h"
  24
  25 #include "mt25218_imp.c"
  26
  27 #include "arbel.h"
  28
  29
  30 static const struct ib_gid arbel_no_gid = {
  31         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 }
  32 };
  33
  34
  35 #define MLX_RX_MAX_FILL NUM_IPOIB_RCV_WQES
  36
  37 struct mlx_nic {
  38         /** Queue pair handle */
  39         udqp_t ipoib_qph;
  40         /** Broadcast Address Vector */
  41         ud_av_t bcast_av;
  42         /** Send completion queue */
  43         cq_t snd_cqh;
  44         /** Receive completion queue */
  45         cq_t rcv_cqh;
  46
  47         /** RX fill level */
  48         unsigned int rx_fill;
  49 };
  50
  51
  52 static struct io_buffer *static_ipoib_tx_ring[NUM_IPOIB_SND_WQES];
  53 static struct io_buffer *static_ipoib_rx_ring[NUM_IPOIB_RCV_WQES];
  54
  55 static struct arbel static_arbel;
  56
  57 static struct arbel_completion_queue static_arbel_ipoib_send_cq = {
  58         .ci_doorbell_idx = IPOIB_SND_CQ_CI_DB_IDX,
  59 };
  60 static struct ib_completion_queue static_ipoib_send_cq = {
  61         .cqn = 1234, /* Only used for debug messages */
  62         .num_cqes = NUM_IPOIB_SND_CQES,
  63         .work_queues = LIST_HEAD_INIT ( static_ipoib_send_cq.work_queues ),
  64         .dev_priv = &static_arbel_ipoib_send_cq,
  65 };
  66
  67 static struct arbel_completion_queue static_arbel_ipoib_recv_cq = {
  68         .ci_doorbell_idx = IPOIB_RCV_CQ_CI_DB_IDX,
  69 };
  70 static struct ib_completion_queue static_ipoib_recv_cq = {
  71         .cqn = 2345, /* Only used for debug messages */
  72         .num_cqes = NUM_IPOIB_RCV_CQES,
  73         .work_queues = LIST_HEAD_INIT ( static_ipoib_recv_cq.work_queues ),
  74         .dev_priv = &static_arbel_ipoib_recv_cq,
  75 };
  76
  77 static struct arbel_queue_pair static_arbel_ipoib_qp = {
  78         .send = {
  79                 .doorbell_idx = IPOIB_SND_QP_DB_IDX,
  80         },
  81         .recv = {
  82                 .doorbell_idx = IPOIB_RCV_QP_DB_IDX,
  83         },
  84 };
  85 static struct ib_queue_pair static_ipoib_qp = {
  86         .send = {
  87                 .qp = &static_ipoib_qp,
  88                 .is_send = 1,
  89                 .cq = &static_ipoib_send_cq,
  90                 .num_wqes = NUM_IPOIB_SND_WQES,
  91                 .iobufs = static_ipoib_tx_ring,
  92                 .list = LIST_HEAD_INIT (static_ipoib_qp.send.list),
  93                 .dev_priv = &static_arbel_ipoib_qp.send,
  94         },
  95         .recv = {
  96                 .qp = &static_ipoib_qp,
  97                 .is_send = 0,
  98                 .cq = &static_ipoib_recv_cq,
  99                 .num_wqes = NUM_IPOIB_RCV_WQES,
 100                 .iobufs = static_ipoib_rx_ring,
 101                 .list = LIST_HEAD_INIT (static_ipoib_qp.recv.list),
 102                 .dev_priv = &static_arbel_ipoib_qp.recv,
 103         },
 104         .dev_priv = &static_arbel_ipoib_qp,
 105 };
 106
 107
 108 static struct ib_device static_ibdev = {
 109         .dev_priv = &static_arbel,
 110 };
 111
 112
 113 /**
 114  * Open network device
 115  *
 116  * @v netdev            Network device
 117  * @ret rc              Return status code
 118  */
 119 static int mlx_open ( struct net_device *netdev ) {
 120
 121         ( void ) netdev;
 122
 123         return 0;
 124 }
 125
 126 /**
 127  * Close network device
 128  *
 129  * @v netdev            Network device
 130  */
 131 static void mlx_close ( struct net_device *netdev ) {
 132
 133         ( void ) netdev;
 134
 135 }
 136
 137 static int arbel_post_send ( struct ib_device *ibdev,
 138                              struct ib_queue_pair *qp,
 139                              struct ib_address_vector *av,
 140                              struct io_buffer *iobuf );
 141
 142 static int mlx_transmit_direct ( struct net_device *netdev,
 143                                  struct io_buffer *iobuf ) {
 144         struct mlx_nic *mlx = netdev->priv;
 145         int rc;
 146
 147         struct ud_av_st *bcast_av = mlx->bcast_av;
 148         struct arbelprm_ud_address_vector *bav =
 149                 ( struct arbelprm_ud_address_vector * ) &bcast_av->av;
 150         struct ib_address_vector av = {
 151                 .dest_qp = bcast_av->dest_qp,
 152                 .qkey = bcast_av->qkey,
 153                 .dlid = MLX_GET ( bav, rlid ),
 154                 .rate = ( MLX_GET ( bav, max_stat_rate ) ? 1 : 4 ),
 155                 .sl = MLX_GET ( bav, sl ),
 156                 .gid_present = 1,
 157         };
 158         memcpy ( &av.gid, ( ( void * ) bav ) + 16, 16 );
 159
 160         rc = arbel_post_send ( &static_ibdev, &static_ipoib_qp, &av, iobuf );
 161
 162         return rc;
 163 }
 164
 165 static void arbel_poll_cq ( struct ib_device *ibdev,
 166                             struct ib_completion_queue *cq,
 167                             ib_completer_t complete_send,
 168                             ib_completer_t complete_recv );
 169
 170 static void temp_complete_send ( struct ib_device *ibdev __unused,
 171                                  struct ib_queue_pair *qp,
 172                                  struct ib_completion *completion,
 173                                  struct io_buffer *iobuf ) {
 174         struct net_device *netdev = qp->owner_priv;
 175
 176         DBG ( "Wahey! TX completion\n" );
 177         netdev_tx_complete_err ( netdev, iobuf,
 178                                  ( completion->syndrome ? -EIO : 0 ) );
 179 }
 180
 181 static void temp_complete_recv ( struct ib_device *ibdev __unused,
 182                                  struct ib_queue_pair *qp,
 183                                  struct ib_completion *completion,
 184                                  struct io_buffer *iobuf ) {
 185         struct net_device *netdev = qp->owner_priv;
 186         struct mlx_nic *mlx = netdev->priv;
 187
 188         DBG ( "Yay! RX completion on %p len %zx:\n", iobuf, completion->len );
 189         if ( completion->syndrome ) {
 190                 netdev_rx_err ( netdev, iobuf, -EIO );
 191         } else {
 192                 iob_put ( iobuf, completion->len );
 193                 iob_pull ( iobuf, sizeof ( struct ib_global_route_header ) );
 194                 netdev_rx ( netdev, iobuf );
 195         }
 196
 197         mlx->rx_fill--;
 198 }
 199
 200 static int arbel_post_recv ( struct ib_device *ibdev,
 201                              struct ib_queue_pair *qp,
 202                              struct io_buffer *iobuf );
 203
 204 static void mlx_refill_rx ( struct net_device *netdev ) {
 205         struct mlx_nic *mlx = netdev->priv;
 206         struct io_buffer *iobuf;
 207         int rc;
 208
 209         while ( mlx->rx_fill < MLX_RX_MAX_FILL ) {
 210                 iobuf = alloc_iob ( 2048 );
 211                 if ( ! iobuf )
 212                         break;
 213                 DBG ( "Posting RX buffer %p:\n", iobuf );
 214                 if ( ( rc = arbel_post_recv ( &static_ibdev,
 215                                               &static_ipoib_qp,
 216                                               iobuf ) ) != 0 ) {
 217                         free_iob ( iobuf );
 218                         break;
 219                 }
 220                 mlx->rx_fill++;
 221         }
 222 }
 223
 224 /**
 225  * Poll for completed and received packets
 226  *
 227  * @v netdev            Network device
 228  */
 229 static void mlx_poll ( struct net_device *netdev ) {
 230         struct mlx_nic *mlx = netdev->priv;
 231         int rc;
 232
 233         if ( ( rc = poll_error_buf() ) != 0 ) {
 234                 DBG ( "poll_error_buf() failed: %s\n", strerror ( rc ) );
 235                 return;
 236         }
 237
 238         /* Drain event queue.  We can ignore events, since we're going
 239          * to just poll all completion queues anyway.
 240          */
 241         if ( ( rc = drain_eq() ) != 0 ) {
 242                 DBG ( "drain_eq() failed: %s\n", strerror ( rc ) );
 243                 return;
 244         }
 245
 246         /* Poll completion queues */
 247         arbel_poll_cq ( &static_ibdev, &static_ipoib_send_cq,
 248                         temp_complete_send, temp_complete_recv );
 249         arbel_poll_cq ( &static_ibdev, &static_ipoib_recv_cq,
 250                         temp_complete_send, temp_complete_recv );
 251
 252         mlx_refill_rx ( netdev );
 253 }
 254
 255 /**
 256  * Enable or disable interrupts
 257  *
 258  * @v netdev            Network device
 259  * @v enable            Interrupts should be enabled
 260  */
 261 static void mlx_irq ( struct net_device *netdev, int enable ) {
 262
 263         ( void ) netdev;
 264         ( void ) enable;
 265
 266 }
 267
 268 static struct net_device_operations mlx_operations = {
 269         .open           = mlx_open,
 270         .close          = mlx_close,
 271         .transmit       = mlx_transmit_direct,
 272         .poll           = mlx_poll,
 273         .irq            = mlx_irq,
 274 };
 275
 276
 277
 278
 279 /***************************************************************************
 280  *
 281  * Queue number allocation
 282  *
 283  ***************************************************************************
 284  */
 285
 286 /**
 287  * Allocate queue number
 288  *
 289  * @v q_inuse           Queue usage bitmask
 290  * @v max_inuse         Maximum number of in-use queues
 291  * @ret qn_offset       Free queue number offset, or negative error
 292  */
 293 static int arbel_alloc_qn_offset ( arbel_bitmask_t *q_inuse,
 294                                    unsigned int max_inuse ) {
 295         unsigned int qn_offset = 0;
 296         arbel_bitmask_t mask = 1;
 297
 298         while ( qn_offset < max_inuse ) {
 299                 if ( ( mask & *q_inuse ) == 0 ) {
 300                         *q_inuse |= mask;
 301                         return qn_offset;
 302                 }
 303                 qn_offset++;
 304                 mask <<= 1;
 305                 if ( ! mask ) {
 306                         mask = 1;
 307                         q_inuse++;
 308                 }
 309         }
 310         return -ENFILE;
 311 }
 312
 313 /**
 314  * Free queue number
 315  *
 316  * @v q_inuse           Queue usage bitmask
 317  * @v qn_offset         Queue number offset
 318  */
 319 static void arbel_free_qn_offset ( arbel_bitmask_t *q_inuse, int qn_offset ) {
 320         arbel_bitmask_t mask;
 321
 322         mask = ( 1 << ( qn_offset % ( 8 * sizeof ( mask ) ) ) );
 323         q_inuse += ( qn_offset / ( 8 * sizeof ( mask ) ) );
 324         *q_inuse &= ~mask;
 325 }
 326
 327 /***************************************************************************
 328  *
 329  * HCA commands
 330  *
 331  ***************************************************************************
 332  */
 333
 334 /**
 335  * Wait for Arbel command completion
 336  *
 337  * @v arbel             Arbel device
 338  * @ret rc              Return status code
 339  */
 340 static int arbel_cmd_wait ( struct arbel *arbel,
 341                             struct arbelprm_hca_command_register *hcr ) {
 342         unsigned int wait;
 343
 344         for ( wait = ARBEL_HCR_MAX_WAIT_MS ; wait ; wait-- ) {
 345                 hcr->u.dwords[6] =
 346                         readl ( arbel->config + ARBEL_HCR_REG ( 6 ) );
 347                 if ( MLX_GET ( hcr, go ) == 0 )
 348                         return 0;
 349                 mdelay ( 1 );
 350         }
 351         return -EBUSY;
 352 }
 353
 354 /**
 355  * Issue HCA command
 356  *
 357  * @v arbel             Arbel device
 358  * @v command           Command opcode, flags and input/output lengths
 359  * @v op_mod            Opcode modifier (0 if no modifier applicable)
 360  * @v in                Input parameters
 361  * @v in_mod            Input modifier (0 if no modifier applicable)
 362  * @v out               Output parameters
 363  * @ret rc              Return status code
 364  */
 365 static int arbel_cmd ( struct arbel *arbel, unsigned long command,
 366                        unsigned int op_mod, const void *in,
 367                        unsigned int in_mod, void *out ) {
 368         struct arbelprm_hca_command_register hcr;
 369         unsigned int opcode = ARBEL_HCR_OPCODE ( command );
 370         size_t in_len = ARBEL_HCR_IN_LEN ( command );
 371         size_t out_len = ARBEL_HCR_OUT_LEN ( command );
 372         void *in_buffer;
 373         void *out_buffer;
 374         unsigned int status;
 375         unsigned int i;
 376         int rc;
 377
 378         DBGC ( arbel, "Arbel %p command %02x in %zx%s out %zx%s\n",
 379                arbel, opcode, in_len,
 380                ( ( command & ARBEL_HCR_IN_MBOX ) ? "(mbox)" : "" ), out_len,
 381                ( ( command & ARBEL_HCR_OUT_MBOX ) ? "(mbox)" : "" ) );
 382
 383         /* Check that HCR is free */
 384         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
 385                 DBGC ( arbel, "Arbel %p command interface locked\n", arbel );
 386                 return rc;
 387         }
 388
 389         /* Prepare HCR */
 390         memset ( &hcr, 0, sizeof ( hcr ) );
 391         in_buffer = &hcr.u.dwords[0];
 392         if ( in_len && ( command & ARBEL_HCR_IN_MBOX ) ) {
 393                 in_buffer = arbel->mailbox_in;
 394                 MLX_FILL_1 ( &hcr, 1, in_param_l, virt_to_bus ( in_buffer ) );
 395         }
 396         memcpy ( in_buffer, in, in_len );
 397         MLX_FILL_1 ( &hcr, 2, input_modifier, in_mod );
 398         out_buffer = &hcr.u.dwords[3];
 399         if ( out_len && ( command & ARBEL_HCR_OUT_MBOX ) ) {
 400                 out_buffer = arbel->mailbox_out;
 401                 MLX_FILL_1 ( &hcr, 4, out_param_l,
 402                              virt_to_bus ( out_buffer ) );
 403         }
 404         MLX_FILL_3 ( &hcr, 6,
 405                      opcode, opcode,
 406                      opcode_modifier, op_mod,
 407                      go, 1 );
 408
 409         /* Issue command */
 410         for ( i = 0 ; i < ( sizeof ( hcr ) / sizeof ( hcr.u.dwords[0] ) ) ;
 411               i++ ) {
 412                 writel ( hcr.u.dwords[i],
 413                          arbel->config + ARBEL_HCR_REG ( i ) );
 414                 barrier();
 415         }
 416
 417         /* Wait for command completion */
 418         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
 419                 DBGC ( arbel, "Arbel %p timed out waiting for command:\n",
 420                        arbel );
 421                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
 422                 return rc;
 423         }
 424
 425         /* Check command status */
 426         status = MLX_GET ( &hcr, status );
 427         if ( status != 0 ) {
 428                 DBGC ( arbel, "Arbel %p command failed with status %02x:\n",
 429                        arbel, status );
 430                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
 431                 return -EIO;
 432         }
 433
 434         /* Read output parameters, if any */
 435         hcr.u.dwords[3] = readl ( arbel->config + ARBEL_HCR_REG ( 3 ) );
 436         hcr.u.dwords[4] = readl ( arbel->config + ARBEL_HCR_REG ( 4 ) );
 437         memcpy ( out, out_buffer, out_len );
 438
 439         return 0;
 440 }
 441
 442 static inline int
 443 arbel_cmd_query_dev_lim ( struct arbel *arbel,
 444                           struct arbelprm_query_dev_lim *dev_lim ) {
 445         return arbel_cmd ( arbel,
 446                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_QUERY_DEV_LIM,
 447                                                1, sizeof ( *dev_lim ) ),
 448                            0, NULL, 0, dev_lim );
 449 }
 450
 451 static inline int
 452 arbel_cmd_sw2hw_cq ( struct arbel *arbel, unsigned long cqn,
 453                      const struct arbelprm_completion_queue_context *cqctx ) {
 454         return arbel_cmd ( arbel,
 455                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_SW2HW_CQ,
 456                                               1, sizeof ( *cqctx ) ),
 457                            0, cqctx, cqn, NULL );
 458 }
 459
 460 static inline int
 461 arbel_cmd_hw2sw_cq ( struct arbel *arbel, unsigned long cqn ) {
 462         return arbel_cmd ( arbel,
 463                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_HW2SW_CQ ),
 464                            1, NULL, cqn, NULL );
 465 }
 466
 467 static inline int
 468 arbel_cmd_rst2init_qpee ( struct arbel *arbel, unsigned long qpn,
 469                           struct arbelprm_queue_pair_ee_context_entry *ctx ) {
 470         return arbel_cmd ( arbel,
 471                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_RST2INIT_QPEE,
 472                                               1, sizeof ( *ctx ) ),
 473                            0, ctx, qpn, NULL );
 474 }
 475
 476 static inline int
 477 arbel_cmd_init2rtr_qpee ( struct arbel *arbel, unsigned long qpn,
 478                           struct arbelprm_queue_pair_ee_context_entry *ctx ) {
 479         return arbel_cmd ( arbel,
 480                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_INIT2RTR_QPEE,
 481                                               1, sizeof ( *ctx ) ),
 482                            0, ctx, qpn, NULL );
 483 }
 484
 485 static inline int
 486 arbel_cmd_rtr2rts_qpee ( struct arbel *arbel, unsigned long qpn,
 487                          struct arbelprm_queue_pair_ee_context_entry *ctx ) {
 488         return arbel_cmd ( arbel,
 489                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_RTR2RTS_QPEE,
 490                                               1, sizeof ( *ctx ) ),
 491                            0, ctx, qpn, NULL );
 492 }
 493
 494 static inline int
 495 arbel_cmd_2rst_qpee ( struct arbel *arbel, unsigned long qpn ) {
 496         return arbel_cmd ( arbel,
 497                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_2RST_QPEE ),
 498                            0x03, NULL, qpn, NULL );
 499 }
 500
 501 /***************************************************************************
 502  *
 503  * Completion queue operations
 504  *
 505  ***************************************************************************
 506  */
 507
 508 /**
 509  * Create completion queue
 510  *
 511  * @v ibdev             Infiniband device
 512  * @v cq                Completion queue
 513  * @ret rc              Return status code
 514  */
 515 static int arbel_create_cq ( struct ib_device *ibdev,
 516                              struct ib_completion_queue *cq ) {
 517         struct arbel *arbel = ibdev->dev_priv;
 518         struct arbel_completion_queue *arbel_cq;
 519         struct arbelprm_completion_queue_context cqctx;
 520         struct arbelprm_cq_ci_db_record *ci_db_rec;
 521         struct arbelprm_cq_arm_db_record *arm_db_rec;
 522         int cqn_offset;
 523         unsigned int i;
 524         int rc;
 525
 526         /* Find a free completion queue number */
 527         cqn_offset = arbel_alloc_qn_offset ( arbel->cq_inuse, ARBEL_MAX_CQS );
 528         if ( cqn_offset < 0 ) {
 529                 DBGC ( arbel, "Arbel %p out of completion queues\n", arbel );
 530                 rc = cqn_offset;
 531                 goto err_cqn_offset;
 532         }
 533         cq->cqn = ( arbel->limits.reserved_cqs + cqn_offset );
 534
 535         /* Allocate control structures */
 536         arbel_cq = zalloc ( sizeof ( *arbel_cq ) );
 537         if ( ! arbel_cq ) {
 538                 rc = -ENOMEM;
 539                 goto err_arbel_cq;
 540         }
 541         arbel_cq->ci_doorbell_idx = arbel_cq_ci_doorbell_idx ( cqn_offset );
 542         arbel_cq->arm_doorbell_idx = arbel_cq_arm_doorbell_idx ( cqn_offset );
 543
 544         /* Allocate completion queue itself */
 545         arbel_cq->cqe_size = ( cq->num_cqes * sizeof ( arbel_cq->cqe[0] ) );
 546         arbel_cq->cqe = malloc_dma ( arbel_cq->cqe_size,
 547                                      sizeof ( arbel_cq->cqe[0] ) );
 548         if ( ! arbel_cq->cqe ) {
 549                 rc = -ENOMEM;
 550                 goto err_cqe;
 551         }
 552         memset ( arbel_cq->cqe, 0, arbel_cq->cqe_size );
 553         for ( i = 0 ; i < cq->num_cqes ; i++ ) {
 554                 MLX_FILL_1 ( &arbel_cq->cqe[i].normal, 7, owner, 1 );
 555         }
 556         barrier();
 557
 558         /* Initialise doorbell records */
 559         ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
 560         MLX_FILL_1 ( ci_db_rec, 0, counter, 0 );
 561         MLX_FILL_2 ( ci_db_rec, 1,
 562                      res, ARBEL_UAR_RES_CQ_CI,
 563                      cq_number, cq->cqn );
 564         arm_db_rec = &arbel->db_rec[arbel_cq->arm_doorbell_idx].cq_arm;
 565         MLX_FILL_1 ( arm_db_rec, 0, counter, 0 );
 566         MLX_FILL_2 ( arm_db_rec, 1,
 567                      res, ARBEL_UAR_RES_CQ_ARM,
 568                      cq_number, cq->cqn );
 569
 570         /* Hand queue over to hardware */
 571         memset ( &cqctx, 0, sizeof ( cqctx ) );
 572         MLX_FILL_1 ( &cqctx, 0, st, 0xa /* "Event fired" */ );
 573         MLX_FILL_1 ( &cqctx, 2, start_address_l,
 574                      virt_to_bus ( arbel_cq->cqe ) );
 575         MLX_FILL_2 ( &cqctx, 3,
 576                      usr_page, arbel->limits.reserved_uars,
 577                      log_cq_size, ( fls ( cq->num_cqes ) - 1 ) );
 578         MLX_FILL_1 ( &cqctx, 5, c_eqn, arbel->eqn );
 579         MLX_FILL_1 ( &cqctx, 6, pd, ARBEL_GLOBAL_PD );
 580         MLX_FILL_1 ( &cqctx, 7, l_key, arbel->reserved_lkey );
 581         MLX_FILL_1 ( &cqctx, 12, cqn, cq->cqn );
 582         MLX_FILL_1 ( &cqctx, 13,
 583                      cq_ci_db_record, arbel_cq->ci_doorbell_idx );
 584         MLX_FILL_1 ( &cqctx, 14,
 585                      cq_state_db_record, arbel_cq->arm_doorbell_idx );
 586         if ( ( rc = arbel_cmd_sw2hw_cq ( arbel, cq->cqn, &cqctx ) ) != 0 ) {
 587                 DBGC ( arbel, "Arbel %p SW2HW_CQ failed: %s\n",
 588                        arbel, strerror ( rc ) );
 589                 goto err_sw2hw_cq;
 590         }
 591
 592         cq->dev_priv = arbel_cq;
 593         return 0;
 594
 595  err_sw2hw_cq:
 596         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 597         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 598         free_dma ( arbel_cq->cqe, arbel_cq->cqe_size );
 599  err_cqe:
 600         free ( arbel_cq );
 601  err_arbel_cq:
 602         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
 603  err_cqn_offset:
 604         return rc;
 605 }
 606
 607 /**
 608  * Destroy completion queue
 609  *
 610  * @v ibdev             Infiniband device
 611  * @v cq                Completion queue
 612  */
 613 static void arbel_destroy_cq ( struct ib_device *ibdev,
 614                                struct ib_completion_queue *cq ) {
 615         struct arbel *arbel = ibdev->dev_priv;
 616         struct arbel_completion_queue *arbel_cq = cq->dev_priv;
 617         struct arbelprm_cq_ci_db_record *ci_db_rec;
 618         struct arbelprm_cq_arm_db_record *arm_db_rec;
 619         int cqn_offset;
 620         int rc;
 621
 622         /* Take ownership back from hardware */
 623         if ( ( rc = arbel_cmd_hw2sw_cq ( arbel, cq->cqn ) ) != 0 ) {
 624                 DBGC ( arbel, "Arbel %p FATAL HW2SW_CQ failed on CQN %#lx: "
 625                        "%s\n", arbel, cq->cqn, strerror ( rc ) );
 626                 /* Leak memory and return; at least we avoid corruption */
 627                 return;
 628         }
 629
 630         /* Clear doorbell records */
 631         ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
 632         arm_db_rec = &arbel->db_rec[arbel_cq->arm_doorbell_idx].cq_arm;
 633         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 634         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 635
 636         /* Free memory */
 637         free_dma ( arbel_cq->cqe, arbel_cq->cqe_size );
 638         free ( arbel_cq );
 639
 640         /* Mark queue number as free */
 641         cqn_offset = ( cq->cqn - arbel->limits.reserved_cqs );
 642         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
 643
 644         cq->dev_priv = NULL;
 645 }
 646
 647 /***************************************************************************
 648  *
 649  * Queue pair operations
 650  *
 651  ***************************************************************************
 652  */
 653
 654 static int arbel_create_send_wq ( struct arbel_send_work_queue *arbel_send_wq,
 655                                   unsigned int num_wqes ) {
 656
 657         arbel_send_wq->wqe_size = ( num_wqes *
 658                                     sizeof ( arbel_send_wq->wqe[0] ) );
 659         arbel_send_wq->wqe = malloc_dma ( arbel_send_wq->wqe_size,
 660                                           sizeof ( arbel_send_wq->wqe[0] ) );
 661         if ( ! arbel_send_wq->wqe )
 662                 return -ENOMEM;
 663
 664         // initialise (prelink?)
 665 }
 666
 667 static int arbel_create_recv_wq ( struct arbel_recv_work_queue *arbel_recv_wq,
 668                                   unsigned int num_wqes ) {
 669
 670         arbel_recv_wq->wqe_size = ( num_wqes *
 671                                     sizeof ( arbel_recv_wq->wqe[0] ) );
 672         arbel_recv_wq->wqe = malloc_dma ( arbel_recv_wq->wqe_size,
 673                                           sizeof ( arbel_recv_wq->wqe[0] ) );
 674         if ( ! arbel_recv_wq->wqe )
 675                 return -ENOMEM;
 676
 677         // initialise (prelink?)
 678 }
 679
 680
 681
 682
 683 /**
 684  * Create queue pair
 685  *
 686  * @v ibdev             Infiniband device
 687  * @v qp                Queue pair
 688  * @ret rc              Return status code
 689  */
 690 static int arbel_create_qp ( struct ib_device *ibdev,
 691                              struct ib_queue_pair *qp ) {
 692         struct arbel *arbel = ibdev->dev_priv;
 693         struct arbel_queue_pair *arbel_qp;
 694         struct arbelprm_queue_pair_ee_context_entry qpctx;
 695         struct arbelprm_qp_db_record *send_db_rec;
 696         struct arbelprm_qp_db_record *recv_db_rec;
 697         int qpn_offset;
 698         int rc;
 699
 700         /* Find a free queue pair number */
 701         qpn_offset = arbel_alloc_qn_offset ( arbel->qp_inuse, ARBEL_MAX_QPS );
 702         if ( qpn_offset < 0 ) {
 703                 DBGC ( arbel, "Arbel %p out of queue pairs\n", arbel );
 704                 rc = qpn_offset;
 705                 goto err_qpn_offset;
 706         }
 707         qp->qpn = ( ARBEL_QPN_BASE + arbel->limits.reserved_qps + qpn_offset );
 708
 709         /* Allocate control structures */
 710         arbel_qp = zalloc ( sizeof ( *arbel_qp ) );
 711         if ( ! arbel_qp ) {
 712                 rc = -ENOMEM;
 713                 goto err_arbel_qp;
 714         }
 715         arbel_qp->send.doorbell_idx = arbel_send_doorbell_idx ( qpn_offset );
 716         arbel_qp->recv.doorbell_idx = arbel_recv_doorbell_idx ( qpn_offset );
 717
 718         /* Create send and receive work queues */
 719         if ( ( rc = arbel_create_send_wq ( &arbel_qp->send,
 720                                            qp->send.num_wqes ) ) != 0 )
 721                 goto err_create_send_wq;
 722         if ( ( rc = arbel_create_recv_wq ( &arbel_qp->recv,
 723                                            qp->recv.num_wqes ) ) != 0 )
 724                 goto err_create_recv_wq;
 725
 726         /* Initialise doorbell records */
 727         send_db_rec = &arbel->db_rec[arbel_qp->send.doorbell_idx].qp;
 728         MLX_FILL_1 ( send_db_rec, 0, counter, 0 );
 729         MLX_FILL_2 ( send_db_rec, 1,
 730                      res, ARBEL_UAR_RES_SQ,
 731                      qp_number, qp->qpn );
 732         recv_db_rec = &arbel->db_rec[arbel_qp->recv.doorbell_idx].qp;
 733         MLX_FILL_1 ( recv_db_rec, 0, counter, 0 );
 734         MLX_FILL_2 ( recv_db_rec, 1,
 735                      res, ARBEL_UAR_RES_RQ,
 736                      qp_number, qp->qpn );
 737
 738         /* Hand queue over to hardware */
 739         memset ( &qpctx, 0, sizeof ( qpctx ) );
 740         // ...  fill in context
 741         if ( ( rc = arbel_cmd_rst2init_qpee ( arbel, qp->qpn, &qpctx )) != 0 ){
 742                 DBGC ( arbel, "Arbel %p RST2INIT_QPEE failed: %s\n",
 743                        arbel, strerror ( rc ) );
 744                 goto err_rst2init_qpee;
 745         }
 746         if ( ( rc = arbel_cmd_init2rtr_qpee ( arbel, qp->qpn, &qpctx )) != 0 ){
 747                 DBGC ( arbel, "Arbel %p INIT2RTR_QPEE failed: %s\n",
 748                        arbel, strerror ( rc ) );
 749                 goto err_init2rtr_qpee;
 750         }
 751         if ( ( rc = arbel_cmd_rtr2rts_qpee ( arbel, qp->qpn, &qpctx ) ) != 0 ){
 752                 DBGC ( arbel, "Arbel %p RTR2RTS_QPEE failed: %s\n",
 753                        arbel, strerror ( rc ) );
 754                 goto err_rtr2rts_qpee;
 755         }
 756
 757         qp->dev_priv = arbel_qp;
 758         return 0;
 759
 760  err_rtr2rts_qpee:
 761  err_init2rtr_qpee:
 762         arbel_cmd_2rst_qpee ( arbel, qp->qpn );
 763  err_rst2init_qpee:
 764         MLX_FILL_1 ( send_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 765         MLX_FILL_1 ( recv_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 766         free_dma ( arbel_qp->recv.wqe, arbel_qp->recv.wqe_size );
 767  err_create_recv_wq:
 768         free_dma ( arbel_qp->send.wqe, arbel_qp->send.wqe_size );
 769  err_create_send_wq:
 770         free ( arbel_qp );
 771  err_arbel_qp:
 772         arbel_free_qn_offset ( arbel->qp_inuse, qpn_offset );
 773  err_qpn_offset:
 774         return rc;
 775 }
 776
 777 /**
 778  * Destroy queue pair
 779  *
 780  * @v ibdev             Infiniband device
 781  * @v qp                Queue pair
 782  */
 783 static void arbel_destroy_qp ( struct ib_device *ibdev,
 784                                struct ib_queue_pair *qp ) {
 785         struct arbel *arbel = ibdev->dev_priv;
 786         struct arbel_queue_pair *arbel_qp = qp->dev_priv;
 787         struct arbelprm_qp_db_record *send_db_rec;
 788         struct arbelprm_qp_db_record *recv_db_rec;
 789         int qpn_offset;
 790         int rc;
 791
 792         /* Take ownership back from hardware */
 793         if ( ( rc = arbel_cmd_2rst_qpee ( arbel, qp->qpn ) ) != 0 ) {
 794                 DBGC ( arbel, "Arbel %p FATAL 2RST_QPEE failed on QPN %#lx: "
 795                        "%s\n", arbel, qp->qpn, strerror ( rc ) );
 796                 /* Leak memory and return; at least we avoid corruption */
 797                 return;
 798         }
 799
 800         /* Clear doorbell records */
 801         send_db_rec = &arbel->db_rec[arbel_qp->send.doorbell_idx].qp;
 802         recv_db_rec = &arbel->db_rec[arbel_qp->recv.doorbell_idx].qp;
 803         MLX_FILL_1 ( send_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 804         MLX_FILL_1 ( recv_db_rec, 1, res, ARBEL_UAR_RES_NONE );
 805
 806         /* Free memory */
 807         free_dma ( arbel_qp->send.wqe, arbel_qp->send.wqe_size );
 808         free_dma ( arbel_qp->recv.wqe, arbel_qp->recv.wqe_size );
 809         free ( arbel_qp );
 810
 811         /* Mark queue number as free */
 812         qpn_offset = ( qp->qpn - ARBEL_QPN_BASE - arbel->limits.reserved_qps );
 813         arbel_free_qn_offset ( arbel->qp_inuse, qpn_offset );
 814
 815         qp->dev_priv = NULL;
 816 }
 817
 818 /***************************************************************************
 819  *
 820  * Work request operations
 821  *
 822  ***************************************************************************
 823  */
 824
 825 /**
 826  * Ring doorbell register in UAR
 827  *
 828  * @v arbel             Arbel device
 829  * @v db_reg            Doorbell register structure
 830  * @v offset            Address of doorbell
 831  */
 832 static void arbel_ring_doorbell ( struct arbel *arbel,
 833                                   union arbelprm_doorbell_register *db_reg,
 834                                   unsigned int offset ) {
 835
 836         DBG ( "arbel_ring_doorbell %08lx:%08lx to %lx\n",
 837               db_reg->dword[0], db_reg->dword[1],
 838               virt_to_phys ( arbel->uar + offset ) );
 839
 840         barrier();
 841         writel ( db_reg->dword[0], ( arbel->uar + offset + 0 ) );
 842         barrier();
 843         writel ( db_reg->dword[1], ( arbel->uar + offset + 4 ) );
 844 }
 845
 846 /**
 847  * Post send work queue entry
 848  *
 849  * @v ibdev             Infiniband device
 850  * @v qp                Queue pair
 851  * @v av                Address vector
 852  * @v iobuf             I/O buffer
 853  * @ret rc              Return status code
 854  */
 855 static int arbel_post_send ( struct ib_device *ibdev,
 856                              struct ib_queue_pair *qp,
 857                              struct ib_address_vector *av,
 858                              struct io_buffer *iobuf ) {
 859         struct arbel *arbel = ibdev->dev_priv;
 860         struct arbel_queue_pair *arbel_qp = qp->dev_priv;
 861         struct ib_work_queue *wq = &qp->send;
 862         struct arbel_send_work_queue *arbel_send_wq = &arbel_qp->send;
 863         struct arbelprm_ud_send_wqe *prev_wqe;
 864         struct arbelprm_ud_send_wqe *wqe;
 865         struct arbelprm_qp_db_record *qp_db_rec;
 866         union arbelprm_doorbell_register db_reg;
 867         const struct ib_gid *gid;
 868         unsigned int wqe_idx_mask;
 869         size_t nds;
 870
 871         /* Allocate work queue entry */
 872         wqe_idx_mask = ( wq->num_wqes - 1 );
 873         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
 874                 DBGC ( arbel, "Arbel %p send queue full", arbel );
 875                 return -ENOBUFS;
 876         }
 877         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
 878         prev_wqe = &arbel_send_wq->wqe[(wq->next_idx - 1) & wqe_idx_mask].ud;
 879         wqe = &arbel_send_wq->wqe[wq->next_idx & wqe_idx_mask].ud;
 880
 881         /* Construct work queue entry */
 882         MLX_FILL_1 ( &wqe->next, 1, always1, 1 );
 883         memset ( &wqe->ctrl, 0, sizeof ( wqe->ctrl ) );
 884         MLX_FILL_1 ( &wqe->ctrl, 0, always1, 1 );
 885         memset ( &wqe->ud, 0, sizeof ( wqe->ud ) );
 886         MLX_FILL_2 ( &wqe->ud, 0,
 887                      ud_address_vector.pd, ARBEL_GLOBAL_PD,
 888                      ud_address_vector.port_number, PXE_IB_PORT );
 889         MLX_FILL_2 ( &wqe->ud, 1,
 890                      ud_address_vector.rlid, av->dlid,
 891                      ud_address_vector.g, av->gid_present );
 892         MLX_FILL_2 ( &wqe->ud, 2,
 893                      ud_address_vector.max_stat_rate,
 894                          ( ( av->rate >= 3 ) ? 0 : 1 ),
 895                      ud_address_vector.msg, 3 );
 896         MLX_FILL_1 ( &wqe->ud, 3, ud_address_vector.sl, av->sl );
 897         gid = ( av->gid_present ? &av->gid : &arbel_no_gid );
 898         memcpy ( &wqe->ud.u.dwords[4], gid, sizeof ( *gid ) );
 899         MLX_FILL_1 ( &wqe->ud, 8, destination_qp, av->dest_qp );
 900         MLX_FILL_1 ( &wqe->ud, 9, q_key, av->qkey );
 901         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_len ( iobuf ) );
 902         MLX_FILL_1 ( &wqe->data[0], 3,
 903                      local_address_l, virt_to_bus ( iobuf->data ) );
 904
 905         /* Update previous work queue entry's "next" field */
 906         nds = ( ( offsetof ( typeof ( *wqe ), data ) +
 907                   sizeof ( wqe->data[0] ) ) >> 4 );
 908         MLX_SET ( &prev_wqe->next, nopcode, ARBEL_OPCODE_SEND );
 909         MLX_FILL_3 ( &prev_wqe->next, 1,
 910                      nds, nds,
 911                      f, 1,
 912                      always1, 1 );
 913
 914         /* Update doorbell record */
 915         barrier();
 916         qp_db_rec = &arbel->db_rec[arbel_send_wq->doorbell_idx].qp;
 917         MLX_FILL_1 ( qp_db_rec, 0,
 918                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );
 919
 920         /* Ring doorbell register */
 921         MLX_FILL_4 ( &db_reg.send, 0,
 922                      nopcode, ARBEL_OPCODE_SEND,
 923                      f, 1,
 924                      wqe_counter, ( wq->next_idx & 0xffff ),
 925                      wqe_cnt, 1 );
 926         MLX_FILL_2 ( &db_reg.send, 1,
 927                      nds, nds,
 928                      qpn, qp->qpn );
 929         arbel_ring_doorbell ( arbel, &db_reg, POST_SND_OFFSET );
 930
 931         /* Update work queue's index */
 932         wq->next_idx++;
 933
 934         return 0;
 935 }
 936
 937 /**
 938  * Post receive work queue entry
 939  *
 940  * @v ibdev             Infiniband device
 941  * @v qp                Queue pair
 942  * @v iobuf             I/O buffer
 943  * @ret rc              Return status code
 944  */
 945 static int arbel_post_recv ( struct ib_device *ibdev,
 946                              struct ib_queue_pair *qp,
 947                              struct io_buffer *iobuf ) {
 948         struct arbel *arbel = ibdev->dev_priv;
 949         struct arbel_queue_pair *arbel_qp = qp->dev_priv;
 950         struct ib_work_queue *wq = &qp->recv;
 951         struct arbel_recv_work_queue *arbel_recv_wq = &arbel_qp->recv;
 952         struct arbelprm_recv_wqe *wqe;
 953         union arbelprm_doorbell_record *db_rec;
 954         unsigned int wqe_idx_mask;
 955
 956         /* Allocate work queue entry */
 957         wqe_idx_mask = ( wq->num_wqes - 1 );
 958         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
 959                 DBGC ( arbel, "Arbel %p receive queue full", arbel );
 960                 return -ENOBUFS;
 961         }
 962         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
 963         wqe = &arbel_recv_wq->wqe[wq->next_idx & wqe_idx_mask].recv;
 964
 965         /* Construct work queue entry */
 966         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_tailroom ( iobuf ) );
 967         MLX_FILL_1 ( &wqe->data[0], 1, l_key, arbel->reserved_lkey );
 968         MLX_FILL_1 ( &wqe->data[0], 3,
 969                      local_address_l, virt_to_bus ( iobuf->data ) );
 970
 971         /* Update doorbell record */
 972         barrier();
 973         db_rec = &arbel->db_rec[arbel_recv_wq->doorbell_idx];
 974         MLX_FILL_1 ( &db_rec->qp, 0,
 975                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );
 976
 977         /* Update work queue's index */
 978         wq->next_idx++;
 979
 980         return 0;
 981 }
 982
 983 /**
 984  * Handle completion
 985  *
 986  * @v ibdev             Infiniband device
 987  * @v cq                Completion queue
 988  * @v cqe               Hardware completion queue entry
 989  * @v complete_send     Send completion handler
 990  * @v complete_recv     Receive completion handler
 991  * @ret rc              Return status code
 992  */
 993 static int arbel_complete ( struct ib_device *ibdev,
 994                             struct ib_completion_queue *cq,
 995                             union arbelprm_completion_entry *cqe,
 996                             ib_completer_t complete_send,
 997                             ib_completer_t complete_recv ) {
 998         struct arbel *arbel = ibdev->dev_priv;
 999         struct ib_completion completion;
1000         struct ib_work_queue *wq;
1001         struct ib_queue_pair *qp;
1002         struct arbel_queue_pair *arbel_qp;
1003         struct arbel_send_work_queue *arbel_send_wq;
1004         struct arbel_recv_work_queue *arbel_recv_wq;
1005         struct io_buffer *iobuf;
1006         ib_completer_t complete;
1007         unsigned int opcode;
1008         unsigned long qpn;
1009         int is_send;
1010         unsigned long wqe_adr;
1011         unsigned int wqe_idx;
1012         int rc = 0;
1013
1014         /* Parse completion */
1015         memset ( &completion, 0, sizeof ( completion ) );
1016         completion.len = MLX_GET ( &cqe->normal, byte_cnt );
1017         qpn = MLX_GET ( &cqe->normal, my_qpn );
1018         is_send = MLX_GET ( &cqe->normal, s );
1019         wqe_adr = ( MLX_GET ( &cqe->normal, wqe_adr ) << 6 );
1020         opcode = MLX_GET ( &cqe->normal, opcode );
1021         if ( opcode >= ARBEL_OPCODE_RECV_ERROR ) {
1022                 /* "s" field is not valid for error opcodes */
1023                 is_send = ( opcode == ARBEL_OPCODE_SEND_ERROR );
1024                 completion.syndrome = MLX_GET ( &cqe->error, syndrome );
1025                 DBGC ( arbel, "Arbel %p CPN %lx syndrome %x vendor %lx\n",
1026                        arbel, cq->cqn, completion.syndrome,
1027                        MLX_GET ( &cqe->error, vendor_code ) );
1028                 rc = -EIO;
1029                 /* Don't return immediately; propagate error to completer */
1030         }
1031
1032         /* Identify work queue */
1033         wq = ib_find_wq ( cq, qpn, is_send );
1034         if ( ! wq ) {
1035                 DBGC ( arbel, "Arbel %p CQN %lx unknown %s QPN %lx\n",
1036                        arbel, cq->cqn, ( is_send ? "send" : "recv" ), qpn );
1037                 return -EIO;
1038         }
1039         qp = wq->qp;
1040         arbel_qp = qp->dev_priv;
1041
1042         /* Identify work queue entry index */
1043         if ( is_send ) {
1044                 arbel_send_wq = &arbel_qp->send;
1045                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_send_wq->wqe ) ) /
1046                             sizeof ( arbel_send_wq->wqe[0] ) );
1047         } else {
1048                 arbel_recv_wq = &arbel_qp->recv;
1049                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_recv_wq->wqe ) ) /
1050                             sizeof ( arbel_recv_wq->wqe[0] ) );
1051         }
1052
1053         /* Identify I/O buffer */
1054         iobuf = wq->iobufs[wqe_idx];
1055         if ( ! iobuf ) {
1056                 DBGC ( arbel, "Arbel %p CQN %lx QPN %lx empty WQE %x\n",
1057                        arbel, cq->cqn, qpn, wqe_idx );
1058                 return -EIO;
1059         }
1060         wq->iobufs[wqe_idx] = NULL;
1061
1062         /* Pass off to caller's completion handler */
1063         complete = ( is_send ? complete_send : complete_recv );
1064         complete ( ibdev, qp, &completion, iobuf );
1065
1066         return rc;
1067 }
1068
1069 /**
1070  * Poll completion queue
1071  *
1072  * @v ibdev             Infiniband device
1073  * @v cq                Completion queue
1074  * @v complete_send     Send completion handler
1075  * @v complete_recv     Receive completion handler
1076  */
1077 static void arbel_poll_cq ( struct ib_device *ibdev,
1078                             struct ib_completion_queue *cq,
1079                             ib_completer_t complete_send,
1080                             ib_completer_t complete_recv ) {
1081         struct arbel *arbel = ibdev->dev_priv;
1082         struct arbel_completion_queue *arbel_cq = cq->dev_priv;
1083         struct arbelprm_cq_ci_db_record *ci_db_rec;
1084         union arbelprm_completion_entry *cqe;
1085         unsigned int cqe_idx_mask;
1086         int rc;
1087
1088         while ( 1 ) {
1089                 /* Look for completion entry */
1090                 cqe_idx_mask = ( cq->num_cqes - 1 );
1091                 cqe = &arbel_cq->cqe[cq->next_idx & cqe_idx_mask];
1092                 if ( MLX_GET ( &cqe->normal, owner ) != 0 ) {
1093                         /* Entry still owned by hardware; end of poll */
1094                         break;
1095                 }
1096
1097                 /* Handle completion */
1098                 if ( ( rc = arbel_complete ( ibdev, cq, cqe, complete_send,
1099                                              complete_recv ) ) != 0 ) {
1100                         DBGC ( arbel, "Arbel %p failed to complete: %s\n",
1101                                arbel, strerror ( rc ) );
1102                         DBGC_HD ( arbel, cqe, sizeof ( *cqe ) );
1103                 }
1104
1105                 /* Return ownership to hardware */
1106                 MLX_FILL_1 ( &cqe->normal, 7, owner, 1 );
1107                 barrier();
1108                 /* Update completion queue's index */
1109                 cq->next_idx++;
1110                 /* Update doorbell record */
1111                 ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
1112                 MLX_FILL_1 ( ci_db_rec, 0,
1113                              counter, ( cq->next_idx & 0xffffffffUL ) );
1114         }
1115 }
1116
1117 /** Arbel Infiniband operations */
1118 static struct ib_device_operations arbel_ib_operations = {
1119         .create_cq      = arbel_create_cq,
1120         .destroy_cq     = arbel_destroy_cq,
1121         .create_qp      = arbel_create_qp,
1122         .destroy_qp     = arbel_destroy_qp,
1123         .post_send      = arbel_post_send,
1124         .post_recv      = arbel_post_recv,
1125         .poll_cq        = arbel_poll_cq,
1126 };
1127
1128 /**
1129  * Remove PCI device
1130  *
1131  * @v pci               PCI device
1132  */
1133 static void arbel_remove ( struct pci_device *pci ) {
1134         struct net_device *netdev = pci_get_drvdata ( pci );
1135
1136         unregister_netdev ( netdev );
1137         ib_driver_close ( 0 );
1138         netdev_nullify ( netdev );
1139         netdev_put ( netdev );
1140 }
1141
1142 /**
1143  * Probe PCI device
1144  *
1145  * @v pci               PCI device
1146  * @v id                PCI ID
1147  * @ret rc              Return status code
1148  */
1149 static int arbel_probe ( struct pci_device *pci,
1150                          const struct pci_device_id *id __unused ) {
1151         struct net_device *netdev;
1152         struct arbelprm_query_dev_lim dev_lim;
1153         struct arbel *arbel = &static_arbel;
1154         struct mlx_nic *mlx;
1155         struct ib_mac *mac;
1156         udqp_t qph;
1157         int rc;
1158
1159         /* Allocate net device */
1160         netdev = alloc_ibdev ( sizeof ( *mlx ) );
1161         if ( ! netdev )
1162                 return -ENOMEM;
1163         netdev_init ( netdev, &mlx_operations );
1164         mlx = netdev->priv;
1165         pci_set_drvdata ( pci, netdev );
1166         netdev->dev = &pci->dev;
1167         memset ( mlx, 0, sizeof ( *mlx ) );
1168
1169         /* Fix up PCI device */
1170         adjust_pci_device ( pci );
1171
1172         /* Initialise hardware */
1173         if ( ( rc = ib_driver_init ( pci, &qph ) ) != 0 )
1174                 goto err_ipoib_init;
1175         mlx->ipoib_qph = qph;
1176         mlx->bcast_av = ib_data.bcast_av;
1177         mlx->snd_cqh = ib_data.ipoib_snd_cq;
1178         mlx->rcv_cqh = ib_data.ipoib_rcv_cq;
1179         mac = ( ( struct ib_mac * ) netdev->ll_addr );
1180         mac->qpn = htonl ( ib_get_qpn ( mlx->ipoib_qph ) );
1181         memcpy ( &mac->gid, ib_data.port_gid.raw, sizeof ( mac->gid ) );
1182
1183         /* Hack up IB structures */
1184         arbel->config = memfree_pci_dev.cr_space;
1185         arbel->mailbox_in = dev_buffers_p->inprm_buf;
1186         arbel->mailbox_out = dev_buffers_p->outprm_buf;
1187         arbel->uar = memfree_pci_dev.uar;
1188         arbel->db_rec = dev_ib_data.uar_context_base;
1189         arbel->reserved_lkey = dev_ib_data.mkey;
1190         arbel->eqn = dev_ib_data.eq.eqn;
1191         static_arbel_ipoib_qp.send.wqe =
1192                 ( ( struct udqp_st * ) qph )->snd_wq;
1193         static_arbel_ipoib_qp.recv.wqe =
1194                 ( ( struct udqp_st * ) qph )->rcv_wq;
1195         static_arbel_ipoib_send_cq.cqe =
1196                 ( ( struct cq_st * ) ib_data.ipoib_snd_cq )->cq_buf;
1197         static_arbel_ipoib_recv_cq.cqe =
1198                 ( ( struct cq_st * ) ib_data.ipoib_rcv_cq )->cq_buf;
1199         static_ipoib_qp.qpn = ib_get_qpn ( qph );
1200         static_ipoib_qp.owner_priv = netdev;
1201         list_add ( &static_ipoib_qp.send.list,
1202                    &static_ipoib_send_cq.work_queues );
1203         list_add ( &static_ipoib_qp.recv.list,
1204                    &static_ipoib_recv_cq.work_queues );
1205         static_ibdev.op = &arbel_ib_operations;
1206
1207         /* Get device limits */
1208         if ( ( rc = arbel_cmd_query_dev_lim ( arbel, &dev_lim ) ) != 0 ) {
1209                 DBGC ( arbel, "Arbel %p could not get device limits: %s\n",
1210                        arbel, strerror ( rc ) );
1211                 goto err_query_dev_lim;
1212         }
1213         arbel->limits.reserved_uars = MLX_GET ( &dev_lim, num_rsvd_uars );
1214         arbel->limits.reserved_cqs =
1215                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_cqs ) );
1216         arbel->limits.reserved_qps =
1217                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_qps ) );
1218         DBG ( "Device limits:\n ");
1219         DBG_HD ( &dev_lim, sizeof ( dev_lim ) );
1220
1221         /* Register network device */
1222         if ( ( rc = register_netdev ( netdev ) ) != 0 )
1223                 goto err_register_netdev;
1224
1225         return 0;
1226
1227  err_query_dev_lim:
1228  err_register_netdev:
1229  err_ipoib_init:
1230         ib_driver_close ( 0 );
1231         netdev_nullify ( netdev );
1232         netdev_put ( netdev );
1233         return rc;
1234 }
1235
1236 static struct pci_device_id arbel_nics[] = {
1237         PCI_ROM ( 0x15b3, 0x6282, "MT25218", "MT25218 HCA driver" ),
1238         PCI_ROM ( 0x15b3, 0x6274, "MT25204", "MT25204 HCA driver" ),
1239 };
1240
1241 struct pci_driver arbel_driver __pci_driver = {
1242         .ids = arbel_nics,
1243         .id_count = ( sizeof ( arbel_nics ) / sizeof ( arbel_nics[0] ) ),
1244         .probe = arbel_probe,
1245         .remove = arbel_remove,
1246 };