DeviceQueue: added callback to solarflare create
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Sun, 2 Oct 2016 14:01:20 +0000 (16:01 +0200)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Sun, 2 Oct 2016 14:01:20 +0000 (16:01 +0200)
Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

include/devif/backends/net/sfn5122f_devif.h
lib/devif/backends/net/solarflare/devif_backend_solarflare.c
lib/devif/backends/net/solarflare/hw_queue.h
usr/tests/devif/queue_interface.c

index a0facb9..29d80e8 100644 (file)
@@ -10,7 +10,9 @@
 #define SFN5122F_DEVIF_H_ 1
 
 struct sfn5122f_queue;
+typedef void (*sfn5122f_event_cb_t)(void* q);
 
-errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userspace, bool interrupts);
+errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb, 
+                               bool userspace, bool interrupts);
 errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q);
 #endif
index 8d27cd9..a9b150d 100644 (file)
@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/waitset.h>
+#include <barrelfish/deferred.h>
 #include <barrelfish/nameservice_client.h>
 #include <devif/queue_interface.h>
 #include <if/sfn5122f_devif_defs.h>
@@ -27,6 +28,7 @@
     #define DEBUG_QUEUE(x...) do {} while (0)
 #endif
 
+#define DELAY 500
 
 // TX Queue
 #define TX_ENTRIES 2048
@@ -39,6 +41,7 @@
 #define EV_CODE_USER 8
 #define EV_CODE_MCDI 12
 #define EV_CODE_GLOBAL 6
+#define EV_CODE_NONE 15
 
 #define BUF_SIZE 4096
 
@@ -80,7 +83,8 @@ static errval_t update_txtail(struct sfn5122f_queue* q, size_t tail)
 static void bind_cb(void *st, errval_t err, struct sfn5122f_devif_binding *b)
 {
     
-    struct sfn5122f_queue* queue = st;
+    DEBUG_QUEUE("binding CB  \n");
+    struct sfn5122f_queue* queue = (struct sfn5122f_queue*) st;
     b->st = queue;
     // Initi RPC client
     
@@ -174,12 +178,15 @@ static errval_t sfn5122f_deregister(struct devq* q, regionid_t rid)
 
 static errval_t sfn5122f_control(struct devq* q, uint64_t cmd, uint64_t value)
 {
+
+    DEBUG_QUEUE("Control cmd=%lu value=%lu \n", cmd, value);
     return SYS_ERR_OK;
 }
 
 
 static errval_t sfn5122f_notify(struct devq* q)
 {
+    DEBUG_QUEUE("Notify \n");
     return SYS_ERR_OK;
 }
 
@@ -282,24 +289,22 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
                                  lpaddr_t* base, size_t* len, uint64_t* flags)
 {
     uint8_t ev_code;
-    bool exit = false;
-    errval_t err;    
+    errval_t err = DEVQ_ERR_RX_EMPTY;    
     
     struct sfn5122f_queue* queue = (struct sfn5122f_queue*) q;
-
-    while(!exit) {
+    
+    while(true) {
         ev_code = sfn5122f_get_event_code(queue);
         switch(ev_code){
         case EV_CODE_RX:
             // TODO multiple packets
             err = sfn5122f_queue_handle_rx_ev_devif(queue, rid, bid, base,
-                                                    len, flags);
-            exit = true;  
+                                                    len, flags);  
             if (err_is_ok(err)) {
                 DEBUG_QUEUE(" RX_EV Q_ID: %d len %ld \n", queue->id, *len);
             }
             sfn5122f_queue_bump_evhead(queue);
-            break;
+            return SYS_ERR_OK;
         case EV_CODE_TX:
             err = sfn5122f_queue_handle_tx_ev_devif(queue, rid, bid, base, 
                                                     len, flags);
@@ -309,9 +314,8 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
                 DEBUG_QUEUE("TX EVENT ERR %d \n", queue->id);
             }
 
-            exit = true;
             sfn5122f_queue_bump_evhead(queue);
-            break;
+            return SYS_ERR_OK;
         case EV_CODE_DRV:
             //DEBUG_QUEUE("DRIVER EVENT %d\n", qi);
             sfn5122f_handle_drv_ev(queue, queue->id);
@@ -334,9 +338,11 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
             DEBUG_QUEUE("GLOBAL EVENT \n");
             sfn5122f_queue_bump_evhead(queue);
             break;
+        case EV_CODE_NONE:
+            sfn5122f_evq_rptr_reg_wr(queue->device, queue->id, 
+                                     queue->ev_head);
+            return err;
         }
-        sfn5122f_evq_rptr_reg_wr(queue->device, queue->id, 
-                                 queue->ev_head);
     }
 
     return err;
