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