2a295d7dbdca642c339b8da9199731fc697f2107
[barrelfish] / usr / drivers / e10k / e10k_cdriver.c
1 /*
2  * Copyright (c) 2007-2011, 2013, 2014, ETH Zurich.
3  * All rights reserved.
4  *
5  * This file is distributed under the terms in the attached LICENSE file.
6  * If you do not find this file, copies can be found by writing to:
7  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <stdarg.h>
14 #include <net/net.h>
15
16 #include <net_device_manager/net_device_manager.h>
17 #include <pci/pci.h>
18 #include <barrelfish/nameservice_client.h>
19 #include <barrelfish/debug.h>
20 #include <barrelfish/deferred.h>
21 #include <lwip/ip.h>
22 #ifdef LIBRARY
23 #       include <netif/e1000.h>
24 #endif
25 #include <arpa/inet.h>
26
27 #include <if/e10k_defs.h>
28 #include <if/e10k_vf_defs.h>
29 #include <if/net_filter_defs.h>
30 #include <dev/e10k_dev.h>
31
32 #include "e10k.h"
33 #include "sleep.h"
34 #include "helper.h"
35
36 //#define VTON_DCBOFF TODO use if VFs are enabled
37 //#define DCA_ENABLED
38
39 //#define DEBUG(x...) printf("e10k: " x)
40 #define DEBUG(x...) do {} while (0)
41
42 #define QUEUE_INTRX 0
43 #define QUEUE_INTTX 1
44
45 struct queue_state {
46     bool enabled;
47     struct e10k_binding *binding;
48     struct e10k_vf_binding *devif;
49
50     struct capref tx_frame;
51     struct capref txhwb_frame;
52     struct capref rx_frame;
53     uint32_t rxbufsz;
54     uint32_t rxhdrsz;
55
56     size_t msix_index;
57     int16_t msix_intvec;
58     uint8_t msix_intdest;
59     bool use_irq;
60     bool use_rsc;
61
62     uint64_t rx_head;
63     uint64_t tx_head;
64     lvaddr_t tx_va;
65     lvaddr_t rx_va;
66     lvaddr_t txhwb_va;
67 };
68
69 enum filter_l4type {
70     L4_OTHER,
71     L4_UDP,
72     L4_TCP,
73     L4_SCTP
74 };
75
76 enum filter_mask {
77     MASK_L4PROTO    = (1 << 0),
78     MASK_SRCIP      = (1 << 1),
79     MASK_DSTIP      = (1 << 2),
80     MASK_SRCPORT    = (1 << 3),
81     MASK_DSTPORT    = (1 << 4),
82 };
83
84 struct e10k_filter {
85     bool enabled;
86     uint8_t priority;
87     uint8_t queue;
88
89     uint32_t src_ip;
90     uint32_t dst_ip;
91     uint16_t src_port;
92     uint16_t dst_port;
93
94     uint16_t mask;
95     uint16_t l4_type;
96 };
97
98 union macentry {
99     uint8_t as8[6];
100     uint64_t as64;
101 };
102
103 static union macentry mactable[128] = {
104     { .as8 = "\x0\x0\x0\x0\x0\x0" },      // First MAC is never set (loaded from card EEPROM)
105
106     { .as8 = "\x22\xc9\xfc\x96\x83\xfc" },
107     { .as8 = "\xce\x43\x5b\xf7\x3e\x60" },
108     { .as8 = "\x6a\xb0\x62\xf6\xa7\x21" },
109     { .as8 = "\xb2\xdf\xf9\x39\xc6\x10" },
110     { .as8 = "\x92\x77\xe7\x3f\x80\x30" },
111     { .as8 = "\xd6\x88\xd6\x86\x4a\x22" },
112     { .as8 = "\x7e\x64\xe9\x2e\xbe\x4b" },
113     { .as8 = "\xba\xac\x49\xd6\x3c\x77" },
114
115     // We set the rest to all zeroes
116
117     // Last MAC (127) never set (loaded from card EEPROM ... at least, it's already there)
118 };
119
120 static uint16_t credit_refill[128];
121 static uint32_t tx_rate[128];
122
123 // Hack for monolithic driver
124 void qd_main(void) __attribute__((weak));
125 void qd_argument(const char *arg) __attribute__((weak));
126 void qd_interrupt(bool is_rx, bool is_tx) __attribute__((weak));
127 void qd_queue_init_data(struct e10k_binding *b, struct capref registers,
128         uint64_t macaddr) __attribute__((weak));
129 void qd_queue_memory_registered(struct e10k_binding *b) __attribute__((weak));
130 void qd_write_queue_tails(struct e10k_binding *b) __attribute__((weak));
131
132
133 void cd_request_device_info(struct e10k_binding *b);
134 void cd_register_queue_memory(struct e10k_binding *b,
135                               uint8_t n,
136                               struct capref tx_frame,
137                               struct capref txhwb_frame,
138                               struct capref rx_frame,
139                               uint32_t rxbufsz,
140                               uint32_t rxhdrsz,
141                               int16_t msix_intvec,
142                               uint8_t msix_intdest,
143                               bool use_irq,
144                               bool use_rsc,
145                               lvaddr_t tx_va,
146                               lvaddr_t rx_va,
147                               lvaddr_t txhwb_va);
148 void cd_set_interrupt_rate(struct e10k_binding *b,
149                            uint8_t queue,
150                            uint16_t rate);
151
152
153 static void idc_write_queue_tails(struct e10k_binding *b);
154 static void stop_device(void);
155
156 static void device_init(void);
157 static void queue_hw_init(uint8_t n, bool set_tail);
158 //static void queue_hw_stop(uint8_t n);
159 static void interrupt_handler_msix(void* arg);
160 //static void interrupt_handler_msix_b(void* arg);
161
162 static void e10k_flt_ftqf_setup(int index, struct e10k_filter *filter);
163 //static void e10k_flt_etype_setup(int filter, int queue, uint16_t etype);
164
165
166
167 static const char *service_name = "e10k";
168 static int initialized = 0;
169 static bool exported = false;
170 static e10k_t *d = NULL;
171 static struct capref *regframe;
172
173 static bool use_interrupts = true;
174 static bool msix = false;
175
176 /** Specifies if RX/TX is currently enabled on the device. */
177 static bool rxtx_enabled = false;
178
179 // Management of MSI-X vectors
180 static struct bmallocator msix_alloc;
181 /** MSI-X vector used by cdriver */
182 static size_t cdriver_msix = -1;
183 static uint8_t cdriver_vector;
184
185
186 // State of queues and filters
187 static struct queue_state queues[128];
188 static struct e10k_filter filters[128];
189
190 static char buf[4096];
191
192 /* PCI device address passed on command line */
193 static uint32_t pci_bus = PCI_DONT_CARE;
194 static uint32_t pci_device = PCI_DONT_CARE;
195 static uint32_t pci_function = 0;
196 static uint32_t pci_deviceid = E10K_PCI_DEVID;
197
198 /* VFs alloacation data*/
199 static bool vf_used[63];
200
201 static void e10k_flt_ftqf_setup(int idx, struct e10k_filter* filter)
202 {
203     uint16_t m = filter->mask;
204     e10k_l4_proto_t p;
205     e10k_ftqf_t ftqf = 0;
206     e10k_l34timir_t timir = 0;
207     e10k_sdpqf_t sdpqf = 0;
208
209
210     // Write filter data
211     if (!(m & MASK_SRCIP)) {
212         DEBUG("src_ip=%"PRIx32" ", filter->src_ip);
213         e10k_saqf_wr(d, idx, htonl(filter->src_ip));
214     }
215
216     if (!(m & MASK_DSTIP)) {
217         DEBUG("dst_ip=%"PRIx32" ", filter->dst_ip);
218         e10k_daqf_wr(d, idx, htonl(filter->dst_ip));
219     }
220
221     if (!(m & MASK_SRCPORT)) {
222         DEBUG("src_port=%d ", filter->src_port);
223         sdpqf = e10k_sdpqf_src_port_insert(sdpqf, htons(filter->src_port));
224     }
225
226     if (!(m & MASK_DSTPORT)) {
227         DEBUG("dst_port=%d ", filter->dst_port);
228         sdpqf = e10k_sdpqf_dst_port_insert(sdpqf, htons(filter->dst_port));
229     }
230     e10k_sdpqf_wr(d, idx, sdpqf);
231     DEBUG("queue_id=%d \n", filter->queue);
232
233     if (!(m & MASK_L4PROTO)) {
234         switch (filter->l4_type) {
235             case L4_OTHER:  p = e10k_l4other; break;
236             case L4_UDP:    p = e10k_l4udp; break;
237             case L4_TCP:    p = e10k_l4tcp; break;
238             case L4_SCTP:   p = e10k_l4sctp; break;
239             default: assert(0); return;
240         }
241         ftqf = e10k_ftqf_protocol_insert(ftqf, p);
242     }
243
244     // Write mask bits
245     ftqf = e10k_ftqf_m_srcaddr_insert(ftqf, !!(m & MASK_SRCIP));
246     ftqf = e10k_ftqf_m_dstaddr_insert(ftqf, !!(m & MASK_DSTIP));
247     ftqf = e10k_ftqf_m_srcport_insert(ftqf, !!(m & MASK_SRCPORT));
248     ftqf = e10k_ftqf_m_dstport_insert(ftqf, !!(m & MASK_DSTPORT));
249     ftqf = e10k_ftqf_m_protocol_insert(ftqf, !!(m & MASK_L4PROTO));
250
251
252     // Configure destination queue and enable filter
253     timir = e10k_l34timir_rx_queue_insert(timir, filter->queue);
254     e10k_l34timir_wr(d, idx, timir);
255
256     ftqf = e10k_ftqf_priority_insert(ftqf, filter->priority);
257     ftqf = e10k_ftqf_pool_mask_insert(ftqf, 1);
258     ftqf = e10k_ftqf_queue_en_insert(ftqf, 1);
259     e10k_ftqf_wr(d, idx, ftqf);
260 }
261
262 #ifndef LIBRARY
263 static int ftqf_index = 0;
264 static int ftqf_alloc(void)
265 {
266     // FIXME: Do this reasonably
267     return ftqf_index++;
268 }
269
270 static errval_t reg_ftfq_filter(struct e10k_filter* f, uint64_t* fid)
271 {
272     int i;
273
274     DEBUG("reg_ftfq_filter: called\n");
275
276     if ((i = ftqf_alloc()) < 0) {
277         return FILTER_ERR_NOT_ENOUGH_MEMORY;
278     }
279
280
281     filters[i] = *f;
282     filters[i].enabled = true;
283
284     e10k_flt_ftqf_setup(i, f);
285
286     *fid = i + 1;
287
288     return SYS_ERR_OK;
289 }
290 #endif
291
292
293 /****************************************************************************/
294 /* Net filter interface implementation                                      */
295 /****************************************************************************/
296
297
298 static errval_t cb_install_filter(struct net_filter_binding *b,
299                                   net_filter_filter_type_t type,
300                                   uint64_t qid,
301                                   uint32_t src_ip,
302                                   uint32_t dst_ip,
303                                   uint16_t src_port,
304                                   uint16_t dst_port,
305                                   uint64_t* fid)
306 {
307
308     errval_t err;
309     struct e10k_filter f = {
310         .dst_port = dst_port,
311         .src_port = src_port,
312         .dst_ip = dst_ip,
313         .src_ip = src_ip,
314         .l4_type = (type == net_filter_PORT_TCP ? L4_TCP : L4_UDP),
315         .priority = 1,
316         .queue = qid,
317     };
318
319     if (src_ip == 0) {
320         f.mask = f.mask | MASK_SRCIP;
321     }
322
323     // ignore dst ip
324     f.mask = f.mask | MASK_DSTIP;
325
326     if (dst_port == 0) {
327         f.mask = f.mask | MASK_DSTPORT;
328     }
329
330     if (src_port == 0) {
331         f.mask = f.mask | MASK_SRCPORT;
332     }
333
334     *fid = -1ULL;
335
336     err = reg_ftfq_filter(&f, fid);
337     DEBUG("filter registered: err=%s, fid=%"PRIu64"\n", err_getstring(err), *fid);
338     return err;
339 }
340
341
342 static errval_t cb_remove_filter(struct net_filter_binding *b,
343                                  net_filter_filter_type_t type,
344                                  uint64_t filter_id,
345                                  errval_t* err)
346 {
347     if ((type == net_filter_PORT_UDP || type == net_filter_PORT_TCP)){
348         USER_PANIC("NYI");
349         *err = SYS_ERR_OK;
350     } else {
351         *err = NET_FILTER_ERR_NOT_FOUND;
352     }
353
354     DEBUG("unregister_filter: called (%"PRIx64")\n", filter_id);
355     return SYS_ERR_OK;
356 }
357
358 static struct net_filter_rpc_rx_vtbl net_filter_rpc_rx_vtbl = {
359     .install_filter_ip_call = cb_install_filter,
360     .remove_filter_call = cb_remove_filter,
361     .install_filter_mac_call = NULL,
362 };
363
364 static void net_filter_export_cb(void *st, errval_t err, iref_t iref)
365 {
366
367     printf("exported net filter interface\n");
368     err = nameservice_register("net_filter_e10k", iref);
369     assert(err_is_ok(err));
370     DEBUG("Net filter interface exported\n");
371 }
372
373
374 static errval_t net_filter_connect_cb(void *st, struct net_filter_binding *b)
375 {
376     printf("New connection on net filter interface\n");
377     b->rpc_rx_vtbl = net_filter_rpc_rx_vtbl;
378     return SYS_ERR_OK;
379 }
380
381
382 #if 0
383 static void e10k_flt_etype_setup(int filter, int queue, uint16_t etype)
384 {
385     // Clear existing values
386     e10k_etqf_wr(d, filter, 0x0);
387     e10k_etqs_wr(d, filter, 0x0);
388
389     e10k_etqs_rx_queue_wrf(d, filter, queue);
390     e10k_etqs_queue_en_wrf(d, filter, 1);
391
392     e10k_etqf_etype_wrf(d, filter, etype);
393     e10k_etqf_filter_en_wrf(d, filter, 1);
394 }
395
396
397 static errval_t arp_filter(uint64_t qid, uint64_t* fid)
398 {
399     e10k_flt_etype_setup(0, (int) qid, 0x0806);
400     *fid = 0;
401     DEBUG("reg_arp_filter: called\n");
402     return SYS_ERR_OK;
403 }
404
405 static errval_t reg_ftfq_filter(struct e10k_filter* f, uint64_t* fid)
406 {
407     int i;
408
409     DEBUG("reg_ftfq_filter: called\n");
410
411     if ((i = ftqf_alloc()) < 0) {
412         return ETHERSRV_ERR_NOT_ENOUGH_MEM;
413     }
414
415
416     filters[i] = *f;
417     filters[i].enabled = true;
418
419     e10k_flt_ftqf_setup(i, f);
420
421     *fid = i + 1;
422
423     return SYS_ERR_OK;
424 }
425
426 static errval_t ipv4_tcp_port(uint64_t qid, uint16_t port, uint64_t* fid)
427 {
428     struct e10k_filter f = {
429         .dst_port = port,
430         .mask = MASK_SRCIP | MASK_DSTIP | MASK_SRCPORT,
431         .l4_type = L4_TCP,
432         .priority = 1,
433         .queue = qid,
434     };
435
436     DEBUG("ipv4_tcp_port: called\n");
437     return reg_ftfq_filter(&f, fid);
438 }
439
440 static errval_t ipv4_udp_port(uint64_t qid, uint16_t port, uint64_t* fid)
441 {
442     struct e10k_filter f = {
443         .dst_port = port,
444         .mask = MASK_SRCIP | MASK_DSTIP | MASK_SRCPORT,
445         .l4_type = L4_UDP,
446         .priority = 1,
447         .queue = qid,
448     };
449
450     DEBUG("ipv4_udp_port: called\n");
451     return reg_ftfq_filter( &f, fid);
452 }
453
454 static errval_t ipv4_tcp_conn(uint64_t qid,
455                               uint32_t l_ip, uint16_t l_port,
456                               uint32_t r_ip, uint16_t r_port,
457                               uint64_t* fid)
458 {
459     struct e10k_filter f = {
460         .dst_ip = l_ip,
461         .dst_port = l_port,
462         .src_ip = r_ip,
463         .src_port = r_port,
464         .mask = 0,
465         .l4_type = L4_TCP,
466         .priority = 0,
467         .queue = qid,
468     };
469
470     DEBUG("ipv4_tcp_conn: called\n");
471     return reg_ftfq_filter(&f, fid);
472 }
473
474 static errval_t deregister_filter(uint64_t fid)
475 {
476     DEBUG("deregister_filter: called\n");
477     return LIB_ERR_NOT_IMPLEMENTED;
478 }
479
480 #endif
481
482
483 /** Enable RX operation for whole card. */
484 static void rx_enable(void)
485 {
486     e10k_secrxctrl_rx_dis_wrf(d, 1);
487     while (e10k_secrxstat_sr_rdy_rdf(d) == 0); // TODO: Timeout
488     e10k_rxctrl_rxen_wrf(d, 1);
489     e10k_secrxctrl_rx_dis_wrf(d, 0);
490 }
491
492 /** Disable RX operation for whole card. */
493 static void rx_disable(void)
494 {
495     e10k_secrxctrl_rx_dis_wrf(d, 1);
496     while (e10k_secrxstat_sr_rdy_rdf(d) == 0); // TODO: Timeout
497     e10k_rxctrl_rxen_wrf(d, 0);
498     e10k_secrxctrl_rx_dis_wrf(d, 0);
499 }
500
501 /** Enable TX operation for whole card. */
502 static void tx_enable(void)
503 {
504     e10k_dmatxctl_txen_wrf(d, 1);
505 }
506
507 /** Disable TX operation for whole card. */
508 static void tx_disable(void)
509 {
510     e10k_dmatxctl_txen_wrf(d, 0);
511     while (e10k_dmatxctl_txen_rdf(d) != 0); // TODO: timeout
512 }
513
514
515 static void setup_interrupt(size_t *msix_index, uint8_t core, uint8_t vector)
516 {
517     bool res;
518     errval_t err;
519     uint8_t dest;
520
521     res = bmallocator_alloc(&msix_alloc, msix_index);
522     assert(res);
523
524     err = get_apicid_from_core(core, &dest);
525     assert(err_is_ok(err));
526
527     err = pci_msix_vector_init(*msix_index, dest, vector);
528     assert(err_is_ok(err));
529
530     DEBUG("e10k: MSI-X vector setup index=%"PRIx64", core=%d apic=%d swvec=%x\n",
531             *msix_index, core, dest, vector);
532 }
533
534 /**
535  * Initialize hardware registers.
536  * Is also called after a reset of the device.
537  */
538 static void device_init(void)
539 {
540     int i;
541     e10k_ctrl_t ctrl;
542     e10k_pfqde_t pfqde;
543     errval_t err;
544     bool initialized_before = initialized;
545
546     initialized = 0;
547
548     stop_device();
549
550     if (initialized_before) {
551         // Save queue heads and tails
552         for (i = 0; i < 128; i++) {
553             if (queues[i].enabled) {
554                 queues[i].tx_head = e10k_tdh_rd(d, i);
555                 if (i < 64) {
556                     queues[i].rx_head = e10k_rdh_1_rd(d, i);
557                 } else {
558                     queues[i].rx_head = e10k_rdh_2_rd(d, i - 64);
559                 }
560             }
561         }
562     }
563
564     // Make a double reset to be sure
565     for (i = 0; i < 2; i++) {
566         // Issue Global reset
567         ctrl = e10k_ctrl_rd(d);
568         ctrl = e10k_ctrl_lrst_insert(ctrl, 1);
569         ctrl = e10k_ctrl_rst_insert(ctrl, 1);
570         e10k_ctrl_wr(d, ctrl);
571         while ((e10k_ctrl_rst_rdf(d) != 0) ||
572                (e10k_ctrl_lrst_rdf(d) != 0)); // TODO: Timeout
573
574         // Spec says 10, fbsd driver 50
575         milli_sleep(50);
576     }
577     DEBUG("Global reset done\n");
578
579     // Disable interrupts
580     e10k_eimc_cause_wrf(d, 0x7FFFFFFF);
581     e10k_eicr_rd(d);
582
583     // Let firmware know that we have taken over
584     e10k_ctrl_ext_drv_load_wrf(d, 1);
585
586     // NO Snoop disable (from FBSD)
587     // Without this, the driver only works on sbrinz1 if the receive buffers are
588     // mapped non cacheable. If the buffers are mapped cacheable, sometimes we
589     // seem to read old buffer contents, not sure exactly why, as far as
590     // understood this, No snoop should only be enabled by the device if it is
591     // save...
592     // TODO: Also check performance implications of this on gottardo and other
593     // machnies where it works without this.
594     e10k_ctrl_ext_ns_dis_wrf(d, 1);
595
596     // Initialize flow-control registers
597     for (i = 0; i < 8; i++) {
598         if (i < 4) e10k_fcttv_wr(d, i, 0x0);
599         e10k_fcrtl_wr(d, i, 0x0);
600         e10k_fcrth_wr(d, i, 0x0);
601     }
602     e10k_fcrtv_wr(d, 0x0);
603     e10k_fccfg_wr(d, 0x0);
604
605     // Initialize Phy
606     e10k_phy_init(d);
607
608     // Wait for EEPROM auto read
609     while (e10k_eec_auto_rd_rdf(d) == 0); // TODO: Timeout
610     DEBUG("EEPROM auto read done\n");
611
612     // Wait for DMA initialization
613     while (e10k_rdrxctl_dma_initok_rdf(d) == 0); // TODO: Timeout
614
615     // Wait for link to come up
616     while (e10k_links_lnk_up_rdf(d) == 0); // TODO: Timeout
617     DEBUG("Link Up\n");
618     milli_sleep(50);
619
620     // Initialize interrupts
621     e10k_eicr_wr(d, 0xffffffff);
622     if (msix) {
623         // Switch to MSI-X mode
624         e10k_gpie_msix_wrf(d, 1);
625         e10k_gpie_pba_sup_wrf(d, 1);
626         e10k_gpie_ocd_wrf(d, 1);
627
628         // Allocate msix vector for cdriver and set up handler
629         if (cdriver_msix == -1) {
630             err = pci_setup_inthandler(interrupt_handler_msix, NULL, &cdriver_vector);
631             assert(err_is_ok(err));
632
633             setup_interrupt(&cdriver_msix, disp_get_core_id(), cdriver_vector);
634         }
635
636         // Map management interrupts to our vector
637         e10k_ivar_misc_i_alloc0_wrf(d, cdriver_msix);
638         e10k_ivar_misc_i_alloc1_wrf(d, cdriver_msix);
639         e10k_ivar_misc_i_allocval0_wrf(d, 1);
640         e10k_ivar_misc_i_allocval1_wrf(d, 1);
641
642         // Enable auto masking of interrupt
643         e10k_gpie_eiame_wrf(d, 1);
644         e10k_eiamn_wr(d, cdriver_msix / 32, (1 << (cdriver_msix % 32)));
645
646         // Set no interrupt delay
647         e10k_eitr_l_wr(d, cdriver_msix, 0);
648         e10k_gpie_eimen_wrf(d, 1);
649
650         // Enable interrupt
651         e10k_eimsn_wr(d, cdriver_msix / 32, (1 << (cdriver_msix % 32)));
652     } else {
653         e10k_gpie_msix_wrf(d, 0);
654         // Set no Interrupt delay
655         e10k_eitr_l_wr(d, 0, 0);
656         e10k_gpie_eimen_wrf(d, 1);
657
658         // Enable all interrupts
659         e10k_eimc_wr(d, e10k_eims_rd(d));
660         e10k_eims_cause_wrf(d, 0x7fffffff);
661     }
662
663     // Just a guess for RSC delay
664     e10k_gpie_rsc_delay_wrf(d, 2);
665
666     // Initialize multiple register tables (MAC 0 and 127 are not set)
667     for (i = 0; i < 128; i++) {
668         /* uint64_t mac = e10k_ral_ral_rdf(d, i) | ((uint64_t) e10k_rah_rah_rdf(d, i) << 32); */
669         /* uint8_t *m = (uint8_t *)&mac; */
670         /* DEBUG("Old MAC %d: %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx ... mac valid = %x\n", */
671         /*       i, m[0], m[1], m[2], m[3], m[4], m[5], e10k_rah_av_rdf(d, 0)); */
672
673         if(i > 0 && i < 127) {
674             e10k_ral_wr(d, i, mactable[i].as64 & 0xffffffff);
675             e10k_rah_wr(d, i, mactable[i].as64 >> 32);
676             e10k_rah_av_wrf(d, i, 1);
677
678             /* mac = e10k_ral_ral_rdf(d, i) | ((uint64_t) e10k_rah_rah_rdf(d, i) << 32); */
679             /* m = (uint8_t *)&mac; */
680             /* DEBUG("New MAC %d: %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx ... mac valid = %x\n", */
681             /*       i, m[0], m[1], m[2], m[3], m[4], m[5], e10k_rah_av_rdf(d, 0)); */
682         }
683     }
684     for (i = 0; i < 128; i++)
685         e10k_mta_bit_vec_wrf(d, i, 0);
686     for (i = 0; i < 128; i++)
687         e10k_vfta_vlan_flt_wrf(d, i, 0);
688     for (i = 0; i < 128; i++)
689         e10k_pfvlvfb_wr(d, i, 0);
690
691     for (i = 0; i < 64; i++) {
692 #ifdef VTON_DCBOFF
693         e10k_pfvlvf_vi_en_wrf(d, i, 1);
694 #else
695         e10k_pfvlvf_vi_en_wrf(d, i, 0);
696 #endif
697         e10k_psrtype_wr(d, i, 0);
698     }
699     for (i = 0; i < 128; i++)
700         e10k_pfuta_wr(d, i, 0);
701     for (i = 0; i < 256; i++)
702         e10k_mpsar_pool_ena_wrf(d, i, 0);
703
704     // Program direct match MAC forwarding rules
705     // This setup will assign the first 64 MAC addresses each to a different
706     // RX pool. This assumes we have 64 VFs. The rest is set to filtered.
707     for(i = 0; i < 128; i++) {
708         if(i < 32) {
709             // Pools < 32 (low bits)
710             e10k_mpsar_pool_ena_wrf(d, 2 * i, 1 << i);
711             e10k_mpsar_pool_ena_wrf(d, 2 * i + 1, 0);
712         } else if(i < 64) {
713             // Pools >= 32 and < 64 (high bits)
714             e10k_mpsar_pool_ena_wrf(d, 2 * i, 0);
715             e10k_mpsar_pool_ena_wrf(d, 2 * i + 1, 1 << (i - 32));
716         } else {
717             // Pools >= 64 -> DROP
718             e10k_mpsar_pool_ena_wrf(d, 2 * i, 0);
719             e10k_mpsar_pool_ena_wrf(d, 2 * i + 1, 0);
720         }
721     }
722
723     for (i = 0; i < 128; i++) {
724         e10k_fhft_1_wr(d, i, 0);
725         if (i < 64) {
726             e10k_fhft_2_wr(d, i, 0);
727         }
728     }
729
730 #ifdef VTON_DCBOFF
731     // Disallow per-queue RSC (not supported in SR-IOV mode)
732     e10k_rfctl_rsc_dis_wrf(d, 1);
733 #else
734     // Allow for per-queue RSC
735     e10k_rfctl_rsc_dis_wrf(d, 0);
736 #endif
737
738     // Initialize RX filters
739     for (i = 0; i < 128; i++) {
740         e10k_ftqf_wr(d, i, 0);
741         e10k_saqf_wr(d, i, 0);
742         e10k_daqf_wr(d, i, 0);
743         e10k_sdpqf_wr(d, i, 0);
744     }
745     for (i = 0; i < 32; i++)
746         e10k_reta_wr(d, i, 0);
747     e10k_mcstctrl_mfe_wrf(d, 0);
748
749     // Accept broadcasts
750     e10k_fctrl_bam_wrf(d, 1);
751
752     // Enable Jumbo frames
753     e10k_hlreg0_jumboen_wrf(d, 1);
754     e10k_maxfrs_mfs_wrf(d, 15872);
755
756     // Make sure Rx CRC strip is consistently enabled in HLREG0 and RDRXCTL
757     e10k_hlreg0_rxcrcstrp_wrf(d, 1);
758     // Note: rscfrstsz has to be set to 0 (is mbz)
759     e10k_rdrxctl_t rdrxctl = e10k_rdrxctl_rd(d);
760     rdrxctl = e10k_rdrxctl_crcstrip_insert(rdrxctl, 1);
761     e10k_rdrxctl_wr(d, rdrxctl);
762
763
764     // Configure buffers etc. according to specification
765     // Section 4.6.11.3.4 (DCB, virtualization, no RSS)
766     // 1:1 from spec, though not sure if everything is necessary, but since
767     // initialization is still buggy, I'd rather be conservative and set some
768     // additional flags, even if they aren't strictly necessary.
769     e10k_rttdcs_arbdis_wrf(d, 1);
770
771 #ifdef VTON_DCBOFF
772     e10k_rxpbsize_size_wrf(d, 0, 0x200);
773     e10k_txpbsize_size_wrf(d, 0, 0xA0);
774     e10k_txpbthresh_thresh_wrf(d, 0, 0xA0);
775     for (i = 1; i < 8; i++) {
776         e10k_rxpbsize_size_wrf(d, i, 0x0);
777         e10k_txpbsize_size_wrf(d, i, 0x0);
778         e10k_txpbthresh_thresh_wrf(d, i, 0x0);
779     }
780
781     e10k_mrqc_mrque_wrf(d, e10k_vrt_only);
782     e10k_mtqc_rt_en_wrf(d, 0);
783     e10k_mtqc_vt_en_wrf(d, 1);
784     e10k_mtqc_num_tc_wrf(d, 1);
785     e10k_pfvtctl_vt_en_wrf(d, 1);
786 #else
787     e10k_rxpbsize_size_wrf(d, 0, 0x200);
788     e10k_txpbsize_size_wrf(d, 0, 0xA0);
789     e10k_txpbthresh_thresh_wrf(d, 0, 0xA0);
790     for (i = 1; i < 8; i++) {
791         e10k_rxpbsize_size_wrf(d, i, 0x0);
792         e10k_txpbsize_size_wrf(d, i, 0x0);
793         e10k_txpbthresh_thresh_wrf(d, i, 0x0);
794     }
795
796     e10k_mrqc_mrque_wrf(d, e10k_no_rss);
797     e10k_mtqc_rt_en_wrf(d, 0);
798     e10k_mtqc_vt_en_wrf(d, 0);
799     e10k_mtqc_num_tc_wrf(d, 0);
800     e10k_pfvtctl_vt_en_wrf(d, 0);
801 #endif
802     e10k_rtrup2tc_wr(d, 0);
803     e10k_rttup2tc_wr(d, 0);
804
805 #ifdef VTON_DCBOFF
806     e10k_dtxmxszrq_max_bytes_wrf(d, 0xFFF);
807 #else
808     e10k_dtxmxszrq_max_bytes_wrf(d, 0x010);
809 #endif
810
811     e10k_rttdcs_arbdis_wrf(d, 0);
812
813     for (i = 0; i < 128; i++) {
814         pfqde = e10k_pfqde_queue_idx_insert(0x0, i);
815         pfqde = e10k_pfqde_we_insert(pfqde, 1);
816         // XXX: Might want to set drop enable here
817         /* pfqde = e10k_pfqde_qde_insert(pfqde, 1); */
818         e10k_pfqde_wr(d, pfqde);
819     }
820
821 #ifdef VTON_DCBOFF
822     e10k_mflcn_rpfce_wrf(d, 0);
823     e10k_mflcn_rfce_wrf(d, 0);
824     e10k_fccfg_tfce_wrf(d, e10k_lfc_en);
825 #else
826     e10k_mflcn_rpfce_wrf(d, 1);
827     e10k_mflcn_rfce_wrf(d, 0);
828     e10k_fccfg_tfce_wrf(d, e10k_pfc_en);
829 #endif
830
831     /* Causes ECC error (could be same problem as with l34timir (see e10k.dev) */
832     for (i = 0; i < 128; i++) {
833         e10k_rttdqsel_txdq_idx_wrf(d, i);
834         e10k_rttdt1c_wr(d, credit_refill[i]);   // Credit refill x 64 bytes
835         e10k_rttbcnrc_wr(d, 0);
836         if(tx_rate[i] != 0) {
837             // Turn on rate scheduler for this queue and set rate factor
838             e10k_rttbcnrc_t rttbcnrc = 0;
839             // XXX: Assuming 10Gb/s link speed. Change if that's not correct.
840             uint32_t tx_factor = (10000 << 14) / tx_rate[i];
841
842             rttbcnrc = e10k_rttbcnrc_rf_dec_insert(rttbcnrc, tx_factor & 0x3fff);
843             rttbcnrc = e10k_rttbcnrc_rf_int_insert(rttbcnrc, tx_factor >> 14);
844             rttbcnrc = e10k_rttbcnrc_rs_ena_insert(rttbcnrc, 1);
845             e10k_rttbcnrc_wr(d, rttbcnrc);
846
847             printf("Setting rate for queue %d to %u\n", i, tx_rate[i]);
848         }
849     }
850
851     for (i = 0; i < 8; i++) {
852         e10k_rttdt2c_wr(d, i, 0);
853         e10k_rttpt2c_wr(d, i, 0);
854         e10k_rtrpt4c_wr(d, i, 0);
855     }
856
857 #ifdef VTON_DCBOFF
858     e10k_rttdcs_tdpac_wrf(d, 0);
859     e10k_rttdcs_vmpac_wrf(d, 1);        // Remember to set RTTDT1C >= MTU when this is 1
860
861     e10k_rttdcs_tdrm_wrf(d, 0);
862     e10k_rttdcs_bdpm_wrf(d, 1);
863     e10k_rttdcs_bpbfsm_wrf(d, 0);
864     e10k_rttpcs_tppac_wrf(d, 0);
865     e10k_rttpcs_tprm_wrf(d, 0);
866     e10k_rttpcs_arbd_wrf(d, 0x224);
867     e10k_rtrpcs_rac_wrf(d, 0);
868     e10k_rtrpcs_rrm_wrf(d, 0);
869 #else
870
871     e10k_rttdcs_tdpac_wrf(d, 0);
872     e10k_rttdcs_vmpac_wrf(d, 0);
873     e10k_rttdcs_tdrm_wrf(d, 0);
874     e10k_rttdcs_bdpm_wrf(d, 1);
875     e10k_rttdcs_bpbfsm_wrf(d, 1);
876     e10k_rttpcs_tppac_wrf(d, 0);
877     e10k_rttpcs_tprm_wrf(d, 0);
878     e10k_rttpcs_arbd_wrf(d, 0x224);
879     e10k_rtrpcs_rac_wrf(d, 0);
880     e10k_rtrpcs_rrm_wrf(d, 0);
881 #endif
882
883     // disable relaxed ordering
884     for (i = 0; i < 128; i++) {
885         e10k_dca_txctrl_txdesc_wbro_wrf(d, i, 0);
886         if (i < 64) {
887             e10k_dca_rxctrl_1_rxhdr_ro_wrf(d, i, 0);
888             e10k_dca_rxctrl_1_rxdata_wrro_wrf(d, i, 0);
889         } else {
890             e10k_dca_rxctrl_2_rxhdr_ro_wrf(d, i - 64, 0);
891             e10k_dca_rxctrl_2_rxdata_wrro_wrf(d, i - 64, 0);
892         }
893     }
894
895     // disable all queues
896     for (i = 0; i < 128; i++) {
897         e10k_txdctl_enable_wrf(d, i, 0);
898         if (i < 64) {
899             e10k_rxdctl_1_enable_wrf(d, i, 0);
900         } else {
901             e10k_rxdctl_2_enable_wrf(d, i - 64, 0);
902         }
903     }
904
905     for(i = 0; i < 64; i++) {
906         e10k_pfvml2flt_mpe_wrf(d, i, 1);
907         e10k_pfvml2flt_bam_wrf(d, i, 1);
908         e10k_pfvml2flt_aupe_wrf(d, i, 1);
909     }
910
911 #ifdef DCA_ENABLED
912     // Enable DCA (Direct Cache Access)
913     {
914         e10k_dca_ctrl_t dca_ctrl = 0;
915         dca_ctrl = e10k_dca_ctrl_dca_mode_insert(dca_ctrl, e10k_dca10);
916         e10k_dca_ctrl_wr(d, dca_ctrl);
917     }
918
919     printf("DCA globally enabled\n");
920 #endif
921
922     DEBUG("Card initialized (%d)\n", initialized_before);
923
924
925     // Restore configuration
926     if (initialized_before) {
927         // Restoring filters
928         for (i = 0; i < 128; i++) {
929             if (filters[i].enabled) {
930                 e10k_flt_ftqf_setup(i, filters + i);
931             }
932         }
933
934         // Restoring queues
935         for (i = 0; i < 128; i++) {
936             if (queues[i].enabled) {
937                 queue_hw_init(i, true);
938             }
939         }
940
941         DEBUG("Configuration restored\n");
942     }
943
944     initialized = 1;
945 }
946
947 /** Initialize hardware queue n. */
948 static void queue_hw_init(uint8_t n, bool set_tail)
949 {
950     errval_t r;
951     struct frame_identity frameid = { .base = 0, .bytes = 0 };
952     uint64_t tx_phys, txhwb_phys, rx_phys;
953     size_t tx_size, rx_size;
954     bool enable_global = !rxtx_enabled;
955
956     // Get physical addresses for rx/tx rings
957     r = invoke_frame_identify(queues[n].tx_frame, &frameid);
958     assert(err_is_ok(r));
959     tx_phys = frameid.base;
960     tx_size = frameid.bytes;
961
962     r = invoke_frame_identify(queues[n].rx_frame, &frameid);
963     assert(err_is_ok(r));
964     rx_phys = frameid.base;
965     rx_size = frameid.bytes;
966
967     DEBUG("tx.phys=%"PRIx64" tx.size=%"PRIu64"\n", tx_phys, tx_size);
968     DEBUG("rx.phys=%"PRIx64" rx.size=%"PRIu64"\n", rx_phys, rx_size);
969
970
971     // Initialize RX queue in HW
972     if (queues[n].rx_va) {
973         e10k_rdbal_1_wr(d, n, queues[n].rx_va);
974         e10k_rdbah_1_wr(d, n, (queues[n].rx_va) >> 32);
975     } else {
976         e10k_rdbal_1_wr(d, n, rx_phys);
977         e10k_rdbah_1_wr(d, n, rx_phys >> 32);
978     }
979     e10k_rdlen_1_wr(d, n, rx_size);
980
981     e10k_srrctl_1_bsz_pkt_wrf(d, n, queues[n].rxbufsz / 1024);
982     uint32_t hdrsz = queues[n].rxhdrsz;
983     if (hdrsz == 0) {
984         hdrsz = 128;
985     }
986     assert(hdrsz % 64 == 0);
987     assert(hdrsz >= 128 && hdrsz <= 1024);
988
989     e10k_srrctl_1_bsz_hdr_wrf(d, n, hdrsz / 64);
990     // Enable header split if desired
991     if (queues[n].rxhdrsz != 0) {
992         e10k_srrctl_1_desctype_wrf(d, n, e10k_adv_hdrsp);
993         // Split packets after TCP, UDP, IP4, IP6 and L2 headers if we enable
994         // header split
995         e10k_psrtype_split_tcp_wrf(d, n, 1);
996         e10k_psrtype_split_udp_wrf(d, n, 1);
997         e10k_psrtype_split_ip4_wrf(d, n, 1);
998         e10k_psrtype_split_ip6_wrf(d, n, 1);
999         e10k_psrtype_split_l2_wrf(d, n, 1);
1000     } else {
1001         //e10k_srrctl_1_desctype_wrf(d, n, e10k_adv_1buf);
1002         e10k_srrctl_1_desctype_wrf(d, n, e10k_legacy);
1003     }
1004     e10k_srrctl_1_bsz_hdr_wrf(d, n, 128 / 64); // TODO: Do 128 bytes suffice in
1005                                                //       all cases?
1006     e10k_srrctl_1_drop_en_wrf(d, n, 1);
1007
1008     // Set RSC status
1009     if (queues[n].use_rsc) {
1010         USER_PANIC("RSC not supported in SR-IOV mode!\n");
1011         e10k_rscctl_1_maxdesc_wrf(d, n, 3);
1012         e10k_rscctl_1_rsc_en_wrf(d, n, 1);
1013         // TODO: (how) does this work for queues >=64?
1014         e10k_psrtype_split_tcp_wrf(d, n, 1); // needed for RSC
1015     } else {
1016         e10k_rscctl_1_maxdesc_wrf(d, n, 0);
1017         e10k_rscctl_1_rsc_en_wrf(d, n, 0);
1018     }
1019
1020     // Initialize queue pointers (empty)
1021     e10k_rdt_1_wr(d, n, queues[n].rx_head);
1022     e10k_rdh_1_wr(d, n, queues[n].rx_head);
1023
1024 #ifdef VTON_DCBOFF
1025     // Open virtualization pool gate (assumes 64 VF mapping)
1026     e10k_pfvfre_wr(d, n / 64, e10k_pfvfre_rd(d, n / 64) | (1 << ((n / 2) % 32)));
1027 #endif
1028
1029     e10k_rxdctl_1_enable_wrf(d, n, 1);
1030     while (e10k_rxdctl_1_enable_rdf(d, n) == 0); // TODO: Timeout
1031     DEBUG("[%x] RX queue enabled\n", n);
1032
1033     // Setup Interrupts for this queue
1034     if (queues[n].use_irq) {
1035         uint8_t rxv, txv;
1036         // Look for interrupt vector
1037         if (queues[n].msix_intvec != 0) {
1038             if (queues[n].msix_index == -1) {
1039                 setup_interrupt(&queues[n].msix_index, queues[n].msix_intdest,
1040                                 queues[n].msix_intvec);
1041             }
1042             rxv = txv = queues[n].msix_index;
1043         } else {
1044             //rxv = QUEUE_INTRX;
1045             //txv = QUEUE_INTTX;
1046             rxv = n % 16;
1047             txv = n % 16;
1048         }
1049         DEBUG("rxv=%d txv=%d\n", rxv, txv);
1050
1051         // Setup mapping queue Rx/Tx -> interrupt
1052         uint8_t i = n / 2;
1053         if ((n % 2) == 0) {
1054             e10k_ivar_i_alloc0_wrf(d, i, rxv);
1055             e10k_ivar_i_allocval0_wrf(d, i, 1);
1056             e10k_ivar_i_alloc1_wrf(d, i, txv);
1057             e10k_ivar_i_allocval1_wrf(d, i, 1);
1058         } else {
1059             e10k_ivar_i_alloc2_wrf(d, i, rxv);
1060             e10k_ivar_i_allocval2_wrf(d, i, 1);
1061             e10k_ivar_i_alloc3_wrf(d, i, txv);
1062             e10k_ivar_i_allocval3_wrf(d, i, 1);
1063         }
1064         if (queues[n].msix_intvec != 0) {
1065             e10k_eitr_l_wr(d, rxv, 0);
1066
1067             // Enable autoclear (higher ones are always auto cleared)
1068             if (rxv < 16) {
1069                 e10k_eiac_rtxq_wrf(d, e10k_eiac_rtxq_rdf(d) | (1 << rxv));
1070             }
1071
1072         }
1073         if (rxv < 16) {
1074             // Make sure interrupt is cleared
1075             e10k_eicr_wr(d, 1 << rxv);
1076         }
1077
1078         // Enable interrupt
1079         e10k_eimsn_wr(d, rxv / 32, (1 << (rxv % 32)));
1080     }
1081
1082     // Enable RX
1083     if (enable_global) {
1084         DEBUG("[%x] Enabling RX globally...\n", n);
1085         rx_enable();
1086         DEBUG("[%x] RX globally enabled\n", n);
1087     }
1088
1089 #ifdef DCA_ENABLED
1090     {
1091         // Enable DCA for this queue
1092         e10k_dca_rxctrl_t dca_rxctrl = 0;
1093
1094         dca_rxctrl = e10k_dca_rxctrl_rxdca_desc_insert(dca_rxctrl, 1);
1095         dca_rxctrl = e10k_dca_rxctrl_rxdca_hdr_insert(dca_rxctrl, 1);
1096         dca_rxctrl = e10k_dca_rxctrl_rxdca_payl_insert(dca_rxctrl, 1);
1097
1098         uint8_t my_apic_id;
1099         errval_t err = sys_debug_get_apic_id(&my_apic_id);
1100         assert(err_is_ok(err));
1101
1102         dca_rxctrl = e10k_dca_rxctrl_cpuid_insert(dca_rxctrl, my_apic_id);
1103
1104         if(n < 64) {
1105             e10k_dca_rxctrl_1_wr(d, n, dca_rxctrl);
1106         } else {
1107             e10k_dca_rxctrl_2_wr(d, n - 64, dca_rxctrl);
1108         }
1109
1110         printf("DCA enabled on queue %d with APIC ID %d\n", n, my_apic_id);
1111     }
1112 #endif
1113
1114     // Initialize TX queue in HW
1115     if (queues[n].rx_va) {
1116         e10k_tdbal_wr(d, n, queues[n].tx_va);
1117         e10k_tdbah_wr(d, n, (queues[n].tx_va) >> 32);
1118     } else {
1119         e10k_tdbal_wr(d, n, tx_phys);
1120         e10k_tdbah_wr(d, n, tx_phys >> 32);
1121     }
1122     e10k_tdlen_wr(d, n, tx_size);
1123
1124     // Initialize TX head index write back
1125     if (!capref_is_null(queues[n].txhwb_frame)) {
1126         r = invoke_frame_identify(queues[n].txhwb_frame, &frameid);
1127         assert(err_is_ok(r));
1128         txhwb_phys = frameid.base;
1129         if (queues[n].rx_va) {
1130             e10k_tdwbal_headwb_low_wrf(d, n, (queues[n].txhwb_va) >> 2);
1131             e10k_tdwbah_headwb_high_wrf(d, n, (queues[n].txhwb_va) >> 32);
1132         } else {
1133             e10k_tdwbal_headwb_low_wrf(d, n, txhwb_phys >> 2);
1134             e10k_tdwbah_headwb_high_wrf(d, n, txhwb_phys >> 32);
1135         }
1136         e10k_tdwbal_headwb_en_wrf(d, n, 1);
1137     }
1138
1139     // Initialized by queue driver to avoid race conditions
1140     // Initialize queue pointers
1141     e10k_tdh_wr(d, n, queues[n].tx_head);
1142     e10k_tdt_wr(d, n, queues[n].tx_head);
1143
1144     // Configure prefetch and writeback threshhold
1145     e10k_txdctl_pthresh_wrf(d, n, 8); // FIXME: Figure out what the right number
1146                                       //        is here.
1147     e10k_txdctl_hthresh_wrf(d, n, 0);
1148     e10k_txdctl_wthresh_wrf(d, n, 0);
1149
1150     if (enable_global) {
1151         DEBUG("[%x] Enabling TX globally...\n", n);
1152         tx_enable();
1153         rxtx_enabled = true;
1154         DEBUG("[%x] TX globally enabled\n", n);
1155     }
1156
1157 #ifdef VTON_DCBOFF
1158     // Open virtualization pool gate (assumes 64 VF mapping)
1159     e10k_pfvfte_wr(d, n / 64, e10k_pfvfte_rd(d, n / 64) | (1 << ((n / 2) % 32)));
1160 #endif
1161
1162     e10k_txdctl_enable_wrf(d, n, 1);
1163     while (e10k_txdctl_enable_rdf(d, n) == 0); // TODO: Timeout
1164     DEBUG("[%x] TX queue enabled\n", n);
1165
1166     // Some initialization stuff from BSD driver
1167     e10k_dca_txctrl_txdesc_wbro_wrf(d, n, 0);
1168
1169     if (set_tail) {
1170         idc_write_queue_tails(queues[n].binding);
1171     }
1172 }
1173
1174 #ifndef LIBRARY
1175 /** Stop queue. */
1176 static void queue_hw_stop(uint8_t n)
1177 {
1178     // This process is described in 4.6.7.1.2
1179
1180     // Disable TX for this queue
1181     e10k_txdctl_enable_wrf(d, n, 0);
1182
1183     // TODO: Flush packet buffers
1184     // TODO: Remove all filters
1185     // TODO: With RSC we have to wait here (see spec), not used atm
1186
1187     // Disable RX for this queue
1188     e10k_rxdctl_1_enable_wrf(d, n, 0);
1189     while (e10k_rxdctl_1_enable_rdf(d, n) != 0); // TODO: Timeout
1190
1191     // A bit too much, but make sure memory is not used anymore
1192     milli_sleep(1);
1193 }
1194 #endif
1195
1196
1197 /** Stop whole device. */
1198 static void stop_device(void)
1199 {
1200     int i = 0;
1201
1202     DEBUG("Stopping device\n");
1203
1204     // Disable RX and TX
1205     rx_disable();
1206     tx_disable();
1207     rxtx_enabled = false;
1208
1209     // Disable interrupts
1210     e10k_eimc_cause_wrf(d, 0x7FFFFFFF);
1211     e10k_eicr_rd(d);
1212
1213     // Disable each RX and TX queue
1214     for (i = 0; i < 128; i++) {
1215         e10k_txdctl_wr(d, i, e10k_txdctl_swflsh_insert(0x0, 1));
1216
1217         if (i < 64) {
1218             e10k_rxdctl_1_wr(d, i, 0x0);
1219         } else {
1220             e10k_rxdctl_2_wr(d, i - 64, 0x0);
1221         }
1222
1223     }
1224
1225     // From BSD driver (not in spec)
1226     milli_sleep(2);
1227
1228     // Master disable procedure
1229     e10k_ctrl_pcie_md_wrf(d, 1);
1230     while (e10k_status_pcie_mes_rdf(d) != 0); // TODO: Timeout
1231     DEBUG("Stopping device done\n");
1232 }
1233
1234 static void management_interrupt(e10k_eicr_t eicr)
1235 {
1236     if (e10k_eicr_ecc_extract(eicr)) {
1237         DEBUG("##########################################\n");
1238         DEBUG("ECC Error, resetting device :-/\n");
1239         DEBUG("##########################################\n");
1240         device_init();
1241     } else if (eicr >> 16) {
1242         DEBUG("Interrupt: %x\n", eicr);
1243         e10k_eicr_prtval(buf, sizeof(buf), eicr);
1244         puts(buf);
1245     } else if (msix) {
1246         DEBUG("Weird management interrupt without cause: eicr=%x\n", eicr);
1247     }
1248 }
1249
1250 static void interrupt_handler_msix(void* arg)
1251 {
1252     DEBUG("e10k: MSI-X management interrupt\n");
1253     e10k_eicr_t eicr = e10k_eicr_rd(d);
1254
1255     eicr &= ~(1 << cdriver_msix);
1256     management_interrupt(eicr);
1257
1258     // Ensure management MSI-X vector is cleared
1259     e10k_eicr_wr(d, (1 << cdriver_msix));
1260
1261     // Reenable interrupt
1262     e10k_eimsn_cause_wrf(d, cdriver_msix / 32, (1 << (cdriver_msix % 32)));
1263 }
1264
1265
1266 static void resend_interrupt(void* arg)
1267 {
1268     errval_t err;
1269     uint64_t i = (uint64_t) arg;
1270     err = queues[i].devif->tx_vtbl.interrupt(queues[i].devif, NOP_CONT, i);
1271     // If the queue is busy, there is already an oustanding message
1272     if (err_is_fail(err) && err != FLOUNDER_ERR_TX_BUSY) {
1273         USER_PANIC("Error when sending interrupt %s \n", err_getstring(err));
1274     }
1275 }
1276
1277 /** Here are the global interrupts handled. */
1278 static void interrupt_handler(void* arg)
1279 {
1280     errval_t err;
1281     e10k_eicr_t eicr = e10k_eicr_rd(d);
1282
1283     if (eicr >> 16) {
1284         management_interrupt(eicr);
1285     }
1286     e10k_eicr_wr(d, eicr);
1287
1288     for (uint64_t i = 0; i < 16; i++) {
1289         if ((eicr >> i) & 0x1) {
1290             DEBUG("Interrupt eicr=%"PRIx32" \n", eicr);
1291             if (queues[i].use_irq && queues[i].devif != NULL) {
1292                 err = queues[i].devif->tx_vtbl.interrupt(queues[i].devif, NOP_CONT, i);
1293                 if (err_is_fail(err)) {
1294                     err = queues[i].devif->register_send(queues[i].devif,
1295                                                          get_default_waitset(),
1296                                                          MKCONT(resend_interrupt,
1297                                                                 (void*)i));
1298                 }
1299             }
1300         }
1301     }
1302 }
1303
1304 /******************************************************************************/
1305 /* Management interface implemetation */
1306
1307 /** Send register cap and mac address to queue driver. */
1308 static void idc_queue_init_data(struct e10k_binding *b,
1309                                 struct capref registers,
1310                                 uint64_t macaddr)
1311 {
1312     errval_t r;
1313     r = e10k_queue_init_data__tx(b, NOP_CONT, registers, macaddr);
1314     // TODO: handle busy
1315     assert(err_is_ok(r));
1316 }
1317
1318 /** Tell queue driver that we are done initializing the queue. */
1319 static void idc_queue_memory_registered(struct e10k_binding *b)
1320 {
1321     errval_t r;
1322     r = e10k_queue_memory_registered__tx(b, NOP_CONT);
1323     // TODO: handle busy
1324     assert(err_is_ok(r));
1325 }
1326
1327 /** Send request to queue driver to rewrite the tail pointers of its queues. */
1328 static void idc_write_queue_tails(struct e10k_binding *b)
1329 {
1330     errval_t r;
1331     if (b == NULL) {
1332         qd_write_queue_tails(b);
1333         return;
1334     }
1335
1336     r = e10k_write_queue_tails__tx(b, NOP_CONT);
1337     // TODO: handle busy
1338     assert(err_is_ok(r));
1339 }
1340
1341 /** Request from queue driver for register memory cap */
1342 void cd_request_device_info(struct e10k_binding *b)
1343 {
1344     assert(initialized);
1345 #ifdef LIBRARY
1346     uint64_t d_mac = e10k_ral_ral_rdf(d, qi) | ((uint64_t) e10k_rah_rah_rdf(d, qi) << 32);
1347     DEBUG("mac valid = %x\n", e10k_rah_av_rdf(d, qi));
1348 #else
1349     uint64_t d_mac = e10k_ral_ral_rdf(d, 0) | ((uint64_t) e10k_rah_rah_rdf(d, 0) << 32);
1350     DEBUG("mac valid = %x\n", e10k_rah_av_rdf(d, 0));
1351 #endif
1352
1353     if (b == NULL) {
1354         struct capref cr;
1355         errval_t err = slot_alloc(&cr);
1356         assert(err_is_ok(err));
1357         err = cap_copy(cr, *regframe);
1358         assert(err_is_ok(err));
1359         qd_queue_init_data(b, cr, d_mac);
1360         return;
1361     }
1362     idc_queue_init_data(b, *regframe, d_mac);
1363 }
1364
1365 /** Request from queue driver to initialize hardware queue. */
1366 void cd_register_queue_memory(struct e10k_binding *b,
1367                               uint8_t n,
1368                               struct capref tx_frame,
1369                               struct capref txhwb_frame,
1370                               struct capref rx_frame,
1371                               uint32_t rxbufsz,
1372                               uint32_t rxhdrsz,
1373                               int16_t msix_intvec,
1374                               uint8_t msix_intdest,
1375                               bool use_irq,
1376                               bool use_rsc,
1377                               lvaddr_t tx_va,
1378                               lvaddr_t rx_va,
1379                               lvaddr_t txhwb_va)
1380 {
1381     DEBUG("register_queue_memory(%"PRIu8")\n", n);
1382     // TODO: Make sure that rxbufsz is a power of 2 >= 1024
1383
1384     if (use_irq && msix_intvec != 0 && !msix) {
1385         printf("e10k: Queue %d requests MSI-X, but MSI-X is not enabled "
1386                 " card driver. Ignoring queue\n", n);
1387         return;
1388     }
1389     // Save state so we can restore the configuration in case we need to do a
1390     // reset
1391     queues[n].enabled = true;
1392     queues[n].tx_frame = tx_frame;
1393     queues[n].txhwb_frame = txhwb_frame;
1394     queues[n].rx_frame = rx_frame;
1395     queues[n].tx_head = 0;
1396     queues[n].rx_head = 0;
1397     queues[n].rxbufsz = rxbufsz;
1398     queues[n].rxhdrsz = rxhdrsz;
1399     queues[n].msix_index = -1;
1400     queues[n].msix_intvec = msix_intvec;
1401     queues[n].msix_intdest = msix_intdest;
1402     queues[n].binding = b;
1403     queues[n].use_irq = use_irq;
1404     queues[n].use_rsc = use_rsc;
1405     queues[n].tx_va = tx_va;
1406     queues[n].rx_va = rx_va;
1407     queues[n].txhwb_va = txhwb_va;
1408
1409     queue_hw_init(n, true);
1410
1411     if (b == NULL) {
1412         qd_queue_memory_registered(b);
1413         return;
1414     }
1415     idc_queue_memory_registered(b);
1416 }
1417
1418
1419 /** Request from queue driver to initialize hardware queue. */
1420 void cd_set_interrupt_rate(struct e10k_binding *b,
1421                            uint8_t n,
1422                            uint16_t rate)
1423 {
1424     DEBUG("set_interrupt_rate(%"PRIu8")\n", n);
1425
1426     uint8_t i;
1427     e10k_eitrn_t eitr = 0;
1428     eitr = e10k_eitrn_itr_int_insert(eitr, rate);
1429
1430     i = (queues[n].msix_index == -1 ? 0 : queues[n].msix_index);
1431     if (i < 24) {
1432         e10k_eitr_l_wr(d, i, eitr);
1433     } else {
1434         e10k_eitr_h_wr(d, i - 24, eitr);
1435     }
1436 }
1437
1438 #ifndef LIBRARY
1439 /**
1440  * Request from queue driver to stop hardware queue and free everything
1441  * associated with that queue.
1442  */
1443 static errval_t idc_terminate_queue(struct e10k_binding *b, uint8_t n)
1444 {
1445     DEBUG("idc_terminate_queue(q=%d)\n", n);
1446
1447     queue_hw_stop(n);
1448
1449     queues[n].enabled = false;
1450     queues[n].binding = NULL;
1451
1452     // TODO: Do we have to free the frame caps, or destroy the binding?
1453     return SYS_ERR_OK;
1454 }
1455
1456 static errval_t idc_register_port_filter(struct e10k_binding *b,
1457                                      uint64_t buf_id_rx,
1458                                      uint64_t buf_id_tx,
1459                                      uint8_t queue,
1460                                      e10k_port_type_t type,
1461                                      uint16_t port,
1462                                      errval_t *err,
1463                                      uint64_t *filter)
1464 {
1465     struct e10k_filter f = {
1466         .dst_port = port,
1467         .mask = MASK_SRCIP | MASK_DSTIP | MASK_SRCPORT,
1468         .l4_type = (type == e10k_PORT_TCP ? L4_TCP : L4_UDP),
1469         .priority = 1,
1470         .queue = queue,
1471     };
1472     *filter = -1ULL;
1473
1474     DEBUG("idc_register_port_filter: called (q=%d t=%d p=%d)\n",
1475             queue, type, port);
1476
1477     *err = reg_ftfq_filter(&f, filter);
1478     DEBUG("filter registered: err=%"PRIu64", fid=%"PRIu64"\n", *err, *filter);
1479     return SYS_ERR_OK;
1480 }
1481
1482 static errval_t idc_unregister_filter(struct e10k_binding *b,
1483                                   uint64_t filter, errval_t *err)
1484 {
1485     DEBUG("unregister_filter: called (%"PRIx64")\n", filter);
1486     *err = LIB_ERR_NOT_IMPLEMENTED;
1487     return SYS_ERR_OK;
1488 }
1489
1490 static struct e10k_rx_vtbl rx_vtbl = {
1491     .request_device_info = cd_request_device_info,
1492     .register_queue_memory = cd_register_queue_memory,
1493     .set_interrupt_rate = cd_set_interrupt_rate,
1494 };
1495
1496 static struct e10k_rpc_rx_vtbl rpc_rx_vtbl = {
1497     .terminate_queue_call = idc_terminate_queue,
1498     .register_port_filter_call = idc_register_port_filter,
1499     .unregister_filter_call = idc_unregister_filter,
1500 };
1501
1502
1503 static void export_cb(void *st, errval_t err, iref_t iref)
1504 {
1505     const char *suffix = "_e10kmng";
1506     char name[strlen(service_name) + strlen(suffix) + 1];
1507
1508     assert(err_is_ok(err));
1509
1510     // Build label for interal management service
1511     sprintf(name, "%s%s", service_name, suffix);
1512
1513     err = nameservice_register(name, iref);
1514     assert(err_is_ok(err));
1515     DEBUG("Management interface exported\n");
1516 }
1517
1518 static errval_t connect_cb(void *st, struct e10k_binding *b)
1519 {
1520     DEBUG("New connection on management interface\n");
1521     b->rx_vtbl = rx_vtbl;
1522     b->rpc_rx_vtbl = rpc_rx_vtbl;
1523     return SYS_ERR_OK;
1524 }
1525
1526 /**
1527  * Initialize management interface for queue drivers.
1528  * This has to be done _after_ the hardware is initialized.
1529  */
1530 static void initialize_mngif(void)
1531 {
1532     errval_t r;
1533
1534     r = e10k_export(NULL, export_cb, connect_cb, get_default_waitset(),
1535                     IDC_BIND_FLAGS_DEFAULT);
1536     assert(err_is_ok(r));
1537 }
1538 #endif
1539
1540 /****** VF/PF server interface *******/
1541
1542 static void init_done_vf(struct e10k_vf_binding *b, uint8_t vfn)
1543 {
1544     assert(vfn < 64);
1545
1546     DEBUG("VF %d init done\n", vfn);
1547
1548     // Enable correct pool for VF
1549     e10k_pfvfre_wr(d, vfn / 32, e10k_pfvfre_rd(d, vfn / 32) | (1 << (vfn % 32)));
1550     e10k_pfvfte_wr(d, vfn / 32, e10k_pfvfte_rd(d, vfn / 32) | (1 << (vfn % 32)));
1551
1552     if(vfn < 32) {
1553         e10k_pfvflrec_wr(d, 0, 1 << vfn);
1554     } else {
1555         e10k_pfvflrec_wr(d, 1, 1 << (vfn - 32));
1556     }
1557
1558     errval_t err = b->tx_vtbl.init_done_response(b, NOP_CONT);
1559     assert(err_is_ok(err));
1560 }
1561
1562 static void get_mac_address_vf(struct e10k_vf_binding *b, uint8_t vfn)
1563 {
1564     assert(initialized);
1565     uint64_t d_mac = e10k_ral_ral_rdf(d, vfn) | ((uint64_t) e10k_rah_rah_rdf(d, vfn) << 32);
1566     errval_t err = b->tx_vtbl.get_mac_address_response(b, NOP_CONT, d_mac);
1567     assert(err_is_ok(err));
1568 }
1569
1570 static void request_vf_number(struct e10k_vf_binding *b)
1571 {
1572     DEBUG("VF allocated\n");
1573     errval_t err;
1574     uint8_t vf_num = 255;
1575     for (int i = 0; i < 64; i++) {
1576         if (!vf_used[i]) {
1577             vf_num = i;
1578             break;
1579         }
1580     }
1581
1582     if (vf_num == 255){
1583         //TODO better error
1584         err = NIC_ERR_ALLOC_QUEUE;
1585     } else {
1586         err = SYS_ERR_OK;
1587     }
1588
1589     err = b->tx_vtbl.request_vf_number_response(b, NOP_CONT, vf_num, err);
1590     assert(err_is_ok(err));
1591 }
1592
1593
1594 static errval_t cd_create_queue_rpc(struct e10k_vf_binding *b,
1595                                     struct capref tx_frame, struct capref txhwb_frame,
1596                                     struct capref rx_frame, uint32_t rxbufsz,
1597                                     int16_t msix_intvec, uint8_t msix_intdest,
1598                                     bool use_irq, bool use_rsc, bool default_q,
1599                                     uint64_t *mac, int32_t *qid, struct capref *regs,
1600                                     errval_t *ret_err)
1601 {
1602     // TODO: Make sure that rxbufsz is a power of 2 >= 1024
1603
1604     if (use_irq && msix_intvec != 0 && !msix) {
1605         printf("e10k: Queue requests MSI-X, but MSI-X is not enabled "
1606                 " card driver. Ignoring queue\n");
1607         *ret_err = NIC_ERR_ALLOC_QUEUE;
1608         return NIC_ERR_ALLOC_QUEUE;
1609     }
1610
1611     // allocate a queue
1612     int n = -1;
1613     for (int i = 1; i < 128; i++) {
1614         if (!queues[i].enabled) {
1615             n = i;
1616             break;
1617         }
1618     }
1619
1620     if (default_q) {
1621         if (queues[0].enabled == false) {
1622             n = 0;
1623         } else {
1624             printf("Default queue already initalized \n");
1625             return NIC_ERR_ALLOC_QUEUE;
1626         }
1627     }
1628
1629     DEBUG("create queue(%"PRIu8": interrupt %d )\n", n, use_irq);
1630
1631     if (n == -1) {
1632         *ret_err = NIC_ERR_ALLOC_QUEUE;
1633         return NIC_ERR_ALLOC_QUEUE;
1634     }
1635
1636     // Save state so we can restore the configuration in case we need to do a
1637     // reset
1638     
1639     queues[n].tx_frame = tx_frame;
1640     queues[n].txhwb_frame = txhwb_frame;
1641     queues[n].rx_frame = rx_frame;
1642     queues[n].tx_head = 0;
1643     queues[n].rx_head = 0;
1644     queues[n].devif = b;
1645     queues[n].rxbufsz = rxbufsz;
1646     queues[n].msix_index = -1;
1647     queues[n].msix_intvec = msix_intvec;
1648     queues[n].msix_intdest = msix_intdest;
1649     queues[n].use_irq = use_irq;
1650     queues[n].use_rsc = use_rsc;
1651     queues[n].enabled = true;
1652     
1653
1654     queue_hw_init(n, false);
1655
1656     // TODO for now vfn = 0
1657     uint64_t d_mac = e10k_ral_ral_rdf(d, 0) | ((uint64_t) e10k_rah_rah_rdf(d, 0) << 32);
1658
1659     *regs = *regframe;
1660     *qid = n;
1661     *mac = d_mac;
1662
1663     DEBUG("[%d] Queue int done\n", n);
1664     *ret_err = SYS_ERR_OK;
1665     return SYS_ERR_OK;
1666 }
1667
1668 static void cd_create_queue(struct e10k_vf_binding *b,
1669                             struct capref tx_frame, struct capref txhwb_frame,
1670                             struct capref rx_frame, uint32_t rxbufsz,
1671                             int16_t msix_intvec, uint8_t msix_intdest,
1672                             bool use_irq, bool use_rsc, bool default_q)
1673 {
1674
1675     uint64_t mac;
1676     int queueid;
1677     errval_t err;
1678
1679     struct capref regs;
1680
1681     err = cd_create_queue_rpc(b, tx_frame, txhwb_frame, rx_frame,
1682                               rxbufsz, msix_intvec, msix_intdest, use_irq, use_rsc,
1683                               default_q, &mac, &queueid, &regs, &err);
1684
1685     err = b->tx_vtbl.create_queue_response(b, NOP_CONT, mac, queueid, regs, err);
1686     assert(err_is_ok(err));
1687     DEBUG("cd_create_queue end\n");
1688 }
1689
1690 static void vf_export_cb(void *st, errval_t err, iref_t iref)
1691 {
1692     const char *suffix = "_vf";
1693     char name[strlen(service_name) + strlen(suffix) + 100];
1694
1695     assert(err_is_ok(err));
1696
1697     // Build label for interal management service
1698     sprintf(name, "%s%s%u", service_name, suffix, pci_function);
1699
1700     err = nameservice_register(name, iref);
1701     assert(err_is_ok(err));
1702     DEBUG("VF/PF interface [%s] exported\n", name);
1703     exported = true;
1704 }
1705
1706 static errval_t vf_connect_cb(void *st, struct e10k_vf_binding *b)
1707 {
1708     DEBUG("New connection on VF/PF interface\n");
1709
1710     b->rx_vtbl.create_queue_call = cd_create_queue;
1711     b->rx_vtbl.request_vf_number_call = request_vf_number;
1712     b->rx_vtbl.init_done_call = init_done_vf;
1713     b->rx_vtbl.get_mac_address_call = get_mac_address_vf;
1714
1715     b->rpc_rx_vtbl.create_queue_call = cd_create_queue_rpc;
1716
1717
1718     return SYS_ERR_OK;
1719 }
1720
1721 /**
1722  * Initialize management interface for queue drivers.
1723  * This has to be done _after_ the hardware is initialized.
1724  */
1725 static void initialize_vfif(void)
1726 {
1727     errval_t r;
1728
1729     r = e10k_vf_export(NULL, vf_export_cb, vf_connect_cb, get_default_waitset(),
1730                        IDC_BIND_FLAGS_DEFAULT);
1731     assert(err_is_ok(r));
1732
1733     r = net_filter_export(NULL, net_filter_export_cb, net_filter_connect_cb,
1734                           get_default_waitset(), IDC_BIND_FLAGS_DEFAULT);
1735     assert(err_is_ok(r));
1736 }
1737
1738 /******************************************************************************/
1739 /* Initialization code for driver */
1740
1741 /** Callback from pci to initialize a specific PCI device. */
1742 static void pci_init_card(void *arg, struct device_mem* bar_info, int bar_count)
1743 {
1744     errval_t err;
1745     bool res;
1746
1747     assert(!initialized);
1748
1749     d = malloc(sizeof(*d));
1750
1751     // Map first BAR for register access
1752     assert(bar_count >= 1);
1753     map_device(&bar_info[0]);
1754     regframe = bar_info[0].frame_cap;
1755     DEBUG("BAR[0] mapped (v=%llx p=%llx l=%llx)\n",
1756             (unsigned long long) bar_info[0].vaddr,
1757             (unsigned long long) bar_info[0].paddr,
1758             (unsigned long long) bar_info[0].bytes);
1759
1760     // Initialize Mackerel binding
1761     e10k_initialize(d, (void*) bar_info[0].vaddr);
1762
1763     DEBUG("STATUS = %x\n", e10k_status_rd(d));
1764
1765     // Initialize manager for MSI-X vectors
1766     if (msix) {
1767         DEBUG("Enabling MSI-X interrupts\n");
1768         uint16_t msix_count = 0;
1769         err = pci_msix_enable(&msix_count);
1770         assert(err_is_ok(err));
1771         assert(msix_count > 0);
1772         DEBUG("MSI-X #vecs=%d\n", msix_count);
1773
1774         res = bmallocator_init(&msix_alloc, msix_count);
1775         assert(res);
1776     } else {
1777         DEBUG("Using legacy interrupts\n");
1778     }
1779
1780     // Initialize hardware registers etc.
1781     DEBUG("Initializing hardware\n");
1782     device_init();
1783
1784     assert(initialized);
1785
1786 #ifdef VTON_DCBOFF
1787     DEBUG("SR-IOV device up routine\n");
1788
1789     // Setup support for 64 VFs
1790     e10k_gcr_ext_vtmode_wrf(d, e10k_vt_64);
1791     e10k_gpie_vtmode_wrf(d, e10k_vt_64);
1792
1793     // Enable virtualization, disable default pool, replication enable
1794     e10k_pfvtctl_t pfvtctl = e10k_pfvtctl_rd(d);
1795     pfvtctl = e10k_pfvtctl_vt_en_insert(pfvtctl, 1);
1796     pfvtctl = e10k_pfvtctl_def_pl_insert(pfvtctl, 0);
1797     pfvtctl = e10k_pfvtctl_dis_def_pl_insert(pfvtctl, 1);
1798     pfvtctl = e10k_pfvtctl_rpl_en_insert(pfvtctl, 1);
1799     e10k_pfvtctl_wr(d, pfvtctl);
1800
1801     // Enable L2 loopback
1802     e10k_pfdtxgswc_lbe_wrf(d, 1);
1803
1804     // TODO: Accept untagged packets in all VMDQ pools
1805     // TODO: Broadcast accept mode
1806     // TODO: Accept packets matching PFUTA table
1807     // TODO: Accept packets matching MTA table
1808     // TODO: Accept untagged packets enable
1809     // TODO: Strip VLAN tag for incoming packets
1810
1811     DEBUG("STATUS = %x\n", e10k_status_rd(d));
1812
1813     e10k_ctrl_ext_pfrstd_wrf(d, 1);
1814 #endif
1815
1816 #ifndef LIBRARY
1817     // Now we initialize the management interface
1818     DEBUG("Initializing management interface\n");
1819     initialize_mngif();
1820 #endif
1821
1822     DEBUG("Initializing VF/PF interface\n");
1823     initialize_vfif();
1824     DEBUG("Done with initialization\n");
1825 }
1826
1827
1828 /** Register with PCI */
1829 static void pci_register(void)
1830 {
1831     errval_t r;
1832
1833     r = pci_client_connect();
1834     assert(err_is_ok(r));
1835     DEBUG("connected to pci\n");
1836
1837     r = pci_register_driver_irq(pci_init_card, NULL, PCI_CLASS_ETHERNET,
1838                                 PCI_DONT_CARE, PCI_DONT_CARE,
1839                                 PCI_VENDOR_INTEL, pci_deviceid,
1840                                 pci_bus, pci_device, pci_function,
1841                                 interrupt_handler, NULL);
1842     assert(err_is_ok(r));
1843 }
1844
1845 static void parse_cmdline(int argc, char **argv)
1846 {
1847     int i;
1848
1849     for (i = 1; i < argc; i++) {
1850         if (strncmp(argv[i], "cardname=", strlen("cardname=")) == 0) {
1851             service_name = argv[i] + strlen("cardname=");
1852         } else if (strncmp(argv[i], "bus=", strlen("bus=")) == 0) {
1853             pci_bus = atol(argv[i] + strlen("bus="));
1854         } else if (strncmp(argv[i], "device=", strlen("device=")) == 0) {
1855             pci_device = atol(argv[i] + strlen("device="));
1856         } else if (strncmp(argv[i], "function=", strlen("function=")) == 0) {
1857             pci_function = atol(argv[i] + strlen("function="));
1858         } else if (strncmp(argv[i], "deviceid=", strlen("deviceid=")) == 0) {
1859             pci_deviceid = strtoul(argv[i] + strlen("deviceid="), NULL, 0);
1860         } else if (strncmp(argv[i], "msix=", strlen("msix=")) == 0) {
1861             msix = !!atol(argv[i] + strlen("msix="));
1862             // also pass this to queue driver
1863             qd_argument(argv[i]);
1864         } else if (strncmp(argv[i], "credit_refill[", strlen("credit_refill[") - 1) == 0) {
1865             // Controls the WRR (weighted round-robin) scheduler's credit refill rate
1866             // This seems to be per VM pool
1867             unsigned int entry, val;
1868             int r = sscanf(argv[i], "credit_refill[%u]=%u", &entry, &val);
1869             assert(r == 2);
1870             assert(entry < 128);
1871             assert(val < 0x3fff);
1872             credit_refill[entry] = val;
1873         } else if (strncmp(argv[i], "tx_rate[", strlen("tx_rate[") - 1) == 0) {
1874             // This is specified in Mbits/s and must be >= 10 and <= link speed (typically 10,000)
1875             // This seems to be per Tx queue
1876             unsigned int entry, val;
1877             int r = sscanf(argv[i], "tx_rate[%u]=%u", &entry, &val);
1878             assert(r == 2);
1879             assert(entry < 128);
1880             assert(val >= 10 && val <= 10000);
1881             tx_rate[entry] = val;
1882         } else {
1883             qd_argument(argv[i]);
1884         }
1885     }
1886 }
1887
1888 #ifndef LIBRARY
1889 static void eventloop(void)
1890 {
1891     struct waitset *ws;
1892     
1893     printf("Entering polling loop\n");
1894     ws = get_default_waitset();
1895     while (1) {
1896         if (use_interrupts) {
1897             event_dispatch(ws);
1898         } else {
1899             networking_poll();
1900         }
1901     }
1902 }
1903
1904 void qd_main(void)
1905 {
1906     eventloop();
1907 }
1908
1909 void qd_argument(const char *arg) { }
1910 void qd_interrupt(bool is_rx, bool is_tx) { }
1911 void qd_queue_init_data(struct e10k_binding *b, struct capref registers,
1912         uint64_t macaddr) { }
1913 void qd_queue_memory_registered(struct e10k_binding *b) { }
1914 void qd_write_queue_tails(struct e10k_binding *b) { }
1915
1916 int main(int argc, char **argv)
1917 #else
1918 int e1000n_driver_init(int argc, char *argv[])
1919 #endif
1920 {
1921     //barrelfish_usleep(10*1000*1000);
1922     DEBUG("PF driver started\n");
1923     // credit_refill value must be >= 1 for a queue to be able to send.
1924     // Set them all to 1 here. May be overridden via commandline.
1925     for(int i = 0; i < 128; i++) {
1926         credit_refill[i] = 1;
1927     }
1928
1929     memset(tx_rate, 0, sizeof(tx_rate));
1930
1931     parse_cmdline(argc, argv);
1932     pci_register();
1933
1934     while (!initialized || !exported) {
1935         event_dispatch(get_default_waitset());
1936     }
1937
1938     DEBUG("e10k driver networking init \n");
1939     errval_t err;
1940     if (use_interrupts){
1941         err = networking_init("e10k", NET_FLAGS_DO_DHCP | NET_FLAGS_DEFAULT_QUEUE);
1942     } else {
1943         err = networking_init("e10k", NET_FLAGS_DO_DHCP | NET_FLAGS_POLLING |
1944                               NET_FLAGS_DEFAULT_QUEUE);
1945     }
1946     DEBUG("e10k driver networking init done with error: %s \n", err_getstring(err));
1947     assert(err_is_ok(err));
1948
1949     qd_main();
1950     return 1;
1951 }