enet: some cleanup
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Fri, 6 Mar 2020 12:44:21 +0000 (13:44 +0100)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Fri, 6 Mar 2020 12:44:21 +0000 (13:44 +0100)
This is now a basic example of ENET cleanQs receving something and
sending something

Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

usr/drivers/enet/enet_module.c

index a9e3c2d..e8f11dd 100644 (file)
@@ -41,275 +41,6 @@ static void some_sleep(uint64_t rep)
     }
 }
 
-/*
-static struct region_entry* get_region(struct enet_queue* q, regionid_t rid)
-{
-    struct region_entry* entry = q->regions;
-    while (entry != NULL) {
-        if (entry->rid == rid) {
-            return entry;
-        }
-        entry = entry->next;
-    }
-    return NULL;
-}
-
-static errval_t enet_register(struct devq* q, struct capref cap, regionid_t rid)
-{
-    errval_t err;
-    struct enet_queue* queue = (struct enet_queue*) q;
-
-    // keep track of regions since we need the virtual address ...
-    struct region_entry* entry = calloc(1, sizeof(struct region_entry));
-    assert(entry);
-    entry->rid = rid;
-    entry->next = NULL;
-    
-    struct frame_identity id;
-    err = frame_identify(cap, &id);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    void* va;
-    err = vspace_map_one_frame_attr(&va, id.bytes, cap,
-                                    VREGION_FLAGS_READ_WRITE,
-                                    NULL, NULL);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    entry->mem.devaddr = id.base;
-    entry->mem.vbase = (lvaddr_t) va;
-    entry->mem.mem = cap;
-    entry->mem.size = id.bytes;
-    
-    ENET_DEBUG("register region id %d base=%lx \n", rid, entry->mem.devaddr);
-    // linked list of regions
-    struct region_entry* cur = queue->regions;
-    if (cur == NULL) {
-        queue->regions = entry;
-        return SYS_ERR_OK;
-    }
-
-    while (cur->next != NULL) {
-        cur = cur->next;
-    }
-    
-    cur->next = entry;
-
-    ENET_DEBUG("registerd region id %d base=%p len=%ld \n", rid, 
-                (void*) entry->mem.vbase, entry->mem.size);
-    return SYS_ERR_OK;
-}
-
-static inline size_t enet_full_slots(struct enet_queue* q)
-{
-    size_t head = q->head;
-    size_t tail = q->tail;
-    size_t size = q->size;
-
-    if (tail >= head) {
-        return (tail - head);
-    } else {
-        return (tail + size - head);
-    }
-}
-
-static errval_t enet_rx_dequeue(struct devq* que, regionid_t* rid,
-                                genoffset_t* offset,
-                                genoffset_t* length,
-                                genoffset_t* valid_data,
-                                genoffset_t* valid_length,
-                                uint64_t* flags)
-{
-    struct enet_queue* q = (struct enet_queue*) que;      
-    enet_bufdesc_t desc = q->ring[q->head];
-    struct devq_buf* buf = &q->ring_bufs[q->head];
-
-    __builtin___clear_cache(desc, desc+sizeof(enet_bufdesc_t));
-
-    uint16_t status = enet_bufdesc_sc_extract(desc);
-
-    if (q->head == q->tail) {
-        return DEVQ_ERR_QUEUE_EMPTY;
-    }
-    if (!(status & ENET_RX_EMPTY)) {
-        // TODO error handling!
-        *valid_length = enet_bufdesc_len_extract(desc);
-        ENET_DEBUG("Received Packet len=%lu entry=%zu \n", *valid_length,
-                   q->head);
-        ENET_DEBUG("offset=%lu length=%lu valid_data=%lu rid=%lu \n",
-                   buf->offset, buf->length, 0, buf->rid);
-        *offset = buf->offset;
-        *valid_data = 0;
-        *length = 2048;
-        *rid = buf->rid;
-        *flags = buf->flags;
-    } else {
-        return DEVQ_ERR_QUEUE_EMPTY;
-    }
-    status &= ~ENET_RX_STATS;
-
-    __builtin___clear_cache(q->ring[q->head], q->ring[q->head+1]);    
-
-    enet_bufdesc_sc_insert(desc, status);
-    
-    q->head = (q->head+1) & (q->size -1);
-
-    return  SYS_ERR_OK;
-}
-
-static errval_t enet_tx_dequeue(struct devq* que, regionid_t* rid,
-                                genoffset_t* offset,
-                                genoffset_t* length,
-                                genoffset_t* valid_data,
-                                genoffset_t* valid_length,
-                                uint64_t* flags)
-{
-    struct enet_queue* q = (struct enet_queue*) que;      
-
-    if (enet_full_slots(q)) {
-        enet_bufdesc_t desc = q->ring[q->head];
-        __builtin___clear_cache(q->ring[q->head], q->ring[q->head+1]);
-        desc = q->ring[q->head];
-        struct devq_buf* buf= &q->ring_bufs[q->head];
-
-        if (!(enet_bufdesc_sc_extract(desc) & ENET_TX_READY)) {
-            ENET_DEBUG("We sent something!! \n");
-            *valid_length = buf->valid_length;
-            *offset = buf->offset;
-            *length = buf->length;
-            *valid_data = 0;
-            *rid = buf->rid;
-            *flags = buf->flags;
-        } else {
-            return DEVQ_ERR_QUEUE_EMPTY;
-        }
-    } else {
-        return DEVQ_ERR_QUEUE_EMPTY;
-    }
-
-    ENET_DEBUG("Deq TX head=%zu \n", q->head);
-    q->head = (q->head + 1) & (q->size -1);
-    return SYS_ERR_OK;
-}
-*/
-
-/*
-static void enet_activate_tx_ring(enet_t * d)
-{
-    ENET_DEBUG("Activating TX ring \n");
-    // bit is always set to 1 only when ring is empty then it is set to 0
-    enet_tdar_tdar_wrf(d, 1); 
-}
-*/
-/*
-static errval_t enet_tx_enqueue(struct devq* que, regionid_t rid, genoffset_t offset,
-                                genoffset_t length, genoffset_t valid_data,
-                                genoffset_t valid_length, uint64_t flags)
-{
-    
-    struct enet_queue* q = (struct enet_queue*) que;   
-
-    assert(valid_length > 0 && valid_length < ENET_MAX_PKT_SIZE);
-
-    if (enet_full_slots(q) == q->size) {
-        return DEVQ_ERR_QUEUE_FULL;
-    }
-
-    lpaddr_t addr = 0;
-    lvaddr_t vaddr = 0;
-    struct region_entry *entry = get_region(q, rid);
-    assert(entry);    
-    addr = (lpaddr_t) entry->mem.devaddr + offset + valid_data;
-    vaddr = (lvaddr_t) entry->mem.vbase + offset + valid_data;
-    
-    struct devq_buf* buf= &q->ring_bufs[q->tail];
-    buf->offset = offset;
-    buf->length = length;
-    buf->valid_length = valid_length;
-    buf->valid_data = valid_data;
-    buf->rid = rid;
-    buf->flags = flags;
-    // TODO alignment
-    
-    enet_bufdesc_t desc = q->ring[q->tail];
-    enet_bufdesc_addr_insert(desc, addr);
-    enet_bufdesc_len_insert(desc, valid_length);
-
-    __builtin___clear_cache((void*) vaddr, (void*) vaddr+valid_length);
-    __builtin___clear_cache(q->ring[q->tail], q->ring[q->tail+1]);
-
-    if (q->tail == (q->size -1)) {
-        enet_bufdesc_sc_insert(desc, ENET_TX_READY | ENET_TX_CRC | 
-                               ENET_TX_LAST | ENET_TX_WRAP);
-    } else {
-        enet_bufdesc_sc_insert(desc, ENET_TX_READY | ENET_TX_CRC | ENET_TX_LAST);
-    }
-
-    // activate TX
-    enet_activate_tx_ring(q->d);
-
-    // wait until sent
-    int timeout = 5000;
-    while(timeout--) {
-        if (!(enet_tdar_tdar_rdf(q->d))) {
-            break;
-        }
-    }
-
-    if (timeout == 0) {
-        debug_printf("Failed sending!! \n");
-        return NIC_ERR_TX_PKT;
-    } else {
-        q->tail = (q->tail + 1) & (q->size -1);
-    }
-
-    return SYS_ERR_OK;
-}
-static errval_t enet_rx_enqueue(struct devq* que, regionid_t rid, genoffset_t offset,
-                                genoffset_t length, genoffset_t valid_data,
-                                genoffset_t valid_length, uint64_t flags)
-{
-    struct enet_queue* q = (struct enet_queue*) que;   
-    //enet_bufdesc_addr_insert(desc, );
-    struct region_entry *entry = get_region(q, rid);
-    assert(entry);    
-    
-    assert(valid_length > 0 && length <= ENET_MAX_BUF_SIZE);
-
-    if (enet_full_slots(q) == q->size) {
-        return DEVQ_ERR_QUEUE_FULL;
-    }
-  
-    lpaddr_t addr = 0;
-    addr = (lpaddr_t) entry->mem.devaddr + offset;
-    struct devq_buf* buf= &q->ring_bufs[q->tail];
-    buf->offset = offset;
-    buf->length = length;
-    buf->valid_length = valid_length;
-    buf->valid_data = valid_data;
-    buf->rid = rid;
-    buf->flags = flags;
-   
-    enet_bufdesc_t desc = q->ring[q->tail];
-    enet_bufdesc_addr_insert(desc, addr);
-    enet_bufdesc_len_insert(desc, 0);
-
-    if (q->tail == (q->size -1)) {
-        enet_bufdesc_sc_insert(desc, ENET_SC_WRAP | ENET_RX_EMPTY);
-    } else {
-        enet_bufdesc_sc_insert(desc, ENET_RX_EMPTY);
-    }
-
-    __builtin___clear_cache(q->ring[q->tail], q->ring[q->tail+1]);
-    q->tail = (q->tail + 1) & (q->size -1);
-    return SYS_ERR_OK;
-}
-*/
 static errval_t enet_write_mdio(struct enet_driver_state* st, int8_t phyaddr,
                                 int8_t regaddr, int16_t data)
 {
@@ -689,14 +420,6 @@ static void enet_write_mac(struct enet_driver_state* st)
     enet_paur_paddr2_wrf(st->d, upper);
 }
 
