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