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