src/drivers/infiniband/linda.c

   1 /*
   2  * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <assert.h>
  26 #include <gpxe/io.h>
  27 #include <gpxe/pci.h>
  28 #include <gpxe/infiniband.h>
  29 #include <gpxe/i2c.h>
  30 #include <gpxe/bitbash.h>
  31 #include <gpxe/malloc.h>
  32 #include <gpxe/iobuf.h>
  33 #include "linda.h"
  34
  35 /**
  36  * @file
  37  *
  38  * QLogic Linda Infiniband HCA
  39  *
  40  */
  41
  42 /** A Linda send work queue */
  43 struct linda_send_work_queue {
  44         /** Send buffer usage */
  45         uint8_t *send_buf;
  46         /** Producer index */
  47         unsigned int prod;
  48         /** Consumer index */
  49         unsigned int cons;
  50 };
  51
  52 /** A Linda receive work queue */
  53 struct linda_recv_work_queue {
  54         /** Receive header ring */
  55         void *header;
  56         /** Receive header producer offset (written by hardware) */
  57         struct QIB_7220_scalar header_prod;
  58         /** Receive header consumer offset */
  59         unsigned int header_cons;
  60         /** Offset within register space of the eager array */
  61         unsigned long eager_array;
  62         /** Number of entries in eager array */
  63         unsigned int eager_entries;
  64         /** Eager array producer index */
  65         unsigned int eager_prod;
  66         /** Eager array consumer index */
  67         unsigned int eager_cons;
  68 };
  69
  70 /** A Linda HCA */
  71 struct linda {
  72         /** Registers */
  73         void *regs;
  74
  75         /** In-use contexts */
  76         uint8_t used_ctx[LINDA_NUM_CONTEXTS];
  77         /** Send work queues */
  78         struct linda_send_work_queue send_wq[LINDA_NUM_CONTEXTS];
  79         /** Receive work queues */
  80         struct linda_recv_work_queue recv_wq[LINDA_NUM_CONTEXTS];
  81
  82         /** Offset within register space of the first send buffer */
  83         unsigned long send_buffer_base;
  84         /** Send buffer availability (reported by hardware) */
  85         struct QIB_7220_SendBufAvail *sendbufavail;
  86         /** Send buffer availability (maintained by software) */
  87         uint8_t send_buf[LINDA_MAX_SEND_BUFS];
  88         /** Send buffer availability producer counter */
  89         unsigned int send_buf_prod;
  90         /** Send buffer availability consumer counter */
  91         unsigned int send_buf_cons;
  92         /** Number of reserved send buffers (across all QPs) */
  93         unsigned int reserved_send_bufs;
  94
  95         /** I2C bit-bashing interface */
  96         struct i2c_bit_basher i2c;
  97         /** I2C serial EEPROM */
  98         struct i2c_device eeprom;
  99 };
 100
 101 /***************************************************************************
 102  *
 103  * Linda register access
 104  *
 105  ***************************************************************************
 106  *
 107  * This card requires atomic 64-bit accesses.  Strange things happen
 108  * if you try to use 32-bit accesses; sometimes they work, sometimes
 109  * they don't, sometimes you get random data.
 110  *
 111  * These accessors use the "movq" MMX instruction, and so won't work
 112  * on really old Pentiums (which won't have PCIe anyway, so this is
 113  * something of a moot point).
 114  */
 115
 116 /**
 117  * Read Linda qword register
 118  *
 119  * @v linda             Linda device
 120  * @v dwords            Register buffer to read into
 121  * @v offset            Register offset
 122  */
 123 static void linda_readq ( struct linda *linda, uint32_t *dwords,
 124                           unsigned long offset ) {
 125         void *addr = ( linda->regs + offset );
 126
 127         __asm__ __volatile__ ( "movq (%1), %%mm0\n\t"
 128                                "movq %%mm0, (%0)\n\t"
 129                                : : "r" ( dwords ), "r" ( addr ) : "memory" );
 130
 131         DBGIO ( "[%08lx] => %08x%08x\n",
 132                 virt_to_phys ( addr ), dwords[1], dwords[0] );
 133 }
 134 #define linda_readq( _linda, _ptr, _offset ) \
 135         linda_readq ( (_linda), (_ptr)->u.dwords, (_offset) )
 136 #define linda_readq_array8b( _linda, _ptr, _offset, _idx ) \
 137         linda_readq ( (_linda), (_ptr), ( (_offset) + ( (_idx) * 8 ) ) )
 138 #define linda_readq_array64k( _linda, _ptr, _offset, _idx ) \
 139         linda_readq ( (_linda), (_ptr), ( (_offset) + ( (_idx) * 65536 ) ) )
 140
 141 /**
 142  * Write Linda qword register
 143  *
 144  * @v linda             Linda device
 145  * @v dwords            Register buffer to write
 146  * @v offset            Register offset
 147  */
 148 static void linda_writeq ( struct linda *linda, const uint32_t *dwords,
 149                            unsigned long offset ) {
 150         void *addr = ( linda->regs + offset );
 151
 152         DBGIO ( "[%08lx] <= %08x%08x\n",
 153                 virt_to_phys ( addr ), dwords[1], dwords[0] );
 154
 155         __asm__ __volatile__ ( "movq (%0), %%mm0\n\t"
 156                                "movq %%mm0, (%1)\n\t"
 157                                : : "r" ( dwords ), "r" ( addr ) : "memory" );
 158 }
 159 #define linda_writeq( _linda, _ptr, _offset ) \
 160         linda_writeq ( (_linda), (_ptr)->u.dwords, (_offset) )
 161 #define linda_writeq_array8b( _linda, _ptr, _offset, _idx ) \
 162         linda_writeq ( (_linda), (_ptr), ( (_offset) + ( (_idx) * 8 ) ) )
 163 #define linda_writeq_array64k( _linda, _ptr, _offset, _idx ) \
 164         linda_writeq ( (_linda), (_ptr), ( (_offset) + ( (_idx) * 65536 ) ) )
 165
 166 /**
 167  * Write Linda dword register
 168  *
 169  * @v linda             Linda device
 170  * @v dword             Value to write
 171  * @v offset            Register offset
 172  */
 173 static void linda_writel ( struct linda *linda, uint32_t dword,
 174                            unsigned long offset ) {
 175         writel ( dword, ( linda->regs + offset ) );
 176 }
 177
 178 /***************************************************************************
 179  *
 180  * Link state management
 181  *
 182  ***************************************************************************
 183  */
 184
 185 /**
 186  * Textual representation of link state
 187  *
 188  * @v link_state        Link state
 189  * @ret link_text       Link state text
 190  */
 191 static const char * linda_link_state_text ( unsigned int link_state ) {
 192         switch ( link_state ) {
 193         case LINDA_LINK_STATE_DOWN:     return "DOWN";
 194         case LINDA_LINK_STATE_INIT:     return "INIT";
 195         case LINDA_LINK_STATE_ARM:      return "ARM";
 196         case LINDA_LINK_STATE_ACTIVE:   return "ACTIVE";
 197         case LINDA_LINK_STATE_ACT_DEFER:return "ACT_DEFER";
 198         default:                        return "UNKNOWN";
 199         }
 200 }
 201
 202 /**
 203  * Handle link state change
 204  *
 205  * @v linda             Linda device
 206  */
 207 static void linda_link_state_changed ( struct ib_device *ibdev ) {
 208         struct linda *linda = ib_get_drvdata ( ibdev );
 209         struct QIB_7220_IBCStatus ibcstatus;
 210         struct QIB_7220_EXTCtrl extctrl;
 211         unsigned int link_state;
 212         unsigned int link_width;
 213         unsigned int link_speed;
 214
 215         /* Read link state */
 216         linda_readq ( linda, &ibcstatus, QIB_7220_IBCStatus_offset );
 217         link_state = BIT_GET ( &ibcstatus, LinkState );
 218         link_width = BIT_GET ( &ibcstatus, LinkWidthActive );
 219         link_speed = BIT_GET ( &ibcstatus, LinkSpeedActive );
 220         DBGC ( linda, "Linda %p link state %s (%s %s)\n", linda,
 221                linda_link_state_text ( link_state ),
 222                ( link_speed ? "DDR" : "SDR" ), ( link_width ? "x4" : "x1" ) );
 223
 224         /* Set LEDs according to link state */
 225         linda_readq ( linda, &extctrl, QIB_7220_EXTCtrl_offset );
 226         BIT_SET ( &extctrl, LEDPriPortGreenOn,
 227                   ( ( link_state >= LINDA_LINK_STATE_INIT ) ? 1 : 0 ) );
 228         BIT_SET ( &extctrl, LEDPriPortYellowOn,
 229                   ( ( link_state >= LINDA_LINK_STATE_ACTIVE ) ? 1 : 0 ) );
 230         linda_writeq ( linda, &extctrl, QIB_7220_EXTCtrl_offset );
 231
 232         /* Notify Infiniband core of link state change */
 233         ibdev->port_state = ( link_state + 1 );
 234         ibdev->link_width_active =
 235                 ( link_width ? IB_LINK_WIDTH_4X : IB_LINK_WIDTH_1X );
 236         ibdev->link_speed_active =
 237                 ( link_speed ? IB_LINK_SPEED_DDR : IB_LINK_SPEED_SDR );
 238         ib_link_state_changed ( ibdev );
 239 }
 240
 241 /**
 242  * Set port information
 243  *
 244  * @v ibdev             Infiniband device
 245  * @v port_info         New port information
 246  */
 247 static int linda_set_port_info ( struct ib_device *ibdev,
 248                                  const struct ib_port_info *port_info ) {
 249         struct linda *linda = ib_get_drvdata ( ibdev );
 250         struct QIB_7220_IBCCtrl ibcctrl;
 251         unsigned int port_state;
 252         unsigned int link_state;
 253
 254         /* Set new link state */
 255         port_state = ( port_info->link_speed_supported__port_state & 0xf );
 256         if ( port_state ) {
 257                 link_state = ( port_state - 1 );
 258                 DBGC ( linda, "Linda %p set link state to %s (%x)\n", linda,
 259                        linda_link_state_text ( link_state ), link_state );
 260                 linda_readq ( linda, &ibcctrl, QIB_7220_IBCCtrl_offset );
 261                 BIT_SET ( &ibcctrl, LinkCmd, link_state );
 262                 linda_writeq ( linda, &ibcctrl, QIB_7220_IBCCtrl_offset );
 263         }
 264
 265         /* Detect and report link state change */
 266         linda_link_state_changed ( ibdev );
 267
 268         return 0;
 269 }
 270
 271 /***************************************************************************
 272  *
 273  * Context allocation
 274  *
 275  ***************************************************************************
 276  */
 277
 278 /**
 279  * Map context number to QPN
 280  *
 281  * @v ctx               Context index
 282  * @ret qpn             Queue pair number
 283  */
 284 static int linda_ctx_to_qpn ( unsigned int ctx ) {
 285         /* This mapping is fixed by hardware */
 286         return ( ctx * 2 );
 287 }
 288
 289 /**
 290  * Map QPN to context number
 291  *
 292  * @v qpn               Queue pair number
 293  * @ret ctx             Context index
 294  */
 295 static int linda_qpn_to_ctx ( unsigned int qpn ) {
 296         /* This mapping is fixed by hardware */
 297         return ( qpn / 2 );
 298 }
 299
 300 /**
 301  * Allocate a context
 302  *
 303  * @v linda             Linda device
 304  * @ret ctx             Context index, or negative error
 305  */
 306 static int linda_alloc_ctx ( struct linda *linda ) {
 307         unsigned int ctx;
 308
 309         for ( ctx = 0 ; ctx < LINDA_NUM_CONTEXTS ; ctx++ ) {
 310
 311                 if ( ! linda->used_ctx[ctx] ) {
 312                         linda->used_ctx[ctx ] = 1;
 313                         DBGC2 ( linda, "Linda %p CTX %d allocated\n",
 314                                 linda, ctx );
 315                         return ctx;
 316                 }
 317         }
 318
 319         DBGC ( linda, "Linda %p out of available contexts\n", linda );
 320         return -ENOENT;
 321 }
 322
 323 /**
 324  * Free a context
 325  *
 326  * @v linda             Linda device
 327  * @v ctx               Context index
 328  */
 329 static void linda_free_ctx ( struct linda *linda, unsigned int ctx ) {
 330
 331         linda->used_ctx[ctx] = 0;
 332         DBGC2 ( linda, "Linda %p CTX %d freed\n", linda, ctx );
 333 }
 334
 335 /***************************************************************************
 336  *
 337  * Send datapath
 338  *
 339  ***************************************************************************
 340  */
 341
 342 /** Send buffer toggle bit
 343  *
 344  * We encode send buffers as 7 bits of send buffer index plus a single
 345  * bit which should match the "check" bit in the SendBufAvail array.
 346  */
 347 #define LINDA_SEND_BUF_TOGGLE 0x80
 348
 349 /**
 350  * Allocate a send buffer
 351  *
 352  * @v linda             Linda device
 353  * @ret send_buf        Send buffer
 354  *
 355  * You must guarantee that a send buffer is available.  This is done
 356  * by refusing to allocate more TX WQEs in total than the number of
 357  * available send buffers.
 358  */
 359 static unsigned int linda_alloc_send_buf ( struct linda *linda ) {
 360         unsigned int send_buf;
 361
 362         send_buf = linda->send_buf[linda->send_buf_cons];
 363         send_buf ^= LINDA_SEND_BUF_TOGGLE;
 364         linda->send_buf_cons = ( ( linda->send_buf_cons + 1 ) %
 365                                  LINDA_MAX_SEND_BUFS );
 366         return send_buf;
 367 }
 368
 369 /**
 370  * Free a send buffer
 371  *
 372  * @v linda             Linda device
 373  * @v send_buf          Send buffer
 374  */
 375 static void linda_free_send_buf ( struct linda *linda,
 376                                   unsigned int send_buf ) {
 377         linda->send_buf[linda->send_buf_prod] = send_buf;
 378         linda->send_buf_prod = ( ( linda->send_buf_prod + 1 ) %
 379                                  LINDA_MAX_SEND_BUFS );
 380 }
 381
 382 /**
 383  * Check to see if send buffer is in use
 384  *
 385  * @v linda             Linda device
 386  * @v send_buf          Send buffer
 387  * @ret in_use          Send buffer is in use
 388  */
 389 static int linda_send_buf_in_use ( struct linda *linda,
 390                                    unsigned int send_buf ) {
 391         unsigned int send_idx;
 392         unsigned int send_check;
 393         unsigned int inusecheck;
 394         unsigned int inuse;
 395         unsigned int check;
 396
 397         send_idx = ( send_buf & ~LINDA_SEND_BUF_TOGGLE );
 398         send_check = ( !! ( send_buf & LINDA_SEND_BUF_TOGGLE ) );
 399         inusecheck = BIT_GET ( linda->sendbufavail, InUseCheck[send_idx] );
 400         inuse = ( !! ( inusecheck & 0x02 ) );
 401         check = ( !! ( inusecheck & 0x01 ) );
 402         return ( inuse || ( check != send_check ) );
 403 }
 404
 405 /**
 406  * Calculate starting offset for send buffer
 407  *
 408  * @v linda             Linda device
 409  * @v send_buf          Send buffer
 410  * @ret offset          Starting offset
 411  */
 412 static unsigned long linda_send_buffer_offset ( struct linda *linda,
 413                                                 unsigned int send_buf ) {
 414         return ( linda->send_buffer_base +
 415                  ( ( send_buf & ~LINDA_SEND_BUF_TOGGLE ) *
 416                    LINDA_SEND_BUF_SIZE ) );
 417 }
 418
 419 /**
 420  * Create send work queue
 421  *
 422  * @v linda             Linda device
 423  * @v qp                Queue pair
 424  */
 425 static int linda_create_send_wq ( struct linda *linda,
 426                                   struct ib_queue_pair *qp ) {
 427         struct ib_work_queue *wq = &qp->send;
 428         struct linda_send_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 429         int rc;
 430
 431         /* Reserve send buffers */
 432         if ( ( linda->reserved_send_bufs + qp->send.num_wqes ) >
 433              LINDA_MAX_SEND_BUFS ) {
 434                 DBGC ( linda, "Linda %p out of send buffers (have %d, used "
 435                        "%d, need %d)\n", linda, LINDA_MAX_SEND_BUFS,
 436                        linda->reserved_send_bufs, qp->send.num_wqes );
 437                 rc = -ENOBUFS;
 438                 goto err_reserve_bufs;
 439         }
 440         linda->reserved_send_bufs += qp->send.num_wqes;
 441
 442         /* Reset work queue */
 443         linda_wq->prod = 0;
 444         linda_wq->cons = 0;
 445
 446         /* Allocate space for send buffer uasge list */
 447         linda_wq->send_buf = zalloc ( qp->send.num_wqes *
 448                                       sizeof ( linda_wq->send_buf[0] ) );
 449         if ( ! linda_wq->send_buf ) {
 450                 rc = -ENOBUFS;
 451                 goto err_alloc_send_buf;
 452         }
 453
 454         return 0;
 455
 456         free ( linda_wq->send_buf );
 457  err_alloc_send_buf:
 458         linda->reserved_send_bufs -= qp->send.num_wqes;
 459  err_reserve_bufs:
 460         return rc;
 461 }
 462
 463 /**
 464  * Destroy send work queue
 465  *
 466  * @v linda             Linda device
 467  * @v qp                Queue pair
 468  */
 469 static void linda_destroy_send_wq ( struct linda *linda,
 470                                     struct ib_queue_pair *qp ) {
 471         struct ib_work_queue *wq = &qp->send;
 472         struct linda_send_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 473
 474         free ( linda_wq->send_buf );
 475         linda->reserved_send_bufs -= qp->send.num_wqes;
 476 }
 477
 478 /**
 479  * Initialise send datapath
 480  *
 481  * @v linda             Linda device
 482  * @ret rc              Return status code
 483  */
 484 static int linda_init_send ( struct linda *linda ) {
 485         struct QIB_7220_SendBufBase sendbufbase;
 486         struct QIB_7220_SendBufAvailAddr sendbufavailaddr;
 487         struct QIB_7220_SendCtrl sendctrl;
 488         unsigned int i;
 489         int rc;
 490
 491         /* Retrieve SendBufBase */
 492         linda_readq ( linda, &sendbufbase, QIB_7220_SendBufBase_offset );
 493         linda->send_buffer_base = BIT_GET ( &sendbufbase,
 494                                             BaseAddr_SmallPIO );
 495         DBGC ( linda, "Linda %p send buffers at %lx\n",
 496                linda, linda->send_buffer_base );
 497
 498         /* Initialise the send_buf[] array */
 499         for ( i = 0 ; i < LINDA_MAX_SEND_BUFS ; i++ )
 500                 linda->send_buf[i] = i;
 501
 502         /* Allocate space for the SendBufAvail array */
 503         linda->sendbufavail = malloc_dma ( sizeof ( *linda->sendbufavail ),
 504                                            LINDA_SENDBUFAVAIL_ALIGN );
 505         if ( ! linda->sendbufavail ) {
 506                 rc = -ENOMEM;
 507                 goto err_alloc_sendbufavail;
 508         }
 509         memset ( linda->sendbufavail, 0, sizeof ( linda->sendbufavail ) );
 510
 511         /* Program SendBufAvailAddr into the hardware */
 512         memset ( &sendbufavailaddr, 0, sizeof ( sendbufavailaddr ) );
 513         BIT_FILL_1 ( &sendbufavailaddr, SendBufAvailAddr,
 514                      ( virt_to_bus ( linda->sendbufavail ) >> 6 ) );
 515         linda_writeq ( linda, &sendbufavailaddr,
 516                        QIB_7220_SendBufAvailAddr_offset );
 517
 518         /* Enable sending and DMA of SendBufAvail */
 519         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
 520         BIT_FILL_2 ( &sendctrl,
 521                      SendBufAvailUpd, 1,
 522                      SPioEnable, 1 );
 523         linda_writeq ( linda, &sendctrl, QIB_7220_SendCtrl_offset );
 524
 525         return 0;
 526
 527         free_dma ( linda->sendbufavail, sizeof ( *linda->sendbufavail ) );
 528  err_alloc_sendbufavail:
 529         return rc;
 530 }
 531
 532 /**
 533  * Shut down send datapath
 534  *
 535  * @v linda             Linda device
 536  */
 537 static void linda_fini_send ( struct linda *linda ) {
 538         struct QIB_7220_SendCtrl sendctrl;
 539
 540         /* Disable sending and DMA of SendBufAvail */
 541         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
 542         linda_writeq ( linda, &sendctrl, QIB_7220_SendCtrl_offset );
 543         mb();
 544
 545         /* Ensure hardware has seen this disable */
 546         linda_readq ( linda, &sendctrl, QIB_7220_SendCtrl_offset );
 547
 548         free_dma ( linda->sendbufavail, sizeof ( *linda->sendbufavail ) );
 549 }
 550
 551 /***************************************************************************
 552  *
 553  * Receive datapath
 554  *
 555  ***************************************************************************
 556  */
 557
 558 /**
 559  * Create receive work queue
 560  *
 561  * @v linda             Linda device
 562  * @v qp                Queue pair
 563  * @ret rc              Return status code
 564  */
 565 static int linda_create_recv_wq ( struct linda *linda,
 566                                   struct ib_queue_pair *qp ) {
 567         struct ib_work_queue *wq = &qp->recv;
 568         struct linda_recv_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 569         struct QIB_7220_RcvHdrAddr0 rcvhdraddr;
 570         struct QIB_7220_RcvHdrTailAddr0 rcvhdrtailaddr;
 571         struct QIB_7220_RcvHdrHead0 rcvhdrhead;
 572         struct QIB_7220_scalar rcvegrindexhead;
 573         struct QIB_7220_RcvCtrl rcvctrl;
 574         unsigned int ctx = linda_qpn_to_ctx ( qp->qpn );
 575         int rc;
 576
 577         /* Reset context information */
 578         memset ( &linda_wq->header_prod, 0,
 579                  sizeof ( linda_wq->header_prod ) );
 580         linda_wq->header_cons = 0;
 581         linda_wq->eager_prod = 0;
 582         linda_wq->eager_cons = 0;
 583
 584         /* Allocate receive header buffer */
 585         linda_wq->header = malloc_dma ( LINDA_RECV_HEADERS_SIZE,
 586                                         LINDA_RECV_HEADERS_ALIGN );
 587         if ( ! linda_wq->header ) {
 588                 rc = -ENOMEM;
 589                 goto err_alloc_header;
 590         }
 591
 592         /* Enable context in hardware */
 593         memset ( &rcvhdraddr, 0, sizeof ( rcvhdraddr ) );
 594         BIT_FILL_1 ( &rcvhdraddr, RcvHdrAddr0,
 595                      ( virt_to_bus ( linda_wq->header ) >> 2 ) );
 596         linda_writeq_array8b ( linda, &rcvhdraddr,
 597                                QIB_7220_RcvHdrAddr0_offset, ctx );
 598         memset ( &rcvhdrtailaddr, 0, sizeof ( rcvhdrtailaddr ) );
 599         BIT_FILL_1 ( &rcvhdrtailaddr, RcvHdrTailAddr0,
 600                      ( virt_to_bus ( &linda_wq->header_prod ) >> 2 ) );
 601         linda_writeq_array8b ( linda, &rcvhdrtailaddr,
 602                                QIB_7220_RcvHdrTailAddr0_offset, ctx );
 603         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
 604         BIT_FILL_1 ( &rcvhdrhead, counter, 1 );
 605         linda_writeq_array64k ( linda, &rcvhdrhead,
 606                                 QIB_7220_RcvHdrHead0_offset, ctx );
 607         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
 608         BIT_FILL_1 ( &rcvegrindexhead, Value, 1 );
 609         linda_writeq_array64k ( linda, &rcvegrindexhead,
 610                                 QIB_7220_RcvEgrIndexHead0_offset, ctx );
 611         linda_readq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 612         BIT_SET ( &rcvctrl, PortEnable[ctx], 1 );
 613         BIT_SET ( &rcvctrl, IntrAvail[ctx], 1 );
 614         linda_writeq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 615
 616         DBGC ( linda, "Linda %p QPN %ld CTX %d hdrs [%lx,%lx) prod %lx\n",
 617                linda, qp->qpn, ctx, virt_to_bus ( linda_wq->header ),
 618                ( virt_to_bus ( linda_wq->header ) + LINDA_RECV_HEADERS_SIZE ),
 619                virt_to_bus ( &linda_wq->header_prod ) );
 620         return 0;
 621
 622         free_dma ( linda_wq->header, LINDA_RECV_HEADERS_SIZE );
 623  err_alloc_header:
 624         return rc;
 625 }
 626
 627 /**
 628  * Destroy receive work queue
 629  *
 630  * @v linda             Linda device
 631  * @v qp                Queue pair
 632  */
 633 static void linda_destroy_recv_wq ( struct linda *linda,
 634                                     struct ib_queue_pair *qp ) {
 635         struct ib_work_queue *wq = &qp->recv;
 636         struct linda_recv_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 637         struct QIB_7220_RcvCtrl rcvctrl;
 638         unsigned int ctx = linda_qpn_to_ctx ( qp->qpn );
 639
 640         /* Disable context in hardware */
 641         linda_readq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 642         BIT_SET ( &rcvctrl, PortEnable[ctx], 0 );
 643         BIT_SET ( &rcvctrl, IntrAvail[ctx], 0 );
 644         linda_writeq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 645
 646         /* Make sure the hardware has seen that the context is disabled */
 647         linda_readq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 648         mb();
 649
 650         /* Free headers ring */
 651         free_dma ( linda_wq->header, LINDA_RECV_HEADERS_SIZE );
 652
 653         /* Free context */
 654         linda_free_ctx ( linda, ctx );
 655 }
 656
 657 /**
 658  * Initialise receive datapath
 659  *
 660  * @v linda             Linda device
 661  * @ret rc              Return status code
 662  */
 663 static int linda_init_recv ( struct linda *linda ) {
 664         struct QIB_7220_RcvCtrl rcvctrl;
 665         struct QIB_7220_scalar rcvegrbase;
 666         struct QIB_7220_scalar rcvhdrentsize;
 667         struct QIB_7220_scalar rcvhdrcnt;
 668         struct QIB_7220_RcvBTHQP rcvbthqp;
 669         unsigned int portcfg;
 670         unsigned long egrbase;
 671         unsigned int eager_array_size_0;
 672         unsigned int eager_array_size_other;
 673         unsigned int ctx;
 674
 675         /* Select configuration based on number of contexts */
 676         switch ( LINDA_NUM_CONTEXTS ) {
 677         case 5:
 678                 portcfg = LINDA_PORTCFG_5CTX;
 679                 eager_array_size_0 = LINDA_EAGER_ARRAY_SIZE_5CTX_0;
 680                 eager_array_size_other = LINDA_EAGER_ARRAY_SIZE_5CTX_OTHER;
 681                 break;
 682         case 9:
 683                 portcfg = LINDA_PORTCFG_9CTX;
 684                 eager_array_size_0 = LINDA_EAGER_ARRAY_SIZE_9CTX_0;
 685                 eager_array_size_other = LINDA_EAGER_ARRAY_SIZE_9CTX_OTHER;
 686                 break;
 687         case 17:
 688                 portcfg = LINDA_PORTCFG_17CTX;
 689                 eager_array_size_0 = LINDA_EAGER_ARRAY_SIZE_17CTX_0;
 690                 eager_array_size_other = LINDA_EAGER_ARRAY_SIZE_17CTX_OTHER;
 691                 break;
 692         default:
 693                 linker_assert ( 0, invalid_LINDA_NUM_CONTEXTS );
 694                 return -EINVAL;
 695         }
 696
 697         /* Configure number of contexts */
 698         memset ( &rcvctrl, 0, sizeof ( rcvctrl ) );
 699         BIT_FILL_3 ( &rcvctrl,
 700                      TailUpd, 1,
 701                      PortCfg, portcfg,
 702                      RcvQPMapEnable, 1 );
 703         linda_writeq ( linda, &rcvctrl, QIB_7220_RcvCtrl_offset );
 704
 705         /* Configure receive header buffer sizes */
 706         memset ( &rcvhdrcnt, 0, sizeof ( rcvhdrcnt ) );
 707         BIT_FILL_1 ( &rcvhdrcnt, Value, LINDA_RECV_HEADER_COUNT );
 708         linda_writeq ( linda, &rcvhdrcnt, QIB_7220_RcvHdrCnt_offset );
 709         memset ( &rcvhdrentsize, 0, sizeof ( rcvhdrentsize ) );
 710         BIT_FILL_1 ( &rcvhdrentsize, Value, ( LINDA_RECV_HEADER_SIZE >> 2 ) );
 711         linda_writeq ( linda, &rcvhdrentsize, QIB_7220_RcvHdrEntSize_offset );
 712
 713         /* Calculate eager array start addresses for each context */
 714         linda_readq ( linda, &rcvegrbase, QIB_7220_RcvEgrBase_offset );
 715         egrbase = BIT_GET ( &rcvegrbase, Value );
 716         linda->recv_wq[0].eager_array = egrbase;
 717         linda->recv_wq[0].eager_entries = eager_array_size_0;
 718         egrbase += ( eager_array_size_0 * sizeof ( struct QIB_7220_RcvEgr ) );
 719         for ( ctx = 1 ; ctx < LINDA_NUM_CONTEXTS ; ctx++ ) {
 720                 linda->recv_wq[ctx].eager_array = egrbase;
 721                 linda->recv_wq[ctx].eager_entries = eager_array_size_other;
 722                 egrbase += ( eager_array_size_other *
 723                              sizeof ( struct QIB_7220_RcvEgr ) );
 724         }
 725         for ( ctx = 0 ; ctx < LINDA_NUM_CONTEXTS ; ctx++ ) {
 726                 DBGC ( linda, "Linda %p CTX %d eager array at %lx (%d "
 727                        "entries)\n", linda, ctx,
 728                        linda->recv_wq[ctx].eager_array,
 729                        linda->recv_wq[ctx].eager_entries );
 730         }
 731
 732         /* Set the BTH QP for Infinipath packets to an unused value */
 733         memset ( &rcvbthqp, 0, sizeof ( rcvbthqp ) );
 734         BIT_FILL_1 ( &rcvbthqp, RcvBTHQP, LINDA_QP_IDETH );
 735         linda_writeq ( linda, &rcvbthqp, QIB_7220_RcvBTHQP_offset );
 736
 737         return 0;
 738 }
 739
 740 /**
 741  * Shut down receive datapath
 742  *
 743  * @v linda             Linda device
 744  */
 745 static void linda_fini_recv ( struct linda *linda __unused ) {
 746         /* Nothing to do; all contexts were already disabled when the
 747          * queue pairs were destroyed
 748          */
 749 }
 750
 751 /***************************************************************************
 752  *
 753  * Completion queue operations
 754  *
 755  ***************************************************************************
 756  */
 757
 758 /**
 759  * Create completion queue
 760  *
 761  * @v ibdev             Infiniband device
 762  * @v cq                Completion queue
 763  * @ret rc              Return status code
 764  */
 765 static int linda_create_cq ( struct ib_device *ibdev,
 766                              struct ib_completion_queue *cq ) {
 767         struct linda *linda = ib_get_drvdata ( ibdev );
 768         static int cqn;
 769
 770         /* The hardware has no concept of completion queues.  We
 771          * simply use the association between CQs and WQs (already
 772          * handled by the IB core) to decide which WQs to poll.
 773          *
 774          * We do set a CQN, just to avoid confusing debug messages
 775          * from the IB core.
 776          */
 777         cq->cqn = ++cqn;
 778         DBGC ( linda, "Linda %p CQN %ld created\n", linda, cq->cqn );
 779
 780         return 0;
 781 }
 782
 783 /**
 784  * Destroy completion queue
 785  *
 786  * @v ibdev             Infiniband device
 787  * @v cq                Completion queue
 788  */
 789 static void linda_destroy_cq ( struct ib_device *ibdev,
 790                                struct ib_completion_queue *cq ) {
 791         struct linda *linda = ib_get_drvdata ( ibdev );
 792
 793         /* Nothing to do */
 794         DBGC ( linda, "Linda %p CQN %ld destroyed\n", linda, cq->cqn );
 795 }
 796
 797 /***************************************************************************
 798  *
 799  * Queue pair operations
 800  *
 801  ***************************************************************************
 802  */
 803
 804 /**
 805  * Create queue pair
 806  *
 807  * @v ibdev             Infiniband device
 808  * @v qp                Queue pair
 809  * @ret rc              Return status code
 810  */
 811 static int linda_create_qp ( struct ib_device *ibdev,
 812                              struct ib_queue_pair *qp ) {
 813         struct linda *linda = ib_get_drvdata ( ibdev );
 814         int ctx;
 815         int rc;
 816
 817         /* Locate an available context */
 818         ctx = linda_alloc_ctx ( linda );
 819         if ( ctx < 0 ) {
 820                 rc = ctx;
 821                 goto err_alloc_ctx;
 822         }
 823
 824         /* Set queue pair number based on context index */
 825         qp->qpn = linda_ctx_to_qpn ( ctx );
 826
 827         /* Set work-queue private data pointers */
 828         ib_wq_set_drvdata ( &qp->send, &linda->send_wq[ctx] );
 829         ib_wq_set_drvdata ( &qp->recv, &linda->recv_wq[ctx] );
 830
 831         /* Create receive work queue */
 832         if ( ( rc = linda_create_recv_wq ( linda, qp ) ) != 0 )
 833                 goto err_create_recv_wq;
 834
 835         /* Create send work queue */
 836         if ( ( rc = linda_create_send_wq ( linda, qp ) ) != 0 )
 837                 goto err_create_send_wq;
 838
 839         return 0;
 840
 841         linda_destroy_send_wq ( linda, qp );
 842  err_create_send_wq:
 843         linda_destroy_recv_wq ( linda, qp );
 844  err_create_recv_wq:
 845         linda_free_ctx ( linda, ctx );
 846  err_alloc_ctx:
 847         return rc;
 848 }
 849
 850 /**
 851  * Modify queue pair
 852  *
 853  * @v ibdev             Infiniband device
 854  * @v qp                Queue pair
 855  * @v mod_list          Modification list
 856  * @ret rc              Return status code
 857  */
 858 static int linda_modify_qp ( struct ib_device *ibdev,
 859                              struct ib_queue_pair *qp,
 860                              unsigned long mod_list __unused ) {
 861         struct linda *linda = ib_get_drvdata ( ibdev );
 862
 863         /* Nothing to do; the hardware doesn't have a notion of queue
 864          * keys
 865          */
 866         DBGC ( linda, "Linda %p QPN %ld modified\n", linda, qp->qpn );
 867         return 0;
 868 }
 869
 870 /**
 871  * Destroy queue pair
 872  *
 873  * @v ibdev             Infiniband device
 874  * @v qp                Queue pair
 875  */
 876 static void linda_destroy_qp ( struct ib_device *ibdev,
 877                                struct ib_queue_pair *qp ) {
 878         struct linda *linda = ib_get_drvdata ( ibdev );
 879
 880         linda_destroy_send_wq ( linda, qp );
 881         linda_destroy_recv_wq ( linda, qp );
 882 }
 883
 884 /***************************************************************************
 885  *
 886  * Work request operations
 887  *
 888  ***************************************************************************
 889  */
 890
 891 /**
 892  * Post send work queue entry
 893  *
 894  * @v ibdev             Infiniband device
 895  * @v qp                Queue pair
 896  * @v av                Address vector
 897  * @v iobuf             I/O buffer
 898  * @ret rc              Return status code
 899  */
 900 static int linda_post_send ( struct ib_device *ibdev,
 901                              struct ib_queue_pair *qp,
 902                              struct ib_address_vector *av,
 903                              struct io_buffer *iobuf ) {
 904         struct linda *linda = ib_get_drvdata ( ibdev );
 905         struct ib_work_queue *wq = &qp->send;
 906         struct linda_send_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 907         struct QIB_7220_SendPbc sendpbc;
 908         uint8_t header_buf[IB_MAX_HEADER_SIZE];
 909         struct io_buffer headers;
 910         unsigned int send_buf;
 911         unsigned long start_offset;
 912         unsigned long offset;
 913         size_t len;
 914         ssize_t frag_len;
 915         uint32_t *data;
 916
 917         /* Allocate send buffer and calculate offset */
 918         send_buf = linda_alloc_send_buf ( linda );
 919         start_offset = offset = linda_send_buffer_offset ( linda, send_buf );
 920
 921         /* Store I/O buffer and send buffer index */
 922         assert ( wq->iobufs[linda_wq->prod] == NULL );
 923         wq->iobufs[linda_wq->prod] = iobuf;
 924         linda_wq->send_buf[linda_wq->prod] = send_buf;
 925
 926         /* Construct headers */
 927         iob_populate ( &headers, header_buf, 0, sizeof ( header_buf ) );
 928         iob_reserve ( &headers, sizeof ( header_buf ) );
 929         ib_push ( ibdev, &headers, qp, iob_len ( iobuf ), av );
 930
 931         /* Calculate packet length */
 932         len = ( ( sizeof ( sendpbc ) + iob_len ( &headers ) +
 933                   iob_len ( iobuf ) + 3 ) & ~3 );
 934
 935         /* Construct send per-buffer control word */
 936         memset ( &sendpbc, 0, sizeof ( sendpbc ) );
 937         BIT_FILL_2 ( &sendpbc,
 938                      LengthP1_toibc, ( ( len >> 2 ) - 1 ),
 939                      VL15, 1 );
 940
 941         /* Write SendPbc */
 942         DBG_DISABLE ( DBGLVL_IO );
 943         linda_writeq ( linda, &sendpbc, offset );
 944         offset += sizeof ( sendpbc );
 945
 946         /* Write headers */
 947         for ( data = headers.data, frag_len = iob_len ( &headers ) ;
 948               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
 949                 linda_writel ( linda, *data, offset );
 950         }
 951
 952         /* Write data */
 953         for ( data = iobuf->data, frag_len = iob_len ( iobuf ) ;
 954               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
 955                 linda_writel ( linda, *data, offset );
 956         }
 957         DBG_ENABLE ( DBGLVL_IO );
 958
 959         assert ( ( start_offset + len ) == offset );
 960         DBGC2 ( linda, "Linda %p QPN %ld TX %d(%d) posted [%lx,%lx)\n",
 961                 linda, qp->qpn, send_buf, linda_wq->prod,
 962                 start_offset, offset );
 963
 964         /* Increment producer counter */
 965         linda_wq->prod = ( ( linda_wq->prod + 1 ) & ( wq->num_wqes - 1 ) );
 966
 967         return 0;
 968 }
 969
 970 /**
 971  * Complete send work queue entry
 972  *
 973  * @v ibdev             Infiniband device
 974  * @v qp                Queue pair
 975  * @v wqe_idx           Work queue entry index
 976  */
 977 static void linda_complete_send ( struct ib_device *ibdev,
 978                                   struct ib_queue_pair *qp,
 979                                   unsigned int wqe_idx ) {
 980         struct linda *linda = ib_get_drvdata ( ibdev );
 981         struct ib_work_queue *wq = &qp->send;
 982         struct linda_send_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
 983         struct io_buffer *iobuf;
 984         unsigned int send_buf;
 985
 986         /* Parse completion */
 987         send_buf = linda_wq->send_buf[wqe_idx];
 988         DBGC2 ( linda, "Linda %p QPN %ld TX %d(%d) complete\n",
 989                 linda, qp->qpn, send_buf, wqe_idx );
 990
 991         /* Complete work queue entry */
 992         iobuf = wq->iobufs[wqe_idx];
 993         assert ( iobuf != NULL );
 994         ib_complete_send ( ibdev, qp, iobuf, 0 );
 995         wq->iobufs[wqe_idx] = NULL;
 996
 997         /* Free send buffer */
 998         linda_free_send_buf ( linda, send_buf );
 999 }
