qemu/roms/ipxe/src/drivers/infiniband/qib7322.c

   1 /*
   2  * Copyright (C) 2009 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., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <unistd.h>
  30 #include <assert.h>
  31 #include <ipxe/io.h>
  32 #include <ipxe/pci.h>
  33 #include <ipxe/infiniband.h>
  34 #include <ipxe/i2c.h>
  35 #include <ipxe/bitbash.h>
  36 #include <ipxe/malloc.h>
  37 #include <ipxe/iobuf.h>
  38 #include <ipxe/pcibackup.h>
  39 #include "qib7322.h"
  40
  41 /**
  42  * @file
  43  *
  44  * QLogic QIB7322 Infiniband HCA
  45  *
  46  */
  47
  48 /** A QIB7322 send buffer set */
  49 struct qib7322_send_buffers {
  50         /** Offset within register space of the first send buffer */
  51         unsigned long base;
  52         /** Send buffer size */
  53         unsigned int size;
  54         /** Index of first send buffer */
  55         unsigned int start;
  56         /** Number of send buffers
  57          *
  58          * Must be a power of two.
  59          */
  60         unsigned int count;
  61         /** Send buffer availability producer counter */
  62         unsigned int prod;
  63         /** Send buffer availability consumer counter */
  64         unsigned int cons;
  65         /** Send buffer availability */
  66         uint16_t avail[0];
  67 };
  68
  69 /** A QIB7322 send work queue */
  70 struct qib7322_send_work_queue {
  71         /** Send buffer set */
  72         struct qib7322_send_buffers *send_bufs;
  73         /** Send buffer usage */
  74         uint16_t *used;
  75         /** Producer index */
  76         unsigned int prod;
  77         /** Consumer index */
  78         unsigned int cons;
  79 };
  80
  81 /** A QIB7322 receive work queue */
  82 struct qib7322_recv_work_queue {
  83         /** Receive header ring */
  84         void *header;
  85         /** Receive header producer offset (written by hardware) */
  86         struct QIB_7322_scalar header_prod;
  87         /** Receive header consumer offset */
  88         unsigned int header_cons;
  89         /** Offset within register space of the eager array */
  90         unsigned long eager_array;
  91         /** Number of entries in eager array */
  92         unsigned int eager_entries;
  93         /** Eager array producer index */
  94         unsigned int eager_prod;
  95         /** Eager array consumer index */
  96         unsigned int eager_cons;
  97 };
  98
  99 /** A QIB7322 HCA */
 100 struct qib7322 {
 101         /** Registers */
 102         void *regs;
 103
 104         /** In-use contexts */
 105         uint8_t used_ctx[QIB7322_NUM_CONTEXTS];
 106         /** Send work queues */
 107         struct qib7322_send_work_queue send_wq[QIB7322_NUM_CONTEXTS];
 108         /** Receive work queues */
 109         struct qib7322_recv_work_queue recv_wq[QIB7322_NUM_CONTEXTS];
 110
 111         /** Send buffer availability (reported by hardware) */
 112         struct QIB_7322_SendBufAvail *sendbufavail;
 113         /** Small send buffers */
 114         struct qib7322_send_buffers *send_bufs_small;
 115         /** VL15 port 0 send buffers */
 116         struct qib7322_send_buffers *send_bufs_vl15_port0;
 117         /** VL15 port 1 send buffers */
 118         struct qib7322_send_buffers *send_bufs_vl15_port1;
 119
 120         /** I2C bit-bashing interface */
 121         struct i2c_bit_basher i2c;
 122         /** I2C serial EEPROM */
 123         struct i2c_device eeprom;
 124
 125         /** Base GUID */
 126         union ib_guid guid;
 127         /** Infiniband devices */
 128         struct ib_device *ibdev[QIB7322_MAX_PORTS];
 129 };
 130
 131 /***************************************************************************
 132  *
 133  * QIB7322 register access
 134  *
 135  ***************************************************************************
 136  *
 137  * This card requires atomic 64-bit accesses.  Strange things happen
 138  * if you try to use 32-bit accesses; sometimes they work, sometimes
 139  * they don't, sometimes you get random data.
 140  *
 141  * These accessors use the "movq" MMX instruction, and so won't work
 142  * on really old Pentiums (which won't have PCIe anyway, so this is
 143  * something of a moot point).
 144  */
 145
 146 /**
 147  * Read QIB7322 qword register
 148  *
 149  * @v qib7322           QIB7322 device
 150  * @v dwords            Register buffer to read into
 151  * @v offset            Register offset
 152  */
 153 static void qib7322_readq ( struct qib7322 *qib7322, uint32_t *dwords,
 154                             unsigned long offset ) {
 155         void *addr = ( qib7322->regs + offset );
 156
 157         __asm__ __volatile__ ( "movq (%1), %%mm0\n\t"
 158                                "movq %%mm0, (%0)\n\t"
 159                                : : "r" ( dwords ), "r" ( addr ) : "memory" );
 160
 161         DBGIO ( "[%08lx] => %08x%08x\n",
 162                 virt_to_phys ( addr ), dwords[1], dwords[0] );
 163 }
 164 #define qib7322_readq( _qib7322, _ptr, _offset ) \
 165         qib7322_readq ( (_qib7322), (_ptr)->u.dwords, (_offset) )
 166 #define qib7322_readq_array8b( _qib7322, _ptr, _offset, _idx ) \
 167         qib7322_readq ( (_qib7322), (_ptr), ( (_offset) + ( (_idx) * 8 ) ) )
 168 #define qib7322_readq_array64k( _qib7322, _ptr, _offset, _idx ) \
 169         qib7322_readq ( (_qib7322), (_ptr), ( (_offset) + ( (_idx) * 65536 ) ) )
 170 #define qib7322_readq_port( _qib7322, _ptr, _offset, _port ) \
 171         qib7322_readq ( (_qib7322), (_ptr), ( (_offset) + ( (_port) * 4096 ) ) )
 172
 173 /**
 174  * Write QIB7322 qword register
 175  *
 176  * @v qib7322           QIB7322 device
 177  * @v dwords            Register buffer to write
 178  * @v offset            Register offset
 179  */
 180 static void qib7322_writeq ( struct qib7322 *qib7322, const uint32_t *dwords,
 181                              unsigned long offset ) {
 182         void *addr = ( qib7322->regs + offset );
 183
 184         DBGIO ( "[%08lx] <= %08x%08x\n",
 185                 virt_to_phys ( addr ), dwords[1], dwords[0] );
 186
 187         __asm__ __volatile__ ( "movq (%0), %%mm0\n\t"
 188                                "movq %%mm0, (%1)\n\t"
 189                                : : "r" ( dwords ), "r" ( addr ) : "memory" );
 190 }
 191 #define qib7322_writeq( _qib7322, _ptr, _offset ) \
 192         qib7322_writeq ( (_qib7322), (_ptr)->u.dwords, (_offset) )
 193 #define qib7322_writeq_array8b( _qib7322, _ptr, _offset, _idx ) \
 194         qib7322_writeq ( (_qib7322), (_ptr), ( (_offset) + ( (_idx) * 8 ) ) )
 195 #define qib7322_writeq_array64k( _qib7322, _ptr, _offset, _idx ) \
 196         qib7322_writeq ( (_qib7322), (_ptr), ( (_offset) + ( (_idx) * 65536 ) ))
 197 #define qib7322_writeq_port( _qib7322, _ptr, _offset, _port ) \
 198         qib7322_writeq ( (_qib7322), (_ptr), ( (_offset) + ( (_port) * 4096 ) ))
 199
 200 /**
 201  * Write QIB7322 dword register
 202  *
 203  * @v qib7322           QIB7322 device
 204  * @v dword             Value to write
 205  * @v offset            Register offset
 206  */
 207 static void qib7322_writel ( struct qib7322 *qib7322, uint32_t dword,
 208                              unsigned long offset ) {
 209         writel ( dword, ( qib7322->regs + offset ) );
 210 }
 211
 212 /***************************************************************************
 213  *
 214  * Link state management
 215  *
 216  ***************************************************************************
 217  */
 218
 219 /**
 220  * Textual representation of link state
 221  *
 222  * @v link_state        Link state
 223  * @ret link_text       Link state text
 224  */
 225 static const char * qib7322_link_state_text ( unsigned int link_state ) {
 226         switch ( link_state ) {
 227         case QIB7322_LINK_STATE_DOWN:           return "DOWN";
 228         case QIB7322_LINK_STATE_INIT:           return "INIT";
 229         case QIB7322_LINK_STATE_ARM:            return "ARM";
 230         case QIB7322_LINK_STATE_ACTIVE:         return "ACTIVE";
 231         case QIB7322_LINK_STATE_ACT_DEFER:      return "ACT_DEFER";
 232         default:                                return "UNKNOWN";
 233         }
 234 }
 235
 236 /**
 237  * Handle link state change
 238  *
 239  * @v qib7322           QIB7322 device
 240  */
 241 static void qib7322_link_state_changed ( struct ib_device *ibdev ) {
 242         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 243         struct QIB_7322_IBCStatusA_0 ibcstatusa;
 244         struct QIB_7322_EXTCtrl extctrl;
 245         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 246         unsigned int link_training_state;
 247         unsigned int link_state;
 248         unsigned int link_width;
 249         unsigned int link_speed;
 250         unsigned int link_speed_qdr;
 251         unsigned int green;
 252         unsigned int yellow;
 253
 254         /* Read link state */
 255         qib7322_readq_port ( qib7322, &ibcstatusa,
 256                              QIB_7322_IBCStatusA_0_offset, port );
 257         link_training_state = BIT_GET ( &ibcstatusa, LinkTrainingState );
 258         link_state = BIT_GET ( &ibcstatusa, LinkState );
 259         link_width = BIT_GET ( &ibcstatusa, LinkWidthActive );
 260         link_speed = BIT_GET ( &ibcstatusa, LinkSpeedActive );
 261         link_speed_qdr = BIT_GET ( &ibcstatusa, LinkSpeedQDR );
 262         DBGC ( qib7322, "QIB7322 %p port %d training state %#x link state %s "
 263                "(%s %s)\n", qib7322, port, link_training_state,
 264                qib7322_link_state_text ( link_state ),
 265                ( link_speed_qdr ? "QDR" : ( link_speed ? "DDR" : "SDR" ) ),
 266                ( link_width ? "x4" : "x1" ) );
 267
 268         /* Set LEDs according to link state */
 269         qib7322_readq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
 270         green = ( ( link_state >= QIB7322_LINK_STATE_INIT ) ? 1 : 0 );
 271         yellow = ( ( link_state >= QIB7322_LINK_STATE_ACTIVE ) ? 1 : 0 );
 272         if ( port == 0 ) {
 273                 BIT_SET ( &extctrl, LEDPort0GreenOn, green );
 274                 BIT_SET ( &extctrl, LEDPort0YellowOn, yellow );
 275         } else {
 276                 BIT_SET ( &extctrl, LEDPort1GreenOn, green );
 277                 BIT_SET ( &extctrl, LEDPort1YellowOn, yellow );
 278         }
 279         qib7322_writeq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
 280
 281         /* Notify Infiniband core of link state change */
 282         ibdev->port_state = ( link_state + 1 );
 283         ibdev->link_width_active =
 284                 ( link_width ? IB_LINK_WIDTH_4X : IB_LINK_WIDTH_1X );
 285         ibdev->link_speed_active =
 286                 ( link_speed ? IB_LINK_SPEED_DDR : IB_LINK_SPEED_SDR );
 287         ib_link_state_changed ( ibdev );
 288 }
 289
 290 /**
 291  * Wait for link state change to take effect
 292  *
 293  * @v ibdev             Infiniband device
 294  * @v new_link_state    Expected link state
 295  * @ret rc              Return status code
 296  */
 297 static int qib7322_link_state_check ( struct ib_device *ibdev,
 298                                       unsigned int new_link_state ) {
 299         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 300         struct QIB_7322_IBCStatusA_0 ibcstatusa;
 301         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 302         unsigned int link_state;
 303         unsigned int i;
 304
 305         for ( i = 0 ; i < QIB7322_LINK_STATE_MAX_WAIT_US ; i++ ) {
 306                 qib7322_readq_port ( qib7322, &ibcstatusa,
 307                                      QIB_7322_IBCStatusA_0_offset, port );
 308                 link_state = BIT_GET ( &ibcstatusa, LinkState );
 309                 if ( link_state == new_link_state )
 310                         return 0;
 311                 udelay ( 1 );
 312         }
 313
 314         DBGC ( qib7322, "QIB7322 %p port %d timed out waiting for link state "
 315                "%s\n", qib7322, port, qib7322_link_state_text ( link_state ) );
 316         return -ETIMEDOUT;
 317 }
 318
 319 /**
 320  * Set port information
 321  *
 322  * @v ibdev             Infiniband device
 323  * @v mad               Set port information MAD
 324  */
 325 static int qib7322_set_port_info ( struct ib_device *ibdev,
 326                                    union ib_mad *mad ) {
 327         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 328         struct ib_port_info *port_info = &mad->smp.smp_data.port_info;
 329         struct QIB_7322_IBCCtrlA_0 ibcctrla;
 330         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 331         unsigned int port_state;
 332         unsigned int link_state;
 333
 334         /* Set new link state */
 335         port_state = ( port_info->link_speed_supported__port_state & 0xf );
 336         if ( port_state ) {
 337                 link_state = ( port_state - 1 );
 338                 DBGC ( qib7322, "QIB7322 %p set link state to %s (%x)\n",
 339                        qib7322, qib7322_link_state_text ( link_state ),
 340                        link_state );
 341                 qib7322_readq_port ( qib7322, &ibcctrla,
 342                                      QIB_7322_IBCCtrlA_0_offset, port );
 343                 BIT_SET ( &ibcctrla, LinkCmd, link_state );
 344                 qib7322_writeq_port ( qib7322, &ibcctrla,
 345                                       QIB_7322_IBCCtrlA_0_offset, port );
 346
 347                 /* Wait for link state change to take effect.  Ignore
 348                  * errors; the current link state will be returned via
 349                  * the GetResponse MAD.
 350                  */
 351                 qib7322_link_state_check ( ibdev, link_state );
 352         }
 353
 354         /* Detect and report link state change */
 355         qib7322_link_state_changed ( ibdev );
 356
 357         return 0;
 358 }
 359
 360 /**
 361  * Set partition key table
 362  *
 363  * @v ibdev             Infiniband device
 364  * @v mad               Set partition key table MAD
 365  */
 366 static int qib7322_set_pkey_table ( struct ib_device *ibdev __unused,
 367                                     union ib_mad *mad __unused ) {
 368         /* Nothing to do */
 369         return 0;
 370 }
 371
 372 /***************************************************************************
 373  *
 374  * Context allocation
 375  *
 376  ***************************************************************************
 377  */
 378
 379 /**
 380  * Allocate a context and set queue pair number
 381  *
 382  * @v ibdev             Infiniband device
 383  * @v qp                Queue pair
 384  * @ret rc              Return status code
 385  */
 386 static int qib7322_alloc_ctx ( struct ib_device *ibdev,
 387                                struct ib_queue_pair *qp ) {
 388         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 389         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 390         unsigned int ctx;
 391
 392         for ( ctx = port ; ctx < QIB7322_NUM_CONTEXTS ; ctx += 2 ) {
 393
 394                 if ( ! qib7322->used_ctx[ctx] ) {
 395                         qib7322->used_ctx[ctx] = 1;
 396                         qp->qpn = ( ctx & ~0x01 );
 397                         DBGC2 ( qib7322, "QIB7322 %p port %d QPN %ld is CTX "
 398                                 "%d\n", qib7322, port, qp->qpn, ctx );
 399                         return 0;
 400                 }
 401         }
 402
 403         DBGC ( qib7322, "QIB7322 %p port %d out of available contexts\n",
 404                qib7322, port );
 405         return -ENOENT;
 406 }
 407
 408 /**
 409  * Get queue pair context number
 410  *
 411  * @v ibdev             Infiniband device
 412  * @v qp                Queue pair
 413  * @ret ctx             Context index
 414  */
 415 static unsigned int qib7322_ctx ( struct ib_device *ibdev,
 416                                   struct ib_queue_pair *qp ) {
 417         return ( qp->qpn + ( ibdev->port - QIB7322_PORT_BASE ) );
 418 }
 419
 420 /**
 421  * Free a context
 422  *
 423  * @v qib7322           QIB7322 device
 424  * @v ctx               Context index
 425  */
 426 static void qib7322_free_ctx ( struct ib_device *ibdev,
 427                                struct ib_queue_pair *qp ) {
 428         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 429         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 430         unsigned int ctx = qib7322_ctx ( ibdev, qp );
 431
 432         qib7322->used_ctx[ctx] = 0;
 433         DBGC2 ( qib7322, "QIB7322 %p port %d CTX %d freed\n",
 434                 qib7322, port, ctx );
 435 }
 436
 437 /***************************************************************************
 438  *
 439  * Send datapath
 440  *
 441  ***************************************************************************
 442  */
 443
 444 /** Send buffer toggle bit
 445  *
 446  * We encode send buffers as 15 bits of send buffer index plus a
 447  * single bit which should match the "check" bit in the SendBufAvail
 448  * array.
 449  */
 450 #define QIB7322_SEND_BUF_TOGGLE 0x8000
 451
 452 /**
 453  * Create send buffer set
 454  *
 455  * @v qib7322           QIB7322 device
 456  * @v base              Send buffer base offset
 457  * @v size              Send buffer size
 458  * @v start             Index of first send buffer
 459  * @v count             Number of send buffers
 460  * @ret send_bufs       Send buffer set
 461  */
 462 static struct qib7322_send_buffers *
 463 qib7322_create_send_bufs ( struct qib7322 *qib7322, unsigned long base,
 464                            unsigned int size, unsigned int start,
 465                            unsigned int count ) {
 466         struct qib7322_send_buffers *send_bufs;
 467         unsigned int i;
 468
 469         /* Allocate send buffer set */
 470         send_bufs = zalloc ( sizeof ( *send_bufs ) +
 471                              ( count * sizeof ( send_bufs->avail[0] ) ) );
 472         if ( ! send_bufs )
 473                 return NULL;
 474
 475         /* Populate send buffer set */
 476         send_bufs->base = base;
 477         send_bufs->size = size;
 478         send_bufs->start = start;
 479         send_bufs->count = count;
 480         for ( i = 0 ; i < count ; i++ )
 481                 send_bufs->avail[i] = ( start + i );
 482
 483         DBGC2 ( qib7322, "QIB7322 %p send buffer set %p [%d,%d] at %lx\n",
 484                 qib7322, send_bufs, start, ( start + count - 1 ),
 485                 send_bufs->base );
 486
 487         return send_bufs;
 488 }
 489
 490 /**
 491  * Destroy send buffer set
 492  *
 493  * @v qib7322           QIB7322 device
 494  * @v send_bufs         Send buffer set
 495  */
 496 static void
 497 qib7322_destroy_send_bufs ( struct qib7322 *qib7322 __unused,
 498                             struct qib7322_send_buffers *send_bufs ) {
 499         free ( send_bufs );
 500 }
 501
 502 /**
 503  * Allocate a send buffer
 504  *
 505  * @v qib7322           QIB7322 device
 506  * @v send_bufs         Send buffer set
 507  * @ret send_buf        Send buffer, or negative error
 508  */
 509 static int qib7322_alloc_send_buf ( struct qib7322 *qib7322,
 510                                     struct qib7322_send_buffers *send_bufs ) {
 511         unsigned int used;
 512         unsigned int mask;
 513         unsigned int send_buf;
 514
 515         used = ( send_bufs->cons - send_bufs->prod );
 516         if ( used >= send_bufs->count ) {
 517                 DBGC ( qib7322, "QIB7322 %p send buffer set %p out of "
 518                        "buffers\n", qib7322, send_bufs );
 519                 return -ENOBUFS;
 520         }
 521
 522         mask = ( send_bufs->count - 1 );
 523         send_buf = send_bufs->avail[ send_bufs->cons++ & mask ];
 524         send_buf ^= QIB7322_SEND_BUF_TOGGLE;
 525         return send_buf;
 526 }
 527
 528 /**
 529  * Free a send buffer
 530  *
 531  * @v qib7322           QIB7322 device
 532  * @v send_bufs         Send buffer set
 533  * @v send_buf          Send buffer
 534  */
 535 static void qib7322_free_send_buf ( struct qib7322 *qib7322 __unused,
 536                                     struct qib7322_send_buffers *send_bufs,
 537                                     unsigned int send_buf ) {
 538         unsigned int mask;
 539
 540         mask = ( send_bufs->count - 1 );
 541         send_bufs->avail[ send_bufs->prod++ & mask ] = send_buf;
 542 }
 543
 544 /**
 545  * Check to see if send buffer is in use
 546  *
 547  * @v qib7322           QIB7322 device
 548  * @v send_buf          Send buffer
 549  * @ret in_use          Send buffer is in use
 550  */
 551 static int qib7322_send_buf_in_use ( struct qib7322 *qib7322,
 552                                      unsigned int send_buf ) {
 553         unsigned int send_idx;
 554         unsigned int send_check;
 555         unsigned int inusecheck;
 556         unsigned int inuse;
 557         unsigned int check;
 558
 559         send_idx = ( send_buf & ~QIB7322_SEND_BUF_TOGGLE );
 560         send_check = ( !! ( send_buf & QIB7322_SEND_BUF_TOGGLE ) );
 561         inusecheck = BIT_GET ( qib7322->sendbufavail, InUseCheck[send_idx] );
 562         inuse = ( !! ( inusecheck & 0x02 ) );
 563         check = ( !! ( inusecheck & 0x01 ) );
 564         return ( inuse || ( check != send_check ) );
 565 }
 566
 567 /**
 568  * Calculate starting offset for send buffer
 569  *
 570  * @v qib7322           QIB7322 device
 571  * @v send_buf          Send buffer
 572  * @ret offset          Starting offset
 573  */
 574 static unsigned long
 575 qib7322_send_buffer_offset ( struct qib7322 *qib7322 __unused,
 576                              struct qib7322_send_buffers *send_bufs,
 577                              unsigned int send_buf ) {
 578         unsigned int index;
 579
 580         index = ( ( send_buf & ~QIB7322_SEND_BUF_TOGGLE ) - send_bufs->start );
 581         return ( send_bufs->base + ( index * send_bufs->size ) );
 582 }
 583
 584 /**
 585  * Create send work queue
 586  *
 587  * @v ibdev             Infiniband device
 588  * @v qp                Queue pair
 589  */
 590 static int qib7322_create_send_wq ( struct ib_device *ibdev,
 591                                     struct ib_queue_pair *qp ) {
 592         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 593         struct ib_work_queue *wq = &qp->send;
 594         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
 595         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 596
 597         /* Select send buffer set */
 598         if ( qp->type == IB_QPT_SMI ) {
 599                 if ( port == 0 ) {
 600                         qib7322_wq->send_bufs = qib7322->send_bufs_vl15_port0;
 601                 } else {
 602                         qib7322_wq->send_bufs = qib7322->send_bufs_vl15_port1;
 603                 }
 604         } else {
 605                 qib7322_wq->send_bufs = qib7322->send_bufs_small;
 606         }
 607
 608         /* Allocate space for send buffer usage list */
 609         qib7322_wq->used = zalloc ( qp->send.num_wqes *
 610                                     sizeof ( qib7322_wq->used[0] ) );
 611         if ( ! qib7322_wq->used )
 612                 return -ENOMEM;
 613
 614         /* Reset work queue */
 615         qib7322_wq->prod = 0;
 616         qib7322_wq->cons = 0;
 617
 618         return 0;
 619 }
 620
 621 /**
 622  * Destroy send work queue
 623  *
 624  * @v ibdev             Infiniband device
 625  * @v qp                Queue pair
 626  */
 627 static void qib7322_destroy_send_wq ( struct ib_device *ibdev __unused,
 628                                       struct ib_queue_pair *qp ) {
 629         struct ib_work_queue *wq = &qp->send;
 630         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
 631
 632         free ( qib7322_wq->used );
 633 }
 634
 635 /**
 636  * Initialise send datapath
 637  *
 638  * @v qib7322           QIB7322 device
 639  * @ret rc              Return status code
 640  */
 641 static int qib7322_init_send ( struct qib7322 *qib7322 ) {
 642         struct QIB_7322_SendBufBase sendbufbase;
 643         struct QIB_7322_SendBufAvailAddr sendbufavailaddr;
 644         struct QIB_7322_SendCtrl sendctrl;
 645         struct QIB_7322_SendCtrl_0 sendctrlp;
 646         unsigned long baseaddr_smallpio;
 647         unsigned long baseaddr_largepio;
 648         unsigned long baseaddr_vl15_port0;
 649         unsigned long baseaddr_vl15_port1;
 650         int rc;
 651
 652         /* Create send buffer sets */
 653         qib7322_readq ( qib7322, &sendbufbase, QIB_7322_SendBufBase_offset );
 654         baseaddr_smallpio = BIT_GET ( &sendbufbase, BaseAddr_SmallPIO );
 655         baseaddr_largepio = BIT_GET ( &sendbufbase, BaseAddr_LargePIO );
 656         baseaddr_vl15_port0 = ( baseaddr_largepio +
 657                                 ( QIB7322_LARGE_SEND_BUF_SIZE *
 658                                   QIB7322_LARGE_SEND_BUF_COUNT ) );
 659         baseaddr_vl15_port1 = ( baseaddr_vl15_port0 +
 660                                 QIB7322_VL15_PORT0_SEND_BUF_SIZE );
 661         qib7322->send_bufs_small =
 662                 qib7322_create_send_bufs ( qib7322, baseaddr_smallpio,
 663                                            QIB7322_SMALL_SEND_BUF_SIZE,
 664                                            QIB7322_SMALL_SEND_BUF_START,
 665                                            QIB7322_SMALL_SEND_BUF_USED );
 666         if ( ! qib7322->send_bufs_small ) {
 667                 rc = -ENOMEM;
 668                 goto err_create_send_bufs_small;
 669         }
 670         qib7322->send_bufs_vl15_port0 =
 671                 qib7322_create_send_bufs ( qib7322, baseaddr_vl15_port0,
 672                                            QIB7322_VL15_PORT0_SEND_BUF_SIZE,
 673                                            QIB7322_VL15_PORT0_SEND_BUF_START,
 674                                            QIB7322_VL15_PORT0_SEND_BUF_COUNT );
 675         if ( ! qib7322->send_bufs_vl15_port0 ) {
 676                 rc = -ENOMEM;
 677                 goto err_create_send_bufs_vl15_port0;
 678         }
 679         qib7322->send_bufs_vl15_port1 =
 680                 qib7322_create_send_bufs ( qib7322, baseaddr_vl15_port1,
 681                                            QIB7322_VL15_PORT1_SEND_BUF_SIZE,
 682                                            QIB7322_VL15_PORT1_SEND_BUF_START,
 683                                            QIB7322_VL15_PORT1_SEND_BUF_COUNT );
 684         if ( ! qib7322->send_bufs_vl15_port1 ) {
 685                 rc = -ENOMEM;
 686                 goto err_create_send_bufs_vl15_port1;
 687         }
 688
 689         /* Allocate space for the SendBufAvail array */
 690         qib7322->sendbufavail = malloc_dma ( sizeof ( *qib7322->sendbufavail ),
 691                                              QIB7322_SENDBUFAVAIL_ALIGN );
 692         if ( ! qib7322->sendbufavail ) {
 693                 rc = -ENOMEM;
 694                 goto err_alloc_sendbufavail;
 695         }
 696         memset ( qib7322->sendbufavail, 0, sizeof ( qib7322->sendbufavail ) );
 697
 698         /* Program SendBufAvailAddr into the hardware */
 699         memset ( &sendbufavailaddr, 0, sizeof ( sendbufavailaddr ) );
 700         BIT_FILL_1 ( &sendbufavailaddr, SendBufAvailAddr,
 701                      ( virt_to_bus ( qib7322->sendbufavail ) >> 6 ) );
 702         qib7322_writeq ( qib7322, &sendbufavailaddr,
 703                          QIB_7322_SendBufAvailAddr_offset );
 704
 705         /* Enable sending */
 706         memset ( &sendctrlp, 0, sizeof ( sendctrlp ) );
 707         BIT_FILL_1 ( &sendctrlp, SendEnable, 1 );
 708         qib7322_writeq ( qib7322, &sendctrlp, QIB_7322_SendCtrl_0_offset );
 709         qib7322_writeq ( qib7322, &sendctrlp, QIB_7322_SendCtrl_1_offset );
 710
 711         /* Enable DMA of SendBufAvail */
 712         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
 713         BIT_FILL_1 ( &sendctrl, SendBufAvailUpd, 1 );
 714         qib7322_writeq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
 715
 716         return 0;
 717
 718         free_dma ( qib7322->sendbufavail, sizeof ( *qib7322->sendbufavail ) );
 719  err_alloc_sendbufavail:
 720         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port1 );
 721  err_create_send_bufs_vl15_port1:
 722         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port0 );
 723  err_create_send_bufs_vl15_port0:
 724         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_small );
 725  err_create_send_bufs_small:
 726         return rc;
 727 }
 728
 729 /**
 730  * Shut down send datapath
 731  *
 732  * @v qib7322           QIB7322 device
 733  */
 734 static void qib7322_fini_send ( struct qib7322 *qib7322 ) {
 735         struct QIB_7322_SendCtrl sendctrl;
 736
 737         /* Disable sending and DMA of SendBufAvail */
 738         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
 739         qib7322_writeq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
 740         mb();
 741
 742         /* Ensure hardware has seen this disable */
 743         qib7322_readq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
 744
 745         free_dma ( qib7322->sendbufavail, sizeof ( *qib7322->sendbufavail ) );
 746         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port1 );
 747         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port0 );
 748         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_small );
 749 }
 750
 751 /***************************************************************************
 752  *
 753  * Receive datapath
 754  *
 755  ***************************************************************************
 756  */
 757
 758 /**
 759  * Create receive work queue
 760  *
 761  * @v ibdev             Infiniband device
 762  * @v qp                Queue pair
 763  * @ret rc              Return status code
 764  */
 765 static int qib7322_create_recv_wq ( struct ib_device *ibdev,
 766                                     struct ib_queue_pair *qp ) {
 767         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 768         struct ib_work_queue *wq = &qp->recv;
 769         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
 770         struct QIB_7322_RcvHdrAddr0 rcvhdraddr;
 771         struct QIB_7322_RcvHdrTailAddr0 rcvhdrtailaddr;
 772         struct QIB_7322_RcvHdrHead0 rcvhdrhead;
 773         struct QIB_7322_scalar rcvegrindexhead;
 774         struct QIB_7322_RcvCtrl rcvctrl;
 775         struct QIB_7322_RcvCtrl_P rcvctrlp;
 776         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 777         unsigned int ctx = qib7322_ctx ( ibdev, qp );
 778         int rc;
 779
 780         /* Reset context information */
 781         memset ( &qib7322_wq->header_prod, 0,
 782                  sizeof ( qib7322_wq->header_prod ) );
 783         qib7322_wq->header_cons = 0;
 784         qib7322_wq->eager_prod = 0;
 785         qib7322_wq->eager_cons = 0;
 786
 787         /* Allocate receive header buffer */
 788         qib7322_wq->header = malloc_dma ( QIB7322_RECV_HEADERS_SIZE,
 789                                           QIB7322_RECV_HEADERS_ALIGN );
 790         if ( ! qib7322_wq->header ) {
 791                 rc = -ENOMEM;
 792                 goto err_alloc_header;
 793         }
 794
 795         /* Enable context in hardware */
 796         memset ( &rcvhdraddr, 0, sizeof ( rcvhdraddr ) );
 797         BIT_FILL_1 ( &rcvhdraddr, RcvHdrAddr,
 798                      ( virt_to_bus ( qib7322_wq->header ) >> 2 ) );
 799         qib7322_writeq_array8b ( qib7322, &rcvhdraddr,
 800                                  QIB_7322_RcvHdrAddr0_offset, ctx );
 801         memset ( &rcvhdrtailaddr, 0, sizeof ( rcvhdrtailaddr ) );
 802         BIT_FILL_1 ( &rcvhdrtailaddr, RcvHdrTailAddr,
 803                      ( virt_to_bus ( &qib7322_wq->header_prod ) >> 2 ) );
 804         qib7322_writeq_array8b ( qib7322, &rcvhdrtailaddr,
 805                                  QIB_7322_RcvHdrTailAddr0_offset, ctx );
 806         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
 807         BIT_FILL_1 ( &rcvhdrhead, counter, 1 );
 808         qib7322_writeq_array64k ( qib7322, &rcvhdrhead,
 809                                   QIB_7322_RcvHdrHead0_offset, ctx );
 810         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
 811         BIT_FILL_1 ( &rcvegrindexhead, Value, 1 );
 812         qib7322_writeq_array64k ( qib7322, &rcvegrindexhead,
 813                                   QIB_7322_RcvEgrIndexHead0_offset, ctx );
 814         qib7322_readq_port ( qib7322, &rcvctrlp,
 815                              QIB_7322_RcvCtrl_0_offset, port );
 816         BIT_SET ( &rcvctrlp, ContextEnable[ctx], 1 );
 817         qib7322_writeq_port ( qib7322, &rcvctrlp,
 818                               QIB_7322_RcvCtrl_0_offset, port );
 819         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 820         BIT_SET ( &rcvctrl, IntrAvail[ctx], 1 );
 821         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 822
 823         DBGC ( qib7322, "QIB7322 %p port %d QPN %ld CTX %d hdrs [%lx,%lx) prod "
 824                "%lx\n", qib7322, port, qp->qpn, ctx,
 825                virt_to_bus ( qib7322_wq->header ),
 826                ( virt_to_bus ( qib7322_wq->header )
 827                  + QIB7322_RECV_HEADERS_SIZE ),
 828                virt_to_bus ( &qib7322_wq->header_prod ) );
 829         return 0;
 830
 831         free_dma ( qib7322_wq->header, QIB7322_RECV_HEADERS_SIZE );
 832  err_alloc_header:
 833         return rc;
 834 }
 835
 836 /**
 837  * Destroy receive work queue
 838  *
 839  * @v ibdev             Infiniband device
 840  * @v qp                Queue pair
 841  */
 842 static void qib7322_destroy_recv_wq ( struct ib_device *ibdev,
 843                                       struct ib_queue_pair *qp ) {
 844         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
 845         struct ib_work_queue *wq = &qp->recv;
 846         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
 847         struct QIB_7322_RcvCtrl rcvctrl;
 848         struct QIB_7322_RcvCtrl_P rcvctrlp;
 849         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
 850         unsigned int ctx = qib7322_ctx ( ibdev, qp );
 851
 852         /* Disable context in hardware */
 853         qib7322_readq_port ( qib7322, &rcvctrlp,
 854                              QIB_7322_RcvCtrl_0_offset, port );
 855         BIT_SET ( &rcvctrlp, ContextEnable[ctx], 0 );
 856         qib7322_writeq_port ( qib7322, &rcvctrlp,
 857                               QIB_7322_RcvCtrl_0_offset, port );
 858         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 859         BIT_SET ( &rcvctrl, IntrAvail[ctx], 0 );
 860         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 861
 862         /* Make sure the hardware has seen that the context is disabled */
 863         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 864         mb();
 865
 866         /* Free headers ring */
 867         free_dma ( qib7322_wq->header, QIB7322_RECV_HEADERS_SIZE );
 868 }
 869
 870 /**
 871  * Initialise receive datapath
 872  *
 873  * @v qib7322           QIB7322 device
 874  * @ret rc              Return status code
 875  */
 876 static int qib7322_init_recv ( struct qib7322 *qib7322 ) {
 877         struct QIB_7322_RcvCtrl rcvctrl;
 878         struct QIB_7322_RcvCtrl_0 rcvctrlp;
 879         struct QIB_7322_RcvQPMapTableA_0 rcvqpmaptablea0;
 880         struct QIB_7322_RcvQPMapTableB_0 rcvqpmaptableb0;
 881         struct QIB_7322_RcvQPMapTableA_1 rcvqpmaptablea1;
 882         struct QIB_7322_RcvQPMapTableB_1 rcvqpmaptableb1;
 883         struct QIB_7322_RcvQPMulticastContext_0 rcvqpmcastctx0;
 884         struct QIB_7322_RcvQPMulticastContext_1 rcvqpmcastctx1;
 885         struct QIB_7322_scalar rcvegrbase;
 886         struct QIB_7322_scalar rcvhdrentsize;
 887         struct QIB_7322_scalar rcvhdrcnt;
 888         struct QIB_7322_RcvBTHQP_0 rcvbthqp;
 889         struct QIB_7322_RxCreditVL0_0 rxcreditvl;
 890         unsigned int contextcfg;
 891         unsigned long egrbase;
 892         unsigned int eager_array_size_kernel;
 893         unsigned int eager_array_size_user;
 894         unsigned int ctx;
 895
 896         /* Select configuration based on number of contexts */
 897         switch ( QIB7322_NUM_CONTEXTS ) {
 898         case 6:
 899                 contextcfg = QIB7322_CONTEXTCFG_6CTX;
 900                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_6CTX_KERNEL;
 901                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_6CTX_USER;
 902                 break;
 903         case 10:
 904                 contextcfg = QIB7322_CONTEXTCFG_10CTX;
 905                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_10CTX_KERNEL;
 906                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_10CTX_USER;
 907                 break;
 908         case 18:
 909                 contextcfg = QIB7322_CONTEXTCFG_18CTX;
 910                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_18CTX_KERNEL;
 911                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_18CTX_USER;
 912                 break;
 913         default:
 914                 linker_assert ( 0, invalid_QIB7322_NUM_CONTEXTS );
 915                 return -EINVAL;
 916         }
 917
 918         /* Configure number of contexts */
 919         memset ( &rcvctrl, 0, sizeof ( rcvctrl ) );
 920         BIT_FILL_2 ( &rcvctrl,
 921                      TailUpd, 1,
 922                      ContextCfg, contextcfg );
 923         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
 924
 925         /* Map QPNs to contexts */
 926         memset ( &rcvctrlp, 0, sizeof ( rcvctrlp ) );
 927         BIT_FILL_3 ( &rcvctrlp,
 928                      RcvIBPortEnable, 1,
 929                      RcvQPMapEnable, 1,
 930                      RcvPartitionKeyDisable, 1 );
 931         qib7322_writeq ( qib7322, &rcvctrlp, QIB_7322_RcvCtrl_0_offset );
 932         qib7322_writeq ( qib7322, &rcvctrlp, QIB_7322_RcvCtrl_1_offset );
 933         memset ( &rcvqpmaptablea0, 0, sizeof ( rcvqpmaptablea0 ) );
 934         BIT_FILL_6 ( &rcvqpmaptablea0,
 935                      RcvQPMapContext0, 0,
 936                      RcvQPMapContext1, 2,
 937                      RcvQPMapContext2, 4,
 938                      RcvQPMapContext3, 6,
 939                      RcvQPMapContext4, 8,
 940                      RcvQPMapContext5, 10 );
 941         qib7322_writeq ( qib7322, &rcvqpmaptablea0,
 942                          QIB_7322_RcvQPMapTableA_0_offset );
 943         memset ( &rcvqpmaptableb0, 0, sizeof ( rcvqpmaptableb0 ) );
 944         BIT_FILL_3 ( &rcvqpmaptableb0,
 945                      RcvQPMapContext6, 12,
 946                      RcvQPMapContext7, 14,
 947                      RcvQPMapContext8, 16 );
 948         qib7322_writeq ( qib7322, &rcvqpmaptableb0,
 949                          QIB_7322_RcvQPMapTableB_0_offset );
 950         memset ( &rcvqpmaptablea1, 0, sizeof ( rcvqpmaptablea1 ) );
 951         BIT_FILL_6 ( &rcvqpmaptablea1,
 952                      RcvQPMapContext0, 1,
 953                      RcvQPMapContext1, 3,
 954                      RcvQPMapContext2, 5,
 955                      RcvQPMapContext3, 7,
 956                      RcvQPMapContext4, 9,
 957                      RcvQPMapContext5, 11 );
 958         qib7322_writeq ( qib7322, &rcvqpmaptablea1,
 959                          QIB_7322_RcvQPMapTableA_1_offset );
 960         memset ( &rcvqpmaptableb1, 0, sizeof ( rcvqpmaptableb1 ) );
 961         BIT_FILL_3 ( &rcvqpmaptableb1,
 962                      RcvQPMapContext6, 13,
 963                      RcvQPMapContext7, 15,
 964                      RcvQPMapContext8, 17 );
 965         qib7322_writeq ( qib7322, &rcvqpmaptableb1,
 966                          QIB_7322_RcvQPMapTableB_1_offset );
 967
 968         /* Map multicast QPNs to contexts */
 969         memset ( &rcvqpmcastctx0, 0, sizeof ( rcvqpmcastctx0 ) );
 970         BIT_FILL_1 ( &rcvqpmcastctx0, RcvQpMcContext, 0 );
 971         qib7322_writeq ( qib7322, &rcvqpmcastctx0,
 972                          QIB_7322_RcvQPMulticastContext_0_offset );
 973         memset ( &rcvqpmcastctx1, 0, sizeof ( rcvqpmcastctx1 ) );
 974         BIT_FILL_1 ( &rcvqpmcastctx1, RcvQpMcContext, 1 );
 975         qib7322_writeq ( qib7322, &rcvqpmcastctx1,
 976                          QIB_7322_RcvQPMulticastContext_1_offset );
 977
 978         /* Configure receive header buffer sizes */
 979         memset ( &rcvhdrcnt, 0, sizeof ( rcvhdrcnt ) );
 980         BIT_FILL_1 ( &rcvhdrcnt, Value, QIB7322_RECV_HEADER_COUNT );
 981         qib7322_writeq ( qib7322, &rcvhdrcnt, QIB_7322_RcvHdrCnt_offset );
 982         memset ( &rcvhdrentsize, 0, sizeof ( rcvhdrentsize ) );
 983         BIT_FILL_1 ( &rcvhdrentsize, Value, ( QIB7322_RECV_HEADER_SIZE >> 2 ) );
 984         qib7322_writeq ( qib7322, &rcvhdrentsize,
 985                          QIB_7322_RcvHdrEntSize_offset );
 986
 987         /* Calculate eager array start addresses for each context */
 988         qib7322_readq ( qib7322, &rcvegrbase, QIB_7322_RcvEgrBase_offset );
 989         egrbase = BIT_GET ( &rcvegrbase, Value );
 990         for ( ctx = 0 ; ctx < QIB7322_MAX_PORTS ; ctx++ ) {
 991                 qib7322->recv_wq[ctx].eager_array = egrbase;
 992                 qib7322->recv_wq[ctx].eager_entries = eager_array_size_kernel;
 993                 egrbase += ( eager_array_size_kernel *
 994                              sizeof ( struct QIB_7322_RcvEgr ) );
 995         }
 996         for ( ; ctx < QIB7322_NUM_CONTEXTS ; ctx++ ) {
 997                 qib7322->recv_wq[ctx].eager_array = egrbase;
 998                 qib7322->recv_wq[ctx].eager_entries = eager_array_size_user;
 999                 egrbase += ( eager_array_size_user *
1000                              sizeof ( struct QIB_7322_RcvEgr ) );
1001         }
1002         for ( ctx = 0 ; ctx < QIB7322_NUM_CONTEXTS ; ctx++ ) {
1003                 DBGC ( qib7322, "QIB7322 %p CTX %d eager array at %lx (%d "
1004                        "entries)\n", qib7322, ctx,
1005                        qib7322->recv_wq[ctx].eager_array,
1006                        qib7322->recv_wq[ctx].eager_entries );
1007         }
1008
1009         /* Set the BTH QP for Infinipath packets to an unused value */
1010         memset ( &rcvbthqp, 0, sizeof ( rcvbthqp ) );
1011         BIT_FILL_1 ( &rcvbthqp, RcvBTHQP, QIB7322_QP_IDETH );
1012         qib7322_writeq ( qib7322, &rcvbthqp, QIB_7322_RcvBTHQP_0_offset );
1013         qib7322_writeq ( qib7322, &rcvbthqp, QIB_7322_RcvBTHQP_1_offset );
1014
1015         /* Assign initial credits */
1016         memset ( &rxcreditvl, 0, sizeof ( rxcreditvl ) );
1017         BIT_FILL_1 ( &rxcreditvl, RxMaxCreditVL, QIB7322_MAX_CREDITS_VL0 );
1018         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1019                                  QIB_7322_RxCreditVL0_0_offset, 0 );
1020         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1021                                  QIB_7322_RxCreditVL0_1_offset, 0 );
1022         BIT_FILL_1 ( &rxcreditvl, RxMaxCreditVL, QIB7322_MAX_CREDITS_VL15 );
1023         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1024                                  QIB_7322_RxCreditVL0_0_offset, 15 );
1025         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1026                                  QIB_7322_RxCreditVL0_1_offset, 15 );
1027
1028         return 0;
1029 }
1030
1031 /**
1032  * Shut down receive datapath
1033  *
1034  * @v qib7322           QIB7322 device
1035  */
1036 static void qib7322_fini_recv ( struct qib7322 *qib7322 __unused ) {
1037         /* Nothing to do; all contexts were already disabled when the
1038          * queue pairs were destroyed
1039          */
1040 }
1041
1042 /***************************************************************************
1043  *
1044  * Completion queue operations
1045  *
1046  ***************************************************************************
1047  */
1048
1049 /**
1050  * Create completion queue
1051  *
1052  * @v ibdev             Infiniband device
1053  * @v cq                Completion queue
1054  * @ret rc              Return status code
1055  */
1056 static int qib7322_create_cq ( struct ib_device *ibdev,
1057                                struct ib_completion_queue *cq ) {
1058         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1059         static int cqn;
1060
1061         /* The hardware has no concept of completion queues.  We
1062          * simply use the association between CQs and WQs (already
1063          * handled by the IB core) to decide which WQs to poll.
1064          *
1065          * We do set a CQN, just to avoid confusing debug messages
1066          * from the IB core.
1067          */
1068         cq->cqn = ++cqn;
1069         DBGC ( qib7322, "QIB7322 %p CQN %ld created\n", qib7322, cq->cqn );
1070
1071         return 0;
1072 }
1073
1074 /**
1075  * Destroy completion queue
1076  *
1077  * @v ibdev             Infiniband device
1078  * @v cq                Completion queue
1079  */
1080 static void qib7322_destroy_cq ( struct ib_device *ibdev,
1081                                  struct ib_completion_queue *cq ) {
1082         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1083
1084         /* Nothing to do */
1085         DBGC ( qib7322, "QIB7322 %p CQN %ld destroyed\n", qib7322, cq->cqn );
1086 }
1087
1088 /***************************************************************************
1089  *
1090  * Queue pair operations
1091  *
1092  ***************************************************************************
1093  */
1094
1095 /**
1096  * Create queue pair
1097  *
1098  * @v ibdev             Infiniband device
1099  * @v qp                Queue pair
1100  * @ret rc              Return status code
1101  */
1102 static int qib7322_create_qp ( struct ib_device *ibdev,
1103                                struct ib_queue_pair *qp ) {
1104         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1105         unsigned int ctx;
1106         int rc;
1107
1108         /* Allocate a context and QPN */
1109         if ( ( rc = qib7322_alloc_ctx ( ibdev, qp ) ) != 0 )
1110                 goto err_alloc_ctx;
1111         ctx = qib7322_ctx ( ibdev, qp );
1112
1113         /* Set work-queue private data pointers */
1114         ib_wq_set_drvdata ( &qp->send, &qib7322->send_wq[ctx] );
1115         ib_wq_set_drvdata ( &qp->recv, &qib7322->recv_wq[ctx] );
1116
1117         /* Create receive work queue */
1118         if ( ( rc = qib7322_create_recv_wq ( ibdev, qp ) ) != 0 )
1119                 goto err_create_recv_wq;
1120
1121         /* Create send work queue */
1122         if ( ( rc = qib7322_create_send_wq ( ibdev, qp ) ) != 0 )
1123                 goto err_create_send_wq;
1124
1125         return 0;
1126
1127         qib7322_destroy_send_wq ( ibdev, qp );
1128  err_create_send_wq:
1129         qib7322_destroy_recv_wq ( ibdev, qp );
1130  err_create_recv_wq:
1131         qib7322_free_ctx ( ibdev, qp );
1132  err_alloc_ctx:
1133         return rc;
1134 }
1135
1136 /**
1137  * Modify queue pair
1138  *
1139  * @v ibdev             Infiniband device
1140  * @v qp                Queue pair
1141  * @ret rc              Return status code
1142  */
1143 static int qib7322_modify_qp ( struct ib_device *ibdev,
1144                                struct ib_queue_pair *qp ) {
1145         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1146
1147         /* Nothing to do; the hardware doesn't have a notion of queue
1148          * keys
1149          */
1150         DBGC2 ( qib7322, "QIB7322 %p QPN %ld modified\n", qib7322, qp->qpn );
1151         return 0;
1152 }
1153
1154 /**
1155  * Destroy queue pair
1156  *
1157  * @v ibdev             Infiniband device
1158  * @v qp                Queue pair
1159  */
1160 static void qib7322_destroy_qp ( struct ib_device *ibdev,
1161                                  struct ib_queue_pair *qp ) {
1162
1163         qib7322_destroy_send_wq ( ibdev, qp );
1164         qib7322_destroy_recv_wq ( ibdev, qp );
1165         qib7322_free_ctx ( ibdev, qp );
1166 }
1167
1168 /***************************************************************************
1169  *
1170  * Work request operations
1171  *
1172  ***************************************************************************
1173  */
1174
1175 /**
1176  * Post send work queue entry
1177  *
1178  * @v ibdev             Infiniband device
1179  * @v qp                Queue pair
1180  * @v dest              Destination address vector
1181  * @v iobuf             I/O buffer
1182  * @ret rc              Return status code
1183  */
1184 static int qib7322_post_send ( struct ib_device *ibdev,
1185                                struct ib_queue_pair *qp,
1186                                struct ib_address_vector *dest,
1187                                struct io_buffer *iobuf ) {
1188         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1189         struct ib_work_queue *wq = &qp->send;
1190         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1191         struct QIB_7322_SendPbc sendpbc;
1192         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1193         uint8_t header_buf[IB_MAX_HEADER_SIZE];
1194         struct io_buffer headers;
1195         int send_buf;
1196         unsigned long start_offset;
1197         unsigned long offset;
1198         size_t len;
1199         ssize_t frag_len;
1200         uint32_t *data;
1201
1202         /* Allocate send buffer and calculate offset */
1203         send_buf = qib7322_alloc_send_buf ( qib7322, qib7322_wq->send_bufs );
1204         if ( send_buf < 0 )
1205                 return send_buf;
1206         start_offset = offset =
1207                 qib7322_send_buffer_offset ( qib7322, qib7322_wq->send_bufs,
1208                                              send_buf );
1209
1210         /* Store I/O buffer and send buffer index */
1211         assert ( wq->iobufs[qib7322_wq->prod] == NULL );
1212         wq->iobufs[qib7322_wq->prod] = iobuf;
1213         qib7322_wq->used[qib7322_wq->prod] = send_buf;
1214
1215         /* Construct headers */
1216         iob_populate ( &headers, header_buf, 0, sizeof ( header_buf ) );
1217         iob_reserve ( &headers, sizeof ( header_buf ) );
1218         ib_push ( ibdev, &headers, qp, iob_len ( iobuf ), dest );
1219
1220         /* Calculate packet length */
1221         len = ( ( sizeof ( sendpbc ) + iob_len ( &headers ) +
1222                   iob_len ( iobuf ) + 3 ) & ~3 );
1223
1224         /* Construct send per-buffer control word */
1225         memset ( &sendpbc, 0, sizeof ( sendpbc ) );
1226         BIT_FILL_3 ( &sendpbc,
1227                      LengthP1_toibc, ( ( len >> 2 ) - 1 ),
1228                      Port, port,
1229                      VL15, ( ( qp->type == IB_QPT_SMI ) ? 1 : 0 ) );
1230
1231         /* Write SendPbc */
1232         DBG_DISABLE ( DBGLVL_IO );
1233         qib7322_writeq ( qib7322, &sendpbc, offset );
1234         offset += sizeof ( sendpbc );
1235
1236         /* Write headers */
1237         for ( data = headers.data, frag_len = iob_len ( &headers ) ;
1238               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
1239                 qib7322_writel ( qib7322, *data, offset );
1240         }
1241
1242         /* Write data */
1243         for ( data = iobuf->data, frag_len = iob_len ( iobuf ) ;
1244               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
1245                 qib7322_writel ( qib7322, *data, offset );
1246         }
1247         DBG_ENABLE ( DBGLVL_IO );
1248
1249         assert ( ( start_offset + len ) == offset );
1250         DBGC2 ( qib7322, "QIB7322 %p QPN %ld TX %04x(%04x) posted [%lx,%lx)\n",
1251                 qib7322, qp->qpn, send_buf, qib7322_wq->prod,
1252                 start_offset, offset );
1253
1254         /* Increment producer counter */
1255         qib7322_wq->prod = ( ( qib7322_wq->prod + 1 ) & ( wq->num_wqes - 1 ) );
1256
1257         return 0;
1258 }
1259
1260 /**
1261  * Complete send work queue entry
1262  *
1263  * @v ibdev             Infiniband device
1264  * @v qp                Queue pair
1265  * @v wqe_idx           Work queue entry index
1266  */
1267 static void qib7322_complete_send ( struct ib_device *ibdev,
1268                                     struct ib_queue_pair *qp,
1269                                     unsigned int wqe_idx ) {
1270         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1271         struct ib_work_queue *wq = &qp->send;
1272         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1273         struct io_buffer *iobuf;
1274         unsigned int send_buf;
1275
1276         /* Parse completion */
1277         send_buf = qib7322_wq->used[wqe_idx];
1278         DBGC2 ( qib7322, "QIB7322 %p QPN %ld TX %04x(%04x) complete\n",
1279                 qib7322, qp->qpn, send_buf, wqe_idx );
1280
1281         /* Complete work queue entry */
1282         iobuf = wq->iobufs[wqe_idx];
1283         assert ( iobuf != NULL );
1284         ib_complete_send ( ibdev, qp, iobuf, 0 );
1285         wq->iobufs[wqe_idx] = NULL;
1286
1287         /* Free send buffer */
1288         qib7322_free_send_buf ( qib7322, qib7322_wq->send_bufs, send_buf );
1289 }
1290
1291 /**
1292  * Poll send work queue
1293  *
1294  * @v ibdev             Infiniband device
1295  * @v qp                Queue pair
1296  */
1297 static void qib7322_poll_send_wq ( struct ib_device *ibdev,
1298                                    struct ib_queue_pair *qp ) {
1299         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1300         struct ib_work_queue *wq = &qp->send;
1301         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1302         unsigned int send_buf;
1303
1304         /* Look for completions */
1305         while ( wq->fill ) {
1306
1307                 /* Check to see if send buffer has completed */
1308                 send_buf = qib7322_wq->used[qib7322_wq->cons];
1309                 if ( qib7322_send_buf_in_use ( qib7322, send_buf ) )
1310                         break;
1311
1312                 /* Complete this buffer */
1313                 qib7322_complete_send ( ibdev, qp, qib7322_wq->cons );
1314
1315                 /* Increment consumer counter */
1316                 qib7322_wq->cons = ( ( qib7322_wq->cons + 1 ) &
1317                                      ( wq->num_wqes - 1 ) );
1318         }
1319 }
1320
1321 /**
1322  * Post receive work queue entry
1323  *
1324  * @v ibdev             Infiniband device
1325  * @v qp                Queue pair
1326  * @v iobuf             I/O buffer
1327  * @ret rc              Return status code
1328  */
1329 static int qib7322_post_recv ( struct ib_device *ibdev,
1330                                struct ib_queue_pair *qp,
1331                                struct io_buffer *iobuf ) {
1332         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1333         struct ib_work_queue *wq = &qp->recv;
1334         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1335         struct QIB_7322_RcvEgr rcvegr;
1336         struct QIB_7322_scalar rcvegrindexhead;
1337         unsigned int ctx = qib7322_ctx ( ibdev, qp );
1338         physaddr_t addr;
1339         size_t len;
1340         unsigned int wqe_idx;
1341         unsigned int bufsize;
1342
1343         /* Sanity checks */
1344         addr = virt_to_bus ( iobuf->data );
1345         len = iob_tailroom ( iobuf );
1346         if ( addr & ( QIB7322_EAGER_BUFFER_ALIGN - 1 ) ) {
1347                 DBGC ( qib7322, "QIB7322 %p QPN %ld misaligned RX buffer "
1348                        "(%08lx)\n", qib7322, qp->qpn, addr );
1349                 return -EINVAL;
1350         }
1351         if ( len != QIB7322_RECV_PAYLOAD_SIZE ) {
1352                 DBGC ( qib7322, "QIB7322 %p QPN %ld wrong RX buffer size "
1353                        "(%zd)\n", qib7322, qp->qpn, len );
1354                 return -EINVAL;
1355         }
1356
1357         /* Calculate eager producer index and WQE index */
1358         wqe_idx = ( qib7322_wq->eager_prod & ( wq->num_wqes - 1 ) );
1359         assert ( wq->iobufs[wqe_idx] == NULL );
1360
1361         /* Store I/O buffer */
1362         wq->iobufs[wqe_idx] = iobuf;
1363
1364         /* Calculate buffer size */
1365         switch ( QIB7322_RECV_PAYLOAD_SIZE ) {
1366         case 2048:  bufsize = QIB7322_EAGER_BUFFER_2K;  break;
1367         case 4096:  bufsize = QIB7322_EAGER_BUFFER_4K;  break;
1368         case 8192:  bufsize = QIB7322_EAGER_BUFFER_8K;  break;
1369         case 16384: bufsize = QIB7322_EAGER_BUFFER_16K; break;
1370         case 32768: bufsize = QIB7322_EAGER_BUFFER_32K; break;
1371         case 65536: bufsize = QIB7322_EAGER_BUFFER_64K; break;
1372         default:    linker_assert ( 0, invalid_rx_payload_size );
1373                     bufsize = QIB7322_EAGER_BUFFER_NONE;
1374         }
1375
1376         /* Post eager buffer */
1377         memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1378         BIT_FILL_2 ( &rcvegr,
1379                      Addr, ( addr >> 11 ),
1380                      BufSize, bufsize );
1381         qib7322_writeq_array8b ( qib7322, &rcvegr, qib7322_wq->eager_array,
1382                                  qib7322_wq->eager_prod );
1383         DBGC2 ( qib7322, "QIB7322 %p QPN %ld RX egr %04x(%04x) posted "
1384                 "[%lx,%lx)\n", qib7322, qp->qpn, qib7322_wq->eager_prod,
1385                 wqe_idx, addr, ( addr + len ) );
1386
1387         /* Increment producer index */
1388         qib7322_wq->eager_prod = ( ( qib7322_wq->eager_prod + 1 ) &
1389                                    ( qib7322_wq->eager_entries - 1 ) );
1390
1391         /* Update head index */
1392         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
1393         BIT_FILL_1 ( &rcvegrindexhead,
1394                      Value, ( ( qib7322_wq->eager_prod + 1 ) &
1395                               ( qib7322_wq->eager_entries - 1 ) ) );
1396         qib7322_writeq_array64k ( qib7322, &rcvegrindexhead,
1397                                   QIB_7322_RcvEgrIndexHead0_offset, ctx );
1398
1399         return 0;
1400 }
1401
1402 /**
1403  * Complete receive work queue entry
1404  *
1405  * @v ibdev             Infiniband device
1406  * @v qp                Queue pair
1407  * @v header_offs       Header offset
1408  */
1409 static void qib7322_complete_recv ( struct ib_device *ibdev,
1410                                     struct ib_queue_pair *qp,
1411                                     unsigned int header_offs ) {
1412         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1413         struct ib_work_queue *wq = &qp->recv;
1414         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1415         struct QIB_7322_RcvHdrFlags *rcvhdrflags;
1416         struct QIB_7322_RcvEgr rcvegr;
1417         struct io_buffer headers;
1418         struct io_buffer *iobuf;
1419         struct ib_queue_pair *intended_qp;
1420         struct ib_address_vector dest;
1421         struct ib_address_vector source;
1422         unsigned int rcvtype;
1423         unsigned int pktlen;
1424         unsigned int egrindex;
1425         unsigned int useegrbfr;
1426         unsigned int iberr, mkerr, tiderr, khdrerr, mtuerr;
1427         unsigned int lenerr, parityerr, vcrcerr, icrcerr;
1428         unsigned int err;
1429         unsigned int hdrqoffset;
1430         unsigned int header_len;
1431         unsigned int padded_payload_len;
1432         unsigned int wqe_idx;
1433         size_t payload_len;
1434         int qp0;
1435         int rc;
1436
1437         /* RcvHdrFlags are at the end of the header entry */
1438         rcvhdrflags = ( qib7322_wq->header + header_offs +
1439                         QIB7322_RECV_HEADER_SIZE - sizeof ( *rcvhdrflags ) );
1440         rcvtype = BIT_GET ( rcvhdrflags, RcvType );
1441         pktlen = ( BIT_GET ( rcvhdrflags, PktLen ) << 2 );
1442         egrindex = BIT_GET ( rcvhdrflags, EgrIndex );
1443         useegrbfr = BIT_GET ( rcvhdrflags, UseEgrBfr );
1444         hdrqoffset = ( BIT_GET ( rcvhdrflags, HdrqOffset ) << 2 );
1445         iberr = BIT_GET ( rcvhdrflags, IBErr );
1446         mkerr = BIT_GET ( rcvhdrflags, MKErr );
1447         tiderr = BIT_GET ( rcvhdrflags, TIDErr );
1448         khdrerr = BIT_GET ( rcvhdrflags, KHdrErr );
1449         mtuerr = BIT_GET ( rcvhdrflags, MTUErr );
1450         lenerr = BIT_GET ( rcvhdrflags, LenErr );
1451         parityerr = BIT_GET ( rcvhdrflags, ParityErr );
1452         vcrcerr = BIT_GET ( rcvhdrflags, VCRCErr );
1453         icrcerr = BIT_GET ( rcvhdrflags, ICRCErr );
1454         header_len = ( QIB7322_RECV_HEADER_SIZE - hdrqoffset -
1455                        sizeof ( *rcvhdrflags ) );
1456         padded_payload_len = ( pktlen - header_len - 4 /* ICRC */ );
1457         err = ( iberr | mkerr | tiderr | khdrerr | mtuerr |
1458                 lenerr | parityerr | vcrcerr | icrcerr );
1459         /* IB header is placed immediately before RcvHdrFlags */
1460         iob_populate ( &headers, ( ( ( void * ) rcvhdrflags ) - header_len ),
1461                        header_len, header_len );
1462
1463         /* Dump diagnostic information */
1464         DBGC2 ( qib7322, "QIB7322 %p QPN %ld RX egr %04x%s hdr %d type %d len "
1465                 "%d(%d+%d+4)%s%s%s%s%s%s%s%s%s%s%s\n", qib7322, qp->qpn,
1466                 egrindex, ( useegrbfr ? "" : "(unused)" ),
1467                 ( header_offs / QIB7322_RECV_HEADER_SIZE ),
1468                 rcvtype, pktlen, header_len, padded_payload_len,
1469                 ( err ? " [Err" : "" ), ( iberr ? " IB" : "" ),
1470                 ( mkerr ? " MK" : "" ), ( tiderr ? " TID" : "" ),
1471                 ( khdrerr ? " KHdr" : "" ), ( mtuerr ? " MTU" : "" ),
1472                 ( lenerr ? " Len" : "" ), ( parityerr ? " Parity" : ""),
1473                 ( vcrcerr ? " VCRC" : "" ), ( icrcerr ? " ICRC" : "" ),
1474                 ( err ? "]" : "" ) );
1475         DBGCP_HDA ( qib7322, hdrqoffset, headers.data,
1476                     ( header_len + sizeof ( *rcvhdrflags ) ) );
1477
1478         /* Parse header to generate address vector */
1479         qp0 = ( qp->qpn == 0 );
1480         intended_qp = NULL;
1481         if ( ( rc = ib_pull ( ibdev, &headers, ( qp0 ? &intended_qp : NULL ),
1482                               &payload_len, &dest, &source ) ) != 0 ) {
1483                 DBGC ( qib7322, "QIB7322 %p could not parse headers: %s\n",
1484                        qib7322, strerror ( rc ) );
1485                 err = 1;
1486         }
1487         if ( ! intended_qp )
1488                 intended_qp = qp;
1489
1490         /* Complete this buffer and any skipped buffers.  Note that
1491          * when the hardware runs out of buffers, it will repeatedly
1492          * report the same buffer (the tail) as a TID error, and that
1493          * it also has a habit of sometimes skipping over several
1494          * buffers at once.
1495          */
1496         while ( 1 ) {
1497
1498                 /* If we have caught up to the producer counter, stop.
1499                  * This will happen when the hardware first runs out
1500                  * of buffers and starts reporting TID errors against
1501                  * the eager buffer it wants to use next.
1502                  */
1503                 if ( qib7322_wq->eager_cons == qib7322_wq->eager_prod )
1504                         break;
1505
1506                 /* If we have caught up to where we should be after
1507                  * completing this egrindex, stop.  We phrase the test
1508                  * this way to avoid completing the entire ring when
1509                  * we receive the same egrindex twice in a row.
1510                  */
1511                 if ( ( qib7322_wq->eager_cons ==
1512                        ( ( egrindex + 1 ) & ( qib7322_wq->eager_entries - 1 ))))
1513                         break;
1514
1515                 /* Identify work queue entry and corresponding I/O
1516                  * buffer.
1517                  */
1518                 wqe_idx = ( qib7322_wq->eager_cons & ( wq->num_wqes - 1 ) );
1519                 iobuf = wq->iobufs[wqe_idx];
1520                 assert ( iobuf != NULL );
1521                 wq->iobufs[wqe_idx] = NULL;
1522
1523                 /* Complete the eager buffer */
1524                 if ( qib7322_wq->eager_cons == egrindex ) {
1525                         /* Completing the eager buffer described in
1526                          * this header entry.
1527                          */
1528                         iob_put ( iobuf, payload_len );
1529                         rc = ( err ? -EIO : ( useegrbfr ? 0 : -ECANCELED ) );
1530                         /* Redirect to target QP if necessary */
1531                         if ( qp != intended_qp ) {
1532                                 DBGC2 ( qib7322, "QIB7322 %p redirecting QPN "
1533                                         "%ld => %ld\n",
1534                                         qib7322, qp->qpn, intended_qp->qpn );
1535                                 /* Compensate for incorrect fill levels */
1536                                 qp->recv.fill--;
1537                                 intended_qp->recv.fill++;
1538                         }
1539                         ib_complete_recv ( ibdev, intended_qp, &dest, &source,
1540                                            iobuf, rc);
1541                 } else {
1542                         /* Completing on a skipped-over eager buffer */
1543                         ib_complete_recv ( ibdev, qp, &dest, &source, iobuf,
1544                                            -ECANCELED );
1545                 }
1546
1547                 /* Clear eager buffer */
1548                 memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1549                 qib7322_writeq_array8b ( qib7322, &rcvegr,
1550                                          qib7322_wq->eager_array,
1551                                          qib7322_wq->eager_cons );
1552
1553                 /* Increment consumer index */
1554                 qib7322_wq->eager_cons = ( ( qib7322_wq->eager_cons + 1 ) &
1555                                            ( qib7322_wq->eager_entries - 1 ) );
1556         }
1557 }
1558
1559 /**
1560  * Poll receive work queue
1561  *
1562  * @v ibdev             Infiniband device
1563  * @v qp                Queue pair
1564  */
1565 static void qib7322_poll_recv_wq ( struct ib_device *ibdev,
1566                                    struct ib_queue_pair *qp ) {
1567         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1568         struct ib_work_queue *wq = &qp->recv;
1569         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1570         struct QIB_7322_RcvHdrHead0 rcvhdrhead;
1571         unsigned int ctx = qib7322_ctx ( ibdev, qp );
1572         unsigned int header_prod;
1573
1574         /* Check for received packets */
1575         header_prod = ( BIT_GET ( &qib7322_wq->header_prod, Value ) << 2 );
1576         if ( header_prod == qib7322_wq->header_cons )
1577                 return;
1578
1579         /* Process all received packets */
1580         while ( qib7322_wq->header_cons != header_prod ) {
1581
1582                 /* Complete the receive */
1583                 qib7322_complete_recv ( ibdev, qp, qib7322_wq->header_cons );
1584
1585                 /* Increment the consumer offset */
1586                 qib7322_wq->header_cons += QIB7322_RECV_HEADER_SIZE;
1587                 qib7322_wq->header_cons %= QIB7322_RECV_HEADERS_SIZE;
1588
1589                 /* QIB7322 has only one send buffer per port for VL15,
1590                  * which almost always leads to send buffer exhaustion
1591                  * and dropped MADs.  Mitigate this by refusing to
1592                  * process more than one VL15 MAD per poll, which will
1593                  * enforce interleaved TX/RX polls.
1594                  */
1595                 if ( qp->type == IB_QPT_SMI )
1596                         break;
1597         }
1598
1599         /* Update consumer offset */
1600         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
1601         BIT_FILL_2 ( &rcvhdrhead,
1602                      RcvHeadPointer, ( qib7322_wq->header_cons >> 2 ),
1603                      counter, 1 );
1604         qib7322_writeq_array64k ( qib7322, &rcvhdrhead,
1605                                   QIB_7322_RcvHdrHead0_offset, ctx );
1606 }
1607
1608 /**
1609  * Poll completion queue
1610  *
1611  * @v ibdev             Infiniband device
1612  * @v cq                Completion queue
1613  */
1614 static void qib7322_poll_cq ( struct ib_device *ibdev,
1615                               struct ib_completion_queue *cq ) {
1616         struct ib_work_queue *wq;
1617
1618         /* Poll associated send and receive queues */
1619         list_for_each_entry ( wq, &cq->work_queues, list ) {
1620                 if ( wq->is_send ) {
1621                         qib7322_poll_send_wq ( ibdev, wq->qp );
1622                 } else {
1623                         qib7322_poll_recv_wq ( ibdev, wq->qp );
1624                 }
1625         }
1626 }
1627
1628 /***************************************************************************
1629  *
1630  * Event queues
1631  *
1632  ***************************************************************************
1633  */
1634
1635 /**
1636  * Poll event queue
1637  *
1638  * @v ibdev             Infiniband device
1639  */
1640 static void qib7322_poll_eq ( struct ib_device *ibdev ) {
1641         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1642         struct QIB_7322_ErrStatus_0 errstatus;
1643         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1644
1645         /* Check for and clear status bits */
1646         DBG_DISABLE ( DBGLVL_IO );
1647         qib7322_readq_port ( qib7322, &errstatus,
1648                              QIB_7322_ErrStatus_0_offset, port );
1649         if ( errstatus.u.qwords[0] ) {
1650                 DBGC ( qib7322, "QIB7322 %p port %d status %08x%08x\n", qib7322,
1651                        port, errstatus.u.dwords[1],  errstatus.u.dwords[0] );
1652                 qib7322_writeq_port ( qib7322, &errstatus,
1653                                       QIB_7322_ErrClear_0_offset, port );
1654         }
1655         DBG_ENABLE ( DBGLVL_IO );
1656
1657         /* Check for link status changes */
1658         if ( BIT_GET ( &errstatus, IBStatusChanged ) )
1659                 qib7322_link_state_changed ( ibdev );
1660 }
1661
1662 /***************************************************************************
1663  *
1664  * Infiniband link-layer operations
1665  *
1666  ***************************************************************************
1667  */
1668
1669 /**
1670  * Determine supported link speeds
1671  *
1672  * @v qib7322           QIB7322 device
1673  * @ret supported       Supported link speeds
1674  */
1675 static unsigned int qib7322_link_speed_supported ( struct qib7322 *qib7322,
1676                                                    unsigned int port ) {
1677         struct QIB_7322_feature_mask features;
1678         struct QIB_7322_Revision revision;
1679         unsigned int supported;
1680         unsigned int boardid;
1681
1682         /* Read the active feature mask */
1683         qib7322_readq ( qib7322, &features,
1684                         QIB_7322_active_feature_mask_offset );
1685         switch ( port ) {
1686         case 0 :
1687                 supported = BIT_GET ( &features, Port0_Link_Speed_Supported );
1688                 break;
1689         case 1 :
1690                 supported = BIT_GET ( &features, Port1_Link_Speed_Supported );
1691                 break;
1692         default:
1693                 DBGC ( qib7322, "QIB7322 %p port %d is invalid\n",
1694                        qib7322, port );
1695                 supported = 0;
1696                 break;
1697         }
1698
1699         /* Apply hacks for specific board IDs */
1700         qib7322_readq ( qib7322, &revision, QIB_7322_Revision_offset );
1701         boardid = BIT_GET ( &revision, BoardID );
1702         switch ( boardid ) {
1703         case QIB7322_BOARD_QMH7342 :
1704                 DBGC2 ( qib7322, "QIB7322 %p is a QMH7342; forcing QDR-only\n",
1705                         qib7322 );
1706                 supported = IB_LINK_SPEED_QDR;
1707                 break;
1708         default:
1709                 /* Do nothing */
1710                 break;
1711         }
1712
1713         DBGC2 ( qib7322, "QIB7322 %p port %d %s%s%s%s\n", qib7322, port,
1714                 ( supported ? "supports" : "disabled" ),
1715                 ( ( supported & IB_LINK_SPEED_SDR ) ? " SDR" : "" ),
1716                 ( ( supported & IB_LINK_SPEED_DDR ) ? " DDR" : "" ),
1717                 ( ( supported & IB_LINK_SPEED_QDR ) ? " QDR" : "" ) );
1718         return supported;
1719 }
1720
1721 /**
1722  * Initialise Infiniband link
1723  *
1724  * @v ibdev             Infiniband device
1725  * @ret rc              Return status code
1726  */
1727 static int qib7322_open ( struct ib_device *ibdev ) {
1728         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1729         struct QIB_7322_IBCCtrlA_0 ibcctrla;
1730         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1731
1732         /* Enable link */
1733         qib7322_readq_port ( qib7322, &ibcctrla,
1734                              QIB_7322_IBCCtrlA_0_offset, port );
1735         BIT_SET ( &ibcctrla, IBLinkEn, 1 );
1736         qib7322_writeq_port ( qib7322, &ibcctrla,
1737                               QIB_7322_IBCCtrlA_0_offset, port );
1738
1739         return 0;
1740 }
1741
1742 /**
1743  * Close Infiniband link
1744  *
1745  * @v ibdev             Infiniband device
1746  */
1747 static void qib7322_close ( struct ib_device *ibdev ) {
1748         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1749         struct QIB_7322_IBCCtrlA_0 ibcctrla;
1750         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1751
1752         /* Disable link */
1753         qib7322_readq_port ( qib7322, &ibcctrla,
1754                              QIB_7322_IBCCtrlA_0_offset, port );
1755         BIT_SET ( &ibcctrla, IBLinkEn, 0 );
1756         qib7322_writeq_port ( qib7322, &ibcctrla,
1757                               QIB_7322_IBCCtrlA_0_offset, port );
1758 }
1759
1760 /***************************************************************************
1761  *
1762  * Multicast group operations
1763  *
1764  ***************************************************************************
1765  */
1766
1767 /**
1768  * Attach to multicast group
1769  *
1770  * @v ibdev             Infiniband device
1771  * @v qp                Queue pair
1772  * @v gid               Multicast GID
1773  * @ret rc              Return status code
1774  */
1775 static int qib7322_mcast_attach ( struct ib_device *ibdev,
1776                                   struct ib_queue_pair *qp,
1777                                   union ib_gid *gid ) {
1778         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1779
1780         ( void ) qib7322;
1781         ( void ) qp;
1782         ( void ) gid;
1783         return 0;
1784 }
1785
1786 /**
1787  * Detach from multicast group
1788  *
1789  * @v ibdev             Infiniband device
1790  * @v qp                Queue pair
1791  * @v gid               Multicast GID
1792  */
1793 static void qib7322_mcast_detach ( struct ib_device *ibdev,
1794                                    struct ib_queue_pair *qp,
1795                                    union ib_gid *gid ) {
1796         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1797
1798         ( void ) qib7322;
1799         ( void ) qp;
1800         ( void ) gid;
1801  }
1802
1803 /** QIB7322 Infiniband operations */
1804 static struct ib_device_operations qib7322_ib_operations = {
1805         .create_cq      = qib7322_create_cq,
1806         .destroy_cq     = qib7322_destroy_cq,
1807         .create_qp      = qib7322_create_qp,
1808         .modify_qp      = qib7322_modify_qp,
1809         .destroy_qp     = qib7322_destroy_qp,
1810         .post_send      = qib7322_post_send,
1811         .post_recv      = qib7322_post_recv,
1812         .poll_cq        = qib7322_poll_cq,
1813         .poll_eq        = qib7322_poll_eq,
1814         .open           = qib7322_open,
1815         .close          = qib7322_close,
1816         .mcast_attach   = qib7322_mcast_attach,
1817         .mcast_detach   = qib7322_mcast_detach,
1818         .set_port_info  = qib7322_set_port_info,
1819         .set_pkey_table = qib7322_set_pkey_table,
1820 };
1821
1822 /***************************************************************************
1823  *
1824  * I2C bus operations
1825  *
1826  ***************************************************************************
1827  */
1828
1829 /** QIB7322 I2C bit to GPIO mappings */
1830 static unsigned int qib7322_i2c_bits[] = {
1831         [I2C_BIT_SCL] = ( 1 << QIB7322_GPIO_SCL ),
1832         [I2C_BIT_SDA] = ( 1 << QIB7322_GPIO_SDA ),
1833 };
1834
1835 /**
1836  * Read QIB7322 I2C line status
1837  *
1838  * @v basher            Bit-bashing interface
1839  * @v bit_id            Bit number
1840  * @ret zero            Input is a logic 0
1841  * @ret non-zero        Input is a logic 1
1842  */
1843 static int qib7322_i2c_read_bit ( struct bit_basher *basher,
1844                                   unsigned int bit_id ) {
1845         struct qib7322 *qib7322 =
1846                 container_of ( basher, struct qib7322, i2c.basher );
1847         struct QIB_7322_EXTStatus extstatus;
1848         unsigned int status;
1849
1850         DBG_DISABLE ( DBGLVL_IO );
1851
1852         qib7322_readq ( qib7322, &extstatus, QIB_7322_EXTStatus_offset );
1853         status = ( BIT_GET ( &extstatus, GPIOIn ) & qib7322_i2c_bits[bit_id] );
1854
1855         DBG_ENABLE ( DBGLVL_IO );
1856
1857         return status;
1858 }
1859
1860 /**
1861  * Write QIB7322 I2C line status
1862  *
1863  * @v basher            Bit-bashing interface
1864  * @v bit_id            Bit number
1865  * @v data              Value to write
1866  */
1867 static void qib7322_i2c_write_bit ( struct bit_basher *basher,
1868                                     unsigned int bit_id, unsigned long data ) {
1869         struct qib7322 *qib7322 =
1870                 container_of ( basher, struct qib7322, i2c.basher );
1871         struct QIB_7322_EXTCtrl extctrl;
1872         struct QIB_7322_GPIO gpioout;
1873         unsigned int bit = qib7322_i2c_bits[bit_id];
1874         unsigned int outputs = 0;
1875         unsigned int output_enables = 0;
1876
1877         DBG_DISABLE ( DBGLVL_IO );
1878
1879         /* Read current GPIO mask and outputs */
1880         qib7322_readq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
1881         qib7322_readq ( qib7322, &gpioout, QIB_7322_GPIOOut_offset );
1882
1883         /* Update outputs and output enables.  I2C lines are tied
1884          * high, so we always set the output to 0 and use the output
1885          * enable to control the line.
1886          */
1887         output_enables = BIT_GET ( &extctrl, GPIOOe );
1888         output_enables = ( ( output_enables & ~bit ) | ( ~data & bit ) );
1889         outputs = BIT_GET ( &gpioout, GPIO );
1890         outputs = ( outputs & ~bit );
1891         BIT_SET ( &extctrl, GPIOOe, output_enables );
1892         BIT_SET ( &gpioout, GPIO, outputs );
1893
1894         /* Write the output enable first; that way we avoid logic
1895          * hazards.
1896          */
1897         qib7322_writeq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
1898         qib7322_writeq ( qib7322, &gpioout, QIB_7322_GPIOOut_offset );
1899         mb();
1900
1901         DBG_ENABLE ( DBGLVL_IO );
1902 }
1903
1904 /** QIB7322 I2C bit-bashing interface operations */
1905 static struct bit_basher_operations qib7322_i2c_basher_ops = {
1906         .read   = qib7322_i2c_read_bit,
1907         .write  = qib7322_i2c_write_bit,
1908 };
1909
1910 /**
1911  * Initialise QIB7322 I2C subsystem
1912  *
1913  * @v qib7322           QIB7322 device
1914  * @ret rc              Return status code
1915  */
1916 static int qib7322_init_i2c ( struct qib7322 *qib7322 ) {
1917         static int try_eeprom_address[] = { 0x51, 0x50 };
1918         unsigned int i;
1919         int rc;
1920
1921         /* Initialise bus */
1922         if ( ( rc = init_i2c_bit_basher ( &qib7322->i2c,
1923                                           &qib7322_i2c_basher_ops ) ) != 0 ) {
1924                 DBGC ( qib7322, "QIB7322 %p could not initialise I2C bus: %s\n",
1925                        qib7322, strerror ( rc ) );
1926                 return rc;
1927         }
1928
1929         /* Probe for devices */
1930         for ( i = 0 ; i < ( sizeof ( try_eeprom_address ) /
1931                             sizeof ( try_eeprom_address[0] ) ) ; i++ ) {
1932                 init_i2c_eeprom ( &qib7322->eeprom, try_eeprom_address[i] );
1933                 if ( ( rc = i2c_check_presence ( &qib7322->i2c.i2c,
1934                                                  &qib7322->eeprom ) ) == 0 ) {
1935                         DBGC2 ( qib7322, "QIB7322 %p found EEPROM at %02x\n",
1936                                 qib7322, try_eeprom_address[i] );
1937                         return 0;
1938                 }
1939         }
1940
1941         DBGC ( qib7322, "QIB7322 %p could not find EEPROM\n", qib7322 );
1942         return -ENODEV;
1943 }
1944
1945 /**
1946  * Read EEPROM parameters
1947  *
1948  * @v qib7322           QIB7322 device
1949  * @ret rc              Return status code
1950  */
1951 static int qib7322_read_eeprom ( struct qib7322 *qib7322 ) {
1952         struct i2c_interface *i2c = &qib7322->i2c.i2c;
1953         union ib_guid *guid = &qib7322->guid;
1954         int rc;
1955
1956         /* Read GUID */
1957         if ( ( rc = i2c->read ( i2c, &qib7322->eeprom,
1958                                 QIB7322_EEPROM_GUID_OFFSET, guid->bytes,
1959                                 sizeof ( *guid ) ) ) != 0 ) {
1960                 DBGC ( qib7322, "QIB7322 %p could not read GUID: %s\n",
1961                        qib7322, strerror ( rc ) );
1962                 return rc;
1963         }
1964         DBGC2 ( qib7322, "QIB7322 %p has GUID " IB_GUID_FMT "\n",
1965                 qib7322, IB_GUID_ARGS ( guid ) );
1966
1967         /* Read serial number (debug only) */
1968         if ( DBG_LOG ) {
1969                 uint8_t serial[QIB7322_EEPROM_SERIAL_SIZE + 1];
1970
1971                 serial[ sizeof ( serial ) - 1 ] = '\0';
1972                 if ( ( rc = i2c->read ( i2c, &qib7322->eeprom,
1973                                         QIB7322_EEPROM_SERIAL_OFFSET, serial,
1974                                         ( sizeof ( serial ) - 1 ) ) ) != 0 ) {
1975                         DBGC ( qib7322, "QIB7322 %p could not read serial: "
1976                                "%s\n", qib7322, strerror ( rc ) );
1977                         return rc;
1978                 }
1979                 DBGC2 ( qib7322, "QIB7322 %p has serial number \"%s\"\n",
1980                         qib7322, serial );
1981         }
1982
1983         return 0;
1984 }
1985
1986 /***************************************************************************
1987  *
1988  * Advanced High-performance Bus (AHB) access
1989  *
1990  ***************************************************************************
1991  */
1992
1993 /**
1994  * Wait for AHB transaction to complete
1995  *
1996  * @v qib7322           QIB7322 device
1997  * @ret rc              Return status code
1998  */
1999 static int qib7322_ahb_wait ( struct qib7322 *qib7322 ) {
2000         struct QIB_7322_ahb_transaction_reg transaction;
2001         unsigned int i;
2002
2003         /* Wait for Ready bit to be asserted */
2004         for ( i = 0 ; i < QIB7322_AHB_MAX_WAIT_US ; i++ ) {
2005                 qib7322_readq ( qib7322, &transaction,
2006                                 QIB_7322_ahb_transaction_reg_offset );
2007                 if ( BIT_GET ( &transaction, ahb_rdy ) )
2008                         return 0;
2009                 udelay ( 1 );
2010         }
2011
2012         DBGC ( qib7322, "QIB7322 %p timed out waiting for AHB transaction\n",
2013                qib7322 );
2014         return -ETIMEDOUT;
2015 }
2016
2017 /**
2018  * Request ownership of the AHB
2019  *
2020  * @v qib7322           QIB7322 device
2021  * @v location          AHB location
2022  * @ret rc              Return status code
2023  */
2024 static int qib7322_ahb_request ( struct qib7322 *qib7322,
2025                                  unsigned int location ) {
2026         struct QIB_7322_ahb_access_ctrl access;
2027         int rc;
2028
2029         /* Request ownership */
2030         memset ( &access, 0, sizeof ( access ) );
2031         BIT_FILL_2 ( &access,
2032                      sw_ahb_sel, 1,
2033                      sw_sel_ahb_trgt, QIB7322_AHB_LOC_TARGET ( location ) );
2034         qib7322_writeq ( qib7322, &access, QIB_7322_ahb_access_ctrl_offset );
2035
2036         /* Wait for ownership to be granted */
2037         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )  {
2038                 DBGC ( qib7322, "QIB7322 %p could not obtain AHB ownership: "
2039                        "%s\n", qib7322, strerror ( rc ) );
2040                 return rc;
2041         }
2042
2043         return 0;
2044 }
2045
2046 /**
2047  * Release ownership of the AHB
2048  *
2049  * @v qib7322           QIB7322 device
2050  */
2051 static void qib7322_ahb_release ( struct qib7322 *qib7322 ) {
2052         struct QIB_7322_ahb_access_ctrl access;
2053
2054         memset ( &access, 0, sizeof ( access ) );
2055         qib7322_writeq ( qib7322, &access, QIB_7322_ahb_access_ctrl_offset );
2056 }
2057
2058 /**
2059  * Read data via AHB
2060  *
2061  * @v qib7322           QIB7322 device
2062  * @v location          AHB location
2063  * @v data              Data to read
2064  * @ret rc              Return status code
2065  *
2066  * You must have already acquired ownership of the AHB.
2067  */
2068 static int qib7322_ahb_read ( struct qib7322 *qib7322, unsigned int location,
2069                               uint32_t *data ) {
2070         struct QIB_7322_ahb_transaction_reg xact;
2071         int rc;
2072
2073         /* Avoid returning uninitialised data on error */
2074         *data = 0;
2075
2076         /* Initiate transaction */
2077         memset ( &xact, 0, sizeof ( xact ) );
2078         BIT_FILL_2 ( &xact,
2079                      ahb_address, QIB7322_AHB_LOC_ADDRESS ( location ),
2080                      write_not_read, 0 );
2081         qib7322_writeq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2082
2083         /* Wait for transaction to complete */
2084         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )
2085                 return rc;
2086
2087         /* Read transaction data */
2088         qib7322_readq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2089         *data = BIT_GET ( &xact, ahb_data );
2090         return 0;
2091 }
2092
2093 /**
2094  * Write data via AHB
2095  *
2096  * @v qib7322           QIB7322 device
2097  * @v location          AHB location
2098  * @v data              Data to write
2099  * @ret rc              Return status code
2100  *
2101  * You must have already acquired ownership of the AHB.
2102  */
2103 static int qib7322_ahb_write ( struct qib7322 *qib7322, unsigned int location,
2104                                uint32_t data ) {
2105         struct QIB_7322_ahb_transaction_reg xact;
2106         int rc;
2107
2108         /* Initiate transaction */
2109         memset ( &xact, 0, sizeof ( xact ) );
2110         BIT_FILL_3 ( &xact,
2111                      ahb_address, QIB7322_AHB_LOC_ADDRESS ( location ),
2112                      write_not_read, 1,
2113                      ahb_data, data );
2114         qib7322_writeq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2115
2116         /* Wait for transaction to complete */
2117         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )
2118                 return rc;
2119
2120         return 0;
2121 }
2122
2123 /**
2124  * Read/modify/write AHB register
2125  *
2126  * @v qib7322           QIB7322 device
2127  * @v location          AHB location
2128  * @v value             Value to set
2129  * @v mask              Mask to apply to old value
2130  * @ret rc              Return status code
2131  */
2132 static int qib7322_ahb_mod_reg ( struct qib7322 *qib7322, unsigned int location,
2133                                  uint32_t value, uint32_t mask ) {
2134         uint32_t old_value;
2135         uint32_t new_value;
2136         int rc;
2137
2138         DBG_DISABLE ( DBGLVL_IO );
2139
2140         /* Sanity check */
2141         assert ( ( value & mask ) == value );
2142
2143         /* Acquire bus ownership */
2144         if ( ( rc = qib7322_ahb_request ( qib7322, location ) ) != 0 )
2145                 goto out;
2146
2147         /* Read existing value */
2148         if ( ( rc = qib7322_ahb_read ( qib7322, location, &old_value ) ) != 0 )
2149                 goto out_release;
2150
2151         /* Update value */
2152         new_value = ( ( old_value & ~mask ) | value );
2153         DBGCP ( qib7322, "QIB7322 %p AHB %x %#08x => %#08x\n",
2154                 qib7322, location, old_value, new_value );
2155         if ( ( rc = qib7322_ahb_write ( qib7322, location, new_value ) ) != 0 )
2156                 goto out_release;
2157
2158  out_release:
2159         /* Release bus */
2160         qib7322_ahb_release ( qib7322 );
2161  out:
2162         DBG_ENABLE ( DBGLVL_IO );
2163         return rc;
2164 }
2165
2166 /**
2167  * Read/modify/write AHB register across all ports and channels
2168  *
2169  * @v qib7322           QIB7322 device
2170  * @v reg               AHB register
2171  * @v value             Value to set
2172  * @v mask              Mask to apply to old value
2173  * @ret rc              Return status code
2174  */
2175 static int qib7322_ahb_mod_reg_all ( struct qib7322 *qib7322, unsigned int reg,
2176                                      uint32_t value, uint32_t mask ) {
2177         unsigned int port;
2178         unsigned int channel;
2179         unsigned int location;
2180         int rc;
2181
2182         for ( port = 0 ; port < QIB7322_MAX_PORTS ; port++ ) {
2183                 for ( channel = 0 ; channel < QIB7322_MAX_WIDTH ; channel++ ) {
2184                         location = QIB7322_AHB_LOCATION ( port, channel, reg );
2185                         if ( ( rc = qib7322_ahb_mod_reg ( qib7322, location,
2186                                                           value, mask ) ) != 0 )
2187                                 return rc;
2188                 }
2189         }
2190         return 0;
2191 }
2192
2193 /***************************************************************************
2194  *
2195  * Infiniband SerDes initialisation
2196  *
2197  ***************************************************************************
2198  */
2199
2200 /**
2201  * Initialise the IB SerDes
2202  *
2203  * @v qib7322           QIB7322 device
2204  * @ret rc              Return status code
2205  */
2206 static int qib7322_init_ib_serdes ( struct qib7322 *qib7322 ) {
2207         struct QIB_7322_IBCCtrlA_0 ibcctrla;
2208         struct QIB_7322_IBCCtrlB_0 ibcctrlb;
2209         struct QIB_7322_IBPCSConfig_0 ibpcsconfig;
2210
2211         /* Configure sensible defaults for IBC */
2212         memset ( &ibcctrla, 0, sizeof ( ibcctrla ) );
2213         BIT_FILL_5 ( &ibcctrla, /* Tuning values taken from Linux driver */
2214                      FlowCtrlPeriod, 0x03,
2215                      FlowCtrlWaterMark, 0x05,
2216                      MaxPktLen, ( ( QIB7322_RECV_HEADER_SIZE +
2217                                     QIB7322_RECV_PAYLOAD_SIZE +
2218                                     4 /* ICRC */ ) >> 2 ),
2219                      PhyerrThreshold, 0xf,
2220                      OverrunThreshold, 0xf );
2221         qib7322_writeq ( qib7322, &ibcctrla, QIB_7322_IBCCtrlA_0_offset );
2222         qib7322_writeq ( qib7322, &ibcctrla, QIB_7322_IBCCtrlA_1_offset );
2223
2224         /* Force SDR only to avoid needing all the DDR tuning,
2225          * Mellanox compatibility hacks etc.  SDR is plenty for
2226          * boot-time operation.
2227          */
2228         qib7322_readq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_0_offset );
2229         BIT_SET ( &ibcctrlb, IB_ENHANCED_MODE, 0 );
2230         BIT_SET ( &ibcctrlb, SD_SPEED_SDR, 1 );
2231         BIT_SET ( &ibcctrlb, SD_SPEED_DDR, 0 );
2232         BIT_SET ( &ibcctrlb, SD_SPEED_QDR, 0 );
2233         BIT_SET ( &ibcctrlb, IB_NUM_CHANNELS, 1 ); /* 4X only */
2234         BIT_SET ( &ibcctrlb, IB_LANE_REV_SUPPORTED, 0 );
2235         BIT_SET ( &ibcctrlb, HRTBT_ENB, 0 );
2236         BIT_SET ( &ibcctrlb, HRTBT_AUTO, 0 );
2237         qib7322_writeq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_0_offset );
2238         qib7322_writeq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_1_offset );
2239
2240         /* Tune SerDes */
2241         qib7322_ahb_mod_reg_all ( qib7322, 2, 0, 0x00000e00UL );
2242
2243         /* Bring XGXS out of reset */
2244         memset ( &ibpcsconfig, 0, sizeof ( ibpcsconfig ) );
2245         qib7322_writeq ( qib7322, &ibpcsconfig, QIB_7322_IBPCSConfig_0_offset );
2246         qib7322_writeq ( qib7322, &ibpcsconfig, QIB_7322_IBPCSConfig_1_offset );
2247
2248         return 0;
2249 }
2250
2251 /***************************************************************************
2252  *
2253  * PCI layer interface
2254  *
2255  ***************************************************************************
2256  */
2257
2258 /**
2259  * Reset QIB7322
2260  *
2261  * @v qib7322           QIB7322 device
2262  * @v pci               PCI device
2263  * @ret rc              Return status code
2264  */
2265 static void qib7322_reset ( struct qib7322 *qib7322, struct pci_device *pci ) {
2266         struct QIB_7322_Control control;
2267         struct pci_config_backup backup;
2268
2269         /* Back up PCI configuration space */
2270         pci_backup ( pci, &backup, NULL );
2271
2272         /* Assert reset */
2273         memset ( &control, 0, sizeof ( control ) );
2274         BIT_FILL_1 ( &control, SyncReset, 1 );
2275         qib7322_writeq ( qib7322, &control, QIB_7322_Control_offset );
2276
2277         /* Wait for reset to complete */
2278         mdelay ( 1000 );
2279
2280         /* Restore PCI configuration space */
2281         pci_restore ( pci, &backup, NULL );
2282 }
2283
2284 /**
2285  * Probe PCI device
2286  *
2287  * @v pci               PCI device
2288  * @v id                PCI ID
2289  * @ret rc              Return status code
2290  */
2291 static int qib7322_probe ( struct pci_device *pci ) {
2292         struct qib7322 *qib7322;
2293         struct QIB_7322_Revision revision;
2294         struct ib_device *ibdev;
2295         unsigned int link_speed_supported;
2296         int i;
2297         int rc;
2298
2299         /* Allocate QIB7322 device */
2300         qib7322 = zalloc ( sizeof ( *qib7322 ) );
2301         if ( ! qib7322 ) {
2302                 rc = -ENOMEM;
2303                 goto err_alloc_qib7322;
2304         }
2305         pci_set_drvdata ( pci, qib7322 );
2306
2307         /* Fix up PCI device */
2308         adjust_pci_device ( pci );
2309
2310         /* Get PCI BARs */
2311         qib7322->regs = ioremap ( pci->membase, QIB7322_BAR0_SIZE );
2312         DBGC2 ( qib7322, "QIB7322 %p has BAR at %08lx\n",
2313                 qib7322, pci->membase );
2314
2315         /* Reset device */
2316         qib7322_reset ( qib7322, pci );
2317
2318         /* Print some general data */
2319         qib7322_readq ( qib7322, &revision, QIB_7322_Revision_offset );
2320         DBGC2 ( qib7322, "QIB7322 %p board %02lx v%ld.%ld.%ld.%ld\n", qib7322,
2321                 BIT_GET ( &revision, BoardID ),
2322                 BIT_GET ( &revision, R_SW ),
2323                 BIT_GET ( &revision, R_Arch ),
2324                 BIT_GET ( &revision, R_ChipRevMajor ),
2325                 BIT_GET ( &revision, R_ChipRevMinor ) );
2326
2327         /* Initialise I2C subsystem */
2328         if ( ( rc = qib7322_init_i2c ( qib7322 ) ) != 0 )
2329                 goto err_init_i2c;
2330
2331         /* Read EEPROM parameters */
2332         if ( ( rc = qib7322_read_eeprom ( qib7322 ) ) != 0 )
2333                 goto err_read_eeprom;
2334
2335         /* Initialise send datapath */
2336         if ( ( rc = qib7322_init_send ( qib7322 ) ) != 0 )
2337                 goto err_init_send;
2338
2339         /* Initialise receive datapath */
2340         if ( ( rc = qib7322_init_recv ( qib7322 ) ) != 0 )
2341                 goto err_init_recv;
2342
2343         /* Initialise the IB SerDes */
2344         if ( ( rc = qib7322_init_ib_serdes ( qib7322 ) ) != 0 )
2345                 goto err_init_ib_serdes;
2346
2347         /* Allocate Infiniband devices */
2348         for ( i = 0 ; i < QIB7322_MAX_PORTS ; i++ ) {
2349                 link_speed_supported =
2350                         qib7322_link_speed_supported ( qib7322, i );
2351                 if ( ! link_speed_supported )
2352                         continue;
2353                 ibdev = alloc_ibdev ( 0 );
2354                 if ( ! ibdev ) {
2355                         rc = -ENOMEM;
2356                         goto err_alloc_ibdev;
2357                 }
2358                 qib7322->ibdev[i] = ibdev;
2359                 ibdev->dev = &pci->dev;
2360                 ibdev->op = &qib7322_ib_operations;
2361                 ibdev->port = ( QIB7322_PORT_BASE + i );
2362                 ibdev->link_width_enabled = ibdev->link_width_supported =
2363                         IB_LINK_WIDTH_4X; /* 1x does not work */
2364                 ibdev->link_speed_enabled = ibdev->link_speed_supported =
2365                         IB_LINK_SPEED_SDR; /* to avoid need for link tuning */
2366                 memcpy ( &ibdev->node_guid, &qib7322->guid,
2367                          sizeof ( ibdev->node_guid ) );
2368                 memcpy ( &ibdev->gid.s.guid, &qib7322->guid,
2369                          sizeof ( ibdev->gid.s.guid ) );
2370                 assert ( ( ibdev->gid.s.guid.bytes[7] & i ) == 0 );
2371                 ibdev->gid.s.guid.bytes[7] |= i;
2372                 ib_set_drvdata ( ibdev, qib7322 );
2373         }
2374
2375         /* Register Infiniband devices */
2376         for ( i = 0 ; i < QIB7322_MAX_PORTS ; i++ ) {
2377                 if ( ! qib7322->ibdev[i] )
2378                         continue;
2379                 if ( ( rc = register_ibdev ( qib7322->ibdev[i] ) ) != 0 ) {
2380                         DBGC ( qib7322, "QIB7322 %p port %d could not register "
2381                                "IB device: %s\n", qib7322, i, strerror ( rc ) );
2382                         goto err_register_ibdev;
2383                 }
2384         }
2385
2386         return 0;
2387
2388         i = QIB7322_MAX_PORTS;
2389  err_register_ibdev:
2390         for ( i-- ; i >= 0 ; i-- ) {
2391                 if ( qib7322->ibdev[i] )
2392                         unregister_ibdev ( qib7322->ibdev[i] );
2393         }
2394         i = QIB7322_MAX_PORTS;
2395  err_alloc_ibdev:
2396         for ( i-- ; i >= 0 ; i-- )
2397                 ibdev_put ( qib7322->ibdev[i] );
2398  err_init_ib_serdes:
2399         qib7322_fini_send ( qib7322 );
2400  err_init_send:
2401         qib7322_fini_recv ( qib7322 );
2402  err_init_recv:
2403  err_read_eeprom:
2404  err_init_i2c:
2405         free ( qib7322 );
2406  err_alloc_qib7322:
2407         return rc;
2408 }
2409
2410 /**
2411  * Remove PCI device
2412  *
2413  * @v pci               PCI device
2414  */
2415 static void qib7322_remove ( struct pci_device *pci ) {
2416         struct qib7322 *qib7322 = pci_get_drvdata ( pci );
2417         int i;
2418
2419         for ( i = ( QIB7322_MAX_PORTS - 1 ) ; i >= 0 ; i-- ) {
2420                 if ( qib7322->ibdev[i] )
2421                         unregister_ibdev ( qib7322->ibdev[i] );
2422         }
2423         for ( i = ( QIB7322_MAX_PORTS - 1 ) ; i >= 0 ; i-- )
2424                 ibdev_put ( qib7322->ibdev[i] );
2425         qib7322_fini_send ( qib7322 );
2426         qib7322_fini_recv ( qib7322 );
2427         free ( qib7322 );
2428 }
2429
2430 static struct pci_device_id qib7322_nics[] = {
2431         PCI_ROM ( 0x1077, 0x7322, "iba7322", "IBA7322 QDR InfiniBand HCA", 0 ),
2432 };
2433
2434 struct pci_driver qib7322_driver __pci_driver = {
2435         .ids = qib7322_nics,
2436         .id_count = ( sizeof ( qib7322_nics ) / sizeof ( qib7322_nics[0] ) ),
2437         .probe = qib7322_probe,
2438         .remove = qib7322_remove,
2439 };