c466adb6ba8516b4495dea3431dc85aa1694cee2
[people/pcmattman/gpxe.git] / src / drivers / net / mlx_ipoib / mt25218.c
1 /**************************************************************************
2 Etherboot -  BOOTP/TFTP Bootstrap Program
3 Skeleton NIC driver for Etherboot
4 ***************************************************************************/
5
6 /*
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2, or (at
10  * your option) any later version.
11  */
12
13 #include <errno.h>
14 #include <gpxe/pci.h>
15 #include <gpxe/malloc.h>
16 #include <gpxe/iobuf.h>
17 #include <gpxe/netdevice.h>
18 #include <gpxe/infiniband.h>
19
20 /* to get some global routines like printf */
21 #include "etherboot.h"
22 /* to get the interface to the body of the program */
23 #include "nic.h"
24
25 #include "mt25218_imp.c"
26
27 #include "arbel.h"
28
29
30 static const struct ib_gid arbel_no_gid = {
31         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 }
32 };
33
34
35 #define MLX_RX_MAX_FILL NUM_IPOIB_RCV_WQES
36
37 struct mlx_nic {
38         /** Queue pair handle */
39         udqp_t ipoib_qph;
40         /** Broadcast Address Vector */
41         ud_av_t bcast_av;
42         /** Send completion queue */
43         cq_t snd_cqh;
44         /** Receive completion queue */
45         cq_t rcv_cqh;
46
47         /** RX fill level */
48         unsigned int rx_fill;
49 };
50
51
52 static struct io_buffer *static_ipoib_tx_ring[NUM_IPOIB_SND_WQES];
53 static struct io_buffer *static_ipoib_rx_ring[NUM_IPOIB_RCV_WQES];
54
55 static struct arbel static_arbel;
56
57 static struct arbel_completion_queue static_arbel_ipoib_send_cq = {
58         .ci_doorbell_idx = IPOIB_SND_CQ_CI_DB_IDX,
59 };
60 static struct ib_completion_queue static_ipoib_send_cq = {
61         .cqn = 1234, /* Only used for debug messages */
62         .num_cqes = NUM_IPOIB_SND_CQES,
63         .work_queues = LIST_HEAD_INIT ( static_ipoib_send_cq.work_queues ),
64         .dev_priv = &static_arbel_ipoib_send_cq,
65 };
66
67 static struct arbel_completion_queue static_arbel_ipoib_recv_cq = {
68         .ci_doorbell_idx = IPOIB_RCV_CQ_CI_DB_IDX,
69 };
70 static struct ib_completion_queue static_ipoib_recv_cq = {
71         .cqn = 2345, /* Only used for debug messages */
72         .num_cqes = NUM_IPOIB_RCV_CQES,
73         .work_queues = LIST_HEAD_INIT ( static_ipoib_recv_cq.work_queues ),
74         .dev_priv = &static_arbel_ipoib_recv_cq,
75 };
76
77 static struct arbel_queue_pair static_arbel_ipoib_qp = {
78         .send = {
79                 .doorbell_idx = IPOIB_SND_QP_DB_IDX,
80         },
81         .recv = {
82                 .doorbell_idx = IPOIB_RCV_QP_DB_IDX,
83         },
84 };
85 static struct ib_queue_pair static_ipoib_qp = {
86         .send = {
87                 .qp = &static_ipoib_qp,
88                 .is_send = 1,
89                 .cq = &static_ipoib_send_cq,
90                 .num_wqes = NUM_IPOIB_SND_WQES,
91                 .iobufs = static_ipoib_tx_ring,
92                 .list = LIST_HEAD_INIT (static_ipoib_qp.send.list),
93                 .dev_priv = &static_arbel_ipoib_qp.send,
94         },
95         .recv = {
96                 .qp = &static_ipoib_qp,
97                 .is_send = 0,
98                 .cq = &static_ipoib_recv_cq,
99                 .num_wqes = NUM_IPOIB_RCV_WQES,
100                 .iobufs = static_ipoib_rx_ring,
101                 .list = LIST_HEAD_INIT (static_ipoib_qp.recv.list),
102                 .dev_priv = &static_arbel_ipoib_qp.recv,
103         },
104         .dev_priv = &static_arbel_ipoib_qp,
105 };
106
107
108 static struct ib_device static_ibdev = {
109         .dev_priv = &static_arbel,
110 };
111
112
113 /**
114  * Open network device
115  *
116  * @v netdev            Network device
117  * @ret rc              Return status code
118  */
119 static int mlx_open ( struct net_device *netdev ) {
120
121         ( void ) netdev;
122
123         return 0;
124 }
125
126 /**
127  * Close network device
128  *
129  * @v netdev            Network device
130  */
131 static void mlx_close ( struct net_device *netdev ) {
132
133         ( void ) netdev;
134
135 }
136
137 static int arbel_post_send ( struct ib_device *ibdev,
138                              struct ib_queue_pair *qp,
139                              struct ib_address_vector *av,
140                              struct io_buffer *iobuf );
141
142 static int mlx_transmit_direct ( struct net_device *netdev,
143                                  struct io_buffer *iobuf ) {
144         struct mlx_nic *mlx = netdev->priv;
145         int rc;
146
147         struct ud_av_st *bcast_av = mlx->bcast_av;
148         struct arbelprm_ud_address_vector *bav =
149                 ( struct arbelprm_ud_address_vector * ) &bcast_av->av;
150         struct ib_address_vector av = {
151                 .dest_qp = bcast_av->dest_qp,
152                 .qkey = bcast_av->qkey,
153                 .dlid = MLX_GET ( bav, rlid ),
154                 .rate = ( MLX_GET ( bav, max_stat_rate ) ? 1 : 4 ),
155                 .sl = MLX_GET ( bav, sl ),
156                 .gid_present = 1,
157         };
158         memcpy ( &av.gid, ( ( void * ) bav ) + 16, 16 );
159
160         rc = arbel_post_send ( &static_ibdev, &static_ipoib_qp, &av, iobuf );
161
162         return rc;
163 }
164
165 static void arbel_poll_cq ( struct ib_device *ibdev,
166                             struct ib_completion_queue *cq,
167                             ib_completer_t complete_send,
168                             ib_completer_t complete_recv );
169
170 static void temp_complete_send ( struct ib_device *ibdev __unused,
171                                  struct ib_queue_pair *qp,
172                                  struct ib_completion *completion,
173                                  struct io_buffer *iobuf ) {
174         struct net_device *netdev = qp->owner_priv;
175
176         DBG ( "Wahey! TX completion\n" );
177         netdev_tx_complete_err ( netdev, iobuf,
178                                  ( completion->syndrome ? -EIO : 0 ) );
179 }
180
181 static void temp_complete_recv ( struct ib_device *ibdev __unused,
182                                  struct ib_queue_pair *qp,
183                                  struct ib_completion *completion,
184                                  struct io_buffer *iobuf ) {
185         struct net_device *netdev = qp->owner_priv;
186         struct mlx_nic *mlx = netdev->priv;
187
188         DBG ( "Yay! RX completion on %p len %zx:\n", iobuf, completion->len );
189         if ( completion->syndrome ) {
190                 netdev_rx_err ( netdev, iobuf, -EIO );
191         } else {
192                 iob_put ( iobuf, completion->len );
193                 iob_pull ( iobuf, sizeof ( struct ib_global_route_header ) );
194                 netdev_rx ( netdev, iobuf );
195         }
196
197         mlx->rx_fill--;
198 }
199
200 static int arbel_post_recv ( struct ib_device *ibdev,
201                              struct ib_queue_pair *qp,
202                              struct io_buffer *iobuf );
203
204 static void mlx_refill_rx ( struct net_device *netdev ) {
205         struct mlx_nic *mlx = netdev->priv;
206         struct io_buffer *iobuf;
207         int rc;
208
209         while ( mlx->rx_fill < MLX_RX_MAX_FILL ) {
210                 iobuf = alloc_iob ( 2048 );
211                 if ( ! iobuf )
212                         break;
213                 DBG ( "Posting RX buffer %p:\n", iobuf );
214                 if ( ( rc = arbel_post_recv ( &static_ibdev,
215                                               &static_ipoib_qp,
216                                               iobuf ) ) != 0 ) {
217                         free_iob ( iobuf );
218                         break;
219                 }
220                 mlx->rx_fill++;
221         }
222 }
223
224 /**
225  * Poll for completed and received packets
226  *
227  * @v netdev            Network device
228  */
229 static void mlx_poll ( struct net_device *netdev ) {
230         struct mlx_nic *mlx = netdev->priv;
231         int rc;
232
233         if ( ( rc = poll_error_buf() ) != 0 ) {
234                 DBG ( "poll_error_buf() failed: %s\n", strerror ( rc ) );
235                 return;
236         }
237
238         /* Drain event queue.  We can ignore events, since we're going
239          * to just poll all completion queues anyway.
240          */
241         if ( ( rc = drain_eq() ) != 0 ) {
242                 DBG ( "drain_eq() failed: %s\n", strerror ( rc ) );
243                 return;
244         }
245
246         /* Poll completion queues */
247         arbel_poll_cq ( &static_ibdev, &static_ipoib_send_cq,
248                         temp_complete_send, temp_complete_recv );
249         arbel_poll_cq ( &static_ibdev, &static_ipoib_recv_cq,
250                         temp_complete_send, temp_complete_recv );
251
252         mlx_refill_rx ( netdev );
253 }
254
255 /**
256  * Enable or disable interrupts
257  *
258  * @v netdev            Network device
259  * @v enable            Interrupts should be enabled
260  */
261 static void mlx_irq ( struct net_device *netdev, int enable ) {
262
263         ( void ) netdev;
264         ( void ) enable;
265
266 }
267
268 static struct net_device_operations mlx_operations = {
269         .open           = mlx_open,
270         .close          = mlx_close,
271         .transmit       = mlx_transmit_direct,
272         .poll           = mlx_poll,
273         .irq            = mlx_irq,
274 };
275
276
277
278
279 /***************************************************************************
280  *
281  * Queue number allocation
282  *
283  ***************************************************************************
284  */
285
286 /**
287  * Allocate queue number
288  *
289  * @v q_inuse           Queue usage bitmask
290  * @v max_inuse         Maximum number of in-use queues
291  * @ret qn_offset       Free queue number offset, or negative error
292  */
293 static int arbel_alloc_qn_offset ( arbel_bitmask_t *q_inuse,
294                                    unsigned int max_inuse ) {
295         unsigned int qn_offset = 0;
296         arbel_bitmask_t mask = 1;
297
298         while ( qn_offset < max_inuse ) {
299                 if ( ( mask & *q_inuse ) == 0 ) {
300                         *q_inuse |= mask;
301                         return qn_offset;
302                 }
303                 qn_offset++;
304                 mask <<= 1;
305                 if ( ! mask ) {
306                         mask = 1;
307                         q_inuse++;
308                 }
309         }
310         return -ENFILE;
311 }
312
313 /**
314  * Free queue number
315  *
316  * @v q_inuse           Queue usage bitmask
317  * @v qn_offset         Queue number offset
318  */
319 static void arbel_free_qn_offset ( arbel_bitmask_t *q_inuse, int qn_offset ) {
320         arbel_bitmask_t mask;
321
322         mask = ( 1 << ( qn_offset % ( 8 * sizeof ( mask ) ) ) );
323         q_inuse += ( qn_offset / ( 8 * sizeof ( mask ) ) );
324         *q_inuse &= ~mask;
325 }
326
327 /***************************************************************************
328  *
329  * HCA commands
330  *
331  ***************************************************************************
332  */
333
334 /**
335  * Wait for Arbel command completion
336  *
337  * @v arbel             Arbel device
338  * @ret rc              Return status code
339  */
340 static int arbel_cmd_wait ( struct arbel *arbel,
341                             struct arbelprm_hca_command_register *hcr ) {
342         unsigned int wait;
343
344         for ( wait = ARBEL_HCR_MAX_WAIT_MS ; wait ; wait-- ) {
345                 hcr->u.dwords[6] =
346                         readl ( arbel->config + ARBEL_HCR_REG ( 6 ) );
347                 if ( MLX_GET ( hcr, go ) == 0 )
348                         return 0;
349                 mdelay ( 1 );
350         }
351         return -EBUSY;
352 }
353
354 /**
355  * Issue HCA command
356  *
357  * @v arbel             Arbel device
358  * @v command           Command opcode, flags and input/output lengths
359  * @v op_mod            Opcode modifier (0 if no modifier applicable)
360  * @v in                Input parameters
361  * @v in_mod            Input modifier (0 if no modifier applicable)
362  * @v out               Output parameters
363  * @ret rc              Return status code
364  */
365 static int arbel_cmd ( struct arbel *arbel, unsigned long command,
366                        unsigned int op_mod, const void *in,
367                        unsigned int in_mod, void *out ) {
368         struct arbelprm_hca_command_register hcr;
369         unsigned int opcode = ARBEL_HCR_OPCODE ( command );
370         size_t in_len = ARBEL_HCR_IN_LEN ( command );
371         size_t out_len = ARBEL_HCR_OUT_LEN ( command );
372         void *in_buffer;
373         void *out_buffer;
374         unsigned int status;
375         unsigned int i;
376         int rc;
377
378         DBGC ( arbel, "Arbel %p command %02x in %zx%s out %zx%s\n",
379                arbel, opcode, in_len,
380                ( ( command & ARBEL_HCR_IN_MBOX ) ? "(mbox)" : "" ), out_len,
381                ( ( command & ARBEL_HCR_OUT_MBOX ) ? "(mbox)" : "" ) );
382
383         /* Check that HCR is free */
384         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
385                 DBGC ( arbel, "Arbel %p command interface locked\n", arbel );
386                 return rc;
387         }
388
389         /* Prepare HCR */
390         memset ( &hcr, 0, sizeof ( hcr ) );
391         in_buffer = &hcr.u.dwords[0];
392         if ( in_len && ( command & ARBEL_HCR_IN_MBOX ) ) {
393                 in_buffer = arbel->mailbox_in;
394                 MLX_FILL_1 ( &hcr, 1, in_param_l, virt_to_bus ( in_buffer ) );
395         }
396         memcpy ( in_buffer, in, in_len );
397         MLX_FILL_1 ( &hcr, 2, input_modifier, in_mod );
398         out_buffer = &hcr.u.dwords[3];
399         if ( out_len && ( command & ARBEL_HCR_OUT_MBOX ) ) {
400                 out_buffer = arbel->mailbox_out;
401                 MLX_FILL_1 ( &hcr, 4, out_param_l,
402                              virt_to_bus ( out_buffer ) );
403         }
404         MLX_FILL_3 ( &hcr, 6,
405                      opcode, opcode,
406                      opcode_modifier, op_mod,
407                      go, 1 );
408
409         /* Issue command */
410         for ( i = 0 ; i < ( sizeof ( hcr ) / sizeof ( hcr.u.dwords[0] ) ) ;
411               i++ ) {
412                 writel ( hcr.u.dwords[i],
413                          arbel->config + ARBEL_HCR_REG ( i ) );
414                 barrier();
415         }
416
417         /* Wait for command completion */
418         if ( ( rc = arbel_cmd_wait ( arbel, &hcr ) ) != 0 ) {
419                 DBGC ( arbel, "Arbel %p timed out waiting for command:\n",
420                        arbel );
421                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
422                 return rc;
423         }
424
425         /* Check command status */
426         status = MLX_GET ( &hcr, status );
427         if ( status != 0 ) {
428                 DBGC ( arbel, "Arbel %p command failed with status %02x:\n",
429                        arbel, status );
430                 DBGC_HD ( arbel, &hcr, sizeof ( hcr ) );
431                 return -EIO;
432         }
433
434         /* Read output parameters, if any */
435         hcr.u.dwords[3] = readl ( arbel->config + ARBEL_HCR_REG ( 3 ) );
436         hcr.u.dwords[4] = readl ( arbel->config + ARBEL_HCR_REG ( 4 ) );
437         memcpy ( out, out_buffer, out_len );
438
439         return 0;
440 }
441
442 static inline int
443 arbel_cmd_query_dev_lim ( struct arbel *arbel,
444                           struct arbelprm_query_dev_lim *dev_lim ) {
445         return arbel_cmd ( arbel,
446                            ARBEL_HCR_OUT_CMD ( ARBEL_HCR_QUERY_DEV_LIM, 
447                                                1, sizeof ( *dev_lim ) ),
448                            0, NULL, 0, dev_lim );
449 }
450
451 static inline int
452 arbel_cmd_sw2hw_cq ( struct arbel *arbel, unsigned long cqn,
453                      const struct arbelprm_completion_queue_context *cqctx ) {
454         return arbel_cmd ( arbel,
455                            ARBEL_HCR_IN_CMD ( ARBEL_HCR_SW2HW_CQ,
456                                               1, sizeof ( *cqctx ) ),
457                            0, cqctx, cqn, NULL );
458 }
459
460 static inline int
461 arbel_cmd_hw2sw_cq ( struct arbel *arbel, unsigned long cqn ) {
462         return arbel_cmd ( arbel,
463                            ARBEL_HCR_VOID_CMD ( ARBEL_HCR_HW2SW_CQ ),
464                            1, NULL, cqn, NULL );
465 }
466
467 /***************************************************************************
468  *
469  * Completion queue operations
470  *
471  ***************************************************************************
472  */
473
474 /**
475  * Create completion queue
476  *
477  * @v ibdev             Infiniband device
478  * @v cq                Completion queue
479  * @ret rc              Return status code
480  */
481 static int arbel_create_cq ( struct ib_device *ibdev,
482                              struct ib_completion_queue *cq ) {
483         struct arbel *arbel = ibdev->dev_priv;
484         struct arbel_completion_queue *arbel_cq;
485         struct arbelprm_completion_queue_context cqctx;
486         struct arbelprm_cq_ci_db_record *ci_db_rec;
487         struct arbelprm_cq_arm_db_record *arm_db_rec;
488         int cqn_offset;
489         size_t cqe_size;
490         unsigned int i;
491         int rc;
492
493         /* Find a free completion queue number */
494         cqn_offset = arbel_alloc_qn_offset ( arbel->cq_inuse, ARBEL_MAX_CQS );
495         if ( cqn_offset < 0 ) {
496                 DBGC ( arbel, "Arbel %p out of completion queues\n", arbel );
497                 rc = cqn_offset;
498                 goto err_cqn_offset;
499         }
500         cq->cqn = ( arbel->limits.reserved_cqs + cqn_offset );
501
502         /* Allocate control structures */
503         arbel_cq = zalloc ( sizeof ( *arbel_cq ) );
504         if ( ! arbel_cq ) {
505                 rc = -ENOMEM;
506                 goto err_arbel_cq;
507         }
508         arbel_cq->ci_doorbell_idx = arbel_cq_ci_doorbell_idx ( cqn_offset );
509         arbel_cq->arm_doorbell_idx = arbel_cq_arm_doorbell_idx ( cqn_offset );
510
511         /* Allocate completion queue itself */
512         cqe_size = ( cq->num_cqes * sizeof ( arbel_cq->cqe[0] ) );
513         arbel_cq->cqe = malloc_dma ( cqe_size, sizeof ( arbel_cq->cqe[0] ) );
514         if ( ! arbel_cq->cqe ) {
515                 rc = -ENOMEM;
516                 goto err_cqe;
517         }
518         memset ( arbel_cq->cqe, 0, cqe_size );
519         for ( i = 0 ; i < cq->num_cqes ; i++ ) {
520                 MLX_FILL_1 ( &arbel_cq->cqe[i].normal, 7, owner, 1 );
521         }
522         barrier();
523
524         /* Initialise doorbell records */
525         ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
526         MLX_FILL_1 ( ci_db_rec, 0, counter, 0 );
527         MLX_FILL_2 ( ci_db_rec, 1,
528                      res, ARBEL_UAR_RES_CQ_CI,
529                      cq_number, cq->cqn );
530         arm_db_rec = &arbel->db_rec[arbel_cq->arm_doorbell_idx].cq_arm;
531         MLX_FILL_1 ( arm_db_rec, 0, counter, 0 );
532         MLX_FILL_2 ( arm_db_rec, 1,
533                      res, ARBEL_UAR_RES_CQ_ARM,
534                      cq_number, cq->cqn );
535
536         /* Hand queue over to hardware */
537         memset ( &cqctx, 0, sizeof ( cqctx ) );
538         MLX_FILL_1 ( &cqctx, 0, st, 0xa /* "Event fired" */ );
539         MLX_FILL_1 ( &cqctx, 2, start_address_l,
540                      virt_to_bus ( arbel_cq->cqe ) );
541 #if 0
542         MLX_FILL_2 ( &cqctx, 3,
543                      usr_page, arbel->limits.reserved_uars,
544                      log_cq_size, log2_num_cqes );
545 #endif
546         MLX_FILL_1 ( &cqctx, 5, c_eqn, arbel->eqn );
547         MLX_FILL_1 ( &cqctx, 6, pd, ARBEL_GLOBAL_PD );
548         MLX_FILL_1 ( &cqctx, 7, l_key, arbel->reserved_lkey );
549         MLX_FILL_1 ( &cqctx, 12, cqn, cq->cqn );
550         MLX_FILL_1 ( &cqctx, 13,
551                      cq_ci_db_record, arbel_cq->ci_doorbell_idx );
552         MLX_FILL_1 ( &cqctx, 14,
553                      cq_state_db_record, arbel_cq->arm_doorbell_idx );
554         if ( ( rc = arbel_cmd_sw2hw_cq ( arbel, cq->cqn, &cqctx ) ) != 0 ) {
555                 DBGC ( arbel, "Arbel %p SW2HW_CQ failed: %s\n",
556                        arbel, strerror ( rc ) );
557                 goto err_sw2hw;
558         }
559
560         cq->dev_priv = arbel_cq;
561         return 0;
562
563  err_sw2hw:
564         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
565         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
566         free_dma ( arbel_cq->cqe, cqe_size );
567  err_cqe:
568         free ( arbel_cq );
569  err_arbel_cq:
570         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
571  err_cqn_offset:
572         return rc;
573 }
574
575 /**
576  * Destroy completion queue
577  *
578  * @v ibdev             Infiniband device
579  * @v cq                Completion queue
580  */
581 static void arbel_destroy_cq ( struct ib_device *ibdev,
582                                struct ib_completion_queue *cq ) {
583         struct arbel *arbel = ibdev->dev_priv;
584         struct arbel_completion_queue *arbel_cq = cq->dev_priv;
585         struct arbelprm_cq_ci_db_record *ci_db_rec;
586         struct arbelprm_cq_arm_db_record *arm_db_rec;
587         int cqn_offset;
588         size_t cqe_size;
589         unsigned int ci_doorbell_idx;
590         unsigned int arm_doorbell_idx;
591         int rc;
592
593         assert ( list_empty ( &cq->work_queues ) );
594
595         /* Take ownership back from hardware */
596         if ( ( rc = arbel_cmd_hw2sw_cq ( arbel, cq->cqn ) ) != 0 ) {
597                 DBGC ( arbel, "Arbel %p FATAL HW2SW_CQ failed: %s\n",
598                        arbel, strerror ( rc ) );
599                 /* Leak memory and return; at least we avoid corruption */
600                 return;
601         }
602
603         /* Clear doorbell records */
604         cqn_offset = ( cq->cqn - arbel->limits.reserved_cqs );
605         ci_doorbell_idx = arbel_cq_ci_doorbell_idx ( cqn_offset );
606         arm_doorbell_idx = arbel_cq_arm_doorbell_idx ( cqn_offset );
607         ci_db_rec = &arbel->db_rec[ci_doorbell_idx].cq_ci;
608         arm_db_rec = &arbel->db_rec[arm_doorbell_idx].cq_arm;
609         MLX_FILL_1 ( ci_db_rec, 1, res, ARBEL_UAR_RES_NONE );
610         MLX_FILL_1 ( arm_db_rec, 1, res, ARBEL_UAR_RES_NONE );
611
612         /* Free memory */
613         cqe_size = ( cq->num_cqes * sizeof ( arbel_cq->cqe[0] ) );
614         free_dma ( arbel_cq->cqe, cqe_size );
615         free ( arbel_cq );
616         arbel_free_qn_offset ( arbel->cq_inuse, cqn_offset );
617 }
618
619 /***************************************************************************
620  *
621  * Queue pair operations
622  *
623  ***************************************************************************
624  */
625
626 static int arbel_create_qp ( struct ib_device *ibdev,
627                              unsigned int log2_num_send_wqes,
628                              struct ib_completion_queue *send_cq,
629                              unsigned int log2_num_recv_wqes,
630                              struct ib_completion_queue *recv_cq,
631                              struct ib_queue_pair **new_qp ) {
632         struct arbel *arbel = ibdev->dev_priv;
633         struct arbel_queue_pair *arbel_qp;
634         struct arbelprm_qp_db_record *send_db_rec;
635         struct arbelprm_qp_db_record *recv_db_rec;
636         int qpn_offset;
637         unsigned int qpn;
638         unsigned int num_send_wqes;
639         unsigned int num_recv_wqes;
640         unsigned int send_doorbell_idx;
641         unsigned int recv_doorbell_idx;
642         int rc;
643
644         /* Find a free queue pair number */
645         qpn_offset = arbel_alloc_qn_offset ( arbel->qp_inuse, ARBEL_MAX_QPS );
646         if ( qpn_offset < 0 ) {
647                 DBGC ( arbel, "Arbel %p out of queue pairs\n", arbel );
648                 rc = qpn_offset;
649                 goto err_qpn_offset;
650         }
651         qpn = ( ARBEL_QPN_BASE + arbel->limits.reserved_qps + qpn_offset );
652         send_doorbell_idx = arbel_send_doorbell_idx ( qpn_offset );
653         recv_doorbell_idx = arbel_recv_doorbell_idx ( qpn_offset );
654
655         /* Allocate control structures */
656         num_send_wqes = ( 1 << log2_num_send_wqes );
657         num_recv_wqes = ( 1 << log2_num_recv_wqes );
658         arbel_qp = zalloc ( sizeof ( *arbel_qp ) );
659
660         return 0;
661
662  err_qpn_offset:
663         return rc;
664 }
665
666 /***************************************************************************
667  *
668  * Work request operations
669  *
670  ***************************************************************************
671  */
672
673 /**
674  * Ring doorbell register in UAR
675  *
676  * @v arbel             Arbel device
677  * @v db_reg            Doorbell register structure
678  * @v offset            Address of doorbell
679  */
680 static void arbel_ring_doorbell ( struct arbel *arbel,
681                                   union arbelprm_doorbell_register *db_reg,
682                                   unsigned int offset ) {
683
684         DBG ( "arbel_ring_doorbell %08lx:%08lx to %lx\n",
685               db_reg->dword[0], db_reg->dword[1],
686               virt_to_phys ( arbel->uar + offset ) );
687
688         barrier();
689         writel ( db_reg->dword[0], ( arbel->uar + offset + 0 ) );
690         barrier();
691         writel ( db_reg->dword[1], ( arbel->uar + offset + 4 ) );
692 }
693
694 /**
695  * Post send work queue entry
696  *
697  * @v ibdev             Infiniband device
698  * @v qp                Queue pair
699  * @v av                Address vector
700  * @v iobuf             I/O buffer
701  * @ret rc              Return status code
702  */
703 static int arbel_post_send ( struct ib_device *ibdev,
704                              struct ib_queue_pair *qp,
705                              struct ib_address_vector *av,
706                              struct io_buffer *iobuf ) {
707         struct arbel *arbel = ibdev->dev_priv;
708         struct arbel_queue_pair *arbel_qp = qp->dev_priv;
709         struct ib_work_queue *wq = &qp->send;
710         struct arbel_send_work_queue *arbel_send_wq = &arbel_qp->send;
711         struct arbelprm_ud_send_wqe *prev_wqe;
712         struct arbelprm_ud_send_wqe *wqe;
713         struct arbelprm_qp_db_record *qp_db_rec;
714         union arbelprm_doorbell_register db_reg;
715         const struct ib_gid *gid;
716         unsigned int wqe_idx_mask;
717         size_t nds;
718
719         /* Allocate work queue entry */
720         wqe_idx_mask = ( wq->num_wqes - 1 );
721         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
722                 DBGC ( arbel, "Arbel %p send queue full", arbel );
723                 return -ENOBUFS;
724         }
725         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
726         prev_wqe = &arbel_send_wq->wqe[(wq->next_idx - 1) & wqe_idx_mask].ud;
727         wqe = &arbel_send_wq->wqe[wq->next_idx & wqe_idx_mask].ud;
728
729         /* Construct work queue entry */
730         MLX_FILL_1 ( &wqe->next, 1, always1, 1 );
731         memset ( &wqe->ctrl, 0, sizeof ( wqe->ctrl ) );
732         MLX_FILL_1 ( &wqe->ctrl, 0, always1, 1 );
733         memset ( &wqe->ud, 0, sizeof ( wqe->ud ) );
734         MLX_FILL_2 ( &wqe->ud, 0,
735                      ud_address_vector.pd, ARBEL_GLOBAL_PD,
736                      ud_address_vector.port_number, PXE_IB_PORT );
737         MLX_FILL_2 ( &wqe->ud, 1,
738                      ud_address_vector.rlid, av->dlid,
739                      ud_address_vector.g, av->gid_present );
740         MLX_FILL_2 ( &wqe->ud, 2,
741                      ud_address_vector.max_stat_rate,
742                          ( ( av->rate >= 3 ) ? 0 : 1 ),
743                      ud_address_vector.msg, 3 );
744         MLX_FILL_1 ( &wqe->ud, 3, ud_address_vector.sl, av->sl );
745         gid = ( av->gid_present ? &av->gid : &arbel_no_gid );
746         memcpy ( &wqe->ud.u.dwords[4], gid, sizeof ( *gid ) );
747         MLX_FILL_1 ( &wqe->ud, 8, destination_qp, av->dest_qp );
748         MLX_FILL_1 ( &wqe->ud, 9, q_key, av->qkey );
749         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_len ( iobuf ) );
750         MLX_FILL_1 ( &wqe->data[0], 3,
751                      local_address_l, virt_to_bus ( iobuf->data ) );
752
753         /* Update previous work queue entry's "next" field */
754         nds = ( ( offsetof ( typeof ( *wqe ), data ) +
755                   sizeof ( wqe->data[0] ) ) >> 4 );
756         MLX_SET ( &prev_wqe->next, nopcode, ARBEL_OPCODE_SEND );
757         MLX_FILL_3 ( &prev_wqe->next, 1,
758                      nds, nds,
759                      f, 1,
760                      always1, 1 );
761
762         /* Update doorbell record */
763         barrier();
764         qp_db_rec = &arbel->db_rec[arbel_send_wq->doorbell_idx].qp;
765         MLX_FILL_1 ( qp_db_rec, 0,
766                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );
767
768         /* Ring doorbell register */
769         MLX_FILL_4 ( &db_reg.send, 0,
770                      nopcode, ARBEL_OPCODE_SEND,
771                      f, 1,
772                      wqe_counter, ( wq->next_idx & 0xffff ),
773                      wqe_cnt, 1 );
774         MLX_FILL_2 ( &db_reg.send, 1,
775                      nds, nds,
776                      qpn, qp->qpn );
777         arbel_ring_doorbell ( arbel, &db_reg, POST_SND_OFFSET );
778
779         /* Update work queue's index */
780         wq->next_idx++;
781
782         return 0;
783 }
784
785 /**
786  * Post receive work queue entry
787  *
788  * @v ibdev             Infiniband device
789  * @v qp                Queue pair
790  * @v iobuf             I/O buffer
791  * @ret rc              Return status code
792  */
793 static int arbel_post_recv ( struct ib_device *ibdev,
794                              struct ib_queue_pair *qp,
795                              struct io_buffer *iobuf ) {
796         struct arbel *arbel = ibdev->dev_priv;
797         struct arbel_queue_pair *arbel_qp = qp->dev_priv;
798         struct ib_work_queue *wq = &qp->recv;
799         struct arbel_recv_work_queue *arbel_recv_wq = &arbel_qp->recv;
800         struct arbelprm_recv_wqe *wqe;
801         union arbelprm_doorbell_record *db_rec;
802         unsigned int wqe_idx_mask;
803
804         /* Allocate work queue entry */
805         wqe_idx_mask = ( wq->num_wqes - 1 );
806         if ( wq->iobufs[wq->next_idx & wqe_idx_mask] ) {
807                 DBGC ( arbel, "Arbel %p receive queue full", arbel );
808                 return -ENOBUFS;
809         }
810         wq->iobufs[wq->next_idx & wqe_idx_mask] = iobuf;
811         wqe = &arbel_recv_wq->wqe[wq->next_idx & wqe_idx_mask].recv;
812
813         /* Construct work queue entry */
814         MLX_FILL_1 ( &wqe->data[0], 0, byte_count, iob_tailroom ( iobuf ) );
815         MLX_FILL_1 ( &wqe->data[0], 1, l_key, arbel->reserved_lkey );
816         MLX_FILL_1 ( &wqe->data[0], 3,
817                      local_address_l, virt_to_bus ( iobuf->data ) );
818
819         /* Update doorbell record */
820         barrier();
821         db_rec = &arbel->db_rec[arbel_recv_wq->doorbell_idx];
822         MLX_FILL_1 ( &db_rec->qp, 0,
823                      counter, ( ( wq->next_idx + 1 ) & 0xffff ) );      
824
825         /* Update work queue's index */
826         wq->next_idx++;
827
828         return 0;       
829 }
830
831 /**
832  * Handle completion
833  *
834  * @v ibdev             Infiniband device
835  * @v cq                Completion queue
836  * @v cqe               Hardware completion queue entry
837  * @v complete_send     Send completion handler
838  * @v complete_recv     Receive completion handler
839  * @ret rc              Return status code
840  */
841 static int arbel_complete ( struct ib_device *ibdev,
842                             struct ib_completion_queue *cq,
843                             union arbelprm_completion_entry *cqe,
844                             ib_completer_t complete_send,
845                             ib_completer_t complete_recv ) {
846         struct arbel *arbel = ibdev->dev_priv;
847         struct ib_completion completion;
848         struct ib_work_queue *wq;
849         struct ib_queue_pair *qp;
850         struct arbel_queue_pair *arbel_qp;
851         struct arbel_send_work_queue *arbel_send_wq;
852         struct arbel_recv_work_queue *arbel_recv_wq;
853         struct io_buffer *iobuf;
854         ib_completer_t complete;
855         unsigned int opcode;
856         unsigned long qpn;
857         int is_send;
858         unsigned long wqe_adr;
859         unsigned int wqe_idx;
860         int rc = 0;
861
862         /* Parse completion */
863         memset ( &completion, 0, sizeof ( completion ) );
864         completion.len = MLX_GET ( &cqe->normal, byte_cnt );
865         qpn = MLX_GET ( &cqe->normal, my_qpn );
866         is_send = MLX_GET ( &cqe->normal, s );
867         wqe_adr = ( MLX_GET ( &cqe->normal, wqe_adr ) << 6 );
868         opcode = MLX_GET ( &cqe->normal, opcode );
869         if ( opcode >= ARBEL_OPCODE_RECV_ERROR ) {
870                 /* "s" field is not valid for error opcodes */
871                 is_send = ( opcode == ARBEL_OPCODE_SEND_ERROR );
872                 completion.syndrome = MLX_GET ( &cqe->error, syndrome );
873                 DBGC ( arbel, "Arbel %p CPN %lx syndrome %x vendor %lx\n",
874                        arbel, cq->cqn, completion.syndrome,
875                        MLX_GET ( &cqe->error, vendor_code ) );
876                 rc = -EIO;
877                 /* Don't return immediately; propagate error to completer */
878         }
879
880         /* Identify work queue */
881         wq = ib_find_wq ( cq, qpn, is_send );
882         if ( ! wq ) {
883                 DBGC ( arbel, "Arbel %p CQN %lx unknown %s QPN %lx\n",
884                        arbel, cq->cqn, ( is_send ? "send" : "recv" ), qpn );
885                 return -EIO;
886         }
887         qp = wq->qp;
888         arbel_qp = qp->dev_priv;
889
890         /* Identify work queue entry index */
891         if ( is_send ) {
892                 arbel_send_wq = &arbel_qp->send;
893                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_send_wq->wqe ) ) /
894                             sizeof ( arbel_send_wq->wqe[0] ) );
895         } else {
896                 arbel_recv_wq = &arbel_qp->recv;
897                 wqe_idx = ( ( wqe_adr - virt_to_bus ( arbel_recv_wq->wqe ) ) /
898                             sizeof ( arbel_recv_wq->wqe[0] ) );
899         }
900
901         /* Identify I/O buffer */
902         iobuf = wq->iobufs[wqe_idx];
903         if ( ! iobuf ) {
904                 DBGC ( arbel, "Arbel %p CQN %lx QPN %lx empty WQE %x\n",
905                        arbel, cq->cqn, qpn, wqe_idx );
906                 return -EIO;
907         }
908         wq->iobufs[wqe_idx] = NULL;
909
910         /* Pass off to caller's completion handler */
911         complete = ( is_send ? complete_send : complete_recv );
912         complete ( ibdev, qp, &completion, iobuf );
913
914         return rc;
915 }                            
916
917 /**
918  * Poll completion queue
919  *
920  * @v ibdev             Infiniband device
921  * @v cq                Completion queue
922  * @v complete_send     Send completion handler
923  * @v complete_recv     Receive completion handler
924  */
925 static void arbel_poll_cq ( struct ib_device *ibdev,
926                             struct ib_completion_queue *cq,
927                             ib_completer_t complete_send,
928                             ib_completer_t complete_recv ) {
929         struct arbel *arbel = ibdev->dev_priv;
930         struct arbel_completion_queue *arbel_cq = cq->dev_priv;
931         struct arbelprm_cq_ci_db_record *ci_db_rec;
932         union arbelprm_completion_entry *cqe;
933         unsigned int cqe_idx_mask;
934         int rc;
935
936         while ( 1 ) {
937                 /* Look for completion entry */
938                 cqe_idx_mask = ( cq->num_cqes - 1 );
939                 cqe = &arbel_cq->cqe[cq->next_idx & cqe_idx_mask];
940                 if ( MLX_GET ( &cqe->normal, owner ) != 0 ) {
941                         /* Entry still owned by hardware; end of poll */
942                         break;
943                 }
944
945                 /* Handle completion */
946                 if ( ( rc = arbel_complete ( ibdev, cq, cqe, complete_send,
947                                              complete_recv ) ) != 0 ) {
948                         DBGC ( arbel, "Arbel %p failed to complete: %s\n",
949                                arbel, strerror ( rc ) );
950                         DBGC_HD ( arbel, cqe, sizeof ( *cqe ) );
951                 }
952
953                 /* Return ownership to hardware */
954                 MLX_FILL_1 ( &cqe->normal, 7, owner, 1 );
955                 barrier();
956                 /* Update completion queue's index */
957                 cq->next_idx++;
958                 /* Update doorbell record */
959                 ci_db_rec = &arbel->db_rec[arbel_cq->ci_doorbell_idx].cq_ci;
960                 MLX_FILL_1 ( ci_db_rec, 0,
961                              counter, ( cq->next_idx & 0xffffffffUL ) );
962         }
963 }
964
965 /** Arbel Infiniband operations */
966 static struct ib_device_operations arbel_ib_operations = {
967         .create_cq      = arbel_create_cq,
968         .destroy_cq     = arbel_destroy_cq,
969         .post_send      = arbel_post_send,
970         .post_recv      = arbel_post_recv,
971         .poll_cq        = arbel_poll_cq,
972 };
973
974 /**
975  * Remove PCI device
976  *
977  * @v pci               PCI device
978  */
979 static void arbel_remove ( struct pci_device *pci ) {
980         struct net_device *netdev = pci_get_drvdata ( pci );
981
982         unregister_netdev ( netdev );
983         ib_driver_close ( 0 );
984         netdev_nullify ( netdev );
985         netdev_put ( netdev );
986 }
987
988 /**
989  * Probe PCI device
990  *
991  * @v pci               PCI device
992  * @v id                PCI ID
993  * @ret rc              Return status code
994  */
995 static int arbel_probe ( struct pci_device *pci,
996                          const struct pci_device_id *id __unused ) {
997         struct net_device *netdev;
998         struct arbelprm_query_dev_lim dev_lim;
999         struct arbel *arbel = &static_arbel;
1000         struct mlx_nic *mlx;
1001         struct ib_mac *mac;
1002         udqp_t qph;
1003         int rc;
1004
1005         /* Allocate net device */
1006         netdev = alloc_ibdev ( sizeof ( *mlx ) );
1007         if ( ! netdev )
1008                 return -ENOMEM;
1009         netdev_init ( netdev, &mlx_operations );
1010         mlx = netdev->priv;
1011         pci_set_drvdata ( pci, netdev );
1012         netdev->dev = &pci->dev;
1013         memset ( mlx, 0, sizeof ( *mlx ) );
1014
1015         /* Fix up PCI device */
1016         adjust_pci_device ( pci );
1017
1018         /* Initialise hardware */
1019         if ( ( rc = ib_driver_init ( pci, &qph ) ) != 0 )
1020                 goto err_ipoib_init;
1021         mlx->ipoib_qph = qph;
1022         mlx->bcast_av = ib_data.bcast_av;
1023         mlx->snd_cqh = ib_data.ipoib_snd_cq;
1024         mlx->rcv_cqh = ib_data.ipoib_rcv_cq;
1025         mac = ( ( struct ib_mac * ) netdev->ll_addr );
1026         mac->qpn = htonl ( ib_get_qpn ( mlx->ipoib_qph ) );
1027         memcpy ( &mac->gid, ib_data.port_gid.raw, sizeof ( mac->gid ) );
1028
1029         /* Hack up IB structures */
1030         arbel->config = memfree_pci_dev.cr_space;
1031         arbel->mailbox_in = dev_buffers_p->inprm_buf;
1032         arbel->mailbox_out = dev_buffers_p->outprm_buf;
1033         arbel->uar = memfree_pci_dev.uar;
1034         arbel->db_rec = dev_ib_data.uar_context_base;
1035         arbel->reserved_lkey = dev_ib_data.mkey;
1036         arbel->eqn = dev_ib_data.eq.eqn;
1037         static_arbel_ipoib_qp.send.wqe =
1038                 ( ( struct udqp_st * ) qph )->snd_wq;
1039         static_arbel_ipoib_qp.recv.wqe =
1040                 ( ( struct udqp_st * ) qph )->rcv_wq;
1041         static_arbel_ipoib_send_cq.cqe =
1042                 ( ( struct cq_st * ) ib_data.ipoib_snd_cq )->cq_buf;
1043         static_arbel_ipoib_recv_cq.cqe =
1044                 ( ( struct cq_st * ) ib_data.ipoib_rcv_cq )->cq_buf;
1045         static_ipoib_qp.qpn = ib_get_qpn ( qph );
1046         static_ipoib_qp.owner_priv = netdev;
1047         list_add ( &static_ipoib_qp.send.list,
1048                    &static_ipoib_send_cq.work_queues );
1049         list_add ( &static_ipoib_qp.recv.list,
1050                    &static_ipoib_recv_cq.work_queues );
1051
1052         /* Get device limits */
1053         if ( ( rc = arbel_cmd_query_dev_lim ( arbel, &dev_lim ) ) != 0 ) {
1054                 DBGC ( arbel, "Arbel %p could not get device limits: %s\n",
1055                        arbel, strerror ( rc ) );
1056                 goto err_query_dev_lim;
1057         }
1058         arbel->limits.reserved_uars = MLX_GET ( &dev_lim, num_rsvd_uars );
1059         arbel->limits.reserved_cqs =
1060                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_cqs ) );
1061         arbel->limits.reserved_qps =
1062                 ( 1 << MLX_GET ( &dev_lim, log2_rsvd_qps ) );
1063         DBG ( "Device limits:\n ");
1064         DBG_HD ( &dev_lim, sizeof ( dev_lim ) );
1065
1066         /* Register network device */
1067         if ( ( rc = register_netdev ( netdev ) ) != 0 )
1068                 goto err_register_netdev;
1069
1070         return 0;
1071
1072  err_query_dev_lim:
1073  err_register_netdev:
1074  err_ipoib_init:
1075         ib_driver_close ( 0 );
1076         netdev_nullify ( netdev );
1077         netdev_put ( netdev );
1078         return rc;
1079 }
1080
1081 static struct pci_device_id arbel_nics[] = {
1082         PCI_ROM ( 0x15b3, 0x6282, "MT25218", "MT25218 HCA driver" ),
1083         PCI_ROM ( 0x15b3, 0x6274, "MT25204", "MT25204 HCA driver" ),
1084 };
1085
1086 struct pci_driver arbel_driver __pci_driver = {
1087         .ids = arbel_nics,
1088         .id_count = ( sizeof ( arbel_nics ) / sizeof ( arbel_nics[0] ) ),
1089         .probe = arbel_probe,
1090         .remove = arbel_remove,
1091 };