libnet: libnet now uses queue creation library
[barrelfish] / lib / net / net_queue.c
1 /*
2  * Copyright (c) 2017, 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, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
8  */
9
10 #include <barrelfish/barrelfish.h>
11 #include <net/net_queue.h>
12 #include "networking_internal.h"
13 #include "net_queue_internal.h"
14
15 static errval_t create_loopback_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
16                                       bool default_q, bool poll, struct devq **retqueue)
17 {
18     errval_t err;
19
20     debug_printf("net: creating loopback queue.\n");
21
22     *queueid = 0;
23     err = loopback_queue_create((struct loopback_queue **)retqueue);
24     if (err_is_fail(err)) {
25         return err;
26     }
27
28     return SYS_ERR_OK;
29 }
30
31 static errval_t create_driver_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
32                                     bool default_q, bool poll, struct devq **retqueue)
33 {
34     *queueid = 0;
35     return SYS_ERR_OK;
36 }
37
38 // cardname - "e1000:vendor:deviceid:bus:device:function"
39 static errval_t create_e1000_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
40                                    bool default_q, bool poll, struct devq **retqueue)
41 {
42     if (cardname[5] != ':') {
43         return SYS_ERR_OK;
44     }
45     uint32_t vendor, deviceid, bus, device, function;
46     unsigned parsed = sscanf(cardname + 6, "%x:%x:%x:%x:%x", &vendor,
47                              &deviceid, &bus, &device, &function);
48     if (parsed != 5) {
49         return SYS_ERR_OK;
50     }
51     return e1000_queue_create((struct e1000_queue**)retqueue, vendor, deviceid,
52                               bus, device, function, 1, interrupt);
53 }
54
55 static errval_t create_e10k_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
56                                   bool default_q, bool poll, struct devq **retqueue)
57 {
58     errval_t err;
59     err = e10k_queue_create((struct e10k_queue**)retqueue, interrupt,
60                             false /*virtual functions*/,
61                             poll, /* user interrupts*/
62                             default_q);
63     *queueid = e10k_queue_get_id((struct e10k_queue*)*retqueue);
64     assert(retqueue != NULL);
65     return err;
66 }
67
68 static errval_t create_sfn5122f_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
69                                       bool default_q, bool poll, struct devq **retqueue)
70 {
71     errval_t err;
72     err = sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, interrupt,
73                                 false /*userlevel network feature*/,
74                                 poll /* user interrupts*/,
75                                 default_q);
76     *queueid = sfn5122f_queue_get_id((struct sfn5122f_queue*)*retqueue);
77     return err;
78 }
79
80
81 typedef errval_t (*queue_create_fn)(const char*, inthandler_t, uint64_t*, bool, bool, struct devq **);
82 struct networking_card
83 {
84     char *cardname;
85     queue_create_fn createfn;
86 } networking_cards [] = {
87     { "loopback", create_loopback_queue},
88     { "driver", create_driver_queue},
89     { "e1000", create_e1000_queue},
90     { "e10k", create_e10k_queue},
91     { "sfn5122f", create_sfn5122f_queue},
92     { NULL, NULL}
93 };
94
95
96 /**
97  * @brief creates a queue to the given card and the queueid
98  *
99  * @param interrupt interrupt handler 
100  * @param cardname  network card to create the queue for
101  * @param queueid   queueid of the network card
102  * @param default_q get the default queue (most of the time queue 0)
103  * @param poll      Is the queue polled or are interrupts used
104  * @param retqueue  returns the pointer to the queue
105  *
106  * @return SYS_ERR_OK on success, errval on failure
107  */
108 errval_t net_queue_internal_create(inthandler_t interrupt, const char *cardname,
109                                    uint64_t* queueid, bool default_q, bool poll, struct devq **retqueue)
110 {
111     struct networking_card *nc = networking_cards;
112     while(nc->cardname != NULL) {
113         if (strncmp(cardname, nc->cardname, strlen(nc->cardname)) == 0) {
114             return nc->createfn(cardname, interrupt, queueid, default_q, 
115                                 poll, retqueue);
116         }
117         nc++;
118     }
119
120     debug_printf("net: ERROR unknown queue. card='%s', queueid=%" PRIu64 "\n",
121                   cardname, *queueid);
122
123     return -1;
124 }
125
126
127 /**
128  * @brief creates a queue to the given card and the queueid
129  *
130  * @param interrupt interrupt handler 
131  * @param cardname  network card to create the queue for
132  * @param queueid   queueid of the network card
133  * @param poll      Is the queue polled or are interrupts used
134  * @param retqueue  returns the pointer to the queue
135  *
136  * @return SYS_ERR_OK on success, errval on failure
137  */
138 errval_t net_queue_create(inthandler_t interrupt, const char *cardname,
139                           uint64_t* queueid, bool poll, struct devq **retqueue)
140 {
141     return net_queue_internal_create(interrupt, cardname, queueid, false, poll, retqueue);
142 }