de91dac651e8e5b299770497fe1b9b7f46f5c220
[people/xl0/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 /* NIC specific static variables go here */
31
32 int prompt_key(int secs, unsigned char *ch_p)
33 {
34         unsigned long tmo;
35         unsigned char ch;
36
37         for (tmo = currticks() + secs * TICKS_PER_SEC; currticks() < tmo;) {
38                 if (iskey()) {
39                         ch = getchar();
40                         /* toupper does not work ... */
41                         if (ch == 'v')
42                                 ch = 'V';
43                         if (ch == 'i')
44                                 ch = 'I';
45                         if ((ch=='V') || (ch=='I')) {
46                                 *ch_p = ch;
47                                 return 1;
48                         }
49                 }
50         }
51
52         return 0;
53 }
54
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
157 /**
158  * Open network device
159  *
160  * @v netdev            Network device
161  * @ret rc              Return status code
162  */
163 static int mlx_open ( struct net_device *netdev ) {
164         return 0;
165 }
166
167 /**
168  * Close network device
169  *
170  * @v netdev            Network device
171  */
172 static void mlx_close ( struct net_device *netdev ) {
173 }
174
175 #warning "Broadcast address?"
176 static uint8_t ib_broadcast[IB_ALEN] = { 0xff, };
177
178
179 /**
180  * Transmit packet
181  *
182  * @v netdev            Network device
183  * @v iobuf             I/O buffer
184  * @ret rc              Return status code
185  */
186 static int mlx_transmit ( struct net_device *netdev,
187                           struct io_buffer *iobuf ) {
188         struct ibhdr *ibhdr = iobuf->data;
189
190         iob_pull ( iobuf, sizeof ( *ibhdr ) );  
191
192         if ( memcmp ( ibhdr->peer, ib_broadcast, IB_ALEN ) == 0 ) {
193                 printf ( "Sending broadcast packet\n" );
194                 return send_bcast_packet ( ntohs ( ibhdr->proto ),
195                                            iobuf->data, iob_len ( iobuf ) );
196         } else {
197                 printf ( "Sending unicast packet\n" );
198                 return send_ucast_packet ( ibhdr->peer,
199                                            ntohs ( ibhdr->proto ),
200                                            iobuf->data, iob_len ( iobuf ) );
201         }
202 }
203
204 /**
205  * Poll for completed and received packets
206  *
207  * @v netdev            Network device
208  */
209 static void mlx_poll ( struct net_device *netdev ) {
210         struct ib_cqe_st ib_cqe;
211         uint8_t num_cqes;
212         unsigned int len;
213         struct io_buffer *iobuf;
214         void *buf;
215         int rc;
216
217         if ( ( rc = poll_error_buf() ) != 0 ) {
218                 DBG ( "poll_error_buf() failed: %s\n", strerror ( rc ) );
219                 return;
220         }
221
222         if ( ( rc = drain_eq() ) != 0 ) {
223                 DBG ( "drain_eq() failed: %s\n", strerror ( rc ) );
224                 return;
225         }
226
227         if ( ( rc = ib_poll_cq ( ipoib_data.rcv_cqh, &ib_cqe,
228                                  &num_cqes ) ) != 0 ) {
229                 DBG ( "ib_poll_cq() failed: %s\n", strerror ( rc ) );
230                 return;
231         }
232
233         if ( ! num_cqes )
234                 return;
235
236         if ( ib_cqe.is_error ) {
237                 DBG ( "cqe error\n" );
238                 free_wqe ( ib_cqe.wqe );
239                 return;
240         }
241
242         len = ib_cqe.count;
243         iobuf = alloc_iob ( len );
244         if ( ! iobuf ) {
245                 DBG ( "out of memory\n" );
246                 free_wqe ( ib_cqe.wqe );
247                 return;
248         }
249         buf = get_rcv_wqe_buf(ib_cqe.wqe, 1);
250         memcpy ( iob_put ( iobuf, len ), buf, len );
251         DBG ( "Received packet header:\n" );
252         struct recv_wqe_st *rcv_wqe = ib_cqe.wqe;
253         DBG_HD ( get_rcv_wqe_buf(ib_cqe.wqe, 0),
254                  be32_to_cpu(rcv_wqe->mpointer[0].byte_count) );
255                  
256         DBG ( "Received packet:\n" );
257         DBG_HD ( iobuf->data, iob_len ( iobuf ) );
258
259         netdev_rx ( netdev, iobuf );
260
261         free_wqe ( ib_cqe.wqe );
262 }
263
264 /**
265  * Enable or disable interrupts
266  *
267  * @v netdev            Network device
268  * @v enable            Interrupts should be enabled
269  */
270 static void mlx_irq ( struct net_device *netdev, int enable ) {
271 }
272
273 static struct net_device_operations mlx_operations = {
274         .open           = mlx_open,
275         .close          = mlx_close,
276         .transmit       = mlx_transmit,
277         .poll           = mlx_poll,
278         .irq            = mlx_irq,
279 };
280
281 /**************************************************************************
282 DISABLE - Turn off ethernet interface
283 ***************************************************************************/
284 static void mt25218_disable(struct nic *nic)
285 {
286         /* put the card in its initial state */
287         /* This function serves 3 purposes.
288          * This disables DMA and interrupts so we don't receive
289          *  unexpected packets or interrupts from the card after
290          *  etherboot has finished. 
291          * This frees resources so etherboot may use
292          *  this driver on another interface
293          * This allows etherboot to reinitialize the interface
294          *  if something is something goes wrong.
295          */
296         if (nic || 1) {         // ????
297                 disable_imp();
298         }
299 }
300
301 /**
302  * Remove PCI device
303  *
304  * @v pci               PCI device
305  */
306 static void mlx_remove ( struct pci_device *pci ) {
307         struct net_device *netdev = pci_get_drvdata ( pci );
308         struct mlx_nic *mlx = netdev->priv;
309
310         unregister_netdev ( netdev );
311         ipoib_close(0);
312         netdev_nullify ( netdev );
313         netdev_put ( netdev );
314 }
315
316 static struct nic_operations mt25218_operations = {
317         .connect        = dummy_connect,
318         .poll           = mt25218_poll,
319         .transmit       = mt25218_transmit,
320         .irq            = mt25218_irq,
321 };
322
323 /**************************************************************************
324 PROBE - Look for an adapter, this routine's visible to the outside
325 ***************************************************************************/
326
327 static int mt25218_probe(struct nic *nic, struct pci_device *pci)
328 {
329         int rc;
330         unsigned char user_request;
331
332         if (pci->vendor != MELLANOX_VENDOR_ID) {
333                 eprintf("");
334                 return 0;
335         }
336
337         printf("\n");
338         printf("Mellanox Technologies LTD - Boot over IB implementaion\n");
339         printf("Build version = %s\n\n", build_revision);
340
341         verbose_messages = 0;
342         print_info = 0;
343         printf("Press within 3 seconds:\n");
344         printf("V - to increase verbosity\n");
345         printf("I - to print information\n");
346         if (prompt_key(3, &user_request)) {
347                 if (user_request == 'V') {
348                         printf("User selected verbose messages\n");
349                         verbose_messages = 1;
350                 }
351                 else if (user_request == 'I') {
352                         printf("User selected to print information\n");
353                         print_info = 1;
354                 }
355         }
356         printf("\n");
357
358         adjust_pci_device(pci);
359
360         nic->priv_data = NULL;
361         rc = probe_imp(pci, nic);
362
363         /* give the user a chance to look at the info */
364         if (print_info)
365                 sleep(5);
366
367         if (!rc) {
368                 /* store NIC parameters */
369                 nic->ioaddr = pci->ioaddr & ~3;
370                 nic->irqno = pci->irq;
371                 /* point to NIC specific routines */
372                 nic->nic_op = &mt25218_operations;
373
374                 uint8_t fixed_node_addr[ETH_ALEN] = { 0x00, 0x02, 0xc9,
375                                                       0x20, 0xf5, 0x95 };
376                 memcpy ( nic->node_addr, fixed_node_addr, ETH_ALEN );
377
378                 return 1;
379         }
380         /* else */
381         return 0;
382 }
383
384 /**
385  * Probe PCI device
386  *
387  * @v pci               PCI device
388  * @v id                PCI ID
389  * @ret rc              Return status code
390  */
391 static int mlx_probe ( struct pci_device *pci,
392                        const struct pci_device_id *id __unused ) {
393         struct net_device *netdev;
394         struct mlx_nic *mlx;
395         int rc;
396
397         /* Allocate net device */
398         netdev = alloc_ibdev ( sizeof ( *mlx ) );
399         if ( ! netdev )
400                 return -ENOMEM;
401         netdev_init ( netdev, &mlx_operations );
402         mlx = netdev->priv;
403         pci_set_drvdata ( pci, netdev );
404         netdev->dev = &pci->dev;
405         memset ( mlx, 0, sizeof ( *mlx ) );
406
407         /* Fix up PCI device */
408         adjust_pci_device ( pci );
409
410         /* Initialise hardware */
411         if ( ( rc = ipoib_init ( pci ) ) != 0 )
412                 goto err_ipoib_init;
413         memcpy ( netdev->ll_addr, ipoib_data.port_gid_raw, IB_ALEN );
414
415         /* Register network device */
416         if ( ( rc = register_netdev ( netdev ) ) != 0 )
417                 goto err_register_netdev;
418
419         return 0;
420
421  err_register_netdev:
422  err_ipoib_init:
423         ipoib_close(0);
424         netdev_nullify ( netdev );
425         netdev_put ( netdev );
426         return rc;
427 }
428
429 static struct pci_device_id mlx_nics[] = {
430         PCI_ROM(0x15b3, 0x6282, "MT25218", "MT25218 HCA driver"),
431         PCI_ROM(0x15b3, 0x6274, "MT25204", "MT25204 HCA driver"),
432 };
433
434 struct pci_driver mlx_driver __pci_driver = {
435         .ids = mlx_nics,
436         .id_count = ( sizeof ( mlx_nics ) / sizeof ( mlx_nics[0] ) ),
437         .probe = mlx_probe,
438         .remove = mlx_remove,
439 };