-/*
-static void enet_activate_rx_ring(struct enet_driver_state* st)
-{
-    ENET_DEBUG("Activating RX ring \n");
-    // bit is always set to 1 only when ring is empty then it is set to 0
-    enet_rdar_rdar_wrf(st->d, 1); 
-}
-*/
 static errval_t enet_reset(struct enet_driver_state* st)
 {
     // reset device
@@ -738,82 +461,12 @@ static void enet_reg_setup(struct enet_driver_state* st)
     enet_rcr_wr(st->d, reg);   
 }
 
-/*
-static errval_t enet_rings_init(struct enet_driver_state* st)
-{
-    // init receive buffer descriptors
-    enet_bufdesc_t desc;
-    uint16_t val;
-
-    memset(st->txq->ring, 0, st->txq->size*sizeof(enet_bufdesc_t));
-    ENET_DEBUG("TX %p ring init to default values \n", st->txq->ring);
-    // init send buffer descriptors
-    for (int i = 0; i < st->txq->size; i++) {
-        desc = st->txq->ring[i];
-        enet_bufdesc_sc_insert(desc, 0);
-        enet_bufdesc_addr_insert(desc, 0);
-    }
-
-    // set last one to wrap
-    desc = st->txq->ring[st->txq->size - 1];
-    val = enet_bufdesc_sc_extract(desc);
-    val |= ENET_SC_WRAP;
-    enet_bufdesc_sc_insert(desc, val);
-
-    st->txq->head = 0;
-    st->txq->tail = 0;
-
-    // TODO dchace flush
-
-    memset(st->rxq->ring, 0, st->rxq->size*sizeof(enet_bufdesc_t));
-    ENET_DEBUG("RX %p ring init to default values \n", st->rxq->ring);
-    for (int i = 0; i < st->rxq->size; i++) {
-        desc = st->rxq->ring[i];
-        enet_bufdesc_sc_insert(desc, 0);
-    }
-
-    // set last one to wrap
-    desc = st->rxq->ring[st->rxq->size - 1];
-    val = enet_bufdesc_sc_extract(desc);
-    val |= ENET_SC_WRAP;
-    enet_bufdesc_sc_insert(desc, val);
-    st->rxq->head = 0;
-    st->rxq->tail = 0;
-    
-    // TODO dchace flush
-    return SYS_ERR_OK;
-}
-*/
-
 static errval_t enet_open(struct enet_driver_state *st)
 {
     errval_t err = SYS_ERR_OK;
     // Enable full duplex, disable heartbeet
     enet_tcr_fden_wrf(st->d, 0x1);
 
-    // Invalidate rx descriptors
-    /*
-    st->rxq->tail = 0;
-    err = frame_alloc(&st->rx_mem, 512*2048, NULL);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    regionid_t rid;
-    err = devq_register((struct devq*) st->rxq, st->rx_mem, &rid);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    for (int i = 0; i < st->rxq->size-1; i++) {
-        err = devq_enqueue((struct devq*) st->rxq, rid, i*(2048), 2048,
-                            0, 2048, 0);
-        if (err_is_fail(err)) {
-            return err;
-        }
-    }
-    */
-
     // Enable HW endian swap
     enet_ecr_dbswp_wrf(st->d, 0x1);
     enet_ecr_en1588_wrf(st->d, 0x0);
@@ -850,16 +503,6 @@ static errval_t enet_init(struct enet_driver_state* st)
     enet_galr_wr(st->d, 0);
     enet_write_mac(st);
 
-    /*
-
-    ENET_DEBUG("Setting RX/TX rings to default values \n");
-    // Init rings
-    err = enet_rings_init(st);
-    if (err_is_fail(err)){
-        return err;
-    }
-    */
-
     enet_reg_setup(st);
 
     uint64_t reg; 
@@ -931,79 +574,11 @@ static errval_t enet_probe(struct enet_driver_state* st)
     return SYS_ERR_OK;
 }
 