1000
1001 /**
1002  * Poll send work queue
1003  *
1004  * @v ibdev             Infiniband device
1005  * @v qp                Queue pair
1006  */
1007 static void linda_poll_send_wq ( struct ib_device *ibdev,
1008                                  struct ib_queue_pair *qp ) {
1009         struct linda *linda = ib_get_drvdata ( ibdev );
1010         struct ib_work_queue *wq = &qp->send;
1011         struct linda_send_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
1012         unsigned int send_buf;
1013
1014         /* Look for completions */
1015         while ( wq->fill ) {
1016
1017                 /* Check to see if send buffer has completed */
1018                 send_buf = linda_wq->send_buf[linda_wq->cons];
1019                 if ( linda_send_buf_in_use ( linda, send_buf ) )
1020                         break;
1021
1022                 /* Complete this buffer */
1023                 linda_complete_send ( ibdev, qp, linda_wq->cons );
1024
1025                 /* Increment consumer counter */
1026                 linda_wq->cons = ( ( linda_wq->cons + 1 ) &
1027                                    ( wq->num_wqes - 1 ) );
1028         }
1029 }
1030
1031 /**
1032  * Post receive work queue entry
1033  *
1034  * @v ibdev             Infiniband device
1035  * @v qp                Queue pair
1036  * @v iobuf             I/O buffer
1037  * @ret rc              Return status code
1038  */
1039 static int linda_post_recv ( struct ib_device *ibdev,
1040                              struct ib_queue_pair *qp,
1041                              struct io_buffer *iobuf ) {
1042         struct linda *linda = ib_get_drvdata ( ibdev );
1043         struct ib_work_queue *wq = &qp->recv;
1044         struct linda_recv_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
1045         struct QIB_7220_RcvEgr rcvegr;
1046         struct QIB_7220_scalar rcvegrindexhead;
1047         unsigned int ctx = linda_qpn_to_ctx ( qp->qpn );
1048         physaddr_t addr;
1049         size_t len;
1050         unsigned int wqe_idx;
1051         unsigned int bufsize;
1052
1053         /* Sanity checks */
1054         addr = virt_to_bus ( iobuf->data );
1055         len = iob_tailroom ( iobuf );
1056         if ( addr & ( LINDA_EAGER_BUFFER_ALIGN - 1 ) ) {
1057                 DBGC ( linda, "Linda %p QPN %ld misaligned RX buffer "
1058                        "(%08lx)\n", linda, qp->qpn, addr );
1059                 return -EINVAL;
1060         }
1061         if ( len != LINDA_RECV_PAYLOAD_SIZE ) {
1062                 DBGC ( linda, "Linda %p QPN %ld wrong RX buffer size (%zd)\n",
1063                        linda, qp->qpn, len );
1064                 return -EINVAL;
1065         }
1066
1067         /* Calculate eager producer index and WQE index */
1068         wqe_idx = ( linda_wq->eager_prod & ( wq->num_wqes - 1 ) );
1069         assert ( wq->iobufs[wqe_idx] == NULL );
1070
1071         /* Store I/O buffer */
1072         wq->iobufs[wqe_idx] = iobuf;
1073
1074         /* Calculate buffer size */
1075         switch ( LINDA_RECV_PAYLOAD_SIZE ) {
1076         case 2048:  bufsize = LINDA_EAGER_BUFFER_2K;  break;
1077         case 4096:  bufsize = LINDA_EAGER_BUFFER_4K;  break;
1078         case 8192:  bufsize = LINDA_EAGER_BUFFER_8K;  break;
1079         case 16384: bufsize = LINDA_EAGER_BUFFER_16K; break;
1080         case 32768: bufsize = LINDA_EAGER_BUFFER_32K; break;
1081         case 65536: bufsize = LINDA_EAGER_BUFFER_64K; break;
1082         default:    linker_assert ( 0, invalid_rx_payload_size );
1083                     bufsize = LINDA_EAGER_BUFFER_NONE;
1084         }
1085
1086         /* Post eager buffer */
1087         memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1088         BIT_FILL_2 ( &rcvegr,
1089                      Addr, ( addr >> 11 ),
1090                      BufSize, bufsize );
1091         linda_writeq_array8b ( linda, &rcvegr,
1092                                linda_wq->eager_array, linda_wq->eager_prod );
1093         DBGC2 ( linda, "Linda %p QPN %ld RX egr %d(%d) posted [%lx,%lx)\n",
1094                 linda, qp->qpn, linda_wq->eager_prod, wqe_idx,
1095                 addr, ( addr + len ) );
1096
1097         /* Increment producer index */
1098         linda_wq->eager_prod = ( ( linda_wq->eager_prod + 1 ) &
1099                                  ( linda_wq->eager_entries - 1 ) );
1100
1101         /* Update head index */
1102         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
1103         BIT_FILL_1 ( &rcvegrindexhead,
1104                      Value, ( ( linda_wq->eager_prod + 1 ) &
1105                               ( linda_wq->eager_entries - 1 ) ) );
1106         linda_writeq_array64k ( linda, &rcvegrindexhead,
1107                                 QIB_7220_RcvEgrIndexHead0_offset, ctx );
1108
1109         return 0;
1110 }
1111
1112 /**
1113  * Complete receive work queue entry
1114  *
1115  * @v ibdev             Infiniband device
1116  * @v qp                Queue pair
1117  * @v header_offs       Header offset
1118  */
1119 static void linda_complete_recv ( struct ib_device *ibdev,
1120                                   struct ib_queue_pair *qp,
1121                                   unsigned int header_offs ) {
1122         struct linda *linda = ib_get_drvdata ( ibdev );
1123         struct ib_work_queue *wq = &qp->recv;
1124         struct linda_recv_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
1125         struct QIB_7220_RcvHdrFlags *rcvhdrflags;
1126         struct QIB_7220_RcvEgr rcvegr;
1127         struct io_buffer headers;
1128         struct io_buffer *iobuf;
1129         struct ib_queue_pair *intended_qp;
1130         struct ib_address_vector av;
1131         unsigned int rcvtype;
1132         unsigned int pktlen;
1133         unsigned int egrindex;
1134         unsigned int useegrbfr;
1135         unsigned int iberr, mkerr, tiderr, khdrerr, mtuerr;
1136         unsigned int lenerr, parityerr, vcrcerr, icrcerr;
1137         unsigned int err;
1138         unsigned int hdrqoffset;
1139         unsigned int header_len;
1140         unsigned int padded_payload_len;
1141         unsigned int wqe_idx;
1142         size_t payload_len;
1143         int qp0;
1144         int rc;
1145
1146         /* RcvHdrFlags are at the end of the header entry */
1147         rcvhdrflags = ( linda_wq->header + header_offs +
1148                         LINDA_RECV_HEADER_SIZE - sizeof ( *rcvhdrflags ) );
1149         rcvtype = BIT_GET ( rcvhdrflags, RcvType );
1150         pktlen = ( BIT_GET ( rcvhdrflags, PktLen ) << 2 );
1151         egrindex = BIT_GET ( rcvhdrflags, EgrIndex );
1152         useegrbfr = BIT_GET ( rcvhdrflags, UseEgrBfr );
1153         hdrqoffset = ( BIT_GET ( rcvhdrflags, HdrqOffset ) << 2 );
1154         iberr = BIT_GET ( rcvhdrflags, IBErr );
1155         mkerr = BIT_GET ( rcvhdrflags, MKErr );
1156         tiderr = BIT_GET ( rcvhdrflags, TIDErr );
1157         khdrerr = BIT_GET ( rcvhdrflags, KHdrErr );
1158         mtuerr = BIT_GET ( rcvhdrflags, MTUErr );
1159         lenerr = BIT_GET ( rcvhdrflags, LenErr );
1160         parityerr = BIT_GET ( rcvhdrflags, ParityErr );
1161         vcrcerr = BIT_GET ( rcvhdrflags, VCRCErr );
1162         icrcerr = BIT_GET ( rcvhdrflags, ICRCErr );
1163         header_len = ( LINDA_RECV_HEADER_SIZE - hdrqoffset -
1164                        sizeof ( *rcvhdrflags ) );
1165         padded_payload_len = ( pktlen - header_len - 4 /* ICRC */ );
1166         err = ( iberr | mkerr | tiderr | khdrerr | mtuerr |
1167                 lenerr | parityerr | vcrcerr | icrcerr );
1168         /* IB header is placed immediately before RcvHdrFlags */
1169         iob_populate ( &headers, ( ( ( void * ) rcvhdrflags ) - header_len ),
1170                        header_len, header_len );
1171
1172         /* Dump diagnostic information */
1173         if ( err || ( ! useegrbfr ) ) {
1174                 DBGC ( linda, "Linda %p QPN %ld RX egr %d%s hdr %d type %d "
1175                        "len %d(%d+%d+4)%s%s%s%s%s%s%s%s%s%s%s\n", linda,
1176                        qp->qpn, egrindex, ( useegrbfr ? "" : "(unused)" ),
1177                        ( header_offs / LINDA_RECV_HEADER_SIZE ), rcvtype,
1178                        pktlen, header_len, padded_payload_len,
1179                        ( err ? " [Err" : "" ), ( iberr ? " IB" : "" ),
1180                        ( mkerr ? " MK" : "" ), ( tiderr ? " TID" : "" ),
1181                        ( khdrerr ? " KHdr" : "" ), ( mtuerr ? " MTU" : "" ),
1182                        ( lenerr ? " Len" : "" ), ( parityerr ? " Parity" : ""),
1183                        ( vcrcerr ? " VCRC" : "" ), ( icrcerr ? " ICRC" : "" ),
1184                        ( err ? "]" : "" ) );
1185         } else {
1186                 DBGC2 ( linda, "Linda %p QPN %ld RX egr %d hdr %d type %d "
1187                         "len %d(%d+%d+4)\n", linda, qp->qpn, egrindex,
1188                         ( header_offs / LINDA_RECV_HEADER_SIZE ), rcvtype,
1189                         pktlen, header_len, padded_payload_len );
1190         }
1191         DBGCP_HDA ( linda, hdrqoffset, headers.data,
1192                     ( header_len + sizeof ( *rcvhdrflags ) ) );
1193
1194         /* Parse header to generate address vector */
1195         qp0 = ( qp->qpn == 0 );
1196         intended_qp = NULL;
1197         if ( ( rc = ib_pull ( ibdev, &headers, ( qp0 ? &intended_qp : NULL ),
1198                               &payload_len, &av ) ) != 0 ) {
1199                 DBGC ( linda, "Linda %p could not parse headers: %s\n",
1200                        linda, strerror ( rc ) );
1201                 err = 1;
1202         }
1203         if ( ! intended_qp )
1204                 intended_qp = qp;
1205
1206         /* Complete this buffer and any skipped buffers.  Note that
1207          * when the hardware runs out of buffers, it will repeatedly
1208          * report the same buffer (the tail) as a TID error, and that
1209          * it also has a habit of sometimes skipping over several
1210          * buffers at once.
1211          */
1212         while ( 1 ) {
1213
1214                 /* If we have caught up to the producer counter, stop.
1215                  * This will happen when the hardware first runs out
1216                  * of buffers and starts reporting TID errors against
1217                  * the eager buffer it wants to use next.
1218                  */
1219                 if ( linda_wq->eager_cons == linda_wq->eager_prod )
1220                         break;
1221
1222                 /* If we have caught up to where we should be after
1223                  * completing this egrindex, stop.  We phrase the test
1224                  * this way to avoid completing the entire ring when
1225                  * we receive the same egrindex twice in a row.
1226                  */
1227                 if ( ( linda_wq->eager_cons ==
1228                        ( ( egrindex + 1 ) & ( linda_wq->eager_entries - 1 ) )))
1229                         break;
1230
1231                 /* Identify work queue entry and corresponding I/O
1232                  * buffer.
1233                  */
1234                 wqe_idx = ( linda_wq->eager_cons & ( wq->num_wqes - 1 ) );
1235                 iobuf = wq->iobufs[wqe_idx];
1236                 assert ( iobuf != NULL );
1237                 wq->iobufs[wqe_idx] = NULL;
1238
1239                 /* Complete the eager buffer */
1240                 if ( linda_wq->eager_cons == egrindex ) {
1241                         /* Completing the eager buffer described in
1242                          * this header entry.
1243                          */
1244                         iob_put ( iobuf, payload_len );
1245                         rc = ( err ? -EIO : ( useegrbfr ? 0 : -ECANCELED ) );
1246                         /* Redirect to target QP if necessary */
1247                         if ( qp != intended_qp ) {
1248                                 DBGC ( linda, "Linda %p redirecting QPN %ld "
1249                                        "=> %ld\n",
1250                                        linda, qp->qpn, intended_qp->qpn );
1251                                 /* Compensate for incorrect fill levels */
1252                                 qp->recv.fill--;
1253                                 intended_qp->recv.fill++;
1254                         }
1255                         ib_complete_recv ( ibdev, intended_qp, &av, iobuf, rc);
1256                 } else {
1257                         /* Completing on a skipped-over eager buffer */
1258                         ib_complete_recv ( ibdev, qp, &av, iobuf, -ECANCELED );
1259                 }
1260
1261                 /* Clear eager buffer */
1262                 memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1263                 linda_writeq_array8b ( linda, &rcvegr, linda_wq->eager_array,
1264                                        linda_wq->eager_cons );
1265
1266                 /* Increment consumer index */
1267                 linda_wq->eager_cons = ( ( linda_wq->eager_cons + 1 ) &
1268                                          ( linda_wq->eager_entries - 1 ) );
1269         }
1270 }
1271
1272 /**
1273  * Poll receive work queue
1274  *
1275  * @v ibdev             Infiniband device
1276  * @v qp                Queue pair
1277  */
1278 static void linda_poll_recv_wq ( struct ib_device *ibdev,
1279                                  struct ib_queue_pair *qp ) {
1280         struct linda *linda = ib_get_drvdata ( ibdev );
1281         struct ib_work_queue *wq = &qp->recv;
1282         struct linda_recv_work_queue *linda_wq = ib_wq_get_drvdata ( wq );
1283         struct QIB_7220_RcvHdrHead0 rcvhdrhead;
1284         unsigned int ctx = linda_qpn_to_ctx ( qp->qpn );
1285         unsigned int header_prod;
1286
1287         /* Check for received packets */
1288         header_prod = ( BIT_GET ( &linda_wq->header_prod, Value ) << 2 );
1289         if ( header_prod == linda_wq->header_cons )
1290                 return;
1291
1292         /* Process all received packets */
1293         while ( linda_wq->header_cons != header_prod ) {
1294
1295                 /* Complete the receive */
1296                 linda_complete_recv ( ibdev, qp, linda_wq->header_cons );
1297
1298                 /* Increment the consumer offset */
1299                 linda_wq->header_cons += LINDA_RECV_HEADER_SIZE;
1300                 linda_wq->header_cons %= LINDA_RECV_HEADERS_SIZE;
1301         }
1302
1303         /* Update consumer offset */
1304         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
1305         BIT_FILL_2 ( &rcvhdrhead,
1306                      RcvHeadPointer, ( linda_wq->header_cons >> 2 ),
1307                      counter, 1 );
1308         linda_writeq_array64k ( linda, &rcvhdrhead,
1309                                 QIB_7220_RcvHdrHead0_offset, ctx );
1310 }
1311
1312 /**
1313  * Poll completion queue
1314  *
1315  * @v ibdev             Infiniband device
1316  * @v cq                Completion queue
1317  */
1318 static void linda_poll_cq ( struct ib_device *ibdev,
1319                             struct ib_completion_queue *cq ) {
1320         struct ib_work_queue *wq;
1321
1322         /* Poll associated send and receive queues */
1323         list_for_each_entry ( wq, &cq->work_queues, list ) {
1324                 if ( wq->is_send ) {
1325                         linda_poll_send_wq ( ibdev, wq->qp );
1326                 } else {
1327                         linda_poll_recv_wq ( ibdev, wq->qp );
1328                 }
1329         }
1330 }
1331
1332 /***************************************************************************
1333  *
1334  * Event queues
1335  *
1336  ***************************************************************************
1337  */
1338
1339 /**
1340  * Poll event queue
1341  *
1342  * @v ibdev             Infiniband device
1343  */
1344 static void linda_poll_eq ( struct ib_device *ibdev ) {
1345         struct linda *linda = ib_get_drvdata ( ibdev );
1346         struct QIB_7220_ErrStatus errstatus;
1347         struct QIB_7220_ErrClear errclear;
1348
1349         /* Check for link status changes */
1350         DBG_DISABLE ( DBGLVL_IO );
1351         linda_readq ( linda, &errstatus, QIB_7220_ErrStatus_offset );
1352         DBG_ENABLE ( DBGLVL_IO );
1353         if ( BIT_GET ( &errstatus, IBStatusChanged ) ) {
1354                 linda_link_state_changed ( ibdev );
1355                 memset ( &errclear, 0, sizeof ( errclear ) );
1356                 BIT_FILL_1 ( &errclear, IBStatusChangedClear, 1 );
1357                 linda_writeq ( linda, &errclear, QIB_7220_ErrClear_offset );
1358         }
1359 }
1360
1361 /***************************************************************************
1362  *
1363  * Infiniband link-layer operations
1364  *
1365  ***************************************************************************
1366  */
1367
1368 /**
1369  * Initialise Infiniband link
1370  *
1371  * @v ibdev             Infiniband device
1372  * @ret rc              Return status code
1373  */
1374 static int linda_open ( struct ib_device *ibdev ) {
1375         struct linda *linda = ib_get_drvdata ( ibdev );
1376         struct QIB_7220_Control control;
1377
1378         /* Disable link */
1379         linda_readq ( linda, &control, QIB_7220_Control_offset );
1380         BIT_SET ( &control, LinkEn, 1 );
1381         linda_writeq ( linda, &control, QIB_7220_Control_offset );
1382         return 0;
1383 }
1384
1385 /**
1386  * Close Infiniband link
1387  *
1388  * @v ibdev             Infiniband device
1389  */
1390 static void linda_close ( struct ib_device *ibdev ) {
1391         struct linda *linda = ib_get_drvdata ( ibdev );
1392         struct QIB_7220_Control control;
1393
1394         /* Disable link */
1395         linda_readq ( linda, &control, QIB_7220_Control_offset );
1396         BIT_SET ( &control, LinkEn, 0 );
1397         linda_writeq ( linda, &control, QIB_7220_Control_offset );
1398 }
1399
1400 /***************************************************************************
1401  *
1402  * Multicast group operations
1403  *
1404  ***************************************************************************
1405  */
1406
1407 /**
1408  * Attach to multicast group
1409  *
1410  * @v ibdev             Infiniband device
1411  * @v qp                Queue pair
1412  * @v gid               Multicast GID
1413  * @ret rc              Return status code
1414  */
1415 static int linda_mcast_attach ( struct ib_device *ibdev,
1416                                 struct ib_queue_pair *qp,
1417                                 struct ib_gid *gid ) {
1418         struct linda *linda = ib_get_drvdata ( ibdev );
1419
1420         ( void ) linda;
1421         ( void ) qp;
1422         ( void ) gid;
1423         return 0;
1424 }
1425
1426 /**
1427  * Detach from multicast group
1428  *
1429  * @v ibdev             Infiniband device
1430  * @v qp                Queue pair
1431  * @v gid               Multicast GID
1432  */
1433 static void linda_mcast_detach ( struct ib_device *ibdev,
1434                                  struct ib_queue_pair *qp,
1435                                  struct ib_gid *gid ) {
1436         struct linda *linda = ib_get_drvdata ( ibdev );
1437
1438         ( void ) linda;
1439         ( void ) qp;
1440         ( void ) gid;
1441 }
1442
1443 /** Linda Infiniband operations */
1444 static struct ib_device_operations linda_ib_operations = {
1445         .create_cq      = linda_create_cq,
1446         .destroy_cq     = linda_destroy_cq,
1447         .create_qp      = linda_create_qp,
1448         .modify_qp      = linda_modify_qp,
1449         .destroy_qp     = linda_destroy_qp,
1450         .post_send      = linda_post_send,
1451         .post_recv      = linda_post_recv,
1452         .poll_cq        = linda_poll_cq,
1453         .poll_eq        = linda_poll_eq,
1454         .open           = linda_open,
1455         .close          = linda_close,
1456         .mcast_attach   = linda_mcast_attach,
1457         .mcast_detach   = linda_mcast_detach,
1458         .set_port_info  = linda_set_port_info,
1459 };
1460
1461 /***************************************************************************
1462  *
1463  * I2C bus operations
1464  *
1465  ***************************************************************************
1466  */
1467
1468 /** Linda I2C bit to GPIO mappings */
1469 static unsigned int linda_i2c_bits[] = {
1470         [I2C_BIT_SCL] = ( 1 << LINDA_GPIO_SCL ),
1471         [I2C_BIT_SDA] = ( 1 << LINDA_GPIO_SDA ),
1472 };
1473
1474 /**
1475  * Read Linda I2C line status
1476  *
1477  * @v basher            Bit-bashing interface
1478  * @v bit_id            Bit number
1479  * @ret zero            Input is a logic 0
1480  * @ret non-zero        Input is a logic 1
1481  */
1482 static int linda_i2c_read_bit ( struct bit_basher *basher,
1483                                 unsigned int bit_id ) {
1484         struct linda *linda =
1485                 container_of ( basher, struct linda, i2c.basher );
1486         struct QIB_7220_EXTStatus extstatus;
1487         unsigned int status;
1488
1489         DBG_DISABLE ( DBGLVL_IO );
1490
1491         linda_readq ( linda, &extstatus, QIB_7220_EXTStatus_offset );
1492         status = ( BIT_GET ( &extstatus, GPIOIn ) & linda_i2c_bits[bit_id] );
1493
1494         DBG_ENABLE ( DBGLVL_IO );
1495
1496         return status;
1497 }
1498
1499 /**
1500  * Write Linda I2C line status
1501  *
1502  * @v basher            Bit-bashing interface
1503  * @v bit_id            Bit number
1504  * @v data              Value to write
1505  */
1506 static void linda_i2c_write_bit ( struct bit_basher *basher,
1507                                   unsigned int bit_id, unsigned long data ) {
1508         struct linda *linda =
1509                 container_of ( basher, struct linda, i2c.basher );
1510         struct QIB_7220_EXTCtrl extctrl;
1511         struct QIB_7220_GPIO gpioout;
1512         unsigned int bit = linda_i2c_bits[bit_id];
1513         unsigned int outputs = 0;
1514         unsigned int output_enables = 0;
1515
1516         DBG_DISABLE ( DBGLVL_IO );
1517
1518         /* Read current GPIO mask and outputs */
1519         linda_readq ( linda, &extctrl, QIB_7220_EXTCtrl_offset );
1520         linda_readq ( linda, &gpioout, QIB_7220_GPIOOut_offset );
1521
1522         /* Update outputs and output enables.  I2C lines are tied
1523          * high, so we always set the output to 0 and use the output
1524          * enable to control the line.
1525          */
1526         output_enables = BIT_GET ( &extctrl, GPIOOe );
1527         output_enables = ( ( output_enables & ~bit ) | ( ~data & bit ) );
1528         outputs = BIT_GET ( &gpioout, GPIO );
1529         outputs = ( outputs & ~bit );
1530         BIT_SET ( &extctrl, GPIOOe, output_enables );
1531         BIT_SET ( &gpioout, GPIO, outputs );
1532
1533         /* Write the output enable first; that way we avoid logic
1534          * hazards.
1535          */
1536         linda_writeq ( linda, &extctrl, QIB_7220_EXTCtrl_offset );
1537         linda_writeq ( linda, &gpioout, QIB_7220_GPIOOut_offset );
1538         mb();
1539
1540         DBG_ENABLE ( DBGLVL_IO );
1541 }
1542
1543 /** Linda I2C bit-bashing interface operations */
1544 static struct bit_basher_operations linda_i2c_basher_ops = {
1545         .read   = linda_i2c_read_bit,
1546         .write  = linda_i2c_write_bit,
1547 };
1548
1549 /**
1550  * Initialise Linda I2C subsystem
1551  *
1552  * @v linda             Linda device
1553  * @ret rc              Return status code
1554  */
1555 static int linda_init_i2c ( struct linda *linda ) {
1556         static int try_eeprom_address[] = { 0x51, 0x50 };
1557         unsigned int i;
1558         int rc;
1559
1560         /* Initialise bus */
1561         if ( ( rc = init_i2c_bit_basher ( &linda->i2c,
1562                                           &linda_i2c_basher_ops ) ) != 0 ) {
1563                 DBGC ( linda, "Linda %p could not initialise I2C bus: %s\n",
1564                        linda, strerror ( rc ) );
1565                 return rc;
1566         }
1567
1568         /* Probe for devices */
1569         for ( i = 0 ; i < ( sizeof ( try_eeprom_address ) /
1570                             sizeof ( try_eeprom_address[0] ) ) ; i++ ) {
1571                 init_i2c_eeprom ( &linda->eeprom, try_eeprom_address[i] );
1572                 if ( ( rc = i2c_check_presence ( &linda->i2c.i2c,
1573                                                  &linda->eeprom ) ) == 0 ) {
1574                         DBGC2 ( linda, "Linda %p found EEPROM at %02x\n",
1575                                 linda, try_eeprom_address[i] );
1576                         return 0;
1577                 }
1578         }
1579
1580         DBGC ( linda, "Linda %p could not find EEPROM\n", linda );
1581         return -ENODEV;
1582 }
1583
1584 /**
1585  * Read EEPROM parameters
1586  *
1587  * @v linda             Linda device
1588  * @v guid              GUID to fill in
1589  * @ret rc              Return status code
1590  */
1591 static int linda_read_eeprom ( struct linda *linda,
1592                                struct ib_gid_half *guid ) {
1593         struct i2c_interface *i2c = &linda->i2c.i2c;
1594         int rc;
1595
1596         /* Read GUID */
1597         if ( ( rc = i2c->read ( i2c, &linda->eeprom, LINDA_EEPROM_GUID_OFFSET,
1598                                 guid->bytes, sizeof ( *guid ) ) ) != 0 ) {
1599                 DBGC ( linda, "Linda %p could not read GUID: %s\n",
1600                        linda, strerror ( rc ) );
1601                 return rc;
1602         }
1603         DBGC2 ( linda, "Linda %p has GUID %02x:%02x:%02x:%02x:%02x:%02x:"
1604                 "%02x:%02x\n", linda, guid->bytes[0], guid->bytes[1],
1605                 guid->bytes[2], guid->bytes[3], guid->bytes[4],
1606                 guid->bytes[5], guid->bytes[6], guid->bytes[7] );
1607
1608         /* Read serial number (debug only) */
1609         if ( DBG_LOG ) {
1610                 uint8_t serial[LINDA_EEPROM_SERIAL_SIZE + 1];
1611
1612                 serial[ sizeof ( serial ) - 1 ] = '\0';
1613                 if ( ( rc = i2c->read ( i2c, &linda->eeprom,
1614                                         LINDA_EEPROM_SERIAL_OFFSET, serial,
1615                                         ( sizeof ( serial ) - 1 ) ) ) != 0 ) {
1616                         DBGC ( linda, "Linda %p could not read serial: %s\n",
1617                                linda, strerror ( rc ) );
1618                         return rc;
1619                 }
1620                 DBGC2 ( linda, "Linda %p has serial number \"%s\"\n",
1621                         linda, serial );
1622         }
1623
1624         return 0;
1625 }
1626
1627 /***************************************************************************
1628  *
1629  * External parallel bus access
1630  *
1631  ***************************************************************************
1632  */
1633
1634 /**
1635  * Request ownership of the IB external parallel bus
1636  *
1637  * @v linda             Linda device
1638  * @ret rc              Return status code
1639  */
1640 static int linda_ib_epb_request ( struct linda *linda ) {
1641         struct QIB_7220_ibsd_epb_access_ctrl access;
1642         unsigned int i;
1643
1644         /* Request ownership */
1645         memset ( &access, 0, sizeof ( access ) );
1646         BIT_FILL_1 ( &access, sw_ib_epb_req, 1 );
1647         linda_writeq ( linda, &access, QIB_7220_ibsd_epb_access_ctrl_offset );
1648
1649         /* Wait for ownership to be granted */
1650         for ( i = 0 ; i < LINDA_EPB_REQUEST_MAX_WAIT_US ; i++ ) {
1651                 linda_readq ( linda, &access,
1652                               QIB_7220_ibsd_epb_access_ctrl_offset );
1653                 if ( BIT_GET ( &access, sw_ib_epb_req_granted ) )
1654                         return 0;
1655                 udelay ( 1 );
1656         }
1657
1658         DBGC ( linda, "Linda %p timed out waiting for IB EPB request\n",
1659                linda );
1660         return -ETIMEDOUT;
1661 }
1662
1663 /**
1664  * Wait for IB external parallel bus transaction to complete
1665  *
1666  * @v linda             Linda device
1667  * @v xact              Buffer to hold transaction result
1668  * @ret rc              Return status code
1669  */
1670 static int linda_ib_epb_wait ( struct linda *linda,
1671                             struct QIB_7220_ibsd_epb_transaction_reg *xact ) {
1672         unsigned int i;
1673
1674         /* Discard first read to allow for signals crossing clock domains */
1675         linda_readq ( linda, xact, QIB_7220_ibsd_epb_transaction_reg_offset );
1676
1677         for ( i = 0 ; i < LINDA_EPB_XACT_MAX_WAIT_US ; i++ ) {
1678                 linda_readq ( linda, xact,
1679                               QIB_7220_ibsd_epb_transaction_reg_offset );
1680                 if ( BIT_GET ( xact, ib_epb_rdy ) ) {
1681                         if ( BIT_GET ( xact, ib_epb_req_error ) ) {
1682                                 DBGC ( linda, "Linda %p EPB transaction "
1683                                        "failed\n", linda );
1684                                 return -EIO;
1685                         } else {
1686                                 return 0;
1687                         }
1688                 }
1689                 udelay ( 1 );
1690         }
1691
1692         DBGC ( linda, "Linda %p timed out waiting for IB EPB transaction\n",
1693                linda );
1694         return -ETIMEDOUT;
1695 }
1696
1697 /**
1698  * Release ownership of the IB external parallel bus
1699  *
1700  * @v linda             Linda device
1701  */
1702 static void linda_ib_epb_release ( struct linda *linda ) {
1703         struct QIB_7220_ibsd_epb_access_ctrl access;
1704
1705         memset ( &access, 0, sizeof ( access ) );
1706         BIT_FILL_1 ( &access, sw_ib_epb_req, 0 );
1707         linda_writeq ( linda, &access, QIB_7220_ibsd_epb_access_ctrl_offset );
1708 }
1709
1710 /**
1711  * Read data via IB external parallel bus
1712  *
1713  * @v linda             Linda device
1714  * @v location          EPB location
1715  * @ret data            Data read, or negative error
1716  *
1717  * You must have already acquired ownership of the IB external
1718  * parallel bus.
1719  */
1720 static int linda_ib_epb_read ( struct linda *linda, unsigned int location ) {
1721         struct QIB_7220_ibsd_epb_transaction_reg xact;
1722         unsigned int data;
1723         int rc;
1724
1725         /* Ensure no transaction is currently in progress */
1726         if ( ( rc = linda_ib_epb_wait ( linda, &xact ) ) != 0 )
1727                 return rc;
1728
1729         /* Process data */
1730         memset ( &xact, 0, sizeof ( xact ) );
1731         BIT_FILL_3 ( &xact,
1732                      ib_epb_address, LINDA_EPB_LOC_ADDRESS ( location ),
1733                      ib_epb_read_write, LINDA_EPB_READ,
1734                      ib_epb_cs, LINDA_EPB_LOC_CS ( location ) );
1735         linda_writeq ( linda, &xact,
1736                        QIB_7220_ibsd_epb_transaction_reg_offset );
1737
1738         /* Wait for transaction to complete */
1739         if ( ( rc = linda_ib_epb_wait ( linda, &xact ) ) != 0 )
1740                 return rc;
1741
1742         data = BIT_GET ( &xact, ib_epb_data );
1743         return data;
1744 }
1745
1746 /**
1747  * Write data via IB external parallel bus
1748  *
1749  * @v linda             Linda device
1750  * @v location          EPB location
1751  * @v data              Data to write
1752  * @ret rc              Return status code
1753  *
1754  * You must have already acquired ownership of the IB external
1755  * parallel bus.
1756  */
1757 static int linda_ib_epb_write ( struct linda *linda, unsigned int location,
1758                                 unsigned int data ) {
1759         struct QIB_7220_ibsd_epb_transaction_reg xact;
1760         int rc;
1761
1762         /* Ensure no transaction is currently in progress */
1763         if ( ( rc = linda_ib_epb_wait ( linda, &xact ) ) != 0 )
1764                 return rc;
1765
1766         /* Process data */
1767         memset ( &xact, 0, sizeof ( xact ) );
1768         BIT_FILL_4 ( &xact,
1769                      ib_epb_data, data,
1770                      ib_epb_address, LINDA_EPB_LOC_ADDRESS ( location ),
1771                      ib_epb_read_write, LINDA_EPB_WRITE,
1772                      ib_epb_cs, LINDA_EPB_LOC_CS ( location ) );
1773         linda_writeq ( linda, &xact,
1774                        QIB_7220_ibsd_epb_transaction_reg_offset );
1775
1776         /* Wait for transaction to complete */
1777         if ( ( rc = linda_ib_epb_wait ( linda, &xact ) ) != 0 )
1778                 return rc;
1779
1780         return 0;
1781 }
1782
1783 /**
1784  * Read/modify/write EPB register
1785  *
1786  * @v linda             Linda device
1787  * @v cs                Chip select
1788  * @v channel           Channel
1789  * @v element           Element
1790  * @v reg               Register
1791  * @v value             Value to set
1792  * @v mask              Mask to apply to old value
1793  * @ret rc              Return status code
1794  */
1795 static int linda_ib_epb_mod_reg ( struct linda *linda, unsigned int cs,
1796                                   unsigned int channel, unsigned int element,
1797                                   unsigned int reg, unsigned int value,
1798                                   unsigned int mask ) {
1799         unsigned int location;
1800         int old_value;
1801         int rc;
1802
1803         DBG_DISABLE ( DBGLVL_IO );
1804
1805         /* Sanity check */
1806         assert ( ( value & mask ) == value );
1807
1808         /* Acquire bus ownership */
1809         if ( ( rc = linda_ib_epb_request ( linda ) ) != 0 )
1810                 goto out;
1811
1812         /* Read existing value, if necessary */
1813         location = LINDA_EPB_LOC ( cs, channel, element, reg );
1814         if ( (~mask) & 0xff ) {
1815                 old_value = linda_ib_epb_read ( linda, location );
1816                 if ( old_value < 0 ) {
1817                         rc = old_value;
1818                         goto out_release;
1819                 }
1820         } else {
1821                 old_value = 0;
1822         }
1823
1824         /* Update value */
1825         value = ( ( old_value & ~mask ) | value );
1826         DBGCP ( linda, "Linda %p CS %d EPB(%d,%d,%#02x) %#02x => %#02x\n",
1827                 linda, cs, channel, element, reg, old_value, value );
1828         if ( ( rc = linda_ib_epb_write ( linda, location, value ) ) != 0 )
1829                 goto out_release;
1830
1831  out_release:
1832         /* Release bus */
1833         linda_ib_epb_release ( linda );
1834  out:
1835         DBG_ENABLE ( DBGLVL_IO );
1836         return rc;
1837 }
1838
1839 /**
1840  * Transfer data to/from microcontroller RAM
1841  *
1842  * @v linda             Linda device
1843  * @v address           Starting address
1844  * @v write             Data to write, or NULL
1845  * @v read              Data to read, or NULL
1846  * @v len               Length of data
1847  * @ret rc              Return status code
1848  */
1849 static int linda_ib_epb_ram_xfer ( struct linda *linda, unsigned int address,
1850                                    const void *write, void *read,
1851                                    size_t len ) {
1852         unsigned int control;
1853         unsigned int address_hi;
1854         unsigned int address_lo;
1855         int data;
1856         int rc;
1857
1858         DBG_DISABLE ( DBGLVL_IO );
1859
1860         assert ( ! ( write && read ) );
1861         assert ( ( address % LINDA_EPB_UC_CHUNK_SIZE ) == 0 );
1862         assert ( ( len % LINDA_EPB_UC_CHUNK_SIZE ) == 0 );
1863
1864         /* Acquire bus ownership */
1865         if ( ( rc = linda_ib_epb_request ( linda ) ) != 0 )
1866                 goto out;
1867
1868         /* Process data */
1869         while ( len ) {
1870
1871                 /* Reset the address for each new chunk */
1872                 if ( ( address % LINDA_EPB_UC_CHUNK_SIZE ) == 0 ) {
1873
1874                         /* Write the control register */
1875                         control = ( read ? LINDA_EPB_UC_CTL_READ :
1876                                     LINDA_EPB_UC_CTL_WRITE );
1877                         if ( ( rc = linda_ib_epb_write ( linda,
1878                                                          LINDA_EPB_UC_CTL,
1879                                                          control ) ) != 0 )
1880                                 break;
1881
1882                         /* Write the address registers */
1883                         address_hi = ( address >> 8 );
1884                         if ( ( rc = linda_ib_epb_write ( linda,
1885                                                          LINDA_EPB_UC_ADDR_HI,
1886                                                          address_hi ) ) != 0 )
1887                                 break;
1888                         address_lo = ( address & 0xff );
1889                         if ( ( rc = linda_ib_epb_write ( linda,
1890                                                          LINDA_EPB_UC_ADDR_LO,
1891                                                          address_lo ) ) != 0 )
1892                                 break;
1893                 }
1894
1895                 /* Read or write the data */
1896                 if ( read ) {
1897                         data = linda_ib_epb_read ( linda, LINDA_EPB_UC_DATA );
1898                         if ( data < 0 ) {
1899                                 rc = data;
1900                                 break;
1901                         }
1902                         *( ( uint8_t * ) read++ ) = data;
1903                 } else {
1904                         data = *( ( uint8_t * ) write++ );
1905                         if ( ( rc = linda_ib_epb_write ( linda,
1906                                                          LINDA_EPB_UC_DATA,
1907                                                          data ) ) != 0 )
1908                                 break;
1909                 }
1910                 address++;
1911                 len--;
1912
1913                 /* Reset the control byte after each chunk */
1914                 if ( ( address % LINDA_EPB_UC_CHUNK_SIZE ) == 0 ) {
1915                         if ( ( rc = linda_ib_epb_write ( linda,
1916                                                          LINDA_EPB_UC_CTL,
1917                                                          0 ) ) != 0 )
1918                                 break;
1919                 }
1920         }
1921
1922         /* Release bus */
1923         linda_ib_epb_release ( linda );
1924
1925  out:
1926         DBG_ENABLE ( DBGLVL_IO );
1927         return rc;
1928 }
1929
1930 /***************************************************************************
1931  *
1932  * Infiniband SerDes initialisation
1933  *
1934  ***************************************************************************
1935  */
1936
1937 /** A Linda SerDes parameter */
1938 struct linda_serdes_param {
1939         /** EPB address as constructed by LINDA_EPB_ADDRESS() */
1940         uint16_t address;
1941         /** Value to set */
1942         uint8_t value;
1943         /** Mask to apply to old value */
1944         uint8_t mask;
1945 } __packed;
1946
1947 /** Magic "all channels" channel number */
1948 #define LINDA_EPB_ALL_CHANNELS 31
1949
1950 /** End of SerDes parameter list marker */
1951 #define LINDA_SERDES_PARAM_END { 0, 0, 0 }
1952
1953 /**
1954  * Program IB SerDes register(s)
1955  *
1956  * @v linda             Linda device
1957  * @v param             SerDes parameter
1958  * @ret rc              Return status code
1959  */
1960 static int linda_set_serdes_param ( struct linda *linda,
1961                                     struct linda_serdes_param *param ) {
1962         unsigned int channel;
1963         unsigned int channel_start;
1964         unsigned int channel_end;
1965         unsigned int element;
1966         unsigned int reg;
1967         int rc;
1968
1969         /* Break down the EPB address and determine channels */
1970         channel = LINDA_EPB_ADDRESS_CHANNEL ( param->address );
1971         element = LINDA_EPB_ADDRESS_ELEMENT ( param->address );
1972         reg = LINDA_EPB_ADDRESS_REG ( param->address );
1973         if ( channel == LINDA_EPB_ALL_CHANNELS ) {
1974                 channel_start = 0;
1975                 channel_end = 3;
1976         } else {
1977                 channel_start = channel_end = channel;
1978         }
1979
1980         /* Modify register for each specified channel */
1981         for ( channel = channel_start ; channel <= channel_end ; channel++ ) {
1982                 if ( ( rc = linda_ib_epb_mod_reg ( linda, LINDA_EPB_CS_SERDES,
1983                                                    channel, element, reg,
1984                                                    param->value,
1985                                                    param->mask ) ) != 0 )
1986                         return rc;
1987         }
1988
1989         return 0;
1990 }
1991
1992 /**
1993  * Program IB SerDes registers
1994  *
1995  * @v linda             Linda device
1996  * @v param             SerDes parameters
1997  * @v count             Number of parameters
1998  * @ret rc              Return status code
1999  */
2000 static int linda_set_serdes_params ( struct linda *linda,
2001                                      struct linda_serdes_param *params ) {
2002         int rc;
2003
2004         for ( ; params->mask != 0 ; params++ ){
2005                 if ( ( rc = linda_set_serdes_param ( linda,
2006                                                          params ) ) != 0 )
2007                         return rc;
2008         }
2009
2010         return 0;
2011 }
2012
2013 #define LINDA_DDS_VAL( amp_d, main_d, ipst_d, ipre_d,                   \
2014                        amp_s, main_s, ipst_s, ipre_s )                  \
2015         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x00 ),        \
2016           ( ( ( amp_d & 0x1f ) << 1 ) | 1 ), 0xff },                    \
2017         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x01 ),        \
2018           ( ( ( amp_s & 0x1f ) << 1 ) | 1 ), 0xff },                    \
2019         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x09 ),        \
2020           ( ( main_d << 3 ) | 4 | ( ipre_d >> 2 ) ), 0xff },            \
2021         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x0a ),        \
2022           ( ( main_s << 3 ) | 4 | ( ipre_s >> 2 ) ), 0xff },            \
2023         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x06 ),        \
2024           ( ( ( ipst_d & 0xf ) << 1 ) |                                 \
2025             ( ( ipre_d & 3 ) << 6 ) | 0x21 ), 0xff },                   \
2026         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 9, 0x07 ),        \
2027           ( ( ( ipst_s & 0xf ) << 1 ) |                                 \
2028             ( ( ipre_s & 3 ) << 6) | 0x21 ), 0xff }
2029
2030 /**
2031  * Linda SerDes default parameters
2032  *
2033  * These magic start-of-day values are taken from the Linux driver.
2034  */
2035 static struct linda_serdes_param linda_serdes_defaults1[] = {
2036         /* RXHSCTRL0 */
2037         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x00 ), 0xd4, 0xff },
2038         /* VCDL_DAC2 */
2039         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x05 ), 0x2d, 0xff },
2040         /* VCDL_CTRL2 */
2041         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x08 ), 0x03, 0x0f },
2042         /* START_EQ1 */
2043         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x27 ), 0x10, 0xff },
2044         /* START_EQ2 */
2045         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x28 ), 0x30, 0xff },
2046         /* BACTRL */
2047         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x0e ), 0x40, 0xff },
2048         /* LDOUTCTRL1 */
2049         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x06 ), 0x04, 0xff },
2050         /* RXHSSTATUS */
2051         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x0f ), 0x04, 0xff },
2052         /* End of this block */
2053         LINDA_SERDES_PARAM_END
2054 };
2055 static struct linda_serdes_param linda_serdes_defaults2[] = {
2056         /* LDOUTCTRL1 */
2057         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x06 ), 0x00, 0xff },
2058         /* DDS values */
2059         LINDA_DDS_VAL ( 31, 19, 12, 0, 29, 22, 9, 0 ),
2060         /* Set Rcv Eq. to Preset node */
2061         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x27 ), 0x10, 0xff },
2062         /* DFELTHFDR */
2063         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x08 ), 0x00, 0xff },
2064         /* DFELTHHDR */
2065         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x21 ), 0x00, 0xff },
2066         /* TLTHFDR */
2067         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x09 ), 0x02, 0xff },
2068         /* TLTHHDR */
2069         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x23 ), 0x02, 0xff },
2070         /* ZFR */
2071         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x1b ), 0x0c, 0xff },
2072         /* ZCNT) */
2073         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x1c ), 0x0c, 0xff },
2074         /* GFR */
2075         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x1e ), 0x10, 0xff },
2076         /* GHR */
2077         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x1f ), 0x10, 0xff },
2078         /* VCDL_CTRL0 toggle */
2079         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x06 ), 0x20, 0xff },
2080         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 6, 0x06 ), 0x00, 0xff },
2081         /* CMUCTRL5 */
2082         { LINDA_EPB_ADDRESS (                      7, 0, 0x15 ), 0x80, 0xff },
2083         /* End of this block */
2084         LINDA_SERDES_PARAM_END
2085 };
2086 static struct linda_serdes_param linda_serdes_defaults3[] = {
2087         /* START_EQ1 */
2088         { LINDA_EPB_ADDRESS ( LINDA_EPB_ALL_CHANNELS, 7, 0x27 ), 0x00, 0x38 },
2089         /* End of this block */
2090         LINDA_SERDES_PARAM_END
2091 };
2092
2093 /**
2094  * Program the microcontroller RAM
2095  *
2096  * @v linda             Linda device
2097  * @ret rc              Return status code
2098  */
2099 static int linda_program_uc_ram ( struct linda *linda ) {
2100         int rc;
2101
2102         if ( ( rc = linda_ib_epb_ram_xfer ( linda, 0, linda_ib_fw, NULL,
2103                                             sizeof ( linda_ib_fw ) ) ) != 0 ){
2104                 DBGC ( linda, "Linda %p could not load IB firmware: %s\n",
2105                        linda, strerror ( rc ) );
2106                 return rc;
2107         }
2108
2109         return 0;
2110 }
2111
2112 /**
2113  * Verify the microcontroller RAM
2114  *
2115  * @v linda             Linda device
2116  * @ret rc              Return status code
2117  */
2118 static int linda_verify_uc_ram ( struct linda *linda ) {
2119         uint8_t verify[LINDA_EPB_UC_CHUNK_SIZE];
2120         unsigned int offset;
2121         int rc;
2122
2123         for ( offset = 0 ; offset < sizeof ( linda_ib_fw );
2124               offset += sizeof ( verify ) ) {
2125                 if ( ( rc = linda_ib_epb_ram_xfer ( linda, offset,
2126                                                     NULL, verify,
2127                                                     sizeof (verify) )) != 0 ){
2128                         DBGC ( linda, "Linda %p could not read back IB "
2129                                "firmware: %s\n", linda, strerror ( rc ) );
2130                         return rc;
2131                 }
2132                 if ( memcmp ( ( linda_ib_fw + offset ), verify,
2133                               sizeof ( verify ) ) != 0 ) {
2134                         DBGC ( linda, "Linda %p firmware verification failed "
2135                                "at offset %#x\n", linda, offset );
2136                         DBGC_HDA ( linda, offset, ( linda_ib_fw + offset ),
2137                                    sizeof ( verify ) );
2138                         DBGC_HDA ( linda, offset, verify, sizeof ( verify ) );
2139                         return -EIO;
2140                 }
2141         }
2142
2143         DBGC2 ( linda, "Linda %p firmware verified ok\n", linda );
2144         return 0;
2145 }
2146
2147 /**
2148  * Use the microcontroller to trim the IB link
2149  *
2150  * @v linda             Linda device
2151  * @ret rc              Return status code
2152  */
2153 static int linda_trim_ib ( struct linda *linda ) {
2154         struct QIB_7220_IBSerDesCtrl ctrl;
2155         struct QIB_7220_IntStatus intstatus;
2156         unsigned int i;
2157         int rc;
2158
2159         /* Bring the microcontroller out of reset */
2160         linda_readq ( linda, &ctrl, QIB_7220_IBSerDesCtrl_offset );
2161         BIT_SET ( &ctrl, ResetIB_uC_Core, 0 );
2162         linda_writeq ( linda, &ctrl, QIB_7220_IBSerDesCtrl_offset );
2163
2164         /* Wait for the "trim done" signal */
2165         for ( i = 0 ; i < LINDA_TRIM_DONE_MAX_WAIT_MS ; i++ ) {
2166                 linda_readq ( linda, &intstatus, QIB_7220_IntStatus_offset );
2167                 if ( BIT_GET ( &intstatus, IBSerdesTrimDone ) ) {
2168                         rc = 0;
2169                         goto out_reset;
2170                 }
2171                 mdelay ( 1 );
2172         }
2173
2174         DBGC ( linda, "Linda %p timed out waiting for trim done\n", linda );
2175         rc = -ETIMEDOUT;
2176  out_reset:
2177         /* Put the microcontroller back into reset */
2178         BIT_SET ( &ctrl, ResetIB_uC_Core, 1 );
2179         linda_writeq ( linda, &ctrl, QIB_7220_IBSerDesCtrl_offset );
2180
2181         return rc;
2182 }
2183
2184 /**
2185  * Initialise the IB SerDes
2186  *
2187  * @v linda             Linda device
2188  * @ret rc              Return status code
2189  */
2190 static int linda_init_ib_serdes ( struct linda *linda ) {
2191         struct QIB_7220_Control control;
2192         struct QIB_7220_IBCCtrl ibcctrl;
2193         struct QIB_7220_IBCDDRCtrl ibcddrctrl;
2194         struct QIB_7220_XGXSCfg xgxscfg;
2195         int rc;
2196
2197         /* Disable link */
2198         linda_readq ( linda, &control, QIB_7220_Control_offset );
2199         BIT_SET ( &control, LinkEn, 0 );
2200         linda_writeq ( linda, &control, QIB_7220_Control_offset );
2201
2202         /* Configure sensible defaults for IBC */
2203         memset ( &ibcctrl, 0, sizeof ( ibcctrl ) );
2204         BIT_FILL_6 ( &ibcctrl, /* Tuning values taken from Linux driver */
2205                      FlowCtrlPeriod, 0x03,
2206                      FlowCtrlWaterMark, 0x05,
2207                      MaxPktLen, ( ( LINDA_RECV_HEADER_SIZE +
2208                                     LINDA_RECV_PAYLOAD_SIZE +
2209                                     4 /* ICRC */ ) >> 2 ),
2210                      PhyerrThreshold, 0xf,
2211                      OverrunThreshold, 0xf,
2212                      CreditScale, 0x4 );
2213         linda_writeq ( linda, &ibcctrl, QIB_7220_IBCCtrl_offset );
2214
2215         /* Force SDR only to avoid needing all the DDR tuning,
2216          * Mellanox compatibility hacks etc.  SDR is plenty for
2217          * boot-time operation.
2218          */
2219         linda_readq ( linda, &ibcddrctrl, QIB_7220_IBCDDRCtrl_offset );
2220         BIT_SET ( &ibcddrctrl, IB_ENHANCED_MODE, 0 );
2221         BIT_SET ( &ibcddrctrl, SD_SPEED_SDR, 1 );
2222         BIT_SET ( &ibcddrctrl, SD_SPEED_DDR, 0 );
2223         BIT_SET ( &ibcddrctrl, SD_SPEED_QDR, 0 );
2224         BIT_SET ( &ibcddrctrl, HRTBT_ENB, 0 );
2225         BIT_SET ( &ibcddrctrl, HRTBT_AUTO, 0 );
2226         linda_writeq ( linda, &ibcddrctrl, QIB_7220_IBCDDRCtrl_offset );
2227
2228         /* Set default SerDes parameters */
2229         if ( ( rc = linda_set_serdes_params ( linda,
2230                                               linda_serdes_defaults1 ) ) != 0 )
2231                 return rc;
2232         udelay ( 415 ); /* Magic delay while SerDes sorts itself out */
2233         if ( ( rc = linda_set_serdes_params ( linda,
2234                                               linda_serdes_defaults2 ) ) != 0 )
2235                 return rc;
2236
2237         /* Program the microcontroller RAM */
2238         if ( ( rc = linda_program_uc_ram ( linda ) ) != 0 )
2239                 return rc;
2240
2241         /* Verify the microcontroller RAM contents */
2242         if ( DBGLVL_LOG ) {
2243                 if ( ( rc = linda_verify_uc_ram ( linda ) ) != 0 )
2244                         return rc;
2245         }
2246
2247         /* More SerDes tuning */
2248         if ( ( rc = linda_set_serdes_params ( linda,
2249                                               linda_serdes_defaults3 ) ) != 0 )
2250                 return rc;
2251
2252         /* Use the microcontroller to trim the IB link */
2253         if ( ( rc = linda_trim_ib ( linda ) ) != 0 )
2254                 return rc;
2255
2256         /* Bring XGXS out of reset */
2257         linda_readq ( linda, &xgxscfg, QIB_7220_XGXSCfg_offset );
2258         BIT_SET ( &xgxscfg, tx_rx_reset, 0 );
2259         BIT_SET ( &xgxscfg, xcv_reset, 0 );
2260         linda_writeq ( linda, &xgxscfg, QIB_7220_XGXSCfg_offset );
2261
2262         return rc;
2263 }
2264
2265 /***************************************************************************
2266  *
2267  * PCI layer interface
2268  *
2269  ***************************************************************************
2270  */
2271
2272 /**
2273  * Probe PCI device
2274  *
2275  * @v pci               PCI device
2276  * @v id                PCI ID
2277  * @ret rc              Return status code
2278  */
2279 static int linda_probe ( struct pci_device *pci,
2280                          const struct pci_device_id *id __unused ) {
2281         struct ib_device *ibdev;
2282         struct linda *linda;
2283         struct QIB_7220_Revision revision;
2284         int rc;
2285
2286         /* Allocate Infiniband device */
2287         ibdev = alloc_ibdev ( sizeof ( *linda ) );
2288         if ( ! ibdev ) {
2289                 rc = -ENOMEM;
2290                 goto err_alloc_ibdev;
2291         }
2292         pci_set_drvdata ( pci, ibdev );
2293         linda = ib_get_drvdata ( ibdev );
2294         ibdev->op = &linda_ib_operations;
2295         ibdev->dev = &pci->dev;
2296         ibdev->port = 1;
2297
2298         /* Fix up PCI device */
2299         adjust_pci_device ( pci );
2300
2301         /* Get PCI BARs */
2302         linda->regs = ioremap ( pci->membase, LINDA_BAR0_SIZE );
2303         DBGC2 ( linda, "Linda %p has BAR at %08lx\n", linda, pci->membase );
2304
2305         /* Print some general data */
2306         linda_readq ( linda, &revision, QIB_7220_Revision_offset );
2307         DBGC2 ( linda, "Linda %p board %02lx v%ld.%ld.%ld.%ld\n", linda,
2308                 BIT_GET ( &revision, BoardID ),
2309                 BIT_GET ( &revision, R_SW ),
2310                 BIT_GET ( &revision, R_Arch ),
2311                 BIT_GET ( &revision, R_ChipRevMajor ),
2312                 BIT_GET ( &revision, R_ChipRevMinor ) );
2313
2314         /* Record link capabilities.  Note that we force SDR only to
2315          * avoid having to carry extra code for DDR tuning etc.
2316          */
2317         ibdev->link_width_enabled = ibdev->link_width_supported =
2318                 ( IB_LINK_WIDTH_4X | IB_LINK_WIDTH_1X );
2319         ibdev->link_speed_enabled = ibdev->link_speed_supported =
2320                 IB_LINK_SPEED_SDR;
2321
2322         /* Initialise I2C subsystem */
2323         if ( ( rc = linda_init_i2c ( linda ) ) != 0 )
2324                 goto err_init_i2c;
2325
2326         /* Read EEPROM parameters */
2327         if ( ( rc = linda_read_eeprom ( linda, &ibdev->gid.u.half[1] ) ) != 0 )
2328                 goto err_read_eeprom;
2329
2330         /* Initialise send datapath */
2331         if ( ( rc = linda_init_send ( linda ) ) != 0 )
2332                 goto err_init_send;
2333
2334         /* Initialise receive datapath */
2335         if ( ( rc = linda_init_recv ( linda ) ) != 0 )
2336                 goto err_init_recv;
2337
2338         /* Initialise the IB SerDes */
2339         if ( ( rc = linda_init_ib_serdes ( linda ) ) != 0 )
2340                 goto err_init_ib_serdes;
2341
2342         /* Register Infiniband device */
2343         if ( ( rc = register_ibdev ( ibdev ) ) != 0 ) {
2344                 DBGC ( linda, "Linda %p could not register IB "
2345                        "device: %s\n", linda, strerror ( rc ) );
2346                 goto err_register_ibdev;
2347         }
2348
2349         return 0;
2350
2351         unregister_ibdev ( ibdev );
2352  err_register_ibdev:
2353         linda_fini_recv ( linda );
2354  err_init_recv:
2355         linda_fini_send ( linda );
2356  err_init_send:
2357  err_init_ib_serdes:
2358  err_read_eeprom:
2359  err_init_i2c:
2360         ibdev_put ( ibdev );
2361  err_alloc_ibdev:
2362         return rc;
2363 }
2364
2365 /**
2366  * Remove PCI device
2367  *
2368  * @v pci               PCI device
2369  */
2370 static void linda_remove ( struct pci_device *pci ) {
2371         struct ib_device *ibdev = pci_get_drvdata ( pci );
2372         struct linda *linda = ib_get_drvdata ( ibdev );
2373
2374         unregister_ibdev ( ibdev );
2375         linda_fini_recv ( linda );
2376         linda_fini_send ( linda );
2377         ibdev_put ( ibdev );
2378 }
2379
2380 static struct pci_device_id linda_nics[] = {
2381         PCI_ROM ( 0x1077, 0x7220, "iba7220", "QLE7240/7280 HCA driver", 0 ),
2382 };
2383
2384 struct pci_driver linda_driver __pci_driver = {
2385         .ids = linda_nics,
2386         .id_count = ( sizeof ( linda_nics ) / sizeof ( linda_nics[0] ) ),
2387         .probe = linda_probe,
2388         .remove = linda_remove,
2389 };