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