solarflare: init queue 0 in driver
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Tue, 11 Apr 2017 14:59:06 +0000 (16:59 +0200)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Tue, 11 Apr 2017 14:59:06 +0000 (16:59 +0200)
Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

if/sfn5122f_devif.if
include/devif/backends/net/sfn5122f_devif.h
lib/devif/backends/net/solarflare/devif_backend_solarflare.c
lib/net/include/net/net.h
lib/net/net.c
lib/net_interfaces/interface_raw.c
usr/drivers/solarflare/Hakefile
usr/drivers/solarflare/sfn5122f_cdriver.c
usr/tests/devif/queue_interface.c

index d180a10..d66dbdc 100644 (file)
@@ -18,6 +18,7 @@ interface sfn5122f_devif "sfn5122f devif communication interface" {
     // create and destroy a queue. Only the device driver itself should
     // access configuration registers
     rpc create_queue(in cap frame, in bool user, in bool interrupt,
+                     in bool qzero,
                      in uint8 core, in uint8 vector,
                      out uint64 mac, out uint16 qid, 
                      out cap regs, out errval err);
index 29d80e8..f51ce6a 100644 (file)
@@ -13,6 +13,6 @@ struct sfn5122f_queue;
 typedef void (*sfn5122f_event_cb_t)(void* q);
 
 errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb, 
-                               bool userspace, bool interrupts);
+                               bool userspace, bool interrupts, bool default_q);
 errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q);
 #endif
index e645546..4b33ede 100644 (file)
@@ -489,7 +489,7 @@ static void interrupt_handler(void* arg)
  */
 
 errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb,
-                               bool userlevel, bool interrupts)
+                               bool userlevel, bool interrupts, bool qzero)
 {
     DEBUG_QUEUE("create called \n");
 
@@ -565,7 +565,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
         printf("Solarflare queue used in polling mode \n");
         err = queue->b->rpc_tx_vtbl.create_queue(queue->b, frame, userlevel,
                                                  interrupts,
-                                                 0, 0, &queue->mac ,&queue->id, 
+                                                 0, 0, qzero, &queue->mac ,&queue->id, 
                                                  &regs, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
@@ -579,7 +579,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
         queue->core = disp_get_core_id();
         
         err = queue->b->rpc_tx_vtbl.create_queue(queue->b, frame, userlevel,
-                                                 interrupts, queue->core,
+                                                 interrupts, qzero, queue->core,
                                                  queue->vector, &queue->mac, 
                                                  &queue->id, &regs, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
index 792d489..8656db6 100644 (file)
@@ -34,6 +34,8 @@ struct eth_addr;
 
 #define NET_FLAGS_BLOCKING_INIT          (1 << 2)
 
+///< initalize with default queue
+#define NET_FLAGS_DEFAULT_QUEUE          (1 << 3)
 ///< networking flags
 typedef uint32_t net_flags_t;
 
index 8f6f6ca..6f14cbd 100644 (file)
@@ -94,7 +94,8 @@ static errval_t create_sfn5122f_queue (struct net_state *st, uint64_t queueid, s
 
     return sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, int_handler,
                                 false /*userlevel network feature*/,
-                                !(st->flags & NET_FLAGS_POLLING) /* user interrupts*/);
+                                !(st->flags & NET_FLAGS_POLLING) /* user interrupts*/,
+                                (st->flags & NET_FLAGS_DEFAULT_QUEUE));
 }
 
 
index 5850c72..bb8f00a 100644 (file)
@@ -231,7 +231,8 @@ void net_if_init(const char* cardname, uint64_t qid)
         struct sfn5122f_queue* sfn5122f;
         err = sfn5122f_queue_create(&sfn5122f, int_handler, 
                                     false /*userlevel network feature*/, 
-                                    true /* user interrupts*/);
+                                    true /* user interrupts*/,
+                                    false);
         assert(err_is_ok(err));
 
         devq = (struct devq*) sfn5122f; 
index dc45321..6048d20 100644 (file)
                         ("net_filter",["rpcclient"])
                         ],
                       mackerelDevices = [ "sfn5122f"],
+                      addIncludes  = [ "include", "/lib/net/include/" ],
                       addLibraries = libDeps["netQmng", "pci", "contmng", 
                                              "net_device_manager", "bench", "trace", "skb",
-                                             "spawndomain", "netd" ]
+                                             "spawndomain", "netd" , "net"]
                     }
   ]
 
