[qib7322] Add support for QLogic 7322 HCA
[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                 goto err_create_send_bufs_small;
662         qib7322->send_bufs_vl15_port0 =
663                 qib7322_create_send_bufs ( qib7322, baseaddr_vl15_port0,
664                                           QIB7322_VL15_PORT0_SEND_BUF_SIZE,
665                                           QIB7322_VL15_PORT0_SEND_BUF_START,
666                                           QIB7322_VL15_PORT0_SEND_BUF_COUNT );
667         if ( ! qib7322->send_bufs_vl15_port0 )
668                 goto err_create_send_bufs_vl15_port0;
669         qib7322->send_bufs_vl15_port1 =
670                 qib7322_create_send_bufs ( qib7322, baseaddr_vl15_port1,
671                                           QIB7322_VL15_PORT1_SEND_BUF_SIZE,
672                                           QIB7322_VL15_PORT1_SEND_BUF_START,
673                                           QIB7322_VL15_PORT1_SEND_BUF_COUNT );
674         if ( ! qib7322->send_bufs_vl15_port1 )
675                 goto err_create_send_bufs_vl15_port1;
676
677         /* Allocate space for the SendBufAvail array */
678         qib7322->sendbufavail = malloc_dma ( sizeof ( *qib7322->sendbufavail ),
679                                             QIB7322_SENDBUFAVAIL_ALIGN );
680         if ( ! qib7322->sendbufavail ) {
681                 rc = -ENOMEM;
682                 goto err_alloc_sendbufavail;
683         }
684         memset ( qib7322->sendbufavail, 0, sizeof ( qib7322->sendbufavail ) );
685
686         /* Program SendBufAvailAddr into the hardware */
687         memset ( &sendbufavailaddr, 0, sizeof ( sendbufavailaddr ) );
688         BIT_FILL_1 ( &sendbufavailaddr, SendBufAvailAddr,
689                      ( virt_to_bus ( qib7322->sendbufavail ) >> 6 ) );
690         qib7322_writeq ( qib7322, &sendbufavailaddr,
691                         QIB_7322_SendBufAvailAddr_offset );
692
693         /* Enable sending */
694         memset ( &sendctrlp, 0, sizeof ( sendctrlp ) );
695         BIT_FILL_1 ( &sendctrlp, SendEnable, 1 );
696         qib7322_writeq ( qib7322, &sendctrlp, QIB_7322_SendCtrl_0_offset );
697         qib7322_writeq ( qib7322, &sendctrlp, QIB_7322_SendCtrl_1_offset );
698
699         /* Enable DMA of SendBufAvail */
700         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
701         BIT_FILL_1 ( &sendctrl, SendBufAvailUpd, 1 );
702         qib7322_writeq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
703
704         return 0;
705
706         free_dma ( qib7322->sendbufavail, sizeof ( *qib7322->sendbufavail ) );
707  err_alloc_sendbufavail:
708         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port1 );
709  err_create_send_bufs_vl15_port1:
710         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port0 );
711  err_create_send_bufs_vl15_port0:
712         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_small );
713  err_create_send_bufs_small:
714         return rc;
715 }
716
717 /**
718  * Shut down send datapath
719  *
720  * @v qib7322           QIB7322 device
721  */
722 static void qib7322_fini_send ( struct qib7322 *qib7322 ) {
723         struct QIB_7322_SendCtrl sendctrl;
724
725         /* Disable sending and DMA of SendBufAvail */
726         memset ( &sendctrl, 0, sizeof ( sendctrl ) );
727         qib7322_writeq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
728         mb();
729
730         /* Ensure hardware has seen this disable */
731         qib7322_readq ( qib7322, &sendctrl, QIB_7322_SendCtrl_offset );
732
733         free_dma ( qib7322->sendbufavail, sizeof ( *qib7322->sendbufavail ) );
734         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port1 );
735         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_vl15_port0 );
736         qib7322_destroy_send_bufs ( qib7322, qib7322->send_bufs_small );
737 }
738
739 /***************************************************************************
740  *
741  * Receive datapath
742  *
743  ***************************************************************************
744  */
745
746 /**
747  * Create receive work queue
748  *
749  * @v ibdev             Infiniband device
750  * @v qp                Queue pair
751  * @ret rc              Return status code
752  */
753 static int qib7322_create_recv_wq ( struct ib_device *ibdev,
754                                    struct ib_queue_pair *qp ) {
755         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
756         struct ib_work_queue *wq = &qp->recv;
757         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
758         struct QIB_7322_RcvHdrAddr0 rcvhdraddr;
759         struct QIB_7322_RcvHdrTailAddr0 rcvhdrtailaddr;
760         struct QIB_7322_RcvHdrHead0 rcvhdrhead;
761         struct QIB_7322_scalar rcvegrindexhead;
762         struct QIB_7322_RcvCtrl rcvctrl;
763         struct QIB_7322_RcvCtrl_P rcvctrlp;
764         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
765         unsigned int ctx = qib7322_ctx ( ibdev, qp );
766         int rc;
767
768         /* Reset context information */
769         memset ( &qib7322_wq->header_prod, 0,
770                  sizeof ( qib7322_wq->header_prod ) );
771         qib7322_wq->header_cons = 0;
772         qib7322_wq->eager_prod = 0;
773         qib7322_wq->eager_cons = 0;
774
775         /* Allocate receive header buffer */
776         qib7322_wq->header = malloc_dma ( QIB7322_RECV_HEADERS_SIZE,
777                                          QIB7322_RECV_HEADERS_ALIGN );
778         if ( ! qib7322_wq->header ) {
779                 rc = -ENOMEM;
780                 goto err_alloc_header;
781         }
782
783         /* Enable context in hardware */
784         memset ( &rcvhdraddr, 0, sizeof ( rcvhdraddr ) );
785         BIT_FILL_1 ( &rcvhdraddr, RcvHdrAddr,
786                      ( virt_to_bus ( qib7322_wq->header ) >> 2 ) );
787         qib7322_writeq_array8b ( qib7322, &rcvhdraddr,
788                                 QIB_7322_RcvHdrAddr0_offset, ctx );
789         memset ( &rcvhdrtailaddr, 0, sizeof ( rcvhdrtailaddr ) );
790         BIT_FILL_1 ( &rcvhdrtailaddr, RcvHdrTailAddr,
791                      ( virt_to_bus ( &qib7322_wq->header_prod ) >> 2 ) );
792         qib7322_writeq_array8b ( qib7322, &rcvhdrtailaddr,
793                                 QIB_7322_RcvHdrTailAddr0_offset, ctx );
794         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
795         BIT_FILL_1 ( &rcvhdrhead, counter, 1 );
796         qib7322_writeq_array64k ( qib7322, &rcvhdrhead,
797                                  QIB_7322_RcvHdrHead0_offset, ctx );
798         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
799         BIT_FILL_1 ( &rcvegrindexhead, Value, 1 );
800         qib7322_writeq_array64k ( qib7322, &rcvegrindexhead,
801                                  QIB_7322_RcvEgrIndexHead0_offset, ctx );
802         qib7322_readq_port ( qib7322, &rcvctrlp,
803                             QIB_7322_RcvCtrl_0_offset, port );
804         BIT_SET ( &rcvctrlp, ContextEnable[ctx], 1 );
805         qib7322_writeq_port ( qib7322, &rcvctrlp,
806                              QIB_7322_RcvCtrl_0_offset, port );
807         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
808         BIT_SET ( &rcvctrl, IntrAvail[ctx], 1 );
809         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
810
811         DBGC ( qib7322, "QIB7322 %p port %d QPN %ld CTX %d hdrs [%lx,%lx) prod "
812                "%lx\n", qib7322, port, qp->qpn, ctx,
813                virt_to_bus ( qib7322_wq->header ),
814                ( virt_to_bus ( qib7322_wq->header )
815                  + QIB7322_RECV_HEADERS_SIZE ),
816                virt_to_bus ( &qib7322_wq->header_prod ) );
817         return 0;
818
819         free_dma ( qib7322_wq->header, QIB7322_RECV_HEADERS_SIZE );
820  err_alloc_header:
821         return rc;
822 }
823
824 /**
825  * Destroy receive work queue
826  *
827  * @v ibdev             Infiniband device
828  * @v qp                Queue pair
829  */
830 static void qib7322_destroy_recv_wq ( struct ib_device *ibdev,
831                                      struct ib_queue_pair *qp ) {
832         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
833         struct ib_work_queue *wq = &qp->recv;
834         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
835         struct QIB_7322_RcvCtrl rcvctrl;
836         struct QIB_7322_RcvCtrl_P rcvctrlp;
837         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
838         unsigned int ctx = qib7322_ctx ( ibdev, qp );
839
840         /* Disable context in hardware */
841         qib7322_readq_port ( qib7322, &rcvctrlp,
842                             QIB_7322_RcvCtrl_0_offset, port );
843         BIT_SET ( &rcvctrlp, ContextEnable[ctx], 0 );
844         qib7322_writeq_port ( qib7322, &rcvctrlp,
845                              QIB_7322_RcvCtrl_0_offset, port );
846         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
847         BIT_SET ( &rcvctrl, IntrAvail[ctx], 0 );
848         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
849
850         /* Make sure the hardware has seen that the context is disabled */
851         qib7322_readq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
852         mb();
853
854         /* Free headers ring */
855         free_dma ( qib7322_wq->header, QIB7322_RECV_HEADERS_SIZE );
856 }
857
858 /**
859  * Initialise receive datapath
860  *
861  * @v qib7322           QIB7322 device
862  * @ret rc              Return status code
863  */
864 static int qib7322_init_recv ( struct qib7322 *qib7322 ) {
865         struct QIB_7322_RcvCtrl rcvctrl;
866         struct QIB_7322_RcvCtrl_0 rcvctrlp;
867         struct QIB_7322_RcvQPMapTableA_0 rcvqpmaptablea0;
868         struct QIB_7322_RcvQPMapTableB_0 rcvqpmaptableb0;
869         struct QIB_7322_RcvQPMapTableA_1 rcvqpmaptablea1;
870         struct QIB_7322_RcvQPMapTableB_1 rcvqpmaptableb1;
871         struct QIB_7322_RcvQPMulticastContext_0 rcvqpmcastctx0;
872         struct QIB_7322_RcvQPMulticastContext_1 rcvqpmcastctx1;
873         struct QIB_7322_scalar rcvegrbase;
874         struct QIB_7322_scalar rcvhdrentsize;
875         struct QIB_7322_scalar rcvhdrcnt;
876         struct QIB_7322_RcvBTHQP_0 rcvbthqp;
877         struct QIB_7322_RxCreditVL0_0 rxcreditvl;
878         unsigned int contextcfg;
879         unsigned long egrbase;
880         unsigned int eager_array_size_kernel;
881         unsigned int eager_array_size_user;
882         unsigned int user_context_mask;
883         unsigned int ctx;
884
885         /* Select configuration based on number of contexts */
886         switch ( QIB7322_NUM_CONTEXTS ) {
887         case 6:
888                 contextcfg = QIB7322_CONTEXTCFG_6CTX;
889                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_6CTX_KERNEL;
890                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_6CTX_USER;
891                 user_context_mask = 0x000f;
892                 break;
893         case 10:
894                 contextcfg = QIB7322_CONTEXTCFG_10CTX;
895                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_10CTX_KERNEL;
896                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_10CTX_USER;
897                 user_context_mask = 0x00ff;
898                 break;
899         case 18:
900                 contextcfg = QIB7322_CONTEXTCFG_18CTX;
901                 eager_array_size_kernel = QIB7322_EAGER_ARRAY_SIZE_18CTX_KERNEL;
902                 eager_array_size_user = QIB7322_EAGER_ARRAY_SIZE_18CTX_USER;
903                 user_context_mask = 0xffff;
904                 break;
905         default:
906                 linker_assert ( 0, invalid_QIB7322_NUM_CONTEXTS );
907                 return -EINVAL;
908         }
909
910         /* Configure number of contexts */
911         memset ( &rcvctrl, 0, sizeof ( rcvctrl ) );
912         BIT_FILL_2 ( &rcvctrl,
913                      TailUpd, 1,
914                      ContextCfg, contextcfg );
915         qib7322_writeq ( qib7322, &rcvctrl, QIB_7322_RcvCtrl_offset );
916
917         /* Map QPNs to contexts */
918         memset ( &rcvctrlp, 0, sizeof ( rcvctrlp ) );
919         BIT_FILL_3 ( &rcvctrlp,
920                      RcvIBPortEnable, 1,
921                      RcvQPMapEnable, 1,
922                      RcvPartitionKeyDisable, 1 );
923         qib7322_writeq ( qib7322, &rcvctrlp, QIB_7322_RcvCtrl_0_offset );
924         qib7322_writeq ( qib7322, &rcvctrlp, QIB_7322_RcvCtrl_1_offset );
925         memset ( &rcvqpmaptablea0, 0, sizeof ( rcvqpmaptablea0 ) );
926         BIT_FILL_6 ( &rcvqpmaptablea0,
927                      RcvQPMapContext0, 0,
928                      RcvQPMapContext1, 2,
929                      RcvQPMapContext2, 4,
930                      RcvQPMapContext3, 6,
931                      RcvQPMapContext4, 8,
932                      RcvQPMapContext5, 10 );
933         qib7322_writeq ( qib7322, &rcvqpmaptablea0,
934                         QIB_7322_RcvQPMapTableA_0_offset );
935         memset ( &rcvqpmaptableb0, 0, sizeof ( rcvqpmaptableb0 ) );
936         BIT_FILL_3 ( &rcvqpmaptableb0,
937                      RcvQPMapContext6, 12,
938                      RcvQPMapContext7, 14,
939                      RcvQPMapContext8, 16 );
940         qib7322_writeq ( qib7322, &rcvqpmaptableb0,
941                         QIB_7322_RcvQPMapTableB_0_offset );
942         memset ( &rcvqpmaptablea1, 0, sizeof ( rcvqpmaptablea1 ) );
943         BIT_FILL_6 ( &rcvqpmaptablea1,
944                      RcvQPMapContext0, 1,
945                      RcvQPMapContext1, 3,
946                      RcvQPMapContext2, 5,
947                      RcvQPMapContext3, 7,
948                      RcvQPMapContext4, 9,
949                      RcvQPMapContext5, 11 );
950         qib7322_writeq ( qib7322, &rcvqpmaptablea1,
951                         QIB_7322_RcvQPMapTableA_1_offset );
952         memset ( &rcvqpmaptableb1, 0, sizeof ( rcvqpmaptableb1 ) );
953         BIT_FILL_3 ( &rcvqpmaptableb1,
954                      RcvQPMapContext6, 13,
955                      RcvQPMapContext7, 15,
956                      RcvQPMapContext8, 17 );
957         qib7322_writeq ( qib7322, &rcvqpmaptableb1,
958                         QIB_7322_RcvQPMapTableB_1_offset );
959
960         /* Map multicast QPNs to contexts */
961         memset ( &rcvqpmcastctx0, 0, sizeof ( rcvqpmcastctx0 ) );
962         BIT_FILL_1 ( &rcvqpmcastctx0, RcvQpMcContext, 0 );
963         qib7322_writeq ( qib7322, &rcvqpmcastctx0,
964                         QIB_7322_RcvQPMulticastContext_0_offset );
965         memset ( &rcvqpmcastctx1, 0, sizeof ( rcvqpmcastctx1 ) );
966         BIT_FILL_1 ( &rcvqpmcastctx1, RcvQpMcContext, 1 );
967         qib7322_writeq ( qib7322, &rcvqpmcastctx1,
968                         QIB_7322_RcvQPMulticastContext_1_offset );
969
970         /* Configure receive header buffer sizes */
971         memset ( &rcvhdrcnt, 0, sizeof ( rcvhdrcnt ) );
972         BIT_FILL_1 ( &rcvhdrcnt, Value, QIB7322_RECV_HEADER_COUNT );
973         qib7322_writeq ( qib7322, &rcvhdrcnt, QIB_7322_RcvHdrCnt_offset );
974         memset ( &rcvhdrentsize, 0, sizeof ( rcvhdrentsize ) );
975         BIT_FILL_1 ( &rcvhdrentsize, Value, ( QIB7322_RECV_HEADER_SIZE >> 2 ) );
976         qib7322_writeq ( qib7322, &rcvhdrentsize,
977                         QIB_7322_RcvHdrEntSize_offset );
978
979         /* Calculate eager array start addresses for each context */
980         qib7322_readq ( qib7322, &rcvegrbase, QIB_7322_RcvEgrBase_offset );
981         egrbase = BIT_GET ( &rcvegrbase, Value );
982         for ( ctx = 0 ; ctx < QIB7322_MAX_PORTS ; ctx++ ) {
983                 qib7322->recv_wq[ctx].eager_array = egrbase;
984                 qib7322->recv_wq[ctx].eager_entries = eager_array_size_kernel;
985                 egrbase += ( eager_array_size_kernel *
986                              sizeof ( struct QIB_7322_RcvEgr ) );
987         }
988         for ( ; ctx < QIB7322_NUM_CONTEXTS ; ctx++ ) {
989                 qib7322->recv_wq[ctx].eager_array = egrbase;
990                 qib7322->recv_wq[ctx].eager_entries = eager_array_size_user;
991                 egrbase += ( eager_array_size_user *
992                              sizeof ( struct QIB_7322_RcvEgr ) );
993         }
994         for ( ctx = 0 ; ctx < QIB7322_NUM_CONTEXTS ; ctx++ ) {
995                 DBGC ( qib7322, "QIB7322 %p CTX %d eager array at %lx (%d "
996                        "entries)\n", qib7322, ctx,
997                        qib7322->recv_wq[ctx].eager_array,
998                        qib7322->recv_wq[ctx].eager_entries );
999         }
1000
1001         /* Set the BTH QP for Infinipath packets to an unused value */
1002         memset ( &rcvbthqp, 0, sizeof ( rcvbthqp ) );
1003         BIT_FILL_1 ( &rcvbthqp, RcvBTHQP, QIB7322_QP_IDETH );
1004         qib7322_writeq ( qib7322, &rcvbthqp, QIB_7322_RcvBTHQP_0_offset );
1005         qib7322_writeq ( qib7322, &rcvbthqp, QIB_7322_RcvBTHQP_1_offset );
1006
1007         /* Assign initial credits */
1008         memset ( &rxcreditvl, 0, sizeof ( rxcreditvl ) );
1009         BIT_FILL_1 ( &rxcreditvl, RxMaxCreditVL, QIB7322_MAX_CREDITS_VL0 );
1010         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1011                                 QIB_7322_RxCreditVL0_0_offset, 0 );
1012         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1013                                 QIB_7322_RxCreditVL0_1_offset, 0 );
1014         BIT_FILL_1 ( &rxcreditvl, RxMaxCreditVL, QIB7322_MAX_CREDITS_VL15 );
1015         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1016                                 QIB_7322_RxCreditVL0_0_offset, 15 );
1017         qib7322_writeq_array8b ( qib7322, &rxcreditvl,
1018                                 QIB_7322_RxCreditVL0_1_offset, 15 );
1019
1020         return 0;
1021 }
1022
1023 /**
1024  * Shut down receive datapath
1025  *
1026  * @v qib7322           QIB7322 device
1027  */
1028 static void qib7322_fini_recv ( struct qib7322 *qib7322 __unused ) {
1029         /* Nothing to do; all contexts were already disabled when the
1030          * queue pairs were destroyed
1031          */
1032 }
1033
1034 /***************************************************************************
1035  *
1036  * Completion queue operations
1037  *
1038  ***************************************************************************
1039  */
1040
1041 /**
1042  * Create completion queue
1043  *
1044  * @v ibdev             Infiniband device
1045  * @v cq                Completion queue
1046  * @ret rc              Return status code
1047  */
1048 static int qib7322_create_cq ( struct ib_device *ibdev,
1049                              struct ib_completion_queue *cq ) {
1050         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1051         static int cqn;
1052
1053         /* The hardware has no concept of completion queues.  We
1054          * simply use the association between CQs and WQs (already
1055          * handled by the IB core) to decide which WQs to poll.
1056          *
1057          * We do set a CQN, just to avoid confusing debug messages
1058          * from the IB core.
1059          */
1060         cq->cqn = ++cqn;
1061         DBGC ( qib7322, "QIB7322 %p CQN %ld created\n", qib7322, cq->cqn );
1062
1063         return 0;
1064 }
1065
1066 /**
1067  * Destroy completion queue
1068  *
1069  * @v ibdev             Infiniband device
1070  * @v cq                Completion queue
1071  */
1072 static void qib7322_destroy_cq ( struct ib_device *ibdev,
1073                                struct ib_completion_queue *cq ) {
1074         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1075
1076         /* Nothing to do */
1077         DBGC ( qib7322, "QIB7322 %p CQN %ld destroyed\n", qib7322, cq->cqn );
1078 }
1079
1080 /***************************************************************************
1081  *
1082  * Queue pair operations
1083  *
1084  ***************************************************************************
1085  */
1086
1087 /**
1088  * Create queue pair
1089  *
1090  * @v ibdev             Infiniband device
1091  * @v qp                Queue pair
1092  * @ret rc              Return status code
1093  */
1094 static int qib7322_create_qp ( struct ib_device *ibdev,
1095                               struct ib_queue_pair *qp ) {
1096         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1097         unsigned int ctx;
1098         int rc;
1099
1100         /* Allocate a context and QPN */
1101         if ( ( rc = qib7322_alloc_ctx ( ibdev, qp ) ) != 0 )
1102                 goto err_alloc_ctx;
1103         ctx = qib7322_ctx ( ibdev, qp );
1104
1105         /* Set work-queue private data pointers */
1106         ib_wq_set_drvdata ( &qp->send, &qib7322->send_wq[ctx] );
1107         ib_wq_set_drvdata ( &qp->recv, &qib7322->recv_wq[ctx] );
1108
1109         /* Create receive work queue */
1110         if ( ( rc = qib7322_create_recv_wq ( ibdev, qp ) ) != 0 )
1111                 goto err_create_recv_wq;
1112
1113         /* Create send work queue */
1114         if ( ( rc = qib7322_create_send_wq ( ibdev, qp ) ) != 0 )
1115                 goto err_create_send_wq;
1116
1117         return 0;
1118
1119         qib7322_destroy_send_wq ( ibdev, qp );
1120  err_create_send_wq:
1121         qib7322_destroy_recv_wq ( ibdev, qp );
1122  err_create_recv_wq:
1123         qib7322_free_ctx ( ibdev, qp );
1124  err_alloc_ctx:
1125         return rc;
1126 }
1127
1128 /**
1129  * Modify queue pair
1130  *
1131  * @v ibdev             Infiniband device
1132  * @v qp                Queue pair
1133  * @ret rc              Return status code
1134  */
1135 static int qib7322_modify_qp ( struct ib_device *ibdev,
1136                               struct ib_queue_pair *qp ) {
1137         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1138
1139         /* Nothing to do; the hardware doesn't have a notion of queue
1140          * keys
1141          */
1142         DBGC2 ( qib7322, "QIB7322 %p QPN %ld modified\n", qib7322, qp->qpn );
1143         return 0;
1144 }
1145
1146 /**
1147  * Destroy queue pair
1148  *
1149  * @v ibdev             Infiniband device
1150  * @v qp                Queue pair
1151  */
1152 static void qib7322_destroy_qp ( struct ib_device *ibdev,
1153                                 struct ib_queue_pair *qp ) {
1154
1155         qib7322_destroy_send_wq ( ibdev, qp );
1156         qib7322_destroy_recv_wq ( ibdev, qp );
1157         qib7322_free_ctx ( ibdev, qp );
1158 }
1159
1160 /***************************************************************************
1161  *
1162  * Work request operations
1163  *
1164  ***************************************************************************
1165  */
1166
1167 /**
1168  * Post send work queue entry
1169  *
1170  * @v ibdev             Infiniband device
1171  * @v qp                Queue pair
1172  * @v av                Address vector
1173  * @v iobuf             I/O buffer
1174  * @ret rc              Return status code
1175  */
1176 static int qib7322_post_send ( struct ib_device *ibdev,
1177                               struct ib_queue_pair *qp,
1178                               struct ib_address_vector *av,
1179                               struct io_buffer *iobuf ) {
1180         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1181         struct ib_work_queue *wq = &qp->send;
1182         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1183         struct QIB_7322_SendPbc sendpbc;
1184         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1185         uint8_t header_buf[IB_MAX_HEADER_SIZE];
1186         struct io_buffer headers;
1187         int send_buf;
1188         unsigned long start_offset;
1189         unsigned long offset;
1190         size_t len;
1191         ssize_t frag_len;
1192         uint32_t *data;
1193
1194         /* Allocate send buffer and calculate offset */
1195         send_buf = qib7322_alloc_send_buf ( qib7322, qib7322_wq->send_bufs );
1196         if ( send_buf < 0 )
1197                 return send_buf;
1198         start_offset = offset =
1199                 qib7322_send_buffer_offset ( qib7322, qib7322_wq->send_bufs,
1200                                             send_buf );
1201
1202         /* Store I/O buffer and send buffer index */
1203         assert ( wq->iobufs[qib7322_wq->prod] == NULL );
1204         wq->iobufs[qib7322_wq->prod] = iobuf;
1205         qib7322_wq->used[qib7322_wq->prod] = send_buf;
1206
1207         /* Construct headers */
1208         iob_populate ( &headers, header_buf, 0, sizeof ( header_buf ) );
1209         iob_reserve ( &headers, sizeof ( header_buf ) );
1210         ib_push ( ibdev, &headers, qp, iob_len ( iobuf ), av );
1211
1212         /* Calculate packet length */
1213         len = ( ( sizeof ( sendpbc ) + iob_len ( &headers ) +
1214                   iob_len ( iobuf ) + 3 ) & ~3 );
1215
1216         /* Construct send per-buffer control word */
1217         memset ( &sendpbc, 0, sizeof ( sendpbc ) );
1218         BIT_FILL_3 ( &sendpbc,
1219                      LengthP1_toibc, ( ( len >> 2 ) - 1 ),
1220                      Port, port,
1221                      VL15, ( ( qp->type == IB_QPT_SMI ) ? 1 : 0 ) );
1222
1223         /* Write SendPbc */
1224         DBG_DISABLE ( DBGLVL_IO );
1225         qib7322_writeq ( qib7322, &sendpbc, offset );
1226         offset += sizeof ( sendpbc );
1227
1228         /* Write headers */
1229         for ( data = headers.data, frag_len = iob_len ( &headers ) ;
1230               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
1231                 qib7322_writel ( qib7322, *data, offset );
1232         }
1233
1234         /* Write data */
1235         for ( data = iobuf->data, frag_len = iob_len ( iobuf ) ;
1236               frag_len > 0 ; data++, offset += 4, frag_len -= 4 ) {
1237                 qib7322_writel ( qib7322, *data, offset );
1238         }
1239         DBG_ENABLE ( DBGLVL_IO );
1240
1241         assert ( ( start_offset + len ) == offset );
1242         DBGC2 ( qib7322, "QIB7322 %p QPN %ld TX %04x(%04x) posted [%lx,%lx)\n",
1243                 qib7322, qp->qpn, send_buf, qib7322_wq->prod,
1244                 start_offset, offset );
1245
1246         /* Increment producer counter */
1247         qib7322_wq->prod = ( ( qib7322_wq->prod + 1 ) & ( wq->num_wqes - 1 ) );
1248
1249         return 0;
1250 }
1251
1252 /**
1253  * Complete send work queue entry
1254  *
1255  * @v ibdev             Infiniband device
1256  * @v qp                Queue pair
1257  * @v wqe_idx           Work queue entry index
1258  */
1259 static void qib7322_complete_send ( struct ib_device *ibdev,
1260                                    struct ib_queue_pair *qp,
1261                                    unsigned int wqe_idx ) {
1262         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1263         struct ib_work_queue *wq = &qp->send;
1264         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1265         struct io_buffer *iobuf;
1266         unsigned int send_buf;
1267
1268         /* Parse completion */
1269         send_buf = qib7322_wq->used[wqe_idx];
1270         DBGC2 ( qib7322, "QIB7322 %p QPN %ld TX %04x(%04x) complete\n",
1271                 qib7322, qp->qpn, send_buf, wqe_idx );
1272
1273         /* Complete work queue entry */
1274         iobuf = wq->iobufs[wqe_idx];
1275         assert ( iobuf != NULL );
1276         ib_complete_send ( ibdev, qp, iobuf, 0 );
1277         wq->iobufs[wqe_idx] = NULL;
1278
1279         /* Free send buffer */
1280         qib7322_free_send_buf ( qib7322, qib7322_wq->send_bufs, send_buf );
1281 }
1282
1283 /**
1284  * Poll send work queue
1285  *
1286  * @v ibdev             Infiniband device
1287  * @v qp                Queue pair
1288  */
1289 static void qib7322_poll_send_wq ( struct ib_device *ibdev,
1290                                   struct ib_queue_pair *qp ) {
1291         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1292         struct ib_work_queue *wq = &qp->send;
1293         struct qib7322_send_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1294         unsigned int send_buf;
1295
1296         /* Look for completions */
1297         while ( wq->fill ) {
1298
1299                 /* Check to see if send buffer has completed */
1300                 send_buf = qib7322_wq->used[qib7322_wq->cons];
1301                 if ( qib7322_send_buf_in_use ( qib7322, send_buf ) )
1302                         break;
1303
1304                 /* Complete this buffer */
1305                 qib7322_complete_send ( ibdev, qp, qib7322_wq->cons );
1306
1307                 /* Increment consumer counter */
1308                 qib7322_wq->cons = ( ( qib7322_wq->cons + 1 ) &
1309                                     ( wq->num_wqes - 1 ) );
1310         }
1311 }
1312
1313 /**
1314  * Post receive work queue entry
1315  *
1316  * @v ibdev             Infiniband device
1317  * @v qp                Queue pair
1318  * @v iobuf             I/O buffer
1319  * @ret rc              Return status code
1320  */
1321 static int qib7322_post_recv ( struct ib_device *ibdev,
1322                               struct ib_queue_pair *qp,
1323                               struct io_buffer *iobuf ) {
1324         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1325         struct ib_work_queue *wq = &qp->recv;
1326         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1327         struct QIB_7322_RcvEgr rcvegr;
1328         struct QIB_7322_scalar rcvegrindexhead;
1329         unsigned int ctx = qib7322_ctx ( ibdev, qp );
1330         physaddr_t addr;
1331         size_t len;
1332         unsigned int wqe_idx;
1333         unsigned int bufsize;
1334
1335         /* Sanity checks */
1336         addr = virt_to_bus ( iobuf->data );
1337         len = iob_tailroom ( iobuf );
1338         if ( addr & ( QIB7322_EAGER_BUFFER_ALIGN - 1 ) ) {
1339                 DBGC ( qib7322, "QIB7322 %p QPN %ld misaligned RX buffer "
1340                        "(%08lx)\n", qib7322, qp->qpn, addr );
1341                 return -EINVAL;
1342         }
1343         if ( len != QIB7322_RECV_PAYLOAD_SIZE ) {
1344                 DBGC ( qib7322, "QIB7322 %p QPN %ld wrong RX buffer size "
1345                        "(%zd)\n", qib7322, qp->qpn, len );
1346                 return -EINVAL;
1347         }
1348
1349         /* Calculate eager producer index and WQE index */
1350         wqe_idx = ( qib7322_wq->eager_prod & ( wq->num_wqes - 1 ) );
1351         assert ( wq->iobufs[wqe_idx] == NULL );
1352
1353         /* Store I/O buffer */
1354         wq->iobufs[wqe_idx] = iobuf;
1355
1356         /* Calculate buffer size */
1357         switch ( QIB7322_RECV_PAYLOAD_SIZE ) {
1358         case 2048:  bufsize = QIB7322_EAGER_BUFFER_2K;  break;
1359         case 4096:  bufsize = QIB7322_EAGER_BUFFER_4K;  break;
1360         case 8192:  bufsize = QIB7322_EAGER_BUFFER_8K;  break;
1361         case 16384: bufsize = QIB7322_EAGER_BUFFER_16K; break;
1362         case 32768: bufsize = QIB7322_EAGER_BUFFER_32K; break;
1363         case 65536: bufsize = QIB7322_EAGER_BUFFER_64K; break;
1364         default:    linker_assert ( 0, invalid_rx_payload_size );
1365                     bufsize = QIB7322_EAGER_BUFFER_NONE;
1366         }
1367
1368         /* Post eager buffer */
1369         memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1370         BIT_FILL_2 ( &rcvegr,
1371                      Addr, ( addr >> 11 ),
1372                      BufSize, bufsize );
1373         qib7322_writeq_array8b ( qib7322, &rcvegr, qib7322_wq->eager_array,
1374                                 qib7322_wq->eager_prod );
1375         DBGC2 ( qib7322, "QIB7322 %p QPN %ld RX egr %04x(%04x) posted "
1376                 "[%lx,%lx)\n", qib7322, qp->qpn, qib7322_wq->eager_prod,
1377                 wqe_idx, addr, ( addr + len ) );
1378
1379         /* Increment producer index */
1380         qib7322_wq->eager_prod = ( ( qib7322_wq->eager_prod + 1 ) &
1381                                  ( qib7322_wq->eager_entries - 1 ) );
1382
1383         /* Update head index */
1384         memset ( &rcvegrindexhead, 0, sizeof ( rcvegrindexhead ) );
1385         BIT_FILL_1 ( &rcvegrindexhead,
1386                      Value, ( ( qib7322_wq->eager_prod + 1 ) &
1387                               ( qib7322_wq->eager_entries - 1 ) ) );
1388         qib7322_writeq_array64k ( qib7322, &rcvegrindexhead,
1389                                 QIB_7322_RcvEgrIndexHead0_offset, ctx );
1390
1391         return 0;
1392 }
1393
1394 /**
1395  * Complete receive work queue entry
1396  *
1397  * @v ibdev             Infiniband device
1398  * @v qp                Queue pair
1399  * @v header_offs       Header offset
1400  */
1401 static void qib7322_complete_recv ( struct ib_device *ibdev,
1402                                    struct ib_queue_pair *qp,
1403                                    unsigned int header_offs ) {
1404         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1405         struct ib_work_queue *wq = &qp->recv;
1406         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1407         struct QIB_7322_RcvHdrFlags *rcvhdrflags;
1408         struct QIB_7322_RcvEgr rcvegr;
1409         struct io_buffer headers;
1410         struct io_buffer *iobuf;
1411         struct ib_queue_pair *intended_qp;
1412         struct ib_address_vector av;
1413         unsigned int rcvtype;
1414         unsigned int pktlen;
1415         unsigned int egrindex;
1416         unsigned int useegrbfr;
1417         unsigned int iberr, mkerr, tiderr, khdrerr, mtuerr;
1418         unsigned int lenerr, parityerr, vcrcerr, icrcerr;
1419         unsigned int err;
1420         unsigned int hdrqoffset;
1421         unsigned int header_len;
1422         unsigned int padded_payload_len;
1423         unsigned int wqe_idx;
1424         size_t payload_len;
1425         int qp0;
1426         int rc;
1427
1428         /* RcvHdrFlags are at the end of the header entry */
1429         rcvhdrflags = ( qib7322_wq->header + header_offs +
1430                         QIB7322_RECV_HEADER_SIZE - sizeof ( *rcvhdrflags ) );
1431         rcvtype = BIT_GET ( rcvhdrflags, RcvType );
1432         pktlen = ( BIT_GET ( rcvhdrflags, PktLen ) << 2 );
1433         egrindex = BIT_GET ( rcvhdrflags, EgrIndex );
1434         useegrbfr = BIT_GET ( rcvhdrflags, UseEgrBfr );
1435         hdrqoffset = ( BIT_GET ( rcvhdrflags, HdrqOffset ) << 2 );
1436         iberr = BIT_GET ( rcvhdrflags, IBErr );
1437         mkerr = BIT_GET ( rcvhdrflags, MKErr );
1438         tiderr = BIT_GET ( rcvhdrflags, TIDErr );
1439         khdrerr = BIT_GET ( rcvhdrflags, KHdrErr );
1440         mtuerr = BIT_GET ( rcvhdrflags, MTUErr );
1441         lenerr = BIT_GET ( rcvhdrflags, LenErr );
1442         parityerr = BIT_GET ( rcvhdrflags, ParityErr );
1443         vcrcerr = BIT_GET ( rcvhdrflags, VCRCErr );
1444         icrcerr = BIT_GET ( rcvhdrflags, ICRCErr );
1445         header_len = ( QIB7322_RECV_HEADER_SIZE - hdrqoffset -
1446                        sizeof ( *rcvhdrflags ) );
1447         padded_payload_len = ( pktlen - header_len - 4 /* ICRC */ );
1448         err = ( iberr | mkerr | tiderr | khdrerr | mtuerr |
1449                 lenerr | parityerr | vcrcerr | icrcerr );
1450         /* IB header is placed immediately before RcvHdrFlags */
1451         iob_populate ( &headers, ( ( ( void * ) rcvhdrflags ) - header_len ),
1452                        header_len, header_len );
1453
1454         /* Dump diagnostic information */
1455         DBGC2 ( qib7322, "QIB7322 %p QPN %ld RX egr %04x%s hdr %d type %d len "
1456                 "%d(%d+%d+4)%s%s%s%s%s%s%s%s%s%s%s\n", qib7322, qp->qpn,
1457                 egrindex, ( useegrbfr ? "" : "(unused)" ),
1458                 ( header_offs / QIB7322_RECV_HEADER_SIZE ),
1459                 rcvtype, pktlen, header_len, padded_payload_len,
1460                 ( err ? " [Err" : "" ), ( iberr ? " IB" : "" ),
1461                 ( mkerr ? " MK" : "" ), ( tiderr ? " TID" : "" ),
1462                 ( khdrerr ? " KHdr" : "" ), ( mtuerr ? " MTU" : "" ),
1463                 ( lenerr ? " Len" : "" ), ( parityerr ? " Parity" : ""),
1464                 ( vcrcerr ? " VCRC" : "" ), ( icrcerr ? " ICRC" : "" ),
1465                 ( err ? "]" : "" ) );
1466         DBGCP_HDA ( qib7322, hdrqoffset, headers.data,
1467                     ( header_len + sizeof ( *rcvhdrflags ) ) );
1468
1469         /* Parse header to generate address vector */
1470         qp0 = ( qp->qpn == 0 );
1471         intended_qp = NULL;
1472         if ( ( rc = ib_pull ( ibdev, &headers, ( qp0 ? &intended_qp : NULL ),
1473                               &payload_len, &av ) ) != 0 ) {
1474                 DBGC ( qib7322, "QIB7322 %p could not parse headers: %s\n",
1475                        qib7322, strerror ( rc ) );
1476                 err = 1;
1477         }
1478         if ( ! intended_qp )
1479                 intended_qp = qp;
1480
1481         /* Complete this buffer and any skipped buffers.  Note that
1482          * when the hardware runs out of buffers, it will repeatedly
1483          * report the same buffer (the tail) as a TID error, and that
1484          * it also has a habit of sometimes skipping over several
1485          * buffers at once.
1486          */
1487         while ( 1 ) {
1488
1489                 /* If we have caught up to the producer counter, stop.
1490                  * This will happen when the hardware first runs out
1491                  * of buffers and starts reporting TID errors against
1492                  * the eager buffer it wants to use next.
1493                  */
1494                 if ( qib7322_wq->eager_cons == qib7322_wq->eager_prod )
1495                         break;
1496
1497                 /* If we have caught up to where we should be after
1498                  * completing this egrindex, stop.  We phrase the test
1499                  * this way to avoid completing the entire ring when
1500                  * we receive the same egrindex twice in a row.
1501                  */
1502                 if ( ( qib7322_wq->eager_cons ==
1503                        ( ( egrindex + 1 ) & ( qib7322_wq->eager_entries - 1 ))))
1504                         break;
1505
1506                 /* Identify work queue entry and corresponding I/O
1507                  * buffer.
1508                  */
1509                 wqe_idx = ( qib7322_wq->eager_cons & ( wq->num_wqes - 1 ) );
1510                 iobuf = wq->iobufs[wqe_idx];
1511                 assert ( iobuf != NULL );
1512                 wq->iobufs[wqe_idx] = NULL;
1513
1514                 /* Complete the eager buffer */
1515                 if ( qib7322_wq->eager_cons == egrindex ) {
1516                         /* Completing the eager buffer described in
1517                          * this header entry.
1518                          */
1519                         iob_put ( iobuf, payload_len );
1520                         rc = ( err ? -EIO : ( useegrbfr ? 0 : -ECANCELED ) );
1521                         /* Redirect to target QP if necessary */
1522                         if ( qp != intended_qp ) {
1523                                 DBGC2 ( qib7322, "QIB7322 %p redirecting QPN "
1524                                         "%ld => %ld\n",
1525                                         qib7322, qp->qpn, intended_qp->qpn );
1526                                 /* Compensate for incorrect fill levels */
1527                                 qp->recv.fill--;
1528                                 intended_qp->recv.fill++;
1529                         }
1530                         ib_complete_recv ( ibdev, intended_qp, &av, iobuf, rc);
1531                 } else {
1532                         /* Completing on a skipped-over eager buffer */
1533                         ib_complete_recv ( ibdev, qp, &av, iobuf, -ECANCELED );
1534                 }
1535
1536                 /* Clear eager buffer */
1537                 memset ( &rcvegr, 0, sizeof ( rcvegr ) );
1538                 qib7322_writeq_array8b ( qib7322, &rcvegr,
1539                                         qib7322_wq->eager_array,
1540                                         qib7322_wq->eager_cons );
1541
1542                 /* Increment consumer index */
1543                 qib7322_wq->eager_cons = ( ( qib7322_wq->eager_cons + 1 ) &
1544                                           ( qib7322_wq->eager_entries - 1 ) );
1545         }
1546 }
1547
1548 /**
1549  * Poll receive work queue
1550  *
1551  * @v ibdev             Infiniband device
1552  * @v qp                Queue pair
1553  */
1554 static void qib7322_poll_recv_wq ( struct ib_device *ibdev,
1555                                   struct ib_queue_pair *qp ) {
1556         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1557         struct ib_work_queue *wq = &qp->recv;
1558         struct qib7322_recv_work_queue *qib7322_wq = ib_wq_get_drvdata ( wq );
1559         struct QIB_7322_RcvHdrHead0 rcvhdrhead;
1560         unsigned int ctx = qib7322_ctx ( ibdev, qp );
1561         unsigned int header_prod;
1562
1563         /* Check for received packets */
1564         header_prod = ( BIT_GET ( &qib7322_wq->header_prod, Value ) << 2 );
1565         if ( header_prod == qib7322_wq->header_cons )
1566                 return;
1567
1568         /* Process all received packets */
1569         while ( qib7322_wq->header_cons != header_prod ) {
1570
1571                 /* Complete the receive */
1572                 qib7322_complete_recv ( ibdev, qp, qib7322_wq->header_cons );
1573
1574                 /* Increment the consumer offset */
1575                 qib7322_wq->header_cons += QIB7322_RECV_HEADER_SIZE;
1576                 qib7322_wq->header_cons %= QIB7322_RECV_HEADERS_SIZE;
1577
1578                 /* QIB7322 has only one send buffer per port for VL15,
1579                  * which almost always leads to send buffer exhaustion
1580                  * and dropped MADs.  Mitigate this by refusing to
1581                  * process more than one VL15 MAD per poll, which will
1582                  * enforce interleaved TX/RX polls.
1583                  */
1584                 if ( qp->type == IB_QPT_SMI )
1585                         break;
1586         }
1587
1588         /* Update consumer offset */
1589         memset ( &rcvhdrhead, 0, sizeof ( rcvhdrhead ) );
1590         BIT_FILL_2 ( &rcvhdrhead,
1591                      RcvHeadPointer, ( qib7322_wq->header_cons >> 2 ),
1592                      counter, 1 );
1593         qib7322_writeq_array64k ( qib7322, &rcvhdrhead,
1594                                 QIB_7322_RcvHdrHead0_offset, ctx );
1595 }
1596
1597 /**
1598  * Poll completion queue
1599  *
1600  * @v ibdev             Infiniband device
1601  * @v cq                Completion queue
1602  */
1603 static void qib7322_poll_cq ( struct ib_device *ibdev,
1604                              struct ib_completion_queue *cq ) {
1605         struct ib_work_queue *wq;
1606
1607         /* Poll associated send and receive queues */
1608         list_for_each_entry ( wq, &cq->work_queues, list ) {
1609                 if ( wq->is_send ) {
1610                         qib7322_poll_send_wq ( ibdev, wq->qp );
1611                 } else {
1612                         qib7322_poll_recv_wq ( ibdev, wq->qp );
1613                 }
1614         }
1615 }
1616
1617 /***************************************************************************
1618  *
1619  * Event queues
1620  *
1621  ***************************************************************************
1622  */
1623
1624 /**
1625  * Poll event queue
1626  *
1627  * @v ibdev             Infiniband device
1628  */
1629 static void qib7322_poll_eq ( struct ib_device *ibdev ) {
1630         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1631         struct QIB_7322_ErrStatus_0 errstatus;
1632         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1633
1634         /* Check for and clear status bits */
1635         DBG_DISABLE ( DBGLVL_IO );
1636         qib7322_readq_port ( qib7322, &errstatus,
1637                             QIB_7322_ErrStatus_0_offset, port );
1638         if ( errstatus.u.qwords[0] ) {
1639                 DBGC ( qib7322, "QIB7322 %p port %d status %08x%08x\n", qib7322,
1640                        port, errstatus.u.dwords[1],  errstatus.u.dwords[0] );
1641                 qib7322_writeq_port ( qib7322, &errstatus,
1642                                      QIB_7322_ErrClear_0_offset, port );
1643         }
1644         DBG_ENABLE ( DBGLVL_IO );
1645
1646         /* Check for link status changes */
1647         if ( BIT_GET ( &errstatus, IBStatusChanged ) )
1648                 qib7322_link_state_changed ( ibdev );
1649 }
1650
1651 /***************************************************************************
1652  *
1653  * Infiniband link-layer operations
1654  *
1655  ***************************************************************************
1656  */
1657
1658 /**
1659  * Determine supported link speeds
1660  *
1661  * @v qib7322           QIB7322 device
1662  * @ret supported       Supported link speeds
1663  */
1664 static unsigned int qib7322_link_speed_supported ( struct qib7322 *qib7322,
1665                                                   unsigned int port ) {
1666         struct QIB_7322_feature_mask features;
1667         struct QIB_7322_Revision revision;
1668         unsigned int supported;
1669         unsigned int boardid;
1670
1671         /* Read the active feature mask */
1672         qib7322_readq ( qib7322, &features,
1673                        QIB_7322_active_feature_mask_offset );
1674         switch ( port ) {
1675         case 0 :
1676                 supported = BIT_GET ( &features, Port0_Link_Speed_Supported );
1677                 break;
1678         case 1 :
1679                 supported = BIT_GET ( &features, Port1_Link_Speed_Supported );
1680                 break;
1681         default:
1682                 DBGC ( qib7322, "QIB7322 %p port %d is invalid\n",
1683                        qib7322, port );
1684                 break;
1685         }
1686
1687         /* Apply hacks for specific board IDs */
1688         qib7322_readq ( qib7322, &revision, QIB_7322_Revision_offset );
1689         boardid = BIT_GET ( &revision, BoardID );
1690         switch ( boardid ) {
1691         case QIB7322_BOARD_QMH7342 :
1692                 DBGC2 ( qib7322, "QIB7322 %p is a QMH7342; forcing QDR-only\n",
1693                         qib7322 );
1694                 supported = IB_LINK_SPEED_QDR;
1695                 break;
1696         default:
1697                 /* Do nothing */
1698                 break;
1699         }
1700
1701         DBGC2 ( qib7322, "QIB7322 %p port %d %s%s%s%s\n", qib7322, port,
1702                 ( supported ? "supports" : "disabled" ),
1703                 ( ( supported & IB_LINK_SPEED_SDR ) ? " SDR" : "" ),
1704                 ( ( supported & IB_LINK_SPEED_DDR ) ? " DDR" : "" ),
1705                 ( ( supported & IB_LINK_SPEED_QDR ) ? " QDR" : "" ) );
1706         return supported;
1707 }
1708
1709 /**
1710  * Initialise Infiniband link
1711  *
1712  * @v ibdev             Infiniband device
1713  * @ret rc              Return status code
1714  */
1715 static int qib7322_open ( struct ib_device *ibdev ) {
1716         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1717         struct QIB_7322_IBCCtrlA_0 ibcctrla;
1718         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1719
1720         /* Enable link */
1721         qib7322_readq_port ( qib7322, &ibcctrla,
1722                             QIB_7322_IBCCtrlA_0_offset, port );
1723         BIT_SET ( &ibcctrla, IBLinkEn, 1 );
1724         qib7322_writeq_port ( qib7322, &ibcctrla,
1725                              QIB_7322_IBCCtrlA_0_offset, port );
1726
1727         return 0;
1728 }
1729
1730 /**
1731  * Close Infiniband link
1732  *
1733  * @v ibdev             Infiniband device
1734  */
1735 static void qib7322_close ( struct ib_device *ibdev ) {
1736         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1737         struct QIB_7322_IBCCtrlA_0 ibcctrla;
1738         unsigned int port = ( ibdev->port - QIB7322_PORT_BASE );
1739
1740         /* Disable link */
1741         qib7322_readq_port ( qib7322, &ibcctrla,
1742                             QIB_7322_IBCCtrlA_0_offset, port );
1743         BIT_SET ( &ibcctrla, IBLinkEn, 0 );
1744         qib7322_writeq_port ( qib7322, &ibcctrla,
1745                              QIB_7322_IBCCtrlA_0_offset, port );
1746 }
1747
1748 /***************************************************************************
1749  *
1750  * Multicast group operations
1751  *
1752  ***************************************************************************
1753  */
1754
1755 /**
1756  * Attach to multicast group
1757  *
1758  * @v ibdev             Infiniband device
1759  * @v qp                Queue pair
1760  * @v gid               Multicast GID
1761  * @ret rc              Return status code
1762  */
1763 static int qib7322_mcast_attach ( struct ib_device *ibdev,
1764                                 struct ib_queue_pair *qp,
1765                                 struct ib_gid *gid ) {
1766         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1767
1768         ( void ) qib7322;
1769         ( void ) qp;
1770         ( void ) gid;
1771         return 0;
1772 }
1773
1774 /**
1775  * Detach from multicast group
1776  *
1777  * @v ibdev             Infiniband device
1778  * @v qp                Queue pair
1779  * @v gid               Multicast GID
1780  */
1781 static void qib7322_mcast_detach ( struct ib_device *ibdev,
1782                                  struct ib_queue_pair *qp,
1783                                  struct ib_gid *gid ) {
1784         struct qib7322 *qib7322 = ib_get_drvdata ( ibdev );
1785
1786         ( void ) qib7322;
1787         ( void ) qp;
1788         ( void ) gid;
1789  }
1790
1791 /** QIB7322 Infiniband operations */
1792 static struct ib_device_operations qib7322_ib_operations = {
1793         .create_cq      = qib7322_create_cq,
1794         .destroy_cq     = qib7322_destroy_cq,
1795         .create_qp      = qib7322_create_qp,
1796         .modify_qp      = qib7322_modify_qp,
1797         .destroy_qp     = qib7322_destroy_qp,
1798         .post_send      = qib7322_post_send,
1799         .post_recv      = qib7322_post_recv,
1800         .poll_cq        = qib7322_poll_cq,
1801         .poll_eq        = qib7322_poll_eq,
1802         .open           = qib7322_open,
1803         .close          = qib7322_close,
1804         .mcast_attach   = qib7322_mcast_attach,
1805         .mcast_detach   = qib7322_mcast_detach,
1806         .set_port_info  = qib7322_set_port_info,
1807         .set_pkey_table = qib7322_set_pkey_table,
1808 };
1809
1810 /***************************************************************************
1811  *
1812  * I2C bus operations
1813  *
1814  ***************************************************************************
1815  */
1816
1817 /** QIB7322 I2C bit to GPIO mappings */
1818 static unsigned int qib7322_i2c_bits[] = {
1819         [I2C_BIT_SCL] = ( 1 << QIB7322_GPIO_SCL ),
1820         [I2C_BIT_SDA] = ( 1 << QIB7322_GPIO_SDA ),
1821 };
1822
1823 /**
1824  * Read QIB7322 I2C line status
1825  *
1826  * @v basher            Bit-bashing interface
1827  * @v bit_id            Bit number
1828  * @ret zero            Input is a logic 0
1829  * @ret non-zero        Input is a logic 1
1830  */
1831 static int qib7322_i2c_read_bit ( struct bit_basher *basher,
1832                                  unsigned int bit_id ) {
1833         struct qib7322 *qib7322 =
1834                 container_of ( basher, struct qib7322, i2c.basher );
1835         struct QIB_7322_EXTStatus extstatus;
1836         unsigned int status;
1837
1838         DBG_DISABLE ( DBGLVL_IO );
1839
1840         qib7322_readq ( qib7322, &extstatus, QIB_7322_EXTStatus_offset );
1841         status = ( BIT_GET ( &extstatus, GPIOIn ) & qib7322_i2c_bits[bit_id] );
1842
1843         DBG_ENABLE ( DBGLVL_IO );
1844
1845         return status;
1846 }
1847
1848 /**
1849  * Write QIB7322 I2C line status
1850  *
1851  * @v basher            Bit-bashing interface
1852  * @v bit_id            Bit number
1853  * @v data              Value to write
1854  */
1855 static void qib7322_i2c_write_bit ( struct bit_basher *basher,
1856                                    unsigned int bit_id, unsigned long data ) {
1857         struct qib7322 *qib7322 =
1858                 container_of ( basher, struct qib7322, i2c.basher );
1859         struct QIB_7322_EXTCtrl extctrl;
1860         struct QIB_7322_GPIO gpioout;
1861         unsigned int bit = qib7322_i2c_bits[bit_id];
1862         unsigned int outputs = 0;
1863         unsigned int output_enables = 0;
1864
1865         DBG_DISABLE ( DBGLVL_IO );
1866
1867         /* Read current GPIO mask and outputs */
1868         qib7322_readq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
1869         qib7322_readq ( qib7322, &gpioout, QIB_7322_GPIOOut_offset );
1870
1871         /* Update outputs and output enables.  I2C lines are tied
1872          * high, so we always set the output to 0 and use the output
1873          * enable to control the line.
1874          */
1875         output_enables = BIT_GET ( &extctrl, GPIOOe );
1876         output_enables = ( ( output_enables & ~bit ) | ( ~data & bit ) );
1877         outputs = BIT_GET ( &gpioout, GPIO );
1878         outputs = ( outputs & ~bit );
1879         BIT_SET ( &extctrl, GPIOOe, output_enables );
1880         BIT_SET ( &gpioout, GPIO, outputs );
1881
1882         /* Write the output enable first; that way we avoid logic
1883          * hazards.
1884          */
1885         qib7322_writeq ( qib7322, &extctrl, QIB_7322_EXTCtrl_offset );
1886         qib7322_writeq ( qib7322, &gpioout, QIB_7322_GPIOOut_offset );
1887         mb();
1888
1889         DBG_ENABLE ( DBGLVL_IO );
1890 }
1891
1892 /** QIB7322 I2C bit-bashing interface operations */
1893 static struct bit_basher_operations qib7322_i2c_basher_ops = {
1894         .read   = qib7322_i2c_read_bit,
1895         .write  = qib7322_i2c_write_bit,
1896 };
1897
1898 /**
1899  * Initialise QIB7322 I2C subsystem
1900  *
1901  * @v qib7322           QIB7322 device
1902  * @ret rc              Return status code
1903  */
1904 static int qib7322_init_i2c ( struct qib7322 *qib7322 ) {
1905         static int try_eeprom_address[] = { 0x51, 0x50 };
1906         unsigned int i;
1907         int rc;
1908
1909         /* Initialise bus */
1910         if ( ( rc = init_i2c_bit_basher ( &qib7322->i2c,
1911                                           &qib7322_i2c_basher_ops ) ) != 0 ) {
1912                 DBGC ( qib7322, "QIB7322 %p could not initialise I2C bus: %s\n",
1913                        qib7322, strerror ( rc ) );
1914                 return rc;
1915         }
1916
1917         /* Probe for devices */
1918         for ( i = 0 ; i < ( sizeof ( try_eeprom_address ) /
1919                             sizeof ( try_eeprom_address[0] ) ) ; i++ ) {
1920                 init_i2c_eeprom ( &qib7322->eeprom, try_eeprom_address[i] );
1921                 if ( ( rc = i2c_check_presence ( &qib7322->i2c.i2c,
1922                                                  &qib7322->eeprom ) ) == 0 ) {
1923                         DBGC2 ( qib7322, "QIB7322 %p found EEPROM at %02x\n",
1924                                 qib7322, try_eeprom_address[i] );
1925                         return 0;
1926                 }
1927         }
1928
1929         DBGC ( qib7322, "QIB7322 %p could not find EEPROM\n", qib7322 );
1930         return -ENODEV;
1931 }
1932
1933 /**
1934  * Read EEPROM parameters
1935  *
1936  * @v qib7322           QIB7322 device
1937  * @ret rc              Return status code
1938  */
1939 static int qib7322_read_eeprom ( struct qib7322 *qib7322 ) {
1940         struct i2c_interface *i2c = &qib7322->i2c.i2c;
1941         struct ib_gid_half *guid = &qib7322->guid;
1942         int rc;
1943
1944         /* Read GUID */
1945         if ( ( rc = i2c->read ( i2c, &qib7322->eeprom,
1946                                 QIB7322_EEPROM_GUID_OFFSET, guid->u.bytes,
1947                                 sizeof ( *guid ) ) ) != 0 ) {
1948                 DBGC ( qib7322, "QIB7322 %p could not read GUID: %s\n",
1949                        qib7322, strerror ( rc ) );
1950                 return rc;
1951         }
1952         DBGC2 ( qib7322, "QIB7322 %p has GUID %02x:%02x:%02x:%02x:%02x:%02x:"
1953                 "%02x:%02x\n", qib7322, guid->u.bytes[0], guid->u.bytes[1],
1954                 guid->u.bytes[2], guid->u.bytes[3], guid->u.bytes[4],
1955                 guid->u.bytes[5], guid->u.bytes[6], guid->u.bytes[7] );
1956
1957         /* Read serial number (debug only) */
1958         if ( DBG_LOG ) {
1959                 uint8_t serial[QIB7322_EEPROM_SERIAL_SIZE + 1];
1960
1961                 serial[ sizeof ( serial ) - 1 ] = '\0';
1962                 if ( ( rc = i2c->read ( i2c, &qib7322->eeprom,
1963                                         QIB7322_EEPROM_SERIAL_OFFSET, serial,
1964                                         ( sizeof ( serial ) - 1 ) ) ) != 0 ) {
1965                         DBGC ( qib7322, "QIB7322 %p could not read serial: "
1966                                "%s\n", qib7322, strerror ( rc ) );
1967                         return rc;
1968                 }
1969                 DBGC2 ( qib7322, "QIB7322 %p has serial number \"%s\"\n",
1970                         qib7322, serial );
1971         }
1972
1973         return 0;
1974 }
1975
1976 /***************************************************************************
1977  *
1978  * Advanced High-performance Bus (AHB) access
1979  *
1980  ***************************************************************************
1981  */
1982
1983 /**
1984  * Wait for AHB transaction to complete
1985  *
1986  * @v qib7322           QIB7322 device
1987  * @ret rc              Return status code
1988  */
1989 static int qib7322_ahb_wait ( struct qib7322 *qib7322 ) {
1990         struct QIB_7322_ahb_transaction_reg transaction;
1991         unsigned int i;
1992
1993         /* Wait for Ready bit to be asserted */
1994         for ( i = 0 ; i < QIB7322_AHB_MAX_WAIT_US ; i++ ) {
1995                 qib7322_readq ( qib7322, &transaction,
1996                                QIB_7322_ahb_transaction_reg_offset );
1997                 if ( BIT_GET ( &transaction, ahb_rdy ) )
1998                         return 0;
1999                 udelay ( 1 );
2000         }
2001
2002         DBGC ( qib7322, "QIB7322 %p timed out waiting for AHB transaction\n",
2003                qib7322 );
2004         return -ETIMEDOUT;
2005 }
2006
2007 /**
2008  * Request ownership of the AHB
2009  *
2010  * @v qib7322           QIB7322 device
2011  * @v location          AHB location
2012  * @ret rc              Return status code
2013  */
2014 static int qib7322_ahb_request ( struct qib7322 *qib7322,
2015                                 unsigned int location ) {
2016         struct QIB_7322_ahb_access_ctrl access;
2017         int rc;
2018
2019         /* Request ownership */
2020         memset ( &access, 0, sizeof ( access ) );
2021         BIT_FILL_2 ( &access,
2022                      sw_ahb_sel, 1,
2023                      sw_sel_ahb_trgt, QIB7322_AHB_LOC_TARGET ( location ) );
2024         qib7322_writeq ( qib7322, &access, QIB_7322_ahb_access_ctrl_offset );
2025
2026         /* Wait for ownership to be granted */
2027         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )  {
2028                 DBGC ( qib7322, "QIB7322 %p could not obtain AHB ownership: "
2029                        "%s\n", qib7322, strerror ( rc ) );
2030                 return rc;
2031         }
2032
2033         return 0;
2034 }
2035
2036 /**
2037  * Release ownership of the AHB
2038  *
2039  * @v qib7322           QIB7322 device
2040  */
2041 static void qib7322_ahb_release ( struct qib7322 *qib7322 ) {
2042         struct QIB_7322_ahb_access_ctrl access;
2043
2044         memset ( &access, 0, sizeof ( access ) );
2045         qib7322_writeq ( qib7322, &access, QIB_7322_ahb_access_ctrl_offset );
2046 }
2047
2048 /**
2049  * Read data via AHB
2050  *
2051  * @v qib7322           QIB7322 device
2052  * @v location          AHB location
2053  * @v data              Data to read
2054  * @ret rc              Return status code
2055  *
2056  * You must have already acquired ownership of the AHB.
2057  */
2058 static int qib7322_ahb_read ( struct qib7322 *qib7322, unsigned int location,
2059                              uint32_t *data ) {
2060         struct QIB_7322_ahb_transaction_reg xact;
2061         int rc;
2062
2063         /* Initiate transaction */
2064         memset ( &xact, 0, sizeof ( xact ) );
2065         BIT_FILL_2 ( &xact,
2066                      ahb_address, QIB7322_AHB_LOC_ADDRESS ( location ),
2067                      write_not_read, 0 );
2068         qib7322_writeq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2069
2070         /* Wait for transaction to complete */
2071         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )
2072                 return rc;
2073
2074         /* Read transaction data */
2075         qib7322_readq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2076         *data = BIT_GET ( &xact, ahb_data );
2077         return 0;
2078 }
2079
2080 /**
2081  * Write data via AHB
2082  *
2083  * @v qib7322           QIB7322 device
2084  * @v location          AHB location
2085  * @v data              Data to write
2086  * @ret rc              Return status code
2087  *
2088  * You must have already acquired ownership of the AHB.
2089  */
2090 static int qib7322_ahb_write ( struct qib7322 *qib7322, unsigned int location,
2091                               uint32_t data ) {
2092         struct QIB_7322_ahb_transaction_reg xact;
2093         int rc;
2094
2095         /* Initiate transaction */
2096         memset ( &xact, 0, sizeof ( xact ) );
2097         BIT_FILL_3 ( &xact,
2098                      ahb_address, QIB7322_AHB_LOC_ADDRESS ( location ),
2099                      write_not_read, 1,
2100                      ahb_data, data );
2101         qib7322_writeq ( qib7322, &xact, QIB_7322_ahb_transaction_reg_offset );
2102
2103         /* Wait for transaction to complete */
2104         if ( ( rc = qib7322_ahb_wait ( qib7322 ) ) != 0 )
2105                 return rc;
2106
2107         return 0;
2108 }
2109
2110 /**
2111  * Read/modify/write AHB register
2112  *
2113  * @v qib7322           QIB7322 device
2114  * @v location          AHB location
2115  * @v value             Value to set
2116  * @v mask              Mask to apply to old value
2117  * @ret rc              Return status code
2118  */
2119 static int qib7322_ahb_mod_reg ( struct qib7322 *qib7322, unsigned int location,
2120                                 uint32_t value, uint32_t mask ) {
2121         uint32_t old_value;
2122         uint32_t new_value;
2123         int rc;
2124
2125         DBG_DISABLE ( DBGLVL_IO );
2126
2127         /* Sanity check */
2128         assert ( ( value & mask ) == value );
2129
2130         /* Acquire bus ownership */
2131         if ( ( rc = qib7322_ahb_request ( qib7322, location ) ) != 0 )
2132                 goto out;
2133
2134         /* Read existing value */
2135         if ( ( rc = qib7322_ahb_read ( qib7322, location, &old_value ) ) != 0 )
2136                 goto out_release;
2137
2138         /* Update value */
2139         new_value = ( ( old_value & ~mask ) | value );
2140         DBGCP ( qib7322, "QIB7322 %p AHB %x %#08x => %#08x\n",
2141                 qib7322, location, old_value, new_value );
2142         if ( ( rc = qib7322_ahb_write ( qib7322, location, new_value ) ) != 0 )
2143                 goto out_release;
2144
2145  out_release:
2146         /* Release bus */
2147         qib7322_ahb_release ( qib7322 );
2148  out:
2149         DBG_ENABLE ( DBGLVL_IO );
2150         return rc;
2151 }
2152
2153 /**
2154  * Read/modify/write AHB register across all ports and channels
2155  *
2156  * @v qib7322           QIB7322 device
2157  * @v reg               AHB register
2158  * @v value             Value to set
2159  * @v mask              Mask to apply to old value
2160  * @ret rc              Return status code
2161  */
2162 static int qib7322_ahb_mod_reg_all ( struct qib7322 *qib7322, unsigned int reg,
2163                                     uint32_t value, uint32_t mask ) {
2164         unsigned int port;
2165         unsigned int channel;
2166         unsigned int location;
2167         int rc;
2168
2169         for ( port = 0 ; port < QIB7322_MAX_PORTS ; port++ ) {
2170                 for ( channel = 0 ; channel < QIB7322_MAX_WIDTH ; channel++ ) {
2171                         location = QIB7322_AHB_LOCATION ( port, channel, reg );
2172                         if ( ( rc = qib7322_ahb_mod_reg ( qib7322, location,
2173                                                          value, mask ) ) != 0 )
2174                                 return rc;
2175                 }
2176         }
2177         return 0;
2178 }
2179
2180 /***************************************************************************
2181  *
2182  * Infiniband SerDes initialisation
2183  *
2184  ***************************************************************************
2185  */
2186
2187 /**
2188  * Initialise the IB SerDes
2189  *
2190  * @v qib7322           QIB7322 device
2191  * @ret rc              Return status code
2192  */
2193 static int qib7322_init_ib_serdes ( struct qib7322 *qib7322 ) {
2194         struct QIB_7322_IBCCtrlA_0 ibcctrla;
2195         struct QIB_7322_IBCCtrlB_0 ibcctrlb;
2196         struct QIB_7322_IBPCSConfig_0 ibpcsconfig;
2197
2198         /* Configure sensible defaults for IBC */
2199         memset ( &ibcctrla, 0, sizeof ( ibcctrla ) );
2200         BIT_FILL_5 ( &ibcctrla, /* Tuning values taken from Linux driver */
2201                      FlowCtrlPeriod, 0x03,
2202                      FlowCtrlWaterMark, 0x05,
2203                      MaxPktLen, ( ( QIB7322_RECV_HEADER_SIZE +
2204                                     QIB7322_RECV_PAYLOAD_SIZE +
2205                                     4 /* ICRC */ ) >> 2 ),
2206                      PhyerrThreshold, 0xf,
2207                      OverrunThreshold, 0xf );
2208         qib7322_writeq ( qib7322, &ibcctrla, QIB_7322_IBCCtrlA_0_offset );
2209         qib7322_writeq ( qib7322, &ibcctrla, QIB_7322_IBCCtrlA_1_offset );
2210
2211         /* Force SDR only to avoid needing all the DDR tuning,
2212          * Mellanox compatibility hacks etc.  SDR is plenty for
2213          * boot-time operation.
2214          */
2215         qib7322_readq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_0_offset );
2216         BIT_SET ( &ibcctrlb, IB_ENHANCED_MODE, 0 );
2217         BIT_SET ( &ibcctrlb, SD_SPEED_SDR, 1 );
2218         BIT_SET ( &ibcctrlb, SD_SPEED_DDR, 0 );
2219         BIT_SET ( &ibcctrlb, SD_SPEED_QDR, 0 );
2220         BIT_SET ( &ibcctrlb, IB_NUM_CHANNELS, 1 ); /* 4X only */
2221         BIT_SET ( &ibcctrlb, IB_LANE_REV_SUPPORTED, 0 );
2222         BIT_SET ( &ibcctrlb, HRTBT_ENB, 0 );
2223         BIT_SET ( &ibcctrlb, HRTBT_AUTO, 0 );
2224         qib7322_writeq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_0_offset );
2225         qib7322_writeq ( qib7322, &ibcctrlb, QIB_7322_IBCCtrlB_1_offset );
2226
2227         /* Tune SerDes */
2228         qib7322_ahb_mod_reg_all ( qib7322, 2, 0, 0x00000e00UL );
2229
2230         /* Bring XGXS out of reset */
2231         memset ( &ibpcsconfig, 0, sizeof ( ibpcsconfig ) );
2232         qib7322_writeq ( qib7322, &ibpcsconfig, QIB_7322_IBPCSConfig_0_offset );
2233         qib7322_writeq ( qib7322, &ibpcsconfig, QIB_7322_IBPCSConfig_1_offset );
2234
2235         return 0;
2236 }
2237
2238 /***************************************************************************
2239  *
2240  * PCI layer interface
2241  *
2242  ***************************************************************************
2243  */
2244
2245 /**
2246  * Reset QIB7322
2247  *
2248  * @v qib7322           QIB7322 device
2249  * @v pci               PCI device
2250  * @ret rc              Return status code
2251  */
2252 static void qib7322_reset ( struct qib7322 *qib7322, struct pci_device *pci ) {
2253         struct QIB_7322_Control control;
2254         struct pci_config_backup backup;
2255
2256         /* Back up PCI configuration space */
2257         pci_backup ( pci, &backup, NULL );
2258
2259         /* Assert reset */
2260         memset ( &control, 0, sizeof ( control ) );
2261         BIT_FILL_1 ( &control, SyncReset, 1 );
2262         qib7322_writeq ( qib7322, &control, QIB_7322_Control_offset );
2263
2264         /* Wait for reset to complete */
2265         mdelay ( 1000 );
2266
2267         /* Restore PCI configuration space */
2268         pci_restore ( pci, &backup, NULL );
2269 }
2270
2271 /**
2272  * Probe PCI device
2273  *
2274  * @v pci               PCI device
2275  * @v id                PCI ID
2276  * @ret rc              Return status code
2277  */
2278 static int qib7322_probe ( struct pci_device *pci,
2279                           const struct pci_device_id *id __unused ) {
2280         struct qib7322 *qib7322;
2281         struct QIB_7322_Revision revision;
2282         struct ib_device *ibdev;
2283         unsigned int link_speed_supported;
2284         int i;
2285         int rc;
2286
2287         /* Allocate QIB7322 device */
2288         qib7322 = zalloc ( sizeof ( *qib7322 ) );
2289         if ( ! qib7322 ) {
2290                 rc = -ENOMEM;
2291                 goto err_alloc_qib7322;
2292         }
2293         pci_set_drvdata ( pci, qib7322 );
2294
2295         /* Fix up PCI device */
2296         adjust_pci_device ( pci );
2297
2298         /* Get PCI BARs */
2299         qib7322->regs = ioremap ( pci->membase, QIB7322_BAR0_SIZE );
2300         DBGC2 ( qib7322, "QIB7322 %p has BAR at %08lx\n",
2301                 qib7322, pci->membase );
2302
2303         /* Reset device */
2304         qib7322_reset ( qib7322, pci );
2305
2306         /* Print some general data */
2307         qib7322_readq ( qib7322, &revision, QIB_7322_Revision_offset );
2308         DBGC2 ( qib7322, "QIB7322 %p board %02lx v%ld.%ld.%ld.%ld\n", qib7322,
2309                 BIT_GET ( &revision, BoardID ),
2310                 BIT_GET ( &revision, R_SW ),
2311                 BIT_GET ( &revision, R_Arch ),
2312                 BIT_GET ( &revision, R_ChipRevMajor ),
2313                 BIT_GET ( &revision, R_ChipRevMinor ) );
2314
2315         /* Initialise I2C subsystem */
2316         if ( ( rc = qib7322_init_i2c ( qib7322 ) ) != 0 )
2317                 goto err_init_i2c;
2318
2319         /* Read EEPROM parameters */
2320         if ( ( rc = qib7322_read_eeprom ( qib7322 ) ) != 0 )
2321                 goto err_read_eeprom;
2322
2323         /* Initialise send datapath */
2324         if ( ( rc = qib7322_init_send ( qib7322 ) ) != 0 )
2325                 goto err_init_send;
2326
2327         /* Initialise receive datapath */
2328         if ( ( rc = qib7322_init_recv ( qib7322 ) ) != 0 )
2329                 goto err_init_recv;
2330
2331         /* Initialise the IB SerDes */
2332         if ( ( rc = qib7322_init_ib_serdes ( qib7322 ) ) != 0 )
2333                 goto err_init_ib_serdes;
2334
2335         /* Allocate Infiniband devices */
2336         for ( i = 0 ; i < QIB7322_MAX_PORTS ; i++ ) {
2337                 link_speed_supported =
2338                         qib7322_link_speed_supported ( qib7322, i );
2339                 if ( ! link_speed_supported )
2340                         continue;
2341                 ibdev = alloc_ibdev ( 0 );
2342                 if ( ! ibdev ) {
2343                         rc = -ENOMEM;
2344                         goto err_alloc_ibdev;
2345                 }
2346                 qib7322->ibdev[i] = ibdev;
2347                 ibdev->dev = &pci->dev;
2348                 ibdev->op = &qib7322_ib_operations;
2349                 ibdev->port = ( QIB7322_PORT_BASE + i );
2350                 ibdev->link_width_enabled = ibdev->link_width_supported =
2351                         IB_LINK_WIDTH_4X; /* 1x does not work */
2352                 ibdev->link_speed_enabled = ibdev->link_speed_supported =
2353                         IB_LINK_SPEED_SDR; /* to avoid need for link tuning */
2354                 memcpy ( &ibdev->gid.u.half[1], &qib7322->guid,
2355                          sizeof ( ibdev->gid.u.half[1] ) );
2356                 assert ( ( ibdev->gid.u.half[1].u.bytes[7] & i ) == 0 );
2357                 ibdev->gid.u.half[1].u.bytes[7] |= i;
2358                 ib_set_drvdata ( ibdev, qib7322 );
2359         }
2360
2361         /* Register Infiniband devices */
2362         for ( i = 0 ; i < QIB7322_MAX_PORTS ; i++ ) {
2363                 if ( ! qib7322->ibdev[i] )
2364                         continue;
2365                 if ( ( rc = register_ibdev ( qib7322->ibdev[i] ) ) != 0 ) {
2366                         DBGC ( qib7322, "QIB7322 %p port %d could not register "
2367                                "IB device: %s\n", qib7322, i, strerror ( rc ) );
2368                         goto err_register_ibdev;
2369                 }
2370         }
2371
2372         return 0;
2373
2374         i = QIB7322_MAX_PORTS;
2375  err_register_ibdev:
2376         for ( i-- ; i >= 0 ; i-- ) {
2377                 if ( qib7322->ibdev[i] )
2378                         unregister_ibdev ( qib7322->ibdev[i] );
2379         }
2380         i = QIB7322_MAX_PORTS;
2381  err_alloc_ibdev:
2382         for ( i-- ; i >= 0 ; i-- )
2383                 ibdev_put ( qib7322->ibdev[i] );
2384  err_init_ib_serdes:
2385         qib7322_fini_send ( qib7322 );
2386  err_init_send:
2387         qib7322_fini_recv ( qib7322 );
2388  err_init_recv:
2389  err_read_eeprom:
2390  err_init_i2c:
2391         free ( qib7322 );
2392  err_alloc_qib7322:
2393         return rc;
2394 }
2395
2396 /**
2397  * Remove PCI device
2398  *
2399  * @v pci               PCI device
2400  */
2401 static void qib7322_remove ( struct pci_device *pci ) {
2402         struct qib7322 *qib7322 = pci_get_drvdata ( pci );
2403         int i;
2404
2405         for ( i = ( QIB7322_MAX_PORTS - 1 ) ; i >= 0 ; i-- ) {
2406                 if ( qib7322->ibdev[i] )
2407                         unregister_ibdev ( qib7322->ibdev[i] );
2408         }
2409         for ( i = ( QIB7322_MAX_PORTS - 1 ) ; i >= 0 ; i-- )
2410                 ibdev_put ( qib7322->ibdev[i] );
2411         qib7322_fini_send ( qib7322 );
2412         qib7322_fini_recv ( qib7322 );
2413         free ( qib7322 );
2414 }
2415
2416 static struct pci_device_id qib7322_nics[] = {
2417         PCI_ROM ( 0x1077, 0x7322, "iba7322", "IBA7322 QDR InfiniBand HCA", 0 ),
2418 };
2419
2420 struct pci_driver qib7322_driver __pci_driver = {
2421         .ids = qib7322_nics,
2422         .id_count = ( sizeof ( qib7322_nics ) / sizeof ( qib7322_nics[0] ) ),
2423         .probe = qib7322_probe,
2424         .remove = qib7322_remove,
2425 };