Now handling TX completions in our poll loop.
[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/iobuf.h>
16 #include <gpxe/netdevice.h>
17 #include <gpxe/infiniband.h>
18
19 /* to get some global routines like printf */
20 #include "etherboot.h"
21 /* to get the interface to the body of the program */
22 #include "nic.h"
23
24 #include "mt_version.c"
25 #include "mt25218_imp.c"
26
27 struct mlx_nic {
28         /** Queue pair handle */
29         udqp_t ipoib_qph;
30         /** Broadcast Address Vector */
31         ud_av_t bcast_av;
32         /** Send completion queue */
33         cq_t snd_cqh;
34         /** Receive completion queue */
35         cq_t rcv_cqh;
36 };
37
38 int prompt_key(int secs, unsigned char *ch_p)
39 {
40         unsigned long tmo;
41         unsigned char ch;
42
43         for (tmo = currticks() + secs * TICKS_PER_SEC; currticks() < tmo;) {
44                 if (iskey()) {
45                         ch = getchar();
46                         /* toupper does not work ... */
47                         if (ch == 'v')
48                                 ch = 'V';
49                         if (ch == 'i')
50                                 ch = 'I';
51                         if ((ch=='V') || (ch=='I')) {
52                                 *ch_p = ch;
53                                 return 1;
54                         }
55                 }
56         }
57
58         return 0;
59 }
60
61 #if 0
62 /**************************************************************************
63 IRQ - handle interrupts
64 ***************************************************************************/
65 static void mt25218_irq(struct nic *nic, irq_action_t action)
66 {
67         /* This routine is somewhat optional.  Etherboot itself
68          * doesn't use interrupts, but they are required under some
69          * circumstances when we're acting as a PXE stack.
70          *
71          * If you don't implement this routine, the only effect will
72          * be that your driver cannot be used via Etherboot's UNDI
73          * API.  This won't affect programs that use only the UDP
74          * portion of the PXE API, such as pxelinux.
75          */
76
77         if (0) {
78                 nic = NULL;
79         }
80         switch (action) {
81         case DISABLE:
82         case ENABLE:
83                 /* Set receive interrupt enabled/disabled state */
84                 /*
85                    outb ( action == ENABLE ? IntrMaskEnabled : IntrMaskDisabled,
86                    nic->ioaddr + IntrMaskRegister );
87                  */
88                 break;
89         case FORCE:
90                 /* Force NIC to generate a receive interrupt */
91                 /*
92                    outb ( ForceInterrupt, nic->ioaddr + IntrForceRegister );
93                  */
94                 break;
95         }
96 }
97
98 /**************************************************************************
99 POLL - Wait for a frame
100 ***************************************************************************/
101 static int mt25218_poll(struct nic *nic, int retrieve)
102 {
103         /* Work out whether or not there's an ethernet packet ready to
104          * read.  Return 0 if not.
105          */
106         /* 
107            if ( ! <packet_ready> ) return 0;
108          */
109
110         /* retrieve==0 indicates that we are just checking for the
111          * presence of a packet but don't want to read it just yet.
112          */
113         /*
114            if ( ! retrieve ) return 1;
115          */
116
117         /* Copy data to nic->packet.  Data should include the
118          * link-layer header (dest MAC, source MAC, type).
119          * Store length of data in nic->packetlen.
120          * Return true to indicate a packet has been read.
121          */
122         /* 
123            nic->packetlen = <packet_length>;
124            memcpy ( nic->packet, <packet_data>, <packet_length> );
125            return 1;
126          */
127         unsigned int size;
128         int rc;
129         rc = poll_imp(nic, retrieve, &size);
130         if (rc) {
131                 return 0;
132         }
133
134         if (size == 0) {
135                 return 0;
136         }
137
138         nic->packetlen = size;
139
140         return 1;
141 }
142
143 /**************************************************************************
144 TRANSMIT - Transmit a frame
145 ***************************************************************************/
146 static void mt25218_transmit(struct nic *nic, const char *dest, /* Destination */
147                              unsigned int type, /* Type */
148                              unsigned int size, /* size */
149                              const char *packet)
150 {                               /* Packet */
151         int rc;
152
153         /* Transmit packet to dest MAC address.  You will need to
154          * construct the link-layer header (dest MAC, source MAC,
155          * type).
156          */
157         if (nic) {
158                 rc = transmit_imp(dest, type, packet, size);
159                 if (rc)
160                         eprintf("tranmit error");
161         }
162 }
163 #endif
164
165 /**
166  * Open network device
167  *
168  * @v netdev            Network device
169  * @ret rc              Return status code
170  */
171 static int mlx_open ( struct net_device *netdev ) {
172
173         ( void ) netdev;
174
175         return 0;
176 }
177
178 /**
179  * Close network device
180  *
181  * @v netdev            Network device
182  */
183 static void mlx_close ( struct net_device *netdev ) {
184
185         ( void ) netdev;
186
187 }
188
189 #warning "Broadcast address?"
190 static uint8_t ib_broadcast[IB_ALEN] = { 0xff, };
191
192
193 /**
194  * Transmit packet
195  *
196  * @v netdev            Network device
197  * @v iobuf             I/O buffer
198  * @ret rc              Return status code
199  */
200 static int mlx_transmit ( struct net_device *netdev,
201                           struct io_buffer *iobuf ) {
202         struct mlx_nic *mlx = netdev->priv;
203         ud_send_wqe_t snd_wqe;
204         int rc;
205
206         snd_wqe = alloc_send_wqe ( mlx->ipoib_qph );
207         if ( ! snd_wqe ) {
208                 DBGC ( mlx, "MLX %p out of TX WQEs\n", mlx );
209                 return -ENOBUFS;
210         }
211
212         prep_send_wqe_buf ( mlx->ipoib_qph, mlx->bcast_av, snd_wqe,
213                             iobuf->data, 0, iob_len ( iobuf ), 0 );
214         if ( ( rc = post_send_req ( mlx->ipoib_qph, snd_wqe, 1 ) ) != 0 ) {
215                 DBGC ( mlx, "MLX %p could not post TX WQE %p: %s\n",
216                        mlx, snd_wqe, strerror ( rc ) );
217                 free_wqe ( snd_wqe );
218                 return rc;
219         }
220
221         return 0;
222
223 #if 0
224         ( void ) netdev;
225
226         iob_pull ( iobuf, sizeof ( *ibhdr ) );  
227
228         if ( memcmp ( ibhdr->peer, ib_broadcast, IB_ALEN ) == 0 ) {
229                 printf ( "Sending broadcast packet\n" );
230                 return send_bcast_packet ( ntohs ( ibhdr->proto ),
231                                            iobuf->data, iob_len ( iobuf ) );
232         } else {
233                 printf ( "Sending unicast packet\n" );
234                 return send_ucast_packet ( ibhdr->peer,
235                                            ntohs ( ibhdr->proto ),
236                                            iobuf->data, iob_len ( iobuf ) );
237         }
238 #endif
239 }
240
241 /**
242  * Handle TX completion
243  *
244  * @v netdev            Network device
245  * @v ib_cqe            Completion queue entry
246  */
247 static void mlx_tx_complete ( struct net_device *netdev,
248                               struct ib_cqe_st *ib_cqe ) {
249         netdev_tx_complete_next_err ( netdev,
250                                       ( ib_cqe->is_error ? -EIO : 0 ) );
251 }
252
253 /**
254  * Handle RX completion
255  *
256  * @v netdev            Network device
257  * @v ib_cqe            Completion queue entry
258  */
259 static void mlx_rx_complete ( struct net_device *netdev,
260                               struct ib_cqe_st *ib_cqe ) {
261         unsigned int len;
262         struct io_buffer *iobuf;
263         void *buf;
264
265         /* Check for errors */
266         if ( ib_cqe->is_error ) {
267                 netdev_rx_err ( netdev, NULL, -EIO );
268                 return;
269         }
270
271         /* Allocate I/O buffer */
272         len = ( ib_cqe->count - GRH_SIZE );
273         iobuf = alloc_iob ( len );
274         if ( ! iobuf ) {
275                 netdev_rx_err ( netdev, NULL, -ENOMEM );
276                 return;
277         }
278         buf = get_rcv_wqe_buf ( ib_cqe->wqe, 1 );
279         memcpy ( iob_put ( iobuf, len ), buf, len );
280         //      DBG ( "Received packet header:\n" );
281         //      struct recv_wqe_st *rcv_wqe = ib_cqe.wqe;
282         //      DBG_HD ( get_rcv_wqe_buf(ib_cqe.wqe, 0),
283         //               be32_to_cpu(rcv_wqe->mpointer[0].byte_count) );
284         //      DBG ( "Received packet:\n" );
285         //      DBG_HD ( iobuf->data, iob_len ( iobuf ) );
286         netdev_rx ( netdev, iobuf );
287 }
288
289 /**
290  * Poll completion queue
291  *
292  * @v netdev            Network device
293  * @v cq                Completion queue
294  * @v handler           Completion handler
295  */
296 static void mlx_poll_cq ( struct net_device *netdev, cq_t cq,
297                           void ( * handler ) ( struct net_device *netdev,
298                                                struct ib_cqe_st *ib_cqe ) ) {
299         struct mlx_nic *mlx = netdev->priv;
300         struct ib_cqe_st ib_cqe;
301         uint8_t num_cqes;
302
303         while ( 1 ) {
304
305                 /* Poll for single completion queue entry */
306                 ib_poll_cq ( cq, &ib_cqe, &num_cqes );
307
308                 /* Return if no entries in the queue */
309                 if ( ! num_cqes )
310                         return;
311
312                 DBGC ( mlx, "MLX %p cpl in %p: err %x send %x "
313                        "wqe %p count %lx\n", mlx, cq, ib_cqe.is_error,
314                        ib_cqe.is_send, ib_cqe.wqe, ib_cqe.count );
315
316                 /* Handle TX/RX completion */
317                 handler ( netdev, &ib_cqe );
318
319                 /* Free associated work queue entry */
320                 free_wqe ( ib_cqe.wqe );
321         }
322 }
323
324 /**
325  * Poll for completed and received packets
326  *
327  * @v netdev            Network device
328  */
329 static void mlx_poll ( struct net_device *netdev ) {
330         struct mlx_nic *mlx = netdev->priv;
331         int rc;
332
333         if ( ( rc = poll_error_buf() ) != 0 ) {
334                 DBG ( "poll_error_buf() failed: %s\n", strerror ( rc ) );
335                 return;
336         }
337
338         if ( ( rc = drain_eq() ) != 0 ) {
339                 DBG ( "drain_eq() failed: %s\n", strerror ( rc ) );
340                 return;
341         }
342
343         mlx_poll_cq ( netdev, mlx->snd_cqh, mlx_tx_complete );
344         mlx_poll_cq ( netdev, mlx->rcv_cqh, mlx_rx_complete );
345 }
346
347 /**
348  * Enable or disable interrupts
349  *
350  * @v netdev            Network device
351  * @v enable            Interrupts should be enabled
352  */
353 static void mlx_irq ( struct net_device *netdev, int enable ) {
354
355         ( void ) netdev;
356         ( void ) enable;
357
358 }
359
360 static struct net_device_operations mlx_operations = {
361         .open           = mlx_open,
362         .close          = mlx_close,
363         .transmit       = mlx_transmit,
364         .poll           = mlx_poll,
365         .irq            = mlx_irq,
366 };
367
368 #if 0
369 /**************************************************************************
370 DISABLE - Turn off ethernet interface
371 ***************************************************************************/
372 static void mt25218_disable(struct nic *nic)
373 {
374         /* put the card in its initial state */
375         /* This function serves 3 purposes.
376          * This disables DMA and interrupts so we don't receive
377          *  unexpected packets or interrupts from the card after
378          *  etherboot has finished. 
379          * This frees resources so etherboot may use
380          *  this driver on another interface
381          * This allows etherboot to reinitialize the interface
382          *  if something is something goes wrong.
383          */
384         if (nic || 1) {         // ????
385                 disable_imp();
386         }
387 }
388 #endif
389
390 /**
391  * Remove PCI device
392  *
393  * @v pci               PCI device
394  */
395 static void mlx_remove ( struct pci_device *pci ) {
396         struct net_device *netdev = pci_get_drvdata ( pci );
397
398         unregister_netdev ( netdev );
399         ib_driver_close ( 0 );
400         netdev_nullify ( netdev );
401         netdev_put ( netdev );
402 }
403
404 #if 0
405 static struct nic_operations mt25218_operations = {
406         .connect        = dummy_connect,
407         .poll           = mt25218_poll,
408         .transmit       = mt25218_transmit,
409         .irq            = mt25218_irq,
410 };
411
412 /**************************************************************************
413 PROBE - Look for an adapter, this routine's visible to the outside
414 ***************************************************************************/
415
416 static int mt25218_probe(struct nic *nic, struct pci_device *pci)
417 {
418         int rc;
419         unsigned char user_request;
420
421         if (pci->vendor != MELLANOX_VENDOR_ID) {
422                 eprintf("");
423                 return 0;
424         }
425
426         printf("\n");
427         printf("Mellanox Technologies LTD - Boot over IB implementaion\n");
428         printf("Build version = %s\n\n", build_revision);
429
430         verbose_messages = 0;
431         print_info = 0;
432         printf("Press within 3 seconds:\n");
433         printf("V - to increase verbosity\n");
434         printf("I - to print information\n");
435         if (prompt_key(3, &user_request)) {
436                 if (user_request == 'V') {
437                         printf("User selected verbose messages\n");
438                         verbose_messages = 1;
439                 }
440                 else if (user_request == 'I') {
441                         printf("User selected to print information\n");
442                         print_info = 1;
443                 }
444         }
445         printf("\n");
446
447         adjust_pci_device(pci);
448
449         nic->priv_data = NULL;
450         rc = probe_imp(pci, nic);
451
452         /* give the user a chance to look at the info */
453         if (print_info)
454                 sleep(5);
455
456         if (!rc) {
457                 /* store NIC parameters */
458                 nic->ioaddr = pci->ioaddr & ~3;
459                 nic->irqno = pci->irq;
460                 /* point to NIC specific routines */
461                 nic->nic_op = &mt25218_operations;
462
463                 uint8_t fixed_node_addr[ETH_ALEN] = { 0x00, 0x02, 0xc9,
464                                                       0x20, 0xf5, 0x95 };
465                 memcpy ( nic->node_addr, fixed_node_addr, ETH_ALEN );
466
467                 return 1;
468         }
469         /* else */
470         return 0;
471 }
472 #endif
473
474 /**
475  * Probe PCI device
476  *
477  * @v pci               PCI device
478  * @v id                PCI ID
479  * @ret rc              Return status code
480  */
481 static int mlx_probe ( struct pci_device *pci,
482                        const struct pci_device_id *id __unused ) {
483         struct net_device *netdev;
484         struct mlx_nic *mlx;
485         struct ib_mac *mac;
486         udqp_t qph;
487         int rc;
488
489         /* Allocate net device */
490         netdev = alloc_ibdev ( sizeof ( *mlx ) );
491         if ( ! netdev )
492                 return -ENOMEM;
493         netdev_init ( netdev, &mlx_operations );
494         mlx = netdev->priv;
495         pci_set_drvdata ( pci, netdev );
496         netdev->dev = &pci->dev;
497         memset ( mlx, 0, sizeof ( *mlx ) );
498
499         /* Fix up PCI device */
500         adjust_pci_device ( pci );
501
502         /* Initialise hardware */
503         if ( ( rc = ib_driver_init ( pci, &qph ) ) != 0 )
504                 goto err_ipoib_init;
505         mlx->ipoib_qph = qph;
506         mlx->bcast_av = ib_data.bcast_av;
507         mlx->snd_cqh = ib_data.ipoib_snd_cq;
508         mlx->rcv_cqh = ib_data.ipoib_rcv_cq;
509         mac = ( ( struct ib_mac * ) netdev->ll_addr );
510         mac->qpn = htonl ( ib_get_qpn ( mlx->ipoib_qph ) );
511         memcpy ( &mac->gid, ib_data.port_gid.raw, sizeof ( mac->gid ) );
512
513         /* Register network device */
514         if ( ( rc = register_netdev ( netdev ) ) != 0 )
515                 goto err_register_netdev;
516
517         return 0;
518
519  err_register_netdev:
520  err_ipoib_init:
521         ib_driver_close ( 0 );
522         netdev_nullify ( netdev );
523         netdev_put ( netdev );
524         return rc;
525 }
526
527 static struct pci_device_id mlx_nics[] = {
528         PCI_ROM(0x15b3, 0x6282, "MT25218", "MT25218 HCA driver"),
529         PCI_ROM(0x15b3, 0x6274, "MT25204", "MT25204 HCA driver"),
530 };
531
532 struct pci_driver mlx_driver __pci_driver = {
533         .ids = mlx_nics,
534         .id_count = ( sizeof ( mlx_nics ) / sizeof ( mlx_nics[0] ) ),
535         .probe = mlx_probe,
536         .remove = mlx_remove,
537 };