-/*
-static errval_t enet_alloc_queues(struct enet_driver_state* st)
-{   
-    errval_t err;
-    ENET_DEBUG("Allocating TX/RX ring data structures \n");
-    st->rxq = calloc(1, sizeof(struct enet_queue));
-    st->txq = calloc(1, sizeof(struct enet_queue));
-    st->rxq->size = RX_RING_SIZE;
-    st->txq->size = TX_RING_SIZE;
-    st->txq->d = st->d;
-    st->rxq->d = st->d;
-
-    assert(st->rxq);
-    assert(st->txq);
-
-    st->rxq->align = 0x3f;
-    st->txq->align = 0;
-
-    // TODO check for advanced descriptors
-    // TODO linking iommu driverkit library does not seem to work ...
-    ENET_DEBUG("Allocating RX/TX descriptor ring \n");
-    size_t tot_size = (st->rxq->size + st->txq->size)*sizeof(enet_bufdesc_t);
-    err = frame_alloc(&(st->rxq->desc_mem.mem), tot_size, (size_t *)&(st->rxq->desc_mem.size));
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    ENET_DEBUG("Mapping RX/TX descriptor ring\n");
-    err = vspace_map_one_frame_attr((void**) &(st->rxq->desc_mem.vbase), tot_size, 
-                                    st->rxq->desc_mem.mem, 
-                                    VREGION_FLAGS_READ_WRITE_NOCACHE, NULL, NULL);
-    if (err_is_fail(err)) {
-        cap_destroy(st->rxq->desc_mem.mem);
-        DEBUG_ERR(err, "vspace_map_one_frame failed");
-        return err;
-    }
-
-    struct frame_identity id;
-    err = frame_identify(st->rxq->desc_mem.mem, &id);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    st->rxq->desc_mem.devaddr = id.base;
-
-    st->rxq->ring = (void*) st->rxq->desc_mem.vbase;
-    assert(st->rxq->ring);
-    assert((st->rxq->desc_mem.devaddr & st->rxq->align) == 0);
-
-    memset(st->rxq->ring, 0, st->rxq->size*sizeof(enet_bufdesc_t));
-
-    st->txq->desc_mem.vbase = (st->rxq->desc_mem.vbase + (st->rxq->size*sizeof(enet_bufdesc_t)));
-    st->txq->desc_mem.devaddr = (st->rxq->desc_mem.devaddr + (st->rxq->size*sizeof(enet_bufdesc_t)));
-    st->txq->ring = (void*) st->txq->desc_mem.vbase;
-    st->txq->desc_mem.size = st->rxq->desc_mem.size;
-
-    assert(st->txq->ring);
-    assert((st->txq->desc_mem.devaddr & st->txq->align) == 0);
-
-    memset(st->txq->ring, 0, st->txq->size*sizeof(enet_bufdesc_t));
-    ENET_DEBUG("RX phys=%p virt=%p \n", (void*) st->rxq->desc_mem.devaddr,
-                (void*) st->rxq->ring);
-    ENET_DEBUG("TX phys=%p virt=%p \n", (void*) st->txq->desc_mem.devaddr,
-                (void*) st->txq->ring);
-
-    return SYS_ERR_OK;
-}
-*/
-uint16_t packet[21] = { 0xffff, 0xffff, 0xffff, 0x507b,
-                        0x9d2b, 0x1cbe, 0x0806, 0x0001,
-                        0x0800, 0x0604, 0x0001, 0x507b,
-                        0x9d2b, 0x1cbe, 0x0a05, 0x29d6,
-                        0x0000, 0x0000, 0x0000, 0x0a6e,
+uint16_t packet[21] = { 0xffff, 0xffff, 0xffff, 0x7b50,
+                        0x2b9d, 0xbe1c, 0x0608, 0x0100,
+                        0x0008, 0x0406, 0x0100, 0x7b50,
+                        0x2b9d, 0xbe1c, 0x050a, 0xd629,
+                        0x0000, 0x0000, 0x0000, 0x6e0a,
                         0x0404};
 /*
 static void print_tx_stats(struct enet_driver_state* st)