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