@@ -347,9 +353,10 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
  *
  */
 
-errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userlevel, 
+errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb, bool userlevel, 
                                bool interrupts)
 {
+    DEBUG_QUEUE("create called \n");
 
     errval_t err;
     struct capref tx_frame, rx_frame, ev_frame;
@@ -383,6 +390,8 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userlevel,
         return SFN_ERR_ALLOC_QUEUE;
     }
 
+
+    DEBUG_QUEUE("queue init \n");
     // Init queue
     queue = sfn5122f_queue_init(tx_virt, TX_ENTRIES, rx_virt, RX_ENTRIES,
                                 ev_virt, EV_ENTRIES, &ops,  NULL, true);
@@ -398,9 +407,9 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userlevel,
         return err;
     }
 
-    err = sfn5122f_devif_bind(iref, bind_cb, q, get_default_waitset(),
+    DEBUG_QUEUE("binding \n");
+    err = sfn5122f_devif_bind(iref, bind_cb, queue, get_default_waitset(),
                               1);
-
     if (err_is_fail(err)) {
         return err;
     }
@@ -410,6 +419,8 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userlevel,
         event_dispatch(get_default_waitset());
     }
 
+    DEBUG_QUEUE("bound \n");
+
     errval_t err2;
     struct capref regs;
     // Inform card driver about new queue and get the registers/queue id
@@ -448,6 +459,14 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, bool userlevel,
     queue->q.f.ctrl = sfn5122f_control;
     queue->q.f.notify = sfn5122f_notify;
     
+    
+    queue->event = malloc(sizeof(struct periodic_event));
+
+    err = periodic_event_create(queue->event, get_default_waitset(),
+                                DELAY, MKCLOSURE(cb, queue));
+    if (err_is_fail(err)) {
+        return err;
+    }
     *q = queue;
 
     return SYS_ERR_OK;
index e798776..ec92eba 100644 (file)
@@ -25,6 +25,7 @@
 struct sfn5122f_devif_binding;
 struct sfn5122f_devif_rpc_client;
 struct sfn5122f_queue;