index e256322..1626b5f 100644 (file)
@@ -16,6 +16,7 @@
 #include <barrelfish/spawn_client.h>
 #include <barrelfish/deferred.h>
 #include <netd/netd.h>
+#include <net/net.h>
 #include <net_device_manager/net_device_manager.h>
 #include <pci/pci.h>
 #include <ipv4/lwip/inet.h>
@@ -23,8 +24,6 @@
 #include <if/sfn5122f_defs.h>
 #include <if/sfn5122f_devif_defs.h>
 #include <if/net_filter_defs.h>
-#include <if/net_ARP_defs.h>
-#include <if/net_ARP_defs.h>
 
 #include "sfn5122f.h"
 #include "sfn5122f_debug.h"
@@ -1170,7 +1169,7 @@ static void global_interrupt_handler(void* arg)
 
     q_to_check = sfn5122f_int_isr0_reg_lo_rd(d);
 
-    for (uint64_t i = 1; i < 32; i++) {
+    for (uint64_t i = 0; i < 32; i++) {
         if ((q_to_check >> i) & 0x1) {
             if (queues[i].use_irq && queues[i].devif != NULL) {
                 DEBUG("Interrupt to queue %lu \n", i);
@@ -1184,13 +1183,6 @@ static void global_interrupt_handler(void* arg)
         }
     }
 
-    if (q_to_check & 0x1) {
-        DEBUG("Interrupt to queue 0 \n");
-        check_queue_0();
-    }
-
-
-   
     // Don't need to start event queues because we're already polling
 
 }
@@ -1326,8 +1318,10 @@ void cd_register_queue_memory(struct sfn5122f_binding *b,
 
 
 static errval_t cd_create_queue_rpc(struct sfn5122f_devif_binding *b, struct capref frame,
-                    bool user, bool interrupt, uint8_t core, uint8_t msix_vector,
-                    uint64_t *mac, uint16_t *qid, struct capref *regs, errval_t *ret_err)
+                    bool user, bool interrupt, bool qzero, 
+                    uint8_t core, uint8_t msix_vector, 
+                    uint64_t *mac, uint16_t *qid, struct capref *regs, 
+                    errval_t *ret_err)
 {
 
     DEBUG("cd_create_queue \n");
@@ -1343,15 +1337,20 @@ static errval_t cd_create_queue_rpc(struct sfn5122f_devif_binding *b, struct cap
         }
     }
 
-
     if (n == -1) {
         *ret_err = NIC_ERR_ALLOC_QUEUE;
         *regs = NULL_CAP;
-//        err = b->tx_vtbl.create_queue_response(b, NOP_CONT, 0, 0, NULL_CAP, err);
-//        //err = b->tx_vtbl.create_queue_response(b, NOP_CONT, 0, err);
-//        assert(err_is_ok(err));
         return NIC_ERR_ALLOC_QUEUE;
     }
+    
+    if (qzero) {
+        if (queues[0].enabled == false) {
+            n = 0;
+        } else {
+            printf("Default queue already initalized \n");
+            return NIC_ERR_ALLOC_QUEUE;
+        }
+    }
 
     b->st = &queues[n];
 
@@ -1392,12 +1391,10 @@ static errval_t cd_create_queue_rpc(struct sfn5122f_devif_binding *b, struct cap
         *ret_err = NIC_ERR_ALLOC_QUEUE;
         *regs = NULL_CAP;
         return NIC_ERR_ALLOC_QUEUE;
-        //err = b->tx_vtbl.create_queue_response(b, NOP_CONT, 0, err);
     }
 
     queues[n].enabled = true;
     DEBUG("created queue %d \n", n);
-    //err = b->tx_vtbl.create_queue_response(b, NOP_CONT, n, *regframe, SYS_ERR_OK);a
 
     *mac = d_mac[pci_function];
     *qid = n;
@@ -1415,7 +1412,8 @@ static errval_t cd_create_queue_rpc(struct sfn5122f_devif_binding *b, struct cap
 
 
 static void cd_create_queue(struct sfn5122f_devif_binding *b, struct capref frame,
-                            bool user, bool interrupt, uint8_t core, uint8_t msix_vector)
+                            bool user, bool interrupt, bool qzero, uint8_t core, 
+                            uint8_t msix_vector)
 {
 
     uint64_t mac;
@@ -1425,7 +1423,7 @@ static void cd_create_queue(struct sfn5122f_devif_binding *b, struct capref fram
     struct capref regs;
 
 
-    cd_create_queue_rpc(b, frame, user, interrupt, core, msix_vector, &mac, &queueid, &regs, &err);
+    cd_create_queue_rpc(b, frame, user, interrupt, false, core, msix_vector, &mac, &queueid, &regs, &err);
 
     err = b->tx_vtbl.create_queue_response(b, NOP_CONT, mac, queueid, regs, err);
     assert(err_is_ok(err));
@@ -1646,11 +1644,6 @@ static void initialize_mngif(void)
 {
     errval_t r;
 
-    /*
-    r = sfn5122f_export(NULL, export_cb, connect_cb, get_default_waitset(),
-                    IDC_BIND_FLAGS_DEFAULT);
-    assert(err_is_ok(r));
-    */
     r = sfn5122f_devif_export(NULL, export_devif_cb, connect_devif_cb,
                               get_default_waitset(), 1);
     assert(err_is_ok(r));
@@ -1808,8 +1801,9 @@ int main(int argc, char** argv)
             pci_device = PCI_DONT_CARE;
             pci_function = 0;
         } else {
-            if ((pci_vendor != PCI_VENDOR_SOLARFLARE) || (pci_devid != DEVICE_ID)) {
-                printf("VENDOR/DEVICE ID MISMATCH: %x/%x %x/%x\n",
+            if ((pci_vendor != PCI_VENDOR_SOLARFLARE) || (pci_devid != DEVICE_ID) ||
+                (pci_function != 0)) {
+                printf("VENDOR/DEVICE ID MISMATCH: %x/%x %x/%x \n",
                         pci_vendor, PCI_VENDOR_SOLARFLARE, pci_devid, DEVICE_ID);
             }
             argc--;
@@ -1831,35 +1825,13 @@ int main(int argc, char** argv)
     while (!initialized) {
         event_dispatch(get_default_waitset());
     }
-
-    init_queue_0("sfn5122f", d_mac[pci_function], d_virt,
-                 use_interrupt, false, &queues[0].ev_frame, 
-                 &queues[0].tx_frame, &queues[0].rx_frame);
-
-    queues[0].enabled = false;
-    queues[0].tx_head = 0;
-    queues[0].rx_head = 0;
-    queues[0].ev_head = 0;
-    queues[0].rxbufsz = MTU_MAX;
-    queues[0].binding = NULL;
-    queues[0].use_irq = true;
-    queues[0].userspace = false;
-
-    struct frame_identity id;
-    err = invoke_frame_identify(queues[0].ev_frame, &id);
-    assert(err_is_ok(err));
-    queues[0].ev_buf_tbl = init_evq(0, id.base, queues[0].use_irq);
-    // enable checksums
-    err = invoke_frame_identify(queues[0].tx_frame, &id);
-    assert(err_is_ok(err));
-    queues[0].tx_buf_tbl = init_txq(0, id.base, csum_offload, false);
-
-    err = invoke_frame_identify(queues[0].rx_frame, &id);
+    
+    DEBUG("SFN5122F driver networking init \n");
+    err = networking_init("sfn5122f", NET_FLAGS_BLOCKING_INIT | NET_FLAGS_DO_DHCP |
+                          NET_FLAGS_DEFAULT_QUEUE);
     assert(err_is_ok(err));
-    queues[0].rx_buf_tbl = init_rxq(0, id.base, false);
-
-    write_queue_tails();
 
+    DEBUG("SFN5122F driver networking init done\n");
     start_all();    
     
     /* loop myself */
index 95fb4dd..203b81b 100644 (file)
@@ -154,7 +154,8 @@ static struct devq* create_net_queue(char* card_name)
         struct sfn5122f_queue* q;
         
         err = sfn5122f_queue_create(&q, event_cb, /* userlevel*/ true,
-                                    /*MSIX interrupts*/ false);
+                                    /*MSIX interrupts*/ false,
+                                    /*default queue*/ true);
         if (err_is_fail(err)){
             USER_PANIC("Allocating devq failed \n");
         }