uknetdev

#include <uk/netdev.h>

// 1. Get device reference
struct uk_netdev *dev = uk_netdev_get(0);

// 2. Probe the device
int ret = uk_netdev_probe(dev);
if (ret < 0)
    return ret;

// 3. Query device capabilities
struct uk_netdev_info info;
uk_netdev_info_get(dev, &info);

// 4. Configure device
struct uk_netdev_conf conf = {
    .nb_rx_queues = 1,
    .nb_tx_queues = 1
};
ret = uk_netdev_configure(dev, &conf);

// 5. Configure RX queue
struct uk_netdev_rxqueue_conf rxconf = {
    .a = allocator,
    .alloc_rxpkts = my_alloc_pkts,
    .callback = rx_callback,
};
ret = uk_netdev_rxq_configure(dev, 0, 256, &rxconf);

// 6. Configure TX queue
struct uk_netdev_txqueue_conf txconf = {
    .a = allocator
};
ret = uk_netdev_txq_configure(dev, 0, 256, &txconf);

// 7. Start the device
ret = uk_netdev_start(dev);

unsigned int uk_netdev_count(void);

struct uk_netdev *uk_netdev_get(unsigned int id);

int uk_netdev_probe(struct uk_netdev *dev);

int uk_netdev_configure(struct uk_netdev *dev,
                        const struct uk_netdev_conf *dev_conf);

int uk_netdev_start(struct uk_netdev *dev);

int uk_netdev_rxq_configure(struct uk_netdev *dev, uint16_t queue_id,
                            uint16_t nb_desc,
                            struct uk_netdev_rxqueue_conf *rx_conf);

int uk_netdev_txq_configure(struct uk_netdev *dev, uint16_t queue_id,
                            uint16_t nb_desc,
                            struct uk_netdev_txqueue_conf *tx_conf);

static inline int uk_netdev_rx_one(struct uk_netdev *dev, uint16_t queue_id,
                                   struct uk_netbuf **pkt);

struct uk_netbuf *pkt;
int status;

status = uk_netdev_rx_one(dev, queue_id, &pkt);
if (uk_netdev_status_successful(status)) {
    // Process packet
    process_packet(pkt);
    
    if (uk_netdev_status_more(status)) {
        // More packets available, continue receiving
    }
}

static inline int uk_netdev_tx_one(struct uk_netdev *dev, uint16_t queue_id,
                                   struct uk_netbuf *pkt);

const struct uk_hwaddr *uk_netdev_hwaddr_get(struct uk_netdev *dev);

uint16_t uk_netdev_mtu_get(struct uk_netdev *dev);
int uk_netdev_mtu_set(struct uk_netdev *dev, uint16_t mtu);

unsigned uk_netdev_promiscuous_get(struct uk_netdev *dev);
int uk_netdev_promiscuous_set(struct uk_netdev *dev, unsigned mode);

static inline int uk_netdev_rxq_intr_enable(struct uk_netdev *dev,
                                            uint16_t queue_id);
static inline int uk_netdev_rxq_intr_disable(struct uk_netdev *dev,
                                             uint16_t queue_id);

*buf -> +----------------------+
        |      HEAD ROOM       |
*data -> +----------------------+
        |     PACKET DATA      |
        |       (len bytes)    |
        +----------------------+
        |      TAIL ROOM       |
        +----------------------+ <- *buf + buflen

struct uk_netbuf *uk_netbuf_alloc_buf(struct uk_alloc *a, size_t buflen,
                                      size_t bufalign, uint16_t headroom,
                                      size_t privlen, uk_netbuf_dtor_t dtor);

static inline int uk_netbuf_header(struct uk_netbuf *head, int16_t len);

static inline size_t uk_netbuf_headroom(struct uk_netbuf *m);
static inline size_t uk_netbuf_tailroom(struct uk_netbuf *m);

void uk_netbuf_connect(struct uk_netbuf *headtail,
                       struct uk_netbuf *tail);
struct uk_netbuf *uk_netbuf_disconnect(struct uk_netbuf *m);

int uk_netdev_drv_register(struct uk_netdev *dev, struct uk_alloc *a,
                           const char *drv_name);

static inline void uk_netdev_drv_rx_event(struct uk_netdev *dev,
                                          uint16_t queue_id);

#include <uk/netdev.h>
#include <uk/netbuf.h>

static uint16_t alloc_rxpkts(void *argp, struct uk_netbuf *pkts[],
                             uint16_t count)
{
    struct uk_alloc *a = argp;
    uint16_t i;
    
    for (i = 0; i < count; i++) {
        pkts[i] = uk_netbuf_alloc_buf(a, 2048, 64, 0, 0, NULL);
        if (!pkts[i])
            break;
    }
    return i;
}

static void rx_callback(struct uk_netdev *dev, uint16_t queue_id,
                       void *argp)
{
    struct uk_netbuf *pkt;
    int status;
    
    // Receive all available packets
    do {
        status = uk_netdev_rx_one(dev, queue_id, &pkt);
        if (uk_netdev_status_successful(status)) {
            // Process packet
            uk_pr_info("Received packet: %u bytes\n", pkt->len);
            uk_netbuf_free(pkt);
        }
    } while (uk_netdev_status_more(status));
}

int setup_network(struct uk_alloc *a)
{
    struct uk_netdev *dev;
    struct uk_netdev_conf conf;
    struct uk_netdev_rxqueue_conf rxconf;
    struct uk_netdev_txqueue_conf txconf;
    int ret;
    
    // Get first network device
    if (uk_netdev_count() == 0)
        return -ENODEV;
    
    dev = uk_netdev_get(0);
    
    // Probe and configure
    ret = uk_netdev_probe(dev);
    if (ret < 0)
        return ret;
    
    conf.nb_rx_queues = 1;
    conf.nb_tx_queues = 1;
    ret = uk_netdev_configure(dev, &conf);
    if (ret < 0)
        return ret;
    
    // Setup RX queue
    rxconf.a = a;
    rxconf.alloc_rxpkts = alloc_rxpkts;
    rxconf.alloc_rxpkts_argp = a;
    rxconf.callback = rx_callback;
    rxconf.callback_cookie = NULL;
    
    ret = uk_netdev_rxq_configure(dev, 0, 256, &rxconf);
    if (ret < 0)
        return ret;
    
    // Setup TX queue
    txconf.a = a;
    ret = uk_netdev_txq_configure(dev, 0, 256, &txconf);
    if (ret < 0)
        return ret;
    
    // Start device
    ret = uk_netdev_start(dev);
    if (ret < 0)
        return ret;
    
    // Enable interrupts
    uk_netdev_rxq_intr_enable(dev, 0);
    
    return 0;
}