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