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