+struct peridoc_event;
 
 struct sfn5122f_queue_ops {
     errval_t (*update_txtail)(struct sfn5122f_queue*, size_t);
@@ -72,7 +73,10 @@ struct sfn5122f_queue {
     // state for devif interface
     struct sfn5122f_devif_binding* b;
     struct sfn5122f_devif_rpc_client* rpc;
-    bool bound;
+    volatile bool bound;
+
+    // callback 
+    struct periodic_event* event;
 
     // Direct interface fields
     uint16_t id;
index 63194d0..a4beb84 100644 (file)
@@ -32,6 +32,9 @@ static struct frame_identity id;
 static lpaddr_t phys_rx;
 static lpaddr_t phys_tx;
 
+static volatile uint32_t num_tx = 0;
+static volatile uint32_t num_rx = 0;
+
 static void* va_rx;
 static void* va_tx;
 
@@ -71,6 +74,42 @@ static void print_buffer(size_t len, bufferid_t bid)
 */
 }
 
+static void sfn5122f_event_cb(void* queue)
+{
+    struct devq* q = (struct devq*) queue;
+
+    errval_t err;
+
+    regionid_t rid;
+    bufferid_t bid;
+    lpaddr_t addr;
+    size_t len;
+    uint64_t flags;
+
+    while (true) {    
+        err = devq_dequeue(q, &rid, &addr, &len, &bid, &flags);
+        if (err_is_fail(err)) {
+            break;
+        }
+
+        switch (flags) {
+            case DEVQ_BUF_FLAG_TX:
+                num_tx++;
+                printf("TX buf returnend \n");
+                break;
+            case DEVQ_BUF_FLAG_RX:
+                num_rx++;
+                print_buffer(len, bid);
+                break;
+            case DEVQ_BUF_FLAG_TX + DEVQ_BUF_FLAG_TX_LAST:
+                num_tx++;
+                printf("TX buf returnend \n");
+                break;
+            default:
+                printf("Unknown flags \n");
+        }    
+    }
+}
 
 static void test_sfn5122f_device_direct(void) 
 {
@@ -80,7 +119,7 @@ static void test_sfn5122f_device_direct(void)
     struct sfn5122f_queue* queue;
 
     printf("SFN5122F direct device test started \n");
-    err = sfn5122f_queue_create(&queue, true, false);
+    err = sfn5122f_queue_create(&queue, sfn5122f_event_cb, true, false);
     if (err_is_fail(err)){
         USER_PANIC("Allocating devq failed \n");
     }    
@@ -97,41 +136,27 @@ static void test_sfn5122f_device_direct(void)
     if (err_is_fail(err)){
         USER_PANIC("Registering memory to devq failed \n");
     }
-  
-    regionid_t rid;
-    bufferid_t ids[NUM_RX_BUF];
-    lpaddr_t addr;
-    size_t len;
-    uint64_t flags;
+    
+    lpaddr_t addr;  
+    bufferid_t bid;
 
     // Enqueue RX buffers to receive into
     for (int i = 0; i < NUM_ROUNDS; i++){
         addr = phys_rx+(i*2048);
         err = devq_enqueue(q, regid_rx, addr, 2048, 
-                           DEVQ_BUF_FLAG_RX, &ids[i]);
+                           DEVQ_BUF_FLAG_RX, &bid);
         if (err_is_fail(err)){
             USER_PANIC("Devq enqueue failed: %s\n", err_getstring(err));
         }    
 
-        // not necessary!
-        err = devq_notify(q);
-        if (err_is_fail(err)){
-            USER_PANIC("Devq notify failed: %s\n", err_getstring(err));
-        }    
-    }
-
-    // 32 Receives
-    for (int i = 0; i < NUM_ROUNDS; i++) {
-        err = devq_dequeue(q, &rid, &addr, &len, &ids[i], &flags);
-        if (err_is_fail(err)){
-            USER_PANIC("Devq dequeue failed \n");
-        } 
-        
-        if (flags == DEVQ_BUF_FLAG_RX) {
-            print_buffer(len, ids[i]);   
-        }  
     }
 
+    // not necessary NOP!
+    err = devq_notify(q);
+    if (err_is_fail(err)){
+        USER_PANIC("Devq notify failed: %s\n", err_getstring(err));
+    }   
     // Send something
     char* write = NULL;
     for (int i = 0; i < NUM_ROUNDS; i++) {
@@ -145,7 +170,7 @@ static void test_sfn5122f_device_direct(void)
         }
 
         err = devq_enqueue(q, regid_tx, addr, 2048, 
-                           DEVQ_BUF_FLAG_TX | DEVQ_BUF_FLAG_TX_LAST, &ids[i]);
+                           DEVQ_BUF_FLAG_TX | DEVQ_BUF_FLAG_TX_LAST, &bid);
         if (err_is_fail(err)){
             USER_PANIC("Devq enqueue failed \n");
         }    
@@ -157,15 +182,12 @@ static void test_sfn5122f_device_direct(void)
         }    
     }
 
-    uint16_t tx_bufs = 0;
-    while (tx_bufs < NUM_ROUNDS) {
-        err = devq_dequeue(q, &rid, &addr, &len, &ids[tx_bufs], &flags);
-        if (err_is_fail(err)){
-            USER_PANIC("Devq dequeue failed \n");
-        }    
-
-        if (flags & DEVQ_BUF_FLAG_TX ) {
-            tx_bufs++;
+    while (true) {
+        if ((num_tx < NUM_ROUNDS) || (num_rx < NUM_ROUNDS)) {
+            event_dispatch(get_default_waitset());
+        } else {
+            printf("exit event loop \n");
+            break;
         }
     }